@voltro/game-stack 0.0.0-stage → 0.87.0

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare class GameStackError extends GameStackError_base {
+}
+
+declare const GameStackError_base: Schema.Class<GameStackError, Schema.TaggedStruct<"GameStackError", {
+    readonly code: Schema.Literals<readonly ["invalid_configuration", "missing_configuration", "duplicate_plugin"]>;
+    readonly systems: Schema.$Array<Schema.Literals<readonly ["auth", "players", "sanctions", "social", "chat", "guilds", "inventory", "economy", "progression", "liveops", "saves", "rooms", "matchmaking", "leaderboards"]>>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,13 @@
+import { GameSystemId as e } from "./systems.js";
+import { Schema as t } from "effect";
+//#region src/errors.ts
+var n = class extends t.TaggedError()("GameStackError", {
+	code: t.Literals([
+		"invalid_configuration",
+		"missing_configuration",
+		"duplicate_plugin"
+	]),
+	systems: t.Array(e)
+}) {};
+//#endregion
+export { n as GameStackError };

package/dist/fight.d.ts

@@ -0,0 +1,239 @@
+import { DeclaredAccess } from '@voltro/protocol';
+import { RoomBudgets } from '@voltro/plugin-rooms/room';
+import { RoomLockstepDescriptor } from '@voltro/plugin-rooms/room';
+import { RoomLockstepOptions } from '@voltro/plugin-rooms/room';
+import { Schema } from 'effect';
+import { Simulation } from '@voltro/plugin-rooms/simulation';
+
+/** Capture the shared explicit two-player init material. No Room/Seat allocation. */
+export declare const createFightOptions: (playerIds: ReadonlyArray<number>, rules?: Partial<FightRules>) => FightOptions;
+
+/** Pure two-player reference Room declaration, referee by default. Actual app
+ * catalogue, bindings, Subject/Seat admission and owner ports remain external. */
+export declare const createFightRoom: (offered: FightRoomOptions) => RoomLockstepDescriptor<typeof FightStateSchema, typeof FightInputSchema, typeof FightOptionsSchema>;
+
+/** Optional pure gameplay reference. Does not install a plugin, Room, client,
+ * host, preset, actor, event bus, port, store, clock or private RNG. */
+export declare const createFightSimulation: (offered?: FightSimulationOptions) => FightSimulation;
+
+/** Default exported pure slot; both attacks are decided before either is applied. */
+export declare const defaultFightHit: (context: FightHitContext) => FightHitResult | null;
+
+/** Default exported pure slot. Q16.16 positions/velocities; no render conversion. */
+export declare const defaultFightMovement: (context: FightMovementContext) => FightMovementResult;
+
+export declare const defaultFightRules: FightRules;
+
+/** Actual descriptor identity only, without options/state/participant data. */
+export declare const describeFightStrategies: (simulation: FightSimulation) => FightStrategySelection;
+
+export declare type FightEvent = Schema.Schema.Type<typeof FightEventSchema>;
+
+export declare const FightEventSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["jump", "strike", "hit", "block", "finish"]>;
+    readonly actorSlot: Schema.Int;
+    readonly targetSlot: Schema.Int;
+    readonly amount: Schema.Int;
+}>;
+
+export declare type FightFighter = Schema.Schema.Type<typeof FightFighterSchema>;
+
+export declare const FightFighterSchema: Schema.Struct<{
+    readonly playerId: Schema.Struct<{
+        readonly hi: Schema.Int;
+        readonly lo: Schema.Int;
+    }>;
+    readonly xRaw: Schema.Int;
+    readonly yRaw: Schema.Int;
+    readonly verticalSpeedRaw: Schema.Int;
+    readonly facing: Schema.Literals<readonly [-1, 1]>;
+    readonly health: Schema.Int;
+    readonly stamina: Schema.Int;
+    readonly cooldownTicks: Schema.Int;
+    readonly stunTicks: Schema.Int;
+    readonly strikeHeld: Schema.Boolean;
+    readonly jumpHeld: Schema.Boolean;
+    readonly blocking: Schema.Boolean;
+}>;
+
+export declare interface FightHitContext {
+    readonly attacker: FightFighter;
+    readonly defender: FightFighter;
+    readonly rules: FightRules;
+    readonly tick: number;
+}
+
+export declare interface FightHitResult {
+    readonly damage: number;
+    readonly stunTicks: number;
+    readonly knockbackRaw: number;
+    readonly blocked: boolean;
+}
+
+export declare type FightInput = Schema.Schema.Type<typeof FightInputSchema>;
+
+export declare const FightInputSchema: Schema.Struct<{
+    readonly move: Schema.Literals<readonly [-1, 0, 1]>;
+    readonly jump: Schema.Boolean;
+    readonly strike: Schema.Boolean;
+    readonly block: Schema.Boolean;
+}>;
+
+export declare interface FightMovementContext {
+    readonly fighter: FightFighter;
+    readonly intent: FightInput;
+    readonly rules: FightRules;
+    readonly canAct: boolean;
+    readonly jump: boolean;
+    readonly tick: number;
+}
+
+export declare interface FightMovementResult {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly verticalSpeedRaw: number;
+}
+
+export declare type FightOptions = Schema.Schema.Type<typeof FightOptionsSchema>;
+
+export declare const FightOptionsSchema: Schema.Struct<{
+    readonly playerIds: Schema.$Array<Schema.Int>;
+    readonly rules: Schema.Struct<{
+        readonly stageHalfWidthRaw: Schema.Int;
+        readonly fighterRadiusRaw: Schema.Int;
+        readonly spawnDistanceRaw: Schema.Int;
+        readonly maxHeightRaw: Schema.Int;
+        readonly moveSpeedRaw: Schema.Int;
+        readonly jumpVelocityRaw: Schema.Int;
+        readonly gravityRaw: Schema.Int;
+        readonly strikeRangeRaw: Schema.Int;
+        readonly strikeHeightRaw: Schema.Int;
+        readonly knockbackRaw: Schema.Int;
+        readonly maxHealth: Schema.Int;
+        readonly damage: Schema.Int;
+        readonly maxStamina: Schema.Int;
+        readonly strikeCost: Schema.Int;
+        readonly blockCost: Schema.Int;
+        readonly staminaRegen: Schema.Int;
+        readonly cooldownTicks: Schema.Int;
+        readonly stunTicks: Schema.Int;
+        readonly roundTicks: Schema.Int;
+        readonly blockDamage: Schema.Int;
+    }>;
+}>;
+
+export declare const FightPlayerIdSchema: Schema.Struct<{
+    readonly hi: Schema.Int;
+    readonly lo: Schema.Int;
+}>;
+
+export declare interface FightRoomOptions {
+    readonly name?: string;
+    /** Actual application access declaration; no successful guard is fabricated. */
+    readonly guards: DeclaredAccess;
+    readonly simulation?: FightSimulation;
+    readonly strategies?: FightStrategies;
+    readonly lockstep?: RoomLockstepOptions<typeof FightInputSchema>;
+    readonly tickRate?: number;
+    readonly budgets?: Partial<RoomBudgets>;
+    readonly reconnect?: {
+        readonly graceMs: number;
+    };
+}
+
+export declare type FightRules = Schema.Schema.Type<typeof FightRulesSchema>;
+
+/** Every authoritative value is an integer/raw fixed word or an explicit enum. */
+export declare const FightRulesSchema: Schema.Struct<{
+    readonly stageHalfWidthRaw: Schema.Int;
+    readonly fighterRadiusRaw: Schema.Int;
+    readonly spawnDistanceRaw: Schema.Int;
+    readonly maxHeightRaw: Schema.Int;
+    readonly moveSpeedRaw: Schema.Int;
+    readonly jumpVelocityRaw: Schema.Int;
+    readonly gravityRaw: Schema.Int;
+    readonly strikeRangeRaw: Schema.Int;
+    readonly strikeHeightRaw: Schema.Int;
+    readonly knockbackRaw: Schema.Int;
+    readonly maxHealth: Schema.Int;
+    readonly damage: Schema.Int;
+    readonly maxStamina: Schema.Int;
+    readonly strikeCost: Schema.Int;
+    readonly blockCost: Schema.Int;
+    readonly staminaRegen: Schema.Int;
+    readonly cooldownTicks: Schema.Int;
+    readonly stunTicks: Schema.Int;
+    readonly roundTicks: Schema.Int;
+    readonly blockDamage: Schema.Int;
+}>;
+
+export declare type FightSimulation = Simulation<typeof FightStateSchema, typeof FightInputSchema, typeof FightOptionsSchema>;
+
+export declare interface FightSimulationOptions {
+    readonly strategies?: FightStrategies;
+}
+
+export declare type FightState = Schema.Schema.Type<typeof FightStateSchema>;
+
+export declare const FightStateSchema: Schema.Struct<{
+    readonly elapsedTicks: Schema.Int;
+    readonly status: Schema.Literals<readonly ["running", "win", "draw"]>;
+    readonly winnerSlot: Schema.Literals<readonly [-1, 0, 1]>;
+    readonly rules: Schema.Struct<{
+        readonly stageHalfWidthRaw: Schema.Int;
+        readonly fighterRadiusRaw: Schema.Int;
+        readonly spawnDistanceRaw: Schema.Int;
+        readonly maxHeightRaw: Schema.Int;
+        readonly moveSpeedRaw: Schema.Int;
+        readonly jumpVelocityRaw: Schema.Int;
+        readonly gravityRaw: Schema.Int;
+        readonly strikeRangeRaw: Schema.Int;
+        readonly strikeHeightRaw: Schema.Int;
+        readonly knockbackRaw: Schema.Int;
+        readonly maxHealth: Schema.Int;
+        readonly damage: Schema.Int;
+        readonly maxStamina: Schema.Int;
+        readonly strikeCost: Schema.Int;
+        readonly blockCost: Schema.Int;
+        readonly staminaRegen: Schema.Int;
+        readonly cooldownTicks: Schema.Int;
+        readonly stunTicks: Schema.Int;
+        readonly roundTicks: Schema.Int;
+        readonly blockDamage: Schema.Int;
+    }>;
+    readonly fighters: Schema.$Array<Schema.Struct<{
+        readonly playerId: Schema.Struct<{
+            readonly hi: Schema.Int;
+            readonly lo: Schema.Int;
+        }>;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly verticalSpeedRaw: Schema.Int;
+        readonly facing: Schema.Literals<readonly [-1, 1]>;
+        readonly health: Schema.Int;
+        readonly stamina: Schema.Int;
+        readonly cooldownTicks: Schema.Int;
+        readonly stunTicks: Schema.Int;
+        readonly strikeHeld: Schema.Boolean;
+        readonly jumpHeld: Schema.Boolean;
+        readonly blocking: Schema.Boolean;
+    }>>;
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["jump", "strike", "hit", "block", "finish"]>;
+        readonly actorSlot: Schema.Int;
+        readonly targetSlot: Schema.Int;
+        readonly amount: Schema.Int;
+    }>>;
+}>;
+
+export declare interface FightStrategies {
+    readonly movement?: (context: FightMovementContext) => FightMovementResult;
+    readonly hit?: (context: FightHitContext) => FightHitResult | null;
+}
+
+export declare interface FightStrategySelection {
+    readonly movement: 'default' | 'custom';
+    readonly hit: 'default' | 'custom';
+}
+
+export { }

