build

Author: github-actions[bot]

dist/GridEngine.esm.min.js

@@ -1,9 +1,9 @@
-import { LayerPosition } from "./../Pathfinding/ShortestPathAlgorithm";
+import { LayerVecPos } from "./../Pathfinding/ShortestPathAlgorithm";
 import { NumberOfDirections } from "./../Direction/Direction";
 import { Direction } from "../Direction/Direction";
-import { GridTilemap, LayerName } from "../GridTilemap/GridTilemap";
+import { GridTilemap } from "../GridTilemap/GridTilemap";
 import { Subject } from "rxjs";
-import { Position } from "../GridEngine";
+import { CharLayer, Position } from "../GridEngine";
 import { Movement } from "../Movement/Movement";
 import { Vector2 } from "../Utils/Vector2/Vector2";
 import * as Phaser from "phaser";
@@ -12,8 +12,8 @@ export declare type GameObject = Phaser.GameObjects.Container | Phaser.GameObjec
 export interface PositionChange {
     exitTile: Position;
     enterTile: Position;
-    exitLayer: LayerName;
-    enterLayer: LayerName;
+    exitLayer: CharLayer;
+    enterLayer: CharLayer;
 }
 export interface CharConfig {
     tilemap: GridTilemap;
@@ -58,16 +58,16 @@ export declare class GridCharacter {
     setMovement(movement?: Movement): void;
     getMovement(): Movement | undefined;
     collidesWithTiles(): boolean;
-    setTilePosition(tilePosition: LayerPosition): void;
-    getTilePos(): LayerPosition;
-    getNextTilePos(): LayerPosition;
+    setTilePosition(tilePosition: LayerVecPos): void;
+    getTilePos(): LayerVecPos;
+    getNextTilePos(): LayerVecPos;
     getTileWidth(): number;
     getTileHeight(): number;
     move(direction: Direction): void;
     update(delta: number): void;
     getMovementDirection(): Direction;
     isBlockingDirection(direction: Direction): boolean;
-    isTileBlocking(direction: Direction, layerInDirection: LayerName): boolean;
+    isTileBlocking(direction: Direction, layerInDirection: CharLayer): boolean;
     private isCharBlocking;
     isMoving(): boolean;
     turnTowards(direction: Direction): void;
@@ -89,11 +89,11 @@ export declare class GridCharacter {
     movementStarted(): Subject<Direction>;
     movementStopped(): Subject<Direction>;
     directionChanged(): Subject<Direction>;
-    tilePositionSet(): Subject<LayerPosition>;
+    tilePositionSet(): Subject<LayerVecPos>;
     positionChangeStarted(): Subject<PositionChange>;
     positionChangeFinished(): Subject<PositionChange>;
     autoMovementSet(): Subject<Movement | undefined>;
-    depthChanged(): Subject<LayerPosition>;
+    depthChanged(): Subject<LayerVecPos>;
     getMovementProgress(): number;
     hasWalkedHalfATile(): boolean;
     private updateCharacterPosition;

dist/GridEngine.min.js

@@ -2,19 +2,26 @@ import { CollisionStrategy } from "./Collisions/CollisionStrategy";
 import { Finished, MoveToConfig, MoveToResult } from "./Movement/TargetMovement/TargetMovement";
 import { PositionChange } from "./GridCharacter/GridCharacter";
 import { Direction, NumberOfDirections } from "./Direction/Direction";
-import { LayerName } from "./GridTilemap/GridTilemap";
 import { Observable } from "rxjs";
 import { NoPathFoundStrategy } from "./Pathfinding/NoPathFoundStrategy";
 import { PathBlockedStrategy } from "./Pathfinding/PathBlockedStrategy";
 import { MovementInfo } from "./Movement/Movement";
 import { CharacterIndex, FrameRow } from "./GridCharacter/CharacterAnimation/CharacterAnimation";
 import { CharacterFilteringOptions } from "./GridCharacter/CharacterFilter/CharacterFilter";
-export { CollisionStrategy, CharacterFilteringOptions, Direction, MoveToConfig, MoveToResult, Finished, FrameRow, NumberOfDirections, NoPathFoundStrategy, PathBlockedStrategy, LayerName, MovementInfo, PositionChange, };
+export { CollisionStrategy, CharacterFilteringOptions, Direction, MoveToConfig, MoveToResult, Finished, FrameRow, NumberOfDirections, NoPathFoundStrategy, PathBlockedStrategy, MovementInfo, PositionChange, };
 export declare type TileSizePerSecond = number;
 export interface Position {
     x: number;
     y: number;
 }
+/**
+ * Specifies a tile position along with a character layer.
+ */
+export interface LayerPosition {
+    position: Position;
+    charLayer: CharLayer;
+}
+export declare type CharLayer = string | undefined;
 /**
  * Configuration object for initializing GridEngine.
  */
@@ -461,11 +468,16 @@ export declare class GridEngine {
      * will be overwritten.
      */
     setCollisionGroups(charId: string, collisionGroups: string[]): void;
+    /**
+     * Gets the tile position and character layer adjacent to the given
+     * position in the given direction.
+     */
+    getTilePosInDirection(position: Position, charLayer: string | undefined, direction: Direction): LayerPosition;
     /**
      * @returns Observable that, whenever a specified position is entered on optionally provided layers,
      *  will notify with the target characters position change
      */
-    steppedOn(charIds: string[], tiles: Position[], layer?: LayerName[]): Observable<{
+    steppedOn(charIds: string[], tiles: Position[], layer?: CharLayer[]): Observable<{
         charId: string;
     } & PositionChange>;
     /**

dist/src/GridCharacter/GridCharacter.d.ts

@@ -1,10 +1,10 @@
 import { GridCharacter } from "../../GridCharacter/GridCharacter";
+import { CharLayer } from "../../GridEngine";
 import { Vector2 } from "../../Utils/Vector2/Vector2";
-import { LayerName } from "../GridTilemap";
 export declare class CharBlockCache {
     private tilePosToCharacters;
     private charRemoved$;
-    isCharBlockingAt(pos: Vector2, layer: LayerName, collisionGroups: string[], exclude?: Set<string>): boolean;
+    isCharBlockingAt(pos: Vector2, layer: CharLayer, collisionGroups: string[], exclude?: Set<string>): boolean;
     getCharactersAt(pos: Vector2, layer: string): Set<GridCharacter>;
     addCharacter(character: GridCharacter): void;
     removeCharacter(character: GridCharacter): void;

dist/src/GridEngine.d.ts

@@ -1,7 +1,8 @@
 import { Direction } from "./../Direction/Direction";
 import { Vector2 } from "../Utils/Vector2/Vector2";
 import { GridCharacter } from "../GridCharacter/GridCharacter";
-export declare type LayerName = string | undefined;
+import { LayerVecPos } from "../Pathfinding/ShortestPathAlgorithm";
+import { CharLayer } from "../GridEngine";
 export declare class GridTilemap {
     private tilemap;
     private static readonly ALWAYS_TOP_PROP_NAME;
@@ -20,20 +21,21 @@ export declare class GridTilemap {
     getCharactersAt(position: Vector2, layer: string): Set<GridCharacter>;
     hasBlockingTile(pos: Vector2, charLayer: string | undefined, direction?: Direction): boolean;
     getTransition(pos: Vector2, fromLayer?: string): string | undefined;
-    setTransition(pos: Vector2, fromLayer: LayerName, toLayer: LayerName): void;
-    getTransitions(): Map<LayerName, Map<LayerName, LayerName>>;
+    setTransition(pos: Vector2, fromLayer: CharLayer, toLayer: CharLayer): void;
+    getTransitions(): Map<CharLayer, Map<CharLayer, CharLayer>>;
     hasNoTile(pos: Vector2, charLayer?: string): boolean;
     hasBlockingChar(pos: Vector2, layer: string | undefined, collisionGroups: string[], exclude?: Set<string>): boolean;
     getTileWidth(): number;
     getTileHeight(): number;
-    getDepthOfCharLayer(layerName: LayerName): number;
+    getDepthOfCharLayer(layerName: CharLayer): number;
     isInRange(pos: Vector2): boolean;
     getTileSize(): Vector2;
     tilePosToPixelPos(tilePosition: Vector2): Vector2;
     getTileDistance(direction: Direction): Vector2;
     toMapDirection(direction: Direction): Direction;
     fromMapDirection(direction: Direction): Direction;
     isIsometric(): boolean;
+    getTilePosInDirection(position: LayerVecPos, direction: Direction): LayerVecPos;
     private isLayerBlockingAt;
     private getCharLayerIndexes;
     private findPrevAndCharLayer;

dist/src/GridTilemap/CharBlockCache/CharBlockCache.d.ts

@@ -1,12 +1,11 @@
-import { LayerName } from "./../../GridTilemap/GridTilemap";
 import { NoPathFoundStrategy } from "./../../Pathfinding/NoPathFoundStrategy";
-import { LayerPosition } from "./../../Pathfinding/ShortestPathAlgorithm";
+import { LayerVecPos } from "./../../Pathfinding/ShortestPathAlgorithm";
 import { GridTilemap } from "../../GridTilemap/GridTilemap";
 import { GridCharacter } from "../../GridCharacter/GridCharacter";
 import { Movement, MovementInfo } from "../Movement";
 import { PathBlockedStrategy } from "../../Pathfinding/PathBlockedStrategy";
 import { ShortestPathAlgorithm } from "../../Pathfinding/ShortestPathAlgorithm";
-import { Position } from "../../GridEngine";
+import { CharLayer, Position } from "../../GridEngine";
 import { Subject } from "rxjs";
 export interface MoveToConfig {
     /**
@@ -86,7 +85,7 @@ export interface Finished {
     position: Position;
     result?: MoveToResult;
     description?: string;
-    layer: LayerName;
+    layer: CharLayer;
 }
 export interface Options {
     distance?: number;
@@ -114,12 +113,12 @@ export declare class TargetMovement implements Movement {
     private distance;
     private isPositionAllowed;
     private shortestPathAlgorithm;
-    constructor(character: GridCharacter, tilemap: GridTilemap, targetPos: LayerPosition, { config, ignoreBlockedTarget, distance, shortestPathAlgorithm, }?: Options);
+    constructor(character: GridCharacter, tilemap: GridTilemap, targetPos: LayerVecPos, { config, ignoreBlockedTarget, distance, shortestPathAlgorithm, }?: Options);
     setPathBlockedStrategy(pathBlockedStrategy: PathBlockedStrategy): void;
     getPathBlockedStrategy(): PathBlockedStrategy;
     private setCharacter;
     update(delta: number): void;
-    getNeighbors: (pos: LayerPosition) => LayerPosition[];
+    getNeighbors: (pos: LayerVecPos) => LayerVecPos[];
     finishedObs(): Subject<Finished>;
     getInfo(): MovementInfo;
     private resultToReason;

dist/src/GridTilemap/GridTilemap.d.ts

@@ -1,8 +1,8 @@
-import { GetNeighbors, LayerPosition, ShortestPathAlgorithm } from "./../ShortestPathAlgorithm";
+import { GetNeighbors, LayerVecPos, ShortestPathAlgorithm } from "./../ShortestPathAlgorithm";
 export declare class Bfs implements ShortestPathAlgorithm {
-    getShortestPath(startPos: LayerPosition, targetPos: LayerPosition, getNeighbors: GetNeighbors): {
-        path: LayerPosition[];
-        closestToTarget: LayerPosition;
+    getShortestPath(startPos: LayerVecPos, targetPos: LayerVecPos, getNeighbors: GetNeighbors): {
+        path: LayerVecPos[];
+        closestToTarget: LayerVecPos;
     };
     private distance;
     private pos2Str;

dist/src/Movement/TargetMovement/TargetMovement.d.ts

@@ -1,8 +1,8 @@
-import { GetNeighbors, LayerPosition, ShortestPathAlgorithm } from "../ShortestPathAlgorithm";
+import { GetNeighbors, LayerVecPos, ShortestPathAlgorithm } from "../ShortestPathAlgorithm";
 export declare class BidirectionalSearch implements ShortestPathAlgorithm {
-    getShortestPath(startPos: LayerPosition, targetPos: LayerPosition, getNeighbors: GetNeighbors): {
-        path: LayerPosition[];
-        closestToTarget: LayerPosition;
+    getShortestPath(startPos: LayerVecPos, targetPos: LayerVecPos, getNeighbors: GetNeighbors): {
+        path: LayerVecPos[];
+        closestToTarget: LayerVecPos;
     };
     /**
      * @returns A memoized version of getNeighbors to improve speed.

dist/src/Pathfinding/Bfs/Bfs.d.ts

@@ -1,17 +1,17 @@
-import { LayerName } from "../GridTilemap/GridTilemap";
+import { CharLayer } from "../GridEngine";
 import { Vector2 } from "../Utils/Vector2/Vector2";
-export interface LayerPosition {
+export interface LayerVecPos {
     position: Vector2;
-    layer: LayerName;
+    layer: CharLayer;
 }
-export declare type GetNeighbors = (pos: LayerPosition) => LayerPosition[];
+export declare type GetNeighbors = (pos: LayerVecPos) => LayerVecPos[];
 export interface ShortestPath {
-    path: LayerPosition[];
+    path: LayerVecPos[];
     distOffset: number;
 }
 export interface ShortestPathAlgorithm {
-    getShortestPath(startPos: LayerPosition, targetPos: LayerPosition, getNeighbors: GetNeighbors): {
-        path: LayerPosition[];
-        closestToTarget: LayerPosition;
+    getShortestPath(startPos: LayerVecPos, targetPos: LayerVecPos, getNeighbors: GetNeighbors): {
+        path: LayerVecPos[];
+        closestToTarget: LayerVecPos;
     };
 }

dist/src/Pathfinding/BidirectionalSearch/BidirectionalSearch.d.ts

@@ -1,7 +1,7 @@
-import { LayerPosition } from "./../../Pathfinding/ShortestPathAlgorithm";
+import { LayerVecPos } from "./../../Pathfinding/ShortestPathAlgorithm";
 export declare class LayerPositionUtils {
-    static equal(position: LayerPosition, otherPosition: LayerPosition): boolean;
-    static copyOver(source: LayerPosition, target: LayerPosition): void;
-    static clone(layerPosition: LayerPosition): LayerPosition;
-    static toString(layerPosition: LayerPosition): string;
+    static equal(position: LayerVecPos, otherPosition: LayerVecPos): boolean;
+    static copyOver(source: LayerVecPos, target: LayerVecPos): void;
+    static clone(layerPosition: LayerVecPos): LayerVecPos;
+    static toString(layerPosition: LayerVecPos): string;
 }

dist/src/Pathfinding/ShortestPathAlgorithm.d.ts

@@ -25,5 +25,6 @@ export declare class Vector2 {
     modulo(vector: Vector2): Vector2;
     scalarModulo(scalar: number): Vector2;
     scalarMult(scalar: number): Vector2;
+    toPosition(): Position;
     toString(): string;
 }