Herramientas GameDev estilo RPG en Godot 4.4

💡 Nota: Este artículo cubre las mejoras específicas de Godot 4.4, incluyendo el nuevo sistema de TileMap layers y las optimizaciones de performance para mundos grandes.

# Configuración recomendada para RPG tile-based
extends TileMap

@export var tile_size: Vector2i = Vector2i(32, 32)
@export var chunk_size: int = 64  # Para optimización de mundos grandes

# Layers estándar para RPG
enum LAYERS {
    GROUND = 0,      # Suelo base
    DECORATION = 1,  # Detalles decorativos
    COLLISION = 2,   # Objetos con colisión
    OVERLAY = 3      # Efectos especiales
}

func _ready():
    # Configurar capas automáticamente
    setup_rpg_layers()

func setup_rpg_layers():
    # Asegurar que tenemos las capas necesarias
    while get_layers_count() < 4:
        add_layer(-1)
    
    # Configurar propiedades de cada capa
    set_layer_name(LAYERS.GROUND, "Ground")
    set_layer_name(LAYERS.DECORATION, "Decoration")
    set_layer_name(LAYERS.COLLISION, "Collision")
    set_layer_name(LAYERS.OVERLAY, "Overlay")
    
    # Solo la capa de colisión debe tener física
    set_layer_enabled(LAYERS.COLLISION, true)
    set_layer_collision_enabled(LAYERS.COLLISION, true)

# Ejemplo de Custom Data Layers para RPG
# En el TileSet resource:

# Layer 1: "walkable" (bool) - ¿Se puede caminar?
# Layer 2: "interaction_type" (String) - "door", "chest", "npc", "shop"
# Layer 3: "damage_per_second" (float) - Para tiles de lava, ácido, etc.
# Layer 4: "sound_material" (String) - "grass", "stone", "wood", "metal"
# Layer 5: "encounter_rate" (float) - Probabilidad de encuentros aleatorios

# Script para autotiling automático
extends TileMap

func auto_tile_area(start_pos: Vector2i, end_pos: Vector2i, terrain_id: int):
    var rect = Rect2i(start_pos, end_pos - start_pos + Vector2i.ONE)
    
    for pos in rect:
        # Usar el nuevo sistema de terrain de Godot 4.4
        set_cells_terrain_connect(0, [pos], 0, terrain_id, false)
    
    # Aplicar las reglas de autotiling
    for pos in rect:
        var neighbors = get_surrounding_cells(pos)
        apply_terrain_rules(pos, neighbors, terrain_id)

class_name RPGPlayer extends CharacterBody2D

@export var move_speed: float = 120.0
@export var tile_size: int = 32

var target_position: Vector2
var is_moving: bool = false
var facing_direction: Vector2 = Vector2.DOWN

@onready var sprite: AnimatedSprite2D = $AnimatedSprite2D
@onready var interaction_area: Area2D = $InteractionArea

func _ready():
    # Alinear posición inicial al grid
    position = snap_to_grid(position)
    target_position = position

func _physics_process(delta):
    handle_input()
    handle_movement(delta)
    update_animation()

func handle_input():
    if is_moving:
        return
    
    var input_dir = Vector2.ZERO
    
    if Input.is_action_just_pressed("move_up"):
        input_dir = Vector2.UP
    elif Input.is_action_just_pressed("move_down"):
        input_dir = Vector2.DOWN
    elif Input.is_action_just_pressed("move_left"):
        input_dir = Vector2.LEFT
    elif Input.is_action_just_pressed("move_right"):
        input_dir = Vector2.RIGHT
    elif Input.is_action_just_pressed("interact"):
        try_interact()
        return
    
    if input_dir != Vector2.ZERO:
        try_move(input_dir)

func try_move(direction: Vector2):
    var new_target = position + direction * tile_size
    
    # Verificar si el tile es caminable
    if is_position_walkable(new_target):
        target_position = new_target
        is_moving = true
        facing_direction = direction

