2186 lines
89 KiB
Python
2186 lines
89 KiB
Python
import datetime,random,math
|
|
from collections import Counter
|
|
import colors,log,trade,variables
|
|
|
|
def dupes(mass=True,nonmass=True,characters=True,specials=True):
|
|
dupeslist = []
|
|
previouscard = ""
|
|
for card in colors.cardlist:
|
|
try:
|
|
if card["colour"] != "sig" and card ["colour"] != "limited":
|
|
if card["name"] == previouscard["name"]:
|
|
dupe = {}
|
|
dupe["name"] = card["name"]
|
|
if len(card["mass"]) > 0:
|
|
if mass:
|
|
dupe["mass"] = card["mass"]
|
|
if card["colour"] == "special":
|
|
if specials:
|
|
dupeslist.append(dupe)
|
|
else:
|
|
if characters:
|
|
dupeslist.append(dupe)
|
|
else:
|
|
if nonmass:
|
|
if card["colour"] == "special":
|
|
if specials:
|
|
dupeslist.append(dupe)
|
|
else:
|
|
if characters:
|
|
dupeslist.append(dupe)
|
|
except:
|
|
pass
|
|
previouscard = card
|
|
return dupeslist
|
|
|
|
def activitydupes():
|
|
print(dupes(False,True,True,False))
|
|
|
|
def nextportfolio(monochrome=False):
|
|
goodtogo = True
|
|
useddecks = {}
|
|
already = 0
|
|
if monochrome:
|
|
for portfolio in colors.portfolios:
|
|
if portfolio["type"] == "monochrome":
|
|
already += 1
|
|
useddecks.update(portfolio["decks"])
|
|
else:
|
|
for portfolio in colors.portfolios:
|
|
if portfolio["type"] == "palette":
|
|
already += 1
|
|
useddecks.update(portfolio["decks"])
|
|
potentials = []
|
|
for deck in colors.decklist:
|
|
if deck["mastered"]:
|
|
if deck["colour"] != "special" and deck["colour"] != "limited":
|
|
potential = True
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
potential = False
|
|
if potential:
|
|
potentials.append(deck)
|
|
potentials = sorted(potentials, key=lambda d: d["mastered"])
|
|
if monochrome:
|
|
reddecks = []
|
|
orangedecks = []
|
|
yellowdecks = []
|
|
greendecks = []
|
|
bluedecks = []
|
|
purpledecks = []
|
|
browndecks = []
|
|
greydecks = []
|
|
for deck in potentials:
|
|
if deck["colour"] == "red":
|
|
reddecks.append(deck)
|
|
elif deck["colour"] == "orange":
|
|
orangedecks.append(deck)
|
|
elif deck["colour"] == "yellow":
|
|
yellowdecks.append(deck)
|
|
elif deck["colour"] == "green":
|
|
greendecks.append(deck)
|
|
elif deck["colour"] == "blue":
|
|
bluedecks.append(deck)
|
|
elif deck["colour"] == "purple":
|
|
purpledecks.append(deck)
|
|
elif deck["colour"] == "brown":
|
|
browndecks.append(deck)
|
|
elif deck["colour"] == "gray":
|
|
greydecks.append(deck)
|
|
longestvalue = len(reddecks)
|
|
nextportcolour = "red"
|
|
if len(orangedecks) > longestvalue:
|
|
nextportcolour = "orange"
|
|
if len(yellowdecks) > longestvalue:
|
|
nextportcolour = "yellow"
|
|
if len(greendecks) > longestvalue:
|
|
nextportcolour = "green"
|
|
if len(bluedecks) > longestvalue:
|
|
nextportcolour = "blue"
|
|
if len(purpledecks) > longestvalue:
|
|
nextportcolour = "purple"
|
|
if len(browndecks) > longestvalue:
|
|
nextportcolour = "brown"
|
|
if len(greydecks) > longestvalue:
|
|
nextportcolour = "grey"
|
|
firstthree = []
|
|
if nextportcolour == "red":
|
|
try:
|
|
firstthree.append(reddecks[0]["name"])
|
|
firstthree.append(reddecks[1]["name"])
|
|
firstthree.append(reddecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
elif nextportcolour == "orange":
|
|
try:
|
|
firstthree.append(orangedecks[0]["name"])
|
|
firstthree.append(orangedecks[1]["name"])
|
|
firstthree.append(orangedecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
elif nextportcolour == "yellow":
|
|
try:
|
|
firstthree.append(yellowdecks[0]["name"])
|
|
firstthree.append(yellowdecks[1]["name"])
|
|
firstthree.append(yellowdecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
elif nextportcolour == "green":
|
|
try:
|
|
firstthree.append(greendecks[0]["name"])
|
|
firstthree.append(greendecks[1]["name"])
|
|
firstthree.append(greendecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
elif nextportcolour == "blue":
|
|
try:
|
|
firstthree.append(bluedecks[0]["name"])
|
|
firstthree.append(bluedecks[1]["name"])
|
|
firstthree.append(bluedecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
elif nextportcolour == "purple":
|
|
try:
|
|
firstthree.append(purpledecks[0]["name"])
|
|
firstthree.append(purpledecks[1]["name"])
|
|
firstthree.append(purpledecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
elif nextportcolour == "brown":
|
|
try:
|
|
firstthree.append(browndecks[0]["name"])
|
|
firstthree.append(browndecks[1]["name"])
|
|
firstthree.append(browndecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
elif nextportcolour == "grey":
|
|
try:
|
|
firstthree.append(greydecks[0]["name"])
|
|
firstthree.append(greydecks[1]["name"])
|
|
firstthree.append(greydecks[2]["name"])
|
|
except:
|
|
goodtogo = False
|
|
if goodtogo:
|
|
secondfive = []
|
|
nearingdecks = sorted(colors.decklist, key=lambda d: d["count"],reverse=True)
|
|
slots = 5
|
|
for deck in nearingdecks:
|
|
if slots > 0:
|
|
try:
|
|
if not deck["mastered"]:
|
|
if nextportcolour == "grey":
|
|
if deck["colour"] == "gray":
|
|
secondfive.append(deck["name"])
|
|
slots -= 1
|
|
else:
|
|
if deck["colour"] == nextportcolour:
|
|
secondfive.append(deck["name"])
|
|
slots -= 1
|
|
except:
|
|
goodtogo = False
|
|
if goodtogo:
|
|
alleight = sorted(firstthree + secondfive)
|
|
else:
|
|
thereddeck = False
|
|
redmastered = False
|
|
theorangedeck = False
|
|
orangemastered = False
|
|
theyellowdeck = False
|
|
yellowmastered = False
|
|
thegreendeck = False
|
|
greenmastered = False
|
|
thebluedeck = False
|
|
bluemastered = False
|
|
thepurpledeck = False
|
|
purplemastered = False
|
|
thebrowndeck = False
|
|
brownmastered = False
|
|
thegreydeck = False
|
|
greymastered = False
|
|
sorteddecks = 0
|
|
for deck in potentials:
|
|
if sorteddecks < 3:
|
|
if deck["colour"] == "red" and thereddeck == False:
|
|
thereddeck = deck["name"]
|
|
redmastered = True
|
|
sorteddecks += 1
|
|
elif deck["colour"] == "orange" and theorangedeck == False:
|
|
theorangedeck = deck["name"]
|
|
orangemastered = True
|
|
sorteddecks += 1
|
|
elif deck["colour"] == "yellow" and theyellowdeck == False:
|
|
theyellowdeck = deck["name"]
|
|
yellowmastered = True
|
|
sorteddecks += 1
|
|
elif deck["colour"] == "green" and thegreendeck == False:
|
|
thegreendeck = deck["name"]
|
|
greenmastered = True
|
|
sorteddecks += 1
|
|
elif deck["colour"] == "blue" and thebluedeck == False:
|
|
thebluedeck = deck["name"]
|
|
bluemastered = True
|
|
sorteddecks += 1
|
|
elif deck["colour"] == "purple" and thepurpledeck == False:
|
|
thepurpledeck = deck["name"]
|
|
purplemastered = True
|
|
sorteddecks += 1
|
|
elif deck["colour"] == "brown" and thebrowndeck == False:
|
|
thebrowndeck = deck["name"]
|
|
brownmastered = True
|
|
sorteddecks += 1
|
|
elif deck["colour"] == "gray" and thegreydeck == False:
|
|
thegreydeck = deck["name"]
|
|
greymastered = True
|
|
sorteddecks += 1
|
|
nearingdecks = sorted(colors.decklist, key=lambda d: d["count"],reverse=True)
|
|
if thereddeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if thereddeck == False:
|
|
if deck["colour"] == "red":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
thereddeck = deck["name"]
|
|
if theorangedeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if theorangedeck == False:
|
|
if deck["colour"] == "orange":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
theorangedeck = deck["name"]
|
|
if theyellowdeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if theyellowdeck == False:
|
|
if deck["colour"] == "yellow":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
theyellowdeck = deck["name"]
|
|
if thegreendeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if thegreendeck == False:
|
|
if deck["colour"] == "green":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
thegreendeck = deck["name"]
|
|
if thebluedeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if thebluedeck == False:
|
|
if deck["colour"] == "blue":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
thebluedeck = deck["name"]
|
|
if thepurpledeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if thepurpledeck == False:
|
|
if deck["colour"] == "purple":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
thepurpledeck = deck["name"]
|
|
if thebrowndeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if thebrowndeck == False:
|
|
if deck["colour"] == "brown":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
thebrowndeck = deck["name"]
|
|
if thegreydeck == False:
|
|
for deck in nearingdecks:
|
|
if not deck["mastered"]:
|
|
if thegreydeck == False:
|
|
if deck["colour"] == "gray":
|
|
used = False
|
|
for key, value in useddecks.items():
|
|
if deck["name"] == key.replace(" ",""):
|
|
used = True
|
|
if used == False:
|
|
thegreydeck = deck["name"]
|
|
alleight = []
|
|
alleight.append(thereddeck)
|
|
alleight.append(theorangedeck)
|
|
alleight.append(theyellowdeck)
|
|
alleight.append(thegreendeck)
|
|
alleight.append(thebluedeck)
|
|
alleight.append(thepurpledeck)
|
|
alleight.append(thebrowndeck)
|
|
alleight.append(thegreydeck)
|
|
if goodtogo:
|
|
portcomment = "♥ <b>Your Name:</b> " + variables.name + "\n♥ <b>Card post:</b> " + variables.url + "\n♥ <b>"
|
|
if monochrome:
|
|
portcomment += "Monochrome"
|
|
else:
|
|
portcomment += "Palette"
|
|
portcomment += " Portfolio #:</b> " + str(already + 1) + "\n"
|
|
if monochrome:
|
|
portcomment += "♥ <b>Monochrome Color:</b> "
|
|
if nextportcolour == "grey":
|
|
if variables.british:
|
|
portcomment += "grey"
|
|
else:
|
|
portcomment += "gray"
|
|
else:
|
|
portcomment += nextportcolour
|
|
portcomment += "\n♥ <b>1st deck:</b> " + alleight[0]
|
|
if alleight[0] in firstthree:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>2nd deck:</b> " + alleight[1]
|
|
if alleight[1] in firstthree:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>3rd deck:</b> " + alleight[2]
|
|
if alleight[2] in firstthree:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>4th deck:</b> " + alleight[3]
|
|
if alleight[3] in firstthree:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>5th deck:</b> " + alleight[4]
|
|
if alleight[4] in firstthree:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>6th deck:</b> " + alleight[5]
|
|
if alleight[5] in firstthree:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>7th deck:</b> " + alleight[6]
|
|
if alleight[6] in firstthree:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>8th deck:</b> " + alleight[7]
|
|
if alleight[7] in firstthree:
|
|
portcomment += " (mastered)"
|
|
else:
|
|
try:
|
|
portcomment += "♥ <b>Red deck:</b> " + thereddeck
|
|
if redmastered:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>Orange deck:</b> " + theorangedeck
|
|
if orangemastered:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>Yellow deck:</b> " + theyellowdeck
|
|
if yellowmastered:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>Green deck:</b> " + thegreendeck
|
|
if greenmastered:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>Blue deck:</b> " + thebluedeck
|
|
if bluemastered:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>Purple deck:</b> " + thepurpledeck
|
|
if purplemastered:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>Brown deck:</b> " + thebrowndeck
|
|
if brownmastered:
|
|
portcomment += " (mastered)"
|
|
portcomment += "\n♥ <b>Gray deck:</b> " + thegreydeck
|
|
if greymastered:
|
|
portcomment += " (mastered)"
|
|
except:
|
|
goodtogo = False
|
|
if goodtogo:
|
|
print(portcomment)
|
|
porturl = input("\nPaste the comment URL here: ")
|
|
print("\n{\"event\":\"portfolio\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + porturl + "\",\"decks\":[\"" + alleight[0] + "\",\"" + alleight[1] + "\",\"" + alleight[2] + "\",\"" + alleight[3] + "\",\"" + alleight[4] + "\",\"" + alleight[5] + "\",\"" + alleight[6] + "\",\"" + alleight[7] + "\"]}")
|
|
else:
|
|
print("Master some more decks first")
|
|
|
|
def switchit():
|
|
wantedbypriority = sorted(colors.wantedlist, key=lambda d: d["priority"])
|
|
redtrade = []
|
|
orangetrade = []
|
|
yellowtrade = []
|
|
greentrade = []
|
|
bluetrade = []
|
|
purpletrade = []
|
|
browntrade = []
|
|
greytrade = []
|
|
for card in colors.cardlist:
|
|
if card["priority"] == 4:
|
|
if card["colour"] == "red":
|
|
redtrade.append(card["name"])
|
|
elif card["colour"] == "orange":
|
|
orangetrade.append(card["name"])
|
|
elif card["colour"] == "yellow":
|
|
yellowtrade.append(card["name"])
|
|
elif card["colour"] == "green":
|
|
greentrade.append(card["name"])
|
|
elif card["colour"] == "blue":
|
|
bluetrade.append(card["name"])
|
|
elif card["colour"] == "purple":
|
|
purpletrade.append(card["name"])
|
|
elif card["colour"] == "brown":
|
|
browntrade.append(card["name"])
|
|
elif card["colour"] == "gray":
|
|
greytrade.append(card["name"])
|
|
wantednames = []
|
|
for card in wantedbypriority:
|
|
wantednames.append(card["name"])
|
|
wantall = []
|
|
tradeall = []
|
|
reds = input("Paste red pile here: ").split(", ")
|
|
oranges = input("Paste orange pile here: ").split(", ")
|
|
yellows = input("Paste yellow pile here: ").split(", ")
|
|
greens = input("Paste green pile here: ").split(", ")
|
|
blues = input("Paste blue pile here: ").split(", ")
|
|
purples = input("Paste purple pile here: ").split(", ")
|
|
browns = input("Paste brown pile here: ").split(", ")
|
|
greys = input("Paste grey pile here: ").split(", ")
|
|
chaos = input("Paste chaos pile here: ").split(", ")
|
|
taken = input("Cards to remove: ").split(", ")
|
|
for card in taken:
|
|
if card in reds:
|
|
reds.remove(card)
|
|
elif card in oranges:
|
|
oranges.remove(card)
|
|
elif card in yellows:
|
|
yellows.remove(card)
|
|
elif card in greens:
|
|
greens.remove(card)
|
|
elif card in blues:
|
|
blues.remove(card)
|
|
elif card in purples:
|
|
purples.remove(card)
|
|
elif card in browns:
|
|
browns.remove(card)
|
|
elif card in greys:
|
|
greys.remove(card)
|
|
elif card in chaos:
|
|
chaos.remove(card)
|
|
wantreds = []
|
|
for card in reds:
|
|
if card in wantednames:
|
|
wantreds.append(card)
|
|
if len(wantreds) > 5:
|
|
wantreds = wantreds[:5]
|
|
if len(wantreds) > len(redtrade):
|
|
wantreds = wantreds[:len(redtrade)]
|
|
if len(wantreds) > 0:
|
|
wantall.extend(wantreds)
|
|
traderedscount = len(wantreds)
|
|
tradereds = []
|
|
tradereds.extend(random.sample(redtrade,len(wantreds)))
|
|
tradeall.extend(tradereds)
|
|
wantoranges = []
|
|
for card in oranges:
|
|
if card in wantednames:
|
|
wantoranges.append(card)
|
|
if len(wantoranges) > 5:
|
|
wantoranges = wantoranges[:5]
|
|
if len(wantoranges) > len(orangetrade):
|
|
wantoranges = wantoranges[:len(orangetrade)]
|
|
if len(wantoranges) > 0:
|
|
wantall.extend(wantoranges)
|
|
tradeorangescount = len(wantoranges)
|
|
tradeoranges = []
|
|
tradeoranges.extend(random.sample(orangetrade,len(wantoranges)))
|
|
tradeall.extend(tradeoranges)
|
|
wantyellows = []
|
|
for card in yellows:
|
|
if card in wantednames:
|
|
wantyellows.append(card)
|
|
if len(wantyellows) > 5:
|
|
wantyellows = wantyellows[:5]
|
|
if len(wantyellows) > len(yellowtrade):
|
|
wantyellows = wantyellows[:len(yellowtrade)]
|
|
if len(wantyellows) > 0:
|
|
wantall.extend(wantyellows)
|
|
tradeyellowscount = len(wantyellows)
|
|
tradeyellows = []
|
|
tradeyellows.extend(random.sample(yellowtrade,len(wantyellows)))
|
|
tradeall.extend(tradeyellows)
|
|
wantgreens = []
|
|
for card in greens:
|
|
if card in wantednames:
|
|
wantgreens.append(card)
|
|
if len(wantgreens) > 5:
|
|
wantgreens = wantgreens[:5]
|
|
if len(wantgreens) > len(greentrade):
|
|
wantgreens = wantgreens[:len(greentrade)]
|
|
if len(wantgreens) > 0:
|
|
wantall.extend(wantgreens)
|
|
tradegreenscount = len(wantgreens)
|
|
tradegreens = []
|
|
tradegreens.extend(random.sample(greentrade,len(wantgreens)))
|
|
tradeall.extend(tradegreens)
|
|
wantblues = []
|
|
for card in blues:
|
|
if card in wantednames:
|
|
wantblues.append(card)
|
|
if len(wantblues) > 5:
|
|
wantblues = wantblues[:5]
|
|
if len(wantblues) > len(bluetrade):
|
|
wantblues = wantblues[:len(bluetrade)]
|
|
if len(wantblues) > 0:
|
|
wantall.extend(wantblues)
|
|
tradebluescount = len(wantblues)
|
|
tradeblues = []
|
|
tradeblues.extend(random.sample(bluetrade,len(wantblues)))
|
|
tradeall.extend(tradeblues)
|
|
wantpurples = []
|
|
for card in purples:
|
|
if card in wantednames:
|
|
wantpurples.append(card)
|
|
if len(wantpurples) > 5:
|
|
wantpurples = wantpurples[:5]
|
|
if len(wantpurples) > len(purpletrade):
|
|
wantpurples = wantpurples[:len(purpletrade)]
|
|
if len(wantpurples) > 0:
|
|
wantall.extend(wantpurples)
|
|
tradepurplescount = len(wantpurples)
|
|
tradepurples = []
|
|
tradepurples.extend(random.sample(purpletrade,len(wantpurples)))
|
|
tradeall.extend(tradepurples)
|
|
wantbrowns = []
|
|
for card in browns:
|
|
if card in wantednames:
|
|
wantbrowns.append(card)
|
|
if len(wantbrowns) > 5:
|
|
wantbrowns = wantbrowns[:5]
|
|
if len(wantbrowns) > len(browntrade):
|
|
wantbrowns = wantbrowns[:len(browntrade)]
|
|
if len(wantbrowns) > 0:
|
|
wantall.extend(wantbrowns)
|
|
tradebrownscount = len(wantbrowns)
|
|
tradebrowns = []
|
|
tradebrowns.extend(random.sample(browntrade,len(wantbrowns)))
|
|
tradeall.extend(tradebrowns)
|
|
wantgreys = []
|
|
for card in greys:
|
|
if card in wantednames:
|
|
wantgreys.append(card)
|
|
if len(wantgreys) > 5:
|
|
wantgreys = wantgreys[:5]
|
|
if len(wantgreys) > len(greytrade):
|
|
wantgreys = wantgreys[:len(greytrade)]
|
|
if len(wantgreys) > 0:
|
|
wantall.extend(wantgreys)
|
|
tradegreyscount = len(wantgreys)
|
|
tradegreys = []
|
|
tradegreys.extend(random.sample(greytrade,len(wantgreys)))
|
|
tradeall.extend(tradegreys)
|
|
wantchaos = []
|
|
for card in chaos:
|
|
if card in wantednames:
|
|
wantchaos.append(card)
|
|
if len(wantchaos) > 5:
|
|
wantchaos = wantchaos[:5]
|
|
if len(wantchaos) > 0:
|
|
wantall.extend(wantchaos)
|
|
tradechaos = input("Provide " + str(len(wantchaos)) + " cards for the chaos pile (for " + ", ".join(wantchaos) + "): ").split(", ")
|
|
tradeall.extend(tradechaos)
|
|
print("\n")
|
|
if len(tradeall) > 0:
|
|
if len(wantreds) > 0:
|
|
print("red: " + ", ".join(tradereds) + " for " + ", ".join(wantreds))
|
|
if len(wantoranges) > 0:
|
|
print("orange: " + ", ".join(tradeoranges) + " for " + ", ".join(wantoranges))
|
|
if len(wantyellows) > 0:
|
|
print("yellow: " + ", ".join(tradeyellows) + " for " + ", ".join(wantyellows))
|
|
if len(wantgreens) > 0:
|
|
print("green: " + ", ".join(tradegreens) + " for " + ", ".join(wantgreens))
|
|
if len(wantblues) > 0:
|
|
print("blue: " + ", ".join(tradeblues) + " for " + ", ".join(wantblues))
|
|
if len(wantpurples) > 0:
|
|
print("purple: " + ", ".join(tradepurples) + " for " + ", ".join(wantpurples))
|
|
if len(wantbrowns) > 0:
|
|
print("brown: " + ", ".join(tradebrowns) + " for " + ", ".join(wantbrowns))
|
|
if len(wantgreys) > 0:
|
|
if variables.british:
|
|
print("grey: " + ", ".join(tradegreys) + " for " + ", ".join(wantgreys))
|
|
else:
|
|
print("gray: " + ", ".join(tradegreys) + " for " + ", ".join(wantgreys))
|
|
if len(wantchaos) > 0:
|
|
print("chaos: " + ", ".join(tradechaos) + " for " + ", ".join(wantchaos))
|
|
images = ""
|
|
for card in tradeall:
|
|
images += "<img src=\"https://colors-tcg.eu/cards/" + card + ".gif\">"
|
|
print("\n" + images + "\n")
|
|
switchround = input("Round number: ")
|
|
switchcomment = input("Comment URL: ")
|
|
print("\n{\"event\":\"switch it up " + switchround + "\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + switchcomment + "\",\"pend\":[\"" + "\",\"".join(wantall) + "\"],\"lost\":[\"" + "\",\"".join(tradeall) + "\"]}")
|
|
else:
|
|
print("No cards found")
|
|
|
|
def fish():
|
|
fishdecks = input("Paste list of decks here: ").split(", ")
|
|
fishfound = []
|
|
for card in colors.cardlist:
|
|
for deck in fishdecks:
|
|
if card["name"][:-2] == deck:
|
|
fishfound.append(card)
|
|
break
|
|
fishrefined = []
|
|
previouscard = ""
|
|
for card in fishfound:
|
|
try:
|
|
if card["name"][:-2] != previouscard["name"][:-2]:
|
|
fishrefined.append(card)
|
|
except:
|
|
fishrefined.append(card)
|
|
previouscard = card
|
|
fishmastered = []
|
|
fishhp = []
|
|
fishmp = []
|
|
fishlp = []
|
|
fishmass = []
|
|
fishtrade = []
|
|
for card in fishrefined:
|
|
found = False
|
|
for deck in colors.decklist:
|
|
if found == False:
|
|
if deck["name"] == card["name"][:-2]:
|
|
if deck["mastered"]:
|
|
fishmastered.append(card)
|
|
else:
|
|
if deck["priority"] == 1:
|
|
fishhp.append(card)
|
|
elif deck["priority"] == 2:
|
|
fishmp.append(card)
|
|
elif deck["priority"] == 3:
|
|
fishlp.append(card)
|
|
else:
|
|
if card["mass"]:
|
|
fishmass.append(card)
|
|
else:
|
|
fishtrade.append(card)
|
|
found = True
|
|
locations = []
|
|
if len(fishmastered) > 0:
|
|
locations.append("mastered")
|
|
if len(fishhp) > 0:
|
|
locations.append("collecting/high priority")
|
|
if len(fishmp) > 0:
|
|
locations.append("collecting/medium priority")
|
|
if len(fishlp) > 0:
|
|
locations.append("collecting/low priority")
|
|
if len(fishmass) > 0:
|
|
for card in fishmass:
|
|
locations.append("mass collecting/" + card["mass"][0])
|
|
if len(fishtrade) > 0:
|
|
locations.append("trading")
|
|
locations = list(dict.fromkeys(locations))
|
|
cardnames = []
|
|
for card in fishrefined:
|
|
cardnames.append(card["name"])
|
|
if len(fishrefined) > 0:
|
|
print("\nTrade post: " + variables.url + "\nNumber of matches: " + str(len(fishrefined)) + "\nCard name(s): " + ", ".join(cardnames) + "\nWhere cards are located: " + ", ".join(locations) + "\nCards:")
|
|
images = ""
|
|
for card in fishrefined:
|
|
images += "<img src=\"https://colors-tcg.eu/cards/" + card["name"] + ".gif\">"
|
|
print(images)
|
|
else:
|
|
print("No cards found")
|
|
|
|
def studio():
|
|
tradedupes = []
|
|
tradedupesreserve = []
|
|
tradenormal = []
|
|
tradespecial = []
|
|
for card in colors.cardlist:
|
|
if card["priority"] == 4:
|
|
if card["colour"] != "sig" and card["colour"] != "limited":
|
|
if card["dupe"]:
|
|
if len(card["mass"]) == 0:
|
|
tradedupes.append(card["name"])
|
|
else:
|
|
tradedupesreserve.append(card["name"])
|
|
else:
|
|
if card["colour"] == "special":
|
|
tradespecial.append(card["name"])
|
|
else:
|
|
tradenormal.append(card["name"])
|
|
dupeslimit = 10
|
|
newlimit = 20
|
|
sigslimit = 10
|
|
choicelimit = 16
|
|
speciallimit = 10
|
|
for event in log.log:
|
|
if event["date"].year == datetime.datetime.now().year and event["date"].month == datetime.datetime.now().month:
|
|
if event["event"] == "art studio":
|
|
try:
|
|
dupeslimit -= event["exchange"]["dupes"]
|
|
except:
|
|
pass
|
|
try:
|
|
newlimit -= event["exchange"]["new"]
|
|
except:
|
|
pass
|
|
try:
|
|
sigslimit -= event["exchange"]["sigs"]
|
|
except:
|
|
pass
|
|
try:
|
|
choicelimit -= event["exchange"]["choice"]
|
|
except:
|
|
pass
|
|
try:
|
|
speciallimit -= event["exchange"]["special"]
|
|
except:
|
|
pass
|
|
dupesalready = dupeslimit
|
|
newalready = newlimit
|
|
sigsalready = sigslimit
|
|
choicealready = choicelimit
|
|
specialalready = speciallimit
|
|
if dupeslimit > len(tradedupes):
|
|
tradedupes.extend(tradedupesreserve)
|
|
if dupeslimit > len(tradedupes):
|
|
dupeslimit = len(tradedupes)
|
|
if dupeslimit > 0:
|
|
dupeswant = int(input("How many randoms for doubles? (" + str(dupeslimit) + " remaining) "))
|
|
else:
|
|
dupeswant = 0
|
|
if newlimit * 2 > len(tradenormal):
|
|
newlimit = math.floor(len(tradenormal)/2)
|
|
if newlimit > 0:
|
|
newwant = int(input("How many new release cards? (" + str(newlimit) + " remaining) "))
|
|
else:
|
|
newwant = 0
|
|
if sigslimit * 3 + newwant * 2 > len(tradenormal):
|
|
sigslimit = math.floor((len(tradenormal) - (newwant * 2))/3)
|
|
if sigslimit > 0:
|
|
sigswant = int(input("How many signatures? (" + str(sigslimit) + " remaining) "))
|
|
else:
|
|
sigswant = 0
|
|
if choicelimit * 3 + sigswant * 3 + newwant * 2 > len(tradenormal):
|
|
choicelimit = math.floor((len(tradenormal) - ((newwant * 2) + (sigswant * 3)))/3)
|
|
if choicelimit > 0:
|
|
choicewant = int(input("How many choice character cards? (" + str(choicelimit) + " remaining) "))
|
|
else:
|
|
choicewant = 0
|
|
if speciallimit * 3 > len(tradespecial):
|
|
speciallimit = math.floor(len(tradespecial)/3)
|
|
if speciallimit > 0:
|
|
specialwant = int(input("How many choice special cards? (" + str(speciallimit) + " remaining) "))
|
|
else:
|
|
specialwant = 0
|
|
neededdupes = dupeswant
|
|
needednormal = 2 * newwant + 3 * sigswant + 3 * choicewant
|
|
neededspecial = 3 * specialwant
|
|
give = []
|
|
if neededdupes > 0:
|
|
give.extend(random.sample(tradedupes,neededdupes))
|
|
if needednormal > 0:
|
|
give.extend(random.sample(tradenormal,needednormal))
|
|
if neededspecial > 0:
|
|
give.extend(random.sample(tradespecial,neededspecial))
|
|
if choicewant > 0:
|
|
choicelist = input(str(choicewant) + " choice character cards: ").split(", ")
|
|
if specialwant > 0:
|
|
speciallist = input(str(specialwant) + " choice special cards: ").split(", ")
|
|
allwants = []
|
|
if dupeswant > 1:
|
|
allwants.append(str(dupeswant) + " random cards")
|
|
elif dupeswant == 1:
|
|
allwants.append(str(dupeswant) + " random card")
|
|
if newwant > 1:
|
|
allwants.append(str(newwant) + " new release cards")
|
|
elif newwant == 1:
|
|
allwants.append(str(newwant) + " new release card")
|
|
if sigswant > 0:
|
|
allwants.append(str(sigswant) + " x sig_" + variables.name.lower())
|
|
if choicewant > 0:
|
|
allwants.extend(choicelist)
|
|
if specialwant > 0:
|
|
allwants.extend(speciallist)
|
|
if len(allwants) > 0:
|
|
print("\n<b>What are you exchanging for?</b>: " + ", ".join(allwants) + "\n<b>Cards you are exchanging</b>:\n<img src=\"https://colors-tcg.eu/cards/" + ".gif\"><img src=\"https://colors-tcg.eu/cards/".join(give) + ".gif\">\n<b>Card names</b>: " + ", ".join(give) + "\n<b>Art Studio use for the current month</b>: random cards: " + str(10 - dupesalready + dupeswant) + "/10; new release cards: " + str(20 - newalready + newwant) + "/20; signatures: " + str(10 - sigsalready + sigswant) + "/10; character cards: " + str(16 - choicealready + choicewant) + "/16; special cards: " + str(10 - specialalready + specialwant) + "/10\n")
|
|
studiourl = input("Paste in comment URL: ")
|
|
studiostring = "{\"event\":\"art studio\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + studiourl + "\",\"lost\":[\"" + "\",\"".join(give) + "\"],"
|
|
allchoice = []
|
|
try:
|
|
allchoice.extend(choicelist)
|
|
except:
|
|
pass
|
|
try:
|
|
allchoice.extend(speciallist)
|
|
except:
|
|
pass
|
|
if len(allchoice) > 0:
|
|
studiostring += "\"pend\":[\"" + "\",\"".join(allchoice) + "\"],"
|
|
studiostring += "\"exchange\":{\"dupes\":" + str(dupeswant) + ",\"new\":" + str(newwant) + ",\"sigs\":" + str(sigswant) + ",\"choice\":" + str(choicewant) + ",\"special\":" + str(specialwant) + "}}"
|
|
print("\n" + studiostring)
|
|
else:
|
|
print("Nothing requested")
|
|
|
|
def randoms(specials=False):
|
|
totalrandoms = int(input("How many? "))
|
|
pool = []
|
|
for card in colors.cardlist:
|
|
if card["priority"] == 4 and card["dupe"] == False and card["colour"] != "sig" and card["colour"] != "limited":
|
|
if specials:
|
|
pool.append(card["name"])
|
|
else:
|
|
if card["colour"] != "special":
|
|
pool.append(card["name"])
|
|
try:
|
|
chosen = sorted(random.sample(pool,totalrandoms))
|
|
print(", ".join(chosen))
|
|
except ValueError:
|
|
print("Too many cards requested")
|
|
|
|
def artshop():
|
|
hpred = []
|
|
mpred = []
|
|
lpred = []
|
|
hporange = []
|
|
mporange = []
|
|
lporange = []
|
|
hpyellow = []
|
|
mpyellow = []
|
|
lpyellow = []
|
|
hpgreen = []
|
|
mpgreen = []
|
|
lpgreen = []
|
|
hpblue = []
|
|
mpblue = []
|
|
lpblue = []
|
|
hppurple = []
|
|
mppurple = []
|
|
lppurple = []
|
|
hpbrown = []
|
|
mpbrown = []
|
|
lpbrown = []
|
|
hpgrey = []
|
|
mpgrey = []
|
|
lpgrey = []
|
|
for deck in colors.decklist:
|
|
if not deck["mastered"]:
|
|
if deck["colour"] == "red":
|
|
if deck["priority"] == 1:
|
|
hpred.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mpred.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lpred.append(deck)
|
|
elif deck["colour"] == "orange":
|
|
if deck["priority"] == 1:
|
|
hporange.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mporange.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lporange.append(deck)
|
|
elif deck["colour"] == "yellow":
|
|
if deck["priority"] == 1:
|
|
hpyellow.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mpyellow.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lpyellow.append(deck)
|
|
elif deck["colour"] == "green":
|
|
if deck["priority"] == 1:
|
|
hpgreen.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mpgreen.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lpgreen.append(deck)
|
|
elif deck["colour"] == "blue":
|
|
if deck["priority"] == 1:
|
|
hpblue.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mpblue.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lpblue.append(deck)
|
|
elif deck["colour"] == "purple":
|
|
if deck["priority"] == 1:
|
|
hppurple.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mppurple.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lppurple.append(deck)
|
|
elif deck["colour"] == "brown":
|
|
if deck["priority"] == 1:
|
|
hpbrown.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mpbrown.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lpbrown.append(deck)
|
|
elif deck["colour"] == "gray":
|
|
if deck["priority"] == 1:
|
|
hpgrey.append(deck)
|
|
elif deck["priority"] == 2:
|
|
mpgrey.append(deck)
|
|
elif deck["priority"] == 3:
|
|
lpgrey.append(deck)
|
|
wantred = []
|
|
wantred.extend(sorted(hpred, key=lambda d: d["count"],reverse=True))
|
|
wantred.extend(sorted(mpred, key=lambda d: d["count"],reverse=True))
|
|
wantred.extend(sorted(lpred, key=lambda d: d["count"],reverse=True))
|
|
wantorange = []
|
|
wantorange.extend(sorted(hporange, key=lambda d: d["count"],reverse=True))
|
|
wantorange.extend(sorted(mporange, key=lambda d: d["count"],reverse=True))
|
|
wantorange.extend(sorted(lporange, key=lambda d: d["count"],reverse=True))
|
|
wantyellow = []
|
|
wantyellow.extend(sorted(hpyellow, key=lambda d: d["count"],reverse=True))
|
|
wantyellow.extend(sorted(mpyellow, key=lambda d: d["count"],reverse=True))
|
|
wantyellow.extend(sorted(lpyellow, key=lambda d: d["count"],reverse=True))
|
|
wantgreen = []
|
|
wantgreen.extend(sorted(hpgreen, key=lambda d: d["count"],reverse=True))
|
|
wantgreen.extend(sorted(mpgreen, key=lambda d: d["count"],reverse=True))
|
|
wantgreen.extend(sorted(lpgreen, key=lambda d: d["count"],reverse=True))
|
|
wantblue = []
|
|
wantblue.extend(sorted(hpblue, key=lambda d: d["count"],reverse=True))
|
|
wantblue.extend(sorted(mpblue, key=lambda d: d["count"],reverse=True))
|
|
wantblue.extend(sorted(lpblue, key=lambda d: d["count"],reverse=True))
|
|
wantpurple = []
|
|
wantpurple.extend(sorted(hppurple, key=lambda d: d["count"],reverse=True))
|
|
wantpurple.extend(sorted(mppurple, key=lambda d: d["count"],reverse=True))
|
|
wantpurple.extend(sorted(lppurple, key=lambda d: d["count"],reverse=True))
|
|
wantbrown = []
|
|
wantbrown.extend(sorted(hpbrown, key=lambda d: d["count"],reverse=True))
|
|
wantbrown.extend(sorted(mpbrown, key=lambda d: d["count"],reverse=True))
|
|
wantbrown.extend(sorted(lpbrown, key=lambda d: d["count"],reverse=True))
|
|
wantgrey = []
|
|
wantgrey.extend(sorted(hpgrey, key=lambda d: d["count"],reverse=True))
|
|
wantgrey.extend(sorted(mpgrey, key=lambda d: d["count"],reverse=True))
|
|
wantgrey.extend(sorted(lpgrey, key=lambda d: d["count"],reverse=True))
|
|
requestcards = []
|
|
redleft = colors.crayred
|
|
redspend = 0
|
|
requestred = True
|
|
for deck in wantred:
|
|
if requestred == True:
|
|
if redleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
redspend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
redleft -= redspend
|
|
else:
|
|
requestred = False
|
|
orangeleft = colors.crayorange
|
|
orangespend = 0
|
|
requestorange = True
|
|
for deck in wantorange:
|
|
if requestorange == True:
|
|
if orangeleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
orangespend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
orangeleft -= orangespend
|
|
else:
|
|
requestorange = False
|
|
yellowleft = colors.crayyellow
|
|
yellowspend = 0
|
|
requestyellow = True
|
|
for deck in wantyellow:
|
|
if requestyellow == True:
|
|
if yellowleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
yellowspend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
yellowleft -= yellowspend
|
|
else:
|
|
requestyellow = False
|
|
greenleft = colors.craygreen
|
|
greenspend = 0
|
|
requestgreen = True
|
|
for deck in wantgreen:
|
|
if requestgreen == True:
|
|
if greenleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
greenspend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
greenleft -= greenspend
|
|
else:
|
|
requestgreen = False
|
|
blueleft = colors.crayblue
|
|
bluespend = 0
|
|
requestblue = True
|
|
for deck in wantblue:
|
|
if requestblue == True:
|
|
if blueleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
bluespend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
blueleft -= bluespend
|
|
else:
|
|
requestblue = False
|
|
purpleleft = colors.craypurple
|
|
purplespend = 0
|
|
requestpurple = True
|
|
for deck in wantpurple:
|
|
if requestpurple == True:
|
|
if purpleleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
purplespend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
purpleleft -= purplespend
|
|
else:
|
|
requestpurple = False
|
|
brownleft = colors.craybrown
|
|
brownspend = 0
|
|
requestbrown = True
|
|
for deck in wantbrown:
|
|
if requestbrown == True:
|
|
if brownleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
brownspend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
brownleft -= brownspend
|
|
else:
|
|
requestbrown = False
|
|
greyleft = colors.craygrey
|
|
greyspend = 0
|
|
requestgrey = True
|
|
for deck in wantgrey:
|
|
if requestgrey == True:
|
|
if greyleft >= 20 - deck["count"]:
|
|
if not deck["01"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "01")
|
|
if not deck["02"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "02")
|
|
if not deck["03"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "03")
|
|
if not deck["04"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "04")
|
|
if not deck["05"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "05")
|
|
if not deck["06"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "06")
|
|
if not deck["07"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "07")
|
|
if not deck["08"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "08")
|
|
if not deck["09"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "09")
|
|
if not deck["10"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "10")
|
|
if not deck["11"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "11")
|
|
if not deck["12"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "12")
|
|
if not deck["13"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "13")
|
|
if not deck["14"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "14")
|
|
if not deck["15"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "15")
|
|
if not deck["16"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "16")
|
|
if not deck["17"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "17")
|
|
if not deck["18"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "18")
|
|
if not deck["19"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "19")
|
|
if not deck["20"]:
|
|
greyspend += 1
|
|
requestcards.append(deck["name"] + "20")
|
|
greyleft -= greyspend
|
|
else:
|
|
requestgrey = False
|
|
tradecommon = list((Counter(colors.tradeout) & Counter(colors.tradein)).elements())
|
|
sketch = len(tradecommon)
|
|
if sketch > 0:
|
|
sketchdifference = int(sketch / 20) - colors.redeemedsketch
|
|
else:
|
|
sketchdifference = 0
|
|
if len(requestcards) == 0 and sketchdifference < 1:
|
|
print("Nothing to request")
|
|
else:
|
|
shopstring = "\n<b>Name:</b> " + variables.name + "\n<b>Card Post:</b> " + variables.url + "\n"
|
|
if len(requestcards) > 0:
|
|
shopstring += "<b>Choice Cards:</b> " + ", ".join(requestcards) + "\n"
|
|
if sketchdifference > 0:
|
|
shopstring += "<b>Number of Sketchpads:</b> " + str(sketchdifference) + "\n<b>Sketchpad Prize:</b> prize " + str(variables.sketchprize) + "\n"
|
|
if len(requestcards) > 0:
|
|
shopstring += "<b>Crayons:</b> "
|
|
if redspend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon1.gif\"> x " + str(redspend)
|
|
if orangespend + yellowspend + greenspend + bluespend + purplespend + brownspend + greyspend > 0:
|
|
shopstring += ", "
|
|
if orangespend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon2.gif\"> x " + str(orangespend)
|
|
if yellowspend + greenspend + bluespend + purplespend + brownspend + greyspend > 0:
|
|
shopstring += ", "
|
|
if yellowspend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon3.gif\"> x " + str(yellowspend)
|
|
if greenspend + bluespend + purplespend + brownspend + greyspend > 0:
|
|
shopstring += ", "
|
|
if greenspend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon4.gif\"> x " + str(greenspend)
|
|
if bluespend + purplespend + brownspend + greyspend > 0:
|
|
shopstring += ", "
|
|
if bluespend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon5.gif\"> x " + str(bluespend)
|
|
if purplespend + brownspend + greyspend > 0:
|
|
shopstring += ", "
|
|
if purplespend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon6.gif\"> x " + str(purplespend)
|
|
if brownspend + greyspend > 0:
|
|
shopstring += ", "
|
|
if brownspend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon7.gif\"> x " + str(brownspend)
|
|
if greyspend > 0:
|
|
shopstring += ", "
|
|
if greyspend > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon8.gif\"> x " + str(greyspend)
|
|
shopstring += "\n"
|
|
if sketchdifference > 0:
|
|
shopstring += "<b>Sketchpads:</b>\n<img src=\"" + variables.url + "/assets/sketch/20.gif\"> x " + str(sketchdifference)
|
|
print(shopstring)
|
|
shopurl = input("\nPaste in comment URL: ")
|
|
shoplog = "\n{\"event\":\"art shop\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + shopurl + "\""
|
|
if len(requestcards) > 0:
|
|
shoplog += ",\"pend\":[\"" + "\",\"".join(requestcards) + "\"],\"crayons\":{"
|
|
if redspend > 0:
|
|
shoplog += "\"red\":-" + str(redspend)
|
|
if orangespend + yellowspend + greenspend + bluespend + purplespend + brownspend + greyspend > 0:
|
|
shoplog += ","
|
|
if orangespend > 0:
|
|
shoplog += "\"orange\":-" + str(orangespend)
|
|
if yellowspend + greenspend + bluespend + purplespend + brownspend + greyspend > 0:
|
|
shoplog += ","
|
|
if yellowspend > 0:
|
|
shoplog += "\"yellow\":-" + str(yellowspend)
|
|
if greenspend + bluespend + purplespend + brownspend + greyspend > 0:
|
|
shoplog += ","
|
|
if greenspend > 0:
|
|
shoplog += "\"green\":-" + str(greenspend)
|
|
if bluespend + purplespend + brownspend + greyspend > 0:
|
|
shoplog += ","
|
|
if bluespend > 0:
|
|
shoplog += "\"blue\":-" + str(bluespend)
|
|
if purplespend + brownspend + greyspend > 0:
|
|
shoplog += ","
|
|
if purplespend > 0:
|
|
shoplog += "\"purple\":-" + str(purplespend)
|
|
if brownspend + greyspend > 0:
|
|
shoplog += ","
|
|
if brownspend > 0:
|
|
shoplog += "\"brown\":-" + str(brownspend)
|
|
if greyspend > 0:
|
|
shoplog += ","
|
|
if greyspend > 0:
|
|
shoplog += "\"gray\":-" + str(greyspend)
|
|
shoplog += "}"
|
|
if sketchdifference > 0:
|
|
shoplog += ",\"sketch\":-" + str(sketchdifference)
|
|
shoplog += "}"
|
|
print(shoplog)
|
|
|
|
def stats():
|
|
if colors.tradepend > 0:
|
|
print("\nCollection size: " + str(len(colors.cardlist) + colors.tradepend) + " cards (" + str(len(colors.cardlist)) + " + " + str(colors.tradepend) + " pending trade)")
|
|
else:
|
|
print("\nCollection size: " + str(len(colors.cardlist)) + " cards")
|
|
print("Level: " + colors.rank)
|
|
tradesize = 0
|
|
for card in colors.cardlist:
|
|
if card["priority"] == 4:
|
|
tradesize += 1
|
|
print("Tradepile: " + str(tradesize) + " cards")
|
|
masteredsize = 0
|
|
for deck in colors.decklist:
|
|
if deck["mastered"]:
|
|
masteredsize += 1
|
|
print("Wantlist: " + str(len(colors.wantedlist)) + " cards")
|
|
print("Mastered: " + str(masteredsize) + " decks")
|
|
print("Mass collection progress:")
|
|
masslist = sorted(list(variables.masscollect.keys()))
|
|
seriesdict = {}
|
|
for series in masslist:
|
|
seriesdict[series] = 0
|
|
for card in colors.cardlist:
|
|
if not card["dupe"]:
|
|
for series in card["mass"]:
|
|
for theseries in masslist:
|
|
if series == theseries:
|
|
seriesdict[series] += 1
|
|
totaldict = {}
|
|
for key,value in variables.masscollect.items():
|
|
thenumber = 0
|
|
try:
|
|
thenumber += 20 * len(value["decks"])
|
|
except:
|
|
pass
|
|
try:
|
|
thenumber += len(value["singles"])
|
|
except:
|
|
pass
|
|
totaldict[key] = thenumber
|
|
totaldict = dict(sorted(totaldict.items()))
|
|
for key in seriesdict:
|
|
if totaldict[key] > seriesdict[key]:
|
|
print(" " + key + ": " + str(seriesdict[key]) + "/" + str(totaldict[key]) + " (" + str(int((float(seriesdict[key])/float(totaldict[key])) * 100)) + "%)")
|
|
else:
|
|
print(" " + key + ": complete")
|
|
|
|
def tradecheck():
|
|
inoffer = input("Paste cards they offered here: ").split(", ")
|
|
outoffer = input("Paste cards they requested here: ").split(", ")
|
|
insig = 0
|
|
inone = 0
|
|
intwo = 0
|
|
inthree = 0
|
|
infour = 0
|
|
for incard in inoffer:
|
|
if incard[0:4] == "sig_":
|
|
insig = 1
|
|
else:
|
|
found = False
|
|
for card in colors.wantedlist:
|
|
if found == False:
|
|
if card["name"] == incard:
|
|
if card["priority"] == 1:
|
|
inone += 1
|
|
elif card["priority"] == 2:
|
|
intwo += 1
|
|
elif card["priority"] == 3:
|
|
inthree += 1
|
|
found = True
|
|
if found == False:
|
|
infour += 1
|
|
print("\n")
|
|
offerstring = "They are offering "
|
|
if inone > 0:
|
|
offerstring += str(inone) + " high priority"
|
|
if intwo + inthree + infour + insig > 0:
|
|
offerstring += ", "
|
|
if intwo > 0:
|
|
offerstring += str(intwo) + " medium priority"
|
|
if inthree + infour + insig > 0:
|
|
offerstring += ", "
|
|
if inthree > 0:
|
|
offerstring += str(inthree) + " low priority"
|
|
if infour + insig > 0:
|
|
offerstring += ", "
|
|
if infour > 0:
|
|
offerstring += str(infour) + " randoms"
|
|
if insig > 0:
|
|
offerstring += ", "
|
|
if insig > 0:
|
|
offerstring += " sig"
|
|
offerstring += " = " + str(inone + intwo + inthree + infour + insig) + " cards"
|
|
print(offerstring)
|
|
reversecards = colors.cardlist[::-1]
|
|
outsig = 0
|
|
outone = 0
|
|
outtwo = 0
|
|
outthree = 0
|
|
outfour = 0
|
|
notin = []
|
|
for outcard in outoffer:
|
|
if outcard[0:4] == "sig_":
|
|
outsig = 1
|
|
else:
|
|
found = False
|
|
for card in reversecards:
|
|
if found == False:
|
|
if card["name"] == outcard:
|
|
if card["priority"] == 1:
|
|
outone += 1
|
|
elif card["priority"] == 2:
|
|
outtwo += 1
|
|
elif card["priority"] == 3:
|
|
outthree += 1
|
|
elif card["priority"] == 4:
|
|
outfour += 1
|
|
found = True
|
|
if found == False:
|
|
notin.append(outcard)
|
|
requeststring = "They are requesting "
|
|
if outone > 0:
|
|
requeststring += str(outone) + " high priority"
|
|
if outtwo + outthree + outfour + outsig > 0:
|
|
requeststring += ", "
|
|
if outtwo > 0:
|
|
requeststring += str(outtwo) + " medium priority"
|
|
if outthree + outfour + outsig > 0:
|
|
requeststring += ", "
|
|
if outthree > 0:
|
|
requeststring += str(outthree) + " low priority"
|
|
if outfour + outsig > 0:
|
|
requeststring += ", "
|
|
if outfour > 0:
|
|
requeststring += str(outfour) + " from tradepile"
|
|
if outsig > 0:
|
|
requeststring += ", "
|
|
if outsig > 0:
|
|
requeststring += " sig"
|
|
requeststring += " = " + str(outone + outtwo + outthree + outfour + outsig) + " cards"
|
|
print(requeststring)
|
|
if len(notin) > 0:
|
|
print("Requested but not in collection: " + ", ".join(notin))
|
|
|
|
def cardcheck():
|
|
thecard = input("Card name: ")
|
|
print("\n")
|
|
found = False
|
|
for card in colors.cardlist:
|
|
if card["name"] == thecard:
|
|
print("In collection:")
|
|
print(card)
|
|
found = True
|
|
if found == False:
|
|
for card in colors.pends:
|
|
if card == thecard:
|
|
print("Card on pending list")
|
|
found = True
|
|
if found == False:
|
|
for card in colors.wantedlist:
|
|
if card["name"] == thecard:
|
|
print("On wantlist:")
|
|
print(card)
|
|
found = True
|
|
if found == False:
|
|
print("No matches")
|
|
|
|
def deckcheck():
|
|
thedeck = input("Deck name: ")
|
|
print("\n")
|
|
found = False
|
|
for deck in colors.decklist:
|
|
if deck["name"] == thedeck:
|
|
print(deck)
|
|
found = True
|
|
if found == False:
|
|
for theme in variables.masscollect:
|
|
try:
|
|
for deck in variables.masscollect[theme]["decks"]:
|
|
if deck == thedeck:
|
|
print("On mass deck wantlist: " + theme)
|
|
found = True
|
|
except:
|
|
pass
|
|
if found == False:
|
|
print("No matches")
|
|
|
|
def maketrade():
|
|
print("\nMake sure the other player’s tradepile and wantlist are in trade.py")
|
|
theirname = input("Player with whom you are trading: ")
|
|
theircards = list(dict.fromkeys(trade.theirtradepile.split(", ")))
|
|
removetheirs = input("Cards to remove from their tradepile: ").split(", ")
|
|
for card in removetheirs:
|
|
if card in theircards:
|
|
theircards.remove(card)
|
|
hpwc = []
|
|
hpws = []
|
|
mpwc = []
|
|
mpws = []
|
|
lpwc = []
|
|
lpws = []
|
|
for thecard in theircards:
|
|
for card in colors.wantedlist:
|
|
if card["name"] == thecard:
|
|
if card["colour"] == "special" or card["colour"] == "limited":
|
|
if card["priority"] == 1:
|
|
hpws.append(thecard)
|
|
elif card["priority"] == 2:
|
|
mpws.append(thecard)
|
|
elif card["priority"] == 3:
|
|
lpws.append(thecard)
|
|
else:
|
|
if card["priority"] == 1:
|
|
hpwc.append(thecard)
|
|
elif card["priority"] == 2:
|
|
mpwc.append(thecard)
|
|
elif card["priority"] == 3:
|
|
lpwc.append(thecard)
|
|
theirwantlist = list(dict.fromkeys(trade.theirwantlist.split(", ")))
|
|
lptc = []
|
|
lpts = []
|
|
mptc = []
|
|
mpts = []
|
|
hptc = []
|
|
hpts = []
|
|
randomch = []
|
|
randomsp = []
|
|
totalrandomch = 0
|
|
totalrandomsp = 0
|
|
ifrandoms = input("Do they take randoms? [y/N] ")
|
|
if ifrandoms == "y":
|
|
randoms = True
|
|
else:
|
|
randoms = False
|
|
for thecard in theirwantlist:
|
|
found = False
|
|
for card in reversed(colors.cardlist):
|
|
if found == False:
|
|
if card["name"] == thecard:
|
|
if card["colour"] == "special" or card["colour"] == "limited":
|
|
if card["priority"] == 4:
|
|
lpts.append(thecard)
|
|
found = True
|
|
elif card["priority"] == 3:
|
|
mpts.append(thecard)
|
|
found = True
|
|
elif variables.trademedium:
|
|
if card["priority"] == 2:
|
|
hpts.append(thecard)
|
|
found = True
|
|
else:
|
|
if card["priority"] == 4:
|
|
lptc.append(thecard)
|
|
found = True
|
|
elif card["priority"] == 3:
|
|
mptc.append(thecard)
|
|
found = True
|
|
elif variables.trademedium:
|
|
if card["priority"] == 2:
|
|
hptc.append(thecard)
|
|
found = True
|
|
if randoms:
|
|
for card in colors.cardlist:
|
|
if card["priority"] == 4:
|
|
if card not in theirwantlist:
|
|
if card["colour"] == "special":
|
|
randomsp.append(card["name"])
|
|
else:
|
|
randomch.append(card["name"])
|
|
inc = []
|
|
outc = []
|
|
inc.extend(hpwc)
|
|
outc.extend(lptc)
|
|
medchadded = False
|
|
if len(inc) > len(outc):
|
|
if randoms:
|
|
try:
|
|
random.shuffle(randomch)
|
|
neededrandomch = len(inc) - len(outc)
|
|
totalrandomch += neededrandomch
|
|
add = randomch[:neededrandomch]
|
|
randomch = randomch[neededrandomch:]
|
|
outc.extend(add)
|
|
trymediumch = True
|
|
except:
|
|
outc.extend(mptc)
|
|
medchadded = True
|
|
if len(inc) > len(outc):
|
|
trymediumch = False
|
|
outc.extend(hptc)
|
|
else:
|
|
trymediumch = True
|
|
else:
|
|
outc.extend(mptc)
|
|
medchadded = True
|
|
if len(inc) > len(outc):
|
|
trymediumch = False
|
|
outc.extend(hptc)
|
|
else:
|
|
trymediumch = True
|
|
else:
|
|
trymediumch = True
|
|
if trymediumch:
|
|
inc.extend(mpwc)
|
|
if len(inc) > len(outc):
|
|
if randoms:
|
|
try:
|
|
random.shuffle(randomch)
|
|
neededrandomch = len(inc) - len(outc)
|
|
totalrandomch += neededrandomch
|
|
add = randomch[:neededrandomch]
|
|
randomch = randomch[neededrandomch:]
|
|
outc.extend(add)
|
|
trylowch = True
|
|
except:
|
|
trylowch = False
|
|
if not medchadded:
|
|
outc.extend(mptc)
|
|
else:
|
|
trylowch = False
|
|
if not medchadded:
|
|
outc.extend(mptc)
|
|
else:
|
|
trylowch = True
|
|
else:
|
|
trylowch = False
|
|
if trylowch:
|
|
inc.extend(lpwc)
|
|
if len(inc) > len(outc):
|
|
if randoms:
|
|
try:
|
|
random.shuffle(randomch)
|
|
neededrandomch = len(inc) - len(outc)
|
|
totalrandomch += neededrandomch
|
|
add = randomch[:neededrandomch]
|
|
randomch = randomch[neededrandomch:]
|
|
outc.extend(add)
|
|
except:
|
|
pass
|
|
if len(inc) > len(outc):
|
|
inc = inc[:len(outc)]
|
|
elif len(outc) > len(inc):
|
|
outc = outc[:len(inc)]
|
|
ins = []
|
|
outs = []
|
|
ins.extend(hpws)
|
|
outs.extend(lpts)
|
|
medspadded = False
|
|
if len(ins) > len(outs):
|
|
if randoms:
|
|
try:
|
|
random.shuffle(randomsp)
|
|
neededrandomsp = len(ins) - len(outs)
|
|
totalrandomsp += neededrandomsp
|
|
add = randomsp[:neededrandomsp]
|
|
randomsp = randomsp[neededrandomsp:]
|
|
outs.extend(add)
|
|
trymediumsp = True
|
|
except:
|
|
outs.extend(mpts)
|
|
medspadded = True
|
|
if len(ins) > len(outs):
|
|
trymediumsp = False
|
|
outs.extend(hpts)
|
|
else:
|
|
trymediumsp = True
|
|
else:
|
|
outs.extend(mpts)
|
|
medspadded = True
|
|
if len(ins) > len(outs):
|
|
trymediumsp = False
|
|
outs.extend(hpts)
|
|
else:
|
|
trymediumsp = True
|
|
else:
|
|
trymediumsp = True
|
|
if trymediumsp:
|
|
ins.extend(mpws)
|
|
if len(ins) > len(outs):
|
|
if randoms:
|
|
try:
|
|
random.shuffle(randomsp)
|
|
neededrandomsp = len(ins) - len(outs)
|
|
totalrandomsp += neededrandomsp
|
|
add = randomsp[:neededrandomsp]
|
|
randomsp = randomsp[neededrandomsp:]
|
|
outs.extend(add)
|
|
trylowsp = True
|
|
except:
|
|
trylowsp = False
|
|
if not medspadded:
|
|
outs.extend(mpts)
|
|
else:
|
|
trylowsp = False
|
|
if not medspadded:
|
|
outs.extend(mpts)
|
|
else:
|
|
trylowsp = True
|
|
else:
|
|
trylowsp = False
|
|
if trylowsp:
|
|
ins.extend(lpws)
|
|
if len(ins) > len(outs):
|
|
if randoms:
|
|
try:
|
|
random.shuffle(randomsp)
|
|
neededrandomsp = len(ins) - len(outs)
|
|
totalrandomsp += neededrandomsp
|
|
add = randomsp[:neededrandomsp]
|
|
randomsp = randomsp[neededrandomsp:]
|
|
outs.extend(add)
|
|
except:
|
|
pass
|
|
if len(ins) > len(outs):
|
|
ins = ins[:len(outs)]
|
|
elif len(outs) > len(ins):
|
|
outs = outs[:len(ins)]
|
|
thein = sorted(inc + ins)
|
|
theout = sorted(outc + outs)
|
|
if randoms:
|
|
randomstotal = totalrandomch + totalrandomsp
|
|
addsigs = input("Add signatures? [y/N] ")
|
|
if addsigs == "y":
|
|
thein.append("sig_" + theirname.lower())
|
|
theout.append("sig_" + variables.name.lower())
|
|
if len(thein) > 0:
|
|
tradestring = "\nmy " + ", ".join(theout) + "\n\nfor your " + ", ".join(thein) + "?"
|
|
if randoms:
|
|
if randomstotal > 0:
|
|
tradestring += "\n\n(" + str(len(thein)) + " cards, including " + str(randomstotal) + " randoms)"
|
|
elif len(thein) > 19:
|
|
tradestring += "\n\n(" + str(len(thein)) + " cards)"
|
|
tradestring += "\n\n<img src=\"https://colors-tcg.eu/cards/" + ".gif\"><img src=\"https://colors-tcg.eu/cards/".join(theout) + ".gif\">"
|
|
print(tradestring)
|
|
tradeurl = input("\nPaste in comment URL: ")
|
|
print("\n{\"event\":\"trade with " + theirname + "\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + tradeurl + "\",\"lost\":[\"" + "\",\"".join(theout) + "\"],\"pend\":[\"" + "\",\"".join(thein) + "\"]}")
|
|
else:
|
|
print("Nothing to trade")
|
|
|
|
def masteredtoday():
|
|
for deck in colors.decklist:
|
|
try:
|
|
if deck["mastered"].date() == datetime.datetime.today().date():
|
|
print(deck["name"])
|
|
except:
|
|
pass
|
|
|
|
def swapstation():
|
|
swappablemedium = []
|
|
swappablelow = []
|
|
for card in colors.cardlist:
|
|
if card["priority"] == 4:
|
|
for deck in colors.decklist:
|
|
if not deck["mastered"]:
|
|
if card["name"][:-2] == deck["name"]:
|
|
if deck["priority"] < 4:
|
|
thecard = {}
|
|
thecard["name"] = card["name"]
|
|
thecard["remaining"] = 20 - deck["count"]
|
|
thecard["priority"] = deck["priority"]
|
|
if deck["priority"] < 3:
|
|
swappablemedium.append(thecard)
|
|
else:
|
|
swappablelow.append(thecard)
|
|
swappablemedium = sorted(swappablemedium, key=lambda d: d["remaining"],reverse=True)
|
|
swappablelow = sorted(swappablelow, key=lambda d: d["remaining"],reverse=True)
|
|
swappable = swappablemedium + swappablelow
|
|
swapquota = 4
|
|
swapcards = []
|
|
while swapquota > 0:
|
|
try:
|
|
swapcards.append(swappable[swapquota - 1]["name"])
|
|
except:
|
|
pass
|
|
swapquota -= 1
|
|
swapcards = sorted(list(dict.fromkeys(swapcards)))
|
|
print("<img src=\"https://colors-tcg.eu/cards/" + ".gif\"><img src=\"https://colors-tcg.eu/cards/".join(swapcards) + ".gif\">\n" + ", ".join(swapcards))
|
|
swapno = input("\nRound number: ")
|
|
swapurl = input("Comment URL: ")
|
|
print("\n{\"event\":\"swap station " + swapno + "\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + swapurl + "\",\"lost\":[\"" + "\",\"".join(swapcards) + "\"]}")
|
|
|
|
def newriku():
|
|
wantedpri = sorted(colors.wantedlist, key=lambda d: d["priority"])
|
|
rikuquota = 5
|
|
potential = colors.cardlist.copy()
|
|
swapseries = []
|
|
allswaps = []
|
|
allin = []
|
|
allout = []
|
|
for card in wantedpri:
|
|
if rikuquota > 0:
|
|
if card["colour"] == "special":
|
|
if card["series"] != "Scrapbook":
|
|
swaps = []
|
|
for tradecard in potential:
|
|
if len(swaps) < 2:
|
|
if tradecard["colour"] == "special":
|
|
if tradecard["series"] != "Scrapbook":
|
|
if tradecard["priority"] == 4:
|
|
if tradecard["series"].lower() == card["series"].lower():
|
|
swaps.append(tradecard["name"])
|
|
potential.remove(tradecard)
|
|
else:
|
|
swaps = []
|
|
for tradecard in potential:
|
|
if len(swaps) < 2:
|
|
if tradecard["colour"] != "special":
|
|
if tradecard["priority"] == 4:
|
|
if tradecard["series"].lower() == card["series"].lower():
|
|
swaps.append(tradecard["name"])
|
|
potential.remove(tradecard)
|
|
if len(swaps) == 2:
|
|
if card["series"] not in swapseries:
|
|
swapseries.append(card["series"])
|
|
swapdict = {}
|
|
swapdict["in"] = card["name"]
|
|
swapdict["out"] = swaps
|
|
allswaps.append(swapdict)
|
|
allin.append(card["name"])
|
|
for outcard in swaps:
|
|
allout.append(outcard)
|
|
rikuquota -= 1
|
|
print("\n<b>Series:</b> " + ", ".join(swapseries) + "\n<b>List of cards given:</b> " + ", ".join(allout) + "\n<img src=\"https://colors-tcg.eu/cards/" + ".gif\"><img src=\"https://colors-tcg.eu/cards/".join(allout) + ".gif\">")
|
|
swapcount = 1
|
|
for swap in allswaps:
|
|
print("<i>Swap " + str(swapcount) + ":</i> " + ", ".join(swap["out"]) + " for " + swap["in"])
|
|
swapcount += 1
|
|
rikuround = input("\nRound number: ")
|
|
rikuurl = input("Comment URL: ")
|
|
print("\n{\"event\":\"riku’s favors " + rikuround + "\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + rikuurl + "\",\"lost\":[\"" + "\",\"".join(allout) + "\"],\"received\":[\"" + "\",\"".join(allin) + "\"]}")
|
|
|
|
if __name__ == "__main__":
|
|
while True:
|
|
index = 0 # adapted from https://stackoverflow.com/a/64536882
|
|
indexValidList = []
|
|
print("Choose from the list:")
|
|
options = ["Get a list of potential cards to trade in for Riku’s Favors","Generate next palette portfolio","Generate next monochrome portfolio","Generate Switch It Up request","Generate Swap Station request","Generate Go Fish comment","Generate art shop request","Generate art studio request","Check a trade offer","Propose a trade","Get a list of random cards from tradepile (excluding specials)","Get a list of random cards from tradepile (including specials)","Check a card in the collection","Check details of a deck","See decks mastered today","See some statistics about the collection"]
|
|
for optionName in options:
|
|
index = index + 1
|
|
indexValidList.extend([options.index(optionName)])
|
|
print(str(index) + ") " + optionName)
|
|
inputValid = False
|
|
while not inputValid:
|
|
inputRaw = input("Option: ")
|
|
inputNo = int(inputRaw) - 1
|
|
if inputNo > -1 and inputNo < len(indexValidList):
|
|
selected = indexValidList[inputNo]
|
|
inputValid = True
|
|
break
|
|
else:
|
|
print("Select a number from the list")
|
|
chosen = options[selected]
|
|
if chosen == "Get a list of potential cards to trade in for Riku’s Favors":
|
|
newriku()
|
|
elif chosen == "Generate next palette portfolio":
|
|
nextportfolio()
|
|
elif chosen == "Generate next monochrome portfolio":
|
|
nextportfolio(True)
|
|
elif chosen == "Generate Switch It Up request":
|
|
switchit()
|
|
elif chosen == "Generate Go Fish comment":
|
|
fish()
|
|
elif chosen == "Generate art studio request":
|
|
studio()
|
|
elif chosen == "Get a list of random cards from tradepile (excluding specials)":
|
|
randoms()
|
|
elif chosen == "Get a list of random cards from tradepile (including specials)":
|
|
randoms(True)
|
|
elif chosen == "Generate art shop request":
|
|
artshop()
|
|
elif chosen == "See some statistics about the collection":
|
|
stats()
|
|
elif chosen == "Check a trade offer":
|
|
tradecheck()
|
|
elif chosen == "Check a card in the collection":
|
|
cardcheck()
|
|
elif chosen == "Check details of a deck":
|
|
deckcheck()
|
|
elif chosen == "See decks mastered today":
|
|
masteredtoday()
|
|
elif chosen == "Propose a trade":
|
|
maketrade()
|
|
elif chosen == "Generate Swap Station request":
|
|
swapstation()
|
|
print("\n")
|
|
input("Press Enter to continue or Ctrl-C to exit")
|