putt_putt_run_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_MAX_HEALTH := 12
const DEFAULT_RUN_MODE_ID := "tutorial_3"
 
var run_modes:Array = []
var golfers:Array = []
var clubs:Array = []
var artifacts:Array = []
var consequences:Array = []
var holes:Array = []
 
 
func load_catalogs(options:Dictionary = {}) -> Dictionary:
    run_modes = _load_array(str(options.get("run_modes", "res://data/games/putt_putt_roguelike/run_modes.json")), "run_modes")
    golfers = _load_array(str(options.get("golfers", "res://data/games/putt_putt_roguelike/golfers.json")), "golfers")
    clubs = _load_array(str(options.get("clubs", "res://data/games/putt_putt_roguelike/clubs.json")), "clubs")
    artifacts = _load_array(str(options.get("artifacts", "res://data/games/putt_putt_roguelike/artifacts.json")), "artifacts")
    consequences = _load_array(str(options.get("consequences", "res://data/games/putt_putt_roguelike/consequences.json")), "consequences")
    holes = _load_array(str(options.get("holes", "res://data/games/putt_putt_roguelike/holes.json")), "holes")
    return {
        "run_modes": run_modes.size(),
        "golfers": golfers.size(),
        "clubs": clubs.size(),
        "artifacts": artifacts.size(),
        "consequences": consequences.size(),
        "holes": holes.size()
    }
 
 
func create_run(options:Dictionary = {}) -> Dictionary:
    var golfer_id:String = str(options.get("golfer_id", _first_id(golfers, "balanced_rookie")))
    var club_id:String = str(options.get("club_id", _first_id(clubs, "standard_putter")))
    var unlocked:Dictionary = _normalized_unlocks(options.get("unlocked", {}), golfer_id, club_id)
    var run_mode_id:String = str(options.get("run_mode_id", DEFAULT_RUN_MODE_ID))
    if not _id_in_rows(get_unlocked_run_modes({"unlocked": unlocked}), run_mode_id):
        run_mode_id = DEFAULT_RUN_MODE_ID
    var run_mode:Dictionary = get_run_mode(run_mode_id)
    var golfer:Dictionary = get_golfer(golfer_id)
    var stats:Dictionary = golfer.get("stats", {}).duplicate(true) if golfer.get("stats", {}) is Dictionary else {}
    var max_health:int = int(stats.get("max_health", DEFAULT_MAX_HEALTH))
    var seed:int = int(options.get("seed", Time.get_unix_time_from_system()))
    var hole_count:int = int(options.get("hole_count", int(run_mode.get("hole_count", 3))))
    var sequence:Array = build_hole_sequence(seed, hole_count, run_mode)
    return {
        "schema_version": 1,
        "game_id": "putt_putt_roguelike",
        "status": "active",
        "seed": seed,
        "run_mode_id": run_mode_id,
        "run_mode_name": str(run_mode.get("name", run_mode_id)),
        "golfer_id": golfer_id,
        "club_id": club_id,
        "stats": stats,
        "health": int(options.get("health", max_health)),
        "max_health": max_health,
        "hole_index": 0,
        "hole_sequence": sequence,
        "total_putts": 0,
        "hole_putts": 0,
        "furthest_hole": 1,
        "completed_holes": 0,
        "artifacts": [],
        "encounter": {},
        "pending_wheel": {},
        "last_result": {},
        "unlocked": unlocked
    }
 
 
func build_hole_sequence(seed:int, count:int, run_mode:Dictionary = {}) -> Array:
    var rng := RandomNumberGenerator.new()
    rng.seed = seed
    var candidates:Array = holes.duplicate(true)
    candidates.sort_custom(func(a, b): return int(a.get("difficulty", 1)) < int(b.get("difficulty", 1)))
    var sequence:Array = []
    for index in range(count):
        var max_difficulty:int = clampi(index + 1, 1, 99)
        var pool:Array = []
        for hole in candidates:
            if int(hole.get("difficulty", 1)) <= max_difficulty:
                pool.append(hole)
        if pool.is_empty():
            pool = candidates
        if pool.is_empty():
            break
        var chosen:Dictionary = pool[rng.randi_range(0, pool.size() - 1)].duplicate(true)
        chosen["run_hole"] = index + 1
        var boss_stage:Dictionary = _boss_stage_for_hole(run_mode, index + 1, rng)
        if not boss_stage.is_empty():
            chosen["encounter_type"] = str(boss_stage.get("type", "mini_boss"))
            chosen["boss_stage"] = boss_stage
        sequence.append(chosen)
    return sequence
 
 
