better check for dead players in kapala/treasure code

[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;

//#define EXPERIMENTAL_RENDER_CACHE

const float FrameTime = 1.0f/30.0f;

const int dumpGridStats = true;

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;
transient name lastMusicName;
//RoomGen[LevelGen::LevelWidth, LevelGen::LevelHeight] rooms; // moved to levelgen

transient float accumTime;
transient bool gamePaused = false;
transient bool checkWater;
transient int liquidTileCount; // cached
transient int damselSaved;

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

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

MapBackTile backtiles;
bool blockWaterChecking;

int inWinCutscene;

LevelGen::RType[MaxTilesWidth, MaxTilesHeight] roomType;

enum LevelKind {
  Normal,
  Transition,
  Title,
  Tutorial,
  Scores,
  Stars,
  Sun,
  Moon,
  //Final,
}
LevelKind levelKind = LevelKind.Normal;

array!MapTile allEnters;
array!MapTile allExits;


int startRoomX, startRoomY;
int endRoomX, endRoomY;

PlayerPawn player;
transient bool playerExited;
transient MapEntity playerExitDoor;
transient bool disablePlayerThink = false;
transient int maxPlayingTime; // in seconds
int levelStartTime;
int levelEndTime;

int ghostTimeLeft;
int musicFadeTimer;
bool ghostSpawned; // to speed up some checks
bool resetBMCOG = false;
int udjatAlarm;


// FPS, i.e. incremented by 30 in one second
int time; // in frames
int lastUsedObjectId;
transient int lastRenderTime = -1;

MapEntity deadItemsHead;

// 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;

// for Olmec level cinematics
IVec2D cameraSlideToDest;
IVec2D cameraSlideToCurr;
IVec2D cameraSlideToSpeed; // !0: slide
int cameraSlideToPlayer;
// `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`

transient int framesProcessedFromLastClear;

transient int BuildYear;
transient int BuildMonth;
transient int BuildDay;
transient int BuildHour;
transient int BuildMin;
transient string BuildDateString;


final string getBuildDateString () {
  if (!BuildYear) return BuildDateString;
  if (BuildDateString) return BuildDateString;
  BuildDateString = va("%d-%s-%s %s:%s", BuildYear, val2dig(BuildMonth), val2dig(BuildDay), val2dig(BuildHour), val2dig(BuildMin));
  return BuildDateString;
}


final void cameraSlideToPoint (int dx, int dy, int speedx, int speedy) {
  cameraSlideToPlayer = 0;
  cameraSlideToDest.x = dx;
  cameraSlideToDest.y = dy;
  cameraSlideToSpeed.x = abs(speedx);
  cameraSlideToSpeed.y = abs(speedy);
  cameraSlideToCurr.x = cameraCurrX;
  cameraSlideToCurr.y = cameraCurrY;
}


final void cameraReturnToPlayer () {
  if (!cameraSlideToPlayer && (cameraSlideToSpeed.x|cameraSlideToSpeed.y)) {
    cameraSlideToCurr.x = cameraCurrX;
    cameraSlideToCurr.y = cameraCurrY;
    if (cameraSlideToSpeed.x && abs(cameraSlideToSpeed.x) < 8) cameraSlideToSpeed.x = 8;
    if (cameraSlideToSpeed.y && abs(cameraSlideToSpeed.y) < 8) cameraSlideToSpeed.y = 8;
    cameraSlideToPlayer = 1;
  }
}


// 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 () onCameraTeleported;

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); }
final bool isTitleRoom () { return (levelKind == LevelKind.Title); }
final bool isTutorialRoom () { return (levelKind == LevelKind.Tutorial); }

bool isHUDEnabled () {
  if (inWinCutscene) return false;
  if (lg.finalBossLevel) return true;
  if (isNormalLevel()) return true;
  // allow HUD in challenge chambers
  return false;
}


// ////////////////////////////////////////////////////////////////////////// //
// stats
void addDeath (name aname) { if (isNormalLevel()) stats.addDeath(aname); }

int starsKills;
int sunScore;
int moonScore;
int moonTimer;

void addKill (name aname, optional bool telefrag) {
       if (isNormalLevel()) stats.addKill(aname, telefrag!optional);
  else if (aname == 'Shopkeeper' && levelKind == LevelKind.Stars) { ++stats.starsKills; ++starsKills; }
}

void addCollect (name aname, optional int amount) { if (isNormalLevel()) stats.addCollect(aname, amount!optional); }

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


// ////////////////////////////////////////////////////////////////////////// //
static final string val2dig (int n) {
  return (n < 10 ? va("0%d", n) : va("%d", n));
}


static final string time2str (int time) {
  int secs = time%60; time /= 60;
  int mins = time%60; time /= 60;
  int hours = time%24; time /= 24;
  int days = time;
  if (days) return va("%d DAYS, %d:%s:%s", days, hours, val2dig(mins), val2dig(secs));
  if (hours) return va("%d:%s:%s", hours, val2dig(mins), val2dig(secs));
  return va("%s:%s", val2dig(mins), val2dig(secs));
}


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


// ////////////////////////////////////////////////////////////////////////// //
protected void resetGameInternal () {
  if (player) player.removeBallAndChain();
  resetBMCOG = false;
  inWinCutscene = 0;
  shakeLeft = 0;
  udjatAlarm = 0;
  starsKills = 0;
  sunScore = 0;
  moonScore = 0;
  moonTimer = 0;
  damselSaved = 0;
  xmoney = 0;
  collectCounter = 0;
  levelMoneyStart = 0;
  if (player) {
    player.removeBallAndChain();
    auto hi = player.holdItem;
    player.holdItem = none;
    if (hi) hi.instanceRemove();
    hi = player.pickedItem;
    player.pickedItem = none;
    if (hi) hi.instanceRemove();
  }
  time = 0;
  lastRenderTime = -1;
  levelStartTime = 0;
  levelEndTime = 0;
  global.resetGame();
  stats.clearGameTotals();
}


// this won't generate a level yet
void restartGame () {
  resetGameInternal();
  if (global.startMoney > 0) stats.setMoneyCheat();
  stats.setMoney(global.startMoney);
  levelKind = LevelKind.Normal;
}


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


void restartTitle () {
  resetGameInternal();
  stats.setMoney(0);
  createSpecialLevel(LevelKind.Title, &createTitleRoom, 'musTitle');
  global.plife = 9999;
  global.bombs = 0;
  global.rope = 0;
  global.arrows = 0;
  global.sgammo = 0;
}


void restartTutorial () {
  resetGameInternal();
  stats.setMoney(0);
  createSpecialLevel(LevelKind.Tutorial, &createTutorialRoom, 'musCave');
  global.plife = 4;
  global.bombs = 0;
  global.rope = 4;
  global.arrows = 0;
  global.sgammo = 0;
}


void restartScores () {
  resetGameInternal();
  stats.setMoney(0);
  createSpecialLevel(LevelKind.Scores, &createScoresRoom, 'musTitle');
  global.plife = 4;
  global.bombs = 0;
  global.rope = 0;
  global.arrows = 0;
  global.sgammo = 0;
}


void restartStarsRoom () {
  resetGameInternal();
  stats.setMoney(0);
  createSpecialLevel(LevelKind.Stars, &createStarsRoom, '');
  global.plife = 8;
  global.bombs = 0;
  global.rope = 0;
  global.arrows = 0;
  global.sgammo = 0;
}


void restartSunRoom () {
  resetGameInternal();
  stats.setMoney(0);
  createSpecialLevel(LevelKind.Sun, &createSunRoom, '');
  global.plife = 8;
  global.bombs = 0;
  global.rope = 0;
  global.arrows = 0;
  global.sgammo = 0;
}


void restartMoonRoom () {
  resetGameInternal();
  stats.setMoney(0);
  createSpecialLevel(LevelKind.Moon, &createMoonRoom, '');
  global.plife = 8;
  global.bombs = 0;
  global.rope = 0;
  global.arrows = 100;
  global.sgammo = 0;
}


// ////////////////////////////////////////////////////////////////////////// //
// 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 == 1) 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.clear();
}


final void osdMessage (string msg, optional float timeout, optional bool urgent) {
  if (!msg) return;
  msg = global.expandString(msg);
  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;

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


// stores should be set
void onLoaded () {
  checkWater = true;
  liquidTileCount = 0;
  levBGImg = bgtileStore[levBGImgName];
  foreach (MapEntity o; objGrid.allObjects()) {
    o.onLoaded();
    auto t = MapTile(o);
    if (t && (t.lava || t.water)) ++liquidTileCount;
  }
  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();
  }
  if (lg && lg.musicName) global.playMusic(lg.musicName); else global.stopMusic();
}


// ////////////////////////////////////////////////////////////////////////// //
void pickedSpectacles () {
  foreach (MapTile t; objGrid.allObjectsSafe(MapTile)) t.onGotSpectacles();
}


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


void onLevelExited () {
  if (playerExitDoor isa TitleTileXTitle) {
    playerExitDoor = none;
    restartTitle();
    return;
  }
  // title
  if (isTitleRoom() || levelKind == LevelKind.Scores) {
    if (playerExitDoor) processTitleExit(playerExitDoor);
    playerExitDoor = none;
    return;
  }
  if (isTutorialRoom()) {
    playerExitDoor = none;
    restartGame();
    global.currLevel = 1;
    generateNormalLevel();
    return;
  }
  // challenges
  if (levelKind == LevelKind.Stars || levelKind == LevelKind.Sun || levelKind == LevelKind.Moon) {
    playerExitDoor = none;
    levelEndTime = time;
    if (onLevelExitedCB) onLevelExitedCB();
    restartTitle();
    return;
  }
  // normal level
  if (isNormalLevel()) {
    stats.maxLevelComplete = max(stats.maxLevelComplete, global.currLevel);
    levelEndTime = time;
    if (playerExitDoor) {
      if (playerExitDoor.objType == 'oXGold') {
        writeln("exiting to City Of Gold");
        global.cityOfGold = true;
        //!global.currLevel += 1;
      } else if (playerExitDoor.objType == 'oXMarket') {
        writeln("exiting to Black Market");
        global.genBlackMarket = true;
        //!global.currLevel += 1;
      }
    }
  }
  if (onLevelExitedCB) onLevelExitedCB();
  //
  playerExitDoor = none;
  if (levelKind == LevelKind.Transition) {
    if (global.thiefLevel > 0) global.thiefLevel -= 1;
    if (global.alienCraft) ++global.alienCraft;
    if (global.yetiLair) ++global.yetiLair;
    if (global.lake) ++global.lake;
    if (global.cityOfGold) ++global.cityOfGold;
    //orig dbg:if (global.currLevel == 1) global.currLevel += firstLevelSkip; else global.currLevel += levelSkip;
    /+
    if (!global.blackMarket && !global.cityOfGold /*&& !global.yetiLair*/) {
      global.currLevel += 1;
    }
    +/
    ++global.currLevel;
    generateLevel();
  } else {
    // < 20 seconds per level: looks like a speedrun
    global.noDarkLevel = (levelEndTime > levelStartTime && levelEndTime-levelStartTime < 20*30);
    if (lg.finalBossLevel) {
      winTime = time;
      ++stats.gamesWon;
      // add money for big idol
      player.addScore(50000);
      stats.gameOver();
      startWinCutscene();
    } else {
      generateTransitionLevel();
    }
  }
  //centerViewAtPlayer();
}


void onOlmecDead (MapObject o) {
  writeln("*** OLMEC IS DEAD!");
  foreach (MapTile t; allExits) {
    if (t.exit) {
      t.openExit();
      auto st = checkTileAtPoint(t.ix+8, t.iy+16);
      if (!st) {
        st = MakeMapTile(t.ix/16, t.iy/16+1, 'oTemple');
        st.ore = 0;
      }
      st.invincible = true;
    }
  }
}


void generateLevelMessages () {
  writeln("LEVEL NUMBER: ", global.currLevel);
  if (global.darkLevel) {
    if (global.hasCrown) {
       osdMessage("THE HEDJET SHINES BRIGHTLY.");
       global.darkLevel = false;
    } else if (global.config.scumDarkness < 2) {
      osdMessage("I CAN'T SEE A THING!\nI'D BETTER USE THESE FLARES!");
    }
  }

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

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

  if (global.snakePit) osdMessage("I HEAR SNAKES... I HATE SNAKES!");
  if (global.yetiLair == 1) osdMessage("IT SMELLS LIKE WET FUR IN HERE!");
  if (global.alienCraft == 1) osdMessage("THERE'S A PSYCHIC PRESENCE HERE!");
  if (global.cityOfGold == 1) {
    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));
}


void createSpecialLevel (LevelKind kind, scope void delegate () creator, name amusic) {
  global.darkLevel = false;
  udjatAlarm = 0;
  xmoney = 0;
  collectCounter = 0;
  global.resetStartingItems();

  global.setMusicPitch(1.0);
  levelKind = kind;

  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearWholeLevel();

  creator();

  setMenuTilesOnTop();

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

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

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

  if (dumpGridStats) objGrid.dumpStats();

  playerExited = false; // just in case
  playerExitDoor = none;

  osdClear();

  setupGhostTime();
  lg.musicName = amusic;
  if (amusic) global.playMusic(lg.musicName); else global.stopMusic();
}


