From e32d655d80e7b22524a6aff3d637ccf1fed186d0 Mon Sep 17 00:00:00 2001
From: Deukhoofd <Deukhoofd@gmail.com>
Date: Sat, 14 May 2022 11:48:27 +0200
Subject: [PATCH] Initial work on WebAssembly script provider

---
 CMakeLists.txt                                |  32 ++-
 sanitizer_ignores                             |   1 +
 src/Battling/Library/ScriptResolver.hpp       |   1 +
 src/Library/Moves/MoveLibrary.hpp             |  10 +
 .../WASM/InterfaceMethods/CoreMethods.cpp     |  86 ++++++++
 .../WASM/InterfaceMethods/CoreMethods.hpp     |  14 ++
 .../Library/LibraryMethods.cpp                |  39 ++++
 .../Library/LibraryMethods.hpp                |  13 ++
 .../WASM/InterfaceMethods/WasmHelperFile.hpp  | 197 ++++++++++++++++++
 src/ScriptResolving/WASM/WasmExternRef.hpp    |  13 ++
 .../WASM/WebAssemblyBattleScript.cpp          |  40 ++++
 .../WASM/WebAssemblyBattleScript.hpp          |  35 ++++
 .../WASM/WebAssemblyFunctionCall.hpp          | 107 ++++++++++
 .../WASM/WebAssemblyScriptCapabilities.hpp    |  63 ++++++
 .../WASM/WebAssemblyScriptResolver.cpp        | 175 ++++++++++++++++
 .../WASM/WebAssemblyScriptResolver.hpp        |  92 ++++++++
 tests/LibraryTests/SpeciesLibraryTests.cpp    |   5 +
 .../BaseScriptClassTests.cpp                  |   2 +-
 .../{ => Angelscript}/ItemUseScriptTests.cpp  |   2 +-
 .../{ => Angelscript}/MetadataTests.cpp       |   6 +-
 .../{ => Angelscript}/ScriptOwnerTest.cpp     |   2 +-
 .../{ => Angelscript}/ScriptResolverTests.cpp |   2 +-
 .../ScriptTypeTests/Battle/BattleTests.cpp    |   2 +-
 .../ScriptTypeTests/Battle/PokemonTests.cpp   |   2 +-
 .../ScriptTypeTests/Library/FormesTests.cpp   |   2 +-
 .../ScriptTypeTests/Library/ItemDataTests.cpp |   2 +-
 .../ScriptTypeTests/Library/MoveTests.cpp     |   2 +-
 .../ScriptTypeTests/Library/SpeciesTests.cpp  |   2 +-
 .../Library/StaticLibraryTests.cpp            |   2 +-
 .../ScriptTests/WASM/ScriptResolverTests.cpp  |  63 ++++++
 tests/ScriptTests/WASM/gen7_scripts_rs.wasm   | Bin 0 -> 28705 bytes
 31 files changed, 995 insertions(+), 19 deletions(-)
 create mode 100644 sanitizer_ignores
 create mode 100644 src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.cpp
 create mode 100644 src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.hpp
 create mode 100644 src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.cpp
 create mode 100644 src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.hpp
 create mode 100644 src/ScriptResolving/WASM/InterfaceMethods/WasmHelperFile.hpp
 create mode 100644 src/ScriptResolving/WASM/WasmExternRef.hpp
 create mode 100644 src/ScriptResolving/WASM/WebAssemblyBattleScript.cpp
 create mode 100644 src/ScriptResolving/WASM/WebAssemblyBattleScript.hpp
 create mode 100644 src/ScriptResolving/WASM/WebAssemblyFunctionCall.hpp
 create mode 100644 src/ScriptResolving/WASM/WebAssemblyScriptCapabilities.hpp
 create mode 100644 src/ScriptResolving/WASM/WebAssemblyScriptResolver.cpp
 create mode 100644 src/ScriptResolving/WASM/WebAssemblyScriptResolver.hpp
 rename tests/ScriptTests/{ => Angelscript}/BaseScriptClassTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ItemUseScriptTests.cpp (98%)
 rename tests/ScriptTests/{ => Angelscript}/MetadataTests.cpp (94%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptOwnerTest.cpp (98%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptResolverTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptTypeTests/Battle/BattleTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptTypeTests/Battle/PokemonTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptTypeTests/Library/FormesTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptTypeTests/Library/ItemDataTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptTypeTests/Library/MoveTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptTypeTests/Library/SpeciesTests.cpp (99%)
 rename tests/ScriptTests/{ => Angelscript}/ScriptTypeTests/Library/StaticLibraryTests.cpp (99%)
 create mode 100644 tests/ScriptTests/WASM/ScriptResolverTests.cpp
 create mode 100755 tests/ScriptTests/WASM/gen7_scripts_rs.wasm

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9c3bd16..6c84d85 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -73,10 +73,15 @@ if (SCRIPT_PROVIDER STREQUAL "angelscript")
                 WORKING_DIRECTORY ${Angelscript_SOURCE_DIR}/angelscript/projects/cmake)
     endif ()
 
-    include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
     include_directories(${Angelscript_SOURCE_DIR}/angelscript/include)
     include_directories(${Angelscript_SOURCE_DIR}/add_on)
+elseif (SCRIPT_PROVIDER STREQUAL "wasm")
+    message(STATUS "Installing wasmer")
+    execute_process(COMMAND bash -c "curl https://get.wasmer.io -sSfL | WASMER_INSTALL_LOG=0 sh")
+    include_directories($ENV{WASMER_DIR}/include)
 endif ()
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
+
 
 if (WINDOWS)
     SET(CMAKE_SYSTEM_NAME Windows)
@@ -160,13 +165,19 @@ if (SCRIPT_PROVIDER STREQUAL "angelscript")
         set(_TESTLINKS ${_TESTLINKS} AngelscriptDebugger)
     endif ()
     ADD_DEFINITIONS(-D AS_USE_ACCESSORS=1)
+elseif(SCRIPT_PROVIDER STREQUAL "wasm")
+    SET(FILE_SOURCE ${FILE_SOURCE}
+            "src/ScriptResolving/WASM/*.cpp"
+            "src/ScriptResolving/WASM/*.hpp")
+    # FIXME: Add C Interface
 endif ()
 
 file(GLOB_RECURSE CORE_SRC_FILES ${FILE_SOURCE})
 add_library(pkmnLib ${LIBTYPE} ${CORE_SRC_FILES})
 # Enable all warnings, and make them error when occurring.
 target_compile_options(pkmnLib PRIVATE -Wall -Wextra -Werror -pedantic-errors)
-target_link_directories(pkmnLib PUBLIC ${Angelscript_BINARY_DIR})
+
+
 
 # If interprocedural optimization is available, apply it
 check_ipo_supported(RESULT IPO_SUPPORTED)
@@ -180,12 +191,21 @@ SET(_TESTLINKS ${_TESTLINKS} pkmnLib CreatureLib Arbutils)
 
 if (SCRIPT_PROVIDER STREQUAL "angelscript")
     message(STATUS "Using Angelscript as script provider.")
+    target_link_directories(pkmnLib PUBLIC ${Angelscript_BINARY_DIR})
+
     ADD_DEFINITIONS(-D ANGELSCRIPT=1)
     SET(_LINKS ${_LINKS} angelscript)
     SET(_TESTLINKS ${_TESTLINKS} angelscript)
     if (ANGELSCRIPT_DEBUGGER)
         ADD_DEFINITIONS(-D ANGELSCRIPT_DEBUGGER=1)
     endif ()
+elseif (SCRIPT_PROVIDER STREQUAL "wasm")
+    message(STATUS "Using WebAssembly as script provider.")
+    target_link_directories(pkmnLib PUBLIC $ENV{WASMER_DIR}/lib)
+    message($ENV{WASMER_DIR}/lib)
+    ADD_DEFINITIONS(-D WASM=1)
+    SET(_LINKS ${_LINKS} -Wl,-Bstatic wasmer -Wl,-Bdynamic)
+    SET(_TESTLINKS ${_TESTLINKS} -Wl,-Bstatic wasmer -Wl,-Bdynamic)
 endif ()
 
 # If we are building for Windows we need to set some specific variables.
@@ -245,6 +265,8 @@ if (PKMNLIB_TESTS)
     endif ()
 endif ()
 
-if (ANGELSCRIPT_DEBUGGER)
-    include_directories(extern/AngelscriptDebuggerServer/extern/asio-1.18.2/include)
-endif ()
+if (SCRIPT_PROVIDER STREQUAL "angelscript")
+    if (ANGELSCRIPT_DEBUGGER)
+        include_directories(extern/AngelscriptDebuggerServer/extern/asio-1.18.2/include)
+    endif ()
+endif()
\ No newline at end of file
diff --git a/sanitizer_ignores b/sanitizer_ignores
new file mode 100644
index 0000000..3a73069
--- /dev/null
+++ b/sanitizer_ignores
@@ -0,0 +1 @@
+src:*/std_function.h
\ No newline at end of file
diff --git a/src/Battling/Library/ScriptResolver.hpp b/src/Battling/Library/ScriptResolver.hpp
index 9a966dd..696bfbc 100644
--- a/src/Battling/Library/ScriptResolver.hpp
+++ b/src/Battling/Library/ScriptResolver.hpp
@@ -1,6 +1,7 @@
 #ifndef PKMNLIB_SCRIPTRESOLVER_HPP
 #define PKMNLIB_SCRIPTRESOLVER_HPP
 
+#include <CreatureLib/Battling/ScriptHandling/ScriptResolver.hpp>
 #include "../EvolutionScript.hpp"
 
 namespace PkmnLib::Battling {
diff --git a/src/Library/Moves/MoveLibrary.hpp b/src/Library/Moves/MoveLibrary.hpp
index 0343f40..4e4a770 100644
--- a/src/Library/Moves/MoveLibrary.hpp
+++ b/src/Library/Moves/MoveLibrary.hpp
@@ -18,9 +18,19 @@ namespace PkmnLib::Library {
                 return {};
             return res.value().ForceAs<const MoveData>();
         }
+        inline std::optional<ArbUt::BorrowedPtr<const MoveData>> TryGet(u32 hash) const {
+            auto res = CreatureLib::Library::AttackLibrary::TryGet(hash);
+            if (!res.has_value())
+                return {};
+            return res.value().ForceAs<const MoveData>();
+        }
+
         inline ArbUt::BorrowedPtr<const MoveData> Get(const ArbUt::BasicStringView& name) const {
             return CreatureLib::Library::AttackLibrary::Get(name).As<const MoveData>();
         }
+        inline ArbUt::BorrowedPtr<const MoveData> Get(u32 hash) const {
+            return CreatureLib::Library::AttackLibrary::Get(hash).As<const MoveData>();
+        }
     };
 }
 
