update

scripts/core/Game.gd

@@ -20,6 +20,11 @@ var pairings: Array = []      ## [{a, b, ghost}]
 var player_combat: Combat = null
 var pending: Array = []       ## Ergebnisse der Bot-Kämpfe
 var last_round_log: Array = []
+var plan_left: float = Data.PLAN_SECONDS
+var timer_enabled: bool = true
+var human_recap: Dictionary = {}   ## Rückblick auf den letzten eigenen Kampf
+## Zählt, wie oft der Mensch gewonnen bzw. verloren hat (für Sound und Anzeige).
+var human_last_result: int = 0   ## 1 Sieg, -1 Niederlage, 0 unentschieden/keine
 
 
 func start(seed_value: int = 0) -> void:
@@ -37,7 +42,9 @@ func start(seed_value: int = 0) -> void:
 	round_no = 1
 	for p in players:
 		p.roll_shop(pool, rand)
+	pairings = _make_pairings()
 	_run_bot_turns()
+	plan_left = Data.PLAN_SECONDS
 	phase = Phase.PLANNING
 
 
@@ -54,7 +61,21 @@ func alive_players() -> Array:
 func _run_bot_turns() -> void:
 	for p in players:
 		if p.is_bot and p.alive:
-			bots[p.pid].take_turn(p, pool, rand, round_no)
+			bots[p.pid].take_turn(p, pool, rand)
+			bots[p.pid].arrange(p, opponent_of(p))
+
+
+## Planungsuhr. Läuft sie ab, startet der Kampf von selbst.
+## Gibt true zurück, wenn dadurch die Phase gewechselt hat.
+func tick_planning(dt: float) -> bool:
+	if phase != Phase.PLANNING or not timer_enabled:
+		return false
+	plan_left -= dt
+	if plan_left <= 0.0:
+		plan_left = 0.0
+		start_combat()
+		return true
+	return false
 
 
 # --- Kampfphase ------------------------------------------------------------
@@ -62,12 +83,16 @@ func _run_bot_turns() -> void:
 func start_combat() -> void:
 	if phase != Phase.PLANNING:
 		return
-	pairings = _make_pairings()
+	# Abbilder erst jetzt kopieren, damit sie den aktuellen Stand zeigen.
+	for pr in pairings:
+		if pr["ghost"]:
+			pr["b"] = _make_ghost(pr["ghost_src"])
 	pending.clear()
 	player_combat = null
 	for pr in pairings:
 		if pr["a"] == human or pr["b"] == human:
 			player_combat = Combat.new(pr["a"], pr["b"], rand.randi())
+			player_combat.record_hits = true
 			pending.append({"pair": pr, "combat": player_combat})
 		else:
 			var c := Combat.new(pr["a"], pr["b"], rand.randi())
@@ -107,7 +132,7 @@ func _make_pairings() -> Array:
 		if others.is_empty():
 			return out
 		var src: PlayerState = others[rand.randi_range(0, others.size() - 1)]
-		out.append({"a": lone, "b": _make_ghost(src), "ghost": true})
+		out.append({"a": lone, "b": _make_ghost(src), "ghost": true, "ghost_src": src})
 	return out
 
 
@@ -129,18 +154,25 @@ func resolve_round() -> void:
 			c.run_to_end()
 		var a: PlayerState = pr["a"]
 		var b: PlayerState = pr["b"]
-		var dmg := 3 + c.survivors
+		var base := Data.round_base_damage(round_no)
+		var dmg := base + c.survivor_stars
+		if a == human or b == human:
+			human_last_result = 0 if c.winner < 0 else (1 if pr["a" if c.winner == 0 else "b"] == human else -1)
+			human_recap = c.recap(0 if a == human else 1)
+			human_recap["opponent"] = (b if a == human else a).pname
+			human_recap["result"] = human_last_result
+			human_recap["damage"] = dmg if c.winner >= 0 else base
 		if c.winner == 0:
 			_apply_result(a, b, dmg, pr["ghost"])
 		elif c.winner == 1:
 			_apply_result(b, a, dmg, pr["ghost"])
 		else:
 			a.register_result(false)
-			a.take_damage(3)
+			a.take_damage(base)
 			if not pr["ghost"]:
 				b.register_result(false)
-				b.take_damage(3)
-			last_round_log.append("%s vs %s: unentschieden" % [a.pname, b.pname])
+				b.take_damage(base)
+			last_round_log.append("%s vs %s: unentschieden (-%d)" % [a.pname, b.pname, base])
 	pending.clear()
 	player_combat = null
 	_check_eliminations()
@@ -176,13 +208,26 @@ func _next_round() -> void:
 		if not p.alive:
 			continue
 		p.gold += p.round_income()
-		p.roll_shop(pool, rand)
+		p.gain_xp(Data.XP_PER_ROUND)
+		p.new_round_shop(pool, rand)
+	pairings = _make_pairings()
 	_run_bot_turns()
+	plan_left = Data.PLAN_SECONDS
 	phase = Phase.PLANNING
 
 
 # --- Hilfen für die UI ----------------------------------------------------
 
+## Gegner eines Spielers in der aktuellen Paarung (Abbilder liefern ihre Quelle).
+func opponent_of(p: PlayerState) -> PlayerState:
+	for pr in pairings:
+		if pr["a"] == p:
+			return pr["ghost_src"] if pr["ghost"] else pr["b"]
+		if pr["b"] == p:
+			return pr["a"]
+	return null
+
+
 func human_opponent() -> PlayerState:
 	for pr in pairings:
 		if pr["a"] == human: