run_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
 
 
func create_run(options:Dictionary = {}) -> Dictionary:
    var now = _now(options)
    return {
        "id": str(options.get("id", _make_run_id(options, now))),
        "game_id": str(options.get("game_id", "")),
        "mode": str(options.get("mode", "run")),
        "status": "active",
        "seed": int(options.get("seed", 0)),
        "attempt": int(options.get("attempt", 1)),
        "started_at": now,
        "ended_at": 0,
        "elapsed": 0.0,
        "objectives": _normalize_objectives(options.get("objectives", [])),
        "counters": _normalize_counts(options.get("counters", {})),
        "collected": _normalize_counts(options.get("collected", {})),
        "rewards": _normalize_counts(options.get("rewards", {})),
        "result": {},
        "metadata": options.get("metadata", {}).duplicate(true) if options.get("metadata", {}) is Dictionary else {}
    }
 
 
 
func is_active(run_state:Dictionary) -> bool:
    return str(run_state.get("status", "")) == "active"
 
 
 
func is_finished(run_state:Dictionary) -> bool:
    return ["completed", "failed", "abandoned"].has(str(run_state.get("status", "")))
 
 
 
func set_counter(run_state:Dictionary, key:String, value:int) -> Dictionary:
    var next = run_state.duplicate(true)
    var counters = next.get("counters", {}).duplicate(true) if next.get("counters", {}) is Dictionary else {}
    counters[key] = value
    next["counters"] = counters
    return next
 
 
 
func increment_counter(run_state:Dictionary, key:String, amount:int = 1) -> Dictionary:
    var next = run_state.duplicate(true)
    var counters = next.get("counters", {}).duplicate(true) if next.get("counters", {}) is Dictionary else {}
    counters[key] = int(counters.get(key, 0)) + amount
    next["counters"] = counters
    return next
 
 
 
func add_collected(run_state:Dictionary, collected:Dictionary) -> Dictionary:
    var next = run_state.duplicate(true)
    next["collected"] = _merge_counts(next.get("collected", {}), collected)
    return next
 
 
 
func set_objective_complete(run_state:Dictionary, objective_id:String, complete:bool = true) -> Dictionary:
    var next = run_state.duplicate(true)
    var objectives := []
    for objective in next.get("objectives", []):
        if not objective is Dictionary:
            continue
        var entry = objective.duplicate(true)
        if str(entry.get("id", "")) == objective_id:
            entry["complete"] = complete
        objectives.append(entry)
    next["objectives"] = objectives
    return next
 
 
 
func required_objectives_complete(run_state:Dictionary) -> bool:
    for objective in run_state.get("objectives", []):
        if objective is Dictionary and bool(objective.get("required", true)) and not bool(objective.get("complete", false)):
            return false
    return true
 
 
 
func complete_run(run_state:Dictionary, rewards:Dictionary = {}, result:Dictionary = {}, options:Dictionary = {}) -> Dictionary:
    var next = _finish(run_state, "completed", result, options)
    next["rewards"] = _merge_counts(next.get("rewards", {}), rewards)
    return next
 
 
 
func fail_run(run_state:Dictionary, result:Dictionary = {}, options:Dictionary = {}) -> Dictionary:
    return _finish(run_state, "failed", result, options)
 
 
 
func abandon_run(run_state:Dictionary, options:Dictionary = {}) -> Dictionary:
    var result = options.get("result", {}) if options.get("result", {}) is Dictionary else {}
    result["rollback_collected"] = bool(options.get("rollback_collected", true))
    result["message"] = str(options.get("message", result.get("message", "Run abandoned.")))
    return _finish(run_state, "abandoned", result, options)
 
 
 
func retry_run(run_state:Dictionary, options:Dictionary = {}) -> Dictionary:
    var retry_options = {
        "game_id": str(run_state.get("game_id", "")),
        "mode": str(run_state.get("mode", "run")),
        "seed": int(options.get("seed", run_state.get("seed", 0))),
        "attempt": int(run_state.get("attempt", 1)) + 1,
        "objectives": run_state.get("objectives", []),
        "metadata": run_state.get("metadata", {})
    }
    for key in options.keys():
        retry_options[key] = options[key]
    return create_run(retry_options)
 
 
 
