Change to RwLock over Mutex, so we can read without locking, changes to BattleRandom to allow for cloning, and prevent race conditions.

This commit is contained in:
Deukhoofd 2022-06-04 12:40:32 +02:00
parent 310bf857d2
commit df662ce6b5
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
7 changed files with 57 additions and 57 deletions

View File

@ -43,8 +43,8 @@ assert_approx_eq = "1.1.0"
# Used for time based code (i.e. randomness)
chrono = "0.4.19"
# Used for RNG
rand = "0.8.3"
rand_pcg = "0.3.0"
rand = "0.8.5"
rand_pcg = "0.3.1"
# Used for the hashmap!{} macro, creating a simple initializer pattern for hashmaps.
maplit = "1.0.2"
failure = "0.1.8"

View File

@ -1,7 +1,8 @@
use crate::dynamic_data::models::pokemon::Pokemon;
use std::fmt::{Debug, Formatter};
use std::sync::{Arc, Mutex};
use std::sync::{Arc, RwLock};
#[derive(Default)]
pub struct EventHook {
evt_hook_function: Vec<fn(&Box<&Event>)>,
}
@ -19,14 +20,6 @@ impl EventHook {
}
}
impl Default for EventHook {
fn default() -> Self {
EventHook {
evt_hook_function: vec![],
}
}
}
impl Debug for EventHook {
fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
Ok(())
@ -38,6 +31,6 @@ pub enum Event<'a> {
Switch {
side_index: u8,
index: u8,
pokemon: Option<Arc<Mutex<Pokemon<'a>>>>,
pokemon: Option<Arc<RwLock<Pokemon<'a>>>>,
},
}

View File

