bard-legends-framework 0.12.1 → 1.0.0-rc0

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

@@ -1,92 +0,0 @@
-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');
-class AvailabilityGridCache {
-  constructor() {
-    this.grids = new Map();
-  }
-  get(cellSize, group) {
-    const 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 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();
-    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

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

@@ -1,26 +0,0 @@
-import { Vector } from 'helpers-lib';
-import p2 from 'p2';
-import { PhysicsAvailabilityGrid } from './physics-availability-grid';
-import { PathFinderResult } from '../../../utilities/libraries/grid-algorithms/path-finder/path-finder';
-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;
-}

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

@@ -1,102 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PhysicsAvailableSpaces = void 0;
-const helpers_lib_1 = require('helpers-lib');
-const closest_available_space_helper_1 = require('../../../utilities/libraries/grid-algorithms/closest-available-space/closest-available-space.helper');
-const p2js_helper_1 = require('../../helpers/p2js.helper');
-const utilities_1 = require('../../../utilities');
-const physics_body_groups_1 = require('../elements/physics-body-groups');
-const physics_entity_1 = require('../../entitity-types/physics-entity');
-const vector_field_path_finder_1 = require('../../../utilities/libraries/grid-algorithms/vector-field-path-finder/vector-field-path-finder');
-const availability_grid_helper_1 = require('./helpers/availability-grid.helper');
-const GRID_CELL_SIZE = 50;
-class PhysicsAvailableSpaces {
-  constructor(physicsAvailabilityGrid) {
-    this.physicsAvailabilityGrid = physicsAvailabilityGrid;
-    this.vectorFieldCache = new Map();
-  }
-  clear() {
-    this.vectorFieldCache.clear();
-  }
-  getAvailabilityGrid(physicsBodyGroup) {
-    const availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, physicsBodyGroup);
-    return availabilityGrid.map((value, position) => ({
-      position: availability_grid_helper_1.AvailabilityGridHelper.gridPositionToPosition(position, GRID_CELL_SIZE),
-      availability: value
-    }));
-  }
-  findClosestAvailableSpace(body, physicsBodyGroup) {
-    body.aabbNeedsUpdate = true;
-    body.updateAABB();
-    const changeVector = closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(
-      this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, physicsBodyGroup),
-      p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb),
-      GRID_CELL_SIZE
-    );
-    return changeVector;
-  }
-  findPathAStar(startingPosition, target, options) {
-    if (!options) {
-      options = {};
-    }
-    if (options.includeDiagonals === undefined) {
-      options.includeDiagonals = false;
-    }
-    if (options.collidableWithGroup === undefined) {
-      options.collidableWithGroup = physics_body_groups_1.PhysicsBodyGroup.none;
-    }
-    let targetPosition;
-    let targetP2Body;
-    if (helpers_lib_1.Comparator.isString(target)) {
-      const targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
-      targetP2Body = targetEntity['p2Body'];
-      targetPosition = p2js_helper_1.P2JSHelper.arrayToVector(targetP2Body.position);
-    } else {
-      targetPosition = target;
-    }
-    const startingGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(
-      startingPosition,
-      GRID_CELL_SIZE
-    );
-    const targetGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(
-      targetPosition,
-      GRID_CELL_SIZE
-    );
-    const availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, options.collidableWithGroup);
-    if (targetP2Body) {
-      const boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetP2Body.aabb);
-      const gridSpaceBoundingBox = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(boundingBox, GRID_CELL_SIZE);
-      availabilityGrid.safeSetArea(gridSpaceBoundingBox, true);
-    }
-    const result = utilities_1.PathFinder.findPath(availabilityGrid, startingGridPosition, targetGridPosition, {
-      includeDiagonals: options.includeDiagonals
-    });
-    result.path = result.path.map(gridPosition =>
-      availability_grid_helper_1.AvailabilityGridHelper.gridPositionToPosition(gridPosition, GRID_CELL_SIZE)
-    );
-    return result;
-  }
-  findPathDirection(startingPosition, target, collidableWithGroup) {
-    let targetArea;
-    if (helpers_lib_1.Comparator.isString(target)) {
-      const targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
-      targetArea = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetEntity['p2Body'].aabb);
-    } else {
-      targetArea = new helpers_lib_1.Rectangle(target, target);
-    }
-    const targetGridArea = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(targetArea, GRID_CELL_SIZE);
-    const cacheName = JSON.stringify({ targetGridArea, collidableWithGroup });
-    let vectorField = this.vectorFieldCache.get(cacheName);
-    if (!vectorField) {
-      const availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, collidableWithGroup);
-      vectorField = new vector_field_path_finder_1.VectorFieldPathFinder(targetGridArea, availabilityGrid);
-      this.vectorFieldCache.set(cacheName, vectorField);
-    }
-    const startingGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(
-      startingPosition,
-      GRID_CELL_SIZE
-    );
-    return vectorField.getDirectionToTarget(startingGridPosition);
-  }
-}
-exports.PhysicsAvailableSpaces = PhysicsAvailableSpaces;
-//# sourceMappingURL=physics-available-spaces.js.map

