update

tests/test_runner.gd

@@ -89,6 +89,8 @@ func _initialize() -> void:
     test_merkmale()
     test_ki_zwei_schritte()
     test_kapitel_zwei_und_merkmalwahl()
+    test_einzelspieler_gegner()
+    test_skilltree()
     test_ki_zeitbudget()
     test_englische_karten()
     test_uebersetzung_vollstaendig()
@@ -96,20 +98,21 @@ func _initialize() -> void:
     quit(1 if failed > 0 else 0)
 
 
-## 150 Karten: je Element und für Neutral alle Werte von 0/1 bis 5/5, die ID verrät die Werte.
+## 550 Karten: je Element und für Neutral alle Werte von 0/1 bis 10/10, die ID verrät die Werte.
 func test_kartenpool() -> void:
-    check(Cards.all().size() == 150, "150 Karten")
+    check(Cards.all().size() == 550, "550 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)
+        check(Cards.all().filter(func(c): return c.elements == [e]).size() == 110, "110 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.attack == int(parts[1]) and c.health == int(parts[2]) and c.attack <= 10 and c.health >= 1 and c.health <= 10, "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() == ("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() == 150, "alle Namen verschieden")
+    check(names.size() == 550, "alle Namen verschieden")
+    check(C("f_10_10").cost == 10 and C("n_6_1").name == "Eiserner Knappe" and C("w_0_10").name == "Stiller Urleviathan", "10/10 kostet 10; neue Eigenschaften und Wesen ab 6")
     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")
@@ -146,12 +149,13 @@ func test_mana_und_kosten() -> void:
     check(h.energy == Game.START_MANA + 21, "keine Obergrenze")
     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(h.cards_played == 1 and g.clone().human.cards_played == 1, "ausgespielte Karte gezählt, auch in der Kopie")
     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) == 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
-## Stapel mit Kostendeckel und ab Kapitel 2 höhere Stufen; Startdecks je Element; Auffüllen.
+## Zufällige Stapel; Elementstapel der Kampagne in der Stufe des Kapitels; Auffüllen.
 func test_stapel() -> void:
     var r := RandomNumberGenerator.new()
     r.seed = 5
@@ -160,29 +164,45 @@ func test_stapel() -> void:
         var uniq := {}
         for id in d:
             uniq[id] = true
-        check(d.size() == Game.DECK_MIN and uniq.size() == Game.DECK_MIN, "40 verschiedene Karten")
+        check(d.size() == Game.DECK_MIN and uniq.size() == Game.DECK_MIN, "30 verschiedene Karten")
         check(d.filter(func(id): return Cards.by_id(id).cost <= Game.START_MANA).size() >= DeckGen.CHEAP_IN_RANDOM, "mindestens zwölf billige")
-    var easy := DeckGen.opponent_deck(r, 1)
-    check(easy.all(func(id): return Cards.by_id(id).cost <= 3), "Kapitel 1: nur bis Kosten 3")
+    var neutral := DeckGen.element_deck(Cards.NEUTRAL)
+    check(neutral.size() == 110 and neutral.all(func(id): return Cards.by_id(id).is_neutral()), "alle 110 neutralen Karten")
+    var start := DeckGen.curve_deck(Cards.NEUTRAL, r)
+    var per_cost := {}
+    var uniq2 := {}
+    for id in start:
+        per_cost[Cards.by_id(id).cost] = int(per_cost.get(Cards.by_id(id).cost, 0)) + 1
+        uniq2[id] = true
+    check(start.size() == Game.DECK_MIN and start.all(func(id): return Cards.by_id(id).is_neutral()) and per_cost.get(0, 0) == 2 and per_cost.get(3, 0) == 6 and per_cost.get(7, 0) == 1 and not per_cost.has(8), "Kurvenstapel: 30 Neutrale nach Manakurve (2 zu 0, 6 zu 3, 1 zu 7, nichts darüber)")
+    check(uniq2.size() == Game.DECK_MIN and DeckGen.curve_deck(Cards.NEUTRAL, r) != start, "nichts doppelt, jedes Mal anders gewürfelt")
+    var capped := DeckGen.curve_deck("Feuer", r, 3)
+    check(capped.size() == Game.DECK_MIN and capped.all(func(id): return Cards.by_id(id).cost <= 3 and Cards.by_id(id).elements[0] == "Feuer"), "Kostendeckel 3: 30 Feuerkarten bis Kosten 3")
+    var fenn := Campaign.opponent(0, r)
+    check(fenn.deck.size() == Game.DECK_MIN and fenn.deck.all(func(id): return Cards.by_id(id).is_neutral() and Cards.by_id(id).cost <= 3) and fenn.looks.values().all(func(l): return l == 0), "Kapitel 1, Stufe 1: 30 Neutrale bis Kosten 3 in Common")
     var boss := Campaign.opponent(15, r)
-    check(boss.deck.size() == Game.DECK_MIN and boss.deck.all(func(id): return Cards.by_id(id).cost <= 5) and boss.looks.values().all(func(l): return l == 1), "Kapitel 2: bis Kosten 5, Stufe Rare")
-    for e in Cards.ELEMENTS:
-        var sd := DeckGen.start_deck(e)
-        var main := sd.filter(func(id): return Cards.by_id(id).elements[0] == e)
-        check(sd.size() == Game.DECK_MIN and main.size() == 25 and main.all(func(id): return Cards.by_id(id).attack <= 4), "Startdeck %s: 25 Karten des Elements bis Angriff 4" % e)
-        for o in Cards.ELEMENTS:
-            if o != e:
-                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])
+    check(boss.deck.size() == Game.DECK_MIN and boss.deck.all(func(id): return Cards.by_id(id).elements[0] == "Feuer" and Cards.by_id(id).cost <= 6) and boss.looks.values().all(func(l): return l == 0), "Kapitel 2, Stufe 6: Feuer bis Kosten 6 in Common")
+    check(Campaign.stage(0).max_cost == 3 and Campaign.stage(9).max_cost == 10 and Campaign.stage(14).max_cost == 5, "Kostendeckel steigt je Stufe von 3 auf 10")
+    for c in Campaign.CHAPTER_ELEMENTS.size():
+        var e: String = Campaign.CHAPTER_ELEMENTS[c]
+        var o := Campaign.opponent(c * Campaign.STAGES_PER_CHAPTER + 9, r)
+        check(o.deck.all(func(id): return Cards.by_id(id).elements[0] == e) and o.looks.values().all(func(l): return l == maxi(0, c - 1)), "Boss von Kapitel %d: nur %s in Stufe %d" % [c + 1, e, maxi(0, c - 1)])
     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 ohne Stufen: teuerste zuerst, dann nach ID, nichts doppelt, bis zur Grenze")
