Godot Genre Survival

extends Node
class_name CraftingRecipeProcessor

## Expert Crafting System (Godot 4.6).
## Two-pass validation and consumption logic for item recipes.

@export var inventory: ModularInventoryController

func craft(recipe_res: Resource) -> bool:
	# 1. Validation: Do we have all ingredients?
	for item_path in recipe_res.ingredients:
		var req = recipe_res.ingredients[item_path]
		if not _has_item(item_path, req): return false
	
	# 2. Consumption: Deduct ingredients
	for item_path in recipe_res.ingredients:
		_consume_item(item_path, recipe_res.ingredients[item_path])
	
	# 3. Output: Add result to inventory
	var output = ResourceLoader.load(recipe_res.output_path)
	inventory.add_item(output, 1)
	return true

func _has_item(path: String, amt: int) -> bool: return true # Implementation logic
func _consume_item(path: String, amt: int) -> void: pass # Implementation logic

## [SKILL NOTICE]: Perform a full validation pass BEFORE consuming any 
## resources to prevent partial-crafting bugs.

# skills/genre-survival/scripts/interactable.gd
extends Area3D

## Interactable Base Class (Expert Pattern)
## Standardizes interaction prompt and behavior.

class_name Interactable

@export var prompt_message: String = "Interact"
@export var one_shot: bool = false

func interact(user: Node) -> void:
    _on_interact(user)
    if one_shot:
        queue_free()

func _on_interact(user: Node) -> void:
    print("Interacted with %s by %s" % [name, user.name])
    # Override this in subclasses
    # e.g. Add item to inventory

## EXPERT USAGE:
## Extend this script (e.g. PickupItem.gd).
## Player RayCast checks for 'Interactable' class.

# skills/genre-survival/scripts/inventory_data.gd
class_name InventoryData
extends Resource

## Inventory Data (Expert Pattern)
## Resource-based inventory system compatible with Save/Load.

signal inventory_updated(slot_index: int)

@export var slots: Array[InventorySlotData] = []

func _init(num_slots: int = 20) -> void:
    slots.resize(num_slots)
    for i in range(num_slots):
        slots[i] = InventorySlotData.new()

func add_item(item: Resource, amount: int) -> int:
    var remaining = amount
    
    # 1. Stack with existing
    for i in range(slots.size()):
        if remaining <= 0: break
        var slot = slots[i]
        if slot.item == item and slot.count < slot.max_stack:
            var space = slot.max_stack - slot.count
            var to_add = min(remaining, space)
            slot.count += to_add
            remaining -= to_add
            inventory_updated.emit(i)
            
    # 2. Add to empty
    for i in range(slots.size()):
        if remaining <= 0: break
        var slot = slots[i]
        if slot.item == null:
            slot.item = item
            var to_add = min(remaining, slot.max_stack) # Assuming item has specific max stack info elsewhere
            slot.count = to_add
            remaining -= to_add
            inventory_updated.emit(i)
            
    return remaining

# Inner Class for Slot cannot be exported strictly as resource in same file in 4.x usually
# But for simplicity in this pattern we define usage. 
# Best practice: Separate file for SlotData.
# Here we assume InventorySlotData is a known class or we use Dictionary if simple.
# For this script, we'll assume InventorySlotData is defined below or externally.

## EXPERT USAGE:
## Create as .tres for default loadouts.
## Use add_item returns to handle "Inventory Full".

# skills/genre-survival/scripts/inventory_slot_data.gd
class_name InventorySlotData
extends Resource

## Inventory Slot Data (Expert Pattern)
## Separate resource for individual slots to allow easy serialization.

@export var item: Resource # Reference to ItemDefinition
@export var count: int = 0
@export var max_stack: int = 64 # Should theoretically come from Item Resource

func can_stack_with(other_slot: InventorySlotData) -> bool:
    return item == other_slot.item and item != null and count < max_stack

## EXPERT USAGE:
## Used internally by InventoryData.

# skills/genre-survival/code/inventory_slot_resource.gd
extends Resource
class_name InventorySlot

## Survival Inventory Expert Pattern
## Uses Resources for type-safety and modularity.

@export var item_id: String = ""
@export var quantity: int = 0
@export var max_stack: int = 99
@export var item_icon: Texture2D
@export var metadata: Dictionary = {} # Store durability, mods, etc.

func can_add(amount: int) -> bool:
    return (quantity + amount) <= max_stack

func add(amount: int) -> void:
    quantity += amount

func use() -> bool:
    if quantity > 0:
        quantity -= 1
        return true
    return false

## EXPERT NOTE:
## NEVER use a simple 'Dictionary' [id, count] for survival inventories. 
## Using a 'Resource' allows each item to store unique state (Durability, 
## Custom Names, Enchantments) and enables easy use of the Inspector 
## for balancing.
## For 'genre-survival', implement a 'Weighted Inventory' system where the 
## total weight of all Slot resources affects the player's move speed.