package/dist/physics/sub-elements/collisions/contact-equation-orginiser.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="p2" />
-import { PhysicsEntity } from '../../entitity-types/physics-entity';
-import { CollisionReport } from '../../interfaces';
-export interface BodyWithCollisionReports {
-  p2Body: p2.Body;
-  entity: PhysicsEntity;
-  collisionReports: CollisionReport[];
-}
-export declare class ContactEquationOrganiser {
-  private bodiesInContactWith;
-  private collisionReports;
-  getAllBodiesWithTheirCollisionReports(): BodyWithCollisionReports[];
-  registerContactEquation(contactEquation: p2.ContactEquation): void;
-  reset(): void;
-  private getCollisionDetails;
-  private getCollisionDetail;
-  private getNormals;
-}

package/dist/physics/sub-elements/collisions/contact-equation-orginiser.js

@@ -1,90 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.ContactEquationOrganiser = void 0;
-const helpers_lib_1 = require('helpers-lib');
-const physics_entity_1 = require('../../entitity-types/physics-entity');
-const p2js_helper_1 = require('../../helpers/p2js.helper');
-class ContactEquationOrganiser {
-  constructor() {
-    this.bodiesInContactWith = new Map();
-    this.collisionReports = new Map();
-  }
-  getAllBodiesWithTheirCollisionReports() {
-    const result = [];
-    this.bodiesInContactWith.forEach((item, bodyId) => {
-      const collisionReports = this.collisionReports.get(bodyId) || [];
-      result.push({
-        p2Body: item.p2Body,
-        entity: item.entity,
-        collisionReports
-      });
-    });
-    return result;
-  }
-  registerContactEquation(contactEquation) {
-    const entityA = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyA.id);
-    const entityB = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyB.id);
-    if (entityA && entityB) {
-      this.bodiesInContactWith.set(contactEquation.bodyA.id, {
-        p2Body: contactEquation.bodyA,
-        entity: entityA
-      });
-      this.bodiesInContactWith.set(contactEquation.bodyB.id, {
-        p2Body: contactEquation.bodyB,
-        entity: entityB
-      });
-      const bodyACollisions = this.collisionReports.get(contactEquation.bodyA.id) || [];
-      const bodyBCollisions = this.collisionReports.get(contactEquation.bodyB.id) || [];
-      const { collisionDetailsA, collisionDetailsB } = this.getCollisionDetails(entityA, entityB, contactEquation);
-      bodyACollisions.push({
-        self: collisionDetailsA,
-        target: collisionDetailsB
-      });
-      bodyBCollisions.push({
-        self: collisionDetailsB,
-        target: collisionDetailsA
-      });
-      this.collisionReports.set(contactEquation.bodyA.id, bodyACollisions);
-      this.collisionReports.set(contactEquation.bodyB.id, bodyBCollisions);
-    } else {
-      console.warn('ContactEquationOrganiser: Entity not found for contact equation', contactEquation);
-    }
-  }
-  reset() {
-    this.bodiesInContactWith.clear();
-    this.collisionReports.clear();
-  }
-  getCollisionDetails(entityA, entityB, contactEquation) {
-    const dtoA = entityA.convertToDTO();
-    const dtoB = entityB.convertToDTO();
-    const contactPointA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointA);
-    const contactPointB = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointB);
-    const { normalA, normalB } = this.getNormals(contactEquation);
-    return {
-      collisionDetailsA: this.getCollisionDetail(dtoA, contactEquation.bodyA.mass, contactPointA, normalA, entityA.area),
-      collisionDetailsB: this.getCollisionDetail(dtoB, contactEquation.bodyB.mass, contactPointB, normalB, entityB.area)
-    };
-  }
-  getCollisionDetail(physicsBodyDTOSelf, massSelf, contactPointSelf, normalSelf, areaSelf) {
-    let positionRelativeToObject;
-    return {
-      body: physicsBodyDTOSelf,
-      getPositionReletiveToObject: () => {
-        if (!positionRelativeToObject) {
-          positionRelativeToObject = contactPointSelf.rotate(helpers_lib_1.Radian.toVector(-physicsBodyDTOSelf.rotation));
-        }
-        return positionRelativeToObject;
-      },
-      position: contactPointSelf,
-      mass: massSelf,
-      area: areaSelf,
-      normal: normalSelf
-    };
-  }
-  getNormals(contactEquation) {
-    const contactEquationNormalA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.normalA);
-    const contactEquationNormalB = contactEquationNormalA.multiply(-1);
-    return { normalA: contactEquationNormalA, normalB: contactEquationNormalB };
-  }
-}
-exports.ContactEquationOrganiser = ContactEquationOrganiser;
-//# sourceMappingURL=contact-equation-orginiser.js.map