+    check(filled == ["f_0_1", "e_0_4", "f_2_1"], "Auffüllen ohne Stufen: gleicher Wert, dann die billigeren, nach ID, nichts doppelt, bis zur Grenze")
+    var full := DeckGen.fill([], neutral, Game.DECK_MIN)
+    var curve_counts: Array[int] = []
+    curve_counts.resize(11)
+    curve_counts.fill(0)
+    for id in full:
+        curve_counts[Cards.by_id(id).cost] += 1
+    check(full.size() == Game.DECK_MIN and curve_counts == DeckGen.CURVE, "Auffüllen aus 110 Neutralen folgt der Manakurve")
     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")
+    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.element_deck(Cards.NEUTRAL), {}) == 100, "Stärke: Mittelwert 300, leer 0, Startsammlung 100")
 
 
 ## Start: die obersten fünf Karten vom eigenen Stapel, ungefiltert. Ziehen bringt eine Karte;
@@ -269,51 +289,42 @@ func test_elementvorteil() -> void:
     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
+    # Schaden: im Vorteil doppelt, im Nachteil halb (aufgerundet), gegen Helden nichts
     var s := setup()
     var g: Game = s[0]
     var h: Game.Player = s[1]
     var o: Game.Player = s[2]
     var tiefen := put(h, "w_4_5")  # Wasser 4/5
     var wolf := put(o, "f_3_2")    # Feuer 3/2
+    check(Game.matchup_bonus(tiefen, wolf) == 4 and Game.matchup_bonus(wolf, tiefen) == -1, "Wasser schlägt Feuer doppelt (4 → 8), Feuer kontert halb (3 → 2)")
     var life: int = o.life
     g.attack(tiefen, wolf)
-    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], "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
+    check(wolf.health <= 0 and o.life == life and tiefen.health == 5 - 2, "8 Schaden töten den Wolf, der Konter bringt 2, nichts schlägt durch")
+    # Nachteil beim Angriff: halb aufgerundet; der Konter des Ziels kommt doppelt
     var s4 := setup()
     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
+    check(w4.health == 5 - 2 and f4.health <= 0, "Feuer trifft Wasser für 2 (3 halbiert, aufgerundet), der Konter 4 × 2 tötet")
+    # Rundung und Null
     var s5 := setup()
     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, wall) == "" and wall.health == 2 and geist5.health == 2, "Erdhüter ohne Bonus kontert nicht")
+    check(s5[0].can_attack(funke, hauch)[1] == "Schwelender Kobold würde keinen Schaden machen", "0 Angriff: auch im Vorteil kein Schaden")
+    var wall := put(s5[2], "w_5_5")
+    check(Game.matchup_bonus(put(s5[1], "f_1_1"), wall) == 0 and Game.matchup_bonus(put(s5[1], "f_2_1"), wall) == -1 and Game.matchup_bonus(put(s5[1], "f_5_1"), wall) == -2, "halbiert aufgerundet: 1 bleibt 1, 2 wird 1, 5 wird 3")
+    check(not s5[0].can_attack(put(s5[1], "l_0_2"), put(s5[2], "e_0_4"))[0], "0 Angriff im Vorteil (Luft gegen Erde): kein Angriff")
+    # Helden haben kein Element
     var s2 := setup()
-    var g2: Game = s2[0]
     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 == 12, "gegen Helden gibt es keinen Vorteil, nur den eigenen Bonus")
