Communicate from game logic to graphics

please run the 'run'-script every time before loading the page

6 files changed, 212 insertions, 11 deletions

diff --git a/WebInterface/wasm/webhogg/graphics.js b/WebInterface/wasm/webhogg/graphics.js
index e4759e9..bafae3d 100644
--- a/WebInterface/wasm/webhogg/graphics.js
+++ b/WebInterface/wasm/webhogg/graphics.js
@@ -73,14 +73,177 @@ function game_logic_entry(worker) {
 __exports.game_logic_entry = game_logic_entry
 
 /**
-* @param {any} worker
 * @returns {void}
 */
-function graphics_entry(worker) {
-    return wasm.graphics_entry(addHeapObject(worker));
+function graphics_entry() {
+    return wasm.graphics_entry();
 }
 __exports.graphics_entry = graphics_entry
 
+function getObject(idx) { return heap[idx]; }
+
+let cachegetUint32Memory = null;
+function getUint32Memory() {
+    if (cachegetUint32Memory === null || cachegetUint32Memory.buffer !== wasm.memory.buffer) {
+        cachegetUint32Memory = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachegetUint32Memory;
+}
+
+function handleError(exnptr, e) {
+    const view = getUint32Memory();
+    view[exnptr / 4] = 1;
+    view[exnptr / 4 + 1] = addHeapObject(e);
+}
+
+function __widl_f_post_message_Worker(arg0, arg1, exnptr) {
+    try {
+        getObject(arg0).postMessage(getObject(arg1));
+    } catch (e) {
+        handleError(exnptr, e);
+    }
+}
+__exports.__widl_f_post_message_Worker = __widl_f_post_message_Worker
+
+function __wbindgen_string_new(p, l) { return addHeapObject(getStringFromWasm(p, l)); }
+__exports.__wbindgen_string_new = __wbindgen_string_new
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+let passStringToWasm;
+if (typeof cachedTextEncoder.encodeInto === 'function') {
+    passStringToWasm = function(arg) {
+
+
+        let size = arg.length;
+        let ptr = wasm.__wbindgen_malloc(size);
+        let offset = 0;
+        {
+            const mem = getUint8Memory();
+            for (; offset < arg.length; offset++) {
+                const code = arg.charCodeAt(offset);
+                if (code > 0x7F) break;
+                mem[ptr + offset] = code;
+            }
+        }
+
+        if (offset !== arg.length) {
+            arg = arg.slice(offset);
+            ptr = wasm.__wbindgen_realloc(ptr, size, size = offset + arg.length * 3);
+            const view = getUint8Memory().subarray(ptr + offset, ptr + size);
+            const ret = cachedTextEncoder.encodeInto(arg, view);
+
+            offset += ret.written;
+        }
+        WASM_VECTOR_LEN = offset;
+        return ptr;
+    };
+} else {
+    passStringToWasm = function(arg) {
+
+
+        let size = arg.length;
+        let ptr = wasm.__wbindgen_malloc(size);
+        let offset = 0;
+        {
+            const mem = getUint8Memory();
+            for (; offset < arg.length; offset++) {
+                const code = arg.charCodeAt(offset);
+                if (code > 0x7F) break;
+                mem[ptr + offset] = code;
+            }
+        }
+
+        if (offset !== arg.length) {
+            const buf = cachedTextEncoder.encode(arg.slice(offset));
+            ptr = wasm.__wbindgen_realloc(ptr, size, size = offset + buf.length);
+            getUint8Memory().set(buf, ptr + offset);
+            offset += buf.length;
+        }
+        WASM_VECTOR_LEN = offset;
+        return ptr;
+    };
+}
+
+function __wbindgen_debug_string(i, len_ptr) {
+    const debug_str =
+    val => {
+        // primitive types
+        const type = typeof val;
+        if (type == 'number' || type == 'boolean' || val == null) {
+            return  `${val}`;
+        }
+        if (type == 'string') {
+            return `"${val}"`;
+        }
+        if (type == 'symbol') {
+            const description = val.description;
+            if (description == null) {
+                return 'Symbol';
+            } else {
+                return `Symbol(${description})`;
+            }
+        }
+        if (type == 'function') {
+            const name = val.name;
+            if (typeof name == 'string' && name.length > 0) {
+                return `Function(${name})`;
+            } else {
+                return 'Function';
+            }
+        }
+        // objects
+        if (Array.isArray(val)) {
+            const length = val.length;
+            let debug = '[';
+            if (length > 0) {
+                debug += debug_str(val[0]);
+            }
+            for(let i = 1; i < length; i++) {
+                debug += ', ' + debug_str(val[i]);
+            }
+            debug += ']';
+            return debug;
+        }
+        // Test for built-in
+        const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+        let className;
+        if (builtInMatches.length > 1) {
+            className = builtInMatches[1];
+        } else {
+            // Failed to match the standard '[object ClassName]'
+            return toString.call(val);
+        }
+        if (className == 'Object') {
+            // we're a user defined class or Object
+            // JSON.stringify avoids problems with cycles, and is generally much
+            // easier than looping through ownProperties of `val`.
+            try {
+                return 'Object(' + JSON.stringify(val) + ')';
+            } catch (_) {
+                return 'Object';
+            }
+        }
+        // errors
+        if (val instanceof Error) {
+        return `${val.name}: ${val.message}
+        ${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+;
+const toString = Object.prototype.toString;
+const val = getObject(i);
+const debug = debug_str(val);
+const ptr = passStringToWasm(debug);
+getUint32Memory()[len_ptr / 4] = WASM_VECTOR_LEN;
+return ptr;
+}
+__exports.__wbindgen_debug_string = __wbindgen_debug_string
+
 function __wbindgen_throw(ptr, len) {
     throw new Error(getStringFromWasm(ptr, len));
 }
@@ -95,6 +258,8 @@ function dropObject(idx) {
 function __wbindgen_object_drop_ref(i) { dropObject(i); }
 __exports.__wbindgen_object_drop_ref = __wbindgen_object_drop_ref
 
+//!IMPORTANT_STUFF
+
 const WASM_URL = './pkg/webhogg_bg.wasm';
 
 const imports = { './webhogg': __exports };
@@ -103,9 +268,9 @@ let res = WebAssembly.instantiateStreaming(fetch(WASM_URL), imports);
 res.then(result => {
     console.log(result);
     wasm = result.instance.exports;
-    wasm.graphics_entry();
+    graphics_entry();
 });
 
 onmessage = function (e) {
-    console.log('gooot messaaage', e);
+    console.log('gooot messaaage', e.data);
 }
diff --git a/WebInterface/wasm/webhogg/index.html b/WebInterface/wasm/webhogg/index.html
index ce09537..ced7e94 100644
--- a/WebInterface/wasm/webhogg/index.html
+++ b/WebInterface/wasm/webhogg/index.html
@@ -3,7 +3,7 @@
     <head>
         <meta charset="UTF-8">
         <title>webhogg</title>
-        <script src='loader.js' type='module'></script>
+        <script src='loader.js'></script>
         <style>
             body {
                 margin: 0;
diff --git a/WebInterface/wasm/webhogg/loader.js b/WebInterface/wasm/webhogg/loader.js
index 159dbb9..1fc8584 100644
--- a/WebInterface/wasm/webhogg/loader.js
+++ b/WebInterface/wasm/webhogg/loader.js
@@ -67,7 +67,7 @@ function addHeapObject(obj) {
 * @param {any} worker
 * @returns {void}
 */
-export function game_logic_entry(worker) {
+function game_logic_entry(worker) {
     return wasm.game_logic_entry(addHeapObject(worker));
 }
 __exports.game_logic_entry = game_logic_entry
@@ -75,7 +75,7 @@ __exports.game_logic_entry = game_logic_entry
 /**
 * @returns {void}
 */
-export function graphics_entry() {
+function graphics_entry() {
     return wasm.graphics_entry();
 }
 __exports.graphics_entry = graphics_entry
@@ -258,6 +258,8 @@ function dropObject(idx) {
 function __wbindgen_object_drop_ref(i) { dropObject(i); }
 __exports.__wbindgen_object_drop_ref = __wbindgen_object_drop_ref
 
+//!IMPORTANT_STUFF
+
 const WASM_URL = './pkg/webhogg_bg.wasm';
 
 const imports = { './webhogg': __exports };
@@ -268,6 +270,7 @@ let graphics = new Worker('./graphics.js', {type: 'module', credentials: 'includ
 res.then(result => {
     console.log(result);
     wasm = result.instance.exports;
-    wasm.game_logic_entry(graphics);
+    console.log('jsjs value', graphics);
+    game_logic_entry(graphics);
 });
 
diff --git a/WebInterface/wasm/webhogg/run b/WebInterface/wasm/webhogg/run
index 1da1e35..76ca728 100755
--- a/WebInterface/wasm/webhogg/run
+++ b/WebInterface/wasm/webhogg/run
@@ -1,3 +1,6 @@
 #!/bin/sh
 
 wasm-pack build --release --target web
+python update.py
+sh killpy
+sh deploy
diff --git a/WebInterface/wasm/webhogg/src/lib.rs b/WebInterface/wasm/webhogg/src/lib.rs
index 5823e72..9d052cd 100644
--- a/WebInterface/wasm/webhogg/src/lib.rs
+++ b/WebInterface/wasm/webhogg/src/lib.rs
@@ -19,11 +19,12 @@ fn run_application() {
 }
 
 #[wasm_bindgen]
-pub fn game_logic_entry(worker: Worker) {
+pub fn game_logic_entry(worker: web_sys::Worker) {
     client_logger::init_logger();
 
     info!("game logic initialisation");
-    //worker.post_message(&wasm_bindgen::JsValue::from_str("msg frm wasm_gLe")).unwrap();
+    info!("js value: {:?}", worker);
+    worker.post_message(&wasm_bindgen::JsValue::from_str("msg frm wasm_gLe")).unwrap();
 }
 
 #[wasm_bindgen]
diff --git a/WebInterface/wasm/webhogg/update.py b/WebInterface/wasm/webhogg/update.py
new file mode 100644
index 0000000..0a0171f
--- /dev/null
+++ b/WebInterface/wasm/webhogg/update.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+ISC = '//!IMPORTANT_STUFF'
+
+def rf(fn):
+    f = open(fn)
+    c = f.read()
+    f.close()
+    return c
+
+nc = rf('pkg/webhogg.js')
+m1 = rf('loader.js')
+m2 = rf('graphics.js')
+
+nc = nc.split('function init(module) {')[0].strip('\n')
+nc = nc.replace('export function ', 'function ')
+m1 = m1.split('//!IMPORTANT_STUFF')[-1]
+m2 = m2.split('//!IMPORTANT_STUFF')[-1]
+
+nc += '\n' * 2 + ISC
+
+m1 = nc + m1
+m2 = nc + m2
+
+with open('loader.js', 'w') as f:
+    f.write(m1)
+
+with open('graphics.js', 'w') as f:
+    f.write(m2)