randomizer.py

from tkinter import *
from tkinter import messagebox
from tkinter import ttk
from specialCard import SpecialCard
from standardCard import StandardCard
from prophecyCard import ProphecyCard
from allyCard import AllyCard
import csv
import random
import os
from PIL import ImageTk, Image

root = Tk()
root.title('Dominion Card Randomizer')
root.configure(background="#f0d5b6")

expandedSets = ['Dominion First', 'Dominion Second', 'Intrigue First', 'Intrigue Second', 'Seaside First', 'Seaside Second', 'Alchemy', 'Prosperity First', 'Prosperity Second','Cornucopia & Guilds First',
                'Cornucopia & Guilds Second', 'Hinterlands First', 'Hinterlands Second', 'Dark Ages', 'Adventures', 'Empires', 'Nocturne', 'Renaissance', 'Menagerie', 'Allies', 'Plunder', 'Rising Sun', 'Promo']

sets = {}
for name in expandedSets:
    sets[name] = BooleanVar(value=False)

frameStyle = ttk.Style()
frameStyle.configure("TFrame", background = "#f0d5b6")
checkStyle = ttk.Style()
checkStyle.configure("TCheckbutton", background = "#f0d5b6", font = ("Arial", 18))
labelStyle = ttk.Style()
labelStyle.configure("TLabel", background = "#f0d5b6",font = ("Arial", 18))
RadioStyle = ttk.Style()
RadioStyle.configure("TRadiobutton", background = "#f0d5b6", font = ("Arial", 18))

leftframe = ttk.Frame(root, padding="3 3 12 12")
leftframe.grid(column = 0, row = 0, sticky=(N, W, E, S))
rightframe = ttk.Frame(root, padding="3 3 12 12")
rightframe.grid(column = 1, row = 0, sticky=(N, W, E, S))
selectorframe = ttk.Frame(leftframe, padding="3 3 12 12", style="TFrame")
selectorframe.grid(column=0, row=0, sticky=(N, W, E, S))
baseframe = ttk.Frame(rightframe,borderwidth=5, relief="ridge")
baseframe.grid(column=0, row=0, sticky=(N, W, E, S))
setModifierframe = ttk.Frame(rightframe,borderwidth = 5, relief="ridge", style="TFrame")
setModifierframe.grid(column = 1, row = 0, columnspan=2, sticky = (N, W, E, S))
horizontalSetModifierframe = ttk.Frame(rightframe,borderwidth = 5, relief="ridge", style="TFrame")
horizontalSetModifierframe.grid(column=1, row=1, sticky = (N, W, E, S))
specialframe = ttk.Frame(rightframe,borderwidth=5, relief="ridge", style="TFrame")
specialframe.grid(column = 0, row = 1, sticky=(N, W, E, S))
root.columnconfigure(0, weight=1)
root.columnconfigure(1, weight=3)

