Adds a large amount of the WASM interface

src/script_implementations/wasm/export_registry/dynamic_data/battle.rs

@@ -1,5 +1,5 @@
 use crate::dynamic_data::{
-    Battle, BattleParty, BattleRandom, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon, PokemonParty,
+    Battle, BattleParty, BattleRandom, BattleResult, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon, PokemonParty,
 };
 use crate::script_implementations::wasm::export_registry::register;
 use crate::script_implementations::wasm::extern_ref::{ExternRef, VecExternRef};
@@ -82,6 +82,66 @@ register! {
         ExternRef::null()
     }
 
+    fn battle_get_pokemon(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        battle: ExternRef<Battle>,
+        side: u8, index: u8
+    ) -> ExternRef<Pokemon> {
+        let battle = battle.value_func(&env).unwrap();
+        let pokemon = battle.get_pokemon(side, index);
+        if let Some(pokemon) = pokemon {
+            ExternRef::func_new(&env, &pokemon)
+        } else {
+            ExternRef::null()
+        }
+    }
+
+    fn battle_get_can_flee(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        battle: ExternRef<Battle>,
+    ) -> u8 {
+        if battle.value_func(&env).unwrap().can_flee() { 1 } else { 0 }
+    }
+
+    fn battle_get_number_of_sides(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        battle: ExternRef<Battle>,
+    ) -> u8 {
+        battle.value_func(&env).unwrap().number_of_sides()
+    }
+
+    fn battle_get_has_ended(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        battle: ExternRef<Battle>,
+    ) -> u8 {
+        if battle.value_func(&env).unwrap().has_ended() { 1 } else { 0 }
+    }
+
+    fn battle_get_has_ended_conclusively(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        battle: ExternRef<Battle>,
+    ) -> u8 {
+        if battle.value_func(&env).unwrap().result().is_conclusive() { 1 } else { 0 }
+    }
+
+    fn battle_get_winning_side(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        battle: ExternRef<Battle>,
+    ) -> u8 {
+        if let BattleResult::Conclusive(result) = battle.value_func(&env).unwrap().result() {
+            result
+        } else {
+            0
+        }
+    }
+
+    fn battle_get_current_turn(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        battle: ExternRef<Battle>,
+    ) -> u32 {
+        battle.value_func(&env).unwrap().current_turn()
+    }
+
     fn battle_party_get_party(
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle_party: ExternRef<BattleParty>,

src/script_implementations/wasm/export_registry/dynamic_data/battle_side.rs

@@ -55,6 +55,20 @@ register! {
         }
     }
 
+    fn battle_side_get_has_fled_battle(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        side: ExternRef<BattleSide>,
+    ) -> u8 {
+        if side.value_func(&env).unwrap().has_fled_battle() { 1 } else { 0 }
+    }
+
+    fn battle_side_get_is_defeated(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        side: ExternRef<BattleSide>,
+    ) -> u8 {
+        if side.value_func(&env).unwrap().is_defeated() { 1 } else { 0 }
+    }
+
     fn battleside_add_volatile_by_name(
         env: FunctionEnvMut<WebAssemblyEnv>,
         side: ExternRef<BattleSide>,

src/script_implementations/wasm/export_registry/dynamic_data/executing_move.rs

@@ -1,6 +1,7 @@
 use crate::dynamic_data::{ExecutingMove, HitData, LearnedMove, Pokemon};
 use crate::script_implementations::wasm::export_registry::register;
 use crate::script_implementations::wasm::extern_ref::ExternRef;
+use crate::script_implementations::wasm::script::WebAssemblyScript;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::MoveData;
 use wasmer::FunctionEnvMut;
@@ -42,4 +43,38 @@ register! {
     ) -> ExternRef<HitData> {
         ExternRef::func_new(&env, executing_move.value_func(&env).unwrap().get_hit_data(target.value_func(&env).unwrap(), hit).unwrap())
     }
+
+    fn executing_move_get_number_of_targets(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        executing_move: ExternRef<ExecutingMove>,
+    ) -> u32 {
+        executing_move.value_func(&env).unwrap().target_count() as u32
+    }
+
+    fn executing_move_is_pokemon_target(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        executing_move: ExternRef<ExecutingMove>,
+        pokemon: ExternRef<Pokemon>
+    ) -> u8 {
+        let pokemon = pokemon.value_func_arc(&env).unwrap();
+        if executing_move.value_func(&env).unwrap().is_pokemon_target(&pokemon) { 1 } else { 0 }
+    }
+
+
+
+    fn executing_move_get_script(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        executing_move: ExternRef<ExecutingMove>,
+    ) -> (u32 , u32) {
+        let executing_move = executing_move.value_func(&env).unwrap();
+        if let Some(script) = executing_move.script().get() {
+            let read_lock = script.read();
+            if let Some(script) = read_lock.as_ref() {
+                let s = script.as_any().downcast_ref::<WebAssemblyScript>().unwrap().get_wasm_pointer();
+                return (s, s + 4)
+            }
+        }
+        (0, 0)
+    }
+
 }