@ -8,7 +8,7 @@ use crate::dynamic_data::models::battle_result::BattleResult;
use crate::dynamic_data::models::battle_side::BattleSide;
use crate::dynamic_data::script_handling::script_set::ScriptSet;
use derive_getters::Getters;
use std::sync::{Arc, Mutex};
use std::sync::{Arc, RwLock};
#[derive(Getters, Debug)]
pub struct Battle<'a> {
@ -38,14 +38,14 @@ impl<'a> Battle<'a> {
number_of_sides: u8,
pokemon_per_side: u8,
random_seed: Option<u128>,
) -> Arc<Mutex<Self>> {
) -> Arc<RwLock<Self>> {
let random = if let Some(seed) = random_seed {
BattleRandom::new_with_seed(seed)
} else {
BattleRandom::new()
BattleRandom::default()
};
let sides = Vec::with_capacity(number_of_sides as usize);
let battle = Arc::new(Mutex::new(Self {
let battle = Arc::new(RwLock::new(Self {
library,
parties,
can_flee,
@ -64,14 +64,14 @@ impl<'a> Battle<'a> {
}));
for i in 0..number_of_sides {
battle.lock().unwrap().sides[i as usize] =
battle.write().unwrap().sides[i as usize] =
BattleSide::new(i, Arc::downgrade(&battle), pokemon_per_side);
}
battle
}
pub fn random(&mut self) -> &mut BattleRandom {
&mut self.random
pub fn random(&self) -> &BattleRandom {
&self.random
}
pub fn can_slot_be_filled(&self) -> bool {

View File

@ -1,8 +1,22 @@
use crate::utils::random::Random;
use std::fmt::{Debug, Formatter};
use std::sync::Mutex;
#[derive(Default)]
pub struct BattleRandom {
random: Random,
random: Mutex<Random>,
}
impl BattleRandom {
pub fn new_with_seed(seed: u128) -> Self {
BattleRandom {
random: Mutex::new(Random::new(seed)),
}
}
pub fn get_rng(&self) -> &Mutex<Random> {
&self.random
}
}
impl Debug for BattleRandom {
@ -11,20 +25,10 @@ impl Debug for BattleRandom {
}
}
impl BattleRandom {
pub fn new() -> Self {
return BattleRandom {
random: Default::default(),
};
impl Clone for BattleRandom {
fn clone(&self) -> Self {
Self {
random: Mutex::new(self.random.lock().unwrap().clone()),
}
pub fn new_with_seed(seed: u128) -> Self {
return BattleRandom {
random: Random::new(seed),
};
}
pub fn get_rng(&mut self) -> &mut Random {
&mut self.random
}
}

View File

@ -5,22 +5,22 @@ use crate::dynamic_data::models::pokemon::Pokemon;
use crate::dynamic_data::script_handling::ScriptSource;
use crate::script_hook;
use derive_getters::Getters;
use std::sync::{Arc, Mutex, Weak};
use std::sync::{Arc, RwLock, Weak};
#[derive(Getters, Debug)]
pub struct BattleSide<'a> {
index: u8,
pokemon_per_side: u8,
pokemon: Vec<Option<Arc<Mutex<Pokemon<'a>>>>>,
pokemon: Vec<Option<Arc<RwLock<Pokemon<'a>>>>>,
choices: Vec<Option<Arc<TurnChoice<'a>>>>,
fillable_slots: Vec<bool>,
choices_set: u8,
battle: Weak<Mutex<Battle<'a>>>,
battle: Weak<RwLock<Battle<'a>>>,
has_fled: bool,
}
impl<'a> BattleSide<'a> {
pub fn new(index: u8, battle: Weak<Mutex<Battle<'a>>>, pokemon_per_side: u8) -> Self {
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);
@ -52,12 +52,12 @@ impl<'a> BattleSide<'a> {
/// empty, but can't be filled by any party anymore.
pub fn all_slots_filled(&self) -> bool {
for pokemon in &self.pokemon {
if (!pokemon.is_none() || !pokemon.as_ref().unwrap().lock().unwrap().is_usable())
if (!pokemon.is_none() || !pokemon.as_ref().unwrap().read().unwrap().is_usable())
&& self
.battle
.upgrade()
.unwrap()
.lock()
.read()
.unwrap()
.can_slot_be_filled()
{
@ -70,7 +70,7 @@ impl<'a> BattleSide<'a> {
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.lock().unwrap().unique_identifier() == choice.user().unique_identifier()
if pokemon.read().unwrap().unique_identifier() == choice.user().unique_identifier()
{
self.choices[index] = Some(Arc::new(choice));
self.choices_set += 1;
@ -84,29 +84,29 @@ impl<'a> BattleSide<'a> {
self.pokemon[index as usize] = None;
}
pub fn set_pokemon(&mut self, index: u8, pokemon: Option<Arc<Mutex<Pokemon<'a>>>>) {
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.lock().unwrap();
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.lock().unwrap();
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.lock().unwrap();
let battle = battle.read().unwrap();
for side in battle.sides() {
if *side.index() == self.index {
continue;
}
for opponent in side.pokemon().iter().flatten() {
let mut opponent = opponent.lock().unwrap();
let mut opponent = opponent.write().unwrap();
opponent.mark_opponent_as_seen(*pokemon.unique_identifier());
pokemon.mark_opponent_as_seen(*opponent.unique_identifier());
}
@ -119,7 +119,7 @@ impl<'a> BattleSide<'a> {
script_hook!(on_switch_in, pokemon, &pokemon);
} else {
let battle = self.battle.upgrade().unwrap();
let battle = battle.lock().unwrap();
let battle = battle.read().unwrap();
battle.event_hook().trigger(Event::Switch {
side_index: self.index,
index,
@ -130,7 +130,7 @@ impl<'a> BattleSide<'a> {
pub fn is_pokemon_on_side(&self, pokemon: Arc<Pokemon<'a>>) -> bool {
for p in self.pokemon.iter().flatten() {
if p.lock().unwrap().unique_identifier() == pokemon.unique_identifier() {
if p.read().unwrap().unique_identifier() == pokemon.unique_identifier() {
return true;
}
}

View File

@ -15,11 +15,11 @@ use crate::static_data::statistics::Statistic;
use crate::utils::random::Random;
use derive_getters::Getters;
use std::collections::HashSet;
use std::sync::{Mutex, Weak};
use std::sync::{RwLock, Weak};
#[derive(Debug)]
pub struct PokemonBattleData<'a> {
battle: Weak<Mutex<Battle<'a>>>,
battle: Weak<RwLock<Battle<'a>>>,
battle_side_index: u8,
index: u8,
on_battle_field: bool,
@ -27,7 +27,7 @@ pub struct PokemonBattleData<'a> {
}
impl<'a> PokemonBattleData<'a> {
pub fn battle(&'a mut self) -> &'a mut Weak<Mutex<Battle<'a>>> {
pub fn battle(&'a mut self) -> &'a mut Weak<RwLock<Battle<'a>>> {
&mut self.battle
}
pub fn battle_side_index(&self) -> u8 {
@ -141,16 +141,18 @@ impl<'a> Pokemon<'a> {
// 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 self.battle_data.is_some() {
let battle = self.battle_data.as_mut().unwrap();
let battle_data = self.battle_data.as_mut().unwrap();
self.gender = species.get_random_gender(
battle
&mut battle_data
.battle
.upgrade()
.unwrap()
.lock()
.read()
.unwrap()
.random()
.get_rng(),
.get_rng()
.lock()
.unwrap(),
);
} else {
self.gender = species.get_random_gender(&mut Random::default());
@ -167,7 +169,7 @@ impl<'a> Pokemon<'a> {
todo!()
}
pub fn set_battle_data(&mut self, battle: Weak<Mutex<Battle<'a>>>, battle_side_index: u8) {
pub fn set_battle_data(&mut self, battle: Weak<RwLock<Battle<'a>>>, battle_side_index: u8) {
if let Some(battle_data) = &mut self.battle_data {
battle_data.battle = battle;
battle_data.battle_side_index = battle_side_index;

View File

@ -2,6 +2,7 @@ use rand::distributions::{Distribution, Uniform};
use rand::{Rng, SeedableRng};
use rand_pcg::Pcg32;
#[derive(Clone)]
pub struct Random {
seed: u128,
distribution: Uniform<f64>,