alchemy_graph_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var definitions := {}
var reactions := []
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_graph(definitions_path:String, reactions_path:String) -> void:
    load_graph_data(
        data_cache_manager.load_json(definitions_path),
        data_cache_manager.load_json(reactions_path)
    )
 
 
 
func load_graph_data(definition_data:Dictionary, reaction_data:Dictionary) -> void:
    definitions.clear()
    reactions.clear()
    _load_definitions(definition_data)
    _load_reactions(reaction_data)
 
 
 
func validate_graph(starter_ids:Array = []) -> Dictionary:
    var issues := {
        "missing_inputs": [],
        "missing_results": [],
        "duplicate_reactions": [],
        "unreachable_results": []
    }
    var seen_reaction_ids := {}
    for reaction in reactions:
        var reaction_id = str(reaction.get("id", ""))
        if reaction_id != "":
            if seen_reaction_ids.has(reaction_id):
                issues["duplicate_reactions"].append(reaction_id)
            seen_reaction_ids[reaction_id] = true
        for input in reaction.get("inputs", []):
            var input_id = str(input)
            if input_id != "" and not definitions.has(input_id):
                issues["missing_inputs"].append({"reaction": reaction_id, "id": input_id})
        var result_id = str(reaction.get("result", ""))
        if result_id != "" and not definitions.has(result_id):
            issues["missing_results"].append({"reaction": reaction_id, "id": result_id})
    if not starter_ids.is_empty():
        var reachable = get_reachable_results(starter_ids)
        for reaction in reactions:
            var result = str(reaction.get("result", ""))
            if result != "" and not reachable.has(result):
                issues["unreachable_results"].append(result)
    return issues
 
 
 
func get_reachable_results(starter_ids:Array) -> Dictionary:
    var known := {}
    for starter in starter_ids:
        var id = str(starter)
        if id != "":
            known[id] = true
    var changed := true
    while changed:
        changed = false
        for reaction in reactions:
            var result = str(reaction.get("result", ""))
            if result == "" or known.has(result):
                continue
            var can_make := true
            for input in reaction.get("inputs", []):
                if not known.has(str(input)):
                    can_make = false
                    break
            for catalyst in reaction.get("catalysts", []):
                if not known.has(str(catalyst)):
                    can_make = false
                    break
            if can_make:
                known[result] = true
                changed = true
    return known
 
 
 
func get_dead_end_results(starter_ids:Array = []) -> Array:
    var reachable = get_reachable_results(starter_ids) if not starter_ids.is_empty() else _all_results()
    var consumed := {}
    for reaction in reactions:
        for input in reaction.get("inputs", []):
            consumed[str(input)] = true
        for catalyst in reaction.get("catalysts", []):
            consumed[str(catalyst)] = true
    var dead_ends := []
    for id in reachable.keys():
        if not consumed.has(id) and _is_compound(id):
            dead_ends.append(id)
    dead_ends.sort()
    return dead_ends
 
 
 
func get_summary(starter_ids:Array = []) -> Dictionary:
    var reachable = get_reachable_results(starter_ids) if not starter_ids.is_empty() else _all_results()
    return {
        "definitions": definitions.keys().size(),
        "reactions": reactions.size(),
        "reachable": reachable.keys().size(),
        "dead_ends": get_dead_end_results(starter_ids)
    }
 
 
func _all_results() -> Dictionary:
    var results := {}
    for reaction in reactions:
        var result = str(reaction.get("result", ""))
        if result != "":
            results[result] = true
    return results
 
 
func _is_compound(id:String) -> bool:
    if not definitions.has(id):
        return false
    return bool(definitions[id].has("tier"))
 
 
func _load_definitions(definition_data:Dictionary) -> void:
    for element in definition_data.get("elements", []):
        if element is Dictionary:
            var id = str(element.get("id", ""))
            if id != "":
                definitions[id] = element.duplicate(true)
    for compound in definition_data.get("compounds", []):
        if compound is Dictionary:
            var id = str(compound.get("id", ""))
            if id != "":
                definitions[id] = compound.duplicate(true)
 
 
func _load_reactions(reaction_data:Dictionary) -> void:
    for reaction in reaction_data.get("reactions", []):
        if reaction is Dictionary:
            reactions.append(reaction.duplicate(true))
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()