supreme_replay_analyzer/

analyzer.rs

//! Main replay analysis functionality

use std::io;

use crate::{AnalyzeResult, CoordinateData, Level, RowData, checkpoint_times, track_scoring};

const BLOCK_SIZE_BYTES: usize = 109;
const TIME_INCREMENT_MS: f32 = 10.0;

pub fn analyze_replay(
    data: &[u8],
    level_data: Option<&[Level]>,
) -> Result<AnalyzeResult, io::Error> {
    let (player_name, end_name_addr) = read_name(data)?;
    let timing_data = get_timing_data_from_header(data, end_name_addr)?;

    let displayed_ms =
        timing_data.total_time_to_finish_ms - timing_data.cross_start_plus_start_delay_ms;
    let lag_before_start_ms = count_same(data)? * TIME_INCREMENT_MS;
    let start_ms = timing_data.cross_start_plus_start_delay_ms - lag_before_start_ms;
    let lag_after_finish_ms =
        timing_data.total_recording_time_ms - timing_data.total_time_to_finish_ms;
    let checkpoint1_ms =
        timing_data.checkpoint1_total_ms - timing_data.cross_start_plus_start_delay_ms;

    // Extract coordinate data
    let coords = get_coordinate_data(data)?;

    let mut result = AnalyzeResult {
        player_name,
        track_name: None,
        displayed_ms,
        start_ms,
        total_ms: displayed_ms + start_ms,
        lag_start_ms: lag_before_start_ms,
        lag_finish_ms: lag_after_finish_ms,
        recording_ms: timing_data.total_recording_time_ms,
        checkpoint1_ms,
        coords: Some(coords),
        checkpoint_times: None,
    };

    // Score track to determine which level this replay is from
    if let Some(level_data) = level_data {
        result.track_name = track_scoring::score_track(&result, level_data);
    }

    // Extract checkpoint crossing times for the detected track
    if let Some(ref track_name) = result.track_name
        && let Some(level_data) = level_data
    {
        result.checkpoint_times = Some(checkpoint_times::extract_checkpoint_times(
            &result, track_name, level_data,
        ));
    }

    Ok(result)
}

pub fn analyze_replay_fast(
    data: &[u8],
    level_data: Option<&[Level]>,
) -> Result<AnalyzeResult, io::Error> {
    let (player_name, end_name_addr) = read_name(data)?;
    let timing_data = get_timing_data_from_header(data, end_name_addr)?;

    let displayed_ms =
        timing_data.total_time_to_finish_ms - timing_data.cross_start_plus_start_delay_ms;
    let lag_before_start_ms = count_same(data)? * TIME_INCREMENT_MS;
    let start_ms = timing_data.cross_start_plus_start_delay_ms - lag_before_start_ms;
    let lag_after_finish_ms =
        timing_data.total_recording_time_ms - timing_data.total_time_to_finish_ms;
    let checkpoint1_ms =
        timing_data.checkpoint1_total_ms - timing_data.cross_start_plus_start_delay_ms;

    // Fast track identification: read positions at Start, CP1, and Finish
    let mut track_name = None;
    if let Some(levels) = level_data {
        let first_block_offset = get_first_block_offset(data)?;

        let start_pos = get_row_at_block_index(data, first_block_offset, 0);
        let cp1_index = (timing_data.checkpoint1_total_ms / TIME_INCREMENT_MS) as usize;
        let cp1_pos = get_row_at_block_index(data, first_block_offset, cp1_index);
        let finish_index = (timing_data.total_time_to_finish_ms / TIME_INCREMENT_MS) as usize;
        let finish_pos = get_row_at_block_index(data, first_block_offset, finish_index);

        if let Some(start) = start_pos {
            if let (Some(cp1), Some(finish)) = (cp1_pos, finish_pos) {
                track_name = track_scoring::identify_track_fast(&start, &cp1, &finish, levels);
            } else {
                // Fallback to start pos only if other blocks are missing
                track_name = track_scoring::identify_track_by_start_pos(&start, levels);
            }
        }
    }

    Ok(AnalyzeResult {
        player_name,
        track_name,
        displayed_ms,
        start_ms,
        total_ms: displayed_ms + start_ms,
        lag_start_ms: lag_before_start_ms,
        lag_finish_ms: lag_after_finish_ms,
        recording_ms: timing_data.total_recording_time_ms,
        checkpoint1_ms,
        coords: None,           // Skip for fast scan
        checkpoint_times: None, // Skip for fast scan
    })
}

fn read_name(data: &[u8]) -> Result<(String, usize), io::Error> {
    for i in 24..data.len() {
        if data[i] == 0x00 {
            let name_bytes = &data[24..i];
            let player_name = String::from_utf8_lossy(name_bytes).to_string();
            return Ok((player_name, i));
        }
    }
    Err(io::Error::new(
        io::ErrorKind::InvalidData,
        "Player name not found in replay data",
    ))
}

struct TimingDataFromHeader {
    total_recording_time_ms: f32,
    cross_start_plus_start_delay_ms: f32,
    checkpoint1_total_ms: f32,
    total_time_to_finish_ms: f32,
}

