alchemy_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var elements := {}
var compounds := {}
var reactions := {}
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_definitions(file_path:String) -> void:
    elements.clear()
    compounds.clear()
    load_definition_data(data_cache_manager.load_json(file_path))
 
 
 
func load_definition_data(data) -> void:
    elements.clear()
    compounds.clear()
    if not data is Dictionary:
        return
    for element in data.get("elements", []):
        if element is Dictionary:
            var id = str(element.get("id", ""))
            if id != "":
                elements[id] = element.duplicate(true)
    for compound in data.get("compounds", []):
        if compound is Dictionary:
            var id = str(compound.get("id", ""))
            if id != "":
                compounds[id] = compound.duplicate(true)
 
 
 
func load_reactions(file_path:String) -> void:
    reactions.clear()
    load_reaction_data(data_cache_manager.load_json(file_path))
 
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
 
func load_reaction_data(data) -> void:
    reactions.clear()
    if not data is Dictionary:
        return
    for reaction in data.get("reactions", []):
        if not reaction is Dictionary:
            continue
        var inputs = reaction.get("inputs", [])
        if not inputs is Array or inputs.is_empty():
            continue
        reactions[_reaction_key(inputs, reaction.get("catalysts", []))] = reaction.duplicate(true)
 
 
 
func attempt_reaction(inputs:Array, catalysts:Array = []) -> Dictionary:
    var key = _reaction_key(inputs, catalysts)
    if reactions.has(key):
        var reaction = reactions[key].duplicate(true)
        reaction["success"] = true
        reaction["key"] = key
        return reaction
    return {
        "success": false,
        "key": key,
        "inputs": _normalized_list(inputs),
        "catalysts": _normalized_list(catalysts),
        "message": "No stable reaction discovered."
    }
 
 
func get_definition(id:String) -> Dictionary:
    if elements.has(id):
        return elements[id].duplicate(true)
    if compounds.has(id):
        return compounds[id].duplicate(true)
    return {}
 
 
func get_all_definitions() -> Dictionary:
    return {
        "elements": elements.duplicate(true),
        "compounds": compounds.duplicate(true)
    }
 
 
func get_reactions() -> Array:
    var rows := []
    for reaction in reactions.values():
        rows.append(reaction.duplicate(true))
    rows.sort_custom(func(a, b): return str(a.get("id", "")) < str(b.get("id", "")))
    return rows
 
 
func get_state() -> Dictionary:
    return {
        "elements": elements.duplicate(true),
        "compounds": compounds.duplicate(true),
        "reactions": reactions.duplicate(true)
    }
 
 
func apply_state(state:Dictionary) -> void:
    elements = state.get("elements", {}).duplicate(true)
    compounds = state.get("compounds", {}).duplicate(true)
    reactions = state.get("reactions", {}).duplicate(true)
 
 
func _reaction_key(inputs:Array, catalysts:Array = []) -> String:
    var normalized_inputs = _normalized_list(inputs)
    var normalized_catalysts = _normalized_list(catalysts)
    var key = "+".join(normalized_inputs)
    if not normalized_catalysts.is_empty():
        key += "|catalysts:" + "+".join(normalized_catalysts)
    return key
 
 
func _normalized_list(values:Array) -> Array:
    var normalized = []
    for value in values:
        var text = str(value).strip_edges().to_lower()
        if text != "":
            normalized.append(text)
    normalized.sort()
    return normalized