wowlab_types/types/sim/encounter/

spatial.rs

// #t(file: rust_alloc_in_loop) validation allocates precise indexed field paths only during construction, never on combat hot paths
// #t(file: rust_unchecked_indexing) validated rings and actor positions are indexed only after structural bounds checks
// #t(file: rust_magic_numbers) numeric literals are planar geometry formulas
// #t(file: rust_missing_error_context) lower-level position errors are replaced with the owning encounter field path

use super::{
    super::FastSet,
    EncounterValidationError, GEOMETRY_EPSILON, SpatialTransform, StaticObstacle,
    StaticSpatialScene,
    geometry::{
        point_in_or_on_ring, point_on_segment, point_strictly_in_ring, rings_intersect,
        validate_ring,
    },
    invalid,
    validation::validate_slug,
};

impl StaticSpatialScene {
    /// Validate layer ordering and all obstacle geometry.
    ///
    /// # Errors
    ///
    /// Returns the first invalid layer or obstacle field encountered.
    pub fn validate(&self) -> Result<(), EncounterValidationError> {
        if self.layers.is_empty() {
            return Err(invalid(
                "spatial_scene.layers",
                "scene must contain at least one layer",
            ));
        }

        let mut slugs = FastSet::default();

        for (index, layer) in self.layers.iter().enumerate() {
            validate_layer(layer, index, &mut slugs)?;
        }

        for (index, obstacle) in self.obstacles.iter().enumerate() {
            let path = format!("spatial_scene.obstacles[{index}]");
            let layer = validate_obstacle(obstacle, &path)?;

            if usize::from(layer.0) >= self.layers.len() {
                return Err(invalid(&path, format!("missing spatial layer {}", layer.0)));
            }
        }

        Ok(())
    }
}

fn validate_layer<'a>(
    layer: &'a super::SpatialLayerDefinition,
    index: usize,
    slugs: &mut FastSet<&'a str>,
) -> Result<(), EncounterValidationError> {
    if usize::from(layer.id.0) != index {
        return Err(invalid(
            format!("spatial_scene.layers[{index}].id"),
            "layer ids must be dense and ordered",
        ));
    }

    validate_slug(&layer.slug, &format!("spatial_scene.layers[{index}].slug"))?;

    if !slugs.insert(layer.slug.as_str()) {
        return Err(invalid(
            "spatial_scene.layers",
            format!("duplicate layer slug {}", layer.slug),
        ));
    }

    Ok(())
}

#[expect(
    clippy::map_err_ignore,
    reason = "coordinate errors are deliberately replaced by the owning obstacle field path"
)]
fn validate_obstacle(
    obstacle: &StaticObstacle,
    path: &str,
) -> Result<super::SpatialLayerId, EncounterValidationError> {
    match obstacle {
        StaticObstacle::Segment { layer, start, end } => {
            start
                .validate()
                .map_err(|_| invalid(path, "segment start must be finite"))?;
            end.validate()
                .map_err(|_| invalid(path, "segment end must be finite"))?;

            if start.distance(*end) <= GEOMETRY_EPSILON {
                return Err(invalid(path, "segment endpoints must differ"));
            }

            Ok(*layer)
        }
        StaticObstacle::Polygon {
            layer,
            exterior,
            holes,
        } => {
            validate_polygon(exterior, holes, path)?;

            Ok(*layer)
        }
    }
}

fn validate_polygon(
    exterior: &[super::Position2],
    holes: &[Vec<super::Position2>],
    path: &str,
) -> Result<(), EncounterValidationError> {
    validate_ring(exterior, &format!("{path}.exterior"))?;

    for (hole_index, hole) in holes.iter().enumerate() {
        let hole_path = format!("{path}.holes[{hole_index}]");

        validate_ring(hole, &hole_path)?;

        if !point_strictly_in_ring(hole[0], exterior) {
            return Err(invalid(hole_path, "hole must be strictly inside exterior"));
        }

        if rings_intersect(hole, exterior) {
            return Err(invalid(
                format!("{path}.holes[{hole_index}]"),
                "hole may not touch or cross exterior",
            ));
        }
    }

    validate_hole_separation(holes, path)
}

fn validate_hole_separation(
    holes: &[Vec<super::Position2>],
    path: &str,
) -> Result<(), EncounterValidationError> {
    for left in 0..holes.len() {
        for right in left + 1..holes.len() {
            if rings_intersect(&holes[left], &holes[right])
                || point_in_or_on_ring(holes[left][0], &holes[right])
                || point_in_or_on_ring(holes[right][0], &holes[left])
            {
                return Err(invalid(
                    path,
                    "polygon holes may not touch, overlap, or nest",
                ));
            }
        }
    }

    Ok(())
}

pub(super) fn validate_not_in_obstacle(
    transform: SpatialTransform,
    scene: &StaticSpatialScene,
    path: &str,
) -> Result<(), EncounterValidationError> {
    for obstacle in &scene.obstacles {
        match obstacle {
            StaticObstacle::Segment { layer, start, end }
                if *layer == transform.layer
                    && point_on_segment(transform.position, *start, *end) =>
            {
                return Err(invalid(path, "actor transform touches a blocking segment"));
            }
            StaticObstacle::Polygon {
                layer,
                exterior,
                holes,
            } if *layer == transform.layer => {
                let in_exterior = point_in_or_on_ring(transform.position, exterior);
                let in_hole = holes
                    .iter()
                    .any(|hole| point_strictly_in_ring(transform.position, hole));

                if in_exterior && !in_hole {
                    return Err(invalid(
                        path,
                        "actor transform is inside or on a blocking polygon",
                    ));
                }

                if holes.iter().any(|hole| {
                    hole.windows(2)
                        .any(|edge| point_on_segment(transform.position, edge[0], edge[1]))
                }) {
                    return Err(invalid(
                        path,
                        "actor transform touches a blocking polygon boundary",
                    ));
                }
            }
            _ => {}
        }
    }

    Ok(())
}