update
This commit is contained in:
team3
@@ -68,6 +68,7 @@ func _initialize() -> void:
|
||||
test_elementboni()
|
||||
test_spott_und_regeneration()
|
||||
test_verschmelzen()
|
||||
test_ki_verschmelzen()
|
||||
test_limits()
|
||||
test_gleiche_regeln()
|
||||
test_zugreihenfolge()
|
||||
@@ -95,20 +96,21 @@ func _initialize() -> void:
|
||||
quit(1 if failed > 0 else 0)
|
||||
|
||||
|
||||
## 120 Karten: je Element alle Werte von 0/1 bis 5/5, die ID verrät die Werte.
|
||||
## 150 Karten: je Element und für Neutral alle Werte von 0/1 bis 5/5, die ID verrät die Werte.
|
||||
func test_kartenpool() -> void:
|
||||
check(Cards.all().size() == 120, "120 Karten")
|
||||
check(Cards.all().all(func(c): return c.elements.size() == 1 and c.elements[0] in Cards.ELEMENTS), "jede Karte hat genau ein Element")
|
||||
for e in Cards.ELEMENTS:
|
||||
check(Cards.all().size() == 150, "150 Karten")
|
||||
check(Cards.all().all(func(c): return c.elements.size() == 1 and (c.elements[0] in Cards.ELEMENTS or c.elements[0] == Cards.NEUTRAL)), "jede Karte hat genau ein Element oder ist neutral")
|
||||
for e in Cards.ELEMENTS + [Cards.NEUTRAL]:
|
||||
check(Cards.all().filter(func(c): return c.elements == [e]).size() == 30, "30 Karten je Element: " + e)
|
||||
var names := {}
|
||||
for c in Cards.all():
|
||||
var parts: PackedStringArray = c.id.split("_")
|
||||
check(c.attack == int(parts[1]) and c.health == int(parts[2]) and c.attack <= 5 and c.health >= 1 and c.health <= 5, "ID passt zu den Werten: " + c.id)
|
||||
check(c.cost == floori((2 * c.attack + c.health) / 3.0), "Kosten = (2 · Angriff + Leben) / 3, abgerundet: " + c.id)
|
||||
check(c.keywords.is_empty() and c.text() == "" and c.name_en != "", "Karten kommen ohne Eigenschaften, mit englischem Namen: " + c.id)
|
||||
check(c.keywords.is_empty() and c.text() == ("Neutral." if c.is_neutral() else "") and c.name_en != "", "Karten kommen ohne Eigenschaften (außer Neutral), mit englischem Namen: " + c.id)
|
||||
names[c.name] = true
|
||||
check(names.size() == 120, "alle Namen verschieden")
|
||||
check(names.size() == 150, "alle Namen verschieden")
|
||||
check(C("n_3_2").is_neutral() and C("n_3_2").text() == "Neutral." and not C("f_3_2").is_neutral(), "neutrale Karten tragen die Eigenschaft Neutral")
|
||||
check(C("f_0_2").cost == 0 and C("f_2_1").cost == 1 and C("f_3_2").cost == 2 and C("f_5_5").cost == 5 and C("e_0_4").cost == 1, "Kostenbeispiele, 0/2 kostet nichts")
|
||||
check(Cards.cost_of(20, 20) == 10, "Kosten enden bei 10")
|
||||
check(C("f_3_2").name == "Brennender Kobold" and C("w_4_5").name == "Flutender Leviathan", "Namen aus Eigenschaft und Wesen")
|
||||
@@ -123,6 +125,7 @@ func test_kombos() -> void:
|
||||
check(Cards.combo_name(["Luft", "Feuer"]) == "Blitz", "Luft+Feuer = Blitz")
|
||||
check(not C("f_5_5").is_combo() and Cards.fusion_name(["Feuer"]) == "Inferno", "Kombos gibt es nur beim Verschmelzen")
|
||||
check(Cards.combo_name(["Feuer", "Wasser", "Erde"]) == "Chimäre", "drei Elemente sind eine Chimäre")
|
||||
check(Cards.combo_name(["Neutral", "Feuer"]) == "Feuerritter" and Cards.combo_name(["Neutral", "Neutral"]) == "Veteran", "Neutral verschmolzen: Elementritter, zweimal neutral: Veteran")
|
||||
|
||||
|
||||
## Mana: 1 im ersten Zug, jede Runde eins mehr, der Rest verfällt; Legen kostet die Kartenkosten.
|
||||
@@ -144,7 +147,7 @@ func test_mana_und_kosten() -> void:
|
||||
h.energy = 5
|
||||
check(g.play_card(h, h.hand[0]) == "" and h.energy == 5 - C("f_3_2").cost, "Ausspielen kostet die Kartenkosten")
|
||||
check(g.can_play(h, h.hand[0])[1] == "Nicht genug Mana", "Drache (5) zu teuer bei %d Mana" % h.energy)
|
||||
check(Cards.fusion_value(4, 2) == 5 and Cards.fusion_value(8, 1) == 9 and Cards.fusion_value(2, 2) == 3 and Cards.fusion_value(0, 4) == 5 and Cards.fusion_value(8, 8) == 11, "Fusionswert: besserer Wert plus ein Drittel des schwächeren, mindestens 1")
|
||||
check(Cards.fusion_value(4, 2) == 4 and Cards.fusion_value(8, 1) == 6 and Cards.fusion_value(2, 2) == 3 and Cards.fusion_value(0, 4) == 3 and Cards.fusion_value(8, 8) == 9, "Fusionswert: aufgerundete halbe Summe plus eins")
|
||||
|
||||
|
||||
## Stapel: 40 verschiedene Karten, zwölf davon im ersten Zug bezahlbar; Kampagnengegner bekommen
|
||||
@@ -172,10 +175,17 @@ func test_stapel() -> void:
|
||||
var others := sd.filter(func(id): return Cards.by_id(id).elements[0] == o)
|
||||
check(others.size() == 5 and others.all(func(id): return Cards.by_id(id).cost <= Game.START_MANA), "Startdeck %s: fünf billige %s" % [e, o])
|
||||
var filled := DeckGen.fill(["f_0_1"], ["f_0_1", "f_2_1", "e_0_4", "l_1_1", "w_5_5"], 3)
|
||||
check(filled == ["f_0_1", "w_5_5", "e_0_4"], "Auffüllen: teuerste zuerst, dann nach ID, nichts doppelt, bis zur Grenze")
|
||||
check(filled == ["f_0_1", "w_5_5", "e_0_4"], "Auffüllen ohne Stufen: teuerste zuerst, dann nach ID, nichts doppelt, bis zur Grenze")
|
||||
filled = DeckGen.fill(["f_0_1"], ["f_0_1", "f_2_1", "e_0_4", "l_1_1", "w_5_5"], 4, {"l_1_1": 2, "e_0_4": 1, "f_2_1": 1})
|
||||
check(filled == ["f_0_1", "l_1_1", "e_0_4", "f_2_1"], "Auffüllen: wertvollste zuerst, bei gleichem Wert die teuerste")
|
||||
# Kartenwert: Grundkarten 100, je Stufe +100; Fusionen aus ihren Werten
|
||||
check(Cards.all().all(func(c): return c.value() == 100), "jede Grundkarte ist 100 wert")
|
||||
check(C("l_1_1").leveled(4).value() == 500 and C("w_4_5").leveled(2).value() == 300, "Ultimate Rare 500, Super Rare 300")
|
||||
check(Cards.fused(C("f_3_2"), C("w_4_5")).value() == 100 and Cards.fused(C("f_3_2"), C("w_4_5"), 3).value() == 400, "Dampf: 100, in Stufe 3 400")
|
||||
check(DeckGen.strength(["f_0_1", "l_1_1", "w_4_5"], {"l_1_1": 4, "w_4_5": 2}) == 300 and DeckGen.strength([], {}) == 0 and DeckGen.strength(DeckGen.start_deck("Feuer"), {}) == 100, "Stärke: Mittelwert 300, leer 0, Startdeck 100")
|
||||
|
||||
|
||||
## Start: fünf im ersten Zug bezahlbare Karten vom eigenen Stapel. Ziehen bringt eine Karte;
|
||||
## Start: die obersten fünf Karten vom eigenen Stapel, ungefiltert. Ziehen bringt eine Karte;
|
||||
## die erste im Zug ist frei, dann 1, 2, 3 … Mana.
|
||||
func test_ziehen() -> void:
|
||||
var r := RandomNumberGenerator.new()
|
||||
@@ -184,13 +194,12 @@ func test_ziehen() -> void:
|
||||
for p in g.players:
|
||||
check(p.deck.size() == Game.DECK_MIN - Game.START_HAND, "jeder hat seinen Stapel, fünf Karten sind auf der Hand")
|
||||
check(p.hand.size() == Game.START_HAND, "Start: fünf Karten auf der Hand")
|
||||
check(p.hand.all(func(c): return c.cost <= Game.START_MANA), "nur Karten, die im ersten Zug spielbar sind")
|
||||
check(p.hand.all(func(c): return c != Cards.by_id(c.id)), "eigene Exemplare")
|
||||
var first: Game.Player = g.current()
|
||||
check(g.draw(first) == "Deine Hand ist voll", "fünf Handkarten sind das Limit")
|
||||
first.hand.pop_back()
|
||||
for i in 8:
|
||||
first.hand.append(first.draw_from_deck())
|
||||
var deck_before := first.deck.size()
|
||||
check(g.draw_cost(first) == 0 and g.draw(first) == "" and first.energy == Game.START_MANA and first.deck.size() == deck_before - 1, "erstes Ziehen frei, eine Karte vom eigenen Stapel")
|
||||
check(g.draw_cost(first) == 0 and g.draw(first) == "" and first.hand.size() == Game.START_HAND + 9 and first.energy == Game.START_MANA and first.deck.size() == deck_before - 1, "erstes Ziehen frei, eine Karte vom eigenen Stapel, auch mit dreizehn auf der Hand")
|
||||
first.hand.pop_back()
|
||||
check(g.draw_cost(first) == 1 and g.draw(first) == "" and first.energy == 0, "zweites Ziehen kostet 1")
|
||||
first.hand.pop_back()
|
||||
@@ -210,11 +219,11 @@ func test_ziehen() -> void:
|
||||
g.end_turn()
|
||||
check(first.life == Game.START_LIFE - 3, "und dann 2, 3 …")
|
||||
# Der eigene Stapel aus dem Spielstand
|
||||
var ids := ["f_0_1", "f_0_2", "w_0_1", "w_0_2", "e_0_1", "e_0_2", "l_0_1", "l_0_2", "f_5_5", "w_5_5"]
|
||||
var ids := ["f_5_5", "w_5_5", "e_5_5", "l_5_5", "f_4_5", "w_4_5", "e_0_1", "e_0_2", "l_0_1", "l_0_2"]
|
||||
var g2 := Game.new_battle(r, {"deck": ids})
|
||||
var seen := g2.human.deck + g2.human.hand.map(func(c): return c.id)
|
||||
check(seen.size() == ids.size() and seen.all(func(id): return id in ids), "der Mensch spielt mit seinem Stapel")
|
||||
check(g2.human.hand.all(func(c): return c.cost <= Game.START_MANA), "die teuren bleiben im Stapel")
|
||||
check(g2.human.hand.any(func(c): return c.cost > Game.START_MANA), "die Starthand ist ungefiltert: teure Karten kommen mit (eigenes Deck, eigene Verantwortung)")
|
||||
|
||||
|
||||
## Gelegte Wesen greifen erst im nächsten Zug an; kein Durchschlag, keine Heilung zu Zugbeginn.
|
||||
@@ -257,6 +266,10 @@ func test_elementvorteil() -> void:
|
||||
check(Cards.matchup(["Erde"], dampf) == 0 and Cards.matchup(["Wasser"], dampf) == 0, "auch als Verteidiger zählt das bessere Element")
|
||||
check(Cards.matchup(dampf, ["Wasser", "Erde"]) == -1 and Cards.matchup(["Wasser", "Erde"], dampf) == 1, "beide Elemente geschlagen: Nachteil")
|
||||
check(Cards.matchup(dampf, []) == 0 and Cards.matchup([], dampf) == 0, "unbekannte Elemente: kein Vorteil")
|
||||
check(Cards.matchup(["Neutral"], ["Feuer"]) == 0 and Cards.matchup(["Wasser"], ["Neutral"]) == 0, "Neutral: nie im Vorteil oder Nachteil")
|
||||
var feuerritter := ["Feuer", "Neutral"]
|
||||
check(Cards.matchup(feuerritter, ["Luft"]) == 1 and Cards.matchup(feuerritter, ["Wasser"]) == 0 and Cards.matchup(["Wasser"], feuerritter) == 0, "Feuerritter: Vorteil bleibt, die Schwäche ist weg")
|
||||
# Ohne Stapelbonus bewirkt das Element nichts
|
||||
var s := setup()
|
||||
var g: Game = s[0]
|
||||
var h: Game.Player = s[1]
|
||||
@@ -265,31 +278,42 @@ func test_elementvorteil() -> void:
|
||||
var wolf := put(o, "f_3_2") # Feuer 3/2
|
||||
var life: int = o.life
|
||||
g.attack(tiefen, wolf)
|
||||
check(wolf.health <= 0 and o.life == life and tiefen.health == 5 - 2, "Wasser gegen Feuer: +1 beim Zuschlagen, der Konter macht 1 weniger, nichts schlägt durch")
|
||||
check(wolf.health <= 0 and o.life == life and tiefen.health == 5 - 3, "Wasser gegen Feuer ohne Stapelbonus: 4 Schaden, Konter 3, nichts schlägt durch")
|
||||
# Im Vorteil zählt der Stapelbonus des Ziels nicht; beim Konter fehlt dem Ziel sein Angriffsbonus
|
||||
var s3 := setup()
|
||||
var w3 := put(s3[1], "f_3_2")
|
||||
var t3 := put(s3[2], "w_4_5")
|
||||
s3[0].attack(w3, t3)
|
||||
check(t3.health == 5 - 2 and w3.health == 2 - 5, "Feuer gegen Wasser: 1 weniger Schaden, der Konter macht 1 mehr")
|
||||
# 0 Angriff: nur mit Elementvorteil geht etwas
|
||||
var w3 := put(s3[1], "w_4_5")
|
||||
var f3 := put(s3[2], "f_3_2")
|
||||
s3[2].played["Feuer"] = 6
|
||||
s3[0].apply_auras()
|
||||
check(f3.aura == 2 and f3.power() == 5 and f3.max_health == 4 and Game.matchup_bonus(w3, f3) == 2 and Game.matchup_bonus(f3, w3) == -2, "Feuer mit +2/+2: Wasser schlägt 2 mehr, Feuer 2 weniger")
|
||||
s3[0].attack(w3, f3)
|
||||
check(f3.health <= 0 and w3.health == 5 - 3, "Wasser trifft für 4 + 2 durch den Bonus, der Konter kommt ohne Bonus: 3")
|
||||
# Im Nachteil fehlt der eigene Angriffsbonus; der Konter geht durch den eigenen Lebensbonus
|
||||
var s4 := setup()
|
||||
var funke := put(s4[1], "f_0_2") # Feuer 0/2
|
||||
var hauch := put(s4[2], "l_0_2") # Luft 0/2
|
||||
var wall := put(s4[2], "e_0_4") # Erde 0/4
|
||||
check(s4[0].can_attack(funke, wall)[1] == "Schwelender Kobold würde keinen Schaden machen", "0 Angriff ohne Vorteil: kein Angriff")
|
||||
check(s4[0].attack(funke, hauch) == "" and hauch.health == 1 and funke.health == 2, "0 Angriff mit Vorteil: 1 Schaden, kein Konter")
|
||||
var f4 := put(s4[1], "f_3_2")
|
||||
var w4 := put(s4[2], "w_4_5")
|
||||
s4[1].played["Feuer"] = 6
|
||||
s4[0].apply_auras()
|
||||
s4[0].attack(f4, w4)
|
||||
check(w4.health == 5 - 3 and f4.health <= 0, "Feuer mit +2/+2 greift Wasser an: schlägt ohne Bonus für 3, der Konter 4 + 2 geht durch den Bonus")
|
||||
# 0 Angriff: nur der Stapelbonus des Ziels gibt Schaden
|
||||
var s5 := setup()
|
||||
var hauch2 := put(s5[1], "l_0_2")
|
||||
var funke2 := put(s5[2], "f_0_2")
|
||||
check(s5[0].attack(hauch2, funke2) == "Leiser Bote würde keinen Schaden machen" and funke2.health == 2, "im Nachteil nichts")
|
||||
var wall2 := put(s5[2], "e_0_4")
|
||||
var funke := put(s5[1], "f_0_2") # Feuer 0/2
|
||||
var hauch := put(s5[2], "l_0_2") # Luft 0/2
|
||||
check(s5[0].can_attack(funke, hauch)[1] == "Schwelender Kobold würde keinen Schaden machen", "0 Angriff, Ziel ohne Bonus: kein Angriff")
|
||||
s5[2].played["Luft"] = 3
|
||||
s5[0].apply_auras()
|
||||
check(hauch.power() == 1 and hauch.health == 3 and s5[0].attack(funke, hauch) == "" and hauch.health == 2 and funke.health == 2, "Ziel mit +1/+1: 0 Angriff trifft durch den Bonus für 1, der Konter 1 − 1 bleibt aus")
|
||||
var wall := put(s5[2], "e_0_4")
|
||||
var geist5 := put(s5[1], "w_2_2") # Wasser 2/2
|
||||
check(s5[0].attack(geist5, wall2) == "" and wall2.health == 4 - 1 and geist5.health == 2 - 1, "Erdhüter kontert mit Elementvorteil für 1")
|
||||
check(s5[0].attack(geist5, wall) == "" and wall.health == 2 and geist5.health == 2, "Erdhüter ohne Bonus kontert nicht")
|
||||
var s2 := setup()
|
||||
var g2: Game = s2[0]
|
||||
var geist := put(s2[1], "w_2_2") # Wasser 2/2
|
||||
var geist := put(s2[1], "w_2_2")
|
||||
s2[1].played["Wasser"] = 3
|
||||
g2.apply_auras()
|
||||
g2.attack(geist, s2[2])
|
||||
check(s2[2].life == 13, "gegen Helden gibt es keinen Vorteil")
|
||||
check(s2[2].life == 12, "gegen Helden gibt es keinen Vorteil, nur den eigenen Bonus")
|
||||
|
||||
|
||||
## Verdeckt: greift nicht an, zählt nicht für die Elementboni, darf erst nach einer Runde aufgedeckt
|
||||
@@ -321,7 +345,7 @@ func test_verdeckt() -> void:
|
||||
|
||||
|
||||
## Elementboni: zwei eigene offene Wesen eines Elements geben den Sondereffekt (Erde Spott, Luft
|
||||
## Flink, Wasser Regeneration, Feuer Doppelschlag); je fünf ausgespielte Karten eines Elements geben
|
||||
## Flink, Wasser Regeneration, Feuer Doppelschlag); je drei ausgespielte Karten eines Elements geben
|
||||
## den eigenen Wesen des Elements +1/+1. Jeder Spieler zählt für sich.
|
||||
func test_elementboni() -> void:
|
||||
var s := setup(["f_4_3", "f_4_3"])
|
||||
@@ -336,29 +360,29 @@ func test_elementboni() -> void:
|
||||
var hidden_fire := put(o, "f_4_3", true, true)
|
||||
g.apply_auras()
|
||||
check(not hidden_fire.has("Doppelschlag") and o.element_count("Feuer") == 0, "verdeckte zählen nicht fürs Paar")
|
||||
# Ausgespielte Karten zählen; je fünf gibt es +1/+1 für die eigenen Wesen des Elements
|
||||
h.played["Feuer"] = 4
|
||||
g.play_card(h, h.hand[0]) # Flammender Wolf: die fünfte Feuerkarte
|
||||
check(int(h.played["Feuer"]) == 5 and fire[0].aura == 1 and fire[0].power() == 4 and fire[0].health == 3 and h.board[2].aura == 1, "fünf Feuerkarten ausgespielt: +1/+1 für alle eigenen Feuerwesen")
|
||||
# Ausgespielte Karten zählen; je drei gibt es +1/+1 für die eigenen Wesen des Elements
|
||||
h.played["Feuer"] = 2
|
||||
g.play_card(h, h.hand[0]) # Flammender Wolf: die dritte Feuerkarte
|
||||
check(int(h.played["Feuer"]) == 3 and fire[0].aura == 1 and fire[0].power() == 4 and fire[0].health == 3 and h.board[2].aura == 1, "drei Feuerkarten ausgespielt: +1/+1 für alle eigenen Feuerwesen")
|
||||
check(bird.aura == 0 and bird.health == 1 and hidden_fire.aura == 0, "der Gegner zählt für sich: nichts")
|
||||
g._flip(hidden_fire)
|
||||
check(hidden_fire.aura == 0 and int(o.played["Feuer"]) == 0, "aufgedeckt, aber nie ausgespielt gezählt: kein Bonus")
|
||||
g.play_card(h, h.hand[0], true) # zweiter Wolf verdeckt
|
||||
var secret: Game.Creature = h.board.back()
|
||||
check(secret.hidden and secret.aura == 0 and int(h.played["Feuer"]) == 6, "verdeckt gelegt zählt als ausgespielt, der Bonus kommt erst offen")
|
||||
check(secret.hidden and secret.aura == 0 and int(h.played["Feuer"]) == 4, "verdeckt gelegt zählt als ausgespielt, der Bonus kommt erst offen")
|
||||
g._flip(secret)
|
||||
check(secret.aura == 1 and secret.power() == 5 and secret.health == 4, "aufgedeckt kommt der Bonus")
|
||||
# Vorschau
|
||||
h.played["Luft"] = 4
|
||||
check(g.forecast(h, C("l_1_1")) == 1 and g.forecast(h, C("w_2_2")) == 0, "Vorschau: der Hauch wäre die fünfte Luftkarte und bekäme +1/+1")
|
||||
h.played["Luft"] = 2
|
||||
check(g.forecast(h, C("l_1_1")) == 1 and g.forecast(h, C("w_2_2")) == 0, "Vorschau: der Hauch wäre die dritte Luftkarte und bekäme +1/+1")
|
||||
# Merkmal: doppelt
|
||||
h.perks = ["element_doppelt"]
|
||||
g.apply_auras()
|
||||
check(fire[0].aura == 2 and fire[0].power() == 5 and fire[0].max_health == 4, "Elementbonus zählt doppelt")
|
||||
h.perks = []
|
||||
h.played["Feuer"] = 10
|
||||
h.played["Feuer"] = 6
|
||||
g.apply_auras()
|
||||
check(fire[0].aura == 2 and fire[0].power() == 5 and fire[0].max_health == 4, "zehn Feuerkarten: +2/+2")
|
||||
check(fire[0].aura == 2 and fire[0].power() == 5 and fire[0].max_health == 4, "sechs Feuerkarten: +2/+2")
|
||||
fire[0].health = 1
|
||||
h.played["Feuer"] = 0
|
||||
g.apply_auras()
|
||||
@@ -383,10 +407,21 @@ func test_elementboni() -> void:
|
||||
g2.apply_auras()
|
||||
check(dampf.has("Doppelschlag") and dampf.has("Regeneration") and dampf.keywords() == ["Regeneration", "Doppelschlag"], "Dampf hat beide Sondereffekte")
|
||||
check(fw.has("Doppelschlag") and ww.has("Regeneration"), "und zählt für beide Paare")
|
||||
h2.played["Feuer"] = 5
|
||||
h2.played["Wasser"] = 5
|
||||
h2.played["Feuer"] = 3
|
||||
h2.played["Wasser"] = 3
|
||||
g2.apply_auras()
|
||||
check(dampf.aura == 2 and fw.aura == 1 and ww.aura == 1, "fünf Feuer und fünf Wasser: Dampf bekommt +2/+2")
|
||||
check(dampf.aura == 2 and fw.aura == 1 and ww.aura == 1, "drei Feuer und drei Wasser: Dampf bekommt +2/+2")
|
||||
# Neutral: kein Paar, aber ein eigener Zähler
|
||||
var s7 := setup(["n_2_2", "n_2_2"])
|
||||
var g7: Game = s7[0]
|
||||
var h7: Game.Player = s7[1]
|
||||
g7.play_card(h7, h7.hand[0])
|
||||
g7.play_card(h7, h7.hand[0])
|
||||
check(h7.played["Neutral"] == 2 and h7.board[0].keywords().is_empty() and h7.board[0].aura == 0, "zwei Neutrale: kein Paar, der Zähler steht auf 2, noch kein Bonus")
|
||||
check(g7.forecast(h7, C("n_5_5")) == 1 and g7.forecast(h7, C("f_5_5")) == 0, "Vorschau: die dritte Neutrale bringt +1/+1, nur für Neutrale")
|
||||
h7.played["Neutral"] = 3
|
||||
g7.apply_auras()
|
||||
check(h7.board.all(func(c): return c.aura == 1 and c.health == 3), "drei Neutrale: +1/+1 für die neutralen Wesen")
|
||||
|
||||
|
||||
## Abwerfen: eine Handkarte loswerden, dafür 1 Mana.
|
||||
@@ -442,68 +477,77 @@ func test_spott_und_regeneration() -> void:
|
||||
check(g2.events.any(func(e): return e.type == "heal" and e.uid == reg.uid), "Ereignis fürs Heilen")
|
||||
|
||||
|
||||
## Verschmelzen: besserer Wert plus ein Drittel des schwächeren, Eigenschaften beider, Kosten die
|
||||
## halbe Manasumme; auch auf der Hand.
|
||||
## Verschmelzen: kostenlos, Hand und Brett auch gemischt; das Ergebnis kommt unverletzt auf die
|
||||
## Hand. Je Wert die aufgerundete halbe Grundwertsumme plus eins, Kosten daraus, dann die höhere
|
||||
## Stufe der Eltern obendrauf.
|
||||
func test_verschmelzen() -> void:
|
||||
var s := setup()
|
||||
var g: Game = s[0]
|
||||
var h: Game.Player = s[1]
|
||||
var a := put(h, "f_3_2") # 3/2, Kosten 2
|
||||
var b := put(h, "w_4_5") # 4/5, Kosten 4
|
||||
b.health = 4
|
||||
b.health = 1
|
||||
a.card.keywords.append("Spott")
|
||||
check(Game.fusion_cost(a, b) == 3, "Verschmelzen kostet die halbe Manasumme: (2 + 4) / 2")
|
||||
check(g.fuse(h, a, b) == "" and h.board.size() == 1 and h.energy == 7, "verschmolzen")
|
||||
var f: Game.Creature = h.board[0]
|
||||
check(f.name == "Dampf" and f.attack == 5 and f.max_health == 6 and f.health == 5, "Dampf: 4+1 Angriff, 5+1 Leben, aktuell 4+1")
|
||||
check("Spott" in f.card.keywords and f.card.cost == 5, "Eigenschaften geerbt, Kosten aus den neuen Werten")
|
||||
check(f.card.elements == ["Feuer", "Wasser"] and f.ready, "beide Elemente, beide waren bereit")
|
||||
var c := put(h, "e_0_4", false)
|
||||
check(Game.fusion_cost(f, c) == 3, "Dampf (5) mit Hüter (1): 3 Mana")
|
||||
g.fuse(h, f, c)
|
||||
var f2: Game.Creature = h.board[0]
|
||||
check(f2.name == "Chimäre" and h.energy == 4 and not f2.ready, "Chimäre aus drei Elementen, nicht bereit, weil der Hüter es nicht war")
|
||||
var d := put(h, "l_1_1")
|
||||
check(Game.fusion_cost(f2, d) == ceili((f2.card.cost + 1) / 2.0), "Kosten folgen den Karten")
|
||||
h.energy = 1
|
||||
check(g.fuse(h, f2, d) == "Nicht genug Mana", "zu teuer")
|
||||
check(g.can_fuse(h, f2, f2)[1] == "Zwei verschiedene Karten wählen", "nicht mit sich selbst")
|
||||
check(Game.fusion_cost(put(h, "f_0_2"), put(h, "w_0_2")) == 0, "zwei Karten für 0 verschmelzen umsonst")
|
||||
# Verdeckte verschmelzen offen
|
||||
var s2 := setup()
|
||||
var x := put(s2[1], "f_3_2", true, true)
|
||||
var y := put(s2[1], "f_2_1", true, true)
|
||||
s2[0].fuse(s2[1], x, y)
|
||||
check(not s2[1].board[0].hidden and s2[1].board[0].name == "Inferno", "das Ergebnis liegt offen")
|
||||
# Elementbonus der Eltern zählt nicht doppelt; Dampf bekommt die Boni beider Elemente
|
||||
var s3 := setup()
|
||||
var g3: Game = s3[0]
|
||||
var h3: Game.Player = s3[1]
|
||||
var fa := put(h3, "f_3_2")
|
||||
var fb := put(h3, "w_4_5")
|
||||
h3.played["Feuer"] = 5
|
||||
g3.apply_auras()
|
||||
check(fa.aura == 1 and fa.power() == 4 and fa.max_health == 3, "fünf Feuerkarten ausgespielt vor dem Verschmelzen")
|
||||
g3.fuse(h3, fa, fb)
|
||||
var ff: Game.Creature = h3.board[0]
|
||||
check(ff.aura == 1 and ff.max_health == 7 and ff.health == 7 and ff.power() == 6, "nach dem Verschmelzen zählt der Bonus nur einmal (6 + 1)")
|
||||
h3.played["Wasser"] = 5
|
||||
g3.apply_auras()
|
||||
check(ff.aura == 2 and ff.power() == 7 and ff.max_health == 8, "Feuer und Wasser voll: Dampf bekommt +2/+2")
|
||||
# Auf der Hand
|
||||
var s4 := setup(["f_3_2", "w_4_5", "l_1_1"])
|
||||
check(g.fuse(h, a, b) == "" and h.board.is_empty() and h.hand.size() == 1 and h.energy == 10, "beide Wesen verlassen das Brett, das Ergebnis liegt auf der Hand, kostenlos")
|
||||
var f: Cards.Card = h.hand[0]
|
||||
check(f.name == "Dampf" and f.attack == 5 and f.health == 5 and f.cost == 5, "Dampf: ⌈7/2⌉ + 1 = 5 Angriff und Leben, Kosten (10 + 5) / 3 = 5, die Verletzung ist weg")
|
||||
check("Spott" in f.keywords and f.elements == ["Feuer", "Wasser"] and f.look == 0, "Eigenschaften und Elemente beider, Stufe Common")
|
||||
check(g.play_card(h, f) == "" and h.energy == 5 and h.board[0].health == 5 and not h.board[0].ready, "ausgespielt für die neuen Kosten, unverletzt, erst nächsten Zug bereit")
|
||||
check(h.played["Feuer"] == 1 and h.played["Wasser"] == 1, "zählt beim Legen für beide Elemente")
|
||||
# Wesen mit Handkarte, auch verdeckt; stark plus schwach ergibt weniger als das starke
|
||||
var dampf: Game.Creature = h.board[0]
|
||||
var secret := put(h, "e_0_4", false, true)
|
||||
h.hand = [C("l_1_1")]
|
||||
check(g.fuse(h, dampf, h.hand[0]) == "" and h.hand.size() == 1 and h.board == [secret], "Wesen mit Handkarte verschmolzen")
|
||||
var chi: Cards.Card = h.hand[0]
|
||||
check(chi.name == "Chimäre" and chi.attack == 4 and chi.health == 4 and chi.cost == 4, "Chimäre aus drei Elementen: ⌈6/2⌉ + 1 = 4/4, schwächer als Dampf, dafür frisch")
|
||||
check(g.fuse(h, h.hand[0], secret) == "" and h.hand[0].name == "Chimäre" and h.hand[0].health == 5 and h.board.is_empty(), "auch mit einem verdeckten Wesen")
|
||||
check(g.can_fuse(h, h.hand[0], h.hand[0])[1] == "Zwei verschiedene Karten wählen", "nicht mit sich selbst")
|
||||
check(g.can_fuse(h, h.hand[0], put(s[2], "f_2_1"))[1] == "Nur eigene Karten" and g.can_fuse(h, h.hand[0], C("f_2_1"))[1] == "Nur eigene Karten", "fremde Wesen und fremde Karten nicht")
|
||||
h.energy = 0
|
||||
check(g.can_fuse(h, h.hand[0], put(h, "f_2_1"))[0], "ohne Mana geht es trotzdem")
|
||||
# Stufe: aus den Grundwerten gerechnet, dann die höhere Stufe obendrauf
|
||||
var s4 := setup(["f_3_2", "l_1_1"])
|
||||
var g4: Game = s4[0]
|
||||
var h4: Game.Player = s4[1]
|
||||
var hand_a: Cards.Card = h4.hand[0]
|
||||
var hand_b: Cards.Card = h4.hand[1]
|
||||
check(g4.can_fuse(h4, hand_a, put(h4, "e_0_4"))[1] == "Nur Hand mit Hand oder Brett mit Brett", "Hand und Brett mischen sich nicht")
|
||||
check(g4.fuse(h4, hand_a, hand_b) == "" and h4.hand.size() == 2 and h4.energy == 7, "zwei Handkarten verschmolzen, 3 Mana")
|
||||
var hc: Cards.Card = h4.hand[0]
|
||||
check(hc.name == "Dampf" and hc.attack == 5 and hc.health == 6 and hc.cost == 5, "Dampf auf der Hand mit 5/6 und Kosten 5")
|
||||
var lava := Cards.fused(C("f_4_3"), C("f_2_1"), 4, 8)
|
||||
check(Cards.fused(lava, C("f_2_1")).attack == 5 and Cards.fused(lava, C("f_2_1")).health == 9, "ein Funke macht Lava 4/8 zu 5/9, nie schlechter")
|
||||
check(g4.play_card(h4, hc) == "" and h4.energy == 7 - 5 and h4.board.back().name == "Dampf", "Ausspielen kostet die neuen Kosten")
|
||||
check(g4.log.any(func(l): return l == "Brennender Kobold und Flutender Leviathan verschmelzen auf der Hand zu Dampf (5/6)."), "Verlauf")
|
||||
h4.hand[1] = h4.hand[1].leveled(4) # Hauch in Ultimate Rare: 5/5 für 1 Mana
|
||||
check(h4.hand[1].attack == 5 and h4.hand[1].base_attack() == 1 and h4.hand[1].cost == 1, "der Stufenbonus liegt auf den Grundwerten")
|
||||
check(g4.fuse(h4, h4.hand[0], h4.hand[1]) == "" and h4.hand.size() == 1, "auf der Hand verschmolzen")
|
||||
var blitz: Cards.Card = h4.hand[0]
|
||||
check(blitz.name == "Blitz" and blitz.look == 4 and blitz.base_attack() == 3 and blitz.base_health() == 3 and blitz.attack == 7 and blitz.health == 7 and blitz.cost == 3, "Blitz: Grundwerte ⌈4/2⌉ + 1 = 3/3, Kosten 3, Stufe 4 macht daraus 7/7")
|
||||
check(g4.log.any(func(l): return l == "Brennender Kobold und Flüchtiger Hauch verschmelzen zu Blitz (7/7) auf der Hand."), "Verlauf")
|
||||
# Bild
|
||||
var lava := Cards.fused(C("f_4_3"), C("f_2_1"))
|
||||
check(lava.name == "Inferno" and lava.attack == 4 and lava.health == 3 and lava.art == "f_4_3" and lava.art_card().id == "f_4_3" and Cards.fused(C("w_2_2"), lava).art == "f_4_3", "das Bild trägt der stärkere Elternteil, auch über Verschmelzungen hinweg")
|
||||
check(Cards.fused(C("f_3_2"), C("w_3_2")).art == "f_3_2" and C("f_3_2").art_card().id == "f_3_2" and Cards.Card.from_dict(lava.to_dict()).art == "f_4_3", "bei Gleichstand die erste Karte; Grundkarten zeigen sich selbst; das Bild überlebt das Speichern")
|
||||
|
||||
|
||||
## KI: heilt ein Wesen mit höchstens halbem Leben per Fusion mit der billigsten Handkarte, wenn
|
||||
## das Ergebnis bezahlbar bleibt; die Vorausschau kennt Fusionen mit Handkarten und bildet sie
|
||||
## zwischen Kopie und Original ab.
|
||||
func test_ki_verschmelzen() -> void:
|
||||
var s := setup(["f_2_1", "w_4_5"])
|
||||
var g: Game = s[0]
|
||||
var h: Game.Player = s[1]
|
||||
var hurt := put(h, "e_3_5")
|
||||
hurt.health = 2
|
||||
var act := AI.choose_action_greedy(g, h)
|
||||
check(act.type == "fuse" and act.creature == hurt and act.other == h.hand[0], "gierig: das halb tote Wesen mit dem Funken verschmelzen")
|
||||
h.energy = 1
|
||||
act = AI.choose_action_greedy(g, h)
|
||||
check(act.type == "play", "ohne Mana fürs Ergebnis keine Heilfusion, sondern legen")
|
||||
h.energy = 10
|
||||
var cands := AI.candidate_actions(g, h)
|
||||
check(cands.any(func(a): return a.type == "fuse" and a.creature == hurt and a.other == h.hand[0]), "Vorausschau: Wesen plus Handkarte als Kandidat")
|
||||
check(cands.any(func(a): return a.type == "fuse" and a.creature is Cards.Card and a.other is Cards.Card), "Vorausschau: zwei Handkarten als Kandidat")
|
||||
var fuse_act: Dictionary = cands.filter(func(a): return a.type == "fuse" and a.creature == hurt)[0]
|
||||
var g2 := g.clone()
|
||||
AI.apply_on_clone(g2, g, fuse_act)
|
||||
check(g2.players[0].board.is_empty() and g2.players[0].hand.size() == 2 and h.board == [hurt] and h.hand.size() == 2, "auf der Kopie verschmolzen, das Original bleibt")
|
||||
var back := AI.map_action(g, g2, fuse_act)
|
||||
check(back.creature == hurt and back.other == h.hand[0], "zurück aufs Original abgebildet")
|
||||
hurt.health = 5
|
||||
check(not AI.candidate_actions(g, h).any(func(a): return a.type == "fuse" and a.creature == hurt), "unverletzt: kein Heilkandidat")
|
||||
|
||||
|
||||
func test_limits() -> void:
|
||||
@@ -516,9 +560,9 @@ func test_limits() -> void:
|
||||
check(g.can_play(h, h.hand[0])[1] == "Dein Feld ist voll", "Feld voll")
|
||||
h.hand = []
|
||||
h.deck = ["f_2_1"]
|
||||
for i in Game.MAX_HAND:
|
||||
for i in 12:
|
||||
h.hand.append(C("f_2_1"))
|
||||
check(g.draw(h) == "Deine Hand ist voll" and h.hand.size() == Game.MAX_HAND, "volle Hand zieht nicht")
|
||||
check(g.draw(h) == "" and h.hand.size() == 13, "keine Grenze für Handkarten")
|
||||
check(g.play_card(h, C("f_2_1")) == "Nicht auf der Hand", "fremde Karte lässt sich nicht spielen")
|
||||
|
||||
|
||||
@@ -643,8 +687,8 @@ func test_booster() -> void:
|
||||
g.play_card(h, h.hand[0])
|
||||
var fused: Game.Creature = h.board[1]
|
||||
h.energy = 10
|
||||
check(g.fuse(h, fused, kobold) == "", "auf dem Brett verschmolzen")
|
||||
check(h.board[0].card.look == 3 and h.board[0].card.rarity_in(h.looks) == "Ultra Rare", "auch auf dem Brett und über zwei Fusionen")
|
||||
check(g.fuse(h, fused, kobold) == "" and h.board.is_empty(), "zwei Wesen vom Brett verschmolzen")
|
||||
check(h.hand[0].look == 3 and h.hand[0].rarity_in(h.looks) == "Ultra Rare", "die Stufe bleibt über zwei Fusionen")
|
||||
|
||||
|
||||
## Sammlung und Deck: Start mit einem Startdeck, Herstellen für Staub, Zerlegen entfernt
|
||||
@@ -943,7 +987,7 @@ func test_ki_zeitbudget() -> void:
|
||||
var g := Game.new_battle(r)
|
||||
var h: Game.Player = g.players[0]
|
||||
h.energy = 30
|
||||
for i in Game.MAX_HAND:
|
||||
for i in 7:
|
||||
h.hand.append(C("f_4_3"))
|
||||
for p in g.players:
|
||||
for i in 3:
|
||||
|
||||
Reference in New Issue
Block a user