firecore-battle 0.0.9

Pokemon battle simulation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//! Move and item execution engine

use alloc::vec::Vec;
use core::{fmt::Debug, hash::Hash};
use std::error::Error;

use rand::Rng;

use pokedex::{
    ailment::LiveAilment,
    item::Item,
    moves::Move,
    pokemon::{owned::SavedPokemon, Health},
};

use crate::{
    data::BattleData,
    moves::{damage::DamageResult, MoveCancel},
    pokemon::{
        stat::{BattleStatType, Stage},
        Indexed, PokemonIdentifier,
    },
};

pub mod pokemon;
pub use pokemon::BattlePokemon;

pub trait BattleEngine {
    // type PokemonState;

    type MoveError: Error;
    
    type ItemError: Error;

    fn execute_move<
        ID: Clone + Hash + Eq + Debug + 'static,
        R: Rng + Clone + 'static,
        PLR: Players<ID>,
    >(
        &self,
        random: &mut R,
        used_move: &Move,
        user: Indexed<ID, &BattlePokemon>,
        targeting: Option<PokemonIdentifier<ID>>,
        players: &PLR,
    ) -> Result<Vec<Indexed<ID, MoveResult>>, Self::MoveError>;

    fn execute_item<ID: PartialEq, R: Rng, PLR: Players<ID>>(
        &self,
        battle: &BattleData,
        random: &mut R,
        item: &Item,
        user: &ID,
        target: PokemonIdentifier<ID>,
        players: &mut PLR,
    ) -> Result<Vec<ItemResult>, Self::ItemError>;

    fn update(&self);
}

pub trait Players<ID: PartialEq> {
    fn create_targets<R: Rng>(
        &self,
        user: &PokemonIdentifier<ID>,
        m: &Move,
        targeting: Option<PokemonIdentifier<ID>>,
        random: &mut R,
    ) -> Vec<PokemonIdentifier<ID>>;

    fn get(&self, id: &PokemonIdentifier<ID>) -> Option<&BattlePokemon>;

    fn get_mut(&mut self, id: &PokemonIdentifier<ID>) -> Option<&mut BattlePokemon>;

    fn take(&mut self, id: &PokemonIdentifier<ID>) -> Option<BattlePokemon>;
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MoveResult {
    Damage(DamageResult<Health>),
    Heal(i16),
    Ailment(Option<LiveAilment>),
    Stat(BattleStatType, Stage),
    Cancel(MoveCancel),
    Custom,
    Miss,
    Error,
}

pub enum ItemResult {
    Catch(SavedPokemon),
}