Navmesh y colisión

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

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

• Ajustar los objetos generados sobre el terreno alcanzable

• Restringir a los jugadores/NPCs a regiones transitables

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

Componentes (resumen rápido)

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

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

• Colliders: Box_Collider, Circle_Collider, Edge_Collider, Polygon_Collider

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

Referencia de la API de Navmesh

Navmesh :: class : 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 :: method(
        to_point: v2,
        result: ref v2,
        triangle_hint: ref s64
    ) -> bool;

    rebuild_immediately :: method() -> bool;
    mark_for_rebuild    :: method();
}

Configuración del editor (construir una navmesh)

1. Crea una entidad y añade un Navmesh 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

   • Activa Invertir interior/exterior para convertirlo en un agujero/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. Invértelo para "abrir agujeros" (islas no transitables) en una navmesh existente.

Colliders y bucles de navmesh

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

Advertencias importantes:

• Un Navmesh no no se reconstruye 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 manualmente la navmesh (ver más abajo).

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

Generación sobre la navmesh (ajustar al terreno alcanzable)

Usa try_find_closest_point_on_navmesh para proyectar una posición deseada al 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 zona (generadores de botín, apariciones por oleadas, etc.). Puede acelerar significativamente la proyección.

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

Usa una de estas opciones:

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

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

navmesh->mark_for_rebuild();

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

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

Colisión (soporte actual de CSL)

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

Comportamiento de colisión pseudonatural (triggers, objetos recogibles, "golpes")

Hasta que los callbacks de colisión estén expuestos en CSL, el enfoque estándar es:

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

• Hacer comprobaciones simples de distancia (in_range) para decidir "dentro", "recogido", "golpeado", 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;
}

Prefiere el lado del servidor para las consecuencias jugables (daño, recogidas, puntuación). Usa comprobaciones solo locales para retroalimentación visual.

Volumen de activación (entrar / permanecer / salir)

Para simular una zona de activación, mantén una lista de quién estaba dentro el último frame 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 {
    radius: float @ao_serialize;
    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) {
                    // on_enter
                    Notifier.notify(p, "¡Entraste en la zona!");
                }
                else {
                    // on_stay
                }
            }
        }

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

        last_inside = current_inside;
    }
}

Esto es lógica de colisión de "mejor esfuerzo". Si algo se teletransporta o desaparece entre actualizaciones, puede que no obtengas una "salida" limpia a menos que gestiones 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 de movimiento rápido (subpasos simples)

Si te mueves muy rápido (dash, proyectil), puedes pasar por alto objetivos estrechos cuando solo compruebas la posición final. Una solución sencilla es usar subpasos: muestrear unos pocos puntos entre la posición anterior y la nueva y ejecutar 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 el golpe una vez, iniciar enfriamiento, etc.
            }
        }
    }
}