@caperjs/plugin-crunch 0.1.0

package/lib/caper-plugin-crunch.mjs

@@ -0,0 +1,1331 @@
+import { Application as e, Logger as t, Plugin as n, SignalConnections as r, bindAllMethods as i, isDev as a, randomUUID as o, resolvePointLike as s, resolveSizeLike as c, version as l } from "@caperjs/core";
+import { Container as u, Graphics as d, Rectangle as f } from "pixi.js";
+//#region src/types.ts
+var p = /* @__PURE__ */ function(e) {
+	return e[e.NONE = 0] = "NONE", e[e.DEFAULT = 1] = "DEFAULT", e[e.PLAYER = 2] = "PLAYER", e[e.ENEMY = 4] = "ENEMY", e[e.PROJECTILE = 8] = "PROJECTILE", e[e.PLATFORM = 16] = "PLATFORM", e[e.TRIGGER = 32] = "TRIGGER", e[e.ITEM = 64] = "ITEM", e[e.WALL = 128] = "WALL", e[e.FX = 256] = "FX", e[e.ALL = 4294967295] = "ALL", e;
+}({}), m = class e {
+	constructor() {
+		this._layers = /* @__PURE__ */ new Map(), this._usedIndices = /* @__PURE__ */ new Set();
+	}
+	static get instance() {
+		return e._instance ||= new e(), e._instance;
+	}
+	register(e, t, n) {
+		if (t < 0 || t > 15) throw Error("Custom collision layer index must be between 0 and 15");
+		if (this._usedIndices.has(t)) throw Error(`Collision layer index ${t} is already in use`);
+		if (this._layers.has(e)) throw Error(`Collision layer with name "${e}" already exists`);
+		let r = {
+			name: e,
+			value: 1 << t + 16,
+			description: n
+		};
+		return this._layers.set(e, r), this._usedIndices.add(t), r;
+	}
+	get(e) {
+		return this._layers.get(e);
+	}
+	getAll() {
+		return Array.from(this._layers.values());
+	}
+	has(e) {
+		return this._layers.has(e);
+	}
+	remove(e) {
+		let t = this._layers.get(e);
+		if (!t) return !1;
+		let n = t.value, r = Math.log2(n) - 16;
+		return this._usedIndices.delete(r), this._layers.delete(e);
+	}
+	clear() {
+		this._layers.clear(), this._usedIndices.clear();
+	}
+	getNextAvailableIndex() {
+		for (let e = 0; e < 16; e++) if (!this._usedIndices.has(e)) return e;
+		return -1;
+	}
+}, h = {
+	createLayer(e) {
+		if (e < 0 || e > 15) throw Error("Custom collision layer index must be between 0 and 15");
+		return 1 << e + 16;
+	},
+	createMask(e) {
+		return e.reduce((e, t) => e | t, 0);
+	},
+	isLayerInMask(e, t) {
+		return (e & t) !== 0;
+	},
+	getRegistry() {
+		return m.instance;
+	}
+};
+//#endregion
+//#region src/utils.ts
+function g(e) {
+	let { x: t, y: n } = e.position === void 0 ? {
+		x: e?.x ?? 0,
+		y: e?.y ?? 0
+	} : s(e.position);
+	return {
+		x: t,
+		y: n
+	};
+}
+function _(e) {
+	let { width: t, height: n } = e.size === void 0 ? {
+		width: e?.width ?? 32,
+		height: e?.height ?? 32
+	} : c(e.size);
+	return {
+		width: t,
+		height: n
+	};
+}
+//#endregion
+//#region src/Entity.ts
+var v = class {
+	set active(e) {
+		this._active = e;
+	}
+	get active() {
+		return this._active;
+	}
+	set id(e) {
+		this._id = e;
+	}
+	get id() {
+		return this._id || this.type;
+	}
+	get make() {
+		return this.app.make;
+	}
+	set data(e) {
+		this._data = e;
+	}
+	get data() {
+		return this._data;
+	}
+	setFollowing(e, t = {
+		x: 0,
+		y: 0
+	}) {
+		this._followOffset = s(t), this._following && this.system.removeFollower(this), this._following = e, e && this.system.addFollower(e, this);
+	}
+	get followOffset() {
+		return this._followOffset || {
+			x: 0,
+			y: 0
+		};
+	}
+	get following() {
+		return this._following;
+	}
+	get followers() {
+		return this.system.getFollowersOf(this);
+	}
+	get group() {
+		return this._group;
+	}
+	set groupOffset(e) {
+		this._groupOffset = s(e);
+	}
+	get groupOffset() {
+		return this._groupOffset || {
+			x: 0,
+			y: 0
+		};
+	}
+	setGroup(e, t = {
+		x: 0,
+		y: 0
+	}) {
+		this._groupOffset = s(t), this._group && (this.system.removeFromGroup(this), this.onRemovedFromGroup()), this._group = e, e && (this.system.addToGroup(e, this), this.onAddedToGroup());
+	}
+	set position(e) {
+		let { x: t, y: n } = s(e);
+		this.setPosition(t, n);
+	}
+	get position() {
+		return {
+			x: this.x,
+			y: this.y
+		};
+	}
+	set x(e) {
+		this._x = e;
+	}
+	get x() {
+		return this._group ? Math.round(this._x + this._group.getChildOffset(this).x) : Math.round(this._x);
+	}
+	set y(e) {
+		this._y = e;
+	}
+	get y() {
+		return this._group ? Math.round(this._y + this._group.getChildOffset(this).y) : Math.round(this._y);
+	}
+	get isCulled() {
+		return this._isCulled;
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	get app() {
+		return e.getInstance();
+	}
+	get physics() {
+		return this.app.getPlugin("crunch");
+	}
+	constructor(e) {
+		this.collisionLayer = p.NONE, this.collisionMask = p.NONE, this._active = !0, this.updatedFollowPosition = !1, this.updatedGroupPosition = !1, i(this), this._config = e, this.signalConnections = new r(), this.shouldRemoveOnCull = !1, this.width = 0, this.height = 0, this._data = {}, this._group = null, this._isCulled = !1, this._isDestroyed = !1, this._isInitialized = !1, this._xRemainder = 0, this._yRemainder = 0, this._x = 0, this._y = 0, e && this.init(e), this.initialize(), this.addView();
+	}
+	initialize() {}
+	preUpdate() {}
+	update(e) {}
+	postUpdate() {}
+	excludeCollisionType() {
+		console.warn("excludeCollisionType is deprecated. Use setCollisionMask instead.");
+	}
+	includeCollisionType() {
+		console.warn("includeCollisionType is deprecated. Use setCollisionMask instead.");
+	}
+	removeCollisionType() {
+		console.warn("removeCollisionType is deprecated. Use removeCollisionMask instead.");
+	}
+	addCollisionType() {
+		console.warn("addCollisionType is deprecated. Use addCollisionMask instead.");
+	}
+	canCollideWith() {
+		return !0;
+	}
+	addView() {
+		this.view && (this.view.visible = !0, this.view.label = this.id || this.type, this.system.container && (this.system.container.addChild(this.view), this.updateView()));
+	}
+	init(e) {
+		if (!e) return;
+		this._config = e, e.id ? this._id = e.id : this._id = o(), e.type && (this.type = e.type), e.data && (this._data = e.data);
+		let t = g(e);
+		this._x = t.x, this._y = t.y;
+		let n = _(e);
+		this.width = n.width, this.height = n.height, e.collisionLayer !== void 0 && this.setCollisionLayer(e.collisionLayer), e.collisionMask !== void 0 && this.setCollisionMask(e.collisionMask), this._xRemainder = 0, this._yRemainder = 0, e.view && this.setView(e.view), e.group && this.setGroup(e.group ?? null, e.groupOffset ? s(e.groupOffset) : {
+			x: 0,
+			y: 0
+		}), e.follows && this.setFollowing(e.follows ?? null, e.followOffset ? s(e.followOffset) : {
+			x: 0,
+			y: 0
+		}), this.addView();
+	}
+	reset() {
+		this._isCulled = !1, this._isDestroyed = !1, this._xRemainder = 0, this._yRemainder = 0, this._followOffset = {
+			x: 0,
+			y: 0
+		}, this._following = null, this._groupOffset = {
+			x: 0,
+			y: 0
+		}, this._group = null, this._data = {}, this._x = -(2 ** 53 - 1), this._y = -(2 ** 53 - 1), this.view && (this.view.visible = !1), this.system.removeEntity(this);
+	}
+	get system() {
+		return this.physics.system;
+	}
+	onAddedToGroup() {}
+	onRemovedFromGroup() {}
+	updatePosition() {
+		this.x = this._x, this.y = this._y, this.updateView();
+	}
+	onCull() {
+		this._isCulled = !0, this.view && (this.view.visible = !1);
+	}
+	onUncull() {
+		this._isCulled = !1, this.view && (this.view.visible = !0);
+	}
+	destroy() {
+		this._isDestroyed || (this._isDestroyed = !0, this._isCulled = !1, this.signalConnections.disconnectAll(), this.view && (this.view.visible = !1, this.view.removeFromParent()), this.system.removeFollower(this));
+	}
+	onRemoved() {
+		this._isDestroyed || this.destroy();
+	}
+	setView(e) {
+		this.view = e, this.updateView();
+	}
+	updateView() {
+		this.view && this.view.visible && this.view.position && this.view.position.set(this.x, this.y);
+	}
+	getBounds() {
+		return {
+			x: this.x,
+			y: this.y,
+			width: this.width,
+			height: this.height
+		};
+	}
+	setPosition(e, t) {
+		this._x = e, this._y = t, this._xRemainder = 0, this._yRemainder = 0, this.updateView();
+	}
+	moveTo(e, t) {
+		this.setPosition(e, t);
+	}
+	addSignalConnection(...e) {
+		for (let t of e) this.signalConnections.add(t);
+	}
+	connectSignal(...e) {
+		for (let t of e) this.signalConnections.add(t);
+	}
+	connectAction(...e) {
+		for (let t of e) this.signalConnections.add(t);
+	}
+	canCollideWithEntity(e) {
+		return (this.collisionLayer & e.collisionMask) !== 0 && (e.collisionLayer & this.collisionMask) !== 0;
+	}
+	setCollisionLayer(e) {
+		this.collisionLayer = e;
+	}
+	addCollisionLayer(e) {
+		this.collisionLayer |= e;
+	}
+	removeCollisionLayer(e) {
+		this.collisionLayer &= ~e;
+	}
+	setCollisionMask(...e) {
+		this.collisionMask = this.physics.createCollisionMask(...e);
+	}
+	addCollisionMask(e) {
+		this.collisionMask |= e;
+	}
+	removeCollisionMask(e) {
+		this.collisionMask &= ~e;
+	}
+	hasCollisionLayer(e) {
+		return (this.collisionLayer & e) !== 0;
+	}
+	canCollideWithLayer(e) {
+		return (this.collisionMask & e) !== 0;
+	}
+}, y = class extends v {
+	constructor(...e) {
+		super(...e), this.entityType = "Actor", this.velocity = {
+			x: 0,
+			y: 0
+		}, this.disableActorCollisions = !1, this.shouldRemoveOnCull = !0, this.collisions = [], this.actorCollisions = [], this._isRidingSolidCache = null, this._carriedBy = null, this._carriedByOverlap = 0, this._currentGridCells = [];
+	}
+	init(e) {
+		super.init(e), this.velocity = {
+			x: 0,
+			y: 0
+		}, this._isRidingSolidCache = null, this._carriedBy = null, this._carriedByOverlap = 0, this.actorCollisions = [], this._currentGridCells = [], e.disableActorCollisions !== void 0 && (this.disableActorCollisions = e.disableActorCollisions), this.system.enableActorCollisions && !this.disableActorCollisions && this.updateGridCells();
+	}
+	preUpdate() {
+		this.active && (this.collisions = [], this.actorCollisions = [], this._isRidingSolidCache = null, this._carriedBy = null, this._carriedByOverlap = 0);
+	}
+	update(e) {
+		this.active && (this.isRidingSolid() || (this.velocity.y += this.system.gravity * e), this.velocity.x = Math.min(Math.max(this.velocity.x, -this.system.maxVelocity), this.system.maxVelocity), this.velocity.y = Math.min(Math.max(this.velocity.y, -this.system.maxVelocity), this.system.maxVelocity), this.velocity.x !== 0 && this.moveX(this.velocity.x * e), this.velocity.y !== 0 && this.moveY(this.velocity.y * e), this.system.enableActorCollisions && this.updateGridCells(), this.updateView());
+	}
+	postUpdate() {
+		this.active && this.isRidingSolid() && (this.velocity.y = 0);
+	}
+	reset() {
+		super.reset(), this._isRidingSolidCache = null, this._carriedBy = null, this._carriedByOverlap = 0, this.velocity = {
+			x: 0,
+			y: 0
+		}, this.updatePosition();
+	}
+	onCull() {
+		this.view?.destroy();
+	}
+	onCollide(e) {}
+	onActorCollide(e) {}
+	isRiding(e) {
+		if (!e.collideable || (this.collisionLayer & e.collisionMask) === 0 || (e.collisionLayer & this.collisionMask) === 0 || this._carriedBy && this._carriedBy !== e) return !1;
+		let t = this.y + this.height, n = Math.abs(t - e.y) <= 1, r = this.x + this.width > e.x && this.x < e.x + e.width, i = Math.min(this.x + this.width, e.x + e.width) - Math.max(this.x, e.x), a = n && r;
+		return a && i > this._carriedByOverlap && (this._carriedBy = e, this._carriedByOverlap = i), a;
+	}
+	isRidingSolid() {
+		return this._isRidingSolidCache === null && (this._isRidingSolidCache = this.getSolidsAt(this.x, this.y + 1).some((e) => this.isRiding(e))), this._isRidingSolidCache;
+	}
+	squish(e) {}
+	updateGridCells() {
+		this.disableActorCollisions || this.system.updateActorInGrid(this);
+	}
+	get currentGridCells() {
+		return this._currentGridCells;
+	}
+	set currentGridCells(e) {
+		this._currentGridCells = e;
+	}
+	moveX(e, t, n) {
+		if (!this.active || e === 0) return [];
+		this._xRemainder += e;
+		let r = Math.round(this._xRemainder);
+		if (r === 0) return [];
+		let i = [], a = this.collisionLayer, o = this.collisionMask;
+		if (o === 0) return this._xRemainder -= r, this._x += r, this.updateView(), [];
+		this._xRemainder -= r;
+		let s = Math.sign(r), c = Math.abs(r), l = s;
+		for (n && (n.collideable = !1); c > 0;) {
+			let e = this._x + l, r = this.getSolidsAt(e, this._y), u = !1;
+			for (let e of r) {
+				if (!e.canCollide || (a & e.collisionMask) === 0 || (e.collisionLayer & o) === 0) continue;
+				let r = {
+					collided: !0,
+					solid: e,
+					normal: {
+						x: -s,
+						y: 0
+					},
+					penetration: l > 0 ? this.x + this.width - e.x : e.x + e.width - this.x,
+					pushingSolid: n
+				};
+				i.push(r), t && t(r), this.onCollide(r), u = !0;
+			}
+			if (u) break;
+			this._x = e, c--, (c % 4 == 0 || c === 0) && this.updateView();
+		}
+		return n && (n.collideable = !0), Math.abs(r) - c > 0 && this.updateView(), i;
+	}
+	moveY(e, t, n) {
+		if (!this.active || e === 0) return [];
+		this._yRemainder += e;
+		let r = Math.round(this._yRemainder);
+		if (r === 0) return [];
+		let i = [], a = this.collisionLayer, o = this.collisionMask;
+		if (o === 0) return this._yRemainder -= r, this._y += r, this.updateView(), [];
+		this._yRemainder -= r;
+		let s = Math.sign(r), c = Math.abs(r), l = s;
+		for (n && (n.collideable = !1); c > 0;) {
+			let e = this._y + l, r = this.getSolidsAt(this._x, e), u = !1;
+			for (let e of r) {
+				if (!e.canCollide || (a & e.collisionMask) === 0 || (e.collisionLayer & o) === 0) continue;
+				let r = {
+					collided: !0,
+					solid: e,
+					normal: {
+						x: 0,
+						y: -s
+					},
+					penetration: l > 0 ? this.y + this.height - e.y : e.y + e.height - this.y,
+					pushingSolid: n
+				};
+				i.push(r), t && t(r), this.onCollide(r), u = !0;
+			}
+			if (u) break;
+			this._y = e, c--, (c % 4 == 0 || c === 0) && this.updateView();
+		}
+		return n && (n.collideable = !0), Math.abs(r) - c > 0 && this.updateView(), i;
+	}
+	updateView() {
+		this.view && this.view.visible && (this.view.x = this._x, this.view.y = this._y);
+	}
+	getSolidsAt(e, t) {
+		return this.system.getSolidsAt(e, t, this);
+	}
+	checkActorCollision(e) {
+		if (!this.active || !e.active || this.disableActorCollisions || e.disableActorCollisions || (this.collisionLayer & e.collisionMask) === 0 || (e.collisionLayer & this.collisionMask) === 0) return {
+			collided: !1,
+			actor: e
+		};
+		let t = this.x, n = this.x + this.width, r = this.y, i = this.y + this.height, a = e.x, o = e.x + e.width, s = e.y, c = e.y + e.height;
+		if (n > a && t < o && i > s && r < c) {
+			let l = Math.min(n - a, o - t), u = Math.min(i - s, c - r), d, f;
+			return l < u ? (f = l, d = {
+				x: t < a ? -1 : 1,
+				y: 0
+			}) : (f = u, d = {
+				x: 0,
+				y: r < s ? -1 : 1
+			}), {
+				collided: !0,
+				actor: e,
+				normal: d,
+				penetration: f
+			};
+		}
+		return {
+			collided: !1,
+			actor: e
+		};
+	}
+	resolveActorCollision(e) {
+		return !e.collided || !e.normal || !e.penetration || this.onActorCollide(e), e;
+	}
+	setSize(e, t) {
+		let n = this.width !== e || this.height !== t;
+		this.width = e, this.height = t, n && this.system.enableActorCollisions && this.updateGridCells();
+	}
+	setWidth(e) {
+		this.width !== e && (this.width = e, this.system.enableActorCollisions && this.updateGridCells());
+	}
+	setHeight(e) {
+		this.height !== e && (this.height = e, this.system.enableActorCollisions && this.updateGridCells());
+	}
+}, b = class extends v {
+	constructor(...e) {
+		super(...e), this._visible = !0, this.entityType = "Group", this.childOffsets = /* @__PURE__ */ new Map(), this.isStatic = !0;
+	}
+	getChildOffset(e) {
+		return this.childOffsets.get(e) ?? {
+			x: 0,
+			y: 0
+		};
+	}
+	set visible(e) {
+		this.system.getEntitiesInGroup(this).forEach((t) => {
+			t.view.visible = e;
+		});
+	}
+	get visible() {
+		return this._visible;
+	}
+	set x(e) {
+		this._x = e;
+	}
+	get x() {
+		return this._x;
+	}
+	set y(e) {
+		this._y = e;
+	}
+	get y() {
+		return this._y;
+	}
+	add(e, t = {
+		x: 0,
+		y: 0
+	}) {
+		return e.setGroup(this, t), this;
+	}
+	remove(e) {
+		return e.setGroup(null), this;
+	}
+	move(e, t) {
+		this._x += e, this._y += t, this.updateView();
+	}
+	moveTo(e, t) {
+		let n = e - this.x, r = t - this.y;
+		this.move(n, r);
+	}
+	getChildrenByType(e) {
+		return this.system.getEntitiesInGroup(this).filter((t) => t.entityType === e || t.type === e);
+	}
+	getActors() {
+		return this.getChildrenByType("Actor");
+	}
+	getSolids() {
+		return this.getChildrenByType("Solid");
+	}
+	getSensors() {
+		return this.getChildrenByType("Sensor");
+	}
+	getGroups() {
+		return this.getChildrenByType("Group");
+	}
+	destroy() {
+		this.system.removeGroup(this), super.destroy();
+	}
+}, x = class extends v {
+	constructor(...e) {
+		super(...e), this.entityType = "Sensor", this.shouldRemoveOnCull = !1, this.collidableTypes = [], this.velocity = {
+			x: 0,
+			y: 0
+		}, this.isStatic = !1, this.overlappingActors = /* @__PURE__ */ new Set(), this._isRidingSolidCache = null, this._currentSensorOverlaps = /* @__PURE__ */ new Set(), this._currentOverlaps = /* @__PURE__ */ new Set();
+	}
+	setPosition(e, t) {
+		this.isStatic ? (this._x = e, this._y = t, this._xRemainder = 0, this._yRemainder = 0, this.updateView(), this.checkActorOverlaps()) : super.setPosition(e, t);
+	}
+	set x(e) {
+		super.x = e, this.isStatic && (this._xRemainder = 0, this.updateView(), this.checkActorOverlaps());
+	}
+	get x() {
+		return super.x;
+	}
+	set y(e) {
+		super.y = e, this.isStatic && (this._yRemainder = 0, this.updateView(), this.checkActorOverlaps());
+	}
+	get y() {
+		return super.y;
+	}
+	init(e) {
+		super.init(e), this.velocity ||= {
+			x: 0,
+			y: 0
+		}, this.velocity.x = 0, this.velocity.y = 0, this.overlappingActors ||= /* @__PURE__ */ new Set(), this._isRidingSolidCache = null;
+	}
+	isRiding(e) {
+		if (Math.sign(this.system.gravity) > 0) {
+			let t = this.y + this.height, n = Math.abs(t - e.y) <= 1, r = this.x + this.width > e.x && this.x < e.x + e.width;
+			return n && r;
+		} else {
+			let t = this.y, n = Math.abs(t - (e.y + e.height)) <= 1, r = this.x + this.width > e.x && this.x < e.x + e.width;
+			return n && r;
+		}
+	}
+	isRidingSolid() {
+		return this._isRidingSolidCache === null && (this._isRidingSolidCache = this.getSolidsAt(this.x, this.system.gravity > 0 ? this.y + 1 : this.y - 1).some((e) => this.isRiding(e))), this._isRidingSolidCache;
+	}
+	moveStatic(e, t) {
+		this._x = e, this._y = t, this._xRemainder = 0, this._yRemainder = 0, this.updateView(), this.checkActorOverlaps();
+	}
+	moveX(e) {
+		if (this.isStatic) return;
+		this._xRemainder += e;
+		let t = Math.round(this._xRemainder);
+		if (t !== 0) {
+			this._xRemainder -= t;
+			let e = Math.sign(t), n = Math.abs(t);
+			for (; n > 0;) {
+				let t = e, r = this.x + t, i = !1;
+				for (let e of this.getSolidsAt(r, this.y)) if (e.canCollide) {
+					i = !0;
+					break;
+				}
+				if (!i) this._x = r, n--, this.updateView(), this.checkActorOverlaps();
+				else {
+					this.velocity.x = 0;
+					break;
+				}
+			}
+		}
+	}
+	moveY(e) {
+		if (this.isStatic) return;
+		this._yRemainder += e;
+		let t = Math.round(this._yRemainder);
+		if (t !== 0) {
+			this._yRemainder -= t;
+			let e = Math.sign(t), n = Math.abs(t);
+			for (; n > 0;) {
+				let t = e, r = this.y + t, i = !1;
+				if (Math.sign(this.system.gravity) === e) {
+					for (let e of this.getSolidsAt(this.x, r)) if (e.canCollide) {
+						i = !0;
+						break;
+					}
+				}
+				if (!i) this._y = r, n--, this.updateView(), this.checkActorOverlaps();
+				else {
+					this.velocity.y = 0;
+					break;
+				}
+			}
+		}
+	}
+	update(e) {
+		this._isRidingSolidCache = null, this.active && (!this.isStatic && !this.isRidingSolid() && (this.velocity.y += this.system.gravity * e), this.velocity.x !== 0 && this.moveX(this.velocity.x * e), this.velocity.y !== 0 && this.moveY(this.velocity.y * e));
+	}
+	checkActorOverlaps() {
+		if (this.collisionMask === 0 || !this.active) return /* @__PURE__ */ new Set();
+		this._currentSensorOverlaps.clear(), this._currentOverlaps.clear();
+		let e = this.collisionLayer, t = this.collisionMask, n = this.system.getActorsByType(this.collidableTypes);
+		for (let r of n) r.active && ((e & r.collisionMask) === 0 || (r.collisionLayer & t) === 0 || this.system.aabbOverlap(this, r) && (this._currentOverlaps.add(r), this.overlappingActors.has(r) || (this._currentSensorOverlaps.add({
+			actor: r,
+			sensor: this,
+			type: `${r.type}|${this.type}`
+		}), this.onActorEnter(r))));
+		for (let e of this.overlappingActors) this._currentOverlaps.has(e) || this.onActorExit(e);
+		let r = this.overlappingActors;
+		return this.overlappingActors = this._currentOverlaps, this._currentOverlaps = r, this._currentOverlaps.clear(), this._currentSensorOverlaps;
+	}
+	reset() {
+		super.reset(), this._currentSensorOverlaps.clear(), this._currentOverlaps.clear(), this._isRidingSolidCache = null, this.velocity = {
+			x: 0,
+			y: 0
+		}, this.overlappingActors = /* @__PURE__ */ new Set();
+	}
+	onActorEnter(e) {}
+	onActorExit(e) {}
+	getSolidsAt(e, t) {
+		return this.system.getSolidsAt(e, t, this);
+	}
+}, S = class extends v {
+	constructor(...e) {
+		super(...e), this.entityType = "Solid", this.shouldRemoveOnCull = !1, this._canCollide = !0, this.collideable = !0, this.moving = !1;
+	}
+	get canCollide() {
+		return this._canCollide;
+	}
+	setPosition(e, t) {
+		this.x = e, this.y = t;
+	}
+	set x(e) {
+		this._nextX = Math.round(e), this.moving = !0;
+	}
+	get x() {
+		return this._x;
+	}
+	set y(e) {
+		this._nextY = Math.round(e), this.moving = !0;
+	}
+	get y() {
+		return this._y;
+	}
+	init(e) {
+		super.init(e), e && (this._nextX = this._x, this._nextY = this._y);
+	}
+	get right() {
+		return this.x + this.width;
+	}
+	get left() {
+		return this.x;
+	}
+	get top() {
+		return this.y;
+	}
+	get bottom() {
+		return this.y + this.height;
+	}
+	canCollideWith() {
+		return !!this.collideable;
+	}
+	move(e, t, n = this.system.actors, r = this.system.sensors, i = !1) {
+		if (!this.active) return;
+		let a = e + (this._nextX - this._x), o = t + (this._nextY - this._y);
+		this._xRemainder += a, this._yRemainder += o;
+		let s = Math.round(this._xRemainder), c = Math.round(this._yRemainder);
+		if (s !== 0 || c !== 0 || i) {
+			if (this.collideable) {
+				let e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set();
+				for (let t of n) (t.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & t.collisionMask) !== 0 && t.isRiding(this) && e.add(t);
+				for (let e of r) (e.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & e.collisionMask) !== 0 && e.isRiding(this) && t.add(e);
+				if (this._canCollide = !1, s !== 0) if (this._xRemainder -= s, this._x += s, s > 0) {
+					for (let t of n) this.overlaps(t) && (t.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & t.collisionMask) !== 0 ? t.moveX(this.right - t.x, t.squish, this) : e.has(t) && t.moveX(s);
+					for (let e of r) this.overlaps(e) && (e.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & e.collisionMask) !== 0 ? e.moveX(this.right - e.x) : t.has(e) && e.moveX(s);
+				} else {
+					for (let t of n) this.overlaps(t) && (t.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & t.collisionMask) !== 0 ? t.moveX(this.left - (t.x + t.width), t.squish, this) : e.has(t) && t.moveX(s);
+					for (let e of r) this.overlaps(e) && (e.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & e.collisionMask) !== 0 ? e.moveX(this.left - (e.x + e.width)) : t.has(e) && e.moveX(s);
+				}
+				if (c !== 0) if (this._yRemainder -= c, this._y += c, c > 0) {
+					for (let t of n) this.overlaps(t) && (t.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & t.collisionMask) !== 0 ? t.moveY(this.bottom - t.y, t.squish, this) : e.has(t) && t.moveY(c);
+					for (let e of r) this.overlaps(e) && (e.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & e.collisionMask) !== 0 ? e.moveY(this.bottom - e.y) : t.has(e) && e.moveY(c);
+				} else {
+					for (let t of n) this.overlaps(t) && (t.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & t.collisionMask) !== 0 ? t.moveY(this.top - (t.y + t.height), t.squish, this) : e.has(t) && t.moveY(c);
+					for (let e of r) this.overlaps(e) && (e.collisionLayer & this.collisionMask) !== 0 && (this.collisionLayer & e.collisionMask) !== 0 ? e.moveY(this.top - (e.y + e.height)) : t.has(e) && e.moveY(c);
+				}
+				this._canCollide = !0;
+			} else s !== 0 && (this._xRemainder -= s, this._x += s), c !== 0 && (this._yRemainder -= c, this._y += c);
+			this._nextX = this._x, this._nextY = this._y, this.updateView();
+		}
+	}
+	overlaps(e) {
+		return (this.collisionLayer & e.collisionMask) === 0 || (e.collisionLayer & this.collisionMask) === 0 ? !1 : this.system.aabbOverlap(this, e);
+	}
+}, C = class {
+	set debug(e) {
+		this._debug = e, this._debug ? (this._debugContainer ||= this.options.plugin.container.addChild(new u()), this._debugGfx ||= new d(), this._debugContainer.addChild(this._debugGfx)) : (this._debugGfx?.clear(), this._debugContainer?.removeChildren());
+	}
+	set gridSize(e) {
+		this.options.gridSize = e, this.grid.clear();
+		for (let e of this.solids) this.addSolidToGrid(e);
+	}
+	set gravity(e) {
+		this.options.gravity = e;
+	}
+	get gravity() {
+		return this.options.gravity;
+	}
+	set maxVelocity(e) {
+		this.options.maxVelocity = e;
+	}
+	get maxVelocity() {
+		return this.options.maxVelocity;
+	}
+	set boundary(e) {
+		this.options.boundary = e;
+	}
+	get boundary() {
+		return this.options.boundary;
+	}
+	get container() {
+		return this.options.plugin.container;
+	}
+	addView(e) {
+		this.container.addChild(e);
+	}
+	constructor(e) {
+		this.entities = /* @__PURE__ */ new Set(), this._flaggedEntities = /* @__PURE__ */ new Set(), this.actors = /* @__PURE__ */ new Set(), this.solids = /* @__PURE__ */ new Set(), this.sensors = /* @__PURE__ */ new Set(), this.groups = /* @__PURE__ */ new Set(), this.actorsByType = /* @__PURE__ */ new Map(), this.solidsByType = /* @__PURE__ */ new Map(), this.sensorsByType = /* @__PURE__ */ new Map(), this.groupsByType = /* @__PURE__ */ new Map(), this.followers = /* @__PURE__ */ new Map(), this.groupWithEntities = /* @__PURE__ */ new Map(), this.grid = /* @__PURE__ */ new Map(), this.collisions = [], this.sensorOverlaps = [], this.actorCollisions = [], this._checkedPairs = /* @__PURE__ */ new Set(), this._collisionResultPool = [], this._collisionResultPoolIndex = 0, this._actorCollisionPool = [], this._actorCollisionPoolIndex = 0, this._debugGfx = null, this._debug = !1, this._movedActors = /* @__PURE__ */ new Set(), this._activeGridCells = /* @__PURE__ */ new Set(), this._potentialCollisions = /* @__PURE__ */ new Map(), this.options = {
+			...e,
+			culling: e.culling ?? !1
+		}, this.debug = e.debug ?? !1, this._debugContainer = new u(), e.plugin.container.addChild(this._debugContainer);
+	}
+	_resetPositionFlags(e) {
+		e.updatedFollowPosition = !1, e.updatedGroupPosition = !1;
+	}
+	update(e) {
+		if (!this.options.plugin.enabled) return;
+		this.collisions.length = 0, this.sensorOverlaps.length = 0, this.actorCollisions.length = 0, this.resetCollisionPools();
+		let t = e / 60;
+		for (let e of this.groups) e.update(t);
+		this.updateSolids(t);
+		for (let e of this.sensors) this.updateSensor(e, t);
+		for (let e of this.actors) e.actorCollisions.length > 0 && (e.actorCollisions.length = 0);
+		this.updateActors(t), this.updateEntityPositions(), this.processCollisionsAndOverlaps(), this.options.culling && this.options.boundary && this.cullOutOfBounds(), this._debug && this.debugRender();
+	}
+	updateSolids(e) {
+		let t = !1;
+		for (let n of this.solids) n.preUpdate(), n.update(e), n.postUpdate(), n.moving && (t = !0);
+		if (!t) return;
+		let n = /* @__PURE__ */ new Set();
+		for (let e of this.solids) e.moving && (this.removeSolidFromGrid(e), e.move(0, 0, this.actors, this.sensors, !0), n.add(e));
+		for (let e of n) this.addSolidToGrid(e);
+	}
+	updateActors(e) {
+		if (this.actors.size !== 0) {
+			for (let t of this.actors) if (t.active) {
+				t.preUpdate(), t.update(e), t.postUpdate();
+				let n = t.collisions;
+				if (n.length > 0) for (let e of n) this.collisions.push({
+					type: `${t.type}|${e.solid.type}`,
+					entity1: t,
+					entity2: e.solid,
+					result: {
+						collided: e.collided,
+						normal: e.normal,
+						penetration: e.penetration,
+						solid: e.solid
+					}
+				});
+			}
+		}
+	}
+	updateEntityPositions() {
+		this._flaggedEntities.clear();
+		for (let [e, t] of this.followers) {
+			let n = e.x, r = e.y;
+			for (let i of t) if (!i.updatedFollowPosition) {
+				let t = i.group !== null;
+				if (t && i.group === e.group) {
+					let t = e.groupOffset, n = i.group.x, r = i.group.y;
+					i.setPosition(n + t.x + i.followOffset.x, r + t.y + i.followOffset.y);
+				} else t ? i.setPosition(n + i.followOffset.x + i.group.x + i.groupOffset.x, r + i.followOffset.y + i.group.y + i.groupOffset.y) : i.setPosition(n + i.followOffset.x, r + i.followOffset.y);
+				i.updatedFollowPosition = !0, this._flaggedEntities.add(i), t && (i.updatedGroupPosition = !0);
+			}
+		}
+		for (let [e, t] of this.groupWithEntities) {
+			let n = e.x, r = e.y;
+			for (let e of t) !e.updatedGroupPosition && !e.updatedFollowPosition && (e.setPosition(n + e.groupOffset.x, r + e.groupOffset.y), e.updatedGroupPosition = !0, this._flaggedEntities.add(e));
+		}
+		this._flaggedEntities.forEach(this._resetPositionFlags);
+	}
+	processCollisionsAndOverlaps() {
+		this.options.overlapResolver && this.sensorOverlaps.length > 0 && this.options.overlapResolver(this.sensorOverlaps), this.options.enableActorCollisions && this.actors.size > 1 && this.checkActorCollisions(), this.collisions.length > 0 && this.options.collisionResolver && this.options.collisionResolver(this.collisions), this.actorCollisions.length > 0 && this.options.actorCollisionResolver && this.options.actorCollisionResolver(this.actorCollisions);
+	}
+	cullOutOfBounds() {
+		if (!this.options.boundary) return;
+		let e = this.options.boundary, t = [], n = [], r = [], i = [], a = e.x, o = e.y, s = a + e.width, c = o + e.height;
+		for (let e of this.actors) {
+			let n = e.x + e.width, r = e.y + e.height;
+			e.x >= s || n <= a || e.y >= c || r <= o ? (e.isCulled || e.onCull(), e.shouldRemoveOnCull && t.push(e)) : e.isCulled && e.onUncull();
+		}
+		for (let e of this.solids) {
+			let t = e.x + e.width, r = e.y + e.height;
+			e.x >= s || t <= a || e.y >= c || r <= o ? (e.isCulled || e.onCull(), e.shouldRemoveOnCull && n.push(e)) : e.isCulled && e.onUncull();
+		}
+		for (let e of this.sensors) {
+			let t = e.x + e.width, n = e.y + e.height;
+			e.x >= s || t <= a || e.y >= c || n <= o ? (e.isCulled || e.onCull(), e.shouldRemoveOnCull && r.push(e)) : e.isCulled && e.onUncull();
+		}
+		for (let e of this.groups) {
+			let t = e.x + e.width, n = e.y + e.height;
+			e.x >= s || t <= a || e.y >= c || n <= o ? (e.isCulled || e.onCull(), e.shouldRemoveOnCull && i.push(e)) : e.isCulled && e.onUncull();
+		}
+		let l = t.length, u = n.length, d = r.length, f = i.length;
+		if (l + u + d + f !== 0) {
+			for (let e = 0; e < l; e++) this.removeActor(t[e]);
+			for (let e = 0; e < u; e++) this.removeSolid(n[e]);
+			for (let e = 0; e < d; e++) this.removeSensor(r[e]);
+			for (let e = 0; e < f; e++) this.removeGroup(i[e]);
+		}
+	}
+	updateSensor(e, t) {
+		e.preUpdate(), e.update(t), e.postUpdate();
+		let n = e.checkActorOverlaps();
+		this.sensorOverlaps.push(...n);
+	}
+	createEntity(e) {
+		if (e.type === "actor") return this.createActor(e);
+		if (e.type === "solid") return this.createSolid(e);
+		if (e.type === "sensor") return this.createSensor(e);
+		if (e.type === "group") return this.createGroup(e);
+		throw Error(`Invalid entity type: ${e.type}`);
+	}
+	addEntity(e) {
+		if (!e || !e.entityType) throw Error("Entity is required");
+		if (e.entityType === "Actor") return this.addActor(e);
+		if (e.entityType === "Solid") return this.addSolid(e);
+		if (e.entityType === "Sensor") return this.addSensor(e);
+		if (e.entityType === "Group") return this.addGroup(e);
+		throw Error(`Invalid entity type: ${e.entityType}`);
+	}
+	removeEntity(e) {
+		e.entityType === "Actor" ? this.removeActor(e) : e.entityType === "Solid" ? this.removeSolid(e) : e.entityType === "Sensor" ? this.removeSensor(e) : e.entityType === "Group" && this.removeGroup(e);
+	}
+	createActor(e) {
+		this.options.defaultCollisionLayer !== void 0 && e.collisionLayer === void 0 && (e.collisionLayer = this.options.defaultCollisionLayer), this.options.defaultCollisionMask !== void 0 && e.collisionMask === void 0 && (e.collisionMask = this.options.defaultCollisionMask);
+		let t = e.class ? new e.class(e) : new y(e);
+		return this.addActor(t);
+	}
+	addActor(e) {
+		return this.entities.add(e), this.actors.add(e), this.actorsByType.has(e.type) || this.actorsByType.set(e.type, /* @__PURE__ */ new Set()), this.actorsByType.get(e.type).add(e), this.options.enableActorCollisions && e.updateGridCells(), e;
+	}
+	createSensor(e) {
+		this.options.defaultCollisionLayer !== void 0 && e.collisionLayer === void 0 && (e.collisionLayer = this.options.defaultCollisionLayer), this.options.defaultCollisionMask !== void 0 && e.collisionMask === void 0 && (e.collisionMask = this.options.defaultCollisionMask);
+		let t = e.class ? new e.class(e) : new x(e);
+		return this.addSensor(t);
+	}
+	addSensor(e) {
+		return this.entities.add(e), this.sensors.add(e), this.sensorsByType.has(e.type) || this.sensorsByType.set(e.type, /* @__PURE__ */ new Set()), this.sensorsByType.get(e.type).add(e), e;
+	}
+	createSolid(e) {
+		this.options.defaultCollisionLayer !== void 0 && e.collisionLayer === void 0 && (e.collisionLayer = this.options.defaultCollisionLayer), this.options.defaultCollisionMask !== void 0 && e.collisionMask === void 0 && (e.collisionMask = this.options.defaultCollisionMask);
+		let t = e.class ? new e.class(e) : new S(e);
+		return this.addSolid(t);
+	}
+	addSolid(e) {
+		return this.entities.add(e), this.solids.add(e), this.solidsByType.has(e.type) || this.solidsByType.set(e.type, /* @__PURE__ */ new Set()), this.solidsByType.get(e.type).add(e), this.addSolidToGrid(e), e;
+	}
+	removeActor(e, t = !0) {
+		this.entities.delete(e), this.actors.delete(e);
+		let n = this.actorsByType.get(e.type);
+		n && (n.delete(e), n.size === 0 && this.actorsByType.delete(e.type)), e.onRemoved(), t && e.view?.removeFromParent(), this.options.enableActorCollisions && this.removeActorFromGrid(e);
+	}
+	removeSolid(e, t = !0) {
+		this.entities.delete(e), this.solids.delete(e);
+		let n = this.solidsByType.get(e.type);
+		n && (n.delete(e), n.size === 0 && this.solidsByType.delete(e.type)), this.removeSolidFromGrid(e), t && e.view?.removeFromParent(), e.onRemoved();
+	}
+	removeSensor(e, t = !0) {
+		this.entities.delete(e), this.sensors.delete(e);
+		let n = this.sensorsByType.get(e.type);
+		n && (n.delete(e), n.size === 0 && this.sensorsByType.delete(e.type)), e.onRemoved(), t && e.view?.removeFromParent();
+	}
+	moveSolid(e, t, n) {
+		this.removeSolidFromGrid(e), e.move(t, n, this.actors, this.sensors), this.addSolidToGrid(e), e.updateView();
+	}
+	getSolidsAt(e, t, n) {
+		if (n.collisionMask === 0) return [];
+		let r = {
+			x: e,
+			y: t,
+			width: n.width,
+			height: n.height
+		}, i = e - n.x, a = t - n.y, o = this.getCells(r);
+		if (i !== 0) {
+			let t = i > 0 ? Math.ceil((e + r.width) / this.options.gridSize) : Math.floor(e / this.options.gridSize) - 1;
+			for (let e = Math.floor(r.y / this.options.gridSize); e < Math.ceil((r.y + r.height) / this.options.gridSize); e++) o.push(`${t},${e}`);
+		}
+		if (a !== 0) {
+			let e = a > 0 ? Math.ceil((t + r.height) / this.options.gridSize) : Math.floor(t / this.options.gridSize) - 1;
+			for (let t = Math.floor(r.x / this.options.gridSize); t < Math.ceil((r.x + r.width) / this.options.gridSize); t++) o.push(`${t},${e}`);
+		}
+		let s = [], c = /* @__PURE__ */ new Set(), l = n.collisionLayer, u = n.collisionMask;
+		for (let e of o) {
+			let t = this.grid.get(e);
+			if (t) for (let e of t.solids) c.has(e) || (l & e.collisionMask) === 0 || (e.collisionLayer & u) === 0 || (c.add(e), this.overlaps(r, {
+				x: e.x,
+				y: e.y,
+				width: e.width,
+				height: e.height
+			}) && s.push(e));
+		}
+		return s;
+	}
+	addFollower(e, t) {
+		this.followers.has(e) || this.followers.set(e, /* @__PURE__ */ new Set()), this.followers.get(e).add(t);
+	}
+	removeFollower(e) {
+		for (let t of this.followers.values()) t.delete(e);
+	}
+	getFollowersOf(e) {
+		return Array.from(this.followers.get(e) || []);
+	}
+	removeFollowersOf(e) {
+		let t = this.followers.get(e);
+		t && (t.forEach((e) => {
+			e.destroy();
+		}), t.clear(), this.followers.delete(e));
+	}
+	addToGroup(e, t) {
+		return this.groupWithEntities.has(e) || this.groupWithEntities.set(e, /* @__PURE__ */ new Set()), this.groupWithEntities.get(e).add(t), t;
+	}
+	removeFromGroup(e) {
+		for (let t of this.groupWithEntities.values()) t.delete(e);
+		return e;
+	}
+	getEntitiesInGroup(e) {
+		return Array.from(this.groupWithEntities.get(e) || []);
+	}
+	removeEntitiesOfGroup(e) {
+		let t = Array.from(this.groupWithEntities.get(e) || []) || [];
+		return t.forEach((e) => {
+			e.setGroup(null);
+		}), this.groupWithEntities.delete(e), t;
+	}
+	overlaps(e, t) {
+		return e.x < t.x + t.width && e.x + e.width > t.x && e.y < t.y + t.height && e.y + e.height > t.y;
+	}
+	getCells(e) {
+		let t = [], { gridSize: n } = this.options, r = Math.floor(e.x / n), i = Math.floor(e.y / n), a = Math.ceil((e.x + e.width) / n), o = Math.ceil((e.y + e.height) / n);
+		t.length = (a - r) * (o - i);
+		let s = 0;
+		for (let e = r; e < a; e++) for (let n = i; n < o; n++) t[s++] = `${e},${n}`;
+		return t;
+	}
+	addSolidToGrid(e) {
+		let t = {
+			x: e.x,
+			y: e.y,
+			width: e.width,
+			height: e.height
+		}, n = this.getCells(t);
+		for (let t of n) this.grid.has(t) || this.grid.set(t, {
+			solids: /* @__PURE__ */ new Set(),
+			actors: /* @__PURE__ */ new Set()
+		}), this.grid.get(t).solids.add(e);
+	}
+	removeSolidFromGrid(e) {
+		let t = {
+			x: e.x,
+			y: e.y,
+			width: e.width,
+			height: e.height
+		}, n = this.getCells(t);
+		for (let t of n) {
+			let n = this.grid.get(t);
+			n && (n.solids.delete(e), n.solids.size === 0 && n.actors.size === 0 && this.grid.delete(t));
+		}
+	}
+	debugRender() {
+		if (!this._debugGfx) return;
+		let e = this._debugGfx;
+		if (e.clear(), this.options.boundary) {
+			let t = this.options.boundary;
+			e.rect(t.x, t.y, t.width, t.height), e.stroke({
+				color: 16711680,
+				width: 2,
+				alignment: .5
+			});
+		}
+		for (let t of this.grid.keys()) {
+			let [n, r] = t.split(",").map(Number);
+			e.rect(n * this.options.gridSize, r * this.options.gridSize, this.options.gridSize, this.options.gridSize);
+		}
+		e.stroke({
+			color: 65280,
+			width: 1,
+			join: "miter",
+			cap: "butt"
+		});
+		for (let t of this.solids) e.rect(t.x, t.y, t.width, t.height), e.stroke({
+			color: t.debugColor ?? 65280,
+			alpha: 1
+		});
+		for (let t of this.actors) e.rect(t.x, t.y, t.width, t.height), e.stroke({
+			color: t.debugColor ?? 16711680,
+			alpha: 1
+		});
+		for (let t of this.sensors) e.rect(t.x, t.y, t.width, t.height), e.stroke({
+			color: t.debugColor ?? 16776960,
+			alpha: 1
+		});
+	}
+	getByType(e) {
+		let t = this.actorsByType.get(e) || /* @__PURE__ */ new Set(), n = this.solidsByType.get(e) || /* @__PURE__ */ new Set();
+		return [...t, ...n];
+	}
+	getActorsByType(e) {
+		return Array.isArray(e) ? e.flatMap((e) => Array.from(this.actorsByType.get(e) || /* @__PURE__ */ new Set())) : Array.from(this.actorsByType.get(e) || /* @__PURE__ */ new Set());
+	}
+	getSolidsByType(e) {
+		return Array.isArray(e) ? e.flatMap((e) => Array.from(this.solidsByType.get(e) || /* @__PURE__ */ new Set())) : Array.from(this.solidsByType.get(e) || /* @__PURE__ */ new Set());
+	}
+	getSensorsByType(e) {
+		return Array.isArray(e) ? e.flatMap((e) => Array.from(this.sensorsByType.get(e) || /* @__PURE__ */ new Set())) : Array.from(this.sensorsByType.get(e) || /* @__PURE__ */ new Set());
+	}
+	clearGrid() {
+		this.grid.clear();
+	}
+	clearAll(e = !0) {
+		this.grid.clear(), this.entities.clear(), e && (this.solids.forEach((e) => {
+			e.destroy();
+		}), this.actors.forEach((e) => {
+			e.destroy();
+		}), this.sensors.forEach((e) => e.destroy())), this.solids.clear(), this.actors.clear(), this.sensors.clear(), this.solidsByType.clear(), this.actorsByType.clear(), this.sensorsByType.clear();
+	}
+	destroy() {
+		this.debug = !1, this.gravity = 0, this.maxVelocity = 0, this.clearAll();
+	}
+	getCollisionResult() {
+		if (this._collisionResultPoolIndex < this._collisionResultPool.length) {
+			let e = this._collisionResultPool[this._collisionResultPoolIndex++];
+			return e.collided = !1, e.actor = null, e.normal = void 0, e.penetration = 0, e;
+		}
+		let e = {
+			collided: !1,
+			actor: null,
+			normal: void 0,
+			penetration: 0
+		};
+		return this._collisionResultPool.push(e), this._collisionResultPoolIndex++, e;
+	}
+	getActorCollision() {
+		if (this._actorCollisionPoolIndex < this._actorCollisionPool.length) return this._actorCollisionPool[this._actorCollisionPoolIndex++];
+		let e = {
+			type: "unknown|unknown",
+			actor1: null,
+			actor2: null,
+			result: null
+		};
+		return this._actorCollisionPool.push(e), this._actorCollisionPoolIndex++, e;
+	}
+	resetCollisionPools() {
+		this._collisionResultPoolIndex = 0, this._actorCollisionPoolIndex = 0;
+	}
+	updateActorInGrid(e) {
+		if (!this.options.enableActorCollisions) return;
+		if (!e.active || e.collisionLayer === 0 || e.collisionMask === 0) {
+			e.currentGridCells.length > 0 && this.removeActorFromGrid(e);
+			return;
+		}
+		this.removeActorFromGrid(e);
+		let t = {
+			x: e.x,
+			y: e.y,
+			width: e.width,
+			height: e.height
+		}, n = this.getCells(t);
+		e.currentGridCells = n;
+		for (let t of n) this.grid.has(t) || this.grid.set(t, {
+			solids: /* @__PURE__ */ new Set(),
+			actors: /* @__PURE__ */ new Set()
+		}), this.grid.get(t).actors.add(e);
+	}
+	removeActorFromGrid(e) {
+		let t = e.currentGridCells;
+		for (let n of t) {
+			let t = this.grid.get(n);
+			t && (t.actors.delete(e), t.actors.size === 0 && t.solids.size === 0 && this.grid.delete(n));
+		}
+		e.currentGridCells = [];
+	}
+	checkActorCollisions() {
+		if (!(this.actors.size <= 1 || !this.options.enableActorCollisions)) {
+			this._checkedPairs.clear(), this._potentialCollisions.clear(), this._activeGridCells.clear();
+			for (let [e, t] of this.grid.entries()) for (let n of t.actors) if (n.active && (n.velocity.x !== 0 || n.velocity.y !== 0)) {
+				this._activeGridCells.add(e);
+				break;
+			}
+			for (let e of this._activeGridCells) {
+				let t = this.grid.get(e);
+				if (!t || t.actors.size <= 1) continue;
+				let n = Array.from(t.actors), r = n.length;
+				for (let e = 0; e < r; e++) {
+					let t = n[e];
+					if (t.active) for (let i = e + 1; i < r; i++) {
+						let e = n[i];
+						if (!e.active) continue;
+						let r = t.id < e.id ? `${t.id}|${e.id}` : `${e.id}|${t.id}`;
+						this._checkedPairs.has(r) || (this._checkedPairs.add(r), !((t.collisionLayer & e.collisionMask) === 0 && (e.collisionLayer & t.collisionMask) === 0) && t.x < e.x + e.width && t.x + t.width > e.x && t.y < e.y + e.height && t.y + t.height > e.y && this._potentialCollisions.set(r, [t, e]));
+					}
+				}
+			}
+			for (let [e, t] of this._potentialCollisions.values()) {
+				let n = e.checkActorCollision(t);
+				if (n.collided) {
+					e.actorCollisions.push(n);
+					let r = this.getCollisionResult();
+					r.collided = !0, r.actor = e, n.normal ? (r.normal ||= {
+						x: 0,
+						y: 0
+					}, r.normal.x = -n.normal.x, r.normal.y = -n.normal.y) : r.normal = void 0, r.penetration = n.penetration, t.actorCollisions.push(r);
+					let i = this.getActorCollision();
+					i.type = `${e.type}|${t.type}`, i.actor1 = e, i.actor2 = t, i.result = n, this.actorCollisions[this._actorCollisionPoolIndex++] = i, e.onActorCollide(n), t.onActorCollide(r), e.resolveActorCollision(n), t.resolveActorCollision(r);
+				}
+			}
+			this._actorCollisionPoolIndex > 0 && this.options.actorCollisionResolver && this.options.actorCollisionResolver(this.actorCollisions.slice(0, this._actorCollisionPoolIndex));
+		}
+	}
+	setCollisionResolver(e) {
+		this.options.collisionResolver = e;
+	}
+	setActorCollisionResolver(e) {
+		this.options.actorCollisionResolver = e;
+	}
+	get enableActorCollisions() {
+		return !!this.options.enableActorCollisions;
+	}
+	setActorCollisionsEnabled(e) {
+		let t = this.options.enableActorCollisions;
+		if (this.options.enableActorCollisions = e, e && !t) for (let e of this.actors) e.updateGridCells();
+		else if (!e && t) {
+			this.grid.clear();
+			for (let e of this.actors) e.currentGridCells = [];
+		}
+	}
+	createGroup(e) {
+		this.options.defaultCollisionLayer !== void 0 && e.collisionLayer === void 0 && (e.collisionLayer = this.options.defaultCollisionLayer), this.options.defaultCollisionMask !== void 0 && e.collisionMask === void 0 && (e.collisionMask = this.options.defaultCollisionMask);
+		let t = e.class ? new e.class(e) : new b(e);
+		return this.addGroup(t);
+	}
+	addGroup(e) {
+		return this.entities.add(e), this.groups.add(e), this.groupsByType.has(e.type) || this.groupsByType.set(e.type, /* @__PURE__ */ new Set()), this.groupsByType.get(e.type).add(e), e;
+	}
+	removeGroup(e, t = !0) {
+		if (!this.groups.has(e)) return;
+		this.entities.delete(e), this.groups.delete(e);
+		let n = this.groupsByType.get(e.type);
+		n && (n.delete(e), n.size === 0 && this.groupsByType.delete(e.type));
+		let r = this.groupWithEntities.get(e);
+		if (r && r.size > 0) {
+			let e = [], n = [], i = [];
+			for (let t of r) t.entityType === "Actor" ? e.push(t) : t.entityType === "Solid" ? n.push(t) : t.entityType === "Sensor" && i.push(t);
+			for (let n of e) this.removeActor(n, t);
+			for (let e of n) this.removeSolid(e, t);
+			for (let e of i) this.removeSensor(e, t);
+		}
+		this.groupWithEntities.delete(e), e.onRemoved();
+	}
+	getGroupsByType(e) {
+		if (Array.isArray(e)) {
+			let t = 0;
+			for (let n of e) {
+				let e = this.groupsByType.get(n);
+				e && (t += e.size);
+			}
+			let n = Array(t), r = 0;
+			for (let t of e) {
+				let e = this.groupsByType.get(t);
+				if (e) for (let t of e) n[r++] = t;
+			}
+			return n;
+		}
+		return Array.from(this.groupsByType.get(e) || /* @__PURE__ */ new Set());
+	}
+	aabbOverlap(e, t) {
+		return e.x < t.x + t.width && e.x + e.width > t.x && e.y < t.y + t.height && e.y + e.height > t.y;
+	}
+}, w = {
+	gridSize: 128,
+	gravity: 900,
+	maxVelocity: 400,
+	debug: !1,
+	culling: !0,
+	boundary: new f(0, 0, 800, 600)
+}, T = class extends n {
+	constructor() {
+		super("crunch"), this.enabled = !1;
+	}
+	hello() {
+		let e = `%c Caper Crunch Physics Plugin v${l}`;
+		console.log(e, "background: rgba(31, 41, 55, 1);color: #74b64c");
+	}
+	async initialize(e, n) {
+		if (this.hello(), !e) return;
+		this._options = {
+			...w,
+			...e
+		}, this.enabled = !0, this.container = e.container || this.app.stage, a && t.log(this._options);
+		let r = e.gridSize ?? 32, i = e.gravity ?? 900, o = e.maxVelocity ?? 400, s = e.debug ?? !1, c = e.enableActorCollisions ?? !1;
+		this.system = new C({
+			gridSize: r,
+			gravity: i,
+			maxVelocity: o,
+			boundary: e.boundary,
+			culling: e.culling,
+			plugin: this,
+			collisionResolver: this.collisionResolver,
+			overlapResolver: this.overlapResolver,
+			actorCollisionResolver: this.actorCollisionResolver,
+			enableActorCollisions: c,
+			defaultCollisionLayer: p.NONE,
+			defaultCollisionMask: p.NONE
+		}), s && (this.system.debug = !0), this.app.ticker.add(this.update);
+	}
+	setCollisionResolver(e) {
+		this.collisionResolver = e, this.system.setCollisionResolver(e);
+	}
+	setActorCollisionResolver(e) {
+		this.actorCollisionResolver = e, this.system.setActorCollisionResolver(e);
+	}
+	setActorCollisionsEnabled(e) {
+		this.system.setActorCollisionsEnabled(e);
+	}
+	createEntity(e) {
+		return this.system.createEntity(e);
+	}
+	addEntity(e) {
+		return this.system.addEntity(e);
+	}
+	createActor(e) {
+		return this.system.createActor(e);
+	}
+	createSolid(e) {
+		return this.system.createSolid(e);
+	}
+	createSensor(e) {
+		return this.system.createSensor(e);
+	}
+	createGroup(e) {
+		return this.system.createGroup(e);
+	}
+	addActor(e) {
+		return this.system.addActor(e);
+	}
+	addSolid(e) {
+		return this.system.addSolid(e);
+	}
+	addSensor(e) {
+		return this.system.addSensor(e);
+	}
+	addGroup(e) {
+		return this.system.addGroup(e);
+	}
+	removeActor(e) {
+		this.system.removeActor(e);
+	}
+	removeSolid(e) {
+		this.system.removeSolid(e);
+	}
+	removeSensor(e) {
+		this.system.removeSensor(e);
+	}
+	removeGroup(e) {
+		this.system.removeGroup(e);
+	}
+	destroy() {
+		this.enabled = !1, this.app.ticker.remove(this.update), this.system &&= (this.system.destroy(), null), super.destroy();
+	}
+	update(e) {
+		this.enabled && this.system.update(e.deltaTime);
+	}
+	createCollisionLayer(e) {
+		return h.createLayer(e);
+	}
+	createCollisionMask(...e) {
+		return h.createMask(e);
+	}
+	registerCollisionLayer(e, t, n) {
+		let r = h.getRegistry();
+		if (typeof t == "number") {
+			let i = t;
+			return r.register(e, i, n).value;
+		} else {
+			let n = t, i = r.getNextAvailableIndex();
+			if (i === -1) throw Error("No more collision layer indices available (maximum 16)");
+			return r.register(e, i, n).value;
+		}
+	}
+	getCollisionLayer(e) {
+		return h.getRegistry().get(e)?.value;
+	}
+	getCollisionLayers() {
+		return h.getRegistry().getAll();
+	}
+	removeCollisionLayer(e) {
+		return h.getRegistry().remove(e);
+	}
+	clearCollisionLayers() {
+		h.getRegistry().clear();
+	}
+	aabbOverlap(e, t) {
+		return this.system.aabbOverlap(e, t);
+	}
+};
+//#endregion
+export { y as Actor, p as CollisionLayer, m as CollisionLayerRegistry, h as CollisionLayers, v as Entity, b as Group, x as Sensor, S as Solid, C as System, T as default };
+
+//# sourceMappingURL=caper-plugin-crunch.mjs.map