+    s2[0].attack(geist, s2[2])
+    check(s2[2].life == 15 - 2, "gegen Helden gibt es keinen Vorteil")
+    # Merkmal: kein Nachteil
+    var s6 := setup()
+    var f6 := put(s6[1], "f_3_2")
+    var w6 := put(s6[2], "w_4_5")
+    s6[1].perks = ["kein_nachteil"]
+    check(Game.matchup_bonus(f6, w6) == 0 and Game.matchup_bonus(w6, f6) == 4, "Merkmal: kein Nachteil für die eigenen Wesen, der Gegner behält seinen Vorteil")
 
 
 ## Verdeckt: greift nicht an, zählt nicht für die Elementboni, darf erst nach einer Runde aufgedeckt
@@ -344,9 +355,8 @@ func test_verdeckt() -> void:
     check(seen.card.id == "?" and seen.attack == 2, "die KI-Kopie kennt verdeckte Wesen nicht")
 
 
-## Elementboni: zwei eigene offene Wesen eines Elements geben den Sondereffekt (Erde Spott, Luft
-## 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.
+## Elementpaare: zwei eigene offene Wesen eines Elements geben den Sondereffekt (Erde Spott, Luft
+## Flink, Wasser Regeneration, Feuer Doppelschlag). Jeder Spieler zählt für sich, verdeckte nicht.
 func test_elementboni() -> void:
     var s := setup(["f_4_3", "f_4_3"])
     var g: Game = s[0]
@@ -354,39 +364,17 @@ func test_elementboni() -> void:
     var o: Game.Player = s[2]
     var fire := [put(h, "f_3_2"), put(h, "f_2_1")]
     var bird := put(o, "l_1_1")  # Luft 1/1
-    g.apply_auras()
-    check(fire[0].aura == 0 and int(h.played["Feuer"]) == 0, "nur gelegt, nicht ausgespielt: kein Bonus")
     check(fire[0].has("Doppelschlag") and fire[0].attacks_per_turn() == 2 and fire[0].keywords() == ["Doppelschlag"], "zwei eigene Feuer: Doppelschlag für beide")
+    check(not bird.has("Flink") and bird.power() == 1 and bird.health == 1, "der Gegner zählt für sich: nichts")
     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 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])  # Flammender Wolf
+    check(h.board[2].has("Doppelschlag") and h.board[2].power() == 4 and h.board[2].health == 3, "ausgespielt: Werte wie auf der Karte, dazu der Effekt")
     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"]) == 4, "verdeckt gelegt zählt als ausgespielt, der Bonus kommt erst offen")
+    check(secret.hidden and not secret.has("Doppelschlag") and h.element_count("Feuer") == 3, "verdeckt gelegt: ohne Effekt, zählt nicht")
     g._flip(secret)
-    check(secret.aura == 1 and secret.power() == 5 and secret.health == 4, "aufgedeckt kommt der Bonus")
-    # Vorschau
-    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"] = 6
-    g.apply_auras()
-    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()
-    check(fire[0].aura == 0 and fire[0].max_health == 2 and fire[0].health == 1, "Bonus weg: nur das Höchstleben sinkt")
+    check(secret.has("Doppelschlag") and h.element_count("Feuer") == 4, "aufgedeckt zählt es und bekommt den Effekt")
     # Die anderen Paare
     var s5 := setup()
     var walls := [put(s5[1], "e_0_4"), put(s5[1], "e_0_4")]
@@ -396,33 +384,22 @@ func test_elementboni() -> void:
     var s6 := setup()
     var geister := [put(s6[1], "w_2_2"), put(s6[1], "w_2_2")]
     check(geister[0].has("Regeneration"), "zwei Wasser: Regeneration")
-    # Verschmolzene Wesen zählen für beide Elemente und bekommen beide Effekte und Boni
+    # Verschmolzene Wesen zählen für beide Elemente und bekommen beide Effekte
     var s2 := setup()
-    var g2: Game = s2[0]
     var h2: Game.Player = s2[1]
     var dampf := put(h2, "f_3_2")
     dampf.card = Cards.fused(C("f_3_2"), C("w_2_2"))
     var fw := put(h2, "f_2_1")
     var ww := put(h2, "w_2_2")
-    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"] = 3
-    h2.played["Wasser"] = 3
-    g2.apply_auras()
-    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
+    # Neutral: kein Paar
     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")
-
+    check(h7.board.size() == 2 and h7.board[0].keywords().is_empty() and h7.board[0].health == 2, "zwei Neutrale: kein Paar, nichts ändert sich")
 
 ## Abwerfen: eine Handkarte loswerden, dafür 1 Mana.
 func test_abwerfen() -> void:
@@ -493,7 +470,6 @@ func test_verschmelzen() -> void:
     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)
@@ -639,27 +615,35 @@ func test_booster() -> void:
     var r := RandomNumberGenerator.new()
     r.seed = 3
     for i in 50:
-        var rolled := Profile.roll_booster(r)
-        check(rolled.size() == 5, "5 Karten")
+        var rolled := Profile.roll_booster(r, "Feuer")
+        check(rolled.size() == 5 and rolled.all(func(x): return x.card.elements[0] == "Feuer"), "5 Feuerkarten")
         check(rolled.any(func(x): return x.rarity != "Common"), "mindestens eine Rare")
     var p := Profile.new()
