update

tests/ui_test.gd

@@ -133,11 +133,8 @@ func screen():
     return main.screen
 
 
-## Jeder Abschnitt startet im Menü, auch wenn ein vorheriger abgebrochen ist; ohne Startdeck wird
-## Feuer gewählt.
+## Jeder Abschnitt startet im Menü, auch wenn ein vorheriger abgebrochen ist.
 func ensure_menu() -> void:
-    if screen() is StartDeckScreen:
-        await click(find_button("Feuer wählen"))
     if TranslationServer.get_locale().begins_with("en"):
         main.set_language("de")
     if not (screen() is MenuScreen):
@@ -188,7 +185,7 @@ func _ready() -> void:
     main.sfx.muted = true  # Tests bleiben still
     await frames(3)
     var suite := [test_start, test_menu, test_gamepad_menue, test_booster, test_gegnerauswahl, test_einstellungen,
-            test_kampagne, test_sammlung, test_deck, test_sprache, test_kampf_steuerung, test_kampf_elemente_und_verschmelzen, test_kampf_grenzen]
+            test_kampagne, test_sammlung, test_skilltree, test_cheats, test_deck, test_sprache, test_kampf_steuerung, test_kampf_elemente_und_verschmelzen, test_kampf_grenzen]
     suite += [test_kampf.bind(3), test_kampf_abbrechen]
     suite.append(test_profil_zuruecksetzen)
     var only := OS.get_environment("DINGER_ONLY")  # z. B. DINGER_ONLY=test_sammlung,test_kampf
@@ -204,16 +201,14 @@ func _ready() -> void:
     get_tree().quit(1 if failed > 0 else 0)
 
 
-## Erster Start: eines von vier Startdecks wählen (ensure_menu hat schon eins gewählt, darum frisch).
+## Neues Profil: die neutralen Karten als Sammlung und Stapel, direkt ins Menü.
 func test_start() -> void:
     main.reset_profile()
     await frames(2)
-    check(screen() is StartDeckScreen and not main.profile.started(), "neues Profil: Startdeck wählen")
-    await shot("00_startdeck")
-    await click(find_button("Feuer wählen"))
     var p: Profile = main.profile
-    check(screen() is MenuScreen and p.started() and p.deck.size() == Game.DECK_MIN and p.deck.filter(func(id): return Cards.by_id(id).elements[0] == "Feuer").size() == 25, "Feuer gewählt: 40 Karten, 25 davon Feuer")
-    check(Profile.load_or_new(SAVE).started(), "gespeichert")
+    check(screen() is MenuScreen and p.collection.size() == 110 and p.deck.size() == Game.DECK_MIN and p.deck.all(func(id): return Cards.by_id(id).is_neutral()), "neues Profil: 110 Neutrale, 30 im Stapel")
+    await shot("00_start")
+    check(Profile.load_or_new(SAVE).collection.size() == 110, "gespeichert")
 
 
 func test_menu() -> void:
@@ -244,6 +239,32 @@ func test_booster() -> void:
         else:
             check(res.dust > 0, "sonst gibt es Staub")
     check(scr.b_buy.disabled == (main.profile.coins < Profile.BOOSTER_COST), "Kaufknopf folgt dem Münzstand")
+    check(not scr.pack_tiles["Feuer"].visible and scr.pack_tiles[Cards.NEUTRAL].visible and scr.pack_tiles[Cards.NEUTRAL].position.x == 530, "Feuer-Pack bis Kapitel 2 unsichtbar, Neutral mittig")
+    check(scr.summary_label.text.ends_with("Staub") and scr.pack_tiles[Cards.NEUTRAL].pulse, "Fazit steht, das gekaufte Pack pulsiert")
+    var saved_coins: int = main.profile.coins
+    main.profile.campaign_stage = Campaign.STAGES_PER_CHAPTER
+    main.profile.coins = Profile.ELEMENT_BOOSTER_COST
+    scr.refresh()
+    check(scr.pack_tiles["Feuer"].visible and not scr.pack_buttons["Feuer"].disabled and "200" in scr.pack_tiles["Feuer"].hint and not scr.pack_tiles["Wasser"].visible, "Kapitel 2 offen: Feuer kaufbar, Wasser unsichtbar")
+    await click(scr.pack_buttons["Feuer"])
+    check(main.profile.coins == 0 and scr.cards.size() == 5 and scr.cards.all(func(res): return res.card.elements[0] == "Feuer"), "Feuer-Booster: fünf Feuerkarten")
+    await click(scr.b_all)
+    await shot("04b_booster_feuer")
+    main.profile.coins = Profile.BOOSTER_COST * 5
+    scr.refresh()
+    check(not scr.pack_tiles[Cards.NEUTRAL].buy_buttons[1].disabled and scr.pack_tiles[Cards.NEUTRAL].buy_buttons[2].disabled, "×5 bezahlbar, ×10 nicht")
+    await click(scr.pack_tiles[Cards.NEUTRAL].buy_buttons[1])
+    check(scr.cards.size() == 25 and main.profile.coins == 0 and scr.revealed.is_empty() and scr.slots.get_children().filter(func(c): return c is BoosterScreen.CardBack).size() == 25, "fünf Packs auf einmal: 25 verdeckte Karten")
+    check(Cards.RARITIES.find(scr.cards[0].rarity) >= Cards.RARITIES.find(scr.cards[24].rarity), "beste Stufe zuerst")
+    await frames(30)
+    await shot("04c_booster_fuenf_zu")
+    await click(scr.b_all)
+    check(scr.revealed.size() == 25 and scr.summary_label.text.begins_with(str(scr.cards.filter(func(x): return x.new).size())) and "Staub" in scr.summary_label.text, "alle aufgedeckt, Fazit zählt neu und Staub")
+    await frames(40)
+    await shot("04d_booster_fuenf_offen")
+    main.profile.campaign_stage = 0
+    main.profile.coins = saved_coins
+    main.save()
     await click(find_button("Zurück"))
     check(screen() is MenuScreen, "zurück im Menü")
 