diff --git a/src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.cpp b/src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.cpp
new file mode 100644
index 0000000..edef7e6
--- /dev/null
+++ b/src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.cpp
@@ -0,0 +1,86 @@
+#include "CoreMethods.hpp"
+#include <cstring>
+#include "../WebAssemblyScriptResolver.hpp"
+#include "WasmHelperFile.hpp"
+#include "wasm.h"
+
+wasm_func_t* CreateErrorFunc(wasm_store_t* store, WebAssemblyScriptResolver* resolver) {
+    // This is probably the most horrific function we need to expose. As we do not want the scripting library to be
+    // responsible for string formatting for size reasons, we pass a lot of data separately. This includes several
+    // strings.
+    return WasmHelpers::CreateFunc<void, i32, i32, i32, i32, i32, i32>(
+        store, resolver, [](void* env, const wasm_val_vec_t* args, wasm_val_vec_t*) -> wasm_trap_t* {
+            auto msg = args->data[0].of.i32;
+            auto msg_len = args->data[1].of.i32;
+            auto file = args->data[2].of.i32;
+            auto file_len = args->data[3].of.i32;
+            auto line = args->data[4].of.i32;
+            auto position = args->data[5].of.i32;
+
+            auto* resolver = (WebAssemblyScriptResolver*)env;
+            auto* msgPointer = wasm_memory_data(resolver->GetMemory()) + msg;
+            auto* filePointer = wasm_memory_data(resolver->GetMemory()) + file;
+
+            auto msgString = std::string_view(msgPointer, msg_len);
+            auto fileString = std::string_view(filePointer, file_len);
+
+            std::stringstream fullMessage;
+            fullMessage << "WASM Error with message: " << msgString << std::endl
+                        << "in file: " << fileString << ". Line: " << line << ":" << position;
+
+            wasm_message_t message;
+            wasm_name_new_from_string_nt(&message, fullMessage.str().c_str());
+            wasm_trap_t* trap = wasm_trap_new(resolver->GetStore(), &message);
+            wasm_name_delete(&message);
+            return trap;
+        });
+}
+
+wasm_func_t* CreatePrintFunc(wasm_store_t* store, WebAssemblyScriptResolver* resolver) {
+    return WasmHelpers::CreateFunc<void, i32, i32>(
+        store, resolver, [](void* env, const wasm_val_vec_t* args, wasm_val_vec_t*) -> wasm_trap_t* {
+            auto msg = args->data[0].of.i32;
+            auto msg_len = args->data[1].of.i32;
+            auto resolver = (WebAssemblyScriptResolver*)env;
+            auto* msgPointer = wasm_memory_data(resolver->GetMemory()) + msg;
+            auto msgString = std::string_view(msgPointer, msg_len);
+            std::cout << msgString << std::endl;
+            return nullptr;
+        });
+    ;
+}
+
+wasm_func_t* ConstString_GetHash(wasm_store_t* store, WebAssemblyScriptResolver* resolver) {
+    return WasmHelpers::CreateFunc2<u32, const ArbUt::StringView*>(
+        store, resolver,
+        std::function<u32(WebAssemblyScriptResolver*, const ArbUt::StringView*)>(
+            [](WebAssemblyScriptResolver*, const ArbUt::StringView* sv) -> u32 { return sv->GetHash(); }));
+}
+
+wasm_func_t* ConstString_GetStr(wasm_store_t* store, WebAssemblyScriptResolver* resolver) {
+    return WasmHelpers::CreateFunc<i32, const ArbUt::StringView*>(
+        store, resolver, [](void* env, const wasm_val_vec_t* args, wasm_val_vec_t* returns) -> wasm_trap_t* {
+            auto resolver = (WebAssemblyScriptResolver*)env;
+            auto& constString = *(ArbUt::StringView*)args->data[0].of.i64;
+
+            // To allow webassembly to access the C String, we need to allocate it inside it's memory.
+            // Length + 1 to make room for the '\0'
+            auto stringPointer = resolver->AllocateMemory(constString.Length() + 1, std::alignment_of<const char>());
+
+            // After we have the pointer to the memory allocated for the string, copy the string with specified length
+            // to it, then suffix it with the null byte to end it.
+            strncpy(reinterpret_cast<char*>(stringPointer.first), constString.c_str(), constString.Length());
+            stringPointer.first[constString.Length()] = '\0';
+
+            returns->data[0] = WASM_I32_VAL(stringPointer.second);
+            return nullptr;
+        });
+}
+
+void WebAssemblyCoreMethods::Register(wasm_store_t* store, ArbUt::Dictionary<std::string, wasm_func_t*>& externs,
+                                      WebAssemblyScriptResolver* resolver) {
+    externs.Insert("_error", CreateErrorFunc(store, resolver));
+    externs.Insert("_print", CreatePrintFunc(store, resolver));
+    externs.Insert("arbutils_const_string_get_hash", ConstString_GetHash(store, resolver));
+    externs.Insert("arbutils_const_string_get_str", ConstString_GetStr(store, resolver));
+}
diff --git a/src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.hpp b/src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.hpp
new file mode 100644
index 0000000..0bf9bf6
--- /dev/null
+++ b/src/ScriptResolving/WASM/InterfaceMethods/CoreMethods.hpp
@@ -0,0 +1,14 @@
+#ifndef PKMNLIB_COREMETHODS_HPP
+#define PKMNLIB_COREMETHODS_HPP
+
+#include <Arbutils/Collections/Dictionary.hpp>
+#include <wasm.h>
+
+class WebAssemblyScriptResolver;
+class WebAssemblyCoreMethods {
+public:
+    static void Register(wasm_store_t* store, ArbUt::Dictionary<std::string, wasm_func_t*>& externs,
+                         WebAssemblyScriptResolver* resolver);
+};
+
+#endif // PKMNLIB_COREMETHODS_HPP
diff --git a/src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.cpp b/src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.cpp
new file mode 100644
index 0000000..58c7cec
--- /dev/null
+++ b/src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.cpp
@@ -0,0 +1,39 @@
+#include "LibraryMethods.hpp"
+#include <type_traits>
+#include "../../../../Battling/Library/BattleLibrary.hpp"
+#include "../../WebAssemblyScriptResolver.hpp"
+#include "../WasmHelperFile.hpp"
+#include "wasm.h"
+
+wasm_func_t* MoveLibrary_GetMoveByHash(wasm_store_t* store) {
+    wasm_functype_t* type =
+        wasm_functype_new_2_1(wasm_valtype_new_i64(), wasm_valtype_new_i32(), wasm_valtype_new_i64());
+    auto* f = wasm_func_new(store, type, [](const wasm_val_vec_t* args, wasm_val_vec_t* returns) -> wasm_trap_t* {
+        auto moveLibrary = (PkmnLib::Library::MoveLibrary*)args->data[0].of.i64;
+        auto hash = (u32)args->data[1].of.i32;
+        auto opt = moveLibrary->TryGet(hash);
+        if (!opt.has_value()) {
+           returns->data[0] = WASM_I64_VAL(0);
+        } else{
+            returns->data[0] = WASM_I64_VAL(reinterpret_cast<i64>(moveLibrary->Get(hash).GetRaw()));
+        }
+        return nullptr;
+    });
+    wasm_functype_delete(type);
+    return f;
+}
+
+void LibraryMethods::Register(wasm_store_t* store, ArbUt::Dictionary<std::string, wasm_func_t*>& externs,
+                              WebAssemblyScriptResolver* resolver) {
+    REGISTER_GETTER("battling_battle_library_get_data_library", PkmnLib::Battling::BattleLibrary, GetStaticLib, store,
+                    resolver);
+    REGISTER_GETTER("library_data_library_get_move_library", PkmnLib::Library::PokemonLibrary, GetMoveLibrary, store,
+                    resolver);
+    externs.Insert("library_move_library_get_move_by_hash", MoveLibrary_GetMoveByHash(store));
+
+    REGISTER_GETTER("library_move_data_get_base_power", CreatureLib::Library::AttackData, GetBasePower, store,
+                    resolver);
+
+    REGISTER_GETTER("library_move_data_get_name", CreatureLib::Library::AttackData, GetName, store,
+                    resolver);
+}
diff --git a/src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.hpp b/src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.hpp
new file mode 100644
index 0000000..6220258
--- /dev/null
+++ b/src/ScriptResolving/WASM/InterfaceMethods/Library/LibraryMethods.hpp
@@ -0,0 +1,13 @@
+#ifndef PKMNLIB_LIBRARYMETHODS_H
+#define PKMNLIB_LIBRARYMETHODS_H
+#include <Arbutils/Collections/Dictionary.hpp>
+#include <wasm.h>
+
+class WebAssemblyScriptResolver;
+class LibraryMethods {
+public:
+    static void Register(wasm_store_t* store, ArbUt::Dictionary<std::string, wasm_func_t*>& externs,
+                         WebAssemblyScriptResolver* resolver);
+};
+
+#endif // PKMNLIB_LIBRARYMETHODS_H
diff --git a/src/ScriptResolving/WASM/InterfaceMethods/WasmHelperFile.hpp b/src/ScriptResolving/WASM/InterfaceMethods/WasmHelperFile.hpp
new file mode 100644
index 0000000..d3f7653
--- /dev/null
+++ b/src/ScriptResolving/WASM/InterfaceMethods/WasmHelperFile.hpp
@@ -0,0 +1,197 @@
+#ifndef PKMNLIB_HELPERFILE_H
+#define PKMNLIB_HELPERFILE_H
+#include <Arbutils/Memory/Memory.hpp>
+#include <memory>
+#include <sstream>
+#include <type_traits>
+#include <wasm.h>
+#include "../WebAssemblyScriptResolver.hpp"
+#include "wasm.h"
+
+template <typename Test, template <typename...> class Ref> struct is_specialization : std::false_type {};
+template <template <typename...> class Ref, typename... Args>
+struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
+template <template <typename...> class Ref, typename... Args>
+struct is_specialization<const Ref<Args...>&, Ref> : std::true_type {};
+template <template <typename...> class Ref, typename... Args>
+struct is_specialization<Ref<Args...>&, Ref> : std::true_type {};
+
+struct WasmHelpers {
+public:
+    static wasm_trap_t* CreateTrapFromException(const ArbUt::Exception& e, const WebAssemblyScriptResolver* resolver) {
+        std::stringstream ss;
+        ss << e.what() << std::endl;
+        ss << e.GetStacktrace() << std::endl;
+
+        wasm_message_t message;
+        wasm_name_new_from_string_nt(&message, ss.str().c_str());
+        wasm_trap_t* trap = wasm_trap_new(resolver->GetStore(), &message);
+        wasm_name_delete(&message);
+        return trap;
+    }
+
+    static wasm_trap_t* FromStdException(const std::exception& e, const WebAssemblyScriptResolver* resolver) {
+        wasm_message_t message;
+        wasm_name_new_from_string_nt(&message, e.what());
+        wasm_trap_t* trap = wasm_trap_new(resolver->GetStore(), &message);
+        wasm_name_delete(&message);
+        return trap;
+    }
+
+    template <typename T, typename R, R (T::*Method)() const>
+    static wasm_func_t* RegisterGetter(wasm_store_t* store, WebAssemblyScriptResolver* resolver) {
+        wasm_functype_t* type = wasm_functype_new_1_1(wasm_valtype_new_i64(), GetValType<R>());
+        auto* f = wasm_func_new_with_env(
+            store, type,
+            [](void* env, const wasm_val_vec_t* args, wasm_val_vec_t* returns) -> wasm_trap_t* {
+                try {
+                    auto obj = (const T*)args->data[0].of.i64;
+                    returns->data[0] = ToVal<R>((obj->*Method)());
+                } catch (ArbUt::Exception& e) {
+                    return CreateTrapFromException(e, (WebAssemblyScriptResolver*)env);
+                } catch (std::exception& e) {
+                    return FromStdException(e, (WebAssemblyScriptResolver*)env);
+                }
+                return nullptr;
+            },
+            resolver, nullptr);
+        wasm_functype_delete(type);
+        return f;
+    }
+
+    template <class R, class... Args>
+    static wasm_func_t* CreateFunc(wasm_store_t* store, WebAssemblyScriptResolver* resolver,
+                                   wasm_func_callback_with_env_t func) {
+        auto funcType = GetFuncType<R, Args...>();
+        auto* f = wasm_func_new_with_env(store, funcType, func, resolver, nullptr);
+        wasm_functype_delete(funcType);
+        return f;
+    }
+
+    template <typename T>
+    inline static T ConvertAllArguments(const wasm_val_vec_t* t, std::size_t& index,
+                                        WebAssemblyScriptResolver* resolver) {
+        return FromVal<T>(t->data[index++], resolver);
+    }
+
+    template <class R, class... Args>
+    static wasm_func_t* CreateFunc2(wasm_store_t* store, WebAssemblyScriptResolver* resolver,
+                                    std::function<R(WebAssemblyScriptResolver*, Args...)> func) {
+        auto funcType = GetFuncType<R, Args...>();
+        struct Env {
+            WebAssemblyScriptResolver* Resolver;
+            std::function<R(WebAssemblyScriptResolver*, Args...)> Func;
+            __attribute__((no_sanitize("address")))
+            ~Env(){}
+        };
+
+        auto env = new Env{.Resolver = resolver, .Func = func};
+        auto* f = wasm_func_new_with_env(
+            store, funcType,
+            [](void* env, const wasm_val_vec_t* parameters, wasm_val_vec_t* results) -> wasm_trap_t* {
+                auto e = *(Env*)env;
+                size_t index = 0;
+                R result = e.Func(e.Resolver, ConvertAllArguments<Args>(parameters, index, e.Resolver)...);
+                results->data[0] = ToVal<R>(result);
+                return nullptr;
+            },
+            env,
+            [](void* env) __attribute__((no_sanitize("address"))) {
+                delete (Env*)env;
+            }
+            );
+        wasm_functype_delete(funcType);
+        return f;
+    }
+
+private:
+    template <class T> inline static wasm_valtype_t* GetValType() {
+        if constexpr (std::is_pointer<T>() || is_specialization<T, ArbUt::BorrowedPtr>::value ||
+                      is_specialization<T, ArbUt::OptionalBorrowedPtr>::value ||
+                      is_specialization<T, std::unique_ptr>::value) {
+            return wasm_valtype_new_i64();
+        } else if constexpr (std::is_enum<T>() || std::is_integral<T>()) {
+            if constexpr (sizeof(T) > 4) {
+                return wasm_valtype_new_i64();
+            } else {
+                return wasm_valtype_new_i32();
+            }
+        } else if constexpr (std::is_same<T, const ArbUt::StringView&>()) {
+            return wasm_valtype_new_i64();
+        }
+        THROW("Unhandled value type: ", typeid(T).name());
+    }
+
+    template <typename T> inline static wasm_val_t ToVal(const T& val) {
+        if constexpr (std::is_pointer<T>()) {
+            return WASM_I64_VAL(reinterpret_cast<i64>(val));
+        } else if constexpr (is_specialization<T, ArbUt::BorrowedPtr>::value) {
+            return WASM_I64_VAL(reinterpret_cast<i64>(val.GetRaw()));
+        } else if constexpr (is_specialization<T, ArbUt::OptionalBorrowedPtr>::value) {
+            return WASM_I64_VAL(reinterpret_cast<i64>(val.GetRaw()));
+        } else if constexpr (is_specialization<T, std::unique_ptr>::value) {
+            return WASM_I64_VAL(reinterpret_cast<i64>(val.get()));
+        } else if constexpr (std::is_enum<T>() || std::is_integral<T>()) {
+            if constexpr (sizeof(T) > 4) {
+                return WASM_I64_VAL((i64)val);
+            } else {
+                return WASM_I32_VAL((i32)val);
+            }
+        } else if constexpr (std::is_same<T, const ArbUt::StringView&>()) {
+            return WASM_I64_VAL(reinterpret_cast<i64>(&val));
+        }
+        THROW("Unhandled value type: ", typeid(T).name());
+    }
+
+    template <typename T> inline static T FromVal(const wasm_val_t& val, WebAssemblyScriptResolver* resolver) {
+        if constexpr (std::is_pointer<T>()) {
+            auto v = reinterpret_cast<void*>(val.of.i64);
+            Ensure(resolver->ValidateLoadedPointer<std::remove_pointer<T>>(v));
+            return (T)v;
+        } else if constexpr (is_specialization<T, ArbUt::BorrowedPtr>::value) {
+            return dynamic_cast<T>(reinterpret_cast<void*>(val.of.i64));
+        } else if constexpr (is_specialization<T, ArbUt::OptionalBorrowedPtr>::value) {
+            return dynamic_cast<T>(reinterpret_cast<void*>(val.of.i64));
+        } else if constexpr (is_specialization<T, std::unique_ptr>::value) {
+            return dynamic_cast<T>(reinterpret_cast<void*>(val.of.i64));
+        } else if constexpr (std::is_enum<T>() || std::is_integral<T>()) {
+            if constexpr (sizeof(T) > 4) {
+                return reinterpret_cast<T>(val.of.i64);
+            } else {
+                return reinterpret_cast<T>(val.of.i32);
+            }
+        }
+        THROW("Unhandled value type: ", typeid(T).name());
+    }
+
+    template <size_t I, class... Args> inline static void AppendArgument(wasm_valtype_t* array[]) {
+        using type = typename std::tuple_element<I, std::tuple<Args...>>::type;
+        array[I] = GetValType<type>();
+        if constexpr (I + 1 < sizeof...(Args)) {
+            AppendArgument<I + 1, Args...>(array);
+        }
+    }
+
+    template <class R, class... Args> static wasm_functype_t* GetFuncType() {
+        wasm_valtype_t* ps[sizeof...(Args)];
+        AppendArgument<0, Args...>(ps);
+
+        wasm_valtype_vec_t params, results;
+        if constexpr (std::is_void<R>()) {
+            results = WASM_EMPTY_VEC;
+        } else {
+            wasm_valtype_t* rs[1] = {GetValType<R>()};
+            wasm_valtype_vec_new(&results, 1, rs);
+        }
+        wasm_valtype_vec_new(&params, sizeof...(Args), ps);
+        return wasm_functype_new(&params, &results);
+    }
+};
+
+#define REGISTER_GETTER(name, cType, cFunc, store, resolver)                                                           \
+    externs.Insert(                                                                                                    \
+        name,                                                                                                          \
+        WasmHelpers::RegisterGetter<cType, std::result_of<decltype (&cType::cFunc)(cType)>::type, &cType::cFunc>(      \
+            store, resolver));
+
+#endif // PKMNLIB_HELPERFILE_H
diff --git a/src/ScriptResolving/WASM/WasmExternRef.hpp b/src/ScriptResolving/WASM/WasmExternRef.hpp
new file mode 100644
index 0000000..9e0fa23
--- /dev/null
+++ b/src/ScriptResolving/WASM/WasmExternRef.hpp
@@ -0,0 +1,13 @@
+#ifndef PKMNLIB_WASMEXTERNREF_HPP
+#define PKMNLIB_WASMEXTERNREF_HPP
+
+template <class T> class WasmExternRef {
+public:
+    WasmExternRef(T* ptr) : _ptr(ptr) {}
+
+    [[nodiscard]] inline T* GetPtr() const noexcept { return _ptr; }
+private:
+    T* _ptr;
+};
+
+#endif // PKMNLIB_WASMEXTERNREF_HPP
diff --git a/src/ScriptResolving/WASM/WebAssemblyBattleScript.cpp b/src/ScriptResolving/WASM/WebAssemblyBattleScript.cpp
new file mode 100644
index 0000000..faa276e
--- /dev/null
+++ b/src/ScriptResolving/WASM/WebAssemblyBattleScript.cpp
@@ -0,0 +1,40 @@
+#include "WebAssemblyBattleScript.hpp"
+#include "WebAssemblyFunctionCall.hpp"
+#include "WebAssemblyScriptResolver.hpp"
+
+WebAssemblyBattleScript::~WebAssemblyBattleScript() {
+    // Ensure the WebAssembly library can clear up its own junk
+    auto funcOpt = _resolver->GetFunction<1, 0>("destroy_script");
+    if (funcOpt.has_value()) {
+        auto& func = funcOpt.value();
+        func.Loadi32(0, _wasmPtr);
+        func.Call();
+    }
+    // Remove the backwards lookup to this script.
+    _resolver->RemoveRegisteredScript(_wasmPtr);
+}
+
+#define WASM_CALL(capability, script_name, args_count, return_count, parameter_setup)                                  \
+    if (!HasCapability(WebAssemblyScriptCapabilities::capability)) {                                                   \
+        return;                                                                                                        \
+    }                                                                                                                  \
+    auto funcOpt = _resolver->GetFunction<args_count, return_count>(script_name);                                      \
+    if (!funcOpt.has_value()) {                                                                                        \
+        return;                                                                                                        \
+    }                                                                                                                  \
+    auto& func = funcOpt.value();                                                                                       \
+    parameter_setup;                                                                                                   \
+    func.Call();
+
+void WebAssemblyBattleScript::OnInitialize(const CreatureLib::Battling::BattleLibrary* library,
+                                           const ArbUt::List<CreatureLib::Library::EffectParameter*>&) {
+    WASM_CALL(Initialize, "script_on_initialize", 2, 0, {
+        func.Loadi32(0, _wasmPtr);
+        func.LoadExternRef(1, library);
+    });
+}
+
+CreatureLib::Battling::BattleScript* WebAssemblyBattleScript::Clone(const ArbUt::OptionalBorrowedPtr<void>&) {
+    // FIXME: Implement
+    return nullptr;
+}
diff --git a/src/ScriptResolving/WASM/WebAssemblyBattleScript.hpp b/src/ScriptResolving/WASM/WebAssemblyBattleScript.hpp
new file mode 100644
index 0000000..d0df986
--- /dev/null
+++ b/src/ScriptResolving/WASM/WebAssemblyBattleScript.hpp
@@ -0,0 +1,35 @@
+#ifndef PKMNLIB_WEBASSEMBLYBATTLESCRIPT_H
+#define PKMNLIB_WEBASSEMBLYBATTLESCRIPT_H
+
+#include "../../Battling/PkmnScript.hpp"
+#include "WebAssemblyScriptCapabilities.hpp"
+
+class WebAssemblyScriptResolver;
+class WebAssemblyBattleScript : public PkmnLib::Battling::PkmnScript {
+public:
+    WebAssemblyBattleScript(const ArbUt::OptionalBorrowedPtr<void>& owner, i32 wasm_ptr,
+                            const std::unordered_set<WebAssemblyScriptCapabilities>* capabilities,
+                            WebAssemblyScriptResolver* resolver, const ArbUt::StringView& scriptName)
+        : PkmnScript(owner), _resolver(resolver), _wasmPtr(wasm_ptr), _capabilities(capabilities),
+          _scriptName(scriptName) {}
+    ~WebAssemblyBattleScript();
+
+    BattleScript* Clone(const ArbUt::OptionalBorrowedPtr<void>& owner) non_null override;
+    const ArbUt::StringView& GetName() const noexcept override { return _scriptName; }
+
+public:
+    void OnInitialize(const CreatureLib::Battling::BattleLibrary* library,
+                      const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters) override;
+
+private:
+    [[nodiscard]] inline bool HasCapability(WebAssemblyScriptCapabilities capability) const noexcept {
+        return _capabilities->contains(capability);
+    }
+
+    WebAssemblyScriptResolver* _resolver;
+    i32 _wasmPtr;
+    const std::unordered_set<WebAssemblyScriptCapabilities>* _capabilities;
+    ArbUt::StringView _scriptName;
+};
+
+#endif // PKMNLIB_WEBASSEMBLYBATTLESCRIPT_H
diff --git a/src/ScriptResolving/WASM/WebAssemblyFunctionCall.hpp b/src/ScriptResolving/WASM/WebAssemblyFunctionCall.hpp
new file mode 100644
index 0000000..9b4c30c
--- /dev/null
+++ b/src/ScriptResolving/WASM/WebAssemblyFunctionCall.hpp
@@ -0,0 +1,107 @@
+#ifndef PKMNLIB_WEBASSEMBLYFUNCTIONCALL_H
+#define PKMNLIB_WEBASSEMBLYFUNCTIONCALL_H
+
+#include <Arbutils/Collections/List.hpp>
+#include <Arbutils/Memory/Memory.hpp>
+#include <wasm.h>
+#include "wasm.h"
+
+template <u32 argsCount, u32 returnsCount>
+class WebAssemblyFunctionCall {
+public:
+    WebAssemblyFunctionCall(const ArbUt::BorrowedPtr<wasm_func_t>& func) : _func(func) {}
+
+    NO_COPY_OR_MOVE(WebAssemblyFunctionCall)
+
+    void Call() {
+        wasm_val_vec_t args = {argsCount, _arguments.Data};
+
+        wasm_val_vec_t results;
+        if constexpr (returnsCount > 0) {
+            results = {returnsCount, _results.Data};
+        } else {
+            results = WASM_EMPTY_VEC;
+        }
+
+        auto* result = wasm_func_call(_func, &args, &results);
+        if (result != nullptr) {
+            wasm_message_t retrieved_message;
+            wasm_trap_message(result, &retrieved_message);
+            auto msg = std::string(retrieved_message.data, retrieved_message.size);
+            THROW(msg);
+        }
+    }
+
+    inline void Loadi32(size_t index, i32 value) { _arguments.Data[index] = WASM_I32_VAL(value); }
+    inline void Loadi64(size_t index, i64 value) { _arguments.Data[index] = WASM_I64_VAL(value); }
+    inline void Loadf32(size_t index, f32 value) { _arguments.Data[index] = WASM_F32_VAL(value); }
+    inline void Loadf64(size_t index, f64 value) { _arguments.Data[index] = WASM_F64_VAL(value); }
+
+    template <class T> inline void LoadExternRef(size_t index, T* value) {
+        _arguments.Data[index] = WASM_I64_VAL(reinterpret_cast<i64>(value));
+    }
+
+    [[nodiscard]] inline i32 GetResultAsi32() const {
+        if constexpr (returnsCount > 0) {
+            Ensure(_results.Data[0].kind == WASM_I32);
+            return _results.Data[0].of.i32;
+        } else {
+            return 0;
+        }
+    }
+    [[nodiscard]] inline i64 GetResultAsi64() const {
+        if constexpr (returnsCount > 0) {
+            Ensure(_results.Data[0].kind == WASM_I64);
+            return _results.Data[0].of.i64;
+        } else {
+            return 0;
+        }
+    }
+    [[nodiscard]] inline f32 GetResultAsf32() const {
+        if constexpr (returnsCount > 0) {
+            Ensure(_results.Data[0].kind == WASM_F32);
+            return _results.Data[0].of.f32;
+        } else {
+            return 0;
+        }
+    }
+    [[nodiscard]] inline f64 GetResultAsf64() const {
+        if constexpr (returnsCount > 0) {
+            Ensure(_results.Data[0].kind == WASM_F64);
+            return _results.Data[0].of.f64;
+        } else {
+            return 0;
+        }
+    }
+
+    template <class T> [[nodiscard]] inline T* GetResultAsExternRef() const {
+        if constexpr (returnsCount > 0) {
+            Ensure(_results.Data[0].kind == WASM_ANYREF);
+            return reinterpret_cast<T*>(_results.Data[0].of.i64);
+        } else {
+            return 0;
+        }
+    }
+
+    inline const wasm_val_t* GetRawResults() const {
+        if constexpr (returnsCount > 0) {
+            return _results.Data;
+        } else {
+            return 0;
+        }
+    }
+
+private:
+    ArbUt::BorrowedPtr<wasm_func_t> _func;
+
+    struct Empty {};
+    template <u32 size> struct NonEmpty { wasm_val_t Data[size]; };
+
+    typedef typename std::conditional<argsCount == 0, Empty, NonEmpty<argsCount>>::type args_t;
+    typedef typename std::conditional<returnsCount == 0, Empty, NonEmpty<returnsCount>>::type result_t;
+
+    args_t _arguments;
+    result_t _results;
+};
+
+#endif // PKMNLIB_WEBASSEMBLYFUNCTIONCALL_H
diff --git a/src/ScriptResolving/WASM/WebAssemblyScriptCapabilities.hpp b/src/ScriptResolving/WASM/WebAssemblyScriptCapabilities.hpp
new file mode 100644
index 0000000..a30dc66
--- /dev/null
+++ b/src/ScriptResolving/WASM/WebAssemblyScriptCapabilities.hpp
@@ -0,0 +1,63 @@
+#ifndef PKMNLIB_WEBASSEMBLYSCRIPTCAPABILITIES_H
+#define PKMNLIB_WEBASSEMBLYSCRIPTCAPABILITIES_H
+
+enum class WebAssemblyScriptCapabilities : u8 {
+    None = 0,
+    Initialize = 1,
+    OnStack,
+    OnRemove,
+    OnBeforeTurn,
+    ChangeAttack,
+    ModifyNumberOfHits,
+    PreventAttack,
+    FailAttack,
+    StopBeforeAttack,
+    OnBeforeAttack,
+    FailIncomingAttack,
+    IsInvulnerable,
+    OnAttackMiss,
+    ChangeAttackType,
+    ChangeEffectiveness,
+    BlockCritical,
+    OnIncomingHit,
+    OnFaintingOpponent,
+    PreventStatBoostChange,
+    ModifyStatBoostChange,
+    PreventSecondaryEffects,
+    OnSecondaryEffect,
+    OnAfterHits,
+    PreventSelfSwitch,
+    ModifyEffectChance,
+    ModifyIncomingEffectChance,
+    OverrideBasePower,
+    ChangeDamageStatsUser,
+    BypassDefensiveStat,
+    BypassOffensiveStat,
+    ModifyStatModifier,
+    ModifyDamageModifier,
+    OverrideDamage,
+    OverrideIncomingDamage,
+    ChangeSpeed,
+    ChangePriority,
+    OnFail,
+    OnOpponentFail,
+    PreventRunAway,
+    PreventOpponentRunAway,
+    PreventOpponentSwitch,
+    OnEndTurn,
+    OnDamage,
+    OnFaint,
+    OnAfterHeldItemConsume,
+    PreventIncomingCritical,
+    ModifyCriticalStage,
+    OverrideCriticalModifier,
+    OverrideSTABModifier,
+    ModifyExperienceGain,
+    DoesShareExperience,
+    BlockWeather,
+    OnSwitchIn,
+    ModifyOffensiveStatValue,
+    ModifyDefensiveStatValue,
+};
+
+#endif // PKMNLIB_WEBASSEMBLYSCRIPTCAPABILITIES_H
diff --git a/src/ScriptResolving/WASM/WebAssemblyScriptResolver.cpp b/src/ScriptResolving/WASM/WebAssemblyScriptResolver.cpp
new file mode 100644
index 0000000..6836678
--- /dev/null
+++ b/src/ScriptResolving/WASM/WebAssemblyScriptResolver.cpp
@@ -0,0 +1,175 @@
+#include "WebAssemblyScriptResolver.hpp"
+#include <iostream>
+#include <unordered_map>
+#include <wasmer.h>
+#include "InterfaceMethods/CoreMethods.hpp"
+#include "InterfaceMethods/Library/LibraryMethods.hpp"
+#include "WebAssemblyBattleScript.hpp"
+#include "WebAssemblyFunctionCall.hpp"
+#include "wasm.h"
+
+PkmnLib::Battling::ScriptResolver* PkmnLib::Battling::BattleLibrary::CreateScriptResolver() {
+    return new WebAssemblyScriptResolver();
+}
+WebAssemblyScriptResolver::WebAssemblyScriptResolver() : _engine(wasm_engine_new()), _store(wasm_store_new(_engine)) {}
+
+WebAssemblyScriptResolver::~WebAssemblyScriptResolver() {
+    wasm_extern_vec_delete(&_exports);
+    for (auto& import : _imports) {
+        wasm_func_delete(import.second);
+    }
+    if (_instance != nullptr) {
+        wasm_instance_delete(_instance);
+    }
+    if (_module != nullptr) {
+        wasm_module_delete(_module);
+    }
+    wasm_store_delete(_store);
+    wasm_engine_delete(_engine);
+}
+
+u8 WebAssemblyScriptResolver::LoadWasmFromFile(const std::string& path) {
+    auto file = fopen(path.c_str(), "rb");
+    if (!file) {
+        return 1;
+    }
+    fseek(file, 0L, SEEK_END);
+    size_t file_size = ftell(file);
+    fseek(file, 0L, SEEK_SET);
+    wasm_byte_vec_t wasm_bytes;
+    wasm_byte_vec_new_uninitialized(&wasm_bytes, file_size);
+    if (fread(wasm_bytes.data, file_size, 1, file) != 1) {
+        wasm_byte_vec_delete(&wasm_bytes);
+        return 2;
+    }
+    fclose(file);
+    _module = wasm_module_new(_store, &wasm_bytes);
+    if (_module == nullptr) {
+        wasm_byte_vec_delete(&wasm_bytes);
+        return 3;
+    }
+    wasm_byte_vec_delete(&wasm_bytes);
+    return 0;
+}
+
+u8 WebAssemblyScriptResolver::LoadWasmFromBytes(std::vector<u8> wasm_bytes) {
+    wasm_byte_vec_t data = {wasm_bytes.size(), (char*)wasm_bytes.data()};
+    _module = wasm_module_new(_store, &data);
+    if (_module == nullptr) {
+        return 3;
+    }
+    return 0;
+}
+
+u8 WebAssemblyScriptResolver::LoadWatFromString(const std::string& data) {
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, data.size(), data.c_str());
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+    _module = wasm_module_new(_store, &wasm_bytes);
+    if (_module == nullptr) {
+        return 3;
+    }
+    wasm_byte_vec_delete(&wasm_bytes);
+    return 0;
+}
+
+void WebAssemblyScriptResolver::RegisterFunction() {}
+
+void WebAssemblyScriptResolver::RegisterDefaultMethods() {
+    WebAssemblyCoreMethods::Register(_store, _imports, this);
+    LibraryMethods::Register(_store, _imports, this);
+}
+
+void WebAssemblyScriptResolver::Finalize() {
+    RegisterDefaultMethods();
+    auto imports = ArbUt::List<wasm_extern_t*>();
+
+    wasm_importtype_vec_t import_types;
+    wasm_module_imports(_module, &import_types);
+    for (size_t i = 0; i < import_types.size; ++i) {
+        auto importType = import_types.data[i];
+        auto nameWasm = wasm_importtype_name(importType);
+        auto name = std::string(nameWasm->data, nameWasm->size);
+        auto exportFunc = _imports.TryGet(name);
+        if (!exportFunc.has_value()) {
+            THROW("Missing imported WASM function: ", name);
+        }
+        imports.Append(wasm_func_as_extern(exportFunc.value()));
+    }
+
+    wasm_extern_vec_t import_object = {imports.Count(), const_cast<wasm_extern_t**>(imports.RawData())};
+
+    wasm_trap_t* trap = nullptr;
+    _instance = wasm_instance_new(_store, _module, &import_object, &trap);
+    wasm_importtype_vec_delete(&import_types);
+    if (_instance == nullptr) {
+        char* err = new char[wasmer_last_error_length()];
+        wasmer_last_error_message(err, wasmer_last_error_length());
+        std::cout << err << std::endl;
+        delete[] err;
+    }
+
+    EnsureNotNull(_instance);
+
+    wasm_exporttype_vec_t export_types;
+    wasm_module_exports(_module, &export_types);
+    wasm_instance_exports(_instance, &_exports);
+    for (size_t i = 0; i < export_types.size; ++i) {
+        auto t = wasm_externtype_kind(wasm_exporttype_type(export_types.data[i]));
+        if (t == WASM_EXTERN_FUNC) {
+            const auto* name = wasm_exporttype_name(export_types.data[i]);
+
+            _exportedFunctions.Insert(ArbUt::StringView(name->data, name->size), wasm_extern_as_func(_exports.data[i]));
+        } else if (t == WASM_EXTERN_MEMORY) {
+            _memory = wasm_extern_as_memory(_exports.data[i]);
+        }
+    }
+    wasm_exporttype_vec_delete(&export_types);
+    if (_memory != nullptr) {
+        wasm_memory_grow(_memory, 100);
+    }
+}
+
+CreatureLib::Battling::BattleScript*
+WebAssemblyScriptResolver::LoadScript(const ArbUt::OptionalBorrowedPtr<void>& owner, ScriptCategory category,
+                                      const ArbUt::StringView& scriptName) {
+    auto loadScriptOpt = GetFunction<2, 1>("load_script"_cnc);
+    if (!loadScriptOpt.has_value()) {
+        return nullptr;
+    }
+    auto& loadScriptFunc = loadScriptOpt.value();
+    loadScriptFunc.Loadi32(0, static_cast<i32>(category));
+    loadScriptFunc.LoadExternRef(1, &scriptName);
+    loadScriptFunc.Call();
+    auto result = loadScriptFunc.GetResultAsi32();
+    if (result == 0) {
+        return nullptr;
+    }
+    auto key = std::pair<ScriptCategory, ArbUt::StringView>(category, scriptName);
+    auto findCapabilities = _scriptCapabilities.find(key);
+    std::unordered_set<WebAssemblyScriptCapabilities> capabilities;
+    if (findCapabilities != _scriptCapabilities.end()) {
+        capabilities = findCapabilities->second;
+    } else {
+        auto getCapabilitiesOpt = GetFunction<1,2>("get_script_capabilities"_cnc);
+        if (getCapabilitiesOpt.has_value()) {
+            auto& getCapabilitiesFunc = getCapabilitiesOpt.value();
+            getCapabilitiesFunc.Loadi32(0, result);
+            getCapabilitiesFunc.Call();
+            const auto* rawResult = getCapabilitiesFunc.GetRawResults();
+            auto ptr = (WebAssemblyScriptCapabilities*)(wasm_memory_data(_memory) + rawResult[0].of.i32);
+            auto end = (WebAssemblyScriptCapabilities*)(ptr + rawResult[1].of.i32);
+            auto vec = std::vector<WebAssemblyScriptCapabilities>(ptr, end);
+            for (auto capability: vec){
+                capabilities.insert(capability);
+            }
+        }
+        _scriptCapabilities[key] = capabilities;
+    }
+
+    auto script = new WebAssemblyBattleScript(owner, result, &_scriptCapabilities[key], this, scriptName);
+    _loadedScripts.Insert(result, script);
+    return script;
+}
diff --git a/src/ScriptResolving/WASM/WebAssemblyScriptResolver.hpp b/src/ScriptResolving/WASM/WebAssemblyScriptResolver.hpp
new file mode 100644
index 0000000..03c516b
--- /dev/null
+++ b/src/ScriptResolving/WASM/WebAssemblyScriptResolver.hpp
@@ -0,0 +1,92 @@
+#ifndef PKMNLIB_WEBASSEMBLYSCRIPTRESOLVER_HPP
+#define PKMNLIB_WEBASSEMBLYSCRIPTRESOLVER_HPP
+
+#include <Arbutils/Collections/Dictionary.hpp>
+#include <optional>
+#include <utility>
+#include <wasm.h>
+#include "../../Battling/Library/ScriptResolver.hpp"
+#include "WebAssemblyBattleScript.hpp"
+#include "WebAssemblyFunctionCall.hpp"
+#include "WebAssemblyScriptCapabilities.hpp"
+
+class WebAssemblyScriptResolver : public PkmnLib::Battling::ScriptResolver {
+public:
+    WebAssemblyScriptResolver();
+    ~WebAssemblyScriptResolver();
+
+    u8 LoadWasmFromFile(const std::string& path);
+    u8 LoadWasmFromBytes(std::vector<u8>);
+    u8 LoadWatFromString(const std::string& data);
+    void RegisterFunction();
+    void Finalize();
+
+    template <u32 argsCount, u32 returnsCount>
+    inline std::optional<WebAssemblyFunctionCall<argsCount, returnsCount>>
+    GetFunction(const ArbUt::StringView& name) const {
+        auto res = _exportedFunctions.TryGet(name);
+        if (!res.has_value()) {
+            return {};
+        }
+        return std::make_optional<WebAssemblyFunctionCall<argsCount, returnsCount>>(
+            ArbUt::BorrowedPtr<wasm_func_t>(res.value()));
+    }
+
+    std::pair<u8*, i32> AllocateMemory(u32 size, u32 align) const {
+        auto funcOpt = GetFunction<2, 1>("allocate_mem");
+        auto& func = funcOpt.value();
+        func.Loadi32(0, size);
+        func.Loadi32(1, align);
+        func.Call();
+        auto memoryOffset = func.GetResultAsi32();
+        return std::make_pair(reinterpret_cast<u8*>(wasm_memory_data(_memory) + memoryOffset), memoryOffset);
+    }
+
+    [[nodiscard]] inline wasm_memory_t* GetMemory() const noexcept { return _memory; }
+
+    CreatureLib::Battling::BattleScript* LoadScript(const ArbUt::OptionalBorrowedPtr<void>& owner,
+                                                    ScriptCategory category,
+                                                    const ArbUt::StringView& scriptName) nullable override;
+
+    [[nodiscard]] inline wasm_store_t* GetStore() const noexcept { return _store; }
+
+    inline void RemoveRegisteredScript(i32 wasmPtr) { _loadedScripts.Remove(wasmPtr); }
+
+    template <typename T>
+    inline void MarkLoadedPointer(T* ptr){
+        _loadedPointers.Set((void*)ptr, typeid(T));
+    }
+
+    template <typename T>
+    inline bool ValidateLoadedPointer(void* ptr){
+        const auto& opt = _loadedPointers.TryGet(ptr);
+        return opt.has_value() && opt.value() == typeid(T);
+    }
+
+private:
+    wasm_engine_t* _engine;
+    wasm_store_t* _store;
+    wasm_module_t* _module = nullptr;
+    wasm_instance_t* _instance = nullptr;
+    wasm_memory_t* _memory = nullptr;
+    ArbUt::Dictionary<std::string, wasm_func_t*> _imports;
+    wasm_extern_vec_t _exports = {0, nullptr};
+    ArbUt::Dictionary<ArbUt::StringView, wasm_func_t*> _exportedFunctions;
+    ArbUt::Dictionary<i32, WebAssemblyBattleScript*> _loadedScripts;
+
+    void RegisterDefaultMethods();
+
+    typedef std::pair<ScriptCategory, ArbUt::StringView> scriptCapabilitiesKey;
+
+    struct pair_hash {
+        template <class T1, class T2> std::size_t operator()(const std::pair<T1, T2>& pair) const {
+            return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
+        }
+    };
+    std::unordered_map<scriptCapabilitiesKey, std::unordered_set<WebAssemblyScriptCapabilities>, pair_hash>
+        _scriptCapabilities;
+
+    ArbUt::Dictionary<void*, std::type_info> _loadedPointers;
+};
+
+#endif // PKMNLIB_WEBASSEMBLYSCRIPTRESOLVER_HPP
diff --git a/tests/LibraryTests/SpeciesLibraryTests.cpp b/tests/LibraryTests/SpeciesLibraryTests.cpp
index 02df443..4e467a6 100644
--- a/tests/LibraryTests/SpeciesLibraryTests.cpp
+++ b/tests/LibraryTests/SpeciesLibraryTests.cpp
@@ -8,4 +8,9 @@ TEST_CASE("Able to build and destroy empty library") {
     delete lib;
 }
 