package/dist/fight.js

@@ -0,0 +1,5 @@
+import { FightEventSchema as e, FightFighterSchema as t, FightInputSchema as n, FightOptionsSchema as r, FightPlayerIdSchema as i, FightRulesSchema as a, FightStateSchema as o } from "./fightSchema.js";
+import { createFightOptions as s, defaultFightRules as c } from "./fightRules.js";
+import { createFightSimulation as l, defaultFightHit as u, defaultFightMovement as d, describeFightStrategies as f } from "./fightSimulation.js";
+import { createFightRoom as p } from "./fightRoom.js";
+export { e as FightEventSchema, t as FightFighterSchema, n as FightInputSchema, r as FightOptionsSchema, i as FightPlayerIdSchema, a as FightRulesSchema, o as FightStateSchema, s as createFightOptions, p as createFightRoom, l as createFightSimulation, u as defaultFightHit, d as defaultFightMovement, c as defaultFightRules, f as describeFightStrategies };

package/dist/fightRoom.js

@@ -0,0 +1,44 @@
+import { fightOwnData as e, fightRefusal as t } from "./fightRules.js";
+import { createFightSimulation as n } from "./fightSimulation.js";
+import { defineRoom as r } from "@voltro/plugin-rooms/room";
+//#region src/fightRoom.ts
+var i = (i) => {
+	let a = e(i, [
+		"name",
+		"guards",
+		"simulation",
+		"strategies",
+		"lockstep",
+		"tickRate",
+		"budgets",
+		"reconnect"
+	], ["guards"]);
+	if (!Array.isArray(a.guards) || !a.guards.length || a.simulation !== void 0 && a.strategies !== void 0) return t();
+	let o = a.lockstep === void 0 ? {} : a.lockstep;
+	if (!o || typeof o != "object" || Object.getPrototypeOf(o) !== Object.prototype) return t();
+	let s = {};
+	for (let e of Reflect.ownKeys(o)) {
+		let n = Object.getOwnPropertyDescriptor(o, e);
+		if (typeof e != "string" || !n?.enumerable || !("value" in n)) return t();
+		Object.defineProperty(s, e, {
+			value: n.value,
+			enumerable: !0
+		});
+	}
+	return Object.hasOwn(s, "maxPlayers") && s.maxPlayers !== 2 ? t() : r({
+		name: a.name === void 0 ? "fight" : a.name,
+		mode: "lockstep",
+		simulation: a.simulation === void 0 ? n(a.strategies === void 0 ? {} : { strategies: a.strategies }) : a.simulation,
+		guards: a.guards,
+		lockstep: {
+			serverRole: "referee",
+			maxPlayers: 2,
+			...s
+		},
+		...a.tickRate === void 0 ? {} : { tickRate: a.tickRate },
+		...a.budgets === void 0 ? {} : { budgets: a.budgets },
+		...a.reconnect === void 0 ? {} : { reconnect: a.reconnect }
+	});
+};
+//#endregion
+export { i as createFightRoom };

