codex_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
var discoveries := {}
var failed_reactions := {}
var notes := []
var reaction_history := []
 
 
 
func record_discovery(reaction:Dictionary) -> void:
    var result_id = str(reaction.get("result", ""))
    if result_id == "":
        return
    var entry = discoveries.get(result_id, {}).duplicate(true)
    entry["id"] = result_id
    entry["state"] = "discovered"
    entry["reaction_key"] = str(reaction.get("key", ""))
    entry["inputs"] = reaction.get("inputs", []).duplicate(true)
    entry["description"] = str(reaction.get("description", entry.get("description", "")))
    entry["uses"] = int(entry.get("uses", 0)) + 1
    discoveries[result_id] = entry
    _record_history({
        "type": "discovery",
        "id": result_id,
        "inputs": entry.get("inputs", []).duplicate(true),
        "catalysts": reaction.get("catalysts", []).duplicate(true),
        "message": str(entry.get("description", "")),
        "success": true
    })
 
 
 
func record_failure(reaction_attempt:Dictionary) -> void:
    var key = str(reaction_attempt.get("key", ""))
    if key == "":
        return
    failed_reactions[key] = {
        "key": key,
        "inputs": reaction_attempt.get("inputs", []).duplicate(true),
        "catalysts": reaction_attempt.get("catalysts", []).duplicate(true),
        "message": str(reaction_attempt.get("message", "No stable reaction."))
    }
    _record_history({
        "type": "failure",
        "id": key,
        "inputs": reaction_attempt.get("inputs", []).duplicate(true),
        "catalysts": reaction_attempt.get("catalysts", []).duplicate(true),
        "message": str(reaction_attempt.get("message", "No stable reaction.")),
        "success": false
    })
 
 
func add_note(category:String, text:String) -> void:
    notes.append({
        "category": category,
        "text": text,
        "created_at": Time.get_unix_time_from_system()
    })
 
 
func has_discovery(id:String) -> bool:
    return discoveries.has(id)
 
 
func get_discoveries() -> Array:
    return discoveries.values()
 
 
func get_failures() -> Array:
    return failed_reactions.values()
 
 
func get_reaction_history(filters := {}) -> Array:
    var entries := []
    for entry in reaction_history:
        if _matches_filters(entry, filters):
            entries.append(entry.duplicate(true))
    return entries
 
 
func get_collection_entries(filters := {}) -> Array:
    var entries := []
    for discovery in get_discoveries():
        var row = discovery.duplicate(true)
        row["type"] = "discovery"
        row["title"] = str(row.get("id", "")).capitalize()
        row["subtitle"] = " + ".join(row.get("inputs", []))
        row["locked"] = false
        if _matches_filters(row, filters):
            entries.append(row)
    for failure in get_failures():
        var row = failure.duplicate(true)
        row["id"] = str(row.get("key", ""))
        row["type"] = "failure"
        row["title"] = "Failed: %s" % " + ".join(row.get("inputs", []))
        row["subtitle"] = str(row.get("message", "No stable reaction."))
        row["locked"] = false
        if _matches_filters(row, filters):
            entries.append(row)
    for note in notes:
        var row = note.duplicate(true)
        row["id"] = "%s:%s" % [str(row.get("category", "note")), str(row.get("created_at", ""))]
        row["type"] = "note"
        row["title"] = str(row.get("category", "Note")).capitalize()
        row["subtitle"] = str(row.get("text", ""))
        row["locked"] = false
        if _matches_filters(row, filters):
            entries.append(row)
    return entries
 
 
func get_state() -> Dictionary:
    return {
        "discoveries": discoveries.duplicate(true),
        "failed_reactions": failed_reactions.duplicate(true),
        "notes": notes.duplicate(true),
        "reaction_history": reaction_history.duplicate(true)
    }
 
 
func apply_state(state:Dictionary) -> void:
    discoveries = state.get("discoveries", {}).duplicate(true)
    failed_reactions = state.get("failed_reactions", {}).duplicate(true)
    notes = state.get("notes", []).duplicate(true)
    reaction_history = state.get("reaction_history", []).duplicate(true)
 
 
func reset() -> void:
    discoveries.clear()
    failed_reactions.clear()
    notes.clear()
    reaction_history.clear()
 
 
func _record_history(entry:Dictionary) -> void:
    var row = entry.duplicate(true)
    row["created_at"] = Time.get_unix_time_from_system()
    reaction_history.push_front(row)
 
 
func _matches_filters(entry:Dictionary, filters:Dictionary) -> bool:
    var type_filter = str(filters.get("type", "all"))
    if type_filter != "all" and str(entry.get("type", "")) != type_filter:
        return false
    var query = str(filters.get("query", "")).strip_edges().to_lower()
    if query == "":
        return true
    var haystack = [
        str(entry.get("id", "")),
        str(entry.get("key", "")),
        str(entry.get("title", "")),
        str(entry.get("subtitle", "")),
        str(entry.get("message", "")),
        " ".join(entry.get("inputs", [])),
        " ".join(entry.get("catalysts", []))
    ]
    return " ".join(haystack).to_lower().contains(query)