alot more data for replays, but replays are alot more reliable; also, fast-forwarding...

[k8vacspelynky.git] / GameLevel.vc

/**********************************************************************************
 * Copyright (c) 2008, 2009 Derek Yu and Mossmouth, LLC
 * Copyright (c) 2018, Ketmar Dark
 *
 * This file is part of Spelunky.
 *
 * You can redistribute and/or modify Spelunky, including its source code, under
 * the terms of the Spelunky User License.
 *
 * Spelunky is distributed in the hope that it will be entertaining and useful,
 * but WITHOUT WARRANTY.  Please see the Spelunky User License for more details.
 *
 * The Spelunky User License should be available in "Game Information", which
 * can be found in the Resource Explorer, or as an external file called COPYING.
 * If not, please obtain a new copy of Spelunky from <http://spelunkyworld.com/>
 *
 **********************************************************************************/
// this is the level we're playing in, with all objects and tiles
class GameLevel : Object;

const float FrameTime = 1.0f/30.0f;

const int dumpGridStats = false;

struct IVec2D {
  int x, y;
}

// in tiles
//enum NormalTilesWidth = LevelGen::LevelWidth*RoomGen::Width+2;
//enum NormalTilesHeight = LevelGen::LevelHeight*RoomGen::Height+2;

enum MaxTilesWidth = 64;
enum MaxTilesHeight = 64;

GameGlobal global;
transient GameStats stats;
transient SpriteStore sprStore;
transient BackTileStore bgtileStore;
transient BackTileImage levBGImg;
name levBGImgName;
LevelGen lg;
//RoomGen[LevelGen::LevelWidth, LevelGen::LevelHeight] rooms; // moved to levelgen

transient float accumTime;
transient bool gamePaused = false;
transient bool checkWater;
transient int damselSaved;

// hud efffects
transient int xmoney;
transient int collectCounter;
transient int levelMoneyStart;

// all movable (thinkable) map objects
EntityGrid objGrid; // monsters and items

MapTile[MaxTilesWidth, MaxTilesHeight] tiles;
MapBackTile backtiles;
EntityGrid miscTileGrid; // moveables and ropes
bool blockWaterChecking;

array!MapObject ballObjects; // list of all ball objects, for speed

LevelGen::RType[MaxTilesWidth, MaxTilesHeight] roomType;

enum LevelKind {
  Normal,
  Transition,
  Title,
  Final,
}
LevelKind levelKind = LevelKind.Normal;

array!MapTile allEnters;
array!MapTile allExits;


int startRoomX, startRoomY;
int endRoomX, endRoomY;

PlayerPawn player;
transient bool playerExited;
transient bool disablePlayerThink = false;
transient int maxPlayingTime; // in seconds

int ghostTimeLeft;
int musicFadeTimer;
bool ghostSpawned; // to speed up some checks


// FPS, i.e. incremented by 30 in one second
int time; // in frames
int lastUsedObjectId;

// screen shake variables
int shakeLeft;
IVec2D shakeOfs;
IVec2D shakeDir;

// set this before calling `fixCamera()`
// dimensions should be real, not scaled up/down
transient int viewWidth, viewHeight;
// room bounds, not scaled
IVec2D viewMin, viewMax;

// `fixCamera()` will set the following
// coordinates will be real too (with scale applied)
// shake is not applied
transient IVec2D viewStart; // with `player.viewOffset`
private transient IVec2D realViewStart; // without `player.viewOffset`

// if `frameSkip` is `true`, there are more frames waiting
// (i.e. you may skip rendering and such)
transient void delegate (bool frameSkip) onBeforeFrame;
transient void delegate (bool frameSkip) onAfterFrame;

transient void delegate () onLevelExitedCB;

// this will be called in-between frames, and
// `frameTime` is [0..1)
transient void delegate (float frameTime) onInterFrame;

final int bizRoomStyle { get { return (lg ? lg.bizRoomStyle : 0); } }


final bool isNormalLevel () { return (levelKind == LevelKind.Normal); }


// ////////////////////////////////////////////////////////////////////////// //
// stats
void addDeath (name aname) { stats.addDeath(aname); }
void addKill (name aname) { stats.addKill(aname); }
void addCollect (name aname, optional int amount) { stats.addCollect(aname, amount!optional); }

void addDamselSaved () { stats.addDamselSaved(); }
void addIdolStolen () { stats.addIdolStolen(); }
void addIdolConverted () { stats.addIdolConverted(); }
void addCrystalIdolStolen () { stats.addCrystalIdolStolen(); }
void addCrystalIdolConverted () { stats.addCrystalIdolConverted(); }
void addGhostSummoned () { stats.addGhostSummoned(); }


// ////////////////////////////////////////////////////////////////////////// //
final int tilesWidth () { return lg.levelRoomWidth*RoomGen::Width+2; }
final int tilesHeight () { return lg.levelRoomHeight*RoomGen::Height+2; }


// ////////////////////////////////////////////////////////////////////////// //
// this won't generate a level yet
void restartGame () {
  if (player) {
    auto hi = player.holdItem;
    player.holdItem = none;
    if (hi) hi.instanceRemove();
    hi = player.pickedItem;
    player.pickedItem = none;
    if (hi) hi.instanceRemove();
  }
  global.resetGame();
  stats.clearGameTotals();
  if (global.startMoney > 0) stats.setMoneyCheat();
  stats.setMoney(global.startMoney);
  //writeln("level=", global.currLevel, "; lt=", global.levelType);
}


// complement function to `restart game`
void generateNormalLevel () {
  generateLevel();
  centerViewAtPlayer();
}


