# Recommended structure (top to bottom):
# 1. Extends declaration
extends CharacterBody2D

# 2. Class name (optional)
class_name Player

# 3. Signals
signal health_changed
signal died

# 4. Constants
const SPEED: float = 300.0
const JUMP_FORCE: float = -400.0

# 5. Variables
var health: int = 100
var is_alive: bool = true

# 6. Built-in functions
func _ready():
    initialize_player()

func _process(delta: float):
    update_movement(delta)

# 7. Custom functions (public first)
func take_damage(amount: int):
    health -= amount

# 8. Private functions (start with _)
func _initialize_player():
    print("Player initialized")

func check_player_state():
    if health <= 0:
        die()
    elif health < 20:
        show_low_health_warning()
        play_hurt_sound()
    elif health < 50:
        play_hurt_sound()
    else:
        # Health is above 50 - player is fine
        pass

enum {STATE_IDLE, STATE_WALK, STATE_RUN, STATE_JUMP}

var player_state = STATE_IDLE

func handle_state():
    match player_state:
        STATE_IDLE:
            play_idle_animation()
            velocity = Vector2.ZERO
        STATE_WALK:
            play_walk_animation()
            velocity = move_direction * walk_speed
        STATE_RUN:
            play_run_animation()
            velocity = move_direction * run_speed
        STATE_JUMP:
            play_jump_animation()
            velocity.y += gravity
        _:  # Default case (optional)
            print("Unknown state!")

func calculate_damage(base_damage: int, multiplier: float):
    print("DEBUG: calculate_damage called")
    print("DEBUG: base_damage = ", base_damage)
    print("DEBUG: multiplier = ", multiplier)
    
    var final_damage = base_damage * multiplier
    print("DEBUG: final_damage = ", final_damage)
    
    return final_damage

# Common extends examples:
extends Node  # Basic node, no special features
extends Node2D  # 2D node with position, rotation, scale
extends Sprite2D  # 2D sprite with texture
extends CharacterBody2D  # 2D character with physics movement
extends CharacterBody3D  # 3D character with physics
extends Control  # UI element
extends AnimationPlayer  # Animation controller

# With class_name for reusable components:
extends Node
class_name HealthComponent  # Now can be reused anywhere

# Array - ordered list
var items: Array = ["sword", "shield", "potion"]
items.append("bow")  # Add item
var first_item = items[0]  # Get first item

# Dictionary - key-value pairs
var player_stats: Dictionary = {
    "health": 100,
    "mana": 50,
    "level": 5
}
var player_health = player_stats["health"]  # Access value
player_stats["exp"] = 1200  # Add new key-value

# Enum - named constants
enum ItemType {WEAPON, ARMOR, POTION, KEY}
var current_item = ItemType.WEAPON

# Typed array (Godot 4+)
var int_array: Array[int] = [1, 2, 3]
var string_array: Array[String] = ["a", "b"]

# Basic variable declaration
var player_name: String = "Hero"
var score: int = 0
var game_over: bool = false

# onready - get references after node is ready
onready var animation_player = $AnimationPlayer
onready var sprite = get_node("Sprite2D")

# export - make editable in Inspector
export var move_speed: float = 300.0
export var jump_height: float = 500.0
export(String) var character_name = "Player"

# constants for values that never change
const MAX_HEALTH: int = 100
const PI: float = 3.14159
const TILE_SIZE: int = 64

# Godot 4 style exports with annotations
# @export var health: int = 100
# @export_range(0, 100) var mana: int = 50
# @export_file("*.png") var texture_path: String

# Basic function without parameters
func say_hello():
    print("Hello, World!")

# Function with parameters
func greet_player(player_name: String):
    print("Hello, " + player_name + "!")

# Function with return value
func add_numbers(a: int, b: int) -> int:
    return a + b

# Calling functions
say_hello()  # Prints: Hello, World!
greet_player("Alex")  # Prints: Hello, Alex!
var result = add_numbers(5, 3)  # result = 8

# Default parameter values
func attack(damage: int = 10, critical: bool = false):
    var final_damage = damage
    if critical:
        final_damage *= 2
    apply_damage(final_damage)

# Can call with different numbers of arguments
attack()  # Uses defaults: damage=10, critical=false
attack(20)  # damage=20, critical=false
attack(15, true)  # damage=15, critical=true

# Variable number of arguments
func sum_numbers(...numbers):
    var total = 0
    for num in numbers:
        total += num
    return total

var total = sum_numbers(1, 2, 3, 4, 5)  # total = 15

extends CharacterBody2D

var speed: float = 300.0
var jump_force: float = -400.0
var gravity: float = 980.0

# Called when node enters the scene tree
func _ready():
    print("Player controller initialized")
    # Setup initial state
    position = Vector2(100, 100)

# Called every physics frame (60 FPS fixed)
func _physics_process(delta: float):
    # Apply gravity
    if not is_on_floor():
        velocity.y += gravity * delta
    
    # Handle movement
    var input_direction = Input.get_axis("move_left", "move_right")
    velocity.x = input_direction * speed
    
    # Handle jumping
    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = jump_force
    
    # Move the character
    move_and_slide()

# Called every frame (variable FPS)
func _process(delta: float):
    # Update animations based on velocity
    update_animations()

# Handle input events
func _input(event: InputEvent):
    if event is InputEventKey:
        if event.pressed and event.keycode == KEY_ESCAPE:
            show_pause_menu()

# Example: Health system functions

# Public function - can be called from other scripts
func take_damage(amount: int):
    if is_invincible:
        return
    
    health -= amount
    _update_health_display()
    _check_death()
    
    if health > 0:
        _start_invincibility()

# Private function - starts with underscore, internal use only
func _update_health_display():
    health_bar.value = health
    health_label.text = "Health: " + str(health)

# Private function with return value
func _check_death() -> bool:
    if health <= 0:
        die()
        return true
    return false

# Function with multiple parameters and default values
func heal(amount: int, play_sound: bool = true, show_effect: bool = true):
    health = min(health + amount, max_health)
    _update_health_display()
    
    if play_sound:
        play_heal_sound()
    
    if show_effect:
        spawn_heal_effect()

# CORRECT: 4 spaces per level
func example_function():
    # Level 1: 4 spaces
    if condition:
        # Level 2: 8 spaces
        do_something()
        for i in range(10):
            # Level 3: 12 spaces
            print(i)
    else:
        # Back to level 2: 8 spaces
        do_something_else()