def submit():
    # Generate all available cards in selected sets
    resetFrame()
    if checkForAttackCollision():
        return
    baseCards = fillBaseLibrary(sets)
    if checkForMinimumCards(baseCards):
        return
    specialCards = fillSpecialLibrary(sets)
    prophecyCards = fillProphecyLibrary(sets)
    allyCards = fillAllyLibrary(sets)

    # Select random cards from available cards
    selectedBaseCards = sortCards(selectBaseCards(baseCards))
    selectedSpecialCards = sortCards(selectSpecialCards(specialCards))

    if checkForOmen(selectedBaseCards):
        selectedProphecy = (selectProphecy(prophecyCards))
        if checkForApproachingArmy(selectedProphecy, baseCards, selectedBaseCards) and excludeAttackToggle.get():
            selectedProphecy = rerollProphecy(prophecyCards)
        prophecySpace = generateProphecy()
        prophecySpace.config(image=selectedProphecy.image, text = selectedProphecy.name)
        prophecySpace.image = selectedProphecy.image

    if checkForLiaison(selectedBaseCards):
        selectedAlly = (selectAlly(allyCards))
        allySpace = generateAlly()
        allySpace.config(image=selectedAlly.image, text = selectedAlly.name)
        allySpace.image = selectedAlly.image
    
    checkProsperity(selectedBaseCards)
    checkDarkAges(selectedBaseCards)
    checkAlchemy(selectedBaseCards)
    checkLooter(selectedBaseCards)
    checkLoot(selectedBaseCards, selectedSpecialCards)
    checkSpoils(selectedBaseCards)
    checkForGhost(selectedBaseCards)
    checkForImp(selectedBaseCards)
    checkForWillOWhisp(selectedBaseCards)
    checkForWish(selectedBaseCards)
    checkForFerryman(selectedBaseCards, baseCards)
    checkForYoungWitch(selectedBaseCards, baseCards)
    checkForWayOfTheMouse(selectedSpecialCards, baseCards, selectedBaseCards)
    checkFate(selectedBaseCards)
    checkDoom(selectedBaseCards)
    
    # Prepare cards for UI display
    generateBaseCards(selectedBaseCards)
    generateSpecialCards(selectedBaseCards,selectedSpecialCards)

def fillBaseLibrary(setDictionary):
    cardList = set (())
    with open('standardCards.csv') as csvfile:
        reader = csv.reader(csvfile)
        for row in reader:
            for key, value in setDictionary.items():
                if value.get() == True:
                    if row[5] in key:                        
                        if "First" in key:
                            strippedCard = key[:-6]
                            edition = key[-5:]
                            if row[5] == strippedCard and row[4] == edition or row[4] == "Base":
                                if "+2 Actions" in row[6]:
                                  cardList.add(StandardCard(row[0],int(row[1]),row[2],row[3],row[4],row[5],row[6],None,True))
                                else:  
                                    cardList.add(StandardCard(row[0],int(row[1]),row[2],row[3],row[4],row[5],row[6]))
                        if "Second" in key:
                            strippedCard = key[:-7]
                            edition = key[-6:]
                            if row[5] == strippedCard and row[4] == edition or row[4] == "Base":
                                if "+2 Actions" in row[6]:
                                  cardList.add(StandardCard(row[0],int(row[1]),row[2],row[3],row[4],row[5],row[6],None,True))
                                else:  
                                    cardList.add(StandardCard(row[0],int(row[1]),row[2],row[3],row[4],row[5],row[6]))
                        else:
                            if row[5] == key:
                                if "+2 Actions" in row[6]:
                                  cardList.add(StandardCard(row[0],int(row[1]),row[2],row[3],row[4],row[5],row[6],None,True))
                                else:  
                                    cardList.add(StandardCard(row[0],int(row[1]),row[2],row[3],row[4],row[5],row[6]))
    addImage(cardList)
    return cardList

def fillSpecialLibrary(setDictionary):
    cardList = set(())
    with open('specialCards.csv') as csvfile:
        reader = csv.reader(csvfile)
        for row in reader:
            for key, value in setDictionary.items():
                if value.get() == True:
                    if key.endswith("Base"):
                        edition = key[-5:]
                        if row[2] == edition:
                            cardList.add(SpecialCard(row[0], row[1], row[2], row[3], row[4]))
                    if "First" in key:
                        edition = key[-6:]
                        if row[2] == edition or row[2] == "Base":
                            cardList.add(SpecialCard(row[0], row[1], row[2], row[3], row[4]))
                    if "Second" in key:
                        edition = key[-7:]
                        if row[2] == edition or row[2] == "Base":
                            cardList.add(SpecialCard(row[0], row[1], row[2], row[3], row[4]))
                    else:
                        if row[2] == key:
                            cardList.add(SpecialCard(row[0], row[1], row[2], row[3], row[4]))
                    
    addImage(cardList)                
    return cardList