-    p.coins = Profile.BOOSTER_COST
-    var got := p.open_booster(r)
-    check(p.coins == 0 and got.size() == 5, "Booster kostet %d" % Profile.BOOSTER_COST)
+    p.coins = Profile.ELEMENT_BOOSTER_COST
+    check(p.open_booster("Feuer", r).is_empty() and p.coins == Profile.ELEMENT_BOOSTER_COST and not p.booster_unlocked("Feuer") and p.booster_unlocked(Cards.NEUTRAL), "Feuer-Booster erst ab Kapitel 2, neutral immer")
+    p.campaign_stage = Campaign.STAGES_PER_CHAPTER
+    check(p.booster_unlocked("Feuer") and not p.booster_unlocked("Wasser"), "Kapitel 2 offen: Feuer ja, Wasser nein")
+    var got := p.open_booster("Feuer", r)
+    check(p.coins == 0 and got.size() == 5 and got.all(func(x): return x.card.elements[0] == "Feuer"), "Feuer-Booster kostet %d" % Profile.ELEMENT_BOOSTER_COST)
     check(got.all(func(x): return p.owns(x.card.id) and x.card.id in p.deck), "alle fünf sind jetzt in Sammlung und Stapel")
     var fresh := got.filter(func(x): return x.new)
     check(not fresh.is_empty() and fresh.all(func(x): return x.dust == 0 and not x.upgraded), "neue Karten: kein Staub, kein Aufwerten")
     check(p.dust == got.reduce(func(a, x): return a + int(x.dust), 0), "Doppelte werden zu Staub")
-    check(p.open_booster(r).is_empty(), "ohne Münzen kein Booster")
+    check(p.open_booster("Feuer", r).is_empty(), "ohne Münzen kein Booster")
+    p.coins = Profile.BOOSTER_COST
+    check(p.open_booster(Cards.NEUTRAL, r).size() == 5 and p.coins == 0, "neutraler Booster kostet %d" % Profile.BOOSTER_COST)
+    p.coins = Profile.ELEMENT_BOOSTER_COST * 3
+    check(p.open_boosters("Feuer", 4, r).is_empty() and p.coins == Profile.ELEMENT_BOOSTER_COST * 3, "vier Packs: zu teuer, nichts passiert")
+    check(p.open_boosters("Feuer", 3, r).size() == 15 and p.coins == 0, "drei Packs auf einmal: 15 Karten, alles bezahlt")
     p.collection = {"f_3_2": 0}
     p.deck = []
     for i in Game.DECK_MAX:
         p.deck.append("x%d" % i)  # voll: neue Karten passen nicht mehr hinein
-    p.coins = Profile.BOOSTER_COST * 20
+    p.coins = Profile.ELEMENT_BOOSTER_COST * 20
     var dust_before := p.dust
     var upgraded := false
     for i in 20:
-        for res in p.open_booster(r):
+        for res in p.open_booster("Feuer", r):
             if res.card.id == "f_3_2" and res.upgraded:
                 upgraded = true
                 check(res.dust == Profile.DUST_DISMANTLE[Cards.RARITIES[Cards.RARITIES.find(res.rarity) - 1]] or res.dust > 0, "die alte Version wird zu Staub")
@@ -691,13 +675,11 @@ func test_booster() -> void:
     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
-## Common-Karten, der Stapel hält 40 bis 60 eigene Karten.
+## Sammlung und Deck: Start mit den neutralen Karten, Herstellen für Staub, Zerlegen entfernt
+## Common-Karten, der Stapel hält 30 bis 60 eigene Karten.
 func test_sammlung_und_deck() -> void:
     var p := Profile.starter()
-    check(not p.started() and p.collection.is_empty() and p.deck.is_empty(), "neues Profil: noch kein Startdeck")
-    p.choose_start("Feuer")
-    check(p.started() and p.collection.size() == Game.DECK_MIN and p.deck == DeckGen.start_deck("Feuer") and p.deck.all(func(id): return p.owns(id)), "Startdeck Feuer: 40 Karten in Sammlung und Stapel")
+    check(p.collection.size() == 110 and p.deck.size() == Game.DECK_MIN and p.deck.all(func(id): return p.owns(id) and p.level(id) == 0 and Cards.by_id(id).is_neutral()), "neues Profil: alle 110 Neutralen in Common in der Sammlung, 30 im Stapel")
     check(p.toggle_deck("f_5_5") == "Karte nicht in der Sammlung", "fremde Karte nicht in den Stapel")
     var first: String = p.deck[0]
     check(p.toggle_deck(first) == "" and p.deck.size() == Game.DECK_MIN - 1, "Karte aus dem Stapel genommen")
@@ -708,7 +690,7 @@ func test_sammlung_und_deck() -> void:
     p.deck = DeckGen.fill(p.deck, p.collection.keys(), Game.DECK_MAX)
     var outside: Array = p.collection.keys().filter(func(id): return not (id in p.deck))
     check(p.toggle_deck(outside[0]) == "Der Stapel ist voll (%d Karten)" % Game.DECK_MAX, "60 ist voll")
-    p.choose_start("Feuer")
+    p = Profile.starter()
     p.dust = Profile.CRAFT_COST - 1
     check(p.craft("f_5_5") == "Nicht genug Staub (%d nötig)" % Profile.CRAFT_COST, "Herstellen braucht Staub")
     p.dust = Profile.CRAFT_COST
