mrpas 2.0.0 → 2.1.1

package/README.md

@@ -17,11 +17,17 @@ Or grab the code from the [repository](https://bitbucket.org/umbraprojekt/mrpas)
 Instantiate a `Mrpas` object by passing it the map dimensions and a callback for determining map cell transparency:
 
 ```
-const Mrpas = require("mrpas").Mrpas;
+const { Mrpas } = require("mrpas");
 
 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
 
 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:

package/dist/cjs/index.js

@@ -0,0 +1,245 @@
+"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;
+        let firstCell;
+        let behindOpen = false;
+        let diagonalOpen;
+        for (y = originY + deltaY; y >= minY && y <= maxY; y += deltaY, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (firstCell = 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) {
+                    diagonalOpen = behindOpen;
+                    behindOpen = isVisible(x, y - deltaY) && isTransparent(x, y - deltaY);
+                    if (!behindOpen &&
+                        !(processedCell > firstCell
+                            ? diagonalOpen
+                            : 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;
+                        }
+                    }
+                }
+            }
+            if (minSlope > 1) {
+                break;
+            }
+        }
+    }
+    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;
+        let firstCell;
+        let behindOpen = false;
+        let diagonalOpen;
+        for (x = originX + deltaX; x >= minX && x <= maxX; x += deltaX, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (firstCell = 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) {
+                    diagonalOpen = behindOpen;
+                    behindOpen = isVisible(x - deltaX, y) && isTransparent(x - deltaX, y);
+                    if (!behindOpen &&
+                        !(processedCell > firstCell
+                            ? diagonalOpen
+                            : 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;
+                        }
+                    }
+                }
+            }
+            if (minSlope > 1) {
+                break;
+            }
+        }
+    }
+    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/{src → dist/esm}/index.d.ts

@@ -1,6 +1,6 @@
-export declare type IsTransparentFunc = (x: number, y: number) => boolean;
-export declare type IsVisibleFunc = (x: number, y: number) => boolean;
-export declare type SetVisibleFunc = (x: number, y: number) => void;
+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;

package/dist/esm/index.js

@@ -0,0 +1,241 @@
+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;
+        let firstCell;
+        let behindOpen = false;
+        let diagonalOpen;
+        for (y = originY + deltaY; y >= minY && y <= maxY; y += deltaY, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (firstCell = 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) {
+                    diagonalOpen = behindOpen;
+                    behindOpen = isVisible(x, y - deltaY) && isTransparent(x, y - deltaY);
+                    if (!behindOpen &&
+                        !(processedCell > firstCell
+                            ? diagonalOpen
+                            : 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;
+                        }
+                    }
+                }
+            }
+            if (minSlope > 1) {
+                break;
+            }
+        }
+    }
+    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;
+        let firstCell;
+        let behindOpen = false;
+        let diagonalOpen;
+        for (x = originX + deltaX; x >= minX && x <= maxX; x += deltaX, obstaclesInLastLine = totalObstacles, ++iteration) {
+            halfSlope = 0.5 / iteration;
+            previousEndSlope = -1;
+            for (firstCell = 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) {
+                    diagonalOpen = behindOpen;
+                    behindOpen = isVisible(x - deltaX, y) && isTransparent(x - deltaX, y);
+                    if (!behindOpen &&
+                        !(processedCell > firstCell
+                            ? diagonalOpen
+                            : 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;
+                        }
+                    }
+                }
+            }
+            if (minSlope > 1) {
+                break;
+            }
+        }
+    }
+    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,25 +1,41 @@
 {
   "name": "mrpas",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "A Field of View (FOV) computation algorithm.",
-  "main": "src/index.js",
+  "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": {
-    "watch": "tsc --watch",
-    "build": "tsc"
+    "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"
   },
-  "typings": "src/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "https://bitbucket.org/umbraprojekt/mrpas.git"
+    "url": "git+https://github.com/mingos777/mrpas.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mingos777/mrpas/issues"
   },
   "keywords": [
     "fov",
     "roguelike"
   ],
-  "author": "Dominik Marczuk <mingos.nospam@gmail.com> (http://dominikmarczuk.pl)",
+  "author": "Dominik Marczuk <mingos.nospam@gmail.com> (https://dominikmarczuk.pl)",
   "license": "BSD-2-Clause",
-  "homepage": "https://bitbucket.org/mingos/mrpas",
+  "homepage": "https://github.com/mingos777/mrpas",
   "devDependencies": {
-    "typescript": "^3.2.2"
+    "typescript": "^7.0.2"
   }
 }

package/CHANGELOG.md

@@ -1,20 +0,0 @@
-# Changelog
-
-## 2.0.0
-### Bugfixes
-* fixed iterator increment again
-* fixed floating point logic in determining initial processed cell per octant row/column
-### Modified features
-* refactored code for brevity and readability
-### New features
-* ported to TypeScript
-### API break
-* exported module is now named. Call `require("mrpas").Mrpas` to import.
-
-## 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.

package/src/index.js

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