Habilidades

Las habilidades son la forma estándar de implementar las acciones del jugador con:

• Una interfaz de botones coherente que funciona bien en móvil y PC.

• Tiempos de reutilización

• Apuntamiento opcional (toque/arrastre en móvil, apuntar con ratón en PC)

Las habilidades son por jugador. Cuando un jugador se une, All Out crea una instancia de cada tipo de habilidad y la almacena en player.abilities.

Inicio rápido (dibujar botones de habilidad)

Dibuja botones de habilidad en Player.ao_late_update, dentro de is_local_or_server():

Player :: class : Player_Base {
    ao_late_update :: method(dt: float) {
        if this->is_local_or_server() {
            draw_ability_button(this, Shoot_Ability, 0);  // botón primario grande
            draw_ability_button(this, Dodge_Roll, 1);     // botón pequeño
        }
    }
}

Los índices de los botones se asignan a posiciones fijas en la pantalla. El índice 0 es el botón primario grande; los índices 1-5 son botones más pequeños alrededor de él.

Referencia de la API de habilidades

Ability_Base :: clase {
    player: Player;

    name: string;
    icon: Texture_Asset;

    current_cooldown: float;
    type: typeid;
    is_aimed_ability: bool;
    mouse_position_on_press: v2;

    keybind_override: Keybind;
    disable_keybind: bool;
    draw_but_dont_use_keybind: bool;

    #interface on_update      :: proc(ability: Ability_Base, params: ref Ability_Update_Params);
    #interface can_use        :: proc(ability: Ability_Base) -> bool;
    #interface on_draw_button :: proc(ability: Ability_Base, rect: Rect);
}

Ability_Update_Params :: struct : Interact_Result {
    can_use: bool;        // cooldown + can_use + Player.ao_can_use_ability (si está presente)
    drag_offset: v2;      // 0..1
    drag_direction: v2;   // dirección unitaria
}

draw_ability_button :: proc(player: Player, $T: typeid, index: int);

Crear una habilidad (clic básico)

Dash_Ability :: clase : Ability_Base {
    on_init :: método() {
        name = "Dash";
        icon = get_asset(Texture_Asset, "icons/dash.png");
    }

    can_use :: método() -> bool {
        // Puerta adicional opcional (además del tiempo de reutilización)
        return true;
    }

    on_update :: método(params: ref Ability_Update_Params) {
        if params.clicked && params.can_use {
            // Realiza la jugabilidad aquí (autorizado por el servidor si cambia el estado)
            // ...

            // IMPORTANTE: establece el tiempo de reutilización cuando lo actives
            current_cooldown = 1.5;
        }
    }
}

Habilidades de mantenimiento (activas mientras se mantienen)

Para habilidades que están activas mientras se mantienen (esprint, escudo, rayo), usa Ability_Utilities.update_holding_ability para que funcione tanto en PC como en móvil.

keybind_sprint: Keybind;

ao_before_scene_load :: proc() {
    keybind_sprint = Keybinds.register("Sprint", .SHIFT);
}

Sprint_Ability :: clase : Ability_Base {
    on_init :: método() {
        name = "Sprint";
        draw_but_dont_use_keybind = true;
        keybind_override = keybind_sprint;
    }

    on_update :: método(params: ref Ability_Update_Params) {
        holding := Ability_Utilities.update_holding_ability(player, ref params, keybind_sprint);
        player.is_sprinting = holding.active;
    }
}

Habilidades con apuntado (arrastra para apuntar en móvil)

Si quieres un comportamiento de “apuntar siempre” (apuntar con el ratón + clic para disparar en PC, presionar-arrastrar-soltar en móvil), usa Ability_Utilities.full_update_aimed_ability:

Shoot_Ability :: clase : Ability_Base {
    on_init :: método() {
        name = "Shoot";
        is_aimed_ability = true;
        disable_keybind = true;
    }

    on_update :: método(params: ref Ability_Update_Params) {
        activation := Ability_Utilities.full_update_aimed_ability(player, ref params);

        if activation.activate && params.can_use {
            // activation.direction es un vector unitario
            // shoot_projectile(player.entity.world_position, activation.direction);
            current_cooldown = 0.5;
        }
    }
}

Si quieres “clic para entrar en modo de apuntado” (PC alterna modo de apuntado; clic derecho cancela), usa Ability_Utilities.full_update_targeted_aimed_ability:

Roll_Ability :: clase : Ability_Base {
    on_init :: método() {
        name = "Roll";
        is_aimed_ability = true;
    }

    on_update :: método(params: ref Ability_Update_Params) {
        activation := Ability_Utilities.full_update_targeted_aimed_ability(player, this, ref params);
        if activation.activate && params.can_use {
            current_cooldown = 1.25;
        }
    }
}

Restricciones de habilidades a nivel de juego (opcional)

Implementa ao_can_use_ability en tu Player clase para aplicar reglas globales (los jugadores muertos no pueden usar habilidades, deshabilitado durante escenas, etc.).

Player :: class : Player_Base {
    ao_can_use_ability :: método(ability: Ability_Base) -> bool {
        if health.is_dead return false;
        return true;
    }
}

Mejores prácticas

• Siempre dibuja botones en ao_late_update y protégelos con is_local_or_server()

• Establece current_cooldown cuando lo actives (de lo contrario se puede spammear)

• Usa Ability_Utilities ayudantes para mantener/apuntar para que móvil + PC se comporten de forma coherente

• Pon las reglas globales en Player.ao_can_use_ability, no duplicadas por cada habilidad