// ////////////////////////////////////////////////////////////////////////// //
// generate angry shopkeeper at exit if murderer or thief
void generateAngryShopkeepers () {
  if (global.murderer || global.thiefLevel > 0) {
    foreach (MapTile e; allExits) {
      auto obj = MonsterShopkeeper(MakeMapObject(e.ix, e.iy, 'oShopkeeper'));
      if (obj) {
        obj.style = 'Bounty Hunter';
        obj.status = MapObject::PATROL;
      }
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final void resetRoomBounds () {
  viewMin.x = 0;
  viewMin.y = 0;
  viewMax.x = tilesWidth*16;
  viewMax.y = tilesHeight*16;
  // Great Lake is bottomless (nope)
  //if (global.lake) viewMax.y -= 16;
  //writeln("ROOM BOUNDS: (", viewMax.x, "x", viewMax.y, ")");
}


final void setRoomBounds (int x0, int y0, int x1, int y1) {
  viewMin.x = x0;
  viewMin.y = y0;
  viewMax.x = x1+16;
  viewMax.y = y1+16;
}


// ////////////////////////////////////////////////////////////////////////// //
struct OSDMessage {
  string msg;
  float timeout; // seconds
  float starttime; // for active
  bool active; // true: timeout is `GetTickCount()` dismissing time
}

array!OSDMessage msglist; // [0]: current one


private final void osdCheckTimeouts () {
  auto stt = GetTickCount();
  while (msglist.length) {
    if (!msglist[0].active) {
      msglist[0].active = true;
      msglist[0].starttime = stt;
    }
    if (msglist[0].starttime+msglist[0].timeout >= stt) break;
    msglist.remove(0);
  }
}


final bool osdHasMessage () {
  osdCheckTimeouts();
  return (msglist.length > 0);
}


final string osdGetMessage (out float timeLeft, out float timeStart) {
  osdCheckTimeouts();
  if (msglist.length == 0) { timeLeft = 0; return ""; }
  auto stt = GetTickCount();
  timeStart = msglist[0].starttime;
  timeLeft = fmax(0, msglist[0].starttime+msglist[0].timeout-stt);
  return msglist[0].msg;
}


final void osdClear () {
  msglist.length -= msglist.length;
}


final void osdMessage (string msg, optional float timeout, optional bool urgent) {
  if (!msg) return;
  if (!specified_timeout) timeout = 3.33;
  // special message for shops
  if (timeout == -666) {
    if (!msg) return;
    if (msglist.length && msglist[0].msg == msg) return;
    if (msglist.length == 0 || msglist[0].msg != msg) {
      osdClear();
      msglist.length += 1;
      msglist[0].msg = msg;
    }
    msglist[0].active = false;
    msglist[0].timeout = 3.33;
    osdCheckTimeouts();
    return;
  }
  if (timeout < 0.1) return;
  timeout = fmax(1.0, timeout);
  //writeln("OSD: ", msg);
  // find existing one, and bring it to the top
  int oldidx = 0;
  for (; oldidx < msglist.length; ++oldidx) {
    if (msglist[oldidx].msg == msg) break; // i found her!
  }
  // duplicate?
  if (oldidx < msglist.length) {
    // yeah, move duplicate to the top
    msglist[oldidx].timeout = fmax(timeout, msglist[oldidx].timeout);
    msglist[oldidx].active = false;
    if (urgent && oldidx != 0) {
      timeout = msglist[oldidx].timeout;
      msglist.remove(oldidx);
      msglist.insert(0);
      msglist[0].msg = msg;
      msglist[0].timeout = timeout;
      msglist[0].active = false;
    }
  } else if (urgent) {
    msglist.insert(0);
    msglist[0].msg = msg;
    msglist[0].timeout = timeout;
    msglist[0].active = false;
  } else {
    // new one
    msglist.length += 1;
    msglist[$-1].msg = msg;
    msglist[$-1].timeout = timeout;
    msglist[$-1].active = false;
  }
  osdCheckTimeouts();
}


// ////////////////////////////////////////////////////////////////////////// //
void setup (GameGlobal aGlobal, SpriteStore aSprStore, BackTileStore aBGTileStore) {
  global = aGlobal;
  sprStore = aSprStore;
  bgtileStore = aBGTileStore;

  lg = SpawnObject(LevelGen);
  lg.global = global;
  lg.level = self;

  miscTileGrid = SpawnObject(EntityGrid);
  miscTileGrid.setup(0, 0, MaxTilesWidth*16, MaxTilesHeight*16, MapTile);
  //miscTileGrid.ownObjects = true;

  objGrid = SpawnObject(EntityGrid);
  objGrid.setup(0, 0, MaxTilesWidth*16, MaxTilesHeight*16, MapObject);
}


// stores should be set
void onLoaded () {
  checkWater = true;
  levBGImg = bgtileStore[levBGImgName];
  foreach (int y; 0..MaxTilesHeight) {
    foreach (int x; 0..MaxTilesWidth) {
      if (tiles[x, y]) tiles[x, y].onLoaded();
    }
  }
  foreach (MapEntity o; miscTileGrid.allObjects()) o.onLoaded();
  foreach (MapEntity o; objGrid.allObjects()) o.onLoaded();
  for (MapBackTile bt = backtiles; bt; bt = bt.next) bt.onLoaded();
  if (player) player.onLoaded();
  //FIXME
  if (msglist.length) {
    msglist[0].active = false;
    msglist[0].timeout = 0.200;
    osdCheckTimeouts();
  }
}


// ////////////////////////////////////////////////////////////////////////// //
void pickedSpectacles () {
  foreach (int y; 0..tilesHeight) {
    foreach (int x; 0..tilesWidth) {
      MapTile t = tiles[x, y];
      if (t && t.isInstanceAlive) t.onGotSpectacles();
    }
  }
  foreach (MapTile t; miscTileGrid.allObjects()) {
    if (t.isInstanceAlive) t.onGotSpectacles();
  }
}


// ////////////////////////////////////////////////////////////////////////// //
#include "rgentile.vc"
#include "rgenobj.vc"


void onLevelExited () {
  if (isNormalLevel()) stats.maxLevelComplete = max(stats.maxLevelComplete, global.currLevel);
  if (onLevelExitedCB) onLevelExitedCB();
  if (levelKind == LevelKind.Transition) {
    if (global.thiefLevel > 0) global.thiefLevel -= 1;
    //orig dbg:if (global.currLevel == 1) global.currLevel += firstLevelSkip; else global.currLevel += levelSkip;
    global.currLevel += 1;
    generateLevel();
  } else {
    generateTransitionLevel();
  }
  centerViewAtPlayer();
}


void generateLevelMessages () {
  if (global.darkLevel) {
         if (global.hasCrown) osdMessage("THE HEDJET SHINES BRIGHTLY.");
    else if (global.config.scumDarkness < 2) osdMessage("I CAN'T SEE A THING!");
    /*
    else global.message = "";
         if (global.hasCrown) global.message2 = "";
    else if (global.scumDarkness &lt; 2) global.message2 = "I'D BETTER USE THESE FLARES!";
    else global.message2 = "";
    global.messageTimer = 200;
    alarm[1] = 210;
    */
  }

  if (global.blackMarket) osdMessage("WELCOME TO THE BLACK MARKET!");

  if (global.cemetary) osdMessage("THE DEAD ARE RESTLESS!");
  if (global.lake) osdMessage("I CAN HEAR RUSHING WATER...");

  if (global.snakePit) osdMessage("I HEAR SNAKES... I HATE SNAKES!");
  if (global.yetiLair) osdMessage("IT SMELLS LIKE WET FUR IN HERE!");
  if (global.alienCraft) osdMessage("THERE'S A PSYCHIC PRESENCE HERE!");
  if (global.cityOfGold) {
    if (true /*hasOlmec()*/) osdMessage("IT'S THE LEGENDARY CITY OF GOLD!");
  }

  if (global.sacrificePit) osdMessage("I CAN HEAR PRAYERS TO KALI!");
}


final MapObject debugSpawnObjectWithClass (class!MapObject oclass, optional bool playerDir) {
  if (!oclass) return none;
  int dx = 0, dy = 0;
  bool canLeft = !isSolidAtPoint(player.ix-8, player.iy);
  bool canRight = !isSolidAtPoint(player.ix+16, player.iy);
  if (!canLeft && !canRight) return none;
  if (canLeft && canRight) {
    if (playerDir) {
      dx = (player.dir == MapObject::Dir.Left ? -16 : 16);
    } else {
      dx = 16;
    }
  } else {
    dx = (canLeft ? -16 : 16);
  }
  auto obj = SpawnMapObjectWithClass(oclass);
  if (obj isa MapEnemy) { dx -= 8; dy -= 8; }
  if (obj) PutSpawnedMapObject(player.ix+dx, player.iy+dy, obj);
  return obj;
}


final MapObject debugSpawnObject (name aname) {
  if (!aname) return none;
  return debugSpawnObjectWithClass(findGameObjectClassByName(aname));
}


// `global.currLevel` is the new level
void generateTransitionLevel () {
  xmoney = 0;
  collectCounter = 0;

  global.setMusicPitch(1.0);
  global.stopMusic();

  levelKind = LevelKind.Transition;

  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearTiles();
  clearObjects();

       if (global.currLevel < 4) createTrans1Room();
  else if (global.currLevel == 4) createTrans1xRoom();
  else if (global.currLevel < 8) createTrans2Room();
  else if (global.currLevel == 8) createTrans2xRoom();
  else if (global.currLevel < 12) createTrans3Room();
  else if (global.currLevel == 12) createTrans3xRoom();
  else if (global.currLevel < 16) createTrans4Room();
  else if (global.currLevel == 16) createTrans4Room();
  else createTrans1Room(); //???

  fixWallTiles();
  addBackgroundGfxDetails();
  levBGImgName = 'bgCave';
  levBGImg = (levBGImgName ? bgtileStore[levBGImgName] : none);

  blockWaterChecking = true;
  fixLiquidTop();
  cleanDeadTiles();

  if (damselSaved > 0) {
    MakeMapObject(176+8, 176+8, 'oDamselKiss');
    global.plife += damselSaved; // if player skipped transition cutscene
    damselSaved = 0;
  }

  ImmediateDelete = olddel;
  CollectGarbage(true); // destroy delayed objects too

  if (dumpGridStats) {
    miscTileGrid.dumpStats();
    objGrid.dumpStats();
  }

  playerExited = false; // just in case

  osdClear();

  setupGhostTime();
  //global.playMusic(lg.musicName);
}


void generateLevel () {
  global.setMusicPitch(1.0);
  stats.clearLevelTotals();

  levelKind = LevelKind.Normal;
  lg.generate();
  //lg.dump();

  resetRoomBounds();

  lg.generateRooms();

  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearTiles();
  clearObjects();

  // if transition cutscene was skipped...
  if (damselSaved > 0) global.plife += damselSaved; // if player skipped transition cutscene
  damselSaved = 0;

  // generate tiles
  startRoomX = lg.startRoomX;
  startRoomY = lg.startRoomY;
  endRoomX = lg.endRoomX;
  endRoomY = lg.endRoomY;
  addBackgroundGfxDetails();
  foreach (int y; 0..tilesHeight) {
    foreach (int x; 0..tilesWidth) {
      lg.genTileAt(x, y);
    }
  }
  fixWallTiles();

  levBGImgName = lg.bgImgName;
  levBGImg = (levBGImgName ? bgtileStore[levBGImgName] : none);

  if (global.allowAngryShopkeepers) generateAngryShopkeepers();

  lg.generateEntities();

  // add box of flares to dark level
  if (global.darkLevel && allEnters.length) {
    auto enter = allEnters[0];
    int x = enter.ix, y = enter.iy;
         if (!isSolidAtPoint(x-16, y)) MakeMapObject(x-16+8, y+8, 'oFlareCrate');
    else if (!isSolidAtPoint(x+16, y)) MakeMapObject(x+16+8, y+8, 'oFlareCrate');
    else MakeMapObject(x+8, y+8, 'oFlareCrate');
  }

  //scrGenerateEntities();
  //foreach (; 0..2) scrGenerateEntities();

  writeln(countObjects, " alive objects inserted");
  writeln(countBackTiles, " background tiles inserted");

  if (!player) FatalError("player pawn is not spawned");

  blockWaterChecking = false;
  fixLiquidTop();
  cleanDeadTiles();

  ImmediateDelete = olddel;
  CollectGarbage(true); // destroy delayed objects too

  if (dumpGridStats) {
    miscTileGrid.dumpStats();
    objGrid.dumpStats();
  }

  playerExited = false; // just in case

  levelMoneyStart = stats.money;

  osdClear();
  generateLevelMessages();

  xmoney = 0;
  collectCounter = 0;

  global.playMusic(lg.musicName);

  setupGhostTime();
}


// ////////////////////////////////////////////////////////////////////////// //
int currKeys, nextKeys;
int pressedKeysQ, releasedKeysQ;
int keysPressed, keysReleased = -1;


struct SavedKeyState {
  int currKeys, nextKeys;
  int pressedKeysQ, releasedKeysQ;
  int keysPressed, keysReleased;
  // for session
  int roomSeed, otherSeed;
}


// for saving/replaying
final void keysSaveState (out SavedKeyState ks) {
  ks.currKeys = currKeys;
  ks.nextKeys = nextKeys;
  ks.pressedKeysQ = pressedKeysQ;
  ks.releasedKeysQ = releasedKeysQ;
  ks.keysPressed = keysPressed;
  ks.keysReleased = keysReleased;
}

// for saving/replaying
final void keysRestoreState (const ref SavedKeyState ks) {
  currKeys = ks.currKeys;
  nextKeys = ks.nextKeys;
  pressedKeysQ = ks.pressedKeysQ;
  releasedKeysQ = ks.releasedKeysQ;
  keysPressed = ks.keysPressed;
  keysReleased = ks.keysReleased;
}


final void keysNextFrame () {
  currKeys = nextKeys;
}


final void clearKeys () {
  currKeys = 0;
  nextKeys = 0;
  pressedKeysQ = 0;
  releasedKeysQ = 0;
  keysPressed = 0;
  keysReleased = -1;
}


final void onKey (int code, bool down) {
  if (!code) return;
  if (down) {
    currKeys |= code;
    nextKeys |= code;
    if (keysReleased&code) {
      keysPressed |= code;
      keysReleased &= ~code;
      pressedKeysQ |= code;
    }
  } else {
    nextKeys &= ~code;
    if (keysPressed&code) {
      keysReleased |= code;
      keysPressed &= ~code;
      releasedKeysQ |= code;
    }
  }
}

final bool isKeyDown (int code) {
  return !!(currKeys&code);
}

final bool isKeyPressed (int code) {
  bool res = !!(pressedKeysQ&code);
  pressedKeysQ &= ~code;
  return res;
}

final bool isKeyReleased (int code) {
  bool res = !!(releasedKeysQ&code);
  releasedKeysQ &= ~code;
  return res;
}


final void clearKeysPressRelease () {
  keysPressed = default.keysPressed;
  keysReleased = default.keysReleased;
  pressedKeysQ = default.pressedKeysQ;
  releasedKeysQ = default.releasedKeysQ;
  currKeys = 0;
  nextKeys = 0;
}


// ////////////////////////////////////////////////////////////////////////// //
final void registerEnter (MapTile t) {
  if (!t) return;
  allEnters[$] = t;
  return;
}


final void registerExit (MapTile t) {
  if (!t) return;
  allExits[$] = t;
  return;
}


final bool isYAtEntranceRow (int py) {
  py /= 16;
  foreach (MapTile t; allEnters) if (t.iy == py) return true;
  return false;
}


final int calcNearestEnterDist (int px, int py) {
  if (allEnters.length == 0) return int.max;
  int curdistsq = int.max;
  foreach (MapTile t; allEnters) {
    int xc = px-t.xCenter, yc = py-t.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq) curdistsq = distsq;
  }
  return round(sqrt(curdistsq));
}


final int calcNearestExitDist (int px, int py) {
  if (allExits.length == 0) return int.max;
  int curdistsq = int.max;
  foreach (MapTile t; allExits) {
    int xc = px-t.xCenter, yc = py-t.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq) curdistsq = distsq;
  }
  return round(sqrt(curdistsq));
}


// ////////////////////////////////////////////////////////////////////////// //
final void clearForTransition () {
  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearTiles();
  clearObjects();
  ImmediateDelete = olddel;
  CollectGarbage(true); // destroy delayed objects too
}


final void clearTiles () {
  accumTime = 0;
  time = 0;
  allEnters.length -= allEnters.length; // don't deallocate
  allExits.length -= allExits.length; // don't deallocate
  foreach (ref auto tile; tiles) delete tile;
  if (dumpGridStats) { if (miscTileGrid.getFirstObject()) miscTileGrid.dumpStats(); }
  miscTileGrid.removeAllObjects(true); // and destroy
  while (backtiles) {
    MapBackTile t = backtiles;
    backtiles = t.next;
    delete t;
  }
  levBGImg = none;
}


// ////////////////////////////////////////////////////////////////////////// //
final int countObjects () {
  return objGrid.countObjects();
}

final int countBackTiles () {
  int res = 0;
  for (MapBackTile bt = backtiles; bt; bt = bt.next) ++res;
  return res;
}

final void clearObjects () {
  // don't kill objects player is holding
  if (player) {
    if (player.pickedItem && player.pickedItem.grid) {
      player.pickedItem.grid.remove(player.pickedItem.gridId);
      writeln("secured pocket item '", GetClassName(player.pickedItem.Class), "'");
      //player.pickedItem.grid = none;
    }
    if (player.holdItem && player.holdItem.grid) {
      player.holdItem.grid.remove(player.holdItem.gridId);
      writeln("secured held item '", GetClassName(player.holdItem.Class), "'");
      //player.holdItem.grid = none;
    }
  }
  //
  int count = objGrid.countObjects();
  if (dumpGridStats) { if (objGrid.getFirstObject()) objGrid.dumpStats(); }
  objGrid.removeAllObjects(true); // and destroy
  if (count > 0) writeln(count, " objects destroyed");
  ballObjects.length = 0;
  lastUsedObjectId = 0;
}


final void insertObject (MapObject o) {
  if (!o) return;
  if (o.grid) FatalError("cannot put object into level twice");
  o.objId = ++lastUsedObjectId;

  // ball from ball-and-chain
  if (o.objType == 'oBall') {
    bool found = false;
    foreach (MapObject bo; ballObjects) if (bo == o) { found = true; break; }
    if (!found) ballObjects[$] = o;
  }

  objGrid.insert(o);
}


final void spawnPlayerAt (int x, int y) {
  // if we have no player, spawn new one
  // otherwise this just a level transition, so simply reposition him
  if (!player) {
    // don't add player to object list, as it has very separate processing anyway
    player = SpawnObject(PlayerPawn);
    player.global = global;
    player.level = self;
    if (!player.initialize()) {
      delete player;
      FatalError("something is wrong with player initialization");
      return;
    }
  }
  player.fltx = x;
  player.flty = y;
  player.saveInterpData();
  player.resurrect();
  playerExited = false;
  if (global.config.startWithKapala) global.hasKapala = true;
  centerViewAtPlayer();
  // reinsert player items into grid
  if (player.pickedItem) objGrid.insert(player.pickedItem);
  if (player.holdItem) objGrid.insert(player.holdItem);
  //writeln("player spawned; active=", player.active);
  player.scrSwitchToPocketItem(forceIfEmpty:false);
}


final void teleportPlayerTo (int x, int y) {
  if (player) {
    player.fltx = x;
    player.flty = y;
    player.saveInterpData();
  }
}


final void resurrectPlayer () {
  if (player) player.resurrect();
  playerExited = false;
}


// ////////////////////////////////////////////////////////////////////////// //
final void scrShake (int duration) {
  if (shakeLeft == 0) {
    shakeOfs.x = 0;
    shakeOfs.y = 0;
    shakeDir.x = 0;
    shakeDir.y = 0;
  }
  shakeLeft = max(shakeLeft, duration);
}



// ////////////////////////////////////////////////////////////////////////// //
enum SCAnger {
  TileDestroyed,
  ItemStolen, // including damsel, lol
  CrapsCheated,
  BombDropped,
  DamselWhipped,
}


// make the nearest shopkeeper angry. RAWR!
void scrShopkeeperAnger (SCAnger reason, optional int maxdist, optional MapEntity offender) {
  if (!offender) offender = player;
  auto shp = MonsterShopkeeper(findNearestEnemy(offender.ix, offender.iy, delegate bool (MapEnemy o) {
    auto sc = MonsterShopkeeper(o);
    if (!sc) return false;
    if (sc.dead || sc.angered) return false;
    return true;
  }));

  if (shp) {
    if (specified_maxdist && offender.directionToEntityCenter(shp) > maxdist) return;
    if (!shp.dead && !shp.angered) {
      shp.status = MapObject::ATTACK;
      string msg;
           if (global.murderer) msg = "YOU'LL PAY FOR YOUR CRIMES!";
      else if (reason == SCAnger.ItemStolen) msg = "COME BACK HERE, THIEF!";
      else if (reason == SCAnger.TileDestroyed) msg = "DIE, YOU VANDAL!";
      else if (reason == SCAnger.BombDropped) msg = "TERRORIST!";
      else if (reason == SCAnger.DamselWhipped) msg = "HEY, ONLY I CAN DO THAT!";
      else if (reason == SCAnger.CrapsCheated) msg = "DIE, CHEATER!";
      else msg = "NOW I'M REALLY STEAMED!";
      if (msg) osdMessage(msg, -666);
      global.thiefLevel += (global.thiefLevel > 0 ? 3 : 2);
    }
  }
}


final MapObject findCrapsPrize () {
  foreach (MapObject o; objGrid.allObjects()) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (o.inDiceHouse) return o;
  }
  return none;
}


// ////////////////////////////////////////////////////////////////////////// //
// moved from oPlayer1.Step.Action so it could be shared with oAltarLeft so that traps will be triggered when the altar is destroyed without picking up the idol.
// note: idols moved by monkeys will have false `stolenIdol`
void scrTriggerIdolAltar (bool stolenIdol) {
  ObjTikiCurse res = none;
  int curdistsq = int.max;
  int px = player.xCenter, py = player.yCenter;
  foreach (MapObject o; objGrid.allObjects()) {
    auto tcr = ObjTikiCurse(o);
    if (!tcr || !tcr.isInstanceAlive) continue;
    if (tcr.activated) continue;
    int xc = px-tcr.xCenter, yc = py-tcr.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq) {
      res = tcr;
      curdistsq = distsq;
    }
  }
  if (res) res.activate(stolenIdol);
}


