96 lines
2.7 KiB
Rust
Executable File
96 lines
2.7 KiB
Rust
Executable File
use std::fmt::{Debug, Formatter};
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use crate::dynamic_data::models::executing_move::ExecutingMove;
|
|
use crate::dynamic_data::models::pokemon::Pokemon;
|
|
use crate::dynamic_data::script_handling::ScriptSource;
|
|
use crate::script_hook;
|
|
use crate::utils::Random;
|
|
|
|
/// The RNG for a battle.
|
|
#[derive(Default)]
|
|
#[cfg_attr(feature = "wasm", derive(unique_type_id_derive::UniqueTypeId))]
|
|
pub struct BattleRandom {
|
|
/// The actual underlying RNG. This is in a mutex, so it is thread safe, and can be ran
|
|
/// predictably, with guaranteed the same outputs.
|
|
random: Mutex<Random>,
|
|
}
|
|
|
|
impl BattleRandom {
|
|
/// Initializes a new RNG with a given seed.
|
|
pub fn new_with_seed(seed: u128) -> Self {
|
|
BattleRandom {
|
|
random: Mutex::new(Random::new(seed)),
|
|
}
|
|
}
|
|
|
|
/// Returns the underlying random number generator.
|
|
pub fn get_rng(&self) -> &Mutex<Random> {
|
|
&self.random
|
|
}
|
|
|
|
/// Get a random 32 bit integer. Can be any value between min int and max int.
|
|
pub fn get(&self) -> i32 {
|
|
return self.get_rng().lock().unwrap().get();
|
|
}
|
|
/// Get a random 32 bit integer between 0 and max.
|
|
pub fn get_max(&self, max: i32) -> i32 {
|
|
return self.get_rng().lock().unwrap().get_max(max);
|
|
}
|
|
/// Get a random 32 bit integer between min and max.
|
|
pub fn get_between(&self, min: i32, max: i32) -> i32 {
|
|
return self.get_rng().lock().unwrap().get_between(min, max);
|
|
}
|
|
|
|
/// Gets whether or not a move triggers its secondary effect. This takes its chance, and
|
|
/// rolls whether it triggers. As a side effect this run scripts to allow modifying this random
|
|
/// chance.
|
|
pub fn effect_chance(
|
|
&self,
|
|
mut chance: f32,
|
|
executing_move: &ExecutingMove,
|
|
target: &Arc<Pokemon>,
|
|
hit_number: u8,
|
|
) -> bool {
|
|
script_hook!(
|
|
change_effect_chance,
|
|
executing_move,
|
|
executing_move,
|
|
target,
|
|
hit_number,
|
|
&mut chance
|
|
);
|
|
script_hook!(
|
|
change_incoming_effect_chance,
|
|
target,
|
|
executing_move,
|
|
target,
|
|
hit_number,
|
|
&mut chance
|
|
);
|
|
if chance < 100.0 {
|
|
if chance > 0.0 {
|
|
self.get_rng().lock().unwrap().get_float() < (chance / 100.0)
|
|
} else {
|
|
false
|
|
}
|
|
} else {
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Debug for BattleRandom {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
|
|
f.debug_struct("BattleRandom").finish()
|
|
}
|
|
}
|
|
|
|
impl Clone for BattleRandom {
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
random: Mutex::new(self.random.lock().unwrap().clone()),
|
|
}
|
|
}
|
|
}
|