client/spacewar/autoload/match_manager.gd

extends Node

# Server-authoritative match-phase state machine — see overview/map1.md.
# PRE_MATCH (ships hidden, capital ships creep into formation, countdown) ->
# IN_PROGRESS (ships released, GameMode's clock runs) -> POST_MATCH (winner
# banner) -> loops back into a fresh PRE_MATCH, forever, matching this
# project's always-on server-pool model (see CLAUDE.md item 16) rather than
# kicking players to the menu at match end.
#
# Follows the exact "decide once on the server, RPC-broadcast the concrete
# value, late joiners pull it" pattern world.gd's decide_offered_races()/
# _deliver_offered_races already established -- _begin_phase broadcasts a
# phase change to every already-connected peer; request_match_state() is the
# pull a late joiner uses to catch up.

enum Phase { PRE_MATCH, IN_PROGRESS, POST_MATCH }

signal phase_changed(phase: int, duration_sec: float)
signal match_ended(winner_race_id: int, is_draw: bool)

var phase: int = Phase.PRE_MATCH
var phase_started_at_msec: int = 0
var phase_duration_sec: float = 0.0
var current_mode: GameMode = null

var _world: Node = null


func _ready() -> void:
	# Every peer builds the same mode object locally from the same shared
	# GameConfig constant -- no replication needed, same as TeamSelect.RACES.
	current_mode = _create_mode(GameConfig.default_game_mode_id)


func _create_mode(mode_id: String) -> GameMode:
	match mode_id:
		"team_deathmatch":
			return TeamDeathmatchMode.new()
		_:
			return TeamDeathmatchMode.new()


# Called once by World._ready() (server only), after map/spawn setup.
func start(world: Node) -> void:
	if not multiplayer.is_server():
		return
	_world = world
	_run_match_loop()


func _run_match_loop() -> void:
	# Lets this frame's deferred flagship spawn (world.gd's decide_offered_races())
	# land before the first _set_phase(PRE_MATCH) call needs those nodes to exist
	# (see World._on_match_phase_changed(), which is what actually plays the
	# creep-in tween now -- see its own comment for why).
	await get_tree().process_frame
	while true:
		await _run_pre_match()
		await _run_in_progress()
		var result: Dictionary = current_mode.check_win_condition(_world)
		await _run_post_match(result)


func _run_pre_match() -> void:
	MatchStats.reset_for_new_match()
	_world.hold_all_ships_for_pre_match()
	var duration: float = GameConfig.match_pre_match_duration
	# Flagship creep-in is no longer triggered directly from here -- this
	# function only ever runs on the server (see start()), so a direct call
	# into World never reached remote clients, leaving their flagships static
	# the whole match. World now plays it off phase_changed instead (emitted
	# identically on every peer by the RPC below), so this just needs to
	# broadcast the phase.
	_set_phase(Phase.PRE_MATCH, duration)
	await get_tree().create_timer(duration).timeout


func _run_in_progress() -> void:
	var duration: float = current_mode.get_match_duration()
	_set_phase(Phase.IN_PROGRESS, duration)
	_world.release_held_ships()
	var elapsed := 0.0
	while elapsed < duration:
		await get_tree().create_timer(1.0).timeout
		elapsed += 1.0
		if current_mode.should_end_early(_world):
			break


func _run_post_match(result: Dictionary) -> void:
	_set_phase(Phase.POST_MATCH, GameConfig.match_post_match_duration)
	_announce_winner.rpc(result.winner_race_id, result.is_draw)
	_report_match_result(result)
	await get_tree().create_timer(GameConfig.match_post_match_duration).timeout


func _set_phase(new_phase: int, duration: float) -> void:
	_begin_phase.rpc(new_phase, duration)


@rpc("authority", "call_local", "reliable")
func _begin_phase(new_phase: int, duration: float) -> void:
	phase = new_phase
	phase_duration_sec = duration
	phase_started_at_msec = Time.get_ticks_msec()
	phase_changed.emit(new_phase, duration)


@rpc("authority", "call_local", "reliable")
func _announce_winner(winner_race_id: int, is_draw: bool) -> void:
	match_ended.emit(winner_race_id, is_draw)


func get_remaining_seconds() -> float:
	var elapsed := (Time.get_ticks_msec() - phase_started_at_msec) / 1000.0
	return max(0.0, phase_duration_sec - elapsed)


@rpc("any_peer", "call_remote", "reliable")
func request_match_state() -> void:
	if not multiplayer.is_server():
		return
	var sender_id := multiplayer.get_remote_sender_id()
	_deliver_match_state.rpc_id(sender_id, phase, get_remaining_seconds())


@rpc("authority", "call_remote", "reliable")
func _deliver_match_state(current_phase: int, remaining: float) -> void:
	phase = current_phase
	phase_duration_sec = remaining
	phase_started_at_msec = Time.get_ticks_msec()
	phase_changed.emit(current_phase, remaining)


# Reports this match's final per-player stats to matchmaking-api so
# Player.kills/deaths/wins/losses/hours_played persist across matches (see
# overview/map1.md). Bots (negative peer_id) never report -- no backend
# identity for them, they're padding, not a player's history.
func _report_match_result(result: Dictionary) -> void:
	if not multiplayer.is_server():
		return
	var players_payload: Array = []
	for peer_id in PlayerRegistry.players:
		if peer_id < 0:
			continue
		var info: Dictionary = PlayerRegistry.get_info(peer_id)
		var stats: Dictionary = MatchStats.get_stats(peer_id)
		var is_winner: bool = not result.is_draw and info.get("race", 0) == result.winner_race_id
		players_payload.append({
			"callsign": info.get("name", ""),
			"team": info.get("race", 0),
			"kills": stats.get("kills", 0),
			"deaths": stats.get("deaths", 0),
			"is_winner": is_winner,
			"seconds_played": current_mode.get_match_duration(),
		})
	if players_payload.is_empty():
		return
	var addr: Dictionary = NetworkManager.get_registered_address()
	var winner_team: int = -1 if result.is_draw else result.winner_race_id
	MatchmakingClient.report_match_result(addr.ip, addr.port, "casual", winner_team, players_payload)