9 files changed, 462 insertions, 76 deletions

diff --git a/WebInterface/wasm/webhogg/deploy b/WebInterface/wasm/webhogg/deploy
index 01bc036..6284564 100755
--- a/WebInterface/wasm/webhogg/deploy
+++ b/WebInterface/wasm/webhogg/deploy
@@ -1,4 +1,3 @@
 #!/bin/sh
-#killall darkhttpd
-#darkhttpd . --addr 127.0.0.1 --port 8080 --mimetypes mimes
-python3 deploy.py
+killall python3
+python3 deploy.py -d
diff --git a/WebInterface/wasm/webhogg/deploy.py b/WebInterface/wasm/webhogg/deploy.py
index 21d9a5e..7bc56ac 100755
--- a/WebInterface/wasm/webhogg/deploy.py
+++ b/WebInterface/wasm/webhogg/deploy.py
@@ -2,10 +2,20 @@
 
 from socket import socket, SOL_SOCKET, SO_REUSEADDR
 
-ws = socket()
-ws.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
-ws.bind(('localhost', 8080))
-ws.listen()
+if False:
+    CSP = {
+        'script-src': ["*", "'unsafe-inline'"],
+        'worker-src': ["*", "'unsafe-inline'"],
+        'style-src': ["*", "'unsafe-inline'"],
+        'default-src': ["*", "'unsafe-inline'"],
+    }
+
+    ADD_HEADERS = 'Content-Security-Policy: ' + '; '.join(
+            k + ' ' + ' '.join(v) for k, v in CSP.items())
+    # ADD_HEADERS += '\r\n' + ADD_HEADERS.replace('cy: ', 'cy-Report-Only: ')
+    print(ADD_HEADERS)
+    ADD_HEADERS = '\r\n' + ADD_HEADERS
+ADD_HEADERS = ''
 
 class Client:
     def __init__(self, sock, addr):
@@ -19,24 +29,69 @@ class Client:
         method, loc, ver = lines[0].split(' ')
         print(f'request from \'{self.addr}\': "{loc}"')
         attrs = {key: value for key, value in (i.split(': ') for i in lines[1:])}
-        return method, loc, attrs
+        return method, loc, attrs, ver
 
     def sen(self, loc, ver):
-        f = open(loc, 'rb')
-        c = f.read()
-        f.close()
-        self.sock.send(f'HTTP/1.1 200'.encode('utf-8') + c)
+        print(f'request {loc}')
+        if loc.startswith('/'):
+            loc = loc[1:]
+        if not loc:
+            loc = 'index.html'
+        try:
+            if loc == 'favicon.ico':
+                raise FileNotFoundError
+            f = open(loc, 'rb')
+            c = f.read()
+            f.close()
+            print(f'successfully requested {loc}')
+            if loc.endswith('.js'):
+                mime = 'application/javascript'
+            elif loc.endswith('.html'):
+                mime = 'text/html'
+            elif loc.endswith('.wasm'):
+                mime = 'application/wasm'
+            else:
+                mime = 'text/plain'
+            packet = f'HTTP/1.1 200 Success\r\nContent-Length: {len(c)}\r\nContent-Type: {mime}{ADD_HEADERS}\r\n\r\n'.encode('utf-8') + c
+            self.sock.send(packet)
+        except FileNotFoundError:
+            print(f'error request {loc}')
+            self.sock.send(f'HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nContent-Type: text/plain\r\n\r\n'.encode('utf-8'))
+        finally:
+            try:
+                f.close()
+            except:
+                ...
 
     def run(self):
-        method, loc, attrs = self.rec()
-        self.sen(loc, ver)
+        while True:
+            method, loc, attrs, ver = self.rec()
+            self.sen(loc, ver)
+
+
+def run_server():
+    ws = socket()
+    ws.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+    ws.bind(('localhost', 8080))
+    ws.listen()
+
+    clients = []
 