void createTitleLevel () {
  createSpecialLevel(LevelKind.Title, &createTitleRoom, 'musTitle');
}


void createTutorialLevel () {
  createSpecialLevel(LevelKind.Tutorial, &createTutorialRoom, 'musCave');
  global.plife = 4;
  global.bombs = 0;
  global.rope = 4;
  global.arrows = 0;
  global.sgammo = 0;
}


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

  global.setMusicPitch(1.0);
  switch (global.config.transitionMusicMode) {
    case GameConfig::MusicMode.Silent: global.stopMusic(); break;
    case GameConfig::MusicMode.Restart: global.restartMusic(); break;
    case GameConfig::MusicMode.DontTouch: break;
  }

  levelKind = LevelKind.Transition;

  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearWholeLevel();

       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(); //???

  setMenuTilesOnTop();

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

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

  if (damselSaved > 0) {
    // this is special "damsel ready to kiss you" object, not a heart
    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) objGrid.dumpStats();

  playerExited = false; // just in case
  playerExitDoor = none;

  osdClear();

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


void generateLevel () {
  levelStartTime = time;
  levelEndTime = time;

  udjatAlarm = 0;
  if (resetBMCOG) {
    resetBMCOG = false;
    global.cityOfGold = false;
    global.genBlackMarket = false;
  }

  global.setMusicPitch(1.0);
  stats.clearLevelTotals();

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

  resetRoomBounds();

  lg.generateRooms();
  //writeln("tw:", tilesWidth, "; th:", tilesHeight);

  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearWholeLevel();

  if (lg.finalBossLevel) {
    blockWaterChecking = true;
    createOlmecRoom();
  }

  // if transition cutscene was skipped...
  global.plife += max(0, 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(objGrid.countObjects, " alive objects inserted");
  writeln(countBackTiles, " background tiles inserted");

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

  if (lg.finalBossLevel) {
    blockWaterChecking = true;
  } else {
    blockWaterChecking = false;
  }
  fixLiquidTop();
  cleanDeadTiles();

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

  if (dumpGridStats) objGrid.dumpStats();

  playerExited = false; // just in case
  playerExitDoor = none;

  levelMoneyStart = stats.money;

  osdClear();
  generateLevelMessages();

  xmoney = 0;
  collectCounter = 0;

  if (lastMusicName != lg.musicName) {
    global.playMusic(lg.musicName);
    //writeln("!<", lastMusicName, ">:<", lg.musicName, ">");
  } else {
    //writeln("MM: ", global.config.nextLevelMusicMode);
    switch (global.config.nextLevelMusicMode) {
      case GameConfig::MusicMode.Silent: global.stopMusic(); break; // the thing that should not be
      case GameConfig::MusicMode.Restart: global.restartMusic(); break;
      case GameConfig::MusicMode.DontTouch:
        if (global.config.transitionMusicMode == GameConfig::MusicMode.Silent) {
          global.playMusic(lg.musicName);
        }
        break;
    }
  }
  lastMusicName = lg.musicName;
  //global.playMusic(lg.musicName);

  setupGhostTime();
  if (global.cityOfGold == 1 || global.genBlackMarket) resetBMCOG = true;
}


// ////////////////////////////////////////////////////////////////////////// //
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;
  clearWholeLevel();
  ImmediateDelete = olddel;
  CollectGarbage(true); // destroy delayed objects too
  global.darkLevel = false;
}


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


final void clearWholeLevel () {
  allEnters.clear();
  allExits.clear();

  // don't kill objects the player is holding
  if (player) {
    if (player.pickedItem isa ItemBall) {
      player.pickedItem.instanceRemove();
      player.pickedItem = none;
    }
    if (player.pickedItem && player.pickedItem.grid) {
      player.pickedItem.grid.remove(player.pickedItem.gridId);
      writeln("secured pocket item '", GetClassName(player.pickedItem.Class), "'");
    }
    if (player.holdItem isa ItemBall) {
      player.removeBallAndChain(temp:true);
      if (player.holdItem) player.holdItem.instanceRemove();
      player.holdItem = none;
    }
    if (player.holdItem && player.holdItem.grid) {
      player.holdItem.grid.remove(player.holdItem.gridId);
      writeln("secured held item '", GetClassName(player.holdItem.Class), "'");
    }
    writeln("secured ball; mustBeChained=", player.mustBeChained, "; wasHoldingBall=", player.wasHoldingBall);
  }

  int count = objGrid.countObjects();
  if (dumpGridStats) { if (objGrid.getFirstObjectCID()) objGrid.dumpStats(); }
  objGrid.removeAllObjects(true); // and destroy
  if (count > 0) writeln(count, " objects destroyed");

  lastUsedObjectId = 0;
  accumTime = 0;
  time = 0;
  lastRenderTime = -1;
  liquidTileCount = 0;
  checkWater = false;

  while (backtiles) {
    MapBackTile t = backtiles;
    backtiles = t.next;
    delete t;
  }

  levBGImg = none;
  framesProcessedFromLastClear = 0;
}


final void insertObject (MapEntity o) {
  if (!o) return;
  if (o.grid) FatalError("cannot put object into level twice");
  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();
  if (player.mustBeChained || global.config.scumBallAndChain) {
    writeln("*** spawning ball and chain");
    player.spawnBallAndChain(levelStart:true);
  }
  playerExited = false;
  playerExitDoor = none;
  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;
  playerExitDoor = none;
}