@@ -717,7 +699,7 @@ func test_sammlung_und_deck() -> void:
     var in_deck: String = p.deck[0]
     check(p.dismantle(in_deck) == "" and not p.owns(in_deck) and not (in_deck in p.deck) and p.dust == Profile.DUST_DISMANTLE["Common"], "Common zerlegt: raus aus Sammlung und Stapel, Staub dafür")
     var filled := p.deck_cards()
-    check(filled.size() == Game.DECK_MIN and filled.all(func(id): return p.owns(id)) and filled.slice(0, p.deck.size()) == p.deck and "f_5_5" in filled, "zum Kampf wird der Stapel mit eigenen Karten bis 40 aufgefüllt")
+    check(filled.size() == Game.DECK_MIN and filled.all(func(id): return p.owns(id)) and filled.slice(0, p.deck.size()) == p.deck, "zum Kampf wird der Stapel mit eigenen Karten bis 30 aufgefüllt")
     p.deck = []
     check(p.deck_cards().size() == Game.DECK_MIN, "leerer Stapel: Standard aus der Sammlung")
     var d := Profile.from_dict(JSON.parse_string(JSON.stringify(p.to_dict())))
@@ -731,12 +713,11 @@ func test_spielstand() -> void:
         if FileAccess.file_exists(path + suffix):
             DirAccess.remove_absolute(abs + suffix)
     var p := Profile.load_or_new(path)
-    check(p.coins == Profile.START_COINS and not p.started(), "Starterprofil: Startdeck noch zu wählen")
-    p.choose_start("Wasser")
-    check(p.collection.size() == Game.DECK_MIN and p.deck.size() == Game.DECK_MIN, "Startdeck gewählt")
+    check(p.coins == Profile.START_COINS and p.collection.size() == 110 and p.deck.size() == Game.DECK_MIN, "Starterprofil: neutrale Karten")
     check(FileAccess.file_exists(path), "Datei angelegt")
     p.coins = 999
     p.collection["f_3_2"] = 2
+    p.collection["f_0_1"] = 0
     p.deck = ["f_3_2", "f_0_1"]
     p.save(path)
     var p2 := Profile.load_or_new(path)
@@ -829,7 +810,7 @@ func test_spielstand_migration() -> void:
         "collection": {"f_kobold": 2}, "decks": [], "settings": {"volume": 0.3}, "perk": "resonanz_doppelt"}
     var p := Profile.from_dict(alt)
     check(p.coins == 300 and p.dust == 70 and p.campaign_stage == 2, "alter Stand gelesen")
-    check(not p.started() and p.deck.is_empty() and p.perk == "", "alte Sammlung verworfen, Startdeck wird neu gewählt, unbekanntes Merkmal verworfen")
+    check(p.deck.size() == Game.DECK_MIN and p.collection.size() == 110 and p.perk == "", "alte Sammlung verworfen, neutrale Startsammlung, unbekanntes Merkmal verworfen")
     check(is_equal_approx(p.settings.volume, 0.3) and p.settings.animations, "Einstellungen übernommen")
     var fresh := Profile.new()
     check(fresh.settings.volume == 0.0 and fresh.settings.music == 0.0, "Ton und Musik sind standardmäßig aus")
@@ -845,23 +826,26 @@ func test_spielstand_migration() -> void:
 func test_kampagne() -> void:
     var r := RandomNumberGenerator.new()
     r.seed = 4
-    check(Campaign.STAGES.size() == 10, "zehn Stufen")
-    var boss := Campaign.opponent(4, r)
-    check(boss.name == "Vulkar" and boss.title == "Herr der Lava" and boss.life == 24, "Stufe 5: Vulkar mit 24 Leben")
+    check(Campaign.STAGES_PER_CHAPTER == 10 and Campaign.total() == 50, "fünf Kapitel mit je zehn Stufen")
+    var boss := Campaign.opponent(4)
+    check(boss.name == "Vulkar" and boss.title == "Söldnerfürst" and boss.life == 24, "Stufe 5: Vulkar mit 24 Leben")
     check(boss.deck.size() == Game.DECK_MIN and boss.looks.values().all(func(l): return l == 0), "Kapitel 1: Stapel in Common")
     var g := Game.new_battle_with(boss, r)
     check(g.opponent == boss and g.human.life == Game.START_LIFE, "Kampagnenkampf gestartet")
+    check(Profile.battle_coins(false, 10, 20, 8) == 190 and Profile.battle_coins(true, 10, 20, 8) == 380, "Münzen: 5 je Zug, Karte und schnellem Zug, Sieg verdoppelt")
+    check(Profile.battle_coins(true, 10, 20, 8, 1.5) == 570 and Profile.battle_coins(true, 10, 20, 8, 2.0) == 760 and Profile.battle_coins(false, 5, 10, 4, 2.0) == 190, "Schwierigkeit ×1,5 und ×2")
+    check(Profile.DIFFICULTIES.leicht.reward == 1.0 and Profile.DIFFICULTIES.normal.reward == 1.5 and Profile.DIFFICULTIES.schwer.reward == 2.0, "Münzfaktoren 1 / 1,5 / 2")
     var p := Profile.starter()