func get_current_hole(run_state:Dictionary) -> Dictionary:
    var sequence:Array = run_state.get("hole_sequence", []) if run_state.get("hole_sequence", []) is Array else []
    var index:int = int(run_state.get("hole_index", 0))
    if index < 0 or index >= sequence.size():
        return {}
    return sequence[index].duplicate(true) if sequence[index] is Dictionary else {}
 
 
func get_golfer(golfer_id:String) -> Dictionary:
    return _find_by_id(golfers, golfer_id)
 
 
func get_club(club_id:String) -> Dictionary:
    return _find_by_id(clubs, club_id)
 
 
func get_run_mode(run_mode_id:String) -> Dictionary:
    return _find_by_id(run_modes, run_mode_id)
 
 
func get_artifact(artifact_id:String) -> Dictionary:
    return _find_by_id(artifacts, artifact_id)
 
 
func get_unlocked_golfers(run_state:Dictionary = {}) -> Array:
    return _unlocked_rows(golfers, run_state, "golfers")
 
 
func get_unlocked_clubs(run_state:Dictionary = {}) -> Array:
    return _unlocked_rows(clubs, run_state, "clubs")
 
 
func get_unlocked_run_modes(run_state:Dictionary = {}) -> Array:
    return _unlocked_rows(run_modes, run_state, "run_modes")
 
 
func begin_current_encounter(run_state:Dictionary) -> Dictionary:
    var next:Dictionary = run_state.duplicate(true)
    var hole:Dictionary = get_current_hole(next)
    var encounter_type:String = str(hole.get("encounter_type", "normal"))
    if encounter_type == "normal":
        next["encounter"] = {}
        return next
    var current:Dictionary = next.get("encounter", {}) if next.get("encounter", {}) is Dictionary else {}
    if int(current.get("hole_index", -1)) == int(next.get("hole_index", 0)) and not current.is_empty():
        return next
    var boss_stage:Dictionary = hole.get("boss_stage", {}) if hole.get("boss_stage", {}) is Dictionary else {}
    next["encounter"] = {
        "hole_index": int(next.get("hole_index", 0)),
        "run_hole": int(hole.get("run_hole", int(next.get("hole_index", 0)) + 1)),
        "type": encounter_type,
        "phase": "exploration",
        "exploration": str(boss_stage.get("exploration", "fog_room")),
        "minigame": str(boss_stage.get("selected_minigame", boss_stage.get("script", "boss_challenge"))),
        "complete": false
    }
    next["last_result"] = {
        "type": "encounter_started",
        "message": encounter_prompt(next)
    }
    return next
 
 
func advance_current_encounter(run_state:Dictionary) -> Dictionary:
    var next:Dictionary = begin_current_encounter(run_state)
    var encounter:Dictionary = next.get("encounter", {}) if next.get("encounter", {}) is Dictionary else {}
    if encounter.is_empty() or bool(encounter.get("complete", false)):
        return next
    match str(encounter.get("phase", "exploration")):
        "exploration":
            encounter["phase"] = "boss" if str(encounter.get("type", "")) == "final_boss" else "minigame"
            next["last_result"] = {
                "type": "encounter_phase",
                "message": encounter_prompt({"encounter": encounter})
            }
        _:
            encounter["phase"] = "complete"
            encounter["complete"] = true
            next["last_result"] = {
                "type": "encounter_complete",
                "message": "Boss challenge cleared. The cup accepts your paperwork."
            }
    next["encounter"] = encounter
    return next
 
 
func encounter_blocks_putting(run_state:Dictionary) -> bool:
    var encounter:Dictionary = run_state.get("encounter", {}) if run_state.get("encounter", {}) is Dictionary else {}
    return not encounter.is_empty() and not bool(encounter.get("complete", false))
 
 
