wowlab_engine_domain/rotation/

interp_backend.rs

// #t(file: rust_floating_point_eq) `float_to_bool` is the documented exact-zero check that mirrors the trait coercion contract.
// #t(file: rust_bool_params) `and_b`/`or_b`/`select_b` are trait primitives whose Bool params are unavoidable.

//! Interpreter side of the [`RotationBackend`] lowering trait.

use std::marker::PhantomData;

use wowlab_types::{
    constants::MS_PER_SECOND,
    numeric::{float_eq, float_ne, safe_div, true_mod},
    sim::{Condition, Rotation, RotationAction, SpellIdx},
};

use super::{
    backend::RotationBackend,
    buffer::{DenseBuffer, DescriptorTable},
    context::ContextSchema,
    decision_trace::{
        ActionEvaluation, ActionOutcome, ActionRecord, Decision, DecisionTraceSink,
        DecisionTraceTarget, EvaluationStatus,
    },
    resolver::SpecResolver,
    result::EvalResult,
    trace::{TraceContext, condition_label_with_values},
};

#[derive(Clone, Copy)]
pub(crate) struct RecorderCtx<'a> {
    pub(crate) rotation: &'a Rotation,
    pub(crate) schema: &'a ContextSchema,
    pub(crate) resolver: &'a SpecResolver,
    pub(crate) table: &'a DescriptorTable,
}

pub(crate) struct InterpFrame<'a> {
    pub(crate) buffer: &'a mut DenseBuffer,
    pub(crate) now: f64,
}

struct TraceState<'a> {
    sink: DecisionTraceTarget,
    ctx: RecorderCtx<'a>,
    buffer: *mut DenseBuffer,
    stack: Vec<Decision>,
    time_ms: u32,
}

pub(crate) struct InterpBackend<'a> {
    buf: *mut u8,
    len: usize,
    now: f64,
    result: Option<EvalResult>,
    trace: Option<TraceState<'a>>,
    _phantom: PhantomData<&'a mut DenseBuffer>,
}

impl<'a> InterpBackend<'a> {
    pub(crate) fn new(frame: InterpFrame<'a>) -> Self {
        let InterpFrame { buffer: buf, now } = frame;
        let len = buf.bytes().len();

        Self {
            buf: buf.as_mut_ptr(),
            len,
            now,
            result: None,
            trace: None,
            _phantom: PhantomData,
        }
    }

    pub(crate) fn with_sink(
        frame: InterpFrame<'a>,
        sink: DecisionTraceTarget,
        ctx: RecorderCtx<'a>,
    ) -> Self {
        let InterpFrame { buffer: buf, now } = frame;
        let time_ms = wowlab_types::numeric::f64_to_u32_saturating_round(now * MS_PER_SECOND);
        let len = buf.bytes().len();
        let buffer_ptr: *mut DenseBuffer = buf;
        let data_ptr = buf.as_mut_ptr();

        Self {
            buf: data_ptr,
            len,
            now,
            result: None,
            trace: Some(TraceState {
                sink,
                ctx,
                buffer: buffer_ptr,
                stack: Vec::new(),
                time_ms,
            }),
            _phantom: PhantomData,
        }
    }

    pub(crate) fn finish(self) -> EvalResult {
        if let Some(state) = self.trace {
            for d in state.stack.into_iter().rev() {
                state.sink.record(d);
            }
        }

        self.result.unwrap_or(EvalResult::NONE)
    }

    #[inline]
    fn bytes(&self) -> &[u8] {
        // SAFETY: exclusive `&mut DenseBuffer` borrow via `PhantomData`; buffer not resized, reads never aliased with stores.
        unsafe { std::slice::from_raw_parts(self.buf, self.len) }
    }

    #[inline]
    fn capture(&mut self, r: EvalResult) {
        if self.result.is_none() {
            self.result = Some(r);
        }
    }
}

impl TraceState<'_> {
    fn rejection_reason(&self, now_secs: f64, failing: &Condition) -> Option<String> {
        // SAFETY: InterpBackend holds the exclusive borrow via PhantomData; recorder runs between lowerer buffer ops, so no concurrent mutation.
        let buffer = unsafe { &mut *self.buffer };
        let mut tc = TraceContext {
            rotation: self.ctx.rotation,
            schema: self.ctx.schema,
            resolver: self.ctx.resolver,
            table: self.ctx.table,
            buffer,
            now_secs,
        };
        let label = condition_label_with_values(failing, &mut tc);

        if label.is_empty() { None } else { Some(label) }
    }
}