@@ -395,13 +416,13 @@ func test_gegnerauswahl() -> void:
     check(find_button("Neu würfeln") == null and find_button("Feuer") == null and find_button("Starten") != null, "nur Schwierigkeit und Starten")
     await click(find_button("Schwer"))
     check(main.profile.settings.difficulty == "schwer" and Profile.load_or_new(SAVE).settings.difficulty == "schwer", "Schwer gewählt und gespeichert")
-    check(str(Profile.DIFFICULTIES.schwer.life) in sel.info_label.text and str(int(Profile.REWARD_WIN * 1.5)) in sel.info_label.text, "Leben des Gegners und Belohnung stehen dabei")
+    check("Rare" in sel.info_label.text and "Merkmal" in sel.info_label.text and "×2" in sel.info_label.text, "Schwer: Gegnerkarten Rare, Merkmal und Münzfaktor stehen dabei: " + sel.info_label.text)
     await shot("07_gegnerauswahl")
     await click(find_button("Starten"))
     var hard = screen()
     check(hard is BattleScreen and hard.game.players.size() == 2, "Duell gestartet")
     var opp: Game.Player = hard.game.opponent
-    check(opp.max_life == Profile.DIFFICULTIES.schwer.life and hard.smart_ai, "Schwer: Gegner mit %d Leben, Vorausschau-KI" % Profile.DIFFICULTIES.schwer.life)
+    check(opp.max_life == Game.START_LIFE and hard.smart_ai and opp.perks.size() == 1 and opp.looks.values().all(func(l): return l == 1) and opp.title == Cards.NEUTRAL, "Schwer: 30 Leben, Vorausschau-KI, ein Merkmal, Neutral in Rare")
     check(hard.game.human.hand.size() == Game.START_HAND and hard.hand_views.size() == Game.START_HAND, "Start: fünf Karten auf der Hand")
     var mine: Array = main.profile.deck_cards()
     check(hard.game.human.hand.all(func(c): return c.id in mine), "die Starthand kommt ungefiltert vom eigenen Stapel")
@@ -414,7 +435,7 @@ func test_gegnerauswahl() -> void:
     await click(find_button("Starten"))
     var easy = screen()
     opp = easy.game.opponent
-    check(opp.max_life == Profile.DIFFICULTIES.leicht.life and not easy.smart_ai, "Leicht: Gegner mit %d Leben, einfache KI" % Profile.DIFFICULTIES.leicht.life)
+    check(opp.max_life == Game.START_LIFE and not easy.smart_ai and opp.perks.is_empty() and opp.looks.values().all(func(l): return l == 0), "Leicht: 30 Leben, einfache KI, kein Merkmal, Common")
     check(easy.game.players[0].max_energy == Game.START_MANA and easy.game.human.life == Game.START_LIFE, "gleiche Regeln für beide")
     await give_up()
     await click(find_button("Einzelspieler"))
@@ -473,28 +494,89 @@ func test_einstellungen() -> void:
     check(screen() is MenuScreen, "zurück im Menü")
 
 