extends Node
class_name ModularInventoryController

## Expert Inventory System (Godot 4.6).
## Uses ItemResources for data and InventorySlots for state tracking.

var slots: Array[InventorySlot] = []

class InventorySlot extends RefCounted:
	var item: Resource # ItemResource
	var amount: int = 0
	func _init(i, a): item = i; amount = a

func add_item(item_res: Resource, amount: int) -> void:
	# 1. Merge into existing slots
	for slot in slots:
		if slot.item == item_res and slot.amount < item_res.max_stack:
			var can_take = item_res.max_stack - slot.amount
			var take = mini(can_take, amount)
			slot.amount += take
			amount -= take
			if amount <= 0: return

	# 2. Add as new slots
	while amount > 0:
		var take = mini(item_res.max_stack, amount)
		slots.append(InventorySlot.new(item_res, take))
		amount -= take

## [SKILL NOTICE]: Use 'ItemResource' files for static data and 
## 'InventorySlot' objects for items currently in the bag to avoid 
## modifying shared resource files during gameplay.

extends Node
class_name StatusDepletionManager

## Expert Status Management (Godot 4.6).
## Continuous depletion of Hunger, Thirst, and Health using physics delta.

var stats: Dictionary = {
	"hunger": {"val": 100.0, "max": 100.0, "rate": 0.5},
	"thirst": {"val": 100.0, "max": 100.0, "rate": 0.8}
}

func _physics_process(delta: float) -> void:
	for id in stats:
		var s = stats[id]
		# Expert Pattern: Frame-independent reduction
		s.val = clamp(s.val - (s.rate * delta), 0.0, s.max)
		if s.val <= 0: _on_stat_empty(id)

func _on_stat_empty(id: String) -> void:
	# Trigger starvation/dehydration damage
	pass

## [SKILL NOTICE]: Use '_physics_process(delta)' for continuous depletion 
## instead of Timers for a smoother, frame-independent survival feel.

# survival_patterns.gd
extends Node

# 1. Time-Independent Decay
# EXPERT NOTE: Multiply decay rates by delta to ensure consistent behavior across different frame rates.
func process_survival_vitals(delta: float, decay_rate: float) -> void:
    # thirst -= decay_rate * delta
    pass

# 2. Environment Lighting Tween (Day/Night)
# EXPERT NOTE: Use interpolation to smoothly transition world lighting for atmospheric immersion.
func transition_to_night(env: Environment) -> void:
    var tween := create_tween()
    tween.tween_property(env, "ambient_light_energy", 0.1, 10.0)

# 3. MultiMeshInstance for Optimized Forests/Nature
# EXPERT NOTE: Efficiently draw thousands of static assets like trees or rocks in a single call.
func populate_nature(mm: MultiMesh, transforms: Array[Transform3D]) -> void:
    for i in transforms.size():
        mm.set_instance_transform(i, transforms[i])

# 4. Deep Duplication of Item Resources
# EXPERT NOTE: Prevent shared reference bugs (e.g., all axes breaking at once) by duplicating resources upon instance.
func initialize_item_stats(base_stats: Resource) -> Resource:
    return base_stats.duplicate(true) # Deep duplicate

# 5. Asynchronous World Chunk Loading
# EXPERT NOTE: Stream persistent world data on background threads to prevent exploration hitches.
func load_world_chunk(path: String) -> void:
    ResourceLoader.load_threaded_request(path)

# 6. GridMap Snapping for Base Building
# EXPERT NOTE: Correctly align player structures to a physical world grid for building systems.
func get_snapped_pos(grid: GridMap, world_pos: Vector3) -> Vector3:
    var cell := grid.local_to_map(world_pos)
    return grid.map_to_local(cell)

# 7. ConfigFile for Persistent Player Data
# EXPERT NOTE: Ideal for saving lightweight persistent options or simple unlocked recipes.
func save_unlocked_recipes(recipes: Array[StringName]) -> void:
    var config := ConfigFile.new()
    config.set_value("Player", "unlocked", recipes)
    config.save("user://progression.cfg")

# 8. Functional Inventory Filtering
# EXPERT NOTE: Use built-in filter method for fast searching of inventory arrays.
func get_edible_items(inventory: Array) -> Array:
    return inventory.filter(func(item): return item.get(&"is_edible") == true)

# 9. Persistent Entity Save Extraction
# EXPERT NOTE: Map all "Persist" group nodes to a dictionary for simple serialization.
func collect_world_state() -> Array[Dictionary]:
    return get_tree().get_nodes_in_group(&"Persist").map(func(n): return n.call(&"save"))

# 10. Physics Body Freeing Wrapper
# EXPERT NOTE: Always use queue_free() for nodes involved in physics to avoid immediate memory corruption.
func safely_remove_entity(entity: Node) -> void:
    if entity is Node:
        entity.queue_free()