package/dist/physics/sub-elements/collisions/physics-collision.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="p2" />
-import { CollisionReport } from '../../interfaces';
-export type OnCollisionCallbackFunciton = (collision: CollisionReport) => void;
-export declare class PhysicsCollision {
-  private p2World;
-  private contactEquationOrganiser;
-  constructor(p2World: p2.World);
-  update(time: number, delta: number): void;
-  isCollidingWithAnything(p2Body: p2.Body): boolean;
-  private setResults;
-  private handleSpeedLimit;
-}

package/dist/physics/sub-elements/collisions/physics-collision.js

@@ -1,50 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PhysicsCollision = void 0;
-const p2js_helper_1 = require('../../helpers/p2js.helper');
-const contact_equation_orginiser_1 = require('./contact-equation-orginiser');
-const physics_entity_1 = require('../../entitity-types/physics-entity');
-const SPEED_LIMIT = 0.8;
-const ROTATIONAL_SPEED_LIMIT = 0.01;
-class PhysicsCollision {
-  constructor(p2World) {
-    this.contactEquationOrganiser = new contact_equation_orginiser_1.ContactEquationOrganiser();
-    this.p2World = p2World;
-    this.p2World.on('beginContact', event => {
-      event.contactEquations.forEach(contactEquation => {
-        this.contactEquationOrganiser.registerContactEquation(contactEquation);
-      });
-    });
-  }
-  update(time, delta) {
-    physics_entity_1.PhysicsEntity.getPhysicsEntities().forEach(entity => {
-      entity['_collisions'] = [];
-    });
-    this.p2World.narrowphase.contactEquations.forEach(contactEquation => {
-      this.contactEquationOrganiser.registerContactEquation(contactEquation);
-    });
-    this.setResults();
-    this.contactEquationOrganiser.reset();
-  }
-  isCollidingWithAnything(p2Body) {
-    p2Body.aabbNeedsUpdate = true;
-    p2Body.updateAABB();
-    const overlappingBodies = this.p2World.broadphase.aabbQuery(this.p2World, p2Body.aabb);
-    return overlappingBodies.length > 0;
-  }
-  setResults() {
-    this.contactEquationOrganiser.getAllBodiesWithTheirCollisionReports().forEach(bodiesAndContacts => {
-      this.handleSpeedLimit(bodiesAndContacts.p2Body);
-      bodiesAndContacts.entity['setCollisionReports'](bodiesAndContacts.collisionReports);
-    });
-  }
-  handleSpeedLimit(body) {
-    let velocity = p2js_helper_1.P2JSHelper.arrayToVector(body.velocity);
-    if (velocity.length > SPEED_LIMIT) {
-      velocity = velocity.normalize(SPEED_LIMIT);
-      body.velocity = p2js_helper_1.P2JSHelper.vectorToArray(velocity);
-    }
-    body.angularVelocity = Math.min(Math.max(body.angularVelocity, -ROTATIONAL_SPEED_LIMIT), ROTATIONAL_SPEED_LIMIT);
-  }
-}
-exports.PhysicsCollision = PhysicsCollision;
-//# sourceMappingURL=physics-collision.js.map

