def test_cross_over():
typer = ["a", "b"]
spiller1 = Spiller(lag_kort(), Spilleske(typer), typer)
spiller2 = Spiller(lag_kort(), Spilleske(typer), typer)
spiller1.prioriteringer = {"a": [1, 2, 3], "b": [7, 8, 9]}
spiller2.prioriteringer = {"a": [4, 5, 6], "b": [10, 11, 12]}
ny_spiller = cross_over([spiller1, spiller2], typer)
print(ny_spiller.prioriteringer)
def test_fjern():
onskeliste = ["La", "So"]
spilleske = Spilleske(onskeliste)
for i in range(10):
spilleske.trekk_fra("La")
assert fjern_tomme(onskeliste,
spilleske) == ["So"
], fjern_tomme(onskeliste, spilleske)
def test_bruk_kort():
kortene = []
spilleske = Spilleske(["Sm", "Gu", "Pr", "So", "Ko", "La"])
for i in range(3):
kortene.append(MyntSeierKort(1, 0))
for i in range(1):
kortene.append(Smie())
for i in range(1):
kortene.append(Landsby())
for i in range(2):
kortene.append(Smie())
for i in range(13):
kortene.append(MyntSeierKort(0, 1))
spiller = Spiller(kortene, spilleske, TYPER)
spiller.trekk_hand()
assert len(spiller.hand) == 5
spiller.bruk_befaling()
assert len(spiller.hand) == 9, [len(spiller.hand), spiller.hand]
assert len(spiller.kastebunke) == 3, spiller.kastebunke
spiller.kast_hand()
assert len(spiller.trekkbunke) == 8, spiller.trekkbunke
assert len(spiller.kastebunke) == 12, spiller.kastebunke
spiller.trekk_hand()
spiller.bruk_befaling()
spiller.kast_hand()
assert len(spiller.trekkbunke) == 3, spiller.trekkbunke
assert len(spiller.kastebunke) == 17, spiller.kastebunke
def test_finn_score():
typer = ["Ko", "So"]
spilleske = Spilleske(typer)
spiller = Spiller(lag_kort(), spilleske, typer)
spiller.prioriteringer = {'Ko': [1, 6, 3], "So": [0, 3, 6]}
spiller.trekkbunke = [
MyntSeierKort(1, 0),
MyntSeierKort(1, 0),
MyntSeierKort(2, 0)
]
spiller.kort["Ko"] = 2
spiller.kort["So"] = 1
svar = spiller.finn_score()
assert svar["Ko"] == 6
assert svar["So"] == 4
kortene = [
MyntSeierKort(1, 0),
MyntSeierKort(2, 0),
MyntSeierKort(2, 0),
MyntSeierKort(2, 0)
]
spiller.prioriteringer = {'Ko': [2, 4, 2], "So": [0, 8, 4]}
score = spiller.finn_scorel(kortene)
assert score["Ko"] == 4.5
assert score["So"] == 5
assert spiller.finn_andelu(MyntSeierKort(1, 0), kortene) == 0.25
def test_finn_andel():
kortene = []
spilleske = Spilleske(["Sm", "Gu", "Pr", "So", "Ko", "La"])
for i in range(7):
kortene.append(MyntSeierKort(1, 0))
for i in range(3):
kortene.append(MyntSeierKort(0, 1))
spiller = Spiller(kortene, spilleske, TYPER)
assert spiller.finn_andel(MyntSeierKort(1, 0)) == 0.7
def test_mtilfeldig(spilleren):
logging.info("Begynner testing gruppe")
kampen = [spilleren]
for telling in range(3):
kampen.append(Spiller(lag_kort(), Spilleske(TYPER), TYPER))
vinneren = spille_mothverandre(kampen)
if vinneren == spilleren:
return 1
else:
return 0
def test_tell_penger():
kortene = []
spilleske = Spilleske(["Sm", "Gu", "Pr", "So", "Ko", "La"])
for i in range(4):
kortene.append(MyntSeierKort(1, 0))
for i in range(1):
kortene.append(MyntSeierKort(0, 1))
spiller = Spiller(kortene, spilleske, TYPER)
spiller.stokk()
spiller.trekk_hand()
assert spiller.tell_penger(spiller.hand) == 4
def print_losning(spiller, filnavn):
losning = spiller.prioriteringer
fil = open(filnavn, "w")
spilleske = Spilleske(TYPER)
antall = spiller.tell_korttyper()
scoresiste = spiller.finn_siste_score()
scoreforste = spiller.finn_forste_score()
rad1 = [
"typer", "Grunntall", "Smie", "Kobber", "Solv", "Gull", "Landsby",
"Provins", "antall", "forste score", "siste score"
]
fil.write(";".join(rad1) + "\n")
for type in losning:
mine_ting = [
type, losning[type][0], losning[type][1], losning[type][2],
losning[type][3], losning[type][4], losning[type][5],
losning[type][6],
antall.get(spilleske.kode_til_kort(type)), scoreforste[type],
scoresiste[type]
]
ny_liste = [str(ordet) for ordet in mine_ting]
fil.write(";".join(ny_liste) + "\n")
def test_kjop():
kortene = []
spilleske = Spilleske(["Sm", "Gu", "Pr", "So", "Ko", "La"])
for i in range(1):
kortene.append(MyntSeierKort(1, 0))
for i in range(1):
kortene.append(MyntSeierKort(2, 0))
for i in range(3):
kortene.append(MyntSeierKort(0, 1))
spiller = Spiller(kortene, spilleske, TYPER)
spiller.trekk_hand()
spiller.bruk_befaling()
# assert spiller.finn_kjop() == "Sm", spiller.finn_kjop()
spiller.kjop()
spiller.kast_hand()
def cross_over(spillere, typer):
assert len(spillere) == 2
ny_spiller = Spiller(lag_kort(), Spilleske(typer), typer)
for type in typer:
for a in range((len(typer) + 1)):
tallet = randint(1, 3)
if tallet == 1:
ny_spiller.prioriteringer[type][a] = spillere[
0].prioriteringer[type][a]
elif tallet == 2:
ny_spiller.prioriteringer[type][a] = spillere[
1].prioriteringer[type][a]
else:
ny_spiller.prioriteringer[type][a] = (
spillere[0].prioriteringer[type][a] +
spillere[1].prioriteringer[type][a]) / 2
ny_spiller.navn = spillere[0].navn + spillere[1].navn
return ny_spiller
def kjor(runder, typer):
samling = {}
for i in range(runder):
kortene = []
spilleske = Spilleske(typer)
for i in range(7):
kortene.append(MyntSeierKort(1, 0))
for i in range(3):
kortene.append(MyntSeierKort(0, 1))
spiller = Spiller(kortene, spilleske, typer)
for nummer in range(100):
spiller.utfor_runde()
runden = spiller.tell_korttyper()
for kort in runden:
if not kort in samling:
samling[kort] = []
samling[kort] += [runden[kort]]
for kortet in samling:
summen = sum(samling[kortet])
gjennomsnitt = summen / runder
print(kortet, gjennomsnitt)
def __init__(self, spillere):
self.spilleske = Spilleske(TYPER)
for spiller in spillere:
spiller.klart_for_nytt_spill(lag_kort(), self.spilleske)
class Spiller:
def __init__(self, kortene, spilleske, typer):
self.trekkbunke = kortene
self.kastebunke = []
self.hand = []
self.bruktekort = []
self.spilleske = spilleske
self.typer = typer
self.prioriteringer = self.lag_prioriteringer()
assert len(self.prioriteringer) == len(self.typer)
self.forsterunde = None
self.kort = {}
self.navn = None
# self.onskeliste = ["Pr", "Gu","Sm", "So", "Ko"]
#self.onskeliste = ["Pr", "Gu", "So", "Ko"]
#self.onskeliste = ["Pr", "Sm", "So", "Ko"]
def _resirkuler_kastebunke(self):
if DEBUG_MODE:
assert self.trekkbunke == []
assert not None in self.trekkbunke
assert not None in self.kastebunke
self.trekkbunke = self.kastebunke
if DEBUG_MODE:
assert not None in self.trekkbunke
self.kastebunke = []
self.stokk()
def finn_forste_score(self):
if self.navn == "manuellsmiland.csv":
a = "a"
kortene = lag_kort()
self.spilleske = Spilleske(self.typer)
return self.finn_scorel(kortene)
def finn_siste_score(self):
self.spilleske.igjen["Pr"] = 1
return self.finn_scorel(self.alle_kort())
def klart_for_nytt_spill(self, kortene, spilleske):
self.kastebunke = []
self.hand = []
self.bruktekort = []
self.trekkbunke = kortene
self.stokk()
self.spilleske = spilleske
for type in self.typer:
self.kort[type] = 0
self.oppdater_antall("Ko", 7)
def oppdater_antall(self, kort, antallet):
self.kort[kort] += antallet
def lage_barn(self):
nye_barn = []
for telling in range(1):
kortene = []
for i in range(7):
kortene.append(MyntSeierKort(1, 0))
for i in range(3):
kortene.append(MyntSeierKort(0, 1))
nye_barn.append(Spiller(kortene, self.spilleske, self.typer))
nye_barn[0].navn = self.navn + str(1)
return nye_barn
def mutasjon(self):
nye_barn = self.lage_barn()
for barnet in nye_barn:
for i in range(3):
barnet.prioriteringer[choice(self.typer)][randint(
0, 6)] += random() / 5 - 0.1
return nye_barn
def tell_poeng(self):
poeng = 0
for kortet in self.alle_kort():
poeng += kortet.poeng
return poeng
def finn_score(self):
Score = {}
for kort in self.prioriteringer:
assert type(self.prioriteringer[kort][0]) == float, (type(
self.prioriteringer[kort][0]), self.prioriteringer[kort][0])
Score[kort] = self.prioriteringer[kort][0]
for ab in range(len(self.typer)):
#print(len(self.typer), len(self.prioriteringer[kort]), type(self.typer))
Score[kort] += self.prioriteringer[kort][ab +
1] * self.finn_andel(
self.typer[ab])
return Score
def finn_scorel(self, kortete):
kortene = [self.spilleske.kort_til_kode(kort) for kort in kortete]
Score = {}
for kort in self.prioriteringer:
Score[kort] = self.prioriteringer[kort][0]
for ab in range(len(self.typer)):
Score[kort] += self.prioriteringer[kort][
ab + 1] * self.finn_andelu(self.typer[ab], kortene)
return Score
def finn_andelu(self, kort, kortene):
if kort == "Pr":
return 1 / self.spilleske.igjen["Pr"]
antall = kortene.count(kort)
return antall / len(kortene)
def finn_onskeliste(self) -> List[str]:
Score = self.finn_score()
# Score["Sm"] = 4 - self.finn_andel(Smie())*30 + self.finn_andel(Landsby()) * 35
# Score["Gu"] = 6 + self.finn_andel(Smie())*3
# Score["Pr"] = 8 + 10-self.finn_andel(MyntSeierKort(0,6))
# Score["So"] = 3 + self.finn_andel(Smie())*3
# Score["Ko"] = 1 - self.finn_andel(MyntSeierKort(2,0))*10 - self.finn_andel(MyntSeierKort(3,0))*20
# Score["La"] = 3 + self.finn_andel(Smie())*20 - self.finn_andel(Landsby())*20
#print(Score["Ko"], Score["Pr"])
#print(self.prioriteringer)
onskeliste = _sorter_onskeliste(Score)
onskeliste = fjern_tomme(onskeliste, self.spilleske)
return onskeliste
def finn_andel(self, kort) -> float:
if kort == "Pr":
return 10 - self.spilleske.igjen["Pr"]
antall = self.kort[kort]
return antall / len(self.alle_kort())
def alle_kort(self) -> List[Kort]:
ny_kastebunke = self.kastebunke + self.hand + self.trekkbunke
if DEBUG_MODE:
assert not None in ny_kastebunke
return ny_kastebunke
def stokk(self):
shuffle(self.trekkbunke)
def trekk_hand(self):
antall_kort = 5
if DEBUG_MODE:
assert self.hand == []
for nummer in range(antall_kort):
if len(self.trekkbunke) == 0:
self._resirkuler_kastebunke()
if len(self.trekkbunke) == 0:
return
if DEBUG_MODE:
assert not None in self.hand
self.hand.append(self.trekkbunke.pop(0))
if DEBUG_MODE:
assert not None in self.hand
def trekk_kort(self, nye_kort):
for nummer in range(nye_kort):
if len(self.trekkbunke) == 0:
self._resirkuler_kastebunke()
if len(self.trekkbunke) == 0:
return
self.hand.append(self.trekkbunke.pop(0))
def tell_penger(self, hand) -> int:
self.penger = 0
for kortet in hand:
self.penger += kortet.peng
return self.penger
def sorter_hand(self) -> List[Kort]:
if DEBUG_MODE:
assert not None in self.hand
ny_hand = []
for kort in self.hand:
fortsett = True
plass = 0
while fortsett == True:
if ny_hand == []:
ny_hand.append(kort)
fortsett = False
else:
if not plass + 1 > len(ny_hand):
hendelse = kort.bruk()
hendelse1 = ny_hand[plass].bruk()
if hendelse.befalinger > hendelse1.befalinger:
ny_hand = ny_hand[:plass] + [kort
] + ny_hand[plass:]
fortsett = False
else:
plass += 1
else:
ny_hand.append(kort)
fortsett = False
if DEBUG_MODE:
assert not None in ny_hand
return ny_hand
def bruk_befaling(self):
if DEBUG_MODE:
assert self.bruktekort == []
befalinger = 1
kjop = 1
hendelse = None
while befalinger >= 1 and hendelse != False:
# print(befalinger,len(self.hand), self.hand,len(self.alle_kort()), self.alle_kort())
hendelse = self.bruk_en_befaling()
if not hendelse == False:
befalinger += hendelse.befalinger
nye_kort = hendelse.kort
kjop += hendelse.kjop
self.trekk_kort(nye_kort)
self.kastebunke += self.bruktekort
if DEBUG_MODE:
assert not None in self.kastebunke
self.bruktekort = []
def bruk_en_befaling(self): #-> Hendelse/False
self.hand = self.sorter_hand()
for i in range(len(self.hand)):
kortet = self.hand[i]
if isinstance(kortet, Befalingskort):
hendelse = kortet.bruk()
self.hand.pop(i)
self.bruktekort.append(kortet)
return hendelse
return False
def kast_hand(self):
for kort in self.hand:
if DEBUG_MODE:
assert not kort is None
self.kastebunke.append(kort)
self.hand = []
def lag_prioriteringer(self):
prioriteringer = {}
for typen in self.typer:
prioriteringer[typen] = []
for i in range(len(self.typer) + 1):
prioriteringer[typen].append(random())
return prioriteringer
def finn_kjop(self): #->Kort/None
for onske in self.finn_onskeliste():
if onske == "Sm" and self.tell_penger(self.hand) >= 4:
return onske
elif onske == "So" and self.tell_penger(self.hand) >= 3:
return onske
elif onske == "Gu" and self.tell_penger(self.hand) >= 6:
return onske
elif onske == "Pr" and self.tell_penger(self.hand) >= 8:
return onske
elif onske == "Ko":
return onske
elif onske == "La" and self.tell_penger(self.hand) >= 3:
return onske
elif onske == "He" and self.tell_penger(self.hand) >= 2:
return onske
return None
def kjop(self):
kjop = self.finn_kjop()
logging.debug("kjop" + str(kjop) + " penger:" +
str(self.tell_penger(self.hand)) + " onskeliste:" +
str(self.finn_onskeliste()))
if not kjop is None:
self.kastebunke.append(self.spilleske.kode_til_kort(kjop))
logging.debug("Foer: " + str(self.spilleske.igjen))
self.spilleske.trekk_fra(kjop)
logging.debug("Etter: " + str(self.spilleske.igjen))
self.oppdater_antall(kjop, 1)
#print (kjop)
return kjop
return "ingenting"
def utfor_runde(self):
if DEBUG_MODE:
assert not None in self.hand
assert not None in self.trekkbunke
self.trekk_hand()
if DEBUG_MODE:
assert not None in self.hand
self.bruk_befaling()
self.kjop()
self.kast_hand()
if DEBUG_MODE:
assert not None in self.trekkbunke
def utfor_runde_medskriv(self):
self.trekk_hand()
if DEBUG_MODE:
assert not None in self.hand
self.bruk_befaling()
kjopet = [self.kjop()]
#print(self.hand)
if DEBUG_MODE:
assert self.spilleske.kort_til_kode(MyntSeierKort(1, 0)) == "Ko"
handa = self.hand
hand = [self.spilleske.kort_til_kode(kortet) for kortet in self.hand]
alle_kort = [
self.spilleske.kort_til_kode(kortet)
for kortet in self.alle_kort()
]
finn_kjop = self.finn_kjop()
if DEBUG_MODE:
assert not None in hand
self.kast_hand()
assert not None in hand
assert not None in alle_kort
assert not None in kjopet
assert not None in [str(self.tell_penger(handa))]
assert not None in [finn_kjop]
return kjopet, [str(self.tell_penger(handa))
], ["I"], hand, ["I"], alle_kort, ["I"], [finn_kjop]
def tell_korttyper(self) -> int:
antall = {}
for kort in self.trekkbunke:
if not kort in antall:
antall[kort] = 0
antall[kort] += 1
for kortet in self.kastebunke:
if not kortet in antall:
antall[kortet] = 0
antall[kortet] += 1
return antall
def finn_forste_score(self):
if self.navn == "manuellsmiland.csv":
a = "a"
kortene = lag_kort()
self.spilleske = Spilleske(self.typer)
return self.finn_scorel(kortene)