Struct GenericProvider 

pub struct GenericProvider;

The generic battle provider: dynamic ids + the runner’s standard formula. The stack never drives a turn loop here (the runner’s own loop fires the events), so select_move/apply_move_effect/create_monster are inert stubs; calculate_damage mirrors the runner formula for completeness.

Trait Implementations

impl BattleProvider for GenericProvider

fn calculate_damage( &self, move_: &Skill, attacker: &BattlerState<Self>, defender: &BattlerState<Self>, random: u8, is_critical: bool, ) -> DamageResult

The runner’s standard formula with the variance byte and crit flag given (the stack driver’s shape). The runner’s own loop precomputes damage itself (damage_roll → ctx.mv.damage); this mirrors it.

type Monster = ()

The monster data type.

type Move = Skill

The move identifier or data type.

type Ability = ()

The ability identifier type.

type Status = StatusId

The status condition type.

type Stat = StatId

The stat identifier type. Must be Copy + PartialEq for EnumMap key usage.

type Species = SpeciesData

The species identifier type.

type Type = TypeId

The elemental type identifier type.

type Item = ()

The item identifier type.

fn select_move( &self, battler: &BattlerState<Self>, _state: &BattleState<Self>, ) -> Self::Move

Select a move for the given battler. Typically delegates to a BattleAI implementation.

fn apply_move_effect( &self, _effect: MoveEffect, _user: &mut BattlerState<Self>, _target: &mut BattlerState<Self>, ) -> EffectResult

Apply a move’s effect after damage has been dealt. Typically delegates to an EffectHandler implementation.

fn create_monster( &self, species: Self::Species, level: u8, ) -> BattlerState<Self>

Construct a battler state from species and level data.

fn check_faint(&self, battler: &BattlerState<Self>) -> bool

Check whether a battler has fainted (HP = 0).

fn move_cost(&self, _move_: &Self::Move) -> &[(u16, u16)]

The resource cost of move_ as a list of (resource_id, amount) pairs.

fn turn_order_key( &self, _state: &BattleState<Self>, _who: BattlerRef, _action: &BattleAction<Self>, _rng: &mut dyn BattleRng, ) -> OrderKey

where Self: Sized,

Return the OrderKey used to sequence who’s action this turn.

fn before_move( &self, _state: &mut BattleState<Self>, _who: BattlerRef, _action: &BattleAction<Self>, _rng: &mut dyn BattleRng, ) -> MoveGate<Self>

where Self: Sized,

Pre-move status gate: may who act with action this turn?

fn accuracy_check( &self, _state: &BattleState<Self>, _who: BattlerRef, _target: BattlerRef, _move_: &Self::Move, _rng: &mut dyn BattleRng, ) -> bool

where Self: Sized,

Accuracy check for who’s move_ against target (incl. the Gen-1 1/256 miss). Returns true if the move connects. Default: always hits.

fn end_of_turn( &self, _state: &mut BattleState<Self>, _rng: &mut dyn BattleRng, ) -> Vec<EffectResult>

where Self: Sized,

End-of-turn residual hook: poison/burn tick, leech seed, wrap damage, weather, etc. The game owns ordering and numbers; it returns the resulting EffectResults for the UI. Default: no residuals.

fn roll_critical( &self, _state: &BattleState<Self>, _who: BattlerRef, _target: BattlerRef, _move_: &Self::Move, _rng: &mut dyn BattleRng, ) -> bool

where Self: Sized,

Roll whether who’s move_ against target lands a critical hit.

impl Clone for GenericProvider

fn clone(&self) -> GenericProvider

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for GenericProvider

impl Debug for GenericProvider

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GenericProvider

fn default() -> GenericProvider

Returns the “default value” for a type.

impl EffectProvider for GenericProvider

fn effect_for_move(&self, _m: &Self::Move) -> Option<&'static Effect<Self>>

The runner collects from the compiled registry directly (per-record), never through the resolvers.

fn effect_for_status(&self, _s: &Self::Status) -> Option<&'static Effect<Self>>

See effect_for_move.

fn turn_order_rank( &self, state: &BattleState<Self>, who: BattlerRef, _action: &Self::Move, ) -> (i32, i32)

(-priority, -effective speed); skills carry no priority (v1), so the priority tier is 0.

type EffectStateKind = VolatileKind

The game-supplied typed per-effect-kind state enum (design §3.1). The engine treats it opaquely (it only stamps effect_order and routes it to the host). pokered supplies the Gen-1 enum (Toxic counter, Substitute hp, …).

fn effect_for_volatile( &self, kind: &Self::EffectStateKind, ) -> Option<&'static Effect<Self>>

where Self: Sized,

