Game Scripting Engine with Rust and WASM

pub struct Memory;

impl Memory {
    /// Calls `__new` to allocate a garbage-collected object, returns a pointer
    pub fn allocate_heap(caller: &mut Caller<'_, ScriptStore>, size: usize, class_id: u32) -> i32 {
        let new = match caller.get_export("__new") {
            Some(Extern::Func(func)) => func
                .typed::<(i32, i32), i32>(&caller)
                .expect("Invalid __new signature"),
            _ => panic!("Function `__new` not found"),
        };

        new.call(caller, (size as i32, class_id as i32)).unwrap()
    }

    /// Writes `bytes` directly to memory starting at `offset`
    pub fn write_bytes_at(caller: &mut Caller<'_, ScriptStore>, bytes: &[u8], offset: i32) {
        let memory = caller.get_export("memory").unwrap().into_memory().unwrap();
        memory
            .write(caller, offset as usize, bytes)
            .expect("Failed to write bytes to memory");
    }

    /// Similar to `allocate_heap`, but here we can pass a struct directly to reserve the needed space for it
    pub fn allocate_heap_object<T: NoUninit + AnyBitPattern + std::fmt::Debug>(
        caller: &mut Caller<'_, ScriptStore>,
        obj: T,
    ) -> i32 {
        let bytes = bytemuck::bytes_of(&obj);
        let ptr = Self::allocate_heap(caller, bytes.len(), 0);
        Self::write_bytes_at(caller, bytes, ptr);
        ptr
    }

    /// Reads an object starting at `ptr`
    pub fn read<T: AnyBitPattern>(caller: &mut Caller<'_, ScriptStore>, ptr: i32) -> T {
        let obj_size = std::mem::size_of::<T>();
        let bytes = Self::read_bytes(caller, ptr, obj_size);

        bytemuck::from_bytes::<T>(&bytes).to_owned()
    }

    /// Reads a specific number of bytes starting at `ptr`
    pub fn read_bytes(caller: &mut Caller<'_, ScriptStore>, ptr: i32, bytes: usize) -> Vec<u8> {
        let memory = caller.get_export("memory").unwrap().into_memory().unwrap();
        let mut bytes = vec![0; bytes];
        memory.read(caller, ptr as _, &mut bytes).unwrap();
        bytes
    }

    /// Allocates memory and writes a string to it, returns the pointer to the string
    pub fn write_string<S: AsRef<str>>(
        caller: &mut Caller<'_, ScriptStore>,
        str: S,
    ) -> wasmtime::Result<i32> {
        let str = str.as_ref();
        let utf16_message: Vec<u16> = str.encode_utf16().collect();

        // Multiply by 2 because each letter occupies two spaces
        let length = utf16_message.len() * 2;

        let pointer = Memory::allocate_heap(caller, length, 2);

        // Write the string length (in UTF-16 code units) at -4 bytes
        // This is because of the memory layout of a string in AssemblyScript
        // https://www.assemblyscript.org/runtime.html#memory-layout
        Self::write_bytes_at(caller, &length.to_le_bytes(), pointer - 4);

        // Write the UTF-16 string data into memory
        for (i, &word) in utf16_message.iter().enumerate() {
            Self::write_bytes_at(caller, &word.to_le_bytes(), pointer + (i as i32 * 2));
        }

        Ok(pointer)
    }

    /// Reads a string from memory located at `ptr`
    pub fn read_string(caller: &mut Caller<'_, ScriptStore>, ptr: i32) -> wasmtime::Result<String> {
        let length = Self::read::<i32>(caller, ptr - 4);
        let str_bytes = Self::read_bytes(caller, ptr, length as usize)
            .into_iter()
            .filter(|b| *b != 0)
            .collect();

        Ok(String::from_utf8(str_bytes)?)
    }
}