-    var reward := p.record_battle(true, 0)
-    check(p.campaign_stage == 1 and reward == Campaign.STAGES[0].reward, "Stufe 1 abgeschlossen")
-    reward = p.record_battle(true, 0)
-    check(p.campaign_stage == 1 and reward == Profile.REWARD_WIN, "Wiederholung gibt normale Belohnung")
-    reward = p.record_battle(false, 1)
-    check(p.campaign_stage == 1 and reward == Profile.REWARD_LOSS, "Niederlage schaltet nichts frei")
+    var reward := p.record_battle(true, 380, 0)
+    check(p.campaign_stage == 1 and reward == 380 + Campaign.stage(0).reward and p.coins == Profile.START_COINS + reward, "Stufe 1 abgeschlossen: Münzen plus Stufenbelohnung")
+    reward = p.record_battle(true, 380, 0)
+    check(p.campaign_stage == 1 and reward == 380, "Wiederholung nur die Münzen des Kampfs")
+    reward = p.record_battle(false, 190, 1)
+    check(p.campaign_stage == 1 and reward == 190, "Niederlage schaltet nichts frei")
     p.campaign_stage = 9
-    p.record_battle(true, 9)
+    p.record_battle(true, 380, 9)
     check(p.campaign_stage == 10, "Kampagne abgeschlossen")
-    var sim := Game.new_battle_with(Campaign.opponent(0, r), r)
+    var sim := Game.new_battle_with(Campaign.opponent(0), r)
     var guard := 0
     while sim.winner == "" and guard < 300:
         AI.take_turn(sim, sim.current(), true)
@@ -918,17 +902,17 @@ func test_merkmale() -> void:
     var mana := h.energy
     check(g.draw_cost(h) == 0 and g.draw(h) == "" and h.energy == mana and g.draw_cost(h) == 1, "Merkmal: ein Ziehen mehr umsonst")
     for perk in Game.PERKS:
-        check(Campaign.STAGES.any(func(st): return st.perk == perk), "Merkmal vergeben: " + perk)
+        check(range(Campaign.total()).any(func(i): return perk in Campaign.stage(i).perks), "Merkmal vergeben: " + perk)
     var r := RandomNumberGenerator.new()
     r.seed = 2
-    var mara: Game.Player = Game.new_battle_with(Campaign.opponent(1, r), r).opponent
+    var mara: Game.Player = Game.new_battle_with(Campaign.opponent(1), r).opponent
     check(mara.life == 22 + 5 and mara.max_life == 27 and mara.perks == ["leben_35"], "Mara hat mit ihrem Merkmal 5 Leben mehr")
-    var g3 := Game.new_battle_with(Campaign.opponent(9, r), r, true)
+    var g3 := Game.new_battle_with(Campaign.opponent(9), r, true)
     var archi: Game.Player = g3.opponent
     check(g3.players[0] == g3.human, "feste Reihenfolge: Mensch beginnt")
     g3.end_turn()
     check(g3.current() == archi and archi.energy == Game.START_MANA + 2, "Archimagier hat im ersten Zug 2 Mana mehr")
-    var nyx: Game.Player = Campaign.opponent(5, r)
+    var nyx: Game.Player = Campaign.opponent(5)
     var g4 := Game.new_battle_with(nyx, r, true)
     g4.end_turn()
     check(nyx.max_energy == Game.START_MANA and nyx.energy == Game.START_MANA + 1, "Nyx bekommt 1 Mana mehr je Zug")
@@ -956,17 +940,19 @@ func test_ki_zwei_schritte() -> void:
 
 
 func test_kapitel_zwei_und_merkmalwahl() -> void:
-    check(Campaign.total() == 30 and Campaign.chapter(9) == 1 and Campaign.chapter(10) == 2 and Campaign.chapter(29) == 3, "dreißig Stufen in drei Kapiteln")
-    check(Campaign.stage(25).perks.size() == 3 and Campaign.stage(25).name == "Nyx", "Kapitel 3 mit drei Merkmalen")
+    check(Campaign.total() == 50 and Campaign.chapter(9) == 1 and Campaign.chapter(10) == 2 and Campaign.chapter(49) == 5, "fünfzig Stufen in fünf Kapiteln")
+    check(Campaign.stage(25).perks.size() == 2 and Campaign.stage(25).name == "Nyx" and Campaign.stage(25).element == "Wasser", "Kapitel 3: Wasser, zwei Merkmale")
+    check(Campaign.stage(45).perks.size() == 3 and Campaign.stage(40).element == "Erde" and Campaign.stage(49).reward == 1500 and Campaign.stage(10).reward == 350 and Campaign.stage(9).reward == 500, "Kapitel 5: Erde, drei Merkmale; Belohnungen 350 bis 1500, Boss 1 gibt 500")
+    check(Campaign.stage(0).perks == ["feuer_angriff"] and Campaign.stage(23).perks == ["ziehen_gratis", "kein_nachteil"] and Campaign.stage(49).perks == ["start_energie", "wesen_angriff", "extra_mana"], "Merkmale je drei Plätze versetzt, nichts doppelt")
     for i in Campaign.total():
         var st := Campaign.stage(i)
         check(st.has("perks") and st.perks.all(func(k): return Game.PERKS.has(k)), "Stufe %d hat gültige Merkmale" % (i + 1))
     var r := RandomNumberGenerator.new()
     r.seed = 8
