def encode(cards):
counts = {}
for card in cards.split():
if card in counts.keys():
counts[card] += 1
else:
counts[card] = 1
cards_with_counts = [str(counts[card]) + ":" + card for card in counts.keys()]
deck = LoRDeck(cards_with_counts)
return deck.encode()
def GetCardCount(deck):
unpackedDeck = LoRDeck.from_deckcode(deck)
cardCount = 0
for card in list(unpackedDeck):
cardCount += int(card[0])
return cardCount
def deck_to_image(deckcode):
unit_images = [0]
champion_images = [0]
spell_images = [0]
deck = LoRDeck.from_deckcode(deckcode)
newdeck = [
Card(CardCode=card_string.split(':')[1],
count=card_string.split(':')[0]) for card_string in deck
]
newdeck.sort(key=lambda x: x.cost, reverse=False)
for card in newdeck:
if card.cardType == 'Unit':
if card.isChampion:
champion_images[0] += card.count
champion_images.append(make_card_image(card))
else:
unit_images[0] += card.count
unit_images.append(make_card_image(card))
else:
spell_images[0] += card.count
spell_images.append(make_card_image(card))
#im.save(card.cardCode + '.png', 'png')
final = make_final_image(champion_images, unit_images, spell_images)
return final
def decode(deck):
codes = list(LoRDeck.from_deckcode(deck))
cards = []
for code in codes:
for i in range(int(code[0])):
cards.append(code[2:])
return " ".join(cards)
def get_cards_infos_from_code(code):
deck = LoRDeck.from_deckcode(code)
cards = []
for c in deck.cards:
qte, code = str(c).split(":")
cards.append((qte, cards_infos[code]))
return cards
def deck_select(deck_code):
deck = LoRDeck.from_deckcode(deck_code)
#iterate through each card of the deck
df = []
for card in deck.cards:
d = {'cardCode': card.card_code, 'count': card.count}
df.append(d)
current_deck = pd.DataFrame(df)
current_deck = current_deck.join(all_cards.set_index('cardCode'),
on='cardCode',
how='left')
current_deck = current_deck[[
'name', 'count', 'cost', 'type', 'supertype', 'spellSpeed'
]]
current_deck.sort_values(by=['cost'], inplace=True)
deck_table = current_deck.to_html(classes='data', header="true")
round_num = 1
mana = 1
spellmana = 0
all_checked = 'checked'
return render_template('deck_test.html',
deck_table=deck_table,
round_num=round_num,
mana=mana,
spellmana=spellmana,
all_checked=all_checked,
deck_code=deck_code)
def generate_rand_deck(selected_regions: [str]) -> [str]:
"""Generates a random and valid Legends of Runeterra deck with the selected regions"""
num_champions = random.randrange(0, MAX_CHAMPIONS)
champion_codes = []
non_champion_codes = []
# separate cards from selected regions into champions and non_champions (followers/spells), store only card codes
for card in all_bundles:
if card['regionRef'] in selected_regions and card['collectible']:
if card['supertype'] == 'Champion':
champion_codes.append(card['cardCode'])
else:
non_champion_codes.append(card['cardCode'])
# store the the max amount of copies of each card in each list (3)
# TODO: better way to do this?
champion_codes = champion_codes * MAX_CARD_COPIES
non_champion_codes = non_champion_codes * MAX_CARD_COPIES
# sample champion and non-champion list adhering to the chosen number of champions for this deck
selected_champion_codes = random.sample(champion_codes, k=num_champions)
selected_non_champion_codes = random.sample(non_champion_codes,
k=MAX_DECK_SIZE -
num_champions)
new_deck_codes = selected_champion_codes + selected_non_champion_codes
# TODO: better way to pick only unique cards than cast as set?
new_deck = LoRDeck([
CardCodeAndCount(card_code, new_deck_codes.count(card_code))
for card_code in set(new_deck_codes)
])
return new_deck
def deck_filter(deck_code):
round_num = request.args['turn']
mana = request.args['mana']
spellmana = request.args['spellmana']
card_type = request.args['card_type']
#iterate through each card of the deck
deck = LoRDeck.from_deckcode(deck_code)
df = []
for card in deck.cards:
d = {'cardCode': card.card_code, 'count': card.count}
df.append(d)
current_deck = pd.DataFrame(df)
current_deck = current_deck.join(all_cards.set_index('cardCode'),
on='cardCode',
how='left')
current_deck = current_deck[[
'name', 'count', 'cost', 'type', 'supertype', 'spellSpeed'
]]
current_deck.sort_values(by=['cost'], inplace=True)
opp_deck = current_deck
if card_type == 'all_cards':
all_checked = 'checked'
fast_checked = ''
burst_checked = ''
spells = opp_deck.query(
'type=="Spell" and cost<={mana}+{spellmana}'.format(
mana=mana, spellmana=spellmana))
units = opp_deck.query(
'type=="Unit" and cost<={mana}'.format(mana=mana))
all_possible = pd.concat([spells, units])
elif card_type == 'fast':
all_checked = ''
fast_checked = 'checked'
burst_checked = ''
spells = opp_deck.query(
'type=="Spell" and spellSpeed!="Slow" and cost<={mana}+{spellmana}'
.format(mana=mana, spellmana=spellmana))
all_possible = spells
elif card_type == 'burst':
all_checked = ''
fast_checked = ''
burst_checked = 'checked'
spells = opp_deck.query(
'type=="Spell" and spellSpeed=="Burst" and cost<={mana}+{spellmana}'
.format(mana=mana, spellmana=spellmana))
all_possible = spells
deck_table = all_possible.to_html(
classes='table table-striped p-3 my-3 border table-hover',
header="true")
return render_template('deck_test.html',
deck_table=deck_table,
round_num=round_num,
mana=mana,
spellmana=spellmana,
card_type=card_type,
all_checked=all_checked,
fast_checked=fast_checked,
burst_checked=burst_checked,
deck_code=deck_code)
def generate_deck(self, code):
deck_list = LoRDeck.from_deckcode(code)
deck = []
for cnc in deck_list.cards:
for i in range(cnc.count):
cd = CardDesc()
cd.from_json(cnc.card_code)
deck.append(cd)
return deck
def add_deck_fields(self, deck_code):
deck_from_code = LoRDeck.from_deckcode(deck_code)
deck_cards = [DeckCard.get_or_create(ccac) for ccac in list(deck_from_code)]
regions = list(set(deck_card.card.region for deck_card in deck_cards))
champions = [deck_card.card for deck_card in deck_cards if deck_card.card.supertype == "Champion"]
self.regions.add(*regions)
self.deck_cards.add(*deck_cards)
self.champions.add(*champions)
def get_deck(self, deck_code):
deck = []
lor_deck = LoRDeck.from_deckcode(deck_code)
for c in list(lor_deck):
[nb, code] = c.split(":")
for _ in range(int(nb)):
card_desc = CardDesc()
card_desc.from_json(code)
deck.append(card_desc)
return deck
def deckCompiler(deckcode):
outputmsg = f">>> "
data = card_identify.cards_data
target = LoRDeck.from_deckcode(deckcode)
card_list = list(target)
for card in card_list:
subject = cardParser(card)
chunkInfo = f"**{subject['amount']} lá **- {(data[subject['cardCode']])['Name']}"
print(chunkInfo)
outputmsg += f"{chunkInfo}\n"
return generateEmbed(outputmsg, deckcode)
def test_buildFromCode(self):
deck = get_dataframe()
testDeck = deck['cardCode'].value_counts().to_dict()
f = lambda key, value: str(value) + ':' + key
cardList = []
for key, value in zip(testDeck.keys(), testDeck.values()):
cardList.append(f(key, value))
testDeck = LoRDeck(cardList)
code = testDeck.encode()
testDataframe = buildFromCode(code)
valid = deck['cardCode'].unique().tolist()
test = testDataframe['cardCode'].unique().tolist()
valid.sort()
test.sort()
for x, y in zip(valid, test):
self.assertEqual(x, y)
def buildFromCode(code):
data = get_dataframe()
deck = LoRDeck.from_deckcode(code)
# codes = [(card.card_code, card.count) for card in deck.cards]
newDeck = pd.DataFrame(columns=data.columns)
for i, card in enumerate(deck.cards):
row = data.loc[data['cardCode'] == card.card_code]
newDeck = newDeck.append(row, ignore_index=True)
newDeck.loc[i, 'count'] = int(card.count)
newDeck['count'] = newDeck['count'].astype(int)
return newDeck
def handleData(data):
global playerDeckCode
global playerDeck
if data['GameState'] == 'InProgress':
req = requests.get('http://127.0.0.1:21337/static-decklist')
deckJson = req.json()
deckCode = deckJson['DeckCode']
# get player deck
if (not playerDeck) or (playerDeckCode != deckCode):
playerDeckCode = deckCode
deck = LoRDeck.from_deckcode(deckCode)
for cardStr in deck:
card = CardCodeAndCount.from_card_string(cardStr)
playerDeck[card.card_code] = card.count
rectangles = data['Rectangles']
for rect in rectangles:
if not rect['LocalPlayer']:
continue
if rect['CardID'] in knownIDs:
continue
knownIDs.append(rect['CardID'])
cardCode = rect['CardCode']
if cardCode not in playerDeck:
continue
if playerDeck[cardCode] < 1:
continue
playerDeck[cardCode] -= 1
playerName = data['PlayerName']
printDeck(playerName)
else:
# for windows
if name == 'nt':
_ = system('cls')
# for mac and linux(here, os.name is 'posix')
else:
_ = system('clear')
print('Start a game to see your deck!')
playerDeck = {}
playerDeckCode = ""
def sv_home():
avoidTables = ['set', 'API']
# get dataframe of db
cnx = sqlite3.connect("card_data/stattracker.db")
df = pd.read_sql_query("select name from sqlite_master where type = 'table'", cnx)
# extract deck names
deckNames = []
for index, row in df.iterrows():
if row['name'] not in avoidTables:
deckNames.append(row['name'])
framesToConcat = []
for i in range(len(deckNames)):
# get stats for deck
unnamedDf = pd.read_sql_query("select * from " + deckNames[i], cnx)
# add deck name to data
# https://stackoverflow.com/a/53236864/13157180
nameCol = []
for j in range(len(unnamedDf.index)):
nameCol.append(deckNames[i])
nameDf = pd.DataFrame(nameCol, columns=['Deck Name'])
unnamedDf.append(nameDf)
# add frames to array
framesToConcat.append(pd.concat([unnamedDf, nameDf], axis=1))
# make df out of array
deckData = pd.concat(framesToConcat)
deckData.reset_index(drop=True, inplace=True) # reset indexes
# make df of cards in each deck
CardDataCardCode = []
CardDataDeckCode = []
for deckName in deckNames:
try:
deck = LoRDeck.from_deckcode(deckName)
for card in deck.cards:
CardDataCardCode.append(str(card)[2:]) # trim quantity
CardDataDeckCode.append(deckName)
except ValueError:
# Invalid deck code, skip
pass
cardData = pd.DataFrame(data={'Deck Name':CardDataDeckCode, 'Card Code':CardDataCardCode})
return render_template('statsviewer/index.html', deckData=deckData.to_json(), cardData=cardData.to_json())
def AssignStaticValues():
global playerName, opponentName, screenDimensions, activeDeck, cardsInDeck, expWins, expLosses, regions
playerName, opponentName, screenDimensions = GetGameInfo()
activeDeck, cardsInDeck = GetActiveDeck()
regions = []
deck = LoRDeck.from_deckcode(activeDeck)
for card in list(deck):
if card[4:6] == "DE" and "Demacia" not in regions:
regions.append("Demacia")
elif card[4:6] == "FR" and "Freljord" not in regions:
regions.append("Freljord")
elif card[4:6] == "IO" and "Ionia" not in regions:
regions.append("Ionia")
elif card[4:6] == "NX" and "Noxus" not in regions:
regions.append("Noxus")
elif card[4:6] == "PZ" and "Piltover & Zaun" not in regions:
regions.append("Piltover & Zaun")
elif card[4:6] == "SI" and "Shadow Isles" not in regions:
regions.append("Shadow Isles")
regions = sorted(regions)
expWins, expLosses = GetExpeditionInfo()
def __init__(self, code):
deck = LoRDeck.from_deckcode(code)
cards = []
self.champions = []
self.regions = []
self.cards_by_region = {}
for cardcode in deck:
card = CardCodeAndCount.from_card_string(cardcode)
for card_data in set_data:
if card_data["cardCode"] == cardcode[2:]:
if card_data["rarity"] == "Champion":
self.champions.append(card_data["name"])
if card_data["region"] not in self.regions:
self.regions.append(card_data["region"])
self.cards_by_region[card_data["region"]] = []
cards.append(Card(card.count, card_data))
self.cards_by_region[card_data["region"]].append(
Card(card.count, card_data))
self.cards = sorted(cards, key=lambda x: x.data["cost"])
for k, v in self.cards_by_region.items():
self.cards_by_region[k] = sorted(v, key=lambda x: x.data["cost"])
def fromUnfinishedDeck(deckCode: str,
genres: list = [basicCheck],
regions=None):
cards = []
if regions == None: tempRegion = set()
for i in LoRDeck.from_deckcode(deckCode).cards:
cards += [(i.count, i.card_code)]
if regions == None:
temp = i.faction
if temp == "IO": temp = "Ionia"
if temp == "SI": temp = "Shadow Isles"
if temp == "DE": temp = "Demacia"
if temp == "FR": temp = "Freljord"
if temp == "NX": temp = "Noxus"
if temp == "PZ": temp = "Piltover & Zaun"
tempRegion |= {temp}
if regions == None: regions = tempRegion
rDeck = Deck(*regions, *genres)
for i in cards:
rDeck.cardOverride(i[1], i[0])
return rDeck
def exportCode(deck):
col = deck['count'].apply(int).apply(str) + ':' + deck['cardCode']
deck = LoRDeck(col.to_list())
return deck.encode()
def Singleton(request):
for x in range(8):
try:
with open('cartas.csv') as csv_file:
listaCarta = list(csv.reader(csv_file))
#aqui está a lógica que vai criar um deck aleatorio com 40 cartas
#iniciando listas e contadores
listaDeck = []
novodeck = []
#imagem dos Campeoes
a = {}
#imagem dos Feiticos
b = {}
#imagem das Unidades
c = {}
copias = []
contador = 1
contadordeCampeos = 0
cor = [
'Freljord', 'Demacia', 'Ionia', 'ShadowIsles', 'PiltoverZaun',
'Noxus', 'Targon', 'Shurima', 'Vazio'
]
#escolhe 2 regiões aleatoriamentes, tem uma chance de escolher apenas uma região
escolhaCor = random.choices(cor, k=2)
#loop que escolhe uma carta aleatoria, há restrições nas escolhas
while contador < 41:
#escolhe uma carta aleatoria
pos = random.randint(1, len(listaCarta))
for x in listaDeck:
if x == listaCarta[pos][0]:
pos = random.randint(1, len(listaCarta))
#a carta deve pertencer à alguma das regiões escolhidas anteriormente e deve ser colecionável
if listaCarta[pos][2] != 'None' and (
listaCarta[pos][1] == escolhaCor[0]
or listaCarta[pos][1] == escolhaCor[1]):
#escolhe 1 carta
numeroDeCartas = 1
contador += numeroDeCartas
#o numero maximo de campeoes é 6
if listaCarta[pos][
2] == "Champion" and contadordeCampeos <= 5:
contadordeCampeos = numeroDeCartas
#o numero de cartas no deck não pode ser maior do que 40 e o numero de campeoes nao pode ser maior que 6
if contador > 41 or contadordeCampeos > 6:
contador -= numeroDeCartas
#esse laço continua ate completar o deck com 40 cartas
elif contador <= 41:
if listaCarta[pos][2] == 'Champion':
a[str(listaCarta[pos][5]) +
str(listaCarta[pos][0])] = (listaCarta[pos][6])
elif listaCarta[pos][2] != 'Champion' and listaCarta[
pos][4] == 'Unit':
c[str(listaCarta[pos][5]) +
str(listaCarta[pos][0])] = (listaCarta[pos][6])
elif listaCarta[pos][2] != 'Champion' and listaCarta[
pos][4] == 'Spell':
b[str(listaCarta[pos][5]) +
str(listaCarta[pos][0])] = (listaCarta[pos][6])
listaDeck.append(listaCarta[pos][0])
cartaENumDeCartas = str(numeroDeCartas) + ':' + str(
listaCarta[pos][3])
copias.append(str(numeroDeCartas))
novodeck.append(cartaENumDeCartas)
#print(numeroDeCartas)
if len(novodeck) == 40:
deck = LoRDeck([
novodeck[0], novodeck[1], novodeck[2], novodeck[3],
novodeck[4], novodeck[5], novodeck[6], novodeck[7],
novodeck[8], novodeck[9], novodeck[10], novodeck[11],
novodeck[12], novodeck[13], novodeck[14], novodeck[15],
novodeck[16], novodeck[17], novodeck[18], novodeck[19],
novodeck[20], novodeck[21], novodeck[22], novodeck[23],
novodeck[24], novodeck[25], novodeck[26], novodeck[27],
novodeck[28], novodeck[29], novodeck[30], novodeck[31],
novodeck[32], novodeck[33], novodeck[34], novodeck[35],
novodeck[36], novodeck[37], novodeck[38], novodeck[39]
])
#returns encoded string
data = deck.encode()
str_error = None
except:
pass
# ordenar as cartas
imagemCampeoes = []
for key in sorted(a):
imagemCampeoes.append(a[key])
imagemFeiticos = []
for key in sorted(b):
imagemFeiticos.append(b[key])
imagemUnidades = []
for key in sorted(c):
imagemUnidades.append(c[key])
#print(contador)
#print(novodeck)
return render(
request, 'Singleton.html', {
'data': data,
'imagemCampeoes': imagemCampeoes,
'imagemFeiticos': imagemFeiticos,
'imagemUnidades': imagemUnidades,
'copias': copias
})
def testingScript(printBool: bool):
success, failure = 0, 0
if printBool:
print(
"\n\t\t/+/=====================================================[ Specific Test (Shadow Isles/ Ionia) ]=====================================================\+\ \n"
)
# Test a deck with specifications
genres = [basicCheck, KBM("Ephemeral", 3), firstRegionBias]
myDeck = Deck("Shadow Isles", "Ionia", *genres)
if myDeck.fillDeck():
if printBool: myDeck.printDeckInfo()
success += 1
else:
failure += 1
print()
rCode = LoRDeck(myDeck.returnDeck())
print(rCode.encode())
del myDeck
if printBool:
print(
"\n\t\t/+/=====================================================[ Mix Test (Demacia, Freljord) ]=====================================================\+\ \n"
)
# Test the MIX genre
genres = [basicCheck, MIX(CBM(4, 5), NKBM("Frostbite", 6))]
myDeck = Deck("Freljord", "Freljord", *genres)
myDeck.cardOverride("She Who Wanders", 2)
myDeck.cardOverride("Tryndamere", 2)
myDeck.cardOverride("Braum", 2)
myDeck.cardOverride("Ashe", 2)
if myDeck.fillDeck():
if printBool: myDeck.printDeckInfo()
success += 1
else:
failure += 1
print()
rCode = LoRDeck(myDeck.returnDeck())
print(rCode.encode())
del myDeck
if printBool:
print(
"\n\t\t/+/=====================================================[ Partial Import Test (Shadow Isles, Ionia) ]=====================================================\+\ \n"
)
# Test a deck from an unfinished deck code
genres = [basicCheck, CBM(4, 5)]
myDeck = fromUnfinishedDeck("CEAQCAIFGUAQCAICBEAA", genres)
if myDeck.fillDeck():
if printBool: myDeck.printDeckInfo()
success += 1
else:
failure += 1
print()
rCode = LoRDeck(myDeck.returnDeck())
print(rCode.encode())
del myDeck
if printBool:
print(
"\n\t\t/+/=====================================================[ All Random Test ]=====================================================\+\ \n"
)
# Test a deck with no specifications, filled in by randomness
genres = randomGenreList(GENRES)
if basicCheck not in genres: genres.append(basicCheck)
randomDeck = Deck(random.choice(REGIONS), random.choice(REGIONS),
*genres)
if randomDeck.fillDeck():
if printBool: randomDeck.printDeckInfo()
success += 1
else:
failure += 1
print()
rCode = LoRDeck(randomDeck.returnDeck())
print(rCode.encode())
del randomDeck
return success, failure
# successRate["Success"] += 1
# else:
# successRate["Failure"] += 1
# del userDeck
# print(f"\nTesting finished with a { (successRate['Success']/(successRate['Success']+successRate['Failure']))*100 }% Success rate.")
# if ((successRate['Success']/(successRate['Success']+successRate['Failure']))*100) == 0 and numPulls >= 6:
# print("\n\t This deck probably chose genres that are impossible to go together.")
# userInput = input("\t Would you like to try again with the same genres? (y/n)\n")
# except MemoryError:
# print("Sorry that's too much.")
with open("deckCodes.txt", "w") as outfile:
successRate = defaultdict(int)
genres = randomGenreList(GENRES)
for i in range(10):
print(f"\n DECK {i+1}\n")
if basicCheck not in genres: genres.append(basicCheck)
randomDeck = Deck(random.choice(REGIONS), random.choice(REGIONS),
*genres)
if randomDeck.fillDeck():
randomDeck.printDeckInfo()
rCode = LoRDeck(randomDeck.returnDeck())
print(rCode.encode() + "\n")
successRate["Success"] += 1
else:
successRate["Failure"] += 1
del randomDeck
print(
f"\nTesting finished with a { (successRate['Success']/(successRate['Success']+successRate['Failure']))*100 }% Success rate."
)
def AllRandom(request):
for x in range(8):
try:
with open('cartas.csv') as csv_file:
listaCarta = list(csv.reader(csv_file))
#aqui está a lógica que vai criar um deck aleatorio com 40 cartas
#iniciando listas e contadores
listaDeck = []
novodeck = []
#imagem dos Campeoes
a = {}
#imagem dos Feiticos
b = {}
#imagem das Unidades
c = {}
copias = []
contador = 1
contadordeCampeos = 0
cor = [
'Freljord', 'Demacia', 'Ionia', 'ShadowIsles', 'PiltoverZaun',
'Noxus', 'Targon', 'Shurima', 'Vazio'
]
#escolhe 2 regiões aleatoriamentes, tem uma chance de escolher apenas uma região
escolhaCor = random.choices(cor, k=2)
#loop que escolhe uma carta aleatoria, há restrições nas escolhas
while contador < 41:
#escolhe uma carta aleatoria
pos = random.randint(1, len(listaCarta))
#a carta deve pertencer à alguma das regiões escolhidas anteriormente e deve ser colecionável
if listaCarta[pos][2] != 'None' and (
listaCarta[pos][1] == escolhaCor[0]
or listaCarta[pos][1] == escolhaCor[1]):
#escolhe um valor entre 1 e 3, esse valor vai ser a quantidade de cópias da carta escolhida
numeroDeCartas = random.randint(1, 3)
contador += numeroDeCartas
#o numero maximo de campeoes é 6
if listaCarta[pos][
2] == "Champion" and contadordeCampeos < 6:
contadordeCampeos = numeroDeCartas
#o numero de cartas no deck não pode ser maior do que 40 e o numero de campeoes nao pode ser maior que 6
if contador > 41 or contadordeCampeos > 6:
contador -= numeroDeCartas
#esse laço continua ate completar o deck com 40 cartas
elif contador <= 41:
if listaCarta[pos][2] == 'Champion':
a[str(listaCarta[pos][5]) +
str(listaCarta[pos][0])] = (listaCarta[pos][6])
elif listaCarta[pos][2] != 'Champion' and listaCarta[
pos][4] == 'Unit':
c[str(listaCarta[pos][5]) +
str(listaCarta[pos][0])] = (listaCarta[pos][6])
elif listaCarta[pos][2] != 'Champion' and listaCarta[
pos][4] == 'Spell':
b[str(listaCarta[pos][5]) +
str(listaCarta[pos][0])] = (listaCarta[pos][6])
cartaENumDeCartas = str(numeroDeCartas) + ':' + str(
listaCarta[pos][3])
for x in novodeck:
if x == cartaENumDeCartas:
novodeck.remove(x)
novodeck.append(cartaENumDeCartas)
deck = LoRDeck(novodeck[:len(novodeck)])
data = deck.encode()
str_error = None
except:
pass
# ordenar as cartas
imagemCampeoes = []
for key in sorted(a):
imagemCampeoes.append(a[key])
imagemFeiticos = []
for key in sorted(b):
imagemFeiticos.append(b[key])
imagemUnidades = []
for key in sorted(c):
imagemUnidades.append(c[key])
return render(
request, 'AllRandom.html', {
'data': data,
'imagemCampeoes': imagemCampeoes,
'imagemFeiticos': imagemFeiticos,
'imagemUnidades': imagemUnidades,
'copias': copias
})
from lor_deckcodes import LoRDeck
from postgres import Postgres
import pandas as pd
import sys
from scipy.stats import hypergeom
import numpy as np
# Decoding
deck = LoRDeck.from_deckcode(sys.argv[1])
# list all cards with card format 3:01SI001
print(list(deck))
def sql_output_as_dataframe(output) -> list:
return [
pd.DataFrame(result[0], columns=[x[0] for x in result[1]]) for result in output
]
with Postgres("dev/guillaumelegoy") as conn:
deck_info = []
card_codes = []
card_count = {}
for card in list(deck):
card_codes.append(card[-7:])
card_count[card[-7:]] = card[:1]
card_count = pd.DataFrame.from_dict(card_count, orient="index").reset_index()
# import neccessary libraries
import pandas as pd
from add_cards import all_cards
from lor_deckcodes import LoRDeck, CardCodeAndCount
#import seleniumtest
#load all decks
all_decks = pd.read_csv('results.csv')
#create list of all deck codes
all_deck_codes = all_decks['deck_code'].to_list()
#itirate through deck codes
deck_details = []
for deck_code in all_deck_codes:
deck = LoRDeck.from_deckcode(deck_code)
#iterate through each card of the deck
df = []
for card in deck.cards:
d = {'cardCode': card.card_code, 'count': card.count}
df.append(d)
current_deck = pd.DataFrame(df)
current_deck = current_deck.join(all_cards.set_index('cardCode'),
on='cardCode',
how='left')
deck_champions = current_deck.loc[
(current_deck['supertype'] == 'Champion')
& (current_deck['type'] == 'Unit')].drop_duplicates()
deck_champions = deck_champions['name'].drop_duplicates()
deck_regions = current_deck['region'].drop_duplicates()
#find region 1
keywordDict[card["region"]] |= set([hiddenKey])
keywordDict[card["region"]] |= set(card["keywords"])
masterDeck = [Card(c) for c in parsed]
for i in range(len(masterDeck) + 1):
card = random.choice(masterDeck)
if basicCheck(card, myDeck, "Ionia"):
myDeck.addCard(card, "Ionia")
if basicCheck(card, myDeck, "Shadow Isles"):
myDeck.addCard(card, "Shadow Isles")
# for card in parsed:
# keywordDict[card["region"]] = dict.fromkeys(keywordDict[card["region"]], 1)
# for card in parsed:
# for keyword in card["keywords"]:
# keywordDict[card["region"]][keyword] += 1
#
# rString = ""
# for region, data in keywordDict.items():
# rString += f"{region}: "
# for key, count in data.items():
# rString += f"{key}[{count}], "
# rString = rString[:-2]
# rString += "\n"
# print(rString)
print(myDeck)
print(repr(myDeck))
print(len(myDeck))
print(myDeck.returnDeck())
deckCode = LoRDeck(myDeck.returnDeck())
print(deckCode.encode())
from django.shortcuts import render, HttpResponse, redirect
from lor_deckcodes import LoRDeck, CardCodeAndCount
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
import json
import os
script_dir = os.path.dirname(__file__)
file_path = os.path.join(script_dir, 'static/returning_app/js/set1-en_us.json')
with open(file_path, 'r') as f:
data = json.load(f)
deck = LoRDeck.from_deckcode('CEBAGAIDBMKS6BYBAUGBEFIXFAXC6AIEAECQIKRLGEBACAIDFIAQCBID')
def index(request):
page = request.GET.get('page', 1)
paginator = Paginator(data, 42)
try:
cards = paginator.page(page)
except PageNotAnInteger:
cards = paginator.page(1)
except EmptyPage:
cards = paginator.page(paginator.num_pages)
return render(request, "returning_app/index.html", { 'cards' : cards} )
#o numero de cartas no deck não pode ser maior do que 40 e o numero de campeoes nao pode ser maior que 6
if contador > 41 or contadordeCampeos > 6:
contador -= numeroDeCartas
#esse laço continua ate completar o deck com 40 cartas
elif contador <= 41:
if listaCarta[pos][2] == 'Champion':
imagemCampeoes[str(listaCarta[pos][5]) + str(listaCarta[pos][0])] = (listaCarta[pos][6])
elif listaCarta[pos][2] != 'Champion' and listaCarta[pos][4] == 'Unit':
imagemUnidades[str(listaCarta[pos][5]) + str(listaCarta[pos][0])] = (listaCarta[pos][6])
elif listaCarta[pos][2] != 'Champion' and listaCarta[pos][4] == 'Spell':
imagemFeiticos[str(listaCarta[pos][5]) + str(listaCarta[pos][0])] = (listaCarta[pos][6])
listaDeck.append(listaCarta[pos][0])
cartaENumDeCartas = str(numeroDeCartas) + ':' + str(listaCarta[pos][3])
novodeck.append(cartaENumDeCartas)
deck = LoRDeck(novodeck[:len(novodeck)])
result = str(deck.encode())
str_error = None
except Exception:
pass
a = []
for key in sorted(imagemUnidades):
a.append(imagemUnidades[key])
print(result)
print(rCode.encode())
del randomDeck
return success, failure
# successRate = defaultdict(int)
# for tests in range(10):
# k,v = testingScript(True)
# successRate["Success"] += k
# successRate["Failure"] += v
# print(f"\nTesting finished with a { (successRate['Success']/(successRate['Success']+successRate['Failure']))*100 }% Success rate.")
savepath = Path(os.getcwd()[:-7] +
"/src/main/resources/") / "deckCodes.txt"
with open(os.path.join(os.path.expanduser('~'), savepath), "w") as outfile:
successRate = defaultdict(int)
genres = randomGenreList(GENRES)
for i in range(10):
if basicCheck not in genres: genres.append(basicCheck)
randomDeck = Deck(random.choice(REGIONS), random.choice(REGIONS),
*genres)
if randomDeck.fillDeck():
rCode = LoRDeck(randomDeck.returnDeck())
outfile.write(rCode.encode() + "\n")
successRate["Success"] += 1
else:
successRate["Failure"] += 1
del randomDeck
print(
f"\nTesting finished with a { (successRate['Success']/(successRate['Success']+successRate['Failure']))*100 }% Success rate."
)