// ////////////////////////////////////////////////////////////////////////// //
void setupGhostTime () {
  musicFadeTimer = -1;
  ghostSpawned = false;

  if (!isNormalLevel()) {
    ghostTimeLeft = -1;
    global.setMusicPitch(1.0);
    return;
  }

  if (global.config.scumGhost < 0) {
    // instant
    ghostTimeLeft = 1;
    osdMessage("A GHASTLY VOICE CALLS YOUR NAME!\nLET'S GET OUT OF HERE!", 6.66, urgent:true);
    return;
  }

  if (global.config.scumGhost == 0) {
    // never
    ghostTimeLeft = -1;
    return;
  }

  // randomizes time until ghost appears once time limit is reached
  // global.ghostRandom (true/false) if extra time is randomized - loaded from yasm.cfg. if false, use 30 second default
  // ghostTimeLeft (time in seconds * 1000) for currently generated level

  if (global.config.ghostRandom) {
    auto tMin = global.randOther(10, 30); // min(global.plife*10, 30);
    auto tMax = max(tMin+global.randOther(10, 30), min(global.config.scumGhost, 300)); // 5 minutes max
    auto tTime = global.randOther(tMin, tMax);
    if (tTime <= 0) tTime = round(tMax/2.0);
    ghostTimeLeft = tTime;
  } else {
    ghostTimeLeft = global.config.scumGhost; // 5 minutes max
  }

  ghostTimeLeft += max(0, global.config.ghostExtraTime);

  ghostTimeLeft *= 30; // seconds -> frames
  //global.ghostShowTime
}


void spawnGhost () {
  addGhostSummoned();
  ghostSpawned = true;

  int vwdt = (viewMax.x-viewMin.x);
  int vhgt = (viewMax.y-viewMin.y);

  int gx, gy;

  if (player.ix < viewMin.x+vwdt/2) {
    // player is in the left side
    gx = viewMin.x+vwdt/2+vwdt/4;
  } else {
    // player is in the right side
    gx = viewMin.x+vwdt/4;
  }

  if (player.iy < viewMin.y+vhgt/2) {
    // player is in the left side
    gy = viewMin.y+vhgt/2+vhgt/4;
  } else {
    // player is in the right side
    gy = viewMin.y+vhgt/4;
  }

  writeln("spawning ghost at tile (", gx/16, ",", gy/16, "); player is at tile (", player.ix/16, ",", player.iy/16, ")");

  MakeMapObject(gx, gy, 'oGhost');

  /*
    if (oPlayer1.x &gt; room_width/2) instance_create(view_xview[0]+view_wview[0]+8, view_yview[0]+floor(view_hview[0] / 2), oGhost);
    else instance_create(view_xview[0]-32, view_yview[0]+floor(view_hview[0]/2), oGhost);
    global.ghostExists = true;
  */
}


void thinkFrameGameGhost () {
  if (player.dead) return;
  if (!isNormalLevel()) return; // just in case

  if (ghostTimeLeft < 0) {
    // turned off
    if (musicFadeTimer > 0) {
      musicFadeTimer = -1;
      global.setMusicPitch(1.0);
    }
    return;
  }

  if (musicFadeTimer >= 0) {
    ++musicFadeTimer;
    if (musicFadeTimer > 0 && musicFadeTimer <= 100*3) {
      float pitch = 1.0-(0.00226/3.0)*musicFadeTimer;
      //writeln("MFT: ", musicFadeTimer, "; pitch=", pitch);
      global.setMusicPitch(pitch);
    }
  }

  if (ghostTimeLeft == 0) {
    // she is already here!
    return;
  }

  // no ghost if we have a crown
  if (global.hasCrown) {
    ghostTimeLeft = -1;
    return;
  }

  // if she was already spawned, don't do it again
  if (ghostSpawned) {
    ghostTimeLeft = 0;
    return;
  }

  if (--ghostTimeLeft != 0) {
    // warning
    if (global.config.ghostExtraTime > 0) {
      if (ghostTimeLeft == global.config.ghostExtraTime*30) {
        osdMessage("A CHILL RUNS UP YOUR SPINE...\nLET'S GET OUT OF HERE!", 6.66, urgent:true);
      }
      if (musicFadeTimer < 0 && ghostTimeLeft <= global.config.ghostExtraTime*30) {
        musicFadeTimer = 0;
      }
    }
    return;
  }

  // spawn her
  if (player.isExitingSprite) {
    // no reason to spawn her, we're leaving
    ghostTimeLeft = -1;
    return;
  }

  spawnGhost();
}


void thinkFrameGame () {
  thinkFrameGameGhost();
}


// ////////////////////////////////////////////////////////////////////////// //
private transient array!MapObject activeThinkerList;


private final bool isWetTile (MapTile t) {
  return (t && t.visible && (t.water || t.lava || t.wet));
}


private final bool isWetOrSolidTile (MapTile t) {
  return (t && t.visible && (t.water || t.lava || t.wet || t.solid) && t.isInstanceAlive);
}


final bool isWetOrSolidTileAtPoint (int px, int py) {
  return !!checkTileAtPoint(px, py, &isWetOrSolidTile);
}


final bool isWetOrSolidTileAtTile (int tx, int ty) {
  return !!checkTileAtPoint(tx*16, ty*16, &isWetOrSolidTile);
}


final bool isWetTileAtTile (int tx, int ty) {
  return !!checkTileAtPoint(tx*16, ty*16, &isWetTile);
}


const int GreatLakeStartTileY = 28;

// called once after level generation
final void fixLiquidTop () {
  foreach (int tileY; 0..tilesHeight) {
    foreach (int tileX; 0..tilesWidth) {
      auto t = tiles[tileX, tileY];

      if (t && !t.isInstanceAlive) {
        delete tiles[tileX, tileY];
        t = none;
      }

      //if (!t) continue;
      //if (!t.water && !t.lava) continue;

      if (!t) {
        if (global.lake && tileY >= GreatLakeStartTileY) {
          //if (tileX >= NormalTilesWidth) continue;
          // fill level with water for lake
          MakeMapTile(tileX, tileY, 'oWaterSwim');
          t = tiles[tileX, tileY];
        } else {
          continue;
        }
      }

      if (!t.water && !t.lava) {
        // mark as wet for lake
        if (global.lake && tileY >= GreatLakeStartTileY) {
          /*
          if (!t.solid) {
            delete tiles[tileX, tileY];
            MakeMapTile(tileX, tileY, 'oWaterSwim');
            t = tiles[tileX, tileY];
          } else {
            t.wet = true;
          }
          */
          t.wet = true;
        }
        continue;
      }

      if (!isWetTileAtTile(tileX, tileY-1)) {
        t.setSprite(t.lava ? 'sLavaTop' : 'sWaterTop');
        continue;
      }

      /* k8: don't distribute, the code above will take care of this
      if (t.spriteName != 'sWaterTop' && t.spriteName != 'sLavaTop') {
        MapTile obj = getTileAt(tileX-1, tileY);
        if (obj && (obj.water || obj.lava)) {
          if (obj.spriteName == 'sWaterTop' || obj.spriteName == 'sLavaTop') {
            //writeln("FIXLTOP (01)!");
            t.setSprite(t.lava ? 'sLavaTop' : 'sWaterTop');
          }
        }
      }

      if (t.spriteName != 'sWaterTop' && t.spriteName != 'sLavaTop') {
        MapTile obj = getTileAt(tileX+1, tileY);
        if (obj && (obj.water || obj.lava)) {
          if (obj.spriteName == 'sWaterTop' || obj.spriteName == 'sLavaTop') {
            //writeln("FIXLTOP (02)!");
            t.setSprite(t.lava ? 'sLavaTop' : 'sWaterTop');
          }
        }
      }
      */
    }
  }
}


private final void checkWaterFlow (MapTile wtile) {
  //if (!wtile || (!wtile.water && !wtile.lava)) return;
  //instance_activate_region(x-16, y-16, 48, 48, true);

  //int x = wtile.ix, y = wtile.iy;
  int tileX = wtile.ix/16, tileY = wtile.iy/16;

  if (global.lake && tileY >= GreatLakeStartTileY) return;

  /*
  if ((not collision_point(x-16, y, oSolid, 0, 0) and not collision_point(x-16, y, oWater, 0, 0)) or
      (not collision_point(x+16, y, oSolid, 0, 0) and not collision_point(x+16, y, oWater, 0, 0)) or
      (not collision_point(x, y+16, oSolid, 0, 0) and not collision_point(x, y+16, oWater, 0, 0)))
  */
  if (!isWetOrSolidTileAtTile(tileX-1, tileY) ||
      !isWetOrSolidTileAtTile(tileX+1, tileY) ||
      !isWetOrSolidTileAtTile(tileX, tileY+1))
  {
    checkWater = true;
    wtile.instanceRemove();
    wtile.onDestroy();
    delete wtile;
    tiles[tileX, tileY] = none;
    return;
  }

  //if (!isSolidAtPoint(x, y-16) && !isLiquidAtPoint(x, y-16)) {
  if (!isWetTileAtTile(tileX, tileY-1)) {
    wtile.setSprite(wtile.lava ? 'sLavaTop' : 'sWaterTop');
  }

  /* k8: don't distribute, the code above will take care of this
  if (wtile.spriteName != 'sWaterTop' && wtile.spriteName != 'sLavaTop') {
    MapTile obj = getTileAt(tileX-1, tileY);
    if (obj && (obj.water || obj.lava)) {
      if (obj.spriteName == 'sWaterTop' || obj.spriteName == 'sLavaTop') {
        wtile.setSprite(wtile.lava ? 'sLavaTop' : 'sWaterTop');
      }
    }
  }

  if (wtile.spriteName != 'sWaterTop' && wtile.spriteName != 'sLavaTop') {
    MapTile obj = getTileAt(tileX+1, tileY);
    if (obj && (obj.water || obj.lava)) {
      if (obj.spriteName == 'sWaterTop' || obj.spriteName == 'sLavaTop') {
        wtile.setSprite(wtile.lava ? 'sLavaTop' : 'sWaterTop');
      }
    }
  }
  */
}


transient private array!MapTile waterTilesToCheck;

final void cleanDeadTiles () {
  bool hasWater = false;
  waterTilesToCheck.length -= waterTilesToCheck.length;
  foreach (int y; 0..tilesHeight) {
    foreach (int x; 0..tilesWidth) {
      auto t = tiles[x, y];
      if (!t) continue;
      if (t.isInstanceAlive) {
        if (t.water || t.lava) waterTilesToCheck[$] = t;
        continue;
      }
      checkWater = true;
      t.onDestroy();
      delete t;
      tiles[x, y] = none;
    }
  }
  if (waterTilesToCheck.length && checkWater && !blockWaterChecking) {
    //writeln("checking water");
    checkWater = false; // `checkWaterFlow()` can set it again
    foreach (MapTile t; waterTilesToCheck) {
      if (t && t.isInstanceAlive && (t.water || t.lava)) checkWaterFlow(t);
    }
    // fill empty spaces in lake with water
    if (global.lake) {
      foreach (int y; GreatLakeStartTileY..tilesHeight) {
        foreach (int x; 0..tilesWidth) {
          auto t = tiles[x, y];
          // just in case
          if (t && !t.isInstanceAlive) {
            t.onDestroy();
            delete tiles[x, y];
            t = none;
          }
          if (t) {
            if (!t.water || !t.lava) { t.wet = true; continue; }
          } else {
            MakeMapTile(x, y, 'oWaterSwim');
            t = tiles[x, y];
          }
          if (t.water) {
            t.setSprite(y == GreatLakeStartTileY ? 'sWaterTop' : 'sWater');
          } else if (t.lava) {
            t.setSprite(y == GreatLakeStartTileY ? 'sLavaTop' : 'sLava');
          }
        }
      }
    }
  }
}


// return `true` if thinker should be removed
final bool thinkOne (MapObject o) {
  if (!o) return true;
  if (o.active && o.isInstanceAlive) {
    bool doThink = true;

    // collision with player weapon
    auto hh = PlayerWeapon(player.holdItem);
    bool doWeaponAction;
    if (hh) {
      if (hh.blockedBySolids) {
        int xx = player.ix+(player.dir == MapObject::Dir.Left ? -16 : 16);
        doWeaponAction = !isSolidAtPoint(xx, player.iy);
      } else {
        doWeaponAction = true;
      }
    } else {
      doWeaponAction = false;
    }

    if (doWeaponAction && o.whipTimer <= 0 && hh && hh.collidesWithObject(o)) {
      //writeln("WEAPONED!");
      if (!o.onTouchedByPlayerWeapon(player, hh)) {
        if (o.isInstanceAlive) hh.onCollisionWithObject(o);
      }
      o.whipTimer = o.whipTimerValue; //HACK
      doThink = o.isInstanceAlive;
    }

    // collision with player
    if (doThink && o.collidesWith(player)) {
      if (!player.onObjectTouched(o) && o.isInstanceAlive) {
        doThink = !o.onTouchedByPlayer(player);
        if (o.grid && o.gridId) o.grid.update(o.gridId, markAsDead:true);
      }
    }

    if (doThink && o.isInstanceAlive) {
      o.saveInterpData();
      o.processAlarms();
      if (o.isInstanceAlive) {
        if (o.grid && o.gridId) o.grid.update(o.gridId, markAsDead:true);
        o.thinkFrame();
        if (o.isInstanceAlive) {
          o.nextAnimFrame();
          if (o.grid && o.gridId) o.grid.update(o.gridId, markAsDead:true);
        }
      }
    }
  }
  if (o.isInstanceAlive) {
    if (!o.canLiveOutsideOfLevel && o.isOutsideOfLevel()) {
      //dead
      o.instanceRemove();
      return true;
    }
    // alive
    return false;
  } else {
    // dead
    return true;
  }
}