-## Deck: eigene Karten rein und raus, Auffüllen nach Filter, Speichern. Beginnt mit dem frischen Startdeck.
-func test_deck() -> void:
-    main.profile.choose_start("Feuer")
+## Skilltree: Level und Punkte aus der Erfahrung, Lernen verbraucht Punkte, Knöpfe folgen dem Stand.
+func test_skilltree() -> void:
+    main.profile.xp = Skills.xp_for_level(3)
+    main.profile.skills = {}
     main.save()
+    await click(find_button("Skilltree"))
+    var scr = screen()
+    check(scr is SkillScreen and scr.level_label.text == "Level 3" and scr.points_label.text == "Skillpunkte: 3", "Skilltree: Level 3, drei Punkte")
+    check(scr.learn_buttons.size() == Skills.SKILLS.size() and not scr.learn_buttons["packglueck"].disabled and scr.xp_label.text == "0 / 400 EP bis Level 4", "alle Skills mit Lernen-Knopf, Fortschritt bis Level 4")
+    check(scr.now_labels["packglueck"].text == "Jetzt: Chancen 45/25/15/10/5 %" and scr.next_labels["packglueck"].text == "Nächste Stufe: Chancen 37/28/17/12/6 %", "Wirkung jetzt und nächste Stufe in Zahlen")
+    await click(scr.learn_buttons["packglueck"])
+    check(main.profile.skill("packglueck") == 1 and scr.points_label.text == "Skillpunkte: 2" and scr.rank_labels["packglueck"].text == "Stufe 1 / 3", "Packglück gelernt, Punkt verbraucht")
+    await click(scr.learn_buttons["gratisziehen"])
+    check(scr.learn_buttons["gratisziehen"].disabled and scr.rank_labels["gratisziehen"].text == "Stufe 1 / 1" and scr.next_labels["gratisziehen"].text == "Höchste Stufe erreicht", "Freies Ziehen voll: Knopf aus")
+    await shot("28_skilltree")
+    check(Profile.load_or_new(SAVE).skill("packglueck") == 1, "gespeichert")
+    await click(find_button("Zurück"))
+    check(screen() is MenuScreen and screen().coll_label.text.ends_with("Level 3"), "zurück im Menü, Level steht dabei")
+    main.profile.xp = 0
+    main.profile.skills = {}
+    main.save()
+
+
+## Cheats: Knöpfe setzen Münzen, Level, Kapitel und Sammlung sofort und speichern.
+func test_cheats() -> void:
+    await click(find_button("Cheats"))
+    var scr = screen()
+    check(scr is CheatScreen and scr.status_label.text.begins_with("Münzen %d" % main.profile.coins), "Cheats geöffnet, Stand steht oben")
+    var coins: int = main.profile.coins
+    await click(find_button("+1.000 Münzen"))
+    check(main.profile.coins == coins + 1000 and Profile.load_or_new(SAVE).coins == coins + 1000 and scr.msg_label.text == "Gespeichert", "+1.000 Münzen, gespeichert")
+    await click(find_button("+1 Level"))
+    check(main.profile.player_level() == 1 and main.profile.skill_points() == 1, "+1 Level: ein Skillpunkt")
+    await click(find_button("Kapitel 3 frei"))
+    check(main.profile.campaign_stage == 20 and main.profile.unlocked_elements().size() == 3, "Kapitel 3 frei: Neutral, Feuer, Wasser")
+    await click(find_button("Alle Karten Ultimate Rare"))
+    check(main.profile.collection.size() == Cards.all().size() and main.profile.level("f_5_5") == 4, "alle 550 Karten in Ultimate Rare")
+    await shot("29_cheats")
+    await click(find_button("Sammlung zurücksetzen"))
+    check(main.profile.collection.size() == 110 and main.profile.deck.size() == Game.DECK_MIN, "Sammlung wieder am Start")
+    await click(find_button("Kampagne zurücksetzen"))
+    await click(find_button("Erfahrung auf 0"))
+    check(main.profile.campaign_stage == 0 and main.profile.xp == 0, "Kampagne und Erfahrung zurück")
+    await click(find_button("Zurück"))
+    check(screen() is MenuScreen, "zurück im Menü")
+
+
+## Deck: eigene Karten rein und raus, Auffüllen nach Filter, Speichern. Beginnt mit einem frischen Profil.
+func test_deck() -> void:
+    main.reset_profile()
+    await frames(2)
     await click(find_button("Deck"))
     var scr = screen()
     check(scr is DeckScreen, "Deck geöffnet")
     var p: Profile = main.profile
     check(scr.grid.views().size() == p.collection.size() and scr.count_label.text == "Stapel: %d Karten (%d bis %d)" % [p.deck.size(), Game.DECK_MIN, Game.DECK_MAX], "alle eigenen Karten, Zähler stimmt")