func is_position_walkable(pos: Vector2) -> bool:
    var tilemap = get_tree().get_first_node_in_group("world_tilemap") as TileMap
    if not tilemap:
        return false
    
    var tile_pos = tilemap.local_to_map(pos)
    var tile_data = tilemap.get_cell_tile_data(0, tile_pos)
    
    if not tile_data:
        return false
    
    # Usar custom data layer para verificar si es caminable
    return tile_data.get_custom_data("walkable")

func handle_movement(delta):
    if not is_moving:
        return
    
    var direction = (target_position - position).normalized()
    velocity = direction * move_speed
    
    move_and_slide()
    
    # Verificar si llegamos al destino
    if position.distance_to(target_position) < 5.0:
        position = target_position
        is_moving = false
        velocity = Vector2.ZERO

func snap_to_grid(pos: Vector2) -> Vector2:
    return Vector2(
        round(pos.x / tile_size) * tile_size,
        round(pos.y / tile_size) * tile_size
    )

class_name InteractableObject extends StaticBody2D

signal interaction_triggered(object: InteractableObject)

@export var interaction_type: String = "generic"
@export var interaction_text: String = "Examinar"
@export var can_interact_from_distance: bool = false
@export var interaction_distance: float = 32.0

var player_nearby: bool = false
var interaction_prompt: Label

func _ready():
    # Configurar área de interacción
    var area = Area2D.new()
    var collision = CollisionShape2D.new()
    var shape = RectangleShape2D.new()
    
    shape.size = Vector2(interaction_distance * 2, interaction_distance * 2)
    collision.shape = shape
    area.add_child(collision)
    add_child(area)
    
    # Conectar señales
    area.body_entered.connect(_on_player_entered)
    area.body_exited.connect(_on_player_exited)
    
    # Crear prompt de interacción
    setup_interaction_prompt()

func _on_player_entered(body):
    if body.is_in_group("player"):
        player_nearby = true
        show_interaction_prompt()

func _on_player_exited(body):
    if body.is_in_group("player"):
        player_nearby = false
        hide_interaction_prompt()

func interact():
    if not player_nearby and not can_interact_from_distance:
        return
    
    match interaction_type:
        "chest":
            open_chest()
        "door":
            toggle_door()
        "npc":
            start_dialogue()
        "shop":
            open_shop()
        "save_point":
            save_game()
        _:
            generic_interaction()
    
    interaction_triggered.emit(self)

func open_chest():
    # Lógica específica para cofres
    var items = get_chest_contents()
    GameManager.add_items_to_inventory(items)
    
    # Cambiar sprite a cofre abierto
    $Sprite2D.texture = preload("res://sprites/chest_open.png")

func start_dialogue():
    var dialogue_id = get_meta("dialogue_id", "default")
    DialogueManager.start_dialogue(dialogue_id)

# ItemResource.gd
class_name ItemResource extends Resource

enum ItemType {
    CONSUMABLE,
    EQUIPMENT,
    KEY_ITEM,
    MATERIAL
}

enum EquipmentSlot {
    WEAPON,
    ARMOR,
    HELMET,
    BOOTS,
    ACCESSORY
}

@export var id: String
@export var name: String
@export var description: String
@export var icon: Texture2D
@export var item_type: ItemType
@export var max_stack: int = 1
@export var value: int = 0

# Para items de equipo
@export var equipment_slot: EquipmentSlot
@export var attack_bonus: int = 0
@export var defense_bonus: int = 0
@export var magic_bonus: int = 0

# Para consumibles
@export var heal_amount: int = 0
@export var mana_restore: int = 0
@export var status_effects: Array[String] = []

func use_item(target_character: Character) -> bool:
    match item_type:
        ItemType.CONSUMABLE:
            return use_consumable(target_character)
        ItemType.EQUIPMENT:
            return equip_item(target_character)
        _:
            return false

func use_consumable(character: Character) -> bool:
    if heal_amount > 0:
        character.heal(heal_amount)
    if mana_restore > 0:
        character.restore_mana(mana_restore)
    
    # Aplicar efectos de estado
    for effect in status_effects:
        character.apply_status_effect(effect)
    
    return true

# InventoryUI.gd
class_name InventoryUI extends Control

@export var grid_container: GridContainer
@export var item_slot_scene: PackedScene
@export var inventory_size: Vector2i = Vector2i(8, 6)

