maps.js

/* Maps.js */
// Contains functions for creating, populating, and using maps

/* Basic Map Functions */

function resetMaps() {
  var i, j, mapfunc;
  window.currentmap = [1, 1];
  window.defaultsetting = { setting: "Overworld" };

  // Mapfuncs starts off such that [X][Y] is window.WorldXY, if it exists
  window.mapfuncs = new Array(9);
  // For each [i][j], if window.WorldIJ exists, it's used
  // Otherwise it will be queried via AJAX later
  for (var i = 1, j; i <= 9; ++i) {
    mapfunc = mapfuncs[i] = [0, 0, 0, 0, 0];
    for (j = mapfunc.length; j >= 0; --j)
      mapfunc[j] = window["World" + i + "" + j];
  }

  // Random maps are all window functions
  mapfuncs["Random"] = {
    Overworld: WorldRandomOverworld,
    Underworld: WorldRandomUnderworld,
    Underwater: WorldRandomUnderwater,
    Bridge: WorldRandomBridge,
    Sky: WorldRandomSky,
    Castle: WorldRandomCastle,
  };

  // Right now there aren't too many special maps
  mapfuncs["Special"] = {
    Blank: BlankMap,
  };

  // Maps not found, and sounds, are loaded via AJAX
  startLoadingMaps();
}

// A new map, which contains general settings for the game run
function Map() {
  this.underwater =
    this.current_character =
    this.current_solid =
    this.current_scenery =
    this.xloc =
      0;
  this.canscroll = true;
  this.floor = 104;
  this.time = 400; // optionally specified later
  this.curloc = -1;
  this.gravity = gravity;
  this.maxyvel = unitsize * 1.75;
  this.maxyvelinv = this.maxyvel * -2.1;
}

// An Area within a map, which contains the PreThings
function Area(setting, rawfunc) {
  this.creation = rawfunc || function () {};
  this.precharacters = [];
  this.presolids = [];
  this.prescenery = [];
  this.floor = 140;
  this.width = 0;
  this.underwater = false;
  setAreaSetting(this, setting || "");
}
function setAreaSetting(area, setting, sound) {
  map.shifting = true;
  if (arguments.length == 1) {
    setting = arguments[0] || "Overworld";
    area = map.area;
  }
  area.setting = area.background = setting;
  area.theme = setting.split(" ")[0];
  area.fillStyle = getAreaFillStyle(area.setting);
  // Water fixen
  if (area.fillStyle.indexOf("Underwater") != -1) goUnderWater();
  else goOntoLand();

  if (sound) AudioPlayer.playTheme();
  if (gameon) clearAllSprites();
  map.shifting = false;
}

// A location within an Area
// Specifies the entry function and xloc if needed
function Location(area, entry, xloc) {
  this.area = area;
  this.xloc = xloc || 0;
  this.yloc = this.floor = 0;
  // If entry is true, use entryPlain (beginning of level).
  // If it's valid, use it.
  // Otherwise, use entryNormal (drop from top)
  this.entry = entry == true ? entryPlain : entry || entryNormal;
}

// A holder for a thing to be placed in a Location
// Stores the coordinates, constructor, and any other arguments
function PreThing(xloc, yloc, type) {
  this.xloc = xloc;
  this.yloc = yloc;
  this.type = type;
  // Pass any arguments after type into the Thing
  var args = arrayMake(arguments),
    // Blank Things are just basically {}, just with the name Thing in devtools :)
    object = new Thing();
  args[2] = type;
  args = args.splice(2); // args is now [type, arg1, arg2...]
  Thing.apply(object, args);

  this.object = object;
}

/* Map Setting */
// Resets the board and starts
function setMap(one, two) {
  if (!gameon) return;

  // Unless it's ok to, kill the editor
  if (!window.canedit && window.editing) editorClose(true);

  // Remove random stuff
  removeRandomDisplays();

  // If arguments[0] is an array, it's [one, two]
  if (one instanceof Array) {
    two = one[1];
    one = one[0];
  }

  var newcurrentmap = one ? [one, two] : window.currentmap,
    newmap = new Map(),
    func = mapfuncs[newcurrentmap[0]];

  // Create the new map using the mapfunc, making sure it's loaded
  if (!func) {
    log("No such map section exists (yet?):", func);
    return;
  }
  newcurrentmap.func = func = func[newcurrentmap[1]];
  if (!func) {
    log("No such map exists (yet?):", func);
    return;
  }

  // Since the func exists, set and use it
  window.map = newmap;
  window.currentmap = newcurrentmap;
  func(newmap);

  // Set the map variables back to 0
  newmap.areanum = newmap.curloc = /* window.playediting =*/ 0;
  window.area = newmap.area = newmap.areas[0];

  // Save the score if need be
  if (window.player && player.power) storePlayerStats();
  if (window.data) data.scoreold = data.score.amount;

  // Actual resetting is done in shiftToLocation
  shiftToLocation(0);
}

// For ease of transfer
// Random map pipe transports are ["Random", "XXXworld", LocationType]
// LocationType is either 1 (down) or -1 (up)
// Down means Player is moving down; Up means Player is moving up.
function setMapRandom(transport) {
  if (!gameon) return;

  resetSeed();

  // Determine how to get into the map
  if (typeof transport == "string") transport = ["Random", transport];
  else if (!transport) transport = ["Random", "Overworld"];

  // Actually set the map and shift to the location
  setMap(transport[0], transport[1]);

  // Record random-specific stuff
  data.traveledold = data.traveled;
  map.sincechange = map.num_random_sections = 0;
  map.entrancetype = transport[2];
  map.random = true;
  if (map.randname == "Sky") map.exitloc = ["Random", "Overworld", "Down"];
}

/* Map Traversal */
function shiftToLocation(loc) {
  // Make sure this is the right function
  if (map.random && typeof loc != "number") {
    return setMapRandom(loc);
  }
  if (typeof loc == "number") loc = map.locs[loc];

  // Reset everything game-related
  pause();
  resetGameState();
  resetGameScreenPosition();
  resetQuadrants();

  // Set this location's area as current
  map.areanum = loc.area;
  window.area = map.area = map.areas[map.areanum];

  // Clear everything, create the map, then set post-creation settings
  setAreaPreCreation(area);
  area.creation();
  setAreaPostCreation(area);

  // Start off by spawning, then placing Player
  spawnMap();
  player = placePlayer();
  scrollPlayer(loc.xloc * unitsize);
  locMovePreparations(player);
  // Note that some locs will pause manually after this
  unpause();
  // Typically this will do nothing or be from a pipe
  loc.entry(player, loc.entrything);
  // Don't forget the least annoying part of programming this!
  TimeHandler.addEvent(AudioPlayer.playTheme, 2);

  // Texts are bound-check checked periodically for peformance reasons
  TimeHandler.addEventInterval(checkTexts, 117, Infinity);

  // At the end of shiftToLocation, replace with this safer version:
  if (map.area.setting && map.area.setting.indexOf("Castle") !== -1) {
    console.log("🏰 Castle level detected");

    // Try to set up the trigger, with a retry mechanism
    function setupToadTrigger() {
      if (window.ToadDialogueTrigger) {
        ToadDialogueTrigger.triggerAtFlagpole();
        console.log("✅ ToadDialogueTrigger found! Setting up...");

        // Set trigger position for where Toad is
        ToadDialogueTrigger.setTriggerPosition(400, 450);
        ToadDialogueTrigger.start();

        // Add the checking interval
        TimeHandler.addEventInterval(
          function () {
            if (
              window.ToadDialogueTrigger &&
              window.ToadDialogueTrigger.active &&
              window.player
            ) {
              console.log("📍 Mario at:", Math.round(player.left));
              window.ToadDialogueTrigger.check();
            }
          },
          10,
          Infinity
        );

        console.log("✅ ToadDialogueTrigger fully configured");
        return true;
      }
      return false;
    }

    // Try immediately
    if (!setupToadTrigger()) {
      console.log("⏳ ToadDialogueTrigger not ready, retrying...");
      // If it failed, retry after a short delay
      TimeHandler.addEvent(function () {
        if (!setupToadTrigger()) {
          console.error("❌ ToadDialogueTrigger still not found after retry!");
          console.log(
            "Available window properties:",
            Object.keys(window).filter(
              (k) =>
                k.includes("Toad") ||
                k.includes("Dialogue") ||
                k.includes("Relationship")
            )
          );
        }
      }, 3);
    }
  }
}
// To do: add in other stuff
function setAreaPreCreation(area) {
  // Clear the containers
  window.events = [];
  TimeHandler.clearAllEvents();
  window.characters = [];
  window.solids = [];
  window.scenery = [];
  clearTexts();
  area.precharacters = [];
  area.presolids = [];
  area.prescenery = [];

  // Reset the spawn & scroll settings
  map.current_solid =
    map.current_character =
    map.current_scenery =
    map.shifting =
      0;
  map.canscroll = true;

  data.time.amount = map.time;
  data.world.amount = currentmap[0] + "-" + currentmap[1];
  setDataDisplay();
  startDataTime();

  if (map.random) {
    data.world.amount = "Random Map";
    data.world.element.innerHTML = "WORLD<br>Random Map";
  }
}
function clearTexts() {
  if (window.texts)
    for (var i = texts.length - 1; i >= 0; --i)
      if (texts[i]) removeChildSafe(texts[i], body);
  window.texts = [];
}
function setAreaPostCreation() {
  map.current_character = map.current_solid = map.current_scenery = 0;
  area.width = max(area.width, gamescreen.width);

  // Reset gravity and underwater
  map.underwater = map.area.underwater;
  map.jumpmod = 1.056 + 3.5 * map.underwater;
  map.has_lakitu = false;
  TimeHandler.addEvent(setMapGravity, 1);

  // If it's underwater, give it the waves on top and player's bubble event
  if (area.underwater) {
    // Random maps have a block to stop player from swimming too high
    area.presolids.push(new PreThing(0, 0, WaterBlock, area.width));
    // Non-random maps also have a water sprite (randoms set it themselves)
    if (!map.random)
      area.presolids.push(
        new PreThing(0, 16, Sprite, "Water", [area.width / 3, 1])
      );
  }

  // Sort everything using ascending order
  area.presolids.sort(prethingsorter);
  area.precharacters.sort(prethingsorter);
  area.prescenery.sort(prethingsorter);

  // If the area has loops (really just castles), do this.
  if (area.sections && area.sections[0]) {
    setBStretch();
    area.sections.current = 0;
    area.sections[0](area.sections.start);
  }
  // Otherwise, give it a ScrollBlocker at the area.width if it's not a random Sky
  else if (!map.random && area.setting != "Sky") {
    var blocker = new PreThing(area.width, 0, ScrollBlocker);
    area.presolids.push(blocker);
  }

  // The fillstyle is the background color
  area.fillStyle = getAreaFillStyle(area.setting);
}
// Given a setting, returns the background color
function getAreaFillStyle(setting) {
  if (
    stringHas(setting, "Underworld") ||
    stringHas(setting, "Castle") ||
    stringHas(setting, "Night")
  )
    return stringHas(setting, "Underwater") ? "#2038ec" : "black";
  if (stringHas(setting, "Underwater")) return "#2038ec";
  return "#5c94fc";
}
function prethingsorter(a, b) {
  if (a.xloc == b.xloc) return b.yloc - a.yloc;
  else return a.xloc - b.xloc;
}

// Moves generation to a specific location #
function setLocationGeneration(num) {
  map.curloc = num;
  map.refx = map.locs[map.curloc].xloc;
  map.refy = map.locs[map.curloc].yloc + map.floor;
  map.areanum = map.locs[map.curloc].area;
}

/* Gamplay Functions */
// Solids are spawned a little bit before characters
function spawnMap() {
  // Reset dialogue trigger for new level
  window.hasTriggeredToadDialogue = false;
  var area = map.area,
    rightdiff = QuadsKeeper.getOutDifference(),
    screenright = gamescreen.right + rightdiff,
    quadswidtht2 = QuadsKeeper.getQuadWidth() * 2 + rightdiff,
    screenrightpq = screenright + quadswidtht2,
    arr,
    arrlen,
    prething,
    thing,
    current;

  // Spawn characters
  arr = area.precharacters;
  arrlen = arr.length;
  current = map.current_character;
  while (
    arrlen > current &&
    screenright >= (prething = arr[current]).xloc * unitsize
  ) {
    thing = prething.object;
    addThing(
      thing,
      prething.xloc * unitsize - gamescreen.left,
      prething.yloc * unitsize
    );
    thing.placenum = current;
    ++current;
  }
  map.current_character = current;

  // Spawn solids
  arr = area.presolids;
  arrlen = arr.length;
  current = map.current_solid;
  while (
    arrlen > current &&
    screenrightpq >= (prething = arr[current]).xloc * unitsize
  ) {
    thing = prething.object;
    addThing(
      thing,
      prething.xloc * unitsize - gamescreen.left,
      prething.yloc * unitsize
    );
    thing.placenum = current;
    ++current;
  }
  map.current_solid = current;

  // Spawn scenery
  arr = area.prescenery;
  arrlen = arr.length;
  current = map.current_scenery;
  while (
    arrlen > current &&
    screenrightpq >= (prething = arr[current]).xloc * unitsize
  ) {
    thing = prething.object;
    addThing(
      thing,
      prething.xloc * unitsize - gamescreen.left,
      prething.yloc * unitsize
    );
    thing.placenum = current;
    ++current;
  }
  map.current_scenery = current;
}

// Entry Functions
function goToTransport(transport) {
  // Goes to a new map
  if (transport instanceof Array) {
    map.ending = true;
    storePlayerStats();
    pause();
    if (map.random) {
      setMapRandom(transport);
      // entryRandom(player);
    } else setMap(transport);
  }
  // Goes to a new Location
  else shiftToLocation(map.locs[transport]);
}
function entryPlain(me) {
  // pause();
  setLeft(me, unitsizet16);
  setBottom(me, map.floor * unitsize);
  me.nocollide = me.piping = false;
  me.placed = true;
  // unpause();
}
function entryNormal(me) {
  // pause();
  setLeft(me, unitsizet16);
  setTop(me, unitsizet16);
  me.nocollide = me.piping = false;
  me.placed = true;
  // unpause();
}
function entryBlank(me) {
  setLeft(me, unitsizet16);
  setBottom(me, map.floor * unitsize);
  me.nocollide = me.piping = me.movement = false;
  me.placed = me.nofall = me.nocollide = notime = nokeys = true;
  thingStoreVelocity(me);
  clearDataDisplay();
}
function entryRandom(me) {
  data.time.amount = 0;
  data.time.dir = 1;
  updateDataElement(data.time);
  if (map.startwidth) {
    if (!map.nofloor) pushPreFloor(0, 0, map.startwidth);
  } else map.startwidth = 0;
  map.firstRandomThings(map);
  map.randtype((map.startwidth + 1) * 8); //17 * 8
  entryPlain(me);
  addDistanceCounter();
  addSeedDisplay();
  // To do: remember to set the text & width of the curmap datadisplay
  switch (map.entrancetype) {
    case "Down":
      entryNormal(player);
      break;
    case "Up":
      // Use a pipe
      locMovePreparations(player);
      exitPipeVert(
        player,
        addThing(new Thing(Pipe, 32), unitsizet8, (map.floor - 32) * unitsize)
      );
      break;
    case "Vine":
      // Do that vine stuff
      locMovePreparations(player);
      TimeHandler.addEvent(function () {
        enterCloudWorld(player, true);
      }, 1);
      player.nofall = true;
      spawnMap();
      break;
    case "Castle":
      startCastle(player);
      break;
    default:
      // Only reached by Overworld the first time
      // if(map.randname == "Overworld") addThing(new Thing(Sprite, "Castle", 1), unitsizet16 * -1, (map.floor - 88) * unitsize);
      break;
  }
}
function enterCloudWorld(me) {
  // There are four cloud blocks to the left
  // The vine goes up until it has four blocks above the clouds, then waits 2 seconds
  // Player climbs up the left until two blocks from the top, then switches & jumps
  // if(paused) unpause();

  if (map.random) map.exitloc = getAfterSkyTransport();

  var screenbottom = 140 * unitsize,
    screentop = 72 * unitsize;
  me.placed = me.nofall = true;
  setTop(me, screenbottom);
  setLeft(me, unitsize * 30);
  removeClass(me, "jumping");
  addClasses(me, ["climbing", "animated"]);
  me.climbing = TimeHandler.addSpriteCycle(me, ["one", "two"], "climbing");

  me.attached = new Thing(Vine, -1);
  addThing(me.attached, unitsizet32, screenbottom - unitsizet8);

  var movement = setInterval(function () {
    // Vine moving up
    if (me.attached.top <= screentop) {
      clearInterval(movement);
      setTop(me.attached, screentop, true);
      me.attached.movement = false;
      var stopheight = me.attached.top + unitsizet16;
      movement = setInterval(function () {
        // Player moving up
        shiftVert(me, unitsized4 * -1, true);
        if (me.top <= stopheight) {
          // Player stops moving up
          removeClass(me, "animated");
          clearInterval(movement);
          setTop(me, stopheight, true);
          clearInterval(movement);
          setTimeout(function () {
            // Player switches sides
            setLeft(me, unitsize * 36, true);
            addClass(me, "flipped");
            setTimeout(function () {
              // Player hops off
              playerHopsOff(me, me.attached, true);
              TimeHandler.clearClassCycle(me, "climbing");
              me.running = TimeHandler.addSpriteCycle(
                me,
                ["one", "two", "three", "two"],
                "running",
                setPlayerRunningCycler
              );
            }, timer * 28);
          }, timer * 14);
        }
      }, timer);
    }
  }, timer);
}
function walkToPipe() {
  player = placePlayer();
  startWalking(player);
  map.canscroll = false;

  var hasPipingStarted = false;
  var move = setInterval(function () {
    if (player.piping) {
      // We have started piping
      AudioPlayer.pauseTheme();
      // nokeys = player.keys.run = notime = false;
      clearInterval(move);
      player.maxspeed = player.maxspeedsave;
    }
  }, timer);
  unpause();
}
function startWalking(me) {
  me.movement = movePlayer;
  me.maxspeed = me.walkspeed;
  nokeys = notime = me.keys.run = true;
  me.nofall = me.nocollide = false;
}
function intoPipeVert(me, pipe, transport) {
  if (
    !pipe.transport ||
    !me.resting ||
    me.right + unitsizet2 > pipe.right ||
    me.left - unitsizet2 < pipe.left
  )
    return;
  pipePreparations(me);
  switchContainers(me, characters, scenery);
  unpause();
  var move = setInterval(function () {
    shiftVert(me, unitsized4, true);
    if (me.top >= pipe.top) {
      clearInterval(move);
      setTimeout(function () {
        goToTransport(transport);
      }, 700);
    }
  }, timer);
}
function intoPipeHoriz(me, pipe, transport) {
  // If Player isn't resting or swimming, he shouldn't be allowed to pipe
  // (resting may have been cleared at this point, so yvel is how it checks)
  // if(abs(me.yvel) > unitsized8 || !map.underwater) return;

  pipePreparations(me);
  switchContainers(me, characters, scenery);
  unpause();
  var move = setInterval(function () {
    shiftHoriz(me, unitsized4, true);
    if (me.left >= pipe.left) {
      clearInterval(move);
      setTimeout(function () {
        goToTransport(transport);
      }, 700);
    }
  }, timer);
}
function pipePreparations(me) {
  AudioPlayer.pauseTheme();
  AudioPlayer.play("Pipe");
  locMovePreparations(me);
  me.nofall = me.nocollide = nokeys = notime = true;
  me.movement = me.xvel = me.yvel = 0;
}

function locMovePreparations(me) {
  // pause();
  me.keys = new Keys();
  me.nocollide = me.piping = 1;
  me.placed = false;
  removeCrouch();
  removeClass(me, "running");
  removeClass(me, "jumping");
  removeClass(me, "flipped");
}
function startCastle(me) {
  me = me || window.player;
  if (!me) return;
  setBottom(me, unitsize * 56);
  setLeft(me, unitsizet2);
  me.nocollide = me.piping = false;
  me.placed = true;
}
// Exit functions
function exitPipeVert(me, pipe) {
  switchContainers(me, characters, scenery);
  me.nofall = nokeys = notime = true;
  AudioPlayer.play("Pipe");
  setTop(me, pipe.top);
  setMidXObj(me, pipe, true);
  var dy = unitsize / -4,
    move = setInterval(function () {
      shiftVert(me, dy, true);
      if (me.bottom <= pipe.top) {
        switchContainers(me, scenery, characters);
        clearInterval(move);
        me.nocollide = me.piping = me.nofall = nokeys = notime = false;
        me.placed = true;
      }
    }, timer);
}

function endLevel() {
  if (map.ending) return;
  map.ending = true;
  map.random ? setMapRandom(["Random", "Castle"]) : setNextLevelArr(currentmap);
  storePlayerStats();
  pause();
  setMap();
}

function setExitLoc(num) {
  map.exitloc = num;
}

/* Shortcut Functions */
// Most of which call pushPre---
function pushPreThing(type, xloc, yloc, extras, more) {
  var prething = new PreThing(
      map.refx + xloc,
      map.refy - yloc,
      type,
      extras,
      more
    ),
    object = prething.object;
  // Stretch the area's width if it's a solid or character
  if ((object.solid || object.character) && !object.nostretch)
    map.area.width = max(map.area.width, prething.xloc + object.width);
  // Otherwise put it in solids or chars (scenery has its own pushPre*)
  if (object.solid && !object.spawn_as_char) map.area.presolids.push(prething);
  else map.area.precharacters.push(prething);
  return prething;
}
function pushPreScenery(name, xloc, yloc, repx, repy) {
  repx = round(repx || 1);
  repy = round(repy || 1);
  var prething = new PreThing(map.refx + xloc, map.refy - yloc, Sprite, name, [
    repx,
    repy,
  ]);
  prething.yloc -= prething.object.height;
  map.area.prescenery.push(prething);
  return prething;
}
function pushPreScenerySolid(name, xloc, yloc, repx, repy) {
  repx = repx || 1;
  repy = repy || 1;
  var prething = new PreThing(map.refx + xloc, map.refy - yloc, Sprite, name, [
    repx,
    repy,
  ]);
  prething.yloc -= prething.object.height;
  map.area.presolids.push(prething);
  return prething;
}
function pushPreText(settings, xloc, yloc) {
  var prething = new PreThing(
    map.refx + xloc,
    map.refy - yloc,
    FuncSpawner,
    spawnText,
    settings
  );
  map.area.presolids.push(prething);
  return prething;
}

function fillPreThing(
  type,
  xloc,
  yloc,
  numx,
  numy,
  width,
  height,
  extras,
  more
) {
  var x = xloc,
    y;
  for (var i = 0, j; i < numx; ++i) {
    y = yloc;
    for (j = 0; j < numy; ++j) {
      pushPreThing(type, x, y, extras, more);
      y += height;
    }
    x += width;
  }
}

function pushPreFloor(xloc, yloc, length) {
  pushPreThing(Floor, xloc, yloc || 0, length || 1, DtB(yloc, 8));
}

function makeCeiling(xloc, num) {
  num = num || 1;
  for (var i = 0; i < num; ++i) pushPreThing(Brick, xloc + i * 8, ceillev);
}
function makeCeilingCastle(xloc, bwidth, bheight) {
  pushPreThing(Stone, xloc, ceillev, bwidth || 1, bheight || 1);
}

function pushPreBridge(xloc, yloc, length, sides) {
  pushPreScenery("Railing", xloc, yloc, length * 2);
  pushPreThing(BridgeBase, xloc, yloc, length);
  if (sides instanceof Array) {
    if (sides[0]) pushPreThing(Stone, xloc - 8, yloc, 1, 64);
    if (sides[1]) pushPreThing(Stone, xloc + length * 8, yloc, 1, 64);
  }
}

function fillPreWater(xloc, yloc, width) {
  // Water is 3 x 5.5
  var dtb = DtB(yloc),
    numy = ceil(dtb / 5.5),
    dtby = numy * 5;
  pushPreScenery("Water", xloc, yloc - 5.5, (width * 4) / 3);
  pushPreScenery(
    "WaterFill",
    xloc,
    yloc - dtby - 15.5,
    (width * 4) / 3,
    numy + 2
  );
}

function pushPrePlatformGenerator(xloc, width, dir) {
  pushPreThing(PlatformGenerator, xloc, ceilmax + 16, width, dir);
}

// settings = [platwidth, offy1, offy2] (offy is distance from top to platform)
function pushPreScale(xloc, yloc, width, settings) {
  var platwidth = settings[0],
    offx = platwidth * 2,
    offy1 = settings[1] + 1.5,
    offy2 = settings[2] + 1.5,
    me = pushPreThing(Scale, xloc, yloc, width).object;

  // Set the platforms
  platleft = pushPreThing(
    Platform,
    xloc - offx,
    yloc - offy1 * 4,
    platwidth,
    moveFallingScale
  ).object;
  platright = pushPreThing(
    Platform,
    xloc + width * 4 - platwidth - 6,
    yloc - offy2 * 4,
    platwidth,
    moveFallingScale
  ).object;
  platleft.parent = me;
  platright.parent = me;
  platleft.partner = platright;
  platright.partner = platleft;
  platleft.tension = offy1 * unitsizet4 - unitsize * 10;
  platright.tension = offy2 * unitsizet4 - unitsize * 10;

  // Set the tension
  me.tensionleft = offy1 * unitsize;
  me.tensionright = offy2 * unitsize;

  // Add the strings
  platleft.string = pushPreScenery(
    "String",
    xloc,
    yloc - offy1 * 4,
    1,
    (offy1 - 0.5) * 4
  ).object;
  platright.string = pushPreScenery(
    "String",
    xloc + width * 4 - 1,
    yloc - offy2 * 4,
    1,
    (offy2 - 0.5) * 4
  ).object;
}

