supreme_replay_analyzer/

track_scoring.rs

//! Track scoring and identification functionality

use crate::models::{AnalyzeResult, Level, Position, RowData};
use crate::plane_intersection::{
    LevelPlaneIntersection, PlaneIntersectionInfo, get_plane_intersections_with_level_data,
};

const PLANE_RADIUS: f32 = 90.5;
const NEAREST_START_POINT_DIST: f32 = 2.0;

#[derive(Debug, Clone)]
pub struct LevelScore {
    pub name: String,
    pub score: usize,
}

#[must_use]
pub fn score_track(analyze_result: &AnalyzeResult, level_data: &[Level]) -> Option<String> {
    let coords = analyze_result.coords.as_ref()?;

    let level_plane_intersections =
        get_plane_intersections_with_level_data(&coords.rows, level_data);
    let level_scores = score_every_level(analyze_result, &level_plane_intersections, level_data);

    if level_scores.is_empty() {
        return None;
    }

    let top_score = level_scores[0].score;
    if top_score == 0 {
        return None;
    }

    let top_scoring: Vec<String> = level_scores
        .iter()
        .filter(|s| s.score == top_score)
        .map(|s| s.name.clone())
        .collect();

    // Special case for ForestHard/ForestMedium ambiguity
    if top_scoring.len() == 2
        && top_scoring.contains(&"ForestHard".to_string())
        && top_scoring.contains(&"ForestMedium".to_string())
    {
        return Some("ForestMediumOrHard".to_string());
    }

    if top_scoring.len() == 1 {
        return Some(top_scoring[0].clone());
    }

    None
}

#[must_use]
pub fn identify_track_by_start_pos(first_row: &RowData, level_data: &[Level]) -> Option<String> {
    let mut best_match = None;
    let mut min_dist = f32::MAX;

    for level in level_data {
        let dist = get_nearest_player_start_location(
            &level.name,
            std::slice::from_ref(first_row),
            level_data,
        );
        if dist < min_dist {
            min_dist = dist;
            best_match = Some(level.name.clone());
        }
    }

    if min_dist <= NEAREST_START_POINT_DIST {
        best_match
    } else {
        None
    }
}

#[must_use]
pub fn identify_track_fast(
    start_pos: &RowData,
    cp1_pos: &RowData,
    finish_pos: &RowData,
    level_data: &[Level],
) -> Option<String> {
    let mut best_match = None;
    let mut min_cum_dist_sq = f32::MAX;

    for level in level_data {
        let l_start = find_closest_level_point(level, "Player_Start_Location", start_pos);
        let l_cp1 = find_closest_level_point(level, "Check_Point_1", cp1_pos);
        let l_finish = find_closest_level_point(level, "Finish_Point", finish_pos);

        if let (Some(ls), Some(lc), Some(lf)) = (l_start, l_cp1, l_finish) {
            let d1 = calculate_distance_sq(start_pos, ls);
            let d2 = calculate_distance_sq(cp1_pos, lc);
            let d3 = calculate_distance_sq(finish_pos, lf);

            let cum_dist_sq = d1 + d2 + d3;
            if cum_dist_sq < min_cum_dist_sq {
                min_cum_dist_sq = cum_dist_sq;
                best_match = Some(level.name.clone());
            }
        }
    }

    best_match
}

fn find_closest_level_point<'a>(
    level: &'a Level,
    name: &str,
    target: &RowData,
) -> Option<&'a Position> {
    level
        .entries
        .iter()
        .filter(|e| e.name == name)
        .min_by(|a, b| {
            let da = calculate_distance_sq(target, &a.position);
            let db = calculate_distance_sq(target, &b.position);
            da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal)
        })
        .map(|e| &e.position)
}

fn calculate_distance_sq(p1: &RowData, p2: &Position) -> f32 {
    let dx = p1.x - p2.x;
    let dy = p1.y - p2.y;
    let dz = p1.z - p2.z;
    dx * dx + dy * dy + dz * dz
}

