Efectos

Los efectos toman temporalmente el control de una entidad para comportamientos complejos como embestidas, ataques, animaciones de comer, escenas cinemáticas o secuencias de muerte/respawn.

Los efectos pueden usarse en jugadores, NPCs o cualquier entidad. Son especialmente útiles cuando quieres:

• Movimiento que controlas en código (embestida/retroceso/rodar)

• “Bloquear” la entrada del jugador por una secuencia corta (comer, revivir, escena cinemática)

• Una ventana temporal de estado (invencibilidad, lentitud, aturdimiento)

• Interfaz de usuario vinculada a un estado temporal (cuenta regresiva de respawn)

Activos vs pasivos

All Out admite dos tipos de efectos:

• Efectos activos: uno a la vez por entidad. Establecer un nuevo efecto activo interrumpe el efecto activo actual.

• Efectos pasivos: se pueden adjuntar múltiples a la vez (mejoras/penalizaciones/aplicaciones de estado apilables).

Un efecto activo también se inserta en la lista de efectos de la entidad, por lo que aparece en effect_iterator igual que los efectos pasivos.

Inicio rápido (un efecto temporal simple)

Crea una clase que herede de Effect_Base, luego adjúntalo a una entidad.

Apple_Pop_Effect :: class : Effect_Base {
    sprite: Sprite_Renderer;
    start_scale: v2;
    start_pos: v2;

    effect_start :: method() {
        sprite = entity->get_component(Sprite_Renderer);
        start_scale = entity.local_scale;
        start_pos = entity.local_position;
        set_duration(0.4); // se elimina automáticamente después de 0.4s
    }

    effect_update :: method(dt: float) {
        t := get_elapsed_time() / 0.4;

        // Aumenta la escala y luego encoge hasta desaparecer
        scale_curve: float;
        if t < 0.3 {
            scale_curve = lerp(1.0, 1.3, Ease.out_back(t / 0.3));
        } else {
            scale_curve = lerp(1.3, 0.0, Ease.in_back((t - 0.3) / 0.7));
        }

        entity->set_local_scale(start_scale * scale_curve);

        // Flota hacia arriba ligeramente
        rise := Ease.out_quad(t) * 0.5;
        entity->set_local_position({start_pos.x, start_pos.y + rise});

        // Desvanece cerca del final
        if sprite != null {
            alpha := 1.0 - Ease.in_quad(max(0.0, (t - 0.5) / 0.5));
            sprite.color.w = alpha;
        }
    }

    effect_end :: method(interrupt: bool) {
        // Limpia cuando termina (o se interrumpe)
        entity->destroy();
    }
}

Adjúntalo como un efecto activo:

effect := new(Apple_Pop_Effect);
entity->set_active_effect(effect);

Ciclo de vida del efecto

Los efectos se basan en callbacks. Implementa solo lo que necesites:

• effect_start(): llamado una vez cuando se adjunta el efecto

• effect_update(dt): llamado cada fotograma

• effect_late_update(dt): llamado cada fotograma después de effect_update

• effect_end(interrupt): llamado cuando se elimina el efecto

Efectos activos (control exclusivo)

Usa set_active_effect para efectos que deben ser mutuamente excluyentes (embestida, preparación de ataque, secuencia de muerte).

dash := new(Dash_Effect);
dash.direction = {1, 0};
player.entity->set_active_effect(dash);

Si la entidad ya tiene un efecto activo, se finaliza con interrupt = true.

Efectos pasivos (mejoras/aplicaciones de estado apilables)

Usa add_passive_effect para efectos que pueden apilarse (lentitud, veneno, escudo, ventana de invencibilidad).

slow := new(Slow_Effect);
slow.speed_multiplier = 0.5;
slow->set_duration(4.0);
enemy.entity->add_passive_effect(slow);

Referencia de la API

Effect_Base

Effect_Base :: class {
    entity: Entity;
    player: Player; // null si este efecto no se añadió a un jugador!

    player_specific: struct {
        freeze_player: bool;
        disable_movement_inputs: bool;
    };

    // Callbacks opcionales
    #interface effect_start       :: proc(c: Effect_Base);
    #interface effect_update      :: proc(c: Effect_Base, dt: float);
    #interface effect_late_update :: proc(c: Effect_Base, dt: float);
    #interface effect_end         :: proc(c: Effect_Base, interrupt: bool);

    // Solo lectura
    start_time: float;
    next_effect: Effect_Base;
    prev_effect: Effect_Base;

    get_elapsed_time :: method() -> float;
    set_duration     :: method(duration: float);
    remove_effect    :: method(interrupt: bool);
}

Aplicar / eliminar efectos

set_active_effect  :: proc(entity: Entity, new_active_effect: $T);
add_passive_effect :: proc(entity: Entity, new_effect: $T);

