Godot Economy System

# currency_label_sync.gd
# Reactive UI for balance display
extends Label

@export var currency_id: String = "gold"

func _ready():
	WalletManager.balance_changed.connect(_on_balance_changed)
	text = str(WalletManager.balances.get(currency_id, 0))

func _on_balance_changed(id: String, amount: int):
	if id == currency_id:
		text = str(amount)

# currency_pickup_effect.gd
# Visual feedback for financial gains
extends GPUParticles2D

# EXPERT NOTE: Trigger visual effects via balance signals 
# to ensure the world "feels" the impact of economic changes.

func _ready():
	WalletManager.balance_changed.connect(_on_balance_changed)

func _on_balance_changed(id: String, _amount: int):
	if id == "gold":
		restart()

# currency_resource.gd
# Specialized data container for denominations
class_name Currency extends Resource

# EXPERT NOTE: Defining Gold, Gems, and XP as Resources 
# allow for modular wallet logic and distinct UI icons.

@export var id: String = "gold"
@export var display_name: String = "Gold"
@export var icon: Texture2D
@export var is_premium: bool = false
@export var max_limit: int = 999999

# dynamic_price_modifier.gd
# Adjusting costs based on world state
extends Resource

# EXPERT NOTE: Injecting price modifiers allows for "Sale" events 
# or "Charisma" discounts without touching core item data.

@export var multiplier: float = 1.0

func calculate_price(base_price: int) -> int:
	return roundi(base_price * multiplier)

# economy_persistence_handler.gd
# Saving financial state securely
extends Node

# EXPERT NOTE: Save balances as a simple JSON-compatible dictionary. 
# Consider basic encryption for premium currency counts.

func save_economy() -> Dictionary:
	return WalletManager.balances.duplicate()

func load_economy(data: Dictionary):
	WalletManager.balances = data
	for id in data:
		WalletManager.balance_changed.emit(id, data[id])

# loot_drop_economy_bridge.gd
# Hooking combat drops to wallet addition
extends Node

# EXPERT NOTE: Use a generic node to listen for "Gold Drops" from enemies 
# to keep the combat system focused only on health/damage.

func _on_enemy_looted(gold_amount: int):
	WalletManager.add_funds("gold", gold_amount)
	print("Looted ", gold_amount, " gold.")

# skills/economy-system/code/loot_table_weighted.gd
extends Resource

## Weighted Loot Table Expert Pattern
## Uses cumulative probability for high-precision drop distribution.

class_name LootTable

@export var items: Array[LootItem] = []

func get_random_item() -> Resource:
    var total_weight = 0.0
    for item in items:
        total_weight += item.weight
    
    var roll = randf() * total_weight
    var cumulative_weight = 0.0
    
    for item in items:
        cumulative_weight += item.weight
        if roll <= cumulative_weight:
            return item.item_resource
    
    return null

## Supporting Resource Type
class LootItem extends Resource:
    @export var item_resource: Resource
    @export var weight: float = 1.0 # Higher = more common
    @export var tier: int = 1       # Optional metadata for filtering

## EXPERT NOTE:
## Storing loot tables as Resources allows designers to swap tables 
## (e.g., 'Normal Chest' vs 'Boss Chest') in the inspector without code changes.

# shop_item_data.gd
# Pricing and availability for purchasables
class_name ShopItem extends Resource

# EXPERT NOTE: Shop items wrap InventoryItems with 
# pricing and stock metadata.

@export var item: InventoryItem
@export var cost: int = 100
@export var currency_id: String = "gold"
@export var initial_stock: int = -1 # -1 for infinite

var current_stock: int = 0

func _init():
	current_stock = initial_stock

# shop_system_logic.gd
# Orchestrating buys and sells
extends Node

# EXPERT NOTE: Logic should be decoupled from UI. 
# This node handles the actual exchange of resources.

func buy_item(shop_item: ShopItem) -> bool:
	if shop_item.current_stock == 0:
		return false
		
	if WalletManager.spend_funds(shop_item.currency_id, shop_item.cost):
		if shop_item.current_stock > 0:
			shop_item.current_stock -= 1
		
		# Assumes InventoryManager exists
		InventoryManager.add_item(shop_item.item)
		return true
		
	return false

func sell_item(item: InventoryItem, price: int):
	if InventoryManager.remove_item(item):
		WalletManager.add_funds("gold", price)

# trade_contract_resource.gd
# Advanced multi-item bartering logic
class_name TradeContract extends Resource

# EXPERT NOTE: Contracts allow for "Quid Pro Quo" transactions 
# where specific items are traded for others without currency.

@export var take_items: Array[InventoryItem]
@export var give_items: Array[InventoryItem]

func execute_trade():
	# Validate inventory has all 'take_items' first...
	pass

# skills/economy-system/scripts/transaction_manager.gd
extends Node

## Transaction Manager Expert Pattern
## Safe atomic transactions for in-game economy (shops, trades).

class_name TransactionManager

signal transaction_completed(type: String, amount: int, item: String)
signal transaction_failed(reason: String)

enum CurrencyType { GOLD, GEMS, TOKENS }

var _wallets: Dictionary = {
	CurrencyType.GOLD: 0,
	CurrencyType.GEMS: 0
}

func get_balance(currency: CurrencyType) -> int:
	return _wallets.get(currency, 0)

func add_currency(currency: CurrencyType, amount: int) -> void:
	_wallets[currency] = get_balance(currency) + amount
	transaction_completed.emit("earn", amount, "")

func attempt_purchase(cost: int, currency: CurrencyType, item_id: String, inventory_target: InventoryData = null) -> bool:
	# 1. Validation
	if cost < 0:
		transaction_failed.emit("Invalid cost")
		return false
		
	if get_balance(currency) < cost:
		transaction_failed.emit("Insufficient funds")
		return false
	
	# 2. Inventory Check (Atomic Step 1)
	if inventory_target:
		if not inventory_target.can_add_item(item_id):
			transaction_failed.emit("Inventory full")
			return false
	
	# 3. Execution (Atomic Step 2)
	_wallets[currency] -= cost
	
	if inventory_target:
		inventory_target.add_item_by_id(item_id)
	
	transaction_completed.emit("spend", cost, item_id)
	return true

func attempt_sell(item_id: String, price: int, currency: CurrencyType, inventory_source: InventoryData) -> bool:
	# 1. Validation
	if not inventory_source.has_item(item_id):
		transaction_failed.emit("Item not found")
		return false
	
	# 2. Execution
	inventory_source.remove_item_by_id(item_id)
	add_currency(currency, price)
	
	transaction_completed.emit("sell", price, item_id)
	return true

## EXPERT USAGE:
## if TransactionManager.attempt_purchase(50, CurrencyType.GOLD, "sword_01", player_inv):
##     play_sound("kaching")

# wallet_manager_singleton.gd
# Centralized economy state and transactions
extends Node

# EXPERT NOTE: The Wallet should be an Autoload to manage 
# balances across different scenes (Shop vs World).

signal balance_changed(currency_id: String, new_amount: int)
signal transaction_failed(reason: String)

var balances: Dictionary = {} # currency_id -> int

func add_funds(currency_id: String, amount: int):
	var current = balances.get(currency_id, 0)
	balances[currency_id] = current + amount
	balance_changed.emit(currency_id, balances[currency_id])

func spend_funds(currency_id: String, amount: int) -> bool:
	var current = balances.get(currency_id, 0)
	if current >= amount:
		balances[currency_id] = current - amount
		balance_changed.emit(currency_id, balances[currency_id])
		return true
	
	transaction_failed.emit("Insufficient funds")
	return false