func encounter_prompt(run_state:Dictionary) -> String:
    var encounter:Dictionary = run_state.get("encounter", {}) if run_state.get("encounter", {}) is Dictionary else {}
    if encounter.is_empty():
        return ""
    var run_hole:int = int(encounter.get("run_hole", 0))
    match str(encounter.get("phase", "exploration")):
        "exploration":
            return "Hole %d boss approach: explore the fogged room before the ball challenge." % run_hole
        "minigame":
            return "Mini-boss challenge: %s. Placeholder for the ball minigame." % str(encounter.get("minigame", "ball challenge"))
        "boss":
            return "Final boss: %s. Placeholder for the scripted boss fight." % str(encounter.get("minigame", "final boss"))
        "complete":
            return "Boss encounter cleared. Finish the run flow."
        _:
            return ""
 
 
func apply_putt(run_state:Dictionary, options:Dictionary = {}) -> Dictionary:
    var next:Dictionary = run_state.duplicate(true)
    if encounter_blocks_putting(next):
        next["last_result"] = {"type": "encounter_blocked", "message": encounter_prompt(next)}
        return next
    var free_first:bool = has_artifact(next, "golden_club") and int(next.get("hole_putts", 0)) == 0
    next["total_putts"] = int(next.get("total_putts", 0)) + 1
    next["hole_putts"] = int(next.get("hole_putts", 0)) + 1
    if not free_first:
        next["health"] = int(next.get("health", 0)) - int(options.get("health_cost", 1))
    if int(next.get("health", 0)) <= 0:
        next["status"] = "failed"
        next["last_result"] = {
            "type": "failed",
            "message": "The round ends one putt short of glory."
        }
    return next
 
 
func complete_hole(run_state:Dictionary) -> Dictionary:
    var next:Dictionary = run_state.duplicate(true)
    var hole:Dictionary = get_current_hole(next)
    var strokes:int = int(next.get("hole_putts", 0))
    var par:int = int(hole.get("par", max(1, strokes)))
    var heal:int = int(hole.get("heal", 3))
    if has_artifact(next, "first_aid_kit"):
        heal += 1
    var max_health:int = int(next.get("max_health", DEFAULT_MAX_HEALTH))
    var health_before:int = int(next.get("health", 0))
    next["health"] = min(max_health, health_before + heal)
    var health_received:int = int(next.get("health", 0)) - health_before
    next["completed_holes"] = int(next.get("completed_holes", 0)) + 1
    next["furthest_hole"] = max(int(next.get("furthest_hole", 1)), int(next.get("completed_holes", 0)) + 1)
    next["pending_wheel"] = spin_wheel(next)
    next["hole_complete_summary"] = {
        "strokes": strokes,
        "par": par,
        "heal": heal,
        "health_received": health_received,
        "health_before": health_before,
        "health_after": int(next.get("health", 0))
    }
    next["last_result"] = {
        "type": "hole_complete",
        "message": "Level complete: %d strokes, par %d, +%d health. Choose a wheel reward to continue." % [strokes, par, health_received]
    }
    var sequence:Array = next.get("hole_sequence", []) if next.get("hole_sequence", []) is Array else []
    if int(next.get("completed_holes", 0)) >= sequence.size():
        next["status"] = "won"
        next["last_result"] = {
            "type": "run_won",
            "message": "Run complete in %d putts." % int(next.get("total_putts", 0))
        }
    return next
 
 
func advance_to_next_hole(run_state:Dictionary) -> Dictionary:
    var next:Dictionary = run_state.duplicate(true)
    if str(next.get("status", "active")) != "active":
        return next
    next["hole_index"] = int(next.get("hole_index", 0)) + 1
    next["hole_putts"] = 0
    next["encounter"] = {}
    next["pending_wheel"] = {}
    return next
 
 
func spin_wheel(run_state:Dictionary) -> Dictionary:
    var luck:int = int(_stats(run_state).get("luck", 0))
    if has_artifact(run_state, "lucky_horseshoe"):
        luck += 1
    var good_chance:float = clampf(0.5 + float(luck) * 0.08, 0.2, 0.85)
    var roll:float = randf()
    return {
        "good_chance": good_chance,
        "roll": roll,
        "result": "good" if roll <= good_chance else "bad"
    }
 
 
