0e16edba82dec8ead95590c38e6a2639b59a047a

Author: github-actions[bot]

404.html

@@ -0,0 +1,6 @@
+<script>
+	window.location.href = '/#' + window.location.href.replace(window.location.origin, '')
+</script>
+GitHub Pages 404
+<br />
+<a href="/">Go back to Home</a>

CNAME

@@ -0,0 +1 @@
+algorithmic.games

FUNDING.yml

@@ -0,0 +1 @@
+github: [ChrisAcrobat]

InterfaceHelper.js

@@ -0,0 +1,266 @@
+'use strict'
+
+class InterfaceHelper {
+	static #initiated = false
+	static #wired = false
+	static #onInit = null
+	static #onWorkerAdded = null
+	static #workers = new Map()
+
+	static preInit() {
+		if (InterfaceHelper.#initiated) {
+			console.error('InterfaceHelper is already initiated.')
+			return
+		}
+		InterfaceHelper.#initiated = true
+
+		const globalStyle = document.createElement('link')
+		globalStyle.rel = 'stylesheet'
+		globalStyle.href = '/global.css'
+		document.head.prepend(globalStyle)
+
+		const fallbackStyle = document.createElement('style')
+		fallbackStyle.textContent = 'html { background-color: var(--main-background-color); }'
+		document.head.prepend(fallbackStyle)
+	}
+
+	/** Coordinator shell: popup opener or `/join` parent. */
+	static #target() {
+		return globalThis.opener ?? globalThis.parent
+	}
+
+	static #ensureWired() {
+		if (InterfaceHelper.#wired) {
+			return
+		}
+		InterfaceHelper.#wired = true
+		globalThis.addEventListener('message', InterfaceHelper.#onWindowMessage)
+	}
+
+	/**
+	 * Called once with cloned match settings (`{ settings, opponents, … }`).
+	 * Register workers with the `workerAdded` callback (slot `0` after this handler returns, then each `{ type: 'WorkerAdded', slot }`).
+	 * @param {(init: unknown, workerAdded: (participant: InterfaceHelperWorker) => void) => void} handler
+	 */
+	static onInit(handler) {
+		InterfaceHelper.#onInit = handler
+		InterfaceHelper.#ensureWired()
+	}
+
+	/**
+	 * @deprecated Register workers via the `workerAdded` argument to {@link InterfaceHelper.onInit} instead.
+	 * @param {(worker: InterfaceHelperWorker) => void} handler
+	 */
+	static workerAdded(handler) {
+		InterfaceHelper.#onWorkerAdded = handler
+		InterfaceHelper.#ensureWired()
+	}
+
+	static #registerWorker(handler) {
+		InterfaceHelper.#onWorkerAdded = handler
+	}
+
+	static #dispatchInit(init) {
+		InterfaceHelper.#onInit?.(init, InterfaceHelper.#registerWorker)
+		InterfaceHelper.#attachWorker(0)
+	}
+
+	/** Tell the coordinator the interface applied init and is listening. */
+	static signalReady() {
+		const t = InterfaceHelper.#target()
+		if (t) {
+			t.postMessage(null, '*')
+		}
+	}
+
+	/** Coordinator init: `{ settings, opponents }` (see `cloneInterfaceWorkerInit`). */
+	static #isInit(data) {
+		if (typeof data !== 'object' || data === null) {
+			return false
+		}
+		const type = data.type
+		if (
+			type === 'Post' || type === 'Kill' || type === 'WorkerAdded' || type === 'Response' ||
+			type === 'Arena-Interface-Ready' || type === 'Arena-Interface-Disconnected'
+		) {
+			return false
+		}
+		const settings = data.settings
+		if (settings !== undefined && typeof settings === 'object' && settings !== null) {
+			return true
+		}
+		return data.general !== undefined && typeof data.general === 'object' && data.general !== null
+	}
+
+	static #unwrapPostEnvelope(data) {
+		if (
+			typeof data === 'object' &&
+			data !== null &&
+			data.type !== 'Post' &&
+			typeof data.message === 'object' &&
+			data.message !== null &&
+			data.message.type === 'Post'
+		) {
+			return data.message
+		}
+		return data
+	}
+
+	static #isPost(data) {
+		return typeof data === 'object' && data !== null && data.type === 'Post'
+	}
+
+	static #isDisconnected(data) {
+		return typeof data === 'object' && data !== null && data.type === 'Arena-Interface-Disconnected'
+	}
+
+	static #showDisconnectedState(label) {
+		const lock = document.getElementById('lock')
+		if (!lock) {
+			return
+		}
+		lock.classList.add('engaged')
+		lock.classList.remove('booting')
+		const span = lock.querySelector('span')
+		if (span) {
+			span.textContent = label
+		}
+	}
+
+	static #coerceWorkerSlot(value) {
+		if (typeof value === 'number' && Number.isFinite(value)) {
+			return value
+		}
+		if (typeof value === 'string' && value !== '') {
+			const n = Number(value)
+			return Number.isFinite(n) ? n : 0
+		}
+		return 0
+	}
+
+	static #workerSlotFromEnvelope(data) {
+		if (typeof data.workerSlot === 'number') {
+			return data.workerSlot
+		}
+		if (typeof data.workerSlot === 'string') {
+			return InterfaceHelper.#coerceWorkerSlot(data.workerSlot)
+		}
+		if (typeof data.workerName === 'string') {
+			return data.workerName === '' ? 0 : InterfaceHelper.#coerceWorkerSlot(data.workerName)
+		}
+		if (data.type === 'Kill' && typeof data.slot === 'number') {
+			return InterfaceHelper.#coerceWorkerSlot(data.slot)
+		}
+		return 0
+	}
+
+	static #sendResponse(value, options, messageIndex) {
+		const t = InterfaceHelper.#target()
+		if (!t) {
+			return
+		}
+		const executionSteps = options?.executionSteps ?? { toRespond: 0, toTerminate: 0 }
+		const idx = options?.messageIndex ?? messageIndex
+		t.postMessage({
+			type: 'Response',
+			response: {
+				value,
+				executionSteps,
+				...(typeof idx === 'number' ? { messageIndex: idx } : {}),
+				...(options?.console ? { console: options.console } : {}),
+			},
+		}, '*')
+	}
+
+	static #createWorker() {
+		/** @type {number | null} */
+		let lastMessageIndex = null
+		const worker = {
+			onMessage: null,
+			onKilled: null,
+			respond(value, options) {
+				InterfaceHelper.#sendResponse(value, options, options?.messageIndex ?? lastMessageIndex)
+			},
+		}
+		Object.defineProperty(worker, '_lastMessageIndex', {
+			get: () => lastMessageIndex,
+			set: (v) => {
+				lastMessageIndex = v
+			},
+		})
+		return worker
+	}
+
+	static #attachWorker(workerSlot) {
+		if (!InterfaceHelper.#onWorkerAdded) {
+			return
+		}
+		let worker = InterfaceHelper.#workers.get(workerSlot)
+		if (worker) {
+			return worker
+		}
+		worker = InterfaceHelper.#createWorker()
+		InterfaceHelper.#workers.set(workerSlot, worker)
+		InterfaceHelper.#onWorkerAdded(worker)
+		return worker
+	}
+
+	static #onWindowMessage(messageEvent) {
+		const data = InterfaceHelper.#unwrapPostEnvelope(messageEvent.data)
+		if (InterfaceHelper.#isDisconnected(data)) {
+			const label = typeof data.message === 'string' && data.message.trim() ? data.message.trim() : 'Match has ended'
+			InterfaceHelper.#showDisconnectedState(label)
+			return
+		}
+		if (InterfaceHelper.#isInit(data)) {
+			InterfaceHelper.#dispatchInit(data)
+			return
+		}
+		if (data.type === 'WorkerAdded' && typeof data.slot === 'number') {
+			InterfaceHelper.#attachWorker(data.slot)
+			return
+		}
+		if (data.type === 'Kill') {
+			const workerSlot = InterfaceHelper.#workerSlotFromEnvelope(data)
+			const worker = InterfaceHelper.#workers.get(workerSlot)
+			if (!worker) {
+				InterfaceHelper.#sendResponse('Dead', {}, data.messageIndex)
+				return
+			}
+			let responded = false
+			const priorRespond = worker.respond
+			worker.respond = function (value, options) {
+				responded = true
+				return priorRespond.call(
+					this,
+					value,
+					{ ...options, messageIndex: options?.messageIndex ?? data.messageIndex },
+				)
+			}
+			worker.onKilled?.()
+			worker.respond = priorRespond
+			if (!responded) {
+				priorRespond.call(worker, 'Dead', { messageIndex: data.messageIndex })
+			}
+			return
+		}
+		if (InterfaceHelper.#isPost(data)) {
+			const workerSlot = InterfaceHelper.#workerSlotFromEnvelope(data)
+			const worker = InterfaceHelper.#workers.get(workerSlot)
+			if (!worker) {
+				return
+			}
+			worker._lastMessageIndex = typeof data.messageIndex === 'number' ? data.messageIndex : null
+			const message = {
+				data: data.message,
+				respond(value, options) {
+					InterfaceHelper.#sendResponse(value, options, data.messageIndex)
+				},
+			}
+			worker.onMessage?.(message)
+		}
+	}
+}
+
+globalThis.InterfaceHelper = InterfaceHelper
+InterfaceHelper.preInit()

README.md

@@ -0,0 +1,3 @@
+# Algorithmic Games
+
+Please read [here](https://github.com/AlgorithmicGames).