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

More work on mocking and removing the impls from the interface

This commit is contained in:
Deukhoofd 2023-01-05 12:54:18 +01:00
parent 6e15a26813
commit 417b776a83
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
19 changed files with 1107 additions and 950 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gen_7_scripts/src/lib.rs
View File

@ -8,6 +8,7 @@
extern crate alloc;
use alloc::boxed::Box;
#[cfg(not(test))]
use pkmn_lib_interface::set_load_script_fn;
#[macro_use]

33
gen_7_scripts/src/moves/after_you.rs
View File

@ -39,3 +39,36 @@ impl Script for AfterYou {
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::rc::Rc;
use pkmn_lib_interface::app_interface::{
MockBattle, MockChoiceQueue, MockExecutingMove, MockPokemon,
};
#[test]
fn move_pokemon_choice_next_gets_called_once() {
let mut battle = MockBattle::new();
battle.expect_choice_queue().once().return_once_st(move || {
let mut choice_queue = MockChoiceQueue::new();
choice_queue
.expect_move_pokemon_choice_next()
.once()
.return_const(true);
Rc::new(choice_queue)
});
let battle = Rc::new(battle);
let mut target = MockPokemon::new();
target
.expect_battle()
.once()
.return_once_st(move || Some(battle.clone()));
let target = Rc::new(target);
let script = AfterYou::new();
script.on_secondary_effect(Rc::new(MockExecutingMove::new()), target, 0);
}
}

8
gen_7_scripts/src/moves/assurance.rs
View File