// worlds gives the pipe [X,Y]
// offset is how far between scrollblocker and main area (8 before first pipe)
// block is whether the screen should be blocked from scrolling to this
function pushPreWarpWorld(xloc, yloc, worlds, offset, block) {
  if (worlds.length == 1) worlds = [-1, worlds[0], -1];
  var startx = (offset || 0) + xloc + 10,
    len = worlds.length,
    pipe,
    i;

  warp = pushPreThing(WarpWorld, xloc, yloc + ceilmax).object;
  var title = pushPreText(
    { innerText: "WELCOME TO WARP ZONE!", style: { visibility: "hidden" } },
    startx,
    58
  );
  warp.texts.push(title.object);

  for (i = 0; i < len; ++i) {
    if (worlds[i] != -1) {
      warp.pipes.push(
        (pipe = pushPrePipe(startx, yloc, 24, true, worlds[i]).object)
      );
      warp.pirhanas.push(pipe.pirhana);
      if (worlds[i] instanceof Array)
        warp.texts.push(
          pushPreText(
            { innerText: worlds[i][0], style: { visibility: "hidden" } },
            startx + 4,
            38
          ).object
        );
    }
    startx += 32;
  }

  if (block) {
    window.block = pushPreThing(ScrollBlocker, xloc, ceilmax);
    pushPreThing(ScrollBlocker, startx + 16, ceilmax);
  }
}

// Can be called either in a map function or during gameplay
function goUnderWater() {
  if (window.map) {
    if (map.area) {
      if (window.player && !map.shifting)
        setAreaSetting(String(map.area.setting || "") + " Underwater");
      map.area.underwater = true;
    }
    setMapGravity();
    TimeHandler.clearEvent(map.bubbling);
    map.bubbling = TimeHandler.addEventInterval(playerBubbles, 96, Infinity);
    map.underwater = true;
  }
}
function goOntoLand() {
  if (map) {
    if (map.area) {
      if (window.player && !map.shifting)
        setAreaSetting(
          map.area.setting.replace("Underwater", "") || "Overworld"
        );
      map.area.underwater = false;
    }
    setMapGravity();
    TimeHandler.clearEvent(map.bubbling);
    map.underwater = false;
  }
}
function setMapGravity() {
  if (window.player) {
    if (map.underwater) player.gravity = gravity / 2.8;
    else player.gravity = gravity;
  }
}

function setBStretch() {
  window.bstretch = gamescreen.width / 8 - 2;
}

/*
 * Specific creation of often-used stuff
 */
// The detector has stuff stored in it, so the animation functions can use them
// Some worlds (8-3, for example) have an unusual distance from flag to castle
// To do: use typical FuncColliders instead of detectors
function endCastleOutside(xloc, yloc, castlevel, wall, dist) {
  xloc = xloc || 0;
  yloc = yloc || 0;
  if (castlevel) castlevel = castlev;
  dist = dist || 20;
  var detect = pushPreThing(FlagDetector, xloc + 7, yloc + 108).object,
    detect2 = pushPreThing(
      CastleDoorDetector,
      xloc + 60 + (castlev == 0) * 8,
      8
    ).object;
  detect.flag = pushPreThing(Flag, xloc + 0.5, yloc + 79.5).object;
  detect.stone = pushPreThing(Stone, xloc + 4, yloc + 8).object;
  detect.top = pushPreThing(FlagTop, xloc + 6.5, 84).object;
  detect.pole = pushPreThing(FlagPole, xloc + 8, 80).object;

  // detect2.castle = pushPreScenery("Castle", xloc + dist, yloc + castlevel).object;
  if (wall) pushPreScenery("CastleWall", xloc + dist + 72, yloc, wall);
  if (castlevel == 0) shiftHoriz(detect2, unitsizet8);

  pushPreCastle(xloc + dist + 16, yloc, castlevel);
}

function startCastleInside() {
  pushPreThing(Stone, 0, 88, 5, 3);
  pushPreThing(Stone, 0, 48, 3, DtB(48, 8));
  pushPreThing(Stone, 24, 40, 1, DtB(40, 8));
  pushPreThing(Stone, 32, 32, 1, DtB(32, 8));
}

function endCastleInside(xloc, last, hard) {
  var collider = pushPreThing(
      FuncCollider,
      xloc + 104,
      48,
      CastleAxeFalls,
      [16, 24]
    ).object,
    axe = (collider.axe = pushPreThing(CastleAxe, xloc + 104, 40).object);
  axe.bridge = pushPreThing(CastleBridge, xloc, 24, 13).object;
  axe.chain = pushPreThing(CastleChain, xloc + 96.5, 32).object;
  axe.bowser = pushPreThing(Bowser, xloc + 69, 42, hard).object;
  pushPreThing(ScrollBlocker, xloc + 112, ceilmax); // 104 + 16

  pushPreThing(Stone, xloc, 88, 32);
  fillPreWater(xloc, 0, 26);
  pushPreFloor(xloc + 104, 32, 3);
  pushPreFloor(xloc + 104, 0, 19);
  pushPreThing(Stone, xloc + 112, 80, 2, 3);

  // Stop that scrolling... again
  pushPreThing(ScrollBlocker, xloc + 256, ceilmax);

  // Place the NPC
  endCastleInsideFinal(xloc, last);
}

// In maps.js

// In maps.js

// This helper function will turn any character into a static, non-moving object.
// In maps.js

// This helper function will turn any character into a static, non-moving object.
// In maps.js

// This helper function will turn any character into a static, non-moving object.
// In maps.js

// This helper function will turn any character into a static, non-moving object.
function freezeCharacterAsNPC(character) {
  character.movement = false; // Stop its unique movement logic
  character.xvel = 0; // Stop horizontal velocity
  character.yvel = 0; // Stop vertical velocity
  character.nofall = true; // Disable gravity
  character.nocollide = true; // Prevent collisions with other characters
  return character; // Return the modified character
}

// This is the final, consolidated function for all castle endings.
function endCastleInsideFinal(xloc, characterName) {
  // This invisible object will trigger the dialogue when touched
  var stopper = pushPreFuncCollider(xloc + 180, collideCastleNPC).object;

  // Create an array to hold the dialogue data
  stopper.dialogueData = [];
  var npc;
  window.currentCastleNPC = stopper;

  // This switch statement chooses the character and STORES the dialogue info
  switch (characterName) {
    case "Peach":
      pushPreThing(Peach, xloc + 194, 12).object;
      stopper.dialogueData.push({
        text: "THANK YOU " + window.player.title.toUpperCase() + "!",
        x: 160,
        y: 66,
      });
      stopper.dialogueData.push({
        text: "YOUR QUEST IS OVER.<BR>WE PRESENT YOU A NEW QUEST.",
        x: 148,
        y: 50,
      });
      stopper.dialogueData.push({
        text: "PRESS BUTTON B<BR>TO SELECT A WORLD.",
        x: 148,
        y: 26,
      });
      break;

    case "Luigi":
      pushPreThing(LuigiNPC, xloc + 194, 8).object;
      stopper.dialogueData.push({ text: "HEY, BRO!", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "YOU HANDLED THAT PRETTY WELL!",
        x: 148,
        y: 50,
      });
      break;

    case "Goomba":
      npc = pushPreThing(Goomba, xloc + 194, 8).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "...", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "NO PRINCESS.<BR>ONLY GOOMBA.",
        x: 148,
        y: 50,
      });
      break;

    case "Koopa":
      npc = pushPreThing(Koopa, xloc + 194, 12).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "WHOA, THANKS!", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "I THOUGHT I WAS A GONER!<BR>...WAIT, YOU'RE NOT ONE OF US!",
        x: 148,
        y: 50,
      });
      break;

    case "HammerBro":
      npc = pushPreThing(HammerBro, xloc + 194, 12).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({
        text: "HEY, WATCH THE HELMET!",
        x: 160,
        y: 66,
      });
      stopper.dialogueData.push({
        text: "THE PRINCESS LEFT<BR>AGES AGO, PAL.",
        x: 148,
        y: 50,
      });
      break;

    case "Bowser":
      npc = pushPreThing(Bowser, xloc + 190, 8).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "FOOL!", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "THAT WAS MY DECOY BROTHER!<BR>YOU'LL NEVER DEFEAT ME!",
        x: 148,
        y: 50,
      });
      break;

    case "Blooper":
      npc = pushPreThing(Blooper, xloc + 194, 12).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "*bloop bloop*", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "(THE PRINCESS IS<BR>SOMEWHERE DRY!)",
        x: 148,
        y: 50,
      });
      break;

    case "CheepCheep":
      npc = pushPreThing(CheepCheep, xloc + 194, 8).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "*glub glub*", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "(WRONG CASTLE,<BR>BUB.)",
        x: 148,
        y: 50,
      });
      break;

    case "Lakitu":
      npc = pushPreThing(Lakitu, xloc + 194, 12).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "NICE AXE SKILLS!", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "TOO BAD I ALREADY<BR>FLEW THE PRINCESS AWAY!",
        x: 148,
        y: 50,
      });
      break;

    case "Spiny":
      npc = pushPreThing(Spiny, xloc + 194, 8).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "OW.", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "THE PRINCESS TOLD ME<BR>NOT TO TALK TO STRANGERS.",
        x: 148,
        y: 50,
      });
      break;

    case "Beetle":
      npc = pushPreThing(Beetle, xloc + 194, 8).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "*Stares blankly*", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "SHE'S NOT HERE. SURPRISE.",
        x: 148,
        y: 50,
      });
      break;

    case "Pirhana":
      npc = pushPreThing(Pirhana, xloc + 194, 12).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "*chomp chomp*", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "I ATE THE PRINCESS.<BR>...JUST KIDDING.",
        x: 148,
        y: 50,
      });
      break;

    case "Podoboo":
      npc = pushPreThing(Podoboo, xloc + 194, 8).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "*fwoosh*", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "THE LAVA IS WARMER<BR>IN THE NEXT CASTLE.",
        x: 148,
        y: 50,
      });
      break;

    case "BulletBill":
      npc = pushPreThing(BulletBill, xloc + 194, 7).object;
      freezeCharacterAsNPC(npc);
      stopper.dialogueData.push({ text: "...", x: 160, y: 66 });
      stopper.dialogueData.push({
        text: "SHE FLEW AWAY.<BR>I'M JEALOUS.",
        x: 148,
        y: 50,
      });
      break;

    default: // This will be Toad
      pushPreThing(Toad, xloc + 194, 12).object;
      stopper.dialogueData.push({
        text: "THANK YOU " + window.player.title.toUpperCase() + "!",
        x: 160,
        y: 66,
      });
      stopper.dialogueData.push({
        text: "BUT OUR PRINCESS IS IN<BR>ANOTHER CASTLE!",
        x: 148,
        y: 50,
      });
      break;
  }
}

function pushPreSectionPass(xloc, yloc, width, height, secnum) {
  var passer = pushPreThing(
      Collider,
      xloc,
      yloc,
      [width, height],
      [sectionPass, sectionColliderInit]
    ).object,
    secnum = map.area.sections.current || 0,
    section = map.area.sections[secnum];

  if (section.numpass) ++section.numpass;
  else section.numpass = 1;

  if (!section.colliders) section.colliders = [passer];
  else section.colliders.push(passer);
}
function pushPreSectionFail(xloc, yloc, width, height, secnum) {
  var failer = pushPreThing(
      Collider,
      xloc,
      yloc,
      [width, height],
      [sectionFail, sectionColliderInit]
    ).object,
    secnum = map.area.sections.current || 0,
    section = map.area.sections[secnum];

  if (!section.colliders) section.colliders = [failer];
  else section.colliders.push(failer);
}
function pushCastleDecider(xloc, secnum) {
  pushPreThing(castleDecider, xloc, ceilmax, xloc, secnum);
}
function sectionColliderInit(me) {
  me.sections = map.area.sections;
  me.parent = me.sections[me.sections.current];
  me.movement = false;
}
function sectionPass(character, collider) {
  if (character.type != "player") return false;
  collider.nocollide = true;
  var parent = collider.parent;
  if (--parent.numpass) return;
  activateSection(collider.parent, true);
}
function sectionFail(character, collider) {
  if (character.type != "player") return false;
  collider.nocollide = true;

  activateSection(collider.parent, false);
}
function activateSection(parent, status) {
  var colliders = parent.colliders;
  for (var i = colliders.length - 1; i >= 0; --i) killNormal(colliders[i]);

  parent.activated = true;
  parent.passed = status;
}

function pushPreTree(xloc, yloc, width) {
  pushPreThing(TreeTop, xloc, yloc, width);
  // Although the tree trunks in later trees overlap earlier ones, it's ok because
  // the pattern is indistinguishible when placed correctly.
  var dtb = DtB(yloc);
  pushPreScenerySolid(
    "TreeTrunk",
    xloc + 8,
    yloc - dtb - 8,
    width - 2,
    dtb / 8
  );
}
function pushPreShroom(xloc, yloc, width) {
  pushPreThing(ShroomTop, xloc, yloc, width);
  var dtb = DtB(yloc - 4);
  pushPreScenery(
    "ShroomTrunk",
    xloc + width * 4 - 4,
    yloc - dtb - 8,
    1,
    dtb / 8
  );
}

function pushPrePipe(xloc, yloc, height, pirhana, intoloc, exitloc) {
  if (!isFinite(height)) {
    height = gamescreen.height;
    yloc -= gamescreen.height;
  }

  var prepipe = pushPreThing(Pipe, xloc, yloc + height, height / 8, intoloc),
    pipe = prepipe.object; /*,
      vert = pushPreThing(PipeVertical, xloc, yloc + height - 8, height - 8)*/

  if (pirhana)
    pipe.pirhana = pushPreThing(Pirhana, xloc + 4, yloc + height + 12).object;
  if (exitloc) {
    map.locs[exitloc].entrything = pipe;
    map.locs[exitloc].xloc = xloc;
  }
  return prepipe;
}

function pushPreCastle(xloc, yloc, big) {
  xloc = xloc || 0;
  yloc = yloc || 0;
  if (big) pushPreCastleBig(xloc, yloc);
  else pushPreCastleSmall(xloc, yloc);
}

// Note: off by 16 or so
function pushPreCastleBig(xloc, yloc) {
  var i, j;
  pushPreCastleSmall(xloc + 16, yloc + 48);
  // Top alternate fillings
  for (i = 0; i < 3; ++i)
    for (j = 0; j < 2; ++j)
      pushPreScenerySolid("BrickPlain", xloc + 16 + i * 16, yloc + 24 + j * 8);
  // Top alternate doors
  for (i = 0; i < 2; ++i)
    pushPreScenerySolid("CastleDoor", xloc + 24 + i * 16, yloc + 24);
  // Top half filling
  for (i = 0; i < 5; ++i)
    if (i == 2) continue;
    else pushPreScenerySolid("BrickHalf", xloc + 16 + i * 8, yloc + 48);

  // Left railings
  for (i = 0; i < 2; ++i)
    pushPreScenerySolid("CastleRailing", xloc + i * 8, yloc + 44);
  // Middle railings
  for (i = 0; i < 5; ++i)
    pushPreScenerySolid("CastleRailingFilled", xloc + 16 + i * 8, yloc + 44);
  // Right railings
  for (i = 5; i < 7; ++i)
    pushPreScenerySolid("CastleRailing", xloc + 16 + i * 8, yloc + 44);

  // Bottom alternate fillings
  for (i = 0; i < 2; ++i)
    for (j = 0; j < 3; ++j)
      pushPreScenerySolid("BrickPlain", xloc + 24 + i * 16, yloc + j * 8);
  // Bottom alternate doors
  for (i = 0; i < 3; ++i)
    pushPreScenerySolid("CastleDoor", xloc + 16 + i * 16, yloc);

  // Left fill
  for (i = 0; i < 2; ++i) {
    for (j = 0; j < 5; ++j)
      pushPreScenerySolid("BrickPlain", xloc + i * 8, yloc + j * 8);
    pushPreScenerySolid("BrickHalf", xloc + i * 8, yloc + 40);
  }

  // Right fill
  for (i = 0; i < 2; ++i) {
    for (j = 0; j < 5; ++j)
      pushPreScenerySolid("BrickPlain", xloc + 56 + i * 8, yloc + j * 8);
    pushPreScenerySolid("BrickHalf", xloc + 56 + i * 8, yloc + 40);
  }

  for (i = 0; i < 3; ++i)
    for (j = 0; j < 2; ++j)
      pushPreScenerySolid("BrickHalf", xloc + 16 + i * 16, yloc + 20 + j * 20);
}

// To do: y u no work scenery
function pushPreCastleSmall(xloc, yloc) {
  var i, j;

  // Top railing
  for (i = 0; i < 3; ++i)
    pushPreScenerySolid("CastleRailing", xloc + 8 + i * 8, yloc + 36);
  // Top bricking
  for (i = 0; i < 2; ++i)
    pushPreScenerySolid("CastleTop", xloc + 8 + i * 12, yloc + 24);
  // Med railing
  pushPreScenerySolid("CastleRailing", xloc, yloc + 20);
  for (i = 1; i <= 3; ++i)
    pushPreScenerySolid("CastleRailingFilled", xloc + i * 8, yloc + 20);
  pushPreScenerySolid("CastleRailing", xloc + 32, yloc + 20);
  // Base filling left
  for (i = 0; i < 2; ++i) {
    // x
    pushPreScenerySolid("BrickHalf", xloc + i * 8, yloc);
    for (
      j = 0;
      j < 2;
      ++j // y
    )
      pushPreScenerySolid("BrickPlain", xloc + i * 8, yloc + 4 + j * 8);
  }
  // Base filling right
  for (i = 0; i < 2; ++i) {
    // x
    pushPreScenerySolid("BrickHalf", xloc + 24 + i * 8, yloc);
    for (
      j = 0;
      j < 2;
      ++j // y
    )
      pushPreScenerySolid("BrickPlain", xloc + 24 + i * 8, yloc + 4 + j * 8);
  }
  // Door
  pushPreScenerySolid("CastleDoor", xloc + 16, yloc);
}

function pushPreFuncCollider(position, func) {
  // Fancy positions are [xloc, yloc, width, height]
  if (position instanceof Array) {
    console.log("position", position);
    return pushPreThing(FuncCollider, position[0], position[1], func, [
      position[2],
      position[3],
    ]);
  }
  // Normally position is xloc
  else return pushPreThing(FuncCollider, position, ceilmax + 40, func);
}
function pushPreFuncSpawner(xloc, func) {
  return pushPreThing(FuncSpawner, xloc, jumplev1, func);
}

function zoneEnableLakitu() {
  map.zone_lakitu = true;
  enterLakitu();
}
function zoneDisableLakitu() {
  if (!map.has_lakitu) return; // killNormal(me);

  var lakitu = map.has_lakitu;
  map.zone_lakitu = map.has_lakitu = false;

  if (!lakitu.lookleft) {
    lakitu.lookleft = true;
    removeClass(lakitu, "flipped");
  }
  lakitu.movement = function (me) {
    me.xvel = max(me.xvel - unitsized32, unitsize * -1);
  };
}
function zoneStartCheeps(xloc) {
  pushPreFuncCollider(xloc, zoneEnableCheeps);
}
function zoneStopCheeps(xloc) {
  pushPreFuncCollider(xloc, zoneDisableCheeps);
}
function zoneEnableCheeps(me) {
  if (map.zone_cheeps || !me.player) return;
  startCheepSpawn();
}
function zoneDisableCheeps(me) {
  if (!me.player) return;
  map.zone_cheeps = false;
}

// This is for patterns
// Sprites will have optional inputs for how many vertically/horizontally
function pushPrePattern(name, xloc, yloc, reps) {
  var xpos = xloc,
    pattern = Scenery.patterns[name],
    info,
    i,
    j;
  for (i = 0; i < reps; ++i) {
    for (j in pattern) {
      // Get the sprite information
      info = pattern[j];
      if (!(info instanceof Array)) continue;
      //[0] is name, [1/2] are x/yloc, [3/4] are repx/y (1 by default)
      pushPreScenery(info[0], xpos + info[1], yloc + info[2], info[3], info[4]);
    }
    xpos += pattern.width;
  }
}

/* Misc. Helpers */

// Distance from the yloc to botmax
//// Assumes yloc is in the form given by mapfuncs - distance from floor
function DtB(yloc, divider) {
  return (yloc + botmax) / (divider || 1);
}

// Used for the editor
function BlankMap(map) {
  map.locs = [new Location(0, entryBlank)];
  map.areas = [
    new Area("Overworld", function () {
      setTimeout(refillCanvas, timer + 2);
    }),
  ];
}

// World11 is kept here to avoid loading
function World11(map) {
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(1),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      var greeter = "";
      greeter +=
        "<div style='width:350px;max-height:189px;background-color:#d64d00;border-radius:7px;box-shadow:3px 3px #efb28b inset, -3px -3px black inset;";
      greeter +=
        'background-image: url("Theme/Greeting.gif"), url("Theme/Greeting.gif"), url("Theme/Greeting.gif"), url("Theme/Greeting.gif");';
      greeter += "background-repeat: no-repeat;";
      greeter +=
        "background-position: 7px 7px, 336px 7px, 7px 168px, 336px 168px";
      greeter += "'>";
      greeter +=
        "  <p style='text-align:left;padding:7px 0 11px 11px;color:#ffcccc;font-family: Super Plumber Bros;font-size:77px;text-shadow:3px 8px black'>";
      greeter += "    <span style='font-size:84px'>super</span>";
      greeter += "    <br><br>"; // To do: make this not so font dependant
      greeter +=
        "    <span style='font-size:81px;line-height:96px'>MARIO BROS.</span>";
      greeter += "  </p>";
      greeter += "</div>";
      greeter +=
        "<div id='boo' style='text-align:right;color:#ffcccc;margin-top:-7px;width:350px;height:35px;'>&copy;1985 NINTENDO</div>";
      greeter +=
        "<p id='explanation' style='text-align:center;<!--/*text-shadow:2px 2px 1px black;*/-->margin-left:7px;'>";
      greeter += "  Move: Arrows/WASD";
      greeter += "  <br>";
      greeter += "  Fire/Sprint: Shift/CTRL";
      greeter += "  <br>";
      greeter += "  Pause/Mute: P/M ";
      // greeter += "  <br>";
      // greeter += "  TOP- " + (localStorage.highscore || "000000");
      greeter += "</p>";
      pushPreText(greeter, 20, 91);

      pushPrePattern("backreg", 0, 0, 5);
      pushPreFloor(0, 0, 69);

      pushPreThing(Block, 128, jumplev1);
      pushPreThing(Brick, 160, jumplev1);
      pushPreThing(Block, 168, jumplev1, Mushroom);
      pushPreThing(Goomba, 176, 8);
      pushPreThing(Brick, 176, jumplev1);
      pushPreThing(Block, 176, jumplev2);
      pushPreThing(Block, 184, jumplev1);
      pushPreThing(Brick, 192, jumplev1);
      pushPrePipe(224, 0, 16, false);
      pushPrePipe(304, 0, 24);
      pushPrePipe(368, 0, 32);
      pushPreThing(Goomba, 340, 8);
      pushPrePipe(368, 0, 32);
      pushPreThing(Goomba, 412, 8);
      pushPreThing(Goomba, 422, 8);
      pushPrePipe(456, 0, 32, false, 2);
      pushPreThing(Block, 512, 40, [Mushroom, 1], true);
      pushPreFloor(568, 0, 15);
      pushPreThing(Brick, 618, jumplev1);
      pushPreThing(Block, 626, jumplev1, Mushroom);
      pushPreThing(Brick, 634, jumplev1);
      pushPreThing(Brick, 640, jumplev2);
      pushPreThing(Goomba, 640, jumplev2 + 8);
      pushPreThing(Brick, 648, jumplev2);
      pushPreThing(Brick, 656, jumplev2);
      pushPreThing(Goomba, 656, jumplev2 + 8);
      pushPreThing(Brick, 664, jumplev2);
      pushPreThing(Brick, 672, jumplev2);
      pushPreThing(Brick, 680, jumplev2);
      pushPreThing(Brick, 688, jumplev2);
      pushPreThing(Brick, 696, jumplev2);
      pushPreFloor(712, 0, 64);
      pushPreThing(Brick, 728, jumplev2);
      pushPreThing(Brick, 736, jumplev2);
      pushPreThing(Brick, 744, jumplev2);
      pushPreThing(Brick, 752, jumplev1, Coin);
      pushPreThing(Block, 752, jumplev2);
      pushPreThing(Goomba, 776, 8);
      pushPreThing(Goomba, 788, 8);
      pushPreThing(Brick, 800, jumplev1);
      pushPreThing(Brick, 808, jumplev1, Star);
      pushPreThing(Block, 848, jumplev1);
      pushPreThing(Koopa, 856, 12);
      pushPreThing(Block, 872, jumplev1);
      pushPreThing(Block, 872, jumplev2, Mushroom);
      pushPreThing(Block, 896, jumplev1);
      pushPreThing(Goomba, 912, 8);
      pushPreThing(Goomba, 924, 8);
      pushPreThing(Brick, 944, jumplev1);
      pushPreThing(Brick, 968, jumplev2);
      pushPreThing(Brick, 976, jumplev2);
      pushPreThing(Brick, 984, jumplev2);
      pushPreThing(Goomba, 992, 8);
      pushPreThing(Goomba, 1004, 8);
      pushPreThing(Goomba, 1024, 8);
      pushPreThing(Goomba, 1036, 8);
      pushPreThing(Brick, 1024, jumplev2);
      pushPreThing(Brick, 1032, jumplev1);
      pushPreThing(Block, 1032, jumplev2);
      pushPreThing(Brick, 1040, jumplev1);
      pushPreThing(Block, 1040, jumplev2);
      pushPreThing(Brick, 1048, jumplev2);
      pushPreThing(Stone, 1072, 8);
      pushPreThing(Stone, 1080, 16, 1, 2);
      pushPreThing(Stone, 1088, 24, 1, 3);
      pushPreThing(Stone, 1096, 32, 1, 4);
      pushPreThing(Stone, 1120, 32, 1, 4);
      pushPreThing(Stone, 1128, 24, 1, 3);
      pushPreThing(Stone, 1136, 16, 1, 2);
      pushPreThing(Stone, 1144, 8);
      pushPreThing(Stone, 1184, 8);
      pushPreThing(Stone, 1192, 16, 1, 2);
      pushPreThing(Stone, 1200, 24, 1, 3);
      pushPreThing(Stone, 1208, 32, 1, 4);
      pushPreThing(Stone, 1216, 32, 1, 4);

      pushPreFloor(1240, 0, 69);
      pushPreThing(Stone, 1240, 32, 1, 4);
      pushPreThing(Stone, 1248, 24, 1, 3);
      pushPreThing(Stone, 1256, 16, 1, 2);
      pushPreThing(Stone, 1264, 8, 1, 1);
      pushPrePipe(1304, 0, 16, false, false, 1);

      pushPreThing(Brick, 1344, jumplev1);
      pushPreThing(Brick, 1352, jumplev1);
      pushPreThing(Block, 1360, jumplev1);
      pushPreThing(Brick, 1368, jumplev1);
      pushPreThing(Goomba, 1392, 8);
      pushPreThing(Goomba, 1404, 8);

      pushPrePipe(1432, 0, 16);
      pushPreThing(Stone, 1448, 8);
      pushPreThing(Stone, 1456, 16, 1, 2);
      pushPreThing(Stone, 1464, 24, 1, 3);
      pushPreThing(Stone, 1472, 32, 1, 4);
      pushPreThing(Stone, 1480, 40, 1, 5);
      pushPreThing(Stone, 1488, 48, 1, 6);
      pushPreThing(Stone, 1496, 56, 1, 7);
      pushPreThing(Stone, 1504, 64, 2, 8);
      endCastleOutside(1580, 0, 1);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(2);
      makeCeiling(32, 7);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 32, 8, 7, 3, 8, 8);
      fillPreThing(Coin, 33, 31, 7, 2, 8, 16);
      fillPreThing(Coin, 41, 63, 5, 1, 8, 8);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
  ];
}

