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

use crate::dynamic_data::{Battle, BattleSide, Pokemon, VolatileScriptsOwner};
use crate::script_implementations::wasm::export_registry::{register, WasmResult};
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::ScriptCategory;
use anyhow::anyhow;
use std::ffi::CStr;
use wasmer::FunctionEnvMut;

register! {
    fn battleside_has_fled_battle(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
    ) -> WasmResult<u8> {
        Ok(u8::from(side.value_func(&env)?.has_fled_battle())).into()
    }

    fn battleside_is_defeated(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
    ) -> WasmResult<u8> {
        Ok(u8::from(side.value_func(&env)?.is_defeated())).into()
    }

    fn battleside_get_side_index(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
    ) -> WasmResult<u8> {
        Ok(side.value_func(&env)?.index()).into()
    }

    fn battleside_get_pokemon_per_side(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
    ) -> WasmResult<u8> {
        Ok(side.value_func(&env)?.pokemon_per_side()).into()
    }

    fn battleside_get_battle(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
    ) -> WasmResult<ExternRef<Battle>> {
        Ok(ExternRef::func_new(&env, side.value_func(&env)?.battle()?)).into()
    }

    fn battleside_get_pokemon(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
        index: u32
    ) -> WasmResult<ExternRef<Pokemon>> {
        Ok(if let Some(Some(p)) = side.value_func(&env)?.pokemon().get(index as usize) {
            ExternRef::func_new(&env, p.as_ref())
        } else {
            ExternRef::null()
        }).into()
    }

    fn battle_side_get_has_fled_battle(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
    ) -> WasmResult<u8> {
        Ok(if side.value_func(&env)?.has_fled_battle() { 1 } else { 0 }).into()
    }

    fn battle_side_get_is_defeated(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
    ) -> WasmResult<u8> {
        Ok(if side.value_func(&env)?.is_defeated() { 1 } else { 0 }).into()
    }

    fn battleside_add_volatile_by_name(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
        name_ptr: u32
    ) -> WasmResult<u32> {
        unsafe {
            let c_name = CStr::from_ptr(env.data().data().get_raw_pointer(name_ptr));
            let script = side.value_func(&env)?.add_volatile_script(&c_name.as_ref().into())?;
            Ok(if let Some(script) = script {
                let script = script.get_as::<WebAssemblyScript>()?;
                script.get_wasm_pointer()
            } else {
                0
            }).into()
        }
    }

    fn battleside_add_volatile(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
        script_ptr: u32
    ) -> WasmResult<u32> {
        let side : &BattleSide = side.value_func(&env)?;
        unsafe {
            let env = env.data().data();
            let name_ptr = match env
                .script_function_cache()
                .script_get_name(&env)?
                .call(&mut env.store_mut(), script_ptr) {
                Ok(name_ptr) => Ok(name_ptr),
                Err(e) => Err(e.into())
            }?;
            let c_name: &CStr = CStr::from_ptr(env.get_raw_pointer(name_ptr));
            let script = env.setup_script(script_ptr, ScriptCategory::Side, &c_name.as_ref().into(), side.into())?;
            env.script_function_cache().dealloc_cstring(&env, name_ptr)?;

            Ok(if let Some(script) = script {
                let script = side.add_volatile_script_with_script(script)?;
                let s = script.as_ref().ok_or(anyhow!("Couldn't get script"))?.get_as::<WebAssemblyScript>()?;
                s.get_wasm_pointer()
            } else {
                0
            }).into()
        }
    }

    fn battleside_has_volatile(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
        name_ptr: u32
    ) -> WasmResult<u8> {
        unsafe {
            let c_name = CStr::from_ptr(env.data().data().get_raw_pointer(name_ptr));
            Ok(u8::from(side.value_func(&env)?.has_volatile_script(&c_name.as_ref().into()))).into()
        }
    }

    fn battleside_get_volatile(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
        name_ptr: u32
    ) -> WasmResult<u32> {
        unsafe {
            let c_name = CStr::from_ptr(env.data().data().get_raw_pointer(name_ptr));
            let script = side.value_func(&env)?.get_volatile_script(&c_name.as_ref().into());
            Ok(if let Some(script) = script {
                let script = script.get_as::<WebAssemblyScript>()?;
                script.get_wasm_pointer()
            } else {
                0
            }).into()
        }
    }

    fn battleside_remove_volatile(
        env: FunctionEnvMut<WebAssemblyEnv>,
        side: ExternRef<BattleSide>,
        name_ptr: u32
    ) -> WasmResult<()> {
        unsafe {
            let c_name = CStr::from_ptr(env.data().data().get_raw_pointer(name_ptr));
            side.value_func(&env)?.remove_volatile_script(&c_name.as_ref().into()).into()
        }
    }

}