# WRONG: Mixed indentation (will cause errors)
func bad_function():
if condition:  # Missing indentation!
    do_something()
       another_thing()  # Wrong: 7 spaces
    yet_another()  # Back to 4 - inconsistent!

# Function definition
func my_function():
    # Function body indented
    print("Hello")

# If statements
if condition:
    # True branch
    do_this()
else:
    # False branch
    do_that()

# Loops
for item in items:
    # Loop body
    process_item(item)

# Nested structures
for enemy in enemies:
    if enemy.is_alive:
        if enemy.can_see_player:
            enemy.attack()
        else:
            enemy.patrol()
    else:
        enemy.remove()

# Single line comment - use for brief explanations
var health = 100  # Current player health

"""
Multi-line comment (three quotes)
Use for longer explanations, function documentation,
or temporarily disabling blocks of code.
"""

# TODO comments for future work
# TODO: Implement power-up system
# FIXME: This function has a bug when health = 0

# Function documentation
## Calculates damage based on weapon and enemy type.
## @param base_damage: The base damage of the weapon
## @param multiplier: Damage multiplier (default 1.0)
## @return: Final damage amount
func calculate_damage(base_damage: int, multiplier: float = 1.0) -> int:
    var damage = base_damage * multiplier
    return int(damage)

# Basic print
print("Game started")

# Print multiple values
print("Player position: ", position, " Health: ", health)

# Debug prints with labels
print("DEBUG: Player took damage. New health: ", health)

# Print for tracking function calls
func complex_function():
    print("DEBUG: Entering complex_function")
    # ... complex logic ...
    print("DEBUG: Exiting complex_function")

# Print with formatting
var player_name = "Hero"
var score = 1500
print("Player %s has score: %d" % [player_name, score])

# Print dictionaries and arrays nicely
var inventory = {"sword": 1, "shield": 1, "potion": 3}
print("Inventory: ", inventory)

# Conditional debugging
const DEBUG_MODE = true

func debug_print(message):
    if DEBUG_MODE:
        print("DEBUG: ", message)

# Use throughout code - easy to disable
debug_print("Player moved to " + str(position))

# Print with different severity levels
func log_info(message):
    print("[INFO] ", message)

func log_warning(message):
    print("[WARN] ", message)
    push_warning(message)  # Also shows in Godot's warning system

func log_error(message):
    print("[ERROR] ", message)
    push_error(message)  # Shows in Godot's error system

# Define signals at top of script
extends Node

signal health_changed(new_health)
signal player_died
signal item_collected(item_name, amount)

# Emit signals when events happen
func take_damage(amount: int):
    health -= amount
    emit_signal("health_changed", health)
    
    if health <= 0:
        emit_signal("player_died")

# Connect to signals in another script
func _ready():
    # Connect using code
    player_node.connect("health_changed", _on_player_health_changed)
    player_node.connect("player_died", _on_player_died)

# Handler functions (called when signal is emitted)
func _on_player_health_changed(new_health: int):
    health_bar.value = new_health

func _on_player_died():
    show_game_over_screen()

# Godot automatically creates this when connecting in editor:
func _on_Button_pressed():
    print("Button was pressed!")

# Signal with parameters - Godot includes them automatically
func _on_Player_health_changed(new_health):
    print("Player health is now: ", new_health)

# Signal with typed parameters (Godot 4)
signal damage_taken(amount: int, from: Node)

# One-time connections (disconnect after first emit)
player.connect("player_died", self, "_on_player_died", [], CONNECT_ONESHOT)

# Connecting with binds (pass extra parameters)
enemy.connect("died", self, "_on_enemy_died", [enemy.type, enemy.reward_exp])

# Disconnecting signals
func cleanup():
    if player.is_connected("health_changed", self, "_on_health_changed"):
        player.disconnect("health_changed", self, "_on_health_changed")

# Yield with signals (wait for signal)
func wait_for_player_death():
    print("Waiting for player to die...")
    yield(player, "player_died")  # Pauses here until signal emitted
    print("Player died! Game over.")

# Basic scene loading and changing

# Load a scene from file (but don't instantiate yet)
var main_menu_scene = preload("res://scenes/main_menu.tscn")
var game_level_scene = load("res://scenes/level_1.tscn")

# Instantiate a scene (create instance from packed scene)
var level_instance = game_level_scene.instantiate()

# Change to a new scene (replace current scene)
func go_to_main_menu():
    get_tree().change_scene_to_packed(main_menu_scene)

func start_game():
    get_tree().change_scene_to_file("res://scenes/game_level.tscn")

# Add scene as child (not replace current scene)
func spawn_enemy():
    var enemy_scene = preload("res://scenes/enemy.tscn")
    var enemy = enemy_scene.instantiate()
    add_child(enemy)
    enemy.position = Vector2(100, 100)

# Passing data to instantiated scenes

# Method 1: Set properties after instantiation
func spawn_player(player_name: String, starting_health: int):
    var player_scene = preload("res://scenes/player.tscn")
    var player = player_scene.instantiate()
    
    # Set properties
    player.name = player_name
    player.health = starting_health
    
    add_child(player)
    return player

# Method 2: Use initialization function
func spawn_enemy_with_type(enemy_type: String, position: Vector2):
    var enemy_scene = preload("res://scenes/enemy.tscn")
    var enemy = enemy_scene.instantiate()
    
    # Call initialization function
    enemy.initialize(enemy_type, position)
    
    add_child(enemy)

# In enemy.gd:
func initialize(type: String, spawn_position: Vector2):
    enemy_type = type
    position = spawn_position
    
    match type:
        "melee":
            speed = 100
            damage = 20
        "ranged":
            speed = 80
            damage = 15

# Adding Timer node in code
extends Node2D

var timer: Timer

func _ready():
    # Create and configure timer
    timer = Timer.new()
    timer.wait_time = 1.0  # 1 second
    timer.one_shot = false  # Repeat forever
    timer.autostart = false  # Don't start automatically
    
    # Connect timeout signal
    timer.connect("timeout", _on_timer_timeout)
    
    # Add as child
    add_child(timer)
    
    # Start the timer
    timer.start()

func _on_timer_timeout():
    print("Timer timeout! 1 second passed.")
    # Do something every second

extends Node2D

var time_since_last_shot: float = 0.0
const SHOT_COOLDOWN: float = 0.3  # 0.3 seconds between shots

