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

A lot of cleanup work
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Deukhoofd 2023-01-05 14:52:33 +01:00
parent c1da29bdeb
commit d4c30d50aa
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
23 changed files with 690 additions and 622 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gen_7_scripts/src/moves/acrobatics.rs
View File

@ -1,5 +1,4 @@
use crate::script;
use alloc::boxed::Box;
use core::any::Any;
use pkmn_lib_interface::app_interface::{ExecutingMove, Pokemon};
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};

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

@ -1,4 +1,3 @@
use alloc::boxed::Box;
use core::any::Any;
use pkmn_lib_interface::app_interface::{ExecutingMove, Pokemon};
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};

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

@ -3,7 +3,7 @@ use alloc::boxed::Box;
use core::any::Any;
use core::sync::atomic::{AtomicBool, Ordering};
use pkmn_lib_interface::app_interface::{
BattleSide, DamageSource, DataLibrary, ExecutingMove, Pokemon, TurnChoice, WithVolatile,
BattleSide, DamageSource, ExecutingMove, Pokemon, TurnChoice, WithVolatile,
};
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};

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

@ -5,9 +5,7 @@ use crate::weather::hail::Hail;
use alloc::boxed::Box;
use core::any::Any;
use core::sync::atomic::{AtomicU32, Ordering};
use pkmn_lib_interface::app_interface::{
BattleSide, ExecutingMove, MoveCategory, Pokemon, WithVolatile,
};
use pkmn_lib_interface::app_interface::{ExecutingMove, MoveCategory, Pokemon, WithVolatile};
use pkmn_lib_interface::handling::ScriptCapabilities::OnEndTurn;
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};

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