/* Random Maps */
function randMapType(map) {
  map.locs = [new Location(0, entryRandom)];
  map.areas = [
    new Area(map.areatype, function () {
      setLocationGeneration(0);
      if (map.randname == "Underwater") {
        goUnderWater();
        // To do: make a unified function for adding in water & blocker, by the block width
        pushPreScenery(
          "Water",
          0,
          ceilmax - 21,
          ((map.startwidth + 1) * 8) / 3,
          1
        );
        pushPreThing(WaterBlock, 0, ceilmax, (map.startwidth + 1) * 8);
      }
      // if(map.randname == "Sky")
      // map.locs[0].entry = enterCloudWorld
    }),
  ];
  map.treefunc = randTrue(3) ? pushPreTree : pushPreShroom;
  map.treeheight = map.treelev = map.sincechange = 0;
}
function randDayNight() {
  return randTrue(3) ? "" : " Night";
}
function WorldRandomOverworld(map) {
  map.random = true;
  map.randtype = pushRandomSectionOverworld;
  map.randname = "Overworld";
  map.areatype = "Overworld" + randDayNight();
  map.firstRandomThings = function (map) {
    // castle added by entrancetype
    for (var i = 0; i < 10; ++i) {
      if (randTrue()) pushRandomGroundScenery(i * 8);
    }
  };
  map.startwidth = 14;
  map.onlysmartkoopas = false;
  randMapType(map);
}
function WorldRandomTrees(map) {
  map.random = true;
  map.randtype = pushRandomSectionTrees;
  map.randname = "Overworld";
  map.areatype = "Overworld" + randDayNight();
  map.firstRandomThings = function (map) {
    map.treefunc(100, (map.treelev = randTrue() + 2) * 8, randTrue() + 4);
    map.startwidth += 7;
  };
  map.startwidth = 11;
  map.onlysmartkoopas = randTrue();
  randMapType(map);
}
function WorldRandomUnderworld(map) {
  map.random = true;
  map.randtype = pushRandomSectionUnderworld;
  map.randname = map.areatype = "Underworld";
  map.firstRandomThings = function (map) {
    fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
  };
  map.startwidth = randTrue(3) + 7;
  map.onlysmartkoopas = true;
  map.respawndist = 42;
  map.entrancetype = "Up";
  randMapType(map);
}
function WorldRandomUnderwater(map) {
  map.random = true;
  map.randtype = pushRandomSectionUnderwater;
  map.randname = "Underwater";
  map.areatype = "Underwater" + randDayNight();
  map.firstRandomThings = function (map) {};
  map.startwidth = randTrue(3) + 7;
  map.entrancetype = "Up";
  map.countCheep = map.countBlooper = 0;
  map.respawndist = 42;
  map.onlysmartkoopas = true;
  randMapType(map);
}
function WorldRandomBridge(map) {
  map.random = true;
  map.randtype = startRandomSectionBridge;
  map.randname = "Overworld";
  map.areatype = "Overworld" + randDayNight();
  map.firstRandomThings = function (map) {};
  map.startwidth = 14;
  randMapType(map);
}
function WorldRandomSky(map) {
  map.random = true;
  map.randtype = startRandomSectionSky;
  map.randname = "Sky";
  map.areatype = "Sky" + randDayNight();
  map.entrancetype = "Vine";
  map.firstRandomThings = function (map) {
    pushPreThing(Stone, 0, 0, 4);
  };
  map.startwidth = 4;
  map.nofloor = true;
  randMapType(map);
}
function WorldRandomCastle(map) {
  map.random = true;
  map.randtype = startRandomSectionCastle;
  map.randname = map.areatype = map.entrancetype = "Castle";
  map.firstRandomThings = function (map) {
    startCastleInside();
    startCastle();
  };
  map.respawndist = 35;
  randMapType(map);
}

console.log(
  "This is an offline copy of Full Screen player, intended for private testing.",
  "Normally, maps are loaded over-eagerly via AJAX requests; for the sake of offline use,",
  "they have all been copied to the bottom of maps.js instead.",
  "If you wish to make changes to a map, change both maps.js::WorldXY(map) and Maps/WorldXY.js",
  "\n",
  "To use Full Screen Mario normally, delete this log message and all functions after it in maps.js."
);

function World12(map) {
  map.locs = [
    new Location(0, walkToPipe),
    new Location(1),
    new Location(2),
    new Location(1, exitPipeVert),
    new Location(3, exitPipeVert),
    new Location(1, false, 1000),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 1);
      pushPreFloor(0, 0, 24);
      pushPreThing(PipeSide, 80, 16, 1);
      pushPrePipe(96, 0, 32);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(1);

      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      pushPreFloor(0, 0, 80);
      makeCeiling(48, 83);
      pushPreThing(Block, 80, jumplev1, Mushroom);
      fillPreThing(Block, 88, jumplev1, 4, 1, 8, 8);

      pushPreThing(Goomba, 128, 8);
      pushPreThing(Stone, 136, 8);
      pushPreThing(Goomba, 136, 16);
      pushPreThing(Stone, 152, 16, 1, 2);
      pushPreThing(Stone, 168, 24, 1, 3);
      pushPreThing(Stone, 184, 32, 1, 4);
      pushPreThing(Stone, 200, 32, 1, 4);
      pushPreThing(Stone, 216, 24, 1, 3);
      pushPreThing(Goomba, 232, 8);
      pushPreThing(Brick, 232, 40, Coin);
      pushPreThing(Stone, 248, 24, 1, 3);
      pushPreThing(Stone, 264, 16, 1, 2);

      fillPreThing(Brick, 312, 32, 1, 3, 8, 8);
      pushPreThing(Brick, 320, 32);
      pushPreThing(Coin, 321, 39);
      fillPreThing(Brick, 328, 32, 1, 3, 8, 8);
      fillPreThing(Coin, 330, 63, 4, 1, 8, 8);
      pushPreThing(Brick, 336, 48);
      pushPreThing(Brick, 344, 48);
      fillPreThing(Koopa, 352, 12, 2, 1, 12);
      fillPreThing(Brick, 352, 32, 1, 3, 8, 8);

      // pushPreThing(Coin, 360, 62);
      pushPreThing(Brick, 360, 32);
      fillPreThing(Brick, 368, 32, 1, 2, 8, 8);
      pushPreThing(Coin, 361, 39);
      pushPreThing(Brick, 368, 48, Star);
      fillPreThing(Brick, 416, 32, 2, 5, 8, 8);
      fillPreThing(Brick, 432, 16, 2, 3, 8, 8);
      fillPreThing(Brick, 432, 72, 2, 2, 8, 8);
      fillPreThing(Brick, 464, 32, 4, 1, 8, 8);
      fillPreThing(Brick, 464, 72, 5, 2, 8, 8);
      fillPreThing(Coin, 465, 39, 4, 1, 8, 8);
      pushPreThing(Koopa, 472, 12);
      fillPreThing(Brick, 496, 32, 2, 7, 8, 8);
      pushPreThing(Goomba, 494, 8);
      pushPreThing(Goomba, 510, 8);

      fillPreThing(Brick, 528, 72, 4, 2, 8, 8);
      fillPreThing(Brick, 536, 32, 1, 5, 8, 8);
      fillPreThing(Brick, 544, 32, 2, 1, 8, 8);
      pushPreThing(Coin, 545, 39);
      pushPreThing(Brick, 552, 40, Mushroom);

      fillPreThing(Brick, 576, 32, 2, 1, 8, 8);
      pushPreThing(Brick, 576, 40);
      fillPreThing(Brick, 576, 48, 2, 3, 8, 8);
      pushPreThing(Brick, 584, 40, Coin);
      pushPreThing(Goomba, 584, 72);

      fillPreThing(Brick, 608, 32, 4, 1, 8);
      fillPreThing(Brick, 608, 72, 4, 2, 8);
      fillPreThing(Goomba, 608, 40, 2, 1, 12);

      pushPreFloor(664, 0, 34);
      fillPreThing(Brick, 672, 40, 6, 2, 8, 8);
      fillPreThing(Coin, 674, 64, 6, 1, 8, 8);
      pushPreThing(Brick, 712, 88, [Mushroom, 1]);
      makeCeiling(720, 45);
      fillPreThing(Goomba, 768, 8, 3, 1, 12, 8);
      pushPrePipe(800, 0, 24, true, 2);
      pushPrePipe(848, 0, 32, true);
      pushPreThing(Goomba, 872, 8);
      pushPrePipe(896, 0, 16, true, false, 3);

      pushPreFloor(952, 0, 2);
      fillPreThing(Brick, 952, 8, 2, 3, 8, 8);

      pushPreFloor(984, 0, 12);
      pushPreThing(Stone, 1040, 8);
      pushPreThing(Stone, 1048, 16, 1, 2);
      pushPreThing(Stone, 1056, 24, 1, 3);
      pushPreThing(Goomba, 1056, 32);
      pushPreThing(Stone, 1064, 32, 1, 4);
      pushPreThing(Goomba, 1064, 48);
      pushPreThing(Stone, 1072, 32, 1, 4);
      pushPrePlatformGenerator(1096, 6, 1);
      // pushPreThing(PlatformGenerator, 1096, ceilmax, 6, 1);

      pushPreFloor(1144, 0, 8);
      fillPreThing(Brick, 1144, 40, 5, 1, 8, 8);
      pushPreThing(Koopa, 1152, 12, true);
      pushPreThing(Brick, 1184, 40, Mushroom);
      pushPrePlatformGenerator(1224, 6, -1);
      // pushPreThing(PlatformGenerator, 1224, ceilmax, 6, -1);

      pushPreFloor(1266, 0, 32);
      fillPreThing(Brick, 1266, 8, 17, 3, 8, 8);
      pushPreThing(PipeSide, 1314, 40, 4);
      pushPreThing(PipeVertical, 1330, 88, 64);
      makeCeiling(1274, 7);
      fillPreThing(Brick, 1346, 32, 7, 7, 8, 8);
      pushPreThing(ScrollEnabler, 1340, ceilmax);
      makeCeiling(1346, 17);
      pushPreWarpWorld(
        1400,
        0,
        [
          [4, 1],
          [3, 1],
          [2, 1],
        ],
        0,
        true
      );
      fillPreThing(Brick, 1506, 8, 2, 11, 8, 8);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(2);

      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Coin, 25, 7, 9, 1, 8, 8);
      fillPreThing(Brick, 24, 32, 9, 1, 8, 8);
      fillPreThing(Coin, 33, 39, 8, 1, 8, 8);
      pushPreThing(Brick, 96, 32, Coin);
      fillPreThing(Brick, 24, 64, 10, 4, 8, 8);
      fillPreThing(Brick, 104, 24, 2, 9, 8, 8);
      pushPreThing(PipeSide, 104, 16, 3);
      pushPreThing(PipeVertical, 120, 100, 100);
    }),
    new Area("Overworld", function () {
      setLocationGeneration(4);

      pushPrePattern("backreg", 104, 0, 1);
      pushPreFloor(0, 0, 58);
      pushPrePipe(0, 0, 16, true, false, 4);
      pushPreThing(Stone, 16, 8);
      pushPreThing(Stone, 24, 16, 1, 2);
      pushPreThing(Stone, 32, 24, 1, 3);
      pushPreThing(Stone, 40, 32, 1, 4);
      pushPreThing(Stone, 48, 40, 1, 5);
      pushPreThing(Stone, 56, 48, 1, 6);
      pushPreThing(Stone, 64, 56, 1, 7);
      pushPreThing(Stone, 72, 64, 2, 8);
      endCastleOutside(148);
    }),
  ];
}

function World13(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 5);
      pushPreFloor(0, 0, 16);

      pushPreTree(144, 8, 4);
      pushPreTree(192, 32, 8);
      pushPreTree(208, 64, 5);
      fillPreThing(Coin, 217, 71, 3, 1, 8, 8, true);
      pushPreThing(Koopa, 240, 76, true);
      pushPreTree(256, 8, 3);
      pushPreThing(Coin, 266, 15);
      pushPreTree(280, 40, 5);
      fillPreThing(Coin, 297, 87, 2, 1, 8);
      pushPreTree(320, 72, 7);
      fillPreThing(Goomba, 352, 80, 2, 1, 16);
      pushPreTree(400, 0, 4);
      fillPreThing(Coin, 402, 55, 2, 1, 8, 8);
      pushPreThing(Platform, 440, 56, 6, [moveFloating, -4, 56]);
      pushPreTree(472, 0, 5);
      pushPreThing(Block, 472, 24, Mushroom);
      pushPreTree(480, 64, 4);
      fillPreThing(Coin, 482, 71, 4, 1, 8);
      pushPreTree(520, 0, 5);
      pushPreTree(560, 32, 3);
      pushPreThing(Koopa, 592, 76, true, [16, 88]);
      pushPreTree(608, 56, 6);
      pushPreThing(Goomba, 640, 64);
      fillPreThing(Coin, 681, 63, 2, 1, 8, 8);
      pushPreThing(Platform, 688, 40, 6, [moveSliding, 660, 720]);
      fillPreThing(Coin, 745, 71, 2, 1, 8, 8);
      pushPreThing(Platform, 752, 32, 6, [moveSliding, 700, 776]);
      fillPreThing(Coin, 777, 71, 2, 1, 8, 8);
      pushPreTree(784, 16, 4);
      pushPreTree(832, 48, 8);
      pushPreThing(Koopa, 880, 60, true);
      pushPreTree(904, 0, 3);
      fillPreThing(Coin, 906, 7, 3, 1, 8, 8);
      pushPreThing(Koopa, 912, 68, true, [4, 76]);
      pushPreTree(928, 32, 4);
      fillPreThing(Coin, 962, 63, 2, 1, 8, 8);
      pushPreTree(976, 32, 4);

      pushPreFloor(1032, 0, 46);
      pushPreThing(Platform, 1048, 56, 6, [moveSliding, 1008, 1076]);
      pushPreThing(Koopa, 1064, 12, true);
      pushPreThing(Stone, 1104, 32, 1, 4);
      pushPreThing(Stone, 1112, 32, 1, 4);
      pushPreThing(Stone, 1120, 48, 1, 6);
      pushPreThing(Stone, 1128, 48, 1, 6);
      pushPreThing(Stone, 1136, 64, 1, 8);
      pushPreThing(Stone, 1144, 64, 1, 8);

      endCastleOutside(1220, 0, true, 11);
    }),
  ];
}

function World14(map) {
  map.time = 300;
  map.locs = [new Location(0, startCastle)];
  map.areas = [
    new Area("Castle", function () {
      setLocationGeneration(0);
      startCastleInside();
      pushPreThing(Stone, 40, 88, 19, 3);
      pushPreFloor(40, 24, 8);
      fillPreWater(104, 8, 4);
      pushPreFloor(120, 24, 11);
      pushPreThing(Stone, 184, 64, 1, 1);
      pushPreThing(CastleBlock, 184, 56);
      makeCeilingCastle(192, 136);
      fillPreWater(208, 0, 6);
      pushPreFloor(232, 24, 3);
      pushPreThing(CastleBlock, 240, 24, 6);
      pushPreThing(Block, 240, 56, Mushroom);
      fillPreWater(256, 0, 6);
      pushPreThing(Stone, 280, 32, 37, 1);
      pushPreThing(Stone, 280, 24, 69, 3);
      pushPreFloor(280, 0, 93);
      pushPreThing(Stone, 296, 80, 35, 3);
      pushPreThing(CastleBlock, 296, 56);
      pushPreThing(CastleBlock, 392, 56, 6);
      pushPreThing(CastleBlock, 480, 56, 6);
      pushPreThing(CastleBlock, 536, 56, 6);
      pushPreThing(CastleBlock, 608, 32, 6);
      pushPreThing(Stone, 640, 80, 1, 1);
      pushPreThing(CastleBlock, 640, 72);
      pushPreThing(CastleBlock, 672, 32, 6);
      pushPreThing(Stone, 704, 80, 1, 1);
      pushPreThing(CastleBlock, 704, 72, 6, true);
      pushPreThing(CastleBlock, 736, 32);
      pushPreThing(Stone, 776, 80, 7, 2);
      pushPreThing(Block, 848, 32, Coin, true);
      pushPreThing(Block, 872, 32, Coin, true);
      pushPreThing(Block, 896, 32, Coin, true);
      pushPreThing(Block, 856, 64, Coin, true);
      pushPreThing(Block, 880, 64, Coin, true);
      pushPreThing(Block, 904, 64, Coin, true);
      pushPreThing(Stone, 928, 24, 4, 3);
      pushPreThing(Stone, 984, 24, 5, 3);
      pushPreThing(Stone, 984, 80, 5, 2);

      endCastleInside(1024, "Toad");

      pushPreThing(Platform, 1108, 56, 4, [
        moveSliding,
        1080,
        1112,
      ]).object.nocollidechar = true;

      // REMOVE THE TRIGGER CODE FROM HERE
    }),
  ];
}

function World21(map) {
  map.locs = [
    new Location(0, true),
    new Location(0, false, 1260),
    new Location(0, exitPipeVert),
    new Location(1, enterCloudWorld),
    new Location(2),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle(0, 0, true);
      pushPrePattern("backfence", 0, 0, 2);
      pushPrePattern("backfencemin", 768, 0, 1);
      pushPrePattern("backfence", 1152, 0, 2);

      pushPreFloor(0, 0, 92);
      pushPreThing(Brick, 120, jumplev1);
      pushPreThing(Brick, 128, jumplev1, Mushroom);
      pushPreThing(Brick, 136, jumplev1);
      pushPreThing(Stone, 160, 8);
      pushPreThing(Stone, 168, 16, 1, 2);
      pushPreThing(Stone, 176, 24, 1, 3);
      pushPreThing(Stone, 184, 32, 1, 4);
      pushPreThing(Stone, 192, 40, 1, 5);
      pushPreThing(Goomba, 192, 48);
      pushPreThing(Block, 224, jumplev1, false, true);
      pushPreThing(Block, 224, jumplev2, [Mushroom, 1], true);
      fillPreThing(Brick, 232, jumplev2, 3, 1, 8, 8);
      pushPreThing(Koopa, 256, 12);
      pushPreThing(Koopa, 264, 12);
      pushPreThing(Stone, 272, 32, 1, 4);
      pushPreThing(Stone, 280, 16, 1, 2);
      pushPreThing(Goomba, 336, 8);
      pushPreThing(Goomba, 348, 8);
      pushPrePipe(368, 0, 32, true);
      pushPreThing(Block, 424, jumplev1, Mushroom);
      fillPreThing(Block, 424, jumplev2, 5, 1, 8, 8);
      fillPreThing(Block, 432, jumplev1, 4, 1, 8, 8);
      pushPreThing(Goomba, 472, 8);
      pushPreThing(Goomba, 484, 8);
      pushPreThing(Koopa, 528, 12);
      fillPreThing(Goomba, 544, 8, 3, 1, 12, 8);
      pushPreThing(Brick, 544, jumplev1);
      pushPreThing(Brick, 552, jumplev2, Star);
      fillPreThing(Brick, 560, jumplev2, 3, 1, 8, 8);

      pushPrePipe(592, 0, 32, true);
      fillPreThing(Block, 632, jumplev1, 4, 1, 8, 8);
      fillPreThing(Brick, 648, jumplev2, 2, 1, 8, 8);
      pushPreThing(Brick, 664, jumplev2, [Vine, 3]);
      fillPreThing(Brick, 672, jumplev2, 2, 1, 8, 8);
      fillPreThing(Block, 680, jumplev1, 3, 1, 8, 8);
      fillPreThing(Goomba, 704, 8, 3, 1, 12, 8);

      fillPreThing(Brick, 736, jumplev2, 4, 1, 8, 8);
      pushPreFloor(768, 0, 10);
      pushPreThing(Goomba, 820, 40, 8, 8);
      pushPrePipe(824, 0, 32, true, 4);

      pushPreFloor(872, 0, 30);
      pushPreThing(Goomba, 916, 24, 8, 8);
      pushPrePipe(920, 0, 16, true, false, 2);
      pushPreThing(Goomba, 962, 8);
      pushPrePipe(976, 0, 32, true);
      pushPreThing(Brick, 1000, jumplev2, Mushroom);
      fillPreThing(Brick, 1008, jumplev2, 3, 1, 8, 8);
      pushPrePipe(1008, 0, 24);
      pushPrePipe(1040, 0, 40, true);
      pushPreThing(Koopa, 1096, 12);

      pushPreFloor(1136, 0, 10);
      pushPreThing(Koopa, 1200, 36, false, true);

      pushPreFloor(1232, 0, 72);
      pushPreThing(Stone, 1232, 24, 1, 3);
      pushPreThing(Brick, 1288, jumplev1, Coin);
      fillPreThing(Goomba, 1296, 8, 2, 1, 12);
      fillPreThing(Brick, 1312, jumplev2, 5, 1, 8);
      fillPreThing(Koopa, 1352, 12, 2, 1, 16);
      pushPreThing(Block, 1360, jumplev1);
      pushPreThing(Block, 1374, jumplev2, Mushroom);
      pushPrePipe(1408, 0, 24, true);
      pushPreThing(Koopa, 1480, 12);
      fillPreThing(Brick, 1480, jumplev1, 2, 1, 8);
      pushPreThing(Block, 1488, jumplev2, Coin, true);
      pushPreThing(Springboard, 1504, 14.5);
      fillPreThing(Stone, 1520, 80, 2, 1, 8, 8, 1, 10);
      endCastleOutside(1596);
    }),
    new Area("Sky", function () {
      setLocationGeneration(3);

      pushPreThing(Stone, 0, 0, 4);
      pushPreThing(Stone, 40, 0, 72);
      pushPreThing(Platform, 120, 32, 8, collideTransport);
      fillPreThing(Coin, 120, 64, 16, 1, 8);
      fillPreThing(Coin, 256, 80, 3, 1, 8);
      fillPreThing(Coin, 288, 72, 16, 1, 8);
      fillPreThing(Coin, 424, 80, 3, 1, 8);

      setExitLoc(1);
      // pushPreThing(LocationShifter, 609, -32, 2, [window.innerWidth / unitsize, 16]);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(4);

      makeCeiling(32, 7);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 32, 8, 7, 3, 8, 8);
      fillPreThing(Coin, 33, 31, 7, 2, 8, 16);
      fillPreThing(Coin, 41, 63, 5, 1, 8, 8);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
  ];
}