def addImage (cardList):
    for card in cardList:
        if isinstance(card,StandardCard):
            width = 200
            height = 320
        else:
            width = 320
            height = 200

        directory = "cardImages\\"+shortenTitle(card.set)
        with os.scandir(directory) as entries:
            for entry in entries:
                cleanEntry = entry.path.lower().split("px")[1]
                if cleanName(card) == cleanEntry:
                    img = Image.open(entry.path)
                    resizedPhoto = img.resize((width, height), Image.LANCZOS)
                    photo = ImageTk.PhotoImage(resizedPhoto)
                    card.image = photo

# Strips everything but the first word in the expansion
def shortenTitle (expansion):
    return expansion.split(" ",1)[0]

def cleanName(card):
    return card.name.replace(" ","").lower() + ".jpg"

def fillProphecyLibrary(setDictionary):
    cardList = []
    with open('prophecyCards.csv') as csvfile:
        reader = csv.reader(csvfile)
        for row in reader:
            for key, value in setDictionary.items():
                if value.get() == True:
                    if row[2] == key:
                        cardList.append(ProphecyCard(row[0], row[1], row[2]))
    addImage(cardList)                
    return cardList

def fillAllyLibrary(setDictionary):
    cardList = []
    with open('allyCards.csv') as csvfile:
        reader = csv.reader(csvfile)
        for row in reader:
            for key, value in setDictionary.items():
                if value.get() == True:
                    if row[2] == key:
                        cardList.append(AllyCard(row[0], row[1], row[2]))
    addImage(cardList)                
    return cardList

def selectBaseCards(cardList):
    selectedCards = set(())
    if len(cardList) > 0:
        while len(selectedCards) < 10:
            randomCard = random.choice(list(cardList))
            selectedCards.add(randomCard)
        excludeAttack(cardList, selectedCards)
        checkAttack(cardList,selectedCards)
        checkVillage(cardList,selectedCards)
        checkCostCurve(cardList,selectedCards)

    # for card in selectedCards:
    #     print(card.name)
    return selectedCards

def selectSpecialCards(cardList):
    selectedCards = set(())
    if len(cardList) > 0:
        while len(selectedCards) < eventNumber.get():  
            if len(selectedCards) == eventNumber.get() or len(cardList) == 0 or len(selectedCards) == len(cardList):
                break
            randomCard = random.choice(list(cardList))
            selectedCards.add(randomCard)
            if len(cardList) < eventNumber.get():
                messagebox.showwarning("Not enough special cards", "There are not enough special cards in the set to fulfill your request")
            
    return selectedCards

def sortCards (cardSet):
    cardList = []
    for card in cardSet:
        cardList.append(card)
    cardList.sort(key=cardCost)
    return cardList

def excludeAttack(cardList, selectedCards):
    attackCards = []
    if len(selectedCards) == 10 and excludeAttackToggle.get() and lookForAttack(selectedCards):
        while lookForAttack(selectedCards):
            for card in selectedCards:
                if "Attack" in card.type:
                    attackCards.append(card) 
            if len(attackCards) > 0:
                for card in attackCards:
                    selectedCards.remove(card)
            while len(selectedCards) < 10:                           
                randomCard = random.choice(list(cardList))
                while "Attack" in randomCard.type:
                    randomCard = random.choice(list(cardList))
                selectedCards.add(randomCard)

def checkAttack(cardList, selectedCards):
    if len(selectedCards) == 10 and includeAttackToggle.get() and not lookForAttack(selectedCards):
                selectedCards.pop()
                randomCard = random.choice(list(cardList))
                while "Attack" not in randomCard.type:
                    randomCard = random.choice(list(cardList))
                selectedCards.add(randomCard)

def checkVillage(cardList, selectedCards):
    if len(selectedCards) == 10 and villageToggle.get() and not lookForVillage(selectedCards):
                if includeAttackToggle.get():
                    removedCard = selectedCards.pop()
                    while "Attack" in removedCard.type:
                        selectedCards.add(removedCard)
                        removedCard = selectedCards.pop()
                else:
                    selectedCards.pop()
                randomCard = random.choice(list(cardList))
                if includeAttackToggle.get():
                    while randomCard.village != True or "Attack" in randomCard.type:
                        randomCard = random.choice(list(cardList))
                else:
                    while randomCard.village != True:
                        randomCard = random.choice(list(cardList))
                selectedCards.add(randomCard)