src/script_implementations/wasm/export_registry/dynamic_data/hit_data.rs

@@ -25,4 +25,58 @@ register! {
     ) {
         hit.value_func(&env).unwrap().fail()
     }
+
+    fn hit_data_get_base_power(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        hit: ExternRef<HitData>,
+    ) -> u8 {
+        hit.value_func(&env).unwrap().base_power()
+    }
+
+    fn hit_data_get_effectiveness(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        hit: ExternRef<HitData>,
+    ) -> f32 {
+        hit.value_func(&env).unwrap().effectiveness()
+    }
+
+    fn hit_data_get_move_type(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        hit: ExternRef<HitData>,
+    ) -> u8 {
+        hit.value_func(&env).unwrap().move_type().into()
+    }
+
+    fn hit_data_set_critical(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        hit: ExternRef<HitData>,
+        value: u8
+    ) {
+        hit.value_func(&env).unwrap().set_critical(value == 1)
+    }
+
+    fn hit_data_set_effectiveness(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        hit: ExternRef<HitData>,
+        effectiveness: f32
+    ) {
+        hit.value_func(&env).unwrap().set_effectiveness(effectiveness)
+    }
+
+    fn hit_data_set_damage(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        hit: ExternRef<HitData>,
+        damage: u32
+    ) {
+        hit.value_func(&env).unwrap().set_damage(damage)
+    }
+
+    fn hit_data_set_move_type(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        hit: ExternRef<HitData>,
+        move_type: u8
+    ) {
+        hit.value_func(&env).unwrap().set_move_type(move_type.into())
+    }
+
 }

src/script_implementations/wasm/export_registry/dynamic_data/learned_move.rs

@@ -23,4 +23,20 @@ register! {
     ) -> ExternRef<dyn MoveData> {
         ExternRef::func_new(&env, turn_choice.value_func(&env).unwrap().move_data())
     }
+
+    fn learned_move_restore_all_uses(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        turn_choice: ExternRef<LearnedMove>,
+    ) {
+        turn_choice.value_func(&env).unwrap().restore_all_uses();
+    }
+
+    fn learned_move_restore_uses(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        turn_choice: ExternRef<LearnedMove>,
+        amount: u8,
+    ) {
+        turn_choice.value_func(&env).unwrap().restore_uses(amount);
+    }
+
 }

src/script_implementations/wasm/export_registry/dynamic_data/mod.rs

@@ -55,6 +55,24 @@ register! {
         }
     }
 
+    fn script_get_owner_kind(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        script: u32,
+    ) -> u8 {
+        let script = env.data().data().get_loaded_script(script);
+        if let Some(script) = script {
+            match script.get_owner() {
+                ScriptOwnerData::Pokemon(_) => 0,
+                ScriptOwnerData::BattleSide(_) => 1,
+                ScriptOwnerData::Battle(_) => 2,
+                ScriptOwnerData::None => 3,
+            }
+        } else {
+            0
+        }
+    }
+
+
     manual manual_register
 }
 

src/script_implementations/wasm/export_registry/dynamic_data/pokemon.rs

@@ -1,14 +1,15 @@
 use std::mem::transmute;
 
