mrpas 1.2.1 → 2.1.0

package/README.md

@@ -8,7 +8,7 @@ Just use npm:
 npm install mrpas
 ```
 
-Or grab the code from the [repository](https://bitbucket.org/mingos/mrpas) and include it in your project.
+Or grab the code from the [repository](https://bitbucket.org/umbraprojekt/mrpas) and include it in your project.
 
 ## Usage
 
@@ -17,11 +17,15 @@ Or grab the code from the [repository](https://bitbucket.org/mingos/mrpas) and i
 Instantiate a `Mrpas` object by passing it the map dimensions and a callback for determining map cell transparency:
 
 ```
-const Mrpas = require("mrpas");
+const { Mrpas } = require("mrpas");
 
-const fov = new Mrpas(20, 20, (x, y) => {
-    return map[x][y].transparent;
-});
+const fov = new Mrpas(20, 20, (x, y) => map[x][y].transparent);
+```
+
+ES modules can import the same named export:
+
+```
+import { Mrpas } from "mrpas";
 ```
 
 ### Compute FOV
@@ -29,11 +33,13 @@ const fov = new Mrpas(20, 20, (x, y) => {
 Compute the field of view for any set of coordinates by calling the `Mrpas#compute()` method and passing it the origin coordinates, FOV calculation radius and two callbacks: one for determining whether a call has been marked as visible, and the othe for marking it as visible:
 
 ```
-fov.compute(10, 10, 7, (x, y) => {
-    return map[x][y].visible;
-}, (x, y) => {
-    map[x][y].visible = true;
-});
+fov.compute(
+    10,
+    10,
+    7,
+    (x, y) => map[x][y].visible,
+    (x, y) => map[x][y].visible = true
+);
 ```
 
 To calculate the FOV on the entire map, regardless of radius, you may pass `Infinity` as the radius value. Just remember that the transparency callback (the one passed to the constructor) will need to account for this, returning `false` when a cell outside the map is checked.
@@ -46,13 +52,31 @@ Should your map change dimensions, you can inform `Mrpas` about it by calling `M
 fov.setMapDimensions(40, 40);
 ```
 