-    check(scr.strength_label.text == "Stärke 100", "Startdeck aus Grundkarten: Stärke 100")
+    check(scr.strength_label.text == "Stärke 100", "Startsammlung aus Grundkarten: Stärke 100")
     p.collection[p.deck[0]] = 4
     scr.refresh()
     await frames(2)
-    check(scr.strength_label.text == "Stärke %d" % roundi((39 * 100 + 500) / 40.0), "eine Ultimate Rare hebt die Stärke: " + scr.strength_label.text)
+    check(scr.strength_label.text == "Stärke %d" % roundi((29 * 100 + 500) / 30.0), "eine Ultimate Rare hebt die Stärke: " + scr.strength_label.text)
+    check(scr.grid.views()[0].card.id == p.deck[0] and scr.grid.views()[0].rarity == "Ultimate Rare", "höchste Stufe steht vorn")
     p.collection[p.deck[0]] = 0
     scr.refresh()
     await frames(2)
     var views: Array = scr.grid.views()
-    check(views.all(func(v): return not v.dim) and p.deck.size() == Game.DECK_MIN, "nach dem Start sind alle eigenen Karten im Stapel")
+    check(views.size() == 110 and views.slice(0, Game.DECK_MIN).all(func(v): return not v.dim and v.marked) and views[Game.DECK_MIN].dim and not views[Game.DECK_MIN].marked and p.deck.size() == Game.DECK_MIN, "Stapelkarten vorn mit Haken, der Rest dunkel")
+    check(scr.curve.counts.size() == 11 and scr.curve.counts.reduce(func(a, v): return a + v, 0) == Game.DECK_MIN and scr.curve.counts[0] == 2, "Manakurve: 30 Karten verteilt, zwei zu 0 Mana")
+    check(scr.share.counts == {Cards.NEUTRAL: Game.DECK_MIN} and scr.share.shown() == [Cards.NEUTRAL], "Elementanteile: nur Neutral")
+    check(views[0].card.cost <= views[1].card.cost and views[Game.DECK_MIN].card.cost <= views[Game.DECK_MIN + 1].card.cost, "innerhalb von Stapel und Rest nach Kosten")
+    await click(scr.cost_buttons[3])
+    views = scr.grid.views()
+    check(scr.cost_filter == 3 and views.size() == 15 and views.all(func(v): return v.card.cost == 3), "Manafilter 3: nur die 15 Karten zu 3 Mana")
+    await click(scr.cost_buttons[3])
+    views = scr.grid.views()
+    check(scr.cost_filter == -1 and views.size() == 110, "derselbe Knopf hebt den Manafilter auf")
+    check(scr.element_buttons.size() == 5 and scr.element_buttons["Feuer"].tooltip_text == "Feuer" and not scr.element_buttons["Feuer"].visible and scr.element_buttons[Cards.NEUTRAL].visible and scr.element_buttons[Cards.NEUTRAL].position.x == 108, "Elementfilter als Symbolknöpfe, nur offene Elemente")
+    await hover(views[2])
+    check(scr.preview_holder.get_child_count() == 1 and scr.preview_holder.get_child(0).card.id == views[2].card.id, "Zeigen stellt die Karte groß in die Vorschau")
     var first_id: String = views[0].card.id
     await click(views[0])
-    check(not (first_id in p.deck) and p.deck.size() == Game.DECK_MIN - 1 and scr.grid.views().any(func(v): return v.card.id == first_id and v.dim), "Klick nimmt die Karte aus dem Stapel, sie wird dunkel")
+    check(not (first_id in p.deck) and p.deck.size() == Game.DECK_MIN - 1 and scr.grid.views().any(func(v): return v.card.id == first_id and v.dim and not v.marked), "Klick nimmt die Karte aus dem Stapel, sie wird dunkel und verliert den Haken")
+    check(scr.curve.counts.reduce(func(a, v): return a + v, 0) == Game.DECK_MIN - 1 and scr.msg_label.text == "Klick auf eine Karte: rein oder raus.", "Manakurve folgt, Hinweis steht")
     var back_view = scr.grid.views().filter(func(v): return v.card.id == first_id)[0]
     scr.grid.ensure_control_visible(back_view)  # sie liegt jetzt hinter den Stapelkarten, außerhalb des Sichtbereichs
     await frames(2)
@@ -503,12 +585,21 @@ func test_deck() -> void:
     await shot("19_deck")
     await click(find_button("Leeren"))
     check(p.deck.is_empty(), "geleert")