+use crate::defines::LevelInt;
 use crate::dynamic_data::{Battle, DynamicLibrary, LearnedMove, Pokemon, VolatileScriptsOwner};
 use crate::script_implementations::wasm::export_registry::register;
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script::WebAssemblyScript;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
-use crate::static_data::{ClampedStatisticSet, Species};
+use crate::static_data::{Ability, ClampedStatisticSet, Form, Nature, Species};
 use crate::static_data::{Item, StatisticSet};
 use crate::ScriptCategory;
-use std::ffi::{c_char, CStr};
+use std::ffi::{c_char, CStr, CString};
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -209,6 +210,200 @@ register! {
         pokemon.value_func(&env).unwrap().clear_status()
     }
 
+    fn pokemon_get_active_ability(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> ExternRef<dyn Ability> {
+        ExternRef::func_new(&env, &pokemon.value_func(&env).unwrap().active_ability())
+    }
+
+    fn pokemon_get_real_ability(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> (u8, u8) {
+        let index = &pokemon.value_func(&env).unwrap().real_ability();
+        (if index.hidden { 1 } else { 0 }, index.index)
+    }
+
+    fn pokemon_get_is_ability_overriden(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u8 {
+        if pokemon.value_func(&env).unwrap().is_ability_overriden() { 1 } else { 0 }
+    }
+
+    fn pokemon_get_allowed_experience_gain(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u8 {
+        if pokemon.value_func(&env).unwrap().allowed_experience_gain() { 1 } else { 0 }
+    }
+
+    fn pokemon_get_is_usable(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u8 {
+        if pokemon.value_func(&env).unwrap().is_usable() { 1 } else { 0 }
+    }
+
+
+    fn pokemon_set_held_item(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+        item: ExternRef<dyn Item>
+    ) -> ExternRef<dyn Item> {
+        let item = item.value_func_arc(&env).unwrap();
+        let old_item = pokemon.value_func(&env).unwrap().set_held_item(&item);
+        if let Some(old_item) = old_item {
+            ExternRef::func_new(&env, &old_item)
+        } else {
+            ExternRef::null()
+        }
+    }
+
+    fn pokemon_remove_held_item(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> ExternRef<dyn Item> {
+        let old_item = pokemon.value_func(&env).unwrap().remove_held_item();
+        if let Some(old_item) = old_item {
+            ExternRef::func_new(&env, &old_item)
+        } else {
+            ExternRef::null()
+        }
+    }
+
+    fn pokemon_consume_held_item(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u8 {
+        if pokemon.value_func(&env).unwrap().consume_held_item() { 1 } else { 0 }
+    }
+
+    fn pokemon_get_types_length(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>
+    ) -> u32 {
+        pokemon.value_func(&env).unwrap().types().len() as u32
+    }
+
+    fn pokemon_get_type(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+        index: u32
+    ) -> u8 {
+        (*pokemon.value_func(&env).unwrap().types().get(index as usize).unwrap()).into()
+    }
+
+    fn pokemon_has_type(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+        t: u8
+    ) -> u8 {
+        if pokemon.value_func(&env).unwrap().types().contains(&t.into()) { 1 } else { 0 }
+    }
+
+    fn pokemon_change_species(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+        species: ExternRef<dyn Species>,
+        form: ExternRef<dyn Form>,
+    ) {
+        pokemon.value_func(&env).unwrap().change_species(
+            species.value_func_arc(&env).unwrap(),
+            form.value_func_arc(&env).unwrap(),
+        );
+    }
+
+    fn pokemon_change_form(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+        form: ExternRef<dyn Form>,
+    ) {
+        pokemon.value_func(&env).unwrap().change_form(
+            &form.value_func_arc(&env).unwrap(),
+        );
+    }
+
+    fn pokemon_get_current_health(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u32 {
+        pokemon.value_func(&env).unwrap().current_health()
+    }
+
+    fn pokemon_get_nature(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> ExternRef<dyn Nature> {
+        ExternRef::func_new(&env, pokemon.value_func(&env).unwrap().nature())
+    }
+
+    fn pokemon_get_form(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> ExternRef<dyn Form> {
+        ExternRef::func_new(&env, &pokemon.value_func(&env).unwrap().form())
+    }
+
+    fn pokemon_get_display_species(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> ExternRef<dyn Species> {
+        ExternRef::func_new(&env, &pokemon.value_func(&env).unwrap().display_species())
+    }
+
+    fn pokemon_get_display_form(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> ExternRef<dyn Form> {
+        ExternRef::func_new(&env, &pokemon.value_func(&env).unwrap().display_form())
+    }
+
+    fn pokemon_get_level(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> LevelInt {
+        pokemon.value_func(&env).unwrap().level()
+    }
+
+    fn pokemon_get_experience(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u32 {
+        pokemon.value_func(&env).unwrap().experience()
+    }
+
+    fn pokemon_get_unique_identifier(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u32 {
+        pokemon.value_func(&env).unwrap().unique_identifier()
+    }
+
+    fn pokemon_get_coloring(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u8 {
+        pokemon.value_func(&env).unwrap().coloring()
+    }
+
+    fn pokemon_get_nickname(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u32 {
+        let pokemon = pokemon.value_func(&env).unwrap();
+        let nickname = pokemon.nickname();
+        if let Some(nickname) = nickname {
+            let nickname: CString = CString::new(nickname.as_str()).unwrap();
+            env.data().data().copy_value_vec_to_wasm(nickname.as_bytes())
+        } else {
+            0
+        }
+    }
+
+
+
     fn pokemon_add_volatile_by_name(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
@@ -288,4 +483,18 @@ register! {
         }
     }
 
+    fn pokemon_get_ability_script(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        pokemon: ExternRef<Pokemon>,
+    ) -> u32 {
+        let pokemon = pokemon.value_func(&env).unwrap();
+        if let Some(script) = pokemon.ability_script().get() {
+            let read_lock = script.read();
+            if let Some(script) = read_lock.as_ref() {
+                return script.as_any().downcast_ref::<WebAssemblyScript>().unwrap().get_wasm_pointer()
+            }
+        }
+        0
+    }
+
 }

src/script_implementations/wasm/export_registry/dynamic_data/turn_choice.rs

@@ -3,6 +3,7 @@ use std::ops::Deref;
 use crate::dynamic_data::{LearnedMove, Pokemon, TurnChoice};
 use crate::script_implementations::wasm::export_registry::register;
 use crate::script_implementations::wasm::extern_ref::ExternRef;
+use crate::script_implementations::wasm::script::WebAssemblyScript;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use wasmer::FunctionEnvMut;
 
@@ -29,6 +30,38 @@ register! {
         }
     }
 
+    fn turn_choice_get_speed(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        turn_choice: ExternRef<TurnChoice>,
+    ) -> u32 {
+        turn_choice.value_func(&env).unwrap().speed()
+    }
+
+    fn turn_choice_has_failed(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        turn_choice: ExternRef<TurnChoice>,
+    ) -> u8 {
+        if turn_choice.value_func(&env).unwrap().has_failed() { 1 } else { 0 }
+    }
+
+    fn turn_choice_fail(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        turn_choice: ExternRef<TurnChoice>,
+    ) {
+        turn_choice.value_func(&env).unwrap().fail();
+    }
+
+
+    fn turn_choice_move_priority(
+        env: FunctionEnvMut<WebAssemblyEnv>,
+        turn_choice: ExternRef<TurnChoice>,
+    ) -> i8 {
+        if let TurnChoice::Move(d) = turn_choice.value_func(&env).unwrap() {
+            return d.priority()
+        }
+        panic!("Invalid turn choice");
+    }
+
     fn turn_choice_move_used_move(
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
@@ -59,11 +92,21 @@ register! {
         panic!("Invalid turn choice");
     }
 
-    fn turn_choice_fail(
+    fn turn_choice_move_script(
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
-    ) {
-        turn_choice.value_func(&env).unwrap().fail();
+    ) -> u32 {
+        if let TurnChoice::Move(d) = turn_choice.value_func(&env).unwrap() {
+            if let Some(script) = d.script().get() {
+                let read_lock = script.read();
+                if let Some(script) = read_lock.as_ref() {
+                    return script.as_any().downcast_ref::<WebAssemblyScript>().unwrap().get_wasm_pointer()
+                }
+            }
+            return 0;
+        }
+        panic!("Invalid turn choice");
     }
 
+
 }