func apply_good_choice(run_state:Dictionary, choice:String) -> Dictionary:
    var next:Dictionary = run_state.duplicate(true)
    if choice == "health":
        next["health"] = min(int(next.get("max_health", DEFAULT_MAX_HEALTH)), int(next.get("health", 0)) + 3)
        next["last_result"] = {"type": "wheel_good", "message": "Good spin: restored health."}
    else:
        var artifact:Dictionary = draw_artifact(next)
        if not artifact.is_empty():
            var ids:Array = next.get("artifacts", []) if next.get("artifacts", []) is Array else []
            ids.append(str(artifact.get("id", "")))
            next["artifacts"] = ids
            next["last_result"] = {"type": "wheel_good", "message": "Good spin: gained %s." % str(artifact.get("name", "an artifact"))}
    next["pending_wheel"] = {}
    return advance_to_next_hole(next)
 
 
func apply_bad_result(run_state:Dictionary) -> Dictionary:
    var next:Dictionary = run_state.duplicate(true)
    var consequence:Dictionary = draw_consequence()
    var effect:Dictionary = consequence.get("effect", {}) if consequence.get("effect", {}) is Dictionary else {}
    match str(effect.get("type", "")):
        "damage":
            next["health"] = int(next.get("health", 0)) - int(effect.get("amount", 1))
        "max_health":
            next["max_health"] = max(1, int(next.get("max_health", DEFAULT_MAX_HEALTH)) + int(effect.get("amount", -1)))
            next["health"] = min(int(next.get("health", 0)), int(next.get("max_health", DEFAULT_MAX_HEALTH)))
        "luck":
            var stats:Dictionary = _stats(next)
            stats["luck"] = int(stats.get("luck", 0)) + int(effect.get("amount", -1))
            next["stats"] = stats
    if int(next.get("health", 0)) <= 0:
        next["status"] = "failed"
    next["last_result"] = {"type": "wheel_bad", "message": "Bad spin: %s" % str(consequence.get("name", "trouble"))}
    next["pending_wheel"] = {}
    if str(next.get("status", "")) == "active":
        next = advance_to_next_hole(next)
    return next
 
 
func draw_artifact(run_state:Dictionary) -> Dictionary:
    var owned:Array = run_state.get("artifacts", []) if run_state.get("artifacts", []) is Array else []
    var pool:Array = []
    for artifact in artifacts:
        if artifact is Dictionary and not owned.has(str(artifact.get("id", ""))):
            pool.append(artifact)
    if pool.is_empty():
        pool = artifacts
    if pool.is_empty():
        return {}
    return pool[randi() % pool.size()].duplicate(true)
 
 
func draw_consequence() -> Dictionary:
    if consequences.is_empty():
        return {}
    return consequences[randi() % consequences.size()].duplicate(true)
 
 
func unlocks_for_run_win(run_state:Dictionary) -> Array:
    var run_mode:Dictionary = get_run_mode(str(run_state.get("run_mode_id", DEFAULT_RUN_MODE_ID)))
    var ids:Array = run_mode.get("unlocks_on_win", []) if run_mode.get("unlocks_on_win", []) is Array else []
    var result:Array = []
    for id in ids:
        var mode:Dictionary = get_run_mode(str(id))
        if not mode.is_empty():
            result.append(mode)
    return result
 
 
func has_artifact(run_state:Dictionary, artifact_id:String) -> bool:
    var ids:Array = run_state.get("artifacts", []) if run_state.get("artifacts", []) is Array else []
    return ids.has(artifact_id)
 
 
func get_summary(run_state:Dictionary) -> Dictionary:
    return {
        "status": str(run_state.get("status", "active")),
        "run_mode_id": str(run_state.get("run_mode_id", DEFAULT_RUN_MODE_ID)),
        "run_mode_name": str(run_state.get("run_mode_name", "")),
        "hole": int(run_state.get("hole_index", 0)) + 1,
        "completed_holes": int(run_state.get("completed_holes", 0)),
        "furthest_hole": int(run_state.get("furthest_hole", 1)),
        "health": int(run_state.get("health", 0)),
        "max_health": int(run_state.get("max_health", DEFAULT_MAX_HEALTH)),
        "putts": int(run_state.get("total_putts", 0)),
        "artifacts": run_state.get("artifacts", []) if run_state.get("artifacts", []) is Array else []
    }
 
 