-    await click(find_button("Wasser"))
+    for id in ["w_0_1", "w_0_2", "w_0_3", "w_0_4", "w_0_5"]:
+        p.collection[id] = 0
+    main.profile.campaign_stage = 2 * Campaign.STAGES_PER_CHAPTER  # Wasser offen
+    scr.refresh()
+    await frames(1)
+    check(scr.element_buttons["Wasser"].visible and scr.element_buttons["Wasser"].position.x == 108 + 2 * 40, "Kapitel 3 offen: Wasserfilter an dritter Stelle")
+    await click(scr.element_buttons["Wasser"])
     await click(find_button("Auffüllen"))
     check(p.deck.size() == 5 and p.deck.all(func(id): return Cards.by_id(id).elements[0] == "Wasser"), "Auffüllen hält sich an den Filter: nur die fünf Wasserkarten")
+    check(scr.share.shown() == ["Wasser"] and scr.share.counts["Wasser"] == 5, "Elementanteile: fünf Wasser")
     await click(find_button("Alle"))
     await click(find_button("Auffüllen"))
-    check(p.deck.size() == Game.DECK_MIN and Profile.load_or_new(SAVE).deck == p.deck, "ohne Filter alles, gespeichert")
+    check(p.deck.size() == Game.DECK_MAX and Profile.load_or_new(SAVE).deck == p.deck, "ohne Filter bis 60, gespeichert")
+    main.profile.campaign_stage = 0
+    main.save()
     await click(find_button("Zurück"))
     check(screen() is MenuScreen, "zurück im Menü")
 
@@ -518,30 +609,38 @@ func test_sammlung() -> void:
     var scr = screen()
     check(scr is CollectionScreen, "Sammlung geöffnet")
     var p: Profile = main.profile
-    check(scr.grid.views().size() == Cards.all().size(), "alle Karten des Spiels sind zu sehen")
-    check(scr.grid.views().slice(0, p.collection.size()).all(func(v): return not v.dim) and scr.grid.views().back().dim, "eigene Karten vorn, fehlende abgedunkelt")
+    check(scr.grid.views().size() == 110 and scr.grid.views().all(func(v): return v.card.is_neutral()), "nur die Karten offener Elemente: zu Beginn die 110 Neutralen")
+    check(find_button("Feuer") == null and find_button("Neutral") != null, "Filter nur für offene Elemente")
+    check(scr.grid.views().all(func(v): return not v.dim), "zu Beginn gehören dir alle gezeigten Karten")
     p.dust = 5000
-    scr.search_box.text = "Lodernder Funke"
-    scr.search_box.text_changed.emit("Lodernder Funke")
+    scr.search_box.text = "Tapferer Knappe"
+    scr.search_box.text_changed.emit("Tapferer Knappe")
     await frames(1)
-    var funke = scr.grid.views().filter(func(v): return v.card.id == "f_2_1")[0]
+    var funke = scr.grid.views().filter(func(v): return v.card.id == "n_2_1")[0]
     await click(funke)
-    check(scr.selected.id == "f_2_1" and p.rarity("f_2_1") == "Common" and scr.b_upgrade.visible, "eigene Karte gewählt, noch Common")
+    check(scr.selected.id == "n_2_1" and p.rarity("n_2_1") == "Common" and scr.b_upgrade.visible, "eigene Karte gewählt, noch Common")
     await click(scr.b_upgrade)
-    check(p.level("f_2_1") == 1 and p.dust == 5000 - Profile.DUST_UPGRADE["Rare"], "auf Rare aufgewertet")
+    check(p.level("n_2_1") == 1 and p.dust == 5000 - Profile.DUST_UPGRADE["Rare"], "auf Rare aufgewertet")
     scr.search_box.text = ""
     scr.search_box.text_changed.emit("")
     await frames(1)
-    var front = scr.grid.views().filter(func(v): return v.card.id == "f_2_1")[0]
+    var front = scr.grid.views().filter(func(v): return v.card.id == "n_2_1")[0]
     check(front.rarity == "Rare" and front.card.attack == 3 and front.card.health == 2 and scr.grid.views()[0].rarity != "Common", "die Rare zeigt +1/+1, aufgewertete stehen vorn: %s %d/%d" % [front.rarity, front.card.attack, front.card.health])
-    check(Profile.load_or_new(SAVE).level("f_2_1") == 1, "Sammlung gespeichert")
-    scr.search_box.text = "Lodernder Funke"
-    scr.search_box.text_changed.emit("Lodernder Funke")
+    check(Profile.load_or_new(SAVE).level("n_2_1") == 1, "Sammlung gespeichert")
+    scr.search_box.text = "Tapferer Knappe"
+    scr.search_box.text_changed.emit("Tapferer Knappe")
     await frames(1)
     var dust: int = p.dust
     await click(scr.b_dismantle)
