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

Update to Wasmer 3.0 beta
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Deukhoofd
2022-08-27 14:14:58 +02:00
parent c5fb81c179
commit bd62c1ac62
14 changed files with 315 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/script_implementations/wasm/export_registry/dynamic_data/learned_move.rs
View File

@@ -5,21 +5,22 @@ use crate::script_implementations::wasm::export_registry::register;
use crate::script_implementations::wasm::extern_ref::ExternRef;
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::static_data::MoveData;
use wasmer::FunctionEnvMut;
register! {
fn learned_move_get_learn_method(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
turn_choice: ExternRef<LearnedMove>,
) -> u8 {
unsafe {
transmute(turn_choice.value(env).unwrap().learn_method())
transmute(turn_choice.value(&env).unwrap().learn_method())
}
}
fn learned_move_get_move_data(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
turn_choice: ExternRef<LearnedMove>,
) -> ExternRef<MoveData> {
ExternRef::new(env.data().as_ref(), turn_choice.value(env).unwrap().move_data())
ExternRef::func_new(&env, turn_choice.value(&env).unwrap().move_data())
}
}

14
src/script_implementations/wasm/export_registry/dynamic_data/mod.rs
View File

@@ -1,7 +1,7 @@
use crate::dynamic_data::DynamicLibrary;
use crate::script_implementations::wasm::export_registry::register;
use crate::script_implementations::wasm::extern_ref::ExternRef;
use wasmer::{Exports, Store};
use wasmer::{FunctionEnv, FunctionEnvMut, Imports, StoreMut};
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::static_data::StaticData;
@@ -15,17 +15,17 @@ mod turn_choice;
register! {
fn dynamic_library_get_static_data(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
dynamic_lib: ExternRef<DynamicLibrary>,
) -> ExternRef<StaticData> {
ExternRef::new(env.data().as_ref(), dynamic_lib.value(env).unwrap().static_data())
ExternRef::func_new(&env, dynamic_lib.value(&env).unwrap().static_data())
}
manual manual_register
}
/// Additional required manual registration
fn manual_register(exports: &mut Exports, store: &Store, env: WebAssemblyEnv) {
turn_choice::register(exports, store, env.clone());
pokemon::register(exports, store, env.clone());
learned_move::register(exports, store, env);
fn manual_register(imports: &mut Imports, store: &mut StoreMut, env: &FunctionEnv<WebAssemblyEnv>) {
turn_choice::register(imports, store, env);
pokemon::register(imports, store, env);
learned_move::register(imports, store, env);
}

47
src/script_implementations/wasm/export_registry/dynamic_data/pokemon.rs
View File

@@ -6,72 +6,73 @@ use crate::script_implementations::wasm::extern_ref::ExternRef;
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::static_data::StatisticSet;
use crate::static_data::{ClampedStatisticSet, Species};
use wasmer::FunctionEnvMut;
register! {
fn pokemon_get_library(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<DynamicLibrary> {
let lib = pokemon.value(env).unwrap().library();
ExternRef::new(env.data().as_ref(), lib)
let lib = pokemon.value(&env).unwrap().library();
ExternRef::func_new(&env, lib)
}
fn pokemon_get_boosted_stats(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<StatisticSet<u32>> {
let statistic_set = pokemon.value(env).unwrap().boosted_stats();
ExternRef::new(env.data().as_ref(), statistic_set)
let statistic_set = pokemon.value(&env).unwrap().boosted_stats();
ExternRef::func_new(&env, statistic_set)
}
fn pokemon_get_flat_stats(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<StatisticSet<u32>> {
let statistic_set = pokemon.value(env).unwrap().flat_stats();
ExternRef::new(env.data().as_ref(), statistic_set)
let statistic_set = pokemon.value(&env).unwrap().flat_stats();
ExternRef::func_new(&env, statistic_set)
}
fn pokemon_get_stat_boosts(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<ClampedStatisticSet<i8, -6, 6>> {
let statistic_set = pokemon.value(env).unwrap().stat_boosts();
ExternRef::new(env.data().as_ref(), statistic_set)
let statistic_set = pokemon.value(&env).unwrap().stat_boosts();
ExternRef::func_new(&env, statistic_set)
}
fn pokemon_get_individual_values(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<ClampedStatisticSet<u8, 0, 31>> {
let statistic_set = pokemon.value(env).unwrap().individual_values();
ExternRef::new(env.data().as_ref(), statistic_set)
let statistic_set = pokemon.value(&env).unwrap().individual_values();
ExternRef::func_new(&env, statistic_set)
}
fn pokemon_get_effort_values(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<ClampedStatisticSet<u8, 0, 252>> {
let statistic_set = pokemon.value(env).unwrap().effort_values();
ExternRef::new(env.data().as_ref(), statistic_set)
let statistic_set = pokemon.value(&env).unwrap().effort_values();
ExternRef::func_new(&env, statistic_set)
}
fn pokemon_get_species(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
) -> ExternRef<Species> {
let species = pokemon.value(env).unwrap().species();
ExternRef::new(env.data().as_ref(), species)
let species = pokemon.value(&env).unwrap().species();
ExternRef::func_new(&env, species)
}
fn pokemon_damage(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
pokemon: ExternRef<Pokemon>,
damage: u32,
source: u8
) {
unsafe{
pokemon.value(env).unwrap().damage(damage, transmute(source));
pokemon.value(&env).unwrap().damage(damage, transmute(source));
}
}
}

25
src/script_implementations/wasm/export_registry/dynamic_data/turn_choice.rs
View File

@@ -4,22 +4,23 @@ 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_resolver::WebAssemblyEnv;
use wasmer::FunctionEnvMut;
register! {
fn turn_choice_get_user(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
turn_choice: ExternRef<TurnChoice>,
) -> ExternRef<Pokemon> {
let turn_choice = turn_choice.value(env).unwrap();
ExternRef::new(env.data().as_ref(), turn_choice.user().as_ref().deref())
let turn_choice = turn_choice.value(&env).unwrap();
ExternRef::func_new(&env, turn_choice.user().as_ref().deref())
}
fn turn_choice_get_kind(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
turn_choice: ExternRef<TurnChoice>,
) -> u8 {
match turn_choice.value(env).unwrap() {
match turn_choice.value(&env).unwrap() {
TurnChoice::Move(_) => 0,
TurnChoice::Item(_) => 1,
TurnChoice::Switch(_) => 2,
@@ -29,30 +30,30 @@ register! {
}
fn turn_choice_move_used_move(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
turn_choice: ExternRef<TurnChoice>,
) -> ExternRef<LearnedMove> {
if let TurnChoice::Move(d) = turn_choice.value(env).unwrap() {
return ExternRef::new(env.data().as_ref(), d.used_move().as_ref());
if let TurnChoice::Move(d) = turn_choice.value(&env).unwrap() {
return ExternRef::func_new(&env, d.used_move().as_ref());
}
panic!("Invalid turn choice");
}
fn turn_choice_move_target_side(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
turn_choice: ExternRef<TurnChoice>,
) -> u8 {
if let TurnChoice::Move(d) = turn_choice.value(env).unwrap() {
if let TurnChoice::Move(d) = turn_choice.value(&env).unwrap() {
return d.target_side();
}
panic!("Invalid turn choice");
}
fn turn_choice_move_target_index(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
turn_choice: ExternRef<TurnChoice>,
) -> u8 {
if let TurnChoice::Move(d) = turn_choice.value(env).unwrap() {
if let TurnChoice::Move(d) = turn_choice.value(&env).unwrap() {
return d.target_index();
}
panic!("Invalid turn choice");

118
src/script_implementations/wasm/export_registry/mod.rs
View File

@@ -1,7 +1,7 @@
use std::ffi::CString;
use std::mem::{align_of, forget};
use wasmer::{Exports, Store};
use wasmer::{FunctionEnv, FunctionEnvMut, Imports, StoreMut};
use crate::script_implementations::wasm::extern_ref::ExternRef;
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
@@ -14,19 +14,12 @@ mod dynamic_data;
mod static_data;
/// Register a single function.
#[allow(unused_macros)]
macro_rules! register_func {
($exports: ident, $store: ident, $func: ident) => {
$exports.insert(stringify!($func), Function::new_native($store, $func));
};
}
/// Register a single function that requires environment data.
macro_rules! register_func_with_env {
($exports: ident, $store: ident, $func: ident, $env: expr) => {
$exports.insert(
($imports: ident, $store: ident, $func: ident, $env: expr) => {
$imports.define(
"env",
stringify!($func),
wasmer::Function::new_native_with_env($store, $env.clone(), $func),
wasmer::Function::new_typed_with_env($store, $env, $func),
);
};
}
@@ -41,19 +34,22 @@ macro_rules! register {
manual $manual_name:ident
)?
) => {
pub(crate) fn register(exports: &mut crate::script_implementations::wasm::export_registry::Exports,
store: &crate::script_implementations::wasm::export_registry::Store,
env: crate::script_implementations::wasm::script_resolver::WebAssemblyEnv) {
$(
$(
fn $name(
$(
$par: $par_type,
)*
) $(-> $return)* $block
crate::script_implementations::wasm::export_registry::register_func_with_env!(exports, store, $name, env);
)*
$( $manual_name(exports, store, env) )*
pub(crate) fn register(imports: &mut wasmer::Imports,
store: &mut wasmer::StoreMut,
env: &wasmer::FunctionEnv<crate::script_implementations::wasm::script_resolver::WebAssemblyEnv>) {
$(
crate::script_implementations::wasm::export_registry::register_func_with_env!(imports, store, $name, env);
)*
$( $manual_name(imports, store, env) )*
}
};
}
@@ -62,27 +58,31 @@ pub(crate) use register;
pub(crate) use register_func_with_env;
/// Register the functions we expose to WASM.
pub(crate) fn register_webassembly_funcs(exports: &mut Exports, store: &Store, env: WebAssemblyEnv) {
register_func_with_env!(exports, store, _print, env);
register_func_with_env!(exports, store, _error, env);
register_func_with_env!(exports, store, _vec_extern_ref_get_value, env);
pub(crate) fn register_webassembly_funcs(
imports: &mut Imports,
store: &mut StoreMut,
env: &FunctionEnv<WebAssemblyEnv>,
) {
register_func_with_env!(imports, store, _print, env);
register_func_with_env!(imports, store, _error, env);
register_func_with_env!(imports, store, _vec_extern_ref_get_value, env);
static_data::register(exports, store, env.clone());
dynamic_data::register(exports, store, env.clone());
static_data::register(imports, store, env);
dynamic_data::register(imports, store, env);
register_func_with_env!(exports, store, string_key_get_hash, env);
register_func_with_env!(exports, store, string_key_get_str, env);
register_func_with_env!(exports, store, effect_parameter_get_type, env);
register_func_with_env!(exports, store, effect_parameter_as_bool, env);
register_func_with_env!(exports, store, effect_parameter_as_int, env);
register_func_with_env!(exports, store, effect_parameter_as_float, env);
register_func_with_env!(exports, store, effect_parameter_as_string, env);
register_func_with_env!(imports, store, string_key_get_hash, env);
register_func_with_env!(imports, store, string_key_get_str, env);
register_func_with_env!(imports, store, effect_parameter_get_type, env);
register_func_with_env!(imports, store, effect_parameter_as_bool, env);
register_func_with_env!(imports, store, effect_parameter_as_int, env);
register_func_with_env!(imports, store, effect_parameter_as_float, env);
register_func_with_env!(imports, store, effect_parameter_as_string, env);
}
/// Logging function for WASM.
fn _print(env: &WebAssemblyEnv, p: u32, len: u32) {
fn _print(env: FunctionEnvMut<WebAssemblyEnv>, p: u32, len: u32) {
unsafe {
let mem: *mut u8 = env.data().memory().data_ptr().offset(p as isize);
let mem: *mut u8 = env.data().data().memory().offset(p as isize);
let s = String::from_raw_parts(mem, len as usize, len as usize);
println!("{}", s);
forget(s);
@@ -91,11 +91,19 @@ fn _print(env: &WebAssemblyEnv, p: u32, len: u32) {
/// Triggers when WASM panics.
#[track_caller]
fn _error(env: &WebAssemblyEnv, message: u32, message_len: u32, file: u32, file_len: u32, line: u32, position: u32) {
fn _error(
env: FunctionEnvMut<WebAssemblyEnv>,
message: u32,
message_len: u32,
file: u32,
file_len: u32,
line: u32,
position: u32,
) {
unsafe {
let mem: *mut u8 = env.data().memory().data_ptr().offset(message as isize);
let mem: *mut u8 = env.data().data().memory().offset(message as isize);
let message_str = String::from_raw_parts(mem, message_len as usize, message_len as usize);
let mem: *mut u8 = env.data().memory().data_ptr().offset(file as isize);
let mem: *mut u8 = env.data().data().memory().offset(file as isize);
let file_str = String::from_raw_parts(mem, file_len as usize, file_len as usize);
panic!(
"Error: {} in file {}, line: {}:{}",
@@ -105,20 +113,21 @@ fn _error(env: &WebAssemblyEnv, message: u32, message_len: u32, file: u32, file_
}
/// Get a single item from an earlier passed VecExternRef
fn _vec_extern_ref_get_value(env: &WebAssemblyEnv, reference: u32, index: u32) -> u32 {
env.data().get_extern_vec_ref_extern_ref(reference, index)
fn _vec_extern_ref_get_value(env: FunctionEnvMut<WebAssemblyEnv>, reference: u32, index: u32) -> u32 {
env.data().data().get_extern_vec_ref_extern_ref(reference, index)
}
/// Gets the hash value of a StringKey.
fn string_key_get_hash(env: &WebAssemblyEnv, string_key: ExternRef<StringKey>) -> u32 {
string_key.value(env).unwrap().hash()
fn string_key_get_hash(env: FunctionEnvMut<WebAssemblyEnv>, string_key: ExternRef<StringKey>) -> u32 {
string_key.value(&env).unwrap().hash()
}
/// Get a null-terminated C string from a StringKey. Note that this involves a copy into WASM
/// memory, so this is relatively heavy.
fn string_key_get_str(env: &WebAssemblyEnv, string_key: ExternRef<StringKey>) -> u32 {
let string_key = string_key.value(env).unwrap().str();
fn string_key_get_str(env: FunctionEnvMut<WebAssemblyEnv>, string_key: ExternRef<StringKey>) -> u32 {
let string_key = string_key.value(&env).unwrap().str();
let wasm_string_ptr = env
.data()
.data()
.allocate_mem((string_key.len() + 1) as u32, align_of::<CString>() as u32);
let mut wasm_string: Vec<u8> =
@@ -131,8 +140,8 @@ fn string_key_get_str(env: &WebAssemblyEnv, string_key: ExternRef<StringKey>) ->
}
/// Gets the type of an EffectParameter
fn effect_parameter_get_type(env: &WebAssemblyEnv, parameter: ExternRef<EffectParameter>) -> u8 {
let v = parameter.value(env).unwrap();
fn effect_parameter_get_type(env: FunctionEnvMut<WebAssemblyEnv>, parameter: ExternRef<EffectParameter>) -> u8 {
let v = parameter.value(&env).unwrap();
match v {
EffectParameter::Bool(_) => 1,
EffectParameter::Int(_) => 2,
@@ -142,8 +151,8 @@ fn effect_parameter_get_type(env: &WebAssemblyEnv, parameter: ExternRef<EffectPa
}
/// Gets the inner bool data of an EffectParameter. Panics if it's not a bool.
fn effect_parameter_as_bool(env: &WebAssemblyEnv, parameter: ExternRef<EffectParameter>) -> u8 {
let v = parameter.value(env).unwrap();
fn effect_parameter_as_bool(env: FunctionEnvMut<WebAssemblyEnv>, parameter: ExternRef<EffectParameter>) -> u8 {
let v = parameter.value(&env).unwrap();
match v {
EffectParameter::Bool(b) => {
if *b {
@@ -157,8 +166,8 @@ fn effect_parameter_as_bool(env: &WebAssemblyEnv, parameter: ExternRef<EffectPar
}
/// Gets the inner int data of an EffectParameter. Panics if it's not an int.
fn effect_parameter_as_int(env: &WebAssemblyEnv, parameter: ExternRef<EffectParameter>) -> i64 {
let v = parameter.value(env).unwrap();
fn effect_parameter_as_int(env: FunctionEnvMut<WebAssemblyEnv>, parameter: ExternRef<EffectParameter>) -> i64 {
let v = parameter.value(&env).unwrap();
match v {
EffectParameter::Int(i) => *i,
_ => panic!("Unexpected parameter type!"),
@@ -166,8 +175,8 @@ fn effect_parameter_as_int(env: &WebAssemblyEnv, parameter: ExternRef<EffectPara
}
/// Gets the inner float data of an EffectParameter. Panics if it's not a float.
fn effect_parameter_as_float(env: &WebAssemblyEnv, parameter: ExternRef<EffectParameter>) -> f32 {
let v = parameter.value(env).unwrap();
fn effect_parameter_as_float(env: FunctionEnvMut<WebAssemblyEnv>, parameter: ExternRef<EffectParameter>) -> f32 {
let v = parameter.value(&env).unwrap();
match v {
EffectParameter::Float(f) => *f,
_ => panic!("Unexpected parameter type!"),
@@ -175,10 +184,13 @@ fn effect_parameter_as_float(env: &WebAssemblyEnv, parameter: ExternRef<EffectPa
}
/// Gets the inner string data of an EffectParameter. Panics if it's not a string.
fn effect_parameter_as_string(env: &WebAssemblyEnv, parameter: ExternRef<EffectParameter>) -> ExternRef<StringKey> {
let v = parameter.value(env).unwrap();
fn effect_parameter_as_string(
env: FunctionEnvMut<WebAssemblyEnv>,
parameter: ExternRef<EffectParameter>,
) -> ExternRef<StringKey> {
let v = parameter.value(&env).unwrap();
match v {
EffectParameter::String(s) => ExternRef::new(env.data().as_ref(), s),
EffectParameter::String(s) => ExternRef::func_new(&env, s),
_ => panic!("Unexpected parameter type!"),
}
}

32
src/script_implementations/wasm/export_registry/static_data/mod.rs
View File

@@ -1,4 +1,4 @@
use wasmer::{Exports, Store};
use wasmer::{FunctionEnv, FunctionEnvMut, Imports, StoreMut};
use crate::defines::LevelInt;
use crate::script_implementations::wasm::export_registry::register;
@@ -12,41 +12,41 @@ mod moves;
mod species;
register! {
fn static_data_get_move_library(env: &WebAssemblyEnv, data_library: ExternRef<StaticData>) -> ExternRef<MoveLibrary> {
ExternRef::new(env.data().as_ref(), data_library.value(env).unwrap().moves())
fn static_data_get_move_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<StaticData>) -> ExternRef<MoveLibrary> {
ExternRef::func_new(&env, data_library.value(&env).unwrap().moves())
}
fn static_data_get_species_library(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
data_library: ExternRef<StaticData>,
) -> ExternRef<SpeciesLibrary> {
ExternRef::new(env.data().as_ref(), data_library.value(env).unwrap().species())
ExternRef::func_new(&env, data_library.value(&env).unwrap().species())
}
fn static_data_get_item_library(env: &WebAssemblyEnv, data_library: ExternRef<StaticData>) -> ExternRef<ItemLibrary> {
ExternRef::new(env.data().as_ref(), data_library.value(env).unwrap().items())
fn static_data_get_item_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<StaticData>) -> ExternRef<ItemLibrary> {
ExternRef::func_new(&env, data_library.value(&env).unwrap().items())
}
fn static_data_get_type_library(env: &WebAssemblyEnv, data_library: ExternRef<StaticData>) -> ExternRef<TypeLibrary> {
ExternRef::new(env.data().as_ref(), data_library.value(env).unwrap().types())
fn static_data_get_type_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<StaticData>) -> ExternRef<TypeLibrary> {
ExternRef::func_new(&env, data_library.value(&env).unwrap().types())
}
fn static_data_get_library_settings(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
data_library: ExternRef<StaticData>,
) -> ExternRef<LibrarySettings> {
ExternRef::new(env.data().as_ref(), data_library.value(env).unwrap().settings())
ExternRef::func_new(&env, data_library.value(&env).unwrap().settings())
}
fn library_settings_get_maximum_level(env: &WebAssemblyEnv, data_library: ExternRef<LibrarySettings>) -> LevelInt {
data_library.value(env).unwrap().maximum_level()
fn library_settings_get_maximum_level(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<LibrarySettings>) -> LevelInt {
data_library.value(&env).unwrap().maximum_level()
}
manual manual_registration
}
/// Additional required manual registration.
fn manual_registration(exports: &mut Exports, store: &Store, env: WebAssemblyEnv) {
moves::register(exports, store, env.clone());
species::register(exports, store, env);
fn manual_registration(imports: &mut Imports, store: &mut StoreMut, env: &FunctionEnv<WebAssemblyEnv>) {
moves::register(imports, store, env);
species::register(imports, store, env);
}

55
src/script_implementations/wasm/export_registry/static_data/moves.rs
View File

@@ -3,66 +3,67 @@ use crate::script_implementations::wasm::extern_ref::ExternRef;
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::static_data::{DataLibrary, MoveData, MoveLibrary};
use crate::StringKey;
use wasmer::FunctionEnvMut;
register! {
fn move_library_get_move(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
lib: ExternRef<MoveLibrary>,
string_key: ExternRef<StringKey>,
) -> ExternRef<MoveData> {
let lib = lib.value(env).unwrap();
let m = lib.get(string_key.value(env).unwrap());
let lib = lib.value(&env).unwrap();
let m = lib.get(string_key.value(&env).unwrap());
if let Some(v) = m {
ExternRef::new(env.data().as_ref(), v)
ExternRef::func_new(&env, v)
} else {
ExternRef::null()
}
}
fn move_library_get_move_by_hash(env: &WebAssemblyEnv, lib: ExternRef<MoveLibrary>, hash: u32) -> ExternRef<MoveData> {
let lib = lib.value(env).unwrap();
fn move_library_get_move_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, lib: ExternRef<MoveLibrary>, hash: u32) -> ExternRef<MoveData> {
let lib = lib.value(&env).unwrap();
let m = lib.get_by_hash(hash);
if let Some(v) = m {
ExternRef::new(env.data().as_ref(), v)
ExternRef::func_new(&env, v)
} else {
ExternRef::null()
}
}
fn move_data_get_name(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> ExternRef<StringKey> {
ExternRef::new(env.data().as_ref(), move_data.value(env).unwrap().name())
fn move_data_get_name(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> ExternRef<StringKey> {
ExternRef::func_new(&env, move_data.value(&env).unwrap().name())
}
fn move_data_get_type(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(env).unwrap().move_type().into()
fn move_data_get_type(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(&env).unwrap().move_type().into()
}
fn move_data_get_category(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(env).unwrap().category() as u8
fn move_data_get_category(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(&env).unwrap().category() as u8
}
fn move_data_get_base_power(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(env).unwrap().base_power()
fn move_data_get_base_power(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(&env).unwrap().base_power()
}
fn move_data_get_accuracy(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(env).unwrap().accuracy()
fn move_data_get_accuracy(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(&env).unwrap().accuracy()
}
fn move_data_get_base_usages(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(env).unwrap().base_usages()
fn move_data_get_base_usages(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(&env).unwrap().base_usages()
}
fn move_data_get_target(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(env).unwrap().target() as u8
fn move_data_get_target(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> u8 {
move_data.value(&env).unwrap().target() as u8
}
fn move_data_get_priority(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>) -> i8 {
move_data.value(env).unwrap().priority()
fn move_data_get_priority(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>) -> i8 {
move_data.value(&env).unwrap().priority()
}
fn move_data_has_flag(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>, flag: ExternRef<StringKey>) -> u8 {
if move_data.value(env).unwrap().has_flag(flag.value(env).unwrap()) {
fn move_data_has_flag(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>, flag: ExternRef<StringKey>) -> u8 {
if move_data.value(&env).unwrap().has_flag(flag.value(&env).unwrap()) {
1
} else {
0
}
}
fn move_data_has_flag_by_hash(env: &WebAssemblyEnv, move_data: ExternRef<MoveData>, flag_hash: u32) -> u8 {
if move_data.value(env).unwrap().has_flag_by_hash(flag_hash) {
fn move_data_has_flag_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<MoveData>, flag_hash: u32) -> u8 {
if move_data.value(&env).unwrap().has_flag_by_hash(flag_hash) {
1
} else {
0

33
src/script_implementations/wasm/export_registry/static_data/species.rs
View File

@@ -3,58 +3,59 @@ use crate::script_implementations::wasm::extern_ref::ExternRef;
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::static_data::{DataLibrary, Species, SpeciesLibrary};
use crate::StringKey;
use wasmer::FunctionEnvMut;
register! {
fn species_library_get_species(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
lib: ExternRef<SpeciesLibrary>,
string_key: ExternRef<StringKey>,
) -> ExternRef<Species> {
let lib = lib.value(env).unwrap();
let m = lib.get(string_key.value(env).unwrap());
let lib = lib.value(&env).unwrap();
let m = lib.get(string_key.value(&env).unwrap());
if let Some(v) = m {
ExternRef::new(env.data().as_ref(), v)
ExternRef::func_new(&env, v)
} else {
ExternRef::null()
}
}
fn species_get_capture_rate(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
) -> u8 {
species.value(env).unwrap().capture_rate()
species.value(&env).unwrap().capture_rate()
}
fn species_get_growth_rate(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
) -> ExternRef<StringKey> {
let species = species.value(env).unwrap();
ExternRef::new(env.data().as_ref(), species.growth_rate())
let species = species.value(&env).unwrap();
ExternRef::func_new(&env, species.growth_rate())
}
fn species_get_gender_rate(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
) -> f32 {
species.value(env).unwrap().gender_rate()
species.value(&env).unwrap().gender_rate()
}
fn species_get_name(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
) -> ExternRef<StringKey> {
let species = species.value(env).unwrap();
ExternRef::new(env.data().as_ref(), species.name())
let species = species.value(&env).unwrap();
ExternRef::func_new(&env, species.name())
}
fn species_get_id(
env: &WebAssemblyEnv,
env: FunctionEnvMut<WebAssemblyEnv>,
species: ExternRef<Species>,
) -> u16 {
species.value(env).unwrap().id()
species.value(&env).unwrap().id()
}