@ -3,8 +3,7 @@ use alloc::boxed::Box;
use core::any::Any;
use core::sync::atomic::{AtomicBool, Ordering};
use pkmn_lib_interface::app_interface::{
BattleSide, BattleSideImpl, DamageSource, DataLibrary, ExecutingMove, Pokemon, TurnChoice,
WithVolatile,
BattleSide, DamageSource, DataLibrary, ExecutingMove, Pokemon, TurnChoice, WithVolatile,
};
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};
@ -26,10 +25,9 @@ impl Script for Assurance {
]
}
#[cfg(not(test))]
fn on_before_turn(&self, choice: TurnChoice) {
if let TurnChoice::Move(data) = &choice {
let side: BattleSideImpl = choice
let side: BattleSide = choice
.user()
.battle()
.unwrap()
@ -90,7 +88,7 @@ impl Script for AssuranceData {
#[cfg(not(test))]
fn on_end_turn(&self) {
let side: BattleSideImpl = self.get_owner().unwrap();
let side: pkmn_lib_interface::app_interface::BattleSideImpl = self.get_owner().unwrap();
side.remove_volatile(self);
}

4
gen_7_scripts/src/moves/aurora_veil.rs
View File

@ -6,7 +6,7 @@ use alloc::boxed::Box;
use core::any::Any;
use core::sync::atomic::{AtomicU32, Ordering};
use pkmn_lib_interface::app_interface::{
BattleSide, BattleSideImpl, ExecutingMove, MoveCategory, Pokemon, WithVolatile,
BattleSide, ExecutingMove, MoveCategory, Pokemon, WithVolatile,
};
use pkmn_lib_interface::handling::ScriptCapabilities::OnEndTurn;
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};
@ -76,7 +76,7 @@ impl Script for AuroraVeilEffect {
if mv.get_hit_data(&target, hit).is_critical() {
return;
}
let side: BattleSideImpl = self.get_owner().unwrap();
let side: pkmn_lib_interface::app_interface::BattleSideImpl = self.get_owner().unwrap();
if side.has_volatile(ReflectEffect::get_const_name())
&& mv.use_move().category() == MoveCategory::Physical
{

5
gen_7_scripts/src/moves/change_all_target_stats.rs
View File

@ -1,7 +1,8 @@
use crate::script;
use alloc::rc::Rc;
use core::any::Any;
use core::sync::atomic::{AtomicI8, Ordering};
use pkmn_lib_interface::app_interface::list::ImmutableList;
use pkmn_lib_interface::app_interface::list::{ImmutableList, ImmutableListTrait};
use pkmn_lib_interface::app_interface::{
DynamicLibrary, EffectParameter, ExecutingMove, Pokemon, Statistic,
};
@ -34,7 +35,7 @@ impl Script for ChangeAllTargetStats {
fn on_initialize(
&self,
_library: &DynamicLibrary,
parameters: Option<ImmutableList<EffectParameter>>,
parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
self.amount.store(
parameters.unwrap().get(0).unwrap().as_int() as i8,

3
gen_7_scripts/src/moves/change_target_stats.rs
View File

@ -1,3 +1,4 @@
use alloc::rc::Rc;
use core::any::Any;
use core::sync::atomic::{AtomicI8, Ordering};
use pkmn_lib_interface::app_interface::list::ImmutableList;
@ -42,7 +43,7 @@ macro_rules! change_stat_effect {
fn on_initialize(
&self,
_library: &DynamicLibrary,
parameters: Option<ImmutableList<EffectParameter>>,
parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
self.amount.store(
parameters.unwrap().get(0).unwrap().as_int() as i8,

5
gen_7_scripts/src/moves/drain.rs
View File

@ -1,8 +1,9 @@
use crate::script;
use alloc::rc::Rc;
use atomic_float::AtomicF32;
use core::any::Any;
use core::sync::atomic::Ordering;
use pkmn_lib_interface::app_interface::list::ImmutableList;
use pkmn_lib_interface::app_interface::list::{ImmutableList, ImmutableListTrait};
use pkmn_lib_interface::app_interface::{DynamicLibrary, EffectParameter, ExecutingMove, Pokemon};
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};
@ -29,7 +30,7 @@ impl Script for Drain {
fn on_initialize(
&self,
_library: &DynamicLibrary,
parameters: Option<ImmutableList<EffectParameter>>,
parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
self.heal_modifier.store(
parameters.unwrap().get(0).unwrap().as_float(),

32
pkmn_lib_interface/src/app_interface/dynamic_data/battle.rs
View File

@ -1,16 +1,16 @@
use alloc::rc::Rc;
use crate::app_interface::list::ImmutableList;
use crate::app_interface::BattleSideImpl;
use crate::app_interface::{
BattleParty, BattlePartyImpl, BattleRandom, ChoiceQueue, DynamicLibrary, Pokemon, StringKey,
BattleParty, BattlePartyImpl, BattleRandom, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon,
StringKey,
};
#[cfg_attr(feature = "mock_data", mockall::automock)]
pub trait BattleTrait {
fn library(&self) -> DynamicLibrary;
fn parties(&self) -> ImmutableList<BattlePartyImpl>;
fn sides(&self) -> ImmutableList<BattleSideImpl>;
fn parties(&self) -> ImmutableList<BattleParty>;
fn sides(&self) -> ImmutableList<BattleSide>;
fn random(&self) -> BattleRandom;
fn choice_queue(&self) -> ChoiceQueue;
fn get_pokemon(&self, side: u8, index: u8) -> Option<Pokemon>;
@ -33,6 +33,9 @@ pub type MockBattle = MockBattleTrait;
#[cfg(not(feature = "mock_data"))]
mod implementation {
use super::*;
use crate::app_interface::list::{
BattlePartyImmutableList, BattleSideImmutableList, ImmutableListWasm,
};
use crate::app_interface::PokemonImpl;
use crate::app_interface::{
BattleParty, BattlePartyImpl, BattleRandom, BattleRandomImpl, BattleSide, BattleSideImpl,
@ -42,15 +45,14 @@ mod implementation {
use crate::handling::Cacheable;
use crate::{
cached_value, cached_value_getters, wasm_value_getters, wasm_value_getters_extern,
wasm_value_getters_funcs, DynamicLibrary, ExternRef, ExternalReferenceType, ImmutableList,
StringKey, VecExternRef,
wasm_value_getters_funcs, ExternRef, ExternalReferenceType, StringKey, VecExternRef,
};
struct BattleInner {
reference: ExternRef<BattleImpl>,
library: CachedValue<DynamicLibrary>,
parties: CachedValue<ImmutableList<BattlePartyImpl>>,
sides: CachedValue<ImmutableList<BattleSideImpl>>,
parties: CachedValue<ImmutableList<BattleParty>>,
sides: CachedValue<ImmutableList<BattleSide>>,
random: CachedValue<Rc<BattleRandomImpl>>,
choice_queue: CachedValue<Rc<ChoiceQueueImpl>>,
}
@ -67,8 +69,14 @@ mod implementation {
inner: Rc::new(BattleInner {
reference,
library: cached_value!({ battle_get_library(reference).get_value().unwrap() }),
parties: cached_value!({ battle_get_parties(reference).get_immutable_list() }),
sides: cached_value!({ battle_get_sides(reference).get_immutable_list() }),
parties: cached_value!({
let reference = battle_get_parties(reference);
Rc::new(BattlePartyImmutableList::from_ref(reference))
}),
sides: cached_value!({
let reference = battle_get_sides(reference);
Rc::new(BattleSideImmutableList::from_ref(reference))
}),
random: cached_value!({
Rc::new(battle_get_random(reference).get_value().unwrap())
}),
@ -84,8 +92,8 @@ mod implementation {
impl BattleTrait for BattleImpl {
cached_value_getters! {
fn library(&self) -> DynamicLibrary;
fn parties(&self) -> ImmutableList<BattlePartyImpl>;
fn sides(&self) -> ImmutableList<BattleSideImpl>;
fn parties(&self) -> ImmutableList<BattleParty>;
fn sides(&self) -> ImmutableList<BattleSide>;
fn random(&self) -> BattleRandom;
fn choice_queue(&self) -> ChoiceQueue;
}

229
pkmn_lib_interface/src/app_interface/dynamic_data/battle_side.rs
View File

@ -1,15 +1,5 @@
use crate::app_interface::{Battle, Pokemon, WithVolatile};
#[cfg(not(feature = "mock_data"))]
use crate::app_interface::{BattleImpl, PokemonImpl};
use crate::handling::cacheable::Cacheable;
use crate::handling::cached_value::CachedValue;
use crate::{
cached_value, cached_value_getters, wasm_value_getters, wasm_value_getters_extern,
wasm_value_getters_funcs, ExternRef, ExternalReferenceType, Script, ScriptPtr,
};
use alloc::boxed::Box;
use alloc::rc::Rc;
use cstr_core::{c_char, CString};
pub trait BattleSideTrait: WithVolatile {
fn side_index(&self) -> u8;
@ -23,128 +13,141 @@ pub trait BattleSideTrait: WithVolatile {
pub type BattleSide = Rc<dyn BattleSideTrait>;
#[cfg(not(feature = "mock_data"))]
struct BattleSideInner {
reference: ExternRef<BattleSideImpl>,
side_index: CachedValue<u8>,
pokemon_per_side: CachedValue<u8>,
battle: CachedValue<Rc<BattleImpl>>,
}
mod implementation {
use super::*;
use crate::app_interface::{BattleImpl, PokemonImpl};
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::{Cacheable, Script};
use crate::{
cached_value, cached_value_getters, wasm_value_getters_extern, wasm_value_getters_funcs,
ScriptPtr,
};
use alloc::boxed::Box;
use cstr_core::{c_char, CString};
#[derive(Clone)]
pub struct BattleSideImpl {
#[cfg(not(feature = "mock_data"))]
inner: Rc<BattleSideInner>,
}
struct BattleSideInner {
reference: ExternRef<BattleSideImpl>,
side_index: CachedValue<u8>,
pokemon_per_side: CachedValue<u8>,
battle: CachedValue<Rc<BattleImpl>>,
}
#[cfg(not(feature = "mock_data"))]
impl BattleSideImpl {
pub fn new(reference: ExternRef<Self>) -> Self {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(BattleSideInner {
reference,
side_index: cached_value!({ battleside_get_side_index(reference) }),
pokemon_per_side: cached_value!({ battleside_get_pokemon_per_side(reference) }),
battle: cached_value!({
Rc::new(battleside_get_battle(reference).get_value().unwrap())
#[derive(Clone)]
pub struct BattleSideImpl {
inner: Rc<BattleSideInner>,
}
impl BattleSideImpl {
pub fn new(reference: ExternRef<Self>) -> Self {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(BattleSideInner {
reference,
side_index: cached_value!({ battleside_get_side_index(reference) }),
pokemon_per_side: cached_value!({ battleside_get_pokemon_per_side(reference) }),
battle: cached_value!({
Rc::new(battleside_get_battle(reference).get_value().unwrap())
}),
}),
}),
})
}
}
#[cfg(not(feature = "mock_data"))]
impl BattleSideTrait for BattleSideImpl {
cached_value_getters! {
fn side_index(&self) -> u8;
fn pokemon_per_side(&self) -> u8;
fn battle(&self) -> Battle;
})
}
}
fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
unsafe {
let p = battleside_get_pokemon(self.inner.reference, index).get_value();
if let Some(p) = p {
Some(Rc::new(p))
} else {
None
impl BattleSideTrait for BattleSideImpl {
cached_value_getters! {
fn side_index(&self) -> u8;
fn pokemon_per_side(&self) -> u8;
fn battle(&self) -> Battle;
}
fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
unsafe {
let p = battleside_get_pokemon(self.inner.reference, index).get_value();
if let Some(p) = p {
Some(Rc::new(p))
} else {
None
}
}
}
wasm_value_getters_funcs! {
BattleSide,
fn has_fled_battle(&self) -> bool;
fn is_defeated(&self) -> bool;
}
}
wasm_value_getters_funcs! {
BattleSide,
fn has_fled_battle(&self) -> bool;
fn is_defeated(&self) -> bool;
}
}
impl WithVolatile for BattleSideImpl {
fn has_volatile(&self, script_name: &str) -> bool {
unsafe {
let script_name = CString::new(script_name).unwrap();
battleside_has_volatile(self.inner.reference, script_name.as_ptr())
}
}
fn add_volatile(&self, script: Box<dyn Script>) -> &dyn Script {
unsafe {
battleside_add_volatile(self.inner.reference, ScriptPtr::new(script))
.val()
.unwrap()
}
}
#[cfg(not(feature = "mock_data"))]
impl WithVolatile for BattleSideImpl {
fn has_volatile(&self, script_name: &str) -> bool {
unsafe {
fn add_volatile_by_name(&self, script_name: &str) -> &dyn Script {
unsafe {
let ptr = CString::new(script_name).unwrap();
battleside_add_volatile_by_name(self.inner.reference, ptr.as_ptr())
.val()
.unwrap()
}
}
fn remove_volatile(&self, script: &dyn Script) {
unsafe {
let name = CString::new(script.get_name()).unwrap();
battleside_remove_volatile(self.inner.reference, name.as_ptr());
}
}
fn get_volatile_script(&self, script_name: &str) -> Option<&dyn Script> {
let script_name = CString::new(script_name).unwrap();
battleside_has_volatile(self.inner.reference, script_name.as_ptr())
}
}
fn add_volatile(&self, script: Box<dyn Script>) -> &dyn Script {
unsafe {
battleside_add_volatile(self.inner.reference, ScriptPtr::new(script))
.val()
.unwrap()
unsafe { battleside_get_volatile(self.inner.reference, script_name.as_ptr()).val() }
}
}
fn add_volatile_by_name(&self, script_name: &str) -> &dyn Script {
unsafe {
let ptr = CString::new(script_name).unwrap();
battleside_add_volatile_by_name(self.inner.reference, ptr.as_ptr())
.val()
.unwrap()
wasm_value_getters_extern! {
BattleSideImpl, BattleSide,
pub fn has_fled_battle(&self) -> bool;
pub fn is_defeated(&self) -> bool;
}
crate::handling::cacheable::cacheable!(BattleSideImpl);
impl ExternalReferenceType for BattleSideImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
fn remove_volatile(&self, script: &dyn Script) {
unsafe {
let name = CString::new(script.get_name()).unwrap();
battleside_remove_volatile(self.inner.reference, name.as_ptr());
}
}
extern "wasm" {
fn battleside_get_side_index(r: ExternRef<BattleSideImpl>) -> u8;
fn battleside_get_pokemon_per_side(r: ExternRef<BattleSideImpl>) -> u8;
fn battleside_get_battle(r: ExternRef<BattleSideImpl>) -> ExternRef<BattleImpl>;
fn battleside_get_pokemon(
r: ExternRef<BattleSideImpl>,
index: usize,
) -> ExternRef<PokemonImpl>;
fn get_volatile_script(&self, script_name: &str) -> Option<&dyn Script> {
let script_name = CString::new(script_name).unwrap();
unsafe { battleside_get_volatile(self.inner.reference, script_name.as_ptr()).val() }
}
}
wasm_value_getters_extern! {
BattleSideImpl, BattleSide,
pub fn has_fled_battle(&self) -> bool;
pub fn is_defeated(&self) -> bool;
}
crate::handling::cacheable::cacheable!(BattleSideImpl);
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for BattleSideImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
fn battleside_add_volatile_by_name(
r: ExternRef<BattleSideImpl>,
name: *const c_char,
) -> ScriptPtr;
fn battleside_add_volatile(r: ExternRef<BattleSideImpl>, script: ScriptPtr) -> ScriptPtr;
fn battleside_has_volatile(r: ExternRef<BattleSideImpl>, name: *const c_char) -> bool;
fn battleside_remove_volatile(r: ExternRef<BattleSideImpl>, name: *const c_char);
fn battleside_get_volatile(r: ExternRef<BattleSideImpl>, name: *const c_char) -> ScriptPtr;
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn battleside_get_side_index(r: ExternRef<BattleSideImpl>) -> u8;
fn battleside_get_pokemon_per_side(r: ExternRef<BattleSideImpl>) -> u8;
fn battleside_get_battle(r: ExternRef<BattleSideImpl>) -> ExternRef<BattleImpl>;
fn battleside_get_pokemon(r: ExternRef<BattleSideImpl>, index: usize)
-> ExternRef<PokemonImpl>;
fn battleside_add_volatile_by_name(
r: ExternRef<BattleSideImpl>,
name: *const c_char,
) -> ScriptPtr;
fn battleside_add_volatile(r: ExternRef<BattleSideImpl>, script: ScriptPtr) -> ScriptPtr;
fn battleside_has_volatile(r: ExternRef<BattleSideImpl>, name: *const c_char) -> bool;
fn battleside_remove_volatile(r: ExternRef<BattleSideImpl>, name: *const c_char);
fn battleside_get_volatile(r: ExternRef<BattleSideImpl>, name: *const c_char) -> ScriptPtr;
}
pub use implementation::*;

71
pkmn_lib_interface/src/app_interface/dynamic_data/choice_queue.rs
View File

@ -1,44 +1,53 @@
#[cfg(not(feature = "mock_data"))]
use crate::app_interface::PokemonImpl;
use crate::{ExternRef, ExternalReferenceType, Pokemon};
use crate::app_interface::Pokemon;
use alloc::rc::Rc;
#[cfg_attr(feature = "mock_data", mockall::automock)]
pub trait ChoiceQueueTrait {
fn move_pokemon_choice_next(&self, pokemon: &Pokemon) -> bool;
}
pub type ChoiceQueue = Rc<dyn ChoiceQueueTrait>;
#[derive(Clone)]
pub struct ChoiceQueueImpl {
reference: ExternRef<ChoiceQueueImpl>,
}
#[cfg(feature = "mock_data")]
pub type MockChoiceQueue = MockChoiceQueueTrait;
#[cfg(not(feature = "mock_data"))]
impl ChoiceQueueImpl {
pub fn new(reference: ExternRef<ChoiceQueueImpl>) -> Self {
Self { reference }
mod implementation {
use super::*;
use crate::app_interface::PokemonImpl;
use crate::{ExternRef, ExternalReferenceType};
#[derive(Clone)]
pub struct ChoiceQueueImpl {
reference: ExternRef<ChoiceQueueImpl>,
}
impl ChoiceQueueImpl {
pub fn new(reference: ExternRef<ChoiceQueueImpl>) -> Self {
Self { reference }
}
}
impl ChoiceQueueTrait for ChoiceQueueImpl {
fn move_pokemon_choice_next(&self, pokemon: &Pokemon) -> bool {
unsafe {
choice_queue_move_pokemon_choice_next(self.reference, pokemon.reference().into())
}
}
}
impl ExternalReferenceType for ChoiceQueueImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
extern "wasm" {
fn choice_queue_move_pokemon_choice_next(
r: ExternRef<ChoiceQueueImpl>,
pokemon: ExternRef<PokemonImpl>,
) -> bool;
}
}
#[cfg(not(feature = "mock_data"))]
impl ChoiceQueueTrait for ChoiceQueueImpl {
fn move_pokemon_choice_next(&self, pokemon: &Pokemon) -> bool {
unsafe { choice_queue_move_pokemon_choice_next(self.reference, pokemon.reference().into()) }
}
}
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for ChoiceQueueImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn choice_queue_move_pokemon_choice_next(
r: ExternRef<ChoiceQueueImpl>,
pokemon: ExternRef<PokemonImpl>,
) -> bool;
}
pub use implementation::*;

41
pkmn_lib_interface/src/app_interface/dynamic_data/pokemon.rs
View File

@ -1,6 +1,6 @@
use crate::app_interface::{
AbilityImpl, AbilityIndex, Battle, BattleSide, ClampedStatisticSet, DynamicLibrary, Form,
Gender, Item, LearnedMove, LevelInt, Nature, Species, Statistic, StatisticSet, TypeIdentifier,
Ability, AbilityIndex, Battle, BattleSide, ClampedStatisticSet, DynamicLibrary, Form, Gender,
Item, LearnedMove, LevelInt, Nature, Species, Statistic, StatisticSet, TypeIdentifier,
WithVolatile,
};
use crate::handling::Script;
@ -16,7 +16,7 @@ pub trait PokemonTrait: WithVolatile {
fn species(&self) -> Species;
fn form(&self) -> Form;
fn active_ability(&self) -> AbilityImpl;
fn active_ability(&self) -> Ability;
fn nature(&self) -> Nature;
fn display_species(&self) -> Option<Species>;
fn display_form(&self) -> Option<Form>;
@ -86,14 +86,15 @@ mod implementation {
use super::*;
use cstr_core::CString;
use crate::app_interface::{BattleImpl, ItemImpl, StatisticSetImpl};
use crate::app_interface::{AbilityImpl, BattleImpl, ItemImpl, StatisticSetImpl};
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
use crate::implementation::ScriptPtr;
use crate::{
cached_value, cached_value_getters, wasm_optional_reference_getters_extern,
wasm_optional_reference_getters_funcs, wasm_reference_getters_extern,
wasm_reference_getters_funcs, wasm_value_getters_extern, wasm_value_getters_funcs,
DynamicLibrary, ExternRef, ExternalReferenceType, Script, ScriptPtr, TypeIdentifier,
ExternRef, ExternalReferenceType, Script,
};
struct PokemonInner {
@ -234,23 +235,29 @@ mod implementation {
}
}
fn battle_side(&self) -> BattleSide {
Rc::new(
self.battle()
.unwrap()
.sides()
.get(self.battle_side_index() as u32)
.unwrap(),
)
self.battle()
.unwrap()
.sides()
.get(self.battle_side_index() as u32)
.unwrap()
}
wasm_reference_getters_funcs! {
Pokemon,
fn species(&self) -> Species;
fn form(&self) -> Form;
fn active_ability(&self) -> AbilityImpl;
fn nature(&self) -> Nature;
}
fn active_ability(&self) -> Ability {
unsafe {
let implementation = pokemon_get_active_ability(self.reference())
.get_value()
.unwrap();
Rc::new(implementation)
}
}
wasm_optional_reference_getters_funcs! {
Pokemon,
fn display_species(&self) -> Option<Species>;
@ -338,7 +345,6 @@ mod implementation {
}
}
#[cfg(not(feature = "mock_data"))]
impl PokemonImpl {
pub(crate) fn new(reference: ExternRef<Self>) -> Self {
Self::from_ref(reference, &|reference| Self {
@ -371,7 +377,6 @@ mod implementation {
}
}
#[cfg(not(feature = "mock_data"))]
wasm_reference_getters_extern! {
PokemonImpl, Pokemon,
pub fn species(&self) -> Species;
@ -380,7 +385,6 @@ mod implementation {
pub fn nature(&self) -> Nature;
}
#[cfg(not(feature = "mock_data"))]
wasm_optional_reference_getters_extern! {
PokemonImpl, Pokemon,
pub fn display_species(&self) -> Option<Species>;
@ -389,7 +393,6 @@ mod implementation {
pub fn battle(&self) -> Option<BattleImpl>;
}
#[cfg(not(feature = "mock_data"))]
wasm_value_getters_extern! {
PokemonImpl, Pokemon,
pub fn level(&self) -> LevelInt;
@ -418,14 +421,12 @@ mod implementation {
crate::handling::cacheable::cacheable!(PokemonImpl);
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for PokemonImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn pokemon_get_library(r: ExternRef<PokemonImpl>) -> ExternRef<DynamicLibrary>;
fn pokemon_get_flat_stats(r: ExternRef<PokemonImpl>) -> ExternRef<StatisticSetImpl<u32>>;
@ -489,7 +490,7 @@ mockall::mock!(
fn reference(&self) -> u32;
fn species(&self) -> Species;
fn form(&self) -> Form;
fn active_ability(&self) -> AbilityImpl;
fn active_ability(&self) -> Ability;
fn nature(&self) -> Nature;
fn display_species(&self) -> Option<Species>;
fn display_form(&self) -> Option<Form>;

275
pkmn_lib_interface/src/app_interface/list.rs
View File

@ -1,114 +1,205 @@
use crate::{ExternalReferenceType, VecExternRef};
use alloc::boxed::Box;
#[cfg(feature = "mock_data")]
use alloc::rc::Rc;
use alloc::vec::Vec;
use core::marker::PhantomData;
#[cfg(not(feature = "mock_data"))]
struct ImmutableListInner<T: Clone> {
extern_ref: VecExternRef<T>,
resource_type: PhantomData<T>,
values: spin::RwLock<Vec<Option<Option<T>>>>,
pub trait ImmutableListTrait<T> {
fn get(&self, index: u32) -> Option<T>;
}
#[derive(Clone)]
#[cfg(not(feature = "mock_data"))]
pub struct ImmutableList<T>
where
T: Clone,
T: ExternalReferenceType,
{
inner: *const ImmutableListInner<T>,
}
pub type ImmutableList<T> = Rc<dyn ImmutableListTrait<T>>;
#[cfg(not(feature = "mock_data"))]
impl<T> ImmutableList<T>
where
T: Clone,
T: ExternalReferenceType,
{
fn new(extern_ref: VecExternRef<T>) -> Self {
let mut values = Vec::new();
values.resize(extern_ref.len() as usize, None);
let inner = Box::new(ImmutableListInner {
extern_ref,
resource_type: Default::default(),
values: spin::RwLock::new(values),
});
let inner_ptr = Box::into_raw(inner);
ImmutableList {
inner: inner_ptr as *const ImmutableListInner<T>,
}
mod implementation {
use super::*;
use crate::app_interface::{
BattleParty, BattlePartyImpl, BattleSide, BattleSideImpl, EffectParameter, StringKey,
};
use crate::handling::extern_ref::{ExternalReferenceType, VecExternRef};
use alloc::boxed::Box;
use alloc::vec::Vec;
use core::marker::PhantomData;
pub(crate) struct ImmutableListInner<T: Clone> {
extern_ref: VecExternRef<T>,
resource_type: PhantomData<T>,
values: spin::RwLock<Vec<Option<Option<Rc<T>>>>>,
}
pub(crate) fn from_ref(extern_ref: VecExternRef<T>) -> Self {
unsafe {
if let None = CACHE {
CACHE = Some(hashbrown::HashMap::new());
}
let existing = CACHE
.as_ref()
.unwrap()
.get(&extern_ref.get_internal_index());
if let Some(v) = existing {
let inner = *v as *const ImmutableListInner<T>;
ImmutableList { inner }
} else {
let v = Self::new(extern_ref);
CACHE
.as_mut()
pub(crate) trait ImmutableListWasm<T: Clone + ExternalReferenceType> {
fn initialize(inner: *const ImmutableListInner<T>) -> Self
where
Self: Sized;
fn new(extern_ref: VecExternRef<T>) -> Self
where
Self: Sized,
{
let mut values = Vec::new();
values.resize(extern_ref.len() as usize, None);
let inner = Box::new(ImmutableListInner {
extern_ref,
resource_type: Default::default(),
values: spin::RwLock::new(values),
});
let inner_ptr = Box::into_raw(inner);
Self::initialize(inner_ptr)
}
fn from_ref(extern_ref: VecExternRef<T>) -> Self
where
Self: Sized,
{
unsafe {
if let None = CACHE {
CACHE = Some(hashbrown::HashMap::new());
}
let existing = CACHE
.as_ref()
.unwrap()
.insert(extern_ref.get_internal_index(), v.inner as *const u8);
v
}
}
}
pub fn get(&self, index: u32) -> Option<T> {
unsafe {
let inner = self.inner.as_ref().unwrap();
{
let rg = inner.values.read();
let v = rg.get(index as usize).unwrap();
if let Some(v) = v {
return v.clone();
.get(&extern_ref.get_internal_index());
if let Some(v) = existing {
let inner = *v as *const ImmutableListInner<T>;
Self::initialize(inner)
} else {
let v = Self::new(extern_ref);
CACHE.as_mut().unwrap().insert(
extern_ref.get_internal_index(),
v.get_inner_ptr() as *const u8,
);
v
}
}
}
fn get_inner(&self) -> &ImmutableListInner<T> {
unsafe { self.get_inner_ptr().as_ref().unwrap() }
}
fn get_inner_ptr(&self) -> *const ImmutableListInner<T>;
fn get_cached(&self, index: u32) -> Option<Rc<T>> {
let inner = self.get_inner();
let rg = inner.values.read();
let v = rg.get(index as usize).unwrap();
if let Some(v) = v {
return v.clone();
}
return None;
}
fn get_value(&self, index: u32) -> Option<Rc<T>> {
if let Some(cached) = self.get_cached(index) {
return Some(cached);
}
let inner = self.get_inner();
let r = inner.extern_ref.at(index);
let value = r.get_value();
let value = if let Some(value) = value {
Some(Rc::new(value))
} else {
None
};
let mut wg = inner.values.write();
wg[index as usize] = Some(value);
wg[index as usize].as_ref().unwrap().clone()
}
}
}
#[cfg(feature = "mock_data")]
pub struct ImmutableListInner<T> {
values: Vec<T>,
}
#[cfg(feature = "mock_data")]
#[derive(Clone)]
pub struct ImmutableList<T> {
inner: Rc<ImmutableListInner<T>>,
}
#[cfg(feature = "mock_data")]
impl<T> ImmutableList<T>
where
T: Clone,
{
pub fn mock(values: Vec<T>) -> Self {
Self {
inner: Rc::new(ImmutableListInner { values }),
let v = wg[index as usize].as_ref().unwrap().clone();
v
}
}
pub fn get(&self, index: u32) -> Option<T> {
self.inner.values.get(index as usize).cloned()
macro_rules! immutable_list_type {
($type_name:ident, $underlying:ident) => {
paste::paste! {
pub struct [<$type_name ImmutableList>] {
inner: *const ImmutableListInner<$underlying>,
}
impl ImmutableListWasm<$underlying> for [<$type_name ImmutableList>] {
fn initialize(inner: *const ImmutableListInner<$underlying>) -> Self
where
Self: Sized,
{
Self { inner }
}
fn get_inner_ptr(&self) -> *const ImmutableListInner<$underlying> {
self.inner
}
}
impl ImmutableListTrait<$type_name> for [<$type_name ImmutableList>] {
fn get(&self, index: u32) -> Option<$type_name> {
let v = self.get_value(index);
if let Some(v) = v {
Some(v)
} else {
None
}
}
}
}
};
}
immutable_list_type!(BattleSide, BattleSideImpl);
immutable_list_type!(BattleParty, BattlePartyImpl);
pub struct EffectParameterImmutableList {
inner: *const ImmutableListInner<EffectParameter>,
}
impl ImmutableListWasm<EffectParameter> for EffectParameterImmutableList {
fn initialize(inner: *const ImmutableListInner<EffectParameter>) -> Self
where
Self: Sized,
{
Self { inner }
}
fn get_inner_ptr(&self) -> *const ImmutableListInner<EffectParameter> {
self.inner
}
}
impl ImmutableListTrait<Rc<EffectParameter>> for EffectParameterImmutableList {
fn get(&self, index: u32) -> Option<Rc<EffectParameter>> {
let v = self.get_value(index);
if let Some(v) = v {
Some(v)
} else {
None
}
}
}
#[derive(Clone)]
pub struct StringKeyImmutableList {
inner: *const ImmutableListInner<StringKey>,
}
impl ImmutableListWasm<StringKey> for StringKeyImmutableList {
fn initialize(inner: *const ImmutableListInner<StringKey>) -> Self
where
Self: Sized,
{
Self { inner }
}
fn get_inner_ptr(&self) -> *const ImmutableListInner<StringKey> {
self.inner
}
}
impl ImmutableListTrait<Rc<StringKey>> for StringKeyImmutableList {
fn get(&self, index: u32) -> Option<Rc<StringKey>> {
let v = self.get_value(index);
if let Some(v) = v {
Some(v)
} else {
None
}
}
}
static mut CACHE: Option<hashbrown::HashMap<u32, *const u8>> = None;
}
static mut CACHE: Option<hashbrown::HashMap<u32, *const u8>> = None;
#[cfg(not(feature = "mock_data"))]
pub use implementation::*;

124
pkmn_lib_interface/src/app_interface/static_data/ability.rs
View File

@ -1,60 +1,13 @@
use crate::handling::cacheable::Cacheable;
use crate::handling::cached_value::CachedValue;
use crate::{
cached_value, cached_value_getters, EffectParameter, ExternRef, ExternalReferenceType,
ImmutableList, StringKey, VecExternRef,
};
use crate::StringKey;
use alloc::rc::Rc;
struct AbilityInner {
reference: ExternRef<AbilityImpl>,
name: CachedValue<StringKey>,
effect: CachedValue<StringKey>,
parameters: CachedValue<ImmutableList<EffectParameter>>,
}
#[cfg_attr(test, mockall::automock)]
pub trait Ability {
pub trait AbilityTrait {
fn name(&self) -> StringKey;
fn effect(&self) -> StringKey;
}
#[derive(Clone)]
pub struct AbilityImpl {
inner: Rc<AbilityInner>,
}
impl AbilityImpl {
#[cfg(not(feature = "mock_data"))]
pub fn new(reference: ExternRef<Self>) -> Self {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(AbilityInner {
reference,
name: cached_value!({ ability_get_name(reference).get_value().unwrap() }),
effect: cached_value!({ ability_get_effect(reference).get_value().unwrap() }),
parameters: cached_value!({
ability_get_parameters(reference).get_immutable_list()
}),
}),
})
}
}
impl Ability for AbilityImpl {
cached_value_getters! {
fn name(&self) -> StringKey;
fn effect(&self) -> StringKey;
}
}
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for AbilityImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
crate::handling::cacheable::cacheable!(AbilityImpl);
pub type Ability = Rc<dyn AbilityTrait>;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(C)]
@ -64,8 +17,71 @@ pub struct AbilityIndex {
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn ability_get_name(r: ExternRef<AbilityImpl>) -> ExternRef<StringKey>;
fn ability_get_effect(r: ExternRef<AbilityImpl>) -> ExternRef<StringKey>;
fn ability_get_parameters(r: ExternRef<AbilityImpl>) -> VecExternRef<EffectParameter>;
mod implementation {
use super::*;
use crate::app_interface::list::{
EffectParameterImmutableList, ImmutableList, ImmutableListWasm,
};
use crate::app_interface::{EffectParameter, StringKey};
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType, VecExternRef};
use crate::handling::Cacheable;
use crate::{cached_value, cached_value_getters};
use alloc::rc::Rc;
struct AbilityInner {
reference: ExternRef<AbilityImpl>,
name: CachedValue<StringKey>,
effect: CachedValue<StringKey>,
parameters: CachedValue<ImmutableList<Rc<EffectParameter>>>,
}
#[derive(Clone)]
pub struct AbilityImpl {
inner: Rc<AbilityInner>,
}
impl AbilityImpl {
#[cfg(not(feature = "mock_data"))]
pub fn new(reference: ExternRef<Self>) -> Self {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(AbilityInner {
reference,
name: cached_value!({ ability_get_name(reference).get_value().unwrap() }),
effect: cached_value!({ ability_get_effect(reference).get_value().unwrap() }),
parameters: cached_value!({
Rc::new(EffectParameterImmutableList::from_ref(
ability_get_parameters(reference),
))
}),
}),
})
}
}
impl AbilityTrait for AbilityImpl {
cached_value_getters! {
fn name(&self) -> StringKey;
fn effect(&self) -> StringKey;
}
}
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for AbilityImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
crate::handling::cacheable::cacheable!(AbilityImpl);
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn ability_get_name(r: ExternRef<AbilityImpl>) -> ExternRef<StringKey>;
fn ability_get_effect(r: ExternRef<AbilityImpl>) -> ExternRef<StringKey>;
fn ability_get_parameters(r: ExternRef<AbilityImpl>) -> VecExternRef<EffectParameter>;
}
}
#[cfg(not(feature = "mock_data"))]
pub use implementation::*;

3
pkmn_lib_interface/src/app_interface/static_data/data_libraries/type_library.rs
View File

@ -1,4 +1,5 @@
use crate::{ExternRef, ExternalReferenceType, TypeIdentifier};
use crate::app_interface::TypeIdentifier;
use crate::{ExternRef, ExternalReferenceType};
use alloc::rc::Rc;
use alloc::string::{String, ToString};
use cstr_core::{c_char, CString};

1
pkmn_lib_interface/src/app_interface/static_data/effect_parameter.rs
View File

@ -63,7 +63,6 @@ impl EffectParameter {
}
panic!("Unexpected effect parameter type: {}", self);
}
}
#[cfg(not(feature = "mock_data"))]

29
pkmn_lib_interface/src/app_interface/static_data/species.rs
View File

@ -1,9 +1,12 @@
use crate::app_interface::get_hash;
use crate::app_interface::list::ImmutableList;
#[cfg(not(feature = "mock_data"))]
use crate::app_interface::list::ImmutableListWasm;
use crate::handling::cached_value::CachedValue;
use crate::handling::ffi_array::FFIArray;
use crate::handling::Cacheable;
use crate::{
cached_value, cached_value_getters, ExternRef, ExternalReferenceType, FFIArray, ImmutableList,
StringKey, VecExternRef,
cached_value, cached_value_getters, ExternRef, ExternalReferenceType, StringKey, VecExternRef,
};
use alloc::rc::Rc;
use alloc::vec::Vec;
@ -97,8 +100,8 @@ struct FormInner {
types: CachedValue<Vec<u8>>,
base_experience: CachedValue<u32>,
base_stats: CachedValue<ImmutableStatisticSet>,
abilities: CachedValue<ImmutableList<StringKey>>,
hidden_abilities: CachedValue<ImmutableList<StringKey>>,
abilities: CachedValue<ImmutableList<Rc<StringKey>>>,
hidden_abilities: CachedValue<ImmutableList<Rc<StringKey>>>,
// moves: CachedValue<LearnableMoves>,
}
@ -122,9 +125,19 @@ impl Form {
}),
base_experience: cached_value!({ form_get_base_experience(reference) }),
base_stats: cached_value!({ form_get_base_stats(reference).get_value().unwrap() }),
abilities: cached_value!({ form_get_abilities(reference).get_immutable_list() }),
abilities: cached_value!({
Rc::new(
crate::app_interface::list::StringKeyImmutableList::from_ref(
form_get_abilities(reference),
),
)
}),
hidden_abilities: cached_value!({
form_get_hidden_abilities(reference).get_immutable_list()
Rc::new(
crate::app_interface::list::StringKeyImmutableList::from_ref(
form_get_hidden_abilities(reference),
),
)
}),
}),
})
@ -140,8 +153,8 @@ impl Form {
pub fn weight(&self) -> f32;
pub fn base_experience(&self) -> u32;
pub fn base_stats(&self) -> ImmutableStatisticSet;
pub fn abilities(&self) -> ImmutableList<StringKey>;
pub fn hidden_abilities(&self) -> ImmutableList<StringKey>;
pub fn abilities(&self) -> ImmutableList<Rc<StringKey>>;
pub fn hidden_abilities(&self) -> ImmutableList<Rc<StringKey>>;
}
pub fn types(&self) -> &Vec<u8> {
self.inner.types.value_ref()

10
pkmn_lib_interface/src/handling/extern_ref.rs
View File

@ -1,4 +1,3 @@
use crate::app_interface::list::ImmutableList;
use alloc::rc::Rc;
use core::cmp::Ordering;
use core::hash::{Hash, Hasher};
@ -152,15 +151,6 @@ impl<T> VecExternRef<T> {
resource_type: Default::default(),
}
}
#[cfg(not(feature = "mock_data"))]
pub(crate) fn get_immutable_list(&self) -> ImmutableList<T>
where
T: Clone,
T: ExternalReferenceType,
{
ImmutableList::from_ref(*self)
}
}
impl<T> Clone for VecExternRef<T> {

10
pkmn_lib_interface/src/handling/script.rs
View File

@ -1,10 +1,12 @@
use crate::app_interface::list::ImmutableList;
use crate::app_interface::{
Battle, DamageSource, DynamicLibrary, EffectParameter, ExecutingMove, Item, Pokemon, Statistic,
TurnChoice, TypeIdentifier,
};
use crate::handling::ScriptCapabilities;
use crate::{ExternRef, ExternalReferenceType, ScriptPtr, StringKey, TurnChoice, TypeIdentifier};
use crate::{ExternRef, ExternalReferenceType, StringKey};
use alloc::boxed::Box;
use alloc::rc::Rc;
use core::any::Any;
use core::fmt::Debug;
@ -25,7 +27,7 @@ pub trait Script {
fn on_initialize(
&self,
_library: &DynamicLibrary,
_parameters: Option<ImmutableList<EffectParameter>>,
_parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
}
@ -352,7 +354,7 @@ pub trait Script {
Self: Sized,
{
unsafe {
script_get_owner(ScriptPtr::from_existing(self))
script_get_owner(crate::implementation::ScriptPtr::from_existing(self))
.cast::<T>()
.get_value()
}
@ -375,5 +377,5 @@ impl Debug for dyn Script {
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn script_get_owner(pointer: ScriptPtr) -> ExternRef<u8>;
fn script_get_owner(pointer: crate::implementation::ScriptPtr) -> ExternRef<u8>;
}

1171
pkmn_lib_interface/src/lib.rs
View File

File diff suppressed because it is too large Load Diff