-    check(p.level("f_2_1") == 0 and p.dust == dust + Profile.DUST_DISMANTLE["Rare"], "wieder zerlegt")
-    # Herstellen einer fehlenden Karte
+    check(p.level("n_2_1") == 0 and p.dust == dust + Profile.DUST_DISMANTLE["Rare"], "wieder zerlegt")
+    # Herstellen einer fehlenden Karte (Feuer: erst ab Kapitel 2 zu sehen)
+    scr.search_box.text = ""
+    scr.search_box.text_changed.emit("")
+    main.profile.campaign_stage = Campaign.STAGES_PER_CHAPTER
+    scr.refresh()
+    await frames(1)
+    var owned_shown: int = scr.grid.views().filter(func(v): return not v.dim).size()
+    check(scr.grid.views().size() == 220 and owned_shown < 220 and scr.grid.views().slice(0, owned_shown).all(func(v): return not v.dim) and scr.grid.views().slice(owned_shown).all(func(v): return v.dim), "Kapitel 2 offen: auch Feuer zu sehen, eigene vorn, fehlende abgedunkelt")
     scr.search_box.text = "Infernalischer Drache"
     scr.search_box.text_changed.emit("Infernalischer Drache")
     await frames(1)
@@ -551,6 +650,8 @@ func test_sammlung() -> void:
     await click(scr.b_craft)
     check(p.owns("f_5_5") and p.dust == dust - Profile.CRAFT_COST, "hergestellt")
     await shot("20_sammlung")
+    main.profile.campaign_stage = 0
+    main.save()
     await click(find_button("Zurück"))
     check(screen() is MenuScreen, "zurück im Menü")
 
@@ -594,9 +695,7 @@ func test_profil_zuruecksetzen() -> void:
     check(not scr.confirm.visible, "abgebrochen")
     await click(find_button("Profil zurücksetzen"))
     await click(find_button("Ja, zurücksetzen"))
-    check(screen() is StartDeckScreen and main.profile.coins == Profile.START_COINS and not main.profile.started(), "Profil zurückgesetzt: Startdeck neu wählen")
-    await click(find_button("Luft wählen"))
-    check(screen() is MenuScreen and main.profile.deck.filter(func(id): return Cards.by_id(id).elements[0] == "Luft").size() == 25, "Luft gewählt")
+    check(screen() is MenuScreen and main.profile.coins == Profile.START_COINS and main.profile.collection.size() == 110 and main.profile.campaign_stage == 0, "Profil zurückgesetzt: neutrale Startsammlung, zurück im Menü")
     check(Profile.load_or_new(SAVE).coins == Profile.START_COINS, "zurückgesetzt gespeichert")
 
 
@@ -745,9 +844,7 @@ func test_kampf_elemente_und_verschmelzen() -> void:
     await wait_for_human(scr)
     var g: Game = scr.game
     g.human.board.clear()
-    scr.opponent().board.clear()  # was die KI im ersten Zug gelegt hat, stört die Zähler
-    for e in Cards.ELEMENTS + [Cards.NEUTRAL]:
-        scr.opponent().played[e] = 0
+    scr.opponent().board.clear()  # was die KI im ersten Zug gelegt hat, stört die Paare
     var put := func(p: Game.Player, id: String, hidden: bool = false) -> Game.Creature:
         var cr := Game.Creature.new(Cards.by_id(id).copy(), p, g.next_uid)
         g.next_uid += 1
@@ -765,12 +862,11 @@ func test_kampf_elemente_und_verschmelzen() -> void:
     g.human.hand = [Cards.by_id("f_2_1").copy(), Cards.by_id("l_1_1").copy()]
     g.human.energy = 20
     g.human.looks = {"w_3_3": 3}
-    g.apply_auras()
     scr.refresh()
     await frames(2)
-    check(scr.element_view.text() == "Feuer 2/0 (Doppelschlag) · Wasser 1/0", "Zähler: nur Elemente mit Wesen oder gespielten Karten, Feuerpaar: " + scr.element_view.text())
-    check(scr.opp_element_view.text() == "Luft 1/0", "die Liste des Gegners zählt nur seine offenen Wesen: " + scr.opp_element_view.text())
-    check(g.human.board[0].keywords() == ["Doppelschlag"] and scr.tiles[secret.uid].secret and scr.hand_views[0].bonus == 0, "Feuerpaar gibt Doppelschlag; fremdes Verdecktes zeigt den Rücken; noch kein Bonus in Sicht")
+    check(scr.element_view.text() == "Feuer 2 (Doppelschlag) · Wasser 1", "Liste: nur Elemente mit offenen Wesen, Feuerpaar: " + scr.element_view.text())
+    check(scr.opp_element_view.text() == "Luft 1", "die Liste des Gegners zählt nur seine offenen Wesen: " + scr.opp_element_view.text())
+    check(g.human.board[0].keywords() == ["Doppelschlag"] and scr.tiles[secret.uid].secret, "Feuerpaar gibt Doppelschlag; fremdes Verdecktes zeigt den Rücken")
     # Rechtsklick auf die Handkarte: Menü mit Verdeckt legen, ohne Verschmelzen
     await hover(scr.hand_views[0])
     await right_click_at(scr.hand_views[0].get_global_rect().get_center())