+
+REGISTER_EXCEPTION_TRANSLATOR(ArbUt::Exception& ex) {
+    return {(std::string(ex.what()) + "\n" + ex.GetStacktrace()).c_str()};
+}
+
 #endif
\ No newline at end of file
diff --git a/tests/ScriptTests/BaseScriptClassTests.cpp b/tests/ScriptTests/Angelscript/BaseScriptClassTests.cpp
similarity index 99%
rename from tests/ScriptTests/BaseScriptClassTests.cpp
rename to tests/ScriptTests/Angelscript/BaseScriptClassTests.cpp
index 7436f1d..6c35259 100644
--- a/tests/ScriptTests/BaseScriptClassTests.cpp
+++ b/tests/ScriptTests/Angelscript/BaseScriptClassTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../src/Battling/Pokemon/CreatePokemon.hpp"
 #include "../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
diff --git a/tests/ScriptTests/ItemUseScriptTests.cpp b/tests/ScriptTests/Angelscript/ItemUseScriptTests.cpp
similarity index 98%
rename from tests/ScriptTests/ItemUseScriptTests.cpp
rename to tests/ScriptTests/Angelscript/ItemUseScriptTests.cpp
index fff8022..73bc834 100644
--- a/tests/ScriptTests/ItemUseScriptTests.cpp
+++ b/tests/ScriptTests/Angelscript/ItemUseScriptTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../src/Battling/Pokemon/CreatePokemon.hpp"
 #include "../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