func get_summary(run_state:Dictionary) -> Dictionary:
    var objectives = run_state.get("objectives", [])
    var required_count := 0
    var required_complete := 0
    for objective in objectives:
        if not objective is Dictionary:
            continue
        if bool(objective.get("required", true)):
            required_count += 1
            if bool(objective.get("complete", false)):
                required_complete += 1
    return {
        "id": str(run_state.get("id", "")),
        "game_id": str(run_state.get("game_id", "")),
        "mode": str(run_state.get("mode", "")),
        "status": str(run_state.get("status", "")),
        "attempt": int(run_state.get("attempt", 1)),
        "elapsed": float(run_state.get("elapsed", 0.0)),
        "required_objectives": required_count,
        "completed_required_objectives": required_complete,
        "counters": run_state.get("counters", {}).duplicate(true) if run_state.get("counters", {}) is Dictionary else {},
        "collected": run_state.get("collected", {}).duplicate(true) if run_state.get("collected", {}) is Dictionary else {},
        "rewards": run_state.get("rewards", {}).duplicate(true) if run_state.get("rewards", {}) is Dictionary else {},
        "result": run_state.get("result", {}).duplicate(true) if run_state.get("result", {}) is Dictionary else {}
    }
 
 
 
func format_counts(counts:Dictionary, empty_label:String = "none") -> String:
    var parts := []
    var keys = counts.keys()
    keys.sort()
    for key in keys:
        var amount = int(counts[key])
        if amount <= 0:
            continue
        parts.append("%dx %s" % [amount, _labelize(str(key))])
    return empty_label if parts.is_empty() else ", ".join(parts)
 
 
 
func format_result_line(run_state:Dictionary) -> String:
    var summary = get_summary(run_state)
    var status = str(summary.get("status", "run")).capitalize()
    var mode = _labelize(str(summary.get("mode", "run")))
    var rewards = format_counts(summary.get("rewards", {}), "no rewards")
    return "%s %s: %s" % [mode, status, rewards]
 
 
func _finish(run_state:Dictionary, status:String, result:Dictionary = {}, options:Dictionary = {}) -> Dictionary:
    var next = run_state.duplicate(true)
    var now = _now(options)
    next["status"] = status
    next["ended_at"] = now
    next["elapsed"] = float(options.get("elapsed", _elapsed(next, now)))
    next["result"] = result.duplicate(true)
    return next
 
 
func _normalize_objectives(raw_objectives) -> Array:
    var objectives := []
    if not raw_objectives is Array:
        return objectives
    for raw_objective in raw_objectives:
        if not raw_objective is Dictionary:
            continue
        var objective = raw_objective.duplicate(true)
        objective["id"] = str(objective.get("id", ""))
        objective["label"] = str(objective.get("label", objective.get("id", "")))
        objective["required"] = bool(objective.get("required", true))
        objective["complete"] = bool(objective.get("complete", false))
        objectives.append(objective)
    return objectives
 
 
func _normalize_counts(raw_counts) -> Dictionary:
    var counts := {}
    if not raw_counts is Dictionary:
        return counts
    for key in raw_counts.keys():
        counts[str(key)] = int(raw_counts[key])
    return counts
 
 
func _merge_counts(base_counts, added_counts) -> Dictionary:
    var merged = _normalize_counts(base_counts)
    if not added_counts is Dictionary:
        return merged
    for key in added_counts.keys():
        merged[str(key)] = int(merged.get(str(key), 0)) + int(added_counts[key])
    return merged
 
 
func _now(options:Dictionary = {}) -> int:
    if options.has("now"):
        return int(options.get("now", 0))
    return int(Time.get_unix_time_from_system())
 
 
func _elapsed(run_state:Dictionary, now:int) -> float:
    var started = int(run_state.get("started_at", now))
    return max(0.0, float(now - started))
 
 
func _make_run_id(options:Dictionary, now:int) -> String:
    var game_id = str(options.get("game_id", "game"))
    var mode = str(options.get("mode", "run"))
    return "%s_%s_%d" % [game_id, mode, now]
 
 
func _labelize(value:String) -> String:
    return value.replace("_", " ").capitalize()