var inventory_slots: Array[InventorySlot] = []
var selected_slot: InventorySlot = null

func _ready():
    setup_inventory_grid()
    InventoryManager.inventory_changed.connect(_on_inventory_changed)

func setup_inventory_grid():
    grid_container.columns = inventory_size.x
    
    # Crear slots de inventario
    for i in range(inventory_size.x * inventory_size.y):
        var slot = item_slot_scene.instantiate() as InventorySlot
        slot.slot_index = i
        slot.slot_clicked.connect(_on_slot_clicked)
        slot.item_dropped.connect(_on_item_dropped)
        
        grid_container.add_child(slot)
        inventory_slots.append(slot)

func _on_inventory_changed():
    refresh_display()

func refresh_display():
    var items = InventoryManager.get_all_items()
    
    # Limpiar slots
    for slot in inventory_slots:
        slot.clear_item()
    
    # Colocar items en slots
    for i in range(min(items.size(), inventory_slots.size())):
        inventory_slots[i].set_item(items[i])

func _on_slot_clicked(slot: InventorySlot):
    if selected_slot == null:
        select_slot(slot)
    else:
        if selected_slot == slot:
            # Deseleccionar
            deselect_slot()
        else:
            # Intercambiar items
            swap_items(selected_slot, slot)
            deselect_slot()

func _on_item_dropped(from_slot: InventorySlot, to_slot: InventorySlot):
    swap_items(from_slot, to_slot)

class_name BattleManager extends Node

signal battle_started
signal battle_ended(victory: bool)
signal turn_changed(character: Character)

enum BattleState {
    WAITING,
    PLAYER_TURN,
    ENEMY_TURN,
    ANIMATION,
    BATTLE_END
}

var current_state: BattleState = BattleState.WAITING
var turn_queue: Array[Character] = []
var current_character_index: int = 0

@export var party_members: Array[Character] = []
@export var enemies: Array[Character] = []

func start_battle(enemy_group: Array[Character]):
    enemies = enemy_group
    setup_battle()
    current_state = BattleState.PLAYER_TURN
    battle_started.emit()

func setup_battle():
    # Combinar party y enemigos para el orden de turnos
    var all_characters = party_members + enemies
    
    # Ordenar por velocidad (speed stat)
    all_characters.sort_custom(func(a, b): return a.speed > b.speed)
    turn_queue = all_characters
    
    current_character_index = 0

func _process(_delta):
    match current_state:
        BattleState.PLAYER_TURN:
            handle_player_turn()
        BattleState.ENEMY_TURN:
            handle_enemy_turn()

func handle_player_turn():
    var current_char = get_current_character()
    if not current_char or current_char.is_dead():
        next_turn()
        return
    
    if current_char in party_members:
        # Esperar input del jugador
        BattleUI.show_action_menu(current_char)
    else:
        next_turn()

func handle_enemy_turn():
    var current_char = get_current_character()
    if not current_char or current_char.is_dead():
        next_turn()
        return
    
    if current_char in enemies:
        # IA del enemigo
        await perform_enemy_ai(current_char)
        next_turn()

func perform_action(actor: Character, action: BattleAction, target: Character):
    current_state = BattleState.ANIMATION
    
    match action.type:
        BattleAction.ActionType.ATTACK:
            await perform_attack(actor, target, action)
        BattleAction.ActionType.SKILL:
            await perform_skill(actor, target, action)
        BattleAction.ActionType.ITEM:
            await perform_item_use(actor, target, action)
    
    check_battle_end()
    
    if current_state != BattleState.BATTLE_END:
        next_turn()

func check_battle_end():
    var party_alive = party_members.any(func(char): return not char.is_dead())
    var enemies_alive = enemies.any(func(char): return not char.is_dead())
    
    if not party_alive:
        end_battle(false)  # Derrota
    elif not enemies_alive:
        end_battle(true)   # Victoria

func end_battle(victory: bool):
    current_state = BattleState.BATTLE_END
    
    if victory:
        calculate_rewards()
    
    battle_ended.emit(victory)

class_name WorldManager extends Node2D

