fixed current level number on transition screen

[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 gameShowHelp = false;
transient int gameHelpScreen = 0;
const int MaxGameHelpScreen = 2;
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;
transient int pausedTime;

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-%02d-%02d %02d:%02d", BuildYear, BuildMonth, BuildDay, BuildHour, 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); }
final bool isTransitionRoom () { return (levelKind == LevelKind.Transition); }

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 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:%02d:%02d", days, hours, mins, secs);
  if (hours) return va("%d:%02d:%02d", hours, mins, secs);
  return va("%02d:%02d", mins, 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;

  resetTransitionOverlay();

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

  if (global.cityOfGold == 1) {
    lg.mapSprite = 'sMapTemple';
    lg.mapTitle = "City of Gold";
  } else if (global.blackMarket) {
    lg.mapSprite = 'sMapJungle';
    lg.mapTitle = "Black Market";
  }
}


// ////////////////////////////////////////////////////////////////////////// //
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.config.ghostAtFirstLevel && 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;
    case LevelKind.Transition: thinkFrameTransition(); 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);
}


// ////////////////////////////////////////////////////////////////////////// //
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) {
          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;
  foreach (MapTile t; objGrid.allObjects(MapTile)) {
    if (!t.water && !t.lava) continue;

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

    //if (global.lake == 1) continue; // 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');
    }
  }
  //writeln("liquid tiles count: ", liquidTileCount);
}


// ////////////////////////////////////////////////////////////////////////// //
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) {
    if (wtile.iy >= GreatLakeStartTileY*16) return false; // lake tile, don't touch
    if (wtile.iy >= GreatLakeStartTileY*16-16) return true; // remove it, so it won't stack on a lake
  }

  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) {
    ++pausedTime;
    if (onBeforeFrame) onBeforeFrame(false);
    if (onAfterFrame) onAfterFrame(false);
    keysNextFrame();
    return;
  } else {
    pausedTime = 0;
  }
  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,
                                optional class!MapTile castClass)
{
  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 (!castClass) castClass = MapTile;
  if (!dg) dg = &cbCollisionAnySolid;

  // check walkable solid objects too
  foreach (MapEntity e; objGrid.inRectPix(x0, y0, w, h, precise:precise, castClass:castClass)) {
    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, optional class!MapTile castClass) {
  if (x0 < 0 || y0 < 0 || x0 >= tilesWidth*16 || y0 >= tilesHeight*16) return none;
  if (!specified_precise) precise = true;
  if (!castClass) castClass = MapTile;
  if (!dg) dg = &cbCollisionAnySolid;

  // check walkable solid objects
  foreach (MapEntity e; objGrid.inCellPix(x0, y0, precise:precise, castClass:castClass)) {
    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);
  }
}


final void drawSpriteAtS3 (name sprName, float frnumf, int x0, int y0) {
  if (!sprName) return;
  auto spr = sprStore[sprName];
  if (!spr || !spr.frames.length) return;
  x0 *= 3;
  y0 *= 3;
  int frnum = max(0, trunc(frnumf))%spr.frames.length;
  auto sfr = spr.frames[frnum];
  int sx0 = x0-sfr.xofs*3;
  int sy0 = y0-sfr.yofs*3;
  sfr.tex.blitAt(sx0, sy0, 3);
}


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


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);
    }
    break; // only the first exit
  }
}


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


// ////////////////////////////////////////////////////////////////////////// //
// x0 and y0 are non-scaled (and will be scaled)
final void drawTextAtS3 (int x0, int y0, string text, optional int hiColor1, optional int hiColor2) {
  if (!text) return;
  x0 *= 3;
  y0 *= 3;
  sprStore.renderTextWithHighlight(x0, y0, text, 3, hiColor1!optional, hiColor2!optional);
}


final void drawTextAtS3Centered (int y0, string text, optional int hiColor1, optional int hiColor2) {
  if (!text) return;
  int x0 = (Video.screenWidth-sprStore.getTextWidth(text, 3, specified_hiColor1, specified_hiColor2))/2;
  sprStore.renderTextWithHighlight(x0, y0*3, text, 3, hiColor1!optional, hiColor2!optional);
}