func validate_run_mode_minigame_refs(known_minigame_ids:Array) -> Array:
    var known:Dictionary = {}
    for id in known_minigame_ids:
        known[str(id)] = true
    var missing:Array = []
    for mode in run_modes:
        if not mode is Dictionary:
            continue
        var mode_id:String = str(mode.get("id", ""))
        var stages:Array = mode.get("boss_stages", []) if mode.get("boss_stages", []) is Array else []
        for stage in stages:
            if not stage is Dictionary:
                continue
            var hole:int = int(stage.get("hole", 0))
            var minigames:Array = stage.get("minigame_pool", []) if stage.get("minigame_pool", []) is Array else []
            for minigame_id in minigames:
                var id:String = str(minigame_id)
                if id != "" and not known.has(id):
                    missing.append({"run_mode": mode_id, "hole": hole, "minigame": id})
            var script_id:String = str(stage.get("script", ""))
            if script_id != "" and not known.has(script_id):
                missing.append({"run_mode": mode_id, "hole": hole, "minigame": script_id})
    return missing
 
 
func _load_array(path:String, key:String) -> Array:
    if not FileAccess.file_exists(path):
        return []
    var file := FileAccess.open(path, FileAccess.READ)
    if file == null:
        return []
    var parsed = JSON.parse_string(file.get_as_text())
    if parsed is Dictionary and parsed.get(key, []) is Array:
        return parsed.get(key, [])
    if parsed is Array:
        return parsed
    return []
 
 
func _find_by_id(rows:Array, id:String) -> Dictionary:
    for row in rows:
        if row is Dictionary and str(row.get("id", "")) == id:
            return row.duplicate(true)
    return {}
 
 
func _id_in_rows(rows:Array, id:String) -> bool:
    for row in rows:
        if row is Dictionary and str(row.get("id", "")) == id:
            return true
    return false
 
 
func _first_id(rows:Array, fallback:String) -> String:
    for row in rows:
        if row is Dictionary and str(row.get("id", "")) != "":
            return str(row.get("id", ""))
    return fallback
 
 
func _stats(run_state:Dictionary) -> Dictionary:
    return run_state.get("stats", {}).duplicate(true) if run_state.get("stats", {}) is Dictionary else {}
 
 
func _unlocked_rows(rows:Array, run_state:Dictionary, key:String) -> Array:
    var unlocked:Dictionary = run_state.get("unlocked", {}) if run_state.get("unlocked", {}) is Dictionary else {}
    var ids:Array = unlocked.get(key, []) if unlocked.get(key, []) is Array else []
    var result:Array = []
    for row in rows:
        if not row is Dictionary:
            continue
        var row_id:String = str(row.get("id", ""))
        if bool(row.get("unlocked", false)) or ids.has(row_id):
            result.append(row.duplicate(true))
    return result
 
 
func _normalized_unlocks(raw, golfer_id:String, club_id:String) -> Dictionary:
    var unlocked:Dictionary = raw.duplicate(true) if raw is Dictionary else {}
    var run_mode_ids:Array = unlocked.get("run_modes", []) if unlocked.get("run_modes", []) is Array else []
    var golfer_ids:Array = unlocked.get("golfers", []) if unlocked.get("golfers", []) is Array else []
    var club_ids:Array = unlocked.get("clubs", []) if unlocked.get("clubs", []) is Array else []
    var artifact_ids:Array = unlocked.get("artifacts", []) if unlocked.get("artifacts", []) is Array else []
    for mode in run_modes:
        if mode is Dictionary and bool(mode.get("unlocked_by_default", false)) and not run_mode_ids.has(str(mode.get("id", ""))):
            run_mode_ids.append(str(mode.get("id", "")))
    if not golfer_ids.has(golfer_id):
        golfer_ids.append(golfer_id)
    if not club_ids.has(club_id):
        club_ids.append(club_id)
    return {
        "run_modes": run_mode_ids,
        "golfers": golfer_ids,
        "clubs": club_ids,
        "artifacts": artifact_ids
    }
 
 
func _boss_stage_for_hole(run_mode:Dictionary, run_hole:int, rng:RandomNumberGenerator) -> Dictionary:
    var stages:Array = run_mode.get("boss_stages", []) if run_mode.get("boss_stages", []) is Array else []
    for stage in stages:
        if not stage is Dictionary or int(stage.get("hole", 0)) != run_hole:
            continue
        var next:Dictionary = stage.duplicate(true)
        var minigames:Array = next.get("minigame_pool", []) if next.get("minigame_pool", []) is Array else []
        if not minigames.is_empty():
            next["selected_minigame"] = str(minigames[rng.randi_range(0, minigames.size() - 1)])
        return next
    return {}