-    var archi2 := Campaign.opponent(19, r)
-    check(archi2.name == "Archimagier" and archi2.perks.size() == 2 and archi2.life == 28, "letzte Stufe von Kapitel 2: Archimagier mit zwei Merkmalen und 28 Leben")
-    check(archi2.looks.values().all(func(l): return l == 1), "Kapitel 2: seine Karten sind Rare")
-    check(Campaign.opponent(25, r).looks.values().all(func(l): return l == 2), "Kapitel 3: Super Rare")
+    var archi2 := Campaign.opponent(19)
+    check(archi2.name == "Archimagier" and archi2.perks.size() == 1 and archi2.life == 28, "letzte Stufe von Kapitel 2: Archimagier mit einem Merkmal und 28 Leben")
+    check(archi2.looks.values().all(func(l): return l == 0) and archi2.deck.all(func(id): return Cards.by_id(id).elements[0] == "Feuer"), "Kapitel 2: seine Karten sind Feuer in Common")
+    check(Campaign.opponent(25).looks.values().all(func(l): return l == 1) and Campaign.opponent(45).looks.values().all(func(l): return l == 3), "Kapitel 3 Rare, Kapitel 5 Ultra Rare")
     var p := Profile.starter()
     check(not p.perk_unlocked(), "Merkmalwahl erst nach Kapitel 1")
     p.campaign_stage = 10
@@ -975,12 +961,90 @@ func test_kapitel_zwei_und_merkmalwahl() -> void:
     var g := Game.new_battle(r, {"human_perks": [p.perk]})
     check(g.human.perks == ["feuer_angriff"] and g.log.any(func(l): return l.begins_with("Spieler: Feuerwesen")), "eigenes Merkmal wirkt und steht im Verlauf")
     p.campaign_stage = 19
-    p.record_battle(true, 19)
+    p.record_battle(true, 380, 19)
     check(p.campaign_stage == 20, "Kapitel 2 abgeschlossen")
     var v := Profile.from_dict(JSON.parse_string(JSON.stringify(p.to_dict())))
     check(v.perk == "feuer_angriff" and v.campaign_stage == 20, "gespeichert und gelesen")
 
 
