1722 lines
70 KiB
Python
1722 lines
70 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 and card["dupe"] == False:
|
|
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))
|
|
allwantch = []
|
|
allwantsp = []
|
|
for card in colors.wantedlist:
|
|
if card["colour"] == "special":
|
|
allwantsp.append(card["name"])
|
|
else:
|
|
allwantch.append(card["name"])
|
|
choicelist = allwantch[:choicewant]
|
|
speciallist = allwantsp[:specialwant]
|
|
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):
|
|
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"])
|
|
totalrandoms = int(input("How many? (maximum " + str(len(pool)) + ") "))
|
|
try:
|
|
chosen = sorted(random.sample(pool,totalrandoms))
|
|
print(", ".join(chosen))
|
|
except ValueError:
|
|
print("Too many cards requested")
|
|
|
|
def artshop():
|
|
wantred = []
|
|
wantorange = []
|
|
wantyellow = []
|
|
wantgreen = []
|
|
wantblue = []
|
|
wantpurple = []
|
|
wantbrown = []
|
|
wantgrey = []
|
|
for card in colors.wantedlist:
|
|
if card["colour"] == "red":
|
|
wantred.append(card)
|
|
elif card["colour"] == "orange":
|
|
wantorange.append(card)
|
|
elif card["colour"] == "yellow":
|
|
wantyellow.append(card)
|
|
elif card["colour"] == "green":
|
|
wantgreen.append(card)
|
|
elif card["colour"] == "blue":
|
|
wantblue.append(card)
|
|
elif card["colour"] == "purple":
|
|
wantpurple.append(card)
|
|
elif card["colour"] == "brown":
|
|
wantbrown.append(card)
|
|
elif card["colour"] == "gray":
|
|
wantgrey.append(card)
|
|
requestcards = []
|
|
potentialred = []
|
|
requestred = []
|
|
potentialred.extend(wantred[:colors.crayred])
|
|
for card in potentialred:
|
|
if card["name"][:-2] != wantred[colors.crayred]["name"][:-2]:
|
|
requestred.append(card)
|
|
proceed = True
|
|
for card in requestred:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestred = []
|
|
if len(requestred) > 0:
|
|
for card in requestred:
|
|
requestcards.append(card["name"])
|
|
potentialorange = []
|
|
requestorange = []
|
|
potentialorange.extend(wantorange[:colors.crayorange])
|
|
for card in potentialorange:
|
|
if card["name"][:-2] != wantorange[colors.crayorange]["name"][:-2]:
|
|
requestorange.append(card)
|
|
proceed = True
|
|
for card in requestorange:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestorange = []
|
|
if len(requestorange) > 0:
|
|
for card in requestorange:
|
|
requestcards.append(card["name"])
|
|
potentialyellow = []
|
|
requestyellow = []
|
|
potentialyellow.extend(wantyellow[:colors.crayyellow])
|
|
for card in potentialyellow:
|
|
if card["name"][:-2] != wantyellow[colors.crayyellow]["name"][:-2]:
|
|
requestyellow.append(card)
|
|
proceed = True
|
|
for card in requestyellow:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestyellow = []
|
|
if len(requestyellow) > 0:
|
|
for card in requestyellow:
|
|
requestcards.append(card["name"])
|
|
potentialgreen = []
|
|
requestgreen = []
|
|
potentialgreen.extend(wantgreen[:colors.craygreen])
|
|
for card in potentialgreen:
|
|
if card["name"][:-2] != wantgreen[colors.craygreen]["name"][:-2]:
|
|
requestgreen.append(card)
|
|
proceed = True
|
|
for card in requestgreen:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestgreen = []
|
|
if len(requestgreen) > 0:
|
|
for card in requestgreen:
|
|
requestcards.append(card["name"])
|
|
potentialblue = []
|
|
requestblue = []
|
|
potentialblue.extend(wantblue[:colors.crayblue])
|
|
for card in potentialblue:
|
|
if card["name"][:-2] != wantblue[colors.crayblue]["name"][:-2]:
|
|
requestblue.append(card)
|
|
proceed = True
|
|
for card in requestblue:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestblue = []
|
|
if len(requestblue) > 0:
|
|
for card in requestblue:
|
|
requestcards.append(card["name"])
|
|
potentialpurple = []
|
|
requestpurple = []
|
|
potentialpurple.extend(wantpurple[:colors.craypurple])
|
|
for card in potentialpurple:
|
|
if card["name"][:-2] != wantpurple[colors.craypurple]["name"][:-2]:
|
|
requestpurple.append(card)
|
|
proceed = True
|
|
for card in requestpurple:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestpurple = []
|
|
if len(requestpurple) > 0:
|
|
for card in requestpurple:
|
|
requestcards.append(card["name"])
|
|
potentialbrown = []
|
|
requestbrown = []
|
|
potentialbrown.extend(wantbrown[:colors.craybrown])
|
|
for card in potentialbrown:
|
|
if card["name"][:-2] != wantbrown[colors.craybrown]["name"][:-2]:
|
|
requestbrown.append(card)
|
|
proceed = True
|
|
for card in requestbrown:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestbrown = []
|
|
if len(requestbrown) > 0:
|
|
for card in requestbrown:
|
|
requestcards.append(card["name"])
|
|
potentialgrey = []
|
|
requestgrey = []
|
|
potentialgrey.extend(wantgrey[:colors.craygrey])
|
|
for card in potentialgrey:
|
|
if card["name"][:-2] != wantgrey[colors.craygrey]["name"][:-2]:
|
|
requestgrey.append(card)
|
|
proceed = True
|
|
for card in requestgrey:
|
|
if card["name"] in colors.pends:
|
|
proceed = False
|
|
if not proceed:
|
|
requestgrey = []
|
|
if len(requestgrey) > 0:
|
|
for card in requestgrey:
|
|
requestcards.append(card["name"])
|
|
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 len(requestred) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon1.gif\"> x " + str(len(requestred))
|
|
if len(requestorange) + len(requestyellow) + len(requestgreen) + len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shopstring += ", "
|
|
if len(requestorange) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon2.gif\"> x " + str(len(requestorange))
|
|
if len(requestyellow) + len(requestgreen) + len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shopstring += ", "
|
|
if len(requestyellow) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon3.gif\"> x " + str(len(requestyellow))
|
|
if len(requestgreen) + len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shopstring += ", "
|
|
if len(requestgreen) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon4.gif\"> x " + str(len(requestgreen))
|
|
if len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shopstring += ", "
|
|
if len(requestblue) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon5.gif\"> x " + str(len(requestblue))
|
|
if len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shopstring += ", "
|
|
if len(requestpurple) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon6.gif\"> x " + str(len(requestpurple))
|
|
if len(requestbrown) + len(requestgrey) > 0:
|
|
shopstring += ", "
|
|
if len(requestbrown) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon7.gif\"> x " + str(len(requestbrown))
|
|
if len(requestgrey) > 0:
|
|
shopstring += ", "
|
|
if len(requestgrey) > 0:
|
|
shopstring += "<img src=\"" + variables.url + "/assets/crayons/crayon8.gif\"> x " + str(len(requestgrey))
|
|
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 len(requestred) > 0:
|
|
shoplog += "\"red\":-" + str(len(requestred))
|
|
if len(requestorange) + len(requestyellow) + len(requestgreen) + len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shoplog += ","
|
|
if len(requestorange) > 0:
|
|
shoplog += "\"orange\":-" + str(len(requestorange))
|
|
if len(requestyellow) + len(requestgreen) + len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shoplog += ","
|
|
if len(requestyellow) > 0:
|
|
shoplog += "\"yellow\":-" + str(len(requestyellow))
|
|
if len(requestgreen) + len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shoplog += ","
|
|
if len(requestgreen) > 0:
|
|
shoplog += "\"green\":-" + str(len(requestgreen))
|
|
if len(requestblue) + len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shoplog += ","
|
|
if len(requestblue) > 0:
|
|
shoplog += "\"blue\":-" + str(len(requestblue))
|
|
if len(requestpurple) + len(requestbrown) + len(requestgrey) > 0:
|
|
shoplog += ","
|
|
if len(requestpurple) > 0:
|
|
shoplog += "\"purple\":-" + str(len(requestpurple))
|
|
if len(requestbrown) + len(requestgrey) > 0:
|
|
shoplog += ","
|
|
if len(requestbrown) > 0:
|
|
shoplog += "\"brown\":-" + str(len(requestbrown))
|
|
if len(requestgrey) > 0:
|
|
shoplog += ","
|
|
if len(requestgrey) > 0:
|
|
shoplog += "\"gray\":-" + str(len(requestgrey))
|
|
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:")
|
|
for mass in sorted(variables.masscollect):
|
|
held = 0
|
|
for card in colors.cardlist:
|
|
if not card["dupe"]:
|
|
if mass in card["mass"]:
|
|
held += 1
|
|
themecount = 0
|
|
try:
|
|
allseries = 0
|
|
for series in variables.masscollect[mass]["series"]:
|
|
seriescount = 0
|
|
for deck in colors.deckkey:
|
|
if colors.deckkey[deck]["series"].lower() == series.lower():
|
|
seriescount += 1
|
|
allseries += seriescount
|
|
themecount += 20 * allseries
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
themecount += 20 * len(variables.masscollect[mass]["decks"])
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
themecount += len(variables.masscollect[mass]["singles"])
|
|
except KeyError:
|
|
pass
|
|
if held == themecount:
|
|
print(" " + mass + ": complete")
|
|
else:
|
|
print(" " + mass + ": " + str(held) + "/" + str(themecount) + " (" + str(int((float(held)/float(themecount)) * 100)) + "%)")
|
|
|
|
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 and card["dupe"] == False:
|
|
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:
|
|
realwant = []
|
|
fakewant = []
|
|
for card in theout:
|
|
if card in theirwantlist:
|
|
realwant.append(card)
|
|
else:
|
|
fakewant.append(card)
|
|
theout = realwant + fakewant
|
|
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 [end of list])"
|
|
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():
|
|
mastereddecks = []
|
|
for deck in colors.decklist:
|
|
try:
|
|
if deck["mastered"].date() == datetime.datetime.today().date():
|
|
mastereddecks.append(deck["name"])
|
|
except:
|
|
pass
|
|
if len(mastereddecks) > 0:
|
|
print(", ".join(mastereddecks))
|
|
else:
|
|
print("No decks mastered today")
|
|
|
|
def topwant(special=False):
|
|
wantedch = []
|
|
wantedsp = []
|
|
for card in colors.wantedlist:
|
|
if card["colour"] == "special":
|
|
wantedsp.append(card["name"])
|
|
else:
|
|
wantedch.append(card["name"])
|
|
showcards = int(input("How many to show? "))
|
|
if special:
|
|
print(", ".join(wantedsp[:showcards]))
|
|
else:
|
|
print(", ".join(wantedch[:showcards]))
|
|
|
|
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) + "\"]}")
|
|
|
|
def roulette():
|
|
x = "temp"
|
|
inside = random.randint(50,(12 * (datetime.datetime.today().year - datetime.datetime(2010,5,1).year) + datetime.datetime.today().month - datetime.datetime(2010,5,1).month - 50))
|
|
evenodd = random.choice(["even","odd"])
|
|
warmcool = random.choice(["warm","cool"])
|
|
print("\n<b>Inside Bet:</b> " + str(inside) + "\n\n<b>Outside Bets:</b>\n<b>Odd/Even:</b> " + evenodd + "\n<b>Warm/Cool:</b> " + warmcool)
|
|
pool = []
|
|
for card in colors.cardlist:
|
|
if card["priority"] == 4 and card["dupe"] == False and card["colour"] != "sig" and card["colour"] != "limited" and len(card["mass"]) == 0 and card["colour"] != "special":
|
|
pool.append(card["name"])
|
|
if len(pool) > 9:
|
|
chosen = sorted(random.sample(pool,10))
|
|
print("\n<b>Double Down:</b>\n<img src=\"https://colors-tcg.eu/cards/" + ".gif\"><img src=\"https://colors-tcg.eu/cards/".join(chosen) + ".gif\">\n<b>Card names:</b> " + ", ".join(chosen))
|
|
theround = input("\nRound number: ")
|
|
letteurl = input("Comment URL: ")
|
|
print("\n{\"event\":\"release roulette " + theround + "\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + letteurl + "\",\"lost\":[\"" + "\",\"".join(chosen) + "\"]}")
|
|
|
|
if __name__ == "__main__":
|
|
while True:
|
|
index = 0 # adapted from https://stackoverflow.com/a/64536882
|
|
indexValidList = []
|
|
print("Choose from the list:")
|
|
options = ["Generate next palette portfolio","Generate next monochrome portfolio","Generate Switch It Up request","Generate Swap Station request","Generate Go Fish comment","Generate Release Roulette comment","Generate Riku’s Favors 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 most wanted character cards","See most wanted special cards","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 == "Generate Riku’s Favors comment":
|
|
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()
|
|
elif chosen == "Generate Release Roulette comment":
|
|
roulette()
|
|
elif chosen == "See most wanted character cards":
|
|
topwant()
|
|
elif chosen == "See most wanted special cards":
|
|
topwant(True)
|
|
print("\n")
|
|
input("Press Enter to continue or Ctrl-C to exit")
|