func _process(delta: float):
    # Accumulate time
    time_since_last_shot += delta
    
    # Check if cooldown has passed
    if Input.is_action_pressed("shoot") and time_since_last_shot >= SHOT_COOLDOWN:
        shoot()
        time_since_last_shot = 0.0  # Reset cooldown

func shoot():
    # Create bullet, play sound, etc.
    print("Pew!")

# Basic multiplayer setup
extends Node

var peer = ENetMultiplayerPeer.new()

# Start as server (host)
func host_game(port: int = 9999):
    var error = peer.create_server(port)
    if error != OK:
        print("Failed to create server: ", error)
        return
    
    multiplayer.multiplayer_peer = peer
    print("Server started on port ", port)

# Connect as client
func join_game(ip: String = "127.0.0.1", port: int = 9999):
    var error = peer.create_client(ip, port)
    if error != OK:
        print("Failed to connect to server: ", error)
        return
    
    multiplayer.multiplayer_peer = peer
    print("Connected to server ", ip, ":", port)

# Disconnect
func disconnect_from_game():
    if multiplayer.multiplayer_peer:
        multiplayer.multiplayer_peer.close()
        multiplayer.multiplayer_peer = null
    print("Disconnected")

extends CharacterBody2D

# Called on server when player wants to move
func _process(delta: float):
    if Input.is_action_pressed("move_right"):
        request_move(Vector2.RIGHT)

# Client asks server to move
func request_move(direction: Vector2):
    move_rpc.rpc_id(1, direction)  # Send to server (ID 1)

# Server moves player and tells everyone
@rpc("any_peer", "call_local", "reliable")
func move_rpc(direction: Vector2):
    var sender_id = multiplayer.get_remote_sender_id()
    
    # Only server should process movement
    if multiplayer.is_server():
        # Move the player
        position += direction * 100 * get_process_delta_time()
        
        # Tell all clients about new position
        update_position_rpc.rpc(sender_id, position)

# Update position on all clients
@rpc("authority", "call_local", "reliable")
func update_position_rpc(player_id: int, new_position: Vector2):
    # Find player node and update position
    var player = get_node("Players/" + str(player_id))
    if player:
        player.position = new_position

# Spawn players when they join
func _ready():
    multiplayer.peer_connected.connect(_on_peer_connected)
    multiplayer.peer_disconnected.connect(_on_peer_disconnected)

func _on_peer_connected(id: int):
    print("Peer connected: ", id)
    spawn_player.rpc_id(id, id)  # Tell new player to spawn themselves
    
    # Tell existing players about new player
    for peer_id in multiplayer.get_peers():
        if peer_id != id:
            spawn_player.rpc_id(peer_id, id)

func _on_peer_disconnected(id: int):
    print("Peer disconnected: ", id)
    despawn_player.rpc(id)  # Remove player from all clients

@rpc("any_peer", "call_local")
func spawn_player(player_id: int):
    var player_scene = preload("res://player.tscn")
    var player = player_scene.instantiate()
    player.name = str(player_id)
    player.set_multiplayer_authority(player_id)  # This player controls this node
    $Players.add_child(player)

@rpc("any_peer", "call_local")
func despawn_player(player_id: int):
    var player = $Players.get_node_or_null(str(player_id))
    if player:
        player.queue_free()

# GameState.gd - A common singleton example
extends Node

# Global variables accessible from anywhere
var current_score: int = 0
var high_score: int = 0
var player_health: int = 100
var current_level: int = 1
var player_name: String = "Player"

# Signals that can be accessed globally
signal score_updated(new_score)
signal health_changed(new_health)
signal level_completed(level_number)

# Called when singleton loads
func _ready():
    print("GameState singleton loaded")
    load_save_data()  # Load saved game data

# Public functions accessible from any scene
func add_score(points: int):
    current_score += points
    if current_score > high_score:
        high_score = current_score
    emit_signal("score_updated", current_score)

func take_damage(amount: int):
    player_health -= amount
    player_health = max(player_health, 0)
    emit_signal("health_changed", player_health)

func complete_level():
    current_level += 1
    emit_signal("level_completed", current_level)
    save_game()

# Save/load system
func save_game():
    var save_data = {
        "high_score": high_score,
        "current_level": current_level,
        "player_name": player_name
    }
    # Save to file (simplified)
    print("Game saved: ", save_data)

func load_save_data():
    # Load from file (simplified)
    print("Loading saved data...")

# Accessing singleton from any script:

# Method 1: Direct access by name (if singleton named "GameState")
GameState.add_score(100)
var current_health = GameState.player_health

# Method 2: Through get_node (more explicit)
var game_state = get_node("/root/GameState")
game_state.take_damage(10)

# Method 3: Connect to singleton signals
func _ready():
    GameState.connect("score_updated", _on_score_updated)
    GameState.connect("health_changed", _on_health_changed)

func _on_score_updated(new_score: int):
    score_label.text = "Score: " + str(new_score)

func _on_health_changed(new_health: int):
    health_bar.value = new_health
    if new_health <= 0:
        game_over()

# Example of AI-generated complex system

# AI can help generate base classes like this:
class_name InventoryItem
extends Resource

@export var item_name: String
@export var item_type: String  # "weapon", "armor", "consumable"
@export var max_stack: int = 1
@export var icon: Texture2D
@export var weight: float = 0.0
@export var value: int = 0

func use(user: Node):
    match item_type:
        "consumable":
            print("Using ", item_name)
            # Apply effects to user
        "weapon":
            print("Equipping ", item_name)
        _:
            print("Item cannot be used directly")

# AI-generated state machine example
class_name EnemyStateMachine
extends Node

enum State {IDLE, PATROL, CHASE, ATTACK, FLEE}

@export var current_state: State = State.IDLE
@export var player: Node2D

func _process(delta: float):
    match current_state:
        State.IDLE:
            idle_state(delta)
        State.PATROL:
            patrol_state(delta)
        State.CHASE:
            chase_state(delta)
        State.ATTACK:
            attack_state(delta)
        State.FLEE:
            flee_state(delta)

func change_state(new_state: State):
    # Exit current state
    match current_state:
        State.IDLE:
            exit_idle()
        # ... other exit functions
    
    # Enter new state
    current_state = new_state
    
    match new_state:
        State.IDLE:
            enter_idle()
        # ... other enter functions

func idle_state(delta: float):
    # Check transitions
    if can_see_player():
        change_state(State.CHASE)
    elif should_patrol():
        change_state(State.PATROL)