function World22(map) {
  map.locs = [
    new Location(0, walkToPipe),
    new Location(1),
    new Location(2, exitPipeVert),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 2);
      pushPreFloor(0, 0, 24);
      pushPreThing(PipeSide, 80, 16, 1);
      pushPrePipe(96, 0, 32);
    }),
    new Area("Underwater", function () {
      setLocationGeneration(1);
      goUnderWater();

      pushPreFloor(0, 0, 67);
      pushPreThing(Coral, 96, 24, 3);
      fillPreThing(Coin, 120, 7, 2, 1, 8);
      pushPreThing(Stone, 152, jumplev1, 3, 1);
      pushPreThing(Blooper, 184, 16);
      fillPreThing(Coin, 224, jumplev2, 3, 1, 8);
      pushPreThing(Coral, 272, 40, 5);
      fillPreThing(Coin, 296, 7, 3, 1, 8);
      pushPreThing(Stone, 344, jumplev1, 2, 1);
      pushPreThing(Coral, 344, jumplev1 + 16, 2);
      pushPreThing(Blooper, 376, jumplev1);
      pushPreThing(Coral, 408, 32, 4);
      pushPreThing(Blooper, 448, 24);
      pushPreThing(Stone, 520, 24, 1, 3);
      pushPreThing(Stone, 528, 40, 1, 5);
      fillPreThing(Coin, 546, 23, 3, 1, 8);

      pushPreFloor(576, 0, 60);
      pushPreThing(Stone, 576, 40, 1, 5);
      pushPreThing(Stone, 584, 24, 1, 3);
      pushPreThing(CheepCheep, 616, 24, false, false);
      pushPreThing(Stone, 632, 24, 2, 3);
      pushPreThing(Stone, 632, 88, 2, 3);
      pushPreThing(CheepCheep, 640, 48, false, false);
      pushPreThing(CheepCheep, 656, 16, false, false);
      pushPreThing(Stone, 664, 64, 3, 1);
      pushPreThing(Blooper, 672, 40, false, false);
      pushPreThing(Coral, 672, 80, 2);
      pushPreThing(Coral, 720, 24, 3);
      pushPreThing(Blooper, 760, 80);
      pushPreThing(CheepCheep, 760, 56, false, false);
      pushPreThing(CheepCheep, 784, 80, true, false);
      fillPreThing(Coin, 816, 15, 3, 1, 8);
      pushPreThing(CheepCheep, 816, 24, false, false);
      pushPreThing(Stone, 824, 32, 2, 1);
      pushPreThing(Coral, 824, 64, 4);
      pushPreThing(Blooper, 848, 16);
      fillPreThing(Coin, 912, 55, 3, 1, 8, 8);
      pushPreThing(Stone, 928, 40, 2, 1);
      pushPreThing(CheepCheep, 944, 72, false, false);
      pushPreThing(Coral, 968, 32, 4);
      pushPreThing(CheepCheep, 1032, 24, true, false);
      pushPreThing(Stone, 1040, 32, 1, 4);
      pushPreThing(Stone, 1048, 16, 1, 2);
      pushPreThing(CheepCheep, 1056, 16, false, false);
      pushPreThing(Stone, 1056, 88, 1, 3);
      pushPreThing(Stone, 1064, 72, 8, 1);
      pushPreThing(Coin, 1072, 15);
      fillPreThing(Coin, 1080, 7, 3, 1, 8);
      pushPreThing(Coin, 1104, 15);
      pushPreThing(CheepCheep, 1100, 40, false, false);
      pushPreFloor(1128, 0, 17);
      pushPreThing(Stone, 1128, 16, 1, 2);
      pushPreThing(Stone, 1136, 32, 1, 4);
      pushPreThing(CheepCheep, 1160, 32, false, false);
      pushPreThing(Coral, 1184, 16, 2);
      pushPreThing(Coral, 1200, 24, 3);
      pushPreThing(CheepCheep, 1206, 56, true, false);
      pushPreThing(Stone, 1256, 64, 1, 8);
      pushPreThing(Stone, 1264, 64, 2, 1);
      fillPreThing(Coin, 1281, 32, 3, 2, 8, -24);
      pushPreThing(Stone, 1304, 64, 2, 1);
      pushPreFloor(1320, 0, 40);
      pushPreThing(Stone, 1320, 64, 1, 8);
      pushPreThing(CheepCheep, 1320, 80, false, false);
      pushPreThing(CheepCheep, 1344, 16, true, false);
      fillPreThing(Stone, 1384, 32, 1, 2, 0, 32, 5, 1);
      pushPreThing(Coral, 1392, 80, 2);
      pushPreThing(CheepCheep, 1408, 40, false, false);
      fillPreThing(Stone, 1448, 32, 1, 2, 0, 32, 4, 1);
      pushPreThing(CheepCheep, 1472, 72, true, false);
      pushPreThing(CheepCheep, 1496, 48, true, false);

      pushPreThing(Stone, 1488, 8, 5, 1);
      pushPreThing(Stone, 1496, 16, 4, 1);
      pushPreThing(Stone, 1504, 24, 3, 1);
      pushPreThing(Stone, 1512, 32, 2, 1);
      pushPreThing(Stone, 1512, 88, 2, 4);
      pushPreThing(PipeSide, 1520, 48, 2, true);
      pushPreThing(Stone, 1528, 88, 14, 11);
    }),
    new Area("Overworld", function () {
      setLocationGeneration(2);

      pushPrePattern("backreg", 104, 0, 1);
      pushPreFloor(0, 0, 42);
      pushPrePipe(0, 0, 16, true, false, 2);
      pushPreThing(Stone, 16, 8, 1, 1);
      pushPreThing(Stone, 24, 16, 1, 2);
      pushPreThing(Stone, 32, 24, 1, 3);
      pushPreThing(Stone, 40, 32, 1, 4);
      pushPreThing(Stone, 48, 40, 1, 5);
      pushPreThing(Stone, 56, 48, 1, 6);
      pushPreThing(Stone, 64, 56, 1, 7);
      pushPreThing(Stone, 72, 64, 2, 8);
      endCastleOutside(148);
    }),
  ];
}

function World23(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 5);

      pushPreFloor(0, 0, 7);
      zoneStartCheeps(64);
      pushPreTree(64, 0, 8);
      pushPreThing(Stone, 80, 8);
      pushPreThing(Stone, 88, 16, 1, 2);
      pushPreThing(Stone, 96, 24, 1, 3);
      pushPreThing(Stone, 104, 24, 1, 3);
      pushPreThing(Stone, 112, 24, 1, 3);
      pushPreBridge(120, 24, 16);
      pushPreThing(Stone, 248, 24, 1, DtB(24, 8));
      pushPreBridge(256, 24, 15);
      fillPreThing(Coin, 290, 63, 4, 1, 8, 8);
      pushPreThing(Stone, 376, 24, 1, DtB(24, 8));
      pushPreBridge(384, 24, 16);
      fillPreThing(Coin, 441, 63, 3, 1, 16);
      fillPreThing(Coin, 449, 55, 2, 1, 16);
      pushPreThing(Stone, 504, 24, 1, DtB(24, 8));

      pushPreThing(Stone, 544, 24, 1, DtB(24, 8));
      pushPreBridge(552, 24, 10);
      fillPreThing(Coin, 578, 63, 2, 1, 24);
      fillPreThing(Coin, 586, 71, 2, 1, 8);
      pushPreThing(Stone, 632, 24, 1, DtB(24, 8));

      pushPreThing(Stone, 672, 24, 1, 64);
      pushPreBridge(680, 24, 10);
      pushPreThing(Stone, 760, 24, 1, 64);

      fillPreThing(Coin, 777, 63, 3, 1, 8);
      pushPreThing(Stone, 792, 32, 1, 64);
      pushPreBridge(800, 32, 5, [true, true]);
      pushPreThing(Block, 816, 64, Mushroom);

      fillPreThing(Coin, 865, 63, 3, 1, 8);
      pushPreTree(896, 0, 8);
      pushPreBridge(976, 24, 3);

      pushPreBridge(1024, 24, 15, [true, true]);
      fillPreThing(Coin, 1065, 63, 6, 1, 8);

      pushPreBridge(1176, 8, 8, [true, true]);
      fillPreThing(Coin, 1193, 39, 4, 1, 8);

      pushPreBridge(1280, 24, 8, [true, true]);

      pushPreBridge(1368, 24, 2);
      fillPreThing(Coin, 1385, 55, 6, 1, 8);
      pushPreBridge(1400, 24, 2);
      pushPreBridge(1432, 24, 2);
      pushPreBridge(1472, 24, 9, [true]);
      pushPreTree(1536, 0, 13);
      pushPreThing(Stone, 1544, 24, 1, 3);
      pushPreThing(Stone, 1552, 24, 1, 3);
      pushPreThing(Stone, 1560, 16, 1, 2);
      pushPreThing(Stone, 1568, 8, 1, 1);
      zoneStopCheeps(1600);

      pushPreFloor(1656, 0, 35);
      pushPreThing(Stone, 1664, 8, 1, 1);
      pushPreThing(Stone, 1672, 16, 1, 2);
      pushPreThing(Stone, 1680, 24, 1, 3);
      pushPreThing(Stone, 1688, 32, 1, 4);
      pushPreThing(Stone, 1696, 40, 1, 5);
      pushPreThing(Stone, 1704, 48, 1, 6);
      pushPreThing(Stone, 1712, 56, 1, 7);
      pushPreThing(Stone, 1720, 64, 1, 8);
      pushPreThing(Stone, 1728, 64, 1, 8);

      endCastleOutside(1796, 0, true, 6);
    }),
  ];
}

function World24(map) {
  map.time = 300;
  map.locs = [new Location(0, startCastle)];
  map.areas = [
    new Area("Castle", function () {
      setLocationGeneration(0);

      startCastleInside();

      makeCeilingCastle(40, 11, 3);
      pushPreFloor(40, 24, 11);

      fillPreWater(128, 0, 32);
      pushPreThing(Podoboo, 128, -32);
      pushPreThing(Stone, 144, 32, 2, 1);
      pushPreThing(Stone, 176, 48, 3, 1);
      pushPreThing(CastleBlock, 184, 48);
      pushPreThing(Block, 184, 80, Mushroom);
      pushPreThing(Stone, 216, 32, 2, 1);
      pushPreThing(Podoboo, 240, -32);

      pushPreFloor(256, 0, 52);
      pushPreThing(Stone, 256, 24, 2, 3);
      makeCeilingCastle(272, 49, 4);
      pushPreThing(Stone, 296, jumplev1, 36, 1);
      pushPreThing(CastleBlock, 344, 0);
      pushPreThing(CastleBlock, 392, jumplev1, 6);
      pushPreThing(CastleBlock, 440, 0);
      pushPreThing(CastleBlock, 440, jumplev2, 6);
      pushPreThing(CastleBlock, 488, jumplev1, 6);
      pushPreThing(CastleBlock, 536, 0);
      pushPreThing(CastleBlock, 584, jumplev1, 6);
      pushPreThing(Stone, 640, 24, 4, 3);
      pushPreThing(CastleBlock, 656, 56, 6);

      pushPrePlatformGenerator(686, 3, -1);
      pushPrePlatformGenerator(710, 3, 1);

      pushPreFloor(736, 16);
      pushPreThing(CastleBlock, 736, 24, 6, true);
      pushPreFloor(744, 24, 6);
      makeCeilingCastle(744, 6, 3);
      pushPreFloor(792, 0, 10);
      fillPreThing(Coin, 817, 7, 3, 2, 8, 32);
      pushPreThing(CastleBlock, 824, 16);
      fillPreWater(872, 0, 4);
      pushPreThing(Stone, 864, 24, 1, 3);
      pushPreFloor(888, 24, 2);
      fillPreWater(904, 0, 4);

      pushPreFloor(920, 0, 13);
      pushPreThing(Stone, 920, 24, 5, 3);
      makeCeilingCastle(920, 13, 3);
      fillPreThing(Stone, 976, 24, 2, 1, 32, 0, 2, 3);

      fillPreThing(Brick, 1024, 64, 6, 1, 8);
      endCastleInside(1024);
    }),
  ];
}

function World31(map) {
  map.time = 300;
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(0, false, 1272),
    new Location(1),
    new Location(2, enterCloudWorld),
  ];
  map.areas = [
    new Area("Overworld Night Alt", function () {
      setLocationGeneration(0);

      pushPreCastle(0, 0, true);
      pushPrePattern("backfence", 0, 0, 5);

      pushPreFloor(0, 0, 45);
      pushPreThing(Block, 128, jumplev1);
      pushPreThing(Block, 152, jumplev1 + 8);
      pushPreThing(Block, 176, 40, Mushroom);
      pushPreThing(Koopa, 200, 12, false, true);
      fillPreThing(Brick, 208, jumplev1, 3, 1, 8);
      pushPreThing(Koopa, 224, 20, false, true);
      pushPrePipe(256, 0, 24, true);
      pushPreThing(Goomba, 296, 8);
      pushPrePipe(304, 0, 32, true, 3);

      pushPreFloor(384, 0, 29);
      fillPreThing(Goomba, 424, 8, 3, 1, 12);
      pushPrePipe(456, 0, 24, true);
      pushPreThing(Brick, 488, jumplev1);
      pushPreThing(Koopa, 520, 12);
      pushPrePipe(536, 0, 16, true, false, 1);
      pushPreThing(Stone, 584, 8);
      pushPreThing(Stone, 592, 16, 1, 2);
      pushPreThing(Stone, 600, 24, 1, 3);
      pushPreThing(Stone, 608, 32, 1, 4);
      fillPreWater(616, 10, 16);
      pushPreBridge(616, 32, 8);
      fillPreThing(Goomba, 656, 40, 3, 1, 12);
      pushPreThing(Block, 656, jumplev2, [Mushroom, 1], true);
      pushPreFloor(680, 0, 1);
      pushPreThing(Stone, 680, 32, 1, 4);
      fillPreWater(688, 10, 4);

      pushPreFloor(704, 0, 40);
      pushPreThing(Stone, 704, 32, 1, 4);
      pushPreThing(Stone, 712, 16, 1, 2);
      pushPreThing(Brick, 720, jumplev2, Star);
      fillPreThing(Brick, 728, jumplev2, 2, 1, 8);
      fillPreThing(Goomba, 752, 8, 2, 1, 12);
      pushPreThing(Koopa, 808, 12);
      pushPrePipe(824, 0, 32, true);
      fillPreThing(Brick, 888, jumplev1, 11, 1, 8);
      fillPreThing(Brick, 888, jumplev2, 2, 1, 8);
      pushPreThing(HammerBro, 904, jumplev1 + 12);
      pushPreThing(Block, 904, jumplev2);
      fillPreThing(Brick, 912, jumplev2, 3, 1, 8);
      pushPreThing(HammerBro, 936, 12);
      pushPreThing(Block, 936, jumplev2, Mushroom);
      fillPreThing(Brick, 944, jumplev2, 3, 1, 8);
      pushPreThing(Springboard, 1008, 14.5);

      fillPreThing(Brick, 1032, 40, 3, 1, 8);
      fillPreThing(Brick, 1032, 64, 2, 1, 8);
      pushPreThing(Brick, 1048, 64, [Vine, 4]);

      pushPreFloor(1056, 0, 10);
      pushPreThing(Stone, 1088, 8);
      pushPreThing(Stone, 1096, 16, 1, 2);
      pushPreThing(Stone, 1104, 24, 1, 3);
      pushPreThing(Stone, 1112, 32, 1, 4);
      pushPreThing(Goomba, 1112, 40);
      pushPreThing(Stone, 1120, 40, 1, 5);
      pushPreThing(Goomba, 1120, 48);
      pushPreThing(Stone, 1128, 48, 1, 6);

      pushPreFloor(1152, 0, 33);
      pushPreThing(Koopa, 1192, 12);
      fillPreThing(Brick, 1200, jumplev1, 2, 2, 16, 32);
      fillPreThing(Block, 1208, jumplev1, 1, 2, 0, 32);
      pushPreThing(Koopa, 1216, 76);
      fillPreThing(Goomba, 1232, 8, 3, 1, 12);
      fillPreThing(Brick, 1240, jumplev1, 2, 2, 16, 32);
      pushPreThing(Block, 1248, jumplev1, Mushroom);
      pushPreThing(Block, 1248, jumplev2);
      pushPreThing(Koopa, 1320, 12, false, true);
      pushPreThing(Brick, 1328, jumplev1);
      pushPreThing(Brick, 1336, jumplev1, Coin);
      pushPreThing(Koopa, 1344, 18, false, true);
      fillPreThing(Brick, 1344, jumplev1, 3, 1, 8);
      pushPreThing(Koopa, 1360, 44);
      pushPreThing(Koopa, 1368, 12, false, true);
      pushPreThing(Stone, 1392, 24, 1, 3);
      pushPreThing(Stone, 1400, 48, 1, 6);

      pushPreFloor(1440, 0, 40);
      pushPreThing(Stone, 1464, 8);
      pushPreThing(Stone, 1472, 16, 1, 2);
      pushPreThing(Stone, 1480, 24, 1, 3);
      pushPreThing(Stone, 1488, 32, 1, 4);
      pushPreThing(Stone, 1496, 40, 1, 5);
      pushPreThing(Stone, 1504, 48, 1, 6);
      pushPreThing(Koopa, 1504, 60);
      pushPreThing(Stone, 1512, 56, 1, 7);
      pushPreThing(Stone, 1520, 64, 2, 8);
      pushPreThing(Koopa, 1528, 76);

      endCastleOutside(1596);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(3);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 24, 40, 2, 4, 72, 8);
      fillPreThing(Brick, 32, 32, 2, 1, 56);
      fillPreThing(Brick, 32, 56, 2, 2, 56, 8);
      fillPreThing(Coin, 33, 39, 2, 1, 56);
      fillPreThing(Brick, 40, 40, 2, 1, 40);
      pushPreThing(Brick, 40, 64, Mushroom);
      fillPreThing(Coin, 41, 47, 2, 1, 40);
      fillPreThing(Brick, 48, 48, 2, 1, 24);
      fillPreThing(Coin, 49, 55, 2, 2, 24, 16);
      fillPreThing(Brick, 56, 56, 2, 2, 8, 8);
      fillPreThing(Coin, 57, 71, 2, 2, 8, 8);
      pushPreThing(Brick, 80, 64);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
    new Area("Sky Night", function () {
      setLocationGeneration(4);
      pushPreThing(Stone, 0, 0, 4);
      pushPreThing(Stone, 40, 0, 78);
      pushPreThing(Platform, 128, 24, 6, collideTransport);
      fillPreThing(Coin, 121, 55, 16, 1, 8);
      pushPreThing(Stone, 256, 40);
      fillPreThing(Coin, 273, 55, 16, 1, 8);
      pushPreThing(Stone, 408, 48, 1, 2);
      fillPreThing(Coin, 425, 63, 7, 1, 8);
      pushPreThing(Stone, 488, 48, 1, 2);
      pushPreThing(Stone, 536, 56, 2);
      fillPreThing(Stone, 568, 56, 5, 1, 16);
      fillPreThing(Coin, 569, 63, 10, 1, 8);
      fillPreThing(Coin, 681, 15, 3, 1, 8);

      setExitLoc(2);
    }),
  ];
}

function World32(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld Night Alt", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backfence", -384, 0, 6);
      pushPreFloor(0, 0, 80);
      pushPreThing(Koopa, 136, 12);
      fillPreThing(Goomba, 192, 8, 3, 1, 12);
      fillPreThing(Koopa, 264, 12, 3, 1, 12);
      fillPreThing(Koopa, 344, 12, 2, 1, 12);
      pushPreThing(Stone, 392, 8);
      fillPreThing(Coin, 441, jumplev1 - 1, 3, 1, 8);
      pushPreThing(Stone, 480, 24, 1, 3);
      pushPreThing(Block, 480, 56, Mushroom);
      pushPreThing(Koopa, 528, 12);
      fillPreThing(Goomba, 568, 8, 3, 1, 12);
      pushPreThing(Stone, 600, 16, 1, 2);
      pushPreThing(Brick, 616, jumplev1, Coin);
      pushPreThing(Brick, 616, jumplev2, Star);
      pushPreThing(Koopa, 624, 12);
      pushPreThing(Stone, 632, 16, 1, 2);

      pushPreFloor(656, 0, 41);
      pushPreThing(Koopa, 736, 34, false, true);
      pushPreThing(Koopa, 888, 12);
      fillPreThing(Goomba, 952, 8, 3, 1, 12);

      pushPreFloor(1000, 0, 3);
      pushPreThing(Stone, 1008, 16, 1, 2);
      pushPreThing(Brick, 1008, 56);

      pushPreFloor(1040, 0, 94);
      pushPreThing(Koopa, 1072, 12);
      fillPreThing(Koopa, 1120, 12, 3, 1, 12);
      fillPreThing(Koopa, 1200, 12, 2, 1, 12);
      fillPreThing(Koopa, 1296, 12, 3, 1, 12);
      fillPreThing(Coin, 1345, 55, 4, 1, 8);
      pushPrePipe(1352, 0, 24, true);
      pushPreThing(Koopa, 1400, 12);
      fillPreThing(Goomba, 1432, 8, 3, 1, 12);
      fillPreThing(Goomba, 1504, 8, 3, 1, 12);
      pushPreThing(Stone, 1536, 8);
      pushPreThing(Stone, 1544, 16, 1, 2);
      pushPreThing(Stone, 1552, 24, 1, 3);
      pushPreThing(Stone, 1560, 32, 1, 4);
      pushPreThing(Stone, 1568, 40, 1, 5);
      pushPreThing(Stone, 1576, 48, 1, 6);
      pushPreThing(Stone, 1584, 56, 1, 7);
      pushPreThing(Stone, 1592, 64, 1, 8);
      pushPreThing(Stone, 1600, 64, 1, 8);

      endCastleOutside(1668);
    }),
  ];
}

function World33(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld Night", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 7);
      pushPreFloor(0, 0, 16);

      pushPreTree(144, 24, 5);
      pushPreTree(176, 48, 6);
      pushPreThing(Goomba, 208, 56);
      pushPreThing(Platform, 240, 72, 6, [moveSliding, 228, 260]);
      pushPreTree(240, 0, 3);
      fillPreThing(Coin, 249, 7, 2, 1, 8);
      pushPreThing(Platform, 264, 40, 6, [moveSliding, 244, 276]);
      pushPreTree(288, 8, 7);
      pushPreThing(Coin, 298, 55);
      fillPreThing(Coin, 337, 55, 3, 1, 8);
      pushPreTree(344, 32, 4);
      pushPreTree(368, 16, 10);
      pushPreTree(376, 48, 6);
      pushPreThing(Block, 392, 80, Mushroom);
      fillPreThing(Coin, 417, 31, 3, 1, 8);
      pushPreThing(Koopa, 416, 60, true);
      pushPreThing(Koopa, 432, 28, true);
      pushPreTree(440, 80, 4);
      fillPreThing(Coin, 449, 87, 2, 1, 8);
      pushPreThing(Platform, 482, 56, 6, moveFalling);

      pushPreTree(520, 0, 16);
      pushPreTree(520, 48, 3);
      pushPreThing(Coin, 529, 55);
      pushPreTree(552, 48, 3);
      pushPreThing(Coin, 561, 55);
      pushPreThing(Koopa, 584, 12, true);
      pushPreTree(584, 48, 3);
      pushPreThing(Coin, 593, 55);
      pushPreTree(616, 72, 3);
      pushPreThing(Coin, 625, 79);

      pushPreScale(660, 86, 14, [6, 6, 10]);
      pushPreTree(672, 16, 4);

      pushPreThing(Platform, 752, 32, 6, moveFalling);
      pushPreThing(Platform, 768, 64, 6, moveFalling);
      pushPreTree(776, 32, 3);
      pushPreThing(Platform, 824, 16, 6, moveFalling);
      pushPreTree(832, 64, 4);
      fillPreThing(Coin, 841, 71, 2, 1, 8);
      pushPreTree(856, 16, 5);
      pushPreThing(Coin, 865, 23);
      pushPreTree(864, 48, 3);
      pushPreThing(Coin, 873, 55);

      pushPreThing(Koopa, 912, 66, true, [14, 66]);
      pushPreTree(928, 0, 3);
      pushPreTree(952, 24, 12);
      fillPreThing(Koopa, 992, 36, 2, 1, 14, 0, true);
      pushPreThing(Platform, 1056, 56, 6);

      pushPreScale(1100, 86, 8, [6, 4, 10]);

      pushPreFloor(1152, 0, 32);
      endCastleOutside(1204, 0, true, 13, 28);
    }),
  ];
}

