PkmnLib_rs/src/dynamic_data/models/executing_move.rs

use crate::dynamic_data::flow::target_resolver::TargetList;
use crate::dynamic_data::models::learned_move::LearnedMove;
use crate::dynamic_data::models::pokemon::Pokemon;
use crate::dynamic_data::script_handling::script::ScriptContainer;
use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
use crate::static_data::MoveData;
use crate::{PkmnResult, PokemonError};
use parking_lot::RwLock;
use std::sync::Arc;

#[derive(Default, Debug)]
pub struct HitData {
    critical: bool,
    base_power: u8,
    effectiveness: f32,
    damage: u32,
    move_type: u8,
    has_failed: bool,
}

impl HitData {
    pub fn is_critical(&self) -> bool {
        self.critical
    }
    pub fn base_power(&self) -> u8 {
        self.base_power
    }
    pub fn effectiveness(&self) -> f32 {
        self.effectiveness
    }
    pub fn damage(&self) -> u32 {
        self.damage
    }
    pub fn move_type(&self) -> u8 {
        self.move_type
    }
    pub fn has_failed(&self) -> bool {
        self.has_failed
    }

    pub fn set_critical(&mut self, value: bool) {
        self.critical = value;
    }
    pub fn set_base_power(&mut self, value: u8) {
        self.base_power = value;
    }
    pub fn set_effectiveness(&mut self, value: f32) {
        self.effectiveness = value;
    }
    pub fn set_damage(&mut self, value: u32) {
        self.damage = value;
    }
    pub fn set_move_type(&mut self, value: u8) {
        self.move_type = value;
    }
    pub fn fail(&mut self) {
        self.has_failed = true;
    }
}

#[derive(Debug)]
pub struct ExecutingMove<'own, 'battle, 'library> {
    number_of_hits: u8,
    hits: Vec<HitData>,
    user: Arc<RwLock<Pokemon<'battle, 'library>>>,
    chosen_move: Arc<LearnedMove<'library>>,
    use_move: &'own MoveData,
    script: ScriptContainer,
    targets: &'own TargetList<'battle, 'library>,
    script_source_data: RwLock<ScriptSourceData>,
}

impl<'own, 'battle, 'library> ExecutingMove<'own, 'battle, 'library> {
    pub fn new(
        targets: &'own TargetList<'battle, 'library>,
        number_of_hits: u8,
        user: Arc<RwLock<Pokemon<'battle, 'library>>>,
        chosen_move: Arc<LearnedMove<'library>>,
        use_move: &'own MoveData,
        script: ScriptContainer,
    ) -> Self {
        let total_hits = number_of_hits as usize * targets.len();
        let mut hits = Vec::with_capacity(total_hits);
        for _i in 0..total_hits {
            hits.push(HitData::default())
        }
        Self {
            number_of_hits,
            hits,
            user,
            chosen_move,
            use_move,
            script,
            targets,
            script_source_data: Default::default(),
        }
    }
    pub fn target_count(&self) -> usize {
        self.targets.len()
    }
    pub fn number_of_hits(&self) -> u8 {
        self.number_of_hits
    }
    pub fn user(&self) -> &Arc<RwLock<Pokemon<'battle, 'library>>> {
        &self.user
    }
    pub fn chosen_move(&self) -> &Arc<LearnedMove<'library>> {
        &self.chosen_move
    }

    pub fn use_move(&self) -> &'own MoveData {
        self.use_move
    }
    pub fn script(&self) -> &ScriptContainer {
        &self.script
    }

    pub fn get_hit_data<'func>(
        &'func self,
        for_target: &'func Arc<RwLock<Pokemon<'battle, 'library>>>,
        hit: u8,
    ) -> PkmnResult<&'func HitData> {
        for (index, target) in self.targets.iter().enumerate() {
            if let Some(target) = target {
                if std::ptr::eq(target.data_ptr(), for_target.data_ptr()) {
                    let i = index * self.number_of_hits as usize + hit as usize;
                    return Ok(&self.hits[i]);
                }
            }
        }
        Err(PokemonError::InvalidTargetRequested)
    }

    pub fn is_pokemon_target(&self, pokemon: &Arc<RwLock<Pokemon<'battle, 'library>>>) -> bool {
        for target in self.targets.iter().flatten() {
            if std::ptr::eq(target.data_ptr(), pokemon.data_ptr()) {
                return true;
            }
        }
        false
    }

    pub(crate) fn get_index_of_target(
        &self,
        for_target: &Arc<RwLock<Pokemon<'battle, 'library>>>,
    ) -> PkmnResult<usize> {
        for (index, target) in self.targets.iter().enumerate() {
            if let Some(target) = target {
                if std::ptr::eq(target.data_ptr(), for_target.data_ptr()) {
                    let i = index * self.number_of_hits as usize;
                    return Ok(i);
                }
            }
        }
        Err(PokemonError::InvalidTargetRequested)
    }

    pub(crate) fn get_hit_from_raw_index(&self, index: usize) -> &HitData {
        &self.hits[index]
    }
    pub(crate) fn get_hit_from_raw_index_mut(&mut self, index: usize) -> &mut HitData {
        &mut self.hits[index]
    }
}

impl<'own, 'battle, 'library> ScriptSource<'own> for ExecutingMove<'own, 'battle, 'library> {
    fn get_script_count(&self) -> usize {
        1
    }

    fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
        &self.script_source_data
    }

    fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
        scripts.push((&self.script).into());
    }

    fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
        self.get_own_scripts(scripts);
        self.user.read().get_own_scripts(scripts);
    }
}