package/dist/physics/sub-elements/elements/physics-body-groups.d.ts

@@ -1,15 +0,0 @@
-export declare enum PhysicsBodyGroup {
-  none = 0,
-  border = 1,
-  friend = 2,
-  friendProjectile = 3,
-  enemy = 4,
-  enemyProjectile = 5,
-  neutral = 6,
-  explosion = 7
-}
-export declare class PhysicsBodyGroups {
-  static getGroupConstant(group: PhysicsBodyGroup): number;
-  static getMaskConstant(group: PhysicsBodyGroup): number;
-  static canCollide(group1: PhysicsBodyGroup, group2: PhysicsBodyGroup): boolean;
-}

package/dist/physics/sub-elements/elements/physics-body-groups.js

@@ -1,76 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PhysicsBodyGroups = exports.PhysicsBodyGroup = void 0;
-/* eslint-disable no-bitwise */
-const BORDER_GROUP = 1 << 0; // 0b0001;
-const FRIEND_GROUP = 1 << 1; // 0b0010;
-const FRIEND_PROJECTILE_GROUP = 1 << 2; // 0b0100;
-const ENEMY_GROUP = 1 << 3; // 0b1000;
-const ENEMY_PROJECTILE_GROUP = 1 << 4;
-const NEUTRAL_GROUP = 1 << 5;
-const EXPLOSION_GROUP = 1 << 6;
-const BORDER_MASK = FRIEND_GROUP | FRIEND_PROJECTILE_GROUP | ENEMY_GROUP | ENEMY_PROJECTILE_GROUP | NEUTRAL_GROUP;
-const FRIEND_MASK = ENEMY_GROUP | ENEMY_PROJECTILE_GROUP | NEUTRAL_GROUP | BORDER_GROUP | EXPLOSION_GROUP;
-const FRIEND_PROJECTILE_MASK = ENEMY_GROUP | NEUTRAL_GROUP | BORDER_GROUP;
-const ENEMY_MASK = FRIEND_GROUP | FRIEND_PROJECTILE_GROUP | NEUTRAL_GROUP | BORDER_GROUP | EXPLOSION_GROUP;
-const ENEMY_PROJECTILE_MASK = FRIEND_GROUP | NEUTRAL_GROUP | BORDER_GROUP;
-const NEUTRAL_MASK =
-  FRIEND_GROUP | FRIEND_PROJECTILE_GROUP | ENEMY_GROUP | ENEMY_PROJECTILE_GROUP | NEUTRAL_GROUP | BORDER_GROUP | EXPLOSION_GROUP;
-const EXPLOSION_MASK = FRIEND_GROUP | ENEMY_GROUP | NEUTRAL_GROUP;
-var PhysicsBodyGroup;
-(PhysicsBodyGroup => {
-  PhysicsBodyGroup[(PhysicsBodyGroup['none'] = 0)] = 'none';
-  PhysicsBodyGroup[(PhysicsBodyGroup['border'] = 1)] = 'border';
-  PhysicsBodyGroup[(PhysicsBodyGroup['friend'] = 2)] = 'friend';
-  PhysicsBodyGroup[(PhysicsBodyGroup['friendProjectile'] = 3)] = 'friendProjectile';
-  PhysicsBodyGroup[(PhysicsBodyGroup['enemy'] = 4)] = 'enemy';
-  PhysicsBodyGroup[(PhysicsBodyGroup['enemyProjectile'] = 5)] = 'enemyProjectile';
-  PhysicsBodyGroup[(PhysicsBodyGroup['neutral'] = 6)] = 'neutral';
-  PhysicsBodyGroup[(PhysicsBodyGroup['explosion'] = 7)] = 'explosion';
-})(PhysicsBodyGroup || (exports.PhysicsBodyGroup = PhysicsBodyGroup = {}));
-class PhysicsBodyGroups {
-  static getGroupConstant(group) {
-    switch (group) {
-      case PhysicsBodyGroup.none:
-        return 0;
-      case PhysicsBodyGroup.border:
-        return BORDER_GROUP;
-      case PhysicsBodyGroup.friend:
-        return FRIEND_GROUP;
-      case PhysicsBodyGroup.friendProjectile:
-        return FRIEND_PROJECTILE_GROUP;
-      case PhysicsBodyGroup.enemy:
-        return ENEMY_GROUP;
-      case PhysicsBodyGroup.enemyProjectile:
-        return ENEMY_PROJECTILE_GROUP;
-      case PhysicsBodyGroup.neutral:
-        return NEUTRAL_GROUP;
-      case PhysicsBodyGroup.explosion:
-        return EXPLOSION_GROUP;
-    }
-  }
-  static getMaskConstant(group) {
-    switch (group) {
-      case PhysicsBodyGroup.none:
-        return 0;
-      case PhysicsBodyGroup.border:
-        return BORDER_MASK;
-      case PhysicsBodyGroup.friend:
-        return FRIEND_MASK;
-      case PhysicsBodyGroup.friendProjectile:
-        return FRIEND_PROJECTILE_MASK;
-      case PhysicsBodyGroup.enemy:
-        return ENEMY_MASK;
-      case PhysicsBodyGroup.enemyProjectile:
-        return ENEMY_PROJECTILE_MASK;
-      case PhysicsBodyGroup.neutral:
-        return NEUTRAL_MASK;
-      case PhysicsBodyGroup.explosion:
-        return EXPLOSION_MASK;
-    }
-  }
-  static canCollide(group1, group2) {
-    return (PhysicsBodyGroups.getMaskConstant(group1) & PhysicsBodyGroups.getGroupConstant(group2)) !== 0;
-  }
-}
-exports.PhysicsBodyGroups = PhysicsBodyGroups;
-//# sourceMappingURL=physics-body-groups.js.map

