@benev/archimedes 0.1.0-1

package/s/_archive/core/speculator.ts

@@ -0,0 +1,63 @@
+
+import {Liaison} from "./liaison.js"
+import {loop} from "../tools/loop.js"
+import {Simulator} from "./simulator.js"
+import {Chronicle} from "../tools/chronicle.js"
+import {AuthorId, Schema, Telegram} from "./types.js"
+import {makeTelegramForInputs} from "./utils/make-telegram-for-inputs.js"
+
+export class Speculator<xSchema extends Schema> {
+	#currentTick = 0
+	#chronicle = new Chronicle<xSchema["input"]>()
+
+	maxIncomingTicks = 5
+
+	constructor(
+		public authorId: AuthorId,
+		public liaison: Liaison<Telegram<xSchema>>,
+		public pastSimulator: Simulator<xSchema>,
+		public futureSimulator: Simulator<xSchema>,
+		public hz: number,
+	) {}
+
+	get ticksAhead() {
+		const rtt = this.liaison.pingponger.averageRtt
+		return Math.round(rtt / (1000 / this.hz))
+	}
+
+	tick() {
+		const telegrams = this.liaison.recv().slice(-this.maxIncomingTicks)
+		const lastTelegram = telegrams.at(-1)
+
+		for (const telegram of telegrams)
+			this.pastSimulator.simulate(telegram)
+
+		if (lastTelegram) {
+			const [latestTick] = lastTelegram
+			this.#currentTick = latestTick
+		}
+		else this.#currentTick += 1
+
+		// roll-forward
+		this.futureSimulator.state = structuredClone(this.pastSimulator.state)
+
+		for (const t of loop(this.ticksAhead)) {
+			for (const inputs of this.#chronicle.at(t)) {
+				this.futureSimulator.simulate(
+					makeTelegramForInputs(t, this.authorId, inputs)
+				)
+			}
+		}
+	}
+
+	sendInputs(inputs: xSchema["input"][]) {
+		const futureTick = this.#currentTick + this.ticksAhead
+
+		// immediately send down the wire
+		this.liaison.send(makeTelegramForInputs(futureTick, this.authorId, inputs))
+
+		// schedule local inputs into the future
+		this.#chronicle.add(inputs, futureTick)
+	}
+}
+

package/s/_archive/core/types.ts

@@ -0,0 +1,32 @@
+
+import {Simulator} from "./simulator.js"
+
+export type TickNumber = number
+export type AuthorId = number
+export type Authored<Content> = [AuthorId, Content]
+
+export type Schema = {
+	state: any
+	delta: any
+	input: any
+}
+
+export type StateDispatch<xSchema extends Schema> = ["state", xSchema["state"]]
+export type DeltaDispatch<xSchema extends Schema> = ["delta", xSchema["delta"]]
+export type InputDispatch<xSchema extends Schema> = ["input", Authored<xSchema["input"]>]
+
+export type Dispatch<xSchema extends Schema> = (
+	| StateDispatch<xSchema>
+	| DeltaDispatch<xSchema>
+	| InputDispatch<xSchema>
+)
+
+export type Telegram<xSchema extends Schema> = [TickNumber, Dispatch<xSchema>[]]
+export type InputTelegram<xSchema extends Schema> = [TickNumber, InputDispatch<xSchema["input"]>]
+
+export type InferSimulatorSchema<S extends Simulator<any>> = (
+	S extends Simulator<infer xSchema>
+		? xSchema
+		: never
+)
+

package/s/_archive/core/utils/handle-telegrams.ts

@@ -0,0 +1,34 @@
+
+import {AuthorId, Schema, Telegram} from "../types.js"
+
+export function handleTelegram<xSchema extends Schema>(
+		telegram: Telegram<xSchema>,
+		callbacks: DispatchCallbacks<xSchema>,
+	) {
+
+	const [authorId, dispatches] = telegram
+
+	for (const [key, content] of dispatches) {
+		switch (key) {
+
+			case "state":
+				callbacks.state(content, authorId)
+				break
+
+			case "delta":
+				callbacks.delta(content, authorId)
+				break
+
+			case "input":
+				callbacks.input(content, authorId)
+				break
+		}
+	}
+}
+
+export type DispatchCallbacks<xSchema extends Schema> = {
+	state: (state: xSchema["state"], authorId: AuthorId) => void
+	delta: (delta: xSchema["delta"], authorId: AuthorId) => void
+	input: (input: xSchema["input"], authorId: AuthorId) => void
+}
+