// ////////////////////////////////////////////////////////////////////////// //
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;
  }, castClass:MonsterShopkeeper));

  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(MapObject)) {
    if (!o.spectral && 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(MapObject)) {
    auto tcr = ObjTikiCurse(o);
    if (!tcr) 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;

  // there is no ghost on the first level
  if (inWinCutscene || !isNormalLevel() || lg.finalBossLevel || global.currLevel == 1) {
    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;
  ghostTimeLeft = -1;

  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();
  // udjat eye blinking
  if (global.hasUdjatEye && player) {
    foreach (MapTile t; allExits) {
      if (t isa MapTileBlackMarketDoor) {
        auto dm = int(player.distanceToEntity(t));
        if (dm < 4) dm = 4;
        if (udjatAlarm < 1 || dm < udjatAlarm) udjatAlarm = dm;
      }
    }
  } else {
    global.udjatBlink = false;
    udjatAlarm = 0;
  }
  if (udjatAlarm > 0) {
    if (--udjatAlarm == 0) {
      global.udjatBlink = !global.udjatBlink;
      if (global.hasUdjatEye && player) {
        player.playSound(global.udjatBlink ? 'sndBlink1' : 'sndBlink2');
      }
    }
  }
  switch (levelKind) {
    case LevelKind.Stars: thinkFrameGameStars(); break;
    case LevelKind.Sun: thinkFrameGameSun(); break;
    case LevelKind.Moon: thinkFrameGameMoon(); break;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
private final bool isWaterTileCB (MapTile t) {
  return (t && t.visible && t.water);
}


private final bool isLavaTileCB (MapTile t) {
  return (t && t.visible && t.lava);
}

/*
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.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 isWetTileAtPix (int tx, int ty) {
  return !!checkTileAtPoint(tx, ty, &isWetTile);
}
*/


// ////////////////////////////////////////////////////////////////////////// //
const int GreatLakeStartTileY = 28;

final void fillGreatLake () {
  if (global.lake == 1) {
    foreach (int y; GreatLakeStartTileY..tilesHeight) {
      foreach (int x; 0..tilesWidth) {
        auto t = checkTileAtPoint(x*16, y*16, delegate bool (MapTile t) {
          if (t.spectral || !t.visible || t.invisible || t.moveable) return false;
          return true;
        });
        if (t) {
          //if (!t.water || !t.lava) { t.wet = true; continue; }
        } else {
          t = MakeMapTile(x, y, 'oWaterSwim');
          if (!t) continue;
        }
        if (t.water) {
          t.setSprite(y == GreatLakeStartTileY ? 'sWaterTop' : 'sWater');
        } else if (t.lava) {
          t.setSprite(y == GreatLakeStartTileY ? 'sLavaTop' : 'sLava');
        }
      }
    }
  }
}


// called once after level generation
final void fixLiquidTop () {
  if (global.lake == 1) fillGreatLake();

  liquidTileCount = 0;
  forEachTile(delegate bool (MapTile t) {
    if (!t.water && !t.lava) {
      // mark as wet for lake
      //if (global.lake == 1 && t.iy >= GreatLakeStartTileY*16) t.wet = true;
      return false;
    }

    ++liquidTileCount;
    //writeln("fixing water tile(", GetClassName(t.Class), "):'", t.objName, "' (water=", t.water, "; lava=", t.lava, "); lqc=", liquidTileCount);

    if (global.lake == 1) return false; // it is done in `fillGreatLake()`

    if (!checkTileAtPoint(t.ix+8, t.iy-8, (t.lava ? &isLavaTileCB : &isWaterTileCB))) {
      t.setSprite(t.lava ? 'sLavaTop' : 'sWaterTop');
    } else {
      // don't do this, it will destroy seaweed
      //t.setSprite(t.lava ? 'sLava' : 'sWater');
      auto spr = t.getSprite();
           if (!spr) t.setSprite(t.lava ? 'sLava' : 'sWater');
      else if (spr.Name == 'sLavaTop') t.setSprite('sLava');
      else if (spr.Name == 'sWaterTop') t.setSprite('sWater');
    }

    return false;
  });
  //writeln("liquid tiles count: ", liquidTileCount);
}


/+
private final void checkWaterFlow (MapTile wtile) {
  if (global.lake == 1 && wtile.iy >= GreatLakeStartTileY*16) return;

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

  bool wetLeft = !!isWetOrSolidTileAtTile(tileX-1, tileY);
  bool wetRight = !!isWetOrSolidTileAtTile(tileX+1, tileY);
  bool wetBottom = !!isWetOrSolidTileAtTile(tileX, tileY+1);

  if (!wetBottom || !wetLeft || !wetRight) {
    //TODO: if this is some pool created by a mattock or by an explosion, fill it
    if (true /*!isGoodPoolAtTile(tileX, tileY)*/) {
      checkWater = true;
      wtile.smashMe();
      wtile.instanceRemove(); // just in case
    }
    return;
  }

  ++liquidTileCount;

  if (!isWetTileAtPix(tileX*16+8, tileY*16-8)) {
    wtile.setSprite(wtile.lava ? 'sLavaTop' : 'sWaterTop');
  }
}
+/

/*
  [.] write water flowing. algo:
      start with the lowest water tile that has any room do drop, or to move to the side
      if water can move down, move it down until it hits the floor, repeat the algo for it
      if water can move left or right, choose a direction (if both dirs are available, make
      a random choice), move water there, and repeat algo
      NOTE: if we're sitting on top of another water tile, choose the side where we can move
            down on the next step
        WARNING! never return to the horizontal tile we already visited! such tiles are
                 considered "occupied"
      if water cannot move anymore, set "check mark" to 1, and continue with other water tiles.

      after all water tiles are moved, check all water tiles again. if some tile is not enclosed
      by another water tiles or solids, remove it
*/
transient MapTile curWaterTile;
transient bool curWaterTileCheckHitsLava;
transient bool curWaterTileCheckHitsSolidOrWater; // only for `checkWaterOrSolidTilePartialCB`
transient int curWaterTileLastHDir;
transient ubyte[16, 16] curWaterOccupied;
transient int curWaterOccupiedCount;
transient int curWaterTileCheckX0, curWaterTileCheckY0;


private final void clearCurWaterCheckState () {
  curWaterTileCheckHitsLava = false;
  curWaterOccupiedCount = 0;
  foreach (auto idx; 0..16*16) curWaterOccupied[idx] = 0;
}


private final bool checkWaterOrSolidTileCB (MapTile t) {
  if (t == curWaterTile) return false;
  if (t.lava && curWaterTile.water) {
    curWaterTileCheckHitsLava = true;
    return true;
  }
  if (t.ix%16 != 0 || t.iy%16 != 0) {
    if (t.water || t.solid) {
      // fill occupied array
      //FIXME: optimize this
      if (curWaterOccupiedCount < 16*16) {
        foreach (auto dy; t.y0..t.y1+1) {
          foreach (auto dx; t.x0..t.x1+1) {
            int sx = dx-curWaterTileCheckX0;
            int sy = dy-curWaterTileCheckY0;
            if (sx >= 0 && sx <= 16 && sy >= 0 && sy <= 15 && !curWaterOccupied[sx, sy]) {
              curWaterOccupied[sx, sy] = 1;
              ++curWaterOccupiedCount;
            }
          }
        }
      }
    }
    return false; // need to check for lava
  }
  if (t.water || t.solid || t.lava) {
    curWaterOccupiedCount = 16*16;
    if (t.water && curWaterTile.lava) t.instanceRemove();
  }
  return false; // need to check for lava
}


private final bool checkWaterOrSolidTilePartialCB (MapTile t) {
  if (t == curWaterTile) return false;
  if (t.lava && curWaterTile.water) {
    //writeln("!!!!!!!!");
    curWaterTileCheckHitsLava = true;
    return true;
  }
  if (t.water || t.solid || t.lava) {
    //writeln("*********");
    curWaterTileCheckHitsSolidOrWater = true;
    if (t.water && curWaterTile.lava) t.instanceRemove();
  }
  return false; // need to check for lava
}


private final bool isFullyOccupiedAtTilePos (int tileX, int tileY) {
  clearCurWaterCheckState();
  curWaterTileCheckX0 = tileX*16;
  curWaterTileCheckY0 = tileY*16;
  checkTilesInRect(tileX*16, tileY*16, 16, 16, &checkWaterOrSolidTileCB);
  return (curWaterTileCheckHitsLava || curWaterOccupiedCount == 16*16);
}


private final bool isAtLeastPartiallyOccupiedAtTilePos (int tileX, int tileY) {
  curWaterTileCheckHitsLava = false;
  curWaterTileCheckHitsSolidOrWater = false;
  checkTilesInRect(tileX*16, tileY*16, 16, 16, &checkWaterOrSolidTilePartialCB);
  return (curWaterTileCheckHitsSolidOrWater || curWaterTileCheckHitsLava);
}


private final bool waterCanReachGroundHoleInDir (MapTile wtile, int dx) {
  if (dx == 0) return false; // just in case
  dx = sign(dx);
  int x = wtile.ix/16, y = wtile.iy/16;
  x += dx;
  while (x >= 0 && x < tilesWidth) {
    if (!isAtLeastPartiallyOccupiedAtTilePos(x, y+1)) return true;
    if (isAtLeastPartiallyOccupiedAtTilePos(x, y)) return false;
    x += dx;
  }
  return false;
}


// returns `true` if this tile must be removed
private final bool checkWaterFlow (MapTile wtile) {
  if (global.lake == 1 && wtile.iy >= GreatLakeStartTileY*16) return false;

  if (wtile.ix%16 != 0 || wtile.iy%16 != 0) return true; // sanity check

  curWaterTile = wtile;
  curWaterTileLastHDir = 0; // never moved to the side

  bool wasMoved = false;

  for (;;) {
    int tileX = wtile.ix/16, tileY = wtile.iy/16;

    // out of level?
    if (tileY >= tilesHeight) return true;

    // check if we can fall down
    auto canFall = !isAtLeastPartiallyOccupiedAtTilePos(tileX, tileY+1);
    // disappear if can fall in lava
    if (wtile.water && curWaterTileCheckHitsLava) {
      //!writeln(wtile.objId, ": LAVA HIT DOWN");
      return true;
    }
    if (wasMoved) {
      // fake, so caller will not start removing tiles
      if (canFall) wtile.waterMovedDown = true;
      break;
    }
    // can move down?
    if (canFall) {
      // move down
      //!writeln(wtile.objId, ": GOING DOWN");
      curWaterTileLastHDir = 0;
      wtile.iy = wtile.iy+16;
      wasMoved = true;
      wtile.waterMovedDown = true;
      continue;
    }

    bool canMoveLeft = (curWaterTileLastHDir > 0 ? false : !isAtLeastPartiallyOccupiedAtTilePos(tileX-1, tileY));
    // disappear if near lava
    if (wtile.water && curWaterTileCheckHitsLava) {
      //!writeln(wtile.objId, ": LAVA HIT LEFT");
      return true;
    }

    bool canMoveRight = (curWaterTileLastHDir < 0 ? false : !isAtLeastPartiallyOccupiedAtTilePos(tileX+1, tileY));
    // disappear if near lava
    if (wtile.water && curWaterTileCheckHitsLava) {
      //!writeln(wtile.objId, ": LAVA HIT RIGHT");
      return true;
    }

    if (!canMoveLeft && !canMoveRight) {
      // do final checks
      //!if (wasMove) writeln(wtile.objId, ": NO MORE MOVES");
      break;
    }

    if (canMoveLeft && canMoveRight) {
      // choose random direction
      //!writeln(wtile.objId, ": CHOOSING RANDOM HDIR");
      // actually, choose direction that leads to hole in a ground
      if (waterCanReachGroundHoleInDir(wtile, -1)) {
        // can reach hole at the left side
        if (waterCanReachGroundHoleInDir(wtile, 1)) {
          // can reach hole at the right side, choose at random
          if (global.randOther(0, 1)) canMoveRight = false; else canMoveLeft = false;
        } else {
          // move left
          canMoveRight = false;
        }
      } else {
        // can't reach hole at the left side
        if (waterCanReachGroundHoleInDir(wtile, 1)) {
          // can reach hole at the right side, choose at random
          canMoveLeft = false;
        } else {
          // no holes at any side, choose at random
          if (global.randOther(0, 1)) canMoveRight = false; else canMoveLeft = false;
        }
      }
    }

    // move
    if (canMoveLeft) {
      if (canMoveRight) FatalError("WATERCHECK: WTF RIGHT");
      //!writeln(wtile.objId, ": MOVING LEFT (", curWaterTileLastHDir, ")");
      curWaterTileLastHDir = -1;
      wtile.ix = wtile.ix-16;
    } else if (canMoveRight) {
      if (canMoveLeft) FatalError("WATERCHECK: WTF LEFT");
      //!writeln(wtile.objId, ": MOVING RIGHT (", curWaterTileLastHDir, ")");
      curWaterTileLastHDir = 1;
      wtile.ix = wtile.ix+16;
    }
    wasMoved = true;
  }

  // remove seaweeds
  if (wasMoved) {
    checkWater = true;
    wtile.setSprite(wtile.lava ? 'sLava' : 'sWater');
    wtile.waterMoved = true;
    // if this tile was not moved down, check if it can move down on any next step
    if (!wtile.waterMovedDown) {
           if (waterCanReachGroundHoleInDir(wtile, -1)) wtile.waterMovedDown = true;
      else if (waterCanReachGroundHoleInDir(wtile, 1)) wtile.waterMovedDown = true;
    }
  }

  return false; // don't remove

  //if (!isWetTileAtPix(tileX*16+8, tileY*16-8)) wtile.setSprite(wtile.lava ? 'sLavaTop' : 'sWaterTop');
}


transient array!MapTile waterTilesList;

final bool sortWaterTilesByCoordsLess (MapTile a, MapTile b) {
  int dy = a.iy-b.iy;
  if (dy) return (dy < 0);
  return (a.ix < b.ix);
}

transient int waterFlowPause = 0;
transient bool debugWaterFlowPause = false;

final void cleanDeadObjects () {
  // remove dead objects
  if (deadItemsHead) {
    auto olddel = ImmediateDelete;
    ImmediateDelete = false;
    do {
      auto it = deadItemsHead;
      deadItemsHead = it.deadItemsNext;
      if (it.grid) it.grid.remove(it.gridId);
      it.onDestroy();
      delete it;
    } while (deadItemsHead);
    ImmediateDelete = olddel;
    if (olddel) CollectGarbage(true); // destroy delayed objects too
  }
}

final void cleanDeadTiles () {
  if (checkWater && /*global.lake == 1 ||*/ (!blockWaterChecking && liquidTileCount)) {
    if (global.lake == 1) fillGreatLake();
    if (waterFlowPause > 1) {
      --waterFlowPause;
      cleanDeadObjects();
      return;
    }
    if (debugWaterFlowPause) waterFlowPause = 4;
    //writeln("checking water");
    waterTilesList.clear();
    foreach (MapTile wtile; objGrid.allObjectsSafe(MapTile)) {
      if (wtile.water || wtile.lava) {
        // sanity check
        if (wtile.ix%16 == 0 && wtile.iy%16 == 0) {
          wtile.waterMoved = false;
          wtile.waterMovedDown = false;
          wtile.waterSlideOldX = wtile.ix;
          wtile.waterSlideOldY = wtile.iy;
          waterTilesList[$] = wtile;
        }
      }
    }
    checkWater = false;
    liquidTileCount = 0;
    waterTilesList.sort(&sortWaterTilesByCoordsLess);
    // do water flow
    bool wasAnyMove = false;
    bool wasAnyMoveDown = false;
    foreach (MapTile wtile; waterTilesList) {
      if (!wtile || !wtile.isInstanceAlive) continue;
      auto killIt = checkWaterFlow(wtile);
      if (killIt) {
        checkWater = true;
        wtile.smashMe();
        wtile.instanceRemove(); // just in case
      } else {
        wtile.saveInterpData();
        wtile.updateGrid();
        wasAnyMove = wasAnyMove || wtile.waterMoved;
        wasAnyMoveDown = wasAnyMoveDown || wtile.waterMovedDown;
        if (wtile.waterMoved && debugWaterFlowPause) wtile.waterSlideCounter = 4;
      }
    }
    // do water check
    liquidTileCount = 0;
    foreach (MapTile wtile; waterTilesList) {
      if (!wtile || !wtile.isInstanceAlive) continue;
      if (wasAnyMoveDown) {
        ++liquidTileCount;
        continue;
      }
      //checkWater = checkWater || wtile.waterMoved;
      curWaterTile = wtile;
      int tileX = wtile.ix/16, tileY = wtile.iy/16;
      // check if we are have no way to leak
      bool killIt = false;
      if (!isFullyOccupiedAtTilePos(tileX-1, tileY) || (wtile.water && curWaterTileCheckHitsLava)) {
        //writeln(" LEFT DEATH (", curWaterOccupiedCount, " : ", curWaterTileCheckHitsLava, ")");
        killIt = true;
      }
      if (!killIt && (!isFullyOccupiedAtTilePos(tileX+1, tileY) || (wtile.water && curWaterTileCheckHitsLava))) {
        //writeln(" RIGHT DEATH (", curWaterOccupiedCount, " : ", curWaterTileCheckHitsLava, ")");
        killIt = true;
      }
      if (!killIt && (!isFullyOccupiedAtTilePos(tileX, tileY+1) || (wtile.water && curWaterTileCheckHitsLava))) {
        //writeln(" DOWN DEATH (", curWaterOccupiedCount, " : ", curWaterTileCheckHitsLava, ")");
        killIt = true;
      }
      //killIt = false;
      if (killIt) {
        checkWater = true;
        wtile.smashMe();
        wtile.instanceRemove(); // just in case
      } else {
        ++liquidTileCount;
      }
    }
    if (wasAnyMove) checkWater = true;
    //writeln("water check: liquidTileCount=", liquidTileCount, "; checkWater=", checkWater, "; wasAnyMove=", wasAnyMove, "; wasAnyMoveDown=", wasAnyMoveDown);

    // fill empty spaces in lake with water
    fixLiquidTop();
  }

  cleanDeadObjects();
}


// ////////////////////////////////////////////////////////////////////////// //
private transient array!MapEntity postponedThinkers;
private transient MapEntity thinkerHeld;
private transient array!MapEntity activeThinkerList;


final void doThinkActionsForObject (MapEntity o) {
       if (o.justSpawned) o.justSpawned = false;
  else if (o.imageSpeed > 0) o.nextAnimFrame();
  o.saveInterpData();
  o.thinkFrame();
  if (o.isInstanceAlive) {
    //o.updateGrid();
    o.processAlarms();
    if (o.isInstanceAlive) {
      if (o.whipTimer > 0) --o.whipTimer;
      o.updateGrid();
      auto obj = MapObject(o);
      if (!o.canLiveOutsideOfLevel && (!obj || !obj.heldBy) && o.isOutsideOfLevel()) {
        // oops, fallen out of level...
        o.onOutOfLevel();
      }
    }
  }
}


// return `true` if thinker should be removed
final void thinkOne (MapEntity o, optional bool doHeldObject, optional bool dontAddHeldObject) {
  if (!o) return;
  if (o == thinkerHeld && !doHeldObject) return; // skip it

  if (!o.active || !o.isInstanceAlive) return;

  auto obj = MapObject(o);

  if (obj && obj.heldBy == player) {
    // fix held item coords
    obj.fixHoldCoords();
    if (doHeldObject) {
      doThinkActionsForObject(o);
    } else {
      if (!dontAddHeldObject) {
        bool found = false;
        foreach (MapEntity e; postponedThinkers) if (e == o) { found = true; break; }
        if (!found) postponedThinkers[$] = o;
      }
    }
    return;
  }

  bool doThink = true;

  // collision with player weapon
  auto hh = PlayerWeapon(player.holdItem);
  bool doWeaponAction = false;
  if (hh) {
    if (hh.blockedBySolids && !global.config.killEnemiesThruWalls) {
      int xx = player.ix+(player.dir == MapObject::Dir.Left ? -16 : 16);
      //doWeaponAction = !isSolidAtPoint(xx, player.iy);
      doWeaponAction = !isSolidAtPoint(xx, hh.yCenter);
      /*
      int dh = max(1, hh.height-2);
      doWeaponAction = !checkTilesInRect(player.ix, player.iy);
      */
    } else {
      doWeaponAction = true;
    }
  }

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

  if (doThink && o.isInstanceAlive) {
    doThinkActionsForObject(o);
    doThink = o.isInstanceAlive;
  }

  // collision with player
  if (doThink && obj && o.collidesWith(player)) {
    if (!player.onObjectTouched(obj) && o.isInstanceAlive) {
      doThink = !o.onTouchedByPlayer(player);
      o.updateGrid();
    }
  }
}


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) {
    postponedThinkers.clear();
    thinkerHeld = none;
    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;
    }
    // advance time
    time += 1;
    // we don't want the time to grow too large
    if (time < 0) { time = 0; lastRenderTime = -1; }
    // 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');
      }
      //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
      doThinkActionsForObject(player);
    }
    // frame thinkers: held object
    thinkerHeld = player.holdItem;
    if (thinkerHeld && thinkerHeld.isInstanceAlive) {
      thinkOne(thinkerHeld, doHeldObject:true);
      if (!thinkerHeld.isInstanceAlive) {
        if (player.holdItem == thinkerHeld) player.holdItem = none;
        thinkerHeld.grid.remove(thinkerHeld.gridId);
        /* later
        thinkerHeld.onDestroy();
        delete thinkerHeld;
        */
      }
    }
    // frame thinkers: objects
    activeThinkerList.clear();
    auto grid = objGrid;
    // collect active objects
    if (global.config.useFrozenRegion) {
      foreach (MapEntity e; grid.inRectPix(viewStart.x/global.scale-64, viewStart.y/global.scale-64, 320+64*2, 240+64*2, precise:false)) {
        if (e.active) activeThinkerList[$] = e;
      }
    } else {
      // no frozen area
      foreach (MapEntity e; grid.allObjects()) {
        if (e.active) activeThinkerList[$] = e;
      }
    }
    // process active objects
    //writeln("thinkers: ", activeThinkerList.length);
    foreach (MapEntity o; activeThinkerList) {
      if (!o) continue;
      thinkOne(o, doHeldObject:false);
      if (!o.isInstanceAlive) {
        //writeln("dead thinker: '", o.objType, "'");
        if (o.grid) o.grid.remove(o.gridId);
        auto obj = MapObject(o);
        if (obj && obj.heldBy) obj.heldBy.holdItem = none;
        /* later
        o.onDestroy();
        delete o;
        */
      }
    }
    // postponed thinkers
    foreach (MapEntity o; postponedThinkers) {
      if (!o) continue;
      thinkOne(o, doHeldObject:true, dontAddHeldObject:true);
      if (!o.isInstanceAlive) {
        //writeln("dead pp-thinker: '", o.objType, "'");
        /* later
        o.onDestroy();
        delete o;
        */
      }
    }
    postponedThinkers.clear();
    thinkerHeld = none;
    // clean dead things
    cleanDeadTiles();
    // fix held item coords
    if (player && player.holdItem) {
      if (player.holdItem.isInstanceAlive) {
        player.holdItem.fixHoldCoords();
      } else {
        player.holdItem = none;
      }
    }
    // money counter
    if (collectCounter == 0) {
      xmoney = max(0, xmoney-100);
    } else {
      --collectCounter;
    }
    // other things
    if (player) {
      if (!player.dead) stats.oneMoreFramePlayed();
      SoundSystem.ListenerOrigin = vector(player.xCenter, player.yCenter, -1);
      //writeln("plrpos=(", player.xCenter, ",", player.yCenter, "); lo=", SoundSystem.ListenerOrigin);
    }
    if (onAfterFrame) onAfterFrame(accumTime >= FrameTime);
    ++framesProcessedFromLastClear;
    keysNextFrame();
    wasFrame = true;
    if (!player.visible && player.holdItem) player.holdItem.visible = false;
    if (winCutsceneSwitchToNext) {
      winCutsceneSwitchToNext = false;
      switch (++inWinCutscene) {
        case 2: startWinCutsceneVolcano(); break;
        case 3: default: startWinCutsceneWinFall(); break;
      }
      break;
    }
    if (playerExited) break;
  }
  ImmediateDelete = olddel;
  if (playerExited) {
    playerExited = false;
    onLevelExited();
    centerViewAtPlayer();
  }
  if (wasFrame) {
    // if we were processed at least one frame, collect garbage
    //keysNextFrame();
    CollectGarbage(true); // destroy delayed objects too
  }
  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;
    return !!checkTilesInRect(tileX*16, tileY*16, 16, 16, delegate bool (MapTile t) { return t.shopWall; });
    //k8: we don't have this
    //if (t && t.objType == 'oShop') return true;
  }
  return false;
}


