Navmesh y colisión

Las navmeshes definen el espacio caminable para la búsqueda de rutas y las restricciones de movimiento.

Las mallas de navegación definen las áreas transitables en tu mundo. Úsalas para:

• Ajustar los objetos generados al terreno alcanzable

• Restringir a los jugadores/NPCs a regiones transitables

Los colliders también se pueden usar para recortar mallas de navegación en el editor.

Componentes (resumen rápido)

• Malla de navegación: la malla de navegación generada que consultas y reconstruyes

• Navmesh_Loop: bucles poligonales que definen los límites transitables (y los huecos)

• Colliders: Box_Collider, Circle_Collider, Edge_Collider, Polygon_Collider

Para movimiento/búsqueda de ruta (Movement_Agent) consulta Agentes de movimiento/NPCs.

Referencia de la API de Navmesh

Navmesh :: class : Component {
    // Proyecta un punto sobre esta malla de navegación.
    // triangle_hint es una pista de aceleración que puedes reutilizar para consultas cercanas.
    try_find_closest_point_on_navmesh :: method(
        to_point: v2,
        result: ref v2,
        triangle_hint: ref s64
    ) -> bool;

    // Lanza un rayo a través de la malla de navegación. Devuelve el punto final y si la consulta tuvo éxito.
    try_raycast :: method(position: v2, direction: v2) -> (v2, bool);

    // Poner en cola una reconstrucción para la actualización normal de la malla de navegación.
    mark_for_rebuild :: method();

    // Reconstruye ahora cuando una consulta en el mismo frame necesita la nueva geometría.
    rebuild_immediately :: method() -> bool;

    // Incluye solo los colliders de esta entidad y sus descendientes.
    child_colliders_only: bool;

    // Detecta cambios de entrada y reconstruye automáticamente.
    enable_automatic_rebuilds: bool;
}

Configuración en el editor (crear una malla de navegación)

1. Crea una entidad y añade un Malla de navegación componente.

2. Crea entidades hijas con Navmesh_Loop componentes para definir polígonos transitables.

3. Para cada Navmesh_Loop:

   • Añade puntos para definir la forma del bucle

   • Ordena los puntos del contorno exterior en sentido antihorario

   • Para invertir un bucle existente, haz clic derecho en el Navmesh_Loop encabezado del componente y selecciona Invertir el orden de giro

   • Alternar Invertir interior/exterior para crear un agujero/obstáculo en lugar de espacio transitable

4. Usa las opciones de depuración de la malla de navegación en el inspector para visualizar los triángulos.

De forma predeterminada, un Navmesh_Loop define un área transitable. Inviértelo para "perforar agujeros" (islas no transitables) en una malla de navegación existente.

El orden de giro del bucle determina qué lado de cada arista se trata como el interior. El giro antihorario es el orden normal para un contorno exterior transitable. El giro horario invierte ese resultado. Si un bucle se creó al revés, haz clic derecho en el encabezado de su componente y selecciona Invertir el orden de giro. Usa Invertir interior/exterior deliberadamente para agujeros en lugar de depender de un orden de puntos invertido por accidente.

Colliders y bucles de malla de navegación

Los colliders también pueden aportar bucles mediante opciones del inspector del collider (por ejemplo "Make Navmesh Loop" / "Flip Navmesh Loop").

Advertencias importantes:

• Con Habilitar reconstrucciones automáticas, las mallas de navegación detectan cambios en la entrada de bucles, colliders, tilemaps y mallas de navegación hijas y ponen en cola una reconstrucción.

• Activa Solo colisionadores hijos para ignorar colisionadores no relacionados en otras partes de la escena.

• Con las reconstrucciones automáticas desactivadas, llama a mark_for_rebuild() después de cambiar una entrada.

• Llama a rebuild_immediately() solo antes de una consulta en el mismo frame que requiera la geometría modificada.

Generación sobre la malla de navegación (ajustar al terreno alcanzable)

Usa try_find_closest_point_on_navmesh para proyectar una posición deseada sobre el punto válido más cercano de una malla de navegación:

spawn_on_navmesh :: proc(navmesh: Navmesh, desired_position: v2) -> Entity {
    spawn_pos: v2;
    triangle_hint: s64; // 0 = aún no establecido

    if navmesh.try_find_closest_point_on_navmesh(desired_position, ref spawn_pos, ref triangle_hint) {
        e := Scene.create_entity();
        e.set_local_position(spawn_pos);
        return e;
    }

    return null;
}

Reutiliza triangle_hint para consultas repetidas en la misma zona (generadores de botín, oleadas, etc.). Puede acelerar significativamente la proyección.

Reconstrucción inmediata de mallas de navegación

La mayoría de los cambios de geometría se detectan automáticamente. Usa esto solo cuando necesites forzar el momento:

• rebuild_immediately(): reconstruye ahora (úsalo solo si debes consultar la malla actualizada en el mismo frame)

ok := navmesh.rebuild_immediately();
if !ok {
    log_info("La reconstrucción de la malla de navegación falló", {});
}

Las mallas de navegación padre se actualizan después de las hijas, así que las mallas padre ensambladas incorporan automáticamente los cambios de entrada de las mallas hijas.

