genre-pack-turnbased

Genre Pack: Turn-Based

Patterns for turn-based games — works for tactics RPGs, card games, roguelikes, and grid-based puzzlers. Designed for deterministic resolution so games are replay-friendly and netcode-friendly.

Core idea

• An Actor is anything that takes turns (player, enemy, summon).
• The TurnManager orders actors by initiative and yields control to each in turn.
• Actors submit Actions; Actions get resolved deterministically.
• All randomness goes through a seeded RNG so the same input → same output.

TurnManager

autoload/turn_manager.gd:

extends Node
## Round-based turn manager. Actors are ordered by initiative each round.
## Emits signals for UI; calls `take_turn()` on each Actor and awaits completion.

signal round_started(round_num: int)
signal round_ended(round_num: int)
signal turn_started(actor: Actor)
signal turn_ended(actor: Actor)
signal battle_ended(winner_team: StringName)

var actors: Array[Actor] = []
var current_round: int = 0
var current_actor_index: int = 0
var battle_running: bool = false

func start_battle(participants: Array[Actor]) -> void:
    actors = participants
    current_round = 0
    battle_running = true
    _next_round()

func _next_round() -> void:
    if not battle_running:
        return
    current_round += 1
    actors.sort_custom(func(a, b): return a.initiative > b.initiative)
    round_started.emit(current_round)
    current_actor_index = -1
    _next_turn()

func _next_turn() -> void:
    if not battle_running:
        return
    current_actor_index += 1
    if current_actor_index >= actors.size():
        round_ended.emit(current_round)
        _check_victory()
        if battle_running:
            _next_round()
        return
    var actor := actors[current_actor_index]
    if not actor.is_alive():
        _next_turn()
        return
    turn_started.emit(actor)
    await actor.take_turn()
    turn_ended.emit(actor)
    _next_turn()

func _check_victory() -> void:
    var teams: Dictionary[StringName, int] = {}
    for a in actors:
        if a.is_alive():
            teams[a.team] = teams.get(a.team, 0) + 1
    if teams.size() <= 1:
        battle_running = false
        var winner: StringName = teams.keys()[0] if teams.size() == 1 else &"draw"
        battle_ended.emit(winner)

func end_battle() -> void:
    battle_running = false