putt_putt_minigame_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_DEFINITIONS_PATH := "res://data/games/putt_putt_roguelike/minigames.json"
 
var definitions_path:String = DEFAULT_DEFINITIONS_PATH
var definitions:Array = []
var definition_lookup:Dictionary = {}
 
 
func load_definitions(path:String = DEFAULT_DEFINITIONS_PATH) -> Dictionary:
    definitions_path = path
    definitions.clear()
    definition_lookup.clear()
    var file = FileAccess.open(path, FileAccess.READ)
    if file == null:
        return {"ok": false, "minigames": 0, "error": "missing_file"}
    var parsed:Variant = JSON.parse_string(file.get_as_text())
    if not parsed is Dictionary:
        return {"ok": false, "minigames": 0, "error": "invalid_json"}
    var rows:Array = parsed.get("minigames", []) if parsed.get("minigames", []) is Array else []
    for row in rows:
        if not row is Dictionary:
            continue
        var definition:Dictionary = Dictionary(row).duplicate(true)
        var id:String = str(definition.get("id", ""))
        if id == "":
            continue
        definitions.append(definition)
        definition_lookup[id] = definition
    return {"ok": true, "minigames": definitions.size(), "error": ""}
 
 
func get_definition(minigame_id:String) -> Dictionary:
    _ensure_definitions_loaded()
    if definition_lookup.has(minigame_id):
        return Dictionary(definition_lookup[minigame_id]).duplicate(true)
    return {}
 
 
func create_minigame(minigame_id:String, seed:int, options:Dictionary = {}) -> Dictionary:
    var definition:Dictionary = get_definition(minigame_id)
    var type:String = str(options.get("type", definition.get("type", _minigame_type(minigame_id))))
    var target_score:int = int(options.get("target_score", definition.get("target_score", _default_target_score(minigame_id))))
    var step_score:int = int(options.get("step_score", definition.get("step_score", _default_step_score(type))))
    return {
        "schema_version": 1,
        "id": minigame_id,
        "seed": seed,
        "name": str(options.get("name", definition.get("name", minigame_id.capitalize()))),
        "description": str(options.get("description", definition.get("description", ""))),
        "type": type,
        "preview": str(options.get("preview", definition.get("preview", type))),
        "target_score": max(1, target_score),
        "step_score": max(1, step_score),
        "score": 0,
        "turns": 0,
        "complete": false,
        "result": ""
    }
 
 
func advance_minigame(state:Dictionary, options:Dictionary = {}) -> Dictionary:
    var next:Dictionary = state.duplicate(true)
    if bool(next.get("complete", false)):
        return next
    var amount:int = max(1, int(options.get("score", next.get("step_score", _default_step_score(str(next.get("type", "")))))))
    next["turns"] = int(next.get("turns", 0)) + 1
    next["score"] = int(next.get("score", 0)) + amount
    if int(next.get("score", 0)) >= int(next.get("target_score", 1)):
        next["score"] = int(next.get("target_score", 1))
        next["complete"] = true
        next["result"] = "won"
    return next
 
 
func is_complete(state:Dictionary) -> bool:
    return bool(state.get("complete", false))
 
 
func progress_text(state:Dictionary) -> String:
    return "%s %d/%d" % [
        _label_for_type(str(state.get("type", ""))),
        int(state.get("score", 0)),
        int(state.get("target_score", 1))
    ]
 
 
func _ensure_definitions_loaded() -> void:
    if definitions.is_empty():
        load_definitions(definitions_path)
 
 
func _minigame_type(minigame_id:String) -> String:
    var id:String = minigame_id.to_lower()
    if id.contains("pong"):
        return "pong"
    if id.contains("breakout"):
        return "breakout"
    if id.contains("boss"):
        return "scripted_boss"
    return "ball_challenge"
 
 
func _default_target_score(minigame_id:String) -> int:
    match _minigame_type(minigame_id):
        "breakout":
            return 6
        "pong":
            return 5
        "scripted_boss":
            return 9
        _:
            return 4
 
 
func _default_step_score(type:String) -> int:
    match type:
        "scripted_boss":
            return 2
        _:
            return 1
 
 
func _label_for_type(type:String) -> String:
    match type:
        "breakout":
            return "Blocks"
        "pong":
            return "Rallies"
        "scripted_boss":
            return "Boss"
        _:
            return "Progress"