date: 2016-09-23
title: Maze thing
thumbnail-image-url: http://picture-files.nuke24.net/uri-res/raw/urn:bitprint:SJ74CKQY5XNV5ZW5BVC2ZDZXCBRERC26.MVQZP6TU2WGA32FH3RWDLEVWEEBXX6LB4SXXYWI/Maze1-20160923.png

<style scoped>/* <![CDATA[ */
html, body {
	margin: 0;
	padding: 0;
	color: white;
	box-sizing: border-box;
}
.maze-area {
	background: rgba(64,64,64,1);
	width: 100%;
	display: flex;
	align-items: center;
	justify-content: center;
	border-top: 4px solid black;
	border-bottom: 4px solid black;
}
.maze-canvas {
	background: black;
	width: 400px;
	height: 240px;
	box-sizing: content-box;
}
@media (min-width: 800px) and (min-height: 520px) {
	.maze-canvas {
		width: 800px;
		height: 480px;
	}
}
@media (min-width: 1200px) and (min-height: 720px) {
	.maze-canvas {
		width: 1200px;
		height: 720px;
	}
}
/* ]]> */</style>

<p>Thing I've been working on (use WASD or arrow keys to move):</p>

<div class="maze-area">
<canvas class="maze-canvas" id="maze-canvas" width="400" height="240"/>
</div>

<p>Features:</p>

<ul>

<li>Better physics than <a href="entry:9">the bouncy ball thing</a>,
  in which balls would sometimes pass through walls.
  This uses a more predictable algorithm where object positions are all
  quantized to 1/8m (a separate 'for velocity calculations only'
  position is also stored so that slow things still move eventually),
  and solid objects are never moved if that would cause them to overlap another solid object.</li>
<li>Visibility calculator had some
  (probably sleep deprivation-induced; they were kind of dumb) bugs, which I have now fixed.
  As a side-effect, that calculation should be a bit faster,
  even without the straight-line optimizations I had made.</li>
<li>Hard-coded, 1-bit bitmap graphics.</li>
<li>I just figured out how to use media queries to make the canvas bigger on big screens.</li>
</ul>

<p>To-do:</p>

<ul>
<li>Better physics:<ul>
  <li>Proper force &rarr; momentum change calculations that take both objects into account
    (all movements are due to pairs of impulses between objects with velocity and mass).</li>
  <li>Easier character movement, especially during jumps.
    My approach to physics for now is to make it mostly right and generally useful,
    and I'll add exceptions as needed for usability once that's in place.</li>
  <li>Take friction into account.</li>
</ul></li>
<li>Different kinds of objects:<ul>
  <li>Ladders.</li>
  <li>Doors.</li>
  <li>Moving platforms.</li>
</ul></li>
<li>Monsters that chase after and try to eat you.
  I've never written a path-finding algorithm, so that should be interesting.</li>
<li>A more interesting maze.  But maybe I should put that off until I've made an editor.</li>
<li>Maybe the visibility algorithm should only allow for a certain number of 90 degree turns
  so that you can't see around corners as much.</li>
<li>The rendering system was a bit broken because of infrastructure changes I've been making
  (specifically, that things may be loaded asynchronously, now)
  and I didn't want to bother fixing that or coming up with pretty 3D stuff.
  Eventually I should get that figured out again.</li>
<li>Related to that, animations.</li>
</ul>