function World34(map) {
  map.time = 300;
  map.locs = [new Location(0, startCastle)];
  map.areas = [
    new Area("Castle", function () {
      setLocationGeneration(0);

      startCastleInside();

      makeCeilingCastle(40, 11, 3);
      pushPreFloor(40, 24, 11);
      pushPreThing(Podoboo, 128, -32);
      makeCeilingCastle(128, 112);

      pushPreFloor(144, 24, 3);
      pushPreThing(CastleBlock, 152, 16, 6);
      pushPreFloor(184, 24, 3);
      pushPreThing(CastleBlock, 192, 16, 6);
      pushPreThing(Podoboo, 208, -32);
      pushPreFloor(224, 24, 3);
      pushPreThing(CastleBlock, 232, 16, 6);

      pushPreFloor(264, 0, 13);
      pushPreThing(Stone, 264, 24, 2, 3);
      pushPreThing(Stone, 280, 80, 11, 2);
      pushPreThing(Block, 336, jumplev1);
      pushPreThing(Block, 344, jumplev1, Mushroom);
      pushPreThing(Block, 352, jumplev1);

      pushPreFloor(384, 0, 40);
      pushPreThing(Stone, 424, 8, 3, 1);
      pushPreThing(Stone, 424, 80, 3, 2);
      pushPreThing(CastleBlock, 432, 16, 6, true);
      pushPreThing(CastleBlock, 432, 64, 6);
      pushPreThing(Stone, 504, 8, 3, 1);
      pushPreThing(Stone, 504, 80, 3, 2);
      pushPreThing(CastleBlock, 512, 16, 6, true);
      pushPreThing(CastleBlock, 512, 64, 6);
      pushPreThing(Stone, 632, 8, 3, 1);
      pushPreThing(Stone, 632, 80, 3, 2);
      pushPreThing(CastleBlock, 640, 16, 6);
      pushPreThing(CastleBlock, 640, 64, 6, true);
      pushPreThing(Podoboo, 704, -32);
      fillPreWater(704, 0, 4);

      pushPreFloor(720, 24, 6);
      pushPreThing(Stone, 720, 80, 6, 2);
      fillPreWater(768, 0, 6);
      pushPreThing(Podoboo, 776, -32);
      pushPreFloor(792, 24, 3);
      fillPreWater(816, 0, 6);
      pushPreThing(Podoboo, 824, -32);
      pushPreFloor(840, 24, 3);
      fillPreWater(864, 0, 6);
      pushPreThing(Podoboo, 872, -32);
      pushPreFloor(888, 0, 17);
      pushPreThing(Stone, 888, 24, 5, 3);
      pushPreThing(Stone, 888, 80, 17, 2);
      pushPreThing(Stone, 944, 24, 10, 3);

      endCastleInside(1024, 0);
      fillPreThing(Brick, 1056, 64, 2, 3, 8, 8);
    }),
  ];
}

function World41(map) {
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(1),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle(0, 0, true);
      pushPrePattern("backreg", 0, 0, 5);
      pushPreFloor(0, 0, 32);
      pushPrePipe(168, 0, 24, true);
      pushPreThing(Block, 200, jumplev1, Mushroom);
      pushPreThing(Block, 200, jumplev2);
      pushPreThing(Lakitu, 212, 84);

      pushPreFloor(272, 0, 44);
      fillPreThing(Coin, 329, 31, 2, 1, 24);
      fillPreThing(Coin, 337, 39, 2, 1, 8);
      fillPreThing(Block, 512, jumplev1, 2, 2, 16, 32);

      pushPreFloor(656, 0, 67);
      fillPreThing(Block, 720, jumplev1, 4, 1, 8);
      pushPreThing(Block, 736, jumplev2, [Mushroom, 1], true);
      pushPreThing(Stone, 824, 24, 1, 3);
      fillPreThing(Coin, 841, 55, 4, 1, 8);
      pushPrePipe(928, 0, 32, true);
      fillPreThing(Coin, 953, 55, 4, 1, 8);
      pushPrePipe(1056, 0, 32, true, 2);
      fillPreThing(Coin, 1081, 55, 4, 1, 8);
      fillPreThing(Block, 1168, jumplev1, 2, 1, 8);
      pushPreThing(Block, 1184, jumplev1, Mushroom);
      fillPreThing(Block, 1184, jumplev2, 4, 1, 8);
      fillPreThing(Brick, 1192, jumplev1, 2, 1, 8);
      fillPreThing(Block, 1208, jumplev1, 3, 1, 8);

      pushPreFloor(1208, 0, 23);
      pushPrePipe(1304, 0, 16, true, false, 1);

      pushPreFloor(1416, 0, 3);
      pushPreFloor(1456, 0, 8);
      pushPreThing(Stone, 1512, 24, 1, 3);

      pushPreFloor(1536, 0, 48);
      pushPreFuncCollider(1664, zoneDisableLakitu); // not sure if accurate
      pushPreThing(Stone, 1664, 8);
      pushPreThing(Stone, 1672, 16, 1, 2);
      pushPreThing(Stone, 1680, 24, 1, 3);
      pushPreThing(Stone, 1688, 32, 1, 4);
      pushPreThing(Stone, 1696, 40, 1, 5);
      pushPreThing(Stone, 1704, 48, 1, 6);
      pushPreThing(Stone, 1712, 56, 1, 7);
      pushPreThing(Stone, 1720, 64, 2, 8);
      pushPreThing(Brick, 1760, jumplev1, Coin);
      endCastleOutside(1796);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(2);

      makeCeiling(32, 11);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 24, 16, 1, 3, 8, 8);
      fillPreThing(Coin, 25, 39, 8, 1, 8);
      fillPreThing(Coin, 25, 7, 10, 1, 8);
      fillPreThing(Brick, 32, 32, 6, 1, 8);
      fillPreThing(Brick, 80, 16, 1, 3, 8, 8);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(Brick, 104, 32, Mushroom);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
  ];
}

function World42(map) {
  map.locs = [
    new Location(0, walkToPipe),
    new Location(1),
    new Location(1, exitPipeVert),
    new Location(2),
    new Location(3, exitPipeVert),
    new Location(4, enterCloudWorld),
  ];
  map.areas = [
    new Area("Overworld", function () {
      // entrance - loc 0
      setLocationGeneration(0);
      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 1);
      pushPreFloor(0, 0, 24);
      pushPreThing(PipeSide, 80, 16, 1);
      pushPrePipe(96, 0, 32);
    }),
    new Area("Underworld", function () {
      // main underworld - locs 1 (entryNormal), 2 (exitPipeVert)
      setLocationGeneration(1);

      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      pushPreFloor(0, 0, 11);
      makeCeiling(48, 51);

      pushPreFloor(104, 0, 2);
      pushPreFloor(136, 0, 1);

      fillPreThing(Brick, 160, 64, 23, 3, 8, 8);
      pushPreFloor(168, 0, 36);
      fillPreThing(Brick, 176, 16, 5, 3, 8, 8);
      pushPreThing(Brick, 216, 32);
      fillPreThing(Coin, 217, 7, 3, 1, 8);
      pushPreThing(Brick, 224, 32, Mushroom);
      fillPreThing(Brick, 240, 8, 18, 4, 8, 8);
      fillPreThing(Goomba, 344, 40, 3, 1, 12);
      pushPreThing(Brick, 344, 64);
      pushPreThing(Brick, 344, 72, Coin);
      pushPreThing(Brick, 344, 80);
      fillPreThing(Brick, 352, jumplev2, 4, 3, 8, 8);
      fillPreThing(Block, 400, jumplev1, 2, 2, 8, 32);
      fillPreThing(Block, 432, jumplev1, 2, 1, 16);
      pushPreThing(Block, 440, jumplev1, Mushroom);

      pushPrePlatformGenerator(470, 6, 1);
      // pushPreThing(PlatformGenerator, 470, ceilmax, 6, 1);

      pushPreFloor(504, 0, 42);
      pushPreThing(Block, 504, 40, Coin, true);
      pushPreThing(Block, 512, 48, Coin, true);
      pushPreThing(Brick, 512, 64, [Vine, 5]); // goes to bonus overworld
      pushPreThing(Block, 520, 40, Coin, true);
      fillPreThing(Brick, 520, 64, 2, 1, 8);
      pushPreThing(Block, 528, 32, Coin, true);
      makeCeiling(536, 45);
      pushPrePipe(576, 0, 24, true);
      pushPreThing(Brick, 608, jumplev1);
      pushPreThing(Koopa, 616, 12);
      pushPreThing(Brick, 616, jumplev1, Coin);
      pushPrePipe(624, 0, 56, true);
      pushPreThing(Brick, 640, jumplev1);
      pushPreThing(Brick, 648, jumplev1, Star);
      pushPreThing(Beetle, 664, 8.5);
      pushPrePipe(672, 0, 24, true, 3); // goes to second underworld
      pushPreThing(Brick, 696, 40);
      pushPreThing(Beetle, 704, 8.5);
      pushPrePipe(712, 0, 24);
      fillPreThing(Koopa, 800, 12, 2, 1, 12);
      pushPreThing(Stone, 824, 16, 1, 2);
      pushPreThing(Stone, 832, 24, 1, 3);

      pushPreFloor(856, 0, 2);
      pushPrePipe(856, 0, 32, true, false, 2);

      pushPreFloor(888, 0, 2);
      pushPreThing(Stone, 888, 24, 2, 3);

      pushPrePlatformGenerator(918, 6, 1);
      // pushPreThing(PlatformGenerator, 918, ceilmax, 6, 1);
      pushPreFloor(952, 0, 4);
      fillPreThing(Brick, 952, 32, 4, 1, 8);
      pushPreThing(Brick, 952, 64);
      fillPreThing(Brick, 952, 88, 4, 1, 8);
      pushPreThing(Brick, 960, 64, Mushroom);
      pushPreThing(Brick, 968, 64);

      pushPrePlatformGenerator(992, 6, -1);
      // pushPreThing(PlatformGenerator, 992, ceilmax, 6, -1);

      makeCeiling(1024, 27);
      pushPreFloor(1032, 0, 15);
      pushPrePipe(1048, 0, 16, false, false, 2); // exit of second underworld
      pushPreThing(Koopa, 1096, 12);
      pushPrePipe(1104, 0, 24, true);
      pushPrePipe(1136, 0, 32, true);

      pushPreFloor(1168, 0, 9);
      pushPreThing(Stone, 1216, 8);
      pushPreThing(Stone, 1224, 16, 1, 2);
      pushPreThing(Stone, 1232, 24, 1, 3);
      pushPreThing(Beetle, 1232, 32.5);

      pushPrePlatformGenerator(1246, 6, 1);
      // pushPreThing(PlatformGenerator, 1246, ceilmax, 6, 1);

      pushPreFloor(1280, 0, 23);
      fillPreThing(Brick, 1280, 48, 1, 2, 8, 8);
      fillPreThing(Brick, 1280, 64, 16, 3, 8, 8);
      makeCeiling(1280, 29);
      pushPreThing(Brick, 1288, jumplev1, Mushroom);
      fillPreThing(Brick, 1296, jumplev1, 10, 1, 8);
      fillPreThing(Coin, 1297, 39, 10, 1, 8);
      fillPreThing(Koopa, 1344, 12, 2, 1, 12);
      pushPreThing(Stone, 1384, 8);
      pushPreThing(Stone, 1392, 16, 1, 2);
      pushPreThing(Stone, 1400, 24, 1, 3);
      pushPreThing(Stone, 1408, 32, 1, 4);
      pushPreThing(Beetle, 1432, 8.5);
      pushPrePipe(1440, 0, 56, true);

      pushPreThing(Floor, 1480, 0, 39);
      fillPreThing(Brick, 1480, 8, 24, 3, 8, 8);
      pushPreThing(PipeSide, 1496, 40, 4);
      pushPreThing(PipeVertical, 1512, 88, 64);
      fillPreThing(Brick, 1528, 32, 18, 7, 8, 8);
      makeCeiling(1528, 28);

      fillPreThing(Brick, 1616, 32, 7, 7, 8, 8);
      pushPreThing(ScrollEnabler, 1610, ceilmax);
      makeCeiling(1616, 17);
      pushPreWarpWorld(1670, 0, [[5, 1]], 0, true);
      fillPreThing(Brick, 1776, 8, 2, 11, 8, 8);
    }),
    new Area("Underworld", function () {
      // secondary underworld - loc 3
      setLocationGeneration(3);

      makeCeiling(32, 7);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 32, 48, 7, 1, 8);
      pushPreThing(Brick, 32, 56);
      fillPreThing(Coin, 42, 55, 5, 2, 8, 8);
      fillPreThing(Brick, 80, 56, 1, 4, 8, 8);
      fillPreThing(Brick, 88, 56, 2, 1, 8);
      pushPreThing(Brick, 112, 48, Coin);
      pushPreThing(PipeSide, 104, 16, 2);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
    new Area("Overworld", function () {
      // regular exit - loc 4
      setLocationGeneration(4);

      pushPrePattern("backreg", 104, 0, 1);
      pushPreFloor(0, 0, 58);
      pushPrePipe(0, 0, 16, true, false, 4);
      pushPreThing(Stone, 16, 8, 1, 1);
      pushPreThing(Stone, 24, 16, 1, 2);
      pushPreThing(Stone, 32, 24, 1, 3);
      pushPreThing(Stone, 40, 32, 1, 4);
      pushPreThing(Stone, 48, 40, 1, 5);
      pushPreThing(Stone, 56, 48, 1, 6);
      pushPreThing(Stone, 64, 56, 1, 7);
      pushPreThing(Stone, 72, 64, 2, 8);
      endCastleOutside(148);
    }),
    new Area("Overworld", function () {
      // bonus world! - loc 5
      setLocationGeneration(5);

      pushPrePattern("backcloud", -384, 4, 3);
      pushPreFloor(0, 0, 4);
      pushPreFloor(40, 0, 59);
      pushPreShroom(96, 32, 3);
      fillPreThing(Coin, 97, 39, 3, 1, 8);
      pushPreShroom(128, 64, 3);
      fillPreThing(Coin, 129, 71, 3, 1, 8);
      pushPreShroom(144, 16, 3);
      pushPreShroom(176, 16, 5);
      pushPreShroom(176, 64, 3);
      fillPreThing(Coin, 177, 71, 3, 1, 8);
      pushPreShroom(208, 48, 3);
      fillPreThing(Coin, 209, 55, 3, 1, 8);
      pushPreShroom(240, 72, 5);
      fillPreThing(Coin, 241, 79, 5, 1, 8);
      pushPreShroom(248, 24, 7);
      fillPreThing(Coin, 281, 31, 2, 1, 8);

      pushPreThing(Stone, 320, 8);
      pushPreThing(Stone, 328, 16, 1, 2);
      pushPreThing(Stone, 336, 24, 1, 3);
      pushPreThing(Stone, 344, 32, 1, 4);
      pushPreThing(Stone, 352, 40, 1, 5);
      pushPreThing(Stone, 360, 48, 1, 6);
      pushPreThing(Stone, 368, 56, 1, 7);
      pushPreThing(Stone, 376, 64, 1, 8);
      pushPreThing(Stone, 384, 72, 1, 9);
      pushPreThing(Stone, 392, 72, 11);
      pushPreWarpWorld(390, 0, [
        [8, 1],
        [7, 1],
        [6, 1],
      ]);
      pushPreThing(Stone, 496, 88, 2, 11);
      pushPreThing(ScrollBlocker, 512, 88);
    }),
  ];
}

function World43(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 3);
      pushPreFloor(0, 0, 15);

      pushPreShroom(128, 0, 5);
      pushPreShroom(152, 64, 5);
      fillPreThing(Coin, 161, 71, 3, 1, 8);
      pushPreShroom(184, 32, 7);
      fillPreThing(Coin, 193, 39, 4, 1, 8);
      fillPreThing(Koopa, 224, 44, 2, 1, 8, 8, true);

      pushPreShroom(256, 72, 3);
      pushPreShroom(288, 8, 7);
      pushPreThing(Koopa, 288, 84, true, [32, 88]);
      pushPreThing(Coin, 305, 15);
      pushPreThing(Koopa, 312, 20, true);
      pushPreShroom(312, 64, 5);
      pushPreThing(Coin, 321, 15);
      pushPreThing(Block, 344, 88, Mushroom);
      pushPreShroom(352, 32, 3);

      pushPreThing(Coin, 385, 47);
      pushPreScale(396, 86, 14, [6, 4, 10]);
      pushPreShroom(408, 40, 3);
      pushPreThing(Platform, 464, 20, 6, [moveFloating, 32, 88, 2]);
      pushPreThing(Platform, 496, 66, 6, [moveFloating, 32, 88, 2]);

      pushPreShroom(520, 0, 5);
      pushPreShroom(536, 48, 3);
      fillPreThing(Coin, 537, 55, 3, 1, 8);
      pushPreThing(Koopa, 544, 12, true);
      pushPreShroom(560, 80, 3);
      fillPreThing(Coin, 561, 87, 3, 1, 8);
      pushPreShroom(576, 32, 3);
      pushPreThing(Coin, 585, 39);
      pushPreShroom(592, 64, 5);
      pushPreThing(Koopa, 624, 76, true);

      pushPreScale(652, 86, 16, [6, 4, 12]);
      pushPreScale(740, 86, 10, [6, 4, 12]);
      pushPreThing(Coin, 770, 47);
      pushPreShroom(792, 16, 3);
      pushPreScale(828, 86, 12, [6, 4, 12]);

      pushPreShroom(904, 32, 5);
      fillPreThing(Coin, 905, 39, 5, 1, 8);
      pushPreShroom(936, 56, 3);
      pushPreShroom(968, 0, 7);
      pushPreShroom(1040, 24, 5);
      pushPreThing(Platform, 1088, 67, 6, [moveFloating, 8, 88, 2]);

      pushPreFloor(1128, 0, 19);
      endCastleOutside(1172, 0, true, 1);
    }),
  ];
}

function World44(map) {
  map.locs = [new Location(0, startCastle)];
  map.areas = [
    new Area("Castle", function () {
      setLocationGeneration(0);

      startCastleInside();

      pushPreFloor(40, 24, 2);
      makeCeilingCastle(40, 11);
      fillPreWater(56, 0, 4);
      pushPreFloor(72, 24, 2);
      fillPreWater(88, 0, 4);
      pushPreFloor(104, 24, 3);

      this.sections = {
        start: 128,
        0: function (xloc) {
          pushPreFloor(xloc, 0, bstretch + 50);
          makeCeilingCastle(xloc, bstretch + 50);
          pushPreThing(Stone, xloc + 16, 56, 6, 4);
          fillPreThing(Stone, xloc + 72, 56, 5, 1, 16, 0, 1, 4);
          pushPreThing(Stone, xloc + 152, 56, 3, 4);
          pushPreThing(Stone, xloc + 176, 56, 6, 1);
          pushPrePipe(xloc + 192, 0, 24, true);
          pushPreThing(Stone, xloc + 224, 56, 17, 4);
          pushPreThing(CastleBlock, xloc + 296, 56, [6, 1], true);
          pushPreSectionFail(xloc + 384, 24, 40, 24);
          pushPreSectionPass(xloc + 384, 80, 40, 24);
          pushPreThing(CastleBlock, xloc + 352, 32, [6, 1], true);
          pushPreThing(Stone, xloc + 360, 56, bstretch, 4);
          pushPreThing(Stone, xloc + 376 + bstretch * 8, 24, 3, 3);
          pushPreThing(Stone, xloc + 376 + bstretch * 8, 80, 3, 3);
          pushCastleDecider(xloc + 400 + bstretch * 8, 0);
        },
        1: function (xloc) {
          pushPreFloor(xloc, 0, 8);
          makeCeilingCastle(xloc, bstretch + 42);
          pushPreThing(Stone, xloc + 48, 24, 2);
          fillPreWater(xloc + 64, 0, 4);
          pushPreThing(Stone, xloc + 72, 40, 2);
          fillPreWater(xloc + 80, 0, 10);

          pushPreFloor(xloc + 80, 16);
          pushPreThing(Stone, xloc + 80, 24, 5);
          pushPreThing(Stone, xloc + 104, 48);
          pushPreThing(Stone, xloc + 112, 40, 1, 2);
          pushPreFloor(xloc + 120, 0, 27);
          pushPreThing(Stone, xloc + 120, 56, 1, 2);
          pushPreThing(Stone, xloc + 128, 24, 26);
          pushPreThing(Stone, xloc + 128, 56, 2);
          pushPreThing(Stone, xloc + 160, 56, 4);
          pushPreThing(Stone, xloc + 200, 48, 1, 3);
          pushPreThing(Stone, xloc + 200, 56, 3);
          pushPreThing(Stone, xloc + 240, 56, 12);
          pushPreThing(CastleBlock, xloc + 280, 56, [6, 1], true);
          pushPreThing(CastleBlock, xloc + 328, 24, [6, 1], true);

          pushPreFloor(xloc + 336, 0, bstretch);
          pushPreThing(Stone, xloc + 336, 24, bstretch);
          pushPreThing(Stone, xloc + 336, 56, bstretch);
          pushPreSectionPass(xloc + 360, 16, 40, 16);
          pushPreSectionFail(xloc + 360, 48, 40, 24);
          pushPreSectionFail(xloc + 360, 80, 40, 24);
          pushCastleDecider(xloc + 336 + bstretch * 8, 1);
        },
        2: function (xloc) {
          pushPreThing(Stone, xloc, 64, 1, 5);
          makeCeilingCastle(xloc, 33, 3);
          pushPreThing(Stone, xloc + 8, 80, 2, 2);
          pushPreFloor(xloc, 0, 10);
          pushPreFloor(xloc + 72, 24, 4);
          makeCeilingCastle(xloc + 72, 8);
          pushPreFloor(xloc + 96, 0, 4);
          pushPreFloor(xloc + 120, 24, 2);
          endCastleInside(xloc + 136);
        },
      };
    }),
  ];
}

function World51(map) {
  map.time = 300;
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(1),
  ];
  map.areas = [
    new Area("Overworld Alt", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backfence", -384, 0, 6);
      pushPreFloor(0, 0, 49);
      pushPreThing(Koopa, 128, 12);
      fillPreThing(Goomba, 152, 8, 3, 1, 12);
      fillPreThing(Goomba, 240, 8, 3, 1, 12);
      fillPreThing(Koopa, 328, 12, 2, 1, 12);
      pushPrePipe(352, 0, 24, true);

      pushPreFloor(408, 0, 41);
      pushPrePipe(408, 0, 24, true);
      pushPreThing(Koopa, 488, 32, false, true);
      fillPreThing(Goomba, 520, 8, 3, 1, 12);
      fillPreThing(Goomba, 608, 8, 3, 1, 12);
      pushPreThing(Koopa, 696, 16, false, true);
      pushPreThing(Stone, 712, 24, 1, 3);
      pushPreThing(Stone, 712, 32, 5);
      fillPreThing(Brick, 720, 64, 2, 1, 16);
      pushPreThing(Brick, 728, 64, Star);

      pushPreFloor(768, 0, 18);
      fillPreThing(Goomba, 824, 8, 3, 1, 12);
      pushPreThing(Cannon, 888, 16, 2);

      pushPreFloor(928, 0, 36);
      pushPreThing(Stone, 928, 24, 1, 3);
      fillPreThing(Goomba, 968, 8, 3, 1, 12);
      pushPreThing(Koopa, 1016, 12);
      fillPreThing(Goomba, 1080, 8, 3, 1, 12);
      fillPreThing(Koopa, 1152, 12, 2, 1, 12);
      pushPreThing(Stone, 1176, 32, 1, 4);
      pushPreThing(Block, 1184, jumplev1, [Mushroom, 1], true);
      fillPreThing(Brick, 1192, jumplev1, 2, 1, 8);

      pushPreFloor(1240, 0, 69);
      pushPreThing(Stone, 1248, jumplev1, 2);
      pushPrePipe(1248, jumplev1, 16, true, 2);
      pushPreThing(Cannon, 1272, 16, 2);
      pushPrePipe(1304, 0, 16, true, false, 1);
      pushPreThing(Cannon, 1360, 16, 2);
      pushPreThing(Koopa, 1424, 12, false, true);
      pushPreThing(Stone, 1456, 8);
      pushPreThing(Brick, 1456, 44);
      pushPreThing(Stone, 1464, 16, 1, 2);
      pushPreThing(Stone, 1472, 24, 1, 3);
      pushPreThing(Stone, 1480, 32, 1, 4);
      pushPreThing(Stone, 1488, 40, 1, 5);
      pushPreThing(Stone, 1512, 64, 2, 7);
      endCastleOutside(1588);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(2);
      makeCeiling(32, 7);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 32, 48, 7, 1, 8);
      pushPreThing(Brick, 32, 56);
      fillPreThing(Coin, 42, 55, 5, 2, 8, 8);
      fillPreThing(Brick, 80, 56, 1, 4, 8, 8);
      fillPreThing(Brick, 88, 56, 2, 1, 8);
      pushPreThing(Brick, 112, 48, Coin);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
  ];
}