fn score_every_level(
    analyze_result: &AnalyzeResult,
    level_plane_intersections: &[LevelPlaneIntersection],
    level_data: &[Level],
) -> Vec<LevelScore> {
    let coords = match &analyze_result.coords {
        Some(c) => c,
        None => return Vec::new(),
    };

    let mut level_scores: Vec<LevelScore> = level_plane_intersections
        .iter()
        .map(|lpc| {
            let nearest_start_dist =
                get_nearest_player_start_location(&lpc.name, &coords.rows, level_data);

            let first_valid_start = get_valid_intersections(lpc, "Start_Point").first().cloned();
            let first_valid_checkpoint1 = get_valid_intersections(lpc, "Check_Point_1")
                .first()
                .cloned();
            let first_valid_finish = get_valid_intersections(lpc, "Finish_Point")
                .first()
                .cloned();

            let all_checkpoint2: Vec<&PlaneIntersectionInfo> = lpc
                .intersections
                .iter()
                .filter(|c| c.object_name == "Check_Point_2")
                .collect();

            let valid_checkpoint2_count = all_checkpoint2
                .iter()
                .filter(|c| c.distance <= PLANE_RADIUS)
                .filter(|c| {
                    first_valid_start
                        .as_ref()
                        .is_none_or(|s| s.frame2 <= c.frame1)
                })
                .filter(|c| {
                    first_valid_checkpoint1
                        .as_ref()
                        .is_none_or(|cp1| cp1.frame2 <= c.frame1)
                })
                .filter(|c| {
                    first_valid_finish
                        .as_ref()
                        .is_none_or(|f| c.frame2 <= f.frame2)
                })
                .count();

            let start_plane_diff_ms =
                get_ms_diff(analyze_result, &first_valid_start, "Start_Point");
            let checkpoint1_diff_ms =
                get_ms_diff(analyze_result, &first_valid_checkpoint1, "Check_Point_1");
            let finish_point_diff_ms =
                get_ms_diff(analyze_result, &first_valid_finish, "Finish_Point");

            let mut score = 0;

            // Score criteria
            if nearest_start_dist <= NEAREST_START_POINT_DIST {
                score += 1;
            }
            if start_plane_diff_ms.is_some_and(|d| d.abs() <= 10.0) {
                score += 1;
            }
            if checkpoint1_diff_ms.is_some_and(|d| d.abs() <= 10.0) {
                score += 1;
            }
            if finish_point_diff_ms.is_some_and(|d| d.abs() <= 10.0) {
                score += 1;
            }
            if valid_checkpoint2_count > 0 {
                score += 1;
            }

            LevelScore {
                name: lpc.name.clone(),
                score,
            }
        })
        .collect();

    level_scores.sort_by_key(|b| std::cmp::Reverse(b.score));
    level_scores
}

fn get_valid_intersections(
    lpc: &LevelPlaneIntersection,
    object_name: &str,
) -> Vec<PlaneIntersectionInfo> {
    lpc.intersections
        .iter()
        .filter(|c| c.object_name == object_name && c.distance <= PLANE_RADIUS)
        .cloned()
        .collect()
}

fn get_ms_diff(
    analyze_result: &AnalyzeResult,
    intersection: &Option<PlaneIntersectionInfo>,
    object_name: &str,
) -> Option<f32> {
    let intersection = intersection.as_ref()?;
    #[allow(clippy::cast_precision_loss)]
    let frame_ms = intersection.frame2 as f32 * 10.0;

    match object_name {
        "Start_Point" => Some(frame_ms - analyze_result.checkpoint1_ms), // Using timing from header
        "Check_Point_1" => Some(frame_ms - analyze_result.checkpoint1_ms),
        "Finish_Point" => Some(frame_ms - (analyze_result.displayed_ms + analyze_result.start_ms)),
        _ => None,
    }
}

fn get_nearest_player_start_location(
    level_name: &str,
    rows: &[RowData],
    level_data: &[Level],
) -> f32 {
    if rows.is_empty() {
        return f32::MAX;
    }

    let level = match level_data.iter().find(|l| l.name == level_name) {
        Some(l) => l,
        None => return f32::MAX,
    };

    let start_locations: Vec<&Position> = level
        .entries
        .iter()
        .filter(|e| e.name == "Player_Start_Location")
        .map(|e| &e.position)
        .collect();

    if start_locations.is_empty() {
        return f32::MAX;
    }

    let replay_start_pos = Position {
        x: rows[0].x,
        y: rows[0].y,
        z: rows[0].z,
    };

    start_locations
        .iter()
        .map(|start_pos| calculate_distance(&replay_start_pos, start_pos))
        .min_by(|a, b| a.total_cmp(b))
        .unwrap_or(f32::MAX)
}

fn calculate_distance(p1: &Position, p2: &Position) -> f32 {
    let dx = p2.x - p1.x;
    let dy = p2.y - p1.y;
    let dz = p2.z - p1.z;
    (dx * dx + dy * dy + dz * dz).sqrt()
}