// ////////////////////////////////////////////////////////////////////////// //
override void Destroy () {
  clearWholeLevel();
  delete tempSolidTile;
  ::Destroy();
}


// ////////////////////////////////////////////////////////////////////////// //
// WARNING! delegate should not create/delete objects!
final MapObject findNearestObject (int px, int py, scope bool delegate (MapObject o) dg, optional class!MapObject castClass) {
  MapObject res = none;
  if (!castClass) castClass = MapObject;
  int curdistsq = int.max;
  foreach (MapObject o; objGrid.allObjects(MapObject)) {
    if (o.spectral) 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;
}


// WARNING! delegate should not create/delete objects!
final MapObject findNearestEnemy (int px, int py, optional scope bool delegate (MapEnemy o) dg, optional class!MapEnemy castClass) {
  if (!castClass) castClass = MapEnemy;
  if (castClass !isa MapEnemy) return none;
  MapObject res = none;
  int curdistsq = int.max;
  foreach (MapEnemy o; objGrid.allObjects(castClass)) {
    //k8: i added `dead` check
    if (o.spectral || o.dead) continue;
    if (dg) {
      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 MonsterShopkeeper findNearestCalmShopkeeper (int px, int py) {
  auto obj = MonsterShopkeeper(findNearestEnemy(px, py, delegate bool (MapEnemy o) {
    auto sk = MonsterShopkeeper(o);
    if (sk && !sk.angered) return true;
    return false;
  }, castClass:MonsterShopkeeper));
  return obj;
}


final MonsterShopkeeper hasAliveShopkeepers (optional bool skipAngry) {
  foreach (MonsterShopkeeper sc; objGrid.allObjects(MonsterShopkeeper)) {
    if (sc.spectral || sc.dead) continue;
    if (skipAngry && (sc.angered || sc.outlaw)) continue;
    return sc;
  }
  return none;
}


// WARNING! delegate should not create/delete objects!
final int calcNearestEnemyDist (int px, int py, optional scope bool delegate (MapEnemy o) dg, optional class!MapEnemy castClass) {
  auto e = findNearestEnemy(px, py, dg!optional, castClass!optional);
  if (!e) return int.max;
  int xc = px-e.xCenter, yc = py-e.yCenter;
  return round(sqrt(xc*xc+yc*yc));
}


// WARNING! delegate should not create/delete objects!
final int calcNearestObjectDist (int px, int py, optional scope bool delegate (MapObject o) dg, optional class!MapObject castClass) {
  auto e = findNearestObject(px, py, dg!optional, castClass!optional);
  if (!e) return int.max;
  int xc = px-e.xCenter, yc = py-e.yCenter;
  return round(sqrt(xc*xc+yc*yc));
}


// WARNING! delegate should not create/delete objects!
final MapTile findNearestMoveableSolid (int px, int py, optional scope bool delegate (MapTile t) dg) {
  MapTile res = none;
  int curdistsq = int.max;
  foreach (MapTile t; objGrid.allObjects(MapTile)) {
    if (t.spectral) 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;
}


// WARNING! delegate should not create/delete objects!
final MapTile findNearestTile (int px, int py, optional scope bool delegate (MapTile t) dg) {
  if (!dg) return none;
  MapTile res = none;
  int curdistsq = int.max;

  //FIXME: make this faster!
  foreach (MapTile t; objGrid.allObjects(MapTile)) {
    if (t.spectral) 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 isa EnemyBlob); }
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 scope bool delegate (MapObject o) dg, optional bool precise) {
  if (!specified_precise) precise = true;
  tileX *= 16;
  tileY *= 16;
  foreach (MapObject o; objGrid.inRectPix(tileX, tileY, 16, 16, precise:precise, castClass:MapObject)) {
    if (o.spectral) continue;
    if (dg) {
      if (dg(o)) return o;
    } else {
      return o;
    }
  }
  return none;
}


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


final MapObject isObjectAtPoint (int xpos, int ypos, optional scope bool delegate (MapObject o) dg, optional bool precise, optional class!MapObject castClass) {
  if (!specified_precise) precise = true;
  if (!castClass) castClass = MapObject;
  foreach (MapObject o; objGrid.inCellPix(xpos, ypos, precise:precise, castClass:castClass)) {
    if (o.spectral) 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 scope bool delegate (MapObject o) dg, optional bool precise, optional class!MapObject castClass) {
  if (w < 1 || h < 1) return none;
  if (!castClass) castClass = MapObject;
  if (w == 1 && h == 1) return isObjectAtPoint(xpos, ypos, dg!optional, precise!optional, castClass);
  if (!specified_precise) precise = true;
  foreach (MapObject o; objGrid.inRectPix(xpos, ypos, w, h, precise:precise, castClass:castClass)) {
    if (o.spectral) continue;
    if (dg) {
      if (dg(o)) return o;
    } else {
      if (o isa MapEnemy) return o;
    }
  }
  return none;
}


final MapObject forEachObject (scope bool delegate (MapObject o) dg, optional bool allowSpectrals, optional class!MapObject castClass) {
  if (!dg) return none;
  if (!castClass) castClass = MapObject;
  foreach (MapObject o; objGrid.allObjectsSafe(castClass)) {
    if (!allowSpectrals && o.spectral) continue;
    if (dg(o)) return o;
  }
  return none;
}


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


final MapObject forEachObjectInRect (int xpos, int ypos, int w, int h, scope 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, precise:precise, castClass:MapObject)) {
    if (o.spectral) continue;
    if (dg(o)) return o;
  }
  return none;
}


final MapEntity forEachEntityInRect (int xpos, int ypos, int w, int h, scope bool delegate (MapEntity o) dg, optional bool precise, optional class!MapEntity castClass) {
  if (!dg || w < 1 || h < 1) return none;
  if (!castClass) castClass = MapEntity;
  if (!specified_precise) precise = true;
  foreach (MapEntity e; objGrid.inRectPix(xpos, ypos, w, h, precise:precise, castClass:castClass)) {
    if (e.spectral) continue;
    if (dg(e)) return e;
  }
  return none;
}


private final bool cbIsRopeTile (MapTile t) { return (t isa MapTileRope); }

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!MapEntity tmpEntityList;

private final bool cbCollectEntitiesWithMask (MapEntity t) {
  if (!t.visible || t.spectral) return false;
  tmpEntityList[$] = t;
  return false;
}


final void touchEntitiesWithMask (int x, int y, SpriteFrame frm, scope bool delegate (MapEntity t) dg, optional class!MapEntity castClass) {
  if (!frm || frm.bw < 1 || frm.bh < 1 || !dg) return;
  if (frm.isEmptyPixelMask) return;
  if (!castClass) castClass = MapEntity;
  // collect tiles
  if (tmpEntityList.length) tmpEntityList.clear();
  if (player isa castClass && player.isRectCollisionFrame(frm, x, y)) tmpEntityList[$] = player;
  forEachEntityInRect(x+frm.bx, y+frm.by, frm.bw, frm.bh, &cbCollectEntitiesWithMask, castClass:castClass);
  foreach (MapEntity e; tmpEntityList) {
    if (!e || !e.isInstanceAlive || !e.visible || e.spectral) continue;
    if (e.isRectCollisionFrame(frm, x, y)) {
      if (dg(e)) 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.isExitActive(); }

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; }


// ////////////////////////////////////////////////////////////////////////// //
transient MapTileTemp tempSolidTile;

private final MapTileTemp makeWalkeableSolidTile (MapObject o) {
  if (!tempSolidTile) {
    tempSolidTile = SpawnObject(MapTileTemp);
  } else if (!tempSolidTile.isInstanceAlive) {
    delete tempSolidTile;
    tempSolidTile = SpawnObject(MapTileTemp);
  }
  // setup data
  tempSolidTile.level = self;
  tempSolidTile.global = global;
  tempSolidTile.solid = true;
  tempSolidTile.objName = MapTileTemp.default.objName;
  tempSolidTile.objType = MapTileTemp.default.objType;
  tempSolidTile.e = o;
  tempSolidTile.fltx = o.fltx;
  tempSolidTile.flty = o.flty;
  return tempSolidTile;
}


final MapTile checkTilesInRect (int x0, int y0, const int w, const int h, optional scope bool delegate (MapTile dg) dg, optional bool precise) {
  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 (!specified_precise) precise = true;
  if (!dg) dg = &cbCollisionAnySolid;

  // check walkable solid objects too
  foreach (MapEntity e; objGrid.inRectPix(x0, y0, w, h, precise:precise)) {
    if (e.spectral || !e.visible) continue;
    auto t = MapTile(e);
    if (t) {
      if (dg(t)) return t;
      continue;
    }
    auto o = MapObject(e);
    if (o && o.walkableSolid) {
      t = makeWalkeableSolidTile(o);
      if (dg(t)) return t;
      continue;
    }
  }

  return none;
}


final MapTile checkTileAtPoint (int x0, int y0, optional scope bool delegate (MapTile dg) dg, optional bool precise) {
  if (x0 < 0 || y0 < 0 || x0 >= tilesWidth*16 || y0 >= tilesHeight*16) return none;
  if (!specified_precise) precise = true;
  if (!dg) dg = &cbCollisionAnySolid;

  // check walkable solid objects
  foreach (MapEntity e; objGrid.inCellPix(x0, y0, precise:precise)) {
    if (e.spectral || !e.visible) continue;
    auto t = MapTile(e);
    if (t) {
      if (dg(t)) return t;
      continue;
    }
    auto o = MapObject(e);
    if (o && o.walkableSolid) {
      t = makeWalkeableSolidTile(o);
      if (dg(t)) return t;
      continue;
    }
  }

  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); }


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


//FIXME: make this faster
transient float gtagX, gtagY;

// only non-moveables and non-specials
final MapTile getTileAtGrid (int tileX, int tileY) {
  gtagX = tileX*16;
  gtagY = tileY*16;
  return checkTileAtPoint(tileX*16, tileY*16, delegate bool (MapTile t) {
    if (t.spectral || t.moveable || t.toSpecialGrid || !t.visible) return false;
    if (t.fltx != gtagX || t.flty != gtagY) return false; // emulate grid
    if (t.width != 16 || t.height != 16) return false;
    return true;
  }, precise:false);
  //return (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight ? tiles[tileX, tileY] : none);
}


final MapTile getTileAtGridAny (int tileX, int tileY) {
  gtagX = tileX*16;
  gtagY = tileY*16;
  return checkTileAtPoint(tileX*16, tileY*16, delegate bool (MapTile t) {
    if (t.spectral /*|| t.moveable*/ || !t.visible) return false;
    if (t.fltx != gtagX || t.flty != gtagY) return false; // emulate grid
    if (t.width != 16 || t.height != 16) return false;
    return true;
  }, precise:false);
  //return (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight ? tiles[tileX, tileY] : none);
}


final bool isNamedTileAt (int tileX, int tileY, name atypename) {
  if (!atypename) return false;
  auto t = getTileAtGridAny(tileX, tileY);
  return (t && t.objName == atypename);
}


final void setTileAtGrid (int tileX, int tileY, MapTile tile) {
  if (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight) {
    if (tile) {
      tile.fltx = tileX*16;
      tile.flty = tileY*16;
      if (!tile.dontReplaceOthers) {
        auto osp = tile.spectral;
        tile.spectral = true;
        auto t = getTileAtGridAny(tileX, tileY);
        tile.spectral = osp;
        if (t && !t.immuneToReplacement) {
          writeln("REPLACING tile(", GetClassName(t.Class), "): '", t.objType, ":", t.objName, "' at ", (t.toSpecialGrid ? "special " : ""), "grid, pos=(", t.fltx/16.0, ",", t.flty/16.0, ")");
          writeln("      NEW tile(", GetClassName(tile.Class), "): '", tile.objType, ":", tile.objName, "' at ", (tile.toSpecialGrid ? "special " : ""), "grid, pos=(", tile.fltx/16.0, ",", tile.flty/16.0, ")");
          t.instanceRemove();
        }
      }
      insertObject(tile);
    } else {
      auto t = getTileAtGridAny(tileX, tileY);
      if (t && !t.immuneToReplacement) {
        writeln("REMOVING tile(", GetClassName(t.Class), "): '", t.objType, ":", t.objName, "' at ", (t.toSpecialGrid ? "special " : ""), "grid, pos=(", t.fltx/16.0, ",", t.flty/16.0, ")");
        t.instanceRemove();
      }
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// return `true` from delegate to stop
MapTile forEachSolidTileOnGrid (scope bool delegate (int tileX, int tileY, MapTile t) dg) {
  if (!dg) return none;
  foreach (MapTile t; objGrid.allObjectsSafe(MapTile)) {
    if (t.spectral || !t.solid || !t.visible) continue;
    if (t.ix%16 != 0 || t.iy%16 != 0) continue; // emulate grid
    if (t.width != 16 || t.height != 16) continue;
    if (dg(t.ix/16, t.iy/16, t)) return t;
  }
  return none;
}


// ////////////////////////////////////////////////////////////////////////// //
// return `true` from delegate to stop
MapTile forEachTile (scope bool delegate (MapTile t) dg, optional class!MapTile castClass) {
  if (!dg) return none;
  if (!castClass) castClass = MapTile;
  foreach (MapTile t; objGrid.allObjectsSafe(castClass)) {
    if (t.spectral || !t.visible) continue;
    if (dg(t)) return t;
  }
  return none;
}


// ////////////////////////////////////////////////////////////////////////// //
final void fixWallTiles () {
  foreach (MapTile t; objGrid.allObjectsSafe(MapTile)) t.beautifyTile();
}


// ////////////////////////////////////////////////////////////////////////// //
final MapTile isCollisionAtPoint (int px, int py, optional scope 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.removeBallAndChain(temp:true);
    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) 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);
}


final int cameraCurrX () { return realViewStart.x/global.scale; }
final int cameraCurrY () { return realViewStart.y/global.scale; }


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;

  cameraSlideToSpeed.x = 0;
  cameraSlideToSpeed.y = 0;
  cameraSlideToPlayer = 0;

  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();

  if (onCameraTeleported) onCameraTeleported();
}


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 alwaysCenterX = global.config.alwaysCenterPlayer;
  auto alwaysCenterY = alwaysCenterX;
  // calculate offset from viewport center (in game units), and fix viewport

  int camDestX = player.ix+8;
  int camDestY = player.iy+8;
  if (!cameraSlideToPlayer && (cameraSlideToSpeed.x|cameraSlideToSpeed.y) != 0) {
    // slide camera to point
    if (cameraSlideToSpeed.x) camDestX = cameraSlideToCurr.x;
    if (cameraSlideToSpeed.y) camDestY = cameraSlideToCurr.y;
    int dx = cameraSlideToDest.x-camDestX;
    int dy = cameraSlideToDest.y-camDestY;
    //writeln("speed:(", cameraSlideToSpeed.x, ",", cameraSlideToSpeed.y, "); cur:(", camDestX, ",", camDestY, "); dest:(", cameraSlideToDest.x, ",", cameraSlideToDest.y, "); delta=(", dx, ",", dy, ")");
    if (dx && cameraSlideToSpeed.x != 0) {
      alwaysCenterX = true;
      if (abs(dx) <= abs(cameraSlideToSpeed.x)) {
        camDestX = cameraSlideToDest.x;
      } else {
        camDestX += sign(dx)*abs(cameraSlideToSpeed.x);
      }
    }
    if (dy && abs(cameraSlideToSpeed.y) != 0) {
      alwaysCenterY = true;
      if (abs(dy) <= cameraSlideToSpeed.y) {
        camDestY = cameraSlideToDest.y;
      } else {
        camDestY += sign(dy)*abs(cameraSlideToSpeed.y);
      }
    }
    //writeln("  new:(", camDestX, ",", camDestY, ")");
    if (cameraSlideToSpeed.x) cameraSlideToCurr.x = camDestX;
    if (cameraSlideToSpeed.y) cameraSlideToCurr.y = camDestY;
  }

  // horizontal
  if (cameraSlideToSpeed.x && !cameraSlideToPlayer) {
    realViewStart.x = clamp(camDestX*scale, 0, tilesWidth*16*scale-viewWidth);
  } else if (!player.cameraBlockX) {
    int x = camDestX*scale;
    int cx = realViewStart.x;
    if (alwaysCenterX) {
      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;
    }
    // slide back to player?
    if (cameraSlideToPlayer && cameraSlideToSpeed.x) {
      int prevx = cameraSlideToCurr.x*scale;
      int dx = (cx-prevx)/scale;
      if (abs(dx) <= cameraSlideToSpeed.x) {
        writeln("BACKSLIDE X COMPLETE!");
        cameraSlideToSpeed.x = 0;
      } else {
        cx = prevx+(sign(dx)*cameraSlideToSpeed.x)*scale;
        cameraSlideToCurr.x += sign(dx)*cameraSlideToSpeed.x;
        if ((dx < 0 && cx <= 0) || (dx > 0 && cx >= tilesWidth*16*scale-viewWidth)) {
          writeln("BACKSLIDE X COMPLETE!");
          cameraSlideToSpeed.x = 0;
        }
      }
    }
    realViewStart.x = clamp(cx, 0, tilesWidth*16*scale-viewWidth);
  }

  // vertical
  if (cameraSlideToSpeed.y && !cameraSlideToPlayer) {
    realViewStart.y = clamp(camDestY*scale, 0, tilesHeight*16*scale-viewHeight);
  } else if (!player.cameraBlockY) {
    int y = camDestY*scale;
    int cy = realViewStart.y;
    if (alwaysCenterY) {
      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;
    }
    // slide back to player?
    if (cameraSlideToPlayer && cameraSlideToSpeed.y) {
      int prevy = cameraSlideToCurr.y*scale;
      int dy = (cy-prevy)/scale;
      if (abs(dy) <= cameraSlideToSpeed.y) {
        writeln("BACKSLIDE Y COMPLETE!");
        cameraSlideToSpeed.y = 0;
      } else {
        cy = prevy+(sign(dy)*cameraSlideToSpeed.y)*scale;
        cameraSlideToCurr.y += sign(dy)*cameraSlideToSpeed.y;
        if ((dy < 0 && cy <= 0) || (dy > 0 && cy >= tilesHeight*16*scale-viewHeight)) {
          writeln("BACKSLIDE Y COMPLETE!");
          cameraSlideToSpeed.y = 0;
        }
      }
    }
    realViewStart.y = clamp(cy, 0, tilesHeight*16*scale-viewHeight);
  }

  if (cameraSlideToPlayer && (cameraSlideToSpeed.x|cameraSlideToSpeed.y) == 0) cameraSlideToPlayer = 0;

  fixRealViewStart();
  //writeln("  new2:(", cameraCurrX, ",", cameraCurrY, ")");

  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 renderStarsHUD (float currFrameDelta) {
  bool scumSmallHud = global.config.scumSmallHud;

  //auto life = max(0, global.plife);
  int talpha = clamp(global.config.hudTextAlpha, 0, 255)<<24;
  int ialpha = clamp(global.config.hudItemsAlpha, 0, 255)<<24;
  //sprStore.loadFont('sFont'); //draw_set_font(global.myFont);

  int hhup;

  if (scumSmallHud) {
    sprStore.loadFont('sFontSmall');
    hhup = 6;
  } else {
    sprStore.loadFont('sFont');
    hhup = 2;
  }

  Video.color = 0xff_ff_ff|talpha; //draw_set_color(c_white);
  //draw_sprite(sHeart, -1, view_xview[0]+8, view_yview[0]+8);
  //draw_text(view_xview[0]+24, view_yview[0]+8, life);
  if (scumSmallHud) {
    if (global.plife == 1) {
      drawSpriteAt('sHeartSmallBlink', global.heartBlink, 10, hhup-4);
      global.heartBlink += 0.1;
      if (global.heartBlink > 3) global.heartBlink = 0;
    } else {
      drawSpriteAt('sHeartSmall', -1, 10, hhup-4);
      global.heartBlink = 0;
    }
  } else {
    if (global.plife == 1) {
      drawSpriteAt('sHeartBlink', global.heartBlink, 8, hhup);
      global.heartBlink += 0.1;
      if (global.heartBlink > 3) global.heartBlink = 0;
    } else {
      drawSpriteAt('sHeart', -1, 8, hhup);
      global.heartBlink = 0;
    }
  }
  int life = clamp(global.plife, 0, 99);
  drawTextAt(16+8, hhup, va("%d", life));

  //draw_sprite(sShopkeeperIcon, -1, view_xview[0]+64, view_yview[0]+8);
  drawSpriteAt('sShopkeeperIcon', -1, 64, hhup, scumSmallHud);
  drawTextAt(64+16-(scumSmallHud ? 6 : 0), hhup, va("%d", starsKills));

  if (starsRoomTimer1 > 0) {
    sprStore.loadFont('sFontSmall');
    Video.color = 0xff_ff_00;
    int scale = global.scale;
    sprStore.renderMultilineTextCentered(Video.screenWidth/2, 216*scale, va("SHOTGUN CHALLENGE BEGINS IN ~%d~", (starsRoomTimer1/30)+1), scale, 0xff_00_00);
  }
}


void renderSunHUD (float currFrameDelta) {
  bool scumSmallHud = global.config.scumSmallHud;

  //auto life = max(0, global.plife);
  int talpha = clamp(global.config.hudTextAlpha, 0, 255)<<24;
  int ialpha = clamp(global.config.hudItemsAlpha, 0, 255)<<24;
  //sprStore.loadFont('sFont'); //draw_set_font(global.myFont);

  int hhup;

  if (scumSmallHud) {
    sprStore.loadFont('sFontSmall');
    hhup = 6;
  } else {
    sprStore.loadFont('sFont');
    hhup = 2;
  }

  Video.color = 0xff_ff_ff|talpha; //draw_set_color(c_white);
  //draw_sprite(sHeart, -1, view_xview[0]+8, view_yview[0]+8);
  //draw_text(view_xview[0]+24, view_yview[0]+8, life);
  if (scumSmallHud) {
    if (global.plife == 1) {
      drawSpriteAt('sHeartSmallBlink', global.heartBlink, 10, hhup-4);
      global.heartBlink += 0.1;
      if (global.heartBlink > 3) global.heartBlink = 0;
    } else {
      drawSpriteAt('sHeartSmall', -1, 10, hhup-4);
      global.heartBlink = 0;
    }
  } else {
    if (global.plife == 1) {
      drawSpriteAt('sHeartBlink', global.heartBlink, 8, hhup);
      global.heartBlink += 0.1;
      if (global.heartBlink > 3) global.heartBlink = 0;
    } else {
      drawSpriteAt('sHeart', -1, 8, hhup);
      global.heartBlink = 0;
    }
  }
  int life = clamp(global.plife, 0, 99);
  drawTextAt(16+8, hhup, va("%d", life));

  //draw_sprite(sShopkeeperIcon, -1, view_xview[0]+64, view_yview[0]+8);
  drawSpriteAt('sDamselIcon', -1, 64, hhup, scumSmallHud);
  drawTextAt(64+16-(scumSmallHud ? 6 : 0), hhup, va("%d", sunScore));

  if (sunRoomTimer1 > 0) {
    sprStore.loadFont('sFontSmall');
    Video.color = 0xff_ff_00;
    int scale = global.scale;
    sprStore.renderMultilineTextCentered(Video.screenWidth/2, 216*scale, va("DAMSEL CHALLENGE BEGINS IN ~%d~", (sunRoomTimer1/30)+1), scale, 0xff_00_00);
  }
}


void renderMoonHUD (float currFrameDelta) {
  bool scumSmallHud = global.config.scumSmallHud;

  //auto life = max(0, global.plife);
  int talpha = clamp(global.config.hudTextAlpha, 0, 255)<<24;
  int ialpha = clamp(global.config.hudItemsAlpha, 0, 255)<<24;
  //sprStore.loadFont('sFont'); //draw_set_font(global.myFont);

  int hhup;

  if (scumSmallHud) {
    sprStore.loadFont('sFontSmall');
    hhup = 6;
  } else {
    sprStore.loadFont('sFont');
    hhup = 2;
  }

  Video.color = 0xff_ff_ff|talpha; //draw_set_color(c_white);

  //draw_sprite(sShopkeeperIcon, -1, view_xview[0]+64, view_yview[0]+8);
  drawSpriteAt('sHoopsIcon', -1, 8, hhup, scumSmallHud);
  drawTextAt(8+16-(scumSmallHud ? 6 : 0), hhup, va("%d", moonScore));
  drawSpriteAt('sTimerIcon', -1, 64, hhup, scumSmallHud);
  drawTextAt(64+16-(scumSmallHud ? 6 : 0), hhup, va("%d", max(0, moonTimer)));

  if (moonRoomTimer1 > 0) {
    sprStore.loadFont('sFontSmall');
    Video.color = 0xff_ff_00;
    int scale = global.scale;
    sprStore.renderMultilineTextCentered(Video.screenWidth/2, 216*scale, va("ARCHERY CHALLENGE BEGINS IN ~%d~", (moonRoomTimer1/30)+1), scale, 0xff_00_00);
  }
}


void renderHUD (float currFrameDelta) {
  if (levelKind == LevelKind.Stars) { renderStarsHUD(currFrameDelta); return; }
  if (levelKind == LevelKind.Sun) { renderSunHUD(currFrameDelta); return; }
  if (levelKind == LevelKind.Moon) { renderMoonHUD(currFrameDelta); return; }

  if (!isHUDEnabled()) return;

  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;
  }
  //int alpha = 0x6f_00_00_00;
  int talpha = clamp(global.config.hudTextAlpha, 0, 255)<<24;
  int ialpha = clamp(global.config.hudItemsAlpha, 0, 255)<<24;

  //Video.color = 0xff_ff_ff;
  Video.color = 0xff_ff_ff|talpha;

  // 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 && (!player || player.holdItem !isa ItemWeaponBow)) {
    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));
  } else if (player && player.holdItem isa ItemWeaponBow) {
    if (scumSmallHud) drawSpriteAt('sArrowRight', -1, ammoX+6, 8-hhup); else drawSpriteAt('sArrowRight', -1, ammoX+7, 12-hhup);
    n = global.arrows;
    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));

  // items
  Video.color = 0xff_ff_ff|ialpha;

  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;
    }
  }

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

  Video.color = 0xff_ff_ff;
  if (global.config.ghostShowTime) renderGhostTimer(currFrameDelta);
}


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

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