package/dist/fightRules.js

@@ -0,0 +1,66 @@
+import { createFixed as e } from "@voltro/plugin-rooms/fixed";
+import { RoomAuthoringError as t } from "@voltro/plugin-rooms/errors";
+//#region src/fightRules.ts
+var n = e(), r = Object.freeze({
+	stageHalfWidthRaw: n.fromInt(8),
+	fighterRadiusRaw: n.fromRatio(1, 2),
+	spawnDistanceRaw: n.fromInt(3),
+	maxHeightRaw: n.fromInt(4),
+	moveSpeedRaw: n.fromRatio(1, 16),
+	jumpVelocityRaw: n.fromRatio(1, 4),
+	gravityRaw: n.fromRatio(1, 64),
+	strikeRangeRaw: n.fromRatio(3, 2),
+	strikeHeightRaw: n.fromRatio(3, 4),
+	knockbackRaw: n.fromRatio(1, 4),
+	maxHealth: 100,
+	damage: 10,
+	maxStamina: 100,
+	strikeCost: 10,
+	blockCost: 3,
+	staminaRegen: 1,
+	cooldownTicks: 18,
+	stunTicks: 6,
+	roundTicks: 3600,
+	blockDamage: 0
+}), i = () => {
+	throw new t({
+		room: "fight",
+		detail: "Fight source configuration, callback output or intent roster could not be admitted"
+	});
+}, a = (e, t, n) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype) return i();
+	let r = {};
+	for (let n of Reflect.ownKeys(e)) {
+		let a = Object.getOwnPropertyDescriptor(e, n);
+		if (typeof n != "string" || !t.includes(n) || !a?.enumerable || !("value" in a)) return i();
+		Object.defineProperty(r, n, {
+			value: a.value,
+			enumerable: !0
+		});
+	}
+	return n.some((e) => !Object.hasOwn(r, e)) ? i() : Object.freeze(r);
+}, o = (e, t, n) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : i(), s = Object.freeze(Object.keys(r)), c = (e, t = !1) => {
+	let i = a(e, s, t ? [] : s), c = {
+		...r,
+		...i
+	}, l = o(c.stageHalfWidthRaw, n.fromInt(1), n.fromInt(128)), u = o(c.fighterRadiusRaw, 1, Math.floor(l / 4));
+	o(c.spawnDistanceRaw, u * 2, l - u);
+	let d = o(c.maxHeightRaw, 1, n.fromInt(32)), f = o(c.jumpVelocityRaw, 1, Math.min(n.scale, d));
+	o(c.moveSpeedRaw, 1, Math.min(n.scale, l - u)), o(c.gravityRaw, 1, f), o(c.strikeRangeRaw, u * 2, l * 2), o(c.strikeHeightRaw, 1, d), o(c.knockbackRaw, 0, l * 2);
+	let p = o(c.maxHealth, 1, 1e6), m = o(c.maxStamina, 1, 1e6), h = o(c.damage, 1, p);
+	return o(c.blockDamage, 0, h), o(c.strikeCost, 1, m), o(c.blockCost, 1, m), o(c.staminaRegen, 0, m), o(c.cooldownTicks, 1, 1024), o(c.stunTicks, 0, 1024), o(c.roundTicks, 1, 65536), Object.freeze(c);
+}, l = (e) => {
+	if (!Array.isArray(e) || e.length !== 2 || Reflect.ownKeys(e).length !== 3) return i();
+	let t = [];
+	for (let n = 0; n < 2; n++) {
+		let r = Object.getOwnPropertyDescriptor(e, String(n));
+		if (!r?.enumerable || !("value" in r)) return i();
+		t.push(o(r.value, 0, 4294967295));
+	}
+	return t[0] === t[1] ? i() : (t.sort((e, t) => e - t), Object.freeze([t[0], t[1]]));
+}, u = (e, t = {}) => Object.freeze({
+	playerIds: l(e),
+	rules: c(t, !0)
+});
+//#endregion
+export { l as captureFightPlayerIds, c as captureFightRules, u as createFightOptions, r as defaultFightRules, a as fightOwnData, i as fightRefusal };