# Basic game logic structure
extends Node

class_name GameManager

# Game state
enum GameState {MENU, PLAYING, PAUSED, GAME_OVER, LEVEL_COMPLETE}
var current_state: GameState = GameState.MENU

# Game variables
var score: int = 0
var lives: int = 3
var current_level: int = 1
var time_remaining: float = 60.0  # 60 second timer

# Signals
signal game_started
signal game_paused
signal game_resumed
signal game_over
signal score_changed(new_score)
signal lives_changed(new_lives)
signal time_changed(new_time)

func _ready():
    setup_game()

func setup_game():
    # Initialize game state
    score = 0
    lives = 3
    current_level = 1
    time_remaining = 60.0
    current_state = GameState.PLAYING
    
    emit_signal("game_started")
    emit_signal("score_changed", score)
    emit_signal("lives_changed", lives)
    emit_signal("time_changed", time_remaining)

func _process(delta: float):
    if current_state == GameState.PLAYING:
        # Update game timer
        time_remaining -= delta
        if time_remaining <= 0:
            time_remaining = 0
            game_over("Time's up!")
        elif time_remaining <= 10.0:
            emit_signal("time_changed", time_remaining)  # Update UI more frequently

func add_score(points: int):
    if current_state != GameState.PLAYING:
        return
    
    score += points
    emit_signal("score_changed", score)
    
    # Check for level completion
    if score >= get_level_target_score(current_level):
        complete_level()

func lose_life():
    if current_state != GameState.PLAYING:
        return
    
    lives -= 1
    emit_signal("lives_changed", lives)
    
    if lives <= 0:
        game_over("No lives remaining!")

func complete_level():
    current_state = GameState.LEVEL_COMPLETE
    print("Level ", current_level, " complete!")
    
    # Load next level after delay
    get_tree().create_timer(2.0).timeout.connect(
        load_next_level
    )

func game_over(reason: String = ""):
    current_state = GameState.GAME_OVER
    print("Game Over: ", reason)
    emit_signal("game_over", reason)

func get_level_target_score(level: int) -> int:
    # Define score needed to complete each level
    return level * 1000

extends Node

class_name DifficultyManager

enum Difficulty {EASY, NORMAL, HARD, INSANE}
@export var current_difficulty: Difficulty = Difficulty.NORMAL

# Difficulty modifiers
var difficulty_settings = {
    Difficulty.EASY: {
        "enemy_health_multiplier": 0.7,
        "enemy_damage_multiplier": 0.5,
        "spawn_rate_multiplier": 0.8,
        "player_health_multiplier": 1.5,
        "score_multiplier": 0.8
    },
    Difficulty.NORMAL: {
        "enemy_health_multiplier": 1.0,
        "enemy_damage_multiplier": 1.0,
        "spawn_rate_multiplier": 1.0,
        "player_health_multiplier": 1.0,
        "score_multiplier": 1.0
    },
    Difficulty.HARD: {
        "enemy_health_multiplier": 1.5,
        "enemy_damage_multiplier": 1.5,
        "spawn_rate_multiplier": 1.3,
        "player_health_multiplier": 0.8,
        "score_multiplier": 1.2
    },
    Difficulty.INSANE: {
        "enemy_health_multiplier": 2.0,
        "enemy_damage_multiplier": 2.0,
        "spawn_rate_multiplier": 1.5,
        "player_health_multiplier": 0.5,
        "score_multiplier": 1.5
    }
}

func get_enemy_health_multiplier() -> float:
    return difficulty_settings[current_difficulty]["enemy_health_multiplier"]

func get_enemy_damage_multiplier() -> float:
    return difficulty_settings[current_difficulty]["enemy_damage_multiplier"]

func get_spawn_rate_multiplier() -> float:
    return difficulty_settings[current_difficulty]["spawn_rate_multiplier"]

func get_player_health_multiplier() -> float:
    return difficulty_settings[current_difficulty]["player_health_multiplier"]

func get_score_multiplier() -> float:
    return difficulty_settings[current_difficulty]["score_multiplier"]

func adjust_difficulty_dynamically(player_performance: float):
    # Auto-adjust difficulty based on player performance
    if player_performance > 0.8:  # Player doing too well
        current_difficulty = clamp(current_difficulty + 1, 0, Difficulty.INSANE)
    elif player_performance < 0.3:  # Player struggling
        current_difficulty = clamp(current_difficulty - 1, Difficulty.EASY, Difficulty.INSANE)

# Example: Debugging a movement bug

# BUG REPORT: "Player sometimes gets stuck when moving right"

# Step 1: Add debug prints to understand the issue
func _physics_process(delta: float):
    debug_print("=== FRAME START ===")
    debug_print("Position before: ", position)
    debug_print("Velocity before: ", velocity)
    
    var input_direction = Input.get_axis("move_left", "move_right")
    debug_print("Input direction: ", input_direction)
    
    velocity.x = input_direction * speed
    debug_print("Velocity after input: ", velocity)
    
    move_and_slide()
    debug_print("Position after: ", position)
    debug_print("Is on floor: ", is_on_floor())
    debug_print("Is on wall: ", is_on_wall())
    
    # Check for collisions
    for i in range(get_slide_collision_count()):
        var collision = get_slide_collision(i)
        debug_print("Collision ", i, ": with ", collision.get_collider().name)
        debug_print("Collision normal: ", collision.get_normal())

extends Sprite2D

# Sprite properties
@export var normal_texture: Texture2D
@export var hover_texture: Texture2D
@export var click_texture: Texture2D

var is_hovered = false
var is_clicked = false

func _ready():
    # Set initial texture
    texture = normal_texture
    
    # Make sure sprite processes input
    set_process_input(true)

func _input(event: InputEvent):
    if event is InputEventMouseButton:
        if event.button_index == MOUSE_BUTTON_LEFT:
            if event.pressed:
                # Check if click is within sprite bounds
                var mouse_pos = get_global_mouse_position()
                var sprite_rect = Rect2(global_position - (scale * texture.get_size() / 2), scale * texture.get_size())
                
                if sprite_rect.has_point(mouse_pos):
                    is_clicked = true
                    texture = click_texture
            else:
                if is_clicked:
                    is_clicked = false
                    texture = normal_texture
                    on_click()  # Custom click handler
    
    elif event is InputEventMouseMotion:
        # Check hover state
        var mouse_pos = get_global_mouse_position()
        var sprite_rect = Rect2(global_position - (scale * texture.get_size() / 2), scale * texture.get_size())
        
        var now_hovered = sprite_rect.has_point(mouse_pos)
        
        if now_hovered != is_hovered:
            is_hovered = now_hovered
            if is_hovered and not is_clicked:
                texture = hover_texture
                modulate = Color(1.2, 1.2, 1.2)  # Brighten
            elif not is_clicked:
                texture = normal_texture
                modulate = Color.WHITE