<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/6cecb9162e92481ff57eb83c298068fbf6353a20 //////

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 (!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("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_7) {
    "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_7.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_8, 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_8.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/Cuboid", "togos-game21/DeepFreezer"], function (require, exports, Cuboid_1, DeepFreezer_9) {
    "use strict";
    exports.EMPTY_STATE = DeepFreezer_9.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";
    })(exports.StructureType || (exports.StructureType = {}));
    var StructureType = exports.StructureType;
    exports.HUNIT_CUBE = DeepFreezer_9.deepFreeze(new Cuboid_1.default(-0.5, -0.5, -0.5, +0.5, +0.5, +0.5));
    var _a;
});
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;
    var _a;
});
define("tshash/uuids", ["require", "exports", "tshash/utils"], function (require, exports, utils_1) {
    "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_1.hexEncode(uuid, 0, 4) + '-' +
            utils_1.hexEncode(uuid, 4, 6) + '-' + utils_1.hexEncode(uuid, 6, 8) + '-' + utils_1.hexEncode(uuid, 8, 10) + '-' +
            utils_1.hexEncode(uuid, 10, 16));
    }
    exports.uuidString = uuidString;
    function uuidUrn(uuid) {
        return "urn:uuid:" + uuidString(uuid);
    }
    exports.uuidUrn = uuidUrn;
    var _a;
});
define("togos-game21/JSONObjectDatastore", ["require", "exports", "togos-game21/DeepFreezer", "tshash/utils"], function (require, exports, DeepFreezer_10, utils_2) {
    "use strict";
    function storeObject(v, datastore) {
        if (v instanceof Uint8Array) {
            return datastore.store(v);
        }
        var json = JSON.stringify(v, null, "\t") + "\n";
        return datastore.store(utils_2.utf8Encode(json)).then(function (dataurn) { return dataurn + "#"; });
    }
    exports.storeObject = storeObject;
    function fastStoreObject(v, datastore) {
        if (v instanceof Uint8Array) {
            return datastore.fastStore(v);
        }
        var json = JSON.stringify(v, null, "\t") + "\n";
        return datastore.fastStore(utils_2.utf8Encode(json)) + '#';
    }
    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_2.utf8Decode(data);
                var obj = JSON.parse(json);
                return freeze ? DeepFreezer_10.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"], function (require, exports, JSONObjectDatastore_1) {
    "use strict";
    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 _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 JSONObjectDatastore_1.fetchObject(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 JSONObjectDatastore_1.fetchObject(nodeUri, datastore).then(function (obj) {
            return _storeValues(updates, obj, nodeUri, datastore, settings);
        });
    }
    exports.storeValues = storeValues;
    function emptyNodeUri(datastore) {
        return JSONObjectDatastore_1.fastStoreObject(leafNode({}), datastore);
    }
    exports.emptyNodeUri = emptyNodeUri;
    var DistributedBucketMapManager = (function () {
        function DistributedBucketMapManager(_datastore, _rootNodeUri) {
            if (_rootNodeUri === void 0) { _rootNodeUri = emptyNodeUri(_datastore); }
            this._datastore = _datastore;
            this._rootNodeUri = _rootNodeUri;
            this.pendingUpdates = {};
            this.currentUpdates = {};
            this.allUpdatesPromise = Promise.resolve(_rootNodeUri);
        }
        DistributedBucketMapManager.prototype.flushUpdates = function () {
            if (this.currentUpdatePromise)
                return this.currentUpdatePromise;
            return Promise.resolve(this._rootNodeUri);
        };
        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.resolve("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/GameDataManager", ["require", "exports", "togos-game21/DeepFreezer", "togos-game21/JSONObjectDatastore", "togos-game21/world"], function (require, exports, DeepFreezer_11, JSONObjectDatastore_2, world_1) {
    "use strict";
    var hashUrnRegex = /^urn:(sha1|bitprint):.*/;
    var GameDataManager = (function () {
        function GameDataManager(ds, omm) {
            this.objectCache = {};
            /**
             * 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.datastore = ds;
            this.objectMapManager = omm;
        }
        GameDataManager.prototype.getObjectIfLoaded = function (ref, initiateFetch) {
            if (initiateFetch === void 0) { initiateFetch = false; }
            var v = this.objectCache[ref];
            if (v == null && initiateFetch && !this.fetching[ref])
                this.fetchObject(ref);
            return v;
        };
        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.getRoom = function (ref) { return this.getObject(ref); };
        GameDataManager.prototype.getEntityClass = function (ref) { return this.getObject(ref); };
        GameDataManager.prototype.cache = function (k, v) {
            this.objectCache[k] = v;
        };
        GameDataManager.prototype.fetchObject = function (ref) {
            var _this = this;
            if (this.objectCache[ref])
                return Promise.resolve(this.objectCache[ref]);
            if (this.fetching[ref])
                return this.fetching[ref];
            if (hashUrnRegex.exec(ref)) {
                return this.fetching[ref] = JSONObjectDatastore_2.fetchObject(ref, this.datastore, true).then(function (v) {
                    _this.cache(ref, v);
                    delete _this.fetching[ref];
                    return v;
                });
            }
            else {
                return this.fetching[ref] = this.objectMapManager.fetchValue(ref).then(function (realRef) {
                    if (realRef == null) {
                        return Promise.reject("No mapping for " + ref);
                    }
                    else {
                        return _this.fetchObject(realRef).then(function (v) {
                            _this.cache(ref, v);
                            delete _this.fetching[ref];
                            return v;
                        });
                    }
                });
            }
        };
        GameDataManager.prototype.clearCache = function () {
            // Well, might not want to clear stuff out that we're in the process of storing.
            // But maybe we do if explicitly asked to clearCache().  *shrug*
            this.objectCache = {};
        };
        GameDataManager.prototype.updateMap = function (updates) {
            return this.objectMapManager.storeValues(updates);
        };
        GameDataManager.prototype.storeObject = function (obj, _name) {
            var _this = this;
            obj = DeepFreezer_11.deepFreeze(obj);
            var urnProm = JSONObjectDatastore_2.storeObject(obj, this.datastore);
            var name = _name; // Make it const so later references check out
            if (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_11.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) {
                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;
        };
        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)
                        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;
                        itemPromises.push(_this.fullyCacheTileEntityPalette(tt.childEntityPaletteRef));
                }
                return Promise.all(itemPromises).then(function () { return ec; });
            });
        };
        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];
                    itemPromises.push(_this.fullyCacheEntityClass(roomEntity.entity.classRef));
                }
                return Promise.all(itemPromises).then(function () { return room; });
            });
        };
        return GameDataManager;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = GameDataManager;
    var _a;
});
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.digest = function () {
            var bi = this.bufLen;
            var buf = this.bufferUint8s;
            buf[bi++] = 0x80; // Our messages are always a multiple of 8 bits long
            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;
    var _a;
});
define("tshash/index", ["require", "exports", "tshash/utils", "tshash/SHA1", "tshash/utils"], function (require, exports, utils_3, SHA1_1, utils_4) {
    "use strict";
    exports.utf8Encode = utils_4.utf8Encode;
    exports.utf8Decode = utils_4.utf8Decode;
    exports.base32Encode = utils_4.base32Encode;
    exports.base32Decode = utils_4.base32Decode;
    exports.hexEncode = utils_4.hexEncode;
    exports.hexDecode = utils_4.hexDecode;
    function hash(data, hashFunc) {
        var u8 = utils_3.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_3.utf8Encode(str), hashFunc);
    }
    exports.hashString = hashString;
    function sha1Urn(thing) {
        return "urn:sha1:" + utils_3.base32Encode(hash(thing, SHA1_1.default));
    }
    exports.sha1Urn = sha1Urn;
    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/Cuboid", "togos-game21/world", "togos-game21/DeepFreezer", "tshash/index", "tshash/SHA1", "togos-game21/util"], function (require, exports, vector3ds_9, vector3dmath_7, Quaternion_2, Cuboid_2, world_2, DeepFreezer_12, index_1, 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 game object"); // Well, really we should be able to for hash URN things eventually
        return gdm.fastStoreObject(op);
    }
    /**
     * Palette can either be an ID of a TileEntityPalette,
     * or a list of tile tree entity class refs.
     */
    function tileEntityPaletteRef(palette, gdm) {
        if (typeof palette == 'string')
            return palette;
        if (gdm == null)
            throw new Error("Can't generate palette ref without game object"); // Well, really we should be able to for hash URN things eventually
        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_12.deepFreeze({
            orientation: Quaternion_2.default.IDENTITY,
            entity: {
                classRef: entityClassRef(obj, gdm)
            },
        }); });
        console.log("saving tile palette", tilePalette);
        return gdm.fastStoreObject(tilePalette);
    }
    exports.tileEntityPaletteRef = tileEntityPaletteRef;
    /**
     * 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 = posBuffer0; }
        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 xd = tt.tilingBoundingBox.width / tt.xDivisions;
            var yd = tt.tilingBoundingBox.height / tt.yDivisions;
            var zd = tt.tilingBoundingBox.depth / tt.zDivisions;
            var x0 = pos.x - tt.tilingBoundingBox.width / 2 + xd / 2;
            var y0 = pos.y - tt.tilingBoundingBox.height / 2 + yd / 2;
            var z0 = pos.z - tt.tilingBoundingBox.depth / 2 + zd / 2;
            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 tileEntity = tilePalette[tilePaletteIndexes[i]];
                        if (tileEntity != null) {
                            var v = callback.call(callbackThis, tileEntity.entity, vector3ds_9.setVector(posBuffer, x0 + x * xd, y0 + y * yd, z0 + z * zd), tileEntity.orientation);
                            if (v != null)
                                return v;
                        }
                    }
        }
        else {
            throw new Error("Unrecognized physical object type: " + proto.structureType);
        }
        return undefined;
    }
    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 = tileEntityPaletteRef(palette, gdm);
        var tilePalette = gdm.getObject(_paletteRef);
        if (tilePalette == null)
            throw new Error("Failed to get tile palette " + _paletteRef);
        console.log("got tile palette", tilePalette);
        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(tileClass.tilingBoundingBox.width, tileW);
            tileH = Math.max(tileClass.tilingBoundingBox.height, tileH);
            tileD = Math.max(tileClass.tilingBoundingBox.depth, tileD);
        }
        var totalOpacity = 0;
        var isInteractive = false;
        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.isInteractive !== false)
                isInteractive = true;
            totalMass += tileClass.mass == null ? Infinity : tileClass.mass;
        }
        var tilingBoundingBox = new Cuboid_2.default(-tileW * w / 2, -tileH * h / 2, -tileD * d / 2, +tileW * w / 2, +tileH * h / 2, +tileD * d / 2);
        return {
            visualBoundingBox: tilingBoundingBox,
            physicalBoundingBox: tilingBoundingBox,
            structureType: world_2.StructureType.TILE_TREE,
            tilingBoundingBox: tilingBoundingBox,
            xDivisions: w,
            yDivisions: h,
            zDivisions: d,
            childEntityPaletteRef: _paletteRef,
            childEntityIndexes: indexes,
            isInteractive: isInteractive,
            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) {
        if (opts === void 0) { opts = {}; }
        var tt = makeTileTreeNode(palette, w, h, d, indexes, gdm, opts);
        return gdm.fastStoreObject(tt);
    }
    exports.makeTileTreeRef = makeTileTreeRef;
    function connectRooms(gdm, room0Ref, room1Ref, offset) {
        offset = DeepFreezer_12.deepFreeze(offset);
        var room0 = gdm.getRoom(room0Ref);
        if (room0 == null)
            throw new Error("Failed to get room " + room0Ref);
        var room1 = gdm.getRoom(room1Ref);
        if (room1 == null)
            throw new Error("Failed to get room " + room1Ref);
        var neighborKey0To1 = "n" + index_1.base32Encode(index_1.hash(room0Ref + ";" + room1Ref + ";" + vector3ds_9.vectorToArray(offset).join(","), SHA1_2.default));
        var neighborKey1To0 = "n" + index_1.base32Encode(index_1.hash(room1Ref + ";" + room0Ref + ";" + vector3ds_9.vectorToArray(vector3dmath_7.scaleVector(offset, -1)).join(","), SHA1_2.default));
        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"], function (require, exports, vector3ds_10, vector3dmath_8, Cuboid_3, worldutil_1) {
    "use strict";
    /*
     * 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_3.default;
    var roomPosBuf = vector3ds_10.makeVector();
    var objPosBuf = vector3ds_10.makeVector();
    var objBB = new Cuboid_3.default;
    var SceneShader = (function () {
        function SceneShader(gameDataManager) {
            this.gameDataManager = gameDataManager;
            this.destBounds = new Cuboid_3.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 != null && proto.opacity == 1) {
                var destMap = this.destShadeMap;
                var tbb = proto.tilingBoundingBox;
                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((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 cy = minCY; cy < maxCY; ++cy) {
                    for (var cx = minCX, ci = cy * destMap.width + cx; cx < maxCX; ++cx, ++ci) {
                        // Slightly more complicated combination arithmetic
                        var currentOpacity = destMap.data[ci] / 255;
                        var combinedOpacity = currentOpacity + (1 - currentOpacity) * proto.opacity;
                        destMap.data[ci] = Math.round(255 * 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] = 0;
                    }
            }
            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(255);
            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;
        };
        // Naive recursion was too slow so optimize by shooting in straight lines
        /*
        TODO: Fix these functions to not be wrong
        public opacityTolVisibilityRasterOptX( opacity:ShadeRaster, x:number, y:number, maxDistance:number, dest:ShadeRaster, dx:number ):void {
            if( x < 0 || y < 0 || x >= opacity.width || y >= opacity.height ) return;
            
            if( maxDistance > 255 ) maxDistance = 255;
            const idx = x+y*opacity.width;
            maxDistance = Math.floor( maxDistance * (255-opacity.data[idx])/255);
            while( x >= 0 && x <= opacity.width && maxDistance > dest.data[idx] ) {
                dest.data[idx] = maxDistance;
                --maxDistance;
                this.opacityTolVisibilityRasterOptY( opacity, x  , y+1, maxDistance, dest, +1 );
                this.opacityTolVisibilityRasterOptY( opacity, x  , y-1, maxDistance, dest, -1 );
                x += dx;
            }
        }
    
        public opacityTolVisibilityRasterOptY( opacity:ShadeRaster, x:number, y:number, maxDistance:number, dest:ShadeRaster, dy:number ):void {
            if( x < 0 || y < 0 || x >= opacity.width || y >= opacity.height ) return;
            
            if( maxDistance > 255 ) maxDistance = 255;
            const idx = x+y*opacity.width;
            maxDistance = Math.floor( maxDistance * (255-opacity.data[idx])/255);
            while( y >= 0 && y <= opacity.height && maxDistance > dest.data[idx] ) {
                dest.data[idx] = maxDistance;
                --maxDistance;
                this.opacityTolVisibilityRasterOptX( opacity, x+1, y  , maxDistance, dest, +1 );
                this.opacityTolVisibilityRasterOptX( opacity, x-1, y  , maxDistance, dest, -1 );
                y += dy;
            }
        }
        */
        /**
         * Fill dest with zeroes and then call this
         * for each cell with eyes.
         */
        SceneShader.prototype.opacityTolVisibilityRaster = function (opacity, x, y, maxDistance, dest) {
            if (x < 0 || y < 0 || x >= opacity.width || y >= opacity.height)
                return;
            x |= 0;
            y |= 0;
            if (maxDistance > 255)
                maxDistance = 255;
            var idx = x + y * opacity.width;
            maxDistance = Math.floor(maxDistance * (255 - opacity.data[idx]) / 255);
            if (maxDistance > dest.data[idx]) {
                dest.data[idx] = maxDistance;
                if (maxDistance > 0) {
                    var maxDistanceMinus1 = maxDistance - 1;
                    this.opacityTolVisibilityRaster(opacity, x + 1, y + 0, maxDistanceMinus1, dest);
                    this.opacityTolVisibilityRaster(opacity, x + 0, y + 1, maxDistanceMinus1, dest);
                    this.opacityTolVisibilityRaster(opacity, x - 1, y + 0, maxDistanceMinus1, dest);
                    this.opacityTolVisibilityRaster(opacity, x + 0, y - 1, maxDistanceMinus1, 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;
            for (var i = 0, y = 0; y < h; ++y)
                for (var x = 0; x < w; ++x, ++i) {
                    if (dat[i] > 0 && dat[i] < 255)
                        ++dat[i];
                }
            for (var i = 0, y = 0; y < h; ++y)
                for (var prevVal = 0, x = 0; x < w; ++x, ++i) {
                    if (dat[i] == 0) {
                        if (prevVal || x < w - 1 && dat[i + 1]) {
                            dat[i] = 1;
                        }
                        prevVal = 0;
                    }
                    else {
                        prevVal = dat[i];
                    }
                }
            for (var x = 0; x < w; ++x)
                for (var prevVal = 0, y = 0; y < h; ++y) {
                    var i = y * w + x;
                    if (dat[i] == 0) {
                        if (prevVal || y < h - 1 && dat[i + w]) {
                            dat[i] = 1;
                        }
                        prevVal = 0;
                    }
                    else {
                        prevVal = dat[i];
                    }
                }
        };
        return SceneShader;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = SceneShader;
    var _a;
});
define("togos-game21/MemoryDatastore", ["require", "exports", "tshash/index"], function (require, exports, index_4) {
    "use strict";
    var MemoryDatastore = (function () {
        function MemoryDatastore(identify, delay) {
            if (delay === void 0) { delay = 0; }
            this.identify = identify;
            this.delay = delay;
            this.values = {};
        }
        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.createSha1Based = function (delay) {
            return new MemoryDatastore(index_4.sha1Urn, delay);
        };
        return MemoryDatastore;
    }());
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = MemoryDatastore;
    var _a;
});
define("togos-game21/Maze1", ["require", "exports", "togos-game21/DeepFreezer", "togos-game21/GameDataManager", "togos-game21/MemoryDatastore", "togos-game21/DistributedBucketMap", "togos-game21/Cuboid", "togos-game21/vector3ds", "togos-game21/vector3dmath", "togos-game21/Quaternion", "togos-game21/TransformationMatrix3D", "togos-game21/SceneShader", "tshash/uuids", "togos-game21/worldutil", "togos-game21/world"], function (require, exports, DeepFreezer_15, GameDataManager_2, MemoryDatastore_3, DistributedBucketMap_3, Cuboid_4, vector3ds_14, vector3dmath_11, Quaternion_4, TransformationMatrix3D_3, SceneShader_2, uuids_1, worldutil_3, world_4) {
    "use strict";
    function newUuidRef() { return uuids_1.uuidUrn(uuids_1.newType4Uuid()); }
    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 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 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 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 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 oneBitImageDataRegex = /^bitimg:([^,]+),([0-9a-f]+)$/;
    function parseBitImg(m) {
        var modStrs = m[1].split(';');
        var modVals = {}; // Actually strings!  But any makes |0 happy.
        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') {
                    throw new Error("Don't handle 0x... colors et");
                }
                modVals[p[0]] = v;
            }
        }
        return {
            bitstr: m[2],
            color0: modVals['color0'] | 0,
            color1: modVals['color1'] | 0,
        };
    }
    // Uhm, hrm, should we use ARGB or RGBA?
    function rgbaToNumber(r, g, b, a) {
        return ((r & 0xFF) << 24) | ((g & 0xFF) << 16) | ((b & 0xFF) << 8) | (a & 0xFF);
    }
    var brikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(255, 255, 128, 255) + "," + hexEncodeBits(brikPix);
    var bigBrikImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(255, 255, 128, 255) + "," + hexEncodeBits(bigBrikPix);
    var playerImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(255, 255, 96, 255) + "," + hexEncodeBits(playerPix);
    var plant1ImgRef = "bitimg:color0=0;color1=" + rgbaToNumber(64, 255, 64, 255) + "," + hexEncodeBits(plant1Pix);
    var mazeData = [
        1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1,
        0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0,
        1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1,
        1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
        1, 1, 1, 0, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 1, 1,
        1, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 0, 2, 2, 2, 1, 1, 2, 0, 1, 1, 1, 1, 3, 1, 0,
        1, 0, 2, 1, 1, 1, 1, 2, 0, 1, 0, 0, 1, 1, 1, 0,
        1, 0, 2, 2, 2, 2, 2, 2, 0, 1, 0, 0, 1, 1, 1, 1,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0,
        1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,
        1, 1, 0, 1, 1, 0, 0, 2, 2, 2, 2, 1, 0, 0, 0, 1,
        1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,
        1, 3, 3, 3, 1, 1, 0, 2, 2, 2, 0, 1, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1,
    ];
    var MazeView = (function () {
        function MazeView(canvas) {
            this.canvas = canvas;
            this.imageCache = {};
            this.viewage = { items: [] };
            this.occlusionFillStyle = 'rgba(64,64,64,1)';
        }
        MazeView.prototype.getImage = function (ref) {
            if (this.imageCache[ref])
                return this.imageCache[ref];
            var bitImgRee = oneBitImageDataRegex.exec(ref);
            var xRef = ref;
            if (bitImgRee) {
                var bitImgInfo = parseBitImg(bitImgRee);
                xRef = parseOneBitImageDataToDataUrl(bitImgInfo.bitstr, 16, 16, bitImgInfo.color0, bitImgInfo.color1);
            }
            else {
                throw new Error(ref + " not parse!");
            }
            var img = document.createElement("img");
            img.src = xRef;
            return this.imageCache[ref] = img;
        };
        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, drawValue, 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 = 16;
            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 = Math.max(0, canvWidth / 2 - (rast.originX * ppm));
                var rastMinPy = Math.max(0, canvHeight / 2 - (rast.originY * ppm));
                var rastMaxPx = Math.min(canvWidth, rastMinPx + (rast.width / rast.resolution) * ppm);
                var rastMaxPy = Math.min(canvHeight, rastMinPy + (rast.height / rast.resolution) * ppm);
                ctx.fillRect(0, 0, canvWidth, rastMinPy);
                ctx.fillRect(0, rastMaxPy, canvWidth, canvHeight - rastMinPy);
                ctx.fillRect(0, rastMinPy, rastMinPx, rastMaxPy - rastMinPy);
                ctx.fillRect(rastMaxPx, rastMinPy, canvWidth - rastMaxPx, rastMaxPy - rastMinPy);
            }
            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);
            };
            for (i = 0, y = 0; y < vrHeight; ++y) {
                var spanStart = null;
                for (var x = 0; x < vrWidth; ++x, ++i) {
                    if (vrData[i] == drawValue) {
                        if (spanStart == null)
                            spanStart = x;
                    }
                    else if (spanStart != null) {
                        fillFog(spanStart, x);
                        spanStart = null;
                    }
                }
                if (spanStart != null) {
                    fillFog(spanStart, vrWidth);
                }
            }
        };
        MazeView.prototype.drawOcclusionFog = function (viz) {
            this.drawRaster(viz, 0, this.occlusionFillStyle, true);
        };
        MazeView.prototype.draw = function () {
            var ctx = this.canvas.getContext('2d');
            if (!ctx)
                return;
            var cx = this.canvas.width / 2;
            var cy = this.canvas.height / 2;
            var ppm = 16;
            for (var i in this.viewage.items) {
                var item = this.viewage.items[i];
                var img = this.getImage(item.visual.imageRef);
                var px = (item.x - item.visual.width / 2) * ppm + cx;
                var py = (item.y - item.visual.height / 2) * ppm + cy;
                ctx.drawImage(img, px, py);
            }
            if (this.viewage.visibility)
                this.drawOcclusionFog(this.viewage.visibility);
        };
        return MazeView;
    }());
    exports.MazeView = MazeView;
    var HUNIT_CUBE = new Cuboid_4.default(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
    function makeTileEntityPalette(gdm) {
        return worldutil_3.tileEntityPaletteRef([
            null,
            gdm.fastStoreObject({
                structureType: world_4.StructureType.INDIVIDUAL,
                tilingBoundingBox: HUNIT_CUBE,
                physicalBoundingBox: HUNIT_CUBE,
                visualBoundingBox: HUNIT_CUBE,
                isInteractive: true,
                isRigid: true,
                mass: Infinity,
                opacity: 1,
                visualRef: brikImgRef
            }),
            gdm.fastStoreObject({
                structureType: world_4.StructureType.INDIVIDUAL,
                tilingBoundingBox: HUNIT_CUBE,
                physicalBoundingBox: HUNIT_CUBE,
                visualBoundingBox: HUNIT_CUBE,
                isInteractive: true,
                isRigid: true,
                mass: Infinity,
                opacity: 1,
                visualRef: bigBrikImgRef
            }),
            gdm.fastStoreObject({
                structureType: world_4.StructureType.INDIVIDUAL,
                tilingBoundingBox: HUNIT_CUBE,
                physicalBoundingBox: HUNIT_CUBE,
                visualBoundingBox: HUNIT_CUBE,
                isInteractive: false,
                isRigid: false,
                mass: Infinity,
                opacity: 0.25,
                visualRef: plant1ImgRef
            }),
        ], gdm);
    }
    function makeRoom(gdm) {
        var tileTreeRef = worldutil_3.makeTileTreeRef(makeTileEntityPalette(gdm), 16, 16, 1, mazeData, gdm, { infiniteMass: true });
        var roomRef = newUuidRef();
        var roomBounds = new Cuboid_4.default(-8, -8, -0.5, 8, 8, 0.5);
        var room = {
            bounds: roomBounds,
            roomEntities: (_a = {},
                _a[newUuidRef()] = {
                    position: vector3ds_14.makeVector(0, 0, 0),
                    entity: {
                        classRef: tileTreeRef
                    }
                },
                _a
            ),
            neighbors: {
                "w": {
                    offset: vector3ds_14.makeVector(-16, 0, 0),
                    bounds: roomBounds,
                    roomRef: roomRef
                },
                "e": {
                    offset: vector3ds_14.makeVector(+16, 0, 0),
                    bounds: roomBounds,
                    roomRef: roomRef
                },
                "n": {
                    offset: vector3ds_14.makeVector(0, -16, 0),
                    bounds: roomBounds,
                    roomRef: roomRef
                },
                "s": {
                    offset: vector3ds_14.makeVector(0, +16, 0),
                    bounds: roomBounds,
                    roomRef: roomRef
                },
            }
        };
        gdm.fastStoreObject(room, roomRef);
        return roomRef;
        var _a;
    }
    function roomToMazeViewage(roomRef, roomX, roomY, gdm, viewage, visibility) {
        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]) {
                            visible = true;
                            break isVisibleLoop;
                        }
                    }
                // TODO: Re-use items, visuals
                if (visible)
                    viewage.items.push({
                        x: position.x,
                        y: position.y,
                        visual: {
                            width: 1,
                            height: 1,
                            imageRef: entityClass.visualRef
                        }
                    });
            }
            worldutil_3.eachSubEntity(entity, position, gdm, _entityToMazeViewage);
        };
        for (var re in room.roomEntities) {
            var roomEntity = room.roomEntities[re];
            var orientation_2 = roomEntity.orientation ? roomEntity.orientation : Quaternion_4.default.IDENTITY;
            _entityToMazeViewage(roomEntity.entity, vector3ds_14.makeVector(roomX + roomEntity.position.x, roomY + roomEntity.position.y, roomEntity.position.z), orientation_2);
        }
    }
    function sceneToMazeViewage(roomRef, roomX, roomY, gdm, viewage, visibility) {
        var room = gdm.getRoom(roomRef);
        if (room == null)
            throw new Error("Failed to load room " + roomRef);
        roomToMazeViewage(roomRef, roomX, roomY, gdm, viewage, visibility);
        for (var n in room.neighbors) {
            var neighb = room.neighbors[n];
            roomToMazeViewage(neighb.roomRef, roomX + neighb.offset.x, roomY + neighb.offset.y, gdm, viewage, visibility);
        }
    }
    var XYZDirection;
    (function (XYZDirection) {
        XYZDirection[XYZDirection["NONE"] = 0] = "NONE";
        XYZDirection[XYZDirection["POSITIVE_X"] = 256] = "POSITIVE_X";
        XYZDirection[XYZDirection["POSITIVE_X_POSITIVE_Y"] = 272] = "POSITIVE_X_POSITIVE_Y";
        XYZDirection[XYZDirection["POSITIVE_Y"] = 16] = "POSITIVE_Y";
        XYZDirection[XYZDirection["NEGATIVE_X_POSITIVE_Y"] = 784] = "NEGATIVE_X_POSITIVE_Y";
        XYZDirection[XYZDirection["NEGATIVE_X"] = 768] = "NEGATIVE_X";
        XYZDirection[XYZDirection["NEGATIVE_X_NEGATIVE_Y"] = 816] = "NEGATIVE_X_NEGATIVE_Y";
        XYZDirection[XYZDirection["NEGATIVE_Y"] = 48] = "NEGATIVE_Y";
        XYZDirection[XYZDirection["POSITIVE_X_NEGATIVE_Y"] = 304] = "POSITIVE_X_NEGATIVE_Y";
        // Fill these in as needed
        XYZDirection[XYZDirection["POSITIVE_Z"] = 1] = "POSITIVE_Z";
        XYZDirection[XYZDirection["NEGATIVE_Z"] = 3] = "NEGATIVE_Z";
    })(XYZDirection || (XYZDirection = {}));
    ;
    var xyzDirectionVectors = {};
    {
        // encode component
        var ec = function (i) {
            return i == 0 ? 0 : i > 0 ? 1 : 3;
        };
        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) << 8) | (ec(y) << 4) | ec(z);
                    xyzDirectionVectors[xyzDirection] = xyzDirection == 0 ? vector3ds_14.ZERO_VECTOR : vector3ds_14.makeVector(x, y, z);
                }
            }
        }
    }
    var entityPositionBuffer = vector3ds_14.makeVector(0, 0, 0);
    var rotate45Clockwise = DeepFreezer_15.deepFreeze(TransformationMatrix3D_3.default.fromXYZAxisAngle(0, 0, 1, +Math.PI / 4));
    var rotate45CounterClockwise = DeepFreezer_15.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_14.ZERO_VECTOR;
    }
    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;
    }
    var MazeGamePhysics = (function () {
        function MazeGamePhysics(game) {
            this.game = game;
            this.impulses = {};
        }
        MazeGamePhysics.prototype.registerImpulse = function (entityRef, impulse) {
            var impulses = this.impulses;
            var current = impulses[entityRef] || vector3ds_14.ZERO_VECTOR;
            impulses[entityRef] = vector3dmath_11.addVector(impulse, current);
        };
        MazeGamePhysics.prototype.registerImpulsePair = function (aRef, bRef, impulse) {
            if (vector3dmath_11.vectorIsZero(impulse))
                return; // Save ourselves a little bit of work
            this.registerImpulse(bRef, impulse);
            this.registerImpulse(aRef, vector3dmath_11.scaleVector(impulse, -1));
        };
        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.x > 0) {
                minZ = maxZ;
                maxZ += gridSize;
            }
            return Cuboid_4.makeCuboid(minX, minY, minZ, maxX, maxY, maxZ);
        };
        MazeGamePhysics.prototype.borderingCollisions = function (roomRef, pos, bb, dir, gridSize, ignoreEntityId) {
            var border = this.borderingCuboid(roomRef, bb, dir, gridSize);
            return this.game.collisionsAt(roomRef, pos, border, ignoreEntityId);
        };
        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);
                if (entityClass.mass != null && entityClass.mass > maxMass) {
                    maxMass = entityClass.mass;
                    massivest = coll;
                }
            }
            return massivest;
        };
        /**
         * Finds the most massive (interactive, rigid) object in the space specified
         */
        MazeGamePhysics.prototype.massivestBorderingCollision = function (roomRef, pos, bb, dir, gridSize, ignoreEntityId) {
            return this.massivestCollision(this.borderingCollisions(roomRef, pos, bb, dir, gridSize, ignoreEntityId));
        };
        /**
         * What's around the entity?
         */
        MazeGamePhysics.prototype.entityBounceBox = function (roomRef, pos, bb, gridSize, ignoreEntityId) {
            var bounceBox = {};
            for (var xyzDir in xyzDirectionVectors) {
                var vec = xyzDirectionVectors[xyzDir];
                bounceBox[xyzDir] = this.massivestBorderingCollision(roomRef, pos, bb, vec, gridSize, ignoreEntityId);
            }
            return bounceBox;
        };
        MazeGamePhysics.prototype.updateEntities = function (interval) {
            var game = this.game;
            /** lesser object ID => greater object ID => force exerted from lesser to greater */
            var gravRef = "gravity";
            var gravVec = vector3ds_14.makeVector(0, 10, 0);
            var rooms = game.activeRooms;
            var maxWalkForce = 450; // ~100 pounds of force?
            var maxJumpImpulse = 300;
            var snapGridSize = 1 / 8;
            // Collect impulses
            // impulses from previous step are also included.
            for (var r in rooms) {
                var room = rooms[r];
                for (var re in room.roomEntities) {
                    var roomEntity = room.roomEntities[re];
                    var entity = roomEntity.entity;
                    var entityClass = game.gameDataManager.getEntityClass(entity.classRef);
                    var entityBb = entityClass.physicalBoundingBox;
                    if (entityClass.isAffectedByGravity && entityClass.mass != null && entityClass.mass != Infinity) {
                        var gravImpulse = vector3dmath_11.scaleVector(gravVec, entityClass.mass * interval);
                        this.registerImpulsePair(gravRef, re, gravImpulse);
                    }
                    var floorCollision = this.massivestBorderingCollision(r, roomEntity.position, entityClass.physicalBoundingBox, xyzDirectionVectors[XYZDirection.POSITIVE_Y], snapGridSize, re);
                    /*
                     * 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
                     */
                    // TODO: Do this in a generic way for any 'walking' entities
                    if (entityVelocity(roomEntity).y >= 0 && floorCollision) {
                        var dmd = entity.desiredMovementDirection || vector3ds_14.ZERO_VECTOR;
                        /** Actual velocity relative to surface */
                        var dvx = entityVelocity(roomEntity).x - entityVelocity(floorCollision.roomEntity).x;
                        var dmx = dmd.x;
                        /** Desired velocity relative to surface */
                        var targetDvx = entityClass.normalWalkingSpeed * oneify(dmx);
                        /** 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.registerImpulsePair(re, floorCollision.roomEntityId, walkImpulse);
                        if (dmd.y < 0) {
                            var jumpImpulse = { x: 0, y: maxJumpImpulse, z: 0 };
                            this.registerImpulsePair(re, floorCollision.roomEntityId, jumpImpulse);
                        }
                    }
                    else {
                    }
                }
            }
            // Apply impulses
            for (var r in rooms) {
                var room = rooms[r];
                for (var re in room.roomEntities) {
                    if (this.impulses[re]) {
                        var roomEntity = room.roomEntities[re];
                        var entity = roomEntity.entity;
                        var entityClass = game.gameDataManager.getEntityClass(entity.classRef);
                        var entityBb = entityClass.physicalBoundingBox;
                        // Δv = impulse / m
                        roomEntity.velocity = vector3dmath_11.addVector(roomEntity.velocity || vector3ds_14.ZERO_VECTOR, vector3dmath_11.scaleVector(this.impulses[re], 1 / entityClass.mass));
                    }
                }
            }
            // They've been applied!
            this.impulses = {};
            // Apply velocity to positions,
            // do collision detection,
            // collect impulses for next frame
            for (var r in rooms) {
                var room = rooms[r];
                for (var re in room.roomEntities) {
                    var roomEntity = room.roomEntities[re];
                    var velocity = roomEntity.velocity;
                    if (velocity == null)
                        continue;
                    var entity = roomEntity.entity;
                    var entityClass = game.gameDataManager.getEntityClass(entity.classRef);
                    var entityBb = entityClass.physicalBoundingBox;
                    var entityRoomRef = r;
                    var displacement = vector3dmath_11.scaleVector(velocity, interval);
                    // 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_11.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_11.scaleVector(displacement, stepDisplacementRatio);
                        var newVelocityLocation = game.fixLocation({
                            roomRef: r,
                            position: vector3dmath_11.addVector(roomEntity.velocityPosition || roomEntity.position, stepDeltaPos)
                        });
                        var newRoomRef = newVelocityLocation.roomRef;
                        var newPosition = vector3dmath_11.roundVectorToGrid(newVelocityLocation.position, snapGridSize);
                        var collisions = game.collisionsAt(newVelocityLocation.roomRef, newPosition, entityBb, re);
                        if (collisions.length == 0) {
                            game.updateRoomEntity(r, re, {
                                roomRef: newRoomRef,
                                position: newPosition,
                                velocityPosition: newVelocityLocation.position
                            });
                            entityRoomRef = newRoomRef;
                            if (stepDisplacementRatio == 1)
                                break displacementStep; // Shortcut; this should happen anyway
                            // Subtract what we did and go again
                            displacement = vector3dmath_11.addVector(displacement, vector3dmath_11.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
                        {
                            var bounceBox = this.entityBounceBox(entityRoomRef, roomEntity.position, entityBb, snapGridSize, re);
                            var maxDvx = 0;
                            var maxDvxColl = void 0;
                            var maxDvy = 0;
                            var maxDvyColl = void 0;
                            // 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])) {
                                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])) {
                                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])) {
                                var collVel = entityVelocity(coll.roomEntity);
                                var dvy = velocity.y - collVel.y;
                                if (dvy > maxDvy) {
                                    maxDvy = dvy;
                                    maxDvyColl = coll;
                                }
                            }
                            if (displacement.y < 0 && (coll = bounceBox[XYZDirection.NEGATIVE_Y])) {
                                var collVel = entityVelocity(coll.roomEntity);
                                var dvy = velocity.y - collVel.y;
                                if (dvy < maxDvy) {
                                    maxDvy = dvy;
                                    maxDvyColl = coll;
                                }
                            }
                            // TODO: check diagonals
                            if (maxDvxColl) {
                                var bounceImpulseX = (1 + bounceFactor(entityClass, maxDvxColl.entityClass)) * maxDvx * entityClass.mass;
                                this.registerImpulsePair(re, maxDvxColl.roomEntityId, vector3ds_14.makeVector(bounceImpulseX, 0, 0));
                            }
                            if (maxDvyColl) {
                                var bounceImpulseY = (1 + bounceFactor(entityClass, maxDvyColl.entityClass)) * maxDvy * entityClass.mass;
                                this.registerImpulsePair(re, maxDvyColl.roomEntityId, vector3ds_14.makeVector(0, bounceImpulseY, 0));
                            }
                            // New displacement = displacement without the components that
                            // would take us into obstacles:
                            var remainingVx = maxDvxColl ? 0 : displacement.x;
                            var remainingVy = maxDvyColl ? 0 : displacement.y;
                            if (remainingVx != 0 && remainingVy != 0) {
                                console.log("Hmm, collision, but no stoppage (maybe a diagonal hit); velocity:", velocity);
                                break displacementStep;
                            }
                            displacement = { x: remainingVx, y: remainingVy, z: 0 };
                        }
                        ++iter;
                        if (iter > 2) {
                            console.log("Too many displacement steps; iter:", iter, "velocity:", velocity);
                            break displacementStep;
                        }
                    }
                }
            }
        };
        return MazeGamePhysics;
    }());
    exports.MazeGamePhysics = MazeGamePhysics;
    var MazeGame = (function () {
        function MazeGame(gameDataManager) {
            this.gameDataManager = gameDataManager;
            this.rooms = {};
            this.phys = new MazeGamePhysics(this);
            this.playerDesiredMovementDirection = vector3ds_14.ZERO_VECTOR;
        }
        Object.defineProperty(MazeGame.prototype, "activeRooms", {
            get: function () { return this.rooms; },
            enumerable: true,
            configurable: true
        });
        MazeGame.prototype.getMutableRoom = function (roomId) {
            if (this.rooms[roomId])
                return this.rooms[roomId];
            var room = this.gameDataManager.getRoom(roomId);
            room = DeepFreezer_15.thaw(room);
            room.roomEntities = DeepFreezer_15.thaw(room.roomEntities);
            for (var re in room.roomEntities) {
                room.roomEntities[re] = DeepFreezer_15.thaw(room.roomEntities[re]);
                room.roomEntities[re].entity = DeepFreezer_15.thaw(room.roomEntities[re].entity);
            }
            // Apparently deepThaw doesn't quite work, yet
            this.rooms[roomId] = room; // deepThaw(room);
            return room;
        };
        MazeGame.prototype.getRoom = function (roomId) {
            if (this.rooms[roomId])
                return this.rooms[roomId];
            return this.gameDataManager.getRoom(roomId);
        };
        MazeGame.prototype.fullyCacheRoom = function (roomId) {
            return this.gameDataManager.fullyCacheRoom(roomId);
        };
        MazeGame.prototype.fullyLoadRoom = function (roomId) {
            var _this = this;
            return this.fullyCacheRoom(roomId).then(function (room) {
                return _this.getMutableRoom(roomId);
            });
        };
        MazeGame.prototype.fixLocation = function (loc) {
            var room = this.getMutableRoom(loc.roomRef);
            if (!Cuboid_4.default.containsVector(room.bounds, loc.position))
                for (var n in room.neighbors) {
                    var neighb = room.neighbors[n];
                    var fixedPos = vector3dmath_11.subtractVector(loc.position, neighb.offset);
                    if (Cuboid_4.default.containsVector(neighb.bounds, fixedPos)) {
                        return {
                            roomRef: neighb.roomRef,
                            position: fixedPos,
                        };
                    }
                }
            return loc;
        };
        MazeGame.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];
            }
        };
        MazeGame.prototype._collisionsAt3 = 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
            into) {
            var _this = this;
            var proto = this.gameDataManager.getEntityClass(entity.classRef);
            if (proto.isInteractive === false)
                return;
            if (!Cuboid_4.default.intersectsWithOffset(entityPos, proto.physicalBoundingBox, checkPos, checkBb))
                return;
            if (proto.structureType == world_4.StructureType.INDIVIDUAL) {
                if (proto.isInteractive && proto.isRigid) {
                    into.push({
                        roomRef: roomRef,
                        roomEntityId: roomEntityId,
                        roomEntity: roomEntity,
                        entityPosition: entityPos,
                        entity: entity,
                        entityClass: proto,
                    });
                }
            }
            else {
                worldutil_3.eachSubEntity(entity, entityPos, this.gameDataManager, function (subEnt, subEntPos, ori) {
                    _this._collisionsAt3(roomRef, roomEntityId, roomEntity, subEntPos, subEnt, checkPos, checkBb, into);
                }, this, entityPos);
            }
            ;
        };
        MazeGame.prototype._collisionsAt2 = function (roomPos, roomRef, checkPos, checkBb, ignoreEntityId, 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) {
                if (re == ignoreEntityId)
                    continue;
                var roomEntity = room.roomEntities[re];
                vector3dmath_11.addVector(roomPos, roomEntity.position, entityPositionBuffer);
                this._collisionsAt3(roomRef, re, roomEntity, entityPositionBuffer, roomEntity.entity, checkPos, checkBb, into);
            }
        };
        /** Overly simplistic 'is there anything at this exact point' check */
        MazeGame.prototype.collisionsAt = function (roomRef, pos, bb, ignoreEntityId) {
            var collisions = [];
            var room = this.getRoom(roomRef);
            if (Cuboid_4.default.intersectsWithOffset(vector3ds_14.ZERO_VECTOR, room.bounds, pos, bb)) {
                this._collisionsAt2(vector3ds_14.ZERO_VECTOR, roomRef, pos, bb, ignoreEntityId, collisions);
            }
            for (var n in room.neighbors) {
                var neighb = room.neighbors[n];
                if (Cuboid_4.default.intersectsWithOffset(neighb.offset, neighb.bounds, pos, bb)) {
                    this._collisionsAt2(neighb.offset, neighb.roomRef, pos, bb, ignoreEntityId, collisions);
                }
            }
            return collisions;
        };
        MazeGame.prototype.update = function (interval) {
            if (interval === void 0) { interval = 1 / 16; }
            for (var r in this.rooms) {
                var room = this.rooms[r];
                for (var re in room.roomEntities) {
                    if (re == this.playerEntityId) {
                        room.roomEntities[re].entity.desiredMovementDirection = this.playerDesiredMovementDirection;
                    }
                }
            }
            this.phys.updateEntities(interval);
            for (var r in this.rooms) {
                var room = this.rooms[r];
                if (!DeepFreezer_15.isDeepFrozen(room)) {
                    // For now we have to do this so that the view will see them,
                    // since gdm doesn't have any way to track objects without saving them.
                    // But it should eventually.
                    var urn = this.gameDataManager.fastStoreObject(room, r);
                }
            }
        };
        MazeGame.prototype.locateRoomEntity = function (id) {
            for (var r in this.rooms) {
                var room = this.rooms[r];
                for (var re in room.roomEntities) {
                    if (re == id) {
                        return {
                            roomRef: r,
                            position: room.roomEntities[re].position
                        };
                    }
                }
            }
            return undefined;
        };
        return MazeGame;
    }());
    exports.MazeGame = MazeGame;
    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 MazeDemo = (function () {
        function MazeDemo() {
            this.keysDown = {};
        }
        MazeDemo.prototype.startSimulation = function () {
            setInterval(this.tick.bind(this), 1000 / 16);
        };
        MazeDemo.prototype.tick = function () {
            this.game.update(1 / 16);
            this.updateView();
        };
        MazeDemo.prototype.updateView = function () {
            this.view.viewage = { items: [] };
            var playerLoc = this.game.locateRoomEntity(this.playerId);
            if (playerLoc) {
                var rasterWidth = 41;
                var rasterHeight = 31;
                var rasterResolution = 2;
                var distance = 20;
                // Line up raster origin so it falls as close as possible to the center of the raster
                // while lining up edges with world coordinates
                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 distanceInPixels = rasterResolution * distance;
                var opacityRaster = new SceneShader_2.ShadeRaster(rasterWidth, rasterHeight, rasterResolution, rasterOriginX, rasterOriginY);
                var visibilityRaster = new SceneShader_2.ShadeRaster(rasterWidth, rasterHeight, rasterResolution, rasterOriginX, rasterOriginY);
                var sceneShader = new SceneShader_2.default(this.game.gameDataManager);
                sceneShader.sceneOpacityRaster(playerLoc.roomRef, vector3dmath_11.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!");
                sceneShader.opacityTolVisibilityRaster(opacityRaster, rasterOriginX * rasterResolution, rasterOriginY * rasterResolution, distanceInPixels, visibilityRaster);
                if (isAllZero(visibilityRaster.data))
                    console.log("Visibility raster is all zero!");
                if (isAllNonZero(visibilityRaster.data))
                    console.log("Visibility raster is all nonzero!");
                sceneShader.growVisibility(visibilityRaster); // Not quite!  Since this expands visibility into non-room space.
                /*
                for( let i=0, y=0; y<visibilityRaster.height; ++y ) {
                    for( let x=0; x<visibilityRaster.width; ++x, ++i ) {
                        if( visibilityRaster.data[i] ) {
                            this.view.viewage.items.push( {
                                x: x / visibilityRaster.resolution - visibilityRaster.originX,
                                y: y / visibilityRaster.resolution - visibilityRaster.originY,
                                visual: {
                                    width: 1 / visibilityRaster.resolution,
                                    height: 1 / visibilityRaster.resolution,
                                    imageRef: [plant1ImgRef,brikImgRef,bigBrikImgRef][visibilityRaster.data[i] % 3]
                                }
                            })
                        }
                    }
                }*/
                sceneToMazeViewage(playerLoc.roomRef, -playerLoc.position.x, -playerLoc.position.y, this.game.gameDataManager, this.view.viewage, visibilityRaster);
                this.view.viewage.visibility = visibilityRaster;
                this.view.viewage.opacity = opacityRaster;
            }
            else {
                console.log("Failed to locate player, " + this.playerId);
            }
            this.view.clear();
            this.view.draw();
        };
        MazeDemo.prototype.keysUpdated = function () {
            var up = false, down = false, left = false, right = false;
            var rightKeys = [33, 34, 39, 68];
            var leftKeys = [35, 36, 37, 65];
            var upKeys = [33, 36, 38, 87];
            var downKeys = [34, 35, 40, 83];
            for (var k in rightKeys)
                if (this.keysDown[rightKeys[k]])
                    right = true;
            for (var k in leftKeys)
                if (this.keysDown[leftKeys[k]])
                    left = true;
            for (var k in upKeys)
                if (this.keysDown[upKeys[k]])
                    up = true;
            for (var k in downKeys)
                if (this.keysDown[downKeys[k]])
                    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;
            this.game.playerDesiredMovementDirection = vector3ds_14.makeVector(moveX, moveY, 0);
        };
        MazeDemo.prototype.keyDown = function (keyEvent) {
            this.keysDown[keyEvent.keyCode] = true;
            this.keysUpdated();
        };
        MazeDemo.prototype.keyUp = function (keyEvent) {
            delete this.keysDown[keyEvent.keyCode];
            this.keysUpdated();
        };
        return MazeDemo;
    }());
    exports.MazeDemo = MazeDemo;
    function startDemo(canv) {
        var ds = MemoryDatastore_3.default.createSha1Based(0); //HTTPHashDatastore();
        var dbmm = new DistributedBucketMap_3.DistributedBucketMapManager(ds);
        var gdm = new GameDataManager_2.default(ds, dbmm);
        var playerId = newUuidRef();
        var playerClass = {
            structureType: world_4.StructureType.INDIVIDUAL,
            tilingBoundingBox: HUNIT_CUBE,
            physicalBoundingBox: new Cuboid_4.default(-0.25, -0.25, 0.25, 0.25, 0.5, 0.25),
            visualBoundingBox: HUNIT_CUBE,
            isInteractive: true,
            isAffectedByGravity: true,
            mass: 45,
            bounciness: 0.5,
            visualRef: playerImgRef,
            normalWalkingSpeed: 4,
            normalClimbingSpeed: 2,
        };
        var playerRoomEntity = {
            position: vector3ds_14.makeVector(-6.5, -1.5, 0),
            entity: {
                id: playerId,
                classRef: gdm.fastStoreObject(playerClass)
            }
        };
        var roomRef = makeRoom(gdm);
        var room = DeepFreezer_15.thaw(gdm.getRoom(roomRef));
        if (room == null)
            throw new Error("Failed to load " + roomRef);
        room.roomEntities = DeepFreezer_15.thaw(room.roomEntities);
        room.roomEntities[playerId] = playerRoomEntity;
        gdm.fastStoreObject(room, roomRef);
        var game = new MazeGame(gdm);
        game.playerEntityId = playerId;
        var v = new MazeView(canv);
        v.gameDataManager = gdm;
        var viewItems = [];
        var demo = new MazeDemo();
        demo.game = game;
        demo.view = v;
        demo.playerId = playerId;
        demo.startSimulation();
        game.fullyLoadRoom(roomRef).then(function (room) {
            demo.updateView();
        });
        return demo;
    }
    exports.startDemo = startDemo;
    var _a;
});
/// <reference path="../Promise.d.ts" />
/* ]]> */</script>
<script type="text/javascript">//<![CDATA[
	require(['togos-game21/Maze1'], function(_Maze1) {
		var demo = _Maze1.startDemo(document.getElementById('maze-canvas'));
		window.addEventListener('keydown', demo.keyDown.bind(demo));
		window.addEventListener('keyup', demo.keyUp.bind(demo));
	});
//]]></script>