Deckstärke, Schwierigkeitsgrade mit Archetypen, Gegnerdecks entlang der Energiekurve, Starter mit zwei seltenen Karten

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QPgKvy5W9WRNFHjkm5QsHx

tests/test_runner.gd

@@ -106,6 +106,8 @@ func _initialize() -> void:
     test_neue_fallen()
     test_kapitel_zwei_und_merkmalwahl()
     test_herausforderung_und_bestenliste()
+    test_deckstaerke_und_schwierigkeit()
+    test_starter_gegen_passende_gegner()
     print("%d Prüfungen bestanden, %d fehlgeschlagen" % [passed, failed])
     quit(1 if failed > 0 else 0)
 
@@ -456,7 +458,7 @@ func test_spielstand() -> void:
     p.coins = 999
     p.save(path)
     var p2 := Profile.load_or_new(path)
-    check(p2.coins == 999 and p2.deck.size() == 20 and p2.collection.size() == 39, "geladen")
+    check(p2.coins == 999 and p2.deck.size() == 20 and p2.collection.size() == 41, "geladen")
     for suffix in ["", ".bak"]:
         if FileAccess.file_exists(path + suffix):
             DirAccess.remove_absolute(abs + suffix)
@@ -1197,3 +1199,65 @@ func test_herausforderung_und_bestenliste() -> void:
     check(text.begins_with("karte;seltenheit;gespielt;partien;siege") and "beste_serie;5" in text, "CSV-Inhalt")
     DirAccess.remove_absolute(ProjectSettings.globalize_path(path))
     Profile.today_override = ""
+
+
+func test_deckstaerke_und_schwierigkeit() -> void:
+    check(is_equal_approx(Cards.card_value(C("f_kobold")), 1.0) and is_equal_approx(Cards.card_value(C("ff_phoenix")), 4.6), "Kartenwert aus Seltenheit, Schlüsselwörtern, Effekten")
+    var starter := Profile.starter().deck_cards()
+    var rs := Game.deck_rating(starter)
+    check(rs > 1.2 and rs < 1.5, "Starter mit zwei seltenen Karten bei etwa 1,3 (%.2f)" % rs)
+    check(Profile.starter().deck_valid()[0] and starter.any(func(c): return c.id == "f_drache") and starter.any(func(c): return c.id == "e_baum"), "Feuerdrache und Uralter Baum im Starterdeck")
+    var r := RandomNumberGenerator.new()
+    r.seed = 5
+    for target in [1.2, 1.6, 2.2, 2.6]:
+        for elems in [["Feuer"], ["Wasser", "Luft"]]:
+            var d := Game.build_opponent_deck_rated(r, elems, target)
+            check(Game.validate_deck(d)[0] and absf(Game.deck_rating(d) - target) <= 0.25, "Zielstärke %.1f für %s erreicht (%.2f)" % [target, "+".join(elems), Game.deck_rating(d)])
+    var strong := Game.build_opponent_deck_rated(r, ["Feuer", "Luft"], 3.0)
+    check(Game.deck_rating(strong) >= 2.8, "Zielstärke 3,0 mit zwei Elementen erreichbar (%.2f)" % Game.deck_rating(strong))
+    var g := Game.new_battle(starter, 2, r, {"target_rating": 1.3})
+    for o in g.opponents:
+        check(absf(Game.deck_rating(o.deck + o.hand) - 1.3) <= 0.3, "Gegner auf Zielstärke (%.2f)" % Game.deck_rating(o.deck + o.hand))
+    check(is_equal_approx(Campaign.target_rating(0, 1.3), 1.3) and is_equal_approx(Campaign.target_rating(0, 2.5), 2.5) and is_equal_approx(Campaign.target_rating(9, 1.3), 2.6), "Kampagne: Stufe oder eigene Stärke, was höher ist")
+    var opps := Campaign.opponents(2, r, 1.3)
+    check(opps.size() == 2 and absf(Game.deck_rating(opps[0].deck) - 1.5) <= 0.25 and absf(Game.deck_rating(opps[1].deck) - 1.5) <= 0.3, "Borin und Gefolge auf 1,5")
+    var p := Profile.starter()
+    check(p.difficulty().name == "Normal" and is_equal_approx(p.target_rating(), rs), "Normal: Zielstärke gleich eigener Stärke")
+    p.settings.difficulty = "schwer"
+    check(is_equal_approx(p.target_rating(), rs * 1.2) and p.difficulty().smart, "Schwer: 1,2-fach mit Vorausschau-KI")
+    p.settings.difficulty = "leicht"
+    check(not p.difficulty().smart and is_equal_approx(p.target_rating(), rs * 0.9), "Leicht: einfache KI, 0,9-fach")
+    var reward := p.record_battle(true, 1, starter, -1, [], 5, {}, p.difficulty().reward)
+    check(reward == int(round(Profile.REWARD_WIN[1] * 0.75)), "Leicht: weniger Münzen")
+    var v := Profile.from_dict(JSON.parse_string(JSON.stringify(p.to_dict())))
+    check(v.settings.difficulty == "leicht", "Schwierigkeit gespeichert")
+    v.settings.difficulty = "unsinn"
+    check(v.difficulty().name == "Normal", "unbekannte Schwierigkeit fällt auf Normal zurück")
+
+
+func test_starter_gegen_passende_gegner() -> void:
+    check(Game.archetypes("leicht").size() == 5 and Game.archetypes("schwer").size() == 5 and Game.archetypes().size() == 10, "Archetypen geteilt")
+    check("Wasser" in Game.archetypes("leicht") and "Erde+Luft" in Game.archetypes("schwer"), "schwache und starke Archetypen")
+    var r := RandomNumberGenerator.new()
+    r.seed = 6
+    var starter := Profile.starter().deck_cards()
+    var rs := Game.deck_rating(starter)
+    var results := {}
+    for key in ["leicht", "schwer"]:
+        var d: Dictionary = Profile.DIFFICULTIES[key]
+        var wins := 0
+        var games := 24
+        for i in games:
+            var g := Game.new_battle(starter, 1, r, {"target_rating": rs * float(d.factor), "tier": d.tier})
+            var arch := Cards.combo_key(Game.deck_elements(g.opponents[0].deck + g.opponents[0].hand))
+            check(arch in Game.archetypes(d.tier), "Archetyp passt zur Stufe (%s)" % arch)
+            var guard := 0
+            while g.winner == "" and guard < 300:
+                var p := g.current()
+                AI.take_turn(g, p, (not d.smart) and not p.is_human)
+                guard += 1
+            if g.winner == "human":
+                wins += 1
+        results[key] = wins
+    check(results.leicht > results.schwer, "Leicht ist leichter als Schwer (%d zu %d von 24)" % [results.leicht, results.schwer])
+    check(results.leicht >= 16, "Leicht: Starter gewinnt meistens (%d von 24)" % results.leicht)