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

use crate::dynamic_data::{DynamicLibrary, MiscLibrary, ScriptOwnerData};
use crate::script_implementations::wasm::export_registry::register;
use crate::script_implementations::wasm::export_registry::wasm_result::{try_wasm, wasm_ok, WasmResult};
use crate::script_implementations::wasm::extern_ref::ExternRef;
use wasmer::{FunctionEnv, FunctionEnvMut, Imports, StoreMut};

use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::static_data::{StaticData, TimeOfDay};

/// The battle registration
mod battle;
/// Battle random registration
mod battle_random;
/// Battle side registration
mod battle_side;
/// Choice queue registration.
mod choice_queue;
/// The executing move registration/
mod executing_move;
/// The hit data registration/
mod hit_data;
/// Learned move registration
mod learned_move;
/// The party registration.
mod party;
/// Pokemon registration
mod pokemon;
/// Turn choice registration
mod turn_choice;

register! {
    fn dynamic_library_get_static_data(
        env: FunctionEnvMut<WebAssemblyEnv>,
        dynamic_lib: ExternRef<dyn DynamicLibrary>,
    ) -> WasmResult<ExternRef<dyn StaticData>> {
        let dynamic_lib = try_wasm!(dynamic_lib.value_func_arc(&env), env);
        let static_data = dynamic_lib.static_data();
        wasm_ok(ExternRef::<dyn StaticData>::func_new(&env, static_data.into()))
    }

    fn dynamic_library_get_misc_library(
        env: FunctionEnvMut<WebAssemblyEnv>,
        dynamic_lib: ExternRef<dyn DynamicLibrary>,
    ) -> WasmResult<ExternRef<dyn MiscLibrary>> {
        let dynamic_lib = try_wasm!(dynamic_lib.value_func_arc(&env), env);
        let misc_library = dynamic_lib.misc_library();
        wasm_ok(ExternRef::<dyn MiscLibrary>::func_new(&env, misc_library.into()))
    }

    fn misc_library_get_time_of_day(
        env: FunctionEnvMut<WebAssemblyEnv>,
        dynamic_lib: ExternRef<dyn MiscLibrary>,
    ) -> WasmResult<u8> {
        let misc_library = try_wasm!(dynamic_lib.value_func_arc(&env), env);
        unsafe{
            let time_of_day = misc_library.time_of_day();
            wasm_ok(std::mem::transmute::<TimeOfDay, u8>(time_of_day))
        }
    }


    fn script_get_owner(
        env: FunctionEnvMut<WebAssemblyEnv>,
        script: u32,
    ) -> u32 {
        let script = env.data().data().get_loaded_script(script);
        if let Some(script) = script {
            match script.get_owner() {
                ScriptOwnerData::Pokemon(p) => env.data().data().get_extern_ref_index(p.into()) as u32,
                ScriptOwnerData::BattleSide(p) => env.data().data().get_extern_ref_index(p.into()) as u32,
                ScriptOwnerData::Battle(p) => env.data().data().get_extern_ref_index(p.into()) as u32,
                ScriptOwnerData::None => 0,
            }
        } else {
            0
        }
    }

    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
}

/// Additional required manual registration
fn manual_register(imports: &mut Imports, store: &mut StoreMut, env: &FunctionEnv<WebAssemblyEnv>) {
    battle::register(imports, store, env);
    turn_choice::register(imports, store, env);
    pokemon::register(imports, store, env);
    learned_move::register(imports, store, env);
    battle_side::register(imports, store, env);
    battle_random::register(imports, store, env);
    choice_queue::register(imports, store, env);
    party::register(imports, store, env);
    executing_move::register(imports, store, env);
    hit_data::register(imports, store, env);
}