final void processThinkers (float timeDelta) {
  if (timeDelta <= 0) return;
  if (gamePaused) {
    if (onBeforeFrame) onBeforeFrame(false);
    if (onAfterFrame) onAfterFrame(false);
    keysNextFrame();
    return;
  }
  accumTime += timeDelta;
  bool wasFrame = false;
  // block GC
  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  while (accumTime >= FrameTime) {
    accumTime -= FrameTime;
    if (onBeforeFrame) onBeforeFrame(accumTime >= FrameTime);
    // shake
    if (shakeLeft > 0) {
      --shakeLeft;
      if (!shakeDir.x) shakeDir.x = (global.randOther(0, 1) ? -3 : 3);
      if (!shakeDir.y) shakeDir.y = (global.randOther(0, 1) ? -3 : 3);
      shakeOfs.x = shakeDir.x;
      shakeOfs.y = shakeDir.y;
      int sgnc = global.randOther(1, 3);
      if (sgnc&0x01) shakeDir.x = -shakeDir.x;
      if (sgnc&0x02) shakeDir.y = -shakeDir.y;
    } else {
      shakeOfs.x = 0;
      shakeOfs.y = 0;
      shakeDir.x = 0;
      shakeDir.y = 0;
    }
    // game-global events
    thinkFrameGame();
    // frame thinkers: player
    if (player && !disablePlayerThink) {
      // time limit
      if (!player.dead && isNormalLevel() &&
          (maxPlayingTime < 0 ||
           (maxPlayingTime > 0 && maxPlayingTime*30 <= time &&
            time%30 == 0 && global.randOther(1, 100) <= 20)))
      {
        MakeMapObject(player.ix, player.iy, 'oExplosion');
        player.scrCreateFlame(player.ix, player.iy, 3);
      }
      //HACK: check for stolen items
      auto item = MapItem(player.holdItem);
      if (item) item.onCheckItemStolen(player);
      item = MapItem(player.pickedItem);
      if (item) item.onCheckItemStolen(player);
      // normal thinking
      player.saveInterpData();
      player.processAlarms();
      if (player.isInstanceAlive) {
        player.thinkFrame();
        if (player.isInstanceAlive) player.nextAnimFrame();
      }
    }
    // frame thinkers: moveable solids
    physStep();
    // frame thinkers: objects
    auto grid = objGrid;
    // collect active objects
    if (global.config.useFrozenRegion) {
      activeThinkerList.length -= activeThinkerList.length;
      foreach (MapObject o; grid.inRectPix(viewStart.x/global.scale-64, viewStart.y/global.scale-64, 320+64*2, 240+64*2, tag:grid.nextTag(), precise:false)) {
        activeThinkerList[$] = o;
      }
      //writeln("thinkers: ", activeThinkerList.length);
      foreach (MapObject o; activeThinkerList) {
        if (thinkOne(o)) {
          grid.remove(o.gridId);
          o.onDestroy();
          delete o;
        }
      }
    } else {
      // no frozen area
      bool killThisOne = false;
      for (int cid = grid.getFirstObject(); cid; cid = grid.getNextObject(cid, killThisOne)) {
        killThisOne = false;
        MapObject o = grid.getObject(MapObject, cid);
        if (!o) { killThisOne = true; continue; }
        // remove this object if it is dead
        if (thinkOne(o)) {
          killThisOne = true;
          if (o) {
            o.onDestroy();
            delete o;
          }
        }
      }
    }
    // done with thinkers
    cleanDeadTiles();
    // money counter
    if (collectCounter == 0) {
      xmoney = max(0, xmoney-100);
    } else {
      --collectCounter;
    }
    // other things
    if (player && !player.dead) stats.oneMoreFramePlayed();
    if (onAfterFrame) onAfterFrame(accumTime >= FrameTime);
    keysNextFrame();
    wasFrame = true;
    if (playerExited) break;
  }
  ImmediateDelete = olddel;
  if (playerExited) {
    playerExited = false;
    onLevelExited();
  }
  if (wasFrame) {
    // if we were processed at least one frame, collect garbage
    //keysNextFrame();
    CollectGarbage(true); // destroy delayed objects too
  }
  if (player.holdItem) player.holdItem.fixHoldCoords();
  if (accumTime > 0 && onInterFrame) onInterFrame(accumTime/FrameTime);
}


// ////////////////////////////////////////////////////////////////////////// //
final void tileXY2roomXY (int tileX, int tileY, out int roomX, out int roomY) {
  roomX = (tileX-1)/RoomGen::Width;
  roomY = (tileY-1)/RoomGen::Height;
}


final bool isInShop (int tileX, int tileY) {
  if (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight) {
    auto n = roomType[tileX, tileY];
    if (n == 4 || n == 5) return true;
    auto t = getTileAt(tileX, tileY);
    if (t && t.shopWall) return true;
    //k8: we don't have this
    //if (t && t.objType == 'oShop') return true;
  }
  return false;
}


// ////////////////////////////////////////////////////////////////////////// //
override void Destroy () {
  clearTiles();
  clearObjects();
  ::Destroy();
}


// ////////////////////////////////////////////////////////////////////////// //
final MapObject findNearestBall (int px, int py) {
  MapObject res = none;
  int curdistsq = int.max;
  foreach (MapObject o; ballObjects) {
    if (!o || o.spectral || !o.isInstanceAlive) continue;
    int xc = px-o.xCenter, yc = py-o.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq) {
      res = o;
      curdistsq = distsq;
    }
  }
  return res;
}


final int calcNearestBallDist (int px, int py) {
  auto e = findNearestBall(px, py);
  if (!e) return int.max;
  int xc = px-e.xCenter, yc = py-e.yCenter;
  return round(sqrt(xc*xc+yc*yc));
}


final MapObject findNearestObject (int px, int py, bool delegate (MapObject o) dg) {
  MapObject res = none;
  int curdistsq = int.max;
  foreach (MapObject o; objGrid.allObjects()) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (!dg(o)) continue;
    int xc = px-o.xCenter, yc = py-o.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq) {
      res = o;
      curdistsq = distsq;
    }
  }
  return res;
}


final MapObject findNearestEnemy (int px, int py, optional bool delegate (MapEnemy o) dg) {
  MapObject res = none;
  int curdistsq = int.max;
  foreach (MapObject o; objGrid.allObjects()) {
    //k8: i added `dead` check
    if (o.spectral || o !isa MapEnemy || o.dead || !o.isInstanceAlive) continue;
    if (dg) {
      if (!dg(MapEnemy(o))) continue;
    }
    int xc = px-o.xCenter, yc = py-o.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq) {
      res = o;
      curdistsq = distsq;
    }
  }
  return res;
}


final MonsterShopkeeper hasAliveShopkeepers (optional bool skipAngry) {
  foreach (MapObject o; objGrid.allObjects()) {
    auto sc = MonsterShopkeeper(o);
    if (!sc || o.spectral || !o.isInstanceAlive) continue;
    if (sc.dead) continue;
    if (skipAngry && sc.angered) continue;
    return sc;
  }
  return none;
}


final int calcNearestEnemyDist (int px, int py, optional bool delegate (MapEnemy o) dg) {
  auto e = findNearestEnemy(px, py, dg!optional);
  if (!e) return int.max;
  int xc = px-e.xCenter, yc = py-e.yCenter;
  return round(sqrt(xc*xc+yc*yc));
}


final int calcNearestObjectDist (int px, int py, optional bool delegate (MapObject o) dg) {
  auto e = findNearestObject(px, py, dg!optional);
  if (!e) return int.max;
  int xc = px-e.xCenter, yc = py-e.yCenter;
  return round(sqrt(xc*xc+yc*yc));
}


final MapTile findNearestMoveableSolid (int px, int py, optional bool delegate (MapTile t) dg) {
  MapTile res = none;
  int curdistsq = int.max;
  foreach (MapTile t; miscTileGrid.allObjects()) {
    if (t.spectral || !t.isInstanceAlive) continue;
    if (dg) {
      if (!dg(t)) continue;
    } else {
      if (!t.solid || !t.moveable) continue;
    }
    int xc = px-t.xCenter, yc = py-t.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq) {
      res = t;
      curdistsq = distsq;
    }
  }
  return res;
}


final MapTile findNearestTile (int px, int py, optional bool delegate (MapTile t) dg) {
  if (!dg) return none;
  MapTile res = none;
  int curdistsq = int.max;

  //FIXME: make this faster!
  foreach (MapTile t; tiles) {
    if (!t || t.spectral || !t.isInstanceAlive) continue;
    int xc = px-t.xCenter, yc = py-t.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq && dg(t)) {
      res = t;
      curdistsq = distsq;
    }
  }

  foreach (MapTile t; miscTileGrid.allObjects()) {
    if (!t || t.spectral || !t.isInstanceAlive) continue;
    int xc = px-t.xCenter, yc = py-t.yCenter;
    int distsq = xc*xc+yc*yc;
    if (distsq < curdistsq && dg(t)) {
      res = t;
      curdistsq = distsq;
    }
  }

  return res;
}


// ////////////////////////////////////////////////////////////////////////// //
final bool cbIsObjectWeb (MapObject o) { return (o isa ItemWeb); }
final bool cbIsObjectBlob (MapObject o) { return (o.objName == 'oBlob'); }
final bool cbIsObjectArrow (MapObject o) { return (o isa ItemProjectileArrow); }
final bool cbIsObjectEnemy (MapObject o) { return (/*o != self &&*/ o isa MapEnemy); }

final bool cbIsObjectTreasure (MapObject o) { return (o.isTreasure); }

final bool cbIsItemObject (MapObject o) { return (o isa MapItem); }

final bool cbIsItemOrEnemyObject (MapObject o) { return (o isa MapItem || o isa MapEnemy); }


final MapObject isObjectAtTile (int tileX, int tileY, optional bool delegate (MapObject o) dg) {
  tileX *= 16;
  tileY *= 16;
  foreach (MapObject o; objGrid.inRectPix(tileX, tileY, 16, 16, objGrid.nextTag(), precise: true)) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (dg) {
      if (dg(o)) return o;
    } else {
      return o;
    }
  }
  return none;
}


final MapObject isObjectAtTilePix (int x, int y, optional bool delegate (MapObject o) dg) {
  return isObjectAtTile(x/16, y/16, dg!optional);
}


final MapObject isObjectAtPoint (int xpos, int ypos, optional bool delegate (MapObject o) dg, optional bool precise) {
  if (!specified_precise) precise = true;
  foreach (MapObject o; objGrid.inCellPix(xpos, ypos, objGrid.nextTag(), precise: precise)) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (dg) {
      if (dg(o)) return o;
    } else {
      if (o isa MapEnemy) return o;
    }
  }
  return none;
}


final MapObject isObjectInRect (int xpos, int ypos, int w, int h, optional bool delegate (MapObject o) dg, optional bool precise) {
  if (w < 1 || h < 1) return none;
  if (w == 1 && h == 1) return isObjectAtPoint(xpos, ypos, dg!optional, precise!optional);
  if (!specified_precise) precise = true;
  foreach (MapObject o; objGrid.inRectPix(xpos, ypos, w, h, objGrid.nextTag(), precise: precise)) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (dg) {
      if (dg(o)) return o;
    } else {
      if (o isa MapEnemy) return o;
    }
  }
  return none;
}


final MapObject forEachObject (bool delegate (MapObject o) dg) {
  if (!dg) return none;
  foreach (MapObject o; objGrid.allObjects()) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (dg(o)) return o;
  }
  return none;
}


final MapObject forEachObjectAtPoint (int xpos, int ypos, bool delegate (MapObject o) dg, optional bool precise) {
  if (!dg) return none;
  if (!specified_precise) precise = true;
  foreach (MapObject o; objGrid.inCellPix(xpos, ypos, objGrid.nextTag(), precise: precise)) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (dg(o)) return o;
  }
  return none;
}


final MapObject forEachObjectInRect (int xpos, int ypos, int w, int h, bool delegate (MapObject o) dg, optional bool precise) {
  if (!dg || w < 1 || h < 1) return none;
  if (w == 1 && h == 1) return forEachObjectAtPoint(xpos, ypos, dg!optional, precise!optional);
  if (!specified_precise) precise = true;
  foreach (MapObject o; objGrid.inRectPix(xpos, ypos, w, h, objGrid.nextTag(), precise: precise)) {
    if (o.spectral || !o.isInstanceAlive) continue;
    if (dg(o)) return o;
  }
  return none;
}


private final bool cbIsRopeTile (MapTile t) { return t.rope; }

final MapTile isRopeAtPoint (int px, int py) {
  return checkTileAtPoint(px, py, &cbIsRopeTile);
}


//FIXME!
final MapTile isWaterSwimAtPoint (int px, int py) {
  return isWaterAtPoint(px, py);
}


// ////////////////////////////////////////////////////////////////////////// //
private array!MapObject tmpObjectList;

private final bool cbCollectObjectsWithMask (MapObject t) {
  if (!t || !t.visible || t.spectral /*|| t.invincible*/ || !t.isInstanceAlive) return false;
  //auto spf = getSpriteFrame();
  //if (!t.sprite || t.sprite.frames.length < 1) return false;
  tmpObjectList[$] = t;
  return false;
}


