research_lab_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
 
 
func attempt_inventory_reaction(alchemy_manager, inventory:Dictionary, inputs:Array, catalysts:Array = [], rng:RandomNumberGenerator = null) -> Dictionary:
    var normalized_inputs = _normalized_inputs(inputs)
    if normalized_inputs.size() != 2:
        return {
            "success": false,
            "valid": false,
            "message": "Choose two materials before starting research.",
            "inputs": normalized_inputs
        }
    if not _has_distinct_inputs(normalized_inputs):
        return {
            "success": false,
            "valid": false,
            "message": "Choose two different materials for research.",
            "inputs": normalized_inputs
        }
    if not _has_required_inventory(inventory, normalized_inputs):
        return {
            "success": false,
            "valid": false,
            "message": "Not enough materials for that research attempt.",
            "inputs": normalized_inputs
        }
    var reaction = alchemy_manager.attempt_reaction(normalized_inputs, catalysts)
    if bool(reaction.get("success", false)):
        var result_id = str(reaction.get("result", ""))
        var gain := {}
        if result_id != "":
            gain[result_id] = 1
        return {
            "success": true,
            "valid": true,
            "inputs": normalized_inputs,
            "consume": _counts_for(normalized_inputs),
            "gain": gain,
            "reaction": reaction,
            "message": "Research succeeded."
        }
    if rng == null:
        rng = RandomNumberGenerator.new()
        rng.randomize()
    var destroyed_index = rng.randi_range(0, normalized_inputs.size() - 1)
    var destroyed = str(normalized_inputs[destroyed_index])
    var returned = str(normalized_inputs[1 - destroyed_index])
    reaction["destroyed"] = destroyed
    reaction["returned"] = returned
    return {
        "success": false,
        "valid": true,
        "inputs": normalized_inputs,
        "consume": {destroyed: 1},
        "gain": {},
        "destroyed": destroyed,
        "returned": returned,
        "reaction": reaction,
        "message": "Research failed."
    }
 
 
 
func preview_inventory_reaction(alchemy_manager, inventory:Dictionary, inputs:Array, known_result_ids:Array = [], catalysts:Array = []) -> Dictionary:
    var normalized_inputs = _normalized_inputs(inputs)
    if normalized_inputs.size() != 2:
        return {
            "valid": false,
            "known": false,
            "result": "",
            "label": "Unknown",
            "message": "Choose two materials."
        }
    if not _has_distinct_inputs(normalized_inputs):
        return {
            "valid": false,
            "known": false,
            "inputs": normalized_inputs,
            "result": "",
            "label": "Unknown",
            "message": "Choose two different materials."
        }
    if not _has_required_inventory(inventory, normalized_inputs):
        return {
            "valid": false,
            "known": false,
            "inputs": normalized_inputs,
            "result": "",
            "label": "Unknown",
            "message": "Not enough materials."
        }
    var reaction = alchemy_manager.attempt_reaction(normalized_inputs, catalysts)
    var result_id = str(reaction.get("result", ""))
    var success = bool(reaction.get("success", false)) and result_id != ""
    var known = success and known_result_ids.has(result_id)
    return {
        "valid": true,
        "success": success,
        "known": known,
        "inputs": normalized_inputs,
        "result": result_id if known else "",
        "hidden_result": result_id,
        "label": result_id.capitalize() if known else "Unknown",
        "reaction": reaction,
        "message": "Known recipe." if known else "Unknown recipe."
    }
 
 
 
func craft_known_reaction(alchemy_manager, inventory:Dictionary, inputs:Array, known_result_ids:Array, catalysts:Array = []) -> Dictionary:
    var preview = preview_inventory_reaction(alchemy_manager, inventory, inputs, known_result_ids, catalysts)
    if not bool(preview.get("known", false)):
        preview["valid"] = false
        preview["message"] = "Research this recipe before crafting it."
        return preview
    var result_id = str(preview.get("result", ""))
    return {
        "success": true,
        "valid": true,
        "known": true,
        "inputs": preview.get("inputs", []).duplicate(true),
        "consume": _counts_for(preview.get("inputs", [])),
        "gain": {result_id: 1},
        "reaction": preview.get("reaction", {}),
        "message": "Crafted known recipe."
    }
 
 
 
func apply_inventory_delta(inventory:Dictionary, result:Dictionary) -> Dictionary:
    var next_inventory = inventory.duplicate(true)
    for id in result.get("consume", {}).keys():
        var remaining = int(next_inventory.get(id, 0)) - int(result.get("consume", {}).get(id, 0))
        if remaining > 0:
            next_inventory[id] = remaining
        else:
            next_inventory.erase(id)
    for id in result.get("gain", {}).keys():
        next_inventory[id] = int(next_inventory.get(id, 0)) + int(result.get("gain", {}).get(id, 0))
    return next_inventory
 
 
func get_available_inputs(inventory:Dictionary) -> Array:
    var available := []
    for id in inventory.keys():
        if int(inventory.get(id, 0)) > 0:
            available.append(str(id))
    available.sort()
    return available
 
 
func _normalized_inputs(inputs:Array) -> Array:
    var normalized := []
    for input in inputs:
        var id = str(input).strip_edges().to_lower()
        if id != "":
            normalized.append(id)
    normalized.sort()
    return normalized
 
 
func _has_distinct_inputs(inputs:Array) -> bool:
    if inputs.size() < 2:
        return false
    return str(inputs[0]) != str(inputs[1])
 
 
func _has_required_inventory(inventory:Dictionary, inputs:Array) -> bool:
    var required = _counts_for(inputs)
    for id in required.keys():
        if int(inventory.get(id, 0)) < int(required[id]):
            return false
    return true
 
 
func _counts_for(inputs:Array) -> Dictionary:
    var counts := {}
    for input in inputs:
        var id = str(input)
        counts[id] = int(counts.get(id, 0)) + 1
    return counts