func on_click():
    print("Sprite clicked!")
    # Add your click logic here

# Animation methods
func pulse(duration: float = 0.5):
    # Create a simple pulse animation
    var tween = create_tween()
    tween.tween_property(self, "scale", Vector2(1.2, 1.2), duration / 2)
    tween.tween_property(self, "scale", Vector2(1.0, 1.0), duration / 2)

extends Area2D

# Damage area (like a spike trap or enemy attack)
@export var damage_amount: int = 10
@export var damage_cooldown: float = 1.0  # Seconds between damage
@export var knockback_force: float = 200.0

var bodies_in_area: Array = []
var damage_timers: Dictionary = {}  # Track cooldowns per body

func _ready():
    # Connect area signals
    body_entered.connect(_on_body_entered)
    body_exited.connect(_on_body_exited)
    
    # Set collision mask/layer if not set in editor
    collision_layer = 2  # Layer 2
    collision_mask = 1   # Detect layer 1 (usually players)

func _on_body_entered(body: Node2D):
    if body.is_in_group("player"):
        bodies_in_area.append(body)
        damage_timers[body] = 0.0  # Initialize cooldown timer
        
        # Apply immediate damage on entry
        apply_damage(body)

func _on_body_exited(body: Node2D):
    if body in bodies_in_area:
        bodies_in_area.erase(body)
    
    if damage_timers.has(body):
        damage_timers.erase(body)

func _process(delta: float):
    # Update cooldown timers
    for body in damage_timers.keys():
        damage_timers[body] -= delta
        
        # Apply damage if cooldown expired and body still in area
        if damage_timers[body] <= 0 and body in bodies_in_area:
            apply_damage(body)
            damage_timers[body] = damage_cooldown

func apply_damage(body: Node2D):
    # Apply damage to body
    if body.has_method("take_damage"):
        body.take_damage(damage_amount)
    
    # Apply knockback
    if body is CharacterBody2D:
        var direction = (body.global_position - global_position).normalized()
        body.velocity += direction * knockback_force
    
    # Visual/audio feedback
    play_hit_effect()

func play_hit_effect():
    # Spawn particles, play sound, etc.
    print("Damage area hit something!")

extends Node2D

@onready var animation_player = $AnimationPlayer
@onready var sprite = $Sprite2D

enum AnimationState {IDLE, WALK, JUMP, ATTACK, HURT, DIE}
var current_animation_state: AnimationState = AnimationState.IDLE
var previous_animation_state: AnimationState = AnimationState.IDLE

func _ready():
    # Connect animation finished signal
    animation_player.animation_finished.connect(_on_animation_finished)
    
    # Start with idle animation
    play_animation("idle")

func _process(delta: float):
    # Determine which animation to play based on game state
    var new_state = determine_animation_state()
    
    if new_state != current_animation_state:
        previous_animation_state = current_animation_state
        current_animation_state = new_state
        update_animation()

func determine_animation_state() -> AnimationState:
    # Example logic - adjust based on your game
    if Input.is_action_pressed("attack"):
        return AnimationState.ATTACK
    elif not is_on_floor():
        return AnimationState.JUMP
    elif Input.is_action_pressed("move_left") or Input.is_action_pressed("move_right"):
        return AnimationState.WALK
    else:
        return AnimationState.IDLE

func update_animation():
    var animation_name = get_animation_name_for_state(current_animation_state)
    
    # Don't restart the same animation unless it's a one-shot
    if animation_player.current_animation != animation_name:
        play_animation(animation_name)
    
    # Handle special cases
    match current_animation_state:
        AnimationState.ATTACK:
            # Attack animations usually shouldn't be interrupted
            pass
        AnimationState.HURT, AnimationState.DIE:
            # These animations play once then transition
            pass

func get_animation_name_for_state(state: AnimationState) -> String:
    match state:
        AnimationState.IDLE:
            return "idle"
        AnimationState.WALK:
            return "walk"
        AnimationState.JUMP:
            return "jump"
        AnimationState.ATTACK:
            return "attack"
        AnimationState.HURT:
            return "hurt"
        AnimationState.DIE:
            return "die"
        _:
            return "idle"

func play_animation(animation_name: String):
    if animation_player.has_animation(animation_name):
        animation_player.play(animation_name)
    else:
        print("Warning: Animation '", animation_name, "' not found!")

func _on_animation_finished(anim_name: String):
    # Handle animation completion
    match anim_name:
        "attack":
            # Return to previous state after attack
            current_animation_state = previous_animation_state
            update_animation()
        "hurt":
            # Return to idle after hurt animation
            current_animation_state = AnimationState.IDLE
            update_animation()
        "die":
            # Game over logic
            game_over()

# Advanced animation control
func blend_animations(animation1: String, animation2: String, blend_amount: float):
    # Simple animation blending example
    animation_player.play(animation1)
    animation_player.advance(blend_amount)

func change_animation_speed(speed_multiplier: float):
    animation_player.speed_scale = speed_multiplier

func play_animation_backwards(animation_name: String):
    animation_player.play(animation_name)
    animation_player.advance(animation_player.current_animation_length)
    animation_player.play_backwards(animation_name)

# Inventory System Base Class
extends Node

class_name InventorySystem

@export var max_slots: int = 20
@export var max_weight: float = 100.0

var items: Array[InventoryItem] = []
var equipped_items: Dictionary = {}  # slot_type: item

signal inventory_updated
signal item_added(item: InventoryItem, slot: int)
signal item_removed(item: InventoryItem, slot: int)
signal item_equipped(item: InventoryItem, slot_type: String)
signal item_unequipped(item: InventoryItem, slot_type: String)

func _ready():
    # Initialize empty inventory slots
    for i in range(max_slots):
        items.append(null)

