2037 lines
84 KiB
Python
2037 lines
84 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():
|
|
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 colors.wantedlist:
|
|
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:
|
|
thecards = wantedsp[:showcards]
|
|
else:
|
|
thecards = wantedch[:showcards]
|
|
caution = []
|
|
for card in colors.pends:
|
|
for thecard in thecards:
|
|
if thecard[:-2] == card[:-2]:
|
|
caution.append(thecard[:-2])
|
|
caution = sorted(list(dict.fromkeys(caution)))
|
|
print(", ".join(thecards))
|
|
if len(caution) > 0:
|
|
print("Caution: cards from " + ", ".join(caution) + " in pending list")
|
|
# 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) + "\"]}")
|
|
|
|
def natsume():
|
|
natsudecks = input("Paste in list of decks: ").split(", ")
|
|
natsuwant = []
|
|
natsugivech = []
|
|
natsugivesp = []
|
|
for card in colors.cardlist:
|
|
for deck in natsudecks:
|
|
for number in colors.numbers:
|
|
if card["name"] == deck + number:
|
|
if card["priority"] > 2:
|
|
if card["colour"] == "special":
|
|
natsugivesp.append(card)
|
|
else:
|
|
natsugivech.append(card)
|
|
for card in colors.wantedlist:
|
|
for deck in natsudecks:
|
|
for number in colors.numbers:
|
|
if card["name"] == deck + number:
|
|
natsuwant.append(card)
|
|
for card in natsugivech:
|
|
count = 0
|
|
for othercard in natsugivech:
|
|
if othercard["name"][:-2] == card["name"][:-2]:
|
|
count += 1
|
|
card["count"] = count
|
|
natsugivech = sorted(natsugivech, key=lambda d: d["count"],reverse=True)
|
|
natsugivech = sorted(natsugivech, key=lambda d: d["priority"],reverse=True)
|
|
for card in natsugivesp:
|
|
count = 0
|
|
for othercard in natsugivesp:
|
|
if othercard["name"][:-2] == card["name"][:-2]:
|
|
count += 1
|
|
card["count"] = count
|
|
natsugivesp = sorted(natsugivesp, key=lambda d: d["count"],reverse=True)
|
|
natsugivesp = sorted(natsugivesp, key=lambda d: d["priority"],reverse=True)
|
|
natsuwantgrouped = []
|
|
natsugivechgrouped = []
|
|
natsugivespgrouped = []
|
|
index = 0
|
|
for card in natsuwant:
|
|
if index > 0:
|
|
if card["name"][:-2] == natsuwant[index-1]["name"][:-2]:
|
|
listone.append(card)
|
|
if index + 1 == len(natsuwant):
|
|
natsuwantgrouped.append(listone)
|
|
else:
|
|
natsuwantgrouped.append(listone)
|
|
listone = []
|
|
listone.append(card)
|
|
if index + 1 == len(natsuwant):
|
|
natsuwantgrouped.append(listone)
|
|
else:
|
|
listone = []
|
|
listone.append(card)
|
|
if len(natsuwant) == 1:
|
|
natsuwantgrouped.append(listone)
|
|
index += 1
|
|
index = 0
|
|
for card in natsugivech:
|
|
if index > 0:
|
|
if card["name"][:-2] == natsugivech[index-1]["name"][:-2]:
|
|
listtwo.append(card["name"])
|
|
if index + 1 == len(natsugivech):
|
|
natsugivechgrouped.append(listtwo)
|
|
else:
|
|
natsugivechgrouped.append(listtwo)
|
|
listtwo = []
|
|
listtwo.append(card["name"])
|
|
if index + 1 == len(natsugivech):
|
|
natsugivechgrouped.append(listtwo)
|
|
else:
|
|
listtwo = []
|
|
listtwo.append(card["name"])
|
|
if len(natsugivech) == 1:
|
|
natsugivechgrouped.append(listtwo)
|
|
index += 1
|
|
index = 0
|
|
for card in natsugivesp:
|
|
if index > 0:
|
|
if card["name"][:-2] == natsugivesp[index-1]["name"][:-2]:
|
|
listthree.append(card["name"])
|
|
if index + 1 == len(natsugivesp):
|
|
natsugivespgrouped.append(listthree)
|
|
else:
|
|
natsugivespgrouped.append(listthree)
|
|
listthree = []
|
|
listthree.append(card["name"])
|
|
if index + 1 == len(natsugivesp):
|
|
natsugivespgrouped.append(listthree)
|
|
else:
|
|
listthree = []
|
|
listthree.append(card["name"])
|
|
if len(natsugivesp) == 1:
|
|
natsugivespgrouped.append(listthree)
|
|
index += 1
|
|
natsugivechgrouped = natsugivechgrouped[:5]
|
|
natsugivespgrouped = natsugivespgrouped[:5]
|
|
finalwant = []
|
|
finalgive = []
|
|
for group in natsuwantgrouped:
|
|
if group[0]["colour"] == "special":
|
|
if len(natsugivespgrouped) > 0:
|
|
if natsugivespgrouped[0][0][:-2] == group[0]["name"][:-2]:
|
|
if len(natsugivespgrouped) > 1:
|
|
group = group[:len(natsugivespgrouped[1])]
|
|
natsugivespgrouped[1] = natsugivespgrouped[1][:len(group)]
|
|
for givecard in natsugivespgrouped[1]:
|
|
finalgive.append(givecard)
|
|
natsugivespgrouped.pop(1)
|
|
for card in group:
|
|
finalwant.append(card["name"])
|
|
else:
|
|
group = group[:len(natsugivespgrouped[0])]
|
|
natsugivespgrouped[0] = natsugivespgrouped[0][:len(group)]
|
|
for givecard in natsugivespgrouped[0]:
|
|
finalgive.append(givecard)
|
|
natsugivespgrouped.pop(0)
|
|
for card in group:
|
|
finalwant.append(card["name"])
|
|
else:
|
|
if len(natsugivechgrouped) > 0:
|
|
if natsugivechgrouped[0][0][:-2] == group[0]["name"][:-2]:
|
|
if len(natsugivechgrouped) > 1:
|
|
group = group[:len(natsugivechgrouped[1])]
|
|
natsugivechgrouped[1] = natsugivechgrouped[1][:len(group)]
|
|
for givecard in natsugivechgrouped[1]:
|
|
finalgive.append(givecard)
|
|
natsugivechgrouped.pop(1)
|
|
for card in group:
|
|
finalwant.append(card["name"])
|
|
else:
|
|
group = group[:len(natsugivechgrouped[0])]
|
|
natsugivechgrouped[0] = natsugivechgrouped[0][:len(group)]
|
|
for givecard in natsugivechgrouped[0]:
|
|
finalgive.append(givecard)
|
|
natsugivechgrouped.pop(0)
|
|
for card in group:
|
|
finalwant.append(card["name"])
|
|
finalwant = finalwant[:5]
|
|
finalgive = finalgive[:5]
|
|
if len(finalwant) > 0:
|
|
print("\n<b>Name</b>: " + variables.name + "\n<b>Cards you are turning in (" + str(len(finalwant)) + "/5)</b>:\n<img src=\"https://colors-tcg.eu/cards/" + ".gif\"><img src=\"https://colors-tcg.eu/cards/".join(finalgive) + ".gif\">\n<b>Card names</b>: " + ", ".join(finalgive) + "\n<b>Cards you want</b>: " + ", ".join(finalwant))
|
|
theround = input("\nRound number: ")
|
|
natsurl = input("Comment URL: ")
|
|
print("\n{\"event\":\"natsume’s book of cards " + theround + "\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + natsurl + "\",\"lost\":[\"" + "\",\"".join(finalgive) + "\"],\"received\":[\"" + "\",\"".join(finalwant) + "\"]}")
|
|
else:
|
|
print("Nothing can be swapped")
|
|
|
|
def lsa():
|
|
thephrase = input("Phrase: ").replace(" ","").lower()
|
|
holder = []
|
|
slots = len(thephrase)
|
|
while slots > 0:
|
|
holder.append("")
|
|
slots -= 1
|
|
nospecials = []
|
|
for card in colors.wantedlist:
|
|
if card["colour"] != "special":
|
|
nospecials.append(card["name"])
|
|
for card in nospecials:
|
|
index = 0
|
|
stop = False
|
|
while index < len(thephrase):
|
|
if not stop:
|
|
if holder[index] == "":
|
|
if thephrase[index] in card[:-2]:
|
|
holder[index] = card
|
|
stop = True
|
|
index += 1
|
|
print(", ".join(holder))
|
|
theround = input("\nRound number: ")
|
|
lsaurl = input("Comment URL: ")
|
|
print("\n{\"event\":\"little spell academia " + theround + "\",\"date\":datetime.datetime(" + datetime.datetime.now().strftime("%Y,%-m,%-d") + "),\"url\":\"" + lsaurl + "\",\"received\":[\"" + "\",\"".join(holder) + "\"]}")
|
|
|
|
def recentpri():
|
|
recentcards = []
|
|
for card in colors.cardlist:
|
|
if datetime.datetime.strftime(card["received"],"%Y%m%d") == datetime.datetime.strftime(datetime.datetime.today(),"%Y%m%d") or card["received"] == datetime.datetime.strftime(datetime.datetime.today() - datetime.timedelta(days=1),"%Y%m%d"):
|
|
if card["priority"] < 4:
|
|
if card["colour"] != "sig":
|
|
recentcards.append(card["name"])
|
|
recentcards = sorted(recentcards)
|
|
if len(recentcards) > 0:
|
|
print(", ".join(recentcards))
|
|
else:
|
|
print("None received")
|
|
|
|
def acrostics(monthly=False):
|
|
startdate = input("Enter the start date (MMDD): ")
|
|
themonth = int(startdate[0:2])
|
|
theday = int(startdate[2:4])
|
|
urls = []
|
|
for event in log.log:
|
|
if event["date"].year == datetime.datetime.today().year:
|
|
if event["date"].month >= themonth:
|
|
if event["date"].day >= theday:
|
|
if "trade with " in event["event"]:
|
|
try:
|
|
if event["received"]:
|
|
urls.append(event["url"])
|
|
except:
|
|
pass
|
|
candidates = []
|
|
for event in log.log:
|
|
if event["url"] in urls:
|
|
try:
|
|
for card in event["received"]:
|
|
if "sig_" not in card:
|
|
carddict = {}
|
|
carddict["card"] = card
|
|
carddict["player"] = event["event"][11:]
|
|
carddict["url"] = event["url"]
|
|
candidates.append(carddict)
|
|
except:
|
|
pass
|
|
try:
|
|
for card in event["lost"]:
|
|
if "sig_" not in card:
|
|
carddict = {}
|
|
carddict["card"] = card
|
|
carddict["player"] = event["event"][11:]
|
|
carddict["url"] = event["url"]
|
|
candidates.append(carddict)
|
|
except:
|
|
pass
|
|
maxcards = {}
|
|
for card in candidates:
|
|
theplayer = card["player"]
|
|
if theplayer in maxcards:
|
|
maxcards[theplayer] += 1
|
|
else:
|
|
maxcards[theplayer] = 1
|
|
for player in maxcards:
|
|
maxcards[player] = int(maxcards[player] / 2)
|
|
if monthly:
|
|
word = input("Enter the monthly phrase: ").replace(" ","").replace(",","").replace("'","#").replace("-","#").lower()
|
|
else:
|
|
word = input("Enter the weekly word: ").replace(" ","").lower()
|
|
wordspace = []
|
|
places = len(word)
|
|
while places > 0:
|
|
wordspace.append("")
|
|
places -= 1
|
|
for card in candidates:
|
|
wordindex = 0
|
|
go = True
|
|
theplayer = card["player"]
|
|
if maxcards[theplayer] > 0:
|
|
for space in wordspace:
|
|
if go:
|
|
if space == "":
|
|
if len(colors.cardlist) + colors.tradepend > 800 and monthly:
|
|
if word[wordindex] == "#":
|
|
if card["card"][0] == "0" or card["card"][0] == "1" or card["card"][0] == "2" or card["card"][0] == "3" or card["card"][0] == "4" or card["card"][0] == "5" or card["card"][0] == "6" or card["card"][0] == "7" or card["card"][0] == "8" or card["card"][0] == "9":
|
|
newspace = word[wordindex].upper() + " " + card["card"] + " – <a href=\"" + card["url"] + "\">" + card["player"] + "</a>"
|
|
wordspace[wordindex] = newspace
|
|
go = False
|
|
theplayer = card["player"]
|
|
maxcards[theplayer] -= 1
|
|
else:
|
|
if card["card"][0] == word[wordindex]:
|
|
newspace = word[wordindex].upper() + " " + card["card"] + " – <a href=\"" + card["url"] + "\">" + card["player"] + "</a>"
|
|
wordspace[wordindex] = newspace
|
|
go = False
|
|
theplayer = card["player"]
|
|
maxcards[theplayer] -= 1
|
|
else:
|
|
if word[wordindex] == "#":
|
|
if "0" in card["card"] or "1" in card["card"] or "2" in card["card"] or "3" in card["card"] or "4" in card["card"] or "5" in card["card"] or "6" in card["card"] or "7" in card["card"] or "8" in card["card"] or "9" in card["card"]:
|
|
newspace = word[wordindex].upper() + " " + card["card"] + " – <a href=\"" + card["url"] + "\">" + card["player"] + "</a>"
|
|
wordspace[wordindex] = newspace
|
|
go = False
|
|
theplayer = card["player"]
|
|
maxcards[theplayer] -= 1
|
|
else:
|
|
if word[wordindex] in card["card"]:
|
|
newspace = word[wordindex].upper() + " " + card["card"] + " – <a href=\"" + card["url"] + "\">" + card["player"] + "</a>"
|
|
wordspace[wordindex] = newspace
|
|
go = False
|
|
theplayer = card["player"]
|
|
maxcards[theplayer] -= 1
|
|
wordindex += 1
|
|
remaining = []
|
|
spaceindex = 0
|
|
for space in wordspace:
|
|
if space == "":
|
|
remaining.append(word[spaceindex].upper())
|
|
spaceindex += 1
|
|
if len(remaining) > 0:
|
|
print("Still need " + ", ".join(remaining))
|
|
else:
|
|
print("\n" + "\n".join(wordspace) + "\n")
|
|
|
|
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 Natsume’s Book of Cards comment","Generate Little Spell Academia comment","Generate weekly acrostics comment","Generate monthly acrostics 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","Show wanted cards gained yesterday + today","See some statistics about the collection"]
|
|
for optionName in options:
|
|
index = index + 1
|
|
indexValidList.extend([options.index(optionName)])
|
|
print(str(index) + ") " + optionName)
|
|
inputValid = False
|
|
while not inputValid:
|
|
inputRaw = input("Option: ")
|
|
inputNo = int(inputRaw) - 1
|
|
if inputNo > -1 and inputNo < len(indexValidList):
|
|
selected = indexValidList[inputNo]
|
|
inputValid = True
|
|
break
|
|
else:
|
|
print("Select a number from the list")
|
|
chosen = options[selected]
|
|
if chosen == "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)
|
|
elif chosen == "Generate Natsume’s Book of Cards comment":
|
|
natsume()
|
|
elif chosen == "Generate Little Spell Academia comment":
|
|
lsa()
|
|
elif chosen == "Show wanted cards gained yesterday + today":
|
|
recentpri()
|
|
elif chosen == "Generate weekly acrostics comment":
|
|
acrostics()
|
|
elif chosen == "Generate monthly acrostics comment":
|
|
acrostics(True)
|
|
print("\n")
|
|
input("Press Enter to continue or Ctrl-C to exit")
|