def checkCostCurve(cardList,selectedCards):
    # Checks if cost curve is possible
    allCardsRequired = True
    totalCardCosts = []
    for card in cardList:
        totalCardCosts.append(card.cost)
    for i in range (2,6):
        if totalCardCosts.count(i) == 0:
            allCardsRequired = False
            if curveToggle.get():
                messagebox.showwarning("Not enough values", "There are not enough cards that cost between 2-5")
            return
    if len(selectedCards) == 10 and curveToggle.get() and allCardsRequired:
        cardCosts = []
        for card in selectedCards:
            cardCosts.append(card.cost)
        # Check for any missing costs
        for i in range (2,6):
            if cardCosts.count(i) == 0:
                missingCost = i
                # Check for duplicate cost card and remove it
                for i in range(2,6):
                    if cardCosts.count(i) > 1:
                        for card in selectedCards:
                            if includeAttackToggle.get() and "Attack" in card.type:
                                continue
                            if villageToggle.get() and card.village == True:
                                continue
                            if card.cost == i:
                                selectedCards.remove(card)
                                break
                        # Add another card that is the needed cost
                        randomCard = random.choice(list(cardList))
                        if excludeAttackToggle.get() and villageToggle.get():
                            while randomCard.cost != missingCost and "Attack" in randomCard.type and randomCard.village == True:
                                randomCard = random.choice(list(cardList))
                        elif excludeAttackToggle.get():
                            while randomCard.cost != missingCost and "Attack" in randomCard.type:
                                randomCard = random.choice(list(cardList))
                        elif villageToggle.get():
                            while randomCard.cost != missingCost and randomCard.village == True:
                                randomCard = random.choice(list(cardList))
                        else:
                            while randomCard.cost != missingCost:
                                randomCard = random.choice(list(cardList))
                        selectedCards.add(randomCard)

def checkProsperity(selectedCards):
    for card in selectedCards:
        if card.set == "Prosperity":
            rawImage = Image.open("cardImages\\Extras\\Colony-Platinum.png")
            fixedImage = ImageTk.PhotoImage(rawImage)
            colonyPlatinum = generateColonyPlatinum()
            colonyPlatinum.configure(image = fixedImage)
            colonyPlatinum.image = fixedImage

def checkDarkAges(selectedCards):
    for card in selectedCards:
        if "Dark Ages" in card.set:
            rawImage = Image.open("cardImages\\Extras\\Shelters.webp")
            fixedImage = ImageTk.PhotoImage(rawImage)
            shelters = generateShelters()
            shelters.configure(image = fixedImage)
            shelters.image = fixedImage