@@ -786,7 +882,7 @@ func test_kampf_elemente_und_verschmelzen() -> void:
     var mana: int = g.human.energy
     await right_click_at(scr.hand_views[0].get_global_rect().get_center(), MOUSE_BUTTON_MIDDLE)
     var mine_hidden: Game.Creature = g.human.board[3]
-    check(mine_hidden.hidden and g.human.energy == mana - 1 and scr.element_view.text().begins_with("Feuer 2/1"), "mittlere Maustaste legt verdeckt: zählt als ausgespielt, nicht als offen")
+    check(mine_hidden.hidden and g.human.energy == mana - 1 and scr.element_view.text().begins_with("Feuer 2 (Doppelschlag)"), "mittlere Maustaste legt verdeckt: zählt nicht als offen")
     # Rechtsklick auf ein eigenes offenes Wesen: nichts zu wählen, also kein Menü
     await right_click_at(scr.own_views[0].get_global_rect().get_center())
     check(not scr.menu_layer.visible, "kein Menü ohne Einträge")
@@ -797,26 +893,15 @@ func test_kampf_elemente_und_verschmelzen() -> void:
     check(mine_hidden.hidden and scr.msg_label.text == "Lodernder Funke kann erst im nächsten Zug aufgedeckt werden", "im Legezug nicht aufzudecken: " + scr.msg_label.text)
     mine_hidden.ready = true
     await click(scr.own_views[3])
-    check(not mine_hidden.hidden and scr.element_view.text().begins_with("Feuer 3/1 (Doppelschlag)"), "aufgedeckt: drei offene Feuer, eine ausgespielt: " + scr.element_view.text())
-    check(wolf.power() == 3 and falke.power() == 3 and mine_hidden.can_attack(), "unter drei Karten kein Bonus, aufgedeckt greift sofort an")
-    g.human.played["Feuer"] = 3
-    g.apply_auras()
-    scr.refresh()
-    await frames(1)
-    check(scr.element_view.text().begins_with("Feuer 3/3 (Doppelschlag) (+1/+1)") and wolf.power() == 4 and falke.power() == 3, "drei Feuerkarten: +1/+1 für die eigenen Feuerwesen: " + scr.element_view.text())
-    check(scr.hand_views[0].bonus == 0, "die Luftkarte auf der Hand zeigt keinen Bonus")
-    await shot("23b_vier_feuer")
-    # Angriffsziel: Elementvorteil schlägt durch den Stapelbonus des Ziels, verdeckte ohne Anzeige, Held gesperrt
-    scr.opponent().played["Luft"] = 3
-    g.apply_auras()
-    scr.refresh()
-    await frames(1)
-    check(falke.aura == 1 and falke.power() == 4 and scr.opp_element_view.text() == "Luft 1/3 (+1/+1)", "der Gegner hat drei Luftkarten gespielt, der Falke trägt +1/+1: " + scr.opp_element_view.text())
+    check(not mine_hidden.hidden and scr.element_view.text().begins_with("Feuer 3 (Doppelschlag)"), "aufgedeckt: drei offene Feuer: " + scr.element_view.text())
+    check(wolf.power() == 3 and falke.power() == 3 and mine_hidden.can_attack(), "Werte bleiben die der Karten, aufgedeckt greift sofort an")
+    await shot("23b_drei_feuer")
+    # Angriffsziel: Feuer gegen Luft schlägt doppelt, der Falke kontert halb; verdeckte ohne Anzeige, Held gesperrt
     await click(scr.own_views[0])
-    check(scr.selected == wolf and scr.tiles[falke.uid].matchup == 1 and scr.tiles[secret.uid].matchup == 0, "Angreifer gewählt: +1 gegen den Falken (sein Bonus zählt nicht), nichts gegen Verdeckte")
-    check(scr.tiles[falke.uid].shown_stats() == [falke.power() - 1, falke.health], "der Falke zeigt seinen Konter gegen den Wolf (ohne seinen Bonus) und sein echtes Leben")
+    check(scr.selected == wolf and scr.tiles[falke.uid].matchup == -1 and scr.tiles[secret.uid].matchup == 0, "Angreifer gewählt: der Falke kontert halbiert, nichts gegen Verdeckte")
+    check(scr.tiles[falke.uid].shown_stats() == [2, falke.health], "der Falke zeigt seinen Konter gegen den Wolf: 3 halbiert, aufgerundet 2")
     await hover(scr.tiles[falke.uid])