Resolve the Effect registered for a live volatile in the effect arena (design §3.4: every live effect on a battler contributes its handlers, not only the non-volatile status). Returns None (the default) when the volatile registers no hooks — so a provider that has no volatile-borne residuals (every game built on the engine so far) is completely unaffected and the driver’s arena-residual pass is inert.

fn forced_action( &self, effects: &[EffectState<Self>], actor: BattlerRef, chosen: &BattleAction<Self>, ) -> Option<BattleAction<Self>>

where Self: Sized,

Cross-turn action override (design §3 / §9, the multi-turn lock-in seam). Before the driver executes actor’s chosen action, it asks the game whether a live volatile forces a different action this turn — Gen-1 Thrash/Petal Dance and Wrap/Bind re-issue the locked move ignoring the player’s choice, Fly/Dig/Solar Beam strike on the second turn, and Hyper Beam recharge forces inaction (BattleAction::Nothing). The game reads its own effects arena (the cross-turn home of the lock counter / charge flag / recharge flag) and returns Some(forced) to override chosen, or None to let the chosen action stand.

fn effect_for_ability( &self, b: &BattlerState<Self>, ) -> Option<&'static Effect<Self>>

where Self: Sized,

Resolve the Effect registered for a battler’s ability, hosted on that battler (design §2.4). Returns None (the default) when the game has no abilities or this one registers no stack hooks.

fn effect_for_item( &self, b: &BattlerState<Self>, ) -> Option<&'static Effect<Self>>

where Self: Sized,

Resolve the Effect registered for a battler’s held item, hosted on that battler (design §2.4). Returns None (the default) when the game has no items or this one registers no stack hooks.

fn side_effects( &self, ctx: &BattleCtx<'_, Self>, side: u8, ) -> &[&'static Effect<Self>]

where Self: Sized,

Resolve the side-hosted effects for side (screens, hazards, Wish; design §2.4). Returns &[] (the default) when the game has no side conditions.

fn field_effects(&self, ctx: &BattleCtx<'_, Self>) -> &[&'static Effect<Self>]

where Self: Sized,

Resolve the field-hosted effects (weather, terrain, Trick Room; design §2.4). Returns &[] (the default) when the game has no field conditions. The returned slice borrows from self (see side_effects).

impl RuleBindings<GenericProvider> for GenericBindings