package/s/_archive/core/utils/is-input-dispatch.ts

@@ -0,0 +1,10 @@
+
+import {Dispatch, InputDispatch, Schema} from "../types.js"
+
+export function isInputDispatch<S extends Schema>(
+		dispatch: Dispatch<S>
+	): dispatch is InputDispatch<S["input"]> {
+	const [kind] = dispatch
+	return kind === "input"
+}
+

package/s/_archive/core/utils/make-telegram-for-inputs.ts

@@ -0,0 +1,12 @@
+
+import {Schema, Telegram} from "../types.js"
+
+export function makeTelegramForInputs<xSchema extends Schema>(
+		futureTick: number,
+		authorId: number,
+		inputs: xSchema["input"][],
+	): Telegram<xSchema> {
+
+	return [futureTick, [["input", [authorId, inputs]]]]
+}
+

package/s/_archive/core/utils/on-channel-message.ts

@@ -0,0 +1,11 @@
+
+export function onChannelMessage(
+		channel: RTCDataChannel,
+		onmessage: (message: any) => void,
+	) {
+
+	const listener = (event: MessageEvent) => onmessage(event.data)
+	channel.addEventListener("message", listener)
+	return () => channel.removeEventListener("message", listener)
+}
+

package/s/_archive/eureka/eureka.ts

@@ -0,0 +1,20 @@
+
+import {World} from "./parts/world.js"
+import {System} from "./parts/system.js"
+import {Components, SystemFn} from "./parts/types.js"
+
+export const setupEureka = <Context, C extends Components>() => ({
+	system: (label: string) => ({
+		select: <K extends keyof C>(...keys: K[]) => ({
+			fn: (fn: SystemFn<Context, C, K, undefined>) => new System(label, keys, [], fn),
+			andMaybe: <K2 extends keyof C>(...keysOptional: K2[]) => ({
+				fn: (fn: SystemFn<Context, C, K, K2>) => new System(label, keys, keysOptional, fn),
+			}),
+		}),
+	}),
+
+	world: (context: Context, systems: System[]) => (
+		new World<Context, C>(context, systems)
+	),
+})
+

package/s/_archive/eureka/integration/context.ts

@@ -0,0 +1,9 @@
+
+import {Inputs} from "./utils/inputs.js"
+import {Relevance} from "./utils/relevance.js"
+
+export class EurekaContext {
+	inputs = new Inputs()
+	relevance = new Relevance()
+}
+

package/s/_archive/eureka/integration/simulator.ts

