(
+ namespace: string,
+ ...keys: K[]
+ ): { [P in K as CamelCase]: string } {
+ return Object.fromEntries(
+ keys.map(k => [toCamel(k), Events.getKey(namespace, k)])
+ ) as { [P in K as CamelCase
]: string };
+ }
+
+ static parseKey(key: string): { namespace: string; key: string } {
+ const index = key.indexOf('/');
+ if (index === -1) {
+ throw new Error(`Invalid event key: "${key}"`);
+ }
+ return {
+ namespace: key.slice(0, index),
+ key: key.slice(index + 1),
+ };
+ }
+
+ static dispatch(event: GameEvent): Pipe {
+ return pendingLens.over(pending => [...pending, event], []);
+ }
+
+ static handle(
+ type: string,
+ fn: (event: GameEvent) => Pipe
+ ): Pipe {
+ const { namespace, key } = Events.parseKey(type);
+ const isWildcard = key === '*';
+ const prefix = namespace + '/';
+
+ return (obj: GameFrame): GameFrame => {
+ const state = eventStateLens.get(obj);
+ const current = state?.current;
+ if (!current || current.length === 0) return obj;
+ let result: GameFrame = obj;
+ for (const event of current) {
+ if (isWildcard ? event.type.startsWith(prefix) : event.type === type) {
+ result = fn(event as GameEvent)(result);
+ }
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Moves events from pending to current.
+ * This prevents events from being processed during the same frame they are created.
+ * This is important because pipes later in the pipeline may add new events.
+ */
+ static pipe: Pipe = Composer.over(events, ({ pending = [] }) => ({
+ pending: [],
+ current: pending,
+ }));
+}
diff --git a/src/engine/pipes/Perf.ts b/src/engine/pipes/Perf.ts
new file mode 100644
index 00000000..ea049425
--- /dev/null
+++ b/src/engine/pipes/Perf.ts
@@ -0,0 +1,171 @@
+import { Composer } from '../Composer';
+import { GameFrame, Pipe } from '../State';
+import { Events, type GameEvent } from './Events';
+import { pluginPaths, PluginId } from '../plugins/Plugins';
+import { typedPath } from '../Lens';
+import { sdk } from '../sdk';
+
+declare module '../sdk' {
+ interface SDK {
+ Perf: typeof Perf;
+ }
+}
+
+export type PluginPerfEntry = {
+ last: number;
+ avg: number;
+ max: number;
+ samples: number[];
+ lastTick: number;
+};
+
+export type PerfMetrics = Record>;
+
+export type PerfConfig = {
+ pluginBudget: number;
+};
+
+export type PerfContext = {
+ plugins: PerfMetrics;
+ config: PerfConfig;
+};
+
+const PLUGIN_NAMESPACE = 'core.perf';
+const SAMPLE_SIZE = 60;
+const EXPIRY_TICKS = 900;
+
+const DEFAULT_CONFIG: PerfConfig = {
+ pluginBudget: 1,
+};
+
+type OverBudgetPayload = {
+ id: string;
+ phase: string;
+ duration: number;
+ budget: number;
+};
+
+const eventType = Events.getKeys(PLUGIN_NAMESPACE, 'over_budget', 'configure');
+
+const perf = pluginPaths(PLUGIN_NAMESPACE);
+const frameTiming = typedPath([]);
+
+function isEntry(value: unknown): value is PluginPerfEntry {
+ return value != null && typeof value === 'object' && 'lastTick' in value;
+}
+
+function pruneExpired(
+ node: Record,
+ tick: number
+): [Record | undefined, boolean] {
+ let dirty = false;
+ const result: Record = {};
+
+ for (const [key, value] of Object.entries(node)) {
+ if (isEntry(value)) {
+ if (tick - value.lastTick <= EXPIRY_TICKS) {
+ result[key] = value;
+ } else {
+ dirty = true;
+ }
+ } else if (value && typeof value === 'object') {
+ const [pruned, changed] = pruneExpired(
+ value as Record,
+ tick
+ );
+ if (pruned) result[key] = pruned;
+ else dirty = true;
+ if (changed) dirty = true;
+ }
+ }
+
+ const empty = Object.keys(result).length === 0;
+ return [empty ? undefined : result, dirty];
+}
+
+export class Perf {
+ static withTiming(id: PluginId, phase: string, pluginPipe: Pipe): Pipe {
+ return Composer.do(({ get, set, pipe }) => {
+ if (!sdk.debug) {
+ pipe(pluginPipe);
+ return;
+ }
+
+ const before = performance.now();
+ pipe(pluginPipe);
+ const after = performance.now();
+ const duration = after - before;
+
+ const tick = get(frameTiming.tick) ?? 0;
+ const entryPath = perf.plugins[id][phase];
+ const entry = get(entryPath);
+
+ const samples = entry
+ ? [...entry.samples, duration].slice(-SAMPLE_SIZE)
+ : [duration];
+
+ const avg = samples.reduce((sum, v) => sum + v, 0) / samples.length;
+ const max = entry ? Math.max(entry.max, duration) : duration;
+
+ set(entryPath, { last: duration, avg, max, samples, lastTick: tick });
+
+ const budget =
+ get(perf.config.pluginBudget) ?? DEFAULT_CONFIG.pluginBudget;
+
+ if (duration > budget) {
+ console.warn(
+ `[perf] ${id} ${phase} took ${duration.toFixed(2)}ms (budget: ${budget}ms)`
+ );
+ pipe(
+ Events.dispatch({
+ type: eventType.overBudget,
+ payload: { id, phase, duration, budget },
+ })
+ );
+ }
+ });
+ }
+
+ static configure(config: Partial): Pipe {
+ return Events.dispatch({
+ type: eventType.configure,
+ payload: config,
+ });
+ }
+
+ static onOverBudget(fn: (event: GameEvent) => Pipe): Pipe {
+ return Events.handle(eventType.overBudget, fn);
+ }
+
+ static pipe: Pipe = Composer.pipe(
+ Composer.do(({ get, set }) => {
+ if (!get(perf.config)) {
+ set(perf.config, DEFAULT_CONFIG);
+ }
+ }),
+
+ Composer.do(({ get, set }) => {
+ const tick = get(frameTiming.tick) ?? 0;
+ const plugins = get(perf.plugins);
+ if (!plugins) return;
+
+ const [pruned, dirty] = pruneExpired(plugins, tick);
+ if (dirty) {
+ set(perf.plugins, pruned ?? {});
+ }
+ }),
+
+ Events.handle>(eventType.configure, event =>
+ Composer.over(perf.config, (config = DEFAULT_CONFIG) => ({
+ ...config,
+ ...event.payload,
+ }))
+ )
+ );
+
+ static get paths() {
+ return perf;
+ }
+}
+
+sdk.Perf = Perf;
diff --git a/src/engine/pipes/Scheduler.ts b/src/engine/pipes/Scheduler.ts
new file mode 100644
index 00000000..61dab9c3
--- /dev/null
+++ b/src/engine/pipes/Scheduler.ts
@@ -0,0 +1,148 @@
+import { Composer } from '../Composer';
+import { typedPath } from '../Lens';
+import { pluginPaths } from '../plugins/Plugins';
+import { GameTiming, Pipe } from '../State';
+import { Events, GameEvent } from './Events';
+
+const PLUGIN_NAMESPACE = 'core.scheduler';
+
+export type ScheduledEvent = {
+ id?: string;
+ duration: number;
+ event: GameEvent;
+ held?: boolean;
+};
+
+type SchedulerState = {
+ scheduled: ScheduledEvent[];
+ current: GameEvent[];
+};
+
+const scheduler = pluginPaths(PLUGIN_NAMESPACE);
+const timing = typedPath([]);
+
+const eventType = Events.getKeys(
+ PLUGIN_NAMESPACE,
+ 'schedule',
+ 'cancel',
+ 'hold',
+ 'release',
+ 'hold_by_prefix',
+ 'release_by_prefix',
+ 'cancel_by_prefix'
+);
+
+export class Scheduler {
+ static getKey(namespace: string, key: string): string {
+ return `${namespace}/schedule/${key}`;
+ }
+
+ // These API methods are events to ensure they dont have weird ordering problems.
+ // TODO: re-evaluate this decision
+
+ static schedule(event: ScheduledEvent): Pipe {
+ return Events.dispatch({ type: eventType.schedule, payload: event });
+ }
+
+ static cancel(id: string): Pipe {
+ return Events.dispatch({ type: eventType.cancel, payload: id });
+ }
+
+ static hold(id: string): Pipe {
+ return Events.dispatch({ type: eventType.hold, payload: id });
+ }
+
+ static release(id: string): Pipe {
+ return Events.dispatch({ type: eventType.release, payload: id });
+ }
+
+ static holdByPrefix(prefix: string): Pipe {
+ return Events.dispatch({ type: eventType.holdByPrefix, payload: prefix });
+ }
+
+ static releaseByPrefix(prefix: string): Pipe {
+ return Events.dispatch({
+ type: eventType.releaseByPrefix,
+ payload: prefix,
+ });
+ }
+
+ static cancelByPrefix(prefix: string): Pipe {
+ return Events.dispatch({ type: eventType.cancelByPrefix, payload: prefix });
+ }
+
+ static pipe: Pipe = Composer.pipe(
+ Composer.bind(timing.step, delta =>
+ Composer.over(scheduler, ({ scheduled = [] }) => {
+ const remaining: ScheduledEvent[] = [];
+ const current: GameEvent[] = [];
+
+ for (const entry of scheduled) {
+ if (entry.held) {
+ remaining.push(entry);
+ continue;
+ }
+ const time = entry.duration - delta;
+ if (time <= 0) {
+ current.push(entry.event);
+ } else {
+ remaining.push({ ...entry, duration: time });
+ }
+ }
+
+ return { scheduled: remaining, current };
+ })
+ ),
+
+ Composer.bind(scheduler.current, events =>
+ Composer.pipe(...events.map(Events.dispatch))
+ ),
+
+ Events.handle(eventType.schedule, event =>
+ Composer.over(scheduler.scheduled, list => [
+ ...list.filter(e => e.id !== event.payload.id),
+ event.payload,
+ ])
+ ),
+
+ Events.handle(eventType.cancel, event =>
+ Composer.over(scheduler.scheduled, list =>
+ list.filter(s => s.id !== event.payload)
+ )
+ ),
+
+ Events.handle(eventType.hold, event =>
+ Composer.over(scheduler.scheduled, list =>
+ list.map(s => (s.id === event.payload ? { ...s, held: true } : s))
+ )
+ ),
+
+ Events.handle(eventType.release, event =>
+ Composer.over(scheduler.scheduled, list =>
+ list.map(s => (s.id === event.payload ? { ...s, held: false } : s))
+ )
+ ),
+
+ Events.handle(eventType.holdByPrefix, event =>
+ Composer.over(scheduler.scheduled, list =>
+ list.map(s =>
+ s.id?.startsWith(event.payload) ? { ...s, held: true } : s
+ )
+ )
+ ),
+
+ Events.handle(eventType.releaseByPrefix, event =>
+ Composer.over(scheduler.scheduled, list =>
+ list.map(s =>
+ s.id?.startsWith(event.payload) ? { ...s, held: false } : s
+ )
+ )
+ ),
+
+ Events.handle(eventType.cancelByPrefix, event =>
+ Composer.over(scheduler.scheduled, list =>
+ list.filter(s => !s.id?.startsWith(event.payload))
+ )
+ )
+ );
+}
diff --git a/src/engine/pipes/Storage.ts b/src/engine/pipes/Storage.ts
new file mode 100644
index 00000000..12c75668
--- /dev/null
+++ b/src/engine/pipes/Storage.ts
@@ -0,0 +1,146 @@
+/**
+ * Storage Pipe
+ *
+ * Primitive pipe that provides access to localStorage.
+ * Uses lazy loading with time-based cache (hot settings).
+ *
+ * Architecture:
+ * - Settings are loaded on-demand from localStorage
+ * - Cached in context with expiry time (measured in game time)
+ * - Hot cache expires after inactivity to save memory
+ * - Writes are immediate to localStorage and update cache
+ */
+
+import { Composer } from '../Composer';
+import { typedPath } from '../Lens';
+import { pluginPaths } from '../plugins/Plugins';
+import { GameTiming, Pipe } from '../State';
+
+export const STORAGE_NAMESPACE = 'how.joi.storage';
+const CACHE_TTL = 30000; // 30 seconds of game time
+
+export type CacheEntry = {
+ value: any;
+ expiry: number; // game time when this expires
+};
+
+export type StorageContext = {
+ cache: { [key: string]: CacheEntry };
+};
+
+const storage = pluginPaths(STORAGE_NAMESPACE);
+const timing = typedPath([]);
+
+/**
+ * Storage API for reading and writing to localStorage
+ */
+export class Storage {
+ /**
+ * Loads a value from localStorage
+ */
+ private static load(key: string): T | undefined {
+ try {
+ const value = localStorage.getItem(key);
+ if (value !== null) {
+ return JSON.parse(value) as T;
+ }
+ } catch (e) {
+ console.error(`Failed to load from localStorage key "${key}":`, e);
+ }
+ return undefined;
+ }
+
+ /**
+ * Gets a value, using cache or loading from localStorage
+ */
+ static bind(key: string, fn: (value: T | undefined) => Pipe): Pipe {
+ return Composer.bind(storage, ctx => {
+ const cache = ctx?.cache || {};
+ const cached = cache[key];
+
+ if (cached) {
+ return fn(cached.value as T | undefined);
+ }
+
+ const value = Storage.load(key);
+
+ return Composer.pipe(
+ Composer.bind(timing.time, elapsedTime =>
+ Composer.over(storage, ctx => ({
+ cache: {
+ ...(ctx?.cache || {}),
+ [key]: {
+ value,
+ expiry: elapsedTime + CACHE_TTL,
+ },
+ },
+ }))
+ ),
+ fn(value)
+ );
+ });
+ }
+
+ /**
+ * Sets a value in localStorage and updates cache
+ */
+ static set(key: string, value: T): Pipe {
+ return frame => {
+ try {
+ localStorage.setItem(key, JSON.stringify(value));
+ } catch (e) {
+ console.error('Failed to write to localStorage:', e);
+ }
+
+ return Composer.bind(timing.time, elapsedTime =>
+ Composer.over(storage, ctx => ({
+ cache: {
+ ...(ctx?.cache || {}),
+ [key]: {
+ value,
+ expiry: elapsedTime + CACHE_TTL,
+ },
+ },
+ }))
+ )(frame);
+ };
+ }
+
+ /**
+ * Removes a value from localStorage and cache
+ */
+ static remove(key: string): Pipe {
+ return frame => {
+ try {
+ localStorage.removeItem(key);
+ } catch (e) {
+ console.error('Failed to remove from localStorage:', e);
+ }
+
+ return Composer.over(storage, ctx => {
+ const newCache = { ...(ctx?.cache || {}) };
+ delete newCache[key];
+ return { cache: newCache };
+ })(frame);
+ };
+ }
+
+ /**
+ * Storage pipe - evicts expired cache entries
+ */
+ static pipe: Pipe = Composer.pipe(
+ Composer.bind(timing.time, elapsedTime =>
+ Composer.over(storage, ctx => {
+ const newCache: { [key: string]: CacheEntry } = {};
+
+ for (const [key, entry] of Object.entries(ctx?.cache || {})) {
+ if (entry.expiry > elapsedTime) {
+ newCache[key] = entry;
+ }
+ }
+
+ return { cache: newCache };
+ })
+ )
+ );
+}
diff --git a/src/engine/pipes/index.ts b/src/engine/pipes/index.ts
new file mode 100644
index 00000000..3bf0322e
--- /dev/null
+++ b/src/engine/pipes/index.ts
@@ -0,0 +1,8 @@
+export * from './Events';
+export * from '../plugins/PluginInstaller';
+export * from '../plugins/PluginManager';
+export * from '../plugins/Plugins';
+export * from './Scheduler';
+export * from './Storage';
+export * from './Perf';
+export * from './Errors';
diff --git a/src/engine/plugins/PluginInstaller.ts b/src/engine/plugins/PluginInstaller.ts
new file mode 100644
index 00000000..9c498f07
--- /dev/null
+++ b/src/engine/plugins/PluginInstaller.ts
@@ -0,0 +1,141 @@
+import { Composer } from '../Composer';
+import { Pipe } from '../State';
+import { Storage } from '../pipes/Storage';
+import { PluginManager } from './PluginManager';
+import { pluginPaths, type PluginId, type PluginClass } from './Plugins';
+
+const PLUGIN_NAMESPACE = 'core.plugin_installer';
+
+type PluginLoad = {
+ promise: Promise;
+ result?: PluginClass;
+ error?: Error;
+};
+
+type InstallerState = {
+ installed: PluginId[];
+ failed: PluginId[];
+ pending: Map;
+};
+
+const ins = pluginPaths(PLUGIN_NAMESPACE);
+
+const storageKey = {
+ user: `${PLUGIN_NAMESPACE}.user`,
+ code: (id: PluginId) => `${PLUGIN_NAMESPACE}.code/${id}`,
+};
+
+async function load(code: string): Promise {
+ const blob = new Blob([code], { type: 'text/javascript' });
+ const url = URL.createObjectURL(blob);
+
+ try {
+ const module = await import(/* @vite-ignore */ url);
+ const cls = module.default;
+
+ if (!cls?.plugin?.id) {
+ throw new Error(
+ 'Plugin must export a default class with a static plugin field'
+ );
+ }
+
+ return cls;
+ } finally {
+ URL.revokeObjectURL(url);
+ }
+}
+
+const importPipe: Pipe = Storage.bind(
+ storageKey.user,
+ (userPluginIds = []) =>
+ Composer.pipe(
+ ...userPluginIds.map(id =>
+ Storage.bind(storageKey.code(id), code =>
+ Composer.do(({ get, over }) => {
+ const installed = get(ins.installed) ?? [];
+ const failed = get(ins.failed) ?? [];
+ const pending = get(ins.pending);
+
+ if (
+ installed.includes(id) ||
+ failed.includes(id) ||
+ pending?.has(id)
+ )
+ return;
+
+ if (!code) {
+ console.error(
+ `[PluginInstaller] plugin "${id}" has no code in storage`
+ );
+ over(ins.failed, (ids = []) => [
+ ...(Array.isArray(ids) ? ids : []),
+ id,
+ ]);
+ return;
+ }
+
+ over(ins.pending, pending => {
+ if (!(pending instanceof Map)) pending = new Map();
+ // TODO: generic async resolver pipe?
+ const pluginLoad: PluginLoad = {
+ promise: load(code),
+ };
+ pluginLoad.promise.then(
+ plugin => {
+ pluginLoad.result = plugin;
+ },
+ error => {
+ pluginLoad.error = error;
+ }
+ );
+ return new Map([...pending, [id, pluginLoad]]);
+ });
+ })
+ )
+ )
+ )
+);
+
+const resolvePipe: Pipe = Composer.do(({ get, set, over, pipe }) => {
+ const pending = get(ins.pending);
+ if (!pending?.size) return;
+
+ const resolved: PluginClass[] = [];
+ const failed: PluginId[] = [];
+ const remaining = new Map();
+
+ for (const [id, entry] of pending) {
+ if (entry.result) {
+ resolved.push(entry.result);
+ } else if (entry.error) {
+ console.error(
+ `[PluginInstaller] failed to load plugin "${id}":`,
+ entry.error
+ );
+ failed.push(id);
+ } else {
+ remaining.set(id, entry);
+ }
+ }
+
+ if (resolved.length > 0) {
+ pipe(...resolved.map(PluginManager.register));
+ over(ins.installed, (ids = []) => [
+ ...(Array.isArray(ids) ? ids : []),
+ ...resolved.map(cls => cls.plugin.id),
+ ]);
+ }
+
+ if (failed.length > 0) {
+ over(ins.failed, (ids = []) => [
+ ...(Array.isArray(ids) ? ids : []),
+ ...failed,
+ ]);
+ }
+
+ if (remaining.size !== pending.size) {
+ set(ins.pending, remaining);
+ }
+});
+
+export const pluginInstallerPipe: Pipe = Composer.pipe(importPipe, resolvePipe);
diff --git a/src/engine/plugins/PluginManager.ts b/src/engine/plugins/PluginManager.ts
new file mode 100644
index 00000000..cfdfe94b
--- /dev/null
+++ b/src/engine/plugins/PluginManager.ts
@@ -0,0 +1,283 @@
+import { Composer } from '../Composer';
+import { Pipe, PipeTransformer } from '../State';
+import {
+ startDOMBatching,
+ stopDOMBatching,
+ flushDOMOperations,
+} from '../DOMBatcher';
+import { Storage } from '../pipes/Storage';
+import { Events } from '../pipes/Events';
+import {
+ pluginPaths,
+ type PluginId,
+ type PluginClass,
+ type PluginRegistry,
+ type EnabledMap,
+} from './Plugins';
+import { Perf } from '../pipes/Perf';
+import { Errors } from '../pipes/Errors';
+import { sdk } from '../sdk';
+
+const PLUGIN_NAMESPACE = 'core.plugin_manager';
+
+const eventType = Events.getKeys(
+ PLUGIN_NAMESPACE,
+ 'register',
+ 'unregister',
+ 'enable',
+ 'disable'
+);
+
+const storageKey = {
+ enabled: `${PLUGIN_NAMESPACE}.enabled`,
+};
+
+export type PluginManagerAPI = {
+ register: PipeTransformer<[PluginClass]>;
+ unregister: PipeTransformer<[PluginId]>;
+ enable: PipeTransformer<[PluginId]>;
+ disable: PipeTransformer<[PluginId]>;
+};
+
+type PluginManagerState = PluginManagerAPI & {
+ loaded: PluginId[];
+ registry: PluginRegistry;
+ loadedRefs: Record;
+ toLoad: PluginId[];
+ toUnload: PluginId[];
+};
+
+const pm = pluginPaths(PLUGIN_NAMESPACE);
+
+export class PluginManager {
+ static register(pluginClass: PluginClass): Pipe {
+ return Composer.bind(pm, ({ register }) => register(pluginClass));
+ }
+
+ static unregister(id: PluginId): Pipe {
+ return Composer.bind(pm, ({ unregister }) => unregister(id));
+ }
+
+ static enable(id: PluginId): Pipe {
+ return Composer.bind(pm, ({ enable }) => enable(id));
+ }
+
+ static disable(id: PluginId): Pipe {
+ return Composer.bind(pm, ({ disable }) => disable(id));
+ }
+}
+
+const apiPipe: Pipe = Composer.over(pm, ctx => ({
+ ...ctx,
+
+ register: plugin =>
+ Events.dispatch({
+ type: eventType.register,
+ payload: plugin,
+ }),
+
+ unregister: id =>
+ Events.dispatch({
+ type: eventType.unregister,
+ payload: id,
+ }),
+
+ enable: id =>
+ Events.dispatch({
+ type: eventType.enable,
+ payload: id,
+ }),
+
+ disable: id =>
+ Events.dispatch({
+ type: eventType.disable,
+ payload: id,
+ }),
+}));
+
+// TODO: enable/disable plugin storage should probably live elsewhere.
+const enableDisablePipe: Pipe = Composer.pipe(
+ Events.handle(eventType.enable, event =>
+ Storage.bind(storageKey.enabled, (map = {}) =>
+ Storage.set(storageKey.enabled, {
+ ...map,
+ [event.payload]: true,
+ })
+ )
+ ),
+ Events.handle(eventType.disable, event =>
+ Storage.bind(storageKey.enabled, (map = {}) =>
+ Storage.set(storageKey.enabled, {
+ ...map,
+ [event.payload]: false,
+ })
+ )
+ )
+);
+
+const reconcilePipe: Pipe = Composer.pipe(
+ Events.handle(eventType.register, event =>
+ Composer.do(({ over }) => {
+ over(pm.registry, registry => ({
+ ...registry,
+ [event.payload.plugin.id]: event.payload,
+ }));
+ })
+ ),
+ Events.handle(eventType.unregister, event =>
+ Composer.do(({ over }) => {
+ over(pm.toUnload, (ids = []) =>
+ Array.isArray(ids) ? [...ids, event.payload] : [event.payload]
+ );
+ })
+ ),
+ Storage.bind(storageKey.enabled, (stored = {}) =>
+ Composer.do(({ get, set, pipe }) => {
+ const registry = get(pm.registry) ?? {};
+ const loaded = get(pm.loaded) ?? [];
+ const forcedUnload = get(pm.toUnload) ?? [];
+
+ const map = { ...stored };
+ let dirty = false;
+
+ for (const id of Object.keys(registry)) {
+ if (!(id in map)) {
+ map[id] = true;
+ dirty = true;
+ }
+ }
+
+ const shouldBeLoaded = new Set(
+ Object.keys(map).filter(id => map[id] && registry[id])
+ );
+
+ for (const id of forcedUnload) shouldBeLoaded.delete(id);
+
+ const currentlyLoaded = new Set(loaded);
+
+ const toUnload = [...currentlyLoaded].filter(
+ id => !shouldBeLoaded.has(id)
+ );
+
+ const toLoad = [...shouldBeLoaded].filter(id => !currentlyLoaded.has(id));
+
+ if (!dirty && toLoad.length === 0 && toUnload.length === 0) return;
+
+ if (dirty) pipe(Storage.set(storageKey.enabled, map));
+ if (toLoad.length > 0) set(pm.toLoad, toLoad);
+ if (toUnload.length > 0) set(pm.toUnload, toUnload);
+ })
+ )
+);
+
+const lifecyclePipe: Pipe = Composer.do(({ get, pipe }) => {
+ const toUnload = get(pm.toUnload) ?? [];
+ const toLoad = get(pm.toLoad) ?? [];
+ const loadedRefs = get(pm.loadedRefs) ?? {};
+ const registry = get(pm.registry) ?? {};
+
+ for (const id of toUnload) {
+ const cls = loadedRefs[id] ?? registry[id];
+ if (cls) delete (sdk as any)[cls.name];
+ }
+
+ for (const id of toLoad) {
+ const cls = registry[id];
+ if (cls) (sdk as any)[cls.name] = cls;
+ }
+
+ const deactivates = toUnload
+ .map(id => {
+ const p = (loadedRefs[id] ?? registry[id])?.plugin.deactivate;
+ return p
+ ? Perf.withTiming(
+ id,
+ 'deactivate',
+ Errors.withCatch(id, 'deactivate', p)
+ )
+ : undefined;
+ })
+ .filter(Boolean) as Pipe[];
+
+ const activates = toLoad
+ .map(id => {
+ const p = registry[id]?.plugin.activate;
+ return p
+ ? Perf.withTiming(id, 'activate', Errors.withCatch(id, 'activate', p))
+ : undefined;
+ })
+ .filter(Boolean) as Pipe[];
+
+ const activeIds = [
+ ...Object.keys(loadedRefs).filter(id => !toUnload.includes(id)),
+ ...toLoad,
+ ];
+
+ const updates = activeIds
+ .map(id => {
+ const p = (loadedRefs[id] ?? registry[id])?.plugin.update;
+ return p
+ ? Perf.withTiming(id, 'update', Errors.withCatch(id, 'update', p))
+ : undefined;
+ })
+ .filter(Boolean) as Pipe[];
+
+ const pipes = [...deactivates, ...activates, ...updates];
+ if (pipes.length === 0) return;
+
+ startDOMBatching();
+ pipe(...pipes);
+ stopDOMBatching();
+ flushDOMOperations();
+});
+
+const finalizePipe: Pipe = Composer.pipe(
+ Events.handle(eventType.unregister, event =>
+ Composer.do(({ over }) => {
+ over(pm.registry, registry => {
+ const next = { ...registry };
+ delete next[event.payload];
+ return next;
+ });
+ })
+ ),
+ Composer.do(({ get, set, over }) => {
+ const toUnload = get(pm.toUnload) ?? [];
+ const toLoad = get(pm.toLoad) ?? [];
+
+ if (toLoad.length === 0 && toUnload.length === 0) return;
+
+ const loadedRefs = get(pm.loadedRefs) ?? {};
+ const registry = get(pm.registry) ?? {};
+
+ const newRefs = { ...loadedRefs };
+ for (const id of toUnload) delete newRefs[id];
+ for (const id of toLoad) {
+ if (registry[id]) newRefs[id] = registry[id];
+ }
+
+ set(pm.loaded, Object.keys(newRefs));
+ over(pm, ctx => ({
+ ...ctx,
+ loadedRefs: newRefs,
+ toLoad: [],
+ toUnload: [],
+ }));
+ })
+);
+
+declare module '../sdk' {
+ interface SDK {
+ PluginManager: typeof PluginManager;
+ }
+}
+
+sdk.PluginManager = PluginManager;
+
+export const pluginManagerPipe: Pipe = Composer.pipe(
+ apiPipe,
+ enableDisablePipe,
+ reconcilePipe,
+ lifecyclePipe,
+ finalizePipe
+);
diff --git a/src/engine/plugins/Plugins.ts b/src/engine/plugins/Plugins.ts
new file mode 100644
index 00000000..58b4a11b
--- /dev/null
+++ b/src/engine/plugins/Plugins.ts
@@ -0,0 +1,31 @@
+import { typedPath, TypedPath } from '../Lens';
+import { Pipe } from '../State';
+
+export function pluginPaths(namespace: string): TypedPath {
+ return typedPath([namespace]);
+}
+
+export type PluginId = string;
+
+export type PluginMeta = {
+ name?: string;
+ description?: string;
+ version?: string;
+ author?: string;
+};
+
+export type Plugin = {
+ id: PluginId;
+ meta?: PluginMeta;
+ activate?: Pipe;
+ update?: Pipe;
+ deactivate?: Pipe;
+};
+
+export type PluginClass = {
+ plugin: Plugin;
+ name: string;
+};
+
+export type PluginRegistry = Record;
+export type EnabledMap = Record;
diff --git a/src/engine/sdk.ts b/src/engine/sdk.ts
new file mode 100644
index 00000000..e11db92e
--- /dev/null
+++ b/src/engine/sdk.ts
@@ -0,0 +1,28 @@
+import { Composer } from './Composer';
+import { Events } from './pipes/Events';
+import { Scheduler } from './pipes/Scheduler';
+import { Storage } from './pipes/Storage';
+import { pluginPaths } from './plugins/Plugins';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface PluginSDK {}
+
+export interface SDK extends PluginSDK {
+ debug: boolean;
+ Composer: typeof Composer;
+ Events: typeof Events;
+ Scheduler: typeof Scheduler;
+ Storage: typeof Storage;
+ pluginPaths: typeof pluginPaths;
+}
+
+export const sdk: SDK = {
+ debug: false,
+ Composer,
+ Events,
+ Scheduler,
+ Storage,
+ pluginPaths,
+} as SDK;
+
+(globalThis as any).sdk = sdk;
diff --git a/src/game/GamePage.tsx b/src/game/GamePage.tsx
index 3a245977..938d26ab 100644
--- a/src/game/GamePage.tsx
+++ b/src/game/GamePage.tsx
@@ -1,20 +1,14 @@
import styled from 'styled-components';
-import {
- GameHypno,
- GameImages,
- GameMeter,
- GameIntensity,
- GameSound,
- GameInstructions,
- GamePace,
- GameEvents,
- GameMessages,
- GameWarmup,
- GameEmergencyStop,
- GameSettings,
- GameVibrator,
-} from './components';
-import { GameProvider } from './GameProvider';
+import { GameMessages } from './components/GameMessages';
+import { GameImages } from './components/GameImages';
+import { GameMeter } from './components/GameMeter';
+import { GameHypno } from './components/GameHypno';
+import { GameSound } from './components/GameSound';
+import { GameVibrator } from './components/GameVibrator';
+import { GameInstructions } from './components/GameInstructions';
+import { GameEmergencyStop } from './components/GameEmergencyStop';
+import { GamePauseMenu } from './components/GamePauseMenu';
+import { GameResume } from './components/GameResume';
const StyledGamePage = styled.div`
position: relative;
@@ -28,10 +22,6 @@ const StyledGamePage = styled.div`
align-items: center;
`;
-const StyledLogicElements = styled.div`
- // these elements have no visual representation. This style is merely to group them.
-`;
-
const StyledTopBar = styled.div`
position: absolute;
top: 0;
@@ -82,30 +72,23 @@ const StyledBottomBar = styled.div`
export const GamePage = () => {
return (
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
);
};
diff --git a/src/game/GameProvider.tsx b/src/game/GameProvider.tsx
index dedd60db..58c848d5 100644
--- a/src/game/GameProvider.tsx
+++ b/src/game/GameProvider.tsx
@@ -1,100 +1,124 @@
-import { useCallback } from 'react';
-import { createStateProvider } from '../utils';
-import { ImageItem } from '../types';
-
-export enum Paws {
- left = 'left',
- right = 'right',
- both = 'both',
- none = 'none',
-}
+import { useEffect, useRef, useState, ReactNode, useCallback } from 'react';
+import { createContext } from 'use-context-selector';
+import { GameEngine, Pipe, GameFrame } from '../engine';
+import { Events } from '../engine/pipes/Events';
+import { Scheduler } from '../engine/pipes/Scheduler';
+import { Perf } from '../engine/pipes/Perf';
+import { Errors } from '../engine/pipes/Errors';
+import { Piper } from '../engine/Piper';
+import { Composer } from '../engine/Composer';
-export const PawLabels: Record = {
- [Paws.left]: 'Left',
- [Paws.right]: 'Right',
- [Paws.both]: 'Both',
- [Paws.none]: 'Off',
+type GameEngineContextValue = {
+ /**
+ * The current game frame containing all plugin data and timing.
+ */
+ frame: GameFrame | null;
+ /**
+ * Queue a one-shot pipe to run in the next tick only.
+ */
+ injectImpulse: (pipe: Pipe) => void;
};
-export enum Stroke {
- up = 'up',
- down = 'down',
-}
+// eslint-disable-next-line react-refresh/only-export-components
+export const GameEngineContext = createContext<
+ GameEngineContextValue | undefined
+>(undefined);
-export enum GamePhase {
- pause = 'pause',
- warmup = 'warmup',
- active = 'active',
- break = 'break',
- finale = 'finale',
- climax = 'climax',
-}
+type Props = {
+ children: ReactNode;
+ pipes?: Pipe[];
+};
-export interface GameMessagePrompt {
- title: string;
- onClick: () => void | Promise;
-}
+export function GameEngineProvider({ children, pipes = [] }: Props) {
+ const engineRef = useRef(null);
-export interface GameMessage {
- id: string;
- title: string;
- description?: string;
- prompts?: GameMessagePrompt[];
- duration?: number;
-}
+ const [frame, setFrame] = useState(null);
-export interface GameState {
- pace: number;
- intensity: number;
- currentImage?: ImageItem;
- seenImages: ImageItem[];
- nextImages: ImageItem[];
- currentHypno: number;
- paws: Paws;
- stroke: Stroke;
- phase: GamePhase;
- edged: boolean;
- messages: GameMessage[];
-}
+ const pendingImpulseRef = useRef([]);
+ const activeImpulseRef = useRef([]);
-export const initialGameState: GameState = {
- pace: 0,
- intensity: 0,
- currentImage: undefined,
- seenImages: [],
- nextImages: [],
- currentHypno: 0,
- paws: Paws.none,
- stroke: Stroke.down,
- phase: GamePhase.warmup,
- edged: false,
- messages: [],
-};
+ useEffect(() => {
+ // To inject one-shot pipes (impulses) into the engine,
+ // we use the pending ref to stage them, and the active ref to apply them.
+ const impulsePipe: Pipe = Composer.chain(c =>
+ c.pipe(...activeImpulseRef.current)
+ );
+
+ engineRef.current = new GameEngine(
+ {},
+ Piper([
+ impulsePipe,
+ Events.pipe,
+ Scheduler.pipe,
+ Perf.pipe,
+ Errors.pipe,
+ ...pipes,
+ ])
+ );
+
+ const STEP = 16;
+ const MAX_TICKS_PER_FRAME = 4;
+ let accumulator = 0;
+ let lastWallTime: number | null = null;
+ let frameId: number;
+
+ const loop = () => {
+ if (!engineRef.current) return;
+
+ const now = performance.now();
+
+ if (document.hidden || lastWallTime === null) {
+ lastWallTime = now;
+ frameId = requestAnimationFrame(loop);
+ return;
+ }
-export const {
- Provider: GameProvider,
- useProvider: useGame,
- useProviderSelector: useGameValue,
-} = createStateProvider({
- defaultData: initialGameState,
-});
-
-export const useSendMessage = () => {
- const [, setMessages] = useGameValue('messages');
-
- return useCallback(
- (message: Partial & { id: string }) => {
- setMessages(messages => {
- const previous = messages.find(m => m.id === message.id);
- return [
- ...messages.filter(m => m.id !== message.id),
- {
- ...previous,
- ...message,
- } as GameMessage,
- ];
- });
- },
- [setMessages]
+ accumulator += now - lastWallTime;
+ lastWallTime = now;
+
+ let ticked = false;
+ let ticks = 0;
+
+ while (accumulator >= STEP && ticks < MAX_TICKS_PER_FRAME) {
+ if (!ticked) {
+ activeImpulseRef.current = pendingImpulseRef.current;
+ pendingImpulseRef.current = [];
+ ticked = true;
+ }
+
+ engineRef.current.tick();
+ accumulator -= STEP;
+ ticks++;
+ }
+
+ if (ticks >= MAX_TICKS_PER_FRAME) {
+ accumulator = 0;
+ }
+
+ if (ticked) {
+ setFrame(engineRef.current.getFrame());
+ }
+
+ frameId = requestAnimationFrame(loop);
+ };
+
+ frameId = requestAnimationFrame(loop);
+
+ return () => {
+ cancelAnimationFrame(frameId);
+ engineRef.current = null;
+ pendingImpulseRef.current = [];
+ activeImpulseRef.current = [];
+ };
+ }, [pipes]);
+
+ const injectImpulse = useCallback((pipe: Pipe) => {
+ pendingImpulseRef.current.push(pipe);
+ }, []);
+
+ return (
+
+ {children}
+
);
-};
+}
diff --git a/src/game/GameShell.tsx b/src/game/GameShell.tsx
new file mode 100644
index 00000000..5e03d621
--- /dev/null
+++ b/src/game/GameShell.tsx
@@ -0,0 +1,25 @@
+import { useMemo, ReactNode } from 'react';
+import { GameEngineProvider } from './GameProvider';
+import { useSettingsPipe } from './pipes';
+import { pluginInstallerPipe } from '../engine/plugins/PluginInstaller';
+import { pluginManagerPipe } from '../engine/plugins/PluginManager';
+import { registerPlugins } from './plugins';
+
+type Props = {
+ children: ReactNode;
+};
+
+export const GameShell = ({ children }: Props) => {
+ const settingsPipe = useSettingsPipe();
+ const pipes = useMemo(
+ () => [
+ pluginManagerPipe,
+ pluginInstallerPipe,
+ registerPlugins,
+ settingsPipe,
+ ],
+ [settingsPipe]
+ );
+
+ return {children};
+};
diff --git a/src/game/SceneBridge.tsx b/src/game/SceneBridge.tsx
new file mode 100644
index 00000000..906fb865
--- /dev/null
+++ b/src/game/SceneBridge.tsx
@@ -0,0 +1,48 @@
+import { useEffect, useRef } from 'react';
+import { useLocation, useNavigate } from 'react-router-dom';
+import { useGameEngine } from './hooks/UseGameEngine';
+import { useGameFrame } from './hooks';
+import Scene from './plugins/scene';
+
+const routeToScene: Record = {
+ '/': 'home',
+ '/play': 'game',
+ '/end': 'end',
+};
+
+const sceneToRoute: Record = {
+ home: '/',
+ game: '/play',
+ end: '/end',
+};
+
+export const SceneBridge = () => {
+ const { injectImpulse } = useGameEngine();
+ const location = useLocation();
+ const navigate = useNavigate();
+ const sceneState = useGameFrame(Scene.paths) as
+ | { current?: string }
+ | undefined;
+
+ const lastRouteSceneRef = useRef(null);
+
+ useEffect(() => {
+ const scene = routeToScene[location.pathname] ?? 'unknown';
+ lastRouteSceneRef.current = scene;
+ injectImpulse(Scene.setScene(scene));
+ }, [location.pathname, injectImpulse]);
+
+ useEffect(() => {
+ const current = sceneState?.current;
+ if (!current || current === 'unknown') return;
+ if (current === lastRouteSceneRef.current) return;
+
+ const route = sceneToRoute[current];
+ if (!route) return;
+
+ lastRouteSceneRef.current = current;
+ navigate(route);
+ }, [navigate, sceneState]);
+
+ return null;
+};
diff --git a/src/game/Sequence.ts b/src/game/Sequence.ts
new file mode 100644
index 00000000..e4a68d81
--- /dev/null
+++ b/src/game/Sequence.ts
@@ -0,0 +1,76 @@
+import { Pipe } from '../engine/State';
+import { Events, GameEvent, Scheduler } from '../engine/pipes';
+import { sdk } from '../engine/sdk';
+import Messages from './plugins/messages';
+
+type MessageInput = Omit[0], 'id'>;
+type MessagePrompt = NonNullable[number];
+
+export type SequenceScope = {
+ messageId: string;
+ on(handler: (event: GameEvent) => Pipe): Pipe;
+ on(name: string, handler: (event: GameEvent) => Pipe): Pipe;
+ message(msg: MessageInput): Pipe;
+ after(duration: number, target: string, payload?: T): Pipe;
+ prompt(title: string, target: string, payload?: T): MessagePrompt;
+ start(payload?: T): Pipe;
+ cancel(): Pipe;
+ dispatch(target: string, payload?: T): Pipe;
+ eventKey(target: string): string;
+ scheduleKey(target: string): string;
+};
+
+export class Sequence {
+ static for(namespace: string, name: string): SequenceScope {
+ const rootKey = Events.getKey(namespace, name);
+ const nodeKey = (n: string) => Events.getKey(namespace, `${name}.${n}`);
+ const schedKey = (n: string) => Scheduler.getKey(namespace, `${name}.${n}`);
+
+ return {
+ messageId: name,
+ on(nameOrHandler: any, handler?: any) {
+ if (typeof nameOrHandler === 'function')
+ return Events.handle(rootKey, nameOrHandler);
+ return Events.handle(nodeKey(nameOrHandler), handler);
+ },
+ message: msg => Messages.send({ ...msg, id: name }),
+ after: (duration, target, payload) =>
+ Scheduler.schedule({
+ id: schedKey(target),
+ duration,
+ event: {
+ type: nodeKey(target),
+ ...(payload !== undefined && { payload }),
+ },
+ }),
+ prompt: (title, target, payload) => ({
+ title,
+ event: {
+ type: nodeKey(target),
+ ...(payload !== undefined && { payload }),
+ },
+ }),
+ start: payload =>
+ Events.dispatch({
+ type: rootKey,
+ ...(payload !== undefined && { payload }),
+ } as GameEvent),
+ cancel: () => Scheduler.cancelByPrefix(Scheduler.getKey(namespace, name)),
+ dispatch: (target, payload) =>
+ Events.dispatch({
+ type: target ? nodeKey(target) : rootKey,
+ ...(payload !== undefined && { payload }),
+ } as GameEvent),
+ eventKey: nodeKey,
+ scheduleKey: schedKey,
+ };
+ }
+}
+
+declare module '../engine/sdk' {
+ interface SDK {
+ Sequence: typeof Sequence;
+ }
+}
+
+sdk.Sequence = Sequence;
diff --git a/src/game/components/GameEmergencyStop.tsx b/src/game/components/GameEmergencyStop.tsx
index fa0d9747..defd8f10 100644
--- a/src/game/components/GameEmergencyStop.tsx
+++ b/src/game/components/GameEmergencyStop.tsx
@@ -1,52 +1,17 @@
-import { GamePhase, useGameValue, useSendMessage } from '../GameProvider';
import { useCallback } from 'react';
-import { wait } from '../../utils';
-import { useSetting } from '../../settings';
import { WaButton, WaIcon } from '@awesome.me/webawesome/dist/react';
+import { useGameFrame } from '../hooks';
+import { useDispatchEvent } from '../hooks/UseDispatchEvent';
+import Phase, { GamePhase } from '../plugins/phase';
+import { Events } from '../../engine/pipes/Events';
export const GameEmergencyStop = () => {
- const [phase, setPhase] = useGameValue('phase');
- const [intensity, setIntensity] = useGameValue('intensity');
- const [, setPace] = useGameValue('pace');
- const [minPace] = useSetting('minPace');
- const sendMessage = useSendMessage();
- const messageId = 'emergency-stop';
+ const phase = useGameFrame(Phase.paths.current) ?? '';
+ const { dispatchEvent } = useDispatchEvent();
- const onStop = useCallback(async () => {
- const timeToCalmDown = Math.ceil((intensity * 500 + 10000) / 1000);
-
- setPhase(GamePhase.break);
-
- sendMessage({
- id: messageId,
- title: 'Calm down with your $hands off.',
- });
-
- // maybe percentage based reduction
- setIntensity(intensity => Math.max(intensity - 30, 0));
- setPace(minPace);
-
- await wait(5000);
-
- for (let i = 0; i < timeToCalmDown; i++) {
- sendMessage({
- id: messageId,
- description: `${timeToCalmDown - i}...`,
- });
- await wait(1000);
- }
-
- sendMessage({
- id: messageId,
- title: 'Put your $hands back.',
- description: undefined,
- duration: 5000,
- });
-
- await wait(2000);
-
- setPhase(GamePhase.active);
- }, [intensity, minPace, sendMessage, setIntensity, setPace, setPhase]);
+ const onStop = useCallback(() => {
+ dispatchEvent({ type: Events.getKey('core.emergencyStop', 'stop') });
+ }, [dispatchEvent]);
return (
<>
diff --git a/src/game/components/GameEvents.tsx b/src/game/components/GameEvents.tsx
deleted file mode 100644
index 4150cb54..00000000
--- a/src/game/components/GameEvents.tsx
+++ /dev/null
@@ -1,162 +0,0 @@
-/* eslint-disable react-refresh/only-export-components */
-import { MutableRefObject, useEffect } from 'react';
-import { GameEvent } from '../../types';
-import {
- GamePhase,
- GameState,
- useGame,
- useGameValue,
- useSendMessage,
-} from '../GameProvider';
-import { Settings, useSetting, useSettings } from '../../settings';
-import {
- useLooping,
- useAutoRef,
- createStateSetters,
- StateWithSetters,
-} from '../../utils';
-import {
- cleanUpEvent,
- climaxEvent,
- doublePaceEvent,
- edgeEvent,
- halfPaceEvent,
- pauseEvent,
- randomGripEvent,
- randomPaceEvent,
- risingPaceEvent,
-} from './events';
-
-export interface EventData {
- game: StateWithSetters & {
- sendMessage: ReturnType;
- };
- settings: StateWithSetters;
-}
-
-export type EventDataRef = MutableRefObject;
-
-export const rollEventDice = (data: EventDataRef) => {
- const {
- game: { intensity, phase, edged },
- settings: { events },
- } = data.current;
-
- const roll = (chance: number): boolean =>
- Math.floor(Math.random() * chance) === 0;
-
- if (phase !== GamePhase.active) return null;
-
- if (
- events.includes(GameEvent.climax) &&
- intensity >= 100 &&
- (!events.includes(GameEvent.edge) || edged)
- ) {
- return GameEvent.climax;
- }
-
- if (events.includes(GameEvent.edge) && intensity >= 90 && !edged) {
- return GameEvent.edge;
- }
-
- if (events.includes(GameEvent.randomPace) && roll(10)) {
- return GameEvent.randomPace;
- }
-
- if (events.includes(GameEvent.cleanUp) && intensity >= 75 && roll(25)) {
- return GameEvent.cleanUp;
- }
-
- if (events.includes(GameEvent.randomGrip) && roll(50)) {
- return GameEvent.randomGrip;
- }
-
- if (
- events.includes(GameEvent.doublePace) &&
- intensity >= 20 &&
- roll(50 - (intensity - 20) * 0.25)
- ) {
- return GameEvent.doublePace;
- }
-
- if (
- events.includes(GameEvent.halfPace) &&
- intensity >= 10 &&
- intensity <= 50 &&
- roll(50)
- ) {
- return GameEvent.halfPace;
- }
-
- if (events.includes(GameEvent.pause) && intensity >= 15 && roll(50)) {
- return GameEvent.pause;
- }
-
- if (events.includes(GameEvent.risingPace) && intensity >= 30 && roll(30)) {
- return GameEvent.risingPace;
- }
-
- return null;
-};
-
-export const handleEvent = async (event: GameEvent, data: EventDataRef) => {
- await {
- climax: climaxEvent,
- edge: edgeEvent,
- pause: pauseEvent,
- halfPace: halfPaceEvent,
- risingPace: risingPaceEvent,
- doublePace: doublePaceEvent,
- randomPace: randomPaceEvent,
- randomGrip: randomGripEvent,
- cleanUp: cleanUpEvent,
- }[event](data);
-};
-
-export const silenceEventData = (data: EventDataRef): EventDataRef => {
- return {
- get current() {
- return {
- ...data.current,
- game: {
- ...data.current.game,
- sendMessage: () => {},
- },
- };
- },
- };
-};
-
-export const GameEvents = () => {
- const [phase] = useGameValue('phase');
- const [, setPaws] = useGameValue('paws');
- const [events] = useSetting('events');
- const sendMessage = useSendMessage();
-
- const data = useAutoRef({
- game: {
- ...createStateSetters(...useGame()),
- sendMessage: sendMessage,
- },
- settings: createStateSetters(...useSettings()),
- });
-
- useEffect(() => {
- if (phase === GamePhase.active && events.includes(GameEvent.randomGrip)) {
- randomGripEvent(silenceEventData(data));
- }
- }, [data, events, phase, setPaws]);
-
- useLooping(
- async () => {
- const event = rollEventDice(data);
- if (event) {
- await handleEvent(event, data);
- }
- },
- 1000,
- phase === GamePhase.active
- );
-
- return null;
-};
diff --git a/src/game/components/GameHypno.tsx b/src/game/components/GameHypno.tsx
index 238e1080..423e5f3c 100644
--- a/src/game/components/GameHypno.tsx
+++ b/src/game/components/GameHypno.tsx
@@ -1,10 +1,11 @@
import styled from 'styled-components';
import { useSetting, useTranslate } from '../../settings';
import { GameHypnoType, HypnoPhrases } from '../../types';
-import { useLooping } from '../../utils';
-import { GamePhase, useGameValue } from '../GameProvider';
-import { useCallback, useMemo } from 'react';
+import { useMemo } from 'react';
import { motion } from 'framer-motion';
+import { useGameFrame } from '../hooks';
+import Intensity from '../plugins/intensity';
+import Hypno from '../plugins/hypno';
const StyledGameHypno = motion.create(styled.div`
pointer-events: none;
@@ -15,33 +16,24 @@ const StyledGameHypno = motion.create(styled.div`
export const GameHypno = () => {
const [hypno] = useSetting('hypno');
- const [current, setCurrent] = useGameValue('currentHypno');
- const [phase] = useGameValue('phase');
- const [intensity] = useGameValue('intensity');
+ const { currentPhrase = 0 } = useGameFrame(Hypno.paths) ?? {};
+ const { intensity = 0 } = useGameFrame(Intensity.paths) ?? {};
const translate = useTranslate();
const phrase = useMemo(() => {
+ if (hypno === GameHypnoType.off) return '';
const phrases = HypnoPhrases[hypno];
if (phrases.length <= 0) return '';
- return translate(phrases[current % phrases.length]);
- }, [current, hypno, translate]);
+ return translate(phrases[currentPhrase % phrases.length]);
+ }, [currentPhrase, hypno, translate]);
- const onTick = useCallback(() => {
- setCurrent(Math.floor(Math.random() * HypnoPhrases[hypno].length));
- }, [hypno, setCurrent]);
+ const delay = useMemo(() => 3000 - intensity * 100 * 29, [intensity]);
- const delay = useMemo(() => 3000 - intensity * 29, [intensity]);
-
- const enabled = useMemo(
- () => phase === GamePhase.active && hypno !== GameHypnoType.off,
- [phase, hypno]
- );
-
- useLooping(onTick, delay, enabled);
+ if (hypno === GameHypnoType.off || !phrase) return null;
return (
{
- const [images] = useImages();
- const [currentImage, setCurrentImage] = useGameValue('currentImage');
- const [seenImages, setSeenImages] = useGameValue('seenImages');
- const [nextImages, setNextImages] = useGameValue('nextImages');
- const [intensity] = useGameValue('intensity');
+ const { currentImage, nextImages = [] } = useGameFrame(Image.paths);
+ const { intensity } = useGameFrame(Intensity.paths);
const [videoSound] = useSetting('videoSound');
const [highRes] = useSetting('highRes');
- const [imageDuration] = useSetting('imageDuration');
- const [intenseImages] = useSetting('intenseImages');
useImagePreloader(nextImages, highRes ? ImageSize.full : ImageSize.preview);
- const imagesTracker = useAutoRef({
- images,
- currentImage,
- setCurrentImage,
- seenImages,
- setSeenImages,
- nextImages,
- setNextImages,
- });
-
- const switchImage = useCallback(() => {
- const {
- images,
- currentImage,
- setCurrentImage,
- seenImages,
- setSeenImages,
- nextImages,
- setNextImages,
- } = imagesTracker.current;
-
- let next = nextImages;
- if (next.length <= 0) {
- next = images.sort(() => Math.random() - 0.5).slice(0, 3);
- }
- const seen = [...seenImages, ...(currentImage ? [currentImage] : [])];
- if (seen.length > images.length / 2) {
- seen.shift();
- }
- const unseen = images.filter(i => !seen.includes(i));
- setCurrentImage(next.shift());
- setSeenImages(seen);
- setNextImages([...next, unseen[Math.floor(Math.random() * unseen.length)]]);
- }, [imagesTracker]);
-
- const switchDuration = useMemo(() => {
- if (intenseImages) {
- const scaleFactor = Math.max((100 - intensity) / 100, 0.1);
- return Math.max(imageDuration * scaleFactor * 1000, 1000);
- }
- return imageDuration * 1000;
- }, [imageDuration, intenseImages, intensity]);
-
- useEffect(() => switchImage(), [switchImage]);
-
- useLooping(switchImage, switchDuration);
+ const switchDuration = Math.max((100 - intensity * 100) * 80, 2000);
return (
@@ -119,7 +70,6 @@ export const GameImages = () => {
@@ -128,9 +78,11 @@ export const GameImages = () => {
{
- const [pace] = useGameValue('pace');
- const [intensity] = useGameValue('intensity');
+const PaceDisplay = () => {
+ const { pace = 0 } = useGameFrame(Pace.paths) ?? {};
const [maxPace] = useSetting('maxPace');
const paceSection = useMemo(() => maxPace / 3, [maxPace]);
- const [paws] = useGameValue('paws');
+ return (
+
+
+
+
+ paceSection && pace <= paceSection * 2}>
+
+
+ paceSection * 2}>
+
+
+
+ {pace} b/s
+
+
+ );
+};
+
+const GripDisplay = () => {
+ const paws = useGameFrame(pawsPath) ?? Paws.both;
+
+ return (
+
+
+
+
+
+
+
+
+ {PawLabels[paws]}
+
+
+ );
+};
+
+const IntensityDisplay = () => {
+ const { intensity = 0 } = useGameFrame(Intensity.paths) ?? {};
+ const intensityPct = Math.round(intensity * 100);
+
+ return (
+
+
+
+
+ );
+};
+
+export const GameInstructions = () => {
const [events] = useSetting('events');
const useRandomGrip = useMemo(
- () => events.includes(GameEvent.randomGrip),
+ () => events.includes(DiceEvent.randomGrip),
[events]
);
return (
-
-
-
-
- paceSection && pace <= paceSection * 2}
- >
-
-
- paceSection * 2}>
-
-
-
- {pace} b/s
-
-
+
{useRandomGrip && (
<>
-
-
-
-
-
-
-
-
- {PawLabels[paws]}
-
-
+
)}
-
-
-
-
+
);
};
diff --git a/src/game/components/GameIntensity.tsx b/src/game/components/GameIntensity.tsx
index 7df0bd08..056ab9a5 100644
--- a/src/game/components/GameIntensity.tsx
+++ b/src/game/components/GameIntensity.tsx
@@ -1,19 +1,33 @@
-import { useSetting } from '../../settings';
-import { useLooping } from '../../utils';
-import { GamePhase, useGameValue } from '../GameProvider';
+import { useGameFrame } from '../hooks';
+import Intensity from '../plugins/intensity';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faFire } from '@fortawesome/free-solid-svg-icons';
+import { ProgressBar } from '../../common';
+import styled from 'styled-components';
+
+const StyledIntensityMeter = styled.div`
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ gap: 4px;
+ margin: 8px;
+`;
export const GameIntensity = () => {
- const [, setIntensity] = useGameValue('intensity');
- const [phase] = useGameValue('phase');
- const [duration] = useSetting('gameDuration');
+ const { intensity } = useGameFrame(Intensity.paths);
- useLooping(
- () => {
- setIntensity(prev => Math.min(prev + 1, 100));
- },
- duration * 10,
- phase === GamePhase.active
+ return (
+
+
+
+
);
-
- return null;
};
diff --git a/src/game/components/GameMessages.tsx b/src/game/components/GameMessages.tsx
index 4449217e..0129dfab 100644
--- a/src/game/components/GameMessages.tsx
+++ b/src/game/components/GameMessages.tsx
@@ -1,10 +1,16 @@
-import { useCallback, useEffect, useState } from 'react';
-import styled from 'styled-components';
-import { GameMessage, GameMessagePrompt, useGameValue } from '../GameProvider';
-import { defaultTransition, playTone } from '../../utils';
+import { useEffect, useRef } from 'react';
import { AnimatePresence, motion } from 'framer-motion';
+import styled from 'styled-components';
import { useTranslate } from '../../settings';
+import { defaultTransition, playTone } from '../../utils';
+import { GameMessage } from '../plugins/messages';
+import Messages from '../plugins/messages';
+import { useGameFrame } from '../hooks/UseGameFrame';
+
+import _ from 'lodash';
+import { useDispatchEvent } from '../hooks/UseDispatchEvent';
+
const StyledGameMessages = styled.div`
display: flex;
flex-direction: column;
@@ -54,83 +60,37 @@ const StyledGameMessageButton = motion.create(styled.button`
`);
export const GameMessages = () => {
- const [, setTimers] = useState>({});
- const [currentMessages, setCurrentMessages] = useState([]);
- const [previousMessages, setPreviousMessages] = useState([]);
- const [messages, setMessages] = useGameValue('messages');
+ const { messages } = useGameFrame(Messages.paths);
+ const { dispatchEvent } = useDispatchEvent();
const translate = useTranslate();
- useEffect(() => {
- setPreviousMessages(currentMessages);
- setCurrentMessages(messages);
- }, [currentMessages, messages]);
+ const prevMessagesRef = useRef([]);
useEffect(() => {
- const addedMessages = currentMessages.filter(
- message => !previousMessages.includes(message)
- );
-
- const newTimers = addedMessages.reduce(
- (acc, message) => {
- if (message.duration) {
- acc[message.id] = window.setTimeout(
- () => setMessages(messages => messages.filter(m => m !== message)),
- message.duration
- );
- }
- return acc;
- },
- {} as Record
- );
-
- if (addedMessages.length > 0) {
+ const prevMessages = prevMessagesRef.current;
+
+ const changed = messages?.some(newMsg => {
+ const oldMsg = prevMessages.find(prev => prev.id === newMsg.id);
+ return !oldMsg || !_.isEqual(oldMsg, newMsg);
+ });
+
+ if (changed) {
playTone(200);
}
- const removedMessages = previousMessages.filter(
- message => !currentMessages.includes(message)
- );
- const removedTimers = removedMessages.map(message => message.id);
-
- setTimers(timers => ({
- ...Object.keys(timers).reduce((acc, key) => {
- if (removedTimers.includes(key)) {
- window.clearTimeout(timers[key]);
- return acc;
- }
- return { ...acc, [key]: timers[key] };
- }, {}),
- ...newTimers,
- }));
- }, [currentMessages, previousMessages, setMessages]);
-
- const onMessageClick = useCallback(
- async (message: GameMessage, prompt: GameMessagePrompt) => {
- await prompt.onClick();
- setMessages(messages => messages.filter(m => m !== message));
- },
- [setMessages]
- );
+ prevMessagesRef.current = messages ?? [];
+ }, [messages]);
return (
- {currentMessages.map(message => (
+ {messages?.map(message => (
{translate(message.title)}
@@ -159,7 +119,7 @@ export const GameMessages = () => {
...defaultTransition,
ease: 'circInOut',
}}
- onClick={() => onMessageClick(message, prompt)}
+ onClick={() => dispatchEvent(prompt.event)}
>
{translate(prompt.title)}
diff --git a/src/game/components/GameMeter.tsx b/src/game/components/GameMeter.tsx
index ad12661e..635bf501 100644
--- a/src/game/components/GameMeter.tsx
+++ b/src/game/components/GameMeter.tsx
@@ -1,8 +1,11 @@
import styled from 'styled-components';
-import { GamePhase, Stroke, useGameValue } from '../GameProvider';
-import { useCallback, useMemo } from 'react';
+import { useMemo } from 'react';
import { motion } from 'framer-motion';
-import { defaultTransition, useLooping } from '../../utils';
+import { defaultTransition } from '../../utils';
+import { useGameFrame } from '../hooks';
+import Phase, { GamePhase } from '../plugins/phase';
+import Stroke, { StrokeDirection } from '../plugins/stroke';
+import Pace from '../plugins/pace';
const StyledGameMeter = styled.div`
pointer-events: none;
@@ -22,70 +25,33 @@ enum MeterColor {
}
export const GameMeter = () => {
- const [stroke, setStroke] = useGameValue('stroke');
- const [phase] = useGameValue('phase');
- const [pace] = useGameValue('pace');
+ const { stroke } = useGameFrame(Stroke.paths) ?? {};
+ const { current: phase } = useGameFrame(Phase.paths) ?? {};
+ const { pace } = useGameFrame(Pace.paths) ?? {};
const switchDuration = useMemo(() => {
- if (pace === 0) return 0;
+ if (!pace || pace === 0) return 0;
return (1 / pace) * 1000;
}, [pace]);
- const updateStroke = useCallback(() => {
- setStroke(stroke => {
- switch (stroke) {
- case Stroke.up:
- return Stroke.down;
- case Stroke.down:
- return Stroke.up;
- }
- });
- }, [setStroke]);
-
- useLooping(
- updateStroke,
- switchDuration,
- [GamePhase.active, GamePhase.finale].includes(phase) && pace > 0
- );
-
const size = useMemo(() => {
- switch (phase) {
- case GamePhase.active:
- case GamePhase.finale:
- return (() => {
- switch (stroke) {
- case Stroke.up:
- return 1;
- case Stroke.down:
- return 0.6;
- }
- })();
+ if (phase === GamePhase.active || phase === GamePhase.finale) {
+ return stroke === StrokeDirection.up ? 1 : 0.6;
}
return 0;
}, [phase, stroke]);
const duration = useMemo(() => {
- switch (phase) {
- case GamePhase.active:
- case GamePhase.finale:
- if (pace >= 5) {
- return 100;
- }
- if (pace >= 3) {
- return 250;
- }
- return 550;
+ if (phase === GamePhase.active || phase === GamePhase.finale) {
+ if (pace && pace >= 5) return 100;
+ if (pace && pace >= 3) return 250;
+ return 550;
}
return 0;
}, [phase, pace]);
const color = useMemo(() => {
- switch (stroke) {
- case Stroke.up:
- return MeterColor.light;
- case Stroke.down:
- return MeterColor.dark;
- }
+ return stroke === StrokeDirection.up ? MeterColor.light : MeterColor.dark;
}, [stroke]);
return (
diff --git a/src/game/components/GamePace.tsx b/src/game/components/GamePace.tsx
deleted file mode 100644
index 56dec88a..00000000
--- a/src/game/components/GamePace.tsx
+++ /dev/null
@@ -1,14 +0,0 @@
-import { useEffect } from 'react';
-import { useGameValue } from '../GameProvider';
-import { useSetting } from '../../settings';
-
-export const GamePace = () => {
- const [minPace] = useSetting('minPace');
- const [, setPace] = useGameValue('pace');
-
- useEffect(() => {
- setPace(minPace);
- }, [minPace, setPace]);
-
- return null;
-};
diff --git a/src/game/components/GamePauseMenu.tsx b/src/game/components/GamePauseMenu.tsx
new file mode 100644
index 00000000..5f4d869b
--- /dev/null
+++ b/src/game/components/GamePauseMenu.tsx
@@ -0,0 +1,126 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useNavigate } from 'react-router-dom';
+import styled from 'styled-components';
+import { WaButton, WaDialog, WaIcon } from '@awesome.me/webawesome/dist/react';
+import { nestedDialogProps, useFullscreen } from '../../utils';
+import { useGameFrame } from '../hooks';
+import { useDispatchEvent } from '../hooks/UseDispatchEvent';
+import Pause from '../plugins/pause';
+
+const StyledTrigger = styled.div`
+ display: flex;
+ height: fit-content;
+ align-items: center;
+ justify-content: center;
+ border-radius: 0 var(--border-radius) 0 0;
+ background: var(--overlay-background);
+ color: var(--overlay-color);
+ padding: var(--wa-space-2xs);
+`;
+
+const StyledDialog = styled(WaDialog)`
+ &::part(dialog) {
+ background-color: transparent;
+ box-shadow: none;
+ }
+
+ &::part(header) {
+ justify-content: center;
+ }
+
+ &::part(title) {
+ text-align: center;
+ }
+
+ &::part(close-button) {
+ display: none;
+ }
+
+ &::part(body) {
+ display: flex;
+ flex-direction: column;
+ align-items: stretch;
+ gap: var(--wa-space-m);
+ max-width: 300px;
+ padding: var(--wa-space-l) 0;
+ margin: 0 auto;
+ }
+`;
+
+const StyledMenuButton = styled(WaButton)`
+ &::part(base) {
+ padding: var(--wa-space-l) var(--wa-space-2xl);
+ background: var(--overlay-background);
+ border-radius: var(--wa-form-control-border-radius);
+ font-size: 1.25rem;
+ }
+
+ &::part(base):hover {
+ background: var(--wa-color-brand);
+ }
+`;
+
+export const GamePauseMenu = () => {
+ const { paused, countdown } = useGameFrame(Pause.paths) ?? {};
+ const [fullscreen, setFullscreen] = useFullscreen();
+ const { inject } = useDispatchEvent();
+ const navigate = useNavigate();
+ const dialogRef = useRef(null);
+
+ const visible = !!paused && countdown == null;
+
+ useEffect(() => {
+ if (dialogRef.current) dialogRef.current.open = visible;
+ }, [visible]);
+
+ const onResume = useCallback(() => {
+ inject(Pause.setPaused(false));
+ }, [inject]);
+
+ const onEndGame = useCallback(() => {
+ navigate('/end');
+ }, [navigate]);
+
+ const onSettings = useCallback(() => {
+ navigate('/');
+ }, [navigate]);
+
+ const onPause = useCallback(() => {
+ inject(Pause.setPaused(true));
+ }, [inject]);
+
+ return (
+ <>
+
+
+
+
+
+ {
+ if (countdown != null) return;
+ inject(Pause.setPaused(false));
+ })}
+ >
+
+
+ Resume
+
+ setFullscreen(fs => !fs)}>
+
+ {fullscreen ? 'Exit Fullscreen' : 'Fullscreen'}
+
+
+
+ Settings
+
+
+
+ End Game
+
+
+
+ );
+};
diff --git a/src/game/components/GameResume.tsx b/src/game/components/GameResume.tsx
new file mode 100644
index 00000000..bd34bd53
--- /dev/null
+++ b/src/game/components/GameResume.tsx
@@ -0,0 +1,50 @@
+import styled from 'styled-components';
+import { AnimatePresence, motion } from 'framer-motion';
+import { useGameFrame } from '../hooks';
+import Pause from '../plugins/pause';
+
+const StyledOverlay = styled(motion.div)`
+ position: absolute;
+ inset: 0;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ pointer-events: none;
+ z-index: 10;
+`;
+
+const StyledNumber = styled(motion.div)`
+ font-size: clamp(3rem, 15vw, 8rem);
+ font-weight: bold;
+ color: var(--overlay-color);
+`;
+
+const display = (countdown: number) =>
+ countdown === 3 ? 'Ready?' : `${countdown}`;
+
+export const GameResume = () => {
+ const { countdown } = useGameFrame(Pause.paths) ?? {};
+
+ return (
+
+ {countdown != null && (
+
+
+ {display(countdown)}
+
+
+ )}
+
+ );
+};
diff --git a/src/game/components/GameSettings.tsx b/src/game/components/GameSettings.tsx
deleted file mode 100644
index 0352ab1c..00000000
--- a/src/game/components/GameSettings.tsx
+++ /dev/null
@@ -1,140 +0,0 @@
-import styled from 'styled-components';
-import { memo, useCallback, useState } from 'react';
-import {
- BoardSettings,
- ClimaxSettings,
- DurationSettings,
- EventSettings,
- HypnoSettings,
- ImageSettings,
- PaceSettings,
- PlayerSettings,
- VibratorSettings,
-} from '../../settings';
-import { GamePhase, useGameValue, useSendMessage } from '../GameProvider';
-import { useFullscreen, useLooping } from '../../utils';
-import {
- WaButton,
- WaDialog,
- WaDivider,
- WaIcon,
-} from '@awesome.me/webawesome/dist/react';
-
-const StyledGameSettings = styled.div`
- display: flex;
- height: fit-content;
-
- align-items: center;
- justify-content: center;
-
- border-radius: 0 var(--border-radius) 0 0;
- background: var(--overlay-background);
- color: var(--overlay-color);
-
- padding: var(--wa-space-2xs);
-`;
-
-const StyledGameSettingsDialog = styled.div`
- overflow: auto;
- max-width: 920px;
- display: grid;
- grid-template-columns: repeat(auto-fit, minmax(min(100%, 400px), 1fr));
-`;
-
-const GameSettingsDialogContent = memo(() => (
-
-
-
-
-
-
-
-
-
-
-
-));
-
-export const GameSettings = () => {
- const [open, setOpen] = useState(false);
- const [phase, setPhase] = useGameValue('phase');
- const [timer, setTimer] = useState(undefined);
- const [fullscreen, setFullscreen] = useFullscreen();
- const sendMessage = useSendMessage();
- const messageId = 'game-settings';
-
- const onOpen = useCallback(
- (open: boolean) => {
- if (open) {
- setTimer(undefined);
- setPhase(phase => {
- if (phase === GamePhase.active) {
- return GamePhase.pause;
- }
- return phase;
- });
- } else {
- setTimer(3000);
- }
- setOpen(open);
- },
- [setPhase]
- );
-
- useLooping(
- () => {
- if (timer === undefined) return;
- if (timer > 0) {
- sendMessage({
- id: messageId,
- title: 'Get ready to continue.',
- description: `${timer * 0.001}...`,
- });
- setTimer(timer - 1000);
- } else if (timer === 0) {
- sendMessage({
- id: messageId,
- title: 'Continue.',
- description: undefined,
- duration: 1500,
- });
- setPhase(GamePhase.active);
- setTimer(undefined);
- }
- },
- 1000,
- !open && phase === GamePhase.pause && timer !== undefined
- );
-
- return (
-
- onOpen(true)}>
-
-
-
- setFullscreen(fullscreen => !fullscreen)}
- >
-
-
- onOpen(false)}
- label={'Game Settings'}
- style={{
- '--width': '920px',
- }}
- >
- {open && }
-
-
- );
-};
diff --git a/src/game/components/GameSound.tsx b/src/game/components/GameSound.tsx
index b43d958d..195dfdb4 100644
--- a/src/game/components/GameSound.tsx
+++ b/src/game/components/GameSound.tsx
@@ -1,20 +1,22 @@
import { useEffect, useState } from 'react';
-import { GamePhase, Stroke, useGameValue } from '../GameProvider';
import { playTone } from '../../utils/sound';
import { wait } from '../../utils';
+import { useGameFrame } from '../hooks';
+import Phase, { GamePhase } from '../plugins/phase';
+import Stroke, { StrokeDirection } from '../plugins/stroke';
export const GameSound = () => {
- const [stroke] = useGameValue('stroke');
- const [phase] = useGameValue('phase');
+ const { stroke } = useGameFrame(Stroke.paths) ?? {};
+ const { current: phase } = useGameFrame(Phase.paths) ?? {};
const [currentPhase, setCurrentPhase] = useState(phase);
useEffect(() => {
switch (stroke) {
- case Stroke.up:
+ case StrokeDirection.up:
playTone(425);
break;
- case Stroke.down:
+ case StrokeDirection.down:
playTone(625);
break;
}
diff --git a/src/game/components/GameVibrator.tsx b/src/game/components/GameVibrator.tsx
index 7ed42337..63c7db4e 100644
--- a/src/game/components/GameVibrator.tsx
+++ b/src/game/components/GameVibrator.tsx
@@ -1,19 +1,25 @@
import { useEffect, useState } from 'react';
-import { GamePhase, Stroke, useGameValue } from '../GameProvider';
import { useAutoRef, useVibratorValue, VibrationMode, wait } from '../../utils';
import { useSetting } from '../../settings';
+import { useGameFrame } from '../hooks';
+import { GamePhase } from '../plugins/phase';
+import Phase from '../plugins/phase';
+import { StrokeDirection } from '../plugins/stroke';
+import Stroke from '../plugins/stroke';
+import Pace from '../plugins/pace';
+import Intensity from '../plugins/intensity';
export const GameVibrator = () => {
- const [stroke] = useGameValue('stroke');
- const [intensity] = useGameValue('intensity');
- const [pace] = useGameValue('pace');
- const [phase] = useGameValue('phase');
+ const { stroke } = useGameFrame(Stroke.paths) ?? {};
+ const { intensity } = useGameFrame(Intensity.paths) ?? {};
+ const { pace } = useGameFrame(Pace.paths) ?? {};
+ const { current: phase } = useGameFrame(Phase.paths) ?? {};
const [mode] = useSetting('vibrations');
const [devices] = useVibratorValue('devices');
const data = useAutoRef({
- intensity,
- pace,
+ intensity: (intensity ?? 0) * 100,
+ pace: pace ?? 1,
devices,
mode,
});
@@ -23,7 +29,7 @@ export const GameVibrator = () => {
useEffect(() => {
const { intensity, pace, devices, mode } = data.current;
switch (stroke) {
- case Stroke.up:
+ case StrokeDirection.up:
switch (mode) {
case VibrationMode.constant: {
const strength = intensity / 100;
@@ -38,7 +44,7 @@ export const GameVibrator = () => {
}
}
break;
- case Stroke.down:
+ case StrokeDirection.down:
break;
}
}, [data, stroke]);
@@ -46,7 +52,7 @@ export const GameVibrator = () => {
useEffect(() => {
const { devices, mode } = data.current;
if (currentPhase == phase) return;
- if ([GamePhase.break, GamePhase.pause].includes(phase)) {
+ if (phase === GamePhase.break) {
devices.forEach(device => device.setVibration(0));
}
if (phase === GamePhase.climax) {
diff --git a/src/game/components/GameWarmup.tsx b/src/game/components/GameWarmup.tsx
deleted file mode 100644
index 65f7bc09..00000000
--- a/src/game/components/GameWarmup.tsx
+++ /dev/null
@@ -1,53 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import { useSetting } from '../../settings';
-import { GamePhase, useGameValue, useSendMessage } from '../GameProvider';
-
-export const GameWarmup = () => {
- const [warmup] = useSetting('warmupDuration');
- const [phase, setPhase] = useGameValue('phase');
- const [, setTimer] = useState(null);
- const sendMessage = useSendMessage();
-
- const onStart = useCallback(() => {
- setPhase(GamePhase.active);
- setTimer(timer => {
- if (timer) window.clearTimeout(timer);
- return null;
- });
- sendMessage({
- id: GamePhase.warmup,
- title: 'Now follow what I say, $player!',
- duration: 5000,
- prompts: undefined,
- });
- }, [sendMessage, setPhase]);
-
- useEffect(() => {
- if (phase !== GamePhase.warmup) return;
- if (warmup === 0) {
- setPhase(GamePhase.active);
- return;
- }
- setTimer(window.setTimeout(onStart, warmup * 1000));
-
- sendMessage({
- id: GamePhase.warmup,
- title: 'Get yourself ready!',
- prompts: [
- {
- title: `I'm ready, $master`,
- onClick: onStart,
- },
- ],
- });
-
- return () => {
- setTimer(timer => {
- if (timer) window.clearTimeout(timer);
- return null;
- });
- };
- }, [onStart, phase, sendMessage, setPhase, warmup]);
-
- return null;
-};
diff --git a/src/game/components/events/clean-up.ts b/src/game/components/events/clean-up.ts
deleted file mode 100644
index d44687e8..00000000
--- a/src/game/components/events/clean-up.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { GameEvent, CleanUpDescriptions } from '../../../types';
-import { GamePhase } from '../../GameProvider';
-import { EventDataRef } from '../GameEvents';
-
-export const cleanUpEvent = async (data: EventDataRef) => {
- const {
- game: { setPhase, sendMessage },
- settings: { body },
- } = data.current;
-
- setPhase(GamePhase.pause);
- sendMessage({
- id: GameEvent.cleanUp,
- title: `Lick up any ${CleanUpDescriptions[body]}`,
- duration: undefined,
- prompts: [
- {
- title: `I'm done, $master`,
- onClick: () => {
- sendMessage({
- id: GameEvent.cleanUp,
- title: 'Good $player',
- duration: 5000,
- prompts: undefined,
- });
- setPhase(GamePhase.active);
- },
- },
- ],
- });
-};
diff --git a/src/game/components/events/climax.ts b/src/game/components/events/climax.ts
deleted file mode 100644
index 8daaa668..00000000
--- a/src/game/components/events/climax.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-import { GameEvent } from '../../../types';
-import { wait } from '../../../utils';
-import { GamePhase } from '../../GameProvider';
-import { EventDataRef } from '../GameEvents';
-
-export const climaxEvent = (data: EventDataRef) => {
- const {
- game: { setPhase, sendMessage, setPace, setIntensity },
- settings: { minPace, climaxChance, ruinChance },
- } = data.current;
-
- setPhase(GamePhase.finale); // this disables events
- sendMessage({
- id: GameEvent.climax,
- title: 'Are you edging?',
- prompts: [
- {
- title: "I'm edging, $master",
- onClick: async () => {
- sendMessage({
- id: GameEvent.climax,
- title: 'Stay on the edge, $player',
- prompts: undefined,
- });
- setPace(minPace);
- await wait(3000);
- sendMessage({
- id: GameEvent.climax,
- description: '3...',
- });
- await wait(5000);
- sendMessage({
- id: GameEvent.climax,
- description: '2...',
- });
- await wait(5000);
- sendMessage({
- id: GameEvent.climax,
- description: '1...',
- });
- await wait(5000);
-
- if (Math.random() * 100 <= climaxChance) {
- if (Math.random() * 100 <= ruinChance) {
- setPhase(GamePhase.pause);
- sendMessage({
- id: GameEvent.climax,
- title: '$HANDS OFF! Ruin your orgasm!',
- description: undefined,
- });
- await wait(3000);
- sendMessage({
- id: GameEvent.climax,
- title: 'Clench in desperation',
- });
- } else {
- setPhase(GamePhase.climax);
- sendMessage({
- id: GameEvent.climax,
- title: 'Cum!',
- description: undefined,
- });
- }
- for (let i = 0; i < 10; i++) {
- setIntensity(intensity => intensity - 10);
- await wait(1000);
- }
- sendMessage({
- id: GameEvent.climax,
- title: 'Good job, $player',
- prompts: [
- {
- title: 'Leave',
- onClick: () => {
- window.location.href = '/';
- },
- },
- ],
- });
- } else {
- setPhase(GamePhase.pause);
- sendMessage({
- id: GameEvent.climax,
- title: '$HANDS OFF! Do not cum!',
- description: undefined,
- });
- for (let i = 0; i < 5; i++) {
- setIntensity(intensity => intensity - 20);
- await wait(1000);
- }
- sendMessage({
- id: GameEvent.climax,
- title: 'Good $player. Let yourself cool off',
- });
- await wait(5000);
- sendMessage({
- id: GameEvent.climax,
- title: 'Leave now.',
- prompts: [
- {
- title: 'Leave',
- onClick: () => {
- window.location.href = '/';
- },
- },
- ],
- });
- }
- },
- },
- {
- title: "I can't",
- onClick: async () => {
- sendMessage({
- id: GameEvent.climax,
- title: "You're pathetic. Stop for a moment",
- });
- setPhase(GamePhase.pause);
- setIntensity(0); // TODO: this essentially restarts the game. is this a good idea?
- await wait(20000);
- sendMessage({
- id: GameEvent.climax,
- title: 'Start to $stroke again',
- duration: 5000,
- });
- setPace(minPace);
- setPhase(GamePhase.active);
- await wait(15000);
- },
- },
- ],
- });
-};
diff --git a/src/game/components/events/double-pace.ts b/src/game/components/events/double-pace.ts
deleted file mode 100644
index 3d71ea6e..00000000
--- a/src/game/components/events/double-pace.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { GameEvent } from '../../../types';
-import { round, wait } from '../../../utils';
-import { EventDataRef, silenceEventData } from '../GameEvents';
-import { randomPaceEvent } from './random-pace';
-
-export const doublePaceEvent = async (data: EventDataRef) => {
- const {
- game: { pace, setPace, sendMessage },
- settings: { maxPace },
- } = data.current;
- const newPace = Math.min(round(pace * 2), maxPace);
- setPace(newPace);
- sendMessage({
- id: GameEvent.doublePace,
- title: 'Double pace!',
- });
- const duration = 9000;
- const durationPortion = duration / 3;
- sendMessage({
- id: GameEvent.doublePace,
- description: '3...',
- });
- await wait(durationPortion);
- sendMessage({
- id: GameEvent.doublePace,
- description: '2...',
- });
- await wait(durationPortion);
- sendMessage({
- id: GameEvent.doublePace,
- description: '1...',
- });
- await wait(durationPortion);
- sendMessage({
- id: GameEvent.doublePace,
- title: 'Done! Back to normal pace',
- description: undefined,
- duration: 5000,
- });
-
- randomPaceEvent(silenceEventData(data));
-};
diff --git a/src/game/components/events/edge.ts b/src/game/components/events/edge.ts
deleted file mode 100644
index d91a97f4..00000000
--- a/src/game/components/events/edge.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { GameEvent } from '../../../types';
-import { wait } from '../../../utils';
-import { EventDataRef } from '../GameEvents';
-
-export const edgeEvent = async (data: EventDataRef) => {
- const {
- game: { setEdged, setPace, sendMessage },
- settings: { minPace },
- } = data.current;
-
- setEdged(true);
- setPace(minPace);
- sendMessage({
- id: GameEvent.edge,
- title: `You should getting close to the edge. Don't cum yet.`,
- duration: 10000,
- });
- await wait(10000);
-};
diff --git a/src/game/components/events/half-pace.ts b/src/game/components/events/half-pace.ts
deleted file mode 100644
index 8c095fdd..00000000
--- a/src/game/components/events/half-pace.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { GameEvent } from '../../../types';
-import { round, wait } from '../../../utils';
-import { EventDataRef, silenceEventData } from '../GameEvents';
-import { randomPaceEvent } from './random-pace';
-
-export const halfPaceEvent = async (data: EventDataRef) => {
- const {
- game: { pace, setPace, sendMessage },
- settings: { minPace },
- } = data.current;
-
- sendMessage({
- id: GameEvent.halfPace,
- title: 'Half pace!',
- });
- const newPace = Math.max(round(pace / 2), minPace);
- setPace(newPace);
- const duration = Math.ceil(Math.random() * 20000) + 12000;
- const durationPortion = duration / 3;
- sendMessage({
- id: GameEvent.halfPace,
- description: '3...',
- });
- await wait(durationPortion);
- sendMessage({
- id: GameEvent.halfPace,
- description: '2...',
- });
- await wait(durationPortion);
- sendMessage({
- id: GameEvent.halfPace,
- description: '1...',
- });
- await wait(durationPortion);
- sendMessage({
- id: GameEvent.halfPace,
- title: 'Done! Back to normal pace',
- description: undefined,
- duration: 5000,
- });
-
- randomPaceEvent(silenceEventData(data));
-};
diff --git a/src/game/components/events/index.ts b/src/game/components/events/index.ts
deleted file mode 100644
index 3fa73b31..00000000
--- a/src/game/components/events/index.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-export * from './clean-up';
-export * from './climax';
-export * from './double-pace';
-export * from './edge';
-export * from './half-pace';
-export * from './pause';
-export * from './random-grip';
-export * from './random-pace';
-export * from './rising-pace';
diff --git a/src/game/components/events/pause.ts b/src/game/components/events/pause.ts
deleted file mode 100644
index 8229edc1..00000000
--- a/src/game/components/events/pause.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { GameEvent } from '../../../types';
-import { wait } from '../../../utils';
-import { GamePhase } from '../../GameProvider';
-import { EventDataRef } from '../GameEvents';
-
-export const pauseEvent = async (data: EventDataRef) => {
- const {
- game: { intensity, setPhase, sendMessage },
- } = data.current;
-
- sendMessage({
- id: GameEvent.pause,
- title: 'Stop stroking!',
- });
- setPhase(GamePhase.pause);
- const duration = Math.ceil(-100 * intensity + 12000);
- await wait(duration);
- sendMessage({
- id: GameEvent.pause,
- title: 'Start stroking again!',
- duration: 5000,
- });
- setPhase(GamePhase.active);
-};
diff --git a/src/game/components/events/random-grip.ts b/src/game/components/events/random-grip.ts
deleted file mode 100644
index 14c65046..00000000
--- a/src/game/components/events/random-grip.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { GameEvent } from '../../../types';
-import { wait } from '../../../utils';
-import { Paws, PawLabels } from '../../GameProvider';
-import { EventDataRef } from '../GameEvents';
-
-export const randomGripEvent = async (data: EventDataRef) => {
- const {
- game: { paws, setPaws, sendMessage },
- } = data.current;
-
- let newPaws: Paws;
- const seed = Math.random();
- if (seed < 0.33) newPaws = paws === Paws.both ? Paws.left : Paws.both;
- if (seed < 0.66) newPaws = paws === Paws.left ? Paws.right : Paws.left;
- newPaws = paws === Paws.right ? Paws.both : Paws.right;
- setPaws(newPaws);
- sendMessage({
- id: GameEvent.randomGrip,
- title: `Grip changed to ${PawLabels[newPaws]}!`,
- duration: 5000,
- });
- await wait(10000);
-};
diff --git a/src/game/components/events/random-pace.ts b/src/game/components/events/random-pace.ts
deleted file mode 100644
index d1212cee..00000000
--- a/src/game/components/events/random-pace.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { GameEvent } from '../../../types';
-import { intensityToPaceRange, round, wait } from '../../../utils';
-import { EventDataRef } from '../GameEvents';
-
-export const randomPaceEvent = async (data: EventDataRef) => {
- const {
- game: { intensity, setPace, sendMessage },
- settings: { minPace, maxPace, steepness, timeshift },
- } = data.current;
-
- const { min, max } = intensityToPaceRange(intensity, steepness, timeshift, {
- min: minPace,
- max: maxPace,
- });
- const newPace = round(Math.random() * (max - min) + min);
- setPace(newPace);
- sendMessage({
- id: GameEvent.randomPace,
- title: `Pace changed to ${newPace}!`,
- duration: 5000,
- });
- await wait(9000);
-};
diff --git a/src/game/components/events/rising-pace.ts b/src/game/components/events/rising-pace.ts
deleted file mode 100644
index 9241865a..00000000
--- a/src/game/components/events/rising-pace.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { GameEvent } from '../../../types';
-import { intensityToPaceRange, wait, round } from '../../../utils';
-import { EventDataRef } from '../GameEvents';
-import { randomPaceEvent } from './random-pace';
-
-export const risingPaceEvent = async (data: EventDataRef) => {
- const {
- game: { intensity, setPace, sendMessage },
- settings: { minPace, maxPace, steepness, timeshift },
- } = data.current;
-
- sendMessage({
- id: GameEvent.risingPace,
- title: 'Rising pace strokes!',
- });
- const acceleration = Math.round(100 / Math.min(intensity, 35));
- const { max } = intensityToPaceRange(intensity, steepness, timeshift, {
- min: minPace,
- max: maxPace,
- });
- const portion = (max - minPace) / acceleration;
- let newPace = minPace;
- setPace(newPace);
- for (let i = 0; i < acceleration; i++) {
- await wait(10000);
- newPace = round(newPace + portion);
- setPace(newPace);
- sendMessage({
- id: GameEvent.risingPace,
- title: `Pace rising to ${newPace}!`,
- duration: 5000,
- });
- }
- await wait(10000);
- sendMessage({
- id: GameEvent.risingPace,
- title: 'Stay at this pace for a bit',
- duration: 5000,
- });
- await wait(15000);
-
- randomPaceEvent(data);
-};
diff --git a/src/game/components/index.ts b/src/game/components/index.ts
index 4cb0ba1e..0c28243c 100644
--- a/src/game/components/index.ts
+++ b/src/game/components/index.ts
@@ -1,14 +1,11 @@
-export * from './events';
export * from './GameEmergencyStop';
-export * from './GameEvents';
export * from './GameHypno';
export * from './GameImages';
export * from './GameInstructions';
export * from './GameIntensity';
export * from './GameMessages';
export * from './GameMeter';
-export * from './GamePace';
-export * from './GameSettings';
+export * from './GameResume';
+export * from './GamePauseMenu';
export * from './GameSound';
export * from './GameVibrator';
-export * from './GameWarmup';
diff --git a/src/game/hooks/UseDispatchEvent.tsx b/src/game/hooks/UseDispatchEvent.tsx
new file mode 100644
index 00000000..6a5ef4e5
--- /dev/null
+++ b/src/game/hooks/UseDispatchEvent.tsx
@@ -0,0 +1,24 @@
+import { useMemo } from 'react';
+import { useContextSelector } from 'use-context-selector';
+import { Events, GameEvent } from '../../engine/pipes/Events';
+import { Pipe } from '../../engine/State';
+import { GameEngineContext } from '../GameProvider';
+
+export function useDispatchEvent() {
+ const injectImpulse = useContextSelector(
+ GameEngineContext,
+ ctx => ctx?.injectImpulse
+ );
+
+ return useMemo(
+ () => ({
+ inject: (pipe: Pipe) => {
+ injectImpulse?.(pipe);
+ },
+ dispatchEvent: (event: GameEvent) => {
+ injectImpulse?.(Events.dispatch(event));
+ },
+ }),
+ [injectImpulse]
+ );
+}
diff --git a/src/game/hooks/UseGameEngine.tsx b/src/game/hooks/UseGameEngine.tsx
new file mode 100644
index 00000000..be226ac4
--- /dev/null
+++ b/src/game/hooks/UseGameEngine.tsx
@@ -0,0 +1,9 @@
+import { useContext } from 'use-context-selector';
+import { GameEngineContext } from '../GameProvider';
+
+export function useGameEngine() {
+ const ctx = useContext(GameEngineContext);
+ if (!ctx)
+ throw new Error('useGameEngine must be used inside GameEngineProvider');
+ return ctx;
+}
diff --git a/src/game/hooks/UseGameFrame.tsx b/src/game/hooks/UseGameFrame.tsx
new file mode 100644
index 00000000..e9f211ad
--- /dev/null
+++ b/src/game/hooks/UseGameFrame.tsx
@@ -0,0 +1,11 @@
+import { useContextSelector } from 'use-context-selector';
+import { lensFromPath, normalizePath, Path } from '../../engine/Lens';
+import { GameEngineContext } from '../GameProvider';
+
+export const useGameFrame = (path: Path): T => {
+ return useContextSelector(GameEngineContext, ctx => {
+ if (!ctx?.frame) return {} as T;
+ const segments = normalizePath(path);
+ return lensFromPath(segments).get(ctx.frame) ?? ({} as T);
+ });
+};
diff --git a/src/game/hooks/index.ts b/src/game/hooks/index.ts
new file mode 100644
index 00000000..719c8bf0
--- /dev/null
+++ b/src/game/hooks/index.ts
@@ -0,0 +1,3 @@
+export * from './UseDispatchEvent';
+export * from './UseGameEngine';
+export * from './UseGameFrame';
diff --git a/src/game/pipes/Settings.ts b/src/game/pipes/Settings.ts
new file mode 100644
index 00000000..085f7e3b
--- /dev/null
+++ b/src/game/pipes/Settings.ts
@@ -0,0 +1,22 @@
+import { useCallback, useRef } from 'react';
+import { useSettings, useImages } from '../../settings';
+import { Composer, Pipe } from '../../engine';
+
+export const useSettingsPipe = (): Pipe => {
+ const [settings] = useSettings();
+ const [images] = useImages();
+ const settingsRef = useRef(settings);
+ const imagesRef = useRef(images);
+
+ settingsRef.current = settings;
+ imagesRef.current = images;
+
+ return useCallback(
+ frame =>
+ Composer.pipe(
+ Composer.set(['settings'], settingsRef.current),
+ Composer.set(['images'], imagesRef.current)
+ )(frame),
+ []
+ );
+};
diff --git a/src/game/pipes/index.ts b/src/game/pipes/index.ts
new file mode 100644
index 00000000..90e26973
--- /dev/null
+++ b/src/game/pipes/index.ts
@@ -0,0 +1 @@
+export * from './Settings';
diff --git a/src/game/plugins/clock.ts b/src/game/plugins/clock.ts
new file mode 100644
index 00000000..e4288032
--- /dev/null
+++ b/src/game/plugins/clock.ts
@@ -0,0 +1,54 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine/Composer';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import Pause from './pause';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Clock: typeof Clock;
+ }
+}
+
+const PLUGIN_ID = 'core.clock';
+
+export type ClockState = {
+ elapsed: number;
+ lastWall: number | null;
+};
+
+const clock = pluginPaths(PLUGIN_ID);
+
+export default class Clock {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Clock',
+ },
+
+ activate: Composer.set(clock, { elapsed: 0, lastWall: null }),
+
+ update: Composer.pipe(
+ Pause.whenPlaying(
+ Composer.do(({ get, over, set }) => {
+ const now = performance.now();
+ const state = get(clock);
+ if (state?.lastWall !== null && state?.lastWall !== undefined) {
+ const delta = now - state.lastWall;
+ over(clock, ({ elapsed = 0, ...rest }) => ({
+ ...rest,
+ elapsed: elapsed + delta,
+ }));
+ }
+ set(clock.lastWall, now);
+ })
+ ),
+ Pause.onPause(() => Composer.set(clock.lastWall, null))
+ ),
+
+ deactivate: Composer.set(clock, undefined),
+ };
+
+ static get paths() {
+ return clock;
+ }
+}
diff --git a/src/game/plugins/dealer.ts b/src/game/plugins/dealer.ts
new file mode 100644
index 00000000..e20e81da
--- /dev/null
+++ b/src/game/plugins/dealer.ts
@@ -0,0 +1,155 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine/Composer';
+import { Pipe } from '../../engine/State';
+import { Events } from '../../engine/pipes/Events';
+import { Scheduler } from '../../engine/pipes/Scheduler';
+import { Sequence } from '../Sequence';
+import Phase, { GamePhase } from './phase';
+import Pause from './pause';
+import Rand from './rand';
+import Clock from './clock';
+import { DiceEvent } from '../../types';
+import {
+ PLUGIN_ID,
+ dice,
+ settings,
+ OUTCOME_DONE,
+ DiceOutcome,
+ DiceLogEntry,
+} from './dice/types';
+import { edgeOutcome } from './dice/edge';
+import { pauseOutcome } from './dice/pause';
+import { randomPaceOutcome } from './dice/randomPace';
+import { doublePaceOutcome } from './dice/doublePace';
+import { halfPaceOutcome } from './dice/halfPace';
+import { risingPaceOutcome } from './dice/risingPace';
+import { randomGripOutcome } from './dice/randomGrip';
+import { cleanUpOutcome } from './dice/cleanUp';
+import { climaxOutcome } from './dice/climax';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Dealer: typeof Dealer;
+ }
+}
+
+const outcomes: DiceOutcome[] = [
+ climaxOutcome,
+ edgeOutcome,
+ randomPaceOutcome,
+ cleanUpOutcome,
+ randomGripOutcome,
+ doublePaceOutcome,
+ halfPaceOutcome,
+ pauseOutcome,
+ risingPaceOutcome,
+];
+
+const rollChances: Record = {
+ [DiceEvent.climax]: 1,
+ [DiceEvent.edge]: 1,
+ [DiceEvent.randomPace]: 10,
+ [DiceEvent.cleanUp]: 25,
+ [DiceEvent.randomGrip]: 50,
+ [DiceEvent.doublePace]: 50,
+ [DiceEvent.halfPace]: 50,
+ [DiceEvent.pause]: 50,
+ [DiceEvent.risingPace]: 30,
+};
+
+const roll = Sequence.for(PLUGIN_ID, 'roll');
+
+export default class Dealer {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Dealer',
+ },
+
+ activate: Composer.pipe(
+ Composer.set(dice, { busy: false, log: [] }),
+ ...outcomes.flatMap(o => (o.activate ? [o.activate] : [])),
+ roll.after(1000, 'check')
+ ),
+
+ update: Composer.pipe(
+ roll.on('check', () =>
+ Composer.pipe(
+ Phase.whenPhase(
+ GamePhase.active,
+ Composer.do(({ get, pipe }) => {
+ const state = get(dice);
+ if (state.busy) return;
+
+ const s = get(settings);
+ const frame = get();
+
+ const eligible = outcomes.filter(o => {
+ if (!s.events.includes(o.id)) return false;
+ if (!rollChances[o.id]) return false;
+ if (o.check && !o.check(frame)) return false;
+ return true;
+ });
+
+ const guaranteed = eligible.find(o => rollChances[o.id] === 1);
+ if (guaranteed) {
+ pipe(roll.dispatch('trigger', guaranteed.id));
+ return;
+ }
+
+ pipe(
+ Rand.next(value => {
+ let cumulative = 0;
+ for (const outcome of eligible) {
+ cumulative += 1 / rollChances[outcome.id];
+ if (value < cumulative) {
+ return roll.dispatch('trigger', outcome.id);
+ }
+ }
+ return Composer.pipe();
+ })
+ );
+ })
+ ),
+ roll.after(1000, 'check')
+ )
+ ),
+
+ roll.on('trigger', event =>
+ Composer.do(({ get, set, over, pipe }) => {
+ set(dice.busy, true);
+ const elapsed = get(Clock.paths)?.elapsed ?? 0;
+ over(dice.log, (log: DiceLogEntry[]) => [
+ ...log,
+ { time: elapsed, event: event.payload },
+ ]);
+ pipe(
+ Events.dispatch({ type: Events.getKey(PLUGIN_ID, event.payload) })
+ );
+ })
+ ),
+
+ ...outcomes.map(o => o.update),
+
+ Events.handle(OUTCOME_DONE, () => Composer.set(dice.busy, false)),
+
+ Phase.onLeave(GamePhase.active, () => Composer.set(dice.busy, false)),
+
+ Pause.onPause(() => Scheduler.holdByPrefix(PLUGIN_ID)),
+ Pause.onResume(() => Scheduler.releaseByPrefix(PLUGIN_ID))
+ ),
+
+ deactivate: Composer.set(dice, undefined),
+ };
+
+ static triggerOutcome(id: DiceEvent): Pipe {
+ return roll.dispatch('trigger', id);
+ }
+
+ static get paths() {
+ return dice;
+ }
+}
+
+export { Paws, PawLabels, pawsPath } from './dice/randomGrip';
+export { type DiceState } from './dice/types';
diff --git a/src/game/plugins/debug.ts b/src/game/plugins/debug.ts
new file mode 100644
index 00000000..5a3bec86
--- /dev/null
+++ b/src/game/plugins/debug.ts
@@ -0,0 +1,64 @@
+import { Composer, pluginPaths } from '../../engine';
+import { sdk } from '../../engine/sdk';
+import type { Pipe } from '../../engine/State';
+import type { Plugin } from '../../engine/plugins/Plugins';
+
+const PLUGIN_ID = 'core.debug';
+
+type DebugState = {
+ visible: boolean;
+};
+
+const debug = pluginPaths(PLUGIN_ID);
+
+let pendingToggle = false;
+let handler: ((e: KeyboardEvent) => void) | null = null;
+
+export default class Debug {
+ static paths = debug;
+
+ static whenDebug(pipe: Pipe): Pipe {
+ return frame => (sdk.debug ? pipe(frame) : frame);
+ }
+
+ static whenVisible(pipe: Pipe): Pipe {
+ return Composer.bind(debug, state => Composer.when(!!state?.visible, pipe));
+ }
+
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Debug',
+ },
+
+ activate: Composer.do(({ set }) => {
+ handler = (e: KeyboardEvent) => {
+ if (e.key === 'F3') {
+ e.preventDefault();
+ pendingToggle = true;
+ }
+ };
+ window.addEventListener('keydown', handler);
+ sdk.debug = false;
+ set(debug.visible, false);
+ }),
+
+ update: Composer.do(({ get, set }) => {
+ if (!pendingToggle) return;
+ pendingToggle = false;
+ const current = get(debug.visible);
+ sdk.debug = !current;
+ set(debug.visible, !current);
+ }),
+
+ deactivate: Composer.do(({ set }) => {
+ if (handler) {
+ window.removeEventListener('keydown', handler);
+ handler = null;
+ }
+ pendingToggle = false;
+ sdk.debug = false;
+ set(debug, undefined);
+ }),
+ };
+}
diff --git a/src/game/plugins/dice/cleanUp.ts b/src/game/plugins/dice/cleanUp.ts
new file mode 100644
index 00000000..94d12f12
--- /dev/null
+++ b/src/game/plugins/dice/cleanUp.ts
@@ -0,0 +1,43 @@
+import { Composer } from '../../../engine/Composer';
+import { Sequence } from '../../Sequence';
+import Phase, { GamePhase } from '../phase';
+import { DiceEvent, CleanUpDescriptions } from '../../../types';
+import {
+ PLUGIN_ID,
+ intensityState,
+ settings,
+ outcomeDone,
+ DiceOutcome,
+} from './types';
+
+const seq = Sequence.for(PLUGIN_ID, 'cleanUp');
+
+export const cleanUpOutcome: DiceOutcome = {
+ id: DiceEvent.cleanUp,
+ check: frame => Composer.get(intensityState)(frame).intensity * 100 >= 75,
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.bind(settings, s =>
+ Composer.pipe(
+ Phase.setPhase(GamePhase.break),
+ seq.message({
+ title: `Lick up any ${CleanUpDescriptions[s.body]}`,
+ duration: undefined,
+ prompts: [seq.prompt(`I'm done, $master`, 'done')],
+ })
+ )
+ )
+ ),
+ seq.on('done', () =>
+ Composer.pipe(
+ seq.message({
+ title: 'Good $player',
+ duration: 5000,
+ prompts: undefined,
+ }),
+ Phase.setPhase(GamePhase.active),
+ outcomeDone()
+ )
+ )
+ ),
+};
diff --git a/src/game/plugins/dice/climax.ts b/src/game/plugins/dice/climax.ts
new file mode 100644
index 00000000..4b841f3e
--- /dev/null
+++ b/src/game/plugins/dice/climax.ts
@@ -0,0 +1,178 @@
+import { Composer } from '../../../engine/Composer';
+import { typedPath } from '../../../engine/Lens';
+import { Sequence } from '../../Sequence';
+import Phase, { GamePhase } from '../phase';
+import Scene from '../scene';
+import Pace from '../pace';
+import Rand from '../rand';
+import { DiceEvent } from '../../../types';
+import { IntensityState } from '../intensity';
+import {
+ PLUGIN_ID,
+ intensityState,
+ settings,
+ outcomeDone,
+ DiceOutcome,
+} from './types';
+import { edged } from './edge';
+
+export type ClimaxResultType = 'climax' | 'denied' | 'ruined' | null;
+
+type ClimaxState = {
+ result: ClimaxResultType;
+};
+
+export const climax = typedPath([PLUGIN_ID, 'climax']);
+
+type ClimaxEndPayload = { countdown: number; denied?: boolean; ruin?: boolean };
+
+const seq = Sequence.for(PLUGIN_ID, 'climax');
+
+export const climaxOutcome: DiceOutcome = {
+ id: DiceEvent.climax,
+ check: frame => {
+ const i = Composer.get(intensityState)(frame).intensity * 100;
+ const s = Composer.get(settings)(frame);
+ return (
+ i >= 100 &&
+ (!s.events.includes(DiceEvent.edge) || !!Composer.get(edged)(frame))
+ );
+ },
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.pipe(
+ Phase.setPhase(GamePhase.finale),
+ seq.message({
+ title: 'Are you edging?',
+ prompts: [
+ seq.prompt("I'm edging, $master", 'edging'),
+ seq.prompt("I can't", 'cant'),
+ ],
+ })
+ )
+ ),
+
+ seq.on('edging', () =>
+ Composer.bind(settings, s =>
+ Composer.pipe(
+ seq.message({
+ title: 'Stay on the edge, $player',
+ prompts: undefined,
+ }),
+ Pace.setPace(s.minPace),
+ seq.after(3000, 'countdown3')
+ )
+ )
+ ),
+
+ seq.on('countdown3', () =>
+ Composer.pipe(
+ seq.message({ description: '3...' }),
+ seq.after(5000, 'countdown2')
+ )
+ ),
+
+ seq.on('countdown2', () =>
+ Composer.pipe(
+ seq.message({ description: '2...' }),
+ seq.after(5000, 'countdown1')
+ )
+ ),
+
+ seq.on('countdown1', () =>
+ Composer.pipe(
+ seq.message({ description: '1...' }),
+ seq.after(5000, 'resolve')
+ )
+ ),
+
+ seq.on('resolve', () =>
+ Composer.bind(settings, s =>
+ Rand.next(roll => {
+ if (roll * 100 > s.climaxChance) {
+ return Composer.pipe(
+ Composer.set(climax.result, 'denied'),
+ Phase.setPhase(GamePhase.break),
+ seq.message({
+ title: '$HANDS OFF! Do not cum!',
+ description: undefined,
+ }),
+ seq.after(1000, 'end', { countdown: 5, denied: true })
+ );
+ }
+ return Rand.next(ruinRoll => {
+ const ruin = ruinRoll * 100 <= s.ruinChance;
+ return Composer.pipe(
+ Composer.set(climax.result, ruin ? 'ruined' : 'climax'),
+ Phase.setPhase(ruin ? GamePhase.break : GamePhase.climax),
+ seq.message({
+ title: ruin ? '$HANDS OFF! Ruin your orgasm!' : 'Cum!',
+ description: undefined,
+ }),
+ seq.after(3000, 'end', { countdown: 10, ruin })
+ );
+ });
+ })
+ )
+ ),
+
+ seq.on('end', event => {
+ const { countdown, denied, ruin } = event.payload;
+ const decay = Composer.over(intensityState, (s: IntensityState) => ({
+ intensity: Math.max(0, s.intensity - (denied ? 0.2 : 0.1)),
+ }));
+ if (countdown <= 1) {
+ if (denied) {
+ return Composer.pipe(
+ decay,
+ seq.message({ title: 'Good $player. Let yourself cool off' }),
+ seq.after(5000, 'cantEnd')
+ );
+ }
+ return Composer.pipe(
+ decay,
+ seq.message({
+ title: ruin ? 'Clench in desperation' : 'Good job, $player',
+ prompts: [seq.prompt('Leave', 'leave')],
+ })
+ );
+ }
+ return Composer.pipe(
+ decay,
+ seq.after(1000, 'end', { countdown: countdown - 1, denied, ruin })
+ );
+ }),
+
+ seq.on('cantEnd', () =>
+ seq.message({
+ title: 'Leave now.',
+ prompts: [seq.prompt('Leave', 'leave')],
+ })
+ ),
+
+ seq.on('cant', () =>
+ Composer.pipe(
+ seq.message({
+ title: "You're pathetic. Stop for a moment",
+ prompts: undefined,
+ }),
+ Phase.setPhase(GamePhase.break),
+ Composer.set(intensityState.intensity, 0),
+ seq.after(20000, 'cantResume')
+ )
+ ),
+
+ seq.on('cantResume', () =>
+ Composer.bind(settings, s =>
+ Composer.pipe(
+ seq.message({ title: 'Start to $stroke again', duration: 5000 }),
+ Pace.setPace(s.minPace),
+ Phase.setPhase(GamePhase.active),
+ outcomeDone()
+ )
+ )
+ ),
+
+ seq.on('leave', () => Scene.setScene('end'))
+ ),
+};
diff --git a/src/game/plugins/dice/doublePace.ts b/src/game/plugins/dice/doublePace.ts
new file mode 100644
index 00000000..73aa3b31
--- /dev/null
+++ b/src/game/plugins/dice/doublePace.ts
@@ -0,0 +1,58 @@
+import { Composer } from '../../../engine/Composer';
+import { Sequence } from '../../Sequence';
+import Pace from '../pace';
+import { DiceEvent } from '../../../types';
+import { round } from '../../../utils';
+import {
+ PLUGIN_ID,
+ paceState,
+ intensityState,
+ settings,
+ outcomeDone,
+ DiceOutcome,
+} from './types';
+import { doRandomPace } from './randomPace';
+
+const seq = Sequence.for(PLUGIN_ID, 'doublePace');
+
+export const doublePaceOutcome: DiceOutcome = {
+ id: DiceEvent.doublePace,
+ check: frame => Composer.get(intensityState)(frame).intensity * 100 >= 20,
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.bind(paceState, pace =>
+ Composer.bind(settings, s => {
+ const newPace = Math.min(round(pace.pace * 2), s.maxPace);
+ return Composer.pipe(
+ Pace.setPace(newPace),
+ seq.message({ title: 'Double pace!', description: '3...' }),
+ seq.after(3000, 'step2')
+ );
+ })
+ )
+ ),
+ seq.on('step2', () =>
+ Composer.pipe(
+ seq.message({ description: '2...' }),
+ seq.after(3000, 'step3')
+ )
+ ),
+ seq.on('step3', () =>
+ Composer.pipe(
+ seq.message({ description: '1...' }),
+ seq.after(3000, 'done')
+ )
+ ),
+ seq.on('done', () =>
+ Composer.pipe(
+ seq.message({
+ title: 'Done! Back to normal pace',
+ description: undefined,
+ duration: 5000,
+ }),
+ doRandomPace(),
+ outcomeDone()
+ )
+ )
+ ),
+};
diff --git a/src/game/plugins/dice/edge.ts b/src/game/plugins/dice/edge.ts
new file mode 100644
index 00000000..b18c3bac
--- /dev/null
+++ b/src/game/plugins/dice/edge.ts
@@ -0,0 +1,40 @@
+import { Composer } from '../../../engine/Composer';
+import { typedPath } from '../../../engine/Lens';
+import { Sequence } from '../../Sequence';
+import Pace from '../pace';
+import { DiceEvent } from '../../../types';
+import {
+ PLUGIN_ID,
+ intensityState,
+ settings,
+ outcomeDone,
+ DiceOutcome,
+} from './types';
+
+export const edged = typedPath([PLUGIN_ID, 'edged']);
+
+const seq = Sequence.for(PLUGIN_ID, 'edge');
+
+export const edgeOutcome: DiceOutcome = {
+ id: DiceEvent.edge,
+ check: frame => {
+ const i = Composer.get(intensityState)(frame).intensity * 100;
+ return i >= 90 && !Composer.get(edged)(frame);
+ },
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.bind(settings, s =>
+ Composer.pipe(
+ Composer.set(edged, true),
+ Pace.setPace(s.minPace),
+ seq.message({
+ title: `You should be getting close to the edge. Don't cum yet.`,
+ duration: 10000,
+ }),
+ seq.after(10000, 'done')
+ )
+ )
+ ),
+ seq.on('done', () => outcomeDone())
+ ),
+};
diff --git a/src/game/plugins/dice/halfPace.ts b/src/game/plugins/dice/halfPace.ts
new file mode 100644
index 00000000..1865b9da
--- /dev/null
+++ b/src/game/plugins/dice/halfPace.ts
@@ -0,0 +1,70 @@
+import { Composer } from '../../../engine/Composer';
+import { Sequence } from '../../Sequence';
+import Pace from '../pace';
+import Rand from '../rand';
+import { DiceEvent } from '../../../types';
+import { round } from '../../../utils';
+import {
+ PLUGIN_ID,
+ paceState,
+ intensityState,
+ settings,
+ outcomeDone,
+ DiceOutcome,
+} from './types';
+import { doRandomPace } from './randomPace';
+
+type HalfPacePayload = { portion: number };
+
+const seq = Sequence.for(PLUGIN_ID, 'halfPace');
+
+export const halfPaceOutcome: DiceOutcome = {
+ id: DiceEvent.halfPace,
+ check: frame => {
+ const i = Composer.get(intensityState)(frame).intensity * 100;
+ return i >= 10 && i <= 50;
+ },
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.do(({ get, pipe }) => {
+ const pace = get(paceState);
+ const s = get(settings);
+ const newPace = Math.max(round(pace.pace / 2), s.minPace);
+ pipe(
+ Rand.next(v => {
+ const duration = Math.ceil(v * 20000) + 12000;
+ const portion = duration / 3;
+ return Composer.pipe(
+ Pace.setPace(newPace),
+ seq.message({ title: 'Half pace!', description: '3...' }),
+ seq.after(portion, 'step2', { portion })
+ );
+ })
+ );
+ })
+ ),
+ seq.on('step2', event =>
+ Composer.pipe(
+ seq.message({ description: '2...' }),
+ seq.after(event.payload.portion, 'step3', event.payload)
+ )
+ ),
+ seq.on('step3', event =>
+ Composer.pipe(
+ seq.message({ description: '1...' }),
+ seq.after(event.payload.portion, 'done')
+ )
+ ),
+ seq.on('done', () =>
+ Composer.pipe(
+ seq.message({
+ title: 'Done! Back to normal pace',
+ description: undefined,
+ duration: 5000,
+ }),
+ doRandomPace(),
+ outcomeDone()
+ )
+ )
+ ),
+};
diff --git a/src/game/plugins/dice/pause.ts b/src/game/plugins/dice/pause.ts
new file mode 100644
index 00000000..7ca86ff5
--- /dev/null
+++ b/src/game/plugins/dice/pause.ts
@@ -0,0 +1,31 @@
+import { Composer } from '../../../engine/Composer';
+import { Sequence } from '../../Sequence';
+import Phase, { GamePhase } from '../phase';
+import { DiceEvent } from '../../../types';
+import { PLUGIN_ID, intensityState, outcomeDone, DiceOutcome } from './types';
+
+const seq = Sequence.for(PLUGIN_ID, 'pause');
+
+export const pauseOutcome: DiceOutcome = {
+ id: DiceEvent.pause,
+ check: frame => Composer.get(intensityState)(frame).intensity * 100 >= 15,
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.bind(intensityState, ist => {
+ const i = ist.intensity * 100;
+ return Composer.pipe(
+ seq.message({ title: 'Stop stroking!' }),
+ Phase.setPhase(GamePhase.break),
+ seq.after(Math.ceil(-100 * i + 12000), 'resume')
+ );
+ })
+ ),
+ seq.on('resume', () =>
+ Composer.pipe(
+ seq.message({ title: 'Start stroking again!', duration: 5000 }),
+ Phase.setPhase(GamePhase.active),
+ outcomeDone()
+ )
+ )
+ ),
+};
diff --git a/src/game/plugins/dice/randomGrip.ts b/src/game/plugins/dice/randomGrip.ts
new file mode 100644
index 00000000..bf379cba
--- /dev/null
+++ b/src/game/plugins/dice/randomGrip.ts
@@ -0,0 +1,48 @@
+import { Composer } from '../../../engine/Composer';
+import { typedPath } from '../../../engine/Lens';
+import { Sequence } from '../../Sequence';
+import { DiceEvent } from '../../../types';
+import Rand from '../rand';
+import { PLUGIN_ID, outcomeDone, DiceOutcome } from './types';
+
+export enum Paws {
+ left = 'left',
+ right = 'right',
+ both = 'both',
+}
+
+export const PawLabels: Record = {
+ left: 'Left',
+ right: 'Right',
+ both: 'Both',
+};
+
+export const pawsPath = typedPath([PLUGIN_ID, 'paws']);
+
+const allPaws = Object.values(Paws);
+
+const seq = Sequence.for(PLUGIN_ID, 'randomGrip');
+
+export const randomGripOutcome: DiceOutcome = {
+ id: DiceEvent.randomGrip,
+ activate: Rand.pick(allPaws, paw => Composer.set(pawsPath, paw)),
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.bind(pawsPath, currentPaws =>
+ Rand.pick(
+ allPaws.filter(p => p !== currentPaws),
+ newPaws =>
+ Composer.pipe(
+ Composer.set(pawsPath, newPaws),
+ seq.message({
+ title: `Grip changed to ${PawLabels[newPaws]}!`,
+ duration: 5000,
+ }),
+ seq.after(10000, 'done')
+ )
+ )
+ )
+ ),
+ seq.on('done', () => outcomeDone())
+ ),
+};
diff --git a/src/game/plugins/dice/randomPace.ts b/src/game/plugins/dice/randomPace.ts
new file mode 100644
index 00000000..0e2d1325
--- /dev/null
+++ b/src/game/plugins/dice/randomPace.ts
@@ -0,0 +1,48 @@
+import { Composer } from '../../../engine/Composer';
+import { Sequence } from '../../Sequence';
+import { Pipe } from '../../../engine/State';
+import Pace from '../pace';
+import Rand from '../rand';
+import { DiceEvent } from '../../../types';
+import { intensityToPaceRange, round } from '../../../utils';
+import {
+ PLUGIN_ID,
+ intensityState,
+ settings,
+ outcomeDone,
+ DiceOutcome,
+} from './types';
+
+const seq = Sequence.for(PLUGIN_ID, 'randomPace');
+
+export const doRandomPace = (): Pipe =>
+ Composer.do(({ get, pipe }) => {
+ const i = get(intensityState).intensity;
+ const s = get(settings);
+ const { min, max } = intensityToPaceRange(
+ i * 100,
+ s.steepness,
+ s.timeshift,
+ { min: s.minPace, max: s.maxPace }
+ );
+ pipe(
+ Rand.nextFloatRange(min, max, v => {
+ const newPace = round(v);
+ return Composer.pipe(
+ Pace.setPace(newPace),
+ seq.message({
+ title: `Pace changed to ${newPace}!`,
+ duration: 5000,
+ })
+ );
+ })
+ );
+ });
+
+export const randomPaceOutcome: DiceOutcome = {
+ id: DiceEvent.randomPace,
+ update: Composer.pipe(
+ seq.on(() => Composer.pipe(doRandomPace(), seq.after(9000, 'done'))),
+ seq.on('done', () => outcomeDone())
+ ),
+};
diff --git a/src/game/plugins/dice/risingPace.ts b/src/game/plugins/dice/risingPace.ts
new file mode 100644
index 00000000..563116e8
--- /dev/null
+++ b/src/game/plugins/dice/risingPace.ts
@@ -0,0 +1,72 @@
+import { Composer } from '../../../engine/Composer';
+import { Sequence } from '../../Sequence';
+import Pace from '../pace';
+import { DiceEvent } from '../../../types';
+import { intensityToPaceRange, round } from '../../../utils';
+import {
+ PLUGIN_ID,
+ intensityState,
+ settings,
+ outcomeDone,
+ DiceOutcome,
+} from './types';
+import { doRandomPace } from './randomPace';
+
+type RisingPacePayload = {
+ current: number;
+ portion: number;
+ remaining: number;
+};
+
+const seq = Sequence.for(PLUGIN_ID, 'risingPace');
+
+export const risingPaceOutcome: DiceOutcome = {
+ id: DiceEvent.risingPace,
+ check: frame => Composer.get(intensityState)(frame).intensity * 100 >= 30,
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.bind(intensityState, ist =>
+ Composer.bind(settings, s => {
+ const i = ist.intensity * 100;
+ const acceleration = Math.round(100 / Math.min(i, 35));
+ const { max } = intensityToPaceRange(i, s.steepness, s.timeshift, {
+ min: s.minPace,
+ max: s.maxPace,
+ });
+ const portion = (max - s.minPace) / acceleration;
+ return Composer.pipe(
+ seq.message({ title: 'Rising pace strokes!' }),
+ Pace.setPace(s.minPace),
+ seq.after(10000, 'step', {
+ current: s.minPace,
+ portion,
+ remaining: acceleration,
+ })
+ );
+ })
+ )
+ ),
+ seq.on('step', event => {
+ const { current, portion, remaining } = event.payload;
+ const newPace = round(current + portion);
+ return Composer.pipe(
+ Pace.setPace(newPace),
+ seq.message({ title: `Pace rising to ${newPace}!`, duration: 5000 }),
+ remaining <= 1
+ ? seq.after(10000, 'hold')
+ : seq.after(10000, 'step', {
+ current: newPace,
+ portion,
+ remaining: remaining - 1,
+ })
+ );
+ }),
+ seq.on('hold', () =>
+ Composer.pipe(
+ seq.message({ title: 'Stay at this pace for a bit', duration: 5000 }),
+ seq.after(15000, 'done')
+ )
+ ),
+ seq.on('done', () => Composer.pipe(doRandomPace(), outcomeDone()))
+ ),
+};
diff --git a/src/game/plugins/dice/types.ts b/src/game/plugins/dice/types.ts
new file mode 100644
index 00000000..49ca81de
--- /dev/null
+++ b/src/game/plugins/dice/types.ts
@@ -0,0 +1,32 @@
+import { Pipe, GameFrame } from '../../../engine/State';
+import { Events } from '../../../engine/pipes/Events';
+import { pluginPaths } from '../../../engine/plugins/Plugins';
+import { typedPath } from '../../../engine/Lens';
+import { IntensityState } from '../intensity';
+import { PaceState } from '../pace';
+import { Settings } from '../../../settings';
+import { DiceEvent } from '../../../types';
+
+export const PLUGIN_ID = 'core.dice';
+
+export type DiceLogEntry = { time: number; event: DiceEvent };
+
+export type DiceState = {
+ busy: boolean;
+ log: DiceLogEntry[];
+};
+
+export const dice = pluginPaths(PLUGIN_ID);
+export const paceState = typedPath(['core.pace']);
+export const intensityState = typedPath(['core.intensity']);
+export const settings = typedPath(['settings']);
+
+export const OUTCOME_DONE = Events.getKey(PLUGIN_ID, 'outcome.done');
+export const outcomeDone = (): Pipe => Events.dispatch({ type: OUTCOME_DONE });
+
+export type DiceOutcome = {
+ id: DiceEvent;
+ check?: (frame: GameFrame) => boolean;
+ activate?: Pipe;
+ update: Pipe;
+};
diff --git a/src/game/plugins/emergencyStop.ts b/src/game/plugins/emergencyStop.ts
new file mode 100644
index 00000000..87348943
--- /dev/null
+++ b/src/game/plugins/emergencyStop.ts
@@ -0,0 +1,77 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine/Composer';
+import { Scheduler } from '../../engine/pipes/Scheduler';
+import { typedPath } from '../../engine/Lens';
+import { Sequence } from '../Sequence';
+import Phase, { GamePhase } from './phase';
+import Pause from './pause';
+import Pace from './pace';
+import { IntensityState } from './intensity';
+import { Settings } from '../../settings';
+
+const PLUGIN_ID = 'core.emergencyStop';
+
+const intensityState = typedPath(['core.intensity']);
+const settings = typedPath(['settings']);
+
+type CountdownPayload = { remaining: number };
+
+const seq = Sequence.for(PLUGIN_ID, 'stop');
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ EmergencyStop: typeof EmergencyStop;
+ }
+}
+
+export default class EmergencyStop {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'EmergencyStop',
+ },
+
+ update: Composer.pipe(
+ seq.on(() =>
+ Composer.bind(intensityState, ist =>
+ Composer.bind(settings, s => {
+ const i = ist.intensity * 100;
+ const timeToCalmDown = Math.ceil((i * 500 + 10000) / 1000);
+ return Composer.pipe(
+ Phase.setPhase(GamePhase.break),
+ seq.message({ title: 'Calm down with your $hands off.' }),
+ Composer.over(intensityState, (st: IntensityState) => ({
+ intensity: Math.max(0, st.intensity - 0.3),
+ })),
+ Pace.setPace(s.minPace),
+ seq.after(5000, 'countdown', { remaining: timeToCalmDown })
+ );
+ })
+ )
+ ),
+
+ seq.on('countdown', event => {
+ const { remaining } = event.payload;
+ if (remaining <= 0) {
+ return Composer.pipe(
+ seq.message({
+ title: 'Put your $hands back.',
+ description: undefined,
+ duration: 5000,
+ }),
+ seq.after(2000, 'resume')
+ );
+ }
+ return Composer.pipe(
+ seq.message({ description: `${remaining}...` }),
+ seq.after(1000, 'countdown', { remaining: remaining - 1 })
+ );
+ }),
+
+ seq.on('resume', () => Phase.setPhase(GamePhase.active)),
+
+ Pause.onPause(() => Scheduler.holdByPrefix(PLUGIN_ID)),
+ Pause.onResume(() => Scheduler.releaseByPrefix(PLUGIN_ID))
+ ),
+ };
+}
diff --git a/src/game/plugins/fps.ts b/src/game/plugins/fps.ts
new file mode 100644
index 00000000..8a386673
--- /dev/null
+++ b/src/game/plugins/fps.ts
@@ -0,0 +1,116 @@
+import { Composer, pluginPaths } from '../../engine';
+import type { Plugin } from '../../engine/plugins/Plugins';
+import Debug from './debug';
+
+const PLUGIN_ID = 'core.fps';
+const ELEMENT_ATTR = 'data-plugin-id';
+const STYLE_ID = `${PLUGIN_ID}-styles`;
+const HISTORY_SIZE = 30;
+
+type FpsContext = {
+ el: HTMLElement;
+ tickTimestamps: number[];
+};
+
+const fps = pluginPaths(PLUGIN_ID);
+
+let rafId = 0;
+let lastFrameTime: number | null = null;
+let fpsHistory: number[] = [];
+
+function rafLoop() {
+ const now = performance.now();
+ if (lastFrameTime !== null) {
+ const delta = now - lastFrameTime;
+ if (delta > 0) {
+ fpsHistory = [...fpsHistory, 1000 / delta].slice(-HISTORY_SIZE);
+ }
+ }
+ lastFrameTime = now;
+ rafId = requestAnimationFrame(rafLoop);
+}
+
+export default class Fps {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'FPS Counter',
+ },
+
+ activate: Composer.do(({ get, set }) => {
+ const style =
+ document.getElementById(STYLE_ID) ?? document.createElement('style');
+ style.id = STYLE_ID;
+ style.textContent = `
+ [${ELEMENT_ATTR}="${PLUGIN_ID}"] {
+ position: fixed;
+ top: 8px;
+ right: 8px;
+ background: black;
+ color: white;
+ padding: 4px 8px;
+ font-family: monospace;
+ font-size: 12px;
+ z-index: 9999;
+ pointer-events: none;
+ }
+ `;
+ if (!style.parentNode) document.head.appendChild(style);
+
+ const existing = document.querySelector(
+ `[${ELEMENT_ATTR}="${PLUGIN_ID}"]`
+ );
+ if (existing) existing.remove();
+
+ const el = document.createElement('div');
+ el.setAttribute(ELEMENT_ATTR, PLUGIN_ID);
+
+ const visible = get(Debug.paths.visible);
+ el.style.display = visible ? '' : 'none';
+
+ document.body.appendChild(el);
+
+ lastFrameTime = null;
+ fpsHistory = [];
+ rafId = requestAnimationFrame(rafLoop);
+
+ set(fps, { el, tickTimestamps: [] });
+ }),
+
+ update: Composer.do(({ get, set }) => {
+ const ctx = get(fps);
+ if (!ctx) return;
+
+ const visible = get(Debug.paths.visible);
+ if (ctx.el) ctx.el.style.display = visible ? '' : 'none';
+ if (!visible) return;
+
+ const avgFps =
+ fpsHistory.length > 0
+ ? fpsHistory.reduce((sum, v) => sum + v, 0) / fpsHistory.length
+ : 0;
+
+ const now = performance.now();
+ const cutoff = now - 1000;
+ const tickTimestamps = [...ctx.tickTimestamps, now].filter(
+ t => t >= cutoff
+ );
+
+ if (ctx.el)
+ ctx.el.textContent = `${Math.round(avgFps)} FPS / ${tickTimestamps.length} TPS`;
+
+ set(fps, { ...ctx, tickTimestamps });
+ }),
+
+ deactivate: Composer.do(({ get, set }) => {
+ cancelAnimationFrame(rafId);
+ rafId = 0;
+ lastFrameTime = null;
+ fpsHistory = [];
+
+ const el = get(fps)?.el;
+ if (el) el.remove();
+ set(fps, undefined);
+ }),
+ };
+}
diff --git a/src/game/plugins/hypno.ts b/src/game/plugins/hypno.ts
new file mode 100644
index 00000000..640f1f74
--- /dev/null
+++ b/src/game/plugins/hypno.ts
@@ -0,0 +1,78 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine/Composer';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import { typedPath } from '../../engine/Lens';
+import { GameTiming } from '../../engine/State';
+import { GamePhase, PhaseState } from './phase';
+import Pause from './pause';
+import { IntensityState } from './intensity';
+import { Settings } from '../../settings';
+import { GameHypnoType, HypnoPhrases } from '../../types';
+import Rand from './rand';
+
+const PLUGIN_ID = 'core.hypno';
+
+export type HypnoState = {
+ currentPhrase: number;
+ timer: number;
+};
+
+const hypno = pluginPaths(PLUGIN_ID);
+const timing = typedPath([]);
+const phaseState = typedPath(['core.phase']);
+const intensityState = typedPath(['core.intensity']);
+const settings = typedPath(['settings']);
+
+export default class Hypno {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Hypno',
+ },
+
+ activate: Composer.set(hypno, {
+ currentPhrase: 0,
+ timer: 0,
+ }),
+
+ update: Pause.whenPlaying(
+ Composer.do(({ get, set, pipe }) => {
+ const phase = get(phaseState).current;
+ if (phase !== GamePhase.active) return;
+
+ const s = get(settings);
+ if (s.hypno === GameHypnoType.off) return;
+
+ const i = get(intensityState).intensity * 100;
+ const delay = 3000 - i * 29;
+ if (delay <= 0) return;
+
+ const delta = get(timing.step);
+ const state = get(hypno);
+ const elapsed = state.timer + delta;
+ if (elapsed < delay) {
+ set(hypno.timer, elapsed);
+ return;
+ }
+
+ const phrases = HypnoPhrases[s.hypno];
+ if (phrases.length <= 0) return;
+
+ pipe(
+ Rand.nextInt(phrases.length, idx =>
+ Composer.set(hypno, {
+ currentPhrase: idx,
+ timer: 0,
+ })
+ )
+ );
+ })
+ ),
+
+ deactivate: Composer.set(hypno, undefined),
+ };
+
+ static get paths() {
+ return hypno;
+ }
+}
diff --git a/src/game/plugins/image.ts b/src/game/plugins/image.ts
new file mode 100644
index 00000000..a758ba47
--- /dev/null
+++ b/src/game/plugins/image.ts
@@ -0,0 +1,109 @@
+import { pluginPaths, type Plugin } from '../../engine/plugins/Plugins';
+import { Pipe } from '../../engine/State';
+import { Composer } from '../../engine';
+import { Events } from '../../engine/pipes/Events';
+import { ImageItem } from '../../types';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Image: typeof Image;
+ }
+}
+
+const PLUGIN_ID = 'core.images';
+
+export type ImageState = {
+ currentImage?: ImageItem;
+ seenImages: ImageItem[];
+ nextImages: ImageItem[];
+};
+
+const image = pluginPaths(PLUGIN_ID);
+
+const eventType = Events.getKeys(
+ PLUGIN_ID,
+ 'push_next',
+ 'set_image',
+ 'set_next_images'
+);
+
+export default class Image {
+ static pushNextImage(img: ImageItem): Pipe {
+ return Events.dispatch({ type: eventType.pushNext, payload: img });
+ }
+
+ static setCurrentImage(img: ImageItem | undefined): Pipe {
+ return Events.dispatch({ type: eventType.setImage, payload: img });
+ }
+
+ static setNextImages(imgs: ImageItem[]): Pipe {
+ return Events.dispatch({ type: eventType.setNextImages, payload: imgs });
+ }
+
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Image',
+ },
+
+ activate: Composer.set(image, {
+ currentImage: undefined,
+ seenImages: [],
+ nextImages: [],
+ }),
+
+ update: Composer.pipe(
+ Events.handle(eventType.pushNext, event =>
+ Composer.over(
+ image,
+ ({ currentImage, seenImages = [], nextImages = [] }) => {
+ const newImage = event.payload;
+ const next = [...nextImages];
+ const seen = [...seenImages];
+
+ if (currentImage) {
+ const existingIndex = seen.indexOf(currentImage);
+ if (existingIndex !== -1) {
+ seen.splice(existingIndex, 1);
+ }
+ seen.unshift(currentImage);
+ }
+
+ if (seen.length > 500) {
+ seen.pop();
+ }
+
+ next.push(newImage);
+ const newCurrent = next.shift();
+
+ return {
+ currentImage: newCurrent,
+ seenImages: seen,
+ nextImages: next,
+ };
+ }
+ )
+ ),
+
+ Events.handle(eventType.setNextImages, event =>
+ Composer.over(image, state => ({
+ ...state,
+ nextImages: event.payload,
+ }))
+ ),
+
+ Events.handle(eventType.setImage, event =>
+ Composer.over(image, state => ({
+ ...state,
+ currentImage: event.payload,
+ }))
+ )
+ ),
+
+ deactivate: Composer.set(image, undefined),
+ };
+
+ static get paths() {
+ return image;
+ }
+}
diff --git a/src/game/plugins/index.ts b/src/game/plugins/index.ts
new file mode 100644
index 00000000..d7bbf3d6
--- /dev/null
+++ b/src/game/plugins/index.ts
@@ -0,0 +1,46 @@
+import { PluginManager } from '../../engine/plugins/PluginManager';
+import { Composer } from '../../engine/Composer';
+import { Pipe } from '../../engine/State';
+import Scene from './scene';
+import Debug from './debug';
+import Fps from './fps';
+import Intensity from './intensity';
+import Pause from './pause';
+import Phase from './phase';
+import Pace from './pace';
+import PerfOverlay from './perf';
+import Image from './image';
+import RandomImages from './randomImages';
+import Warmup from './warmup';
+import Stroke from './stroke';
+import Rand from './rand';
+import Dealer from './dealer';
+import EmergencyStop from './emergencyStop';
+import Hypno from './hypno';
+import Messages from './messages';
+import Clock from './clock';
+
+const plugins = [
+ Scene,
+ Phase,
+ Rand,
+ Messages,
+ Image,
+ Debug,
+ Pause,
+ Clock,
+ Intensity,
+ Pace,
+ Stroke,
+ Dealer,
+ Warmup,
+ Hypno,
+ RandomImages,
+ EmergencyStop,
+ Fps,
+ PerfOverlay,
+];
+
+export const registerPlugins: Pipe = Composer.pipe(
+ ...plugins.map(PluginManager.register)
+);
diff --git a/src/game/plugins/intensity.ts b/src/game/plugins/intensity.ts
new file mode 100644
index 00000000..012f1512
--- /dev/null
+++ b/src/game/plugins/intensity.ts
@@ -0,0 +1,54 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine/Composer';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import { typedPath } from '../../engine/Lens';
+import { Settings } from '../../settings';
+import { GameTiming } from '../../engine/State';
+import Phase, { GamePhase } from './phase';
+import Pause from './pause';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Intensity: typeof Intensity;
+ }
+}
+
+const PLUGIN_ID = 'core.intensity';
+
+export type IntensityState = {
+ intensity: number;
+};
+
+const intensity = pluginPaths(PLUGIN_ID);
+const timing = typedPath([]);
+const settings = typedPath(['settings']);
+
+export default class Intensity {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Intensity',
+ },
+
+ activate: Composer.set(intensity, { intensity: 0 }),
+
+ update: Pause.whenPlaying(
+ Phase.whenPhase(
+ GamePhase.active,
+ Composer.do(({ get, over }) => {
+ const delta = get(timing.step);
+ const s = get(settings);
+ over(intensity, ({ intensity: i = 0 }) => ({
+ intensity: Math.min(1, i + delta / (s.gameDuration * 1000)),
+ }));
+ })
+ )
+ ),
+
+ deactivate: Composer.set(intensity, undefined),
+ };
+
+ static get paths() {
+ return intensity;
+ }
+}
diff --git a/src/game/plugins/messages.ts b/src/game/plugins/messages.ts
new file mode 100644
index 00000000..68693053
--- /dev/null
+++ b/src/game/plugins/messages.ts
@@ -0,0 +1,114 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import { Pipe } from '../../engine/State';
+import { Composer } from '../../engine/Composer';
+import { Events, GameEvent } from '../../engine/pipes/Events';
+import { Scheduler } from '../../engine/pipes/Scheduler';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Messages: typeof Messages;
+ }
+}
+
+export interface GameMessagePrompt {
+ title: string;
+ event: GameEvent;
+}
+
+export interface GameMessage {
+ id: string;
+ title: string;
+ description?: string;
+ prompts?: GameMessagePrompt[];
+ duration?: number;
+}
+
+export type PartialGameMessage = Partial & Pick;
+
+export type MessageState = {
+ messages: GameMessage[];
+};
+
+const PLUGIN_ID = 'core.messages';
+
+const paths = pluginPaths(PLUGIN_ID);
+
+const eventType = Events.getKeys(PLUGIN_ID, 'send_message', 'expire_message');
+
+export default class Messages {
+ static send(message: PartialGameMessage): Pipe {
+ return Events.dispatch({
+ type: eventType.sendMessage,
+ payload: message,
+ });
+ }
+
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Messages',
+ },
+
+ activate: Composer.set(paths, { messages: [] }),
+
+ update: Composer.pipe(
+ Events.handle(eventType.sendMessage, event =>
+ Composer.pipe(
+ Composer.over(paths, ({ messages }) => {
+ const patch = event.payload;
+ const index = messages.findIndex(m => m.id === patch.id);
+ const existing = messages[index];
+
+ if (!existing && !patch.title) return { messages };
+
+ const updated = [...messages];
+ updated[index < 0 ? updated.length : index] = {
+ ...existing,
+ ...patch,
+ };
+
+ return { messages: updated };
+ }),
+
+ Composer.do(({ get, pipe }) => {
+ const { messages } = get(paths);
+ const messageId = event.payload.id;
+ const updated = messages.find(m => m.id === messageId);
+ const scheduleId = Scheduler.getKey(
+ PLUGIN_ID,
+ `message/${messageId}`
+ );
+
+ if (updated?.duration !== undefined) {
+ return pipe(
+ Scheduler.schedule({
+ id: scheduleId,
+ duration: updated.duration,
+ event: {
+ type: eventType.expireMessage,
+ payload: updated.id,
+ },
+ })
+ );
+ } else {
+ return pipe(Scheduler.cancel(scheduleId));
+ }
+ })
+ )
+ ),
+
+ Events.handle(eventType.expireMessage, event =>
+ Composer.over(paths, ({ messages }) => ({
+ messages: messages.filter(m => m.id !== event.payload),
+ }))
+ )
+ ),
+
+ deactivate: Composer.set(paths, undefined),
+ };
+
+ static get paths() {
+ return paths;
+ }
+}
diff --git a/src/game/plugins/pace.ts b/src/game/plugins/pace.ts
new file mode 100644
index 00000000..2161b80e
--- /dev/null
+++ b/src/game/plugins/pace.ts
@@ -0,0 +1,77 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Pipe } from '../../engine/State';
+import { typedPath } from '../../engine/Lens';
+import { Settings } from '../../settings';
+import { Composer, pluginPaths } from '../../engine';
+import Clock from './clock';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Pace: typeof Pace;
+ }
+}
+
+const PLUGIN_ID = 'core.pace';
+
+export type PaceEntry = { time: number; pace: number };
+
+export type PaceState = {
+ pace: number;
+ prevMinPace: number;
+ prevPace: number;
+ history: PaceEntry[];
+};
+
+const pace = pluginPaths(PLUGIN_ID);
+const settings = typedPath(['settings']);
+
+export default class Pace {
+ static setPace(val: number): Pipe {
+ return Composer.set(pace.pace, val);
+ }
+
+ static resetPace(): Pipe {
+ return Composer.bind(settings, s => Composer.set(pace.pace, s.minPace));
+ }
+
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Pace',
+ },
+
+ activate: Composer.bind(settings, s =>
+ Composer.set(pace, {
+ pace: s.minPace,
+ prevMinPace: s.minPace,
+ prevPace: s.minPace,
+ history: [{ time: 0, pace: s.minPace }],
+ })
+ ),
+
+ update: Composer.do(({ get, set, over }) => {
+ const state = get(pace);
+ const { minPace } = get(settings);
+
+ if (minPace !== state.prevMinPace) {
+ set(pace.prevMinPace, minPace);
+ set(pace.pace, minPace);
+ }
+
+ if (state.pace !== state.prevPace) {
+ const { elapsed } = get(Clock.paths) ?? { elapsed: 0 };
+ set(pace.prevPace, state.pace);
+ over(pace.history, (h: PaceEntry[]) => [
+ ...h,
+ { time: elapsed, pace: state.pace },
+ ]);
+ }
+ }),
+
+ deactivate: Composer.set(pace, undefined),
+ };
+
+ static get paths() {
+ return pace;
+ }
+}
diff --git a/src/game/plugins/pause.ts b/src/game/plugins/pause.ts
new file mode 100644
index 00000000..c71d7979
--- /dev/null
+++ b/src/game/plugins/pause.ts
@@ -0,0 +1,133 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Pipe } from '../../engine/State';
+import { Composer } from '../../engine/Composer';
+import { Events } from '../../engine/pipes/Events';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import { Sequence } from '../Sequence';
+import { sdk } from '../../engine/sdk';
+import Scene from './scene';
+
+const PLUGIN_ID = 'core.pause';
+
+export type PauseState = {
+ paused: boolean;
+ prev: boolean;
+ countdown: number | null;
+ gen: number;
+};
+
+const paths = pluginPaths(PLUGIN_ID);
+
+const eventType = Events.getKeys(PLUGIN_ID, 'on', 'off');
+
+type SetPayload = { paused: boolean };
+type CountdownPayload = { remaining: number; gen: number };
+
+const seq = Sequence.for(PLUGIN_ID, 'set');
+
+export default class Pause {
+ static setPaused(val: boolean): Pipe {
+ return seq.start({ paused: val });
+ }
+
+ static get togglePause(): Pipe {
+ return Composer.bind(paths, state => Pause.setPaused(!state?.paused));
+ }
+
+ static whenPaused(pipe: Pipe): Pipe {
+ return Composer.bind(paths, state => Composer.when(!!state?.paused, pipe));
+ }
+
+ static whenPlaying(pipe: Pipe): Pipe {
+ return Composer.bind(paths, state => Composer.when(!state?.paused, pipe));
+ }
+
+ static onPause(fn: () => Pipe): Pipe {
+ return Events.handle(eventType.on, fn);
+ }
+
+ static onResume(fn: () => Pipe): Pipe {
+ return Events.handle(eventType.off, fn);
+ }
+
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Pause',
+ },
+
+ activate: Composer.set(paths, {
+ paused: true,
+ prev: true,
+ countdown: null,
+ gen: 0,
+ }),
+
+ update: Composer.pipe(
+ Scene.onEnter('game', () => Pause.setPaused(false)),
+ Scene.onLeave('game', () => Pause.setPaused(true)),
+
+ Composer.do(({ get, set, pipe }) => {
+ const { paused, prev } = get(paths);
+ if (paused === prev) return;
+ set(paths.prev, paused);
+ pipe(Events.dispatch({ type: paused ? eventType.on : eventType.off }));
+ }),
+
+ seq.on(event =>
+ Composer.bind(paths.gen, (gen = 0) => {
+ const next = gen + 1;
+ return Composer.when(
+ event.payload.paused,
+ Composer.pipe(
+ Composer.set(paths.gen, next),
+ Composer.set(paths.paused, true),
+ Composer.set(paths.countdown, null)
+ ),
+ Composer.pipe(
+ Composer.set(paths.gen, next),
+ Composer.set(paths.countdown, 3),
+ seq.after(1000, 'countdown', { remaining: 2, gen: next })
+ )
+ );
+ })
+ ),
+
+ seq.on('countdown', event =>
+ Composer.bind(paths.gen, gen =>
+ Composer.when(
+ event.payload.gen === gen,
+ Composer.when(
+ event.payload.remaining <= 0,
+ Composer.pipe(
+ Composer.set(paths.countdown, null),
+ Composer.set(paths.paused, false)
+ ),
+ Composer.pipe(
+ Composer.set(paths.countdown, event.payload.remaining),
+ seq.after(1000, 'countdown', {
+ remaining: event.payload.remaining - 1,
+ gen,
+ })
+ )
+ )
+ )
+ )
+ )
+ ),
+
+ deactivate: Composer.set(paths, undefined),
+ };
+
+ static get paths() {
+ return paths;
+ }
+}
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Pause: typeof Pause;
+ }
+}
+
+sdk.Pause = Pause;
diff --git a/src/game/plugins/perf.ts b/src/game/plugins/perf.ts
new file mode 100644
index 00000000..d50e2565
--- /dev/null
+++ b/src/game/plugins/perf.ts
@@ -0,0 +1,154 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import type { PluginPerfEntry } from '../../engine/pipes/Perf';
+import { Composer } from '../../engine/Composer';
+import { Perf } from '../../engine/pipes/Perf';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import Debug from './debug';
+
+const PLUGIN_ID = 'core.perf_overlay';
+const ELEMENT_ATTR = 'data-plugin-id';
+const STYLE_ID = `${PLUGIN_ID}-styles`;
+
+type PerfOverlayContext = {
+ el: HTMLElement;
+};
+
+const po = pluginPaths(PLUGIN_ID);
+
+const COLOR_OK = [0x4a, 0xde, 0x80] as const;
+const COLOR_WARN = [0xfa, 0xcc, 0x15] as const;
+const COLOR_OVER = [0xf8, 0x71, 0x71] as const;
+
+function lerpRgb(
+ a: readonly number[],
+ b: readonly number[],
+ t: number
+): string {
+ const r = Math.round(a[0] + (b[0] - a[0]) * t);
+ const g = Math.round(a[1] + (b[1] - a[1]) * t);
+ const bl = Math.round(a[2] + (b[2] - a[2]) * t);
+ return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${bl.toString(16).padStart(2, '0')}`;
+}
+
+function budgetColor(duration: number, budget: number): string {
+ const ratio = duration / budget;
+ if (ratio <= 0) return lerpRgb(COLOR_OK, COLOR_OK, 0);
+ if (ratio < 1) return lerpRgb(COLOR_OK, COLOR_WARN, ratio);
+ return lerpRgb(COLOR_WARN, COLOR_OVER, Math.min(ratio - 1, 1));
+}
+
+function formatLine(
+ id: string,
+ phase: string,
+ avg: number,
+ budget: number
+): string {
+ const name = id.padEnd(24);
+ const ph = phase.padEnd(11);
+ const a = `${avg.toFixed(2)}ms`.padStart(8);
+ const color = budgetColor(avg, budget);
+ return `${name}${ph}${a}`;
+}
+
+export default class PerfOverlay {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Performance Overlay',
+ },
+
+ activate: Composer.do(({ get, set }) => {
+ const style =
+ document.getElementById(STYLE_ID) ?? document.createElement('style');
+ style.id = STYLE_ID;
+ style.textContent = `
+ [${ELEMENT_ATTR}="${PLUGIN_ID}"] {
+ position: fixed;
+ top: 42px;
+ right: 8px;
+ background: rgba(0, 0, 0, 0.8);
+ color: white;
+ padding: 8px 12px;
+ font-family: monospace;
+ font-size: 11px;
+ line-height: 1.4;
+ z-index: 9999;
+ pointer-events: none;
+ white-space: pre;
+ border-radius: 4px;
+ }
+ `;
+ if (!style.parentNode) document.head.appendChild(style);
+
+ const existing = document.querySelector(
+ `[${ELEMENT_ATTR}="${PLUGIN_ID}"]`
+ );
+ if (existing) existing.remove();
+
+ const el = document.createElement('div');
+ el.setAttribute(ELEMENT_ATTR, PLUGIN_ID);
+
+ const visible = get(Debug.paths.visible);
+ el.style.display = visible ? '' : 'none';
+
+ document.body.appendChild(el);
+ set(po, { el });
+ }),
+
+ update: Composer.do(({ get }) => {
+ const el = get(po)?.el;
+ if (!el) return;
+
+ const visible = get(Debug.paths.visible);
+ el.style.display = visible ? '' : 'none';
+ if (!visible) return;
+
+ const ctx = get(Perf.paths);
+ if (!ctx) return;
+
+ const { plugins, config } = ctx;
+ const lines: string[] = [];
+
+ let totalAvg = 0;
+
+ const walk = (node: Record, prefix: string[]) => {
+ for (const [key, value] of Object.entries(node)) {
+ if (!value || typeof value !== 'object') continue;
+ if ('lastTick' in value) {
+ const id = prefix.join('.');
+ if (id === PLUGIN_ID) continue;
+ const entry = value as PluginPerfEntry;
+ totalAvg += entry.avg;
+ lines.push(formatLine(id, key, entry.avg, config.pluginBudget));
+ } else {
+ walk(value, [...prefix, key]);
+ }
+ }
+ };
+
+ walk(plugins as Record, []);
+
+ if (lines.length > 0) {
+ const totalColor = budgetColor(
+ totalAvg,
+ config.pluginBudget * lines.length
+ );
+ lines.push('');
+ lines.push(
+ `${'frame'.padEnd(35)}${`${totalAvg.toFixed(2)}ms`.padStart(8)}`
+ );
+ }
+
+ el.innerHTML =
+ lines.length > 0
+ ? lines.join('\n')
+ : 'no plugin data';
+ }),
+
+ deactivate: Composer.do(({ get, set }) => {
+ const el = get(po)?.el;
+ if (el) el.remove();
+ set(po, undefined);
+ }),
+ };
+}
diff --git a/src/game/plugins/phase.ts b/src/game/plugins/phase.ts
new file mode 100644
index 00000000..843d3e60
--- /dev/null
+++ b/src/game/plugins/phase.ts
@@ -0,0 +1,78 @@
+import { pluginPaths, type Plugin } from '../../engine/plugins/Plugins';
+import { Pipe } from '../../engine/State';
+import { Events } from '../../engine/pipes/Events';
+import { Composer } from '../../engine';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Phase: typeof Phase;
+ }
+}
+
+const PLUGIN_ID = 'core.phase';
+
+export enum GamePhase {
+ warmup = 'warmup',
+ active = 'active',
+ break = 'break',
+ finale = 'finale',
+ climax = 'climax',
+}
+
+export type PhaseState = {
+ current: string;
+ prev: string;
+};
+
+const phase = pluginPaths(PLUGIN_ID);
+
+const eventType = {
+ enter: (p: string) => Events.getKey(PLUGIN_ID, `enter/${p}`),
+ leave: (p: string) => Events.getKey(PLUGIN_ID, `leave/${p}`),
+};
+
+export default class Phase {
+ static setPhase(p: string): Pipe {
+ return Composer.set(phase.current, p);
+ }
+
+ static whenPhase(p: string, pipe: Pipe): Pipe {
+ return Composer.bind(phase, state =>
+ Composer.when(state?.current === p, pipe)
+ );
+ }
+
+ static onEnter(p: string, fn: () => Pipe): Pipe {
+ return Events.handle(eventType.enter(p), fn);
+ }
+
+ static onLeave(p: string, fn: () => Pipe): Pipe {
+ return Events.handle(eventType.leave(p), fn);
+ }
+
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Phase',
+ },
+
+ activate: Composer.set(phase, {
+ current: GamePhase.warmup,
+ prev: GamePhase.warmup,
+ }),
+
+ update: Composer.do(({ get, set, pipe }) => {
+ const { current, prev } = get(phase);
+ if (current === prev) return;
+ set(phase.prev, current);
+ pipe(Events.dispatch({ type: eventType.leave(prev) }));
+ pipe(Events.dispatch({ type: eventType.enter(current) }));
+ }),
+
+ deactivate: Composer.set(phase, undefined),
+ };
+
+ static get paths() {
+ return phase;
+ }
+}
diff --git a/src/game/plugins/rand.ts b/src/game/plugins/rand.ts
new file mode 100644
index 00000000..a2b31447
--- /dev/null
+++ b/src/game/plugins/rand.ts
@@ -0,0 +1,91 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine/Composer';
+import { Pipe } from '../../engine/State';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Rand: typeof Rand;
+ }
+}
+
+const PLUGIN_ID = 'core.rand';
+
+type RandState = {
+ seed: string;
+ cursor: number;
+};
+
+const paths = pluginPaths(PLUGIN_ID);
+
+function stringToSeed(str: string): number {
+ let hash = 0;
+ for (let i = 0; i < str.length; i++) {
+ hash = (Math.imul(31, hash) + str.charCodeAt(i)) | 0;
+ }
+ return hash >>> 0;
+}
+
+function advance(cursor: number): [number, number] {
+ const next = Math.imul(48271, cursor) % 0x7fffffff;
+ return [next, (next & 0x7fffffff) / 0x7fffffff];
+}
+
+export default class Rand {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Rand',
+ },
+
+ activate: Composer.do(({ set }) => {
+ const seed = Date.now().toString();
+ set(paths, { seed, cursor: stringToSeed(seed) });
+ }),
+
+ deactivate: Composer.set(paths, undefined),
+ };
+
+ static next(fn: (value: number) => Pipe): Pipe {
+ return Composer.do(({ get, set, pipe }) => {
+ const [cursor, value] = advance(get(paths.cursor));
+ set(paths.cursor, cursor);
+ pipe(fn(value));
+ });
+ }
+
+ static nextInt(max: number, fn: (value: number) => Pipe): Pipe {
+ return Rand.next(v => fn(Math.floor(v * max)));
+ }
+
+ static nextFloatRange(
+ min: number,
+ max: number,
+ fn: (value: number) => Pipe
+ ): Pipe {
+ return Rand.next(v => fn(v * (max - min) + min));
+ }
+
+ static pick(arr: T[], fn: (value: T) => Pipe): Pipe {
+ return Rand.nextInt(arr.length, i => fn(arr[i]));
+ }
+
+ static shuffle(arr: T[], fn: (shuffled: T[]) => Pipe): Pipe {
+ return Composer.do(({ get, set, pipe }) => {
+ let cursor = get(paths.cursor);
+ const shuffled = [...arr];
+ for (let i = shuffled.length - 1; i > 0; i--) {
+ const [c, v] = advance(cursor);
+ cursor = c;
+ const j = Math.floor(v * (i + 1));
+ [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+ }
+ set(paths.cursor, cursor);
+ pipe(fn(shuffled));
+ });
+ }
+
+ static get paths() {
+ return paths;
+ }
+}
diff --git a/src/game/plugins/randomImages.ts b/src/game/plugins/randomImages.ts
new file mode 100644
index 00000000..8d8b1ad4
--- /dev/null
+++ b/src/game/plugins/randomImages.ts
@@ -0,0 +1,101 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine';
+import { Events } from '../../engine/pipes/Events';
+import { Scheduler } from '../../engine/pipes/Scheduler';
+import { typedPath } from '../../engine/Lens';
+import { ImageItem } from '../../types';
+import Image, { ImageState } from './image';
+import { IntensityState } from './intensity';
+import Rand from './rand';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ RandomImages: typeof RandomImages;
+ }
+}
+
+const PLUGIN_ID = 'core.random_images';
+
+const images = typedPath(['images']);
+const intensityState = typedPath(['core.intensity']);
+const imageState = typedPath(['core.images']);
+
+const eventType = Events.getKeys(PLUGIN_ID, 'schedule_next');
+
+const scheduleId = Scheduler.getKey(PLUGIN_ID, 'randomImageSwitch');
+
+const getImageSwitchDuration = (intensity: number): number => {
+ return Math.max((100 - intensity * 100) * 80, 2000);
+};
+
+export default class RandomImages {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'RandomImages',
+ },
+
+ activate: Composer.do(({ get, pipe }) => {
+ const imgs = get(images);
+ if (!imgs || imgs.length === 0) return;
+
+ pipe(
+ Rand.shuffle(imgs, shuffled => {
+ const initial = shuffled.slice(0, Math.min(3, imgs.length));
+ return Composer.pipe(
+ ...initial.map(img => Image.pushNextImage(img)),
+ Events.dispatch({ type: eventType.scheduleNext })
+ );
+ })
+ );
+ }),
+
+ update: Events.handle(eventType.scheduleNext, () =>
+ Composer.do(({ get, pipe }) => {
+ const imgs = get(images);
+ if (!imgs || imgs.length === 0) return;
+
+ const { seenImages = [] } = get(imageState);
+ const { intensity = 0 } = get(intensityState);
+
+ const imagesWithDistance = imgs.map(image => {
+ const seenIndex = seenImages.indexOf(image);
+ const distance = seenIndex === -1 ? seenImages.length : seenIndex;
+ return { image, distance };
+ });
+
+ imagesWithDistance.sort((a, b) => b.distance - a.distance);
+
+ const weights = imagesWithDistance.map((_, index) =>
+ Math.max(1, imagesWithDistance.length - index)
+ );
+ const totalWeight = weights.reduce((sum, w) => sum + w, 0);
+
+ pipe(
+ Rand.next(roll => {
+ let remaining = roll * totalWeight;
+ let selectedIndex = 0;
+ for (let i = 0; i < weights.length; i++) {
+ remaining -= weights[i];
+ if (remaining <= 0) {
+ selectedIndex = i;
+ break;
+ }
+ }
+
+ const randomImage = imagesWithDistance[selectedIndex].image;
+
+ return Composer.pipe(
+ Image.pushNextImage(randomImage),
+ Scheduler.schedule({
+ id: scheduleId,
+ duration: getImageSwitchDuration(intensity),
+ event: { type: eventType.scheduleNext },
+ })
+ );
+ })
+ );
+ })
+ ),
+ };
+}
diff --git a/src/game/plugins/scene.ts b/src/game/plugins/scene.ts
new file mode 100644
index 00000000..4b54c3ac
--- /dev/null
+++ b/src/game/plugins/scene.ts
@@ -0,0 +1,73 @@
+import { pluginPaths, type Plugin } from '../../engine/plugins/Plugins';
+import { Pipe } from '../../engine/State';
+import { Events } from '../../engine/pipes/Events';
+import { Composer } from '../../engine';
+import { sdk } from '../../engine/sdk';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Scene: typeof Scene;
+ }
+}
+
+const PLUGIN_ID = 'core.scene';
+
+export type SceneState = {
+ current: string;
+ prev: string;
+};
+
+const scene = pluginPaths(PLUGIN_ID);
+
+const eventType = {
+ enter: (s: string) => Events.getKey(PLUGIN_ID, `enter/${s}`),
+ leave: (s: string) => Events.getKey(PLUGIN_ID, `leave/${s}`),
+};
+
+export default class Scene {
+ static setScene(s: string): Pipe {
+ return Composer.set(scene.current, s);
+ }
+
+ static whenScene(s: string, pipe: Pipe): Pipe {
+ return Composer.bind(scene, state =>
+ Composer.when(state?.current === s, pipe)
+ );
+ }
+
+ static onEnter(s: string, fn: () => Pipe): Pipe {
+ return Events.handle(eventType.enter(s), fn);
+ }
+
+ static onLeave(s: string, fn: () => Pipe): Pipe {
+ return Events.handle(eventType.leave(s), fn);
+ }
+
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Scene',
+ },
+
+ activate: Composer.set(scene, {
+ current: 'unknown',
+ prev: 'unknown',
+ }),
+
+ update: Composer.do(({ get, set, pipe }) => {
+ const { current, prev } = get(scene);
+ if (current === prev) return;
+ set(scene.prev, current);
+ pipe(Events.dispatch({ type: eventType.leave(prev) }));
+ pipe(Events.dispatch({ type: eventType.enter(current) }));
+ }),
+
+ deactivate: Composer.set(scene, undefined),
+ };
+
+ static get paths() {
+ return scene;
+ }
+}
+
+sdk.Scene = Scene;
diff --git a/src/game/plugins/stroke.ts b/src/game/plugins/stroke.ts
new file mode 100644
index 00000000..0a3a1795
--- /dev/null
+++ b/src/game/plugins/stroke.ts
@@ -0,0 +1,80 @@
+import type { Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine/Composer';
+import { pluginPaths } from '../../engine/plugins/Plugins';
+import { typedPath } from '../../engine/Lens';
+import { GameTiming } from '../../engine/State';
+import { PhaseState, GamePhase } from './phase';
+import Pause from './pause';
+import { PaceState } from './pace';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Stroke: typeof Stroke;
+ }
+}
+
+const PLUGIN_ID = 'core.stroke';
+
+export enum StrokeDirection {
+ up = 'up',
+ down = 'down',
+}
+
+export type StrokeState = {
+ stroke: StrokeDirection;
+ timer: number;
+};
+
+const stroke = pluginPaths(PLUGIN_ID);
+const timing = typedPath([]);
+const phaseState = typedPath(['core.phase']);
+const paceState = typedPath(['core.pace']);
+
+export default class Stroke {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Stroke',
+ },
+
+ activate: Composer.set(stroke, {
+ stroke: StrokeDirection.up,
+ timer: 0,
+ }),
+
+ update: Pause.whenPlaying(
+ Composer.do(({ get, set }) => {
+ const phase = get(phaseState)?.current;
+ if (phase !== GamePhase.active && phase !== GamePhase.finale) return;
+
+ const pace = get(paceState)?.pace;
+ if (!pace || pace <= 0) return;
+
+ const delta = get(timing.step);
+ const state = get(stroke);
+ if (!state) return;
+
+ const interval = (1 / pace) * 1000;
+ const elapsed = state.timer + delta;
+
+ if (elapsed >= interval) {
+ set(stroke, {
+ stroke:
+ state.stroke === StrokeDirection.up
+ ? StrokeDirection.down
+ : StrokeDirection.up,
+ timer: elapsed - interval,
+ });
+ } else {
+ set(stroke.timer, elapsed);
+ }
+ })
+ ),
+
+ deactivate: Composer.set(stroke, undefined),
+ };
+
+ static get paths() {
+ return stroke;
+ }
+}
diff --git a/src/game/plugins/warmup.ts b/src/game/plugins/warmup.ts
new file mode 100644
index 00000000..9896b352
--- /dev/null
+++ b/src/game/plugins/warmup.ts
@@ -0,0 +1,98 @@
+import { pluginPaths, type Plugin } from '../../engine/plugins/Plugins';
+import { Composer } from '../../engine';
+import { Events } from '../../engine/pipes/Events';
+import Messages from './messages';
+import { Scheduler } from '../../engine/pipes/Scheduler';
+import { typedPath } from '../../engine/Lens';
+import { Settings } from '../../settings';
+import Phase, { GamePhase } from './phase';
+import Pause from './pause';
+
+declare module '../../engine/sdk' {
+ interface PluginSDK {
+ Warmup: typeof Warmup;
+ }
+}
+
+const PLUGIN_ID = 'core.warmup';
+
+type WarmupState = {
+ initialized: boolean;
+};
+
+const warmup = pluginPaths(PLUGIN_ID);
+const settings = typedPath(['settings']);
+
+const AUTOSTART_KEY = Scheduler.getKey(PLUGIN_ID, 'autoStart');
+
+const eventType = Events.getKeys(PLUGIN_ID, 'start_game');
+
+export default class Warmup {
+ static plugin: Plugin = {
+ id: PLUGIN_ID,
+ meta: {
+ name: 'Warmup',
+ },
+
+ activate: Composer.set(warmup, { initialized: false }),
+
+ update: Composer.pipe(
+ Pause.whenPlaying(
+ Phase.whenPhase(
+ GamePhase.warmup,
+ Composer.do(({ get, set, pipe }) => {
+ const s = get(settings);
+
+ if (s.warmupDuration === 0) {
+ pipe(Phase.setPhase(GamePhase.active));
+ return;
+ }
+
+ const state = get(warmup);
+ if (state.initialized) return;
+
+ set(warmup.initialized, true);
+ pipe(
+ Messages.send({
+ id: GamePhase.warmup,
+ title: 'Get yourself ready!',
+ prompts: [
+ {
+ title: `I'm ready, $master`,
+ event: { type: eventType.startGame },
+ },
+ ],
+ })
+ );
+ pipe(
+ Scheduler.schedule({
+ id: AUTOSTART_KEY,
+ duration: s.warmupDuration * 1000,
+ event: { type: eventType.startGame },
+ })
+ );
+ })
+ )
+ ),
+
+ Events.handle(eventType.startGame, () =>
+ Composer.pipe(
+ Scheduler.cancel(AUTOSTART_KEY),
+ Composer.set(warmup, { initialized: false }),
+ Messages.send({
+ id: GamePhase.warmup,
+ title: 'Now follow what I say, $player!',
+ duration: 5000,
+ prompts: undefined,
+ }),
+ Phase.setPhase(GamePhase.active)
+ )
+ ),
+
+ Pause.onPause(() => Scheduler.hold(AUTOSTART_KEY)),
+ Pause.onResume(() => Scheduler.release(AUTOSTART_KEY))
+ ),
+
+ deactivate: Composer.set(warmup, undefined),
+ };
+}
diff --git a/src/settings/SettingsProvider.tsx b/src/settings/SettingsProvider.tsx
index 390d7144..aa447592 100644
--- a/src/settings/SettingsProvider.tsx
+++ b/src/settings/SettingsProvider.tsx
@@ -1,5 +1,5 @@
import { useCallback } from 'react';
-import { GameEvent, GameHypnoType, PlayerBody, PlayerGender } from '../types';
+import { DiceEvent, GameHypnoType, PlayerBody, PlayerGender } from '../types';
import { createLocalStorageProvider, VibrationMode } from '../utils';
import { interpolateWith } from '../utils/translate';
@@ -12,7 +12,7 @@ export interface Settings {
maxPace: number;
steepness: number;
timeshift: number;
- events: GameEvent[];
+ events: DiceEvent[];
hypno: GameHypnoType;
gender: PlayerGender;
body: PlayerBody;
@@ -32,7 +32,7 @@ export const defaultSettings: Settings = {
maxPace: 5,
steepness: 0.5,
timeshift: 0.5,
- events: Object.values(GameEvent),
+ events: Object.values(DiceEvent),
hypno: GameHypnoType.joi,
gender: PlayerGender.male,
body: PlayerBody.penis,
diff --git a/src/settings/components/EventSettings.tsx b/src/settings/components/EventSettings.tsx
index e9e4e8bb..0308d1f7 100644
--- a/src/settings/components/EventSettings.tsx
+++ b/src/settings/components/EventSettings.tsx
@@ -1,4 +1,4 @@
-import { GameEvent, GameEventDescriptions, GameEventLabels } from '../../types';
+import { DiceEvent, DiceEventDescriptions, DiceEventLabels } from '../../types';
import { useCallback } from 'react';
import { Fields, JoiToggleTile, SettingsDescription } from '../../common';
import { useSetting } from '../SettingsProvider';
@@ -7,7 +7,7 @@ export const EventSettings = () => {
const [events, setEvents] = useSetting('events');
const toggleEvent = useCallback(
- (event: GameEvent) => {
+ (event: DiceEvent) => {
if (events.includes(event)) {
setEvents(events.filter(e => e !== event));
} else {
@@ -22,8 +22,8 @@ export const EventSettings = () => {
Check the events you want to occur during the game
- {Object.keys(GameEvent).map(key => {
- const event = GameEvent[key as keyof typeof GameEvent];
+ {Object.keys(DiceEvent).map(key => {
+ const event = DiceEvent[key as keyof typeof DiceEvent];
return (
{
onClick={() => toggleEvent(event)}
type={'check'}
>
- {GameEventLabels[event]}
- {GameEventDescriptions[event]}
+ {DiceEventLabels[event]}
+ {DiceEventDescriptions[event]}
);
})}
diff --git a/src/types/event.ts b/src/types/event.ts
index 39e171c3..0a04bec5 100644
--- a/src/types/event.ts
+++ b/src/types/event.ts
@@ -1,6 +1,6 @@
import { PlayerBody } from './body';
-export enum GameEvent {
+export enum DiceEvent {
randomPace = 'randomPace',
halfPace = 'halfPace',
doublePace = 'doublePace',
@@ -12,7 +12,7 @@ export enum GameEvent {
cleanUp = 'cleanUp',
}
-export const GameEventLabels: Record = {
+export const DiceEventLabels: Record = {
randomPace: 'Random Pace',
halfPace: 'Half Pace',
doublePace: 'Double Pace',
@@ -24,7 +24,7 @@ export const GameEventLabels: Record = {
cleanUp: 'Clean Up Mess',
};
-export const GameEventDescriptions: Record = {
+export const DiceEventDescriptions: Record = {
randomPace: 'Randomly select a new pace',
halfPace: 'Paw at half the current pace for a few seconds',
doublePace: 'Paw at twice the current pace for a few seconds',
diff --git a/src/utils/case.ts b/src/utils/case.ts
new file mode 100644
index 00000000..e9cd8755
--- /dev/null
+++ b/src/utils/case.ts
@@ -0,0 +1,6 @@
+export type CamelCase = S extends `${infer H}_${infer T}`
+ ? `${H}${Capitalize>}`
+ : S;
+
+export const toCamel = (s: string) =>
+ s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
diff --git a/src/utils/dialogNesting.ts b/src/utils/dialogNesting.ts
new file mode 100644
index 00000000..ca2afc54
--- /dev/null
+++ b/src/utils/dialogNesting.ts
@@ -0,0 +1,15 @@
+export function nestedDialogProps(onClose: () => void) {
+ return {
+ onWaHide: (e: Event) => {
+ if (
+ e.target === e.currentTarget &&
+ (e.currentTarget as HTMLElement)?.querySelector('wa-dialog[open]')
+ )
+ e.preventDefault();
+ },
+ onWaAfterHide: (e: Event) => {
+ if (e.target !== e.currentTarget) return;
+ onClose();
+ },
+ };
+}
diff --git a/src/utils/index.ts b/src/utils/index.ts
index c0c1952b..4009f4ad 100644
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -1,4 +1,5 @@
export * from './animation';
+export * from './dialogNesting';
export * from './fullscreen';
export * from './images';
export * from './intensity';
@@ -12,4 +13,5 @@ export * from './sound';
export * from './state';
export * from './translate';
export * from './vibrator';
+export * from './time';
export * from './wait';
diff --git a/src/utils/time.ts b/src/utils/time.ts
new file mode 100644
index 00000000..3cad6ce2
--- /dev/null
+++ b/src/utils/time.ts
@@ -0,0 +1,6 @@
+export const formatTime = (ms: number) => {
+ const totalSeconds = Math.floor(ms / 1000);
+ const minutes = Math.floor(totalSeconds / 60);
+ const seconds = totalSeconds % 60;
+ return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+};
diff --git a/tests/engine/Composer.test.ts b/tests/engine/Composer.test.ts
new file mode 100644
index 00000000..b0b067c9
--- /dev/null
+++ b/tests/engine/Composer.test.ts
@@ -0,0 +1,458 @@
+import { describe, it, expect } from 'vitest';
+import { Composer } from '../../src/engine/Composer';
+
+describe('Composer', () => {
+ describe('instance methods', () => {
+ describe('chain', () => {
+ it('should chain composer functions', () => {
+ const obj = { count: 5 };
+ const result = new Composer(obj)
+ .chain(c => c.set('count', 10))
+ .chain(c => c.over('count', x => x * 2))
+ .get();
+
+ expect(result.count).toBe(20);
+ });
+ });
+
+ describe('pipe', () => {
+ it('should apply multiple functions in sequence', () => {
+ const obj = { value: 1 };
+ const result = new Composer(obj)
+ .pipe(
+ o => ({ ...o, value: o.value + 1 }),
+ o => ({ ...o, value: o.value * 2 })
+ )
+ .get();
+
+ expect(result.value).toBe(4);
+ });
+ });
+
+ describe('get', () => {
+ it('should get the whole object when no path provided', () => {
+ const obj = { foo: 'bar' };
+ const result = new Composer(obj).get();
+
+ expect(result).toEqual({ foo: 'bar' });
+ });
+
+ it('should get nested value', () => {
+ const obj = { a: { b: { c: 42 } } };
+ const result = new Composer(obj).get('a.b.c');
+
+ expect(result).toBe(42);
+ });
+ });
+
+ describe('set', () => {
+ it('should replace entire object', () => {
+ const obj = { old: 'value' };
+ const result = new Composer(obj).set({ new: 'value' }).get();
+
+ expect(result).toEqual({ new: 'value' });
+ });
+
+ it('should set nested value', () => {
+ const obj = { a: { b: 1 } };
+ const result = new Composer(obj).set('a.b', 42).get();
+
+ expect(result.a.b).toBe(42);
+ });
+ });
+
+ describe('zoom', () => {
+ it('should compose on a nested object', () => {
+ const obj = {
+ user: {
+ name: 'Alice',
+ age: 30,
+ },
+ };
+
+ const result = new Composer(obj)
+ .zoom('user', c => c.set('age', 31).set('name', 'Bob'))
+ .get();
+
+ expect(result.user.name).toBe('Bob');
+ expect(result.user.age).toBe(31);
+ });
+ });
+
+ describe('over', () => {
+ it('should update a nested property', () => {
+ const obj = { counter: 5 };
+ const result = new Composer(obj)
+ .over('counter', x => x + 1)
+ .get();
+
+ expect(result.counter).toBe(6);
+ });
+ });
+
+ describe('bind', () => {
+ it('should read value and apply transformer', () => {
+ const obj = { x: 10, y: 0 };
+ const result = new Composer(obj)
+ .bind('x', x => o => ({ ...o, y: x * 2 }))
+ .get();
+
+ expect(result.y).toBe(20);
+ expect(result.x).toBe(10);
+ });
+ });
+
+ describe('when', () => {
+ it('should apply function when condition is true', () => {
+ const obj = { value: 5 };
+ const result = new Composer(obj)
+ .when(true, c => c.set('value', 10))
+ .get();
+
+ expect(result.value).toBe(10);
+ });
+
+ it('should skip function when condition is false', () => {
+ const obj = { value: 5 };
+ const result = new Composer(obj)
+ .when(false, c => c.set('value', 10))
+ .get();
+
+ expect(result.value).toBe(5);
+ });
+
+ it('should apply else when condition is false', () => {
+ const obj = { value: 5 };
+ const result = new Composer(obj)
+ .when(
+ false,
+ c => c.set('value', 10),
+ c => c.set('value', 99)
+ )
+ .get();
+
+ expect(result.value).toBe(99);
+ });
+
+ it('should not apply else when condition is true', () => {
+ const obj = { value: 5 };
+ const result = new Composer(obj)
+ .when(
+ true,
+ c => c.set('value', 10),
+ c => c.set('value', 99)
+ )
+ .get();
+
+ expect(result.value).toBe(10);
+ });
+ });
+
+ describe('unless', () => {
+ it('should skip function when condition is true', () => {
+ const obj = { value: 5 };
+ const result = new Composer(obj)
+ .unless(true, c => c.set('value', 10))
+ .get();
+
+ expect(result.value).toBe(5);
+ });
+
+ it('should apply function when condition is false', () => {
+ const obj = { value: 5 };
+ const result = new Composer(obj)
+ .unless(false, c => c.set('value', 10))
+ .get();
+
+ expect(result.value).toBe(10);
+ });
+ });
+ });
+
+ describe('static methods', () => {
+ describe('Composer.chain', () => {
+ it('should create a function that chains composers', () => {
+ const fn = Composer.chain<{ count: number }>(c =>
+ c.set('count', 10).over('count', x => x * 2)
+ );
+
+ const result = fn({ count: 5 });
+ expect(result.count).toBe(20);
+ });
+ });
+
+ describe('Composer.pipe', () => {
+ it('should create a function that pipes transformations', () => {
+ const fn = Composer.pipe<{ value: number }>(
+ o => ({ ...o, value: o.value + 1 }),
+ o => ({ ...o, value: o.value * 2 })
+ );
+
+ const result = fn({ value: 1 });
+ expect(result.value).toBe(4);
+ });
+ });
+
+ describe('Composer.get', () => {
+ it('should create a getter function', () => {
+ const getValue = Composer.get('a.b.c');
+ const result = getValue({ a: { b: { c: 42 } } });
+
+ expect(result).toBe(42);
+ });
+ });
+
+ describe('Composer.set', () => {
+ it('should create a setter function', () => {
+ const setCount = Composer.set('count', 100);
+ const result = setCount({ count: 0 });
+
+ expect(result.count).toBe(100);
+ });
+ });
+
+ describe('Composer.zoom', () => {
+ it('should create a zoom function', () => {
+ const updateUser = Composer.zoom<{ age: number }>('user', u => ({
+ ...u,
+ age: u.age + 1,
+ }));
+
+ const result = updateUser({ user: { age: 30 } });
+ expect(result.user.age).toBe(31);
+ });
+ });
+
+ describe('Composer.over', () => {
+ it('should create an over function', () => {
+ const increment = Composer.over('counter', x => x + 1);
+ const result = increment({ counter: 5 });
+
+ expect(result.counter).toBe(6);
+ });
+
+ it('should update a deeply nested object', () => {
+ const obj = {
+ data: {
+ user: {
+ profile: {
+ scores: [10, 20, 30],
+ },
+ },
+ },
+ };
+
+ const result = Composer.over(
+ ['data', 'user.profile.scores'],
+ scores => [...scores, 40]
+ )(obj);
+
+ expect(result.data.user.profile.scores).toEqual([10, 20, 30, 40]);
+ });
+ });
+
+ describe('Composer.bind', () => {
+ it('should create a bind function', () => {
+ const fn = Composer.bind('x', x => o => ({ ...o, y: x * 2 }));
+ const result = fn({ x: 10, y: 0 });
+
+ expect(result.y).toBe(20);
+ });
+ });
+
+ describe('Composer.call', () => {
+ it('should read a function from path and call it with args', () => {
+ type State = {
+ value: number;
+ api: { setValue: (n: number) => (obj: any) => any };
+ };
+
+ const obj: State = {
+ value: 0,
+ api: { setValue: n => o => ({ ...o, value: n }) },
+ };
+
+ const result = Composer.call