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

use crate::dynamic_data::{
    Battle, BattleParty, BattleRandom, BattleResult, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon, PokemonParty,
};
use crate::script_implementations::wasm::export_registry::wasm_result::{
    get_value, get_value_arc, get_value_call_getter, try_wasm,
};
use crate::script_implementations::wasm::export_registry::{register, wasm_ok, WasmResult};
use crate::script_implementations::wasm::extern_ref::{ExternRef, VecExternRef};
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::StringKey;
use anyhow_ext::Context;
use wasmer::FunctionEnvMut;

register! {
    fn battle_get_pokemon_per_side(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<u8> {
        let value = get_value_call_getter!(battle.pokemon_per_side(), env);
        wasm_ok(value)
    }

    fn battle_get_parties(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<VecExternRef<BattleParty>> {
        let parties = get_value_call_getter!(battle.parties(), env);
        wasm_ok(VecExternRef::new(env.data().data().as_ref(), parties))
    }

    fn battle_get_choice_queue(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<ExternRef<ChoiceQueue>> {
        let value = get_value_call_getter!(battle.current_turn_queue(), env);
        let queue = value.read();
        wasm_ok(if let Some(queue) = queue.as_ref() {
            ExternRef::<ChoiceQueue>::func_new(&env, queue)
        } else {
            ExternRef::null()
        })
    }

    fn battle_get_library(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<ExternRef<dyn DynamicLibrary>> {
        let value = get_value_call_getter!(battle.library(), env);
        wasm_ok(ExternRef::<dyn DynamicLibrary>::func_new(&env, &value.clone()))
    }

    fn battle_get_sides(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<VecExternRef<BattleSide>> {
        let value = get_value_arc!(battle, env);
        wasm_ok(VecExternRef::new(env.data().data().as_ref(), value.sides()))
    }

    fn battle_get_random(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<ExternRef<BattleRandom>> {
        let random = get_value_call_getter!(battle.random(), env);
        wasm_ok(ExternRef::<BattleRandom>::func_new(&env, random))
    }

    fn battle_get_weather_name(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<ExternRef<StringKey>> {
        let weather = get_value_call_getter!(battle.weather_name(), env);
        let weather = try_wasm!(weather, env);
        wasm_ok(if let Some(weather) = weather {
            ExternRef::<StringKey>::func_new(&env, &weather)
        } else {
            ExternRef::null()
        })
    }

    fn battle_find_party_for_pokemon(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
        pokemon: ExternRef<Pokemon>
    ) -> WasmResult<ExternRef<BattleParty>> {
        let battle = get_value!(battle, env);
        let pokemon = get_value!(pokemon, env);
        for party in battle.parties() {
            if party.party().has_pokemon(pokemon) {
                return wasm_ok(ExternRef::<BattleParty>::func_new(&env, party));
            }
        }
        wasm_ok(ExternRef::<BattleParty>::null())
    }

    fn battle_get_pokemon(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
        side: u8, index: u8
    ) -> WasmResult<ExternRef<Pokemon>> {
        let battle = get_value!(battle, env);
        let pokemon = battle.get_pokemon(side, index);
        wasm_ok(if let Some(pokemon) = pokemon {
            ExternRef::<Pokemon>::func_new(&env, &pokemon)
        } else {
            ExternRef::null()
        })
    }

    fn battle_get_can_flee(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<u8> {
        wasm_ok(if get_value_call_getter!(battle.can_flee(), env) { 1 } else { 0 })
    }

    fn battle_get_number_of_sides(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<u8> {
        wasm_ok(get_value_call_getter!(battle.number_of_sides(), env))
    }

    fn battle_get_has_ended(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<u8> {
        wasm_ok(if get_value_call_getter!(battle.has_ended(), env) { 1u8 } else { 0u8 })
    }

    fn battle_get_has_ended_conclusively(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<u8> {
        let value = get_value_call_getter!(battle.result(), env);
        wasm_ok(if value.is_conclusive() { 1 } else { 0 })
    }

    fn battle_get_winning_side(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<u8> {
        let value = get_value_call_getter!(battle.result(), env);
        wasm_ok(if let BattleResult::Conclusive(result) = value {
            result
        } else {
            0
        })
    }

    fn battle_get_current_turn(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle: ExternRef<Battle>,
    ) -> WasmResult<u32> {
        wasm_ok(get_value_call_getter!(battle.current_turn(), env))
    }

    fn battle_party_get_party(
        env: FunctionEnvMut<WebAssemblyEnv>,
        battle_party: ExternRef<BattleParty>,
    ) -> WasmResult<ExternRef<PokemonParty>> {
        let value = get_value_call_getter!(battle_party.party(), env);
        wasm_ok(ExternRef::<PokemonParty>::func_new(&env, value.as_ref()))
    }
}