286 lines
9.3 KiB
Rust
286 lines
9.3 KiB
Rust
use crate::dynamic_data::choices::TurnChoice;
|
|
use crate::dynamic_data::event_hooks::event_hook::Event;
|
|
use crate::dynamic_data::models::battle::Battle;
|
|
use crate::dynamic_data::models::battle_party::BattleParty;
|
|
use crate::dynamic_data::models::pokemon::Pokemon;
|
|
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::dynamic_data::script_handling::ScriptSource;
|
|
use crate::{script_hook, PkmnResult, StringKey};
|
|
use std::ops::Deref;
|
|
use std::sync::{Arc, RwLock, Weak};
|
|
|
|
#[derive(Debug)]
|
|
pub struct BattleSide<'a> {
|
|
index: u8,
|
|
pokemon_per_side: u8,
|
|
pokemon: Vec<Option<Arc<RwLock<Pokemon<'a>>>>>,
|
|
choices: Vec<Option<Arc<TurnChoice<'a>>>>,
|
|
fillable_slots: Vec<bool>,
|
|
choices_set: u8,
|
|
battle: Weak<RwLock<Battle<'a>>>,
|
|
has_fled_battle: bool,
|
|
volatile_scripts: Arc<RwLock<ScriptSet>>,
|
|
}
|
|
|
|
impl<'a> BattleSide<'a> {
|
|
pub fn new(index: u8, battle: Weak<RwLock<Battle<'a>>>, pokemon_per_side: u8) -> Self {
|
|
let mut pokemon = Vec::with_capacity(pokemon_per_side as usize);
|
|
let mut choices = Vec::with_capacity(pokemon_per_side as usize);
|
|
let mut fillable_slots = Vec::with_capacity(pokemon_per_side as usize);
|
|
|
|
for i in 0..pokemon_per_side {
|
|
pokemon[i as usize] = None;
|
|
choices[i as usize] = None;
|
|
fillable_slots[i as usize] = true;
|
|
}
|
|
|
|
Self {
|
|
index,
|
|
pokemon_per_side,
|
|
pokemon,
|
|
choices,
|
|
fillable_slots,
|
|
choices_set: 0,
|
|
battle,
|
|
has_fled_battle: false,
|
|
volatile_scripts: Default::default(),
|
|
}
|
|
}
|
|
pub fn index(&self) -> u8 {
|
|
self.index
|
|
}
|
|
pub fn pokemon_per_side(&self) -> u8 {
|
|
self.pokemon_per_side
|
|
}
|
|
pub fn pokemon(&self) -> &Vec<Option<Arc<RwLock<Pokemon<'a>>>>> {
|
|
&self.pokemon
|
|
}
|
|
pub fn choices(&self) -> &Vec<Option<Arc<TurnChoice<'a>>>> {
|
|
&self.choices
|
|
}
|
|
pub fn fillable_slots(&self) -> &Vec<bool> {
|
|
&self.fillable_slots
|
|
}
|
|
pub fn choices_set(&self) -> u8 {
|
|
self.choices_set
|
|
}
|
|
pub fn battle(&self) -> &Weak<RwLock<Battle<'a>>> {
|
|
&self.battle
|
|
}
|
|
pub fn has_fled_battle(&self) -> bool {
|
|
self.has_fled_battle
|
|
}
|
|
pub fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>> {
|
|
&self.volatile_scripts
|
|
}
|
|
|
|
pub fn all_choices_set(&self) -> bool {
|
|
self.choices_set == self.pokemon_per_side
|
|
}
|
|
|
|
/// Returns true if there are slots that need to be filled with a new pokemon, that have parties
|
|
/// responsible for them. Returns false if all slots are filled with usable pokemon, or slots are
|
|
/// empty, but can't be filled by any party anymore.
|
|
pub fn all_slots_filled(&self) -> bool {
|
|
for (i, pokemon) in self.pokemon.iter().enumerate() {
|
|
if (!pokemon.is_none() || !pokemon.as_ref().unwrap().read().unwrap().is_usable())
|
|
&& self
|
|
.battle
|
|
.upgrade()
|
|
.unwrap()
|
|
.read()
|
|
.unwrap()
|
|
.can_slot_be_filled(self.index, i as u8)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
|
|
pub fn set_choice(&mut self, choice: TurnChoice<'a>) {
|
|
for (index, pokemon_slot) in self.pokemon.iter().enumerate() {
|
|
if let Some(pokemon) = pokemon_slot {
|
|
if pokemon.read().unwrap().unique_identifier() == choice.user().unique_identifier()
|
|
{
|
|
self.choices[index] = Some(Arc::new(choice));
|
|
self.choices_set += 1;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn force_clear_pokemon(&mut self, index: u8) {
|
|
self.pokemon[index as usize] = None;
|
|
}
|
|
|
|
pub fn set_pokemon(&mut self, index: u8, pokemon: Option<Arc<RwLock<Pokemon<'a>>>>) {
|
|
let old = &mut self.pokemon[index as usize];
|
|
if let Some(old_pokemon) = old {
|
|
let mut p = old_pokemon.write().unwrap();
|
|
script_hook!(on_remove, p,);
|
|
p.set_on_battlefield(false);
|
|
}
|
|
self.pokemon[index as usize] = pokemon;
|
|
let pokemon = &self.pokemon[index as usize];
|
|
if let Some(pokemon_mutex) = pokemon {
|
|
let mut pokemon = pokemon_mutex.write().unwrap();
|
|
pokemon.set_battle_data(self.battle.clone(), self.index);
|
|
pokemon.set_on_battlefield(true);
|
|
pokemon.set_battle_index(index);
|
|
|
|
let battle = self.battle.upgrade().unwrap();
|
|
let battle = battle.read().unwrap();
|
|
for side in battle.sides() {
|
|
if side.index() == self.index {
|
|
continue;
|
|
}
|
|
for opponent_mutex in side.pokemon().iter().flatten() {
|
|
let mut opponent = opponent_mutex.write().unwrap();
|
|
opponent.mark_opponent_as_seen(Arc::downgrade(pokemon_mutex));
|
|
pokemon.mark_opponent_as_seen(Arc::downgrade(opponent_mutex));
|
|
}
|
|
}
|
|
battle.event_hook().trigger(Event::Switch {
|
|
side_index: self.index,
|
|
index,
|
|
pokemon: Some(&pokemon),
|
|
});
|
|
script_hook!(on_switch_in, pokemon, &pokemon);
|
|
} else {
|
|
let battle = self.battle.upgrade().unwrap();
|
|
let battle = battle.read().unwrap();
|
|
battle.event_hook().trigger(Event::Switch {
|
|
side_index: self.index,
|
|
index,
|
|
pokemon: None,
|
|
});
|
|
}
|
|
}
|
|
|
|
pub fn is_pokemon_on_side(&self, pokemon: Arc<Pokemon<'a>>) -> bool {
|
|
for p in self.pokemon.iter().flatten() {
|
|
if p.read().unwrap().unique_identifier() == pokemon.unique_identifier() {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
pub fn mark_slot_as_unfillable(&mut self, pokemon: &Pokemon<'a>) {
|
|
for (i, slot) in self.pokemon.iter().enumerate() {
|
|
if let Some(p) = slot {
|
|
if p.read().unwrap().deref() as *const Pokemon == pokemon as *const Pokemon {
|
|
self.fillable_slots[i] = false;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn is_slot_unfillable(&self, pokemon: Arc<Pokemon<'a>>) -> bool {
|
|
for (i, slot) in self.pokemon.iter().enumerate() {
|
|
if let Some(p) = slot {
|
|
if p.read().unwrap().unique_identifier() == pokemon.unique_identifier() {
|
|
return self.fillable_slots[i];
|
|
}
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
pub fn is_defeated(&self) -> bool {
|
|
for fillable_slot in &self.fillable_slots {
|
|
if *fillable_slot {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
|
|
pub fn has_fled(&self) -> bool {
|
|
self.has_fled_battle
|
|
}
|
|
|
|
pub fn mark_as_fled(&mut self) {
|
|
self.has_fled_battle = true;
|
|
}
|
|
|
|
pub fn get_random_creature_index(&self) -> u8 {
|
|
// TODO: Consider adding parameter to only get index for available creatures.
|
|
self.battle
|
|
.upgrade()
|
|
.unwrap()
|
|
.read()
|
|
.unwrap()
|
|
.random()
|
|
.get_max(self.pokemon_per_side as i32) as u8
|
|
}
|
|
|
|
pub fn swap_positions(&mut self, a: u8, b: u8) -> bool {
|
|
// If out of range, don't allow swapping.
|
|
if a >= self.pokemon_per_side || b >= self.pokemon_per_side {
|
|
return false;
|
|
}
|
|
// If the two indices are the same, don't allow swapping.
|
|
if a == b {
|
|
return false;
|
|
}
|
|
|
|
let battle = self.battle.upgrade().unwrap();
|
|
let battle = battle.read().unwrap();
|
|
// Fetch parties for the two indices.
|
|
let mut party_a = None;
|
|
let mut party_b = None;
|
|
for party in battle.parties() {
|
|
if party.is_responsible_for_index(self.index, a) {
|
|
party_a = Some(party);
|
|
}
|
|
if party.is_responsible_for_index(self.index, b) {
|
|
party_b = Some(party);
|
|
}
|
|
}
|
|
// If either of the parties does not exist, fail.
|
|
if party_a.is_none() || party_b.is_none() {
|
|
return false;
|
|
}
|
|
// Don't allow swapping if different parties are responsible for the indices.
|
|
if party_a.unwrap() as *const BattleParty != party_b.unwrap() as *const BattleParty {
|
|
return false;
|
|
}
|
|
|
|
self.pokemon.swap(a as usize, b as usize);
|
|
battle.event_hook().trigger(Event::Swap {
|
|
side_index: self.index,
|
|
index_a: a,
|
|
index_b: b,
|
|
});
|
|
true
|
|
}
|
|
}
|
|
|
|
impl<'a> VolatileScripts<'a> for BattleSide<'a> {
|
|
fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>> {
|
|
&self.volatile_scripts
|
|
}
|
|
|
|
fn load_volatile_script(&self, key: &StringKey) -> PkmnResult<Option<Box<dyn Script>>> {
|
|
self.battle
|
|
.upgrade()
|
|
.unwrap()
|
|
.read()
|
|
.unwrap()
|
|
.library()
|
|
.load_script(crate::ScriptCategory::Side, key)
|
|
}
|
|
}
|
|
|
|
impl<'a> ScriptSource for BattleSide<'a> {
|
|
fn get_script_count(&self) {
|
|
todo!()
|
|
}
|
|
}
|