function World52(map) {
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(0, entryNormal, 1032),
    new Location(1),
    new Location(2, enterCloudWorld),
  ];
  map.areas = [
    new Area("Overworld Alt", function () {
      setLocationGeneration(0);

      pushPreCastle();
      // pushPreScenery("Castle", -1 * unitsizet4, castlev);
      pushPreCastle(0, 0);
      pushPrePattern("backfence", -384, 0, 4);
      pushPrePattern("backfence", 1152, 0, 2);
      pushPreFloor(0, 0, 26);
      pushPreThing(Stone, 96, 8);
      pushPreThing(Stone, 104, 16, 1, 2);
      pushPreThing(Stone, 112, 24, 1, 3);
      pushPreThing(Stone, 120, 24, 1, 3);
      pushPreThing(Stone, 120, 32, 4);
      pushPreThing(Cannon, 136, 48, 2);
      fillPreThing(Coin, 169, 71, 3, 1, 8);
      pushPreThing(Koopa, 184, 12);
      pushPreThing(Springboard, 200, 14.5);

      pushPreFloor(232, 0, 37);
      fillPreThing(Brick, 232, jumplev1, 6, 1, 8);
      fillPreThing(Brick, 232, jumplev2, 5, 1, 8);
      fillPreThing(Coin, 233, 39, 3, 1, 8);
      pushPreThing(Brick, 272, jumplev2, Mushroom);
      pushPreThing(Koopa, 320, 32, false, true);
      pushPreThing(Stone, 352, 8);
      pushPreThing(Stone, 360, 16, 1, 2);
      pushPreThing(Stone, 368, 24, 1, 3);
      pushPreThing(HammerBro, 368, 36);
      pushPreThing(Stone, 376, 32, 2, 4);
      pushPreThing(Stone, 392, 16, 1, 2);
      pushPrePipe(440, 0, 24, true, 3);
      pushPreThing(Stone, 496, 8);
      pushPreThing(Stone, 504, 16, 1, 2);
      pushPreThing(Goomba, 504, 24);
      pushPreThing(Stone, 512, 24, 1, 3);
      pushPreThing(Stone, 520, 32, 1, 4);
      pushPreThing(Goomba, 520, 40);

      pushPreFloor(544, 0, 24);
      pushPreThing(Stone, 544, 40, 1, 5);
      pushPreThing(Stone, 552, 48, 2, 6);
      fillPreThing(Block, 624, jumplev1, 5, 1, 8);
      pushPreThing(HammerBro, 648, 46);
      pushPreThing(Block, 672, jumplev1, Coin, true);
      pushPreThing(Brick, 680, jumplev2, [Vine, 4]);
      fillPreThing(Brick, 688, jumplev2, 2, 1, 8);
      fillPreThing(Coin, 689, 71, 2, 1, 8);
      fillPreThing(Brick, 712, 40, 3, 1, 8);
      fillPreThing(Coin, 713, 7, 2, 1, 8);

      pushPreFloor(768, 0, 31);
      pushPreThing(Koopa, 848, 32, false, true);
      pushPreThing(Cannon, 856, 16, 2);
      pushPrePipe(920, 0, 16, true, false, 1);
      fillPreThing(Brick, 944, jumplev1, 8, 1, 8);
      fillPreThing(Brick, 944, jumplev2, 7, 1, 8);
      pushPreThing(HammerBro, 960, 44);
      pushPreThing(HammerBro, 992, 76);
      pushPreThing(Brick, 1000, jumplev2, Star);

      pushPreFloor(1032, 0, 15);
      pushPreThing(Stone, 1032, 24, 1, 3);
      fillPreThing(Beetle, 1088, 8.5, 3, 1, 8.5);
      pushPreThing(Brick, 1128, 16, Coin);
      pushPreThing(Brick, 1136, 16, Mushroom);

      fillPreThing(Brick, 1176, 32, 3, 1, 8);
      pushPreFloor(1208, 0, 19);
      fillPreThing(Brick, 1224, jumplev2, 5, 1, 8);
      fillPreThing(Goomba, 1240, 8, 2, 1, 12);
      pushPreThing(Koopa, 1256, 76, true);
      pushPreThing(Koopa, 1304, 28, false, true);
      pushPreThing(Koopa, 1328, 20, false, true);
      pushPreThing(Block, 1344, 32, Mushroom);

      fillPreThing(Brick, 1376, jumplev2, 4, 1, 8);
      fillPreThing(Coin, 1377, 71, 2, 1, 8);
      pushPreFloor(1384, 0, 2);
      pushPrePipe(1384, 0, 16);

      pushPreFloor(1416, 0, 8);
      pushPreThing(Stone, 1464, 8);
      pushPreThing(Stone, 1472, 16, 1, 2);

      pushPreThing(SceneryBlocker, 1480, 8);
      pushPreFloor(1488, 0, 2);
      pushPreThing(Stone, 1488, 32, 1, 4);
      pushPreThing(Koopa, 1488, 64, false, true);
      pushPreThing(Stone, 1496, 40, 1, 5);

      pushPreFloor(1512, 0, 35);
      pushPreThing(Stone, 1512, 56, 1, 7);
      pushPreThing(Stone, 1520, 64, 2, 8);
      endCastleOutside(1596);
    }),
    new Area("Underwater", function () {
      setLocationGeneration(3);

      goUnderWater();

      pushPreFloor(0, 0, 22);
      pushPreThing(Stone, 88, 56, 5);
      pushPreThing(Coral, 96, 24, 3);
      pushPreThing(Coral, 120, 72, 2);
      pushPreThing(Blooper, 136, 24);
      pushPreThing(Coral, 160, 32, 4);
      fillPreThing(Coin, 177, 47, 10, 1, 8, 8);

      pushPrePlatformGenerator(182, 6, 1);
      pushPreFloor(208, 24, 2);
      pushPreThing(Stone, 208, 88, 2, 3);
      pushPreThing(CheepCheep, 220, 60);
      pushPrePlatformGenerator(230, 6, 1);
      pushPreFloor(256, 24, 2);
      pushPreThing(Stone, 256, 88, 2, 3);
      pushPreFloor(272, 0, 4);
      pushPreThing(Blooper, 272, 24);

      pushPreThing(Coral, 304, 64, 4);
      pushPreThing(Stone, 304, 72, 6);
      pushPreThing(CheepCheep, 312, 20);
      pushPreFloor(320, 0, 2);
      fillPreThing(Coin, 321, 7, 2, 1, 8);
      pushPreThing(Coral, 344, 64, 4);
      pushPreThing(Blooper, 348, 22);
      pushPreFloor(352, 0, 21);
      pushPreThing(Coral, 368, 16, 2);

      pushPreThing(CheepCheep, 388, 40, true);
      pushPreThing(Stone, 400, 32, 4);
      fillPreThing(Coin, 401, 39, 4, 1, 8);
      pushPreThing(CheepCheep, 424, 84);
      pushPreThing(Stone, 432, 56, 4);
      fillPreThing(Coin, 433, 63, 4, 1, 8);

      pushPreThing(Stone, 472, 8);
      pushPreThing(Stone, 480, 16, 1, 2);
      pushPreThing(Stone, 488, 32, 2, 4);
      pushPreThing(Stone, 488, 88, 2, 4);
      pushPreThing(PipeSide, 496, 48, 1);
      pushPreThing(Stone, 504, 88, 2, 11);
    }),
    new Area("Sky", function () {
      setLocationGeneration(4);

      pushPreThing(Stone, 0, 0, 4);
      pushPreThing(Stone, 40, 0, 72);
      pushPreThing(Platform, 120, 32, 8, collideTransport);
      fillPreThing(Stone, 120, 64, 16, 1, 8);
      fillPreThing(Stone, 256, 80, 3, 1, 8);
      fillPreThing(Stone, 288, 72, 16, 1, 8);
      fillPreThing(Stone, 424, 80, 3, 1, 8);

      setExitLoc(2);
    }),
  ];
}

function World53(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle(0, 0);
      pushPrePattern("backcloud", 0, 4, 8);
      pushPreFloor(0, 0, 16);

      pushPreTree(144, 8, 4);
      pushPreTree(192, 32, 8);
      pushPreTree(208, 64, 5);
      fillPreThing(Coin, 217, 71, 3, 1, 8, 8);
      pushPreThing(Koopa, 240, 76, true);
      pushPreTree(256, 8, 3);
      pushPreThing(Coin, 266, 15);
      pushPreTree(280, 40, 5);
      fillPreThing(Coin, 297, 87, 2, 1, 8);
      pushPreTree(320, 72, 7);
      fillPreThing(Goomba, 352, 80, 2, 1, 16);
      pushPreTree(400, 0, 4);
      fillPreThing(Coin, 402, 55, 2, 1, 8, 8);
      pushPreThing(Platform, 440, 56, 6, [moveFloating, -4, 56]);
      pushPreTree(472, 0, 5);
      pushPreThing(Block, 472, 24, Mushroom);
      pushPreTree(480, 64, 4);
      fillPreThing(Coin, 482, 71, 4, 1, 8);
      pushPreTree(520, 0, 5);
      pushPreTree(560, 32, 3);
      pushPreThing(Koopa, 592, 76, true, [16, 88]);
      pushPreTree(608, 56, 6);
      pushPreThing(Goomba, 640, 64);
      fillPreThing(Coin, 681, 63, 2, 1, 8, 8);
      pushPreThing(Platform, 688, 40, 6, [moveSliding, 660, 720]);
      fillPreThing(Coin, 745, 71, 2, 1, 8, 8);
      pushPreThing(Platform, 752, 32, 6, [moveSliding, 700, 776]);
      fillPreThing(Coin, 777, 71, 2, 1, 8, 8);
      pushPreTree(784, 16, 4);
      pushPreTree(832, 48, 8);
      pushPreThing(Koopa, 880, 60, true);
      pushPreTree(904, 0, 3);
      fillPreThing(Coin, 906, 7, 3, 1, 8, 8);
      pushPreThing(Koopa, 912, 68, true, [4, 76]);
      pushPreTree(928, 32, 4);
      fillPreThing(Coin, 962, 63, 2, 1, 8, 8);
      pushPreTree(976, 32, 4);

      pushPreFloor(1032, 0, 47);
      pushPreThing(Platform, 1048, 56, 6, [moveSliding, 1008, 1076]);
      pushPreThing(Koopa, 1064, 12, true);
      pushPreThing(Stone, 1112, 32, 2, 4);
      pushPreThing(Stone, 1120, 48, 2, 6);
      pushPreThing(Stone, 1136, 64, 2, 8);
      endCastleOutside(1212, 0, true, 13);
    }),
  ];
}

function World54(map) {
  map.time = 300;
  map.locs = [new Location(0, startCastle)];
  map.areas = [
    new Area("Castle", function () {
      setLocationGeneration(0);

      startCastleInside();

      makeCeilingCastle(40, 11, 3);
      pushPreFloor(40, 24, 11);

      fillPreWater(128, 0, 32);
      pushPreThing(Podoboo, 128, -32);
      pushPreThing(Stone, 144, 32, 2, 1);
      pushPreThing(Podoboo, 160, -24);
      pushPreThing(Stone, 176, 48, 3, 1);
      pushPreThing(CastleBlock, 184, 48, 12, true);
      pushPreThing(Block, 184, 80, Mushroom);
      pushPreThing(Stone, 216, 32, 2, 1);
      pushPreThing(Podoboo, 240, -32);

      pushPreFloor(256, 0, 52);
      pushPreThing(Stone, 256, 24, 2, 3);
      makeCeilingCastle(272, 49, 4);
      pushPreThing(Stone, 296, jumplev1, 36, 1);
      pushPreThing(CastleBlock, 344, 0, 6, true);
      pushPreThing(CastleBlock, 392, jumplev1, 6);
      pushPreThing(CastleBlock, 440, 0, 6, true);
      pushPreThing(CastleBlock, 440, jumplev2);
      pushPreThing(CastleBlock, 488, jumplev1, 6);
      pushPreThing(CastleBlock, 536, 0, 6);
      pushPreThing(CastleBlock, 584, jumplev1, 6);
      pushPreThing(Stone, 640, 24, 4, 3);
      pushPreThing(CastleBlock, 656, 56, 6);

      pushPrePlatformGenerator(686, 3, -1);
      pushPrePlatformGenerator(710, 3, 1);

      pushPreFloor(736, 16);
      pushPreThing(CastleBlock, 736, 24, 6, true);
      pushPreFloor(744, 24, 6);
      makeCeilingCastle(744, 6, 3);
      pushPreFloor(792, 0, 10);
      fillPreThing(Coin, 817, 7, 3, 2, 8, 32);
      pushPreThing(CastleBlock, 824, 16, 6, -1.17);
      fillPreWater(872, 0, 4);
      pushPreThing(Stone, 864, 24, 1, 3);
      pushPreThing(Podoboo, 872, -32);
      pushPreFloor(888, 24, 2);
      fillPreWater(904, 0, 4);

      pushPreFloor(920, 0, 13);
      pushPreThing(Stone, 920, 24, 5, 3);
      makeCeilingCastle(920, 13, 3);
      fillPreThing(Stone, 976, 24, 2, 1, 32, 0, 2, 3);
      pushPreThing(Podoboo, 904, -32);

      fillPreThing(Brick, 1024, 64, 6, 1, 8);
      endCastleInside(1024);
      pushPreThing(Podoboo, 1048, -40);
    }),
  ];
}

function World61(map) {
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld Night", function () {
      setLocationGeneration(0);

      pushPreCastle(0, 0, true);
      pushPrePattern("backreg", 0, 0, 4);
      pushPreFloor(0, 0, 20);
      pushPreThing(Lakitu, 184, 84);
      fillPreThing(Block, 128, jumplev1, 2, 1, 8);

      pushPreFloor(176, 0, 9);
      pushPreThing(Stone, 208, 8, 6);
      pushPreThing(Stone, 232, 16, 5);
      pushPreThing(Stone, 256, 24, 4);
      pushPreThing(Stone, 280, 32, 3);
      pushPreThing(Brick, 288, jumplev2, Mushroom);
      pushPreFloor(296, 0, 2);
      pushPreThing(Brick, 296, jumplev2);

      pushPreFloor(328, 0, 16);
      fillPreThing(Brick, 328, jumplev1, 2, 1, 8);
      pushPreThing(Brick, 344, jumplev1, Coin);

      pushPreFloor(472, 0, 15);
      fillPreThing(Coin, 497, jumplev1 - 1, 3, 1, 8);
      pushPreThing(Stone, 552, 8);
      pushPreThing(Stone, 560, 16, 1, 2);
      pushPreThing(Stone, 568, 24, 1, 3);
      pushPreThing(Stone, 576, 32, 2, 4);

      fillPreThing(Coin, 609, 47, 2, 1, 8);
      pushPreFloor(616, 0, 16);
      pushPreThing(Stone, 672, 16);
      pushPreThing(Stone, 680, 24, 1, 2);
      pushPreThing(Stone, 696, 40, 1, 5);
      pushPreThing(Stone, 704, 48, 1, 6);
      pushPreThing(Stone, 712, 56, 1, 7);
      pushPreThing(Block, 720, 40, [Mushroom, 1], true);
      fillPreThing(Brick, 720, 56, 3, 1, 8);
      fillPreThing(Brick, 736, 24, 3, 1, 8);

      pushPreFloor(768, 0, 31);
      pushPrePipe(816, 0, 24, true);
      fillPreThing(Coin, 841, 39, 3, 1, 8);
      fillPreThing(Block, 904, jumplev1, 1, 2, 0, 32, Coin, true);
      pushPreThing(Stone, 976, 8);
      pushPreThing(Stone, 984, 16, 1, 2);
      pushPreThing(Stone, 992, 24, 1, 3);
      pushPreThing(Stone, 1000, 32, 1, 4);
      pushPreThing(Stone, 1008, 40, 1, 5);
      fillPreThing(Brick, 1016, 40, 2, 1, 8);
      fillPreThing(Brick, 1040, 8, 5, 1, 8);
      pushPreThing(Block, 1040, 40, Mushroom);
      pushPreThing(Block, 1048, 40);
      pushPreFloor(1072, 0, 2);

      pushPreFloor(1096, 0, 12);
      pushPreThing(Stone, 1144, 8);
      pushPreThing(Stone, 1152, 16, 1, 2);
      pushPreThing(Stone, 1160, 24, 1, 3);
      pushPreThing(Stone, 1168, 32, 1, 4);
      pushPreThing(Stone, 1176, 40, 1, 5);
      pushPreThing(Stone, 1184, 48, 1, 6);
      fillPreThing(Brick, 1192, 48, 2, 1, 8);
      pushPreThing(Brick, 1208, 32);
      fillPreThing(Brick, 1216, 16, 3, 1, 8);
      pushPreThing(Brick, 1216, 32, Coin);
      pushPreFloor(1240, 0, 9);

      pushPreFloor(1336, 0, 7);
      pushPreThing(Stone, 1352, 8);
      pushPreThing(Stone, 1360, 16, 1, 2);
      pushPreThing(Stone, 1368, 24, 1, 3);
      pushPreThing(Stone, 1376, 32, 1, 4);
      pushPreThing(Stone, 1384, 40, 1, 5);

      pushPreFloor(1408, 0, 30);
      pushPreFuncCollider(1408, zoneDisableLakitu);
      pushPreThing(Stone, 1408, 64, 2, 8);
      endCastleOutside(1484);
    }),
  ];
}

function World62(map) {
  map.locs = [
    new Location(0, true), // 0: main entrance
    new Location(0, exitPipeVert), // 1: exit first underworld
    new Location(0, exitPipeVert), // 2: exit underwater
    new Location(0, false, 1304), // 3: exit cloud world
    new Location(0, exitPipeVert), // 4: exit second underworld
    new Location(1), // 5: enter first underworld
    new Location(2), // 6: enter underwater
    new Location(3, enterCloudWorld), // 7: enter sky
    new Location(4), // 8: enter second underworld
  ];
  map.areas = [
    new Area("Overworld Night", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backreg", 0, 0, 5);
      pushPreFloor(0, 0, 123);
      fillPreThing(Brick, 80, jumplev1, 3, 1, 8);
      pushPrePipe(152, 0, 32, true, 5); // enter first underworld
      pushPreThing(Brick, 184, jumplev2);
      pushPreThing(Block, 192, jumplev1, Coin, true);
      pushPreThing(Brick, 192, jumplev2, Coin);
      pushPreThing(Brick, 200, jumplev2);
      pushPreThing(Koopa, 208, 12);
      pushPrePipe(224, 0, 32, true);
      pushPreThing(Stone, 256, 40, 2);
      pushPrePipe(256, 40, 16, true);
      pushPrePipe(280, 0, 16, true, false, 1); // exit first underworld
      pushPrePipe(296, 0, 16, true);
      pushPreThing(Koopa, 344, 32, false, true);
      pushPrePipe(368, 0, 32, true);
      pushPreThing(Brick, 408, jumplev1);
      pushPreThing(Brick, 416, jumplev1, Mushroom);
      pushPreThing(Beetle, 432, 8.5);
      pushPrePipe(448, 0, 40, true, 6); // enter underwater
      pushPreThing(Stone, 496, jumplev1, 2);
      pushPrePipe(496, jumplev1, 16, true);
      pushPrePipe(536, 0, 16, true);
      fillPreThing(Brick, 536, jumplev2, 5, 1, 8);
      pushPreThing(Goomba, 536, 72);
      pushPrePipe(592, 0, 16, true);
      fillPreThing(Brick, 616, jumplev2, 4, 1, 8);
      pushPrePipe(640, 0, 24, true);
      pushPreThing(Brick, 648, jumplev2, [Vine, 7]); // enter cloud world
      pushPreThing(Block, 656, jumplev1, Coin, true);
      pushPrePipe(672, 0, 16, true);
      pushPrePipe(696, 0, 48, true);
      pushPreThing(Beetle, 736, 8.5);
      pushPrePipe(752, 0, 24, true);
      pushPrePipe(816, 0, 32);
      pushPrePipe(840, 0, 16, true);
      fillPreThing(Brick, 880, jumplev1, 2, 1, 24);
      pushPreThing(Stone, 888, jumplev1, 2);
      pushPrePipe(888, jumplev1, 24, true);
      pushPrePipe(920, 0, 16, true, false, 2); // exit underwater
      pushPreThing(Brick, 920, jumplev2);
      fillPreThing(Brick, 952, jumplev2, 9, 1, 8);
      pushPreThing(Beetle, 960, 72.5);

      pushPreFloor(1032, 0, 12);
      pushPrePipe(1048, 0, 16, true);
      pushPrePipe(1080, 0, 16, true);
      fillPreThing(Brick, 1104, 40, 2, 1, 8);
      pushPreThing(Brick, 1120, 64, Star);
      pushPreThing(Brick, 1128, 64);
      pushPreFloor(1136, 0, 1);

      pushPreFloor(1152, 0, 8);
      fillPreThing(Brick, 1152, jumplev1, 3, 1, 8);
      fillPreThing(Brick, 1160, jumplev2, 2, 1, 8);
      pushPreThing(Stone, 1192, 8);
      pushPreThing(Stone, 1200, 16, 1, 2);
      pushPreThing(Stone, 1208, 24, 1, 3);

      pushPreFloor(1224, 0, 87);
      pushPrePipe(1224, 0, 24, true, 8); // enter second underworld
      pushPreThing(Stone, 1248, 32, 1, 4);
      pushPreThing(Stone, 1256, 16, 1, 2);
      fillPreThing(Brick, 1280, jumplev1, 3, 2, 8, 32);
      pushPreThing(Beetle, 1304, 8.5);
      pushPreThing(Stone, 1336, jumplev1, 2);
      pushPrePipe(1336, jumplev1, 24, true);
      pushPreThing(Goomba, 1352, 8);
      pushPrePipe(1392, 0, 32, true);
      pushPrePipe(1432, 0, 16, true, false, 4); // exit second underworld
      pushPrePipe(1448, 0, 24, true);
      pushPrePipe(1464, 0, 32, true);
      pushPrePipe(1512, 0, 24, true);
      pushPreThing(Stone, 1592, 8);
      pushPreThing(Stone, 1600, 16, 1, 2);
      pushPrePipe(1608, 0, 32, true);
      pushPreThing(Stone, 1624, 40, 1, 5);
      pushPreThing(Stone, 1632, 48, 1, 6);
      pushPreThing(Stone, 1640, 56, 1, 7);
      pushPreThing(Stone, 1648, 64, 2, 8);
      pushPreThing(Koopa, 1648, 84, false, true);
      endCastleOutside(1724);
    }),
    new Area("Underworld", function () {
      // first underworld
      setLocationGeneration(5);

      makeCeiling(32, 7);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 32, 48, 7, 1, 8);
      pushPreThing(Brick, 32, 56);
      fillPreThing(Coin, 42, 55, 5, 2, 8, 8);
      fillPreThing(Brick, 80, 56, 1, 4, 8, 8);
      fillPreThing(Brick, 88, 56, 2, 1, 8);
      pushPreThing(Brick, 112, 48, Coin);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
    new Area("Underwater", function () {
      // underwater
      setLocationGeneration(6);
      goUnderWater();

      pushPreFloor(0, 0, 22);
      pushPreThing(Stone, 88, 56, 5);
      pushPreThing(Coral, 96, 24, 3);
      pushPreThing(Coral, 120, 72, 2);
      pushPreThing(Blooper, 136, 24);
      pushPreThing(Coral, 160, 32, 4);
      fillPreThing(Coin, 177, 47, 10, 1, 8, 8);

      pushPrePlatformGenerator(186, 4, 1);
      pushPreFloor(208, 24, 2);
      pushPreThing(Stone, 208, 88, 2, 3);
      pushPreThing(CheepCheep, 220, 60);
      pushPrePlatformGenerator(234, 4, 1);
      pushPreFloor(256, 24, 2);
      pushPreThing(Stone, 256, 88, 2, 3);
      pushPreFloor(272, 0, 4);
      pushPreThing(Blooper, 272, 24);

      pushPreThing(Coral, 304, 64, 4);
      pushPreThing(Stone, 304, 72, 6);
      pushPreThing(CheepCheep, 312, 20);
      pushPreFloor(320, 0, 2);
      fillPreThing(Coin, 321, 7, 2, 1, 8);
      pushPreThing(Coral, 344, 64, 4);
      pushPreThing(Blooper, 348, 22);
      pushPreFloor(352, 0, 21);
      pushPreThing(Coral, 368, 16, 2);

      pushPreThing(CheepCheep, 388, 40, true);
      pushPreThing(Stone, 400, 32, 4);
      fillPreThing(Coin, 401, 39, 4, 1, 8);
      pushPreThing(CheepCheep, 424, 84);
      pushPreThing(Stone, 432, 56, 4);
      fillPreThing(Coin, 433, 63, 4, 1, 8);

      pushPreThing(Stone, 472, 8);
      pushPreThing(Stone, 480, 16, 1, 2);
      pushPreThing(Stone, 488, 32, 2, 4);
      pushPreThing(Stone, 488, 88, 2, 4);
      pushPreThing(PipeSide, 496, 48, 2);
      pushPreThing(Stone, 504, 88, 2, 11);
    }),
    new Area("Sky Night", function () {
      // cloud world
      setLocationGeneration(7);

      pushPreThing(Stone, 0, 0, 4);
      pushPreThing(Stone, 40, 0, 78);
      pushPreThing(Platform, 128, 24, 6, collideTransport);
      fillPreThing(Coin, 121, 55, 16, 1, 8);
      pushPreThing(Stone, 256, 40);
      fillPreThing(Coin, 273, 55, 16, 1, 8);
      pushPreThing(Stone, 408, 48, 1, 2);
      fillPreThing(Coin, 425, 63, 7, 1, 8);
      pushPreThing(Stone, 488, 48, 1, 2);
      pushPreThing(Stone, 536, 56, 2);
      fillPreThing(Stone, 568, 56, 5, 1, 16);
      fillPreThing(Coin, 569, 63, 10, 1, 8);
      fillPreThing(Coin, 681, 15, 3, 1, 8);

      setExitLoc(3);
    }),
    new Area("Underworld", function () {
      // second underworld
      setLocationGeneration(8);

      makeCeiling(32, 11);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 24, 16, 1, 3, 8, 8);
      fillPreThing(Coin, 25, 39, 8, 1, 8);
      fillPreThing(Coin, 25, 7, 10, 1, 8);
      fillPreThing(Brick, 32, 32, 6, 1, 8);
      fillPreThing(Brick, 80, 16, 1, 3, 8, 8);
      pushPreThing(PipeSide, 104, 16, 4);
      pushPreThing(Brick, 104, 32, Mushroom);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
  ];
}

function World63(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld Night Alt2", function () {
      setLocationGeneration(0);
      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 4);
      pushPreFloor(0, 0, 16);

      pushPreTree(144, 0, 3);
      pushPreTree(168, 32, 3);
      pushPreTree(192, 0, 3);
      pushPreThing(Platform, 224, 0, 4, [moveFloating, 0, 56]); // should move up and down
      fillPreThing(Coin, 226, 87, 2, 1, 8);

      pushPreTree(248, 32, 4);
      pushPreTree(296, 0, 3);
      pushPreThing(Springboard, 304, 14.5);
      pushPreTree(344, 0, 3);
      fillPreThing(Coin, 345, 71, 7, 1, 8);
      pushPreThing(Platform, 348, 64, 4, [moveSliding, 312, 364]);
      pushPreThing(Platform, 388, 47, 4, [moveSliding, 356, 400]);
      pushPreTree(392, 16, 4);

      pushPreThing(Block, 440, 80, Mushroom);
      pushPreThing(Platform, 444, 56, 4, [moveSliding, 408, 464]);
      pushPreThing(Platform, 480, 7, 4, [moveFloating, -8, 52]);
      pushPreTree(520, 32, 5);

      pushPreScale(572, 86, 8, [4, 4, 12]);
      pushPreScale(636, 86, 6, [4, 4, 12]);

      pushPreTree(680, 24, 5);
      pushPreTree(680, 80, 3);
      fillPreThing(Coin, 681, 87, 3, 1, 8);
      pushPreTree(720, 40, 3);
      pushPreTree(744, 0, 3);
      pushPreTree(776, 0, 4);
      fillPreThing(Coin, 801, 39, 4, 1, 8);
      pushPreTree(824, 0, 3);
      pushPreTree(856, 32, 5);
      pushPreTree(904, 0, 5);
      pushPreThing(Springboard, 928, 14.5);

      pushPreThing(Platform, 972, 63, 4, [moveSliding, 940, 992]);
      pushPreTree(984, 0, 3);
      pushPreScale(1020, 86, 6, [4, 6, 12]);
      pushPreTree(1056, 0, 4);
      pushPreTree(1056, 64, 3);
      pushPreTree(1080, 32, 4);

      pushPreThing(Platform, 1128, 47, 4, moveFalling);
      pushPreThing(Platform, 1160, 55, 4, moveFalling);
      fillPreThing(Coin, 1161, 47, 2, 1, 8);
      pushPreThing(Platform, 1192, 39, 4, moveFalling);
      pushPreThing(Platform, 1224, 47, 4, moveFalling);
      fillPreThing(Coin, 1233, 79, 2, 1, 8);
      pushPreTree(1248, 64, 3);

      pushPreFloor(1280, 0, 32);
      endCastleOutside(1332, 0, true, 13, 28);
    }),
  ];
}