@@ -0,0 +1,75 @@
+
+import {World} from "../parts/world.js"
+import {EurekaSchema} from "./types.js"
+import {EurekaContext} from "./context.js"
+import {Components, EntityId} from "../parts/types.js"
+import {Simulator} from "../../core/simulator.js"
+import {AuthorId, Dispatch, Telegram} from "../../core/types.js"
+
+export class EurekaSimulator
+	<xContext extends EurekaContext, C extends Components>
+	extends Simulator<EurekaSchema<C>> {
+
+	#deltas: EurekaSchema<C>["delta"] = []
+	#authorityId = 0
+
+	constructor(public world: World<xContext, C>) {
+		super([...world.data()])
+		world.on((id, entity) => void this.#deltas.push([id, entity?.components ?? null]))
+	}
+
+	simulate(telegram: Telegram<EurekaSchema<C>>): EurekaSchema<C>["delta"] {
+		this.#deltas = []
+
+		Simulator.handleTelegram(telegram, {
+			input: (inputs) => {
+				this.world.context.inputs.add(inputs)
+			},
+
+			state: (state, authorId) => {
+				if (authorId === this.#authorityId) {
+					this.world.clear()
+					this.world.overwrite(state)
+				}
+			},
+
+			delta: (deltas, authorId) => {
+				if (authorId === this.#authorityId)
+					return undefined
+				for (const [id, components] of deltas)
+					this.world.write(id, components)
+			},
+		})
+
+		this.world.execute()
+		return this.#deltas
+	}
+
+	tailor(audienceAuthorId: AuthorId, telegram: Telegram<EurekaSchema<C>>): Telegram<EurekaSchema<C>> {
+		const check = (eid: EntityId) => this.world.context.relevance.check(audienceAuthorId, eid)
+		const [telegramAuthorId, dispatches] = telegram
+		const relevantDispatches: Dispatch<EurekaSchema<C>>[] = []
+		for (const [kind, x] of dispatches) {
+			switch (kind) {
+
+				case "state": {
+					relevantDispatches.push([kind, x.filter(([id]) => check(id))])
+				} break
+
+				case "delta": {
+					relevantDispatches.push([kind, x.filter(([id]) => check(id))])
+				} break
+
+				case "input": {
+					const [authorId, inputEntries] = x
+					relevantDispatches.push([
+						kind,
+						[authorId, inputEntries.filter(([id]) => check(id))],
+					])
+				} break
+			}
+		}
+		return [telegramAuthorId, relevantDispatches]
+	}
+}
+

package/s/_archive/eureka/integration/types.ts

@@ -0,0 +1,12 @@
+
+import {Components, EntityId, EntityData} from "../parts/types.js"
+
+export type InputEntry = [EntityId, unknown[]]
+export type Delta<C extends Components> = EntityData<C>
+
+export type EurekaSchema<C extends Components> = {
+	state: EntityData<C>[]
+	delta: Delta<C>[]
+	input: InputEntry[]
+}
+

package/s/_archive/eureka/integration/utils/inputs.ts

@@ -0,0 +1,24 @@
+
+import {MapG} from "@e280/stz"
+import {InputEntry} from "../types.js"
+import {EntityId} from "../../parts/types.js"
+
+export class Inputs {
+	#inbox = new MapG<EntityId, unknown[]>()
+
+	add(entries: InputEntry[]) {
+		for (const [id, newInputs] of entries) {
+			const inputs = this.#inbox.guarantee(id, () => [])
+			inputs.push(...newInputs)
+		}
+	}
+
+	read<Input = unknown>(id: EntityId) {
+		return (this.#inbox.get(id) ?? []) as Input[]
+	}
+
+	clear() {
+		this.#inbox.clear()
+	}
+}
+

package/s/_archive/eureka/integration/utils/relevance.ts

@@ -0,0 +1,10 @@
+
+import {EntityId} from "../../parts/types.js"
+import {AuthorId} from "../../../core/types.js"
+
+export class Relevance {
+	check(_authorId: AuthorId, _entityId: EntityId) {
+		return true
+	}
+}
+

package/s/_archive/eureka/parts/entity.ts

@@ -0,0 +1,37 @@
+
+import {Components, EntityId, EntityData} from "./types.js"
+
+export class Entity<C extends Components = any> {
+	static setComponents(entity: Entity, components: Components) {
+		entity.#components = new Proxy(components, {
+			set: (target: any, key: string, value: any) => {
+				if (value === undefined) delete target[key]
+				else target[key] = value
+				entity.onChange()
+				return true
+			},
+			deleteProperty: (target: any, key: string) => {
+				delete target[key]
+				entity.onChange()
+				return true
+			},
+		})
+	}
+
+	#components!: C
+	get components() { return this.#components }
+
+	constructor(
+		public readonly id: EntityId,
+		private onChange: () => void,
+	) {}
+
+	write() {
+		this.onChange()
+	}
+
+	data() {
+		return [this.id, this.components] as EntityData<C>
+	}
+}
+

package/s/_archive/eureka/parts/system.ts

@@ -0,0 +1,38 @@
+
+import {MapG} from "@e280/stz"
+import {Entity} from "./entity.js"
+import {World} from "./world.js"
+import {SystemFn, UnknownComponents} from "./types.js"
+
+export class System {
+	#cacheMap = new MapG<number, Entity>()
+	#cacheArray: Entity[] = []
+
+	constructor(
+		public label: string,
+		public keys: any[],
+		public keysOptional: any[],
+		public fn: SystemFn<any, any, any, any>,
+	) {}
+
+	execute(world: World<any, any>) {
+		this.fn(this.#cacheArray, world)
+	}
+
+	cache(id: number, entity: Entity | null) {
+		if (entity) {
+			if (this.#matching(entity)) this.#cacheMap.set(id, entity)
+			else this.#cacheMap.delete(id)
+			this.#cacheArray = [...this.#cacheMap.values()]
+		}
+		else {
+			this.#cacheMap.delete(id)
+			this.#cacheArray = [...this.#cacheMap.values()]
+		}
+	}
+
+	#matching(entity: UnknownComponents) {
+		return this.keys.every(requiredKey => requiredKey in entity.components)
+	}
+}
+

package/s/_archive/eureka/parts/types.ts

@@ -0,0 +1,21 @@
+
+import {World} from "./world.js"
+import {Entity} from "./entity.js"
+
+export type Components = Record<string, any>
+export type EntityId = number
+
+export type EntityData<C extends Components = any> = [EntityId, UnknownComponents<C> | null]
+export type UnknownComponents<C extends Components = any> = Partial<C>
+export type SpecificComponents<C extends Components, K extends keyof C> = {[X in K]: C[X]}
+
+export type FancySelect<C extends Components, K extends keyof C, K2 extends (keyof C) | undefined> = (
+	K2 extends keyof C
+		? Entity<SpecificComponents<C, K> & Partial<SpecificComponents<C, K2>>>
+		: Entity<SpecificComponents<C, K>>
+)
+
+export type SystemFn<Context, C extends Components, K extends keyof C, K2 extends (keyof C) | undefined> = (
+	(entities: FancySelect<C, K, K2>[], world: World<Context, C>) => void
+)
+

package/s/_archive/eureka/parts/world.ts

@@ -0,0 +1,140 @@
+
+import {deep, MapG, sub} from "@e280/stz"
+import {System} from "./system.js"
+import {Entity} from "./entity.js"
+import {IdCounter} from "../../tools/id-counter.js"
+import {Components, EntityId, EntityData, UnknownComponents} from "./types.js"
+
+export class World<Context, C extends Components> {
+	counter = new IdCounter()
+	on = sub<[EntityId, Entity<UnknownComponents<C>> | null]>()
+
+	#entities = new MapG<EntityId, Entity<Partial<C>>>()
+	#changed = new Set<EntityId>()
+
+	constructor(public context: Context, private systems: System[]) {}
+
+	/** iterate all entities */
+	all() {
+		return this.#entities.values()
+	}
+
+	/** iterate all entity ids */
+	ids() {
+		return this.#entities.keys()
+	}
+
+	/** get an entity by id (return null if not found) */
+	get<C2 extends Partial<C2>>(id: number) {
+		return (this.#entities.get(id) ?? null) as Entity<C2> | null
+	}
+
+	/** get an entity by id (throw an error if not found) */
+	require<C2 extends Partial<C2>>(id: number) {
+		return this.#entities.require(id) as unknown as C2
+	}
+
+	/** create, update, or delete an entity */
+	write<C2 extends Partial<C>>(id: number, components: C2 | null) {
+		if (components) {
+			const onChange = () => this.#changed.add(id)
+
+			// get or create entity
+			const entity = this.#entities.guarantee(
+				id,
+				() => new Entity(id, onChange),
+			) as Entity<C2>
+
+			Entity.setComponents(entity, components)
+
+			// initialize the systems cache for this entity
+			for (const system of this.systems)
+				system.cache(id, entity)
+
+			// recognize that a change happened
+			this.on.pub(id, entity)
+			return entity
+		}
+		else {
+			// delete the entity
+			this.#entities.delete(id)
+
+			// update the cache
+			for (const system of this.systems)
+				system.cache(id, null)
+
+			// recognize that a change happened
+			this.on.pub(id, null)
+			return null
+		}
+	}
+
+	/** create a new entity */
+	create<C2 extends Partial<C>>(components: C2) {
+		const id = this.counter.next()
+		return this.write(id, components)!
+	}
+
+	/** update or create an entity */
+	update<C2 extends Partial<C>>(id: number, components: C2) {
+		return this.write(id, components) as Entity<C2>
+	}
+
+	/** delete an entity, dispatching relevant pubsubs */
+	delete(id: number) {
+		return this.write(id, null)
+	}
+
+	/** iterate all entity data */
+	*data() {
+		for (const entity of this.all())
+			yield entity.data()
+	}
+
+	/** delete everything */
+	clear() {
+		for (const id of [...this.#entities.keys()])
+			this.delete(id)
+	}
+
+	/** forget everything and start from a new state */
+	overwrite(data: EntityData<C>[]) {
+		for (const [id, components] of data)
+			this.write(id, components)
+	}
+
+	/** execute all systems (and maintain caching stuff) */
+	execute() {
+		// execute all systems
+		for (const system of this.systems) {
+			system.execute(this)
+
+			// update all system caches for changes
+			for (const id of this.#changed) {
+				const entity = this.get(id)
+				for (const system of this.systems)
+					system.cache(id, entity)
+			}
+		}
+
+		// dispatch all pent up changes
+		for (const id of this.#changed)
+			this.on.pub(id, this.get(id))
+
+		// clear changes
+		this.#changed.clear()
+	}
+
+	/** create a new downstream clone world that stays synchronized with this one */
+	replicate(
+			context: Context,
+			systems: System[],
+		) {
+		const downstream = new World<Context, C>(context, systems)
+		const detach = this.on((id, entity) => {
+			downstream.write(id, deep.clone(entity?.components ?? null))
+		})
+		return [downstream, detach]
+	}
+}
+

package/s/_archive/eureka/testing/eureka.test.ts

@@ -0,0 +1,27 @@
+
+import {Science, test, expect} from "@e280/science"
+import {setupHealthSituation} from "./situations/health.js"
+
+export default Science.suite({
+	"systems can execute on the right entities": test(async() => {
+		const {world} = setupHealthSituation()
+		const warrior = world.create({health: 100, bleeding: 1})
+		const wizard = world.create({health: 100, mana: 0, manaRegen: 1})
+		expect(warrior.components.health).is(100)
+		expect(wizard.components.health).is(100)
+		world.execute()
+		expect(warrior.components.health).is(99)
+		expect(wizard.components.health).is(100)
+	}),
+
+	"warrior can bleed out, gets deleted": test(async() => {
+		const {world} = setupHealthSituation()
+		const warrior = world.create({health: 2, bleeding: 1})
+		expect(world.get(warrior.id)).ok()
+		world.execute()
+		expect(world.get(warrior.id)).ok()
+		world.execute()
+		expect(world.get(warrior.id)).not.ok()
+	}),
+})
+

package/s/_archive/eureka/testing/integration.test.ts

@@ -0,0 +1,40 @@
+
+import {loop} from "@e280/stz"
+import {Science, test, expect} from "@e280/science"
+
+import {EasyHost} from "../../sugar/easy-host.js"
+import {setupEurekaDemo} from "./situations/integration.js"
+import {EurekaSimulator} from "../integration/simulator.js"
+
+export default Science.suite({
+
+	"we host a game, we join it": test(async() => {
+		const host = new EasyHost({
+			hz: 10,
+			makeSimulator: () => {
+				const {world} = setupEurekaDemo()
+				return new EurekaSimulator(world)
+			},
+		})
+		const client = await host.localClient()
+
+		const {world} = host.session.simulator
+		const warrior = world.create({health: 100, bleeding: 1})
+
+		for (const _ of loop(50)) {
+			host.session.authority.tick()
+			client.speculator.tick()
+		}
+
+		expect(warrior.components.health).is(50)
+
+		// TODO wut?
+		// // FAILS HERE, component not found
+		// const clientWarrior = client.pastSimulator.world
+		// 	.require<typeof warrior.components>(warrior.id)
+		//
+		// expect(clientWarrior).ok()
+		// expect(clientWarrior.health).is(50)
+	}),
+})
+

package/s/_archive/eureka/testing/situations/health.ts

@@ -0,0 +1,43 @@
+
+import {setupEureka} from "../../eureka.js"
+
+class MyContext {}
+
+type MyComponents = {
+	health: number
+	bleeding: number
+	mana: number
+	manaRegen: number
+}
+
+export function setupHealthSituation() {
+	const eureka = setupEureka<MyContext, MyComponents>()
+
+	const world = eureka.world(new MyContext(), [
+		eureka.system("health")
+			.select("health").andMaybe("bleeding")
+			.fn((entities, world) => {
+				for (const {id, components} of entities) {
+
+					// process bleeding
+					if (components.bleeding)
+						components.health -= components.bleeding
+
+					// process death
+					if (components.health <= 0)
+						world.delete(id)
+				}
+			}),
+
+		eureka.system("mana")
+			.select("mana").andMaybe("manaRegen")
+			.fn((entities, _world) => {
+				for (const {components} of entities)
+					if (components.manaRegen)
+						components.mana += components.manaRegen
+			}),
+	])
+
+	return {world}
+}
+