`.
+ *
+ * This will load the engine if it is not loaded, and preload the main pck.
+ *
+ * This method expects the initial config (or the override) to have both the :js:attr:`executable` and :js:attr:`mainPack`
+ * properties set (normally done by the editor during export).
+ *
+ * @param {EngineConfig} override An optional configuration override.
+ * @return {Promise} Promise that resolves once the game started.
+ */
+ startGame: function (override) {
+ this.config.update(override);
+ // Add main-pack argument.
+ const exe = this.config.executable;
+ const pack = this.config.mainPack || `${exe}.pck`;
+ this.config.args = ['--main-pack', pack].concat(this.config.args);
+ // Start and init with execName as loadPath if not inited.
+ const me = this;
+ return Promise.all([
+ this.init(exe),
+ this.preloadFile(pack, pack),
+ ]).then(function () {
+ return me.start.apply(me);
+ });
+ },
+
+ /**
+ * Create a file at the specified ``path`` with the passed as ``buffer`` in the instance's file system.
+ *
+ * @param {string} path The location where the file will be created.
+ * @param {ArrayBuffer} buffer The content of the file.
+ */
+ copyToFS: function (path, buffer) {
+ if (this.rtenv == null) {
+ throw new Error('Engine must be inited before copying files');
+ }
+ this.rtenv['copyToFS'](path, buffer);
+ },
+
+ /**
+ * Request that the current instance quit.
+ *
+ * This is akin the user pressing the close button in the window manager, and will
+ * have no effect if the engine has crashed, or is stuck in a loop.
+ *
+ */
+ requestQuit: function () {
+ if (this.rtenv) {
+ this.rtenv['request_quit']();
+ }
+ },
+ };
+
+ Engine.prototype = proto;
+ // Closure compiler exported instance methods.
+ Engine.prototype['init'] = Engine.prototype.init;
+ Engine.prototype['preloadFile'] = Engine.prototype.preloadFile;
+ Engine.prototype['start'] = Engine.prototype.start;
+ Engine.prototype['startGame'] = Engine.prototype.startGame;
+ Engine.prototype['copyToFS'] = Engine.prototype.copyToFS;
+ Engine.prototype['requestQuit'] = Engine.prototype.requestQuit;
+ // Also expose static methods as instance methods
+ Engine.prototype['load'] = Engine.load;
+ Engine.prototype['unload'] = Engine.unload;
+ return new Engine(initConfig);
+ }
+
+ // Closure compiler exported static methods.
+ SafeEngine['load'] = Engine.load;
+ SafeEngine['unload'] = Engine.unload;
+
+ // Feature-detection utilities.
+ SafeEngine['isWebGLAvailable'] = Features.isWebGLAvailable;
+ SafeEngine['isFetchAvailable'] = Features.isFetchAvailable;
+ SafeEngine['isSecureContext'] = Features.isSecureContext;
+ SafeEngine['isCrossOriginIsolated'] = Features.isCrossOriginIsolated;
+ SafeEngine['isSharedArrayBufferAvailable'] = Features.isSharedArrayBufferAvailable;
+ SafeEngine['isAudioWorkletAvailable'] = Features.isAudioWorkletAvailable;
+ SafeEngine['getMissingFeatures'] = Features.getMissingFeatures;
+
+ return SafeEngine;
+}());
+if (typeof window !== 'undefined') {
+ window['Engine'] = Engine;
+}
diff --git a/games/GrappleTest/index.pck b/games/GrappleTest/index.pck
new file mode 100644
index 0000000..e4f8ee5
Binary files /dev/null and b/games/GrappleTest/index.pck differ
diff --git a/games/GrappleTest/index.png b/games/GrappleTest/index.png
new file mode 100644
index 0000000..766b0b6
Binary files /dev/null and b/games/GrappleTest/index.png differ
diff --git a/games/GrappleTest/index.wasm b/games/GrappleTest/index.wasm
new file mode 100644
index 0000000..c871bcd
Binary files /dev/null and b/games/GrappleTest/index.wasm differ
diff --git a/games/GrappleTest/index.worker.js b/games/GrappleTest/index.worker.js
new file mode 100644
index 0000000..95147a2
--- /dev/null
+++ b/games/GrappleTest/index.worker.js
@@ -0,0 +1,161 @@
+/**
+ * @license
+ * Copyright 2015 The Emscripten Authors
+ * SPDX-License-Identifier: MIT
+ */
+
+// Pthread Web Worker startup routine:
+// This is the entry point file that is loaded first by each Web Worker
+// that executes pthreads on the Emscripten application.
+
+'use strict';
+
+var Module = {};
+
+// Thread-local guard variable for one-time init of the JS state
+var initializedJS = false;
+
+function assert(condition, text) {
+ if (!condition) abort('Assertion failed: ' + text);
+}
+
+function threadPrintErr() {
+ var text = Array.prototype.slice.call(arguments).join(' ');
+ console.error(text);
+}
+function threadAlert() {
+ var text = Array.prototype.slice.call(arguments).join(' ');
+ postMessage({cmd: 'alert', text: text, threadId: Module['_pthread_self']()});
+}
+// We don't need out() for now, but may need to add it if we want to use it
+// here. Or, if this code all moves into the main JS, that problem will go
+// away. (For now, adding it here increases code size for no benefit.)
+var out = () => { throw 'out() is not defined in worker.js.'; }
+var err = threadPrintErr;
+self.alert = threadAlert;
+
+Module['instantiateWasm'] = (info, receiveInstance) => {
+ // Instantiate from the module posted from the main thread.
+ // We can just use sync instantiation in the worker.
+ var module = Module['wasmModule'];
+ // We don't need the module anymore; new threads will be spawned from the main thread.
+ Module['wasmModule'] = null;
+ var instance = new WebAssembly.Instance(module, info);
+ // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193,
+ // the above line no longer optimizes out down to the following line.
+ // When the regression is fixed, we can remove this if/else.
+ return receiveInstance(instance);
+}
+
+// Turn unhandled rejected promises into errors so that the main thread will be
+// notified about them.
+self.onunhandledrejection = (e) => {
+ throw e.reason ?? e;
+};
+
+function handleMessage(e) {
+ try {
+ if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
+
+ // Until we initialize the runtime, queue up any further incoming messages.
+ let messageQueue = [];
+ self.onmessage = (e) => messageQueue.push(e);
+
+ // And add a callback for when the runtime is initialized.
+ self.startWorker = (instance) => {
+ Module = instance;
+ // Notify the main thread that this thread has loaded.
+ postMessage({ 'cmd': 'loaded' });
+ // Process any messages that were queued before the thread was ready.
+ for (let msg of messageQueue) {
+ handleMessage(msg);
+ }
+ // Restore the real message handler.
+ self.onmessage = handleMessage;
+ };
+
+ // Module and memory were sent from main thread
+ Module['wasmModule'] = e.data.wasmModule;
+
+ // Use `const` here to ensure that the variable is scoped only to
+ // that iteration, allowing safe reference from a closure.
+ for (const handler of e.data.handlers) {
+ Module[handler] = function() {
+ postMessage({ cmd: 'callHandler', handler, args: [...arguments] });
+ }
+ }
+
+ Module['wasmMemory'] = e.data.wasmMemory;
+
+ Module['buffer'] = Module['wasmMemory'].buffer;
+
+ Module['workerID'] = e.data.workerID;
+
+ Module['ENVIRONMENT_IS_PTHREAD'] = true;
+
+ if (typeof e.data.urlOrBlob == 'string') {
+ importScripts(e.data.urlOrBlob);
+ } else {
+ var objectUrl = URL.createObjectURL(e.data.urlOrBlob);
+ importScripts(objectUrl);
+ URL.revokeObjectURL(objectUrl);
+ }
+ Godot(Module);
+ } else if (e.data.cmd === 'run') {
+ // Pass the thread address to wasm to store it for fast access.
+ Module['__emscripten_thread_init'](e.data.pthread_ptr, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0, /*canBlock=*/1);
+
+ // Await mailbox notifications with `Atomics.waitAsync` so we can start
+ // using the fast `Atomics.notify` notification path.
+ Module['__emscripten_thread_mailbox_await'](e.data.pthread_ptr);
+
+ assert(e.data.pthread_ptr);
+ // Also call inside JS module to set up the stack frame for this pthread in JS module scope
+ Module['establishStackSpace']();
+ Module['PThread'].receiveObjectTransfer(e.data);
+ Module['PThread'].threadInitTLS();
+
+ if (!initializedJS) {
+ initializedJS = true;
+ }
+
+ try {
+ Module['invokeEntryPoint'](e.data.start_routine, e.data.arg);
+ } catch(ex) {
+ if (ex != 'unwind') {
+ // The pthread "crashed". Do not call `_emscripten_thread_exit` (which
+ // would make this thread joinable). Instead, re-throw the exception
+ // and let the top level handler propagate it back to the main thread.
+ throw ex;
+ }
+ }
+ } else if (e.data.cmd === 'cancel') { // Main thread is asking for a pthread_cancel() on this thread.
+ if (Module['_pthread_self']()) {
+ Module['__emscripten_thread_exit'](-1);
+ }
+ } else if (e.data.target === 'setimmediate') {
+ // no-op
+ } else if (e.data.cmd === 'checkMailbox') {
+ if (initializedJS) {
+ Module['checkMailbox']();
+ }
+ } else if (e.data.cmd) {
+ // The received message looks like something that should be handled by this message
+ // handler, (since there is a e.data.cmd field present), but is not one of the
+ // recognized commands:
+ err('worker.js received unknown command ' + e.data.cmd);
+ err(e.data);
+ }
+ } catch(ex) {
+ err('worker.js onmessage() captured an uncaught exception: ' + ex);
+ if (ex && ex.stack) err(ex.stack);
+ if (Module['__emscripten_thread_crashed']) {
+ Module['__emscripten_thread_crashed']();
+ }
+ throw ex;
+ }
+};
+
+self.onmessage = handleMessage;
+
+
diff --git a/games/GrappleTest/style.css b/games/GrappleTest/style.css
new file mode 100644
index 0000000..e69de29
diff --git a/index.js b/index.js
index f89ec54..188d77d 100644
--- a/index.js
+++ b/index.js
@@ -2,7 +2,7 @@ const express = require('express'),
path = require('path'),
fs = require('fs'),
pageUpdater = require('./pageUpdater.js')
- // ytjs = require("youtubei.js")
+// ytjs = require("youtubei.js")
var app = express()
@@ -39,8 +39,18 @@ app.listen(PORT, () => {
})
var cachePath = path.join(staticpath, 'cached')
+var gamePath = path.join(__dirname, "games")
// var imgPath = path.join(staticpath, 'imgs')
+app.use(function (req, res, next) {
+ res.header("Cross-Origin-Embedder-Policy", "require-corp");
+ res.header("Cross-Origin-Opener-Policy", "same-origin");
+ next();
+});
+
+
+app.use("/games", express.static(gamePath))
+
if (!fs.existsSync(cachePath)) {
fs.mkdirSync(cachePath)
} else {
@@ -51,4 +61,4 @@ if (!fs.existsSync(cachePath)) {
}
}
-app.use(pageUpdater.middleWare)
+app.use(pageUpdater.middleWare)
\ No newline at end of file
diff --git a/overcomplicatedStatuses.js b/overcomplicatedStatuses.js
index 51e22b1..1f1bc56 100644
--- a/overcomplicatedStatuses.js
+++ b/overcomplicatedStatuses.js
@@ -195,7 +195,6 @@ module.exports = {
}
}
}
- addedHTML = addedHTML.replaceAll("Violet", "{Violet}")
return addedHTML + ""
}
}
\ No newline at end of file
diff --git a/static/index.html b/static/index.html
index 0bc38cb..1a9861d 100644
--- a/static/index.html
+++ b/static/index.html
@@ -46,13 +46,12 @@
Make sure to check out this project on Codeberg!
{ACTIVITIES}
- Kind of announcement I guess !!
+
Kind of announcement I guess !!
Over the past while (like a week I think) I've been working on a small 2d platformer. It's very, very early in development, but I would love feedback!
Check it out on:
- itch.io (Web & downloads)
- Play on Violet's Purgatory
- Coming soon!
+ itch.io (Play Web or Download)
+ Play on Violet's Purgatory
Socials