function World64(map) {
  map.time = 300;
  map.locs = [new Location(0, startCastle)];
  map.areas = [
    new Area("Castle", function () {
      setLocationGeneration(0);

      startCastleInside();

      makeCeilingCastle(40, 19, 3);
      pushPreFloor(40, 24, 8);
      fillPreWater(104, 8, 4);

      pushPreFloor(120, 24, 11);
      pushPreThing(Stone, 184, 64, 1, 1);
      pushPreThing(CastleBlock, 184, 56, 6);
      makeCeilingCastle(192, 136);
      fillPreWater(208, 0, 6);
      pushPreThing(Podoboo, 216, -32);

      pushPreFloor(232, 24, 3);
      pushPreThing(CastleBlock, 240, 24, 6);
      pushPreThing(Block, 240, 56, Mushroom);
      fillPreWater(256, 0, 6);
      pushPreThing(Podoboo, 264, -32);

      pushPreThing(Stone, 280, 32, 37, 1);
      pushPreThing(Stone, 280, 24, 69, 3);
      pushPreFloor(280, 0, 93);
      pushPreThing(Stone, 296, 80, 35, 3);
      pushPreThing(CastleBlock, 296, 56, 6);
      pushPreThing(CastleBlock, 392, 56, 6);
      pushPreThing(CastleBlock, 480, 56, 6);
      pushPreThing(CastleBlock, 536, 56, 6);
      pushPreThing(CastleBlock, 608, 32, 6);
      pushPreThing(Stone, 640, 80, 1, 1);
      pushPreThing(CastleBlock, 640, 72, 6);
      pushPreThing(CastleBlock, 672, 32, 6);
      pushPreThing(Stone, 704, 80, 1, 1);
      pushPreThing(CastleBlock, 704, 72, 6, true);
      pushPreThing(CastleBlock, 736, 32, 6);
      pushPreThing(Stone, 776, 80, 7, 2);
      pushPreThing(Block, 848, 32, Coin, true);
      pushPreThing(Block, 872, 32, Coin, true);
      pushPreThing(Block, 896, 32, Coin, true);
      pushPreThing(Block, 856, 64, Coin, true);
      pushPreThing(Block, 880, 64, Coin, true);
      pushPreThing(Block, 904, 64, Coin, true);
      pushPreThing(Stone, 928, 24, 4, 3);
      pushPreThing(Stone, 984, 24, 5, 3);
      pushPreThing(Stone, 984, 80, 5, 2);

      endCastleInside(1024, 0, 1);
    }),
  ];
}

function World71(map) {
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(1),
  ];
  map.areas = [
    new Area("Overworld Alt", function () {
      setLocationGeneration(0);

      pushPreCastle(0, 0, true);
      pushPrePattern("backfence", 0, 0, 6);
      pushPreFloor(0, 0, 73);
      pushPreThing(Cannon, 152, 16, 2);
      pushPreThing(Koopa, 208, 22, false, true);
      pushPreThing(Brick, 216, jumplev2, Mushroom);
      pushPreThing(Cannon, 224, 8, 1);
      pushPreThing(Cannon, 224, 24, 2);
      fillPreThing(Brick, 224, jumplev2, 2, 1, 8);
      pushPreThing(Cannon, 288, 16, 2);
      fillPreThing(Block, 312, jumplev1, 4, 1, 8);
      pushPreThing(Koopa, 352, 28, false, true);
      pushPreThing(Cannon, 368, 24, 3);
      pushPreThing(Koopa, 424, 22, false, true);
      pushPreThing(Cannon, 448, 8);
      pushPreThing(Cannon, 448, 24, 2);
      fillPreThing(Brick, 496, jumplev1, 2, 1, 8);
      pushPreThing(Stone, 512, jumplev1);
      pushPreThing(Cannon, 512, 48, 2);
      pushPreThing(Koopa, 520, 16, false, true);
      pushPreThing(Brick, 520, jumplev1, Coin);
      pushPreThing(Brick, 528, jumplev1);
      pushPreThing(Cannon, 544, 16, 2);

      pushPreFloor(600, 0, 77);
      pushPrePipe(608, 0, 24, true);
      fillPreThing(Brick, 656, jumplev1, 7, 2, 8, 32);
      pushPreThing(HammerBro, 680, 44);
      pushPreThing(HammerBro, 692, 76);
      pushPrePipe(744, 0, 24, true, 2);
      pushPreThing(Block, 744, jumplev2, [Mushroom, 1], true);
      pushPreThing(Cannon, 832, 16, 2);
      pushPrePipe(872, 0, 24, true);
      pushPreThing(Koopa, 912, 12);
      pushPrePipe(920, 0, 16, true, false, 1);
      pushPreThing(Cannon, 976, 16, 2);
      pushPrePipe(1024, 0, 16, true);
      fillPreThing(Brick, 1072, jumplev1, 5, 2, 8, 32);
      pushPreThing(HammerBro, 1080, 12);
      pushPreThing(HammerBro, 1096, 44);
      pushPreThing(Stone, 1128, 24, 1, 3);
      pushPreThing(Cannon, 1168, 8);
      pushPreThing(Cannon, 1168, 24, 2);
      fillPreThing(Brick, 1192, 40, 2, 1, 8);
      pushPreThing(Springboard, 1208, 14.5);
      pushPreThing(Brick, 1208, 88, Mushroom);

      pushPreFloor(1224, 0, 50);
      pushPreThing(Stone, 1224, 8);
      fillPreThing(Brick, 1224, 56, 2, 1, 8);
      pushPreThing(Stone, 1232, 16, 1, 2);
      pushPreThing(Stone, 1240, 24, 1, 3);
      pushPreThing(Stone, 1248, 32, 1, 4);
      pushPreThing(Stone, 1256, 40, 1, 5);
      pushPreThing(Stone, 1264, 48, 1, 6);

      pushPreThing(Stone, 1296, 8);
      pushPreThing(Stone, 1304, 16, 1, 2);
      pushPreThing(Stone, 1312, 24, 1, 3);
      pushPreThing(Stone, 1320, 32, 1, 4);
      pushPreThing(Stone, 1328, 40, 1, 5);
      pushPreThing(Stone, 1336, 48, 1, 6);
      pushPreThing(Stone, 1344, 56, 1, 7);
      pushPreThing(Stone, 1352, 64, 2, 8);
      pushPreThing(Beetle, 1352, 72.5);

      endCastleOutside(1428);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(2);

      makeCeiling(32, 7);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 32, 8, 7, 3, 8, 8);
      fillPreThing(Coin, 33, 31, 7, 2, 8, 16);
      fillPreThing(Coin, 41, 63, 5, 1, 8, 8);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
  ];
}

function World72(map) {
  map.locs = [
    new Location(0, walkToPipe),
    new Location(1),
    new Location(2, exitPipeVert),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 2);
      pushPreFloor(0, 0, 24);
      pushPreThing(PipeSide, 80, 16, 1);
      pushPrePipe(96, 0, 32);
    }),
    new Area("Underwater", function () {
      setLocationGeneration(1);
      goUnderWater();

      pushPreFloor(0, 0, 67);
      pushPreThing(Coral, 96, 24, 3);
      fillPreThing(Coin, 120, 7, 2, 1, 8);
      pushPreThing(Stone, 152, jumplev1, 3, 1);
      pushPreThing(Blooper, 184, 16);
      pushPreThing(Blooper, 208, 46);
      fillPreThing(Coin, 224, jumplev2, 3, 1, 8);
      pushPreThing(Coral, 272, 40, 5);
      fillPreThing(Coin, 296, 7, 3, 1, 8);
      pushPreThing(Stone, 344, jumplev1, 2, 1);
      pushPreThing(Coral, 344, jumplev1 + 16, 2);
      pushPreThing(Blooper, 376, jumplev1);
      pushPreThing(Coral, 408, 32, 4);
      pushPreThing(Blooper, 424, 46);
      pushPreThing(Blooper, 448, 24);
      pushPreThing(Stone, 520, 24, 1, 3);
      pushPreThing(Stone, 528, 40, 1, 5);
      fillPreThing(Coin, 546, 23, 3, 1, 8);

      pushPreFloor(576, 0, 60);
      pushPreThing(Stone, 576, 40, 1, 5);
      pushPreThing(Stone, 584, 24, 1, 3);
      pushPreThing(CheepCheep, 616, 24, false, false);
      pushPreThing(Stone, 632, 24, 2, 3);
      pushPreThing(Stone, 632, 88, 2, 3);
      pushPreThing(Blooper, 624, 54);
      pushPreThing(CheepCheep, 640, 48, false, false);
      pushPreThing(CheepCheep, 656, 16, false, false);
      pushPreThing(Stone, 664, 64, 3, 1);
      pushPreThing(Blooper, 672, 40, false, false);
      pushPreThing(Coral, 672, 80, 2);
      pushPreThing(Coral, 720, 24, 3);
      pushPreThing(Blooper, 728, 16);
      pushPreThing(Blooper, 760, 80);
      pushPreThing(CheepCheep, 760, 56, false, false);
      pushPreThing(CheepCheep, 784, 80, true, false);
      fillPreThing(Coin, 816, 15, 3, 1, 8);
      pushPreThing(CheepCheep, 816, 24, false, false);
      pushPreThing(Stone, 824, 32, 2, 1);
      pushPreThing(Coral, 824, 64, 4);
      pushPreThing(Blooper, 848, 16);
      fillPreThing(Coin, 912, 55, 3, 1, 8, 8);
      pushPreThing(Stone, 928, 40, 2, 1);
      pushPreThing(CheepCheep, 944, 72, false, false);
      pushPreThing(Coral, 968, 32, 4);
      pushPreThing(CheepCheep, 1032, 24, true, false);
      pushPreThing(Stone, 1040, 32, 1, 4);
      pushPreThing(Stone, 1048, 16, 1, 2);
      pushPreThing(CheepCheep, 1056, 16, false, false);
      pushPreThing(Stone, 1056, 88, 1, 3);
      pushPreThing(Stone, 1064, 72, 8, 1);
      pushPreThing(Coin, 1072, 15);
      fillPreThing(Coin, 1080, 7, 3, 1, 8);
      pushPreThing(Coin, 1104, 15);
      pushPreThing(CheepCheep, 1100, 40, false, false);
      pushPreFloor(1128, 0, 17);
      pushPreThing(Stone, 1128, 16, 1, 2);
      pushPreThing(Stone, 1136, 32, 1, 4);
      pushPreThing(CheepCheep, 1160, 32, false, false);
      pushPreThing(Coral, 1184, 16, 2);
      pushPreThing(Coral, 1200, 24, 3);
      pushPreThing(CheepCheep, 1206, 56, true, false);
      pushPreThing(Blooper, 1208, 38);
      pushPreThing(Stone, 1256, 64, 1, 8);
      pushPreThing(Stone, 1264, 64, 2, 1);
      fillPreThing(Coin, 1281, 32, 3, 2, 8, -24);
      pushPreThing(Stone, 1304, 64, 2, 1);
      pushPreFloor(1320, 0, 40);
      pushPreThing(Stone, 1320, 64, 1, 8);
      pushPreThing(CheepCheep, 1320, 80, false, false);
      pushPreThing(CheepCheep, 1344, 16, true, false);
      fillPreThing(Stone, 1384, 32, 1, 2, 0, 32, 5, 1);
      pushPreThing(Blooper, 1392, 14);
      pushPreThing(Coral, 1392, 80, 2);
      pushPreThing(CheepCheep, 1408, 40, false, false);
      pushPreThing(Blooper, 1440, 14);
      fillPreThing(Stone, 1448, 32, 1, 2, 0, 32, 4, 1);
      pushPreThing(CheepCheep, 1472, 72, true, false);
      pushPreThing(CheepCheep, 1496, 48, true, false);

      pushPreThing(Stone, 1488, 8, 5, 1);
      pushPreThing(Stone, 1496, 16, 4, 1);
      pushPreThing(Stone, 1504, 24, 3, 1);
      pushPreThing(Stone, 1512, 32, 2, 1);
      pushPreThing(Stone, 1512, 88, 2, 4);
      pushPreThing(PipeSide, 1520, 48, 2);
      pushPreThing(Stone, 1528, 88, 14, 11);
    }),
    new Area("Overworld", function () {
      setLocationGeneration(2);

      pushPrePattern("backreg", 104, 0, 1);
      pushPreFloor(0, 0, 42);
      pushPrePipe(0, 0, 16, true, false, 2);
      pushPreThing(Stone, 16, 8);
      pushPreThing(Stone, 24, 16, 1, 2);
      pushPreThing(Stone, 32, 24, 1, 3);
      pushPreThing(Stone, 40, 32, 1, 4);
      pushPreThing(Stone, 48, 40, 1, 5);
      pushPreThing(Stone, 56, 48, 1, 6);
      pushPreThing(Stone, 64, 56, 1, 7);
      pushPreThing(Stone, 72, 64, 1, 8);
      pushPreThing(Stone, 80, 64, 1, 8);
      endCastleOutside(148);
    }),
  ];
}

function World73(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPreCastle();
      pushPrePattern("backcloud", 0, 4, 5);

      pushPreFloor(0, 0, 7);
      zoneStartCheeps(64);
      pushPreTree(64, 0, 8);
      pushPreThing(Stone, 80, 8);
      pushPreThing(Stone, 88, 16, 1, 2);
      pushPreThing(Stone, 96, 24, 1, 3);
      pushPreThing(Stone, 104, 24, 1, 3);
      pushPreThing(Stone, 112, 24, 1, 3);
      pushPreBridge(120, 24, 16);
      pushPreThing(Stone, 248, 24, 1, DtB(24, 8));
      pushPreBridge(256, 24, 15);
      fillPreThing(Coin, 290, 63, 4, 1, 8, 8);
      pushPreThing(Koopa, 312, 36);
      pushPreThing(Stone, 376, 24, 1, DtB(24, 8));
      pushPreBridge(384, 24, 16);
      pushPreThing(Koopa, 416, 44, false, true);
      fillPreThing(Coin, 441, 63, 3, 1, 16);
      fillPreThing(Coin, 449, 55, 2, 1, 16);
      pushPreThing(Stone, 504, 24, 1, DtB(24, 8));

      pushPreThing(Stone, 544, 24, 1, DtB(24, 8));
      pushPreBridge(552, 24, 10);
      fillPreThing(Coin, 578, 63, 2, 1, 24);
      fillPreThing(Coin, 586, 71, 2, 1, 8);
      pushPreThing(Stone, 632, 24, 1, DtB(24, 8));
      pushPreThing(Koopa, 632, 36, true, false);

      pushPreThing(Stone, 672, 24, 1, DtB(24, 8));
      pushPreBridge(680, 24, 10);
      pushPreThing(Stone, 760, 24, 1, DtB(24, 8));
      pushPreThing(Koopa, 760, 36, true, false);

      fillPreThing(Coin, 777, 63, 3, 1, 8);
      pushPreThing(Stone, 792, 32, 1, DtB(24, 8));
      pushPreBridge(800, 32, 5, [true, true]);
      pushPreThing(Block, 816, 64, Mushroom);

      fillPreThing(Coin, 865, 63, 3, 1, 8);
      pushPreTree(896, 0, 8);
      pushPreThing(Koopa, 952, 12, true);
      pushPreBridge(976, 24, 3);

      pushPreBridge(1024, 24, 15, [true, true]);
      fillPreThing(Coin, 1065, 63, 6, 1, 8);
      pushPreThing(Koopa, 1120, 52, false, true);

      pushPreBridge(1176, 8, 8, [true, true]);
      fillPreThing(Coin, 1193, 39, 4, 1, 8);
      pushPreThing(Koopa, 1248, 36, false, true);

      pushPreBridge(1280, 24, 8, [true, true]);

      pushPreBridge(1368, 24, 2);
      fillPreThing(Coin, 1385, 55, 6, 1, 8);
      pushPreBridge(1400, 24, 2);
      pushPreBridge(1432, 24, 2);
      pushPreBridge(1472, 24, 9, [true]);
      pushPreTree(1536, 0, 13);
      pushPreThing(Stone, 1544, 24, 1, 3);
      pushPreThing(Stone, 1552, 24, 1, 3);
      pushPreThing(Stone, 1560, 16, 1, 2);
      pushPreThing(Stone, 1568, 8);
      zoneStopCheeps(1600);

      pushPreFloor(1656, 0, 35);
      pushPreThing(Stone, 1664, 8);
      pushPreThing(Stone, 1672, 16, 1, 2);
      pushPreThing(Stone, 1680, 24, 1, 3);
      pushPreThing(Stone, 1688, 32, 1, 4);
      pushPreThing(Stone, 1696, 40, 1, 5);
      pushPreThing(Stone, 1704, 48, 1, 6);
      pushPreThing(Stone, 1712, 56, 1, 7);
      pushPreThing(Stone, 1720, 64, 1, 8);
      pushPreThing(Stone, 1728, 64, 1, 8);

      endCastleOutside(1796, 0, true, 6);
    }),
  ];
}

function World74(map) {
  map.locs = [new Location(0, startCastle)];
  map.areas = [
    new Area("Castle", function () {
      setLocationGeneration(0);
      startCastleInside();

      makeCeilingCastle(40, 11, 3);
      pushPreFloor(40, 24, 11);
      fillPreWater(128, 0, 22);
      makeCeilingCastle(128, 16);
      pushPreThing(Platform, 144, 48, 4, moveFalling); // falling
      pushPreThing(Podoboo, 160, -32);
      pushPreThing(Platform, 176, 40, 4, moveFalling); // falling

      pushPreThing(Stone, 216, 24, 5, DtB(24, 8));
      pushPreThing(Stone, 224, 80, 4, 2);

      this.sections = {
        start: 256,
        0: function (xloc) {
          pushPreFloor(xloc, 0, bstretch * 3 + 31);
          makeCeilingCastle(xloc, bstretch * 3 + 31);

          pushPreThing(Stone, xloc + 16, 32, 5);
          pushPreThing(Stone, xloc + 32, 40, 3);
          pushPreThing(Stone, xloc + 40, 48, 2);
          pushPreThing(Stone, xloc + 48, 56, 1);
          pushPreThing(Stone, xloc + 56, 56, bstretch, 4);

          pushPreSectionPass(xloc + (bstretch + 1) * 8, 24, 40, 24);
          pushPreSectionFail(xloc + (bstretch + 1) * 8, 80, 40, 24);

          pushPreThing(Stone, xloc + (bstretch + 11) * 8, 24, bstretch + 2);
          pushPreThing(Stone, xloc + (bstretch + 12) * 8, 56, bstretch);
          pushPreSectionFail(xloc + (bstretch * 2 + 6) * 8, 16, 40, 16);
          pushPreSectionPass(xloc + (bstretch * 2 + 6) * 8, 48, 40, 24);
          pushPreSectionFail(xloc + (bstretch * 2 + 6) * 8, 80, 40, 24);

          pushPreThing(
            Stone,
            xloc + (bstretch * 2 + 16) * 8,
            56,
            bstretch + 7,
            4
          );
          pushPreSectionFail(xloc + (bstretch * 2 + 17) * 8, 24, 40, 24);
          pushPreSectionPass(xloc + (bstretch * 2 + 17) * 8, 80, 40, 24);
          pushPreThing(Stone, xloc + (bstretch * 3 + 23) * 8, 40, 1);
          pushPreThing(Stone, xloc + (bstretch * 3 + 23) * 8, 48, 2);
          pushPreThing(Stone, xloc + (bstretch * 3 + 23) * 8, 56, 4);

          pushPreThing(Stone, xloc + (bstretch * 3 + 28) * 8, 24, 3, 3);
          pushCastleDecider(xloc + (bstretch * 3 + 31) * 8, 0);
        },
        1: function (xloc) {
          pushPreFloor(xloc, 24, 3);
          makeCeilingCastle(xloc, 17);
          pushPreFloor(xloc + 24, 0, 4);
          pushPreThing(Stone, xloc + 48, 56, 2);
          fillPreWater(xloc + 56, 0, 6);
          pushPreThing(Stone, xloc + 72, 56, 3);
          pushPreFloor(xloc + 80, 0);
          pushPreThing(CastleBlock, xloc + 80, 48, 6, true);
          fillPreWater(xloc + 88, 0, 6);
          pushPreThing(Stone, xloc + 104, 56, 4, 1);
          pushPreFloor(xloc + 112, 0, 3);

          pushPreSectionFail(xloc + 96 + (bstretch - 6) * 8, 24, 40, 24);
          pushPreSectionPass(xloc + 96 + (bstretch - 6) * 8, 80, 40, 24);
          pushPreFloor(xloc + 136, 0, bstretch - 5);
          pushPreThing(Stone, xloc + 136, 56, bstretch - 5, 4);
          makeCeilingCastle(xloc + 136, bstretch - 5);

          pushPreSectionFail(xloc + (bstretch * 2 + 9) * 8, 80, 40, 24);
          pushPreSectionPass(xloc + (bstretch * 2 + 10) * 8, 48, 32, 24);
          pushPreSectionFail(xloc + (bstretch * 2 + 10) * 8, 16, 40, 16);
          pushPreFloor(xloc + (bstretch + 12) * 8, 0, bstretch + 10);
          makeCeilingCastle(xloc + (bstretch + 12) * 8, bstretch + 10);
          pushPreThing(Stone, xloc + (bstretch + 14) * 8, 56, 3);
          pushPreThing(Stone, xloc + (bstretch + 15) * 8, 24, 3);
          pushPreThing(Stone, xloc + (bstretch + 19) * 8, 56, bstretch - 4);
          pushPreThing(Stone, xloc + (bstretch + 20) * 8, 24, bstretch - 4);
          pushPreThing(Stone, xloc + (bstretch * 2 + 17) * 8, 56, 3);
          pushPreThing(Stone, xloc + (bstretch * 2 + 18) * 8, 24, 3);

          pushPreFloor(xloc + (bstretch * 2 + 22) * 8, 0, bstretch + 12);
          makeCeilingCastle(xloc + (bstretch * 2 + 22) * 8, bstretch + 12);
          pushPreThing(Stone, xloc + (bstretch * 2 + 22) * 8, 48, 1, 3);
          pushPreThing(Stone, xloc + (bstretch * 2 + 22) * 8, 56, bstretch + 5);
          pushPreThing(Stone, xloc + (bstretch * 2 + 24) * 8, 8, bstretch + 10);
          pushPreThing(Stone, xloc + (bstretch * 2 + 25) * 8, 16, bstretch + 9);
          pushPreThing(Stone, xloc + (bstretch * 2 + 26) * 8, 24, bstretch + 8);
          pushPreSectionFail(xloc + (bstretch * 2 + 28) * 8, 48, 40, 24);
          pushPreSectionPass(xloc + (bstretch * 2 + 28) * 8, 80, 40, 24);
          pushCastleDecider(xloc + (bstretch * 3 + 34) * 8, 1);
        },
        2: function (xloc) {
          pushPreFloor(xloc, 0, 3);
          makeCeilingCastle(xloc, 32);
          pushPreFloor(xloc + 24, 24, 3);
          pushPreFloor(xloc + 48, 0, 2);
          pushPreFloor(xloc + 64, 24, 8);
          pushPreFloor(xloc + 128, 0, 2);
          pushPreFloor(xloc + 144, 24, 2);
          pushPreFloor(xloc + 160, 0, 2);
          pushPreFloor(xloc + 176, 24, 2);
          pushPreFloor(xloc + 192, 0, 2);
          pushPreFloor(xloc + 208, 24, 6);
          endCastleInside(xloc + 256, 0, 1);
        },
      };
    }),
  ];
}