void renderHelpOverlay () {
  Video.color = 0;
  Video.fillRect(0, 0, Video.screenWidth, Video.screenHeight);

  int tx = 16;
  int txoff = 0; // text x pos offset (for multi-color lines)
  int ty = 8;
  if (gameHelpScreen) {
    sprStore.loadFont('sFontSmall');
    Video.color = 0xff_ff_ff;
    drawTextAtS3Centered(ty, va("HELP (PAGE ~%d~ OF ~%d~)", gameHelpScreen, MaxGameHelpScreen), 0xff_ff_00);
    ty += 24;
  }

  if (gameHelpScreen == 1) {
    sprStore.loadFont('sFontSmall');
    Video.color = 0xff_ff_00; drawTextAtS3(tx, ty, "INVENTORY BASICS"); ty += 16;
    Video.color = 0xff_ff_ff;
    drawTextAtS3(tx, ty, global.expandString("Press $SWITCH to cycle through items."), 0x00_ff_00);
    ty += 8;
    ty += 56;
    Video.color = 0xff_ff_ff;
    drawSpriteAtS3('sHelpSprite1', -1, 64, 96);
  } else if (gameHelpScreen == 2) {
    sprStore.loadFont('sFontSmall');
    Video.color = 0xff_ff_00;
    drawTextAtS3(tx, ty, "SELLING TO SHOPKEEPERS"); ty += 16;
    Video.color = 0xff_ff_ff;
    drawTextAtS3(tx, ty, global.expandString("Press $PAY to offer your currently"), 0x00_ff_00); ty += 8;
    drawTextAtS3(tx, ty, "held item to the shopkeeper."); ty += 16;
    drawTextAtS3(tx, ty, "If the shopkeeper is interested, "); ty += 8;
    //drawTextAtS3(tx, ty, global.expandString("press $PAY again to complete the sale."), 0x00_ff_00); ty += 72;
    drawTextAtS3(tx, ty, global.expandString("press $PAY again to complete"), 0x00_ff_00);
    drawTextAtS3(tx, ty+8, "the sale.");
    ty += 72;
    drawSpriteAtS3('sHelpSell', -1, 112, 100);
    drawTextAtS3(tx, ty, "Purchasing goods from the shopkeeper"); ty += 8;
    drawTextAtS3(tx, ty, "will increase the funds he has"); ty += 8;
    drawTextAtS3(tx, ty, "available to buy your unwanted stuff."); ty += 8;
  } else {
    // map
    sprStore.loadFont('sFont');
    Video.color = 0xff_ff_ff;
    drawTextAtS3(136, 8, "MAP");

    Video.color = 0xff_ff_00;
    drawTextAtS3Centered(24, lg.mapTitle);

    if (lg.mapSprite) {
      auto spf = sprStore[lg.mapSprite].frames[0];
      int mapX = 160-spf.width/2;
      int mapY = 120-spf.height/2;
      //mapTitleX = 160-string_length(global.mapTitle)*8/2;

      Video.color = 0xff_ff_ff;
      drawSpriteAtS3(lg.mapSprite, -1, mapX, mapY);

      if (lg.mapSprite != 'sMapDefault') {
        int mx = -1, my = -1;

        // set position of player icon
        switch (global.currLevel) {
          case 1: mx = 81; my = 22; break;
          case 2: mx = 113; my = 63; break;
          case 3: mx = 197; my = 86; break;
          case 4: mx = 133; my = 109; break;
          case 5: mx = 181; my = 22; break;
          case 6: mx = 126; my = 64; break;
          case 7: mx = 158; my = 112; break;
          case 8: mx = 66; my = 80; break;
          case 9: mx = 30; my = 26; break;
          case 10: mx = 88; my = 54; break;
          case 11: mx = 148; my = 81; break;
          case 12: mx = 210; my = 205; break;
          case 13: mx = 66; my = 17; break;
          case 14: mx = 146; my = 17; break;
          case 15: mx = 82; my = 77; break;
          case 16: mx = 178; my = 81; break;
        }

        if (mx >= 0) {
          int plrx = mx+player.ix/16;
          int plry = my+player.iy/16;
          name plrspr = 'sMapSpelunker';
               if (global.isDamsel) plrspr = 'sMapDamsel';
          else if (global.isTunnelMan) plrspr = 'sMapTunnel';
          auto ss = sprStore[plrspr];
          drawSpriteAtS3(plrspr, (pausedTime/2)%ss.frames.length, mapX+plrx, mapY+plry);
          // exit door icon
          if (global.hasCompass && allExits.length) {
            drawSpriteAtS3('sMapRedDot', -1, mapX+mx+allExits[0].ix/16, mapY+my+allExits[0].iy/16);
          }
        }
      }
    }
  }

  sprStore.loadFont('sFontSmall');
  Video.color = 0xff_ff_00;
  drawTextAtS3Centered(232, "PRESS ~SPACE~/~LEFT~/~RIGHT~ TO CHANGE PAGE", 0x00_ff_00);

  Video.color = 0xff_ff_ff;
}