@export var chunk_size: int = 64  # Tiles por chunk
@export var load_radius: int = 2  # Chunks alrededor del jugador
@export var world_data: WorldData

var loaded_chunks: Dictionary = {}
var player_chunk_pos: Vector2i

@onready var player: RPGPlayer = get_tree().get_first_node_in_group("player")

func _ready():
    # Cargar chunk inicial
    update_loaded_chunks()

func _process(_delta):
    var current_chunk = world_pos_to_chunk(player.global_position)
    
    if current_chunk != player_chunk_pos:
        player_chunk_pos = current_chunk
        update_loaded_chunks()

func update_loaded_chunks():
    var chunks_to_load: Array[Vector2i] = []
    var chunks_to_unload: Array[Vector2i] = []
    
    # Determinar chunks que deben estar cargados
    for x in range(-load_radius, load_radius + 1):
        for y in range(-load_radius, load_radius + 1):
            var chunk_pos = player_chunk_pos + Vector2i(x, y)
            chunks_to_load.append(chunk_pos)
    
    # Descargar chunks lejanos
    for chunk_pos in loaded_chunks.keys():
        if chunk_pos not in chunks_to_load:
            chunks_to_unload.append(chunk_pos)
    
    # Ejecutar carga/descarga
    for chunk_pos in chunks_to_unload:
        unload_chunk(chunk_pos)
    
    for chunk_pos in chunks_to_load:
        if chunk_pos not in loaded_chunks:
            load_chunk(chunk_pos)

func load_chunk(chunk_pos: Vector2i):
    var chunk_data = world_data.get_chunk_data(chunk_pos)
    if not chunk_data:
        return
    
    var chunk_node = ChunkNode.new()
    chunk_node.setup_from_data(chunk_data)
    chunk_node.position = chunk_to_world_pos(chunk_pos)
    
    add_child(chunk_node)
    loaded_chunks[chunk_pos] = chunk_node

func unload_chunk(chunk_pos: Vector2i):
    if chunk_pos in loaded_chunks:
        var chunk_node = loaded_chunks[chunk_pos]
        chunk_node.queue_free()
        loaded_chunks.erase(chunk_pos)

class_name AudioManager extends Node

@export var music_bus: String = "Music"
@export var sfx_bus: String = "SFX"
@export var ambient_bus: String = "Ambient"

var current_bgm: AudioStream
var music_player: AudioStreamPlayer
var ambient_player: AudioStreamPlayer
var footstep_sounds: Dictionary = {}

func _ready():
    setup_audio_players()
    load_footstep_sounds()

func play_bgm(track: AudioStream, fade_time: float = 1.0):
    if current_bgm == track:
        return
    
    current_bgm = track
    
    # Fade out actual, fade in nuevo
    var tween = create_tween()
    tween.tween_method(set_music_volume, 1.0, 0.0, fade_time * 0.5)
    tween.tween_callback(func(): music_player.stream = track; music_player.play())
    tween.tween_method(set_music_volume, 0.0, 1.0, fade_time * 0.5)

func play_footstep_sound(material: String):
    if material in footstep_sounds:
        var sound = footstep_sounds[material]
        play_sfx(sound, randf_range(0.8, 1.2))  # Variación de pitch

func play_sfx(sound: AudioStream, pitch: float = 1.0, volume: float = 0.0):
    var player = AudioStreamPlayer.new()
    player.stream = sound
    player.pitch_scale = pitch
    player.volume_db = volume
    player.bus = sfx_bus
    
    add_child(player)
    player.play()
    
    # Auto-eliminar cuando termine
    player.finished.connect(func(): player.queue_free())

✅ Mejores Prácticas

• Usa TileMap layers en lugar de múltiples TileMaps
• Implementa object pooling para proyectiles y efectos
• Carga lazy de assets para reducir memoria inicial
• Usa CanvasLayer para UI que no debe moverse con la cámara
• Optimiza spritesheets usando atlas de texturas

❌ Errores Comunes

• No usar culling en mundos grandes
• Demasiados AudioStreamPlayer simultáneos
• Animaciones pesadas en muchos objetos
• Falta de object pooling para partículas
• Saves frecuentes que bloquean gameplay