final void touchObjectsWithMask (int x, int y, SpriteFrame frm, bool delegate (MapObject t) dg) {
  if (!frm || frm.bw < 1 || frm.bh < 1 || !dg) return;
  if (frm.isEmptyPixelMask) return;
  // collect tiles
  if (tmpObjectList.length) tmpObjectList.length -= tmpObjectList.length; // don't realloc
  if (player.isRectCollisionFrame(frm, x, y)) {
    //writeln("player hit");
    tmpObjectList[$] = player;
  } else {
    /*
    writeln("no player hit: plr=(", player.ix, ",", player.iy, ")-(", player.ix+player.width-1, ",", player.iy+player.height-1, "); ",
      "frm=(", x+frm.bx, ",", y+frm.by, ")-(", x+frm.bx+frm.bw-1, ",", y+frm.by+frm.bh-1, ")");
    */
  }
  forEachObjectInRect(x+frm.bx, y+frm.by, frm.bw, frm.bh, &cbCollectObjectsWithMask);
  foreach (MapObject t; tmpObjectList) {
    if (!t || !t.isInstanceAlive || !t.visible || t.spectral) continue;
    /*
    auto tf = t.getSpriteFrame();
    if (!tf) {
      //writeln("no sprite frame for ", GetClassName(t.Class));
      continue;
    }
    */
    /*
    if (frm.pixelCheck(tf, t.ix-tf.xofs-x, t.iy-tf.yofs-y)) {
      //writeln("pixel hit for ", GetClassName(t.Class));
      if (dg(t)) break;
    }
    */
    if (t.isRectCollisionFrame(frm, x, y)) {
      if (dg(t)) break;
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final void destroyTileAt (int x, int y) {
  if (x < 0 || y < 0 || x >= tilesWidth*16 || y >= tilesHeight*16) return;
  x /= 16;
  y /= 16;
  MapTile t = tiles[x, y];
  if (!t || !t.visible || t.spectral || t.invincible || !t.isInstanceAlive) return;
  t.instanceRemove();
  t.onDestroy();
  delete tiles[x, y];
  checkWater = true;
}


private array!MapTile tmpTileList;

private final bool cbCollectTilesWithMask (MapTile t) {
  if (!t || !t.visible || t.spectral /*|| t.invincible*/ || !t.isInstanceAlive) return false;
  if (!t.sprite || t.sprite.frames.length < 1) return false;
  tmpTileList[$] = t;
  return false;
}

final void touchTilesWithMask (int x, int y, SpriteFrame frm, bool delegate (MapTile t) dg) {
  if (!frm || frm.bw < 1 || frm.bh < 1 || !dg) return;
  if (frm.isEmptyPixelMask) return;
  // collect tiles
  if (tmpTileList.length) tmpTileList.length -= tmpTileList.length; // don't realloc
  checkTilesInRect(x+frm.bx, y+frm.by, frm.bw, frm.bh, &cbCollectTilesWithMask);
  foreach (MapTile t; tmpTileList) {
    if (!t || !t.isInstanceAlive || !t.visible || t.spectral) continue;
    /*
    auto tf = t.sprite.frames[0];
    if (frm.pixelCheck(tf, t.ix-x, t.iy-y)) {
      if (dg(t)) break;
      //doCleanup = doCleanup || !t.isInstanceAlive;
      //writeln("dtwm at (", x, ",", y, "): dead at (", t.ix, ",", t.iy, ") : (", x/16, ",", y/16, ") : (", t.ix/16, ",", t.iy/16, ") <", GetClassName(t.Class), "> (name:", t.objName, "; type:", t.objType, ")");
    }
    */
    if (t.isRectCollisionFrame(frm, x, y)) {
      if (dg(t)) break;
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final bool cbCollisionAnySolid (MapTile t) { return t.solid; }
final bool cbCollisionAnyMoveableSolid (MapTile t) { return t.solid && t.moveable; }
final bool cbCollisionLiquid (MapTile t) { return (t.water || t.lava); }
final bool cbCollisionAnySolidOrLiquid (MapTile t) { return (t.solid || t.water || t.lava); }
final bool cbCollisionLadder (MapTile t) { return t.ladder; }
final bool cbCollisionLadderTop (MapTile t) { return t.laddertop; }
final bool cbCollisionAnyLadder (MapTile t) { return (t.ladder || t.laddertop); }
final bool cbCollisionAnySolidIce (MapTile t) { return (t.solid && t.ice); }
final bool cbCollisionWater (MapTile t) { return t.water; }
final bool cbCollisionLava (MapTile t) { return t.lava; }
final bool cbCollisionAnyTree (MapTile t) { return t.tree; }
final bool cbCollisionPlatform (MapTile t) { return t.platform; }
final bool cbCollisionLadderOrPlatform (MapTile t) { return (t.ladder || t.platform); }
//final bool cbCollisionAnyHangeable (MapTile t) { return t.hangeable; } // no need to check for solids here, it is done in MapTile initializer
final bool cbCollisionSpringTrap (MapTile t) { return t.springtrap; }
final bool cbCollisionSpikes (MapTile t) { return t.spikes; }
final bool cbCollisionExitTile (MapTile t) { return t.exit; }

final bool cbCollisionForWhoa (MapTile t) { return (t.solid || t.laddertop); }

//final bool cbCollisionSacAltar (MapTile t) { return (t.objName == 'oSacAltarLeft'); } // only left part, yeah
final bool cbCollisionSacAltar (MapTile t) { return t.sacrificingAltar; }


// ////////////////////////////////////////////////////////////////////////// //
final MapTile checkTilesInRect (int x0, int y0, const int w, const int h, optional bool delegate (MapTile dg) dg, optional bool precise/*, optional bool dbgdump*/) {
  //!if (dbgdump) writeln("checkTilesInRect: (", x0, ",", y0, ")-(", x0+w-1, ",", y0+h-1, ") ; w=", w, "; h=", h);
  if (w < 1 || h < 1) return none;
  if (w == 1 && h == 1) return checkTileAtPoint(x0, y0, dg!optional);
  int x1 = x0+w-1, y1 = y0+h-1;
  if (x0 >= tilesWidth*16 || y0 >= tilesHeight*16 || x1 < 0 || y1 < 0) return none;
  if (!dg) {
    //!if (dbgdump) writeln("default checker set");
    dg = &cbCollisionAnySolid;
  }
  //!if (dbgdump) writeln("delegate: ", dg);
  int origx0 = x0, origy0 = y0;
  int tileSX = max(0, x0)/16;
  int tileSY = max(0, y0)/16;
  int tileEX = min(tilesWidth*16-1, x1)/16;
  int tileEY = min(tilesHeight*16-1, y1)/16;
  //!if (dbgdump) writeln("  tiles: (", tileSX, ",", tileSY, ")-(", tileEX, ",", tileEY, ")");
  auto grid = miscTileGrid;
  int tag = grid.nextTag();
  for (int ty = tileSY; ty <= tileEY; ++ty) {
    for (int tx = tileSX; tx <= tileEX; ++tx) {
      MapTile t = tiles[tx, ty];
      //!if (dbgdump && t && t.visible && t.isInstanceAlive && t.isRectCollision(origx0, origy0, w, h) ) writeln("   tile: ", GetClassName(t.Class), " : ", t.objName, " : ", t.objType, " : ", dg(t));
      if (t && !t.spectral && t.visible && t.isInstanceAlive && t.isRectCollision(origx0, origy0, w, h) && dg(t)) return t;
      // moveable tiles are in separate grid
      foreach (t; grid.inCellPix(tx*16, ty*16, tag, precise:precise)) {
        //if (t.isRectCollision(origx0, origy0, w, h) && dg(t)) return t;
        if (t.isInstanceAlive && !t.spectral && t.visible && t.isRectCollision(origx0, origy0, w, h) && dg(t)) return t;
      }
    }
  }
  return none;
}


final MapTile checkTileAtPoint (int x0, int y0, optional bool delegate (MapTile dg) dg) {
  if (x0 < 0 || y0 < 0 || x0 >= tilesWidth*16 || y0 >= tilesHeight*16) return none;
  if (!dg) dg = &cbCollisionAnySolid;
  //if (!self) { writeln("WTF?!"); return none; }
  MapTile t = tiles[x0/16, y0/16];
  if (t && !t.spectral && t.visible && t.isInstanceAlive && t.isPointCollision(x0, y0) && dg(t)) return t;
  // moveable tiles are in separate grid
  auto grid = miscTileGrid;
  foreach (t; grid.inCellPix(x0, y0, grid.nextTag(), precise:true)) {
    if (t.isInstanceAlive && !t.spectral && t.visible && dg(t)) return t;
  }
  return none;
}


//FIXME: optimize this with clipping first
//TODO: moveable tiles
/+
final MapTile checkTilesAtLine (int ax0, int ay0, int ax1, int ay1, optional bool delegate (MapTile dg) dg) {
  // do it faster if we can

  // strict vertical check?
  if (ax0 == ax1 && ay0 <= ay1) return checkTilesInRect(ax0, ay0, 1, ay1-ay0+1, dg!optional);
  // strict horizontal check?
  if (ay0 == ay1 && ax0 <= ax1) return checkTilesInRect(ax0, ay0, ax1-ax0+1, 1, dg!optional);

  float x0 = float(ax0)/16.0, y0 = float(ay0)/16.0, x1 = float(ax1)/16.0, y1 = float(ay1)/16.0;

  // fix delegate
  if (!dg) dg = &cbCollisionAnySolid;

  // get starting and enging tile
  int tileSX = trunc(x0), tileSY = trunc(y0);
  int tileEX = trunc(x1), tileEY = trunc(y1);

  // first hit is always landed
  if (tileSX >= 0 && tileSY >= 0 && tileSX < TilesWidth && tileSY < TilesHeight) {
    MapTile t = tiles[tileSX, tileSY];
    if (t && t.visible && Geom.lineAABBIntersects(ax0, ay0, ax1, ay1, tileSX*16, tileSY*16, 16, 16) && dg(t)) return t;
  }

  // if starting and ending tile is the same, we don't need to do anything more
  if (tileSX == tileEX && tileSY == tileEY) return none;

  // calculate ray direction
  TVec dv = (vector(x1, y1)-vector(x0, y0)).normalise2d;

  // length of ray from one x or y-side to next x or y-side
  float deltaDistX = (fabs(dv.x) > 0.0001 ? fabs(1.0/dv.x) : 0.0);
  float deltaDistY = (fabs(dv.y) > 0.0001 ? fabs(1.0/dv.y) : 0.0);

  // calculate step and initial sideDists

  float sideDistX; // length of ray from current position to next x-side
  int stepX; // what direction to step in x (either +1 or -1)
  if (dv.x < 0) {
    stepX = -1;
    sideDistX = (x0-tileSX)*deltaDistX;
  } else {
    stepX = 1;
    sideDistX = (tileSX+1.0-x0)*deltaDistX;
  }

  float sideDistY; // length of ray from current position to next y-side
  int stepY; // what direction to step in y (either +1 or -1)
  if (dv.y < 0) {
    stepY = -1;
    sideDistY = (y0-tileSY)*deltaDistY;
  } else {
    stepY = 1;
    sideDistY = (tileSY+1.0-y0)*deltaDistY;
  }

  // perform DDA
  //int side; // was a NS or a EW wall hit?
  for (;;) {
    // jump to next map square, either in x-direction, or in y-direction
    if (sideDistX < sideDistY) {
      sideDistX += deltaDistX;
      tileSX += stepX;
      //side = 0;
    } else {
      sideDistY += deltaDistY;
      tileSY += stepY;
      //side = 1;
    }
    // check tile
    if (tileSX >= 0 && tileSY >= 0 && tileSX < TilesWidth && tileSY < TilesHeight) {
      MapTile t = tiles[tileSX, tileSY];
      if (t && t.visible && Geom.lineAABBIntersects(ax0, ay0, ax1, ay1, tileSX*16, tileSY*16, 16, 16) && dg(t)) return t;
    }
    // did we arrived at the destination?
    if (tileSX == tileEX && tileSY == tileEY) break;
  }

  return none;
}
+/


// ////////////////////////////////////////////////////////////////////////// //
final MapTile isSolidAtPoint (int px, int py) { return checkTileAtPoint(px, py); }
final MapTile isSolidInRect (int rx, int ry, int rw, int rh) { return checkTilesInRect(rx, ry, rw, rh); }
final MapTile isLadderAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionLadder); }
final MapTile isLadderOrPlatformAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionLadderOrPlatform); }
final MapTile isLadderTopAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionLadderTop); }
final MapTile isAnyLadderAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionAnyLadder); }
final MapTile isWaterAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionWater); }
final MapTile isLavaAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionLava); }
final MapTile isLiquidAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionLiquid); }
final MapTile isIceAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionAnySolidIce); }
final MapTile isTreeAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionAnyTree); }
//final MapTile isHangeableAtPoint (int px, int py) { return checkTileAtPoint(px, py, &cbCollisionAnyHangeable); }