+### TypeScript
+
+MRPAS includes a TypeScript declaration file. It can be used in TypeScript projects without additional typings:
+
+```
+import { Mrpas } from "mrpas";
+
+const fov: Mrpas = new Mrpas(20, 20, (x: number, y: number): boolean => map[x][y].transparent);
+
+fov.compute(
+    10,
+    10,
+    7,
+    (x: number, y: number): boolean => map[x][y].visible,
+    (x: number, y: number): void => map[x][y].visible = true
+);
+```
+
 ## About MRPAS
 
 MRPAS, or [Mingos' Restrictive Precise Angle Shadowcasting](http://www.roguebasin.com/index.php?title=Restrictive_Precise_Angle_Shadowcasting) (Precise Angle Shadowcasting for short) is a field of view (FOV) computation algorithm. Given a 2D grid with a source point *S* and *n* points marked as obstacles, it will determine all points visible from *S*.
 
 To visualise this, let the following be a 2D grid of 20 by 20 points. The character `@` represents the field of view source, `#` characters represent obstacles. Cells with yellow background are in the source point's field of view:
 
-![fov](https://bytebucket.org/mingos/mrpas/raw/0c4ef44008589b0d4366b3f44072cfd3731b6410/img/fov.png)
+![fov](https://mingos.bitbucket.io/img/umbraprojekt/mrpas/fov.png)
 
 ### Real life uses
 
@@ -82,22 +106,20 @@ Considering the mathematics behind determining the FOV, the line of sight from A
 
 The algorithm's asymmetry can be seen on the following image, where the `.` character has been used to mark asymmetric points (if on yellow background, they can be seen from the source, but cannot see the source; if on black, the source is visible from them, but it cannot see them):
 
-![fov](https://bytebucket.org/mingos/mrpas/raw/0c4ef44008589b0d4366b3f44072cfd3731b6410/img/symmetry.png)
+![fov](https://mingos.bitbucket.io/img/umbraprojekt/mrpas/symmetry.png)
 
 On the above map, 1.6% of all points not containing an obstacle are asymmetric.
 
 The percentage of asymmetric points is within the range of single digit numbers, depending on the map layout. An "outdoor" map with scattered single point obstacles will always contain the most symmetry artifacts.
 
-For comparison, here's an "outdoor" map with 4.4% asymmetric points:
+For comparison, here's an "outdoor" map with 3.9% asymmetric points:
 
-![fov](https://bytebucket.org/mingos/mrpas/raw/0c4ef44008589b0d4366b3f44072cfd3731b6410/img/symmetry-outdoor.png)
+![fov](https://mingos.bitbucket.io/img/umbraprojekt/mrpas/symmetry-outdoor.png)
 
 ### Performance
 
-MRPAS was written with performace in mind. It processes as few points as possible, discarding the ones obviously out of FOV. Since raw numbers, such as FOV computations per second, are meaningless without context, suffice it to say that MRPAS tends to outperform all popular FOV algorithms by a fair margin.
-
-It is worth noting that the ES6 version of MRPAS is 2-3 times slower, depending on the map it is being used on. The default implementation is therefore ES5, but ES6 is included just for fun.
+MRPAS was written with performace in mind. It processes as few points as possible, discarding the ones obviously out of FOV. Since raw numbers, such as FOV computations per second, are meaningless without context, suffice it to say that MRPAS tends to match or outperform all popular FOV algorithms.
 
 ## Images
 
-FOV images have been generated by [FOV Torture Chamber](https://bitbucket.org/mingos/fov-torture-chamber).
+FOV images have been generated by [FOV Torture Chamber](https://bitbucket.org/umbraprojekt/fov-torture-chamber).

package/dist/cjs/index.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mrpas = void 0;
+class Mrpas {
+    mapWidth;
+    mapHeight;
+    isTransparent;
+    constructor(mapWidth, mapHeight, isTransparent) {
+        this.mapWidth = mapWidth;
+        this.mapHeight = mapHeight;
+        this.isTransparent = isTransparent;
+    }
+    computeOctantY(deltaX, deltaY, data) {
+        const startSlopes = [];
+        const endSlopes = [];
+        const minX = data.minX;
+        const maxX = data.maxX;
+        const minY = data.minY;
+        const maxY = data.maxY;
+        const originX = data.originX;
+        const originY = data.originY;
+        const isTransparent = this.isTransparent;
+        const isVisible = data.isVisible;
+        const setVisible = data.setVisible;
+        let iteration = 1;
+        let totalObstacles = 0;
+        let obstaclesInLastLine = 0;
+        let minSlope = 0;
+        let x;
+        let y;
+        let halfSlope;
+        let processedCell;
+        let visible;
+        let extended;
+        let centreSlope;
+        let startSlope;
+        let endSlope;
+        let previousEndSlope;
+        let cellTransparent = false;
+        let transparencyChecked;
+        for (y = originY + deltaY; y >= minY && y <= maxY; y += deltaY, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (processedCell = Math.floor(minSlope * iteration + 0.5), x = originX + (processedCell * deltaX); processedCell <= iteration && x >= minX && x <= maxX; x += deltaX, ++processedCell, previousEndSlope = endSlope) {
+                visible = true;
+                extended = false;
+                centreSlope = processedCell / iteration;
+                startSlope = previousEndSlope;
+                endSlope = centreSlope + halfSlope;
+                transparencyChecked = false;
+                if (obstaclesInLastLine > 0) {
+                    if (!(isVisible(x, y - deltaY) &&
+                        isTransparent(x, y - deltaY)) &&
+                        !(isVisible(x - deltaX, y - deltaY) &&
+                            isTransparent(x - deltaX, y - deltaY))) {
+                        visible = false;
+                    }
+                    else {
+                        for (var idx = 0; idx < obstaclesInLastLine && visible; ++idx) {
+                            if (startSlope <= endSlopes[idx] && endSlope >= startSlopes[idx]) {
+                                if (!transparencyChecked) {
+                                    cellTransparent = isTransparent(x, y);
+                                    transparencyChecked = true;
+                                }
+                                if (cellTransparent) {
+                                    if (centreSlope > startSlopes[idx] && centreSlope < endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                }
+                                else {
+                                    if (startSlope >= startSlopes[idx] && endSlope <= endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                    else {
+                                        if (startSlope < startSlopes[idx]) {
+                                            startSlopes[idx] = startSlope;
+                                        }
+                                        if (endSlope > endSlopes[idx]) {
+                                            endSlopes[idx] = endSlope;
+                                        }
+                                        extended = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (visible) {
+                    setVisible(x, y);
+                    if (!transparencyChecked) {
+                        cellTransparent = isTransparent(x, y);
+                    }
+                    if (!cellTransparent) {
+                        if (minSlope >= startSlope) {
+                            minSlope = endSlope;
+                        }
+                        else if (!extended) {
+                            startSlopes[totalObstacles] = startSlope;
+                            endSlopes[totalObstacles++] = endSlope;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    computeOctantX(deltaX, deltaY, data) {
+        const startSlopes = [];
+        const endSlopes = [];
+        const minX = data.minX;
+        const maxX = data.maxX;
+        const minY = data.minY;
+        const maxY = data.maxY;
+        const originX = data.originX;
+        const originY = data.originY;
+        const isTransparent = this.isTransparent;
+        const isVisible = data.isVisible;
+        const setVisible = data.setVisible;
+        let iteration = 1;
+        let totalObstacles = 0;
+        let obstaclesInLastLine = 0;
+        let minSlope = 0;
+        let x;
+        let y;
+        let halfSlope;
+        let processedCell;
+        let visible;
+        let extended;
+        let centreSlope;
+        let startSlope;
+        let endSlope;
+        let previousEndSlope;
+        let cellTransparent = false;
+        let transparencyChecked;
+        for (x = originX + deltaX; x >= minX && x <= maxX; x += deltaX, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (processedCell = Math.floor(minSlope * iteration + 0.5), y = originY + (processedCell * deltaY); processedCell <= iteration && y >= minY && y <= maxY; y += deltaY, ++processedCell, previousEndSlope = endSlope) {
+                visible = true;
+                extended = false;
+                centreSlope = processedCell / iteration;
+                startSlope = previousEndSlope;
+                endSlope = centreSlope + halfSlope;
+                transparencyChecked = false;
+                if (obstaclesInLastLine > 0) {
+                    if (!(isVisible(x - deltaX, y) &&
+                        isTransparent(x - deltaX, y)) &&
+                        !(isVisible(x - deltaX, y - deltaY) &&
+                            isTransparent(x - deltaX, y - deltaY))) {
+                        visible = false;
+                    }
+                    else {
+                        for (var idx = 0; idx < obstaclesInLastLine && visible; ++idx) {
+                            if (startSlope <= endSlopes[idx] && endSlope >= startSlopes[idx]) {
+                                if (!transparencyChecked) {
+                                    cellTransparent = isTransparent(x, y);
+                                    transparencyChecked = true;
+                                }
+                                if (cellTransparent) {
+                                    if (centreSlope > startSlopes[idx] && centreSlope < endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                }
+                                else {
+                                    if (startSlope >= startSlopes[idx] && endSlope <= endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                    else {
+                                        if (startSlope < startSlopes[idx]) {
+                                            startSlopes[idx] = startSlope;
+                                        }
+                                        if (endSlope > endSlopes[idx]) {
+                                            endSlopes[idx] = endSlope;
+                                        }
+                                        extended = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (visible) {
+                    setVisible(x, y);
+                    if (!transparencyChecked) {
+                        cellTransparent = isTransparent(x, y);
+                    }
+                    if (!cellTransparent) {
+                        if (minSlope >= startSlope) {
+                            minSlope = endSlope;
+                        }
+                        else if (!extended) {
+                            startSlopes[totalObstacles] = startSlope;
+                            endSlopes[totalObstacles++] = endSlope;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    setMapDimensions(mapWidth, mapHeight) {
+        this.mapWidth = mapWidth;
+        this.mapHeight = mapHeight;
+    }
+    compute(originX, originY, radius, isVisible, setVisible) {
+        setVisible(originX, originY);
+        const data = {
+            minX: Math.max(0, originX - radius),
+            minY: Math.max(0, originY - radius),
+            maxX: Math.min(this.mapWidth - 1, originX + radius),
+            maxY: Math.min(this.mapHeight - 1, originY + radius),
+            originX: originX,
+            originY: originY,
+            isVisible: isVisible,
+            setVisible: setVisible
+        };
+        this.computeOctantY(1, 1, data);
+        this.computeOctantX(1, 1, data);
+        this.computeOctantY(1, -1, data);
+        this.computeOctantX(1, -1, data);
+        this.computeOctantY(-1, 1, data);
+        this.computeOctantX(-1, 1, data);
+        this.computeOctantY(-1, -1, data);
+        this.computeOctantX(-1, -1, data);
+    }
+}
+exports.Mrpas = Mrpas;

package/dist/esm/index.d.ts

@@ -0,0 +1,13 @@
+export type IsTransparentFunc = (x: number, y: number) => boolean;
+export type IsVisibleFunc = (x: number, y: number) => boolean;
+export type SetVisibleFunc = (x: number, y: number) => void;
+export declare class Mrpas {
+    private mapWidth;
+    private mapHeight;
+    private readonly isTransparent;
+    constructor(mapWidth: number, mapHeight: number, isTransparent: IsTransparentFunc);
+    private computeOctantY;
+    private computeOctantX;
+    setMapDimensions(mapWidth: number, mapHeight: number): void;
+    compute(originX: number, originY: number, radius: number, isVisible: IsVisibleFunc, setVisible: SetVisibleFunc): void;
+}

package/dist/esm/index.js

@@ -0,0 +1,225 @@
+export class Mrpas {
+    mapWidth;
+    mapHeight;
+    isTransparent;
+    constructor(mapWidth, mapHeight, isTransparent) {
+        this.mapWidth = mapWidth;
+        this.mapHeight = mapHeight;
+        this.isTransparent = isTransparent;
+    }
+    computeOctantY(deltaX, deltaY, data) {
+        const startSlopes = [];
+        const endSlopes = [];
+        const minX = data.minX;
+        const maxX = data.maxX;
+        const minY = data.minY;
+        const maxY = data.maxY;
+        const originX = data.originX;
+        const originY = data.originY;
+        const isTransparent = this.isTransparent;
+        const isVisible = data.isVisible;
+        const setVisible = data.setVisible;
+        let iteration = 1;
+        let totalObstacles = 0;
+        let obstaclesInLastLine = 0;
+        let minSlope = 0;
+        let x;
+        let y;
+        let halfSlope;
+        let processedCell;
+        let visible;
+        let extended;
+        let centreSlope;
+        let startSlope;
+        let endSlope;
+        let previousEndSlope;
+        let cellTransparent = false;
+        let transparencyChecked;
+        for (y = originY + deltaY; y >= minY && y <= maxY; y += deltaY, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (processedCell = Math.floor(minSlope * iteration + 0.5), x = originX + (processedCell * deltaX); processedCell <= iteration && x >= minX && x <= maxX; x += deltaX, ++processedCell, previousEndSlope = endSlope) {
+                visible = true;
+                extended = false;
+                centreSlope = processedCell / iteration;
+                startSlope = previousEndSlope;
+                endSlope = centreSlope + halfSlope;
+                transparencyChecked = false;
+                if (obstaclesInLastLine > 0) {
+                    if (!(isVisible(x, y - deltaY) &&
+                        isTransparent(x, y - deltaY)) &&
+                        !(isVisible(x - deltaX, y - deltaY) &&
+                            isTransparent(x - deltaX, y - deltaY))) {
+                        visible = false;
+                    }
+                    else {
+                        for (var idx = 0; idx < obstaclesInLastLine && visible; ++idx) {
+                            if (startSlope <= endSlopes[idx] && endSlope >= startSlopes[idx]) {
+                                if (!transparencyChecked) {
+                                    cellTransparent = isTransparent(x, y);
+                                    transparencyChecked = true;
+                                }
+                                if (cellTransparent) {
+                                    if (centreSlope > startSlopes[idx] && centreSlope < endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                }
+                                else {
+                                    if (startSlope >= startSlopes[idx] && endSlope <= endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                    else {
+                                        if (startSlope < startSlopes[idx]) {
+                                            startSlopes[idx] = startSlope;
+                                        }
+                                        if (endSlope > endSlopes[idx]) {
+                                            endSlopes[idx] = endSlope;
+                                        }
+                                        extended = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (visible) {
+                    setVisible(x, y);
+                    if (!transparencyChecked) {
+                        cellTransparent = isTransparent(x, y);
+                    }
+                    if (!cellTransparent) {
+                        if (minSlope >= startSlope) {
+                            minSlope = endSlope;
+                        }
+                        else if (!extended) {
+                            startSlopes[totalObstacles] = startSlope;
+                            endSlopes[totalObstacles++] = endSlope;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    computeOctantX(deltaX, deltaY, data) {
+        const startSlopes = [];
+        const endSlopes = [];
+        const minX = data.minX;
+        const maxX = data.maxX;
+        const minY = data.minY;
+        const maxY = data.maxY;
+        const originX = data.originX;
+        const originY = data.originY;
+        const isTransparent = this.isTransparent;
+        const isVisible = data.isVisible;
+        const setVisible = data.setVisible;
+        let iteration = 1;
+        let totalObstacles = 0;
+        let obstaclesInLastLine = 0;
+        let minSlope = 0;
+        let x;
+        let y;
+        let halfSlope;
+        let processedCell;
+        let visible;
+        let extended;
+        let centreSlope;
+        let startSlope;
+        let endSlope;
+        let previousEndSlope;
+        let cellTransparent = false;
+        let transparencyChecked;
+        for (x = originX + deltaX; x >= minX && x <= maxX; x += deltaX, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (processedCell = Math.floor(minSlope * iteration + 0.5), y = originY + (processedCell * deltaY); processedCell <= iteration && y >= minY && y <= maxY; y += deltaY, ++processedCell, previousEndSlope = endSlope) {
+                visible = true;
+                extended = false;
+                centreSlope = processedCell / iteration;
+                startSlope = previousEndSlope;
+                endSlope = centreSlope + halfSlope;
+                transparencyChecked = false;
+                if (obstaclesInLastLine > 0) {
+                    if (!(isVisible(x - deltaX, y) &&
+                        isTransparent(x - deltaX, y)) &&
+                        !(isVisible(x - deltaX, y - deltaY) &&
+                            isTransparent(x - deltaX, y - deltaY))) {
+                        visible = false;
+                    }
+                    else {
+                        for (var idx = 0; idx < obstaclesInLastLine && visible; ++idx) {
+                            if (startSlope <= endSlopes[idx] && endSlope >= startSlopes[idx]) {
+                                if (!transparencyChecked) {
+                                    cellTransparent = isTransparent(x, y);
+                                    transparencyChecked = true;
+                                }
+                                if (cellTransparent) {
+                                    if (centreSlope > startSlopes[idx] && centreSlope < endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                }
+                                else {
+                                    if (startSlope >= startSlopes[idx] && endSlope <= endSlopes[idx]) {
+                                        visible = false;
+                                        break;
+                                    }
+                                    else {
+                                        if (startSlope < startSlopes[idx]) {
+                                            startSlopes[idx] = startSlope;
+                                        }
+                                        if (endSlope > endSlopes[idx]) {
+                                            endSlopes[idx] = endSlope;
+                                        }
+                                        extended = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (visible) {
+                    setVisible(x, y);
+                    if (!transparencyChecked) {
+                        cellTransparent = isTransparent(x, y);
+                    }
+                    if (!cellTransparent) {
+                        if (minSlope >= startSlope) {
+                            minSlope = endSlope;
+                        }
+                        else if (!extended) {
+                            startSlopes[totalObstacles] = startSlope;
+                            endSlopes[totalObstacles++] = endSlope;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    setMapDimensions(mapWidth, mapHeight) {
+        this.mapWidth = mapWidth;
+        this.mapHeight = mapHeight;
+    }
+    compute(originX, originY, radius, isVisible, setVisible) {
+        setVisible(originX, originY);
+        const data = {
+            minX: Math.max(0, originX - radius),
+            minY: Math.max(0, originY - radius),
+            maxX: Math.min(this.mapWidth - 1, originX + radius),
+            maxY: Math.min(this.mapHeight - 1, originY + radius),
+            originX: originX,
+            originY: originY,
+            isVisible: isVisible,
+            setVisible: setVisible
+        };
+        this.computeOctantY(1, 1, data);
+        this.computeOctantX(1, 1, data);
+        this.computeOctantY(1, -1, data);
+        this.computeOctantX(1, -1, data);
+        this.computeOctantY(-1, 1, data);
+        this.computeOctantX(-1, 1, data);
+        this.computeOctantY(-1, -1, data);
+        this.computeOctantX(-1, -1, data);
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -1,12 +1,29 @@
 {
   "name": "mrpas",
-  "version": "1.2.1",
+  "version": "2.1.0",
   "description": "A Field of View (FOV) computation algorithm.",
-  "main": "src/index.js",
-  "scripts": {},
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "watch": "tsc --watch -p tsconfig.esm.json"
+  },
   "repository": {
     "type": "git",
-    "url": "https://bitbucket.org/mingos/mrpas.git"
+    "url": "https://bitbucket.org/umbraprojekt/mrpas.git"
   },
   "keywords": [
     "fov",
@@ -14,5 +31,8 @@
   ],
   "author": "Dominik Marczuk <mingos.nospam@gmail.com> (http://dominikmarczuk.pl)",
   "license": "BSD-2-Clause",
-  "homepage": "https://bitbucket.org/mingos/mrpas"
+  "homepage": "https://bitbucket.org/mingos/mrpas",
+  "devDependencies": {
+    "typescript": "^7.0.2"
+  }
 }

package/.npmignore

@@ -1,3 +0,0 @@
-.idea
-*.iml
-node_modules

package/src/CHANGELOG.md

@@ -1,11 +0,0 @@
-# Changelog
-
-## 1.2.1 (2017-02-20)
-
-### Bugfixes
-
-* fixed iterator being incremented twice, causing incorrect FOV shape in ES5 version
-
-## 1.2.0 (2017-02-18)
-
-Initial release, based on C code available in [libtcod](https://bitbucket.org/libtcod/libtcod). Created ES5 and ES6 versions.