221 lines
7.2 KiB
Rust
Executable File
221 lines
7.2 KiB
Rust
Executable File
use std::ops::Deref;
|
|
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU8, Ordering};
|
|
use std::sync::Arc;
|
|
|
|
use atomig::Atomic;
|
|
use parking_lot::RwLock;
|
|
|
|
use crate::dynamic_data::models::learned_move::LearnedMove;
|
|
use crate::dynamic_data::models::pokemon::Pokemon;
|
|
use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
|
|
use crate::dynamic_data::ScriptContainer;
|
|
use crate::dynamic_data::TargetList;
|
|
use crate::static_data::{MoveData, TypeIdentifier};
|
|
use crate::{PkmnResult, PokemonError};
|
|
|
|
/// A hit data is the data for a single hit, on a single target.
|
|
#[derive(Default, Debug)]
|
|
#[cfg_attr(feature = "wasm", derive(unique_type_id_derive::UniqueTypeId))]
|
|
pub struct HitData {
|
|
/// Whether or not the hit is critical.
|
|
critical: AtomicBool,
|
|
/// The base power of the hit.
|
|
base_power: AtomicU8,
|
|
/// The type effectiveness of the hit.
|
|
effectiveness: Atomic<f32>,
|
|
/// The actual damage of the hit.
|
|
damage: AtomicU32,
|
|
/// The type id of the type used for the hit.
|
|
move_type: Atomic<TypeIdentifier>,
|
|
/// Whether or not the hit has failed.
|
|
has_failed: AtomicBool,
|
|
}
|
|
|
|
impl HitData {
|
|
/// Whether or not the hit is critical.
|
|
pub fn is_critical(&self) -> bool {
|
|
self.critical.load(Ordering::Relaxed)
|
|
}
|
|
/// The base power of the hit.
|
|
pub fn base_power(&self) -> u8 {
|
|
self.base_power.load(Ordering::Relaxed)
|
|
}
|
|
/// The type effectiveness of the hit.
|
|
pub fn effectiveness(&self) -> f32 {
|
|
self.effectiveness.load(Ordering::Relaxed)
|
|
}
|
|
/// The actual damage of the hit.
|
|
pub fn damage(&self) -> u32 {
|
|
self.damage.load(Ordering::Relaxed)
|
|
}
|
|
/// The type id of the type used for the hit.
|
|
pub fn move_type(&self) -> TypeIdentifier {
|
|
self.move_type.load(Ordering::Relaxed)
|
|
}
|
|
/// Whether or not the hit has failed.
|
|
pub fn has_failed(&self) -> bool {
|
|
self.has_failed.load(Ordering::Relaxed)
|
|
}
|
|
|
|
/// Sets whether or not the hit is critical.
|
|
pub fn set_critical(&self, value: bool) {
|
|
self.critical.store(value, Ordering::SeqCst);
|
|
}
|
|
/// Sets the base power of the hit.
|
|
pub fn set_base_power(&self, value: u8) {
|
|
self.base_power.store(value, Ordering::SeqCst);
|
|
}
|
|
/// Sets the type effectiveness of the hit.
|
|
pub fn set_effectiveness(&self, value: f32) {
|
|
self.effectiveness.store(value, Ordering::SeqCst);
|
|
}
|
|
/// Sets the actual damage of the hit.
|
|
pub fn set_damage(&self, value: u32) {
|
|
self.damage.store(value, Ordering::SeqCst);
|
|
}
|
|
/// Sets the move type id of the hit.
|
|
pub fn set_move_type(&self, value: TypeIdentifier) {
|
|
self.move_type.store(value, Ordering::SeqCst);
|
|
}
|
|
/// Marks the hit as failed.
|
|
pub fn fail(&self) {
|
|
self.has_failed.store(true, Ordering::SeqCst);
|
|
}
|
|
}
|
|
|
|
/// An executing move is the data of the move for while it is executing.
|
|
#[derive(Debug)]
|
|
#[cfg_attr(feature = "wasm", derive(unique_type_id_derive::UniqueTypeId))]
|
|
pub struct ExecutingMove {
|
|
/// The number of hits this move has.
|
|
number_of_hits: u8,
|
|
/// A list of hits for this move. For multi target multi hit moves, this stores the hits linearly,
|
|
/// for example: (target1, hit1), (target1, hit2), (target2, hit1), (target2, hit2), etc.
|
|
hits: Vec<HitData>,
|
|
/// The user of the move.
|
|
user: Arc<Pokemon>,
|
|
/// The move the user has actually chosen to do.
|
|
chosen_move: Arc<LearnedMove>,
|
|
/// The move that the user is actually going to do.
|
|
use_move: Arc<MoveData>,
|
|
/// The script of the move.
|
|
script: ScriptContainer,
|
|
/// The targets for this move.
|
|
targets: TargetList,
|
|
/// Data required for this to be a script source.
|
|
script_source_data: RwLock<ScriptSourceData>,
|
|
}
|
|
|
|
impl ExecutingMove {
|
|
/// Instantiates an executing move.
|
|
pub fn new(
|
|
targets: TargetList,
|
|
number_of_hits: u8,
|
|
user: Arc<Pokemon>,
|
|
chosen_move: Arc<LearnedMove>,
|
|
use_move: Arc<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(),
|
|
}
|
|
}
|
|
|
|
/// The number of targets this move has.
|
|
pub fn target_count(&self) -> usize {
|
|
self.targets.len()
|
|
}
|
|
/// The number of hits this move has per target.
|
|
pub fn number_of_hits(&self) -> u8 {
|
|
self.number_of_hits
|
|
}
|
|
/// The user of the move.
|
|
pub fn user(&self) -> &Arc<Pokemon> {
|
|
&self.user
|
|
}
|
|
/// The move the user has actually chosen to do.
|
|
pub fn chosen_move(&self) -> &Arc<LearnedMove> {
|
|
&self.chosen_move
|
|
}
|
|
/// The move that the user is actually going to do.
|
|
pub fn use_move(&self) -> &Arc<MoveData> {
|
|
&self.use_move
|
|
}
|
|
/// The script of the move.
|
|
pub fn script(&self) -> &ScriptContainer {
|
|
&self.script
|
|
}
|
|
|
|
/// Gets a hit data for a target, with a specific index.
|
|
pub fn get_hit_data(&self, for_target: &Pokemon, hit: u8) -> PkmnResult<&HitData> {
|
|
for (index, target) in self.targets.iter().enumerate() {
|
|
if let Some(target) = target {
|
|
if std::ptr::eq(target.deref().deref(), for_target.deref().deref()) {
|
|
let i = index * self.number_of_hits as usize + hit as usize;
|
|
return Ok(&self.hits[i]);
|
|
}
|
|
}
|
|
}
|
|
Err(PokemonError::InvalidTargetRequested)
|
|
}
|
|
|
|
/// Checks whether a Pokemon is a target for this move.
|
|
pub fn is_pokemon_target(&self, pokemon: &Arc<Pokemon>) -> bool {
|
|
for target in self.targets.iter().flatten() {
|
|
if std::ptr::eq(target.deref().deref(), pokemon.deref().deref()) {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
/// Gets the index of the hits in this move where the hits for a specific target start.
|
|
pub(crate) fn get_index_of_target(&self, for_target: &Arc<Pokemon>) -> PkmnResult<usize> {
|
|
for (index, target) in self.targets.iter().enumerate() {
|
|
if let Some(target) = target {
|
|
if std::ptr::eq(target.deref().deref(), for_target.deref().deref()) {
|
|
let i = index * self.number_of_hits as usize;
|
|
return Ok(i);
|
|
}
|
|
}
|
|
}
|
|
Err(PokemonError::InvalidTargetRequested)
|
|
}
|
|
|
|
/// Gets a hit based on its raw index.
|
|
pub(crate) fn get_hit_from_raw_index(&self, index: usize) -> &HitData {
|
|
&self.hits[index]
|
|
}
|
|
}
|
|
|
|
impl ScriptSource for ExecutingMove {
|
|
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.get_own_scripts(scripts);
|
|
}
|
|
}
|