// ////////////////////////////////////////////////////////////////////////// //
// PlayerPawn has it's own movement code, so don't process it here
// but process moveable solids here, yeah
final void physStep () {
  // advance time
  time += 1;
  // we don't want the time to grow too large
  if (time > 100000000) time = 0;

  auto grid = miscTileGrid;

  // process gravity for moveable solids and burning for ropes
  int cid = grid.getFirstObject();
  while (cid) {
    MapTile t = grid.getObject(MapTile, cid);
    if (!t) continue;
    if (t.isInstanceAlive) {
      t.saveInterpData();
      t.processAlarms();
      if (t.isInstanceAlive) {
        grid.update(cid, markAsDead:false);
        t.thinkFrame();
        if (t.isInstanceAlive && !t.canLiveOutsideOfLevel && t.isOutsideOfLevel()) t.instanceRemove();
        grid.update(cid, markAsDead:false);
      }
    }
    if (t.isInstanceAlive) {
      cid = grid.getNextObject(cid, removeThis:false);
    } else {
      cid = grid.getNextObject(cid, removeThis:true);
      t.instanceRemove(); // just in case
      t.onDestroy();
      delete t;
      checkWater = true;
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final void setTileTypeAt (int tileX, int tileY, LevelGen::RType rt) {
  if (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight) roomType[tileX, tileY] = rt;
}

final MapTile getTileAt (int tileX, int tileY) {
  return (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight ? tiles[tileX, tileY] : none);
}

final bool isNamedTileAt (int tileX, int tileY, name atypename) {
  if (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight) {
    auto t = tiles[tileX, tileY];
    if (t && t.objName == atypename) return true;
  }
  return false;
}

final void setTileAt (int tileX, int tileY, MapTile tile) {
  if (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight) {
    //FIXME
    if (tiles[tileX, tileY]) checkWater = true;
    delete tiles[tileX, tileY];
    tiles[tileX, tileY] = tile;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// return `true` from delegate to stop
MapTile forEachSolidTile (bool delegate (int x, int y, MapTile t) dg) {
  if (!dg) return none;
  foreach (int y; 0..tilesHeight) {
    foreach (int x; 0..tilesWidth) {
      auto t = tiles[x, y];
      if (t && t.solid && t.visible && t.isInstanceAlive) {
        if (dg(x, y, t)) return t;
      }
    }
  }
  return none;
}


// ////////////////////////////////////////////////////////////////////////// //
// return `true` from delegate to stop
MapTile forEachNormalTile (bool delegate (int x, int y, MapTile t) dg) {
  if (!dg) return none;
  foreach (int y; 0..tilesHeight) {
    foreach (int x; 0..tilesWidth) {
      auto t = tiles[x, y];
      if (t && t.visible && t.isInstanceAlive) {
        if (dg(x, y, t)) return t;
      }
    }
  }
  return none;
}


// WARNING! don't destroy tiles here! (instanceRemove() is ok, tho)
MapTile forEachTile (bool delegate (MapTile t) dg) {
  if (!dg) return none;
  foreach (int y; 0..tilesHeight) {
    foreach (int x; 0..tilesWidth) {
      auto t = tiles[x, y];
      if (t && t.visible && !t.spectral && t.isInstanceAlive) {
        if (dg(t)) return t;
      }
    }
  }
  foreach (MapObject o; miscTileGrid.allObjects()) {
    auto mt = MapTile(o);
    if (!mt) continue;
    if (mt.visible && !mt.spectral && mt.isInstanceAlive) {
      //writeln("special map tile: '", GetClassName(mt.Class), "'");
      if (dg(mt)) return mt;
    }
  }
  return none;
}


// ////////////////////////////////////////////////////////////////////////// //
final void fixWallTiles () {
  foreach (int y; 0..tilesHeight) {
    foreach (int x; 0..tilesWidth) {
      auto t = getTileAt(x, y);
      if (!t) continue;
      /*
      if (y == tilesHeight-2) {
        writeln("0: tx=", x, "; tile=", t.objName, "; ty=", y, ": (", t.iy/16, ")");
      } else if (y == tilesHeight-1) {
        writeln("1: tx=", x, "; tile=", t.objName, "; ty=", y, ": (", t.iy/16, ")");
      }
      */
      t.beautifyTile();
    }
  }
  foreach (MapTile t; miscTileGrid.allObjects()) {
    if (t.isInstanceAlive) t.beautifyTile();
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final MapTile isCollisionAtPoint (int px, int py, optional bool delegate (MapTile dg) dg) {
  if (!dg) dg = &cbCollisionAnySolid;
  return checkTilesInRect(px, py, 1, 1, dg);
}


// ////////////////////////////////////////////////////////////////////////// //
string scrGetKaliGift (MapTile altar, optional name gift) {
  string res;

  // find other side of the altar
  int sx = player.ix, sy = player.iy;
  if (altar) {
    sx = altar.ix;
    sy = altar.iy;
    auto a2 = isCollisionAtPoint(altar.ix+18, altar.iy+8, &cbCollisionSacAltar);
    if (!a2) a2 = isCollisionAtPoint(altar.ix-8, altar.iy+8, &cbCollisionSacAltar);
    if (a2) { sx = a2.ix; sy = a2.iy; }
  }

       if (global.favor <= -8) res = "SHE SEEMS VERY ANGRY WITH YOU!";
  else if (global.favor < 0) res = "SHE SEEMS ANGRY WITH YOU.";
  else if (global.favor == 0) res = "SHE HAS FORGIVEN YOU!";
  else if (global.favor >= 32) {
    if (global.kaliGift >= 3 && global.favor >= 32+(global.kaliGift-2)*16) {
      res = "YOU FEEL INVIGORATED!";
      global.kaliGift += 1;
      global.plife += global.randOther(4, 8);
    } else if (global.kaliGift >= 3) {
      res = "SHE SEEMS ECSTATIC WITH YOU!";
    } else if (global.bombs < 80) {
      res = "YOUR SATCHEL FEELS VERY FULL NOW!";
      global.kaliGift = 3;
      global.bombs = 99;
    } else {
      res = "YOU FEEL INVIGORATED!";
      global.kaliGift += 1;
      global.plife += global.randOther(4, 8);
    }
  } else if (global.favor >= 16) {
    if (global.kaliGift >= 2) {
      res = "SHE SEEMS VERY HAPPY WITH YOU!";
    } else {
      res = "SHE BESTOWS A GIFT UPON YOU!";
      global.kaliGift = 2;
      // poofs
      auto obj = MakeMapObject(sx, sy-8, 'oPoof');
      obj.xVel = -1;
      obj.yVel = 0;
      obj = MakeMapObject(sx, sy-8, 'oPoof');
      obj.xVel = 1;
      obj.yVel = 0;
      // a gift
      obj = none;
      if (gift) obj = MakeMapObject(sx, sy-8, gift);
      if (!obj) obj = MakeMapObject(sx, sy-8, 'oKapala');
    }
  } else if (global.favor >= 8) {
    if (global.kaliGift >= 1) {
      res = "SHE SEEMS HAPPY WITH YOU.";
    } else {
      res = "SHE BESTOWS A GIFT UPON YOU!";
      global.kaliGift = 1;
      //rAltar = instance_nearest(x, y, oSacAltarRight);
      //if (instance_exists(rAltar)) {
      // poofs
      auto obj = MakeMapObject(sx, sy-8, 'oPoof');
      obj.xVel = -1;
      obj.yVel = 0;
      obj = MakeMapObject(sx, sy-8, 'oPoof');
      obj.xVel = 1;
      obj.yVel = 0;
      obj = none;
      if (gift) obj = MakeMapObject(sx, sy-8, gift);
      if (!obj) {
        auto n = global.randOther(1, 8);
        auto m = n;
        for (;;) {
          name aname = '';
               if (n == 1 && !global.hasCape && !global.hasJetpack) aname = 'oCapePickup';
          else if (n == 2 && !global.hasGloves) aname = 'oGloves';
          else if (n == 3 && !global.hasSpectacles) aname = 'oSpectacles';
          else if (n == 4 && !global.hasMitt) aname = 'oMitt';
          else if (n == 5 && !global.hasSpringShoes) aname = 'oSpringShoes';
          else if (n == 6 && !global.hasSpikeShoes) aname = 'oSpikeShoes';
          else if (n == 7 && !global.hasStickyBombs) aname = 'oPaste';
          else if (n == 8 && !global.hasCompass) aname = 'oCompass';
          if (aname) {
            obj = MakeMapObject(sx, sy-8, aname);
            if (obj) break;
          }
          ++n;
          if (n > 8) n = 1;
          if (n == m) {
            obj = MakeMapObject(sx, sy-8, (global.hasJetpack ? 'oBombBox' : 'oJetpack'));
            break;
          }
        }
      }
    }
  } else if (global.favor > 0) {
    res = "SHE SEEMS PLEASED WITH YOU.";
  }

  /*
  if (argument1) {
    global.message = "";
    res = "KALI DEVOURS YOU!"; // sacrifice is player
  }
  */

  return res;
}


void performSacrifice (MapObject what, MapTile where) {
  if (!what || !what.isInstanceAlive) return;
  MakeMapObject(what.ix+8, what.iy+8, 'oFlame');
  if (where) where.playSound('sndSmallExplode'); else what.playSound('sndSmallExplode');
  if (!what.bloodless) what.scrCreateBlood(what.ix+8, what.iy+8, 3);

  string msg = "KALI ACCEPTS THE SACRIFICE!";

  auto idol = ItemGoldIdol(what);
  if (idol) {
    ++stats.totalSacrifices;
         if (global.favor <= -8) msg = "SHE SEEMS VERY ANGRY WITH YOU!";
    else if (global.favor < 0) msg = "SHE SEEMS ANGRY WITH YOU.";
    else if (global.favor >= 0) {
      // find other side of the altar
      int sx = player.ix, sy = player.iy;
      auto altar = where;
      if (altar) {
        sx = altar.ix;
        sy = altar.iy;
        auto a2 = isCollisionAtPoint(altar.ix+18, altar.iy+8, &cbCollisionSacAltar);
        if (!a2) a2 = isCollisionAtPoint(altar.ix-8, altar.iy+8, &cbCollisionSacAltar);
        if (a2) { sx = a2.ix; sy = a2.iy; }
      }
      // poofs
      auto obj = MakeMapObject(sx, sy-8, 'oPoof');
      obj.xVel = -1;
      obj.yVel = 0;
      obj = MakeMapObject(sx, sy-8, 'oPoof');
      obj.xVel = 1;
      obj.yVel = 0;
      // a gift
      obj = MakeMapObject(sx, sy-16-8, 'oMonkeyGold');
    }
    osdMessage(msg, 6.66);
    scrShake(10);
    idol.instanceRemove();
    return;
  }

  if (global.favor <= -8) {
    msg = "KALI DEVOURS THE SACRIFICE!";
  } else if (global.favor < 0) {
    global.favor += (what.status == MapObject::STUNNED ? what.favor : round(what.favor/2.0)); //k8: added `round()`
    if (what.favor > 0) what.favor = 0;
  } else {
    global.favor += (what.status == MapObject::STUNNED ? what.favor : round(what.favor/2.0)); //k8: added `round()`
  }

  /*!!
       if (myAltar.gift1 != "" and global.kaliGift == 0) scrGetKaliGift(myAltar.gift1);
  else if (myAltar.gift2 != "" and global.kaliGift == 1) scrGetKaliGift(myAltar.gift2);
  else scrGetKaliGift("");
  */

  // sacrifice is player?
  if (what isa PlayerPawn) {
    ++stats.totalSelfSacrifices;
    msg = "KALI DEVOURS YOU!";
    player.visible = false;
    player.dead = true;
    player.status = MapObject::DEAD;
  } else {
    ++stats.totalSacrifices;
    auto msg2 = scrGetKaliGift(where);
    what.instanceRemove();
    if (msg2) msg = va("%s\n%s", msg, msg2);
  }

  osdMessage(msg, 6.66);

  //!if (isRealLevel()) global.totalSacrifices += 1;

  //!global.messageTimer = 200;
  //!global.shake = 10;
  scrShake(10);

  /*damsel
  instance_create(x, y, oFlame);
  playSound(global.sndSmallExplode);
  scrCreateBlood(x, y, 3);
  global.message = "KALI ACCEPTS YOUR SACRIFICE!";
  if (global.favor <= -8) {
    global.message = "KALI DEVOURS YOUR SACRIFICE!";
  } else if (global.favor < 0) {
    if (status == 98) global.favor += favor*1.5; else global.favor += favor;
    if (favor > 0) favor = 0;
  } else {
    if (status == 98) global.favor += favor*1.5; else global.favor += favor;
  }

       if (myAltar.gift1 != "" and global.kaliGift == 0) scrGetFavorMsg(myAltar.gift1);
  else if (myAltar.gift2 != "" and global.kaliGift == 1) scrGetFavorMsg(myAltar.gift2);
  else scrGetFavorMsg("");

  global.messageTimer = 200;
  global.shake = 10;
  instance_destroy();
  */
}


// ////////////////////////////////////////////////////////////////////////// //
final void addBackgroundGfxDetails () {
  // add background details
  //if (global.customLevel || global.parallax) return;
  foreach (; 0..20) {
    // bg = instance_create(16*randRoom(1, 42), 16*randRoom(1, 33), oCaveBG);
         if (global.levelType == 1 && global.randRoom(1, 3) < 3) MakeMapBackTile('bgExtrasLush', 32*global.randRoom(0, 1), 0, 32, 32, 16*global.randRoom(1, 42), 16*global.randRoom(1, 33), 10002);
    else if (global.levelType == 2 && global.randRoom(1, 3) < 3) MakeMapBackTile('bgExtrasIce', 32*global.randRoom(0, 1), 0, 32, 32, 16*global.randRoom(1, 42), 16*global.randRoom(1, 33), 10002);
    else if (global.levelType == 3 && global.randRoom(1, 3) < 3) MakeMapBackTile('bgExtrasTemple', 32*global.randRoom(0, 1), 0, 32, 32, 16*global.randRoom(1, 42), 16*global.randRoom(1, 33), 10002);
    else MakeMapBackTile('bgExtras', 32*global.randRoom(0, 1), 0, 32, 32, 16*global.randRoom(1, 42), 16*global.randRoom(1, 33), 10002);
  }
}


// ////////////////////////////////////////////////////////////////////////// //
private final void fixRealViewStart () {
  int scale = global.scale;
  realViewStart.x = clamp(realViewStart.x, viewMin.x*scale, viewMax.x*scale-viewWidth);
  realViewStart.y = clamp(realViewStart.y, viewMin.y*scale, viewMax.y*scale-viewHeight);
}


private final void fixViewStart () {
  int scale = global.scale;
  viewStart.x = clamp(viewStart.x, viewMin.x*scale, viewMax.x*scale-viewWidth);
  viewStart.y = clamp(viewStart.y, viewMin.y*scale, viewMax.y*scale-viewHeight);
}


final void centerViewAtPlayer () {
  if (viewWidth < 1 || viewHeight < 1 || !player) return;
  centerViewAt(player.xCenter, player.yCenter);
}


final void centerViewAt (int x, int y) {
  if (viewWidth < 1 || viewHeight < 1) return;
  int scale = global.scale;
  x *= scale;
  y *= scale;
  realViewStart.x = clamp(x-viewWidth/2, 0, tilesWidth*16*scale-viewWidth);
  realViewStart.y = clamp(y-viewHeight/2, 0, tilesHeight*16*scale-viewHeight);
  fixRealViewStart();

  viewStart.x = realViewStart.x;
  viewStart.y = clamp(realViewStart.y+(player ? player.viewOffset*scale : 0), 0, tilesHeight*16*scale-viewHeight);
  fixViewStart();
}


const int ViewPortToleranceX = 16*1+8;
const int ViewPortToleranceY = 16*1+8;

final void fixCamera () {
  if (!player) return;
  if (viewWidth < 1 || viewHeight < 1) return;
  int scale = global.scale;
  auto alwaysCenter = global.config.alwaysCenterPlayer;
  // calculate offset from viewport center (in game units), and fix viewport
  // horizontal
  if (!player.cameraBlockX) {
    int x = player.xCenter*scale;
    int cx = realViewStart.x;
    if (alwaysCenter) {
      cx = x-viewWidth/2;
    } else {
      int xofs = x-(cx+viewWidth/2);
           if (xofs < -ViewPortToleranceX*scale) cx += xofs+ViewPortToleranceX*scale;
      else if (xofs > ViewPortToleranceX*scale) cx += xofs-ViewPortToleranceX*scale;
    }
    realViewStart.x = clamp(cx, 0, tilesWidth*16*scale-viewWidth);
  }
  // vertical
  if (!player.cameraBlockY) {
    int y = player.yCenter*scale;
    int cy = realViewStart.y;
    if (alwaysCenter) {
      cy = y-viewHeight/2;
    } else {
      int yofs = y-(cy+viewHeight/2);
           if (yofs < -ViewPortToleranceY*scale) cy += yofs+ViewPortToleranceY*scale;
      else if (yofs > ViewPortToleranceY*scale) cy += yofs-ViewPortToleranceY*scale;
    }
    realViewStart.y = clamp(cy, 0, tilesHeight*16*scale-viewHeight);
  }
  fixRealViewStart();

  viewStart.x = realViewStart.x;
  viewStart.y = clamp(realViewStart.y+(player ? player.viewOffset*scale : 0), 0, tilesHeight*16*scale-viewHeight);
  fixViewStart();
}


// ////////////////////////////////////////////////////////////////////////// //
// x0 and y0 are non-scaled (and will be scaled)
final void drawSpriteAt (name sprName, float frnumf, int x0, int y0, optional bool small) {
  if (!sprName) return;
  auto spr = sprStore[sprName];
  if (!spr || !spr.frames.length) return;
  int scale = global.scale;
  x0 *= scale;
  y0 *= scale;
  int frnum = max(0, trunc(frnumf))%spr.frames.length;
  auto sfr = spr.frames[frnum];
  int sx0 = x0-sfr.xofs*scale;
  int sy0 = y0-sfr.yofs*scale;
  if (small && scale > 1) {
    sfr.tex.blitExt(sx0, sy0, round(sx0+sfr.tex.width*(scale/2.0)), round(sy0+sfr.tex.height*(scale/2.0)), 0, 0);
  } else {
    sfr.tex.blitAt(sx0, sy0, scale);
  }
}


// x0 and y0 are non-scaled (and will be scaled)
final void drawTextAt (int x0, int y0, string text) {
  if (!text) return;
  int scale = global.scale;
  x0 *= scale;
  y0 *= scale;
  sprStore.renderText(x0, y0, text, scale);
}


void renderCompass (float currFrameDelta) {
  if (!global.hasCompass) return;

  /*
  if (isRoom("rOlmec")) {
    global.exitX = 648;
    global.exitY = 552;
  } else if (isRoom("rOlmec2")) {
    global.exitX = 648;
    global.exitY = 424;
  }
  */

  bool hasMessage = osdHasMessage();
  foreach (MapTile et; allExits) {
    // original compass
    int exitX = et.ix, exitY = et.iy;
    int vx0 = viewStart.x/global.scale, vy0 = viewStart.y/global.scale;
    int vx1 = (viewStart.x+viewWidth)/global.scale;
    int vy1 = (viewStart.y+viewHeight)/global.scale;
    if (exitY > vy1-16) {
      if (exitX < vx0) {
        drawSpriteAt(hasMessage ? 'sCompassSmallLL' : 'sCompassLL', 0, 0, 224);
      } else if (exitX > vx1-16) {
        drawSpriteAt(hasMessage ? 'sCompassSmallLR' : 'sCompassLR', 0, 304, 224);
      } else {
        drawSpriteAt(hasMessage ? 'sCompassSmallDown' : 'sCompassDown', 0, exitX-vx0, 224);
      }
    } else if (exitX < vx0) {
      drawSpriteAt(hasMessage ? 'sCompassSmallLeft' : 'sCompassLeft', 0, 0, exitY-vy0);
    } else if (exitX > vx1-16) {
      drawSpriteAt(hasMessage ? 'sCompassSmallRight' : 'sCompassRight', 0, 304, exitY-vy0);
    }
  }
}


final bool totalsNameCmpCB (ref GameStats::TotalItem a, ref GameStats::TotalItem b) {
  auto sa = string(a.objName);
  auto sb = string(b.objName);
  return (sa < sb);
}

void renderTransitionInfo (float currFrameDelta) {
  //FIXME!
  /*
  GameStats.sortTotalsList(stats.kills, &totalsNameCmpCB);

  int maxLen = 0;
  foreach (int idx, ref auto k; stats.kills) {
    string s = string(k);
    maxLen = max(maxLen, s.length);
  }
  maxLen *= 8;

  sprStore.loadFont('sFontSmall');
  Video.color = 0xff_ff_00;
  foreach (int idx, ref auto k; stats.kills) {
    int deaths = 0;
    foreach (int xidx, ref auto d; stats.totalKills) {
      if (d.objName == k) { deaths = d.count; break; }
    }
    //drawTextAt(16, 4+idx*8, va("%s: %d (%d)", string(k.objName).toUpperCase, k.count, deaths));
    drawTextAt(16, 4+idx*8, string(k).toUpperCase);
    drawTextAt(16+maxLen, 4+idx*8, va(": %d (%d)", k.count, deaths));
  }
  */
}


void renderGhostTimer (float currFrameDelta) {
  if (ghostTimeLeft <= 0) return;
  //ghostTimeLeft /= 30; // frames -> seconds

  int hgt = Video.screenHeight-64;
  if (hgt < 1) return;
  int rhgt = round(float(hgt)*(float(ghostTimeLeft)/30.0)/1000.0);
  //writeln("hgt=", hgt, "; rhgt=", rhgt, "; gtl=", ghostTimeLeft/30);
  if (rhgt > 0) {
    auto oclr = Video.color;
    Video.color = 0xcf_ff_7f_00;
    Video.fillRect(Video.screenWidth-20, 32, 16, hgt-rhgt);
    Video.color = 0x7f_ff_7f_00;
    Video.fillRect(Video.screenWidth-20, 32+(hgt-rhgt), 16, rhgt);
    Video.color = oclr;
  }
}


void renderHUD (float currFrameDelta) {
  if (levelKind == LevelKind.Transition) { renderTransitionInfo(currFrameDelta); return; }

  int lifeX = 4; // 8
  int bombX = 56;
  int ropeX = 104;
  int ammoX = 152;
  int moneyX = 200;
  int hhup;
  bool scumSmallHud = global.config.scumSmallHud;
  if (!global.config.optSGAmmo) moneyX = ammoX;

  if (scumSmallHud) {
    sprStore.loadFont('sFontSmall');
    hhup = 6;
  } else {
    sprStore.loadFont('sFont');
    hhup = 0;
  }
  Video.color = 0xff_ff_ff;

  // hearts
  if (scumSmallHud) {
    if (global.plife == 1) {
      drawSpriteAt('sHeartSmallBlink', global.heartBlink, lifeX+2, 4-hhup);
      global.heartBlink += 0.1;
      if (global.heartBlink > 3) global.heartBlink = 0;
    } else {
      drawSpriteAt('sHeartSmall', -1, lifeX+2, 4-hhup);
      global.heartBlink = 0;
    }
  } else {
    if (global.plife == 1) {
      drawSpriteAt('sHeartBlink', global.heartBlink, lifeX, 8-hhup);
      global.heartBlink += 0.1;
      if (global.heartBlink > 3) global.heartBlink = 0;
    } else {
      drawSpriteAt('sHeart', -1, lifeX, 8-hhup);
      global.heartBlink = 0;
    }
  }

  int life = clamp(global.plife, 0, 99);
  //if (!scumHud && life > 99) life = 99;
  drawTextAt(lifeX+16, 8-hhup, va("%d", life));

  // bombs
  if (global.hasStickyBombs && global.stickyBombsActive) {
    if (scumSmallHud) drawSpriteAt('sStickyBombIconSmall', -1, bombX+2, 4-hhup); else drawSpriteAt('sStickyBombIcon', -1, bombX, 8-hhup);
  } else {
    if (scumSmallHud) drawSpriteAt('sBombIconSmall', -1, bombX+2, 4-hhup); else drawSpriteAt('sBombIcon', -1, bombX, 8-hhup);
  }
  int n = global.bombs;
  if (n < 0) n = 0; else if (!scumSmallHud && n > 99) n = 99;
  drawTextAt(bombX+16, 8-hhup, va("%d", n));

  // ropes
  if (scumSmallHud) drawSpriteAt('sRopeIconSmall', -1, ropeX+2, 4-hhup); else drawSpriteAt('sRopeIcon', -1, ropeX, 8-hhup);
  n = global.rope;
  if (n < 0) n = 0; else if (!scumSmallHud && n > 99) n = 99;
  drawTextAt(ropeX+16, 8-hhup, va("%d", n));

  // shotgun shells
  if (global.config.optSGAmmo) {
    if (scumSmallHud) drawSpriteAt('sShellsIcon', -1, ammoX+6, 8-hhup); else drawSpriteAt('sShellsIcon', -1, ammoX+7, 12-hhup);
    n = global.sgammo;
    if (n < 0) n = 0; else if (!scumSmallHud && n > 99) n = 99;
    drawTextAt(ammoX+16, 8-hhup, va("%d", n));
  }

  // money
  if (scumSmallHud) drawSpriteAt('sDollarSignSmall', -1, moneyX+2, 3-hhup); else drawSpriteAt('sDollarSign', -1, moneyX, 8-hhup);
  drawTextAt(moneyX+16, 8-hhup, va("%d", stats.money-xmoney));

  int ity = (scumSmallHud ? 18-hhup : 24-hhup);

  n = 8; //28;
  if (global.hasUdjatEye) {
    if (global.udjatBlink) drawSpriteAt('sUdjatEyeIcon2', -1, n, ity); else drawSpriteAt('sUdjatEyeIcon', -1, n, ity);
    n += 20;
  }
  if (global.hasAnkh) { drawSpriteAt('sAnkhIcon', -1, n, ity); n += 20; }
  if (global.hasCrown) { drawSpriteAt('sCrownIcon', -1, n, ity); n += 20; }
  if (global.hasKapala) {
         if (global.bloodLevel == 0) drawSpriteAt('sKapalaIcon', 0, n, ity);
    else if (global.bloodLevel <= 2) drawSpriteAt('sKapalaIcon', 1, n, ity);
    else if (global.bloodLevel <= 4) drawSpriteAt('sKapalaIcon', 2, n, ity);
    else if (global.bloodLevel <= 6) drawSpriteAt('sKapalaIcon', 3, n, ity);
    else if (global.bloodLevel <= 8) drawSpriteAt('sKapalaIcon', 4, n, ity);
    n += 20;
  }
  if (global.hasSpectacles) { drawSpriteAt('sSpectaclesIcon', -1, n, ity); n += 20; }
  if (global.hasGloves) { drawSpriteAt('sGlovesIcon', -1, n, ity); n += 20; }
  if (global.hasMitt) { drawSpriteAt('sMittIcon', -1, n, ity); n += 20; }
  if (global.hasSpringShoes) { drawSpriteAt('sSpringShoesIcon', -1, n, ity); n += 20; }
  if (global.hasJordans) { drawSpriteAt('sJordansIcon', -1, n, ity); n += 20; }
  if (global.hasSpikeShoes) { drawSpriteAt('sSpikeShoesIcon', -1, n, ity); n += 20; }
  if (global.hasCape) { drawSpriteAt('sCapeIcon', -1, n, ity); n += 20; }
  if (global.hasJetpack) { drawSpriteAt('sJetpackIcon', -1, n, ity); n += 20; }
  if (global.hasStickyBombs) { drawSpriteAt('sPasteIcon', -1, n, ity); n += 20; }
  if (global.hasCompass) { drawSpriteAt('sCompassIcon', -1, n, ity); n += 20; }
  if (global.hasParachute) { drawSpriteAt('sParachuteIcon', -1, n, ity); n += 20; }

  if (player.holdItem && player.holdItem.objName == 'Bow' && global.arrows > 0) {
    int m = 1;
    float malpha = 1;
    while (m <= global.arrows && m <= 20 && malpha > 0) {
      Video.color = trunc(malpha*255)<<24|0xff_ff_ff;
      drawSpriteAt('sArrowIcon', -1, n, ity);
      n += 4;
      if (m > 10) malpha -= 0.1; //and global.arrows > 20 malpha -= 0.1
      m += 1;
    }
    Video.color = 0xff_ff_ff;
  }

  if (xmoney > 0) {
    sprStore.loadFont('sFontSmall');
    Video.color = 0xff_ff_00;
    if (scumSmallHud) drawTextAt(moneyX+8, 8+8-hhup, va("+%d", xmoney));
    else drawTextAt(moneyX, 8+16-hhup, va("+%d", xmoney));
  }

  if (global.config.ghostShowTime) renderGhostTimer(currFrameDelta);
}


// ////////////////////////////////////////////////////////////////////////// //
private transient array!MapEntity renderVisibleCids;
private transient array!MapTile renderMidTiles, renderFrontTiles; // normal, with fg

final bool renderSortByDepth (MapEntity oa, MapEntity ob) {
  //MapObject oa = MapObject(a);
  //MapObject ob = MapObject(b);
  auto da = oa.depth, db = ob.depth;
  if (da == db) return (oa.objId < ob.objId);
  return (da < db);
}


const int RenderEdgePix = 32;

void renderWithOfs (int xofs, int yofs, float currFrameDelta) {
  int scale = global.scale;
  int tsz = 16*scale;

  Video.color = 0xff_ff_ff;

  // render cave background
  if (levBGImg) {
    int bgw = levBGImg.tex.width*scale;
    int bgh = levBGImg.tex.height*scale;
    int bgTW = (tilesWidth*tsz+bgw-1)/bgw;
    int bgTH = (tilesHeight*tsz+bgh-1)/bgh;
    int bgX0 = max(0, xofs/bgw);
    int bgY0 = max(0, yofs/bgh);
    int bgX1 = min(bgTW, (xofs+viewWidth+bgw-1)/bgw);
    int bgY1 = min(bgTH, (yofs+viewHeight+bgh-1)/bgh);
    foreach (int ty; bgY0..bgY1) {
      foreach (int tx; bgX0..bgX1) {
        int x0 = tx*bgw-xofs;
        int y0 = ty*bgh-yofs;
        levBGImg.tex.blitAt(x0, y0, scale);
      }
    }
  }

  // render background tiles
  for (MapBackTile bt = backtiles; bt; bt = bt.next) {
    bt.drawWithOfs(xofs, yofs, scale, currFrameDelta);
  }

  // render stationary tiles
  int tileX0 = max(0, xofs/tsz);
  int tileY0 = max(0, yofs/tsz);
  int tileX1 = min(tilesWidth, (xofs+viewWidth+tsz-1)/tsz);
  int tileY1 = min(tilesHeight, (yofs+viewHeight+tsz-1)/tsz);

  // render backs; collect tile arrays
  renderMidTiles.length -= renderMidTiles.length; // don't realloc
  renderFrontTiles.length -= renderFrontTiles.length; // don't realloc

  foreach (int ty; tileY0..tileY1) {
    foreach (int tx; tileX0..tileX1) {
      auto tile = getTileAt(tx, ty);
      if (tile && tile.visible && tile.isInstanceAlive) {
        renderMidTiles[$] = tile;
        if (tile.bgfront) renderFrontTiles[$] = tile;
        if (tile.bgback) tile.drawWithOfsBack(xofs, yofs, scale, currFrameDelta);
      }
    }
  }

  // render "mid" (i.e. normal) tiles
  foreach (MapTile tile; renderMidTiles) tile.drawWithOfs(xofs, yofs, scale, currFrameDelta);

  // render moveable tiles
  /*
  foreach (MapTile mt; miscTileGrid.allObjects()) {
    if (mt.visible && mt.isInstanceAlive) {
      Video.color = (mt.moveable ? 0xff_7f_00 : 0xff_ff_ff);
      mt.drawWithOfs(xofs, yofs, scale, currFrameDelta);
    }
  }
  */
  renderVisibleCids.length -= renderVisibleCids.length;

  foreach (MapTile mt; miscTileGrid.inRectPix(xofs/scale-RenderEdgePix, yofs/scale-RenderEdgePix, (viewWidth+scale-1)/scale+RenderEdgePix*2, (viewHeight+scale-1)/scale+RenderEdgePix*2, tag:miscTileGrid.nextTag(), precise:false)) {
    if (!mt.visible || !mt.isInstanceAlive) continue;
    //Video.color = (mt.moveable ? 0xff_7f_00 : 0xff_ff_ff);
    //!mt.drawWithOfs(xofs, yofs, scale, currFrameDelta);
    renderVisibleCids[$] = mt;
  }
  //Video.color = 0xff_ff_ff;

  // render objects (and player)
  if (player && player.visible) renderVisibleCids[$] = player; // include player in render list
  auto ogrid = objGrid;
  foreach (MapObject o; ogrid.inRectPix(xofs/scale-RenderEdgePix, yofs/scale-RenderEdgePix, (viewWidth+scale-1)/scale+RenderEdgePix*2, (viewHeight+scale-1)/scale+RenderEdgePix*2, tag:ogrid.nextTag(), precise:false)) {
    if (o.visible && o.isInstanceAlive) renderVisibleCids[$] = o;
  }
  EntityGrid.sortEntList(renderVisibleCids, &renderSortByDepth);

  auto depth4Start = 0;
  foreach (auto xidx, MapEntity o; renderVisibleCids) {
    if (o.depth >= 4) {
      depth4Start = xidx;
      break;
    }
  }

  foreach (auto idx; depth4Start..renderVisibleCids.length; reverse) {
    MapEntity o = renderVisibleCids[idx];
    //if (idx && renderSortByDepth(o, renderVisibleCids[idx-1])) writeln("VIOLATION!");
    o.drawWithOfs(xofs, yofs, scale, currFrameDelta);
  }

  // render player
  //if (player && player.visible) player.drawWithOfs(xofs, yofs, scale, currFrameDelta);

  // render front tile parts (depth 3.5)
  foreach (MapTile tile; renderFrontTiles) tile.drawWithOfsFront(xofs, yofs, scale, currFrameDelta);

  // render items with depth 3 and less
  foreach (auto idx; 0..depth4Start; reverse) {
    MapEntity o = renderVisibleCids[idx];
    o.drawWithOfs(xofs, yofs, scale, currFrameDelta);
  }

  renderVisibleCids.length -= renderVisibleCids.length;

  // render player post-effects, so cape or jetpack will be correctly rendered on level exit, for example
  player.lastDrawWithOfs(xofs, yofs, scale, currFrameDelta);

  if (global.config.drawHUD) renderHUD(currFrameDelta);
  renderCompass(currFrameDelta);

  float osdTimeLeft, osdTimeStart;
  string msg = osdGetMessage(out osdTimeLeft, out osdTimeStart);
  if (msg) {
    auto ct = GetTickCount();
    int msgScale = 3;
    sprStore.loadFont('sFontSmall');
    auto msgHeight = sprStore.getMultilineTextHeight(msg, msgScale);
    int x = Video.screenWidth/2;
    int y = Video.screenHeight-64-msgHeight;
    auto oldColor = Video.color;
    Video.color = 0xff_ff_00;
    if (osdTimeLeft < 0.5) {
      int alpha = 255-clamp(int(510*osdTimeLeft), 0, 255);
      Video.color = Video.color|(alpha<<24);
    } else if (ct-osdTimeStart < 0.5) {
      osdTimeStart = ct-osdTimeStart;
      int alpha = 255-clamp(int(510*osdTimeStart), 0, 255);
      Video.color = Video.color|(alpha<<24);
    }
    sprStore.renderMultilineTextCentered(x, y, msg, msgScale);
    Video.color = oldColor;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final class!MapObject findGameObjectClassByName (name aname) {
  if (!aname) return none; // just in case
  auto co = FindClassByGameObjName(aname);
  if (!co) {
    writeln("***UNKNOWN GAME OBJECT: '", aname, "'");
    return none;
  }
  co = GetClassReplacement(co);
  if (!co) FatalError("findGameObjectClassByName: WTF?!");
  if (!class!MapObject(co)) FatalError("findGameTileClassByName: object '%n' is not a map object, it is a `%n`", aname, GetClassName(co));
  return class!MapObject(co);
}


final class!MapTile findGameTileClassByName (name aname) {
  if (!aname) return none; // just in case
  auto co = FindClassByGameObjName(aname);
  if (!co) return MapTile; // unknown names will be routed directly to tile object
  co = GetClassReplacement(co);
  if (!co) FatalError("findGameTileClassByName: WTF?!");
  if (!class!MapTile(co)) FatalError("findGameTileClassByName: object '%n' is not a tile, it is a `%n`", aname, GetClassName(co));
  return class!MapTile(co);
}


final MapObject findAnyObjectOfType (name aname) {
  if (!aname) return none;
  auto cls = FindClassByGameObjName(aname);
  if (!cls) return none;
  for (auto cid = objGrid.getFirstObject(); cid; cid = objGrid.getNextObject(cid)) {
    MapObject obj = objGrid.getObject(MapObject, cid);
    if (!obj || obj.spectral || !obj.isInstanceAlive) continue;
    if (obj isa cls) return obj;
  }
  return none;
}


// ////////////////////////////////////////////////////////////////////////// //
final MapTile CreateMapTile (int xpos, int ypos, name aname) {
  if (!aname) FatalError("cannot create typeless tile");
  //MapTile tile = SpawnObject(aname == 'oRope' ? MapTileRope : MapTile);
  auto tclass = findGameTileClassByName(aname);
  if (!tclass) return none;
  MapTile tile = SpawnObject(tclass);
  tile.global = global;
  tile.level = self;
  tile.objName = aname;
  tile.objType = aname; // just in case
  tile.fltx = xpos;
  tile.flty = ypos;
  if (!tile.initialize()) FatalError("cannot create tile '%n'", aname);
  return tile;
}


final bool isRopePlacedAt (int x, int y) {
  int[8] covered;
  foreach (ref auto v; covered) v = false;
  foreach (MapTile t; miscTileGrid.inRectPix(x, y-8, 1, 17, precise:false)) {
    if (!cbIsRopeTile(t)) continue;
    if (t.ix != x) continue;
    if (t.iy == y) return true;
    foreach (int ty; t.iy..t.iy+8) {
      int d = ty-y;
      if (d >= 0 && d < covered.length) covered[d] = true;
    }
  }
  // check if the whole rope height is completely covered with ropes
  foreach (auto v; covered) if (!v) return false;
  return true;
}


// won't call `onDestroy()`
final void RemoveMapTile (int tileX, int tileY) {
  if (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight) {
    if (tiles[tileX, tileY]) checkWater = true;
    delete tiles[tileX, tileY];
    tiles[tileX, tileY] = none;
  }
}


final MapTile MakeMapTile (int mapx, int mapy, name aname/*, optional name sprname*/) {
  if (mapx < 0 || mapx >= tilesWidth || mapy < 0 || mapy >= tilesHeight) return none;

  // if we already have rope tile there, there is no reason to add another one
  if (aname == 'oRope') {
    if (isRopePlacedAt(mapx*16, mapy*16)) {
      //writeln("dupe rope (0)!");
      return none;
    }
  }

  auto tile = CreateMapTile(mapx*16, mapy*16, aname);
  if (tile.moveable || tile.toSpecialGrid) {
    // moveable tiles goes to the separate list
    miscTileGrid.insert(tile);
  } else {
    setTileAt(mapx, mapy, tile);
  }

  switch (aname) {
    case 'oEntrance': registerEnter(tile); break;
    case 'oExit': registerExit(tile); break;
  }

  return tile;
}


final void MarkTileAsWet (int tileX, int tileY) {
  auto t = getTileAt(tileX, tileY);
  if (t) t.wet = true;
}


final MapTile MakeMapTileAtPix (int xpix, int ypix, name aname/*, optional name sprname*/) {
  if (xpix%16 == 0 && ypix%16 == 0) return MakeMapTile(xpix/16, ypix/16, aname);
  //if (mapx < 0 || mapx >= TilesWidth || mapy < 0 || mapy >= TilesHeight) return none;

  // if we already have rope tile there, there is no reason to add another one
  if (aname == 'oRope') {
    if (isRopePlacedAt(xpix, ypix)) {
      //writeln("dupe rope (0)!");
      return none;
    }
  }

  auto tile = CreateMapTile(xpix, ypix, aname);
  // non-aligned tiles goes to the special grid
  miscTileGrid.insert(tile);

  switch (aname) {
    case 'oEntrance': registerEnter(tile); break;
    case 'oExit': registerExit(tile); break;
  }

  return tile;
}


final MapTile MakeMapRopeTileAt (int x0, int y0) {
  // if we already have rope tile there, there is no reason to add another one
  if (isRopePlacedAt(x0, y0)) {
    //writeln("dupe rope (1)!");
    return none;
  }

  auto tile = CreateMapTile(x0, y0, 'oRope');
  miscTileGrid.insert(tile);

  return tile;
}


// ////////////////////////////////////////////////////////////////////////// //
final MapBackTile CreateBgTile (name sprName, optional int atx0, optional int aty0, optional int aw, optional int ah) {
  BackTileImage img = bgtileStore[sprName];
  auto res = SpawnObject(MapBackTile);
  res.global = global;
  res.level = self;
  res.bgt = img;
  res.bgtName = sprName;
  if (specified_atx0) res.tx0 = atx0;
  if (specified_aty0) res.ty0 = aty0;
  if (specified_aw) res.w = aw;
  if (specified_ah) res.h = ah;
  if (!res.initialize()) FatalError("cannot create background tile with image '%n'", sprName);
  return res;
}


// ////////////////////////////////////////////////////////////////////////// //
/*
background The background asset from which the new tile will be extracted.
left The x coordinate of the left of the new tile, relative to the background asset's top left corner.
top The y coordinate of the top of the new tile, relative to the background assets top left corner.
width The width of the tile.
height The height of the tile.
x The x position in the room to place the tile.
y The y position in the room to place the tile.
depth The depth at which to place the tile.
*/
final void MakeMapBackTile (name bgname, int left, int top, int width, int height, int x, int y, int depth) {
  if (width < 1 || height < 1 || !bgname) return;
  auto bgt = bgtileStore[bgname];
  if (!bgt) FatalError("cannot load background '%n'", bgname);
  MapBackTile bt = SpawnObject(MapBackTile);
  bt.global = global;
  bt.level = self;
  bt.objName = bgname;
  bt.bgt = bgt;
  bt.bgtName = bgname;
  bt.fltx = x;
  bt.flty = y;
  bt.tx0 = left;
  bt.ty0 = top;
  bt.w = width;
  bt.h = height;
  bt.depth = depth;
  // find a place for it
  if (!backtiles) {
    backtiles = bt;
    return;
  }
  // back tiles with the highest depth should come first
  MapBackTile ct = backtiles, cprev = none;
  while (ct && depth <= ct.depth) { cprev = ct; ct = ct.next; }
  // insert before ct
  if (cprev) {
    bt.next = cprev.next;
    cprev.next = bt;
  } else {
    bt.next = backtiles;
    backtiles = bt;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final MapObject SpawnMapObjectWithClass (class!MapObject oclass) {
  if (!oclass) return none;

  MapObject obj = SpawnObject(oclass);
  if (!obj) FatalError("cannot create map object '%n'", GetClassName(oclass));

  //if (aname == 'oShells' || aname == 'oShellSingle' || aname == 'oRopePile') writeln("*** CREATED '", aname, "'");

  obj.global = global;
  obj.level = self;

  return obj;
}


final MapObject SpawnMapObject (name aname) {
  if (!aname) return none;
  return SpawnMapObjectWithClass(findGameObjectClassByName(aname));
}


final MapObject PutSpawnedMapObject (int x, int y, MapObject obj) {
  if (!obj /*|| obj.global || obj.level*/) return none; // oops

  obj.fltx = x;
  obj.flty = y;
  if (!obj.initialize()) { delete obj; return none; } // not fatal

  insertObject(obj);

  return obj;
}


final MapObject MakeMapObject (int x, int y, name aname) {
  MapObject obj = SpawnMapObject(aname);
  obj = PutSpawnedMapObject(x, y, obj);
  return obj;
}


// ////////////////////////////////////////////////////////////////////////// //
#include "roomTitle.vc"
#include "roomTrans1.vc"
#include "roomTrans2.vc"
#include "roomTrans3.vc"
#include "roomTrans4.vc"
#include "roomOlmec.vc"


// ////////////////////////////////////////////////////////////////////////// //
#include "packages/Generator/loadRoomGens.vc"
#include "packages/Generator/loadEntityGens.vc"