131 lines
3.8 KiB
Rust
131 lines
3.8 KiB
Rust
use crate::dynamic_data::event_hooks::event_hook::EventHook;
|
|
use crate::dynamic_data::flow::choice_queue::ChoiceQueue;
|
|
use crate::dynamic_data::history::history_holder::HistoryHolder;
|
|
use crate::dynamic_data::libraries::dynamic_library::DynamicLibrary;
|
|
use crate::dynamic_data::models::battle_party::BattleParty;
|
|
use crate::dynamic_data::models::battle_random::BattleRandom;
|
|
use crate::dynamic_data::models::battle_result::BattleResult;
|
|
use crate::dynamic_data::models::battle_side::BattleSide;
|
|
use crate::dynamic_data::script_handling::script::Script;
|
|
use crate::dynamic_data::script_handling::script_set::ScriptSet;
|
|
use crate::dynamic_data::script_handling::volatile_scripts::VolatileScripts;
|
|
use crate::{PkmnResult, ScriptCategory};
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
#[derive(Debug)]
|
|
pub struct Battle<'a> {
|
|
library: &'a DynamicLibrary<'a>,
|
|
parties: Vec<BattleParty<'a>>,
|
|
can_flee: bool,
|
|
number_of_sides: u8,
|
|
pokemon_per_side: u8,
|
|
sides: Vec<BattleSide<'a>>,
|
|
random: BattleRandom,
|
|
choice_queue: ChoiceQueue,
|
|
has_ended: bool,
|
|
result: BattleResult,
|
|
event_hook: EventHook,
|
|
history_holder: Box<HistoryHolder>,
|
|
current_turn: u32,
|
|
volatile: Arc<RwLock<ScriptSet>>,
|
|
last_turn_time: i64,
|
|
}
|
|
|
|
impl<'a> Battle<'a> {
|
|
pub fn new(
|
|
library: &'a DynamicLibrary<'a>,
|
|
parties: Vec<BattleParty<'a>>,
|
|
can_flee: bool,
|
|
number_of_sides: u8,
|
|
pokemon_per_side: u8,
|
|
random_seed: Option<u128>,
|
|
) -> Arc<RwLock<Self>> {
|
|
let random = if let Some(seed) = random_seed {
|
|
BattleRandom::new_with_seed(seed)
|
|
} else {
|
|
BattleRandom::default()
|
|
};
|
|
let sides = Vec::with_capacity(number_of_sides as usize);
|
|
let battle = Arc::new(RwLock::new(Self {
|
|
library,
|
|
parties,
|
|
can_flee,
|
|
number_of_sides,
|
|
pokemon_per_side,
|
|
sides,
|
|
random,
|
|
choice_queue: ChoiceQueue {},
|
|
has_ended: false,
|
|
result: BattleResult::Inconclusive,
|
|
event_hook: Default::default(),
|
|
history_holder: Box::new(HistoryHolder {}),
|
|
current_turn: 0,
|
|
volatile: Default::default(),
|
|
last_turn_time: 0,
|
|
}));
|
|
|
|
for i in 0..number_of_sides {
|
|
battle.write().unwrap().sides[i as usize] =
|
|
BattleSide::new(i, Arc::downgrade(&battle), pokemon_per_side);
|
|
}
|
|
battle
|
|
}
|
|
|
|
pub fn library(&self) -> &'a DynamicLibrary<'a> {
|
|
self.library
|
|
}
|
|
pub fn parties(&self) -> &Vec<BattleParty<'a>> {
|
|
&self.parties
|
|
}
|
|
pub fn can_flee(&self) -> bool {
|
|
self.can_flee
|
|
}
|
|
pub fn number_of_sides(&self) -> u8 {
|
|
self.number_of_sides
|
|
}
|
|
pub fn pokemon_per_side(&self) -> u8 {
|
|
self.pokemon_per_side
|
|
}
|
|
pub fn sides(&self) -> &Vec<BattleSide<'a>> {
|
|
&self.sides
|
|
}
|
|
pub fn random(&self) -> &BattleRandom {
|
|
&self.random
|
|
}
|
|
pub fn has_ended(&self) -> bool {
|
|
self.has_ended
|
|
}
|
|
pub fn result(&self) -> BattleResult {
|
|
self.result
|
|
}
|
|
pub fn event_hook(&self) -> &EventHook {
|
|
&self.event_hook
|
|
}
|
|
pub fn history_holder(&self) -> &Box<HistoryHolder> {
|
|
&self.history_holder
|
|
}
|
|
pub fn current_turn(&self) -> u32 {
|
|
self.current_turn
|
|
}
|
|
pub fn last_turn_time(&self) -> i64 {
|
|
self.last_turn_time
|
|
}
|
|
pub fn choice_queue(&self) -> &ChoiceQueue {
|
|
&self.choice_queue
|
|
}
|
|
|
|
pub fn can_slot_be_filled(&self) -> bool {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl<'a> VolatileScripts<'a> for Battle<'a> {
|
|
fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>> {
|
|
&self.volatile
|
|
}
|
|
|
|
fn load_volatile_script(&self, key: &str) -> PkmnResult<Box<dyn Script>> {
|
|
self.library.load_script(ScriptCategory::Battle, key)
|
|
}
|
|
}
|