func add_item(item: InventoryItem) -> bool:
    # Check if we can carry this item
    if get_current_weight() + item.weight > max_weight:
        print("Too heavy to carry!")
        return false
    
    # Find empty slot or stack with existing item
    var slot = find_available_slot(item)
    
    if slot == -1:
        print("No space in inventory!")
        return false
    
    # Add to slot
    if items[slot] == null:
        items[slot] = item
        item.quantity = 1
    else:
        # Stack items
        var existing_item = items[slot]
        var space_left = existing_item.max_stack - existing_item.quantity
        
        if space_left >= item.quantity:
            existing_item.quantity += item.quantity
        else:
            # Partial stack
            existing_item.quantity = existing_item.max_stack
            item.quantity -= space_left
            # Try to add remainder to another slot
            return add_item(item) and true  # Recursive call
    
    emit_signal("item_added", item, slot)
    emit_signal("inventory_updated")
    return true

func remove_item(slot: int, quantity: int = 1) -> InventoryItem:
    if slot < 0 or slot >= items.size() or items[slot] == null:
        return null
    
    var item = items[slot]
    
    if quantity >= item.quantity:
        # Remove entire stack
        items[slot] = null
    else:
        # Remove partial stack
        item.quantity -= quantity
        # Create new item instance for the removed portion
        var removed_item = item.duplicate()
        removed_item.quantity = quantity
    
    emit_signal("item_removed", item, slot)
    emit_signal("inventory_updated")
    return item

func find_available_slot(item: InventoryItem) -> int:
    # First try to stack with existing items
    for i in range(items.size()):
        if items[i] != null and items[i].item_id == item.item_id:
            if items[i].quantity < items[i].max_stack:
                return i
    
    # Then find empty slot
    for i in range(items.size()):
        if items[i] == null:
            return i
    
    return -1  # No available slots

func get_current_weight() -> float:
    var total_weight: float = 0.0
    for item in items:
        if item != null:
            total_weight += item.weight * item.quantity
    return total_weight

func equip_item(slot: int, equipment_slot: String) -> bool:
    if slot < 0 or slot >= items.size() or items[slot] == null:
        return false
    
    var item = items[slot]
    
    # Check if item can be equipped in this slot
    if not equipment_slot in item.equippable_slots:
        print("Item cannot be equipped in this slot!")
        return false
    
    # Unequip current item in this slot if any
    if equipped_items.has(equipment_slot):
        unequip_item(equipment_slot)
    
    # Equip new item
    equipped_items[equipment_slot] = item
    
    # Apply item stats to player
    apply_item_stats(item)
    
    emit_signal("item_equipped", item, equipment_slot)
    return true

func unequip_item(equipment_slot: String) -> InventoryItem:
    if not equipped_items.has(equipment_slot):
        return null
    
    var item = equipped_items[equipment_slot]
    equipped_items.erase(equipment_slot)
    
    # Remove item stats from player
    remove_item_stats(item)
    
    emit_signal("item_unequipped", item, equipment_slot)
    return item

func apply_item_stats(item: InventoryItem):
    # Apply item's stats to the player character
    # This would interface with your character stats system
    print("Applying stats from ", item.item_name)

extends CanvasLayer

class_name DialogueSystem

@onready var dialogue_box = $DialogueBox
@onready var name_label = $DialogueBox/NameLabel
@onready var text_label = $DialogueBox/TextLabel
@onready var choices_container = $DialogueBox/ChoicesContainer
@onready var continue_indicator = $DialogueBox/ContinueIndicator

@export var text_speed: float = 0.05  # Seconds per character
@export var auto_advance_delay: float = 2.0  # Seconds before auto-advance

var current_dialogue: Dictionary
var current_line_index: int = 0
var is_dialogue_active: bool = false
var is_typing: bool = false
var typewriter_timer: float = 0.0
var current_character_index: int = 0

signal dialogue_started
signal dialogue_ended
signal dialogue_line_started(line_index: int)
signal dialogue_line_completed(line_index: int)
signal choice_selected(choice_index: int)

func _ready():
    hide_dialogue()

func start_dialogue(dialogue_data: Dictionary):
    if is_dialogue_active:
        print("Dialogue already active!")
        return
    
    current_dialogue = dialogue_data
    current_line_index = 0
    is_dialogue_active = true
    
    show_dialogue()
    emit_signal("dialogue_started")
    
    display_current_line()

func display_current_line():
    if current_line_index >= current_dialogue["lines"].size():
        end_dialogue()
        return
    
    var line_data = current_dialogue["lines"][current_line_index]
    
    # Set speaker name
    name_label.text = line_data["speaker"] if line_data.has("speaker") else ""
    
    # Clear previous text
    text_label.text = ""
    current_character_index = 0
    is_typing = true
    
    # Clear previous choices
    clear_choices()
    
    # Hide continue indicator while typing
    continue_indicator.visible = false
    
    emit_signal("dialogue_line_started", current_line_index)

func _process(delta: float):
    if not is_dialogue_active or not is_typing:
        return
    
    # Typewriter effect
    typewriter_timer += delta
    
    var line_data = current_dialogue["lines"][current_line_index]
    var full_text = line_data["text"]
    
    if typewriter_timer >= text_speed:
        typewriter_timer = 0.0
        current_character_index += 1
        
        if current_character_index > full_text.length():
            finish_typing()
        else:
            text_label.text = full_text.substr(0, current_character_index)

func finish_typing():
    is_typing = false
    var line_data = current_dialogue["lines"][current_line_index]
    text_label.text = line_data["text"]
    
    # Show choices if this line has them
    if line_data.has("choices") and not line_data["choices"].is_empty():
        show_choices(line_data["choices"])
    else:
        # Show continue indicator
        continue_indicator.visible = true
    
    emit_signal("dialogue_line_completed", current_line_index)

func show_choices(choices: Array):
    # Create choice buttons
    for i in range(choices.size()):
        var choice_data = choices[i]
        var button = Button.new()
        button.text = choice_data["text"]
        button.pressed.connect(
            func(): on_choice_selected(i)
        )
        choices_container.add_child(button)

func on_choice_selected(choice_index: int):
    var line_data = current_dialogue["lines"][current_line_index]
    var choice_data = line_data["choices"][choice_index]
    
    # Handle choice result
    if choice_data.has("next_line"):
        current_line_index = choice_data["next_line"]
    elif choice_data.has("end_dialogue") and choice_data["end_dialogue"]:
        end_dialogue()
        return
    else:
        current_line_index += 1
    
    clear_choices()
    display_current_line()
    
    emit_signal("choice_selected", choice_index)