fn get_timing_data_from_header(
    data: &[u8],
    end_name_addr: usize,
) -> Result<TimingDataFromHeader, io::Error> {
    if data.len() < 6 {
        return Err(io::Error::new(
            io::ErrorKind::InvalidData,
            "Data too short for timing header",
        ));
    }

    if end_name_addr + 11 >= data.len() {
        return Err(io::Error::new(
            io::ErrorKind::InvalidData,
            "Data too short for timing data after name",
        ));
    }

    // Read little-endian u16 values and convert to milliseconds
    let total_recording_time_ms =
        TIME_INCREMENT_MS * f32::from(u16::from_le_bytes([data[4], data[5]]));
    let cross_start_plus_start_delay_ms = TIME_INCREMENT_MS
        * f32::from(u16::from_le_bytes([
            data[end_name_addr + 1],
            data[end_name_addr + 2],
        ]));
    let checkpoint1_total_ms = TIME_INCREMENT_MS
        * f32::from(u16::from_le_bytes([
            data[end_name_addr + 5],
            data[end_name_addr + 6],
        ]));
    let total_time_to_finish_ms = TIME_INCREMENT_MS
        * f32::from(u16::from_le_bytes([
            data[end_name_addr + 9],
            data[end_name_addr + 10],
        ]));

    Ok(TimingDataFromHeader {
        total_recording_time_ms,
        cross_start_plus_start_delay_ms,
        checkpoint1_total_ms,
        total_time_to_finish_ms,
    })
}

fn count_same(data: &[u8]) -> Result<f32, io::Error> {
    let first_block_offset = get_first_block_offset(data)?;
    let mut count = 1.0;
    let mut i = first_block_offset;

    while i + BLOCK_SIZE_BYTES < data.len() {
        if !block_is_same(data, i, i + BLOCK_SIZE_BYTES) {
            return Ok(count);
        }
        i += BLOCK_SIZE_BYTES;
        count += 1.0;
    }

    Ok(count)
}

fn block_is_same(data: &[u8], block1: usize, block2: usize) -> bool {
    for i in 0..BLOCK_SIZE_BYTES {
        if block1 + i >= data.len() || block2 + i >= data.len() {
            return false;
        }
        if data[block1 + i] != data[block2 + i] {
            return false;
        }
    }
    true
}

fn get_first_block_offset(data: &[u8]) -> Result<usize, io::Error> {
    let (_, end_name_addr) = read_name(data)?;
    Ok(end_name_addr + 13)
}

fn get_row_at_block_index(data: &[u8], offset: usize, index: usize) -> Option<RowData> {
    let block_start = offset + index * BLOCK_SIZE_BYTES;
    let pos_offset = block_start + 44;

    if pos_offset + 12 > data.len() {
        return None;
    }

    let x = f32::from_le_bytes([
        data[pos_offset],
        data[pos_offset + 1],
        data[pos_offset + 2],
        data[pos_offset + 3],
    ]);
    let y = f32::from_le_bytes([
        data[pos_offset + 4],
        data[pos_offset + 5],
        data[pos_offset + 6],
        data[pos_offset + 7],
    ]);
    let z = f32::from_le_bytes([
        data[pos_offset + 8],
        data[pos_offset + 9],
        data[pos_offset + 10],
        data[pos_offset + 11],
    ]);

    Some(RowData { x, y, z })
}

fn get_coordinate_data(block_data: &[u8]) -> Result<CoordinateData, io::Error> {
    let first_block_offset = get_first_block_offset(block_data)?;

    // Check if footer exists (last block is all zeros)
    let footer_exists = if block_data.len() >= BLOCK_SIZE_BYTES {
        let last_block_start = block_data.len() - BLOCK_SIZE_BYTES;
        block_data[last_block_start..].iter().all(|&b| b == 0x00)
    } else {
        false
    };

    let mut rows = Vec::new();
    let last_block = if footer_exists {
        block_data.len() - BLOCK_SIZE_BYTES
    } else {
        block_data.len()
    };

    let mut i = first_block_offset;
    while i + BLOCK_SIZE_BYTES <= last_block {
        let pos_offset = i + 44;
        let matrix_offset = pos_offset + 3 * 4;

        if matrix_offset + 9 * 4 > block_data.len() {
            break;
        }

        // Read position (3 f32 values)
        let x = f32::from_le_bytes([
            block_data[pos_offset],
            block_data[pos_offset + 1],
            block_data[pos_offset + 2],
            block_data[pos_offset + 3],
        ]);
        let y = f32::from_le_bytes([
            block_data[pos_offset + 4],
            block_data[pos_offset + 5],
            block_data[pos_offset + 6],
            block_data[pos_offset + 7],
        ]);
        let z = f32::from_le_bytes([
            block_data[pos_offset + 8],
            block_data[pos_offset + 9],
            block_data[pos_offset + 10],
            block_data[pos_offset + 11],
        ]);

        rows.push(RowData { x, y, z });

        i += BLOCK_SIZE_BYTES;
    }

    Ok(CoordinateData { rows })
}