Add host functions that have to run on the tick and futures (#8)

* Add rust crate

* Add futures

* Add redstone functions

* Update rust crate

Author: TheBlckbird

.gitignore

@@ -25,4 +25,4 @@ run-data
 
 repo
 
-.DS_Store
+.DS_Store

rustedcomputer-rs/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+target/

rustedcomputer-rs/Cargo.lock

@@ -0,0 +1,12 @@
+[package]
+name = "rustedcomputer"
+version = "0.1.0"
+edition = "2024"
+license = "MPL-2.0"
+description = "Programmable Computers in Minecraft with WebAssembly"
+homepage = "https://github.com/TheBlckbird/rustedcomputer"
+repository = "https://github.com/TheBlckbird/rustedcomputer"
+readme = "Readme.md"
+
+[dependencies]
+thiserror = "2.0.16"

rustedcomputer-rs/Cargo.toml

@@ -0,0 +1,3 @@
+# Rusted Computer
+
+This is a reserved crate. It will later be the wrapper crate for [github.com/TheBlckbird/rustedcomputer](https://github.com/TheBlckbird/rustedcomputer).

rustedcomputer-rs/Readme.md

@@ -0,0 +1,23 @@
+use std::ops::{Deref, DerefMut};
+
+pub struct FutureId(i32);
+
+impl From<i32> for FutureId {
+    fn from(value: i32) -> Self {
+        Self(value)
+    }
+}
+
+impl Deref for FutureId {
+    type Target = i32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for FutureId {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

rustedcomputer-rs/src/async_runtime/future_id.rs

@@ -0,0 +1,95 @@
+use std::pin::Pin;
+use std::{ptr, slice, thread};
+use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+use std::time::Duration;
+use crate::async_runtime::future_id::FutureId;
+use crate::error::{Result, RustedComputerError};
+
+pub mod future_id;
+
+pub struct RustedComputerFuture<T, F>
+where
+    F: Fn(String) -> T,
+{
+    pub id: FutureId,
+    pub converter: F,
+}
+
+impl<T, F> RustedComputerFuture<T, F>
+where
+    F: Fn(String) -> T,
+{
+    pub fn new<G>(caller: G, converter: F) -> Self
+    where
+        G: Fn() -> FutureId,
+    {
+        let id = caller();
+        Self { id, converter }
+    }
+}
+
+impl<T, F> Future for RustedComputerFuture<T, F>
+where
+    F: Fn(String) -> T,
+{
+    type Output = Result<T>;
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let poll_result = unsafe { poll(*self.id) };
+
+        let length = (poll_result & 0xFFFFFFFF) as usize;
+        let pointer = (poll_result >> 32) as *mut u8;
+
+        let slice = unsafe { slice::from_raw_parts_mut(pointer, length) };
+        let boxed_slice = unsafe { Box::from_raw(slice) };
+        let future = str::from_utf8(&boxed_slice).unwrap();
+
+        if future == "P" {
+            Poll::Pending
+        } else if future == "F" {
+            Poll::Ready(Err(RustedComputerError::FutureFailed))
+        } else if future.starts_with("S") {
+            let future_result = future[1..].to_owned();
+            let converted_result = (self.converter)(future_result);
+
+            Poll::Ready(Ok(converted_result))
+        } else {
+            unreachable!()
+        }
+    }
+}
+
+fn noop_raw_waker() -> RawWaker {
+    fn clone(_: *const ()) -> RawWaker {
+        noop_raw_waker()
+    }
+    fn no_op(_: *const ()) {}
+
+    static VTABLE: RawWakerVTable = RawWakerVTable::new(clone, no_op, no_op, no_op);
+    RawWaker::new(ptr::null(), &VTABLE)
+}
+
+fn noop_waker() -> Waker {
+    unsafe { Waker::from_raw(noop_raw_waker()) }
+}
+
+pub fn block_on<F: Future>(mut future: F) -> F::Output {
+    let mut future = unsafe { Pin::new_unchecked(&mut future) };
+    let waker = noop_waker();
+    let mut cx = Context::from_waker(&waker);
+
+    loop {
+        match future.as_mut().poll(&mut cx) {
+            Poll::Ready(val) => return val,
+            Poll::Pending => {
+                thread::sleep(Duration::from_millis(100));
+            }
+        }
+    }
+}
+
+#[link(wasm_import_module = "future")]
+unsafe extern "C" {
+    #[link_name = "poll"]
+    pub fn poll(future_id: i32) -> i64;
+}

rustedcomputer-rs/src/async_runtime/mod.rs

@@ -0,0 +1,11 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum RustedComputerError {
+    #[error("Future failed to resolve")]
+    FutureFailed,
+    #[error("Future had a timeout")]
+    FutureTimeout,
+}
+
+pub type Result<T, E = RustedComputerError> = std::result::Result<T, E>;

rustedcomputer-rs/src/error.rs

@@ -0,0 +1 @@
+pub mod redstone;

rustedcomputer-rs/src/functions/mod.rs

@@ -0,0 +1,34 @@
+use crate::async_runtime::RustedComputerFuture;
+use crate::error::Result;
+use crate::side::Side;
+
+pub async fn set_output(side: Side, power: u8) -> Result<()> {
+    let side = side.to_string();
+    let side_length = side.len() as i32;
+    let side_offset = side.as_ptr() as i32;
+
+    let caller = || unsafe { ext_set_output(side_length, side_offset, power as i32) }.into();
+    let converter = |_| ();
+
+    RustedComputerFuture::new(caller, converter).await
+}
+
+pub async fn get_input(side: Side) -> Result<u8> {
+    let side = side.to_string();
+    let side_length = side.len() as i32;
+    let side_offset = side.as_ptr() as i32;
+
+    let caller = || unsafe { ext_get_input(side_length, side_offset) }.into();
+    let converter = |value: String| value.parse().unwrap();
+
+    RustedComputerFuture::new(caller, converter).await
+}
+
+#[link(wasm_import_module = "redstone")]
+unsafe extern "C" {
+    #[link_name = "set_output"]
+    fn ext_set_output(side_length: i32, side_offset: i32, power: i32) -> i32;
+
+    #[link_name = "get_input"]
+    fn ext_get_input(side_length: i32, side_offset: i32) -> i32;
+}