impl RotationBackend for InterpBackend<'_> {
    type Bool = bool;
    type Int = i64;
    type Float = f64;

    #[inline]
    fn const_bool(&mut self, v: bool) -> bool {
        v
    }
    #[inline]
    fn const_i32(&mut self, v: i32) -> i64 {
        i64::from(v)
    }
    #[inline]
    fn const_i64(&mut self, v: i64) -> i64 {
        v
    }
    #[inline]
    fn const_f64(&mut self, v: f64) -> f64 {
        v
    }

    #[inline]
    fn load_bool(&mut self, offset: usize) -> bool {
        // #t(block: rust_unchecked_indexing) offset is schema-validated to lie within byte_len; bool fields are stored as i32
        bytemuck::pod_read_unaligned::<i32>(&self.bytes()[offset..offset + size_of::<i32>()]) != 0
    }
    #[inline]
    fn load_i32(&mut self, offset: usize) -> i64 {
        // #t(block: rust_unchecked_indexing) offset is schema-validated to lie within byte_len
        i64::from(bytemuck::pod_read_unaligned::<i32>(
            &self.bytes()[offset..offset + size_of::<i32>()],
        ))
    }
    #[inline]
    fn load_i64(&mut self, offset: usize) -> i64 {
        // #t(block: rust_unchecked_indexing) offset is schema-validated to lie within byte_len
        bytemuck::pod_read_unaligned::<i64>(&self.bytes()[offset..offset + size_of::<i64>()])
    }
    #[inline]
    fn load_f64(&mut self, offset: usize) -> f64 {
        // #t(block: rust_unchecked_indexing) offset is schema-validated to lie within byte_len
        bytemuck::pod_read_unaligned::<f64>(&self.bytes()[offset..offset + size_of::<f64>()])
    }

    #[inline]
    fn store_bool(&mut self, offset: usize, v: bool) {
        let bytes = i32::from(v).to_ne_bytes();
        // SAFETY: offset and width are schema-validated, and the buffer remains exclusively borrowed.

        unsafe { std::slice::from_raw_parts_mut(self.buf.add(offset), bytes.len()) }
            .copy_from_slice(&bytes);
    }
    #[inline]
    fn store_i32(&mut self, offset: usize, v: i64) {
        let bytes = crate::numeric::wrapping_i64_to_i32(v).to_ne_bytes();
        // SAFETY: offset and width are schema-validated, and the buffer remains exclusively borrowed.

        unsafe { std::slice::from_raw_parts_mut(self.buf.add(offset), bytes.len()) }
            .copy_from_slice(&bytes);
    }
    #[inline]
    fn store_f64(&mut self, offset: usize, v: f64) {
        let bytes = v.to_ne_bytes();
        // SAFETY: offset and width are schema-validated, and the buffer remains exclusively borrowed.

        unsafe { std::slice::from_raw_parts_mut(self.buf.add(offset), bytes.len()) }
            .copy_from_slice(&bytes);
    }

    #[inline]
    fn now(&mut self) -> f64 {
        self.now
    }

    #[inline]
    fn add_f(&mut self, a: f64, b: f64) -> f64 {
        a + b
    }
    #[inline]
    fn sub_f(&mut self, a: f64, b: f64) -> f64 {
        a - b
    }
    #[inline]
    fn mul_f(&mut self, a: f64, b: f64) -> f64 {
        a * b
    }
    #[inline]
    fn safe_div_f(&mut self, a: f64, b: f64) -> f64 {
        safe_div(a, b)
    }
    #[inline]
    fn true_mod_f(&mut self, a: f64, b: f64) -> f64 {
        true_mod(a, b)
    }
    #[inline]
    fn min_f(&mut self, a: f64, b: f64) -> f64 {
        a.min(b)
    }
    #[inline]
    fn max_f(&mut self, a: f64, b: f64) -> f64 {
        a.max(b)
    }
    #[inline]
    fn floor_f(&mut self, v: f64) -> f64 {
        v.floor()
    }
    #[inline]
    fn ceil_f(&mut self, v: f64) -> f64 {
        v.ceil()
    }
    #[inline]
    fn abs_f(&mut self, v: f64) -> f64 {
        v.abs()
    }

    #[inline]
    fn cmp_gt_f(&mut self, a: f64, b: f64) -> bool {
        a > b
    }
    #[inline]
    fn cmp_gte_f(&mut self, a: f64, b: f64) -> bool {
        a >= b
    }
    #[inline]
    fn cmp_lt_f(&mut self, a: f64, b: f64) -> bool {
        a < b
    }
    #[inline]
    fn cmp_lte_f(&mut self, a: f64, b: f64) -> bool {
        a <= b
    }
    #[inline]
    fn cmp_eq_f(&mut self, a: f64, b: f64) -> bool {
        float_eq(a, b)
    }
    #[inline]
    fn cmp_ne_f(&mut self, a: f64, b: f64) -> bool {
        float_ne(a, b)
    }
    #[inline]
    fn cmp_eq_i(&mut self, a: i64, b: i64) -> bool {
        a == b
    }
    #[inline]
    fn cmp_ne_i(&mut self, a: i64, b: i64) -> bool {
        a != b
    }
    #[inline]
    fn cmp_gt_i(&mut self, a: i64, b: i64) -> bool {
        a > b
    }
    #[inline]
    fn cmp_gte_i(&mut self, a: i64, b: i64) -> bool {
        a >= b
    }
    #[inline]
    fn cmp_lt_i(&mut self, a: i64, b: i64) -> bool {
        a < b
    }
    #[inline]
    fn cmp_lte_i(&mut self, a: i64, b: i64) -> bool {
        a <= b
    }

    #[inline]
    fn and_b(&mut self, a: bool, b: bool) -> bool {
        a && b
    }
    #[inline]
    fn or_b(&mut self, a: bool, b: bool) -> bool {
        a || b
    }
    #[inline]
    fn not_b(&mut self, a: bool) -> bool {
        !a
    }

    #[inline]
    fn bool_to_float(&mut self, v: bool) -> f64 {
        if v { 1.0 } else { 0.0 }
    }
    #[inline]
    fn bool_to_int(&mut self, v: bool) -> i64 {
        i64::from(v)
    }
    #[inline]
    fn int_to_float(&mut self, v: i64) -> f64 {
        wowlab_types::numeric::i64_to_f64(v)
    }
    #[inline]
    fn int_to_bool(&mut self, v: i64) -> bool {
        v != 0
    }
    #[inline]
    fn float_to_bool(&mut self, v: f64) -> bool {
        v != 0.0
    }
    #[inline]
    fn float_to_int(&mut self, v: f64) -> i64 {
        wowlab_types::numeric::f64_to_i64_saturating_trunc(v)
    }

    #[inline]
    fn select_f(&mut self, cond: bool, t: f64, f: f64) -> f64 {
        if cond { t } else { f }
    }
    #[inline]
    fn select_i(&mut self, cond: bool, t: i64, f: i64) -> i64 {
        if cond { t } else { f }
    }
    #[inline]
    fn select_b(&mut self, cond: bool, t: bool, f: bool) -> bool {
        if cond { t } else { f }
    }

    #[inline]
    fn return_none_if(&mut self, cond: bool) {
        if cond {
            self.capture(EvalResult::NONE);
        }
    }
    #[inline]
    fn return_cast_if(&mut self, cond: bool, spell_id: u32, empower_rank: u8) {
        if cond {
            self.capture(EvalResult::cast(SpellIdx(spell_id), empower_rank));
        }
    }
    #[inline]
    fn return_wait_if(&mut self, cond: bool, seconds: f32) {
        if cond {
            self.capture(EvalResult::wait(seconds));
        }
    }
    #[inline]
    fn return_pool_if(&mut self, cond: bool, target: f32) {
        if cond {
            self.capture(EvalResult::pool(target));
        }
    }
    #[inline]
    fn return_use_item_if(&mut self, cond: bool, gear_slot: u8, empower_rank: u8) {
        if cond {
            self.capture(EvalResult::use_item_raw(gear_slot, empower_rank));
        }
    }
    #[inline]
    fn return_none(&mut self) {
        self.capture(EvalResult::NONE);
    }

    #[inline]
    fn record_action(&mut self, record: ActionRecord<'_>) {
        let now_secs = self.now;
        let Some(state) = self.trace.as_mut() else {
            return;
        };
        let status = record.outcome.status();
        let rejection_reason = match &record.outcome {
            ActionOutcome::Rejected { failing } => state.rejection_reason(now_secs, failing),
            _ => None,
        };
        let Some(decision) = state.stack.last_mut() else {
            return;
        };

        decision.evaluations.push(ActionEvaluation {
            list_id: record.list_id.to_string(),
            action_index: record.action_index,
            status,
            rejection_reason,
        });

        if matches!(record.outcome, ActionOutcome::Fired) {
            decision.fired_action_index = Some(record.action_index);
        }
    }

    #[inline]
    fn record_action_guarded(
        &mut self,
        list_id: &str,
        action_index: usize,
        _action: &RotationAction,
        is_terminator: bool,
        guard_held: bool,
        failing: &Condition,
    ) {
        let now_secs = self.now;
        let Some(state) = self.trace.as_mut() else {
            return;
        };
        let already_fired = state
            .stack
            .last()
            .is_some_and(|d| d.fired_action_index.is_some());
        let (status, rejection_reason) = if already_fired {
            (EvaluationStatus::NotReached, None)
        } else if guard_held {
            if is_terminator {
                (EvaluationStatus::Fired, None)
            } else {
                (EvaluationStatus::Executed, None)
            }
        } else {
            let reason = state.rejection_reason(now_secs, failing);

            (EvaluationStatus::Rejected, reason)
        };
        let Some(decision) = state.stack.last_mut() else {
            return;
        };

        decision.evaluations.push(ActionEvaluation {
            list_id: list_id.to_string(),
            action_index,
            status,
            rejection_reason,
        });

        if status == EvaluationStatus::Fired {
            decision.fired_action_index = Some(action_index);
        }
    }

    #[inline]
    fn begin_list_recording(&mut self, list_id: &str) {
        let Some(state) = self.trace.as_mut() else {
            return;
        };

        state.stack.push(Decision {
            time_ms: state.time_ms,
            list_id: list_id.to_string(),
            fired_action_index: None,
            evaluations: Vec::new(),
            nested: Vec::new(),
        });
    }

    #[inline]
    fn end_list_recording(&mut self) {
        let Some(state) = self.trace.as_mut() else {
            return;
        };
        let Some(finished) = state.stack.pop() else {
            return;
        };

        if let Some(parent) = state.stack.last_mut() {
            parent.nested.push(finished);
        } else {
            state.sink.record(finished);
        }
    }
}