+    while True:
+        c, a = ws.accept()
+        print(f'{a[0]}:{a[1]} connected')
+        client = Client(c, a)
+        clients.append(clients)
+        client.run()
 
-clients = []
 
-while True:
-    c, a = ws.accept()
-    print(f'{a[0]}:{a[1]} connected')
-    client = Client(c, a)
-    clients.append(clients)
-    client.run()
+if __name__ == '__main__':
+    from sys import argv
+    if len(argv) > 1 and argv[1] in ('-d', '--daemon'):
+        import sys
+        from os import getcwd
+        from daemon import DaemonContext
+        with DaemonContext(working_directory=getcwd(), stderr=sys.stderr):
+            run_server()
+    else:
+        run_server()
diff --git a/WebInterface/wasm/webhogg/graphics.js b/WebInterface/wasm/webhogg/graphics.js
index f3bab19..e4759e9 100644
--- a/WebInterface/wasm/webhogg/graphics.js
+++ b/WebInterface/wasm/webhogg/graphics.js
@@ -1,6 +1,111 @@
-import {default as init_r} from './webhogg.js'
-import {init_x} from './webhogg.js'
+const __exports = {};
+let wasm;
 
-let module = init_r('./pkg/webhogg_bg.wasm');
+let cachedTextDecoder = new TextDecoder('utf-8');
 
-init_x(module, 'graphics', null);
+let cachegetUint8Memory = null;
+function getUint8Memory() {
+    if (cachegetUint8Memory === null || cachegetUint8Memory.buffer !== wasm.memory.buffer) {
+        cachegetUint8Memory = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachegetUint8Memory;
+}
+
+function getStringFromWasm(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory().subarray(ptr, ptr + len));
+}
+
+function __wbg_debug_eacd5b227c4c01c7(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.debug(varg0, varg2, varg4);
+}
+__exports.__wbg_debug_eacd5b227c4c01c7 = __wbg_debug_eacd5b227c4c01c7
+
+function __wbg_info_be654745b6a55079(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.info(varg0, varg2, varg4);
+}
+__exports.__wbg_info_be654745b6a55079 = __wbg_info_be654745b6a55079
+
+function __wbg_warn_804a0523852c6d10(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.warn(varg0, varg2, varg4);
+}
+__exports.__wbg_warn_804a0523852c6d10 = __wbg_warn_804a0523852c6d10
+
+function __wbg_error_56a861ecc80f27e1(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.error(varg0, varg2, varg4);
+}
+__exports.__wbg_error_56a861ecc80f27e1 = __wbg_error_56a861ecc80f27e1
+
+const heap = new Array(32);
+
+heap.fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+/**
+* @param {any} worker
+* @returns {void}
+*/
+function game_logic_entry(worker) {
+    return wasm.game_logic_entry(addHeapObject(worker));
+}
+__exports.game_logic_entry = game_logic_entry
+
+/**
+* @param {any} worker
+* @returns {void}
+*/
+function graphics_entry(worker) {
+    return wasm.graphics_entry(addHeapObject(worker));
+}
+__exports.graphics_entry = graphics_entry
+
+function __wbindgen_throw(ptr, len) {
+    throw new Error(getStringFromWasm(ptr, len));
+}
+__exports.__wbindgen_throw = __wbindgen_throw
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function __wbindgen_object_drop_ref(i) { dropObject(i); }
+__exports.__wbindgen_object_drop_ref = __wbindgen_object_drop_ref
+
+const WASM_URL = './pkg/webhogg_bg.wasm';
+
+const imports = { './webhogg': __exports };
+let res = WebAssembly.instantiateStreaming(fetch(WASM_URL), imports);
+
+res.then(result => {
+    console.log(result);
+    wasm = result.instance.exports;
+    wasm.graphics_entry();
+});
+
+onmessage = function (e) {
+    console.log('gooot messaaage', e);
+}
diff --git a/WebInterface/wasm/webhogg/killpy b/WebInterface/wasm/webhogg/killpy
new file mode 100755
index 0000000..5e2b9bc
--- /dev/null
+++ b/WebInterface/wasm/webhogg/killpy
@@ -0,0 +1,2 @@
+#!/bin/sh
+killall python3
diff --git a/WebInterface/wasm/webhogg/lighttpd.config b/WebInterface/wasm/webhogg/lighttpd.config
deleted file mode 100644
index 4072b30..0000000
--- a/WebInterface/wasm/webhogg/lighttpd.config
+++ /dev/null
@@ -1,34 +0,0 @@
-server.http-parseopts = (
-    "header-strict"            => "enable",
-    "host-strict"              => "enable",
-    "host-normalize"           => "enable",
-    "url-normalize"            => "enable",
-    "url-normalize-unreserved" => "enable",
-    "url-normalize-required"   => "enable",
-    "url-ctrls-reject"         => "enable",
-    "url-path-2f-decode"       => "enable",
-    "url-path-dotseg-remove"   => "enable",
-    "url-query-20-plus"        => "enable"
-)
-
-server.modules += ( "mod_setenv" )
-
-server.document-root = "/home/jan/projects/DiscoBot/WebInterface/wasm/webhogg"
-server.port = 8080
-dir-listing.activate    = "enable"
-index-file.names    = ( "index.html" )
-mimetype.assign     = (
-    ".html" => "text/html",
-    ".txt" => "text/plain",
-    ".css" => "text/css",
-    ".js" => "application/javascript",
-    ".jpg" => "image/jpeg",
-    ".jpeg" => "image/jpeg",
-    ".gif" => "image/gif",
-    ".png" => "image/png",
-    ".wasm" => "application/wasm",
-    "" => "application/octet-stream"
-)
-sentenv.add-response-header = (
-    "Content-Security-Policy" => "worker-src localhost:*"
-)
diff --git a/WebInterface/wasm/webhogg/loader.js b/WebInterface/wasm/webhogg/loader.js
index cc66ff6..159dbb9 100644
--- a/WebInterface/wasm/webhogg/loader.js
+++ b/WebInterface/wasm/webhogg/loader.js
@@ -1,9 +1,273 @@
-import {default as init_r} from './webhogg.js'
-import {init_x} from './webhogg.js'
+const __exports = {};
+let wasm;
 