function World81(map) {
  map.time = 300;
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(1),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPrePattern("backfence", 0, 0, 10);
      pushPreCastle(0, 0, true);
      pushPreFloor(0, 0, 46);
      pushPreThing(Beetle, 144, 8.5);
      fillPreThing(Goomba, 184, 8, 3, 1, 12);
      fillPreThing(Goomba, 240, 8, 3, 1, 12);
      pushPrePipe(280, 0, 32, true);
      fillPreThing(Koopa, 344, 12, 2, 1, 12);
      pushPreFloor(376, 0, 1);
      pushPreFloor(392, 0, 2);
      pushPreFloor(416, 0, 2);
      pushPreFloor(440, 0, 2);
      pushPreFloor(464, 0, 111);
      pushPreThing(Koopa, 488, 12);
      pushPreThing(Coin, 513, 39);
      fillPreThing(Goomba, 552, 8, 3, 1, 12);
      pushPrePipe(608, 0, 32, true);
      pushPreThing(Block, 640, 40, [Mushroom, 1], true);
      pushPreThing(Beetle, 648, 8.5);
      pushPrePipe(656, 0, 24, true);
      pushPreThing(Coin, 713, 39);
      pushPrePipe(752, 0, 32, true);
      pushPreThing(Coin, 786, 39);
      pushPrePipe(832, 0, 32, true, 2);
      fillPreThing(Goomba, 864, 8, 3, 1, 12);
      fillPreThing(Coin, 873, 71, 2, 1, 8);
      pushPrePipe(920, 0, 16, true, false, 1);
      pushPreThing(Koopa, 952, 12);
      fillPreThing(Koopa, 992, 12, 3, 1, 12);
      fillPreThing(Koopa, 1040, 12, 3, 1, 12);
      pushPrePipe(1120, 0, 24, true);
      fillPreThing(Goomba, 1184, 8, 3, 1, 12);
      pushPreThing(Stone, 1224, 32, 1, 4);
      fillPreThing(Brick, 1232, jumplev2, 4, 1, 8);
      pushPreThing(Block, 1264, jumplev1, Coin, true);
      pushPreThing(Brick, 1264, jumplev2, Mushroom);
      fillPreThing(Brick, 1272, jumplev2, 3, 1, 8);
      pushPreThing(Koopa, 1288, jumplev1, false, true);
      pushPreThing(Stone, 1304, 32, 1, 4);

      pushPreFloor(1360, 0, 1);
      pushPreFloor(1376, 0, 2);
      pushPreThing(Koopa, 1376, 32, false, true);
      pushPreFloor(1400, 0, 1);
      pushPreFloor(1416, 0, 2);
      pushPreThing(Koopa, 1416, 28, false, true);
      pushPreFloor(1416, 0, 2);

      pushPreFloor(1440, 0, 17);
      fillPreThing(Brick, 1472, 40, 2, 1, 8);
      pushPreThing(Brick, 1488, 40, Star);
      fillPreThing(Brick, 1496, 40, 5, 1, 8);
      pushPreFloor(1584, 0, 1);
      pushPreFloor(1600, 0, 1);
      pushPreFloor(1616, 0, 19);
      fillPreThing(Koopa, 1656, 12, 2, 1, 12);
      pushPreThing(Stone, 1680, 16, 1, 2);

      fillPreThing(Coin, 1785, 39, 2, 1, 8);

      pushPreFloor(1816, 0, 10);
      fillPreThing(Goomba, 1856, 8, 3, 1, 12);
      pushPreFloor(1904, 0, 2);
      pushPrePipe(1904, 0, 24, true);
      pushPreFloor(1936, 0, 2);
      pushPrePipe(1936, 0, 32, true);

      pushPreFloor(1968, 0, 44);
      pushPrePipe(1968, 0, 40);
      pushPreThing(Beetle, 2032, 8.5);
      fillPreThing(Goomba, 2056, 8, 3, 1, 12);
      fillPreThing(Goomba, 2112, 8, 3, 1, 12);
      fillPreThing(Goomba, 2176, 8, 2, 1, 12);
      pushPreThing(Stone, 2200, 8);
      pushPreThing(Stone, 2208, 16, 1, 2);
      pushPreThing(Stone, 2216, 24, 1, 3);
      pushPreThing(Stone, 2224, 32, 1, 4);
      pushPreThing(Stone, 2232, 40, 1, 5);
      pushPreThing(Stone, 2240, 48, 1, 6);
      pushPreThing(Beetle, 2264, 8.5);
      fillPreThing(Coin, 2265, 39, 2, 1, 8);

      fillPreThing(Coin, 2329, 39, 2, 1, 40);
      pushPreFloor(2344, 0, 2);
      pushPreFloor(2384, 0, 16);
      fillPreThing(Stone, 2424, 16, 2, 1, 32, 8, 1, 2);
      pushPreThing(Koopa, 2440, 12);
      fillPreThing(Coin, 2529, 39, 2, 1, 8);
      pushPreFloor(2552, 0, 1);
      fillPreThing(Coin, 2569, 39, 2, 1, 8);

      pushPreFloor(2592, 0, 35);
      pushPreThing(Koopa, 2656, 12);
      fillPreThing(Koopa, 2712, 12, 3, 1, 12);
      pushPrePipe(2752, 0, 24, true);
      pushPrePipe(2840, 0, 16, true);

      pushPreFloor(2880, 0, 1);
      pushPreThing(Stone, 2880, 16, 1, 2);
      pushPreFloor(2896, 0, 1);
      pushPreThing(Stone, 2896, 32, 1, 4);
      pushPreFloor(2912, 0, 1);
      pushPreThing(Stone, 2912, 48, 1, 6);
      pushPreFloor(2928, 0, 34);
      pushPreThing(Stone, 2928, 64, 2, 8);
      endCastleOutside(3004);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(2);

      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Coin, 25, 7, 9, 1, 8, 8);
      fillPreThing(Brick, 24, 32, 9, 1, 8, 8);
      fillPreThing(Coin, 33, 39, 8, 1, 8, 8);
      pushPreThing(Brick, 96, 32, Coin);
      fillPreThing(Brick, 24, 64, 10, 4, 8, 8);
      fillPreThing(Brick, 104, 24, 2, 9, 8, 8);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 100, 100);
    }),
  ];
}

function World82(map) {
  map.locs = [
    new Location(0, true),
    new Location(0, exitPipeVert),
    new Location(1),
  ];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPrePattern("backfencemin2", 0, 0, 5);
      pushPreCastle();
      pushPreFloor(0, 0, 15);
      pushPreFloor(128, 0, 5);
      pushPreThing(Lakitu, 128, 84);
      pushPreThing(Stone, 136, 8, 1);
      pushPreThing(Stone, 144, 16, 1, 2);
      pushPreThing(Stone, 152, 24, 1, 3);
      pushPreThing(Stone, 160, 32, 1, 4);
      pushPreFloor(176, 0, 14);
      pushPreThing(Stone, 176, 48, 1, 6);
      pushPreThing(Stone, 184, 56, 1, 7);
      pushPreThing(Stone, 192, 64, 2, 8);
      fillPreThing(Block, 232, 32, 4, 1, 8);

      pushPreFloor(296, 0, 8);
      pushPreThing(Brick, 344, 64);
      pushPreThing(Springboard, 352, 14.5);
      pushPreThing(Brick, 352, 64, [Mushroom, 1]);
      fillPreThing(Brick, 360, 64, 31, 1, 8);
      pushPreFloor(368, 0, 4);
      pushPreFloor(408, 0, 1);
      pushPreFloor(424, 0, 3);
      pushPreFloor(456, 0, 6);
      pushPreThing(Koopa, 456, 26, false, true);
      pushPreFloor(512, 0, 14);
      fillPreThing(Brick, 616, 32, 2, 1, 8);
      pushPreScenery("PlantLarge", 552, 0);
      pushPreFloor(640, 0, 4);

      pushPreFloor(680, 0, 53);
      pushPreThing(Cannon, 680, 16, 2);
      pushPreThing(Koopa, 736, 32, false, true);
      pushPreThing(Cannon, 744, 8, 1, true);
      pushPreThing(Cannon, 744, 24, 2);
      pushPreThing(Koopa, 760, 24, false, true);
      pushPreThing(Brick, 792, jumplev1);
      pushPreThing(Brick, 800, jumplev1, Mushroom);
      pushPreThing(Cannon, 840, 16, 2);
      fillPreThing(Brick, 880, jumplev1, 2, 1, 8);
      pushPreScenery("Fence", 888, 0);
      pushPreThing(Beetle, 888, 8.5);
      pushPreThing(Cannon, 920, 8, 1);
      pushPreThing(Brick, 944, jumplev1);
      pushPreScenery("PlantLarge", 936, 0);
      pushPreThing(Stone, 952, jumplev1);
      pushPreThing(Cannon, 952, 40);
      pushPreThing(Brick, 960, jumplev1, Mushroom);
      pushPreThing(Beetle, 968, 8.5);
      pushPreThing(Beetle, 984, 8.5);
      pushPreThing(Cannon, 1000, 24, 3);
      pushPrePipe(1048, 0, 16, true);

      pushPreFloor(1112, 0, 5);
      pushPreThing(Koopa, 1112, 12, false, true);
      pushPrePipe(1136, 0, 16, true);
      pushPreFloor(1160, 0, 1);
      pushPreFloor(1176, 0, 1);

      pushPreFloor(1232, 0, 20);
      pushPreScenery("Fence", 1272, 0);
      pushPrePipe(1248, 0, 32, true, 2);
      pushPrePipe(1304, 0, 16, true, false, 1);
      pushPreScenery("PlantLarge", 1320, 0);
      pushPreThing(Koopa, 1360, 32, false, true);
      pushPreThing(Koopa, 1376, 24, false, true);
      pushPreFloor(1400, 0, 1);
      pushPreThing(Cannon, 1400, 16, 2);
      pushPreThing(Koopa, 1400, 48, false, true);

      pushPreFloor(1432, 0, 23);
      pushPreThing(Stone, 1456, 8, 1);
      pushPreThing(Stone, 1464, 16, 1, 2);
      pushPreThing(Stone, 1472, 24, 1, 3);
      pushPreThing(Goomba, 1472, 32);
      pushPreThing(Stone, 1480, 32, 1, 4);
      pushPreThing(Stone, 1488, 40, 1, 5);
      pushPreThing(Goomba, 1488, 48);
      pushPreThing(Beetle, 1512, 8.5);
      pushPreThing(Cannon, 1528, 8, 1, true);
      pushPreThing(Cannon, 1528, 24, 2);
      pushPreThing(Stone, 1592, 8);
      pushPreThing(Stone, 1600, 16, 1, 2);
      pushPreThing(Stone, 1608, 24, 1, 3);
      pushPreFloor(1624, 0, 1);
      pushPreThing(Stone, 1624, 40, 1, 5);
      pushPreThing(Koopa, 1624, 72, false, true);

      pushPreThing(SceneryBlocker, 1640, 24, 8, 24);
      pushPreFloor(1648, 0, 40);
      pushPreFuncCollider(1648, zoneDisableLakitu);
      pushPreThing(Stone, 1648, 64, 2, 8);
      pushPreScenery("PlantLarge", 1704, 0);
      endCastleOutside(1724);
    }),
    new Area("Underworld", function () {
      setLocationGeneration(2);

      makeCeiling(32, 7);
      pushPreFloor(0, 0, 17);
      fillPreThing(Brick, 0, 8, 1, 11, 8, 8);
      fillPreThing(Brick, 32, 48, 7, 1, 8);
      pushPreThing(Brick, 32, 56);
      fillPreThing(Coin, 42, 55, 5, 2, 8, 8);
      fillPreThing(Brick, 80, 56, 1, 4, 8, 8);
      fillPreThing(Brick, 88, 56, 2, 1, 8);
      pushPreThing(Brick, 112, 48, Coin);
      pushPreThing(PipeSide, 104, 16, 1);
      pushPreThing(PipeVertical, 120, 88, 88);
    }),
  ];
}

function World83(map) {
  map.time = 300;
  map.locs = [new Location(0, true)];
  map.areas = [
    new Area("Overworld", function () {
      setLocationGeneration(0);

      pushPrePattern("backfencemin3", -384, 0, 7);
      pushPreCastle();
      pushPreFloor(0, 0, 69);
      // pushPreScenery("Fence", 120, 0);
      pushPreThing(Cannon, 144, 16, 2);
      pushPreScenery("CastleWall", 192, 0, 8);
      pushPreThing(Koopa, 240, 32, false, true);
      pushPreThing(Cannon, 272, 24, 3);
      pushPreScenery("CastleWall", 296, 0, 14);
      pushPrePipe(424, 0, 32, true);
      fillPreThing(Brick, 480, jumplev1, 8, 1, 8);
      fillPreThing(Brick, 480, jumplev2, 6, 1, 8);
      // pushPreScenery("Fence", 504, 0);
      pushPreThing(HammerBro, 504, 12);
      pushPreThing(HammerBro, 520, 44);
      pushPreThing(Brick, 528, jumplev2, Mushroom);
      pushPreThing(Brick, 536, jumplev2);

      pushPreFloor(568, 0, 4);
      pushPreThing(Stone, 568, 32, 1, 4);
      pushPreThing(Stone, 576, 24, 1, 3);
      pushPreThing(Stone, 584, 16, 1, 2);
      pushPreThing(Stone, 592, 8, 1, 1);

      pushPreFloor(616, 0, 47);
      pushPreScenery("CastleWall", 632, 0, 6);
      pushPreThing(Cannon, 688, 16, 2);
      pushPreScenery("CastleWall", 704, 0, 6);
      pushPreThing(Koopa, 744, 24, false, true);
      pushPreThing(Stone, 760, 24, 1, 3);
      pushPreScenery("CastleWall", 776, 0, 10);
      pushPreThing(Stone, 872, 32, 2, 4);
      fillPreThing(Brick, 920, jumplev1, 8, 1, 8);
      pushPreThing(Brick, 920, jumplev2);
      pushPreThing(Brick, 928, jumplev2, Mushroom);
      pushPreThing(HammerBro, 936, 44);
      fillPreThing(Brick, 936, jumplev2, 6, 1, 8);
      pushPreThing(HammerBro, 952, 12);

      pushPreFloor(1008, 0, 2);
      pushPrePipe(1008, 0, 32, true);

      pushPreFloor(1040, 0, 67);
      pushPreScenery("CastleWall", 1056, 0, 34);
      pushPreThing(Koopa, 1096, 12);
      pushPreThing(HammerBro, 1168, 12);
      pushPreThing(HammerBro, 1270, 12);
      pushPrePipe(1344, 0, 24, true);
      pushPreScenery("CastleWall", 1376, 0, 20);
      pushPreThing(HammerBro, 1416, 12);
      pushPreThing(HammerBro, 1480, 12);
      pushPreThing(Brick, 1520, jumplev1, Coin);
      pushPreThing(Stone, 1560, 16, 1, 2);

      pushPreThing(Stone, 1584, 16);
      pushPreThing(Stone, 1600, 32);
      pushPreThing(Stone, 1616, 48);
      pushPreThing(SceneryBlocker, 1624, 24, 40, 24);
      pushPreThing(Stone, 1632, 64, 2, 1);
      pushPreFloor(1664, 0, 32);
      endCastleOutside(1708, 0, true, 11, 44);
    }),
  ];
}

function World84(map) {
  map.locs = [
    new Location(0, startCastle),
    new Location(0, exitPipeVert), // Pipe 1
    new Location(1, exitPipeVert), // Past B
    new Location(2, exitPipeVert), // Past D
    new Location(3, exitPipeVert, 24), // Underwater
    new Location(4, exitPipeVert), // Pipe 2
  ];
  map.areas = [
    new Area("Castle", function () {
      // Area 0
      setLocationGeneration(0);

      startCastleInside();
      pushPreThing(Stone, 40, 24, 1, DtB(24, 8));
      makeCeilingCastle(40, 32);
      fillPreWater(48, 0, 10);
      pushPreThing(Stone, 88, 0, 8, DtB(0, 8));
      pushPrePipe(152, 16, Infinity, true, false, 1); // Pipe 1
      pushPreFloor(168, 0, 11);

      this.sections = {
        start: 256,
        0: function (xloc) {
          pushPreFloor(xloc, 0, bstretch);
          makeCeilingCastle(xloc, bstretch + 53);
          pushPreSectionFail(xloc, 80, 40, 80);
          pushPrePipe(xloc + bstretch * 8, 16, Infinity, true, 1); // Back to Pipe 1
          pushPreFloor(xloc + bstretch * 8 + 16, 0, 9);
          fillPreThing(Goomba, xloc + bstretch * 8 + 36, 8, 3, 1, 12);
          pushPreFloor(xloc + bstretch * 8 + 88, 24, 4);
          fillPreWater(xloc + bstretch * 8 + 120, 0, 34);
          // To do: make sure this is correct
          pushPreThing(Platform, xloc + bstretch * 8 + 152, 0, 4, [
            moveSliding,
            xloc + bstretch * 8 + 140,
            xloc + bstretch * 8 + 232,
            2,
          ]);
          pushPreFloor(xloc + bstretch * 8 + 256, 24, 6);
          pushPreThing(Stone, xloc + bstretch * 8 + 264, 56, 4);
          pushPrePipe(xloc + bstretch * 8 + 304, 40, Infinity, true, 2); // Goes to Past B
          pushPreFloor(xloc + bstretch * 8 + 320, 24, 7);
          pushPrePipe(xloc + bstretch * 8 + 376, 48, Infinity, true);
          pushPreFloor(xloc + bstretch * 8 + 392, 24, 4);
          pushCastleDecider(xloc + bstretch * 8 + 424, 0);
        },
      };
    }),
    new Area("Castle", function () {
      // Area 1
      setLocationGeneration(2);

      setBStretch();
      pushPreFloor(0, 0, bstretch);
      makeCeilingCastle(0, bstretch);
      this.sections = {
        start: bstretch * 8,
        0: function (xloc) {
          pushPreSectionFail(xloc, 80, 40, 80);
          pushPrePipe(xloc, 16, Infinity, true, false, 2); // Past B
          makeCeilingCastle(xloc, bstretch + 45);
          pushPreFloor(xloc + 16, 0, 5);
          pushPrePipe(xloc + 56, 24, Infinity, true);
          pushPreFloor(xloc + 72, 0, 8);
          fillPreThing(Beetle, xloc + 104, 8.5, 2, 1, 16);
          pushPrePipe(xloc + 136, 16, Infinity, true, 1); // Back to Pipe 1
          pushPreFloor(xloc + 152, 0, 8);
          pushPreThing(Koopa, xloc + 192, 32, false, true);
          pushPreThing(Koopa, xloc + 208, 24, false, true);
          pushPrePipe(xloc + 216, 24, Infinity, true);
          fillPreWater(xloc + 232, 0, 6);
          pushPreFloor(xloc + 256, 0, 13 + bstretch);
          pushPreThing(Block, xloc + 280, jumplev1, Coin, true);
          pushPreThing(Stone, xloc + 296, jumplev1, 2);
          pushPrePipe(xloc + 296, jumplev1, 24, true, 3); // Goes Past C
          pushPreThing(Koopa, xloc + 320, 20, false, true);
          pushPreThing(Koopa, xloc + 336, 24, false, true);
          pushCastleDecider(xloc + 360 + bstretch * 8, 0);
        },
      };
    }),
    new Area("Castle", function () {
      // Area 2
      setLocationGeneration(3);

      pushPreFloor(0, 0, 3);
      makeCeilingCastle(0, 3);
      this.sections = {
        start: 24,
        0: function (xloc) {
          pushPreSectionFail(xloc, 80, 40, 80);
          pushPrePipe(xloc, 16, Infinity, true, false, 3);
          makeCeilingCastle(xloc, bstretch + 38);
          pushPreFloor(xloc + 16, 0);
          pushPreFloor(xloc + 24, 24, 6);
          pushPrePipe(xloc + 72, 40, Infinity, true);
          // start cheeps here
          pushPreFloor(xloc + 88, 24, 6);
          pushPrePipe(xloc + 136, 48, Infinity, true, 1); // Back to Pipe 1
          pushPreFloor(xloc + 152, 24, 6);
          // end cheeps here
          fillPreWater(xloc + 200, 0, 8);
          pushPreFloor(xloc + 232, 24, 4);
          pushPrePipe(xloc + 264, 40, Infinity, true, 4); // To Underwater (Area 3)
          pushPreFloor(xloc + 280, 24, bstretch);
          pushPreFloor(xloc + 280 + bstretch * 8, 0, 3);
          pushCastleDecider(xloc + 304 + bstretch * 8, 0);
        },
      };
    }),
    new Area("Underwater Castle", function () {
      // Area 3 (Underwater)
      setLocationGeneration(4);

      goUnderWater();
      pushPreThing(Stone, 0, 88, 2, DtB(88, 8));
      pushPreFloor(16, 0, 1, 62);
      pushPrePipe(24, -200, 216, false, false, 4);
      pushPreFloor(40, 0, 67);
      pushPreThing(Stone, 48, 24, 5, 3);
      pushPreThing(Stone, 48, 80, 5, 2);
      pushPreThing(Stone, 48, 88, 66, 1);
      pushPreThing(Stone, 88, 32, 7, 4);
      pushPreThing(Stone, 88, 80, 7, 3);
      pushPreThing(CastleBlock, 160, 46, [6, 1], true);
      pushPreThing(Blooper, 224, 16);
      pushPreThing(CastleBlock, 248, 22, [6, 1], true);
      pushPreThing(Stone, 312, 24, 3, 3);
      pushPreThing(Stone, 312, 80, 3, 3);
      pushPreThing(CastleBlock, 320, 54, [6, 1], true);
      pushPreThing(Blooper, 408, 24);
      pushPreThing(Blooper, 424, 56);
      pushPreThing(CastleBlock, 446, 38, [6, 1], true);
      pushPreThing(CastleBlock, 512, 44, [6, 1], true);
      pushPreThing(Stone, 536, 32, 5, 4);
      pushPreThing(Stone, 536, 80, 5, 3);
      pushPreThing(PipeSide, 544, 48, 5);
      pushPreThing(Stone, 552, 56, 3, 3);
    }),
    new Area("Castle", function () {
      // Area 4
      setLocationGeneration(5);

      pushPrePipe(0, 16, Infinity, true, false, 5);
      makeCeilingCastle(0, 29);
      pushPreFloor(16, 0, 5);
      pushPrePipe(56, 16, Infinity, true);
      pushPreFloor(72, 0, 9);
      pushPreThing(HammerBro, 112, 12);
      fillPreWater(128, 0, 14);
      pushPreThing(Podoboo, 160, -32);
      pushPreFloor(184, 24, 6);
      pushPreThing(Stone, 184, 80, 6, 2);
      endCastleInside(232, 1, 1);
    }),
  ];
}