const int RenderEdgePixNormal = 64;
const int RenderEdgePixLight = 256;

#ifndef EXPERIMENTAL_RENDER_CACHE
enum skipListCreation = false;
#endif

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

  // don't touch framebuffer alpha
  Video.colorMask = Video::CMask.Colors;
  Video.color = 0xff_ff_ff;

  bool isDarkLevel = global.darkLevel;

  if (isDarkLevel) {
    switch (global.config.scumPlayerLit) {
      case 0: player.lightRadius = 0; break; // never
      case 1: // only in "scumDarkness"
        player.lightRadius = (global.config.scumDarkness >= 2 ? 96 : 32);
        break;
      case 2:
        player.lightRadius = 96;
        break;
    }
  }

  // render cave background
  if (levBGImg) {
    int tsz = 16*scale;
    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);
      }
    }
  }

  int RenderEdgePix = (global.darkLevel ? RenderEdgePixLight : RenderEdgePixNormal);

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

  // collect visible special tiles
#ifdef EXPERIMENTAL_RENDER_CACHE
  bool skipListCreation = (lastRenderTime == time && renderVisibleCids.length); //FIXME
#endif

  if (!skipListCreation) {
    renderVisibleCids.clear();
    renderVisibleLights.clear();
    renderFrontTiles.clear();

    int endVX = xofs+viewWidth;
    int endVY = yofs+viewHeight;

    // add player
    //int cnt = 0;
    if (player && player.visible) renderVisibleCids[$] = player; // include player in render list

    //FIXME: drop lit objects which cannot affect visible area
    if (scale > 1) {
      // collect visible objects
      foreach (MapEntity o; objGrid.inRectPix(xofs/scale-RenderEdgePix, yofs/scale-RenderEdgePix, (viewWidth+scale-1)/scale+RenderEdgePix*2, (viewHeight+scale-1)/scale+RenderEdgePix*2, precise:false)) {
        if (!o.visible) continue;
        auto tile = MapTile(o);
        if (tile) {
          if (isDarkLevel && (o.lightRadius > 4 || tile.litWholeTile)) renderVisibleLights[$] = o;
          if (tile.invisible) continue;
          if (tile.bgfront) renderFrontTiles[$] = tile;
          if (tile.bgback) tile.drawWithOfsBack(xofs, yofs, scale, currFrameDelta);
        } else {
          if (isDarkLevel && o.lightRadius > 4) renderVisibleLights[$] = o;
        }
        // check if the object is really visible -- this will speed up later sorting
        int fx0, fy0, fx1, fy1;
        auto spf = o.getSpriteFrame(default, out fx0, out fy0, out fx1, out fy1);
        if (!spf) continue; // no sprite -- nothing to draw (no, really)
        int ix = o.ix, iy = o.iy;
        int x0 = (ix+fx0)*scale, y0 = (iy+fy0)*scale;
        int x1 = (ix+fx1)*scale, y1 = (iy+fy1)*scale;
        if (x1 <= xofs || y1 <= yofs || x0 >= endVX || y0 >= endVY) {
          //++cnt;
          continue;
        }
        renderVisibleCids[$] = o;
      }
    } else {
      foreach (MapEntity o; objGrid.allObjects()) {
        if (!o.visible) continue;
        auto tile = MapTile(o);
        if (tile) {
          if (isDarkLevel && (o.lightRadius > 4 || tile.litWholeTile)) renderVisibleLights[$] = o;
          if (tile.invisible) continue;
          if (tile.bgfront) renderFrontTiles[$] = tile;
          if (tile.bgback) tile.drawWithOfsBack(xofs, yofs, scale, currFrameDelta);
        } else {
          if (isDarkLevel && o.lightRadius > 4) renderVisibleLights[$] = o;
        }
        renderVisibleCids[$] = o;
      }
    }
    //writeln("::: ", cnt, " invisible objects dropped");

    renderVisibleCids.sort(&renderSortByDepth);
    lastRenderTime = time;
  }

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

  // render objects (part one: depth > 3)
  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 object (part two: front tile parts, depth 3.5)
  foreach (MapTile tile; renderFrontTiles) {
    tile.drawWithOfsFront(xofs, yofs, scale, currFrameDelta);
  }

  // render objects (part three: depth <= 3)
  foreach (auto idx; 0..depth4Start; reverse) {
    MapEntity o = renderVisibleCids[idx];
    o.drawWithOfs(xofs, yofs, scale, currFrameDelta);
    //done above;if (isDarkLevel && (o.lightRadius > 4 || (o isa MapTile && MapTile(o).litWholeTile))) renderVisibleLights[$] = o;
  }

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

  // lighting
  if (isDarkLevel) {
    auto ltex = bgtileStore.lightTexture('ltx512', 512);

    // set screen alpha to min
    Video.colorMask = Video::CMask.Alpha;
    Video.blendMode = Video::BlendMode.None;
    Video.color = 0xff_ff_ff_ff;
    Video.fillRect(0, 0, Video.screenWidth, Video.screenHeight);
    //Video.colorMask = Video::CMask.All;

    // blend lights
    // also, stencil 'em, so we can filter dark areas
    Video.textureFiltering = true;
    Video.stencil = true;
    Video.stencilFunc(Video::StencilFunc.Always, 1);
    Video.stencilOp(Video::StencilOp.Keep, Video::StencilOp.Replace);
    Video.alphaTestFunc = Video::AlphaFunc.Greater;
    Video.alphaTestVal = 0.03;
    Video.color = 0xff_ff_ff;
    Video.blendFunc = Video::BlendFunc.Max;
    Video.blendMode = Video::BlendMode.Blend; // anything except `Normal`
    Video.colorMask = Video::CMask.Alpha;

    foreach (MapEntity e; renderVisibleLights) {
      int xi, yi;
      e.getInterpCoords(currFrameDelta, scale, out xi, out yi);
      auto tile = MapTile(e);
      if (tile && tile.litWholeTile) {
        //Video.color = 0xff_ff_ff;
        Video.fillRect(xi-xofs, yi-yofs, e.width*scale, e.height*scale);
      }
      int lrad = e.lightRadius;
      if (lrad < 4) continue; // just in case
      lrad += 8;
      float lightscale = float(lrad*scale)/float(ltex.tex.width);
#ifdef OLD_LIGHT_OFFSETS
      int fx0, fy0, fx1, fy1;
      bool doMirror;
      auto spf = e.getSpriteFrame(out doMirror, out fx0, out fy0, out fx1, out fy1);
      if (spf) {
        xi += (fx1-fx0)*scale/2;
        yi += (fy1-fy0)*scale/2;
      }
#else
      int lxofs, lyofs;
      e.getLightOffset(out lxofs, out lyofs);
      xi += lxofs*scale;
      yi += lyofs*scale;

#endif
      lrad = lrad*scale/2;
      xi -= xofs+lrad;
      yi -= yofs+lrad;
      ltex.tex.blitAt(xi, yi, lightscale);
    }
    Video.textureFiltering = false;

    // modify only lit parts
    Video.stencilFunc(Video::StencilFunc.Equal, 1);
    Video.stencilOp(Video::StencilOp.Keep, Video::StencilOp.Keep);
    // multiply framebuffer colors by framebuffer alpha
    Video.color = 0xff_ff_ff; // it doesn't matter
    Video.blendFunc = Video::BlendFunc.Add;
    Video.blendMode = Video::BlendMode.DstMulDstAlpha;
    Video.colorMask = Video::CMask.Colors;
    Video.fillRect(0, 0, Video.screenWidth, Video.screenHeight);

    // filter unlit parts
    Video.stencilFunc(Video::StencilFunc.NotEqual, 1);
    Video.stencilOp(Video::StencilOp.Keep, Video::StencilOp.Keep);
    Video.blendFunc = Video::BlendFunc.Add;
    Video.blendMode = Video::BlendMode.Filter;
    Video.colorMask = Video::CMask.Colors;
    Video.color = 0x00_00_18;
    Video.fillRect(0, 0, Video.screenWidth, Video.screenHeight);

    // restore defaults
    Video.blendFunc = Video::BlendFunc.Add;
    Video.blendMode = Video::BlendMode.Normal;
    Video.colorMask = Video::CMask.All;
    Video.alphaTestFunc = Video::AlphaFunc.Always;
    Video.stencil = false;
  }

  // clear visible objects list (nope)
  //renderVisibleCids.clear();
  //renderVisibleLights.clear();


  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, 0x00_ff_00, 0xff_ff_ff);
    Video.color = oldColor;
  }

  if (inWinCutscene) renderWinCutsceneOverlay();
  Video.color = 0xff_ff_ff;
}


