@antha/entity-2d 0.4.3 → 0.6.0

package/dist/entity-suite.d.ts

@@ -1,12 +1,14 @@
 import { type AnyObject, type Constructor, type IsAny } from '@augment-vir/common';
 import { type Shape } from 'object-shape-tester';
-import { BaseEntity2d, type BaseEntityAssetDefinitions, type Entity2dConstructorParams, EntityStore2d, type EntityStore2dConstructorParams, type MappedEntityAssets, type ParamsMap, type ReverseParamsMap, ViewEntity2d } from './entity.js';
+import { BaseEntity2d, type BaseEntityAssetDefinitions, type Entity2dConstructor, type Entity2dConstructorParams, type EntityCollisionDefinition, EntityStore2d, type EntityStore2dConstructorParams, type MappedEntityAssets, type ParamsMap, type ReverseParamsMap, ViewEntity2d } from './entity.js';
 /**
  * Params for both {@link EntitySuite2d.defineEntity} and {@link EntitySuite2d.defineLogicEntity}.
  *
  * @category Internal
  */
 export type DefineEntity2dArgs<ParamsShape extends Shape<AnyObject> | undefined, EntityAssets extends BaseEntityAssetDefinitions | undefined> = {
+    /** Entity classes this entity observes collisions with. Omit to observe none. */
+    collidesWith?: EntityCollisionDefinition | undefined;
     /**
      * This key is used for deserialization of entities to track which class needs to be
      * constructed. Do not use duplicate key strings across multiple entity classes.
@@ -96,6 +98,10 @@ export type DefineEntity2dArgs<ParamsShape extends Shape<AnyObject> | undefined,
  * @category Internal
  */
 export type StaticEntity2dParts<State extends AnyObject = any, ParamsShape extends Shape<AnyObject> | undefined = any, EntityAssets extends BaseEntityAssetDefinitions | undefined = any> = {
+    /** Entity classes this entity observes collisions with. Omit to observe none. */
+    collidesWith: EntityCollisionDefinition | undefined;
+    /** Cached entity classes this entity observes collisions with. */
+    collidesWithSet: ReadonlySet<Entity2dConstructor>;
     /**
      * This key is used for deserialization of entities to track which class needs to be
      * constructed. You cannot have duplicate keys loaded at the same time.

package/dist/entity-suite.js

@@ -13,7 +13,7 @@ export function defineEntitySuite2d() {
         return (params) => {
             if (params.assets) {
                 getObjectTypedEntries(params.assets).forEach(([key, rawAsset,]) => {
-                    rawAsset.name = [
+                    rawAsset.assetName = [
                         params.key,
                         key,
                     ].join(':');
@@ -22,7 +22,7 @@ export function defineEntitySuite2d() {
             return defineEntity(entityParent, params);
         };
     }
-    function defineEntity(entityParent, { key, paramsShape, paramsMap, assets }) {
+    function defineEntity(entityParent, { collidesWith, key, paramsShape, paramsMap, assets }) {
         if (entityKeys.has(key)) {
             throw new Error(`Entity key '${key}' has already been attached to an entity class.`);
         }
@@ -30,9 +30,11 @@ export function defineEntitySuite2d() {
         const classWrapper = {
             // @ts-expect-error: abstract methods are intentionally not implemented here
             [key]: class extends entityParent {
+                static collidesWith = collidesWith;
+                static collidesWithSet = new Set(collidesWith?.collidesWithOtherEntities);
                 static entityKey = key;
                 static paramsShape = paramsShape;
-                static assets = assets;
+                static assets = assets || {};
                 static paramsMap = paramsMap;
                 static reverseParamsMap = reverseParamsMap(paramsMap);
             },

package/dist/entity.d.ts

@@ -13,8 +13,8 @@ export { System as HitboxSystem, type Response as Collision } from 'detect-colli
  * @category Internal
  */
 export type BaseEntityAssetDefinitions = Record<string, Omit<Asset, 
-/** Name will be the value's key in this object. */
-'name'>>;
+/** Asset names are derived from the entity and asset keys. */
+'assetName'>>;
 /**
  * A record of `Asset` entries.
  *
@@ -28,7 +28,7 @@ export type BaseEntityAssets = Record<string, Asset>;
  */
 export type MappedEntityAssets<Definitions extends BaseEntityAssetDefinitions | undefined> = Definitions extends undefined ? EmptyObject : {
     [Key in keyof Definitions]: Definitions[Key] & {
-        name: string;
+        assetName: string;
     };
 };
 /**
@@ -72,7 +72,31 @@ export type EntityStore2dConstructorParams<State extends AnyObject = any> = {
  *
  * @category Internal
  */
-export type Entity2dConstructor = Constructor<BaseEntity2d> & StaticEntity2dParts;
+export type Entity2dConstructor = Constructor<BaseEntity2d> & StaticEntity2dParts<any, any, BaseEntityAssetDefinitions>;
+/**
+ * Defines which entity classes this entity observes collisions with.
+ *
+ * @category Internal
+ */
+export type EntityCollisionDefinition = PartialWithUndefined<{
+    /** Whether this entity observes collisions with instances of its own class. */
+    collidesWithSelf: boolean;
+    /** Other entity classes this entity observes collisions with. */
+    collidesWithOtherEntities: ReadonlyArray<Entity2dConstructor>;
+}>;
+/** Loads assets declared by the given entity classes. */
+export declare function loadEntityAssets({ assetLoader, entities, otherAssets, }: Readonly<{
+    assetLoader: AssetLoader;
+    entities: ReadonlyArray<Entity2dConstructor>;
+    otherAssets?: ReadonlyArray<Readonly<Asset>> | undefined;
+}>, options?: Readonly<AssetBulkLoaderLoadOptions> | undefined): Promise<readonly unknown[]>;
+/** A collision system that skips pairs no entity observes before running SAT collision checks. */
+export declare class EntityHitboxSystem extends HitboxSystem {
+    protected checkedHitboxPairs: WeakMap<Hitbox, WeakSet<Hitbox>> | undefined;
+    checkAll(...[callback, response,]: Parameters<HitboxSystem['checkAll']>): any;
+    checkOne(...[hitbox, callback, response,]: Parameters<HitboxSystem['checkOne']>): boolean;
+    checkCollision(...hitboxes: Parameters<HitboxSystem['checkCollision']>): boolean;
+}
 /**
  * The top level storage class of all entities. Add entities with {@link EntityStore2d.addEntity}.
  *
@@ -102,14 +126,6 @@ export declare class EntityStore2d<State extends AnyObject = any> {
     readonly state: State;
     readonly assetLoader: AssetLoader;
     constructor(args: Readonly<EntityStore2dConstructorParams>);
-    /**
-     * Load all the assets for all the given entities. Without this, assets will be loaded on demand
-     * only.
-     */
-    loadEntityAssets({ entities, otherAssets, }: Readonly<{
-        entities: ReadonlyArray<Entity2dConstructor>;
-        otherAssets?: ReadonlyArray<Readonly<Asset>> | undefined;
-    }>, options?: Readonly<AssetBulkLoaderLoadOptions> | undefined): Promise<readonly unknown[]>;
     /**
      * Register a set of entities so that they can be deserialized (for example, when transferring
      * game state in across the network for multilayer).
@@ -299,6 +315,10 @@ export declare abstract class BaseEntity2d<State extends AnyObject = any, Params
      * constructed. You cannot have duplicate keys loaded at the same time.
      */
     static readonly entityKey: string;
+    /** Entity classes this entity observes collisions with. Omit to observe none. */
+    static readonly collidesWith: EntityCollisionDefinition | undefined;
+    /** Cached entity classes this entity observes collisions with. */
+    static readonly collidesWithSet: ReadonlySet<Entity2dConstructor>;
     /** Shape definition of this entity's parameters. */
     static readonly paramsShape: Shape<AnyObject> | undefined;
     static readonly assets: MappedEntityAssets<BaseEntityAssetDefinitions | undefined> | undefined;
@@ -321,6 +341,8 @@ export declare abstract class BaseEntity2d<State extends AnyObject = any, Params
     dispatch(event: EntityEvent | EntityDestroyEvent): void;
     /** If true, this entity should no longer be used or operated upon. */
     readonly isDestroyed: boolean;
+    /** Static definition used to construct this entity. */
+    readonly entityDefinition: Entity2dConstructor;
     protected readonly abortController: AbortController;
     /** An `AbortSignal` that triggers when the entity is destroyed. */
     readonly abortSignal: AbortSignal;

package/dist/entity.js

@@ -1,10 +1,129 @@
 import { assert, check } from '@augment-vir/assert';
-import { ConstructorInstanceMap, getObjectTypedEntries, makeWritable, mapObjectValues, } from '@augment-vir/common';
-import { System as HitboxSystem, } from 'detect-collisions';
+import { ConstructorInstanceMap, getObjectTypedEntries, getObjectTypedValues, makeWritable, mapObjectValues, } from '@augment-vir/common';
+import { System as HitboxSystem, Response, } from 'detect-collisions';
 import { assertValidShape, defineShape } from 'object-shape-tester';
 import { ParticleContainer } from 'pixi.js';
 import { defineTypedCustomEvent, GenericListenTarget } from 'typed-event-target';
 export { System as HitboxSystem } from 'detect-collisions';
+/** Loads assets declared by the given entity classes. */
+export async function loadEntityAssets({ assetLoader, entities, otherAssets, }, options) {
+    const assets = [
+        ...(otherAssets || []),
+        ...entities.flatMap((entity) => {
+            return getObjectTypedValues(entity.assets);
+        }),
+    ];
+    return await assetLoader.bulkLoadAssets(assets, options);
+}
+function extractEntityFromHitbox(hitbox) {
+    return hitbox.userData instanceof BaseEntity2d ? hitbox.userData : undefined;
+}
+function hasCollisionTargets(entity) {
+    return (!!entity.entityDefinition.collidesWith?.collidesWithSelf ||
+        entity.entityDefinition.collidesWithSet.size > 0);
+}
+function doesEntityCollideWith({ entity, otherEntity, }) {
+    return ((entity.entityDefinition.collidesWith?.collidesWithSelf &&
+        entity.entityDefinition === otherEntity.entityDefinition) ||
+        entity.entityDefinition.collidesWithSet.has(otherEntity.entityDefinition));
+}
+function shouldCheckEntityCollision({ firstEntity, secondEntity, }) {
+    return (doesEntityCollideWith({
+        entity: firstEntity,
+        otherEntity: secondEntity,
+    }) ||
+        doesEntityCollideWith({
+            entity: secondEntity,
+            otherEntity: firstEntity,
+        }));
+}
+function shouldNotifyEntityOfCollision({ entity, otherEntity, }) {
+    return doesEntityCollideWith({
+        entity,
+        otherEntity,
+    });
+}
+function createReversedCollision(collision) {
+    const reversedCollision = new Response();
+    reversedCollision.a = collision.b;
+    reversedCollision.aInB = collision.bInA;
+    reversedCollision.b = collision.a;
+    reversedCollision.bInA = collision.aInB;
+    reversedCollision.overlap = collision.overlap;
+    reversedCollision.overlapN.x = -collision.overlapN.x;
+    reversedCollision.overlapN.y = -collision.overlapN.y;
+    reversedCollision.overlapV.x = -collision.overlapV.x;
+    reversedCollision.overlapV.y = -collision.overlapV.y;
+    return reversedCollision;
+}
+function hasAlreadyCheckedHitboxPair({ checkedHitboxPairs, firstHitbox, secondHitbox, }) {
+    return (checkedHitboxPairs.get(firstHitbox)?.has(secondHitbox) ||
+        checkedHitboxPairs.get(secondHitbox)?.has(firstHitbox));
+}
+function markHitboxPairAsChecked({ checkedHitboxPairs, firstHitbox, secondHitbox, }) {
+    const firstHitboxPairs = checkedHitboxPairs.get(firstHitbox);
+    if (firstHitboxPairs) {
+        firstHitboxPairs.add(secondHitbox);
+    }
+    else {
+        checkedHitboxPairs.set(firstHitbox, new WeakSet([secondHitbox]));
+    }
+}
+/** A collision system that skips pairs no entity observes before running SAT collision checks. */
+export class EntityHitboxSystem extends HitboxSystem {
+    checkedHitboxPairs;
+    checkAll(...[callback, response,]) {
+        const previousCheckedHitboxPairs = this.checkedHitboxPairs;
+        this.checkedHitboxPairs = new WeakMap();
+        try {
+            return this.all().some((hitbox) => {
+                const entity = extractEntityFromHitbox(hitbox);
+                return ((!entity || hasCollisionTargets(entity)) &&
+                    this.checkOne(hitbox, callback, response));
+            });
+        }
+        finally {
+            this.checkedHitboxPairs = previousCheckedHitboxPairs;
+        }
+    }
+    checkOne(...[hitbox, callback, response,]) {
+        const entity = extractEntityFromHitbox(hitbox);
+        if (entity && !hasCollisionTargets(entity)) {
+            return false;
+        }
+        return super.checkOne(hitbox, callback, response);
+    }
+    checkCollision(...hitboxes) {
+        const [firstHitbox, secondHitbox,] = hitboxes;
+        const checkedHitboxPairs = this.checkedHitboxPairs;
+        if (checkedHitboxPairs &&
+            hasAlreadyCheckedHitboxPair({
+                checkedHitboxPairs,
+                firstHitbox,
+                secondHitbox,
+            })) {
+            return false;
+        }
+        if (checkedHitboxPairs) {
+            markHitboxPairAsChecked({
+                checkedHitboxPairs,
+                firstHitbox,
+                secondHitbox,
+            });
+        }
+        const firstEntity = extractEntityFromHitbox(firstHitbox);
+        const secondEntity = extractEntityFromHitbox(secondHitbox);
+        if (firstEntity &&
+            secondEntity &&
+            !shouldCheckEntityCollision({
+                firstEntity,
+                secondEntity,
+            })) {
+            return false;
+        }
+        return super.checkCollision(...hitboxes);
+    }
+}
 /**
  * The top level storage class of all entities. Add entities with {@link EntityStore2d.addEntity}.
  *
@@ -36,7 +155,7 @@ export class EntityStore2d {
     constructor(args) {
         this.pixi = args.pixi;
         this.assetLoader = args.assetLoader;
-        this.hitboxSystem = args.customHitboxSystem || new HitboxSystem();
+        this.hitboxSystem = args.customHitboxSystem || new EntityHitboxSystem();
         this.state = args.state;
         if (args.preregisteredEntities) {
             this.registerEntities({
@@ -45,21 +164,6 @@ export class EntityStore2d {
             });
         }
     }
-    /**
-     * Load all the assets for all the given entities. Without this, assets will be loaded on demand
-     * only.
-     */
-    async loadEntityAssets({ entities, otherAssets, }, options) {
-        const assets = [
-            ...(otherAssets || []),
-            ...entities.flatMap((entity) => {
-                return Object.values(entity.assets).map((asset) => {
-                    return asset;
-                });
-            }),
-        ];
-        return await this.assetLoader.bulkLoadAssets(assets, options);
-    }
     /**
      * Register a set of entities so that they can be deserialized (for example, when transferring
      * game state in across the network for multilayer).
@@ -111,9 +215,22 @@ export class EntityStore2d {
                 secondaryEntity.isDestroyed) {
                 return;
             }
-            const result = primaryEntity.collide(secondaryEntity, response);
-            if (result instanceof Promise) {
-                collisionPromises.push(result);
+            function trackCollisionResult(result) {
+                if (result instanceof Promise) {
+                    collisionPromises.push(result);
+                }
+            }
+            if (shouldNotifyEntityOfCollision({
+                entity: primaryEntity,
+                otherEntity: secondaryEntity,
+            })) {
+                trackCollisionResult(primaryEntity.collide(secondaryEntity, response));
+            }
+            if (shouldNotifyEntityOfCollision({
+                entity: secondaryEntity,
+                otherEntity: primaryEntity,
+            })) {
+                trackCollisionResult(secondaryEntity.collide(primaryEntity, createReversedCollision(response)));
             }
         });
         await Promise.all(collisionPromises);
@@ -254,6 +371,10 @@ export class BaseEntity2d {
      * constructed. You cannot have duplicate keys loaded at the same time.
      */
     static entityKey = 'BaseEntity';
+    /** Entity classes this entity observes collisions with. Omit to observe none. */
+    static collidesWith;
+    /** Cached entity classes this entity observes collisions with. */
+    static collidesWithSet = new Set();
     /** Shape definition of this entity's parameters. */
     static paramsShape;
     static assets;
@@ -288,6 +409,8 @@ export class BaseEntity2d {
     }
     /** If true, this entity should no longer be used or operated upon. */
     isDestroyed = false;
+    /** Static definition used to construct this entity. */
+    entityDefinition;
     abortController = new AbortController();
     /** An `AbortSignal` that triggers when the entity is destroyed. */
     abortSignal = this.abortController.signal;
@@ -302,6 +425,7 @@ export class BaseEntity2d {
     hitboxSystem;
     getAsset;
     constructor(args) {
+        this.entityDefinition = this.constructor;
         this.entityStore = args.entityStore;
         this.params = args.params;
         this.pixi = args.pixi;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/entity-2d",
-    "version": "0.4.3",
+    "version": "0.6.0",
     "description": "An Antha mod for handling 2D entities.",
     "keywords": [
         "vir",
@@ -39,8 +39,8 @@
         "@augment-vir/common": "^32.2.3"
     },
     "devDependencies": {
-        "@antha/engine": "^0.4.3",
-        "@antha/web-test-runner-plugin-pixi": "^0.4.3",
+        "@antha/engine": "^0.6.0",
+        "@antha/web-test-runner-plugin-pixi": "^0.6.0",
         "@augment-vir/test": "^32.2.3",
         "@web/dev-server-esbuild": "^2.0.0",
         "@web/test-runner": "^1.0.0",
@@ -52,9 +52,9 @@
         "typed-event-target": "^4.3.3"
     },
     "peerDependencies": {
-        "@antha/asset": "^0.4.3",
-        "@antha/engine": "^0.4.3",
-        "@antha/graphics-2d": "^0.4.3",
+        "@antha/asset": "^0.6.0",
+        "@antha/engine": "^0.6.0",
+        "@antha/graphics-2d": "^0.6.0",
         "detect-collisions": ">=10",
         "element-vir": ">=26",
         "object-shape-tester": ">=6",