remove_all_effects :: proc(entity: Entity);
remove_effect      :: proc(entity: Entity, type: typeid, interrupt: bool) -> bool;

Comprobar / iterar efectos

get_effect :: proc(entity: Entity, $T: typeid, mode := Try_Get_Effect_Mode.EXACT_MATCH) -> T, bool;
has_effect :: proc(entity: Entity, $T: typeid, mode := Try_Get_Effect_Mode.EXACT_MATCH) -> bool;

effect_iterator :: proc(entity: Entity) -> Effect_Iterator;

Después de llamar remove_effect(...), el objeto efecto se libera. Devuelve inmediatamente y no toques this después de la eliminación.

freeze_player vs disable_movement_inputs

• player_specific.freeze_player = true: bloquea completamente la posición del jugador.

• player_specific.disable_movement_inputs = true: ignora la entrada, pero tu efecto aún puede mover al jugador (embestida/rodar).

Ambos solo se aplican cuando player != null (es decir, el efecto está en una entidad que tiene un Player componente).

Ejemplos de efectos

Embestida / rodar (efecto activo)

Roll_Effect :: class : Effect_Base {
    direction: v2;
    original_friction: float;

    effect_start :: method() {
        player_specific.disable_movement_inputs = true;
        original_friction = player.agent.friction;
        player.agent.friction = 0;
        player->player_set_trigger("dodge_roll");
        player->set_facing_right(direction.x > 0);
        set_duration(0.5);
    }

    effect_update :: method(dt: float) {
        player.agent.velocity = direction * 8;
    }

    effect_end :: method(interrupt: bool) {
        player.agent.friction = original_friction;
    }
}

Ventana de invencibilidad (efecto pasivo)

Usa un efecto pasivo para representar el estado invencible y compruébalo donde sea que apliques daño.

Invincible_Effect :: class : Effect_Base {
}

give_invincibility :: proc(player: Player, seconds: float) {
    e := new(Invincible_Effect);
    e->set_duration(seconds);
    player.entity->add_passive_effect(e);
}

// Ejemplo de puerta de daño:
take_damage :: proc(player: Player, amount: s64) {
    if player.entity->has_effect(Invincible_Effect) {
        return;
    }
    player.health->take_damage(amount);
}

2x de tamaño por unos segundos (efecto pasivo)

Grow_Effect :: class : Effect_Base {
    scale_multiplier: float;
    start_scale: v2;

    effect_start :: method() {
        start_scale = entity.local_scale;
        entity->set_local_scale(start_scale * scale_multiplier);
    }

    effect_end :: method(interrupt: bool) {
        entity->set_local_scale(start_scale);
    }
}

apply_grow :: proc(entity: Entity) {
    e := new(Grow_Effect);
    e.scale_multiplier = 2.0;
    e->set_duration(3.0);
    entity->add_passive_effect(e);
}

Secuencia de muerte / respawn (efecto activo con IU local)

Death_Effect :: class : Effect_Base {
    effect_start :: method() {
        player_specific.freeze_player = true;
        player->add_name_invisibility_reason("death");
        player->player_set_trigger("death");
    }

    effect_update :: method(dt: float) {
        time_until_respawn := 5.0 - get_elapsed_time();

        if player->is_local() {
            ts := UI.default_text_settings();
            ts.size = 64;
            rect := UI.get_screen_rect()->bottom_center_rect()->offset(0, 150);
            UI.text(rect, ts, "Respawning in %s", {time_until_respawn.(int) + 1});
        }

        if time_until_respawn <= 0 {
            remove_effect(false);
            return;
        }
    }

    effect_end :: method(interrupt: bool) {
        player->remove_name_invisibility_reason("death");
        respawn_player(player);
        player.health->reset();
        player->player_set_trigger("RESET");
    }
}

Bloqueo de escena cinemática (efecto activo)

Cutscene_Effect :: class : Effect_Base {
    effect_start :: method() {
        player_specific.freeze_player = true;
        set_duration(2.0);
    }

    effect_late_update :: method(dt: float) {
        if player != null && player->is_local() {
            Notifier.notify("Escena cinematográfica...");
        }
    }
}

Mejores prácticas

• Usa set_active_effect cuando el efecto “posee” la entidad por una secuencia corta (embestida/ataque/muerte/escena cinematográfica).

• Usa add_passive_effect para estado apilable (mejoras/penalizaciones/estados).

• Usa set_duration(...) para efectos temporizados en lugar de temporizadores manuales.

• Siempre restaura cualquier estado modificado en effect_end (fricción, escala, disparadores de animación, etc.).

• Mantén puramente cosméticos IU/efectos locales (envuélvelos en player->is_local()), y mantén el estado del juego autoritativo en el servidor.