+## Einzelspieler: der Gegner spielt ein offenes Element in einer Stufe relativ zu deiner Deckstärke.
+func test_einzelspieler_gegner() -> void:
+    var r := RandomNumberGenerator.new()
+    r.seed = 21
+    var p := Profile.starter()
+    check(p.deck_level() == 0 and p.unlocked_elements() == [Cards.NEUTRAL] and p.unlocked_cards().size() == 110 and p.unlocked_cards().all(func(c): return c.is_neutral()), "Start: Stufe Common, nur Neutral offen, 110 Karten sichtbar")
+    check(Profile.DIFFICULTIES.leicht.level == -1 and Profile.DIFFICULTIES.normal.level == 0 and Profile.DIFFICULTIES.schwer.level == 1, "Versatz -1 / 0 / +1")
+    p.settings.difficulty = "schwer"
+    var o := p.single_opponent(r)
+    check(o.deck.size() == Game.DECK_MIN and o.deck.all(func(id): return Cards.by_id(id).is_neutral()) and o.looks.values().all(func(l): return l == 1) and o.life == Game.START_LIFE, "Schwer: 30 Neutrale, eine Stufe über dir, 30 Leben")
+    check(o.perks.size() == 1 and Game.PERKS.has(o.perks[0]) and o.title == Cards.NEUTRAL, "Schwer: ein zufälliges Merkmal, Element als Titel")
+    p.settings.difficulty = "leicht"
+    o = p.single_opponent(r)
+    check(o.looks.values().all(func(l): return l == 0) and o.perks.is_empty(), "Leicht: nicht unter Common, kein Merkmal")
+    for id in p.collection:
+        p.collection[id] = 3
+    check(p.deck_level() == 3 and p.opponent_level() == 2, "Ultra-Rare-Deck: Stufe 3, Leicht eine darunter")
+    p.settings.difficulty = "normal"
+    check(p.opponent_level() == 3 and p.single_opponent(r).looks.values().all(func(l): return l == 3), "Normal: deine Stufe")
+    for id in p.deck.slice(0, 3):
+        p.collection[id] = 4
+    check(DeckGen.strength(p.deck_cards(), p.collection) == 410 and p.deck_level() == 3, "410 rundet auf Stufe 3")
+    p.campaign_stage = Campaign.STAGES_PER_CHAPTER
+    check(p.unlocked_elements() == [Cards.NEUTRAL, "Feuer"] and p.unlocked_cards().size() == 220, "Kapitel 2 offen: Feuer dazu, 220 Karten sichtbar")
+    var seen := {}
+    for i in 30:
+        var e: String = Cards.by_id(p.single_opponent(r).deck[0]).elements[0]
+        seen[e] = true
+    check(seen.keys().size() == 2 and seen.has("Feuer") and seen.has(Cards.NEUTRAL), "Gegner würfelt aus Neutral und Feuer")
+    p.campaign_stage = Campaign.total()
+    check(p.unlocked_elements() == Array(Campaign.CHAPTER_ELEMENTS), "alles offen: alle fünf")
+    var g := Game.new_battle_with(p.single_opponent(r), r, false, {"deck": p.deck_cards(), "looks": p.looks()})
+    check(g.opponent.deck.size() + g.opponent.hand.size() == Game.DECK_MIN and g.opponent.hand.all(func(c): return c.look == 3), "im Kampf: 30 Karten in Stufe 3")
+
+
+## Skilltree: Münzen sind Erfahrung, je Level ein Punkt, Skills wirken auf Booster, Staub, Münzen und Kampf.
+func test_skilltree() -> void:
+    check(Skills.xp_for_level(1) == 100 and Skills.xp_for_level(2) == 300 and Skills.xp_for_level(5) == 1500 and Skills.level_for(0) == 0 and Skills.level_for(299) == 1 and Skills.level_for(300) == 2, "Level brauchen 100, 300, 600 … Erfahrung")
+    var p := Profile.starter()
+    check(p.player_level() == 0 and p.skill_points() == 0 and p.learn("packglueck") == "Kein Skillpunkt frei", "Start: Level 0, kein Punkt")
+    var reward := p.record_battle(true, 380)
+    check(reward == 380 and p.xp == 380 and p.player_level() == 2 and p.skill_points() == 2 and p.take_notices() == ["Level 2 erreicht: +2 Skillpunkte"], "380 Münzen: Level 2, zwei Punkte, Meldung")
+    check(p.learn("packglueck") == "" and p.skill("packglueck") == 1 and p.skill_points() == 1, "Packglück gelernt")
+    check(p.learn("gratisziehen") == "" and p.learn("gratisziehen") == "Schon auf der höchsten Stufe" and p.skill_points() == 0, "Freies Ziehen hat nur eine Stufe")
+    check(p.battle_perks() == ["ziehen_gratis"], "Kampfskill wird im Kampf zum Merkmal")
+    p.perk = "leben_35"
+    p.campaign_stage = Campaign.STAGES_PER_CHAPTER
+    check(p.battle_perks() == ["leben_35", "ziehen_gratis"], "das gewählte Merkmal kommt dazu")
+    p.xp = 100000
+    for i in 3:
+        p.learn("muenzen")
+        p.learn("staub")
+    p.learn("packpreis")
+    p.learn("packpreis")
+    check(is_equal_approx(p.coin_factor(), 1.3) and p.pack_price(Cards.NEUTRAL) == 80 and p.pack_price("Feuer") == 160 and p.dust_gain(100) == 175, "Münzsegen ×1,3, Händler −20 %, Staubsammler +75 %")
+    var coins := p.coins
+    check(p.record_battle(false, 200) == 260 and p.coins == coins + 260, "260 statt 200 Münzen")
+    p.coins = 80
+    check(p.open_booster(Cards.NEUTRAL).size() == 5 and p.coins == 0, "neutraler Booster kostet mit Händler 80")
+    var rr := RandomNumberGenerator.new()
+    rr.seed = 9
+    var commons := 0
+    var commons0 := 0
+    for i in 200:
+        commons += Profile.roll_booster(rr, Cards.NEUTRAL, 3).filter(func(x): return x.rarity == "Common").size()
+        commons0 += Profile.roll_booster(rr, Cards.NEUTRAL, 0).filter(func(x): return x.rarity == "Common").size()
+    check(commons < commons0 * 0.7, "Packglück 3: deutlich weniger Common (%d statt %d)" % [commons, commons0])
+    p.collection["n_0_1"] = 1
+    var dust := p.dust
+    check(p.dismantle("n_0_1") == "" and p.dust == dust + 175, "Zerlegen einer Rare mit Staubsammler 3: 175 statt 100")
+    var d := Profile.from_dict(JSON.parse_string(JSON.stringify(p.to_dict())))
+    check(d.xp == p.xp and d.skills == p.skills and d.skill_points() == p.skill_points(), "Erfahrung und Skills gespeichert")
+    var bad := Profile.from_dict({"version": Profile.SAVE_VERSION, "xp": 100, "skills": {"gibt_es_nicht": 2, "packglueck": 9}})
+    check(bad.skill("packglueck") == 3 and bad.skills.size() == 1 and bad.player_level() == 1, "unbekannte Skills fliegen raus, Stufen gedeckelt")
+    check(Skills.pack_weights(0) == PackedFloat32Array([45, 25, 15, 10, 5]) and Skills.pack_weights(3) == PackedFloat32Array([21, 34, 21, 16, 8]), "Packglück 3: Chancen 21/34/21/16/8")
+    check(Skills.effect("packglueck", 1) == "Chancen 37/28/17/12/6 %" and Skills.effect("packpreis", 2) == "Neutral 80, Element 160 Münzen" and Skills.effect("startmana", 1) == "erster Zug: 3 Mana" and Skills.effect("gratisziehen", 0) == "eine Karte je Zug gratis", "Wirkungstexte in Zahlen")
+
+
 func test_ki_zeitbudget() -> void:
     var r := RandomNumberGenerator.new()
     r.seed = 12