diff --git a/tests/ScriptTests/MetadataTests.cpp b/tests/ScriptTests/Angelscript/MetadataTests.cpp
similarity index 94%
rename from tests/ScriptTests/MetadataTests.cpp
rename to tests/ScriptTests/Angelscript/MetadataTests.cpp
index 01d6bcf..84247b7 100644
--- a/tests/ScriptTests/MetadataTests.cpp
+++ b/tests/ScriptTests/Angelscript/MetadataTests.cpp
@@ -1,7 +1,7 @@
 #ifdef TESTS_BUILD
-#include <Arbutils/StringView.hpp>
-#include <doctest.h>
-#include "../../src/ScriptResolving/AngelScript/AngelScriptMetadata.hpp"
+#include "../../../src/ScriptResolving/AngelScript/AngelScriptMetadata.hpp"
+#include "Arbutils/StringView.hpp"
+#include "doctest.h"
 
 TEST_CASE("Metadata without parameters") {
     auto m = AngelscriptMetadata("Foo");
diff --git a/tests/ScriptTests/ScriptOwnerTest.cpp b/tests/ScriptTests/Angelscript/ScriptOwnerTest.cpp
similarity index 98%
rename from tests/ScriptTests/ScriptOwnerTest.cpp
rename to tests/ScriptTests/Angelscript/ScriptOwnerTest.cpp
index f4a1596..2cea1c3 100644
--- a/tests/ScriptTests/ScriptOwnerTest.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptOwnerTest.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../src/Battling/Pokemon/CreatePokemon.hpp"
 #include "../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
diff --git a/tests/ScriptTests/ScriptResolverTests.cpp b/tests/ScriptTests/Angelscript/ScriptResolverTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptResolverTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptResolverTests.cpp
index aec388d..e908e63 100644
--- a/tests/ScriptTests/ScriptResolverTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptResolverTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD && ANGELSCRIPT
 #include <doctest.h>
 #include "../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
 #include "../../src/ScriptResolving/AngelScript/ContextPool.hpp"
diff --git a/tests/ScriptTests/ScriptTypeTests/Battle/BattleTests.cpp b/tests/ScriptTests/Angelscript/ScriptTypeTests/Battle/BattleTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptTypeTests/Battle/BattleTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptTypeTests/Battle/BattleTests.cpp
index 0c1cc92..1351cb2 100644
--- a/tests/ScriptTests/ScriptTypeTests/Battle/BattleTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptTypeTests/Battle/BattleTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../../../src/Battling/Battle/Battle.hpp"
 #include "../../../../src/Battling/Pokemon/CreatePokemon.hpp"
diff --git a/tests/ScriptTests/ScriptTypeTests/Battle/PokemonTests.cpp b/tests/ScriptTests/Angelscript/ScriptTypeTests/Battle/PokemonTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptTypeTests/Battle/PokemonTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptTypeTests/Battle/PokemonTests.cpp
index b7092ca..50973ab 100644
--- a/tests/ScriptTests/ScriptTypeTests/Battle/PokemonTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptTypeTests/Battle/PokemonTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../../../src/Battling/Pokemon/CreatePokemon.hpp"
 #include "../../../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
diff --git a/tests/ScriptTests/ScriptTypeTests/Library/FormesTests.cpp b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/FormesTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptTypeTests/Library/FormesTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptTypeTests/Library/FormesTests.cpp
index a2eb936..158fc40 100644
--- a/tests/ScriptTests/ScriptTypeTests/Library/FormesTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/FormesTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
 #include "../../../../src/ScriptResolving/AngelScript/ContextPool.hpp"
diff --git a/tests/ScriptTests/ScriptTypeTests/Library/ItemDataTests.cpp b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/ItemDataTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptTypeTests/Library/ItemDataTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptTypeTests/Library/ItemDataTests.cpp
index 21f1323..9bef743 100644
--- a/tests/ScriptTests/ScriptTypeTests/Library/ItemDataTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/ItemDataTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
 #include "../../../../src/ScriptResolving/AngelScript/ContextPool.hpp"
diff --git a/tests/ScriptTests/ScriptTypeTests/Library/MoveTests.cpp b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/MoveTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptTypeTests/Library/MoveTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptTypeTests/Library/MoveTests.cpp
index 8f023d3..4c0f8dd 100644
--- a/tests/ScriptTests/ScriptTypeTests/Library/MoveTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/MoveTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
 #include "../../../../src/ScriptResolving/AngelScript/ContextPool.hpp"
diff --git a/tests/ScriptTests/ScriptTypeTests/Library/SpeciesTests.cpp b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/SpeciesTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptTypeTests/Library/SpeciesTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptTypeTests/Library/SpeciesTests.cpp
index a449356..1fc7cb6 100644
--- a/tests/ScriptTests/ScriptTypeTests/Library/SpeciesTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/SpeciesTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD && ANGELSCRIPT
 #include <doctest.h>
 #include "../../../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
 #include "../../../../src/ScriptResolving/AngelScript/ContextPool.hpp"
diff --git a/tests/ScriptTests/ScriptTypeTests/Library/StaticLibraryTests.cpp b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/StaticLibraryTests.cpp
similarity index 99%
rename from tests/ScriptTests/ScriptTypeTests/Library/StaticLibraryTests.cpp
rename to tests/ScriptTests/Angelscript/ScriptTypeTests/Library/StaticLibraryTests.cpp
index 3d2c0cb..63a2234 100644
--- a/tests/ScriptTests/ScriptTypeTests/Library/StaticLibraryTests.cpp
+++ b/tests/ScriptTests/Angelscript/ScriptTypeTests/Library/StaticLibraryTests.cpp
@@ -1,4 +1,4 @@
-#ifdef TESTS_BUILD
+#if TESTS_BUILD and ANGELSCRIPT
 #include <doctest.h>
 #include "../../../../src/ScriptResolving/AngelScript/AngelScriptResolver.hpp"
 #include "../../../../src/ScriptResolving/AngelScript/ContextPool.hpp"
diff --git a/tests/ScriptTests/WASM/ScriptResolverTests.cpp b/tests/ScriptTests/WASM/ScriptResolverTests.cpp
new file mode 100644
index 0000000..9f0b140
--- /dev/null
+++ b/tests/ScriptTests/WASM/ScriptResolverTests.cpp
@@ -0,0 +1,63 @@
+#if TESTS_BUILD && WASM
+#include <doctest.h>
+#include "../../TestLibrary/TestLibrary.hpp"
+#include "../../src/ScriptResolving/WASM/WebAssemblyFunctionCall.hpp"
+#include "../../src/ScriptResolving/WASM/WebAssemblyScriptResolver.hpp"
+
+TEST_CASE("Get a script resolver, initialize it, then delete it") {
+    auto lib = PkmnLib::Battling::BattleLibrary::CreateScriptResolver();
+    lib->Initialize(TestLibrary::GetLibrary());
+    delete lib;
+}
+
+TEST_CASE("Get a script resolver, load simple wat, run function") {
+    auto lib = dynamic_cast<WebAssemblyScriptResolver*>(PkmnLib::Battling::BattleLibrary::CreateScriptResolver());
+    lib->Initialize(TestLibrary::GetLibrary());
+    auto res = lib->LoadWatFromString(R"(
+(module
+    (type $add_one_t (func (param i32) (result i32)))
+    (func $add_one_f (type $add_one_t) (param $value i32) (result i32)
+        local.get $value
+        i32.const 1
+        i32.add)
+    (export "add_one" (func $add_one_f))
+)
+)");
+    REQUIRE_EQ(0, res);
+    lib->Finalize();
+    auto func_opt = lib->GetFunction<1, 1>("add_one");
+    REQUIRE(func_opt.has_value());
+    auto& func = func_opt.value();
+    func.Loadi32(0, 684);
+    func.Call();
+    REQUIRE_EQ(func.GetResultAsi32(), 685);
+    delete lib;
+}
+
+TEST_CASE("Get a script resolver, load a real wasm script") {
+    auto lib = dynamic_cast<WebAssemblyScriptResolver*>(PkmnLib::Battling::BattleLibrary::CreateScriptResolver());
+    lib->Initialize(TestLibrary::GetLibrary());
+    std::string file_path = __FILE__;
+    std::string dir_path = file_path.substr(0, file_path.rfind("/"));
+    auto res = lib->LoadWasmFromFile(dir_path + "/gen7_scripts_rs.wasm");
+    REQUIRE_EQ(0, res);
+    lib->Finalize();
+    delete lib;
+}
+
+TEST_CASE("Get a script resolver, load a real wasm script, load test script") {
+    ArbUt::ScopedPtr<WebAssemblyScriptResolver> lib =
+        dynamic_cast<WebAssemblyScriptResolver*>(PkmnLib::Battling::BattleLibrary::CreateScriptResolver());
+    lib->Initialize(TestLibrary::GetLibrary());
+    std::string file_path = __FILE__;
+    std::string dir_path = file_path.substr(0, file_path.rfind("/"));
+    auto res = lib->LoadWasmFromFile(dir_path + "/gen7_scripts_rs.wasm");
+    REQUIRE_EQ(0, res);
+    lib->Finalize();
+    auto script = lib->LoadScript(nullptr, ScriptCategory::Attack, "test"_cnc);
+    EnsureNotNull(script);
+    script->OnInitialize(TestLibrary::GetLibrary(), {});
+    delete script;
+}
+
+#endif
diff --git a/tests/ScriptTests/WASM/gen7_scripts_rs.wasm b/tests/ScriptTests/WASM/gen7_scripts_rs.wasm
new file mode 100755
index 0000000000000000000000000000000000000000..fce3ea377084603dc56ed5f696da1a4ee25f31e2
GIT binary patch
literal 28705
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

literal 0
HcmV?d00001