1697 lines
71 KiB
Python
1697 lines
71 KiB
Python
import datetime,random,math
|
||
from collections import Counter
|
||
import colors,log,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 riku():
|
||
print("Specials")
|
||
print(dupes(True,False,False,True))
|
||
print("Characters")
|
||
print(dupes(True,False,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:
|
||
if card["priority"] == 1:
|
||
for deck in colors.decklist:
|
||
if deck["name"] == card["name"][:-2]:
|
||
if deck["mastered"]:
|
||
fishmastered.append(card)
|
||
else:
|
||
fishhp.append(card)
|
||
elif card["priority"] == 2:
|
||
if card["mass"]:
|
||
for deck in colors.decklist:
|
||
if deck["name"] == card["name"][:-2]:
|
||
if deck["mass"]:
|
||
fishmp.append(card)
|
||
else:
|
||
fishmass.append(card)
|
||
else:
|
||
fishmp.append(card)
|
||
elif card["priority"] == 3:
|
||
fishlp.append(card)
|
||
else:
|
||
fishtrade.append(card)
|
||
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:
|
||
if len(requestcards) > 0:
|
||
shoplog += ","
|
||
shoplog += "\"sketch\":-" + str(sketchdifference)
|
||
shoplog += "}"
|
||
print(shoplog)
|
||
|
||
def stats():
|
||
print("\nCollection size: " + str(len(colors.cardlist)) + " cards")
|
||
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")
|
||
|
||
|
||
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 Go Fish comment","Generate art shop request","Generate art studio request","Get a list of random cards from tradepile (excluding specials)","Get a list of random cards from tradepile (including specials)","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":
|
||
riku()
|
||
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()
|
||
print("\n")
|
||
input("Press Enter to continue or Ctrl-C to exit")
|