func advance_dialogue():
    if not is_dialogue_active:
        return
    
    if is_typing:
        finish_typing()
        return
    
    var line_data = current_dialogue["lines"][current_line_index]
    
    # Check if current line has choices
    if line_data.has("choices") and not line_data["choices"].is_empty():
        # Don't advance if there are choices to make
        return
    
    current_line_index += 1
    display_current_line()

func end_dialogue():
    is_dialogue_active = false
    hide_dialogue()
    emit_signal("dialogue_ended")

func show_dialogue():
    dialogue_box.visible = true
    set_process(true)

func hide_dialogue():
    dialogue_box.visible = false
    set_process(false)

func clear_choices():
    for child in choices_container.get_children():
        child.queue_free()

# Example dialogue data structure:
# var dialogue = {
#     "lines": [
#         {
#             "speaker": "NPC",
#             "text": "Hello, traveler!",
#         },
#         {
#             "speaker": "NPC",
#             "text": "Would you like to help me?",
#             "choices": [
#                 {"text": "Yes, I'll help!", "next_line": 2},
#                 {"text": "No, I'm busy.", "end_dialogue": true}
#             ]
#         }
#     ]
# }

extends Node

class_name SaveSystem

const SAVE_DIR = "user://saves/"
const SAVE_FILE_TEMPLATE = "save_%d.json"

signal game_saved(slot: int)
signal game_loaded(slot: int)
signal save_deleted(slot: int)

func _ready():
    # Ensure save directory exists
    var dir = DirAccess.open("user://")
    if not dir.dir_exists(SAVE_DIR):
        dir.make_dir(SAVE_DIR)

func save_game(slot: int = 0, data: Dictionary = {}) -> bool:
    # Get save data from game systems if not provided
    if data.is_empty():
        data = collect_save_data()
    
    # Add metadata
    data["metadata"] = {
        "save_date": Time.get_datetime_string_from_system(),
        "game_version": "1.0.0",
        "play_time": GameStats.play_time
    }
    
    # Convert to JSON
    var json_string = JSON.stringify(data, "\t")
    
    # Save to file
    var file_path = SAVE_DIR.path_join(SAVE_FILE_TEMPLATE % slot)
    var file = FileAccess.open(file_path, FileAccess.WRITE)
    
    if file == null:
        push_error("Failed to save game: ", FileAccess.get_open_error())
        return false
    
    file.store_string(json_string)
    file.close()
    
    print("Game saved to slot ", slot)
    emit_signal("game_saved", slot)
    return true

func load_game(slot: int = 0) -> Dictionary:
    var file_path = SAVE_DIR.path_join(SAVE_FILE_TEMPLATE % slot)
    
    if not FileAccess.file_exists(file_path):
        push_error("Save file not found: ", file_path)
        return {}
    
    var file = FileAccess.open(file_path, FileAccess.READ)
    
    if file == null:
        push_error("Failed to load game: ", FileAccess.get_open_error())
        return {}
    
    var json_string = file.get_as_text()
    file.close()
    
    var json = JSON.new()
    var error = json.parse(json_string)
    
    if error != OK:
        push_error("Failed to parse save file: ", json.get_error_message())
        return {}
    
    var data = json.get_data()
    
    # Validate save data
    if not validate_save_data(data):
        push_error("Save data validation failed!")
        return {}
    
    print("Game loaded from slot ", slot)
    emit_signal("game_loaded", slot)
    
    return data

func collect_save_data() -> Dictionary:
    # Collect data from all game systems
    var data = {}
    
    # Player data
    data["player"] = {
        "position": GameState.player_position,
        "health": GameState.player_health,
        "level": GameState.player_level,
        "experience": GameState.player_experience
    }
    
    # Inventory data
    var inventory_data = []
    for item in InventorySystem.items:
        if item != null:
            inventory_data.append({
                "item_id": item.item_id,
                "quantity": item.quantity
            })
    data["inventory"] = inventory_data
    
    # Quest data
    data["quests"] = QuestSystem.get_save_data()
    
    # World state
    data["world"] = WorldState.get_save_data()
    
    return data

func apply_save_data(data: Dictionary):
    # Apply loaded data to game systems
    
    # Player data
    if data.has("player"):
        var player_data = data["player"]
        GameState.player_position = player_data["position"]
        GameState.player_health = player_data["health"]
        GameState.player_level = player_data["level"]
        GameState.player_experience = player_data["experience"]
    
    # Inventory data
    if data.has("inventory"):
        InventorySystem.load_from_data(data["inventory"])
    
    # Quest data
    if data.has("quests"):
        QuestSystem.load_from_data(data["quests"])
    
    # World state
    if data.has("world"):
        WorldState.load_from_data(data["world"])

func validate_save_data(data: Dictionary) -> bool:
    # Basic validation
    if not data.has("metadata"):
        return false
    
    var metadata = data["metadata"]
    
    # Check version compatibility
    if metadata.has("game_version"):
        var save_version = metadata["game_version"]
        var current_version = "1.0.0"  # Should be from your game config
        
        # Simple version check (in real game, use proper semver comparison)
        if save_version != current_version:
            print("Warning: Save version mismatch. Save: ", save_version, ", Current: ", current_version)
            # You might want to add version migration logic here
    
    return true

func get_save_slots_info() -> Array:
    # Get information about all save slots
    var slots_info = []
    
    for slot in range(10):  # 10 save slots
        var file_path = SAVE_DIR.path_join(SAVE_FILE_TEMPLATE % slot)
        
        if FileAccess.file_exists(file_path):
            # Load just the metadata to show in UI
            var file = FileAccess.open(file_path, FileAccess.READ)
            if file:
                var json_string = file.get_as_text()
                file.close()
                
                var json = JSON.new()
                if json.parse(json_string) == OK:
                    var data = json.get_data()
                    if data.has("metadata"):
                        slots_info.append({
                            "slot": slot,
                            "exists": true,
                            "metadata": data["metadata"]
                        })
                        continue
        
        slots_info.append({
            "slot": slot,
            "exists": false,
            "metadata": {}
        })
    
    return slots_info

func delete_save(slot: int) -> bool:
    var file_path = SAVE_DIR.path_join(SAVE_FILE_TEMPLATE % slot)
    
    if not FileAccess.file_exists(file_path):
        print("Save file not found: ", file_path)
        return false
    
    var dir = DirAccess.open(SAVE_DIR)
    if dir.remove(file_path) != OK:
        push_error("Failed to delete save file: ", file_path)
        return false
    
    print("Save file deleted: ", file_path)
    emit_signal("save_deleted", slot)
    return true

