Navmesh y colisión

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

Las navmeshes definen la áreas transitables en tu mundo. Úsalas para:

• Ajustar los objetos generados al suelo alcanzable

• Restringir a jugadores/NPCs a regiones transitables

Los colliders también pueden usarse para recortar navmeshes en el editor.

Componentes (visión rápida)

• Navmesh: la malla de navegación cocida que consultas y reconstruyes

• Navmesh_Loop: bucles de polígonos que definen límites transitables (y huecos)

• Colliders: Box_Collider, Circle_Collider, Edge_Collider, Polygon_Collider

Para movimiento/búsqueda de rutas (Movement_Agent) ver Agentes de movimiento/NPCs.

Referencia de la API de Navmesh

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

    rebuild_immediately :: método() -> bool;
    mark_for_rebuild    :: método();
}

Configuración del editor (construyendo una navmesh)

1. Crea una entidad y añade un Navmesh componente.

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

3. Para cada Navmesh_Loop:

   • Añade puntos para definir la forma del bucle

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

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

Por defecto, un Navmesh_Loop define un área transitable. Inviértelo para "hacer agujeros" (islas intransitables) en una navmesh existente.

Colliders y bucles de navmesh

Los colliders también pueden aportar bucles mediante las opciones del inspector de collider (por ejemplo "Hacer Navmesh Loop" / "Invertir Navmesh Loop").

Advertencias importantes:

• Un Navmesh no hace reconstrucción automáticamente solo porque un collider cambie en tiempo de ejecución.

• Si modificas la geometría del collider y dependes de bucles impulsados por colliders, reconstruye la navmesh manualmente (ver más abajo).

• Si quieres una navmesh que ignore completamente los colliders, usa la opción del inspector de navmesh para ignorar colliders.

Generar sobre la navmesh (ajustar al suelo alcanzable)

Usa try_find_closest_point_on_navmesh para proyectar una posición deseada sobre el punto válido más cercano en una navmesh:

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 área (generadores de botín, generación por oleadas, etc.). Puede acelerar significativamente la proyección.

Reconstrucción de navmeshes (cuando la geometría cambia)

Usa una de:

• mark_for_rebuild(): difiere la reconstrucción al inicio del siguiente frame (mejor para agrupar)

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

navmesh->mark_for_rebuild();

ok := navmesh->rebuild_immediately();
if !ok {
    log_info("Fallo la reconstrucción de la navmesh", {});
}

Si tienes una navmesh padre que "coser" varias navmeshes hijas, cambiar una navmesh hija no reconstruye automáticamente la padre. Llama mark_for_rebuild() / rebuild_immediately() en la padre después de las ediciones.

Colisión (soporte actual de CSL)

Los colliders existen como componentes (Box_Collider, Circle_Collider, Edge_Collider, Polygon_Collider), pero las callbacks de scripting de entrada/salida de colisión están aún no implementadas en CSL.

Comportamiento de colisión pseudo (triggers, pickups, "golpes")

Hasta que las callbacks de colisión se expongan en CSL, el enfoque estándar es:

• Consultar componentes cercanos con Scene.get_all_components_in_range / Scene.get_closest_component_in_range

• Realizar comprobaciones simples de distancia (in_range) para decidir "dentro", "recogido", "golpeado", etc.

Ayudantes de consulta de Scene

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;
}

Prefiere el lado del servidor para consecuencias de jugabilidad (daño, recogidas, puntuación). Usa comprobaciones locales solo para retroalimentación cosmética.

Volumen trigger (entrada / permanencia / salida)

Para simular una zona trigger, mantiene 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 :: clase : Component {
    radius: float @ao_serialize;
    last_inside: [..]u64;

    ao_update :: método(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) {
                    // on_enter
                    Notifier.notify(p, "¡Entró en la zona!");
                }
                else {
                    // on_stay
                }
            }
        }

        for id: last_inside {
            if !contains_id(current_inside, id) {
                // on_exit (puede que quieras tu propia búsqueda id->player)
            }
        }

        last_inside = current_inside;
    }
}

Esta es una lógica de colisión de "mejor esfuerzo". Si algo es teletransportado/desaparecido entre actualizaciones, puede que no obtengas una "salida" limpia a menos que manejes la limpieza.

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 (otorgar + destruir)
        }
    }
}

"Golpes" por movimiento rápido (subpasos simples)

Si te mueves rápidamente (embestida, proyectil), puedes fallar objetivos estrechos si solo compruebas la posición final. Una solución simple es subpasos: muestrea algunos puntos 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) {
                // aplicar impacto una vez, iniciar enfriamiento, etc.
            }
        }
    }
}