@ -2,7 +2,7 @@ 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, ImmutableListTrait};
use pkmn_lib_interface::app_interface::list::ImmutableList;
use pkmn_lib_interface::app_interface::{
DynamicLibrary, EffectParameter, ExecutingMove, Pokemon, Statistic,
};
@ -34,7 +34,7 @@ impl Script for ChangeAllTargetStats {
fn on_initialize(
&self,
_library: &DynamicLibrary,
_library: DynamicLibrary,
parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
self.amount.store(

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

@ -42,7 +42,7 @@ macro_rules! change_stat_effect {
fn on_initialize(
&self,
_library: &DynamicLibrary,
_library: DynamicLibrary,
parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
self.amount.store(

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

@ -3,7 +3,7 @@ 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, ImmutableListTrait};
use pkmn_lib_interface::app_interface::list::ImmutableList;
use pkmn_lib_interface::app_interface::{DynamicLibrary, EffectParameter, ExecutingMove, Pokemon};
use pkmn_lib_interface::handling::{Script, ScriptCapabilities};
@ -29,7 +29,7 @@ impl Script for Drain {
fn on_initialize(
&self,
_library: &DynamicLibrary,
_library: DynamicLibrary,
parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
self.heal_modifier.store(

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

@ -2,8 +2,7 @@ use alloc::rc::Rc;
use crate::app_interface::list::ImmutableList;
use crate::app_interface::{
BattleParty, BattlePartyImpl, BattleRandom, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon,
StringKey,
BattleParty, BattleRandom, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon, StringKey,
};
#[cfg_attr(feature = "mock_data", mockall::automock)]
@ -33,6 +32,7 @@ pub type MockBattle = MockBattleTrait;
#[cfg(not(feature = "mock_data"))]
mod implementation {
use super::*;
use crate::app_interface::dynamic_data::dynamic_library::DynamicLibraryImpl;
use crate::app_interface::list::{
BattlePartyImmutableList, BattleSideImmutableList, ImmutableListWasm,
};
@ -44,8 +44,8 @@ mod implementation {
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
use crate::{
cached_value, cached_value_getters, wasm_value_getters, wasm_value_getters_extern,
wasm_value_getters_funcs, ExternRef, ExternalReferenceType, StringKey, VecExternRef,
cached_value, cached_value_getters, wasm_value_getters_extern, wasm_value_getters_funcs,
ExternRef, ExternalReferenceType, StringKey, VecExternRef,
};
struct BattleInner {
@ -68,7 +68,9 @@ mod implementation {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(BattleInner {
reference,
library: cached_value!({ battle_get_library(reference).get_value().unwrap() }),
library: cached_value!({
Rc::new(battle_get_library(reference).get_value().unwrap())
}),
parties: cached_value!({
let reference = battle_get_parties(reference);
Rc::new(BattlePartyImmutableList::from_ref(reference))
@ -168,7 +170,7 @@ mod implementation {
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn battle_get_library(r: ExternRef<BattleImpl>) -> ExternRef<DynamicLibrary>;
fn battle_get_library(r: ExternRef<BattleImpl>) -> ExternRef<DynamicLibraryImpl>;
fn battle_get_parties(r: ExternRef<BattleImpl>) -> VecExternRef<BattlePartyImpl>;
fn battle_get_sides(r: ExternRef<BattleImpl>) -> VecExternRef<BattleSideImpl>;
fn battle_get_random(r: ExternRef<BattleImpl>) -> ExternRef<BattleRandomImpl>;

50
pkmn_lib_interface/src/app_interface/dynamic_data/battle_party.rs
View File

@ -1,7 +1,4 @@
use crate::app_interface::{Party, PartyImpl};
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
use crate::{cached_value, cached_value_getters, ExternRef, ExternalReferenceType};
use crate::app_interface::Party;
use alloc::rc::Rc;
pub trait BattlePartyTrait {
@ -10,18 +7,26 @@ pub trait BattlePartyTrait {
pub type BattleParty = Rc<dyn BattlePartyTrait>;
struct BattlePartyInner {
#[cfg(not(feature = "mock_data"))]
mod implementation {
use crate::app_interface::{BattlePartyTrait, Party, PartyImpl};
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::Cacheable;
use crate::{cached_value, cached_value_getters};
use alloc::rc::Rc;
struct BattlePartyInner {
reference: ExternRef<BattlePartyImpl>,
party: CachedValue<Rc<PartyImpl>>,
}
}
#[derive(Clone)]
pub struct BattlePartyImpl {
#[derive(Clone)]
pub struct BattlePartyImpl {
inner: Rc<BattlePartyInner>,
}
}
#[cfg(not(feature = "mock_data"))]
impl BattlePartyImpl {
impl BattlePartyImpl {
pub fn new(reference: ExternRef<BattlePartyImpl>) -> Self {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(BattlePartyInner {
@ -32,25 +37,28 @@ impl BattlePartyImpl {
}),
})
}
}
}
#[cfg(not(feature = "mock_data"))]
impl BattlePartyTrait for BattlePartyImpl {
impl BattlePartyTrait for BattlePartyImpl {
cached_value_getters! {
fn party(&self) -> Party;
}
}
}
crate::handling::cacheable::cacheable!(BattlePartyImpl);
crate::handling::cacheable::cacheable!(BattlePartyImpl);
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for BattlePartyImpl {
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for BattlePartyImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn battle_party_get_party(r: ExternRef<BattlePartyImpl>) -> ExternRef<PartyImpl>;
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn battle_party_get_party(r: ExternRef<BattlePartyImpl>) -> ExternRef<PartyImpl>;
}
pub use implementation::*;

69
pkmn_lib_interface/src/app_interface/dynamic_data/dynamic_library.rs
View File

@ -1,57 +1,66 @@
use crate::app_interface::StaticData;
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
use crate::{cached_value, ExternRef, ExternalReferenceType};
use alloc::rc::Rc;
struct DynamicLibraryInner {
ptr: ExternRef<DynamicLibrary>,
pub trait DynamicLibraryTrait {
fn data_library(&self) -> StaticData;
}
pub type DynamicLibrary = Rc<dyn DynamicLibraryTrait>;
#[cfg(not(feature = "mock_data"))]
mod implementation {
use super::*;
use crate::app_interface::dynamic_data::dynamic_library::DynamicLibraryTrait;
use crate::app_interface::StaticDataImpl;
use crate::cached_value;
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::Cacheable;
use alloc::rc::Rc;
struct DynamicLibraryInner {
ptr: ExternRef<DynamicLibraryImpl>,
static_data: CachedValue<StaticData>,
}
}
#[derive(Clone)]
pub struct DynamicLibrary {
#[derive(Clone)]
pub struct DynamicLibraryImpl {
inner: Rc<DynamicLibraryInner>,
}
}
crate::handling::cacheable::cacheable!(DynamicLibrary);
crate::handling::cacheable::cacheable!(DynamicLibraryImpl);
impl DynamicLibrary {
#[cfg(not(feature = "mock_data"))]
impl DynamicLibraryImpl {
pub(crate) fn new(ptr: ExternRef<Self>) -> Self {
Self::from_ref(ptr, &|ptr| Self {
inner: Rc::new(DynamicLibraryInner {
ptr,
static_data: cached_value!({
dynamic_library_get_static_data(ptr).get_value().unwrap()
Rc::new(dynamic_library_get_static_data(ptr).get_value().unwrap())
}),
}),
})
}
#[cfg(feature = "mock_data")]
pub fn new(data: StaticData) -> Self {
Self {
inner: Rc::new(DynamicLibraryInner {
ptr: ExternRef::mock(),
static_data: data.into(),
}),
}
}
pub fn data_library(&self) -> StaticData {
impl DynamicLibraryTrait for DynamicLibraryImpl {
fn data_library(&self) -> StaticData {
self.inner.static_data.value()
}
}
}
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for DynamicLibrary {
impl ExternalReferenceType for DynamicLibraryImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
DynamicLibrary::new(reference)
DynamicLibraryImpl::new(reference)
}
}
extern "wasm" {
fn dynamic_library_get_static_data(
ptr: ExternRef<DynamicLibraryImpl>,
) -> ExternRef<StaticDataImpl>;
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn dynamic_library_get_static_data(ptr: ExternRef<DynamicLibrary>) -> ExternRef<StaticData>;
}
pub use implementation::*;

19
pkmn_lib_interface/src/app_interface/dynamic_data/executing_move.rs
View File

@ -1,9 +1,5 @@
#[cfg(not(feature = "mock_data"))]
use crate::app_interface::PokemonImpl;
use crate::app_interface::{LearnedMove, MoveData, Pokemon};
use crate::handling::cached_value::CachedValue;
use crate::handling::temporary::Temporary;
use crate::{cached_value, ExternRef, ExternalReferenceType, Script};
use crate::handling::Script;
use alloc::rc::Rc;
#[cfg_attr(feature = "mock_data", mockall::automock)]
@ -47,6 +43,11 @@ pub use implementation::*;
#[cfg(not(feature = "mock_data"))]
mod implementation {
use super::*;
use crate::app_interface::{LearnedMoveImpl, PokemonImpl};
use crate::cached_value;
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::temporary::Temporary;
#[derive(Clone)]
pub struct ExecutingMoveImpl {
@ -57,7 +58,7 @@ mod implementation {
reference: ExternRef<ExecutingMoveImpl>,
number_of_hits: CachedValue<u8>,
user: CachedValue<Pokemon>,
chosen_move: CachedValue<LearnedMove>,
chosen_move: CachedValue<Rc<LearnedMoveImpl>>,
use_move: CachedValue<MoveData>,
}
@ -76,9 +77,11 @@ mod implementation {
Rc::new(executing_move_get_user(reference).get_value().unwrap())
}),
chosen_move: cached_value!({
Rc::new(
executing_move_get_chosen_move(reference)
.get_value()
.unwrap()
.unwrap(),
)
}),
use_move: cached_value!({
executing_move_get_use_move(reference).get_value().unwrap()
@ -196,7 +199,7 @@ mod implementation {
fn executing_move_get_user(r: ExternRef<ExecutingMoveImpl>) -> ExternRef<PokemonImpl>;
fn executing_move_get_chosen_move(
r: ExternRef<ExecutingMoveImpl>,
) -> ExternRef<LearnedMove>;
) -> ExternRef<LearnedMoveImpl>;
fn executing_move_get_use_move(r: ExternRef<ExecutingMoveImpl>) -> ExternRef<MoveData>;
#[allow(improper_ctypes)]
fn executing_move_get_script(r: ExternRef<ExecutingMoveImpl>) -> *const dyn Script;

87
pkmn_lib_interface/src/app_interface/dynamic_data/learned_move.rs
View File

@ -1,18 +1,6 @@
use crate::app_interface::MoveData;
use crate::handling::cacheable::Cacheable;
use crate::handling::cached_value::CachedValue;
use crate::{
cached_value, cached_value_getters, wasm_value_getters, ExternRef, ExternalReferenceType,
};
use alloc::rc::Rc;
struct LearnedMoveInner {
reference: ExternRef<LearnedMove>,
move_data: CachedValue<MoveData>,
learn_method: CachedValue<MoveLearnMethod>,
}
#[derive(Copy, Clone, Debug, Default)]
#[repr(u8)]
pub enum MoveLearnMethod {
@ -23,22 +11,44 @@ pub enum MoveLearnMethod {
Level = 1,
}
#[derive(Clone)]
pub struct LearnedMove {
inner: Rc<LearnedMoveInner>,
pub trait LearnedMoveTrait {
fn move_data(&self) -> MoveData;
fn learn_method(&self) -> MoveLearnMethod;
fn restore_all_uses(&self);
fn restore_uses(&self, uses: u8);
}
crate::handling::cacheable::cacheable!(LearnedMove);
pub type LearnedMove = Rc<dyn LearnedMoveTrait>;
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for LearnedMove {
mod implementation {
use super::*;
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::Cacheable;
use crate::{cached_value, cached_value_getters, wasm_value_getters};
use alloc::rc::Rc;
#[derive(Clone)]
pub struct LearnedMoveImpl {
inner: Rc<LearnedMoveInner>,
}
struct LearnedMoveInner {
reference: ExternRef<LearnedMoveImpl>,
move_data: CachedValue<MoveData>,
learn_method: CachedValue<MoveLearnMethod>,
}
crate::handling::cacheable::cacheable!(LearnedMoveImpl);
impl ExternalReferenceType for LearnedMoveImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
}
impl LearnedMove {
#[cfg(not(feature = "mock_data"))]
impl LearnedMoveImpl {
pub fn new(reference: ExternRef<Self>) -> Self {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(LearnedMoveInner {
@ -50,37 +60,40 @@ impl LearnedMove {
}),
})
}
cached_value_getters! {
pub fn move_data(&self) -> MoveData;
pub fn learn_method(&self) -> MoveLearnMethod;
}
#[cfg(not(feature = "mock_data"))]
pub fn restore_all_uses(&self) {
impl LearnedMoveTrait for LearnedMoveImpl {
cached_value_getters! {
fn move_data(&self) -> MoveData;
fn learn_method(&self) -> MoveLearnMethod;
}
fn restore_all_uses(&self) {
unsafe {
learned_move_restore_all_uses(self.inner.reference);
}
}
#[cfg(not(feature = "mock_data"))]
pub fn restore_uses(&self, uses: u8) {
fn restore_uses(&self, uses: u8) {
unsafe {
learned_move_restore_uses(self.inner.reference, uses);
}
}
}
}
wasm_value_getters! {
LearnedMove,
wasm_value_getters! {
LearnedMoveImpl,
pub fn max_pp(&self) -> u8;
pub fn remaining_pp(&self) -> u8;
}
extern "wasm" {
fn learned_move_get_move_data(r: ExternRef<LearnedMoveImpl>) -> ExternRef<MoveData>;
fn learned_move_get_learn_method(r: ExternRef<LearnedMoveImpl>) -> MoveLearnMethod;
fn learned_move_restore_uses(r: ExternRef<LearnedMoveImpl>, uses: u8);
fn learned_move_restore_all_uses(r: ExternRef<LearnedMoveImpl>);
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn learned_move_get_move_data(r: ExternRef<LearnedMove>) -> ExternRef<MoveData>;
fn learned_move_get_learn_method(r: ExternRef<LearnedMove>) -> MoveLearnMethod;
fn learned_move_restore_uses(r: ExternRef<LearnedMove>, uses: u8);
fn learned_move_restore_all_uses(r: ExternRef<LearnedMove>);
}
pub use implementation::*;

2
pkmn_lib_interface/src/app_interface/dynamic_data/mod.rs
View File

@ -17,7 +17,7 @@ pub use battle_party::*;
pub use battle_random::*;
pub use battle_side::*;
pub use choice_queue::*;
pub use dynamic_library::DynamicLibrary;
pub use dynamic_library::*;
pub use executing_move::*;
pub use learned_move::*;
pub use party::*;

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

@ -1,7 +1,4 @@
use crate::app_interface::Pokemon;
#[cfg(not(feature = "mock_data"))]
use crate::app_interface::PokemonImpl;
use crate::{ExternRef, ExternalReferenceType};
use alloc::rc::Rc;
pub trait PartyTrait {
@ -11,20 +8,24 @@ pub trait PartyTrait {
pub type Party = Rc<dyn PartyTrait>;
#[derive(Clone)]
pub struct PartyImpl {
reference: ExternRef<Self>,
}
#[cfg(not(feature = "mock_data"))]
impl PartyImpl {
mod implementation {
use super::*;
use crate::app_interface::PokemonImpl;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
#[derive(Clone)]
pub struct PartyImpl {
reference: ExternRef<Self>,
}
impl PartyImpl {
pub fn new(reference: ExternRef<PartyImpl>) -> Self {
Self { reference }
}
}
}
#[cfg(not(feature = "mock_data"))]
impl PartyTrait for PartyImpl {
impl PartyTrait for PartyImpl {
fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
unsafe {
let v = party_get_pokemon(self.reference, index).get_value();
@ -39,17 +40,19 @@ impl PartyTrait for PartyImpl {
fn length(&self) -> usize {
unsafe { party_get_length(self.reference) }
}
}
}
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for PartyImpl {
impl ExternalReferenceType for PartyImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
Self::new(reference)
}
}
extern "wasm" {
fn party_get_pokemon(r: ExternRef<PartyImpl>, index: usize) -> ExternRef<PokemonImpl>;
fn party_get_length(r: ExternRef<PartyImpl>) -> usize;
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn party_get_pokemon(r: ExternRef<PartyImpl>, index: usize) -> ExternRef<PokemonImpl>;
fn party_get_length(r: ExternRef<PartyImpl>) -> usize;
}
pub use implementation::*;

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

@ -86,7 +86,10 @@ mod implementation {
use super::*;
use cstr_core::CString;
use crate::app_interface::{AbilityImpl, BattleImpl, ItemImpl, StatisticSetImpl};
use crate::app_interface::dynamic_data::dynamic_library::DynamicLibraryImpl;
use crate::app_interface::{
AbilityImpl, BattleImpl, ItemImpl, LearnedMoveImpl, StatisticSetImpl,
};
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
use crate::implementation::ScriptPtr;
@ -94,7 +97,7 @@ mod implementation {
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,
ExternRef, ExternalReferenceType, Script,
ExternRef, ExternalReferenceType,
};
struct PokemonInner {
@ -208,7 +211,14 @@ mod implementation {
false
}
fn get_learned_move(&self, index: usize) -> Option<LearnedMove> {
unsafe { pokemon_get_learned_move(self.inner.reference, index).get_value() }
unsafe {
let v = pokemon_get_learned_move(self.inner.reference, index).get_value();
if let Some(v) = v {
Some(Rc::new(v))
} else {
None
}
}
}
fn change_stat_boost(
&self,
@ -350,7 +360,9 @@ mod implementation {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(PokemonInner {
reference,
library: cached_value!({ pokemon_get_library(reference).get_value().unwrap() }),
library: cached_value!({
Rc::new(pokemon_get_library(reference).get_value().unwrap())
}),
flat_stats: cached_value!({
Rc::new(pokemon_get_flat_stats(reference).get_value().unwrap())
}),
@ -428,7 +440,7 @@ mod implementation {
}
extern "wasm" {
fn pokemon_get_library(r: ExternRef<PokemonImpl>) -> ExternRef<DynamicLibrary>;
fn pokemon_get_library(r: ExternRef<PokemonImpl>) -> ExternRef<DynamicLibraryImpl>;
fn pokemon_get_flat_stats(r: ExternRef<PokemonImpl>) -> ExternRef<StatisticSetImpl<u32>>;
fn pokemon_get_stat_boosts(r: ExternRef<PokemonImpl>)
-> ExternRef<ClampedStatisticSet<i8>>;
@ -452,7 +464,7 @@ mod implementation {
fn pokemon_get_learned_move(
r: ExternRef<PokemonImpl>,
index: usize,
) -> ExternRef<LearnedMove>;
) -> ExternRef<LearnedMoveImpl>;
fn pokemon_change_stat_boost(
r: ExternRef<PokemonImpl>,
tat: Statistic,

159
pkmn_lib_interface/src/app_interface/dynamic_data/turn_choices.rs
View File

@ -1,70 +1,8 @@
#[cfg(not(feature = "mock_data"))]
use crate::app_interface::PokemonImpl;
use crate::app_interface::{LearnedMove, Pokemon};
use crate::handling::cached_value::CachedValue;
use crate::handling::temporary::Temporary;
use crate::ExternRef;
use crate::{cached_value, ExternalReferenceType, Script};
use crate::handling::Script;
use alloc::boxed::Box;
use alloc::rc::Rc;
pub trait BaseTurnChoiceDataTrait {
fn reference(&self) -> u32;
fn user(&self) -> Pokemon;
fn speed(&self) -> u32;
fn has_failed(&self) -> bool;
fn fail(&self);
}
#[cfg(not(feature = "mock_data"))]
struct BaseTurnChoiceDataImpl {
reference: ExternRef<TurnChoice>,
user: CachedValue<Rc<PokemonImpl>>,
}
#[cfg(not(feature = "mock_data"))]
impl BaseTurnChoiceDataTrait for BaseTurnChoiceDataImpl {
fn reference(&self) -> u32 {
self.reference.get_internal_index()
}
fn user(&self) -> Pokemon {
self.user.value()
}
fn speed(&self) -> u32 {
unsafe { turn_choice_get_speed(self.reference) }
}
fn has_failed(&self) -> bool {
unsafe { turn_choice_has_failed(self.reference) }
}
fn fail(&self) {
unsafe { turn_choice_fail(self.reference) }
}
}
pub type BaseTurnChoiceData = Rc<dyn BaseTurnChoiceDataTrait>;
struct MoveTurnChoiceDataInner {
base: BaseTurnChoiceData,
used_move: CachedValue<LearnedMove>,
target_side: CachedValue<u8>,
target_index: CachedValue<u8>,
}
pub trait MoveTurnChoiceDataTrait {
fn base(&self) -> BaseTurnChoiceData;
fn used_move(&self) -> LearnedMove;
fn target_side(&self) -> u8;
fn target_index(&self) -> u8;
fn priority(&self) -> i8;
fn move_script(&self) -> Option<&Box<dyn Script>>;
}
#[derive(Clone)]
pub struct MoveTurnChoiceDataImpl {
inner: Temporary<MoveTurnChoiceDataInner>,
}
pub enum TurnChoice {
Move(Box<dyn MoveTurnChoiceDataTrait>),
Item(),
@ -98,8 +36,72 @@ impl TurnChoice {
}
}
pub trait BaseTurnChoiceDataTrait {
fn reference(&self) -> u32;
fn user(&self) -> Pokemon;
fn speed(&self) -> u32;
fn has_failed(&self) -> bool;
fn fail(&self);
}
pub type BaseTurnChoiceData = Rc<dyn BaseTurnChoiceDataTrait>;
pub trait MoveTurnChoiceDataTrait {
fn base(&self) -> BaseTurnChoiceData;
fn used_move(&self) -> LearnedMove;
fn target_side(&self) -> u8;
fn target_index(&self) -> u8;
fn priority(&self) -> i8;
fn move_script(&self) -> Option<&Box<dyn Script>>;
}
#[cfg(not(feature = "mock_data"))]
impl MoveTurnChoiceDataTrait for MoveTurnChoiceDataImpl {
mod implementation {
use super::*;
use crate::app_interface::{LearnedMoveImpl, PokemonImpl};
use crate::cached_value;
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::temporary::Temporary;
struct BaseTurnChoiceDataImpl {
reference: ExternRef<TurnChoice>,
user: CachedValue<Rc<PokemonImpl>>,
}
impl BaseTurnChoiceDataTrait for BaseTurnChoiceDataImpl {
fn reference(&self) -> u32 {
self.reference.get_internal_index()
}
fn user(&self) -> Pokemon {
self.user.value()
}
fn speed(&self) -> u32 {
unsafe { turn_choice_get_speed(self.reference) }
}
fn has_failed(&self) -> bool {
unsafe { turn_choice_has_failed(self.reference) }
}
fn fail(&self) {
unsafe { turn_choice_fail(self.reference) }
}
}
struct MoveTurnChoiceDataInner {
base: BaseTurnChoiceData,
used_move: CachedValue<LearnedMove>,
target_side: CachedValue<u8>,
target_index: CachedValue<u8>,
}
#[derive(Clone)]
pub struct MoveTurnChoiceDataImpl {
inner: Temporary<MoveTurnChoiceDataInner>,
}
#[cfg(not(feature = "mock_data"))]
impl MoveTurnChoiceDataTrait for MoveTurnChoiceDataImpl {
fn base(&self) -> BaseTurnChoiceData {
self.inner.value().base.clone()
}
@ -119,10 +121,10 @@ impl MoveTurnChoiceDataTrait for MoveTurnChoiceDataImpl {
fn move_script(&self) -> Option<&Box<dyn Script>> {
unsafe { turn_choice_move_script(self.base().reference().into()).as_ref() }
}
}
}
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for TurnChoice {
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for TurnChoice {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
let kind = unsafe { turn_choice_get_kind(reference) };
match kind {
@ -135,10 +137,10 @@ impl ExternalReferenceType for TurnChoice {
_ => panic!("Unknown turn choice type"),
}
}
}
}
#[cfg(not(feature = "mock_data"))]
impl MoveTurnChoiceDataInner {
#[cfg(not(feature = "mock_data"))]
impl MoveTurnChoiceDataInner {
fn from_reference(reference: ExternRef<MoveTurnChoiceDataImpl>) -> Self {
Self {
base: Rc::new(BaseTurnChoiceDataImpl {
@ -148,28 +150,35 @@ impl MoveTurnChoiceDataInner {
}),
}),
used_move: cached_value!({
Rc::new(
turn_choice_move_used_move(reference.cast())
.get_value()
.unwrap()
.unwrap(),
)
}),
target_side: cached_value!({ turn_choice_move_target_side(reference.cast()) }),
target_index: cached_value!({ turn_choice_move_target_index(reference.cast()) }),
}
}
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
extern "wasm" {
fn turn_choice_get_kind(r: ExternRef<TurnChoice>) -> u8;
fn turn_choice_get_user(r: ExternRef<TurnChoice>) -> ExternRef<PokemonImpl>;
fn turn_choice_get_speed(r: ExternRef<TurnChoice>) -> u32;
fn turn_choice_has_failed(r: ExternRef<TurnChoice>) -> bool;
fn turn_choice_fail(r: ExternRef<TurnChoice>);
fn turn_choice_move_used_move(r: ExternRef<MoveTurnChoiceDataImpl>) -> ExternRef<LearnedMove>;
fn turn_choice_move_used_move(
r: ExternRef<MoveTurnChoiceDataImpl>,
) -> ExternRef<LearnedMoveImpl>;
fn turn_choice_move_target_side(r: ExternRef<MoveTurnChoiceDataImpl>) -> u8;
fn turn_choice_move_target_index(r: ExternRef<MoveTurnChoiceDataImpl>) -> u8;
fn turn_choice_move_priority(r: ExternRef<MoveTurnChoiceDataImpl>) -> i8;
#[allow(improper_ctypes)]
fn turn_choice_move_script(r: ExternRef<MoveTurnChoiceDataImpl>) -> *const Box<dyn Script>;
}
}
#[cfg(not(feature = "mock_data"))]
pub use implementation::*;

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

@ -1,4 +1,3 @@
use crate::{ExternalReferenceType, VecExternRef};
use alloc::rc::Rc;
pub trait ImmutableListTrait<T> {

2
pkmn_lib_interface/src/app_interface/static_data/data_libraries/item_library.rs
View File

@ -1,4 +1,4 @@
use crate::app_interface::{DataLibrary, Item, ItemImpl};
use crate::app_interface::{DataLibrary, ItemImpl};
use crate::{ExternRef, ExternalReferenceType, StringKey};
use alloc::rc::Rc;
use spin::rwlock::RwLock;

199
pkmn_lib_interface/src/app_interface/static_data/data_libraries/mod.rs
View File

@ -1,38 +1,57 @@
use crate::{cached_value, cached_value_getters, ExternRef, ExternalReferenceType, StringKey};
use crate::app_interface::item_library::ItemLibrary;
use crate::app_interface::move_library::MoveLibrary;
use crate::app_interface::species_library::SpeciesLibrary;
use crate::app_interface::type_library::TypeLibrary;
use crate::app_interface::LevelInt;
use alloc::rc::Rc;
use move_library::MoveLibrary;
use spin::rwlock::RwLock;
pub mod item_library;
pub mod move_library;
pub mod species_library;
pub mod type_library;
use crate::app_interface::species_library::SpeciesLibrary;
use crate::app_interface::type_library::TypeLibrary;
use crate::app_interface::{get_hash, LevelInt};
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
pub use item_library::*;
pub use move_library::*;
pub trait StaticDataTrait {
fn move_library(&self) -> MoveLibrary;
fn item_library(&self) -> ItemLibrary;
fn species_library(&self) -> SpeciesLibrary;
fn type_library(&self) -> TypeLibrary;
}
struct StaticDataInner {
reference: ExternRef<StaticData>,
pub type StaticData = Rc<dyn StaticDataTrait>;
pub trait LibrarySettingsTrait {
fn maximum_level(&self) -> LevelInt;
}
pub type LibrarySettings = Rc<dyn LibrarySettingsTrait>;
#[cfg(not(feature = "mock_data"))]
mod implementation {
use super::*;
use crate::app_interface::{get_hash, StringKey};
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::Cacheable;
use crate::{cached_value, cached_value_getters};
use spin::RwLock;
struct StaticDataInner {
reference: ExternRef<StaticDataImpl>,
move_library: CachedValue<MoveLibrary>,
item_library: CachedValue<ItemLibrary>,
species_library: CachedValue<SpeciesLibrary>,
type_library: CachedValue<TypeLibrary>,
settings: CachedValue<LibrarySettings>,
}
}
#[derive(Clone)]
pub struct StaticData {
#[derive(Clone)]
pub struct StaticDataImpl {
inner: Rc<StaticDataInner>,
}
}
impl StaticData {
impl StaticDataImpl {
#[cfg(not(feature = "mock_data"))]
pub(crate) fn new(reference: ExternRef<StaticData>) -> Self {
pub(crate) fn new(reference: ExternRef<StaticDataImpl>) -> Self {
Self::from_ref(reference, &|reference| Self {
inner: Rc::new(StaticDataInner {
reference,
@ -51,108 +70,88 @@ impl StaticData {
static_data_get_type_library(reference).get_value().unwrap()
}),
settings: cached_value!({
Rc::new(
static_data_get_library_settings(reference)
.get_value()
.unwrap()
.unwrap(),
)
}),
}),
})
}
#[cfg(feature = "mock_data")]
pub fn mock(
moves: MoveLibrary,
items: ItemLibrary,
species: SpeciesLibrary,
types: TypeLibrary,
settings: LibrarySettings,
) -> Self {
Self {
inner: Rc::new(StaticDataInner {
reference: ExternRef::mock(),
move_library: moves.into(),
item_library: items.into(),
species_library: species.into(),
type_library: types.into(),
settings: settings.into(),
}),
}
}
impl StaticDataTrait for StaticDataImpl {
cached_value_getters! {
pub fn move_library(&self) -> MoveLibrary;
pub fn item_library(&self) -> ItemLibrary;
pub fn species_library(&self) -> SpeciesLibrary;
pub fn type_library(&self) -> TypeLibrary;
fn move_library(&self) -> MoveLibrary;
fn item_library(&self) -> ItemLibrary;
fn species_library(&self) -> SpeciesLibrary;
fn type_library(&self) -> TypeLibrary;
}
}
crate::handling::cacheable::cacheable!(StaticData);
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for StaticData {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
StaticData::new(reference)
}
}
struct LibrarySettingsInner {
maximum_level: CachedValue<LevelInt>,
}
crate::handling::cacheable::cacheable!(StaticDataImpl);
#[derive(Clone)]
pub struct LibrarySettings {
inner: Rc<LibrarySettingsInner>,
}
impl LibrarySettings {
#[cfg(not(feature = "mock_data"))]
pub(crate) fn new(ptr: ExternRef<LibrarySettings>) -> Self {
impl ExternalReferenceType for StaticDataImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
StaticDataImpl::new(reference)
}
}
#[derive(Clone)]
pub struct LibrarySettingsImpl {
inner: Rc<LibrarySettingsInner>,
}
struct LibrarySettingsInner {
maximum_level: CachedValue<LevelInt>,
}
impl LibrarySettingsImpl {
#[cfg(not(feature = "mock_data"))]
pub(crate) fn new(ptr: ExternRef<LibrarySettingsImpl>) -> Self {
Self {
inner: Rc::new(LibrarySettingsInner {
maximum_level: cached_value!({ library_settings_get_maximum_level(ptr) }),
}),
}
}
#[cfg(feature = "mock_data")]
pub fn mock(maximum_level: LevelInt) -> Self {
Self {
inner: Rc::new(LibrarySettingsInner {
maximum_level: maximum_level.into(),
}),
}
}
impl LibrarySettingsTrait for LibrarySettingsImpl {
cached_value_getters! {
pub fn maximum_level(&self) -> LevelInt;
fn maximum_level(&self) -> LevelInt;
}
}
}
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for LibrarySettings {
#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for LibrarySettingsImpl {
fn from_extern_value(reference: ExternRef<Self>) -> Self {
LibrarySettings::new(reference)
LibrarySettingsImpl::new(reference)
}
}
}
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn static_data_get_move_library(ptr: ExternRef<StaticData>) -> ExternRef<MoveLibrary>;
fn static_data_get_item_library(ptr: ExternRef<StaticData>) -> ExternRef<ItemLibrary>;
fn static_data_get_species_library(ptr: ExternRef<StaticData>) -> ExternRef<SpeciesLibrary>;
fn static_data_get_type_library(ptr: ExternRef<StaticData>) -> ExternRef<TypeLibrary>;
fn static_data_get_library_settings(ptr: ExternRef<StaticData>) -> ExternRef<LibrarySettings>;
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn static_data_get_move_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<MoveLibrary>;
fn static_data_get_item_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<ItemLibrary>;
fn static_data_get_species_library(
ptr: ExternRef<StaticDataImpl>,
) -> ExternRef<SpeciesLibrary>;
fn static_data_get_type_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<TypeLibrary>;
fn static_data_get_library_settings(
ptr: ExternRef<StaticDataImpl>,
) -> ExternRef<LibrarySettingsImpl>;
fn library_settings_get_maximum_level(ptr: ExternRef<LibrarySettings>) -> LevelInt;
}
fn library_settings_get_maximum_level(ptr: ExternRef<LibrarySettingsImpl>) -> LevelInt;
}
#[cfg(not(feature = "mock_data"))]
pub trait DataLibrary<T>: Cacheable
where
pub trait DataLibrary<T>: Cacheable
where
T: ExternalReferenceType,
T: Clone,
{
{
fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
fn get_self_ref(&self) -> ExternRef<Self>
where
@ -200,13 +199,27 @@ where
}
v
}
}
}
#[cfg(not(feature = "mock_data"))]
pub use implementation::*;
#[cfg(feature = "mock_data")]
pub trait DataLibrary<T>: Cacheable
where
mod mocked {
use super::*;
use crate::app_interface::StringKey;
use crate::handling::cached_value::CachedValue;
use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
use crate::handling::Cacheable;
use crate::{cached_value, cached_value_getters};
use spin::RwLock;
#[cfg(feature = "mock_data")]
pub trait DataLibrary<T>: Cacheable
where
T: Clone,
{
{
fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
fn get_self_ref(&self) -> ExternRef<Self>
where
@ -229,4 +242,8 @@ where
fn insert(&self, hash: u32, item: T) {
self.get_cache().write().insert(hash, item);
}
}
}
#[cfg(feature = "mock_data")]
pub use mocked::*;

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

@ -5,7 +5,6 @@ use crate::app_interface::{
};
use crate::handling::ScriptCapabilities;
use crate::{ExternRef, ExternalReferenceType, StringKey};
use alloc::boxed::Box;
use alloc::rc::Rc;
use core::any::Any;
use core::fmt::Debug;
@ -26,7 +25,7 @@ pub trait Script {
/// This function is ran when this script starts being in effect.
fn on_initialize(
&self,
_library: &DynamicLibrary,
_library: DynamicLibrary,
_parameters: Option<ImmutableList<Rc<EffectParameter>>>,
) {
}

8
pkmn_lib_interface/src/handling/temporary.rs
View File

@ -41,14 +41,6 @@ impl<T> Temporary<T> {
}
self.value.clone()
}
#[inline]
pub fn value_ref(&self) -> &T {
if self.is_deleted.load(Ordering::SeqCst) {
panic!("Accessed value after it had been deleted");
}
self.value.as_ref()
}
}
#[cfg(not(feature = "mock_data"))]

7
pkmn_lib_interface/src/lib.rs
View File

@ -24,7 +24,6 @@ static ALLOC: dlmalloc::GlobalDlmalloc = dlmalloc::GlobalDlmalloc {};
pub(crate) use crate::app_interface::StringKey;
pub(crate) use crate::handling::extern_ref::*;
pub(crate) use crate::handling::Script;
#[macro_use]
#[allow(dead_code)]
@ -36,7 +35,7 @@ pub mod utils;
mod implementation {
use crate::app_interface::list::{EffectParameterImmutableList, ImmutableListWasm};
use crate::app_interface::{
BattleImpl, DamageSource, DynamicLibrary, EffectParameter, ExecutingMoveImpl, ItemImpl,
BattleImpl, DamageSource, DynamicLibraryImpl, EffectParameter, ExecutingMoveImpl, ItemImpl,
PokemonImpl, Statistic, StringKey, TurnChoice, TypeIdentifier,
};
use crate::handling::extern_ref::ExternRef;
@ -187,11 +186,11 @@ mod implementation {
fn script_on_initialize(
script: ScriptPtr,
library: ExternRef<DynamicLibrary>,
library: ExternRef<DynamicLibraryImpl>,
parameters: VecExternRef<EffectParameter>,
) {
let parameters = Rc::new(EffectParameterImmutableList::from_ref(parameters));
script.val().unwrap().on_initialize(&library.not_null(), Some(parameters));
script.val().unwrap().on_initialize(library.not_null_rc(), Some(parameters));
}
fn script_on_before_turn(

107
pkmn_lib_interface/src/utils.rs
View File

@ -1,40 +1,9 @@
use alloc::alloc::alloc;
use alloc::string::String;
use core::alloc::Layout;
#[cfg(not(feature = "mock_data"))]
use core::panic::PanicInfo;
#[cfg(feature = "mock_data")]
use cstr_core::CStr;
use cstr_core::{c_char, CString};
#[cfg(not(feature = "mock_data"))]
#[cfg(not(feature = "mock_data"))]
extern "wasm" {
fn _print(s: *const u8);
fn _error(message: *const u8, file: *const u8, line: u32, position: u32);
}
#[cfg(not(feature = "mock_data"))]
pub fn print_raw(s: &[u8]) {
unsafe {
let cstring = CString::from_vec_unchecked(s.to_vec());
_print(cstring.as_ptr());
}
}
#[cfg(feature = "mock_data")]
pub fn print_raw(s: &[u8]) {
unsafe {
println!("{}", String::from_utf8_lossy(s));
}
}
#[macro_export]
macro_rules! println { ($($args:tt)*) => { pkmn_lib_interface::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
macro_rules! println { ($($args:tt)*) => { crate::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
#[macro_export]
#[cfg(debug_assertions)]
macro_rules! dbg { ($($args:tt)*) => { pkmn_lib_interface::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
macro_rules! dbg { ($($args:tt)*) => { crate::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
#[macro_export]
#[cfg(not(debug_assertions))]
@ -42,11 +11,31 @@ macro_rules! dbg {
($($args:tt)*) => {{}};
}
#[panic_handler]
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
#[cfg(not(test))]
pub fn begin_panic_handler(panic_info: &PanicInfo<'_>) -> ! {
mod implementation {
use alloc::alloc::alloc;
use core::alloc::Layout;
use core::panic::PanicInfo;
use cstr_core::{c_char, CString};
extern "wasm" {
fn _print(s: *const u8);
fn _error(message: *const u8, file: *const u8, line: u32, position: u32);
}
#[cfg(not(feature = "mock_data"))]
pub fn print_raw(s: &[u8]) {
unsafe {
let cstring = CString::from_vec_unchecked(s.to_vec());
_print(cstring.as_ptr());
}
}
#[panic_handler]
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
#[cfg(not(test))]
pub fn begin_panic_handler(panic_info: &PanicInfo<'_>) -> ! {
let msg = CString::new(panic_info.message().unwrap().as_str().unwrap()).unwrap();
let mut line = 0;
let mut position = 0;
@ -61,24 +50,42 @@ pub fn begin_panic_handler(panic_info: &PanicInfo<'_>) -> ! {
_error(msg.as_ptr(), file.as_ptr(), line, position);
}
loop {}
}
}
#[alloc_error_handler]
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
#[cfg(not(test))]
fn allocation_error_handler(layout: core::alloc::Layout) -> ! {
#[alloc_error_handler]
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
#[cfg(not(test))]
fn allocation_error_handler(layout: core::alloc::Layout) -> ! {
panic!("memory allocation of {} bytes failed", layout.size())
}
}
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
unsafe extern "wasm" fn allocate_mem(len: u32, align: u32) -> *mut u8 {
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
unsafe extern "wasm" fn allocate_mem(len: u32, align: u32) -> *mut u8 {
alloc(Layout::from_size_align(len as usize, align as usize).unwrap())
}
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
unsafe extern "wasm" fn dealloc_cstring(ptr: *mut c_char) {
CString::from_raw(ptr);
}
}
#[no_mangle]
#[cfg(not(feature = "mock_data"))]
unsafe extern "wasm" fn dealloc_cstring(ptr: *mut c_char) {
CString::from_raw(ptr);
pub use implementation::*;
#[cfg(feature = "mock_data")]
mod mocked {
use super::*;
pub fn print_raw(s: &[u8]) {
unsafe {
println!("{}", String::from_utf8_lossy(s));
}
}
}
#[cfg(feature = "mock_data")]
pub use mocked::*;