wowlab_engine_domain/rotation/lower/

action.rs

use wowlab_types::sim::{Condition, RotationAction as AstAction};

use super::{
    super::{
        backend::RotationBackend,
        decision_trace::{ActionOutcome, ActionRecord},
    },
    Lowerer,
    condition::lower_condition,
};

mod lists;
mod terminators;
mod vars;

use lists::{lower_call, lower_run};
use terminators::{
    lower_cast, lower_pool, lower_use_item, lower_use_trinket, lower_wait, lower_wait_until,
};
pub(super) use vars::store_user_var;
use vars::{ModifyVarArgs, lower_modify_var, lower_set_var};

pub(super) fn lower_actions<B>(
    lo: &mut Lowerer<'_>,
    b: &mut B,
    list_id: &str,
    actions: &[AstAction],
) where
    B: RotationBackend,
{
    b.begin_list_recording(list_id);

    for (idx, action) in actions.iter().enumerate() {
        if !action.enabled() {
            b.record_action(ActionRecord {
                list_id,
                action_index: idx,
                action,
                outcome: ActionOutcome::Disabled,
            });
            continue;
        }

        if lo.unconditionally_returned {
            b.record_action(ActionRecord {
                list_id,
                action_index: idx,
                action,
                outcome: ActionOutcome::NotReached,
            });
            continue;
        }

        let mut ctx = LowerCtx {
            lo,
            b,
            action: ActionRef::new(list_id, idx, action),
        };

        lower_action(&mut ctx);
    }

    b.end_list_recording();
}

pub(super) fn init_user_variables<B>(lo: &mut Lowerer<'_>, b: &mut B)
where
    B: RotationBackend,
{
    let names: Vec<String> = lo.variables.keys().cloned().collect();

    for name in &names {
        let init = lo
            .variables
            .get(name)
            .expect("variable name pulled from the same map");
        // #t(rust_clone_in_loop) drops the &Condition borrow on `variables` so `store_user_var` can take `&mut Lowerer` for the rest of the loop.
        let init = init.clone();

        store_user_var(lo, b, name, &init);
    }
}

struct LoweredGuard<B>
where
    B: RotationBackend,
{
    bool_val: B::Bool,
    is_unconditional: bool,
}

fn lower_optional_guard<B>(
    lo: &mut Lowerer<'_>,
    b: &mut B,
    condition: Option<&Condition>,
) -> LoweredGuard<B>
where
    B: RotationBackend,
{
    match condition {
        Some(c) => LoweredGuard {
            bool_val: lower_condition(lo, b, c).into_bool(b),
            is_unconditional: false,
        },
        None => LoweredGuard {
            bool_val: b.const_bool(true),
            is_unconditional: true,
        },
    }
}

const fn is_terminator(action: &AstAction) -> bool {
    matches!(
        action,
        AstAction::Cast { .. }
            | AstAction::Wait { .. }
            | AstAction::WaitUntil { .. }
            | AstAction::Pool { .. }
            | AstAction::UseTrinket { .. }
            | AstAction::UseItem { .. }
    )
}

// Recorded so an action with no condition still shows up in the decision trace.
static ALWAYS_TRUE_SENTINEL: Condition = Condition::Bool { value: true };

#[inline]
fn failing_condition(condition: Option<&Condition>) -> &Condition {
    condition.unwrap_or(&ALWAYS_TRUE_SENTINEL)
}

#[derive(Clone, Copy)]
struct ActionRef<'a> {
    list_id: &'a str,
    action_index: usize,
    action: &'a AstAction,
    is_term: bool,
}

impl<'a> ActionRef<'a> {
    fn new(list_id: &'a str, action_index: usize, action: &'a AstAction) -> Self {
        Self {
            list_id,
            action_index,
            action,
            is_term: is_terminator(action),
        }
    }
}

struct LowerCtx<'ctx, 'action, 'rotation, B> {
    lo: &'ctx mut Lowerer<'rotation>,
    b: &'ctx mut B,
    action: ActionRef<'action>,
}

#[inline]
fn record_skipped<B>(ctx: &mut LowerCtx<'_, '_, '_, B>, failing: &Condition)
where
    B: RotationBackend,
{
    let false_bool = ctx.b.const_bool(false);

    ctx.b.record_action_guarded(
        ctx.action.list_id,
        ctx.action.action_index,
        ctx.action.action,
        ctx.action.is_term,
        false_bool,
        failing,
    );
}

#[inline]
fn record_guarded<B>(
    ctx: &mut LowerCtx<'_, '_, '_, B>,
    guard: &LoweredGuard<B>,
    condition: Option<&Condition>,
) where
    B: RotationBackend,
{
    ctx.b.record_action_guarded(
        ctx.action.list_id,
        ctx.action.action_index,
        ctx.action.action,
        ctx.action.is_term,
        guard.bool_val,
        failing_condition(condition),
    );

    if guard.is_unconditional {
        ctx.lo.unconditionally_returned = true;
    }
}

fn lower_action<B>(ctx: &mut LowerCtx<'_, '_, '_, B>)
where
    B: RotationBackend,
{
    match ctx.action.action {
        AstAction::Cast {
            spell,
            empower_rank,
            condition,
            ..
        } => lower_cast(ctx, spell, *empower_rank, condition.as_ref()),
        AstAction::Wait {
            seconds, condition, ..
        } => lower_wait(ctx, *seconds, condition.as_ref()),
        AstAction::WaitUntil { condition, .. } => lower_wait_until(ctx, condition),
        AstAction::Pool {
            extra, condition, ..
        } => lower_pool(ctx, *extra, condition.as_ref()),
        AstAction::UseTrinket {
            slot,
            empower_rank,
            condition,
            ..
        } => lower_use_trinket(ctx, *slot, *empower_rank, condition.as_ref()),
        AstAction::UseItem {
            name,
            empower_rank,
            condition,
            ..
        } => lower_use_item(ctx, name, *empower_rank, condition.as_ref()),
        AstAction::SetVar {
            name,
            value,
            condition,
            ..
        } => lower_set_var(ctx, name, value, condition.as_ref()),
        AstAction::ModifyVar {
            name,
            op,
            value,
            condition,
            ..
        } => lower_modify_var(
            ctx,
            &ModifyVarArgs {
                name,
                op: *op,
                value,
                condition: condition.as_ref(),
            },
        ),
        AstAction::Call {
            list, condition, ..
        } => lower_call(ctx, list, condition.as_ref()),
        AstAction::Run {
            list, condition, ..
        } => lower_run(ctx, list, condition.as_ref()),
        _ => unreachable!("rotation validation rejects unsupported action variants"),
    }
}

#[inline]
fn skip_in_run<B>(ctx: &mut LowerCtx<'_, '_, '_, B>, condition: Option<&Condition>) -> bool
where
    B: RotationBackend,
{
    if ctx.lo.run_depth > 0 {
        record_skipped(ctx, failing_condition(condition));

        true
    } else {
        false
    }
}