-let module = init_r('./pkg/webhogg_bg.wasm');
+let cachedTextDecoder = new TextDecoder('utf-8');
 
-let graphics = new Worker('./graphics.js')
+let cachegetUint8Memory = null;
+function getUint8Memory() {
+    if (cachegetUint8Memory === null || cachegetUint8Memory.buffer !== wasm.memory.buffer) {
+        cachegetUint8Memory = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachegetUint8Memory;
+}
 
-init_x(module, 'game logic', graphics);
+function getStringFromWasm(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory().subarray(ptr, ptr + len));
+}
+
+function __wbg_debug_eacd5b227c4c01c7(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.debug(varg0, varg2, varg4);
+}
+__exports.__wbg_debug_eacd5b227c4c01c7 = __wbg_debug_eacd5b227c4c01c7
+
+function __wbg_info_be654745b6a55079(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.info(varg0, varg2, varg4);
+}
+__exports.__wbg_info_be654745b6a55079 = __wbg_info_be654745b6a55079
+
+function __wbg_warn_804a0523852c6d10(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.warn(varg0, varg2, varg4);
+}
+__exports.__wbg_warn_804a0523852c6d10 = __wbg_warn_804a0523852c6d10
+
+function __wbg_error_56a861ecc80f27e1(arg0, arg1, arg2, arg3, arg4, arg5) {
+    let varg0 = getStringFromWasm(arg0, arg1);
+    let varg2 = getStringFromWasm(arg2, arg3);
+    let varg4 = getStringFromWasm(arg4, arg5);
+    console.error(varg0, varg2, varg4);
+}
+__exports.__wbg_error_56a861ecc80f27e1 = __wbg_error_56a861ecc80f27e1
+
+const heap = new Array(32);
+
+heap.fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+/**
+* @param {any} worker
+* @returns {void}
+*/
+export function game_logic_entry(worker) {
+    return wasm.game_logic_entry(addHeapObject(worker));
+}
+__exports.game_logic_entry = game_logic_entry
+
+/**
+* @returns {void}
+*/
+export 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));
+}
+__exports.__wbindgen_throw = __wbindgen_throw
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function __wbindgen_object_drop_ref(i) { dropObject(i); }
+__exports.__wbindgen_object_drop_ref = __wbindgen_object_drop_ref
+
+const WASM_URL = './pkg/webhogg_bg.wasm';
+
+const imports = { './webhogg': __exports };
+let res = WebAssembly.instantiateStreaming(fetch(WASM_URL), imports);
+
+let graphics = new Worker('./graphics.js', {type: 'module', credentials: 'include'});
+
+res.then(result => {
+    console.log(result);
+    wasm = result.instance.exports;
+    wasm.game_logic_entry(graphics);
+});
 
