Deukhoofd/PkmnLib_rs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Major rework of extern ref system for WASM, fixes most possible panics in WASM handling
All checks were successful
continuous-integration/drone Build is passing
Details

Browse Source
This commit is contained in:
Deukhoofd
2023-06-22 15:43:41 +02:00
parent 6a2353df4c
commit 46195d3042
71 changed files with 2142 additions and 1488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
src/dynamic_data/models/battle.rs
View File

@@ -1,6 +1,7 @@
use std::ffi::c_void;
use std::ops::{Deref, DerefMut};
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::Arc;
use std::sync::{Arc, Weak};
use anyhow::Result;
use anyhow_ext::anyhow;
@@ -22,15 +23,15 @@ use crate::dynamic_data::{ChoiceQueue, ScriptContainer};
use crate::dynamic_data::{ScriptCategory, ScriptSource, ScriptSourceData};
use crate::{script_hook, PkmnError, StringKey, ValueIdentifiable, ValueIdentifier, VecExt};
/// A pokemon battle, with any amount of sides and pokemon per side.
/// The data of a battle.
#[derive(Debug)]
pub struct Battle {
struct BattleData {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
/// The library the battle uses for handling.
library: Arc<dyn DynamicLibrary>,
/// A list of all different parties in the battle.
parties: Vec<BattleParty>,
parties: Vec<Arc<BattleParty>>,
/// Whether or not Pokemon can flee from the battle.
can_flee: bool,
/// The number of sides in the battle. Typically 2.
@@ -40,9 +41,9 @@ pub struct Battle {
/// A list of all sides in the battle.
sides: Vec<BattleSide>,
/// The RNG used for the battle.
random: BattleRandom,
random: Arc<BattleRandom>,
/// A queue of the yet to be executed choices in a turn.
current_turn_queue: RwLock<Option<ChoiceQueue>>,
current_turn_queue: RwLock<Option<Arc<ChoiceQueue>>>,
/// Whether or not the battle has ended.
has_ended: AtomicBool,
/// The eventual result of the battle. Inconclusive until the battle is ended.
@@ -61,16 +62,30 @@ pub struct Battle {
script_source_data: RwLock<ScriptSourceData>,
}
/// A pokemon battle, with any amount of sides and pokemon per side.
#[derive(Clone, Debug)]
pub struct Battle {
/// The actual data of the battle.
data: Arc<BattleData>,
}
/// A weak reference to a battle.
#[derive(Clone, Debug, Default)]
pub struct WeakBattleReference {
/// A weak reference to the actual data of the battle.
data: Weak<BattleData>,
}
impl Battle {
/// Initializes a new battle.
pub fn new(
library: Arc<dyn DynamicLibrary>,
parties: Vec<BattleParty>,
parties: Vec<Arc<BattleParty>>,
can_flee: bool,
number_of_sides: u8,
pokemon_per_side: u8,
random_seed: Option<u128>,
) -> Arc<Self> {
) -> Self {
// If no seed was passed, we use the current time as seed for the RNG, otherwise we use the
// seed.
let random = if let Some(seed) = random_seed {
@@ -83,7 +98,7 @@ impl Battle {
sides.push(BattleSide::new(i, pokemon_per_side));
}
let battle = Self {
let battle = BattleData {
identifier: Default::default(),
library,
parties,
@@ -91,7 +106,7 @@ impl Battle {
number_of_sides,
pokemon_per_side,
sides,
random,
random: Arc::new(random),
current_turn_queue: RwLock::new(None),
has_ended: AtomicBool::new(false),
result: RwLock::new(BattleResult::Inconclusive),
@@ -104,73 +119,77 @@ impl Battle {
};
let battle_arc = Arc::new(battle);
let battle_ptr = Arc::as_ptr(&battle_arc) as *mut Battle;
unsafe {
for side in &mut battle_ptr.as_mut().unwrap().sides {
side.set_battle(Arc::downgrade(&battle_arc));
}
let battle = Self { data: battle_arc };
for side in &battle.data.sides {
side.set_battle(battle.weak());
}
battle_arc
battle
}
/// Returns a weak reference to the battle.
pub fn weak(&self) -> WeakBattleReference {
WeakBattleReference {
data: Arc::downgrade(&self.data),
}
}
/// The library the battle uses for handling.
pub fn library(&self) -> &Arc<dyn DynamicLibrary> {
&self.library
&self.data.library
}
/// A list of all different parties in the battle.
pub fn parties(&self) -> &Vec<BattleParty> {
&self.parties
pub fn parties(&self) -> &Vec<Arc<BattleParty>> {
&self.data.parties
}
/// Whether or not Pokemon can flee from the battle.
pub fn can_flee(&self) -> bool {
self.can_flee
self.data.can_flee
}
/// The number of sides in the battle. Typically 2.
pub fn number_of_sides(&self) -> u8 {
self.number_of_sides
self.data.number_of_sides
}
/// The number of Pokemon that can be on each side.
pub fn pokemon_per_side(&self) -> u8 {
self.pokemon_per_side
self.data.pokemon_per_side
}
/// A list of all sides in the battle.
pub fn sides(&self) -> &Vec<BattleSide> {
&self.sides
&self.data.sides
}
/// The RNG used for the battle.
pub fn random(&self) -> &BattleRandom {
&self.random
pub fn random(&self) -> &Arc<BattleRandom> {
&self.data.random
}
/// Whether or not the battle has ended.
pub fn has_ended(&self) -> bool {
self.has_ended.load(Ordering::Relaxed)
self.data.has_ended.load(Ordering::Relaxed)
}
/// The eventual result of the battle. Inconclusive until the battle is ended.
pub fn result(&self) -> BattleResult {
*self.result.read()
*self.data.result.read()
}
/// The handler to send all events to.
pub fn event_hook(&self) -> &EventHook {
&self.event_hook
&self.data.event_hook
}
/// The index of the current turn. 0 until all choices
pub fn current_turn(&self) -> u32 {
self.current_turn.load(Ordering::Relaxed)
self.data.current_turn.load(Ordering::Relaxed)
}
/// The time in nanoseconds the last turn took to run. Defaults to 0.
pub fn last_turn_time(&self) -> u64 {
self.last_turn_time.load(Ordering::Relaxed)
self.data.last_turn_time.load(Ordering::Relaxed)
}
/// A queue of the yet to be executed choices in a turn.
pub fn current_turn_queue(&self) -> &RwLock<Option<ChoiceQueue>> {
&self.current_turn_queue
pub fn current_turn_queue(&self) -> &RwLock<Option<Arc<ChoiceQueue>>> {
&self.data.current_turn_queue
}
/// Get a Pokemon on the battlefield, on a specific side and an index on that side.
pub fn get_pokemon(&self, side: u8, index: u8) -> Option<Arc<Pokemon>> {
let side = self.sides.get(side as usize);
pub fn get_pokemon(&self, side: u8, index: u8) -> Option<Pokemon> {
let side = self.data.sides.get(side as usize);
let pokemon_read_lock = side?.pokemon();
let pokemon = pokemon_read_lock.get(index as usize);
pokemon?.clone()
@@ -180,7 +199,7 @@ impl Battle {
/// for that slot, or a party is responsible, but has no remaining Pokemon to throw out anymore,
/// this returns false.
pub fn can_slot_be_filled(&self, side: u8, index: u8) -> bool {
for party in &self.parties {
for party in &self.data.parties {
if party.is_responsible_for_index(side, index) && party.has_pokemon_not_in_field() {
return true;
}
@@ -197,12 +216,12 @@ impl Battle {
}
let mut surviving_side_exists = false;
let mut winning_side = None;
for (side_index, side) in self.sides.iter().enumerate() {
for (side_index, side) in self.data.sides.iter().enumerate() {
// If any side has fled, the battle end.
if side.has_fled_battle() {
let mut w = self.result.write();
let mut w = self.data.result.write();
*w = BattleResult::Inconclusive;
self.has_ended.store(true, Ordering::SeqCst);
self.data.has_ended.store(true, Ordering::SeqCst);
return Ok(());
}
// If the side is not defeated
@@ -217,15 +236,15 @@ impl Battle {
}
// Everyone died :(
if !surviving_side_exists {
let mut w = self.result.write();
let mut w = self.data.result.write();
*w = BattleResult::Inconclusive;
}
// Someone survived, they won!
else {
let mut w = self.result.write();
let mut w = self.data.result.write();
*w = BattleResult::Conclusive(winning_side.ok_or(anyhow!("Winning side was not set"))?);
}
self.has_ended.store(true, Ordering::SeqCst);
self.data.has_ended.store(true, Ordering::SeqCst);
Ok(())
}
@@ -263,7 +282,7 @@ impl Battle {
let side = choice.user().get_battle_side_index();
match side {
Some(side) => {
self.sides.get_res(side as usize)?.set_choice(choice)?;
self.data.sides.get_res(side as usize)?.set_choice(choice)?;
self.check_choices_set_and_run()?;
Ok(true)
}
@@ -274,7 +293,7 @@ impl Battle {
/// Checks to see whether all Pokemon on the field have set their choices. If so, we then run
/// the turn.
fn check_choices_set_and_run(&self) -> Result<()> {
for side in &self.sides {
for side in &self.data.sides {
if !side.all_choices_set() {
return Ok(());
}
@@ -283,20 +302,19 @@ impl Battle {
}
}
let start_time = chrono::Utc::now();
let mut choices = Vec::with_capacity(self.number_of_sides as usize * self.pokemon_per_side as usize);
for side in &self.sides {
let mut choices = Vec::with_capacity(self.data.number_of_sides as usize * self.data.pokemon_per_side as usize);
for side in &self.data.sides {
let mut side_choices = side.choices().write();
for choice_opt in side_choices.deref_mut() {
let mut choice = choice_opt
let choice = choice_opt
.as_mut()
.ok_or(anyhow!("Choice was none, but all choices were set? Logic error."))?;
let c = choice.deref();
if let TurnChoice::Move(data) = c {
if let TurnChoice::Move(data) = choice.clone().deref() {
let mut change_priority = data.priority();
script_hook!(change_priority, c, c, &mut change_priority);
script_hook!(change_priority, choice, choice, &mut change_priority);
if change_priority != data.priority() {
if let TurnChoice::Move(data) = choice.deref_mut() {
*data.priority_mut() = change_priority;
if let TurnChoice::Move(data) = choice.clone().deref() {
data.set_priority(change_priority);
}
}
}
@@ -304,31 +322,34 @@ impl Battle {
let mut speed = choice.user().boosted_stats().speed();
let c = choice.deref();
script_hook!(change_speed, c, c, &mut speed);
*choice.speed_mut() = speed;
choice.set_speed(speed);
choice.set_random_value(self.random.get()? as u32);
choice.set_random_value(self.data.random.get()? as u32);
choices.push(choice_opt.take());
}
// Drop the lock guard, as we need to write into it in reset_choices.
drop(side_choices);
side.reset_choices();
}
self.current_turn.fetch_add(1, Ordering::SeqCst);
self.data.current_turn.fetch_add(1, Ordering::SeqCst);
self.current_turn_queue.write().replace(ChoiceQueue::new(choices));
self.data
.current_turn_queue
.write()
.replace(Arc::new(ChoiceQueue::new(choices)));
{
self.run_turn()?;
}
self.current_turn_queue.write().take();
self.event_hook.trigger(Event::EndTurn);
self.data.current_turn_queue.write().take();
self.data.event_hook.trigger(Event::EndTurn);
let end_time = chrono::Utc::now();
let time = end_time - start_time;
match time.num_nanoseconds() {
None => {}
Some(v) => {
self.last_turn_time.store(v as u64, Ordering::SeqCst);
self.data.last_turn_time.store(v as u64, Ordering::SeqCst);
}
}
Ok(())
@@ -341,16 +362,16 @@ impl Battle {
.library()
.load_script(self.into(), ScriptCategory::Weather, &weather)?
.ok_or(anyhow!("Couldn't find weather script by name {}", weather))?;
self.weather.set(script);
self.data.weather.set(script);
} else {
self.weather.clear();
self.data.weather.clear();
}
Ok(())
}
/// Gets the current weather of the battle. If no weather is present, this returns None.
pub fn weather_name(&self) -> Result<Option<StringKey>> {
if let Some(script) = self.weather.get() {
if let Some(script) = self.data.weather.get() {
let lock = script.read();
Ok(Some(
lock.as_ref().ok_or(PkmnError::UnableToAcquireLock)?.name()?.clone(),
@@ -361,13 +382,38 @@ impl Battle {
}
}
impl WeakBattleReference {
/// Attempts to upgrade the weak reference to a strong reference. If the strong reference has
/// been dropped, this returns None.
pub fn upgrade(&self) -> Option<Battle> {
self.data.upgrade().map(|battle| Battle { data: battle })
}
/// Gets the inner pointer to the reference counted data.
pub(crate) fn as_ptr(&self) -> *const c_void {
self.data.as_ptr() as *const c_void
}
}
unsafe impl Send for WeakBattleReference {}
unsafe impl Sync for WeakBattleReference {}
impl PartialEq for WeakBattleReference {
fn eq(&self, other: &Self) -> bool {
self.data.ptr_eq(&other.data)
}
}
impl Eq for WeakBattleReference {}
impl VolatileScriptsOwner for Battle {
fn volatile_scripts(&self) -> &Arc<ScriptSet> {
&self.volatile_scripts
&self.data.volatile_scripts
}
fn load_volatile_script(&self, key: &StringKey) -> Result<Option<Arc<dyn Script>>> {
self.library.load_script(self.into(), ScriptCategory::Battle, key)
self.data.library.load_script(self.into(), ScriptCategory::Battle, key)
}
}
@@ -377,12 +423,12 @@ impl ScriptSource for Battle {
}
fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
&self.script_source_data
&self.data.script_source_data
}
fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
scripts.push((&self.weather).into());
scripts.push((&self.volatile_scripts).into());
scripts.push((&self.data.weather).into());
scripts.push((&self.data.volatile_scripts).into());
}
fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) -> Result<()> {
@@ -393,7 +439,7 @@ impl ScriptSource for Battle {
impl ValueIdentifiable for Battle {
fn value_identifier(&self) -> ValueIdentifier {
self.identifier
self.data.identifier
}
}

2
src/dynamic_data/models/battle_party.rs
View File

@@ -49,7 +49,7 @@ impl BattleParty {
}
/// Gets a Pokemon at an index.
pub fn get_pokemon(&self, index: usize) -> Option<Arc<Pokemon>> {
pub fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
self.party.at(index)
}

4
src/dynamic_data/models/battle_random.rs
View File

@@ -60,8 +60,8 @@ impl BattleRandom {
pub fn effect_chance(
&self,
mut chance: f32,
executing_move: &ExecutingMove,
target: &Arc<Pokemon>,
executing_move: &Arc<ExecutingMove>,
target: &Pokemon,
hit_number: u8,
) -> Result<bool> {
script_hook!(

200
src/dynamic_data/models/battle_side.rs
View File

@@ -1,3 +1,4 @@
use std::ffi::c_void;
use std::ops::Deref;
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
use std::sync::{Arc, Weak};
@@ -11,14 +12,14 @@ use crate::dynamic_data::event_hooks::Event;
use crate::dynamic_data::models::battle::Battle;
use crate::dynamic_data::models::pokemon::Pokemon;
use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
use crate::dynamic_data::Script;
use crate::dynamic_data::ScriptSet;
use crate::dynamic_data::VolatileScriptsOwner;
use crate::dynamic_data::{Script, WeakBattleReference};
use crate::{script_hook, StringKey, ValueIdentifiable, ValueIdentifier, VecExt};
/// A side on a battle.
/// The data that is stored for a battle side.
#[derive(Debug)]
pub struct BattleSide {
struct BattleSideData {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
/// The index of the side on the battle.
@@ -26,18 +27,18 @@ pub struct BattleSide {
/// The number of Pokemon that can be on the side.
pokemon_per_side: u8,
/// A list of pokemon currently on the battlefield.
pokemon: RwLock<Vec<Option<Arc<Pokemon>>>>,
pokemon: RwLock<Vec<Option<Pokemon>>>,
/// The currently set choices for all Pokemon on the battlefield. Cleared when the turn starts.
choices: RwLock<Vec<Option<TurnChoice>>>,
choices: RwLock<Vec<Option<Arc<TurnChoice>>>>,
/// The slots on the side that can still be filled. Once all slots are set to false, this side
/// has lost the battle.
fillable_slots: Vec<AtomicBool>,
/// The number of choices that are set.
choices_set: AtomicU8,
/// A reference to the battle we're part of.
battle: Weak<Battle>,
battle: WeakBattleReference,
/// Whether or not this side has fled.
has_fled_battle: bool,
has_fled_battle: AtomicBool,
/// The volatile scripts that are attached to the side.
volatile_scripts: Arc<ScriptSet>,
@@ -45,6 +46,20 @@ pub struct BattleSide {
script_source_data: RwLock<ScriptSourceData>,
}
/// A side on a battle.
#[derive(Debug)]
pub struct BattleSide {
/// The data that is stored for this side.
data: Arc<BattleSideData>,
}
/// A non owning reference to a battle side.
#[derive(Debug, Clone)]
pub struct WeakBattleSideReference {
/// A weak reference to the data of the battle side.
data: Weak<BattleSideData>,
}
impl BattleSide {
/// Instantiates a battle side.
pub fn new(index: u8, pokemon_per_side: u8) -> Self {
@@ -61,83 +76,92 @@ impl BattleSide {
let pokemon = RwLock::new(pokemon);
Self {
identifier: Default::default(),
index,
pokemon_per_side,
pokemon,
choices,
fillable_slots,
choices_set: AtomicU8::new(0),
battle: Weak::new(),
has_fled_battle: false,
volatile_scripts: Default::default(),
script_source_data: Default::default(),
data: Arc::new(BattleSideData {
identifier: Default::default(),
index,
pokemon_per_side,
pokemon,
choices,
fillable_slots,
choices_set: AtomicU8::new(0),
battle: WeakBattleReference::default(),
has_fled_battle: AtomicBool::new(false),
volatile_scripts: Default::default(),
script_source_data: Default::default(),
}),
}
}
/// Set the battle this side belongs to.
pub(crate) fn set_battle(&mut self, battle: Weak<Battle>) {
self.battle = battle;
pub(crate) fn set_battle(&self, battle: WeakBattleReference) {
#[allow(clippy::unwrap_used)] // Can only be Some()
unsafe {
(self.data.deref() as *const BattleSideData as *mut BattleSideData)
.as_mut()
.unwrap()
.battle = battle;
}
}
/// The index of the side on the battle.
pub fn index(&self) -> u8 {
self.index
self.data.index
}
/// The number of Pokemon that can be on the side.
pub fn pokemon_per_side(&self) -> u8 {
self.pokemon_per_side
self.data.pokemon_per_side
}
/// A list of pokemon currently on the battlefield.
pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Arc<Pokemon>>>> {
self.pokemon.read()
pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Pokemon>>> {
self.data.pokemon.read()
}
/// The currently set choices for all Pokemon on the battlefield. Cleared when the turn starts.
pub fn choices(&self) -> &RwLock<Vec<Option<TurnChoice>>> {
&self.choices
pub fn choices(&self) -> &RwLock<Vec<Option<Arc<TurnChoice>>>> {
&self.data.choices
}
/// The slots on the side that can still be filled. Once all slots are set to false, this side
/// has lost the battle.
pub fn fillable_slots(&self) -> &Vec<AtomicBool> {
&self.fillable_slots
&self.data.fillable_slots
}
/// The number of choices that are set.
pub fn choices_set(&self) -> u8 {
self.choices_set.load(Ordering::SeqCst)
self.data.choices_set.load(Ordering::SeqCst)
}
/// A reference to the battle we're part of.
pub fn battle(&self) -> Result<Arc<Battle>> {
self.battle
pub fn battle(&self) -> Result<Battle> {
self.data
.battle
.upgrade()
.ok_or(anyhow!("Battle was not set, but requested"))
}
/// Whether or not this side has fled.
pub fn has_fled_battle(&self) -> bool {
self.has_fled_battle
self.data.has_fled_battle.load(Ordering::SeqCst)
}
/// The volatile scripts that are attached to the side.
pub fn volatile_scripts(&self) -> &Arc<ScriptSet> {
&self.volatile_scripts
&self.data.volatile_scripts
}
/// Whether every Pokemon on this side has its choices
pub fn all_choices_set(&self) -> bool {
self.choices_set() == self.pokemon_per_side
self.choices_set() == self.data.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) -> Result<bool> {
for (i, pokemon) in self.pokemon.read().iter().enumerate() {
for (i, pokemon) in self.data.pokemon.read().iter().enumerate() {
match pokemon {
Some(pokemon) => {
if !pokemon.is_usable() && self.battle()?.can_slot_be_filled(self.index, i as u8) {
if !pokemon.is_usable() && self.battle()?.can_slot_be_filled(self.data.index, i as u8) {
return Ok(false);
}
}
None => {
if self.battle()?.can_slot_be_filled(self.index, i as u8) {
if self.battle()?.can_slot_be_filled(self.data.index, i as u8) {
return Ok(false);
}
}
@@ -148,11 +172,11 @@ impl BattleSide {
/// Sets a choice for a Pokemon on this side.
pub(crate) fn set_choice(&self, choice: TurnChoice) -> Result<()> {
for (index, pokemon_slot) in self.pokemon.read().iter().enumerate() {
for (index, pokemon_slot) in self.data.pokemon.read().iter().enumerate() {
if let Some(pokemon) = pokemon_slot {
if std::ptr::eq(pokemon.deref(), choice.user().deref()) {
self.choices.write().get_mut_res(index)?.replace(choice);
self.choices_set.fetch_add(1, Ordering::SeqCst);
if Pokemon::eq(pokemon, choice.user()) {
self.data.choices.write().get_mut_res(index)?.replace(choice.into());
self.data.choices_set.fetch_add(1, Ordering::SeqCst);
return Ok(());
}
}
@@ -162,21 +186,21 @@ impl BattleSide {
/// Resets all choices on this side.
pub fn reset_choices(&self) {
let len = self.choices.read().len();
let len = self.data.choices.read().len();
for i in 0..len {
self.choices.write().get_mut(i).take();
self.data.choices.write().get_mut(i).take();
}
}
/// Forcibly removes a Pokemon from the field.
pub fn force_clear_pokemon(&mut self, index: u8) {
self.pokemon.write().get_mut(index as usize).take();
self.data.pokemon.write().get_mut(index as usize).take();
}
/// Switches out a spot on the field for a different Pokemon.
pub fn set_pokemon(&self, index: u8, pokemon: Option<Arc<Pokemon>>) -> Result<()> {
pub fn set_pokemon(&self, index: u8, pokemon: Option<Pokemon>) -> Result<()> {
{
let mut write_lock = self.pokemon.write();
let mut write_lock = self.data.pokemon.write();
let old = write_lock.get_mut_res(index as usize)?;
let old = match pokemon {
Some(pokemon) => old.replace(pokemon),
@@ -192,33 +216,33 @@ impl BattleSide {
}
let pokemon = {
let read_lock = self.pokemon.read();
let read_lock = self.data.pokemon.read();
&read_lock.get_res(index as usize)?.clone()
};
if let Some(pokemon) = pokemon {
pokemon.set_battle_data(self.battle.clone(), self.index);
pokemon.set_battle_data(self.data.battle.clone(), self.data.index);
pokemon.set_on_battlefield(true)?;
pokemon.set_battle_index(index);
let battle = self.battle()?;
for side in battle.sides() {
if side.index() == self.index {
if side.index() == self.data.index {
continue;
}
for opponent in side.pokemon().iter().flatten() {
opponent.mark_opponent_as_seen(Arc::downgrade(pokemon));
pokemon.mark_opponent_as_seen(Arc::downgrade(opponent));
opponent.mark_opponent_as_seen(pokemon.weak());
pokemon.mark_opponent_as_seen(opponent.weak());
}
}
battle.event_hook().trigger(Event::Switch {
side_index: self.index,
side_index: self.data.index,
index,
pokemon: Some(pokemon.clone()),
});
script_hook!(on_switch_in, pokemon, pokemon);
} else {
self.battle()?.event_hook().trigger(Event::Switch {
side_index: self.index,
side_index: self.data.index,
index,
pokemon: None,
});
@@ -227,9 +251,9 @@ impl BattleSide {
}
/// Checks whether a Pokemon is on the field in this side.
pub fn is_pokemon_on_side(&self, pokemon: Arc<Pokemon>) -> bool {
for p in self.pokemon.read().iter().flatten() {
if Arc::ptr_eq(p, &pokemon) {
pub fn is_pokemon_on_side(&self, pokemon: Pokemon) -> bool {
for p in self.data.pokemon.read().iter().flatten() {
if Pokemon::eq(p, &pokemon) {
return true;
}
}
@@ -239,18 +263,19 @@ impl BattleSide {
/// Marks a slot as unfillable. This happens when no parties are able to fill the slot anymore.
/// If this happens, the slot can not be used again.
pub(crate) fn mark_slot_as_unfillable(&self, index: u8) -> Result<()> {
self.fillable_slots
self.data
.fillable_slots
.get_res(index as usize)?
.store(false, Ordering::SeqCst);
Ok(())
}
/// Checks whether a slot is unfillable or not.
pub fn is_slot_unfillable(&self, pokemon: Arc<Pokemon>) -> Result<bool> {
for (i, slot) in self.pokemon.read().iter().enumerate() {
pub fn is_slot_unfillable(&self, pokemon: Pokemon) -> Result<bool> {
for (i, slot) in self.data.pokemon.read().iter().enumerate() {
if let Some(p) = slot {
if Arc::ptr_eq(p, &pokemon) {
return Ok(self.fillable_slots.get_res(i)?.load(Ordering::Relaxed));
if Pokemon::eq(p, &pokemon) {
return Ok(self.data.fillable_slots.get_res(i)?.load(Ordering::Relaxed));
}
}
}
@@ -259,7 +284,7 @@ impl BattleSide {
/// Checks whether the side has been defeated.
pub fn is_defeated(&self) -> bool {
for fillable_slot in &self.fillable_slots {
for fillable_slot in &self.data.fillable_slots {
if fillable_slot.load(Ordering::Relaxed) {
return false;
}
@@ -269,19 +294,20 @@ impl BattleSide {
/// Mark the side as fled.
pub fn mark_as_fled(&mut self) {
self.has_fled_battle = true;
self.data.has_fled_battle.store(true, Ordering::SeqCst);
}
/// Gets a random Pokemon on the given side.
pub fn get_random_creature_index(&self) -> Result<u8> {
// TODO: Consider adding parameter to only get index for available creatures.
Ok(self.battle()?.random().get_max(self.pokemon_per_side as i32)? as u8)
Ok(self.battle()?.random().get_max(self.data.pokemon_per_side as i32)? as u8)
}
/// Swap two Pokemon on a single side around.
pub fn swap_positions(&mut self, a: u8, b: u8) -> Result<bool> {
let data = &self.data;
// If out of range, don't allow swapping.
if a >= self.pokemon_per_side || b >= self.pokemon_per_side {
if a >= data.pokemon_per_side || b >= data.pokemon_per_side {
return Ok(false);
}
// If the two indices are the same, don't allow swapping.
@@ -294,10 +320,10 @@ impl BattleSide {
let mut party_b = None;
let battle = self.battle()?;
for party in battle.parties() {
if party.is_responsible_for_index(self.index, a) {
if party.is_responsible_for_index(data.index, a) {
party_a = Some(party);
}
if party.is_responsible_for_index(self.index, b) {
if party.is_responsible_for_index(data.index, b) {
party_b = Some(party);
}
}
@@ -315,19 +341,49 @@ impl BattleSide {
return Ok(false);
}
self.pokemon.write().swap(a as usize, b as usize);
data.pokemon.write().swap(a as usize, b as usize);
self.battle()?.event_hook().trigger(Event::Swap {
side_index: self.index,
side_index: data.index,
index_a: a,
index_b: b,
});
Ok(true)
}
/// Gets a weak reference to the side.
pub fn weak(&self) -> WeakBattleSideReference {
WeakBattleSideReference {
data: Arc::downgrade(&self.data),
}
}
}
impl WeakBattleSideReference {
/// Upgrades the weak reference to a strong reference, returning `None` if the side has been
/// dropped.
pub fn upgrade(&self) -> Option<BattleSide> {
self.data.upgrade().map(|data| BattleSide { data })
}
/// Gets the underlying pointer to the data of the side.
pub(crate) fn as_ptr(&self) -> *const c_void {
self.data.as_ptr() as *const c_void
}
}
unsafe impl Send for WeakBattleSideReference {}
unsafe impl Sync for WeakBattleSideReference {}
impl PartialEq for WeakBattleSideReference {
fn eq(&self, other: &Self) -> bool {
self.data.ptr_eq(&other.data)
}
}
impl VolatileScriptsOwner for BattleSide {
fn volatile_scripts(&self) -> &Arc<ScriptSet> {
&self.volatile_scripts
&self.data.volatile_scripts
}
fn load_volatile_script(&self, key: &StringKey) -> Result<Option<Arc<dyn Script>>> {
@@ -343,11 +399,11 @@ impl ScriptSource for BattleSide {
}
fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
&self.script_source_data
&self.data.script_source_data
}
fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
scripts.push((&self.volatile_scripts).into());
scripts.push((&self.data.volatile_scripts).into());
}
fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) -> Result<()> {
@@ -358,6 +414,6 @@ impl ScriptSource for BattleSide {
impl ValueIdentifiable for BattleSide {
fn value_identifier(&self) -> ValueIdentifier {
self.identifier
self.data.identifier
}
}

23
src/dynamic_data/models/executing_move.rs
View File

@@ -16,7 +16,6 @@ use crate::{PkmnError, ValueIdentifiable, ValueIdentifier};
/// A hit data is the data for a single hit, on a single target.
#[derive(Default, Debug)]
pub struct HitData {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
@@ -96,9 +95,9 @@ pub struct ExecutingMove {
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>,
hits: Vec<Arc<HitData>>,
/// The user of the move.
user: Arc<Pokemon>,
user: Pokemon,
/// The move the user has actually chosen to do.
chosen_move: Arc<LearnedMove>,
/// The move that the user is actually going to do.
@@ -116,7 +115,7 @@ impl ExecutingMove {
pub fn new(
targets: TargetList,
number_of_hits: u8,
user: Arc<Pokemon>,
user: Pokemon,
chosen_move: Arc<LearnedMove>,
use_move: Arc<dyn MoveData>,
script: ScriptContainer,
@@ -124,7 +123,7 @@ impl ExecutingMove {
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())
hits.push(Arc::new(HitData::default()))
}
Self {
identifier: Default::default(),
@@ -148,7 +147,7 @@ impl ExecutingMove {
self.number_of_hits
}
/// The user of the move.
pub fn user(&self) -> &Arc<Pokemon> {
pub fn user(&self) -> &Pokemon {
&self.user
}
/// The move the user has actually chosen to do.
@@ -165,10 +164,10 @@ impl ExecutingMove {
}
/// Gets a hit data for a target, with a specific index.
pub fn get_hit_data(&self, for_target: &Arc<Pokemon>, hit: u8) -> Result<&HitData> {
pub fn get_hit_data(&self, for_target: &Pokemon, hit: u8) -> Result<&Arc<HitData>> {
for (index, target) in self.targets.iter().enumerate() {
if let Some(target) = target {
if Arc::ptr_eq(target, for_target) {
if Pokemon::eq(target, for_target) {
let i = index * self.number_of_hits as usize + hit as usize;
return match self.hits.get(i) {
Some(hit) => Ok(hit),
@@ -185,9 +184,9 @@ impl ExecutingMove {
}
/// Checks whether a Pokemon is a target for this move.
pub fn is_pokemon_target(&self, pokemon: &Arc<Pokemon>) -> bool {
pub fn is_pokemon_target(&self, pokemon: &Pokemon) -> bool {
for target in self.targets.iter().flatten() {
if Arc::ptr_eq(target, pokemon) {
if Pokemon::eq(target, pokemon) {
return true;
}
}
@@ -195,10 +194,10 @@ impl ExecutingMove {
}
/// 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>) -> Result<usize> {
pub(crate) fn get_index_of_target(&self, for_target: &Pokemon) -> Result<usize> {
for (index, target) in self.targets.iter().enumerate() {
if let Some(target) = target {
if Arc::ptr_eq(target, for_target) {
if Pokemon::eq(target, for_target) {
let i = index * self.number_of_hits as usize;
return Ok(i);
}

339
src/dynamic_data/models/pokemon.rs
View File

@@ -1,3 +1,4 @@
use std::ffi::c_void;
use std::fmt::{Debug, Formatter};
use std::ops::{Deref, DerefMut};
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU8, Ordering};
@@ -12,7 +13,9 @@ use crate::dynamic_data::event_hooks::Event;
use crate::dynamic_data::models::battle::Battle;
use crate::dynamic_data::models::learned_move::{LearnedMove, MoveLearnMethod};
use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
use crate::dynamic_data::{DynamicLibrary, Script, ScriptCategory, ScriptContainer, ScriptSet, VolatileScriptsOwner};
use crate::dynamic_data::{
DynamicLibrary, Script, ScriptCategory, ScriptContainer, ScriptSet, VolatileScriptsOwner, WeakBattleReference,
};
use crate::static_data::AbilityIndex;
use crate::static_data::Form;
use crate::static_data::Gender;
@@ -26,8 +29,8 @@ use crate::utils::Random;
use crate::{script_hook, PkmnError, StringKey, ValueIdentifiable, ValueIdentifier, VecExt};
use anyhow::{anyhow, bail, Result};
/// An individual Pokemon as we know and love them.
pub struct Pokemon {
/// The data of a Pokemon.
struct PokemonData {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
/// The library data of the Pokemon.
@@ -67,16 +70,16 @@ pub struct Pokemon {
height: Atomic<f32>,
/// The stats of the Pokemon when disregarding any stat boosts.
flat_stats: StatisticSet<u32>,
flat_stats: Arc<StatisticSet<u32>>,
/// The statistics boosts of the Pokemon. Will prevent the value from going above 6, and below
/// -6.
stat_boost: ClampedStatisticSet<i8, -6, 6>,
stat_boost: Arc<ClampedStatisticSet<i8, -6, 6>>,
/// The stats of the Pokemon including the stat boosts
boosted_stats: StatisticSet<u32>,
boosted_stats: Arc<StatisticSet<u32>>,
/// The [individual values](https://bulbapedia.bulbagarden.net/wiki/Individual_values) of the Pokemon.
individual_values: ClampedStatisticSet<u8, 0, 31>,
individual_values: Arc<ClampedStatisticSet<u8, 0, 31>>,
/// The [effort values](https://bulbapedia.bulbagarden.net/wiki/Effort_values) of the Pokemon.
effort_values: ClampedStatisticSet<u8, 0, 252>,
effort_values: Arc<ClampedStatisticSet<u8, 0, 252>>,
/// The [nature](https://bulbapedia.bulbagarden.net/wiki/Nature) of the Pokemon.
nature: Arc<dyn Nature>,
@@ -118,6 +121,24 @@ pub struct Pokemon {
script_source_data: RwLock<ScriptSourceData>,
}
/// An individual Pokemon.
#[derive(Clone)]
pub struct Pokemon {
/// The data of the Pokemon.
data: Arc<PokemonData>,
}
/// A non-owning reference to a Pokemon.
#[derive(Debug, Clone)]
pub struct WeakPokemonReference {
/// The weak reference to the data.
data: Weak<PokemonData>,
}
unsafe impl Send for WeakPokemonReference {}
unsafe impl Sync for WeakPokemonReference {}
impl Pokemon {
/// Instantiates a new Pokemon.
pub fn new(
@@ -143,7 +164,7 @@ impl Pokemon {
.natures()
.get_nature(nature)
.ok_or(PkmnError::InvalidNatureName { nature: nature.clone() })?;
let mut pokemon = Self {
let pokemon_data = PokemonData {
identifier: Default::default(),
library,
species: RwLock::new(species),
@@ -180,28 +201,32 @@ impl Pokemon {
volatile: Default::default(),
script_source_data: Default::default(),
};
let pokemon = Self {
data: Arc::new(pokemon_data),
};
pokemon.recalculate_flat_stats()?;
let health = pokemon.flat_stats().hp();
pokemon.current_health = AtomicU32::new(health);
pokemon.data.current_health.store(health, Ordering::Relaxed);
Ok(pokemon)
}
/// The library data of the Pokemon.
pub fn library(&self) -> &Arc<dyn DynamicLibrary> {
&self.library
&self.data.library
}
/// The species of the Pokemon.
pub fn species(&self) -> Arc<dyn Species> {
self.species.read().clone()
self.data.species.read().clone()
}
/// The form of the Pokemon.
pub fn form(&self) -> Arc<dyn Form> {
self.form.read().clone()
self.data.form.read().clone()
}
/// The species that should be displayed to the user. This handles stuff like the Illusion ability.
pub fn display_species(&self) -> Arc<dyn Species> {
if let Some(v) = &self.display_species {
if let Some(v) = &self.data.display_species {
v.clone()
} else {
self.species()
@@ -209,7 +234,7 @@ impl Pokemon {
}
/// The form that should be displayed to the user. This handles stuff like the Illusion ability.
pub fn display_form(&self) -> Arc<dyn Form> {
if let Some(v) = &self.display_form {
if let Some(v) = &self.data.display_form {
v.clone()
} else {
self.form()
@@ -217,53 +242,57 @@ impl Pokemon {
}
/// The current level of the Pokemon.
pub fn level(&self) -> LevelInt {
self.level.load(Ordering::Relaxed)
self.data.level.load(Ordering::Relaxed)
}
/// The amount of experience of the Pokemon.
pub fn experience(&self) -> u32 {
self.experience.load(Ordering::Relaxed)
self.data.experience.load(Ordering::Relaxed)
}
/// A unique random number for this Pokemon.
pub fn unique_identifier(&self) -> u32 {
self.unique_identifier
self.data.unique_identifier
}
/// The gender of the Pokemon.
pub fn gender(&self) -> Gender {
*self.gender.read()
*self.data.gender.read()
}
/// The coloring of the Pokemon. Value 0 is the default, value 1 means shiny. Other values are
/// currently not used, and can be used for other implementations.
pub fn coloring(&self) -> u8 {
self.coloring
self.data.coloring
}
/// Gets the held item of a Pokemon
pub fn held_item(&self) -> &RwLock<Option<Arc<dyn Item>>> {
&self.held_item
&self.data.held_item
}
/// Checks whether the Pokemon is holding a specific item.
pub fn has_held_item(&self, name: &StringKey) -> bool {
// Only true if we have an item, and the item name is the same as the requested item.
if let Some(v) = self.held_item.read().deref() {
if let Some(v) = self.data.held_item.read().deref() {
return v.name() == name;
}
false
}
/// Changes the held item of the Pokemon. Returns the previously held item.
pub fn set_held_item(&self, item: &Arc<dyn Item>) -> Option<Arc<dyn Item>> {
self.held_item.write().replace(item.clone())
self.data.held_item.write().replace(item.clone())
}
/// Removes the held item from the Pokemon. Returns the previously held item.
pub fn remove_held_item(&self) -> Option<Arc<dyn Item>> {
self.held_item.write().take()
self.data.held_item.write().take()
}
/// Makes the Pokemon uses its held item.
pub fn consume_held_item(&self) -> Result<bool> {
if self.held_item.read().is_none() {
if self.data.held_item.read().is_none() {
return Ok(false);
}
let script = self
.library
.load_item_script(self.held_item.read().as_ref().ok_or(PkmnError::UnableToAcquireLock)?)?;
let script = self.data.library.load_item_script(
self.data
.held_item
.read()
.as_ref()
.ok_or(PkmnError::UnableToAcquireLock)?,
)?;
if script.is_none() {
return Ok(false);
}
@@ -274,60 +303,60 @@ impl Pokemon {
/// The remaining health points of the Pokemon.
pub fn current_health(&self) -> u32 {
self.current_health.load(Ordering::Relaxed)
self.data.current_health.load(Ordering::Relaxed)
}
/// The max health points of the Pokemon.
pub fn max_health(&self) -> u32 {
self.boosted_stats.hp()
self.data.boosted_stats.hp()
}
/// The weight of the Pokemon in kilograms.
pub fn weight(&self) -> f32 {
self.weight.load(Ordering::Relaxed)
self.data.weight.load(Ordering::Relaxed)
}
/// Sets the weight of the Pokemon in kilograms.
pub fn set_weight(&self, weight: f32) {
self.weight.store(weight, Ordering::Relaxed)
self.data.weight.store(weight, Ordering::Relaxed)
}
/// The height of the Pokemon in meters.
pub fn height(&self) -> f32 {
self.height.load(Ordering::Relaxed)
self.data.height.load(Ordering::Relaxed)
}
/// An optional nickname of the Pokemon.
pub fn nickname(&self) -> &Option<String> {
&self.nickname
&self.data.nickname
}
/// An index of the ability to find the actual ability on the form.
pub fn real_ability(&self) -> &AbilityIndex {
&self.ability_index
&self.data.ability_index
}
/// The current types of the Pokemon.
pub fn types(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<TypeIdentifier>> {
self.types.read()
self.data.types.read()
}
/// The moves the Pokemon has learned. This is of a set length of [`MAX_MOVES`]. Empty move slots
/// are defined by None.
pub fn learned_moves(&self) -> &RwLock<[Option<Arc<LearnedMove>>; MAX_MOVES]> {
&self.moves
&self.data.moves
}
/// The stats of the Pokemon when disregarding any stat boosts.
pub fn flat_stats(&self) -> &StatisticSet<u32> {
&self.flat_stats
pub fn flat_stats(&self) -> &Arc<StatisticSet<u32>> {
&self.data.flat_stats
}
/// The amount of boosts on a specific stat.
pub fn stat_boosts(&self) -> &ClampedStatisticSet<i8, -6, 6> {
&self.stat_boost
pub fn stat_boosts(&self) -> &Arc<ClampedStatisticSet<i8, -6, 6>> {
&self.data.stat_boost
}
/// The stats of the Pokemon including the stat boosts
pub fn boosted_stats(&self) -> &StatisticSet<u32> {
&self.boosted_stats
pub fn boosted_stats(&self) -> &Arc<StatisticSet<u32>> {
&self.data.boosted_stats
}
/// Get the stat boosts for a specific stat.
pub fn stat_boost(&self, stat: Statistic) -> i8 {
self.stat_boost.get_stat(stat)
self.data.stat_boost.get_stat(stat)
}
/// Change a boosted stat by a certain amount.
pub fn change_stat_boost(&self, stat: Statistic, mut diff_amount: i8, self_inflicted: bool) -> Result<bool> {
@@ -357,13 +386,13 @@ impl Pokemon {
}
let mut changed = false;
let old_value = self.stat_boost.get_stat(stat);
let old_value = self.data.stat_boost.get_stat(stat);
match diff_amount.cmp(&0_i8) {
std::cmp::Ordering::Less => {
changed = self.stat_boost.decrease_stat(stat, -diff_amount);
changed = self.data.stat_boost.decrease_stat(stat, -diff_amount);
}
std::cmp::Ordering::Greater => {
changed = self.stat_boost.increase_stat(stat, -diff_amount);
changed = self.data.stat_boost.increase_stat(stat, -diff_amount);
}
_ => {}
}
@@ -383,17 +412,17 @@ impl Pokemon {
}
/// The [individual values](https://bulbapedia.bulbagarden.net/wiki/Individual_values) of the Pokemon.
pub fn individual_values(&self) -> &ClampedStatisticSet<u8, 0, 31> {
&self.individual_values
pub fn individual_values(&self) -> &Arc<ClampedStatisticSet<u8, 0, 31>> {
&self.data.individual_values
}
/// The [effort values](https://bulbapedia.bulbagarden.net/wiki/Effort_values) of the Pokemon.
pub fn effort_values(&self) -> &ClampedStatisticSet<u8, 0, 252> {
&self.effort_values
pub fn effort_values(&self) -> &Arc<ClampedStatisticSet<u8, 0, 252>> {
&self.data.effort_values
}
/// Gets the battle the battle is currently in.
pub fn get_battle(&self) -> Option<Arc<Battle>> {
let r = self.battle_data.read();
pub fn get_battle(&self) -> Option<Battle> {
let r = self.data.battle_data.read();
if let Some(data) = &r.deref() {
data.battle.upgrade()
} else {
@@ -403,26 +432,31 @@ impl Pokemon {
/// Get the index of the side of the battle the Pokemon is in. Only returns a value if the Pokemon
/// is on the battlefield.
pub fn get_battle_side_index(&self) -> Option<u8> {
self.battle_data.read().as_ref().map(|data| data.battle_side_index())
self.data
.battle_data
.read()
.as_ref()
.map(|data| data.battle_side_index())
}
/// Get the index of the slot on the side of the battle the Pokemon is in. Only returns a value
/// if the Pokemon is on the battlefield.
pub fn get_battle_index(&self) -> Option<u8> {
self.battle_data.read().as_ref().map(|data| data.index())
self.data.battle_data.read().as_ref().map(|data| data.index())
}
/// Returns whether something overrides the ability.
pub fn is_ability_overriden(&self) -> bool {
self.override_ability.is_some()
self.data.override_ability.is_some()
}
/// Returns the currently active ability.
pub fn active_ability(&self) -> Result<Arc<dyn Ability>> {
if let Some(v) = &self.override_ability {
if let Some(v) = &self.data.override_ability {
return Ok(v.clone());
}
let form = self.form();
let ability = form.get_ability(self.ability_index)?;
let ability = form.get_ability(self.data.ability_index)?;
Ok(self
.data
.library
.static_data()
.abilities()
@@ -434,68 +468,70 @@ impl Pokemon {
/// The script for the status.
pub fn status(&self) -> &ScriptContainer {
&self.status_script
&self.data.status_script
}
/// Returns the script for the currently active ability.
pub fn ability_script(&self) -> &ScriptContainer {
&self.ability_script
&self.data.ability_script
}
/// Whether or not the Pokemon is allowed to gain experience.
pub fn allowed_experience_gain(&self) -> bool {
self.allowed_experience
self.data.allowed_experience
}
/// The [nature](https://bulbapedia.bulbagarden.net/wiki/Nature) of the Pokemon.
pub fn nature(&self) -> &Arc<dyn Nature> {
&self.nature
&self.data.nature
}
/// Calculates the flat stats on the Pokemon. This should be called when for example the base
/// stats, level, nature, IV, or EV changes. This has a side effect of recalculating the boosted
/// stats, as those depend on the flat stats.
pub fn recalculate_flat_stats(&self) -> Result<()> {
self.library
self.data
.library
.stat_calculator()
.calculate_flat_stats(self, &self.flat_stats)?;
.calculate_flat_stats(self, &self.data.flat_stats)?;
self.recalculate_boosted_stats()?;
Ok(())
}
/// Calculates the boosted stats on the Pokemon, _without_ recalculating the flat stats.
/// This should be called when a stat boost changes.
pub fn recalculate_boosted_stats(&self) -> Result<()> {
self.library
self.data
.library
.stat_calculator()
.calculate_boosted_stats(self, &self.boosted_stats)
.calculate_boosted_stats(self, &self.data.boosted_stats)
}
/// Change the species of the Pokemon.
pub fn change_species(&self, species: Arc<dyn Species>, form: Arc<dyn Form>) -> Result<()> {
*self.species.write() = species.clone();
*self.form.write() = form.clone();
*self.data.species.write() = species.clone();
*self.data.form.write() = form.clone();
// If the pokemon is genderless, but it's new species is not, we want to set its gender
if self.gender() != Gender::Genderless && species.gender_rate() < 0.0 {
// If we're in battle, use the battle random for predictability
let r = self.battle_data.read();
let r = self.data.battle_data.read();
if let Some(data) = r.deref() {
let battle = data.battle().ok_or(anyhow!("Battle not set"))?;
let mut random = match battle.random().get_rng().lock() {
Ok(v) => v,
Err(_) => return Err(PkmnError::UnableToAcquireLock.into()),
};
*self.gender.write() = species.get_random_gender(random.deref_mut());
*self.data.gender.write() = species.get_random_gender(random.deref_mut());
} else {
// If we're not in battle, just use a new random.
*self.gender.write() = species.get_random_gender(&mut Random::default());
*self.data.gender.write() = species.get_random_gender(&mut Random::default());
}
}
// Else if the new species is genderless, but the pokemon has a gender, make the creature genderless.
else if species.gender_rate() < 0.0 && self.gender() != Gender::Genderless {
*self.gender.write() = Gender::Genderless;
*self.data.gender.write() = Gender::Genderless;
}
let r = self.battle_data.read();
let r = self.data.battle_data.read();
if let Some(battle_data) = &r.deref() {
if let Some(battle) = battle_data.battle() {
battle.event_hook().trigger(Event::SpeciesChange {
@@ -513,29 +549,31 @@ impl Pokemon {
if self.form().value_identifier() == form.value_identifier() {
return Ok(());
}
*self.form.write() = form.clone();
*self.data.form.write() = form.clone();
{
let mut type_lock = self.types.write();
let mut type_lock = self.data.types.write();
type_lock.clear();
for t in form.types() {
type_lock.push(*t);
}
}
self.weight.store(form.weight(), Ordering::SeqCst);
self.height.store(form.height(), Ordering::SeqCst);
self.data.weight.store(form.weight(), Ordering::SeqCst);
self.data.height.store(form.height(), Ordering::SeqCst);
let ability = self.active_ability()?;
let ability_script = self
.data
.library
.load_script(self.into(), ScriptCategory::Ability, ability.name())?;
if let Some(ability_script) = ability_script {
let script_result = self
.data
.ability_script
.set(ability_script)
.as_ref()
// Ensure the ability script gets initialized with the parameters for the ability.
.on_initialize(&self.library, ability.parameters().to_vec());
.on_initialize(&self.data.library, ability.parameters().to_vec());
match script_result {
Ok(_) => (),
Err(e) => {
@@ -543,21 +581,23 @@ impl Pokemon {
}
}
} else {
self.ability_script.clear();
self.data.ability_script.clear();
}
let old_health = self.max_health();
self.recalculate_flat_stats()?;
let diff_health = (self.max_health() - old_health) as i32;
if self.current_health() == 0 && (self.current_health() as i32) < -diff_health {
self.current_health.store(0, Ordering::SeqCst);
self.data.current_health.store(0, Ordering::SeqCst);
} else if diff_health < 0 {
self.current_health.fetch_sub(-diff_health as u32, Ordering::SeqCst);
self.data
.current_health
.fetch_sub(-diff_health as u32, Ordering::SeqCst);
} else {
self.current_health.fetch_add(diff_health as u32, Ordering::SeqCst);
self.data.current_health.fetch_add(diff_health as u32, Ordering::SeqCst);
}
// TODO: consider form specific attacks?
let r = self.battle_data.read();
let r = self.data.battle_data.read();
if let Some(battle_data) = r.deref() {
if let Some(battle) = battle_data.battle() {
battle.event_hook().trigger(Event::FormChange {
@@ -571,7 +611,7 @@ impl Pokemon {
/// Whether or not the Pokemon is useable in a battle.
pub fn is_usable(&self) -> bool {
!self.is_caught && !self.is_egg && !self.is_fainted()
!self.data.is_caught && !self.data.is_egg && !self.is_fainted()
}
/// Returns whether the Pokemon is fainted.
@@ -580,8 +620,8 @@ impl Pokemon {
}
/// Sets the current battle the Pokemon is in.
pub fn set_battle_data(&self, battle: Weak<Battle>, battle_side_index: u8) {
let mut w = self.battle_data.write();
pub fn set_battle_data(&self, battle: WeakBattleReference, battle_side_index: u8) {
let mut w = self.data.battle_data.write();
if let Some(battle_data) = w.deref_mut() {
battle_data.battle = battle;
battle_data.battle_side_index.store(battle_side_index, Ordering::SeqCst);
@@ -598,13 +638,13 @@ impl Pokemon {
/// Sets whether or not the Pokemon is on the battlefield.
pub fn set_on_battlefield(&self, value: bool) -> Result<()> {
let r = self.battle_data.read();
let r = self.data.battle_data.read();
if let Some(data) = &mut r.deref() {
data.on_battle_field.store(value, Ordering::SeqCst);
if !value {
self.volatile.clear()?;
self.weight.store(self.form().weight(), Ordering::SeqCst);
self.height.store(self.form().height(), Ordering::SeqCst);
self.data.volatile.clear()?;
self.data.weight.store(self.form().weight(), Ordering::SeqCst);
self.data.height.store(self.form().height(), Ordering::SeqCst);
}
}
Ok(())
@@ -612,7 +652,7 @@ impl Pokemon {
/// Sets the index of the slot of the side the Pokemon is on.
pub fn set_battle_index(&self, index: u8) {
let r = self.battle_data.read();
let r = self.data.battle_data.read();
if let Some(data) = r.deref() {
data.index.store(index, Ordering::SeqCst)
}
@@ -620,16 +660,20 @@ impl Pokemon {
/// Whether or not the Pokemon is on the battlefield.
pub fn is_on_battlefield(&self) -> bool {
self.battle_data.read().as_ref().is_some_and(|a| a.on_battle_field())
self.data
.battle_data
.read()
.as_ref()
.is_some_and(|a| a.on_battle_field())
}
/// Marks an opponent as seen, for use in experience gain.
pub fn mark_opponent_as_seen(&self, pokemon: Weak<Pokemon>) {
let r = self.battle_data.read();
if let Some(battle_data) = &r.deref() {
pub fn mark_opponent_as_seen(&self, pokemon: WeakPokemonReference) {
let r = self.data.battle_data.read();
if let Some(battle_data) = r.deref() {
let mut opponents = battle_data.seen_opponents().write();
for seen_opponent in opponents.deref() {
if seen_opponent.ptr_eq(&pokemon) {
if seen_opponent.eq(&pokemon) {
return;
}
}
@@ -646,7 +690,7 @@ impl Pokemon {
return Ok(());
}
let new_health = self.current_health() - damage;
if let Some(battle_data) = &self.battle_data.read().deref() {
if let Some(battle_data) = &self.data.battle_data.read().deref() {
if let Some(battle) = battle_data.battle() {
battle.event_hook().trigger(Event::Damage {
pokemon: self,
@@ -656,11 +700,17 @@ impl Pokemon {
});
}
}
if self.battle_data.read().as_ref().is_some_and(|a| a.on_battle_field()) {
if self
.data
.battle_data
.read()
.as_ref()
.is_some_and(|a| a.on_battle_field())
{
script_hook!(on_damage, self, self, source, self.current_health(), new_health);
}
self.current_health.store(new_health, Ordering::SeqCst);
self.data.current_health.store(new_health, Ordering::SeqCst);
if self.is_fainted() && damage > 0 {
self.on_faint(source)?;
}
@@ -669,7 +719,7 @@ impl Pokemon {
/// Triggers when the Pokemon faints.
fn on_faint(&self, source: DamageSource) -> Result<()> {
let r = self.battle_data.read();
let r = self.data.battle_data.read();
if let Some(battle_data) = r.deref() {
if let Some(battle) = battle_data.battle() {
battle.event_hook().trigger(Event::Faint { pokemon: self });
@@ -703,7 +753,7 @@ impl Pokemon {
return false;
}
let new_health = self.current_health() + max_amount;
if let Some(battle_data) = &self.battle_data.read().deref() {
if let Some(battle_data) = &self.data.battle_data.read().deref() {
if let Some(battle) = battle_data.battle() {
battle.event_hook().trigger(Event::Heal {
pokemon: self,
@@ -712,7 +762,7 @@ impl Pokemon {
});
}
}
self.current_health.store(new_health, Ordering::SeqCst);
self.data.current_health.store(new_health, Ordering::SeqCst);
true
}
@@ -727,6 +777,7 @@ impl Pokemon {
}
};
let move_data = self
.data
.library
.static_data()
.moves()
@@ -742,12 +793,13 @@ impl Pokemon {
/// Removes the current non-volatile status from the Pokemon.
pub fn clear_status(&self) {
self.status_script.clear()
self.data.status_script.clear()
}
/// Increases the level by a certain amount
pub fn change_level_by(&self, amount: LevelInt) -> Result<()> {
self.level
self.data
.level
.fetch_update(Ordering::SeqCst, Ordering::Relaxed, |x| {
let max_level = self.library().static_data().settings().maximum_level();
if x + amount > max_level {
@@ -759,13 +811,50 @@ impl Pokemon {
.ok();
self.recalculate_flat_stats()
}
/// Take a weak reference to the Pokemon.
pub fn weak(&self) -> WeakPokemonReference {
WeakPokemonReference {
data: Arc::downgrade(&self.data),
}
}
}
impl PartialEq for Pokemon {
fn eq(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.data, &other.data)
}
}
impl Eq for Pokemon {}
impl PartialEq for WeakPokemonReference {
fn eq(&self, other: &Self) -> bool {
Weak::ptr_eq(&self.data, &other.data)
}
}
impl Eq for WeakPokemonReference {}
impl WeakPokemonReference {
/// Attempts to upgrade the weak reference to a strong reference.
pub fn upgrade(&self) -> Option<Pokemon> {
Some(Pokemon {
data: self.data.upgrade()?,
})
}
/// Gets the pointer to the underlying data.
pub(crate) fn as_ptr(&self) -> *const c_void {
self.data.as_ptr() as *const c_void
}
}
/// The data of the Pokemon related to being in a battle.
#[derive(Debug)]
pub struct PokemonBattleData {
/// The battle data of the Pokemon
battle: Weak<Battle>,
battle: WeakBattleReference,
/// The index of the side of the Pokemon
battle_side_index: AtomicU8,
/// The index of the slot on the side of the Pokemon.
@@ -773,16 +862,12 @@ pub struct PokemonBattleData {
/// Whether or not the Pokemon is on the battlefield.
on_battle_field: AtomicBool,
/// A list of opponents the Pokemon has seen this battle.
seen_opponents: RwLock<Vec<Weak<Pokemon>>>,
seen_opponents: RwLock<Vec<WeakPokemonReference>>,
}
impl PokemonBattleData {
/// The battle data of the Pokemon
pub fn battle_mut(&mut self) -> Option<Arc<Battle>> {
self.battle.upgrade()
}
/// The battle data of the Pokemon
pub fn battle(&self) -> Option<Arc<Battle>> {
pub fn battle(&self) -> Option<Battle> {
self.battle.upgrade()
}
@@ -799,7 +884,7 @@ impl PokemonBattleData {
self.on_battle_field.load(Ordering::Relaxed)
}
/// A list of opponents the Pokemon has seen this battle.
pub fn seen_opponents(&self) -> &RwLock<Vec<Weak<Pokemon>>> {
pub fn seen_opponents(&self) -> &RwLock<Vec<WeakPokemonReference>> {
&self.seen_opponents
}
}
@@ -807,7 +892,7 @@ impl PokemonBattleData {
impl ScriptSource for Pokemon {
fn get_script_count(&self) -> Result<usize> {
let mut c = 3;
if let Some(battle_data) = &self.battle_data.read().deref() {
if let Some(battle_data) = &self.data.battle_data.read().deref() {
if let Some(battle) = battle_data.battle() {
c += battle
.sides()
@@ -819,19 +904,19 @@ impl ScriptSource for Pokemon {
}
fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
&self.script_source_data
&self.data.script_source_data
}
fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
scripts.push((&self.held_item_trigger_script).into());
scripts.push((&self.ability_script).into());
scripts.push((&self.status_script).into());
scripts.push((&self.volatile).into());
scripts.push((&self.data.held_item_trigger_script).into());
scripts.push((&self.data.ability_script).into());
scripts.push((&self.data.status_script).into());
scripts.push((&self.data.volatile).into());
}
fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) -> Result<()> {
self.get_own_scripts(scripts);
if let Some(battle_data) = &self.battle_data.read().deref() {
if let Some(battle_data) = &self.data.battle_data.read().deref() {
if let Some(battle) = battle_data.battle() {
battle
.sides()
@@ -845,17 +930,17 @@ impl ScriptSource for Pokemon {
impl VolatileScriptsOwner for Pokemon {
fn volatile_scripts(&self) -> &Arc<ScriptSet> {
&self.volatile
&self.data.volatile
}
fn load_volatile_script(&self, key: &StringKey) -> Result<Option<Arc<dyn Script>>> {
self.library.load_script(self.into(), ScriptCategory::Pokemon, key)
self.data.library.load_script(self.into(), ScriptCategory::Pokemon, key)
}
}
impl ValueIdentifiable for Pokemon {
fn value_identifier(&self) -> ValueIdentifier {
self.identifier
self.data.identifier
}
}
@@ -921,7 +1006,7 @@ pub mod test {
});
let mut static_lib = MockStaticData::new();
static_lib.expect_species().return_const(Box::new(species_lib));
static_lib.expect_species().return_const(Arc::new(species_lib));
let mut growth_rate_lib = MockGrowthRateLibrary::new();
growth_rate_lib
@@ -934,8 +1019,8 @@ pub mod test {
Some(Arc::new(n))
});
static_lib.expect_growth_rates().return_const(Box::new(growth_rate_lib));
static_lib.expect_natures().return_const(Box::new(nature_lib));
static_lib.expect_growth_rates().return_const(Arc::new(growth_rate_lib));
static_lib.expect_natures().return_const(Arc::new(nature_lib));
let mut stat_calculator = MockBattleStatCalculator::new();
stat_calculator.expect_calculate_flat_stats().returning(|_, _| Ok(()));
@@ -944,8 +1029,8 @@ pub mod test {
.returning(|_, _| Ok(()));
let mut lib = MockDynamicLibrary::new();
lib.expect_static_data().return_const(Box::new(static_lib));
lib.expect_stat_calculator().return_const(Box::new(stat_calculator));
lib.expect_static_data().return_const(Arc::new(static_lib));
lib.expect_stat_calculator().return_const(Arc::new(stat_calculator));
Arc::new(lib)
}

13
src/dynamic_data/models/pokemon_party.rs
View File

@@ -1,7 +1,6 @@
use anyhow::Result;
use parking_lot::lock_api::RwLockReadGuard;
use parking_lot::{RawRwLock, RwLock};
use std::sync::Arc;
use crate::dynamic_data::models::pokemon::Pokemon;
use crate::{ValueIdentifiable, ValueIdentifier, VecExt};
@@ -12,7 +11,7 @@ pub struct PokemonParty {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
/// The underlying list of Pokemon.
pokemon: RwLock<Vec<Option<Arc<Pokemon>>>>,
pokemon: RwLock<Vec<Option<Pokemon>>>,
}
impl PokemonParty {
@@ -29,7 +28,7 @@ impl PokemonParty {
}
/// Instantiates a party with a list.
pub fn new_from_vec(pokemon: Vec<Option<Arc<Pokemon>>>) -> Self {
pub fn new_from_vec(pokemon: Vec<Option<Pokemon>>) -> Self {
Self {
identifier: Default::default(),
pokemon: RwLock::new(pokemon),
@@ -37,7 +36,7 @@ impl PokemonParty {
}
/// Gets a Pokemon at an index in the party.
pub fn at(&self, index: usize) -> Option<Arc<Pokemon>> {
pub fn at(&self, index: usize) -> Option<Pokemon> {
let read_lock = self.pokemon.read();
let opt = read_lock.get(index);
if let Some(v) = opt {
@@ -53,7 +52,7 @@ impl PokemonParty {
}
/// Sets the Pokemon at an index to a Pokemon, returning the old Pokemon.
pub fn swap_into(&self, index: usize, pokemon: Option<Arc<Pokemon>>) -> Result<Option<Arc<Pokemon>>> {
pub fn swap_into(&self, index: usize, pokemon: Option<Pokemon>) -> Result<Option<Pokemon>> {
let mut party = self.pokemon.write();
if index >= party.len() {
return Ok(pokemon);
@@ -82,7 +81,7 @@ impl PokemonParty {
}
/// Gets the underlying list of Pokemon.
pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Arc<Pokemon>>>> {
pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Pokemon>>> {
self.pokemon.read()
}
@@ -112,7 +111,7 @@ impl PokemonParty {
/// Checks if the party contains a given pokemon.
pub fn has_pokemon(&self, pokemon: &Pokemon) -> bool {
for p in self.pokemon.read().iter().flatten() {
if std::ptr::eq(p.as_ref(), pokemon) {
if Pokemon::eq(p, pokemon) {
return true;
}
}