From e29588d6e154dd6c53a15c1fd4312a463e76b922 Mon Sep 17 00:00:00 2001
From: Yann Ducrocq <yann@giween.com>
Date: Sun, 17 Feb 2013 12:03:06 +0100
Subject: [PATCH 01/20] _digCallback function fix

check if this._map[x] exists in the _digCallback function
---
 rot.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rot.js b/rot.js
index 0d847d64..bf4dce60 100644
--- a/rot.js
+++ b/rot.js
@@ -2048,6 +2048,7 @@ ROT.Map.Digger.prototype.create = function(callback) {
 
 ROT.Map.Digger.prototype._digCallback = function(x, y, value) {
 	if (value == 0 || value == 2) { /* empty */
+		if (!this._map[x]) this._map[x]=[];
 		this._map[x][y] = 0;
 		this._dug++;
 	} else { /* wall */

From 9813bdd0f665e16b713b5116c3e5be1199471e3c Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Wed, 7 Aug 2013 01:09:16 +0200
Subject: [PATCH 02/20] Added the first version of ASCII art image converter
 (from http://blog.nihilogic.dk/2008/03/jsascii.html).

---
 src/image/image.js   |   5 ++
 src/image/jsascii.js | 194 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 199 insertions(+)
 create mode 100644 src/image/image.js
 create mode 100644 src/image/jsascii.js

diff --git a/src/image/image.js b/src/image/image.js
new file mode 100644
index 00000000..81e22a68
--- /dev/null
+++ b/src/image/image.js
@@ -0,0 +1,5 @@
+/**
+ * @class Base image (as ASCII art) converter
+ */
+ROT.image = function() {
+};
\ No newline at end of file
diff --git a/src/image/jsascii.js b/src/image/jsascii.js
new file mode 100644
index 00000000..7af9886b
--- /dev/null
+++ b/src/image/jsascii.js
@@ -0,0 +1,194 @@
+/*
+ * jsAscii 0.1
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.nihilogic.dk/licenses/mit-license.txt]
+ */
+
+var jsAscii = (function() {
+
+	var aDefaultCharList = (" .,:;i1tfLCG08@").split("");
+	var aDefaultColorCharList = (" CGO08@").split("");
+	var strFont = "courier new";
+
+
+	// convert img element to ascii
+	function asciifyImage(oImg, oCanvasImg) 
+	{
+		var oCanvas = document.createElement("canvas");
+		if (!oCanvas.getContext) {
+			return;
+		}
+		var oCtx = oCanvas.getContext("2d");
+		if (!oCtx.getImageData) {
+			return;
+		}
+
+		var iScale = parseInt(oImg.getAttribute("asciiscale")) || 1;
+		var bColor = (oImg.getAttribute("asciicolor") == "true");
+		var bAlpha = (oImg.getAttribute("asciialpha") == "true");
+		var bBlock = (oImg.getAttribute("asciiblock") == "true");
+		var bInvert = (oImg.getAttribute("asciiinvert") == "true");
+		var strResolution = oImg.getAttribute("asciiresolution") || "medium";
+		var aCharList = oImg.getAttribute("asciichars") || 
+			(bColor ? aDefaultColorCharList : aDefaultCharList);
+
+		var fResolution = 0.5;
+		switch (strResolution) {
+			case "low" : 	fResolution = 0.25; break;
+			case "medium" : fResolution = 0.5; break;
+			case "high" : 	fResolution = 1; break;
+		}
+
+		var iWidth = Math.round(parseInt(oImg.offsetWidth) * fResolution);
+		var iHeight = Math.round(parseInt(oImg.offsetHeight) * fResolution);
+
+		oCanvas.width = iWidth;
+		oCanvas.height = iHeight;
+		oCanvas.style.display = "none";
+		oCanvas.style.width = iWidth;
+		oCanvas.style.height = iHeight;
+
+		oCtx.drawImage(oCanvasImg, 0, 0, iWidth, iHeight);
+		var oImgData = oCtx.getImageData(0, 0, iWidth, iHeight).data;
+	
+		var strChars = "";
+
+		for (var y=0;y<iHeight;y+=2) {
+			for (var x=0;x<iWidth;x++) {
+				var iOffset = (y*iWidth + x) * 4;
+	
+				var iRed = oImgData[iOffset];
+				var iGreen = oImgData[iOffset + 1];
+				var iBlue = oImgData[iOffset + 2];
+				var iAlpha = oImgData[iOffset + 3];
+	
+				if (iAlpha == 0) {
+					var iBrightIdx = 0;
+				} else {
+					var fBrightness = (0.3*iRed + 0.59*iGreen + 0.11*iBlue) / 255;
+					var iCharIdx = (aCharList.length-1) - Math.round(fBrightness * (aCharList.length-1));
+				}
+
+				if (bInvert) {
+					iCharIdx = (aCharList.length-1) - iCharIdx;
+				}
+				var strThisChar = aCharList[iCharIdx];
+
+				if (strThisChar == " ") 
+					strThisChar = "&nbsp;";
+
+				if (bColor) {
+					strChars += "<span style='"
+						+ "color:rgb("+iRed+","+iGreen+","+iBlue+");"
+						+ (bBlock ? "background-color:rgb("+iRed+","+iGreen+","+iBlue+");" : "")
+						+ (bAlpha ? "opacity:" + (iAlpha/255) + ";" : "")
+						+ "'>" + strThisChar + "</span>";
+				} else {
+					strChars += strThisChar;
+				}
+			}
+			strChars += "<br/>";
+		}
+	
+	
+		var fFontSize = (2/fResolution)*iScale;
+		var fLineHeight = (2/fResolution)*iScale;
+
+		// adjust letter-spacing for all combinations of scale and resolution to get it to fit the image width.
+		var fLetterSpacing = 0;
+		if (strResolution == "low") {
+			switch (iScale) {
+				case 1 : fLetterSpacing = -1; break;
+				case 2 : 
+				case 3 : fLetterSpacing = -2.1; break;
+				case 4 : fLetterSpacing = -3.1; break;
+				case 5 : fLetterSpacing = -4.15; break;
+			}
+		}
+		if (strResolution == "medium") {
+			switch (iScale) {
+				case 1 : fLetterSpacing = 0; break;
+				case 2 : fLetterSpacing = -1; break;
+				case 3 : fLetterSpacing = -1.04; break;
+				case 4 : 
+				case 5 : fLetterSpacing = -2.1; break;
+			}
+		}
+		if (strResolution == "high") {
+			switch (iScale) {
+				case 1 : 
+				case 2 : fLetterSpacing = 0; break;
+				case 3 : 
+				case 4 : 
+				case 5 : fLetterSpacing = -1; break;
+			}
+		}
+
+
+		// can't get a span or div to flow like an img element, but a table works?
+		var oAscii = document.createElement("table");
+		oAscii.innerHTML = "<tr><td>" + strChars + "</td></tr>";
+
+		if (oImg.style.backgroundColor) {
+			oAscii.rows[0].cells[0].style.backgroundColor = oImg.style.backgroundColor;
+			oAscii.rows[0].cells[0].style.color = oImg.style.color;
+		}
+
+		oAscii.cellSpacing = 0;
+		oAscii.cellPadding = 0;
+
+		var oStyle = oAscii.style;
+		oStyle.display = "inline";
+		oStyle.width = Math.round(iWidth/fResolution*iScale) + "px";
+		oStyle.height = Math.round(iHeight/fResolution*iScale) + "px";
+		oStyle.whiteSpace = "pre";
+		oStyle.margin = "0px";
+		oStyle.padding = "0px";
+		oStyle.letterSpacing = fLetterSpacing + "px";
+		oStyle.fontFamily = strFont;
+		oStyle.fontSize = fFontSize + "px";
+		oStyle.lineHeight = fLineHeight + "px";
+		oStyle.textAlign = "left";
+		oStyle.textDecoration = "none";
+
+		oImg.parentNode.replaceChild(oAscii, oImg);
+
+	}
+
+	// load the image file
+	function asciifyImageLoad(oImg)
+	{
+		var oCanvasImg = new Image();
+		oCanvasImg.src = oImg.src;
+		if (oCanvasImg.complete) {
+			asciifyImage(oImg, oCanvasImg);
+		} else {
+			oCanvasImg.onload = function() {
+				asciifyImage(oImg, oCanvasImg)
+			}
+		}
+	}
+
+	return function() {
+		var aImg = document.getElementsByTagName("img");
+		var aImages = [];
+		for (var i=0;i<aImg.length;i++) {
+			aImages[i] = aImg[i];
+		}
+
+		for (var i=0;i<aImages.length;i++) {
+			if (aImages[i].getAttribute("asciify") == "true") {
+				asciifyImageLoad(aImages[i]);
+			}
+		}
+	}
+	
+})();
+
+
+if (window.addEventListener) { 
+	window.addEventListener("load", jsAscii, false); 
+} else if (window.attachEvent) { 
+	window.attachEvent("onload", jsAscii); 
+}
+

From 805aea83da044006a8b152d7cb20a400c9d02787 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Fri, 9 Aug 2013 01:25:26 +0200
Subject: [PATCH 03/20] Start to create the Image class from jsascii code. And
 added into the "makefile" for rot.js .

---
 src/gen-rot.sh     |  1 +
 src/image/image.js | 11 +++++++++--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/gen-rot.sh b/src/gen-rot.sh
index a98ca5dd..e80242d6 100755
--- a/src/gen-rot.sh
+++ b/src/gen-rot.sh
@@ -40,6 +40,7 @@ lighting.js
 path/path.js
 path/dijkstra.js
 path/astar.js
+image/image.js
 "
 
 star() {
diff --git a/src/image/image.js b/src/image/image.js
index 81e22a68..d0ab5926 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -1,5 +1,12 @@
 /**
  * @class Base image (as ASCII art) converter
  */
-ROT.image = function() {
-};
\ No newline at end of file
+ROT.Image = function() {
+	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
+	this.aDefaultColorCharList = (" CGO08@").split("");
+	this.strFont = "courier new";
+};
+
+ROT.Image.prototype.get = function(xin, yin) {
+	console.log(888);
+}

From eeafcdf536cc6f293eb47e2b11e31709c536babf Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Fri, 9 Aug 2013 01:27:13 +0200
Subject: [PATCH 04/20] Added a directory with some examples (well it is more a
 working directory for check the rot.js ;) ).

---
 examples/rot.js    | 4743 ++++++++++++++++++++++++++++++++++++++++++++
 examples/test.html |   31 +
 2 files changed, 4774 insertions(+)
 create mode 100644 examples/rot.js
 create mode 100644 examples/test.html

diff --git a/examples/rot.js b/examples/rot.js
new file mode 100644
index 00000000..fcc2dc6d
--- /dev/null
+++ b/examples/rot.js
@@ -0,0 +1,4743 @@
+/*
+	This is rot.js, the ROguelike Toolkit in JavaScript.
+	Version 0.5~dev, generated on vie ago  9 01:23:35 CEST 2013.
+*/
+
+/**
+ * @namespace Top-level ROT namespace
+ */
+var ROT = {
+	/**
+	 * @returns {bool} Is rot.js supported by this browser?
+	 */
+	isSupported: function() {
+		return !!(document.createElement("canvas").getContext && Function.prototype.bind);
+	},
+
+	/** Default with for display and map generators */
+	DEFAULT_WIDTH: 80,
+	/** Default height for display and map generators */
+	DEFAULT_HEIGHT: 25,
+
+	/** Directional constants. Ordering is important! */
+	DIRS: {
+		"4": [
+			[ 0, -1],
+			[ 1,  0],
+			[ 0,  1],
+			[-1,  0]
+		],
+		"8": [
+			[ 0, -1],
+			[ 1, -1],
+			[ 1,  0],
+			[ 1,  1],
+			[ 0,  1],
+			[-1,  1],
+			[-1,  0],
+			[-1, -1]
+		],
+		"6": [
+			[-1, -1],
+			[ 1, -1],
+			[ 2,  0],
+			[ 1,  1],
+			[-1,  1],
+			[-2,  0]
+		]
+	},
+
+	/** Cancel key. */
+	VK_CANCEL: 3, 
+	/** Help key. */
+	VK_HELP: 6, 
+	/** Backspace key. */
+	VK_BACK_SPACE: 8, 
+	/** Tab key. */
+	VK_TAB: 9, 
+	/** 5 key on Numpad when NumLock is unlocked. Or on Mac, clear key which is positioned at NumLock key. */
+	VK_CLEAR: 12, 
+	/** Return/enter key on the main keyboard. */
+	VK_RETURN: 13, 
+	/** Reserved, but not used. */
+	VK_ENTER: 14, 
+	/** Shift key. */
+	VK_SHIFT: 16, 
+	/** Control key. */
+	VK_CONTROL: 17, 
+	/** Alt (Option on Mac) key. */
+	VK_ALT: 18, 
+	/** Pause key. */
+	VK_PAUSE: 19, 
+	/** Caps lock. */
+	VK_CAPS_LOCK: 20, 
+	/** Escape key. */
+	VK_ESCAPE: 27, 
+	/** Space bar. */
+	VK_SPACE: 32, 
+	/** Page Up key. */
+	VK_PAGE_UP: 33, 
+	/** Page Down key. */
+	VK_PAGE_DOWN: 34, 
+	/** End key. */
+	VK_END: 35, 
+	/** Home key. */
+	VK_HOME: 36, 
+	/** Left arrow. */
+	VK_LEFT: 37, 
+	/** Up arrow. */
+	VK_UP: 38, 
+	/** Right arrow. */
+	VK_RIGHT: 39, 
+	/** Down arrow. */
+	VK_DOWN: 40, 
+	/** Print Screen key. */
+	VK_PRINTSCREEN: 44, 
+	/** Ins(ert) key. */
+	VK_INSERT: 45, 
+	/** Del(ete) key. */
+	VK_DELETE: 46, 
+	/***/
+	VK_0: 48,
+	/***/
+	VK_1: 49,
+	/***/
+	VK_2: 50,
+	/***/
+	VK_3: 51,
+	/***/
+	VK_4: 52,
+	/***/
+	VK_5: 53,
+	/***/
+	VK_6: 54,
+	/***/
+	VK_7: 55,
+	/***/
+	VK_8: 56,
+	/***/
+	VK_9: 57,
+	/** Colon (:) key. Requires Gecko 15.0 */
+	VK_COLON: 58, 
+	/** Semicolon (;) key. */
+	VK_SEMICOLON: 59, 
+	/** Less-than (<) key. Requires Gecko 15.0 */
+	VK_LESS_THAN: 60, 
+	/** Equals (=) key. */
+	VK_EQUALS: 61, 
+	/** Greater-than (>) key. Requires Gecko 15.0 */
+	VK_GREATER_THAN: 62, 
+	/** Question mark (?) key. Requires Gecko 15.0 */
+	VK_QUESTION_MARK: 63, 
+	/** Atmark (@) key. Requires Gecko 15.0 */
+	VK_AT: 64, 
+	/***/
+	VK_A: 65,
+	/***/
+	VK_B: 66,
+	/***/
+	VK_C: 67,
+	/***/
+	VK_D: 68,
+	/***/
+	VK_E: 69,
+	/***/
+	VK_F: 70,
+	/***/
+	VK_G: 71,
+	/***/
+	VK_H: 72,
+	/***/
+	VK_I: 73,
+	/***/
+	VK_J: 74,
+	/***/
+	VK_K: 75,
+	/***/
+	VK_L: 76,
+	/***/
+	VK_M: 77,
+	/***/
+	VK_N: 78,
+	/***/
+	VK_O: 79,
+	/***/
+	VK_P: 80,
+	/***/
+	VK_Q: 81,
+	/***/
+	VK_R: 82,
+	/***/
+	VK_S: 83,
+	/***/
+	VK_T: 84,
+	/***/
+	VK_U: 85,
+	/***/
+	VK_V: 86,
+	/***/
+	VK_W: 87,
+	/***/
+	VK_X: 88,
+	/***/
+	VK_Y: 89,
+	/***/
+	VK_Z: 90,
+	/***/
+	VK_CONTEXT_MENU: 93,
+	/** 0 on the numeric keypad. */
+	VK_NUMPAD0: 96, 
+	/** 1 on the numeric keypad. */
+	VK_NUMPAD1: 97, 
+	/** 2 on the numeric keypad. */
+	VK_NUMPAD2: 98, 
+	/** 3 on the numeric keypad. */
+	VK_NUMPAD3: 99, 
+	/** 4 on the numeric keypad. */
+	VK_NUMPAD4: 100, 
+	/** 5 on the numeric keypad. */
+	VK_NUMPAD5: 101, 
+	/** 6 on the numeric keypad. */
+	VK_NUMPAD6: 102, 
+	/** 7 on the numeric keypad. */
+	VK_NUMPAD7: 103, 
+	/** 8 on the numeric keypad. */
+	VK_NUMPAD8: 104, 
+	/** 9 on the numeric keypad. */
+	VK_NUMPAD9: 105, 
+	/** * on the numeric keypad. */
+	VK_MULTIPLY: 106,
+	/** + on the numeric keypad. */
+	VK_ADD: 107, 
+	/***/
+	VK_SEPARATOR: 108,
+	/** - on the numeric keypad. */
+	VK_SUBTRACT: 109, 
+	/** Decimal point on the numeric keypad. */
+	VK_DECIMAL: 110, 
+	/** / on the numeric keypad. */
+	VK_DIVIDE: 111, 
+	/** F1 key. */
+	VK_F1: 112, 
+	/** F2 key. */
+	VK_F2: 113, 
+	/** F3 key. */
+	VK_F3: 114, 
+	/** F4 key. */
+	VK_F4: 115, 
+	/** F5 key. */
+	VK_F5: 116, 
+	/** F6 key. */
+	VK_F6: 117, 
+	/** F7 key. */
+	VK_F7: 118, 
+	/** F8 key. */
+	VK_F8: 119, 
+	/** F9 key. */
+	VK_F9: 120, 
+	/** F10 key. */
+	VK_F10: 121, 
+	/** F11 key. */
+	VK_F11: 122, 
+	/** F12 key. */
+	VK_F12: 123, 
+	/** F13 key. */
+	VK_F13: 124, 
+	/** F14 key. */
+	VK_F14: 125, 
+	/** F15 key. */
+	VK_F15: 126, 
+	/** F16 key. */
+	VK_F16: 127, 
+	/** F17 key. */
+	VK_F17: 128, 
+	/** F18 key. */
+	VK_F18: 129, 
+	/** F19 key. */
+	VK_F19: 130, 
+	/** F20 key. */
+	VK_F20: 131, 
+	/** F21 key. */
+	VK_F21: 132, 
+	/** F22 key. */
+	VK_F22: 133, 
+	/** F23 key. */
+	VK_F23: 134, 
+	/** F24 key. */
+	VK_F24: 135, 
+	/** Num Lock key. */
+	VK_NUM_LOCK: 144, 
+	/** Scroll Lock key. */
+	VK_SCROLL_LOCK: 145, 
+	/** Circumflex (^) key. Requires Gecko 15.0 */
+	VK_CIRCUMFLEX: 160, 
+	/** Exclamation (!) key. Requires Gecko 15.0 */
+	VK_EXCLAMATION: 161, 
+	/** Double quote () key. Requires Gecko 15.0 */
+	VK_DOUBLE_QUOTE: 162, 
+	/** Hash (#) key. Requires Gecko 15.0 */
+	VK_HASH: 163, 
+	/** Dollar sign ($) key. Requires Gecko 15.0 */
+	VK_DOLLAR: 164, 
+	/** Percent (%) key. Requires Gecko 15.0 */
+	VK_PERCENT: 165, 
+	/** Ampersand (&) key. Requires Gecko 15.0 */
+	VK_AMPERSAND: 166, 
+	/** Underscore (_) key. Requires Gecko 15.0 */
+	VK_UNDERSCORE: 167, 
+	/** Open parenthesis (() key. Requires Gecko 15.0 */
+	VK_OPEN_PAREN: 168, 
+	/** Close parenthesis ()) key. Requires Gecko 15.0 */
+	VK_CLOSE_PAREN: 169, 
+	/* Asterisk (*) key. Requires Gecko 15.0 */
+	VK_ASTERISK: 170,
+	/** Plus (+) key. Requires Gecko 15.0 */
+	VK_PLUS: 171, 
+	/** Pipe (|) key. Requires Gecko 15.0 */
+	VK_PIPE: 172, 
+	/** Hyphen-US/docs/Minus (-) key. Requires Gecko 15.0 */
+	VK_HYPHEN_MINUS: 173, 
+	/** Open curly bracket ({) key. Requires Gecko 15.0 */
+	VK_OPEN_CURLY_BRACKET: 174, 
+	/** Close curly bracket (}) key. Requires Gecko 15.0 */
+	VK_CLOSE_CURLY_BRACKET: 175, 
+	/** Tilde (~) key. Requires Gecko 15.0 */
+	VK_TILDE: 176, 
+	/** Comma (,) key. */
+	VK_COMMA: 188, 
+	/** Period (.) key. */
+	VK_PERIOD: 190, 
+	/** Slash (/) key. */
+	VK_SLASH: 191, 
+	/** Back tick (`) key. */
+	VK_BACK_QUOTE: 192, 
+	/** Open square bracket ([) key. */
+	VK_OPEN_BRACKET: 219, 
+	/** Back slash (\) key. */
+	VK_BACK_SLASH: 220, 
+	/** Close square bracket (]) key. */
+	VK_CLOSE_BRACKET: 221, 
+	/** Quote (''') key. */
+	VK_QUOTE: 222, 
+	/** Meta key on Linux, Command key on Mac. */
+	VK_META: 224, 
+	/** AltGr key on Linux. Requires Gecko 15.0 */
+	VK_ALTGR: 225, 
+	/** Windows logo key on Windows. Or Super or Hyper key on Linux. Requires Gecko 15.0 */
+	VK_WIN: 91, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_KANA: 21, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_HANGUL: 21, 
+	/** 英数 key on Japanese Mac keyboard. Requires Gecko 15.0 */
+	VK_EISU: 22, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_JUNJA: 23, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_FINAL: 24, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_HANJA: 25, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_KANJI: 25, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_CONVERT: 28, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_NONCONVERT: 29, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_ACCEPT: 30, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_MODECHANGE: 31, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_SELECT: 41, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_PRINT: 42, 
+	/** Linux support for this keycode was added in Gecko 4.0. */
+	VK_EXECUTE: 43, 
+	/** Linux support for this keycode was added in Gecko 4.0.	 */
+	VK_SLEEP: 95 
+};
+/**
+ * @namespace
+ * Contains text tokenization and breaking routines
+ */
+ROT.Text = {
+	RE_COLORS: /%([bc]){([^}]*)}/g,
+
+	/* token types */
+	TYPE_TEXT:		0,
+	TYPE_NEWLINE:	1,
+	TYPE_FG:		2,
+	TYPE_BG:		3,
+
+	/**
+	 * Measure size of a resulting text block
+	 */
+	measure: function(str, maxWidth) {
+		var result = {width:0, height:1};
+		var tokens = this.tokenize(str, maxWidth);
+		var lineWidth = 0;
+
+		for (var i=0;i<tokens.length;i++) {
+			var token = tokens[i];
+			switch (token.type) {
+				case this.TYPE_TEXT:
+					lineWidth += token.value.length;
+				break;
+
+				case this.TYPE_NEWLINE:
+					result.height++;
+					result.width = Math.max(result.width, lineWidth);
+					lineWidth = 0;
+				break;
+			}
+		}
+		result.width = Math.max(result.width, lineWidth);
+
+		return result;
+	},
+
+	/**
+	 * Convert string to a series of a formatting commands
+	 */
+	tokenize: function(str, maxWidth) {
+		var result = [];
+
+		/* first tokenization pass - split texts and color formatting commands */
+		var offset = 0;
+		str.replace(this.RE_COLORS, function(match, type, name, index) {
+			/* string before */
+			var part = str.substring(offset, index);
+			if (part.length) {
+				result.push({
+					type: ROT.Text.TYPE_TEXT,
+					value: part
+				});
+			}
+
+			/* color command */
+			result.push({
+				type: (type == "c" ? ROT.Text.TYPE_FG : ROT.Text.TYPE_BG),
+				value: name.trim()
+			});
+
+			offset = index + match.length;
+			return "";
+		});
+
+		/* last remaining part */
+		var part = str.substring(offset);
+		if (part.length) {
+			result.push({
+				type: ROT.Text.TYPE_TEXT,
+				value: part
+			});
+		}
+
+		return this._breakLines(result, maxWidth);
+	},
+
+	/* insert line breaks into first-pass tokenized data */
+	_breakLines: function(tokens, maxWidth) {
+		if (!maxWidth) { maxWidth = Infinity; };
+
+		var i = 0;
+		var lineLength = 0;
+		var lastTokenWithSpace = -1;
+
+		while (i < tokens.length) { /* take all text tokens, remove space, apply linebreaks */
+			var token = tokens[i];
+			if (token.type == ROT.Text.TYPE_NEWLINE) { /* reset */
+				lineLength = 0; 
+				lastTokenWithSpace = -1;
+			}
+			if (token.type != ROT.Text.TYPE_TEXT) { /* skip non-text tokens */
+				i++;
+				continue; 
+			}
+
+			/* remove spaces at the beginning of line */
+			while (lineLength == 0 && token.value.charAt(0) == " ") { token.value = token.value.substring(1); }
+
+			/* forced newline? insert two new tokens after this one */
+			var index = token.value.indexOf("\n");
+			if (index != -1) { 
+				token.value = this._breakInsideToken(tokens, i, index, true); 
+
+				/* if there are spaces at the end, we must remove them (we do not want the line too long) */
+				var arr = token.value.split("");
+				while (arr[arr.length-1] == " ") { arr.pop(); }
+				token.value = arr.join("");
+			}
+
+			/* token degenerated? */
+			if (!token.value.length) {
+				tokens.splice(i, 1);
+				continue;
+			}
+
+			if (lineLength + token.value.length > maxWidth) { /* line too long, find a suitable breaking spot */
+
+				/* is it possible to break within this token? */
+				var index = -1;
+				while (1) {
+					var nextIndex = token.value.indexOf(" ", index+1);
+					if (nextIndex == -1) { break; }
+					if (lineLength + nextIndex > maxWidth) { break; }
+					index = nextIndex;
+				}
+
+				if (index != -1) { /* break at space within this one */
+					token.value = this._breakInsideToken(tokens, i, index, true);
+				} else if (lastTokenWithSpace != -1) { /* is there a previous token where a break can occur? */
+					var token = tokens[lastTokenWithSpace];
+					var breakIndex = token.value.lastIndexOf(" ");
+					token.value = this._breakInsideToken(tokens, lastTokenWithSpace, breakIndex, true);
+					i = lastTokenWithSpace;
+				} else { /* force break in this token */
+					token.value = this._breakInsideToken(tokens, i, maxWidth-lineLength, false);
+				}
+
+			} else { /* line not long, continue */
+				lineLength += token.value.length;
+				if (token.value.indexOf(" ") != -1) { lastTokenWithSpace = i; }
+			}
+			
+			i++; /* advance to next token */
+		}
+
+
+		tokens.push({type: ROT.Text.TYPE_NEWLINE}); /* insert fake newline to fix the last text line */
+
+		/* remove trailing space from text tokens before newlines */
+		var lastTextToken = null;
+		for (var i=0;i<tokens.length;i++) {
+			var token = tokens[i];
+			switch (token.type) {
+				case ROT.Text.TYPE_TEXT: lastTextToken = token; break;
+				case ROT.Text.TYPE_NEWLINE: 
+					if (lastTextToken) { /* remove trailing space */
+						var arr = lastTextToken.value.split("");
+						while (arr[arr.length-1] == " ") { arr.pop(); }
+						lastTextToken.value = arr.join("");
+					}
+					lastTextToken = null;
+				break;
+			}
+		}
+
+		tokens.pop(); /* remove fake token */
+
+		return tokens;
+	},
+
+	/**
+	 * Create new tokens and insert them into the stream
+	 * @param {object[]} tokens
+	 * @param {int} tokenIndex Token being processed
+	 * @param {int} breakIndex Index within current token's value
+	 * @param {bool} removeBreakChar Do we want to remove the breaking character?
+	 * @returns {string} remaining unbroken token value
+	 */
+	_breakInsideToken: function(tokens, tokenIndex, breakIndex, removeBreakChar) {
+		var newBreakToken = {
+			type: ROT.Text.TYPE_NEWLINE
+		}
+		var newTextToken = {
+			type: ROT.Text.TYPE_TEXT,
+			value: tokens[tokenIndex].value.substring(breakIndex + (removeBreakChar ? 1 : 0))
+		}
+		tokens.splice(tokenIndex+1, 0, newBreakToken, newTextToken);
+		return tokens[tokenIndex].value.substring(0, breakIndex);
+	}
+}
+/**
+ * @returns {any} Randomly picked item, null when length=0
+ */
+Array.prototype.random = function() {
+	if (!this.length) { return null; }
+	return this[Math.floor(ROT.RNG.getUniform() * this.length)];
+}
+
+/**
+ * @returns {array} New array with randomized items
+ * FIXME destroys this!
+ */
+Array.prototype.randomize = function() {
+	var result = [];
+	while (this.length) {
+		var index = this.indexOf(this.random());
+		result.push(this.splice(index, 1)[0]);
+	}
+	return result;
+}
+/**
+ * Always positive modulus
+ * @param {int} n Modulus
+ * @returns {int} this modulo n
+ */
+Number.prototype.mod = function(n) {
+	return ((this%n)+n)%n;
+}
+/**
+ * @returns {string} First letter capitalized
+ */
+String.prototype.capitalize = function() {
+	return this.charAt(0).toUpperCase() + this.substring(1);
+}
+
+/** 
+ * Left pad
+ * @param {string} [character="0"]
+ * @param {int} [count=2]
+ */
+String.prototype.lpad = function(character, count) {
+	var ch = character || "0";
+	var cnt = count || 2;
+
+	var s = "";
+	while (s.length < (cnt - this.length)) { s += ch; }
+	s = s.substring(0, cnt-this.length);
+	return s+this;
+}
+
+/** 
+ * Right pad
+ * @param {string} [character="0"]
+ * @param {int} [count=2]
+ */
+String.prototype.rpad = function(character, count) {
+	var ch = character || "0";
+	var cnt = count || 2;
+
+	var s = "";
+	while (s.length < (cnt - this.length)) { s += ch; }
+	s = s.substring(0, cnt-this.length);
+	return this+s;
+}
+
+/**
+ * Format a string in a flexible way. Scans for %s strings and replaces them with arguments. List of patterns is modifiable via String.format.map.
+ * @param {string} template
+ * @param {any} [argv]
+ */
+String.format = function(template) {
+	var map = String.format.map;
+	var args = Array.prototype.slice.call(arguments, 1);
+
+	var replacer = function(match, group1, group2, index) {
+		if (template.charAt(index-1) == "%") { return match.substring(1); }
+		if (!args.length) { return match; }
+		var obj = args[0];
+
+		var group = group1 || group2;
+		var parts = group.split(",");
+		var name = parts.shift();
+		var method = map[name.toLowerCase()];
+		if (!method) { return match; }
+
+		var obj = args.shift();
+		var replaced = obj[method].apply(obj, parts);
+
+		var first = name.charAt(0);
+		if (first != first.toLowerCase()) { replaced = replaced.capitalize(); }
+
+		return replaced;
+	}
+	return template.replace(/%(?:([a-z]+)|(?:{([^}]+)}))/gi, replacer);
+}
+
+String.format.map = {
+	"s": "toString"
+}
+
+/**
+ * Convenience shortcut to String.format(this)
+ */
+String.prototype.format = function() {
+	var args = Array.prototype.slice.call(arguments);
+	args.unshift(this);
+	return String.format.apply(String, args);
+}
+
+if (!Object.create) {  
+	/**
+	 * ES5 Object.create
+	 */
+	Object.create = function(o) {  
+		var tmp = function() {};
+		tmp.prototype = o;
+		return new tmp();
+	};  
+}  
+/**
+ * Sets prototype of this function to an instance of parent function
+ * @param {function} parent
+ */
+Function.prototype.extend = function(parent) {
+	this.prototype = Object.create(parent.prototype);
+	this.prototype.constructor = this;
+	return this;
+}
+/**
+ * @class Visual map display
+ * @param {object} [options]
+ * @param {int} [options.width=ROT.DEFAULT_WIDTH]
+ * @param {int} [options.height=ROT.DEFAULT_HEIGHT]
+ * @param {int} [options.fontSize=15]
+ * @param {string} [options.fontFamily="monospace"]
+ * @param {string} [options.fontStyle=""] bold/italic/none/both
+ * @param {string} [options.fg="#ccc"]
+ * @param {string} [options.bg="#000"]
+ * @param {int} [options.fps=25]
+ * @param {float} [options.spacing=1]
+ * @param {float} [options.border=0]
+ * @param {string} [options.layout="rect"]
+ */
+ROT.Display = function(options) {
+	var canvas = document.createElement("canvas");
+	this._context = canvas.getContext("2d");
+	this._data = {};
+	this._dirty = false; /* false = nothing, true = all, object = dirty cells */
+	this._options = {};
+	this._backend = null;
+	
+	var defaultOptions = {
+		width: ROT.DEFAULT_WIDTH,
+		height: ROT.DEFAULT_HEIGHT,
+		layout: "rect",
+		fontSize: 15,
+		fps: 25,
+		spacing: 1,
+		border: 0,
+		fontFamily: "monospace",
+		fontStyle: "",
+		fg: "#ccc",
+		bg: "#000"
+	};
+	for (var p in options) { defaultOptions[p] = options[p]; }
+	this.setOptions(defaultOptions);
+	this.DEBUG = this.DEBUG.bind(this);
+	
+	this._interval = setInterval(this._tick.bind(this), 1000/this._options.fps);
+}
+
+/**
+ * Debug helper, ideal as a map generator callback. Always bound to this.
+ * @param {int} x
+ * @param {int} y
+ * @param {int} what
+ */
+ROT.Display.prototype.DEBUG = function(x, y, what) {
+	var colors = [this._options.bg, this._options.fg];
+	this.draw(x, y, null, null, colors[what % colors.length]);
+}
+
+/**
+ * Clear the whole display (cover it with background color)
+ */
+ROT.Display.prototype.clear = function() {
+	this._data = {};
+	this._dirty = true;
+}
+
+/**
+ * @see ROT.Display
+ */
+ROT.Display.prototype.setOptions = function(options) {
+	for (var p in options) { this._options[p] = options[p]; }
+	if (options.width || options.height || options.fontSize || options.fontFamily || options.spacing || options.layout) {
+		if (options.layout) { 
+			this._backend = new ROT.Display[options.layout.capitalize()](this._context);
+		}
+
+		var font = (this._options.fontStyle ? this._options.fontStyle + " " : "") + this._options.fontSize + "px " + this._options.fontFamily;
+		this._context.font = font;
+		this._backend.compute(this._options);
+		this._context.font = font;
+		this._context.textAlign = "center";
+		this._context.textBaseline = "middle";
+		this._dirty = true;
+	}
+	return this;
+}
+
+/**
+ * Returns currently set options
+ * @returns {object} Current options object 
+ */
+ROT.Display.prototype.getOptions = function() {
+	return this._options;
+}
+
+/**
+ * Returns the DOM node of this display
+ * @returns {node} DOM node
+ */
+ROT.Display.prototype.getContainer = function() {
+	return this._context.canvas;
+}
+
+/**
+ * Compute the maximum width/height to fit into a set of given constraints
+ * @param {int} availWidth Maximum allowed pixel width
+ * @param {int} availHeight Maximum allowed pixel height
+ * @returns {int[2]} cellWidth,cellHeight
+ */
+ROT.Display.prototype.computeSize = function(availWidth, availHeight) {
+	return this._backend.computeSize(availWidth, availHeight, this._options);
+}
+
+/**
+ * Compute the maximum font size to fit into a set of given constraints
+ * @param {int} availWidth Maximum allowed pixel width
+ * @param {int} availHeight Maximum allowed pixel height
+ * @returns {int} fontSize
+ */
+ROT.Display.prototype.computeFontSize = function(availWidth, availHeight) {
+	return this._backend.computeFontSize(availWidth, availHeight, this._options);
+}
+
+/**
+ * Convert a DOM event (mouse or touch) to map coordinates. Uses first touch for multi-touch.
+ * @param {Event} e event
+ * @returns {int[2]} -1 for values outside of the canvas
+ */
+ROT.Display.prototype.eventToPosition = function(e) {
+	if (e.touches) {
+		var x = e.touches[0].clientX;
+		var y = e.touches[0].clientY;
+	} else {
+		var x = e.clientX;
+		var y = e.clientY;
+	}
+
+	var rect = this._context.canvas.getBoundingClientRect();
+	x -= rect.left;
+	y -= rect.top;
+	
+	if (x < 0 || y < 0 || x >= this._context.canvas.width || y >= this._context.canvas.height) { return [-1, -1]; }
+
+	return this._backend.eventToPosition(x, y);
+}
+
+/**
+ * @param {int} x
+ * @param {int} y
+ * @param {string} ch 
+ * @param {string} [fg] foreground color
+ * @param {string} [bg] background color
+ */
+ROT.Display.prototype.draw = function(x, y, ch, fg, bg) {
+	if (!fg) { fg = this._options.fg; }
+	if (!bg) { bg = this._options.bg; }
+	this._data[x+","+y] = [x, y, ch, fg, bg];
+	
+	if (this._dirty === true) { return; } /* will already redraw everything */
+	if (!this._dirty) { this._dirty = {}; } /* first! */
+	this._dirty[x+","+y] = true;
+}
+
+/**
+ * Draws a text at given position. Optionally wraps at a maximum length. Currently does not work with hex layout.
+ * @param {int} x
+ * @param {int} y
+ * @param {string} text May contain color/background format specifiers, %c{name}/%b{name}, both optional. %c{}/%b{} resets to default.
+ * @param {int} [maxWidth] wrap at what width?
+ * @returns {int} lines drawn
+ */
+ROT.Display.prototype.drawText = function(x, y, text, maxWidth) {
+	var fg = null;
+	var bg = null;
+	var cx = x;
+	var cy = y;
+	var lines = 1;
+	if (!maxWidth) { maxWidth = this._options.width-x; }
+
+	var tokens = ROT.Text.tokenize(text, maxWidth);
+
+	while (tokens.length) { /* interpret tokenized opcode stream */
+		var token = tokens.shift();
+		switch (token.type) {
+			case ROT.Text.TYPE_TEXT:
+				for (var i=0;i<token.value.length;i++) {
+					this.draw(cx++, cy, token.value.charAt(i), fg, bg);
+				}
+			break;
+
+			case ROT.Text.TYPE_FG:
+				fg = token.value || null;
+			break;
+
+			case ROT.Text.TYPE_BG:
+				bg = token.value || null;
+			break;
+
+			case ROT.Text.TYPE_NEWLINE:
+				cx = x;
+				cy++;
+				lines++
+			break;
+		}
+	}
+
+	return lines;
+}
+
+/**
+ * Timer tick: update dirty parts
+ */
+ROT.Display.prototype._tick = function() {
+	if (!this._dirty) { return; }
+
+	if (this._dirty === true) { /* draw all */
+		this._context.fillStyle = this._options.bg;
+		this._context.fillRect(0, 0, this._context.canvas.width, this._context.canvas.height);
+
+		for (var id in this._data) { /* redraw cached data */
+			this._draw(id, false);
+		}
+
+	} else { /* draw only dirty */
+		for (var key in this._dirty) {
+			this._draw(key, true);
+		}
+	}
+
+	this._dirty = false;
+}
+
+/**
+ * @param {string} key What to draw
+ * @param {bool} clearBefore Is it necessary to clean before?
+ */
+ROT.Display.prototype._draw = function(key, clearBefore) {
+	var data = this._data[key];
+	if (data[4] != this._options.bg) { clearBefore = true; }
+
+	this._backend.draw(data, clearBefore);
+}
+/**
+ * @class Abstract display backend module
+ * @private
+ */
+ROT.Display.Backend = function(context) {
+	this._context = context;
+}
+
+ROT.Display.Backend.prototype.compute = function(options) {
+}
+
+ROT.Display.Backend.prototype.draw = function(data, clearBefore) {
+}
+
+ROT.Display.Backend.prototype.computeSize = function(availWidth, availHeight) {
+}
+
+ROT.Display.Backend.prototype.computeFontSize = function(availWidth, availHeight) {
+}
+
+ROT.Display.Backend.prototype.eventToPosition = function(x, y) {
+}
+/**
+ * @class Rectangular backend
+ * @private
+ */
+ROT.Display.Rect = function(context) {
+	ROT.Display.Backend.call(this, context);
+	
+	this._spacingX = 0;
+	this._spacingY = 0;
+	this._canvasCache = {};
+	this._options = {};
+}
+ROT.Display.Rect.extend(ROT.Display.Backend);
+
+ROT.Display.Rect.cache = false;
+
+ROT.Display.Rect.prototype.compute = function(options) {
+	this._canvasCache = {};
+	this._options = options;
+
+	var charWidth = Math.ceil(this._context.measureText("W").width);
+	this._spacingX = Math.ceil(options.spacing * charWidth);
+	this._spacingY = Math.ceil(options.spacing * options.fontSize);
+	this._context.canvas.width = options.width * this._spacingX;
+	this._context.canvas.height = options.height * this._spacingY;
+}
+
+ROT.Display.Rect.prototype.draw = function(data, clearBefore) {
+	if (this.constructor.cache) {
+		this._drawWithCache(data, clearBefore);
+	} else {
+		this._drawNoCache(data, clearBefore);
+	}
+}
+
+ROT.Display.Rect.prototype._drawWithCache = function(data, clearBefore) {
+	var x = data[0];
+	var y = data[1];
+	var ch = data[2];
+	var fg = data[3];
+	var bg = data[4];
+
+	var hash = ""+ch+fg+bg;
+	if (hash in this._canvasCache) {
+		var canvas = this._canvasCache[hash];
+	} else {
+		var b = this._options.border;
+		var canvas = document.createElement("canvas");
+		var ctx = canvas.getContext("2d");
+		canvas.width = this._spacingX;
+		canvas.height = this._spacingY;
+		ctx.fillStyle = bg;
+		ctx.fillRect(b, b, canvas.width-b, canvas.height-b);
+		
+		if (ch) {
+			ctx.fillStyle = fg;
+			ctx.font = this._context.font;
+			ctx.textAlign = "center";
+			ctx.textBaseline = "middle";
+			ctx.fillText(ch, this._spacingX/2, this._spacingY/2);
+		}
+		this._canvasCache[hash] = canvas;
+	}
+	
+	this._context.drawImage(canvas, x*this._spacingX, y*this._spacingY);
+}
+
+ROT.Display.Rect.prototype._drawNoCache = function(data, clearBefore) {
+	var x = data[0];
+	var y = data[1];
+	var ch = data[2];
+	var fg = data[3];
+	var bg = data[4];
+
+	if (clearBefore) { 
+		var b = this._options.border;
+		this._context.fillStyle = bg;
+		this._context.fillRect(x*this._spacingX + b, y*this._spacingY + b, this._spacingX - b, this._spacingY - b);
+	}
+	
+	if (!ch) { return; }
+
+	this._context.fillStyle = fg;
+	this._context.fillText(ch, (x+0.5) * this._spacingX, (y+0.5) * this._spacingY);
+}
+
+ROT.Display.Rect.prototype.computeSize = function(availWidth, availHeight) {
+	var width = Math.floor(availWidth / this._spacingX);
+	var height = Math.floor(availHeight / this._spacingY);
+	return [width, height];
+}
+
+ROT.Display.Rect.prototype.computeFontSize = function(availWidth, availHeight) {
+	var boxWidth = Math.floor(availWidth / this._options.width);
+	var boxHeight = Math.floor(availHeight / this._options.height);
+
+	/* compute char ratio */
+	var oldFont = this._context.font;
+	this._context.font = "100px " + this._options.fontFamily;
+	var width = Math.ceil(this._context.measureText("W").width);
+	this._context.font = oldFont;
+	var ratio = width / 100;
+		
+	var widthFraction = ratio * boxHeight / boxWidth;
+	if (widthFraction > 1) { /* too wide with current aspect ratio */
+		boxHeight = Math.floor(boxHeight / widthFraction);
+	}
+	return Math.floor(boxHeight / this._options.spacing);
+}
+
+ROT.Display.Rect.prototype.eventToPosition = function(x, y) {
+	return [Math.floor(x/this._spacingX), Math.floor(y/this._spacingY)];
+}
+/**
+ * @class Hexagonal backend
+ * @private
+ */
+ROT.Display.Hex = function(context) {
+	ROT.Display.Backend.call(this, context);
+
+	this._spacingX = 0;
+	this._spacingY = 0;
+	this._hexSize = 0;
+	this._options = {};
+}
+ROT.Display.Hex.extend(ROT.Display.Backend);
+
+ROT.Display.Hex.prototype.compute = function(options) {
+	this._options = options;
+
+	var charWidth = Math.ceil(this._context.measureText("W").width);
+	this._hexSize = Math.floor(options.spacing * (options.fontSize + charWidth/Math.sqrt(3)) / 2);
+	this._spacingX = this._hexSize * Math.sqrt(3) / 2;
+	this._spacingY = this._hexSize * 1.5;
+	this._context.canvas.width = Math.ceil( (options.width + 1) * this._spacingX );
+	this._context.canvas.height = Math.ceil( (options.height - 1) * this._spacingY + 2*this._hexSize );
+}
+
+ROT.Display.Hex.prototype.draw = function(data, clearBefore) {
+	var x = data[0];
+	var y = data[1];
+	var ch = data[2];
+	var fg = data[3];
+	var bg = data[4];
+
+	var cx = (x+1) * this._spacingX;
+	var cy = y * this._spacingY + this._hexSize;
+
+	if (clearBefore) { 
+		this._context.fillStyle = bg;
+		this._fill(cx, cy);
+	}
+	
+	if (!ch) { return; }
+
+	this._context.fillStyle = fg;
+	this._context.fillText(ch, cx, cy);
+}
+
+
+ROT.Display.Hex.prototype.computeSize = function(availWidth, availHeight) {
+	var width = Math.floor(availWidth / this._spacingX) - 1;
+	var height = Math.floor((availHeight - 2*this._hexSize) / this._spacingY + 1);
+	return [width, height];
+}
+
+ROT.Display.Hex.prototype.computeFontSize = function(availWidth, availHeight) {
+	var hexSizeWidth = 2*availWidth / ((this._options.width+1) * Math.sqrt(3)) - 1;
+	var hexSizeHeight = availHeight / (2 + 1.5*(this._options.height-1));
+	var hexSize = Math.min(hexSizeWidth, hexSizeHeight);
+
+	/* compute char ratio */
+	var oldFont = this._context.font;
+	this._context.font = "100px " + this._options.fontFamily;
+	var width = Math.ceil(this._context.measureText("W").width);
+	this._context.font = oldFont;
+	var ratio = width / 100;
+
+	hexSize = Math.floor(hexSize)+1; /* closest larger hexSize */
+
+	var fontSize = 2*hexSize / (this._options.spacing * (1 + ratio / Math.sqrt(3)));
+
+	/* closest smaller fontSize */
+	return Math.ceil(fontSize)-1;
+}
+
+ROT.Display.Hex.prototype.eventToPosition = function(x, y) {
+	var height = this._context.canvas.height / this._options.height;
+	y = Math.floor(y/height);
+	
+	if (y.mod(2)) { /* odd row */
+		x -= this._spacingX;
+		x = 1 + 2*Math.floor(x/(2*this._spacingX));
+	} else {
+		x = 2*Math.floor(x/(2*this._spacingX));
+	}
+	
+	return [x, y];
+}
+
+ROT.Display.Hex.prototype._fill = function(cx, cy) {
+	var a = this._hexSize;
+	var b = this._options.border;
+	
+	this._context.beginPath();
+	this._context.moveTo(cx, cy-a+b);
+	this._context.lineTo(cx + this._spacingX - b, cy-a/2+b);
+	this._context.lineTo(cx + this._spacingX - b, cy+a/2-b);
+	this._context.lineTo(cx, cy+a-b);
+	this._context.lineTo(cx - this._spacingX + b, cy+a/2-b);
+	this._context.lineTo(cx - this._spacingX + b, cy-a/2+b);
+	this._context.lineTo(cx, cy-a+b);
+	this._context.fill();
+}
+/**
+ * @namespace
+ * This code is an implementation of Alea algorithm; (C) 2010 Johannes Baagøe.
+ * Alea is licensed according to the http://en.wikipedia.org/wiki/MIT_License.
+ */
+ROT.RNG = {
+	/**
+	 * @returns {number} 
+	 */
+	getSeed: function() {
+		return this._seed;
+	},
+
+	/**
+	 * @param {number} seed Seed the number generator
+	 */
+	setSeed: function(seed) {
+		seed = (seed < 1 ? 1/seed : seed);
+
+		this._seed = seed;
+		this._s0 = (seed >>> 0) * this._frac;
+
+		seed = (seed*69069 + 1) >>> 0;
+		this._s1 = seed * this._frac;
+
+		seed = (seed*69069 + 1) >>> 0;
+		this._s2 = seed * this._frac;
+
+		this._c = 1;
+		return this;
+	},
+
+	/**
+	 * @returns {float} Pseudorandom value [0,1), uniformly distributed
+	 */
+	getUniform: function() {
+		var t = 2091639 * this._s0 + this._c * this._frac;
+		this._s0 = this._s1;
+		this._s1 = this._s2;
+		this._c = t | 0;
+		this._s2 = t - this._c;
+		return this._s2;
+	},
+
+	/**
+	 * @param {float} [mean=0] Mean value
+	 * @param {float} [stddev=1] Standard deviation. ~95% of the absolute values will be lower than 2*stddev.
+	 * @returns {float} A normally distributed pseudorandom value
+	 */
+	getNormal: function(mean, stddev) {
+		do {
+			var u = 2*this.getUniform()-1;
+			var v = 2*this.getUniform()-1;
+			var r = u*u + v*v;
+		} while (r > 1 || r == 0);
+
+		var gauss = u * Math.sqrt(-2*Math.log(r)/r);
+		return (mean || 0) + gauss*(stddev || 1);
+	},
+
+	/**
+	 * @returns {int} Pseudorandom value [1,100] inclusive, uniformly distributed
+	 */
+	getPercentage: function() {
+		return 1 + Math.floor(this.getUniform()*100);
+	},
+	
+	/**
+	 * @param {object} data key=whatever, value=weight (relative probability)
+	 * @returns {string} whatever
+	 */
+	getWeightedValue: function(data) {
+		var avail = [];
+		var total = 0;
+		
+		for (var id in data) {
+			total += data[id];
+		}
+		var random = Math.floor(this.getUniform()*total);
+		
+		var part = 0;
+		for (var id in data) {
+			part += data[id];
+			if (random < part) { return id; }
+		}
+		
+		return null;
+	},
+
+	/**
+	 * Get RNG state. Useful for storing the state and re-setting it via setState.
+	 * @returns {?} Internal state
+	 */
+	getState: function() {
+		return [this._s0, this._s1, this._s2, this._c];
+	},
+
+	/**
+	 * Set a previously retrieved state.
+	 * @param {?} state
+	 */
+	setState: function(state) {
+		this._s0 = state[0];
+		this._s1 = state[1];
+		this._s2 = state[2];
+		this._c  = state[3];
+		return this;
+	},
+
+	_s0: 0,
+	_s1: 0,
+	_s2: 0,
+	_c: 0,
+	_frac: 2.3283064365386963e-10 /* 2^-32 */
+}
+
+ROT.RNG.setSeed(Date.now());
+/**
+ * @class (Markov process)-based string generator. 
+ * Copied from a <a href="http://www.roguebasin.roguelikedevelopment.org/index.php?title=Names_from_a_high_order_Markov_Process_and_a_simplified_Katz_back-off_scheme">RogueBasin article</a>. 
+ * Offers configurable order and prior.
+ * @param {object} [options]
+ * @param {bool} [options.words=false] Use word mode?
+ * @param {int} [options.order=3]
+ * @param {float} [options.prior=0.001]
+ */
+ROT.StringGenerator = function(options) {
+	this._options = {
+		words: false,
+		order: 3,
+		prior: 0.001
+	}
+	for (var p in options) { this._options[p] = options[p]; }
+
+	this._boundary = String.fromCharCode(0);
+	this._suffix = this._boundary;
+	this._prefix = [];
+	for (var i=0;i<this._options.order;i++) { this._prefix.push(this._boundary); }
+
+	this._priorValues = {};
+	this._priorValues[this._boundary] = this._options.prior;
+
+	this._data = {};
+}
+
+/**
+ * Remove all learning data
+ */
+ROT.StringGenerator.prototype.clear = function() {
+	this._data = {};
+	this._priorValues = {};
+}
+
+/**
+ * @returns {string} Generated string
+ */
+ROT.StringGenerator.prototype.generate = function() {
+	var result = [this._sample(this._prefix)];
+	while (result[result.length-1] != this._boundary) {
+		result.push(this._sample(result));
+	}
+	return this._join(result.slice(0, -1));
+}
+
+/**
+ * Observe (learn) a string from a training set
+ */
+ROT.StringGenerator.prototype.observe = function(string) {
+	var tokens = this._split(string);
+
+	for (var i=0; i<tokens.length; i++) {
+		this._priorValues[tokens[i]] = this._options.prior;
+	}
+
+	tokens = this._prefix.concat(tokens).concat(this._suffix); /* add boundary symbols */
+
+	for (var i=this._options.order; i<tokens.length; i++) {
+		var context = tokens.slice(i-this._options.order, i);
+		var event = tokens[i];
+		for (var j=0; j<context.length; j++) {
+			var subcontext = context.slice(j);
+			this._observeEvent(subcontext, event);
+		}
+	}
+}
+
+ROT.StringGenerator.prototype.getStats = function() {
+	var parts = [];
+
+	var priorCount = 0;
+	for (var p in this._priorValues) { priorCount++; }
+	priorCount--; /* boundary */
+	parts.push("distinct samples: " + priorCount);
+
+	var dataCount = 0;
+	var eventCount = 0;
+	for (var p in this._data) { 
+		dataCount++; 
+		for (var key in this._data[p]) {
+			eventCount++;
+		}
+	}
+	parts.push("dictionary size (contexts): " + dataCount);
+	parts.push("dictionary size (events): " + eventCount);
+
+	return parts.join(", ");
+}
+
+/**
+ * @param {string}
+ * @returns {string[]}
+ */
+ROT.StringGenerator.prototype._split = function(str) {
+	return str.split(this._options.words ? /\s+/ : "");
+}
+
+/**
+ * @param {string[]}
+ * @returns {string} 
+ */
+ROT.StringGenerator.prototype._join = function(arr) {
+	return arr.join(this._options.words ? " " : "");
+}
+
+/**
+ * @param {string[]} context
+ * @param {string} event
+ */
+ROT.StringGenerator.prototype._observeEvent = function(context, event) {
+	var key = this._join(context);
+	if (!(key in this._data)) { this._data[key] = {}; }
+	var data = this._data[key];
+
+	if (!(event in data)) { data[event] = 0; }
+	data[event]++;
+}
+
+/**
+ * @param {string[]}
+ * @returns {string}
+ */
+ROT.StringGenerator.prototype._sample = function(context) {
+	context = this._backoff(context);
+	var key = this._join(context);
+	var data = this._data[key];
+
+	var available = {};
+
+	if (this._options.prior) {
+		for (var event in this._priorValues) { available[event] = this._priorValues[event]; }
+		for (var event in data) { available[event] += data[event]; }
+	} else { 
+		available = data;
+	}
+
+	return this._pickRandom(available);
+}
+
+/**
+ * @param {string[]}
+ * @returns {string[]}
+ */
+ROT.StringGenerator.prototype._backoff = function(context) {
+	if (context.length > this._options.order) {
+		context = context.slice(-this._options.order);
+	} else if (context.length < this._options.order) {
+		context = this._prefix.slice(0, this._options.order - context.length).concat(context);
+	}
+
+	while (!(this._join(context) in this._data) && context.length > 0) { context = context.slice(1); }
+
+	return context;
+}
+
+
+ROT.StringGenerator.prototype._pickRandom = function(data) {
+	var total = 0;
+	
+	for (var id in data) {
+		total += data[id];
+	}
+	var random = ROT.RNG.getUniform()*total;
+	
+	var part = 0;
+	for (var id in data) {
+		part += data[id];
+		if (random < part) { return id; }
+	}
+}
+/**
+ * @class Generic event queue: stores events and retrieves them based on their time
+ */
+ROT.EventQueue = function() {
+	this._time = 0;
+	this._events = [];
+	this._eventTimes = [];
+}
+
+/**
+ * @returns {number} Elapsed time
+ */
+ROT.EventQueue.prototype.getTime = function() {
+	return this._time;
+}
+
+/**
+ * Clear all scheduled events
+ */
+ROT.EventQueue.prototype.clear = function() {
+	this._events = [];
+	this._eventTimes = [];
+	return this;
+}
+
+/**
+ * @param {?} event
+ * @param {number} time
+ */
+ROT.EventQueue.prototype.add = function(event, time) {
+	var index = this._events.length;
+	for (var i=0;i<this._eventTimes.length;i++) {
+		if (this._eventTimes[i] > time) {
+			index = i;
+			break;
+		}
+	}
+
+	this._events.splice(index, 0, event);
+	this._eventTimes.splice(index, 0, time);
+}
+
+/**
+ * Locates the nearest event, advances time if necessary. Returns that event and removes it from the queue.
+ * @returns {? || null} The event previously added by addEvent, null if no event available
+ */
+ROT.EventQueue.prototype.get = function() {
+	if (!this._events.length) { return null; }
+
+	var time = this._eventTimes.splice(0, 1)[0];
+	if (time > 0) { /* advance */
+		this._time += time;
+		for (var i=0;i<this._eventTimes.length;i++) { this._eventTimes[i] -= time; }
+	}
+
+	return this._events.splice(0, 1)[0];
+}
+
+/**
+ * Remove an event from the queue
+ * @param {?} event
+ * @returns {bool} success?
+ */
+ROT.EventQueue.prototype.remove = function(event) {
+	var index = this._events.indexOf(event);
+	if (index == -1) { return false }
+	this._remove(index);
+	return true;
+}
+
+/**
+ * Remove an event from the queue
+ * @param {int} index
+ */
+ROT.EventQueue.prototype._remove = function(index) {
+	this._events.splice(index, 1);
+	this._eventTimes.splice(index, 1);
+}
+/**
+ * @class Abstract scheduler
+ */
+ROT.Scheduler = function() {
+	this._queue = new ROT.EventQueue();
+	this._repeat = [];
+	this._current = null;
+}
+
+/**
+ * @see ROT.EventQueue#getTime
+ */
+ROT.Scheduler.prototype.getTime = function() {
+	return this._queue.getTime();
+}
+
+/**
+ * @param {?} item
+ * @param {bool} repeat
+ */
+ROT.Scheduler.prototype.add = function(item, repeat) {
+	if (repeat) { this._repeat.push(item); }
+	return this;
+}
+
+/**
+ * Clear all items
+ */
+ROT.Scheduler.prototype.clear = function() {
+	this._queue.clear();
+	this._repeat = [];
+	this._current = null;
+	return this;
+}
+
+/**
+ * Remove a previously added item
+ * @param {?} item
+ * @returns {bool} successful?
+ */
+ROT.Scheduler.prototype.remove = function(item) {
+	var result = this._queue.remove(item);
+
+	var index = this._repeat.indexOf(item);
+	if (index != -1) { this._repeat.splice(index, 1); }
+
+	if (this._current == item) { this._current = null; }
+
+	return result;
+}
+
+/**
+ * Schedule next item
+ * @returns {?}
+ */
+ROT.Scheduler.prototype.next = function() {
+	this._current = this._queue.get();
+	return this._current;
+}
+/**
+ * @class Simple fair scheduler (round-robin style)
+ * @augments ROT.Scheduler
+ */
+ROT.Scheduler.Simple = function() {
+	ROT.Scheduler.call(this);
+}
+ROT.Scheduler.Simple.extend(ROT.Scheduler);
+
+/**
+ * @see ROT.Scheduler#add
+ */
+ROT.Scheduler.Simple.prototype.add = function(item, repeat) {
+	this._queue.add(item, 0);
+	return ROT.Scheduler.prototype.add.call(this, item, repeat);
+}
+
+/**
+ * @see ROT.Scheduler#next
+ */
+ROT.Scheduler.Simple.prototype.next = function() {
+	if (this._current && this._repeat.indexOf(this._current) != -1) {
+		this._queue.add(this._current, 0);
+	}
+	return ROT.Scheduler.prototype.next.call(this);
+}
+/**
+ * @class Speed-based scheduler
+ * @augments ROT.Scheduler
+ */
+ROT.Scheduler.Speed = function() {
+	ROT.Scheduler.call(this);
+}
+ROT.Scheduler.Speed.extend(ROT.Scheduler);
+
+/**
+ * @param {object} item anything with "getSpeed" method
+ * @param {bool} repeat
+ * @see ROT.Scheduler#add
+ */
+ROT.Scheduler.Speed.prototype.add = function(item, repeat) {
+	this._queue.add(item, 1/item.getSpeed());
+	return ROT.Scheduler.prototype.add.call(this, item, repeat);
+}
+
+/**
+ * @see ROT.Scheduler#next
+ */
+ROT.Scheduler.Speed.prototype.next = function() {
+	if (this._current && this._repeat.indexOf(this._current) != -1) {
+		this._queue.add(this._current, 1/this._current.getSpeed());
+	}
+	return ROT.Scheduler.prototype.next.call(this);
+}
+/**
+ * @class Action-based scheduler
+ * @augments ROT.Scheduler
+ */
+ROT.Scheduler.Action = function() {
+	ROT.Scheduler.call(this);
+	this._defaultDuration = 1; /* for newly added */
+	this._duration = this._defaultDuration; /* for this._current */
+}
+ROT.Scheduler.Action.extend(ROT.Scheduler);
+
+/**
+ * @param {object} item
+ * @param {bool} repeat
+ * @param {number} [time=1]
+ * @see ROT.Scheduler#add
+ */
+ROT.Scheduler.Action.prototype.add = function(item, repeat, time) {
+	this._queue.add(item, time || this._defaultDuration);
+	return ROT.Scheduler.prototype.add.call(this, item, repeat);
+}
+
+ROT.Scheduler.Action.prototype.clear = function() {
+	this._duration = this._defaultDuration;
+	return ROT.Scheduler.prototype.clear.call(this);
+}
+
+ROT.Scheduler.Action.prototype.remove = function(item) {
+	if (item == this._current) { this._duration = this._defaultDuration; }
+	return ROT.Scheduler.prototype.remove.call(this, item);
+}
+
+/**
+ * @see ROT.Scheduler#next
+ */
+ROT.Scheduler.Action.prototype.next = function() {
+	if (this._current && this._repeat.indexOf(this._current) != -1) {
+		this._queue.add(this._current, this._duration || this._defaultDuration);
+		this._duration = this._defaultDuration;
+	}
+	return ROT.Scheduler.prototype.next.call(this);
+}
+
+/**
+ * Set duration for the active item
+ */
+ROT.Scheduler.Action.prototype.setDuration = function(time) {
+	if (this._current) { this._duration = time; }
+	return this;
+}
+/**
+ * @class Asynchronous main loop
+ * @param {ROT.Scheduler} scheduler
+ */
+ROT.Engine = function(scheduler) {
+	this._scheduler = scheduler;
+	this._lock = 1;
+}
+
+/**
+ * Start the main loop. When this call returns, the loop is locked.
+ */
+ROT.Engine.prototype.start = function() {
+	return this.unlock();
+}
+
+/**
+ * Interrupt the engine by an asynchronous action
+ */
+ROT.Engine.prototype.lock = function() {
+	this._lock++;
+}
+
+/**
+ * Resume execution (paused by a previous lock)
+ */
+ROT.Engine.prototype.unlock = function() {
+	if (!this._lock) { throw new Error("Cannot unlock unlocked engine"); }
+	this._lock--;
+
+	while (!this._lock) {
+		var actor = this._scheduler.next();
+		if (!actor) { return this.lock(); } /* no actors */
+		actor.act();
+	}
+
+	return this;
+}
+/**
+ * @class Base map generator
+ * @param {int} [width=ROT.DEFAULT_WIDTH]
+ * @param {int} [height=ROT.DEFAULT_HEIGHT]
+ */
+ROT.Map = function(width, height) {
+	this._width = width || ROT.DEFAULT_WIDTH;
+	this._height = height || ROT.DEFAULT_HEIGHT;
+};
+
+ROT.Map.prototype.create = function(callback) {}
+
+ROT.Map.prototype._fillMap = function(value) {
+	var map = [];
+	for (var i=0;i<this._width;i++) {
+		map.push([]);
+		for (var j=0;j<this._height;j++) { map[i].push(value); }
+	}
+	return map;
+}
+/**
+ * @class Simple empty rectangular room
+ * @augments ROT.Map
+ */
+ROT.Map.Arena = function(width, height) {
+	ROT.Map.call(this, width, height);
+}
+ROT.Map.Arena.extend(ROT.Map);
+
+ROT.Map.Arena.prototype.create = function(callback) {
+	var w = this._width-1;
+	var h = this._height-1;
+	for (var i=0;i<=w;i++) {
+		for (var j=0;j<=h;j++) {
+			var empty = (i && j && i<w && j<h);
+			callback(i, j, empty ? 0 : 1);
+		}
+	}
+	return this;
+}
+/**
+ * @class Recursively divided maze, http://en.wikipedia.org/wiki/Maze_generation_algorithm#Recursive_division_method
+ * @augments ROT.Map
+ */
+ROT.Map.DividedMaze = function(width, height) {
+	ROT.Map.call(this, width, height);
+	this._stack = [];
+}
+ROT.Map.DividedMaze.extend(ROT.Map);
+
+ROT.Map.DividedMaze.prototype.create = function(callback) {
+	var w = this._width;
+	var h = this._height;
+	
+	this._map = [];
+	
+	for (var i=0;i<w;i++) {
+		this._map.push([]);
+		for (var j=0;j<h;j++) {
+			var border = (i == 0 || j == 0 || i+1 == w || j+1 == h);
+			this._map[i].push(border ? 1 : 0);
+		}
+	}
+	
+	this._stack = [
+		[1, 1, w-2, h-2]
+	];
+	this._process();
+	
+	for (var i=0;i<w;i++) {
+		for (var j=0;j<h;j++) {
+			callback(i, j, this._map[i][j]);
+		}
+	}
+	this._map = null;
+	return this;
+}
+
+ROT.Map.DividedMaze.prototype._process = function() {
+	while (this._stack.length) {
+		var room = this._stack.shift(); /* [left, top, right, bottom] */
+		this._partitionRoom(room);
+	}
+}
+
+ROT.Map.DividedMaze.prototype._partitionRoom = function(room) {
+	var availX = [];
+	var availY = [];
+	
+	for (var i=room[0]+1;i<room[2];i++) {
+		var top = this._map[i][room[1]-1];
+		var bottom = this._map[i][room[3]+1];
+		if (top && bottom && !(i % 2)) { availX.push(i); }
+	}
+	
+	for (var j=room[1]+1;j<room[3];j++) {
+		var left = this._map[room[0]-1][j];
+		var right = this._map[room[2]+1][j];
+		if (left && right && !(j % 2)) { availY.push(j); }
+	}
+
+	if (!availX.length || !availY.length) { return; }
+
+	var x = availX.random();
+	var y = availY.random();
+	
+	this._map[x][y] = 1;
+	
+	var walls = [];
+	
+	var w = []; walls.push(w); /* left part */
+	for (var i=room[0]; i<x; i++) { 
+		this._map[i][y] = 1;
+		w.push([i, y]); 
+	}
+	
+	var w = []; walls.push(w); /* right part */
+	for (var i=x+1; i<=room[2]; i++) { 
+		this._map[i][y] = 1;
+		w.push([i, y]); 
+	}
+
+	var w = []; walls.push(w); /* top part */
+	for (var j=room[1]; j<y; j++) { 
+		this._map[x][j] = 1;
+		w.push([x, j]); 
+	}
+	
+	var w = []; walls.push(w); /* bottom part */
+	for (var j=y+1; j<=room[3]; j++) { 
+		this._map[x][j] = 1;
+		w.push([x, j]); 
+	}
+		
+	var solid = walls.random();
+	for (var i=0;i<walls.length;i++) {
+		var w = walls[i];
+		if (w == solid) { continue; }
+		
+		var hole = w.random();
+		this._map[hole[0]][hole[1]] = 0;
+	}
+
+	this._stack.push([room[0], room[1], x-1, y-1]); /* left top */
+	this._stack.push([x+1, room[1], room[2], y-1]); /* right top */
+	this._stack.push([room[0], y+1, x-1, room[3]]); /* left bottom */
+	this._stack.push([x+1, y+1, room[2], room[3]]); /* right bottom */
+}
+/**
+ * @class Icey's Maze generator
+ * See http://www.roguebasin.roguelikedevelopment.org/index.php?title=Simple_maze for explanation
+ * @augments ROT.Map
+ */
+ROT.Map.IceyMaze = function(width, height, regularity) {
+	ROT.Map.call(this, width, height);
+	this._regularity = regularity || 0;
+}
+ROT.Map.IceyMaze.extend(ROT.Map);
+
+ROT.Map.IceyMaze.prototype.create = function(callback) {
+	var width = this._width;
+	var height = this._height;
+	
+	var map = this._fillMap(1);
+	
+	width -= (width % 2 ? 1 : 2);
+	height -= (height % 2 ? 1 : 2);
+
+	var cx = 0;
+	var cy = 0;
+	var nx = 0;
+	var ny = 0;
+
+	var done = 0;
+	var blocked = false;
+	var dirs = [
+		[0, 0],
+		[0, 0],
+		[0, 0],
+		[0, 0]
+	];
+	do {
+		cx = 1 + 2*Math.floor(ROT.RNG.getUniform()*(width-1) / 2);
+		cy = 1 + 2*Math.floor(ROT.RNG.getUniform()*(height-1) / 2);
+
+		if (!done) { map[cx][cy] = 0; }
+		
+		if (!map[cx][cy]) {
+			this._randomize(dirs);
+			do {
+				if (Math.floor(ROT.RNG.getUniform()*(this._regularity+1)) == 0) { this._randomize(dirs); }
+				blocked = true;
+				for (var i=0;i<4;i++) {
+					nx = cx + dirs[i][0]*2;
+					ny = cy + dirs[i][1]*2;
+					if (this._isFree(map, nx, ny, width, height)) {
+						map[nx][ny] = 0;
+						map[cx + dirs[i][0]][cy + dirs[i][1]] = 0;
+						
+						cx = nx;
+						cy = ny;
+						blocked = false;
+						done++;
+						break;
+					}
+				}
+			} while (!blocked);
+		}
+	} while (done+1 < width*height/4);
+	
+	for (var i=0;i<this._width;i++) {
+		for (var j=0;j<this._height;j++) {
+			callback(i, j, map[i][j]);
+		}
+	}
+	this._map = null;
+	return this;
+}
+
+ROT.Map.IceyMaze.prototype._randomize = function(dirs) {
+	for (var i=0;i<4;i++) {
+		dirs[i][0] = 0;
+		dirs[i][1] = 0;
+	}
+	
+	switch (Math.floor(ROT.RNG.getUniform()*4)) {
+		case 0:
+			dirs[0][0] = -1; dirs[1][0] = 1;
+			dirs[2][1] = -1; dirs[3][1] = 1;
+		break;
+		case 1:
+			dirs[3][0] = -1; dirs[2][0] = 1;
+			dirs[1][1] = -1; dirs[0][1] = 1;
+		break;
+		case 2:
+			dirs[2][0] = -1; dirs[3][0] = 1;
+			dirs[0][1] = -1; dirs[1][1] = 1;
+		break;
+		case 3:
+			dirs[1][0] = -1; dirs[0][0] = 1;
+			dirs[3][1] = -1; dirs[2][1] = 1;
+		break;
+	}
+}
+
+ROT.Map.IceyMaze.prototype._isFree = function(map, x, y, width, height) {
+	if (x < 1 || y < 1 || x >= width || y >= height) { return false; }
+	return map[x][y];
+}
+/**
+ * @class Maze generator - Eller's algorithm
+ * See http://homepages.cwi.nl/~tromp/maze.html for explanation
+ * @augments ROT.Map
+ */
+ROT.Map.EllerMaze = function(width, height) {
+	ROT.Map.call(this, width, height);
+}
+ROT.Map.EllerMaze.extend(ROT.Map);
+
+ROT.Map.EllerMaze.prototype.create = function(callback) {
+	var map = this._fillMap(1);
+	var w = Math.ceil((this._width-2)/2);
+	
+	var rand = 9/24;
+	
+	var L = [];
+	var R = [];
+	
+	for (var i=0;i<w;i++) {
+		L.push(i);
+		R.push(i);
+	}
+	L.push(w-1); /* fake stop-block at the right side */
+
+	for (var j=1;j+3<this._height;j+=2) {
+		/* one row */
+		for (var i=0;i<w;i++) {
+			/* cell coords (will be always empty) */
+			var x = 2*i+1;
+			var y = j;
+			map[x][y] = 0;
+			
+			/* right connection */
+			if (i != L[i+1] && ROT.RNG.getUniform() > rand) {
+				this._addToList(i, L, R);
+				map[x+1][y] = 0;
+			}
+			
+			/* bottom connection */
+			if (i != L[i] && ROT.RNG.getUniform() > rand) {
+				/* remove connection */
+				this._removeFromList(i, L, R);
+			} else {
+				/* create connection */
+				map[x][y+1] = 0;
+			}
+		}
+	}
+
+	/* last row */
+	for (var i=0;i<w;i++) {
+		/* cell coords (will be always empty) */
+		var x = 2*i+1;
+		var y = j;
+		map[x][y] = 0;
+		
+		/* right connection */
+		if (i != L[i+1] && (i == L[i] || ROT.RNG.getUniform() > rand)) {
+			/* dig right also if the cell is separated, so it gets connected to the rest of maze */
+			this._addToList(i, L, R);
+			map[x+1][y] = 0;
+		}
+		
+		this._removeFromList(i, L, R);
+	}
+	
+	for (var i=0;i<this._width;i++) {
+		for (var j=0;j<this._height;j++) {
+			callback(i, j, map[i][j]);
+		}
+	}
+	
+	return this;
+}
+
+/**
+ * Remove "i" from its list
+ */
+ROT.Map.EllerMaze.prototype._removeFromList = function(i, L, R) {
+	R[L[i]] = R[i];
+	L[R[i]] = L[i];
+	R[i] = i;
+	L[i] = i;
+}
+
+/**
+ * Join lists with "i" and "i+1"
+ */
+ROT.Map.EllerMaze.prototype._addToList = function(i, L, R) {
+	R[L[i+1]] = R[i];
+	L[R[i]] = L[i+1];
+	R[i] = i+1;
+	L[i+1] = i;
+}
+/**
+ * @class Cellular automaton map generator
+ * @augments ROT.Map
+ * @param {int} [width=ROT.DEFAULT_WIDTH]
+ * @param {int} [height=ROT.DEFAULT_HEIGHT]
+ * @param {object} [options] Options
+ * @param {int[]} [options.born] List of neighbor counts for a new cell to be born in empty space
+ * @param {int[]} [options.survive] List of neighbor counts for an existing  cell to survive
+ * @param {int} [options.topology] Topology 4 or 6 or 8
+ */
+ROT.Map.Cellular = function(width, height, options) {
+	ROT.Map.call(this, width, height);
+	this._options = {
+		born: [5, 6, 7, 8],
+		survive: [4, 5, 6, 7, 8],
+		topology: 8
+	};
+	for (var p in options) { this._options[p] = options[p]; }
+	
+	this._dirs = ROT.DIRS[this._options.topology];
+	this._map = this._fillMap(0);
+}
+ROT.Map.Cellular.extend(ROT.Map);
+
+/**
+ * Fill the map with random values
+ * @param {float} probability Probability for a cell to become alive; 0 = all empty, 1 = all full
+ */
+ROT.Map.Cellular.prototype.randomize = function(probability) {
+	for (var i=0;i<this._width;i++) {
+		for (var j=0;j<this._height;j++) {
+			this._map[i][j] = (ROT.RNG.getUniform() < probability ? 1 : 0);
+		}
+	}
+	return this;
+}
+
+ROT.Map.Cellular.prototype.set = function(x, y, value) {
+	this._map[x][y] = value;
+}
+
+ROT.Map.Cellular.prototype.create = function(callback) {
+	var newMap = this._fillMap(0);
+	var born = this._options.born;
+	var survive = this._options.survive;
+
+
+	for (var j=0;j<this._height;j++) {
+		var widthStep = 1;
+		var widthStart = 0;
+		if (this._options.topology == 6) { 
+			widthStep = 2;
+			widthStart = j%2;
+		}
+
+		for (var i=widthStart; i<this._width; i+=widthStep) {
+
+			var cur = this._map[i][j];
+			var ncount = this._getNeighbors(i, j);
+			
+			if (cur && survive.indexOf(ncount) != -1) { /* survive */
+				newMap[i][j] = 1;
+			} else if (!cur && born.indexOf(ncount) != -1) { /* born */
+				newMap[i][j] = 1;
+			}
+			
+			if (callback) { callback(i, j, newMap[i][j]); }
+		}
+	}
+	
+	this._map = newMap;
+}
+
+/**
+ * Get neighbor count at [i,j] in this._map
+ */
+ROT.Map.Cellular.prototype._getNeighbors = function(cx, cy) {
+	var result = 0;
+	for (var i=0;i<this._dirs.length;i++) {
+		var dir = this._dirs[i];
+		var x = cx + dir[0];
+		var y = cy + dir[1];
+		
+		if (x < 0 || x >= this._width || x < 0 || y >= this._width) { continue; }
+		result += (this._map[x][y] == 1 ? 1 : 0);
+	}
+	
+	return result;
+}
+/**
+ * @class Dungeon map: has rooms and corridors
+ * @augments ROT.Map
+ */
+ROT.Map.Dungeon = function(width, height) {
+	ROT.Map.call(this, width, height);
+	this._rooms = []; /* list of all rooms */
+	this._corridors = [];
+}
+ROT.Map.Dungeon.extend(ROT.Map);
+
+/**
+ * Get all generated rooms
+ * @returns {ROT.Map.Feature.Room[]}
+ */
+ROT.Map.Dungeon.prototype.getRooms = function() {
+	return this._rooms;
+}
+
+/**
+ * Get all generated corridors
+ * @returns {ROT.Map.Feature.Corridor[]}
+ */
+ROT.Map.Dungeon.prototype.getCorridors = function() {
+	return this._corridors;
+}
+/**
+ * @class Random dungeon generator using human-like digging patterns.
+ * Heavily based on Mike Anderson's ideas from the "Tyrant" algo, mentioned at 
+ * http://www.roguebasin.roguelikedevelopment.org/index.php?title=Dungeon-Building_Algorithm.
+ * @augments ROT.Map.Dungeon
+ */
+ROT.Map.Digger = function(width, height, options) {
+	ROT.Map.Dungeon.call(this, width, height);
+	
+	this._options = {
+		roomWidth: [3, 9], /* room minimum and maximum width */
+		roomHeight: [3, 5], /* room minimum and maximum height */
+		corridorLength: [3, 10], /* corridor minimum and maximum length */
+		dugPercentage: 0.2, /* we stop after this percentage of level area has been dug out */
+		timeLimit: 1000 /* we stop after this much time has passed (msec) */
+	}
+	for (var p in options) { this._options[p] = options[p]; }
+	
+	this._features = {
+		"Room": 4,
+		"Corridor": 4
+	}
+	this._featureAttempts = 20; /* how many times do we try to create a feature on a suitable wall */
+	this._walls = {}; /* these are available for digging */
+	
+	this._digCallback = this._digCallback.bind(this);
+	this._canBeDugCallback = this._canBeDugCallback.bind(this);
+	this._isWallCallback = this._isWallCallback.bind(this);
+	this._priorityWallCallback = this._priorityWallCallback.bind(this);
+}
+ROT.Map.Digger.extend(ROT.Map.Dungeon);
+
+/**
+ * Create a map
+ * @see ROT.Map#create
+ */
+ROT.Map.Digger.prototype.create = function(callback) {
+	this._rooms = [];
+	this._corridors = [];
+	this._map = this._fillMap(1);
+	this._walls = {};
+	this._dug = 0;
+	var area = (this._width-2) * (this._height-2);
+
+	this._firstRoom();
+	
+	var t1 = Date.now();
+
+	do {
+		var t2 = Date.now();
+		if (t2 - t1 > this._options.timeLimit) { break; }
+
+		/* find a good wall */
+		var wall = this._findWall();
+		if (!wall) { break; } /* no more walls */
+		
+		var parts = wall.split(",");
+		var x = parseInt(parts[0]);
+		var y = parseInt(parts[1]);
+		var dir = this._getDiggingDirection(x, y);
+		if (!dir) { continue; } /* this wall is not suitable */
+		
+//		console.log("wall", x, y);
+
+		/* try adding a feature */
+		var featureAttempts = 0;
+		do {
+			featureAttempts++;
+			if (this._tryFeature(x, y, dir[0], dir[1])) { /* feature added */
+				//if (this._rooms.length + this._corridors.length == 2) { this._rooms[0].addDoor(x, y); } /* first room oficially has doors */
+				this._removeSurroundingWalls(x, y);
+				this._removeSurroundingWalls(x-dir[0], y-dir[1]);
+				break; 
+			}
+		} while (featureAttempts < this._featureAttempts);
+		
+		var priorityWalls = 0;
+		for (var id in this._walls) { 
+			if (this._walls[id] > 1) { priorityWalls++; }
+		}
+
+	} while (this._dug/area < this._options.dugPercentage || priorityWalls); /* fixme number of priority walls */
+
+	this._addDoors();
+
+	if (callback) {
+		for (var i=0;i<this._width;i++) {
+			for (var j=0;j<this._height;j++) {
+				callback(i, j, this._map[i][j]);
+			}
+		}
+	}
+	
+	this._walls = {};
+	this._map = null;
+
+	return this;
+}
+
+ROT.Map.Digger.prototype._digCallback = function(x, y, value) {
+	if (value == 0 || value == 2) { /* empty */
+		this._map[x][y] = 0;
+		this._dug++;
+	} else { /* wall */
+		this._walls[x+","+y] = 1;
+	}
+}
+
+ROT.Map.Digger.prototype._isWallCallback = function(x, y) {
+	if (x < 0 || y < 0 || x >= this._width || y >= this._height) { return false; }
+	return (this._map[x][y] == 1);
+}
+
+ROT.Map.Digger.prototype._canBeDugCallback = function(x, y) {
+	if (x < 1 || y < 1 || x+1 >= this._width || y+1 >= this._height) { return false; }
+	return (this._map[x][y] == 1);
+}
+
+ROT.Map.Digger.prototype._priorityWallCallback = function(x, y) {
+	this._walls[x+","+y] = 2;
+}
+
+ROT.Map.Digger.prototype._firstRoom = function() {
+	var cx = Math.floor(this._width/2);
+	var cy = Math.floor(this._height/2);
+	var room = ROT.Map.Feature.Room.createRandomCenter(cx, cy, this._options);
+	this._rooms.push(room);
+	room.create(this._digCallback);
+}
+
+/**
+ * Get a suitable wall
+ */
+ROT.Map.Digger.prototype._findWall = function() {
+	var prio1 = [];
+	var prio2 = [];
+	for (var id in this._walls) {
+		var prio = this._walls[id];
+		if (prio == 2) { 
+			prio2.push(id); 
+		} else {
+			prio1.push(id);
+		}
+	}
+	
+	var arr = (prio2.length ? prio2 : prio1);
+	if (!arr.length) { return null; } /* no walls :/ */
+	
+	var id = arr.random();
+	delete this._walls[id];
+
+	return id;
+}
+
+/**
+ * Tries adding a feature
+ * @returns {bool} was this a successful try?
+ */
+ROT.Map.Digger.prototype._tryFeature = function(x, y, dx, dy) {
+	var feature = ROT.RNG.getWeightedValue(this._features);
+	feature = ROT.Map.Feature[feature].createRandomAt(x, y, dx, dy, this._options);
+	
+	if (!feature.isValid(this._isWallCallback, this._canBeDugCallback)) {
+//		console.log("not valid");
+//		feature.debug();
+		return false;
+	}
+	
+	feature.create(this._digCallback);
+//	feature.debug();
+
+	if (feature instanceof ROT.Map.Feature.Room) { this._rooms.push(feature); }
+	if (feature instanceof ROT.Map.Feature.Corridor) { 
+		feature.createPriorityWalls(this._priorityWallCallback);
+		this._corridors.push(feature); 
+	}
+	
+	return true;
+}
+
+ROT.Map.Digger.prototype._removeSurroundingWalls = function(cx, cy) {
+	var deltas = ROT.DIRS[4];
+
+	for (var i=0;i<deltas.length;i++) {
+		var delta = deltas[i];
+		var x = cx + delta[0];
+		var y = cy + delta[1];
+		delete this._walls[x+","+y];
+		var x = cx + 2*delta[0];
+		var y = cy + 2*delta[1];
+		delete this._walls[x+","+y];
+	}
+}
+
+/**
+ * Returns vector in "digging" direction, or false, if this does not exist (or is not unique)
+ */
+ROT.Map.Digger.prototype._getDiggingDirection = function(cx, cy) {
+	var result = null;
+	var deltas = ROT.DIRS[4];
+	
+	for (var i=0;i<deltas.length;i++) {
+		var delta = deltas[i];
+		var x = cx + delta[0];
+		var y = cy + delta[1];
+		
+		if (x < 0 || y < 0 || x >= this._width || y >= this._width) { return null; }
+		
+		if (!this._map[x][y]) { /* there already is another empty neighbor! */
+			if (result) { return null; }
+			result = delta;
+		}
+	}
+	
+	/* no empty neighbor */
+	if (!result) { return null; }
+	
+	return [-result[0], -result[1]];
+}
+
+/**
+ * Find empty spaces surrounding rooms, and apply doors.
+ */
+ROT.Map.Digger.prototype._addDoors = function() {
+	var data = this._map;
+	var isWallCallback = function(x, y) {
+		return (data[x][y] == 1);
+	}
+	for (var i = 0; i < this._rooms.length; i++ ) {
+		var room = this._rooms[i];
+		room.clearDoors();
+		room.addDoors(isWallCallback);
+	}
+}
+/**
+ * @class Dungeon generator which tries to fill the space evenly. Generates independent rooms and tries to connect them.
+ * @augments ROT.Map.Dungeon
+ */
+ROT.Map.Uniform = function(width, height, options) {
+	ROT.Map.Dungeon.call(this, width, height);
+
+	this._options = {
+		roomWidth: [3, 9], /* room minimum and maximum width */
+		roomHeight: [3, 5], /* room minimum and maximum height */
+		roomDugPercentage: 0.1, /* we stop after this percentage of level area has been dug out by rooms */
+		timeLimit: 1000 /* we stop after this much time has passed (msec) */
+	}
+	for (var p in options) { this._options[p] = options[p]; }
+
+	this._roomAttempts = 20; /* new room is created N-times until is considered as impossible to generate */
+	this._corridorAttempts = 20; /* corridors are tried N-times until the level is considered as impossible to connect */
+
+	this._connected = []; /* list of already connected rooms */
+	this._unconnected = []; /* list of remaining unconnected rooms */
+	
+	this._digCallback = this._digCallback.bind(this);
+	this._canBeDugCallback = this._canBeDugCallback.bind(this);
+	this._isWallCallback = this._isWallCallback.bind(this);
+}
+ROT.Map.Uniform.extend(ROT.Map.Dungeon);
+
+/**
+ * Create a map. If the time limit has been hit, returns null.
+ * @see ROT.Map#create
+ */
+ROT.Map.Uniform.prototype.create = function(callback) {
+	var t1 = Date.now();
+	while (1) {
+		var t2 = Date.now();
+		if (t2 - t1 > this._options.timeLimit) { return null; } /* time limit! */
+	
+		this._map = this._fillMap(1);
+		this._dug = 0;
+		this._rooms = [];
+		this._unconnected = [];
+		this._generateRooms();
+		if (this._generateCorridors()) { break; }
+	}
+	
+	if (callback) {
+		for (var i=0;i<this._width;i++) {
+			for (var j=0;j<this._height;j++) {
+				callback(i, j, this._map[i][j]);
+			}
+		}
+	}
+	
+	return this;
+}
+
+/**
+ * Generates a suitable amount of rooms
+ */
+ROT.Map.Uniform.prototype._generateRooms = function() {
+	var w = this._width-2;
+	var h = this._height-2;
+
+	do {
+		var room = this._generateRoom();
+		if (this._dug/(w*h) > this._options.roomDugPercentage) { break; } /* achieved requested amount of free space */
+	} while (room);
+
+	/* either enough rooms, or not able to generate more of them :) */
+}
+
+/**
+ * Try to generate one room
+ */
+ROT.Map.Uniform.prototype._generateRoom = function() {
+	var count = 0;
+	while (count < this._roomAttempts) {
+		count++;
+		
+		var room = ROT.Map.Feature.Room.createRandom(this._width, this._height, this._options);
+		if (!room.isValid(this._isWallCallback, this._canBeDugCallback)) { continue; }
+		
+		room.create(this._digCallback);
+		this._rooms.push(room);
+		return room;
+	} 
+
+	/* no room was generated in a given number of attempts */
+	return null;
+}
+
+/**
+ * Generates connectors beween rooms
+ * @returns {bool} success Was this attempt successfull?
+ */
+ROT.Map.Uniform.prototype._generateCorridors = function() {
+	var cnt = 0;
+	while (cnt < this._corridorAttempts) {
+		cnt++;
+		this._corridors = [];
+
+		/* dig rooms into a clear map */
+		this._map = this._fillMap(1);
+		for (var i=0;i<this._rooms.length;i++) { 
+			var room = this._rooms[i];
+			room.clearDoors();
+			room.create(this._digCallback); 
+		}
+
+		this._unconnected = this._rooms.slice().randomize();
+		this._connected = [];
+		if (this._unconnected.length) { this._connected.push(this._unconnected.pop()); } /* first one is always connected */
+		
+		while (1) {
+			/* 1. pick random connected room */
+			var connected = this._connected.random();
+			
+			/* 2. find closest unconnected */
+			var room1 = this._closestRoom(this._unconnected, connected);
+			
+			/* 3. connect it to closest connected */
+			var room2 = this._closestRoom(this._connected, room1);
+			
+			var ok = this._connectRooms(room1, room2);
+			if (!ok) { break; } /* stop connecting, re-shuffle */
+			
+			if (!this._unconnected.length) { return true; } /* done; no rooms remain */
+		}
+	}
+	return false;
+}
+
+/**
+ * For a given room, find the closest one from the list
+ */
+ROT.Map.Uniform.prototype._closestRoom = function(rooms, room) {
+	var dist = Infinity;
+	var center = room.getCenter();
+	var result = null;
+	
+	for (var i=0;i<rooms.length;i++) {
+		var r = rooms[i];
+		var c = r.getCenter();
+		var dx = c[0]-center[0];
+		var dy = c[1]-center[1];
+		var d = dx*dx+dy*dy;
+		
+		if (d < dist) {
+			dist = d;
+			result = r;
+		}
+	}
+	
+	return result;
+}
+
+ROT.Map.Uniform.prototype._connectRooms = function(room1, room2) {
+	/*
+		room1.debug();
+		room2.debug();
+	*/
+
+	var center1 = room1.getCenter();
+	var center2 = room2.getCenter();
+
+	var diffX = center2[0] - center1[0];
+	var diffY = center2[1] - center1[1];
+
+	if (Math.abs(diffX) < Math.abs(diffY)) { /* first try connecting north-south walls */
+		var dirIndex1 = (diffY > 0 ? 2 : 0);
+		var dirIndex2 = (dirIndex1 + 2) % 4;
+		var min = room2.getLeft();
+		var max = room2.getRight();
+		var index = 0;
+	} else { /* first try connecting east-west walls */
+		var dirIndex1 = (diffX > 0 ? 1 : 3);
+		var dirIndex2 = (dirIndex1 + 2) % 4;
+		var min = room2.getTop();
+		var max = room2.getBottom();
+		var index = 1;
+	}
+
+	var start = this._placeInWall(room1, dirIndex1); /* corridor will start here */
+	if (!start) { return false; }
+
+	if (start[index] >= min && start[index] <= max) { /* possible to connect with straight line (I-like) */
+		var end = start.slice();
+		var value = null;
+		switch (dirIndex2) {
+			case 0: value = room2.getTop()-1; break;
+			case 1: value = room2.getRight()+1; break;
+			case 2: value = room2.getBottom()+1; break;
+			case 3: value = room2.getLeft()-1; break;
+		}
+		end[(index+1)%2] = value;
+		this._digLine([start, end]);
+		
+	} else if (start[index] < min-1 || start[index] > max+1) { /* need to switch target wall (L-like) */
+
+		var diff = start[index] - center2[index];
+		switch (dirIndex2) {
+			case 0:
+			case 1:	var rotation = (diff < 0 ? 3 : 1); break;
+			case 2:
+			case 3:	var rotation = (diff < 0 ? 1 : 3); break;
+		}
+		dirIndex2 = (dirIndex2 + rotation) % 4;
+		
+		var end = this._placeInWall(room2, dirIndex2);
+		if (!end) { return false; }
+
+		var mid = [0, 0];
+		mid[index] = start[index];
+		var index2 = (index+1)%2;
+		mid[index2] = end[index2];
+		this._digLine([start, mid, end]);
+		
+	} else { /* use current wall pair, but adjust the line in the middle (S-like) */
+	
+		var index2 = (index+1)%2;
+		var end = this._placeInWall(room2, dirIndex2);
+		if (!end) { return; }
+		var mid = Math.round((end[index2] + start[index2])/2);
+
+		var mid1 = [0, 0];
+		var mid2 = [0, 0];
+		mid1[index] = start[index];
+		mid1[index2] = mid;
+		mid2[index] = end[index];
+		mid2[index2] = mid;
+		this._digLine([start, mid1, mid2, end]);
+	}
+
+	room1.addDoor(start[0], start[1]);
+	room2.addDoor(end[0], end[1]);
+	
+	var index = this._unconnected.indexOf(room1);
+	if (index != -1) {
+		this._unconnected.splice(index, 1);
+		this._connected.push(room1);
+	}
+
+	var index = this._unconnected.indexOf(room2);
+	if (index != -1) {
+		this._unconnected.splice(index, 1);
+		this._connected.push(room2);
+	}
+	
+	return true;
+}
+
+ROT.Map.Uniform.prototype._placeInWall = function(room, dirIndex) {
+	var start = [0, 0];
+	var dir = [0, 0];
+	var length = 0;
+	
+	switch (dirIndex) {
+		case 0:
+			dir = [1, 0];
+			start = [room.getLeft(), room.getTop()-1];
+			length = room.getRight()-room.getLeft()+1;
+		break;
+		case 1:
+			dir = [0, 1];
+			start = [room.getRight()+1, room.getTop()];
+			length = room.getBottom()-room.getTop()+1;
+		break;
+		case 2:
+			dir = [1, 0];
+			start = [room.getLeft(), room.getBottom()+1];
+			length = room.getRight()-room.getLeft()+1;
+		break;
+		case 3:
+			dir = [0, 1];
+			start = [room.getLeft()-1, room.getTop()];
+			length = room.getBottom()-room.getTop()+1;
+		break;
+	}
+	
+	var avail = [];
+	var lastBadIndex = -2;
+
+	for (var i=0;i<length;i++) {
+		var x = start[0] + i*dir[0];
+		var y = start[1] + i*dir[1];
+		avail.push(null);
+		
+		var isWall = (this._map[x][y] == 1);
+		if (isWall) {
+			if (lastBadIndex != i-1) { avail[i] = [x, y]; }
+		} else {
+			lastBadIndex = i;
+			if (i) { avail[i-1] = null; }
+		}
+	}
+	
+	for (var i=avail.length-1; i>=0; i--) {
+		if (!avail[i]) { avail.splice(i, 1); }
+	}
+	return (avail.length ? avail.random() : null);
+}
+
+/**
+ * Dig a polyline.
+ */
+ROT.Map.Uniform.prototype._digLine = function(points) {
+	for (var i=1;i<points.length;i++) {
+		var start = points[i-1];
+		var end = points[i];
+		var corridor = new ROT.Map.Feature.Corridor(start[0], start[1], end[0], end[1]);
+		corridor.create(this._digCallback);
+		this._corridors.push(corridor);
+	}
+}
+
+ROT.Map.Uniform.prototype._digCallback = function(x, y, value) {
+	this._map[x][y] = value;
+	if (value == 0) { this._dug++; }
+}
+
+ROT.Map.Uniform.prototype._isWallCallback = function(x, y) {
+	if (x < 0 || y < 0 || x >= this._width || y >= this._height) { return false; }
+	return (this._map[x][y] == 1);
+}
+
+ROT.Map.Uniform.prototype._canBeDugCallback = function(x, y) {
+	if (x < 1 || y < 1 || x+1 >= this._width || y+1 >= this._height) { return false; }
+	return (this._map[x][y] == 1);
+}
+
+/**
+ * @author hyakugei
+ * @class Dungeon generator which uses the "orginal" Rogue dungeon generation algorithm. See http://kuoi.com/~kamikaze/GameDesign/art07_rogue_dungeon.php
+ * @augments ROT.Map
+ * @param {int} [width=ROT.DEFAULT_WIDTH]
+ * @param {int} [height=ROT.DEFAULT_HEIGHT]
+ * @param {object} [options] Options
+ * @param {int[]} [options.cellWidth=3] Number of cells to create on the horizontal (number of rooms horizontally)
+ * @param {int[]} [options.cellHeight=3] Number of cells to create on the vertical (number of rooms vertically) 
+ * @param {int} [options.roomWidth] Room min and max width - normally set auto-magically via the constructor.
+ * @param {int} [options.roomHeight] Room min and max height - normally set auto-magically via the constructor. 
+ */
+ROT.Map.Rogue = function(width, height, options) {
+	ROT.Map.call(this, width, height);
+	
+	this._options = {
+		cellWidth: 3,  // NOTE to self, these could probably work the same as the roomWidth/room Height values
+		cellHeight: 3  //     ie. as an array with min-max values for each direction....
+	}
+	
+	for (var p in options) { this._options[p] = options[p]; }
+	
+	/*
+	Set the room sizes according to the over-all width of the map, 
+	and the cell sizes. 
+	*/
+	
+	if (!this._options.hasOwnProperty("roomWidth")) {
+		this._options["roomWidth"] = this._calculateRoomSize(width, this._options["cellWidth"]);
+	}
+	if (!this._options.hasOwnProperty["roomHeight"]) {
+		this._options["roomHeight"] = this._calculateRoomSize(height, this._options["cellHeight"]);
+	}
+	
+}
+
+ROT.Map.Rogue.extend(ROT.Map); 
+
+/**
+ * @see ROT.Map#create
+ */
+ROT.Map.Rogue.prototype.create = function(callback) {
+	this.map = this._fillMap(1);
+	this.rooms = [];
+	this.connectedCells = [];
+	
+	this._initRooms();
+	this._connectRooms();
+	this._connectUnconnectedRooms();
+	this._createRandomRoomConnections();
+	this._createRooms();
+	this._createCorridors();
+	
+	if (callback) {
+		for (var i = 0; i < this._width; i++) {
+			for (var j = 0; j < this._height; j++) {
+				callback(i, j, this.map[i][j]);   
+			}
+		}
+	}
+	
+	return this;
+}
+
+ROT.Map.Rogue.prototype._getRandomInt = function(min, max) {
+	return Math.floor(ROT.RNG.getUniform() * (max - min + 1)) + min;
+}
+
+ROT.Map.Rogue.prototype._calculateRoomSize = function(size, cell) {
+	var max = Math.floor((size/cell) * 0.8);
+	var min = Math.floor((size/cell) * 0.25);
+	if (min < 2) min = 2;
+	if (max < 2) max = 2;
+	return [min, max];
+}
+
+ROT.Map.Rogue.prototype._initRooms = function () { 
+	// create rooms array. This is the "grid" list from the algo.  
+	for (var i = 0; i < this._options.cellWidth; i++) {  
+		this.rooms.push([]);
+		for(var j = 0; j < this._options.cellHeight; j++) {
+			this.rooms[i].push({"x":0, "y":0, "width":0, "height":0, "connections":[], "cellx":i, "celly":j});
+		}
+	}
+}
+
+ROT.Map.Rogue.prototype._connectRooms = function() {
+	//pick random starting grid
+	var cgx = this._getRandomInt(0, this._options.cellWidth-1);
+	var cgy = this._getRandomInt(0, this._options.cellHeight-1);
+	
+	var idx;
+	var ncgx;
+	var ncgy;
+	
+	var found = false;
+	var room;
+	var otherRoom;
+	
+	// find  unconnected neighbour cells
+	do {
+	
+		//var dirToCheck = [0,1,2,3,4,5,6,7];
+		var dirToCheck = [0,2,4,6];
+		dirToCheck = dirToCheck.randomize();
+		
+		do {
+			found = false;
+			idx = dirToCheck.pop();
+			
+			
+			ncgx = cgx + ROT.DIRS[8][idx][0];
+			ncgy = cgy + ROT.DIRS[8][idx][1];
+			
+			if(ncgx < 0 || ncgx >= this._options.cellWidth) continue;
+			if(ncgy < 0 || ncgy >= this._options.cellHeight) continue;
+			
+			room = this.rooms[cgx][cgy];
+			
+			if(room["connections"].length > 0)
+			{
+				// as long as this room doesn't already coonect to me, we are ok with it. 
+				if(room["connections"][0][0] == ncgx &&
+				room["connections"][0][1] == ncgy)
+				{
+					break;
+				}
+			}
+			
+			otherRoom = this.rooms[ncgx][ncgy];
+			
+			if (otherRoom["connections"].length == 0) { 
+				otherRoom["connections"].push([cgx,cgy]);
+				
+				this.connectedCells.push([ncgx, ncgy]);
+				cgx = ncgx;
+				cgy = ncgy;
+				found = true;
+			}
+					
+		} while (dirToCheck.length > 0 && found == false)
+		
+	} while (dirToCheck.length > 0)
+
+}
+
+ROT.Map.Rogue.prototype._connectUnconnectedRooms = function() {
+	//While there are unconnected rooms, try to connect them to a random connected neighbor 
+	//(if a room has no connected neighbors yet, just keep cycling, you'll fill out to it eventually).
+	var cw = this._options.cellWidth;
+	var ch = this._options.cellHeight;
+	
+	var randomConnectedCell;
+	this.connectedCells = this.connectedCells.randomize();
+	var room;
+	var otherRoom;
+	var validRoom;
+	
+	for (var i = 0; i < this._options.cellWidth; i++) {
+		for (var j = 0; j < this._options.cellHeight; j++)  {
+				
+			room = this.rooms[i][j];
+			
+			if (room["connections"].length == 0) {
+				var directions = [0,2,4,6];
+				directions = directions.randomize();
+				
+				var validRoom = false;
+				
+				do {
+					
+					var dirIdx = directions.pop();
+					var newI = i + ROT.DIRS[8][dirIdx][0];
+					var newJ = j + ROT.DIRS[8][dirIdx][1];
+					
+					if (newI < 0 || newI >= cw || 
+					newJ < 0 || newJ >= ch) {
+						continue;
+					}
+					
+					otherRoom = this.rooms[newI][newJ];
+					
+					validRoom = true;
+					
+					if (otherRoom["connections"].length == 0) {
+						break;
+					}
+					
+					for (var k = 0; k < otherRoom["connections"].length; k++) {
+						if(otherRoom["connections"][k][0] == i && 
+						otherRoom["connections"][k][1] == j) {
+							validRoom = false;
+							break;
+						}
+					}
+					
+					if (validRoom) break;
+					
+				} while (directions.length)
+				
+				if(validRoom) { 
+					room["connections"].push( [otherRoom["cellx"], otherRoom["celly"]] );  
+				} else {
+					console.log("-- Unable to connect room.");
+				}
+			}
+		}
+	}
+}
+
+ROT.Map.Rogue.prototype._createRandomRoomConnections = function(connections) {
+	// Empty for now. 
+}
+
+
+ROT.Map.Rogue.prototype._createRooms = function() {
+	// Create Rooms 
+	
+	var w = this._width;
+	var h = this._height;
+	
+	var cw = this._options.cellWidth;
+	var ch = this._options.cellHeight;
+	
+	var cwp = Math.floor(this._width / cw);
+	var chp = Math.floor(this._height / ch);
+	
+	var roomw;
+	var roomh;
+	var roomWidth = this._options["roomWidth"];
+	var roomHeight = this._options["roomHeight"];
+	var sx;
+	var sy;
+	var tx;
+	var ty;
+	var otherRoom;
+	
+	for (var i = 0; i < cw; i++) {
+		for (var j = 0; j < ch; j++) {
+			sx = cwp * i;
+			sy = chp * j;
+			
+			if (sx == 0) sx = 1;
+			if (sy == 0) sy = 1;
+			
+			roomw = this._getRandomInt(roomWidth[0], roomWidth[1]);
+			roomh = this._getRandomInt(roomHeight[0], roomHeight[1]);
+			
+			if (j > 0) {
+				otherRoom = this.rooms[i][j-1];
+				while (sy - (otherRoom["y"] + otherRoom["height"] ) < 3) {
+					sy++;
+				}
+			}
+			
+			if (i > 0) {
+				otherRoom = this.rooms[i-1][j];
+				while(sx - (otherRoom["x"] + otherRoom["width"]) < 3) {
+					sx++;
+				}
+			}
+						
+			var sxOffset = Math.round(this._getRandomInt(0, cwp-roomw)/2);
+			var syOffset = Math.round(this._getRandomInt(0, chp-roomh)/2);
+			
+			while (sx + sxOffset + roomw >= w) {
+				if(sxOffset) {
+					sxOffset--;
+				} else {
+					roomw--; 
+				}
+			}
+			
+			while (sy + syOffset + roomh >= h) { 
+				if(syOffset) {
+					syOffset--;
+				} else {
+					roomh--; 
+				}
+			}
+			
+			sx = sx + sxOffset;
+			sy = sy + syOffset;
+			
+			this.rooms[i][j]["x"] = sx;
+			this.rooms[i][j]["y"] = sy;
+			this.rooms[i][j]["width"] = roomw;
+			this.rooms[i][j]["height"] = roomh;  
+			
+			for (var ii = sx; ii < sx + roomw; ii++) {
+				for (var jj = sy; jj < sy + roomh; jj++) {
+					this.map[ii][jj] = 0;
+				}
+			}  
+		}
+	}
+}
+
+ROT.Map.Rogue.prototype._getWallPosition = function(aRoom, aDirection) {
+	var rx;
+	var ry;
+	var door;
+	
+	if (aDirection == 1 || aDirection == 3) {
+		rx = this._getRandomInt(aRoom["x"] + 1, aRoom["x"] + aRoom["width"] - 2);
+		if (aDirection == 1) {
+			ry = aRoom["y"] - 2;
+			door = ry + 1;
+		} else {
+			ry = aRoom["y"] + aRoom["height"] + 1;
+			door = ry -1;
+		}
+		
+		this.map[rx][door] = 0; // i'm not setting a specific 'door' tile value right now, just empty space. 
+		
+	} else if (aDirection == 2 || aDirection == 4) {
+		ry = this._getRandomInt(aRoom["y"] + 1, aRoom["y"] + aRoom["height"] - 2);
+		if(aDirection == 2) {
+			rx = aRoom["x"] + aRoom["width"] + 1;
+			door = rx - 1;
+		} else {
+			rx = aRoom["x"] - 2;
+			door = rx + 1;
+		}
+		
+		this.map[door][ry] = 0; // i'm not setting a specific 'door' tile value right now, just empty space. 
+		
+	}
+	return [rx, ry];
+}
+
+/***
+* @param startPosition a 2 element array
+* @param endPosition a 2 element array
+*/
+ROT.Map.Rogue.prototype._drawCorridore = function (startPosition, endPosition) {
+	var xOffset = endPosition[0] - startPosition[0];
+	var yOffset = endPosition[1] - startPosition[1];
+	
+	var xpos = startPosition[0];
+	var ypos = startPosition[1];
+	
+	var tempDist;
+	var xDir;
+	var yDir;
+	
+	var move; // 2 element array, element 0 is the direction, element 1 is the total value to move. 
+	var moves = []; // a list of 2 element arrays
+	
+	var xAbs = Math.abs(xOffset);
+	var yAbs = Math.abs(yOffset);
+	
+	var percent = ROT.RNG.getUniform(); // used to split the move at different places along the long axis
+	var firstHalf = percent;
+	var secondHalf = 1 - percent;
+	
+	xDir = xOffset > 0 ? 2 : 6;
+	yDir = yOffset > 0 ? 4 : 0;
+	
+	if (xAbs < yAbs) {
+		// move firstHalf of the y offset
+		tempDist = Math.ceil(yAbs * firstHalf);
+		moves.push([yDir, tempDist]);
+		// move all the x offset
+		moves.push([xDir, xAbs]);
+		// move sendHalf of the  y offset
+		tempDist = Math.floor(yAbs * secondHalf);
+		moves.push([yDir, tempDist]);
+	} else {
+		//  move firstHalf of the x offset
+		tempDist = Math.ceil(xAbs * firstHalf);
+		moves.push([xDir, tempDist]);
+		// move all the y offset
+		moves.push([yDir, yAbs]);
+		// move secondHalf of the x offset.
+		tempDist = Math.floor(xAbs * secondHalf);
+		moves.push([xDir, tempDist]);  
+	}
+	
+	this.map[xpos][ypos] = 0;
+	
+	while (moves.length > 0) {
+		move = moves.pop();
+		while (move[1] > 0) {
+			xpos += ROT.DIRS[8][move[0]][0];
+			ypos += ROT.DIRS[8][move[0]][1];
+			this.map[xpos][ypos] = 0;
+			move[1] = move[1] - 1;
+		}
+	}
+}
+
+ROT.Map.Rogue.prototype._createCorridors = function () {
+	// Draw Corridors between connected rooms
+	
+	var cw = this._options.cellWidth;
+	var ch = this._options.cellHeight;
+	var room;
+	var connection;
+	var otherRoom;
+	var wall;
+	var otherWall;
+	
+	for (var i = 0; i < cw; i++) {
+		for (var j = 0; j < ch; j++) {
+			room = this.rooms[i][j];
+			
+			for (var k = 0; k < room["connections"].length; k++) {
+					
+				connection = room["connections"][k]; 
+				
+				otherRoom = this.rooms[connection[0]][connection[1]];
+				
+				// figure out what wall our corridor will start one.
+				// figure out what wall our corridor will end on. 
+				if (otherRoom["cellx"] > room["cellx"] ) {
+					wall = 2;
+					otherWall = 4;
+				} else if (otherRoom["cellx"] < room["cellx"] ) {
+					wall = 4;
+					otherWall = 2;
+				} else if(otherRoom["celly"] > room["celly"]) {
+					wall = 3;
+					otherWall = 1;
+				} else if(otherRoom["celly"] < room["celly"]) {
+					wall = 1;
+					otherWall = 3;
+				}
+				
+				this._drawCorridore(this._getWallPosition(room, wall), this._getWallPosition(otherRoom, otherWall));
+			}
+		}
+	}
+}
+/**
+ * @class Dungeon feature; has own .create() method
+ */
+ROT.Map.Feature = function() {}
+ROT.Map.Feature.prototype.isValid = function(canBeDugCallback) {}
+ROT.Map.Feature.prototype.create = function(digCallback) {}
+ROT.Map.Feature.prototype.debug = function() {}
+ROT.Map.Feature.createRandomAt = function(x, y, dx, dy, options) {}
+
+/**
+ * @class Room
+ * @augments ROT.Map.Feature
+ * @param {int} x1
+ * @param {int} y1
+ * @param {int} x2
+ * @param {int} y2
+ * @param {int} [doorX]
+ * @param {int} [doorY]
+ */
+ROT.Map.Feature.Room = function(x1, y1, x2, y2, doorX, doorY) {
+	this._x1 = x1;
+	this._y1 = y1;
+	this._x2 = x2;
+	this._y2 = y2;
+	this._doors = {};
+	if (arguments.length > 4) { this.addDoor(doorX, doorY); }
+}
+ROT.Map.Feature.Room.extend(ROT.Map.Feature);
+
+/**
+ * Room of random size, with a given doors and direction
+ */
+ROT.Map.Feature.Room.createRandomAt = function(x, y, dx, dy, options) {
+	var min = options.roomWidth[0];
+	var max = options.roomWidth[1];
+	var width = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
+	
+	var min = options.roomHeight[0];
+	var max = options.roomHeight[1];
+	var height = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
+	
+	if (dx == 1) { /* to the right */
+		var y2 = y - Math.floor(ROT.RNG.getUniform() * height);
+		return new this(x+1, y2, x+width, y2+height-1, x, y);
+	}
+	
+	if (dx == -1) { /* to the left */
+		var y2 = y - Math.floor(ROT.RNG.getUniform() * height);
+		return new this(x-width, y2, x-1, y2+height-1, x, y);
+	}
+
+	if (dy == 1) { /* to the bottom */
+		var x2 = x - Math.floor(ROT.RNG.getUniform() * width);
+		return new this(x2, y+1, x2+width-1, y+height, x, y);
+	}
+
+	if (dy == -1) { /* to the top */
+		var x2 = x - Math.floor(ROT.RNG.getUniform() * width);
+		return new this(x2, y-height, x2+width-1, y-1, x, y);
+	}
+}
+
+/**
+ * Room of random size, positioned around center coords
+ */
+ROT.Map.Feature.Room.createRandomCenter = function(cx, cy, options) {
+	var min = options.roomWidth[0];
+	var max = options.roomWidth[1];
+	var width = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
+	
+	var min = options.roomHeight[0];
+	var max = options.roomHeight[1];
+	var height = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
+
+	var x1 = cx - Math.floor(ROT.RNG.getUniform()*width);
+	var y1 = cy - Math.floor(ROT.RNG.getUniform()*height);
+	var x2 = x1 + width - 1;
+	var y2 = y1 + height - 1;
+
+	return new this(x1, y1, x2, y2);
+}
+
+/**
+ * Room of random size within a given dimensions
+ */
+ROT.Map.Feature.Room.createRandom = function(availWidth, availHeight, options) {
+	var min = options.roomWidth[0];
+	var max = options.roomWidth[1];
+	var width = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
+	
+	var min = options.roomHeight[0];
+	var max = options.roomHeight[1];
+	var height = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
+	
+	var left = availWidth - width - 1;
+	var top = availHeight - height - 1;
+
+	var x1 = 1 + Math.floor(ROT.RNG.getUniform()*left);
+	var y1 = 1 + Math.floor(ROT.RNG.getUniform()*top);
+	var x2 = x1 + width - 1;
+	var y2 = y1 + height - 1;
+
+	return new this(x1, y1, x2, y2);
+}
+
+ROT.Map.Feature.Room.prototype.addDoor = function(x, y) {
+	this._doors[x+","+y] = 1;
+	return this;
+}
+
+/**
+ * @param {function}
+ */
+ROT.Map.Feature.Room.prototype.getDoors = function(callback) {
+	for (var key in this._doors) {
+		var parts = key.split(",");
+		callback(parseInt(parts[0]), parseInt(parts[1]));
+	}
+	return this;
+}
+
+ROT.Map.Feature.Room.prototype.clearDoors = function() {
+	this._doors = {};
+	return this;
+}
+
+ROT.Map.Feature.Room.prototype.addDoors = function(isWallCallback) {
+	var left = this._x1-1;
+	var right = this._x2+1;
+	var top = this._y1-1;
+	var bottom = this._y2+1;
+
+	for (var x=left; x<=right; x++) {
+		for (var y=top; y<=bottom; y++) {
+			if (x != left && x != right && y != top && y != bottom) { continue; }
+			if (isWallCallback(x, y)) { continue; }
+
+			this.addDoor(x, y);
+		}
+	}
+
+	return this;
+}
+
+ROT.Map.Feature.Room.prototype.debug = function() {
+	console.log("room", this._x1, this._y1, this._x2, this._y2);
+}
+
+ROT.Map.Feature.Room.prototype.isValid = function(isWallCallback, canBeDugCallback) { 
+	var left = this._x1-1;
+	var right = this._x2+1;
+	var top = this._y1-1;
+	var bottom = this._y2+1;
+	
+	for (var x=left; x<=right; x++) {
+		for (var y=top; y<=bottom; y++) {
+			if (x == left || x == right || y == top || y == bottom) {
+				if (!isWallCallback(x, y)) { return false; }
+			} else {
+				if (!canBeDugCallback(x, y)) { return false; }
+			}
+		}
+	}
+
+	return true;
+}
+
+/**
+ * @param {function} digCallback Dig callback with a signature (x, y, value). Values: 0 = empty, 1 = wall, 2 = door. Multiple doors are allowed.
+ */
+ROT.Map.Feature.Room.prototype.create = function(digCallback) { 
+	var left = this._x1-1;
+	var right = this._x2+1;
+	var top = this._y1-1;
+	var bottom = this._y2+1;
+	
+	var value = 0;
+	for (var x=left; x<=right; x++) {
+		for (var y=top; y<=bottom; y++) {
+			if (x+","+y in this._doors) {
+				value = 2;
+			} else if (x == left || x == right || y == top || y == bottom) {
+				value = 1;
+			} else {
+				value = 0;
+			}
+			digCallback(x, y, value);
+		}
+	}
+}
+
+ROT.Map.Feature.Room.prototype.getCenter = function() {
+	return [Math.round((this._x1 + this._x2)/2), Math.round((this._y1 + this._y2)/2)];
+}
+
+ROT.Map.Feature.Room.prototype.getLeft = function() {
+	return this._x1;
+}
+
+ROT.Map.Feature.Room.prototype.getRight = function() {
+	return this._x2;
+}
+
+ROT.Map.Feature.Room.prototype.getTop = function() {
+	return this._y1;
+}
+
+ROT.Map.Feature.Room.prototype.getBottom = function() {
+	return this._y2;
+}
+
+/**
+ * @class Corridor
+ * @augments ROT.Map.Feature
+ * @param {int} startX
+ * @param {int} startY
+ * @param {int} endX
+ * @param {int} endY
+ */
+ROT.Map.Feature.Corridor = function(startX, startY, endX, endY) {
+	this._startX = startX;
+	this._startY = startY;
+	this._endX = endX; 
+	this._endY = endY;
+	this._endsWithAWall = true;
+}
+ROT.Map.Feature.Corridor.extend(ROT.Map.Feature);
+
+ROT.Map.Feature.Corridor.createRandomAt = function(x, y, dx, dy, options) {
+	var min = options.corridorLength[0];
+	var max = options.corridorLength[1];
+	var length = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
+	
+	return new this(x, y, x + dx*length, y + dy*length);
+}
+
+ROT.Map.Feature.Corridor.prototype.debug = function() {
+	console.log("corridor", this._startX, this._startY, this._endX, this._endY);
+}
+
+ROT.Map.Feature.Corridor.prototype.isValid = function(isWallCallback, canBeDugCallback){ 
+	var sx = this._startX;
+	var sy = this._startY;
+	var dx = this._endX-sx;
+	var dy = this._endY-sy;
+	var length = 1 + Math.max(Math.abs(dx), Math.abs(dy));
+	
+	if (dx) { dx = dx/Math.abs(dx); }
+	if (dy) { dy = dy/Math.abs(dy); }
+	var nx = dy;
+	var ny = -dx;
+	
+	var ok = true;
+	for (var i=0; i<length; i++) {
+		var x = sx + i*dx;
+		var y = sy + i*dy;
+
+		if (!canBeDugCallback(     x,      y)) { ok = false; }
+		if (!isWallCallback  (x + nx, y + ny)) { ok = false; }
+		if (!isWallCallback  (x - nx, y - ny)) { ok = false; }
+		
+		if (!ok) {
+			length = i;
+			this._endX = x-dx;
+			this._endY = y-dy;
+			break;
+		}
+	}
+	
+	/**
+	 * If the length degenerated, this corridor might be invalid
+	 */
+	 
+	/* not supported */
+	if (length == 0) { return false; } 
+	
+	 /* length 1 allowed only if the next space is empty */
+	if (length == 1 && isWallCallback(this._endX + dx, this._endY + dy)) { return false; }
+	
+	/**
+	 * We do not want the corridor to crash into a corner of a room;
+	 * if any of the ending corners is empty, the N+1th cell of this corridor must be empty too.
+	 * 
+	 * Situation:
+	 * #######1
+	 * .......?
+	 * #######2
+	 * 
+	 * The corridor was dug from left to right.
+	 * 1, 2 - problematic corners, ? = N+1th cell (not dug)
+	 */
+	var firstCornerBad = !isWallCallback(this._endX + dx + nx, this._endY + dy + ny);
+	var secondCornerBad = !isWallCallback(this._endX + dx - nx, this._endY + dy - ny);
+	this._endsWithAWall = isWallCallback(this._endX + dx, this._endY + dy);
+	if ((firstCornerBad || secondCornerBad) && this._endsWithAWall) { return false; }
+
+	return true;
+}
+
+/**
+ * @param {function} digCallback Dig callback with a signature (x, y, value). Values: 0 = empty.
+ */
+ROT.Map.Feature.Corridor.prototype.create = function(digCallback) { 
+	var sx = this._startX;
+	var sy = this._startY;
+	var dx = this._endX-sx;
+	var dy = this._endY-sy;
+	var length = 1+Math.max(Math.abs(dx), Math.abs(dy));
+	
+	if (dx) { dx = dx/Math.abs(dx); }
+	if (dy) { dy = dy/Math.abs(dy); }
+	var nx = dy;
+	var ny = -dx;
+	
+	for (var i=0; i<length; i++) {
+		var x = sx + i*dx;
+		var y = sy + i*dy;
+		digCallback(x, y, 0);
+	}
+	
+	return true;
+}
+
+ROT.Map.Feature.Corridor.prototype.createPriorityWalls = function(priorityWallCallback) {
+	if (!this._endsWithAWall) { return; }
+
+	var sx = this._startX;
+	var sy = this._startY;
+
+	var dx = this._endX-sx;
+	var dy = this._endY-sy;
+	if (dx) { dx = dx/Math.abs(dx); }
+	if (dy) { dy = dy/Math.abs(dy); }
+	var nx = dy;
+	var ny = -dx;
+
+	priorityWallCallback(this._endX + dx, this._endY + dy);
+	priorityWallCallback(this._endX + nx, this._endY + ny);
+	priorityWallCallback(this._endX - nx, this._endY - ny);
+}/**
+ * @class Base noise generator
+ */
+ROT.Noise = function() {
+};
+
+ROT.Noise.prototype.get = function(x, y) {}
+/**
+ * A simple 2d implementation of simplex noise by Ondrej Zara
+ *
+ * Based on a speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
+ * Which is based on example code by Stefan Gustavson (stegu@itn.liu.se).
+ * With Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+ * Better rank ordering method by Stefan Gustavson in 2012.
+ */
+
+/**
+ * @class 2D simplex noise generator
+ * @param {int} [gradients=256] Random gradients
+ */
+ROT.Noise.Simplex = function(gradients) {
+	ROT.Noise.call(this);
+
+	this._F2 = 0.5 * (Math.sqrt(3) - 1);
+    this._G2 = (3 - Math.sqrt(3)) / 6;
+
+	this._gradients = [
+		[ 0, -1],
+		[ 1, -1],
+		[ 1,  0],
+		[ 1,  1],
+		[ 0,  1],
+		[-1,  1],
+		[-1,  0],
+		[-1, -1]
+	];
+
+	var permutations = [];
+	var count = gradients || 256;
+	for (var i=0;i<count;i++) { permutations.push(i); }
+	permutations = permutations.randomize();
+
+	this._perms = [];
+	this._indexes = [];
+
+	for (var i=0;i<2*count;i++) {
+		this._perms.push(permutations[i % count]);
+		this._indexes.push(this._perms[i] % this._gradients.length);
+	}
+
+};
+ROT.Noise.Simplex.extend(ROT.Noise);
+
+ROT.Noise.Simplex.prototype.get = function(xin, yin) {
+	var perms = this._perms;
+	var indexes = this._indexes;
+	var count = perms.length/2;
+	var G2 = this._G2;
+
+	var n0 =0, n1 = 0, n2 = 0, gi; // Noise contributions from the three corners
+
+	// Skew the input space to determine which simplex cell we're in
+	var s = (xin + yin) * this._F2; // Hairy factor for 2D
+	var i = Math.floor(xin + s);
+	var j = Math.floor(yin + s);
+	var t = (i + j) * G2;
+	var X0 = i - t; // Unskew the cell origin back to (x,y) space
+	var Y0 = j - t;
+	var x0 = xin - X0; // The x,y distances from the cell origin
+	var y0 = yin - Y0;
+
+	// For the 2D case, the simplex shape is an equilateral triangle.
+	// Determine which simplex we are in.
+	var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
+	if (x0 > y0) {
+		i1 = 1;
+		j1 = 0;
+	} else { // lower triangle, XY order: (0,0)->(1,0)->(1,1)
+		i1 = 0;
+		j1 = 1;
+	} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
+
+	// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
+	// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
+	// c = (3-sqrt(3))/6
+	var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+	var y1 = y0 - j1 + G2;
+	var x2 = x0 - 1 + 2*G2; // Offsets for last corner in (x,y) unskewed coords
+	var y2 = y0 - 1 + 2*G2;
+
+	// Work out the hashed gradient indices of the three simplex corners
+	var ii = i.mod(count);
+	var jj = j.mod(count);
+
+	// Calculate the contribution from the three corners
+	var t0 = 0.5 - x0*x0 - y0*y0;
+	if (t0 >= 0) {
+		t0 *= t0;
+		gi = indexes[ii+perms[jj]];
+		var grad = this._gradients[gi];
+		n0 = t0 * t0 * (grad[0] * x0 + grad[1] * y0);
+	}
+	
+	var t1 = 0.5 - x1*x1 - y1*y1;
+	if (t1 >= 0) {
+		t1 *= t1;
+		gi = indexes[ii+i1+perms[jj+j1]];
+		var grad = this._gradients[gi];
+		n1 = t1 * t1 * (grad[0] * x1 + grad[1] * y1);
+	}
+	
+	var t2 = 0.5 - x2*x2 - y2*y2;
+	if (t2 >= 0) {
+		t2 *= t2;
+		gi = indexes[ii+1+perms[jj+1]];
+		var grad = this._gradients[gi];
+		n2 = t2 * t2 * (grad[0] * x2 + grad[1] * y2);
+	}
+
+	// Add contributions from each corner to get the final noise value.
+	// The result is scaled to return values in the interval [-1,1].
+	return 70 * (n0 + n1 + n2);
+}
+/**
+ * @class Abstract FOV algorithm
+ * @param {function} lightPassesCallback Does the light pass through x,y?
+ * @param {object} [options]
+ * @param {int} [options.topology=8] 4/6/8
+ */
+ROT.FOV = function(lightPassesCallback, options) {
+	this._lightPasses = lightPassesCallback;
+	this._options = {
+		topology: 8
+	}
+	for (var p in options) { this._options[p] = options[p]; }
+};
+
+/**
+ * Compute visibility
+ * @param {int} x
+ * @param {int} y
+ * @param {int} R Maximum visibility radius
+ * @param {function} callback
+ */
+ROT.FOV.prototype.compute = function(x, y, R, callback) {}
+
+/**
+ * Return all neighbors in a concentric ring
+ * @param {int} cx center-x
+ * @param {int} cy center-y
+ * @param {int} r range
+ */
+ROT.FOV.prototype._getCircle = function(cx, cy, r) {
+	var result = [];
+	var dirs, countFactor, startOffset;
+
+	switch (this._options.topology) {
+		case 4:
+			countFactor = 1;
+			startOffset = [0, 1];
+			dirs = [
+				ROT.DIRS[8][7],
+				ROT.DIRS[8][1],
+				ROT.DIRS[8][3],
+				ROT.DIRS[8][5]
+			]
+		break;
+
+		case 6:
+			dirs = ROT.DIRS[6];
+			countFactor = 1;
+			startOffset = [-1, 1];
+		break;
+
+		case 8:
+			dirs = ROT.DIRS[4];
+			countFactor = 2;
+			startOffset = [-1, 1];
+		break;
+	}
+
+	/* starting neighbor */
+	var x = cx + startOffset[0]*r;
+	var y = cy + startOffset[1]*r;
+
+	/* circle */
+	for (var i=0;i<dirs.length;i++) {
+		for (var j=0;j<r*countFactor;j++) {
+			result.push([x, y]);
+			x += dirs[i][0];
+			y += dirs[i][1];
+
+		}
+	}
+
+	return result;
+}
+/**
+ * @class Discrete shadowcasting algorithm
+ * @augments ROT.FOV
+ */
+ROT.FOV.DiscreteShadowcasting = function(lightPassesCallback, options) {
+	ROT.FOV.call(this, lightPassesCallback, options);
+}
+ROT.FOV.DiscreteShadowcasting.extend(ROT.FOV);
+
+/**
+ * @see ROT.FOV#compute
+ */
+ROT.FOV.DiscreteShadowcasting.prototype.compute = function(x, y, R, callback) {
+	var center = this._coords;
+	var map = this._map;
+
+	/* this place is always visible */
+	callback(x, y, 0);
+
+	/* standing in a dark place. FIXME is this a good idea?  */
+	if (!this._lightPasses(x, y)) { return; }
+	
+	/* start and end angles */
+	var DATA = [];
+	
+	var A, B, cx, cy, blocks;
+
+	/* analyze surrounding cells in concentric rings, starting from the center */
+	for (var r=1; r<=R; r++) {
+		var neighbors = this._getCircle(x, y, r);
+		var angle = 360 / neighbors.length;
+
+		for (var i=0;i<neighbors.length;i++) {
+			cx = neighbors[i][0];
+			cy = neighbors[i][1];
+			A = angle * (i - 0.5);
+			B = A + angle;
+			
+			blocks = !this._lightPasses(cx, cy);
+			if (this._visibleCoords(Math.floor(A), Math.ceil(B), blocks, DATA)) { callback(cx, cy, r, 1); }
+			
+			if (DATA.length == 2 && DATA[0] == 0 && DATA[1] == 360) { return; } /* cutoff? */
+
+		} /* for all cells in this ring */
+	} /* for all rings */
+}
+
+/**
+ * @param {int} A start angle
+ * @param {int} B end angle
+ * @param {bool} blocks Does current cell block visibility?
+ * @param {int[][]} DATA shadowed angle pairs
+ */
+ROT.FOV.DiscreteShadowcasting.prototype._visibleCoords = function(A, B, blocks, DATA) {
+	if (A < 0) { 
+		var v1 = arguments.callee(0, B, blocks, DATA);
+		var v2 = arguments.callee(360+A, 360, blocks, DATA);
+		return v1 || v2;
+	}
+	
+	var index = 0;
+	while (index < DATA.length && DATA[index] < A) { index++; }
+	
+	if (index == DATA.length) { /* completely new shadow */
+		if (blocks) { DATA.push(A, B); } 
+		return true;
+	}
+	
+	var count = 0;
+	
+	if (index % 2) { /* this shadow starts in an existing shadow, or within its ending boundary */
+		while (index < DATA.length && DATA[index] < B) {
+			index++;
+			count++;
+		}
+		
+		if (count == 0) { return false; }
+		
+		if (blocks) { 
+			if (count % 2) {
+				DATA.splice(index-count, count, B);
+			} else {
+				DATA.splice(index-count, count);
+			}
+		}
+		
+		return true;
+
+	} else { /* this shadow starts outside an existing shadow, or within a starting boundary */
+		while (index < DATA.length && DATA[index] < B) {
+			index++;
+			count++;
+		}
+		
+		/* visible when outside an existing shadow, or when overlapping */
+		if (A == DATA[index-count] && count == 1) { return false; }
+		
+		if (blocks) { 
+			if (count % 2) {
+				DATA.splice(index-count, count, A);
+			} else {
+				DATA.splice(index-count, count, A, B);
+			}
+		}
+			
+		return true;
+	}
+}
+/**
+ * @class Precise shadowcasting algorithm
+ * @augments ROT.FOV
+ */
+ROT.FOV.PreciseShadowcasting = function(lightPassesCallback, options) {
+	ROT.FOV.call(this, lightPassesCallback, options);
+}
+ROT.FOV.PreciseShadowcasting.extend(ROT.FOV);
+
+/**
+ * @see ROT.FOV#compute
+ */
+ROT.FOV.PreciseShadowcasting.prototype.compute = function(x, y, R, callback) {
+	/* this place is always visible */
+	callback(x, y, 0, 1);
+
+	/* standing in a dark place. FIXME is this a good idea?  */
+	if (!this._lightPasses(x, y)) { return; }
+	
+	/* list of all shadows */
+	var SHADOWS = [];
+	
+	var cx, cy, blocks, A1, A2, visibility;
+
+	/* analyze surrounding cells in concentric rings, starting from the center */
+	for (var r=1; r<=R; r++) {
+		var neighbors = this._getCircle(x, y, r);
+		var neighborCount = neighbors.length;
+
+		for (var i=0;i<neighborCount;i++) {
+			cx = neighbors[i][0];
+			cy = neighbors[i][1];
+			/* shift half-an-angle backwards to maintain consistency of 0-th cells */
+			A1 = [i ? 2*i-1 : 2*neighborCount-1, 2*neighborCount];
+			A2 = [2*i+1, 2*neighborCount]; 
+			
+			blocks = !this._lightPasses(cx, cy);
+			visibility = this._checkVisibility(A1, A2, blocks, SHADOWS);
+			if (visibility) { callback(cx, cy, r, visibility); }
+
+			if (SHADOWS.length == 2 && SHADOWS[0][0] == 0 && SHADOWS[1][0] == SHADOWS[1][1]) { return; } /* cutoff? */
+
+		} /* for all cells in this ring */
+	} /* for all rings */
+}
+
+/**
+ * @param {int[2]} A1 arc start
+ * @param {int[2]} A2 arc end
+ * @param {bool} blocks Does current arc block visibility?
+ * @param {int[][]} SHADOWS list of active shadows
+ */
+ROT.FOV.PreciseShadowcasting.prototype._checkVisibility = function(A1, A2, blocks, SHADOWS) {
+	if (A1[0] > A2[0]) { /* split into two sub-arcs */
+		var v1 = this._checkVisibility(A1, [A1[1], A1[1]], blocks, SHADOWS);
+		var v2 = this._checkVisibility([0, 1], A2, blocks, SHADOWS);
+		return (v1+v2)/2;
+	}
+
+	/* index1: first shadow >= A1 */
+	var index1 = 0, edge1 = false;
+	while (index1 < SHADOWS.length) {
+		var old = SHADOWS[index1];
+		var diff = old[0]*A1[1] - A1[0]*old[1];
+		if (diff >= 0) { /* old >= A1 */
+			if (diff == 0 && !(index1 % 2)) { edge1 = true; }
+			break;
+		}
+		index1++;
+	}
+
+	/* index2: last shadow <= A2 */
+	var index2 = SHADOWS.length, edge2 = false;
+	while (index2--) {
+		var old = SHADOWS[index2];
+		var diff = A2[0]*old[1] - old[0]*A2[1];
+		if (diff >= 0) { /* old <= A2 */
+			if (diff == 0 && (index2 % 2)) { edge2 = true; }
+			break;
+		}
+	}
+
+	var visible = true;
+	if (index1 == index2 && (edge1 || edge2)) {  /* subset of existing shadow, one of the edges match */
+		visible = false; 
+	} else if (edge1 && edge2 && index1+1==index2 && (index2 % 2)) { /* completely equivalent with existing shadow */
+		visible = false;
+	} else if (index1 > index2 && (index1 % 2)) { /* subset of existing shadow, not touching */
+		visible = false;
+	}
+	
+	if (!visible) { return 0; } /* fast case: not visible */
+	
+	var visibleLength, P;
+
+	/* compute the length of visible arc, adjust list of shadows (if blocking) */
+	var remove = index2-index1+1;
+	if (remove % 2) {
+		if (index1 % 2) { /* first edge within existing shadow, second outside */
+			var P = SHADOWS[index1];
+			visibleLength = (A2[0]*P[1] - P[0]*A2[1]) / (P[1] * A2[1]);
+			if (blocks) { SHADOWS.splice(index1, remove, A2); }
+		} else { /* second edge within existing shadow, first outside */
+			var P = SHADOWS[index2];
+			visibleLength = (P[0]*A1[1] - A1[0]*P[1]) / (A1[1] * P[1]);
+			if (blocks) { SHADOWS.splice(index1, remove, A1); }
+		}
+	} else {
+		if (index1 % 2) { /* both edges within existing shadows */
+			var P1 = SHADOWS[index1];
+			var P2 = SHADOWS[index2];
+			visibleLength = (P2[0]*P1[1] - P1[0]*P2[1]) / (P1[1] * P2[1]);
+			if (blocks) { SHADOWS.splice(index1, remove); }
+		} else { /* both edges outside existing shadows */
+			if (blocks) { SHADOWS.splice(index1, remove, A1, A2); }
+			return 1; /* whole arc visible! */
+		}
+	}
+
+	var arcLength = (A2[0]*A1[1] - A1[0]*A2[1]) / (A1[1] * A2[1]);
+
+	return visibleLength/arcLength;
+}
+/**
+ * @namespace Color operations
+ */
+ROT.Color = {
+	fromString: function(str) {
+		var cached, r;
+		if (str in this._cache) {
+			cached = this._cache[str];
+		} else {
+			if (str.charAt(0) == "#") { /* hex rgb */
+
+				var values = str.match(/[0-9a-f]/gi).map(function(x) { return parseInt(x, 16); });
+				if (values.length == 3) {
+					cached = values.map(function(x) { return x*17; });
+				} else {
+					for (var i=0;i<3;i++) {
+						values[i+1] += 16*values[i];
+						values.splice(i, 1);
+					}
+					cached = values;
+				}
+
+			} else if (r = str.match(/rgb\(([0-9, ]+)\)/i)) { /* decimal rgb */
+				cached = r[1].split(/\s*,\s*/).map(function(x) { return parseInt(x); });
+			} else { /* html name */
+				cached = [0, 0, 0];
+			}
+
+			this._cache[str] = cached;
+		}
+
+		return cached.slice();
+	},
+
+	/**
+	 * Add two or more colors
+	 * @param {number[]} color1
+	 * @param {number[]} color2
+	 * @returns {number[]}
+	 */
+	add: function(color1, color2) {
+		var result = color1.slice();
+		for (var i=0;i<3;i++) {
+			for (var j=1;j<arguments.length;j++) {
+				result[i] += arguments[j][i];
+			}
+		}
+		return result;
+	},
+
+	/**
+	 * Add two or more colors, MODIFIES FIRST ARGUMENT
+	 * @param {number[]} color1
+	 * @param {number[]} color2
+	 * @returns {number[]}
+	 */
+	add_: function(color1, color2) {
+		for (var i=0;i<3;i++) {
+			for (var j=1;j<arguments.length;j++) {
+				color1[i] += arguments[j][i];
+			}
+		}
+		return color1;
+	},
+
+	/**
+	 * Multiply (mix) two or more colors
+	 * @param {number[]} color1
+	 * @param {number[]} color2
+	 * @returns {number[]}
+	 */
+	multiply: function(color1, color2) {
+		var result = color1.slice();
+		for (var i=0;i<3;i++) {
+			for (var j=1;j<arguments.length;j++) {
+				result[i] *= arguments[j][i] / 255;
+			}
+			result[i] = Math.round(result[i]);
+		}
+		return result;
+	},
+
+	/**
+	 * Multiply (mix) two or more colors, MODIFIES FIRST ARGUMENT
+	 * @param {number[]} color1
+	 * @param {number[]} color2
+	 * @returns {number[]}
+	 */
+	multiply_: function(color1, color2) {
+		for (var i=0;i<3;i++) {
+			for (var j=1;j<arguments.length;j++) {
+				color1[i] *= arguments[j][i] / 255;
+			}
+			color1[i] = Math.round(color1[i]);
+		}
+		return color1;
+	},
+
+	/**
+	 * Interpolate (blend) two colors with a given factor
+	 * @param {number[]} color1
+	 * @param {number[]} color2
+	 * @param {float} [factor=0.5] 0..1
+	 * @returns {number[]}
+	 */
+	interpolate: function(color1, color2, factor) {
+		if (arguments.length < 3) { factor = 0.5; }
+		var result = color1.slice();
+		for (var i=0;i<3;i++) {
+			result[i] = Math.round(result[i] + factor*(color2[i]-color1[i]));
+		}
+		return result;
+	},
+
+	/**
+	 * Interpolate (blend) two colors with a given factor in HSL mode
+	 * @param {number[]} color1
+	 * @param {number[]} color2
+	 * @param {float} [factor=0.5] 0..1
+	 * @returns {number[]}
+	 */
+	interpolateHSL: function(color1, color2, factor) {
+		if (arguments.length < 3) { factor = 0.5; }
+		var hsl1 = this.rgb2hsl(color1);
+		var hsl2 = this.rgb2hsl(color2);
+		for (var i=0;i<3;i++) {
+			hsl1[i] += factor*(hsl2[i]-hsl1[i]);
+		}
+		return this.hsl2rgb(hsl1);
+	},
+
+	/**
+	 * Create a new random color based on this one
+	 * @param {number[]} color
+	 * @param {number[]} diff Set of standard deviations
+	 * @returns {number[]}
+	 */
+	randomize: function(color, diff) {
+		if (!(diff instanceof Array)) { diff = ROT.RNG.getNormal(0, diff); }
+		var result = color.slice();
+		for (var i=0;i<3;i++) {
+			result[i] += (diff instanceof Array ? Math.round(ROT.RNG.getNormal(0, diff[i])) : diff);
+		}
+		return result;
+	},
+
+	/**
+	 * Converts an RGB color value to HSL. Expects 0..255 inputs, produces 0..1 outputs.
+	 * @param {number[]} color
+	 * @returns {number[]}
+	 */
+	rgb2hsl: function(color) {
+		var r = color[0]/255;
+		var g = color[1]/255;
+		var b = color[2]/255;
+
+		var max = Math.max(r, g, b), min = Math.min(r, g, b);
+		var h, s, l = (max + min) / 2;
+
+		if (max == min) {
+			h = s = 0; // achromatic
+		} else {
+			var d = max - min;
+			s = (l > 0.5 ? d / (2 - max - min) : d / (max + min));
+			switch(max) {
+				case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+				case g: h = (b - r) / d + 2; break;
+				case b: h = (r - g) / d + 4; break;
+			}
+			h /= 6;
+		}
+
+		return [h, s, l];
+	},
+
+	/**
+	 * Converts an HSL color value to RGB. Expects 0..1 inputs, produces 0..255 outputs.
+	 * @param {number[]} color
+	 * @returns {number[]}
+	 */
+	hsl2rgb: function(color) {
+		var l = color[2];
+
+		if (color[1] == 0) {
+			l *= 255;
+			return [l, l, l];
+		} else {
+			function hue2rgb(p, q, t) {
+				if (t < 0) t += 1;
+				if (t > 1) t -= 1;
+				if (t < 1/6) return p + (q - p) * 6 * t;
+				if (t < 1/2) return q;
+				if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+				return p;
+			}
+
+			var s = color[1];
+			var q = (l < 0.5 ? l * (1 + s) : l + s - l * s);
+			var p = 2 * l - q;
+			var r = hue2rgb(p, q, color[0] + 1/3);
+			var g = hue2rgb(p, q, color[0]);
+			var b = hue2rgb(p, q, color[0] - 1/3);
+			return [Math.round(r*255), Math.round(g*255), Math.round(b*255)];
+		}
+	},
+
+	toRGB: function(color) {
+		return "rgb(" + this._clamp(color[0]) + "," + this._clamp(color[1]) + "," + this._clamp(color[2]) + ")";
+	},
+
+	toHex: function(color) {
+		var parts = [];
+		for (var i=0;i<3;i++) {
+			parts.push(this._clamp(color[i]).toString(16).lpad("0", 2));
+		}
+		return "#" + parts.join("");
+	},
+
+	_clamp: function(num) {
+		if (num < 0) {
+			return 0;
+		} else if (num > 255) {
+			return 255;
+		} else {
+			return num;
+		}
+	},
+
+	_cache: {
+		"black": [0,0,0],
+		"navy": [0,0,128],
+		"darkblue": [0,0,139],
+		"mediumblue": [0,0,205],
+		"blue": [0,0,255],
+		"darkgreen": [0,100,0],
+		"green": [0,128,0],
+		"teal": [0,128,128],
+		"darkcyan": [0,139,139],
+		"deepskyblue": [0,191,255],
+		"darkturquoise": [0,206,209],
+		"mediumspringgreen": [0,250,154],
+		"lime": [0,255,0],
+		"springgreen": [0,255,127],
+		"aqua": [0,255,255],
+		"cyan": [0,255,255],
+		"midnightblue": [25,25,112],
+		"dodgerblue": [30,144,255],
+		"forestgreen": [34,139,34],
+		"seagreen": [46,139,87],
+		"darkslategray": [47,79,79],
+		"darkslategrey": [47,79,79],
+		"limegreen": [50,205,50],
+		"mediumseagreen": [60,179,113],
+		"turquoise": [64,224,208],
+		"royalblue": [65,105,225],
+		"steelblue": [70,130,180],
+		"darkslateblue": [72,61,139],
+		"mediumturquoise": [72,209,204],
+		"indigo": [75,0,130],
+		"darkolivegreen": [85,107,47],
+		"cadetblue": [95,158,160],
+		"cornflowerblue": [100,149,237],
+		"mediumaquamarine": [102,205,170],
+		"dimgray": [105,105,105],
+		"dimgrey": [105,105,105],
+		"slateblue": [106,90,205],
+		"olivedrab": [107,142,35],
+		"slategray": [112,128,144],
+		"slategrey": [112,128,144],
+		"lightslategray": [119,136,153],
+		"lightslategrey": [119,136,153],
+		"mediumslateblue": [123,104,238],
+		"lawngreen": [124,252,0],
+		"chartreuse": [127,255,0],
+		"aquamarine": [127,255,212],
+		"maroon": [128,0,0],
+		"purple": [128,0,128],
+		"olive": [128,128,0],
+		"gray": [128,128,128],
+		"grey": [128,128,128],
+		"skyblue": [135,206,235],
+		"lightskyblue": [135,206,250],
+		"blueviolet": [138,43,226],
+		"darkred": [139,0,0],
+		"darkmagenta": [139,0,139],
+		"saddlebrown": [139,69,19],
+		"darkseagreen": [143,188,143],
+		"lightgreen": [144,238,144],
+		"mediumpurple": [147,112,216],
+		"darkviolet": [148,0,211],
+		"palegreen": [152,251,152],
+		"darkorchid": [153,50,204],
+		"yellowgreen": [154,205,50],
+		"sienna": [160,82,45],
+		"brown": [165,42,42],
+		"darkgray": [169,169,169],
+		"darkgrey": [169,169,169],
+		"lightblue": [173,216,230],
+		"greenyellow": [173,255,47],
+		"paleturquoise": [175,238,238],
+		"lightsteelblue": [176,196,222],
+		"powderblue": [176,224,230],
+		"firebrick": [178,34,34],
+		"darkgoldenrod": [184,134,11],
+		"mediumorchid": [186,85,211],
+		"rosybrown": [188,143,143],
+		"darkkhaki": [189,183,107],
+		"silver": [192,192,192],
+		"mediumvioletred": [199,21,133],
+		"indianred": [205,92,92],
+		"peru": [205,133,63],
+		"chocolate": [210,105,30],
+		"tan": [210,180,140],
+		"lightgray": [211,211,211],
+		"lightgrey": [211,211,211],
+		"palevioletred": [216,112,147],
+		"thistle": [216,191,216],
+		"orchid": [218,112,214],
+		"goldenrod": [218,165,32],
+		"crimson": [220,20,60],
+		"gainsboro": [220,220,220],
+		"plum": [221,160,221],
+		"burlywood": [222,184,135],
+		"lightcyan": [224,255,255],
+		"lavender": [230,230,250],
+		"darksalmon": [233,150,122],
+		"violet": [238,130,238],
+		"palegoldenrod": [238,232,170],
+		"lightcoral": [240,128,128],
+		"khaki": [240,230,140],
+		"aliceblue": [240,248,255],
+		"honeydew": [240,255,240],
+		"azure": [240,255,255],
+		"sandybrown": [244,164,96],
+		"wheat": [245,222,179],
+		"beige": [245,245,220],
+		"whitesmoke": [245,245,245],
+		"mintcream": [245,255,250],
+		"ghostwhite": [248,248,255],
+		"salmon": [250,128,114],
+		"antiquewhite": [250,235,215],
+		"linen": [250,240,230],
+		"lightgoldenrodyellow": [250,250,210],
+		"oldlace": [253,245,230],
+		"red": [255,0,0],
+		"fuchsia": [255,0,255],
+		"magenta": [255,0,255],
+		"deeppink": [255,20,147],
+		"orangered": [255,69,0],
+		"tomato": [255,99,71],
+		"hotpink": [255,105,180],
+		"coral": [255,127,80],
+		"darkorange": [255,140,0],
+		"lightsalmon": [255,160,122],
+		"orange": [255,165,0],
+		"lightpink": [255,182,193],
+		"pink": [255,192,203],
+		"gold": [255,215,0],
+		"peachpuff": [255,218,185],
+		"navajowhite": [255,222,173],
+		"moccasin": [255,228,181],
+		"bisque": [255,228,196],
+		"mistyrose": [255,228,225],
+		"blanchedalmond": [255,235,205],
+		"papayawhip": [255,239,213],
+		"lavenderblush": [255,240,245],
+		"seashell": [255,245,238],
+		"cornsilk": [255,248,220],
+		"lemonchiffon": [255,250,205],
+		"floralwhite": [255,250,240],
+		"snow": [255,250,250],
+		"yellow": [255,255,0],
+		"lightyellow": [255,255,224],
+		"ivory": [255,255,240],
+		"white": [255,255,255]
+	}
+}
+/**
+ * @class Lighting computation, based on a traditional FOV for multiple light sources and multiple passes.
+ * @param {function} reflectivityCallback Callback to retrieve cell reflectivity (0..1)
+ * @param {object} [options]
+ * @param {int} [options.passes=1] Number of passes. 1 equals to simple FOV of all light sources, >1 means a *highly simplified* radiosity-like algorithm.
+ * @param {int} [options.emissionThreshold=100] Cells with emissivity > threshold will be treated as light source in the next pass.
+ * @param {int} [options.range=10] Max light range
+ */
+ROT.Lighting = function(reflectivityCallback, options) {
+	this._reflectivityCallback = reflectivityCallback;
+	this._options = {
+		passes: 1,
+		emissionThreshold: 100,
+		range: 10
+	};
+	this._fov = null;
+
+	this._lights = {};
+	this._reflectivityCache = {};
+	this._fovCache = {};
+
+	this.setOptions(options);
+}
+
+/**
+ * Adjust options at runtime
+ * @see ROT.Lighting
+ * @param {object} [options]
+ */
+ROT.Lighting.prototype.setOptions = function(options) {
+	for (var p in options) { this._options[p] = options[p]; }
+	if (options.range) { this.reset(); }
+	return this;
+}
+
+/**
+ * Set the used Field-Of-View algo
+ * @param {ROT.FOV} fov
+ */
+ROT.Lighting.prototype.setFOV = function(fov) {
+	this._fov = fov;
+	this._fovCache = {};
+	return this;
+}
+
+/**
+ * Set (or remove) a light source
+ * @param {int} x
+ * @param {int} y
+ * @param {null || string || number[3]} color
+ */
+ROT.Lighting.prototype.setLight = function(x, y, color) {
+	var key = x+","+y;
+
+	if (color) {
+		this._lights[key] = (typeof(color) == "string" ? ROT.Color.fromString(color) : color);
+	} else {
+		delete this._lights[key];
+	}
+	return this;
+}
+
+/**
+ * Reset the pre-computed topology values. Call whenever the underlying map changes its light-passability.
+ */
+ROT.Lighting.prototype.reset = function() {
+	this._reflectivityCache = {};
+	this._fovCache = {};
+
+	return this;
+}
+
+/**
+ * Compute the lighting
+ * @param {function} lightingCallback Will be called with (x, y, color) for every lit cell
+ */
+ROT.Lighting.prototype.compute = function(lightingCallback) {
+	var doneCells = {};
+	var emittingCells = {};
+	var litCells = {};
+
+	for (var key in this._lights) { /* prepare emitters for first pass */
+		var light = this._lights[key];
+		if (!(key in emittingCells)) { emittingCells[key] = [0, 0, 0]; }
+
+		ROT.Color.add_(emittingCells[key], light);
+	}
+
+	for (var i=0;i<this._options.passes;i++) { /* main loop */
+		this._emitLight(emittingCells, litCells, doneCells);
+		if (i+1 == this._options.passes) { continue; } /* not for the last pass */
+		emittingCells = this._computeEmitters(litCells, doneCells);
+	}
+
+	for (var litKey in litCells) { /* let the user know what and how is lit */
+		var parts = litKey.split(",");
+		var x = parseInt(parts[0]);
+		var y = parseInt(parts[1]);
+		lightingCallback(x, y, litCells[litKey]);
+	}
+
+	return this;
+}
+
+/**
+ * Compute one iteration from all emitting cells
+ * @param {object} emittingCells These emit light
+ * @param {object} litCells Add projected light to these
+ * @param {object} doneCells These already emitted, forbid them from further calculations
+ */
+ROT.Lighting.prototype._emitLight = function(emittingCells, litCells, doneCells) {
+	for (var key in emittingCells) {
+		var parts = key.split(",");
+		var x = parseInt(parts[0]);
+		var y = parseInt(parts[1]);
+		this._emitLightFromCell(x, y, emittingCells[key], litCells);
+		doneCells[key] = 1;
+	}
+	return this;
+}
+
+/**
+ * Prepare a list of emitters for next pass
+ * @param {object} litCells
+ * @param {object} doneCells
+ * @returns {object}
+ */
+ROT.Lighting.prototype._computeEmitters = function(litCells, doneCells) {
+	var result = {};
+
+	for (var key in litCells) {
+		if (key in doneCells) { continue; } /* already emitted */
+
+		var color = litCells[key];
+
+		if (key in this._reflectivityCache) {
+			var reflectivity = this._reflectivityCache[key];
+		} else {
+			var parts = key.split(",");
+			var x = parseInt(parts[0]);
+			var y = parseInt(parts[1]);
+			var reflectivity = this._reflectivityCallback(x, y);
+			this._reflectivityCache[key] = reflectivity;
+		}
+
+		if (reflectivity == 0) { continue; } /* will not reflect at all */
+
+		/* compute emission color */
+		var emission = [];
+		var intensity = 0;
+		for (var i=0;i<3;i++) {
+			var part = Math.round(color[i]*reflectivity);
+			emission[i] = part;
+			intensity += part;
+		}
+		if (intensity > this._options.emissionThreshold) { result[key] = emission; }
+	}
+
+	return result;
+}
+
+/**
+ * Compute one iteration from one cell
+ * @param {int} x
+ * @param {int} y
+ * @param {number[]} color
+ * @param {object} litCells Cell data to by updated
+ */
+ROT.Lighting.prototype._emitLightFromCell = function(x, y, color, litCells) {
+	var key = x+","+y;
+	if (key in this._fovCache) {
+		var fov = this._fovCache[key];
+	} else {
+		var fov = this._updateFOV(x, y);
+	}
+
+	for (var fovKey in fov) {
+		var formFactor = fov[fovKey];
+
+		if (fovKey in litCells) { /* already lit */
+			var result = litCells[fovKey];
+		} else { /* newly lit */
+			var result = [0, 0, 0];
+			litCells[fovKey] = result;
+		}
+
+		for (var i=0;i<3;i++) { result[i] += Math.round(color[i]*formFactor); } /* add light color */
+	}
+
+	return this;
+}
+
+/**
+ * Compute FOV ("form factor") for a potential light source at [x,y]
+ * @param {int} x
+ * @param {int} y
+ * @returns {object}
+ */
+ROT.Lighting.prototype._updateFOV = function(x, y) {
+	var key1 = x+","+y;
+	var cache = {};
+	this._fovCache[key1] = cache;
+	var range = this._options.range;
+	var cb = function(x, y, r, vis) {
+		var key2 = x+","+y;
+		var formFactor = vis * (1-r/range);
+		if (formFactor == 0) { return; }
+		cache[key2] = formFactor;
+	}
+	this._fov.compute(x, y, range, cb.bind(this));
+
+	return cache;
+}
+/**
+ * @class Abstract pathfinder
+ * @param {int} toX Target X coord
+ * @param {int} toY Target Y coord
+ * @param {function} passableCallback Callback to determine map passability
+ * @param {object} [options]
+ * @param {int} [options.topology=8]
+ */
+ROT.Path = function(toX, toY, passableCallback, options) {
+	this._toX = toX;
+	this._toY = toY;
+	this._fromX = null;
+	this._fromY = null;
+	this._passableCallback = passableCallback;
+	this._options = {
+		topology: 8
+	}
+	for (var p in options) { this._options[p] = options[p]; }
+
+	this._dirs = ROT.DIRS[this._options.topology];
+}
+
+/**
+ * Compute a path from a given point
+ * @param {int} fromX
+ * @param {int} fromY
+ * @param {function} callback Will be called for every path item with arguments "x" and "y"
+ */
+ROT.Path.prototype.compute = function(fromX, fromY, callback) {
+}
+
+ROT.Path.prototype._getNeighbors = function(cx, cy) {
+	var result = [];
+	for (var i=0;i<this._dirs.length;i++) {
+		var dir = this._dirs[i];
+		var x = cx + dir[0];
+		var y = cy + dir[1];
+		
+		if (!this._passableCallback(x, y)) { continue; }
+		result.push([x, y]);
+	}
+	
+	return result;
+}
+/**
+ * @class Simplified Dijkstra's algorithm: all edges have a value of 1
+ * @augments ROT.Path
+ * @see ROT.Path
+ */
+ROT.Path.Dijkstra = function(toX, toY, passableCallback, options) {
+	ROT.Path.call(this, toX, toY, passableCallback, options);
+
+	this._computed = {};
+	this._todo = [];
+	this._add(toX, toY, null);
+}
+ROT.Path.Dijkstra.extend(ROT.Path);
+
+/**
+ * Compute a path from a given point
+ * @see ROT.Path#compute
+ */
+ROT.Path.Dijkstra.prototype.compute = function(fromX, fromY, callback) {
+	var key = fromX+","+fromY;
+	if (!(key in this._computed)) { this._compute(fromX, fromY); }
+	if (!(key in this._computed)) { return; }
+	
+	var item = this._computed[key];
+	while (item) {
+		callback(item.x, item.y);
+		item = item.prev;
+	}
+}
+
+/**
+ * Compute a non-cached value
+ */
+ROT.Path.Dijkstra.prototype._compute = function(fromX, fromY) {
+	while (this._todo.length) {
+		var item = this._todo.shift();
+		if (item.x == fromX && item.y == fromY) { return; }
+		
+		var neighbors = this._getNeighbors(item.x, item.y);
+		
+		for (var i=0;i<neighbors.length;i++) {
+			var neighbor = neighbors[i];
+			var x = neighbor[0];
+			var y = neighbor[1];
+			var id = x+","+y;
+			if (id in this._computed) { continue; } /* already done */	
+			this._add(x, y, item); 
+		}
+	}
+}
+
+ROT.Path.Dijkstra.prototype._add = function(x, y, prev) {
+	var obj = {
+		x: x,
+		y: y,
+		prev: prev
+	}
+	this._computed[x+","+y] = obj;
+	this._todo.push(obj);
+}
+/**
+ * @class Simplified A* algorithm: all edges have a value of 1
+ * @augments ROT.Path
+ * @see ROT.Path
+ */
+ROT.Path.AStar = function(toX, toY, passableCallback, options) {
+	ROT.Path.call(this, toX, toY, passableCallback, options);
+
+	this._todo = [];
+	this._done = {};
+	this._fromX = null;
+	this._fromY = null;
+}
+ROT.Path.AStar.extend(ROT.Path);
+
+/**
+ * Compute a path from a given point
+ * @see ROT.Path#compute
+ */
+ROT.Path.AStar.prototype.compute = function(fromX, fromY, callback) {
+	this._todo = [];
+	this._done = {};
+	this._fromX = fromX;
+	this._fromY = fromY;
+	this._add(this._toX, this._toY, null);
+
+	while (this._todo.length) {
+		var item = this._todo.shift();
+		if (item.x == fromX && item.y == fromY) { break; }
+		var neighbors = this._getNeighbors(item.x, item.y);
+
+		for (var i=0;i<neighbors.length;i++) {
+			var neighbor = neighbors[i];
+			var x = neighbor[0];
+			var y = neighbor[1];
+			var id = x+","+y;
+			if (id in this._done) { continue; }
+			this._add(x, y, item); 
+		}
+	}
+	
+	var item = this._done[fromX+","+fromY];
+	if (!item) { return; }
+	
+	while (item) {
+		callback(item.x, item.y);
+		item = item.prev;
+	}
+}
+
+ROT.Path.AStar.prototype._add = function(x, y, prev) {
+	var obj = {
+		x: x,
+		y: y,
+		prev: prev,
+		g: (prev ? prev.g+1 : 0),
+		h: this._distance(x, y)
+	}
+	this._done[x+","+y] = obj;
+	
+	/* insert into priority queue */
+	
+	var f = obj.g + obj.h;
+	for (var i=0;i<this._todo.length;i++) {
+		var item = this._todo[i];
+		if (f < item.g + item.h) {
+			this._todo.splice(i, 0, obj);
+			return;
+		}
+	}
+	
+	this._todo.push(obj);
+}
+
+ROT.Path.AStar.prototype._distance = function(x, y) {
+	switch (this._options.topology) {
+		case 4:
+			return (Math.abs(x-this._fromX) + Math.abs(y-this._fromY));
+		break;
+
+		case 6:
+			var dx = Math.abs(x - this._fromX);
+			var dy = Math.abs(y - this._fromY);
+			return dy + Math.max(0, (dx-dy)/2);
+		break;
+
+		case 8: 
+			return Math.max(Math.abs(x-this._fromX), Math.abs(y-this._fromY));
+		break;
+	}
+}
+/**
+ * @class Base image (as ASCII art) converter
+ */
+ROT.Image = function() {
+	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
+	this.aDefaultColorCharList = (" CGO08@").split("");
+	this.strFont = "courier new";
+};
+
+ROT.Image.prototype.get = function(xin, yin) {
+	console.log(888);
+}
diff --git a/examples/test.html b/examples/test.html
new file mode 100644
index 00000000..b77779e3
--- /dev/null
+++ b/examples/test.html
@@ -0,0 +1,31 @@
+<html>
+<head>
+<title>test</title>
+</head>
+<body>
+<script type="text/javascript" src="rot.js"></script>
+<script type="text/javascript">
+var w = 256;
+var h = 100;
+var noise = new ROT.Noise.Simplex();
+var image = new ROT.Image();
+image.get();
+
+var display = new ROT.Display({width:w, height:h, fontSize:3});
+
+document.body.appendChild(display.getContainer());
+
+for (var j=0;j<h;j++) {
+    for (var i=0;i<w;i++) {
+        var val = noise.get(i/20, j/20) * 255;
+
+        var r = ~~(val>0 ? val : 0);
+        var g = ~~(val<0 ? -val : 0);
+        
+        display.draw(i, j, "", "", "rgb("+r+","+g+",0)");
+    }
+}
+</script>
+<canvas></canvas>
+</body>
+</html>
\ No newline at end of file

From e83835c38055d90c99765f8717e8d6354cdd42b1 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 20 Aug 2013 02:47:44 +0200
Subject: [PATCH 05/20] More job into the image ascii art.

---
 rot.js             | 14 ++++++-
 rot.min.js         |  2 +-
 src/image/image.js | 96 +++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 109 insertions(+), 3 deletions(-)

diff --git a/rot.js b/rot.js
index 52128abc..fcc2dc6d 100644
--- a/rot.js
+++ b/rot.js
@@ -1,6 +1,6 @@
 /*
 	This is rot.js, the ROguelike Toolkit in JavaScript.
-	Version 0.5~dev, generated on Thu Jul 25 08:44:01 CEST 2013.
+	Version 0.5~dev, generated on vie ago  9 01:23:35 CEST 2013.
 */
 
 /**
@@ -4729,3 +4729,15 @@ ROT.Path.AStar.prototype._distance = function(x, y) {
 		break;
 	}
 }
+/**
+ * @class Base image (as ASCII art) converter
+ */
+ROT.Image = function() {
+	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
+	this.aDefaultColorCharList = (" CGO08@").split("");
+	this.strFont = "courier new";
+};
+
+ROT.Image.prototype.get = function(xin, yin) {
+	console.log(888);
+}
diff --git a/rot.min.js b/rot.min.js
index 06a991c1..870c7304 100644
--- a/rot.min.js
+++ b/rot.min.js
@@ -132,4 +132,4 @@ ROT.Path.Dijkstra=function(a,b,c,d){ROT.Path.call(this,a,b,c,d);this._computed={
 ROT.Path.Dijkstra.prototype._compute=function(a,b){for(;this._todo.length;){var c=this._todo.shift();if(c.x==a&&c.y==b)break;for(var d=this._getNeighbors(c.x,c.y),e=0;e<d.length;e++){var f=d[e],g=f[0],f=f[1];g+","+f in this._computed||this._add(g,f,c)}}};ROT.Path.Dijkstra.prototype._add=function(a,b,c){c={x:a,y:b,prev:c};this._computed[a+","+b]=c;this._todo.push(c)};ROT.Path.AStar=function(a,b,c,d){ROT.Path.call(this,a,b,c,d);this._todo=[];this._done={};this._fromY=this._fromX=null};ROT.Path.AStar.extend(ROT.Path);
 ROT.Path.AStar.prototype.compute=function(a,b,c){this._todo=[];this._done={};this._fromX=a;this._fromY=b;for(this._add(this._toX,this._toY,null);this._todo.length;){var d=this._todo.shift();if(d.x==a&&d.y==b)break;for(var e=this._getNeighbors(d.x,d.y),f=0;f<e.length;f++){var g=e[f],h=g[0],g=g[1];h+","+g in this._done||this._add(h,g,d)}}if(d=this._done[a+","+b])for(;d;)c(d.x,d.y),d=d.prev};
 ROT.Path.AStar.prototype._add=function(a,b,c){c={x:a,y:b,prev:c,g:c?c.g+1:0,h:this._distance(a,b)};this._done[a+","+b]=c;a=c.g+c.h;for(b=0;b<this._todo.length;b++){var d=this._todo[b];if(a<d.g+d.h){this._todo.splice(b,0,c);return}}this._todo.push(c)};
-ROT.Path.AStar.prototype._distance=function(a,b){switch(this._options.topology){case 4:return Math.abs(a-this._fromX)+Math.abs(b-this._fromY);case 6:var c=Math.abs(a-this._fromX),d=Math.abs(b-this._fromY);return d+Math.max(0,(c-d)/2);case 8:return Math.max(Math.abs(a-this._fromX),Math.abs(b-this._fromY))}};
+ROT.Path.AStar.prototype._distance=function(a,b){switch(this._options.topology){case 4:return Math.abs(a-this._fromX)+Math.abs(b-this._fromY);case 6:var c=Math.abs(a-this._fromX),d=Math.abs(b-this._fromY);return d+Math.max(0,(c-d)/2);case 8:return Math.max(Math.abs(a-this._fromX),Math.abs(b-this._fromY))}};ROT.Image=function(){this.aDefaultCharList=" .,:;i1tfLCG08@".split("");this.aDefaultColorCharList=" CGO08@".split("");this.strFont="courier new"};ROT.Image.prototype.get=function(a,b){console.log(888)};
diff --git a/src/image/image.js b/src/image/image.js
index d0ab5926..f627e259 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -5,8 +5,102 @@ ROT.Image = function() {
 	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
 	this.aDefaultColorCharList = (" CGO08@").split("");
 	this.strFont = "courier new";
+	
+	this.ascii_art = "";
+};
+
+ROT.Image.prototype.loadASCII = function() {
+	var aCharList = this.aDefaultCharList;
+	var bBlock = true;
+	var bAlpha = false;
+	
+	var oCanvas = document.createElement("canvas");
+	if (!oCanvas.getContext) {
+		return;
+	}
+	var oCtx = oCanvas.getContext("2d");
+	if (!oCtx.getImageData) {
+		return;
+	}
+	
+	var strResolution = "low";
+	
+	var fResolution = 0.5;
+	
+	switch (strResolution) {
+		case "low" : 	fResolution = 0.25;	break;
+		case "medium" :	fResolution = 0.5;	break;
+		case "high" : 	fResolution = 1;	break;
+	}
+	
+	var iWidth = Math.round(parseInt(this.img.width) * fResolution);
+	var iHeight = Math.round(parseInt(this.img.height) * fResolution);
+	
+	oCanvas.width = iWidth;
+	oCanvas.height = iHeight;
+	//oCanvas.style.display = "none";
+	oCanvas.style.width = iWidth;
+	oCanvas.style.height = iHeight;
+	
+	oCtx.drawImage(this.img, 0, 0, iWidth, iHeight);
+	
+	var oImgData = oCtx.getImageData(0, 0, iWidth, iHeight).data;
+	
+	var strChars = "";
+	
+	for (var y=0;y<iHeight;y+=2) {
+		for (var x=0;x<iWidth;x++) {
+			var iOffset = (y*iWidth + x) * 4;
+			
+			var iRed = oImgData[iOffset];
+			var iGreen = oImgData[iOffset + 1];
+			var iBlue = oImgData[iOffset + 2];
+			var iAlpha = oImgData[iOffset + 3];
+			
+			if (iAlpha == 0) {
+				var iBrightIdx = 0;
+			} else {
+				var fBrightness = (0.3*iRed + 0.59*iGreen + 0.11*iBlue) / 255;
+				var iCharIdx = (aCharList.length-1) - Math.round(fBrightness * (aCharList.length-1));
+			}
+			
+			//~ if (bInvert) {
+				//~ iCharIdx = (aCharList.length-1) - iCharIdx;
+			//~ }
+			var strThisChar = aCharList[iCharIdx];
+			
+			if (strThisChar == " ") 
+				strThisChar = "&nbsp;";
+			
+			//~ if (bColor) {
+				strChars += "<span style='"
+					+ "color:rgb("+iRed+","+iGreen+","+iBlue+");"
+					+ (bBlock ? "background-color:rgb("+iRed+","+iGreen+","+iBlue+");" : "")
+					+ (bAlpha ? "opacity:" + (iAlpha/255) + ";" : "")
+					+ "'>" + strThisChar + "</span>";
+			//~ } else {
+				//~ strChars += strThisChar;
+			//~ }
+		}
+		strChars += "<br/>";
+	}
+	
+	return strChars;
+};
+
+ROT.Image.prototype.load = function(image_url) {
+	this.img = new Image();
+	this.img.src = image_url;
+	if (this.img.complete) {
+		this.ascii_art = this.loadASCII();
+	}
+	else {
+		this.img.onload = function() {
+			this.ascii_art = this.loadASCII()
+		}
+	}
 };
 
 ROT.Image.prototype.get = function(xin, yin) {
 	console.log(888);
-}
+};
\ No newline at end of file

From 82c4f889dfa0ccc5e0ec518e387f8c9f307c3fb4 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 20 Aug 2013 02:49:32 +0200
Subject: [PATCH 06/20] Delete a ugly files.

---
 examples/rot.js    | 4743 --------------------------------------------
 examples/test.html |   31 -
 2 files changed, 4774 deletions(-)
 delete mode 100644 examples/rot.js
 delete mode 100644 examples/test.html

diff --git a/examples/rot.js b/examples/rot.js
deleted file mode 100644
index fcc2dc6d..00000000
--- a/examples/rot.js
+++ /dev/null
@@ -1,4743 +0,0 @@
-/*
-	This is rot.js, the ROguelike Toolkit in JavaScript.
-	Version 0.5~dev, generated on vie ago  9 01:23:35 CEST 2013.
-*/
-
-/**
- * @namespace Top-level ROT namespace
- */
-var ROT = {
-	/**
-	 * @returns {bool} Is rot.js supported by this browser?
-	 */
-	isSupported: function() {
-		return !!(document.createElement("canvas").getContext && Function.prototype.bind);
-	},
-
-	/** Default with for display and map generators */
-	DEFAULT_WIDTH: 80,
-	/** Default height for display and map generators */
-	DEFAULT_HEIGHT: 25,
-
-	/** Directional constants. Ordering is important! */
-	DIRS: {
-		"4": [
-			[ 0, -1],
-			[ 1,  0],
-			[ 0,  1],
-			[-1,  0]
-		],
-		"8": [
-			[ 0, -1],
-			[ 1, -1],
-			[ 1,  0],
-			[ 1,  1],
-			[ 0,  1],
-			[-1,  1],
-			[-1,  0],
-			[-1, -1]
-		],
-		"6": [
-			[-1, -1],
-			[ 1, -1],
-			[ 2,  0],
-			[ 1,  1],
-			[-1,  1],
-			[-2,  0]
-		]
-	},
-
-	/** Cancel key. */
-	VK_CANCEL: 3, 
-	/** Help key. */
-	VK_HELP: 6, 
-	/** Backspace key. */
-	VK_BACK_SPACE: 8, 
-	/** Tab key. */
-	VK_TAB: 9, 
-	/** 5 key on Numpad when NumLock is unlocked. Or on Mac, clear key which is positioned at NumLock key. */
-	VK_CLEAR: 12, 
-	/** Return/enter key on the main keyboard. */
-	VK_RETURN: 13, 
-	/** Reserved, but not used. */
-	VK_ENTER: 14, 
-	/** Shift key. */
-	VK_SHIFT: 16, 
-	/** Control key. */
-	VK_CONTROL: 17, 
-	/** Alt (Option on Mac) key. */
-	VK_ALT: 18, 
-	/** Pause key. */
-	VK_PAUSE: 19, 
-	/** Caps lock. */
-	VK_CAPS_LOCK: 20, 
-	/** Escape key. */
-	VK_ESCAPE: 27, 
-	/** Space bar. */
-	VK_SPACE: 32, 
-	/** Page Up key. */
-	VK_PAGE_UP: 33, 
-	/** Page Down key. */
-	VK_PAGE_DOWN: 34, 
-	/** End key. */
-	VK_END: 35, 
-	/** Home key. */
-	VK_HOME: 36, 
-	/** Left arrow. */
-	VK_LEFT: 37, 
-	/** Up arrow. */
-	VK_UP: 38, 
-	/** Right arrow. */
-	VK_RIGHT: 39, 
-	/** Down arrow. */
-	VK_DOWN: 40, 
-	/** Print Screen key. */
-	VK_PRINTSCREEN: 44, 
-	/** Ins(ert) key. */
-	VK_INSERT: 45, 
-	/** Del(ete) key. */
-	VK_DELETE: 46, 
-	/***/
-	VK_0: 48,
-	/***/
-	VK_1: 49,
-	/***/
-	VK_2: 50,
-	/***/
-	VK_3: 51,
-	/***/
-	VK_4: 52,
-	/***/
-	VK_5: 53,
-	/***/
-	VK_6: 54,
-	/***/
-	VK_7: 55,
-	/***/
-	VK_8: 56,
-	/***/
-	VK_9: 57,
-	/** Colon (:) key. Requires Gecko 15.0 */
-	VK_COLON: 58, 
-	/** Semicolon (;) key. */
-	VK_SEMICOLON: 59, 
-	/** Less-than (<) key. Requires Gecko 15.0 */
-	VK_LESS_THAN: 60, 
-	/** Equals (=) key. */
-	VK_EQUALS: 61, 
-	/** Greater-than (>) key. Requires Gecko 15.0 */
-	VK_GREATER_THAN: 62, 
-	/** Question mark (?) key. Requires Gecko 15.0 */
-	VK_QUESTION_MARK: 63, 
-	/** Atmark (@) key. Requires Gecko 15.0 */
-	VK_AT: 64, 
-	/***/
-	VK_A: 65,
-	/***/
-	VK_B: 66,
-	/***/
-	VK_C: 67,
-	/***/
-	VK_D: 68,
-	/***/
-	VK_E: 69,
-	/***/
-	VK_F: 70,
-	/***/
-	VK_G: 71,
-	/***/
-	VK_H: 72,
-	/***/
-	VK_I: 73,
-	/***/
-	VK_J: 74,
-	/***/
-	VK_K: 75,
-	/***/
-	VK_L: 76,
-	/***/
-	VK_M: 77,
-	/***/
-	VK_N: 78,
-	/***/
-	VK_O: 79,
-	/***/
-	VK_P: 80,
-	/***/
-	VK_Q: 81,
-	/***/
-	VK_R: 82,
-	/***/
-	VK_S: 83,
-	/***/
-	VK_T: 84,
-	/***/
-	VK_U: 85,
-	/***/
-	VK_V: 86,
-	/***/
-	VK_W: 87,
-	/***/
-	VK_X: 88,
-	/***/
-	VK_Y: 89,
-	/***/
-	VK_Z: 90,
-	/***/
-	VK_CONTEXT_MENU: 93,
-	/** 0 on the numeric keypad. */
-	VK_NUMPAD0: 96, 
-	/** 1 on the numeric keypad. */
-	VK_NUMPAD1: 97, 
-	/** 2 on the numeric keypad. */
-	VK_NUMPAD2: 98, 
-	/** 3 on the numeric keypad. */
-	VK_NUMPAD3: 99, 
-	/** 4 on the numeric keypad. */
-	VK_NUMPAD4: 100, 
-	/** 5 on the numeric keypad. */
-	VK_NUMPAD5: 101, 
-	/** 6 on the numeric keypad. */
-	VK_NUMPAD6: 102, 
-	/** 7 on the numeric keypad. */
-	VK_NUMPAD7: 103, 
-	/** 8 on the numeric keypad. */
-	VK_NUMPAD8: 104, 
-	/** 9 on the numeric keypad. */
-	VK_NUMPAD9: 105, 
-	/** * on the numeric keypad. */
-	VK_MULTIPLY: 106,
-	/** + on the numeric keypad. */
-	VK_ADD: 107, 
-	/***/
-	VK_SEPARATOR: 108,
-	/** - on the numeric keypad. */
-	VK_SUBTRACT: 109, 
-	/** Decimal point on the numeric keypad. */
-	VK_DECIMAL: 110, 
-	/** / on the numeric keypad. */
-	VK_DIVIDE: 111, 
-	/** F1 key. */
-	VK_F1: 112, 
-	/** F2 key. */
-	VK_F2: 113, 
-	/** F3 key. */
-	VK_F3: 114, 
-	/** F4 key. */
-	VK_F4: 115, 
-	/** F5 key. */
-	VK_F5: 116, 
-	/** F6 key. */
-	VK_F6: 117, 
-	/** F7 key. */
-	VK_F7: 118, 
-	/** F8 key. */
-	VK_F8: 119, 
-	/** F9 key. */
-	VK_F9: 120, 
-	/** F10 key. */
-	VK_F10: 121, 
-	/** F11 key. */
-	VK_F11: 122, 
-	/** F12 key. */
-	VK_F12: 123, 
-	/** F13 key. */
-	VK_F13: 124, 
-	/** F14 key. */
-	VK_F14: 125, 
-	/** F15 key. */
-	VK_F15: 126, 
-	/** F16 key. */
-	VK_F16: 127, 
-	/** F17 key. */
-	VK_F17: 128, 
-	/** F18 key. */
-	VK_F18: 129, 
-	/** F19 key. */
-	VK_F19: 130, 
-	/** F20 key. */
-	VK_F20: 131, 
-	/** F21 key. */
-	VK_F21: 132, 
-	/** F22 key. */
-	VK_F22: 133, 
-	/** F23 key. */
-	VK_F23: 134, 
-	/** F24 key. */
-	VK_F24: 135, 
-	/** Num Lock key. */
-	VK_NUM_LOCK: 144, 
-	/** Scroll Lock key. */
-	VK_SCROLL_LOCK: 145, 
-	/** Circumflex (^) key. Requires Gecko 15.0 */
-	VK_CIRCUMFLEX: 160, 
-	/** Exclamation (!) key. Requires Gecko 15.0 */
-	VK_EXCLAMATION: 161, 
-	/** Double quote () key. Requires Gecko 15.0 */
-	VK_DOUBLE_QUOTE: 162, 
-	/** Hash (#) key. Requires Gecko 15.0 */
-	VK_HASH: 163, 
-	/** Dollar sign ($) key. Requires Gecko 15.0 */
-	VK_DOLLAR: 164, 
-	/** Percent (%) key. Requires Gecko 15.0 */
-	VK_PERCENT: 165, 
-	/** Ampersand (&) key. Requires Gecko 15.0 */
-	VK_AMPERSAND: 166, 
-	/** Underscore (_) key. Requires Gecko 15.0 */
-	VK_UNDERSCORE: 167, 
-	/** Open parenthesis (() key. Requires Gecko 15.0 */
-	VK_OPEN_PAREN: 168, 
-	/** Close parenthesis ()) key. Requires Gecko 15.0 */
-	VK_CLOSE_PAREN: 169, 
-	/* Asterisk (*) key. Requires Gecko 15.0 */
-	VK_ASTERISK: 170,
-	/** Plus (+) key. Requires Gecko 15.0 */
-	VK_PLUS: 171, 
-	/** Pipe (|) key. Requires Gecko 15.0 */
-	VK_PIPE: 172, 
-	/** Hyphen-US/docs/Minus (-) key. Requires Gecko 15.0 */
-	VK_HYPHEN_MINUS: 173, 
-	/** Open curly bracket ({) key. Requires Gecko 15.0 */
-	VK_OPEN_CURLY_BRACKET: 174, 
-	/** Close curly bracket (}) key. Requires Gecko 15.0 */
-	VK_CLOSE_CURLY_BRACKET: 175, 
-	/** Tilde (~) key. Requires Gecko 15.0 */
-	VK_TILDE: 176, 
-	/** Comma (,) key. */
-	VK_COMMA: 188, 
-	/** Period (.) key. */
-	VK_PERIOD: 190, 
-	/** Slash (/) key. */
-	VK_SLASH: 191, 
-	/** Back tick (`) key. */
-	VK_BACK_QUOTE: 192, 
-	/** Open square bracket ([) key. */
-	VK_OPEN_BRACKET: 219, 
-	/** Back slash (\) key. */
-	VK_BACK_SLASH: 220, 
-	/** Close square bracket (]) key. */
-	VK_CLOSE_BRACKET: 221, 
-	/** Quote (''') key. */
-	VK_QUOTE: 222, 
-	/** Meta key on Linux, Command key on Mac. */
-	VK_META: 224, 
-	/** AltGr key on Linux. Requires Gecko 15.0 */
-	VK_ALTGR: 225, 
-	/** Windows logo key on Windows. Or Super or Hyper key on Linux. Requires Gecko 15.0 */
-	VK_WIN: 91, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_KANA: 21, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_HANGUL: 21, 
-	/** 英数 key on Japanese Mac keyboard. Requires Gecko 15.0 */
-	VK_EISU: 22, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_JUNJA: 23, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_FINAL: 24, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_HANJA: 25, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_KANJI: 25, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_CONVERT: 28, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_NONCONVERT: 29, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_ACCEPT: 30, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_MODECHANGE: 31, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_SELECT: 41, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_PRINT: 42, 
-	/** Linux support for this keycode was added in Gecko 4.0. */
-	VK_EXECUTE: 43, 
-	/** Linux support for this keycode was added in Gecko 4.0.	 */
-	VK_SLEEP: 95 
-};
-/**
- * @namespace
- * Contains text tokenization and breaking routines
- */
-ROT.Text = {
-	RE_COLORS: /%([bc]){([^}]*)}/g,
-
-	/* token types */
-	TYPE_TEXT:		0,
-	TYPE_NEWLINE:	1,
-	TYPE_FG:		2,
-	TYPE_BG:		3,
-
-	/**
-	 * Measure size of a resulting text block
-	 */
-	measure: function(str, maxWidth) {
-		var result = {width:0, height:1};
-		var tokens = this.tokenize(str, maxWidth);
-		var lineWidth = 0;
-
-		for (var i=0;i<tokens.length;i++) {
-			var token = tokens[i];
-			switch (token.type) {
-				case this.TYPE_TEXT:
-					lineWidth += token.value.length;
-				break;
-
-				case this.TYPE_NEWLINE:
-					result.height++;
-					result.width = Math.max(result.width, lineWidth);
-					lineWidth = 0;
-				break;
-			}
-		}
-		result.width = Math.max(result.width, lineWidth);
-
-		return result;
-	},
-
-	/**
-	 * Convert string to a series of a formatting commands
-	 */
-	tokenize: function(str, maxWidth) {
-		var result = [];
-
-		/* first tokenization pass - split texts and color formatting commands */
-		var offset = 0;
-		str.replace(this.RE_COLORS, function(match, type, name, index) {
-			/* string before */
-			var part = str.substring(offset, index);
-			if (part.length) {
-				result.push({
-					type: ROT.Text.TYPE_TEXT,
-					value: part
-				});
-			}
-
-			/* color command */
-			result.push({
-				type: (type == "c" ? ROT.Text.TYPE_FG : ROT.Text.TYPE_BG),
-				value: name.trim()
-			});
-
-			offset = index + match.length;
-			return "";
-		});
-
-		/* last remaining part */
-		var part = str.substring(offset);
-		if (part.length) {
-			result.push({
-				type: ROT.Text.TYPE_TEXT,
-				value: part
-			});
-		}
-
-		return this._breakLines(result, maxWidth);
-	},
-
-	/* insert line breaks into first-pass tokenized data */
-	_breakLines: function(tokens, maxWidth) {
-		if (!maxWidth) { maxWidth = Infinity; };
-
-		var i = 0;
-		var lineLength = 0;
-		var lastTokenWithSpace = -1;
-
-		while (i < tokens.length) { /* take all text tokens, remove space, apply linebreaks */
-			var token = tokens[i];
-			if (token.type == ROT.Text.TYPE_NEWLINE) { /* reset */
-				lineLength = 0; 
-				lastTokenWithSpace = -1;
-			}
-			if (token.type != ROT.Text.TYPE_TEXT) { /* skip non-text tokens */
-				i++;
-				continue; 
-			}
-
-			/* remove spaces at the beginning of line */
-			while (lineLength == 0 && token.value.charAt(0) == " ") { token.value = token.value.substring(1); }
-
-			/* forced newline? insert two new tokens after this one */
-			var index = token.value.indexOf("\n");
-			if (index != -1) { 
-				token.value = this._breakInsideToken(tokens, i, index, true); 
-
-				/* if there are spaces at the end, we must remove them (we do not want the line too long) */
-				var arr = token.value.split("");
-				while (arr[arr.length-1] == " ") { arr.pop(); }
-				token.value = arr.join("");
-			}
-
-			/* token degenerated? */
-			if (!token.value.length) {
-				tokens.splice(i, 1);
-				continue;
-			}
-
-			if (lineLength + token.value.length > maxWidth) { /* line too long, find a suitable breaking spot */
-
-				/* is it possible to break within this token? */
-				var index = -1;
-				while (1) {
-					var nextIndex = token.value.indexOf(" ", index+1);
-					if (nextIndex == -1) { break; }
-					if (lineLength + nextIndex > maxWidth) { break; }
-					index = nextIndex;
-				}
-
-				if (index != -1) { /* break at space within this one */
-					token.value = this._breakInsideToken(tokens, i, index, true);
-				} else if (lastTokenWithSpace != -1) { /* is there a previous token where a break can occur? */
-					var token = tokens[lastTokenWithSpace];
-					var breakIndex = token.value.lastIndexOf(" ");
-					token.value = this._breakInsideToken(tokens, lastTokenWithSpace, breakIndex, true);
-					i = lastTokenWithSpace;
-				} else { /* force break in this token */
-					token.value = this._breakInsideToken(tokens, i, maxWidth-lineLength, false);
-				}
-
-			} else { /* line not long, continue */
-				lineLength += token.value.length;
-				if (token.value.indexOf(" ") != -1) { lastTokenWithSpace = i; }
-			}
-			
-			i++; /* advance to next token */
-		}
-
-
-		tokens.push({type: ROT.Text.TYPE_NEWLINE}); /* insert fake newline to fix the last text line */
-
-		/* remove trailing space from text tokens before newlines */
-		var lastTextToken = null;
-		for (var i=0;i<tokens.length;i++) {
-			var token = tokens[i];
-			switch (token.type) {
-				case ROT.Text.TYPE_TEXT: lastTextToken = token; break;
-				case ROT.Text.TYPE_NEWLINE: 
-					if (lastTextToken) { /* remove trailing space */
-						var arr = lastTextToken.value.split("");
-						while (arr[arr.length-1] == " ") { arr.pop(); }
-						lastTextToken.value = arr.join("");
-					}
-					lastTextToken = null;
-				break;
-			}
-		}
-
-		tokens.pop(); /* remove fake token */
-
-		return tokens;
-	},
-
-	/**
-	 * Create new tokens and insert them into the stream
-	 * @param {object[]} tokens
-	 * @param {int} tokenIndex Token being processed
-	 * @param {int} breakIndex Index within current token's value
-	 * @param {bool} removeBreakChar Do we want to remove the breaking character?
-	 * @returns {string} remaining unbroken token value
-	 */
-	_breakInsideToken: function(tokens, tokenIndex, breakIndex, removeBreakChar) {
-		var newBreakToken = {
-			type: ROT.Text.TYPE_NEWLINE
-		}
-		var newTextToken = {
-			type: ROT.Text.TYPE_TEXT,
-			value: tokens[tokenIndex].value.substring(breakIndex + (removeBreakChar ? 1 : 0))
-		}
-		tokens.splice(tokenIndex+1, 0, newBreakToken, newTextToken);
-		return tokens[tokenIndex].value.substring(0, breakIndex);
-	}
-}
-/**
- * @returns {any} Randomly picked item, null when length=0
- */
-Array.prototype.random = function() {
-	if (!this.length) { return null; }
-	return this[Math.floor(ROT.RNG.getUniform() * this.length)];
-}
-
-/**
- * @returns {array} New array with randomized items
- * FIXME destroys this!
- */
-Array.prototype.randomize = function() {
-	var result = [];
-	while (this.length) {
-		var index = this.indexOf(this.random());
-		result.push(this.splice(index, 1)[0]);
-	}
-	return result;
-}
-/**
- * Always positive modulus
- * @param {int} n Modulus
- * @returns {int} this modulo n
- */
-Number.prototype.mod = function(n) {
-	return ((this%n)+n)%n;
-}
-/**
- * @returns {string} First letter capitalized
- */
-String.prototype.capitalize = function() {
-	return this.charAt(0).toUpperCase() + this.substring(1);
-}
-
-/** 
- * Left pad
- * @param {string} [character="0"]
- * @param {int} [count=2]
- */
-String.prototype.lpad = function(character, count) {
-	var ch = character || "0";
-	var cnt = count || 2;
-
-	var s = "";
-	while (s.length < (cnt - this.length)) { s += ch; }
-	s = s.substring(0, cnt-this.length);
-	return s+this;
-}
-
-/** 
- * Right pad
- * @param {string} [character="0"]
- * @param {int} [count=2]
- */
-String.prototype.rpad = function(character, count) {
-	var ch = character || "0";
-	var cnt = count || 2;
-
-	var s = "";
-	while (s.length < (cnt - this.length)) { s += ch; }
-	s = s.substring(0, cnt-this.length);
-	return this+s;
-}
-
-/**
- * Format a string in a flexible way. Scans for %s strings and replaces them with arguments. List of patterns is modifiable via String.format.map.
- * @param {string} template
- * @param {any} [argv]
- */
-String.format = function(template) {
-	var map = String.format.map;
-	var args = Array.prototype.slice.call(arguments, 1);
-
-	var replacer = function(match, group1, group2, index) {
-		if (template.charAt(index-1) == "%") { return match.substring(1); }
-		if (!args.length) { return match; }
-		var obj = args[0];
-
-		var group = group1 || group2;
-		var parts = group.split(",");
-		var name = parts.shift();
-		var method = map[name.toLowerCase()];
-		if (!method) { return match; }
-
-		var obj = args.shift();
-		var replaced = obj[method].apply(obj, parts);
-
-		var first = name.charAt(0);
-		if (first != first.toLowerCase()) { replaced = replaced.capitalize(); }
-
-		return replaced;
-	}
-	return template.replace(/%(?:([a-z]+)|(?:{([^}]+)}))/gi, replacer);
-}
-
-String.format.map = {
-	"s": "toString"
-}
-
-/**
- * Convenience shortcut to String.format(this)
- */
-String.prototype.format = function() {
-	var args = Array.prototype.slice.call(arguments);
-	args.unshift(this);
-	return String.format.apply(String, args);
-}
-
-if (!Object.create) {  
-	/**
-	 * ES5 Object.create
-	 */
-	Object.create = function(o) {  
-		var tmp = function() {};
-		tmp.prototype = o;
-		return new tmp();
-	};  
-}  
-/**
- * Sets prototype of this function to an instance of parent function
- * @param {function} parent
- */
-Function.prototype.extend = function(parent) {
-	this.prototype = Object.create(parent.prototype);
-	this.prototype.constructor = this;
-	return this;
-}
-/**
- * @class Visual map display
- * @param {object} [options]
- * @param {int} [options.width=ROT.DEFAULT_WIDTH]
- * @param {int} [options.height=ROT.DEFAULT_HEIGHT]
- * @param {int} [options.fontSize=15]
- * @param {string} [options.fontFamily="monospace"]
- * @param {string} [options.fontStyle=""] bold/italic/none/both
- * @param {string} [options.fg="#ccc"]
- * @param {string} [options.bg="#000"]
- * @param {int} [options.fps=25]
- * @param {float} [options.spacing=1]
- * @param {float} [options.border=0]
- * @param {string} [options.layout="rect"]
- */
-ROT.Display = function(options) {
-	var canvas = document.createElement("canvas");
-	this._context = canvas.getContext("2d");
-	this._data = {};
-	this._dirty = false; /* false = nothing, true = all, object = dirty cells */
-	this._options = {};
-	this._backend = null;
-	
-	var defaultOptions = {
-		width: ROT.DEFAULT_WIDTH,
-		height: ROT.DEFAULT_HEIGHT,
-		layout: "rect",
-		fontSize: 15,
-		fps: 25,
-		spacing: 1,
-		border: 0,
-		fontFamily: "monospace",
-		fontStyle: "",
-		fg: "#ccc",
-		bg: "#000"
-	};
-	for (var p in options) { defaultOptions[p] = options[p]; }
-	this.setOptions(defaultOptions);
-	this.DEBUG = this.DEBUG.bind(this);
-	
-	this._interval = setInterval(this._tick.bind(this), 1000/this._options.fps);
-}
-
-/**
- * Debug helper, ideal as a map generator callback. Always bound to this.
- * @param {int} x
- * @param {int} y
- * @param {int} what
- */
-ROT.Display.prototype.DEBUG = function(x, y, what) {
-	var colors = [this._options.bg, this._options.fg];
-	this.draw(x, y, null, null, colors[what % colors.length]);
-}
-
-/**
- * Clear the whole display (cover it with background color)
- */
-ROT.Display.prototype.clear = function() {
-	this._data = {};
-	this._dirty = true;
-}
-
-/**
- * @see ROT.Display
- */
-ROT.Display.prototype.setOptions = function(options) {
-	for (var p in options) { this._options[p] = options[p]; }
-	if (options.width || options.height || options.fontSize || options.fontFamily || options.spacing || options.layout) {
-		if (options.layout) { 
-			this._backend = new ROT.Display[options.layout.capitalize()](this._context);
-		}
-
-		var font = (this._options.fontStyle ? this._options.fontStyle + " " : "") + this._options.fontSize + "px " + this._options.fontFamily;
-		this._context.font = font;
-		this._backend.compute(this._options);
-		this._context.font = font;
-		this._context.textAlign = "center";
-		this._context.textBaseline = "middle";
-		this._dirty = true;
-	}
-	return this;
-}
-
-/**
- * Returns currently set options
- * @returns {object} Current options object 
- */
-ROT.Display.prototype.getOptions = function() {
-	return this._options;
-}
-
-/**
- * Returns the DOM node of this display
- * @returns {node} DOM node
- */
-ROT.Display.prototype.getContainer = function() {
-	return this._context.canvas;
-}
-
-/**
- * Compute the maximum width/height to fit into a set of given constraints
- * @param {int} availWidth Maximum allowed pixel width
- * @param {int} availHeight Maximum allowed pixel height
- * @returns {int[2]} cellWidth,cellHeight
- */
-ROT.Display.prototype.computeSize = function(availWidth, availHeight) {
-	return this._backend.computeSize(availWidth, availHeight, this._options);
-}
-
-/**
- * Compute the maximum font size to fit into a set of given constraints
- * @param {int} availWidth Maximum allowed pixel width
- * @param {int} availHeight Maximum allowed pixel height
- * @returns {int} fontSize
- */
-ROT.Display.prototype.computeFontSize = function(availWidth, availHeight) {
-	return this._backend.computeFontSize(availWidth, availHeight, this._options);
-}
-
-/**
- * Convert a DOM event (mouse or touch) to map coordinates. Uses first touch for multi-touch.
- * @param {Event} e event
- * @returns {int[2]} -1 for values outside of the canvas
- */
-ROT.Display.prototype.eventToPosition = function(e) {
-	if (e.touches) {
-		var x = e.touches[0].clientX;
-		var y = e.touches[0].clientY;
-	} else {
-		var x = e.clientX;
-		var y = e.clientY;
-	}
-
-	var rect = this._context.canvas.getBoundingClientRect();
-	x -= rect.left;
-	y -= rect.top;
-	
-	if (x < 0 || y < 0 || x >= this._context.canvas.width || y >= this._context.canvas.height) { return [-1, -1]; }
-
-	return this._backend.eventToPosition(x, y);
-}
-
-/**
- * @param {int} x
- * @param {int} y
- * @param {string} ch 
- * @param {string} [fg] foreground color
- * @param {string} [bg] background color
- */
-ROT.Display.prototype.draw = function(x, y, ch, fg, bg) {
-	if (!fg) { fg = this._options.fg; }
-	if (!bg) { bg = this._options.bg; }
-	this._data[x+","+y] = [x, y, ch, fg, bg];
-	
-	if (this._dirty === true) { return; } /* will already redraw everything */
-	if (!this._dirty) { this._dirty = {}; } /* first! */
-	this._dirty[x+","+y] = true;
-}
-
-/**
- * Draws a text at given position. Optionally wraps at a maximum length. Currently does not work with hex layout.
- * @param {int} x
- * @param {int} y
- * @param {string} text May contain color/background format specifiers, %c{name}/%b{name}, both optional. %c{}/%b{} resets to default.
- * @param {int} [maxWidth] wrap at what width?
- * @returns {int} lines drawn
- */
-ROT.Display.prototype.drawText = function(x, y, text, maxWidth) {
-	var fg = null;
-	var bg = null;
-	var cx = x;
-	var cy = y;
-	var lines = 1;
-	if (!maxWidth) { maxWidth = this._options.width-x; }
-
-	var tokens = ROT.Text.tokenize(text, maxWidth);
-
-	while (tokens.length) { /* interpret tokenized opcode stream */
-		var token = tokens.shift();
-		switch (token.type) {
-			case ROT.Text.TYPE_TEXT:
-				for (var i=0;i<token.value.length;i++) {
-					this.draw(cx++, cy, token.value.charAt(i), fg, bg);
-				}
-			break;
-
-			case ROT.Text.TYPE_FG:
-				fg = token.value || null;
-			break;
-
-			case ROT.Text.TYPE_BG:
-				bg = token.value || null;
-			break;
-
-			case ROT.Text.TYPE_NEWLINE:
-				cx = x;
-				cy++;
-				lines++
-			break;
-		}
-	}
-
-	return lines;
-}
-
-/**
- * Timer tick: update dirty parts
- */
-ROT.Display.prototype._tick = function() {
-	if (!this._dirty) { return; }
-
-	if (this._dirty === true) { /* draw all */
-		this._context.fillStyle = this._options.bg;
-		this._context.fillRect(0, 0, this._context.canvas.width, this._context.canvas.height);
-
-		for (var id in this._data) { /* redraw cached data */
-			this._draw(id, false);
-		}
-
-	} else { /* draw only dirty */
-		for (var key in this._dirty) {
-			this._draw(key, true);
-		}
-	}
-
-	this._dirty = false;
-}
-
-/**
- * @param {string} key What to draw
- * @param {bool} clearBefore Is it necessary to clean before?
- */
-ROT.Display.prototype._draw = function(key, clearBefore) {
-	var data = this._data[key];
-	if (data[4] != this._options.bg) { clearBefore = true; }
-
-	this._backend.draw(data, clearBefore);
-}
-/**
- * @class Abstract display backend module
- * @private
- */
-ROT.Display.Backend = function(context) {
-	this._context = context;
-}
-
-ROT.Display.Backend.prototype.compute = function(options) {
-}
-
-ROT.Display.Backend.prototype.draw = function(data, clearBefore) {
-}
-
-ROT.Display.Backend.prototype.computeSize = function(availWidth, availHeight) {
-}
-
-ROT.Display.Backend.prototype.computeFontSize = function(availWidth, availHeight) {
-}
-
-ROT.Display.Backend.prototype.eventToPosition = function(x, y) {
-}
-/**
- * @class Rectangular backend
- * @private
- */
-ROT.Display.Rect = function(context) {
-	ROT.Display.Backend.call(this, context);
-	
-	this._spacingX = 0;
-	this._spacingY = 0;
-	this._canvasCache = {};
-	this._options = {};
-}
-ROT.Display.Rect.extend(ROT.Display.Backend);
-
-ROT.Display.Rect.cache = false;
-
-ROT.Display.Rect.prototype.compute = function(options) {
-	this._canvasCache = {};
-	this._options = options;
-
-	var charWidth = Math.ceil(this._context.measureText("W").width);
-	this._spacingX = Math.ceil(options.spacing * charWidth);
-	this._spacingY = Math.ceil(options.spacing * options.fontSize);
-	this._context.canvas.width = options.width * this._spacingX;
-	this._context.canvas.height = options.height * this._spacingY;
-}
-
-ROT.Display.Rect.prototype.draw = function(data, clearBefore) {
-	if (this.constructor.cache) {
-		this._drawWithCache(data, clearBefore);
-	} else {
-		this._drawNoCache(data, clearBefore);
-	}
-}
-
-ROT.Display.Rect.prototype._drawWithCache = function(data, clearBefore) {
-	var x = data[0];
-	var y = data[1];
-	var ch = data[2];
-	var fg = data[3];
-	var bg = data[4];
-
-	var hash = ""+ch+fg+bg;
-	if (hash in this._canvasCache) {
-		var canvas = this._canvasCache[hash];
-	} else {
-		var b = this._options.border;
-		var canvas = document.createElement("canvas");
-		var ctx = canvas.getContext("2d");
-		canvas.width = this._spacingX;
-		canvas.height = this._spacingY;
-		ctx.fillStyle = bg;
-		ctx.fillRect(b, b, canvas.width-b, canvas.height-b);
-		
-		if (ch) {
-			ctx.fillStyle = fg;
-			ctx.font = this._context.font;
-			ctx.textAlign = "center";
-			ctx.textBaseline = "middle";
-			ctx.fillText(ch, this._spacingX/2, this._spacingY/2);
-		}
-		this._canvasCache[hash] = canvas;
-	}
-	
-	this._context.drawImage(canvas, x*this._spacingX, y*this._spacingY);
-}
-
-ROT.Display.Rect.prototype._drawNoCache = function(data, clearBefore) {
-	var x = data[0];
-	var y = data[1];
-	var ch = data[2];
-	var fg = data[3];
-	var bg = data[4];
-
-	if (clearBefore) { 
-		var b = this._options.border;
-		this._context.fillStyle = bg;
-		this._context.fillRect(x*this._spacingX + b, y*this._spacingY + b, this._spacingX - b, this._spacingY - b);
-	}
-	
-	if (!ch) { return; }
-
-	this._context.fillStyle = fg;
-	this._context.fillText(ch, (x+0.5) * this._spacingX, (y+0.5) * this._spacingY);
-}
-
-ROT.Display.Rect.prototype.computeSize = function(availWidth, availHeight) {
-	var width = Math.floor(availWidth / this._spacingX);
-	var height = Math.floor(availHeight / this._spacingY);
-	return [width, height];
-}
-
-ROT.Display.Rect.prototype.computeFontSize = function(availWidth, availHeight) {
-	var boxWidth = Math.floor(availWidth / this._options.width);
-	var boxHeight = Math.floor(availHeight / this._options.height);
-
-	/* compute char ratio */
-	var oldFont = this._context.font;
-	this._context.font = "100px " + this._options.fontFamily;
-	var width = Math.ceil(this._context.measureText("W").width);
-	this._context.font = oldFont;
-	var ratio = width / 100;
-		
-	var widthFraction = ratio * boxHeight / boxWidth;
-	if (widthFraction > 1) { /* too wide with current aspect ratio */
-		boxHeight = Math.floor(boxHeight / widthFraction);
-	}
-	return Math.floor(boxHeight / this._options.spacing);
-}
-
-ROT.Display.Rect.prototype.eventToPosition = function(x, y) {
-	return [Math.floor(x/this._spacingX), Math.floor(y/this._spacingY)];
-}
-/**
- * @class Hexagonal backend
- * @private
- */
-ROT.Display.Hex = function(context) {
-	ROT.Display.Backend.call(this, context);
-
-	this._spacingX = 0;
-	this._spacingY = 0;
-	this._hexSize = 0;
-	this._options = {};
-}
-ROT.Display.Hex.extend(ROT.Display.Backend);
-
-ROT.Display.Hex.prototype.compute = function(options) {
-	this._options = options;
-
-	var charWidth = Math.ceil(this._context.measureText("W").width);
-	this._hexSize = Math.floor(options.spacing * (options.fontSize + charWidth/Math.sqrt(3)) / 2);
-	this._spacingX = this._hexSize * Math.sqrt(3) / 2;
-	this._spacingY = this._hexSize * 1.5;
-	this._context.canvas.width = Math.ceil( (options.width + 1) * this._spacingX );
-	this._context.canvas.height = Math.ceil( (options.height - 1) * this._spacingY + 2*this._hexSize );
-}
-
-ROT.Display.Hex.prototype.draw = function(data, clearBefore) {
-	var x = data[0];
-	var y = data[1];
-	var ch = data[2];
-	var fg = data[3];
-	var bg = data[4];
-
-	var cx = (x+1) * this._spacingX;
-	var cy = y * this._spacingY + this._hexSize;
-
-	if (clearBefore) { 
-		this._context.fillStyle = bg;
-		this._fill(cx, cy);
-	}
-	
-	if (!ch) { return; }
-
-	this._context.fillStyle = fg;
-	this._context.fillText(ch, cx, cy);
-}
-
-
-ROT.Display.Hex.prototype.computeSize = function(availWidth, availHeight) {
-	var width = Math.floor(availWidth / this._spacingX) - 1;
-	var height = Math.floor((availHeight - 2*this._hexSize) / this._spacingY + 1);
-	return [width, height];
-}
-
-ROT.Display.Hex.prototype.computeFontSize = function(availWidth, availHeight) {
-	var hexSizeWidth = 2*availWidth / ((this._options.width+1) * Math.sqrt(3)) - 1;
-	var hexSizeHeight = availHeight / (2 + 1.5*(this._options.height-1));
-	var hexSize = Math.min(hexSizeWidth, hexSizeHeight);
-
-	/* compute char ratio */
-	var oldFont = this._context.font;
-	this._context.font = "100px " + this._options.fontFamily;
-	var width = Math.ceil(this._context.measureText("W").width);
-	this._context.font = oldFont;
-	var ratio = width / 100;
-
-	hexSize = Math.floor(hexSize)+1; /* closest larger hexSize */
-
-	var fontSize = 2*hexSize / (this._options.spacing * (1 + ratio / Math.sqrt(3)));
-
-	/* closest smaller fontSize */
-	return Math.ceil(fontSize)-1;
-}
-
-ROT.Display.Hex.prototype.eventToPosition = function(x, y) {
-	var height = this._context.canvas.height / this._options.height;
-	y = Math.floor(y/height);
-	
-	if (y.mod(2)) { /* odd row */
-		x -= this._spacingX;
-		x = 1 + 2*Math.floor(x/(2*this._spacingX));
-	} else {
-		x = 2*Math.floor(x/(2*this._spacingX));
-	}
-	
-	return [x, y];
-}
-
-ROT.Display.Hex.prototype._fill = function(cx, cy) {
-	var a = this._hexSize;
-	var b = this._options.border;
-	
-	this._context.beginPath();
-	this._context.moveTo(cx, cy-a+b);
-	this._context.lineTo(cx + this._spacingX - b, cy-a/2+b);
-	this._context.lineTo(cx + this._spacingX - b, cy+a/2-b);
-	this._context.lineTo(cx, cy+a-b);
-	this._context.lineTo(cx - this._spacingX + b, cy+a/2-b);
-	this._context.lineTo(cx - this._spacingX + b, cy-a/2+b);
-	this._context.lineTo(cx, cy-a+b);
-	this._context.fill();
-}
-/**
- * @namespace
- * This code is an implementation of Alea algorithm; (C) 2010 Johannes Baagøe.
- * Alea is licensed according to the http://en.wikipedia.org/wiki/MIT_License.
- */
-ROT.RNG = {
-	/**
-	 * @returns {number} 
-	 */
-	getSeed: function() {
-		return this._seed;
-	},
-
-	/**
-	 * @param {number} seed Seed the number generator
-	 */
-	setSeed: function(seed) {
-		seed = (seed < 1 ? 1/seed : seed);
-
-		this._seed = seed;
-		this._s0 = (seed >>> 0) * this._frac;
-
-		seed = (seed*69069 + 1) >>> 0;
-		this._s1 = seed * this._frac;
-
-		seed = (seed*69069 + 1) >>> 0;
-		this._s2 = seed * this._frac;
-
-		this._c = 1;
-		return this;
-	},
-
-	/**
-	 * @returns {float} Pseudorandom value [0,1), uniformly distributed
-	 */
-	getUniform: function() {
-		var t = 2091639 * this._s0 + this._c * this._frac;
-		this._s0 = this._s1;
-		this._s1 = this._s2;
-		this._c = t | 0;
-		this._s2 = t - this._c;
-		return this._s2;
-	},
-
-	/**
-	 * @param {float} [mean=0] Mean value
-	 * @param {float} [stddev=1] Standard deviation. ~95% of the absolute values will be lower than 2*stddev.
-	 * @returns {float} A normally distributed pseudorandom value
-	 */
-	getNormal: function(mean, stddev) {
-		do {
-			var u = 2*this.getUniform()-1;
-			var v = 2*this.getUniform()-1;
-			var r = u*u + v*v;
-		} while (r > 1 || r == 0);
-
-		var gauss = u * Math.sqrt(-2*Math.log(r)/r);
-		return (mean || 0) + gauss*(stddev || 1);
-	},
-
-	/**
-	 * @returns {int} Pseudorandom value [1,100] inclusive, uniformly distributed
-	 */
-	getPercentage: function() {
-		return 1 + Math.floor(this.getUniform()*100);
-	},
-	
-	/**
-	 * @param {object} data key=whatever, value=weight (relative probability)
-	 * @returns {string} whatever
-	 */
-	getWeightedValue: function(data) {
-		var avail = [];
-		var total = 0;
-		
-		for (var id in data) {
-			total += data[id];
-		}
-		var random = Math.floor(this.getUniform()*total);
-		
-		var part = 0;
-		for (var id in data) {
-			part += data[id];
-			if (random < part) { return id; }
-		}
-		
-		return null;
-	},
-
-	/**
-	 * Get RNG state. Useful for storing the state and re-setting it via setState.
-	 * @returns {?} Internal state
-	 */
-	getState: function() {
-		return [this._s0, this._s1, this._s2, this._c];
-	},
-
-	/**
-	 * Set a previously retrieved state.
-	 * @param {?} state
-	 */
-	setState: function(state) {
-		this._s0 = state[0];
-		this._s1 = state[1];
-		this._s2 = state[2];
-		this._c  = state[3];
-		return this;
-	},
-
-	_s0: 0,
-	_s1: 0,
-	_s2: 0,
-	_c: 0,
-	_frac: 2.3283064365386963e-10 /* 2^-32 */
-}
-
-ROT.RNG.setSeed(Date.now());
-/**
- * @class (Markov process)-based string generator. 
- * Copied from a <a href="http://www.roguebasin.roguelikedevelopment.org/index.php?title=Names_from_a_high_order_Markov_Process_and_a_simplified_Katz_back-off_scheme">RogueBasin article</a>. 
- * Offers configurable order and prior.
- * @param {object} [options]
- * @param {bool} [options.words=false] Use word mode?
- * @param {int} [options.order=3]
- * @param {float} [options.prior=0.001]
- */
-ROT.StringGenerator = function(options) {
-	this._options = {
-		words: false,
-		order: 3,
-		prior: 0.001
-	}
-	for (var p in options) { this._options[p] = options[p]; }
-
-	this._boundary = String.fromCharCode(0);
-	this._suffix = this._boundary;
-	this._prefix = [];
-	for (var i=0;i<this._options.order;i++) { this._prefix.push(this._boundary); }
-
-	this._priorValues = {};
-	this._priorValues[this._boundary] = this._options.prior;
-
-	this._data = {};
-}
-
-/**
- * Remove all learning data
- */
-ROT.StringGenerator.prototype.clear = function() {
-	this._data = {};
-	this._priorValues = {};
-}
-
-/**
- * @returns {string} Generated string
- */
-ROT.StringGenerator.prototype.generate = function() {
-	var result = [this._sample(this._prefix)];
-	while (result[result.length-1] != this._boundary) {
-		result.push(this._sample(result));
-	}
-	return this._join(result.slice(0, -1));
-}
-
-/**
- * Observe (learn) a string from a training set
- */
-ROT.StringGenerator.prototype.observe = function(string) {
-	var tokens = this._split(string);
-
-	for (var i=0; i<tokens.length; i++) {
-		this._priorValues[tokens[i]] = this._options.prior;
-	}
-
-	tokens = this._prefix.concat(tokens).concat(this._suffix); /* add boundary symbols */
-
-	for (var i=this._options.order; i<tokens.length; i++) {
-		var context = tokens.slice(i-this._options.order, i);
-		var event = tokens[i];
-		for (var j=0; j<context.length; j++) {
-			var subcontext = context.slice(j);
-			this._observeEvent(subcontext, event);
-		}
-	}
-}
-
-ROT.StringGenerator.prototype.getStats = function() {
-	var parts = [];
-
-	var priorCount = 0;
-	for (var p in this._priorValues) { priorCount++; }
-	priorCount--; /* boundary */
-	parts.push("distinct samples: " + priorCount);
-
-	var dataCount = 0;
-	var eventCount = 0;
-	for (var p in this._data) { 
-		dataCount++; 
-		for (var key in this._data[p]) {
-			eventCount++;
-		}
-	}
-	parts.push("dictionary size (contexts): " + dataCount);
-	parts.push("dictionary size (events): " + eventCount);
-
-	return parts.join(", ");
-}
-
-/**
- * @param {string}
- * @returns {string[]}
- */
-ROT.StringGenerator.prototype._split = function(str) {
-	return str.split(this._options.words ? /\s+/ : "");
-}
-
-/**
- * @param {string[]}
- * @returns {string} 
- */
-ROT.StringGenerator.prototype._join = function(arr) {
-	return arr.join(this._options.words ? " " : "");
-}
-
-/**
- * @param {string[]} context
- * @param {string} event
- */
-ROT.StringGenerator.prototype._observeEvent = function(context, event) {
-	var key = this._join(context);
-	if (!(key in this._data)) { this._data[key] = {}; }
-	var data = this._data[key];
-
-	if (!(event in data)) { data[event] = 0; }
-	data[event]++;
-}
-
-/**
- * @param {string[]}
- * @returns {string}
- */
-ROT.StringGenerator.prototype._sample = function(context) {
-	context = this._backoff(context);
-	var key = this._join(context);
-	var data = this._data[key];
-
-	var available = {};
-
-	if (this._options.prior) {
-		for (var event in this._priorValues) { available[event] = this._priorValues[event]; }
-		for (var event in data) { available[event] += data[event]; }
-	} else { 
-		available = data;
-	}
-
-	return this._pickRandom(available);
-}
-
-/**
- * @param {string[]}
- * @returns {string[]}
- */
-ROT.StringGenerator.prototype._backoff = function(context) {
-	if (context.length > this._options.order) {
-		context = context.slice(-this._options.order);
-	} else if (context.length < this._options.order) {
-		context = this._prefix.slice(0, this._options.order - context.length).concat(context);
-	}
-
-	while (!(this._join(context) in this._data) && context.length > 0) { context = context.slice(1); }
-
-	return context;
-}
-
-
-ROT.StringGenerator.prototype._pickRandom = function(data) {
-	var total = 0;
-	
-	for (var id in data) {
-		total += data[id];
-	}
-	var random = ROT.RNG.getUniform()*total;
-	
-	var part = 0;
-	for (var id in data) {
-		part += data[id];
-		if (random < part) { return id; }
-	}
-}
-/**
- * @class Generic event queue: stores events and retrieves them based on their time
- */
-ROT.EventQueue = function() {
-	this._time = 0;
-	this._events = [];
-	this._eventTimes = [];
-}
-
-/**
- * @returns {number} Elapsed time
- */
-ROT.EventQueue.prototype.getTime = function() {
-	return this._time;
-}
-
-/**
- * Clear all scheduled events
- */
-ROT.EventQueue.prototype.clear = function() {
-	this._events = [];
-	this._eventTimes = [];
-	return this;
-}
-
-/**
- * @param {?} event
- * @param {number} time
- */
-ROT.EventQueue.prototype.add = function(event, time) {
-	var index = this._events.length;
-	for (var i=0;i<this._eventTimes.length;i++) {
-		if (this._eventTimes[i] > time) {
-			index = i;
-			break;
-		}
-	}
-
-	this._events.splice(index, 0, event);
-	this._eventTimes.splice(index, 0, time);
-}
-
-/**
- * Locates the nearest event, advances time if necessary. Returns that event and removes it from the queue.
- * @returns {? || null} The event previously added by addEvent, null if no event available
- */
-ROT.EventQueue.prototype.get = function() {
-	if (!this._events.length) { return null; }
-
-	var time = this._eventTimes.splice(0, 1)[0];
-	if (time > 0) { /* advance */
-		this._time += time;
-		for (var i=0;i<this._eventTimes.length;i++) { this._eventTimes[i] -= time; }
-	}
-
-	return this._events.splice(0, 1)[0];
-}
-
-/**
- * Remove an event from the queue
- * @param {?} event
- * @returns {bool} success?
- */
-ROT.EventQueue.prototype.remove = function(event) {
-	var index = this._events.indexOf(event);
-	if (index == -1) { return false }
-	this._remove(index);
-	return true;
-}
-
-/**
- * Remove an event from the queue
- * @param {int} index
- */
-ROT.EventQueue.prototype._remove = function(index) {
-	this._events.splice(index, 1);
-	this._eventTimes.splice(index, 1);
-}
-/**
- * @class Abstract scheduler
- */
-ROT.Scheduler = function() {
-	this._queue = new ROT.EventQueue();
-	this._repeat = [];
-	this._current = null;
-}
-
-/**
- * @see ROT.EventQueue#getTime
- */
-ROT.Scheduler.prototype.getTime = function() {
-	return this._queue.getTime();
-}
-
-/**
- * @param {?} item
- * @param {bool} repeat
- */
-ROT.Scheduler.prototype.add = function(item, repeat) {
-	if (repeat) { this._repeat.push(item); }
-	return this;
-}
-
-/**
- * Clear all items
- */
-ROT.Scheduler.prototype.clear = function() {
-	this._queue.clear();
-	this._repeat = [];
-	this._current = null;
-	return this;
-}
-
-/**
- * Remove a previously added item
- * @param {?} item
- * @returns {bool} successful?
- */
-ROT.Scheduler.prototype.remove = function(item) {
-	var result = this._queue.remove(item);
-
-	var index = this._repeat.indexOf(item);
-	if (index != -1) { this._repeat.splice(index, 1); }
-
-	if (this._current == item) { this._current = null; }
-
-	return result;
-}
-
-/**
- * Schedule next item
- * @returns {?}
- */
-ROT.Scheduler.prototype.next = function() {
-	this._current = this._queue.get();
-	return this._current;
-}
-/**
- * @class Simple fair scheduler (round-robin style)
- * @augments ROT.Scheduler
- */
-ROT.Scheduler.Simple = function() {
-	ROT.Scheduler.call(this);
-}
-ROT.Scheduler.Simple.extend(ROT.Scheduler);
-
-/**
- * @see ROT.Scheduler#add
- */
-ROT.Scheduler.Simple.prototype.add = function(item, repeat) {
-	this._queue.add(item, 0);
-	return ROT.Scheduler.prototype.add.call(this, item, repeat);
-}
-
-/**
- * @see ROT.Scheduler#next
- */
-ROT.Scheduler.Simple.prototype.next = function() {
-	if (this._current && this._repeat.indexOf(this._current) != -1) {
-		this._queue.add(this._current, 0);
-	}
-	return ROT.Scheduler.prototype.next.call(this);
-}
-/**
- * @class Speed-based scheduler
- * @augments ROT.Scheduler
- */
-ROT.Scheduler.Speed = function() {
-	ROT.Scheduler.call(this);
-}
-ROT.Scheduler.Speed.extend(ROT.Scheduler);
-
-/**
- * @param {object} item anything with "getSpeed" method
- * @param {bool} repeat
- * @see ROT.Scheduler#add
- */
-ROT.Scheduler.Speed.prototype.add = function(item, repeat) {
-	this._queue.add(item, 1/item.getSpeed());
-	return ROT.Scheduler.prototype.add.call(this, item, repeat);
-}
-
-/**
- * @see ROT.Scheduler#next
- */
-ROT.Scheduler.Speed.prototype.next = function() {
-	if (this._current && this._repeat.indexOf(this._current) != -1) {
-		this._queue.add(this._current, 1/this._current.getSpeed());
-	}
-	return ROT.Scheduler.prototype.next.call(this);
-}
-/**
- * @class Action-based scheduler
- * @augments ROT.Scheduler
- */
-ROT.Scheduler.Action = function() {
-	ROT.Scheduler.call(this);
-	this._defaultDuration = 1; /* for newly added */
-	this._duration = this._defaultDuration; /* for this._current */
-}
-ROT.Scheduler.Action.extend(ROT.Scheduler);
-
-/**
- * @param {object} item
- * @param {bool} repeat
- * @param {number} [time=1]
- * @see ROT.Scheduler#add
- */
-ROT.Scheduler.Action.prototype.add = function(item, repeat, time) {
-	this._queue.add(item, time || this._defaultDuration);
-	return ROT.Scheduler.prototype.add.call(this, item, repeat);
-}
-
-ROT.Scheduler.Action.prototype.clear = function() {
-	this._duration = this._defaultDuration;
-	return ROT.Scheduler.prototype.clear.call(this);
-}
-
-ROT.Scheduler.Action.prototype.remove = function(item) {
-	if (item == this._current) { this._duration = this._defaultDuration; }
-	return ROT.Scheduler.prototype.remove.call(this, item);
-}
-
-/**
- * @see ROT.Scheduler#next
- */
-ROT.Scheduler.Action.prototype.next = function() {
-	if (this._current && this._repeat.indexOf(this._current) != -1) {
-		this._queue.add(this._current, this._duration || this._defaultDuration);
-		this._duration = this._defaultDuration;
-	}
-	return ROT.Scheduler.prototype.next.call(this);
-}
-
-/**
- * Set duration for the active item
- */
-ROT.Scheduler.Action.prototype.setDuration = function(time) {
-	if (this._current) { this._duration = time; }
-	return this;
-}
-/**
- * @class Asynchronous main loop
- * @param {ROT.Scheduler} scheduler
- */
-ROT.Engine = function(scheduler) {
-	this._scheduler = scheduler;
-	this._lock = 1;
-}
-
-/**
- * Start the main loop. When this call returns, the loop is locked.
- */
-ROT.Engine.prototype.start = function() {
-	return this.unlock();
-}
-
-/**
- * Interrupt the engine by an asynchronous action
- */
-ROT.Engine.prototype.lock = function() {
-	this._lock++;
-}
-
-/**
- * Resume execution (paused by a previous lock)
- */
-ROT.Engine.prototype.unlock = function() {
-	if (!this._lock) { throw new Error("Cannot unlock unlocked engine"); }
-	this._lock--;
-
-	while (!this._lock) {
-		var actor = this._scheduler.next();
-		if (!actor) { return this.lock(); } /* no actors */
-		actor.act();
-	}
-
-	return this;
-}
-/**
- * @class Base map generator
- * @param {int} [width=ROT.DEFAULT_WIDTH]
- * @param {int} [height=ROT.DEFAULT_HEIGHT]
- */
-ROT.Map = function(width, height) {
-	this._width = width || ROT.DEFAULT_WIDTH;
-	this._height = height || ROT.DEFAULT_HEIGHT;
-};
-
-ROT.Map.prototype.create = function(callback) {}
-
-ROT.Map.prototype._fillMap = function(value) {
-	var map = [];
-	for (var i=0;i<this._width;i++) {
-		map.push([]);
-		for (var j=0;j<this._height;j++) { map[i].push(value); }
-	}
-	return map;
-}
-/**
- * @class Simple empty rectangular room
- * @augments ROT.Map
- */
-ROT.Map.Arena = function(width, height) {
-	ROT.Map.call(this, width, height);
-}
-ROT.Map.Arena.extend(ROT.Map);
-
-ROT.Map.Arena.prototype.create = function(callback) {
-	var w = this._width-1;
-	var h = this._height-1;
-	for (var i=0;i<=w;i++) {
-		for (var j=0;j<=h;j++) {
-			var empty = (i && j && i<w && j<h);
-			callback(i, j, empty ? 0 : 1);
-		}
-	}
-	return this;
-}
-/**
- * @class Recursively divided maze, http://en.wikipedia.org/wiki/Maze_generation_algorithm#Recursive_division_method
- * @augments ROT.Map
- */
-ROT.Map.DividedMaze = function(width, height) {
-	ROT.Map.call(this, width, height);
-	this._stack = [];
-}
-ROT.Map.DividedMaze.extend(ROT.Map);
-
-ROT.Map.DividedMaze.prototype.create = function(callback) {
-	var w = this._width;
-	var h = this._height;
-	
-	this._map = [];
-	
-	for (var i=0;i<w;i++) {
-		this._map.push([]);
-		for (var j=0;j<h;j++) {
-			var border = (i == 0 || j == 0 || i+1 == w || j+1 == h);
-			this._map[i].push(border ? 1 : 0);
-		}
-	}
-	
-	this._stack = [
-		[1, 1, w-2, h-2]
-	];
-	this._process();
-	
-	for (var i=0;i<w;i++) {
-		for (var j=0;j<h;j++) {
-			callback(i, j, this._map[i][j]);
-		}
-	}
-	this._map = null;
-	return this;
-}
-
-ROT.Map.DividedMaze.prototype._process = function() {
-	while (this._stack.length) {
-		var room = this._stack.shift(); /* [left, top, right, bottom] */
-		this._partitionRoom(room);
-	}
-}
-
-ROT.Map.DividedMaze.prototype._partitionRoom = function(room) {
-	var availX = [];
-	var availY = [];
-	
-	for (var i=room[0]+1;i<room[2];i++) {
-		var top = this._map[i][room[1]-1];
-		var bottom = this._map[i][room[3]+1];
-		if (top && bottom && !(i % 2)) { availX.push(i); }
-	}
-	
-	for (var j=room[1]+1;j<room[3];j++) {
-		var left = this._map[room[0]-1][j];
-		var right = this._map[room[2]+1][j];
-		if (left && right && !(j % 2)) { availY.push(j); }
-	}
-
-	if (!availX.length || !availY.length) { return; }
-
-	var x = availX.random();
-	var y = availY.random();
-	
-	this._map[x][y] = 1;
-	
-	var walls = [];
-	
-	var w = []; walls.push(w); /* left part */
-	for (var i=room[0]; i<x; i++) { 
-		this._map[i][y] = 1;
-		w.push([i, y]); 
-	}
-	
-	var w = []; walls.push(w); /* right part */
-	for (var i=x+1; i<=room[2]; i++) { 
-		this._map[i][y] = 1;
-		w.push([i, y]); 
-	}
-
-	var w = []; walls.push(w); /* top part */
-	for (var j=room[1]; j<y; j++) { 
-		this._map[x][j] = 1;
-		w.push([x, j]); 
-	}
-	
-	var w = []; walls.push(w); /* bottom part */
-	for (var j=y+1; j<=room[3]; j++) { 
-		this._map[x][j] = 1;
-		w.push([x, j]); 
-	}
-		
-	var solid = walls.random();
-	for (var i=0;i<walls.length;i++) {
-		var w = walls[i];
-		if (w == solid) { continue; }
-		
-		var hole = w.random();
-		this._map[hole[0]][hole[1]] = 0;
-	}
-
-	this._stack.push([room[0], room[1], x-1, y-1]); /* left top */
-	this._stack.push([x+1, room[1], room[2], y-1]); /* right top */
-	this._stack.push([room[0], y+1, x-1, room[3]]); /* left bottom */
-	this._stack.push([x+1, y+1, room[2], room[3]]); /* right bottom */
-}
-/**
- * @class Icey's Maze generator
- * See http://www.roguebasin.roguelikedevelopment.org/index.php?title=Simple_maze for explanation
- * @augments ROT.Map
- */
-ROT.Map.IceyMaze = function(width, height, regularity) {
-	ROT.Map.call(this, width, height);
-	this._regularity = regularity || 0;
-}
-ROT.Map.IceyMaze.extend(ROT.Map);
-
-ROT.Map.IceyMaze.prototype.create = function(callback) {
-	var width = this._width;
-	var height = this._height;
-	
-	var map = this._fillMap(1);
-	
-	width -= (width % 2 ? 1 : 2);
-	height -= (height % 2 ? 1 : 2);
-
-	var cx = 0;
-	var cy = 0;
-	var nx = 0;
-	var ny = 0;
-
-	var done = 0;
-	var blocked = false;
-	var dirs = [
-		[0, 0],
-		[0, 0],
-		[0, 0],
-		[0, 0]
-	];
-	do {
-		cx = 1 + 2*Math.floor(ROT.RNG.getUniform()*(width-1) / 2);
-		cy = 1 + 2*Math.floor(ROT.RNG.getUniform()*(height-1) / 2);
-
-		if (!done) { map[cx][cy] = 0; }
-		
-		if (!map[cx][cy]) {
-			this._randomize(dirs);
-			do {
-				if (Math.floor(ROT.RNG.getUniform()*(this._regularity+1)) == 0) { this._randomize(dirs); }
-				blocked = true;
-				for (var i=0;i<4;i++) {
-					nx = cx + dirs[i][0]*2;
-					ny = cy + dirs[i][1]*2;
-					if (this._isFree(map, nx, ny, width, height)) {
-						map[nx][ny] = 0;
-						map[cx + dirs[i][0]][cy + dirs[i][1]] = 0;
-						
-						cx = nx;
-						cy = ny;
-						blocked = false;
-						done++;
-						break;
-					}
-				}
-			} while (!blocked);
-		}
-	} while (done+1 < width*height/4);
-	
-	for (var i=0;i<this._width;i++) {
-		for (var j=0;j<this._height;j++) {
-			callback(i, j, map[i][j]);
-		}
-	}
-	this._map = null;
-	return this;
-}
-
-ROT.Map.IceyMaze.prototype._randomize = function(dirs) {
-	for (var i=0;i<4;i++) {
-		dirs[i][0] = 0;
-		dirs[i][1] = 0;
-	}
-	
-	switch (Math.floor(ROT.RNG.getUniform()*4)) {
-		case 0:
-			dirs[0][0] = -1; dirs[1][0] = 1;
-			dirs[2][1] = -1; dirs[3][1] = 1;
-		break;
-		case 1:
-			dirs[3][0] = -1; dirs[2][0] = 1;
-			dirs[1][1] = -1; dirs[0][1] = 1;
-		break;
-		case 2:
-			dirs[2][0] = -1; dirs[3][0] = 1;
-			dirs[0][1] = -1; dirs[1][1] = 1;
-		break;
-		case 3:
-			dirs[1][0] = -1; dirs[0][0] = 1;
-			dirs[3][1] = -1; dirs[2][1] = 1;
-		break;
-	}
-}
-
-ROT.Map.IceyMaze.prototype._isFree = function(map, x, y, width, height) {
-	if (x < 1 || y < 1 || x >= width || y >= height) { return false; }
-	return map[x][y];
-}
-/**
- * @class Maze generator - Eller's algorithm
- * See http://homepages.cwi.nl/~tromp/maze.html for explanation
- * @augments ROT.Map
- */
-ROT.Map.EllerMaze = function(width, height) {
-	ROT.Map.call(this, width, height);
-}
-ROT.Map.EllerMaze.extend(ROT.Map);
-
-ROT.Map.EllerMaze.prototype.create = function(callback) {
-	var map = this._fillMap(1);
-	var w = Math.ceil((this._width-2)/2);
-	
-	var rand = 9/24;
-	
-	var L = [];
-	var R = [];
-	
-	for (var i=0;i<w;i++) {
-		L.push(i);
-		R.push(i);
-	}
-	L.push(w-1); /* fake stop-block at the right side */
-
-	for (var j=1;j+3<this._height;j+=2) {
-		/* one row */
-		for (var i=0;i<w;i++) {
-			/* cell coords (will be always empty) */
-			var x = 2*i+1;
-			var y = j;
-			map[x][y] = 0;
-			
-			/* right connection */
-			if (i != L[i+1] && ROT.RNG.getUniform() > rand) {
-				this._addToList(i, L, R);
-				map[x+1][y] = 0;
-			}
-			
-			/* bottom connection */
-			if (i != L[i] && ROT.RNG.getUniform() > rand) {
-				/* remove connection */
-				this._removeFromList(i, L, R);
-			} else {
-				/* create connection */
-				map[x][y+1] = 0;
-			}
-		}
-	}
-
-	/* last row */
-	for (var i=0;i<w;i++) {
-		/* cell coords (will be always empty) */
-		var x = 2*i+1;
-		var y = j;
-		map[x][y] = 0;
-		
-		/* right connection */
-		if (i != L[i+1] && (i == L[i] || ROT.RNG.getUniform() > rand)) {
-			/* dig right also if the cell is separated, so it gets connected to the rest of maze */
-			this._addToList(i, L, R);
-			map[x+1][y] = 0;
-		}
-		
-		this._removeFromList(i, L, R);
-	}
-	
-	for (var i=0;i<this._width;i++) {
-		for (var j=0;j<this._height;j++) {
-			callback(i, j, map[i][j]);
-		}
-	}
-	
-	return this;
-}
-
-/**
- * Remove "i" from its list
- */
-ROT.Map.EllerMaze.prototype._removeFromList = function(i, L, R) {
-	R[L[i]] = R[i];
-	L[R[i]] = L[i];
-	R[i] = i;
-	L[i] = i;
-}
-
-/**
- * Join lists with "i" and "i+1"
- */
-ROT.Map.EllerMaze.prototype._addToList = function(i, L, R) {
-	R[L[i+1]] = R[i];
-	L[R[i]] = L[i+1];
-	R[i] = i+1;
-	L[i+1] = i;
-}
-/**
- * @class Cellular automaton map generator
- * @augments ROT.Map
- * @param {int} [width=ROT.DEFAULT_WIDTH]
- * @param {int} [height=ROT.DEFAULT_HEIGHT]
- * @param {object} [options] Options
- * @param {int[]} [options.born] List of neighbor counts for a new cell to be born in empty space
- * @param {int[]} [options.survive] List of neighbor counts for an existing  cell to survive
- * @param {int} [options.topology] Topology 4 or 6 or 8
- */
-ROT.Map.Cellular = function(width, height, options) {
-	ROT.Map.call(this, width, height);
-	this._options = {
-		born: [5, 6, 7, 8],
-		survive: [4, 5, 6, 7, 8],
-		topology: 8
-	};
-	for (var p in options) { this._options[p] = options[p]; }
-	
-	this._dirs = ROT.DIRS[this._options.topology];
-	this._map = this._fillMap(0);
-}
-ROT.Map.Cellular.extend(ROT.Map);
-
-/**
- * Fill the map with random values
- * @param {float} probability Probability for a cell to become alive; 0 = all empty, 1 = all full
- */
-ROT.Map.Cellular.prototype.randomize = function(probability) {
-	for (var i=0;i<this._width;i++) {
-		for (var j=0;j<this._height;j++) {
-			this._map[i][j] = (ROT.RNG.getUniform() < probability ? 1 : 0);
-		}
-	}
-	return this;
-}
-
-ROT.Map.Cellular.prototype.set = function(x, y, value) {
-	this._map[x][y] = value;
-}
-
-ROT.Map.Cellular.prototype.create = function(callback) {
-	var newMap = this._fillMap(0);
-	var born = this._options.born;
-	var survive = this._options.survive;
-
-
-	for (var j=0;j<this._height;j++) {
-		var widthStep = 1;
-		var widthStart = 0;
-		if (this._options.topology == 6) { 
-			widthStep = 2;
-			widthStart = j%2;
-		}
-
-		for (var i=widthStart; i<this._width; i+=widthStep) {
-
-			var cur = this._map[i][j];
-			var ncount = this._getNeighbors(i, j);
-			
-			if (cur && survive.indexOf(ncount) != -1) { /* survive */
-				newMap[i][j] = 1;
-			} else if (!cur && born.indexOf(ncount) != -1) { /* born */
-				newMap[i][j] = 1;
-			}
-			
-			if (callback) { callback(i, j, newMap[i][j]); }
-		}
-	}
-	
-	this._map = newMap;
-}
-
-/**
- * Get neighbor count at [i,j] in this._map
- */
-ROT.Map.Cellular.prototype._getNeighbors = function(cx, cy) {
-	var result = 0;
-	for (var i=0;i<this._dirs.length;i++) {
-		var dir = this._dirs[i];
-		var x = cx + dir[0];
-		var y = cy + dir[1];
-		
-		if (x < 0 || x >= this._width || x < 0 || y >= this._width) { continue; }
-		result += (this._map[x][y] == 1 ? 1 : 0);
-	}
-	
-	return result;
-}
-/**
- * @class Dungeon map: has rooms and corridors
- * @augments ROT.Map
- */
-ROT.Map.Dungeon = function(width, height) {
-	ROT.Map.call(this, width, height);
-	this._rooms = []; /* list of all rooms */
-	this._corridors = [];
-}
-ROT.Map.Dungeon.extend(ROT.Map);
-
-/**
- * Get all generated rooms
- * @returns {ROT.Map.Feature.Room[]}
- */
-ROT.Map.Dungeon.prototype.getRooms = function() {
-	return this._rooms;
-}
-
-/**
- * Get all generated corridors
- * @returns {ROT.Map.Feature.Corridor[]}
- */
-ROT.Map.Dungeon.prototype.getCorridors = function() {
-	return this._corridors;
-}
-/**
- * @class Random dungeon generator using human-like digging patterns.
- * Heavily based on Mike Anderson's ideas from the "Tyrant" algo, mentioned at 
- * http://www.roguebasin.roguelikedevelopment.org/index.php?title=Dungeon-Building_Algorithm.
- * @augments ROT.Map.Dungeon
- */
-ROT.Map.Digger = function(width, height, options) {
-	ROT.Map.Dungeon.call(this, width, height);
-	
-	this._options = {
-		roomWidth: [3, 9], /* room minimum and maximum width */
-		roomHeight: [3, 5], /* room minimum and maximum height */
-		corridorLength: [3, 10], /* corridor minimum and maximum length */
-		dugPercentage: 0.2, /* we stop after this percentage of level area has been dug out */
-		timeLimit: 1000 /* we stop after this much time has passed (msec) */
-	}
-	for (var p in options) { this._options[p] = options[p]; }
-	
-	this._features = {
-		"Room": 4,
-		"Corridor": 4
-	}
-	this._featureAttempts = 20; /* how many times do we try to create a feature on a suitable wall */
-	this._walls = {}; /* these are available for digging */
-	
-	this._digCallback = this._digCallback.bind(this);
-	this._canBeDugCallback = this._canBeDugCallback.bind(this);
-	this._isWallCallback = this._isWallCallback.bind(this);
-	this._priorityWallCallback = this._priorityWallCallback.bind(this);
-}
-ROT.Map.Digger.extend(ROT.Map.Dungeon);
-
-/**
- * Create a map
- * @see ROT.Map#create
- */
-ROT.Map.Digger.prototype.create = function(callback) {
-	this._rooms = [];
-	this._corridors = [];
-	this._map = this._fillMap(1);
-	this._walls = {};
-	this._dug = 0;
-	var area = (this._width-2) * (this._height-2);
-
-	this._firstRoom();
-	
-	var t1 = Date.now();
-
-	do {
-		var t2 = Date.now();
-		if (t2 - t1 > this._options.timeLimit) { break; }
-
-		/* find a good wall */
-		var wall = this._findWall();
-		if (!wall) { break; } /* no more walls */
-		
-		var parts = wall.split(",");
-		var x = parseInt(parts[0]);
-		var y = parseInt(parts[1]);
-		var dir = this._getDiggingDirection(x, y);
-		if (!dir) { continue; } /* this wall is not suitable */
-		
-//		console.log("wall", x, y);
-
-		/* try adding a feature */
-		var featureAttempts = 0;
-		do {
-			featureAttempts++;
-			if (this._tryFeature(x, y, dir[0], dir[1])) { /* feature added */
-				//if (this._rooms.length + this._corridors.length == 2) { this._rooms[0].addDoor(x, y); } /* first room oficially has doors */
-				this._removeSurroundingWalls(x, y);
-				this._removeSurroundingWalls(x-dir[0], y-dir[1]);
-				break; 
-			}
-		} while (featureAttempts < this._featureAttempts);
-		
-		var priorityWalls = 0;
-		for (var id in this._walls) { 
-			if (this._walls[id] > 1) { priorityWalls++; }
-		}
-
-	} while (this._dug/area < this._options.dugPercentage || priorityWalls); /* fixme number of priority walls */
-
-	this._addDoors();
-
-	if (callback) {
-		for (var i=0;i<this._width;i++) {
-			for (var j=0;j<this._height;j++) {
-				callback(i, j, this._map[i][j]);
-			}
-		}
-	}
-	
-	this._walls = {};
-	this._map = null;
-
-	return this;
-}
-
-ROT.Map.Digger.prototype._digCallback = function(x, y, value) {
-	if (value == 0 || value == 2) { /* empty */
-		this._map[x][y] = 0;
-		this._dug++;
-	} else { /* wall */
-		this._walls[x+","+y] = 1;
-	}
-}
-
-ROT.Map.Digger.prototype._isWallCallback = function(x, y) {
-	if (x < 0 || y < 0 || x >= this._width || y >= this._height) { return false; }
-	return (this._map[x][y] == 1);
-}
-
-ROT.Map.Digger.prototype._canBeDugCallback = function(x, y) {
-	if (x < 1 || y < 1 || x+1 >= this._width || y+1 >= this._height) { return false; }
-	return (this._map[x][y] == 1);
-}
-
-ROT.Map.Digger.prototype._priorityWallCallback = function(x, y) {
-	this._walls[x+","+y] = 2;
-}
-
-ROT.Map.Digger.prototype._firstRoom = function() {
-	var cx = Math.floor(this._width/2);
-	var cy = Math.floor(this._height/2);
-	var room = ROT.Map.Feature.Room.createRandomCenter(cx, cy, this._options);
-	this._rooms.push(room);
-	room.create(this._digCallback);
-}
-
-/**
- * Get a suitable wall
- */
-ROT.Map.Digger.prototype._findWall = function() {
-	var prio1 = [];
-	var prio2 = [];
-	for (var id in this._walls) {
-		var prio = this._walls[id];
-		if (prio == 2) { 
-			prio2.push(id); 
-		} else {
-			prio1.push(id);
-		}
-	}
-	
-	var arr = (prio2.length ? prio2 : prio1);
-	if (!arr.length) { return null; } /* no walls :/ */
-	
-	var id = arr.random();
-	delete this._walls[id];
-
-	return id;
-}
-
-/**
- * Tries adding a feature
- * @returns {bool} was this a successful try?
- */
-ROT.Map.Digger.prototype._tryFeature = function(x, y, dx, dy) {
-	var feature = ROT.RNG.getWeightedValue(this._features);
-	feature = ROT.Map.Feature[feature].createRandomAt(x, y, dx, dy, this._options);
-	
-	if (!feature.isValid(this._isWallCallback, this._canBeDugCallback)) {
-//		console.log("not valid");
-//		feature.debug();
-		return false;
-	}
-	
-	feature.create(this._digCallback);
-//	feature.debug();
-
-	if (feature instanceof ROT.Map.Feature.Room) { this._rooms.push(feature); }
-	if (feature instanceof ROT.Map.Feature.Corridor) { 
-		feature.createPriorityWalls(this._priorityWallCallback);
-		this._corridors.push(feature); 
-	}
-	
-	return true;
-}
-
-ROT.Map.Digger.prototype._removeSurroundingWalls = function(cx, cy) {
-	var deltas = ROT.DIRS[4];
-
-	for (var i=0;i<deltas.length;i++) {
-		var delta = deltas[i];
-		var x = cx + delta[0];
-		var y = cy + delta[1];
-		delete this._walls[x+","+y];
-		var x = cx + 2*delta[0];
-		var y = cy + 2*delta[1];
-		delete this._walls[x+","+y];
-	}
-}
-
-/**
- * Returns vector in "digging" direction, or false, if this does not exist (or is not unique)
- */
-ROT.Map.Digger.prototype._getDiggingDirection = function(cx, cy) {
-	var result = null;
-	var deltas = ROT.DIRS[4];
-	
-	for (var i=0;i<deltas.length;i++) {
-		var delta = deltas[i];
-		var x = cx + delta[0];
-		var y = cy + delta[1];
-		
-		if (x < 0 || y < 0 || x >= this._width || y >= this._width) { return null; }
-		
-		if (!this._map[x][y]) { /* there already is another empty neighbor! */
-			if (result) { return null; }
-			result = delta;
-		}
-	}
-	
-	/* no empty neighbor */
-	if (!result) { return null; }
-	
-	return [-result[0], -result[1]];
-}
-
-/**
- * Find empty spaces surrounding rooms, and apply doors.
- */
-ROT.Map.Digger.prototype._addDoors = function() {
-	var data = this._map;
-	var isWallCallback = function(x, y) {
-		return (data[x][y] == 1);
-	}
-	for (var i = 0; i < this._rooms.length; i++ ) {
-		var room = this._rooms[i];
-		room.clearDoors();
-		room.addDoors(isWallCallback);
-	}
-}
-/**
- * @class Dungeon generator which tries to fill the space evenly. Generates independent rooms and tries to connect them.
- * @augments ROT.Map.Dungeon
- */
-ROT.Map.Uniform = function(width, height, options) {
-	ROT.Map.Dungeon.call(this, width, height);
-
-	this._options = {
-		roomWidth: [3, 9], /* room minimum and maximum width */
-		roomHeight: [3, 5], /* room minimum and maximum height */
-		roomDugPercentage: 0.1, /* we stop after this percentage of level area has been dug out by rooms */
-		timeLimit: 1000 /* we stop after this much time has passed (msec) */
-	}
-	for (var p in options) { this._options[p] = options[p]; }
-
-	this._roomAttempts = 20; /* new room is created N-times until is considered as impossible to generate */
-	this._corridorAttempts = 20; /* corridors are tried N-times until the level is considered as impossible to connect */
-
-	this._connected = []; /* list of already connected rooms */
-	this._unconnected = []; /* list of remaining unconnected rooms */
-	
-	this._digCallback = this._digCallback.bind(this);
-	this._canBeDugCallback = this._canBeDugCallback.bind(this);
-	this._isWallCallback = this._isWallCallback.bind(this);
-}
-ROT.Map.Uniform.extend(ROT.Map.Dungeon);
-
-/**
- * Create a map. If the time limit has been hit, returns null.
- * @see ROT.Map#create
- */
-ROT.Map.Uniform.prototype.create = function(callback) {
-	var t1 = Date.now();
-	while (1) {
-		var t2 = Date.now();
-		if (t2 - t1 > this._options.timeLimit) { return null; } /* time limit! */
-	
-		this._map = this._fillMap(1);
-		this._dug = 0;
-		this._rooms = [];
-		this._unconnected = [];
-		this._generateRooms();
-		if (this._generateCorridors()) { break; }
-	}
-	
-	if (callback) {
-		for (var i=0;i<this._width;i++) {
-			for (var j=0;j<this._height;j++) {
-				callback(i, j, this._map[i][j]);
-			}
-		}
-	}
-	
-	return this;
-}
-
-/**
- * Generates a suitable amount of rooms
- */
-ROT.Map.Uniform.prototype._generateRooms = function() {
-	var w = this._width-2;
-	var h = this._height-2;
-
-	do {
-		var room = this._generateRoom();
-		if (this._dug/(w*h) > this._options.roomDugPercentage) { break; } /* achieved requested amount of free space */
-	} while (room);
-
-	/* either enough rooms, or not able to generate more of them :) */
-}
-
-/**
- * Try to generate one room
- */
-ROT.Map.Uniform.prototype._generateRoom = function() {
-	var count = 0;
-	while (count < this._roomAttempts) {
-		count++;
-		
-		var room = ROT.Map.Feature.Room.createRandom(this._width, this._height, this._options);
-		if (!room.isValid(this._isWallCallback, this._canBeDugCallback)) { continue; }
-		
-		room.create(this._digCallback);
-		this._rooms.push(room);
-		return room;
-	} 
-
-	/* no room was generated in a given number of attempts */
-	return null;
-}
-
-/**
- * Generates connectors beween rooms
- * @returns {bool} success Was this attempt successfull?
- */
-ROT.Map.Uniform.prototype._generateCorridors = function() {
-	var cnt = 0;
-	while (cnt < this._corridorAttempts) {
-		cnt++;
-		this._corridors = [];
-
-		/* dig rooms into a clear map */
-		this._map = this._fillMap(1);
-		for (var i=0;i<this._rooms.length;i++) { 
-			var room = this._rooms[i];
-			room.clearDoors();
-			room.create(this._digCallback); 
-		}
-
-		this._unconnected = this._rooms.slice().randomize();
-		this._connected = [];
-		if (this._unconnected.length) { this._connected.push(this._unconnected.pop()); } /* first one is always connected */
-		
-		while (1) {
-			/* 1. pick random connected room */
-			var connected = this._connected.random();
-			
-			/* 2. find closest unconnected */
-			var room1 = this._closestRoom(this._unconnected, connected);
-			
-			/* 3. connect it to closest connected */
-			var room2 = this._closestRoom(this._connected, room1);
-			
-			var ok = this._connectRooms(room1, room2);
-			if (!ok) { break; } /* stop connecting, re-shuffle */
-			
-			if (!this._unconnected.length) { return true; } /* done; no rooms remain */
-		}
-	}
-	return false;
-}
-
-/**
- * For a given room, find the closest one from the list
- */
-ROT.Map.Uniform.prototype._closestRoom = function(rooms, room) {
-	var dist = Infinity;
-	var center = room.getCenter();
-	var result = null;
-	
-	for (var i=0;i<rooms.length;i++) {
-		var r = rooms[i];
-		var c = r.getCenter();
-		var dx = c[0]-center[0];
-		var dy = c[1]-center[1];
-		var d = dx*dx+dy*dy;
-		
-		if (d < dist) {
-			dist = d;
-			result = r;
-		}
-	}
-	
-	return result;
-}
-
-ROT.Map.Uniform.prototype._connectRooms = function(room1, room2) {
-	/*
-		room1.debug();
-		room2.debug();
-	*/
-
-	var center1 = room1.getCenter();
-	var center2 = room2.getCenter();
-
-	var diffX = center2[0] - center1[0];
-	var diffY = center2[1] - center1[1];
-
-	if (Math.abs(diffX) < Math.abs(diffY)) { /* first try connecting north-south walls */
-		var dirIndex1 = (diffY > 0 ? 2 : 0);
-		var dirIndex2 = (dirIndex1 + 2) % 4;
-		var min = room2.getLeft();
-		var max = room2.getRight();
-		var index = 0;
-	} else { /* first try connecting east-west walls */
-		var dirIndex1 = (diffX > 0 ? 1 : 3);
-		var dirIndex2 = (dirIndex1 + 2) % 4;
-		var min = room2.getTop();
-		var max = room2.getBottom();
-		var index = 1;
-	}
-
-	var start = this._placeInWall(room1, dirIndex1); /* corridor will start here */
-	if (!start) { return false; }
-
-	if (start[index] >= min && start[index] <= max) { /* possible to connect with straight line (I-like) */
-		var end = start.slice();
-		var value = null;
-		switch (dirIndex2) {
-			case 0: value = room2.getTop()-1; break;
-			case 1: value = room2.getRight()+1; break;
-			case 2: value = room2.getBottom()+1; break;
-			case 3: value = room2.getLeft()-1; break;
-		}
-		end[(index+1)%2] = value;
-		this._digLine([start, end]);
-		
-	} else if (start[index] < min-1 || start[index] > max+1) { /* need to switch target wall (L-like) */
-
-		var diff = start[index] - center2[index];
-		switch (dirIndex2) {
-			case 0:
-			case 1:	var rotation = (diff < 0 ? 3 : 1); break;
-			case 2:
-			case 3:	var rotation = (diff < 0 ? 1 : 3); break;
-		}
-		dirIndex2 = (dirIndex2 + rotation) % 4;
-		
-		var end = this._placeInWall(room2, dirIndex2);
-		if (!end) { return false; }
-
-		var mid = [0, 0];
-		mid[index] = start[index];
-		var index2 = (index+1)%2;
-		mid[index2] = end[index2];
-		this._digLine([start, mid, end]);
-		
-	} else { /* use current wall pair, but adjust the line in the middle (S-like) */
-	
-		var index2 = (index+1)%2;
-		var end = this._placeInWall(room2, dirIndex2);
-		if (!end) { return; }
-		var mid = Math.round((end[index2] + start[index2])/2);
-
-		var mid1 = [0, 0];
-		var mid2 = [0, 0];
-		mid1[index] = start[index];
-		mid1[index2] = mid;
-		mid2[index] = end[index];
-		mid2[index2] = mid;
-		this._digLine([start, mid1, mid2, end]);
-	}
-
-	room1.addDoor(start[0], start[1]);
-	room2.addDoor(end[0], end[1]);
-	
-	var index = this._unconnected.indexOf(room1);
-	if (index != -1) {
-		this._unconnected.splice(index, 1);
-		this._connected.push(room1);
-	}
-
-	var index = this._unconnected.indexOf(room2);
-	if (index != -1) {
-		this._unconnected.splice(index, 1);
-		this._connected.push(room2);
-	}
-	
-	return true;
-}
-
-ROT.Map.Uniform.prototype._placeInWall = function(room, dirIndex) {
-	var start = [0, 0];
-	var dir = [0, 0];
-	var length = 0;
-	
-	switch (dirIndex) {
-		case 0:
-			dir = [1, 0];
-			start = [room.getLeft(), room.getTop()-1];
-			length = room.getRight()-room.getLeft()+1;
-		break;
-		case 1:
-			dir = [0, 1];
-			start = [room.getRight()+1, room.getTop()];
-			length = room.getBottom()-room.getTop()+1;
-		break;
-		case 2:
-			dir = [1, 0];
-			start = [room.getLeft(), room.getBottom()+1];
-			length = room.getRight()-room.getLeft()+1;
-		break;
-		case 3:
-			dir = [0, 1];
-			start = [room.getLeft()-1, room.getTop()];
-			length = room.getBottom()-room.getTop()+1;
-		break;
-	}
-	
-	var avail = [];
-	var lastBadIndex = -2;
-
-	for (var i=0;i<length;i++) {
-		var x = start[0] + i*dir[0];
-		var y = start[1] + i*dir[1];
-		avail.push(null);
-		
-		var isWall = (this._map[x][y] == 1);
-		if (isWall) {
-			if (lastBadIndex != i-1) { avail[i] = [x, y]; }
-		} else {
-			lastBadIndex = i;
-			if (i) { avail[i-1] = null; }
-		}
-	}
-	
-	for (var i=avail.length-1; i>=0; i--) {
-		if (!avail[i]) { avail.splice(i, 1); }
-	}
-	return (avail.length ? avail.random() : null);
-}
-
-/**
- * Dig a polyline.
- */
-ROT.Map.Uniform.prototype._digLine = function(points) {
-	for (var i=1;i<points.length;i++) {
-		var start = points[i-1];
-		var end = points[i];
-		var corridor = new ROT.Map.Feature.Corridor(start[0], start[1], end[0], end[1]);
-		corridor.create(this._digCallback);
-		this._corridors.push(corridor);
-	}
-}
-
-ROT.Map.Uniform.prototype._digCallback = function(x, y, value) {
-	this._map[x][y] = value;
-	if (value == 0) { this._dug++; }
-}
-
-ROT.Map.Uniform.prototype._isWallCallback = function(x, y) {
-	if (x < 0 || y < 0 || x >= this._width || y >= this._height) { return false; }
-	return (this._map[x][y] == 1);
-}
-
-ROT.Map.Uniform.prototype._canBeDugCallback = function(x, y) {
-	if (x < 1 || y < 1 || x+1 >= this._width || y+1 >= this._height) { return false; }
-	return (this._map[x][y] == 1);
-}
-
-/**
- * @author hyakugei
- * @class Dungeon generator which uses the "orginal" Rogue dungeon generation algorithm. See http://kuoi.com/~kamikaze/GameDesign/art07_rogue_dungeon.php
- * @augments ROT.Map
- * @param {int} [width=ROT.DEFAULT_WIDTH]
- * @param {int} [height=ROT.DEFAULT_HEIGHT]
- * @param {object} [options] Options
- * @param {int[]} [options.cellWidth=3] Number of cells to create on the horizontal (number of rooms horizontally)
- * @param {int[]} [options.cellHeight=3] Number of cells to create on the vertical (number of rooms vertically) 
- * @param {int} [options.roomWidth] Room min and max width - normally set auto-magically via the constructor.
- * @param {int} [options.roomHeight] Room min and max height - normally set auto-magically via the constructor. 
- */
-ROT.Map.Rogue = function(width, height, options) {
-	ROT.Map.call(this, width, height);
-	
-	this._options = {
-		cellWidth: 3,  // NOTE to self, these could probably work the same as the roomWidth/room Height values
-		cellHeight: 3  //     ie. as an array with min-max values for each direction....
-	}
-	
-	for (var p in options) { this._options[p] = options[p]; }
-	
-	/*
-	Set the room sizes according to the over-all width of the map, 
-	and the cell sizes. 
-	*/
-	
-	if (!this._options.hasOwnProperty("roomWidth")) {
-		this._options["roomWidth"] = this._calculateRoomSize(width, this._options["cellWidth"]);
-	}
-	if (!this._options.hasOwnProperty["roomHeight"]) {
-		this._options["roomHeight"] = this._calculateRoomSize(height, this._options["cellHeight"]);
-	}
-	
-}
-
-ROT.Map.Rogue.extend(ROT.Map); 
-
-/**
- * @see ROT.Map#create
- */
-ROT.Map.Rogue.prototype.create = function(callback) {
-	this.map = this._fillMap(1);
-	this.rooms = [];
-	this.connectedCells = [];
-	
-	this._initRooms();
-	this._connectRooms();
-	this._connectUnconnectedRooms();
-	this._createRandomRoomConnections();
-	this._createRooms();
-	this._createCorridors();
-	
-	if (callback) {
-		for (var i = 0; i < this._width; i++) {
-			for (var j = 0; j < this._height; j++) {
-				callback(i, j, this.map[i][j]);   
-			}
-		}
-	}
-	
-	return this;
-}
-
-ROT.Map.Rogue.prototype._getRandomInt = function(min, max) {
-	return Math.floor(ROT.RNG.getUniform() * (max - min + 1)) + min;
-}
-
-ROT.Map.Rogue.prototype._calculateRoomSize = function(size, cell) {
-	var max = Math.floor((size/cell) * 0.8);
-	var min = Math.floor((size/cell) * 0.25);
-	if (min < 2) min = 2;
-	if (max < 2) max = 2;
-	return [min, max];
-}
-
-ROT.Map.Rogue.prototype._initRooms = function () { 
-	// create rooms array. This is the "grid" list from the algo.  
-	for (var i = 0; i < this._options.cellWidth; i++) {  
-		this.rooms.push([]);
-		for(var j = 0; j < this._options.cellHeight; j++) {
-			this.rooms[i].push({"x":0, "y":0, "width":0, "height":0, "connections":[], "cellx":i, "celly":j});
-		}
-	}
-}
-
-ROT.Map.Rogue.prototype._connectRooms = function() {
-	//pick random starting grid
-	var cgx = this._getRandomInt(0, this._options.cellWidth-1);
-	var cgy = this._getRandomInt(0, this._options.cellHeight-1);
-	
-	var idx;
-	var ncgx;
-	var ncgy;
-	
-	var found = false;
-	var room;
-	var otherRoom;
-	
-	// find  unconnected neighbour cells
-	do {
-	
-		//var dirToCheck = [0,1,2,3,4,5,6,7];
-		var dirToCheck = [0,2,4,6];
-		dirToCheck = dirToCheck.randomize();
-		
-		do {
-			found = false;
-			idx = dirToCheck.pop();
-			
-			
-			ncgx = cgx + ROT.DIRS[8][idx][0];
-			ncgy = cgy + ROT.DIRS[8][idx][1];
-			
-			if(ncgx < 0 || ncgx >= this._options.cellWidth) continue;
-			if(ncgy < 0 || ncgy >= this._options.cellHeight) continue;
-			
-			room = this.rooms[cgx][cgy];
-			
-			if(room["connections"].length > 0)
-			{
-				// as long as this room doesn't already coonect to me, we are ok with it. 
-				if(room["connections"][0][0] == ncgx &&
-				room["connections"][0][1] == ncgy)
-				{
-					break;
-				}
-			}
-			
-			otherRoom = this.rooms[ncgx][ncgy];
-			
-			if (otherRoom["connections"].length == 0) { 
-				otherRoom["connections"].push([cgx,cgy]);
-				
-				this.connectedCells.push([ncgx, ncgy]);
-				cgx = ncgx;
-				cgy = ncgy;
-				found = true;
-			}
-					
-		} while (dirToCheck.length > 0 && found == false)
-		
-	} while (dirToCheck.length > 0)
-
-}
-
-ROT.Map.Rogue.prototype._connectUnconnectedRooms = function() {
-	//While there are unconnected rooms, try to connect them to a random connected neighbor 
-	//(if a room has no connected neighbors yet, just keep cycling, you'll fill out to it eventually).
-	var cw = this._options.cellWidth;
-	var ch = this._options.cellHeight;
-	
-	var randomConnectedCell;
-	this.connectedCells = this.connectedCells.randomize();
-	var room;
-	var otherRoom;
-	var validRoom;
-	
-	for (var i = 0; i < this._options.cellWidth; i++) {
-		for (var j = 0; j < this._options.cellHeight; j++)  {
-				
-			room = this.rooms[i][j];
-			
-			if (room["connections"].length == 0) {
-				var directions = [0,2,4,6];
-				directions = directions.randomize();
-				
-				var validRoom = false;
-				
-				do {
-					
-					var dirIdx = directions.pop();
-					var newI = i + ROT.DIRS[8][dirIdx][0];
-					var newJ = j + ROT.DIRS[8][dirIdx][1];
-					
-					if (newI < 0 || newI >= cw || 
-					newJ < 0 || newJ >= ch) {
-						continue;
-					}
-					
-					otherRoom = this.rooms[newI][newJ];
-					
-					validRoom = true;
-					
-					if (otherRoom["connections"].length == 0) {
-						break;
-					}
-					
-					for (var k = 0; k < otherRoom["connections"].length; k++) {
-						if(otherRoom["connections"][k][0] == i && 
-						otherRoom["connections"][k][1] == j) {
-							validRoom = false;
-							break;
-						}
-					}
-					
-					if (validRoom) break;
-					
-				} while (directions.length)
-				
-				if(validRoom) { 
-					room["connections"].push( [otherRoom["cellx"], otherRoom["celly"]] );  
-				} else {
-					console.log("-- Unable to connect room.");
-				}
-			}
-		}
-	}
-}
-
-ROT.Map.Rogue.prototype._createRandomRoomConnections = function(connections) {
-	// Empty for now. 
-}
-
-
-ROT.Map.Rogue.prototype._createRooms = function() {
-	// Create Rooms 
-	
-	var w = this._width;
-	var h = this._height;
-	
-	var cw = this._options.cellWidth;
-	var ch = this._options.cellHeight;
-	
-	var cwp = Math.floor(this._width / cw);
-	var chp = Math.floor(this._height / ch);
-	
-	var roomw;
-	var roomh;
-	var roomWidth = this._options["roomWidth"];
-	var roomHeight = this._options["roomHeight"];
-	var sx;
-	var sy;
-	var tx;
-	var ty;
-	var otherRoom;
-	
-	for (var i = 0; i < cw; i++) {
-		for (var j = 0; j < ch; j++) {
-			sx = cwp * i;
-			sy = chp * j;
-			
-			if (sx == 0) sx = 1;
-			if (sy == 0) sy = 1;
-			
-			roomw = this._getRandomInt(roomWidth[0], roomWidth[1]);
-			roomh = this._getRandomInt(roomHeight[0], roomHeight[1]);
-			
-			if (j > 0) {
-				otherRoom = this.rooms[i][j-1];
-				while (sy - (otherRoom["y"] + otherRoom["height"] ) < 3) {
-					sy++;
-				}
-			}
-			
-			if (i > 0) {
-				otherRoom = this.rooms[i-1][j];
-				while(sx - (otherRoom["x"] + otherRoom["width"]) < 3) {
-					sx++;
-				}
-			}
-						
-			var sxOffset = Math.round(this._getRandomInt(0, cwp-roomw)/2);
-			var syOffset = Math.round(this._getRandomInt(0, chp-roomh)/2);
-			
-			while (sx + sxOffset + roomw >= w) {
-				if(sxOffset) {
-					sxOffset--;
-				} else {
-					roomw--; 
-				}
-			}
-			
-			while (sy + syOffset + roomh >= h) { 
-				if(syOffset) {
-					syOffset--;
-				} else {
-					roomh--; 
-				}
-			}
-			
-			sx = sx + sxOffset;
-			sy = sy + syOffset;
-			
-			this.rooms[i][j]["x"] = sx;
-			this.rooms[i][j]["y"] = sy;
-			this.rooms[i][j]["width"] = roomw;
-			this.rooms[i][j]["height"] = roomh;  
-			
-			for (var ii = sx; ii < sx + roomw; ii++) {
-				for (var jj = sy; jj < sy + roomh; jj++) {
-					this.map[ii][jj] = 0;
-				}
-			}  
-		}
-	}
-}
-
-ROT.Map.Rogue.prototype._getWallPosition = function(aRoom, aDirection) {
-	var rx;
-	var ry;
-	var door;
-	
-	if (aDirection == 1 || aDirection == 3) {
-		rx = this._getRandomInt(aRoom["x"] + 1, aRoom["x"] + aRoom["width"] - 2);
-		if (aDirection == 1) {
-			ry = aRoom["y"] - 2;
-			door = ry + 1;
-		} else {
-			ry = aRoom["y"] + aRoom["height"] + 1;
-			door = ry -1;
-		}
-		
-		this.map[rx][door] = 0; // i'm not setting a specific 'door' tile value right now, just empty space. 
-		
-	} else if (aDirection == 2 || aDirection == 4) {
-		ry = this._getRandomInt(aRoom["y"] + 1, aRoom["y"] + aRoom["height"] - 2);
-		if(aDirection == 2) {
-			rx = aRoom["x"] + aRoom["width"] + 1;
-			door = rx - 1;
-		} else {
-			rx = aRoom["x"] - 2;
-			door = rx + 1;
-		}
-		
-		this.map[door][ry] = 0; // i'm not setting a specific 'door' tile value right now, just empty space. 
-		
-	}
-	return [rx, ry];
-}
-
-/***
-* @param startPosition a 2 element array
-* @param endPosition a 2 element array
-*/
-ROT.Map.Rogue.prototype._drawCorridore = function (startPosition, endPosition) {
-	var xOffset = endPosition[0] - startPosition[0];
-	var yOffset = endPosition[1] - startPosition[1];
-	
-	var xpos = startPosition[0];
-	var ypos = startPosition[1];
-	
-	var tempDist;
-	var xDir;
-	var yDir;
-	
-	var move; // 2 element array, element 0 is the direction, element 1 is the total value to move. 
-	var moves = []; // a list of 2 element arrays
-	
-	var xAbs = Math.abs(xOffset);
-	var yAbs = Math.abs(yOffset);
-	
-	var percent = ROT.RNG.getUniform(); // used to split the move at different places along the long axis
-	var firstHalf = percent;
-	var secondHalf = 1 - percent;
-	
-	xDir = xOffset > 0 ? 2 : 6;
-	yDir = yOffset > 0 ? 4 : 0;
-	
-	if (xAbs < yAbs) {
-		// move firstHalf of the y offset
-		tempDist = Math.ceil(yAbs * firstHalf);
-		moves.push([yDir, tempDist]);
-		// move all the x offset
-		moves.push([xDir, xAbs]);
-		// move sendHalf of the  y offset
-		tempDist = Math.floor(yAbs * secondHalf);
-		moves.push([yDir, tempDist]);
-	} else {
-		//  move firstHalf of the x offset
-		tempDist = Math.ceil(xAbs * firstHalf);
-		moves.push([xDir, tempDist]);
-		// move all the y offset
-		moves.push([yDir, yAbs]);
-		// move secondHalf of the x offset.
-		tempDist = Math.floor(xAbs * secondHalf);
-		moves.push([xDir, tempDist]);  
-	}
-	
-	this.map[xpos][ypos] = 0;
-	
-	while (moves.length > 0) {
-		move = moves.pop();
-		while (move[1] > 0) {
-			xpos += ROT.DIRS[8][move[0]][0];
-			ypos += ROT.DIRS[8][move[0]][1];
-			this.map[xpos][ypos] = 0;
-			move[1] = move[1] - 1;
-		}
-	}
-}
-
-ROT.Map.Rogue.prototype._createCorridors = function () {
-	// Draw Corridors between connected rooms
-	
-	var cw = this._options.cellWidth;
-	var ch = this._options.cellHeight;
-	var room;
-	var connection;
-	var otherRoom;
-	var wall;
-	var otherWall;
-	
-	for (var i = 0; i < cw; i++) {
-		for (var j = 0; j < ch; j++) {
-			room = this.rooms[i][j];
-			
-			for (var k = 0; k < room["connections"].length; k++) {
-					
-				connection = room["connections"][k]; 
-				
-				otherRoom = this.rooms[connection[0]][connection[1]];
-				
-				// figure out what wall our corridor will start one.
-				// figure out what wall our corridor will end on. 
-				if (otherRoom["cellx"] > room["cellx"] ) {
-					wall = 2;
-					otherWall = 4;
-				} else if (otherRoom["cellx"] < room["cellx"] ) {
-					wall = 4;
-					otherWall = 2;
-				} else if(otherRoom["celly"] > room["celly"]) {
-					wall = 3;
-					otherWall = 1;
-				} else if(otherRoom["celly"] < room["celly"]) {
-					wall = 1;
-					otherWall = 3;
-				}
-				
-				this._drawCorridore(this._getWallPosition(room, wall), this._getWallPosition(otherRoom, otherWall));
-			}
-		}
-	}
-}
-/**
- * @class Dungeon feature; has own .create() method
- */
-ROT.Map.Feature = function() {}
-ROT.Map.Feature.prototype.isValid = function(canBeDugCallback) {}
-ROT.Map.Feature.prototype.create = function(digCallback) {}
-ROT.Map.Feature.prototype.debug = function() {}
-ROT.Map.Feature.createRandomAt = function(x, y, dx, dy, options) {}
-
-/**
- * @class Room
- * @augments ROT.Map.Feature
- * @param {int} x1
- * @param {int} y1
- * @param {int} x2
- * @param {int} y2
- * @param {int} [doorX]
- * @param {int} [doorY]
- */
-ROT.Map.Feature.Room = function(x1, y1, x2, y2, doorX, doorY) {
-	this._x1 = x1;
-	this._y1 = y1;
-	this._x2 = x2;
-	this._y2 = y2;
-	this._doors = {};
-	if (arguments.length > 4) { this.addDoor(doorX, doorY); }
-}
-ROT.Map.Feature.Room.extend(ROT.Map.Feature);
-
-/**
- * Room of random size, with a given doors and direction
- */
-ROT.Map.Feature.Room.createRandomAt = function(x, y, dx, dy, options) {
-	var min = options.roomWidth[0];
-	var max = options.roomWidth[1];
-	var width = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
-	
-	var min = options.roomHeight[0];
-	var max = options.roomHeight[1];
-	var height = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
-	
-	if (dx == 1) { /* to the right */
-		var y2 = y - Math.floor(ROT.RNG.getUniform() * height);
-		return new this(x+1, y2, x+width, y2+height-1, x, y);
-	}
-	
-	if (dx == -1) { /* to the left */
-		var y2 = y - Math.floor(ROT.RNG.getUniform() * height);
-		return new this(x-width, y2, x-1, y2+height-1, x, y);
-	}
-
-	if (dy == 1) { /* to the bottom */
-		var x2 = x - Math.floor(ROT.RNG.getUniform() * width);
-		return new this(x2, y+1, x2+width-1, y+height, x, y);
-	}
-
-	if (dy == -1) { /* to the top */
-		var x2 = x - Math.floor(ROT.RNG.getUniform() * width);
-		return new this(x2, y-height, x2+width-1, y-1, x, y);
-	}
-}
-
-/**
- * Room of random size, positioned around center coords
- */
-ROT.Map.Feature.Room.createRandomCenter = function(cx, cy, options) {
-	var min = options.roomWidth[0];
-	var max = options.roomWidth[1];
-	var width = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
-	
-	var min = options.roomHeight[0];
-	var max = options.roomHeight[1];
-	var height = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
-
-	var x1 = cx - Math.floor(ROT.RNG.getUniform()*width);
-	var y1 = cy - Math.floor(ROT.RNG.getUniform()*height);
-	var x2 = x1 + width - 1;
-	var y2 = y1 + height - 1;
-
-	return new this(x1, y1, x2, y2);
-}
-
-/**
- * Room of random size within a given dimensions
- */
-ROT.Map.Feature.Room.createRandom = function(availWidth, availHeight, options) {
-	var min = options.roomWidth[0];
-	var max = options.roomWidth[1];
-	var width = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
-	
-	var min = options.roomHeight[0];
-	var max = options.roomHeight[1];
-	var height = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
-	
-	var left = availWidth - width - 1;
-	var top = availHeight - height - 1;
-
-	var x1 = 1 + Math.floor(ROT.RNG.getUniform()*left);
-	var y1 = 1 + Math.floor(ROT.RNG.getUniform()*top);
-	var x2 = x1 + width - 1;
-	var y2 = y1 + height - 1;
-
-	return new this(x1, y1, x2, y2);
-}
-
-ROT.Map.Feature.Room.prototype.addDoor = function(x, y) {
-	this._doors[x+","+y] = 1;
-	return this;
-}
-
-/**
- * @param {function}
- */
-ROT.Map.Feature.Room.prototype.getDoors = function(callback) {
-	for (var key in this._doors) {
-		var parts = key.split(",");
-		callback(parseInt(parts[0]), parseInt(parts[1]));
-	}
-	return this;
-}
-
-ROT.Map.Feature.Room.prototype.clearDoors = function() {
-	this._doors = {};
-	return this;
-}
-
-ROT.Map.Feature.Room.prototype.addDoors = function(isWallCallback) {
-	var left = this._x1-1;
-	var right = this._x2+1;
-	var top = this._y1-1;
-	var bottom = this._y2+1;
-
-	for (var x=left; x<=right; x++) {
-		for (var y=top; y<=bottom; y++) {
-			if (x != left && x != right && y != top && y != bottom) { continue; }
-			if (isWallCallback(x, y)) { continue; }
-
-			this.addDoor(x, y);
-		}
-	}
-
-	return this;
-}
-
-ROT.Map.Feature.Room.prototype.debug = function() {
-	console.log("room", this._x1, this._y1, this._x2, this._y2);
-}
-
-ROT.Map.Feature.Room.prototype.isValid = function(isWallCallback, canBeDugCallback) { 
-	var left = this._x1-1;
-	var right = this._x2+1;
-	var top = this._y1-1;
-	var bottom = this._y2+1;
-	
-	for (var x=left; x<=right; x++) {
-		for (var y=top; y<=bottom; y++) {
-			if (x == left || x == right || y == top || y == bottom) {
-				if (!isWallCallback(x, y)) { return false; }
-			} else {
-				if (!canBeDugCallback(x, y)) { return false; }
-			}
-		}
-	}
-
-	return true;
-}
-
-/**
- * @param {function} digCallback Dig callback with a signature (x, y, value). Values: 0 = empty, 1 = wall, 2 = door. Multiple doors are allowed.
- */
-ROT.Map.Feature.Room.prototype.create = function(digCallback) { 
-	var left = this._x1-1;
-	var right = this._x2+1;
-	var top = this._y1-1;
-	var bottom = this._y2+1;
-	
-	var value = 0;
-	for (var x=left; x<=right; x++) {
-		for (var y=top; y<=bottom; y++) {
-			if (x+","+y in this._doors) {
-				value = 2;
-			} else if (x == left || x == right || y == top || y == bottom) {
-				value = 1;
-			} else {
-				value = 0;
-			}
-			digCallback(x, y, value);
-		}
-	}
-}
-
-ROT.Map.Feature.Room.prototype.getCenter = function() {
-	return [Math.round((this._x1 + this._x2)/2), Math.round((this._y1 + this._y2)/2)];
-}
-
-ROT.Map.Feature.Room.prototype.getLeft = function() {
-	return this._x1;
-}
-
-ROT.Map.Feature.Room.prototype.getRight = function() {
-	return this._x2;
-}
-
-ROT.Map.Feature.Room.prototype.getTop = function() {
-	return this._y1;
-}
-
-ROT.Map.Feature.Room.prototype.getBottom = function() {
-	return this._y2;
-}
-
-/**
- * @class Corridor
- * @augments ROT.Map.Feature
- * @param {int} startX
- * @param {int} startY
- * @param {int} endX
- * @param {int} endY
- */
-ROT.Map.Feature.Corridor = function(startX, startY, endX, endY) {
-	this._startX = startX;
-	this._startY = startY;
-	this._endX = endX; 
-	this._endY = endY;
-	this._endsWithAWall = true;
-}
-ROT.Map.Feature.Corridor.extend(ROT.Map.Feature);
-
-ROT.Map.Feature.Corridor.createRandomAt = function(x, y, dx, dy, options) {
-	var min = options.corridorLength[0];
-	var max = options.corridorLength[1];
-	var length = min + Math.floor(ROT.RNG.getUniform()*(max-min+1));
-	
-	return new this(x, y, x + dx*length, y + dy*length);
-}
-
-ROT.Map.Feature.Corridor.prototype.debug = function() {
-	console.log("corridor", this._startX, this._startY, this._endX, this._endY);
-}
-
-ROT.Map.Feature.Corridor.prototype.isValid = function(isWallCallback, canBeDugCallback){ 
-	var sx = this._startX;
-	var sy = this._startY;
-	var dx = this._endX-sx;
-	var dy = this._endY-sy;
-	var length = 1 + Math.max(Math.abs(dx), Math.abs(dy));
-	
-	if (dx) { dx = dx/Math.abs(dx); }
-	if (dy) { dy = dy/Math.abs(dy); }
-	var nx = dy;
-	var ny = -dx;
-	
-	var ok = true;
-	for (var i=0; i<length; i++) {
-		var x = sx + i*dx;
-		var y = sy + i*dy;
-
-		if (!canBeDugCallback(     x,      y)) { ok = false; }
-		if (!isWallCallback  (x + nx, y + ny)) { ok = false; }
-		if (!isWallCallback  (x - nx, y - ny)) { ok = false; }
-		
-		if (!ok) {
-			length = i;
-			this._endX = x-dx;
-			this._endY = y-dy;
-			break;
-		}
-	}
-	
-	/**
-	 * If the length degenerated, this corridor might be invalid
-	 */
-	 
-	/* not supported */
-	if (length == 0) { return false; } 
-	
-	 /* length 1 allowed only if the next space is empty */
-	if (length == 1 && isWallCallback(this._endX + dx, this._endY + dy)) { return false; }
-	
-	/**
-	 * We do not want the corridor to crash into a corner of a room;
-	 * if any of the ending corners is empty, the N+1th cell of this corridor must be empty too.
-	 * 
-	 * Situation:
-	 * #######1
-	 * .......?
-	 * #######2
-	 * 
-	 * The corridor was dug from left to right.
-	 * 1, 2 - problematic corners, ? = N+1th cell (not dug)
-	 */
-	var firstCornerBad = !isWallCallback(this._endX + dx + nx, this._endY + dy + ny);
-	var secondCornerBad = !isWallCallback(this._endX + dx - nx, this._endY + dy - ny);
-	this._endsWithAWall = isWallCallback(this._endX + dx, this._endY + dy);
-	if ((firstCornerBad || secondCornerBad) && this._endsWithAWall) { return false; }
-
-	return true;
-}
-
-/**
- * @param {function} digCallback Dig callback with a signature (x, y, value). Values: 0 = empty.
- */
-ROT.Map.Feature.Corridor.prototype.create = function(digCallback) { 
-	var sx = this._startX;
-	var sy = this._startY;
-	var dx = this._endX-sx;
-	var dy = this._endY-sy;
-	var length = 1+Math.max(Math.abs(dx), Math.abs(dy));
-	
-	if (dx) { dx = dx/Math.abs(dx); }
-	if (dy) { dy = dy/Math.abs(dy); }
-	var nx = dy;
-	var ny = -dx;
-	
-	for (var i=0; i<length; i++) {
-		var x = sx + i*dx;
-		var y = sy + i*dy;
-		digCallback(x, y, 0);
-	}
-	
-	return true;
-}
-
-ROT.Map.Feature.Corridor.prototype.createPriorityWalls = function(priorityWallCallback) {
-	if (!this._endsWithAWall) { return; }
-
-	var sx = this._startX;
-	var sy = this._startY;
-
-	var dx = this._endX-sx;
-	var dy = this._endY-sy;
-	if (dx) { dx = dx/Math.abs(dx); }
-	if (dy) { dy = dy/Math.abs(dy); }
-	var nx = dy;
-	var ny = -dx;
-
-	priorityWallCallback(this._endX + dx, this._endY + dy);
-	priorityWallCallback(this._endX + nx, this._endY + ny);
-	priorityWallCallback(this._endX - nx, this._endY - ny);
-}/**
- * @class Base noise generator
- */
-ROT.Noise = function() {
-};
-
-ROT.Noise.prototype.get = function(x, y) {}
-/**
- * A simple 2d implementation of simplex noise by Ondrej Zara
- *
- * Based on a speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
- * Which is based on example code by Stefan Gustavson (stegu@itn.liu.se).
- * With Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
- * Better rank ordering method by Stefan Gustavson in 2012.
- */
-
-/**
- * @class 2D simplex noise generator
- * @param {int} [gradients=256] Random gradients
- */
-ROT.Noise.Simplex = function(gradients) {
-	ROT.Noise.call(this);
-
-	this._F2 = 0.5 * (Math.sqrt(3) - 1);
-    this._G2 = (3 - Math.sqrt(3)) / 6;
-
-	this._gradients = [
-		[ 0, -1],
-		[ 1, -1],
-		[ 1,  0],
-		[ 1,  1],
-		[ 0,  1],
-		[-1,  1],
-		[-1,  0],
-		[-1, -1]
-	];
-
-	var permutations = [];
-	var count = gradients || 256;
-	for (var i=0;i<count;i++) { permutations.push(i); }
-	permutations = permutations.randomize();
-
-	this._perms = [];
-	this._indexes = [];
-
-	for (var i=0;i<2*count;i++) {
-		this._perms.push(permutations[i % count]);
-		this._indexes.push(this._perms[i] % this._gradients.length);
-	}
-
-};
-ROT.Noise.Simplex.extend(ROT.Noise);
-
-ROT.Noise.Simplex.prototype.get = function(xin, yin) {
-	var perms = this._perms;
-	var indexes = this._indexes;
-	var count = perms.length/2;
-	var G2 = this._G2;
-
-	var n0 =0, n1 = 0, n2 = 0, gi; // Noise contributions from the three corners
-
-	// Skew the input space to determine which simplex cell we're in
-	var s = (xin + yin) * this._F2; // Hairy factor for 2D
-	var i = Math.floor(xin + s);
-	var j = Math.floor(yin + s);
-	var t = (i + j) * G2;
-	var X0 = i - t; // Unskew the cell origin back to (x,y) space
-	var Y0 = j - t;
-	var x0 = xin - X0; // The x,y distances from the cell origin
-	var y0 = yin - Y0;
-
-	// For the 2D case, the simplex shape is an equilateral triangle.
-	// Determine which simplex we are in.
-	var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
-	if (x0 > y0) {
-		i1 = 1;
-		j1 = 0;
-	} else { // lower triangle, XY order: (0,0)->(1,0)->(1,1)
-		i1 = 0;
-		j1 = 1;
-	} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
-
-	// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
-	// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
-	// c = (3-sqrt(3))/6
-	var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
-	var y1 = y0 - j1 + G2;
-	var x2 = x0 - 1 + 2*G2; // Offsets for last corner in (x,y) unskewed coords
-	var y2 = y0 - 1 + 2*G2;
-
-	// Work out the hashed gradient indices of the three simplex corners
-	var ii = i.mod(count);
-	var jj = j.mod(count);
-
-	// Calculate the contribution from the three corners
-	var t0 = 0.5 - x0*x0 - y0*y0;
-	if (t0 >= 0) {
-		t0 *= t0;
-		gi = indexes[ii+perms[jj]];
-		var grad = this._gradients[gi];
-		n0 = t0 * t0 * (grad[0] * x0 + grad[1] * y0);
-	}
-	
-	var t1 = 0.5 - x1*x1 - y1*y1;
-	if (t1 >= 0) {
-		t1 *= t1;
-		gi = indexes[ii+i1+perms[jj+j1]];
-		var grad = this._gradients[gi];
-		n1 = t1 * t1 * (grad[0] * x1 + grad[1] * y1);
-	}
-	
-	var t2 = 0.5 - x2*x2 - y2*y2;
-	if (t2 >= 0) {
-		t2 *= t2;
-		gi = indexes[ii+1+perms[jj+1]];
-		var grad = this._gradients[gi];
-		n2 = t2 * t2 * (grad[0] * x2 + grad[1] * y2);
-	}
-
-	// Add contributions from each corner to get the final noise value.
-	// The result is scaled to return values in the interval [-1,1].
-	return 70 * (n0 + n1 + n2);
-}
-/**
- * @class Abstract FOV algorithm
- * @param {function} lightPassesCallback Does the light pass through x,y?
- * @param {object} [options]
- * @param {int} [options.topology=8] 4/6/8
- */
-ROT.FOV = function(lightPassesCallback, options) {
-	this._lightPasses = lightPassesCallback;
-	this._options = {
-		topology: 8
-	}
-	for (var p in options) { this._options[p] = options[p]; }
-};
-
-/**
- * Compute visibility
- * @param {int} x
- * @param {int} y
- * @param {int} R Maximum visibility radius
- * @param {function} callback
- */
-ROT.FOV.prototype.compute = function(x, y, R, callback) {}
-
-/**
- * Return all neighbors in a concentric ring
- * @param {int} cx center-x
- * @param {int} cy center-y
- * @param {int} r range
- */
-ROT.FOV.prototype._getCircle = function(cx, cy, r) {
-	var result = [];
-	var dirs, countFactor, startOffset;
-
-	switch (this._options.topology) {
-		case 4:
-			countFactor = 1;
-			startOffset = [0, 1];
-			dirs = [
-				ROT.DIRS[8][7],
-				ROT.DIRS[8][1],
-				ROT.DIRS[8][3],
-				ROT.DIRS[8][5]
-			]
-		break;
-
-		case 6:
-			dirs = ROT.DIRS[6];
-			countFactor = 1;
-			startOffset = [-1, 1];
-		break;
-
-		case 8:
-			dirs = ROT.DIRS[4];
-			countFactor = 2;
-			startOffset = [-1, 1];
-		break;
-	}
-
-	/* starting neighbor */
-	var x = cx + startOffset[0]*r;
-	var y = cy + startOffset[1]*r;
-
-	/* circle */
-	for (var i=0;i<dirs.length;i++) {
-		for (var j=0;j<r*countFactor;j++) {
-			result.push([x, y]);
-			x += dirs[i][0];
-			y += dirs[i][1];
-
-		}
-	}
-
-	return result;
-}
-/**
- * @class Discrete shadowcasting algorithm
- * @augments ROT.FOV
- */
-ROT.FOV.DiscreteShadowcasting = function(lightPassesCallback, options) {
-	ROT.FOV.call(this, lightPassesCallback, options);
-}
-ROT.FOV.DiscreteShadowcasting.extend(ROT.FOV);
-
-/**
- * @see ROT.FOV#compute
- */
-ROT.FOV.DiscreteShadowcasting.prototype.compute = function(x, y, R, callback) {
-	var center = this._coords;
-	var map = this._map;
-
-	/* this place is always visible */
-	callback(x, y, 0);
-
-	/* standing in a dark place. FIXME is this a good idea?  */
-	if (!this._lightPasses(x, y)) { return; }
-	
-	/* start and end angles */
-	var DATA = [];
-	
-	var A, B, cx, cy, blocks;
-
-	/* analyze surrounding cells in concentric rings, starting from the center */
-	for (var r=1; r<=R; r++) {
-		var neighbors = this._getCircle(x, y, r);
-		var angle = 360 / neighbors.length;
-
-		for (var i=0;i<neighbors.length;i++) {
-			cx = neighbors[i][0];
-			cy = neighbors[i][1];
-			A = angle * (i - 0.5);
-			B = A + angle;
-			
-			blocks = !this._lightPasses(cx, cy);
-			if (this._visibleCoords(Math.floor(A), Math.ceil(B), blocks, DATA)) { callback(cx, cy, r, 1); }
-			
-			if (DATA.length == 2 && DATA[0] == 0 && DATA[1] == 360) { return; } /* cutoff? */
-
-		} /* for all cells in this ring */
-	} /* for all rings */
-}
-
-/**
- * @param {int} A start angle
- * @param {int} B end angle
- * @param {bool} blocks Does current cell block visibility?
- * @param {int[][]} DATA shadowed angle pairs
- */
-ROT.FOV.DiscreteShadowcasting.prototype._visibleCoords = function(A, B, blocks, DATA) {
-	if (A < 0) { 
-		var v1 = arguments.callee(0, B, blocks, DATA);
-		var v2 = arguments.callee(360+A, 360, blocks, DATA);
-		return v1 || v2;
-	}
-	
-	var index = 0;
-	while (index < DATA.length && DATA[index] < A) { index++; }
-	
-	if (index == DATA.length) { /* completely new shadow */
-		if (blocks) { DATA.push(A, B); } 
-		return true;
-	}
-	
-	var count = 0;
-	
-	if (index % 2) { /* this shadow starts in an existing shadow, or within its ending boundary */
-		while (index < DATA.length && DATA[index] < B) {
-			index++;
-			count++;
-		}
-		
-		if (count == 0) { return false; }
-		
-		if (blocks) { 
-			if (count % 2) {
-				DATA.splice(index-count, count, B);
-			} else {
-				DATA.splice(index-count, count);
-			}
-		}
-		
-		return true;
-
-	} else { /* this shadow starts outside an existing shadow, or within a starting boundary */
-		while (index < DATA.length && DATA[index] < B) {
-			index++;
-			count++;
-		}
-		
-		/* visible when outside an existing shadow, or when overlapping */
-		if (A == DATA[index-count] && count == 1) { return false; }
-		
-		if (blocks) { 
-			if (count % 2) {
-				DATA.splice(index-count, count, A);
-			} else {
-				DATA.splice(index-count, count, A, B);
-			}
-		}
-			
-		return true;
-	}
-}
-/**
- * @class Precise shadowcasting algorithm
- * @augments ROT.FOV
- */
-ROT.FOV.PreciseShadowcasting = function(lightPassesCallback, options) {
-	ROT.FOV.call(this, lightPassesCallback, options);
-}
-ROT.FOV.PreciseShadowcasting.extend(ROT.FOV);
-
-/**
- * @see ROT.FOV#compute
- */
-ROT.FOV.PreciseShadowcasting.prototype.compute = function(x, y, R, callback) {
-	/* this place is always visible */
-	callback(x, y, 0, 1);
-
-	/* standing in a dark place. FIXME is this a good idea?  */
-	if (!this._lightPasses(x, y)) { return; }
-	
-	/* list of all shadows */
-	var SHADOWS = [];
-	
-	var cx, cy, blocks, A1, A2, visibility;
-
-	/* analyze surrounding cells in concentric rings, starting from the center */
-	for (var r=1; r<=R; r++) {
-		var neighbors = this._getCircle(x, y, r);
-		var neighborCount = neighbors.length;
-
-		for (var i=0;i<neighborCount;i++) {
-			cx = neighbors[i][0];
-			cy = neighbors[i][1];
-			/* shift half-an-angle backwards to maintain consistency of 0-th cells */
-			A1 = [i ? 2*i-1 : 2*neighborCount-1, 2*neighborCount];
-			A2 = [2*i+1, 2*neighborCount]; 
-			
-			blocks = !this._lightPasses(cx, cy);
-			visibility = this._checkVisibility(A1, A2, blocks, SHADOWS);
-			if (visibility) { callback(cx, cy, r, visibility); }
-
-			if (SHADOWS.length == 2 && SHADOWS[0][0] == 0 && SHADOWS[1][0] == SHADOWS[1][1]) { return; } /* cutoff? */
-
-		} /* for all cells in this ring */
-	} /* for all rings */
-}
-
-/**
- * @param {int[2]} A1 arc start
- * @param {int[2]} A2 arc end
- * @param {bool} blocks Does current arc block visibility?
- * @param {int[][]} SHADOWS list of active shadows
- */
-ROT.FOV.PreciseShadowcasting.prototype._checkVisibility = function(A1, A2, blocks, SHADOWS) {
-	if (A1[0] > A2[0]) { /* split into two sub-arcs */
-		var v1 = this._checkVisibility(A1, [A1[1], A1[1]], blocks, SHADOWS);
-		var v2 = this._checkVisibility([0, 1], A2, blocks, SHADOWS);
-		return (v1+v2)/2;
-	}
-
-	/* index1: first shadow >= A1 */
-	var index1 = 0, edge1 = false;
-	while (index1 < SHADOWS.length) {
-		var old = SHADOWS[index1];
-		var diff = old[0]*A1[1] - A1[0]*old[1];
-		if (diff >= 0) { /* old >= A1 */
-			if (diff == 0 && !(index1 % 2)) { edge1 = true; }
-			break;
-		}
-		index1++;
-	}
-
-	/* index2: last shadow <= A2 */
-	var index2 = SHADOWS.length, edge2 = false;
-	while (index2--) {
-		var old = SHADOWS[index2];
-		var diff = A2[0]*old[1] - old[0]*A2[1];
-		if (diff >= 0) { /* old <= A2 */
-			if (diff == 0 && (index2 % 2)) { edge2 = true; }
-			break;
-		}
-	}
-
-	var visible = true;
-	if (index1 == index2 && (edge1 || edge2)) {  /* subset of existing shadow, one of the edges match */
-		visible = false; 
-	} else if (edge1 && edge2 && index1+1==index2 && (index2 % 2)) { /* completely equivalent with existing shadow */
-		visible = false;
-	} else if (index1 > index2 && (index1 % 2)) { /* subset of existing shadow, not touching */
-		visible = false;
-	}
-	
-	if (!visible) { return 0; } /* fast case: not visible */
-	
-	var visibleLength, P;
-
-	/* compute the length of visible arc, adjust list of shadows (if blocking) */
-	var remove = index2-index1+1;
-	if (remove % 2) {
-		if (index1 % 2) { /* first edge within existing shadow, second outside */
-			var P = SHADOWS[index1];
-			visibleLength = (A2[0]*P[1] - P[0]*A2[1]) / (P[1] * A2[1]);
-			if (blocks) { SHADOWS.splice(index1, remove, A2); }
-		} else { /* second edge within existing shadow, first outside */
-			var P = SHADOWS[index2];
-			visibleLength = (P[0]*A1[1] - A1[0]*P[1]) / (A1[1] * P[1]);
-			if (blocks) { SHADOWS.splice(index1, remove, A1); }
-		}
-	} else {
-		if (index1 % 2) { /* both edges within existing shadows */
-			var P1 = SHADOWS[index1];
-			var P2 = SHADOWS[index2];
-			visibleLength = (P2[0]*P1[1] - P1[0]*P2[1]) / (P1[1] * P2[1]);
-			if (blocks) { SHADOWS.splice(index1, remove); }
-		} else { /* both edges outside existing shadows */
-			if (blocks) { SHADOWS.splice(index1, remove, A1, A2); }
-			return 1; /* whole arc visible! */
-		}
-	}
-
-	var arcLength = (A2[0]*A1[1] - A1[0]*A2[1]) / (A1[1] * A2[1]);
-
-	return visibleLength/arcLength;
-}
-/**
- * @namespace Color operations
- */
-ROT.Color = {
-	fromString: function(str) {
-		var cached, r;
-		if (str in this._cache) {
-			cached = this._cache[str];
-		} else {
-			if (str.charAt(0) == "#") { /* hex rgb */
-
-				var values = str.match(/[0-9a-f]/gi).map(function(x) { return parseInt(x, 16); });
-				if (values.length == 3) {
-					cached = values.map(function(x) { return x*17; });
-				} else {
-					for (var i=0;i<3;i++) {
-						values[i+1] += 16*values[i];
-						values.splice(i, 1);
-					}
-					cached = values;
-				}
-
-			} else if (r = str.match(/rgb\(([0-9, ]+)\)/i)) { /* decimal rgb */
-				cached = r[1].split(/\s*,\s*/).map(function(x) { return parseInt(x); });
-			} else { /* html name */
-				cached = [0, 0, 0];
-			}
-
-			this._cache[str] = cached;
-		}
-
-		return cached.slice();
-	},
-
-	/**
-	 * Add two or more colors
-	 * @param {number[]} color1
-	 * @param {number[]} color2
-	 * @returns {number[]}
-	 */
-	add: function(color1, color2) {
-		var result = color1.slice();
-		for (var i=0;i<3;i++) {
-			for (var j=1;j<arguments.length;j++) {
-				result[i] += arguments[j][i];
-			}
-		}
-		return result;
-	},
-
-	/**
-	 * Add two or more colors, MODIFIES FIRST ARGUMENT
-	 * @param {number[]} color1
-	 * @param {number[]} color2
-	 * @returns {number[]}
-	 */
-	add_: function(color1, color2) {
-		for (var i=0;i<3;i++) {
-			for (var j=1;j<arguments.length;j++) {
-				color1[i] += arguments[j][i];
-			}
-		}
-		return color1;
-	},
-
-	/**
-	 * Multiply (mix) two or more colors
-	 * @param {number[]} color1
-	 * @param {number[]} color2
-	 * @returns {number[]}
-	 */
-	multiply: function(color1, color2) {
-		var result = color1.slice();
-		for (var i=0;i<3;i++) {
-			for (var j=1;j<arguments.length;j++) {
-				result[i] *= arguments[j][i] / 255;
-			}
-			result[i] = Math.round(result[i]);
-		}
-		return result;
-	},
-
-	/**
-	 * Multiply (mix) two or more colors, MODIFIES FIRST ARGUMENT
-	 * @param {number[]} color1
-	 * @param {number[]} color2
-	 * @returns {number[]}
-	 */
-	multiply_: function(color1, color2) {
-		for (var i=0;i<3;i++) {
-			for (var j=1;j<arguments.length;j++) {
-				color1[i] *= arguments[j][i] / 255;
-			}
-			color1[i] = Math.round(color1[i]);
-		}
-		return color1;
-	},
-
-	/**
-	 * Interpolate (blend) two colors with a given factor
-	 * @param {number[]} color1
-	 * @param {number[]} color2
-	 * @param {float} [factor=0.5] 0..1
-	 * @returns {number[]}
-	 */
-	interpolate: function(color1, color2, factor) {
-		if (arguments.length < 3) { factor = 0.5; }
-		var result = color1.slice();
-		for (var i=0;i<3;i++) {
-			result[i] = Math.round(result[i] + factor*(color2[i]-color1[i]));
-		}
-		return result;
-	},
-
-	/**
-	 * Interpolate (blend) two colors with a given factor in HSL mode
-	 * @param {number[]} color1
-	 * @param {number[]} color2
-	 * @param {float} [factor=0.5] 0..1
-	 * @returns {number[]}
-	 */
-	interpolateHSL: function(color1, color2, factor) {
-		if (arguments.length < 3) { factor = 0.5; }
-		var hsl1 = this.rgb2hsl(color1);
-		var hsl2 = this.rgb2hsl(color2);
-		for (var i=0;i<3;i++) {
-			hsl1[i] += factor*(hsl2[i]-hsl1[i]);
-		}
-		return this.hsl2rgb(hsl1);
-	},
-
-	/**
-	 * Create a new random color based on this one
-	 * @param {number[]} color
-	 * @param {number[]} diff Set of standard deviations
-	 * @returns {number[]}
-	 */
-	randomize: function(color, diff) {
-		if (!(diff instanceof Array)) { diff = ROT.RNG.getNormal(0, diff); }
-		var result = color.slice();
-		for (var i=0;i<3;i++) {
-			result[i] += (diff instanceof Array ? Math.round(ROT.RNG.getNormal(0, diff[i])) : diff);
-		}
-		return result;
-	},
-
-	/**
-	 * Converts an RGB color value to HSL. Expects 0..255 inputs, produces 0..1 outputs.
-	 * @param {number[]} color
-	 * @returns {number[]}
-	 */
-	rgb2hsl: function(color) {
-		var r = color[0]/255;
-		var g = color[1]/255;
-		var b = color[2]/255;
-
-		var max = Math.max(r, g, b), min = Math.min(r, g, b);
-		var h, s, l = (max + min) / 2;
-
-		if (max == min) {
-			h = s = 0; // achromatic
-		} else {
-			var d = max - min;
-			s = (l > 0.5 ? d / (2 - max - min) : d / (max + min));
-			switch(max) {
-				case r: h = (g - b) / d + (g < b ? 6 : 0); break;
-				case g: h = (b - r) / d + 2; break;
-				case b: h = (r - g) / d + 4; break;
-			}
-			h /= 6;
-		}
-
-		return [h, s, l];
-	},
-
-	/**
-	 * Converts an HSL color value to RGB. Expects 0..1 inputs, produces 0..255 outputs.
-	 * @param {number[]} color
-	 * @returns {number[]}
-	 */
-	hsl2rgb: function(color) {
-		var l = color[2];
-
-		if (color[1] == 0) {
-			l *= 255;
-			return [l, l, l];
-		} else {
-			function hue2rgb(p, q, t) {
-				if (t < 0) t += 1;
-				if (t > 1) t -= 1;
-				if (t < 1/6) return p + (q - p) * 6 * t;
-				if (t < 1/2) return q;
-				if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
-				return p;
-			}
-
-			var s = color[1];
-			var q = (l < 0.5 ? l * (1 + s) : l + s - l * s);
-			var p = 2 * l - q;
-			var r = hue2rgb(p, q, color[0] + 1/3);
-			var g = hue2rgb(p, q, color[0]);
-			var b = hue2rgb(p, q, color[0] - 1/3);
-			return [Math.round(r*255), Math.round(g*255), Math.round(b*255)];
-		}
-	},
-
-	toRGB: function(color) {
-		return "rgb(" + this._clamp(color[0]) + "," + this._clamp(color[1]) + "," + this._clamp(color[2]) + ")";
-	},
-
-	toHex: function(color) {
-		var parts = [];
-		for (var i=0;i<3;i++) {
-			parts.push(this._clamp(color[i]).toString(16).lpad("0", 2));
-		}
-		return "#" + parts.join("");
-	},
-
-	_clamp: function(num) {
-		if (num < 0) {
-			return 0;
-		} else if (num > 255) {
-			return 255;
-		} else {
-			return num;
-		}
-	},
-
-	_cache: {
-		"black": [0,0,0],
-		"navy": [0,0,128],
-		"darkblue": [0,0,139],
-		"mediumblue": [0,0,205],
-		"blue": [0,0,255],
-		"darkgreen": [0,100,0],
-		"green": [0,128,0],
-		"teal": [0,128,128],
-		"darkcyan": [0,139,139],
-		"deepskyblue": [0,191,255],
-		"darkturquoise": [0,206,209],
-		"mediumspringgreen": [0,250,154],
-		"lime": [0,255,0],
-		"springgreen": [0,255,127],
-		"aqua": [0,255,255],
-		"cyan": [0,255,255],
-		"midnightblue": [25,25,112],
-		"dodgerblue": [30,144,255],
-		"forestgreen": [34,139,34],
-		"seagreen": [46,139,87],
-		"darkslategray": [47,79,79],
-		"darkslategrey": [47,79,79],
-		"limegreen": [50,205,50],
-		"mediumseagreen": [60,179,113],
-		"turquoise": [64,224,208],
-		"royalblue": [65,105,225],
-		"steelblue": [70,130,180],
-		"darkslateblue": [72,61,139],
-		"mediumturquoise": [72,209,204],
-		"indigo": [75,0,130],
-		"darkolivegreen": [85,107,47],
-		"cadetblue": [95,158,160],
-		"cornflowerblue": [100,149,237],
-		"mediumaquamarine": [102,205,170],
-		"dimgray": [105,105,105],
-		"dimgrey": [105,105,105],
-		"slateblue": [106,90,205],
-		"olivedrab": [107,142,35],
-		"slategray": [112,128,144],
-		"slategrey": [112,128,144],
-		"lightslategray": [119,136,153],
-		"lightslategrey": [119,136,153],
-		"mediumslateblue": [123,104,238],
-		"lawngreen": [124,252,0],
-		"chartreuse": [127,255,0],
-		"aquamarine": [127,255,212],
-		"maroon": [128,0,0],
-		"purple": [128,0,128],
-		"olive": [128,128,0],
-		"gray": [128,128,128],
-		"grey": [128,128,128],
-		"skyblue": [135,206,235],
-		"lightskyblue": [135,206,250],
-		"blueviolet": [138,43,226],
-		"darkred": [139,0,0],
-		"darkmagenta": [139,0,139],
-		"saddlebrown": [139,69,19],
-		"darkseagreen": [143,188,143],
-		"lightgreen": [144,238,144],
-		"mediumpurple": [147,112,216],
-		"darkviolet": [148,0,211],
-		"palegreen": [152,251,152],
-		"darkorchid": [153,50,204],
-		"yellowgreen": [154,205,50],
-		"sienna": [160,82,45],
-		"brown": [165,42,42],
-		"darkgray": [169,169,169],
-		"darkgrey": [169,169,169],
-		"lightblue": [173,216,230],
-		"greenyellow": [173,255,47],
-		"paleturquoise": [175,238,238],
-		"lightsteelblue": [176,196,222],
-		"powderblue": [176,224,230],
-		"firebrick": [178,34,34],
-		"darkgoldenrod": [184,134,11],
-		"mediumorchid": [186,85,211],
-		"rosybrown": [188,143,143],
-		"darkkhaki": [189,183,107],
-		"silver": [192,192,192],
-		"mediumvioletred": [199,21,133],
-		"indianred": [205,92,92],
-		"peru": [205,133,63],
-		"chocolate": [210,105,30],
-		"tan": [210,180,140],
-		"lightgray": [211,211,211],
-		"lightgrey": [211,211,211],
-		"palevioletred": [216,112,147],
-		"thistle": [216,191,216],
-		"orchid": [218,112,214],
-		"goldenrod": [218,165,32],
-		"crimson": [220,20,60],
-		"gainsboro": [220,220,220],
-		"plum": [221,160,221],
-		"burlywood": [222,184,135],
-		"lightcyan": [224,255,255],
-		"lavender": [230,230,250],
-		"darksalmon": [233,150,122],
-		"violet": [238,130,238],
-		"palegoldenrod": [238,232,170],
-		"lightcoral": [240,128,128],
-		"khaki": [240,230,140],
-		"aliceblue": [240,248,255],
-		"honeydew": [240,255,240],
-		"azure": [240,255,255],
-		"sandybrown": [244,164,96],
-		"wheat": [245,222,179],
-		"beige": [245,245,220],
-		"whitesmoke": [245,245,245],
-		"mintcream": [245,255,250],
-		"ghostwhite": [248,248,255],
-		"salmon": [250,128,114],
-		"antiquewhite": [250,235,215],
-		"linen": [250,240,230],
-		"lightgoldenrodyellow": [250,250,210],
-		"oldlace": [253,245,230],
-		"red": [255,0,0],
-		"fuchsia": [255,0,255],
-		"magenta": [255,0,255],
-		"deeppink": [255,20,147],
-		"orangered": [255,69,0],
-		"tomato": [255,99,71],
-		"hotpink": [255,105,180],
-		"coral": [255,127,80],
-		"darkorange": [255,140,0],
-		"lightsalmon": [255,160,122],
-		"orange": [255,165,0],
-		"lightpink": [255,182,193],
-		"pink": [255,192,203],
-		"gold": [255,215,0],
-		"peachpuff": [255,218,185],
-		"navajowhite": [255,222,173],
-		"moccasin": [255,228,181],
-		"bisque": [255,228,196],
-		"mistyrose": [255,228,225],
-		"blanchedalmond": [255,235,205],
-		"papayawhip": [255,239,213],
-		"lavenderblush": [255,240,245],
-		"seashell": [255,245,238],
-		"cornsilk": [255,248,220],
-		"lemonchiffon": [255,250,205],
-		"floralwhite": [255,250,240],
-		"snow": [255,250,250],
-		"yellow": [255,255,0],
-		"lightyellow": [255,255,224],
-		"ivory": [255,255,240],
-		"white": [255,255,255]
-	}
-}
-/**
- * @class Lighting computation, based on a traditional FOV for multiple light sources and multiple passes.
- * @param {function} reflectivityCallback Callback to retrieve cell reflectivity (0..1)
- * @param {object} [options]
- * @param {int} [options.passes=1] Number of passes. 1 equals to simple FOV of all light sources, >1 means a *highly simplified* radiosity-like algorithm.
- * @param {int} [options.emissionThreshold=100] Cells with emissivity > threshold will be treated as light source in the next pass.
- * @param {int} [options.range=10] Max light range
- */
-ROT.Lighting = function(reflectivityCallback, options) {
-	this._reflectivityCallback = reflectivityCallback;
-	this._options = {
-		passes: 1,
-		emissionThreshold: 100,
-		range: 10
-	};
-	this._fov = null;
-
-	this._lights = {};
-	this._reflectivityCache = {};
-	this._fovCache = {};
-
-	this.setOptions(options);
-}
-
-/**
- * Adjust options at runtime
- * @see ROT.Lighting
- * @param {object} [options]
- */
-ROT.Lighting.prototype.setOptions = function(options) {
-	for (var p in options) { this._options[p] = options[p]; }
-	if (options.range) { this.reset(); }
-	return this;
-}
-
-/**
- * Set the used Field-Of-View algo
- * @param {ROT.FOV} fov
- */
-ROT.Lighting.prototype.setFOV = function(fov) {
-	this._fov = fov;
-	this._fovCache = {};
-	return this;
-}
-
-/**
- * Set (or remove) a light source
- * @param {int} x
- * @param {int} y
- * @param {null || string || number[3]} color
- */
-ROT.Lighting.prototype.setLight = function(x, y, color) {
-	var key = x+","+y;
-
-	if (color) {
-		this._lights[key] = (typeof(color) == "string" ? ROT.Color.fromString(color) : color);
-	} else {
-		delete this._lights[key];
-	}
-	return this;
-}
-
-/**
- * Reset the pre-computed topology values. Call whenever the underlying map changes its light-passability.
- */
-ROT.Lighting.prototype.reset = function() {
-	this._reflectivityCache = {};
-	this._fovCache = {};
-
-	return this;
-}
-
-/**
- * Compute the lighting
- * @param {function} lightingCallback Will be called with (x, y, color) for every lit cell
- */
-ROT.Lighting.prototype.compute = function(lightingCallback) {
-	var doneCells = {};
-	var emittingCells = {};
-	var litCells = {};
-
-	for (var key in this._lights) { /* prepare emitters for first pass */
-		var light = this._lights[key];
-		if (!(key in emittingCells)) { emittingCells[key] = [0, 0, 0]; }
-
-		ROT.Color.add_(emittingCells[key], light);
-	}
-
-	for (var i=0;i<this._options.passes;i++) { /* main loop */
-		this._emitLight(emittingCells, litCells, doneCells);
-		if (i+1 == this._options.passes) { continue; } /* not for the last pass */
-		emittingCells = this._computeEmitters(litCells, doneCells);
-	}
-
-	for (var litKey in litCells) { /* let the user know what and how is lit */
-		var parts = litKey.split(",");
-		var x = parseInt(parts[0]);
-		var y = parseInt(parts[1]);
-		lightingCallback(x, y, litCells[litKey]);
-	}
-
-	return this;
-}
-
-/**
- * Compute one iteration from all emitting cells
- * @param {object} emittingCells These emit light
- * @param {object} litCells Add projected light to these
- * @param {object} doneCells These already emitted, forbid them from further calculations
- */
-ROT.Lighting.prototype._emitLight = function(emittingCells, litCells, doneCells) {
-	for (var key in emittingCells) {
-		var parts = key.split(",");
-		var x = parseInt(parts[0]);
-		var y = parseInt(parts[1]);
-		this._emitLightFromCell(x, y, emittingCells[key], litCells);
-		doneCells[key] = 1;
-	}
-	return this;
-}
-
-/**
- * Prepare a list of emitters for next pass
- * @param {object} litCells
- * @param {object} doneCells
- * @returns {object}
- */
-ROT.Lighting.prototype._computeEmitters = function(litCells, doneCells) {
-	var result = {};
-
-	for (var key in litCells) {
-		if (key in doneCells) { continue; } /* already emitted */
-
-		var color = litCells[key];
-
-		if (key in this._reflectivityCache) {
-			var reflectivity = this._reflectivityCache[key];
-		} else {
-			var parts = key.split(",");
-			var x = parseInt(parts[0]);
-			var y = parseInt(parts[1]);
-			var reflectivity = this._reflectivityCallback(x, y);
-			this._reflectivityCache[key] = reflectivity;
-		}
-
-		if (reflectivity == 0) { continue; } /* will not reflect at all */
-
-		/* compute emission color */
-		var emission = [];
-		var intensity = 0;
-		for (var i=0;i<3;i++) {
-			var part = Math.round(color[i]*reflectivity);
-			emission[i] = part;
-			intensity += part;
-		}
-		if (intensity > this._options.emissionThreshold) { result[key] = emission; }
-	}
-
-	return result;
-}
-
-/**
- * Compute one iteration from one cell
- * @param {int} x
- * @param {int} y
- * @param {number[]} color
- * @param {object} litCells Cell data to by updated
- */
-ROT.Lighting.prototype._emitLightFromCell = function(x, y, color, litCells) {
-	var key = x+","+y;
-	if (key in this._fovCache) {
-		var fov = this._fovCache[key];
-	} else {
-		var fov = this._updateFOV(x, y);
-	}
-
-	for (var fovKey in fov) {
-		var formFactor = fov[fovKey];
-
-		if (fovKey in litCells) { /* already lit */
-			var result = litCells[fovKey];
-		} else { /* newly lit */
-			var result = [0, 0, 0];
-			litCells[fovKey] = result;
-		}
-
-		for (var i=0;i<3;i++) { result[i] += Math.round(color[i]*formFactor); } /* add light color */
-	}
-
-	return this;
-}
-
-/**
- * Compute FOV ("form factor") for a potential light source at [x,y]
- * @param {int} x
- * @param {int} y
- * @returns {object}
- */
-ROT.Lighting.prototype._updateFOV = function(x, y) {
-	var key1 = x+","+y;
-	var cache = {};
-	this._fovCache[key1] = cache;
-	var range = this._options.range;
-	var cb = function(x, y, r, vis) {
-		var key2 = x+","+y;
-		var formFactor = vis * (1-r/range);
-		if (formFactor == 0) { return; }
-		cache[key2] = formFactor;
-	}
-	this._fov.compute(x, y, range, cb.bind(this));
-
-	return cache;
-}
-/**
- * @class Abstract pathfinder
- * @param {int} toX Target X coord
- * @param {int} toY Target Y coord
- * @param {function} passableCallback Callback to determine map passability
- * @param {object} [options]
- * @param {int} [options.topology=8]
- */
-ROT.Path = function(toX, toY, passableCallback, options) {
-	this._toX = toX;
-	this._toY = toY;
-	this._fromX = null;
-	this._fromY = null;
-	this._passableCallback = passableCallback;
-	this._options = {
-		topology: 8
-	}
-	for (var p in options) { this._options[p] = options[p]; }
-
-	this._dirs = ROT.DIRS[this._options.topology];
-}
-
-/**
- * Compute a path from a given point
- * @param {int} fromX
- * @param {int} fromY
- * @param {function} callback Will be called for every path item with arguments "x" and "y"
- */
-ROT.Path.prototype.compute = function(fromX, fromY, callback) {
-}
-
-ROT.Path.prototype._getNeighbors = function(cx, cy) {
-	var result = [];
-	for (var i=0;i<this._dirs.length;i++) {
-		var dir = this._dirs[i];
-		var x = cx + dir[0];
-		var y = cy + dir[1];
-		
-		if (!this._passableCallback(x, y)) { continue; }
-		result.push([x, y]);
-	}
-	
-	return result;
-}
-/**
- * @class Simplified Dijkstra's algorithm: all edges have a value of 1
- * @augments ROT.Path
- * @see ROT.Path
- */
-ROT.Path.Dijkstra = function(toX, toY, passableCallback, options) {
-	ROT.Path.call(this, toX, toY, passableCallback, options);
-
-	this._computed = {};
-	this._todo = [];
-	this._add(toX, toY, null);
-}
-ROT.Path.Dijkstra.extend(ROT.Path);
-
-/**
- * Compute a path from a given point
- * @see ROT.Path#compute
- */
-ROT.Path.Dijkstra.prototype.compute = function(fromX, fromY, callback) {
-	var key = fromX+","+fromY;
-	if (!(key in this._computed)) { this._compute(fromX, fromY); }
-	if (!(key in this._computed)) { return; }
-	
-	var item = this._computed[key];
-	while (item) {
-		callback(item.x, item.y);
-		item = item.prev;
-	}
-}
-
-/**
- * Compute a non-cached value
- */
-ROT.Path.Dijkstra.prototype._compute = function(fromX, fromY) {
-	while (this._todo.length) {
-		var item = this._todo.shift();
-		if (item.x == fromX && item.y == fromY) { return; }
-		
-		var neighbors = this._getNeighbors(item.x, item.y);
-		
-		for (var i=0;i<neighbors.length;i++) {
-			var neighbor = neighbors[i];
-			var x = neighbor[0];
-			var y = neighbor[1];
-			var id = x+","+y;
-			if (id in this._computed) { continue; } /* already done */	
-			this._add(x, y, item); 
-		}
-	}
-}
-
-ROT.Path.Dijkstra.prototype._add = function(x, y, prev) {
-	var obj = {
-		x: x,
-		y: y,
-		prev: prev
-	}
-	this._computed[x+","+y] = obj;
-	this._todo.push(obj);
-}
-/**
- * @class Simplified A* algorithm: all edges have a value of 1
- * @augments ROT.Path
- * @see ROT.Path
- */
-ROT.Path.AStar = function(toX, toY, passableCallback, options) {
-	ROT.Path.call(this, toX, toY, passableCallback, options);
-
-	this._todo = [];
-	this._done = {};
-	this._fromX = null;
-	this._fromY = null;
-}
-ROT.Path.AStar.extend(ROT.Path);
-
-/**
- * Compute a path from a given point
- * @see ROT.Path#compute
- */
-ROT.Path.AStar.prototype.compute = function(fromX, fromY, callback) {
-	this._todo = [];
-	this._done = {};
-	this._fromX = fromX;
-	this._fromY = fromY;
-	this._add(this._toX, this._toY, null);
-
-	while (this._todo.length) {
-		var item = this._todo.shift();
-		if (item.x == fromX && item.y == fromY) { break; }
-		var neighbors = this._getNeighbors(item.x, item.y);
-
-		for (var i=0;i<neighbors.length;i++) {
-			var neighbor = neighbors[i];
-			var x = neighbor[0];
-			var y = neighbor[1];
-			var id = x+","+y;
-			if (id in this._done) { continue; }
-			this._add(x, y, item); 
-		}
-	}
-	
-	var item = this._done[fromX+","+fromY];
-	if (!item) { return; }
-	
-	while (item) {
-		callback(item.x, item.y);
-		item = item.prev;
-	}
-}
-
-ROT.Path.AStar.prototype._add = function(x, y, prev) {
-	var obj = {
-		x: x,
-		y: y,
-		prev: prev,
-		g: (prev ? prev.g+1 : 0),
-		h: this._distance(x, y)
-	}
-	this._done[x+","+y] = obj;
-	
-	/* insert into priority queue */
-	
-	var f = obj.g + obj.h;
-	for (var i=0;i<this._todo.length;i++) {
-		var item = this._todo[i];
-		if (f < item.g + item.h) {
-			this._todo.splice(i, 0, obj);
-			return;
-		}
-	}
-	
-	this._todo.push(obj);
-}
-
-ROT.Path.AStar.prototype._distance = function(x, y) {
-	switch (this._options.topology) {
-		case 4:
-			return (Math.abs(x-this._fromX) + Math.abs(y-this._fromY));
-		break;
-
-		case 6:
-			var dx = Math.abs(x - this._fromX);
-			var dy = Math.abs(y - this._fromY);
-			return dy + Math.max(0, (dx-dy)/2);
-		break;
-
-		case 8: 
-			return Math.max(Math.abs(x-this._fromX), Math.abs(y-this._fromY));
-		break;
-	}
-}
-/**
- * @class Base image (as ASCII art) converter
- */
-ROT.Image = function() {
-	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
-	this.aDefaultColorCharList = (" CGO08@").split("");
-	this.strFont = "courier new";
-};
-
-ROT.Image.prototype.get = function(xin, yin) {
-	console.log(888);
-}
diff --git a/examples/test.html b/examples/test.html
deleted file mode 100644
index b77779e3..00000000
--- a/examples/test.html
+++ /dev/null
@@ -1,31 +0,0 @@
-<html>
-<head>
-<title>test</title>
-</head>
-<body>
-<script type="text/javascript" src="rot.js"></script>
-<script type="text/javascript">
-var w = 256;
-var h = 100;
-var noise = new ROT.Noise.Simplex();
-var image = new ROT.Image();
-image.get();
-
-var display = new ROT.Display({width:w, height:h, fontSize:3});
-
-document.body.appendChild(display.getContainer());
-
-for (var j=0;j<h;j++) {
-    for (var i=0;i<w;i++) {
-        var val = noise.get(i/20, j/20) * 255;
-
-        var r = ~~(val>0 ? val : 0);
-        var g = ~~(val<0 ? -val : 0);
-        
-        display.draw(i, j, "", "", "rgb("+r+","+g+",0)");
-    }
-}
-</script>
-<canvas></canvas>
-</body>
-</html>
\ No newline at end of file

From d14790c084eea68d980cc37f55aff1ec33260945 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 20 Aug 2013 02:51:15 +0200
Subject: [PATCH 07/20] Add a small example to testing and check the progress.

---
 examples/test.html | 78 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 examples/test.html

diff --git a/examples/test.html b/examples/test.html
new file mode 100644
index 00000000..c09da2aa
--- /dev/null
+++ b/examples/test.html
@@ -0,0 +1,78 @@
+<html>
+<head>
+<title>test</title>
+</head>
+<body>
+<script type="text/javascript" src="src/rot.js"></script>
+<script type="text/javascript" src="src/text.js"></script>
+<script type="text/javascript" src="src/js/array.js"></script>
+<script type="text/javascript" src="src/js/number.js"></script>
+<script type="text/javascript" src="src/js/string.js"></script>
+<script type="text/javascript" src="src/js/object.js"></script>
+<script type="text/javascript" src="src/js/function.js"></script>
+<script type="text/javascript" src="src/display/display.js"></script>
+<script type="text/javascript" src="src/display/backend.js"></script>
+<script type="text/javascript" src="src/display/rect.js"></script>
+<script type="text/javascript" src="src/display/hex.js"></script>
+<script type="text/javascript" src="src/rng.js"></script>
+<script type="text/javascript" src="src/stringgenerator.js"></script>
+<script type="text/javascript" src="src/eventqueue.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler-simple.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler-speed.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler-action.js"></script>
+<script type="text/javascript" src="src/engine.js"></script>
+<script type="text/javascript" src="src/map/map.js"></script>
+<script type="text/javascript" src="src/map/arena.js"></script>
+<script type="text/javascript" src="src/map/dividedmaze.js"></script>
+<script type="text/javascript" src="src/map/iceymaze.js"></script>
+<script type="text/javascript" src="src/map/ellermaze.js"></script>
+<script type="text/javascript" src="src/map/cellular.js"></script>
+<script type="text/javascript" src="src/map/dungeon.js"></script>
+<script type="text/javascript" src="src/map/digger.js"></script>
+<script type="text/javascript" src="src/map/uniform.js"></script>
+<script type="text/javascript" src="src/map/rogue.js"></script>
+<script type="text/javascript" src="src/map/features.js"></script>
+<script type="text/javascript" src="src/noise/noise.js"></script>
+<script type="text/javascript" src="src/noise/simplex.js"></script>
+<script type="text/javascript" src="src/fov/fov.js"></script>
+<script type="text/javascript" src="src/fov/discrete-shadowcasting.js"></script>
+<script type="text/javascript" src="src/fov/precise-shadowcasting.js"></script>
+<script type="text/javascript" src="src/color.js"></script>
+<script type="text/javascript" src="src/lighting.js"></script>
+<script type="text/javascript" src="src/path/path.js"></script>
+<script type="text/javascript" src="src/path/dijkstra.js"></script>
+<script type="text/javascript" src="src/path/astar.js"></script>
+<script type="text/javascript" src="src/image/image.js"></script>
+
+<script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
+
+<script type="text/javascript">
+var w = 256;
+var h = 100;
+var noise = new ROT.Noise.Simplex();
+var image = new ROT.Image();
+image.load("mario.jpg");
+image.get();
+
+var display = new ROT.Display({width:w, height:h, fontSize:3});
+
+document.body.appendChild(display.getContainer());
+
+$("body").html(image.ascii_art);
+
+for (var j=0;j<h;j++) {
+    for (var i=0;i<w;i++) {
+        var val = noise.get(i/20, j/20) * 255;
+
+        var r = ~~(val>0 ? val : 0);
+        var g = ~~(val<0 ? -val : 0);
+        
+        display.draw(i, j, "", "", "rgb("+r+","+g+",0)");
+    }
+}
+</script>
+<canvas></canvas>
+<img src="mario.jpg"/>
+</body>
+</html>
\ No newline at end of file

From 7a7e92621169950b7a894fa171ad6ad802094a14 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 3 Sep 2013 01:32:46 +0200
Subject: [PATCH 08/20] More changes.

---
 src/image/image.js | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/image/image.js b/src/image/image.js
index f627e259..e3b17ae5 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -5,14 +5,19 @@ ROT.Image = function() {
 	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
 	this.aDefaultColorCharList = (" CGO08@").split("");
 	this.strFont = "courier new";
+	this.bBlock = true;
+	this.bAlpha = false;
+	this.bColor = true;
+	this.strResolution = "low";
 	
 	this.ascii_art = "";
 };
 
 ROT.Image.prototype.loadASCII = function() {
 	var aCharList = this.aDefaultCharList;
-	var bBlock = true;
-	var bAlpha = false;
+	var bBlock = this.bBlock;
+	var bAlpha = this.bAlpha;
+	var bColor = this.bColor;
 	
 	var oCanvas = document.createElement("canvas");
 	if (!oCanvas.getContext) {
@@ -23,7 +28,7 @@ ROT.Image.prototype.loadASCII = function() {
 		return;
 	}
 	
-	var strResolution = "low";
+	var strResolution = this.strResolution;
 	
 	var fResolution = 0.5;
 	
@@ -72,15 +77,15 @@ ROT.Image.prototype.loadASCII = function() {
 			if (strThisChar == " ") 
 				strThisChar = "&nbsp;";
 			
-			//~ if (bColor) {
+			if (bColor) {
 				strChars += "<span style='"
 					+ "color:rgb("+iRed+","+iGreen+","+iBlue+");"
 					+ (bBlock ? "background-color:rgb("+iRed+","+iGreen+","+iBlue+");" : "")
 					+ (bAlpha ? "opacity:" + (iAlpha/255) + ";" : "")
 					+ "'>" + strThisChar + "</span>";
-			//~ } else {
-				//~ strChars += strThisChar;
-			//~ }
+			} else {
+				strChars += strThisChar;
+			}
 		}
 		strChars += "<br/>";
 	}

From ea857af6d76e549329695e06edbc4eabfa4a81b2 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Wed, 4 Sep 2013 01:27:27 +0200
Subject: [PATCH 09/20] First beta version. There is a method to print a ascii
 art in rot!!

---
 src/image/image.js | 41 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 40 insertions(+), 1 deletion(-)

diff --git a/src/image/image.js b/src/image/image.js
index e3b17ae5..77a16041 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -11,6 +11,9 @@ ROT.Image = function() {
 	this.strResolution = "low";
 	
 	this.ascii_art = "";
+	this.ascii_art_array = null;
+	this.height = 0;
+	this.width = 0;
 };
 
 ROT.Image.prototype.loadASCII = function() {
@@ -40,6 +43,8 @@ ROT.Image.prototype.loadASCII = function() {
 	
 	var iWidth = Math.round(parseInt(this.img.width) * fResolution);
 	var iHeight = Math.round(parseInt(this.img.height) * fResolution);
+	this.width = iWidth;
+	this.height = iHeight;
 	
 	oCanvas.width = iWidth;
 	oCanvas.height = iHeight;
@@ -52,8 +57,10 @@ ROT.Image.prototype.loadASCII = function() {
 	var oImgData = oCtx.getImageData(0, 0, iWidth, iHeight).data;
 	
 	var strChars = "";
+	var array_chars = [];
 	
 	for (var y=0;y<iHeight;y+=2) {
+		array_chars[y] = [];
 		for (var x=0;x<iWidth;x++) {
 			var iOffset = (y*iWidth + x) * 4;
 			
@@ -73,6 +80,7 @@ ROT.Image.prototype.loadASCII = function() {
 				//~ iCharIdx = (aCharList.length-1) - iCharIdx;
 			//~ }
 			var strThisChar = aCharList[iCharIdx];
+			var unscape_char = strThisChar;
 			
 			if (strThisChar == " ") 
 				strThisChar = "&nbsp;";
@@ -83,13 +91,18 @@ ROT.Image.prototype.loadASCII = function() {
 					+ (bBlock ? "background-color:rgb("+iRed+","+iGreen+","+iBlue+");" : "")
 					+ (bAlpha ? "opacity:" + (iAlpha/255) + ";" : "")
 					+ "'>" + strThisChar + "</span>";
+				
+				array_chars[y][x] = {'r': iRed, 'g' : iGreen, 'b' : iBlue, 'char': unscape_char};
 			} else {
 				strChars += strThisChar;
+				array_chars[y][x] = {'char': unscape_char};
 			}
 		}
 		strChars += "<br/>";
 	}
 	
+	this.ascii_art_array = array_chars;
+	
 	return strChars;
 };
 
@@ -107,5 +120,31 @@ ROT.Image.prototype.load = function(image_url) {
 };
 
 ROT.Image.prototype.get = function(xin, yin) {
-	console.log(888);
+	return this.ascii_art_array[yin][xin];
+};
+
+ROT.Image.prototype.paint = function(display, offset_x, offset_y) {
+	var i = 0;
+	for (var y = 0; y < this.height; y += 2) {
+		var j = 0;
+		for (var x = 0; x < this.width; x++) {
+			if (this.bColor) {
+				var color = "#" +
+					this.ascii_art_array[y][x]['r'].toString(16) +
+					this.ascii_art_array[y][x]['g'].toString(16) +
+					this.ascii_art_array[y][x]['b'].toString(16);
+				if (this.bBlock) {
+					display.draw(offset_x + j,  offset_y + i, this.ascii_art_array[y][x]['char'], color, color);
+				}
+				else {
+					display.draw(offset_x + j,  offset_y + i, this.ascii_art_array[y][x]['char'], color);
+				}
+			}
+			else {
+				display.draw(offset_x + j,  offset_y + i, this.ascii_art_array[y][x]['char']);
+			}
+			j++;
+		}
+		i++;
+	}
 };
\ No newline at end of file

From dc2aac4d6d64327bc1520f1b385bab239eb2ce24 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Fri, 27 Sep 2013 02:22:07 +0200
Subject: [PATCH 10/20] It is a early version of image ascii art, there are
 blit functions.

---
 src/image/image.js | 43 ++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 38 insertions(+), 5 deletions(-)

diff --git a/src/image/image.js b/src/image/image.js
index 77a16041..d70e9083 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -59,8 +59,9 @@ ROT.Image.prototype.loadASCII = function() {
 	var strChars = "";
 	var array_chars = [];
 	
+	var iterator_y = 0;
 	for (var y=0;y<iHeight;y+=2) {
-		array_chars[y] = [];
+		array_chars[iterator_y] = [];
 		for (var x=0;x<iWidth;x++) {
 			var iOffset = (y*iWidth + x) * 4;
 			
@@ -92,15 +93,19 @@ ROT.Image.prototype.loadASCII = function() {
 					+ (bAlpha ? "opacity:" + (iAlpha/255) + ";" : "")
 					+ "'>" + strThisChar + "</span>";
 				
-				array_chars[y][x] = {'r': iRed, 'g' : iGreen, 'b' : iBlue, 'char': unscape_char};
-			} else {
+				array_chars[iterator_y][x] = {'r': iRed, 'g' : iGreen, 'b' : iBlue, 'char': unscape_char};
+			}
+			else {
 				strChars += strThisChar;
-				array_chars[y][x] = {'char': unscape_char};
+				array_chars[iterator_y][x] = {'char': unscape_char};
 			}
 		}
+		iterator_y++;
 		strChars += "<br/>";
 	}
 	
+	this.height = iterator_y;
+	
 	this.ascii_art_array = array_chars;
 	
 	return strChars;
@@ -123,9 +128,37 @@ ROT.Image.prototype.get = function(xin, yin) {
 	return this.ascii_art_array[yin][xin];
 };
 
+ROT.Image.prototype.blit = function(display, display_x, display_y, image_x, image_y, rect_w, rect_h) {
+	var i = 0;
+	
+	for (var y = image_y; y < rect_h; y++) {
+		var j = 0;
+		for (var x = image_x; x < rect_w; x++) {
+			if (this.bColor) {
+				var color = "#" +
+					this.ascii_art_array[y][x]['r'].toString(16) +
+					this.ascii_art_array[y][x]['g'].toString(16) +
+					this.ascii_art_array[y][x]['b'].toString(16);
+				if (this.bBlock) {
+					display.draw(display_x + j,  display_y + i, this.ascii_art_array[y][x]['char'], color, color);
+				}
+				else {
+					display.draw(display_x + j,  display_y + i, this.ascii_art_array[y][x]['char'], color);
+				}
+			}
+			else {
+				display.draw(display_x + j,  display_y + i, this.ascii_art_array[y][x]['char']);
+			}
+			j++;
+		}
+		i++;
+	}
+};
+
 ROT.Image.prototype.paint = function(display, offset_x, offset_y) {
 	var i = 0;
-	for (var y = 0; y < this.height; y += 2) {
+	
+	for (var y = 0; y < this.height; y++) {
 		var j = 0;
 		for (var x = 0; x < this.width; x++) {
 			if (this.bColor) {

From 64f31fed23adb2e74308ec58fd8f84b619a8b963 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Fri, 27 Sep 2013 02:26:52 +0200
Subject: [PATCH 11/20] Added in the comment where is the original library
 (jsAscii, author Jacob Seidelin) and remove the library.

---
 src/image/image.js   |   7 ++
 src/image/jsascii.js | 194 -------------------------------------------
 2 files changed, 7 insertions(+), 194 deletions(-)
 delete mode 100644 src/image/jsascii.js

diff --git a/src/image/image.js b/src/image/image.js
index d70e9083..4ddee283 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -1,6 +1,13 @@
 /**
  * @class Base image (as ASCII art) converter
  */
+ 
+ //BASED IN THE WORK OF:
+ /*
+ * jsAscii 0.1
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.nihilogic.dk/licenses/mit-license.txt]
+ */
 ROT.Image = function() {
 	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
 	this.aDefaultColorCharList = (" CGO08@").split("");
diff --git a/src/image/jsascii.js b/src/image/jsascii.js
deleted file mode 100644
index 7af9886b..00000000
--- a/src/image/jsascii.js
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * jsAscii 0.1
- * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
- * MIT License [http://www.nihilogic.dk/licenses/mit-license.txt]
- */
-
-var jsAscii = (function() {
-
-	var aDefaultCharList = (" .,:;i1tfLCG08@").split("");
-	var aDefaultColorCharList = (" CGO08@").split("");
-	var strFont = "courier new";
-
-
-	// convert img element to ascii
-	function asciifyImage(oImg, oCanvasImg) 
-	{
-		var oCanvas = document.createElement("canvas");
-		if (!oCanvas.getContext) {
-			return;
-		}
-		var oCtx = oCanvas.getContext("2d");
-		if (!oCtx.getImageData) {
-			return;
-		}
-
-		var iScale = parseInt(oImg.getAttribute("asciiscale")) || 1;
-		var bColor = (oImg.getAttribute("asciicolor") == "true");
-		var bAlpha = (oImg.getAttribute("asciialpha") == "true");
-		var bBlock = (oImg.getAttribute("asciiblock") == "true");
-		var bInvert = (oImg.getAttribute("asciiinvert") == "true");
-		var strResolution = oImg.getAttribute("asciiresolution") || "medium";
-		var aCharList = oImg.getAttribute("asciichars") || 
-			(bColor ? aDefaultColorCharList : aDefaultCharList);
-
-		var fResolution = 0.5;
-		switch (strResolution) {
-			case "low" : 	fResolution = 0.25; break;
-			case "medium" : fResolution = 0.5; break;
-			case "high" : 	fResolution = 1; break;
-		}
-
-		var iWidth = Math.round(parseInt(oImg.offsetWidth) * fResolution);
-		var iHeight = Math.round(parseInt(oImg.offsetHeight) * fResolution);
-
-		oCanvas.width = iWidth;
-		oCanvas.height = iHeight;
-		oCanvas.style.display = "none";
-		oCanvas.style.width = iWidth;
-		oCanvas.style.height = iHeight;
-
-		oCtx.drawImage(oCanvasImg, 0, 0, iWidth, iHeight);
-		var oImgData = oCtx.getImageData(0, 0, iWidth, iHeight).data;
-	
-		var strChars = "";
-
-		for (var y=0;y<iHeight;y+=2) {
-			for (var x=0;x<iWidth;x++) {
-				var iOffset = (y*iWidth + x) * 4;
-	
-				var iRed = oImgData[iOffset];
-				var iGreen = oImgData[iOffset + 1];
-				var iBlue = oImgData[iOffset + 2];
-				var iAlpha = oImgData[iOffset + 3];
-	
-				if (iAlpha == 0) {
-					var iBrightIdx = 0;
-				} else {
-					var fBrightness = (0.3*iRed + 0.59*iGreen + 0.11*iBlue) / 255;
-					var iCharIdx = (aCharList.length-1) - Math.round(fBrightness * (aCharList.length-1));
-				}
-
-				if (bInvert) {
-					iCharIdx = (aCharList.length-1) - iCharIdx;
-				}
-				var strThisChar = aCharList[iCharIdx];
-
-				if (strThisChar == " ") 
-					strThisChar = "&nbsp;";
-
-				if (bColor) {
-					strChars += "<span style='"
-						+ "color:rgb("+iRed+","+iGreen+","+iBlue+");"
-						+ (bBlock ? "background-color:rgb("+iRed+","+iGreen+","+iBlue+");" : "")
-						+ (bAlpha ? "opacity:" + (iAlpha/255) + ";" : "")
-						+ "'>" + strThisChar + "</span>";
-				} else {
-					strChars += strThisChar;
-				}
-			}
-			strChars += "<br/>";
-		}
-	
-	
-		var fFontSize = (2/fResolution)*iScale;
-		var fLineHeight = (2/fResolution)*iScale;
-
-		// adjust letter-spacing for all combinations of scale and resolution to get it to fit the image width.
-		var fLetterSpacing = 0;
-		if (strResolution == "low") {
-			switch (iScale) {
-				case 1 : fLetterSpacing = -1; break;
-				case 2 : 
-				case 3 : fLetterSpacing = -2.1; break;
-				case 4 : fLetterSpacing = -3.1; break;
-				case 5 : fLetterSpacing = -4.15; break;
-			}
-		}
-		if (strResolution == "medium") {
-			switch (iScale) {
-				case 1 : fLetterSpacing = 0; break;
-				case 2 : fLetterSpacing = -1; break;
-				case 3 : fLetterSpacing = -1.04; break;
-				case 4 : 
-				case 5 : fLetterSpacing = -2.1; break;
-			}
-		}
-		if (strResolution == "high") {
-			switch (iScale) {
-				case 1 : 
-				case 2 : fLetterSpacing = 0; break;
-				case 3 : 
-				case 4 : 
-				case 5 : fLetterSpacing = -1; break;
-			}
-		}
-
-
-		// can't get a span or div to flow like an img element, but a table works?
-		var oAscii = document.createElement("table");
-		oAscii.innerHTML = "<tr><td>" + strChars + "</td></tr>";
-
-		if (oImg.style.backgroundColor) {
-			oAscii.rows[0].cells[0].style.backgroundColor = oImg.style.backgroundColor;
-			oAscii.rows[0].cells[0].style.color = oImg.style.color;
-		}
-
-		oAscii.cellSpacing = 0;
-		oAscii.cellPadding = 0;
-
-		var oStyle = oAscii.style;
-		oStyle.display = "inline";
-		oStyle.width = Math.round(iWidth/fResolution*iScale) + "px";
-		oStyle.height = Math.round(iHeight/fResolution*iScale) + "px";
-		oStyle.whiteSpace = "pre";
-		oStyle.margin = "0px";
-		oStyle.padding = "0px";
-		oStyle.letterSpacing = fLetterSpacing + "px";
-		oStyle.fontFamily = strFont;
-		oStyle.fontSize = fFontSize + "px";
-		oStyle.lineHeight = fLineHeight + "px";
-		oStyle.textAlign = "left";
-		oStyle.textDecoration = "none";
-
-		oImg.parentNode.replaceChild(oAscii, oImg);
-
-	}
-
-	// load the image file
-	function asciifyImageLoad(oImg)
-	{
-		var oCanvasImg = new Image();
-		oCanvasImg.src = oImg.src;
-		if (oCanvasImg.complete) {
-			asciifyImage(oImg, oCanvasImg);
-		} else {
-			oCanvasImg.onload = function() {
-				asciifyImage(oImg, oCanvasImg)
-			}
-		}
-	}
-
-	return function() {
-		var aImg = document.getElementsByTagName("img");
-		var aImages = [];
-		for (var i=0;i<aImg.length;i++) {
-			aImages[i] = aImg[i];
-		}
-
-		for (var i=0;i<aImages.length;i++) {
-			if (aImages[i].getAttribute("asciify") == "true") {
-				asciifyImageLoad(aImages[i]);
-			}
-		}
-	}
-	
-})();
-
-
-if (window.addEventListener) { 
-	window.addEventListener("load", jsAscii, false); 
-} else if (window.attachEvent) { 
-	window.attachEvent("onload", jsAscii); 
-}
-

From 55e5c968fe9e39e2c782f4834c4ec8aef6ccba4d Mon Sep 17 00:00:00 2001
From: mdtrooper <miguel@miguel-HP-Pavilion-dm4-Notebook-PC>
Date: Fri, 27 Sep 2013 16:21:01 +0200
Subject: [PATCH 12/20] Added some "awesome" examples of image (ASCII art)
 class.

---
 examples/{test.html => combat.html} |  25 ++++------
 examples/combat.png                 | Bin 0 -> 19756 bytes
 examples/src                        |   1 +
 examples/title.html                 |  69 ++++++++++++++++++++++++++++
 examples/title.png                  | Bin 0 -> 21777 bytes
 src/image/image.js                  |   2 +-
 6 files changed, 79 insertions(+), 18 deletions(-)
 rename examples/{test.html => combat.html} (87%)
 create mode 100644 examples/combat.png
 create mode 120000 examples/src
 create mode 100644 examples/title.html
 create mode 100644 examples/title.png

diff --git a/examples/test.html b/examples/combat.html
similarity index 87%
rename from examples/test.html
rename to examples/combat.html
index c09da2aa..ea6eec96 100644
--- a/examples/test.html
+++ b/examples/combat.html
@@ -48,31 +48,22 @@
 <script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
 
 <script type="text/javascript">
-var w = 256;
-var h = 100;
+var w = 200;
+var h = 60;
 var noise = new ROT.Noise.Simplex();
 var image = new ROT.Image();
-image.load("mario.jpg");
-image.get();
+image.strResolution = "medium";
+image.bBlock = false;
+image.load("combat.png");
 
-var display = new ROT.Display({width:w, height:h, fontSize:3});
+var display = new ROT.Display({width:w, height:h, fontSize:10});
 
-document.body.appendChild(display.getContainer());
+image.paint(display, 0, 0);
 
-$("body").html(image.ascii_art);
+document.body.appendChild(display.getContainer());
 
-for (var j=0;j<h;j++) {
-    for (var i=0;i<w;i++) {
-        var val = noise.get(i/20, j/20) * 255;
 
-        var r = ~~(val>0 ? val : 0);
-        var g = ~~(val<0 ? -val : 0);
-        
-        display.draw(i, j, "", "", "rgb("+r+","+g+",0)");
-    }
-}
 </script>
 <canvas></canvas>
-<img src="mario.jpg"/>
 </body>
 </html>
\ No newline at end of file
diff --git a/examples/combat.png b/examples/combat.png
new file mode 100644
index 0000000000000000000000000000000000000000..286e34dea4430937272e9f8c36c94f9a9032d169
GIT binary patch
literal 19756
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
BHH82G

literal 0
HcmV?d00001

diff --git a/examples/src b/examples/src
new file mode 120000
index 00000000..e057607e
--- /dev/null
+++ b/examples/src
@@ -0,0 +1 @@
+../src/
\ No newline at end of file
diff --git a/examples/title.html b/examples/title.html
new file mode 100644
index 00000000..b82a2c66
--- /dev/null
+++ b/examples/title.html
@@ -0,0 +1,69 @@
+<html>
+<head>
+<title>test</title>
+</head>
+<body>
+<script type="text/javascript" src="src/rot.js"></script>
+<script type="text/javascript" src="src/text.js"></script>
+<script type="text/javascript" src="src/js/array.js"></script>
+<script type="text/javascript" src="src/js/number.js"></script>
+<script type="text/javascript" src="src/js/string.js"></script>
+<script type="text/javascript" src="src/js/object.js"></script>
+<script type="text/javascript" src="src/js/function.js"></script>
+<script type="text/javascript" src="src/display/display.js"></script>
+<script type="text/javascript" src="src/display/backend.js"></script>
+<script type="text/javascript" src="src/display/rect.js"></script>
+<script type="text/javascript" src="src/display/hex.js"></script>
+<script type="text/javascript" src="src/rng.js"></script>
+<script type="text/javascript" src="src/stringgenerator.js"></script>
+<script type="text/javascript" src="src/eventqueue.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler-simple.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler-speed.js"></script>
+<script type="text/javascript" src="src/scheduler/scheduler-action.js"></script>
+<script type="text/javascript" src="src/engine.js"></script>
+<script type="text/javascript" src="src/map/map.js"></script>
+<script type="text/javascript" src="src/map/arena.js"></script>
+<script type="text/javascript" src="src/map/dividedmaze.js"></script>
+<script type="text/javascript" src="src/map/iceymaze.js"></script>
+<script type="text/javascript" src="src/map/ellermaze.js"></script>
+<script type="text/javascript" src="src/map/cellular.js"></script>
+<script type="text/javascript" src="src/map/dungeon.js"></script>
+<script type="text/javascript" src="src/map/digger.js"></script>
+<script type="text/javascript" src="src/map/uniform.js"></script>
+<script type="text/javascript" src="src/map/rogue.js"></script>
+<script type="text/javascript" src="src/map/features.js"></script>
+<script type="text/javascript" src="src/noise/noise.js"></script>
+<script type="text/javascript" src="src/noise/simplex.js"></script>
+<script type="text/javascript" src="src/fov/fov.js"></script>
+<script type="text/javascript" src="src/fov/discrete-shadowcasting.js"></script>
+<script type="text/javascript" src="src/fov/precise-shadowcasting.js"></script>
+<script type="text/javascript" src="src/color.js"></script>
+<script type="text/javascript" src="src/lighting.js"></script>
+<script type="text/javascript" src="src/path/path.js"></script>
+<script type="text/javascript" src="src/path/dijkstra.js"></script>
+<script type="text/javascript" src="src/path/astar.js"></script>
+<script type="text/javascript" src="src/image/image.js"></script>
+
+<script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
+
+<script type="text/javascript">
+var w = 200;
+var h = 60;
+var noise = new ROT.Noise.Simplex();
+var image = new ROT.Image();
+image.strResolution = "medium";
+image.bBlock = false;
+image.load("title.png");
+
+var display = new ROT.Display({width:w, height:h, fontSize:10});
+
+image.paint(display, 0, 0);
+
+document.body.appendChild(display.getContainer());
+
+
+</script>
+<canvas></canvas>
+</body>
+</html>
\ No newline at end of file
diff --git a/examples/title.png b/examples/title.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b555d988b53d2fd068f97ab106bd3596ebd4555
GIT binary patch
literal 21777
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
X<ncbSgU95tyHte9u(2pJbC3QX*5IS<

literal 0
HcmV?d00001

diff --git a/src/image/image.js b/src/image/image.js
index 4ddee283..6e570f13 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -15,7 +15,7 @@ ROT.Image = function() {
 	this.bBlock = true;
 	this.bAlpha = false;
 	this.bColor = true;
-	this.strResolution = "low";
+	this.strResolution = "medium";
 	
 	this.ascii_art = "";
 	this.ascii_art_array = null;

From 7252f6a9c843c48439b1d71132e7ee4e51fdb8c5 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 22 Apr 2014 00:39:22 +0200
Subject: [PATCH 13/20] Added a short explain about the ASCIIart support

---
 README.md | 34 +++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 4b9fe16d..5dc38c35 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,36 @@
-rot.js
-======
+rot.js _(with ASCIIart support)_
+=================================
 
-ROguelike Toolkit
+**RO**guelike **T**oolkit
 
 More info: http://ondras.github.com/rot.js
 
 RogueBasin page (with links to some rot.js-based games): http://www.roguebasin.roguelikedevelopment.org/index.php?title=Rot.js
+
+ASCIIart support
+----------------
+This fork has a support for [ASCIIart (link to wikipedia)](http://en.wikipedia.org/wiki/ASCII_art) for you use the image files in native format (jpg, png…) and the game shows a pretty ASCIIart.
+
+It is very easy to use.
+
+```javascript
+var image = new ROT.Image();
+
+image.strResolution = "medium";
+image.bBlock = false;
+image.load("combat.png");
+
+var display = new ROT.Display({width:w, height:h, fontSize:10});
+
+image.paint(display, 0, 0);
+```
+
+The image methods are:
+* load(url): get a image from url and convert to ASCIIart.
+* blit(display, display_x, display_y, image_x, image_y, rect_w, rect_h): paint a part of ASCIIart into the display.
+* paint(display, offset_x, offset_y): paint the entire ASCIIart into a position in the display.
+
+And the config attributes are:
+* bBlock: for to paint blocks instead characters.
+* bColor: ASCIIart in color or not.
+* strResolution: (low, medium, high) the ASCII art resolution.

From 2b7cafcfc91292123414cdb90c5476415c15f8b5 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 1 Nov 2016 20:21:16 +0100
Subject: [PATCH 14/20] Making a new js files.

---
 rot.js     |  28 +++++++++--
 rot.min.js | 144 -----------------------------------------------------
 2 files changed, 24 insertions(+), 148 deletions(-)
 delete mode 100644 rot.min.js

diff --git a/rot.js b/rot.js
index 25259921..aaea5e33 100644
--- a/rot.js
+++ b/rot.js
@@ -1,6 +1,6 @@
 /*
 	This is rot.js, the ROguelike Toolkit in JavaScript.
-	Version 0.7~dev, generated on Tue Aug 30 12:08:59 CEST 2016.
+	Version 0.7~dev, generated on mar nov  1 20:20:43 CET 2016.
 */
 /**
  * @namespace Top-level ROT namespace
@@ -1712,6 +1712,17 @@ ROT.EventQueue.prototype.get = function() {
 	return this._events.splice(0, 1)[0];
 }
 
+/**
+ * Get the time associated with the given event
+ * @param {?} event
+ * @returns {number} time
+ */
+ROT.EventQueue.prototype.getEventTime = function(event) {
+	var index = this._events.indexOf(event);
+	if (index == -1) { return undefined }
+	return this._eventTimes[index];
+}
+
 /**
  * Remove an event from the queue
  * @param {?} event
@@ -1757,6 +1768,15 @@ ROT.Scheduler.prototype.add = function(item, repeat) {
 	return this;
 }
 
+/**
+ * Get the time the given item is scheduled for
+ * @param {?} item
+ * @returns {number} time
+ */
+ROT.Scheduler.prototype.getTimeOf = function(item) {
+	return this._queue.getEventTime(item);
+}
+
 /**
  * Clear all items
  */
@@ -1829,10 +1849,11 @@ ROT.Scheduler.Speed.extend(ROT.Scheduler);
 /**
  * @param {object} item anything with "getSpeed" method
  * @param {bool} repeat
+ * @param {number} [time=1/item.getSpeed()]
  * @see ROT.Scheduler#add
  */
-ROT.Scheduler.Speed.prototype.add = function(item, repeat) {
-	this._queue.add(item, 1/item.getSpeed());
+ROT.Scheduler.Speed.prototype.add = function(item, repeat, time) {
+	this._queue.add(item, time !== undefined ? time : 1/item.getSpeed());
 	return ROT.Scheduler.prototype.add.call(this, item, repeat);
 }
 
@@ -2694,7 +2715,6 @@ ROT.Map.Digger.prototype.create = function(callback) {
 
 ROT.Map.Digger.prototype._digCallback = function(x, y, value) {
 	if (value == 0 || value == 2) { /* empty */
-		if (!this._map[x]) this._map[x]=[];
 		this._map[x][y] = 0;
 		this._dug++;
 	} else { /* wall */
diff --git a/rot.min.js b/rot.min.js
deleted file mode 100644
index 5b853613..00000000
--- a/rot.min.js
+++ /dev/null
@@ -1,144 +0,0 @@
-var ROT={isSupported:function(){return!(!document.createElement("canvas").getContext||!Function.prototype.bind)},DEFAULT_WIDTH:80,DEFAULT_HEIGHT:25,DIRS:{4:[[0,-1],[1,0],[0,1],[-1,0]],8:[[0,-1],[1,-1],[1,0],[1,1],[0,1],[-1,1],[-1,0],[-1,-1]],6:[[-1,-1],[1,-1],[2,0],[1,1],[-1,1],[-2,0]]},VK_CANCEL:3,VK_HELP:6,VK_BACK_SPACE:8,VK_TAB:9,VK_CLEAR:12,VK_RETURN:13,VK_ENTER:14,VK_SHIFT:16,VK_CONTROL:17,VK_ALT:18,VK_PAUSE:19,VK_CAPS_LOCK:20,VK_ESCAPE:27,VK_SPACE:32,VK_PAGE_UP:33,VK_PAGE_DOWN:34,VK_END:35,
-VK_HOME:36,VK_LEFT:37,VK_UP:38,VK_RIGHT:39,VK_DOWN:40,VK_PRINTSCREEN:44,VK_INSERT:45,VK_DELETE:46,VK_0:48,VK_1:49,VK_2:50,VK_3:51,VK_4:52,VK_5:53,VK_6:54,VK_7:55,VK_8:56,VK_9:57,VK_COLON:58,VK_SEMICOLON:59,VK_LESS_THAN:60,VK_EQUALS:61,VK_GREATER_THAN:62,VK_QUESTION_MARK:63,VK_AT:64,VK_A:65,VK_B:66,VK_C:67,VK_D:68,VK_E:69,VK_F:70,VK_G:71,VK_H:72,VK_I:73,VK_J:74,VK_K:75,VK_L:76,VK_M:77,VK_N:78,VK_O:79,VK_P:80,VK_Q:81,VK_R:82,VK_S:83,VK_T:84,VK_U:85,VK_V:86,VK_W:87,VK_X:88,VK_Y:89,VK_Z:90,VK_CONTEXT_MENU:93,
-VK_NUMPAD0:96,VK_NUMPAD1:97,VK_NUMPAD2:98,VK_NUMPAD3:99,VK_NUMPAD4:100,VK_NUMPAD5:101,VK_NUMPAD6:102,VK_NUMPAD7:103,VK_NUMPAD8:104,VK_NUMPAD9:105,VK_MULTIPLY:106,VK_ADD:107,VK_SEPARATOR:108,VK_SUBTRACT:109,VK_DECIMAL:110,VK_DIVIDE:111,VK_F1:112,VK_F2:113,VK_F3:114,VK_F4:115,VK_F5:116,VK_F6:117,VK_F7:118,VK_F8:119,VK_F9:120,VK_F10:121,VK_F11:122,VK_F12:123,VK_F13:124,VK_F14:125,VK_F15:126,VK_F16:127,VK_F17:128,VK_F18:129,VK_F19:130,VK_F20:131,VK_F21:132,VK_F22:133,VK_F23:134,VK_F24:135,VK_NUM_LOCK:144,
-VK_SCROLL_LOCK:145,VK_CIRCUMFLEX:160,VK_EXCLAMATION:161,VK_DOUBLE_QUOTE:162,VK_HASH:163,VK_DOLLAR:164,VK_PERCENT:165,VK_AMPERSAND:166,VK_UNDERSCORE:167,VK_OPEN_PAREN:168,VK_CLOSE_PAREN:169,VK_ASTERISK:170,VK_PLUS:171,VK_PIPE:172,VK_HYPHEN_MINUS:173,VK_OPEN_CURLY_BRACKET:174,VK_CLOSE_CURLY_BRACKET:175,VK_TILDE:176,VK_COMMA:188,VK_PERIOD:190,VK_SLASH:191,VK_BACK_QUOTE:192,VK_OPEN_BRACKET:219,VK_BACK_SLASH:220,VK_CLOSE_BRACKET:221,VK_QUOTE:222,VK_META:224,VK_ALTGR:225,VK_WIN:91,VK_KANA:21,VK_HANGUL:21,
-VK_EISU:22,VK_JUNJA:23,VK_FINAL:24,VK_HANJA:25,VK_KANJI:25,VK_CONVERT:28,VK_NONCONVERT:29,VK_ACCEPT:30,VK_MODECHANGE:31,VK_SELECT:41,VK_PRINT:42,VK_EXECUTE:43,VK_SLEEP:95,Text:{RE_COLORS:/%([bc]){([^}]*)}/g,TYPE_TEXT:0,TYPE_NEWLINE:1,TYPE_FG:2,TYPE_BG:3,measure:function(a,b){for(var c={width:0,height:1},d=this.tokenize(a,b),e=0,f=0;f<d.length;f++){var g=d[f];switch(g.type){case this.TYPE_TEXT:e+=g.value.length;break;case this.TYPE_NEWLINE:c.height++,c.width=Math.max(c.width,e),e=0}}c.width=Math.max(c.width,
-e);return c},tokenize:function(a,b){var c=[],d=0;a.replace(this.RE_COLORS,function(b,e,h,l){var m=a.substring(d,l);m.length&&c.push({type:ROT.Text.TYPE_TEXT,value:m});c.push({type:"c"==e?ROT.Text.TYPE_FG:ROT.Text.TYPE_BG,value:h.trim()});d=l+b.length;return""});var e=a.substring(d);e.length&&c.push({type:ROT.Text.TYPE_TEXT,value:e});return this._breakLines(c,b)},_breakLines:function(a,b){b||(b=Infinity);for(var c=0,d=0,e=-1;c<a.length;){var f=a[c];f.type==ROT.Text.TYPE_NEWLINE&&(d=0,e=-1);if(f.type!=
-ROT.Text.TYPE_TEXT)c++;else{for(;0==d&&" "==f.value.charAt(0);)f.value=f.value.substring(1);var g=f.value.indexOf("\n");if(-1!=g){f.value=this._breakInsideToken(a,c,g,!0);for(g=f.value.split("");g.length&&" "==g[g.length-1];)g.pop();f.value=g.join("")}if(f.value.length){if(d+f.value.length>b){for(g=-1;;){var h=f.value.indexOf(" ",g+1);if(-1==h)break;if(d+h>b)break;g=h}-1!=g?f.value=this._breakInsideToken(a,c,g,!0):-1!=e?(f=a[e],c=f.value.lastIndexOf(" "),f.value=this._breakInsideToken(a,e,c,!0),c=
-e):f.value=this._breakInsideToken(a,c,b-d,!1)}else d+=f.value.length,-1!=f.value.indexOf(" ")&&(e=c);c++}else a.splice(c,1)}}a.push({type:ROT.Text.TYPE_NEWLINE});d=null;for(c=0;c<a.length;c++)switch(f=a[c],f.type){case ROT.Text.TYPE_TEXT:d=f;break;case ROT.Text.TYPE_NEWLINE:if(d){for(g=d.value.split("");g.length&&" "==g[g.length-1];)g.pop();d.value=g.join("")}d=null}a.pop();return a},_breakInsideToken:function(a,b,c,d){var e={type:ROT.Text.TYPE_NEWLINE};d={type:ROT.Text.TYPE_TEXT,value:a[b].value.substring(c+
-(d?1:0))};a.splice(b+1,0,e,d);return a[b].value.substring(0,c)}}};Array.prototype.random=Array.prototype.random||function(){return this.length?this[Math.floor(ROT.RNG.getUniform()*this.length)]:null};Array.prototype.randomize=Array.prototype.randomize||function(){for(var a=[],b=this.slice();b.length;){var c=b.indexOf(b.random());a.push(b.splice(c,1)[0])}return a};Number.prototype.mod=Number.prototype.mod||function(a){return(this%a+a)%a};
-String.prototype.capitalize=String.prototype.capitalize||function(){return this.charAt(0).toUpperCase()+this.substring(1)};String.prototype.lpad=String.prototype.lpad||function(a,b){for(var c=a||"0",d=b||2,e="";e.length<d-this.length;)e+=c;e=e.substring(0,d-this.length);return e+this};String.prototype.rpad=String.prototype.rpad||function(a,b){for(var c=a||"0",d=b||2,e="";e.length<d-this.length;)e+=c;e=e.substring(0,d-this.length);return this+e};
-String.format=String.format||function(a){var b=String.format.map,c=Array.prototype.slice.call(arguments,1);return a.replace(/%(?:([a-z]+)|(?:{([^}]+)}))/gi,function(d,e,f,g){if("%"==a.charAt(g-1))return d.substring(1);if(!c.length)return d;f=(e||f).split(",");e=f.shift();g=b[e.toLowerCase()];if(!g)return d;d=c.shift();d=d[g].apply(d,f);e=e.charAt(0);e!=e.toLowerCase()&&(d=d.capitalize());return d})};String.format.map=String.format.map||{s:"toString"};
-String.prototype.format=String.prototype.format||function(){var a=Array.prototype.slice.call(arguments);a.unshift(this);return String.format.apply(String,a)};Object.create||(Object.create=function(a){var b=function(){};b.prototype=a;return new b});Function.prototype.extend=Function.prototype.extend||function(a){this.prototype=Object.create(a.prototype);this.prototype.constructor=this;return this};
-"undefined"!=typeof window&&(window.requestAnimationFrame=window.requestAnimationFrame||window.mozRequestAnimationFrame||window.webkitRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(a){return setTimeout(a,1E3/60)},window.cancelAnimationFrame=window.cancelAnimationFrame||window.mozCancelAnimationFrame||window.webkitCancelAnimationFrame||window.oCancelAnimationFrame||window.msCancelAnimationFrame||function(a){return clearTimeout(a)});
-ROT.Display=function(a){this._context=document.createElement("canvas").getContext("2d");this._data={};this._dirty=!1;this._options={};this._backend=null;var b={width:ROT.DEFAULT_WIDTH,height:ROT.DEFAULT_HEIGHT,transpose:!1,layout:"rect",fontSize:15,spacing:1,border:0,forceSquareRatio:!1,fontFamily:"monospace",fontStyle:"",fg:"#ccc",bg:"#000",tileWidth:32,tileHeight:32,tileMap:{},tileSet:null,tileColorize:!1,termColor:"xterm"},c;for(c in a)b[c]=a[c];this.setOptions(b);this.DEBUG=this.DEBUG.bind(this);
-this._tick=this._tick.bind(this);requestAnimationFrame(this._tick)};ROT.Display.prototype.DEBUG=function(a,b,c){var d=[this._options.bg,this._options.fg];this.draw(a,b,null,null,d[c%d.length])};ROT.Display.prototype.clear=function(){this._data={};this._dirty=!0};
-ROT.Display.prototype.setOptions=function(a){for(var b in a)this._options[b]=a[b];if(a.width||a.height||a.fontSize||a.fontFamily||a.spacing||a.layout)a.layout&&(this._backend=new (ROT.Display[a.layout.capitalize()])(this._context)),a=(this._options.fontStyle?this._options.fontStyle+" ":"")+this._options.fontSize+"px "+this._options.fontFamily,this._context.font=a,this._backend.compute(this._options),this._context.font=a,this._context.textAlign="center",this._context.textBaseline="middle",this._dirty=
-!0;return this};ROT.Display.prototype.getOptions=function(){return this._options};ROT.Display.prototype.getContainer=function(){return this._context.canvas};ROT.Display.prototype.computeSize=function(a,b){return this._backend.computeSize(a,b,this._options)};ROT.Display.prototype.computeFontSize=function(a,b){return this._backend.computeFontSize(a,b,this._options)};
-ROT.Display.prototype.eventToPosition=function(a){if(a.touches){var b=a.touches[0].clientX;a=a.touches[0].clientY}else b=a.clientX,a=a.clientY;var c=this._context.canvas.getBoundingClientRect(),b=b-c.left;a-=c.top;return 0>b||0>a||b>=this._context.canvas.width||a>=this._context.canvas.height?[-1,-1]:this._backend.eventToPosition(b,a)};
-ROT.Display.prototype.draw=function(a,b,c,d,e){d||(d=this._options.fg);e||(e=this._options.bg);this._data[a+","+b]=[a,b,c,d,e];!0!==this._dirty&&(this._dirty||(this._dirty={}),this._dirty[a+","+b]=!0)};
-ROT.Display.prototype.drawText=function(a,b,c,d){var e=null,f=null,g=a,h=1;d||(d=this._options.width-a);for(c=ROT.Text.tokenize(c,d);c.length;)switch(d=c.shift(),d.type){case ROT.Text.TYPE_TEXT:for(var k=0;k<d.value.length;k++)this.draw(g++,b,d.value.charAt(k),e,f);break;case ROT.Text.TYPE_FG:e=d.value||null;break;case ROT.Text.TYPE_BG:f=d.value||null;break;case ROT.Text.TYPE_NEWLINE:g=a,b++,h++}return h};
-ROT.Display.prototype._tick=function(){requestAnimationFrame(this._tick);if(this._dirty){if(!0===this._dirty){this._context.fillStyle=this._options.bg;this._context.fillRect(0,0,this._context.canvas.width,this._context.canvas.height);for(var a in this._data)this._draw(a,!1)}else for(var b in this._dirty)this._draw(b,!0);this._dirty=!1}};ROT.Display.prototype._draw=function(a,b){var c=this._data[a];c[4]!=this._options.bg&&(b=!0);this._backend.draw(c,b)};
-ROT.Display.Backend=function(a){this._context=a};ROT.Display.Backend.prototype.compute=function(a){};ROT.Display.Backend.prototype.draw=function(a,b){};ROT.Display.Backend.prototype.computeSize=function(a,b){};ROT.Display.Backend.prototype.computeFontSize=function(a,b){};ROT.Display.Backend.prototype.eventToPosition=function(a,b){};ROT.Display.Rect=function(a){ROT.Display.Backend.call(this,a);this._spacingY=this._spacingX=0;this._canvasCache={};this._options={}};ROT.Display.Rect.extend(ROT.Display.Backend);
-ROT.Display.Rect.cache=!1;ROT.Display.Rect.prototype.compute=function(a){this._canvasCache={};this._options=a;var b=Math.ceil(this._context.measureText("W").width);this._spacingX=Math.ceil(a.spacing*b);this._spacingY=Math.ceil(a.spacing*a.fontSize);this._context.canvas.width=a.width*this._spacingX;this._context.canvas.height=a.height*this._spacingY};ROT.Display.Rect.prototype.draw=function(a,b){this.constructor.cache?this._drawWithCache(a,b):this._drawNoCache(a,b)};
-ROT.Display.Rect.prototype._drawWithCache=function(a,b){var c=a[0],d=a[1],e=a[2],f=a[3],g=a[4],h=""+e+f+g;if(h in this._canvasCache)var k=this._canvasCache[h];else{var l=this._options.border,k=document.createElement("canvas"),m=k.getContext("2d");k.width=this._spacingX;k.height=this._spacingY;m.fillStyle=g;m.fillRect(l,l,k.width-l,k.height-l);if(e)for(m.fillStyle=f,m.font=this._context.font,m.textAlign="center",m.textBaseline="middle",e=[].concat(e),f=0;f<e.length;f++)m.fillText(e[f],this._spacingX/
-2,this._spacingY/2);this._canvasCache[h]=k}this._context.drawImage(k,c*this._spacingX,d*this._spacingY)};ROT.Display.Rect.prototype._drawNoCache=function(a,b){var c=a[0],d=a[1],e=a[2],f=a[3],g=a[4];if(b){var h=this._options.border;this._context.fillStyle=g;this._context.fillRect(c*this._spacingX+h,d*this._spacingY+h,this._spacingX-h,this._spacingY-h)}if(e)for(this._context.fillStyle=f,e=[].concat(e),f=0;f<e.length;f++)this._context.fillText(e[f],(c+0.5)*this._spacingX,(d+0.5)*this._spacingY)};
-ROT.Display.Rect.prototype.computeSize=function(a,b){return[Math.floor(a/this._spacingX),Math.floor(b/this._spacingY)]};ROT.Display.Rect.prototype.computeFontSize=function(a,b){var c=Math.floor(a/this._options.width),d=Math.floor(b/this._options.height),e=this._context.font;this._context.font="100px "+this._options.fontFamily;var f=Math.ceil(this._context.measureText("W").width);this._context.font=e;c=f/100*d/c;1<c&&(d=Math.floor(d/c));return Math.floor(d/this._options.spacing)};
-ROT.Display.Rect.prototype.eventToPosition=function(a,b){return[Math.floor(a/this._spacingX),Math.floor(b/this._spacingY)]};ROT.Display.Hex=function(a){ROT.Display.Backend.call(this,a);this._hexSize=this._spacingY=this._spacingX=0;this._options={}};ROT.Display.Hex.extend(ROT.Display.Backend);
-ROT.Display.Hex.prototype.compute=function(a){this._options=a;var b=Math.ceil(this._context.measureText("W").width);this._hexSize=Math.floor(a.spacing*(a.fontSize+b/Math.sqrt(3))/2);this._spacingX=this._hexSize*Math.sqrt(3)/2;this._spacingY=1.5*this._hexSize;this._context.canvas.width=Math.ceil((a.width+1)*this._spacingX);this._context.canvas.height=Math.ceil((a.height-1)*this._spacingY+2*this._hexSize)};
-ROT.Display.Hex.prototype.draw=function(a,b){var c=a[2],d=a[3],e=a[4],f=(a[0]+1)*this._spacingX,g=a[1]*this._spacingY+this._hexSize;b&&(this._context.fillStyle=e,this._fill(f,g));if(c)for(this._context.fillStyle=d,c=[].concat(c),d=0;d<c.length;d++)this._context.fillText(c[d],f,g)};ROT.Display.Hex.prototype.computeSize=function(a,b){return[Math.floor(a/this._spacingX)-1,Math.floor((b-2*this._hexSize)/this._spacingY+1)]};
-ROT.Display.Hex.prototype.computeFontSize=function(a,b){var c=2*a/((this._options.width+1)*Math.sqrt(3))-1,c=Math.min(c,b/(2+1.5*(this._options.height-1))),d=this._context.font;this._context.font="100px "+this._options.fontFamily;var e=Math.ceil(this._context.measureText("W").width);this._context.font=d;c=Math.floor(c)+1;c=2*c/(this._options.spacing*(1+e/100/Math.sqrt(3)));return Math.ceil(c)-1};
-ROT.Display.Hex.prototype.eventToPosition=function(a,b){b=Math.floor(b/(this._context.canvas.height/this._options.height));b.mod(2)?(a-=this._spacingX,a=1+2*Math.floor(a/(2*this._spacingX))):a=2*Math.floor(a/(2*this._spacingX));return[a,b]};
-ROT.Display.Hex.prototype._fill=function(a,b){var c=this._hexSize,d=this._options.border;this._context.beginPath();this._context.moveTo(a,b-c+d);this._context.lineTo(a+this._spacingX-d,b-c/2+d);this._context.lineTo(a+this._spacingX-d,b+c/2-d);this._context.lineTo(a,b+c-d);this._context.lineTo(a-this._spacingX+d,b+c/2-d);this._context.lineTo(a-this._spacingX+d,b-c/2+d);this._context.lineTo(a,b-c+d);this._context.fill()};ROT.Display.Tile=function(a){ROT.Display.Rect.call(this,a);this._options={}};ROT.Display.Tile.extend(ROT.Display.Rect);
-ROT.Display.Tile.prototype.compute=function(a){this._options=a;this._context.canvas.width=a.width*a.tileWidth;this._context.canvas.height=a.height*a.tileHeight};
-ROT.Display.Tile.prototype.draw=function(a,b){var c=a[0],d=a[1],e=a[2],f=a[4],g=this._options.tileWidth,h=this._options.tileHeight;b&&(this._context.fillStyle=f,this._context.fillRect(c*g,d*h,g,h));if(e)for(e=[].concat(e),f=0;f<e.length;f++){var k=this._options.tileMap[e[f]];if(!k)throw Error("Char '"+e[f]+"' not found in tileMap");this._context.drawImage(this._options.tileSet,k[0],k[1],g,h,c*g,d*h,g,h)}};
-ROT.Display.Tile.prototype.computeSize=function(a,b){return[Math.floor(a/this._options.tileWidth),Math.floor(b/this._options.tileHeight)]};ROT.Display.Tile.prototype.computeFontSize=function(a,b){return[Math.floor(a/this._options.width),Math.floor(b/this._options.height)]};
-ROT.RNG={getSeed:function(){return this._seed},setSeed:function(a){this._seed=a=1>a?1/a:a;this._s0=(a>>>0)*this._frac;a=69069*a+1>>>0;this._s1=a*this._frac;this._s2=(69069*a+1>>>0)*this._frac;this._c=1;return this},getUniform:function(){var a=2091639*this._s0+this._c*this._frac;this._s0=this._s1;this._s1=this._s2;this._c=a|0;return this._s2=a-this._c},getUniformInt:function(a,b){var c=Math.max(a,b),d=Math.min(a,b);return Math.floor(this.getUniform()*(c-d+1))+d},getNormal:function(a,b){do var c=2*
-this.getUniform()-1,d=2*this.getUniform()-1,d=c*c+d*d;while(1<d||0==d);c*=Math.sqrt(-2*Math.log(d)/d);return(a||0)+c*(b||1)},getPercentage:function(){return 1+Math.floor(100*this.getUniform())},getWeightedValue:function(a){var b=0,c;for(c in a)b+=a[c];var b=Math.floor(this.getUniform()*b),d=0;for(c in a)if(d+=a[c],b<d)return c;return null},getState:function(){return[this._s0,this._s1,this._s2,this._c]},setState:function(a){this._s0=a[0];this._s1=a[1];this._s2=a[2];this._c=a[3];return this},_s0:0,
-_s1:0,_s2:0,_c:0,_frac:2.3283064365386963E-10};ROT.RNG.setSeed(Date.now());ROT.StringGenerator=function(a){this._options={words:!1,order:3,prior:0.001};for(var b in a)this._options[b]=a[b];this._suffix=this._boundary=String.fromCharCode(0);this._prefix=[];for(a=0;a<this._options.order;a++)this._prefix.push(this._boundary);this._priorValues={};this._priorValues[this._boundary]=this._options.prior;this._data={}};ROT.StringGenerator.prototype.clear=function(){this._data={};this._priorValues={}};
-ROT.StringGenerator.prototype.generate=function(){for(var a=[this._sample(this._prefix)];a[a.length-1]!=this._boundary;)a.push(this._sample(a));return this._join(a.slice(0,-1))};
-ROT.StringGenerator.prototype.observe=function(a){a=this._split(a);for(var b=0;b<a.length;b++)this._priorValues[a[b]]=this._options.prior;a=this._prefix.concat(a).concat(this._suffix);for(b=this._options.order;b<a.length;b++)for(var c=a.slice(b-this._options.order,b),d=a[b],e=0;e<c.length;e++){var f=c.slice(e);this._observeEvent(f,d)}};
-ROT.StringGenerator.prototype.getStats=function(){var a=[],b=0,c;for(c in this._priorValues)b++;b--;a.push("distinct samples: "+b);var d=b=0;for(c in this._data){b++;for(var e in this._data[c])d++}a.push("dictionary size (contexts): "+b);a.push("dictionary size (events): "+d);return a.join(", ")};ROT.StringGenerator.prototype._split=function(a){return a.split(this._options.words?/\s+/:"")};ROT.StringGenerator.prototype._join=function(a){return a.join(this._options.words?" ":"")};
-ROT.StringGenerator.prototype._observeEvent=function(a,b){var c=this._join(a);c in this._data||(this._data[c]={});c=this._data[c];b in c||(c[b]=0);c[b]++};ROT.StringGenerator.prototype._sample=function(a){a=this._backoff(a);a=this._join(a);a=this._data[a];var b={};if(this._options.prior){for(var c in this._priorValues)b[c]=this._priorValues[c];for(c in a)b[c]+=a[c]}else b=a;return this._pickRandom(b)};
-ROT.StringGenerator.prototype._backoff=function(a){for(a.length>this._options.order?a=a.slice(-this._options.order):a.length<this._options.order&&(a=this._prefix.slice(0,this._options.order-a.length).concat(a));!(this._join(a)in this._data)&&0<a.length;)a=a.slice(1);return a};ROT.StringGenerator.prototype._pickRandom=function(a){var b=0,c;for(c in a)b+=a[c];var b=ROT.RNG.getUniform()*b,d=0;for(c in a)if(d+=a[c],b<d)return c};
-ROT.EventQueue=function(){this._time=0;this._events=[];this._eventTimes=[]};ROT.EventQueue.prototype.getTime=function(){return this._time};ROT.EventQueue.prototype.clear=function(){this._events=[];this._eventTimes=[];return this};ROT.EventQueue.prototype.add=function(a,b){for(var c=this._events.length,d=0;d<this._eventTimes.length;d++)if(this._eventTimes[d]>b){c=d;break}this._events.splice(c,0,a);this._eventTimes.splice(c,0,b)};
-ROT.EventQueue.prototype.get=function(){if(!this._events.length)return null;var a=this._eventTimes.splice(0,1)[0];if(0<a){this._time+=a;for(var b=0;b<this._eventTimes.length;b++)this._eventTimes[b]-=a}return this._events.splice(0,1)[0]};ROT.EventQueue.prototype.remove=function(a){a=this._events.indexOf(a);if(-1==a)return!1;this._remove(a);return!0};ROT.EventQueue.prototype._remove=function(a){this._events.splice(a,1);this._eventTimes.splice(a,1)};
-ROT.Scheduler=function(){this._queue=new ROT.EventQueue;this._repeat=[];this._current=null};ROT.Scheduler.prototype.getTime=function(){return this._queue.getTime()};ROT.Scheduler.prototype.add=function(a,b){b&&this._repeat.push(a);return this};ROT.Scheduler.prototype.clear=function(){this._queue.clear();this._repeat=[];this._current=null;return this};
-ROT.Scheduler.prototype.remove=function(a){var b=this._queue.remove(a),c=this._repeat.indexOf(a);-1!=c&&this._repeat.splice(c,1);this._current==a&&(this._current=null);return b};ROT.Scheduler.prototype.next=function(){return this._current=this._queue.get()};ROT.Scheduler.Simple=function(){ROT.Scheduler.call(this)};ROT.Scheduler.Simple.extend(ROT.Scheduler);ROT.Scheduler.Simple.prototype.add=function(a,b){this._queue.add(a,0);return ROT.Scheduler.prototype.add.call(this,a,b)};
-ROT.Scheduler.Simple.prototype.next=function(){this._current&&-1!=this._repeat.indexOf(this._current)&&this._queue.add(this._current,0);return ROT.Scheduler.prototype.next.call(this)};ROT.Scheduler.Speed=function(){ROT.Scheduler.call(this)};ROT.Scheduler.Speed.extend(ROT.Scheduler);ROT.Scheduler.Speed.prototype.add=function(a,b){this._queue.add(a,1/a.getSpeed());return ROT.Scheduler.prototype.add.call(this,a,b)};
-ROT.Scheduler.Speed.prototype.next=function(){this._current&&-1!=this._repeat.indexOf(this._current)&&this._queue.add(this._current,1/this._current.getSpeed());return ROT.Scheduler.prototype.next.call(this)};ROT.Scheduler.Action=function(){ROT.Scheduler.call(this);this._duration=this._defaultDuration=1};ROT.Scheduler.Action.extend(ROT.Scheduler);ROT.Scheduler.Action.prototype.add=function(a,b,c){this._queue.add(a,c||this._defaultDuration);return ROT.Scheduler.prototype.add.call(this,a,b)};
-ROT.Scheduler.Action.prototype.clear=function(){this._duration=this._defaultDuration;return ROT.Scheduler.prototype.clear.call(this)};ROT.Scheduler.Action.prototype.remove=function(a){a==this._current&&(this._duration=this._defaultDuration);return ROT.Scheduler.prototype.remove.call(this,a)};
-ROT.Scheduler.Action.prototype.next=function(){this._current&&-1!=this._repeat.indexOf(this._current)&&(this._queue.add(this._current,this._duration||this._defaultDuration),this._duration=this._defaultDuration);return ROT.Scheduler.prototype.next.call(this)};ROT.Scheduler.Action.prototype.setDuration=function(a){this._current&&(this._duration=a);return this};ROT.Engine=function(a){this._scheduler=a;this._lock=1};ROT.Engine.prototype.start=function(){return this.unlock()};
-ROT.Engine.prototype.lock=function(){this._lock++;return this};ROT.Engine.prototype.unlock=function(){if(!this._lock)throw Error("Cannot unlock unlocked engine");for(this._lock--;!this._lock;){var a=this._scheduler.next();if(!a)return this.lock();(a=a.act())&&a.then&&(this.lock(),a.then(this.unlock.bind(this)))}return this};ROT.Map=function(a,b){this._width=a||ROT.DEFAULT_WIDTH;this._height=b||ROT.DEFAULT_HEIGHT};ROT.Map.prototype.create=function(a){};
-ROT.Map.prototype._fillMap=function(a){for(var b=[],c=0;c<this._width;c++){b.push([]);for(var d=0;d<this._height;d++)b[c].push(a)}return b};ROT.Map.Arena=function(a,b){ROT.Map.call(this,a,b)};ROT.Map.Arena.extend(ROT.Map);ROT.Map.Arena.prototype.create=function(a){for(var b=this._width-1,c=this._height-1,d=0;d<=b;d++)for(var e=0;e<=c;e++)a(d,e,d&&e&&d<b&&e<c?0:1);return this};ROT.Map.DividedMaze=function(a,b){ROT.Map.call(this,a,b);this._stack=[]};ROT.Map.DividedMaze.extend(ROT.Map);
-ROT.Map.DividedMaze.prototype.create=function(a){var b=this._width,c=this._height;this._map=[];for(var d=0;d<b;d++){this._map.push([]);for(var e=0;e<c;e++)this._map[d].push(0==d||0==e||d+1==b||e+1==c?1:0)}this._stack=[[1,1,b-2,c-2]];this._process();for(d=0;d<b;d++)for(e=0;e<c;e++)a(d,e,this._map[d][e]);this._map=null;return this};ROT.Map.DividedMaze.prototype._process=function(){for(;this._stack.length;){var a=this._stack.shift();this._partitionRoom(a)}};
-ROT.Map.DividedMaze.prototype._partitionRoom=function(a){for(var b=[],c=[],d=a[0]+1;d<a[2];d++){var e=this._map[d][a[3]+1];!this._map[d][a[1]-1]||!e||d%2||b.push(d)}for(d=a[1]+1;d<a[3];d++)e=this._map[a[2]+1][d],!this._map[a[0]-1][d]||!e||d%2||c.push(d);if(b.length&&c.length){b=b.random();c=c.random();this._map[b][c]=1;var e=[],f=[];e.push(f);for(d=a[0];d<b;d++)this._map[d][c]=1,f.push([d,c]);f=[];e.push(f);for(d=b+1;d<=a[2];d++)this._map[d][c]=1,f.push([d,c]);f=[];e.push(f);for(d=a[1];d<c;d++)this._map[b][d]=
-1,f.push([b,d]);f=[];e.push(f);for(d=c+1;d<=a[3];d++)this._map[b][d]=1,f.push([b,d]);for(var g=e.random(),d=0;d<e.length;d++)f=e[d],f!=g&&(f=f.random(),this._map[f[0]][f[1]]=0);this._stack.push([a[0],a[1],b-1,c-1]);this._stack.push([b+1,a[1],a[2],c-1]);this._stack.push([a[0],c+1,b-1,a[3]]);this._stack.push([b+1,c+1,a[2],a[3]])}};ROT.Map.IceyMaze=function(a,b,c){ROT.Map.call(this,a,b);this._regularity=c||0};ROT.Map.IceyMaze.extend(ROT.Map);
-ROT.Map.IceyMaze.prototype.create=function(a){var b=this._width,c=this._height,d=this._fillMap(1),b=b-(b%2?1:2),c=c-(c%2?1:2),e=0,f=0,g=0,h=0,k=0,l=!1,m=[[0,0],[0,0],[0,0],[0,0]];do if(e=1+2*Math.floor(ROT.RNG.getUniform()*(b-1)/2),f=1+2*Math.floor(ROT.RNG.getUniform()*(c-1)/2),k||(d[e][f]=0),!d[e][f]){this._randomize(m);do{0==Math.floor(ROT.RNG.getUniform()*(this._regularity+1))&&this._randomize(m);for(var l=!0,p=0;4>p;p++)if(g=e+2*m[p][0],h=f+2*m[p][1],this._isFree(d,g,h,b,c)){d[g][h]=0;d[e+m[p][0]][f+
-m[p][1]]=0;e=g;f=h;l=!1;k++;break}}while(!l)}while(k+1<b*c/4);for(p=0;p<this._width;p++)for(b=0;b<this._height;b++)a(p,b,d[p][b]);this._map=null;return this};
-ROT.Map.IceyMaze.prototype._randomize=function(a){for(var b=0;4>b;b++)a[b][0]=0,a[b][1]=0;switch(Math.floor(4*ROT.RNG.getUniform())){case 0:a[0][0]=-1;a[1][0]=1;a[2][1]=-1;a[3][1]=1;break;case 1:a[3][0]=-1;a[2][0]=1;a[1][1]=-1;a[0][1]=1;break;case 2:a[2][0]=-1;a[3][0]=1;a[0][1]=-1;a[1][1]=1;break;case 3:a[1][0]=-1,a[0][0]=1,a[3][1]=-1,a[2][1]=1}};ROT.Map.IceyMaze.prototype._isFree=function(a,b,c,d,e){return 1>b||1>c||b>=d||c>=e?!1:a[b][c]};ROT.Map.EllerMaze=function(a,b){ROT.Map.call(this,a,b)};ROT.Map.EllerMaze.extend(ROT.Map);
-ROT.Map.EllerMaze.prototype.create=function(a){for(var b=this._fillMap(1),c=Math.ceil((this._width-2)/2),d=[],e=[],f=0;f<c;f++)d.push(f),e.push(f);d.push(c-1);for(var g=1;g+3<this._height;g+=2)for(f=0;f<c;f++){var h=2*f+1,k=g;b[h][k]=0;f!=d[f+1]&&0.375<ROT.RNG.getUniform()&&(this._addToList(f,d,e),b[h+1][k]=0);f!=d[f]&&0.375<ROT.RNG.getUniform()?this._removeFromList(f,d,e):b[h][k+1]=0}for(f=0;f<c;f++)h=2*f+1,k=g,b[h][k]=0,f!=d[f+1]&&(f==d[f]||0.375<ROT.RNG.getUniform())&&(this._addToList(f,d,e),b[h+
-1][k]=0),this._removeFromList(f,d,e);for(f=0;f<this._width;f++)for(g=0;g<this._height;g++)a(f,g,b[f][g]);return this};ROT.Map.EllerMaze.prototype._removeFromList=function(a,b,c){c[b[a]]=c[a];b[c[a]]=b[a];c[a]=a;b[a]=a};ROT.Map.EllerMaze.prototype._addToList=function(a,b,c){c[b[a+1]]=c[a];b[c[a]]=b[a+1];c[a]=a+1;b[a+1]=a};
-ROT.Map.Cellular=function(a,b,c){ROT.Map.call(this,a,b);this._options={born:[5,6,7,8],survive:[4,5,6,7,8],topology:8};this.setOptions(c);this._dirs=ROT.DIRS[this._options.topology];this._map=this._fillMap(0)};ROT.Map.Cellular.extend(ROT.Map);ROT.Map.Cellular.prototype.randomize=function(a){for(var b=0;b<this._width;b++)for(var c=0;c<this._height;c++)this._map[b][c]=ROT.RNG.getUniform()<a?1:0;return this};ROT.Map.Cellular.prototype.setOptions=function(a){for(var b in a)this._options[b]=a[b]};
-ROT.Map.Cellular.prototype.set=function(a,b,c){this._map[a][b]=c};ROT.Map.Cellular.prototype.create=function(a){for(var b=this._fillMap(0),c=this._options.born,d=this._options.survive,e=0;e<this._height;e++){var f=1,g=0;6==this._options.topology&&(f=2,g=e%2);for(;g<this._width;g+=f){var h=this._map[g][e],k=this._getNeighbors(g,e);h&&-1!=d.indexOf(k)?b[g][e]=1:h||-1==c.indexOf(k)||(b[g][e]=1);a&&a(g,e,b[g][e])}}this._map=b};
-ROT.Map.Cellular.prototype._getNeighbors=function(a,b){for(var c=0,d=0;d<this._dirs.length;d++){var e=this._dirs[d],f=a+e[0],e=b+e[1];0>f||f>=this._width||0>f||e>=this._width||(c+=1==this._map[f][e]?1:0)}return c};ROT.Map.Dungeon=function(a,b){ROT.Map.call(this,a,b);this._rooms=[];this._corridors=[]};ROT.Map.Dungeon.extend(ROT.Map);ROT.Map.Dungeon.prototype.getRooms=function(){return this._rooms};ROT.Map.Dungeon.prototype.getCorridors=function(){return this._corridors};
-ROT.Map.Digger=function(a,b,c){ROT.Map.Dungeon.call(this,a,b);this._options={roomWidth:[3,9],roomHeight:[3,5],corridorLength:[3,10],dugPercentage:0.2,timeLimit:1E3};for(var d in c)this._options[d]=c[d];this._features={Room:4,Corridor:4};this._featureAttempts=20;this._walls={};this._digCallback=this._digCallback.bind(this);this._canBeDugCallback=this._canBeDugCallback.bind(this);this._isWallCallback=this._isWallCallback.bind(this);this._priorityWallCallback=this._priorityWallCallback.bind(this)};ROT.Map.Digger.extend(ROT.Map.Dungeon);
-ROT.Map.Digger.prototype.create=function(a){this._rooms=[];this._corridors=[];this._map=this._fillMap(1);this._walls={};this._dug=0;var b=(this._width-2)*(this._height-2);this._firstRoom();var c=Date.now();do{if(Date.now()-c>this._options.timeLimit)break;var d=this._findWall();if(!d)break;var e=d.split(","),d=parseInt(e[0]),e=parseInt(e[1]),f=this._getDiggingDirection(d,e);if(f){var g=0;do if(g++,this._tryFeature(d,e,f[0],f[1])){this._removeSurroundingWalls(d,e);this._removeSurroundingWalls(d-f[0],
-e-f[1]);break}while(g<this._featureAttempts);var g=0,h;for(h in this._walls)1<this._walls[h]&&g++}}while(this._dug/b<this._options.dugPercentage||g);this._addDoors();if(a)for(b=0;b<this._width;b++)for(c=0;c<this._height;c++)a(b,c,this._map[b][c]);this._walls={};this._map=null;return this};ROT.Map.Digger.prototype._digCallback=function(a,b,c){0==c||2==c?(this._map[a][b]=0,this._dug++):this._walls[a+","+b]=1};
-ROT.Map.Digger.prototype._isWallCallback=function(a,b){return 0>a||0>b||a>=this._width||b>=this._height?!1:1==this._map[a][b]};ROT.Map.Digger.prototype._canBeDugCallback=function(a,b){return 1>a||1>b||a+1>=this._width||b+1>=this._height?!1:1==this._map[a][b]};ROT.Map.Digger.prototype._priorityWallCallback=function(a,b){this._walls[a+","+b]=2};
-ROT.Map.Digger.prototype._firstRoom=function(){var a=ROT.Map.Feature.Room.createRandomCenter(Math.floor(this._width/2),Math.floor(this._height/2),this._options);this._rooms.push(a);a.create(this._digCallback)};ROT.Map.Digger.prototype._findWall=function(){var a=[],b=[],c;for(c in this._walls)2==this._walls[c]?b.push(c):a.push(c);a=b.length?b:a;if(!a.length)return null;c=a.random();delete this._walls[c];return c};
-ROT.Map.Digger.prototype._tryFeature=function(a,b,c,d){var e=ROT.RNG.getWeightedValue(this._features),e=ROT.Map.Feature[e].createRandomAt(a,b,c,d,this._options);if(!e.isValid(this._isWallCallback,this._canBeDugCallback))return!1;e.create(this._digCallback);e instanceof ROT.Map.Feature.Room&&this._rooms.push(e);e instanceof ROT.Map.Feature.Corridor&&(e.createPriorityWalls(this._priorityWallCallback),this._corridors.push(e));return!0};
-ROT.Map.Digger.prototype._removeSurroundingWalls=function(a,b){for(var c=ROT.DIRS[4],d=0;d<c.length;d++){var e=c[d],f=a+e[0],g=b+e[1];delete this._walls[f+","+g];f=a+2*e[0];g=b+2*e[1];delete this._walls[f+","+g]}};ROT.Map.Digger.prototype._getDiggingDirection=function(a,b){for(var c=null,d=ROT.DIRS[4],e=0;e<d.length;e++){var f=d[e],g=a+f[0],h=b+f[1];if(0>g||0>h||g>=this._width||h>=this._width)return null;if(!this._map[g][h]){if(c)return null;c=f}}return c?[-c[0],-c[1]]:null};
-ROT.Map.Digger.prototype._addDoors=function(){for(var a=this._map,b=function(b,c){return 1==a[b][c]},c=0;c<this._rooms.length;c++){var d=this._rooms[c];d.clearDoors();d.addDoors(b)}};
-ROT.Map.Uniform=function(a,b,c){ROT.Map.Dungeon.call(this,a,b);this._options={roomWidth:[3,9],roomHeight:[3,5],roomDugPercentage:0.1,timeLimit:1E3};for(var d in c)this._options[d]=c[d];this._corridorAttempts=this._roomAttempts=20;this._connected=[];this._unconnected=[];this._digCallback=this._digCallback.bind(this);this._canBeDugCallback=this._canBeDugCallback.bind(this);this._isWallCallback=this._isWallCallback.bind(this)};ROT.Map.Uniform.extend(ROT.Map.Dungeon);
-ROT.Map.Uniform.prototype.create=function(a){for(var b=Date.now();;){if(Date.now()-b>this._options.timeLimit)return null;this._map=this._fillMap(1);this._dug=0;this._rooms=[];this._unconnected=[];this._generateRooms();if(!(2>this._rooms.length)&&this._generateCorridors())break}if(a)for(b=0;b<this._width;b++)for(var c=0;c<this._height;c++)a(b,c,this._map[b][c]);return this};
-ROT.Map.Uniform.prototype._generateRooms=function(){var a=this._width-2,b=this._height-2;do{var c=this._generateRoom();if(this._dug/(a*b)>this._options.roomDugPercentage)break}while(c)};ROT.Map.Uniform.prototype._generateRoom=function(){for(var a=0;a<this._roomAttempts;){a++;var b=ROT.Map.Feature.Room.createRandom(this._width,this._height,this._options);if(b.isValid(this._isWallCallback,this._canBeDugCallback))return b.create(this._digCallback),this._rooms.push(b),b}return null};
-ROT.Map.Uniform.prototype._generateCorridors=function(){for(var a=0;a<this._corridorAttempts;){a++;this._corridors=[];this._map=this._fillMap(1);for(var b=0;b<this._rooms.length;b++){var c=this._rooms[b];c.clearDoors();c.create(this._digCallback)}this._unconnected=this._rooms.slice().randomize();this._connected=[];for(this._unconnected.length&&this._connected.push(this._unconnected.pop());;){b=this._connected.random();b=this._closestRoom(this._unconnected,b);c=this._closestRoom(this._connected,b);
-if(!this._connectRooms(b,c))break;if(!this._unconnected.length)return!0}}return!1};ROT.Map.Uniform.prototype._closestRoom=function(a,b){for(var c=Infinity,d=b.getCenter(),e=null,f=0;f<a.length;f++){var g=a[f],h=g.getCenter(),k=h[0]-d[0],h=h[1]-d[1],k=k*k+h*h;k<c&&(c=k,e=g)}return e};
-ROT.Map.Uniform.prototype._connectRooms=function(a,b){var c=a.getCenter(),d=b.getCenter(),e=d[0]-c[0],c=d[1]-c[1];if(Math.abs(e)<Math.abs(c))var c=0<c?2:0,f=(c+2)%4,g=b.getLeft(),h=b.getRight(),e=0;else c=0<e?1:3,f=(c+2)%4,g=b.getTop(),h=b.getBottom(),e=1;c=this._placeInWall(a,c);if(!c)return!1;if(c[e]>=g&&c[e]<=h){var k=c.slice(),d=null;switch(f){case 0:d=b.getTop()-1;break;case 1:d=b.getRight()+1;break;case 2:d=b.getBottom()+1;break;case 3:d=b.getLeft()-1}k[(e+1)%2]=d;this._digLine([c,k])}else if(c[e]<
-g-1||c[e]>h+1){d=c[e]-d[e];switch(f){case 0:case 1:k=0>d?3:1;break;case 2:case 3:k=0>d?1:3}k=this._placeInWall(b,(f+k)%4);if(!k)return!1;f=[0,0];f[e]=c[e];d=(e+1)%2;f[d]=k[d];this._digLine([c,f,k])}else{d=(e+1)%2;k=this._placeInWall(b,f);if(!k)return;f=Math.round((k[d]+c[d])/2);g=[0,0];h=[0,0];g[e]=c[e];g[d]=f;h[e]=k[e];h[d]=f;this._digLine([c,g,h,k])}a.addDoor(c[0],c[1]);b.addDoor(k[0],k[1]);e=this._unconnected.indexOf(a);-1!=e&&(this._unconnected.splice(e,1),this._connected.push(a));e=this._unconnected.indexOf(b);
--1!=e&&(this._unconnected.splice(e,1),this._connected.push(b));return!0};
-ROT.Map.Uniform.prototype._placeInWall=function(a,b){var c=[0,0],d=[0,0],e=0;switch(b){case 0:d=[1,0];c=[a.getLeft(),a.getTop()-1];e=a.getRight()-a.getLeft()+1;break;case 1:d=[0,1];c=[a.getRight()+1,a.getTop()];e=a.getBottom()-a.getTop()+1;break;case 2:d=[1,0];c=[a.getLeft(),a.getBottom()+1];e=a.getRight()-a.getLeft()+1;break;case 3:d=[0,1],c=[a.getLeft()-1,a.getTop()],e=a.getBottom()-a.getTop()+1}for(var f=[],g=-2,h=0;h<e;h++){var k=c[0]+h*d[0],l=c[1]+h*d[1];f.push(null);1==this._map[k][l]?g!=h-
-1&&(f[h]=[k,l]):(g=h)&&(f[h-1]=null)}for(h=f.length-1;0<=h;h--)f[h]||f.splice(h,1);return f.length?f.random():null};ROT.Map.Uniform.prototype._digLine=function(a){for(var b=1;b<a.length;b++){var c=a[b-1],d=a[b],c=new ROT.Map.Feature.Corridor(c[0],c[1],d[0],d[1]);c.create(this._digCallback);this._corridors.push(c)}};ROT.Map.Uniform.prototype._digCallback=function(a,b,c){this._map[a][b]=c;0==c&&this._dug++};
-ROT.Map.Uniform.prototype._isWallCallback=function(a,b){return 0>a||0>b||a>=this._width||b>=this._height?!1:1==this._map[a][b]};ROT.Map.Uniform.prototype._canBeDugCallback=function(a,b){return 1>a||1>b||a+1>=this._width||b+1>=this._height?!1:1==this._map[a][b]};
-ROT.Map.Rogue=function(a,b,c){ROT.Map.call(this,a,b);this._options={cellWidth:3,cellHeight:3};for(var d in c)this._options[d]=c[d];this._options.hasOwnProperty("roomWidth")||(this._options.roomWidth=this._calculateRoomSize(a,this._options.cellWidth));this._options.hasOwnProperty.roomHeight||(this._options.roomHeight=this._calculateRoomSize(b,this._options.cellHeight))};ROT.Map.Rogue.extend(ROT.Map);
-ROT.Map.Rogue.prototype.create=function(a){this.map=this._fillMap(1);this.rooms=[];this.connectedCells=[];this._initRooms();this._connectRooms();this._connectUnconnectedRooms();this._createRandomRoomConnections();this._createRooms();this._createCorridors();if(a)for(var b=0;b<this._width;b++)for(var c=0;c<this._height;c++)a(b,c,this.map[b][c]);return this};ROT.Map.Rogue.prototype._getRandomInt=function(a,b){return Math.floor(ROT.RNG.getUniform()*(b-a+1))+a};
-ROT.Map.Rogue.prototype._calculateRoomSize=function(a,b){var c=Math.floor(a/b*0.8),d=Math.floor(a/b*0.25);2>d&&(d=2);2>c&&(c=2);return[d,c]};ROT.Map.Rogue.prototype._initRooms=function(){for(var a=0;a<this._options.cellWidth;a++){this.rooms.push([]);for(var b=0;b<this._options.cellHeight;b++)this.rooms[a].push({x:0,y:0,width:0,height:0,connections:[],cellx:a,celly:b})}};
-ROT.Map.Rogue.prototype._connectRooms=function(){var a=this._getRandomInt(0,this._options.cellWidth-1),b=this._getRandomInt(0,this._options.cellHeight-1),c,d,e=!1,f;do{var g=[0,2,4,6],g=g.randomize();do if(e=!1,c=g.pop(),d=a+ROT.DIRS[8][c][0],c=b+ROT.DIRS[8][c][1],!(0>d||d>=this._options.cellWidth||0>c||c>=this._options.cellHeight)){f=this.rooms[a][b];if(0<f.connections.length&&f.connections[0][0]==d&&f.connections[0][1]==c)break;f=this.rooms[d][c];0==f.connections.length&&(f.connections.push([a,
-b]),this.connectedCells.push([d,c]),a=d,b=c,e=!0)}while(0<g.length&&!1==e)}while(0<g.length)};
-ROT.Map.Rogue.prototype._connectUnconnectedRooms=function(){var a=this._options.cellWidth,b=this._options.cellHeight;this.connectedCells=this.connectedCells.randomize();for(var c,d,e,f=0;f<this._options.cellWidth;f++)for(var g=0;g<this._options.cellHeight;g++)if(c=this.rooms[f][g],0==c.connections.length){var h=[0,2,4,6],h=h.randomize();e=!1;do{var k=h.pop(),l=f+ROT.DIRS[8][k][0],k=g+ROT.DIRS[8][k][1];if(!(0>l||l>=a||0>k||k>=b)){d=this.rooms[l][k];e=!0;if(0==d.connections.length)break;for(l=0;l<d.connections.length;l++)if(d.connections[l][0]==
-f&&d.connections[l][1]==g){e=!1;break}if(e)break}}while(h.length);e?c.connections.push([d.cellx,d.celly]):console.log("-- Unable to connect room.")}};ROT.Map.Rogue.prototype._createRandomRoomConnections=function(a){};
-ROT.Map.Rogue.prototype._createRooms=function(){for(var a=this._width,b=this._height,c=this._options.cellWidth,d=this._options.cellHeight,e=Math.floor(this._width/c),f=Math.floor(this._height/d),g,h,k=this._options.roomWidth,l=this._options.roomHeight,m,p,n,q=0;q<c;q++)for(var r=0;r<d;r++){m=e*q;p=f*r;0==m&&(m=1);0==p&&(p=1);g=this._getRandomInt(k[0],k[1]);h=this._getRandomInt(l[0],l[1]);if(0<r)for(n=this.rooms[q][r-1];3>p-(n.y+n.height);)p++;if(0<q)for(n=this.rooms[q-1][r];3>m-(n.x+n.width);)m++;
-n=Math.round(this._getRandomInt(0,e-g)/2);for(var s=Math.round(this._getRandomInt(0,f-h)/2);m+n+g>=a;)n?n--:g--;for(;p+s+h>=b;)s?s--:h--;m+=n;p+=s;this.rooms[q][r].x=m;this.rooms[q][r].y=p;this.rooms[q][r].width=g;this.rooms[q][r].height=h;for(n=m;n<m+g;n++)for(s=p;s<p+h;s++)this.map[n][s]=0}};
-ROT.Map.Rogue.prototype._getWallPosition=function(a,b){var c,d,e;if(1==b||3==b)c=this._getRandomInt(a.x+1,a.x+a.width-2),1==b?(d=a.y-2,e=d+1):(d=a.y+a.height+1,e=d-1),this.map[c][e]=0;else if(2==b||4==b)d=this._getRandomInt(a.y+1,a.y+a.height-2),2==b?(c=a.x+a.width+1,e=c-1):(c=a.x-2,e=c+1),this.map[e][d]=0;return[c,d]};
-ROT.Map.Rogue.prototype._drawCorridore=function(a,b){var c=b[0]-a[0],d=b[1]-a[1],e=a[0],f=a[1],g,h,k=[];h=Math.abs(c);var l=Math.abs(d);g=ROT.RNG.getUniform();var m=1-g,c=0<c?2:6,d=0<d?4:0;h<l?(g=Math.ceil(l*g),k.push([d,g]),k.push([c,h]),g=Math.floor(l*m),k.push([d,g])):(g=Math.ceil(h*g),k.push([c,g]),k.push([d,l]),g=Math.floor(h*m),k.push([c,g]));for(this.map[e][f]=0;0<k.length;)for(h=k.pop();0<h[1];)e+=ROT.DIRS[8][h[0]][0],f+=ROT.DIRS[8][h[0]][1],this.map[e][f]=0,h[1]-=1};
-ROT.Map.Rogue.prototype._createCorridors=function(){for(var a=this._options.cellWidth,b=this._options.cellHeight,c,d,e,f,g=0;g<a;g++)for(var h=0;h<b;h++){c=this.rooms[g][h];for(var k=0;k<c.connections.length;k++)d=c.connections[k],d=this.rooms[d[0]][d[1]],d.cellx>c.cellx?(e=2,f=4):d.cellx<c.cellx?(e=4,f=2):d.celly>c.celly?(e=3,f=1):d.celly<c.celly&&(e=1,f=3),this._drawCorridore(this._getWallPosition(c,e),this._getWallPosition(d,f))}};ROT.Map.Feature=function(){};
-ROT.Map.Feature.prototype.isValid=function(a){};ROT.Map.Feature.prototype.create=function(a){};ROT.Map.Feature.prototype.debug=function(){};ROT.Map.Feature.createRandomAt=function(a,b,c,d,e){};ROT.Map.Feature.Room=function(a,b,c,d,e,f){this._x1=a;this._y1=b;this._x2=c;this._y2=d;this._doors={};4<arguments.length&&this.addDoor(e,f)};ROT.Map.Feature.Room.extend(ROT.Map.Feature);
-ROT.Map.Feature.Room.createRandomAt=function(a,b,c,d,e){var f=e.roomWidth[0],g=e.roomWidth[1],h=f+Math.floor(ROT.RNG.getUniform()*(g-f+1)),f=e.roomHeight[0],g=e.roomHeight[1];e=f+Math.floor(ROT.RNG.getUniform()*(g-f+1));if(1==c)return c=b-Math.floor(ROT.RNG.getUniform()*e),new this(a+1,c,a+h,c+e-1,a,b);if(-1==c)return c=b-Math.floor(ROT.RNG.getUniform()*e),new this(a-h,c,a-1,c+e-1,a,b);if(1==d)return c=a-Math.floor(ROT.RNG.getUniform()*h),new this(c,b+1,c+h-1,b+e,a,b);if(-1==d)return c=a-Math.floor(ROT.RNG.getUniform()*
-h),new this(c,b-e,c+h-1,b-1,a,b)};ROT.Map.Feature.Room.createRandomCenter=function(a,b,c){var d=c.roomWidth[0],e=c.roomWidth[1],f=d+Math.floor(ROT.RNG.getUniform()*(e-d+1)),d=c.roomHeight[0],e=c.roomHeight[1];c=d+Math.floor(ROT.RNG.getUniform()*(e-d+1));a-=Math.floor(ROT.RNG.getUniform()*f);b-=Math.floor(ROT.RNG.getUniform()*c);return new this(a,b,a+f-1,b+c-1)};
-ROT.Map.Feature.Room.createRandom=function(a,b,c){var d=c.roomWidth[0],e=c.roomWidth[1],f=d+Math.floor(ROT.RNG.getUniform()*(e-d+1)),d=c.roomHeight[0],e=c.roomHeight[1];c=d+Math.floor(ROT.RNG.getUniform()*(e-d+1));a=a-f-1;b=b-c-1;a=1+Math.floor(ROT.RNG.getUniform()*a);b=1+Math.floor(ROT.RNG.getUniform()*b);return new this(a,b,a+f-1,b+c-1)};ROT.Map.Feature.Room.prototype.addDoor=function(a,b){this._doors[a+","+b]=1;return this};
-ROT.Map.Feature.Room.prototype.getDoors=function(a){for(var b in this._doors){var c=b.split(",");a(parseInt(c[0]),parseInt(c[1]))}return this};ROT.Map.Feature.Room.prototype.clearDoors=function(){this._doors={};return this};ROT.Map.Feature.Room.prototype.addDoors=function(a){for(var b=this._x1-1,c=this._x2+1,d=this._y1-1,e=this._y2+1,f=b;f<=c;f++)for(var g=d;g<=e;g++)if(f==b||f==c||g==d||g==e)a(f,g)||this.addDoor(f,g);return this};
-ROT.Map.Feature.Room.prototype.debug=function(){console.log("room",this._x1,this._y1,this._x2,this._y2)};ROT.Map.Feature.Room.prototype.isValid=function(a,b){for(var c=this._x1-1,d=this._x2+1,e=this._y1-1,f=this._y2+1,g=c;g<=d;g++)for(var h=e;h<=f;h++)if(g==c||g==d||h==e||h==f){if(!a(g,h))return!1}else if(!b(g,h))return!1;return!0};
-ROT.Map.Feature.Room.prototype.create=function(a){for(var b=this._x1-1,c=this._x2+1,d=this._y1-1,e=this._y2+1,f=0,g=b;g<=c;g++)for(var h=d;h<=e;h++)f=g+","+h in this._doors?2:g==b||g==c||h==d||h==e?1:0,a(g,h,f)};ROT.Map.Feature.Room.prototype.getCenter=function(){return[Math.round((this._x1+this._x2)/2),Math.round((this._y1+this._y2)/2)]};ROT.Map.Feature.Room.prototype.getLeft=function(){return this._x1};ROT.Map.Feature.Room.prototype.getRight=function(){return this._x2};
-ROT.Map.Feature.Room.prototype.getTop=function(){return this._y1};ROT.Map.Feature.Room.prototype.getBottom=function(){return this._y2};ROT.Map.Feature.Corridor=function(a,b,c,d){this._startX=a;this._startY=b;this._endX=c;this._endY=d;this._endsWithAWall=!0};ROT.Map.Feature.Corridor.extend(ROT.Map.Feature);ROT.Map.Feature.Corridor.createRandomAt=function(a,b,c,d,e){var f=e.corridorLength[0];e=e.corridorLength[1];f+=Math.floor(ROT.RNG.getUniform()*(e-f+1));return new this(a,b,a+c*f,b+d*f)};
-ROT.Map.Feature.Corridor.prototype.debug=function(){console.log("corridor",this._startX,this._startY,this._endX,this._endY)};
-ROT.Map.Feature.Corridor.prototype.isValid=function(a,b){var c=this._startX,d=this._startY,e=this._endX-c,f=this._endY-d,g=1+Math.max(Math.abs(e),Math.abs(f));e&&(e/=Math.abs(e));f&&(f/=Math.abs(f));for(var h=f,k=-e,l=!0,m=0;m<g;m++){var p=c+m*e,n=d+m*f;b(p,n)||(l=!1);a(p+h,n+k)||(l=!1);a(p-h,n-k)||(l=!1);if(!l){g=m;this._endX=p-e;this._endY=n-f;break}}if(0==g||1==g&&a(this._endX+e,this._endY+f))return!1;c=!a(this._endX+e+h,this._endY+f+k);h=!a(this._endX+e-h,this._endY+f-k);this._endsWithAWall=a(this._endX+
-e,this._endY+f);return(c||h)&&this._endsWithAWall?!1:!0};ROT.Map.Feature.Corridor.prototype.create=function(a){var b=this._startX,c=this._startY,d=this._endX-b,e=this._endY-c,f=1+Math.max(Math.abs(d),Math.abs(e));d&&(d/=Math.abs(d));e&&(e/=Math.abs(e));for(var g=0;g<f;g++)a(b+g*d,c+g*e,0);return!0};
-ROT.Map.Feature.Corridor.prototype.createPriorityWalls=function(a){if(this._endsWithAWall){var b=this._endX-this._startX,c=this._endY-this._startY;b&&(b/=Math.abs(b));c&&(c/=Math.abs(c));var d=c,e=-b;a(this._endX+b,this._endY+c);a(this._endX+d,this._endY+e);a(this._endX-d,this._endY-e)}};ROT.Noise=function(){};ROT.Noise.prototype.get=function(a,b){};
-ROT.Noise.Simplex=function(a){ROT.Noise.call(this);this._F2=0.5*(Math.sqrt(3)-1);this._G2=(3-Math.sqrt(3))/6;this._gradients=[[0,-1],[1,-1],[1,0],[1,1],[0,1],[-1,1],[-1,0],[-1,-1]];var b=[];a=a||256;for(var c=0;c<a;c++)b.push(c);b=b.randomize();this._perms=[];this._indexes=[];for(c=0;c<2*a;c++)this._perms.push(b[c%a]),this._indexes.push(this._perms[c]%this._gradients.length)};ROT.Noise.Simplex.extend(ROT.Noise);
-ROT.Noise.Simplex.prototype.get=function(a,b){var c=this._perms,d=this._indexes,e=c.length/2,f=this._G2,g=0,h=0,k=0,l,m=(a+b)*this._F2,p=Math.floor(a+m);l=Math.floor(b+m);var m=(p+l)*f,n=a-(p-m),q=b-(l-m),r,s;n>q?(r=1,s=0):(r=0,s=1);var u=n-r+f,v=q-s+f,m=n-1+2*f,f=q-1+2*f,p=p.mod(e),e=l.mod(e),t=0.5-n*n-q*q;0<=t&&(t*=t,l=d[p+c[e]],l=this._gradients[l],g=t*t*(l[0]*n+l[1]*q));n=0.5-u*u-v*v;0<=n&&(n*=n,l=d[p+r+c[e+s]],l=this._gradients[l],h=n*n*(l[0]*u+l[1]*v));n=0.5-m*m-f*f;0<=n&&(n*=n,l=d[p+1+c[e+
-1]],l=this._gradients[l],k=n*n*(l[0]*m+l[1]*f));return 70*(g+h+k)};ROT.FOV=function(a,b){this._lightPasses=a;this._options={topology:8};for(var c in b)this._options[c]=b[c]};ROT.FOV.prototype.compute=function(a,b,c,d){};
-ROT.FOV.prototype._getCircle=function(a,b,c){var d=[],e,f,g;switch(this._options.topology){case 4:f=1;g=[0,1];e=[ROT.DIRS[8][7],ROT.DIRS[8][1],ROT.DIRS[8][3],ROT.DIRS[8][5]];break;case 6:e=ROT.DIRS[6];f=1;g=[-1,1];break;case 8:e=ROT.DIRS[4],f=2,g=[-1,1]}a+=g[0]*c;b+=g[1]*c;for(g=0;g<e.length;g++)for(var h=0;h<c*f;h++)d.push([a,b]),a+=e[g][0],b+=e[g][1];return d};ROT.FOV.DiscreteShadowcasting=function(a,b){ROT.FOV.call(this,a,b)};ROT.FOV.DiscreteShadowcasting.extend(ROT.FOV);
-ROT.FOV.DiscreteShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0);if(this._lightPasses(a,b))for(var e=[],f,g,h,k,l,m=1;m<=c;m++)for(var p=this._getCircle(a,b,m),n=360/p.length,q=0;q<p.length;q++)if(h=p[q][0],k=p[q][1],f=n*(q-0.5),g=f+n,l=!this._lightPasses(h,k),this._visibleCoords(Math.floor(f),Math.ceil(g),l,e)&&d(h,k,m,1),2==e.length&&0==e[0]&&360==e[1])return};
-ROT.FOV.DiscreteShadowcasting.prototype._visibleCoords=function(a,b,c,d){if(0>a){var e=arguments.callee(0,b,c,d),f=arguments.callee(360+a,360,c,d);return e||f}for(e=0;e<d.length&&d[e]<a;)e++;if(e==d.length)return c&&d.push(a,b),!0;f=0;if(e%2){for(;e<d.length&&d[e]<b;)e++,f++;if(0==f)return!1;c&&(f%2?d.splice(e-f,f,b):d.splice(e-f,f))}else{for(;e<d.length&&d[e]<b;)e++,f++;if(a==d[e-f]&&1==f)return!1;c&&(f%2?d.splice(e-f,f,a):d.splice(e-f,f,a,b))}return!0};
-ROT.FOV.PreciseShadowcasting=function(a,b){ROT.FOV.call(this,a,b)};ROT.FOV.PreciseShadowcasting.extend(ROT.FOV);ROT.FOV.PreciseShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0,1);if(this._lightPasses(a,b))for(var e=[],f,g,h,k,l,m=1;m<=c;m++)for(var p=this._getCircle(a,b,m),n=p.length,q=0;q<n;q++)if(f=p[q][0],g=p[q][1],k=[q?2*q-1:2*n-1,2*n],l=[2*q+1,2*n],h=!this._lightPasses(f,g),(h=this._checkVisibility(k,l,h,e))&&d(f,g,m,h),2==e.length&&0==e[0][0]&&e[1][0]==e[1][1])return};
-ROT.FOV.PreciseShadowcasting.prototype._checkVisibility=function(a,b,c,d){if(a[0]>b[0])return a=this._checkVisibility(a,[a[1],a[1]],c,d),b=this._checkVisibility([0,1],b,c,d),(a+b)/2;for(var e=0,f=!1;e<d.length;){var g=d[e],g=g[0]*a[1]-a[0]*g[1];if(0<=g){0!=g||e%2||(f=!0);break}e++}for(var h=d.length,k=!1;h--;)if(g=d[h],g=b[0]*g[1]-g[0]*b[1],0<=g){0==g&&h%2&&(k=!0);break}g=!0;e==h&&(f||k)?g=!1:f&&k&&e+1==h&&h%2?g=!1:e>h&&e%2&&(g=!1);if(!g)return 0;f=h-e+1;if(f%2)e%2?(h=d[e],h=(b[0]*h[1]-h[0]*b[1])/
-(h[1]*b[1]),c&&d.splice(e,f,b)):(h=d[h],h=(h[0]*a[1]-a[0]*h[1])/(a[1]*h[1]),c&&d.splice(e,f,a));else if(e%2)k=d[e],h=d[h],h=(h[0]*k[1]-k[0]*h[1])/(k[1]*h[1]),c&&d.splice(e,f);else return c&&d.splice(e,f,a,b),1;return h/((b[0]*a[1]-a[0]*b[1])/(a[1]*b[1]))};ROT.FOV.RecursiveShadowcasting=function(a,b){ROT.FOV.call(this,a,b)};ROT.FOV.RecursiveShadowcasting.extend(ROT.FOV);ROT.FOV.RecursiveShadowcasting.OCTANTS=[[-1,0,0,1],[0,-1,1,0],[0,-1,-1,0],[-1,0,0,-1],[1,0,0,-1],[0,1,-1,0],[0,1,1,0],[1,0,0,1]];
-ROT.FOV.RecursiveShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0,!0);for(var e=0;e<ROT.FOV.RecursiveShadowcasting.OCTANTS.length;e++)this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[e],c,d)};
-ROT.FOV.RecursiveShadowcasting.prototype.compute180=function(a,b,c,d,e){e(a,b,0,!0);var f=(d-1+8)%8,g=(d+1+8)%8;this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[(d-2+8)%8],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[f],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[d],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[g],c,e)};
-ROT.FOV.RecursiveShadowcasting.prototype.compute90=function(a,b,c,d,e){e(a,b,0,!0);var f=(d-1+8)%8;this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[d],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[f],c,e)};ROT.FOV.RecursiveShadowcasting.prototype._renderOctant=function(a,b,c,d,e){this._castVisibility(a,b,1,1,0,d+1,c[0],c[1],c[2],c[3],e)};
-ROT.FOV.RecursiveShadowcasting.prototype._castVisibility=function(a,b,c,d,e,f,g,h,k,l,m){if(!(d<e))for(;c<=f;c++){for(var p=-c-1,n=-c,q=!1,r=0;0>=p;){var p=p+1,s=a+p*g+n*h,u=b+p*k+n*l,v=(p-0.5)/(n+0.5),t=(p+0.5)/(n-0.5);if(!(t>d)){if(v<e)break;p*p+n*n<f*f&&m(s,u,c,!0);q?this._lightPasses(s,u)?(q=!1,d=r):r=t:!this._lightPasses(s,u)&&c<f&&(q=!0,this._castVisibility(a,b,c+1,d,v,f,g,h,k,l,m),r=t)}}if(q)break}};
-ROT.Color={fromString:function(a){var b,c;if(a in this._cache)b=this._cache[a];else{if("#"==a.charAt(0))if(b=a.match(/[0-9a-f]/gi).map(function(a){return parseInt(a,16)}),3==b.length)b=b.map(function(a){return 17*a});else for(c=0;3>c;c++)b[c+1]+=16*b[c],b.splice(c,1);else b=(c=a.match(/rgb\(([0-9, ]+)\)/i))?c[1].split(/\s*,\s*/).map(function(a){return parseInt(a)}):[0,0,0];this._cache[a]=b}return b.slice()},add:function(a,b){for(var c=a.slice(),d=0;3>d;d++)for(var e=1;e<arguments.length;e++)c[d]+=
-arguments[e][d];return c},add_:function(a,b){for(var c=0;3>c;c++)for(var d=1;d<arguments.length;d++)a[c]+=arguments[d][c];return a},multiply:function(a,b){for(var c=a.slice(),d=0;3>d;d++){for(var e=1;e<arguments.length;e++)c[d]*=arguments[e][d]/255;c[d]=Math.round(c[d])}return c},multiply_:function(a,b){for(var c=0;3>c;c++){for(var d=1;d<arguments.length;d++)a[c]*=arguments[d][c]/255;a[c]=Math.round(a[c])}return a},interpolate:function(a,b,c){3>arguments.length&&(c=0.5);for(var d=a.slice(),e=0;3>
-e;e++)d[e]=Math.round(d[e]+c*(b[e]-a[e]));return d},interpolateHSL:function(a,b,c){3>arguments.length&&(c=0.5);for(var d=this.rgb2hsl(a),e=this.rgb2hsl(b),f=0;3>f;f++)d[f]+=c*(e[f]-d[f]);return this.hsl2rgb(d)},randomize:function(a,b){b instanceof Array||(b=ROT.RNG.getNormal(0,b));for(var c=a.slice(),d=0;3>d;d++)c[d]+=b instanceof Array?Math.round(ROT.RNG.getNormal(0,b[d])):b;return c},rgb2hsl:function(a){var b=a[0]/255,c=a[1]/255;a=a[2]/255;var d=Math.max(b,c,a),e=Math.min(b,c,a),f,g=(d+e)/2;if(d==
-e)f=e=0;else{var h=d-e,e=0.5<g?h/(2-d-e):h/(d+e);switch(d){case b:f=(c-a)/h+(c<a?6:0);break;case c:f=(a-b)/h+2;break;case a:f=(b-c)/h+4}f/=6}return[f,e,g]},hsl2rgb:function(a){var b=a[2];if(0==a[1])return b=Math.round(255*b),[b,b,b];var c=function(a,b,c){0>c&&(c+=1);1<c&&(c-=1);return c<1/6?a+6*(b-a)*c:0.5>c?b:c<2/3?a+(b-a)*(2/3-c)*6:a},d=a[1],d=0.5>b?b*(1+d):b+d-b*d,e=2*b-d,b=c(e,d,a[0]+1/3),f=c(e,d,a[0]);a=c(e,d,a[0]-1/3);return[Math.round(255*b),Math.round(255*f),Math.round(255*a)]},toRGB:function(a){return"rgb("+
-this._clamp(a[0])+","+this._clamp(a[1])+","+this._clamp(a[2])+")"},toHex:function(a){for(var b=[],c=0;3>c;c++)b.push(this._clamp(a[c]).toString(16).lpad("0",2));return"#"+b.join("")},_clamp:function(a){return 0>a?0:255<a?255:a},_cache:{black:[0,0,0],navy:[0,0,128],darkblue:[0,0,139],mediumblue:[0,0,205],blue:[0,0,255],darkgreen:[0,100,0],green:[0,128,0],teal:[0,128,128],darkcyan:[0,139,139],deepskyblue:[0,191,255],darkturquoise:[0,206,209],mediumspringgreen:[0,250,154],lime:[0,255,0],springgreen:[0,
-255,127],aqua:[0,255,255],cyan:[0,255,255],midnightblue:[25,25,112],dodgerblue:[30,144,255],forestgreen:[34,139,34],seagreen:[46,139,87],darkslategray:[47,79,79],darkslategrey:[47,79,79],limegreen:[50,205,50],mediumseagreen:[60,179,113],turquoise:[64,224,208],royalblue:[65,105,225],steelblue:[70,130,180],darkslateblue:[72,61,139],mediumturquoise:[72,209,204],indigo:[75,0,130],darkolivegreen:[85,107,47],cadetblue:[95,158,160],cornflowerblue:[100,149,237],mediumaquamarine:[102,205,170],dimgray:[105,
-105,105],dimgrey:[105,105,105],slateblue:[106,90,205],olivedrab:[107,142,35],slategray:[112,128,144],slategrey:[112,128,144],lightslategray:[119,136,153],lightslategrey:[119,136,153],mediumslateblue:[123,104,238],lawngreen:[124,252,0],chartreuse:[127,255,0],aquamarine:[127,255,212],maroon:[128,0,0],purple:[128,0,128],olive:[128,128,0],gray:[128,128,128],grey:[128,128,128],skyblue:[135,206,235],lightskyblue:[135,206,250],blueviolet:[138,43,226],darkred:[139,0,0],darkmagenta:[139,0,139],saddlebrown:[139,
-69,19],darkseagreen:[143,188,143],lightgreen:[144,238,144],mediumpurple:[147,112,216],darkviolet:[148,0,211],palegreen:[152,251,152],darkorchid:[153,50,204],yellowgreen:[154,205,50],sienna:[160,82,45],brown:[165,42,42],darkgray:[169,169,169],darkgrey:[169,169,169],lightblue:[173,216,230],greenyellow:[173,255,47],paleturquoise:[175,238,238],lightsteelblue:[176,196,222],powderblue:[176,224,230],firebrick:[178,34,34],darkgoldenrod:[184,134,11],mediumorchid:[186,85,211],rosybrown:[188,143,143],darkkhaki:[189,
-183,107],silver:[192,192,192],mediumvioletred:[199,21,133],indianred:[205,92,92],peru:[205,133,63],chocolate:[210,105,30],tan:[210,180,140],lightgray:[211,211,211],lightgrey:[211,211,211],palevioletred:[216,112,147],thistle:[216,191,216],orchid:[218,112,214],goldenrod:[218,165,32],crimson:[220,20,60],gainsboro:[220,220,220],plum:[221,160,221],burlywood:[222,184,135],lightcyan:[224,255,255],lavender:[230,230,250],darksalmon:[233,150,122],violet:[238,130,238],palegoldenrod:[238,232,170],lightcoral:[240,
-128,128],khaki:[240,230,140],aliceblue:[240,248,255],honeydew:[240,255,240],azure:[240,255,255],sandybrown:[244,164,96],wheat:[245,222,179],beige:[245,245,220],whitesmoke:[245,245,245],mintcream:[245,255,250],ghostwhite:[248,248,255],salmon:[250,128,114],antiquewhite:[250,235,215],linen:[250,240,230],lightgoldenrodyellow:[250,250,210],oldlace:[253,245,230],red:[255,0,0],fuchsia:[255,0,255],magenta:[255,0,255],deeppink:[255,20,147],orangered:[255,69,0],tomato:[255,99,71],hotpink:[255,105,180],coral:[255,
-127,80],darkorange:[255,140,0],lightsalmon:[255,160,122],orange:[255,165,0],lightpink:[255,182,193],pink:[255,192,203],gold:[255,215,0],peachpuff:[255,218,185],navajowhite:[255,222,173],moccasin:[255,228,181],bisque:[255,228,196],mistyrose:[255,228,225],blanchedalmond:[255,235,205],papayawhip:[255,239,213],lavenderblush:[255,240,245],seashell:[255,245,238],cornsilk:[255,248,220],lemonchiffon:[255,250,205],floralwhite:[255,250,240],snow:[255,250,250],yellow:[255,255,0],lightyellow:[255,255,224],ivory:[255,
-255,240],white:[255,255,255]}};ROT.Lighting=function(a,b){this._reflectivityCallback=a;this._options={passes:1,emissionThreshold:100,range:10};this._fov=null;this._lights={};this._reflectivityCache={};this._fovCache={};this.setOptions(b)};ROT.Lighting.prototype.setOptions=function(a){for(var b in a)this._options[b]=a[b];a.range&&this.reset();return this};ROT.Lighting.prototype.setFOV=function(a){this._fov=a;this._fovCache={};return this};
-ROT.Lighting.prototype.setLight=function(a,b,c){a=a+","+b;c?this._lights[a]="string"==typeof c?ROT.Color.fromString(c):c:delete this._lights[a];return this};ROT.Lighting.prototype.reset=function(){this._reflectivityCache={};this._fovCache={};return this};
-ROT.Lighting.prototype.compute=function(a){var b={},c={},d={},e;for(e in this._lights){var f=this._lights[e];e in c||(c[e]=[0,0,0]);ROT.Color.add_(c[e],f)}for(e=0;e<this._options.passes;e++)this._emitLight(c,d,b),e+1!=this._options.passes&&(c=this._computeEmitters(d,b));for(var g in d)c=g.split(","),b=parseInt(c[0]),c=parseInt(c[1]),a(b,c,d[g]);return this};
-ROT.Lighting.prototype._emitLight=function(a,b,c){for(var d in a){var e=d.split(","),f=parseInt(e[0]),e=parseInt(e[1]);this._emitLightFromCell(f,e,a[d],b);c[d]=1}return this};
-ROT.Lighting.prototype._computeEmitters=function(a,b){var c={},d;for(d in a)if(!(d in b)){var e=a[d];if(d in this._reflectivityCache)var f=this._reflectivityCache[d];else{var g=d.split(","),f=parseInt(g[0]),g=parseInt(g[1]),f=this._reflectivityCallback(f,g);this._reflectivityCache[d]=f}if(0!=f){for(var g=[],h=0,k=0;3>k;k++){var l=Math.round(e[k]*f);g[k]=l;h+=l}h>this._options.emissionThreshold&&(c[d]=g)}}return c};
-ROT.Lighting.prototype._emitLightFromCell=function(a,b,c,d){var e=a+","+b;a=e in this._fovCache?this._fovCache[e]:this._updateFOV(a,b);for(var f in a){b=a[f];f in d?e=d[f]:(e=[0,0,0],d[f]=e);for(var g=0;3>g;g++)e[g]+=Math.round(c[g]*b)}return this};ROT.Lighting.prototype._updateFOV=function(a,b){var c={};this._fovCache[a+","+b]=c;var d=this._options.range;this._fov.compute(a,b,d,function(a,b,g,h){g=h*(1-g/d);0!=g&&(c[a+","+b]=g)}.bind(this));return c};
-ROT.Path=function(a,b,c,d){this._toX=a;this._toY=b;this._fromY=this._fromX=null;this._passableCallback=c;this._options={topology:8};for(var e in d)this._options[e]=d[e];this._dirs=ROT.DIRS[this._options.topology];8==this._options.topology&&(this._dirs=[this._dirs[0],this._dirs[2],this._dirs[4],this._dirs[6],this._dirs[1],this._dirs[3],this._dirs[5],this._dirs[7]])};ROT.Path.prototype.compute=function(a,b,c){};
-ROT.Path.prototype._getNeighbors=function(a,b){for(var c=[],d=0;d<this._dirs.length;d++){var e=this._dirs[d],f=a+e[0],e=b+e[1];this._passableCallback(f,e)&&c.push([f,e])}return c};ROT.Path.Dijkstra=function(a,b,c,d){ROT.Path.call(this,a,b,c,d);this._computed={};this._todo=[];this._add(a,b,null)};ROT.Path.Dijkstra.extend(ROT.Path);
-ROT.Path.Dijkstra.prototype.compute=function(a,b,c){var d=a+","+b;d in this._computed||this._compute(a,b);if(d in this._computed)for(a=this._computed[d];a;)c(a.x,a.y),a=a.prev};ROT.Path.Dijkstra.prototype._compute=function(a,b){for(;this._todo.length;){var c=this._todo.shift();if(c.x==a&&c.y==b)break;for(var d=this._getNeighbors(c.x,c.y),e=0;e<d.length;e++){var f=d[e],g=f[0],f=f[1];g+","+f in this._computed||this._add(g,f,c)}}};
-ROT.Path.Dijkstra.prototype._add=function(a,b,c){c={x:a,y:b,prev:c};this._computed[a+","+b]=c;this._todo.push(c)};ROT.Path.AStar=function(a,b,c,d){ROT.Path.call(this,a,b,c,d);this._todo=[];this._done={};this._fromY=this._fromX=null};ROT.Path.AStar.extend(ROT.Path);
-ROT.Path.AStar.prototype.compute=function(a,b,c){this._todo=[];this._done={};this._fromX=a;this._fromY=b;for(this._add(this._toX,this._toY,null);this._todo.length;){var d=this._todo.shift();if(d.x==a&&d.y==b)break;for(var e=this._getNeighbors(d.x,d.y),f=0;f<e.length;f++){var g=e[f],h=g[0],g=g[1];h+","+g in this._done||this._add(h,g,d)}}if(d=this._done[a+","+b])for(;d;)c(d.x,d.y),d=d.prev};
-ROT.Path.AStar.prototype._add=function(a,b,c){c={x:a,y:b,prev:c,g:c?c.g+1:0,h:this._distance(a,b)};this._done[a+","+b]=c;a=c.g+c.h;for(b=0;b<this._todo.length;b++){var d=this._todo[b];if(a<d.g+d.h){this._todo.splice(b,0,c);return}}this._todo.push(c)};
-ROT.Path.AStar.prototype._distance=function(a,b){switch(this._options.topology){case 4:return Math.abs(a-this._fromX)+Math.abs(b-this._fromY);case 6:var c=Math.abs(a-this._fromX),d=Math.abs(b-this._fromY);return d+Math.max(0,(c-d)/2);case 8:return Math.max(Math.abs(a-this._fromX),Math.abs(b-this._fromY))}};

From b147c84cbbc5d11de9862c26c33155ec012b72ff Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 1 Nov 2016 20:23:21 +0100
Subject: [PATCH 15/20] Upload last generate js files.

---
 rot.js     |   2 +-
 rot.min.js | 154 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 155 insertions(+), 1 deletion(-)
 create mode 100644 rot.min.js

diff --git a/rot.js b/rot.js
index aaea5e33..f657836f 100644
--- a/rot.js
+++ b/rot.js
@@ -1,6 +1,6 @@
 /*
 	This is rot.js, the ROguelike Toolkit in JavaScript.
-	Version 0.7~dev, generated on mar nov  1 20:20:43 CET 2016.
+	Version 0.7~dev, generated on mar nov  1 20:22:45 CET 2016.
 */
 /**
  * @namespace Top-level ROT namespace
diff --git a/rot.min.js b/rot.min.js
new file mode 100644
index 00000000..f7e7886d
--- /dev/null
+++ b/rot.min.js
@@ -0,0 +1,154 @@
+var ROT={isSupported:function(){return!(!document.createElement("canvas").getContext||!Function.prototype.bind)},DEFAULT_WIDTH:80,DEFAULT_HEIGHT:25,DIRS:{4:[[0,-1],[1,0],[0,1],[-1,0]],8:[[0,-1],[1,-1],[1,0],[1,1],[0,1],[-1,1],[-1,0],[-1,-1]],6:[[-1,-1],[1,-1],[2,0],[1,1],[-1,1],[-2,0]]},VK_CANCEL:3,VK_HELP:6,VK_BACK_SPACE:8,VK_TAB:9,VK_CLEAR:12,VK_RETURN:13,VK_ENTER:14,VK_SHIFT:16,VK_CONTROL:17,VK_ALT:18,VK_PAUSE:19,VK_CAPS_LOCK:20,VK_ESCAPE:27,VK_SPACE:32,VK_PAGE_UP:33,VK_PAGE_DOWN:34,VK_END:35,
+VK_HOME:36,VK_LEFT:37,VK_UP:38,VK_RIGHT:39,VK_DOWN:40,VK_PRINTSCREEN:44,VK_INSERT:45,VK_DELETE:46,VK_0:48,VK_1:49,VK_2:50,VK_3:51,VK_4:52,VK_5:53,VK_6:54,VK_7:55,VK_8:56,VK_9:57,VK_COLON:58,VK_SEMICOLON:59,VK_LESS_THAN:60,VK_EQUALS:61,VK_GREATER_THAN:62,VK_QUESTION_MARK:63,VK_AT:64,VK_A:65,VK_B:66,VK_C:67,VK_D:68,VK_E:69,VK_F:70,VK_G:71,VK_H:72,VK_I:73,VK_J:74,VK_K:75,VK_L:76,VK_M:77,VK_N:78,VK_O:79,VK_P:80,VK_Q:81,VK_R:82,VK_S:83,VK_T:84,VK_U:85,VK_V:86,VK_W:87,VK_X:88,VK_Y:89,VK_Z:90,VK_CONTEXT_MENU:93,
+VK_NUMPAD0:96,VK_NUMPAD1:97,VK_NUMPAD2:98,VK_NUMPAD3:99,VK_NUMPAD4:100,VK_NUMPAD5:101,VK_NUMPAD6:102,VK_NUMPAD7:103,VK_NUMPAD8:104,VK_NUMPAD9:105,VK_MULTIPLY:106,VK_ADD:107,VK_SEPARATOR:108,VK_SUBTRACT:109,VK_DECIMAL:110,VK_DIVIDE:111,VK_F1:112,VK_F2:113,VK_F3:114,VK_F4:115,VK_F5:116,VK_F6:117,VK_F7:118,VK_F8:119,VK_F9:120,VK_F10:121,VK_F11:122,VK_F12:123,VK_F13:124,VK_F14:125,VK_F15:126,VK_F16:127,VK_F17:128,VK_F18:129,VK_F19:130,VK_F20:131,VK_F21:132,VK_F22:133,VK_F23:134,VK_F24:135,VK_NUM_LOCK:144,
+VK_SCROLL_LOCK:145,VK_CIRCUMFLEX:160,VK_EXCLAMATION:161,VK_DOUBLE_QUOTE:162,VK_HASH:163,VK_DOLLAR:164,VK_PERCENT:165,VK_AMPERSAND:166,VK_UNDERSCORE:167,VK_OPEN_PAREN:168,VK_CLOSE_PAREN:169,VK_ASTERISK:170,VK_PLUS:171,VK_PIPE:172,VK_HYPHEN_MINUS:173,VK_OPEN_CURLY_BRACKET:174,VK_CLOSE_CURLY_BRACKET:175,VK_TILDE:176,VK_COMMA:188,VK_PERIOD:190,VK_SLASH:191,VK_BACK_QUOTE:192,VK_OPEN_BRACKET:219,VK_BACK_SLASH:220,VK_CLOSE_BRACKET:221,VK_QUOTE:222,VK_META:224,VK_ALTGR:225,VK_WIN:91,VK_KANA:21,VK_HANGUL:21,
+VK_EISU:22,VK_JUNJA:23,VK_FINAL:24,VK_HANJA:25,VK_KANJI:25,VK_CONVERT:28,VK_NONCONVERT:29,VK_ACCEPT:30,VK_MODECHANGE:31,VK_SELECT:41,VK_PRINT:42,VK_EXECUTE:43,VK_SLEEP:95,Text:{RE_COLORS:/%([bc]){([^}]*)}/g,TYPE_TEXT:0,TYPE_NEWLINE:1,TYPE_FG:2,TYPE_BG:3,measure:function(a,b){for(var c={width:0,height:1},d=this.tokenize(a,b),e=0,f=0;f<d.length;f++){var g=d[f];switch(g.type){case this.TYPE_TEXT:e+=g.value.length;break;case this.TYPE_NEWLINE:c.height++,c.width=Math.max(c.width,e),e=0}}c.width=Math.max(c.width,
+e);return c},tokenize:function(a,b){var c=[],d=0;a.replace(this.RE_COLORS,function(b,e,h,l){var f=a.substring(d,l);f.length&&c.push({type:ROT.Text.TYPE_TEXT,value:f});c.push({type:"c"==e?ROT.Text.TYPE_FG:ROT.Text.TYPE_BG,value:h.trim()});d=l+b.length;return""});var e=a.substring(d);e.length&&c.push({type:ROT.Text.TYPE_TEXT,value:e});return this._breakLines(c,b)},_breakLines:function(a,b){b||(b=Infinity);for(var c=0,d=0,e=-1;c<a.length;){var f=a[c];f.type==ROT.Text.TYPE_NEWLINE&&(d=0,e=-1);if(f.type!=
+ROT.Text.TYPE_TEXT)c++;else{for(;0==d&&" "==f.value.charAt(0);)f.value=f.value.substring(1);var g=f.value.indexOf("\n");if(-1!=g){f.value=this._breakInsideToken(a,c,g,!0);for(g=f.value.split("");g.length&&" "==g[g.length-1];)g.pop();f.value=g.join("")}if(f.value.length){if(d+f.value.length>b){for(g=-1;;){var h=f.value.indexOf(" ",g+1);if(-1==h)break;if(d+h>b)break;g=h}-1!=g?f.value=this._breakInsideToken(a,c,g,!0):-1!=e?(f=a[e],c=f.value.lastIndexOf(" "),f.value=this._breakInsideToken(a,e,c,!0),c=
+e):f.value=this._breakInsideToken(a,c,b-d,!1)}else d+=f.value.length,-1!=f.value.indexOf(" ")&&(e=c);c++}else a.splice(c,1)}}a.push({type:ROT.Text.TYPE_NEWLINE});d=null;for(c=0;c<a.length;c++)switch(f=a[c],f.type){case ROT.Text.TYPE_TEXT:d=f;break;case ROT.Text.TYPE_NEWLINE:if(d){for(g=d.value.split("");g.length&&" "==g[g.length-1];)g.pop();d.value=g.join("")}d=null}a.pop();return a},_breakInsideToken:function(a,b,c,d){var e={type:ROT.Text.TYPE_NEWLINE};d={type:ROT.Text.TYPE_TEXT,value:a[b].value.substring(c+
+(d?1:0))};a.splice(b+1,0,e,d);return a[b].value.substring(0,c)}}};Array.prototype.random=Array.prototype.random||function(){return this.length?this[Math.floor(ROT.RNG.getUniform()*this.length)]:null};Array.prototype.randomize=Array.prototype.randomize||function(){for(var a=[],b=this.slice();b.length;){var c=b.indexOf(b.random());a.push(b.splice(c,1)[0])}return a};Number.prototype.mod=Number.prototype.mod||function(a){return(this%a+a)%a};
+String.prototype.capitalize=String.prototype.capitalize||function(){return this.charAt(0).toUpperCase()+this.substring(1)};String.prototype.lpad=String.prototype.lpad||function(a,b){for(var c=a||"0",d=b||2,e="";e.length<d-this.length;)e+=c;e=e.substring(0,d-this.length);return e+this};String.prototype.rpad=String.prototype.rpad||function(a,b){for(var c=a||"0",d=b||2,e="";e.length<d-this.length;)e+=c;e=e.substring(0,d-this.length);return this+e};
+String.format=String.format||function(a){var b=String.format.map,c=Array.prototype.slice.call(arguments,1);return a.replace(/%(?:([a-z]+)|(?:{([^}]+)}))/gi,function(d,e,f,g){if("%"==a.charAt(g-1))return d.substring(1);if(!c.length)return d;f=(e||f).split(",");e=f.shift();g=b[e.toLowerCase()];if(!g)return d;d=c.shift();d=d[g].apply(d,f);e=e.charAt(0);e!=e.toLowerCase()&&(d=d.capitalize());return d})};String.format.map=String.format.map||{s:"toString"};
+String.prototype.format=String.prototype.format||function(){var a=Array.prototype.slice.call(arguments);a.unshift(this);return String.format.apply(String,a)};Object.create||(Object.create=function(a){var b=function(){};b.prototype=a;return new b});Function.prototype.extend=Function.prototype.extend||function(a){this.prototype=Object.create(a.prototype);this.prototype.constructor=this;return this};
+"undefined"!=typeof window&&(window.requestAnimationFrame=window.requestAnimationFrame||window.mozRequestAnimationFrame||window.webkitRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(a){return setTimeout(a,1E3/60)},window.cancelAnimationFrame=window.cancelAnimationFrame||window.mozCancelAnimationFrame||window.webkitCancelAnimationFrame||window.oCancelAnimationFrame||window.msCancelAnimationFrame||function(a){return clearTimeout(a)});
+ROT.Display=function(a){this._context=document.createElement("canvas").getContext("2d");this._data={};this._dirty=!1;this._options={};this._backend=null;var b={width:ROT.DEFAULT_WIDTH,height:ROT.DEFAULT_HEIGHT,transpose:!1,layout:"rect",fontSize:15,spacing:1,border:0,forceSquareRatio:!1,fontFamily:"monospace",fontStyle:"",fg:"#ccc",bg:"#000",tileWidth:32,tileHeight:32,tileMap:{},tileSet:null,tileColorize:!1,termColor:"xterm"},c;for(c in a)b[c]=a[c];this.setOptions(b);this.DEBUG=this.DEBUG.bind(this);
+this._tick=this._tick.bind(this);requestAnimationFrame(this._tick)};ROT.Display.prototype.DEBUG=function(a,b,c){var d=[this._options.bg,this._options.fg];this.draw(a,b,null,null,d[c%d.length])};ROT.Display.prototype.clear=function(){this._data={};this._dirty=!0};
+ROT.Display.prototype.setOptions=function(a){for(var b in a)this._options[b]=a[b];if(a.width||a.height||a.fontSize||a.fontFamily||a.spacing||a.layout)a.layout&&(this._backend=new (ROT.Display[a.layout.capitalize()])(this._context)),a=(this._options.fontStyle?this._options.fontStyle+" ":"")+this._options.fontSize+"px "+this._options.fontFamily,this._context.font=a,this._backend.compute(this._options),this._context.font=a,this._context.textAlign="center",this._context.textBaseline="middle",this._dirty=
+!0;return this};ROT.Display.prototype.getOptions=function(){return this._options};ROT.Display.prototype.getContainer=function(){return this._context.canvas};ROT.Display.prototype.computeSize=function(a,b){return this._backend.computeSize(a,b,this._options)};ROT.Display.prototype.computeFontSize=function(a,b){return this._backend.computeFontSize(a,b,this._options)};
+ROT.Display.prototype.eventToPosition=function(a){if(a.touches){var b=a.touches[0].clientX;a=a.touches[0].clientY}else b=a.clientX,a=a.clientY;var c=this._context.canvas.getBoundingClientRect(),b=b-c.left;a-=c.top;b*=this._context.canvas.width/this._context.canvas.clientWidth;a*=this._context.canvas.height/this._context.canvas.clientHeight;return 0>b||0>a||b>=this._context.canvas.width||a>=this._context.canvas.height?[-1,-1]:this._backend.eventToPosition(b,a)};
+ROT.Display.prototype.draw=function(a,b,c,d,e){d||(d=this._options.fg);e||(e=this._options.bg);this._data[a+","+b]=[a,b,c,d,e];!0!==this._dirty&&(this._dirty||(this._dirty={}),this._dirty[a+","+b]=!0)};
+ROT.Display.prototype.drawText=function(a,b,c,d){var e=null,f=null,g=a,h=1;d||(d=this._options.width-a);for(c=ROT.Text.tokenize(c,d);c.length;)switch(d=c.shift(),d.type){case ROT.Text.TYPE_TEXT:for(var l,m=!1,n,q=!1,p=0;p<d.value.length;p++){l=d.value.charCodeAt(p);var r=d.value.charAt(p);n=255<l&&65377>l||65500<l&&65512>l&&65518<l;l=32==r.charCodeAt(0)||12288==r.charCodeAt(0);!q||n||l||g++;n&&!m&&g++;this.draw(g++,b,r,e,f);m=l;q=n}break;case ROT.Text.TYPE_FG:e=d.value||null;break;case ROT.Text.TYPE_BG:f=
+d.value||null;break;case ROT.Text.TYPE_NEWLINE:g=a,b++,h++}return h};ROT.Display.prototype._tick=function(){requestAnimationFrame(this._tick);if(this._dirty){if(!0===this._dirty){this._context.fillStyle=this._options.bg;this._context.fillRect(0,0,this._context.canvas.width,this._context.canvas.height);for(var a in this._data)this._draw(a,!1)}else for(var b in this._dirty)this._draw(b,!0);this._dirty=!1}};
+ROT.Display.prototype._draw=function(a,b){var c=this._data[a];c[4]!=this._options.bg&&(b=!0);this._backend.draw(c,b)};ROT.Display.Backend=function(a){this._context=a};ROT.Display.Backend.prototype.compute=function(a){};ROT.Display.Backend.prototype.draw=function(a,b){};ROT.Display.Backend.prototype.computeSize=function(a,b){};ROT.Display.Backend.prototype.computeFontSize=function(a,b){};ROT.Display.Backend.prototype.eventToPosition=function(a,b){};
+ROT.Display.Rect=function(a){ROT.Display.Backend.call(this,a);this._spacingY=this._spacingX=0;this._canvasCache={};this._options={}};ROT.Display.Rect.extend(ROT.Display.Backend);ROT.Display.Rect.cache=!1;
+ROT.Display.Rect.prototype.compute=function(a){this._canvasCache={};this._options=a;var b=Math.ceil(this._context.measureText("W").width);this._spacingX=Math.ceil(a.spacing*b);this._spacingY=Math.ceil(a.spacing*a.fontSize);this._options.forceSquareRatio&&(this._spacingX=this._spacingY=Math.max(this._spacingX,this._spacingY));this._context.canvas.width=a.width*this._spacingX;this._context.canvas.height=a.height*this._spacingY};
+ROT.Display.Rect.prototype.draw=function(a,b){this.constructor.cache?this._drawWithCache(a,b):this._drawNoCache(a,b)};
+ROT.Display.Rect.prototype._drawWithCache=function(a,b){var c=a[0],d=a[1],e=a[2],f=a[3],g=a[4],h=""+e+f+g;if(h in this._canvasCache)var l=this._canvasCache[h];else{var m=this._options.border,l=document.createElement("canvas"),n=l.getContext("2d");l.width=this._spacingX;l.height=this._spacingY;n.fillStyle=g;n.fillRect(m,m,l.width-m,l.height-m);if(e)for(n.fillStyle=f,n.font=this._context.font,n.textAlign="center",n.textBaseline="middle",e=[].concat(e),f=0;f<e.length;f++)n.fillText(e[f],this._spacingX/
+2,Math.ceil(this._spacingY/2));this._canvasCache[h]=l}this._context.drawImage(l,c*this._spacingX,d*this._spacingY)};ROT.Display.Rect.prototype._drawNoCache=function(a,b){var c=a[0],d=a[1],e=a[2],f=a[3],g=a[4];if(b){var h=this._options.border;this._context.fillStyle=g;this._context.fillRect(c*this._spacingX+h,d*this._spacingY+h,this._spacingX-h,this._spacingY-h)}if(e)for(this._context.fillStyle=f,e=[].concat(e),f=0;f<e.length;f++)this._context.fillText(e[f],(c+.5)*this._spacingX,Math.ceil((d+.5)*this._spacingY))};
+ROT.Display.Rect.prototype.computeSize=function(a,b){return[Math.floor(a/this._spacingX),Math.floor(b/this._spacingY)]};ROT.Display.Rect.prototype.computeFontSize=function(a,b){var c=Math.floor(a/this._options.width),d=Math.floor(b/this._options.height),e=this._context.font;this._context.font="100px "+this._options.fontFamily;var f=Math.ceil(this._context.measureText("W").width);this._context.font=e;c=f/100*d/c;1<c&&(d=Math.floor(d/c));return Math.floor(d/this._options.spacing)};
+ROT.Display.Rect.prototype.eventToPosition=function(a,b){return[Math.floor(a/this._spacingX),Math.floor(b/this._spacingY)]};ROT.Display.Hex=function(a){ROT.Display.Backend.call(this,a);this._hexSize=this._spacingY=this._spacingX=0;this._options={}};ROT.Display.Hex.extend(ROT.Display.Backend);
+ROT.Display.Hex.prototype.compute=function(a){this._options=a;var b=Math.ceil(this._context.measureText("W").width);this._hexSize=Math.floor(a.spacing*(a.fontSize+b/Math.sqrt(3))/2);this._spacingX=this._hexSize*Math.sqrt(3)/2;this._spacingY=1.5*this._hexSize;if(a.transpose)var b="height",c="width";else b="width",c="height";this._context.canvas[b]=Math.ceil((a.width+1)*this._spacingX);this._context.canvas[c]=Math.ceil((a.height-1)*this._spacingY+2*this._hexSize)};
+ROT.Display.Hex.prototype.draw=function(a,b){var c=a[2],d=a[3],e=a[4],f=[(a[0]+1)*this._spacingX,a[1]*this._spacingY+this._hexSize];this._options.transpose&&f.reverse();b&&(this._context.fillStyle=e,this._fill(f[0],f[1]));if(c)for(this._context.fillStyle=d,c=[].concat(c),d=0;d<c.length;d++)this._context.fillText(c[d],f[0],Math.ceil(f[1]))};
+ROT.Display.Hex.prototype.computeSize=function(a,b){this._options.transpose&&(a+=b,b=a-b,a-=b);return[Math.floor(a/this._spacingX)-1,Math.floor((b-2*this._hexSize)/this._spacingY+1)]};
+ROT.Display.Hex.prototype.computeFontSize=function(a,b){this._options.transpose&&(a+=b,b=a-b,a-=b);var c=Math.min(2*a/((this._options.width+1)*Math.sqrt(3))-1,b/(2+1.5*(this._options.height-1))),d=this._context.font;this._context.font="100px "+this._options.fontFamily;var e=Math.ceil(this._context.measureText("W").width);this._context.font=d;c=Math.floor(c)+1;return Math.ceil(2*c/(this._options.spacing*(1+e/100/Math.sqrt(3))))-1};
+ROT.Display.Hex.prototype.eventToPosition=function(a,b){if(this._options.transpose){a+=b;b=a-b;a-=b;var c=this._context.canvas.width}else c=this._context.canvas.height;b=Math.floor(b/(c/this._options.height));b.mod(2)?(a-=this._spacingX,a=1+2*Math.floor(a/(2*this._spacingX))):a=2*Math.floor(a/(2*this._spacingX));return[a,b]};
+ROT.Display.Hex.prototype._fill=function(a,b){var c=this._hexSize,d=this._options.border;this._context.beginPath();this._options.transpose?(this._context.moveTo(a-c+d,b),this._context.lineTo(a-c/2+d,b+this._spacingX-d),this._context.lineTo(a+c/2-d,b+this._spacingX-d),this._context.lineTo(a+c-d,b),this._context.lineTo(a+c/2-d,b-this._spacingX+d),this._context.lineTo(a-c/2+d,b-this._spacingX+d),this._context.lineTo(a-c+d,b)):(this._context.moveTo(a,b-c+d),this._context.lineTo(a+this._spacingX-d,b-c/
+2+d),this._context.lineTo(a+this._spacingX-d,b+c/2-d),this._context.lineTo(a,b+c-d),this._context.lineTo(a-this._spacingX+d,b+c/2-d),this._context.lineTo(a-this._spacingX+d,b-c/2+d),this._context.lineTo(a,b-c+d));this._context.fill()};ROT.Display.Tile=function(a){ROT.Display.Rect.call(this,a);this._options={};this._colorCanvas=document.createElement("canvas")};ROT.Display.Tile.extend(ROT.Display.Rect);
+ROT.Display.Tile.prototype.compute=function(a){this._options=a;this._context.canvas.width=a.width*a.tileWidth;this._context.canvas.height=a.height*a.tileHeight;this._colorCanvas.width=a.tileWidth;this._colorCanvas.height=a.tileHeight};
+ROT.Display.Tile.prototype.draw=function(a,b){var c=a[0],d=a[1],e=a[2],f=a[3],g=a[4],h=this._options.tileWidth,l=this._options.tileHeight;b&&(this._options.tileColorize?this._context.clearRect(c*h,d*l,h,l):(this._context.fillStyle=g,this._context.fillRect(c*h,d*l,h,l)));if(e)for(var e=[].concat(e),m=0;m<e.length;m++){var n=this._options.tileMap[e[m]];if(!n)throw Error("Char '"+e[m]+"' not found in tileMap");if(this._options.tileColorize){var q=this._colorCanvas,p=q.getContext("2d");p.clearRect(0,
+0,h,l);p.drawImage(this._options.tileSet,n[0],n[1],h,l,0,0,h,l);"transparent"!=f&&(p.fillStyle=f,p.globalCompositeOperation="source-atop",p.fillRect(0,0,h,l));"transparent"!=g&&(p.fillStyle=g,p.globalCompositeOperation="destination-over",p.fillRect(0,0,h,l));this._context.drawImage(q,c*h,d*l,h,l)}else this._context.drawImage(this._options.tileSet,n[0],n[1],h,l,c*h,d*l,h,l)}};ROT.Display.Tile.prototype.computeSize=function(a,b){return[Math.floor(a/this._options.tileWidth),Math.floor(b/this._options.tileHeight)]};
+ROT.Display.Tile.prototype.computeFontSize=function(a,b){return[Math.floor(a/this._options.width),Math.floor(b/this._options.height)]};ROT.Display.Tile.prototype.eventToPosition=function(a,b){return[Math.floor(a/this._options.tileWidth),Math.floor(b/this._options.tileHeight)]};
+ROT.RNG={getSeed:function(){return this._seed},setSeed:function(a){this._seed=a=1>a?1/a:a;this._s0=(a>>>0)*this._frac;a=69069*a+1>>>0;this._s1=a*this._frac;this._s2=(69069*a+1>>>0)*this._frac;this._c=1;return this},getUniform:function(){var a=2091639*this._s0+this._c*this._frac;this._s0=this._s1;this._s1=this._s2;this._c=a|0;return this._s2=a-this._c},getUniformInt:function(a,b){var c=Math.max(a,b),d=Math.min(a,b);return Math.floor(this.getUniform()*(c-d+1))+d},getNormal:function(a,b){do var c=2*
+this.getUniform()-1,d=2*this.getUniform()-1,d=c*c+d*d;while(1<d||0==d);return(a||0)+c*Math.sqrt(-2*Math.log(d)/d)*(b||1)},getPercentage:function(){return 1+Math.floor(100*this.getUniform())},getWeightedValue:function(a){var b=0,c;for(c in a)b+=a[c];var b=this.getUniform()*b,d=0;for(c in a)if(d+=a[c],b<d)break;return c},getState:function(){return[this._s0,this._s1,this._s2,this._c]},setState:function(a){this._s0=a[0];this._s1=a[1];this._s2=a[2];this._c=a[3];return this},clone:function(){var a=Object.create(this);
+a.setState(this.getState());return a},_s0:0,_s1:0,_s2:0,_c:0,_frac:2.3283064365386963E-10};ROT.RNG.setSeed(Date.now());ROT.StringGenerator=function(a){this._options={words:!1,order:3,prior:.001};for(var b in a)this._options[b]=a[b];this._suffix=this._boundary=String.fromCharCode(0);this._prefix=[];for(a=0;a<this._options.order;a++)this._prefix.push(this._boundary);this._priorValues={};this._priorValues[this._boundary]=this._options.prior;this._data={}};
+ROT.StringGenerator.prototype.clear=function(){this._data={};this._priorValues={}};ROT.StringGenerator.prototype.generate=function(){for(var a=[this._sample(this._prefix)];a[a.length-1]!=this._boundary;)a.push(this._sample(a));return this._join(a.slice(0,-1))};
+ROT.StringGenerator.prototype.observe=function(a){a=this._split(a);for(var b=0;b<a.length;b++)this._priorValues[a[b]]=this._options.prior;a=this._prefix.concat(a).concat(this._suffix);for(b=this._options.order;b<a.length;b++)for(var c=a.slice(b-this._options.order,b),d=a[b],e=0;e<c.length;e++){var f=c.slice(e);this._observeEvent(f,d)}};
+ROT.StringGenerator.prototype.getStats=function(){var a=[],b=0,c;for(c in this._priorValues)b++;b--;a.push("distinct samples: "+b);var d=b=0;for(c in this._data){b++;for(var e in this._data[c])d++}a.push("dictionary size (contexts): "+b);a.push("dictionary size (events): "+d);return a.join(", ")};ROT.StringGenerator.prototype._split=function(a){return a.split(this._options.words?/\s+/:"")};ROT.StringGenerator.prototype._join=function(a){return a.join(this._options.words?" ":"")};
+ROT.StringGenerator.prototype._observeEvent=function(a,b){var c=this._join(a);c in this._data||(this._data[c]={});c=this._data[c];b in c||(c[b]=0);c[b]++};ROT.StringGenerator.prototype._sample=function(a){a=this._backoff(a);a=this._join(a);a=this._data[a];var b={};if(this._options.prior){for(var c in this._priorValues)b[c]=this._priorValues[c];for(c in a)b[c]+=a[c]}else b=a;return ROT.RNG.getWeightedValue(b)};
+ROT.StringGenerator.prototype._backoff=function(a){for(a.length>this._options.order?a=a.slice(-this._options.order):a.length<this._options.order&&(a=this._prefix.slice(0,this._options.order-a.length).concat(a));!(this._join(a)in this._data)&&0<a.length;)a=a.slice(1);return a};ROT.EventQueue=function(){this._time=0;this._events=[];this._eventTimes=[]};ROT.EventQueue.prototype.getTime=function(){return this._time};ROT.EventQueue.prototype.clear=function(){this._events=[];this._eventTimes=[];return this};
+ROT.EventQueue.prototype.add=function(a,b){for(var c=this._events.length,d=0;d<this._eventTimes.length;d++)if(this._eventTimes[d]>b){c=d;break}this._events.splice(c,0,a);this._eventTimes.splice(c,0,b)};ROT.EventQueue.prototype.get=function(){if(!this._events.length)return null;var a=this._eventTimes.splice(0,1)[0];if(0<a){this._time+=a;for(var b=0;b<this._eventTimes.length;b++)this._eventTimes[b]-=a}return this._events.splice(0,1)[0]};
+ROT.EventQueue.prototype.getEventTime=function(a){a=this._events.indexOf(a);if(-1!=a)return this._eventTimes[a]};ROT.EventQueue.prototype.remove=function(a){a=this._events.indexOf(a);if(-1==a)return!1;this._remove(a);return!0};ROT.EventQueue.prototype._remove=function(a){this._events.splice(a,1);this._eventTimes.splice(a,1)};ROT.Scheduler=function(){this._queue=new ROT.EventQueue;this._repeat=[];this._current=null};ROT.Scheduler.prototype.getTime=function(){return this._queue.getTime()};
+ROT.Scheduler.prototype.add=function(a,b){b&&this._repeat.push(a);return this};ROT.Scheduler.prototype.getTimeOf=function(a){return this._queue.getEventTime(a)};ROT.Scheduler.prototype.clear=function(){this._queue.clear();this._repeat=[];this._current=null;return this};ROT.Scheduler.prototype.remove=function(a){var b=this._queue.remove(a),c=this._repeat.indexOf(a);-1!=c&&this._repeat.splice(c,1);this._current==a&&(this._current=null);return b};
+ROT.Scheduler.prototype.next=function(){return this._current=this._queue.get()};ROT.Scheduler.Simple=function(){ROT.Scheduler.call(this)};ROT.Scheduler.Simple.extend(ROT.Scheduler);ROT.Scheduler.Simple.prototype.add=function(a,b){this._queue.add(a,0);return ROT.Scheduler.prototype.add.call(this,a,b)};ROT.Scheduler.Simple.prototype.next=function(){this._current&&-1!=this._repeat.indexOf(this._current)&&this._queue.add(this._current,0);return ROT.Scheduler.prototype.next.call(this)};
+ROT.Scheduler.Speed=function(){ROT.Scheduler.call(this)};ROT.Scheduler.Speed.extend(ROT.Scheduler);ROT.Scheduler.Speed.prototype.add=function(a,b,c){this._queue.add(a,void 0!==c?c:1/a.getSpeed());return ROT.Scheduler.prototype.add.call(this,a,b)};ROT.Scheduler.Speed.prototype.next=function(){this._current&&-1!=this._repeat.indexOf(this._current)&&this._queue.add(this._current,1/this._current.getSpeed());return ROT.Scheduler.prototype.next.call(this)};
+ROT.Scheduler.Action=function(){ROT.Scheduler.call(this);this._duration=this._defaultDuration=1};ROT.Scheduler.Action.extend(ROT.Scheduler);ROT.Scheduler.Action.prototype.add=function(a,b,c){this._queue.add(a,c||this._defaultDuration);return ROT.Scheduler.prototype.add.call(this,a,b)};ROT.Scheduler.Action.prototype.clear=function(){this._duration=this._defaultDuration;return ROT.Scheduler.prototype.clear.call(this)};
+ROT.Scheduler.Action.prototype.remove=function(a){a==this._current&&(this._duration=this._defaultDuration);return ROT.Scheduler.prototype.remove.call(this,a)};ROT.Scheduler.Action.prototype.next=function(){this._current&&-1!=this._repeat.indexOf(this._current)&&(this._queue.add(this._current,this._duration||this._defaultDuration),this._duration=this._defaultDuration);return ROT.Scheduler.prototype.next.call(this)};
+ROT.Scheduler.Action.prototype.setDuration=function(a){this._current&&(this._duration=a);return this};ROT.Engine=function(a){this._scheduler=a;this._lock=1};ROT.Engine.prototype.start=function(){return this.unlock()};ROT.Engine.prototype.lock=function(){this._lock++;return this};ROT.Engine.prototype.unlock=function(){if(!this._lock)throw Error("Cannot unlock unlocked engine");for(this._lock--;!this._lock;){var a=this._scheduler.next();if(!a)return this.lock();(a=a.act())&&a.then&&(this.lock(),a.then(this.unlock.bind(this)))}return this};
+ROT.Map=function(a,b){this._width=a||ROT.DEFAULT_WIDTH;this._height=b||ROT.DEFAULT_HEIGHT};ROT.Map.prototype.create=function(a){};ROT.Map.prototype._fillMap=function(a){for(var b=[],c=0;c<this._width;c++){b.push([]);for(var d=0;d<this._height;d++)b[c].push(a)}return b};ROT.Map.Arena=function(a,b){ROT.Map.call(this,a,b)};ROT.Map.Arena.extend(ROT.Map);ROT.Map.Arena.prototype.create=function(a){for(var b=this._width-1,c=this._height-1,d=0;d<=b;d++)for(var e=0;e<=c;e++)a(d,e,d&&e&&d<b&&e<c?0:1);return this};
+ROT.Map.DividedMaze=function(a,b){ROT.Map.call(this,a,b);this._stack=[]};ROT.Map.DividedMaze.extend(ROT.Map);ROT.Map.DividedMaze.prototype.create=function(a){var b=this._width,c=this._height;this._map=[];for(var d=0;d<b;d++){this._map.push([]);for(var e=0;e<c;e++)this._map[d].push(0==d||0==e||d+1==b||e+1==c?1:0)}this._stack=[[1,1,b-2,c-2]];this._process();for(d=0;d<b;d++)for(e=0;e<c;e++)a(d,e,this._map[d][e]);this._map=null;return this};
+ROT.Map.DividedMaze.prototype._process=function(){for(;this._stack.length;){var a=this._stack.shift();this._partitionRoom(a)}};
+ROT.Map.DividedMaze.prototype._partitionRoom=function(a){for(var b=[],c=[],d=a[0]+1;d<a[2];d++){var e=this._map[d][a[3]+1];!this._map[d][a[1]-1]||!e||d%2||b.push(d)}for(d=a[1]+1;d<a[3];d++)e=this._map[a[2]+1][d],!this._map[a[0]-1][d]||!e||d%2||c.push(d);if(b.length&&c.length){b=b.random();c=c.random();this._map[b][c]=1;var e=[],f=[];e.push(f);for(d=a[0];d<b;d++)this._map[d][c]=1,f.push([d,c]);f=[];e.push(f);for(d=b+1;d<=a[2];d++)this._map[d][c]=1,f.push([d,c]);f=[];e.push(f);for(d=a[1];d<c;d++)this._map[b][d]=
+1,f.push([b,d]);f=[];e.push(f);for(d=c+1;d<=a[3];d++)this._map[b][d]=1,f.push([b,d]);for(var g=e.random(),d=0;d<e.length;d++)f=e[d],f!=g&&(f=f.random(),this._map[f[0]][f[1]]=0);this._stack.push([a[0],a[1],b-1,c-1]);this._stack.push([b+1,a[1],a[2],c-1]);this._stack.push([a[0],c+1,b-1,a[3]]);this._stack.push([b+1,c+1,a[2],a[3]])}};ROT.Map.IceyMaze=function(a,b,c){ROT.Map.call(this,a,b);this._regularity=c||0};ROT.Map.IceyMaze.extend(ROT.Map);
+ROT.Map.IceyMaze.prototype.create=function(a){var b=this._width,c=this._height,d=this._fillMap(1),b=b-(b%2?1:2),c=c-(c%2?1:2),e,f,g,h,l=0,m,n=[[0,0],[0,0],[0,0],[0,0]];do if(e=1+2*Math.floor(ROT.RNG.getUniform()*(b-1)/2),f=1+2*Math.floor(ROT.RNG.getUniform()*(c-1)/2),l||(d[e][f]=0),!d[e][f]){this._randomize(n);do{0==Math.floor(ROT.RNG.getUniform()*(this._regularity+1))&&this._randomize(n);m=!0;for(var q=0;4>q;q++)if(g=e+2*n[q][0],h=f+2*n[q][1],this._isFree(d,g,h,b,c)){d[g][h]=0;d[e+n[q][0]][f+n[q][1]]=
+0;e=g;f=h;m=!1;l++;break}}while(!m)}while(l+1<b*c/4);for(q=0;q<this._width;q++)for(b=0;b<this._height;b++)a(q,b,d[q][b]);this._map=null;return this};ROT.Map.IceyMaze.prototype._randomize=function(a){for(var b=0;4>b;b++)a[b][0]=0,a[b][1]=0;switch(Math.floor(4*ROT.RNG.getUniform())){case 0:a[0][0]=-1;a[1][0]=1;a[2][1]=-1;a[3][1]=1;break;case 1:a[3][0]=-1;a[2][0]=1;a[1][1]=-1;a[0][1]=1;break;case 2:a[2][0]=-1;a[3][0]=1;a[0][1]=-1;a[1][1]=1;break;case 3:a[1][0]=-1,a[0][0]=1,a[3][1]=-1,a[2][1]=1}};
+ROT.Map.IceyMaze.prototype._isFree=function(a,b,c,d,e){return 1>b||1>c||b>=d||c>=e?!1:a[b][c]};ROT.Map.EllerMaze=function(a,b){ROT.Map.call(this,a,b)};ROT.Map.EllerMaze.extend(ROT.Map);
+ROT.Map.EllerMaze.prototype.create=function(a){for(var b=this._fillMap(1),c=Math.ceil((this._width-2)/2),d=[],e=[],f=0;f<c;f++)d.push(f),e.push(f);d.push(c-1);for(var g=1;g+3<this._height;g+=2)for(f=0;f<c;f++){var h=2*f+1,l=g;b[h][l]=0;f!=d[f+1]&&.375<ROT.RNG.getUniform()&&(this._addToList(f,d,e),b[h+1][l]=0);f!=d[f]&&.375<ROT.RNG.getUniform()?this._removeFromList(f,d,e):b[h][l+1]=0}for(f=0;f<c;f++)h=2*f+1,l=g,b[h][l]=0,f!=d[f+1]&&(f==d[f]||.375<ROT.RNG.getUniform())&&(this._addToList(f,d,e),b[h+
+1][l]=0),this._removeFromList(f,d,e);for(f=0;f<this._width;f++)for(g=0;g<this._height;g++)a(f,g,b[f][g]);return this};ROT.Map.EllerMaze.prototype._removeFromList=function(a,b,c){c[b[a]]=c[a];b[c[a]]=b[a];c[a]=a;b[a]=a};ROT.Map.EllerMaze.prototype._addToList=function(a,b,c){c[b[a+1]]=c[a];b[c[a]]=b[a+1];c[a]=a+1;b[a+1]=a};
+ROT.Map.Cellular=function(a,b,c){ROT.Map.call(this,a,b);this._options={born:[5,6,7,8],survive:[4,5,6,7,8],topology:8};this.setOptions(c);this._dirs=ROT.DIRS[this._options.topology];this._map=this._fillMap(0)};ROT.Map.Cellular.extend(ROT.Map);ROT.Map.Cellular.prototype.randomize=function(a){for(var b=0;b<this._width;b++)for(var c=0;c<this._height;c++)this._map[b][c]=ROT.RNG.getUniform()<a?1:0;return this};ROT.Map.Cellular.prototype.setOptions=function(a){for(var b in a)this._options[b]=a[b]};
+ROT.Map.Cellular.prototype.set=function(a,b,c){this._map[a][b]=c};ROT.Map.Cellular.prototype.create=function(a){for(var b=this._fillMap(0),c=this._options.born,d=this._options.survive,e=0;e<this._height;e++){var f=1,g=0;6==this._options.topology&&(f=2,g=e%2);for(;g<this._width;g+=f){var h=this._map[g][e],l=this._getNeighbors(g,e);h&&-1!=d.indexOf(l)?b[g][e]=1:h||-1==c.indexOf(l)||(b[g][e]=1)}}this._map=b;this.serviceCallback(a)};
+ROT.Map.Cellular.prototype.serviceCallback=function(a){if(a)for(var b=0;b<this._height;b++){var c=1,d=0;6==this._options.topology&&(c=2,d=b%2);for(;d<this._width;d+=c)a(d,b,this._map[d][b])}};ROT.Map.Cellular.prototype._getNeighbors=function(a,b){for(var c=0,d=0;d<this._dirs.length;d++){var e=this._dirs[d],f=a+e[0],e=b+e[1];0>f||f>=this._width||0>e||e>=this._width||(c+=1==this._map[f][e]?1:0)}return c};
+ROT.Map.Cellular.prototype.connect=function(a,b,c){b||(b=0);for(var d=[],e={},f=0;f<this._width;f++)for(var g=0;g<this._height;g++)if(this._freeSpace(f,g,b)){var h=[f,g];e[this._pointKey(h)]=h;d.push([f,g])}h=d[ROT.RNG.getUniformInt(0,d.length-1)];f=this._pointKey(h);d={};d[f]=h;delete e[f];for(this._findConnected(d,e,[h],!1,b);0<Object.keys(e).length;){h=this._getFromTo(d,e);f=h[0];g=h[1];h={};h[this._pointKey(f)]=f;this._findConnected(h,e,[f],!0,b);this._tunnelToConnected(g,f,d,e,b,c);for(var l in h)f=
+h[l],this._map[f[0]][f[1]]=b,d[l]=f,delete e[l]}this.serviceCallback(a)};ROT.Map.Cellular.prototype._getFromTo=function(a,b){for(var c,d,e,f=Object.keys(a),g=Object.keys(b),h=0;5>h&&!(f.length<g.length?(c=f,d=a[c[ROT.RNG.getUniformInt(0,c.length-1)]],c=this._getClosest(d,b)):(c=g,c=b[c[ROT.RNG.getUniformInt(0,c.length-1)]],d=this._getClosest(c,a)),e=(c[0]-d[0])*(c[0]-d[0])+(c[1]-d[1])*(c[1]-d[1]),64>e);h++);return[c,d]};
+ROT.Map.Cellular.prototype._getClosest=function(a,b){var c=null,d=null;for(k in b){var e=b[k],f=(e[0]-a[0])*(e[0]-a[0])+(e[1]-a[1])*(e[1]-a[1]);if(null==d||f<d)d=f,c=e}return c};ROT.Map.Cellular.prototype._findConnected=function(a,b,c,d,e){for(;0<c.length;)for(var f=c.splice(0,1)[0],f=[[f[0]+1,f[1]],[f[0]-1,f[1]],[f[0],f[1]+1],[f[0],f[1]-1]],g=0;g<f.length;g++){var h=this._pointKey(f[g]);null==a[h]&&this._freeSpace(f[g][0],f[g][1],e)&&(a[h]=f[g],d||delete b[h],c.push(f[g]))}};
+ROT.Map.Cellular.prototype._tunnelToConnected=function(a,b,c,d,e,f){this._pointKey(b);var g,h;b[0]<a[0]?(g=b,h=a):(g=a,h=b);for(var l=g[0];l<=h[0];l++){this._map[l][g[1]]=e;var m=[l,g[1]],n=this._pointKey(m);c[n]=m;delete d[n]}f&&g[0]<h[0]&&f(g,[h[0],g[1]]);l=h[0];b[1]<a[1]?(g=b,h=a):(g=a,h=b);for(a=g[1];a<h[1];a++)this._map[l][a]=e,m=[l,a],n=this._pointKey(m),c[n]=m,delete d[n];f&&g[1]<h[1]&&f([h[0],g[1]],[h[0],h[1]])};
+ROT.Map.Cellular.prototype._freeSpace=function(a,b,c){return 0<=a&&a<this._width&&0<=b&&b<this._height&&this._map[a][b]==c};ROT.Map.Cellular.prototype._pointKey=function(a){return a[0]+"."+a[1]};ROT.Map.Dungeon=function(a,b){ROT.Map.call(this,a,b);this._rooms=[];this._corridors=[]};ROT.Map.Dungeon.extend(ROT.Map);ROT.Map.Dungeon.prototype.getRooms=function(){return this._rooms};ROT.Map.Dungeon.prototype.getCorridors=function(){return this._corridors};
+ROT.Map.Digger=function(a,b,c){ROT.Map.Dungeon.call(this,a,b);this._options={roomWidth:[3,9],roomHeight:[3,5],corridorLength:[3,10],dugPercentage:.2,timeLimit:1E3};for(var d in c)this._options[d]=c[d];this._features={Room:4,Corridor:4};this._featureAttempts=20;this._walls={};this._digCallback=this._digCallback.bind(this);this._canBeDugCallback=this._canBeDugCallback.bind(this);this._isWallCallback=this._isWallCallback.bind(this);this._priorityWallCallback=this._priorityWallCallback.bind(this)};ROT.Map.Digger.extend(ROT.Map.Dungeon);
+ROT.Map.Digger.prototype.create=function(a){this._rooms=[];this._corridors=[];this._map=this._fillMap(1);this._walls={};this._dug=0;var b=(this._width-2)*(this._height-2);this._firstRoom();var c=Date.now();do{if(Date.now()-c>this._options.timeLimit)break;var d=this._findWall();if(!d)break;var e=d.split(","),d=parseInt(e[0]),e=parseInt(e[1]),f=this._getDiggingDirection(d,e);if(f){var g=0;do if(g++,this._tryFeature(d,e,f[0],f[1])){this._removeSurroundingWalls(d,e);this._removeSurroundingWalls(d-f[0],
+e-f[1]);break}while(g<this._featureAttempts);var g=0,h;for(h in this._walls)1<this._walls[h]&&g++}}while(this._dug/b<this._options.dugPercentage||g);this._addDoors();if(a)for(b=0;b<this._width;b++)for(c=0;c<this._height;c++)a(b,c,this._map[b][c]);this._walls={};this._map=null;return this};ROT.Map.Digger.prototype._digCallback=function(a,b,c){0==c||2==c?(this._map[a][b]=0,this._dug++):this._walls[a+","+b]=1};
+ROT.Map.Digger.prototype._isWallCallback=function(a,b){return 0>a||0>b||a>=this._width||b>=this._height?!1:1==this._map[a][b]};ROT.Map.Digger.prototype._canBeDugCallback=function(a,b){return 1>a||1>b||a+1>=this._width||b+1>=this._height?!1:1==this._map[a][b]};ROT.Map.Digger.prototype._priorityWallCallback=function(a,b){this._walls[a+","+b]=2};
+ROT.Map.Digger.prototype._firstRoom=function(){var a=ROT.Map.Feature.Room.createRandomCenter(Math.floor(this._width/2),Math.floor(this._height/2),this._options);this._rooms.push(a);a.create(this._digCallback)};ROT.Map.Digger.prototype._findWall=function(){var a=[],b=[],c;for(c in this._walls)2==this._walls[c]?b.push(c):a.push(c);a=b.length?b:a;if(!a.length)return null;c=a.random();delete this._walls[c];return c};
+ROT.Map.Digger.prototype._tryFeature=function(a,b,c,d){var e=ROT.RNG.getWeightedValue(this._features),e=ROT.Map.Feature[e].createRandomAt(a,b,c,d,this._options);if(!e.isValid(this._isWallCallback,this._canBeDugCallback))return!1;e.create(this._digCallback);e instanceof ROT.Map.Feature.Room&&this._rooms.push(e);e instanceof ROT.Map.Feature.Corridor&&(e.createPriorityWalls(this._priorityWallCallback),this._corridors.push(e));return!0};
+ROT.Map.Digger.prototype._removeSurroundingWalls=function(a,b){for(var c=ROT.DIRS[4],d=0;d<c.length;d++){var e=c[d],f=a+e[0],g=b+e[1];delete this._walls[f+","+g];f=a+2*e[0];g=b+2*e[1];delete this._walls[f+","+g]}};ROT.Map.Digger.prototype._getDiggingDirection=function(a,b){if(0>=a||0>=b||a>=this._width-1||b>=this._height-1)return null;for(var c=null,d=ROT.DIRS[4],e=0;e<d.length;e++){var f=d[e];if(!this._map[a+f[0]][b+f[1]]){if(c)return null;c=f}}return c?[-c[0],-c[1]]:null};
+ROT.Map.Digger.prototype._addDoors=function(){for(var a=this._map,b=function(b,c){return 1==a[b][c]},c=0;c<this._rooms.length;c++){var d=this._rooms[c];d.clearDoors();d.addDoors(b)}};
+ROT.Map.Uniform=function(a,b,c){ROT.Map.Dungeon.call(this,a,b);this._options={roomWidth:[3,9],roomHeight:[3,5],roomDugPercentage:.1,timeLimit:1E3};for(var d in c)this._options[d]=c[d];this._corridorAttempts=this._roomAttempts=20;this._connected=[];this._unconnected=[];this._digCallback=this._digCallback.bind(this);this._canBeDugCallback=this._canBeDugCallback.bind(this);this._isWallCallback=this._isWallCallback.bind(this)};ROT.Map.Uniform.extend(ROT.Map.Dungeon);
+ROT.Map.Uniform.prototype.create=function(a){for(var b=Date.now();;){if(Date.now()-b>this._options.timeLimit)return null;this._map=this._fillMap(1);this._dug=0;this._rooms=[];this._unconnected=[];this._generateRooms();if(!(2>this._rooms.length)&&this._generateCorridors())break}if(a)for(b=0;b<this._width;b++)for(var c=0;c<this._height;c++)a(b,c,this._map[b][c]);return this};
+ROT.Map.Uniform.prototype._generateRooms=function(){var a=this._width-2,b=this._height-2;do{var c=this._generateRoom();if(this._dug/(a*b)>this._options.roomDugPercentage)break}while(c)};ROT.Map.Uniform.prototype._generateRoom=function(){for(var a=0;a<this._roomAttempts;){a++;var b=ROT.Map.Feature.Room.createRandom(this._width,this._height,this._options);if(b.isValid(this._isWallCallback,this._canBeDugCallback))return b.create(this._digCallback),this._rooms.push(b),b}return null};
+ROT.Map.Uniform.prototype._generateCorridors=function(){for(var a=0;a<this._corridorAttempts;){a++;this._corridors=[];this._map=this._fillMap(1);for(var b=0;b<this._rooms.length;b++){var c=this._rooms[b];c.clearDoors();c.create(this._digCallback)}this._unconnected=this._rooms.slice().randomize();this._connected=[];for(this._unconnected.length&&this._connected.push(this._unconnected.pop());;){b=this._connected.random();b=this._closestRoom(this._unconnected,b);c=this._closestRoom(this._connected,b);
+if(!this._connectRooms(b,c))break;if(!this._unconnected.length)return!0}}return!1};ROT.Map.Uniform.prototype._closestRoom=function(a,b){for(var c=Infinity,d=b.getCenter(),e=null,f=0;f<a.length;f++){var g=a[f],h=g.getCenter(),l=h[0]-d[0],h=h[1]-d[1],l=l*l+h*h;l<c&&(c=l,e=g)}return e};
+ROT.Map.Uniform.prototype._connectRooms=function(a,b){var c=a.getCenter(),d=b.getCenter(),e=d[0]-c[0],c=d[1]-c[1];if(Math.abs(e)<Math.abs(c))var c=0<c?2:0,f=(c+2)%4,g=b.getLeft(),h=b.getRight(),e=0;else c=0<e?1:3,f=(c+2)%4,g=b.getTop(),h=b.getBottom(),e=1;c=this._placeInWall(a,c);if(!c)return!1;if(c[e]>=g&&c[e]<=h){var l=c.slice(),d=null;switch(f){case 0:d=b.getTop()-1;break;case 1:d=b.getRight()+1;break;case 2:d=b.getBottom()+1;break;case 3:d=b.getLeft()-1}l[(e+1)%2]=d;this._digLine([c,l])}else if(c[e]<
+g-1||c[e]>h+1){d=c[e]-d[e];switch(f){case 0:case 1:l=0>d?3:1;break;case 2:case 3:l=0>d?1:3}l=this._placeInWall(b,(f+l)%4);if(!l)return!1;f=[0,0];f[e]=c[e];d=(e+1)%2;f[d]=l[d];this._digLine([c,f,l])}else{d=(e+1)%2;l=this._placeInWall(b,f);if(!l)return!1;f=Math.round((l[d]+c[d])/2);g=[0,0];h=[0,0];g[e]=c[e];g[d]=f;h[e]=l[e];h[d]=f;this._digLine([c,g,h,l])}a.addDoor(c[0],c[1]);b.addDoor(l[0],l[1]);e=this._unconnected.indexOf(a);-1!=e&&(this._unconnected.splice(e,1),this._connected.push(a));e=this._unconnected.indexOf(b);
+-1!=e&&(this._unconnected.splice(e,1),this._connected.push(b));return!0};
+ROT.Map.Uniform.prototype._placeInWall=function(a,b){var c=[0,0],d=[0,0],e=0;switch(b){case 0:d=[1,0];c=[a.getLeft(),a.getTop()-1];e=a.getRight()-a.getLeft()+1;break;case 1:d=[0,1];c=[a.getRight()+1,a.getTop()];e=a.getBottom()-a.getTop()+1;break;case 2:d=[1,0];c=[a.getLeft(),a.getBottom()+1];e=a.getRight()-a.getLeft()+1;break;case 3:d=[0,1],c=[a.getLeft()-1,a.getTop()],e=a.getBottom()-a.getTop()+1}for(var f=[],g=-2,h=0;h<e;h++){var l=c[0]+h*d[0],m=c[1]+h*d[1];f.push(null);1==this._map[l][m]?g!=h-
+1&&(f[h]=[l,m]):(g=h)&&(f[h-1]=null)}for(h=f.length-1;0<=h;h--)f[h]||f.splice(h,1);return f.length?f.random():null};ROT.Map.Uniform.prototype._digLine=function(a){for(var b=1;b<a.length;b++){var c=a[b-1],d=a[b],c=new ROT.Map.Feature.Corridor(c[0],c[1],d[0],d[1]);c.create(this._digCallback);this._corridors.push(c)}};ROT.Map.Uniform.prototype._digCallback=function(a,b,c){this._map[a][b]=c;0==c&&this._dug++};
+ROT.Map.Uniform.prototype._isWallCallback=function(a,b){return 0>a||0>b||a>=this._width||b>=this._height?!1:1==this._map[a][b]};ROT.Map.Uniform.prototype._canBeDugCallback=function(a,b){return 1>a||1>b||a+1>=this._width||b+1>=this._height?!1:1==this._map[a][b]};
+ROT.Map.Rogue=function(a,b,c){ROT.Map.call(this,a,b);this._options={cellWidth:3,cellHeight:3};for(var d in c)this._options[d]=c[d];this._options.hasOwnProperty("roomWidth")||(this._options.roomWidth=this._calculateRoomSize(this._width,this._options.cellWidth));this._options.hasOwnProperty("roomHeight")||(this._options.roomHeight=this._calculateRoomSize(this._height,this._options.cellHeight))};ROT.Map.Rogue.extend(ROT.Map);
+ROT.Map.Rogue.prototype.create=function(a){this.map=this._fillMap(1);this.rooms=[];this.connectedCells=[];this._initRooms();this._connectRooms();this._connectUnconnectedRooms();this._createRandomRoomConnections();this._createRooms();this._createCorridors();if(a)for(var b=0;b<this._width;b++)for(var c=0;c<this._height;c++)a(b,c,this.map[b][c]);return this};ROT.Map.Rogue.prototype._calculateRoomSize=function(a,b){var c=Math.floor(a/b*.8),d=Math.floor(a/b*.25);2>d&&(d=2);2>c&&(c=2);return[d,c]};
+ROT.Map.Rogue.prototype._initRooms=function(){for(var a=0;a<this._options.cellWidth;a++){this.rooms.push([]);for(var b=0;b<this._options.cellHeight;b++)this.rooms[a].push({x:0,y:0,width:0,height:0,connections:[],cellx:a,celly:b})}};
+ROT.Map.Rogue.prototype._connectRooms=function(){var a=ROT.RNG.getUniformInt(0,this._options.cellWidth-1),b=ROT.RNG.getUniformInt(0,this._options.cellHeight-1),c,d,e,f;do{var g=[0,2,4,6],g=g.randomize();do if(e=!1,c=g.pop(),d=a+ROT.DIRS[8][c][0],c=b+ROT.DIRS[8][c][1],!(0>d||d>=this._options.cellWidth||0>c||c>=this._options.cellHeight)){f=this.rooms[a][b];if(0<f.connections.length&&f.connections[0][0]==d&&f.connections[0][1]==c)break;f=this.rooms[d][c];0==f.connections.length&&(f.connections.push([a,
+b]),this.connectedCells.push([d,c]),a=d,b=c,e=!0)}while(0<g.length&&0==e)}while(0<g.length)};
+ROT.Map.Rogue.prototype._connectUnconnectedRooms=function(){var a=this._options.cellWidth,b=this._options.cellHeight;this.connectedCells=this.connectedCells.randomize();for(var c,d,e,f=0;f<this._options.cellWidth;f++)for(var g=0;g<this._options.cellHeight;g++)if(c=this.rooms[f][g],0==c.connections.length){var h=[0,2,4,6],h=h.randomize();e=!1;do{var l=h.pop(),m=f+ROT.DIRS[8][l][0],l=g+ROT.DIRS[8][l][1];if(!(0>m||m>=a||0>l||l>=b)){d=this.rooms[m][l];e=!0;if(0==d.connections.length)break;for(m=0;m<d.connections.length;m++)if(d.connections[m][0]==
+f&&d.connections[m][1]==g){e=!1;break}if(e)break}}while(h.length);e?c.connections.push([d.cellx,d.celly]):console.log("-- Unable to connect room.")}};ROT.Map.Rogue.prototype._createRandomRoomConnections=function(a){};
+ROT.Map.Rogue.prototype._createRooms=function(){for(var a=this._width,b=this._height,c=this._options.cellWidth,d=this._options.cellHeight,e=Math.floor(this._width/c),f=Math.floor(this._height/d),g,h,l=this._options.roomWidth,m=this._options.roomHeight,n,q,p,r=0;r<c;r++)for(var t=0;t<d;t++){n=e*r;q=f*t;0==n&&(n=1);0==q&&(q=1);g=ROT.RNG.getUniformInt(l[0],l[1]);h=ROT.RNG.getUniformInt(m[0],m[1]);if(0<t)for(p=this.rooms[r][t-1];3>q-(p.y+p.height);)q++;if(0<r)for(p=this.rooms[r-1][t];3>n-(p.x+p.width);)n++;
+p=Math.round(ROT.RNG.getUniformInt(0,e-g)/2);for(var u=Math.round(ROT.RNG.getUniformInt(0,f-h)/2);n+p+g>=a;)p?p--:g--;for(;q+u+h>=b;)u?u--:h--;n+=p;q+=u;this.rooms[r][t].x=n;this.rooms[r][t].y=q;this.rooms[r][t].width=g;this.rooms[r][t].height=h;for(p=n;p<n+g;p++)for(u=q;u<q+h;u++)this.map[p][u]=0}};
+ROT.Map.Rogue.prototype._getWallPosition=function(a,b){var c,d,e;if(1==b||3==b)c=ROT.RNG.getUniformInt(a.x+1,a.x+a.width-2),1==b?(d=a.y-2,e=d+1):(d=a.y+a.height+1,e=d-1),this.map[c][e]=0;else if(2==b||4==b)d=ROT.RNG.getUniformInt(a.y+1,a.y+a.height-2),2==b?(c=a.x+a.width+1,e=c-1):(c=a.x-2,e=c+1),this.map[e][d]=0;return[c,d]};
+ROT.Map.Rogue.prototype._drawCorridor=function(a,b){var c=b[0]-a[0],d=b[1]-a[1],e=a[0],f=a[1],g,h,l=[];h=Math.abs(c);var m=Math.abs(d);g=ROT.RNG.getUniform();var n=1-g,c=0<c?2:6,d=0<d?4:0;h<m?(g=Math.ceil(m*g),l.push([d,g]),l.push([c,h]),g=Math.floor(m*n),l.push([d,g])):(g=Math.ceil(h*g),l.push([c,g]),l.push([d,m]),g=Math.floor(h*n),l.push([c,g]));for(this.map[e][f]=0;0<l.length;)for(h=l.pop();0<h[1];)e+=ROT.DIRS[8][h[0]][0],f+=ROT.DIRS[8][h[0]][1],this.map[e][f]=0,--h[1]};
+ROT.Map.Rogue.prototype._createCorridors=function(){for(var a=this._options.cellWidth,b=this._options.cellHeight,c,d,e,f,g=0;g<a;g++)for(var h=0;h<b;h++){c=this.rooms[g][h];for(var l=0;l<c.connections.length;l++)d=c.connections[l],d=this.rooms[d[0]][d[1]],d.cellx>c.cellx?(e=2,f=4):d.cellx<c.cellx?(e=4,f=2):d.celly>c.celly?(e=3,f=1):d.celly<c.celly&&(e=1,f=3),this._drawCorridor(this._getWallPosition(c,e),this._getWallPosition(d,f))}};ROT.Map.Feature=function(){};ROT.Map.Feature.prototype.isValid=function(a){};
+ROT.Map.Feature.prototype.create=function(a){};ROT.Map.Feature.prototype.debug=function(){};ROT.Map.Feature.createRandomAt=function(a,b,c,d,e){};ROT.Map.Feature.Room=function(a,b,c,d,e,f){this._x1=a;this._y1=b;this._x2=c;this._y2=d;this._doors={};4<arguments.length&&this.addDoor(e,f)};ROT.Map.Feature.Room.extend(ROT.Map.Feature);
+ROT.Map.Feature.Room.createRandomAt=function(a,b,c,d,e){var f=e.roomWidth[0],g=e.roomWidth[1],h=ROT.RNG.getUniformInt(f,g),f=e.roomHeight[0],g=e.roomHeight[1];e=ROT.RNG.getUniformInt(f,g);if(1==c)return c=b-Math.floor(ROT.RNG.getUniform()*e),new this(a+1,c,a+h,c+e-1,a,b);if(-1==c)return c=b-Math.floor(ROT.RNG.getUniform()*e),new this(a-h,c,a-1,c+e-1,a,b);if(1==d)return c=a-Math.floor(ROT.RNG.getUniform()*h),new this(c,b+1,c+h-1,b+e,a,b);if(-1==d)return c=a-Math.floor(ROT.RNG.getUniform()*h),new this(c,
+b-e,c+h-1,b-1,a,b);throw Error("dx or dy must be 1 or -1");};ROT.Map.Feature.Room.createRandomCenter=function(a,b,c){var d=c.roomWidth[0],e=c.roomWidth[1],f=ROT.RNG.getUniformInt(d,e),d=c.roomHeight[0],e=c.roomHeight[1];c=ROT.RNG.getUniformInt(d,e);a-=Math.floor(ROT.RNG.getUniform()*f);b-=Math.floor(ROT.RNG.getUniform()*c);return new this(a,b,a+f-1,b+c-1)};
+ROT.Map.Feature.Room.createRandom=function(a,b,c){var d=c.roomWidth[0],e=c.roomWidth[1],f=ROT.RNG.getUniformInt(d,e),d=c.roomHeight[0],e=c.roomHeight[1];c=ROT.RNG.getUniformInt(d,e);a=a-f-1;b=b-c-1;a=1+Math.floor(ROT.RNG.getUniform()*a);b=1+Math.floor(ROT.RNG.getUniform()*b);return new this(a,b,a+f-1,b+c-1)};ROT.Map.Feature.Room.prototype.addDoor=function(a,b){this._doors[a+","+b]=1;return this};
+ROT.Map.Feature.Room.prototype.getDoors=function(a){for(var b in this._doors){var c=b.split(",");a(parseInt(c[0]),parseInt(c[1]))}return this};ROT.Map.Feature.Room.prototype.clearDoors=function(){this._doors={};return this};ROT.Map.Feature.Room.prototype.addDoors=function(a){for(var b=this._x1-1,c=this._x2+1,d=this._y1-1,e=this._y2+1,f=b;f<=c;f++)for(var g=d;g<=e;g++)if(f==b||f==c||g==d||g==e)a(f,g)||this.addDoor(f,g);return this};
+ROT.Map.Feature.Room.prototype.debug=function(){console.log("room",this._x1,this._y1,this._x2,this._y2)};ROT.Map.Feature.Room.prototype.isValid=function(a,b){for(var c=this._x1-1,d=this._x2+1,e=this._y1-1,f=this._y2+1,g=c;g<=d;g++)for(var h=e;h<=f;h++)if(g==c||g==d||h==e||h==f){if(!a(g,h))return!1}else if(!b(g,h))return!1;return!0};
+ROT.Map.Feature.Room.prototype.create=function(a){for(var b=this._x1-1,c=this._x2+1,d=this._y1-1,e=this._y2+1,f,g=b;g<=c;g++)for(var h=d;h<=e;h++)f=g+","+h in this._doors?2:g==b||g==c||h==d||h==e?1:0,a(g,h,f)};ROT.Map.Feature.Room.prototype.getCenter=function(){return[Math.round((this._x1+this._x2)/2),Math.round((this._y1+this._y2)/2)]};ROT.Map.Feature.Room.prototype.getLeft=function(){return this._x1};ROT.Map.Feature.Room.prototype.getRight=function(){return this._x2};
+ROT.Map.Feature.Room.prototype.getTop=function(){return this._y1};ROT.Map.Feature.Room.prototype.getBottom=function(){return this._y2};ROT.Map.Feature.Corridor=function(a,b,c,d){this._startX=a;this._startY=b;this._endX=c;this._endY=d;this._endsWithAWall=!0};ROT.Map.Feature.Corridor.extend(ROT.Map.Feature);ROT.Map.Feature.Corridor.createRandomAt=function(a,b,c,d,e){e=ROT.RNG.getUniformInt(e.corridorLength[0],e.corridorLength[1]);return new this(a,b,a+c*e,b+d*e)};
+ROT.Map.Feature.Corridor.prototype.debug=function(){console.log("corridor",this._startX,this._startY,this._endX,this._endY)};
+ROT.Map.Feature.Corridor.prototype.isValid=function(a,b){var c=this._startX,d=this._startY,e=this._endX-c,f=this._endY-d,g=1+Math.max(Math.abs(e),Math.abs(f));e&&(e/=Math.abs(e));f&&(f/=Math.abs(f));for(var h=f,l=-e,m=!0,n=0;n<g;n++){var q=c+n*e,p=d+n*f;b(q,p)||(m=!1);a(q+h,p+l)||(m=!1);a(q-h,p-l)||(m=!1);if(!m){g=n;this._endX=q-e;this._endY=p-f;break}}if(0==g||1==g&&a(this._endX+e,this._endY+f))return!1;c=!a(this._endX+e+h,this._endY+f+l);h=!a(this._endX+e-h,this._endY+f-l);this._endsWithAWall=a(this._endX+
+e,this._endY+f);return(c||h)&&this._endsWithAWall?!1:!0};ROT.Map.Feature.Corridor.prototype.create=function(a){var b=this._startX,c=this._startY,d=this._endX-b,e=this._endY-c,f=1+Math.max(Math.abs(d),Math.abs(e));d&&(d/=Math.abs(d));e&&(e/=Math.abs(e));for(var g=0;g<f;g++)a(b+g*d,c+g*e,0);return!0};
+ROT.Map.Feature.Corridor.prototype.createPriorityWalls=function(a){if(this._endsWithAWall){var b=this._endX-this._startX,c=this._endY-this._startY;b&&(b/=Math.abs(b));c&&(c/=Math.abs(c));var d=c,e=-b;a(this._endX+b,this._endY+c);a(this._endX+d,this._endY+e);a(this._endX-d,this._endY-e)}};ROT.Noise=function(){};ROT.Noise.prototype.get=function(a,b){};
+ROT.Noise.Simplex=function(a){ROT.Noise.call(this);this._F2=.5*(Math.sqrt(3)-1);this._G2=(3-Math.sqrt(3))/6;this._gradients=[[0,-1],[1,-1],[1,0],[1,1],[0,1],[-1,1],[-1,0],[-1,-1]];var b=[];a=a||256;for(var c=0;c<a;c++)b.push(c);b=b.randomize();this._perms=[];this._indexes=[];for(c=0;c<2*a;c++)this._perms.push(b[c%a]),this._indexes.push(this._perms[c]%this._gradients.length)};ROT.Noise.Simplex.extend(ROT.Noise);
+ROT.Noise.Simplex.prototype.get=function(a,b){var c=this._perms,d=this._indexes,e=c.length/2,f=this._G2,g=0,h=0,l=0,m,n=(a+b)*this._F2,q=Math.floor(a+n);m=Math.floor(b+n);var n=(q+m)*f,p=a-(q-n),r=b-(m-n),t,u;p>r?(t=1,u=0):(t=0,u=1);var w=p-t+f,x=r-u+f,n=p-1+2*f,f=r-1+2*f,q=q.mod(e),e=m.mod(e),v=.5-p*p-r*r;0<=v&&(v*=v,m=d[q+c[e]],m=this._gradients[m],g=v*v*(m[0]*p+m[1]*r));p=.5-w*w-x*x;0<=p&&(p*=p,m=d[q+t+c[e+u]],m=this._gradients[m],h=p*p*(m[0]*w+m[1]*x));p=.5-n*n-f*f;0<=p&&(p*=p,m=d[q+1+c[e+1]],
+m=this._gradients[m],l=p*p*(m[0]*n+m[1]*f));return 70*(g+h+l)};ROT.FOV=function(a,b){this._lightPasses=a;this._options={topology:8};for(var c in b)this._options[c]=b[c]};ROT.FOV.prototype.compute=function(a,b,c,d){};
+ROT.FOV.prototype._getCircle=function(a,b,c){var d=[],e,f,g;switch(this._options.topology){case 4:f=1;g=[0,1];e=[ROT.DIRS[8][7],ROT.DIRS[8][1],ROT.DIRS[8][3],ROT.DIRS[8][5]];break;case 6:e=ROT.DIRS[6];f=1;g=[-1,1];break;case 8:e=ROT.DIRS[4],f=2,g=[-1,1]}a+=g[0]*c;b+=g[1]*c;for(g=0;g<e.length;g++)for(var h=0;h<c*f;h++)d.push([a,b]),a+=e[g][0],b+=e[g][1];return d};ROT.FOV.DiscreteShadowcasting=function(a,b){ROT.FOV.call(this,a,b)};ROT.FOV.DiscreteShadowcasting.extend(ROT.FOV);
+ROT.FOV.DiscreteShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0,1);if(this._lightPasses(a,b))for(var e=[],f,g,h,l,m,n=1;n<=c;n++)for(var q=this._getCircle(a,b,n),p=360/q.length,r=0;r<q.length;r++)if(h=q[r][0],l=q[r][1],f=p*(r-.5),g=f+p,m=!this._lightPasses(h,l),this._visibleCoords(Math.floor(f),Math.ceil(g),m,e)&&d(h,l,n,1),2==e.length&&0==e[0]&&360==e[1])return};
+ROT.FOV.DiscreteShadowcasting.prototype._visibleCoords=function(a,b,c,d){if(0>a){var e=arguments.callee(0,b,c,d),f=arguments.callee(360+a,360,c,d);return e||f}for(e=0;e<d.length&&d[e]<a;)e++;if(e==d.length)return c&&d.push(a,b),!0;f=0;if(e%2){for(;e<d.length&&d[e]<b;)e++,f++;if(0==f)return!1;c&&(f%2?d.splice(e-f,f,b):d.splice(e-f,f))}else{for(;e<d.length&&d[e]<b;)e++,f++;if(a==d[e-f]&&1==f)return!1;c&&(f%2?d.splice(e-f,f,a):d.splice(e-f,f,a,b))}return!0};
+ROT.FOV.PreciseShadowcasting=function(a,b){ROT.FOV.call(this,a,b)};ROT.FOV.PreciseShadowcasting.extend(ROT.FOV);ROT.FOV.PreciseShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0,1);if(this._lightPasses(a,b))for(var e=[],f,g,h,l,m,n=1;n<=c;n++)for(var q=this._getCircle(a,b,n),p=q.length,r=0;r<p;r++)if(f=q[r][0],g=q[r][1],l=[r?2*r-1:2*p-1,2*p],m=[2*r+1,2*p],h=!this._lightPasses(f,g),(h=this._checkVisibility(l,m,h,e))&&d(f,g,n,h),2==e.length&&0==e[0][0]&&e[1][0]==e[1][1])return};
+ROT.FOV.PreciseShadowcasting.prototype._checkVisibility=function(a,b,c,d){if(a[0]>b[0])return a=this._checkVisibility(a,[a[1],a[1]],c,d),b=this._checkVisibility([0,1],b,c,d),(a+b)/2;for(var e=0,f=!1;e<d.length;){var g=d[e],g=g[0]*a[1]-a[0]*g[1];if(0<=g){0!=g||e%2||(f=!0);break}e++}for(var h=d.length,l=!1;h--;)if(g=d[h],g=b[0]*g[1]-g[0]*b[1],0<=g){0==g&&h%2&&(l=!0);break}g=!0;e==h&&(f||l)?g=!1:f&&l&&e+1==h&&h%2?g=!1:e>h&&e%2&&(g=!1);if(!g)return 0;f=h-e+1;if(f%2)e%2?(h=d[e],h=(b[0]*h[1]-h[0]*b[1])/
+(h[1]*b[1]),c&&d.splice(e,f,b)):(h=d[h],h=(h[0]*a[1]-a[0]*h[1])/(a[1]*h[1]),c&&d.splice(e,f,a));else if(e%2)l=d[e],h=d[h],h=(h[0]*l[1]-l[0]*h[1])/(l[1]*h[1]),c&&d.splice(e,f);else return c&&d.splice(e,f,a,b),1;return h/((b[0]*a[1]-a[0]*b[1])/(a[1]*b[1]))};ROT.FOV.RecursiveShadowcasting=function(a,b){ROT.FOV.call(this,a,b)};ROT.FOV.RecursiveShadowcasting.extend(ROT.FOV);ROT.FOV.RecursiveShadowcasting.OCTANTS=[[-1,0,0,1],[0,-1,1,0],[0,-1,-1,0],[-1,0,0,-1],[1,0,0,-1],[0,1,-1,0],[0,1,1,0],[1,0,0,1]];
+ROT.FOV.RecursiveShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0,1);for(var e=0;e<ROT.FOV.RecursiveShadowcasting.OCTANTS.length;e++)this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[e],c,d)};
+ROT.FOV.RecursiveShadowcasting.prototype.compute180=function(a,b,c,d,e){e(a,b,0,1);var f=(d-1+8)%8,g=(d+1+8)%8;this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[(d-2+8)%8],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[f],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[d],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[g],c,e)};
+ROT.FOV.RecursiveShadowcasting.prototype.compute90=function(a,b,c,d,e){e(a,b,0,1);var f=(d-1+8)%8;this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[d],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[f],c,e)};ROT.FOV.RecursiveShadowcasting.prototype._renderOctant=function(a,b,c,d,e){this._castVisibility(a,b,1,1,0,d+1,c[0],c[1],c[2],c[3],e)};
+ROT.FOV.RecursiveShadowcasting.prototype._castVisibility=function(a,b,c,d,e,f,g,h,l,m,n){if(!(d<e))for(;c<=f;c++){for(var q=-c-1,p=-c,r=!1,t=0;0>=q;){var q=q+1,u=a+q*g+p*h,w=b+q*l+p*m,x=(q-.5)/(p+.5),v=(q+.5)/(p-.5);if(!(v>d)){if(x<e)break;q*q+p*p<f*f&&n(u,w,c,1);r?this._lightPasses(u,w)?(r=!1,d=t):t=v:!this._lightPasses(u,w)&&c<f&&(r=!0,this._castVisibility(a,b,c+1,d,x,f,g,h,l,m,n),t=v)}}if(r)break}};
+ROT.Color={fromString:function(a){var b,c;if(a in this._cache)b=this._cache[a];else{if("#"==a.charAt(0))if(b=a.match(/[0-9a-f]/gi).map(function(a){return parseInt(a,16)}),3==b.length)b=b.map(function(a){return 17*a});else for(c=0;3>c;c++)b[c+1]+=16*b[c],b.splice(c,1);else b=(c=a.match(/rgb\(([0-9, ]+)\)/i))?c[1].split(/\s*,\s*/).map(function(a){return parseInt(a)}):[0,0,0];this._cache[a]=b}return b.slice()},add:function(a,b){for(var c=a.slice(),d=0;3>d;d++)for(var e=1;e<arguments.length;e++)c[d]+=
+arguments[e][d];return c},add_:function(a,b){for(var c=0;3>c;c++)for(var d=1;d<arguments.length;d++)a[c]+=arguments[d][c];return a},multiply:function(a,b){for(var c=a.slice(),d=0;3>d;d++){for(var e=1;e<arguments.length;e++)c[d]*=arguments[e][d]/255;c[d]=Math.round(c[d])}return c},multiply_:function(a,b){for(var c=0;3>c;c++){for(var d=1;d<arguments.length;d++)a[c]*=arguments[d][c]/255;a[c]=Math.round(a[c])}return a},interpolate:function(a,b,c){3>arguments.length&&(c=.5);for(var d=a.slice(),e=0;3>e;e++)d[e]=
+Math.round(d[e]+c*(b[e]-a[e]));return d},interpolateHSL:function(a,b,c){3>arguments.length&&(c=.5);for(var d=this.rgb2hsl(a),e=this.rgb2hsl(b),f=0;3>f;f++)d[f]+=c*(e[f]-d[f]);return this.hsl2rgb(d)},randomize:function(a,b){b instanceof Array||(b=Math.round(ROT.RNG.getNormal(0,b)));for(var c=a.slice(),d=0;3>d;d++)c[d]+=b instanceof Array?Math.round(ROT.RNG.getNormal(0,b[d])):b;return c},rgb2hsl:function(a){var b=a[0]/255,c=a[1]/255;a=a[2]/255;var d=Math.max(b,c,a),e=Math.min(b,c,a),f,g=(d+e)/2;if(d==
+e)f=e=0;else{var h=d-e,e=.5<g?h/(2-d-e):h/(d+e);switch(d){case b:f=(c-a)/h+(c<a?6:0);break;case c:f=(a-b)/h+2;break;case a:f=(b-c)/h+4}f/=6}return[f,e,g]},hsl2rgb:function(a){var b=a[2];if(0==a[1])return b=Math.round(255*b),[b,b,b];var c=function(a,b,c){0>c&&(c+=1);1<c&&--c;return c<1/6?a+6*(b-a)*c:.5>c?b:c<2/3?a+(b-a)*(2/3-c)*6:a},d=a[1],d=.5>b?b*(1+d):b+d-b*d,e=2*b-d,b=c(e,d,a[0]+1/3),f=c(e,d,a[0]);a=c(e,d,a[0]-1/3);return[Math.round(255*b),Math.round(255*f),Math.round(255*a)]},toRGB:function(a){return"rgb("+
+this._clamp(a[0])+","+this._clamp(a[1])+","+this._clamp(a[2])+")"},toHex:function(a){for(var b=[],c=0;3>c;c++)b.push(this._clamp(a[c]).toString(16).lpad("0",2));return"#"+b.join("")},_clamp:function(a){return 0>a?0:255<a?255:a},_cache:{black:[0,0,0],navy:[0,0,128],darkblue:[0,0,139],mediumblue:[0,0,205],blue:[0,0,255],darkgreen:[0,100,0],green:[0,128,0],teal:[0,128,128],darkcyan:[0,139,139],deepskyblue:[0,191,255],darkturquoise:[0,206,209],mediumspringgreen:[0,250,154],lime:[0,255,0],springgreen:[0,
+255,127],aqua:[0,255,255],cyan:[0,255,255],midnightblue:[25,25,112],dodgerblue:[30,144,255],forestgreen:[34,139,34],seagreen:[46,139,87],darkslategray:[47,79,79],darkslategrey:[47,79,79],limegreen:[50,205,50],mediumseagreen:[60,179,113],turquoise:[64,224,208],royalblue:[65,105,225],steelblue:[70,130,180],darkslateblue:[72,61,139],mediumturquoise:[72,209,204],indigo:[75,0,130],darkolivegreen:[85,107,47],cadetblue:[95,158,160],cornflowerblue:[100,149,237],mediumaquamarine:[102,205,170],dimgray:[105,
+105,105],dimgrey:[105,105,105],slateblue:[106,90,205],olivedrab:[107,142,35],slategray:[112,128,144],slategrey:[112,128,144],lightslategray:[119,136,153],lightslategrey:[119,136,153],mediumslateblue:[123,104,238],lawngreen:[124,252,0],chartreuse:[127,255,0],aquamarine:[127,255,212],maroon:[128,0,0],purple:[128,0,128],olive:[128,128,0],gray:[128,128,128],grey:[128,128,128],skyblue:[135,206,235],lightskyblue:[135,206,250],blueviolet:[138,43,226],darkred:[139,0,0],darkmagenta:[139,0,139],saddlebrown:[139,
+69,19],darkseagreen:[143,188,143],lightgreen:[144,238,144],mediumpurple:[147,112,216],darkviolet:[148,0,211],palegreen:[152,251,152],darkorchid:[153,50,204],yellowgreen:[154,205,50],sienna:[160,82,45],brown:[165,42,42],darkgray:[169,169,169],darkgrey:[169,169,169],lightblue:[173,216,230],greenyellow:[173,255,47],paleturquoise:[175,238,238],lightsteelblue:[176,196,222],powderblue:[176,224,230],firebrick:[178,34,34],darkgoldenrod:[184,134,11],mediumorchid:[186,85,211],rosybrown:[188,143,143],darkkhaki:[189,
+183,107],silver:[192,192,192],mediumvioletred:[199,21,133],indianred:[205,92,92],peru:[205,133,63],chocolate:[210,105,30],tan:[210,180,140],lightgray:[211,211,211],lightgrey:[211,211,211],palevioletred:[216,112,147],thistle:[216,191,216],orchid:[218,112,214],goldenrod:[218,165,32],crimson:[220,20,60],gainsboro:[220,220,220],plum:[221,160,221],burlywood:[222,184,135],lightcyan:[224,255,255],lavender:[230,230,250],darksalmon:[233,150,122],violet:[238,130,238],palegoldenrod:[238,232,170],lightcoral:[240,
+128,128],khaki:[240,230,140],aliceblue:[240,248,255],honeydew:[240,255,240],azure:[240,255,255],sandybrown:[244,164,96],wheat:[245,222,179],beige:[245,245,220],whitesmoke:[245,245,245],mintcream:[245,255,250],ghostwhite:[248,248,255],salmon:[250,128,114],antiquewhite:[250,235,215],linen:[250,240,230],lightgoldenrodyellow:[250,250,210],oldlace:[253,245,230],red:[255,0,0],fuchsia:[255,0,255],magenta:[255,0,255],deeppink:[255,20,147],orangered:[255,69,0],tomato:[255,99,71],hotpink:[255,105,180],coral:[255,
+127,80],darkorange:[255,140,0],lightsalmon:[255,160,122],orange:[255,165,0],lightpink:[255,182,193],pink:[255,192,203],gold:[255,215,0],peachpuff:[255,218,185],navajowhite:[255,222,173],moccasin:[255,228,181],bisque:[255,228,196],mistyrose:[255,228,225],blanchedalmond:[255,235,205],papayawhip:[255,239,213],lavenderblush:[255,240,245],seashell:[255,245,238],cornsilk:[255,248,220],lemonchiffon:[255,250,205],floralwhite:[255,250,240],snow:[255,250,250],yellow:[255,255,0],lightyellow:[255,255,224],ivory:[255,
+255,240],white:[255,255,255]}};ROT.Lighting=function(a,b){this._reflectivityCallback=a;this._options={passes:1,emissionThreshold:100,range:10};this._fov=null;this._lights={};this._reflectivityCache={};this._fovCache={};this.setOptions(b)};ROT.Lighting.prototype.setOptions=function(a){for(var b in a)this._options[b]=a[b];a&&a.range&&this.reset();return this};ROT.Lighting.prototype.setFOV=function(a){this._fov=a;this._fovCache={};return this};
+ROT.Lighting.prototype.setLight=function(a,b,c){a=a+","+b;c?this._lights[a]="string"==typeof c?ROT.Color.fromString(c):c:delete this._lights[a];return this};ROT.Lighting.prototype.clearLights=function(){this._lights={}};ROT.Lighting.prototype.reset=function(){this._reflectivityCache={};this._fovCache={};return this};
+ROT.Lighting.prototype.compute=function(a){var b={},c={},d={},e;for(e in this._lights){var f=this._lights[e];c[e]=[0,0,0];ROT.Color.add_(c[e],f)}for(e=0;e<this._options.passes;e++)this._emitLight(c,d,b),e+1!=this._options.passes&&(c=this._computeEmitters(d,b));for(var g in d)c=g.split(","),b=parseInt(c[0]),c=parseInt(c[1]),a(b,c,d[g]);return this};
+ROT.Lighting.prototype._emitLight=function(a,b,c){for(var d in a){var e=d.split(","),f=parseInt(e[0]),e=parseInt(e[1]);this._emitLightFromCell(f,e,a[d],b);c[d]=1}return this};
+ROT.Lighting.prototype._computeEmitters=function(a,b){var c={},d;for(d in a)if(!(d in b)){var e=a[d];if(d in this._reflectivityCache)var f=this._reflectivityCache[d];else{var g=d.split(","),f=parseInt(g[0]),g=parseInt(g[1]),f=this._reflectivityCallback(f,g);this._reflectivityCache[d]=f}if(0!=f){for(var g=[],h=0,l=0;3>l;l++){var m=Math.round(e[l]*f);g[l]=m;h+=m}h>this._options.emissionThreshold&&(c[d]=g)}}return c};
+ROT.Lighting.prototype._emitLightFromCell=function(a,b,c,d){var e=a+","+b;a=e in this._fovCache?this._fovCache[e]:this._updateFOV(a,b);for(var f in a){b=a[f];f in d?e=d[f]:(e=[0,0,0],d[f]=e);for(var g=0;3>g;g++)e[g]+=Math.round(c[g]*b)}return this};ROT.Lighting.prototype._updateFOV=function(a,b){var c={};this._fovCache[a+","+b]=c;var d=this._options.range;this._fov.compute(a,b,d,function(a,b,g,h){g=h*(1-g/d);0!=g&&(c[a+","+b]=g)}.bind(this));return c};
+ROT.Path=function(a,b,c,d){this._toX=a;this._toY=b;this._fromY=this._fromX=null;this._passableCallback=c;this._options={topology:8};for(var e in d)this._options[e]=d[e];this._dirs=ROT.DIRS[this._options.topology];8==this._options.topology&&(this._dirs=[this._dirs[0],this._dirs[2],this._dirs[4],this._dirs[6],this._dirs[1],this._dirs[3],this._dirs[5],this._dirs[7]])};ROT.Path.prototype.compute=function(a,b,c){};
+ROT.Path.prototype._getNeighbors=function(a,b){for(var c=[],d=0;d<this._dirs.length;d++){var e=this._dirs[d],f=a+e[0],e=b+e[1];this._passableCallback(f,e)&&c.push([f,e])}return c};ROT.Path.Dijkstra=function(a,b,c,d){ROT.Path.call(this,a,b,c,d);this._computed={};this._todo=[];this._add(a,b,null)};ROT.Path.Dijkstra.extend(ROT.Path);
+ROT.Path.Dijkstra.prototype.compute=function(a,b,c){var d=a+","+b;d in this._computed||this._compute(a,b);if(d in this._computed)for(a=this._computed[d];a;)c(a.x,a.y),a=a.prev};ROT.Path.Dijkstra.prototype._compute=function(a,b){for(;this._todo.length;){var c=this._todo.shift();if(c.x==a&&c.y==b)break;for(var d=this._getNeighbors(c.x,c.y),e=0;e<d.length;e++){var f=d[e],g=f[0],f=f[1];g+","+f in this._computed||this._add(g,f,c)}}};
+ROT.Path.Dijkstra.prototype._add=function(a,b,c){c={x:a,y:b,prev:c};this._computed[a+","+b]=c;this._todo.push(c)};ROT.Path.AStar=function(a,b,c,d){ROT.Path.call(this,a,b,c,d);this._todo=[];this._done={};this._fromY=this._fromX=null};ROT.Path.AStar.extend(ROT.Path);
+ROT.Path.AStar.prototype.compute=function(a,b,c){this._todo=[];this._done={};this._fromX=a;this._fromY=b;for(this._add(this._toX,this._toY,null);this._todo.length;){var d=this._todo.shift();if(d.x==a&&d.y==b)break;for(var e=this._getNeighbors(d.x,d.y),f=0;f<e.length;f++){var g=e[f],h=g[0],g=g[1];h+","+g in this._done||this._add(h,g,d)}}if(d=this._done[a+","+b])for(;d;)c(d.x,d.y),d=d.prev};
+ROT.Path.AStar.prototype._add=function(a,b,c){var d=this._distance(a,b);c={x:a,y:b,prev:c,g:c?c.g+1:0,h:d};this._done[a+","+b]=c;a=c.g+c.h;for(b=0;b<this._todo.length;b++){var e=this._todo[b],f=e.g+e.h;if(a<f||a==f&&d<e.h){this._todo.splice(b,0,c);return}}this._todo.push(c)};
+ROT.Path.AStar.prototype._distance=function(a,b){switch(this._options.topology){case 4:return Math.abs(a-this._fromX)+Math.abs(b-this._fromY);case 6:var c=Math.abs(b-this._fromY);return c+Math.max(0,(Math.abs(a-this._fromX)-c)/2);case 8:return Math.max(Math.abs(a-this._fromX),Math.abs(b-this._fromY))}throw Error("Illegal topology");};

From 497adcea0b8ff700deb7b721d44bcc0f96ba3063 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 1 Nov 2016 20:25:28 +0100
Subject: [PATCH 16/20] Added the own image files into the makefile.

---
 Makefile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Makefile b/Makefile
index 6219e160..590a87b7 100644
--- a/Makefile
+++ b/Makefile
@@ -42,6 +42,7 @@ SOURCES = 	src/rot.js \
 			src/path/path.js \
 			src/path/dijkstra.js \
 			src/path/astar.js
+			src/image/image.js
 
 NODE_VERSION = "$(shell head -1 < NODE_VERSION)"
 NODE_PRE_SOURCES = 	node/node-shim.js

From ec4eb449313c1266778e854144c196d93377a5fe Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 1 Nov 2016 20:26:23 +0100
Subject: [PATCH 17/20] Fixed typo bug in the Makefile.

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 590a87b7..35964f4a 100644
--- a/Makefile
+++ b/Makefile
@@ -41,7 +41,7 @@ SOURCES = 	src/rot.js \
 			src/lighting.js \
 			src/path/path.js \
 			src/path/dijkstra.js \
-			src/path/astar.js
+			src/path/astar.js \
 			src/image/image.js
 
 NODE_VERSION = "$(shell head -1 < NODE_VERSION)"

From d8bca521c2381dbfd18fc4e56d076f996ee379c9 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 1 Nov 2016 21:04:27 +0100
Subject: [PATCH 18/20] Some fixes in image module and re-generated js
 libraries.

---
 rot.js             | 197 ++++++++++++++++++++++++++++++++++++++++++++-
 rot.min.js         |  10 ++-
 src/image/image.js |   7 +-
 3 files changed, 210 insertions(+), 4 deletions(-)

diff --git a/rot.js b/rot.js
index f657836f..d4a4e856 100644
--- a/rot.js
+++ b/rot.js
@@ -1,6 +1,6 @@
 /*
 	This is rot.js, the ROguelike Toolkit in JavaScript.
-	Version 0.7~dev, generated on mar nov  1 20:22:45 CET 2016.
+	Version 0.7~dev, generated on mar nov  1 20:53:53 CET 2016.
 */
 /**
  * @namespace Top-level ROT namespace
@@ -5326,3 +5326,198 @@ ROT.Path.AStar.prototype._distance = function(x, y) {
 
         throw new Error("Illegal topology");
 }
+/**
+ * @class Base image (as ASCII art) converter
+ */
+ 
+ //BASED IN THE WORK OF:
+ /*
+ * jsAscii 0.1
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.nihilogic.dk/licenses/mit-license.txt]
+ */
+ROT.Image = function() {
+	this.aDefaultCharList = (" .,:;i1tfLCG08@").split("");
+	this.aDefaultColorCharList = (" CGO08@").split("");
+	this.strFont = "courier new";
+	this.bBlock = true;
+	this.bAlpha = false;
+	this.bColor = true;
+	this.strResolution = "medium";
+	
+	this.ascii_art = "";
+	this.ascii_art_array = null;
+	this.height = 0;
+	this.width = 0;
+};
+
+ROT.Image.prototype.loadASCII = function() {
+	var aCharList = this.aDefaultCharList;
+	var bBlock = this.bBlock;
+	var bAlpha = this.bAlpha;
+	var bColor = this.bColor;
+	
+	var oCanvas = document.createElement("canvas");
+	if (!oCanvas.getContext) {
+		return;
+	}
+	var oCtx = oCanvas.getContext("2d");
+	if (!oCtx.getImageData) {
+		return;
+	}
+	
+	var strResolution = this.strResolution;
+	
+	var fResolution = 0.5;
+	
+	switch (strResolution) {
+		case "low" : 	fResolution = 0.25;	break;
+		case "medium" :	fResolution = 0.5;	break;
+		case "high" : 	fResolution = 1;	break;
+	}
+	
+	var iWidth = Math.round(parseInt(this.img.width) * fResolution);
+	var iHeight = Math.round(parseInt(this.img.height) * fResolution);
+	this.width = iWidth;
+	this.height = iHeight;
+	
+	oCanvas.width = iWidth;
+	oCanvas.height = iHeight;
+	//oCanvas.style.display = "none";
+	oCanvas.style.width = iWidth;
+	oCanvas.style.height = iHeight;
+	
+	oCtx.drawImage(this.img, 0, 0, iWidth, iHeight);
+	
+	var oImgData = oCtx.getImageData(0, 0, iWidth, iHeight).data;
+	
+	var strChars = "";
+	var array_chars = [];
+	
+	var iterator_y = 0;
+	for (var y=0;y<iHeight;y+=2) {
+		array_chars[iterator_y] = [];
+		for (var x=0;x<iWidth;x++) {
+			var iOffset = (y*iWidth + x) * 4;
+			
+			var iRed = oImgData[iOffset];
+			var iGreen = oImgData[iOffset + 1];
+			var iBlue = oImgData[iOffset + 2];
+			var iAlpha = oImgData[iOffset + 3];
+			
+			if (iAlpha == 0) {
+				var iBrightIdx = 0;
+			} else {
+				var fBrightness = (0.3*iRed + 0.59*iGreen + 0.11*iBlue) / 255;
+				var iCharIdx = (aCharList.length-1) - Math.round(fBrightness * (aCharList.length-1));
+			}
+			
+			//~ if (bInvert) {
+				//~ iCharIdx = (aCharList.length-1) - iCharIdx;
+			//~ }
+			var strThisChar = aCharList[iCharIdx];
+			var unscape_char = strThisChar;
+			
+			if (strThisChar == " ") 
+				strThisChar = "&nbsp;";
+			
+			if (bColor) {
+				strChars += "<span style='"
+					+ "color:rgb("+iRed+","+iGreen+","+iBlue+");"
+					+ (bBlock ? "background-color:rgb("+iRed+","+iGreen+","+iBlue+");" : "")
+					+ (bAlpha ? "opacity:" + (iAlpha/255) + ";" : "")
+					+ "'>" + strThisChar + "</span>";
+				
+				array_chars[iterator_y][x] = {'r': iRed, 'g' : iGreen, 'b' : iBlue, 'char': unscape_char};
+			}
+			else {
+				strChars += strThisChar;
+				array_chars[iterator_y][x] = {'char': unscape_char};
+			}
+		}
+		iterator_y++;
+		strChars += "<br/>";
+	}
+	
+	this.height = iterator_y;
+	
+	this.ascii_art_array = array_chars;
+	
+	return strChars;
+};
+
+ROT.Image.prototype.load = function(image_url) {
+	this.img = new Image();
+	this.img.setAttribute('crossOrigin', '');
+	this.img.src = image_url;
+	
+	var self = this;
+	
+	if (this.img.complete) {
+		console.log(this);
+		this.ascii_art = this.loadASCII();
+	}
+	else {
+		this.img.onload = function() {
+			self.ascii_art = self.loadASCII();
+		}
+	}
+};
+
+ROT.Image.prototype.get = function(xin, yin) {
+	return this.ascii_art_array[yin][xin];
+};
+
+ROT.Image.prototype.blit = function(display, display_x, display_y, image_x, image_y, rect_w, rect_h) {
+	var i = 0;
+	
+	for (var y = image_y; y < rect_h; y++) {
+		var j = 0;
+		for (var x = image_x; x < rect_w; x++) {
+			if (this.bColor) {
+				var color = "#" +
+					this.ascii_art_array[y][x]['r'].toString(16) +
+					this.ascii_art_array[y][x]['g'].toString(16) +
+					this.ascii_art_array[y][x]['b'].toString(16);
+				if (this.bBlock) {
+					display.draw(display_x + j,  display_y + i, this.ascii_art_array[y][x]['char'], color, color);
+				}
+				else {
+					display.draw(display_x + j,  display_y + i, this.ascii_art_array[y][x]['char'], color);
+				}
+			}
+			else {
+				display.draw(display_x + j,  display_y + i, this.ascii_art_array[y][x]['char']);
+			}
+			j++;
+		}
+		i++;
+	}
+};
+
+ROT.Image.prototype.paint = function(display, offset_x, offset_y) {
+	var i = 0;
+	
+	for (var y = 0; y < this.height; y++) {
+		var j = 0;
+		for (var x = 0; x < this.width; x++) {
+			if (this.bColor) {
+				var color = "#" +
+					this.ascii_art_array[y][x]['r'].toString(16) +
+					this.ascii_art_array[y][x]['g'].toString(16) +
+					this.ascii_art_array[y][x]['b'].toString(16);
+				if (this.bBlock) {
+					display.draw(offset_x + j,  offset_y + i, this.ascii_art_array[y][x]['char'], color, color);
+				}
+				else {
+					display.draw(offset_x + j,  offset_y + i, this.ascii_art_array[y][x]['char'], color);
+				}
+			}
+			else {
+				display.draw(offset_x + j,  offset_y + i, this.ascii_art_array[y][x]['char']);
+			}
+			j++;
+		}
+		i++;
+	}
+};
\ No newline at end of file
diff --git a/rot.min.js b/rot.min.js
index f7e7886d..0e0a26d5 100644
--- a/rot.min.js
+++ b/rot.min.js
@@ -116,7 +116,7 @@ ROT.Map.Feature.Corridor.prototype.isValid=function(a,b){var c=this._startX,d=th
 e,this._endY+f);return(c||h)&&this._endsWithAWall?!1:!0};ROT.Map.Feature.Corridor.prototype.create=function(a){var b=this._startX,c=this._startY,d=this._endX-b,e=this._endY-c,f=1+Math.max(Math.abs(d),Math.abs(e));d&&(d/=Math.abs(d));e&&(e/=Math.abs(e));for(var g=0;g<f;g++)a(b+g*d,c+g*e,0);return!0};
 ROT.Map.Feature.Corridor.prototype.createPriorityWalls=function(a){if(this._endsWithAWall){var b=this._endX-this._startX,c=this._endY-this._startY;b&&(b/=Math.abs(b));c&&(c/=Math.abs(c));var d=c,e=-b;a(this._endX+b,this._endY+c);a(this._endX+d,this._endY+e);a(this._endX-d,this._endY-e)}};ROT.Noise=function(){};ROT.Noise.prototype.get=function(a,b){};
 ROT.Noise.Simplex=function(a){ROT.Noise.call(this);this._F2=.5*(Math.sqrt(3)-1);this._G2=(3-Math.sqrt(3))/6;this._gradients=[[0,-1],[1,-1],[1,0],[1,1],[0,1],[-1,1],[-1,0],[-1,-1]];var b=[];a=a||256;for(var c=0;c<a;c++)b.push(c);b=b.randomize();this._perms=[];this._indexes=[];for(c=0;c<2*a;c++)this._perms.push(b[c%a]),this._indexes.push(this._perms[c]%this._gradients.length)};ROT.Noise.Simplex.extend(ROT.Noise);
-ROT.Noise.Simplex.prototype.get=function(a,b){var c=this._perms,d=this._indexes,e=c.length/2,f=this._G2,g=0,h=0,l=0,m,n=(a+b)*this._F2,q=Math.floor(a+n);m=Math.floor(b+n);var n=(q+m)*f,p=a-(q-n),r=b-(m-n),t,u;p>r?(t=1,u=0):(t=0,u=1);var w=p-t+f,x=r-u+f,n=p-1+2*f,f=r-1+2*f,q=q.mod(e),e=m.mod(e),v=.5-p*p-r*r;0<=v&&(v*=v,m=d[q+c[e]],m=this._gradients[m],g=v*v*(m[0]*p+m[1]*r));p=.5-w*w-x*x;0<=p&&(p*=p,m=d[q+t+c[e+u]],m=this._gradients[m],h=p*p*(m[0]*w+m[1]*x));p=.5-n*n-f*f;0<=p&&(p*=p,m=d[q+1+c[e+1]],
+ROT.Noise.Simplex.prototype.get=function(a,b){var c=this._perms,d=this._indexes,e=c.length/2,f=this._G2,g=0,h=0,l=0,m,n=(a+b)*this._F2,q=Math.floor(a+n);m=Math.floor(b+n);var n=(q+m)*f,p=a-(q-n),r=b-(m-n),t,u;p>r?(t=1,u=0):(t=0,u=1);var x=p-t+f,v=r-u+f,n=p-1+2*f,f=r-1+2*f,q=q.mod(e),e=m.mod(e),w=.5-p*p-r*r;0<=w&&(w*=w,m=d[q+c[e]],m=this._gradients[m],g=w*w*(m[0]*p+m[1]*r));p=.5-x*x-v*v;0<=p&&(p*=p,m=d[q+t+c[e+u]],m=this._gradients[m],h=p*p*(m[0]*x+m[1]*v));p=.5-n*n-f*f;0<=p&&(p*=p,m=d[q+1+c[e+1]],
 m=this._gradients[m],l=p*p*(m[0]*n+m[1]*f));return 70*(g+h+l)};ROT.FOV=function(a,b){this._lightPasses=a;this._options={topology:8};for(var c in b)this._options[c]=b[c]};ROT.FOV.prototype.compute=function(a,b,c,d){};
 ROT.FOV.prototype._getCircle=function(a,b,c){var d=[],e,f,g;switch(this._options.topology){case 4:f=1;g=[0,1];e=[ROT.DIRS[8][7],ROT.DIRS[8][1],ROT.DIRS[8][3],ROT.DIRS[8][5]];break;case 6:e=ROT.DIRS[6];f=1;g=[-1,1];break;case 8:e=ROT.DIRS[4],f=2,g=[-1,1]}a+=g[0]*c;b+=g[1]*c;for(g=0;g<e.length;g++)for(var h=0;h<c*f;h++)d.push([a,b]),a+=e[g][0],b+=e[g][1];return d};ROT.FOV.DiscreteShadowcasting=function(a,b){ROT.FOV.call(this,a,b)};ROT.FOV.DiscreteShadowcasting.extend(ROT.FOV);
 ROT.FOV.DiscreteShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0,1);if(this._lightPasses(a,b))for(var e=[],f,g,h,l,m,n=1;n<=c;n++)for(var q=this._getCircle(a,b,n),p=360/q.length,r=0;r<q.length;r++)if(h=q[r][0],l=q[r][1],f=p*(r-.5),g=f+p,m=!this._lightPasses(h,l),this._visibleCoords(Math.floor(f),Math.ceil(g),m,e)&&d(h,l,n,1),2==e.length&&0==e[0]&&360==e[1])return};
@@ -127,7 +127,7 @@ ROT.FOV.PreciseShadowcasting.prototype._checkVisibility=function(a,b,c,d){if(a[0
 ROT.FOV.RecursiveShadowcasting.prototype.compute=function(a,b,c,d){d(a,b,0,1);for(var e=0;e<ROT.FOV.RecursiveShadowcasting.OCTANTS.length;e++)this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[e],c,d)};
 ROT.FOV.RecursiveShadowcasting.prototype.compute180=function(a,b,c,d,e){e(a,b,0,1);var f=(d-1+8)%8,g=(d+1+8)%8;this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[(d-2+8)%8],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[f],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[d],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[g],c,e)};
 ROT.FOV.RecursiveShadowcasting.prototype.compute90=function(a,b,c,d,e){e(a,b,0,1);var f=(d-1+8)%8;this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[d],c,e);this._renderOctant(a,b,ROT.FOV.RecursiveShadowcasting.OCTANTS[f],c,e)};ROT.FOV.RecursiveShadowcasting.prototype._renderOctant=function(a,b,c,d,e){this._castVisibility(a,b,1,1,0,d+1,c[0],c[1],c[2],c[3],e)};
-ROT.FOV.RecursiveShadowcasting.prototype._castVisibility=function(a,b,c,d,e,f,g,h,l,m,n){if(!(d<e))for(;c<=f;c++){for(var q=-c-1,p=-c,r=!1,t=0;0>=q;){var q=q+1,u=a+q*g+p*h,w=b+q*l+p*m,x=(q-.5)/(p+.5),v=(q+.5)/(p-.5);if(!(v>d)){if(x<e)break;q*q+p*p<f*f&&n(u,w,c,1);r?this._lightPasses(u,w)?(r=!1,d=t):t=v:!this._lightPasses(u,w)&&c<f&&(r=!0,this._castVisibility(a,b,c+1,d,x,f,g,h,l,m,n),t=v)}}if(r)break}};
+ROT.FOV.RecursiveShadowcasting.prototype._castVisibility=function(a,b,c,d,e,f,g,h,l,m,n){if(!(d<e))for(;c<=f;c++){for(var q=-c-1,p=-c,r=!1,t=0;0>=q;){var q=q+1,u=a+q*g+p*h,x=b+q*l+p*m,v=(q-.5)/(p+.5),w=(q+.5)/(p-.5);if(!(w>d)){if(v<e)break;q*q+p*p<f*f&&n(u,x,c,1);r?this._lightPasses(u,x)?(r=!1,d=t):t=w:!this._lightPasses(u,x)&&c<f&&(r=!0,this._castVisibility(a,b,c+1,d,v,f,g,h,l,m,n),t=w)}}if(r)break}};
 ROT.Color={fromString:function(a){var b,c;if(a in this._cache)b=this._cache[a];else{if("#"==a.charAt(0))if(b=a.match(/[0-9a-f]/gi).map(function(a){return parseInt(a,16)}),3==b.length)b=b.map(function(a){return 17*a});else for(c=0;3>c;c++)b[c+1]+=16*b[c],b.splice(c,1);else b=(c=a.match(/rgb\(([0-9, ]+)\)/i))?c[1].split(/\s*,\s*/).map(function(a){return parseInt(a)}):[0,0,0];this._cache[a]=b}return b.slice()},add:function(a,b){for(var c=a.slice(),d=0;3>d;d++)for(var e=1;e<arguments.length;e++)c[d]+=
 arguments[e][d];return c},add_:function(a,b){for(var c=0;3>c;c++)for(var d=1;d<arguments.length;d++)a[c]+=arguments[d][c];return a},multiply:function(a,b){for(var c=a.slice(),d=0;3>d;d++){for(var e=1;e<arguments.length;e++)c[d]*=arguments[e][d]/255;c[d]=Math.round(c[d])}return c},multiply_:function(a,b){for(var c=0;3>c;c++){for(var d=1;d<arguments.length;d++)a[c]*=arguments[d][c]/255;a[c]=Math.round(a[c])}return a},interpolate:function(a,b,c){3>arguments.length&&(c=.5);for(var d=a.slice(),e=0;3>e;e++)d[e]=
 Math.round(d[e]+c*(b[e]-a[e]));return d},interpolateHSL:function(a,b,c){3>arguments.length&&(c=.5);for(var d=this.rgb2hsl(a),e=this.rgb2hsl(b),f=0;3>f;f++)d[f]+=c*(e[f]-d[f]);return this.hsl2rgb(d)},randomize:function(a,b){b instanceof Array||(b=Math.round(ROT.RNG.getNormal(0,b)));for(var c=a.slice(),d=0;3>d;d++)c[d]+=b instanceof Array?Math.round(ROT.RNG.getNormal(0,b[d])):b;return c},rgb2hsl:function(a){var b=a[0]/255,c=a[1]/255;a=a[2]/255;var d=Math.max(b,c,a),e=Math.min(b,c,a),f,g=(d+e)/2;if(d==
@@ -152,3 +152,9 @@ ROT.Path.Dijkstra.prototype._add=function(a,b,c){c={x:a,y:b,prev:c};this._comput
 ROT.Path.AStar.prototype.compute=function(a,b,c){this._todo=[];this._done={};this._fromX=a;this._fromY=b;for(this._add(this._toX,this._toY,null);this._todo.length;){var d=this._todo.shift();if(d.x==a&&d.y==b)break;for(var e=this._getNeighbors(d.x,d.y),f=0;f<e.length;f++){var g=e[f],h=g[0],g=g[1];h+","+g in this._done||this._add(h,g,d)}}if(d=this._done[a+","+b])for(;d;)c(d.x,d.y),d=d.prev};
 ROT.Path.AStar.prototype._add=function(a,b,c){var d=this._distance(a,b);c={x:a,y:b,prev:c,g:c?c.g+1:0,h:d};this._done[a+","+b]=c;a=c.g+c.h;for(b=0;b<this._todo.length;b++){var e=this._todo[b],f=e.g+e.h;if(a<f||a==f&&d<e.h){this._todo.splice(b,0,c);return}}this._todo.push(c)};
 ROT.Path.AStar.prototype._distance=function(a,b){switch(this._options.topology){case 4:return Math.abs(a-this._fromX)+Math.abs(b-this._fromY);case 6:var c=Math.abs(b-this._fromY);return c+Math.max(0,(Math.abs(a-this._fromX)-c)/2);case 8:return Math.max(Math.abs(a-this._fromX),Math.abs(b-this._fromY))}throw Error("Illegal topology");};
+ROT.Image=function(){this.aDefaultCharList=" .,:;i1tfLCG08@".split("");this.aDefaultColorCharList=" CGO08@".split("");this.strFont="courier new";this.bBlock=!0;this.bAlpha=!1;this.bColor=!0;this.strResolution="medium";this.ascii_art="";this.ascii_art_array=null;this.width=this.height=0};
+ROT.Image.prototype.loadASCII=function(){var a=this.aDefaultCharList,b=this.bBlock,c=this.bAlpha,d=this.bColor,e=document.createElement("canvas");if(e.getContext){var f=e.getContext("2d");if(f.getImageData){var g=.5;switch(this.strResolution){case "low":g=.25;break;case "medium":g=.5;break;case "high":g=1}var h=Math.round(parseInt(this.img.width)*g),g=Math.round(parseInt(this.img.height)*g);this.width=h;this.height=g;e.width=h;e.height=g;e.style.width=h;e.style.height=g;f.drawImage(this.img,0,0,h,
+g);for(var e=f.getImageData(0,0,h,g).data,f="",l=[],m=0,n=0;n<g;n+=2){l[m]=[];for(var q=0;q<h;q++){var p=4*(n*h+q),r=e[p],t=e[p+1],u=e[p+2],p=e[p+3];if(0!=p)var x=a.length-1-Math.round((.3*r+.59*t+.11*u)/255*(a.length-1));var v=a[x],w=v;" "==v&&(v="&nbsp;");d?(f+="<span style='color:rgb("+r+","+t+","+u+");"+(b?"background-color:rgb("+r+","+t+","+u+");":"")+(c?"opacity:"+p/255+";":"")+"'>"+v+"</span>",l[m][q]={r:r,g:t,b:u,"char":w}):(f+=v,l[m][q]={"char":w})}m++;f+="<br/>"}this.height=m;this.ascii_art_array=
+l;return f}}};ROT.Image.prototype.load=function(a){this.img=new Image;this.img.setAttribute("crossOrigin","");this.img.src=a;var b=this;this.img.complete?(console.log(this),this.ascii_art=this.loadASCII()):this.img.onload=function(){b.ascii_art=b.loadASCII()}};ROT.Image.prototype.get=function(a,b){return this.ascii_art_array[b][a]};
+ROT.Image.prototype.blit=function(a,b,c,d,e,f,g){for(var h=0;e<g;e++){for(var l=0,m=d;m<f;m++){if(this.bColor){var n="#"+this.ascii_art_array[e][m].r.toString(16)+this.ascii_art_array[e][m].g.toString(16)+this.ascii_art_array[e][m].b.toString(16);this.bBlock?a.draw(b+l,c+h,this.ascii_art_array[e][m]["char"],n,n):a.draw(b+l,c+h,this.ascii_art_array[e][m]["char"],n)}else a.draw(b+l,c+h,this.ascii_art_array[e][m]["char"]);l++}h++}};
+ROT.Image.prototype.paint=function(a,b,c){for(var d=0,e=0;e<this.height;e++){for(var f=0,g=0;g<this.width;g++){if(this.bColor){var h="#"+this.ascii_art_array[e][g].r.toString(16)+this.ascii_art_array[e][g].g.toString(16)+this.ascii_art_array[e][g].b.toString(16);this.bBlock?a.draw(b+f,c+d,this.ascii_art_array[e][g]["char"],h,h):a.draw(b+f,c+d,this.ascii_art_array[e][g]["char"],h)}else a.draw(b+f,c+d,this.ascii_art_array[e][g]["char"]);f++}d++}};
diff --git a/src/image/image.js b/src/image/image.js
index 6e570f13..1d0a5f87 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -120,13 +120,18 @@ ROT.Image.prototype.loadASCII = function() {
 
 ROT.Image.prototype.load = function(image_url) {
 	this.img = new Image();
+	this.img.setAttribute('crossOrigin', '');
 	this.img.src = image_url;
+	
+	var self = this;
+	
 	if (this.img.complete) {
+		console.log(this);
 		this.ascii_art = this.loadASCII();
 	}
 	else {
 		this.img.onload = function() {
-			this.ascii_art = this.loadASCII()
+			self.ascii_art = self.loadASCII();
 		}
 	}
 };

From 876eac68fad80de735a98ca6336c750ccfcc5723 Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Tue, 1 Nov 2016 21:04:54 +0100
Subject: [PATCH 19/20] Cleaned source code of examples for ASCIIart.

---
 examples/combat.html | 46 ++++----------------------------------------
 examples/title.html  | 46 ++++----------------------------------------
 2 files changed, 8 insertions(+), 84 deletions(-)

diff --git a/examples/combat.html b/examples/combat.html
index ea6eec96..d0c6a2f5 100644
--- a/examples/combat.html
+++ b/examples/combat.html
@@ -3,54 +3,16 @@
 <title>test</title>
 </head>
 <body>
-<script type="text/javascript" src="src/rot.js"></script>
-<script type="text/javascript" src="src/text.js"></script>
-<script type="text/javascript" src="src/js/array.js"></script>
-<script type="text/javascript" src="src/js/number.js"></script>
-<script type="text/javascript" src="src/js/string.js"></script>
-<script type="text/javascript" src="src/js/object.js"></script>
-<script type="text/javascript" src="src/js/function.js"></script>
-<script type="text/javascript" src="src/display/display.js"></script>
-<script type="text/javascript" src="src/display/backend.js"></script>
-<script type="text/javascript" src="src/display/rect.js"></script>
-<script type="text/javascript" src="src/display/hex.js"></script>
-<script type="text/javascript" src="src/rng.js"></script>
-<script type="text/javascript" src="src/stringgenerator.js"></script>
-<script type="text/javascript" src="src/eventqueue.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler-simple.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler-speed.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler-action.js"></script>
-<script type="text/javascript" src="src/engine.js"></script>
-<script type="text/javascript" src="src/map/map.js"></script>
-<script type="text/javascript" src="src/map/arena.js"></script>
-<script type="text/javascript" src="src/map/dividedmaze.js"></script>
-<script type="text/javascript" src="src/map/iceymaze.js"></script>
-<script type="text/javascript" src="src/map/ellermaze.js"></script>
-<script type="text/javascript" src="src/map/cellular.js"></script>
-<script type="text/javascript" src="src/map/dungeon.js"></script>
-<script type="text/javascript" src="src/map/digger.js"></script>
-<script type="text/javascript" src="src/map/uniform.js"></script>
-<script type="text/javascript" src="src/map/rogue.js"></script>
-<script type="text/javascript" src="src/map/features.js"></script>
-<script type="text/javascript" src="src/noise/noise.js"></script>
-<script type="text/javascript" src="src/noise/simplex.js"></script>
-<script type="text/javascript" src="src/fov/fov.js"></script>
-<script type="text/javascript" src="src/fov/discrete-shadowcasting.js"></script>
-<script type="text/javascript" src="src/fov/precise-shadowcasting.js"></script>
-<script type="text/javascript" src="src/color.js"></script>
-<script type="text/javascript" src="src/lighting.js"></script>
-<script type="text/javascript" src="src/path/path.js"></script>
-<script type="text/javascript" src="src/path/dijkstra.js"></script>
-<script type="text/javascript" src="src/path/astar.js"></script>
-<script type="text/javascript" src="src/image/image.js"></script>
+<script type="text/javascript" src="../rot.js"></script>
 
+<!--
 <script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
+-->
 
 <script type="text/javascript">
 var w = 200;
 var h = 60;
-var noise = new ROT.Noise.Simplex();
+
 var image = new ROT.Image();
 image.strResolution = "medium";
 image.bBlock = false;
diff --git a/examples/title.html b/examples/title.html
index b82a2c66..b4ff8ee3 100644
--- a/examples/title.html
+++ b/examples/title.html
@@ -3,54 +3,16 @@
 <title>test</title>
 </head>
 <body>
-<script type="text/javascript" src="src/rot.js"></script>
-<script type="text/javascript" src="src/text.js"></script>
-<script type="text/javascript" src="src/js/array.js"></script>
-<script type="text/javascript" src="src/js/number.js"></script>
-<script type="text/javascript" src="src/js/string.js"></script>
-<script type="text/javascript" src="src/js/object.js"></script>
-<script type="text/javascript" src="src/js/function.js"></script>
-<script type="text/javascript" src="src/display/display.js"></script>
-<script type="text/javascript" src="src/display/backend.js"></script>
-<script type="text/javascript" src="src/display/rect.js"></script>
-<script type="text/javascript" src="src/display/hex.js"></script>
-<script type="text/javascript" src="src/rng.js"></script>
-<script type="text/javascript" src="src/stringgenerator.js"></script>
-<script type="text/javascript" src="src/eventqueue.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler-simple.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler-speed.js"></script>
-<script type="text/javascript" src="src/scheduler/scheduler-action.js"></script>
-<script type="text/javascript" src="src/engine.js"></script>
-<script type="text/javascript" src="src/map/map.js"></script>
-<script type="text/javascript" src="src/map/arena.js"></script>
-<script type="text/javascript" src="src/map/dividedmaze.js"></script>
-<script type="text/javascript" src="src/map/iceymaze.js"></script>
-<script type="text/javascript" src="src/map/ellermaze.js"></script>
-<script type="text/javascript" src="src/map/cellular.js"></script>
-<script type="text/javascript" src="src/map/dungeon.js"></script>
-<script type="text/javascript" src="src/map/digger.js"></script>
-<script type="text/javascript" src="src/map/uniform.js"></script>
-<script type="text/javascript" src="src/map/rogue.js"></script>
-<script type="text/javascript" src="src/map/features.js"></script>
-<script type="text/javascript" src="src/noise/noise.js"></script>
-<script type="text/javascript" src="src/noise/simplex.js"></script>
-<script type="text/javascript" src="src/fov/fov.js"></script>
-<script type="text/javascript" src="src/fov/discrete-shadowcasting.js"></script>
-<script type="text/javascript" src="src/fov/precise-shadowcasting.js"></script>
-<script type="text/javascript" src="src/color.js"></script>
-<script type="text/javascript" src="src/lighting.js"></script>
-<script type="text/javascript" src="src/path/path.js"></script>
-<script type="text/javascript" src="src/path/dijkstra.js"></script>
-<script type="text/javascript" src="src/path/astar.js"></script>
-<script type="text/javascript" src="src/image/image.js"></script>
+<script type="text/javascript" src="../rot.js"></script>
 
+<!--
 <script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
+-->
 
 <script type="text/javascript">
 var w = 200;
 var h = 60;
-var noise = new ROT.Noise.Simplex();
+
 var image = new ROT.Image();
 image.strResolution = "medium";
 image.bBlock = false;

From 88d3d1069a72c157dc398d934682d64a59ef674c Mon Sep 17 00:00:00 2001
From: mdtrooper <tres.14159@gmail.com>
Date: Wed, 2 Nov 2016 01:12:37 +0100
Subject: [PATCH 20/20] I love the f*cking javascript and the lost mutex in
 this language.

---
 examples/combat.html | 62 +++++++++++++++++++++++---------------------
 examples/title.html  | 61 ++++++++++++++++++++++---------------------
 rot.js               | 12 ++++++---
 rot.min.js           |  2 +-
 src/image/image.js   | 10 +++++--
 5 files changed, 83 insertions(+), 64 deletions(-)

diff --git a/examples/combat.html b/examples/combat.html
index d0c6a2f5..2ff5fad3 100644
--- a/examples/combat.html
+++ b/examples/combat.html
@@ -1,31 +1,35 @@
 <html>
-<head>
-<title>test</title>
-</head>
-<body>
-<script type="text/javascript" src="../rot.js"></script>
-
-<!--
-<script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
--->
-
-<script type="text/javascript">
-var w = 200;
-var h = 60;
-
-var image = new ROT.Image();
-image.strResolution = "medium";
-image.bBlock = false;
-image.load("combat.png");
-
-var display = new ROT.Display({width:w, height:h, fontSize:10});
-
-image.paint(display, 0, 0);
-
-document.body.appendChild(display.getContainer());
-
-
-</script>
-<canvas></canvas>
-</body>
+	<head>
+		<title>test</title>
+	</head>
+	<body>
+		<script type="text/javascript" src="../rot.js"></script>
+		
+		<!--
+		<script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
+		-->
+		
+		<script type="text/javascript">
+			var w = 200;
+			var h = 60;
+			
+			var image = new ROT.Image();
+			
+			image.strResolution = "medium";
+			image.bBlock = false;
+			image.load("combat.png", function() {game();} );
+			
+			var display = new ROT.Display({width:w, height:h, fontSize:10});
+			
+			
+			
+			document.body.appendChild(display.getContainer());
+			
+			function game()
+			{
+				image.paint(display, 0, 0);
+			}
+		</script>
+		<canvas></canvas>
+	</body>
 </html>
\ No newline at end of file
diff --git a/examples/title.html b/examples/title.html
index b4ff8ee3..557297ae 100644
--- a/examples/title.html
+++ b/examples/title.html
@@ -1,31 +1,34 @@
 <html>
-<head>
-<title>test</title>
-</head>
-<body>
-<script type="text/javascript" src="../rot.js"></script>
-
-<!--
-<script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
--->
-
-<script type="text/javascript">
-var w = 200;
-var h = 60;
-
-var image = new ROT.Image();
-image.strResolution = "medium";
-image.bBlock = false;
-image.load("title.png");
-
-var display = new ROT.Display({width:w, height:h, fontSize:10});
-
-image.paint(display, 0, 0);
-
-document.body.appendChild(display.getContainer());
-
-
-</script>
-<canvas></canvas>
-</body>
+	<head>
+	<title>test</title>
+	</head>
+	<body>
+		<script type="text/javascript" src="../rot.js"></script>
+		
+		<!--
+		<script type="text/javascript" src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
+		-->
+		
+		<script type="text/javascript">
+			var w = 200;
+			var h = 60;
+			
+			var image = new ROT.Image();
+			image.strResolution = "medium";
+			image.bBlock = false;
+			image.load("title.png", function() {game();} );
+			
+			var display = new ROT.Display({width:w, height:h, fontSize:10});
+			
+			
+			
+			document.body.appendChild(display.getContainer());
+			
+			function game()
+			{
+				image.paint(display, 0, 0);
+			}
+		</script>
+		<canvas></canvas>
+	</body>
 </html>
\ No newline at end of file
diff --git a/rot.js b/rot.js
index d4a4e856..3280624d 100644
--- a/rot.js
+++ b/rot.js
@@ -1,6 +1,6 @@
 /*
 	This is rot.js, the ROguelike Toolkit in JavaScript.
-	Version 0.7~dev, generated on mar nov  1 20:53:53 CET 2016.
+	Version 0.7~dev, generated on mié nov  2 00:54:29 CET 2016.
 */
 /**
  * @namespace Top-level ROT namespace
@@ -5446,7 +5446,7 @@ ROT.Image.prototype.loadASCII = function() {
 	return strChars;
 };
 
-ROT.Image.prototype.load = function(image_url) {
+ROT.Image.prototype.load = function(image_url, callback_load_complete) {
 	this.img = new Image();
 	this.img.setAttribute('crossOrigin', '');
 	this.img.src = image_url;
@@ -5454,13 +5454,19 @@ ROT.Image.prototype.load = function(image_url) {
 	var self = this;
 	
 	if (this.img.complete) {
-		console.log(this);
 		this.ascii_art = this.loadASCII();
+		
+		return true;
 	}
 	else {
 		this.img.onload = function() {
 			self.ascii_art = self.loadASCII();
+			
+			if (typeof(callback_load_complete) != "undefined")
+				callback_load_complete();
 		}
+		
+		return false;
 	}
 };
 
diff --git a/rot.min.js b/rot.min.js
index 0e0a26d5..9940312f 100644
--- a/rot.min.js
+++ b/rot.min.js
@@ -155,6 +155,6 @@ ROT.Path.AStar.prototype._distance=function(a,b){switch(this._options.topology){
 ROT.Image=function(){this.aDefaultCharList=" .,:;i1tfLCG08@".split("");this.aDefaultColorCharList=" CGO08@".split("");this.strFont="courier new";this.bBlock=!0;this.bAlpha=!1;this.bColor=!0;this.strResolution="medium";this.ascii_art="";this.ascii_art_array=null;this.width=this.height=0};
 ROT.Image.prototype.loadASCII=function(){var a=this.aDefaultCharList,b=this.bBlock,c=this.bAlpha,d=this.bColor,e=document.createElement("canvas");if(e.getContext){var f=e.getContext("2d");if(f.getImageData){var g=.5;switch(this.strResolution){case "low":g=.25;break;case "medium":g=.5;break;case "high":g=1}var h=Math.round(parseInt(this.img.width)*g),g=Math.round(parseInt(this.img.height)*g);this.width=h;this.height=g;e.width=h;e.height=g;e.style.width=h;e.style.height=g;f.drawImage(this.img,0,0,h,
 g);for(var e=f.getImageData(0,0,h,g).data,f="",l=[],m=0,n=0;n<g;n+=2){l[m]=[];for(var q=0;q<h;q++){var p=4*(n*h+q),r=e[p],t=e[p+1],u=e[p+2],p=e[p+3];if(0!=p)var x=a.length-1-Math.round((.3*r+.59*t+.11*u)/255*(a.length-1));var v=a[x],w=v;" "==v&&(v="&nbsp;");d?(f+="<span style='color:rgb("+r+","+t+","+u+");"+(b?"background-color:rgb("+r+","+t+","+u+");":"")+(c?"opacity:"+p/255+";":"")+"'>"+v+"</span>",l[m][q]={r:r,g:t,b:u,"char":w}):(f+=v,l[m][q]={"char":w})}m++;f+="<br/>"}this.height=m;this.ascii_art_array=
-l;return f}}};ROT.Image.prototype.load=function(a){this.img=new Image;this.img.setAttribute("crossOrigin","");this.img.src=a;var b=this;this.img.complete?(console.log(this),this.ascii_art=this.loadASCII()):this.img.onload=function(){b.ascii_art=b.loadASCII()}};ROT.Image.prototype.get=function(a,b){return this.ascii_art_array[b][a]};
+l;return f}}};ROT.Image.prototype.load=function(a,b){this.img=new Image;this.img.setAttribute("crossOrigin","");this.img.src=a;var c=this;if(this.img.complete)return this.ascii_art=this.loadASCII(),!0;this.img.onload=function(){c.ascii_art=c.loadASCII();"undefined"!=typeof b&&b()};return!1};ROT.Image.prototype.get=function(a,b){return this.ascii_art_array[b][a]};
 ROT.Image.prototype.blit=function(a,b,c,d,e,f,g){for(var h=0;e<g;e++){for(var l=0,m=d;m<f;m++){if(this.bColor){var n="#"+this.ascii_art_array[e][m].r.toString(16)+this.ascii_art_array[e][m].g.toString(16)+this.ascii_art_array[e][m].b.toString(16);this.bBlock?a.draw(b+l,c+h,this.ascii_art_array[e][m]["char"],n,n):a.draw(b+l,c+h,this.ascii_art_array[e][m]["char"],n)}else a.draw(b+l,c+h,this.ascii_art_array[e][m]["char"]);l++}h++}};
 ROT.Image.prototype.paint=function(a,b,c){for(var d=0,e=0;e<this.height;e++){for(var f=0,g=0;g<this.width;g++){if(this.bColor){var h="#"+this.ascii_art_array[e][g].r.toString(16)+this.ascii_art_array[e][g].g.toString(16)+this.ascii_art_array[e][g].b.toString(16);this.bBlock?a.draw(b+f,c+d,this.ascii_art_array[e][g]["char"],h,h):a.draw(b+f,c+d,this.ascii_art_array[e][g]["char"],h)}else a.draw(b+f,c+d,this.ascii_art_array[e][g]["char"]);f++}d++}};
diff --git a/src/image/image.js b/src/image/image.js
index 1d0a5f87..0271a3f8 100644
--- a/src/image/image.js
+++ b/src/image/image.js
@@ -118,7 +118,7 @@ ROT.Image.prototype.loadASCII = function() {
 	return strChars;
 };
 
-ROT.Image.prototype.load = function(image_url) {
+ROT.Image.prototype.load = function(image_url, callback_load_complete) {
 	this.img = new Image();
 	this.img.setAttribute('crossOrigin', '');
 	this.img.src = image_url;
@@ -126,13 +126,19 @@ ROT.Image.prototype.load = function(image_url) {
 	var self = this;
 	
 	if (this.img.complete) {
-		console.log(this);
 		this.ascii_art = this.loadASCII();
+		
+		return true;
 	}
 	else {
 		this.img.onload = function() {
 			self.ascii_art = self.loadASCII();
+			
+			if (typeof(callback_load_complete) != "undefined")
+				callback_load_complete();
 		}
+		
+		return false;
 	}
 };