package/dist/fightSchema.js

@@ -0,0 +1,81 @@
+import { Schema as e } from "effect";
+import { fieldId as t } from "@voltro/plugin-rooms/room";
+//#region src/fightSchema.ts
+var n = e.Struct({
+	stageHalfWidthRaw: e.Int.pipe(t(1)),
+	fighterRadiusRaw: e.Int.pipe(t(2)),
+	spawnDistanceRaw: e.Int.pipe(t(3)),
+	maxHeightRaw: e.Int.pipe(t(4)),
+	moveSpeedRaw: e.Int.pipe(t(5)),
+	jumpVelocityRaw: e.Int.pipe(t(6)),
+	gravityRaw: e.Int.pipe(t(7)),
+	strikeRangeRaw: e.Int.pipe(t(8)),
+	strikeHeightRaw: e.Int.pipe(t(9)),
+	knockbackRaw: e.Int.pipe(t(10)),
+	maxHealth: e.Int.pipe(t(11)),
+	damage: e.Int.pipe(t(12)),
+	maxStamina: e.Int.pipe(t(13)),
+	strikeCost: e.Int.pipe(t(14)),
+	blockCost: e.Int.pipe(t(15)),
+	staminaRegen: e.Int.pipe(t(16)),
+	cooldownTicks: e.Int.pipe(t(17)),
+	stunTicks: e.Int.pipe(t(18)),
+	roundTicks: e.Int.pipe(t(19)),
+	blockDamage: e.Int.pipe(t(20))
+}), r = e.Struct({
+	hi: e.Int.pipe(t(1)),
+	lo: e.Int.pipe(t(2))
+}), i = e.Struct({
+	playerId: r.pipe(t(1)),
+	xRaw: e.Int.pipe(t(2)),
+	yRaw: e.Int.pipe(t(3)),
+	verticalSpeedRaw: e.Int.pipe(t(4)),
+	facing: e.Literals([-1, 1]).pipe(t(5)),
+	health: e.Int.pipe(t(6)),
+	stamina: e.Int.pipe(t(7)),
+	cooldownTicks: e.Int.pipe(t(8)),
+	stunTicks: e.Int.pipe(t(9)),
+	strikeHeld: e.Boolean.pipe(t(10)),
+	jumpHeld: e.Boolean.pipe(t(11)),
+	blocking: e.Boolean.pipe(t(12))
+}), a = e.Struct({
+	move: e.Literals([
+		-1,
+		0,
+		1
+	]),
+	jump: e.Boolean,
+	strike: e.Boolean,
+	block: e.Boolean
+}), o = e.Struct({
+	kind: e.Literals([
+		"jump",
+		"strike",
+		"hit",
+		"block",
+		"finish"
+	]).pipe(t(1)),
+	actorSlot: e.Int.pipe(t(2)),
+	targetSlot: e.Int.pipe(t(3)),
+	amount: e.Int.pipe(t(4))
+}), s = e.Struct({
+	elapsedTicks: e.Int.pipe(t(1)),
+	status: e.Literals([
+		"running",
+		"win",
+		"draw"
+	]).pipe(t(2)),
+	winnerSlot: e.Literals([
+		-1,
+		0,
+		1
+	]).pipe(t(3)),
+	rules: n.pipe(t(4)),
+	fighters: e.Array(i).pipe(t(5)),
+	events: e.Array(o).pipe(t(6))
+}), c = e.Struct({
+	playerIds: e.Array(e.Int),
+	rules: n
+});
+//#endregion
+export { o as FightEventSchema, i as FightFighterSchema, a as FightInputSchema, c as FightOptionsSchema, r as FightPlayerIdSchema, n as FightRulesSchema, s as FightStateSchema };