// ////////////////////////////////////////////////////////////////////////// //
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;
  foreach (MapObject obj; objGrid.allObjects(MapObject)) {
    if (obj.spectral) continue;
    if (obj isa cls) return obj;
  }
  return none;
}


// ////////////////////////////////////////////////////////////////////////// //
final bool isRopePlacedAt (int x, int y) {
  int[8] covered;
  foreach (ref auto v; covered) v = false;
  foreach (MapTile t; objGrid.inRectPix(x, y-8, 1, 17, precise:false, castClass:MapTileRope)) {
    //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;
}


final MapTile CreateMapTile (int xpos, int ypos, name aname) {
  if (!aname) FatalError("cannot create typeless tile");
  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;
  tile.objId = ++lastUsedObjectId;
  if (!tile.initialize()) FatalError("cannot create tile '%n'", aname);
  return tile;
}


final bool PutSpawnedMapTile (int x, int y, MapTile tile, optional bool putToGrid) {
  if (!tile || !tile.isInstanceAlive) return false;

  if (!putToGrid) putToGrid = (tile.moveable || tile.toSpecialGrid || tile.width != 16 || tile.height != 16 || x%16 != 0 || y%16 != 0);

  //writeln("putting tile(", GetClassName(tile.Class), "): '", tile.objType, ":", tile.objName, "' at ", (putToGrid ? "special " : ""), "grid, pos=(", x/16.0, ",", y/16.0, ")");

  if (!putToGrid) {
    int mapx = x/16, mapy = y/16;
    if (mapx < 0 || mapx >= tilesWidth || mapy < 0 || mapy >= tilesHeight) return false;
  }

  // if we already have rope tile there, there is no reason to add another one
  if (tile isa MapTileRope) {
    if (isRopePlacedAt(x, y)) return false;
  }

  // activate special or animated tile
  tile.active = tile.active || putToGrid || tile.moveable || tile.toSpecialGrid || tile.lava /*|| tile.water*/; // will be done in MakeMapTile
  // animated tiles must be active
  if (!tile.active) {
    auto spr = tile.getSprite();
    if (spr && spr.frames.length > 1) {
      writeln("activated animated tile '", tile.objName, "'");
      tile.active = true;
    }
  }

  tile.fltx = x;
  tile.flty = y;
  if (putToGrid) {
    //if (tile isa TitleTileCopy) writeln("*** PUTTING COPYRIGHT TILE");
    tile.toSpecialGrid = true;
    if (!tile.dontReplaceOthers && x&16 == 0 && y%16 == 0) {
      auto t = getTileAtGridAny(x/16, y/16);
      if (t && !t.immuneToReplacement) {
        writeln("REPLACING tile(", GetClassName(t.Class), "): '", t.objType, ":", t.objName, "' at ", (t.toSpecialGrid ? "special " : ""), "grid, pos=(", t.fltx/16.0, ",", t.flty/16.0, ")");
        writeln("      NEW tile(", GetClassName(tile.Class), "): '", tile.objType, ":", tile.objName, "' at ", (tile.toSpecialGrid ? "special " : ""), "grid, pos=(", tile.fltx/16.0, ",", tile.flty/16.0, ")");
        t.instanceRemove();
      }
    }
    objGrid.insert(tile);
  } else {
    //writeln("SIZE: ", tilesWidth, "x", tilesHeight);
    setTileAtGrid(x/16, y/16, tile);
    auto t = getTileAtGridAny(x/16, y/16);
    /*
    if (t != tile) {
      writeln("putting tile(", GetClassName(tile.Class), "): '", tile.objType, ":", tile.objName, "' at ", (putToGrid ? "special " : ""), "grid, pos=(", x/16.0, ",", y/16.0, ")");
      checkTilesInRect(x/16, y/16, 16, 16, delegate bool (MapTile tile) {
        writeln("  *** tile(", GetClassName(tile.Class), "): '", tile.objType, ":", tile.objName, "' at ", (tile.toSpecialGrid || tile.moveable ? "special " : ""), "grid, pos=(", tile.fltx/16.0, ",", tile.flty/16.0, ")");
        return false;
      });
      FatalError("FUUUUUU");
    }
    */
  }

  if (tile.enter) registerEnter(tile);
  if (tile.exit) registerExit(tile);

  return true;
}


// won't call `onDestroy()`
final void RemoveMapTileFromGrid (int tileX, int tileY, optional string reason) {
  if (tileX >= 0 & tileY >= 0 && tileX < tilesWidth && tileY < tilesHeight) {
    auto t = getTileAtGridAny(tileX, tileY);
    if (t) {
      writeln("REMOVING(RMT", (reason ? ":"~reason : ""), ") tile(", GetClassName(t.Class), "): '", t.objType, ":", t.objName, "' at ", (t.toSpecialGrid ? "special " : ""), "grid, pos=(", t.fltx/16.0, ",", t.flty/16.0, ")");
      t.instanceRemove();
      checkWater = true;
    }
  }
}


final MapTile MakeMapTile (int mapx, int mapy, name aname, optional bool putToGrid) {
  //if (mapy >= tilesHeight) { writeln("OOM: ", aname, "; ty=", mapy, "; hgt=", tilesHeight); }
  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)) return none;
  }

  auto tile = CreateMapTile(mapx*16, mapy*16, aname);
  if (!tile) return none;
  if (!PutSpawnedMapTile(mapx*16, mapy*16, tile, putToGrid!optional)) {
    delete tile;
    tile = none;
  }

  return tile;
}


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