package/dist/physics/sub-elements/elements/physics-materials.d.ts

@@ -1,19 +0,0 @@
-import p2 from 'p2';
-import { BorderProperties, MaterialContactDefinition, MaterialDefinition } from '../../interfaces';
-export declare class PhysicsMaterials {
-  private borderMaterial;
-  private materials;
-  private materialDefinitions;
-  constructor(
-    p2World: p2.World,
-    borderProperties: BorderProperties,
-    materialDefinitions: ReadonlyArray<MaterialDefinition>,
-    materialContactDefinitions: ReadonlyArray<MaterialContactDefinition>
-  );
-  getBorderMaterial(): p2.Material;
-  getMaterial(name: string): p2.Material;
-  getMaterialDefinition(name: string): MaterialDefinition;
-  private addContactMaterials;
-  private getFullListOfMaterialContactDefinitions;
-  private addContactMaterialsWithBorder;
-}

package/dist/physics/sub-elements/elements/physics-materials.js

@@ -1,108 +0,0 @@
-var __importDefault = (this && this.__importDefault) || (mod => (mod && mod.__esModule ? mod : { default: mod }));
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PhysicsMaterials = void 0;
-const p2_1 = __importDefault(require('p2'));
-const interfaces_1 = require('../../interfaces');
-class PhysicsMaterials {
-  constructor(p2World, borderProperties, materialDefinitions, materialContactDefinitions) {
-    this.borderMaterial = new p2_1.default.Material();
-    this.materials = new Map();
-    this.materialDefinitions = new Map();
-    materialDefinitions.forEach(materialDefinition => {
-      this.materials.set(materialDefinition.name, new p2_1.default.Material());
-      this.materialDefinitions.set(materialDefinition.name, materialDefinition);
-    });
-    this.addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions);
-  }
-  getBorderMaterial() {
-    return this.borderMaterial;
-  }
-  getMaterial(name) {
-    if (name === interfaces_1.BorderMaterialName) {
-      return this.borderMaterial;
-    } else {
-      const material = this.materials.get(name);
-      if (!material) {
-        throw new Error(`Could not find material with name ${name}.`);
-      }
-      return material;
-    }
-  }
-  getMaterialDefinition(name) {
-    if (name === interfaces_1.BorderMaterialName) {
-      return {
-        name: interfaces_1.BorderMaterialName,
-        density: Number.MAX_SAFE_INTEGER,
-        velocityDrag: 1,
-        rotationalDrag: 1
-      };
-    } else {
-      const materialDefinition = this.materialDefinitions.get(name);
-      if (!materialDefinition) {
-        throw new Error(`Could not find material definition with name ${name}.`);
-      }
-      return materialDefinition;
-    }
-  }
-  addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions) {
-    this.getFullListOfMaterialContactDefinitions(
-      materialDefinitions.map(definition => definition.name),
-      materialContactDefinitions
-    ).forEach(contactDefinition => {
-      const materialA = this.getMaterial(contactDefinition.materialA);
-      const materialB = this.getMaterial(contactDefinition.materialB);
-      p2World.addContactMaterial(
-        new p2_1.default.ContactMaterial(materialA, materialB, {
-          friction: contactDefinition.friction,
-          restitution: contactDefinition.bounciness,
-          stiffness: contactDefinition.stiffness
-        })
-      );
-    });
-    this.addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions);
-  }
-  getFullListOfMaterialContactDefinitions(materialNames, materialContactDefinitions) {
-    const definedCombinations = new Map();
-    materialContactDefinitions.forEach(contactDefinition => {
-      let materialAMap = definedCombinations.get(contactDefinition.materialA);
-      if (!materialAMap) {
-        materialAMap = new Map();
-        definedCombinations.set(contactDefinition.materialA, materialAMap);
-      }
-      materialAMap.set(contactDefinition.materialB, contactDefinition);
-    });
-    const fullList = [];
-    materialNames.forEach((materialA, index) => {
-      for (let i = index; i < materialNames.length; i++) {
-        const materialB = materialNames[i];
-        const contactDefinition = definedCombinations.get(materialA)?.get(materialB);
-        if (contactDefinition) {
-          fullList.push(contactDefinition);
-        } else {
-          fullList.push({
-            materialA,
-            materialB,
-            friction: 0,
-            bounciness: 0,
-            stiffness: 1e6 // default p2js stiffness
-          });
-        }
-      }
-    });
-    return fullList;
-  }
-  addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions) {
-    materialDefinitions.forEach(materialDefinition => {
-      const materialA = this.getMaterial(materialDefinition.name);
-      p2World.addContactMaterial(
-        new p2_1.default.ContactMaterial(materialA, this.borderMaterial, {
-          friction: borderProperties.friction,
-          restitution: borderProperties.bounciness,
-          stiffness: borderProperties.stiffness
-        })
-      );
-    });
-  }
-}
-exports.PhysicsMaterials = PhysicsMaterials;
-//# sourceMappingURL=physics-materials.js.map

package/dist/physics/sub-elements/elements/physics-world-borders.d.ts

@@ -1,11 +0,0 @@
-import { Vector } from 'helpers-lib';
-import { PhysicsEntityDefinition } from '../../interfaces';
-import { PhysicsWorld } from '../../physics-world';
-import { ImmovablePhysicsEntity } from '../../entitity-types/immovable-physics-entity';
-export declare class BorderEntity extends ImmovablePhysicsEntity {
-  constructor(physicsWorld: any, physicsEntityDefinition: PhysicsEntityDefinition);
-}
-export declare class PhysicsWorldBorders {
-  static createBorders(physicsWorld: PhysicsWorld, mapSize: Vector): void;
-  private static createBorder;
-}