def checkAlchemy(selectedCards):
    for card in selectedCards:
        if "Alchemy" in card.set:
            rawImage = Image.open("cardImages\\Extras\\Potion.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            potion = generatePotion()
            potion.configure(image = fixedImage)
            potion.image = fixedImage

def checkLooter(selectedCards):
    for card in selectedCards:
        if "Looter" in card.type:
            rawImage = Image.open("cardImages\\Extras\\Ruins.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            ruin = generateRuin()
            ruin.configure(image = fixedImage)
            ruin.image = fixedImage

def checkLoot(baseCards, specialCards):
    lootNeeded = False
    for card in baseCards:
        if "Loot" in card.text:
            lootNeeded = True
    if lootNeeded == False:
        for card in specialCards:
            if "Loot" in card.text:
                lootNeeded = True
    if lootNeeded == True:
        rawImage = Image.open("cardImages\\Extras\\Loot.jpg")
        fixedImage = ImageTk.PhotoImage(rawImage)
        loot = generateLoot()
        loot.configure(image = fixedImage)
        loot.image = fixedImage

def checkSpoils(selectedCards):
    for card in selectedCards:
        if "Spoils" in card.text:
            rawImage = Image.open("cardImages\\Extras\\Spoils.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            spoils = generateSpoils()
            spoils.configure(image = fixedImage)
            spoils.image = fixedImage

def checkForFerryman (selectedCards, cardList):
    for card in selectedCards:
        if card.name == "Ferryman":
            possibleCards = []
            for card in cardList:
                if (card.cost == 3 or card.cost == 4) and card not in selectedCards:
                    possibleCards.append(card)
            cardLabel = generateFerryman()
            randomCard = possibleCards[random.randrange(0,len(possibleCards))]
            cardLabel.config(image = randomCard.image, text = randomCard.name)
            cardLabel.image = randomCard.image

def checkForYoungWitch (selectedCards, cardList):
    for card in selectedCards:
        if card.name == "Young Witch":
            possibleCards = []
            for card in cardList:
                if (card.cost == 2 or card.cost == 3) and card not in selectedCards:
                    possibleCards.append(card)
            cardLabel = generateYoungWitch()
            randomCard = possibleCards[random.randrange(0,len(possibleCards))]
            cardLabel.config(image = randomCard.image, text = randomCard.name)
            cardLabel.image = randomCard.image

def checkForGhost (selectedCards):
    for card in selectedCards:
        if card.name == "Cemetery" or card.name == "Exorcist":
            rawImage = Image.open("cardImages\\Extras\\Ghost.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            ghost = generateGhost()
            ghost.configure(image = fixedImage)
            ghost.image = fixedImage

def checkForImp (selectedCards):
    for card in selectedCards:
        if card.name == "Devil's Workshop" or card.name == "Tormentor" or card.name == "Exorcist":
            rawImage = Image.open("cardImages\\Extras\\Imp.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            imp = generateImp()
            imp.configure(image = fixedImage)
            imp.image = fixedImage

def checkForWillOWhisp (selectedCards):
    for card in selectedCards:
        if card.name == "Exorcist":
            rawImage = Image.open("cardImages\\Extras\\Will-o'-Wisp.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            wisp = generateWillOWhisp()
            wisp.configure(image = fixedImage)
            wisp.image = fixedImage

def checkForWish (selectedCards):
    for card in selectedCards:
        if card.name == "Leprechaun" or card.name == "Secret Cave":
            rawImage = Image.open("cardImages\\Extras\\Wish.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            wish = generateWish()
            wish.configure(image = fixedImage)
            wish.image = fixedImage

def checkForWayOfTheMouse (specialCards, cardList, basecards):
    for card in specialCards:
        if card.name == "Way of the Mouse":
            possibleCards = []
            for card in cardList:
                if (card.cost == 2 or card.cost == 3) and "Duration" not in card.type and card not in basecards:
                    possibleCards.append(card)
            cardLabel = generateMouse()
            randomCard = possibleCards[random.randrange(0,len(possibleCards))]
            cardLabel.config(image = randomCard.image, text = randomCard.name)
            cardLabel.image = randomCard.image

def checkForApproachingArmy (prophecy, cardList, basecards):
    if prophecy.name == "Approaching Army":
        possibleCards = []
        for card in cardList:
            if "Attack" in card.type and card not in basecards:
                possibleCards.append(card)
        cardLabel = generateApproachingArmy()
        randomCard = possibleCards[random.randrange(0,len(possibleCards))]
        cardLabel.config(image = randomCard.image, text = randomCard.name)
        cardLabel.image = randomCard.image
        return True
    return False

def checkFate(selectedCards):
    for card in selectedCards:
        if "Fate" in card.type:
            rawImage = Image.open("cardImages\\Extras\\Will-o'-Wisp.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            wisp = generateWillOWhisp()
            wisp.configure(image = fixedImage)
            wisp.image = fixedImage

            rawImage = Image.open("cardImages\\Extras\\Boon.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            boons = generateBoon()
            boons.configure(image = fixedImage)
            boons.image = fixedImage

def checkDoom(selectedCards):
    for card in selectedCards:
        if "Doom" in card.type:
            rawImage = Image.open("cardImages\\Extras\\Hex.jpg")
            fixedImage = ImageTk.PhotoImage(rawImage)
            hexes = generateHex()
            hexes.configure(image = fixedImage)
            hexes.image = fixedImage

def cardCost (StandardCard):
    return StandardCard.cost

def selectProphecy (cardList: list[ProphecyCard]):
    return random.choice(list(cardList))

def selectAlly (cardList: list[AllyCard]):
    return random.choice(list(cardList))

def rerollProphecy (prophecyList):
    randomCard = prophecyList[random.randrange(0,len(prophecyList))]
    while randomCard.name == "Approaching Army":
        randomCard = prophecyList[random.randrange(0,len(prophecyList))]
    return randomCard   

def resetFrame():
    for card in baseframe.winfo_children():
        card.destroy()
    for card in specialframe.winfo_children():
        card.destroy()
    for card in setModifierframe.winfo_children():
        card.destroy()    
    for card in horizontalSetModifierframe.winfo_children():
        card.destroy()

def checkForOmen (cardList):
    for card in cardList:
        if 'Omen' in card.type:
            return True
    return False

def checkForLiaison (cardList):
    for card in cardList:
        if 'Liaison' in card.type:
            return True
    return False

def checkForAttackCollision():
    if excludeAttackToggle.get() and includeAttackToggle.get():
        messagebox.showerror("Invalid option", "Both Include Attacks and Exclude Attacks are selected")
        return True
    return False

def checkForMinimumCards(cardList):
    if len(cardList) < 10:
        messagebox.showerror("Set error", "Not enough cards to generate a full set")
        return True
    return False

def lookForAttack (cardSet):
    for card in cardSet:
        if 'Attack' in card.type:
            return True
    return False

def lookForVillage (cardSet):
    for card in cardSet:
        if card.village == True:
            return True
    return False

# Generate checkboxes and place on grid
checkboxes = []
gridRow = 0
for name in expandedSets:
    pogCheck = ttk.Checkbutton(selectorframe, text=name, variable=sets[name], style="TCheckbutton").grid(column = 0, row = gridRow, sticky=W)
    checkboxes.append(pogCheck)
    gridRow = gridRow + 1

eventCountLabel = ttk.Label(selectorframe, text="Event number", style="TLabel")
eventCountLabel.grid(column=0, row=100, sticky=W)
eventNumber = IntVar()
for i in range(5):
    radio = ttk.Radiobutton(selectorframe, text = i, variable = eventNumber, value = i, style="TRadiobutton")
    radio.grid(column=0, row=101 + i,sticky=W)

excludeAttackToggle = BooleanVar()
excludeAttackCheck = ttk.Checkbutton(selectorframe, text = "Exclude attacks", variable = excludeAttackToggle)
excludeAttackCheck.grid(column = 0, row = 112, sticky = W)

includeAttackToggle = BooleanVar()
includeAttackCheck = ttk.Checkbutton(selectorframe, text = "Include at least one attack", variable = includeAttackToggle)
includeAttackCheck.grid(column=0, row = 113, sticky=W)

villageToggle = BooleanVar()
villageCheck = ttk.Checkbutton(selectorframe, text = "Include +2 Actions", variable = villageToggle)
villageCheck.grid(column=0, row=114, sticky=W)

curveToggle = BooleanVar()
curveCheck = ttk.Checkbutton(selectorframe, text = "Guarantee 2-5 cost curve", variable = curveToggle)
curveCheck.grid(column = 0, row = 115, sticky = W)

submitButton = ttk.Button(selectorframe,text='Submit', command=submit,).grid(column = 0, row = 200)

def generateBaseCards(selectedBasecards):
    gridCol = 0
    gridRow = 0
    for i in range(len(selectedBasecards)):
        if i == 5:
            gridCol = 0
            gridRow = 1      
        cardframe = ttk.Frame(baseframe)
        cardframe.grid(column=gridCol, row=gridRow, sticky=(N,W,E,S))
        gridCol = gridCol + 1
        basecard = ttk.Label(cardframe, image=selectedBasecards[i].image, text=selectedBasecards[i].name)
        basecard.image = selectedBasecards[i].image
        basecard.grid(column = 0, row = 0)
        basecardLabel = ttk.Label(cardframe, text = selectedBasecards[i].set)
        basecardLabel.config(font=("Arial", 12, "bold"))
        basecardLabel.grid(column = 0, row = 1, pady=(5,15))

def generateSpecialCards(selectedBasecards ,selectedSpecialcards):
    gridCol = 0
    gridRow = 0
    availableCards = selectedBasecards
    for i in range(len(selectedSpecialcards)):     
        cardframe = ttk.Frame(specialframe)
        cardframe.grid(column=gridCol, row=gridRow, sticky=(N,W,E,S), pady = (0,7))
        gridCol = gridCol + 1
        specialcard = ttk.Label(cardframe, image=selectedSpecialcards[i].image, text=selectedSpecialcards[i].name)
        specialcard.image = selectedSpecialcards[i].image
        specialcard.grid(column = 0, row = 0)
        specialcardLabel = ttk.Label(cardframe, text = selectedSpecialcards[i].set)
        specialcardLabel.config(font=("Arial", 10, "bold"))
        specialcardLabel.grid(column = 0, row = 1)
        if selectedSpecialcards[i].type == "Trait":
            availableCards.remove(assignTrait(cardframe, availableCards))  

def assignTrait(cardframe, selectedBasecards):
    cleanedList = []
    for card in selectedBasecards:
        if "Action" in card.type or "Treasure" in card.type:
            cleanedList.append(card)
    selectedCard = random.choice(cleanedList)
    traitLabel = ttk.Label(cardframe, text = "Applies to "+ selectedCard.name)
    traitLabel.config(font=("Arial", 10))
    traitLabel.grid(column = 0, row = 2, pady = (0,5))
    return selectedCard

def generateProphecy():
    prophecyCard = ttk.Label(specialframe, image=None, text = None)
    prophecyCard.grid(column = 1, row = 3)
    return prophecyCard

def generateAlly():
    allyCard = ttk.Label(specialframe, image=None, text = None)
    allyCard.grid(column=0, row = 3)
    return allyCard

def generateColonyPlatinum():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 0, row = 0)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(setModifierframe, text="Colonies and Platinums needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateShelters():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 1, row = 0)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Shelters needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generatePotion():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 3, row = 0)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Potions needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateLoot():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 4, row = 0)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Loot needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateFerryman():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 1, row = 2)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Ferried Card")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateYoungWitch():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 1, row = 2)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Young Witch's Bane")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateMouse():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 2, row = 2)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Way of the Mouse Card")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateApproachingArmy():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 3, row = 2)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Approaching Army Card")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateRuin():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 4, row = 2)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Ruins needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateSpoils():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 5, row = 2)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Spoils needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateGhost():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 0, row = 3)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Ghost needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateImp():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 1, row = 3)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Imp needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateWillOWhisp():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 2, row = 3)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Will O' Wisp needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateWish():
    cardframe = ttk.Frame(setModifierframe)
    cardframe.grid(column = 3, row = 3)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Wish needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card


def generateBoon():
    cardframe = ttk.Frame(horizontalSetModifierframe)
    cardframe.grid(column = 0, row = 0)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Boons needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

def generateHex():
    cardframe = ttk.Frame(horizontalSetModifierframe)
    cardframe.grid(column = 1, row = 0)
    card = ttk.Label(cardframe, image=None)
    card.grid(column = 0, row = 0)
    text = ttk.Label(cardframe, text="Hexes needed")
    text.config(font=("Arial", 10, "bold"))
    text.grid(column = 0, row = 1)
    return card

root.mainloop()