fn type_chart_mult( &self, ctx: &BattleCtx<'_, GenericProvider>, move_type_index: usize, defender: BattlerRef, ) -> (u32, u32)

The chart fold for the in-flight move type vs the defender’s element, read from the COMPILED RON type_chart (the data layer owns the relation). An untyped defender is neutral.

fn apply_boost( &self, b: &mut BattlerState<GenericProvider>, stat_index: usize, stages: i8, ) -> bool

Apply a signed stat-stage delta to who for the interned stat_index. Returns false if the index is unknown (a no-op; the loader validates names at compile, so this is defense-in-depth). Phase 1 applies directly; the nested-TryBoost veto is driver orchestration (doc 11 §3).

fn set_status( &self, b: &mut BattlerState<GenericProvider>, status_index: usize, ) -> bool

Set who’s non-volatile status for the interned status_index. Returns false if the index is unknown.

fn has_type(&self, b: &BattlerState<GenericProvider>, type_index: usize) -> bool

Whether who has the type with interned chart type_index (the HasType predicate, doc 11 §1.1). Pure read.

fn make_volatile(&self, name: &str, amount: u16) -> Option<VolatileKind>

Build the game’s OPAQUE P::EffectStateKind volatile for the vocabulary name + already-resolved amount (the InflictVolatile op). The engine installs whatever is returned generically (fresh arena id) and never learns what the volatile means — only the game does. Defaulted to None ⇒ a game with no volatiles (or that doesn’t recognise name) makes the op inert. Pure — the engine already drew any rng needed for amount.

fn has_volatile( &self, ctx: &BattleCtx<'_, GenericProvider>, who: BattlerRef, name: &str, ) -> bool

Whether who currently has the live volatile named by name (the HasVolatile predicate, blueprint 15 §2/§3 — the Substitute block on side-status). The game inspects its own ctx.effects arena (the engine treats EffectStateKind opaquely, so only the game can tell which arena entry IS “Substitute”). Defaulted to false so a game with no volatiles (every game built so far) is unaffected and the predicate never matches. Pure read; no entropy.

fn battler_level(&self, b: &BattlerState<GenericProvider>) -> u16

The level of battler b (the LevelGE predicate’s gate + the level-based SetDamage sources — Seismic Toss / Night Shade / Psywave; blueprint 15 §2/§3). BattlerState<P> carries no level field (the engine is level-agnostic), so the game answers it here. Defaulted to 0 ⇒ a game that authors no level-gated op is unaffected (it never calls this) and LevelGE is 0 >= 0 == true. Pure read; no entropy. Game-agnostic: “a number the binding supplies per battler”.

fn has_status( &self, b: &BattlerState<GenericProvider>, status_index: usize, ) -> bool

Whether who currently has the non-volatile status at interned status_index (the TargetHasStatus predicate — the Dream Eater sleep gate, blueprint 15 §2). The status index is the game’s vocabulary (the same indices set_status consumes). Defaulted to false ⇒ a game that does not implement it never matches. Pure read; no entropy.

fn has_any_status(&self, b: &BattlerState<GenericProvider>) -> bool

Whether b has ANY non-volatile status (the TargetHasAnyStatus predicate — the Toxic “already-statused ⇒ fail” guard). The engine knows no concrete status, so the game answers. Defaulted to false ⇒ a game that doesn’t implement it never matches. Pure read; no entropy.

fn set_status_with_amount( &self, b: &mut BattlerState<P>, status_index: usize, _amount: u16, ) -> bool

Set who’s non-volatile status carrying a game-interpreted numeric amount (e.g. Gen-1 sleep turns). The engine resolves amount from the op’s AmountSpec — drawing its OWN rng — and hands the pure number here. Defaulted to delegate to set_status and ignore the amount, so a game whose statuses carry no duration is unaffected. Pure; no entropy.

fn current_stat_index(&self, _ctx: &BattleCtx<'_, P>) -> Option<usize>

The in-flight folded stat index, if the driver stashed one for a StatIs predicate (the Sandstorm WeatherModifyStat case, doc 11 §1). Default None ⇒ StatIs never matches. Pure.

fn redirect_hp_loss( &self, _ctx: &mut BattleCtx<'_, P>, _who: BattlerRef, _source: BattlerRef, _amount: u16, ) -> bool

Damage-redirection seam for the DIRECT-MUTATE ops (SetHp / DamageFraction / DamageCurrentHpFraction / RepeatHits) that apply HP OUTSIDE the driver’s Event::Damage fold. Before such an op subtracts amount HP from who (attributed to source), the interpreter asks the game whether a damage sink on who should swallow it instead — a monster Substitute doll, a cross-game shield/ward/decoy. Returning true means the game HANDLED the loss (it mutated its own sink via ctx); the interpreter then SKIPS the direct HP write. Returning false (the default) leaves the op to apply HP exactly as before.

fn move_type_is_defender_type( &self, ctx: &BattleCtx<'_, P>, move_type_index: usize, who: BattlerRef, ) -> bool

Whether the in-flight move’s type (move_type_index, recovered from the record’s type:) equals one of who’s types (the MoveTypeIsDefenderType predicate — Gen-1 burn/freeze/paralyze self-type-immunity quirk #23, blueprint 15 §2/§3). Defaulted to false ⇒ the quirk never fires for a game that does not implement it. Pure read; no entropy. The default body delegates to has_type so a game whose has_type already answers chart membership gets the quirk for free by overriding nothing — but the engine has no move_type_index for a generic predicate, so the loader passes it through and the binding decides.

fn resource_id(&self, resource_index: usize) -> u16

Map an interned resource index (the ruleset’s resources: order) to the engine’s opaque resource id used in ResourcePool / BattleProvider::move_cost (the MP/SP/mana cost gate, doc 13 §4). Defaulted so games with no resources need not implement it — they never reference a resource, so it is never called. Default: identity (index as u16). Pure.

fn can_pay_resource( &self, b: &BattlerState<P>, resource_index: usize, amount: u16, ) -> bool

Whether b can pay amount of the resource at interned resource_index (the PayResource op’s gate, doc 13 §4). Pure read. The default delegates to the engine’s ResourcePool via resource_id — a game that stores its pool on BattlerState.resources (the engine default) gets correct behavior for free.

fn pay_resource( &self, b: &mut BattlerState<P>, resource_index: usize, amount: u16, )

Deduct amount of the resource at interned resource_index from b (the PayResource op’s deduction). Pure arithmetic — no rng. Default delegates to the engine ResourcePool.

impl RulesProvider for GenericProvider

type Bindings = GenericBindings

The game binding resolving interned indices ↔ concrete P::Stat/P::Status and supplying the chart fold.

fn compiled(&self) -> &CompiledRuleset

The compiled ruleset (the side registry the interpreter reads by source_effect). Typically a &'static built once via OnceLock.

fn bindings(&self) -> &Self::Bindings

The game binding instance.

fn rules_host() -> Option<&'static RulesHost<GenericProvider>>

Read the provider from ctx for the interpreter. The interpreter only has &mut BattleCtx, which does NOT carry &P (the engine’s borrow discipline). A game whose chart/registry is a &'static (the common case) returns it here without touching ctx; the default points at that static. Returns None if no static is installed.