Lanzamiento de rayos a través de una malla de navegación

try_raycast sigue la dirección hasta el límite de la malla de navegación. El segundo resultado indica si la consulta tuvo éxito.

endpoint, ok := navmesh.try_raycast(start, direction);
if ok {
    // el endpoint está en el límite de la malla de navegación.
}

Disparadores de colisionador

Un colisionador con is_trigger == true puede informar cuando otro colisionador entra, permanece dentro o sale. Los callbacks de disparador funcionan con colisionadores estáticos y en movimiento; no se requiere un Movement_Agent no se requiere una

Usa los colisionadores con moderación. Añádelos solo a superficies críticas para la jugabilidad: límites del mapa, plataformas sobre las que el jugador debe aterrizar, obstáculos clave y volúmenes de disparador deliberados. No añadas colisionadores a entidades decorativas (árboles, arbustos, props de fondo, etc.). La mayoría de las entidades en una escena no deberían tener colisionador.

Trigger_Listener :: class : Component {
    ao_start :: method() {
        trigger_collider := entity.get_component(Circle_Collider);
        trigger_collider.is_trigger = true;

        trigger_collider.on_trigger_start = proc(self: Collider, other: Collider) {
            log("INICIO DE SOLAPAMIENTO: %", {other.entity.get_name()});
        };

        trigger_collider.on_trigger_stay = proc(self: Collider, other: Collider) {
            log("SOLAPAMIENTO CONTINÚO: %", {other.entity.get_name()});
        };

        trigger_collider.on_trigger_end = proc(self: Collider, other: Collider) {
            log("FIN DEL SOLAPAMIENTO: %", {other.entity.get_name()});
        };
    }
}

Comprobaciones de proximidad y lógica de impacto personalizada

Para zonas de disparador que usan consultas de rango en lugar de callbacks de colisionador, objetos recogibles, comprobaciones de proyectiles u otra lógica personalizada de impacto, usa:

• Scene.get_all_components_in_range / Scene.get_closest_component_in_range

• Comprobaciones simples de distancia (in_range) para decidir "dentro", "recogido", "impactado", etc.

Ayudantes de consulta de escena

Scene :: struct {
    get_all_components_in_range :: proc(position: v2, range: float, results: ref [..]$T);
    get_closest_component_in_range :: proc(position: v2, range: float, $T: typeid) -> (T, bool);
}

Ejecuta el daño, los objetos recogibles y la puntuación en la ruta normal compartida de juego. No protejas la jugabilidad predicha con Game.is_server().

Volumen de disparador (entrar / permanecer / salir)

Para simular una zona de disparador, mantén una lista de quién estaba dentro en el frame anterior y compárala con los resultados del frame actual.

contains_id :: proc(list: []u64, id: u64) -> bool {
    for x: list if x == id return true;
    return false;
}

Trigger_Zone :: class : Component {
    @ao_serialize radius: float;
    last_inside: [..]u64;

    ao_update :: method(dt: float) {
        center := entity.world_position;

        players: [..]Player;
        Scene.get_all_components_in_range(center, radius, ref players);

        current_inside: [..]u64;

        for p: players {
            if in_range(p.entity.world_position, center, radius) {
                current_inside.append(p.entity.id);

                if !contains_id(last_inside, p.entity.id) {
                    // al entrar
                    Notifier.notify(p, "¡Has entrado en la zona!");
                }
                else {
                    // al permanecer
                }
            }
        }

        for id: last_inside {
            if !contains_id(current_inside, id) {
                // al salir (quizá quieras tu propia búsqueda id.player)
            }
        }

        last_inside.clear();
        for id: current_inside {
            last_inside.append(id);
        }
    }
}

Este patrón manual de disparador sigue siendo útil cuando no quieres añadir un volumen de disparador con colisionador. Si algo se teletransporta o desaparece entre actualizaciones, puede que no obtengas una "salida" limpia a menos que gestiones la limpieza.

Objetos recogibles (el más cercano en rango)

try_pickup_near_player :: proc(player: Player) {
    pos := player.entity.world_position;

    pickup, ok := Scene.get_closest_component_in_range(pos, 1.5, Pickup);
    if ok && pickup != null {
        if in_range(pickup.entity.world_position, pos, 1.5) {
            pickup.claim(player); // tu propia lógica (dar + destruir)
        }
    }
}

"Impactos" de movimiento rápido (submuestreo simple)

Si te mueves rápido (dash, proyectil), puedes pasar por alto objetivos estrechos cuando solo compruebas la posición final. Una solución sencilla es el submuestreo por pasos: toma unas cuantas muestras entre la posición anterior y la nueva y ejecuta las mismas consultas de rango.

hit_check_move :: proc(last_pos: v2, new_pos: v2) {
    steps := 4;
    for i := 1; i <= steps; i += 1 {
        t := (i.(float)) / (steps.(float));
        p := lerp(last_pos, new_pos, t);

        enemies: [..]Enemy;
        Scene.get_all_components_in_range(p, 1.0, ref enemies);
        for e: enemies {
            if in_range(e.entity.world_position, p, 1.0) {
                // aplica el impacto una vez, inicia el tiempo de reutilización, etc.
            }
        }
    }
}