Struct BattleState 

pub struct BattleState<P: BattleProvider + ?Sized> {
    pub player_battlers: Vec<BattlerState<P>>,
    pub opponent_battlers: Vec<BattlerState<P>>,
    pub turn_order: Vec<usize>,
    pub weather: Weather,
    pub terrain: Terrain,
    pub turn_count: u32,
}

The complete state of an ongoing battle.

Tracks both sides’ parties, turn order, field conditions, and turn counter. Generic over the BattleProvider that supplies the concrete type identifiers.

Fields

player_battlers: Vec<BattlerState<P>>

The player’s party (one or more battlers).

opponent_battlers: Vec<BattlerState<P>>

The opponent’s party (one or more battlers).

turn_order: Vec<usize>

Turn order — indices into the combined battler list.

weather: Weather

Current weather condition.

terrain: Terrain

Current terrain condition.

turn_count: u32

Number of turns elapsed.

Implementations

impl<P: BattleProvider + ?Sized> BattleState<P>

pub fn new( player_battlers: Vec<BattlerState<P>>, opponent_battlers: Vec<BattlerState<P>>, ) -> Self

Create a new battle state.

Examples found in repository

examples/hello_dotzuki.rs (line 518)

fn demo_battle() {
    println!("\n╔══ BATTLE ENCOUNTER ═════════════════════╗");
    let provider = HelloConfig::new();
    let warrior = provider.create_monster(Species::Warrior, 5);
    let mage = provider.create_monster(Species::Mage, 5);

    println!("║ {} (HP:{}/{}) vs {} (HP:{}/{})",
        warrior.species.name(), warrior.hp, warrior.max_hp,
        mage.species.name(), mage.hp, mage.max_hp);

    // Warrior attacks with Slash → super effective (2×) vs Mage
    let result = provider.calculate_damage(&MoveKind::Slash, &warrior, &mage, 100, false);
    println!("║ {} uses Slash! {} damage ({}x effective)",
        warrior.species.name(), result.damage, result.effectiveness);

    let mut enemy = mage.clone();
    enemy.take_damage(result.damage);
    println!("║ {} HP: {} → {}", mage.species.name(), mage.hp, enemy.hp);

    // Mage attacks with Fireball → not very effective (0.5×) vs Warrior
    let result = provider.calculate_damage(&MoveKind::Fireball, &mage, &warrior, 100, false);
    println!("║ {} uses Fireball! {} damage ({}x effective)",
        mage.species.name(), result.damage, result.effectiveness);

    let mut hero = warrior.clone();
    hero.take_damage(result.damage);
    println!("║ {} HP: {} → {}", warrior.species.name(), warrior.hp, hero.hp);

    // EffectHandler
    let mut user = warrior.clone();
    let mut target = mage.clone();
    let eff_result = HelloConfig::new().handle_effect(MoveEffect::Damage, &mut user, &mut target, &HelloConfig::new());
    println!("║ EffectHandler(Damage) → {:?}", eff_result);

    // BattleAI
    let state = BattleState::new(vec![warrior.clone()], vec![mage.clone()]);
    let ai_move = BattleAI::select_move(&HelloConfig::default(), &warrior, &state);
    println!("║ BattleAI chose: {}", ai_move.name());
    println!("╚══════════════════════════════════════════╝");
}

pub fn active_player(&self) -> Option<&BattlerState<P>>

Get a reference to the active player battler (first in party).

pub fn active_player_mut(&mut self) -> Option<&mut BattlerState<P>>

Get a mutable reference to the active player battler.

pub fn active_opponent(&self) -> Option<&BattlerState<P>>

Get a reference to the active opponent battler.

pub fn active_opponent_mut(&mut self) -> Option<&mut BattlerState<P>>

Get a mutable reference to the active opponent battler.

Trait Implementations

impl<P: BattleProvider + ?Sized> Clone for BattleState<P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: BattleProvider + ?Sized> Debug for BattleState<P>

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

Formats the value using the given formatter.