final MapTile MakeMapTileAtPix (int xpix, int ypix, name aname, optional bool putToGrid) {
  // if we already have rope tile there, there is no reason to add another one
  if (aname == 'oRope') {
    if (isRopePlacedAt(xpix, ypix)) return none;
  }

  auto tile = CreateMapTile(xpix, ypix, aname);
  if (!tile) return none;
  if (!PutSpawnedMapTile(xpix, ypix, tile, putToGrid!optional)) {
    delete tile;
    tile = none;
  }

  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)) return none;

  auto tile = CreateMapTile(x0, y0, 'oRope');
  if (!PutSpawnedMapTile(x0, y0, tile, putToGrid:true)) {
    delete tile;
    tile = none;
  }

  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;
  obj.objId = ++lastUsedObjectId;

  return obj;
}


final MapObject SpawnMapObject (name aname) {
  if (!aname) return none;
  auto res = SpawnMapObjectWithClass(findGameObjectClassByName(aname));
  if (res && !res.objType) res.objType = aname; // just in case
  return res;
}


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;
}


// ////////////////////////////////////////////////////////////////////////// //
int winCutSceneTimer = -1;
int winVolcanoTimer = -1;
int winCutScenePhase = 0;
int winSceneDrawStatus = 0;
int winMoneyCount = 0;
int winTime;
bool winFadeOut = false;
int winFadeLevel = 0;
int winCutsceneSkip = 0; // 1: waiting for pay release; 2: pay released, do skip
bool winCutsceneSwitchToNext = false;


void startWinCutscene () {
  global.hasParachute = false;
  shakeLeft = 0;
  winCutsceneSwitchToNext = false;
  winCutsceneSkip = 0;
  isKeyPressed(GameConfig::Key.Pay);
  isKeyReleased(GameConfig::Key.Pay);

  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearWholeLevel();

  createEnd1Room();
  fixWallTiles();
  addBackgroundGfxDetails();

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

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

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

  if (dumpGridStats) objGrid.dumpStats();

  playerExited = false; // just in case
  playerExitDoor = none;

  osdClear();

  setupGhostTime();
  global.stopMusic();

  inWinCutscene = 1;
  winCutSceneTimer = -1;
  winCutScenePhase = 0;

  /+
  if (global.config.gameMode != GameConfig::GameMode.Vanilla) {
    if (global.config.bizarre) {
      global.yasmScore = 1;
      global.config.bizarrePlusTitle = true;
    }

    array!MapTile toReplace;
    forEachTile(delegate bool (MapTile t) {
      if (t.objType == 'oGTemple' ||
          t.objType == 'oIce' ||
          t.objType == 'oDark' ||
          t.objType == 'oBrick' ||
          t.objType == 'oLush')
      {
        toReplace[$] = t;
      }
      return false;
    });

    foreach (MapTile t; miscTileGrid.allObjects()) {
      if (t.objType == 'oGTemple' ||
          t.objType == 'oIce' ||
          t.objType == 'oDark' ||
          t.objType == 'oBrick' ||
          t.objType == 'oLush')
      {
        toReplace[$] = t;
      }
    }

    foreach (MapTile t; toReplace) {
      if (t.iy < 192) {
        t.cleanDeath = true;
            if (rand(1,120) == 1) instance_change(oGTemple, false);
        else if (rand(1,100) == 1) instance_change(oIce, false);
        else if (rand(1,90) == 1) instance_change(oDark, false);
        else if (rand(1,80) == 1) instance_change(oBrick, false);
        else if (rand(1,70) == 1) instance_change(oLush, false);
          }
      }
      with (oBrick)
      {
          if (y &lt; 192)
          {
              cleanDeath = true;
              if (rand(1,5) == 1) instance_change(oLush, false);
          }
      }
  }
  +/
  //!instance_create(0, 0, oBricks);

  //shakeToggle = false;
  //oPDummy.status = 2;

  //timer = 0;

  /+
  if (global.kaliPunish &gt;= 2) {
      instance_create(oPDummy.x, oPDummy.y+2, oBall2);
      obj = instance_create(oPDummy.x, oPDummy.y, oChain2);
      obj.linkVal = 1;
      obj = instance_create(oPDummy.x, oPDummy.y, oChain2);
      obj.linkVal = 2;
      obj = instance_create(oPDummy.x, oPDummy.y, oChain2);
      obj.linkVal = 3;
      obj = instance_create(oPDummy.x, oPDummy.y, oChain2);
      obj.linkVal = 4;
  }
  +/
}


void startWinCutsceneVolcano () {
  global.hasParachute = false;
  /*
  writeln("VOLCANO HOLD 0: ", (player.holdItem ? GetClassName(player.holdItem.Class) : ''));
  writeln("VOLCANO PICK 0: ", (player.pickedItem ? GetClassName(player.pickedItem.Class) : ''));
  */

  shakeLeft = 0;
  winCutsceneSwitchToNext = false;
  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearWholeLevel();

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

  blockWaterChecking = true;

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

  spawnPlayerAt(2*16+8, 11*16+8);
  player.dir = MapEntity::Dir.Right;

  playerExited = false; // just in case
  playerExitDoor = none;

  osdClear();

  setupGhostTime();
  global.stopMusic();

  inWinCutscene = 2;
  winCutSceneTimer = -1;
  winCutScenePhase = 0;

  MakeMapTile(0, 0, 'oEnd2BG');
  realViewStart.x = 0;
  realViewStart.y = 0;
  viewStart.x = 0;
  viewStart.y = 0;

  viewMin.x = 0;
  viewMin.y = 0;
  viewMax.x = 320;
  viewMax.y = 240;

  player.dead = false;
  player.active = true;
  player.visible = false;
  player.removeBallAndChain(temp:true);
  player.stunned = false;
  player.status = MapObject::FALLING;
  if (player.holdItem) player.holdItem.visible = false;
  player.fltx = 320/2;
  player.flty = 0;

  /*
  writeln("VOLCANO HOLD 1: ", (player.holdItem ? GetClassName(player.holdItem.Class) : ''));
  writeln("VOLCANO PICK 1: ", (player.pickedItem ? GetClassName(player.pickedItem.Class) : ''));
  */
}


void startWinCutsceneWinFall () {
  global.hasParachute = false;
  /*
  writeln("FALL HOLD 0: ", (player.holdItem ? GetClassName(player.holdItem.Class) : ''));
  writeln("FALL PICK 0: ", (player.pickedItem ? GetClassName(player.pickedItem.Class) : ''));
  */

  shakeLeft = 0;
  winCutsceneSwitchToNext = false;

  auto olddel = ImmediateDelete;
  ImmediateDelete = false;
  clearWholeLevel();

  createEnd3Room();
  setMenuTilesVisible(false);
  //fixWallTiles();
  //addBackgroundGfxDetails();

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

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

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

  if (dumpGridStats) objGrid.dumpStats();

  playerExited = false; // just in case
  playerExitDoor = none;

  osdClear();

  setupGhostTime();
  global.stopMusic();

  inWinCutscene = 3;
  winCutSceneTimer = -1;
  winCutScenePhase = 0;

  player.dead = false;
  player.active = true;
  player.visible = false;
  player.removeBallAndChain(temp:true);
  player.stunned = false;
  player.status = MapObject::FALLING;
  if (player.holdItem) player.holdItem.visible = false;
  player.fltx = 320/2;
  player.flty = 0;

  winSceneDrawStatus = 0;
  winMoneyCount = 0;

  winFadeOut = false;
  winFadeLevel = 0;

  /*
  writeln("FALL HOLD 1: ", (player.holdItem ? GetClassName(player.holdItem.Class) : ''));
  writeln("FALL PICK 1: ", (player.pickedItem ? GetClassName(player.pickedItem.Class) : ''));
  */
}


void setGameOver () {
  if (inWinCutscene) {
    player.visible = false;
    player.removeBallAndChain(temp:true);
    if (player.holdItem) player.holdItem.visible = false;
  }
  player.dead = true;
  if (inWinCutscene > 0) {
    winFadeOut = true;
    winFadeLevel = 255;
    winSceneDrawStatus = 8;
  }
}


MapTile findEndPlatTile () {
  return forEachTile(delegate bool (MapTile t) { return (t isa MapTileEndPlat); }, castClass:MapTileEndPlat);
}


MapObject findBigTreasure () {
  return forEachObject(delegate bool (MapObject o) { return (o isa MapObjectBigTreasure); }, castClass:MapObjectBigTreasure);
}