diff --git a/WebInterface/wasm/webhogg/mimes b/WebInterface/wasm/webhogg/mimes
deleted file mode 100644
index 007445d..0000000
--- a/WebInterface/wasm/webhogg/mimes
+++ /dev/null
@@ -1 +0,0 @@
-application/wasm wasm
diff --git a/WebInterface/wasm/webhogg/src/lib.rs b/WebInterface/wasm/webhogg/src/lib.rs
index 4a79a24..5823e72 100644
--- a/WebInterface/wasm/webhogg/src/lib.rs
+++ b/WebInterface/wasm/webhogg/src/lib.rs
@@ -23,10 +23,11 @@ pub fn game_logic_entry(worker: Worker) {
     client_logger::init_logger();
 
     info!("game logic initialisation");
+    //worker.post_message(&wasm_bindgen::JsValue::from_str("msg frm wasm_gLe")).unwrap();
 }
 
 #[wasm_bindgen]
-pub fn graphics_entry(worker: Worker) {
+pub fn graphics_entry() {
     client_logger::init_logger();
 
     info!("graphics initialisation");
diff --git a/WebInterface/wasm/webhogg/webhogg.js b/WebInterface/wasm/webhogg/webhogg.js
index 751ac77..c01d70f 100644
--- a/WebInterface/wasm/webhogg/webhogg.js
+++ b/WebInterface/wasm/webhogg/webhogg.js
@@ -1,6 +1,4 @@
-
 const __exports = {};
-let wasm;
 
 let cachedTextDecoder = new TextDecoder('utf-8');
 
@@ -47,9 +45,7 @@ function __wbg_error_56a861ecc80f27e1(arg0, arg1, arg2, arg3, arg4, arg5) {
     console.error(varg0, varg2, varg4);
 }
 __exports.__wbg_error_56a861ecc80f27e1 = __wbg_error_56a861ecc80f27e1
-/**
-* @returns {void}
-*/
+
 export function game_logic_entry(worker) {
     return wasm.game_logic_entry(addHeapObject(worker));
 }
@@ -58,8 +54,8 @@ __exports.game_logic_entry = game_logic_entry
 /**
 * @returns {void}
 */
-export function graphics_entry(worker) {
-    return wasm.graphics_entry(addHeapObject(worker));
+export function graphics_entry() {
+    return wasm.graphics_entry();
 }
 __exports.graphics_entry = graphics_entry
 
@@ -102,11 +98,10 @@ function init_r(module) {
     return result;
 }
 
-function _init_x(result, bx) {
+function _init_x(result, worker) {
     return result.then(({instance, module}) => {
         wasm = instance.exports;
-        if (bx == 1) wasm.game_logic_entry();
-        else         wasm.graphics_entry();
+        wasm.game_logic_entry(worker);
         //init_r.__wbindgen_wasm_module = module;
         //wasm.__wbindgen_start();
         return wasm;