release stuff

.vsls.json

@@ -0,0 +1 @@
+{"gitignore":"none"}

README.md

@@ -3,19 +3,43 @@
 ## Wuts this?
 Wasm runtime is a mod that executes webassembly modules within minecraft using wasmtime
 
+## Current supported platforms
+Since wasmtime is written in rust, to use it, I have to write a native library in rust, which I have to compile to specific platforms.
+
+* Windows
+* Linux*
+* Mac**
+
+<sub>*only tested on ubuntu</sub>
+<br />
+<sub>**Compiled for Intel x86_64</sub>
+
 ## Stuff to do
 ### Minecraft API
-Idk, I'll just do whatever seems useful here, I'll probably just copy scarpet
+Idk, I'll just do whatever seems useful here, I'll probably just copy scarpet...
 ### Other APIs
 1. Web requests
 2. Terminal commands?
 3. File system
 
-## API ideas
+## Future API ideas
 Spawning items
 Creating loot tables to spawn items from (good for those videos that are like "manhunt but thingy drops op loot")
 Some sort of equivalent to Javascript's `e.preventDefault()`
 Manipulating nbt is definitely a must have
 
 ## How to use
-idk yet this mod doesn't work rn
+Put your .wasm files in the wasm folder in the config folder, then in game you can do /wasm load \<name\> to load the wasm module
+
+To automatically load wasm modules, in your world folder, open `wasm.json` and between the brackets add `"<name>"`, for example:
+
+```json
+[
+  "moduleName1",
+  "moduleName2",
+  "moduleName3"
+]
+```
+
+
+ps if you see weird comments in the source code blame matgenius04

src/main/java/wasmruntime/ModuleWrapper.java

@@ -2,65 +2,74 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardCopyOption;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
-import org.apache.commons.io.FilenameUtils;
-
 import wasmruntime.Enums.WasmType;
 import wasmruntime.Exceptions.WasmtimeException;
 import wasmruntime.Types.FuncType;
 import wasmruntime.Types.Value;
