// @echo '/// <reference path="GameStartr-0.2.0.ts" />'
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; }
    __.prototype = b.prototype;
    d.prototype = new __();
};
// @ifdef INCLUDE_DEFINITIONS
/// <reference path="References/GameStartr-0.2.0.ts" />
/// <reference path="FullScreenMario.d.ts" />
// @endif
// @include ../Source/FullScreenMario.d.ts
var FullScreenMario;
(function (FullScreenMario_1) {
    "use strict";
    /**
     * A free HTML5 remake of Nintendo's original Super Mario Bros, expanded for the
     * modern web. It includes the original 32 levels, a random map generator, a
     * level editor, and over a dozen custom mods.
     */
    var FullScreenMario = (function (_super) {
        __extends(FullScreenMario, _super);
        /**
         * Constructor for a new FullScreenMario game object.
         * Static game settings are stored in the appropriate settings/*.js object
         * as members of the FullScreenMario.prototype object.
         * Dynamic game settings may be given as members of the "customs" argument.
         * On typical machines, game startup time is approximately 500-700ms.
         */
        function FullScreenMario(settings) {
            this.settings = FullScreenMario.settings;
            this.deviceMotionStatus = {
                "motionDown": false,
                "motionLeft": false,
                "motionRight": false,
                "x": undefined,
                "y": undefined,
                "dy": undefined
            };
            _super.call(this, this.proliferate({
                "constantsSource": FullScreenMario,
                "constants": [
                    "unitsize",
                    "scale",
                    "gravity",
                    "pointLevels",
                    "customTextMappings"
                ]
            }, settings));
        }
        /* Resets
        */
        FullScreenMario.prototype.resetObjectMaker = function (FSM, settings) {
            FSM.ObjectMaker = new ObjectMakr.ObjectMakr(FSM.proliferate({
                "properties": {
                    "Quadrant": {
                        "EightBitter": FSM,
                        "GameStarter": FSM,
                        "FSM": FSM
                    },
                    "Thing": {
                        "EightBitter": FSM,
                        "GameStarter": FSM,
                        "FSM": FSM
                    }
                }
            }, FSM.settings.objects));
        };
        /**
         * Sets this.AudioPlayer.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} customs
         */
        FullScreenMario.prototype.resetAudioPlayer = function (FSM, settings) {
            _super.prototype.resetAudioPlayer.call(this, FSM, settings);
            FSM.AudioPlayer.setGetVolumeLocal(FSM.getVolumeLocal.bind(FSM, FSM));
            FSM.AudioPlayer.setGetThemeDefault(FSM.getAudioThemeDefault.bind(FSM, FSM));
        };
        /**
         * Sets this.ThingHitter.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} customs
         */
        FullScreenMario.prototype.resetThingHitter = function (FSM, settings) {
            _super.prototype.resetThingHitter.call(this, FSM, settings);
            FSM.ThingHitter.cacheHitCheckGroup("Solid");
            FSM.ThingHitter.cacheHitCheckGroup("Character");
        };
        /**
         * Sets this.MapsHandler.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} customs
         */
        FullScreenMario.prototype.resetMapsHandler = function (FSM, settings) {
            FSM.MapsHandler = new MapsHandlr.MapsHandlr({
                "MapsCreator": FSM.MapsCreator,
                "MapScreener": FSM.MapScreener,
                "screenAttributes": FSM.settings.maps.screenAttributes,
                "onSpawn": FSM.settings.maps.onSpawn.bind(FSM),
                "stretchAdd": FSM.mapAddStretched.bind(FSM),
                "afterAdd": FSM.mapAddAfter.bind(FSM)
            });
        };
        /**
         * Resets this.ItemsHolder via the parent GameStartr resetItemsHolder.
         *
         * If the screen isn't wide enough to fit the 'lives' display, it's hidden.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} customs
         */
        FullScreenMario.prototype.resetItemsHolder = function (FSM, settings) {
            _super.prototype.resetItemsHolder.call(this, FSM, settings);
            if (settings.width < 560) {
                FSM.ItemsHolder.getContainer().children[0].cells[4].style.display = "none";
            }
        };
        /**
         * Sets this.MathDecider, using its existing MapScreenr as its constants.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} customs
         */
        FullScreenMario.prototype.resetMathDecider = function (FSM, customs) {
            FSM.MathDecider = new MathDecidr.MathDecidr(FSM.proliferate({
                "constants": FSM.MapScreener
            }, FSM.settings.math));
        };
        /**
         * Sets this.container via the parent GameStartr resetContaienr.
         *
         * The container is given the "Press Start" font, the PixelRender is told
         * to draw the scenery, solid, character, and text groups, and the container
         * width is set to the custom's width.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} customs
         */
        FullScreenMario.prototype.resetContainer = function (FSM, settings) {
            _super.prototype.resetContainer.call(this, FSM, settings);
            FSM.container.style.fontFamily = "Press Start";
            FSM.container.className += " FullScreenMario";
            FSM.PixelDrawer.setThingArrays([
                FSM.GroupHolder.getGroup("Scenery"),
                FSM.GroupHolder.getGroup("Solid"),
                FSM.GroupHolder.getGroup("Character"),
                FSM.GroupHolder.getGroup("Text")
            ]);
            FSM.ItemsHolder.getContainer().style.width = settings.width + "px";
            FSM.container.appendChild(FSM.ItemsHolder.getContainer());
        };
        /* Global manipulations
        */
        /**
         * Completely restarts the game. Lives are reset to 3, the map goes back
         * to default, and the onGameStart mod trigger is fired.
         */
        FullScreenMario.prototype.gameStart = function () {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this);
            FSM.setMap(FSM.settings.maps.mapDefault, FSM.settings.maps.locationDefault);
            FSM.ItemsHolder.setItem("lives", FSM.settings.statistics.values.lives.valueDefault);
            FSM.ModAttacher.fireEvent("onGameStart");
        };
        /**
         * Completely ends the game. All Thing groups are clared, sounds are
         * stopped, the screen goes to black, "GAME OVER" is displayed. After a
         * while, the game restarts again via gameStart.
         */
        FullScreenMario.prototype.gameOver = function () {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), text = FSM.ObjectMaker.make("CustomText", {
                "texts": [{
                        "text": "GAME OVER"
                    }]
            }), texts, textWidth, i;
            FSM.killNPCs();
            FSM.AudioPlayer.clearAll();
            FSM.AudioPlayer.play("Game Over");
            FSM.GroupHolder.clearArrays();
            FSM.ItemsHolder.hideContainer();
            FSM.TimeHandler.cancelAllEvents();
            FSM.PixelDrawer.setBackground("black");
            FSM.addThing(text, FSM.MapScreener.width / 2, FSM.MapScreener.height / 2);
            texts = text.children;
            textWidth = -(texts[texts.length - 1].right - texts[0].left) / 2;
            for (i = 0; i < texts.length; i += 1) {
                FSM.shiftHoriz(texts[i], textWidth);
            }
            FSM.TimeHandler.addEvent(function () {
                FSM.gameStart();
                FSM.ItemsHolder.displayContainer();
            }, 420);
            FSM.ModAttacher.fireEvent("onGameOver");
        };
        /**
         * Slight addition to the GameStartr thingProcess Function. The Thing's hit
         * check type is cached immediately.
         */
        FullScreenMario.prototype.thingProcess = function (thing, title, settings, defaults) {
            // Infinite height refers to objects that reach exactly to the bottom
            if (thing.height === "Infinity" || thing.height === Infinity) {
                thing.height = thing.FSM.getAbsoluteHeight(thing.y) / thing.FSM.unitsize;
            }
            _super.prototype.thingProcess.call(this, thing, title, settings, defaults);
            // ThingHittr becomes very non-performant if functions aren't generated
            // for each Thing constructor (optimization does not respect prototypal 
            // inheritance, sadly).
            thing.FSM.ThingHitter.cacheHitCheckType(thing.title, thing.groupType);
        };
        /**
         * Adds a Thing via addPreThing based on the specifications in a PreThing.
         * This is done relative to MapScreener.left and MapScreener.floor.
         *
         * @param {PreThing} prething
         */
        FullScreenMario.prototype.addPreThing = function (prething) {
            var thing = prething.thing, position = prething.position || thing.position;
            thing.FSM.addThing(thing, prething.left * thing.FSM.unitsize - thing.FSM.MapScreener.left, (thing.FSM.MapScreener.floor - prething.top) * thing.FSM.unitsize);
            // Either the prething or thing, in that order, may request to be in the
            // front or back of its container using the "position" attribute
            if (position) {
                thing.FSM.TimeHandler.addEvent(function () {
                    switch (position) {
                        case "beginning":
                            thing.FSM.arrayToBeginning(thing, thing.FSM.GroupHolder.getGroup(thing.groupType));
                            break;
                        case "end":
                            thing.FSM.arrayToEnd(thing, thing.FSM.GroupHolder.getGroup(thing.groupType));
                            break;
                        default:
                            break;
                    }
                });
            }
            thing.FSM.ModAttacher.fireEvent("onAddPreThing", prething);
        };
        /**
         * Adds a new Player Thing to the game and sets it as EightBitter.play. Any
         * required additional settings (namely keys, power/size, and swimming) are
         * applied here.
         *
         * @this {EightBittr}
         * @param {Number} [left]   A left coordinate to place the Thing at (by
         *                          default, unitsize * 16).
         * @param {Number} [bottom]   A bottom coordinate to place the Thing upon
         *                            (by default, unitsize * 16).
         */
        FullScreenMario.prototype.addPlayer = function (left, bottom) {
            if (left === void 0) { left = this.unitsize * 16; }
            if (bottom === void 0) { bottom = this.unitsize * 16; }
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), player;
            player = FSM.player = FSM.ObjectMaker.make("Player", {
                "power": FSM.ItemsHolder.getItem("power")
            });
            player.keys = player.getKeys();
            if (FSM.MapScreener.underwater) {
                player.swimming = true;
                FSM.TimeHandler.addClassCycle(player, [
                    "swim1", "swim2"
                ], "swimming", 5);
                FSM.TimeHandler.addEventInterval(player.FSM.animatePlayerBubbling, 96, Infinity, player);
            }
            FSM.setPlayerSizeSmall(player);
            if (player.power >= 2) {
                FSM.playerGetsBig(player, true);
                if (player.power === 3) {
                    FSM.playerGetsFire(player);
                }
            }
            FSM.addThing(player, left, bottom - player.height * FSM.unitsize);
            FSM.ModAttacher.fireEvent("onAddPlayer", player);
            return player;
        };
        /**
         * Shortcut to call scrollThing on the player.
         *
         * @this {EightBittr}
         * @param {Number} dx
         * @param {Number} dy
         */
        FullScreenMario.prototype.scrollPlayer = function (dx, dy) {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this);
            FSM.scrollThing(FSM.player, dx, dy);
            FSM.ModAttacher.fireEvent("onScrollPlayer", dx, dy);
        };
        /**
         * Triggered Function for when the game is paused. Music stops, the pause
         * bleep is played, and the mod event is fired.
         */
        FullScreenMario.prototype.onGamePause = function (FSM) {
            FSM.AudioPlayer.pauseAll();
            FSM.AudioPlayer.play("Pause");
            FSM.ModAttacher.fireEvent("onGamePause");
        };
        /**
         * Triggered Function for when the game is played or unpause. Music resumes
         * and the mod event is fired.
         */
        FullScreenMario.prototype.onGamePlay = function (FSM) {
            FSM.AudioPlayer.resumeAll();
            FSM.ModAttacher.fireEvent("onGamePlay");
        };
        /* Input
        */
        /**
         * Reacts to the left key being pressed. keys.run and leftDown are marked
         * and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyDownLeft = function (FSM, event) {
            if (FSM.GamesRunner.getPaused()) {
                return;
            }
            var player = FSM.player;
            player.keys.run = -1;
            player.keys.leftDown = true; // independent of changes to keys.run
            player.FSM.ModAttacher.fireEvent("onKeyDownLeft");
        };
        /**
         * Reacts to the right key being pressed. keys.run and keys.rightDown are
         * marked and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyDownRight = function (FSM, event) {
            if (FSM.GamesRunner.getPaused()) {
                return;
            }
            var player = FSM.player;
            player.keys.run = 1;
            player.keys.rightDown = true; // independent of changes to keys.run
            player.FSM.ModAttacher.fireEvent("onKeyDownRight");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the up key being pressed. If the player can jump, it does, and
         * underwater paddling is checked. The mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyDownUp = function (FSM, event) {
            if (FSM.GamesRunner.getPaused()) {
                return;
            }
            var player = FSM.player;
            player.keys.up = true;
            if (player.canjump && (player.resting || FSM.MapScreener.underwater)) {
                player.keys.jump = true;
                player.canjump = false;
                player.keys.jumplev = 0;
                if (player.power > 1) {
                    FSM.AudioPlayer.play("Jump Super");
                }
                else {
                    FSM.AudioPlayer.play("Jump Small");
                }
                if (FSM.MapScreener.underwater) {
                    FSM.TimeHandler.addEvent(function () {
                        player.jumping = player.keys.jump = false;
                    }, 14);
                }
            }
            FSM.ModAttacher.fireEvent("onKeyDownUp");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the down key being pressed. The player's keys.crouch is marked
         * and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyDownDown = function (FSM, event) {
            if (FSM.GamesRunner.getPaused()) {
                return;
            }
            var player = FSM.player;
            player.keys.crouch = true;
            FSM.ModAttacher.fireEvent("onKeyDownDown");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the sprint key being pressed. Firing happens if the player is
         * able, keys.spring is marked, and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyDownSprint = function (FSM, event) {
            if (FSM.GamesRunner.getPaused()) {
                return;
            }
            var player = FSM.player;
            if (player.power === 3 && player.keys.sprint === false && !player.crouching) {
                player.fire(player);
            }
            player.keys.sprint = true;
            player.FSM.ModAttacher.fireEvent("onKeyDownSprint");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the pause key being pressed. The game is either paused or unpaused,
         * and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyDownPause = function (FSM, event) {
            if (FSM.GamesRunner.getPaused()) {
                FSM.GamesRunner.play();
            }
            else {
                FSM.GamesRunner.pause();
            }
            FSM.ModAttacher.fireEvent("onKeyDownPause");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the mute key being lifted. Muting is toggled and the mod event
         * is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyDownMute = function (FSM, event) {
            if (FSM.GamesRunner.getPaused()) {
                return;
            }
            FSM.AudioPlayer.toggleMuted();
            FSM.ModAttacher.fireEvent("onKeyDownMute");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the left key being lifted. keys.run and keys.leftDown are
         * marked and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyUpLeft = function (FSM, event) {
            var player = FSM.player;
            player.keys.run = 0;
            player.keys.leftDown = false;
            FSM.ModAttacher.fireEvent("onKeyUpLeft");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the right key being lifted. keys.run and keys.rightDown are
         * marked and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyUpRight = function (FSM, event) {
            var player = FSM.player;
            player.keys.run = 0;
            player.keys.rightDown = false;
            FSM.ModAttacher.fireEvent("onKeyUpRight");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the up key being lifted. Jumping stops and the mod event is
         * fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyUpUp = function (FSM, event) {
            var player = FSM.player;
            if (!FSM.MapScreener.underwater) {
                player.keys.jump = player.keys.up = false;
            }
            player.canjump = true;
            FSM.ModAttacher.fireEvent("onKeyUpUp");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the down key being lifted. keys.crouch is marked, crouch
         * removal happens if necessary, and the mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyUpDown = function (FSM, event) {
            var player = FSM.player;
            player.keys.crouch = false;
            if (!player.piping) {
                FSM.animatePlayerRemoveCrouch(player);
            }
            FSM.ModAttacher.fireEvent("onKeyUpDown");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the spring key being lifted. keys.sprint is marked and the mod
         * event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyUpSprint = function (FSM, event) {
            var player = FSM.player;
            player.keys.sprint = false;
            FSM.ModAttacher.fireEvent("onKeyUpSprint");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to the pause key being lifted. The mod event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.keyUpPause = function (FSM, event) {
            FSM.ModAttacher.fireEvent("onKeyUpPause");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to a right click being pressed. Pausing is toggled and the mod
         * event is fired.
         *
         * @param {Player} player
         */
        FullScreenMario.prototype.mouseDownRight = function (FSM, event) {
            FSM.GamesRunner.togglePause();
            FSM.ModAttacher.fireEvent("onMouseDownRight");
            if (event && event.preventDefault !== undefined) {
                event.preventDefault();
            }
        };
        /**
         * Reacts to a regularly caused device motion event. Acceleration is checked
         * for changed tilt horizontally (to trigger left or right key statuses) or
         * changed tilt vertically (jumping). The mod event is also fired.
         *
         * @param {Player} player
         * @param {DeviceMotionEvent} event
         */
        FullScreenMario.prototype.deviceMotion = function (FSM, event) {
            var player = FSM.player, deviceMotionStatus = FSM.deviceMotionStatus, acceleration = event.accelerationIncludingGravity;
            FSM.ModAttacher.fireEvent("onDeviceMotion", event);
            if (deviceMotionStatus.y !== undefined) {
                deviceMotionStatus.dy = acceleration.y - deviceMotionStatus.y;
                if (deviceMotionStatus.dy > 0.21) {
                    FSM.keyDownUp(FSM);
                }
                else if (deviceMotionStatus.dy < -0.14) {
                    FSM.keyUpUp(FSM);
                }
            }
            deviceMotionStatus.x = acceleration.x;
            deviceMotionStatus.y = acceleration.y;
            if (deviceMotionStatus.x > 2.1) {
                if (!deviceMotionStatus.motionLeft) {
                    player.FSM.keyDownLeft(FSM);
                    deviceMotionStatus.motionLeft = true;
                }
            }
            else if (deviceMotionStatus.x < -2.1) {
                if (!deviceMotionStatus.motionRight) {
                    player.FSM.keyDownRight(FSM);
                    deviceMotionStatus.motionRight = true;
                }
            }
            else {
                if (deviceMotionStatus.motionLeft) {
                    player.FSM.keyUpLeft(FSM);
                    deviceMotionStatus.motionLeft = false;
                }
                if (deviceMotionStatus.motionRight) {
                    player.FSM.keyUpRight(FSM);
                    deviceMotionStatus.motionRight = false;
                }
            }
        };
        /**
         * Checks whether inputs can be fired, which is equivalent to the status of
         * the MapScreener's nokeys variable (an inverse value).
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.canInputsTrigger = function (FSM) {
            return !FSM.MapScreener.nokeys;
        };
        /* Upkeep maintenence
        */
        /**
         * Regular maintenance Function called to decrease time every 25 game
         * ticks. Returns whether time should stop counting, which is only when
         * it becomes 0.
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.maintainTime = function (FSM) {
            if (!FSM.MapScreener.notime) {
                FSM.ItemsHolder.decrease("time", 1);
                return false;
            }
            if (!FSM.ItemsHolder.getItem("time")) {
                return true;
            }
            return false;
        };
        /**
         * Regular maintenance Function called on the Scenery group every 350
         * upkeeps (slightly over 5 seconds). Things are checked for being alive
         * and to the left of QuadsKeeper.left; if they aren't, they are removed.
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.maintainScenery = function (FSM) {
            var things = FSM.GroupHolder.getGroup("Scenery"), delx = FSM.QuadsKeeper.left, thing, i;
            for (i = 0; i < things.length; i += 1) {
                thing = things[i];
                if (thing.right < delx && thing.outerok !== 2) {
                    FSM.arrayDeleteThing(thing, things, i);
                    i -= 1;
                }
            }
        };
        /**
         * Regular maintenance Function called on the Solids group every upkeep.
         * Things are checked for being alive and to the right of QuadsKeeper.left;
         * if they aren't, they are removed. Each Thing is also allowed a movement
         * Function.
         *
         * @param {FullScreenMario} FSM
         * @param {Solid[]} solids   FSM's GroupHolder's Solid group.
         */
        FullScreenMario.prototype.maintainSolids = function (FSM, solids) {
            var delx = FSM.QuadsKeeper.left, solid, i;
            FSM.QuadsKeeper.determineAllQuadrants("Solid", solids);
            for (i = 0; i < solids.length; i += 1) {
                solid = solids[i];
                if (solid.alive && solid.right > delx) {
                    if (solid.movement) {
                        solid.movement(solid);
                    }
                }
                else if (!solid.alive || solid.outerok !== 2) {
                    FSM.arrayDeleteThing(solid, solids, i);
                    i -= 1;
                }
            }
        };
        /**
         * Regular maintenance Function called on the Characters group every upkeep.
         * Things have gravity and y-velocities, collision detection, and resting
         * checks applied before they're checked for being alive. If they are, they
         * are allowed a movement Function; if not, they are removed.
         *
         * @param {FullScreenMario} FSM
         * @param {Character[]} characters   EightBittr's GroupHolder's Characters
         *                                   group.
         */
        FullScreenMario.prototype.maintainCharacters = function (FSM, characters) {
            var delx = FSM.QuadsKeeper.right, character, i;
            for (i = 0; i < characters.length; i += 1) {
                character = characters[i];
                // Gravity
                if (character.resting) {
                    character.yvel = 0;
                }
                else {
                    if (!character.nofall) {
                        character.yvel += character.gravity || FSM.MapScreener.gravity;
                    }
                    character.yvel = Math.min(character.yvel, FSM.MapScreener.maxyvel);
                }
                // Position updating and collision detection
                character.under = character.undermid = undefined;
                FSM.updatePosition(character);
                FSM.QuadsKeeper.determineThingQuadrants(character);
                FSM.ThingHitter.checkHitsOf[character.title](character);
                // Overlaps
                if (character.overlaps && character.overlaps.length) {
                    FSM.maintainOverlaps(character);
                }
                // Resting tests
                if (character.resting) {
                    if (!FSM.isCharacterOnResting(character, character.resting)) {
                        if (character.onRestingOff) {
                            character.onRestingOff(character, character.resting);
                        }
                        else {
                            // Necessary for moving platforms
                            character.resting = undefined;
                        }
                    }
                    else {
                        character.yvel = 0;
                        FSM.setBottom(character, character.resting.top);
                    }
                }
                // Movement or deletion
                // To do: rethink this...
                if (character.alive) {
                    if (!character.player &&
                        (character.numquads === 0 || character.left > delx) &&
                        (!character.outerok || (character.outerok !== 2
                            && character.right < FSM.MapScreener.width - delx))) {
                        FSM.arrayDeleteThing(character, characters, i);
                        i -= 1;
                    }
                    else {
                        if (!character.nomove && character.movement) {
                            character.movement(character);
                        }
                    }
                }
                else {
                    FSM.arrayDeleteThing(character, characters, i);
                    i -= 1;
                }
            }
        };
        /**
         * Maintenance Function only triggered for Things that are known to have
         * overlapping Solids stored in their overlaps attribute. This will slide
         * the offending Thing away from the midpoint of those overlaps once a call
         * until it's past the boundary (and check for those boundaries if not
         * already set).
         *
         * @param {Thing} thing
         */
        FullScreenMario.prototype.maintainOverlaps = function (character) {
            // If checkOverlaps is still true, this is the first maintain call
            if (character.checkOverlaps) {
                if (!character.FSM.setOverlapBoundaries(character)) {
                    return;
                }
            }
            character.FSM.slideToX(character, character.overlapGoal, character.FSM.unitsize);
            // Goal to the right: has the thing gone far enough to the right?
            if (character.overlapGoRight) {
                if (character.left >= character.overlapCheck) {
                    character.FSM.setLeft(character, character.overlapCheck);
                }
                else {
                    return;
                }
            }
            else {
                // Goal to the left: has the thing gone far enough to the left?
                if (character.right <= character.overlapCheck) {
                    character.FSM.setRight(character, character.overlapCheck);
                }
                else {
                    return;
                }
            }
            // A check above didn't fail into a return, so overlapping is solved
            character.overlaps.length = 0;
            character.checkOverlaps = true;
        };
        /**
         * Sets the overlapping properties of a Thing when it is first detected as
         * overlapping in maintainOverlaps. All solids in its overlaps Array are
         * checked to find the leftmost and rightmost extremes and midpoint.
         * Then, the Thing is checked for being to the left or right of the
         * midpoint, and the goal set to move it away from the midpoint.
         *
         * @param {Thing} thing
         * @return {Boolean}   Whether the Thing's overlaps were successfully
         *                     recorded (if there was only one, not so).
         */
        FullScreenMario.prototype.setOverlapBoundaries = function (thing) {
            // Only having one overlap means nothing should be done
            if (thing.overlaps.length === 1) {
                thing.overlaps.length = 0;
                return false;
            }
            var rightX = -Infinity, leftX = Infinity, overlaps = thing.overlaps, other, leftThing, rightThing, midpoint, i;
            for (i = 0; i < overlaps.length; i += 1) {
                other = overlaps[i];
                if (other.right > rightX) {
                    rightThing = other;
                }
                if (other.left < leftX) {
                    leftThing = other;
                }
            }
            midpoint = (leftX + rightX) / 2;
            if (thing.FSM.getMidX(thing) >= midpoint) {
                thing.overlapGoal = Infinity;
                thing.overlapGoRight = true;
                thing.overlapCheck = rightThing.right;
            }
            else {
                thing.overlapGoal = -Infinity;
                thing.overlapGoRight = false;
                thing.overlapCheck = leftThing.left;
            }
            thing.checkOverlaps = false;
            return true;
        };
        /**
         * Regular maintenance Function called on the player every upkeep. A barrage
         * of tests are applied, namely falling/jumping, dying, x- and y-velocities,
         * running, and scrolling. This is separate from the movePlayer movement
         * Function that will be called in maintainCharacters.
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.maintainPlayer = function (FSM) {
            var player = FSM.player;
            if (!FSM.isThingAlive(player)) {
                return;
            }
            // Player is falling
            if (player.yvel > 0) {
                if (!FSM.MapScreener.underwater) {
                    player.keys.jump = false;
                }
                // Jumping?
                if (!player.jumping && !player.crouching) {
                    // Paddling? (from falling off a solid)
                    if (FSM.MapScreener.underwater) {
                        if (!player.paddling) {
                            FSM.switchClass(player, "paddling", "paddling");
                            player.paddling = true;
                        }
                    }
                    else {
                        FSM.addClass(player, "jumping");
                        player.jumping = true;
                    }
                }
                // Player has fallen too far
                if (!player.dying && player.top > FSM.MapScreener.bottom) {
                    // If the map has an exit (e.g. cloud world), transport there
                    if (FSM.MapsHandler.getArea().exit) {
                        FSM.setLocation(FSM.MapsHandler.getArea().exit);
                    }
                    else {
                        // Otherwise, since Player is below the screen, kill him dead
                        FSM.killPlayer(player, 2);
                    }
                    return;
                }
            }
            // Player is moving to the right
            if (player.xvel > 0) {
                if (player.right > FSM.MapScreener.middleX) {
                    // If Player is to the right of the screen's middle, move the screen
                    if (player.right > FSM.MapScreener.right - FSM.MapScreener.left) {
                        player.xvel = Math.min(0, player.xvel);
                    }
                }
            }
            else if (player.left < 0) {
                // Player is moving to the left
                // Stop Player from going to the left.
                player.xvel = Math.max(0, player.xvel);
            }
            // Player is hitting something (stop jumping)
            if (player.under) {
                player.jumpcount = 0;
            }
            // Scrolloffset is how far over the middle player's right is
            if (FSM.MapScreener.canscroll) {
                var scrolloffset = player.right - FSM.MapScreener.middleX;
                if (scrolloffset > 0) {
                    FSM.scrollWindow(Math.min(player.scrollspeed, scrolloffset));
                }
            }
        };
        /* Collision detectors
        */
        /**
         * Function generator for the generic canThingCollide checker. This is used
         * repeatedly by ThingHittr to generate separately optimized Functions for
         * different Thing types.
         *
         * @return {Function}
         */
        FullScreenMario.prototype.generateCanThingCollide = function () {
            /**
             * Generic checker for canCollide, used for both Solids and Characters.
             * This just returns if the Thing is alive and doesn't have the
             * nocollide flag.
             *
             * @param {Thing} thing
             * @return {Boolean}
             */
            return function canThingCollide(thing) {
                return thing.alive && !thing.nocollide;
            };
        };
        /**
         * @param {Thing} thing
         * @return {Boolean} Whether the Thing is alive, meaning it has a true alive
         *                   flag and a false dead flag.
         */
        FullScreenMario.prototype.isThingAlive = function (thing) {
            return thing && thing.alive && !thing.dead;
        };
        /**
         * Generic base function to check if one Thing is touching another. This
         * will be called by the more specific Thing touching functions.
         *
         * @param {Thing} thing
         * @param {Thing} other
         * @return {Boolean}
         * @remarks Only the horizontal checks use unitsize
         */
        FullScreenMario.prototype.isThingTouchingThing = function (thing, other) {
            return (!thing.nocollide && !other.nocollide
                && thing.right - thing.FSM.unitsize > other.left
                && thing.left + thing.FSM.unitsize < other.right
                && thing.bottom >= other.top
                && thing.top <= other.bottom);
        };
        /**
         * General top collision detection Function for two Things to determine if
         * one Thing is on top of another. This takes into consideration factors
         * such as which are solid or an enemy, and y-velocity.
         *
         * @param {Thing} thing
         * @param {Thing} other
         * @return {Boolean}
         * @remarks This is a more specific form of isThingTouchingThing
         */
        FullScreenMario.prototype.isThingOnThing = function (thing, other) {
            // If thing is a solid and other is falling, thing can't be above other
            if (thing.groupType === "Solid" && other.yvel > 0) {
                return false;
            }
            // If other is falling faster than thing, and isn't a solid,
            // thing can't be on top (if anything, the opposite is true)
            if (thing.yvel < other.yvel && other.groupType !== "Solid") {
                return false;
            }
            // If thing is the player, and it's on top of an enemy, that's true
            if (thing.player && thing.bottom < other.bottom
                && other.type === "enemy") {
                return true;
            }
            // If thing is too far to the right, it can't be touching other
            if (thing.left + thing.FSM.unitsize >= other.right) {
                return false;
            }
            // If thing is too far to the left, it can't be touching other
            if (thing.right - thing.FSM.unitsize <= other.left) {
                return false;
            }
            // If thing's bottom is below other's top, factoring tolerance and
            // other's vertical velocity, they're touching
            if (thing.bottom <= other.top + other.toly + other.yvel) {
                return true;
            }
            // Same as before, but with velocity as the absolute difference between
            // their two velocities
            if (thing.bottom <= other.top + other.toly + Math.abs(thing.yvel - other.yvel)) {
                return true;
            }
            // None of the above checks passed for true, so this is false (thing's
            // bottom is above other's top
            return false;
        };
        /**
         * Top collision Function to determine if one Thing is on top of a solid.
         *
         * @param {Thing} thing
         * @param {Solid} other
         * @remarks Similar to isThingOnThing, but more specifically used for
         *          isCharacterOnSolid and isCharacterOnResting
         */
        FullScreenMario.prototype.isThingOnSolid = function (thing, other) {
            // If thing is too far to the right, they're not touching
            if (thing.left + thing.FSM.unitsize >= other.right) {
                return false;
            }
            // If thing is too far to the left, they're not touching
            if (thing.right - thing.FSM.unitsize <= other.left) {
                return false;
            }
            // If thing's bottom is below other's top, factoring thing's velocity
            // and other's tolerance, they're touching
            if (thing.bottom - thing.yvel <= other.top + other.toly + thing.yvel) {
                return true;
            }
            // Same as before, but with velocity as the absolute difference between
            // their two velocities
            if (thing.bottom <= other.top + other.toly + Math.abs(thing.yvel - other.yvel)) {
                return true;
            }
            // None of the above checks passed for true, so this is false (thing's
            // bottom is above other's top
            return false;
        };
        /**
         * Top collision Function to determine if a character is on top of a solid.
         * This is always true for resting (since resting checks happen before when
         * this should be called).
         *
         * @param {Character} thing
         * @param {Solid} other
         * @return {Boolean}
         */
        FullScreenMario.prototype.isCharacterOnSolid = function (thing, other) {
            // If character is resting on solid, this is automatically true
            if (thing.resting === other) {
                return true;
            }
            // If the character is jumping upwards, it's not on a solid
            // (removing this check would cause Mario to have "sticky" behavior when
            // jumping at the corners of solids)
            if (thing.yvel < 0) {
                return false;
            }
            // The character and solid must be touching appropriately
            if (!thing.FSM.isThingOnSolid(thing, other)) {
                return false;
            }
            // Corner case: when character is exactly falling off the right (false)
            if (thing.left + thing.xvel + thing.FSM.unitsize === other.right) {
                return false;
            }
            // Corner case: when character is exactly falling off the left (false)
            if (thing.right - thing.xvel - thing.FSM.unitsize === other.left) {
                return false;
            }
            // None of the above checks caught a falsity, so this must be true
            return true;
        };
        /**
         * Top collision Function to determine if a character should be considered
         * resting on a solid. This mostly uses isThingOnSolid, but also checks for
         * the corner cases of the character being exactly at the edge of the solid
         * (such as when jumping while next to it).
         *
         * @param {Character} thing
         * @param {Solid} other
         * @return {Boolean}
         */
        FullScreenMario.prototype.isCharacterOnResting = function (thing, other) {
            if (!thing.FSM.isThingOnSolid(thing, other)) {
                return false;
            }
            // Corner case: when character is exactly falling off the right (false)
            if (thing.left + thing.xvel + thing.FSM.unitsize === other.right) {
                return false;
            }
            // Corner case: when character is exactly falling off the left (false)
            if (thing.right - thing.xvel - thing.FSM.unitsize === other.left) {
                return false;
            }
            // None of the above checks caught a falsity, so this must be true
            return true;
        };
        /**
         * Function generator for the generic isCharacterTouchingCharacter checker.
         * This is used repeatedly by ThingHittr to generate separately optimized
         * Functions for different Thing types.
         *
         * @return {Function}
         */
        FullScreenMario.prototype.generateIsCharacterTouchingCharacter = function () {
            /**
             * Generic checker for whether two characters are touching each other.
             * This mostly checks to see if either has the nocollidechar flag, and
             * if the other is a player. isThingTouchingThing is used after.
             *
             * @param {Character} thing
             * @param {Character} other
             * @return {Boolean}
             */
            return function isCharacterTouchingCharacter(thing, other) {
                if (thing.nocollidechar && (!other.player || thing.nocollideplayer)) {
                    return false;
                }
                if (other.nocollidechar && (!thing.player || other.nocollideplayer)) {
                    return false;
                }
                return thing.FSM.isThingTouchingThing(thing, other);
            };
        };
        /**
         * Function generator for the generic isCharacterTouchingSolid checker. This
         * is used repeatedly by ThingHittr to generate separately optimized
         * Functions for different Thing types.
         *
         * @return {Function}
         */
        FullScreenMario.prototype.generateIsCharacterTouchingSolid = function () {
            /**
             * Generic checker for whether a character is touching a solid. The
             * hidden, collideHidden, and nocollidesolid flags are most relevant.
             *
             * @param {Character} thing
             * @param {Solid} other
             */
            return function isCharacterTouchingSolid(thing, other) {
                // Hidden solids can only be touched by the player bottom-bumping
                // them, or by specifying collideHidden
                if (other.hidden && !other.collideHidden) {
                    if (!thing.player || !thing.FSM.isSolidOnCharacter(other, thing)) {
                        return false;
                    }
                }
                if (thing.nocollidesolid && !(thing.allowUpSolids && other.up)) {
                    return false;
                }
                return thing.FSM.isThingTouchingThing(thing, other);
            };
        };
        /**
         * @param {Character} thing
         * @param {Enemy} other
         * @return {Boolean} Whether the Thing's bottom is above the other's top,
         *                   allowing for the other's toly.
         */
        FullScreenMario.prototype.isCharacterAboveEnemy = function (thing, other) {
            return thing.bottom < other.top + other.toly;
        };
        /**
         * @param {Character} thing
         * @param {Solid} other
         * @return {Boolean} Whether the Thing's top is above the other's bottom,
         *                   allowing for the Thing's toly and yvel.
         */
        FullScreenMario.prototype.isCharacterBumpingSolid = function (thing, other) {
            return thing.top + thing.toly + Math.abs(thing.yvel) > other.bottom;
        };
        /**
         * @param {Character} thing
         * @param {Solid} other
         * @return {Boolean} Whether the Thing is "overlapping" the solid, which
         *                   should move the Thing until it isn't.
         */
        FullScreenMario.prototype.isCharacterOverlappingSolid = function (thing, other) {
            return thing.top <= other.top && thing.bottom > other.bottom;
        };
        /**
         * @param {Solid} thing
         * @param {Character} other
         * @return {Boolean} Whether the Thing, typically a solid, is on top of the
         *                   other.
         * @remarks Similar to isThingOnThing, but more specifically used for
         *          characterTouchedSolid
         */
        FullScreenMario.prototype.isSolidOnCharacter = function (thing, other) {
            // This can never be true if other is falling
            if (other.yvel >= 0) {
                return false;
            }
            // Horizontally, all that's required is for the other's midpoint to
            // be within the thing's left and right
            var midx = thing.FSM.getMidX(other);
            if (midx <= thing.left || midx >= thing.right) {
                return false;
            }
            // If the thing's bottom is below the other's top, factoring
            // tolerance and velocity, that's false (this function assumes they're
            // already touching)
            if (thing.bottom - thing.yvel > other.top + other.toly - other.yvel) {
                return false;
            }
            // The above checks never caught falsities, so this must be true
            return true;
        };
        /* Collision reactions
        */
        /**
         * Externally facing Function to gain some number of lives. ItemsHolder
         * increases the "score" statistic, an audio is played, and the mod event is
         * fired.
         *
         * @this {EightBittr}
         * @param {Number} [amount]   How many lives to gain (by default, 1).
         * @param {Boolean} [nosound]   Whether the sound should be skipped (by
         *                              default, false).
         */
        FullScreenMario.prototype.gainLife = function (amount, nosound) {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this);
            amount = Number(amount) || 1;
            FSM.ItemsHolder.increase("lives", amount);
            if (!nosound) {
                this.AudioPlayer.play("Gain Life");
            }
            FSM.ModAttacher.fireEvent("onGainLife", amount);
        };
        /**
         * Basic Function for an item to jump slightly into the air, such as from
         * the player hitting a solid below it.
         *
         * @param {Item} thing
         * @remarks This simply moves the thing up slightly and decreases its
         *          y-velocity, without considering x-direction.
         */
        FullScreenMario.prototype.itemJump = function (thing) {
            thing.yvel -= FullScreenMario.unitsize * 1.4;
            this.shiftVert(thing, -FullScreenMario.unitsize);
        };
        /**
         * Generic Function for when the player jumps on top of an enemy. The enemy
         * is killed, the player's velocity points upward, and score is gained.
         *
         * @param {Player} thing
         * @param {Enemy} other
         */
        FullScreenMario.prototype.jumpEnemy = function (thing, other) {
            if (thing.keys.up) {
                thing.yvel = thing.FSM.unitsize * -1.4;
            }
            else {
                thing.yvel = thing.FSM.unitsize * -0.7;
            }
            thing.xvel *= 0.91;
            thing.FSM.AudioPlayer.play("Kick");
            if (other.group !== "item" || other.shell) {
                thing.jumpcount += 1;
                thing.FSM.scoreOn(thing.FSM.findScore(thing.jumpcount + thing.jumpers), other);
            }
            thing.jumpers += 1;
            thing.FSM.TimeHandler.addEvent(function (thing) {
                thing.jumpers -= 1;
            }, 1, thing);
        };
        /**
         * Callback for the player hitting a Mushroom or FireFlower. The player's
         * power and the ItemsHolder's "power" statistic both go up, and the
         * corresponding animations and mod event are triggered.
         *
         * @param {Player} thing
         * @param {Item} [other]
         */
        FullScreenMario.prototype.playerShroom = function (thing, other) {
            if (thing.shrooming || !thing.player) {
                return;
            }
            thing.FSM.AudioPlayer.play("Powerup");
            thing.FSM.scoreOn(1000, thing.FSM.player);
            if (thing.power < 3) {
                thing.FSM.ItemsHolder.increase("power");
                if (thing.power < 3) {
                    thing.shrooming = true;
                    thing.power += 1;
                    if (thing.power === 3) {
                        thing.FSM.playerGetsFire(thing.FSM.player);
                    }
                    else {
                        thing.FSM.playerGetsBig(thing.FSM.player);
                    }
                }
            }
            thing.FSM.ModAttacher.fireEvent("onPlayerShroom", thing, other);
        };
        /**
         * Callback for the player hitting a Mushroom1Up. The game simply calls
         * gainLife and triggers the mod event.
         *
         * @param {Player} thing
         * @param {Item} [other]
         */
        FullScreenMario.prototype.playerShroom1Up = function (thing, other) {
            if (!thing.player) {
                return;
            }
            thing.FSM.gainLife(1);
            thing.FSM.ModAttacher.fireEvent("onPlayerShroom1Up", thing, other);
        };
        /**
         * Callback for the player hitting a Star. A set of animation loops and
         * sounds play, and the mod event is triggered. After some long period time,
         * playerStarDown is called to start the process of removing star power.
         *
         * @param {Player} thing
         * @param {Number} [timeout]   How long to wait before calling
         *                             playerStarDown (by default, 560).
         */
        FullScreenMario.prototype.playerStarUp = function (thing, timeout) {
            if (timeout === void 0) { timeout = 560; }
            thing.star += 1;
            thing.FSM.switchClass(thing, "normal fiery", "star");
            thing.FSM.AudioPlayer.play("Powerup");
            thing.FSM.AudioPlayer.addEventListener("Powerup", "ended", thing.FSM.AudioPlayer.playTheme.bind(thing.FSM.AudioPlayer, "Star", true));
            thing.FSM.TimeHandler.addClassCycle(thing, [
                "star1", "star2", "star3", "star4"
            ], "star", 2);
            thing.FSM.TimeHandler.addEvent(thing.FSM.playerStarDown, timeout || 560, thing);
            thing.FSM.ModAttacher.fireEvent("onPlayerStarUp", thing);
        };
        /**
         * Trigger to commence reducing the player's star power. This slows the
         * class cycle, times a playerStarOffCycle trigger, and fires the mod event.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.playerStarDown = function (thing) {
            if (!thing.player) {
                return;
            }
            thing.FSM.TimeHandler.cancelClassCycle(thing, "star");
            thing.FSM.TimeHandler.addClassCycle(thing, [
                "star1", "star2", "star3", "star4"
            ], "star", 5);
            thing.FSM.TimeHandler.addEvent(thing.FSM.playerStarOffCycle, 140, thing);
            thing.FSM.AudioPlayer.removeEventListeners("Powerup", "ended");
            thing.FSM.ModAttacher.fireEvent("onPlayerStarDown", thing);
        };
        /**
         * Trigger to continue reducing the player's star power. This resumes
         * playing the regular theme, times a playerStarOffFinal trigger, and fires
         * the mod event.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.playerStarOffCycle = function (thing) {
            if (!thing.player) {
                return;
            }
            if (thing.star > 1) {
                thing.star -= 1;
                return;
            }
            if (!thing.FSM.AudioPlayer.getTheme().paused) {
                thing.FSM.AudioPlayer.playTheme();
            }
            thing.FSM.TimeHandler.addEvent(thing.FSM.playerStarOffFinal, 70, thing);
            thing.FSM.ModAttacher.fireEvent("onPlayerStarOffCycle", thing);
        };
        /**
         * Trigger to finish reducing the player's star power. This actually reduces
         * the player's star attribute, cancels the sprite cycle, adds the previous
         * classes back, and fires the mod event.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.playerStarOffFinal = function (thing) {
            if (!thing.player) {
                return;
            }
            thing.star -= 1;
            thing.FSM.TimeHandler.cancelClassCycle(thing, "star");
            thing.FSM.removeClasses(thing, "star star1 star2 star3 star4");
            thing.FSM.addClass(thing, "normal");
            if (thing.power === 3) {
                thing.FSM.addClass(thing, "fiery");
            }
            thing.FSM.ModAttacher.fireEvent("onPlayerStarOffFinal", thing);
        };
        /**
         * Sizing modifier for the player, typically called when entering a location
         * or colliding with a Mushroom. This sets the player's size to the large
         * mode and optionally plays the animation. The mod event is then fired.
         *
         * @param {Player} thing
         * @param {Boolean} [noAnimation]   Whether to skip the animation (by
         *                                  default, false).
         */
        FullScreenMario.prototype.playerGetsBig = function (thing, noAnimation) {
            thing.FSM.setPlayerSizeLarge(thing);
            thing.FSM.removeClasses(thing, "crouching small");
            thing.FSM.updateBottom(thing, 0);
            thing.FSM.updateSize(thing);
            if (noAnimation) {
                thing.FSM.addClass(thing, "large");
            }
            else {
                thing.FSM.playerGetsBigAnimation(thing);
            }
            thing.FSM.ModAttacher.fireEvent("onPlayerGetsBig", thing);
        };
        /**
         * Animation scheduler for the player getting big. The shrooming classes are
         * cycled through rapidly while the player's velocity is paused.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.playerGetsBigAnimation = function (thing) {
            var stages = [
                "shrooming1", "shrooming2",
                "shrooming1", "shrooming2",
                "shrooming3", "shrooming2", "shrooming3"
            ];
            thing.FSM.addClass(thing, "shrooming");
            thing.FSM.thingPauseVelocity(thing);
            // The last stage in the events clears it, resets movement, and stops
            stages.push(function (thing, stages) {
                thing.shrooming = false;
                stages.length = 0;
                thing.FSM.addClass(thing, "large");
                thing.FSM.removeClasses(thing, "shrooming shrooming3");
                thing.FSM.thingResumeVelocity(thing);
                return true;
            });
            thing.FSM.TimeHandler.addClassCycle(thing, stages, "shrooming", 6);
        };
        /**
         * Sizing modifier for the player, typically called when going down to
         * normal size after being large. This containst eha nimation scheduling
         * to cycle through paddling classes, then flickers the player. The mod
         * event is fired.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.playerGetsSmall = function (thing) {
            var bottom = thing.bottom;
            thing.FSM.thingPauseVelocity(thing);
            // Step one
            thing.nocollidechar = true;
            thing.FSM.animateFlicker(thing);
            thing.FSM.removeClasses(thing, "running skidding jumping fiery");
            thing.FSM.addClasses(thing, "paddling small");
            // Step two (t+21)
            thing.FSM.TimeHandler.addEvent(function (thing) {
                thing.FSM.removeClass(thing, "large");
                thing.FSM.setPlayerSizeSmall(thing);
                thing.FSM.setBottom(thing, bottom - FullScreenMario.unitsize);
            }, 21, thing);
            // Step three (t+42)
            thing.FSM.TimeHandler.addEvent(function (thing) {
                thing.FSM.thingResumeVelocity(thing, false);
                thing.FSM.removeClass(thing, "paddling");
                if (thing.running || thing.xvel) {
                    thing.FSM.addClass(thing, "running");
                }
                thing.FSM.PixelDrawer.setThingSprite(thing);
            }, 42, thing);
            // Step four (t+70)
            thing.FSM.TimeHandler.addEvent(function (thing) {
                thing.nocollidechar = false;
            }, 70, thing);
            thing.FSM.ModAttacher.fireEvent("onPlayerGetsSmall");
        };
        /**
         * Visual changer for when the player collides with a FireFlower. The
         * "fiery" class is added, and the mod event is fired.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.playerGetsFire = function (thing) {
            thing.shrooming = false;
            if (!thing.star) {
                thing.FSM.addClass(thing, "fiery");
            }
            thing.FSM.ModAttacher.fireEvent("onPlayerGetsFire");
        };
        /**
         * Actually sets the size for a player to small (8x8) via setSize and
         * updateSize.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.setPlayerSizeSmall = function (thing) {
            thing.FSM.setSize(thing, 8, 8, true);
            thing.FSM.updateSize(thing);
        };
        /**
         * Actually sets the size for a player to large (8x16) via setSize and
         * updateSize.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.setPlayerSizeLarge = function (thing) {
            thing.FSM.setSize(thing, 8, 16, true);
            thing.FSM.updateSize(thing);
        };
        /**
         * Removes the crouching flag from the player and re-adds the running cycle.
         * If the player is large (has power > 1), size and classes must be set.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerRemoveCrouch = function (thing) {
            thing.crouching = false;
            thing.toly = thing.tolyOld || 0;
            if (thing.power !== 1) {
                thing.FSM.setHeight(thing, 16, true, true);
                thing.FSM.removeClasses(thing, "crouching");
                thing.FSM.updateBottom(thing, 0);
                thing.FSM.updateSize(thing);
            }
            thing.FSM.animatePlayerRunningCycle(thing);
        };
        /**
         * Officially unattaches a player from a solid. The thing's physics flags
         * are reset to normal, the two have their attachment flags set, and the
         * thing is set to be jumping off.
         *
         * @param {Player} thing   A character attached to other.
         * @param {Solid} other   A solid the thing is attached to.
         */
        FullScreenMario.prototype.unattachPlayer = function (thing, other) {
            thing.nofall = false;
            thing.nocollide = false;
            thing.checkOverlaps = true;
            thing.attachedSolid = undefined;
            thing.xvel = thing.keys ? thing.keys.run : 0;
            thing.movement = thing.FSM.movePlayer;
            thing.FSM.addClass(thing, "jumping");
            thing.FSM.removeClasses(thing, "climbing", "animated");
            other.attachedCharacter = undefined;
        };
        /**
         * Adds an invisible RestingStone underneath the player. It is hidden and
         * unable to collide until the player falls to its level, at which point the
         * stone is set underneath the player to be rested upon.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.playerAddRestingStone = function (thing) {
            var stone = thing.FSM.addThing("RestingStone", thing.left, thing.top + thing.FSM.unitsize * 48);
            thing.nocollide = true;
            thing.FSM.TimeHandler.addEventInterval(function () {
                if (thing.bottom < stone.top) {
                    return false;
                }
                thing.nocollide = false;
                thing.FSM.setMidXObj(stone, thing);
                thing.FSM.setBottom(thing, stone.top);
                return true;
            }, 1, Infinity);
        };
        /**
         * Marks a new overlapping Thing in the first Thing's overlaps Array,
         * creating the Array if needed.
         *
         * @param {Thing} thing   The Thing that is overlapping another Thing.
         * @param {Thing} other   The Thing being added to the overlaps Array.
         */
        FullScreenMario.prototype.markOverlap = function (thing, other) {
            if (!thing.overlaps) {
                thing.overlaps = [other];
            }
            else {
                thing.overlaps.push(other);
            }
        };
        /* Spawn / activate functions
        */
        /**
         * Spawn callback for DeadGoombas. They simply disappear after 21 steps.
         *
         * @param {DeadGoomba} thing
         */
        FullScreenMario.prototype.spawnDeadGoomba = function (thing) {
            thing.FSM.TimeHandler.addEvent(FullScreenMario.prototype.killNormal, 21, thing);
        };
        /**
         * Spawn callback for HammerBros. Gravity is reduced, and the hammer and
         * jump event intervals are started. The cyclical movement counter is set to
         * 0.
         *
         * @param {HammerBro} thing
         */
        FullScreenMario.prototype.spawnHammerBro = function (thing) {
            thing.counter = 0;
            thing.gravity = thing.FSM.MapScreener.gravity / 2.1;
            thing.FSM.TimeHandler.addEvent(thing.FSM.animateThrowingHammer, 35, thing, 7);
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.animateJump, 140, Infinity, thing);
        };
        /**
         * Spawn callback for Bowsers. The cyclical movement counter is set to 0 and
         * the firing and jumping event intervals are started. If it also specifies
         * a throwing interval, that's started too.
         *
         * @param {Bowser} thing
         */
        FullScreenMario.prototype.spawnBowser = function (thing) {
            var i;
            thing.counter = 0;
            thing.deathcount = 0;
            for (i = 0; i < thing.fireTimes.length; i += 1) {
                thing.FSM.TimeHandler.addEventInterval(thing.FSM.animateBowserFire, thing.fireTimes[i], Infinity, thing);
            }
            for (i = 0; i < thing.jumpTimes.length; i += 1) {
                thing.FSM.TimeHandler.addEventInterval(thing.FSM.animateBowserJump, thing.jumpTimes[i], Infinity, thing);
            }
            if (thing.throwing) {
                for (i = 0; i < thing.throwAmount; i += 1) {
                    thing.FSM.TimeHandler.addEvent(function () {
                        thing.FSM.TimeHandler.addEventInterval(thing.FSM.animateBowserThrow, thing.throwPeriod, Infinity, thing);
                    }, thing.throwDelay + i * thing.throwBetween);
                }
            }
        };
        /**
         * Spawn callback for Piranhas. The movement counter and direction are
         * reset, and if the Piranha is on a pipe, it has a reduced height (6).
         *
         * @param {Piranha} thing
         */
        FullScreenMario.prototype.spawnPiranha = function (thing) {
            var bottom;
            thing.counter = 0;
            thing.direction = thing.FSM.unitsize / -40;
            if (thing.onPipe) {
                bottom = thing.bottom;
                thing.FSM.setHeight(thing, 6);
                thing.FSM.setBottom(thing, bottom);
            }
        };
        /**
         * Spawn callback for Bloopers. Its squeeze and movement counters are set to
         * 0.
         *
         * @param {Blooper} thing
         */
        FullScreenMario.prototype.spawnBlooper = function (thing) {
            thing.squeeze = 0;
            thing.counter = 0;
        };
        /**
         * Spawn callback for Podoboos. The jumping interval is set to the Thing's
         * frequency.
         *
         * @param {Podoboo} thing
         */
        FullScreenMario.prototype.spawnPodoboo = function (thing) {
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.animatePodobooJumpUp, thing.frequency, Infinity, thing);
        };
        /**
         * Spawn callback for Lakitus. MapScreenr registers the most recently
         * added lakitu, as some areas spawn them every once in a while.
         *
         * @param {Lakitu} thing
         */
        FullScreenMario.prototype.spawnLakitu = function (thing) {
            thing.FSM.MapScreener.lakitu = thing;
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.animateLakituThrowingSpiny, 140, Infinity, thing);
        };
        /**
         * Spawning callback for Cannons. Unless specified by the noBullets flag,
         * the firing interval is set to the Thing's frequency.
         *
         * @param {Cannon} thing
         */
        FullScreenMario.prototype.spawnCannon = function (thing) {
            if (thing.noBullets) {
                return;
            }
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.animateCannonFiring, thing.frequency, thing.frequency, thing);
        };
        /**
         * Spawning callback for CastleBlocks. If the Thing has fireballs, an Array
         * of them are made and animated to tick around the block like a clock, set
         * by the thing's speed and direction.
         *
         * @param {CastleBlock} thing
         */
        FullScreenMario.prototype.spawnCastleBlock = function (thing) {
            if (!thing.fireballs) {
                return;
            }
            var balls = [], i;
            for (i = 0; i < thing.fireballs; i += 1) {
                balls.push(thing.FSM.addThing("CastleFireball"));
                thing.FSM.setMidObj(balls[i], thing);
            }
            if (thing.speed >= 0) {
                thing.dt = 0.07;
                thing.angle = 0.25;
            }
            else {
                thing.dt = -0.07;
                thing.angle = -0.25;
            }
            if (!thing.direction) {
                thing.direction = -1;
            }
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.animateCastleBlock, Math.round(7 / Math.abs(thing.speed)), Infinity, thing, balls);
        };
        /**
         * Spawning callback for floating Things, such as Koopas and Platforms. The
         * Thing's begin and end attributes are set relative to the MapScreener's
         * floor, so its movement can handle cycling between the two.
         *
         * @param {Thing} thing
         */
        FullScreenMario.prototype.spawnMoveFloating = function (thing) {
            // Make sure thing.begin <= thing.end
            thing.FSM.setMovementEndpoints(thing);
            // Make thing.begin and thing.end relative to the area's floor
            thing.begin = (thing.FSM.MapScreener.floor
                * thing.FSM.unitsize - thing.begin);
            thing.end = (thing.FSM.MapScreener.floor
                * thing.FSM.unitsize - thing.end);
        };
        /**
         * Spawning callback for sliding Things, such as Platforms. The Thing's
         * begin and end attributes do not need to be relative to anything.
         *
         * @param {Thing} thing
         */
        FullScreenMario.prototype.spawnMoveSliding = function (thing) {
            // Make sure thing.begin <= thing.end
            thing.FSM.setMovementEndpoints(thing);
        };
        /**
         * Spawning callback for a Platform that's a part of a Scale. ???
         *
         * @param {Platform} thing
         */
        FullScreenMario.prototype.spawnScalePlatform = function (thing) {
            var collection = thing.collection || {}, ownKey = thing.collectionKey === "platformLeft" ? "Left" : "Right", partnerKey = ownKey === "Left" ? "Right" : "Left";
            thing.partners = {
                "ownString": collection["string" + ownKey],
                "partnerString": collection["string" + partnerKey],
                "partnerPlatform": collection["platform" + partnerKey]
            };
        };
        /**
         * Generator callback to create a random CheepCheep. The spawn is given a
         * random x-velocity, is placed at a random point just below the screen, and
         * is oriented towards the player.
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.spawnRandomCheep = function (FSM) {
            if (!FSM.MapScreener.spawningCheeps) {
                return true;
            }
            var spawn;
            spawn = FSM.ObjectMaker.make("CheepCheep", {
                "flying": true,
                "xvel": FSM.NumberMaker.random() * FSM.unitsize * 1.4,
                "yvel": FSM.unitsize * -1.4
            });
            FSM.addThing(spawn, FSM.NumberMaker.random() * FSM.MapScreener.width, FSM.MapScreener.height);
            if (spawn.left < FSM.MapScreener.width / 2) {
                FSM.flipHoriz(spawn);
            }
            else {
                spawn.xvel *= -1;
            }
            return false;
        };
        /**
         * Generator callback to create a BulleBill. The spawn moves horizontally
         * at a constant rate towards the left side of the bill, and is placed at a
         * random point to the right side of the screen.
         *
         * @param {FullScreenMario} FSM
         * @return {Boolean} Whether the spawn cancelled (FSM.MapScreenr's
         *                   spawningBulletBills is false).
         */
        FullScreenMario.prototype.spawnRandomBulletBill = function (FSM) {
            if (!FSM.MapScreener.spawningBulletBills) {
                return true;
            }
            var spawn;
            spawn = FSM.ObjectMaker.make("BulletBill");
            spawn.direction = 1;
            spawn.moveleft = true;
            spawn.xvel *= -1;
            FSM.flipHoriz(spawn);
            FSM.addThing(spawn, FSM.MapScreener.width, Math.floor(FSM.NumberMaker.randomIntWithin(0, FSM.MapScreener.floor) / 8) * 8 * FSM.unitsize);
            return false;
        };
        /**
         * Spawns a CustomText by killing it and placing the contents of its texts
         * member variable. These are written with a determined amount of spacing
         * between them, as if by a typewriter.
         *
         * @param {CustomText} thing
         */
        FullScreenMario.prototype.spawnCustomText = function (thing) {
            var top = thing.top, texts = thing.texts, attributes = thing.textAttributes, spacingHorizontal = thing.spacingHorizontal * thing.FSM.unitsize, spacingVertical = thing.spacingVertical * thing.FSM.unitsize, spacingVerticalBlank = thing.spacingVerticalBlank * thing.FSM.unitsize, children = [], left, text, letter, textThing, i, j;
            thing.children = children;
            for (i = 0; i < texts.length; i += 1) {
                if (!texts[i]) {
                    top += spacingVerticalBlank;
                    continue;
                }
                text = texts[i].text;
                if (texts[i].offset) {
                    left = thing.left + texts[i].offset * thing.FSM.unitsize;
                }
                else {
                    left = thing.left;
                }
                for (j = 0; j < text.length; j += 1) {
                    letter = text[j];
                    if (thing.FSM.customTextMappings.hasOwnProperty(letter)) {
                        letter = thing.FSM.customTextMappings[letter];
                    }
                    letter = "Text" + thing.size + letter;
                    textThing = thing.FSM.ObjectMaker.make(letter, attributes);
                    textThing.FSM.addThing(textThing, left, top);
                    children.push(textThing);
                    left += textThing.width * thing.FSM.unitsize;
                    left += spacingHorizontal;
                }
                top += spacingVertical;
            }
            thing.FSM.killNormal(thing);
        };
        /**
         * Spawning callback for generic detectors, activated as soon as they are
         * placed. The Thing's activate trigger is called, then it is killed.
         *
         * @param {Detector} thing
         */
        FullScreenMario.prototype.spawnDetector = function (thing) {
            thing.activate(thing);
            thing.FSM.killNormal(thing);
        };
        /**
         * Spawning callback for ScrollBlockers. If the Thing is too the right of
         * the visible viewframe, it should limit scrolling when triggered.
         *
         * @param {ScrollBlocker} thing
         */
        FullScreenMario.prototype.spawnScrollBlocker = function (thing) {
            if (thing.FSM.MapScreener.width < thing.right) {
                thing.setEdge = true;
            }
        };
        /**
         * Used by Things in a collection to register themselves as a part of their
         * container collection Object. This is called by onThingMake, so they're
         * immediately put in the collection and have it as a member variable.
         *
         * @param {Object} collection   The collection Object shared by all members
         *                              of it. It should be automatically generated.
         * @param {Thing} thing   A member of the collection being spawned.
         * @remarks This should be bound in prethings as ".bind(scope, collection)"
         */
        FullScreenMario.prototype.spawnCollectionComponent = function (collection, thing) {
            thing.collection = collection;
            collection[thing.collectionName] = thing;
        };
        /**
         * Used by Things in a collection to get direct references to other Things
         * ("partners") in that collection. This is called by onThingAdd, so it's
         * always after spawnCollectionComponent (which is by onThingMake).
         *
         * @param {Object} collection   The collection Object shared by all members
         *                              of it. It should be automatically generated.
         * @param {Thing} thing   A member of the collection being spawned.
         * @remarks This should be bound in prethings as ".bind(scope, collection)"
         */
        FullScreenMario.prototype.spawnCollectionPartner = function (collection, thing) {
            var partnerNames = thing.collectionPartnerNames, partners = {}, name;
            for (name in partnerNames) {
                if (partnerNames.hasOwnProperty(name)) {
                    partners[name] = collection[partnerNames[name]];
                }
            }
            thing.partners = {};
        };
        /**
         * Spawning callback for RandomSpawner Things, which generate a set of
         * commands using the WorldSeeder to be piped into the MapsHandlr, then
         * spawn the immediate area.
         *
         * @param {RandomSpawner} thing
         */
        FullScreenMario.prototype.spawnRandomSpawner = function (thing) {
            var FSM = thing.FSM, left = (thing.left + FSM.MapScreener.left) / FSM.unitsize;
            FSM.WorldSeeder.clearGeneratedCommands();
            FSM.WorldSeeder.generateFull({
                "title": thing.randomization,
                "top": thing.randomTop,
                "right": left + thing.randomWidth,
                "bottom": thing.randomBottom,
                "left": left,
                "width": thing.randomWidth,
                "height": thing.randomTop - thing.randomBottom
            });
            FSM.WorldSeeder.runGeneratedCommands();
            FSM.MapsHandler.spawnMap("xInc", FSM.QuadsKeeper.top / FSM.unitsize, FSM.QuadsKeeper.right / FSM.unitsize, FSM.QuadsKeeper.bottom / FSM.unitsize, FSM.QuadsKeeper.left / FSM.unitsize);
        };
        /**
         * Activation callback for starting spawnRandomCheep on an interval.
         * MapScreener is notified that spawningCheeps is true.
         *
         * @param {Detector} thing
         */
        FullScreenMario.prototype.activateCheepsStart = function (thing) {
            thing.FSM.MapScreener.spawningCheeps = true;
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.spawnRandomCheep, 21, Infinity, thing.FSM);
        };
        /**
         * Activation callback to stop spawning CheepCheeps. MapScreener is notified
         * that spawningCheeps is false.
         *
         * @param {Detector} thing
         */
        FullScreenMario.prototype.activateCheepsStop = function (thing) {
            thing.FSM.MapScreener.spawningCheeps = false;
        };
        /**
         * Activation callback for starting spawnRandomBulletBill on an interval.
         * MapScreener is notified that spawningBulletBills is true.
         *
         * @param {Detector} thing
         */
        FullScreenMario.prototype.activateBulletBillsStart = function (thing) {
            thing.FSM.MapScreener.spawningBulletBills = true;
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.spawnRandomBulletBill, 210, Infinity, thing.FSM);
        };
        /**
         * Activation callback to stop spawning BulletBills. MapScreener is notified
         * that spawningBulletBills is false.
         *
         * @param {Detector} thing
         */
        FullScreenMario.prototype.activateBulletBillsStop = function (thing) {
            thing.FSM.MapScreener.spawningBulletBills = false;
        };
        /**
         * Activation callback to tell the area's Lakitu, if it exists, to start
         * fleeing the scene.
         *
         * @param {Detector} thing
         */
        FullScreenMario.prototype.activateLakituStop = function (thing) {
            var lakitu = thing.FSM.MapScreener.lakitu;
            if (!lakitu) {
                return;
            }
            lakitu.fleeing = true;
            lakitu.movement = thing.FSM.moveLakituFleeing;
        };
        /**
         * Activation callback for a warp world area, triggered by the player
         * touching a collider on top of it. Piranhas disappear and texts are
         * revealed.
         *
         * @param {Thing} player
         * @param {DetectCollision} other
         */
        FullScreenMario.prototype.activateWarpWorld = function (thing, other) {
            var collection = other.collection, key = 0, keyString, texts, j;
            if (!thing.player) {
                return;
            }
            texts = collection.Welcomer.children;
            for (j = 0; j < texts.length; j += 1) {
                if (texts[j].title !== "TextSpace") {
                    texts[j].hidden = false;
                }
            }
            while (true) {
                keyString = key + "-Text";
                if (!collection.hasOwnProperty(keyString)) {
                    break;
                }
                texts = collection[keyString].children;
                for (j = 0; j < texts.length; j += 1) {
                    if (texts[j].title !== "TextSpace") {
                        texts[j].hidden = false;
                    }
                }
                thing.FSM.killNormal(collection[key + "-Piranha"]);
                key += 1;
            }
        };
        /**
         * Activation callback for when the player lands on a RestingStone. The
         * stone "appears" (via opacity), the regular theme plays if it wasn't
         * already, and the RestingStone waits to kill itself when the player isn't
         * touching it.
         *
         * @param {RestingStone} thing
         * @param {Player} other
         */
        FullScreenMario.prototype.activateRestingStone = function (thing, other) {
            if (thing.activated) {
                return;
            }
            thing.activated = true;
            thing.opacity = 1;
            thing.FSM.AudioPlayer.playTheme();
            thing.FSM.TimeHandler.addEventInterval(function () {
                if (other.resting === thing) {
                    return false;
                }
                thing.FSM.killNormal(thing);
                return true;
            }, 1, Infinity);
        };
        /**
         * Generic activation callback for DetectWindow Things. This is typically
         * set as a .movement Function, so it waits until the calling Thing is
         * within the MapScreener's area to call the activate Function and kill
         * itself.
         *
         * @param {DetectWindow} thing
         */
        FullScreenMario.prototype.activateWindowDetector = function (thing) {
            if (thing.FSM.MapScreener.right - thing.FSM.MapScreener.left < thing.left) {
                return;
            }
            thing.activate(thing);
            thing.FSM.killNormal(thing);
        };
        /**
         * Activation callback for ScrollBlocker Things. These are WindowDetectors
         * that set MapScreener.canscroll to false when they're triggered. If the
         * latest scrollWindow call pushed it too far to the left, it scrolls back
         * the other way.
         *
         * @param {ScrollBlocker} thing
         */
        FullScreenMario.prototype.activateScrollBlocker = function (thing) {
            var dx = thing.FSM.MapScreener.width - thing.left;
            thing.FSM.MapScreener.canscroll = false;
            if (thing.setEdge && dx > 0) {
                thing.FSM.scrollWindow(-dx);
            }
        };
        /**
         * Activation callback for ScrollBlocker Things. These are DetectCollision
         * that set MapScreener.canscroll to true when they're triggered.
         *
         * @param {DetectCollision} thing
         */
        FullScreenMario.prototype.activateScrollEnabler = function (thing) {
            thing.FSM.MapScreener.canscroll = true;
        };
        /**
         * Activates the "before" component of a stretchable section. The creation
         * commands of the section are loaded onto the screen as is and a
         * DetectWindow is added to their immediate right that will trigger the
         * equivalent activateSectionStretch.
         *
         * @param {DetectWindow} thing
         */
        FullScreenMario.prototype.activateSectionBefore = function (thing) {
            var FSM = thing.FSM, MapsCreator = FSM.MapsCreator, MapScreener = FSM.MapScreener, MapsHandler = FSM.MapsHandler, area = MapsHandler.getArea(), map = MapsHandler.getMap(), prethings = MapsHandler.getPreThings(), section = area.sections[thing.section || 0], left = (thing.left + MapScreener.left) / FSM.unitsize, before = section.before ? section.before.creation : undefined, command, i;
            // If there is a before, parse each command into the prethings array
            if (before) {
                for (i = 0; i < before.length; i += 1) {
                    // A copy of the command must be used to not modify the original 
                    command = FSM.proliferate({}, before[i]);
                    // The command's x must be shifted by the thing's placement
                    if (!command.x) {
                        command.x = left;
                    }
                    else {
                        command.x += left;
                    }
                    // For Platforms that slide around, start and end are dynamic
                    if (command.sliding) {
                        command.begin += left;
                        command.end += left;
                    }
                    MapsCreator.analyzePreSwitch(command, prethings, area, map);
                }
            }
            // Add a prething at the end of all this to trigger the stretch part
            command = {
                "thing": "DetectWindow",
                "x": left + (before ? section.before.width : 0), "y": 0,
                "activate": FSM.activateSectionStretch,
                "section": thing.section || 0
            };
            MapsCreator.analyzePreSwitch(command, prethings, area, map);
            // Spawn new Things that should be placed for being nearby
            MapsHandler.spawnMap("xInc", MapScreener.top / FSM.unitsize, (MapScreener.left + FSM.QuadsKeeper.right) / FSM.unitsize, MapScreener.bottom / FSM.unitsize, left);
        };
        /**
         * Activates the "stretch" component of a stretchable section. The creation
         * commands of the section are loaded onto the screen and have their widths
         * set to take up the entire width of the screen. A DetectWindow is added
         * to their immediate right that will trigger the equivalent
         * activateSectionAfter.
         *
         * @param {DetectWindow} thing
         */
        FullScreenMario.prototype.activateSectionStretch = function (thing) {
            var FSM = thing.FSM, MapsCreator = FSM.MapsCreator, MapScreener = FSM.MapScreener, MapsHandler = FSM.MapsHandler, area = MapsHandler.getArea(), map = MapsHandler.getMap(), prethings = MapsHandler.getPreThings(), section = area.sections[thing.section || 0], stretch = section.stretch ? section.stretch.creation : undefined, left = (thing.left + MapScreener.left) / FSM.unitsize, width = MapScreener.width / FSM.unitsize, command, i;
            // If there is a stretch, parse each command into the current prethings array
            if (stretch) {
                for (i = 0; i < stretch.length; i += 1) {
                    // A copy of the command must be used, so the original isn't modified
                    command = FSM.proliferate({}, stretch[i]);
                    command.x = left;
                    // "stretch" the command by making its width equal to the screen
                    command.width = width;
                    MapsCreator.analyzePreSwitch(command, prethings, area, map);
                }
                // Add a prething at the end of all this to trigger the after part
                command = {
                    "thing": "DetectWindow",
                    "x": left + width,
                    "y": 0,
                    "activate": FSM.activateSectionAfter,
                    "section": thing.section || 0
                };
                MapsCreator.analyzePreSwitch(command, prethings, area, map);
            }
            // Spawn the map, so new Things that should be placed will be spawned if nearby
            MapsHandler.spawnMap("xInc", MapScreener.top / FSM.unitsize, left + (MapScreener.width / FSM.unitsize), MapScreener.bottom / FSM.unitsize, left);
        };
        /**
         * Activates the "after" component of a stretchable sectin. The creation
         * commands of the stretch are loaded onto the screen as is.
         *
         * @param {DetectWindow} thing
         */
        FullScreenMario.prototype.activateSectionAfter = function (thing) {
            // Since the section was passed, do the rest of things normally
            var FSM = thing.FSM, MapsCreator = FSM.MapsCreator, MapScreener = FSM.MapScreener, MapsHandler = FSM.MapsHandler, area = MapsHandler.getArea(), map = MapsHandler.getMap(), prethings = MapsHandler.getPreThings(), section = area.sections[thing.section || 0], left = (thing.left + MapScreener.left) / FSM.unitsize, after = section.after ? section.after.creation : undefined, command, i;
            // If there is an after, parse each command into the current prethings array
            if (after) {
                for (i = 0; i < after.length; i += 1) {
                    // A copy of the command must be used, so the original isn't modified
                    command = FSM.proliferate({}, after[i]);
                    // The command's x-location must be shifted by the thing's placement
                    if (!command.x) {
                        command.x = left;
                    }
                    else {
                        command.x += left;
                    }
                    // For Platforms that slide around, start and end are dynamic
                    if (command.sliding) {
                        command.begin += left;
                        command.end += left;
                    }
                    MapsCreator.analyzePreSwitch(command, prethings, area, map);
                }
            }
            // Spawn the map, so new Things that should be placed will be spawned if nearby
            MapsHandler.spawnMap("xInc", MapScreener.top / FSM.unitsize, left + (MapScreener.right / FSM.unitsize), MapScreener.bottom / FSM.unitsize, left);
        };
        /* Collision functions
        */
        /**
         * Function generator for the generic hitCharacterSolid callback. This is
         * used repeatedly by ThingHittr to generate separately optimized Functions
         * for different Thing types.
         *
         * @return {Function}
         */
        FullScreenMario.prototype.generateHitCharacterSolid = function () {
            /**
             * Generic callback for when a character touches a solid. Solids that
             * "up" kill anything that didn't cause the up, but otherwise this will
             * normally involve the solid's collide callback being called and
             * under/undermid checks activating.
             *
             * @param {Character} thing
             * @param {Solid} other
             */
            return function hitCharacterSolid(thing, other) {
                // "Up" solids are special (they kill things that aren't their .up)
                if (other.up && thing !== other.up) {
                    return thing.FSM.collideCharacterSolidUp(thing, other);
                }
                other.collide(thing, other);
                // If a character is bumping into the bottom, call that
                if (thing.undermid) {
                    if (thing.undermid.bottomBump) {
                        thing.undermid.bottomBump(thing.undermid, thing);
                    }
                }
                else if (thing.under && thing.under && thing.under.bottomBump) {
                    thing.under.bottomBump(thing.under[0], thing);
                }
                // If the character is overlapping the solid, call that too
                if (thing.checkOverlaps
                    && thing.FSM.isCharacterOverlappingSolid(thing, other)) {
                    thing.FSM.markOverlap(thing, other);
                }
            };
        };
        /**
         * Function generator for the generic hitCharacterCharacter callback. This
         * is used repeatedly by ThingHittr to generate separately optimized
         * Functions for different Thing types.
         *
         * @return {Function}
         */
        FullScreenMario.prototype.generateHitCharacterCharacter = function () {
            /**
             * Generic callback for when a character touches another character. The
             * first Thing's collide callback is called unless it's a player, in
             * which the other Thing's is.
             *
             * @param {Character} thing
             * @param {Character} other
             */
            return function hitCharacterCharacter(thing, other) {
                // The player calls the other's collide function, such as playerStar
                if (thing.player) {
                    if (other.collide) {
                        return other.collide(thing, other);
                    }
                }
                else if (thing.collide) {
                    // Otherwise just use thing's collide function
                    thing.collide(other, thing);
                }
            };
        };
        /**
         * Collision callback used by most Items. The item's action callback will
         * be called only if the first Thing is a player.
         *
         * @param {Thing} thing
         * @param {Item} other
         */
        FullScreenMario.prototype.collideFriendly = function (thing, other) {
            if (!thing.player || !thing.FSM.isThingAlive(other)) {
                return;
            }
            if (other.action) {
                other.action(thing, other);
            }
            other.death(other);
        };
        /**
         * General callback for when a character touches a solid. This mostly
         * determines if the character is on top (it should rest on the solid), to
         * the side (it should shouldn't overlap), or undernearth (it also shouldn't
         * overlap).
         *
         * @param {Character} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.collideCharacterSolid = function (thing, other) {
            if (other.up === thing) {
                return;
            }
            // Character on top of solid
            if (thing.FSM.isCharacterOnSolid(thing, other)) {
                if (other.hidden && !other.collideHidden) {
                    return;
                }
                if (thing.resting !== other) {
                    thing.resting = other;
                    if (thing.onResting) {
                        thing.onResting(thing, other);
                    }
                    if (other.onRestedUpon) {
                        other.onRestedUpon(other, thing);
                    }
                }
            }
            else if (thing.FSM.isSolidOnCharacter(other, thing)) {
                // Solid on top of character
                var midx = thing.FSM.getMidX(thing);
                if (midx > other.left && midx < other.right) {
                    thing.undermid = other;
                }
                else if (other.hidden && !other.collideHidden) {
                    return;
                }
                if (!thing.under) {
                    thing.under = [other];
                }
                else {
                    thing.under.push(other);
                }
                if (thing.player) {
                    thing.keys.jump = false;
                    thing.FSM.setTop(thing, other.bottom - thing.toly + other.yvel);
                }
                thing.yvel = other.yvel;
            }
            if (other.hidden && !other.collideHidden) {
                return;
            }
            // Character bumping into the side of the solid
            if (thing.resting !== other
                && !thing.FSM.isCharacterBumpingSolid(thing, other)
                && !thing.FSM.isThingOnThing(thing, other)
                && !thing.FSM.isThingOnThing(other, thing)
                && !thing.under) {
                // Character to the left of the solid
                if (thing.right <= other.right) {
                    thing.xvel = Math.min(thing.xvel, 0);
                    thing.FSM.shiftHoriz(thing, Math.max(other.left + thing.FSM.unitsize - thing.right, thing.FSM.unitsize / -2));
                }
                else {
                    // Character to the right of the solid
                    thing.xvel = Math.max(thing.xvel, 0);
                    thing.FSM.shiftHoriz(thing, Math.min(other.right - thing.FSM.unitsize - thing.left, thing.FSM.unitsize / 2));
                }
                // Non-players flip horizontally
                if (!thing.player) {
                    if (!thing.noflip) {
                        thing.moveleft = !thing.moveleft;
                    }
                    // Some items require fancy versions (e.g. Shell)
                    if (thing.group === "item") {
                        thing.collide(other, thing);
                    }
                }
                else if (other.actionLeft) {
                    // Players trigger other actions (e.g. Pipe's mapExitPipeHorizontal)
                    thing.FSM.ModAttacher.fireEvent("onPlayerActionLeft", thing, other);
                    other.actionLeft(thing, other, other.transport);
                }
            }
        };
        /**
         * Collision callback for a character hitting an "up" solid. If it has an
         * onCollideUp callback, that is called; otherwise, it is killed.
         *
         * @param {Character} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.collideCharacterSolidUp = function (thing, other) {
            if (thing.onCollideUp) {
                thing.onCollideUp(thing, other);
            }
            else {
                thing.FSM.scoreOn(thing.scoreBelow, thing);
                thing.death(thing, 2);
            }
        };
        /**
         * Collision callback for an item hitting an "up" solid. Items just hop
         * and switch direction.
         *
         * @param {Item} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.collideUpItem = function (thing, other) {
            thing.FSM.animateCharacterHop(thing);
            thing.moveleft = thing.FSM.objectToLeft(thing, other);
        };
        /**
         * Collision callback for a floating coin being hit by an "up" solid. It is
         * animated, as if it were hit as the contents of a solid.
         *
         * @param {Coin} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.collideUpCoin = function (thing, other) {
            thing.blockparent = other;
            thing.animate(thing, other);
        };
        /**
         * Collision callback for a player hitting a regular Coin. The Coin
         * disappears but points and Coin totals are both increased, along with
         * the "Coin" sound being played.
         *
         * @param {Player} thing
         * @param {Coin} other
         */
        FullScreenMario.prototype.collideCoin = function (thing, other) {
            if (!thing.player) {
                return;
            }
            thing.FSM.AudioPlayer.play("Coin");
            thing.FSM.ItemsHolder.increase("score", 200);
            thing.FSM.ItemsHolder.increase("coins", 1);
            thing.FSM.killNormal(other);
        };
        /**
         * Collision callback for a player hitting a Star. The Star is killed, and
         * the playerStarUp trigger is called on the Thing.
         *
         * @param {Player} thing
         * @param {Star} other
         */
        FullScreenMario.prototype.collideStar = function (thing, other) {
            if (!thing.player || thing.star) {
                return;
            }
            thing.FSM.playerStarUp(thing);
            thing.FSM.ModAttacher.fireEvent("onCollideStar", thing, other);
        };
        /**
         * Collision callback for a character being hit by a fireball. It will
         * most likely be killed with an explosion unless it has the nofiredeath
         * flag, in which case only the fireball dies.
         *
         * @param {Character} thing
         * @param {Fireball} other
         */
        FullScreenMario.prototype.collideFireball = function (thing, other) {
            if (!thing.FSM.isThingAlive(thing)
                || thing.height < thing.FSM.unitsize) {
                return;
            }
            if (thing.nofire) {
                if (thing.nofire > 1) {
                    other.death(other);
                }
                return;
            }
            if (thing.nofiredeath) {
                thing.FSM.AudioPlayer.playLocal("Bump", thing.FSM.getMidX(other));
                thing.death(thing);
            }
            else {
                thing.FSM.AudioPlayer.playLocal("Kick", thing.FSM.getMidX(other));
                thing.death(thing, 2);
                thing.FSM.scoreOn(thing.scoreFire, thing);
            }
            other.death(other);
        };
        /**
         * Collision callback for hitting a CastleFireball. The character is killed
         * unless it has the star flag, in which case the CastleFireball is.
         *
         * @param {Character} thing
         * @param {CastleFireball} other
         */
        FullScreenMario.prototype.collideCastleFireball = function (thing, other) {
            if (thing.star) {
                other.death(other);
            }
            else {
                thing.death(thing);
            }
        };
        /**
         * Collision callback for when a character hits a Shell. This covers various
         * cases, such as deaths, side-to-side Shell collisions, player stomps, and
         * so on.
         *
         * @param {Character} thing
         * @param {Shell} other
         */
        FullScreenMario.prototype.collideShell = function (thing, other) {
            // If only one is a shell, it should be other, not thing
            if (thing.shell) {
                if (other.shell) {
                    return thing.FSM.collideShellShell(thing, other);
                }
                return thing.FSM.collideShell(thing, other);
            }
            // Hitting a solid (e.g. wall) 
            if (thing.groupType === "Solid") {
                return thing.FSM.collideShellSolid(thing, other);
            }
            // Hitting the player
            if (thing.player) {
                return thing.FSM.collideShellPlayer(thing, other);
            }
            // Assume anything else to be an enemy, which only moving shells kill
            if (other.xvel) {
                thing.FSM.killFlip(thing);
                if (thing.shellspawn) {
                    thing = thing.FSM.killSpawn(thing);
                }
                thing.FSM.AudioPlayer.play("Kick");
                thing.FSM.scoreOn(thing.FSM.findScore(other.enemyhitcount), thing);
                other.enemyhitcount += 1;
            }
            else {
                thing.moveleft = thing.FSM.objectToLeft(thing, other);
            }
        };
        /**
         * Collision callback for a solid being hit by a Shell. The Shell will
         * bounce the opposition direction.
         *
         * @param {Solid} thing
         * @param {Shell} other
         */
        FullScreenMario.prototype.collideShellSolid = function (thing, other) {
            if (other.right < thing.right) {
                thing.FSM.AudioPlayer.playLocal("Bump", thing.left);
                thing.FSM.setRight(other, thing.left);
                other.xvel = -other.speed;
                other.moveleft = true;
            }
            else {
                thing.FSM.AudioPlayer.playLocal("Bump", thing.right);
                thing.FSM.setLeft(other, thing.right);
                other.xvel = other.speed;
                other.moveleft = false;
            }
        };
        /**
         * Collision callback for when the player hits a Shell. This covers all the
         * possible scenarios, and is much larger than common sense dictates.
         *
         * @param {Player} thing
         * @param {Shell} other
         */
        FullScreenMario.prototype.collideShellPlayer = function (thing, other) {
            var shelltoleft = thing.FSM.objectToLeft(other, thing), playerjump = thing.yvel > 0 && (thing.bottom <= other.top + thing.FSM.unitsize * 2);
            // Star players kill the shell no matter what
            if (thing.star) {
                thing.FSM.scorePlayerShell(thing, other);
                other.death(other, 2);
                return;
            }
            // If the shell is already being landed on by the player, see if it's
            // still being pushed to the side, or has reversed direction (is deadly)
            if (other.landing) {
                // Equal shelltoleft measurements: it's still being pushed
                if (other.shelltoleft === shelltoleft) {
                    // Tepmorarily increase the landing count of the shell; if it is 
                    // just being started, that counts as the score hit
                    other.landing += 1;
                    if (other.landing === 1) {
                        thing.FSM.scorePlayerShell(thing, other);
                    }
                    thing.FSM.TimeHandler.addEvent(function (other) {
                        other.landing -= 1;
                    }, 2, other);
                }
                else {
                    // Different shelltoleft measurements: it's deadly
                    thing.death(thing);
                }
                return;
            }
            // If the shell is being kicked by the player, either by hitting a still
            // shell or jumping onto an already moving one
            if (other.xvel === 0 || playerjump) {
                // Reset any signs of peeking from the shell
                other.counting = 0;
                // If the shell is standing still, make it move
                if (other.xvel === 0) {
                    thing.FSM.AudioPlayer.play("Kick");
                    thing.FSM.scorePlayerShell(thing, other);
                    if (shelltoleft) {
                        other.moveleft = true;
                        other.xvel = -other.speed;
                    }
                    else {
                        other.moveleft = false;
                        other.xvel = other.speed;
                    }
                    other.hitcount += 1;
                    thing.FSM.TimeHandler.addEvent(function (other) {
                        other.hitcount -= 1;
                    }, 2, other);
                }
                else {
                    // Otherwise it was moving, but should now be still
                    other.xvel = 0;
                }
                if (other.peeking) {
                    other.peeking = 0;
                    thing.FSM.removeClass(other, "peeking");
                    other.height -= thing.FSM.unitsize / 8;
                    thing.FSM.updateSize(other);
                }
                // If the player is landing on the shell (with movements and xvels
                // already set), the player should then jump up a bit
                if (playerjump) {
                    thing.FSM.AudioPlayer.play("Kick");
                    if (!other.xvel) {
                        thing.FSM.jumpEnemy(thing, other);
                        thing.yvel *= 2;
                        // thing.FSM.scorePlayerShell(thing, other);
                        thing.FSM.setBottom(thing, other.top - thing.FSM.unitsize);
                    }
                    else {
                    }
                    other.landing += 1;
                    other.shelltoleft = shelltoleft;
                    thing.FSM.TimeHandler.addEvent(function (other) {
                        other.landing -= 1;
                    }, 2, other);
                }
            }
            else {
                // Since the player is touching the shell normally, that's a death if
                // the shell isn't moving away
                if (!other.hitcount && ((shelltoleft && other.xvel > 0)
                    || (!shelltoleft && other.xvel < 0))) {
                    thing.death(thing);
                }
            }
        };
        /**
         * Collision callback for two Shells. If one is moving, it kills the other;
         * otherwise, they bounce off.
         *
         * @param {Shell} thing
         * @param {Shell} other
         */
        FullScreenMario.prototype.collideShellShell = function (thing, other) {
            if (thing.xvel !== 0) {
                if (other.xvel !== 0) {
                    var temp = thing.xvel;
                    thing.xvel = other.xvel;
                    other.xvel = temp;
                    thing.FSM.shiftHoriz(thing, thing.xvel);
                    thing.FSM.shiftHoriz(other, other.xvel);
                }
                else {
                    thing.FSM.ItemsHolder.increase("score", 500);
                    other.death(other);
                }
            }
            else {
                thing.FSM.ItemsHolder.increase("score", 500);
                thing.death(thing);
            }
        };
        /**
         * Collision callback for a general character hitting an enemy. This covers
         * many general cases, most of which involve a player and an enemy.
         *
         * @param {Character} thing
         * @param {Enemy} other
         */
        FullScreenMario.prototype.collideEnemy = function (thing, other) {
            // If either is a player, make it thing (not other)
            if (!thing.player && other.player) {
                return thing.FSM.collideEnemy(thing, other);
            }
            // Death: nothing happens
            if (!thing.FSM.isThingAlive(thing)
                || !thing.FSM.isThingAlive(other)) {
                return;
            }
            // Items
            if (thing.group === "item") {
                if (thing.collidePrimary) {
                    return thing.collide(other, thing);
                }
                return;
            }
            // For non-players, it's just to characters colliding: they bounce
            if (!thing.player) {
                thing.moveleft = thing.FSM.objectToLeft(thing, other);
                other.moveleft = !thing.moveleft;
                return;
            }
            // Player landing on top of an enemy
            if ((thing.star && !other.nostar)
                || (!thing.FSM.MapScreener.underwater
                    && (!other.deadly && thing.FSM.isThingOnThing(thing, other)))) {
                // For the sake of typing. Should be optimized during runtime.
                var player = thing;
                // Enforces toly (not touching means stop)
                if (player.FSM.isCharacterAboveEnemy(player, other)) {
                    return;
                }
                // A star player just kills the enemy, no matter what
                if (player.star) {
                    other.nocollide = true;
                    other.death(other, 2);
                    player.FSM.scoreOn(other.scoreStar, other);
                    player.FSM.AudioPlayer.play("Kick");
                }
                else {
                    // A non-star player kills the enemy with spawn, and hops
                    player.FSM.setBottom(player, Math.min(player.bottom, other.top + player.FSM.unitsize));
                    player.FSM.TimeHandler.addEvent(player.FSM.jumpEnemy, 0, player, other);
                    other.death(other, player.star ? 2 : 0);
                    player.FSM.addClass(player, "hopping");
                    player.FSM.removeClasses(player, "running skidding jumping one two three");
                    player.hopping = true;
                    if (player.power === 1) {
                        player.FSM.setPlayerSizeSmall(player);
                    }
                }
            }
            else if (!thing.FSM.isCharacterAboveEnemy(thing, other)) {
                // Player being landed on by an enemy
                thing.death(thing);
            }
        };
        /**
         * Collision callback for a character bumping into the bottom of a solid.
         * Only players cause the solid to jump and be considered "up", though large
         * players will kill solids that have the breakable flag on. If the solid
         * does jump and has contents, they emerge.
         *
         * @param {Solid} thing
         * @param {Character} other
         */
        FullScreenMario.prototype.collideBottomBrick = function (thing, other) {
            if (other.solid && !thing.solid) {
                return thing.FSM.collideBottomBrick(other, thing);
            }
            if (thing.up || !other.player) {
                return;
            }
            thing.FSM.AudioPlayer.play("Bump");
            if (thing.used) {
                return;
            }
            thing.up = other;
            if (other.power > 1 && thing.breakable && !thing.contents) {
                thing.FSM.TimeHandler.addEvent(thing.FSM.killBrick, 2, thing, other);
                return;
            }
            thing.FSM.animateSolidBump(thing);
            if (thing.contents) {
                thing.FSM.TimeHandler.addEvent(function () {
                    thing.FSM.animateSolidContents(thing, other);
                    if (thing.contents !== "Coin") {
                        thing.FSM.animateBlockBecomesUsed(thing);
                    }
                    else {
                        if (thing.lastcoin) {
                            thing.FSM.animateBlockBecomesUsed(thing);
                        }
                        else {
                            thing.FSM.TimeHandler.addEvent(function () {
                                thing.lastcoin = true;
                            }, 245);
                        }
                    }
                }, 7);
            }
        };
        /**
         * Collision callback for the player hitting the bottom of a Block. Unused
         * Blocks have their contents emerge (by default a Coin), while used Blocks
         * just have a small bump noise played.
         *
         * @param {Solid} thing
         * @param {Player} other
         */
        FullScreenMario.prototype.collideBottomBlock = function (thing, other) {
            if (other.solid && !thing.solid) {
                return thing.FSM.collideBottomBlock(other, thing);
            }
            if (thing.up || !other.player) {
                return;
            }
            if (thing.used) {
                thing.FSM.AudioPlayer.play("Bump");
                return;
            }
            thing.used = true;
            thing.hidden = false;
            thing.up = other;
            thing.FSM.animateSolidBump(thing);
            thing.FSM.removeClass(thing, "hidden");
            thing.FSM.switchClass(thing, "unused", "used");
            thing.FSM.TimeHandler.addEvent(thing.FSM.animateSolidContents, 7, thing, other);
        };
        /**
         * Collision callback for Vines. The player becomes "attached" to the Vine
         * and starts climbing it, with movement set to movePlayerVine.
         *
         * @param {Player} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.collideVine = function (thing, other) {
            if (!thing.player || thing.attachedSolid || thing.climbing) {
                return;
            }
            if (thing.bottom > other.bottom + thing.FSM.unitsize * 2) {
                return;
            }
            other.attachedCharacter = thing;
            thing.attachedSolid = other;
            thing.nofall = true;
            thing.checkOverlaps = false;
            thing.resting = undefined;
            // To the left of the vine
            if (thing.right < other.right) {
                thing.lookleft = false;
                thing.moveleft = false;
                thing.attachedDirection = -1;
                thing.FSM.unflipHoriz(thing);
            }
            else {
                // To the right of the vine
                thing.lookleft = true;
                thing.moveleft = true;
                thing.attachedDirection = 1;
                thing.FSM.flipHoriz(thing);
            }
            thing.FSM.thingPauseVelocity(thing);
            thing.FSM.addClass(thing, "climbing");
            thing.FSM.removeClasses(thing, "running", "jumping", "skidding");
            thing.FSM.TimeHandler.cancelClassCycle(thing, "running");
            thing.FSM.TimeHandler.addClassCycle(thing, ["one", "two"], "climbing", 0);
            thing.attachedLeft = !thing.FSM.objectToLeft(thing, other);
            thing.attachedOff = thing.attachedLeft ? 1 : -1;
            thing.movement = thing.FSM.movePlayerVine;
        };
        /**
         * Collision callback for a character hitting a Springboard. This acts as a
         * normal solid to non-players, and only acts as a spring if the player is
         * above it and moving down.
         *
         * @param {Character} thing
         * @param {Springboard} other
         */
        FullScreenMario.prototype.collideSpringboard = function (thing, other) {
            if (thing.player && thing.yvel >= 0 && !other.tension
                && thing.FSM.isCharacterOnSolid(thing, other)) {
                other.tension = other.tensionSave = Math.max(thing.yvel * 0.77, thing.FSM.unitsize);
                thing.movement = thing.FSM.movePlayerSpringboardDown;
                thing.spring = other;
                thing.xvel /= 2.8;
            }
            else {
                thing.FSM.collideCharacterSolid(thing, other);
            }
        };
        /**
         * Collision callback for a character hitting a WaterBlocker on the top of
         * an underwater area. It simply stops them from moving up.
         *
         * @param {Character} thing
         * @param {WaterBlocker} other
         */
        FullScreenMario.prototype.collideWaterBlocker = function (thing, other) {
            thing.FSM.collideCharacterSolid(thing, other);
        };
        /**
         * Collision callback for the DetectCollision on a flagpole at the end of an
         * EndOutsideCastle. The Flagpole cutscene is started.
         *
         * @param {Player} thing
         * @param {DetectCollision} other
         */
        FullScreenMario.prototype.collideFlagpole = function (thing, other) {
            if (thing.bottom > other.bottom) {
                return;
            }
            thing.FSM.ScenePlayer.startCutscene("Flagpole", {
                "player": thing,
                "collider": other
            });
        };
        /**
         * Collision callback for the player hitting a CastleAxe. The player and
         * screen are paused for 140 steps (other callbacks should be animating
         * the custcene).
         *
         * @param {Player} thing
         * @param {CastleAxe} other
         */
        FullScreenMario.prototype.collideCastleAxe = function (thing, other) {
            if (!thing.FSM.MathDecider.compute("canPlayerTouchCastleAxe", thing, other)) {
                return;
            }
            thing.FSM.ScenePlayer.startCutscene("BowserVictory", {
                "player": thing,
                "axe": other
            });
        };
        /**
         * Collision callback for a player hitting the DetectCollision placed next
         * a CastleDoor in EndOutsideCastle. Things and the current time are added
         * to cutscene settings. Infinite time goes directly to the Fireworks
         * routine, while having non-infinite time goes to the Countdown routine.
         *
         * @param {Player} thing
         * @param {DetectCollision} other
         */
        FullScreenMario.prototype.collideCastleDoor = function (thing, other) {
            thing.FSM.killNormal(thing);
            if (!thing.player) {
                return;
            }
            var time = thing.FSM.ItemsHolder.getItem("time");
            thing.FSM.ScenePlayer.addCutsceneSetting("player", thing);
            thing.FSM.ScenePlayer.addCutsceneSetting("detector", other);
            thing.FSM.ScenePlayer.addCutsceneSetting("time", time);
            if (time === Infinity) {
                thing.FSM.ScenePlayer.playRoutine("Fireworks");
            }
            else {
                thing.FSM.ScenePlayer.playRoutine("Countdown");
            }
        };
        /**
         * Collision callback for a player reaching a castle NPC. Things and
         * the NPC's keys are added to cutscene settings, and the Dialog routine
         * is played.
         *
         * @param {Player} thing
         * @param {DetectCollision} other
         */
        FullScreenMario.prototype.collideCastleNPC = function (thing, other) {
            var keys = other.collection.npc.collectionKeys;
            thing.FSM.ScenePlayer.addCutsceneSetting("keys", keys);
            thing.FSM.ScenePlayer.addCutsceneSetting("player", thing);
            thing.FSM.ScenePlayer.addCutsceneSetting("detector", other);
            thing.FSM.ScenePlayer.playRoutine("Dialog");
        };
        /**
         * Collision callback for a player hitting the transportation Platform in
         * cloud worlds. The player collides with it as normal for solids, but if
         * the player is then resting on it, it becomes a normal moving platform
         * with only horizontal momentum.
         *
         * @param {Player} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.collideTransport = function (thing, other) {
            if (!thing.player) {
                return;
            }
            thing.FSM.collideCharacterSolid(thing, other);
            if (thing.resting !== other) {
                return;
            }
            other.xvel = thing.FSM.unitsize / 2;
            other.movement = thing.FSM.movePlatform;
            other.collide = thing.FSM.collideCharacterSolid;
        };
        /**
         * General collision callback for DetectCollision Things. The real activate
         * callback is only hit if the Thing is a player; otherwise, an optional
         * activateFail may be activated. The DetectCollision is then killed if it
         * doesn't have the noActivateDeath flag.
         *
         * @param {Thing} thing
         * @param {DetectCollision} other
         */
        FullScreenMario.prototype.collideDetector = function (thing, other) {
            if (!thing.player) {
                if (other.activateFail) {
                    other.activateFail(thing);
                }
                return;
            }
            other.activate(thing, other);
            if (!other.noActivateDeath) {
                thing.FSM.killNormal(other);
            }
        };
        /**
         * Collision callback for level transports (any Thing with a .transport
         * attribute). Depending on the transport, either the map or location are
         * shifted to it.
         *
         * @param {Player} thing
         * @param {Thing} other
         */
        FullScreenMario.prototype.collideLevelTransport = function (thing, other) {
            var transport = other.transport;
            if (!thing.player) {
                return;
            }
            if (typeof transport === "undefined") {
                throw new Error("No transport given to collideLevelTransport");
            }
            if (transport.constructor === String) {
                thing.FSM.setLocation(transport);
            }
            else if (typeof transport.map !== "undefined") {
                if (typeof transport.location !== "undefined") {
                    thing.FSM.setMap(transport.map, transport.location);
                }
                else {
                    thing.FSM.setMap(transport.map);
                }
            }
            else if (typeof transport.location !== "undefined") {
                thing.FSM.setLocation(transport.location);
            }
            else {
                throw new Error("Unknown transport type:" + transport);
            }
        };
        /* Movement functions
        */
        /**
         * Base, generic movement Function for simple characters. The Thing moves
         * at a constant rate in either the x or y direction, and switches direction
         * only if directed by the engine (e.g. when it hits a Solid)
         *
         * @param {Character} thing
         * @remarks thing.speed is the only required member attribute; .direction
         *          and .moveleft should be set by the game engine.
         */
        FullScreenMario.prototype.moveSimple = function (thing) {
            // If the thing is looking away from the intended direction, flip it
            if (thing.direction !== thing.moveleft) {
                // thing.moveleft is truthy: it should now be looking to the right
                if (thing.moveleft) {
                    thing.xvel = -thing.speed;
                    if (!thing.noflip) {
                        thing.FSM.unflipHoriz(thing);
                    }
                }
                else {
                    // thing.moveleft is falsy: it should now be looking to the left
                    thing.xvel = thing.speed;
                    if (!thing.noflip) {
                        thing.FSM.flipHoriz(thing);
                    }
                }
                thing.direction = thing.moveleft;
            }
        };
        /**
         * Extension of the moveSimple movement Function for Things that shouldn't
         * fall off the edge of their resting blocks
         *
         * @param {Character} thing
         */
        FullScreenMario.prototype.moveSmart = function (thing) {
            // Start off by calling moveSimple for normal movement
            thing.FSM.moveSimple(thing);
            // If this isn't resting, it's the same as moveSimple
            if (thing.yvel !== 0) {
                return;
            }
            if (!thing.resting || !thing.FSM.isCharacterOnResting(thing, thing.resting)) {
                if (thing.moveleft) {
                    thing.FSM.shiftHoriz(thing, thing.FSM.unitsize, true);
                }
                else {
                    thing.FSM.shiftHoriz(thing, -thing.FSM.unitsize, true);
                }
                thing.moveleft = !thing.moveleft;
            }
            // // Check for being over the edge in the direction of movement
            // if (thing.moveleft) {
            // if (thing.left + thing.FSM.unitsize <= thing.resting.left) {
            // thing.FSM.shiftHoriz(thing, thing.FSM.unitsize);
            // thing.moveleft = false;
            // }
            // } else {
            // if (thing.right - thing.FSM.unitsize >= thing.resting.right) {
            // thing.FSM.shiftHoriz(thing, -thing.FSM.unitsize);
            // thing.moveleft = true;
            // }
            // }
        };
        /**
         * Extension of the moveSimple movement Function for Things that should
         * jump whenever they start resting.
         *
         * @param {Character} thing
         * @remarks thing.jumpheight is required to know how high to jump
         */
        FullScreenMario.prototype.moveJumping = function (thing) {
            // Start off by calling moveSimple for normal movement
            thing.FSM.moveSimple(thing);
            // If .resting, jump!
            if (thing.resting) {
                thing.yvel = -Math.abs(thing.jumpheight);
                thing.resting = undefined;
            }
        };
        /**
         * Movement Function for Things that slide back and forth, such as
         * HammerBros and Lakitus.
         *
         * @remarks thing.counter must be a number set elsewhere, such as in a spawn
         *          Function.
         */
        FullScreenMario.prototype.movePacing = function (thing) {
            thing.counter += .007;
            thing.xvel = Math.sin(Math.PI * thing.counter) / 2.1;
        };
        /**
         * Movement Function for HammerBros. They movePacing, look towards the
         * player, and have the nocollidesolid flag if they're jumping up or
         * intentionally falling through a solid.
         *
         * @param {HammerBro} thing
         */
        FullScreenMario.prototype.moveHammerBro = function (thing) {
            thing.FSM.movePacing(thing);
            thing.FSM.lookTowardsPlayer(thing);
            thing.nocollidesolid = thing.yvel < 0 || thing.falling;
        };
        /**
         * Movement Function for Bowser. Bowser always faces the player and
         * movePaces if he's to the right of the player, or moves to the right if
         * he's to the left.
         *
         * @param {Bowser} thing
         */
        FullScreenMario.prototype.moveBowser = function (thing) {
            // Facing to the right
            if (thing.flipHoriz) {
                // To the left of player: walk to the right
                if (thing.FSM.objectToLeft(thing, thing.FSM.player)) {
                    thing.FSM.moveSimple(thing);
                }
                else {
                    // To the right of player: look to the left and movePacing as normal
                    thing.lookleft = thing.moveleft = true;
                    thing.FSM.unflipHoriz(thing);
                    thing.FSM.movePacing(thing);
                }
            }
            else {
                // Facing to the left
                // To the left of player: look and walk to the right
                if (thing.FSM.objectToLeft(thing, thing.FSM.player)) {
                    thing.lookleft = thing.moveleft = false;
                    thing.FSM.flipHoriz(thing);
                    thing.FSM.moveSimple(thing);
                }
                else {
                    // To the right of the player: movePacing as normal
                    thing.FSM.movePacing(thing);
                }
            }
        };
        /**
         * Movement Function for Bowser's spewed fire. It has a ylev stored from
         * creation that will tell it when to stop changing its vertical
         * velocity from this Function; otherwise, it shifts its vertical
         * position to move to the ylev.
         *
         * @param {BowserFire} thing
         */
        FullScreenMario.prototype.moveBowserFire = function (thing) {
            if (Math.round(thing.bottom) === Math.round(thing.ylev)) {
                thing.movement = undefined;
                return;
            }
            thing.FSM.shiftVert(thing, Math.min(Math.max(0, thing.ylev - thing.bottom), thing.FSM.unitsize));
        };
        /**
         * Movement function for Things that float up and down (vertically).
         * If the Thing has reached thing.begin or thing.end, it gradually switches
         * thing.yvel
         *
         * @param {Thing} thing
         * @remarks thing.maxvel is used as the maximum absolute speed vertically
         * @remarks thing.begin and thing.end are used as the vertical endpoints;
         *          .begin is the bottom and .end is the top (since begin <= end)
         */
        FullScreenMario.prototype.moveFloating = function (thing) {
            // If above the endpoint:
            if (thing.top <= thing.end) {
                thing.yvel = Math.min(thing.yvel + thing.FSM.unitsize / 64, thing.maxvel);
            }
            else if (thing.bottom >= thing.begin) {
                // If below the endpoint:
                thing.yvel = Math.max(thing.yvel - thing.FSM.unitsize / 64, -thing.maxvel);
            }
            // Deal with velocities and whether the player is resting on this
            thing.FSM.movePlatform(thing);
        };
        /**
         * Actual movement Function for Things that float sideways (horizontally).
         * If the Thing has reached thing.begin or thing.end, it gradually switches
         * thing.xvel.
         *
         * @param {Thing} thing
         * @remarks thing.maxvel is used as the maximum absolute speed horizontally
         * @remarks thing.begin and thing.end are used as the horizontal endpoints;
         *          .begin is the left and .end is the right (since begin <= end)
         */
        FullScreenMario.prototype.moveSliding = function (thing) {
            // If to the left of the endpoint:
            if (thing.FSM.MapScreener.left + thing.left <= thing.begin) {
                thing.xvel = Math.min(thing.xvel + thing.FSM.unitsize / 64, thing.maxvel);
            }
            else if (thing.FSM.MapScreener.left + thing.right > thing.end) {
                // If to the right of the endpoint:
                thing.xvel = Math.max(thing.xvel - thing.FSM.unitsize / 64, -thing.maxvel);
            }
            // Deal with velocities and whether the player is resting on this
            thing.FSM.movePlatform(thing);
        };
        /**
         * Ensures thing.begin <= thing.end (so there won't be glitches pertaining
         * to them in functions like moveFloating and moveSliding
         *
         * @param {Thing} thing
         */
        FullScreenMario.prototype.setMovementEndpoints = function (thing) {
            if (thing.begin > thing.end) {
                var temp = thing.begin;
                thing.begin = thing.end;
                thing.end = temp;
            }
            thing.begin *= thing.FSM.unitsize;
            thing.end *= thing.FSM.unitsize;
        };
        /**
         * General movement Function for Platforms. Moves a Platform by its
         * velocities, and checks for whether a Thing is resting on it (if so,
         * the Thing is accordingly).
         *
         * @param {Thing} thing
         */
        FullScreenMario.prototype.movePlatform = function (thing) {
            thing.FSM.shiftHoriz(thing, thing.xvel);
            thing.FSM.shiftVert(thing, thing.yvel);
            // If the player is resting on this and this is alive, move the player
            if (thing === thing.FSM.player.resting && thing.FSM.player.alive) {
                thing.FSM.setBottom(thing.FSM.player, thing.top);
                thing.FSM.shiftHoriz(thing.FSM.player, thing.xvel);
                // If the player is too far to the right or left, stop that overlap
                if (thing.FSM.player.right > thing.FSM.MapScreener.width) {
                    thing.FSM.setRight(thing.FSM.player, thing.FSM.MapScreener.width);
                }
                else if (thing.FSM.player.left < 0) {
                    thing.FSM.setLeft(thing.FSM.player, 0);
                }
            }
        };
        /**
         * Movement Function for platforms that are in a PlatformGenerator. They
         * have the typical movePlatform applied to them, but if they reach the
         * bottom or top of the screen, they are shifted to the opposite side.
         *
         * @param {Platform} thing
         */
        FullScreenMario.prototype.movePlatformSpawn = function (thing) {
            if (thing.bottom < 0) {
                thing.FSM.setTop(thing, thing.FSM.MapScreener.bottomPlatformMax);
            }
            else if (thing.top > thing.FSM.MapScreener.bottomPlatformMax) {
                thing.FSM.setBottom(thing, 0);
            }
            else {
                thing.FSM.movePlatform(thing);
                return;
            }
            if (thing.FSM.player
                && thing.FSM.player.resting === thing) {
                thing.FSM.player.resting = undefined;
            }
        };
        /**
         * Movement Function for Platforms that fall whenever rested upon by a
         * player. Being rested upon means the Platform falls; when it reaches a
         * terminal velocity, it switches to moveFreeFalling forever.
         *
         * @param {Platform} thing
         */
        FullScreenMario.prototype.moveFalling = function (thing) {
            // If the player isn't resting on this thing (any more?), ignore it
            if (thing.FSM.player.resting !== thing) {
                // Since the player might have been on this thing but isn't anymore, 
                // set the yvel to 0 just in case
                thing.yvel = 0;
                return;
            }
            // Since the player is on this thing, start falling more
            thing.FSM.shiftVert(thing, thing.yvel += thing.FSM.unitsize / 8);
            thing.FSM.setBottom(thing.FSM.player, thing.top);
            // After a velocity threshold, start always falling
            if (thing.yvel >= (thing.fallThresholdStart || thing.FSM.unitsize * 2.8)) {
                thing.freefall = true;
                thing.movement = thing.FSM.moveFreeFalling;
            }
        };
        /**
         * Movement Function for Platforms that have reached terminal velocity in
         * moveFalling and are now destined to die. The Platform will continue to
         * accelerate towards certain death until another velocity threshold,
         * and then switches to movePlatform to remain at that rate.
         *
         * @param {Platform} thing
         */
        FullScreenMario.prototype.moveFreeFalling = function (thing) {
            // Accelerate downwards, increasing the thing's y-velocity
            thing.yvel += thing.acceleration || thing.FSM.unitsize / 16;
            thing.FSM.shiftVert(thing, thing.yvel);
            // After a velocity threshold, stop accelerating
            if (thing.yvel >= (thing.fallThresholdEnd || thing.FSM.unitsize * 2)) {
                thing.movement = thing.FSM.movePlatform;
            }
        };
        /**
         * Movement Function for Platforms that are a part of a scale.  Nothing
         * happens if a Platform isn't being rested and doesn't have a y-velocity.
         * Being rested upon means the y-velocity increases, and not being rested
         * means the y-velocity decreases: either moves the corresponding Platform
         * "partner" in the other vertical direction. When the Platform is too far
         * down (visually has no string left), they both fall.
         *
         * @param {Platform} thing
         * @todo Implement this! See #146.
         */
        FullScreenMario.prototype.movePlatformScale = function (thing) {
            // If the Player is resting on this, fall hard
            if (thing.FSM.player.resting === thing) {
                thing.yvel += thing.FSM.unitsize / 16;
            }
            else if (thing.yvel > 0) {
                // If this still has velocity from a player, stop or fall less
                if (!thing.partners) {
                    thing.yvel = 0;
                }
                else {
                    thing.yvel = Math.max(thing.yvel - thing.FSM.unitsize / 16, 0);
                }
            }
            else {
                // Not being rested upon or having a yvel means nothing happens
                return;
            }
            thing.tension += thing.yvel;
            thing.FSM.shiftVert(thing, thing.yvel);
            // The rest of the logic is for the platform's partner(s)
            if (!thing.partners) {
                return;
            }
            thing.partners.partnerPlatform.tension -= thing.yvel;
            // If the partner has fallen off, everybody falls!
            if (thing.partners.partnerPlatform.tension <= 0) {
                thing.FSM.scoreOn(1000, thing);
                thing.partners.partnerPlatform.yvel = thing.FSM.unitsize / 2;
                thing.collide = thing.partners.partnerPlatform.collide = (thing.FSM.collideCharacterSolid);
                thing.movement = thing.partners.partnerPlatform.movement = (thing.FSM.moveFreeFalling);
            }
            // The partner has yvel equal and opposite to this platform's
            thing.FSM.shiftVert(thing.partners.partnerPlatform, -thing.yvel);
            // This platform's string grows with its yvel
            thing.FSM.setHeight(thing.partners.ownString, thing.partners.ownString.height + thing.yvel / thing.FSM.unitsize);
            // The partner's string shrinks while this platform's string grows
            thing.FSM.setHeight(thing.partners.partnerString, Math.max(thing.partners.partnerString.height - (thing.yvel / thing.FSM.unitsize), 0));
        };
        /**
         * Movement Function for Vines. They are constantly growing upward, until
         * some trigger (generally from animateEmergeVine) sets movement to
         * undefined. If there is an attached Thing, it is moved up at the same rate
         * as the Vine.
         *
         * @param {Vine} thing
         */
        FullScreenMario.prototype.moveVine = function (thing) {
            thing.FSM.increaseHeight(thing, thing.speed);
            thing.FSM.updateSize(thing);
            if (thing.attachedSolid) {
                thing.FSM.setBottom(thing, thing.attachedSolid.top);
            }
            if (thing.attachedCharacter) {
                thing.FSM.shiftVert(thing.attachedCharacter, -thing.speed);
            }
        };
        /**
         * Movement Function for Springboards that are "pushing up" during or after
         * being hit by a player. The Springboard changes its height based on its
         * tension. If the player is still on it, then the player is given extra
         * vertical velocity and taken off.
         *
         * @param {Springboard} thing
         */
        FullScreenMario.prototype.moveSpringboardUp = function (thing) {
            var player = thing.FSM.player;
            thing.FSM.reduceHeight(thing, -thing.tension, true);
            thing.tension *= 2;
            // If the spring height is past the normal, it's done moving
            if (thing.height > thing.heightNormal) {
                thing.FSM.reduceHeight(thing, (thing.height - thing.heightNormal) * thing.FSM.unitsize);
                if (thing === player.spring) {
                    player.yvel = thing.FSM.MathDecider.compute("springboardYvelUp", thing);
                    player.resting = player.spring = undefined;
                    player.movement = thing.FSM.movePlayer;
                }
                thing.tension = 0;
                thing.movement = undefined;
            }
            else {
                thing.FSM.setBottom(player, thing.top);
            }
            if (thing === player.spring) {
                if (!thing.FSM.isThingTouchingThing(player, thing)) {
                    player.spring = undefined;
                    player.movement = FullScreenMario.prototype.movePlayer;
                }
            }
        };
        /**
         * Movement Function for Shells. This actually does nothing for moving
         * Shells (since they only interact unusually on collision). For Shells with
         * no x-velocity, a counting variable is increased. Once it reaches 350, the
         * shell is "peeking" visually; when it reaches 490, the Shell spawns back
         * into its original spawner (typically Koopa or Beetle).
         *
         * @param {Shell} thing
         */
        FullScreenMario.prototype.moveShell = function (thing) {
            if (thing.xvel !== 0) {
                return;
            }
            thing.counting += 1;
            if (thing.counting === 350) {
                thing.peeking = 1;
                thing.height += thing.FSM.unitsize / 8;
                thing.FSM.addClass(thing, "peeking");
                thing.FSM.updateSize(thing);
            }
            else if (thing.counting === 455) {
                thing.peeking = 2;
            }
            else if (thing.counting === 490) {
                thing.spawnSettings = {
                    "smart": thing.smart
                };
                thing.FSM.killSpawn(thing);
            }
        };
        /**
         * Movement Function for Piranhas. These constantly change their height
         * except when they reach 0 or full height (alternating direction), at which
         * point they switch to movePiranhaLatent to wait to move in the opposite
         * direction.
         *
         * @param {Piranha} thing
         */
        FullScreenMario.prototype.movePiranha = function (thing) {
            var bottom = thing.bottom, height = thing.height + thing.direction, atEnd = false;
            if (thing.resting && !thing.FSM.isThingAlive(thing.resting)) {
                bottom = thing.constructor.prototype.height * thing.FSM.unitsize + thing.top;
                height = Infinity;
                thing.resting = undefined;
            }
            if (height <= 0) {
                height = thing.height = 0;
                atEnd = true;
            }
            else if (height >= thing.constructor.prototype.height) {
                height = thing.height = thing.constructor.prototype.height;
                atEnd = true;
            }
            thing.FSM.setHeight(thing, height);
            thing.FSM.setBottom(thing, bottom);
            // Canvas height should be manually reset, as PixelRendr will otherwise
            // store the height as the initial small height from spawnPiranha...
            thing.canvas.height = height * thing.FSM.unitsize;
            thing.FSM.PixelDrawer.setThingSprite(thing);
            if (atEnd) {
                thing.counter = 0;
                thing.movement = thing.FSM.movePiranhaLatent;
            }
        };
        /**
         * Movement Function for Piranhas that are not changing size. They wait
         * until a counter reaches a point (and then, if their height is 0, for the
         * player to go away) to switch back to movePiranha.
         *
         * @param {Piranha} thing
         */
        FullScreenMario.prototype.movePiranhaLatent = function (thing) {
            var playerX = thing.FSM.getMidX(thing.FSM.player);
            if (thing.counter >= thing.countermax
                && (thing.height > 0
                    || playerX < thing.left - thing.FSM.unitsize * 8
                    || playerX > thing.right + thing.FSM.unitsize * 8)) {
                thing.movement = undefined;
                thing.direction *= -1;
                thing.FSM.TimeHandler.addEvent(function () {
                    thing.movement = thing.FSM.movePiranha;
                }, 7);
            }
            else {
                thing.counter += 1;
            }
        };
        /**
         * Movement Function for the Bubbles that come out of a player's mouth
         * underwater. They die when they reach a top threshold of unitsize * 16.
         *
         * @param {Bubble} thing
         */
        FullScreenMario.prototype.moveBubble = function (thing) {
            if (thing.top < (thing.FSM.MapScreener.top
                + thing.FSM.unitsize * 16)) {
                thing.FSM.killNormal(thing);
            }
        };
        /**
         * Movement Function for typical CheepCheeps, which are underwater. They
         * move according to their native velocities except that they cannot travel
         * above the unitsize * 16 top threshold.
         *
         * @param {CheepCheep} thing
         */
        FullScreenMario.prototype.moveCheepCheep = function (thing) {
            if (thing.top < thing.FSM.unitsize * 16) {
                thing.FSM.setTop(thing, thing.FSM.unitsize * 16);
                thing.yvel *= -1;
                return;
            }
        };
        /**
         * Movement Function for flying CheepCheeps, like in bridge areas. They
         * lose a movement Function (and therefore just fall) at a unitsize * 28 top
         * threshold.
         *
         * @param {CheepCheep} thing
         */
        FullScreenMario.prototype.moveCheepCheepFlying = function (thing) {
            if (thing.top < thing.FSM.unitsize * 28) {
                thing.movement = undefined;
                thing.nofall = false;
            }
        };
        /**
         * Movement Function for Bloopers. These switch between "squeezing" (moving
         * down) and moving up ("unsqueezing"). They always try to unsqueeze if the
         * player is above them.
         *
         * @param {Blooper} thing
         */
        FullScreenMario.prototype.moveBlooper = function (thing) {
            // If the player is dead, just drift aimlessly
            if (!thing.FSM.isThingAlive(thing.FSM.player)) {
                thing.xvel = thing.FSM.unitsize / -4;
                thing.yvel = 0;
                thing.movement = undefined;
                return;
            }
            switch (thing.counter) {
                case 56:
                    thing.squeeze = 1;
                    thing.counter += 1;
                    break;
                case 63:
                    thing.FSM.moveBlooperSqueezing(thing);
                    break;
                default:
                    thing.counter += 1;
                    if (thing.top < thing.FSM.unitsize * 18) {
                        thing.FSM.moveBlooperSqueezing(thing);
                    }
                    break;
            }
            if (thing.squeeze) {
                thing.yvel = Math.max(thing.yvel + .021, .7); // going down
            }
            else {
                thing.yvel = Math.min(thing.yvel - .035, -.7); // going up
            }
            if (thing.top > thing.FSM.unitsize * 16) {
                thing.FSM.shiftVert(thing, thing.yvel, true);
            }
            if (!thing.squeeze) {
                if (thing.FSM.player.left
                    > thing.right + thing.FSM.unitsize * 8) {
                    // Go to the right
                    thing.xvel = Math.min(thing.speed, thing.xvel + thing.FSM.unitsize / 32);
                }
                else if (thing.FSM.player.right
                    < thing.left - thing.FSM.unitsize * 8) {
                    // Go to the left
                    thing.xvel = Math.max(-thing.speed, thing.xvel - thing.FSM.unitsize / 32);
                }
            }
        };
        /**
         * Additional movement Function for Bloopers that are "squeezing". Squeezing
         * Bloopers travel downard at a gradual pace until they reach either the
         * player's bottom or a threshold of unitsize * 90.
         *
         * @param {Blooper} thing
         */
        FullScreenMario.prototype.moveBlooperSqueezing = function (thing) {
            if (thing.squeeze !== 2) {
                thing.squeeze = 2;
                thing.FSM.addClass(thing, "squeeze");
                thing.FSM.setHeight(thing, 10, true, true);
            }
            if (thing.squeeze < 7) {
                thing.xvel /= 1.4;
            }
            else if (thing.squeeze === 7) {
                thing.xvel = 0;
            }
            thing.squeeze += 1;
            if (thing.top > thing.FSM.player.bottom
                || thing.bottom > thing.FSM.unitsize * 91) {
                thing.FSM.animateBlooperUnsqueezing(thing);
            }
        };
        /**
         * Movement Function for Podoboos that is only used when they are falling.
         * Podoboo animations trigger this when they reach a certain height, and
         * use this to determine when they should stop accelerating downward, which
         * is their starting location.
         *
         * @param {Podoboo} thing
         */
        FullScreenMario.prototype.movePodobooFalling = function (thing) {
            if (thing.top >= thing.starty) {
                thing.yvel = 0;
                thing.movement = undefined;
                thing.FSM.unflipVert(thing);
                thing.FSM.setTop(thing, thing.starty);
                return;
            }
            if (thing.yvel >= thing.speed) {
                thing.yvel = thing.speed;
                return;
            }
            if (!thing.flipVert && thing.yvel > 0) {
                thing.FSM.flipVert(thing);
            }
            thing.yvel += thing.acceleration;
        };
        /**
         * Movement Function for Lakitus that have finished their moveLakituInitial
         * run. This is similar to movePacing in that it makes the Lakitu pace to
         * left and right of the player, and moves with the player rather than the
         * scrolling window.
         *
         * @param {Lakitu} thing
         */
        FullScreenMario.prototype.moveLakitu = function (thing) {
            var player = thing.FSM.player;
            // If the player is moving quickly to the right, move in front and stay there
            if (player.xvel > thing.FSM.unitsize / 8
                && player.left > thing.FSM.MapScreener.width / 2) {
                if (thing.left < player.right + thing.FSM.unitsize * 16) {
                    // slide to xloc
                    thing.FSM.slideToX(thing, player.right + player.xvel + thing.FSM.unitsize * 32, player.maxspeed * 1.4);
                    thing.counter = 0;
                }
            }
            else {
                thing.counter += .007;
                thing.FSM.slideToX(thing, player.left + player.xvel + Math.sin(Math.PI * thing.counter) * 117, player.maxspeed * .7);
            }
        };
        /**
         * Initial entry movement Function for Lakitus. They enter by sliding across
         * the top of the screen until they reach the player, and then switch to
         * their standard moveLakitu movement.
         *
         * @param {Lakitu} thing
         */
        FullScreenMario.prototype.moveLakituInitial = function (thing) {
            if (thing.right < thing.FSM.player.left) {
                thing.counter = 0;
                thing.movement = thing.FSM.moveLakitu;
                thing.movement(thing);
                return;
            }
            thing.FSM.shiftHoriz(thing, -thing.FSM.unitsize);
        };
        /**
         * Alternate movement Function for Lakitus. This is used when the player
         * reaches the ending flagpole in a level and the Lakitu just flies to the
         * left.
         *
         * @param {Lakitu} thing
         */
        FullScreenMario.prototype.moveLakituFleeing = function (thing) {
            thing.FSM.shiftHoriz(thing, -thing.FSM.unitsize);
        };
        /**
         * Movement Function for Coins that have been animated. They move based on
         * their yvel, and if they have a parent, die when they go below the parent.
         *
         * @param {Coin} thing
         * @param {Solid} [parent]
         */
        FullScreenMario.prototype.moveCoinEmerge = function (thing, parent) {
            thing.FSM.shiftVert(thing, thing.yvel);
            if (parent && thing.bottom >= thing.blockparent.bottom) {
                thing.FSM.killNormal(thing);
            }
        };
        /**
         * Movement Function for the player. It reacts to almost all actions that
         * to be done, but is horribly written so that is all the documentation you
         * get here. Sorry! Sections are labeled on the inside.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.movePlayer = function (thing) {
            // Not jumping
            if (!thing.keys.up) {
                thing.keys.jump = false;
            }
            else if (
            // Jumping
            thing.keys.jump
                && (thing.yvel <= 0 || thing.FSM.MapScreener.underwater)) {
                if (thing.FSM.MapScreener.underwater) {
                    thing.FSM.animatePlayerPaddling(thing);
                    thing.FSM.removeClass(thing, "running");
                }
                if (thing.resting) {
                    if (thing.resting.xvel) {
                        thing.xvel += thing.resting.xvel;
                    }
                    thing.resting = undefined;
                }
                else {
                    // Jumping, not resting
                    if (!thing.jumping && !thing.FSM.MapScreener.underwater) {
                        thing.FSM.switchClass(thing, "running skidding", "jumping");
                    }
                    thing.jumping = true;
                    if (thing.power > 1 && thing.crouching) {
                        thing.FSM.removeClass(thing, "jumping");
                    }
                }
                if (!thing.FSM.MapScreener.underwater) {
                    thing.keys.jumplev += 1;
                    thing.FSM.MathDecider.compute("decreasePlayerJumpingYvel", thing);
                }
            }
            // Crouching
            if (thing.keys.crouch && !thing.crouching && thing.resting) {
                if (thing.power > 1) {
                    thing.crouching = true;
                    thing.FSM.removeClass(thing, "running");
                    thing.FSM.addClass(thing, "crouching");
                    thing.FSM.setHeight(thing, 11, true, true);
                    thing.height = 11;
                    thing.tolyOld = thing.toly;
                    thing.toly = thing.FSM.unitsize * 4;
                    thing.FSM.updateBottom(thing, 0);
                    thing.FSM.updateSize(thing);
                }
                // Pipe movement
                if (thing.resting.actionTop) {
                    thing.FSM.ModAttacher.fireEvent("onPlayerActionTop", thing, thing.resting);
                    thing.resting.actionTop(thing, thing.resting);
                }
            }
            // Running
            if (thing.FSM.MathDecider.compute("decreasePlayerRunningXvel", thing)) {
                if (thing.skidding) {
                    thing.FSM.addClass(thing, "skidding");
                }
                else {
                    thing.FSM.removeClass(thing, "skidding");
                }
            }
            // Movement mods
            // Slowing down
            if (Math.abs(thing.xvel) < .14) {
                if (thing.running) {
                    thing.running = false;
                    if (thing.power === 1) {
                        thing.FSM.setPlayerSizeSmall(thing);
                    }
                    thing.FSM.removeClasses(thing, "running skidding one two three");
                    thing.FSM.addClass(thing, "still");
                    thing.FSM.TimeHandler.cancelClassCycle(thing, "running");
                }
            }
            else if (!thing.running) {
                // Not moving slowly
                thing.running = true;
                thing.FSM.animatePlayerRunningCycle(thing);
                if (thing.power === 1) {
                    thing.FSM.setPlayerSizeSmall(thing);
                }
            }
            if (thing.xvel > 0) {
                thing.xvel = Math.min(thing.xvel, thing.maxspeed);
                if (thing.moveleft && (thing.resting || thing.FSM.MapScreener.underwater)) {
                    thing.FSM.unflipHoriz(thing);
                    thing.moveleft = false;
                }
            }
            else if (thing.xvel < 0) {
                thing.xvel = Math.max(thing.xvel, thing.maxspeed * -1);
                if (!thing.moveleft && (thing.resting || thing.FSM.MapScreener.underwater)) {
                    thing.moveleft = true;
                    thing.FSM.flipHoriz(thing);
                }
            }
            // Resting stops a bunch of other stuff
            if (thing.resting) {
                // Hopping
                if (thing.hopping) {
                    thing.hopping = false;
                    thing.FSM.removeClass(thing, "hopping");
                    if (thing.xvel) {
                        thing.FSM.addClass(thing, "running");
                    }
                }
                // Jumping
                thing.keys.jumplev = thing.yvel = thing.jumpcount = 0;
                if (thing.jumping) {
                    thing.jumping = false;
                    thing.FSM.removeClass(thing, "jumping");
                    if (thing.power === 1) {
                        thing.FSM.setPlayerSizeSmall(thing);
                    }
                    thing.FSM.addClass(thing, Math.abs(thing.xvel) < .14 ? "still" : "running");
                }
                // Paddling
                if (thing.paddling) {
                    thing.paddling = thing.swimming = false;
                    thing.FSM.TimeHandler.cancelClassCycle(thing, "paddling");
                    thing.FSM.removeClasses(thing, "paddling swim1 swim2");
                    thing.FSM.addClass(thing, "running");
                }
            }
        };
        /**
         * Alternate movement Function for players attached to a Vine. They may
         * climb up or down the Vine, or jump off.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.movePlayerVine = function (thing) {
            var attachedSolid = thing.attachedSolid, animatedClimbing;
            if (!attachedSolid) {
                thing.movement = thing.FSM.movePlayer;
                return;
            }
            if (thing.bottom < thing.attachedSolid.top) {
                thing.FSM.unattachPlayer(thing, thing.attachedSolid);
                return;
            }
            // Running away from the vine means dropping off
            if (thing.keys.run !== 0 && thing.keys.run === thing.attachedDirection) {
                // Leaving to the left
                if (thing.attachedDirection === -1) {
                    thing.FSM.setRight(thing, attachedSolid.left - thing.FSM.unitsize);
                }
                else if (thing.attachedDirection === 1) {
                    // Leaving to the right
                    thing.FSM.setLeft(thing, attachedSolid.right + thing.FSM.unitsize);
                }
                thing.FSM.unattachPlayer(thing, attachedSolid);
                return;
            }
            // If the player is moving up, simply move up
            if (thing.keys.up) {
                animatedClimbing = true;
                thing.FSM.shiftVert(thing, thing.FSM.unitsize / -4);
            }
            else if (thing.keys.crouch) {
                // If the thing is moving down, move down and check for unattachment
                animatedClimbing = true;
                thing.FSM.shiftVert(thing, thing.FSM.unitsize / 2);
                if (thing.top > attachedSolid.bottom) {
                    thing.FSM.unattachPlayer(thing, thing.attachedSolid);
                }
                return;
            }
            else {
                animatedClimbing = false;
            }
            if (animatedClimbing && !thing.animatedClimbing) {
                thing.FSM.addClass(thing, "animated");
            }
            else if (!animatedClimbing && thing.animatedClimbing) {
                thing.FSM.removeClass(thing, "animated");
            }
            thing.animatedClimbing = animatedClimbing;
            if (thing.bottom < thing.FSM.MapScreener.top - thing.FSM.unitsize * 4) {
                thing.FSM.setLocation(thing.attachedSolid.transport);
            }
        };
        /**
         * Movement Function for players pressing down onto a Springboard. This does
         * basically nothing except check for when the player is off the spring or
         * the spring is fully contracted. The former restores the player's movement
         * and the latter clears it (to be restored in moveSpringboardUp).
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.movePlayerSpringboardDown = function (thing) {
            var other = thing.spring;
            // If the player has moved off the spring, get outta here
            if (!thing.FSM.isThingTouchingThing(thing, other)) {
                thing.movement = thing.FSM.movePlayer;
                other.movement = thing.FSM.moveSpringboardUp;
                thing.spring = undefined;
                return;
            }
            // If the spring is fully contracted, go back up
            if (other.height < thing.FSM.unitsize * 2.5
                || other.tension < thing.FSM.unitsize / 32) {
                thing.movement = undefined;
                other.movement = thing.FSM.moveSpringboardUp;
                return;
            }
            // Make sure it's hard to slide off
            if (thing.left < other.left + thing.FSM.unitsize * 2
                || thing.right > other.right - thing.FSM.unitsize * 2) {
                thing.xvel /= 1.4;
            }
            thing.FSM.reduceHeight(other, other.tension, true);
            other.tension /= 2;
            thing.FSM.setBottom(thing, other.top);
            thing.FSM.updateSize(other);
        };
        /* Animations
        */
        /**
         * Animates a solid that has just had its bottom "bumped" by a player. It
         * moves with a dx that is initially negative (up) and increases (to down).
         *
         * @param {Solid} thing
         */
        FullScreenMario.prototype.animateSolidBump = function (thing) {
            var dx = -3;
            thing.FSM.TimeHandler.addEventInterval(function (thing) {
                thing.FSM.shiftVert(thing, dx);
                dx += .5;
                if (dx === 3.5) {
                    thing.up = undefined;
                    return true;
                }
                return false;
            }, 1, Infinity, thing);
        };
        /**
         * Animates a Block to switch from unused to used.
         *
         * @param {Block} thing
         */
        FullScreenMario.prototype.animateBlockBecomesUsed = function (thing) {
            thing.used = true;
            thing.FSM.switchClass(thing, "unused", "used");
        };
        /**
         * Animates a solid to have its contents emerge. A new Thing based on the
         * contents is spawned directly on top of (visually behind) the solid, and
         * has its animate callback triggered.
         *
         * @param {Solid} thing
         * @param {Player} other
         * @remarks If the contents are "Mushroom" and a large player hits the
         *          solid, they turn into "FireFlower".
         * @remarks For the level editor, if thing.contents is false, the prototype
         *          is tried (so false becomes Coin in Blocks).
         */
        FullScreenMario.prototype.animateSolidContents = function (thing, other) {
            var output;
            if (other
                && other.player
                && other.power > 1
                && thing.contents === "Mushroom") {
                thing.contents = "FireFlower";
            }
            output = thing.FSM.addThing(thing.contents || thing.constructor.prototype.contents);
            thing.FSM.setMidXObj(output, thing);
            thing.FSM.setTop(output, thing.top);
            output.blockparent = thing;
            output.animate(output, thing);
            return output;
        };
        /**
         * Animates a Brick turning into four rotating shards flying out of it. The
         * shards have an initial x- and y-velocities, and die after 70 steps.
         *
         * @param {Brick} thing
         */
        FullScreenMario.prototype.animateBrickShards = function (thing) {
            var unitsize = thing.FSM.unitsize, shard, left, top, i;
            for (i = 0; i < 4; i += 1) {
                left = thing.left + Number(i < 2) * thing.width * unitsize - unitsize * 2;
                top = thing.top + (i % 2) * thing.height * unitsize - unitsize * 2;
                shard = thing.FSM.addThing("BrickShard", left, top);
                shard.xvel = shard.speed = unitsize / 2 - unitsize * Number(i > 1);
                shard.yvel = unitsize * -1.4 + i % 2;
                thing.FSM.TimeHandler.addEvent(thing.FSM.killNormal, 70, shard);
            }
        };
        /**
         * Standard animation Function for Things emerging from a solid as contents.
         * They start at inside the solid, slowly move up, then moveSimple until
         * they're off the solid, at which point they revert to their normal
         * movement.
         *
         * @param {Character} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.animateEmerge = function (thing, other) {
            thing.nomove = thing.nocollide = thing.nofall = thing.alive = true;
            thing.FSM.flipHoriz(thing);
            thing.FSM.AudioPlayer.play("Powerup Appears");
            thing.FSM.arraySwitch(thing, thing.FSM.GroupHolder.getGroup("Character"), thing.FSM.GroupHolder.getGroup("Scenery"));
            thing.FSM.TimeHandler.addEventInterval(function () {
                thing.FSM.shiftVert(thing, thing.FSM.unitsize / -8);
                // Only stop once the bottom has reached the solid's top
                if (thing.bottom > other.top) {
                    return false;
                }
                thing.FSM.setBottom(thing, other.top);
                thing.FSM.GroupHolder.switchMemberGroup(thing, "Scenery", "Character");
                thing.nomove = thing.nocollide = thing.nofall = thing.moveleft = false;
                if (thing.emergeOut) {
                    thing.emergeOut(thing, other);
                }
                // Wait for movement until moveSimple moves this off the solid
                if (thing.movement) {
                    thing.movementOld = thing.movement;
                    thing.movement = thing.FSM.moveSimple;
                    thing.FSM.TimeHandler.addEventInterval(function () {
                        if (thing.resting === other) {
                            return false;
                        }
                        thing.FSM.TimeHandler.addEvent(function () {
                            thing.movement = thing.movementOld;
                        }, 1);
                        return true;
                    }, 1, Infinity);
                }
                return true;
            }, 1, Infinity);
        };
        /**
         * Animation Function for Coins emerging from (or being hit by) a solid. The
         * Coin switches to the Scenery group, rotates between animation classes,
         * moves up then down then dies, plays the "Coin" sound, and increaes the
         * "coins" and "score" statistics.
         *
         * @param {Coin} thing
         * @param {Solid} other
         */
        FullScreenMario.prototype.animateEmergeCoin = function (thing, other) {
            thing.nocollide = thing.alive = thing.nofall = true;
            thing.yvel -= thing.FSM.unitsize;
            thing.FSM.switchClass(thing, "still", "anim");
            thing.FSM.GroupHolder.switchMemberGroup(thing, "Character", "Scenery");
            thing.FSM.AudioPlayer.play("Coin");
            thing.FSM.ItemsHolder.increase("coins", 1);
            thing.FSM.ItemsHolder.increase("score", 200);
            thing.FSM.TimeHandler.cancelClassCycle(thing, "0");
            thing.FSM.TimeHandler.addClassCycle(thing, [
                "anim1", "anim2", "anim3", "anim4", "anim3", "anim2"
            ], "0", 5);
            thing.FSM.TimeHandler.addEventInterval(function () {
                thing.FSM.moveCoinEmerge(thing, other);
                return !thing.FSM.isThingAlive(thing);
            }, 1, Infinity);
            thing.FSM.TimeHandler.addEvent(function () {
                thing.FSM.killNormal(thing);
            }, 49);
            thing.FSM.TimeHandler.addEvent(function () {
                thing.yvel *= -1;
            }, 25);
        };
        /**
         * Animation Function for a Vine emerging from a solid. It continues to grow
         * as normal via moveVine for 700 steps, then has its movement erased to
         * stop.
         *
         * @param {Vine} thing
         * @param {Solid} solid
         */
        FullScreenMario.prototype.animateEmergeVine = function (thing, solid) {
            // This allows the thing's movement to keep it on the solid
            thing.attachedSolid = solid;
            thing.FSM.setHeight(thing, 0);
            thing.FSM.AudioPlayer.play("Vine Emerging");
            thing.FSM.TimeHandler.addEvent(function () {
                thing.nocollide = false;
            }, 14);
            thing.FSM.TimeHandler.addEvent(function () {
                thing.movement = undefined;
            }, 700);
        };
        /**
         * Animates a "flicker" effect on a Thing by repeatedly toggling its hidden
         * flag for a little while.
         *
         * @param {Thing} thing
         * @param {Number} [cleartime]   How long to wait to stop the effect (by
         *                               default, 49).
         * @param {Number} [interval]   How many steps between hidden toggles (by
         *                              default, 2).
         */
        FullScreenMario.prototype.animateFlicker = function (thing, cleartime, interval) {
            cleartime = Math.round(cleartime) || 49;
            interval = Math.round(interval) || 2;
            thing.flickering = true;
            thing.FSM.TimeHandler.addEventInterval(function () {
                thing.hidden = !thing.hidden;
                thing.FSM.PixelDrawer.setThingSprite(thing);
            }, interval, cleartime);
            thing.FSM.TimeHandler.addEvent(function () {
                thing.flickering = thing.hidden = false;
                thing.FSM.PixelDrawer.setThingSprite(thing);
            }, cleartime * interval + 1);
        };
        /**
         * Animate Function for a HammerBro to throw a hammer. The HammerBro
         * switches to the "throwing" class, waits and throws a few repeats, then
         * goes back to normal.
         *
         * @param {HammerBro} thing
         * @param {Number} count   How many times left there are to throw a hammer.
         *                         If equal to 3, a hammer will not be thrown (to
         *                         mimic the pause in the original game).
         * @remarks This could probably be re-written.
         */
        FullScreenMario.prototype.animateThrowingHammer = function (thing, count) {
            if (!thing.FSM.isThingAlive(thing)) {
                return true;
            }
            if (thing.FSM.isThingAlive(thing.FSM.player)
                && thing.right >= thing.FSM.unitsize * -32
                && count !== 3) {
                thing.FSM.switchClass(thing, "thrown", "throwing");
            }
            thing.FSM.TimeHandler.addEvent(function () {
                if (!thing.FSM.isThingAlive(thing)) {
                    return;
                }
                // Schedule the next animateThrowingHammer call
                if (count > 0) {
                    thing.FSM.TimeHandler.addEvent(thing.FSM.animateThrowingHammer, 7, thing, count - 1);
                }
                else {
                    thing.FSM.TimeHandler.addEvent(thing.FSM.animateThrowingHammer, 70, thing, 7);
                    thing.FSM.removeClass(thing, "thrown");
                }
                // Don't throw if the player is dead, or this is too far to the left
                if (!thing.FSM.isThingAlive(thing.FSM.player) || thing.right < thing.FSM.unitsize * -32) {
                    thing.FSM.switchClass(thing, "throwing", "thrown");
                    return;
                }
                // Don't throw in the third iteration (makes a gap in the hammers)
                if (count === 3) {
                    return;
                }
                // Throw by creating a hammer and visually updating
                thing.FSM.switchClass(thing, "throwing", "thrown");
                thing.FSM.addThing(["Hammer", {
                        "xvel": thing.lookleft
                            ? thing.FSM.unitsize / -1.4
                            : thing.FSM.unitsize / 1.4,
                        "yvel": thing.FSM.unitsize * -1.4,
                        "gravity": thing.FSM.MapScreener.gravity / 2.1
                    }], thing.left - thing.FSM.unitsize * 2, thing.top - thing.FSM.unitsize * 2);
            }, 14);
            return false;
        };
        /**
         * Animation Function for when Bowser jumps. This will only trigger if he is
         * facing left and a player exists. If either Bowser or the player die, it
         * is cancelled. He is given a negative yvel to jump, and the nocollidesolid
         * flag is enabled as long as he is rising.
         *
         * @param {Bowser} thing
         */
        FullScreenMario.prototype.animateBowserJump = function (thing) {
            if (!thing.lookleft || !thing.FSM.player || !thing.FSM.isThingAlive(thing.FSM.player)) {
                return false;
            }
            if (!thing.FSM.isThingAlive(thing)) {
                return true;
            }
            thing.resting = undefined;
            thing.yvel = thing.FSM.unitsize * -1.4;
            // If there is a platform, don't bump into it
            thing.nocollidesolid = true;
            thing.FSM.TimeHandler.addEventInterval(function () {
                if (thing.dead || thing.yvel > thing.FSM.unitsize) {
                    thing.nocollidesolid = false;
                    return true;
                }
                return false;
            }, 3, Infinity);
            return false;
        };
        /**
         * Animation Function for when Bowser fires. This will only trigger if he is
         * facing left and a player exists. If either Bowser or the player die, it
         * is cancelled. His mouth is closed and an animateBowserFireOpen call is
         * scheduled to complete the animation.
         *
         * @param {Bowser} thing
         */
        FullScreenMario.prototype.animateBowserFire = function (thing) {
            if (!thing.lookleft || !thing.FSM.player || !thing.FSM.isThingAlive(thing.FSM.player)) {
                return false;
            }
            if (!thing.FSM.isThingAlive(thing)) {
                return true;
            }
            // Close the mouth
            thing.FSM.addClass(thing, "firing");
            thing.FSM.AudioPlayer.playLocal("Bowser Fires", thing.left);
            // After a bit, re-open and fire
            thing.FSM.TimeHandler.addEvent(thing.FSM.animateBowserFireOpen, 14, thing);
            return false;
        };
        /**
         * Animation Function for when Bowser actually fires. A BowserFire Thing is
         * placed at his mouth, given a (rounded to unitsize * 8) destination y, and
         * sent firing to the player.
         *
         * @param {Bowser} thing
         */
        FullScreenMario.prototype.animateBowserFireOpen = function (thing) {
            var unitsize = thing.FSM.unitsize, ylev = Math.max(-thing.height * unitsize, Math.round(thing.FSM.player.bottom / (unitsize * 8))
                * unitsize * 8);
            if (!thing.FSM.isThingAlive(thing)) {
                return true;
            }
            thing.FSM.removeClass(thing, "firing");
            thing.FSM.addThing(["BowserFire", {
                    "ylev": ylev
                }], thing.left - thing.FSM.unitsize * 8, thing.top + thing.FSM.unitsize * 4);
            return false;
        };
        /**
         * Animation Function for when Bowser throws a Hammer. It's similar to a
         * HammerBro, but the hammer appears on top of Bowser for a few steps
         * before being thrown in the direction Bowser is facing (though it will
         * only be added if facing left).
         *
         * @param {Bowser} thing
         */
        FullScreenMario.prototype.animateBowserThrow = function (thing) {
            if (!thing.lookleft || !thing.FSM.player || !thing.FSM.isThingAlive(thing.FSM.player)) {
                return false;
            }
            if (!thing.FSM.isThingAlive(thing)) {
                return true;
            }
            var hammer = thing.FSM.addThing("Hammer", thing.left + thing.FSM.unitsize * 2, thing.top - thing.FSM.unitsize * 2);
            thing.FSM.TimeHandler.addEventInterval(function () {
                if (!thing.FSM.isThingAlive(thing)) {
                    thing.FSM.killNormal(hammer);
                    return true;
                }
                thing.FSM.setTop(hammer, thing.top - thing.FSM.unitsize * 2);
                if (thing.lookleft) {
                    thing.FSM.setLeft(hammer, thing.left + thing.FSM.unitsize * 2);
                }
                else {
                    thing.FSM.setLeft(hammer, thing.right - thing.FSM.unitsize * 2);
                }
                return true;
            }, 1, 14);
            thing.FSM.TimeHandler.addEvent(function () {
                hammer.xvel = thing.FSM.unitsize * 1.17;
                hammer.yvel = thing.FSM.unitsize * -2.1;
                // hammer.gravity = thing.FSM.MapScreener.gravity / 1.4;
                if (thing.lookleft) {
                    hammer.xvel *= -1;
                }
            }, 14);
            return false;
        };
        /**
         * Animation Function for when Bowser freezes upon the player hitting a
         * CastleAxe. Velocity and movement are paused, and the Bowser is added to
         * the current cutscene's settings.
         *
         * @param {Bowser} thing
         * @remarks This is triggered as Bowser's killonend property.
         */
        FullScreenMario.prototype.animateBowserFreeze = function (thing) {
            thing.nofall = true;
            thing.nothrow = true;
            thing.movement = undefined;
            thing.dead = true;
            thing.FSM.thingPauseVelocity(thing);
            thing.FSM.ScenePlayer.addCutsceneSetting("bowser", thing);
            thing.FSM.TimeHandler.addEvent(function () {
                thing.nofall = false;
            }, 70);
        };
        /**
         * Animation Function for a standard jump, such as what HammerBros do. The
         * jump may be in either up or down, chosen at random by the NumberMaker.
         * Steps are taken to ensure the Thing does not collide at improper points
         * during the jump.
         *
         * @param {Thing} thing
         */
        FullScreenMario.prototype.animateJump = function (thing) {
            // Finish
            if (!thing.FSM.isThingAlive(thing) || !thing.FSM.isThingAlive(thing.FSM.player)) {
                return true;
            }
            // Skip
            if (!thing.resting) {
                return false;
            }
            // Jump up?
            if (thing.FSM.MapScreener.floor - (thing.bottom / thing.FSM.unitsize) >= 30
                && thing.resting.title !== "Floor"
                && thing.FSM.NumberMaker.randomBoolean()) {
                thing.falling = true;
                thing.yvel = thing.FSM.unitsize * -.7;
                thing.FSM.TimeHandler.addEvent(function () {
                    thing.falling = false;
                }, 42);
            }
            else {
                // Jump down
                thing.nocollidesolid = true;
                thing.yvel = thing.FSM.unitsize * -2.1;
                thing.FSM.TimeHandler.addEvent(function () {
                    thing.nocollidesolid = false;
                }, 42);
            }
            thing.resting = undefined;
            return false;
        };
        /**
         * Animation Function for Bloopers starting to "unsqueeze". The "squeeze"
         * class is removed, their height is reset to 12, and their counter reset.
         *
         * @param {Blooper} thing
         */
        FullScreenMario.prototype.animateBlooperUnsqueezing = function (thing) {
            thing.counter = 0;
            thing.squeeze = 0;
            thing.FSM.removeClass(thing, "squeeze");
            thing.FSM.setHeight(thing, 12, true, true);
        };
        /**
         * Animation Function for Podoboos jumping up. Their top is recorded and a
         * large negative yvel is given; after the jumpheight number of steps, they
         * fall back down.
         *
         * @param {Podoboo} thing
         */
        FullScreenMario.prototype.animatePodobooJumpUp = function (thing) {
            thing.starty = thing.top;
            thing.yvel = thing.speed * -1;
            thing.FSM.TimeHandler.addEvent(thing.FSM.animatePodobooJumpDown, thing.jumpHeight, thing);
        };
        /**
         * Animation Function for when a Podoboo needs to stop jumping. It obtains
         * the movePodobooFalling movement to track its descent.
         *
         * @param {Podoboo} thing
         */
        FullScreenMario.prototype.animatePodobooJumpDown = function (thing) {
            thing.movement = thing.FSM.movePodobooFalling;
        };
        /**
         * Animation Function for a Lakitu throwing a SpinyEgg. The Lakitu hides
         * behind its cloud ("hiding" class), waits 21 steps, then throws an egg up
         * and comes out of "hiding".
         *
         * @param {Lakitu} thing
         */
        FullScreenMario.prototype.animateLakituThrowingSpiny = function (thing) {
            if (thing.fleeing || !thing.FSM.isThingAlive(thing)) {
                return true;
            }
            thing.FSM.switchClass(thing, "out", "hiding");
            thing.FSM.TimeHandler.addEvent(function () {
                if (thing.dead) {
                    return;
                }
                var spawn = thing.FSM.addThing("SpinyEgg", thing.left, thing.top);
                spawn.yvel = thing.FSM.unitsize * -2.1;
                thing.FSM.switchClass(thing, "hiding", "out");
            }, 21);
        };
        /**
         * Animation Function for when a SpinyEgg hits the ground. The SpinyEgg is
         * killed and a Spiny is put in its place, moving towards the player.
         *
         * @param {SpinyEgg} thing
         */
        FullScreenMario.prototype.animateSpinyEggHatching = function (thing) {
            if (!thing.FSM.isThingAlive(thing)) {
                return;
            }
            var spawn = thing.FSM.addThing("Spiny", thing.left, thing.top - thing.yvel);
            spawn.moveleft = thing.FSM.objectToLeft(thing.FSM.player, spawn);
            thing.FSM.killNormal(thing);
        };
        /**
         * Animation Function for when a Fireball emerges from a player. All that
         * happens is the "Fireball" sound plays.
         *
         * @param {Fireball} thing
         */
        FullScreenMario.prototype.animateFireballEmerge = function (thing) {
            thing.FSM.AudioPlayer.play("Fireball");
        };
        /**
         * Animation Function for when a Fireball explodes. It is deleted and,
         * unless big is === 2 (as this is used as a kill Function), a Firework is
         * put in its place.
         *
         * @param {Fireball} thing
         * @param {Number} [big]   The "level" of death this is (a 2 implies this is
         *                         a sudden death, without animations).
         */
        FullScreenMario.prototype.animateFireballExplode = function (thing, big) {
            thing.nocollide = true;
            thing.FSM.killNormal(thing);
            if (big === 2) {
                return;
            }
            var output = thing.FSM.addThing("Firework");
            thing.FSM.setMidXObj(output, thing);
            thing.FSM.setMidYObj(output, thing);
            output.animate(output);
        };
        /**
         * Animation Function for a Firework, triggered immediately upon spawning.
         * The Firework cycles between "n1" through "n3", then dies.
         *
         * @param {Firework} thing
         */
        FullScreenMario.prototype.animateFirework = function (thing) {
            var name = thing.className + " n", i;
            for (i = 0; i < 3; i += 1) {
                thing.FSM.TimeHandler.addEvent(function (i) {
                    thing.FSM.setClass(thing, name + String(i + 1));
                }, i * 7, i);
            }
            thing.FSM.AudioPlayer.play("Firework");
            thing.FSM.TimeHandler.addEvent(function () {
                thing.FSM.killNormal(thing);
            }, i * 7);
        };
        /**
         * Animation Function for a Cannon outputting a BulletBill. This will only
         * happen if the Cannon isn't within 8 units of the player. The spawn flies
         * at a constant rate towards the player.
         *
         * @param {Cannon} thing
         */
        FullScreenMario.prototype.animateCannonFiring = function (thing) {
            if (!thing.FSM.isThingAlive(thing)) {
                return;
            }
            // Don't fire if Player is too close
            if (thing.FSM.player.right > (thing.left - thing.FSM.unitsize * 8)
                && thing.FSM.player.left < (thing.right + thing.FSM.unitsize * 8)) {
                return;
            }
            var spawn = thing.FSM.ObjectMaker.make("BulletBill");
            if (thing.FSM.objectToLeft(thing.FSM.player, thing)) {
                spawn.direction = spawn.moveleft = true;
                spawn.xvel *= -1;
                thing.FSM.flipHoriz(spawn);
                thing.FSM.addThing(spawn, thing.left, thing.top);
            }
            else {
                thing.FSM.addThing(spawn, thing.left + thing.width, thing.top);
            }
            thing.FSM.AudioPlayer.playLocal("Bump", thing.right);
        };
        /**
         * Animation Function for a fiery player throwing a Fireball. The player may
         * only do so if fewer than 2 other thrown Fireballs exist. A new Fireball
         * is created in front of where the player is facing and are sent bouncing
         * away.
         *
         * @param {Player} thing
         * @remarks Yes, it's called numballs.
         */
        FullScreenMario.prototype.animatePlayerFire = function (thing) {
            if (thing.numballs >= 2) {
                return;
            }
            var xloc = thing.moveleft
                ? (thing.left - thing.FSM.unitsize / 4)
                : (thing.right + thing.FSM.unitsize / 4), ball = thing.FSM.ObjectMaker.make("Fireball", {
                "moveleft": thing.moveleft,
                "speed": thing.FSM.unitsize * 1.75,
                "jumpheight": thing.FSM.unitsize * 1.56,
                "gravity": thing.FSM.MapScreener.gravity * 1.56,
                "yvel": thing.FSM.unitsize,
                "movement": thing.FSM.moveJumping
            });
            thing.FSM.addThing(ball, xloc, thing.top + thing.FSM.unitsize * 8);
            ball.animate(ball);
            ball.onDelete = function () {
                thing.numballs -= 1;
            };
            thing.numballs += 1;
            thing.FSM.addClass(thing, "firing");
            thing.FSM.TimeHandler.addEvent(function () {
                thing.FSM.removeClass(thing, "firing");
            }, 7);
        };
        /**
         * Animation Function that regularly spings CastleFireballs around their
         * parent CastleBlock. The CastleBlock's location and angle determine the
         * location of each CastleFireball, and its dt and direction determine how
         * the angle is changed for the next call.
         *
         * @param {CastleBlock} thing
         * @param {CastleFireball[]} balls
         */
        FullScreenMario.prototype.animateCastleBlock = function (thing, balls) {
            var midx = thing.EightBitter.getMidX(thing), midy = thing.EightBitter.getMidY(thing), ax = Math.cos(thing.angle * Math.PI) * thing.FSM.unitsize * 4, ay = Math.sin(thing.angle * Math.PI) * thing.FSM.unitsize * 4, i;
            for (i = 0; i < balls.length; i += 1) {
                thing.FSM.setMidX(balls[i], midx + ax * i);
                thing.FSM.setMidY(balls[i], midy + ay * i);
            }
            thing.angle += thing.dt * thing.direction;
        };
        /**
         * Animation Function to close a CastleBridge when the player triggers its
         * killonend after hitting the CastleAxe in EndInsideCastle. Its width is
         * reduced repeatedly on an interval until it's 0.
         *
         * @param {CastleBridge} thing
         * @remarks This is triggered as the killonend property of the bridge.
         */
        FullScreenMario.prototype.animateCastleBridgeOpen = function (thing) {
            thing.FSM.ScenePlayer.playRoutine("CastleBridgeOpen", thing);
        };
        /**
         * Animation Function for when a CastleChain opens, which just delays a
         * killNormal call for 7 steps.
         *
         * @param {CastleChain} thing
         * @remarks This is triggered as the killonend property of the chain.
         */
        FullScreenMario.prototype.animateCastleChainOpen = function (thing) {
            thing.FSM.TimeHandler.addEvent(thing.FSM.killNormal, 3, thing);
        };
        /**
         * Animation Function for when the player paddles underwater. Any previous
         * Any previous paddling classes and cycle are removed, and a new one is
         * added that, when it finishes, remnoves the player's paddlingCycle as
         * well.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerPaddling = function (thing) {
            if (!thing.paddlingCycle) {
                thing.FSM.removeClasses(thing, "skidding paddle1 paddle2 paddle3 paddle4 paddle5");
                thing.FSM.addClass(thing, "paddling");
                thing.FSM.TimeHandler.cancelClassCycle(thing, "paddlingCycle");
                thing.FSM.TimeHandler.addClassCycle(thing, [
                    "paddle1", "paddle2", "paddle3", "paddle2", "paddle1",
                    function () {
                        return thing.paddlingCycle = false;
                    },
                ], "paddlingCycle", 7);
            }
            thing.paddling = thing.paddlingCycle = thing.swimming = true;
            thing.yvel = thing.FSM.unitsize * -.84;
        };
        /**
         * Animation Function for when a player lands to reset size and remove
         * hopping (and if underwater, paddling) classes. The mod event is fired.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerLanding = function (thing) {
            if (thing.crouching && thing.power > 1) {
                thing.FSM.setHeight(thing, 11, true, true);
            }
            if (thing.FSM.hasClass(thing, "hopping")) {
                thing.FSM.switchClass(thing, "hopping", "jumping");
            }
            if (thing.FSM.MapScreener.underwater) {
                thing.FSM.removeClass(thing, "paddling");
            }
            thing.FSM.ModAttacher.fireEvent("onPlayerLanding", thing, thing.resting);
        };
        /**
         * Animation Function for when the player moves off a resting solid. It
         * sets resting to undefined, and if underwater, switches the "running" and
         * "paddling" classes.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerRestingOff = function (thing) {
            thing.resting = undefined;
            if (thing.FSM.MapScreener.underwater) {
                thing.FSM.switchClass(thing, "running", "paddling");
            }
        };
        /**
         * Animation Function for when a player breathes a underwater. This creates
         * a Bubble, which slowly rises to the top of the screen.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerBubbling = function (thing) {
            thing.FSM.addThing("Bubble", thing.right, thing.top);
        };
        /**
         * Animation Function to give the player a cycle of running classes. The
         * cycle auto-updates its time as a function of how fast the player is
         * moving relative to its maximum speed.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerRunningCycle = function (thing) {
            thing.FSM.switchClass(thing, "still", "running");
            thing.running = thing.FSM.TimeHandler.addClassCycle(thing, [
                "one", "two", "three", "two"
            ], "running", function (event) {
                event.timeout = 5 + Math.ceil(thing.maxspeedsave - Math.abs(thing.xvel));
            });
        };
        /**
         * Animation Function for when a player hops on an enemy. Resting is set to
         * undefined, and a small vertical yvel is given.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animateCharacterHop = function (thing) {
            thing.resting = undefined;
            thing.yvel = thing.FSM.unitsize * -1.4;
        };
        /**
         * Animation Function to start a player transferring through a Pipe. This is
         * generic for entrances and exists horizontally and vertically: movement
         * and velocities are frozen, size is reset, and the piping flag enabled.
         * The player is also moved into the Scenery group to be behind the Pipe.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerPipingStart = function (thing) {
            thing.nocollide = thing.nofall = thing.piping = true;
            thing.xvel = thing.yvel = 0;
            thing.movementOld = thing.movement;
            thing.movement = undefined;
            if (thing.power > 1) {
                thing.FSM.animatePlayerRemoveCrouch(thing);
                thing.FSM.setPlayerSizeLarge(thing);
            }
            else {
                thing.FSM.setPlayerSizeSmall(thing);
            }
            thing.FSM.removeClasses(thing, "jumping running crouching");
            thing.FSM.AudioPlayer.clearTheme();
            thing.FSM.TimeHandler.cancelAllCycles(thing);
            thing.FSM.GroupHolder.switchMemberGroup(thing, "Character", "Scenery");
        };
        /**
         * Animation Function for when a player is done passing through a Pipe. This
         * is abstracted for exits both horizontally and vertically, typically after
         * an area has just been entered.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerPipingEnd = function (thing) {
            thing.movement = thing.movementOld;
            thing.nocollide = thing.nofall = thing.piping = false;
            thing.FSM.AudioPlayer.resumeTheme();
            thing.FSM.GroupHolder.switchMemberGroup(thing, "Scenery", "Character");
        };
        /**
         * Animation Function for when a player is hopping off a pole. It hops off
         * and faces the opposite direction.
         *
         * @param {Player} thing
         * @param {Boolean} [doRun]   Whether the player should have a running cycle
         *                            added immediately, such as during cutscenes
         *                            (by default, false).
         */
        FullScreenMario.prototype.animatePlayerOffPole = function (thing, doRun) {
            thing.FSM.removeClasses(thing, "climbing running");
            thing.FSM.addClass(thing, "jumping");
            thing.xvel = 1.4;
            thing.yvel = -.7;
            thing.nocollide = thing.nofall = false;
            thing.gravity = thing.FSM.MapScreener.gravity / 14;
            thing.FSM.TimeHandler.addEvent(function () {
                thing.movement = thing.FSM.movePlayer;
                thing.gravity = thing.FSM.MapScreener.gravity;
                thing.FSM.unflipHoriz(thing);
                if (doRun) {
                    thing.FSM.animatePlayerRunningCycle(thing);
                }
            }, 21);
        };
        /**
         * Animation Function for when a player must hop off a Vine during an area's
         * opening cutscene. The player switches sides, waits 14 steps, then calls
         * animatePlayerOffPole.
         *
         * @param {Player} thing
         */
        FullScreenMario.prototype.animatePlayerOffVine = function (thing) {
            thing.FSM.flipHoriz(thing);
            thing.FSM.shiftHoriz(thing, (thing.width - 1) * thing.FSM.unitsize);
            thing.FSM.TimeHandler.addEvent(thing.FSM.animatePlayerOffPole, 14, thing);
        };
        /* Appearance utilities
        */
        /**
         * Makes one Thing look towards another, chainging lookleft and moveleft in
         * the process.
         *
         * @param {Thing} thing
         * @param {Thing} other
         */
        FullScreenMario.prototype.lookTowardsThing = function (thing, other) {
            // Case: other is to the left
            if (other.right <= thing.left) {
                thing.lookleft = true;
                thing.moveleft = true;
                thing.FSM.unflipHoriz(thing);
            }
            else if (other.left >= thing.right) {
                // Case: other is to the right
                thing.lookleft = false;
                thing.moveleft = false;
                thing.FSM.flipHoriz(thing);
            }
        };
        /**
         * Makes one Thing look towards the player, chainging lookleft and moveleft
         * in the process.
         *
         * @param {Thing} thing
         * @param {Boolean} [big]   Whether to always change lookleft and moveleft,
         *                          even if lookleft is already accurate (by
         *                          default, false).
         */
        FullScreenMario.prototype.lookTowardsPlayer = function (thing, big) {
            // Case: Player is to the left
            if (thing.FSM.player.right <= thing.left) {
                if (!thing.lookleft || big) {
                    thing.lookleft = true;
                    thing.moveleft = false;
                    thing.FSM.unflipHoriz(thing);
                }
            }
            else if (thing.FSM.player.left >= thing.right) {
                // Case: Player is to the right
                if (thing.lookleft || big) {
                    thing.lookleft = false;
                    thing.moveleft = true;
                    thing.FSM.flipHoriz(thing);
                }
            }
        };
        /* Death functions
        */
        /**
         * Standard Function to kill a Thing, which means marking it as dead and
         * clearing its numquads, resting, movement, and cycles. It will later be
         * marked as gone by its maintain* Function (Solids or Characters).
         *
         * @param {Thing} thing
         */
        FullScreenMario.prototype.killNormal = function (thing) {
            if (!thing) {
                return;
            }
            thing.hidden = thing.dead = true;
            thing.alive = false;
            thing.numquads = 0;
            thing.movement = undefined;
            if (this.hasOwnProperty("resting")) {
                thing.resting = undefined;
            }
            if (thing.FSM) {
                thing.FSM.TimeHandler.cancelAllCycles(thing);
            }
            thing.FSM.ModAttacher.fireEvent("onKillNormal", thing);
        };
        /**
         * Death Function commonly called on characters to animate a small flip
         * before killNormal is called.
         *
         * @param {Thing} thing
         * @param {Number} [extra]   How much time to wait beyond the standard 70
         *                           steps before calling killNormal (by default,
         *                           0).
         */
        FullScreenMario.prototype.killFlip = function (thing, extra) {
            if (extra === void 0) { extra = 0; }
            thing.FSM.flipVert(thing);
            if (thing.bottomBump) {
                thing.bottomBump = undefined;
            }
            thing.nocollide = thing.dead = true;
            thing.speed = thing.xvel = 0;
            thing.nofall = false;
            thing.resting = thing.movement = undefined;
            thing.yvel = -thing.FSM.unitsize;
            thing.FSM.TimeHandler.addEvent(thing.FSM.killNormal, 70 + extra, thing);
        };
        /**
         * Kill Function to replace a Thing with a spawned Thing, determined by the
         * thing's spawnType, in the same location.
         *
         * @param {Thing} thing
         * @param {Boolean} [big]   Whether this should skip creating the spawn (by
         *                          default, false).
         */
        FullScreenMario.prototype.killSpawn = function (thing, big) {
            if (big) {
                thing.FSM.killNormal(thing);
                return;
            }
            if (!thing.spawnType) {
                throw new Error("Thing " + thing.title + " has no .spawnType.");
            }
            var spawn = thing.FSM.ObjectMaker.make(thing.spawnType, thing.spawnSettings || {});
            thing.FSM.addThing(spawn);
            thing.FSM.setBottom(spawn, thing.bottom);
            thing.FSM.setMidXObj(spawn, thing);
            thing.FSM.killNormal(thing);
            return spawn;
        };
        /**
         * A kill Function similar to killSpawn but more configurable. A spawned
         * Thing is created with the given attributes and copies over any specified
         * attributes from the original Thing.
         *
         * @param {Thing} thing
         * @param {String} title   The type of new Thing to create, such as "Goomba".
         * @param {Object} [attributes]   An optional object to pass in to the
         *                                ObjectMaker.make call (by default, {}).
         * @param {String[]} [attributesCopied]   An optional listing of attributes
         *                                        to copy from the original Thing
         *                                        (by default, none).
         */
        FullScreenMario.prototype.killReplace = function (thing, title, attributes, attributesCopied) {
            var spawn, i;
            if (typeof attributes === "undefined") {
                attributes = {};
            }
            if (typeof attributesCopied !== "undefined") {
                for (i = 0; i < attributesCopied.length; i += 1) {
                    attributes[attributesCopied[i]] = thing[attributesCopied[i]];
                }
            }
            spawn = thing.FSM.ObjectMaker.make(title, attributes);
            if (thing.flipHoriz) {
                thing.FSM.flipHoriz(spawn);
            }
            if (thing.flipVert) {
                thing.FSM.flipVert(spawn);
            }
            thing.FSM.addThing(spawn, thing.left, thing.top);
            thing.FSM.killNormal(thing);
            return spawn;
        };
        /**
         * Kill Function for Goombas. If big isn't specified, it replaces the
         * killed Goomba with a DeadGoomba via killSpawn.
         *
         * @param {Thing} thing
         * @param {Boolean} [big]   Whether to call killFlip on the Thing instead of
         *                          killSpawn, such as when a Shell hits it.
         */
        FullScreenMario.prototype.killGoomba = function (thing, big) {
            if (big) {
                thing.FSM.killFlip(thing);
                return;
            }
            thing.FSM.killSpawn(thing);
        };
        /**
         * Kill Function for Koopas. Jumping and floating Koopas are replacing with
         * an equivalent Koopa that's just walking, while walking Koopas become
         * Shells.
         *
         * @param {Koopa} thing
         * @param {Boolean} [big]   Whether shells should be immediately killed.
         * @remarks This isn't called when a Shell hits a Koopa.
         */
        FullScreenMario.prototype.killKoopa = function (thing, big) {
            var spawn;
            if (thing.jumping || thing.floating) {
                spawn = thing.FSM.killReplace(thing, "Koopa", undefined, ["smart", "direction", "moveleft"]);
                spawn.xvel = spawn.moveleft ? -spawn.speed : spawn.speed;
            }
            else {
                spawn = thing.FSM.killToShell(thing, Number(big));
            }
            return spawn;
        };
        /**
         * Kill Function for Lakitus. If this is the last Lakitu in Characters,
         * a new one is scheduled to be spawned at the same y-position.
         *
         * @param {Lakitu} thing
         */
        FullScreenMario.prototype.killLakitu = function (thing) {
            var characters = thing.FSM.GroupHolder.getGroup("Character"), i;
            thing.FSM.killFlip(thing);
            thing.FSM.MapScreener.lakitu = undefined;
            // If any other Lakitu exists after killNormal, killLakitu is done
            for (i = 0; i < characters.length; i += 1) {
                if (characters[i].title === "Lakitu") {
                    thing.FSM.MapScreener.lakitu = characters[i];
                    return;
                }
            }
            // The next Lakitu is spawned ~5 seconds later, give or take
            thing.FSM.TimeHandler.addEvent(thing.FSM.addThing.bind(thing.FSM), 350, "Lakitu", thing.FSM.MapScreener.right, thing.top);
        };
        /**
         * Kill Function for Bowsers. In reality this is only called when the player
         * Fireballs him or all NPCs are to be killed. It takes five Fireballs to
         * killFlip a Bowser, which scores 5000 points.
         *
         * @param {Bowser} thing
         * @param {Boolean} [big]   Whether this should default to killFlip, as in
         *                          an EndInsideCastle cutscene.
         */
        FullScreenMario.prototype.killBowser = function (thing, big) {
            if (big) {
                thing.nofall = false;
                thing.movement = undefined;
                thing.FSM.killFlip(thing.FSM.killSpawn(thing));
                return;
            }
            thing.deathcount += 1;
            if (thing.deathcount === 5) {
                thing.yvel = thing.speed = 0;
                thing.movement = undefined;
                thing.FSM.killFlip(thing.FSM.killSpawn(thing), 350);
                thing.FSM.scoreOn(5000, thing);
            }
        };
        /**
         * Kills a Thing by replacing it with another Thing, typically a Shell or
         * BeetleShell (determined by thing.shelltype). The spawn inherits smartness
         * and location from its parent, and is temporarily given nocollidechar to
         * stop double collision detections.
         *
         * @param {Thing} thing
         * @param {Number} [big]   Whether the spawned Shell should be killed
         *                         immediately (by default, false).
         */
        FullScreenMario.prototype.killToShell = function (thing, big) {
            var spawn, nocollidecharold, nocollideplayerold;
            thing.spawnSettings = {
                "smart": thing.smart
            };
            if (big && big !== 2) {
                thing.spawnType = thing.title;
            }
            else {
                thing.spawnType = thing.shelltype || "Shell";
            }
            thing.spawnSettings = {
                "smart": thing.smart
            };
            spawn = thing.FSM.killSpawn(thing);
            nocollidecharold = spawn.nocollidechar;
            nocollideplayerold = spawn.nocollideplayer;
            spawn.nocollidechar = true;
            spawn.nocollideplayer = true;
            thing.FSM.TimeHandler.addEvent(function () {
                spawn.nocollidechar = nocollidecharold;
                spawn.nocollideplayer = nocollideplayerold;
            }, 7);
            thing.FSM.killNormal(thing);
            if (big === 2) {
                thing.FSM.killFlip(spawn);
            }
            return spawn;
        };
        /**
         * Wipes the screen of any characters or solids that should be gone during
         * an important cutscene, such as hitting an end-of-level flag.
         * For characters, they're deleted if .nokillonend isn't truthy. If they
         * have a .killonend function, that's called on them.
         * Solids are only deleted if their .killonend is true.
         *
         * @remarks If thing.killonend is a Function, it is called on the Thing.
         * @todo   Rename .killonend to be more accurate
         */
        FullScreenMario.prototype.killNPCs = function () {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), group, character, solid, i;
            // Characters: they must opt out of being killed with .nokillonend, and
            // may opt into having a function called instead (such as Lakitus).
            group = FSM.GroupHolder.getGroup("Character");
            for (i = group.length - 1; i >= 0; --i) {
                character = group[i];
                if (!character.nokillend) {
                    character.FSM.killNormal(character);
                    character.FSM.arrayDeleteThing(character, group, i);
                }
                else if (character.killonend) {
                    character.killonend(character);
                }
            }
            // Solids: they may opt into being deleted
            group = FSM.GroupHolder.getGroup("Solid");
            for (i = group.length - 1; i >= 0; --i) {
                solid = group[i];
                if (solid.killonend) {
                    if (solid.killonend.constructor === Function) {
                        solid.killonend(solid, group, i);
                    }
                    else {
                        solid.FSM.arrayDeleteThing(solid, group, i);
                    }
                }
            }
        };
        /**
         * Kill Function for Bricks. The Brick is killed an an animateBrickShards
         * animation is timed. If other is provided, it's also marked as the Brick's
         * up, which will kill colliding characters: this works because
         * maintainSolids happens before maintainCharacters, so the killNormal won't
         * come into play until after the next maintainCharacters call.
         *
         * @param {Brick} thing
         * @param {Thing} [other]   An optional Thing to mark as the cause of the
         *                          Brick's death (its up attribute).
         */
        FullScreenMario.prototype.killBrick = function (thing, other) {
            thing.FSM.AudioPlayer.play("Break Block");
            thing.FSM.TimeHandler.addEvent(thing.FSM.animateBrickShards, 1, thing);
            thing.FSM.killNormal(thing);
            if (other instanceof thing.FSM.ObjectMaker.getFunction("Thing")) {
                thing.up = other;
            }
            else {
                thing.up = undefined;
            }
        };
        /**
         * Kill Function for the player. It's big and complicated, but in general...
         * 1. If big === 2, just kill it altogether
         * 2. If the player is large and big isn't true, just power down the player.
         * 3. The player can't survive this, so animate the "shrug" class and an
         *    up-then-down movement.
         * At the end of 1. and 3., decrease the "lives" and "power" statistics and
         * call the equivalent onPlayerDeath or onGameOver callbacks, depending on
         * how many lives are left. The mod event is also fired.
         *
         * @param {Thing} thing
         * @param {Number} [big]   The severity of this death: 0 for normal, 1 for
         *                         not survivable, 2 for immediate death.
         */
        FullScreenMario.prototype.killPlayer = function (thing, big) {
            if (!thing.alive || thing.flickering || thing.dying) {
                return;
            }
            var FSM = thing.FSM, area = thing.FSM.MapsHandler.getArea();
            // Large big: real, no-animation death
            if (big === 2) {
                thing.dead = thing.dying = true;
                thing.alive = false;
                FSM.MapScreener.notime = true;
            }
            else {
                // Regular big: regular (enemy, time, etc.) kill
                // If the player can survive this, just power down
                if (!big && thing.power > 1) {
                    thing.power = 1;
                    FSM.ItemsHolder.setItem("power", 1);
                    FSM.AudioPlayer.play("Power Down");
                    FSM.playerGetsSmall(thing);
                    return;
                }
                else {
                    // The player can't survive this: animate a death
                    thing.dying = true;
                    FSM.setSize(thing, 7.5, 7, true);
                    FSM.updateSize(thing);
                    FSM.setClass(thing, "character player dead");
                    FSM.thingPauseVelocity(thing);
                    FSM.arrayToEnd(thing, FSM.GroupHolder.getGroup(thing.groupType));
                    FSM.MapScreener.notime = true;
                    FSM.MapScreener.nokeys = true;
                    FSM.TimeHandler.cancelAllCycles(thing);
                    FSM.TimeHandler.addEvent(function () {
                        FSM.thingResumeVelocity(thing, true);
                        thing.nocollide = true;
                        thing.movement = thing.resting = undefined;
                        thing.gravity = FSM.MapScreener.gravity / 2.1;
                        thing.yvel = FullScreenMario.unitsize * -1.4;
                    }, 7);
                }
            }
            thing.nocollide = thing.nomove = thing.dead = true;
            FSM.MapScreener.nokeys = true;
            FSM.AudioPlayer.clearAll();
            FSM.AudioPlayer.play("Player Dies");
            FSM.ItemsHolder.decrease("lives");
            FSM.ItemsHolder.setItem("power", 1);
            if (FSM.ItemsHolder.getItem("lives") > 0) {
                FSM.TimeHandler.addEvent(area.onPlayerDeath.bind(FSM), area.onPlayerDeathTimeout, FSM);
            }
            else {
                FSM.TimeHandler.addEvent(area.onGameOver.bind(FSM), area.onGameOverTimeout, FSM);
            }
        };
        /* Scoring
        */
        /**
         * @this {EightBittr}
         * @param {Number} level   What number call this is in a chain of scoring
         *                         events, such as a Shell or hopping spree.
         * @return {Number}   How many points should be gained (if 0, that means the
         *                    maximum points were passed and gainLife was called).
         */
        FullScreenMario.prototype.findScore = function (level) {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this);
            if (level < FSM.pointLevels.length) {
                return FSM.pointLevels[level];
            }
            FSM.gainLife(1);
            return 0;
        };
        /**
         * Driver function to score some number of points for the player and show
         * the gains via an animation.
         *
         * @this {EightBittr}
         * @param {Number} value   How many points the player is receiving.
         * @param {Boolean} [continuation]   Whether the game shouldn't increase the
         *                                   score amount in the ItemsHoldr (this will
         *                                   only be false on the first score() call).
         * @remarks   For point gains that should not have a visual animation,
         *            directly call ItemsHolder.increase("score", value).
         * @remarks   The calling chain will be:
         *                score -> scoreOn -> scoreAnimateOn -> scoreAnimate
         */
        FullScreenMario.prototype.score = function (value, continuation) {
            if (!value) {
                return;
            }
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this);
            FSM.scoreOn(value, FSM.player, true);
            if (!continuation) {
                this.ItemsHolder.increase("score", value);
            }
        };
        /**
         * Scores a given number of points for the player, and shows the gains via
         * an animation centered at the top of a thing.
         *
         * @param {Number} value   How many points the player is receiving.
         * @param {Thing} thing   An in-game Thing to place the visual score text
         *                        on top of and centered.
         * @param {Boolean} [continuation]   Whether the game shouldn't increase the
         *                                   score amount in the ItemsHoldr (this will
         *                                   only be false on the first score() call).
         * @remarks   The calling chain will be:
         *                scoreOn -> scoreAnimateOn -> scoreAnimate
         */
        FullScreenMario.prototype.scoreOn = function (value, thing, continuation) {
            if (!value) {
                return;
            }
            var text = thing.FSM.addThing("Text" + value);
            thing.FSM.scoreAnimateOn(text, thing);
            if (!continuation) {
                this.ItemsHolder.increase("score", value);
            }
            thing.FSM.ModAttacher.fireEvent("onScoreOn", value, thing, continuation);
        };
        /**
         * Centers a text associated with some points gain on the top of a Thing,
         * and animates it updward, setting an event for it to die.
         *
         * @param {Thing} text   The text whose position is being manipulated.
         * @param {Thing} thing   An in-game Thing to place the visual score text
         *                        on top of and centered.
         * @remarks   The calling chain will be:
         *                scoreAnimateOn -> scoreAnimate
         */
        FullScreenMario.prototype.scoreAnimateOn = function (text, thing) {
            thing.FSM.setMidXObj(text, thing);
            thing.FSM.setBottom(text, thing.top);
            thing.FSM.scoreAnimate(text);
        };
        /**
         * Animates a score on top of a Thing.
         *
         * @param {Thing} thing
         * @param {Number} [timeout]   How many game ticks to wait before killing
         *                             the text (defaults to 28).
         * @remarks   This is the last function in the score() calling chain:
         *                scoreAnimate <- scoreAnimateOn <- scoreOn <- score
         */
        FullScreenMario.prototype.scoreAnimate = function (thing, timeout) {
            if (timeout === void 0) { timeout = 28; }
            thing.FSM.TimeHandler.addEventInterval(thing.FSM.shiftVert, 1, timeout, thing, -thing.FSM.unitsize / 6);
            thing.FSM.TimeHandler.addEvent(thing.FSM.killNormal, timeout, thing);
        };
        /**
         * Inelegant catch-all Function for when the player has hit a shell and
         * needs points to be scored. This takes into account player star status and
         * Shell resting and peeking. With none of those modifiers, it defaults to
         * scoreOn with 400.
         *
         * @param {Player} thing
         * @param {Shell} other
         * @remarks See http://themushroomkingdom.net/smb_breakdown.shtml
         */
        FullScreenMario.prototype.scorePlayerShell = function (thing, other) {
            // Star player: 200 points
            if (thing.star) {
                thing.FSM.scoreOn(200, other);
                return;
            }
            // Shells in the air: 8000 points (see guide)
            if (!other.resting) {
                thing.FSM.scoreOn(8000, other);
                return;
            }
            // Peeking shells: 1000 points
            if (other.peeking) {
                thing.FSM.scoreOn(1000, other);
                return;
            }
            // Already hopping: 500 points
            if (thing.jumpcount) {
                thing.FSM.scoreOn(500, other);
                return;
            }
            // All other cases: the shell's default
            thing.FSM.scoreOn(400, other);
        };
        /**
         * Determines the amount a player should score upon hitting a flag, based on
         * the player's y-position.
         *
         * @param {Player} thing
         * @param {Number} difference   How far up the pole the collision happened,
         *                              by absolute amount (not multiplied by
         *                              unitsize).
         * @return {Number}
         * @remarks See http://themushroomkingdom.net/smb_breakdown.shtml
         */
        FullScreenMario.prototype.scorePlayerFlag = function (thing, difference) {
            var amount;
            if (difference < 28) {
                amount = difference < 8 ? 100 : 400;
            }
            else if (difference < 40) {
                amount = 800;
            }
            else {
                amount = difference < 62 ? 2000 : 5000;
            }
            return amount;
        };
        /* Audio
        */
        /**
         * @param {FullScreenMario} FSM
         * @param {Number} xloc   The x-location of the sound's source.
         * @return {Number} How loud the sound should be at that position, in [0,1].
         *                  This is louder closer to the player, and nothing to
         *                  the right of the visible screen.
         */
        FullScreenMario.prototype.getVolumeLocal = function (FSM, xloc) {
            if (xloc > FSM.MapScreener.right) {
                return 0;
            }
            return Math.max(.14, Math.min(.84, (FSM.MapScreener.width - Math.abs(xloc - FSM.player.left)) / FSM.MapScreener.width));
        };
        /**
         * @param {FullScreenMario} FSM
         * @return {String} The name of the default audio for the current area,
         *                  which is the first word in the area's setting (split on
         *                  spaces).
         */
        FullScreenMario.prototype.getAudioThemeDefault = function (FSM) {
            return FSM.MapsHandler.getArea().setting.split(" ")[0];
        };
        /* Map sets
        */
        /**
         * Sets the game state to a new map, resetting all Things and inputs in the
         * process. The mod events are fired.
         *
         * @param {String} [name]   The name of the map (by default, the currently
         *                          played one).
         * @param {Mixed} [location]   The name of the location within the map (by
         *                             default 0 for the first in Array form).
         * @remarks Most of the work here is done by setLocation.
         */
        FullScreenMario.prototype.setMap = function (name, location) {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), time, map;
            if (typeof name === "undefined" || name.constructor === FullScreenMario) {
                name = FSM.MapsHandler.getMapName();
            }
            map = FSM.MapsHandler.setMap(name);
            FSM.ModAttacher.fireEvent("onPreSetMap", map);
            if (map.seed) {
                FSM.NumberMaker.resetFromSeed(map.seed);
            }
            FSM.ItemsHolder.setItem("world", name);
            FSM.InputWriter.restartHistory();
            FSM.ModAttacher.fireEvent("onSetMap", map);
            FSM.setLocation(location || map.locationDefault || FSM.settings.maps.locationDefault);
            time = FSM.MapsHandler.getArea().time || FSM.MapsHandler.getMap().time;
            FSM.ItemsHolder.setItem("time", Number(time));
        };
        /**
         * Sets the game state to a location within the current map, resetting all
         * Things, inputs, the current Area, PixelRender, and MapScreener in the
         * process. The location's entry Function is called to bring a new Player
         * into the game. The mod events are fired.
         *
         * @param {Mixed} [name]   The name of the location within the map (by
         *                         default 0 for the first in Array form).
         */
        FullScreenMario.prototype.setLocation = function (name) {
            if (name === void 0) { name = 0; }
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), location;
            FSM.MapScreener.nokeys = false;
            FSM.MapScreener.notime = false;
            FSM.MapScreener.canscroll = true;
            FSM.MapScreener.clearScreen();
            FSM.GroupHolder.clearArrays();
            FSM.TimeHandler.cancelAllEvents();
            FSM.MapsHandler.setLocation((name || 0).toString());
            FSM.MapScreener.setVariables();
            location = FSM.MapsHandler.getLocation((name || 0).toString());
            FSM.ModAttacher.fireEvent("onPreSetLocation", location);
            FSM.PixelDrawer.setBackground(FSM.MapsHandler.getArea().background);
            FSM.TimeHandler.addEventInterval(FSM.maintainTime, 25, Infinity, FSM);
            FSM.TimeHandler.addEventInterval(FSM.maintainScenery, 350, Infinity, FSM);
            FSM.AudioPlayer.clearAll();
            FSM.AudioPlayer.playTheme();
            FSM.QuadsKeeper.resetQuadrants();
            location.entry(FSM, location);
            FSM.ModAttacher.fireEvent("onSetLocation", location);
            FSM.GamesRunner.play();
        };
        /* Map entrances
        */
        /**
         * Standard map entrance Function for dropping from the ceiling. A new
         * player is placed 16x16 units away from the top-left corner, with
         * location.xloc scrolling applied if necessary.
         *
         * @param {FullScreenMario} FSM
         * @param {Location} [location]   The calling Location entering into (by
         *                                default, not used).
         */
        FullScreenMario.prototype.mapEntranceNormal = function (FSM, location) {
            if (location && location.xloc) {
                FSM.scrollWindow(location.xloc * FSM.unitsize);
            }
            FSM.addPlayer(FSM.unitsize * 16, FSM.unitsize * 16);
        };
        /**
         * Standard map entrance Function for starting on the ground. A new player
         * is placed 16x16 units away from the top-left corner, with location.xloc
         * scrolling applied if necessary.
         *
         * @param {FullScreenMario} FSM
         * @param {Location} [location]   The calling Location entering into (by
         *                                default, not used).
         */
        FullScreenMario.prototype.mapEntrancePlain = function (FSM, location) {
            if (location && location.xloc) {
                FSM.scrollWindow(location.xloc * FSM.unitsize);
            }
            FSM.addPlayer(FSM.unitsize * 16, FSM.MapScreener.floor * FSM.unitsize);
        };
        /**
         * Map entrance Function for starting on the ground and immediately walking
         * as if in a cutscene. mapEntrancePlain is immediately called, and the
         * player has movement forced to be walking, with nokeys and notime set to
         * true.
         *
         * @param {FullScreenMario} FSM
         * @param {Location} [location]   The calling Location entering into (by
         *                                default, not used).
         */
        FullScreenMario.prototype.mapEntranceWalking = function (FSM, location) {
            FSM.mapEntrancePlain(FSM, location);
            FSM.player.keys.run = 1;
            FSM.player.maxspeed = FSM.player.walkspeed;
            FSM.MapScreener.nokeys = true;
            FSM.MapScreener.notime = true;
        };
        /**
         * Map entrance Function for entering a castle area. The player is simply
         * added at 2 x 56.
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.mapEntranceCastle = function (FSM) {
            FSM.addPlayer(FSM.unitsize * 2, FSM.unitsize * 56);
        };
        /**
         * Map entrance Function for entering an area climbing a Vine. The Vine
         * enters first by growing, then the player climbs it and hops off. The
         * player's actions are done via mapEntranceVinePlayer and are triggered
         * when the Vine's top reaches its threshold.
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.mapEntranceVine = function (FSM) {
            var threshold = (FSM.MapScreener.bottom - FSM.unitsize * 40), vine = FSM.addThing("Vine", FSM.unitsize * 32, FSM.MapScreener.bottom + FSM.unitsize * 8);
            FSM.TimeHandler.addEventInterval(function () {
                if (vine.top >= threshold) {
                    return false;
                }
                vine.movement = undefined;
                FSM.mapEntranceVinePlayer(FSM, vine);
                return true;
            }, 1, Infinity);
        };
        /**
         * Continuation of mapEntranceVine for the player's actions. The player
         * climbs up the Vine; once it reaches the threshold, it hops off using
         * animatePlayerOffVine.
         *
         * @param {FullScreenMario} FSM
         * @param {Vine} vine
         */
        FullScreenMario.prototype.mapEntranceVinePlayer = function (FSM, vine) {
            var threshold = (FSM.MapScreener.bottom - FSM.unitsize * 24), speed = FSM.unitsize / -4, player = FSM.addPlayer(FSM.unitsize * 29, FSM.MapScreener.bottom - FSM.unitsize * 4);
            FSM.shiftVert(player, player.height * FSM.unitsize);
            FSM.collideVine(player, vine);
            FSM.TimeHandler.addEventInterval(function () {
                FSM.shiftVert(player, speed);
                if (player.top < threshold) {
                    FSM.TimeHandler.addEvent(FSM.animatePlayerOffVine, 49, player);
                    return true;
                }
                return false;
            }, 1, Infinity);
        };
        /**
         * Map entrance Function for coming in through a vertical Pipe. The player
         * is added just below the top of the Pipe, and is animated to rise up
         * through it like an Italian chestburster.
         *
         * @param {FullScreenMario} FSM
         * @param {Location} [location]   The calling Location entering into (by
         *                                default, not used).
         */
        FullScreenMario.prototype.mapEntrancePipeVertical = function (FSM, location) {
            if (location && location.xloc) {
                FSM.scrollWindow(location.xloc * FSM.unitsize);
            }
            FSM.addPlayer(location.entrance.left + FSM.player.width * FSM.unitsize / 2, location.entrance.top + FSM.player.height * FSM.unitsize);
            FSM.animatePlayerPipingStart(FSM.player);
            FSM.AudioPlayer.play("Pipe");
            FSM.AudioPlayer.addEventListener("Pipe", "ended", function () {
                FSM.AudioPlayer.playTheme();
            });
            FSM.TimeHandler.addEventInterval(function () {
                FSM.shiftVert(FSM.player, FSM.unitsize / -4);
                if (FSM.player.bottom <= location.entrance.top) {
                    FSM.animatePlayerPipingEnd(FSM.player);
                    return true;
                }
                return false;
            }, 1, Infinity);
        };
        /**
         * Map entrance Function for coming in through a horizontal Pipe. The player
         * is added just to the left of the entrance, and is animated to pass
         * through it like an Italian chestburster.
         *
         * @param {FullScreenMario} FSM
         * @param {Location} [location]   The calling Location entering into (by
         *                                default, not used).
         */
        FullScreenMario.prototype.mapEntrancePipeHorizontal = function (FSM, location) {
            throw new Error("mapEntrancePipeHorizontal is not yet implemented.");
        };
        /**
         * Map entrance Function for the player reincarnating into a level,
         * typically from a random map. The player is placed at 16 x 0 and a
         * Resting Stone placed some spaces below via playerAddRestingStone.
         *
         * @param {FullScreenMario} FSM
         */
        FullScreenMario.prototype.mapEntranceRespawn = function (FSM) {
            FSM.MapScreener.nokeys = false;
            FSM.MapScreener.notime = false;
            FSM.MapScreener.canscroll = true;
            FSM.addPlayer(FSM.unitsize * 16, 0);
            FSM.animateFlicker(FSM.player);
            if (!FSM.MapScreener.underwater) {
                FSM.playerAddRestingStone(FSM.player);
            }
            FSM.ModAttacher.fireEvent("onPlayerRespawn");
        };
        /* Map exits
        */
        /**
         * Map exit Function for leaving through a vertical Pipe. The player is
         * animated to pass through it and then transfer locations.
         *
         * @param {Player} thing
         * @param {Pipe} other
         */
        FullScreenMario.prototype.mapExitPipeVertical = function (thing, other) {
            if (!thing.resting || typeof (other.transport) === "undefined"
                || thing.right + thing.FSM.unitsize * 2 > other.right
                || thing.left - thing.FSM.unitsize * 2 < other.left) {
                return;
            }
            thing.FSM.animatePlayerPipingStart(thing);
            thing.FSM.AudioPlayer.play("Pipe");
            thing.FSM.TimeHandler.addEventInterval(function () {
                thing.FSM.shiftVert(thing, thing.FSM.unitsize / 4);
                if (thing.top <= other.top) {
                    return false;
                }
                thing.FSM.TimeHandler.addEvent(function () {
                    if (other.transport.constructor === Object) {
                        thing.FSM.setMap(other.transport.map);
                    }
                    else {
                        thing.FSM.setLocation(other.transport);
                    }
                }, 42);
                return true;
            }, 1, Infinity);
        };
        /**
         * Map exit Function for leaving through a horiontal Pipe. The player is
         * animated to pass through it and then transfer locations.
         *
         * @param {Player} thing
         * @param {Pipe} other
         * @param {Boolean} [shouldTransport]   Whether not resting and not paddling
         *                                      does not imply the player cannot
         *                                      pass through the Pipe (by default,
         *                                      false, as this is normal).
         * @remarks The shouldTransport argument was added because the "Bouncy
         *          Bounce!" mod rendered some areas unenterable without it.
         */
        FullScreenMario.prototype.mapExitPipeHorizontal = function (thing, other, shouldTransport) {
            if (!shouldTransport && !thing.resting && !thing.paddling) {
                return;
            }
            if (thing.top < other.top || thing.bottom > other.bottom) {
                return;
            }
            if (!thing.keys.run) {
                return;
            }
            thing.FSM.animatePlayerPipingStart(thing);
            thing.FSM.AudioPlayer.play("Pipe");
            thing.FSM.TimeHandler.addEventInterval(function () {
                thing.FSM.shiftHoriz(thing, thing.FSM.unitsize / 4);
                if (thing.left <= other.left) {
                    return false;
                }
                thing.FSM.TimeHandler.addEvent(function () {
                    thing.FSM.setLocation(other.transport);
                }, 42);
                return true;
            }, 1, Infinity);
        };
        /* Map creation
        */
        /**
         * The onMake callback for Areas. Attributes are copied as specified in the
         * prototype, and the background is set based on the setting.
         *
         * @this {Area}
         */
        FullScreenMario.prototype.initializeArea = function () {
            var scope = this, i;
            // Copy all attributes, if they exist
            if (scope.attributes) {
                for (i in scope.attributes) {
                    if (scope.hasOwnProperty(i) && scope[i]) {
                        FullScreenMario.prototype.proliferate(scope, scope.attributes[i]);
                    }
                }
            }
            scope.setBackground(scope);
        };
        /**
         * Sets an area's background as a function of its setting.
         *
         * @param {Area} area
         * @remarks In the future, it might be more elegant to make Areas inherit
         * from base Area types (Overworld, etc.) so this inelegant switch
         * statement doesn't have to be used.
         */
        FullScreenMario.prototype.setAreaBackground = function (area) {
            // Non-underwater Underworld, Castle, and all Nights: black background
            if (area.setting.indexOf("Underwater") === -1
                && (area.setting.indexOf("Underworld") !== -1
                    || area.setting.indexOf("Castle") !== -1
                    || area.setting.indexOf("Night") !== -1)) {
                area.background = "#000000";
            }
            else {
                // Default (typically Overworld): sky blue background
                area.background = "#5c94fc";
            }
        };
        /**
         * @param {Number} yloc   A height to find the distance to the floor from.
         * @param {Boolean} [correctUnitsize]   Whether the yloc accounts for
         *                                      unitsize expansion (e.g. 48 rather
         *                                      than 12, for unitsize=4).
         * @return {Number} The distance from the absolute base (bottom of the
         *                  user's viewport) to a specific height above the floor
         *                  (in the form given by map functions, distance from the
         *                  floor).
         */
        FullScreenMario.prototype.getAbsoluteHeight = function (yloc, correctUnitsize) {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), height = yloc + FSM.MapScreener.height;
            if (!correctUnitsize) {
                height *= FSM.unitsize;
            }
            return height;
        };
        /**
         * Adds a PreThing to the map and stretches it to fit a width equal to the
         * current map's outermost boundaries.
         *
         * @this {EightBittr}
         * @param {PreThing} prethingRaw
         * @return {Thing} A strethed Thing, newly added via addThing.
         */
        FullScreenMario.prototype.mapAddStretched = function (prethingRaw) {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), boundaries = FSM.MapsHandler.getArea().boundaries, prething = prethingRaw instanceof String
                ? {
                    "thing": prething
                }
                : prethingRaw, y = ((FSM.MapScreener.floor - prething.y)
                * FSM.unitsize), 
            // It is assumed the PreThing does have a .thing if it's a stretch
            thing = FSM.ObjectMaker.make(prething.thing, {
                "width": boundaries.right - boundaries.left,
                "height": prething.height || FSM.getAbsoluteHeight(prething.y)
            });
            return FSM.addThing(thing, boundaries.left, y);
        };
        /**
         * Analyzes a PreThing to be placed to the right of the current map's
         * boundaries (after everything else).
         *
         * @this {EightBittr}
         * @param {PreThing} prethingRaw
         */
        FullScreenMario.prototype.mapAddAfter = function (prethingRaw) {
            var FSM = FullScreenMario.prototype.ensureCorrectCaller(this), MapsCreator = FSM.MapsCreator, MapsHandler = FSM.MapsHandler, prethings = MapsHandler.getPreThings(), prething = prethingRaw instanceof String
                ? {
                    "thing": prething
                }
                : prethingRaw, area = MapsHandler.getArea(), map = MapsHandler.getMap(), boundaries = FSM.MapsHandler.getArea().boundaries;
            prething.x = boundaries.right;
            MapsCreator.analyzePreSwitch(prething, prethings, area, map);
        };
        /* Cutscenes
        */
        /**
         * First cutscene for the Flagpole routine. The player becomes invincible and
         * starts sliding down the flagpole, while all other Things are killed.
         * A score calculated by scorePlayerFlag is shown at the base of the pole and
         * works its way up. The collideFlagBottom callback will be fired when the player
         * reaches the bottom.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         */
        FullScreenMario.prototype.cutsceneFlagpoleStartSlidingDown = function (FSM, settings) {
            var thing = settings.player, other = settings.collider, height = (other.bottom - thing.bottom) | 0, scoreAmount = FSM.scorePlayerFlag(thing, height / FSM.unitsize), scoreThing = FSM.ObjectMaker.make("Text" + scoreAmount);
            // This is a cutscene. No movement, no deaths, no scrolling.
            thing.star = 1;
            thing.nocollidechar = true;
            FSM.MapScreener.nokeys = true;
            FSM.MapScreener.notime = true;
            FSM.MapScreener.canscroll = false;
            // Kill all other characters and pause the player next to the pole
            FSM.killNPCs();
            FSM.thingPauseVelocity(thing);
            FSM.setRight(thing, other.left + FSM.unitsize * 3);
            FSM.killNormal(other);
            // The player is now climbing down the pole
            FSM.removeClasses(thing, "running jumping skidding");
            FSM.addClass(thing, "climbing animated");
            FSM.TimeHandler.addClassCycle(thing, ["one", "two"], "climbing", 0);
            // Animate the Flag to the base of the pole
            FSM.TimeHandler.addEventInterval(FSM.shiftVert, 1, 64, other.collection.Flag, FSM.unitsize);
            // Add a ScoreText element at the bottom of the flag and animate it up
            FSM.addThing(scoreThing, other.right, other.bottom);
            FSM.TimeHandler.addEventInterval(FSM.shiftVert, 1, 72, scoreThing, -FSM.unitsize);
            FSM.TimeHandler.addEvent(FSM.ItemsHolder.increase.bind(FSM.ItemsHolder), 72, "score", scoreAmount);
            // All audio stops, and the flagpole clip is played
            FSM.AudioPlayer.clearAll();
            FSM.AudioPlayer.clearTheme();
            FSM.AudioPlayer.play("Flagpole");
            FSM.TimeHandler.addEventInterval(function () {
                // While the player hasn't reached the bottom yet, slide down
                if (thing.bottom < other.bottom) {
                    FSM.shiftVert(thing, FSM.unitsize);
                    return false;
                }
                // If the flag hasn't reached it but the player has, don't move yet
                if ((other.collection.Flag.bottom | 0) < (other.bottom | 0)) {
                    return false;
                }
                // The player is done climbing: trigger the flag bottom collision
                thing.movement = undefined;
                FSM.setBottom(thing, other.bottom);
                FSM.TimeHandler.cancelClassCycle(thing, "climbing");
                FSM.TimeHandler.addEvent(FSM.ScenePlayer.bindRoutine("HitBottom"), 21);
                return true;
            }, 1, Infinity);
        };
        /**
         * Routine for when a player hits the bottom of a flagpole. It is
         * flipped horizontally, shifted to the other side of the pole, and the
         * animatePlayerOffPole callback is quickly timed.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         */
        FullScreenMario.prototype.cutsceneFlagpoleHitBottom = function (FSM, settings) {
            var thing = settings.player;
            thing.keys.run = 1;
            thing.maxspeed = thing.walkspeed;
            thing.FSM.flipHoriz(thing);
            thing.FSM.shiftHoriz(thing, (thing.width + 1) * thing.FSM.unitsize);
            thing.FSM.TimeHandler.addEvent(function () {
                thing.FSM.AudioPlayer.play("Stage Clear");
                thing.FSM.animatePlayerOffPole(thing, true);
            }, 14);
        };
        /**
         * Routine for counting down time and increasing score at the end of
         * a level. When it's done, it calls the Fireworks routine.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         */
        FullScreenMario.prototype.cutsceneFlagpoleCountdown = function (FSM, settings) {
            FSM.TimeHandler.addEventInterval(function () {
                FSM.ItemsHolder.decrease("time");
                FSM.ItemsHolder.increase("score", 50);
                FSM.AudioPlayer.play("Coin");
                if (FSM.ItemsHolder.getItem("time") > 0) {
                    return false;
                }
                FSM.TimeHandler.addEvent(FSM.ScenePlayer.bindRoutine("Fireworks"), 35);
                return true;
            }, 1, Infinity);
        };
        /**
         * Animation routine for the fireworks found at the end of EndOutsideCastle.
         * Fireworks are added on a timer (if there should be any), and the level
         * transport is called when any fireworks are done.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         */
        FullScreenMario.prototype.cutsceneFlagpoleFireworks = function (FSM, settings) {
            var numFireworks = FSM.MathDecider.compute("numberOfFireworks", settings.time), player = settings.player, detector = settings.detector, doorRight = detector.left, doorLeft = doorRight - FSM.unitsize * 8, doorBottom = detector.bottom, doorTop = doorBottom - FSM.unitsize * 16, flag = FSM.ObjectMaker.make("CastleFlag", {
                "position": "beginning"
            }), flagMovements = 28, fireInterval = 28, fireworkPositions = [
                [0, -48],
                [-8, -40],
                [8, -40],
                [-8, -32],
                [0, -48],
                [-8, -40]
            ], i = 0, firework, position;
            // Add a flag to the center of the castle, behind everything else
            FSM.addThing(flag, doorLeft + FSM.unitsize, doorTop - FSM.unitsize * 24);
            FSM.arrayToBeginning(flag, FSM.GroupHolder.getGroup(flag.groupType));
            // Animate the flag raising
            FSM.TimeHandler.addEventInterval(function () {
                FSM.shiftVert(flag, FSM.unitsize * -.25);
            }, 1, flagMovements);
            // If there should be fireworks, add each of them on an interval
            if (numFireworks > 0) {
                FSM.TimeHandler.addEventInterval(function () {
                    position = fireworkPositions[i];
                    firework = FSM.addThing("Firework", player.left + position[0] * FSM.unitsize, player.top + position[1] * FSM.unitsize);
                    firework.animate(firework);
                    i += 1;
                }, fireInterval, numFireworks);
            }
            // After everything, activate the detector's transport to leave
            FSM.TimeHandler.addEvent(function () {
                FSM.AudioPlayer.addEventImmediate("Stage Clear", "ended", function () {
                    FSM.collideLevelTransport(player, detector);
                    FSM.ScenePlayer.stopCutscene();
                });
            }, i * fireInterval + 420);
        };
        /**
         * Routine for when a player collides with a castle axe. All unimportant NPCs
         * are killed and the player running again is scheduled.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         */
        FullScreenMario.prototype.cutsceneBowserVictoryCollideCastleAxe = function (FSM, settings) {
            var player = settings.player, axe = settings.axe;
            FSM.thingPauseVelocity(player);
            FSM.killNormal(axe);
            FSM.killNPCs();
            FSM.AudioPlayer.clearTheme();
            FSM.MapScreener.nokeys = true;
            FSM.MapScreener.notime = true;
            player.FSM.TimeHandler.addEvent(function () {
                player.keys.run = 1;
                player.maxspeed = player.walkspeed;
                FSM.thingResumeVelocity(player);
                player.yvel = 0;
                FSM.MapScreener.canscroll = true;
                FSM.AudioPlayer.play("World Clear");
            }, 140);
        };
        /**
         * Routine for a castle bridge opening. Its width is reduced repeatedly on an
         * interval until it's 0, at which point the BowserFalls routine plays.
         *
         * @param {FullScreenMario} FSM
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         * @remarks The castle bridge's animateCastleBridgeOpen (called via killNPCs
         *          as the bridge's .killonend attribute) is what triggers this.
         */
        FullScreenMario.prototype.cutsceneBowserVictoryCastleBridgeOpen = function (FSM, settings) {
            var bridge = settings.routineArguments[0];
            FSM.TimeHandler.addEventInterval(function () {
                bridge.right -= FSM.unitsize * 2;
                FSM.setWidth(bridge, bridge.width - 2);
                FSM.AudioPlayer.play("Break Block");
                if (bridge.width <= 0) {
                    FSM.ScenePlayer.playRoutine("BowserFalls");
                    return true;
                }
                return false;
            }, 1, Infinity);
        };
        /**
         * Routine for Bowser falling after his bridge opens.
         *
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         * @param {FullScreenMario} FSM
         * @remarks This is called by the CastleBridgeOpen routine, once the bridge
         *          has been reduced to no width.
         */
        FullScreenMario.prototype.cutsceneBowserVictoryBowserFalls = function (FSM, settings) {
            FSM.AudioPlayer.play("Bowser Falls");
            settings.bowser.nofall = true;
        };
        /**
         * Routine for displaying text above a castle NPC. Each "layer" of text
         * is added in order, after which collideLevelTransport is called.
         *
         * @param {Object} settings   Storage for the cutscene from ScenePlayr.
         * @param {FullScreenMario} FSM
         * @remarks This is called by collideCastleNPC.
         */
        FullScreenMario.prototype.cutsceneBowserVictoryDialog = function (FSM, settings) {
            var player = settings.player, detector = settings.detector, keys = settings.keys, interval = 140, i = 0, j, letters;
            player.keys.run = 0;
            player.FSM.killNormal(detector);
            player.FSM.TimeHandler.addEventInterval(function () {
                letters = detector.collection[keys[i]].children;
                for (j = 0; j < letters.length; j += 1) {
                    if (letters[j].title !== "TextSpace") {
                        letters[j].hidden = false;
                    }
                }
                i += 1;
            }, interval, keys.length);
            player.FSM.TimeHandler.addEvent(function () {
                player.FSM.collideLevelTransport(player, detector);
            }, 280 + interval * keys.length);
        };
        /* Map macros
        */
        /**
         * Sample macro with no functionality, except to console.log a listing of
         * the arguments provided to each macro function.
         * For all real macros, arguments are listed as the keys given as members of
         * the reference object.
         * They also ignore the "x" and "y" arguments, which
         * are the x-location and y-location of the output (and both default to 0),
         * and the "macro" argument, which is listed as their alias.
         *
         * @alias Example
         * @param {Object} reference   A listing of the settings for this macro,
         *                             from an Area's .creation Array. This should
         *                             be treated as const!
         * @param {Object[]} prethings   The Area's actual .creation Array, which
         *                               consists of a bunch of reference Objects.
         * @param {Area} area   The area currently being generated.
         * @param {Map} map   The map containing the area currently being generated.
         */
        FullScreenMario.prototype.macroExample = function (reference, prethings, area, map, scope) {
            console.log("This is a macro that may be called by a map creation.");
            console.log("The arguments are:\n");
            console.log("Reference (the listing from area.creation):  ", reference);
            console.log("Prethings (the area's listing of prethings): ", prethings);
            console.log("Area      (the currently generated area):    ", area);
            console.log("Map       (the map containing the area):     ", map);
            console.log("Scope     (the custom scope container):      ", scope);
        };
        /**
         * Macro to place a single type of Thing multiple times, drawing from a
         * bottom/left corner to a top/right corner.
         *
         * @alias Fill
         * @param {String} thing   The name of the Thing to fill (e.g. "Brick").
         * @param {Number} xnum   How many times to repeat the Thing horizontally
         *                        to the right (defaults to 1)
         * @param {Number} ynum   How many times to repeat the Thing vertically
         *                        upwards (defaults to 1)
         * @param {Number} xwidth   How many units are between the left edges of
         *                          placed Things horizontally (defaults to 0)
         * @param {Number} yheight   How many units are between the top edges of
         *                           placed Things vertically (defaults to 0)
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @example   { "macro": "Fill", "thing": "Brick",
         *              "x": 644, "y": 64, "xnum": 5, "xwidth": 8 }
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroFillPreThings = function (reference, prethings, area, map, scope) {
            var defaults = scope.ObjectMaker.getFullPropertiesOf(reference.thing), xnum = reference.xnum || 1, ynum = reference.ynum || 1, xwidth = reference.xwidth || defaults.width, yheight = reference.yheight || defaults.height, x = reference.x || 0, yref = reference.y || 0, outputs = [], output, o = 0, y, i, j;
            for (i = 0; i < xnum; ++i) {
                y = yref;
                for (j = 0; j < ynum; ++j) {
                    output = {
                        "x": x,
                        "y": y,
                        "macro": undefined
                    };
                    outputs.push(FullScreenMario.prototype.proliferate(output, reference, true));
                    o += 1;
                    y += yheight;
                }
                x += xwidth;
            }
            return outputs;
        };
        /**
         * Macro to continuously place a listing of Things multiple times, from left
         * to right. This is commonly used for repeating background scenery.
         *
         * @alias Pattern
         * @param {String} pattern   The name of the pattern to print, from the
         *                           listing in scope.settings.maps.patterns.
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [repeat]   How many times to repeat the overall pattern
         *                            (by default, 1).
         * @param {Number[]} [skips]   Which numbered items to skip, if any.
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroFillPrePattern = function (reference, prethings, area, map, scope) {
            // Make sure the pattern exists before doing anything
            if (!scope.settings.maps.patterns[reference.pattern]) {
                console.warn("An unknown pattern is referenced: " + reference);
                return;
            }
            var pattern = scope.settings.maps.patterns[reference.pattern], length = pattern.length, defaults = scope.ObjectMaker.getFullProperties(), repeats = reference.repeat || 1, xpos = reference.x || 0, ypos = reference.y || 0, outputs = [], o = 0, skips = {}, prething, output, i, j;
            // If skips are given, record them in an Object for quick access
            if (typeof reference.skips !== "undefined") {
                for (i = 0; i < reference.skips.length; i += 1) {
                    skips[reference.skips[i]] = true;
                }
            }
            // For each time the pattern should be repeated:
            for (i = 0; i < repeats; i += 1) {
                // For each Thing listing in the pattern:
                for (j = 0; j < length; j += 1) {
                    // Don't place if marked in skips
                    if (skips[j]) {
                        continue;
                    }
                    prething = pattern[j];
                    output = {
                        "thing": prething[0],
                        "x": xpos + prething[1],
                        "y": ypos + prething[2]
                    };
                    output.y += defaults[prething[0]].height;
                    if (prething[3]) {
                        output.width = prething[3];
                    }
                    outputs.push(output);
                    o += 1;
                }
                xpos += pattern.width;
            }
            return outputs;
        };
        /**
         * Macro to place a Floor Thing with infinite height. All settings are
         * passed in except "macro", which becomes undefined.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [width]   How wide the Floor should be (by default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroFloor = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, floor = FullScreenMario.prototype.proliferate({
                "thing": "Floor",
                "x": x,
                "y": y,
                "width": (reference.width || 8),
                "height": "Infinity"
            }, reference, true);
            floor.macro = undefined;
            return floor;
        };
        /**
         * Macro to place a Pipe, possibly with a pirahna, location hooks, and/or
         * infinite height. All settings are copied to Pipe except for "macro",
         * which becomes undefined.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Mixed} [height]   How high the Pipe should be (by default, 8).
         *                           May be a Number or "Infinity".
         * @param {Boolean} [piranha]   Whethere there should be a Piranha spawned
         *                              with the Pipe (by default, false).
         * @param {Mixed} [transport]   What location the Pipe should transport to
         *                              (by default, none).
         * @param {Mixed} [entrance]   What location the Pipe should act as an
         *                             entrance to (by default, none).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroPipe = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, height = reference.height || 16, pipe = FullScreenMario.prototype.proliferate({
                "thing": "Pipe",
                "x": x,
                "y": y,
                "width": 16,
                "height": reference.height === Infinity
                    ? "Infinity"
                    : reference.height || 8
            }, reference, true), output = [pipe];
            pipe.macro = undefined;
            if (height === "Infinity" || height === Infinity) {
                pipe.height = scope.MapScreener.height;
            }
            else {
                pipe.y += height;
            }
            if (reference.piranha) {
                output.push({
                    "thing": "Piranha",
                    "x": x + 4,
                    "y": pipe.y + 12,
                    "onPipe": true
                });
            }
            return output;
        };
        /**
         * Macro to place a horizontal Pipe with a vertical one, likely with
         * location hooks.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Mixed} [height]   How high the Pipe should be (by default, 8).
         *                           May be a Number or "Infinity".
         * @param {Mixed} [transport]   What location the Pipe should transport to
         *                              (by default, none).
         * @param {Boolean} [scrollEnabler]   Whether there should be a
         *                                    ScrollEnabler placed on top of the
         *                                    PipeVertical (by default, false).
         * @param {Boolean} [scrollBlocker]   Whether there should be a
         *                                    ScrollBlocker placed to the right of
         *                                    the PipeVertical (by default, false).
         * @return {Object[]}
         * @remarks This could be used in maps like 1-2, but there's no real need to
         *          take the time (unless you're a volunteer and want something to
         *          do!). It was introduced for WorldSeedr generation.
         */
        FullScreenMario.prototype.macroPipeCorner = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, height = reference.height || 16, output = [
                {
                    "thing": "PipeHorizontal",
                    "x": x,
                    "y": y,
                    "transport": reference.transport || 0
                },
                {
                    "thing": "PipeVertical",
                    "x": x + 16,
                    "y": y + height - 16,
                    "height": height
                }
            ];
            if (reference.scrollEnabler) {
                output.push({
                    "thing": "ScrollEnabler",
                    "x": x + 16,
                    "y": y + height + 48,
                    "height": 64,
                    "width": 16
                });
            }
            if (reference.scrollBlocker) {
                output.push({
                    "thing": "ScrollBlocker",
                    "x": x + 32
                });
            }
            return output;
        };
        /**
         * Macro to place a large Tree.
         *
         * @param {Number} width   How wide the Tree should be (preferably a
         *                         multiple of eight
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Boolean} [solidTrunk]   Whether the trunk scenery should be
         *                                 listed in the Solids group instead of
         *                                 Scenery for the sake of overlaps (by
         *                                 default, false).
         * @return {Object[]}
         * @remarks Although the tree trunks in later trees overlap earlier ones,
         *          it's ok because the pattern is indistinguishible when placed
         *          correctly.
         */
        FullScreenMario.prototype.macroTree = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, width = reference.width || 24, output = [
                {
                    "thing": "TreeTop",
                    "x": x,
                    "y": y,
                    "width": width
                }
            ];
            if (width > 16) {
                output.push({
                    "thing": "TreeTrunk",
                    "x": x + 8,
                    "y": y - 8,
                    "width": width - 16,
                    "height": "Infinity",
                    "groupType": reference.solidTrunk ? "Solid" : "Scenery"
                });
            }
            return output;
        };
        /**
         * Macro to place a large Shroom (a Tree that looks like a large Mushroom).
         *
         * @param {Number} width   How wide the Shroom should be (preferably a
         *                         multiple of eight).
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Boolean} [solidTrunk]   Whether the trunk scenery should be
         *                                 listed in the Solids group instead of
         *                                 Scenery for the sake of overlaps (by
         *                                 default, false).
         * @return {Object[]}
         * @remarks Although the shroom trunks in later shrooms overlap earlier
         *          ones, it's ok because the pattern is indistinguishible when
         *          placed correctly.
         */
        FullScreenMario.prototype.macroShroom = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, width = reference.width || 24, output = [
                {
                    "thing": "ShroomTop",
                    "x": x,
                    "y": y,
                    "width": width
                }
            ];
            if (width > 16) {
                output.push({
                    "thing": "ShroomTrunk",
                    "x": x + (width - 8) / 2,
                    "y": y - 8,
                    "height": Infinity,
                    "groupType": reference.solidTrunk ? "Solid" : "Scenery"
                });
            }
            return output;
        };
        /**
         * Macro to place Water of infinite height. All settings are copied to the
         * Water except for "macro", which becomes undefined.
         *
         * @param {Number} width   How wide the Water should be.
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @return {Object}
         */
        FullScreenMario.prototype.macroWater = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = (reference.y || 0) + 2, output = FullScreenMario.prototype.proliferate({
                "thing": "Water",
                "x": x,
                "y": y,
                "height": "Infinity",
                "macro": undefined
            }, reference, true);
            return output;
        };
        /**
         * Macro to place a row of Bricks at y = 88.
         *
         * @param {Number} width   How wide the ceiling should be (eight times the
         *                         number of Bricks).
         * @param {Number} [x]   The x-location (defaults to 0).
         * @return {Object}
         */
        FullScreenMario.prototype.macroCeiling = function (reference) {
            return {
                "macro": "Fill",
                "thing": "Brick",
                "x": reference.x,
                "y": 88,
                "xnum": (reference.width / 8) | 0,
                "xwidth": 8
            };
        };
        /**
         * Macro to place a bridge, possibly with columns at the start and/or end.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [width]   How wide the bridge should be (by default, 16).
         * @param {Boolean} [begin]   Whether the first 8 units should be taken up
         *                            by an infinitely high Stone column (by
         *                            default, false).
         * @param {Boolean} [end]   Whether the last 8 units should be taken up by
         *                          an infinitely high Stone column (by default,
         *                          false).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroBridge = function (reference) {
            var x = reference.x || 0, y = reference.y || 0, width = Math.max(reference.width || 0, 16), output = [];
            // A beginning column reduces the width and pushes it forward
            if (reference.begin) {
                width -= 8;
                output.push({
                    "thing": "Stone",
                    "x": x,
                    "y": y,
                    "height": "Infinity"
                });
                x += 8;
            }
            // An ending column just reduces the width 
            if (reference.end) {
                width -= 8;
                output.push({
                    "thing": "Stone",
                    "x": x + width,
                    "y": y,
                    "height": "Infinity"
                });
            }
            // Between any columns is a BridgeBase with a Railing on top
            output.push({ "thing": "BridgeBase", "x": x, "y": y, "width": width });
            output.push({ "thing": "Railing", "x": x, "y": y + 4, "width": width });
            return output;
        };
        /**
         * Macro to place a scale on the map, which is two Platforms seemingly
         * suspended by Strings.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [widthLeft]   How wide the left Platform should be (by
         *                               default, 24).
         * @param {Number} [widthRight]   How wide the right Platform should be (by
         *                               default, 24).
         * @param {Number} [between]   How much space there should be between
         *                             Platforms (by default, 40).
         * @param {Number} [dropLeft]   How far down from y the left platform should
         *                              start (by default, 24).
         * @param {Number} [dropRight]   How far down from y the right platform
         *                               should start (by default, 24).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroScale = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, unitsize = scope.unitsize, widthLeft = reference.widthLeft || 24, widthRight = reference.widthRight || 24, between = reference.between || 40, dropLeft = reference.dropLeft || 24, dropRight = reference.dropRight || 24, collectionName = "ScaleCollection--" + [
                x, y, widthLeft, widthRight, dropLeft, dropRight
            ].join(","), stringLeft = {
                "thing": "String",
                "x": x,
                "y": y - 4,
                "height": dropLeft - 4,
                "collectionName": collectionName,
                "collectionKey": "stringLeft"
            }, stringRight = {
                "thing": "String",
                "x": x + between,
                "y": y - 4,
                "height": dropRight - 4,
                "collectionName": collectionName,
                "collectionKey": "stringRight"
            }, stringMiddle = {
                "thing": "String",
                "x": x + 4,
                "y": y,
                "width": between - 7,
                "collectionName": collectionName,
                "collectionKey": "stringMiddle"
            }, cornerLeft = {
                "thing": "StringCornerLeft",
                "x": x,
                "y": y
            }, cornerRight = {
                "thing": "StringCornerRight",
                "x": x + between - 4,
                "y": y
            }, platformLeft = {
                "thing": "Platform",
                "x": x - (widthLeft / 2),
                "y": y - dropLeft,
                "width": widthLeft,
                "inScale": true,
                "tension": (dropLeft - 1.5) * unitsize,
                "onThingAdd": scope.spawnScalePlatform,
                "collectionName": collectionName,
                "collectionKey": "platformLeft"
            }, platformRight = {
                "thing": "Platform",
                "x": x + between - (widthRight / 2),
                "y": y - dropRight,
                "width": widthRight,
                "inScale": true,
                "tension": (dropRight - 1.5) * unitsize,
                "onThingAdd": scope.spawnScalePlatform,
                "collectionName": collectionName,
                "collectionKey": "platformRight"
            };
            return [
                stringLeft,
                stringRight,
                stringMiddle,
                cornerLeft,
                cornerRight,
                platformLeft,
                platformRight
            ];
        };
        /**
         * Macro to place what appears to be a PlatformGenerator on the map (in
         * actuality, it is multiple Platforms vertically that know how to respawn).
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [direction]   What direction to travel (either -1 or 1;
         *                               defaults to 1).
         * @param {Number} [width]   How wide the Platforms should be (by default,
         *                           16).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroPlatformGenerator = function (reference, prethings, area, map, scope) {
            var output = [], direction = reference.direction || 1, levels = direction > 0 ? [0, 48] : [8, 56], width = reference.width || 16, x = reference.x || 0, yvel = direction * scope.unitsize * .42, i;
            for (i = 0; i < levels.length; i += 1) {
                output.push({
                    "thing": "Platform",
                    "x": x,
                    "y": levels[i],
                    "width": width,
                    "yvel": yvel,
                    "movement": scope.movePlatformSpawn
                });
            }
            output.push({
                "thing": "PlatformString",
                "x": x + (width / 2) - .5,
                "y": scope.MapScreener.floor,
                "width": 1,
                "height": scope.MapScreener.height / scope.unitsize
            });
            return output;
        };
        /**
         * Macro to place a Warp World group of Pipes, Texts, Piranhas, and
         * detectors.
         *
         * @param {String[]} warps   The map names each Pipe should warp to.
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [textHeight]   How far above the Piranhas to place the
         *                                CustomText labels (by default, 8).
         *
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroWarpWorld = function (reference, prethings, area, map, scope) {
            var output = [], x = reference.x || 0, y = reference.y || 0, textHeight = reference.hasOwnProperty("textHeight") ? reference.textHeight : 8, warps = reference.warps, collectionName = "WarpWorldCollection-" + warps.join("."), keys = [], i;
            output.push({
                "thing": "CustomText",
                "x": x + 8,
                "y": y + textHeight + 56,
                "texts": [{
                        "text": "WELCOME TO WARP WORLD!"
                    }],
                "textAttributes": {
                    "hidden": true
                },
                "collectionName": collectionName,
                "collectionKey": "Welcomer"
            });
            output.push({
                "thing": "DetectCollision",
                "x": x + 64,
                "y": y + 174,
                "width": 40,
                "height": 102,
                "activate": scope.activateWarpWorld,
                "collectionName": collectionName,
                "collectionKey": "Detector"
            });
            for (i = 0; i < warps.length; i += 1) {
                keys.push(i);
                output.push({
                    "macro": "Pipe",
                    "x": x + 8 + i * 32,
                    "height": 24,
                    "transport": { "map": warps[i] + "-1" },
                    "collectionName": collectionName,
                    "collectionKey": i + "-Pipe"
                });
                output.push({
                    "thing": "Piranha",
                    "x": x + 12 + i * 32,
                    "y": y + 36,
                    "collectionName": collectionName,
                    "collectionKey": i + "-Piranha"
                });
                output.push({
                    "thing": "CustomText",
                    "x": x + 14 + i * 32,
                    "y": y + 32 + textHeight,
                    "texts": [{
                            "text": String(warps[i])
                        }],
                    "textAttributes": {
                        "hidden": true
                    },
                    "collectionName": collectionName,
                    "collectionKey": i + "-Text"
                });
            }
            if (warps.length === 1) {
                for (i = 2; i < output.length; i += 1) {
                    output[i].x += 32;
                }
            }
            return output;
        };
        /**
         * Macro to place a DetectCollision that will start the map spawning random
         * CheepCheeps intermittently.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [width]   How wide the infinitely tall DetectCollision
         *                           should be (by default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroCheepsStart = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectCollision",
                "x": reference.x || 0,
                "y": scope.MapScreener.floor,
                "width": reference.width || 8,
                "height": scope.MapScreener.height / scope.unitsize,
                "activate": scope.activateCheepsStart
            };
        };
        /**
         * Macro to place a DetectCollision that will stop the map spawning random
         * CheepCheeps intermittently.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [width]   How wide the infinitely tall DetectCollision
         *                           should be (by default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroCheepsStop = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectCollision",
                "x": reference.x || 0,
                "y": scope.MapScreener.floor,
                "width": reference.width || 8,
                "height": scope.MapScreener.height / scope.unitsize,
                "activate": scope.activateCheepsStop
            };
        };
        /**
         * Macro to place a DetectCollision that will start the map spawning random
         * BulletBills intermittently.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [width]   How wide the infinitely tall DetectCollision
         *                           should be (by default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroBulletBillsStart = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectCollision",
                "x": reference.x || 0,
                "y": scope.MapScreener.floor,
                "width": reference.width || 8,
                "height": scope.MapScreener.height / scope.unitsize,
                "activate": scope.activateBulletBillsStart
            };
        };
        /**
         * Macro to place a DetectCollision that will stop the map spawning random
         * BulletBills intermittently.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [width]   How wide the infinitely tall DetectCollision
         *                           should be (by default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroBulletBillsStop = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectCollision",
                "x": reference.x || 0,
                "y": scope.MapScreener.floor,
                "width": reference.width || 8,
                "height": scope.MapScreener.height / scope.unitsize,
                "activate": scope.activateBulletBillsStop
            };
        };
        /**
         * Macro to place a DetectCollision that will tell any current Lakitu to
         * flee the scene.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [width]   How wide the infinitely tall DetectCollision
         *                           should be (by default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroLakituStop = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectCollision",
                "x": reference.x || 0,
                "y": scope.MapScreener.floor,
                "width": reference.width || 8,
                "height": scope.MapScreener.height / scope.unitsize,
                "activate": scope.activateLakituStop
            };
        };
        /**
         * Macro to place a small castle, which is really a collection of sceneries.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Mixed} [transport]   What map or location to shift to after
         *                              ending theatrics (collidePlayerTransport).
         * @param {Number} [walls]   How many CastleWall Things should be placed to
         *                           the right of the castle (by default, 2).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroCastleSmall = function (reference) {
            var output = [], x = reference.x || 0, y = reference.y || 0, i, j;
            // Base filling left
            for (i = 0; i < 2; i += 1) {
                output.push({
                    "thing": "BrickHalf",
                    "x": x + i * 8,
                    "y": y + 4,
                    "position": "end"
                });
                for (j = 1; j < 3; j += 1) {
                    output.push({
                        "thing": "BrickPlain",
                        "x": x + i * 8,
                        "y": y + 4 + j * 8,
                        "position": "end"
                    });
                }
            }
            // Base filling right
            for (i = 0; i < 2; i += 1) {
                output.push({
                    "thing": "BrickHalf",
                    "x": x + 24 + i * 8,
                    "y": y + 4,
                    "position": "end"
                });
                for (j = 1; j < 3; j += 1) {
                    output.push({
                        "thing": "BrickPlain",
                        "x": x + 24 + i * 8,
                        "y": y + 4 + j * 8,
                        "position": "end"
                    });
                }
            }
            // Medium railing left
            output.push({
                "thing": "CastleRailing",
                "x": x,
                "y": y + 24,
                "position": "end"
            });
            // Medium railing center
            for (i = 0; i < 3; i += 1) {
                output.push({
                    "thing": "CastleRailingFilled",
                    "x": x + (i + 1) * 8,
                    "y": y + 24,
                    "position": "end"
                });
            }
            // Medium railing right
            output.push({
                "thing": "CastleRailing",
                "x": x + 32,
                "y": y + 24,
                "position": "end"
            });
            // Top railing
            for (i = 0; i < 3; i += 1) {
                output.push({
                    "thing": "CastleRailing",
                    "x": x + (i + 1) * 8,
                    "y": y + 40,
                    "position": "end"
                });
            }
            // Top bricking
            for (i = 0; i < 2; i += 1) {
                output.push({
                    "thing": "CastleTop",
                    "x": x + 8 + i * 12,
                    "y": y + 36,
                    "position": "end"
                });
            }
            // Door, and detector if required
            output.push({
                "thing": "CastleDoor",
                "x": x + 16,
                "y": y + 20,
                "position": "end"
            });
            if (reference.transport) {
                output.push({
                    "thing": "DetectCollision",
                    "x": x + 24,
                    "y": y + 16,
                    "height": 16,
                    "activate": FullScreenMario.prototype.collideCastleDoor,
                    "transport": reference.transport,
                    "position": "end"
                });
            }
            return output;
        };
        /**
         * Macro to place a large castle, which is really a collection of sceneries
         * underneath a small castle.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Mixed} [transport]   What map or location to shift to after
         *                              ending theatrics (collidePlayerTransport).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroCastleLarge = function (reference) {
            var output = [], x = reference.x || 0, y = reference.y || 0, i, j;
            output.push({
                "macro": "CastleSmall",
                "x": x + 16,
                "y": y + 48
            });
            // CastleWalls left
            for (i = 0; i < 2; i += 1) {
                output.push({
                    "thing": "CastleWall",
                    "x": x + i * 8,
                    "y": y + 48
                });
            }
            // Bottom doors with bricks on top
            for (i = 0; i < 3; i += 1) {
                output.push({
                    "thing": "CastleDoor",
                    "x": x + 16 + i * 16,
                    "y": y + 20,
                    "position": "end"
                });
                for (j = 0; j < 2; j += 1) {
                    output.push({
                        "thing": "BrickPlain",
                        "x": x + 16 + i * 16,
                        "y": y + 28 + j * 8
                    });
                    output.push({
                        "thing": "BrickHalf",
                        "x": x + 16 + i * 16,
                        "y": y + 40 + j * 4
                    });
                }
            }
            // Bottom bricks with doors on top
            for (i = 0; i < 2; i += 1) {
                for (j = 0; j < 3; j += 1) {
                    output.push({
                        "thing": "BrickPlain",
                        "x": x + 24 + i * 16,
                        "y": y + 8 + j * 8
                    });
                }
                output.push({
                    "thing": "CastleDoor",
                    "x": x + 24 + i * 16,
                    "y": y + 44
                });
            }
            // Railing (filled)
            for (i = 0; i < 5; i += 1) {
                output.push({
                    "thing": "CastleRailingFilled",
                    "x": x + 16 + i * 8,
                    "y": y + 48
                });
            }
            // CastleWalls right
            j = reference.hasOwnProperty("walls") ? reference.walls : 2;
            for (i = 0; i < j; i += 1) {
                output.push({
                    "thing": "CastleWall",
                    "x": x + 56 + i * 8,
                    "y": y + 48,
                    "position": "end"
                });
            }
            if (reference.transport) {
                output.push({
                    "thing": "DetectCollision",
                    "x": x + 24,
                    "y": y + 16,
                    "height": 16,
                    "activate": FullScreenMario.prototype.collideCastleDoor,
                    "transport": reference.transport,
                    "position": "end"
                });
            }
            return output;
        };
        /**
         * Macro to place the typical starting Things for the inside of a castle
         * area.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [width]   How wide the entire shebang should be (by
         *                           default, 40).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroStartInsideCastle = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, width = (reference.width || 0) - 40, output = [
                {
                    "thing": "Stone",
                    "x": x,
                    "y": y + 48,
                    "width": 24,
                    "height": Infinity
                },
                {
                    "thing": "Stone",
                    "x": x + 24,
                    "y": y + 40,
                    "width": 8,
                    "height": Infinity
                },
                {
                    "thing": "Stone",
                    "x": x + 32,
                    "y": y + 32,
                    "width": 8,
                    "height": Infinity
                }
            ];
            if (width > 0) {
                output.push({
                    "macro": "Floor",
                    "x": x + 40,
                    "y": y + 24,
                    "width": width
                });
            }
            return output;
        };
        /**
         * Macro to place the typical ending Things for the inside of an outdoor
         * area.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Mixed} [transport]   What map or location to shift to after
         *                              ending theatrics (collidePlayerTransport).
         * @param {Boolean} [large]   Whether this should place a large castle
         *                            instead of a small (by default, false).
         * @param {Number} [castleDistance]   How far from the flagpole to the
         *                                    castle (by default, 24 for large
         *                                    castles and 32 for small).
         * @param {Number} [walls]   For large castles, how many CastleWall Things
         *                           should be placed after (by default, 2).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroEndOutsideCastle = function (reference) {
            var x = reference.x || 0, y = reference.y || 0, collectionName = "EndOutsideCastle-" + [
                reference.x, reference.y, reference.large
            ].join(","), output;
            // Output starts off with the general flag & collision detection
            output = [
                // Initial collision detector
                {
                    "thing": "DetectCollision", x: x, y: y + 108, height: 100,
                    "activate": FullScreenMario.prototype.collideFlagpole,
                    "activateFail": FullScreenMario.prototype.killNormal,
                    "noActivateDeath": true,
                    "collectionName": collectionName,
                    "collectionKey": "DetectCollision"
                },
                // Flag (scenery)
                {
                    "thing": "Flag", "x": x - 4.5, "y": y + 79.5,
                    "collectionName": collectionName,
                    "collectionKey": "Flag"
                },
                {
                    "thing": "FlagTop", "x": x + 1.5, "y": y + 84,
                    "collectionName": collectionName,
                    "collectionKey": "FlagTop"
                },
                {
                    "thing": "FlagPole", "x": x + 3, "y": y + 80,
                    "collectionName": collectionName,
                    "collectionKey": "FlagPole"
                },
                // Bottom stone
                {
                    "thing": "Stone", "x": x, "y": y + 8,
                    "collectionName": collectionName,
                    "collectionKey": "FlagPole"
                },
            ];
            if (reference.large) {
                output.push({
                    "macro": "CastleLarge",
                    "x": x + (reference.castleDistance || 24),
                    "y": y,
                    "transport": reference.transport,
                    "walls": reference.walls || 8
                });
            }
            else {
                output.push({
                    "macro": "CastleSmall",
                    "x": x + (reference.castleDistance || 32),
                    "y": y,
                    "transport": reference.transport
                });
            }
            return output;
        };
        /**
         * Macro to place the typical ending Things for the inside of a castle area.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Mixed} [transport]   What map or location to shift to after
         *                              ending theatrics (collidePlayerTransport).
         * @param {String} [npc]   Which NPC to use (either "Toad" or "Peach";
         *                         "Toad" by default).
         * @param {Boolean} [hard]   Whether Bowser should be "hard" (by default,
         *                           false).
         * @param {String} [spawnType]   What the Bowser's spawnType should be for
         *                               fireball deaths (by default, "Goomba").
         * @param {Boolean} [throwing]   Whether the Bowser is also throwing hammers
         *                               (by default, false).
         * @param {Boolean} [topScrollEnabler]   Whether a ScrollEnabler should be
         *                                       added like the ones at the end of
         *                                       large underground PipeCorners (by
         *                                       default, false).
         * @return {Object[]}
         */
        FullScreenMario.prototype.macroEndInsideCastle = function (reference, prethings, area, map, scope) {
            var x = reference.x || 0, y = reference.y || 0, npc = reference.npc || "Toad", output, texts, keys;
            if (npc === "Toad") {
                keys = ["1", "2"];
                texts = [
                    {
                        "thing": "CustomText",
                        "x": x + 164,
                        "y": y + 64,
                        "texts": [{
                                "text": "THANK YOU MARIO!"
                            }],
                        "textAttributes": {
                            "hidden": true
                        },
                        "collectionName": "endInsideCastleText",
                        "collectionKey": "1"
                    }, {
                        "thing": "CustomText",
                        "x": x + 152,
                        "y": y + 48,
                        "texts": [
                            {
                                "text": "BUT OUR PRINCESS IS IN"
                            }, {
                                "text": "ANOTHER CASTLE!"
                            }],
                        "textAttributes": {
                            "hidden": true
                        },
                        "collectionName": "endInsideCastleText",
                        "collectionKey": "2"
                    }];
            }
            else if (npc === "Peach") {
                keys = ["1", "2", "3"];
                texts = [
                    {
                        "thing": "CustomText",
                        "x": x + 164,
                        "y": y + 64,
                        "texts": [{
                                "text": "THANK YOU MARIO!"
                            }],
                        "textAttributes": {
                            "hidden": true
                        },
                        "collectionName": "endInsideCastleText",
                        "collectionKey": "1"
                    }, {
                        "thing": "CustomText",
                        "x": x + 152,
                        "y": y + 48,
                        "texts": [
                            {
                                "text": "YOUR QUEST IS OVER.",
                                "offset": 12
                            }, {
                                "text": "WE PRESENT YOU A NEW QUEST."
                            }],
                        "textAttributes": {
                            "hidden": true
                        },
                        "collectionName": "endInsideCastleText",
                        "collectionKey": "2"
                    }, {
                        "thing": "CustomText",
                        "x": x + 152,
                        "y": 32,
                        "texts": [
                            {
                                "text": "PRESS BUTTON B",
                                "offset": 8
                            }, {
                                "text": "TO SELECT A WORLD"
                            }],
                        "textAttributes": {
                            "hidden": true
                        },
                        "collectionName": "endInsideCastleText",
                        "collectionKey": "3"
                    }];
            }
            output = [
                { "thing": "Stone", "x": x, "y": y + 88, "width": 256 },
                { "macro": "Water", "x": x, "y": y, "width": 104 },
                // Bridge & Bowser area
                { "thing": "CastleBridge", "x": x, "y": y + 24, "width": 104 },
                {
                    "thing": "Bowser", "x": x + 69, "y": y + 42,
                    "hard": reference.hard,
                    "spawnType": reference.spawnType || "Goomba",
                    "throwing": reference.throwing
                },
                { "thing": "CastleChain", "x": x + 96, "y": y + 32 },
                // Axe area
                { "thing": "CastleAxe", "x": x + 104, "y": y + 40 },
                { "thing": "ScrollBlocker", "x": x + 112 },
                { "macro": "Floor", "x": x + 104, "y": y, "width": 152 },
                {
                    "thing": "Stone", "x": x + 104, "y": y + 32,
                    "width": 24, "height": 32
                },
                {
                    "thing": "Stone", "x": x + 112, "y": y + 80,
                    "width": 16, "height": 24
                },
                // Peach's Magical Happy Chamber of Fantastic Love
                {
                    "thing": "DetectCollision", "x": x + 180,
                    "activate": scope.collideCastleNPC,
                    "transport": reference.transport,
                    "collectionName": "endInsideCastleText",
                    "collectionKey": "npc",
                    "collectionKeys": keys
                },
                { "thing": npc, "x": x + 200, "y": 13 },
                { "thing": "ScrollBlocker", "x": x + 256 }
            ];
            if (reference.topScrollEnabler) {
                output.push({
                    "thing": "ScrollEnabler",
                    "x": x + 96, "y": y + 140,
                    "height": 52, "width": 16
                });
                output.push({
                    "thing": "ScrollEnabler",
                    "x": x + 240, "y": y + 140,
                    "height": 52, "width": 16
                });
            }
            output.push.apply(output, texts);
            return output;
        };
        /**
         * Macro to place a DetectSpawn that will call activateSectionBefore to
         * start a stretch section.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [section]   Which of the area's sections to spawn (by
         *                             default, 0).
         * @return {Object}
         */
        FullScreenMario.prototype.macroSection = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectSpawn",
                "x": reference.x || 0,
                "y": reference.y || 0,
                "activate": scope.activateSectionBefore,
                "section": reference.section || 0
            };
        };
        /**
         * Macro to place a DetectCollision to mark the current section as passed.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [width]   How wide the DetectCollision should be (by
         *                           default, 8).
         * @param {Number} [height]   How high the DetectCollision should be (by
         *                            default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroSectionPass = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectCollision",
                "x": reference.x || 0,
                "y": reference.y || 0,
                "width": reference.width || 8,
                "height": reference.height || 8,
                "activate": function (thing) {
                    thing.FSM.AudioPlayer.play("Coin");
                    thing.FSM.MapScreener.sectionPassed = true;
                }
            };
        };
        /**
         * Macro to place a DetectCollision to mark the current section as failed.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [width]   How wide the DetectCollision should be (by
         *                           default, 8).
         * @param {Number} [height]   How high the DetectCollision should be (by
         *                            default, 8).
         * @return {Object}
         */
        FullScreenMario.prototype.macroSectionFail = function (reference, prethings, area, map, scope) {
            return [
                {
                    "thing": "DetectCollision",
                    "x": reference.x,
                    "y": reference.y,
                    "width": reference.width || 8,
                    "height": reference.height || 8,
                    "activate": function (thing) {
                        thing.FSM.AudioPlayer.play("Fail");
                        thing.FSM.MapScreener.sectionPassed = false;
                    }
                }
            ];
        };
        /**
         * Macro to place a DetectSpawn that will spawn a following section based on
         * whether the current one was marked as passed or failed.
         *
         * @param {Number} [x]   The x-location (defaults to 0).
         * @param {Number} [y]   The y-location (defaults to 0).
         * @param {Number} [pass]   Which section to spawn if passed (by default,
         *                          0).
         * @param {Number} [fail]   Which section to spawn if failed (by default,
         *                          0).
         * @return {Object}
         */
        FullScreenMario.prototype.macroSectionDecider = function (reference, prethings, area, map, scope) {
            return {
                "thing": "DetectSpawn",
                "x": reference.x || 0,
                "y": reference.y || 0,
                "activate": function (thing) {
                    if (thing.FSM.MapScreener.sectionPassed) {
                        thing.section = reference.pass || 0;
                    }
                    else {
                        thing.section = reference.fail || 0;
                    }
                    thing.FSM.activateSectionBefore(thing);
                }
            };
        };
        /* Miscellaneous utilities
        */
        /**
         * Ensures the current object is a GameStartr by throwing an error if it
         * is not. This should be used for functions in any GameStartr descendants
         * that have to call 'this' to ensure their caller is what the programmer
         * expected it to be.
         *
         * @param {Mixed} current
         */
        FullScreenMario.prototype.ensureCorrectCaller = function (current) {
            if (!(current instanceof FullScreenMario)) {
                throw new Error("A function requires the scope ('this') to be the "
                    + "manipulated FullScreenMario object. Unfortunately, 'this' is a "
                    + typeof (this) + ".");
            }
            return current;
        };
        // For the sake of reset functions, constants are stored as members of the 
        // FullScreenMario Function itself - this allows prototype setters to use 
        // them regardless of whether the prototype has been instantiated yet.
        /**
         * Static settings passed to individual reset Functions. Each of these
         * should be filled out separately, after the FullScreenMario class
         * has been declared but before an instance has been instantiated.
         */
        FullScreenMario.settings = {
            "audio": undefined,
            "collisions": undefined,
            "devices": undefined,
            "editor": undefined,
            "generator": undefined,
            "groups": undefined,
            "events": undefined,
            "input": undefined,
            "math": undefined,
            "maps": undefined,
            "mods": undefined,
            "objects": undefined,
            "quadrants": undefined,
            "renderer": undefined,
            "runner": undefined,
            "scenes": undefined,
            "sprites": undefined,
            "statistics": undefined,
            "touch": undefined,
            "ui": undefined
        };
        /**
         * Static unitsize of 4, as that's how Super Mario Bros. is.
         */
        FullScreenMario.unitsize = 4;
        /**
         * Static scale of 2, to exand to two pixels per one game pixel.
         */
        FullScreenMario.scale = 2;
        /**
         * Gravity is always a function of unitsize (and about .48).
         */
        FullScreenMario.gravity = Math.round(12 * FullScreenMario.unitsize) / 100;
        /**
         * Levels of points to award for hopping on / shelling enemies.
         */
        FullScreenMario.pointLevels = [
            100, 200, 400, 500, 800, 1000, 2000, 4000, 5000, 8000
        ];
        /**
         * Useful for custom text Things, where "text!" cannot be a Function name.
         */
        FullScreenMario.customTextMappings = {
            " ": "Space",
            ".": "Period",
            "!": "ExclamationMark",
            ":": "Colon",
            "/": "Slash",
            "©": "Copyright"
        };
        return FullScreenMario;
    })(GameStartr.GameStartr);
    FullScreenMario_1.FullScreenMario = FullScreenMario;
})(FullScreenMario || (FullScreenMario = {}));