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

Move Form and Species to traits, implement a bunch of mocks
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Deukhoofd 2022-11-28 21:34:28 +01:00
parent c1e09c654b
commit bce636b97e
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
25 changed files with 447 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/dynamic_data/event_hooks.rs
View File

@ -76,16 +76,16 @@ pub enum Event<'own> {
/// The pokemon that changed species.
pokemon: &'own Pokemon,
/// The new species of the Pokemon.
species: Arc<Species>,
species: Arc<dyn Species>,
/// The form of the species the Pokemon will have.
form: Arc<Form>,
form: Arc<dyn Form>,
},
/// This event happens when a Pokemon changes form during battle. This is rather common.
FormChange {
/// The pokemon that changed forms.
pokemon: &'own Pokemon,
/// The new form of the Pokemon.
form: &'own Form,
form: Arc<dyn Form>,
},
/// This event happens when a Pokemon takes damage.
Damage {

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

@ -100,7 +100,7 @@ impl ValueIdentifiable for LearnedMove {
#[cfg(test)]
mod tests {
use super::*;
use crate::static_data::MockMoveData;
use crate::static_data::tests::MockMoveData;
#[test]
fn create_learned_move_restore_uses() {

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

@ -32,16 +32,16 @@ pub struct Pokemon {
/// The library data of the Pokemon.
library: Arc<DynamicLibrary>,
/// The species of the Pokemon.
species: RwLock<Arc<Species>>,
species: RwLock<Arc<dyn Species>>,
/// The form of the Pokemon.
form: RwLock<Arc<Form>>,
form: RwLock<Arc<dyn Form>>,
/// An optional display species of the Pokemon. If this is set, the client should display this
/// species. An example of usage for this is the Illusion ability.
display_species: Option<Arc<Species>>,
display_species: Option<Arc<dyn Species>>,
/// An optional display form of the Pokemon. If this is set, the client should display this
// species. An example of usage for this is the Illusion ability.
display_form: Option<Arc<Form>>,
display_form: Option<Arc<dyn Form>>,
/// The current level of the Pokemon.
level: Atomic<LevelInt>,
@ -121,8 +121,8 @@ impl Pokemon {
/// Instantiates a new Pokemon.
pub fn new(
library: Arc<DynamicLibrary>,
species: Arc<Species>,
form: &Arc<Form>,
species: Arc<dyn Species>,
form: &Arc<dyn Form>,
ability: AbilityIndex,
level: LevelInt,
unique_identifier: u32,
@ -192,15 +192,15 @@ impl Pokemon {
&self.library
}
/// The species of the Pokemon.
pub fn species(&self) -> Arc<Species> {
pub fn species(&self) -> Arc<dyn Species> {
self.species.read().clone()
}
/// The form of the Pokemon.
pub fn form(&self) -> Arc<Form> {
pub fn form(&self) -> Arc<dyn Form> {
self.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<Species> {
pub fn display_species(&self) -> Arc<dyn Species> {
if let Some(v) = &self.display_species {
v.clone()
} else {
@ -208,7 +208,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<Form> {
pub fn display_form(&self) -> Arc<dyn Form> {
if let Some(v) = &self.display_form {
v.clone()
} else {
@ -465,7 +465,7 @@ impl Pokemon {
}
/// Change the species of the Pokemon.
pub fn change_species(&self, species: Arc<Species>, form: Arc<Form>) {
pub fn change_species(&self, species: Arc<dyn Species>, form: Arc<dyn Form>) {
*self.species.write() = species.clone();
*self.form.write() = form.clone();
@ -498,7 +498,7 @@ impl Pokemon {
}
/// Change the form of the Pokemon.
pub fn change_form(&self, form: &Arc<Form>) {
pub fn change_form(&self, form: &Arc<dyn Form>) {
if self.form().value_identifier() == form.value_identifier() {
return;
}
@ -542,7 +542,10 @@ impl Pokemon {
let r = self.battle_data.read();
if let Some(battle_data) = r.deref() {
if let Some(battle) = battle_data.battle() {
battle.event_hook().trigger(Event::FormChange { pokemon: self, form })
battle.event_hook().trigger(Event::FormChange {
pokemon: self,
form: form.clone(),
})
}
}
}

18
src/ffi/dynamic_data/models/pokemon.rs
View File

@ -12,8 +12,8 @@ use std::sync::Arc;
#[no_mangle]
extern "C" fn pokemon_new(
library: ExternPointer<Arc<DynamicLibrary>>,
species: ExternPointer<Arc<Species>>,
form: ExternPointer<Arc<Form>>,
species: ExternPointer<Arc<dyn Species>>,
form: ExternPointer<Arc<dyn Form>>,
hidden_ability: bool,
ability_index: u8,
level: LevelInt,
@ -54,25 +54,25 @@ extern "C" fn pokemon_library(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiableP
/// The species of the Pokemon.
#[no_mangle]
extern "C" fn pokemon_species(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<Species>> {
extern "C" fn pokemon_species(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Species>> {
ptr.as_ref().species().into()
}
/// The form of the Pokemon.
#[no_mangle]
extern "C" fn pokemon_form(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<Form>> {
extern "C" fn pokemon_form(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Form>> {
ptr.as_ref().form().into()
}
/// The species that should be displayed to the user. This handles stuff like the Illusion ability.
#[no_mangle]
extern "C" fn pokemon_display_species(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<Species>> {
extern "C" fn pokemon_display_species(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Species>> {
ptr.as_ref().display_species().into()
}
/// The form that should be displayed to the user. This handles stuff like the Illusion ability.
#[no_mangle]
extern "C" fn pokemon_display_form(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<Form>> {
extern "C" fn pokemon_display_form(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Form>> {
ptr.as_ref().display_form().into()
}
@ -294,8 +294,8 @@ extern "C" fn pokemon_recalculate_boosted_stats(ptr: ExternPointer<Arc<Pokemon>>
#[no_mangle]
extern "C" fn pokemon_change_species(
ptr: ExternPointer<Arc<Pokemon>>,
species: ExternPointer<Arc<Species>>,
form: ExternPointer<Arc<Form>>,
species: ExternPointer<Arc<dyn Species>>,
form: ExternPointer<Arc<dyn Form>>,
) {
ptr.as_ref()
.change_species(species.as_ref().clone(), form.as_ref().clone())
@ -303,7 +303,7 @@ extern "C" fn pokemon_change_species(
/// Change the form of the Pokemon.
#[no_mangle]
extern "C" fn pokemon_change_form(ptr: ExternPointer<Arc<Pokemon>>, form: ExternPointer<Arc<Form>>) {
extern "C" fn pokemon_change_form(ptr: ExternPointer<Arc<Pokemon>>, form: ExternPointer<Arc<dyn Form>>) {
ptr.as_ref().change_form(form.as_ref())
}

2
src/ffi/mod.rs
View File

@ -58,7 +58,7 @@ macro_rules! ffi_vec_value_getters {
/// length function, and a getter.
macro_rules! ffi_vec_stringkey_getters {
(
$type:ident, $func:ident
$type:ty, $func:ident
) => {
paste::paste! {
#[no_mangle]

34
src/ffi/static_data/form.rs
View File

@ -2,7 +2,7 @@ use crate::ffi::{
ffi_arc_getter, ffi_vec_stringkey_getters, ffi_vec_value_getters, BorrowedPtr, ExternPointer, IdentifiablePointer,
OwnedPtr,
};
use crate::static_data::{Form, LearnableMoves, StaticStatisticSet, TypeIdentifier};
use crate::static_data::{Form, FormImpl, LearnableMoves, StaticStatisticSet, TypeIdentifier};
use crate::StringKey;
use hashbrown::HashSet;
use std::ffi::{c_char, CStr, CString};
@ -26,7 +26,7 @@ unsafe extern "C" fn form_new(
moves: OwnedPtr<Box<dyn LearnableMoves>>,
flags: *const *const c_char,
flags_length: usize,
) -> IdentifiablePointer<Arc<Form>> {
) -> IdentifiablePointer<Arc<dyn Form>> {
let name: StringKey = CStr::from_ptr(name).to_str().unwrap().into();
let abilities = std::slice::from_raw_parts(abilities, abilities_length);
@ -46,7 +46,7 @@ unsafe extern "C" fn form_new(
flags_set.insert(CStr::from_ptr(*flag).to_str().unwrap().into());
}
Arc::new(Form::new(
let a: Arc<dyn Form> = Arc::new(FormImpl::new(
&name,
height,
weight,
@ -57,47 +57,49 @@ unsafe extern "C" fn form_new(
hidden_abilities_vec,
*Box::from_raw(moves),
flags_set,
))
.into()
));
a.into()
}
/// Drops a reference count for a form.
#[no_mangle]
unsafe extern "C" fn form_drop(ptr: OwnedPtr<Arc<Form>>) {
unsafe extern "C" fn form_drop(ptr: OwnedPtr<Arc<dyn Form>>) {
drop_in_place(ptr)
}
/// The name of the form.
#[no_mangle]
unsafe extern "C" fn form_name(ptr: ExternPointer<Arc<Form>>) -> OwnedPtr<c_char> {
unsafe extern "C" fn form_name(ptr: ExternPointer<Arc<dyn Form>>) -> OwnedPtr<c_char> {
let name = ptr.as_ref().name();
CString::new(name.str()).unwrap().into_raw()
}
ffi_arc_getter!(Form, height, f32);
ffi_arc_getter!(Form, weight, f32);
ffi_arc_getter!(Form, base_experience, u32);
ffi_arc_getter!(dyn Form, height, f32);
ffi_arc_getter!(dyn Form, weight, f32);
ffi_arc_getter!(dyn Form, base_experience, u32);
ffi_vec_value_getters!(Form, types, TypeIdentifier);
ffi_vec_value_getters!(dyn Form, types, TypeIdentifier);
/// The inherent values of a form of species that are used for the stats of a Pokemon.
#[no_mangle]
unsafe extern "C" fn form_base_stats(ptr: ExternPointer<Arc<Form>>) -> IdentifiablePointer<StaticStatisticSet<u16>> {
unsafe extern "C" fn form_base_stats(
ptr: ExternPointer<Arc<dyn Form>>,
) -> IdentifiablePointer<StaticStatisticSet<u16>> {
(ptr.as_ref().base_stats() as *const StaticStatisticSet<u16>).into()
}
ffi_vec_stringkey_getters!(Form, abilities);
ffi_vec_stringkey_getters!(Form, hidden_abilities);
ffi_vec_stringkey_getters!(dyn Form, abilities);
ffi_vec_stringkey_getters!(dyn Form, hidden_abilities);
/// The moves a Pokemon with this form can learn.
#[no_mangle]
extern "C" fn form_moves(ptr: ExternPointer<Arc<Form>>) -> BorrowedPtr<Box<dyn LearnableMoves>> {
extern "C" fn form_moves(ptr: ExternPointer<Arc<dyn Form>>) -> BorrowedPtr<Box<dyn LearnableMoves>> {
ptr.as_ref().moves() as *const Box<dyn LearnableMoves>
}
/// Check if the form has a specific flag set.
#[no_mangle]
unsafe extern "C" fn form_has_flag(ptr: ExternPointer<Arc<Form>>, flag: *const c_char) -> u8 {
unsafe extern "C" fn form_has_flag(ptr: ExternPointer<Arc<dyn Form>>, flag: *const c_char) -> u8 {
let flag = CStr::from_ptr(flag).into();
u8::from(ptr.as_ref().has_flag(&flag))
}

2
src/ffi/static_data/libraries/mod.rs
View File

@ -72,7 +72,7 @@ macro_rules! library_interface {
};
}
library_interface!(SpeciesLibrary, Species);
library_interface!(SpeciesLibrary, dyn Species);
library_interface!(MoveLibrary, dyn MoveData);
library_interface!(AbilityLibrary, dyn Ability);
library_interface!(ItemLibrary, dyn Item);

32
src/ffi/static_data/species.rs
View File

@ -1,5 +1,5 @@
use crate::ffi::{ffi_arc_getter, ffi_arc_stringkey_getter, BorrowedPtr, ExternPointer, IdentifiablePointer, OwnedPtr};
use crate::static_data::{Form, Species};
use crate::static_data::{Form, Species, SpeciesImpl};
use crate::StringKey;
use hashbrown::HashSet;
use std::ffi::{c_char, CStr};
@ -14,10 +14,10 @@ unsafe extern "C" fn species_new(
gender_rate: f32,
growth_rate: BorrowedPtr<c_char>,
capture_rate: u8,
default_form: OwnedPtr<Arc<Form>>,
default_form: OwnedPtr<Arc<dyn Form>>,
flags: *const *const c_char,
flags_length: usize,
) -> IdentifiablePointer<Arc<Species>> {
) -> IdentifiablePointer<Arc<dyn Species>> {
let name: StringKey = CStr::from_ptr(name).to_str().unwrap().into();
let growth_rate: StringKey = CStr::from_ptr(growth_rate).to_str().unwrap().into();
@ -26,7 +26,7 @@ unsafe extern "C" fn species_new(
for flag in flags {
flags_set.insert(CStr::from_ptr(*flag).to_str().unwrap().into());
}
Arc::new(Species::new(
let a: Arc<dyn Species> = Arc::new(SpeciesImpl::new(
id,
&name,
gender_rate,
@ -34,28 +34,28 @@ unsafe extern "C" fn species_new(
capture_rate,
default_form.as_ref().unwrap().clone(),
flags_set,
))
.into()
));
a.into()
}
/// Drop a reference to the species.
#[no_mangle]
unsafe extern "C" fn species_drop(ptr: OwnedPtr<Arc<Species>>) {
unsafe extern "C" fn species_drop(ptr: OwnedPtr<Arc<dyn Species>>) {
drop_in_place(ptr);
}
ffi_arc_getter!(Species, id, u16);
ffi_arc_stringkey_getter!(Species, name);
ffi_arc_getter!(Species, gender_rate, f32);
ffi_arc_stringkey_getter!(Species, growth_rate);
ffi_arc_getter!(Species, capture_rate, u8);
ffi_arc_getter!(dyn Species, id, u16);
ffi_arc_stringkey_getter!(dyn Species, name);
ffi_arc_getter!(dyn Species, gender_rate, f32);
ffi_arc_stringkey_getter!(dyn Species, growth_rate);
ffi_arc_getter!(dyn Species, capture_rate, u8);
/// Adds a new form to the species.
#[no_mangle]
unsafe extern "C" fn species_add_form(
mut species: ExternPointer<Arc<Species>>,
mut species: ExternPointer<Arc<dyn Species>>,
name: BorrowedPtr<c_char>,
form: OwnedPtr<Arc<Form>>,
form: OwnedPtr<Arc<dyn Form>>,
) {
let form = form.as_ref().unwrap().clone();
species.as_mut().add_form(CStr::from_ptr(name).into(), form)
@ -64,9 +64,9 @@ unsafe extern "C" fn species_add_form(
/// Gets a form by name.
#[no_mangle]
unsafe extern "C" fn species_get_form(
species: ExternPointer<Arc<Species>>,
species: ExternPointer<Arc<dyn Species>>,
name: BorrowedPtr<c_char>,
) -> IdentifiablePointer<Arc<Form>> {
) -> IdentifiablePointer<Arc<dyn Form>> {
let form = species.as_ref().get_form(&CStr::from_ptr(name).into());
if let Some(form) = form {
form.into()

2
src/script_implementations/wasm/export_registry/dynamic_data/pokemon.rs
View File

@ -63,7 +63,7 @@ register! {
fn pokemon_get_species(
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<Species> {
) -> ExternRef<dyn Species> {
let species = pokemon.value_func(&env).unwrap().species();
ExternRef::func_new(&env, &species)
}

22
src/script_implementations/wasm/export_registry/static_data/species.rs
View File

@ -11,7 +11,7 @@ fn species_library_get_species(
env: FunctionEnvMut<WebAssemblyEnv>,
lib: ExternRef<SpeciesLibrary>,
string_key: ExternRef<StringKey>,
) -> ExternRef<Species> {
) -> ExternRef<dyn Species> {
let lib = lib.value_func(&env).unwrap();
let m = lib.get(string_key.value_func(&env).unwrap());
if let Some(v) = m {
@ -23,39 +23,39 @@ fn species_library_get_species(
fn species_get_capture_rate(
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
species: ExternRef<dyn Species>,
) -> u8 {
species.value_func(&env).unwrap().capture_rate()
species.value_func_arc(&env).unwrap().capture_rate()
}
fn species_get_growth_rate(
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
species: ExternRef<dyn Species>,
) -> ExternRef<StringKey> {
let species = species.value_func(&env).unwrap();
let species = species.value_func_arc(&env).unwrap();
ExternRef::func_new(&env, species.growth_rate())
}
fn species_get_gender_rate(
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
species: ExternRef<dyn Species>,
) -> f32 {
species.value_func(&env).unwrap().gender_rate()
species.value_func_arc(&env).unwrap().gender_rate()
}
fn species_get_name(
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
species: ExternRef<dyn Species>,
) -> ExternRef<StringKey> {
let species = species.value_func(&env).unwrap();
let species = species.value_func_arc(&env).unwrap();
ExternRef::func_new(&env, species.name())
}
fn species_get_id(
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
species: ExternRef<dyn Species>,
) -> u16 {
species.value_func(&env).unwrap().id()
species.value_func_arc(&env).unwrap().id()
}

14
src/static_data/growth_rates.rs
View File

@ -40,3 +40,17 @@ impl GrowthRate for LookupGrowthRate {
}
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub GrowthRate {}
impl GrowthRate for GrowthRate {
fn calculate_level(&self, experience: u32) -> LevelInt;
fn calculate_experience(&self, level: LevelInt) -> u32;
}
}
}

23
src/static_data/items.rs
View File

@ -133,3 +133,26 @@ impl ValueIdentifiable for ItemImpl {
self.identifier
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub Item {}
impl Item for Item {
fn name(&self) -> &StringKey;
fn category(&self) -> ItemCategory;
fn battle_category(&self) -> BattleItemCategory;
fn price(&self) -> i32;
fn flags(&self) -> &HashSet<StringKey>;
fn has_flag(&self, key: &StringKey) -> bool;
}
impl ValueIdentifiable for Item {
fn value_identifier(&self) -> ValueIdentifier {
ValueIdentifier::new(0)
}
}
}
}

3
src/static_data/libraries/mod.rs
View File

@ -19,6 +19,9 @@ pub use static_data::StaticData;
#[doc(inline)]
pub use type_library::*;
#[cfg(test)]
pub(crate) mod tests {}
/// The library data for abilities.
mod ability_library;
/// Basic helper trait for libraries.

24
src/static_data/libraries/species_library.rs
View File

@ -13,7 +13,7 @@ pub struct SpeciesLibrary {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
/// The underlying map.
map: IndexMap<StringKey, Arc<Species>>,
map: IndexMap<StringKey, Arc<dyn Species>>,
}
impl SpeciesLibrary {
@ -26,11 +26,11 @@ impl SpeciesLibrary {
}
}
impl DataLibrary<Species> for SpeciesLibrary {
fn map(&self) -> &IndexMap<StringKey, Arc<Species>> {
impl DataLibrary<dyn Species> for SpeciesLibrary {
fn map(&self) -> &IndexMap<StringKey, Arc<dyn Species>> {
&self.map
}
fn get_modify(&mut self) -> &mut IndexMap<StringKey, Arc<Species>> {
fn get_modify(&mut self) -> &mut IndexMap<StringKey, Arc<dyn Species>> {
&mut self.map
}
}
@ -48,18 +48,18 @@ pub mod tests {
use crate::static_data::libraries::data_library::DataLibrary;
use crate::static_data::libraries::species_library::SpeciesLibrary;
use crate::static_data::Species;
use crate::static_data::StaticStatisticSet;
use crate::static_data::{Form, LearnableMovesImpl};
use crate::static_data::LearnableMovesImpl;
use crate::static_data::{FormImpl, StaticStatisticSet};
use crate::static_data::{Species, SpeciesImpl};
fn build_species() -> Species {
Species::new(
fn build_species() -> Arc<dyn Species> {
Arc::new(SpeciesImpl::new(
0,
&"foo".into(),
0.5,
&"test_growthrate".into(),
0,
Arc::new(Form::new(
Arc::new(FormImpl::new(
&"default".into(),
0.0,
0.0,
@ -72,7 +72,7 @@ pub mod tests {
HashSet::new(),
)),
HashSet::new(),
)
))
}
pub fn build() -> SpeciesLibrary {
@ -80,7 +80,7 @@ pub mod tests {
let species = build_species();
// Borrow as mut so we can insert
let w = &mut lib;
w.add(&"foo".into(), Arc::new(species));
w.add(&"foo".into(), species);
// Drops borrow as mut
lib

17
src/static_data/mod.rs
View File

@ -17,6 +17,23 @@ pub use statistic_set::*;
pub use statistics::*;
use std::fmt::{Display, Formatter};
#[cfg(test)]
pub(crate) mod tests {
use super::*;
#[doc(inline)]
pub use growth_rates::tests::*;
#[doc(inline)]
pub use items::tests::*;
#[doc(inline)]
pub use libraries::tests::*;
#[doc(inline)]
pub use moves::tests::*;
#[doc(inline)]
pub use natures::tests::*;
#[doc(inline)]
pub use species_data::tests::*;
}
/// Growth rates define how fast a Pokemon can level up.
mod growth_rates;
/// Items are objects which the player can pick up, keep in their Bag, and use in some manner

10
src/static_data/moves/mod.rs
View File

@ -3,6 +3,16 @@ pub use move_data::*;
#[doc(inline)]
pub use secondary_effect::*;
#[cfg(test)]
pub(crate) mod tests {
use super::*;
#[doc(inline)]
pub use move_data::tests::*;
#[doc(inline)]
pub use secondary_effect::tests::*;
}
/// The data belonging to a certain move.
mod move_data;
/// A secondary effect is an effect on a move that happens after it hits.

42
src/static_data/moves/move_data.rs
View File

@ -208,25 +208,29 @@ impl ValueIdentifiable for MoveDataImpl {
}
#[cfg(test)]
mockall::mock! {
#[derive(Debug)]
pub MoveData{}
impl MoveData for MoveData {
fn name(&self) -> &StringKey;
fn move_type(&self) -> TypeIdentifier;
fn category(&self) -> MoveCategory;
fn base_power(&self) -> u8;
fn accuracy(&self) -> u8;
fn base_usages(&self) -> u8;
fn target(&self) -> MoveTarget;
fn priority(&self) -> i8;
fn secondary_effect(&self) -> &Option<Box<dyn SecondaryEffect>>;
fn has_flag(&self, key: &StringKey) -> bool;
fn has_flag_by_hash(&self, key_hash: u32) -> bool;
}
impl ValueIdentifiable for MoveData{
fn value_identifier(&self) -> ValueIdentifier{
ValueIdentifier::new(0)
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub MoveData{}
impl MoveData for MoveData {
fn name(&self) -> &StringKey;
fn move_type(&self) -> TypeIdentifier;
fn category(&self) -> MoveCategory;
fn base_power(&self) -> u8;
fn accuracy(&self) -> u8;
fn base_usages(&self) -> u8;
fn target(&self) -> MoveTarget;
fn priority(&self) -> i8;
fn secondary_effect(&self) -> &Option<Box<dyn SecondaryEffect>>;
fn has_flag(&self, key: &StringKey) -> bool;
fn has_flag_by_hash(&self, key_hash: u32) -> bool;
}
impl ValueIdentifiable for MoveData{
fn value_identifier(&self) -> ValueIdentifier{
ValueIdentifier::new(0)
}
}
}
}

18
src/static_data/moves/secondary_effect.rs
View File

@ -59,12 +59,28 @@ impl ValueIdentifiable for SecondaryEffectImpl {
}
#[cfg(test)]
mod tests {
pub(crate) mod tests {
use super::*;
use assert_approx_eq::assert_approx_eq;
use crate::static_data::moves::secondary_effect::SecondaryEffect;
use crate::static_data::SecondaryEffectImpl;
mockall::mock! {
#[derive(Debug)]
pub SecondaryEffect{}
impl SecondaryEffect for SecondaryEffect {
fn chance(&self) -> f32;
fn effect_name(&self) -> &StringKey;
fn parameters(&self) -> &Vec<EffectParameter>;
}
impl ValueIdentifiable for SecondaryEffect{
fn value_identifier(&self) -> ValueIdentifier{
ValueIdentifier::new(0)
}
}
}
#[test]
fn create_secondary_effect() {
let empty = SecondaryEffectImpl::new(0.0, "".into(), vec![]);

20
src/static_data/natures.rs
View File

@ -80,3 +80,23 @@ impl ValueIdentifiable for NatureImpl {
self.identifier
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub Nature {}
impl Nature for Nature {
fn increased_stat(&self) -> Statistic;
fn decreased_stat(&self) -> Statistic;
fn get_stat_modifier(&self, stat: Statistic) -> f32;
}
impl ValueIdentifiable for Nature {
fn value_identifier(&self) -> ValueIdentifier {
ValueIdentifier::new(0)
}
}
}
}

20
src/static_data/species_data/ability.rs
View File

@ -68,3 +68,23 @@ pub struct AbilityIndex {
/// The index of the ability.
pub index: u8,
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub Ability{}
impl Ability for Ability {
fn name(&self) -> &StringKey;
fn effect(&self) -> &StringKey;
fn parameters(&self) -> &Vec<EffectParameter>;
}
impl ValueIdentifiable for Ability {
fn value_identifier(&self) -> ValueIdentifier {
ValueIdentifier::new(0)
}
}
}
}

128
src/static_data/species_data/form.rs
View File

@ -1,4 +1,5 @@
use hashbrown::HashSet;
use std::fmt::Debug;
use crate::static_data::Statistic;
use crate::static_data::TypeIdentifier;
@ -7,10 +8,56 @@ use crate::static_data::{AbilityIndex, LearnableMoves};
use crate::StringKey;
use crate::{Random, ValueIdentifiable, ValueIdentifier};
/// A form is a variant of a specific species. A species always has at least one form, but can have
/// many more.
pub trait Form: ValueIdentifiable + Debug {
/// The name of the form.
fn name(&self) -> &StringKey;
/// The height of the form in meters.
fn height(&self) -> f32;
/// The weight of the form in kilograms.
fn weight(&self) -> f32;
/// The base amount of experience that is gained when beating a Pokemon with this form.
fn base_experience(&self) -> u32;
/// The normal types a Pokemon with this form has.
fn types(&self) -> &Vec<TypeIdentifier>;
/// The inherent values of a form of species that are used for the stats of a Pokemon.
fn base_stats(&self) -> &StaticStatisticSet<u16>;
/// The possible abilities a Pokemon with this form can have.
fn abilities(&self) -> &Vec<StringKey>;
/// The possible hidden abilities a Pokemon with this form can have.
fn hidden_abilities(&self) -> &Vec<StringKey>;
#[allow(clippy::borrowed_box)]
/// The moves a Pokemon with this form can learn.
fn moves(&self) -> &Box<dyn LearnableMoves>;
/// Arbitrary flags can be set on a form for scripting use.
fn flags(&self) -> &HashSet<StringKey>;
/// Get a type of the move at a certain index.
fn get_type(&self, index: usize) -> TypeIdentifier;
/// Gets a single base stat value.
fn get_base_stat(&self, stat: Statistic) -> u16;
/// Find the index of an ability that can be on this form.
fn find_ability_index(&self, ability: &dyn Ability) -> Option<AbilityIndex>;
/// Gets an ability from the form.
fn get_ability(&self, index: AbilityIndex) -> &StringKey;
/// Gets a random ability from the form.
fn get_random_ability(&self, rand: &mut Random) -> &StringKey;
/// Gets a random hidden ability from the form.
fn get_random_hidden_ability(&self, rand: &mut Random) -> &StringKey;
/// Check if the form has a specific flag set.
fn has_flag(&self, key: &StringKey) -> bool;
}
/// A form is a variant of a specific species. A species always has at least one form, but can have
/// many more.
#[derive(Debug)]
pub struct Form {
pub struct FormImpl {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
/// The name of the form.
@ -35,7 +82,7 @@ pub struct Form {
flags: HashSet<StringKey>,
}
impl Form {
impl FormImpl {
/// Instantiates a new form.
pub fn new(
name: &StringKey,
@ -48,8 +95,8 @@ impl Form {
hidden_abilities: Vec<StringKey>,
moves: Box<dyn LearnableMoves>,
flags: HashSet<StringKey>,
) -> Form {
Form {
) -> Self {
Self {
identifier: Default::default(),
name: name.clone(),
height,
@ -63,62 +110,64 @@ impl Form {
flags,
}
}
}
impl Form for FormImpl {
/// The name of the form.
pub fn name(&self) -> &StringKey {
fn name(&self) -> &StringKey {
&self.name
}
/// The height of the form in meters.
pub fn height(&self) -> f32 {
fn height(&self) -> f32 {
self.height
}
/// The weight of the form in kilograms.
pub fn weight(&self) -> f32 {
fn weight(&self) -> f32 {
self.weight
}
/// The base amount of experience that is gained when beating a Pokemon with this form.
pub fn base_experience(&self) -> u32 {
fn base_experience(&self) -> u32 {
self.base_experience
}
/// The normal types a Pokemon with this form has.
pub fn types(&self) -> &Vec<TypeIdentifier> {
fn types(&self) -> &Vec<TypeIdentifier> {
&self.types
}
/// The inherent values of a form of species that are used for the stats of a Pokemon.
pub fn base_stats(&self) -> &StaticStatisticSet<u16> {
fn base_stats(&self) -> &StaticStatisticSet<u16> {
&self.base_stats
}
/// The possible abilities a Pokemon with this form can have.
pub fn abilities(&self) -> &Vec<StringKey> {
fn abilities(&self) -> &Vec<StringKey> {
&self.abilities
}
/// The possible hidden abilities a Pokemon with this form can have.
pub fn hidden_abilities(&self) -> &Vec<StringKey> {
fn hidden_abilities(&self) -> &Vec<StringKey> {
&self.hidden_abilities
}
#[allow(clippy::borrowed_box)]
/// The moves a Pokemon with this form can learn.
pub fn moves(&self) -> &Box<dyn LearnableMoves> {
fn moves(&self) -> &Box<dyn LearnableMoves> {
&self.moves
}
/// Arbitrary flags can be set on a form for scripting use.
pub fn flags(&self) -> &HashSet<StringKey> {
fn flags(&self) -> &HashSet<StringKey> {
&self.flags
}
/// Get a type of the move at a certain index.
pub fn get_type(&self, index: usize) -> TypeIdentifier {
fn get_type(&self, index: usize) -> TypeIdentifier {
self.types[index]
}
/// Gets a single base stat value.
pub fn get_base_stat(&self, stat: Statistic) -> u16 {
fn get_base_stat(&self, stat: Statistic) -> u16 {
self.base_stats.get_stat(stat)
}
/// Find the index of an ability that can be on this form.
pub fn find_ability_index(&self, ability: &dyn Ability) -> Option<AbilityIndex> {
fn find_ability_index(&self, ability: &dyn Ability) -> Option<AbilityIndex> {
for (index, a) in self.abilities.iter().enumerate() {
if a == ability.name() {
return Some(AbilityIndex {
@ -139,7 +188,7 @@ impl Form {
}
/// Gets an ability from the form.
pub fn get_ability(&self, index: AbilityIndex) -> &StringKey {
fn get_ability(&self, index: AbilityIndex) -> &StringKey {
if index.hidden {
&self.hidden_abilities[index.index as usize]
} else {
@ -148,22 +197,57 @@ impl Form {
}
/// Gets a random ability from the form.
pub fn get_random_ability(&self, rand: &mut Random) -> &StringKey {
fn get_random_ability(&self, rand: &mut Random) -> &StringKey {
&self.abilities[rand.get_between_unsigned(0, self.abilities.len() as u32) as usize]
}
/// Gets a random hidden ability from the form.
pub fn get_random_hidden_ability(&self, rand: &mut Random) -> &StringKey {
fn get_random_hidden_ability(&self, rand: &mut Random) -> &StringKey {
&self.hidden_abilities[rand.get_between_unsigned(0, self.hidden_abilities.len() as u32) as usize]
}
/// Check if the form has a specific flag set.
pub fn has_flag(&self, key: &StringKey) -> bool {
fn has_flag(&self, key: &StringKey) -> bool {
self.flags.contains(key)
}
}
impl ValueIdentifiable for Form {
impl ValueIdentifiable for FormImpl {
fn value_identifier(&self) -> ValueIdentifier {
self.identifier
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub Form {}
impl Form for Form {
fn name(&self) -> &StringKey;
fn height(&self) -> f32;
fn weight(&self) -> f32;
fn base_experience(&self) -> u32;
fn types(&self) -> &Vec<TypeIdentifier>;
fn base_stats(&self) -> &StaticStatisticSet<u16>;
fn abilities(&self) -> &Vec<StringKey>;
fn hidden_abilities(&self) -> &Vec<StringKey>;
#[allow(clippy::borrowed_box)]
fn moves(&self) -> &Box<dyn LearnableMoves>;
fn flags(&self) -> &HashSet<StringKey>;
fn get_type(&self, index: usize) -> TypeIdentifier;
fn get_base_stat(&self, stat: Statistic) -> u16;
fn find_ability_index(&self, ability: &dyn Ability) -> Option<AbilityIndex>;
fn get_ability(&self, index: AbilityIndex) -> &StringKey;
fn get_random_ability(&self, rand: &mut Random) -> &StringKey;
fn get_random_hidden_ability(&self, rand: &mut Random) -> &StringKey;
fn has_flag(&self, key: &StringKey) -> bool;
}
impl ValueIdentifiable for Form {
fn value_identifier(&self) -> ValueIdentifier {
ValueIdentifier::new(0)
}
}
}
}

13
src/static_data/species_data/learnable_moves.rs
View File

@ -59,9 +59,8 @@ impl LearnableMoves for LearnableMovesImpl {
}
#[cfg(test)]
mod tests {
use crate::static_data::species_data::learnable_moves::LearnableMoves;
use crate::static_data::LearnableMovesImpl;
pub(crate) mod tests {
use super::*;
#[test]
fn adds_level_moves() {
@ -92,4 +91,12 @@ mod tests {
assert_eq!(distinct.len(), 1);
assert_eq!(distinct[0], "foo".into());
}
mockall::mock! {
pub LearnableMoves {
fn add_level_move(&mut self, level: LevelInt, m: &StringKey);
fn get_learned_by_level<'a>(&'a self, level: LevelInt) -> Option<&'a Vec<StringKey>>;
fn get_distinct_level_moves(&self) -> &Vec<StringKey>;
}
}
}

8
src/static_data/species_data/mod.rs
View File

@ -9,6 +9,14 @@ pub use learnable_moves::*;
#[doc(inline)]
pub use species::*;
#[cfg(test)]
pub(crate) mod tests {
pub use super::ability::tests::*;
pub use super::form::tests::*;
pub use super::learnable_moves::tests::*;
pub use super::species::tests::*;
}
/// An ability is a passive effect in battle that is attached to a Pokemon.
mod ability;
/// A form is a variant of a specific species. A species always has at least one form, but can have

99
src/static_data/species_data/species.rs
View File

@ -1,3 +1,4 @@
use std::fmt::Debug;
use std::sync::{Arc, LazyLock};
use hashbrown::{HashMap, HashSet};
@ -9,9 +10,38 @@ use crate::static_data::Gender;
use crate::StringKey;
use crate::{Random, ValueIdentifiable, ValueIdentifier};
/// The data belonging to a Pokemon with certain characteristics.
pub trait Species: ValueIdentifiable + Debug {
/// The national dex identifier of the Pokemon.
fn id(&self) -> u16;
/// The name of the Pokemon.
fn name(&self) -> &StringKey;
/// The chance between 0.0 and 1.0 that a Pokemon is female.
fn gender_rate(&self) -> f32;
/// How much experience is required for a level.
fn growth_rate(&self) -> &StringKey;
/// How hard it is to capture a Pokemon. 255 means this will be always caught, 0 means this is
/// uncatchable.
fn capture_rate(&self) -> u8;
/// The forms that belong to this Pokemon.
fn forms(&self) -> RwLockReadGuard<'_, RawRwLock, HashMap<StringKey, Arc<dyn Form>>>;
/// The arbitrary flags that can be set on a Pokemon for script use.
fn flags(&self) -> &HashSet<StringKey>;
/// Adds a new form to the species.
fn add_form(&self, id: StringKey, form: Arc<dyn Form>);
/// Gets a form by name.
fn get_form(&self, id: &StringKey) -> Option<Arc<dyn Form>>;
/// Gets the form the Pokemon will have by default, if no other form is specified.
fn get_default_form(&self) -> Arc<dyn Form>;
/// Gets a random gender.
fn get_random_gender(&self, rand: &mut Random) -> Gender;
/// Check whether the Pokemon has a specific flag set.
fn has_flag(&self, key: &StringKey) -> bool;
}
/// The data belonging to a Pokemon with certain characteristics.
#[derive(Debug)]
pub struct Species {
pub struct SpeciesImpl {
/// A unique identifier so we know what value this is.
identifier: ValueIdentifier,
/// The national dex identifier of the Pokemon.
@ -26,7 +56,7 @@ pub struct Species {
/// uncatchable.
capture_rate: u8,
/// The forms that belong to this Pokemon.
forms: RwLock<HashMap<StringKey, Arc<Form>>>,
forms: RwLock<HashMap<StringKey, Arc<dyn Form>>>,
/// The arbitrary flags that can be set on a Pokemon for script use.
flags: HashSet<StringKey>,
}
@ -39,7 +69,7 @@ fn get_default_key() -> StringKey {
DEFAULT_KEY.clone()
}
impl Species {
impl SpeciesImpl {
/// Creates a new species.
pub fn new(
id: u16,
@ -47,12 +77,12 @@ impl Species {
gender_rate: f32,
growth_rate: &StringKey,
capture_rate: u8,
default_form: Arc<Form>,
default_form: Arc<dyn Form>,
flags: HashSet<StringKey>,
) -> Species {
) -> Self {
let mut forms = HashMap::with_capacity(1);
forms.insert_unique_unchecked(get_default_key(), default_form);
Species {
Self {
identifier: Default::default(),
id,
name: name.clone(),
@ -63,54 +93,56 @@ impl Species {
flags,
}
}
}
impl Species for SpeciesImpl {
/// The national dex identifier of the Pokemon.
pub fn id(&self) -> u16 {
fn id(&self) -> u16 {
self.id
}
/// The name of the Pokemon.
pub fn name(&self) -> &StringKey {
fn name(&self) -> &StringKey {
&self.name
}
/// The chance between 0.0 and 1.0 that a Pokemon is female.
pub fn gender_rate(&self) -> f32 {
fn gender_rate(&self) -> f32 {
self.gender_rate
}
/// How much experience is required for a level.
pub fn growth_rate(&self) -> &StringKey {
fn growth_rate(&self) -> &StringKey {
&self.growth_rate
}
/// How hard it is to capture a Pokemon. 255 means this will be always caught, 0 means this is
/// uncatchable.
pub fn capture_rate(&self) -> u8 {
fn capture_rate(&self) -> u8 {
self.capture_rate
}
/// The forms that belong to this Pokemon.
pub fn forms(&self) -> RwLockReadGuard<'_, RawRwLock, HashMap<StringKey, Arc<Form>>> {
fn forms(&self) -> RwLockReadGuard<'_, RawRwLock, HashMap<StringKey, Arc<dyn Form>>> {
self.forms.read()
}
/// The arbitrary flags that can be set on a Pokemon for script use.
pub fn flags(&self) -> &HashSet<StringKey> {
fn flags(&self) -> &HashSet<StringKey> {
&self.flags
}
/// Adds a new form to the species.
pub fn add_form(&self, id: StringKey, form: Arc<Form>) {
fn add_form(&self, id: StringKey, form: Arc<dyn Form>) {
self.forms.write().insert(id, form);
}
/// Gets a form by name.
pub fn get_form(&self, id: &StringKey) -> Option<Arc<Form>> {
fn get_form(&self, id: &StringKey) -> Option<Arc<dyn Form>> {
self.forms.read().get(id).cloned()
}
/// Gets the form the Pokemon will have by default, if no other form is specified.
pub fn get_default_form(&self) -> Arc<Form> {
fn get_default_form(&self) -> Arc<dyn Form> {
self.forms.read().get(&get_default_key()).unwrap().clone()
}
/// Gets a random gender.
pub fn get_random_gender(&self, rand: &mut Random) -> Gender {
fn get_random_gender(&self, rand: &mut Random) -> Gender {
if self.gender_rate < 0.0 {
Gender::Genderless
} else if rand.get_float() >= self.gender_rate {
@ -121,13 +153,42 @@ impl Species {
}
/// Check whether the Pokemon has a specific flag set.
pub fn has_flag(&self, key: &StringKey) -> bool {
fn has_flag(&self, key: &StringKey) -> bool {
self.flags.contains(key)
}
}
impl ValueIdentifiable for Species {
impl ValueIdentifiable for SpeciesImpl {
fn value_identifier(&self) -> ValueIdentifier {
self.identifier
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub Species {}
impl Species for Species {
fn id(&self) -> u16;
fn name(&self) -> &StringKey;
fn gender_rate(&self) -> f32;
fn growth_rate(&self) -> &StringKey;
fn capture_rate(&self) -> u8;
fn forms(&self) -> RwLockReadGuard<'_, RawRwLock, HashMap<StringKey, Arc<dyn Form>>>;
fn flags(&self) -> &HashSet<StringKey>;
fn add_form(&self, id: StringKey, form: Arc<dyn Form>);
fn get_form(&self, id: &StringKey) -> Option<Arc<dyn Form>>;
fn get_default_form(&self) -> Arc<dyn Form>;
fn get_random_gender(&self, rand: &mut Random) -> Gender;
fn has_flag(&self, key: &StringKey) -> bool;
}
impl ValueIdentifiable for Species {
fn value_identifier(&self) -> ValueIdentifier {
ValueIdentifier::new(0)
}
}
}
}

14
tests/common/library_loader.rs
View File

@ -16,10 +16,10 @@ use pkmn_lib::dynamic_data::Gen7DamageLibrary;
use pkmn_lib::dynamic_data::Gen7MiscLibrary;
use pkmn_lib::script_implementations::wasm::script_resolver::WebAssemblyScriptResolver;
use pkmn_lib::static_data::{
AbilityImpl, AbilityLibrary, BattleItemCategory, DataLibrary, EffectParameter, Form, GrowthRateLibrary, ItemImpl,
ItemLibrary, LearnableMoves, LearnableMovesImpl, LibrarySettings, LookupGrowthRate, MoveDataImpl, MoveLibrary,
NatureImpl, NatureLibrary, SecondaryEffect, SecondaryEffectImpl, Species, StaticData, StaticStatisticSet,
Statistic, TypeLibrary,
AbilityImpl, AbilityLibrary, BattleItemCategory, DataLibrary, EffectParameter, Form, FormImpl, GrowthRateLibrary,
ItemImpl, ItemLibrary, LearnableMoves, LearnableMovesImpl, LibrarySettings, LookupGrowthRate, MoveDataImpl,
MoveLibrary, NatureImpl, NatureLibrary, SecondaryEffect, SecondaryEffectImpl, SpeciesImpl, StaticData,
StaticStatisticSet, Statistic, TypeLibrary,
};
use pkmn_lib::StringKey;
@ -263,7 +263,7 @@ pub fn load_species(path: &String, library: &mut StaticData) {
let default_form_value = forms.get("default").unwrap();
let default_form = parse_form("default".into(), default_form_value, library);
let species = Species::new(
let species = SpeciesImpl::new(
id as u16,
&name,
gender_rate as f32,
@ -285,7 +285,7 @@ fn load_wasm(path: &String, library: &mut WebAssemblyScriptResolver) {
library.finalize();
}
fn parse_form(name: StringKey, value: &Value, library: &mut StaticData) -> Arc<Form> {
fn parse_form(name: StringKey, value: &Value, library: &mut StaticData) -> Arc<dyn Form> {
let mut abilities = Vec::new();
for a in value.get("abilities").unwrap().as_array().unwrap() {
abilities.push(a.as_str().unwrap().into());
@ -310,7 +310,7 @@ fn parse_form(name: StringKey, value: &Value, library: &mut StaticData) -> Arc<F
let moves = parse_moves(value.get("moves").unwrap(), library.moves());
Arc::new(Form::new(
Arc::new(FormImpl::new(
&name,
height as f32,
weight as f32,