+import wasmruntime.Utils.DetectOS;
+import wasmruntime.Utils.NativeUtils;
 
 public class ModuleWrapper {
-  public static final String compileTo = "DEBUG";
+  public static final boolean debug = true;
   public String moduleName;
 
   private long InstanceID;
-
+  
   public Map<String, FuncType> exportedFunctions = new HashMap<String, FuncType>();
 
   public Map<String, WasmType> exportedGlobals = new HashMap<String, WasmType>();
 
+  // <name, default>
   public static Map<String, Value<?>> knownSettings = new HashMap<String, Value<?>>();
 
   static {
     try {
-      String fileName;
+      String fileName = "";
 
-      if (compileTo == "DEBUG") {
+      if (debug) {
+        // because I'm a window's simp
         fileName = "debug/Wasmtime_embedding.dll";
-      } else if (compileTo == "WINDOWS") {
-        fileName = "x86_64-pc-windows-gnu/release/Wasmtime_embedding.dll";
-      } else if (compileTo == "LINUX") {
-        fileName = "x86_64-unknown-linux-gnu/release/Wasmtime_embedding.so";
-      }
-
-      System.out.println(FilenameUtils.getPrefix(fileName));
-      Path tempFile = Files.createTempFile(FilenameUtils.removeExtension(fileName), FilenameUtils.getPrefix(fileName));
-      try (InputStream in = ModuleWrapper.class.getResourceAsStream('/' + fileName)) {
-        Files.copy(in, tempFile, StandardCopyOption.REPLACE_EXISTING);
+      } else {
+        // for some reason my naming conventions are all over the place
+        // but that's ok
+        // psssstt... DetectOS is some code that was copied from stackoverflow
+        // duh it has a stack overflow link -xendergo
+        switch (DetectOS.getOperatingSystemType()) {
+          case Windows:
+          fileName = "Wasmtime_embedding.dll";
+          break;
+
+          case MacOS:
+          fileName = "Wasmtime_embedding.dylib";
+          break;
+
+          case Linux:
+          fileName = "Wasmtime_embedding.so";
+          break;
+
+          default:
+          throw new RuntimeException("Your OS is unsupported right now");
+        }
       }
-
-      // URL res = ModuleWrapper.class.getClassLoader().getResource("Wasmtime-embedding/target/" + fileName);
-      // File file = Paths.get(res.toURI()).toFile();
-      System.load(tempFile.toAbsolutePath().toString());
+      // Uses the NativeUtils library because dependency's are hard?
+      NativeUtils.loadLibraryFromJar("/Wasmtime-embedding/target/"+fileName);
+      // Initializes the things?
       Init();
     } catch (WasmtimeException e) {
       throw new RuntimeException(e);
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
-
+    // Set's autoReload to false which is apparently the default value according to Xendergo
+    // this doesn't set anything this is literally just a default value -xendergo
     knownSettings.put("autoReload", Value.fromI32(0));
   }
-
+  // Wraps on a module like a day old piece of spaghettttt / Constructor sometimes I think
   public ModuleWrapper(File file, String name) throws IOException, WasmtimeException {
     moduleName = name;
     InstanceID = LoadModule(file.getAbsolutePath());
@@ -104,10 +113,12 @@ public void close() {
 
   private static native void UnloadModule(long InstancePtr);
 
+  // all functions in the module
   private static native Map<String, List<Byte>> Functions(long InstancePtr) throws WasmtimeException;
 
   private static native List<Value<?>> CallFunction(long InstancePtr, String name, List<Value<?>> params) throws WasmtimeException;
 
+  // all globals in the module
   private static native Map<String, Byte> Globals(long InstancePtr) throws WasmtimeException;
 
   private static native Value<?> GetGlobal(long InstancePtr, String name) throws WasmtimeException;

src/main/java/wasmruntime/Types/FuncType.java

@@ -5,6 +5,7 @@
 
 import wasmruntime.Enums.WasmType;
 
+// type signature of a wasm function -matgenius04
 public class FuncType {
   public WasmType[] inputs;
   public WasmType[] outputs;

src/main/java/wasmruntime/Utils/DetectOS.java

@@ -0,0 +1,45 @@
+package wasmruntime.Utils;
+
+/**
+ * helper class to check the operating system this Java VM runs in
+ *
+ * please keep the notes below as a pseudo-license
+ *
+ * http://stackoverflow.com/questions/228477/how-do-i-programmatically-determine-operating-system-in-java
+ * compare to http://svn.terracotta.org/svn/tc/dso/tags/2.6.4/code/base/common/src/com/tc/util/runtime/Os.java
+ * http://www.docjar.com/html/api/org/apache/commons/lang/SystemUtils.java.html
+ */
+import java.util.Locale;
+public final class DetectOS {
+  /**
+   * types of Operating Systems
+   */
+  public enum OSType {
+    Windows, MacOS, Linux, Other
+  };
+
+  // cached result of OS detection
+  protected static OSType detectedOS;
+
+  /**
+   * detect the operating system from the os.name System property and cache
+   * the result
+   * 
+   * @returns - the operating system detected
+   */
+  public static OSType getOperatingSystemType() {
+    if (detectedOS == null) {
+      String OS = System.getProperty("os.name", "generic").toLowerCase(Locale.ENGLISH);
+      if ((OS.indexOf("mac") >= 0) || (OS.indexOf("darwin") >= 0)) {
+        detectedOS = OSType.MacOS;
+      } else if (OS.indexOf("win") >= 0) {
+        detectedOS = OSType.Windows;
+      } else if (OS.indexOf("nux") >= 0) {
+        detectedOS = OSType.Linux;
+      } else {
+        detectedOS = OSType.Other;
+      }
+    }
+    return detectedOS;
+  }
+}

src/main/java/wasmruntime/Utils/NativeUtils.java

@@ -0,0 +1,119 @@
+package wasmruntime.Utils;
+
+import java.io.*;
+import java.nio.file.FileSystemNotFoundException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.ProviderNotFoundException;
+import java.nio.file.StandardCopyOption;
+
+/**
+ * A simple library class which helps with loading dynamic libraries stored in the
+ * JAR archive. These libraries usually contain implementation of some methods in
+ * native code (using JNI - Java Native Interface).
+ * 
+ * @see <a href="http://adamheinrich.com/blog/2012/how-to-load-native-jni-library-from-jar">http://adamheinrich.com/blog/2012/how-to-load-native-jni-library-from-jar</a>
+ * @see <a href="https://github.com/adamheinrich/native-utils">https://github.com/adamheinrich/native-utils</a>
+ *
+ */
+public class NativeUtils {
+
+    /**
+     * The minimum length a prefix for a file has to have according to {@link File#createTempFile(String, String)}}.
+     */
+    private static final int MIN_PREFIX_LENGTH = 3;
+    public static final String NATIVE_FOLDER_PATH_PREFIX = "nativeutils";
+
+    /**
+     * Temporary directory which will contain the DLLs.
+     */
+    private static File temporaryDir;
+
+    /**
+     * Private constructor - this class will never be instanced
+     */
+    private NativeUtils() {
+    }
+
+    /**
+     * Loads library from current JAR archive
+     * 
+     * The file from JAR is copied into system temporary directory and then loaded. The temporary file is deleted after
+     * exiting.
+     * Method uses String as filename because the pathname is "abstract", not system-dependent.
+     * 
+     * @param path The path of file inside JAR as absolute path (beginning with '/'), e.g. /package/File.ext
+     * @throws IOException If temporary file creation or read/write operation fails
+     * @throws IllegalArgumentException If source file (param path) does not exist
+     * @throws IllegalArgumentException If the path is not absolute or if the filename is shorter than three characters
+     * (restriction of {@link File#createTempFile(java.lang.String, java.lang.String)}).
+     * @throws FileNotFoundException If the file could not be found inside the JAR.
+     */
+    public static void loadLibraryFromJar(String path) throws IOException {
+
+        if (null == path || !path.startsWith("/")) {
+            throw new IllegalArgumentException("The path has to be absolute (start with '/').");
+        }
+
+        // Obtain filename from path
+        String[] parts = path.split("/");
+        String filename = (parts.length > 1) ? parts[parts.length - 1] : null;
+
+        // Check if the filename is okay
+        if (filename == null || filename.length() < MIN_PREFIX_LENGTH) {
+            throw new IllegalArgumentException("The filename has to be at least 3 characters long.");
+        }
+
+        // Prepare temporary file
+        if (temporaryDir == null) {
+            temporaryDir = createTempDirectory(NATIVE_FOLDER_PATH_PREFIX);
+            temporaryDir.deleteOnExit();
+        }
+
+        File temp = new File(temporaryDir, filename);
+
+        try (InputStream is = NativeUtils.class.getResourceAsStream(path)) {
+            Files.copy(is, temp.toPath(), StandardCopyOption.REPLACE_EXISTING);
+        } catch (IOException e) {
+            temp.delete();
+            throw e;
+        } catch (NullPointerException e) {
+            temp.delete();
+            throw new FileNotFoundException("File " + path + " was not found inside JAR.");
+        }
+
+        try {
+            System.load(temp.getAbsolutePath());
+        } finally {
+            if (isPosixCompliant()) {
+                // Assume POSIX compliant file system, can be deleted after loading
+                temp.delete();
+            } else {
+                // Assume non-POSIX, and don't delete until last file descriptor closed
+                temp.deleteOnExit();
+            }
+        }
+    }
+
+    private static boolean isPosixCompliant() {
+        try {
+            return FileSystems.getDefault()
+                    .supportedFileAttributeViews()
+                    .contains("posix");
+        } catch (FileSystemNotFoundException
+                | ProviderNotFoundException
+                | SecurityException e) {
+            return false;
+        }
+    }
+
+    private static File createTempDirectory(String prefix) throws IOException {
+        String tempDir = System.getProperty("java.io.tmpdir");
+        File generatedDir = new File(tempDir, prefix + System.nanoTime());
+
+        if (!generatedDir.mkdir())
+            throw new IOException("Failed to create temp directory " + generatedDir.getName());
+
+        return generatedDir;
+    }
+}