-    check(scr.tiles[falke.uid].doomed and not scr.own_views[0].doomed and scr.own_views[0].shown_stats()[0] == wolf.power() + 1, "über dem Falken: er stirbt, der Wolf nicht, der Wolf schlägt mit +1 zu")
+    check(scr.tiles[falke.uid].doomed and not scr.own_views[0].doomed and scr.own_views[0].shown_stats()[0] == wolf.power() * 2, "über dem Falken: er stirbt, der Wolf nicht, der Wolf schlägt doppelt zu")
     await shot("23c_angreifer_gewaehlt")
     check(not g.can_attack(wolf, scr.opponent())[0], "Held nicht angreifbar, solange Wesen stehen")
     await click(scr.tiles[secret.uid])
@@ -866,7 +951,8 @@ func test_kampagne() -> void:
     var scr = screen()
     check(scr is CampaignScreen, "Kampagne geöffnet")
     await shot("15_kampagne")
-    check(scr.node_buttons.filter(func(b): return b.disabled).size() == Campaign.STAGES.size() - 1 and find_button("Kämpfen") != null, "neun Stationen gesperrt, die erste offen")
+    check(scr.node_buttons.filter(func(b): return b.disabled).size() == Campaign.STAGES_PER_CHAPTER - 1 and find_button("Kämpfen") != null, "neun Stationen gesperrt, die erste offen")
+    check(find_button("Kapitel 5") != null and find_button("Kapitel 5").disabled, "fünf Kapitel, das letzte gesperrt")
     await click(scr.node_buttons[3])
     check(scr.selected == 0, "gesperrte Station lässt sich nicht wählen")
     check(find_button("Kapitel 2").disabled and scr.perk_box == null, "Kapitel 2 und Merkmal noch gesperrt")
@@ -878,7 +964,7 @@ func test_kampagne() -> void:
     await shot("16_kampagne_kampf")
     await give_up()
     # Kapitel 1 als abgeschlossen setzen: Kapitel 2 und Merkmalwahl
-    main.profile.campaign_stage = Campaign.STAGES.size()
+    main.profile.campaign_stage = Campaign.STAGES_PER_CHAPTER
     await click(find_button("Kampagne"))
     var scr2 = screen()
     check(scr2.chapter == 2 and scr2.perk_box != null, "Kapitel 2 offen, Merkmal wählbar")
@@ -888,7 +974,8 @@ func test_kampagne() -> void:
     await shot("27_kampagne_kapitel2")
     await click(find_button("Kämpfen"))
     var b2 = screen()
-    check(b2 is BattleScreen and b2.stage == 10 and b2.game.opponent.perks.size() == 2 and b2.game.opponent.life == 22, "Kapitel-2-Boss mit zwei Merkmalen und 22 Leben")
+    check(b2 is BattleScreen and b2.stage == 10 and b2.game.opponent.perks.size() == 1 and b2.game.opponent.life == 22, "Kapitel-2-Gegner mit einem Merkmal und 22 Leben")
+    check(b2.game.opponent.deck.all(func(id): return Cards.by_id(id).elements[0] == "Feuer") and b2.game.opponent.looks.values().all(func(l): return l == 0), "Kapitel 2: nur Feuer in Common")
     check(b2.game.human.perks == [main.profile.perk], "eigenes Merkmal im Kampf")
     await give_up()
     main.profile.campaign_stage = 0
@@ -934,6 +1021,8 @@ func test_kampf(shot_turn: int) -> void:
     await frames(3)
     await shot("09_kampf_ende")
     check(scr.reward > 0 and main.profile.coins >= coins + scr.reward, "Belohnung gutgeschrieben")
+    check(scr.fast_turns > 0 and scr.reward == Profile.battle_coins(g.winner == "human", g.human.turns, g.human.cards_played, scr.fast_turns, main.profile.difficulty().reward), "Münzen aus Zügen, Karten und schnellen Zügen")
+    check(scr.detail_label.visible and tr("%d Züge") % g.human.turns in scr.detail_label.text and "= " in scr.detail_label.text, "Aufschlüsselung im Ergebnisbild")
     check(Profile.load_or_new(SAVE).coins == main.profile.coins, "Belohnung gespeichert")
     await click(find_button("Zurück zum Menü"))
     check(screen() is MenuScreen, "zurück im Menü")