void setMenuTilesVisible (bool vis) {
  if (vis) {
    forEachTile(delegate bool (MapTile t) {
      if (t isa TitleTileBlack || t isa TitleTileSpecialNonSolidInvincible) {
        t.invisible = false;
      }
      return false;
    });
  } else {
    forEachTile(delegate bool (MapTile t) {
      if (t isa TitleTileBlack || t isa TitleTileSpecialNonSolidInvincible) {
        t.invisible = true;
      }
      return false;
    });
  }
}


void setMenuTilesOnTop () {
  forEachTile(delegate bool (MapTile t) {
    if (t isa TitleTileBlack || t isa TitleTileSpecialNonSolidInvincible) {
      t.depth = 1;
    }
    return false;
  });
}


void winCutscenePlayerControl (PlayerPawn plr) {
  auto payPress = isKeyPressed(GameConfig::Key.Pay);
  auto payRelease = isKeyReleased(GameConfig::Key.Pay);

  switch (winCutsceneSkip) {
    case 0: // nothing was pressed
      if (payPress) winCutsceneSkip = 1;
      break;
    case 1: // waiting for pay release
      if (payRelease) winCutsceneSkip = 2;
      break;
    case 2: // pay released, do skip
      setGameOver();
      return;
  }

  // first winning room
  if (inWinCutscene == 1) {
    if (plr.ix < 448+8) {
      plr.kRight = true;
      return;
    }

    // waiting for chest to open
    if (winCutScenePhase == 0) {
      winCutSceneTimer = 120/2;
      winCutScenePhase = 1;
      return;
    }

    // spawn big idol
    if (winCutScenePhase == 1) {
      if (--winCutSceneTimer == 0) {
        winCutScenePhase = 2;
        winCutSceneTimer = 20;
        forEachObject(delegate bool (MapObject o) {
          if (o isa MapObjectBigChest) {
            o.setSprite(global.config.gameMode == GameConfig::GameMode.Vanilla ? 'sBigChestOpen' : 'sBigChestOpen2');
            auto treasure = MakeMapObject(o.ix, o.iy, 'oBigTreasure');
            if (treasure) {
              treasure.yVel = -4;
              treasure.xVel = -3;
              o.playSound('sndClick');
              //!!!if (global.config.gameMode != GameConfig::GameMode.Vanilla) scrSprayGems(oBigChest.x+24, oBigChest.y+24);
            }
          }
          return false;
        });
      }
      return;
    }

    // lava pump wait
    if (winCutScenePhase == 2) {
      if (--winCutSceneTimer == 0) {
        winCutScenePhase = 3;
        winCutSceneTimer = 50;
      }
      return;
    }

    // lava pump start
    if (winCutScenePhase == 3) {
      auto ep = findEndPlatTile();
      if (ep) MakeMapObject(ep.ix+global.randOther(0, 80), /*ep.iy*/192+32, 'oBurn');
      if (--winCutSceneTimer == 0) {
        winCutScenePhase = 4;
        winCutSceneTimer = 10;
        if (ep) MakeMapObject(ep.ix, ep.iy+30, 'oLavaSpray');
        scrShake(9999);
      }
      return;
    }

    // lava pump first accel
    if (winCutScenePhase == 4) {
      if (--winCutSceneTimer == 0) {
        forEachObject(delegate bool (MapObject o) {
          if (o isa MapObjectLavaSpray) o.yAcc = -0.1;
          return false;
        });
      }
    }

    // lava pump complete
    if (winCutScenePhase == 5) {
      if (--winCutSceneTimer == 0) {
        //if (oLavaSpray) oLavaSpray.yAcc = -0.1;
        startWinCutsceneVolcano();
      }
      return;
    }
    return;
  }


  // volcano room
  if (inWinCutscene == 2) {
    plr.flty = 0;

    // initialize
    if (winCutScenePhase == 0) {
      winCutSceneTimer = 50;
      winCutScenePhase = 1;
      winVolcanoTimer = 10;
      return;
    }

    if (winVolcanoTimer > 0) {
      if (--winVolcanoTimer == 0) {
        MakeMapObject(224+global.randOther(0,48), 144+global.randOther(0,8), 'oVolcanoFlame');
        winVolcanoTimer = global.randOther(10, 20);
      }
    }

    // plr sil
    if (winCutScenePhase == 1) {
      if (--winCutSceneTimer == 0) {
        winCutSceneTimer = 30;
        winCutScenePhase = 2;
        auto sil = MakeMapObject(240, 132, 'oPlayerSil');
        //sil.xVel = -6;
        //sil.yVel = -8;
      }
      return;
    }

    // treasure sil
    if (winCutScenePhase == 2) {
      if (--winCutSceneTimer == 0) {
        winCutScenePhase = 3;
        auto sil = MakeMapObject(240, 132, 'oTreasureSil');
        //sil.xVel = -6;
        //sil.yVel = -8;
      }
      return;
    }

    return;
  }

  // winning camel room
  if (inWinCutscene == 3) {
    //if (!player.holdItem)  writeln("SCENE 3: LOST ITEM!");

    if (!plr.visible) plr.flty = -32;

    // initialize
    if (winCutScenePhase == 0) {
      winCutSceneTimer = 50;
      winCutScenePhase = 1;
      return;
    }

    // fall sound
    if (winCutScenePhase == 1) {
      if (--winCutSceneTimer == 0) {
        winCutSceneTimer = 50;
        winCutScenePhase = 2;
        plr.playSound('sndPFall');
        plr.visible = true;
        plr.active = true;
        writeln("MUST BE CHAINED: ", plr.mustBeChained);
        if (plr.mustBeChained) {
          plr.removeBallAndChain(temp:true);
          plr.spawnBallAndChain();
        }
        /*
        writeln("HOLD: ", (player.holdItem ? GetClassName(player.holdItem.Class) : ''));
        writeln("PICK: ", (player.pickedItem ? GetClassName(player.pickedItem.Class) : ''));
        */
        if (!player.holdItem && player.pickedItem) player.scrSwitchToPocketItem(forceIfEmpty:false);
        if (player.holdItem) {
          player.holdItem.visible = true;
          player.holdItem.canLiveOutsideOfLevel = true;
          writeln("HOLD ITEM: '", GetClassName(player.holdItem.Class), "'");
        }
        plr.status == MapObject::FALLING;
        global.plife += 99; // just in case
      }
      return;
    }

    if (winCutScenePhase == 2) {
      auto ball = plr.getMyBall();
      if (ball && plr.holdItem != ball) {
        ball.teleportTo(plr.fltx, plr.flty+8);
        ball.yVel = 6;
        ball.myGrav = 0.6;
      }
      if (plr.status == MapObject::STUNNED || plr.stunned) {
        //alarm[0] = 70;
        //alarm[1] = 50;
        //status = GETUP;
        auto treasure = MakeMapObject(144+16+8, -32, 'oBigTreasure');
        if (treasure) treasure.depth = 1;
        winCutScenePhase = 3;
        plr.stunTimer = 30;
        plr.playSound('sndTFall');
      }
      return;
    }

    if (winCutScenePhase == 3) {
      if (plr.status != MapObject::STUNNED && !plr.stunned) {
        auto bt = findBigTreasure();
        if (bt) {
          if (bt.yVel == 0) {
            //plr.yVel = -4;
            //plr.status = MapObject::JUMPING;
            plr.kJump = true;
            plr.kJumpPressed = true;
            winCutScenePhase = 4;
            winCutSceneTimer = 50;
          }
        }
      }
      return;
    }

    if (winCutScenePhase == 4) {
      if (--winCutSceneTimer == 0) {
        setMenuTilesVisible(true);
        winCutScenePhase = 5;
        winSceneDrawStatus = 1;
        global.playMusic('musVictory', loop:false);
        winCutSceneTimer = 50;
      }
      return;
    }

    if (winCutScenePhase == 5) {
      if (winSceneDrawStatus == 3) {
        int money = stats.money;
        if (winMoneyCount < money) {
          if (money-winMoneyCount > 1000) {
            winMoneyCount += 1000;
          } else if (money-winMoneyCount > 100) {
            winMoneyCount += 100;
          } else if (money-winMoneyCount > 10) {
            winMoneyCount += 10;
          } else {
            ++winMoneyCount;
          }
        }
        if (winMoneyCount >= money) {
          winMoneyCount = money;
          ++winSceneDrawStatus;
        }
        return;
      }

      if (winSceneDrawStatus == 7) {
        winFadeOut = true;
        winFadeLevel += 1;
        if (winFadeLevel >= 255) {
          ++winSceneDrawStatus;
          winCutSceneTimer = 30*30;
        }
        return;
      }

      if (winSceneDrawStatus == 8) {
        if (--winCutSceneTimer == 0) {
          setGameOver();
        }
        return;
      }

      if (--winCutSceneTimer == 0) {
        ++winSceneDrawStatus;
        winCutSceneTimer = 50;
      }
    }

    return;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
void renderWinCutsceneOverlay () {
  if (inWinCutscene == 3) {
    if (winSceneDrawStatus > 0) {
      Video.color = 0xff_ff_ff;
      sprStore.loadFont('sFont'); //draw_set_font(global.myFont);
      //draw_set_color(txtCol);
      drawTextAt(64, 32, "YOU MADE IT!");

      sprStore.loadFont('sFontSmall'); //draw_set_font(global.myFontSmall);
      if (global.config.gameMode == GameConfig::GameMode.Vanilla) {
        Video.color = 0xff_ff_00; //draw_set_color(c_yellow);
        drawTextAt(64, 48, "Classic Mode done!");
      } else {
        Video.color = 0x00_80_80; //draw_set_color(c_teal);
        if (global.config.bizarrePlus) drawTextAt(64, 48, "Bizarre Mode Plus done!");
        else drawTextAt(64, 48, "Bizarre Mode done!");
        //draw_set_color(c_white);
      }
      if (!global.usedShortcut) {
        Video.color = 0xc0_c0_c0; //draw_set_color(c_silver);
        drawTextAt(64, 56, "No shortcuts used!");
        //draw_set_color(c_yellow);
      }
    }

    if (winSceneDrawStatus > 1) {
      sprStore.loadFont('sFontSmall'); //draw_set_font(global.myFontSmall);
      //draw_set_color(txtCol);
      Video.color = 0xff_ff_ff;
      drawTextAt(64, 64, "FINAL SCORE:");
    }

    if (winSceneDrawStatus > 2) {
      sprStore.loadFont('sFont'); //draw_set_font(global.myFont);
      Video.color = 0xff_ff_ff; //draw_set_color(c_white);
      drawTextAt(64, 72, va("$%d", winMoneyCount));
    }

    if (winSceneDrawStatus > 4) {
      sprStore.loadFont('sFontSmall'); //draw_set_font(global.myFontSmall);
      Video.color = 0xff_ff_ff; //draw_set_color(c_white);
      drawTextAt(64, 96, va("Time: %s", time2str(winTime/30)));
      /*
      draw_set_color(c_white);
      if (s &lt; 10) draw_text(96+24, 96, string(m) + ":0" + string(s));
      else draw_text(96+24, 96, string(m) + ":" + string(s));
      */
    }

    if (winSceneDrawStatus > 5) {
      sprStore.loadFont('sFontSmall'); //draw_set_font(global.myFontSmall);
      Video.color = 0xff_ff_ff; //draw_set_color(txtCol);
      drawTextAt(64, 96+8, "Kills: ");
      Video.color = 0xff_ff_ff; //draw_set_color(c_white);
      drawTextAt(96+24, 96+8, va("%s", stats.countKills()));
    }

    if (winSceneDrawStatus > 6) {
      sprStore.loadFont('sFontSmall'); //draw_set_font(global.myFontSmall);
      Video.color = 0xff_ff_ff; //draw_set_color(txtCol);
      drawTextAt(64, 96+16, "Saves: ");
      Video.color = 0xff_ff_ff; //draw_set_color(c_white);
      drawTextAt(96+24, 96+16, va("%s", stats.damselsSaved));
    }

    if (winFadeOut) {
      Video.color = (255-clamp(winFadeLevel, 0, 255))<<24;
      Video.fillRect(0, 0, Video.screenWidth, Video.screenHeight);
    }

    if (winSceneDrawStatus == 8) {
      sprStore.loadFont('sFontSmall'); //draw_set_font(global.myFontSmall);
      Video.color = 0xff_ff_ff; //draw_set_color(c_white);
      string lastString;
      if (global.config.gameMode == GameConfig::GameMode.Vanilla) {
        Video.color = 0xff_ff_00; //draw_set_color(c_yellow);
        lastString = "YOU SHALL BE REMEMBERED AS A HERO.";
      } else {
        Video.color = 0x00_ff_ff;
        if (global.config.bizarrePlus) lastString = "ANOTHER LEGENDARY ADVENTURE!";
        else lastString = "YOUR DISCOVERIES WILL BE CELEBRATED!";
      }
      auto strLen = lastString.length*8;
      int n = 320-strLen;
      n = trunc(ceil(n/2.0));
      drawTextAt(n, 116, lastString);
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
#include "roomTitle.vc"
#include "roomTrans1.vc"
#include "roomTrans2.vc"
#include "roomTrans3.vc"
#include "roomTrans4.vc"
#include "roomOlmec.vc"
#include "roomEnd.vc"
#include "roomTutorial.vc"
#include "roomScores.vc"
#include "roomStars.vc"
#include "roomSun.vc"
#include "roomMoon.vc"


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