# Main Game Script - Ties everything together
extends Node

class_name GameMain

# Game state management
enum GamePhase {BOOT, MAIN_MENU, PLAYING, PAUSED, GAME_OVER, CREDITS}
@export var current_phase: GamePhase = GamePhase.BOOT

# Subsystems
@onready var audio_manager = $AudioManager
@onready var save_system = $SaveSystem
@onready var input_manager = $InputManager
@onready var scene_manager = $SceneManager
@onready var ui_manager = $UIManager

# Game data
var game_settings: Dictionary = {}
var player_data: Dictionary = {}
var world_state: Dictionary = {}

func _ready():
    # Initialize game
    initialize_game()

func initialize_game():
    print("=== GAME INITIALIZATION ===")
    
    # Load settings
    load_settings()
    
    # Apply settings to subsystems
    apply_game_settings()
    
    # Initialize subsystems
    audio_manager.initialize()
    input_manager.initialize()
    ui_manager.initialize()
    
    # Show splash screen or go to main menu
    transition_to_phase(GamePhase.MAIN_MENU)
    
    print("Game initialized successfully")

func load_settings():
    # Try to load saved settings
    var settings_path = "user://settings.cfg"
    
    if FileAccess.file_exists(settings_path):
        var file = FileAccess.open(settings_path, FileAccess.READ)
        if file:
            var json_string = file.get_as_text()
            file.close()
            
            var json = JSON.new()
            if json.parse(json_string) == OK:
                game_settings = json.get_data()
                return
    
    # Load default settings
    game_settings = {
        "audio": {
            "master_volume": 1.0,
            "music_volume": 0.8,
            "sfx_volume": 1.0
        },
        "graphics": {
            "resolution": Vector2(1280, 720),
            "fullscreen": false,
            "vsync": true
        },
        "gameplay": {
            "difficulty": "normal",
            "language": "en"
        }
    }

func save_settings():
    var settings_path = "user://settings.cfg"
    var file = FileAccess.open(settings_path, FileAccess.WRITE)
    
    if file:
        var json_string = JSON.stringify(game_settings, "\t")
        file.store_string(json_string)
        file.close()
        print("Settings saved")
    else:
        push_error("Failed to save settings")

func apply_game_settings():
    # Apply audio settings
    if game_settings.has("audio"):
        var audio = game_settings["audio"]
        audio_manager.set_master_volume(audio["master_volume"])
        audio_manager.set_music_volume(audio["music_volume"])
        audio_manager.set_sfx_volume(audio["sfx_volume"])
    
    # Apply graphics settings
    if game_settings.has("graphics"):
        var graphics = game_settings["graphics"]
        var resolution = graphics["resolution"]
        get_window().set_size(resolution)
        get_window().set_mode(Window.MODE_FULLSCREEN if graphics["fullscreen"] else Window.MODE_WINDOWED)
        DisplayServer.window_set_vsync_mode(DisplayServer.VSYNC_ENABLED if graphics["vsync"] else DisplayServer.VSYNC_DISABLED)

func transition_to_phase(new_phase: GamePhase):
    # Exit current phase
    exit_current_phase()
    
    # Enter new phase
    current_phase = new_phase
    enter_new_phase(new_phase)

func exit_current_phase():
    match current_phase:
        GamePhase.MAIN_MENU:
            ui_manager.hide_main_menu()
        GamePhase.PLAYING:
            # Save game state if needed
            if should_autosave():
                save_system.save_game(0)
        GamePhase.PAUSED:
            ui_manager.hide_pause_menu()

func enter_new_phase(phase: GamePhase):
    match phase:
        GamePhase.MAIN_MENU:
            ui_manager.show_main_menu()
            audio_manager.play_menu_music()
        GamePhase.PLAYING:
            start_gameplay()
        GamePhase.PAUSED:
            ui_manager.show_pause_menu()
        GamePhase.GAME_OVER:
            ui_manager.show_game_over_screen()
        GamePhase.CREDITS:
            ui_manager.show_credits()

func start_gameplay():
    # Load or create new game
    if should_load_saved_game():
        var save_data = save_system.load_game(0)
        if not save_data.is_empty():
            load_game_state(save_data)
    else:
        create_new_game()
    
    # Start gameplay systems
    audio_manager.play_gameplay_music()
    ui_manager.show_game_hud()
    
    # Unpause game
    get_tree().paused = false

func create_new_game():
    print("Creating new game...")
    
    # Initialize player data
    player_data = {
        "health": 100,
        "level": 1,
        "experience": 0,
        "position": Vector2(0, 0)
    }
    
    # Initialize world state
    world_state = {
        "current_level": 1,
        "time_of_day": 0.0,
        "weather": "clear"
    }
    
    # Load first level
    scene_manager.load_level(1)

func load_game_state(save_data: Dictionary):
    print("Loading game state...")
    
    # Apply save data to all systems
    save_system.apply_save_data(save_data)
    
    # Load appropriate level
    if save_data.has("world") and save_data["world"].has("current_level"):
        scene_manager.load_level(save_data["world"]["current_level"])

func should_autosave() -> bool:
    # Check if we should autosave based on game state
    return current_phase == GamePhase.PLAYING and game_settings.get("autosave", true)

func should_load_saved_game() -> bool:
    # Check if there's a saved game and player wants to continue
    # This would be set by the main menu based on player choice
    return false  # For new game

func _input(event: InputEvent):
    # Global input handling
    if event.is_action_pressed("pause"):
        if current_phase == GamePhase.PLAYING:
            transition_to_phase(GamePhase.PAUSED)
            get_tree().paused = true
        elif current_phase == GamePhase.PAUSED:
            transition_to_phase(GamePhase.PLAYING)
            get_tree().paused = false
    
    if event.is_action_pressed("fullscreen"):
        toggle_fullscreen()

func toggle_fullscreen():
    var fullscreen = not get_window().mode == Window.MODE_FULLSCREEN
    get_window().set_mode(Window.MODE_FULLSCREEN if fullscreen else Window.MODE_WINDOWED)
    
    # Update settings
    if not game_settings.has("graphics"):
        game_settings["graphics"] = {}
    game_settings["graphics"]["fullscreen"] = fullscreen
    
    save_settings()

func quit_game():
    # Save before quitting
    if should_autosave():
        save_system.save_game(0)
    
    save_settings()
    
    print("Quitting game...")
    get_tree().quit()