date: 2016-10-30
title: Random mazes
thumbnail-image-url: http://picture-files.nuke24.net/uri-res/raw/urn:bitprint:YWNEXCEUE3SMXYA7EAI4CSUNPBEZXW62.KSFA52RQC46ZVQDXX4IPUIBHTZKDIG3D5O4UNKY/RandomCave.png
summary: Random graph-based mazes for you to wander in!

<style scoped>/* <![CDATA[ */
html, body {
	background: black;
	margin: 0;
	padding: 0;
	color: white;
	font-family: sans-serif;
}
* {
	box-sizing: border-box;
}
p, ul {
	margin: 0;
	padding: 4px 8px;
}
ul {
	padding-left: 24px;
}
.game-interface {
	display: flex;
	width: 100%;
	flex-direction: column;
	justify-content: space-around;
	background: black;
}
.game-interface {
	border-top: 2px solid darkgray;
	border-bottom: 2px solid darkgray;
	margin: 8px 0 8px 0;
}
.game-interface:focus {
	border-top: 2px solid lightgray;
	border-bottom: 2px solid lightgray;
}
.maze-area {
	width: 100%;
	display: flex;
	align-items: center;
	justify-content: center;
}
.maze-canvas {
	background: black;
	border: none;
	width: 320px;
	height: 240px;
	box-sizing: content-box;
	image-rendering: pixelated;
}

ul.tile-palette {
	display: flex;
	flex-direction: row;
	justify-content: left;
	margin: 0; padding: 0;
	list-style-type: none;
}
ul.tile-palette li {
	margin: 2px;
	border: 1px solid #444;
	padding: 2px;
	box-sizing: content-box;
	width: 32px;
	height: 32px;
	background-origin: content-box;
	background-size: contain;
	background-position: center;
	background-repeat: no-repeat;
	image-rendering: pixelated;
}
ul.tile-palette li.selected {
	border-color: #FFF;
}
.button-bar {
	display: flex;
	flex-direction: row;
	justify-content: flex-start;
	align-items: center;
}
.button-bar > fieldset {
	display: table-row;
	flex-direction: row;
	justify-content: flex-start;
	flex-basis: content;
	border: none;
	margin: 0;
	padding: 0;
}
.button-bar > fieldset > * {
	display: table-cell;
}
.button-bar > *:nth-child(n+2) {
	margin-left: 8px;
}

.dialog-box {
	position: fixed;
	z-index: 2;
	
	border: 1px solid #666;
	padding: 0;
	
	display: flex;
	flex-direction: column
}
.dialog-box-content {
	flex-grow: 1;
	display: flex;
	flex-direction: column;
	overflow: auto;
}
.help-box-content {
	background: rgba(0,0,0,0.75);
	padding: 4px 8px;
	overflow: auto;
}
.dialog-box-header {
	display: flex;
	margin: 0; padding: 0;
	flex-direction: row;
	justify-content: space-between;
	align-items: center;

	flex-basis: content;
	flex-shrink: 0;
	
	background: #444;
}
.dialog-box-header button {
	margin: 16px;
}
.dialog-box h3 {
	margin: 0;
	padding: 16px;
	font-size: 18px;
	font-family: sans-serif;
}
.big-dialog-box {
	top: 10vh;
	left: 10vw;
	height: 80vh;
	width: 80vw;
}

.dialog-text-area {
	background: rgba(0,0,0,0.6);	
	color: white;
	margin: 0px;
	padding: 4px 8px;
	overflow-y: auto;
	box-sizing: border-box;
}

#load-list {
	flex-grow: 1;
	list-style-type: none;
}
#load-list li {
	margin: 0;
	padding: 2px 4px;
	cursor: pointer;
}
#load-list li:hover {
	text-decoration: underline;
}

#console-output {
	flex-grow: 1;
}
#console-input {
	flex-basis: content;
	flex-shrink: 0;
}

#camera-location-box {
	color: #AA0;
	background: rgba(0,0,0,0.75);
	font-family: monospace;
}

#energy-bar {
	overflow: visible;
	white-space: nowrap;
	background: rgba(255,0,0,0.5);
}

#inventory-dialog {
	position: fixed;
	top: 10vh;
	left: 10vh;
	bottom: 10vh;
	right: 10vh;
	
	display: flex;
	flex-direction: column;
	align-content: left;
}
.storage-compartment-content {
	min-width: 32px;
	min-height: 32px;
	background: rgba(0,0,0,0.5);
	display: flex;
	flex-direction: column;
}
.storage-compartment-content > * {
	margin: 0;
	padding: 2px;
	box-sizing: content-box;
	width: 32px;
	height: 32px;
	background-origin: content-box;
	background-size: contain;
	background-position: center;
	background-repeat: no-repeat;
	image-rendering: pixelated;
	border: 1px solid rgba(64,64,64,0.75);
}
.storage-compartment-content > *.selected {
	border-color: rgba(192,192,192,0.75);
}

@media (min-width: 640px) and (min-height: 500px) {
	.maze-canvas {
		width: 640px;
		height: 480px;
	}
}
@media (min-width: 960px) and (min-height: 740px) {
	.maze-canvas {
		width: 960px;
		height: 720px;
	}
}

#loading-status-box {
	position: fixed;
	z-index: 1;
	top: 0;
	left: 0;
	display: inline-block;
	background: purple;
	color: white;
}

.event-dialog {
	top: 20vh;
	right: 25vw;
	left: 25vw;
	background: black;
}
.event-dialog-message-area {
	display: flex;
	flex-direction: column;
	flex-grow: 2;
}
.event-dialog-message-area > p {
	font-size: 36px;
	text-align: center;
	margin: 8px 16px;
}
.event-dialog-button-area {
	display: flex;
	flex-basis: content;
	flex-grow: 0;
	flex-direction: row;
	justify-content: space-around;
}
.event-dialog-button-area button {
	margin: 8px;
	font-size: 24px;
}
/* ]]> */</style>

<div id="loading-status-box">Loading JavaScript...</div>

<p>Justus encouraged me to enter
<a href="https://www.it-talents.de/foerderung/code-competition/code-competition-10-2016">this
random dungeon generator competition</a>, so here's my entry.</p>

<div class="game-interface" id="game-interface" tabindex="0">
<div class="maze-area" id="maze-area" style="position:relative">
<div id="camera-location-box" style="position:absolute; top:0; left:0;"></div>
<div id="energy-bar" style="position:absolute; top:0; left:0; width:12px;">Energy: <span id="energy-counter">567</span></div>
<canvas class="maze-canvas" id="maze-canvas" width="320" height="240"/>
</div>

<div id="tile-palette-area"></div>
</div>

<p>Hit "/" to open the console.  "/level <i>n</i>" to warp to level <i>n</i> ('<i>n</i>' standing for some integer).</p>

<div id="console-dialog" class="dialog-box big-dialog-box" style="display:none">
  <div class="dialog-box-header">
    <h3>Console</h3>
    <button id="console-close-button">Close</button>
  </div>
  <div class="dialog-box-content">
    <div id="console-output" class="dialog-text-area" style="flex-grow: 1"></div>
    <input id="console-input" class="dialog-text-area"/>
  </div>
</div>

<div id="load-dialog" class="dialog-box big-dialog-box" style="display:none">
  <div class="dialog-box-header">
    <h3>Load</h3>
    <button id="load-cancel-button">Cancel</button>
  </div>
  <div class="dialog-box-content">
    <ul id="load-list" class="dialog-text-area">
    </ul>
  </div>
</div>

<div id="help-dialog" class="dialog-box big-dialog-box" style="display:none">
  <div class="dialog-box-header">
    <h3>About</h3>
    <button id="help-close-button">Close</button>
  </div>
  <div class="dialog-box-content help-box-content">
    <p>W,A,S,D to move around.</p>
	
    <p>Hit the tab key to toggle between edit and play mode.</p>
    
    <p>Hit <kbd>/</kbd> to open the console.</p>
    
    <h4>Console commands</h4>
    
    <p>Note that some editing commands require you to be in edit mode because they rely
    on information that is only given to the client in edit mode.</p> 
    
    <ul>
    <li><code>/load &lt;savegame-ID&gt;</code> - load a save game by URN; note that this URN should end with a "<code>#</code>" and you will need to enclose it in quotes.</li>
    <li><code>/create-room</code> - creates a new room, not connected to any other</li>
    <li><code>/connect-new-room &lt;direction&gt;</code> - create a new room and connect the current room to it in the specified direction.
      Directions are <code>t</code> (top), <code>r</code> (right), <code>b</code> (bottom), <code>l</code> (left), or some combination,
      (for diagonals).  Don't create a new room when a link already exists in that direction,
	  as that will cause trouble (later versions will prevent this from happening).</li>
    <li><code>/connect-rooms &lt;room-A-ID&gt; &lt;direction&gt; &lt;room-B-ID&gt;</code> - connect 2 rooms.</li>
    </ul>
    
    <p>The ID of the room you are currently in is shown at the top of the screen.</p>
	
	<p>There exists a door and a lift in this world that can be controlled with Door/Lift selector
	and the 'Up'/'Down' buttons at the bottom of this page.
	There is currently no way to create new doors or lifts, but with a bit of dedication
	you may be able to move the existing ones.
	In the future doors and lifts should be controllable with switches
	or keys scattered through the maze.</p>
	
	<p>There is no end goal.
	If you'd like there to be one, maybe make a room
	with 'Winner' spelled out in blocks or something.</p>
  </div>
</div>

<div id="inventory-dialog" style="display:none">
</div>

<div id="win-dialog" class="dialog-box event-dialog" style="display:none">
<div id="win-dialog-message-area" class="event-dialog-message-area"></div>
<div id="win-dialog-button-area" class="event-dialog-button-area"></div>
</div>

<div id="restart-dialog" class="dialog-box event-dialog" style="display:none">
<div id="restart-dialog-message-area" class="event-dialog-message-area"></div>
<div id="restart-dialog-button-area" class="event-dialog-button-area"></div>
</div>



<script type="text/javascript">/* <![CDATA[ */
////// ./fakerequire.js //////

/**
 * [Attempt at a] drop-in replacement for requireJS
 * for when you control the loading of all the files
 * and can guarantee that all needed dependencies exist.
 * 
 * define( name, dependencies, callback );
 * ....
 * require( [someModuleName], function(someModule) { } );
 */
var fakerequire = (function() {
	var modules = {};
	var define = function(name, deps, callback) {
		modules[name] = { dependencies: deps, callback: callback, exports: undefined };
	};
	var resolveDeps = function(depNames, overrides) {
		var deps = [];
		for( var d in depNames ) {
			var depName = depNames[d];
			var v;
			if( overrides[depName] !== undefined ) {
				v = overrides[depName];
			} else {
				v = getModuleExports(depName);
			}
			deps.push(v);
		}
		return deps;
	};
	var getModuleExports = function(name) {
		var module = modules[name];
		if( !module ) throw new Error("No module '"+name+"' defined");
		if( module.exports === undefined ) {
			module.exports = {};
			var deps = resolveDeps( module.dependencies, {exports: module.exports, require: null} );
			module.callback.apply(module.callback, deps);
		}
		return module.exports;
	};
	var require = function(depNames, callback, errback) {
		var exports = {};
		var args;
		if( errback ) {
			try {
				args = resolveDeps(depNames, { exports: exports, require: null });
			} catch( e ) {
				errback(e);
			}
		} else {
			args = resolveDeps(depNames, { exports: exports, require: null });
		}
		
		callback.apply(callback, args);
	};
	
	return {
		define: define,
		require: require
	};
})();

window.define = fakerequire.define;
window.require = fakerequire.require;
////// ./temp/6a54b3e854525aa170c78e14ab9e29f40cb1d733 //////

var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
define("togos-game21/DeepFreezer", ["require", "exports"], function (require, exports) {
    "use strict";
    //// Object cloning utilities
    var identity = function (x) { return x; };
    var _map = function (from, to, mapFunc, mapFuncParam) {
        Object.getOwnPropertyNames(from).forEach(function (k) {
            to[k] = mapFunc(from[k], mapFuncParam);
        });
    };
    var map = function (obj, mapFunc, mapFuncParam) {
        //var clone = {}; // Loses too much information!
        //var clone = Object.create(Object.getPrototypeOf(obj)); // Fails to construct arrays right, so length becomes enumerable
        var prototype = Object.getPrototypeOf(obj);
        var constructor = prototype.constructor;
        if (constructor.createFrom) {
            var props = {};
            _map(obj, props, mapFunc, mapFuncParam);
            return constructor.createFrom(props);
        }
        else {
            var clone = new (prototype.constructor)();
            _map(obj, clone, mapFunc, mapFuncParam);
            return clone;
        }
    };
    function clone(obj) {
        return map(obj, identity, null);
    }
    exports.clone = clone;
    ;
    var deepFrozen = Symbol("deep freeze ID");
    function isFrozen(obj) {
        if (Object.isFrozen(obj))
            return true;
        // But!  Some objects we want to treat as frozen even though we can't Object.freeze them.
        // Like array buffer arrays.
        if (obj[deepFrozen])
            return true;
        return false;
    }
    function isDeepFrozen(val) {
        return !!((typeof val !== 'function' && typeof val !== 'object') || val === null || val[deepFrozen]);
    }
    exports.isDeepFrozen = isDeepFrozen;
    ;
    function deepFreezeIdUnchecked(val) {
        return val[deepFrozen];
    }
    exports.deepFreezeIdUnchecked = deepFreezeIdUnchecked;
    function deepFreezeId(val) {
        if ((typeof val !== 'function' && typeof val !== 'object'))
            throw new Error("Only objects and functions can have a deepFreezeId.  Given a " + typeof (val));
        if (val[deepFrozen] == null)
            throw new Error("Object lacks a deep freeze ID");
        return deepFreezeIdUnchecked(val);
    }
    exports.deepFreezeId = deepFreezeId;
    /**
     * Differs from object.feeze only in that this will add the deepFrozen
     * property if the object happens to be deep frozen.
     *
     * Why would you use this instead of deepFreeze?
     * Probably shouldn't.
     */
    function freeze(obj, inPlace) {
        if (inPlace === void 0) { inPlace = false; }
        if (isFrozen(obj))
            return obj;
        var hasAnyMutableProperties = false;
        Object.getOwnPropertyNames(obj).forEach(function (k) {
            if (!isDeepFrozen(obj[k])) {
                hasAnyMutableProperties = true;
            }
        });
        var frozenObj = inPlace ? obj : clone(obj);
        if (!hasAnyMutableProperties)
            frozenObj[deepFrozen] = ++lastFreezeId;
        return Object.freeze(frozenObj);
    }
    exports.freeze = freeze;
    ;
    var lastFreezeId = 0;
    function isObjectFreezable(obj) {
        if (obj.buffer instanceof ArrayBuffer)
            return false; // "Cannot freeze array buffer views" says Chrome.
        return true;
    }
    /**
     * Return either the object or a clone of it that is deep frozen.
     * To ensure that your exiting object remains mutable (assuming it is),
     * pass true to the (slightly misnamed) newInstance parameter.
     *
     * @param {object} obj the object to freeze
     * @param {boolean} inPlace true if you want to allow the object to be frozen in-place;
     *   otherwise, the original object is left as-is and any freezing would be done on a new object.
     *   Note that even when true, this does not guarantee that the object will be deep-frozen in-place;
     *   If the object is frozen but not deep-frozen, for example, a new instance will be returned.
     *   Also note that passing false does not guarantee a new instance;
     *   If the object is already deep-frozen, that same object will be returned.
     */
    function deepFreeze(obj, allowInPlace) {
        if (allowInPlace === void 0) { allowInPlace = false; }
        if (isDeepFrozen(obj))
            return obj;
        // If it ain't /deep frozen/ we're going to have
        // to thaw it at least to add the deepFrozen property.
        obj = thaw(allowInPlace ? obj : clone(obj));
        _map(obj, obj, deepFreeze, allowInPlace);
        obj[deepFrozen] = ++lastFreezeId;
        if (isObjectFreezable(obj))
            Object.freeze(obj);
        return obj;
    }
    exports.deepFreeze = deepFreeze;
    ;
    function thaw(obj) {
        if (obj == null)
            return obj;
        if (!isFrozen(obj))
            return obj;
        if (typeof obj !== 'object' && typeof obj !== 'function')
            return obj;
        return map(obj, identity, null);
    }
    exports.thaw = thaw;
    ;
    function deepThaw(obj) {
        obj = thaw(obj);
        _map(obj, obj, thaw, null);
        return obj;
    }
    exports.deepThaw = deepThaw;
    ;
});
define("togos-game21/vector3ds", ["require", "exports", "togos-game21/DeepFreezer"], function (require, exports, DeepFreezer_1) {
    "use strict";
    function makeVector(x, y, z) {
        if (x === void 0) { x = 0; }
        if (y === void 0) { y = 0; }
        if (z === void 0) { z = 0; }
        return { x: x, y: y, z: z };
    }
    exports.makeVector = makeVector;
    function setVector(v, x, y, z) {
        if (v) {
            v.x = x;
            v.y = y;
            v.z = z;
        }
        else {
            v = { x: x, y: y, z: z };
        }
        return v;
    }
    exports.setVector = setVector;
    exports.ZERO_VECTOR = DeepFreezer_1.deepFreeze(makeVector(0, 0, 0));
    exports.I_VECTOR = DeepFreezer_1.deepFreeze(makeVector(1, 0, 0));
    exports.J_VECTOR = DeepFreezer_1.deepFreeze(makeVector(0, 1, 0));
    exports.K_VECTOR = DeepFreezer_1.deepFreeze(makeVector(0, 0, 1));
    exports.TEMP_VECTOR = makeVector();
    function vectorToArray(v) {
        return [v.x, v.y, v.z];
    }
    exports.vectorToArray = vectorToArray;
    function vectorToString(v) {
        if (v === undefined)
            return '(undefined vector)';
        if (v === null)
            return '(null vector)';
        return "<" + v.x.toFixed(3) + "," + v.y.toFixed(3) + "," + v.z.toFixed(3) + ">";
    }
    exports.vectorToString = vectorToString;
    function parseVector(a) {
        if (typeof a.x == 'number' && typeof a.y == 'number' && typeof a.z == 'number')
            return a;
        if (typeof a[0] == 'number' && typeof a[1] == 'number' && typeof a[2] == 'number') {
            return makeVector(a[0], a[1], a[2]);
        }
        return makeVector(+a.x, +a.y, +a.z);
    }
    exports.parseVector = parseVector;
});
define("togos-game21/vector3dmath", ["require", "exports", "togos-game21/vector3ds"], function (require, exports, vector3ds_1) {
    "use strict";
    function roundToNearestMultiple(n, gridSize) {
        return Math.round(n / gridSize) * gridSize;
    }
    function scaleVector(v, s, dest) {
        if (s == 1 && dest == null)
            return v;
        return vector3ds_1.setVector(dest, v.x * s, v.y * s, v.z * s);
    }
    exports.scaleVector = scaleVector;
    function vectorIsZero(v) {
        return v.x == 0 && v.y == 0 && v.z == 0;
    }
    exports.vectorIsZero = vectorIsZero;
    function vectorLength(v) {
        return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
    }
    exports.vectorLength = vectorLength;
    function normalizeVector(vec, targetLength, dest) {
        if (targetLength === void 0) { targetLength = 1; }
        var len = vectorLength(vec);
        var sca = len == 0 ? 1 : targetLength / len;
        return scaleVector(vec, sca, dest);
    }
    exports.normalizeVector = normalizeVector;
    function accumulateVector(v0, dest, scale) {
        if (scale === void 0) { scale = 1; }
        dest.x += v0.x * scale;
        dest.y += v0.y * scale;
        dest.z += v0.z * scale;
        return dest;
    }
    exports.accumulateVector = accumulateVector;
    function addVector(v0, v1, dest) {
        return vector3ds_1.setVector(dest, v0.x + v1.x, v0.y + v1.y, v0.z + v1.z);
    }
    exports.addVector = addVector;
    function subtractVector(v0, v1, dest) {
        return vector3ds_1.setVector(dest, v0.x - v1.x, v0.y - v1.y, v0.z - v1.z);
    }
    exports.subtractVector = subtractVector;
    function vectorDifferenceMagnitude(v0, v1) {
        // return subtract(v0,v1).length
        var dx = v0.x - v1.x, dy = v0.y - v1.y, dz = v0.z - v1.z;
        return Math.sqrt(dx * dx + dy * dy + dz * dz);
    }
    exports.vectorDifferenceMagnitude = vectorDifferenceMagnitude;
    function roundVectorToGrid(vec, xGrid, yGrid, zGrid, dest) {
        if (xGrid === void 0) { xGrid = 1; }
        if (yGrid === void 0) { yGrid = xGrid; }
        if (zGrid === void 0) { zGrid = xGrid; }
        return vector3ds_1.setVector(dest, roundToNearestMultiple(vec.x, xGrid), roundToNearestMultiple(vec.y, yGrid), roundToNearestMultiple(vec.z, zGrid));
    }
    exports.roundVectorToGrid = roundVectorToGrid;
    function dotProduct(v0, v1) {
        return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z;
    }
    exports.dotProduct = dotProduct;
});
define("tshash/utils", ["require", "exports"], function (require, exports) {
    "use strict";
    function asciiDecode(data, maxAllowed) {
        if (maxAllowed === void 0) { maxAllowed = 127; }
        var p = [];
        for (var i = 0; i < data.length; ++i) {
            if (data[i] < 0)
                throw new Error("Code point is <0: " + data[i]);
            if (data[i] > maxAllowed)
                throw new Error("Code point is >" + maxAllowed + ": " + data[i]);
            p.push(String.fromCharCode(data[i]));
        }
        return p.join('');
    }
    exports.asciiDecode = asciiDecode;
    function asciiEncode(str, maxAllowed) {
        if (maxAllowed === void 0) { maxAllowed = 127; }
        var data = new Uint8Array(str.length);
        for (var i = 0; i < str.length; ++i) {
            var cp = str.charCodeAt(i);
            if (cp > maxAllowed)
                throw new Error("Code point is >" + maxAllowed + ": " + cp);
            data[i] = cp;
        }
        return data;
    }
    exports.asciiEncode = asciiEncode;
    function utf8Encode(str) {
        if (str.length == 0)
            return new Uint8Array(0);
        if (typeof TextEncoder != 'undefined') {
            return (new TextEncoder('utf-8')).encode(str);
        }
        // Otherwise fall back to the ASCII encoder and hope that it's good enough.
        return asciiEncode(str);
    }
    exports.utf8Encode = utf8Encode;
    function utf8Decode(bytes) {
        if (bytes.length == 0)
            return '';
        if (typeof TextEncoder != 'undefined') {
            return (new TextDecoder('utf-8')).decode(bytes);
        }
        // Otherwise fall back to the ASCII decoder and hope that it's good enough.
        return asciiDecode(bytes);
    }
    exports.utf8Decode = utf8Decode;
    ////
    function toUint8Array(data) {
        if (data instanceof Uint8Array) {
            return data;
        }
        else if (typeof (data) == 'string') {
            return utf8Encode(data);
        }
        else if (data instanceof ArrayBuffer) {
            return new Uint8Array(data);
        }
        else {
            throw new Error("Don't know how to convert " + JSON.stringify(data) + " to Uint8Array");
        }
    }
    exports.toUint8Array = toUint8Array;
    //// Hex encoding/decoding
    function hexDig(i) {
        return String.fromCharCode(i < 10 ? 48 + i : 87 + i);
    }
    function hexVal(charCode) {
        switch (charCode) {
            case 0x30: return 0;
            case 0x31: return 1;
            case 0x32: return 2;
            case 0x33: return 3;
            case 0x34: return 4;
            case 0x35: return 5;
            case 0x36: return 6;
            case 0x37: return 7;
            case 0x38: return 8;
            case 0x39: return 9;
            case 0x41:
            case 0x61: return 10;
            case 0x42:
            case 0x62: return 11;
            case 0x43:
            case 0x63: return 12;
            case 0x44:
            case 0x64: return 13;
            case 0x45:
            case 0x65: return 14;
            case 0x46:
            case 0x66: return 15;
            default: throw new Error("Invalid hex digit: " + String.fromCharCode(charCode));
        }
    }
    function hexEncode(data, begin, end) {
        if (begin === void 0) { begin = 0; }
        if (end === void 0) { end = data.length; }
        var astuff = new Array(data.length);
        for (var i = begin; i < end; ++i) {
            astuff[i] = hexDig(data[i] >> 4) + hexDig(data[i] & 0xF);
        }
        return astuff.join('');
    }
    exports.hexEncode = hexEncode;
    function hexDecode(hex) {
        if (hex.length % 2 != 0)
            throw new Error("Can't hex-decode a string with non-even length: " + hex.length);
        var byteCount = hex.length / 2;
        var rez = new Uint8Array(byteCount);
        for (var i = 0; i < byteCount; ++i) {
            rez[i] = (hexVal(hex.charCodeAt(i * 2)) << 4) | hexVal(hex.charCodeAt(i * 2 + 1));
        }
        return rez;
    }
    exports.hexDecode = hexDecode;
    //// Base32 encoding/decoding
    var BASE32_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
    var BASE32_CHAR_VALUES = [
        0xFF, 0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
        0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
        0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
        0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
        0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
        0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
        0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF // 'x', 'y', 'z', '{', '|', '}', '~', 'DEL'
    ];
    /*
     * Base32 - encodes and decodes RFC3548 Base32
     * (see http://www.faqs.org/rfcs/rfc3548.html )
     *
     * Based on Java code by Bitzi (PD) 2006.
     *
     * @author Robert Kaye
     * @author Gordon Mohr
     * @author TOGoS (converted to TypeScript)
     */
    /**
     * Encodes byte array to Base32 String.
     *
     * @param {Uint8Array} bytes - bytes to encode.
     * @return {string}
     */
    function base32Encode(thing) {
        var bytes = toUint8Array(thing);
        var i = 0, j = 0, index = 0, digit = 0;
        var currByte, nextByte;
        var base32 = new Array(Math.floor((bytes.length + 7) * 8 / 5));
        while (i < bytes.length) {
            currByte = bytes[i];
            /* Is the current digit going to span a byte boundary? */
            if (index > 3) {
                nextByte = (i + 1) < bytes.length ? bytes[i + 1] : 0;
                digit = currByte & (0xFF >> index);
                index = (index + 5) % 8;
                digit <<= index;
                digit |= nextByte >> (8 - index);
                ++i;
            }
            else {
                digit = (currByte >> (8 - (index + 5))) & 0x1F;
                index = (index + 5) % 8;
                if (index == 0)
                    ++i;
            }
            base32[j++] = BASE32_CHARS.charAt(digit);
        }
        return base32.slice(0, j).join('');
    }
    exports.base32Encode = base32Encode;
    /**
     * Decodes the given Base32 String to a raw byte array.
     *
     * @param {string|Uint8Array|DataBuffer} base32-encoded data
     * @return {Uint8Array} decoded data
     */
    function base32Decode(base32) {
        var i, index, lookup, offset, digit;
        var bytes = new Uint8Array(Math.floor(base32.length * 5 / 8));
        var firstCharCode = "0".charCodeAt(0);
        for (i = 0, index = 0, offset = 0; i < base32.length; ++i) {
            lookup = base32.charCodeAt(i) - firstCharCode;
            /* Skip chars outside the lookup table */
            if (lookup < 0 || lookup >= BASE32_CHAR_VALUES.length)
                continue;
            digit = BASE32_CHAR_VALUES[lookup];
            /* If this digit is not in the table, ignore it */
            if (digit == 0xFF)
                continue;
            if (index <= 3) {
                index = (index + 5) % 8;
                if (index == 0) {
                    bytes[offset++] |= digit;
                    if (offset >= bytes.length)
                        break;
                }
                else {
                    bytes[offset] |= digit << (8 - index);
                }
            }
            else {
                index = (index + 5) % 8;
                bytes[offset] |= (digit >>> index);
                offset++;
                if (offset >= bytes.length)
                    break;
                bytes[offset] |= digit << (8 - index);
            }
        }
        return bytes;
    }
    exports.base32Decode = base32Decode;
});
define("togos-game21/BrowserStorageDatastore", ["require", "exports", "tshash/utils"], function (require, exports, utils_1) {
    "use strict";
    var BrowserStorageDatastore = (function () {
        function BrowserStorageDatastore(_identify, browserStorage) {
            this._identify = _identify;
            this.browserStorage = browserStorage;
        }
        Object.defineProperty(BrowserStorageDatastore.prototype, "identify", {
            get: function () { return this._identify; },
            enumerable: true,
            configurable: true
        });
        /** Returns the data if immediately available.  Otherwise returns null. */
        BrowserStorageDatastore.prototype.get = function (uri) {
            var str = this.browserStorage.getItem(uri);
            if (str != null)
                return utils_1.utf8Encode(str);
            var hex = this.browserStorage.getItem("hex-encode:" + uri);
            if (hex != null)
                return utils_1.hexDecode(hex);
            return undefined;
        };
        BrowserStorageDatastore.prototype.fetch = function (uri) {
            var data = this.get(uri);
            return data == null ? Promise.reject(new Error(uri + " not found in BrowserStorageDatastore")) : Promise.resolve(data);
        };
        BrowserStorageDatastore.prototype.store = function (data) {
            return Promise.resolve(this.fastStore(data));
        };
        /**
         * Store the data, return its ID.
         * The onComplete callback, if passed, will not be invoked until *after*
         * this function returns.
         */
        BrowserStorageDatastore.prototype.fastStore = function (data, onComplete) {
            if (onComplete)
                throw new Error("onComplete not supported by BrowserStorageDatastore#fastStore");
            var id = this._identify(data);
            this.put(id, data);
            return id;
        };
        BrowserStorageDatastore.prototype.utf8Decode = function (data) {
            try {
                var decoded = utils_1.utf8Decode(data);
                var reencoded = utils_1.utf8Encode(decoded);
                if (reencoded.length != data.length)
                    return undefined;
                for (var i = 0; i < data.length; ++i) {
                    if (data[i] != reencoded[i])
                        return undefined;
                }
                return decoded;
            }
            catch (err) {
                return undefined;
            }
        };
        BrowserStorageDatastore.prototype.put = function (id, data) {
            var utf8Decoded = this.utf8Decode(data);
            if (utf8Decoded != null) {
                this.browserStorage.setItem(id, utf8Decoded);
            }
            else {
                this.browserStorage.setItem("hex-encode:" + id, utils_1.hexEncode(data));
            }
            return Promise.resolve(id);
        };
        return BrowserStorageDatastore;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = BrowserStorageDatastore;
});
/// <reference path="../Promise.d.ts" />
/// <reference path="../node.d.ts" />
define("tshash/SHA1", ["require", "exports"], function (require, exports) {
    "use strict";
    function lrot(n, shift) {
        return ((n << shift) | (n >>> (32 - shift)));
    }
    // Translated from pseudocode at
    //   https://en.wikipedia.org/wiki/SHA-1
    // and taking some hints from
    //   https://gist.github.com/ducksoupdev/bbfcf8b9cee688b97865
    var SHA1Hashing = (function () {
        function SHA1Hashing() {
            this.buffer = new ArrayBuffer(80 * 4);
            this.bufferUint8s = new Uint8Array(this.buffer);
            this.bufferView = new DataView(this.buffer);
            this.valid = false;
            this.reset();
        }
        SHA1Hashing.prototype.reset = function () {
            this.h0 = 0x67452301;
            this.h1 = 0xEFCDAB89;
            this.h2 = 0x98BADCFE;
            this.h3 = 0x10325476;
            this.h4 = 0xC3D2E1F0;
            this.bufLen = 0;
            this.ml = 0;
            this.valid = true;
        };
        SHA1Hashing.prototype.updateChunk = function () {
            var bv = this.bufferView;
            for (var i = 16; i < 80; ++i) {
                bv.setUint32(i * 4, lrot(bv.getUint32((i - 3) * 4) ^
                    bv.getUint32((i - 8) * 4) ^
                    bv.getUint32((i - 14) * 4) ^
                    bv.getUint32((i - 16) * 4), 1));
            }
            var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4;
            for (var i = 0; i < 80; ++i) {
                var f = void 0, k = void 0;
                if (i < 20) {
                    f = (b & c) | ((~b) & d);
                    k = 0x5A827999;
                }
                else if (i < 40) {
                    f = b ^ c ^ d;
                    k = 0x6ED9EBA1;
                }
                else if (i < 60) {
                    f = (b & c) | (b & d) | (c & d);
                    k = 0x8F1BBCDC;
                }
                else {
                    f = b ^ c ^ d;
                    k = 0xCA62C1D6;
                }
                var temp = lrot(a, 5) + f + e + k + bv.getUint32(i * 4);
                e = d;
                d = c;
                c = lrot(b, 30);
                b = a;
                a = temp;
            }
            this.h0 += a;
            this.h1 += b;
            this.h2 += c;
            this.h3 += d;
            this.h4 += e;
        };
        SHA1Hashing.prototype.update = function (data) {
            if (!this.valid) {
                throw new Error("SHA1Hashing in invalid state.  Someone forgot to call reset()");
            }
            var buf = this.bufferUint8s;
            var bi = this.bufLen;
            var di = 0;
            for (di = 0; di < data.length; ++di, ++bi) {
                if (bi == 64) {
                    this.updateChunk();
                    bi = 0;
                }
                buf[bi] = data[di];
            }
            this.bufLen = bi;
            this.ml += data.length;
        };
        SHA1Hashing.prototype.updateByte = function (v) {
            var bi = this.bufLen;
            if (bi == 64) {
                this.updateChunk();
                bi = 0;
            }
            this.bufferUint8s[bi++] = 0x80;
            this.bufLen = bi;
        };
        SHA1Hashing.prototype.digest = function () {
            // If message is a multiple of 8 bits (ours always are), 'append a bit' (0x80):
            this.updateByte(0x80);
            var bi = this.bufLen;
            var buf = this.bufferUint8s;
            if (bi > 56) {
                for (; bi < 64; ++bi)
                    buf[bi] = 0;
                this.updateChunk();
                bi = 0;
            }
            for (; bi < 56; ++bi) {
                buf[bi] = 0;
            }
            var bv = this.bufferView;
            var ml = this.ml * 8;
            var lengthHigh = Math.floor(ml / 4294967296);
            var lengthLow = ml & 0xFFFFFFFF;
            bv.setUint32(56, lengthHigh);
            bv.setUint32(60, lengthLow);
            this.updateChunk();
            var digestBuf = new ArrayBuffer(20);
            var digestView = new DataView(digestBuf);
            digestView.setUint32(0, this.h0);
            digestView.setUint32(4, this.h1);
            digestView.setUint32(8, this.h2);
            digestView.setUint32(12, this.h3);
            digestView.setUint32(16, this.h4);
            return new Uint8Array(digestBuf);
        };
        return SHA1Hashing;
    }());
    exports.SHA1Hashing = SHA1Hashing;
    var SHA1 = (function () {
        function SHA1() {
        }
        SHA1.newHashing = function () {
            return new SHA1Hashing;
        };
        return SHA1;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = SHA1;
});
define("tshash/index", ["require", "exports", "tshash/utils", "tshash/SHA1", "tshash/utils"], function (require, exports, utils_2, SHA1_1, utils_3) {
    "use strict";
    exports.utf8Encode = utils_3.utf8Encode;
    exports.utf8Decode = utils_3.utf8Decode;
    exports.base32Encode = utils_3.base32Encode;
    exports.base32Decode = utils_3.base32Decode;
    exports.hexEncode = utils_3.hexEncode;
    exports.hexDecode = utils_3.hexDecode;
    function hash(data, hashFunc) {
        var u8 = utils_2.toUint8Array(data);
        var hashing = hashFunc.newHashing();
        hashing.update(u8);
        return hashing.digest();
    }
    exports.hash = hash;
    /** @deprecated; just use hash(str, hashFunc) */
    function hashString(str, hashFunc) {
        return hash(utils_2.utf8Encode(str), hashFunc);
    }
    exports.hashString = hashString;
    function sha1Urn(thing) {
        return "urn:sha1:" + utils_2.base32Encode(hash(thing, SHA1_1.default));
    }
    exports.sha1Urn = sha1Urn;
});
define("togos-game21/CachingDatastore", ["require", "exports"], function (require, exports) {
    "use strict";
    var CachingDatastore = (function () {
        function CachingDatastore(_identify, cacheDs, fallbackDs) {
            this._identify = _identify;
            this.cacheDs = cacheDs;
            this.fallbackDs = fallbackDs;
        }
        Object.defineProperty(CachingDatastore.prototype, "identify", {
            get: function () { return this._identify; },
            enumerable: true,
            configurable: true
        });
        CachingDatastore.prototype.get = function (uri) {
            var v = this.cacheDs.get(uri);
            if (v == null) {
                v = this.fallbackDs.get(uri);
                if (v != null) {
                    this.cacheDs.put(uri, v);
                }
            }
            return v;
        };
        CachingDatastore.prototype.fetch = function (uri) {
            var _this = this;
            return this.cacheDs.fetch(uri).catch(function () {
                return _this.fallbackDs.fetch(uri).then(function (v) {
                    _this.cacheDs.put(uri, v);
                    return v;
                });
            });
        };
        CachingDatastore.prototype.store = function (data) {
            var k = this._identify(data);
            return this.put(k, data);
        };
        CachingDatastore.prototype.fastStore = function (data, onComplete) {
            var ident = this._identify(data);
            var putProm = this.put(ident, data);
            if (onComplete) {
                var onCompleat_1 = onComplete;
                putProm.then(function (id) { return onCompleat_1(true); }, function (err) { return onCompleat_1(false, err); });
            }
            return ident;
        };
        CachingDatastore.prototype.put = function (id, data) {
            return Promise.all([
                this.cacheDs.put(id, data),
                this.fallbackDs.put(id, data)
            ]).then(function () { return id; });
        };
        return CachingDatastore;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = CachingDatastore;
});
define("togos-game21/aabbs", ["require", "exports", "togos-game21/DeepFreezer"], function (require, exports, DeepFreezer_7) {
    "use strict";
    function makeAabb(minX, minY, minZ, maxX, maxY, maxZ) {
        return { minX: minX, minY: minY, minZ: minZ, maxX: maxX, maxY: maxY, maxZ: maxZ };
    }
    exports.makeAabb = makeAabb;
    function setAabb(aabb, minX, minY, minZ, maxX, maxY, maxZ) {
        if (!aabb)
            return makeAabb(minX, minY, minZ, maxX, maxY, maxZ);
        aabb.minX = minX;
        aabb.minY = minY;
        aabb.minZ = minZ;
        aabb.maxX = maxX;
        aabb.maxY = maxY;
        aabb.maxZ = maxZ;
        return aabb;
    }
    exports.setAabb = setAabb;
    function aabbWidth(aabb) { return aabb.maxX - aabb.minX; }
    exports.aabbWidth = aabbWidth;
    function aabbHeight(aabb) { return aabb.maxY - aabb.minY; }
    exports.aabbHeight = aabbHeight;
    function aabbDepth(aabb) { return aabb.maxZ - aabb.minZ; }
    exports.aabbDepth = aabbDepth;
    function aabbAverageX(aabb) { return (aabb.maxX + aabb.minX) / 2; }
    exports.aabbAverageX = aabbAverageX;
    function aabbAverageY(aabb) { return (aabb.maxY + aabb.minY) / 2; }
    exports.aabbAverageY = aabbAverageY;
    function aabbAverageZ(aabb) { return (aabb.maxZ + aabb.minZ) / 2; }
    exports.aabbAverageZ = aabbAverageZ;
    function scaleAabb(aabb, scale) {
        return {
            minX: aabb.minX * scale, minY: aabb.minY * scale, minZ: aabb.minZ * scale,
            maxX: aabb.maxX * scale, maxY: aabb.maxY * scale, maxZ: aabb.maxZ * scale,
        };
    }
    exports.scaleAabb = scaleAabb;
    function aabbIntersectsWithOffset(aPos, aBb, bPos, bBb) {
        if (aPos.x + aBb.maxX <= bPos.x + bBb.minX)
            return false;
        if (aPos.x + aBb.minX >= bPos.x + bBb.maxX)
            return false;
        if (aPos.y + aBb.maxY <= bPos.y + bBb.minY)
            return false;
        if (aPos.y + aBb.minY >= bPos.y + bBb.maxY)
            return false;
        if (aPos.z + aBb.maxZ <= bPos.z + bBb.minZ)
            return false;
        if (aPos.z + aBb.minZ >= bPos.z + bBb.maxZ)
            return false;
        return true;
    }
    exports.aabbIntersectsWithOffset = aabbIntersectsWithOffset;
    function aabbContainsVector(bb, v) {
        if (v.x < bb.minX)
            return false;
        if (v.y < bb.minY)
            return false;
        if (v.z < bb.minZ)
            return false;
        if (v.x > bb.maxX)
            return false;
        if (v.y > bb.maxY)
            return false;
        if (v.z > bb.maxZ)
            return false;
        return true;
    }
    exports.aabbContainsVector = aabbContainsVector;
    function offsetAabbContainsVector(bbOffset, bb, v) {
        if (v.x < bbOffset.x + bb.minX)
            return false;
        if (v.y < bbOffset.y + bb.minY)
            return false;
        if (v.z < bbOffset.z + bb.minZ)
            return false;
        if (v.x > bbOffset.x + bb.maxX)
            return false;
        if (v.y > bbOffset.y + bb.maxY)
            return false;
        if (v.z > bbOffset.z + bb.maxZ)
            return false;
        return true;
    }
    exports.offsetAabbContainsVector = offsetAabbContainsVector;
    exports.UNIT_CUBE = DeepFreezer_7.deepFreeze(makeAabb(-0.5, -0.5, -0.5, +0.5, +0.5, +0.5));
    exports.UNBOUNDED_AABB = DeepFreezer_7.deepFreeze(makeAabb(-Infinity, -Infinity, -Infinity, +Infinity, +Infinity, +Infinity));
    var _a;
});
define("togos-game21/Cuboid", ["require", "exports"], function (require, exports) {
    "use strict";
    var Cuboid = (function () {
        function Cuboid(minX, minY, minZ, maxX, maxY, maxZ) {
            if (minX === void 0) { minX = 0; }
            if (minY === void 0) { minY = 0; }
            if (minZ === void 0) { minZ = 0; }
            if (maxX === void 0) { maxX = 0; }
            if (maxY === void 0) { maxY = 0; }
            if (maxZ === void 0) { maxZ = 0; }
            this.minX = minX;
            this.minY = minY;
            this.minZ = minZ;
            this.maxX = maxX;
            this.maxY = maxY;
            this.maxZ = maxZ;
        }
        Object.defineProperty(Cuboid.prototype, "width", {
            get: function () { return this.maxX - this.minX; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Cuboid.prototype, "height", {
            get: function () { return this.maxY - this.minY; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Cuboid.prototype, "depth", {
            get: function () { return this.maxZ - this.minZ; },
            enumerable: true,
            configurable: true
        });
        //get isPositiveSize():boolean { return this.width > 0 && this.height > 0 && this.depth > 0; }
        Cuboid.intersection = function (c0, c1, dest) {
            if (dest === void 0) { dest = new Cuboid; }
            dest.minX = Math.max(c0.minX, c1.minX);
            dest.minY = Math.max(c0.minY, c1.minY);
            dest.minZ = Math.max(c0.minZ, c1.minZ);
            dest.maxX = Math.min(c0.maxX, c1.maxX);
            dest.maxY = Math.min(c0.maxY, c1.maxY);
            dest.maxZ = Math.min(c0.maxZ, c1.maxZ);
            return dest;
        };
        Cuboid.containsVector = function (cuboid, v) {
            if (v.x < cuboid.minX)
                return false;
            if (v.y < cuboid.minY)
                return false;
            if (v.z < cuboid.minZ)
                return false;
            if (v.x > cuboid.maxX)
                return false;
            if (v.y > cuboid.maxY)
                return false;
            if (v.z > cuboid.maxZ)
                return false;
            return true;
        };
        Cuboid.intersectsWithOffset = function (aPos, aBb, bPos, bBb) {
            if (aPos.x + aBb.maxX <= bPos.x + bBb.minX)
                return false;
            if (aPos.x + aBb.minX >= bPos.x + bBb.maxX)
                return false;
            if (aPos.y + aBb.maxY <= bPos.y + bBb.minY)
                return false;
            if (aPos.y + aBb.minY >= bPos.y + bBb.maxY)
                return false;
            if (aPos.z + aBb.maxZ <= bPos.z + bBb.minZ)
                return false;
            if (aPos.z + aBb.minZ >= bPos.z + bBb.maxZ)
                return false;
            return true;
        };
        Cuboid.prototype.containsVector = function (v) {
            return Cuboid.containsVector(this, v);
        };
        return Cuboid;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = Cuboid;
    ;
    function makeCuboid(minX, minY, minZ, maxX, maxY, maxZ) {
        if (minY === void 0) { minY = 0; }
        if (minZ === void 0) { minZ = 0; }
        if (maxX === void 0) { maxX = 0; }
        if (maxY === void 0) { maxY = 0; }
        if (maxZ === void 0) { maxZ = 0; }
        return new Cuboid(minX, minY, minZ, maxX, maxY, maxZ);
    }
    exports.makeCuboid = makeCuboid;
    function cuboidWidth(cuboid) {
        return cuboid.maxX - cuboid.minX;
    }
    exports.cuboidWidth = cuboidWidth;
    function cuboidHeight(cuboid) {
        return cuboid.maxY - cuboid.minY;
    }
    exports.cuboidHeight = cuboidHeight;
    function cuboidDepth(cuboid) {
        return cuboid.maxZ - cuboid.minZ;
    }
    exports.cuboidDepth = cuboidDepth;
    var _a;
});
define("togos-game21/Quaternion", ["require", "exports", "togos-game21/DeepFreezer"], function (require, exports, DeepFreezer_8) {
    "use strict";
    var Quaternion = (function () {
        /*
         * Sometimes quaternions are written as w + xi + yj + zk,
         * Where i, j, and k are imaginary numbers.
         * I use use the symbols 'a, b, c, d' to mean 'w, x, y, z', respectively,
         * probably because those were used in some of the conversion examples I based my code on.
         * i.e. <1, 0, 0, 0> has only a=1, i.e. w=1, i.e. only the real component is non-zero.
         * Hence that being the identity.
         */
        function Quaternion(a, b, c, d) {
            if (a === void 0) { a = 1; }
            if (b === void 0) { b = 0; }
            if (c === void 0) { c = 0; }
            if (d === void 0) { d = 0; }
            this.a = a;
            this.b = b;
            this.c = c;
            this.d = d;
        }
        Quaternion.prototype.set = function (a, b, c, d) {
            this.a = a;
            this.b = b;
            this.c = c;
            this.d = d;
            return this;
        };
        Quaternion.prototype.normalize = function () {
            return Quaternion.normalize(this);
        };
        /**
         * Assumes x, y, z is normalized!
         */
        Quaternion.fromXYZAxisAngle = function (x, y, z, angle, dest) {
            if (dest === void 0) { dest = new Quaternion(0, 0, 0, 0); }
            // https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
            var s = Math.sin(angle / 2);
            return dest.set(Math.cos(angle / 2), s * x, s * y, s * z);
        };
        Quaternion.fromAxisAngle = function (v, angle, dest) {
            if (dest === void 0) { dest = new Quaternion; }
            return this.fromXYZAxisAngle(v.x, v.y, v.z, angle, dest);
        };
        Quaternion.multiply = function (q0, q1, dest) {
            if (dest === void 0) { dest = new Quaternion; }
            dest.set(q0.a * q1.a - q0.b * q1.b - q0.c * q1.c - q0.d * q1.d, q0.a * q1.b + q0.b * q1.a + q0.c * q1.d - q0.d * q1.c, q0.a * q1.c - q0.b * q1.d + q0.c * q1.a + q0.d * q1.b, q0.a * q1.d + q0.b * q1.c - q0.c * q1.b + q0.d * q1.a);
            return dest;
        };
        Quaternion.dotProduct = function (q0, q1) {
            return q0.a * q1.a + q0.b * q1.b + q0.c * q1.c + q0.d * q1.d;
        };
        Quaternion.normalize = function (q, dest) {
            if (dest === void 0) { dest = new Quaternion; }
            var len = Math.sqrt(q.a * q.a + q.b * q.b + q.c * q.c + q.d * q.d);
            if (len == 0)
                dest.set(q.a, q.b, q.c, q.d);
            dest.set(q.a / len, q.b / len, q.c / len, q.d / len);
            return dest;
        };
        Quaternion.random = function () {
            var q = new Quaternion(Math.random(), Math.random(), Math.random(), Math.random());
            this.normalize(q, q);
            return q;
        };
        // based on this guy's code:
        // https://github.com/Kent-H/blue3D/blob/master/Blue3D/src/blue3D/type/QuaternionF.java
        Quaternion.slerp = function (q0, q1, t, allowFlip, dest) {
            if (dest === void 0) { dest = new Quaternion; }
            // Warning: this method should not normalize the Quaternion
            var cosAngle = this.dotProduct(q0, q1);
            var c1, c2;
            // Linear interpolation for close orientations
            if ((1.0 - Math.abs(cosAngle)) < 0.01) {
                c1 = 1.0 - t;
                c2 = t;
            }
            else {
                // Spherical interpolation
                var angle = Math.acos(Math.abs(cosAngle));
                var sinAngle = Math.sin(angle);
                c1 = (Math.sin(angle * (1.0 - t)) / sinAngle);
                c2 = (Math.sin(angle * t) / sinAngle);
            }
            // Use the shortest path
            if (allowFlip && (cosAngle < 0.0))
                c1 = -c1;
            dest.a = c1 * q0.a + c2 * q1.a;
            dest.b = c1 * q0.b + c2 * q1.b;
            dest.c = c1 * q0.c + c2 * q1.c;
            dest.d = c1 * q0.d + c2 * q1.d;
            return dest;
        };
        Quaternion.areEqual = function (q0, q1) {
            return q0.a === q1.a && q0.b === q1.b && q0.c === q1.c && q0.d === q1.d;
        };
        Quaternion.IDENTITY = DeepFreezer_8.deepFreeze(new Quaternion(1, 0, 0, 0));
        return Quaternion;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = Quaternion;
    function assertEquals(a, b, m) {
        var aJson = JSON.stringify(a);
        var bJson = JSON.stringify(b);
        if (aJson !== bJson) {
            throw new Error("Assertion failed: " + aJson + " != " + bJson + (m ? "; " + m : ""));
        }
    }
    assertEquals(Quaternion.IDENTITY, Quaternion.multiply(Quaternion.IDENTITY, Quaternion.IDENTITY));
    var _a;
});
define("togos-game21/TransformationMatrix3D", ["require", "exports", "togos-game21/DeepFreezer", "togos-game21/vector3ds"], function (require, exports, DeepFreezer_9, vector3ds_7) {
    "use strict";
    var fmtNum = function (num, size, digits) {
        if (digits === void 0) { digits = 2; }
        var s = num.toPrecision(digits);
        while (s.length < size)
            s = " " + s;
        return s;
    };
    /**
     * Acts as a 4D matrix, but only storing the first 3 rows.
     * The last row is assumed to be [0,0,0,1]
     */
    var TransformationMatrix3D = (function () {
        function TransformationMatrix3D(xx, xy, xz, x1, yx, yy, yz, y1, zx, zy, zz, z1) {
            if (xx === void 0) { xx = 0; }
            if (xy === void 0) { xy = 0; }
            if (xz === void 0) { xz = 0; }
            if (x1 === void 0) { x1 = 0; }
            if (yx === void 0) { yx = 0; }
            if (yy === void 0) { yy = 0; }
            if (yz === void 0) { yz = 0; }
            if (y1 === void 0) { y1 = 0; }
            if (zx === void 0) { zx = 0; }
            if (zy === void 0) { zy = 0; }
            if (zz === void 0) { zz = 0; }
            if (z1 === void 0) { z1 = 0; }
            this.xx = xx;
            this.xy = xy;
            this.xz = xz;
            this.x1 = x1;
            this.yx = yx;
            this.yy = yy;
            this.yz = yz;
            this.y1 = y1;
            this.zx = zx;
            this.zy = zy;
            this.zz = zz;
            this.z1 = z1;
        }
        Object.defineProperty(TransformationMatrix3D.prototype, "scale", {
            // TODO: This is similar to 'magnitude',
            // which is the maximum stretching (in any direction)
            // done by this matrix.
            // (according to some math site, that's what matrix magnitude means)
            get: function () {
                var xScale = Math.sqrt(this.xx * this.xx + this.yx * this.yx + this.zx * this.zx);
                var yScale = Math.sqrt(this.xy * this.xy + this.yy * this.yy + this.zy * this.zy);
                var zScale = Math.sqrt(this.xz * this.xz + this.yz * this.yz + this.zz * this.zz);
                return (xScale + yScale + zScale) / 3;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TransformationMatrix3D.prototype, "hasRotation", {
            get: function () {
                return this.xy != 0 || this.xz != 0 || this.yx != 0 || this.yz != 0 || this.zx != 0 || this.zy != 0;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TransformationMatrix3D.prototype, "hasTranslation", {
            get: function () {
                return this.x1 != 0 || this.y1 != 0 || this.z1 != 0;
            },
            enumerable: true,
            configurable: true
        });
        TransformationMatrix3D.prototype.set = function (xx, xy, xz, x1, yx, yy, yz, y1, zx, zy, zz, z1) {
            this.xx = xx;
            this.xy = xy;
            this.xz = xz;
            this.x1 = x1;
            this.yx = yx;
            this.yy = yy;
            this.yz = yz;
            this.y1 = y1;
            this.zx = zx;
            this.zy = zy;
            this.zz = zz;
            this.z1 = z1;
            return this;
        };
        Object.defineProperty(TransformationMatrix3D.prototype, "1x", {
            get: function () { return 0; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TransformationMatrix3D.prototype, "1y", {
            get: function () { return 0; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TransformationMatrix3D.prototype, "1z", {
            get: function () { return 0; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TransformationMatrix3D.prototype, "11", {
            get: function () { return 1; },
            enumerable: true,
            configurable: true
        });
        TransformationMatrix3D.prototype.multiplyVector = function (v, dest) {
            return vector3ds_7.setVector(dest, this.xx * v.x + this.xy * v.y + this.xz * v.z + this.x1, this.yx * v.x + this.yy * v.y + this.yz * v.z + this.y1, this.zx * v.x + this.zy * v.y + this.zz * v.z + this.z1);
        };
        TransformationMatrix3D.scale = function (sx, sy, sz, dest) {
            if (sy === void 0) { sy = sx; }
            if (sz === void 0) { sz = sx; }
            if (dest === void 0) { dest = new TransformationMatrix3D; }
            return dest.set(sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, sz, 0);
        };
        TransformationMatrix3D.translationXYZ = function (x, y, z, dest) {
            if (dest === void 0) { dest = new TransformationMatrix3D; }
            return dest.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z);
        };
        TransformationMatrix3D.translation = function (xlt, dest) {
            if (dest === void 0) { dest = new TransformationMatrix3D; }
            return dest.set(1, 0, 0, xlt.x, 0, 1, 0, xlt.y, 0, 0, 1, xlt.z);
        };
        ;
        TransformationMatrix3D.multiply = function (m1, m2, dest) {
            if (dest === void 0) { dest = new TransformationMatrix3D; }
            var xx = m1.xx * m2.xx + m1.xy * m2.yx + m1.xz * m2.zx + 0;
            var xy = m1.xx * m2.xy + m1.xy * m2.yy + m1.xz * m2.zy + 0;
            var xz = m1.xx * m2.xz + m1.xy * m2.yz + m1.xz * m2.zz + 0;
            var x1 = m1.xx * m2.x1 + m1.xy * m2.y1 + m1.xz * m2.z1 + m1.x1;
            var yx = m1.yx * m2.xx + m1.yy * m2.yx + m1.yz * m2.zx + 0;
            var yy = m1.yx * m2.xy + m1.yy * m2.yy + m1.yz * m2.zy + 0;
            var yz = m1.yx * m2.xz + m1.yy * m2.yz + m1.yz * m2.zz + 0;
            var y1 = m1.yx * m2.x1 + m1.yy * m2.y1 + m1.yz * m2.z1 + m1.y1;
            var zx = m1.zx * m2.xx + m1.zy * m2.yx + m1.zz * m2.zx + 0;
            var zy = m1.zx * m2.xy + m1.zy * m2.yy + m1.zz * m2.zy + 0;
            var zz = m1.zx * m2.xz + m1.zy * m2.yz + m1.zz * m2.zz + 0;
            var z1 = m1.zx * m2.x1 + m1.zy * m2.y1 + m1.zz * m2.z1 + m1.z1;
            return dest.set(xx, xy, xz, x1, yx, yy, yz, y1, zx, zy, zz, z1);
        };
        TransformationMatrix3D.prototype.multiply = function (r, dest) {
            if (dest === void 0) { dest = new TransformationMatrix3D; }
            return TransformationMatrix3D.multiply(this, r, dest);
        };
        /**
         * Assumes axis vector (x,y,z) is already normalized
         */
        TransformationMatrix3D.fromXYZAxisAngle = function (x, y, z, angle, dest) {
            if (dest === void 0) { dest = new TransformationMatrix3D(); }
            var c = Math.cos(angle);
            var s = Math.sin(angle);
            var t = 1 - c;
            // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToMatrix/
            return dest.set(t * x * x + c, t * x * y - z * s, t * x * z + y * s, 0, t * x * y + z * s, t * y * y + c, t * y * z - x * s, 0, t * x * z - y * s, t * y * z + x * s, t * z * z + c, 0);
        };
        TransformationMatrix3D.fromAxisAngle = function (axis, angle, dest) {
            if (dest === void 0) { dest = new TransformationMatrix3D(); }
            return this.fromXYZAxisAngle(axis.x, axis.y, axis.z, angle, dest);
        };
        TransformationMatrix3D.fromQuaternion = function (q, dest) {
            if (dest === void 0) { dest = new TransformationMatrix3D(); }
            // Symbols defined to match those used on
            // https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Quaternion-derived_rotation_matrix
            var r = q.a, i = q.b, j = q.c, k = q.d;
            var rr = r * r, ii = i * i, jj = j * j, kk = k * k;
            var ij = i * j, ik = i * k, ir = i * r, kr = k * r, jk = j * k, jr = j * r;
            return dest.set(1 - 2 * (jj + kk), 2 * (ij - kr), 2 * (ik + jr), 0, 2 * (ij + kr), 1 - 2 * (ii + kk), 2 * (jk - ir), 0, 2 * (ik - jr), 2 * (jk + ir), 1 - 2 * (ii + jj), 0);
        };
        Object.defineProperty(TransformationMatrix3D.prototype, "rows", {
            get: function () {
                return [[this.xx, this.xy, this.xz, this.x1], [this.yx, this.yy, this.yz, this.y1], [this.zx, this.zy, this.zz, this.z1], [this["1x"], this["1y"], this["1z"], this["11"]]];
            },
            enumerable: true,
            configurable: true
        });
        TransformationMatrix3D.prototype.toString = function () {
            return this.rows.map(function (r) { return r.map(function (n) { return fmtNum(n, 7, 2); }).join(" "); }).join("\n");
        };
        TransformationMatrix3D.prototype.clone = function (into) {
            if (into === void 0) { into = new TransformationMatrix3D; }
            return into.set(this.xx, this.xy, this.xz, this.x1, this.yx, this.yy, this.yz, this.y1, this.zx, this.zy, this.zz, this.z1);
        };
        TransformationMatrix3D.IDENTITY = DeepFreezer_9.deepFreeze(new TransformationMatrix3D(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0));
        return TransformationMatrix3D;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = TransformationMatrix3D;
    var _a;
});
define("togos-game21/world", ["require", "exports", "togos-game21/DeepFreezer"], function (require, exports, DeepFreezer_10) {
    "use strict";
    exports.EMPTY_STATE = DeepFreezer_10.deepFreeze({});
    (function (StructureType) {
        StructureType[StructureType["NONE"] = 0] = "NONE";
        StructureType[StructureType["INDIVIDUAL"] = 1] = "INDIVIDUAL";
        StructureType[StructureType["TILE_TREE"] = 2] = "TILE_TREE";
        StructureType[StructureType["STACK"] = 3] = "STACK";
        StructureType[StructureType["LIST"] = 4] = "LIST";
    })(exports.StructureType || (exports.StructureType = {}));
    var StructureType = exports.StructureType;
    exports.AZTYPE_BAG = "http://ns.nuke24.net/Game21/AttachmentZoneTypes/Bag"; // Can hold a (conceptually) unordered set of items
    exports.AZTYPE_PANEL = "http://ns.nuke24.net/Game21/AttachmentZoneTypes/Panel"; // A 2D grid of connectors
    exports.AZTYPE_BOX = "http://ns.nuke24.net/Game21/AttachmentZoneTypes/Box"; // A 3D volume with explicitly-placed contents
    exports.AZTYPE_HAND = "http://ns.nuke24.net/Game21/AttachmentZoneTypes/Hand"; // Can hold a single item of arbitrary size
    var _a;
});
define("tshash/uuids", ["require", "exports", "tshash/utils"], function (require, exports, utils_5) {
    "use strict";
    function newType4Uuid() {
        var uuid = new Uint8Array(16);
        for (var i = 0; i < 16; ++i)
            uuid[i] = Math.floor(Math.random() * 256);
        uuid[6] |= 0x40;
        uuid[6] &= 0x4F;
        uuid[8] |= 0x80;
        uuid[8] &= 0xBF;
        return uuid;
    }
    exports.newType4Uuid = newType4Uuid;
    function uuidString(uuid) {
        return (utils_5.hexEncode(uuid, 0, 4) + '-' +
            utils_5.hexEncode(uuid, 4, 6) + '-' + utils_5.hexEncode(uuid, 6, 8) + '-' + utils_5.hexEncode(uuid, 8, 10) + '-' +
            utils_5.hexEncode(uuid, 10, 16));
    }
    exports.uuidString = uuidString;
    function uuidUrn(uuid) {
        return "urn:uuid:" + uuidString(uuid);
    }
    exports.uuidUrn = uuidUrn;
    var _a;
});
/// <reference path="../Promise.d.ts" />
define("togos-game21/MemoryDatastore", ["require", "exports", "tshash/index"], function (require, exports, index_3) {
    "use strict";
    var MemoryDatastore = (function () {
        function MemoryDatastore(_identify, delay) {
            if (delay === void 0) { delay = 0; }
            this._identify = _identify;
            this.delay = delay;
            this._values = {};
        }
        Object.defineProperty(MemoryDatastore.prototype, "identify", {
            get: function () { return this._identify; },
            enumerable: true,
            configurable: true
        });
        MemoryDatastore.prototype.get = function (uri) {
            return this._values[uri];
        };
        MemoryDatastore.prototype.fetch = function (uri) {
            var _this = this;
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    var val = _this._values[uri];
                    if (val)
                        resolve(val);
                    else
                        reject(new Error("Resource " + uri + " not found"));
                }, +_this.delay);
            });
        };
        MemoryDatastore.prototype.store = function (data) {
            var _this = this;
            return new Promise(function (resolve, reject) {
                var ident = _this._identify(data);
                setTimeout(function () {
                    _this._values[ident] = data;
                    setTimeout(function () { return resolve(ident); }, _this.delay);
                }, _this.delay);
            });
        };
        MemoryDatastore.prototype.fastStore = function (data, onComplete) {
            var _this = this;
            var ident = this._identify(data);
            var onCompleat = onComplete;
            setTimeout(function () {
                _this._values[ident] = data;
                if (onCompleat)
                    setTimeout(function () { return onCompleat(true); }, _this.delay);
            }, this.delay);
            return ident;
        };
        MemoryDatastore.prototype.put = function (id, data) {
            this._values[id] = data;
            return Promise.resolve(id);
        };
        MemoryDatastore.prototype.multiPut = function (vals) {
            for (var v in vals) {
                this.values[v] = vals[v];
            }
        };
        Object.defineProperty(MemoryDatastore.prototype, "values", {
            get: function () {
                return this._values;
            },
            enumerable: true,
            configurable: true
        });
        MemoryDatastore.createSha1Based = function (delay) {
            return new MemoryDatastore(index_3.sha1Urn, delay);
        };
        return MemoryDatastore;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = MemoryDatastore;
    var _a;
});
define("togos-game21/PrettierJSONEncoder", ["require", "exports"], function (require, exports) {
    "use strict";
    function isComplex(a) {
        for (var k in a) {
            if (!a.hasOwnProperty(k))
                continue;
            if (typeof a[k] !== 'number' && a[k] != null)
                return true;
        }
        return false;
    }
    /**
     * Encode arrays of numbers and simple objects on one line,
     * but everything else spaced out and indented.
     */
    var PrettierJSONEncoder = (function () {
        function PrettierJSONEncoder(output) {
            this.output = output;
            this.indentLevel = 0;
            this.indentString = "\t";
        }
        PrettierJSONEncoder.prototype.emit = function (t) {
            this.output(t);
        };
        PrettierJSONEncoder.prototype.emitIndent = function () {
            for (var i = 0; i < this.indentLevel; ++i)
                this.emit(this.indentString);
        };
        PrettierJSONEncoder.prototype.writeSimple = function (t) {
            this.emit(JSON.stringify(t));
        };
        PrettierJSONEncoder.prototype.writeArray = function (t) {
            if (isComplex(t)) {
                this.emit("[\n");
                ++this.indentLevel;
                for (var i = 0; i < t.length; ++i) {
                    if (i != 0)
                        this.emit(",\n");
                    this.emitIndent();
                    this.write(t[i]);
                }
                this.emit("\n");
                --this.indentLevel;
                this.emitIndent();
                this.emit("]");
            }
            else {
                this.emit(JSON.stringify(t));
            }
        };
        PrettierJSONEncoder.prototype.writeObject = function (t) {
            if (!isComplex(t)) {
                var simple = JSON.stringify(t);
                if (simple == null)
                    throw new Error(typeof t + " stringified to null!");
                if (simple.length <= 60) {
                    this.emit(simple);
                    return;
                }
            }
            this.emit("{\n");
            ++this.indentLevel;
            var first = true;
            for (var i in t) {
                if (!t.hasOwnProperty(i) || typeof t[i] == 'function')
                    continue;
                if (!first)
                    this.emit(",\n");
                this.emitIndent();
                this.writeSimple(i);
                this.emit(": ");
                this.write(t[i]);
                first = false;
            }
            this.emit("\n");
            --this.indentLevel;
            this.emitIndent();
            this.emit("}");
        };
        PrettierJSONEncoder.prototype.write = function (t) {
            if (t == null || typeof t == 'function') {
                this.emit("null");
            }
            else if (typeof t === 'string' || typeof t === 'number' || typeof t === 'boolean') {
                this.emit(JSON.stringify(t));
            }
            else if (typeof t === 'object') {
                if (Array.isArray(t)) {
                    this.writeArray(t);
                }
                else {
                    this.writeObject(t);
                }
            }
            else {
                throw new Error("Don't know how to stringify " + typeof t);
            }
        };
        PrettierJSONEncoder.stringify = function (thing) {
            var parts = [];
            var encoder = new PrettierJSONEncoder(function (s) { return parts.push(s); });
            encoder.write(thing);
            parts.push("\n");
            return parts.join("");
        };
        return PrettierJSONEncoder;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = PrettierJSONEncoder;
    var _a;
});
define("togos-game21/JSONObjectDatastore", ["require", "exports", "togos-game21/DeepFreezer", "tshash/utils", "togos-game21/PrettierJSONEncoder"], function (require, exports, DeepFreezer_11, utils_6, PrettierJSONEncoder_1) {
    "use strict";
    function stringify(v) {
        //return JSON.stringify(v);
        return PrettierJSONEncoder_1.default.stringify(v);
    }
    function encodeObject(obj) {
        return utils_6.utf8Encode(stringify(obj));
    }
    exports.encodeObject = encodeObject;
    function dataUrnToSubjectUrn(urn) {
        return urn + "#";
    }
    function identifyObject(v, identifyData) {
        return dataUrnToSubjectUrn(identifyData(encodeObject(v)));
    }
    exports.identifyObject = identifyObject;
    function storeObject(v, datastore) {
        if (v instanceof Uint8Array) {
            return datastore.store(v);
        }
        return datastore.store(encodeObject(v)).then(function (dataUrn) { return dataUrnToSubjectUrn(dataUrn); });
    }
    exports.storeObject = storeObject;
    function fastStoreObject(v, datastore) {
        if (v instanceof Uint8Array) {
            return datastore.fastStore(v);
        }
        return dataUrnToSubjectUrn(datastore.fastStore(encodeObject(v)));
    }
    exports.fastStoreObject = fastStoreObject;
    function fetchObject(uri, datastore, freeze) {
        if (freeze === void 0) { freeze = false; }
        if (uri[uri.length - 1] == '#') {
            return datastore.fetch(uri.substr(0, uri.length - 1)).then(function (data) {
                var json = utils_6.utf8Decode(data);
                var obj = JSON.parse(json);
                return freeze ? DeepFreezer_11.deepFreeze(obj, true) : obj;
            });
        }
        else {
            // Can't deepfreeze Uint8Arrays or I would.  ;(
            // But they're less likely to get munged anyway.
            return datastore.fetch(uri);
        }
    }
    exports.fetchObject = fetchObject;
    var _a;
});
define("togos-game21/DistributedBucketMap", ["require", "exports", "togos-game21/JSONObjectDatastore", "togos-game21/DeepFreezer"], function (require, exports, JSONObjectDatastore_1, DeepFreezer_12) {
    "use strict";
    exports.EMPTY_NODE = DeepFreezer_12.deepFreeze(leafNode({}));
    exports.EMPTY_NODE_URI = "urn:sha1:GVEKPNGUKNG4NEVXMJBIPURTQHDBZ3ST";
    function invalidNodeError(node, msg) {
        return new Error(msg + ": " + JSON.stringify(node, null, "\t"));
    }
    function missingValuesError(node) {
        return invalidNodeError(node, "Node without prefix length should have values but does not");
    }
    function missingSubBucketUrisError(node) {
        return invalidNodeError(node, "Node with prefix length should have sub-bucket URIs but does not");
    }
    function fetchNode(uri, ds) {
        if (uri == exports.EMPTY_NODE_URI)
            return Promise.resolve(exports.EMPTY_NODE);
        return JSONObjectDatastore_1.fetchObject(uri, ds);
    }
    function _fetchValue(valueName, node, datastore) {
        if (node.prefixLength == null) {
            if (!node.values)
                throw missingValuesError(node);
            return Promise.resolve(node.values[valueName]);
        }
        else {
            var prefix = valueName.substr(0, node.prefixLength);
            if (!node.subBucketUris)
                throw missingSubBucketUrisError(node);
            var subBucketUri = node.subBucketUris[prefix];
            if (subBucketUri == undefined)
                return Promise.resolve(undefined);
            return fetchValue(valueName, subBucketUri, datastore);
        }
    }
    function fetchValue(valueName, nodeUri, datastore) {
        if (typeof (nodeUri) === 'string') {
            return fetchNode(nodeUri, datastore).then(function (obj) {
                return _fetchValue(valueName, obj, datastore);
            });
        }
        else {
            return _fetchValue(valueName, nodeUri, datastore);
        }
    }
    exports.fetchValue = fetchValue;
    //// Updating's a bit more complex
    function updateValues(original, updates) {
        var clone = {};
        for (var k in original)
            clone[k] = original[k];
        for (var k in updates) {
            var v = updates[k];
            if (v != undefined)
                clone[k] = v;
            else
                delete clone[k];
        }
        return clone;
    }
    ;
    function kCount(l) {
        var count = 0;
        for (var k in l)
            ++count;
        return count;
    }
    function leafNode(values) {
        return {
            values: values,
            entryCount: kCount(values),
        };
    }
    // TODO: Will probably need to return some structure including
    // metadata about the new node so we don't have to re-request it
    // and count its entries or whatever
    function _storeValues(updates, node, nodeUri, datastore, settings) {
        var newValues;
        if (node.prefixLength == null) {
            if (!node.values)
                throw missingValuesError(node);
            var anythingChanged = false;
            for (var k in updates) {
                var newVal = updates[k];
                if (node.values[k] != newVal)
                    anythingChanged = true;
            }
            if (!anythingChanged)
                return Promise.resolve(nodeUri);
            node = leafNode(updateValues(node.values, updates));
        }
        else {
            throw new Error("Updating non-leaf node not implemented");
        }
        // TODO: split up if violating size constraints
        // At this point, node is some mutable DistributedBucketMap
        // that we're going to mess with.
        return JSONObjectDatastore_1.storeObject(node, datastore);
    }
    exports._storeValues = _storeValues;
    function storeValues(updates, nodeUri, datastore, settings) {
        return fetchNode(nodeUri, datastore).then(function (obj) {
            return _storeValues(updates, obj, nodeUri, datastore, settings);
        });
    }
    exports.storeValues = storeValues;
    function emptyNodeUri(datastore) {
        return JSONObjectDatastore_1.fastStoreObject(exports.EMPTY_NODE, datastore);
    }
    exports.emptyNodeUri = emptyNodeUri;
    var DistributedBucketMapManager = (function () {
        function DistributedBucketMapManager(_datastore, _rootNodeUri) {
            if (_rootNodeUri === void 0) { _rootNodeUri = exports.EMPTY_NODE_URI; }
            this._datastore = _datastore;
            this._rootNodeUri = _rootNodeUri;
            this.pendingUpdates = {};
            this.currentUpdates = {};
            this.allUpdatesPromise = Promise.resolve(_rootNodeUri);
        }
        DistributedBucketMapManager.prototype.flushUpdates = function () {
            if (this.allUpdatesPromise)
                return this.allUpdatesPromise;
            return Promise.resolve(this._rootNodeUri);
        };
        Object.defineProperty(DistributedBucketMapManager.prototype, "rootNodeUri", {
            get: function () { return this._rootNodeUri; },
            enumerable: true,
            configurable: true
        });
        DistributedBucketMapManager.prototype.fetchValue = function (k) {
            if (this.pendingUpdates.hasOwnProperty(k)) {
                return Promise.resolve(this.pendingUpdates[k]);
            }
            if (this.currentUpdates.hasOwnProperty(k)) {
                return Promise.resolve(this.currentUpdates[k]);
            }
            return fetchValue(k, this._rootNodeUri, this._datastore);
        };
        DistributedBucketMapManager.prototype.storeValues = function (updates) {
            var _this = this;
            for (var u in updates) {
                this.pendingUpdates[u] = updates[u];
            }
            // If there's already a currentUpdatePromise, it's already set to call storeUpdates
            // when it's done, so we don't need to do anything!
            if (this.currentUpdatePromise != null)
                return this.currentUpdatePromise;
            // Otherwise we have to make currentUpdatePromise
            var storeUpdates;
            storeUpdates = function () { return Promise.reject("xxx oh no"); }; // To trick compiler into letting me use it down below 
            storeUpdates = function () {
                var anyUpdates = false;
                for (var u in _this.pendingUpdates) {
                    anyUpdates = true;
                    break;
                }
                if (anyUpdates) {
                    _this.currentUpdates = _this.pendingUpdates;
                    _this.pendingUpdates = {};
                    _this.currentUpdatePromise = storeValues(_this.currentUpdates, _this._rootNodeUri, _this._datastore, _this.storeSettings).then(function (newRootNodeUri) {
                        _this._rootNodeUri = newRootNodeUri;
                        _this.currentUpdates = {};
                        return newRootNodeUri;
                    });
                    _this.allUpdatesPromise = _this.currentUpdatePromise.then(storeUpdates);
                    return _this.currentUpdatePromise;
                }
                else {
                    _this.currentUpdatePromise = null;
                    return _this.allUpdatesPromise = Promise.resolve(_this._rootNodeUri);
                }
            };
            return storeUpdates();
        };
        return DistributedBucketMapManager;
    }());
    exports.DistributedBucketMapManager = DistributedBucketMapManager;
    var _a;
});
/// <reference path="../Promise.d.ts"/>
define("togos-game21/promises", ["require", "exports"], function (require, exports) {
    "use strict";
    var State;
    (function (State) {
        State[State["NORMAL"] = 0] = "NORMAL";
        State[State["RESOLVED"] = 1] = "RESOLVED";
        State[State["REJECTED"] = 2] = "REJECTED";
    })(State || (State = {}));
    var STATESYM = Symbol("resolved");
    var VALUESYM = Symbol("value");
    var ERRORSYM = Symbol("value");
    exports.RESOLVED_VOID_PROMISE = resolvedPromise(undefined);
    function resolvedPromise(value) {
        var p = Promise.resolve(value);
        p[VALUESYM] = value;
        p[STATESYM] = State.RESOLVED;
        return p;
    }
    exports.resolvedPromise = resolvedPromise;
    function rejectedPromise(error) {
        var p = Promise.reject(value);
        p[ERRORSYM] = error;
        p[STATESYM] = State.REJECTED;
        return p;
    }
    exports.rejectedPromise = rejectedPromise;
    function isResolved(p) {
        return p[STATESYM] === State.RESOLVED;
    }
    exports.isResolved = isResolved;
    function isRejected(p) {
        return p[STATESYM] === State.REJECTED;
    }
    exports.isRejected = isRejected;
    function value(p) {
        return (p[VALUESYM]);
    }
    exports.value = value;
    function isThenable(v) {
        return v != null && v.then;
    }
    function thenable(v) {
        return isThenable(v) ? v : resolvedPromise(v);
    }
    function shortcutThen(p, onResolve) {
        if (isResolved(p)) {
            var u = onResolve(value(p));
            return isThenable(u) ? u : resolvedPromise(u);
        }
        return p.then(onResolve);
    }
    exports.shortcutThen = shortcutThen;
    /**
     * If p is null, return an immediately resolved promise.
     * Otherwise return p.
     */
    function vopToPromise(p, v) {
        return p != null ? p : resolvedPromise(v);
    }
    exports.vopToPromise = vopToPromise;
    function finalmente(p, finalStuff) {
        return p.then(function (v) { finalStuff(); return v; }, function (err) { finalStuff(); return Promise.reject(err); });
    }
    exports.finalmente = finalmente;
    var _a;
});
///<reference path="../Promise.d.ts"/>
define("togos-game21/GameDataManager", ["require", "exports", "togos-game21/DeepFreezer", "togos-game21/DistributedBucketMap", "togos-game21/JSONObjectDatastore", "togos-game21/world"], function (require, exports, DeepFreezer_13, DistributedBucketMap_1, JSONObjectDatastore_2, world_1) {
    "use strict";
    var refKeyRegex = /.*Ref$/;
    var hashUrnRegex = /^urn:(sha1|bitprint):.*/;
    function isHashUrn(urn) {
        return hashUrnRegex.exec(urn) != null;
    }
    function assertNameNotHashUrn(name) {
        if (isHashUrn(name)) {
            throw new Error("Name for object is a hash URN, which is probably a bad idea! " + name);
        }
    }
    function thawEntity(entity) {
        entity = DeepFreezer_13.thaw(entity);
        if (entity.internalSystems) {
            entity.internalSystems = DeepFreezer_13.thaw(entity.internalSystems);
            for (var isk in entity.internalSystems) {
                entity.internalSystems[isk] = DeepFreezer_13.thaw(entity.internalSystems[isk]);
            }
        }
        if (entity.maze1Inventory) {
            entity.maze1Inventory = DeepFreezer_13.thaw(entity.maze1Inventory);
            for (var ik in entity.maze1Inventory) {
                entity.maze1Inventory[ik] = thawEntity(entity.maze1Inventory[ik]);
            }
        }
        return entity;
    }
    var GameDataManager = (function () {
        function GameDataManager(datastore, rootNodeUri) {
            this.datastore = datastore;
            this.objectCache = {};
            this.knownStored = {};
            /**
             * Stuff we're currently storing.
             * Generally we don't want to let stuff fall out of the cache
             * if we're still storing it, since that could result in fetch
             * returning an outdated value!
             */
            this.storing = {};
            this.fetching = {};
            this.mutableObjects = {};
            /**
             * Immutable URNs of objects that have been 'temp stored'
             * and should be saved to the backing datastore on flushUpdates
             * if they are still referenced from the root nodes.
             */
            this.tempObjectUrns = {};
            /** Name => data name mappings that haven't yet been saved */
            this.tempNameMap = {};
            this.objectsToSave = {};
            this.collected = {};
            this.objectMapManager = new DistributedBucketMap_1.DistributedBucketMapManager(this.datastore, rootNodeUri);
        }
        Object.defineProperty(GameDataManager.prototype, "rootMapNodeUri", {
            get: function () { return this.objectMapManager.rootNodeUri; },
            enumerable: true,
            configurable: true
        });
        GameDataManager.prototype.fetchHardRef = function (name) {
            if (this.tempNameMap[name])
                return Promise.resolve(this.tempNameMap[name]);
            if (this.mutableObjects[name])
                return Promise.reject(new Error("No hard ref for " + name + " because it is currently loaded as mutable"));
            return this.objectMapManager.fetchValue(name).then(function (hardRef) {
                if (hardRef == undefined) {
                    return Promise.reject("No mapping found for " + name);
                }
                return hardRef;
            });
        };
        GameDataManager.prototype.getObjectIfLoaded = function (ref, initiateFetch) {
            if (initiateFetch === void 0) { initiateFetch = false; }
            var v = this.mutableObjects[ref];
            if (v == null)
                v = this.objectCache[ref];
            if (v == null && initiateFetch && !this.fetching[ref])
                this.fetchObject(ref);
            return v;
        };
        GameDataManager.prototype.getMutableObject = function (ref) {
            if (this.mutableObjects[ref])
                return this.mutableObjects[ref];
            throw new Error(ref + " not in mutable object store");
        };
        GameDataManager.prototype.getObject = function (ref, initiateFetch) {
            if (initiateFetch === void 0) { initiateFetch = false; }
            var v = this.getObjectIfLoaded(ref, initiateFetch);
            if (v == null)
                throw new Error(ref + " not loaded");
            return v;
        };
        GameDataManager.prototype.putMutableObject = function (ref, obj) {
            // Make sure it's not also in the regular cache!
            delete this.objectCache[ref];
            this.mutableObjects[ref] = obj;
        };
        GameDataManager.prototype.getMutableRoom = function (roomId) {
            if (this.mutableObjects[roomId])
                return this.mutableObjects[roomId];
            var room = this.getRoom(roomId);
            // Apparently deepThaw doesn't quite work, yet
            room = DeepFreezer_13.thaw(room);
            room.roomEntities = DeepFreezer_13.thaw(room.roomEntities);
            for (var re in room.roomEntities) {
                room.roomEntities[re] = DeepFreezer_13.thaw(room.roomEntities[re]);
                room.roomEntities[re].entity = thawEntity(room.roomEntities[re].entity);
            }
            room.neighbors = DeepFreezer_13.thaw(room.neighbors);
            for (var n in room.neighbors) {
                room.neighbors[n] = DeepFreezer_13.thaw(room.neighbors[n]);
            }
            this.putMutableObject(roomId, room);
            return room;
        };
        GameDataManager.prototype.getRoom = function (ref) { return this.getObject(ref); };
        GameDataManager.prototype.getEntityClass = function (ref, initiateFetch) {
            if (initiateFetch === void 0) { initiateFetch = false; }
            return this.getObject(ref, initiateFetch);
        };
        GameDataManager.prototype.cache = function (k, v) {
            this.objectCache[k] = v;
        };
        GameDataManager.prototype.fetchObject = function (ref) {
            var _this = this;
            if (ref == null)
                throw new Error("Null ref passed to fetchObject");
            if (this.objectCache[ref])
                return Promise.resolve(this.objectCache[ref]);
            if (this.fetching[ref])
                return this.fetching[ref];
            if (isHashUrn(ref)) {
                return this.fetching[ref] = JSONObjectDatastore_2.fetchObject(ref, this.datastore, true).then(function (v) {
                    _this.cache(ref, v);
                    _this.knownStored[ref] = true;
                    delete _this.fetching[ref];
                    return v;
                });
            }
            else {
                return this.fetching[ref] = this.fetchHardRef(ref).then(function (realRef) {
                    return _this.fetchObject(realRef).then(function (v) {
                        _this.cache(ref, v);
                        delete _this.fetching[ref];
                        return v;
                    });
                });
            }
        };
        // Since this is cache 'objects', I think it should by default be recursive
        // for subject URNs (i.e. 'urn:sha1:BLAH#' should be recursive, 'urn:sha1:BLAH' should not be)
        GameDataManager.prototype.cacheObjects = function (refs) {
            var leRefs = refs; // Placate the TypeScript compiler.
            var fetchPromises = [];
            for (var r in leRefs) {
                fetchPromises.push(this.fetchObject(leRefs[r]));
            }
            return Promise.all(fetchPromises);
        };
        GameDataManager.prototype._collectLiveObjectsForSaving = function (obj) {
            for (var k in obj) {
                var v = obj[k];
                if (v == null) {
                }
                if (typeof v == 'string') {
                    if (refKeyRegex.exec(k)) {
                        this.collectLiveObjectsForSaving(v);
                    }
                }
                else if (typeof v == 'object') {
                    this._collectLiveObjectsForSaving(v);
                }
            }
        };
        GameDataManager.prototype.collectLiveObjectsForSaving = function (ref) {
            if (this.collected[ref])
                return; // Already visited!
            this.collected[ref] = ref;
            if (isHashUrn(ref) && !this.tempObjectUrns[ref]) {
                // Probably safe to assume that everything it references has also been saved,
                // so we don't need to recurse any further.
                return;
            }
            var obj = this.getObjectIfLoaded(ref);
            if (this.tempObjectUrns[ref]) {
                if (obj == null) {
                    console.warn("Tried to walk temp object " + ref + " but it's not in the cache!");
                    return;
                }
                this.objectsToSave[ref] = obj;
            }
            if (obj == null)
                return;
            if (typeof obj == 'object') {
                this._collectLiveObjectsForSaving(obj);
            }
        };
        /**
         * Returns a promise of the root data map URN
         */
        GameDataManager.prototype.flushUpdates = function () {
            var _this = this;
            for (var k in this.mutableObjects) {
                var obj = this.mutableObjects[k];
                this.tempStoreObject(obj, k);
            }
            for (var r in this.mutableObjects) {
                this.collectLiveObjectsForSaving(r);
            }
            for (var name_1 in this.tempNameMap) {
                var urn = this.tempNameMap[name_1];
                if (urn)
                    this.collectLiveObjectsForSaving(urn);
            }
            // Any that should be saved have been collected
            this.tempObjectUrns = {};
            this.collected = {};
            var storePromises = [];
            var _loop_1 = function(_k) {
                var v = this_1.objectsToSave[_k];
                if (this_1.knownStored[_k])
                    return "continue";
                var k = _k;
                storePromises.push(this_1.storeObject(v).then(function (savedAs) {
                    if (savedAs !== k) {
                        // This would be a major problem!
                        return Promise.reject(new Error("Temp-saved object " + k + " finally saved with different URN: " + savedAs));
                    }
                    _this.knownStored[savedAs] = true;
                    return savedAs;
                }));
            };
            var this_1 = this;
            for (var _k in this.objectsToSave) {
                _loop_1(_k);
            }
            this.objectsToSave = {};
            this.objectMapManager.storeValues(this.tempNameMap);
            this.tempNameMap = {};
            var rootUrnPromise = this.objectMapManager.flushUpdates();
            storePromises.push(rootUrnPromise);
            return Promise.all(storePromises).then(function () { return rootUrnPromise; });
        };
        /**
         * Clears the cache.
         * No data should ever be lost due to a cache clear (unless something has happened to the backing store).
         */
        GameDataManager.prototype.clearCache = function () {
            var oldCache = this.objectCache;
            var newCache = {};
            for (var urn in this.tempObjectUrns) {
                var tempObj = oldCache[urn];
                if (!tempObj) {
                    console.warn("Temp object " + urn + " isn't in the cache!");
                }
                newCache[urn] = tempObj;
            }
            this.objectCache = newCache;
            this.knownStored = {};
        };
        GameDataManager.prototype.updateMap = function (updates) {
            for (var k in updates) {
                // Any overrides are no longer valid!
                delete this.tempNameMap[k];
                delete this.objectCache[k];
                if (this.objectCache[updates[k]]) {
                    // If everything's already in memory, make sure immediate gets will still work.
                    this.objectCache[k] = this.objectCache[updates[k]];
                }
            }
            return this.objectMapManager.storeValues(updates);
        };
        GameDataManager.prototype.storeObject = function (obj, _name) {
            var _this = this;
            obj = DeepFreezer_13.deepFreeze(obj);
            var urnProm = JSONObjectDatastore_2.storeObject(obj, this.datastore).then(function (storedAs) {
                _this.knownStored[storedAs] = true;
                return storedAs;
            });
            var name = _name; // Make it const so later references check out
            if (name) {
                assertNameNotHashUrn(name);
                this.objectCache[name] = obj;
                this.storing[name] = true;
                return urnProm.then(function (urn) {
                    return _this.updateMap((_a = {}, _a[name] = urn, _a)).then(function (newMapUrn) {
                        delete _this.storing[name];
                        return urn;
                    });
                    var _a;
                });
            }
            else
                return urnProm;
        };
        GameDataManager.prototype.fastStoreObject = function (obj, _name) {
            var _this = this;
            obj = DeepFreezer_13.deepFreeze(obj);
            var urn = JSONObjectDatastore_2.fastStoreObject(obj, this.datastore);
            this.objectCache[urn] = obj;
            // Uhm, how can we set this.storing[urn] and then have it get cleared, uhm
            var name = _name;
            if (name) {
                assertNameNotHashUrn(name);
                this.objectCache[name] = obj;
                this.storing[name] = true;
                this.updateMap((_a = {}, _a[name] = urn, _a)).then(function (newMapUrn) {
                    delete _this.storing[name];
                });
            }
            return urn;
            var _a;
        };
        /**
         * Store the given object (and optionally a name mapping)
         * in a local memory datastore without committing the data
         * to the backing datastore.
         *
         * Only data that is referenced by a name and
         */
        GameDataManager.prototype.tempStoreObject = function (obj, _name) {
            obj = DeepFreezer_13.deepFreeze(obj);
            var urn = JSONObjectDatastore_2.identifyObject(obj, this.datastore.identify);
            this.objectCache[urn] = obj;
            this.tempObjectUrns[urn] = true;
            if (_name) {
                assertNameNotHashUrn(_name);
                this.objectCache[_name] = obj;
                this.tempNameMap[_name] = urn;
            }
            return urn;
        };
        GameDataManager.prototype.fullyCacheTileEntityPalette = function (paletteRef) {
            var _this = this;
            return this.fetchObject(paletteRef).then(function (tep) {
                var itemPromises = [];
                for (var te in tep) {
                    var tileEntity = tep[te];
                    if (!tileEntity)
                        continue;
                    if (!tileEntity.entity.classRef)
                        return Promise.reject("Tile entity palette " + paletteRef + " entry " + te + " has no classRef: " + JSON.stringify(tileEntity, null, "\t"));
                    itemPromises.push(_this.fullyCacheEntityClass(tileEntity.entity.classRef));
                }
                return Promise.all(itemPromises).then(function () { return tep; });
            });
        };
        GameDataManager.prototype.fullyCacheEntityClass = function (classRef) {
            var _this = this;
            return this.fetchObject(classRef).then(function (ec) {
                var itemPromises = [];
                switch (ec.structureType) {
                    case world_1.StructureType.INDIVIDUAL:
                    case world_1.StructureType.NONE:
                        break;
                    case world_1.StructureType.TILE_TREE:
                        var tt = ec;
                        if (!tt.childEntityPaletteRef)
                            return Promise.reject("TileTree has no childEntityPaletteRef: " + JSON.stringify(ec, null, "\t"));
                        itemPromises.push(_this.fullyCacheTileEntityPalette(tt.childEntityPaletteRef));
                        break;
                    default:
                        console.warn("Unrecognized entity structure type: " + ec.structureType);
                }
                return Promise.all(itemPromises).then(function () { return ec; });
            });
        };
        GameDataManager.prototype._fullyCacheEntity = function (entity, itemPromises) {
            itemPromises.push(this.fullyCacheEntityClass(entity.classRef));
            if (entity.maze1Inventory)
                for (var ii in entity.maze1Inventory) {
                    this._fullyCacheEntity(entity.maze1Inventory[ii], itemPromises);
                }
        };
        GameDataManager.prototype.fullyCacheRoom = function (roomId) {
            var _this = this;
            return this.fetchObject(roomId).then(function (room) {
                var itemPromises = [];
                for (var re in room.roomEntities) {
                    var roomEntity = room.roomEntities[re];
                    _this._fullyCacheEntity(roomEntity.entity, itemPromises);
                }
                return Promise.all(itemPromises).then(function () { return room; });
            });
        };
        return GameDataManager;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = GameDataManager;
    var _a;
});
define("togos-game21/util", ["require", "exports"], function (require, exports) {
    "use strict";
    function coalesce2(v, v1) {
        if (v != null)
            return v;
        return v1;
    }
    exports.coalesce2 = coalesce2;
    function compareByteArrays(a, b) {
        var minLen = Math.min(a.length, b.length);
        for (var i = 0; i < minLen; ++i) {
            var av = a[i];
            var bv = b[i];
            if (av < bv)
                return -1;
            if (av > bv)
                return +1;
        }
        if (a.length < b.length)
            return -1;
        if (a.length > b.length)
            return +1;
        return 0;
    }
    exports.compareByteArrays = compareByteArrays;
    var _a;
});
define("togos-game21/worldutil", ["require", "exports", "togos-game21/vector3ds", "togos-game21/vector3dmath", "togos-game21/Quaternion", "togos-game21/aabbs", "togos-game21/world", "togos-game21/DeepFreezer", "tshash/index", "tshash/SHA1", "togos-game21/util"], function (require, exports, vector3ds_9, vector3dmath_7, Quaternion_2, aabbs_3, world_2, DeepFreezer_14, index_4, SHA1_2, util_1) {
    "use strict";
    var posBuffer0 = vector3ds_9.makeVector();
    function toArray(src, dest) {
        for (var i = 0; i < src.length; ++i)
            dest[i] = src[i];
        return dest;
    }
    function toUint8Array(src) {
        return toArray(src, new Uint8Array(src.length));
    }
    function entityClassRef(op, gdm) {
        if (typeof op == 'string')
            return op;
        if (gdm == null)
            throw new Error("Can't generate object prototype ref without GameDataManager");
        return gdm.tempStoreObject(op);
    }
    /**
     * Palette can either be an ID of a TileEntityPalette,
     * or a list of tile tree entity class refs.
     */
    function makeTileEntityPaletteRef(palette, gdm, alias) {
        if (typeof palette == 'string')
            return palette;
        if (gdm == null)
            throw new Error("Can't generate palette ref without GameDataManager");
        if (!Array.isArray(palette))
            throw new Error("Supposed tile palette is not an array; can't reference it: " + JSON.stringify(palette));
        var tilePalette = palette.map(function (obj) { return obj == null ? null : DeepFreezer_14.deepFreeze({
            orientation: Quaternion_2.default.IDENTITY,
            entity: {
                classRef: entityClassRef(obj, gdm)
            },
        }); });
        return gdm.tempStoreObject(tilePalette, alias);
    }
    exports.makeTileEntityPaletteRef = makeTileEntityPaletteRef;
    /**
     * It is safe to pass posBuffer = pos
     * so long as you don't rely on that buffer
     * calling eachSubEntity.
     */
    function eachSubEntityIntersectingBb(entity, pos, bbPos, bb, gdm, callback, callbackThis, posBuffer) {
        if (callbackThis === void 0) { callbackThis = null; }
        if (posBuffer === void 0) { posBuffer = undefined; }
        var proto = gdm.getObject(entity.classRef);
        if (proto == null)
            throw new Error("Failed to get entity class " + entity.classRef);
        if (proto.structureType == world_2.StructureType.NONE) {
        }
        else if (proto.structureType == world_2.StructureType.INDIVIDUAL) {
        }
        else if (proto.structureType == world_2.StructureType.TILE_TREE) {
            var tt = proto;
            var tilePaletteIndexes = tt.childEntityIndexes;
            var tilePalette = gdm.getObject(tt.childEntityPaletteRef);
            if (tilePalette == null)
                return;
            var ttBb = tt.tilingBoundingBox;
            var zDivs = tt.zDivisions, yDivs = tt.yDivisions, xDivs = tt.xDivisions;
            var ttWidth = ttBb.maxX - ttBb.minX, ttHeight = ttBb.maxY - ttBb.minY, ttDepth = ttBb.maxZ - ttBb.minZ;
            var xd = ttWidth / xDivs, yd = ttHeight / yDivs, zd = ttDepth / zDivs;
            var halfZd = zd / 2, halfXd = xd / 2, halfYd = yd / 2;
            // Tile tree corners, adjusted by pos:
            var x0 = pos.x + ttBb.minX, x1 = pos.x + ttBb.maxX;
            var y0 = pos.y + ttBb.minY, y1 = pos.y + ttBb.maxY;
            var z0 = pos.z + ttBb.minZ, z1 = pos.z + ttBb.maxZ;
            var bbMinX = bbPos.x + bb.minX, bbMaxX = bbPos.x + bb.maxX;
            var bbMinY = bbPos.y + bb.minY, bbMaxY = bbPos.y + bb.maxY;
            var bbMinZ = bbPos.z + bb.minZ, bbMaxZ = bbPos.z + bb.maxZ;
            // Slice/row/cell numbers that intersect the bounding box
            var cx0 = bbMinX <= x0 ? 0 : bbMinX >= x1 ? xDivs : Math.floor((bbMinX - x0) / xd);
            var cx1 = bbMaxX <= x0 ? 0 : bbMaxX >= x1 ? xDivs : Math.ceil((bbMaxX - x0) / xd);
            var cy0 = bbMinY <= y0 ? 0 : bbMinY >= y1 ? yDivs : Math.floor((bbMinY - y0) / yd);
            var cy1 = bbMaxY <= y0 ? 0 : bbMaxY >= y1 ? yDivs : Math.ceil((bbMaxY - y0) / yd);
            var cz0 = bbMinZ <= z0 ? 0 : bbMinZ >= z1 ? zDivs : Math.floor((bbMinZ - z0) / zd);
            var cz1 = bbMaxZ <= z0 ? 0 : bbMaxZ >= z1 ? zDivs : Math.ceil((bbMaxZ - z0) / zd);
            for (var cz = cz0; cz < cz1; ++cz) {
                var subZ = z0 + cz * zd + halfZd;
                for (var cy = cy0; cy < cy1; ++cy) {
                    var subY = y0 + cy * yd + halfYd;
                    for (var cx = cx0, i = cx + (cy * xDivs) + (cz * xDivs * yDivs); cx < cx1; ++cx, ++i) {
                        var subX = x0 + cx * xd + halfXd;
                        var tileEntity = tilePalette[tilePaletteIndexes[i]];
                        if (tileEntity != null) {
                            var v = callback.call(callbackThis, tileEntity.entity, vector3ds_9.setVector(posBuffer, subX, subY, subZ), tileEntity.orientation);
                            if (v != null)
                                return v;
                        }
                    }
                }
            }
        }
        else {
            throw new Error("Unrecognized physical object type: " + proto.structureType);
        }
        return undefined;
    }
    exports.eachSubEntityIntersectingBb = eachSubEntityIntersectingBb;
    /**
     * It is safe to pass posBuffer = pos
     * so long as you don't rely on that buffer
     * calling eachSubEntity.
     */
    function eachSubEntity(entity, pos, gdm, callback, callbackThis, posBuffer) {
        if (callbackThis === void 0) { callbackThis = null; }
        if (posBuffer === void 0) { posBuffer = undefined; }
        return eachSubEntityIntersectingBb(entity, pos, vector3ds_9.ZERO_VECTOR, aabbs_3.UNBOUNDED_AABB, gdm, callback, callbackThis, posBuffer);
    }
    exports.eachSubEntity = eachSubEntity;
    function makeTileTreeNode(palette, w, h, d, indexes, gdm, opts) {
        if (opts === void 0) { opts = {}; }
        if (indexes.length != w * h * d) {
            throw new Error("Expected 'indexes' to be array of length " + (w * d * h) + "; but it had length " + indexes.length);
        }
        var _paletteRef = makeTileEntityPaletteRef(palette, gdm);
        var tilePalette = gdm.getObject(_paletteRef);
        if (tilePalette == null)
            throw new Error("Failed to get tile palette " + _paletteRef);
        var tileW = 0, tileH = 0, tileD = 0;
        for (var t in tilePalette) {
            var tileEntity = tilePalette[t];
            if (tileEntity == null)
                continue;
            if (tileEntity.entity == null)
                throw new Error("TileEntity#entity is null!");
            var tileClassRef = tileEntity.entity.classRef;
            var tileClass = gdm.getObject(tileClassRef);
            if (tileClass == null)
                throw new Error("Couldn't find entity class " + tileClassRef + " while calculating size for tile tree; given palette: " + JSON.stringify(palette) + "; " + JSON.stringify(tilePalette));
            tileW = Math.max(aabbs_3.aabbWidth(tileClass.tilingBoundingBox), tileW);
            tileH = Math.max(aabbs_3.aabbHeight(tileClass.tilingBoundingBox), tileH);
            tileD = Math.max(aabbs_3.aabbDepth(tileClass.tilingBoundingBox), tileD);
        }
        var totalOpacity = 0;
        var isCompletelyUnsolid = true;
        var isCompletelySolid = true;
        var totalMass = 0;
        for (var i = w * d * h - 1; i >= 0; --i) {
            var tileEntity = tilePalette[indexes[i]];
            if (tileEntity == null)
                continue;
            if (tileEntity.entity.classRef == null)
                continue;
            var tileClass = gdm.getObject(tileEntity.entity.classRef);
            if (tileClass == null)
                throw new Error("Failed to get tile class " + tileEntity.entity.classRef);
            totalOpacity += tileClass.opacity ? tileClass.opacity : 0;
            if (tileClass.isSolid === true)
                isCompletelyUnsolid = false;
            if (tileClass.isSolid === false)
                isCompletelySolid = false;
            totalMass += tileClass.mass == null ? Infinity : tileClass.mass;
        }
        var tilingBoundingBox = DeepFreezer_14.deepFreeze(opts.boundingBox ? opts.boundingBox : aabbs_3.makeAabb(-tileW * w / 2, -tileH * h / 2, -tileD * d / 2, +tileW * w / 2, +tileH * h / 2, +tileD * d / 2));
        return DeepFreezer_14.deepFreeze({
            visualBoundingBox: tilingBoundingBox,
            physicalBoundingBox: tilingBoundingBox,
            structureType: world_2.StructureType.TILE_TREE,
            tilingBoundingBox: tilingBoundingBox,
            xDivisions: w,
            yDivisions: h,
            zDivisions: d,
            childEntityPaletteRef: _paletteRef,
            childEntityIndexes: indexes,
            isSolid: isCompletelyUnsolid ? false : isCompletelySolid ? true : undefined,
            mass: opts.infiniteMass ? Infinity : totalMass,
            // These don't really make sense to have to have on a tile tree
            // isAffectedByGravity: false,
            // visualRef: undefined,
            opacity: totalOpacity / (w * h * d),
        });
    }
    exports.makeTileTreeNode = makeTileTreeNode;
    function makeTileTreeRef(palette, w, h, d, indexes, gdm, opts, alias) {
        if (opts === void 0) { opts = {}; }
        var tt = makeTileTreeNode(palette, w, h, d, indexes, gdm, opts);
        return gdm.tempStoreObject(tt, alias);
    }
    exports.makeTileTreeRef = makeTileTreeRef;
    function roomNeighborKey(room0Ref, offset, room1Ref) {
        return "n" + index_4.base32Encode(index_4.hash(room0Ref + ";" + room1Ref + ";" + vector3ds_9.vectorToArray(offset).join(","), SHA1_2.default));
    }
    exports.roomNeighborKey = roomNeighborKey;
    function roomNeighborKeys(room0Ref, offset, room1Ref) {
        return [
            roomNeighborKey(room0Ref, offset, room1Ref),
            roomNeighborKey(room1Ref, vector3dmath_7.scaleVector(offset, -1), room0Ref),
        ];
    }
    exports.roomNeighborKeys = roomNeighborKeys;
    function connectRooms(gdm, room0Ref, room1Ref, offset) {
        offset = DeepFreezer_14.deepFreeze(offset);
        var room0 = gdm.getMutableRoom(room0Ref);
        if (room0 == null)
            throw new Error("Failed to get room " + room0Ref);
        var room1 = gdm.getMutableRoom(room1Ref);
        if (room1 == null)
            throw new Error("Failed to get room " + room1Ref);
        var _a = roomNeighborKeys(room0Ref, offset, room1Ref), neighborKey0To1 = _a[0], neighborKey1To0 = _a[1];
        room0.neighbors[neighborKey0To1] = {
            offset: offset,
            roomRef: room1Ref,
            bounds: room1.bounds,
        };
        room1.neighbors[neighborKey1To0] = {
            offset: vector3dmath_7.scaleVector(offset, -1),
            roomRef: room0Ref,
            bounds: room0.bounds,
        };
    }
    exports.connectRooms = connectRooms;
    function roomEntityVelocity(re) {
        return util_1.coalesce2(re.velocity, vector3ds_9.ZERO_VECTOR);
    }
    exports.roomEntityVelocity = roomEntityVelocity;
    function roomEntityOrientation(re) {
        return util_1.coalesce2(re.orientation, Quaternion_2.default.IDENTITY);
    }
    exports.roomEntityOrientation = roomEntityOrientation;
    var _a;
});
define("togos-game21/SceneShader", ["require", "exports", "togos-game21/vector3ds", "togos-game21/vector3dmath", "togos-game21/Cuboid", "togos-game21/worldutil", "togos-game21/world"], function (require, exports, vector3ds_10, vector3dmath_8, Cuboid_1, worldutil_1, world_3) {
    "use strict";
    exports.OPACITY_TRANSPARENT = 0;
    exports.OPACITY_OPAQUE = 254;
    exports.OPACITY_VOID = 255; // Void space!  Even more opaque than opaque.
    exports.VISIBILITY_VOID = 0; // Void space!  Even less visible than none.
    exports.VISIBILITY_NONE = 1; // Invisible due to opaqueness
    exports.VISIBILITY_MIN = 2; // Minimum visiblity for actually seeing something at all
    exports.VISIBILITY_MAX = 255; // Very visible
    /*
     * Opactity map gives opacity of each cell
     *
     * Shade map gives visibility of each cell corner
     */
    var ShadeRaster = (function () {
        /**
         * originX and originY are the location of the map's origin relative to its top-left corner in world units
         * width and height are in samples
         * resolution = samples per meter; higher means the size of the thing is smaller
         */
        function ShadeRaster(width, height, resolution, originX, originY) {
            this.width = width;
            this.height = height;
            this.resolution = resolution;
            this.originX = originX;
            this.originY = originY;
            this.data = new Uint8Array(width * height);
        }
        /**
         * If dest is a cuboid, set dest.{min,max}Z as you see fit (-0.5 to +0.5, maybe)
         */
        ShadeRaster.prototype.getBounds = function (dest) {
            dest.minX = -this.originX;
            dest.minY = -this.originY;
            dest.maxX = this.width / this.resolution - this.originX;
            dest.maxY = this.height / this.resolution - this.originY;
            return dest;
        };
        return ShadeRaster;
    }());
    exports.ShadeRaster = ShadeRaster;
    var mapBoundsBuffer = new Cuboid_1.default;
    var roomPosBuf = vector3ds_10.makeVector();
    var objPosBuf = vector3ds_10.makeVector();
    var objBB = new Cuboid_1.default;
    var plax = function (dx0, dy0, dx1, dy1, a, b) {
        return dx0 == dx1 && dy0 == dy1 ? a : b;
    };
    var SceneShader = (function () {
        function SceneShader(gameDataManager) {
            this.gameDataManager = gameDataManager;
            this.destBounds = new Cuboid_1.default;
        }
        SceneShader.prototype.shareMap = function (opacityMap, dest) {
            dest.data.fill(0);
            return dest;
        };
        SceneShader.prototype.applyObjectToOpacityRaster = function (ent, pos, orientation) {
            var proto = this.gameDataManager.getObject(ent.classRef);
            if (!proto)
                return; // Well, maybe we should just mark everything opaque!
            var vbb = proto.visualBoundingBox;
            var destBounds = this.destBounds;
            if (pos.x + vbb.maxX <= destBounds.minX)
                return;
            if (pos.y + vbb.maxY <= destBounds.minY)
                return;
            if (pos.x + vbb.minX >= destBounds.maxX)
                return;
            if (pos.y + vbb.minY >= destBounds.maxY)
                return;
            if (pos.z + vbb.maxZ <= destBounds.minZ)
                return;
            if (proto.opacity === 0)
                return;
            if (proto.structureType == world_3.StructureType.INDIVIDUAL && proto.opacity != null) {
                var destMap = this.destShadeMap;
                var opacityByte = Math.round(255 * proto.opacity);
                // Round object's corners to nearest opacity raster cell corners.
                // (this should have the effect that any cell whose center is covered by the object gets marked opaque)
                var minCX = Math.max(0, Math.round((vbb.minX + pos.x + destMap.originX) * destMap.resolution));
                var minCY = Math.max(0, Math.round((vbb.minY + pos.y + destMap.originY) * destMap.resolution));
                var maxCX = Math.min(destMap.width, Math.round((vbb.maxX + pos.x + destMap.originX) * destMap.resolution));
                var maxCY = Math.min(destMap.height, Math.round((vbb.maxY + pos.y + destMap.originY) * destMap.resolution));
                for (var cy = minCY; cy < maxCY; ++cy) {
                    for (var cx = minCX, ci = cy * destMap.width + cx; cx < maxCX; ++cx, ++ci) {
                        var currentOpacity = destMap.data[ci] / 255;
                        var combinedOpacity = currentOpacity + (1 - currentOpacity) * proto.opacity;
                        destMap.data[ci] = Math.round(exports.OPACITY_OPAQUE * combinedOpacity);
                    }
                }
                return;
            }
            worldutil_1.eachSubEntity(ent, pos, this.gameDataManager, this.applyObjectToOpacityRaster, this);
        };
        /**
         * Pos = position relative to the shademap's origin where this room's origin would appear
         */
        SceneShader.prototype.applyRoomToOpacityRaster = function (room, pos) {
            {
                // Set opacity of room area to zero
                var destMap = this.destShadeMap;
                var destData = destMap.data;
                var tbb = room.bounds;
                var minCX = Math.max(0, Math.round((tbb.minX + pos.x + destMap.originX) * destMap.resolution));
                var minCY = Math.max(0, Math.round((tbb.minY + pos.y + destMap.originY) * destMap.resolution));
                var maxCX = Math.min(destMap.width, Math.round((tbb.maxX + pos.x + destMap.originX) * destMap.resolution));
                var maxCY = Math.min(destMap.height, Math.round((tbb.maxY + pos.y + destMap.originY) * destMap.resolution));
                for (var y = minCY; y < maxCY; ++y)
                    for (var x = minCX, i = y * destMap.width + x; x < maxCX; ++x, ++i) {
                        destData[i] = exports.OPACITY_TRANSPARENT;
                    }
            }
            for (var e in room.roomEntities) {
                var re = room.roomEntities[e];
                var ent = re.entity;
                vector3dmath_8.addVector(pos, re.position, objPosBuf);
                // If we really cared about orientation (and assuming rooms can have them),
                // we'd do the same thing to it.
                this.applyObjectToOpacityRaster(ent, objPosBuf, worldutil_1.roomEntityOrientation(re));
            }
        };
        SceneShader.prototype.sceneOpacityRaster = function (roomRef, roomPos, dest) {
            dest.data.fill(exports.OPACITY_VOID);
            this.destShadeMap = dest;
            dest.getBounds(this.destBounds);
            this.destBounds.minZ = -0.5;
            this.destBounds.maxZ = +0.5;
            var room = this.gameDataManager.getRoom(roomRef);
            if (room == null)
                return dest;
            this.applyRoomToOpacityRaster(room, roomPos);
            for (var n in room.neighbors) {
                var neighbor = room.neighbors[n];
                var neighbR = this.gameDataManager.getObject(neighbor.roomRef);
                if (neighbR == null)
                    continue;
                vector3dmath_8.addVector(roomPos, neighbor.offset, roomPosBuf);
                this.applyRoomToOpacityRaster(neighbR, roomPosBuf);
            }
            return dest;
        };
        /**
         * Fill dest with zeroes and then call this
         * for each cell with eyes.
         */
        SceneShader.prototype.opacityTolVisibilityRaster2 = function (opacity, x, y, dx, dy, maxDistance, dest) {
            if (maxDistance <= exports.VISIBILITY_NONE)
                return;
            if (x < 0 || y < 0 || x >= opacity.width || y >= opacity.height)
                return;
            x |= 0;
            y |= 0;
            if (maxDistance > exports.VISIBILITY_MAX)
                maxDistance = exports.VISIBILITY_MAX;
            var idx = x + y * opacity.width;
            var od = opacity.data[idx];
            if (od >= exports.OPACITY_VOID)
                return;
            maxDistance = exports.VISIBILITY_NONE + Math.floor((maxDistance - exports.VISIBILITY_NONE) * (exports.OPACITY_OPAQUE - od) / exports.OPACITY_OPAQUE);
            if (maxDistance > dest.data[idx]) {
                dest.data[idx] = maxDistance;
                if (maxDistance >= exports.VISIBILITY_MIN) {
                    var ndA = maxDistance - 1;
                    var ndB = (dx == 0 && dy == 0) ? ndA : Math.floor(maxDistance / 2);
                    this.opacityTolVisibilityRaster2(opacity, x + 1, y + 0, +1, 0, plax(+1, 0, dx, dy, ndA, ndB), dest);
                    this.opacityTolVisibilityRaster2(opacity, x + 0, y + 1, 0, +1, plax(0, +1, dx, dy, ndA, ndB), dest);
                    this.opacityTolVisibilityRaster2(opacity, x - 1, y + 0, -1, 0, plax(-1, 0, dx, dy, ndA, ndB), dest);
                    this.opacityTolVisibilityRaster2(opacity, x + 0, y - 1, 0, -1, plax(0, -1, dx, dy, ndA, ndB), dest);
                }
            }
        };
        SceneShader.prototype.initializeVisibilityRaster = function (opacity, dest, opaqueVisibility) {
            if (opaqueVisibility === void 0) { opaqueVisibility = exports.VISIBILITY_NONE; }
            if (dest.width != opacity.width || dest.height != opacity.height) {
                throw new Error("Opacity and destination visibility rasters must have the same dimensions; given " +
                    opacity.width + "x" + opacity.height + " and " + dest.width + "x" + dest.height);
            }
            // Translate voidness to visibility raster
            var opDat = opacity.data, destDat = dest.data;
            for (var i = opacity.width * opacity.height - 1; i >= 0; --i) {
                destDat[i] = opDat[i] == exports.OPACITY_VOID ? exports.VISIBILITY_VOID : opaqueVisibility;
            }
        };
        SceneShader.prototype.opacityTolVisibilityRaster = function (opacity, x, y, maxDistance, dest) {
            this.opacityTolVisibilityRaster2(opacity, x, y, 0, 0, maxDistance, dest);
        };
        /**
         *
         */
        SceneShader.prototype.visibilityToShadeRaster = function (visibility, dest) {
            var vd = visibility.data;
            var dd = dest.data;
            var width = dest.width;
            var height = dest.height;
            for (var i = 0, y = 0; y < height; ++y) {
                for (var x = 0; x < width; ++x, ++i) {
                    var vdc = vd[i];
                    //let v0 = vdc, v1 = vdc, v2 = vdc, v3 = vdc;
                    var vdw = x > 0 ? vd[i - 1] : 0;
                    var vde = x < width - 1 ? vd[i + 1] : 0;
                    var vdn = y > 0 ? vd[i - width] : 0;
                    var vds = y < height - 1 ? vd[i + width] : 0;
                    var vdnw = x > 0 ? (y > 0 ? vd[i - width - 1] : vdc) : vdn;
                    var vdne = x < width - 1 ? (y > 0 ? vd[i - width + 1] : vdc) : vdn;
                    var vdsw = x > 0 ? (y < height - 1 ? vd[i + width - 1] : vdc) : vds;
                    var vdse = x < width - 1 ? (y < height - 1 ? vd[i + width + 1] : vdc) : vds;
                    var v0 = Math.max(vdc, vdnw, vdn, vdw);
                    var v1 = Math.max(vdc, vdne, vdn, vde);
                    var v2 = Math.max(vdc, vdsw, vds, vdw);
                    var v3 = Math.max(vdc, vdse, vds, vde);
                    dd[i] = ((v0 & 0xC0) |
                        ((v1 >> 2) & 0x30) |
                        ((v2 >> 4) & 0x0C) |
                        ((v3 >> 6) & 0x03));
                }
            }
        };
        /**
         * Expand visibility by one sample in every direction (including diagonals);
         * Useful if you're working directly from the visibility raster
         * for determining object visibility instead of converting to a shade raster.
         */
        SceneShader.prototype.growVisibility = function (visibility) {
            var dat = visibility.data;
            var w = visibility.width;
            var h = visibility.height;
            // Increase the value of any cells with visibility=NONE
            // to MIN if they have any neighbor with visibility>MIN.
            // Spread horizontally:
            for (var i = 0, y = 0; y < h; ++y)
                for (var prevVal = 0, x = 0; x < w; ++x, ++i) {
                    if (dat[i] == exports.VISIBILITY_NONE) {
                        if (prevVal >= exports.VISIBILITY_MIN || x < w - 1 && dat[i + 1] >= exports.VISIBILITY_MIN) {
                            dat[i] = exports.VISIBILITY_MIN;
                        }
                        prevVal = exports.VISIBILITY_NONE; // The original value of this cell, not the new one
                    }
                    else {
                        prevVal = dat[i];
                    }
                }
            // Spread vertically:
            for (var x = 0; x < w; ++x)
                for (var prevVal = 0, y = 0; y < h; ++y) {
                    var i = y * w + x;
                    if (dat[i] == exports.VISIBILITY_NONE) {
                        if (prevVal >= exports.VISIBILITY_MIN || y < h - 1 && dat[i + w] >= exports.VISIBILITY_MIN) {
                            dat[i] = exports.VISIBILITY_MIN;
                        }
                        prevVal = exports.VISIBILITY_NONE; // The original value of this cell, not the new one
                    }
                    else {
                        prevVal = dat[i];
                    }
                }
        };
        return SceneShader;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = SceneShader;
    var _a;
});
define("togos-game21/http", ["require", "exports", "tshash/utils"], function (require, exports, utils_7) {
    "use strict";
    var XHRClient = (function () {
        function XHRClient() {
        }
        XHRClient.prototype.openRequest = function (request) {
            return new Promise(function (resolve, reject) {
                var xhr = new XMLHttpRequest;
                xhr.responseType = 'arraybuffer';
                xhr.onreadystatechange = function () {
                    if (xhr.readyState == XMLHttpRequest.DONE) {
                        resolve({
                            statusCode: xhr.status,
                            statusText: xhr.statusText,
                            headers: {},
                            content: new Uint8Array(xhr.response)
                        });
                    }
                };
                xhr.open(request.method, request.uri, true);
                for (var k in request.headers) {
                    xhr.setRequestHeader(k, request.headers[k]);
                }
                if (request.content)
                    xhr.send(request.content);
                else
                    xhr.send();
            });
        };
        return XHRClient;
    }());
    function arrayToBuffer(arr) {
        var buf = new Buffer(arr.length);
        for (var i = arr.length - 1; i >= 0; --i)
            buf[i] = arr[i];
        return buf;
    }
    var NodeClient = (function () {
        function NodeClient() {
        }
        NodeClient.prototype.openRequest = function (request) {
            return new Promise(function (resolve, reject) {
                var HTTP = require('http');
                var URL = require('url');
                var parsedUrl = URL.parse(request.uri);
                var req = HTTP.request({
                    hostname: parsedUrl.hostname,
                    port: parsedUrl.port,
                    path: parsedUrl.path,
                    method: request.method,
                    headers: request.headers,
                }, function (res) {
                    var buffers = [];
                    res.setEncoding(null);
                    res.on('data', function (d) {
                        if (typeof (d) == 'string') {
                            // ugh y this happen 2 me
                            // hacky worxakround ;;((
                            d = utils_7.utf8Encode(d);
                        }
                        buffers.push(d);
                    });
                    res.on('end', function () {
                        var data = new Uint8Array(buffers.reduce(function (len, buf) { return len + buf.length; }, 0));
                        for (var i = 0, b = 0; b < buffers.length; ++b) {
                            var buf = buffers[b];
                            for (var j = 0; j < buf.length; ++j, ++i) {
                                data[i] = buf[j];
                            }
                        }
                        resolve({
                            statusCode: res.statusCode,
                            statusText: res.statusMessage,
                            headers: res.headers,
                            content: data
                        });
                    });
                });
                req.on('error', function (e) { return reject(e); });
                if (request.content)
                    req.write(arrayToBuffer(request.content));
                req.end();
            });
        };
        return NodeClient;
    }());
    function makeClient() {
        if (typeof (XMLHttpRequest) != 'undefined')
            return new XHRClient();
        if (typeof (require) != 'undefined') {
            try {
                require.resolve('http');
                return new NodeClient();
            }
            catch (e) { }
        }
        throw new Error("No XMLHttpRequest or require('http'); can't consturct http client.");
    }
    var _client;
    function getClient() {
        if (!_client)
            _client = makeClient();
        return _client;
    }
    exports.getClient = getClient;
    function makeRequest(method, uri, headers, content) {
        if (headers === void 0) { headers = {}; }
        return { method: method, uri: uri, headers: headers, content: content };
    }
    exports.makeRequest = makeRequest;
    function request(method, uri, headers, content) {
        if (headers === void 0) { headers = {}; }
        return getClient().openRequest(makeRequest(method, uri, headers, content));
    }
    exports.request = request;
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = {
        request: request,
        makeRequest: makeRequest,
        getClient: getClient,
    };
    var _a;
});
define("togos-game21/HTTPHashDatastore", ["require", "exports", "tshash/index", "togos-game21/http"], function (require, exports, index_5, http_1) {
    "use strict";
    var HTTPHashDatastore = (function () {
        function HTTPHashDatastore(_identify, n2rUrl) {
            this._identify = _identify;
            this.n2rUrl = n2rUrl;
        }
        HTTPHashDatastore.createDefault = function () {
            return new HTTPHashDatastore(index_5.sha1Urn, "http://game21-data.nuke24.net/uri-res/N2R");
        };
        Object.defineProperty(HTTPHashDatastore.prototype, "identify", {
            get: function () { return this._identify; },
            enumerable: true,
            configurable: true
        });
        /** Returns the data if immediately available.  Otherwise returns null. */
        HTTPHashDatastore.prototype.get = function (uri) {
            return undefined; // We don't keep anything on hand
        };
        HTTPHashDatastore.prototype.fetch = function (urn) {
            var url = this.n2rUrl + "?" + urn;
            return http_1.default.request('GET', url).then(function (res) {
                if (res.statusCode == 200)
                    return res.content;
                else
                    return Promise.reject(new Error("GET " + url + " returned " + res.statusCode));
            });
        };
        HTTPHashDatastore.prototype.store = function (data) {
            var urn = this._identify(data);
            var url = this.n2rUrl + "?" + urn;
            var resProm = http_1.default.request('PUT', url, {}, data);
            return resProm.then(function () { return urn; });
        };
        HTTPHashDatastore.prototype.fastStore = function (data, onComplete) {
            var urn = this._identify(data);
            var putProm = this.put(urn, data);
            if (onComplete) {
                var onCompleat_2 = onComplete;
                putProm.then(function (id) { return onCompleat_2(true); }, function (err) { return onCompleat_2(false, err); });
            }
            return urn;
        };
        HTTPHashDatastore.prototype.put = function (urn, data) {
            var url = this.n2rUrl + "?" + urn;
            return http_1.default.request('PUT', url, {}, data).then(function (res) {
                if (res.statusCode < 200 || res.statusCode >= 300) {
                    return Promise.reject(new Error("Received status code " + res.statusCode + " from PUT to " + url));
                }
                else {
                    return Promise.resolve(urn);
                }
            });
        };
        return HTTPHashDatastore;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = HTTPHashDatastore;
    var _a;
});
define("togos-game21/forth/Token", ["require", "exports"], function (require, exports) {
    "use strict";
    (function (TokenType) {
        TokenType[TokenType["BAREWORD"] = 0] = "BAREWORD";
        TokenType[TokenType["SINGLE_QUOTED"] = 1] = "SINGLE_QUOTED";
        TokenType[TokenType["DOUBLE_QUOTED"] = 2] = "DOUBLE_QUOTED";
        TokenType[TokenType["COMMENT"] = 3] = "COMMENT";
        TokenType[TokenType["END_OF_FILE"] = 4] = "END_OF_FILE";
    })(exports.TokenType || (exports.TokenType = {}));
    var TokenType = exports.TokenType;
    var Token = (function () {
        function Token(text, type, sourceLocation) {
            this.text = text;
            this.type = type;
            this.sourceLocation = sourceLocation;
        }
        return Token;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = Token;
    var _a;
});
define("togos-game21/forth/Tokenizer", ["require", "exports", "togos-game21/forth/Token", "togos-game21/promises"], function (require, exports, Token_1, promises_1) {
    "use strict";
    var C_BEL = 0x07;
    var C_TAB = 0x09;
    var C_NL = 0x0A;
    var C_VT = 0x0B;
    var C_FF = 0x0C;
    var C_CR = 0x0D;
    var C_ESC = 0x1B;
    var C_SPACE = 0x20;
    var C_A = 'a'.charCodeAt(0);
    var C_E = 'e'.charCodeAt(0);
    var C_F = 'f'.charCodeAt(0);
    var C_N = 'n'.charCodeAt(0);
    var C_R = 'r'.charCodeAt(0);
    var C_T = 't'.charCodeAt(0);
    var C_V = 'v'.charCodeAt(0);
    var C_SHARP = 0x23;
    var C_DOUBLE_QUOTE = 0x22;
    var C_BACKSLASH = 0x5C;
    var C_SINGLE_QUOTE = 0x27;
    var C_OPEN_SINGLE_ANGLE_QUOTE = "‹".charCodeAt(0);
    var C_CLOSE_SINGLE_ANGLE_QUOTE = "›".charCodeAt(0);
    var C_OPEN_DOUBLE_ANGLE_QUOTE = "«".charCodeAt(0);
    var C_CLOSE_DOUBLE_ANGLE_QUOTE = "»".charCodeAt(0);
    var QuoteStyle = (function () {
        function QuoteStyle(openCharCode, closeCharCode, backslashEscapes, tokenType) {
            this.openCharCode = openCharCode;
            this.closeCharCode = closeCharCode;
            this.backslashEscapes = backslashEscapes;
            this.tokenType = tokenType;
        }
        return QuoteStyle;
    }());
    var Tokenizer = (function () {
        function Tokenizer(l) {
            /**
             * Lists end-quote characters that we're awaiting, from inner-most to outer-most.
             * If empty, we're not inside any quotes at all.
             */
            this.handlingLineComment = false;
            this.handlingBackslashEscape = false;
            this.awaitingCloseQuoteChars = [];
            this.tokenType = Token_1.TokenType.BAREWORD;
            this.tokenBuffer = "";
            this.tokenStartLineNumber = 1;
            this.tokenStartColumnNumber = 1;
            this.sourceLineNumber = 1;
            this.sourceColumnNumber = 1;
            this.sourceFileUri = "(anonymous source buffer)";
            this.ended = false;
            this.quoteStylesByOpenChar = {};
            this.quoteStylesByCloseChar = {};
            this.tokenListener = l;
            this.quoteStyles = [
                new QuoteStyle(C_SINGLE_QUOTE, C_SINGLE_QUOTE, true, Token_1.TokenType.SINGLE_QUOTED),
                new QuoteStyle(C_DOUBLE_QUOTE, C_DOUBLE_QUOTE, true, Token_1.TokenType.DOUBLE_QUOTED),
                new QuoteStyle(C_OPEN_SINGLE_ANGLE_QUOTE, C_CLOSE_SINGLE_ANGLE_QUOTE, false, Token_1.TokenType.SINGLE_QUOTED),
                new QuoteStyle(C_OPEN_DOUBLE_ANGLE_QUOTE, C_CLOSE_DOUBLE_ANGLE_QUOTE, false, Token_1.TokenType.DOUBLE_QUOTED),
            ];
        }
        Object.defineProperty(Tokenizer.prototype, "quoteStyles", {
            set: function (styles) {
                this.quoteStylesByOpenChar = {};
                this.quoteStylesByCloseChar = {};
                for (var i in styles) {
                    var style = styles[i];
                    this.quoteStylesByOpenChar[style.openCharCode] = style;
                    this.quoteStylesByCloseChar[style.closeCharCode] = style;
                }
            },
            enumerable: true,
            configurable: true
        });
        /** Adjust source location after processing a character */
        Tokenizer.prototype.postChar = function (c) {
            switch (c) {
                case C_NL:
                    ++this.sourceLineNumber;
                    this.sourceColumnNumber = 1;
                    break;
                case C_TAB:
                    this.sourceColumnNumber = (Math.floor((this.sourceColumnNumber - 1) / 8) + 1) * 8 + 1;
                    break;
                default:
                    ++this.sourceColumnNumber;
                    break;
            }
        };
        Tokenizer.prototype.flushToken = function () {
            if (this.tokenBuffer.length == 0 && this.tokenType == Token_1.TokenType.BAREWORD) {
                // Nothing to flush! Ahahahah1!!
                return;
            }
            var p = this.tokenListener(new Token_1.default(this.tokenBuffer, this.tokenType, {
                fileUri: this.sourceFileUri,
                lineNumber: this.tokenStartLineNumber,
                columnNumber: this.tokenStartColumnNumber,
                endLineNumber: this.sourceLineNumber,
                endColumnNumber: this.sourceColumnNumber
            }));
            this.tokenBuffer = "";
            this.tokenType = Token_1.TokenType.BAREWORD;
            return p;
        };
        Object.defineProperty(Tokenizer.prototype, "atstr", {
            get: function () {
                return "at " + this.sourceFileUri + ":" + this.sourceLineNumber + "," + this.sourceColumnNumber;
            },
            enumerable: true,
            configurable: true
        });
        Tokenizer.prototype._char = function (c) {
            if (this.ended)
                throw new Error("Already ended");
            if (this.handlingLineComment) {
                switch (c) {
                    case C_VT:
                    case C_CR:
                    case C_NL:
                    case C_FF:
                        this.flushToken();
                        this.handlingLineComment = false;
                        break;
                    default:
                        this.tokenBuffer += String.fromCharCode(c);
                        break;
                }
                this.postChar(c);
                return;
            }
            else if (this.handlingBackslashEscape) {
                var decoded = void 0;
                switch (c) {
                    case C_A:
                        decoded = C_BEL;
                        break;
                    case C_E:
                        decoded = C_ESC;
                        break;
                    case C_F:
                        decoded = C_FF;
                        break;
                    case C_N:
                        decoded = C_NL;
                        break;
                    case C_R:
                        decoded = C_CR;
                        break;
                    case C_T:
                        decoded = C_TAB;
                        break;
                    case C_V:
                        decoded = C_VT;
                        break;
                    case C_BACKSLASH:
                    case C_DOUBLE_QUOTE:
                    case C_SINGLE_QUOTE:
                        decoded = c;
                        break;
                    default:
                        throw new Error("Invalid backslash escape sequence: \\" + String.fromCharCode(c) + " " + this.atstr);
                }
                this.tokenBuffer += String.fromCharCode(decoded);
                this.postChar(c);
                this.handlingBackslashEscape = false;
                return;
            }
            else if (this.awaitingCloseQuoteChars.length == 0) {
                // Reading spaces or barewords!
                switch (c) {
                    case C_TAB:
                    case C_VT:
                    case C_NL:
                    case C_FF:
                    case C_CR:
                    case C_SPACE:
                        {
                            var p = this.flushToken();
                            this.postChar(c);
                            return p;
                        }
                    case C_SHARP:
                        {
                            var p = this.flushToken();
                            this.tokenStartLineNumber = this.sourceLineNumber;
                            this.tokenStartColumnNumber = this.sourceColumnNumber;
                            this.tokenType = Token_1.TokenType.COMMENT;
                            this.handlingLineComment = true;
                            this.postChar(c);
                            return p;
                        }
                    default:
                        var quoteStyle = this.quoteStylesByOpenChar[c];
                        if (quoteStyle) {
                            if (this.tokenBuffer.length != 0) {
                                throw new Error("Open-quote found in middle of token (" + this.tokenBuffer + ") " + this.atstr);
                            }
                            this.tokenStartLineNumber = this.sourceLineNumber;
                            this.tokenStartColumnNumber = this.sourceColumnNumber;
                            this.tokenType = quoteStyle.tokenType;
                            this.awaitingCloseQuoteChars.unshift(quoteStyle.closeCharCode);
                            this.postChar(c);
                            return;
                        }
                        if (this.tokenBuffer.length == 0) {
                            this.tokenStartLineNumber = this.sourceLineNumber;
                            this.tokenStartColumnNumber = this.sourceColumnNumber;
                        }
                        this.tokenBuffer += String.fromCharCode(c);
                        this.postChar(c);
                        return;
                }
            }
            else {
                if (this.awaitingCloseQuoteChars[0] == c) {
                    this.awaitingCloseQuoteChars.shift();
                    if (this.awaitingCloseQuoteChars.length == 0) {
                        this.postChar(c);
                        return this.flushToken();
                    }
                }
                var currentCloseChar = this.awaitingCloseQuoteChars[0];
                var style = this.quoteStylesByCloseChar[currentCloseChar];
                if (style == null)
                    throw new Error("Failed to find quote for close quote " + String.fromCharCode(currentCloseChar));
                if (style.backslashEscapes && c == C_BACKSLASH) {
                    this.handlingBackslashEscape = true;
                    this.postChar(c);
                    return;
                }
                if (style.openCharCode == c) {
                    this.awaitingCloseQuoteChars.unshift(style.closeCharCode);
                }
                this.tokenBuffer += String.fromCharCode(c);
                this.postChar(c);
                return;
            }
        };
        Object.defineProperty(Tokenizer.prototype, "sourceLocation", {
            set: function (sl) {
                this.sourceLineNumber = sl.lineNumber;
                this.sourceColumnNumber = sl.columnNumber;
                this.sourceFileUri = sl.fileUri;
            },
            enumerable: true,
            configurable: true
        });
        Tokenizer.prototype.text = function (text, skip) {
            var _this = this;
            if (skip === void 0) { skip = 0; }
            var _loop_2 = function(i) {
                var p = void 0;
                if ((p = this_2._char(text.charCodeAt(i))) != null) {
                    return { value: p.then(function () { return _this.text(text, i + 1); }) };
                }
            };
            var this_2 = this;
            for (var i = skip; i < text.length; ++i) {
                var state_3 = _loop_2(i);
                if (typeof state_3 === "object") return state_3.value;
            }
            return promises_1.RESOLVED_VOID_PROMISE;
        };
        Tokenizer.prototype.end = function () {
            var _this = this;
            if (this.handlingBackslashEscape) {
                throw new Error("Expected rest of backslash escape sequence but encountered end of stream " + this.atstr);
            }
            if (this.ended)
                throw new Error("Already ended");
            if (this.awaitingCloseQuoteChars.length > 0) {
                throw new Error("Expected " + String.fromCharCode(this.awaitingCloseQuoteChars[0]) + " but encountered end of stream " + this.atstr);
            }
            this.ended = true;
            return promises_1.shortcutThen(promises_1.vopToPromise(this.flushToken(), null), function () { return _this.tokenListener({
                type: Token_1.TokenType.END_OF_FILE,
                text: "",
                sourceLocation: {
                    fileUri: _this.sourceFileUri,
                    lineNumber: _this.sourceLineNumber,
                    columnNumber: _this.sourceColumnNumber,
                    endLineNumber: _this.sourceLineNumber,
                    endColumnNumber: _this.sourceColumnNumber,
                }
            }); });
        };
        return Tokenizer;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = Tokenizer;
    var _a;
});
/// <reference path="../../Promise.d.ts"/>
define("togos-game21/MultiDatastore", ["require", "exports"], function (require, exports) {
    "use strict";
    function fetchFrom(uri, stores, skip) {
        if (skip === void 0) { skip = 0; }
        if (skip >= stores.length)
            return Promise.reject(uri + " not found in any datastore.");
        return stores[skip].fetch(uri).then(function (got) { return got; }, function (error) { return fetchFrom(uri, stores, skip + 1); });
    }
    var MultiDatastore = (function () {
        function MultiDatastore(_identify, stores, fetchOnlyStores) {
            if (fetchOnlyStores === void 0) { fetchOnlyStores = []; }
            this._identify = _identify;
            this.stores = stores;
            this.fetchOnlyStores = fetchOnlyStores;
        }
        Object.defineProperty(MultiDatastore.prototype, "identify", {
            get: function () { return this._identify; },
            enumerable: true,
            configurable: true
        });
        MultiDatastore.prototype.get = function (uri) {
            for (var s in this.stores) {
                var v = this.stores[s].get(uri);
                if (v != null)
                    return v;
            }
            for (var s in this.fetchOnlyStores) {
                var v = this.fetchOnlyStores[s].get(uri);
                if (v != null)
                    return v;
            }
            return undefined;
        };
        Object.defineProperty(MultiDatastore.prototype, "allStores", {
            get: function () {
                if (this.fetchOnlyStores.length == 0)
                    return this.stores;
                if (this.stores.length == 0)
                    return this.fetchOnlyStores;
                return this.stores.concat(this.fetchOnlyStores);
            },
            enumerable: true,
            configurable: true
        });
        MultiDatastore.prototype.fetch = function (uri) {
            return fetchFrom(uri, this.allStores);
        };
        MultiDatastore.prototype.store = function (data) {
            if (this.stores.length == 0)
                return Promise.reject("No stores; can't store.");
            var storePromises = [];
            for (var s in this.stores) {
                storePromises.push(this.stores[s].store(data));
            }
            // Maybe what we actually want is to return on first /success/.
            // Or require some number of successes.
            return Promise.race(storePromises);
        };
        MultiDatastore.prototype.fastStore = function (data, onComplete) {
            if (onComplete)
                throw new Error("MultiDatastore#fastStore doesn't support onComplete!");
            var ident = this._identify(data);
            for (var s in this.stores) {
                this.stores[s].fastStore(data);
            }
            return ident;
        };
        MultiDatastore.prototype.put = function (id, data) {
            return Promise.race(this.stores.map(function (s) { return s.put(id, data); }));
        };
        return MultiDatastore;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = MultiDatastore;
    var _a;
});
define("togos-game21/graphmaze/picking", ["require", "exports"], function (require, exports) {
    "use strict";
    exports.EVERYTHING_FITS = function (x) { return 1; };
    function randInt(min, max) {
        var m = Math.floor(max - min) + 1;
        return min + Math.floor(m * Math.random());
    }
    exports.randInt = randInt;
    function nMostFit(coll, count, fitnessFunction, collectionDescription, minFitness, minCount) {
        if (collectionDescription === void 0) { collectionDescription = "items"; }
        if (minFitness === void 0) { minFitness = 0; }
        if (minCount === void 0) { minCount = 1; }
        var withFitness = coll.map(function (n) { return [n, fitnessFunction(n)]; });
        var filtered = withFitness.filter(function (_a) {
            var n = _a[0], fit = _a[1];
            return fit >= minFitness;
        });
        if (filtered.length < minCount)
            throw new Error("Found only " + filtered.length + " of " + minCount + " " + collectionDescription);
        var sorted = filtered.sort(function (_a, _b) {
            var n0 = _a[0], fit0 = _a[1];
            var n1 = _b[0], fit1 = _b[1];
            return fit0 > fit1 ? -1 : fit0 == fit1 ? 0 : +1;
        });
        return sorted.slice(0, count).map(function (_a) {
            var n = _a[0], fit = _a[1];
            return n;
        });
    }
    exports.nMostFit = nMostFit;
    function bestFit(coll, fitnessFunction, resultDescription) {
        if (resultDescription === void 0) { resultDescription = "item"; }
        var bestFitness = 0;
        var bestFit = undefined;
        for (var i in coll) {
            var item = coll[i];
            var fitness = fitnessFunction(item);
            if (fitness > bestFitness) {
                bestFitness = fitness;
                bestFit = item;
            }
        }
        if (bestFit == undefined)
            throw new Error("Can't pick " + resultDescription + "; no items had fitness > 0!");
        return bestFit;
    }
    exports.bestFit = bestFit;
    function pickOne(t) {
        if (t.length == 0)
            throw new Error("Can't pick from zero-length list!");
        return t[Math.floor(Math.random() * t.length)];
    }
    exports.pickOne = pickOne;
    var _a;
});
define("togos-game21/maze1demodata", ["require", "exports", "togos-game21/vector3ds", "togos-game21/aabbs", "togos-game21/world", "togos-game21/worldutil", "togos-game21/GameDataManager", "tshash/index", "togos-game21/HTTPHashDatastore"], function (require, exports, vector3ds_14, aabbs_5, world_5, worldutil_3, GameDataManager_2, index_8, HTTPHashDatastore_3) {
    "use strict";
    /// <reference path="../Promise.d.ts"/>
    function hexDig(i) {
        return String.fromCharCode(i < 10 ? 48 + i : 87 + i);
    }
    function hexEncodeBits(pix) {
        var enc = "";
        for (var i = 0; i + 4 <= pix.length; i += 4) {
            var num = (pix[i + 0] << 3) | (pix[i + 1] << 2) | (pix[i + 2] << 1) | (pix[i + 3] << 0);
            enc += hexDig(num);
        }
        return enc;
    }
    function rgbaToNumber(r, g, b, a) {
        return ((r & 0xFF) << 24) | ((g & 0xFF) << 16) | ((b & 0xFF) << 8) | (a & 0xFF);
    }
    //// Images
    var rox1Pix = [
        0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
        0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
        1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
        1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,
        1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,
        1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,
        1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,
        1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,
        1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
    ];
    var brikPix = [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,
        1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,
        1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    ];
    var bigBrikPix = [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    ];
    var playerPix = [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0,
        0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0,
        0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
        0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
        0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
    ];
    var deadPlayerPix = [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0,
        0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0,
        0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,
    ];
    var plant1Pix = [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0,
        0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0,
        0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,
        0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0,
        0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0,
        0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
    ];
    var vines1Pix = [
        0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0,
        0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1,
        0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0,
        0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
        0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0,
        0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0,
        0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0,
        0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0,
        0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0,
        0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0,
        0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0,
        0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0,
        0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0,
        0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,
        0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0,
        0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
    ];
    var roots1Pix = [
        0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
        0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0,
        0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0,
        0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0,
        0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
        1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1,
        1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
        0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0,
        0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0,
        0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0,
        0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0,
        0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0,
        1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1,
        1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0,
        1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
    ];
    var ladder1FrontPix = [
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
    ];
    var ladder1SidePix = [
        0, 1, 1, 0,
        0, 1, 1, 0,
        1, 1, 1, 1,
        0, 1, 1, 0,
        0, 1, 1, 0,
        0, 1, 1, 0,
        1, 1, 1, 1,
        0, 1, 1, 0,
        0, 1, 1, 0,
        0, 1, 1, 0,
        1, 1, 1, 1,
        0, 1, 1, 0,
        0, 1, 1, 0,
        0, 1, 1, 0,
        1, 1, 1, 1,
        0, 1, 1, 0,
    ];
    var ladder1TopPix = [
        0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0,
    ];
    var doorFramePix = [
        1, 1, 0, 1,
        1, 0, 1, 1,
        1, 1, 0, 1,
        1, 0, 0, 1,
    ];
    var doorTrackPix = [
        0, 0, 0, 0,
        1, 0, 1, 0,
        0, 1, 0, 1,
        0, 0, 0, 0,
    ];
    var chunkPix = [
        0, 1, 1, 1,
        1, 1, 1, 0,
    ];
    var doorSegmentPix = [
        0, 0, 1, 1, 1, 1, 1, 1, 0, 0,
        0, 1, 1, 0, 0, 0, 0, 1, 1, 0,
        0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
        1, 1, 0, 1, 0, 0, 1, 0, 1, 1,
        1, 1, 0, 1, 0, 0, 1, 0, 1, 1,
        0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
        0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
        0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
        0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
        0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
        0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
        1, 1, 0, 1, 0, 0, 1, 0, 1, 1,
        1, 1, 0, 1, 0, 0, 1, 0, 1, 1,
        0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
        0, 1, 1, 0, 0, 0, 0, 1, 1, 0,
        0, 0, 1, 1, 1, 1, 1, 1, 0, 0,
    ];
    var platformSegmentPix = [
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 0, 0, 0, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 0, 0, 0, 0, 0, 0, 1,
        0, 1, 0, 0, 0, 0, 1, 0,
        0, 0, 1, 0, 0, 1, 0, 0,
        1, 1, 1, 1, 1, 1, 1, 1,
    ];
    var ballPix = [
        0, 0, 1, 1, 1, 1, 0, 0,
        0, 1, 1, 1, 1, 1, 1, 0,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 0, 1,
        1, 1, 1, 1, 1, 1, 0, 1,
        1, 1, 1, 1, 1, 0, 0, 1,
        0, 1, 1, 0, 0, 0, 1, 0,
        0, 0, 1, 1, 1, 1, 0, 0,
    ];
    var latticeColumnPix = [
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 0, 0, 0, 0, 1, 1,
        1, 1, 1, 0, 0, 1, 1, 1,
        1, 1, 0, 1, 1, 0, 1, 1,
        1, 1, 0, 1, 1, 0, 1, 1,
        1, 1, 1, 0, 0, 1, 1, 1,
        1, 1, 0, 0, 0, 0, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
    ];
    var keyPix = [
        0, 1, 1, 1, 0, 0, 0, 0,
        1, 1, 0, 1, 1, 1, 1, 1,
        1, 1, 0, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 0, 1, 0, 1,
    ];
    var applePix = [
        0, 0, 0, 0, 0, 1, 0, 0,
        0, 0, 0, 0, 1, 0, 0, 0,
        0, 1, 1, 1, 0, 1, 1, 0,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 1, 1,
        1, 1, 1, 1, 1, 0, 1, 1,
        0, 1, 1, 1, 0, 1, 1, 0,
        0, 0, 1, 0, 1, 1, 0, 0,
    ];
    var stick1Pix = [
        0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 1,
        0, 0, 0, 0, 0, 0, 1, 0,
        0, 0, 0, 0, 0, 1, 0, 0,
        0, 0, 1, 1, 1, 0, 0, 0,
        1, 1, 0, 0, 0, 1, 1, 1,
    ];
    var stick2Pix = [
        0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 1, 0, 0, 0, 0,
        0, 0, 0, 1, 0, 0, 0, 0,
        0, 1, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 1, 0,
        1, 1, 0, 0, 0, 0, 0, 1,
    ];
    var cheapDoorPix = [
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
        0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0,
    ];
    var triforcePix = [
        0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
        0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
        0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
        0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,
        0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    ];
    function bitImgColor(c) {
        if (typeof c == 'number')
            return c;
        if (c.length == 3) {
            return rgbaToNumber(c[0], c[1], c[2], 255);
        }
        else if (c.length == 4) {
            return rgbaToNumber(c[0], c[1], c[2], c[3]);
        }
        throw new Error("BitImg color parameter must be a number of array of length 3 or 4");
    }
    function bitImgRef(color0, color1, pixDat, width, height) {
        var mods = [];
        if (color0 != 0)
            mods.push("color0=" + bitImgColor(color0));
        mods.push("color1=" + bitImgColor(color1));
        if (width != undefined)
            mods.push("width=" + width);
        if (height != undefined)
            mods.push("height=" + height);
        return "bitimg:" + mods.join(';') + "," + hexEncodeBits(pixDat);
    }
    var black = [0, 0, 0];
    var wallBlue = [128, 128, 220];
    var wallRed = [220, 128, 128];
    var wallYellow = [220, 220, 128];
    var tanRox1ImgRef = bitImgRef(black, [180, 160, 140], rox1Pix);
    var brikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(200, 200, 180, 255) + "," + hexEncodeBits(brikPix);
    var brownBrikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(200, 180, 128, 255) + "," + hexEncodeBits(brikPix);
    var grayBrikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(128, 128, 128, 255) + "," + hexEncodeBits(brikPix);
    var blueBrikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(128, 128, 220, 255) + "," + hexEncodeBits(brikPix);
    var yellowBrikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(220, 220, 128, 255) + "," + hexEncodeBits(brikPix);
    var redBrikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(220, 128, 128, 255) + "," + hexEncodeBits(brikPix);
    var bigBrikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(220, 220, 200, 255) + "," + hexEncodeBits(bigBrikPix);
    var bigBlueBrikImgRef = bitImgRef(black, wallBlue, bigBrikPix);
    var bigYellowBrikImgRef = bitImgRef(black, wallYellow, bigBrikPix);
    var bigRedBrikImgRef = bitImgRef(black, wallRed, bigBrikPix);
    var plant1ImgRef = bitImgRef(0, [64, 192, 64], plant1Pix);
    var browningPlant1ImgRef = bitImgRef(0, [64, 112, 64], plant1Pix);
    var brownPlant1ImgRef = bitImgRef(0, [80, 72, 48], plant1Pix);
    var vines1ImgRef = bitImgRef(0, [64, 192, 64], vines1Pix);
    var browningVines1ImgRef = bitImgRef(0, [64, 128, 64], vines1Pix);
    var roots1ImgRef = bitImgRef(0, [96, 80, 64], roots1Pix);
    var ballImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(128, 48, 48, 255) + "," + hexEncodeBits(ballPix);
    var doorFrameImgRef = "bitimg:color1=" + rgbaToNumber(64, 64, 64, 255) + "," + hexEncodeBits(doorFramePix);
    var doorSegmentImgRef = 'bitimg:width=10;height=16;color1=' + rgbaToNumber(240, 240, 230, 255) + "," + hexEncodeBits(doorSegmentPix);
    var platformSegmentImgRef = 'bitimg:color1=' + rgbaToNumber(240, 240, 160, 255) + "," + hexEncodeBits(platformSegmentPix);
    var ladder1FrontImgRef = "bitimg:color1=" + rgbaToNumber(128, 96, 96, 255) + "," + hexEncodeBits(ladder1FrontPix);
    var ladder1SideImgRef = "bitimg:width=4;height=16;color1=" + rgbaToNumber(128, 96, 96, 255) + "," + hexEncodeBits(ladder1SidePix);
    var ladder1TopImgRef = "bitimg:width=16;height=4;color1=" + rgbaToNumber(128, 96, 96, 255) + "," + hexEncodeBits(ladder1TopPix);
    var latticeColumnImgRef = "bitimg:color1=" + rgbaToNumber(192, 192, 192, 255) + "," + hexEncodeBits(latticeColumnPix);
    var latticeColumnBgImgRef = "bitimg:color1=" + rgbaToNumber(64, 64, 64, 255) + "," + hexEncodeBits(latticeColumnPix);
    var playerImgRef = bitImgRef(0, [224, 224, 96], playerPix);
    var deadPlayerImgRef = bitImgRef(0, [112, 96, 48], deadPlayerPix, 16, 8);
    var blueKeyImgRef = bitImgRef(0, [0, 0, 192], keyPix, 8, 4);
    var yellowKeyImgRef = bitImgRef(0, [192, 192, 0], keyPix, 8, 4);
    var redKeyImgRef = bitImgRef(0, [192, 0, 0], keyPix, 8, 4);
    var triforceImgRef = bitImgRef(0, [200, 200, 128], triforcePix, 12, 12);
    var appleImgRef = bitImgRef(0, [160, 64, 32], applePix);
    var stick1ImgRef = bitImgRef(0, [112, 96, 72], stick1Pix, 8, 6);
    var stick2ImgRef = bitImgRef(0, [112, 96, 72], stick2Pix, 8, 6);
    var vomitChunk1ImgRef = bitImgRef(0, [128, 96, 48], chunkPix, 4, 2);
    var vomitChunk2ImgRef = bitImgRef(0, [96, 128, 48], chunkPix, 4, 2);
    var vomitChunk3ImgRef = bitImgRef(0, [160, 192, 64], chunkPix, 4, 2);
    var cheapBlueDoorImgRef = bitImgRef(0, [0, 0, 192], cheapDoorPix, 10, 16);
    var cheapYellowDoorImgRef = bitImgRef(0, [192, 192, 0], cheapDoorPix, 10, 16);
    var cheapRedDoorImgRef = bitImgRef(0, [192, 0, 0], cheapDoorPix, 10, 16);
    //// Room data
    exports.room1Id = 'urn:uuid:9d424151-1abf-45c1-b581-170c6eec5941';
    exports.room2Id = 'urn:uuid:9d424151-1abf-45c1-b581-170c6eec5942';
    exports.room3Id = 'urn:uuid:9d424151-1abf-45c1-b581-170c6eec5943';
    var room1Data = [
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 13, 0, 0, 12,
        1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 13, 0, 0, 10,
        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 0, 13, 0, 0, 10,
        1, 0, 16, 0, 1, 3, 8, 8, 8, 8, 0, 0, 13, 0, 0, 10,
        1, 0, 16, 0, 1, 1, 1, 2, 2, 2, 2, 2, 11, 0, 0, 10,
        1, 0, 16, 0, 0, 0, 0, 0, 5, 0, 0, 0, 13, 0, 0, 10,
        1, 0, 2, 2, 2, 1, 1, 2, 5, 1, 1, 1, 11, 0, 0, 12,
        1, 0, 2, 1, 1, 1, 1, 2, 5, 1, 0, 2, 11, 0, 0, 12,
        1, 0, 0, 0, 2, 2, 2, 2, 5, 1, 0, 2, 11, 0, 0, 10,
        0, 0, 5, 0, 0, 0, 0, 0, 5, 0, 0, 2, 11, 0, 0, 12,
        1, 1, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 5, 1, 1, 0, 0, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 0, 5, 0, 0, 0, 0, 8, 8, 8, 0, 0, 13, 0, 0, 10,
        1, 3, 5, 3, 1, 1, 0, 2, 2, 2, 0, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
    ];
    var room3Data = [
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 11, 0, 0, 10,
    ];
    var room2Data = [
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 0, 5, 0, 0, 0, 0, 0, 9, 9, 0, 9, 1, 0, 1, 0,
        1, 0, 5, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
        1, 1, 1, 0, 1, 1, 1, 2, 7, 0, 0, 0, 1, 0, 0, 1,
        1, 1, 1, 0, 1, 1, 1, 2, 7, 0, 0, 0, 0, 0, 1, 1,
        1, 1, 1, 0, 8, 8, 4, 8, 7, 0, 0, 2, 2, 2, 1, 1,
        1, 0, 0, 0, 8, 8, 4, 8, 7, 0, 0, 0, 0, 0, 0, 0,
        1, 0, 2, 2, 2, 1, 4, 2, 7, 0, 0, 6, 1, 3, 3, 7,
        1, 0, 0, 0, 0, 1, 4, 2, 7, 0, 0, 6, 1, 1, 1, 7,
        1, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 6, 1, 1, 1, 1,
        0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 0, 6, 1, 0, 0, 0,
        1, 2, 5, 1, 1, 1, 1, 1, 1, 3, 3, 6, 1, 0, 1, 1,
        1, 2, 5, 1, 1, 0, 0, 2, 2, 2, 2, 1, 1, 0, 0, 1,
        1, 2, 5, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,
        1, 2, 5, 0, 2, 1, 0, 2, 2, 2, 0, 1, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    ];
    var defaultRoomData = [
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    ];
    exports.basicTileEntityPaletteRef = 'urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#';
    function makeSolidArray(v, length) {
        var arr = [];
        for (var i = 0; i < length; ++i)
            arr.push(v);
        return arr;
    }
    function getDefaultRoomTileTreeRef(gdm, width, height, depth) {
        return worldutil_3.makeTileTreeRef(exports.basicTileEntityPaletteRef, width, height, depth, makeSolidArray(1, width * height * depth), gdm, { infiniteMass: true });
    }
    exports.getDefaultRoomTileTreeRef = getDefaultRoomTileTreeRef;
    ;
    //// Tile tree data
    var doorFrameBlockData = [
        1, 0, 0, 1,
        1, 0, 0, 1,
        1, 0, 0, 1,
        1, 0, 0, 1,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        1, 0, 0, 1,
        1, 0, 0, 1,
        1, 0, 0, 1,
        1, 0, 0, 1,
    ];
    var doorData = [1, 1, 1];
    var UNIT_CUBE = aabbs_5.makeAabb(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
    var HUNIT_CUBE = aabbs_5.makeAabb(-0.25, -0.25, -0.25, 0.25, 0.25, 0.25);
    var QUNIT_CUBE = aabbs_5.makeAabb(-0.125, -0.125, -0.125, 0.125, 0.125, 0.125);
    var NORTH_SIDE_BB = aabbs_5.makeAabb(-0.5, -0.5, -0.5, +0.5, +0.5, -0.25);
    var EAST_SIDE_BB = aabbs_5.makeAabb(+0.25, -0.5, -0.5, +0.5, +0.5, +0.5);
    var WEST_SIDE_BB = aabbs_5.makeAabb(-0.5, -0.5, -0.5, -0.25, +0.5, +0.5);
    var TOP_SIDE_BB = aabbs_5.makeAabb(-0.5, -0.5, -0.5, +0.5, -0.25, +0.5);
    exports.ballEntityClassId = 'urn:uuid:762f0209-0b91-4084-b1e0-3aac3ca5f5ab';
    exports.doorFramePieceEntityId = 'urn:uuid:3709e285-3444-420d-9753-ef101fd7924b';
    exports.doorSegmentEntityClassId = 'urn:uuid:5da4e293-031f-4062-b83f-83241d6768e9';
    exports.door3EntityClassId = 'urn:uuid:13a4aa97-7b26-49ee-b282-fc53eccdf9cb';
    exports.platformSegmentEntityClassId = 'urn:uuid:819f8257-bcad-4d2f-a64e-0a855ad9dd6e';
    exports.platform3EntityClassId = 'urn:uuid:585927b9-b225-49d7-a49a-dff0445a1f78';
    exports.tileEntityPaletteId = 'urn:uuid:50c19be4-7ab9-4dda-a52f-cf4cfe2562ac';
    exports.spawnPointEntityClassId = 'urn:uuid:416bfc18-7412-489f-a45e-6ff4c6a4e08a';
    exports.playerEntityClassId = 'urn:uuid:416bfc18-7412-489f-a45e-6ff4c6a4e08b';
    exports.deadPlayerEntityClassId = 'urn:uuid:416bfc18-7412-489f-a45e-6ff4c6a4e08c';
    exports.tanRox1EntityClassId = 'urn:uuid:4513ae98-0f43-4099-a532-6522adc6b6f1';
    exports.brikEntityClassId = 'urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f77';
    exports.brownBrikEntityClassId = 'urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f78';
    exports.blueBrikEntityClassId = 'urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f79';
    exports.yellowBrikEntityClassId = 'urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f7a';
    exports.redBrikEntityClassId = 'urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f7b';
    exports.grayBrikEntityClassId = 'urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f7c';
    exports.bigBrikEntityClassId = 'urn:uuid:de6fbe4f-a475-46fe-8613-1900d6a5d36c';
    exports.bigBlueBrikEntityClassId = 'urn:uuid:6764a015-767e-4403-b565-4fbe94851f0d';
    exports.bigYellowBrikEntityClassId = 'urn:uuid:6764a015-767e-4403-b565-4fbe94851f0e';
    exports.bigRedBrikEntityClassId = 'urn:uuid:6764a015-767e-4403-b565-4fbe94851f0f';
    exports.plant1EntityClassId = 'urn:uuid:159aa4e5-016a-473d-9be7-5ba492fa899b';
    exports.browningPlant1EntityClassId = 'urn:uuid:159aa4e5-016a-473d-9be7-5ba492fa899c';
    exports.brownPlant1EntityClassId = 'urn:uuid:159aa4e5-016a-473d-9be7-5ba492fa899d';
    exports.vines1EntityClassId = 'urn:uuid:4ee24c8f-7309-462e-b219-ed60505bdb52';
    exports.browningVines1EntityClassId = 'urn:uuid:4ee24c8f-7309-462e-b219-ed60505bdb53';
    exports.roots1EntityClassId = 'urn:uuid:123da2f5-252a-408d-9031-98a7f6639acc';
    exports.backLadderEntityClassId = 'urn:uuid:80cad088-4875-4fc4-892e-34c3035035cc';
    exports.doorFrameEntityClassId = 'urn:uuid:fde59aa4-d580-456b-b173-2b65f837fcb0';
    exports.latticeColumnEntityClassId = 'urn:uuid:601fb61a-df00-49bf-8189-877497cf492f';
    exports.latticeColumnRightBlockEntityClassId = 'urn:uuid:02056297-7242-4ff2-af15-69055671e5c5';
    exports.latticeColumnLeftBlockEntityClassId = 'urn:uuid:9bee7432-5ad0-4f9d-9759-9d1a6fa02a85';
    exports.latticeColumnBgEntityClassId = 'urn:uuid:b64789e4-023c-49ea-98b5-a9d892688bbb';
    exports.latticeColumnBgRightBlockEntityClassId = 'urn:uuid:c447986a-19d2-447a-ab39-afe9df781dbe';
    exports.latticeColumnBgLeftBlockEntityClassId = 'urn:uuid:c145afdd-bc60-4c97-bad8-b6fcb3e1846f';
    exports.primarySpawnPointEntityId = 'urn:uuid:d42a8340-ec03-482b-ae4c-a1bfdec4ba3a';
    exports.playerEntityId = 'urn:uuid:d42a8340-ec03-482b-ae4c-a1bfdec4ba32';
    exports.ballEntityId = 'urn:uuid:10070a44-2a0f-41a1-bcfb-b9e16a6f1b59';
    exports.blueKeyEntityId = 'urn:uuid:fd1935da-f128-4195-8a13-90fbf59ef3b1';
    exports.yellowKeyEntityId = 'urn:uuid:fd1935da-f128-4195-8a13-90fbf59ef3b2';
    exports.door3EntityId = 'urn:uuid:1a8455be-8cce-4721-8ccb-7f5644e30081';
    exports.platformEntityId = 'urn:uuid:27c27635-99ba-4ef3-b3ff-445eb9b132e5';
    var room1TileTreeId = 'urn:uuid:a11ed6ae-f096-4b30-bd39-2a78d39a1381';
    var room2TileTreeId = 'urn:uuid:a11ed6ae-f096-4b30-bd39-2a78d39a1382';
    var room3TileTreeId = 'urn:uuid:a11ed6ae-f096-4b30-bd39-2a78d39a1383';
    exports.blueKeyEntityClassId = 'urn:uuid:f2f4bea7-7a6a-45af-9a70-83c7ce58ba31';
    exports.redKeyEntityClassId = 'urn:uuid:f2f4bea7-7a6a-45af-9a70-83c7ce58ba32';
    exports.yellowKeyEntityClassId = 'urn:uuid:f2f4bea7-7a6a-45af-9a70-83c7ce58ba33';
    exports.triforceEntityClassId = 'urn:uuid:849d75c9-ab5b-476f-9192-c87601d40de0';
    exports.appleEntityClassId = 'urn:uuid:6048f9b8-f5bf-414a-b439-3f812e1ad31a';
    exports.stick1EntityClassId = 'urn:uuid:4f3fd5b7-b51e-4ae7-9673-febed16050c1';
    exports.stick2EntityClassId = 'urn:uuid:4f3fd5b7-b51e-4ae7-9673-febed16050c2';
    exports.vomitChunk1EntityClassId = 'urn:uuid:8025cb25-4797-48ef-9500-78f202f074ea';
    exports.vomitChunk2EntityClassId = 'urn:uuid:8025cb25-4797-48ef-9500-78f202f074eb';
    exports.vomitChunk3EntityClassId = 'urn:uuid:8025cb25-4797-48ef-9500-78f202f074ec';
    exports.cheapBlueDoorEntityClassId = 'urn:uuid:0575864a-e0d0-4fa4-b84a-a724a66dcb61';
    exports.cheapRedDoorEntityClassId = 'urn:uuid:0575864a-e0d0-4fa4-b84a-a724a66dcb62';
    exports.cheapYellowDoorEntityClassId = 'urn:uuid:0575864a-e0d0-4fa4-b84a-a724a66dcb63';
    exports.keyDoorClassRefs = {
        blueKeyEntityClassId: exports.cheapBlueDoorEntityClassId,
        yellowKeyEntityClassId: exports.cheapYellowDoorEntityClassId,
        redKeyEntityClassId: exports.cheapRedDoorEntityClassId,
    };
    exports.keyClassRefs = [
        exports.blueKeyEntityClassId,
        exports.yellowKeyEntityClassId,
        exports.redKeyEntityClassId,
    ];
    /**
     * Returns a promise for the new game data root node URI
     */
    function initData(gdm) {
        var doorFrameBlockEntityPaletteRef = worldutil_3.makeTileEntityPaletteRef([
            null,
            exports.doorFramePieceEntityId,
        ], gdm);
        var doorEntityPaletteRef = worldutil_3.makeTileEntityPaletteRef([
            null,
            exports.doorSegmentEntityClassId,
        ], gdm);
        var platformEntityPaletteRef = worldutil_3.makeTileEntityPaletteRef([
            null,
            exports.platformSegmentEntityClassId,
        ], gdm);
        gdm.tempStoreObject({
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: QUNIT_CUBE,
            physicalBoundingBox: QUNIT_CUBE,
            visualBoundingBox: QUNIT_CUBE,
            isSolid: true,
            mass: 10,
            opacity: 1,
            climbability: 1 / 16,
            visualRef: doorFrameImgRef
        }, exports.doorFramePieceEntityId);
        gdm.tempStoreObject({
            debugLabel: "rocks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: tanRox1ImgRef
        }, exports.tanRox1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "big blue bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: bigBlueBrikImgRef
        }, exports.bigBlueBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "big yellow bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: bigYellowBrikImgRef
        }, exports.bigYellowBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "big red bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: bigRedBrikImgRef
        }, exports.bigRedBrikEntityClassId);
        var leftHandAttachmentZoneKey = 'urn:uuid:aed817b0-e381-400e-9797-ce9bff56d76d';
        var rightHandAttachmentZoneKey = 'urn:uuid:8e39b8de-5f0f-4312-889b-d053bdc22649';
        var playerHandAttachmentZoneClassRef = 'urn:uuid:9ba873f6-eb7b-4f21-859f-9eba85a724c8';
        gdm.tempStoreObject({
            attachmentZoneTypeRef: world_5.AZTYPE_HAND
        }, playerHandAttachmentZoneClassRef);
        gdm.tempStoreObject({
            debugLabel: "spawn point",
            structureType: world_5.StructureType.NONE,
            tilingBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
        }, exports.spawnPointEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "player",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: aabbs_5.makeAabb(-0.25, -0.25, -0.25, 0.25, 0.5, 0.25),
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            isAffectedByGravity: true,
            mass: 45,
            bounciness: 1 / 64,
            visualRef: playerImgRef,
            maxFlyingForce: 100,
            maxClimbForce: 1000,
            normalWalkingSpeed: 4,
            normalClimbingSpeed: 2,
            climbingSkill: 0.5,
            maxJumpImpulse: 300,
            attachmentZoneClasseRefs: (_a = {},
                _a[leftHandAttachmentZoneKey] = playerHandAttachmentZoneClassRef,
                _a[rightHandAttachmentZoneKey] = playerHandAttachmentZoneClassRef,
                _a
            ),
            maze1InventorySize: 4,
        }, exports.playerEntityClassId);
        var deadPlayerPhysicalBoundingBox = aabbs_5.makeAabb(-0.25, -0.125, -0.25, +0.25, +0.125, +0.25);
        var deadPlayerVisualBoundingBox = aabbs_5.makeAabb(-0.5, -0.5 + 0.125, -0.25, +0.5, +0.125, +0.25);
        gdm.tempStoreObject({
            debugLabel: "dead player",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: deadPlayerPhysicalBoundingBox,
            visualBoundingBox: deadPlayerVisualBoundingBox,
            isSolid: true,
            isAffectedByGravity: true,
            mass: 45,
            bounciness: 1 / 64,
            visualRef: deadPlayerImgRef,
        }, exports.deadPlayerEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "bouncy ball",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: HUNIT_CUBE,
            physicalBoundingBox: HUNIT_CUBE,
            visualBoundingBox: HUNIT_CUBE,
            isSolid: true,
            isAffectedByGravity: true,
            mass: 10,
            bounciness: 1,
            opacity: 0.25,
            visualRef: ballImgRef
        }, exports.ballEntityClassId);
        var platformSegmentBounds = aabbs_5.makeAabb(-0.25, -0.25, -0.5, +0.25, +0.25, +0.5);
        gdm.tempStoreObject({
            debugLabel: "platform segment",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: platformSegmentBounds,
            physicalBoundingBox: platformSegmentBounds,
            visualBoundingBox: platformSegmentBounds,
            isSolid: true,
            mass: 20,
            opacity: 0.5,
            visualRef: platformSegmentImgRef
        }, exports.platformSegmentEntityClassId);
        var platform3Bounds = aabbs_5.makeAabb(-1.5, -0.25, -0.5, +1.5, +0.25, +0.5);
        gdm.tempStoreObject({
            debugLabel: "1.5m-wide platform",
            structureType: world_5.StructureType.TILE_TREE,
            tilingBoundingBox: platform3Bounds,
            physicalBoundingBox: platform3Bounds,
            visualBoundingBox: platform3Bounds,
            xDivisions: 6,
            yDivisions: 1,
            zDivisions: 1,
            opacity: 0.5,
            childEntityPaletteRef: platformEntityPaletteRef,
            childEntityIndexes: [1, 1, 1, 1, 1, 1],
            mass: 120,
            isAffectedByGravity: true,
            normalClimbingSpeed: 4,
            climbingSkill: 15 / 16,
            maxClimbForce: 5000,
        }, exports.platform3EntityClassId);
        var doorSegmentBounds = aabbs_5.makeAabb(-0.25, -0.5, -0.5, +0.25, +0.5, +0.5);
        var doorSegmentVizBounds = aabbs_5.makeAabb(-5 / 16, -0.5, -0.5, +5 / 16, +0.5, +0.5);
        // It is a little wider visually so that it always occludes things!
        gdm.tempStoreObject({
            debugLabel: "door segment",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: doorSegmentBounds,
            physicalBoundingBox: doorSegmentBounds,
            visualBoundingBox: doorSegmentVizBounds,
            isSolid: true,
            mass: 40,
            opacity: 1,
            visualRef: doorSegmentImgRef
        }, exports.doorSegmentEntityClassId);
        var door3Bounds = aabbs_5.makeAabb(-0.25, -1.5, -0.5, +0.25, +1.5, +0.5);
        var door3VisBounds = aabbs_5.makeAabb(-5 / 16, -1.5, -0.5, +5 / 16, +1.5, +0.5);
        gdm.tempStoreObject({
            debugLabel: "3-segment vertical door",
            structureType: world_5.StructureType.TILE_TREE,
            tilingBoundingBox: door3Bounds,
            physicalBoundingBox: door3Bounds,
            visualBoundingBox: door3VisBounds,
            xDivisions: 1,
            yDivisions: 3,
            zDivisions: 1,
            opacity: 1,
            childEntityPaletteRef: doorEntityPaletteRef,
            childEntityIndexes: [1, 1, 1],
            mass: 120,
            isAffectedByGravity: true,
            normalClimbingSpeed: 4,
            maxClimbForce: 3000,
            climbingSkill: 15 / 16,
        }, exports.door3EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "light gray bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: brikImgRef
        }, exports.brikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "brown bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: brownBrikImgRef
        }, exports.brownBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "blue bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: blueBrikImgRef
        }, exports.blueBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "yellow bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: yellowBrikImgRef
        }, exports.yellowBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "red bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: redBrikImgRef
        }, exports.redBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "gray bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: grayBrikImgRef
        }, exports.grayBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "big bricks",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: true,
            opacity: 1,
            visualRef: bigBrikImgRef
        }, exports.bigBrikEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "plant",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: false,
            opacity: 0.25,
            visualRef: plant1ImgRef
        }, exports.plant1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "browning plant",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: false,
            opacity: 0.25,
            visualRef: browningPlant1ImgRef
        }, exports.browningPlant1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "plant",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: false,
            opacity: 0.125,
            visualRef: brownPlant1ImgRef
        }, exports.brownPlant1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "vines",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: false,
            opacity: 3 / 4,
            visualRef: vines1ImgRef
        }, exports.vines1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "browning vines",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: false,
            opacity: 3 / 4,
            visualRef: browningVines1ImgRef
        }, exports.browningVines1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "roots",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            isSolid: false,
            opacity: 1 / 2,
            visualRef: roots1ImgRef
        }, exports.roots1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "door frame",
            structureType: world_5.StructureType.TILE_TREE,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            xDivisions: 4,
            yDivisions: 4,
            zDivisions: 4,
            opacity: 0,
            childEntityPaletteRef: doorFrameBlockEntityPaletteRef,
            childEntityIndexes: doorFrameBlockData
        }, exports.doorFrameEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "ladder (+Z)",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: NORTH_SIDE_BB,
            visualBoundingBox: UNIT_CUBE,
            opacity: 0.125,
            climbability: 0.75,
            isSolid: true,
            visualRef: ladder1FrontImgRef,
        }, exports.backLadderEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "small lattice column",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: HUNIT_CUBE,
            physicalBoundingBox: HUNIT_CUBE,
            visualBoundingBox: HUNIT_CUBE,
            isSolid: true,
            opacity: 1 / 4,
            climbability: 1 / 16,
            visualRef: latticeColumnImgRef
        }, exports.latticeColumnEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "small lattice column block (+x)",
            structureType: world_5.StructureType.TILE_TREE,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            xDivisions: 2,
            yDivisions: 2,
            zDivisions: 2,
            childEntityPaletteRef: worldutil_3.makeTileEntityPaletteRef([null, exports.latticeColumnEntityClassId], gdm),
            childEntityIndexes: [0, 1, 0, 1, 0, 1, 0, 1]
        }, exports.latticeColumnRightBlockEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "small lattice column block (-x)",
            structureType: world_5.StructureType.TILE_TREE,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            xDivisions: 2,
            yDivisions: 2,
            zDivisions: 2,
            childEntityPaletteRef: worldutil_3.makeTileEntityPaletteRef([null, exports.latticeColumnEntityClassId], gdm),
            childEntityIndexes: [1, 0, 1, 0, 1, 0, 1, 0]
        }, exports.latticeColumnLeftBlockEntityClassId);
        var bgLatticeBounds = aabbs_5.makeAabb(-0.25, -0.25, -0.125, +0.25, +0.25, +0.125);
        gdm.tempStoreObject({
            debugLabel: "small lattice column (background)",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: bgLatticeBounds,
            physicalBoundingBox: bgLatticeBounds,
            visualBoundingBox: bgLatticeBounds,
            isSolid: true,
            opacity: 1 / 4,
            climbability: 1 / 16,
            visualRef: latticeColumnBgImgRef
        }, exports.latticeColumnBgEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "small lattice column block (+x)",
            structureType: world_5.StructureType.TILE_TREE,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            xDivisions: 2,
            yDivisions: 2,
            zDivisions: 4,
            childEntityPaletteRef: worldutil_3.makeTileEntityPaletteRef([null, exports.latticeColumnBgEntityClassId], gdm),
            childEntityIndexes: [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1]
        }, exports.latticeColumnBgRightBlockEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "small lattice column block (-x)",
            structureType: world_5.StructureType.TILE_TREE,
            tilingBoundingBox: UNIT_CUBE,
            physicalBoundingBox: UNIT_CUBE,
            visualBoundingBox: UNIT_CUBE,
            xDivisions: 2,
            yDivisions: 2,
            zDivisions: 4,
            childEntityPaletteRef: worldutil_3.makeTileEntityPaletteRef([null, exports.latticeColumnBgEntityClassId], gdm),
            childEntityIndexes: [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0]
        }, exports.latticeColumnBgLeftBlockEntityClassId);
        var keyBoundingBox = aabbs_5.makeAabb(-0.25, -0.125, -0.125, +0.25, +0.125, +0.125);
        var cheapDoorBoundingBox = aabbs_5.makeAabb(-0.25, -0.5, -0.5, +0.25, +0.5, +0.5);
        var keyColors = ["blue", "yellow", "red"];
        var keyClassRefs = [exports.blueKeyEntityClassId, exports.yellowKeyEntityClassId, exports.redKeyEntityClassId];
        var keyVisualRefs = [blueKeyImgRef, yellowKeyImgRef, redKeyImgRef];
        var cheapDoorClassRefs = [exports.cheapBlueDoorEntityClassId, exports.cheapYellowDoorEntityClassId, exports.cheapRedDoorEntityClassId];
        var cheapDoorVisualRefs = [cheapBlueDoorImgRef, cheapYellowDoorImgRef, cheapRedDoorImgRef];
        for (var i = 0; i < keyClassRefs.length; ++i) {
            gdm.tempStoreObject({
                debugLabel: keyColors[i] + " key",
                structureType: world_5.StructureType.INDIVIDUAL,
                tilingBoundingBox: HUNIT_CUBE,
                physicalBoundingBox: keyBoundingBox,
                visualBoundingBox: keyBoundingBox,
                isMaze1AutoPickup: true,
                isAffectedByGravity: true,
                isSolid: true,
                mass: 0.25,
                coefficientOfFriction: 0.65,
                visualRef: keyVisualRefs[i],
                maze1Importance: 2,
            }, keyClassRefs[i]);
            gdm.tempStoreObject({
                debugLabel: "cheap " + keyColors[i] + "-lock door",
                structureType: world_5.StructureType.INDIVIDUAL,
                tilingBoundingBox: HUNIT_CUBE,
                physicalBoundingBox: doorSegmentBounds,
                visualBoundingBox: doorSegmentVizBounds,
                visualRef: cheapDoorVisualRefs[i],
                opacity: 0.5,
                cheapMaze1DoorKeyClassRef: keyClassRefs[i],
            }, cheapDoorClassRefs[i]);
        }
        var triforceBoundingBox = aabbs_5.makeAabb(-8 / 16, -6 / 16, -8 / 16, +8 / 16, +6 / 16, +8 / 16);
        gdm.tempStoreObject({
            debugLabel: "triforce",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: HUNIT_CUBE,
            physicalBoundingBox: triforceBoundingBox,
            visualBoundingBox: triforceBoundingBox,
            isMaze1AutoPickup: true,
            isAffectedByGravity: true,
            isSolid: true,
            mass: 0.25,
            visualRef: triforceImgRef,
            maze1Importance: 3,
        }, exports.triforceEntityClassId);
        gdm.tempStoreObject({
            debugLabel: "apple",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: HUNIT_CUBE,
            physicalBoundingBox: HUNIT_CUBE,
            visualBoundingBox: HUNIT_CUBE,
            isMaze1AutoPickup: true,
            isAffectedByGravity: true,
            isSolid: true,
            mass: 0.25,
            coefficientOfFriction: 0.25,
            visualRef: appleImgRef,
            isMaze1Edible: true,
            maze1NutritionalValue: 10000 // Not realistic!  Realistic value:  397480 joules (95 kilocalories)
        }, exports.appleEntityClassId);
        var stickVisualBoundingBox = aabbs_5.makeAabb(-0.25, -0.25, -0.125, +0.25, +0.125, +0.125);
        var stickPhysicalBoundingBox = aabbs_5.makeAabb(-0.25, -0.125, -0.125, +0.25, +0.125, +0.125);
        gdm.tempStoreObject({
            debugLabel: "stick",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: HUNIT_CUBE,
            physicalBoundingBox: stickPhysicalBoundingBox,
            visualBoundingBox: stickVisualBoundingBox,
            isMaze1AutoPickup: true,
            isAffectedByGravity: true,
            isSolid: true,
            mass: 0.25,
            coefficientOfFriction: 0.75,
            visualRef: stick1ImgRef,
            maze1Importance: 0,
        }, exports.stick1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "stick",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: HUNIT_CUBE,
            physicalBoundingBox: stickPhysicalBoundingBox,
            visualBoundingBox: stickVisualBoundingBox,
            isMaze1AutoPickup: true,
            isAffectedByGravity: true,
            isSolid: true,
            mass: 0.25,
            coefficientOfFriction: 0.75,
            visualRef: stick2ImgRef,
            maze1Importance: 0,
        }, exports.stick2EntityClassId);
        var chunkBb = aabbs_5.makeAabb(-1 / 8, -1 / 16, -1 / 8, +1 / 8, +1 / 16, +1 / 8);
        gdm.tempStoreObject({
            debugLabel: "vomit chunk",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: chunkBb,
            physicalBoundingBox: chunkBb,
            visualBoundingBox: chunkBb,
            isAffectedByGravity: true,
            isSolid: true,
            mass: 1 / 32,
            coefficientOfFriction: 0.75,
            visualRef: vomitChunk1ImgRef,
            isMaze1AutoPickup: true,
            isMaze1Edible: true,
            maze1NutritionalValue: 10
        }, exports.vomitChunk1EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "vomit chunk",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: chunkBb,
            physicalBoundingBox: chunkBb,
            visualBoundingBox: chunkBb,
            isAffectedByGravity: true,
            isSolid: true,
            mass: 1 / 32,
            coefficientOfFriction: 0.75,
            visualRef: vomitChunk2ImgRef,
            isMaze1AutoPickup: true,
            isMaze1Edible: true,
            maze1NutritionalValue: 10
        }, exports.vomitChunk2EntityClassId);
        gdm.tempStoreObject({
            debugLabel: "vomit chunk",
            structureType: world_5.StructureType.INDIVIDUAL,
            tilingBoundingBox: chunkBb,
            physicalBoundingBox: chunkBb,
            visualBoundingBox: chunkBb,
            isAffectedByGravity: true,
            isSolid: true,
            mass: 1 / 32,
            coefficientOfFriction: 0.75,
            visualRef: vomitChunk3ImgRef,
            isMaze1AutoPickup: true,
            isMaze1Edible: true,
            maze1NutritionalValue: 10
        }, exports.vomitChunk3EntityClassId);
        var regularTileEntityPaletteRef = worldutil_3.makeTileEntityPaletteRef([
            null,
            exports.brikEntityClassId,
            exports.bigBrikEntityClassId,
            exports.plant1EntityClassId,
            /* 4: */ exports.doorFrameEntityClassId,
            /* 5: */ exports.backLadderEntityClassId,
            /* 6: */ gdm.tempStoreObject({
                debugLabel: "ladder (+X)",
                structureType: world_5.StructureType.INDIVIDUAL,
                tilingBoundingBox: UNIT_CUBE,
                physicalBoundingBox: EAST_SIDE_BB,
                visualBoundingBox: EAST_SIDE_BB,
                opacity: 0.125,
                climbability: 0.75,
                isSolid: true,
                visualRef: ladder1SideImgRef,
            }),
            /* 7: */ gdm.tempStoreObject({
                debugLabel: "ladder (-X)",
                structureType: world_5.StructureType.INDIVIDUAL,
                tilingBoundingBox: UNIT_CUBE,
                physicalBoundingBox: WEST_SIDE_BB,
                visualBoundingBox: WEST_SIDE_BB,
                opacity: 0.125,
                climbability: 0.75,
                isSolid: true,
                visualRef: ladder1SideImgRef,
            }),
            /* 8 */ exports.vines1EntityClassId,
            /* 9: */ gdm.tempStoreObject({
                debugLabel: "ladder (-Y)",
                structureType: world_5.StructureType.INDIVIDUAL,
                tilingBoundingBox: UNIT_CUBE,
                physicalBoundingBox: TOP_SIDE_BB,
                visualBoundingBox: TOP_SIDE_BB,
                opacity: 0.125,
                climbability: 0.75,
                isSolid: true,
                visualRef: ladder1TopImgRef,
            }),
            /* 10 */ exports.latticeColumnRightBlockEntityClassId,
            /* 11 */ exports.latticeColumnLeftBlockEntityClassId,
            /* 12 */ exports.latticeColumnBgRightBlockEntityClassId,
            /* 13 */ exports.latticeColumnBgLeftBlockEntityClassId,
            /* 14 */ exports.brownBrikEntityClassId,
            /* 15 */ exports.blueBrikEntityClassId,
            /* 16 */ exports.cheapBlueDoorEntityClassId,
            /* 17 */ exports.cheapYellowDoorEntityClassId,
            /* 18 */ exports.cheapRedDoorEntityClassId,
            /* 19 */ exports.yellowBrikEntityClassId,
            /* 20 */ exports.redBrikEntityClassId,
            /* 21 */ exports.grayBrikEntityClassId,
            /* 22 */ exports.bigBlueBrikEntityClassId,
            /* 23 */ exports.bigYellowBrikEntityClassId,
            /* 24 */ exports.bigRedBrikEntityClassId,
            /* 25 */ exports.browningPlant1EntityClassId,
            /* 26 */ exports.brownPlant1EntityClassId,
            /* 27 */ exports.browningVines1EntityClassId,
            /* 28 */ exports.roots1EntityClassId,
            /* 29 */ exports.tanRox1EntityClassId,
        ], gdm, exports.tileEntityPaletteId);
        // do this as second step because we need to reference that tile tree palette by ID
        var roomBounds = aabbs_5.makeAabb(-8, -8, -0.5, 8, 8, 0.5);
        gdm.tempStoreObject({
            bounds: roomBounds,
            roomEntities: (_b = {},
                _b[exports.playerEntityId] = {
                    position: vector3ds_14.makeVector(-4.5, -2.5, 0),
                    entity: {
                        id: exports.playerEntityId,
                        classRef: exports.playerEntityClassId,
                        desiresMaze1AutoActivation: true,
                    },
                },
                _b[exports.blueKeyEntityId] = {
                    position: vector3ds_14.makeVector(-3.5, -1.5, 0),
                    entity: {
                        classRef: exports.blueKeyEntityClassId
                    }
                },
                _b['the-triforce'] = {
                    position: vector3ds_14.makeVector(-2.5, -1.5, 0),
                    entity: {
                        classRef: exports.triforceEntityClassId
                    }
                },
                _b[room1TileTreeId] = {
                    position: vector3ds_14.makeVector(0, 0, 0),
                    entity: {
                        classRef: worldutil_3.makeTileTreeRef(regularTileEntityPaletteRef, 16, 16, 1, room1Data, gdm, { infiniteMass: true })
                    }
                },
                _b[exports.ballEntityId] = {
                    position: vector3ds_14.makeVector(-2.5, -3.5, 0),
                    entity: {
                        classRef: exports.ballEntityClassId
                    }
                },
                _b[exports.yellowKeyEntityId] = {
                    position: vector3ds_14.makeVector(-1.5, -3.5, 0),
                    entity: {
                        classRef: exports.yellowKeyEntityClassId
                    }
                },
                _b[exports.platformEntityId] = {
                    position: vector3ds_14.makeVector(6, 0, 0),
                    entity: {
                        classRef: exports.platform3EntityClassId,
                        desiredMovementDirection: vector3ds_14.makeVector(0, -1.0, 0),
                    }
                },
                _b
            ),
            neighbors: {
                "w": {
                    offset: vector3ds_14.makeVector(-16, 0, 0),
                    bounds: roomBounds,
                    roomRef: exports.room2Id
                },
                "e": {
                    offset: vector3ds_14.makeVector(+16, 0, 0),
                    bounds: roomBounds,
                    roomRef: exports.room2Id
                },
                "n": {
                    offset: vector3ds_14.makeVector(0, -16, 0),
                    bounds: roomBounds,
                    roomRef: exports.room3Id,
                },
                "2": {
                    offset: vector3ds_14.makeVector(0, +16, 0),
                    bounds: roomBounds,
                    roomRef: exports.room3Id,
                },
            }
        }, exports.room1Id);
        gdm.tempStoreObject({
            bounds: roomBounds,
            roomEntities: (_c = {},
                _c[room2TileTreeId] = {
                    position: vector3ds_14.makeVector(0, 0, 0),
                    entity: {
                        classRef: worldutil_3.makeTileTreeRef(regularTileEntityPaletteRef, 16, 16, 1, room2Data, gdm, { infiniteMass: true })
                    }
                },
                _c[exports.door3EntityId] = {
                    position: vector3ds_14.makeVector(-1.5, +1.5, 0),
                    entity: {
                        classRef: exports.door3EntityClassId
                    }
                },
                _c
            ),
            neighbors: {
                "w": {
                    offset: vector3ds_14.makeVector(-16, 0, 0),
                    bounds: roomBounds,
                    roomRef: exports.room1Id
                },
                "e": {
                    offset: vector3ds_14.makeVector(+16, 0, 0),
                    bounds: roomBounds,
                    roomRef: exports.room1Id
                },
            }
        }, exports.room2Id);
        gdm.tempStoreObject({
            bounds: roomBounds,
            roomEntities: (_d = {},
                _d[room3TileTreeId] = {
                    position: vector3ds_14.makeVector(0, 0, 0),
                    entity: {
                        classRef: worldutil_3.makeTileTreeRef(regularTileEntityPaletteRef, 16, 16, 1, room3Data, gdm, { infiniteMass: true })
                    }
                },
                _d
            ),
            neighbors: {
                "n": {
                    offset: vector3ds_14.makeVector(0, -16, 0),
                    bounds: roomBounds,
                    roomRef: exports.room1Id,
                },
                "s": {
                    offset: vector3ds_14.makeVector(0, +16, 0),
                    bounds: roomBounds,
                    roomRef: exports.room1Id,
                },
            }
        }, exports.room3Id);
        return Promise.resolve();
        var _a, _b, _c, _d;
    }
    exports.initData = initData;
    if (typeof require != 'undefined' && typeof module != 'undefined' && require.main === module) {
        var dataIdent = index_8.sha1Urn;
        var ds = HTTPHashDatastore_3.default.createDefault();
        var gdm_1 = new GameDataManager_2.default(ds);
        initData(gdm_1).then(function () { return gdm_1.flushUpdates(); }).then(function (rootNodeUri) {
            var saveGame = {
                gameDataRef: rootNodeUri,
                rootRoomId: exports.room1Id,
                playerId: exports.playerEntityId
            };
            return gdm_1.storeObject(saveGame).then(function (saveRef) {
                console.log(saveRef);
            });
        }).catch(function (err) {
            console.error("Error generating initial savegame", err);
        });
    }
    var _a;
});
define("togos-game21/images", ["require", "exports"], function (require, exports) {
    "use strict";
    exports.EMPTY_IMAGE_URL = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
    function imageFromUrl(srcRef) {
        var img = document.createElement('img');
        img.src = srcRef;
        return img;
    }
    exports.imageFromUrl = imageFromUrl;
    exports.EMPTY_IMAGE = imageFromUrl(exports.EMPTY_IMAGE_URL);
    exports.EMPTY_IMAGE_SLICE = {
        bounds: {
            minX: 0, minY: 0, minZ: 0,
            maxX: 1, maxY: 1, maxZ: 0,
        },
        origin: { x: 0, y: 0, z: 0 },
        sheetRef: exports.EMPTY_IMAGE_URL,
        sheet: exports.EMPTY_IMAGE
    };
    var _a;
});
define("togos-game21/tiletrees", ["require", "exports", "togos-game21/DeepFreezer", "togos-game21/Quaternion", "togos-game21/vector3ds", "togos-game21/aabbs", "togos-game21/world"], function (require, exports, DeepFreezer_17, Quaternion_4, vector3ds_15, aabbs_6, world_6) {
    "use strict";
    var TileEntityPaletteManager = (function () {
        function TileEntityPaletteManager(paletteRef, gdm) {
            this.gdm = gdm;
            this._paletteRef = paletteRef;
        }
        Object.defineProperty(TileEntityPaletteManager.prototype, "palette", {
            get: function () {
                if (this._palette == null) {
                    if (this._paletteRef == null)
                        throw new Error("Can't fetch palette without ref!");
                    this._palette = this.gdm.getObject(this._paletteRef);
                }
                return this._palette;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TileEntityPaletteManager.prototype, "paletteRef", {
            get: function () {
                if (this._paletteRef == null) {
                    if (this._palette == null)
                        throw new Error("Can't calculate palette ref without palette!");
                    Object.freeze(this._palette);
                    this._paletteRef = this.gdm.tempStoreObject(this._palette);
                }
                return this._paletteRef;
            },
            enumerable: true,
            configurable: true
        });
        TileEntityPaletteManager.prototype.addTileEntity = function (te) {
            var pal = this.palette;
            this._paletteRef = undefined;
            if (Object.isFrozen(pal)) {
                var newPal = new Array(pal.length);
                for (var i = 0; i < pal.length; ++i)
                    newPal[i] = pal[i];
                pal = newPal;
            }
            pal.push(te);
            this._palette = pal;
            return pal.length - 1;
        };
        // TODO: Not obvious that this adds new ones when not found; maybe make 'addIfNotFound:boolean=false' parameter.
        TileEntityPaletteManager.prototype.findTileEntity = function (te) {
            var pal = this.palette;
            for (var i = 0; i < pal.length; ++i) {
                var palE = pal[i];
                if (te == null && palE == null)
                    return i;
                if (te != null && palE != null) {
                    if (palE.entity.classRef == te.entity.classRef) {
                        // Good enough for now; we'll ignore other properties
                        return i;
                    }
                }
            }
            return this.addTileEntity(te);
        };
        return TileEntityPaletteManager;
    }());
    var ttRewritePos = vector3ds_15.makeVector();
    var ttRewriteAabb = aabbs_6.makeAabb(0, 0, 0, 0, 0, 0);
    function rewriteTileTree(ttPos, ttRef, rewrite, gdm) {
        // Eventually should define rewrite function to allow returning
        // new TileEntity and create a new palette if needed.
        var entityClass = gdm.getEntityClass(ttRef);
        if (entityClass.structureType != world_6.StructureType.TILE_TREE) {
            throw new Error("Can't rewrite " + entityClass + "; not a tile tree!");
        }
        var tt = entityClass;
        var tepm = new TileEntityPaletteManager(tt.childEntityPaletteRef, gdm);
        var ttBb = tt.tilingBoundingBox;
        var pal = tepm.palette;
        var cellWidth = aabbs_6.aabbWidth(ttBb) / tt.xDivisions;
        var cellHeight = aabbs_6.aabbHeight(ttBb) / tt.yDivisions;
        var cellDepth = aabbs_6.aabbDepth(ttBb) / tt.zDivisions;
        aabbs_6.setAabb(ttRewriteAabb, -cellWidth / 2, -cellHeight / 2, -cellDepth / 2, +cellWidth / 2, +cellHeight / 2, +cellDepth / 2);
        var minX = ttPos.x + ttBb.minX, minY = ttPos.y + ttBb.minY, minZ = ttPos.z + ttBb.minZ;
        var indexes = tt.childEntityIndexes;
        var newIndexes = indexes;
        for (var i = 0, z = 0; z < tt.zDivisions; ++z) {
            for (var y = 0; y < tt.yDivisions; ++y) {
                for (var x = 0; x < tt.xDivisions; ++x, ++i) {
                    var tileIndex = indexes[i];
                    vector3ds_15.setVector(ttRewritePos, minX + (x + 0.5) * cellWidth, minY + (y + 0.5) * cellHeight, minZ + (z + 0.5) * cellDepth);
                    /*
                    setAabb(ttRewriteAabb,
                        minX+    x*cellWidth, minY+    y*cellHeight, minZ+    z*cellDepth,
                        minX+(x+1)*cellWidth, minY+(y+1)*cellHeight, minZ+(z+1)*cellDepth);
                        */
                    var newIndex = rewrite(ttRewritePos, ttRewriteAabb, tileIndex, pal[tileIndex]);
                    if (typeof newIndex == 'string') {
                        newIndex = tepm.findTileEntity({ entity: { classRef: newIndex }, orientation: Quaternion_4.default.IDENTITY });
                    }
                    else if (typeof newIndex == 'object') {
                        newIndex = tepm.findTileEntity(newIndex);
                    }
                    // TODO: some special value to indicate 'recurse'
                    if (typeof newIndex != 'number') {
                        throw new Error('non-number return value from rewrite function not yet supported');
                    }
                    if (newIndex != tileIndex) {
                        if (newIndexes === indexes) {
                            // Clone it
                            var size = tt.xDivisions * tt.yDivisions * tt.zDivisions;
                            newIndexes = new Array(size);
                            for (var j = 0; j < size; ++j)
                                newIndexes[j] = indexes[j];
                        }
                        newIndexes[i] = newIndex;
                    }
                }
            }
        }
        if (newIndexes === indexes) {
            return ttRef;
        }
        else {
            var newTt = DeepFreezer_17.clone(tt);
            newTt.childEntityIndexes = newIndexes;
            newTt.childEntityPaletteRef = tepm.paletteRef;
            return gdm.tempStoreObject(newTt);
        }
    }
    exports.rewriteTileTree = rewriteTileTree;
    var _a;
});
define("togos-game21/MultiLogger", ["require", "exports"], function (require, exports) {
    "use strict";
    var MultiConsole = (function () {
        function MultiConsole(backends) {
            this.backends = backends;
        }
        MultiConsole.prototype.log = function (message) {
            var optionalParams = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                optionalParams[_i - 1] = arguments[_i];
            }
            for (var b in this.backends)
                (_a = this.backends[b]).log.apply(_a, [message].concat(optionalParams));
            var _a;
        };
        MultiConsole.prototype.warn = function (message) {
            var optionalParams = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                optionalParams[_i - 1] = arguments[_i];
            }
            for (var b in this.backends)
                (_a = this.backends[b]).warn.apply(_a, [message].concat(optionalParams));
            var _a;
        };
        MultiConsole.prototype.debug = function (message) {
            var optionalParams = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                optionalParams[_i - 1] = arguments[_i];
            }
            for (var b in this.backends)
                (_a = this.backends[b]).debug.apply(_a, [message].concat(optionalParams));
            var _a;
        };
        MultiConsole.prototype.error = function (message) {
            var optionalParams = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                optionalParams[_i - 1] = arguments[_i];
            }
            for (var b in this.backends)
                (_a = this.backends[b]).error.apply(_a, [message].concat(optionalParams));
            var _a;
        };
        return MultiConsole;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = MultiConsole;
    var _a;
});
define("togos-game21/ui/DOMLogger", ["require", "exports"], function (require, exports) {
    "use strict";
    function logStringify(thing) {
        if (typeof (thing) == 'string')
            return thing;
        if (typeof (thing) == 'number')
            return "" + thing;
        if (typeof (thing) == 'boolean')
            return thing ? 'true' : 'false';
        if (typeof (thing) == 'undefined')
            return 'undefined';
        if (typeof (thing) == 'null')
            return 'null';
        return JSON.stringify(thing, null, "\t");
    }
    var DOMLogger = (function () {
        function DOMLogger(outputElem) {
            this.outputElement = outputElem;
            this.document = outputElem.ownerDocument;
        }
        DOMLogger.prototype.append = function (elem) {
            var wasAtBottom = this.outputElement.scrollTop == (this.outputElement.scrollHeight - this.outputElement.clientHeight);
            this.outputElement.appendChild(elem);
            if (wasAtBottom) {
                this.outputElement.scrollTop = this.outputElement.scrollHeight - this.outputElement.clientHeight;
            }
        };
        DOMLogger.prototype.printLine = function (fh, text) {
            var line = this.document.createElement('p');
            line.appendChild(document.createTextNode(text));
            this.append(line);
        };
        DOMLogger.prototype._log = function (className) {
            var stuff = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                stuff[_i - 1] = arguments[_i];
            }
            var eventElement = this.document.createElement('p');
            eventElement.className = className;
            var texts = [];
            var first = true;
            for (var t in stuff) {
                if (!first) {
                    eventElement.appendChild(document.createTextNode(" "));
                }
                var fragElems = void 0;
                if (this.fragReplacer) {
                    fragElems = this.fragReplacer(stuff[t]);
                }
                if (fragElems == null) {
                    var fragElem = this.document.createElement('span');
                    fragElem.appendChild(this.document.createTextNode(logStringify(stuff[t])));
                    fragElems = [fragElem];
                }
                for (var e in fragElems) {
                    eventElement.appendChild(fragElems[e]);
                }
                first = false;
            }
            this.append(eventElement);
        };
        // TODO: make diff colors or classes something
        DOMLogger.prototype.log = function () {
            var stuff = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                stuff[_i - 0] = arguments[_i];
            }
            this._log.apply(this, ["log"].concat(stuff));
        };
        DOMLogger.prototype.error = function () {
            var stuff = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                stuff[_i - 0] = arguments[_i];
            }
            this._log.apply(this, ["error"].concat(stuff));
        };
        DOMLogger.prototype.warn = function () {
            var stuff = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                stuff[_i - 0] = arguments[_i];
            }
            this._log.apply(this, ["warning"].concat(stuff));
        };
        DOMLogger.prototype.debug = function () {
            var stuff = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                stuff[_i - 0] = arguments[_i];
            }
            this._log.apply(this, ["debug"].concat(stuff));
        };
        return DOMLogger;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = DOMLogger;
    var _a;
});
define("togos-game21/ui/TilePalette", ["require", "exports", "togos-game21/Quaternion"], function (require, exports, Quaternion_5) {
    "use strict";
    var TilePalette = (function () {
        function TilePalette(slotCount, _renderer) {
            var _this = this;
            this._renderer = _renderer;
            this._selectedSlotIndex = 0;
            this.selectListeners = [];
            this.tileEntities = new Array(slotCount);
            this.imageUrls = new Array(slotCount);
            this.imageUrlPromises = new Array(slotCount);
            this.tileElements = new Array(slotCount);
            var tab = this._element = document.createElement('ul');
            tab.className = "tile-palette";
            var _loop_5 = function(i) {
                var li = this_3.tileElements[i] = document.createElement('li');
                if (i == this_3._selectedSlotIndex)
                    li.className = "selected";
                var label = document.createTextNode("" + i);
                li.appendChild(label);
                var _i = i;
                li.addEventListener('click', function (evt) {
                    _this.selectSlot(_i);
                });
                tab.appendChild(li);
            };
            var this_3 = this;
            for (var i = 0; i < this.tileEntities.length; ++i) {
                _loop_5(i);
            }
        }
        Object.defineProperty(TilePalette.prototype, "element", {
            get: function () { return this._element; },
            enumerable: true,
            configurable: true
        });
        TilePalette.prototype.renderSlot = function (index) {
            var _this = this;
            var tileEntity = this.tileEntities[index];
            if (tileEntity == null) {
                this.imageUrls[index] = null;
                this.imageUrls[index] = null;
                this.tileElements[index].style.backgroundImage = null;
            }
            else if (this._renderer) {
                var renderP_1 = this._renderer(tileEntity.entity, tileEntity.orientation);
                this.imageUrlPromises[index] = renderP_1;
                renderP_1.then(function (url) {
                    if (_this.imageUrlPromises[index] === renderP_1) {
                        _this.imageUrls[index] = url;
                        _this.tileElements[index].style.backgroundImage = url ? "url('" + url + "')" : null;
                    }
                }, function (err) {
                    console.error("Failed to render entity for slot " + index + ", class = " + tileEntity.entity.classRef + ";", err);
                    _this.imageUrls[index] = null;
                    _this.tileElements[index].style.background = "red";
                });
            }
            else {
                console.warn("Can't render tiles; no renderer configured on tile palette");
            }
        };
        TilePalette.prototype.setSlot = function (index, _entity) {
            if (_entity === null)
                _entity = undefined;
            if (typeof _entity == 'string') {
                _entity = {
                    entity: { classRef: _entity },
                    orientation: Quaternion_5.default.IDENTITY
                };
            }
            var tileEntity = _entity;
            if (tileEntity == null) {
                this.tileEntities[index] = undefined;
                this.renderSlot(index);
                this.imageUrlPromises[index] = undefined;
            }
            else if (JSON.stringify(tileEntity) != JSON.stringify(this.tileEntities[index])) {
                this.tileEntities[index] = tileEntity;
                this.imageUrls[index] = null;
                this.renderSlot(index);
            }
            this.triggerSelectListeners();
        };
        TilePalette.prototype.setAllSlots = function (entities) {
            for (var i = 0; i < this.tileEntities.length; ++i) {
                this.setSlot(i, entities[i]);
            }
        };
        TilePalette.prototype.triggerSelectListeners = function () {
            for (var t in this.selectListeners) {
                this.selectListeners[t](this._selectedSlotIndex, this.tileEntities[this._selectedSlotIndex] || null);
            }
        };
        Object.defineProperty(TilePalette.prototype, "selectedSlotIndex", {
            get: function () { return this._selectedSlotIndex; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TilePalette.prototype, "selectedItem", {
            get: function () {
                return this.tileEntities[this._selectedSlotIndex];
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TilePalette.prototype, "selectedItemKey", {
            get: function () {
                var item = this.selectedItem;
                return (item == null) ? undefined : item.key;
            },
            enumerable: true,
            configurable: true
        });
        TilePalette.prototype.selectSlot = function (index) {
            if (index == this._selectedSlotIndex)
                return;
            this.tileElements[this._selectedSlotIndex].className = '';
            this.tileElements[index].className = 'selected';
            this._selectedSlotIndex = index;
            this.triggerSelectListeners();
        };
        TilePalette.prototype.on = function (event, then) {
            this.selectListeners.push(then);
        };
        Object.defineProperty(TilePalette.prototype, "entityRenderer", {
            set: function (renderer) {
                this._renderer = renderer;
                this.rerenderAll();
            },
            enumerable: true,
            configurable: true
        });
        TilePalette.prototype.rerenderAll = function () {
            for (var i = 0; i < this.tileEntities.length; ++i) {
                this.renderSlot(i);
            }
        };
        return TilePalette;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = TilePalette;
    var _a;
});
define("togos-game21/ui/inventory", ["require", "exports"], function (require, exports) {
    "use strict";
    function emptyElement(e) {
        while (e.firstChild)
            e.removeChild(e.firstChild);
    }
    var StorageCompartmentContentUI = (function () {
        function StorageCompartmentContentUI(ctx) {
            this._items = [];
            this._itemRenderPromises = [];
            this._itemElements = [];
            if (ctx)
                this._entityRenderer = ctx.entityRenderer;
        }
        Object.defineProperty(StorageCompartmentContentUI.prototype, "element", {
            get: function () {
                if (this._element == null)
                    this._element = this.createElement();
                return this._element;
            },
            enumerable: true,
            configurable: true
        });
        StorageCompartmentContentUI.prototype.createElement = function () {
            var elem = document.createElement('div');
            elem.className = 'storage-compartment-content';
            return elem;
        };
        StorageCompartmentContentUI.prototype.rebuildUi = function () {
            this._itemElements = [];
            var elem = this.element;
            var items = this._items;
            while (elem.firstChild)
                elem.removeChild(elem.firstChild);
            for (var _i = 0; _i < this._items.length; ++_i) {
                var i = _i;
                var itemElement = document.createElement('div');
                itemElement.dataset["itemIndex"] = "" + i;
                if (i == this._selectedItemIndex) {
                    itemElement.classList.add("selected");
                }
                this._itemElements.push(itemElement);
                elem.appendChild(itemElement);
            }
            this.renderItems;
        };
        StorageCompartmentContentUI.prototype.renderItems = function () {
            var _this = this;
            var elem = this._element;
            var items = this._items;
            var itemElements = this._itemElements;
            this._itemRenderPromises = [];
            var rend = this._entityRenderer;
            var _loop_6 = function(_i) {
                var i = _i;
                var item = items[i];
                var itemElement = itemElements[i];
                if (!item || !rend) {
                    itemElement.style.backgroundImage = '';
                }
                else {
                    var renderPromise_1 = rend(item);
                    this_4._itemRenderPromises.push(renderPromise_1);
                    renderPromise_1.then(function (slice) {
                        if (_this._itemRenderPromises[i] !== renderPromise_1)
                            return;
                        itemElement.style.backgroundImage = 'url("' + slice.sheetRef + '")';
                    }, function (err) {
                        if (_this._itemRenderPromises[i] !== renderPromise_1)
                            return;
                        itemElement.style.backgroundImage = 'red';
                        console.error("Error rendering tile palette item " + i + ":", err);
                    });
                }
            };
            var this_4 = this;
            for (var _i = 0; _i < items.length; ++_i) {
                _loop_6(_i);
            }
        };
        StorageCompartmentContentUI.prototype.setState = function (items, selectedItemIndex) {
            this._selectedItemIndex = selectedItemIndex;
            // Can skip the set selectedItemIndex stuff since rebuilding will take it care of
            this.items = items;
        };
        Object.defineProperty(StorageCompartmentContentUI.prototype, "items", {
            set: function (items) {
                this._items = items;
                this.rebuildUi();
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(StorageCompartmentContentUI.prototype, "entityRenderer", {
            set: function (renderer) {
                this._entityRenderer = renderer;
                this.renderItems();
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(StorageCompartmentContentUI.prototype, "uiContext", {
            set: function (ctx) {
                this.entityRenderer = ctx.entityRenderer;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(StorageCompartmentContentUI.prototype, "selectedItemIndex", {
            set: function (index) {
                if (this._selectedItemIndex == index)
                    return;
                if (this._selectedItemIndex != null && this._itemElements[this._selectedItemIndex]) {
                    this._itemElements[this._selectedItemIndex].classList.remove("selected");
                }
                this._selectedItemIndex = index;
                if (index != null && this._itemElements[index]) {
                    this._itemElements[index].classList.add("selected");
                }
            },
            enumerable: true,
            configurable: true
        });
        return StorageCompartmentContentUI;
    }());
    exports.StorageCompartmentContentUI = StorageCompartmentContentUI;
    var EntityInventoryUI = (function () {
        function EntityInventoryUI(ctx) {
            this._uiContext = ctx;
        }
        Object.defineProperty(EntityInventoryUI.prototype, "chain", {
            set: function (c) {
                // TODO: build the UI
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(EntityInventoryUI.prototype, "chainTail", {
            get: function () {
                return null;
            },
            enumerable: true,
            configurable: true
        });
        return EntityInventoryUI;
    }());
    exports.EntityInventoryUI = EntityInventoryUI;
    /**
     * UI component for a single root entity,
     * which includes sub-item ineventories
     */
    var InventoryRowUI = (function () {
        function InventoryRowUI(ctx) {
            this._entityInventoryUis = [];
            this._uiContext = ctx;
        }
        InventoryRowUI.prototype.createElement = function () {
            var elem = document.createElement('div');
            elem.className = 'inventory';
            return elem;
        };
        Object.defineProperty(InventoryRowUI.prototype, "element", {
            get: function () {
                if (this._element == null)
                    this._element = this.createElement();
                return this._element;
            },
            enumerable: true,
            configurable: true
        });
        InventoryRowUI.prototype.rebuildUi = function () {
            emptyElement(this._element);
            this._entityInventoryUis = [];
            var chain = this._chain;
            while (chain) {
                var eiui = new EntityInventoryUI(this._uiContext);
                this._entityInventoryUis.push(eiui);
                chain = eiui.chainTail;
            }
        };
        Object.defineProperty(InventoryRowUI.prototype, "chain", {
            set: function (chain) {
                this._chain = chain;
                this.rebuildUi();
            },
            enumerable: true,
            configurable: true
        });
        return InventoryRowUI;
    }());
    exports.InventoryRowUI = InventoryRowUI;
    /**
     * Encapsulates several inventory row UIs, each for a different root entity
     */
    var InventoryUI = (function () {
        function InventoryUI() {
            this._chains = [];
            this._rootEntityRowUis = [];
            this._rootEntityElements = [];
        }
        InventoryUI.prototype.createElement = function () {
            var elem = document.createElement('div');
            elem.className = 'inventory';
            return elem;
        };
        Object.defineProperty(InventoryUI.prototype, "element", {
            get: function () {
                if (this._element == null)
                    this._element = this.createElement();
                return this._element;
            },
            enumerable: true,
            configurable: true
        });
        InventoryUI.prototype.rebuildUi = function () {
            this._rootEntityRowUis = [];
            var rootElem = this.element;
            emptyElement(rootElem);
            for (var _i in this._chains) {
                var rowUi = new InventoryRowUI(this._uiContext);
                rowUi.chain = this._chains[_i];
                this._rootEntityRowUis.push(rowUi);
                rootElem.appendChild(rowUi.element);
            }
        };
        Object.defineProperty(InventoryUI.prototype, "uiContext", {
            set: function (ctx) {
                this._uiContext = ctx;
                this.rebuildUi();
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(InventoryUI.prototype, "chains", {
            set: function (chains) {
                this._chains = chains;
                this.rebuildUi(); // Eventually only rebuild the changed parts!
            },
            enumerable: true,
            configurable: true
        });
        return InventoryUI;
    }());
    exports.InventoryUI = InventoryUI;
    var _a;
});
define("togos-game21/ui/SoundPlayer", ["require", "exports"], function (require, exports) {
    "use strict";
    var SoundPlayer = (function () {
        function SoundPlayer(datastore, auctx) {
            this.datastore = datastore;
            this.loadedSounds = {};
            this.loadingSounds = {};
            if (auctx == undefined) {
                if (typeof AudioContext != 'undefined') {
                    auctx = new AudioContext();
                }
            }
            this.auctx = auctx;
        }
        SoundPlayer.prototype.playSound = function (buf, volume) {
            if (this.auctx) {
                if (volume == undefined)
                    volume = 1;
                var source = this.auctx.createBufferSource();
                source.buffer = buf;
                var gain = this.auctx.createGain();
                gain.gain.value = volume;
                source.connect(gain);
                gain.connect(this.auctx.destination);
                source.start();
            }
        };
        SoundPlayer.prototype.preloadSound = function (soundRef) {
            var _this = this;
            var auctx = this.auctx;
            if (auctx == undefined)
                return;
            if (this.loadingSounds[soundRef])
                return;
            this.loadingSounds[soundRef] = true;
            this.datastore.fetch(soundRef).then(function (buffer) {
                auctx.decodeAudioData(buffer.buffer).then(function (aubuf) {
                    _this.loadedSounds[soundRef] = aubuf;
                    delete _this.loadingSounds[soundRef];
                }, function (err) {
                    console.error("Failed to load " + soundRef, err);
                });
            });
        };
        SoundPlayer.prototype.playSoundByRef = function (soundRef, volume) {
            if (!this.auctx)
                return;
            if (this.loadedSounds[soundRef]) {
                this.playSound(this.loadedSounds[soundRef], volume);
            }
            else {
                console.error("Can't play sound " + soundRef + "; not loaded");
            }
        };
        return SoundPlayer;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = SoundPlayer;
    var _a;
});
define("togos-game21/graphmaze", ["require", "exports"], function (require, exports) {
    "use strict";
    exports.ITEMCLASS_START = 'start';
    exports.ITEMCLASS_END = 'end';
    exports.ITEMCLASS_BLUEKEY = 'blueKey';
    exports.ITEMCLASS_YELLOWKEY = 'yellowKey';
    exports.ITEMCLASS_REDKEY = 'redKey';
    exports.DEFAULT_LINK_ATTRIBUTES = {
        locks: {},
        allowsForwardMovement: true,
        allowsBackwardMovement: true,
    };
    var _a;
});
define("togos-game21/graphmaze/setutil", ["require", "exports"], function (require, exports) {
    "use strict";
    function union(a, b) {
        var aIsComplete = true;
        var bIsComplete = true;
        for (var k in a)
            if (!b[k])
                bIsComplete = false;
        if (bIsComplete)
            return b;
        for (var k in b)
            if (!a[k])
                aIsComplete = false;
        if (aIsComplete)
            return a;
        var union = {};
        for (var k in a)
            union[k] = a[k];
        for (var k in b)
            union[k] = b[k];
        return union;
    }
    exports.union = union;
    function isSubset(a, b) {
        for (var k in a)
            if (!b[k])
                return false;
        return true;
    }
    exports.isSubset = isSubset;
    function isSameSet(a, b) {
        return isSubset(a, b) && isSubset(b, a);
    }
    exports.isSameSet = isSameSet;
    function difference(a, b) {
        var diff = {};
        for (var k in a)
            if (!b[k])
                diff[k] = a[k];
        return diff;
    }
    exports.difference = difference;
    function symmetricDifference(a, b) {
        var diff = {};
        for (var k in a)
            if (!b[k])
                diff[k] = a[k];
        for (var k in b)
            if (!a[k])
                diff[k] = b[k];
        return diff;
    }
    exports.symmetricDifference = symmetricDifference;
    function isEmpty(t) {
        for (var i in t)
            return false;
        return true;
    }
    exports.isEmpty = isEmpty;
    var _a;
});
/// <reference path="../../node.d.ts"/>
define("togos-game21/graphmaze/GraphMazeGenerator2", ["require", "exports", "togos-game21/graphmaze/setutil", "togos-game21/graphmaze/picking", "togos-game21/graphmaze"], function (require, exports, setutil_1, picking_1, graphmaze_1) {
    "use strict";
    function pickOne(coll, fitnessFunction, resultDescription) {
        if (fitnessFunction === void 0) { fitnessFunction = picking_1.EVERYTHING_FITS; }
        if (resultDescription === void 0) { resultDescription = "item"; }
        if (coll.length == 0)
            throw new Error("Can't pick " + resultDescription + " from zero-length collection");
        var startIdx = Math.floor(Math.random() * coll.length);
        for (var i = 0; i < coll.length; ++i) {
            // TODO: This is biased towards finding the first fitting node after a series of unfit ones
            var idx = (i + startIdx) % coll.length;
            if (fitnessFunction(coll[idx]) > 0)
                return coll[idx];
        }
        throw new Error("No fit items in collection");
    }
    var MazeGenerator = (function () {
        function MazeGenerator() {
            this.generatorName = "xxx";
            this.targetNodeCount = 32;
            this.nodes = [];
            this.links = [];
            this.currentNodeCollection = [];
            this.requireKeys = [];
            this.complectificationFactor = 1 / 2;
        }
        Object.defineProperty(MazeGenerator.prototype, "selectedNode", {
            get: function () {
                if (this._selectedNode == undefined)
                    throw new Error("No selected node!");
                return this._selectedNode;
            },
            enumerable: true,
            configurable: true
        });
        MazeGenerator.prototype.newCollection = function () {
            this.currentNodeCollection = [];
            return this.currentNodeCollection;
        };
        MazeGenerator.prototype.flushCollection = function () {
            var c = this.currentNodeCollection;
            this.newCollection();
            return c;
        };
        MazeGenerator.prototype.newNode = function () {
            var n = {
                id: this.nodes.length,
                linkIds: [],
                requiredKeys: {},
                items: {}
            };
            this.nodes.push(n);
            this.currentNodeCollection.push(n);
            this._selectedNode = n;
            return n;
        };
        MazeGenerator.prototype.createStartNode = function () {
            var n = this.newNode();
            n.items[graphmaze_1.ITEMCLASS_START] = graphmaze_1.ITEMCLASS_START;
            this.startNode = n;
            return n;
        };
        MazeGenerator.prototype.randomNode = function (collection, fitnessfunction, resultDescription) {
            if (collection === void 0) { collection = this.nodes; }
            if (fitnessfunction === void 0) { fitnessfunction = picking_1.EVERYTHING_FITS; }
            if (resultDescription === void 0) { resultDescription = "node"; }
            var subCollection = fitnessfunction === picking_1.EVERYTHING_FITS ? collection : picking_1.nMostFit(collection, Math.max(2, collection.length / 4), fitnessfunction, resultDescription);
            if (subCollection.length == 0)
                throw new Error("Collection is empty; can't pick " + resultDescription);
            return pickOne(subCollection, picking_1.EVERYTHING_FITS, resultDescription);
        };
        MazeGenerator.prototype.selectRandomNode = function (collection, fitnessfunction, resultDescription) {
            if (collection === void 0) { collection = this.nodes; }
            if (fitnessfunction === void 0) { fitnessfunction = picking_1.EVERYTHING_FITS; }
            if (resultDescription === void 0) { resultDescription = "node"; }
            return this._selectedNode = this.randomNode(collection, fitnessfunction, resultDescription);
        };
        MazeGenerator.prototype.linkNodes = function (n0, n1, linkAttrs) {
            var newLinkId = this.links.length;
            var n0LinkNumber = n0.linkIds.length;
            n0.linkIds.push(newLinkId);
            var n1LinkNumber = n1.linkIds.length;
            n1.linkIds.push(newLinkId);
            var link = {
                id: newLinkId,
                endpoint0: { nodeId: n0.id, linkNumber: n0LinkNumber },
                endpoint1: { nodeId: n1.id, linkNumber: n1LinkNumber },
                allowsBackwardMovement: linkAttrs.allowsBackwardMovement,
                allowsForwardMovement: linkAttrs.allowsForwardMovement,
                locks: linkAttrs.locks,
                direction: linkAttrs.direction,
            };
            this.links.push(link);
            return link;
        };
        MazeGenerator.prototype.dig = function (linkAttrs) {
            if (linkAttrs === void 0) { linkAttrs = graphmaze_1.DEFAULT_LINK_ATTRIBUTES; }
            var n0 = this.selectedNode;
            if (n0 == undefined)
                throw new Error("Can't dig; no currently selected node");
            var n1 = this.newNode();
            n1.requiredKeys = setutil_1.union(n0.requiredKeys, linkAttrs.locks);
            this.linkNodes(n0, n1, linkAttrs);
            this._selectedNode = n1;
            return n1;
        };
        MazeGenerator.prototype.digPath = function (len, entranceLocks) {
            if (entranceLocks === void 0) { entranceLocks = {}; }
            for (var i = 0; i < len; ++i) {
                this.dig({
                    allowsForwardMovement: true,
                    allowsBackwardMovement: true,
                    locks: i == 0 ? entranceLocks : {},
                });
                --len;
            }
        };
        MazeGenerator.prototype.placeItem = function (classRef) {
            if (this.selectedNode == null)
                throw new Error("No node currently selected");
            this.selectedNode.items[classRef] = classRef;
        };
        MazeGenerator.prototype.pickLoopOutputNode = function () {
            var inputKeys = this.selectedNode.requiredKeys;
            return pickOne(this.nodes, function (n) {
                return setutil_1.isSubset(n.requiredKeys, inputKeys) ? 1 / n.linkIds.length : 0;
            }, "loop output node");
        };
        MazeGenerator.prototype.digOneWayLoop = function (length, endNode, entranceLocks) {
            if (endNode === void 0) { endNode = this.pickLoopOutputNode(); }
            if (entranceLocks === void 0) { entranceLocks = {}; }
            for (var i = 0; i < length; ++i) {
                var linkLocks = i == 0 ? entranceLocks : {};
                this.dig({
                    allowsForwardMovement: true,
                    allowsBackwardMovement: !setutil_1.isEmpty(linkLocks) || Math.random() < 0.75,
                    locks: linkLocks,
                });
            }
            this.linkNodes(this.selectedNode, endNode, {
                allowsForwardMovement: true,
                allowsBackwardMovement: false,
                locks: {}
            });
        };
        MazeGenerator.prototype.digBranches = function (newNodeCount, originNodes, entranceLocks) {
            if (entranceLocks === void 0) { entranceLocks = {}; }
            var totalCollection = originNodes.slice(0, originNodes.length);
            for (var i = 0; i < newNodeCount; ++i) {
                this._selectedNode = pickOne(totalCollection, picking_1.EVERYTHING_FITS, "branch start node");
                totalCollection.push(this.dig({
                    allowsForwardMovement: true,
                    allowsBackwardMovement: true,
                    locks: i == 0 ? entranceLocks : {},
                }));
            }
        };
        /**
         * Digs either a linear or looping path.
         * Sets the current node to some node somewhere in the path.
         */
        MazeGenerator.prototype.digSomeKindOfPath = function (length, entranceLocks) {
            if (entranceLocks === void 0) { entranceLocks = {}; }
            if (length <= 0)
                return;
            if (Math.random() < 0.5)
                this.digPath(length, entranceLocks);
            else {
                var start = this.nodes.length;
                this.digOneWayLoop(length, undefined, entranceLocks);
                var end = this.nodes.length;
                this._selectedNode = this.nodes[start + Math.floor(Math.random() * (end - start))];
            }
        };
        MazeGenerator.prototype.accessibleNeighbors = function (node) {
            var others = [];
            links: for (var l = 0; l < node.linkIds.length; ++l) {
                var link = this.links[node.linkIds[l]];
                var isForward = (link.endpoint0.nodeId == node.id && link.endpoint0.linkNumber == l);
                if ((isForward && !link.allowsForwardMovement) || (!isForward && !link.allowsBackwardMovement))
                    continue links;
                var otherEndpoint = isForward ? link.endpoint1 : link.endpoint0;
                var otherNodeId = otherEndpoint.nodeId;
                others.push(this.nodes[otherNodeId]);
            }
            return others;
        };
        MazeGenerator.prototype.calculateNodeDistances = function (startNode) {
            for (var i = 0; i < this.nodes.length; ++i)
                this.nodes[i].distanceValue = undefined;
            startNode.distanceValue = 0;
            var q = [startNode];
            for (var i = 0; i < q.length; ++i) {
                var curNode = q[i];
                var neighbors = this.accessibleNeighbors(curNode);
                for (var n in neighbors) {
                    var neighb = neighbors[n];
                    if (neighb.distanceValue == undefined || neighb.distanceValue > curNode.distanceValue) {
                        neighb.distanceValue = curNode.distanceValue + 1;
                        q.push(neighb);
                    }
                }
            }
        };
        MazeGenerator.prototype.init = function (generatorName) {
            this.nodes = [];
            this.links = [];
            this.generatorName = generatorName;
            this.currentNodeCollection = [];
            this._selectedNode = undefined;
        };
        /**
         * For each stage:
         * generate a bunch of maze
         * - dig new nodes, locked with stage requirements
         * - randomly dig/branch/loop
         * pick node farthest from start of stage
         * place item
         */
        MazeGenerator.prototype.generate2 = function () {
            var _this = this;
            this.init("generate2");
            var stageStartNode = this.createStartNode();
            var stages = [];
            /*
            []
                {require: {}, provide:ITEMCLASS_BLUEKEY},
                {require: {[ITEMCLASS_BLUEKEY]:true}, provide:ITEMCLASS_YELLOWKEY},
                {require: {[ITEMCLASS_YELLOWKEY]:true}, provide:ITEMCLASS_REDKEY},
                {require: {[ITEMCLASS_BLUEKEY]:true,[ITEMCLASS_YELLOWKEY]:true,[ITEMCLASS_REDKEY]:true}, provide:ITEMCLASS_END},
            ]
            */
            var stageReqs = {};
            var allKeys = {};
            for (var r in this.requireKeys) {
                var keyClass = this.requireKeys[r];
                allKeys[keyClass] = true;
                stages.push({ require: stageReqs, provide: keyClass });
                // Usually require that key for the next stage, but not always
                if (Math.random() < 0.75)
                    stageReqs = (_a = {}, _a[keyClass] = true, _a);
            }
            stages.push({ require: allKeys, provide: graphmaze_1.ITEMCLASS_END });
            var newNodesPerStage = (this.targetNodeCount - 1) / stages.length;
            var budsPerStage = Math.ceil(newNodesPerStage / 2);
            var pathsPerStage = newNodesPerStage - budsPerStage;
            var maxComplictificationsPerStage = Math.ceil(pathsPerStage * this.complectificationFactor);
            for (var s in stages) {
                var stage = stages[s];
                var stageStart = this.nodes.length;
                var stageEndTarget = stageStart + newNodesPerStage;
                var stageBuds = [];
                for (var i = 0; i < budsPerStage; ++i) {
                    var n = this._selectedNode = picking_1.bestFit(this.nodes, function (n) { return Math.random() + 1 / (1 + n.linkIds.length); }, "bud node");
                    stageBuds.push(this.dig({
                        allowsForwardMovement: true,
                        allowsBackwardMovement: true,
                        locks: setutil_1.difference(stage.require, n.requiredKeys),
                    }));
                }
                var complectificationCount = 0;
                complectifications: while (this.nodes.length < stageEndTarget &&
                    complectificationCount < maxComplictificationsPerStage) {
                    var node = this.randomNode(this.nodes.slice(stageStart));
                    if (node.linkIds.length < 3) {
                        ++complectificationCount;
                        this._selectedNode = node;
                        var v = Math.random();
                        if (v < 0.5 && this.nodes.length > 4) {
                            var rando = void 0;
                            try {
                                rando = this.randomNode(this.nodes, function (n) { return 1 / (1 + n.linkIds.length); });
                            }
                            catch (err) {
                                continue complectifications;
                            }
                            if (Math.random() < 0.5) {
                                this.linkNodes(node, rando, {
                                    allowsForwardMovement: true,
                                    allowsBackwardMovement: true,
                                    locks: setutil_1.symmetricDifference(node.requiredKeys, rando.requiredKeys),
                                });
                            }
                            else {
                                this.linkNodes(node, rando, {
                                    allowsForwardMovement: true,
                                    allowsBackwardMovement: false,
                                    locks: {},
                                });
                            }
                            continue complectifications;
                        }
                        var pathLen = Math.min(stageEndTarget - this.nodes.length, picking_1.randInt(1, 3));
                        this.digSomeKindOfPath(pathLen, setutil_1.difference(stage.require, node.requiredKeys));
                    }
                }
                this.calculateNodeDistances(stageStartNode);
                var stagePreEndNode = this._selectedNode = picking_1.bestFit(this.nodes, function (n) { return Math.random() + n.distanceValue + n.id * 4 / _this.nodes.length; });
                console.log("Stage " + s + "; " + (this.nodes.length - stageStart) + " nodes; end node ID = " + stagePreEndNode.id + ", distance = " + stagePreEndNode.distanceValue);
                var stageEndNode = this.dig({
                    allowsForwardMovement: true,
                    allowsBackwardMovement: true,
                    locks: setutil_1.difference(stage.require, stagePreEndNode.requiredKeys)
                });
                this.placeItem(stage.provide);
                // set up for next stage...
                stageStartNode = stageEndNode;
            }
            return this.maze;
            var _a;
        };
        MazeGenerator.prototype.generate1 = function () {
            this.init("generate1");
            this.createStartNode();
            this.newCollection();
            this.dig();
            var stdPathLen = Math.max(1, this.targetNodeCount / (this.requireKeys.length * 6 + 1));
            this.digSomeKindOfPath(stdPathLen - 1);
            this.digBranches(stdPathLen, this.currentNodeCollection);
            for (var k in this.requireKeys) {
                var keyClassRef = this.requireKeys[k];
                this.newCollection();
                this.selectRandomNode();
                this.digPath(2);
                this.placeItem(keyClassRef);
                this.digBranches(stdPathLen, this.currentNodeCollection);
                this.digBranches(stdPathLen, this.nodes, (_a = {}, _a[keyClassRef] = true, _a));
            }
            // Make path to end
            this.selectRandomNode();
            for (var k in this.requireKeys) {
                this.newCollection();
                var keyClassRef = this.requireKeys[k];
                this.digSomeKindOfPath(stdPathLen, (_b = {}, _b[keyClassRef] = true, _b));
                this.digBranches(stdPathLen, this.currentNodeCollection);
            }
            this.placeItem(graphmaze_1.ITEMCLASS_END);
            return this.maze;
            var _a, _b;
        };
        MazeGenerator.prototype.generate = function () { return this.generate2(); };
        Object.defineProperty(MazeGenerator.prototype, "maze", {
            get: function () {
                return {
                    nodes: this.nodes,
                    links: this.links,
                    generatorName: this.generatorName,
                };
            },
            enumerable: true,
            configurable: true
        });
        return MazeGenerator;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = MazeGenerator;
    if (typeof require != 'undefined' && typeof module != 'undefined' && require.main === module) {
        var generator = new MazeGenerator();
        generator.requireKeys = [graphmaze_1.ITEMCLASS_BLUEKEY];
        var maze = generator.generate();
        console.log(JSON.stringify(maze, null, "\t"));
    }
    var _a;
});
/// <reference path="../../node.d.ts"/>
/// <reference path="../../Promise.d.ts"/>
define("togos-game21/graphmaze/GraphWorldifier", ["require", "exports", "togos-game21/graphmaze", "togos-game21/graphmaze/picking", "togos-game21/GameDataManager", "tshash/uuids", "togos-game21/aabbs", "togos-game21/vector3dmath", "togos-game21/vector3ds", "togos-game21/worldutil", "togos-game21/maze1demodata", "tshash/index", "togos-game21/HTTPHashDatastore"], function (require, exports, graphmaze_2, picking_2, GameDataManager_3, uuids_1, aabbs_7, vector3dmath_11, vector3ds_16, worldutil_4, dat, index_9, HTTPHashDatastore_4) {
    "use strict";
    function newUuidRef() { return uuids_1.uuidUrn(uuids_1.newType4Uuid()); }
    var DIR_RIGHT = 0;
    var DIR_DOWN = 1;
    var DIR_LEFT = 2;
    var DIR_UP = 3;
    function oppositeDirection(dir) {
        return (dir + 2) % 4;
    }
    /** Pick a direction for the a link! */
    function pickLinkDirection(usedDirections, link) {
        var hasLocks = false;
        for (var lock in link.locks)
            hasLocks = true;
        if (link.allowsForwardMovement && !link.allowsBackwardMovement)
            return DIR_DOWN;
        if (link.allowsBackwardMovement && !link.allowsForwardMovement)
            return DIR_UP;
        // Sometimes pick one at random.
        if (!hasLocks && Math.random() < 0.25) {
            return randInt(0, 3);
        }
        var minDirs = [];
        var minCount = Infinity;
        for (var d = 0; d < 4; ++d) {
            if (hasLocks && (d == DIR_UP || d == DIR_DOWN))
                continue;
            if (usedDirections[d] == minCount) {
                minDirs.push(d);
            }
            else if (usedDirections[d] < minCount) {
                minDirs = [d];
                minCount = usedDirections[d];
            }
        }
        var horizontalDirs = [];
        var verticalDirs = [];
        for (var i in minDirs) {
            var d = minDirs[i];
            switch (d) {
                case DIR_LEFT:
                case DIR_RIGHT:
                    horizontalDirs.push(d);
                    break;
                default:
                    verticalDirs.push(d);
                    break;
            }
        }
        minDirs = (horizontalDirs.length >= verticalDirs.length) ? horizontalDirs : verticalDirs;
        return minDirs[randInt(0, minDirs.length - 1)];
    }
    function newProtoRoom(spanId, bounds) {
        return {
            id: newUuidRef(),
            protoRoomSpanRef: spanId,
            bounds: bounds,
            protoLinks: [undefined, undefined, undefined, undefined],
            doors: {}
        };
    }
    function linkProtoRooms(pr0, pp0, dir, pr1, pp1, linkAttributes) {
        if (pr0.protoLinks[dir])
            throw new Error("Can't connect " + pr0.id + " " + dir + "-wise to " + pr1.id + "; link already exists");
        var rid = oppositeDirection(dir);
        if (pr1.protoLinks[rid])
            throw new Error("Can't connect " + pr1.id + " " + rid + "-wise to " + pr0.id + "; link already exists");
        pr0.protoLinks[dir] = { neighborRef: pr1.id, attributes: linkAttributes, position: pp0 };
        pr1.protoLinks[rid] = { neighborRef: pr0.id, attributes: linkAttributes, position: pp1 };
    }
    function roomLeftFloorHeight(pr) {
        return pr.bounds.maxY - 3;
    }
    function roomRightFloorHeight(pr) {
        return pr.bounds.maxY - 3;
    }
    function linkProtoRoomsDefaultly(pr0, dir, pr1, linkAttributes) {
        var y0l = roomLeftFloorHeight(pr0);
        var y0r = roomRightFloorHeight(pr0);
        var defaultLinkPositions0 = [
            { x: pr0.bounds.maxX, y: y0r, z: 0 },
            { x: 0, y: pr0.bounds.maxY, z: 0 },
            { x: pr0.bounds.minX, y: y0l, z: 0 },
            { x: 0, y: pr0.bounds.minY, z: 0 },
        ];
        var y1l = roomLeftFloorHeight(pr1);
        var y1r = roomRightFloorHeight(pr1);
        var defaultLinkPositions1 = [
            { x: pr1.bounds.minX, y: y1l, z: 0 },
            { x: 0, y: pr1.bounds.minY, z: 0 },
            { x: pr1.bounds.maxX, y: y1r, z: 0 },
            { x: 0, y: pr1.bounds.maxY, z: 0 },
        ];
        linkProtoRooms(pr0, defaultLinkPositions0[dir], dir, pr1, defaultLinkPositions1[dir], linkAttributes);
    }
    function neighborOffset(bounds, dir, nBounds) {
        switch (dir) {
            case DIR_RIGHT: return { x: bounds.maxX - nBounds.minX, y: 0, z: 0 };
            case DIR_LEFT: return { x: bounds.minX - nBounds.maxX, y: 0, z: 0 };
            case DIR_DOWN: return { x: 0, y: bounds.maxY - nBounds.minY, z: 0 };
            case DIR_UP: return { x: 0, y: bounds.minY - nBounds.maxY, z: 0 };
            default: throw new Error("Bad direction: " + dir);
        }
    }
    function assertInteger(n, ctx) {
        if (n != Math.floor(n))
            throw new Error(ctx + " is not an integer!: " + n);
    }
    var Bitmap = (function () {
        function Bitmap(bounds) {
            this.bounds = bounds;
            this._offsetX = bounds.minX;
            this._offsetY = bounds.minY;
            this._offsetZ = bounds.minZ;
            this._width = bounds.maxX - bounds.minX;
            this._height = bounds.maxY - bounds.minY;
            this._depth = bounds.maxZ - bounds.minZ;
            assertInteger(this._width, "bitmap width");
            assertInteger(this._height, "bitmap height");
            assertInteger(this._depth, "bitmap depth");
            this._data = new Array(this._width * this._height * this._depth);
        }
        Object.defineProperty(Bitmap.prototype, "width", {
            get: function () { return this._width; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Bitmap.prototype, "height", {
            get: function () { return this._height; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Bitmap.prototype, "depth", {
            get: function () { return this._depth; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Bitmap.prototype, "data", {
            get: function () { return this._data; },
            enumerable: true,
            configurable: true
        });
        Bitmap.prototype.fill = function (x0, y0, z0, x1, y1, z1, v) {
            if (x0 < this._offsetX)
                x0 = this._offsetX;
            if (y0 < this._offsetY)
                y0 = this._offsetY;
            if (z0 < this._offsetZ)
                z0 = this._offsetZ;
            var maxX = this._offsetX + this._width;
            var maxY = this._offsetY + this._height;
            var maxZ = this._offsetZ + this._depth;
            if (x1 > maxX)
                x1 = maxX;
            if (y1 > maxY)
                y1 = maxY;
            if (z1 > maxZ)
                z1 = maxZ;
            x0 -= this._offsetX;
            y0 -= this._offsetY;
            z0 -= this._offsetZ;
            x1 -= this._offsetX;
            y1 -= this._offsetY;
            z1 -= this._offsetZ;
            for (var z = z0; z < z1; ++z) {
                for (var y = y0; y < y1; ++y) {
                    for (var x = x0; x < x1; ++x) {
                        var i = x + y * (this._width) + z * (this._width * this._height);
                        this._data[i] = v;
                    }
                }
            }
        };
        return Bitmap;
    }());
    function randInt(min, max) {
        var m = Math.floor(max - min) + 1;
        return min + Math.floor(m * Math.random());
    }
    function rot2(t) {
        return [t[2], t[3], t[0], t[1]];
    }
    var GraphWorldifier = (function () {
        function GraphWorldifier(_gdm, _maze) {
            this._gdm = _gdm;
            this._maze = _maze;
            this.linkDirections = {};
            this.protoRoomSpans = {};
            this.gardenChance = 0.125;
            this.caveChance = 0.5;
            this.baseRootiness = 1;
            this.themeAreaSize = 7;
            this.protoRooms = {};
            this.spareProtoRoomSpans = {};
            this.nodeThemes = {};
            this.nodeFoods = {};
        }
        Object.defineProperty(GraphWorldifier.prototype, "gameDataManager", {
            get: function () { return this._gdm; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(GraphWorldifier.prototype, "maze", {
            get: function () { return this._maze; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(GraphWorldifier.prototype, "tileEntityPaletteRef", {
            get: function () {
                if (this._tileEntityPaletteRef == null)
                    throw new Error("No tile entity palette ref!");
                return this._tileEntityPaletteRef;
            },
            set: function (t) {
                this._tileEntityPaletteRef = t;
            },
            enumerable: true,
            configurable: true
        });
        GraphWorldifier.prototype.newProtoRoom = function (spanId, bounds) {
            var pr = newProtoRoom(spanId, bounds);
            this.protoRooms[pr.id] = pr;
            return pr;
        };
        GraphWorldifier.prototype.protoRoomSpanMeetsRequirements = function (prs, reqs) {
            var openSides = [0, 0, 0, 0];
            for (var pr in prs.protoRooms) {
                for (var d = 0; d < 4; ++d)
                    if (prs.protoRooms[pr].protoLinks[d] == null)
                        ++openSides[d];
            }
            for (var d = 0; d < 4; ++d) {
                if (reqs.exitsPerSide[d] > openSides[d])
                    return false;
            }
            return true;
        };
        GraphWorldifier.prototype.calculateNodeSpanRequirements = function (gn) {
            var linkCounts = [0, 0, 0, 0];
            // Count number of links that must point each direction
            for (var linkNumber = 0; linkNumber < gn.linkIds.length; ++linkNumber) {
                var linkId = gn.linkIds[linkNumber];
                var link = this._maze.links[linkId];
                var linkDir = this.linkDirections[linkId];
                if (linkDir) {
                    var isForward = (link.endpoint0.nodeId == gn.id && link.endpoint0.linkNumber == linkNumber);
                    var dir = isForward ? linkDir : oppositeDirection(linkDir);
                    ++linkCounts[dir];
                }
            }
            // Pick directions for any undecided links
            for (var linkNumber = 0; linkNumber < gn.linkIds.length; ++linkNumber) {
                var linkId = gn.linkIds[linkNumber];
                var link = this._maze.links[linkId];
                var linkDir = this.linkDirections[linkId];
                if (linkDir == undefined) {
                    var isForward = (link.endpoint0.nodeId == gn.id && link.endpoint0.linkNumber == linkNumber);
                    var linkCounts2 = isForward ? linkCounts : rot2(linkCounts);
                    var linkDir_1 = pickLinkDirection(linkCounts2, link);
                    this.linkDirections[linkId] = linkDir_1;
                    ++linkCounts[isForward ? linkDir_1 : oppositeDirection(linkDir_1)];
                }
            }
            var exitsPerSide = [0, 0, 0, 0];
            for (var linkNumber = 0; linkNumber < gn.linkIds.length; ++linkNumber) {
                var linkId = gn.linkIds[linkNumber];
                var link = this._maze.links[linkId];
                var linkDir = this.linkDirections[linkId];
                if (linkDir == undefined)
                    throw new Error("linkDir should have been popualted");
                var isForward = (link.endpoint0.nodeId == gn.id && link.endpoint0.linkNumber == linkNumber);
                var dir = isForward ? linkDir : oppositeDirection(linkDir);
                ++exitsPerSide[dir];
            }
            return { exitsPerSide: exitsPerSide };
        };
        GraphWorldifier.prototype.generateBoringProtoRoomSpan = function (reqs, node) {
            // Is this where 'generate nice room spans' code might go?
            // e.g. try generating a cavey room or something
            var spanId = newUuidRef();
            var spanProtoRooms = {};
            var openSides = [1, 1, 1, 1];
            //let maxRex = Math.max(reqs.exitsPerSide[DIR_UP], reqs.exitsPerSide[DIR_DOWN]);
            var isSpecialNode = node.items[graphmaze_2.ITEMCLASS_START] || node.items[graphmaze_2.ITEMCLASS_END];
            var isCavey = !isSpecialNode && this.nodeThemes[node.id] == "cavey";
            var roomBounds = isCavey ? aabbs_7.makeAabb(randInt(-4, -6), randInt(-4, -6), -0.5, randInt(4, 6), randInt(4, 6), +0.5) :
                aabbs_7.makeAabb(-4, -4, -0.5, 4, 4, 0.5);
            var protoRoom = this.newProtoRoom(spanId, roomBounds);
            spanProtoRooms[protoRoom.id] = protoRoom;
            for (var i = 0; i < reqs.exitsPerSide.length; ++i) {
                while (reqs.exitsPerSide[i] > openSides[i]) {
                    // We gotta dig in a perpendicular direction.
                    var digDir = ((i + 1) + randInt(0, 1) * 2) % 4;
                    if (protoRoom.protoLinks[digDir])
                        digDir = (digDir + 2) % 4;
                    var newRoom = this.newProtoRoom(spanId, roomBounds);
                    linkProtoRoomsDefaultly(protoRoom, digDir, newRoom, {
                        isBidirectional: true,
                        interSpan: false,
                    });
                    spanProtoRooms[newRoom.id] = newRoom;
                    ++openSides[i];
                    ++openSides[oppositeDirection(i)];
                    protoRoom = newRoom;
                }
            }
            return { id: spanId, protoRooms: spanProtoRooms, isCavey: isCavey };
        };
        GraphWorldifier.prototype.generateProtoRoomSpan = function (reqs, node) {
            return this.generateBoringProtoRoomSpan(reqs, node);
        };
        GraphWorldifier.prototype.getNewProtoRoomSpanForNode = function (node) {
            var reqs = this.calculateNodeSpanRequirements(node);
            for (var i in this.spareProtoRoomSpans) {
                if (this.protoRoomSpanMeetsRequirements(this.spareProtoRoomSpans[i], reqs)) {
                    var prs_1 = this.spareProtoRoomSpans[i];
                    delete this.spareProtoRoomSpans[i];
                    prs_1.node = node;
                    return prs_1;
                }
            }
            for (var i = 0; i < 10; ++i) {
                var prs_2 = this.generateProtoRoomSpan(reqs, node);
                if (this.protoRoomSpanMeetsRequirements(prs_2, reqs)) {
                    prs_2.node = node;
                    return prs_2;
                }
            }
            var prs = this.generateBoringProtoRoomSpan(reqs, node);
            prs.node = node;
            return prs;
        };
        GraphWorldifier.prototype.generateLinkSpan = function (link, locks) {
            var spanId = newUuidRef();
            var protoRooms = {};
            var newRoom = this.newProtoRoom(spanId, aabbs_7.makeAabb(-4, -4, -0.5, +4, +4, +0.5));
            newRoom.doors = locks;
            protoRooms[newRoom.id] = newRoom;
            return { id: spanId, protoRooms: protoRooms };
        };
        GraphWorldifier.prototype.findRoomWithOpenWall = function (span, direction, spanId) {
            var roomCount = 0;
            for (var r in span.protoRooms) {
                var room = span.protoRooms[r];
                if (room.protoLinks[direction] == null)
                    return room;
                ++roomCount;
            }
            console.error("Span " + spanId + ": " + JSON.stringify(span, null, "\t"));
            throw new Error("No open " + direction + " wall in span " + spanId + "; size=" + roomCount);
        };
        GraphWorldifier.prototype.connectSpans = function (span0Id, dir, span1Id, isBidirectional) {
            var span0 = this.protoRoomSpans[span0Id];
            var span1 = this.protoRoomSpans[span1Id];
            var rid = oppositeDirection(dir);
            var room0 = this.findRoomWithOpenWall(span0, dir, span0Id);
            var room1 = this.findRoomWithOpenWall(span1, rid, span1Id);
            var linkAttributes = { isBidirectional: isBidirectional, interSpan: true };
            linkProtoRoomsDefaultly(room0, dir, room1, linkAttributes);
        };
        GraphWorldifier.prototype.primaryWallTileIndex = function (node) {
            if (node) {
                if (node.items[graphmaze_2.ITEMCLASS_START])
                    return 14;
                else if (node.items[graphmaze_2.ITEMCLASS_END])
                    return 1;
                else if (this.nodeThemes[node.id] == "cavey")
                    return 29;
                else if (node.requiredKeys[graphmaze_2.ITEMCLASS_REDKEY])
                    return 20;
                else if (node.requiredKeys[graphmaze_2.ITEMCLASS_YELLOWKEY])
                    return 19;
                else if (node.requiredKeys[graphmaze_2.ITEMCLASS_BLUEKEY])
                    return 15;
            }
            return 21;
        };
        GraphWorldifier.prototype.protoLinkedWallTileIndex = function (link) {
            if (!link)
                return 21;
            var protoRoom = this.protoRooms[link.neighborRef];
            if (!protoRoom)
                return 21;
            var span = this.protoRoomSpans[protoRoom.protoRoomSpanRef];
            if (!span || !span.node)
                return 21;
            return this.primaryWallTileIndex(span.node);
        };
        GraphWorldifier.prototype.protoRoomSpanToWorldRooms = function (span) {
            var itemsPlaced = false;
            for (var pr in span.protoRooms) {
                var protoRoom = span.protoRooms[pr];
                // TODO: Make more interesting rooms, maybe with the help of generateSpan
                // have it figure general size and shape so we know how to place neighbors ahead of time
                //const roomWidth = 8, roomHeight = 8, roomDepth = 1;
                //const roomBounds:AABB = makeAabb(-roomWidth/2, -roomHeight/2, -roomDepth/2, roomWidth/2, roomHeight/2, roomDepth/2);
                var roomBounds = protoRoom.bounds;
                var roomWidth = roomBounds.maxX - roomBounds.minX;
                var roomHeight = roomBounds.maxY - roomBounds.minY;
                var tileBmp = new Bitmap(roomBounds);
                var primaryFloorHeight = roomBounds.maxY - 3;
                var ceilingHeight = span.node ? randInt(roomBounds.minX + 1, primaryFloorHeight - 2) : primaryFloorHeight - 2;
                var neighbors = {};
                var ladderTileIndex = 5;
                var rockTileIndex = 29;
                var platformTileIndex = 2;
                var rootTileIndex = 28;
                var browningVinesTileIndex = 27;
                var wallTileIndex = this.primaryWallTileIndex(span.node);
                var rightProtoLink = protoRoom.protoLinks[DIR_RIGHT];
                var leftProtoLink = protoRoom.protoLinks[DIR_LEFT];
                var topProtoLink = protoRoom.protoLinks[DIR_UP];
                var bottomProtoLink = protoRoom.protoLinks[DIR_DOWN];
                if (bottomProtoLink && !bottomProtoLink.attributes.isBidirectional) {
                    // Make sure they have room to jump over
                    ceilingHeight = Math.min(primaryFloorHeight - 3, ceilingHeight);
                }
                var hasDoors = false;
                for (var k in protoRoom.doors)
                    hasDoors = true;
                var x0 = roomBounds.minX, x1 = roomBounds.maxX;
                var y0 = roomBounds.minY, y1 = roomBounds.maxY;
                var z0 = roomBounds.minZ, z1 = roomBounds.maxZ;
                var isCavey = span.isCavey;
                var hasGarden = Math.random() < (isCavey ? 0.75 : this.gardenChance);
                var rootiness = isCavey ? Math.random() * 2 * this.baseRootiness :
                    hasGarden && Math.random() < 0.5 ? this.baseRootiness * Math.random() - 0.5 : 0;
                var wallThickness = isCavey ? 1 : 2;
                var leftWallX = x0 + wallThickness;
                var rightWallX = x1 - wallThickness;
                var ceilingY = y0 + 1;
                var floorHeights = protoRoom.floorHeights;
                if (floorHeights == undefined) {
                    floorHeights = [];
                    for (var i = 0; i < tileBmp.width; ++i)
                        floorHeights[i] = primaryFloorHeight;
                }
                var ceilingHeights = protoRoom.ceilingHeights;
                if (ceilingHeights == undefined) {
                    ceilingHeights = [];
                    for (var i = 0; i < tileBmp.width; ++i)
                        ceilingHeights[i] = ceilingY;
                }
                var rightFloorHeight = Math.round(floorHeights[floorHeights.length - 1]);
                var leftFloorHeight = Math.round(floorHeights[0]);
                // Start with empty space:
                tileBmp.fill(x0, y0, z0, x1, y1, z1, 0);
                // Add cool stuff:
                if (isCavey) {
                    var caveCeilingHeight = ceilingY + Math.random() * (primaryFloorHeight - ceilingY);
                    for (var x = leftWallX; x < rightWallX; ++x) {
                        var i = x - x0;
                        ceilingHeights[i] = Math.max(ceilingHeights[i], Math.round(caveCeilingHeight));
                        tileBmp.fill(x, y0, z0, x + 1, caveCeilingHeight, z1, rockTileIndex);
                        caveCeilingHeight += Math.random() * 2 - 1;
                    }
                }
                // Add walls:
                tileBmp.fill(x0, y0, z0, x1, ceilingY, z1, wallTileIndex);
                tileBmp.fill(x0, y0, z0, leftWallX, y1, z1, wallTileIndex);
                tileBmp.fill(rightWallX, y0, z0, x1, y1, z1, wallTileIndex);
                // Make sure there's some path through the middle
                tileBmp.fill(leftWallX, primaryFloorHeight - 2, z0, rightWallX, primaryFloorHeight, z1, 0);
                if (rootiness > 0) {
                    var rootBaseLength = 2 * rootiness * Math.random();
                    var hasVines = Math.random() < 1 / 8;
                    for (var x = leftWallX; x < rightWallX; ++x) {
                        var i = x - x0;
                        //rootBaseLength += Math.random()-0.5;
                        var rootLength = rootBaseLength * (Math.random() + 0.5);
                        var rootEndY = Math.round(ceilingHeights[i] + rootLength);
                        tileBmp.fill(x, ceilingHeights[i], z0, x + 1, rootEndY, z1, hasVines && Math.random() < 1 / 8 ? browningVinesTileIndex : rootTileIndex);
                    }
                }
                // Floor
                tileBmp.fill(x0, primaryFloorHeight, z0, x1, y1, z1, wallTileIndex);
                var fancyLadders = true;
                if (rightProtoLink) {
                    var hallWidth = rightProtoLink.attributes.interSpan ? 2 : 4;
                    tileBmp.fill(rightWallX, Math.max(roomBounds.minY + 1, rightFloorHeight - hallWidth), z0, roomBounds.maxX, Math.min(roomBounds.maxY - 1, rightFloorHeight), z1, 0);
                }
                if (leftProtoLink) {
                    var hallWidth = leftProtoLink.attributes.interSpan ? 2 : 4;
                    tileBmp.fill(roomBounds.minX, Math.max(roomBounds.minY + 1, leftFloorHeight - hallWidth), z0, leftWallX, Math.min(roomBounds.maxY - 1, leftFloorHeight), z1, 0);
                }
                var itemX = !protoRoom.protoLinks[DIR_DOWN] ? 0.5 :
                    !protoRoom.protoLinks[DIR_LEFT] ? -1.5 :
                        !protoRoom.protoLinks[DIR_RIGHT] ? +1.5 :
                            -0.5;
                var roomEntities = {};
                if (hasGarden) {
                    // Garden!
                    tileBmp.fill(roomBounds.minX + 1, primaryFloorHeight, z0, roomBounds.maxX - 1, roomBounds.maxY, z1, 0);
                    //tileBmp.fill( 1,floorHeight+1,0, roomWidth-1,floorHeight+2,1, rockTileIndex ); // rocks!
                    var hilliness = Math.random();
                    var groundHeight = primaryFloorHeight + Math.random() * (primaryFloorHeight + roomBounds.maxY - 1);
                    for (var x = roomBounds.minX + 1; x < roomBounds.maxX - 1; ++x) {
                        groundHeight += (Math.random() - 0.5) * 2 * hilliness;
                        var minGroundHeight = (x < leftWallX + 1 || x > rightWallX - 1) ? primaryFloorHeight - 1 : ceilingHeight + 1;
                        if (groundHeight < minGroundHeight)
                            groundHeight = minGroundHeight;
                        if (groundHeight > roomBounds.maxY - 1)
                            groundHeight = roomBounds.maxY - 1;
                        var groundHeightAbs = Math.round(groundHeight);
                        floorHeights[x - roomBounds.minX] = groundHeightAbs;
                        tileBmp.fill(x, groundHeightAbs, z0, x + 1, roomBounds.maxY, z1, rockTileIndex);
                        if (Math.random() < 0.5) {
                            var plantTileIndex = void 0;
                            if (Math.random() < 0.125)
                                plantTileIndex = 14; // brown brick
                            else
                                plantTileIndex = [26, 25, 3][Math.floor(Math.random() * Math.random() * 3)];
                            tileBmp.fill(x, groundHeightAbs - 1, z0, x + 1, groundHeightAbs, z1, plantTileIndex);
                        }
                        if (Math.random() < 0.125 && x != Math.floor(itemX)) {
                            // Leave a stick!
                            var stickClassRef = picking_2.pickOne([dat.stick1EntityClassId, dat.stick2EntityClassId]);
                            roomEntities[newUuidRef()] = {
                                position: { x: x + 0.5, y: groundHeightAbs - 1 / 8, z: 0 },
                                entity: { classRef: stickClassRef }
                            };
                        }
                    }
                }
                if (topProtoLink) {
                    if (hasDoors)
                        throw new Error("Lock room has vertical link!");
                    var linkX = topProtoLink.position.x;
                    if (fancyLadders) {
                        if (topProtoLink.attributes.isBidirectional) {
                            var holeMinX = linkX - randInt(0, 1);
                            var holeMaxX = linkX + 1 + randInt(0, 1);
                            tileBmp.fill(holeMinX, y0, z0, holeMaxX, floorHeights[linkX - x0] - 1, z1, 0);
                            tileBmp.fill(linkX, y0, z0, linkX + 1, floorHeights[linkX - x0] - 1, z1, ladderTileIndex);
                        }
                        else {
                            var hallWidth = topProtoLink.attributes.interSpan ? 2 : 4;
                            var hhw = hallWidth / 2;
                            tileBmp.fill(linkX - hhw, y0, z0, linkX + hhw, primaryFloorHeight, z1, 0);
                        }
                    }
                    else {
                        if (topProtoLink.attributes.isBidirectional) {
                            tileBmp.fill(linkX, y0, z0, linkX + 1, Math.floor(floorHeights[linkX - x0]) - 1, z1, ladderTileIndex);
                        }
                        else {
                            tileBmp.fill(linkX, y0, z0, linkX + 1, Math.floor(floorHeights[linkX - x0]) - 1, z1, 0);
                        }
                    }
                }
                if (bottomProtoLink) {
                    if (hasDoors)
                        throw new Error("Lock room has vertical link!");
                    var linkX = bottomProtoLink.position.x;
                    if (fancyLadders) {
                        if (bottomProtoLink.attributes.isBidirectional) {
                            if (Math.random() < 0.5) {
                                tileBmp.fill(linkX - 1, primaryFloorHeight, z0, linkX + 2, primaryFloorHeight + 1, 1, platformTileIndex);
                            }
                            else {
                                tileBmp.fill(x0, primaryFloorHeight, z0, x1, primaryFloorHeight + 1, z1, platformTileIndex);
                            }
                            var ladderX = linkX;
                            tileBmp.fill(ladderX, primaryFloorHeight - 1, z0, ladderX + 1, y1, z1, ladderTileIndex);
                        }
                        else {
                            var hallWidth = bottomProtoLink.attributes.interSpan ? 2 : 4;
                            var hhw = hallWidth / 2;
                            tileBmp.fill(linkX - hhw, primaryFloorHeight, z0, linkX + hhw, y1, z1, 0);
                        }
                    }
                    else {
                        if (bottomProtoLink.attributes.isBidirectional) {
                            tileBmp.fill(linkX, Math.floor(floorHeights[linkX - x0]) - 1, z0, linkX + 1, y1, z1, ladderTileIndex);
                        }
                        else {
                            tileBmp.fill(linkX, Math.floor(floorHeights[linkX - x0]), z0, linkX + 1, y1, z1, 0);
                        }
                    }
                }
                for (var i = 0; i < 4; ++i) {
                    var protoLink = protoRoom.protoLinks[i];
                    if (protoLink) {
                        var neighborProtoRoom = this.protoRooms[protoLink.neighborRef];
                        var neighborLink = neighborProtoRoom.protoLinks[(i + 2) % 4];
                        if (!neighborLink)
                            throw new Error("Complementary link missing!!");
                        var neighborLinkPosition = neighborLink.position;
                        neighbors["n" + i] = {
                            bounds: roomBounds,
                            roomRef: protoLink.neighborRef,
                            offset: vector3dmath_11.subtractVector(protoLink.position, neighborLinkPosition)
                        };
                    }
                }
                if (hasDoors) {
                    var leftWallTileIndex = this.protoLinkedWallTileIndex(protoRoom.protoLinks[DIR_LEFT]);
                    var rightWallTileIndex = this.protoLinkedWallTileIndex(protoRoom.protoLinks[DIR_RIGHT]);
                    var doorPos = roomBounds.minX + 2;
                    var lastDoorPos = doorPos;
                    tileBmp.fill(roomBounds.minX, roomBounds.minY, z0, doorPos, ceilingHeight, z1, leftWallTileIndex);
                    tileBmp.fill(roomBounds.minX, primaryFloorHeight, z0, doorPos, roomBounds.maxY, z1, leftWallTileIndex);
                    for (var k in protoRoom.doors) {
                        var doorTileIndex = void 0;
                        var doorFrameTileIndex = void 0;
                        switch (k) {
                            case graphmaze_2.ITEMCLASS_BLUEKEY:
                                doorTileIndex = 16;
                                doorFrameTileIndex = 22;
                                break;
                            case graphmaze_2.ITEMCLASS_YELLOWKEY:
                                doorTileIndex = 17;
                                doorFrameTileIndex = 23;
                                break;
                            case graphmaze_2.ITEMCLASS_REDKEY:
                                doorTileIndex = 18;
                                doorFrameTileIndex = 24;
                                break;
                            default: throw new Error("No door tile index known for " + k);
                        }
                        tileBmp.fill(doorPos, roomBounds.minY, z0, doorPos + 1, roomBounds.maxY, z1, doorFrameTileIndex);
                        tileBmp.fill(doorPos, ceilingHeight, z0, doorPos + 1, primaryFloorHeight, z1, doorTileIndex);
                        lastDoorPos = doorPos;
                        doorPos += 2;
                    }
                    tileBmp.fill(lastDoorPos + 1, roomBounds.minX, z0, roomBounds.maxX, ceilingHeight, z1, rightWallTileIndex);
                    tileBmp.fill(lastDoorPos + 1, primaryFloorHeight, z0, roomBounds.maxX, roomBounds.maxY, z1, rightWallTileIndex);
                }
                var itemClassRefs = [];
                var itemsNeedFancyPedestal = false;
                if (span.node && !itemsPlaced) {
                    for (var k in span.node.items) {
                        var itemClassId = span.node.items[k];
                        var entityClassRef = void 0;
                        switch (itemClassId) {
                            case graphmaze_2.ITEMCLASS_BLUEKEY:
                                entityClassRef = dat.blueKeyEntityClassId;
                                break;
                            case graphmaze_2.ITEMCLASS_YELLOWKEY:
                                entityClassRef = dat.yellowKeyEntityClassId;
                                break;
                            case graphmaze_2.ITEMCLASS_REDKEY:
                                entityClassRef = dat.redKeyEntityClassId;
                                break;
                            case graphmaze_2.ITEMCLASS_START:
                                entityClassRef = dat.spawnPointEntityClassId;
                                break;
                            case graphmaze_2.ITEMCLASS_END:
                                entityClassRef = dat.triforceEntityClassId;
                                break;
                            default: throw new Error("Unknown entity type " + itemClassId);
                        }
                        itemClassRefs.push(entityClassRef);
                        itemsNeedFancyPedestal = true;
                    }
                    if (this.nodeFoods[span.node.id]) {
                        itemClassRefs.push(dat.appleEntityClassId);
                    }
                }
                var itemY = floorHeights[Math.floor(itemX - roomBounds.minX)] - 0.5;
                if (itemsNeedFancyPedestal)
                    itemY -= 1;
                for (var i in itemClassRefs) {
                    var entityClassRef = itemClassRefs[i];
                    var tileX = Math.floor(itemX);
                    var tileY = Math.floor(itemY);
                    if (itemsNeedFancyPedestal && !itemsPlaced) {
                        tileBmp.fill(tileX, tileY + 1, z0, tileX + 1, tileY + 2, z1, platformTileIndex);
                    }
                    // Make sure there's space around to get the thing!
                    tileBmp.fill(tileX - 1, tileY, z0, tileX + 2, tileY + 1, z1, 0);
                    roomEntities[newUuidRef()] = {
                        position: { x: itemX, y: itemY, z: 0 },
                        entity: { classRef: entityClassRef }
                    };
                    --itemY;
                    itemsPlaced = true;
                }
                if (span.node && span.node.id == 0) {
                    // Player might get placed in here.
                    tileBmp.fill(1, 0, z0, 2, floorHeights[0 - x0], z1, 0);
                }
                roomEntities[newUuidRef()] = {
                    position: vector3ds_16.ZERO_VECTOR,
                    entity: { classRef: worldutil_4.makeTileTreeRef(this.tileEntityPaletteRef, tileBmp.width, tileBmp.height, tileBmp.depth, tileBmp.data, this._gdm, {
                            infiniteMass: true, boundingBox: roomBounds
                        }) }
                };
                var room = {
                    bounds: roomBounds,
                    roomEntities: roomEntities,
                    neighbors: neighbors
                };
                this._gdm.tempStoreObject(room, protoRoom.id);
            }
        };
        GraphWorldifier.prototype.figureNodeThemes = function () {
            if (this.maze.nodes.length == 0)
                return;
            //const themes = ["normal","cavey"];
            var pickCount = Math.max(2, Math.ceil(this.maze.nodes.length / this.themeAreaSize));
            var pickedThemes = {};
            var spreads = [];
            for (var i = 0; i < pickCount; ++i) {
                var node = picking_2.pickOne(this.maze.nodes);
                var shouldBeCave = Math.random() < this.caveChance * node.linkIds.length / 4;
                var theme = shouldBeCave ? "cavey" : "normal";
                this.nodeThemes[node.id] = theme;
                pickedThemes[theme] = (pickedThemes[theme] || 0) + 1;
                spreads.push(node.id);
            }
            var pickedThemeDebugs = [];
            for (var t in pickedThemes) {
                pickedThemeDebugs.push(pickedThemes[t] + " " + t + " areas");
            }
            console.log(pickedThemeDebugs.join(", "));
            for (var i = 0; i < spreads.length; ++i) {
                var nodeId = spreads[i];
                var node = this.maze.nodes[nodeId];
                var theme = this.nodeThemes[nodeId];
                for (var linkNumber = 0; linkNumber < node.linkIds.length; ++linkNumber) {
                    var link = this.maze.links[node.linkIds[linkNumber]];
                    var isForward = link.endpoint0.nodeId == nodeId && link.endpoint0.linkNumber == linkNumber;
                    var otherEnd = isForward ? link.endpoint1 : link.endpoint0;
                    if (this.nodeThemes[otherEnd.nodeId] == null) {
                        this.nodeThemes[otherEnd.nodeId] = theme;
                        spreads.push(otherEnd.nodeId);
                    }
                }
            }
        };
        GraphWorldifier.prototype.figureFoodLocations = function () {
            var fitNodes = picking_2.nMostFit(this.maze.nodes, Math.ceil(this.maze.nodes.length / (4 + 12 / this.maze.nodes.length)), function (n) {
                var itemCount = 0;
                for (var i in n.items)
                    ++itemCount;
                var lockCount = 0;
                for (var k in n.requiredKeys)
                    ++lockCount;
                return 8 / (1 + n.linkIds.length + itemCount + lockCount / 3) + Math.random() / 2;
            });
            for (var i = 0; i < fitNodes.length; ++i) {
                this.nodeFoods[fitNodes[i].id] = true;
            }
        };
        GraphWorldifier.prototype.run = function () {
            this.figureNodeThemes();
            this.figureFoodLocations();
            var startNodeId = '0';
            var nodeProtoRoomSpans = {};
            for (var n in this._maze.nodes) {
                var node = this._maze.nodes[n];
                var protoRoomSpan = this.getNewProtoRoomSpanForNode(node);
                this.protoRoomSpans[protoRoomSpan.id] = protoRoomSpan;
                nodeProtoRoomSpans[n] = protoRoomSpan;
                if (node.items[graphmaze_2.ITEMCLASS_START])
                    startNodeId = n;
            }
            for (var linkId in this._maze.links) {
                var link = this._maze.links[linkId];
                var linkDir = this.linkDirections[linkId];
                if (linkDir == undefined) {
                    throw new Error("Link " + linkId + " has no direction");
                }
                var needsOwnRoom = false;
                for (var k in link.locks)
                    needsOwnRoom = true;
                var span0Id = nodeProtoRoomSpans[link.endpoint0.nodeId].id;
                var span1Id = nodeProtoRoomSpans[link.endpoint1.nodeId].id;
                var span2Id = void 0, span3Id = void 0;
                if (needsOwnRoom) {
                    var linkSpan = this.generateLinkSpan(link, link.locks);
                    this.protoRoomSpans[linkSpan.id] = linkSpan;
                    span2Id = span3Id = linkSpan.id;
                }
                else {
                    span2Id = span1Id;
                    span3Id = span0Id;
                }
                this.connectSpans(span0Id, linkDir, span2Id, link.allowsForwardMovement && link.allowsBackwardMovement);
                if (span2Id != span1Id)
                    this.connectSpans(span1Id, oppositeDirection(linkDir), span3Id, link.allowsForwardMovement && link.allowsBackwardMovement);
            }
            for (var spanId in this.protoRoomSpans) {
                var span = this.protoRoomSpans[spanId];
                this.protoRoomSpanToWorldRooms(span);
            }
            var span0 = nodeProtoRoomSpans[startNodeId];
            for (var r in span0.protoRooms) {
                return span0.protoRooms[r].id;
            }
            throw new Error("No start room??");
        };
        return GraphWorldifier;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = GraphWorldifier;
    function mazeToWorld(worldifier) {
        var gdm = worldifier.gameDataManager;
        return dat.initData(gdm).then(function () { return gdm.fetchHardRef(dat.tileEntityPaletteId); }).then(function (tepRef) {
            //const worldifier:GraphWorldifier = new GraphWorldifier(gdm, maze);
            worldifier.tileEntityPaletteRef = tepRef;
            return worldifier;
        }).then(function (worldifier) {
            var startRoomRef = worldifier.run();
            /*
            const startRoom = gdm.getMutableRoom(startRoomRef)
            startRoom.roomEntities[dat.primarySpawnPointEntityId] = {
                position: {x:1.5,y:0.5,z:0},
                entity: {
                    id: dat.playerEntityId,
                    classRef: dat.spawnPointEntityClassId,
                }
            }
            */
            return { gdm: gdm, playerId: dat.playerEntityId, startRoomRef: startRoomRef };
        });
    }
    exports.mazeToWorld = mazeToWorld;
    if (typeof require != 'undefined' && typeof module != 'undefined' && require.main === module) {
        var readStream = function (s) {
            return new Promise(function (resolve, reject) {
                var parts = [];
                s.on('data', function (dat) { return parts.push(dat); });
                s.on('end', function () { return resolve(parts); });
                s.on('error', function (err) { return reject(err); });
                s.read();
            });
        };
        var dataIdent = index_9.sha1Urn;
        var ds = HTTPHashDatastore_4.default.createDefault();
        var gdm_2 = new GameDataManager_3.default(ds);
        readStream(process.stdin).then(function (parts) {
            var maze = JSON.parse(parts.join(""));
            var worldifier = new GraphWorldifier(gdm_2, maze);
            return mazeToWorld(worldifier);
        }).then(function (_a) {
            var gdm = _a.gdm, playerId = _a.playerId, startRoomRef = _a.startRoomRef;
            gdm.flushUpdates().then(function (rootNodeUri) {
                if (gdm.getObjectIfLoaded(startRoomRef) == undefined) {
                    throw new Error("Failed to find start room in " + rootNodeUri);
                }
                var sg = {
                    gameDataRef: rootNodeUri,
                    playerId: dat.playerEntityId,
                    rootRoomId: startRoomRef,
                };
                return gdm.storeObject(sg);
            }).then(function (saveRef) {
                console.log(saveRef);
            });
        }).catch(function (err) {
            console.error("Error! ", err);
            process.exit(1);
        });
    }
    var _a;
});
define("togos-game21/simulationmessaging", ["require", "exports"], function (require, exports) {
    "use strict";
    function entityPathToString(path) {
        // TODO: Don't encode ":"
        return "g21-item://" + path.map(encodeURIComponent).join("/");
    }
    exports.entityPathToString = entityPathToString;
    exports.ROOMID_FINDENTITY = 'find-entity'; // Wherever the entity is
    exports.ROOMID_SIMULATOR = 'simulator'; // The simulation itself (entity ID ignored?)
    exports.ROOMID_EXTERNAL = 'external'; // For referring to recipients outside the simulation
    exports.XMSN_SPACE = "http://ns.nuke24.net/Game21/TransmissionMedia/Space";
    exports.XMSN_COPPER = "http://ns.nuke24.net/Game21/TransmissionMedia/Copper";
    exports.CHAN_ANALOG_1 = 1;
    exports.CHAN_ANALOG_2 = 2;
    // More analog channels?
    exports.CHAN_ETHERNET = 8023; // Data assumed to be Ethernet Type II frames
    var _a;
});
define("togos-game21/Maze1", ["require", "exports", "tshash/index", "togos-game21/HTTPHashDatastore", "togos-game21/MemoryDatastore", "togos-game21/CachingDatastore", "togos-game21/BrowserStorageDatastore", "togos-game21/MultiDatastore", "togos-game21/promises", "togos-game21/DeepFreezer", "togos-game21/GameDataManager", "togos-game21/JSONObjectDatastore", "togos-game21/vector3ds", "togos-game21/graphmaze/picking", "togos-game21/vector3dmath", "togos-game21/aabbs", "togos-game21/Quaternion", "togos-game21/TransformationMatrix3D", "togos-game21/SceneShader", "tshash/uuids", "togos-game21/worldutil", "togos-game21/maze1demodata", "togos-game21/http", "togos-game21/world", "togos-game21/images", "togos-game21/tiletrees", "togos-game21/forth/Tokenizer", "togos-game21/forth/Token", "togos-game21/MultiLogger", "togos-game21/ui/DOMLogger", "togos-game21/ui/TilePalette", "togos-game21/ui/inventory", "togos-game21/ui/SoundPlayer", "togos-game21/graphmaze", "togos-game21/graphmaze/GraphMazeGenerator2", "togos-game21/graphmaze/GraphWorldifier", "togos-game21/simulationmessaging"], function (require, exports, index_10, HTTPHashDatastore_5, MemoryDatastore_3, CachingDatastore_1, BrowserStorageDatastore_2, MultiDatastore_1, promises_5, DeepFreezer_18, GameDataManager_4, JSONObjectDatastore_3, vector3ds_17, picking_3, vector3dmath_12, aabbs_8, Quaternion_6, TransformationMatrix3D_3, SceneShader_2, uuids_2, worldutil_5, dat, http, world_7, images_1, tiletrees_1, Tokenizer_2, Token_5, MultiLogger_1, DOMLogger_1, TilePalette_1, inventory_1, SoundPlayer_1, graphmaze_3, GraphMazeGenerator2_1, GraphWorldifier_1, simulationmessaging_1) {
    "use strict";
    var UI_ENTIY_PATH = [simulationmessaging_1.ROOMID_EXTERNAL, "demo UI"];
    // KeyEvent isn't always available, boo.
    var KEY_CTRL = 17;
    var KEY_ESC = 27;
    var KEY_UP = 38;
    var KEY_DOWN = 40;
    var KEY_ENTER = 13;
    var KEY_TAB = 9;
    var KEY_SLASH = 191;
    var KEY_BACKTICK = 192;
    var KEY_0 = 48;
    var KEY_9 = 57;
    function entityMessageDataPath(emd) {
        return "" + emd[0];
    }
    function base64Encode(data) {
        // btoa is kinda goofy.
        var strs = new Array(data.length);
        for (var i = data.length - 1; i >= 0; --i)
            strs[i] = String.fromCharCode(data[i]);
        return btoa(strs.join(""));
    }
    function newUuidRef() { return uuids_2.uuidUrn(uuids_2.newType4Uuid()); }
    function hexVal(charCode) {
        switch (charCode) {
            case 0x30: return 0;
            case 0x31: return 1;
            case 0x32: return 2;
            case 0x33: return 3;
            case 0x34: return 4;
            case 0x35: return 5;
            case 0x36: return 6;
            case 0x37: return 7;
            case 0x38: return 8;
            case 0x39: return 9;
            case 0x41:
            case 0x61: return 10;
            case 0x42:
            case 0x62: return 11;
            case 0x43:
            case 0x63: return 12;
            case 0x44:
            case 0x64: return 13;
            case 0x45:
            case 0x65: return 14;
            case 0x46:
            case 0x66: return 15;
            default: throw new Error("Invalid hex digit: " + String.fromCharCode(charCode));
        }
    }
    function hexDecodeBits(enc) {
        var arr = new Array(enc.length * 4);
        for (var i = 0; i < enc.length; ++i) {
            var n = hexVal(enc.charCodeAt(i));
            arr[i * 4 + 0] = (n >> 3) & 1;
            arr[i * 4 + 1] = (n >> 2) & 1;
            arr[i * 4 + 2] = (n >> 1) & 1;
            arr[i * 4 + 3] = (n >> 0) & 1;
        }
        return arr;
    }
    function numberToFillStyle(col) {
        return 'rgba(' +
            ((col >> 24) & 0xFF) + ',' +
            ((col >> 16) & 0xFF) + ',' +
            ((col >> 8) & 0xFF) + ',' +
            (((col >> 0) & 0xFF) / 255) + ')';
    }
    function parseOneBitImageDataToDataUrl(enc, w, h, color0, color1) {
        var pixDat = hexDecodeBits(enc);
        var canv = document.createElement('canvas');
        canv.width = w;
        canv.height = h;
        var ctx = canv.getContext('2d');
        if (ctx == null)
            throw new Error("No ctx from canvas!");
        var prevColor = null;
        for (var i = 0, y = 0; y < h; ++y) {
            for (var x = 0; x < w; ++x, ++i) {
                var col = pixDat[i] ? color1 : color0;
                if (col != prevColor)
                    ctx.fillStyle = numberToFillStyle(col);
                ctx.fillRect(x, y, 1, 1);
                prevColor = col;
            }
        }
        return canv.toDataURL();
    }
    var oneBitImageDataRegex = /^bitimg:([^,]+),([0-9a-f]+)$/;
    function parseBitImg(m) {
        var modStrs = m[1].split(';');
        var bitStr = m[2];
        var modVals = {}; // Actually strings!  But any makes |0 happy.
        var length = bitStr.length * 4;
        var defaultWidth = Math.sqrt(length), defaultHeight = length / defaultWidth;
        for (var i = 0; i < modStrs.length; ++i) {
            var p = modStrs[i].split('=', 2);
            if (p.length == 2) {
                var v = p[1];
                if (v[0] == '0' && v[1] == 'x') {
                    v = parseInt(v.substr(2, 16));
                }
                modVals[p[0]] = v;
            }
        }
        return {
            bitstr: bitStr,
            color0: modVals['color0'] | 0,
            color1: modVals['color1'] | 0,
            width: modVals['width'] | 0 || defaultWidth,
            height: modVals['height'] | 0 || defaultHeight
        };
    }
    var EntityImageManager = (function () {
        // Note that this all needs to be completely rewritten
        // in order to deal with non-bitimg: icons
        // and to take state, time, orientation into account
        function EntityImageManager(gameDataManager) {
            this.gameDataManager = gameDataManager;
            this.urlishImageCache = {};
            this.iconCache = {};
            this.iconPromises = {};
        }
        EntityImageManager.prototype.getUrlishImage = function (ref) {
            if (this.urlishImageCache[ref])
                return this.urlishImageCache[ref];
            var bitImgRee = oneBitImageDataRegex.exec(ref);
            var xRef = ref;
            if (bitImgRee) {
                var bitImgInfo = parseBitImg(bitImgRee);
                xRef = parseOneBitImageDataToDataUrl(bitImgInfo.bitstr, bitImgInfo.width, bitImgInfo.height, bitImgInfo.color0, bitImgInfo.color1);
            }
            else {
                throw new Error(ref + " not parse!");
            }
            return this.urlishImageCache[ref] = xRef;
        };
        EntityImageManager.prototype.getIconIfLoaded = function (visualRef, state, time, orientation, preferredResolution, initiateFetch) {
            if (initiateFetch === void 0) { initiateFetch = false; }
            if (this.iconCache[visualRef])
                return this.iconCache[visualRef];
            if (initiateFetch)
                this.fetchIcon(visualRef, state, time, orientation, preferredResolution);
            return undefined;
        };
        EntityImageManager.prototype.fetchImage = function (srcRef) {
            var img = images_1.imageFromUrl(srcRef);
            if (img.width == 0) {
                return new Promise(function (resolve, reject) {
                    img.addEventListener('load', function (loadEvent) {
                        resolve(img);
                    });
                    setTimeout(function () { reject("Timed out while waiting for image " + srcRef + " to load"); }, 2000);
                });
            }
            else {
                return Promise.resolve(img);
            }
        };
        EntityImageManager.prototype.fetchIcon = function (visualRef, state, time, orientation, preferredResolution) {
            var _this = this;
            if (this.iconPromises[visualRef])
                return this.iconPromises[visualRef];
            var imgRef = this.getUrlishImage(visualRef);
            return this.iconPromises[visualRef] = this.fetchImage(imgRef).then(function (img) {
                return _this.iconCache[visualRef] = {
                    sheetRef: imgRef,
                    sheet: img,
                    origin: vector3ds_17.makeVector(img.width / 2, img.height / 2, 0),
                    resolution: 16,
                    bounds: aabbs_8.makeAabb(0, 0, 0, img.width, img.height, 0)
                };
            });
            //return Promise.resolve(this.getIcon(visualRef, state, time, orientation, preferredResolution));
        };
        EntityImageManager.prototype.fetchEntityIcon = function (entity, time, orientation, preferredResolution) {
            var _this = this;
            return this.gameDataManager.fetchObject(entity.classRef).then(function (entityClass) {
                if (!entityClass.visualRef)
                    return Promise.resolve(images_1.EMPTY_IMAGE_SLICE);
                return _this.fetchIcon(entityClass.visualRef, entity.state || {}, time, orientation, preferredResolution);
            });
        };
        return EntityImageManager;
    }());
    var MazeView = (function () {
        function MazeView(canvas) {
            this.canvas = canvas;
            this._viewage = { visualEntities: [] };
            this.ppm = 16;
            this.occlusionFillStyle = 'rgba(96,64,64,1)';
            this.redrawRequested = false;
        }
        Object.defineProperty(MazeView.prototype, "screenCenterX", {
            get: function () { return this.canvas.width / 2; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(MazeView.prototype, "screenCenterY", {
            get: function () { return this.canvas.height / 2; },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(MazeView.prototype, "gameDataManager", {
            set: function (gdm) {
                this._gameDataManager = gdm;
                this._entityImageManager = new EntityImageManager(gdm);
            },
            enumerable: true,
            configurable: true
        });
        MazeView.prototype.getTileEntityAt = function (coords, tileSize) {
            if (tileSize === void 0) { tileSize = 1; }
            var closestMatchValue = 0;
            var closestMatch = undefined;
            var viewItems = this._viewage.visualEntities;
            for (var i in viewItems) {
                var vi = viewItems[i];
                var te = vi.entity;
                var gdm = this._gameDataManager;
                if (te && gdm) {
                    var ec = gdm.getObjectIfLoaded(te.classRef);
                    if (ec && aabbs_8.offsetAabbContainsVector(vi.position, ec.tilingBoundingBox, coords)) {
                        var matchValue = 1;
                        if (ec.tilingBoundingBox.maxX - ec.tilingBoundingBox.minX == tileSize) {
                            ++matchValue;
                        }
                        if (matchValue > closestMatchValue) {
                            closestMatch = {
                                orientation: vi.orientation || Quaternion_6.default.IDENTITY,
                                entity: te
                            };
                            closestMatchValue = matchValue;
                        }
                    }
                }
            }
            return closestMatch;
        };
        MazeView.prototype.clear = function () {
            var ctx = this.canvas.getContext('2d');
            if (!ctx)
                return;
            ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
        };
        MazeView.prototype.drawRaster = function (rast, minDrawValue, maxDrawValue, fillStyle, drawMargin, borderColor) {
            var ctx = this.canvas.getContext('2d');
            if (!ctx)
                return;
            var cx = this.canvas.width / 2;
            var cy = this.canvas.height / 2;
            var ppm = this.ppm;
            var canvWidth = this.canvas.width;
            var canvHeight = this.canvas.height;
            var vrWidth = rast.width, vrHeight = rast.height;
            var vrData = rast.data;
            ctx.fillStyle = fillStyle;
            if (borderColor) {
                ctx.strokeStyle = borderColor;
                ctx.strokeRect(canvWidth / 2 - rast.originX * ppm, canvHeight / 2 - rast.originY * ppm, rast.width * ppm / rast.resolution, rast.height * ppm / rast.resolution);
            }
            if (drawMargin) {
                var rastMinPx = canvWidth / 2 - (rast.originX * ppm);
                var rastMinPy = canvHeight / 2 - (rast.originY * ppm);
                var mx0 = Math.max(0, rastMinPx);
                var my0 = Math.max(0, rastMinPy);
                var mx1 = Math.min(canvWidth, rastMinPx + (rast.width / rast.resolution) * ppm);
                var my1 = Math.min(canvHeight, rastMinPy + (rast.height / rast.resolution) * ppm);
                ctx.fillRect(0, 0, canvWidth, my0); // Top
                ctx.fillRect(0, my1, canvWidth, canvHeight - my0); // Bottom
                ctx.fillRect(0, my0, mx0, my1 - my0); // Left
                ctx.fillRect(mx1, my0, canvWidth - mx1, my1 - my0); // Right
            }
            var i, y;
            var fillFog = function (x0, x1) {
                ctx.fillRect(cx + ppm * (x0 / rast.resolution - rast.originX), cy + ppm * (y / rast.resolution - rast.originY), ppm * (x1 - x0) / rast.resolution, ppm / rast.resolution);
            };
            var showValue = false; // Turn to true for debuggin'
            if (showValue)
                ctx.strokeStyle = '#F0F'; // For le debug text
            for (i = 0, y = 0; y < vrHeight; ++y) {
                var spanStart = null;
                for (var x = 0; x < vrWidth; ++x, ++i) {
                    if (vrData[i] >= minDrawValue && vrData[i] <= maxDrawValue) {
                        if (spanStart == null)
                            spanStart = x;
                    }
                    else if (spanStart != null) {
                        fillFog(spanStart, x);
                        spanStart = null;
                    }
                    if (showValue)
                        ctx.strokeText("" + (vrData[i] > 9 ? 9 : vrData[i]), cx + ppm * (x / rast.resolution - rast.originX), 8 + cy + ppm * (y / rast.resolution - rast.originY));
                }
                if (spanStart != null) {
                    fillFog(spanStart, vrWidth);
                }
            }
        };
        MazeView.prototype.drawOcclusionFog = function (viz) {
            this.drawRaster(viz, SceneShader_2.VISIBILITY_VOID, SceneShader_2.VISIBILITY_NONE, this.occlusionFillStyle, true);
        };
        MazeView.prototype.draw = function () {
            var ctx = this.canvas.getContext('2d');
            if (!ctx)
                return;
            var eim = this._entityImageManager;
            var cx = this.canvas.width / 2;
            var cy = this.canvas.height / 2;
            var ppm = 16;
            if (eim)
                for (var i in this._viewage.visualEntities) {
                    var item = this._viewage.visualEntities[i];
                    var time = 0;
                    if (!item.visualRef)
                        continue;
                    var icon = eim.getIconIfLoaded(item.visualRef, item.state, time, item.orientation || Quaternion_6.default.IDENTITY, 16, true);
                    if (icon == null)
                        continue;
                    var px = item.position.x * ppm + cx;
                    var py = item.position.y * ppm + cy;
                    var iconScale = ppm / icon.resolution;
                    ctx.drawImage(icon.sheet, icon.bounds.minX, icon.bounds.minY, aabbs_8.aabbWidth(icon.bounds), aabbs_8.aabbHeight(icon.bounds), px + iconScale * (icon.bounds.minX - icon.origin.x), py + iconScale * (icon.bounds.minY - icon.origin.y), iconScale * aabbs_8.aabbWidth(icon.bounds), iconScale * aabbs_8.aabbHeight(icon.bounds));
                }
            if (this._viewage.visibility)
                this.drawOcclusionFog(this._viewage.visibility);
        };
        MazeView.prototype.requestRedraw = function () {
            var _this = this;
            if (this.redrawRequested)
                return;
            this.redrawRequested = true;
            // TODO: Skip drawing if not in viewport (but make sure it gets drawn when it is visible again!)
            window.requestAnimationFrame(function () {
                _this.redrawRequested = false;
                _this.clear();
                _this.draw();
            });
        };
        Object.defineProperty(MazeView.prototype, "viewage", {
            get: function () { return this._viewage; },
            set: function (v) {
                this._viewage = v;
                this.requestRedraw();
            },
            enumerable: true,
            configurable: true
        });
        MazeView.prototype.canvasPixelToWorldCoordinates = function (x, y, dest) {
            var pdx = x - this.screenCenterX, pdy = y - this.screenCenterY;
            var ppm = this.ppm;
            return vector3ds_17.setVector(dest, pdx / ppm, pdy / ppm, 0);
        };
        return MazeView;
    }());
    exports.MazeView = MazeView;
    function roomToMazeViewage(roomRef, roomPosition, gdm, viewage, visibility, includeGreatInfo) {
        var room = gdm.getRoom(roomRef);
        if (room == null)
            throw new Error("Failed to load room " + roomRef);
        var _entityToMazeViewage = function (entity, position, orientation) { };
        _entityToMazeViewage = function (entity, position, orientation) {
            var entityClass = gdm.getEntityClass(entity.classRef);
            if (entityClass == null)
                throw new Error("Failed to load entity class " + entity.classRef);
            if (entityClass.visualRef) {
                var minVrX = Math.max(0, Math.floor((position.x + entityClass.visualBoundingBox.minX + visibility.originX) * visibility.resolution));
                var minVrY = Math.max(0, Math.floor((position.y + entityClass.visualBoundingBox.minY + visibility.originY) * visibility.resolution));
                var maxVrX = Math.min(visibility.width, Math.ceil((position.x + entityClass.visualBoundingBox.maxX + visibility.originX) * visibility.resolution));
                var maxVrY = Math.min(visibility.height, Math.ceil((position.y + entityClass.visualBoundingBox.maxY + visibility.originY) * visibility.resolution));
                //console.log("Visibility bounds: "+minVrX+","+minVrY+" - "+maxVrX+","+maxVrY);
                var visible = false;
                isVisibleLoop: for (var vry = minVrY; vry < maxVrY; ++vry)
                    for (var vrx = minVrX; vrx < maxVrX; ++vrx) {
                        //console.log("Check bisibility raster@"+vrx+","+vry+"; "+(visibility.width*vry+vrx)+" = "+visibility.data[visibility.width*vry+vrx]);
                        if (visibility.data[visibility.width * vry + vrx] >= SceneShader_2.VISIBILITY_MIN) {
                            visible = true;
                            break isVisibleLoop;
                        }
                    }
                // TODO: Re-use items, visuals
                if (visible)
                    viewage.visualEntities.push({
                        // TODO: Just send position normal,
                        // visual should contain offsets
                        position: {
                            x: position.x + aabbs_8.aabbAverageX(entityClass.visualBoundingBox),
                            y: position.y + aabbs_8.aabbAverageY(entityClass.visualBoundingBox),
                            z: position.z + aabbs_8.aabbAverageZ(entityClass.visualBoundingBox),
                        },
                        orientation: orientation,
                        visualRef: entityClass.visualRef,
                        entity: includeGreatInfo ? entity : undefined,
                    });
            }
            worldutil_5.eachSubEntity(entity, position, gdm, _entityToMazeViewage);
        };
        for (var re in room.roomEntities) {
            var roomEntity = room.roomEntities[re];
            var orientation_2 = roomEntity.orientation ? roomEntity.orientation : Quaternion_6.default.IDENTITY;
            _entityToMazeViewage(roomEntity.entity, vector3dmath_12.addVector(roomPosition, roomEntity.position), orientation_2);
        }
    }
    function sceneToMazeViewage(roomRef, roomPosition, gdm, viewage, visibility, includeGreatInfo) {
        var room = gdm.getRoom(roomRef);
        if (room == null)
            throw new Error("Failed to load room " + roomRef);
        roomToMazeViewage(roomRef, roomPosition, gdm, viewage, visibility, includeGreatInfo);
        for (var n in room.neighbors) {
            var neighb = room.neighbors[n];
            roomToMazeViewage(neighb.roomRef, vector3dmath_12.addVector(roomPosition, neighb.offset), gdm, viewage, visibility, includeGreatInfo);
        }
    }
    var XYZDirection;
    (function (XYZDirection) {
        XYZDirection[XYZDirection["NONE"] = 0] = "NONE";
        XYZDirection[XYZDirection["POSITIVE_X"] = 1] = "POSITIVE_X";
        XYZDirection[XYZDirection["NEGATIVE_X"] = 2] = "NEGATIVE_X";
        XYZDirection[XYZDirection["POSITIVE_Y"] = 4] = "POSITIVE_Y";
        XYZDirection[XYZDirection["NEGATIVE_Y"] = 8] = "NEGATIVE_Y";
        XYZDirection[XYZDirection["POSITIVE_X_POSITIVE_Y"] = 5] = "POSITIVE_X_POSITIVE_Y";
        XYZDirection[XYZDirection["NEGATIVE_X_NEGATIVE_Y"] = 10] = "NEGATIVE_X_NEGATIVE_Y";
        XYZDirection[XYZDirection["NEGATIVE_X_POSITIVE_Y"] = 6] = "NEGATIVE_X_POSITIVE_Y";
        XYZDirection[XYZDirection["POSITIVE_X_NEGATIVE_Y"] = 9] = "POSITIVE_X_NEGATIVE_Y";
        // Fill these in as needed
        XYZDirection[XYZDirection["POSITIVE_Z"] = 16] = "POSITIVE_Z";
        XYZDirection[XYZDirection["NEGATIVE_Z"] = 32] = "NEGATIVE_Z";
    })(XYZDirection || (XYZDirection = {}));
    ;
    var xyzDirectionVectors = {};
    {
        // encode component
        var ec = function (i) {
            return i == 0 ? 0 : i > 0 ? 1 : 2;
        };
        for (var z = -1; z <= 1; ++z) {
            for (var y = -1; y <= 1; ++y) {
                for (var x = -1; x <= 1; ++x) {
                    var xyzDirection = (ec(x)) | (ec(y) << 2) | (ec(z) << 4);
                    xyzDirectionVectors[xyzDirection] = xyzDirection == 0 ? vector3ds_17.ZERO_VECTOR : vector3ds_17.makeVector(x, y, z);
                }
            }
        }
    }
    var sideDirections = [
        XYZDirection.POSITIVE_X,
        XYZDirection.POSITIVE_Y,
        XYZDirection.POSITIVE_Z,
        XYZDirection.NEGATIVE_X,
        XYZDirection.NEGATIVE_Y,
        XYZDirection.NEGATIVE_Z,
    ];
    var ALL_SIDES = 0x3F;
    var entityPositionBuffer = vector3ds_17.makeVector(0, 0, 0);
    var rotate45Clockwise = DeepFreezer_18.deepFreeze(TransformationMatrix3D_3.default.fromXYZAxisAngle(0, 0, 1, +Math.PI / 4));
    var rotate45CounterClockwise = DeepFreezer_18.deepFreeze(TransformationMatrix3D_3.default.fromXYZAxisAngle(0, 0, 1, -Math.PI / 4));
    var movementAttemptTransforms = [
        TransformationMatrix3D_3.default.IDENTITY,
        rotate45Clockwise,
        rotate45CounterClockwise
    ];
    function entityVelocity(roomEntity) {
        return roomEntity.velocity || vector3ds_17.ZERO_VECTOR;
    }
    function entityMass(entityClass) {
        return entityClass.mass == null ? Infinity : entityClass.mass;
    }
    function bounceFactor(ec0, ec1) {
        var bf0 = ec0.bounciness == null ? 0.5 : ec0.bounciness;
        var bf1 = ec1.bounciness == null ? 0.5 : ec1.bounciness;
        return bf0 * bf1;
    }
    function oneify(val) {
        return val == 0 ? 0 : val > 0 ? 1 : -1;
    }
    function clampAbs(val, maxAbs) {
        if (val > maxAbs)
            return maxAbs;
        if (val < -maxAbs)
            return -maxAbs;
        return val;
    }
    function directionate(dir, current) {
        if (dir > 0 && current > 0)
            return current;
        if (dir < 0 && current < 0)
            return current;
        return current;
    }
    function directionateVector(desired, current) {
        return {
            x: directionate(desired.x, current.x),
            y: directionate(desired.y, current.y),
            z: directionate(desired.z, current.z),
        };
    }
    /**
     * Calculate the impulse that entity A should exert onto entity B
     * in order to affect the desired change in B's relative velocity, dv.
     */
    function dvImpulse(desiredDv, entityAMass, entityBMass, maxImpulseMagnitude, multiplier) {
        if (multiplier === void 0) { multiplier = 1; }
        if (entityAMass == null)
            entityAMass = Infinity;
        if (entityBMass == null)
            entityBMass = Infinity;
        var minMass = Math.min(entityAMass, entityBMass);
        if (minMass == Infinity) {
            // maximum impulse!
            return vector3dmath_12.normalizeVector(desiredDv, maxImpulseMagnitude * multiplier);
        }
        var desiredImpulse = vector3dmath_12.scaleVector(desiredDv, minMass);
        var desiredImpulseMagnitude = vector3dmath_12.vectorLength(desiredImpulse);
        if (desiredImpulseMagnitude > maxImpulseMagnitude) {
            multiplier *= maxImpulseMagnitude / desiredImpulseMagnitude;
        }
        return vector3dmath_12.scaleVector(desiredImpulse, multiplier);
    }
    function impulseForAtLeastDesiredVelocity(desiredRelativeVelocity, currentRelativeVelocity, entityAMass, entityBMass, maxSpeed, maxImpulse, multiplier) {
        if (multiplier === void 0) { multiplier = 1; }
        var targetRelativeVelocity = vector3dmath_12.normalizeVector(desiredRelativeVelocity, maxSpeed);
        var targetDeltaVelocity = directionateVector(desiredRelativeVelocity, vector3dmath_12.subtractVector(targetRelativeVelocity, currentRelativeVelocity));
        return dvImpulse(targetDeltaVelocity, entityAMass, entityBMass, maxImpulse, multiplier);
    }
    function perpendicularPart(vec, perpendicularTo) {
        var perpendicularLength = vector3dmath_12.vectorLength(perpendicularTo);
        if (perpendicularLength == 0)
            return vec;
        return vector3dmath_12.subtractVector(vec, vector3dmath_12.scaleVector(perpendicularTo, vector3dmath_12.dotProduct(vec, perpendicularTo) / perpendicularLength));
    }
    var MazeGamePhysics = (function () {
        function MazeGamePhysics(game) {
            this.game = game;
            this.activeRoomIds = {};
            this.activatedRoomIds = {};
            this.snapGridSize = 1 / 8;
        }
        MazeGamePhysics.prototype.induceVelocityChange = function (roomId, entityId, roomEntity, dv) {
            if (vector3dmath_12.vectorIsZero(dv))
                return; // Save ourselves a little bit of work
            roomEntity.velocity = vector3dmath_12.addVector(entityVelocity(roomEntity), dv);
            this.activatedRoomIds[roomId] = roomId;
        };
        MazeGamePhysics.prototype.registerReactionlessImpulse = function (roomId, entityId, roomEntity, impulse) {
            var entityClass = this.game.gameDataManager.getEntityClass(roomEntity.entity.classRef);
            var mass = entityMass(entityClass);
            if (mass == Infinity)
                return; // Nothing's going to happen
            this.induceVelocityChange(roomId, entityId, roomEntity, vector3dmath_12.scaleVector(impulse, -1 / mass));
        };
        MazeGamePhysics.prototype.registerImpulse = function (eARoomId, entityAId, entityA, eBRoomId, entityBId, entityB, impulse) {
            if (vector3dmath_12.vectorIsZero(impulse))
                return; // Save ourselves a little bit of work
            var eAClass = this.game.gameDataManager.getEntityClass(entityA.entity.classRef);
            var eBClass = this.game.gameDataManager.getEntityClass(entityB.entity.classRef);
            var eAMass = entityMass(eAClass);
            var eBMass = entityMass(eBClass);
            if (eAMass == Infinity && eBMass == Infinity)
                return; // Nothing's going to happen
            var eAVel = entityVelocity(entityA);
            var eBVel = entityVelocity(entityB);
            var systemMass;
            var aRat, bRat;
            //let systemVelocity:Vector3D;
            if (eAMass == Infinity) {
                systemMass = Infinity;
                aRat = 0;
                bRat = 1;
            }
            else if (eBMass == Infinity) {
                systemMass = Infinity;
                aRat = 1;
                bRat = 0;
            }
            else {
                systemMass = eAMass + eBMass;
                aRat = (systemMass - eAMass) / systemMass;
                bRat = (systemMass - eBMass) / systemMass;
            }
            var relativeDv = vector3dmath_12.scaleVector(impulse, 1 / eBMass + 1 / eAMass);
            //const eADv = scaleVector(impulse, -1/eAMass);
            if (aRat != 0)
                this.induceVelocityChange(eARoomId, entityAId, entityA, vector3dmath_12.scaleVector(relativeDv, -aRat));
            if (bRat != 0)
                this.induceVelocityChange(eBRoomId, entityBId, entityB, vector3dmath_12.scaleVector(relativeDv, +bRat));
        };
        MazeGamePhysics.prototype.drainEnergy = function (entity, drain) {
            if (entity.storedEnergy == undefined)
                return drain;
            //if( entity.storedEnergy == 0 ) return 0;
            drain = Math.min(entity.storedEnergy, drain);
            entity.storedEnergy -= drain;
            return drain;
        };
        MazeGamePhysics.prototype.attemptInducedImpulse = function (eARoomId, entityAId, entityA, eBRoomId, entityBId, entityB, impulse) {
            var requiredEnergy = vector3dmath_12.vectorLength(impulse); // TODO: I don't think that's right.
            var availableEnergy = this.drainEnergy(entityA.entity, requiredEnergy);
            // TODO: Calculate actual impulse from available energy
            var adjustedImpulse = vector3dmath_12.normalizeVector(impulse, availableEnergy);
            this.registerImpulse(eARoomId, entityAId, entityA, eBRoomId, entityBId, entityB, adjustedImpulse);
            return true;
        };
        MazeGamePhysics.prototype.applyCollisions = function () {
            for (var collEntityAId in this.collisions) {
                for (var collEntityBId in this.collisions[collEntityAId]) {
                    var collision = this.collisions[collEntityAId][collEntityBId];
                    var eAClass = this.game.gameDataManager.getEntityClass(collision.roomEntityA.entity.classRef);
                    var eBClass = this.game.gameDataManager.getEntityClass(collision.roomEntityB.entity.classRef);
                    // TODO: Figure out collision physics better?
                    var theBounceFactor = bounceFactor(eAClass, eBClass);
                    var stopImpulse = vector3dmath_12.scaleVector(collision.velocity, Math.min(entityMass(eAClass), entityMass(eBClass)));
                    var bounceImpulse = vector3dmath_12.scaleVector(stopImpulse, theBounceFactor);
                    var eAVel = collision.roomEntityA.velocity || vector3ds_17.ZERO_VECTOR;
                    var eBVel = collision.roomEntityB.velocity || vector3ds_17.ZERO_VECTOR;
                    var eAPerpVel = perpendicularPart(eAVel, collision.velocity);
                    var eBPerpVel = perpendicularPart(eBVel, collision.velocity);
                    var frictionImpulse = vector3dmath_12.normalizeVector(vector3dmath_12.subtractVector(eAPerpVel, eBPerpVel), Math.max(eAClass.coefficientOfFriction || 0.25, eBClass.coefficientOfFriction || 0.25) *
                        vector3dmath_12.vectorLength(stopImpulse) *
                        Math.max(0, 1 - theBounceFactor));
                    var totalImpulse = { x: 0, y: 0, z: 0 };
                    vector3dmath_12.accumulateVector(stopImpulse, totalImpulse);
                    vector3dmath_12.accumulateVector(bounceImpulse, totalImpulse);
                    vector3dmath_12.accumulateVector(frictionImpulse, totalImpulse);
                    this.registerImpulse(collision.roomAId, collEntityAId, collision.roomEntityA, collision.roomBId, collEntityBId, collision.roomEntityB, totalImpulse);
                }
            }
            this.collisions = {};
        };
        MazeGamePhysics.prototype.registerCollision = function (roomAId, eAId, eA, roomBId, eBId, eB, velocity) {
            if (eAId > eBId) {
                return this.registerCollision(roomBId, eBId, eB, roomAId, eAId, eA, vector3dmath_12.scaleVector(velocity, -1));
            }
            if (!this.collisions[eAId])
                this.collisions[eAId] = {};
            var already = this.collisions[eAId][eBId];
            if (already && vector3dmath_12.vectorLength(already.velocity) > vector3dmath_12.vectorLength(velocity))
                return;
            this.collisions[eAId][eBId] = {
                roomAId: roomAId,
                roomEntityA: eA,
                roomBId: roomBId,
                roomEntityB: eB,
                velocity: velocity
            };
        };
        MazeGamePhysics.prototype.borderingCuboid = function (roomRef, bb, dir, gridSize) {
            var minX = bb.minX, maxX = bb.maxX;
            var minY = bb.minY, maxY = bb.maxY;
            var minZ = bb.minZ, maxZ = bb.maxZ;
            if (dir.x < 0) {
                maxX = minX;
                minX -= gridSize;
            }
            else if (dir.x > 0) {
                minX = maxX;
                maxX += gridSize;
            }
            if (dir.y < 0) {
                maxY = minY;
                minY -= gridSize;
            }
            else if (dir.y > 0) {
                minY = maxY;
                maxY += gridSize;
            }
            if (dir.z < 0) {
                maxZ = minZ;
                minZ -= gridSize;
            }
            else if (dir.z > 0) {
                minZ = maxZ;
                maxZ += gridSize;
            }
            return aabbs_8.makeAabb(minX, minY, minZ, maxX, maxY, maxZ);
        };
        MazeGamePhysics.prototype.borderingEntities = function (roomRef, pos, bb, dir, gridSize, filter) {
            var border = this.borderingCuboid(roomRef, bb, dir, gridSize);
            return this.game.entitiesAt(roomRef, pos, border, filter);
        };
        MazeGamePhysics.prototype.massivestCollision = function (collisions) {
            var maxMass = 0;
            var massivest = undefined;
            for (var c in collisions) {
                var coll = collisions[c];
                var entityClass = this.game.gameDataManager.getEntityClass(coll.roomEntity.entity.classRef);
                var mass = entityMass(entityClass);
                if (mass > maxMass) {
                    maxMass = mass;
                    massivest = coll;
                }
            }
            return massivest;
        };
        /**
         * Finds the most massive (interactive, rigid) object in the space specified
         */
        MazeGamePhysics.prototype.massivestBorderingEntity = function (roomRef, pos, bb, dir, gridSize, filter) {
            return this.massivestCollision(this.borderingEntities(roomRef, pos, bb, dir, gridSize, filter));
        };
        MazeGamePhysics.prototype.neighboringEntities = function (roomRef, pos, bb, sideMask, gridSize, filter) {
            var neighbors = {};
            for (var d in sideDirections) {
                var xyzDir = sideDirections[d];
                if (((+xyzDir) & sideMask) == 0)
                    continue;
                var vec = xyzDirectionVectors[xyzDir];
                neighbors[xyzDir] = this.borderingEntities(roomRef, pos, bb, vec, gridSize, filter);
            }
            return neighbors;
        };
        /**
         * What's around the entity?
         */
        MazeGamePhysics.prototype.entityBounceBox = function (roomRef, pos, bb, sideMask, gridSize, filter) {
            var bounceBox = {};
            for (var d in sideDirections) {
                var xyzDir = sideDirections[d];
                if (((+xyzDir) & sideMask) == 0)
                    continue;
                var vec = xyzDirectionVectors[xyzDir];
                bounceBox[xyzDir] = this.massivestBorderingEntity(roomRef, pos, bb, vec, gridSize, filter);
            }
            return bounceBox;
        };
        MazeGamePhysics.prototype.updateEntities = function (interval) {
            var game = this.game;
            var gdm = game.gameDataManager;
            /** lesser object ID => greater object ID => force exerted from lesser to greater */
            var gravRef = "gravity";
            var gravDv = vector3ds_17.makeVector(0, 10 * interval, 0);
            var rooms = game.activeRooms;
            var maxWalkForce = 450; // ~100 pounds of force?
            var entitiesToMove = [];
            var snapGridSize = this.snapGridSize;
            // Auto pickups!  And door opens.  And death.
            for (var r in this.activeRoomIds) {
                var room = rooms[r];
                for (var re in room.roomEntities) {
                    var roomEntity = room.roomEntities[re];
                    var entity = roomEntity.entity;
                    var reVel = roomEntity.velocity || vector3ds_17.ZERO_VECTOR;
                    if (entity.classRef == dat.playerEntityClassId && entity.storedEnergy < 1) {
                        this.game.killRoomEntity(r, re);
                    }
                    if (!entity.desiresMaze1AutoActivation)
                        continue;
                    var entityClass = gdm.getEntityClass(entity.classRef);
                    var pickupFilter = function (roomEntityId, roomEntity, entity, _entityClass) {
                        return _entityClass.structureType != world_7.StructureType.INDIVIDUAL ? undefined :
                            _entityClass.isMaze1AutoPickup || _entityClass.cheapMaze1DoorKeyClassRef != undefined;
                    };
                    var eBb = entityClass.physicalBoundingBox;
                    var pickupBb = aabbs_8.makeAabb(eBb.minX - snapGridSize, eBb.minY - snapGridSize, eBb.minZ - snapGridSize, eBb.maxX + snapGridSize, eBb.maxY + snapGridSize, eBb.maxZ + snapGridSize);
                    var foundIois = this.game.entitiesAt(r, roomEntity.position, pickupBb, pickupFilter);
                    checkIois: for (var p in foundIois) {
                        var foundIoi = foundIois[p];
                        if (foundIoi.roomRef == r &&
                            vector3dmath_12.dotProduct(vector3dmath_12.subtractVector(foundIoi.entityPosition, roomEntity.position), vector3dmath_12.subtractVector(foundIoi.roomEntity.velocity || vector3ds_17.ZERO_VECTOR, reVel)) > 0) {
                            // If they're moving away from each other, forget it!
                            continue checkIois;
                        }
                        if (foundIoi.entityClass.isMaze1AutoPickup) {
                            var pickedUp = void 0;
                            if (foundIoi.entityClass.isMaze1Edible) {
                                entity.storedEnergy += +foundIoi.entityClass.maze1NutritionalValue;
                                pickedUp = true;
                            }
                            else {
                                var inventorySize = entityClass.maze1InventorySize;
                                if (inventorySize == undefined)
                                    continue checkIois;
                                if (entity.maze1Inventory == undefined)
                                    entity.maze1Inventory = {};
                                var currentItemCount = 0;
                                var leastImportantItemKey = void 0;
                                var leastImportantItemImportance = Infinity;
                                for (var k in entity.maze1Inventory) {
                                    ++currentItemCount;
                                    var itemClass = gdm.getEntityClass(entity.maze1Inventory[k].classRef);
                                    var itemImportance = itemClass.maze1Importance || 0;
                                    if (itemImportance < leastImportantItemImportance) {
                                        leastImportantItemImportance = itemImportance;
                                        leastImportantItemKey = k;
                                    }
                                }
                                if (currentItemCount >= inventorySize) {
                                    if (leastImportantItemKey == undefined) {
                                        console.warn("Can't pick up new item; inventory full and nothing to drop!");
                                        continue checkIois;
                                    }
                                    var foundItemImportance = foundIoi.entityClass.maze1Importance || 0;
                                    if (foundItemImportance < leastImportantItemImportance) {
                                        continue checkIois;
                                    }
                                    var throwDirection = vector3dmath_12.vectorIsZero(reVel) ? { x: 1, y: 0, z: 0 } : vector3dmath_12.normalizeVector(reVel, -1);
                                    var throwStart = vector3dmath_12.addVector(roomEntity.position, vector3dmath_12.normalizeVector(throwDirection, 0.5));
                                    try {
                                        this.game.placeItemSomewhereNear(entity.maze1Inventory[leastImportantItemKey], r, throwStart, throwDirection);
                                    }
                                    catch (err) {
                                        console.log("Couldn't drop less important item:", err);
                                        continue checkIois;
                                    }
                                    delete entity.maze1Inventory[leastImportantItemKey];
                                }
                                entity.maze1Inventory[foundIoi.roomEntityId] = foundIoi.entity;
                                pickedUp = true;
                            }
                            if (pickedUp) {
                                this.game.sendSimpleEventToUi({
                                    classRef: "http://ns.nuke24.net/Game21/SimulationMessage/ItemGot",
                                    itemClassRef: foundIoi.entity.classRef
                                });
                                delete rooms[foundIoi.roomRef].roomEntities[foundIoi.roomEntityId];
                            }
                        }
                        doKey: if (foundIoi.entityClass.cheapMaze1DoorKeyClassRef) {
                            var requiredKeyClass = foundIoi.entityClass.cheapMaze1DoorKeyClassRef;
                            var doorClass = foundIoi.entity.classRef;
                            // Does player have one?
                            if (entity.maze1Inventory) {
                                for (var k in entity.maze1Inventory) {
                                    if (entity.maze1Inventory[k].classRef == requiredKeyClass) {
                                        this.game.destroyCheapDoor(foundIoi.roomRef, foundIoi.entityPosition, doorClass);
                                        break doKey;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            // Collect impulses
            // impulses from previous step are also included.
            for (var r in this.activeRoomIds) {
                var room = rooms[r];
                var _loop_7 = function(re) {
                    var roomEntity = room.roomEntities[re];
                    var entity = roomEntity.entity;
                    var entityClass = gdm.getEntityClass(entity.classRef);
                    if (entityClass.mass == null || entityClass.mass == Infinity) {
                        // This thing ain't going anywhere
                        if (entity.desiredMovementDirection == null) {
                            // Nor is it attempting to apply forces onto anyone else.
                            // So we can skip doing anything with it at all.
                            return "continue";
                        }
                    }
                    // Room's got a possibly active entity in it,
                    // so add to the active rooms list.
                    this_5.activatedRoomIds[r] = r;
                    // TODO: Don't activate room if entity is settled into an unmoving state
                    // (would require activating neighbor rooms when things at edges change, etc)
                    if (entityClass.isAffectedByGravity && entityClass.mass != null && entityClass.mass != Infinity) {
                        this_5.registerReactionlessImpulse(r, re, roomEntity, vector3dmath_12.scaleVector(gravDv, -entityClass.mass));
                    }
                    var otherEntityFilter = function (roomEntityId, roomEntity, entity, _entityClass) {
                        return roomEntityId != re;
                    };
                    var neighbEnts = this_5.neighboringEntities(r, roomEntity.position, entityClass.physicalBoundingBox, ALL_SIDES, snapGridSize, otherEntityFilter);
                    // TODO: Just use neighbEnts rather than querying again.
                    var solidOtherEntityFilter = function (roomEntityId, roomEntity, entity, entityClass) {
                        return roomEntityId != re && entityClass.isSolid !== false;
                    };
                    var floorCollision = this_5.massivestBorderingEntity(r, roomEntity.position, entityClass.physicalBoundingBox, xyzDirectionVectors[XYZDirection.POSITIVE_Y], snapGridSize, solidOtherEntityFilter);
                    /*
                     * Possible forces:
                     * * Gravity pulls everything down
                     * - Entities may push directly off any surfaces (jump)
                     * - Entities may push sideways against surfaces that they are pressed against (e.g. floor)
                     * - Entities may climb along ladders or other climbable things
                     */
                    var dmd = entity.desiredMovementDirection;
                    var climbing = false;
                    var walking = false;
                    if (dmd != null && entityClass.climbingSkill && (floorCollision == null || dmd.y != 0)) {
                        var minClimbability = 1 - entityClass.climbingSkill;
                        var mostClimbable = void 0;
                        var maxClimbability = 0;
                        for (var dir in neighbEnts) {
                            var neighbEnts2 = neighbEnts[dir];
                            for (var e in neighbEnts2) {
                                var climbability = neighbEnts2[e].entityClass.climbability;
                                if (climbability != null && climbability >= minClimbability && climbability >= maxClimbability) {
                                    // Aw yih we can climb that!
                                    // Theoretically we would take direction of movement into account,
                                    // so if you wanted to go up you'd prefer a ladder that's itself moving that way.
                                    mostClimbable = neighbEnts2[e];
                                    maxClimbability = climbability;
                                }
                            }
                        }
                        if (mostClimbable) {
                            climbing = true;
                            var maxClimbForce = entityClass.maxClimbForce || 0;
                            var currentRv = vector3dmath_12.subtractVector(entityVelocity(roomEntity), entityVelocity(mostClimbable.roomEntity));
                            var maxClimbSpeed = entityClass.normalClimbingSpeed || entityClass.normalWalkingSpeed || 0;
                            var climbImpulse = impulseForAtLeastDesiredVelocity(dmd, currentRv, entityClass.mass, gdm.getEntityClass(mostClimbable.roomEntity.entity.classRef).mass, maxClimbSpeed, interval * maxClimbForce, -1);
                            this_5.attemptInducedImpulse(r, re, roomEntity, mostClimbable.roomRef, mostClimbable.roomEntityId, mostClimbable.roomEntity, climbImpulse);
                        }
                    }
                    var onFloor = false;
                    // TODO: Do this in a generic way for any 'walking' entities
                    walk: if (floorCollision && entityVelocity(roomEntity).y - entityVelocity(floorCollision.roomEntity).y >= 0) {
                        onFloor = true;
                        if (dmd == null)
                            break walk;
                        /** Actual velocity relative to surface */
                        var dvx = entityVelocity(roomEntity).x - entityVelocity(floorCollision.roomEntity).x;
                        /** Desired velocity relative to surface */
                        var targetDvx = (entityClass.normalWalkingSpeed || 0) * oneify(dmd.x);
                        /** Desired velocity change */
                        var attemptDdvx = targetDvx - dvx;
                        // Attempt to change to target velocity in single tick
                        var walkForce = clampAbs(-attemptDdvx * entityClass.mass / interval, maxWalkForce);
                        var walkImpulse = { x: walkForce * interval, y: 0, z: 0 };
                        this_5.attemptInducedImpulse(r, re, roomEntity, floorCollision.roomRef, floorCollision.roomEntityId, floorCollision.roomEntity, walkImpulse);
                        if (dmd.y < 0 && entityClass.maxJumpImpulse) {
                            var jumpImpulse = { x: 0, y: entityClass.maxJumpImpulse, z: 0 };
                            if (this_5.attemptInducedImpulse(r, re, roomEntity, floorCollision.roomRef, floorCollision.roomEntityId, floorCollision.roomEntity, jumpImpulse)) {
                                this_5.game.sendSimpleEventToUi({
                                    classRef: "http://ns.nuke24.net/Game21/SimulationMessage/SimpleEvent",
                                    eventCode: 'jump'
                                });
                            }
                        }
                    }
                    else {
                        if (dmd && dmd.y < 0 && entityClass.maxJumpImpulse) {
                        }
                    }
                    if (!climbing && !onFloor && dmd && entityClass.maxFlyingForce) {
                        this_5.registerReactionlessImpulse(r, re, roomEntity, vector3dmath_12.scaleVector(dmd, -entityClass.maxFlyingForce * interval));
                    }
                    if (roomEntity.velocity && !vector3dmath_12.vectorIsZero(roomEntity.velocity)) {
                        var moveOrder = -vector3dmath_12.dotProduct(roomEntity.position, roomEntity.velocity);
                        entitiesToMove.push({ roomId: r, entityId: re, moveOrder: moveOrder });
                    }
                };
                var this_5 = this;
                for (var re in room.roomEntities) {
                    _loop_7(re);
                }
            }
            entitiesToMove.sort(function (a, b) { return a.moveOrder - b.moveOrder; });
            // Apply velocity to positions,
            // do collision detection to prevent overlap and collection collisions
            this.collisions = {};
            var _loop_8 = function(etm) {
                var entityToMove = entitiesToMove[etm];
                var room = rooms[entityToMove.roomId];
                var entityId = entityToMove.entityId;
                {
                    var roomEntity = room.roomEntities[entityId];
                    var velocity = roomEntity.velocity;
                    if (velocity == null || vector3dmath_12.vectorIsZero(velocity))
                        return "continue";
                    var entity = roomEntity.entity;
                    var entityClass = gdm.getEntityClass(entity.classRef);
                    var entityBb = entityClass.physicalBoundingBox;
                    var entityRoomRef = entityToMove.roomId;
                    var displacement = vector3dmath_12.scaleVector(velocity, interval);
                    var solidOtherEntityFilter = function (roomEntityId, roomEntity, entity, entityClass) {
                        return roomEntityId != entityId && entityClass.isSolid !== false;
                    };
                    // Strategy here is:
                    // figure [remaining] displacement based on velocity*interval
                    // while remaining displacement > 0 {
                    //   move along velocity vector as far as possible without collision
                    //   based on objects in path of remaining displacement, apply impulses,
                    //   calculate remaining displacement along surfaces
                    // }
                    var iter = 0;
                    displacementStep: while (displacement && !vector3dmath_12.vectorIsZero(displacement)) {
                        var maxDisplacementComponent = Math.max(Math.abs(displacement.x), Math.abs(displacement.y), Math.abs(displacement.z));
                        // How much of it can we do in a single step?
                        var stepDisplacementRatio = Math.min(snapGridSize, maxDisplacementComponent) / maxDisplacementComponent;
                        // Attempt displacing!
                        var stepDeltaPos = vector3dmath_12.scaleVector(displacement, stepDisplacementRatio);
                        var newVelocityLocation = game.fixLocation({
                            roomRef: entityRoomRef,
                            position: vector3dmath_12.addVector(roomEntity.velocityPosition || roomEntity.position, stepDeltaPos)
                        });
                        var newRoomRef = newVelocityLocation.roomRef;
                        var newPosition = vector3dmath_12.roundVectorToGrid(newVelocityLocation.position, snapGridSize);
                        var collisions = game.entitiesAt(newVelocityLocation.roomRef, newPosition, entityBb, solidOtherEntityFilter);
                        if (collisions.length == 0) {
                            game.updateRoomEntity(entityRoomRef, entityId, {
                                roomRef: newRoomRef,
                                position: newPosition,
                                velocityPosition: newVelocityLocation.position
                            });
                            this_6.activatedRoomIds[newRoomRef] = newRoomRef;
                            entityRoomRef = newRoomRef;
                            if (stepDisplacementRatio == 1)
                                break displacementStep; // Shortcut; this should happen anyway
                            // Subtract what we did and go again
                            displacement = vector3dmath_12.addVector(displacement, vector3dmath_12.scaleVector(displacement, -stepDisplacementRatio));
                            continue displacementStep;
                        }
                        // Uh oh, we've collided somehow.
                        // Need to take that into account, zero out part or all of our displacement
                        // based on where the obstacle was, register some impulses
                        {
                            // TODO: Only need bounce box for directions moving in
                            var bounceBox = this_6.entityBounceBox(entityRoomRef, roomEntity.position, entityBb, ALL_SIDES, snapGridSize, solidOtherEntityFilter);
                            var maxDvx = 0;
                            var maxDvxColl = void 0;
                            var maxDvy = 0;
                            var maxDvyColl = void 0;
                            var remainingDx = displacement.x;
                            var remainingDy = displacement.y;
                            // Is there a less repetetive way to write this?
                            // Check up/down/left/right to find collisions.
                            // If nothing found, then it must be a diagonal collision!
                            // So then check diagonals.
                            var coll = void 0;
                            if (displacement.x > 0 && (coll = bounceBox[XYZDirection.POSITIVE_X])) {
                                remainingDx = 0;
                                var collVel = entityVelocity(coll.roomEntity);
                                var dvx = velocity.x - collVel.x;
                                if (dvx > maxDvx) {
                                    maxDvx = dvx;
                                    maxDvxColl = coll;
                                }
                            }
                            if (displacement.x < 0 && (coll = bounceBox[XYZDirection.NEGATIVE_X])) {
                                remainingDx = 0;
                                var collVel = entityVelocity(coll.roomEntity);
                                var dvx = velocity.x - collVel.x;
                                if (dvx < maxDvx) {
                                    maxDvx = dvx;
                                    maxDvxColl = coll;
                                }
                            }
                            if (displacement.y > 0 && (coll = bounceBox[XYZDirection.POSITIVE_Y])) {
                                remainingDy = 0;
                                var collVel = entityVelocity(coll.roomEntity);
                                var dvy = velocity.y - collVel.y;
                                if (maxDvyColl == null || dvy > maxDvy) {
                                    maxDvy = dvy;
                                    maxDvyColl = coll;
                                }
                            }
                            if (displacement.y < 0 && (coll = bounceBox[XYZDirection.NEGATIVE_Y])) {
                                remainingDy = 0;
                                var collVel = entityVelocity(coll.roomEntity);
                                var dvy = velocity.y - collVel.y;
                                if (dvy < maxDvy) {
                                    maxDvy = dvy;
                                    maxDvyColl = coll;
                                }
                            }
                            if (maxDvxColl) {
                                this_6.registerCollision(newRoomRef, entityId, roomEntity, maxDvxColl.roomRef, maxDvxColl.roomEntityId, maxDvxColl.roomEntity, vector3ds_17.makeVector(maxDvx, 0, 0));
                            }
                            if (maxDvyColl) {
                                this_6.registerCollision(newRoomRef, entityId, roomEntity, maxDvyColl.roomRef, maxDvyColl.roomEntityId, maxDvyColl.roomEntity, vector3ds_17.makeVector(0, maxDvy, 0));
                            }
                            // New displacement = displacement without the components that
                            // would take us into obstacles:
                            if (remainingDx != 0 && remainingDy != 0) {
                                // A diagonal hit, probably.
                                // Keep the larger velocity component
                                if (Math.abs(remainingDx) < Math.abs(remainingDy)) {
                                    remainingDx = 0;
                                }
                                else {
                                    remainingDy = 0;
                                }
                            }
                            displacement = { x: remainingDx, y: remainingDy, z: 0 };
                            ++iter;
                            if (iter > 2) {
                                console.log("Too many displacement steps while moving " + entityId + ":", roomEntity, "class:", entityClass, "iter:", iter, "velocity:", velocity, "displacement:", displacement, "bounceBox:", bounceBox, "max dvx coll:", maxDvxColl, "max dby coll:", maxDvyColl);
                                break displacementStep;
                            }
                        }
                    }
                }
            };
            var this_6 = this;
            for (var etm in entitiesToMove) {
                _loop_8(etm);
            }
            this.applyCollisions();
        };
        return MazeGamePhysics;
    }());
    exports.MazeGamePhysics = MazeGamePhysics;
    // TODO: Rename to MazeGameSimulator,
    // move active room management to GameDataManager.
    var MazeSimulator = (function () {
        function MazeSimulator(gameDataManager) {
            this.gameDataManager = gameDataManager;
            this.rooms = {};
            this.activeRoomIds = {};
            this.phys = new MazeGamePhysics(this);
            this.logger = console;
            this.enqueuedActions = [];
            this.externalDevices = {};
            this.roomLoadPromises = {};
            this.messageUpdateLength = 1 / 8192;
        }
        MazeSimulator.prototype.registerExternalDevice = function (name, dev) {
            this.externalDevices[name] = dev;
        };
        MazeSimulator.prototype.enqueueAction = function (act) {
            this.enqueuedActions.push(act);
        };
        Object.defineProperty(MazeSimulator.prototype, "activeRooms", {
            get: function () { return this.rooms; },
            enumerable: true,
            configurable: true
        });
        MazeSimulator.prototype.getMutableRoom = function (roomId) {
            if (this.rooms[roomId])
                return this.rooms[roomId];
            return this.rooms[roomId] = this.gameDataManager.getMutableRoom(roomId);
        };
        MazeSimulator.prototype.getRoom = function (roomId) {
            if (this.rooms[roomId])
                return this.rooms[roomId];
            return this.gameDataManager.getRoom(roomId);
        };
        MazeSimulator.prototype.fullyCacheRoom = function (roomId) {
            return this.gameDataManager.fullyCacheRoom(roomId);
        };
        MazeSimulator.prototype.fullyLoadRoom = function (roomId) {
            var _this = this;
            return this.fullyCacheRoom(roomId).then(function (room) {
                return _this.getMutableRoom(roomId);
            });
        };
        MazeSimulator.prototype.fullyLoadRooms2 = function (rootRoomId) {
            var _this = this;
            if (this.roomLoadPromises[rootRoomId])
                return this.roomLoadPromises[rootRoomId];
            this.roomLoadPromises[rootRoomId] = this.fullyLoadRoom(rootRoomId);
            return this.roomLoadPromises[rootRoomId].then(function (room) {
                var lProms = [];
                for (var n in room.neighbors) {
                    var nRoomRef = room.neighbors[n].roomRef;
                    if (!_this.rooms[nRoomRef] && !_this.roomLoadPromises[nRoomRef]) {
                        lProms.push(_this.fullyLoadRooms2(nRoomRef));
                    }
                }
                return Promise.all(lProms).then(function () { return room; });
            });
        };
        MazeSimulator.prototype.fullyLoadRooms = function (rootRoomId) {
            var _this = this;
            this.rootRoomId = rootRoomId;
            return this.fullyLoadRooms2(rootRoomId).then(function () {
                _this.roomLoadPromises = {};
                return _this.rooms;
            });
        };
        MazeSimulator.prototype.fixLocation = function (loc) {
            var room = this.getMutableRoom(loc.roomRef);
            if (!aabbs_8.aabbContainsVector(room.bounds, loc.position))
                for (var n in room.neighbors) {
                    var neighb = room.neighbors[n];
                    var fixedPos = vector3dmath_12.subtractVector(loc.position, neighb.offset);
                    if (aabbs_8.aabbContainsVector(neighb.bounds, fixedPos)) {
                        return {
                            roomRef: neighb.roomRef,
                            position: fixedPos,
                        };
                    }
                }
            return loc;
        };
        MazeSimulator.prototype.updateRoomEntity = function (roomRef, entityId, update) {
            var room = this.getMutableRoom(roomRef);
            var roomEntity = room.roomEntities[entityId];
            if (update.position) {
                roomEntity.position = update.position;
                delete roomEntity.velocityPosition;
            }
            if (update.velocityPosition)
                roomEntity.velocityPosition = update.velocityPosition;
            if (update.roomRef != null && update.roomRef != roomRef) {
                var newRoom = this.getMutableRoom(update.roomRef);
                newRoom.roomEntities[entityId] = roomEntity;
                delete room.roomEntities[entityId];
            }
        };
        /**
         * It should be safe to pass entityPositionBuffer as the entity position,
         * since checking intersections is the last thing done with it.
         */
        MazeSimulator.prototype.entitiesAt3 = function (roomRef, roomEntityId, roomEntity, // Root roomEntity
            entityPos, entity, // Individual entity being checked against (may be a sub-entity of the roomEntity)
            checkPos, checkBb, // Sample box
            filter, into) {
            var _this = this;
            var proto = this.gameDataManager.getEntityClass(entity.classRef);
            var filtered = filter(roomEntityId, roomEntity, entity, proto);
            if (filtered === false)
                return;
            if (!aabbs_8.aabbIntersectsWithOffset(entityPos, proto.physicalBoundingBox, checkPos, checkBb))
                return;
            if (proto.structureType == world_7.StructureType.INDIVIDUAL) {
                if (!filtered)
                    return;
                into.push({
                    roomRef: roomRef,
                    roomEntityId: roomEntityId,
                    roomEntity: roomEntity,
                    entityPosition: { x: entityPos.x, y: entityPos.y, z: entityPos.z },
                    entity: entity,
                    entityClass: proto,
                });
            }
            worldutil_5.eachSubEntityIntersectingBb(entity, entityPos, checkPos, checkBb, this.gameDataManager, function (subEnt, subEntPos, ori) {
                _this.entitiesAt3(roomRef, roomEntityId, roomEntity, subEntPos, subEnt, checkPos, checkBb, filter, into);
            }, this, entityPositionBuffer);
        };
        MazeSimulator.prototype.entitiesAt2 = function (roomPos, roomRef, checkPos, checkBb, filter, into) {
            // Room bounds have presumably already been determined to intersect
            // with that of the box being checked, so we'll skip that and go
            // straight to checking entities.
            var room = this.getRoom(roomRef);
            for (var re in room.roomEntities) {
                var roomEntity = room.roomEntities[re];
                vector3dmath_12.addVector(roomPos, roomEntity.position, entityPositionBuffer);
                this.entitiesAt3(roomRef, re, roomEntity, entityPositionBuffer, roomEntity.entity, checkPos, checkBb, filter, into);
            }
        };
        /** Overly simplistic 'is there anything at this exact point' check */
        MazeSimulator.prototype.entitiesAt = function (roomRef, pos, bb, filter) {
            var collisions = [];
            var room = this.getRoom(roomRef);
            if (aabbs_8.aabbIntersectsWithOffset(vector3ds_17.ZERO_VECTOR, room.bounds, pos, bb)) {
                this.entitiesAt2(vector3ds_17.ZERO_VECTOR, roomRef, pos, bb, filter, collisions);
            }
            for (var n in room.neighbors) {
                var neighb = room.neighbors[n];
                // I used to check that bb overlapped neighb.bounds.
                // That results in missing collisions with entities whose physical bounds
                // go beyond that of the room they're in, duh.	
                this.entitiesAt2(neighb.offset, neighb.roomRef, pos, bb, filter, collisions);
            }
            return collisions;
        };
        MazeSimulator.prototype.setTileTreeBlock = function (roomId, pos, tileScale, newTile) {
            var room = this.getMutableRoom(roomId);
            for (var re in room.roomEntities) {
                var roomEntity = room.roomEntities[re];
                var entityClass = this.gameDataManager.getEntityClass(roomEntity.entity.classRef);
                if (entityClass.structureType == world_7.StructureType.TILE_TREE) {
                    var posWithinTt = vector3dmath_12.subtractVector(pos, roomEntity.position);
                    if (aabbs_8.aabbContainsVector(entityClass.tilingBoundingBox, posWithinTt)) {
                        // TODO: Make sure this works for trees with depth > 1
                        roomEntity.entity.classRef = tiletrees_1.rewriteTileTree(roomEntity.position, roomEntity.entity.classRef, function (ckPos, ckAabb, currentTileIndex, currentTileEntity) {
                            if (aabbs_8.offsetAabbContainsVector(ckPos, ckAabb, pos) && aabbs_8.aabbWidth(ckAabb) == tileScale) {
                                return newTile;
                            }
                            else {
                                return currentTileIndex;
                            }
                        }, this.gameDataManager);
                    }
                }
            }
        };
        /** @temporary-shortcut */
        MazeSimulator.prototype.destroyCheapDoor = function (roomId, pos, doorEntityClass) {
            // destroy all nearby doorEntityClass tiles in the same root tiletree
            var aabbOfDestruction = aabbs_8.makeAabb(pos.x - 0.5, pos.y - 2.5, pos.z - 0.5, pos.x + 0.5, pos.y + 2.5, pos.z + 0.5);
            var room = this.getMutableRoom(roomId);
            for (var re in room.roomEntities) {
                var roomEntity = room.roomEntities[re];
                var entityClass = this.gameDataManager.getEntityClass(roomEntity.entity.classRef);
                if (entityClass.structureType == world_7.StructureType.TILE_TREE) {
                    var posWithinTt = vector3dmath_12.subtractVector(pos, roomEntity.position);
                    if (aabbs_8.aabbContainsVector(entityClass.tilingBoundingBox, posWithinTt)) {
                        roomEntity.entity.classRef = tiletrees_1.rewriteTileTree(roomEntity.position, roomEntity.entity.classRef, function (ckPos, ckAabb, currentTileIndex, currentTileEntity) {
                            if (aabbs_8.aabbIntersectsWithOffset(ckPos, ckAabb, vector3ds_17.ZERO_VECTOR, aabbOfDestruction) &&
                                currentTileEntity && currentTileEntity.entity.classRef == doorEntityClass) {
                                return null;
                            }
                            else {
                                return currentTileIndex;
                            }
                        }, this.gameDataManager);
                    }
                }
            }
            this.sendSimpleEventToUi({
                classRef: "http://ns.nuke24.net/Game21/SimulationMessage/SimpleEvent",
                eventCode: 'door-opened'
            });
        };
        MazeSimulator.prototype.processEntityMessage = function (roomId, room, entityId, roomEntity, md) {
            switch (md.classRef) {
                case "http://ns.nuke24.net/Game21/SimulationMessage/CommandReceived":
                    return this.processEntityCommand(roomId, room, entityId, roomEntity, md.command);
            }
        };
        MazeSimulator.prototype.processEntityCommand = function (roomId, room, entityId, roomEntity, md) {
            var path = entityMessageDataPath(md);
            if (path == "/desiredmovementdirection") {
                roomEntity.entity.desiredMovementDirection = vector3ds_17.makeVector(+md[1], +md[2], +md[3]);
                // Make sure the room is marked as active:
                this.activeRoomIds[roomId] = roomId;
            }
            else if (path == "/painttiletreeblock") {
                var relX = +md[1];
                var relY = +md[2];
                var relZ = +md[3];
                var tileScale = +md[4] || 1;
                var block_1 = md[5];
                if (typeof block_1 != 'string' && typeof block_1 != 'number' && block_1 !== null) {
                    console.log("Erps; bad block");
                    return;
                }
                if (typeof block_1 == 'string') {
                    if (this.gameDataManager.getObjectIfLoaded(block_1) == null) {
                        console.log("Entity class " + block_1 + " not loaded.  Try again later.");
                        // Try to load it up and ignore this request for now.
                        // User can click again. :P
                        this.gameDataManager.fetchObject(block_1).then(function (entiyClass) {
                            console.log("Entity class " + block_1 + " loaded, now!  You should be able to place it, now.");
                        }).catch(function (err) {
                            console.error("Failed to load entity class " + block_1);
                        });
                        return;
                    }
                }
                var rePos = roomEntity.position;
                var blockLoc = this.fixLocation({ roomRef: roomId, position: vector3ds_17.makeVector(relX + rePos.x, relY + rePos.y, relZ + rePos.z) });
                this.setTileTreeBlock(blockLoc.roomRef, blockLoc.position, tileScale, block_1);
                return;
            }
            else if (path == '/give') {
                // put a thing in your inventory, if there's space
                var itemClassRef = md[1];
                if (itemClassRef == undefined)
                    return;
                try {
                    var itemClass = this.gameDataManager.getEntityClass(itemClassRef, true);
                }
                catch (err) {
                    console.error("Couldn't give item", err);
                    return;
                }
                var entityClass = this.gameDataManager.getEntityClass(roomEntity.entity.classRef);
                var inventorySize = entityClass.maze1InventorySize || 0;
                if (inventorySize == 0) {
                    console.warn("Can't add item; inventory size = 0");
                    return;
                }
                var currentItemCount = 0;
                if (roomEntity.entity.maze1Inventory == undefined)
                    roomEntity.entity.maze1Inventory = {};
                for (var k in roomEntity.entity.maze1Inventory)
                    ++currentItemCount;
                if (currentItemCount < inventorySize) {
                    roomEntity.entity.maze1Inventory[newUuidRef()] = {
                        classRef: itemClassRef
                    };
                }
                else {
                    console.warn("Can't add item; inventory full");
                }
            }
            else if (path == '/vomit') {
                if (roomEntity.entity.storedEnergy != undefined) {
                    roomEntity.entity.storedEnergy /= 2;
                    chunks: for (var i = 0; i < 20; ++i) {
                        var vel = roomEntity.velocity || vector3ds_17.ZERO_VECTOR;
                        if (vector3dmath_12.vectorIsZero(vel))
                            vel = { x: 0, y: -1, z: 0 };
                        vel = vector3dmath_12.addVector(vel, vector3dmath_12.normalizeVector(vel, 5));
                        vel = { x: vel.x + Math.random() - 0.5, y: vel.y + Math.random() - 0.5, z: vel.z };
                        vel = vector3dmath_12.normalizeVector(vel, 4 + Math.random() * 0.25 - 0.125);
                        var offset = vector3dmath_12.normalizeVector(vel, 0.5);
                        var chunk = { classRef: picking_3.pickOne([dat.vomitChunk1EntityClassId, dat.vomitChunk2EntityClassId, dat.vomitChunk3EntityClassId]) };
                        try {
                            this.placeItemSomewhereNear(chunk, roomId, vector3dmath_12.addVector(roomEntity.position, offset), vel);
                        }
                        catch (err) {
                            break chunks;
                        }
                    }
                }
            }
            else if (path == '/throwinventoryitem') {
                if (md[1] == undefined) {
                    console.error("missing item key argument to /throwinventoryitem");
                    return;
                }
                var itemRef = md[1];
                if (roomEntity.entity.maze1Inventory == undefined) {
                    console.warn("No inventory at all; can't throw item'");
                    return;
                }
                var item = roomEntity.entity.maze1Inventory[itemRef];
                if (item == undefined) {
                    console.warn("No item " + itemRef + " seems to exist in inventory:", roomEntity.entity.maze1Inventory);
                    return;
                }
                var throwOffset = vector3dmath_12.normalizeVector({ x: +md[2], y: +md[3], z: +md[4] }, 0.5);
                try {
                    this.placeItemSomewhereNear(item, roomId, vector3dmath_12.addVector(roomEntity.position, throwOffset), vector3dmath_12.scaleVector(throwOffset, 10));
                }
                catch (err) {
                    console.log("Couldn't throw:", err);
                    return;
                }
                delete roomEntity.entity.maze1Inventory[itemRef];
            }
        };
        MazeSimulator.prototype.processSimulatorMessage = function (msg) {
            switch (msg.classRef) {
                case "http://ns.nuke24.net/Game21/SimulationMessage/CommandReceived":
                    return this.processSimulatorCommand(msg.command);
            }
        };
        MazeSimulator.prototype.processSimulatorCommand = function (messageData) {
            switch (messageData[0]) {
                case '/create-room':
                    {
                        var roomId = messageData[1];
                        if (typeof roomId != 'string') {
                            this.logger.error("'create-room' argument not a string", messageData);
                            return;
                        }
                        var size = +(messageData[2] || 16);
                        var ttId = newUuidRef();
                        this.gameDataManager.putMutableObject(roomId, {
                            bounds: aabbs_8.makeAabb(-size / 2, -size / 2, -8, size / 2, size / 2, 8),
                            neighbors: {},
                            roomEntities: (_a = {},
                                _a[ttId] = {
                                    position: vector3ds_17.ZERO_VECTOR,
                                    entity: {
                                        classRef: dat.getDefaultRoomTileTreeRef(this.gameDataManager, size, size, 1)
                                    }
                                },
                                _a
                            )
                        });
                        this.logger.log("Created room " + roomId);
                    }
                    break;
                case '/connect-rooms':
                    {
                        var room1Id = messageData[1];
                        var dir = "" + messageData[2];
                        var room2Id = messageData[3];
                        // For now all rooms are 16x16, so
                        var nx = 0, ny = 0, nz = 0;
                        for (var i = 0; i < dir.length; ++i) {
                            switch (dir[i]) {
                                case 't':
                                    ny = -1;
                                    break;
                                case 'b':
                                    ny = +1;
                                    break;
                                case 'l':
                                    nx = -1;
                                    break;
                                case 'r':
                                    nx = +1;
                                    break;
                                case 'a':
                                    nz = -1;
                                    break;
                                case 'z':
                                    nz = +1;
                                    break;
                                default:
                                    this.logger.warn("Unrecognized direction char: " + dir[i]);
                            }
                        }
                        try {
                            var room1 = this.gameDataManager.getRoom(room1Id);
                            var room2 = this.gameDataManager.getRoom(room2Id);
                            var dx = nx > 0 ? room1.bounds.maxX - room2.bounds.minX :
                                nx < 0 ? room1.bounds.minX - room2.bounds.maxX : 0;
                            var dy = ny > 0 ? room1.bounds.maxY - room2.bounds.minY :
                                ny < 0 ? room1.bounds.minY - room2.bounds.maxY : 0;
                            var dz = nz > 0 ? room1.bounds.maxZ - room2.bounds.minZ :
                                nz < 0 ? room1.bounds.minZ - room2.bounds.maxZ : 0;
                            var nVec = vector3ds_17.makeVector(dx, dy, dz);
                            this.logger.log("Connecting " + room1Id + " to " + room2Id + " @ " + vector3ds_17.vectorToString(nVec));
                            worldutil_5.connectRooms(this.gameDataManager, room1Id, room2Id, nVec);
                        }
                        catch (err) {
                            this.logger.error("Failed to connect rooms", err);
                        }
                    }
                    break;
                default:
                    this.logger.warn("Unrecognized simulator message:", messageData);
            }
            var _a;
        };
        Object.defineProperty(MazeSimulator.prototype, "hasPendingMessageUpdates", {
            get: function () {
                return this.enqueuedActions.length > 0;
            },
            enumerable: true,
            configurable: true
        });
        MazeSimulator.prototype.findEntity = function (entityId) {
            for (var roomId in this.rooms) {
                var room = this.rooms[roomId];
                if (room.roomEntities[entityId])
                    return roomId;
            }
            return undefined;
        };
        MazeSimulator.prototype.sendSimpleEventToUi = function (message) {
            var dev = this.externalDevices['ui'];
            if (!dev)
                return;
            dev.message(message);
        };
        MazeSimulator.prototype.doReceiveMessageAction = function (act) {
            var roomId;
            if (this.externalDevices[act.entityPath[0]]) {
                this.externalDevices[act.entityPath[0]].message(act.message, act.replyPath);
                return;
            }
            switch (act.entityPath[0]) {
                case simulationmessaging_1.ROOMID_SIMULATOR:
                    this.processSimulatorMessage(act.message);
                    return;
                case simulationmessaging_1.ROOMID_FINDENTITY:
                    roomId = this.findEntity(act.entityPath[1]);
                    if (roomId == null) {
                        console.warn("Can't deliver entity message: failed to find room containing entity " + act.entityPath[1]);
                        return;
                    }
                    break;
                case simulationmessaging_1.ROOMID_EXTERNAL:
                    console.log("Hey look, message to " + act.entityPath.join("/") + ":", act.message);
                    return;
                default:
                    roomId = act.entityPath[0];
            }
            if (act.entityPath.length != 2) {
                console.error("Can't deliver entity message: unsupported path length: " + act.entityPath.length);
                return;
            }
            var room = this.rooms[roomId];
            if (!room) {
                console.warn("Can't deliver entity message: no such room: '" + roomId + "'");
                return;
            }
            var roomEntityKey = act.entityPath[1];
            var roomEntity = room.roomEntities[roomEntityKey];
            if (roomEntity == null) {
                console.warn("Can't deliver entity message: entity " + roomEntityKey + " not found in room " + roomId);
                return;
            }
            // TODO: May need to handle more path... 
            this.processEntityMessage(roomId, room, roomEntityKey, roomEntity, act.message);
        };
        MazeSimulator.prototype.doAction = function (act) {
            switch (act.classRef) {
                case "http://ns.nuke24.net/Game21/SimulationAction/ReceiveMessage":
                    this.doReceiveMessageAction(act);
                    break;
                default:
                    console.error("Unrecognized action class: " + act.classRef);
            }
        };
        MazeSimulator.prototype.doMessageUpdate = function () {
            var handlingActions = this.enqueuedActions;
            this.enqueuedActions = [];
            for (var ac in handlingActions) {
                var act = handlingActions[ac];
                this.doAction(act);
            }
        };
        MazeSimulator.prototype.doMessageUpdates = function (interval) {
            var count = Math.floor(interval / this.messageUpdateLength);
            for (var i = 0; i < count && this.hasPendingMessageUpdates; ++i) {
                this.doMessageUpdate();
            }
        };
        MazeSimulator.prototype.findEmptySpaceNear = function (bb, roomId, position) {
            var distance = 0;
            var filter = function (roomEntityId, roomEntity, entity, entityClass) {
                if (entityClass.structureType == world_7.StructureType.INDIVIDUAL) {
                    return entityClass.isSolid !== false;
                }
                return undefined;
            };
            for (var attempts = 0; attempts < 16; ++attempts) {
                var placePos = {
                    x: position.x + (Math.random() * 2 - 1) * distance,
                    y: position.y + (Math.random() * 2 - 1) * distance,
                    z: position.z
                };
                if (this.entitiesAt(roomId, placePos, bb, filter).length == 0) {
                    return this.fixLocation({
                        roomRef: roomId,
                        position: placePos
                    });
                }
                distance += 1 / 16;
            }
            throw new Error("Failed to find empty space!");
        };
        MazeSimulator.prototype.placeItemSomewhereNear = function (entity, roomId, position, velocity) {
            if (velocity === void 0) { velocity = vector3ds_17.ZERO_VECTOR; }
            var entityClass = this.gameDataManager.getEntityClass(entity.classRef);
            var physBb = entityClass.physicalBoundingBox;
            if (entityClass.structureType != world_7.StructureType.INDIVIDUAL) {
                throw new Error('placeItemSomewhereNear not meant to handle ' + entityClass.structureType + '-structure-typed things');
            }
            var loc = this.findEmptySpaceNear(physBb, roomId, position);
            var room = this.activeRooms[loc.roomRef];
            room.roomEntities[entity.id || newUuidRef()] = {
                position: loc.position,
                velocity: velocity,
                entity: entity
            };
        };
        MazeSimulator.prototype.killRoomEntity = function (roomRef, entityRef) {
            var room = this.activeRooms[roomRef];
            var roomEntity = room.roomEntities[entityRef];
            if (roomEntity == undefined) {
                console.warn("Can't kill entity " + roomRef + "/" + entityRef + " because that room entity's not found");
                return;
            }
            var entity = roomEntity.entity;
            if (entity.maze1Inventory)
                for (var i in entity.maze1Inventory) {
                    try {
                        this.placeItemSomewhereNear(entity.maze1Inventory[i], roomRef, roomEntity.position);
                    }
                    catch (err) {
                        console.warn("Uh oh, inventory item " + i + " was lost!");
                    }
                }
            entity.maze1Inventory = {};
            entity.classRef = dat.deadPlayerEntityClassId;
            delete entity.desiredMovementDirection;
            delete entity.desiresMaze1AutoActivation; // Otherwise skeleton will steal your dropped keys! 
        };
        MazeSimulator.prototype.update = function (interval) {
            if (interval === void 0) { interval = 1 / 16; }
            this.doMessageUpdates(interval / 2);
            this.phys.activeRoomIds = this.activeRoomIds;
            this.phys.activatedRoomIds = {};
            this.phys.updateEntities(interval);
            this.activeRoomIds = this.phys.activatedRoomIds;
            this.doMessageUpdates(interval / 2);
        };
        MazeSimulator.prototype.flushUpdates = function () {
            return this.gameDataManager.flushUpdates();
        };
        MazeSimulator.prototype.locateRoomEntity = function (id) {
            for (var r in this.rooms) {
                var room = this.rooms[r];
                for (var re in room.roomEntities) {
                    if (re == id) {
                        var roomEntity = room.roomEntities[re];
                        var entity = roomEntity.entity;
                        var entityClass = this.gameDataManager.getEntityClass(entity.classRef);
                        return {
                            roomRef: r,
                            roomEntityId: id,
                            roomEntity: roomEntity,
                            entityPosition: roomEntity.position,
                            entity: entity,
                            entityClass: entityClass
                        };
                    }
                }
            }
            return undefined;
        };
        return MazeSimulator;
    }());
    exports.MazeSimulator = MazeSimulator;
    function isAllZero(data) {
        for (var i = 0; i < data.length; ++i)
            if (data[i] != 0)
                return false;
        return true;
    }
    function isAllNonZero(data) {
        for (var i = 0; i < data.length; ++i)
            if (data[i] == 0)
                return false;
        return true;
    }
    var simulatorId = 'urn:uuid:002ae5c8-1c7f-470c-8b5d-cf79e58aa561';
    var DemoMode;
    (function (DemoMode) {
        DemoMode[DemoMode["PLAY"] = 0] = "PLAY";
        DemoMode[DemoMode["EDIT"] = 1] = "EDIT";
    })(DemoMode || (DemoMode = {}));
    var MazeDemo = (function () {
        function MazeDemo() {
            this.tabSwitchesMode = true;
            this.soundEffectsEnabled = true;
            this.tickRate = 1 / 32;
            this._demoMode = DemoMode.PLAY;
            this.foundTriforceCount = 0;
            this.currentLevelNumber = 0;
            this.foundTriforceThisLevel = false;
            this.loadingStatusUpdated = function (t) { };
            this.contextListeners = [];
            this.picking = false;
            // TODO: Make the key codes key_ constants
            // TODO: use keyActions for the other things, too.
            this.keyActions = (_a = {
                    // Keypad keys:
                    33: ['right', 'up'],
                    34: ['right', 'down'],
                    35: ['left', 'down'],
                    36: ['left', 'up'],
                    // Arrows?
                    37: ['left'],
                    38: ['up'],
                    39: ['right'],
                    40: ['down'],
                    // WASD
                    87: ['up'],
                    65: ['left'],
                    83: ['down'],
                    68: ['right']
                },
                _a[KEY_CTRL] = ['pick'],
                _a
            );
            this.keysDown = {};
            this.paintEntityClassRef = null;
            this.mouse1PreviouslyDown = true;
            this.commandHistory = [];
            this.commandScratch = ""; // Anything entered before going into history
            this.defaultNewRoomSize = 16;
            var _a;
        }
        MazeDemo.prototype.addContextListener = function (l) {
            this.contextListeners.push(l);
        };
        Object.defineProperty(MazeDemo.prototype, "context", {
            set: function (ctx) {
                if (this.simulator)
                    this.simulator.gameDataManager = ctx.gameDataManager;
                if (this.view)
                    this.view.gameDataManager = ctx.gameDataManager;
                for (var l in this.contextListeners) {
                    this.contextListeners[l](ctx);
                }
            },
            enumerable: true,
            configurable: true
        });
        MazeDemo.prototype.logLoadingStatus = function (stat, isError, err) {
            if (isError === void 0) { isError = false; }
            this.loadingStatusUpdated(stat);
            if (isError)
                this.logger.error(stat, err || new Error(stat));
            else
                this.logger.log(stat);
        };
        Object.defineProperty(MazeDemo.prototype, "loadingStatus", {
            set: function (stat) {
                this.loadingStatusUpdated(stat);
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(MazeDemo.prototype, "demoMode", {
            get: function () { return this._demoMode; },
            set: function (mode) {
                mode = mode % 2;
                if (mode == this._demoMode)
                    return;
                this._demoMode = mode;
                if (this._demoMode == DemoMode.EDIT) {
                    this.tilePaletteUi.element.style.display = "";
                    this.maze1InventoryUi.element.style.display = "none";
                }
                else {
                    this.tilePaletteUi.element.style.display = "none";
                    this.maze1InventoryUi.element.style.display = "";
                }
            },
            enumerable: true,
            configurable: true
        });
        MazeDemo.prototype.switchToNextMode = function () {
            this.demoMode += 1;
        };
        MazeDemo.prototype.startSimulation = function () {
            if (this.tickTimerId == undefined) {
                this.tickTimerId = setInterval(this.tick.bind(this), 1000 * this.tickRate);
            }
        };
        MazeDemo.prototype.stopSimulation = function () {
            if (this.tickTimerId != undefined) {
                clearInterval(this.tickTimerId);
                this.tickTimerId = undefined;
            }
        };
        MazeDemo.prototype.tick = function () {
            this.simulator.update(this.tickRate);
            this.updateView();
        };
        MazeDemo.prototype.updateView = function () {
            // TODO: Have player entity send messages to the UI
            // instead of mucking around in game state
            this.maybePaint();
            var newViewage = { visualEntities: [] };
            var foundPlayer = this.simulator.locateRoomEntity(this.playerId);
            var playerLoc = foundPlayer ? { roomRef: foundPlayer.roomRef, position: foundPlayer.entityPosition } : undefined;
            if (playerLoc) {
                var rasterWidth = 41;
                var rasterHeight = 31;
                var rasterResolution = 2;
                var distance = 21;
                // Line up raster origin so it falls as close as possible to the center of the raster
                // while lining up edges with world coordinates
                // TODO: shouldn't need to snap to integer world coords; raster coords would be fine.
                var rasterOriginX = Math.floor(rasterWidth / rasterResolution / 2) + playerLoc.position.x - Math.floor(playerLoc.position.x);
                var rasterOriginY = Math.floor(rasterHeight / rasterResolution / 2) + playerLoc.position.y - Math.floor(playerLoc.position.y);
                var visibilityRaster = new SceneShader_2.ShadeRaster(rasterWidth, rasterHeight, rasterResolution, rasterOriginX, rasterOriginY);
                var opacityRaster = void 0;
                var seeAll = this._demoMode == DemoMode.EDIT;
                var visibilityDistanceInRasterPixels = rasterResolution * distance;
                opacityRaster = new SceneShader_2.ShadeRaster(rasterWidth, rasterHeight, rasterResolution, rasterOriginX, rasterOriginY);
                var sceneShader = new SceneShader_2.default(this.simulator.gameDataManager);
                sceneShader.sceneOpacityRaster(playerLoc.roomRef, vector3dmath_12.scaleVector(playerLoc.position, -1), opacityRaster);
                if (isAllZero(opacityRaster.data))
                    console.log("Opacity raster is all zero!");
                if (isAllNonZero(opacityRaster.data))
                    console.log("Opacity raster is all nonzero!");
                if (seeAll) {
                    sceneShader.initializeVisibilityRaster(opacityRaster, visibilityRaster, SceneShader_2.VISIBILITY_MIN);
                }
                else {
                    sceneShader.initializeVisibilityRaster(opacityRaster, visibilityRaster);
                    // Player eyes (TODO: configure on entity class):
                    sceneShader.opacityTolVisibilityRaster(opacityRaster, (rasterOriginX - 1 / 4) * rasterResolution, rasterOriginY * rasterResolution, visibilityDistanceInRasterPixels, visibilityRaster);
                    sceneShader.opacityTolVisibilityRaster(opacityRaster, (rasterOriginX + 1 / 4) * rasterResolution, rasterOriginY * rasterResolution, visibilityDistanceInRasterPixels, visibilityRaster);
                    sceneShader.growVisibility(visibilityRaster);
                }
                sceneToMazeViewage(playerLoc.roomRef, vector3dmath_12.scaleVector(playerLoc.position, -1), this.simulator.gameDataManager, newViewage, visibilityRaster, seeAll);
                if (seeAll)
                    newViewage.cameraLocation = playerLoc;
                newViewage.visibility = visibilityRaster;
                newViewage.opacity = opacityRaster;
            }
            else {
                console.log("Failed to locate player, " + this.playerId);
            }
            {
                var invItems = [];
                if (foundPlayer) {
                    var inv = foundPlayer.entity.maze1Inventory || {};
                    for (var k in inv) {
                        invItems.push({ key: k, orientation: Quaternion_6.default.IDENTITY, entity: inv[k] });
                        if (inv[k].classRef == dat.triforceEntityClassId && !this.foundTriforceThisLevel) {
                            // omg a triforce
                            ++this.foundTriforceCount;
                            this.popUpWinDialog("You have found " + this.foundTriforceCount + " triforces!");
                            this.foundTriforceThisLevel = true;
                        }
                    }
                    if (this.energyIndicator)
                        this.energyIndicator.value = foundPlayer.entity.storedEnergy;
                    if (foundPlayer.entity.storedEnergy < 1 && this.restartDialog && !this.restartDialog.isVisible) {
                        this.logger.log("You have run out of energy and died. :(");
                        this.restartDialog.message = "You have run out of energy and died.";
                        this.restartDialog.isVisible = true;
                    }
                }
                else {
                    if (this.energyIndicator)
                        this.energyIndicator.value = undefined;
                }
                this.maze1InventoryUi.setAllSlots(invItems);
            }
            var locationDiv = document.getElementById('camera-location-box');
            if (locationDiv) {
                var locationNode = locationDiv.firstChild;
                if (locationNode == null)
                    locationDiv.appendChild(locationNode = document.createTextNode(""));
                var cameraLoc = newViewage.cameraLocation;
                if (cameraLoc) {
                    var p = cameraLoc.position;
                    locationNode.nodeValue = cameraLoc.roomRef + " @ " + p.x.toFixed(3) + "," + p.y.toFixed(3) + "," + p.z.toFixed(3);
                }
                else {
                    locationNode.nodeValue = "";
                }
            }
            this.view.viewage = newViewage;
        };
        MazeDemo.prototype.keysUpdated = function () {
            var up = false, down = false, left = false, right = false;
            var actions = {};
            for (var k in this.keysDown) {
                var acts = this.keyActions[k];
                if (acts)
                    for (var a in acts) {
                        actions[acts[a]] = true;
                    }
            }
            if (actions['right'])
                right = true;
            if (actions['left'])
                left = true;
            if (actions['up'])
                up = true;
            if (actions['down'])
                down = true;
            if (left && right)
                left = right = false;
            if (up && down)
                up = down = false;
            var moveX = right ? +1 : left ? -1 : 0;
            var moveY = down ? +1 : up ? -1 : 0;
            if (this.simulator && this.playerId) {
                this.enqueueMessage([simulationmessaging_1.ROOMID_FINDENTITY, this.playerId], ["/desiredmovementdirection", moveX, moveY, 0]);
            }
            this.picking = actions['pick'];
        };
        // When keys are pressed in the main game interface
        MazeDemo.prototype.gameKeyDown = function (keyEvent) {
            if (this.keyActions[keyEvent.keyCode]) {
                this.keysDown[keyEvent.keyCode] = true;
                this.keysUpdated();
                keyEvent.preventDefault();
            }
            if (keyEvent.keyCode >= KEY_0 && keyEvent.keyCode <= KEY_9) {
                var selectedIndex = keyEvent.keyCode - KEY_0;
                switch (this._demoMode) {
                    case DemoMode.EDIT:
                        if (this.tilePaletteUi)
                            this.tilePaletteUi.selectSlot(selectedIndex);
                        break;
                    case DemoMode.PLAY:
                        if (this.maze1InventoryUi)
                            this.maze1InventoryUi.selectSlot(selectedIndex);
                        break;
                }
                keyEvent.preventDefault();
            }
        };
        MazeDemo.prototype.globalKeyUp = function (keyEvent) {
            if (this.keyActions[keyEvent.keyCode]) {
                delete this.keysDown[keyEvent.keyCode];
                this.keysUpdated();
            }
        };
        // Keys pressed anywhere
        MazeDemo.prototype.globalKeyDown = function (keyEvent) {
            switch (keyEvent.keyCode) {
                case KEY_TAB:
                    if (this.tabSwitchesMode) {
                        this.switchToNextMode();
                        keyEvent.preventDefault();
                        return;
                    }
                    ;
                    break;
                case KEY_SLASH:
                    this.popUpConsole("/");
                    keyEvent.preventDefault();
                    return;
                case KEY_BACKTICK:
                    this.popUpConsole("");
                    keyEvent.preventDefault();
                    return;
            }
        };
        MazeDemo.prototype.saveGame = function () {
            var _this = this;
            return this.simulator.flushUpdates().then(function (gameDataRef) {
                var rrf = _this.simulator.rootRoomId;
                if (rrf == null)
                    return Promise.reject(new Error("Can't save; no root room specified!"));
                var saveGame = {
                    gameDataRef: gameDataRef,
                    rootRoomId: rrf,
                    playerId: _this.playerId
                };
                return JSONObjectDatastore_3.storeObject(saveGame, _this.datastore);
            });
        };
        MazeDemo.prototype.saveGame2 = function (note) {
            var _this = this;
            if (this.saveButton)
                this.saveButton.disabled = true;
            this.saveGame().then(function (saveRef) {
                var saveMeta = {
                    note: note,
                    date: new Date().toISOString(),
                    saveRef: saveRef,
                };
                _this.logger.log("Serialized as " + saveRef + "; uploading...");
                http.request('POST', 'http://game21-data.nuke24.net/saves', { 'content-type': 'application/json' }, JSONObjectDatastore_3.encodeObject(saveMeta)).then(function (res) {
                    if (res.statusCode != 200) {
                        _this.logger.error("Failed to save to website;", res.content);
                    }
                    else {
                        _this.logger.log("Saved " + saveRef + " to website");
                    }
                });
                if (window.localStorage) {
                    var savesJson = window.localStorage.getItem("game21-local-saves");
                    var saves = savesJson ? JSON.parse(savesJson) : [];
                    saves.push(saveMeta);
                    window.localStorage.setItem("game21-local-saves", JSON.stringify(saves, null, "\t"));
                }
                // TODO: catch any rejects here and return them
                if (_this.saveButton)
                    _this.saveButton.disabled = false;
            }).catch(function (err) {
                if (_this.saveButton)
                    _this.saveButton.disabled = false;
                _this.logger.error("Error saving!", err);
            });
        };
        MazeDemo.prototype.loadGame2 = function (gdm, playerId, rootRoomId, gameDescription) {
            var _this = this;
            this.stopSimulation();
            this.logLoadingStatus("Loading " + gameDescription + "...");
            this.context = {
                gameDataManager: gdm,
                entityImageManager: new EntityImageManager(gdm)
            };
            this.gameDataManager = gdm;
            this.simulator = new MazeSimulator(gdm);
            var sounds = {
                'jump': { dataRef: 'urn:bitprint:PUI5IOGTUW32PKDJXH2WPAIKF6ZV2UVH.5YEO5BYLXIINTBTLXFWIQ5QKOOA5O2CARTPMTZQ', volume: 0.25 },
                'food-ate': { dataRef: 'urn:bitprint:52C7CJ3H23QPTH4ORAS4XMI2JIGKYOKC.F6NQEI6XJYNCSHQFDOGO3PWBUDX6ZOD6KJTYCWA', volume: 0.75 },
                'key-got': { dataRef: 'urn:bitprint:S6K6KYKJVBNLIR5Y7MDQHMR4ORQZGYOE.AU73BOMZZKFBMGOS4CBJCGWVKGJW72PKW2UGNAY', volume: 0.125 },
                'triforce-got': { dataRef: 'urn:bitprint:NLQVXM2OZGSHWVWJVUPBFIGKBJ4PLJ6N.L4IOHLRD5U57XEW4U4CI5TDFC4NGF6XVNGLSAPA' },
                'stick-got': { dataRef: 'urn:bitprint:RK2CXQIXPC6DX7E66AKWJFBPBHBZ6EJI.BYKJVUZFX4CFTFOVT4OXNDAOLJBJ3MHN7NN57GQ' },
                'door-opened': { dataRef: 'urn:bitprint:24QIYL5AH2ZEWUB4KYQSAWPYV43DOKKC.3WIXHFFFIT2ZK4D6HVGP52BIBRU5WIRK27BMWUA', volume: 0.5 },
            };
            var simpleEventSounds = {
                'jump': sounds['jump'],
                'door-opened': sounds['door-opened'],
            };
            var itemSounds = (_a = {},
                _a[dat.appleEntityClassId] = sounds['food-ate'],
                _a[dat.blueKeyEntityClassId] = sounds['key-got'],
                _a[dat.yellowKeyEntityClassId] = sounds['key-got'],
                _a[dat.redKeyEntityClassId] = sounds['key-got'],
                _a[dat.triforceEntityClassId] = sounds['triforce-got'],
                _a[dat.stick1EntityClassId] = sounds['stick-got'],
                _a[dat.stick2EntityClassId] = sounds['stick-got'],
                _a
            );
            for (var k in sounds) {
                this.soundPlayer.preloadSound(sounds[k].dataRef);
            }
            this.simulator.registerExternalDevice("ui", {
                message: function (msg) {
                    if (!_this.soundEffectsEnabled)
                        return;
                    switch (msg.classRef) {
                        case "http://ns.nuke24.net/Game21/SimulationMessage/SimpleEvent":
                            if (simpleEventSounds[msg.eventCode]) {
                                _this.soundPlayer.playSoundByRef(simpleEventSounds[msg.eventCode].dataRef, simpleEventSounds[msg.eventCode].volume);
                            }
                            break;
                        case "http://ns.nuke24.net/Game21/SimulationMessage/ItemGot":
                            if (itemSounds[msg.itemClassRef]) {
                                _this.soundPlayer.playSoundByRef(itemSounds[msg.itemClassRef].dataRef, itemSounds[msg.itemClassRef].volume);
                            }
                            break;
                    }
                }
            });
            var loadPromise = gdm.cacheObjects([
                dat.basicTileEntityPaletteRef // A thing whose ID tends to be hard coded around
            ]).then(function () {
                return _this.simulator.fullyLoadRooms(rootRoomId);
            }).then(function () {
                _this.playerId = playerId;
                _this.updateView();
                _this.startSimulation();
                return _this.simulator;
            });
            loadPromise.then(function (game) {
                _this.logger.log("Loaded " + gameDescription);
                _this.loadingStatus = "";
                _this.foundTriforceThisLevel = false;
            }).catch(function (err) {
                _this.logger.error("Error loading " + gameDescription, err);
                _this.loadingStatus = "Error loading!";
            });
            return loadPromise;
            var _a;
        };
        MazeDemo.prototype.loadGame1 = function (saveRef) {
            var _this = this;
            this.stopSimulation();
            if (saveRef.substr(saveRef.length - 1) != '#')
                saveRef += "#";
            this.logLoadingStatus("Loading save " + saveRef + "...");
            return JSONObjectDatastore_3.fetchObject(saveRef, this.datastore, true).then(function (save) {
                if (!save.gameDataRef)
                    return Promise.reject(new Error("Oh no, save data all messed up? " + JSON.stringify(save)));
                var gdm = new GameDataManager_4.default(_this.datastore, save.gameDataRef);
                return _this.loadGame2(gdm, save.playerId, save.rootRoomId, saveRef);
            }, function (err) {
                _this.logLoadingStatus("Error loading save " + saveRef + "!", true, err);
            });
        };
        MazeDemo.prototype.loadGame = function (saveGameRef) {
            var _this = this;
            var levelRe = /^level(\d+)$/;
            var levelReMatch;
            var tempGdm = new GameDataManager_4.default(this.datastore);
            if (saveGameRef == 'demo') {
                return dat.initData(tempGdm).then(function () { return _this.loadGame2(tempGdm, dat.playerEntityId, dat.room1Id, "demo maze"); });
            }
            else if (saveGameRef == '' || saveGameRef == undefined) {
                return Promise.resolve().then(function () { return _this.generateAndLoadNewLevel(0); });
            }
            else if ((levelReMatch = levelRe.exec(saveGameRef))) {
                // generateAndLoadNewLevel depends on some UI elements being set up, so defer it...
                var levelNumber_1 = parseInt(levelReMatch[1]);
                return Promise.resolve().then(function () { return _this.generateAndLoadNewLevel(levelNumber_1); });
            }
            else {
                return this.loadGame1(saveGameRef);
            }
        };
        MazeDemo.prototype.restartLevel = function () {
            var newPlayerId = this.playerId = newUuidRef();
            var playerPlaced = false;
            for (var r in this.simulator.activeRooms) {
                var room = this.simulator.activeRooms[r];
                for (var re in room.roomEntities) {
                    var roomEntity = room.roomEntities[re];
                    if (!playerPlaced && roomEntity.entity.classRef == dat.spawnPointEntityClassId) {
                        // Oh oh put the player here!
                        room.roomEntities[newPlayerId] = {
                            position: roomEntity.position,
                            entity: {
                                id: newPlayerId,
                                classRef: dat.playerEntityClassId,
                                desiresMaze1AutoActivation: true,
                                storedEnergy: 100000
                            }
                        };
                        playerPlaced = true;
                    }
                    if (re != newPlayerId && roomEntity.entity.classRef == dat.playerEntityClassId) {
                        this.simulator.killRoomEntity(r, re);
                    }
                }
            }
            if (this.restartDialog)
                this.restartDialog.isVisible = false;
            if (!playerPlaced) {
                this.logLoadingStatus("No spawn point found!", true);
            }
        };
        MazeDemo.prototype.generateAndLoadNewLevel = function (level) {
            var _this = this;
            var attempts = 0;
            var generateMaze = function () { return Promise.resolve(); }; // stupid ts compiler blah
            generateMaze = function () {
                var generator = new GraphMazeGenerator2_1.default();
                if (level > 2)
                    generator.requireKeys.push(graphmaze_3.ITEMCLASS_BLUEKEY);
                if (level > 6)
                    generator.requireKeys.push(graphmaze_3.ITEMCLASS_YELLOWKEY);
                if (level > 12)
                    generator.requireKeys.push(graphmaze_3.ITEMCLASS_REDKEY);
                generator.targetNodeCount = 8 + level;
                generator.complectificationFactor = 1 / 4 + Math.random() * Math.random() / 2 + (1 / 3) * (level / 50);
                var generationMessage = "Generating new level " +
                    "requiring " + generator.requireKeys.length + " keys, " +
                    "complectification factor: " + generator.complectificationFactor.toPrecision(2) + ", " +
                    "target node count: " + generator.targetNodeCount +
                    (attempts > 0 ? " (attempt " + attempts + ")" : "") + "...";
                _this.logger.log(generationMessage);
                _this.loadingStatus = "Generating level " + level + "...";
                if (_this.winDialog)
                    _this.winDialog.message = generationMessage;
                if (_this.winDialog && _this.winDialog.dismissButton)
                    _this.winDialog.dismissButton.disabled = true;
                ++attempts;
                var p = new Promise(function (res, rej) { return setTimeout(res, 50); }).then(function () {
                    var maze = generator.generate();
                    _this.logger.log("Generated maze graph with " + maze.nodes.length + " nodes, " + maze.links.length + " links");
                    var gdm = new GameDataManager_4.default(_this.datastore);
                    var worldifier = new GraphWorldifier_1.default(gdm, maze);
                    worldifier.gardenChance = Math.random() * Math.random();
                    worldifier.caveChance = Math.min(1, level / 10) * Math.random();
                    worldifier.baseRootiness = Math.min(1, level / 10) * Math.random() * Math.random() * 3;
                    worldifier.themeAreaSize = 4 + Math.random() * 8;
                    return worldifier;
                }).then(function (worldifier) { return GraphWorldifier_1.mazeToWorld(worldifier); }).then(function (_a) {
                    var gdm = _a.gdm, playerId = _a.playerId, startRoomRef = _a.startRoomRef;
                    _this.hideDialog(_this.winDialog);
                    return _this.loadGame2(gdm, playerId, startRoomRef, "generated maze").then(function () {
                        _this.restartLevel();
                    });
                }, function (err) {
                    if (attempts < 50) {
                        _this.logger.warn("Maze generation failed; trying agin (attempt #" + attempts + "): ", err);
                        return generateMaze();
                    }
                    else {
                        var errorMessage = "Maze generation failed 50 times!  I guess my generator sucks!";
                        _this.logger.error(errorMessage);
                        if (_this.winDialog)
                            _this.winDialog.message = errorMessage;
                        _this.loadingStatus = "Error generating maze!";
                        return Promise.reject(err);
                    }
                }).then(function () {
                    _this.currentLevelNumber = level;
                });
                return promises_5.finalmente(p, function () {
                    if (_this.winDialog && _this.winDialog.dismissButton)
                        _this.winDialog.dismissButton.disabled = false;
                });
            };
            return generateMaze().then(function () { return _this.simulator; });
        };
        MazeDemo.prototype.hideDialog = function (d) {
            hideDialogBox(d);
            this.refocus();
        };
        /** Refocus game interface if dialog boxes are closed */
        MazeDemo.prototype.refocus = function () {
            if (dialogBoxIsVisible(this.winDialog))
                return;
            if (dialogBoxIsVisible(this.consoleDialog))
                return;
            if (dialogBoxIsVisible(this.helpDialog))
                return;
            if (dialogBoxIsVisible(this.loadDialog))
                return;
            this.focusGameInterface();
        };
        /*
         * Close any dialog boxes and focus the game interface.
         */
        MazeDemo.prototype.focusGameInterface = function () {
            hideDialogBox(this.winDialog);
            hideDialogBox(this.consoleDialog);
            hideDialogBox(this.helpDialog);
            hideDialogBox(this.loadDialog);
            if (this.gameInterfaceElem)
                this.gameInterfaceElem.focus();
        };
        MazeDemo.prototype.inspect = function (ref) {
            return this.simulator.gameDataManager.fetchObject(ref);
        };
        MazeDemo.prototype.exportCachedData = function () {
            var _this = this;
            var leObj = {};
            for (var k in this.memoryDatastore.values) {
                var v = this.memoryDatastore.values[k];
                try {
                    var str = index_10.utf8Decode(v);
                    leObj[k] = str;
                }
                catch (err) { } // That's fine.  Just skip it.
            }
            JSONObjectDatastore_3.storeObject(leObj, this.exportDatastore).then(function (urn) {
                _this.logger.log("JSON cache dump: ", urn);
            });
        };
        MazeDemo.prototype.importCacheStrings = function (exported) {
            for (var k in exported) {
                var v = index_10.utf8Encode(exported[k]);
                this.memoryDatastore.put(k, v);
            }
        };
        MazeDemo.prototype.eventToCanvasPixelCoordinates = function (evt) {
            var canv = this.canvas;
            return {
                x: evt.offsetX * (canv.width / canv.clientWidth),
                y: evt.offsetY * (canv.height / canv.clientHeight),
                z: 0
            };
        };
        MazeDemo.prototype.maybePaint = function () {
            var coords = this.paintCoordinates;
            if (coords) {
                this.enqueueMessage([simulationmessaging_1.ROOMID_FINDENTITY, this.playerId], ["/painttiletreeblock", coords.x, coords.y, coords.z, 1, this.paintEntityClassRef]);
            }
        };
        MazeDemo.prototype.handleMouseEvent = function (evt) {
            if (evt.buttons == 1) {
                var cpCoords = this.eventToCanvasPixelCoordinates(evt);
                var coords = this.view.canvasPixelToWorldCoordinates(cpCoords.x, cpCoords.y);
                switch (this._demoMode) {
                    case DemoMode.EDIT:
                        if (this.picking) {
                            var entity = this.view.getTileEntityAt(coords, 1);
                            this.tilePaletteUi.setSlot(this.tilePaletteUi.selectedSlotIndex, entity || null);
                        }
                        else {
                            this.paintCoordinates = coords;
                            this.maybePaint();
                        }
                        break;
                    case DemoMode.PLAY:
                        if (!this.mouse1PreviouslyDown) {
                            var itemKey = this.maze1InventoryUi.selectedItemKey;
                            if (itemKey)
                                this.enqueueMessage([simulationmessaging_1.ROOMID_FINDENTITY, this.playerId], ["/throwinventoryitem", this.maze1InventoryUi.selectedItemKey, coords.x, coords.y, coords.z]);
                        }
                        break;
                }
                this.mouse1PreviouslyDown = true;
            }
            else {
                this.paintCoordinates = undefined;
                this.mouse1PreviouslyDown = false;
            }
        };
        MazeDemo.prototype.addToCommandHistory = function (cmd) {
            if (this.commandHistory[this.commandHistory.length - 1] == cmd)
                return;
            this.commandHistory.push(cmd);
        };
        MazeDemo.prototype.moveThroughCommandHistory = function (delta) {
            if (delta == 0)
                return;
            delta = delta < 0 ? -1 : +1;
            if (this.commandHistoryIndex == null) {
                this.commandHistoryIndex = this.commandHistory.length;
            }
            var newIndex = this.commandHistoryIndex + delta;
            newIndex = newIndex < 0 ? 0 : newIndex > this.commandHistory.length ? this.commandHistory.length : newIndex;
            if (newIndex == this.commandHistoryIndex)
                return;
            if (newIndex < 0)
                newIndex = 0;
            if (newIndex > this.commandHistory.length)
                newIndex = this.commandHistory.length;
            this.goToCommandHistory(newIndex);
        };
        MazeDemo.prototype.goToCommandHistory = function (index) {
            if (index == this.commandHistoryIndex)
                return;
            if (!this.consoleDialog)
                return;
            var input = this.consoleDialog.inputElement;
            if (this.commandHistoryIndex == this.commandHistory.length) {
                this.commandScratch = input.value;
            }
            this.commandHistoryIndex = index;
            var text = index == this.commandHistory.length ? this.commandScratch : this.commandHistory[index];
            input.value = text;
            input.setSelectionRange(text.length, text.length);
        };
        MazeDemo.prototype.goToCommandHistoryBeginning = function () { this.goToCommandHistory(0); };
        MazeDemo.prototype.goToCommandHistoryEnd = function () { this.goToCommandHistory(this.commandHistory.length); };
        MazeDemo.prototype.enqueueMessage = function (entityPath, command, replyPath) {
            if (replyPath === void 0) { replyPath = UI_ENTIY_PATH; }
            this.simulator.enqueueAction({
                classRef: "http://ns.nuke24.net/Game21/SimulationAction/ReceiveMessage",
                entityPath: entityPath,
                replyPath: replyPath,
                message: {
                    classRef: "http://ns.nuke24.net/Game21/SimulationMessage/CommandReceived",
                    command: command
                }
            });
        };
        MazeDemo.prototype.submitConsoleCommand = function (cmd) {
            var _this = this;
            if (cmd == null) {
                if (!this.consoleDialog)
                    return;
                cmd = this.consoleDialog.inputElement.value;
                this.consoleDialog.inputElement.value = "";
                this.addToCommandHistory(cmd);
                this.goToCommandHistoryEnd();
            }
            cmd = cmd.trim();
            if (cmd == '') {
                // Do nothing, don't add to history
                return;
            }
            else if (cmd[0] == '#') {
            }
            else if (cmd[0] == '/') {
                var tokens_1 = [];
                var tokenizer = new Tokenizer_2.default(function (token) {
                    if (token.type == Token_5.TokenType.END_OF_FILE)
                        return;
                    if (token.type == Token_5.TokenType.COMMENT)
                        return;
                    tokens_1.push(token);
                });
                tokenizer.sourceLocation = { fileUri: "console-input", lineNumber: this.commandHistory.length + 1, columnNumber: 1 };
                tokenizer.text(cmd.substr(1));
                tokenizer.end();
                if (tokens_1.length == 0) {
                    return;
                }
                else {
                    var tt0 = tokens_1[0].text;
                    doCommand: switch (tt0) {
                        case 'set':
                        case 'set/cache':
                            if (!this.gameDataManager) {
                                this.logger.error("Can't update name mappings; no game loaded");
                                break;
                            }
                            if (tokens_1.length == 3) {
                                var name_2 = tokens_1[1].text;
                                var hardRef_1 = tokens_1[2].text;
                                if (tt0 == 'set/cache') {
                                    this.gameDataManager.cacheObjects([hardRef_1]).then(function () {
                                        _this.gameDataManager.updateMap((_a = {}, _a[name_2] = hardRef_1, _a));
                                        var _a;
                                    });
                                }
                                else {
                                    this.gameDataManager.updateMap((_a = {}, _a[name_2] = hardRef_1, _a));
                                }
                            }
                            else {
                                this.logger.error("/set takes 2 arguments: /set <name> <hard reference>");
                            }
                            break;
                        case 'get-hard-ref':
                            if (!this.gameDataManager) {
                                this.logger.error("Can't look up hard refs; no game loaded");
                                break;
                            }
                            var _loop_9 = function(t) {
                                var name_3 = tokens_1[t].text;
                                this_7.gameDataManager.fetchHardRef(name_3).then(function (hardRef) {
                                    _this.logger.log("/set/cache '" + name_3 + "' '" + hardRef + "'");
                                }).catch(function (err) {
                                    _this.logger.error("Failed to look up hard ref for '" + name_3 + "':", err);
                                });
                            };
                            var this_7 = this;
                            for (var t = 1; t < tokens_1.length; ++t) {
                                _loop_9(t);
                            }
                            ;
                            break;
                        case 'cache':
                            if (!this.gameDataManager) {
                                this.logger.error("Can't cache anything; no game loaded");
                                break;
                            }
                            {
                                var stuffToCache = [];
                                for (var t = 1; t < tokens_1.length; ++t) {
                                    stuffToCache.push(tokens_1[t].text);
                                }
                                this.gameDataManager.cacheObjects(stuffToCache);
                            }
                            break;
                        case 'next-level':
                            this.generateAndLoadNewLevel(this.currentLevelNumber + 1);
                            break;
                        case 'level':
                            {
                                if (tokens_1.length == 1) {
                                    this.logger.log("Current level: " + this.currentLevelNumber);
                                }
                                else if (tokens_1.length == 2) {
                                    this.generateAndLoadNewLevel(parseInt(tokens_1[1].text));
                                }
                                else {
                                    this.logger.error("/level takes zero or one argument: /level [<level number>]");
                                }
                            }
                            ;
                            break;
                        case 'export-cached-data':
                        case 'ecd':
                            this.exportCachedData();
                            break;
                        case 'edit-mode':
                            this.demoMode = DemoMode.EDIT;
                            break;
                        case 'play-mode':
                            this.demoMode = DemoMode.PLAY;
                            break;
                        case 'save':
                            {
                                if (tokens_1.length == 2) {
                                    this.saveGame2(tokens_1[1].text);
                                    this.logger.log("Saving...");
                                }
                                else {
                                    this.logger.error("/save requires a single argument, e.g. /save \"a good save!\"");
                                }
                            }
                            break;
                        case 'show-console':
                            this.popUpConsole("");
                            break;
                        case 'hide-console':
                            this.hideDialog(this.consoleDialog);
                            break;
                        case 'echo':
                            {
                                var texts = [];
                                for (var i = 1; i < tokens_1.length; ++i)
                                    texts.push(tokens_1[i].text);
                                this.logger.log.apply(this.logger, texts);
                            }
                            break;
                        case 'load':
                            {
                                if (tokens_1.length != 2) {
                                    this.logger.error("Load takes a single argument: <savegame URI>");
                                    //e.g. urn:sha1:53GHW7DMQF472PTXLWKKE25BKUJXOTXZ#
                                    break doCommand;
                                }
                                this.loadGame(tokens_1[1].text);
                            }
                            break;
                        case 'set-tile-palette-slot':
                            {
                                var slotIndex = this.tilePaletteUi.selectedSlotIndex;
                                var classRef = void 0;
                                if (tokens_1.length == 3) {
                                    slotIndex = parseInt(tokens_1[1].text) | 0;
                                    classRef = tokens_1[2].text;
                                }
                                else if (tokens_1.length == 2) {
                                    classRef = tokens_1[1].text;
                                }
                                else {
                                    this.logger.error("set-tile-palette-slot takes 1 or 2 arguments: [<slot number>] <entity class ref>");
                                    break;
                                }
                                this.tilePaletteUi.setSlot(slotIndex, classRef);
                            }
                            break;
                        case 'default-room-size':
                            {
                                if (tokens_1[1]) {
                                    this.defaultNewRoomSize = +tokens_1[1].text;
                                }
                                this.logger.log("Default room size is now " + this.defaultNewRoomSize);
                            }
                            break;
                        case 'create-new-room':
                            {
                                var newRoomUuid = newUuidRef();
                                this.logger.log("New room ID:", newRoomUuid);
                                var size = tokens_1[2] ? +tokens_1[2].text : this.defaultNewRoomSize;
                                this.enqueueMessage([simulationmessaging_1.ROOMID_SIMULATOR], ["/create-room", newRoomUuid, size]);
                            }
                            break;
                        case 'connect-new-room':
                        case 'dig-new-room':
                        case 'dnr':
                            {
                                var currentLocation = this.view.viewage.cameraLocation;
                                if (!currentLocation || !currentLocation.roomRef) {
                                    this.logger.error("Can't dig to new room; current room ID not known.");
                                    break doCommand;
                                }
                                if (tokens_1.length != 2) {
                                    this.logger.error("/connect-new-room takes 1 argument: <direction (t,l,r,b,a,z)>");
                                    break doCommand;
                                }
                                var newRoomUuid = newUuidRef();
                                var dir = tokens_1[1].text;
                                this.logger.log("New room ID:", newRoomUuid);
                                this.enqueueMessage([simulationmessaging_1.ROOMID_SIMULATOR], ["/create-room", newRoomUuid, this.defaultNewRoomSize]);
                                this.enqueueMessage([simulationmessaging_1.ROOMID_SIMULATOR], ["/connect-rooms", currentLocation.roomRef, dir, newRoomUuid]);
                            }
                            break;
                        case 'cr':
                        case 'connect-rooms':
                            {
                                if (tokens_1.length != 4) {
                                    this.logger.error("/cr takes 3 arguments: <room 1 ID> <direction (t,l,r,b,a,z)> <room2 ID>");
                                    break doCommand;
                                }
                                var roomAId = tokens_1[1].text;
                                var dirName = tokens_1[2].text;
                                var roomBId = tokens_1[3].text;
                                this.enqueueMessage([simulationmessaging_1.ROOMID_SIMULATOR], ["/connect-rooms", roomAId, dirName, roomBId]);
                            }
                            break;
                        case 'restart-level':
                            this.restartLevel();
                            break;
                        case 'sound-effects':
                            if (tokens_1.length == 1) {
                            }
                            else if (tokens_1.length == 2) {
                                var t = tokens_1[1].text.trim().toLowerCase();
                                var v = void 0;
                                switch (t) {
                                    case '0':
                                    case 'off':
                                    case 'false':
                                    case 'disabled':
                                        v = false;
                                        break;
                                    case '1':
                                    case 'on':
                                    case 'true':
                                    case 'enabled':
                                        v = true;
                                        break;
                                    default:
                                        this.logger.error("Bad on/off value: '" + t + "'");
                                        break doCommand;
                                }
                                this.soundEffectsEnabled = v;
                            }
                            else {
                                this.logger.error("Usage: /sound-effects [on|off]");
                                break;
                            }
                            this.logger.log("Sound effects are " + (this.soundEffectsEnabled ? "enabled" : "disabled"));
                            break;
                        case 'vomit':
                            this.enqueueMessage([simulationmessaging_1.ROOMID_FINDENTITY, this.playerId], ["/vomit"]);
                            break;
                        case 'give':
                            if (tokens_1.length == 2) {
                                this.enqueueMessage([simulationmessaging_1.ROOMID_FINDENTITY, this.playerId], ["/give", tokens_1[1].text]);
                            }
                            else {
                                this.logger.error("/give takes 1 argument: <entity class ref>.  e.g. '/give urn:uuid:4f3fd5b7-b51e-4ae7-9673-febed16050c1'");
                            }
                            break;
                        default:
                            this.logger.error("Unrecognized command: /" + tokens_1[0].text);
                            break;
                    }
                }
            }
            var _a;
        };
        MazeDemo.prototype.popUpConsole = function (initialText) {
            if (!this.consoleDialog)
                return;
            this.goToCommandHistoryEnd();
            this.consoleDialog.inputElement.value = initialText;
            this.consoleDialog.setVisible(true);
            this.consoleDialog.inputElement.setSelectionRange(initialText.length, initialText.length);
            this.consoleDialog.inputElement.focus();
        };
        MazeDemo.prototype.popUpWinDialog = function (text) {
            if (this.winDialog) {
                this.logger.log(text);
                this.winDialog.message = text;
                this.winDialog.setVisible(true);
            }
            else {
                this.logger.log(text + "\nBut there's no win dialog.  Type '/next-level' to go to the next level");
            }
        };
        return MazeDemo;
    }());
    exports.MazeDemo = MazeDemo;
    var DialogBox = (function () {
        function DialogBox(element) {
            this.element = element;
        }
        Object.defineProperty(DialogBox.prototype, "isVisible", {
            get: function () {
                return this.element.style.display != 'none';
            },
            set: function (v) {
                this.setVisible(v);
            },
            enumerable: true,
            configurable: true
        });
        /**
         * Always use demo.hideDialog so that focus can be put back on game interface!
         * when no dialogs are visible!
         */
        DialogBox.prototype.setVisible = function (viz) {
            this.element.style.display = viz ? "" : "none";
        };
        return DialogBox;
    }());
    function dialogBoxIsVisible(db) {
        return db != undefined && db.isVisible;
    }
    function hideDialogBox(db) {
        if (db)
            db.setVisible(false);
    }
    var EventDialogBox = (function (_super) {
        __extends(EventDialogBox, _super);
        function EventDialogBox() {
            _super.apply(this, arguments);
        }
        Object.defineProperty(EventDialogBox.prototype, "message", {
            set: function (text) {
                var e = this.messageAreaElement;
                if (e) {
                    while (e.firstChild)
                        e.removeChild(e.firstChild);
                    var p = document.createElement('p');
                    p.appendChild(document.createTextNode(text));
                    e.appendChild(p);
                }
            },
            enumerable: true,
            configurable: true
        });
        EventDialogBox.prototype.setVisible = function (viz) {
            _super.prototype.setVisible.call(this, viz);
            if (viz && this.dismissButton)
                this.dismissButton.focus();
        };
        return EventDialogBox;
    }(DialogBox));
    var TileEntityRenderer = (function () {
        function TileEntityRenderer(gameDataManager) {
            this.gameDataManager = gameDataManager;
            this.imageCache = {};
            this.entityClassUrlishIconPromises = {};
            this.entityImageManager = new EntityImageManager(gameDataManager);
        }
        TileEntityRenderer.prototype.renderEntity = function (position, orientation, ppm, entity, ctx) {
            var _this = this;
            return this.gameDataManager.fetchObject(entity.classRef).then(function (entityClass) {
                if (entityClass.visualRef) {
                    return _this.entityClassRefIcon(entity.classRef).then(function (icon) {
                        var iconScale = ppm / icon.resolution;
                        ctx.drawImage(icon.sheet, icon.bounds.minX, icon.bounds.minY, aabbs_8.aabbWidth(icon.bounds), aabbs_8.aabbHeight(icon.bounds), position.x * ppm + iconScale * (icon.bounds.minX - icon.origin.x), position.y * ppm + iconScale * (icon.bounds.minY - icon.origin.y), iconScale * aabbs_8.aabbWidth(icon.bounds), iconScale * aabbs_8.aabbHeight(icon.bounds));
                    });
                }
                var renderPromises = [];
                worldutil_5.eachSubEntity(entity, position, _this.gameDataManager, function (subEnt, subPos, subOri) {
                    renderPromises.push(_this.renderEntity(subPos, subOri, ppm, subEnt, ctx));
                });
                return Promise.all(renderPromises).then(function () { });
            });
        };
        TileEntityRenderer.prototype.entityClassRefIcon = function (entityClassRef) {
            var _this = this;
            if (this.entityClassUrlishIconPromises.hasOwnProperty(entityClassRef)) {
                return this.entityClassUrlishIconPromises[entityClassRef];
            }
            return this.gameDataManager.fetchObject(entityClassRef).then(function (entityClass) {
                if (entityClass.visualRef) {
                    return _this.entityImageManager.fetchIcon(entityClass.visualRef, {}, 0, Quaternion_6.default.IDENTITY, 32);
                }
                else if (entityClass.structureType != world_7.StructureType.INDIVIDUAL) {
                    var canv_1 = document.createElement('canvas');
                    var vbb = entityClass.visualBoundingBox;
                    var maxCanvWidth = 32, maxCanvHeight = 32;
                    var scale_1 = Math.min(maxCanvWidth / aabbs_8.aabbWidth(vbb), maxCanvHeight / aabbs_8.aabbHeight(vbb));
                    canv_1.width = (scale_1 * aabbs_8.aabbWidth(vbb)) | 0;
                    canv_1.height = (scale_1 * aabbs_8.aabbHeight(vbb)) | 0;
                    var ctx = canv_1.getContext('2d');
                    if (ctx == null)
                        return Promise.reject(new Error("Failed to create 2d rendering context"));
                    return _this.renderEntity(vector3ds_17.makeVector(aabbs_8.aabbWidth(vbb) / 2, aabbs_8.aabbHeight(vbb) / 2, 0), Quaternion_6.default.IDENTITY, scale_1, { classRef: entityClassRef }, ctx).then(function () {
                        var imgUrl = canv_1.toDataURL();
                        return {
                            bounds: { minX: 0, minY: 0, minZ: 0, maxX: canv_1.width, maxY: canv_1.height, maxZ: 0 },
                            origin: { x: canv_1.width / 2, y: canv_1.height / 2, z: 0 },
                            resolution: 1 / scale_1,
                            sheetRef: imgUrl,
                            sheet: images_1.imageFromUrl(imgUrl),
                        };
                    });
                }
                return Promise.resolve(images_1.EMPTY_IMAGE_SLICE);
            });
        };
        TileEntityRenderer.prototype.entityIcon = function (entity, orientation) {
            if (entity == null)
                return Promise.resolve(images_1.EMPTY_IMAGE_SLICE);
            return this.entityClassRefIcon(entity.classRef);
        };
        return TileEntityRenderer;
    }());
    function startDemo(canv, saveGameRef, loadingStatusUpdated, cacheStrings) {
        if (loadingStatusUpdated === void 0) { loadingStatusUpdated = function (t) { }; }
        if (cacheStrings === void 0) { cacheStrings = {}; }
        var dataIdent = index_10.sha1Urn;
        var ds2 = HTTPHashDatastore_5.default.createDefault();
        var ds1 = window.localStorage ? new CachingDatastore_1.default(dataIdent, new BrowserStorageDatastore_2.default(dataIdent, window.localStorage), ds2) : ds2;
        var memds = new MemoryDatastore_3.default(dataIdent);
        var expds = new MemoryDatastore_3.default(dataIdent);
        var ds = new CachingDatastore_1.default(dataIdent, memds, new MultiDatastore_1.default(dataIdent, [ds1], [expds]));
        var v = new MazeView(canv);
        var demo = new MazeDemo();
        demo.soundPlayer = new SoundPlayer_1.default(ds);
        demo.canvas = canv;
        demo.datastore = ds;
        demo.memoryDatastore = memds;
        demo.exportDatastore = expds;
        demo.view = v;
        demo.loadingStatusUpdated = loadingStatusUpdated;
        demo.importCacheStrings(cacheStrings);
        var gameLoaded = demo.loadGame(saveGameRef || "level0");
        canv.addEventListener('mousedown', demo.handleMouseEvent.bind(demo));
        canv.addEventListener('mouseup', demo.handleMouseEvent.bind(demo));
        canv.addEventListener('mousemove', demo.handleMouseEvent.bind(demo));
        var tpArea = document.getElementById('tile-palette-area');
        if (tpArea) {
            var tpUi_1 = new TilePalette_1.default(16);
            var invUi_1 = new TilePalette_1.default(4);
            tpUi_1.element.style.display = 'none';
            demo.tilePaletteUi = tpUi_1;
            demo.maze1InventoryUi = invUi_1;
            tpUi_1.on('select', function (index, te) {
                demo.paintEntityClassRef = te ? te.entity.classRef : null;
            });
            tpArea.appendChild(invUi_1.element);
            tpArea.appendChild(tpUi_1.element);
            gameLoaded.then(function () {
                var entityRenderer = new TileEntityRenderer(demo.simulator.gameDataManager);
                invUi_1.entityRenderer = tpUi_1.entityRenderer = function (ent, orientation) {
                    return entityRenderer.entityIcon(ent, orientation).then(function (icon) { return icon.sheetRef; });
                };
                var initialPaletteEntityClassRefs = [
                    null, dat.brikEntityClassId, dat.bigBrikEntityClassId,
                    dat.bigYellowBrikEntityClassId, dat.vines1EntityClassId,
                    dat.backLadderEntityClassId, dat.plant1EntityClassId,
                    dat.doorFrameEntityClassId,
                    dat.latticeColumnRightBlockEntityClassId,
                    dat.latticeColumnLeftBlockEntityClassId,
                    dat.latticeColumnBgRightBlockEntityClassId,
                    dat.latticeColumnBgLeftBlockEntityClassId,
                ];
                for (var i = 0; i < initialPaletteEntityClassRefs.length; ++i) {
                    tpUi_1.setSlot(i, initialPaletteEntityClassRefs[i]);
                }
            });
        }
        var butta = document.getElementById('button-area');
        if (butta) {
            var targetEntityIdBox_1 = document.createElement("select");
            targetEntityIdBox_1.value = dat.door3EntityId;
            var selectable = {
                "Door": dat.door3EntityId,
                "Lift": dat.platformEntityId
            };
            for (var s in selectable) {
                var opt = document.createElement("option");
                opt.value = selectable[s];
                opt.appendChild(document.createTextNode(s));
                targetEntityIdBox_1.appendChild(opt);
            }
            var openDoorButton = document.createElement('button');
            openDoorButton.appendChild(document.createTextNode("Up"));
            openDoorButton.onclick = function () {
                demo.enqueueMessage([simulationmessaging_1.ROOMID_FINDENTITY, targetEntityIdBox_1.value], ["/desiredmovementdirection", 0, -1, 0]);
            };
            var closeDoorButton = document.createElement('button');
            closeDoorButton.appendChild(document.createTextNode("Down"));
            closeDoorButton.onclick = function () {
                demo.enqueueMessage([simulationmessaging_1.ROOMID_FINDENTITY, targetEntityIdBox_1.value], ["/desiredmovementdirection", 0, +1, 0]);
            };
            var udGroup = document.createElement("fieldset");
            udGroup.appendChild(targetEntityIdBox_1);
            udGroup.appendChild(openDoorButton);
            udGroup.appendChild(closeDoorButton);
            butta.appendChild(udGroup);
            var saveButton_1 = demo.saveButton = document.createElement("button");
            saveButton_1.appendChild(document.createTextNode("Save"));
            saveButton_1.onclick = function () {
                var saveNote = window.prompt("Note");
                if (saveNote == null || saveNote.length == 0)
                    return;
                saveButton_1.disabled = true;
                demo.saveGame2(saveNote);
            };
            butta.appendChild(saveButton_1);
            var loadDialogElem_1 = document.getElementById('load-dialog');
            if (loadDialogElem_1) {
                var loadDialog_1 = demo.loadDialog = new DialogBox(loadDialogElem_1);
                var loadButton_1 = document.createElement("button");
                loadButton_1.appendChild(document.createTextNode("Load..."));
                loadButton_1.onclick = function () {
                    loadButton_1.disabled = true;
                    var loadList = document.getElementById('load-list');
                    if (loadList) {
                        while (loadList.firstChild)
                            loadList.removeChild(loadList.firstChild);
                        var savesJson = window.localStorage.getItem("game21-local-saves");
                        var saves = savesJson ? JSON.parse(savesJson) : [];
                        var _loop_10 = function(s) {
                            var save = saves[s];
                            var loadItem = document.createElement('li');
                            loadItem.appendChild(document.createTextNode(save.note + " - " + save.date));
                            loadItem.onclick = function () {
                                demo.hideDialog(loadDialog_1);
                                loadButton_1.disabled = false;
                                demo.loadGame(save.saveRef);
                            };
                            loadList.appendChild(loadItem);
                        };
                        for (var s in saves) {
                            _loop_10(s);
                        }
                    }
                    loadDialog_1.setVisible(true);
                };
                var cancelLoadButton = document.getElementById('load-cancel-button');
                if (cancelLoadButton) {
                    cancelLoadButton.onclick = function () {
                        loadDialogElem_1.style.display = 'none';
                        loadButton_1.disabled = false;
                    };
                }
                butta.appendChild(loadButton_1);
            }
            var helpDialogElement = document.getElementById('help-dialog');
            if (helpDialogElement) {
                var helpDialog_1 = demo.helpDialog = new DialogBox(helpDialogElement);
                var helpButton = document.createElement('button');
                helpButton.appendChild(document.createTextNode("Help!"));
                helpButton.onclick = function () { return helpDialog_1.setVisible(true); };
                var closeHelpButton = document.getElementById('help-close-button');
                if (closeHelpButton)
                    closeHelpButton.onclick = function () { return demo.hideDialog(helpDialog_1); };
                butta.appendChild(helpButton);
            }
        }
        var gameInterfaceElem = demo.gameInterfaceElem = document.getElementById('game-interface');
        if (gameInterfaceElem) {
            gameInterfaceElem.addEventListener('keydown', demo.gameKeyDown.bind(demo), true);
            //gameInterfaceElem.addEventListener('keyup', demo.gameKeyUp.bind(demo), true);
            gameInterfaceElem.focus();
        }
        else {
            console.warn("No game interface element!  Binding key listeners to window");
            window.addEventListener('keydown', demo.gameKeyDown.bind(demo));
        }
        window.addEventListener('keydown', demo.globalKeyDown.bind(demo));
        window.addEventListener('keyup', demo.globalKeyUp.bind(demo));
        var winDialogElem = document.getElementById('win-dialog');
        if (winDialogElem) {
            var winDialog = demo.winDialog = new EventDialogBox(winDialogElem);
            winDialog.messageAreaElement = document.getElementById('win-dialog-message-area');
            var winButtonArea = document.getElementById('win-dialog-button-area');
            var dismissWinDialog_1 = function () {
                demo.generateAndLoadNewLevel(demo.currentLevelNumber + 1);
            };
            if (winButtonArea) {
                var nextLevelButton = winDialog.dismissButton = document.createElement('button');
                nextLevelButton.appendChild(document.createTextNode('Next level!'));
                nextLevelButton.onclick = dismissWinDialog_1;
                winButtonArea.appendChild(nextLevelButton);
            }
            winDialogElem.addEventListener('keydown', function (keyEvent) {
                if (keyEvent.keyCode == KEY_ESC || keyEvent.keyCode == KEY_ENTER) {
                    dismissWinDialog_1();
                    keyEvent.preventDefault();
                    keyEvent.stopPropagation();
                }
            });
        }
        var restartDialogElem = document.getElementById('restart-dialog');
        if (restartDialogElem) {
            var restartDialog = demo.restartDialog = new EventDialogBox(restartDialogElem);
            restartDialog.messageAreaElement = document.getElementById('restart-dialog-message-area');
            var restartButtonArea = document.getElementById('restart-dialog-button-area');
            var dismissRestartDialog_1 = function () {
                demo.restartLevel();
            };
            if (restartButtonArea) {
                var restartLevelButton = restartDialog.dismissButton = document.createElement('button');
                restartLevelButton.appendChild(document.createTextNode('Respawn'));
                restartLevelButton.onclick = dismissRestartDialog_1;
                restartButtonArea.appendChild(restartLevelButton);
            }
            restartDialogElem.addEventListener('keydown', function (keyEvent) {
                if (keyEvent.keyCode == KEY_ESC || keyEvent.keyCode == KEY_ENTER) {
                    dismissRestartDialog_1();
                    keyEvent.preventDefault();
                    keyEvent.stopPropagation();
                }
            });
        }
        var consoleDialogElem = document.getElementById('console-dialog');
        if (consoleDialogElem) {
            var consoleDialog_1 = demo.consoleDialog = new DialogBox(consoleDialogElem);
            consoleDialog_1.inputElement = document.getElementById('console-input');
            consoleDialog_1.inputElement.addEventListener('keydown', function (keyEvent) {
                if (keyEvent.keyCode == KEY_UP) {
                    demo.moveThroughCommandHistory(-1);
                    keyEvent.preventDefault();
                    keyEvent.stopPropagation();
                }
                else if (keyEvent.keyCode == KEY_DOWN) {
                    demo.moveThroughCommandHistory(+1);
                    keyEvent.preventDefault();
                    keyEvent.stopPropagation();
                }
                else if (keyEvent.keyCode == KEY_ENTER) {
                    demo.submitConsoleCommand.bind(demo)();
                    keyEvent.preventDefault();
                    keyEvent.stopPropagation();
                }
            });
            var consoleCloseButton = document.getElementById('console-close-button');
            if (consoleCloseButton)
                consoleCloseButton.onclick = function () { return demo.hideDialog(consoleDialog_1); };
            consoleDialogElem.addEventListener('keydown', function (keyEvent) {
                if (keyEvent.keyCode == KEY_ESC) {
                    demo.hideDialog(consoleDialog_1);
                }
                // Prevent any keys from propagating to the window and messing up our game
                keyEvent.stopPropagation();
            }, false);
            // Why did I need this?
            consoleDialogElem.addEventListener('keyup', function (keyEvent) { return keyEvent.preventDefault(); });
            // Stand firm for what you believe in, until and unless experience proves you wrong.
            // Remember, when the emperor looks naked, the emperor *is* naked.
            // The truth and a lie are not sort of the same thing.
            // And there is no aspect, no facet, no moment of life that can't be improved with pizza.
            var loggers = [console];
            var htmlConsoleElement = document.getElementById('console-output');
            if (htmlConsoleElement) {
                var hashUrnRegex_1 = /^(urn:(?:sha1|bitprint):[^#]+)(\#.*)?$/;
                var domLogger = new DOMLogger_1.default(htmlConsoleElement);
                domLogger.fragReplacer = function (thing) {
                    if (typeof thing == 'string') {
                        var m = void 0;
                        if ((m = hashUrnRegex_1.exec(thing))) {
                            var dataUrn = m[1];
                            var target = demo.datastore.get(dataUrn);
                            var linkUrl = target ?
                                "data:application/json;base64," + base64Encode(target) :
                                "http://game21-data.nuke24.net/uri-res/raw/" + encodeURIComponent(dataUrn) + "/thing.txt";
                            var fragElem = document.createElement('span');
                            var linkElem = document.createElement('a');
                            linkElem.href = linkUrl;
                            linkElem.appendChild(document.createTextNode(m[1]));
                            fragElem.appendChild(linkElem);
                            if (m[2] && m[2].length > 0)
                                fragElem.appendChild(document.createTextNode(m[2]));
                            return [fragElem];
                        }
                    }
                    return undefined;
                };
                loggers.push(domLogger);
            }
            demo.logger = new MultiLogger_1.default(loggers);
        }
        var inventoryDialogElement = document.getElementById('inventory-dialog');
        if (inventoryDialogElement) {
            inventoryDialogElement.style.display = 'none';
            var ui_1 = new inventory_1.StorageCompartmentContentUI();
            demo.addContextListener(function (ctx) {
                ui_1.entityRenderer = function (entity) { return ctx.entityImageManager.fetchEntityIcon(entity, 0, Quaternion_6.default.IDENTITY, 32); };
            });
        }
        var energyBarElement = document.getElementById('energy-bar');
        var energyCounterElement = document.getElementById('energy-counter');
        var energyCounterTextNode = energyCounterElement && energyCounterElement.firstChild.nodeType == Node.TEXT_NODE ?
            energyCounterElement.firstChild : undefined;
        if (energyBarElement) {
            demo.energyIndicator = {
                set value(v) {
                    if (energyBarElement)
                        energyBarElement.style.width = (v == undefined ? 0 : v * 400 / 100000) + 'px';
                    if (energyCounterTextNode)
                        energyCounterTextNode.nodeValue = (v == undefined ? "--" : Math.round(v).toFixed(0));
                }
            };
            demo.energyIndicator.value = undefined;
        }
        return demo;
    }
    exports.startDemo = startDemo;
    var _a;
});
/// <reference path="../Promise.d.ts" />
/* ]]> */</script>
<script type="text/javascript">//<![CDATA[
	function updateLoadingStatus(text) {
		var div = document.getElementById('loading-status-box');
		if( text == null || text.length == 0 ) {
			div.style.display = 'none';
			div.firstChild.nodeValue = "";
		} else {
			div.style.display = '';
			div.firstChild.nodeValue = text;
		}
	}

	require(['togos-game21/Maze1'], function(_Maze1) {
		updateLoadingStatus("Importing cache data...");
		
		var cacheStrings = {
			"urn:sha1:CIVZODABOUQCPKTOHTGGH5YS2ZEZZGVA": "{\n\t\"gameDataRef\": \"urn:sha1:457M3J272UXEVFUYJRGTYUVY5UODPF5K#\",\n\t\"rootRoomId\": \"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5941\",\n\t\"playerId\": \"urn:uuid:d42a8340-ec03-482b-ae4c-a1bfdec4ba32\"\n}\n",
			"urn:sha1:457M3J272UXEVFUYJRGTYUVY5UODPF5K": "{\n\t\"values\": {\n\t\t\"urn:uuid:3709e285-3444-420d-9753-ef101fd7924b\": \"urn:sha1:CASLCYPGJDP3NEZCYLSE6XTAGKUICVWQ#\",\n\t\t\"urn:uuid:6764a015-767e-4403-b565-4fbe94851f0e\": \"urn:sha1:SQDEY7PXPCOTS37E4J5FIKPFYW2WT2XX#\",\n\t\t\"urn:uuid:416bfc18-7412-489f-a45e-6ff4c6a4e08b\": \"urn:sha1:4CVALUALUAWW47I2HRCPQHKU6ZMQAHGX#\",\n\t\t\"urn:uuid:819f8257-bcad-4d2f-a64e-0a855ad9dd6e\": \"urn:sha1:3PQTAKG3X5CW222ETB7BNOB2ZQLEHF5J#\",\n\t\t\"urn:uuid:585927b9-b225-49d7-a49a-dff0445a1f78\": \"urn:sha1:6LRUFWPH4U4HHF6KF3ONEMPU6BQG5CQW#\",\n\t\t\"urn:uuid:5da4e293-031f-4062-b83f-83241d6768e9\": \"urn:sha1:IX62MRBWLKE5ZTS3NSGFMNSL3OD7F4MD#\",\n\t\t\"urn:uuid:13a4aa97-7b26-49ee-b282-fc53eccdf9cb\": \"urn:sha1:ECLZ2YCU5GLZ24BWCLLJVOWHUWRL3UV6#\",\n\t\t\"urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f77\": \"urn:sha1:2VDARGVUTOGU4RJ74WTUTT3X7GVKRAMK#\",\n\t\t\"urn:uuid:de6fbe4f-a475-46fe-8613-1900d6a5d36c\": \"urn:sha1:LYYME4OFV2PBBOJAXZRFCUE2SLZHOQDJ#\",\n\t\t\"urn:uuid:159aa4e5-016a-473d-9be7-5ba492fa899b\": \"urn:sha1:KUMPEBLX7TVYY7KAGCJ3MLL6SFVRRZVX#\",\n\t\t\"urn:uuid:fde59aa4-d580-456b-b173-2b65f837fcb0\": \"urn:sha1:BTPAHAF6SQHQBMEUQ6PZTJ4U5LVBESHF#\",\n\t\t\"urn:uuid:80cad088-4875-4fc4-892e-34c3035035cc\": \"urn:sha1:ANGIERNX22553GTA66GHF6LG2G4JNZ3R#\",\n\t\t\"urn:uuid:4ee24c8f-7309-462e-b219-ed60505bdb52\": \"urn:sha1:LPK5G4TEWN3WYAKPQUG66EBQWLVJJCQL#\",\n\t\t\"urn:uuid:601fb61a-df00-49bf-8189-877497cf492f\": \"urn:sha1:DIKGTQTWHLZ5NTPBWZKPPZKGGABW6TXL#\",\n\t\t\"urn:uuid:02056297-7242-4ff2-af15-69055671e5c5\": \"urn:sha1:4ILEXQUSIL2FK4ZXEULMOD3LMCVLYSBL#\",\n\t\t\"urn:uuid:9bee7432-5ad0-4f9d-9759-9d1a6fa02a85\": \"urn:sha1:MEJSVKEPQXJ37DPLD2EWPEO6YJP7DRD4#\",\n\t\t\"urn:uuid:b64789e4-023c-49ea-98b5-a9d892688bbb\": \"urn:sha1:UHLPT7XSX4TDR4I4LRUWDI4HSKDPD6SR#\",\n\t\t\"urn:uuid:c447986a-19d2-447a-ab39-afe9df781dbe\": \"urn:sha1:PRESXPBHFTFENY4GBOUJXS2ELODUV26O#\",\n\t\t\"urn:uuid:c145afdd-bc60-4c97-bad8-b6fcb3e1846f\": \"urn:sha1:OE6MZDMTTQZZJ3ACJZAJGWFWWOLWJC7H#\",\n\t\t\"urn:uuid:50c19be4-7ab9-4dda-a52f-cf4cfe2562ac\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\t\"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5941\": \"urn:sha1:OL4MALXUZUXFZIMRQHV524RSQSHVD7LR#\",\n\t\t\"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5942\": \"urn:sha1:SQJPFMV2GMNGADFUPABQ34WL3EQCCX33#\",\n\t\t\"urn:uuid:762f0209-0b91-4084-b1e0-3aac3ca5f5ab\": \"urn:sha1:TBDAUYVF3LFCW42C4Y643MZ2SDHD2VTX#\",\n\t\t\"urn:uuid:15b955ce-fc1a-487c-aa55-4b1ea0863464\": \"urn:sha1:RNRVGTH56URDA7SMYQC4QHCGGBQDA4KD#\",\n\t\t\"urn:uuid:489195b2-59e8-402e-9216-de71b68ef674\": \"urn:sha1:RBTSSKSLWCKJ4WXWPE23UYMINF5X2DT4#\",\n\t\t\"urn:uuid:4f9cfdbc-1a4c-4016-8b77-25969d425a57\": \"urn:sha1:4DHAFMJTSCPXSZX2BG6XKTU3LWQL5XNZ#\",\n\t\t\"urn:uuid:b529295e-a143-4646-8c6e-773bead08873\": \"urn:sha1:VGLOGHUGTSXI46TLL5EKVTR2C4FQZ5LD#\",\n\t\t\"urn:uuid:496c20d9-93b3-4f06-b0d5-37a6a4991627\": \"urn:sha1:57XOHTZIZYPZIU3VOG4LKGMTHVQR37ZY#\",\n\t\t\"urn:uuid:9500a034-65b4-439f-9721-9313aec9c190\": \"urn:sha1:WV4XL2DISYMDKJSJUP6IBJMZA7CTTNUJ#\",\n\t\t\"urn:uuid:8ab3a6fc-f4e5-405b-8a20-7fc7eb9107c7\": \"urn:sha1:YDYP72ATEWQNX36SMZLZ36CIUNLUB73Y#\",\n\t\t\"urn:uuid:df224f24-a83a-4e21-9456-cae51680aa80\": \"urn:sha1:OCYNZH4V2JNRAKKU4MK4S22ESIXJAY6Q#\",\n\t\t\"urn:uuid:f98c3b9f-86d2-4dd6-ba65-b818dacc25e1\": \"urn:sha1:UCS273BS76IQSNCVUA6RDD42VUIGK7ZH#\",\n\t\t\"urn:uuid:762472d7-b519-4850-9ee8-55a42f683014\": \"urn:sha1:BJF45ON5GCGIPSXPCFFMTBJUN5XCOD5C#\",\n\t\t\"urn:uuid:f37b5525-bf0d-4d81-81ad-8cdf4c1dc803\": \"urn:sha1:RIIOIESN7VZH2IFQ3WM3X22PGJ5CMWHV#\",\n\t\t\"urn:uuid:0bb511cf-d0e6-464e-8dd5-32b61aa6190c\": \"urn:sha1:CGXNV4GUHKOJM6L3LWLR3XML7RPV2WPM#\",\n\t\t\"urn:uuid:9f2c7823-4c7b-4112-9607-c0201a8ab91c\": \"urn:sha1:E7ZB2NUWSQPOZ6GVYJYAODHVZCOTCYK4#\",\n\t\t\"urn:uuid:6c4a07d2-132d-4a1c-bfd9-d471a55991e0\": \"urn:sha1:6JHCA5WBYH4M5OJENQVLOMIYIQKO74NG#\",\n\t\t\"urn:uuid:1aa9cc62-3904-42ee-a5a3-7811c2e8e3da\": \"urn:sha1:DNTWUAVDRCOKQJRNPVCCSRBPKVNYTZ23#\",\n\t\t\"urn:uuid:d0e528af-fdf8-47e4-9b75-68ca581bff3b\": \"urn:sha1:AWV6YZTDEG4SEK4IHMLYMEFNXIMKKAPC#\",\n\t\t\"urn:uuid:8d1cf0d5-8458-4455-ac1e-27fa0b1a752e\": \"urn:sha1:Y3YOT2JUJJTZIOHOHS7OTPECC7EDX2XI#\"\n\t},\n\t\"entryCount\": 40\n}\n",
			"urn:sha1:OL4MALXUZUXFZIMRQHV524RSQSHVD7LR": "{\n\t\"bounds\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:a11ed6ae-f096-4b30-bd39-2a78d39a1385\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:UGKXSSOQEPWEMUQMPMUTIEHEG4M3F6VO#\"\n\t\t\t}\n\t\t},\n\t\t\"urn:uuid:10070a44-2a0f-41a1-bcfb-b9e16a6f1b59\": {\n\t\t\t\"position\": {\"x\":-2.5,\"y\":-3.25,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:uuid:762f0209-0b91-4084-b1e0-3aac3ca5f5ab\"\n\t\t\t},\n\t\t\t\"velocity\": {\"x\":0,\"y\":-0.10416666666666669,\"z\":0},\n\t\t\t\"velocityPosition\": {\"x\":-2.5,\"y\":-3.188720703125,\"z\":0}\n\t\t},\n\t\t\"urn:uuid:27c27635-99ba-4ef3-b3ff-445eb9b132e5\": {\n\t\t\t\"position\": {\"x\":4,\"y\":-6.75,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:uuid:585927b9-b225-49d7-a49a-dff0445a1f78\",\n\t\t\t\t\"desiredMovementDirection\": {\"x\":0,\"y\":-1,\"z\":0}\n\t\t\t},\n\t\t\t\"velocity\": {\"x\":0,\"y\":0.19791666666666652,\"z\":0},\n\t\t\t\"velocityPosition\": {\"x\":3.953011514130368,\"y\":-6.800747949057131,\"z\":0}\n\t\t}\n\t},\n\t\"neighbors\": {\n\t\t\"w\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"bounds\": {\n\t\t\t\t\"minX\": -8,\n\t\t\t\t\"minY\": -8,\n\t\t\t\t\"minZ\": -0.5,\n\t\t\t\t\"maxX\": 8,\n\t\t\t\t\"maxY\": 8,\n\t\t\t\t\"maxZ\": 0.5\n\t\t\t},\n\t\t\t\"roomRef\": \"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5942\"\n\t\t},\n\t\t\"e\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"bounds\": {\n\t\t\t\t\"minX\": -8,\n\t\t\t\t\"minY\": -8,\n\t\t\t\t\"minZ\": -0.5,\n\t\t\t\t\"maxX\": 8,\n\t\t\t\t\"maxY\": 8,\n\t\t\t\t\"maxZ\": 0.5\n\t\t\t},\n\t\t\t\"roomRef\": \"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5942\"\n\t\t},\n\t\t\"n7OOGZCORZNJN6BQNYXS5ODP25FK6232F\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:15b955ce-fc1a-487c-aa55-4b1ea0863464\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t}\n}\n",
			"urn:sha1:UGKXSSOQEPWEMUQMPMUTIEHEG4M3F6VO": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:BOP3JKXLW3ADDCZ6OPXALZ4VVYJMC473#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,0,1,1,0,13,0,0,12,0,0,1,1,0,0,0,1,0,0,0,0,13,0,0,12,0,1,1,1,1,0,1,1,1,1,1,1,11,0,0,12,0,1,1,1,1,0,1,3,8,8,8,8,13,0,0,10,0,1,1,1,1,0,1,1,1,2,2,2,11,0,0,10,0,1,1,0,0,0,0,0,0,0,5,0,13,0,0,10,0,1,1,0,2,2,2,1,1,2,5,1,11,0,0,10,0,1,1,0,2,1,1,1,1,2,5,1,11,0,0,12,0,1,1,0,0,0,2,2,2,2,5,1,11,0,0,12,0,1,0,0,5,0,0,0,0,0,5,0,13,0,0,12,0,0,1,1,5,1,1,1,1,1,1,1,11,0,0,12,1,1,1,1,5,1,1,0,0,2,2,2,11,0,0,10,1,1,1,0,5,0,0,0,0,0,0,1,11,0,0,10,1,0,1,3,5,3,1,1,0,2,2,2,11,0,0,0,0,0,1,1,5,1,1,1,1,1,1,1,1,5,1,1,1,1],\n\t\"isSolid\": null,\n\t\"mass\": null,\n\t\"opacity\": 0.52734375\n}\n",
			"urn:sha1:BOP3JKXLW3ADDCZ6OPXALZ4VVYJMC473": "[\n\tnull,\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f77\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:de6fbe4f-a475-46fe-8613-1900d6a5d36c\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:159aa4e5-016a-473d-9be7-5ba492fa899b\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:fde59aa4-d580-456b-b173-2b65f837fcb0\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:80cad088-4875-4fc4-892e-34c3035035cc\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:sha1:F2OWVUYLPVKZMGHOD3TJVTCR7KNK4KYS#\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:sha1:DNWKUFQUXPF3CGXJV74LYJPAKDVCKBA3#\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:4ee24c8f-7309-462e-b219-ed60505bdb52\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:sha1:VMV7AZMSGZ7Y473ZGI63SQZB4PRN6CSG#\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:02056297-7242-4ff2-af15-69055671e5c5\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:9bee7432-5ad0-4f9d-9759-9d1a6fa02a85\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:c447986a-19d2-447a-ab39-afe9df781dbe\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:c145afdd-bc60-4c97-bad8-b6fcb3e1846f\"\n\t\t}\n\t},\n\t{\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:416bfc18-7412-489f-a45e-6ff4c6a4e08b\"\n\t\t},\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0}\n\t}\n]\n",
			"urn:sha1:TBDAUYVF3LFCW42C4Y643MZ2SDHD2VTX": "{\n\t\"debugLabel\": \"bouncy ball\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.25,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.25\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.25,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.25\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.25,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.25\n\t},\n\t\"isSolid\": true,\n\t\"isAffectedByGravity\": true,\n\t\"mass\": 10,\n\t\"bounciness\": 1,\n\t\"opacity\": 0.25,\n\t\"visualRef\": \"bitimg:color0=0;color1=-2144325377,3c7efffdfdf9623c\"\n}\n",
			"urn:sha1:6LRUFWPH4U4HHF6KF3ONEMPU6BQG5CQW": "{\n\t\"debugLabel\": \"1.5m-wide platform\",\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -1.5,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 1.5,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -1.5,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 1.5,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -1.5,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 1.5,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 6,\n\t\"yDivisions\": 1,\n\t\"zDivisions\": 1,\n\t\"opacity\": 0.5,\n\t\"childEntityPaletteRef\": \"urn:sha1:S3N6FDLABMCNSYUSGDZX3MARG6ATIKF6#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1],\n\t\"mass\": 120,\n\t\"isAffectedByGravity\": true,\n\t\"normalClimbingSpeed\": 4,\n\t\"climbingSkill\": 0.9375,\n\t\"maxClimbForce\": 5000\n}\n",
			"urn:sha1:F2OWVUYLPVKZMGHOD3TJVTCR7KNK4KYS": "{\n\t\"debugLabel\": \"ladder (+X)\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": 0.25,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": 0.25,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"opacity\": 0.125,\n\t\"climbability\": 0.75,\n\t\"isSolid\": true,\n\t\"visualRef\": \"bitimg:width=4;height=16;color1=-2141167361,66f666f666f666f6\"\n}\n",
			"urn:sha1:DNWKUFQUXPF3CGXJV74LYJPAKDVCKBA3": "{\n\t\"debugLabel\": \"ladder (-X)\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": -0.25,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": -0.25,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"opacity\": 0.125,\n\t\"climbability\": 0.75,\n\t\"isSolid\": true,\n\t\"visualRef\": \"bitimg:width=4;height=16;color1=-2141167361,66f666f666f666f6\"\n}\n",
			"urn:sha1:VMV7AZMSGZ7Y473ZGI63SQZB4PRN6CSG": "{\n\t\"debugLabel\": \"ladder (-Y)\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": -0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": -0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"opacity\": 0.125,\n\t\"climbability\": 0.75,\n\t\"isSolid\": true,\n\t\"visualRef\": \"bitimg:width=16;height=4;color1=-2141167361,2222ffffffff2222\"\n}\n",
			"urn:sha1:S3N6FDLABMCNSYUSGDZX3MARG6ATIKF6": "[\n\tnull,\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:819f8257-bcad-4d2f-a64e-0a855ad9dd6e\"\n\t\t}\n\t}\n]\n",
			"urn:sha1:2VDARGVUTOGU4RJ74WTUTT3X7GVKRAMK": "{\n\t\"debugLabel\": \"bricks\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": true,\n\t\"opacity\": 1,\n\t\"visualRef\": \"bitimg:color0=0;color1=-926370561,0000e7e7e7e7000000007e7e7e7e00000000e7e7e7e7000000007e7e7e7e0000\"\n}\n",
			"urn:sha1:LYYME4OFV2PBBOJAXZRFCUE2SLZHOQDJ": "{\n\t\"debugLabel\": \"big bricks\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": true,\n\t\"opacity\": 1,\n\t\"visualRef\": \"bitimg:color0=0;color1=-589510401,00007ffe7ffe7ffe7ffe7ffe7ffe00000000fe7ffe7ffe7ffe7ffe7ffe7f0000\"\n}\n",
			"urn:sha1:KUMPEBLX7TVYY7KAGCJ3MLL6SFVRRZVX": "{\n\t\"debugLabel\": \"plant\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": false,\n\t\"opacity\": 0.25,\n\t\"visualRef\": \"bitimg:color0=0;color1=1086341375,00000000000000c0092c04120f2834e4086007c00af400cc3d8243f001880180\"\n}\n",
			"urn:sha1:BTPAHAF6SQHQBMEUQ6PZTJ4U5LVBESHF": "{\n\t\"debugLabel\": \"door frame\",\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 4,\n\t\"yDivisions\": 4,\n\t\"zDivisions\": 4,\n\t\"opacity\": 0,\n\t\"childEntityPaletteRef\": \"urn:sha1:BWNDEGQQVP6OH2FK3WMK6H2ZONNI7VUK#\",\n\t\"childEntityIndexes\": [1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1]\n}\n",
			"urn:sha1:ANGIERNX22553GTA66GHF6LG2G4JNZ3R": "{\n\t\"debugLabel\": \"ladder (+Z)\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": -0.25\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"opacity\": 0.125,\n\t\"climbability\": 0.75,\n\t\"isSolid\": true,\n\t\"visualRef\": \"bitimg:color1=-2141167361,300c300c3ffc300c300c300c3ffc300c300c300c3ffc300c300c300c3ffc300c\"\n}\n",
			"urn:sha1:LPK5G4TEWN3WYAKPQUG66EBQWLVJJCQL": "{\n\t\"debugLabel\": \"vines\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": false,\n\t\"opacity\": 0.75,\n\t\"visualRef\": \"bitimg:color0=0;color1=1086341375,12262251244e28442a4e172633124a144988094811282224272457444a882110\"\n}\n",
			"urn:sha1:4ILEXQUSIL2FK4ZXEULMOD3LMCVLYSBL": "{\n\t\"debugLabel\": \"small lattice column block (+x)\",\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 2,\n\t\"yDivisions\": 2,\n\t\"zDivisions\": 2,\n\t\"childEntityPaletteRef\": \"urn:sha1:EIIES2DCC4AHIT5GBQ4BSC7LC2D7A5WN#\",\n\t\"childEntityIndexes\": [0,1,0,1,0,1,0,1]\n}\n",
			"urn:sha1:MEJSVKEPQXJ37DPLD2EWPEO6YJP7DRD4": "{\n\t\"debugLabel\": \"small lattice column block (-x)\",\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 2,\n\t\"yDivisions\": 2,\n\t\"zDivisions\": 2,\n\t\"childEntityPaletteRef\": \"urn:sha1:EIIES2DCC4AHIT5GBQ4BSC7LC2D7A5WN#\",\n\t\"childEntityIndexes\": [1,0,1,0,1,0,1,0]\n}\n",
			"urn:sha1:PRESXPBHFTFENY4GBOUJXS2ELODUV26O": "{\n\t\"debugLabel\": \"small lattice column block (+x)\",\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 2,\n\t\"yDivisions\": 2,\n\t\"zDivisions\": 4,\n\t\"childEntityPaletteRef\": \"urn:sha1:GLQR25XUQVFFIZMWTVHEULRFVEGEB375#\",\n\t\"childEntityIndexes\": [0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1]\n}\n",
			"urn:sha1:OE6MZDMTTQZZJ3ACJZAJGWFWWOLWJC7H": "{\n\t\"debugLabel\": \"small lattice column block (-x)\",\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 2,\n\t\"yDivisions\": 2,\n\t\"zDivisions\": 4,\n\t\"childEntityPaletteRef\": \"urn:sha1:GLQR25XUQVFFIZMWTVHEULRFVEGEB375#\",\n\t\"childEntityIndexes\": [1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0]\n}\n",
			"urn:sha1:4CVALUALUAWW47I2HRCPQHKU6ZMQAHGX": "{\n\t\"debugLabel\": \"player\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.25,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.25\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": true,\n\t\"isAffectedByGravity\": true,\n\t\"mass\": 45,\n\t\"bounciness\": 0.015625,\n\t\"visualRef\": \"bitimg:color0=0;color1=-522166017,000001e001e001e001e0008007f00a280aa80aa80a280be806300c180c183c1e\",\n\t\"maxFlyingForce\": 100,\n\t\"maxClimbForce\": 1000,\n\t\"normalWalkingSpeed\": 4,\n\t\"normalClimbingSpeed\": 2,\n\t\"climbingSkill\": 0.5,\n\t\"maxJumpImpulse\": 300\n}\n",
			"urn:sha1:BWNDEGQQVP6OH2FK3WMK6H2ZONNI7VUK": "[\n\tnull,\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:3709e285-3444-420d-9753-ef101fd7924b\"\n\t\t}\n\t}\n]\n",
			"urn:sha1:EIIES2DCC4AHIT5GBQ4BSC7LC2D7A5WN": "[\n\tnull,\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:601fb61a-df00-49bf-8189-877497cf492f\"\n\t\t}\n\t}\n]\n",
			"urn:sha1:GLQR25XUQVFFIZMWTVHEULRFVEGEB375": "[\n\tnull,\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:b64789e4-023c-49ea-98b5-a9d892688bbb\"\n\t\t}\n\t}\n]\n",
			"urn:sha1:3PQTAKG3X5CW222ETB7BNOB2ZQLEHF5J": "{\n\t\"debugLabel\": \"platform segment\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": true,\n\t\"mass\": 20,\n\t\"opacity\": 0.5,\n\t\"visualRef\": \"bitimg:color1=-252665601,ffff81ff814224ff\"\n}\n",
			"urn:sha1:CASLCYPGJDP3NEZCYLSE6XTAGKUICVWQ": "{\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.125,\n\t\t\"minY\": -0.125,\n\t\t\"minZ\": -0.125,\n\t\t\"maxX\": 0.125,\n\t\t\"maxY\": 0.125,\n\t\t\"maxZ\": 0.125\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.125,\n\t\t\"minY\": -0.125,\n\t\t\"minZ\": -0.125,\n\t\t\"maxX\": 0.125,\n\t\t\"maxY\": 0.125,\n\t\t\"maxZ\": 0.125\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.125,\n\t\t\"minY\": -0.125,\n\t\t\"minZ\": -0.125,\n\t\t\"maxX\": 0.125,\n\t\t\"maxY\": 0.125,\n\t\t\"maxZ\": 0.125\n\t},\n\t\"isSolid\": true,\n\t\"mass\": 10,\n\t\"opacity\": 1,\n\t\"climbability\": 0.0625,\n\t\"visualRef\": \"bitimg:color1=1077952767,dbd9\"\n}\n",
			"urn:sha1:DIKGTQTWHLZ5NTPBWZKPPZKGGABW6TXL": "{\n\t\"debugLabel\": \"small lattice column\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.25,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.25\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.25,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.25\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.25,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.25\n\t},\n\t\"isSolid\": true,\n\t\"opacity\": 0.25,\n\t\"climbability\": 0.0625,\n\t\"visualRef\": \"bitimg:color1=-1061109505,ffc3e7dbdbe7c3ff\"\n}\n",
			"urn:sha1:UHLPT7XSX4TDR4I4LRUWDI4HSKDPD6SR": "{\n\t\"debugLabel\": \"small lattice column (background)\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.125,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.125\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.125,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.125\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.25,\n\t\t\"minZ\": -0.125,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.25,\n\t\t\"maxZ\": 0.125\n\t},\n\t\"isSolid\": true,\n\t\"opacity\": 0.25,\n\t\"climbability\": 0.0625,\n\t\"visualRef\": \"bitimg:color1=1077952767,ffc3e7dbdbe7c3ff\"\n}\n",
			"urn:sha1:SQJPFMV2GMNGADFUPABQ34WL3EQCCX33": "{\n\t\"bounds\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:67228411-243c-414c-99d7-960f1151b970\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:D7MRG3QFUOJID547RUJEET57K753PZ7S#\"\n\t\t\t}\n\t\t},\n\t\t\"urn:uuid:1a8455be-8cce-4721-8ccb-7f5644e30081\": {\n\t\t\t\"position\": {\"x\":-1.5,\"y\":1.5,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:uuid:13a4aa97-7b26-49ee-b282-fc53eccdf9cb\",\n\t\t\t\t\"desiredMovementDirection\": {\"x\":0,\"y\":1,\"z\":0}\n\t\t\t},\n\t\t\t\"velocity\": {\"x\":0,\"y\":-0.21875,\"z\":0},\n\t\t\t\"velocityPosition\": {\"x\":-1.5,\"y\":1.5574951171875,\"z\":0}\n\t\t}\n\t},\n\t\"neighbors\": {\n\t\t\"w\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"bounds\": {\n\t\t\t\t\"minX\": -8,\n\t\t\t\t\"minY\": -8,\n\t\t\t\t\"minZ\": -0.5,\n\t\t\t\t\"maxX\": 8,\n\t\t\t\t\"maxY\": 8,\n\t\t\t\t\"maxZ\": 0.5\n\t\t\t},\n\t\t\t\"roomRef\": \"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5941\"\n\t\t},\n\t\t\"e\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"bounds\": {\n\t\t\t\t\"minX\": -8,\n\t\t\t\t\"minY\": -8,\n\t\t\t\t\"minZ\": -0.5,\n\t\t\t\t\"maxX\": 8,\n\t\t\t\t\"maxY\": 8,\n\t\t\t\t\"maxZ\": 0.5\n\t\t\t},\n\t\t\t\"roomRef\": \"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5941\"\n\t\t}\n\t}\n}\n",
			"urn:sha1:RNRVGTH56URDA7SMYQC4QHCGGBQDA4KD": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"n7T4B65O7637RZKQ5IBWJS2ZCIGZEFHPH\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:9d424151-1abf-45c1-b581-170c6eec5941\",\n\t\t\t\"bounds\": {\n\t\t\t\t\"minX\": -8,\n\t\t\t\t\"minY\": -8,\n\t\t\t\t\"minZ\": -0.5,\n\t\t\t\t\"maxX\": 8,\n\t\t\t\t\"maxY\": 8,\n\t\t\t\t\"maxZ\": 0.5\n\t\t\t}\n\t\t},\n\t\t\"nK24ITKY3H5OQ7XW32HXPFN7PEGUJXVMT\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:489195b2-59e8-402e-9216-de71b68ef674\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"n2DYUBMMGVEIJ7O6PKVCWE4V7KUUMYL76\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:df224f24-a83a-4e21-9456-cae51680aa80\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:55ccf886-bc4c-4676-a4b7-e704fee039c8\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:RYYCSWXL64XWGLEG32VXZLLXUGWTIHM7#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:D7MRG3QFUOJID547RUJEET57K753PZ7S": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,5,0,0,0,0,0,9,9,0,9,1,0,1,0,1,0,5,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,1,0,1,1,1,2,7,0,0,0,1,0,0,1,1,1,1,0,1,1,1,2,7,0,0,0,0,0,1,1,1,1,1,0,8,8,4,8,7,0,0,2,2,2,1,1,1,0,0,0,8,8,4,8,7,0,0,0,0,0,0,0,1,0,2,2,2,1,4,2,7,0,0,6,1,3,3,7,1,0,0,0,0,1,4,2,7,0,0,6,1,1,1,7,1,0,0,0,0,0,4,0,0,0,0,6,1,1,1,1,0,0,5,0,0,0,4,0,0,0,0,6,1,0,0,0,1,0,5,1,1,1,1,1,1,3,3,6,1,0,0,5,0,0,5,2,2,2,2,2,2,2,2,2,2,2,0,5,0,2,5,0,0,0,0,0,0,0,0,0,0,0,0,5,1,2,5,0,0,0,0,0,0,0,0,0,0,0,0,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": null,\n\t\"mass\": null,\n\t\"opacity\": 0.49365234375\n}\n",
			"urn:sha1:RYYCSWXL64XWGLEG32VXZLLXUGWTIHM7": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,5,1,1,1,1,1,1,1,1,5,1,1,1,1,1,0,5,0,0,0,0,0,9,9,0,5,1,0,1,1,1,0,5,0,0,1,0,0,0,0,0,5,1,0,0,1,1,1,1,0,1,1,1,2,7,0,0,5,1,0,0,1,1,1,1,0,1,1,1,2,7,0,0,5,0,0,1,1,1,1,1,0,8,8,4,8,7,0,0,2,2,2,1,1,1,0,0,0,8,8,4,8,7,0,0,0,0,0,0,0,1,0,2,2,2,1,4,2,7,0,0,6,1,3,3,0,1,0,0,0,0,1,4,2,7,0,0,6,1,1,1,1,0,0,0,0,0,0,4,0,0,0,0,6,1,1,1,1,0,0,5,0,0,0,4,0,0,0,0,6,1,0,0,1,1,2,5,1,1,1,1,1,1,3,3,6,1,0,1,1,1,2,5,1,1,0,0,2,2,2,2,1,1,0,0,1,1,2,5,0,0,0,0,0,0,1,0,0,0,0,0,1,1,2,5,0,2,1,3,2,2,2,0,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": null,\n\t\"mass\": null,\n\t\"opacity\": 0.49365234375\n}\n",
			"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q": "[\n\tnull,\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:7164c409-9d00-4d75-8fc6-4f30a5755f77\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:de6fbe4f-a475-46fe-8613-1900d6a5d36c\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:159aa4e5-016a-473d-9be7-5ba492fa899b\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:fde59aa4-d580-456b-b173-2b65f837fcb0\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:80cad088-4875-4fc4-892e-34c3035035cc\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:sha1:F2OWVUYLPVKZMGHOD3TJVTCR7KNK4KYS#\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:sha1:DNWKUFQUXPF3CGXJV74LYJPAKDVCKBA3#\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:4ee24c8f-7309-462e-b219-ed60505bdb52\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:sha1:VMV7AZMSGZ7Y473ZGI63SQZB4PRN6CSG#\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:02056297-7242-4ff2-af15-69055671e5c5\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:9bee7432-5ad0-4f9d-9759-9d1a6fa02a85\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:c447986a-19d2-447a-ab39-afe9df781dbe\"\n\t\t}\n\t},\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:c145afdd-bc60-4c97-bad8-b6fcb3e1846f\"\n\t\t}\n\t}\n]\n",
			"urn:sha1:ECLZ2YCU5GLZ24BWCLLJVOWHUWRL3UV6": "{\n\t\"debugLabel\": \"3-segment vertical door\",\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -1.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 1.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -1.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 1.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.3125,\n\t\t\"minY\": -1.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.3125,\n\t\t\"maxY\": 1.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 1,\n\t\"yDivisions\": 3,\n\t\"zDivisions\": 1,\n\t\"opacity\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:6ZQALONLF4NSXDHS6EKR6MEGFEDDZPD7#\",\n\t\"childEntityIndexes\": [1,1,1],\n\t\"mass\": 120,\n\t\"isAffectedByGravity\": true,\n\t\"normalClimbingSpeed\": 4,\n\t\"maxClimbForce\": 3000,\n\t\"climbingSkill\": 0.9375\n}\n",
			"urn:sha1:6ZQALONLF4NSXDHS6EKR6MEGFEDDZPD7": "[\n\tnull,\n\t{\n\t\t\"orientation\": {\"a\":1,\"b\":0,\"c\":0,\"d\":0},\n\t\t\"entity\": {\n\t\t\t\"classRef\": \"urn:uuid:5da4e293-031f-4062-b83f-83241d6768e9\"\n\t\t}\n\t}\n]\n",
			"urn:sha1:RBTSSKSLWCKJ4WXWPE23UYMINF5X2DT4": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nDCSJVNW2OMV7J7AVCISHBYYLDR3F4QNE\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:15b955ce-fc1a-487c-aa55-4b1ea0863464\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nUIGTMMOYNVQAJYFGLUVH7QB2J7UAEJZ3\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:4f9cfdbc-1a4c-4016-8b77-25969d425a57\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"n2OXM5B7NHLHNLJ5ZP6674SMMWHKU5MUA\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:9500a034-65b4-439f-9721-9313aec9c190\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:f608f0ac-ffba-4216-8b52-281343e2c792\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:IUTNJPYVWOKISXXRRHUN5JO5L5XVB42F#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:OCYNZH4V2JNRAKKU4MK4S22ESIXJAY6Q": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"n44DV45ZFUE2DXJOIIRKFANHHGN64MONN\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:15b955ce-fc1a-487c-aa55-4b1ea0863464\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nVZXGP5O5OHWUGQ7LU5OB6UGJ77J2EG6J\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:f98c3b9f-86d2-4dd6-ba65-b818dacc25e1\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:364c9850-cde8-4aa7-aa52-c0d9084dd594\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:7MLBFI3GAP72ZYYSPGVGS4RDP3K7I422#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:IUTNJPYVWOKISXXRRHUN5JO5L5XVB42F": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,5,0,0,0,0,0,0,0,0,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,0,0,0,0,12,0,12,0,0,0,0,0,0,0,5,0,0,0,0,0,12,0,12,0,0,0,0,0,0,0,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:7MLBFI3GAP72ZYYSPGVGS4RDP3K7I422": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,0,0,0,0,0,2,2,1,1,1,1,1,1,1,0,0,0,0,0,2,2,2,1,1,1,1,1,1,0,0,0,0,0,0,2,2,2,2,1,1,1,1,1,0,0,0,0,0,1,2,2,2,2,1,1,1,1,1,1,5,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,5,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,5,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,5,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,5,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:IX62MRBWLKE5ZTS3NSGFMNSL3OD7F4MD": "{\n\t\"debugLabel\": \"door segment\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.25,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.25,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.3125,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.3125,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": true,\n\t\"mass\": 40,\n\t\"opacity\": 1,\n\t\"visualRef\": \"bitimg:width=10;height=16;color1=-252647681,3f1864cb4bd2d4a5294a5294a52b4bd2d32618fc\"\n}\n",
			"urn:sha1:4DHAFMJTSCPXSZX2BG6XKTU3LWQL5XNZ": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nLCYJAT2EXWW5RT6OTTA4D5HUWU4PDF5J\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:489195b2-59e8-402e-9216-de71b68ef674\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"n4ODSGFPHRWEFQ7ZL7PJ2L63TPZS4XKAP\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:b529295e-a143-4646-8c6e-773bead08873\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:ae730363-f2b8-4768-90ab-e07041bde82f\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:5L2RZBBACOEDUEBSAHFXHS2G7OA4PMSS#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:WV4XL2DISYMDKJSJUP6IBJMZA7CTTNUJ": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nQORZOOMF4ATC6QTFO3OZKBVEUMAMJL4R\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:489195b2-59e8-402e-9216-de71b68ef674\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nAROQS7DJIYKC5KHVL55LMQ6NKCY37QPQ\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:8ab3a6fc-f4e5-405b-8a20-7fc7eb9107c7\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nVNYNGQGMBNMQEHRIYMTJAOWZ2QK6RW5M\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:8d1cf0d5-8458-4455-ac1e-27fa0b1a752e\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:dbb6d2ec-184a-4eb9-bbd7-485f9cffa36b\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:XCJ7V5SY37NJIDVUYGN6JW3R6IX7IB6C#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:UCS273BS76IQSNCVUA6RDD42VUIGK7ZH": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nJUVOVAAJBRHGQSJV2C4XKHUA6YQZKLJR\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:df224f24-a83a-4e21-9456-cae51680aa80\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nQDC3FL3UEMRLBSPAXYGFM3E3KGG22R3P\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:762472d7-b519-4850-9ee8-55a42f683014\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:0101e8b4-f544-467e-a572-97d80372c9ee\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:TN2Y5VY7TPMW3G252M7QO5F5NU3LLFL4#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:5L2RZBBACOEDUEBSAHFXHS2G7OA4PMSS": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,2,0,2,0,0,0,0,0,0,0,0,0,0,1,0,2,1,0,1,2,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,0,0,1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,2,5,2,2,2,2,2,3,3,2,2,2,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:XCJ7V5SY37NJIDVUYGN6JW3R6IX7IB6C": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,8,8,8,1,1,1,1,1,1,1,1,1,1,1,1,2,8,8,8,8,2,1,1,1,1,1,1,1,1,1,1,2,8,8,8,8,2,1,1,1,1,1,1,1,1,1,1,0,0,8,8,8,2,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,2,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,2,1,1,0,0,0,12,0,0,0,0,0,0,0,0,0,2,1,1,0,0,0,12,0,0,0,0,0,0,0,0,0,2,1,1,1,1,1,2,0,0,0,0,0,0,0,0,0,2,1,1,1,1,1,2,2,0,0,2,2,2,0,0,2,2,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:TN2Y5VY7TPMW3G252M7QO5F5NU3LLFL4": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,2,2,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,2,2,2,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:VGLOGHUGTSXI46TLL5EKVTR2C4FQZ5LD": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nSEIYDDY56MWHJYIY77ELCFCJ4GBKUDSQ\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:4f9cfdbc-1a4c-4016-8b77-25969d425a57\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nRN4HJSCAPOEUE666GFIM2D4C7YBKV4VI\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:496c20d9-93b3-4f06-b0d5-37a6a4991627\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:325be6b5-180e-4110-a503-b89f7bd7fa67\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:6IJK76CJDK6GIXJ6OMCHRQDJCSOLYE5M#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:YDYP72ATEWQNX36SMZLZ36CIUNLUB73Y": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nM5VO7OOBM2VJKVB7BGYD3P2AF6KLAL7Z\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:496c20d9-93b3-4f06-b0d5-37a6a4991627\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nS24SPGO3WHO6SLD2SWMV5SL3CTTKH7WQ\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:9500a034-65b4-439f-9721-9313aec9c190\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:ca77f5f8-f730-4575-9894-cf4630feb73b\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:PE4WG56R5NHPOEH4FONZP4JMN5UIGB64#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:Y3YOT2JUJJTZIOHOHS7OTPECC7EDX2XI": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"n6FVTUFBNCBHCXHKVMYHUIXKDJS2GA6S3\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:d0e528af-fdf8-47e4-9b75-68ca581bff3b\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"n7IJLKE32PCHEUKGAD52MKUCYSBONSCKZ\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:9500a034-65b4-439f-9721-9313aec9c190\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nZ4OTRU4JIZI64TQRY7TCSUATNVOWRCVE\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:0bb511cf-d0e6-464e-8dd5-32b61aa6190c\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:c698ced5-be3e-40d0-9e87-aa4396d0a48f\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:MUH25ACS5CNLNGP3FP73FZ3WEUHDRXEH#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:BJF45ON5GCGIPSXPCFFMTBJUN5XCOD5C": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nPKTE6QA6TDPC7CONPHBRDILMWFU7FUR3\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:f98c3b9f-86d2-4dd6-ba65-b818dacc25e1\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nZKPIMFKQTOAYR5JDUPIBNMYQDQT2ATSY\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:f37b5525-bf0d-4d81-81ad-8cdf4c1dc803\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"n3KSKHOE5KSP2LKD3IJYVRMB2NGVNK2NQ\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:0bb511cf-d0e6-464e-8dd5-32b61aa6190c\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:63aa7568-7a50-46c5-927f-5b16ba56b9c3\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:KIBCQL7GU3E4EN3YYTBI6I4D7OFQ4GF4#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:6IJK76CJDK6GIXJ6OMCHRQDJCSOLYE5M": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,5,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,5,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:PE4WG56R5NHPOEH4FONZP4JMN5UIGB64": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,2,0,0,0,0,0,0,0,0,0,0,0,2,1,1,1,2,0,0,0,0,0,0,0,0,0,0,8,2,1,1,1,2,3,0,0,0,0,0,0,0,2,3,8,2,1,1,1,2,1,3,1,2,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,0,8,8,1,1,1,1,1,1,1,1,1,1,1,1,2,8,8,8,1,1,1,1,1,1,1,1,1,1,1,1,2,8,8,1,1,1,1,1,1,1,1,1,1,1,1,1,2,8,8,1,1,1,1,1,1,1,1,1,1,1,1,1,2,8,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:MUH25ACS5CNLNGP3FP73FZ3WEUHDRXEH": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,5,0,1,1,1,1,1,1,1,2,0,0,2,2,2,0,5,2,1,1,1,1,1,1,1,1,0,0,1,1,1,0,5,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,5,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,5,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,5,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,5,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,5,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,5,1,1,1,1,1,1,1,1,1,1,0,0,2,2,3,5,1,1,1,1,1,1,1,1,1,8,0,0,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:KIBCQL7GU3E4EN3YYTBI6I4D7OFQ4GF4": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,8,1,1,1,1,5,1,1,1,1,1,1,0,0,0,0,8,1,1,1,1,5,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,5,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,2,1,1,1,0,0,0,0,0,0,0,0,0,2,1,1,2,1,1,1,2,2,0,0,0,0,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:57XOHTZIZYPZIU3VOG4LKGMTHVQR37ZY": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"n7TDAMDURSTRR7UJTJFC5UKB4WFQ6OTCR\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:b529295e-a143-4646-8c6e-773bead08873\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nFSCVPU3Z6DPPDIUNXTQE2UHZGAAJYMOQ\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:8ab3a6fc-f4e5-405b-8a20-7fc7eb9107c7\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:683f5ca5-a4d6-4b0c-b320-0aee6f52c7a5\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:V354M5ZJEVR3Z2EFJKLPANG6USFID2QE#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:AWV6YZTDEG4SEK4IHMLYMEFNXIMKKAPC": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"n7IMBSYZNIRINNSFLVHUIO7CNW75L46VT\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:1aa9cc62-3904-42ee-a5a3-7811c2e8e3da\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nJYUIVCAM4PJIT7BHXDCLFEHFSZ2IRJKZ\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:8d1cf0d5-8458-4455-ac1e-27fa0b1a752e\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:f9fca238-638b-4a1b-9b8a-89617529cdb8\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:G7IXZV5HZZLIJAHFIIGFUEHPA5ZYKBAR#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:CGXNV4GUHKOJM6L3LWLR3XML7RPV2WPM": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nAOS5XSTM7FKQA4YWFLUYWUJHNJHGBB5A\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:762472d7-b519-4850-9ee8-55a42f683014\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nIR547YZA4U2GK56T4VFV56FKELGKJNYF\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:9f2c7823-4c7b-4112-9607-c0201a8ab91c\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nCC4UQLI5UUB64ZAGZ3YEA6WCFV4I5KOD\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:8d1cf0d5-8458-4455-ac1e-27fa0b1a752e\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:2bbf565f-0296-4a84-a358-4d7abdcf3faf\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:6V4HKXCKC65IA55A3RICB7GRYMM6X2GY#\"\n\t\t\t}\n\t\t},\n\t\t\"urn:uuid:d42a8340-ec03-482b-ae4c-a1bfdec4ba32\": {\n\t\t\t\"position\": {\"x\":-7.75,\"y\":2.5,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"id\": \"urn:uuid:d42a8340-ec03-482b-ae4c-a1bfdec4ba32\",\n\t\t\t\t\"classRef\": \"urn:uuid:416bfc18-7412-489f-a45e-6ff4c6a4e08b\",\n\t\t\t\t\"desiredMovementDirection\": {\"x\":0,\"y\":0,\"z\":0}\n\t\t\t},\n\t\t\t\"velocity\": {\"x\":0,\"y\":-0.002422480620155043,\"z\":0},\n\t\t\t\"velocityPosition\": {\"x\":-7.757396764858962,\"y\":2.5601840255193387,\"z\":0}\n\t\t}\n\t}\n}\n",
			"urn:sha1:RIIOIESN7VZH2IFQ3WM3X22PGJ5CMWHV": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"n4NSPRP3AZ4Q6KGX6ELJR3ANR5P5ERCN6\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:762472d7-b519-4850-9ee8-55a42f683014\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nSVLXCWZI4FCSBVXPMWVQKKJKU4VIZJD2\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:1aa9cc62-3904-42ee-a5a3-7811c2e8e3da\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:5d6881ce-9df9-4025-aaaf-dbf0856480dc\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:KPHSWJXS6YBQJUBFD37V76V5TMCDWCEQ#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:V354M5ZJEVR3Z2EFJKLPANG6USFID2QE": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,1,1,1,1,2,0,0,0,0,2,1,1,1,1,1,1,2,0,0,0,0,0,0,0,0,0,0,0,2,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:G7IXZV5HZZLIJAHFIIGFUEHPA5ZYKBAR": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,3,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,2,0,0,0,0,0,0,0,0,1,1,1,1,1,1,3,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,5,0,1,1,1,1,1,2,2,2,2,2,2,2,2,2,5,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,5,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,5,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,5,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,5,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:6V4HKXCKC65IA55A3RICB7GRYMM6X2GY": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,8,8,0,0,1,1,1,1,1,1,1,1,1,1,1,1,8,8,0,0,1,1,1,1,1,1,1,1,1,1,1,8,8,8,0,0,1,1,1,1,1,1,1,1,0,0,0,8,0,8,0,0,0,0,0,1,1,1,1,1,0,5,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,5,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,5,1,1,1,1,1,1,1,0,0,0,0,0,0,1,0,5,1,1,1,1,1,1,1,1,0,0,0,0,0,1,0,5,0,0,0,1,1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:KPHSWJXS6YBQJUBFD37V76V5TMCDWCEQ": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,8,1,1,1,1,1,1,1,1,1,1,1,1,5,0,0,8,1,8,1,1,1,1,1,1,1,1,1,1,5,2,2,8,0,8,0,1,1,1,1,1,1,1,1,1,5,0,1,0,0,0,0,0,0,1,1,1,1,1,1,1,5,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,1,2,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:DNTWUAVDRCOKQJRNPVCCSRBPKVNYTZ23": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nO33GTERMGK7QJMNBHX7TTOAFCZZNCVNW\": {\n\t\t\t\"offset\": {\"x\":-16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:f37b5525-bf0d-4d81-81ad-8cdf4c1dc803\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nLSVQQ7NMKKZ6Q2SU56JPLGFMFAL3QFUK\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:d0e528af-fdf8-47e4-9b75-68ca581bff3b\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:5e593bc1-3bba-4fdc-aa43-9cb5b84d4a8f\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:JAK4TDASZOKCBJ7LLQH67SWZ7IYBRQ4S#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:E7ZB2NUWSQPOZ6GVYJYAODHVZCOTCYK4": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"nEXBOEWX2FRAQBN4Y6VV2PUQ3HEFETVCG\": {\n\t\t\t\"offset\": {\"x\":16,\"y\":0,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:0bb511cf-d0e6-464e-8dd5-32b61aa6190c\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t},\n\t\t\"nPU4ZENX66SU6QQZ6KGXJKBYOMJZXA7OR\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:6c4a07d2-132d-4a1c-bfd9-d471a55991e0\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:bdbb7f99-eeec-48f8-86eb-c842b29f84b9\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:HS2ZXMB5BZED4WUU3IAM5ZJDPUYLSR4O#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:JAK4TDASZOKCBJ7LLQH67SWZ7IYBRQ4S": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,5,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,5,0,0,1,1,1,1,1,1,2,2,0,2,2,2,2,5,0,0,1,1,1,1,1,1,1,0,0,0,11,10,0,5,0,0,1,1,1,1,1,1,1,0,0,0,11,10,0,5,0,0,1,1,1,1,1,1,0,0,0,0,11,10,0,5,0,0,1,1,1,1,1,1,0,0,0,0,13,12,0,5,0,0,1,1,1,1,1,1,0,0,0,0,13,12,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:HS2ZXMB5BZED4WUU3IAM5ZJDPUYLSR4O": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:6JHCA5WBYH4M5OJENQVLOMIYIQKO74NG": "{\n\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8},\n\t\"neighbors\": {\n\t\t\"n6JNGOCXF2RRUQ2AJEB5TMCLTFUPU5SC4\": {\n\t\t\t\"offset\": {\"x\":0,\"y\":-16,\"z\":0},\n\t\t\t\"roomRef\": \"urn:uuid:9f2c7823-4c7b-4112-9607-c0201a8ab91c\",\n\t\t\t\"bounds\": {\"minX\":-8,\"minY\":-8,\"minZ\":-8,\"maxX\":8,\"maxY\":8,\"maxZ\":8}\n\t\t}\n\t},\n\t\"roomEntities\": {\n\t\t\"urn:uuid:d0769fbf-1c23-4802-83a1-4206acd75a3d\": {\n\t\t\t\"position\": {\"x\":0,\"y\":0,\"z\":0},\n\t\t\t\"entity\": {\n\t\t\t\t\"classRef\": \"urn:sha1:75K5QQAVFDDOZQFQEM5KBXG7FZOPV2B4#\"\n\t\t\t}\n\t\t}\n\t}\n}\n",
			"urn:sha1:75K5QQAVFDDOZQFQEM5KBXG7FZOPV2B4": "{\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"structureType\": 2,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -8,\n\t\t\"minY\": -8,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 8,\n\t\t\"maxY\": 8,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"xDivisions\": 16,\n\t\"yDivisions\": 16,\n\t\"zDivisions\": 1,\n\t\"childEntityPaletteRef\": \"urn:sha1:IMPKF5EUH4AW7TCEK4LP66ZTG2DXRH3Q#\",\n\t\"childEntityIndexes\": [1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n\t\"isSolid\": true,\n\t\"mass\": null,\n\t\"opacity\": 1\n}\n",
			"urn:sha1:SQDEY7PXPCOTS37E4J5FIKPFYW2WT2XX": "{\n\t\"debugLabel\": \"big yellow bricks\",\n\t\"structureType\": 1,\n\t\"tilingBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"physicalBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"visualBoundingBox\": {\n\t\t\"minX\": -0.5,\n\t\t\"minY\": -0.5,\n\t\t\"minZ\": -0.5,\n\t\t\"maxX\": 0.5,\n\t\t\"maxY\": 0.5,\n\t\t\"maxZ\": 0.5\n\t},\n\t\"isSolid\": true,\n\t\"opacity\": 1,\n\t\"visualRef\": \"bitimg:color0=0;color1=-589528833,00007ffe7ffe7ffe7ffe7ffe7ffe00000000fe7ffe7ffe7ffe7ffe7ffe7f0000\"\n}\n"
		};
		
		updateLoadingStatus("Starting...");
		
		var demo = _Maze1.startDemo(document.getElementById('maze-canvas'), null, updateLoadingStatus, cacheStrings);
		demo.tabSwitchesMode = false;
		window.maze1Demo = demo;
		
		const fogColor = 'rgba(38,38,44,1)';
		demo.view.occlusionFillStyle = fogColor;
		document.getElementById('maze-area').style.background = fogColor;
	});
//]]></script>