package/dist/fightSimulation.js

@@ -0,0 +1,220 @@
+import { FightInputSchema as e, FightOptionsSchema as t, FightStateSchema as n } from "./fightSchema.js";
+import { captureFightPlayerIds as r, captureFightRules as i, fightOwnData as a, fightRefusal as o } from "./fightRules.js";
+import { createFixed as s } from "@voltro/plugin-rooms/fixed";
+import { defineSimulation as c } from "@voltro/plugin-rooms/simulation";
+//#region src/fightSimulation.ts
+var l = s(), u = /* @__PURE__ */ new WeakMap(), d = (e) => {
+	let { fighter: t, intent: n, rules: r } = e, i = r.stageHalfWidthRaw - r.fighterRadiusRaw, a = e.canAct && !t.blocking ? n.move * r.moveSpeedRaw : 0, o = l.clamp(l.add(l.raw(t.xRaw), l.raw(a)), l.raw(-i), l.raw(i)), s = e.jump ? r.jumpVelocityRaw : t.verticalSpeedRaw;
+	s = !e.jump && t.yRaw === 0 ? 0 : Math.max(-r.maxHeightRaw, l.sub(l.raw(s), l.raw(r.gravityRaw)));
+	let c = l.add(l.raw(t.yRaw), l.raw(s)), u = l.clamp(c, l.raw(0), l.raw(r.maxHeightRaw));
+	return (c <= 0 || c >= r.maxHeightRaw) && (s = 0), Object.freeze({
+		xRaw: o,
+		yRaw: u,
+		verticalSpeedRaw: s
+	});
+}, f = (e) => {
+	let { attacker: t, defender: n, rules: r } = e, i = l.sub(l.raw(n.xRaw), l.raw(t.xRaw)), a = l.abs(l.sub(l.raw(n.yRaw), l.raw(t.yRaw)));
+	if (l.abs(i) > r.strikeRangeRaw || a > r.strikeHeightRaw || i !== 0 && Math.sign(i) !== t.facing) return null;
+	let o = n.blocking && n.stamina >= r.blockCost;
+	return Object.freeze({
+		damage: o ? r.blockDamage : r.damage,
+		stunTicks: o ? 0 : r.stunTicks,
+		knockbackRaw: o ? 0 : r.knockbackRaw,
+		blocked: o
+	});
+}, p = (e) => Object.freeze({
+	...e,
+	playerId: Object.freeze({ ...e.playerId })
+}), m = (e) => e.playerId.hi * 65536 + e.playerId.lo, h = (e, t, n) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : o(), g = (e) => e instanceof Promise ? (Promise.prototype.then.call(e, void 0, () => void 0), o()) : e, _ = (e, t) => {
+	let n = a(e, [
+		"xRaw",
+		"yRaw",
+		"verticalSpeedRaw"
+	], [
+		"xRaw",
+		"yRaw",
+		"verticalSpeedRaw"
+	]), r = t.stageHalfWidthRaw - t.fighterRadiusRaw;
+	return Object.freeze({
+		xRaw: h(n.xRaw, -r, r),
+		yRaw: h(n.yRaw, 0, t.maxHeightRaw),
+		verticalSpeedRaw: h(n.verticalSpeedRaw, -t.maxHeightRaw, t.maxHeightRaw)
+	});
+}, v = (e, t) => {
+	if (e === null) return null;
+	let n = a(e, [
+		"damage",
+		"stunTicks",
+		"knockbackRaw",
+		"blocked"
+	], [
+		"damage",
+		"stunTicks",
+		"knockbackRaw",
+		"blocked"
+	]);
+	return typeof n.blocked == "boolean" ? Object.freeze({
+		damage: h(n.damage, 0, t.maxHealth),
+		stunTicks: h(n.stunTicks, 0, 1024),
+		knockbackRaw: h(n.knockbackRaw, 0, t.stageHalfWidthRaw * 2),
+		blocked: n.blocked
+	}) : o();
+}, y = (e, t) => {
+	if (e.length !== 2 || t.length !== 2 || m(e[0]) === m(e[1])) return o();
+	let n = [];
+	for (let r of e) {
+		let e = m(r), i = t.filter((t) => t.playerId === e);
+		if (i.length !== 1) return o();
+		let s = a(i[0].input, [
+			"move",
+			"jump",
+			"strike",
+			"block"
+		], [
+			"move",
+			"jump",
+			"strike",
+			"block"
+		]);
+		if (![
+			-1,
+			0,
+			1
+		].includes(s.move) || typeof s.jump != "boolean" || typeof s.strike != "boolean" || typeof s.block != "boolean") return o();
+		n.push(Object.freeze({
+			move: s.move,
+			jump: s.jump,
+			strike: s.strike,
+			block: s.block
+		}));
+	}
+	return Object.freeze([n[0], n[1]]);
+}, b = (e, t, n) => {
+	let r = n.fighterRadiusRaw * 2;
+	if (Math.abs(e[0].yRaw - e[1].yRaw) >= r) return;
+	let i = t.fighters[0].xRaw <= t.fighters[1].xRaw ? 0 : 1, a = +(i === 0), o = e[i], s = e[a];
+	if (s.xRaw - o.xRaw >= r) return;
+	let c = n.stageHalfWidthRaw - n.fighterRadiusRaw, u = l.div(l.add(l.raw(o.xRaw), l.raw(s.xRaw)), l.fromInt(2)), d = l.clamp(u, l.raw(-c + n.fighterRadiusRaw), l.raw(c - n.fighterRadiusRaw));
+	o.xRaw = l.sub(d, l.raw(n.fighterRadiusRaw)), s.xRaw = l.add(d, l.raw(n.fighterRadiusRaw));
+}, x = (e, t, n, r) => {
+	if (t[0].health > 0 && t[1].health > 0 && n < e.rules.roundTicks) return {
+		...e,
+		elapsedTicks: n,
+		fighters: t,
+		events: r
+	};
+	let i = t[0].health === t[1].health ? -1 : t[0].health > t[1].health ? 0 : 1;
+	return r.push({
+		kind: "finish",
+		actorSlot: i,
+		targetSlot: -1,
+		amount: n
+	}), {
+		...e,
+		elapsedTicks: n,
+		status: i === -1 ? "draw" : "win",
+		winnerSlot: i,
+		fighters: t,
+		events: r
+	};
+}, S = (s = {}) => {
+	let m = a(s, ["strategies"], []), h = m.strategies === void 0 ? {} : a(m.strategies, ["movement", "hit"], []), S = Object.hasOwn(h, "movement") ? h.movement : d, C = Object.hasOwn(h, "hit") ? h.hit : f;
+	if (typeof S != "function" || typeof C != "function") return o();
+	let w = S, T = C, E = c({
+		state: n,
+		input: e,
+		options: t,
+		limits: {
+			maxCollectionLength: 16,
+			maxNodes: 4096,
+			maxBytes: 65536,
+			maxFieldId: 64
+		},
+		init: (e, t) => {
+			let n = i(t.rules);
+			return {
+				elapsedTicks: 0,
+				status: "running",
+				winnerSlot: -1,
+				rules: n,
+				fighters: r(t.playerIds).map((e, t) => ({
+					playerId: {
+						hi: e >>> 16,
+						lo: e & 65535
+					},
+					xRaw: t === 0 ? -n.spawnDistanceRaw : n.spawnDistanceRaw,
+					yRaw: 0,
+					verticalSpeedRaw: 0,
+					facing: t === 0 ? 1 : -1,
+					health: n.maxHealth,
+					stamina: n.maxStamina,
+					cooldownTicks: 0,
+					stunTicks: 0,
+					strikeHeld: !1,
+					jumpHeld: !1,
+					blocking: !1
+				})),
+				events: []
+			};
+		},
+		step: (e, t, n) => {
+			if (e.status !== "running") return e;
+			let r = e.rules, i = y(e.fighters, t), a = [], s = [!1, !1], c = [{ ...e.fighters[0] }, { ...e.fighters[1] }];
+			for (let t of [0, 1]) {
+				let o = c[t], l = e.fighters[t], u = i[t], d = l.stunTicks === 0;
+				o.stamina = Math.min(r.maxStamina, l.stamina + r.staminaRegen), o.cooldownTicks = Math.max(0, l.cooldownTicks - 1), o.stunTicks = Math.max(0, l.stunTicks - 1), o.blocking = d && u.block && l.yRaw === 0 && o.stamina >= r.blockCost;
+				let f = d && !o.blocking && u.jump && !l.jumpHeld && l.yRaw === 0, m = _(g(w(Object.freeze({
+					fighter: p(o),
+					intent: u,
+					rules: Object.freeze({ ...r }),
+					canAct: d,
+					jump: f,
+					tick: n
+				}))), r);
+				Object.assign(o, m), f && m.yRaw > 0 && a.push({
+					kind: "jump",
+					actorSlot: t,
+					targetSlot: -1,
+					amount: m.yRaw
+				}), o.strikeHeld = u.strike, o.jumpHeld = u.jump, s[t] = d && !o.blocking && l.cooldownTicks === 0 && u.strike && !l.strikeHeld && o.stamina >= r.strikeCost, s[t] && (o.stamina -= r.strikeCost, o.cooldownTicks = r.cooldownTicks, a.push({
+					kind: "strike",
+					actorSlot: t,
+					targetSlot: 1 - t,
+					amount: r.strikeCost
+				}));
+			}
+			b(c, e, r), c[0].xRaw !== c[1].xRaw && (c[0].facing = c[0].xRaw < c[1].xRaw ? 1 : -1, c[1].facing = c[0].facing === 1 ? -1 : 1);
+			let u = [null, null];
+			for (let e of [0, 1]) s[e] && (u[e] = v(g(T(Object.freeze({
+				attacker: p(c[e]),
+				defender: p(c[+(e === 0)]),
+				rules: Object.freeze({ ...r }),
+				tick: n
+			}))), r));
+			for (let e of [0, 1]) {
+				let t = u[e];
+				if (!t) continue;
+				let n = c[+(e === 0)];
+				if (t.blocked) {
+					if (!n.blocking || n.stamina < r.blockCost) return o();
+					n.stamina -= r.blockCost;
+				}
+				n.health = Math.max(0, n.health - t.damage), n.stunTicks = Math.max(n.stunTicks, t.stunTicks);
+				let i = r.stageHalfWidthRaw - r.fighterRadiusRaw, s = c[e].facing;
+				n.xRaw = l.clamp(l.add(l.raw(n.xRaw), l.raw(s * t.knockbackRaw)), l.raw(-i), l.raw(i)), a.push({
+					kind: t.blocked ? "block" : "hit",
+					actorSlot: e,
+					targetSlot: +(e === 0),
+					amount: t.damage
+				});
+			}
+			return b(c, e, r), x(e, c, e.elapsedTicks + 1, a);
+		}
+	});
+	return u.set(E, Object.freeze({
+		movement: w === d ? "default" : "custom",
+		hit: T === f ? "default" : "custom"
+	})), E;
+}, C = (e) => u.get(e) ?? o();
+//#endregion
+export { S as createFightSimulation, f as defaultFightHit, d as defaultFightMovement, C as describeFightStrategies };