void renderPauseOverlay () {
  //drawTextAt(256, 432, "PAUSED", scale);

  if (gameShowHelp) { renderHelpOverlay(); return; }

  Video.color = 0xff_ff_00;
  //int hiColor = 0x00_ff_00;

  int n = 120;
  if (isTutorialRoom()) {
    sprStore.loadFont('sFont');
    drawTextAtS3(40, n-24, "TUTORIAL CAVE");
  } else if (isNormalLevel()) {
    sprStore.loadFont('sFont');

    drawTextAtS3Centered(n-32, va("LEVEL ~%d~", global.currLevel), 0x00_ff_00);

    sprStore.loadFont('sFontSmall');

    int depth = round((174.8*(global.currLevel-1)+(player.iy+8)*0.34)*(global.config.scumMetric ? 0.3048 : 1.0)*10);
    string depthStr = va("DEPTH: ~%d.%d~ %s", depth/10, depth%10, (global.config.scumMetric ? "METRES" : "FEET"));
    drawTextAtS3Centered(n-16, depthStr, 0x00_ff_00);

    n += 16;
    drawTextAtS3Centered(n, va("MONEY: ~%d~", stats.money), 0x00_ff_00);
    drawTextAtS3Centered(n+16, va("KILLS: ~%d~", stats.countKills), 0x00_ff_00);
    drawTextAtS3Centered(n+32, va("SAVES: ~%d~", stats.damselsSaved), 0x00_ff_00);
    drawTextAtS3Centered(n+48, va("TIME: ~%s~", time2str(time/30)), 0x00_ff_00);
    drawTextAtS3Centered(n+64, va("LEVEL TIME: ~%s~", time2str((time-levelStartTime)/30)), 0x00_ff_00);
  }

  sprStore.loadFont('sFontSmall');
  Video.color = 0xff_ff_ff;
  drawTextAtS3Centered(240-2-8, "~ESC~-RETURN  ~F10~-QUIT  ~CTRL+DEL~-SUICIDE", 0xff_7f_00);
  drawTextAtS3Centered(2, "~O~PTIONS  REDEFINE ~K~EYS  ~S~TATISTICS", 0xff_7f_00);
}


// ////////////////////////////////////////////////////////////////////////// //
transient int drawLoot;
transient int drawPosX, drawPosY;

void resetTransitionOverlay () {
  drawLoot = 0;
  drawPosX = 100;
  drawPosY = 83;
}

/*
// current game, uncollapsed
struct LevelStatInfo {
  name aname;
  // for transition screen
  bool render;
  int x, y;
}
*/


void thinkFrameTransition () {
  if (drawLoot == 0) {
    if (drawPosX > 272) {
      drawPosX = 100;
      drawPosY += 2;
      if (drawPosY > 83+4) drawPosY = 83;
    }
  } else if (drawPosX > 232) {
    drawPosX = 96;
    drawPosY += 2;
    if (drawPosY > 91+4) drawPosY = 91;
  }
}


void renderTransitionOverlay () {
  sprStore.loadFont('sFontSmall');
  Video.color = 0xff_ff_00;
  //else if (global.currLevel-1 &lt; 1) draw_text(32, 48, "TUTORIAL CAVE COMPLETED!");
  //else draw_text(32, 48, "LEVEL "+string(global.currLevel-1)+" COMPLETED!");
  drawTextAt(32, 48, va("LEVEL ~%d~ COMPLETED!", global.currLevel), hiColor1:0x00_ff_ff);
  Video.color = 0xff_ff_ff;
  drawTextAt(32, 64, va("TIME  = ~%s~", time2str((levelEndTime-levelStartTime)/30)), hiColor1:0xff_ff_00);

  if (/*stats.collected.length == 0*/stats.money <= levelMoneyStart) {
    drawTextAt(32, 80, "LOOT  = ~NONE~", hiColor1:0xff_00_00);
  } else {
    drawTextAt(32, 80, va("LOOT  = ~%d~", stats.money-levelMoneyStart), hiColor1:0xff_ff_00);
  }

  if (stats.kills.length == 0) {
    drawTextAt(32, 96, "KILLS = ~NONE~", hiColor1:0x00_ff_00);
  } else {
    drawTextAt(32, 96, va("KILLS = ~%d~", stats.kills.length), hiColor1:0xff_ff_00);
  }

  drawTextAt(32, 112, va("MONEY = ~%d~", stats.money), hiColor1:0xff_ff_00);
}


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

  bool playerPowerupRendered = false;

  // render objects (part one: depth > 3)
  foreach (auto idx; depth4Start..renderVisibleCids.length; reverse) {
    MapEntity o = renderVisibleCids[idx];
    // 1000 is an ordinary tile
    if (!playerPowerupRendered && o.depth <= 1200) {
      playerPowerupRendered = true;
      // so ducking player will have it's cape correctly rendered
      if (player.visible) player.drawPrePrePowerupWithOfs(xofs, yofs, scale, currFrameDelta);
    }
    //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+0.011*global.config.darknessDarkness;
    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+0x00_00_10*global.config.darknessDarkness;
    //Video.color = 0x00_00_18;
    //Video.color = 0x00_00_38;
    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();
  if (isTransitionRoom()) renderTransitionOverlay();
  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 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"