bard-legends-framework 0.9.5 → 0.9.7

package/dist/physics/physics-world.js

@@ -1,144 +1,153 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+var __decorate =
+  (this && this.__decorate) ||
+  ((decorators, target, key, desc) => {
+    var c = arguments.length,
+      r = c < 3 ? target : desc === null ? (desc = Object.getOwnPropertyDescriptor(target, key)) : desc,
+      d;
+    if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
+      r = Reflect.decorate(decorators, target, key, desc);
+    else
+      for (var i = decorators.length - 1; i >= 0; i--)
+        if ((d = decorators[i])) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  });
+var __metadata =
+  (this && this.__metadata) ||
+  ((k, v) => {
+    if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') return Reflect.metadata(k, v);
+  });
+var __importDefault = (this && this.__importDefault) || (mod => (mod && mod.__esModule ? mod : { default: mod }));
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsWorld = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const actions_lib_1 = require("actions-lib");
-const p2_1 = __importDefault(require("p2"));
-const physics_materials_1 = require("./sub-elements/elements/physics-materials");
-const physics_collision_1 = require("./sub-elements/collisions/physics-collision");
-const interfaces_1 = require("./interfaces");
-const game_entities_1 = require("../game-entities");
-const physics_availability_grid_1 = require("./sub-elements/available-spaces/physics-availability-grid");
-const physics_available_spaces_1 = require("./sub-elements/available-spaces/physics-available-spaces");
-const physics_body_groups_1 = require("./sub-elements/elements/physics-body-groups");
-const physics_explosion_1 = require("./sub-elements/raycasting/physics-explosion");
-const immovable_physics_entity_1 = require("./entitity-types/immovable-physics-entity");
+const helpers_lib_1 = require('helpers-lib');
+const actions_lib_1 = require('actions-lib');
+const p2_1 = __importDefault(require('p2'));
+const physics_materials_1 = require('./sub-elements/elements/physics-materials');
+const physics_collision_1 = require('./sub-elements/collisions/physics-collision');
+const interfaces_1 = require('./interfaces');
+const game_entities_1 = require('../game-entities');
+const physics_availability_grid_1 = require('./sub-elements/available-spaces/physics-availability-grid');
+const physics_available_spaces_1 = require('./sub-elements/available-spaces/physics-available-spaces');
+const physics_body_groups_1 = require('./sub-elements/elements/physics-body-groups');
+const physics_explosion_1 = require('./sub-elements/raycasting/physics-explosion');
+const immovable_physics_entity_1 = require('./entitity-types/immovable-physics-entity');
 let PhysicsWorld = class PhysicsWorld extends game_entities_1.Entity {
-    constructor(mapSize, borderProperties, materialDefinitions, materialContactDefinitions, modifyUpdateCycle = true) {
-        super();
-        this.onPhysicsStep = new actions_lib_1.Action();
-        this.lastP2Time = 0;
-        this.mapSize = mapSize;
-        this.mapSizeCenter = this.mapSize.multiply(0.5);
-        this.modifyUpdateCycle = modifyUpdateCycle;
-        this.p2World = new p2_1.default.World({ gravity: [0, 0] });
-        this.physicsMaterials = new physics_materials_1.PhysicsMaterials(this.p2World, borderProperties, materialDefinitions, materialContactDefinitions);
-        this.physicsCollision = new physics_collision_1.PhysicsCollision(this.p2World);
-        this.physicsAvailabilityGrid = new physics_availability_grid_1.PhysicsAvailabilityGrid(this.p2World, mapSize);
-        this.physicsAvailableSpaces = new physics_available_spaces_1.PhysicsAvailableSpaces(this.physicsAvailabilityGrid);
-        this.createBorders(this, mapSize);
-        if (modifyUpdateCycle) {
-            game_entities_1.UpdateCycle.registerUpdateModifier((time, delta) => this.step(time, delta));
-        }
-        else {
-            game_entities_1.UpdateCycle.beforeSceneUpdateAction
-                .subscribe(({ time, delta }) => {
-                this.step(time, delta);
-            })
-                .attach(this);
-        }
+  constructor(mapSize, borderProperties, materialDefinitions, materialContactDefinitions, modifyUpdateCycle = true) {
+    super();
+    this.onPhysicsStep = new actions_lib_1.Action();
+    this.lastP2Time = 0;
+    this.mapSize = mapSize;
+    this.mapSizeCenter = this.mapSize.multiply(0.5);
+    this.modifyUpdateCycle = modifyUpdateCycle;
+    this.p2World = new p2_1.default.World({ gravity: [0, 0] });
+    this.physicsMaterials = new physics_materials_1.PhysicsMaterials(
+      this.p2World,
+      borderProperties,
+      materialDefinitions,
+      materialContactDefinitions
+    );
+    this.physicsCollision = new physics_collision_1.PhysicsCollision(this.p2World);
+    this.physicsAvailabilityGrid = new physics_availability_grid_1.PhysicsAvailabilityGrid(this.p2World, mapSize);
+    this.physicsAvailableSpaces = new physics_available_spaces_1.PhysicsAvailableSpaces(this.physicsAvailabilityGrid);
+    this.createBorders(this, mapSize);
+    if (modifyUpdateCycle) {
+      game_entities_1.UpdateCycle.registerUpdateModifier((time, delta) => this.step(time, delta));
+    } else {
+      game_entities_1.UpdateCycle.beforeSceneUpdateAction
+        .subscribe(({ time, delta }) => {
+          this.step(time, delta);
+        })
+        .attach(this);
     }
-    step(previousTime, delta) {
-        this.physicsAvailabilityGrid.clear();
-        this.physicsAvailableSpaces.clear();
-        this.p2World.step(1, delta, 100);
-        if (this.modifyUpdateCycle) {
-            delta = this.p2World.time - this.lastP2Time;
-        }
-        let time = previousTime + delta;
-        this.physicsCollision.update(time, delta);
-        this.onPhysicsStep.trigger({ time, delta });
-        this.lastP2Time = this.p2World.time;
-        return delta;
+  }
+  step(previousTime, delta) {
+    this.physicsAvailabilityGrid.clear();
+    this.physicsAvailableSpaces.clear();
+    this.p2World.step(1, delta, 100);
+    if (this.modifyUpdateCycle) {
+      delta = this.p2World.time - this.lastP2Time;
     }
-    destroy() {
-        this.p2World.clear();
-        if (this.modifyUpdateCycle) {
-            game_entities_1.UpdateCycle.cleanUpdateModifier();
-        }
+    const time = previousTime + delta;
+    this.physicsCollision.update(time, delta);
+    this.onPhysicsStep.trigger({ time, delta });
+    this.lastP2Time = this.p2World.time;
+    return delta;
+  }
+  destroy() {
+    this.p2World.clear();
+    if (this.modifyUpdateCycle) {
+      game_entities_1.UpdateCycle.cleanUpdateModifier();
     }
-    addBody(body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
-        if (addInEmptySpace) {
-            let changeVector = this.physicsAvailableSpaces.findClosestAvailableSpace(body, physicsBodyGroup);
-            if (changeVector) {
-                body.position[0] += changeVector.x;
-                body.position[1] += changeVector.y;
-                this.p2World.addBody(body);
-                if (includeOnPathfinding) {
-                    this.physicsAvailabilityGrid.onBodyAdded(body, physicsBodyGroup);
-                }
-                return true;
-            }
-            else {
-                return false;
-            }
-        }
-        else {
-            this.p2World.addBody(body);
-            return true;
+  }
+  addBody(body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
+    if (addInEmptySpace) {
+      const changeVector = this.physicsAvailableSpaces.findClosestAvailableSpace(body, physicsBodyGroup);
+      if (changeVector) {
+        body.position[0] += changeVector.x;
+        body.position[1] += changeVector.y;
+        this.p2World.addBody(body);
+        if (includeOnPathfinding) {
+          this.physicsAvailabilityGrid.onBodyAdded(body, physicsBodyGroup);
         }
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      this.p2World.addBody(body);
+      return true;
     }
-    removeBody(body) {
-        this.p2World.removeBody(body);
-    }
-    isCollidingWithAnything(p2Body) {
-        return this.physicsCollision.isCollidingWithAnything(p2Body);
-    }
-    getAvailabilityGrid(physicsBodyGroup) {
-        return this.physicsAvailableSpaces.getAvailabilityGrid(physicsBodyGroup);
-    }
-    findPath(startingPosition, target, options) {
-        return this.physicsAvailableSpaces.findPathAStar(startingPosition, target, options);
-    }
-    findPathDirection(startingPosition, target, collidableWithGroup) {
-        return this.physicsAvailableSpaces.findPathDirection(startingPosition, target, collidableWithGroup);
-    }
-    createExplosion(position, radius, physicsBodyGroup, severity, options) {
-        return physics_explosion_1.PhysicsExplosion.createExplosion(position, radius, physicsBodyGroup, severity, this, options);
-    }
-    createBorders(physicsWorld, mapSize) {
-        let BorderEntity = class BorderEntity extends immovable_physics_entity_1.ImmovablePhysicsEntity {
-            constructor(physicsEntityDefinition) {
-                super(physicsWorld, physicsEntityDefinition);
-            }
-        };
-        BorderEntity = __decorate([
-            (0, game_entities_1.EntityDecorator)(),
-            __metadata("design:paramtypes", [Object])
-        ], BorderEntity);
-        let createBorder = (position, size) => new BorderEntity({
-            shapeDefinition: {
-                materialName: interfaces_1.BorderMaterialName,
-                group: physics_body_groups_1.PhysicsBodyGroup.border,
-                shapeType: interfaces_1.PhysicsShapeType.rectangle,
-                shapeData: { size }
-            },
-            position,
-            rotation: 0,
-            addInEmptySpace: false,
-            includeOnPathfinding: true
-        }).attach(physicsWorld);
-        createBorder(new helpers_lib_1.Vector(mapSize.x / 2, -50), new helpers_lib_1.Vector(mapSize.x + 200, 100)); // Top border
-        createBorder(new helpers_lib_1.Vector(mapSize.x / 2, mapSize.y + 50), new helpers_lib_1.Vector(mapSize.x + 200, 100)); // Bottom border
-        createBorder(new helpers_lib_1.Vector(-50, mapSize.y / 2), new helpers_lib_1.Vector(100, mapSize.y + 200)); // Left border
-        createBorder(new helpers_lib_1.Vector(mapSize.x + 50, mapSize.y / 2), new helpers_lib_1.Vector(100, mapSize.y + 200)); // Right border
-    }
+  }
+  removeBody(body) {
+    this.p2World.removeBody(body);
+  }
+  isCollidingWithAnything(p2Body) {
+    return this.physicsCollision.isCollidingWithAnything(p2Body);
+  }
+  getAvailabilityGrid(physicsBodyGroup) {
+    return this.physicsAvailableSpaces.getAvailabilityGrid(physicsBodyGroup);
+  }
+  findPath(startingPosition, target, options) {
+    return this.physicsAvailableSpaces.findPathAStar(startingPosition, target, options);
+  }
+  findPathDirection(startingPosition, target, collidableWithGroup) {
+    return this.physicsAvailableSpaces.findPathDirection(startingPosition, target, collidableWithGroup);
+  }
+  createExplosion(position, radius, physicsBodyGroup, severity, options) {
+    return physics_explosion_1.PhysicsExplosion.createExplosion(position, radius, physicsBodyGroup, severity, this, options);
+  }
+  createBorders(physicsWorld, mapSize) {
+    let BorderEntity = class BorderEntity extends immovable_physics_entity_1.ImmovablePhysicsEntity {
+      constructor(physicsEntityDefinition) {
+        super(physicsWorld, physicsEntityDefinition);
+      }
+    };
+    BorderEntity = __decorate([(0, game_entities_1.EntityDecorator)(), __metadata('design:paramtypes', [Object])], BorderEntity);
+    const createBorder = (position, size) =>
+      new BorderEntity({
+        shapeDefinition: {
+          materialName: interfaces_1.BorderMaterialName,
+          group: physics_body_groups_1.PhysicsBodyGroup.border,
+          shapeType: interfaces_1.PhysicsShapeType.rectangle,
+          shapeData: { size }
+        },
+        position,
+        rotation: 0,
+        addInEmptySpace: false,
+        includeOnPathfinding: true
+      }).attach(physicsWorld);
+    createBorder(new helpers_lib_1.Vector(mapSize.x / 2, -50), new helpers_lib_1.Vector(mapSize.x + 200, 100)); // Top border
+    createBorder(new helpers_lib_1.Vector(mapSize.x / 2, mapSize.y + 50), new helpers_lib_1.Vector(mapSize.x + 200, 100)); // Bottom border
+    createBorder(new helpers_lib_1.Vector(-50, mapSize.y / 2), new helpers_lib_1.Vector(100, mapSize.y + 200)); // Left border
+    createBorder(new helpers_lib_1.Vector(mapSize.x + 50, mapSize.y / 2), new helpers_lib_1.Vector(100, mapSize.y + 200)); // Right border
+  }
 };
 exports.PhysicsWorld = PhysicsWorld;
-exports.PhysicsWorld = PhysicsWorld = __decorate([
+exports.PhysicsWorld = PhysicsWorld = __decorate(
+  [
     (0, game_entities_1.EntityDecorator)(),
-    __metadata("design:paramtypes", [helpers_lib_1.Vector, Object, Array, Array, Boolean])
-], PhysicsWorld);
-//# sourceMappingURL=physics-world.js.map
+    __metadata('design:paramtypes', [helpers_lib_1.Vector, Object, Array, Array, Boolean])
+  ],
+  PhysicsWorld
+);
+//# sourceMappingURL=physics-world.js.map

package/dist/physics/sub-elements/available-spaces/helpers/availability-grid.helper.d.ts

@@ -1,6 +1,6 @@
 import { Rectangle, Vector } from 'helpers-lib';
 export declare class AvailabilityGridHelper {
-    static areaToGridArea(boundingBox: Rectangle, cellSize: number): Rectangle;
-    static positionToGridPosition(point: Vector, cellSize: number): Vector;
-    static gridPositionToPosition(gridPosition: Vector, cellSize: number): Vector;
+  static areaToGridArea(boundingBox: Rectangle, cellSize: number): Rectangle;
+  static positionToGridPosition(point: Vector, cellSize: number): Vector;
+  static gridPositionToPosition(gridPosition: Vector, cellSize: number): Vector;
 }

package/dist/physics/sub-elements/available-spaces/helpers/availability-grid.helper.js

@@ -1,17 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.AvailabilityGridHelper = void 0;
-const helpers_lib_1 = require("helpers-lib");
+const helpers_lib_1 = require('helpers-lib');
 class AvailabilityGridHelper {
-    static areaToGridArea(boundingBox, cellSize) {
-        return new helpers_lib_1.Rectangle(this.positionToGridPosition(boundingBox.topLeft, cellSize), this.positionToGridPosition(boundingBox.bottomRight, cellSize));
-    }
-    static positionToGridPosition(point, cellSize) {
-        return point.divide(cellSize).floor();
-    }
-    static gridPositionToPosition(gridPosition, cellSize) {
-        return gridPosition.add(new helpers_lib_1.Vector(0.5, 0.5)).multiply(cellSize);
-    }
+  static areaToGridArea(boundingBox, cellSize) {
+    return new helpers_lib_1.Rectangle(
+      AvailabilityGridHelper.positionToGridPosition(boundingBox.topLeft, cellSize),
+      AvailabilityGridHelper.positionToGridPosition(boundingBox.bottomRight, cellSize)
+    );
+  }
+  static positionToGridPosition(point, cellSize) {
+    return point.divide(cellSize).floor();
+  }
+  static gridPositionToPosition(gridPosition, cellSize) {
+    return gridPosition.add(new helpers_lib_1.Vector(0.5, 0.5)).multiply(cellSize);
+  }
 }
 exports.AvailabilityGridHelper = AvailabilityGridHelper;
-//# sourceMappingURL=availability-grid.helper.js.map
+//# sourceMappingURL=availability-grid.helper.js.map

package/dist/physics/sub-elements/available-spaces/physics-availability-grid.d.ts

@@ -3,13 +3,13 @@ import { Vector } from 'helpers-lib';
 import { Grid } from '../../../utilities/libraries/data-structures/grid/grid';
 import { PhysicsBodyGroup } from '../elements/physics-body-groups';
 export declare class PhysicsAvailabilityGrid {
-    private p2World;
-    private mapSize;
-    private availabilityGrids;
-    constructor(p2World: p2.World, mapsize: Vector);
-    clear(): void;
-    onBodyAdded(body: p2.Body, physicsBodyGroup: PhysicsBodyGroup): void;
-    getAvilabilityGrid(cellSize: number, physicsBodyGroup?: PhysicsBodyGroup): Grid<boolean>;
-    private createGrid;
-    private getGridSpaceBoundingBox;
+  private p2World;
+  private mapSize;
+  private availabilityGrids;
+  constructor(p2World: p2.World, mapsize: Vector);
+  clear(): void;
+  onBodyAdded(body: p2.Body, physicsBodyGroup: PhysicsBodyGroup): void;
+  getAvilabilityGrid(cellSize: number, physicsBodyGroup?: PhysicsBodyGroup): Grid<boolean>;
+  private createGrid;
+  private getGridSpaceBoundingBox;
 }

package/dist/physics/sub-elements/available-spaces/physics-availability-grid.js

@@ -1,87 +1,92 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsAvailabilityGrid = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const grid_1 = require("../../../utilities/libraries/data-structures/grid/grid");
-const p2js_helper_1 = require("../../helpers/p2js.helper");
-const physics_body_groups_1 = require("../elements/physics-body-groups");
-const physics_entity_1 = require("../../entitity-types/physics-entity");
-const availability_grid_helper_1 = require("./helpers/availability-grid.helper");
+const helpers_lib_1 = require('helpers-lib');
+const grid_1 = require('../../../utilities/libraries/data-structures/grid/grid');
+const p2js_helper_1 = require('../../helpers/p2js.helper');
+const physics_body_groups_1 = require('../elements/physics-body-groups');
+const physics_entity_1 = require('../../entitity-types/physics-entity');
+const availability_grid_helper_1 = require('./helpers/availability-grid.helper');
 class AvailabilityGridCache {
-    constructor() {
-        this.grids = new Map();
+  constructor() {
+    this.grids = new Map();
+  }
+  get(cellSize, group) {
+    const cellSizeMap = this.grids.get(cellSize);
+    if (!cellSizeMap) {
+      return undefined;
     }
-    get(cellSize, group) {
-        let cellSizeMap = this.grids.get(cellSize);
-        if (!cellSizeMap) {
-            return undefined;
+    return cellSizeMap.get(group);
+  }
+  getCollidableGrids(physicsBodyGroup) {
+    const results = [];
+    this.grids.forEach((cellSizeMap, cellSize) => {
+      cellSizeMap.forEach((grid, gridPhysicsBodyGroup) => {
+        if (physics_body_groups_1.PhysicsBodyGroups.canCollide(gridPhysicsBodyGroup, physicsBodyGroup)) {
+          results.push({ grid, cellSize });
         }
-        return cellSizeMap.get(group);
-    }
-    getCollidableGrids(physicsBodyGroup) {
-        let results = [];
-        this.grids.forEach((cellSizeMap, cellSize) => {
-            cellSizeMap.forEach((grid, gridPhysicsBodyGroup) => {
-                if (physics_body_groups_1.PhysicsBodyGroups.canCollide(gridPhysicsBodyGroup, physicsBodyGroup)) {
-                    results.push({ grid, cellSize });
-                }
-            });
-        });
-        return results;
-    }
-    set(cellSize, group, grid) {
-        let cellSizeMap = this.grids.get(cellSize);
-        if (!cellSizeMap) {
-            cellSizeMap = new Map();
-            this.grids.set(cellSize, cellSizeMap);
-        }
-        cellSizeMap.set(group, grid);
-    }
-    clear() {
-        this.grids.clear();
+      });
+    });
+    return results;
+  }
+  set(cellSize, group, grid) {
+    let cellSizeMap = this.grids.get(cellSize);
+    if (!cellSizeMap) {
+      cellSizeMap = new Map();
+      this.grids.set(cellSize, cellSizeMap);
     }
+    cellSizeMap.set(group, grid);
+  }
+  clear() {
+    this.grids.clear();
+  }
 }
 class PhysicsAvailabilityGrid {
-    constructor(p2World, mapsize) {
-        this.availabilityGrids = new AvailabilityGridCache();
-        this.p2World = p2World;
-        this.mapSize = mapsize;
-    }
-    clear() {
-        this.availabilityGrids.clear();
-    }
-    onBodyAdded(body, physicsBodyGroup) {
-        body.aabbNeedsUpdate = true;
-        body.updateAABB();
-        let boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb);
-        this.availabilityGrids.getCollidableGrids(physicsBodyGroup).forEach(item => {
-            let gridSpaceBoundingBox = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(boundingBox, item.cellSize);
-            item.grid.safeSetArea(gridSpaceBoundingBox, false);
-        });
-    }
-    getAvilabilityGrid(cellSize, physicsBodyGroup = physics_body_groups_1.PhysicsBodyGroup.none) {
-        let grid = this.availabilityGrids.get(cellSize, physicsBodyGroup);
-        if (!grid) {
-            grid = this.createGrid(cellSize, physicsBodyGroup);
-            this.availabilityGrids.set(cellSize, physicsBodyGroup, grid);
-        }
-        return grid;
-    }
-    createGrid(cellSize, physicsBodyGroup) {
-        let grid = grid_1.Grid.createNew(new helpers_lib_1.Vector(Math.floor(this.mapSize.x / cellSize), Math.floor(this.mapSize.y / cellSize)), true);
-        this.p2World.bodies.forEach(p2Body => {
-            let physicsEntity = physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(p2Body.id);
-            if (physicsEntity.includeInPathfinding && physics_body_groups_1.PhysicsBodyGroups.canCollide(physicsEntity.physicsBodyGroup, physicsBodyGroup)) {
-                let gridSpaceBoundingBox = this.getGridSpaceBoundingBox(p2Body, cellSize);
-                grid?.safeSetArea(gridSpaceBoundingBox, false);
-            }
-        });
-        return grid;
-    }
-    getGridSpaceBoundingBox(p2Body, cellSize) {
-        let boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(p2Body.aabb);
-        return availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(boundingBox, cellSize);
+  constructor(p2World, mapsize) {
+    this.availabilityGrids = new AvailabilityGridCache();
+    this.p2World = p2World;
+    this.mapSize = mapsize;
+  }
+  clear() {
+    this.availabilityGrids.clear();
+  }
+  onBodyAdded(body, physicsBodyGroup) {
+    body.aabbNeedsUpdate = true;
+    body.updateAABB();
+    const boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb);
+    this.availabilityGrids.getCollidableGrids(physicsBodyGroup).forEach(item => {
+      const gridSpaceBoundingBox = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(boundingBox, item.cellSize);
+      item.grid.safeSetArea(gridSpaceBoundingBox, false);
+    });
+  }
+  getAvilabilityGrid(cellSize, physicsBodyGroup = physics_body_groups_1.PhysicsBodyGroup.none) {
+    let grid = this.availabilityGrids.get(cellSize, physicsBodyGroup);
+    if (!grid) {
+      grid = this.createGrid(cellSize, physicsBodyGroup);
+      this.availabilityGrids.set(cellSize, physicsBodyGroup, grid);
     }
+    return grid;
+  }
+  createGrid(cellSize, physicsBodyGroup) {
+    const grid = grid_1.Grid.createNew(
+      new helpers_lib_1.Vector(Math.floor(this.mapSize.x / cellSize), Math.floor(this.mapSize.y / cellSize)),
+      true
+    );
+    this.p2World.bodies.forEach(p2Body => {
+      const physicsEntity = physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(p2Body.id);
+      if (
+        physicsEntity.includeInPathfinding &&
+        physics_body_groups_1.PhysicsBodyGroups.canCollide(physicsEntity.physicsBodyGroup, physicsBodyGroup)
+      ) {
+        const gridSpaceBoundingBox = this.getGridSpaceBoundingBox(p2Body, cellSize);
+        grid?.safeSetArea(gridSpaceBoundingBox, false);
+      }
+    });
+    return grid;
+  }
+  getGridSpaceBoundingBox(p2Body, cellSize) {
+    const boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(p2Body.aabb);
+    return availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(boundingBox, cellSize);
+  }
 }
 exports.PhysicsAvailabilityGrid = PhysicsAvailabilityGrid;
-//# sourceMappingURL=physics-availability-grid.js.map
+//# sourceMappingURL=physics-availability-grid.js.map

package/dist/physics/sub-elements/available-spaces/physics-available-spaces.d.ts

@@ -5,18 +5,22 @@ import { PathFinderResult } from '../../../utilities/libraries/grid-algorithms/p
 import { PhysicsBodyGroup } from '../elements/physics-body-groups';
 import { Grid } from '../../../utilities/libraries/data-structures/grid/grid';
 export declare class PhysicsAvailableSpaces {
-    private physicsAvailabilityGrid;
-    private vectorFieldCache;
-    constructor(physicsAvailabilityGrid: PhysicsAvailabilityGrid);
-    clear(): void;
-    getAvailabilityGrid(physicsBodyGroup: PhysicsBodyGroup): Grid<{
-        position: Vector;
-        availability: boolean;
-    }>;
-    findClosestAvailableSpace(body: p2.Body, physicsBodyGroup: PhysicsBodyGroup): Vector | undefined;
-    findPathAStar(startingPosition: Vector, target: Vector | string, options?: {
-        includeDiagonals?: boolean;
-        collidableWithGroup?: PhysicsBodyGroup;
-    }): PathFinderResult;
-    findPathDirection(startingPosition: Vector, target: Vector | string, collidableWithGroup: PhysicsBodyGroup): number | undefined;
+  private physicsAvailabilityGrid;
+  private vectorFieldCache;
+  constructor(physicsAvailabilityGrid: PhysicsAvailabilityGrid);
+  clear(): void;
+  getAvailabilityGrid(physicsBodyGroup: PhysicsBodyGroup): Grid<{
+    position: Vector;
+    availability: boolean;
+  }>;
+  findClosestAvailableSpace(body: p2.Body, physicsBodyGroup: PhysicsBodyGroup): Vector | undefined;
+  findPathAStar(
+    startingPosition: Vector,
+    target: Vector | string,
+    options?: {
+      includeDiagonals?: boolean;
+      collidableWithGroup?: PhysicsBodyGroup;
+    }
+  ): PathFinderResult;
+  findPathDirection(startingPosition: Vector, target: Vector | string, collidableWithGroup: PhysicsBodyGroup): number | undefined;
 }