fixed alot of warnings, and some bugs, so it can be compiled with the current vccrun

[k8vacspelynky.git] / GameLevel.vc

/**********************************************************************************
 * Copyright (c) 2008, 2009 Derek Yu and Mossmouth, LLC
 * Copyright (c) 2010, Moloch
 * 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;
transient int loserGPU;
//RoomGen[LevelGen::LevelWidth, LevelGen::LevelHeight] rooms; // moved to levelgen

transient float accumTime;
transient bool gamePaused = false;
transient bool gameShowHelp = false;
transient bool checkWater;
transient int gameHelpScreen = 0;
const int MaxGameHelpScreen = 2;
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;
bool someTilesRemoved;

int inWinCutscene;
int inIntroCutscene;
bool cameFromIntroRoom; // for title screen
bool allowFinalCutsceneSkip;

LevelGen::RType[MaxTilesWidth, MaxTilesHeight] roomType;

enum LevelKind {
  Normal,
  Transition,
  Title,
  Intro,
  Tutorial,
  Scores,
  Stars,
  Sun,
  Moon,
  //Final,
}
LevelKind levelKind = LevelKind.Normal;
int transitionLevelIndex; // set in `generateTransitionLevel()`, used by Tunnel Man

array!MapTile allEnters;
array!MapTile allExits;


int startRoomX, startRoomY;
int endRoomX, endRoomY;

PlayerPawn player;
bool playerExited;
MapEntity playerExitDoor;
transient bool disablePlayerThink = false;
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;
transient /*bool*/int hasSolidObjects = true; // to speed up tilechecks
// as we have ALOT of inactive tiles on level, we'd better have
// a separate list of active items
private array!MapEntity activeItemsList;


final int activeItemsCount { get { return activeItemsList.length; } }

// WARNING! don't add the entity twice!
private final void addActiveEntity (MapEntity e) {
  if (!e) return;
  if (e.activeItemListIndex) FatalError("addActiveEntity: duplicate!");
  int fh = activeItemsList.length;
  activeItemsList[fh] = e;
  e.activeItemListIndex = fh+1;
}

private final void removeActiveEntity (MapEntity e) {
  if (!e) return;
  int ei = e.activeItemListIndex;
  if (!ei) return;
  --ei;
  if (activeItemsList[ei] != e) FatalError("removeActiveEntity: entity management failed (0)");
  // swap last item and `e`, so we don't have to fix alot of index backrefs
  auto alen = activeItemsList.length-1;
  if (alen > 0) {
    MapEntity ne = activeItemsList[alen];
    if (ne.activeItemListIndex-1 != alen) FatalError("removeActiveEntity: entity management failed (1)");
    ne.activeItemListIndex = ei+1;
    activeItemsList[ei] = ne;
  } else {
    if (ei != 0) FatalError("removeActiveEntity: entity management failed (2)");
  }
  activeItemsList.length -= 1;
  e.activeItemListIndex = 0;
}

private final void clearActiveEntities () {
  foreach (ref auto ai; activeItemsList) if (ai) ai.activeItemListIndex = 0;
  activeItemsList.clear();
}


// 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;
//transient int viewOffsetX, viewOffsetY;

// 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); }
final bool isIntroRoom () { return (levelKind == LevelKind.Transition); }


bool isHUDEnabled () {
  if (inWinCutscene) return false;
  if (inIntroCutscene) return false;
  if (lg.finalBossLevel) return true;
  if (isNormalLevel()) return true;
  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;
  allowFinalCutsceneSkip = true;
  //inIntroCutscene = 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();
  someTilesRemoved = false;
}


// 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 restartIntro () {
  resetGameInternal();
  stats.setMoney(0);
  createSpecialLevel(LevelKind.Intro, &createIntroRoom, '');
  global.plife = 9999;
  global.bombs = 0;
  global.rope = 1;
  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) {
      if (e.specialExit || !e.isInstanceAlive) continue;
      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

struct OSDMessageTalk {
  string msg;
  float timeout; // seconds;
  float starttime; // for active
  bool active; // true: timeout is `GetTickCount()` dismissing time
  bool shopOnly; // true: timeout when player exited the shop
  int hiColor1; // -1: default
  int hiColor2; // -1: default
}

array!OSDMessageTalk msgtalklist; // [0]: current one


private final void osdCheckTimeouts () {
  auto stt = GetTickCount();
  while (msglist.length) {
    if (!msglist[0].msg) { msglist.remove(0); continue; }
    if (!msglist[0].active) {
      msglist[0].active = true;
      msglist[0].starttime = stt;
    }
    if (msglist[0].starttime+msglist[0].timeout >= stt) break;
    msglist.remove(0);
  }
  if (msgtalklist.length) {
    bool inshop = isInShop(player.ix/16, player.iy/16);
    while (msgtalklist.length) {
      if (!msgtalklist[0].msg) { msgtalklist.remove(0); continue; }
      if (msgtalklist[0].shopOnly) {
        if (inshop == msgtalklist[0].active) {
          msgtalklist[0].active = !inshop;
          if (!inshop) msgtalklist[0].starttime = stt;
        }
      } else {
        if (!msgtalklist[0].active) {
          msgtalklist[0].active = true;
          msgtalklist[0].starttime = stt;
        }
      }
      if (!msgtalklist[0].active) break;
      //writeln("timedelta: ", msgtalklist[0].starttime+msgtalklist[0].timeout-stt);
      if (msgtalklist[0].starttime+msgtalklist[0].timeout >= stt) break;
      msgtalklist.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 string osdGetTalkMessage (optional out int hiColor1, optional out int hiColor2) {
  osdCheckTimeouts();
  if (msgtalklist.length == 0) return "";
  hiColor1 = msgtalklist[0].hiColor1;
  hiColor2 = msgtalklist[0].hiColor2;
  return msgtalklist[0].msg;
}


final void osdClear (optional bool clearTalk) {
  msglist.clear();
  if (clearTalk) msgtalklist.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(clearTalk:false);
      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 osdMessageTalk (string msg, optional bool replace, optional float timeout, optional bool inShopOnly,
                     optional int hiColor1, optional int hiColor2)
{
  //if (!msg) return;
  //writeln("talk msg: replace=", replace, "; timeout=", timeout, "; inshop=", inShopOnly, "; msg=", msg);
  if (!specified_timeout) timeout = 3.33;
  if (!specified_inShopOnly) inShopOnly = true;
  if (!specified_hiColor1) hiColor1 = -1;
  if (!specified_hiColor2) hiColor2 = -1;
  msg = global.expandString(msg);
  if (replace) {
    if (!msg) { msgtalklist.clear(); return; }
    if (msgtalklist.length && msgtalklist[0].msg == msg) {
      while (msgtalklist.length > 1) msgtalklist.remove(1);
      msgtalklist[$-1].timeout = timeout;
      msgtalklist[$-1].shopOnly = inShopOnly;
    } else {
      if (msgtalklist.length) msgtalklist.clear();
      msgtalklist.length += 1;
      msgtalklist[$-1].msg = msg;
      msgtalklist[$-1].timeout = timeout;
      msgtalklist[$-1].active = false;
      msgtalklist[$-1].shopOnly = inShopOnly;
      msgtalklist[$-1].hiColor1 = hiColor1;
      msgtalklist[$-1].hiColor2 = hiColor2;
    }
  } else {
    if (!msg) return;
    bool found = false;
    foreach (auto midx, ref auto mnfo; msgtalklist) {
      if (mnfo.msg == msg) {
        mnfo.timeout = timeout;
        mnfo.shopOnly = inShopOnly;
        found = true;
      }
    }
    if (!found) {
      msgtalklist.length += 1;
      msgtalklist[$-1].msg = msg;
      msgtalklist[$-1].timeout = timeout;
      msgtalklist[$-1].active = false;
      msgtalklist[$-1].shopOnly = inShopOnly;
      msgtalklist[$-1].hiColor1 = hiColor1;
      msgtalklist[$-1].hiColor2 = hiColor2;
    }
  }
  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();
  }
  lastMusicName = (lg ? lg.musicName : '');
  global.setMusicPitch(1.0);
  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();
    global.currLevel = 0;
    generateTransitionLevel();
    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;
    global.genBlackMarket = false;
    if (playerExitDoor) {
      if (playerExitDoor.objType == 'oXGold') {
        writeln("exiting to City Of Gold");
        global.cityOfGold = -1;
        //!global.currLevel += 1;
      } else if (playerExitDoor.objType == 'oXMarket') {
        writeln("exiting to Black Market");
        global.genBlackMarket = true;
        //!global.currLevel += 1;
      } else {
        writeln("exit door(", GetClassName(playerExitDoor.Class), "): '", playerExitDoor.objType, "'");
      }
    } else {
      writeln("WTF?! NO EXIT DOOR!");
    }
  }
  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) { if (++global.cityOfGold == 0) global.cityOfGold = 1; }
    //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;
      allowFinalCutsceneSkip = (stats.gamesWon != 0);
      ++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.x0-12, player.yCenter);
  bool canRight = !isSolidAtPoint(player.x1+12, player.yCenter);
  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 -= (obj isa MonsterDamsel ? 2 : 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();
  shakeLeft = 0;
  transitionLevelIndex = 0;

  global.setMusicPitch(1.0);
  levelKind = kind;

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

  creator();

  setMenuTilesOnTop();

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

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

  GC_ImmediateDelete = olddel;
  GC_CollectGarbage(true); // destroy delayed objects too

  if (dumpGridStats) objGrid.dumpStats();

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

  osdClear(clearTalk:true);

  setupGhostTime();
  lg.musicName = amusic;
  lastMusicName = amusic;
  global.setMusicPitch(1.0);
  if (amusic) global.playMusic(lg.musicName); else global.stopMusic();
  someTilesRemoved = false;
}


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;
  shakeLeft = 0;
  transitionLevelIndex = 0;

  resetTransitionOverlay();

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

  levelKind = LevelKind.Transition;

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

       if (global.currLevel < 4) { createTrans1Room(); transitionLevelIndex = 0; }
  else if (global.currLevel == 4) { createTrans1xRoom(); transitionLevelIndex = 1; }
  else if (global.currLevel < 8) { createTrans2Room(); transitionLevelIndex = 0; }
  else if (global.currLevel == 8) { createTrans2xRoom(); transitionLevelIndex = 2; }
  else if (global.currLevel < 12) { createTrans3Room(); transitionLevelIndex = 0; }
  else if (global.currLevel == 12) { createTrans3xRoom(); transitionLevelIndex = 3; }
  else if (global.currLevel < 16) { createTrans4Room(); transitionLevelIndex = 0; }
  else if (global.currLevel == 16) { createTrans4Room(); transitionLevelIndex = 0; }
  else { createTrans1Room(); transitionLevelIndex = 0; } //???

  bool createTunnelMan = true;
  if (global.config.scumUnlocked || global.isTunnelMan) {
    createTunnelMan = false;
  } else if (stats.money > 0) {
    // WARNING! call `stats.needTunnelMan()` only once!
    createTunnelMan = stats.needTunnelMan(transitionLevelIndex);
  } else {
    createTunnelMan = false;
  }

  if (!createTunnelMan) {
    // don't create tunnel man
    if (/*global.config.bizarre &&*/ global.randOther(1, 3) == 1) {
           if (global.randOther(1, 3) == 1) MakeMapObject(56+global.randOther(1, 6)*16, 188, 'oRock');
      else if (global.randOther(1, 3) == 1) MakeMapObject(56+global.randOther(1, 6)*16, 186, 'oJar');
      else {
        MakeMapObject(48+global.randOther(1, 6)*16, 176, 'oBones');
        MakeMapObject(48+global.randOther(1, 6)*16, 188, 'oSkull');
      }
    }
    if (global.config.bizarre && global.randOther(1, 5) == 1) MakeMapObject(16+global.randOther(1, 16)*16, 144, 'oWeb');
  } else {
    // create tunnel man
    MakeMapObject(96+8, 176+8, 'oTunnelMan');
  }


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

  GC_ImmediateDelete = olddel;
  GC_CollectGarbage(true); // destroy delayed objects too

  if (dumpGridStats) objGrid.dumpStats();

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

  osdClear(clearTalk:true);

  setupGhostTime();
  //global.playMusic(lg.musicName);
  someTilesRemoved = false;
}


void generateLevel () {
  levelStartTime = time;
  levelEndTime = time;
  shakeLeft = 0;
  transitionLevelIndex = 0;

  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 = GC_ImmediateDelete;
  GC_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();

  GC_ImmediateDelete = olddel;
  GC_CollectGarbage(true); // destroy delayed objects too

  if (dumpGridStats) objGrid.dumpStats();

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

  levelMoneyStart = stats.money;

  osdClear(clearTalk:true);
  generateLevelMessages();

  xmoney = 0;
  collectCounter = 0;

  //writeln("!<", lastMusicName, ">:<", lg.musicName, ">");
  global.setMusicPitch(1.0);
  if (lastMusicName != lg.musicName) {
    global.playMusic(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.stopMusic(); global.playMusic(lg.musicName); 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";
  }

  someTilesRemoved = false;
}


// ////////////////////////////////////////////////////////////////////////// //
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 roundi(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 roundi(sqrt(curdistsq));
}


// ////////////////////////////////////////////////////////////////////////// //
final void clearForTransition () {
  auto olddel = GC_ImmediateDelete;
  GC_ImmediateDelete = false;
  clearWholeLevel();
  GC_ImmediateDelete = olddel;
  GC_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();
  clearActiveEntities();

  // 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);
  if (o.active || o isa MapObject) addActiveEntity(o);
}


final void reinsertObject (MapEntity o) {
  if (!o || !o.isInstanceAlive) return;
  if (o.grid) o.grid.remove(o.gridId);
  objGrid.insert(o);
  if (o.active || o isa MapObject) addActiveEntity(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) reinsertObject(player.pickedItem);
  if (player.holdItem) reinsertObject(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,
}

// checks for dead, agnered, distance, etc. should be already done
protected void doAngerShopkeeper (MonsterShopkeeper shp, SCAnger reason, ref bool messaged,
                                  int maxdist, MapEntity offender)
{
  if (!shp || shp.dead || shp.angered) return;
  if (offender.distanceToEntityCenter(shp) > maxdist) return;

  shp.status = MapObject::ATTACK;
  string msg;
  if (global.murderer) {
    msg = "~YOU'LL PAY FOR YOUR CRIMES!~";
  } else {
    switch (reason) {
      case SCAnger.TileDestroyed: msg = "~DIE, YOU VANDAL!~"; break;
      case SCAnger.ItemStolen: msg = "~COME BACK HERE, THIEF!~"; break;
      case SCAnger.CrapsCheated: msg = "~DIE, CHEATER!~"; break;
      case SCAnger.BombDropped: msg = "~TERRORIST!~"; break;
      case SCAnger.DamselWhipped: msg = "~HEY, ONLY I CAN DO THAT!~"; break;
      default: "~NOW I'M REALLY STEAMED!~"; break;
    }
  }

  writeln("shopkeeper angered; reason=", reason, "; maxdist=", maxdist, "; msg=\"", msg, "\"");
  if (!messaged) {
    messaged = true;
    if (msg) osdMessageTalk(msg, replace:true, inShopOnly:false, hiColor1:0xff_00_00);
    global.thiefLevel += (global.thiefLevel > 0 ? 3 : 2);
  }
}


// make the nearest shopkeeper angry. RAWR!
void scrShopkeeperAnger (SCAnger reason, optional int maxdist, optional MapEntity offender) {
  bool messaged = false;
  maxdist = clamp(maxdist, 96, 100000);
  if (!offender) offender = player;
  if (maxdist == 100000) {
    foreach (MonsterShopkeeper shp; objGrid.allObjects(MonsterShopkeeper)) {
      doAngerShopkeeper(shp, reason, messaged, maxdist, offender);
    }
  } else {
    foreach (MonsterShopkeeper shp; objGrid.inRectPix(offender.xCenter-maxdist-128, offender.yCenter-maxdist-128, (maxdist+128)*2, (maxdist+128)*2, precise:false, castClass:MonsterShopkeeper)) {
      doAngerShopkeeper(shp, reason, messaged, maxdist, offender);
    }
  }
}


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 || inIntroCutscene || !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 = roundi(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]+ffloor(view_hview[0] / 2), oGhost);
    else instance_create(view_xview[0]-32, view_yview[0]+ffloor(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.distanceToEntityCenter(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;
    case LevelKind.Intro: thinkFrameIntro(); 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 int sortWaterTilesByCoordsCmp (MapTile a, MapTile b) {
  int dy = a.iy-b.iy;
  if (dy) return dy;
  return (a.ix-b.ix);
}

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

final void cleanDeadObjects () {
  // remove dead objects
  if (deadItemsHead) {
    auto olddel = GC_ImmediateDelete;
    GC_ImmediateDelete = false;
    do {
      auto it = deadItemsHead;
      deadItemsHead = it.deadItemsNext;
      if (!someTilesRemoved && it isa MapTile) someTilesRemoved = true;
      if (it.grid) it.grid.remove(it.gridId);
      it.onDestroy();
      removeActiveEntity(it);
      delete it;
    } while (deadItemsHead);
    GC_ImmediateDelete = olddel;
    if (olddel) GC_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(&sortWaterTilesByCoordsCmp);
    // 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 MapEntity thinkerHeld;


private 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
private final void thinkOne (MapEntity o) {
  //if (!o) return;
  //if (!o.isInstanceAlive) return;
  //if (!o.active) return;

  auto obj = MapObject(o);

  if (obj && obj.heldBy == player) {
    // fix held item coords
    obj.fixHoldCoords();
    doThinkActionsForObject(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!");
    //writeln("weapon collides with '", GetClassName(o.Class), "' (", o.objType, "'");
    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 = GC_ImmediateDelete;
  GC_ImmediateDelete = false;
  while (accumTime >= FrameTime) {
    bool solidObjectSeen = false;
    //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)))
      {
        global.hasAnkh = false;
        global.plife = 1;
        player.invincible = 0;
        auto xplo = MapObjExplosion(MakeMapObject(player.ix, player.iy, 'oExplosion'));
        if (xplo) xplo.suicide = true;
      }
      //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) {
      if (thinkerHeld.active) {
        thinkOne(thinkerHeld);
        if (!thinkerHeld.isInstanceAlive) {
          if (player.holdItem == thinkerHeld) player.holdItem = none;
          thinkerHeld.grid.remove(thinkerHeld.gridId);
        }
      } else {
        //HACK!
        auto item = MapItem(thinkerHeld);
        if (item) {
          if (item.forSale || item.sellOfferDone) {
            if (++item.forSaleFrame < 0) item.forSaleFrame = 0;
          }
        }
      }
    }
    // frame thinkers: objects
    foreach (MapEntity e; activeItemsList) {
      if (!e || e == thinkerHeld) continue;
      if (!e.active || !e.isInstanceAlive) continue;
      thinkOne(e);
      if (!e.isInstanceAlive) {
        if (e.grid) e.grid.remove(e.gridId);
        auto obj = MapObject(e);
        if (obj && obj.heldBy) obj.heldBy.holdItem = none;
      } else if (!solidObjectSeen && e.walkableSolid) {
        solidObjectSeen = true;
        hasSolidObjects = true;
      }
    }
    thinkerHeld = none;
    // clean dead things
    someTilesRemoved = false;
    cleanDeadTiles();
    hasSolidObjects = !!solidObjectSeen;
    // 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;
  }
  GC_ImmediateDelete = olddel;
  if (playerExited) {
    playerExited = false;
    onLevelExited();
    centerViewAtPlayer();
  }
  if (wasFrame) {
    // if we were processed at least one frame, collect garbage
    //keysNextFrame();
    GC_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 roundi(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 roundi(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 (castClass !isa MapTile) return none;
  if (!dg) dg = &cbCollisionAnySolid;

  if (hasSolidObjects) {
    // 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 (t isa castClass && dg(t)) return t;
        continue;
      }
      auto o = MapObject(e);
      if (o && o.walkableSolid) {
        t = makeWalkeableSolidTile(o);
        if (t isa castClass && dg(t)) return t;
        continue;
      }
    }
  } else {
    // no walkeable solid MapObjects, speed it up
    foreach (MapTile t; objGrid.inRectPix(x0, y0, w, h, precise:precise, castClass:castClass)) {
      if (t.spectral || !t.visible) continue;
      if (dg(t)) return t;
    }
  }

  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 (castClass !isa MapTile) return none;
  if (!dg) dg = &cbCollisionAnySolid;

  if (hasSolidObjects) {
    // 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 (t isa castClass && dg(t)) return t;
        continue;
      }
      auto o = MapObject(e);
      if (o && o.walkableSolid) {
        t = makeWalkeableSolidTile(o);
        if (t isa castClass && dg(t)) return t;
        continue;
      }
    }
  } else {
    //writeln("NOWS!");
    // no walkeable solid MapObjects, speed it up
    foreach (MapTile t; objGrid.inCellPix(x0, y0, precise:precise, castClass:castClass)) {
      if (t.spectral || !t.visible) continue;
      if (dg(t)) return t;
    }
  }

  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)) {
    //writeln("beautify: '", GetClassName(t.Class), "' (", t.objType, "' (name:", t.objName, ")");
    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');
  what.spillBlood(amount:3, forced:true);

  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 : roundi(what.favor/2.0)); //k8: added `roundi()`
    if (what.favor > 0) what.favor = 0;
  } else {
    global.favor += (what.status == MapObject::STUNNED ? what.favor : roundi(what.favor/2.0)); //k8: added `roundi()`
  }

  /*!!
       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);

  scrShake(10);
}


// ////////////////////////////////////////////////////////////////////////// //
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);
  //print("vy=%s; lo=%s; hi=%s", 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, trunci(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, roundi(sx0+sfr.width*(scale/2.0)), roundi(sy0+sfr.height*(scale/2.0)), 0, 0);
  } else {
    sfr.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, trunci(frnumf))%spr.frames.length;
  auto sfr = spr.frames[frnum];
  int sx0 = x0-sfr.xofs*3;
  int sy0 = y0-sfr.yofs*3;
  sfr.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');
  GLVideo.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 = viewHeight-64;
  if (hgt < 1) return;
  int rhgt = roundi(float(hgt)*(float(ghostTimeLeft)/30.0)/1000.0);
  //writeln("hgt=", hgt, "; rhgt=", rhgt, "; gtl=", ghostTimeLeft/30);
  if (rhgt > 0) {
    auto oclr = GLVideo.color;
    GLVideo.color = 0xcf_ff_7f_00;
    GLVideo.fillRect(viewWidth-20, 32, 16, hgt-rhgt);
    GLVideo.color = 0x7f_ff_7f_00;
    GLVideo.fillRect(viewWidth-20, 32+(hgt-rhgt), 16, rhgt);
    GLVideo.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;
  }

  GLVideo.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');
    GLVideo.color = 0xff_ff_00;
    int scale = global.scale;
    sprStore.renderMultilineTextCentered(viewWidth/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;
  }

  GLVideo.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');
    GLVideo.color = 0xff_ff_00;
    int scale = global.scale;
    sprStore.renderMultilineTextCentered(viewWidth/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;
  }

  GLVideo.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');
    GLVideo.color = 0xff_ff_00;
    int scale = global.scale;
    sprStore.renderMultilineTextCentered(viewWidth/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 && (!player || player.holdItem !isa ItemWeaponBow)) 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;

  //GLVideo.color = 0xff_ff_ff;
  GLVideo.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
  GLVideo.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) {
      GLVideo.color = trunci(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');
    GLVideo.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));
  }

  GLVideo.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 = (viewWidth-sprStore.getTextWidth(text, 3, specified_hiColor1, specified_hiColor2))/2;
  sprStore.renderTextWithHighlight(x0, y0*3, text, 3, hiColor1!optional, hiColor2!optional);
}


void renderHelpOverlay () {
  GLVideo.color = 0;
  GLVideo.fillRect(0, 0, viewWidth, viewHeight);

  int tx = 16;
  //int txoff = 0; // text x pos offset (for multi-color lines)
  int ty = 8;
  if (gameHelpScreen) {
    sprStore.loadFont('sFontSmall');
    GLVideo.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');
    GLVideo.color = 0xff_ff_00; drawTextAtS3(tx, ty, "INVENTORY BASICS"); ty += 16;
    GLVideo.color = 0xff_ff_ff;
    drawTextAtS3(tx, ty, global.expandString("Press $SWITCH to cycle through items."), 0x00_ff_00);
    ty += 8;
    ty += 56;
    GLVideo.color = 0xff_ff_ff;
    drawSpriteAtS3('sHelpSprite1', -1, 64, 96);
  } else if (gameHelpScreen == 2) {
    sprStore.loadFont('sFontSmall');
    GLVideo.color = 0xff_ff_00;
    drawTextAtS3(tx, ty, "SELLING TO SHOPKEEPERS"); ty += 16;
    GLVideo.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');
    GLVideo.color = 0xff_ff_ff;
    drawTextAtS3(136, 8, "MAP");

    if (lg.mapSprite && (isNormalLevel() || isTransitionRoom())) {
      GLVideo.color = 0xff_ff_00;
      drawTextAtS3Centered(24, lg.mapTitle);

      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;

      GLVideo.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;
          if (isTransitionRoom()) { plrx = mx+20; plry = my+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');
  GLVideo.color = 0xff_ff_00;
  drawTextAtS3Centered(232, "PRESS ~SPACE~/~LEFT~/~RIGHT~ TO CHANGE PAGE", 0x00_ff_00);

  GLVideo.color = 0xff_ff_ff;
}


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

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

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

  int n = 120;
  if (isTutorialRoom()) {
    sprStore.loadFont('sFont');
    drawTextAtS3Centered(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 = roundi((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');
  GLVideo.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');
  GLVideo.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!");
  if (global.currLevel == 0) {
    drawTextAt(32, 48, "TUTORIAL CAVE COMPLETED!");
  } else {
    drawTextAt(32, 48, va("LEVEL ~%d~ COMPLETED!", global.currLevel), hiColor1:0x00_ff_ff);
  }
  GLVideo.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 int renderSortByDepth (MapEntity oa, MapEntity ob) {
  //auto da = oa.depth, db = ob.depth;
  //if (da == db) return (oa.objId < ob.objId);
  //return (da < db);
  auto d = oa.depth-ob.depth;
  return (d ? d : oa.objId-ob.objId);
}


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
  GLVideo.colorMask = GLVideo::CMask.Colors;
  GLVideo.color = 0xff_ff_ff;

  /*
  GLVideo::ScissorRect scsave;
  bool doRestoreGL = false;

  if (viewOffsetX > 0 || viewOffsetY > 0) {
    doRestoreGL = true;
    GLVideo.getScissor(scsave);
    GLVideo.scissorCombine(viewOffsetX, viewOffsetY, viewWidth, viewHeight);
    GLVideo.glPushMatrix();
    GLVideo.glTranslate(viewOffsetX, viewOffsetY);
    //GLVideo.glTranslate(-550, 0);
    //GLVideo.glScale(1, 1);
  }
  */


  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.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 /*|| tile.spriteLeftDeco || tile.spriteRightDeco*/) 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*/SpriteFrame 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 /*|| tile.spriteLeftDeco || tile.spriteRightDeco*/) 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
    GLVideo.colorMask = GLVideo::CMask.Alpha;
    GLVideo.blendMode = GLVideo::BlendMode.None;
    GLVideo.color = 0xff_ff_ff_ff;
    GLVideo.fillRect(0, 0, GLVideo.screenWidth, GLVideo.screenHeight);
    //GLVideo.colorMask = GLVideo::CMask.All;

    // blend lights
    // also, stencil 'em, so we can filter dark areas
    GLVideo.textureFiltering = true;
    GLVideo.stencil = true;
    GLVideo.stencilFunc(GLVideo::StencilFunc.Always, 1);
    GLVideo.stencilOp(GLVideo::StencilOp.Keep, GLVideo::StencilOp.Replace);
    GLVideo.alphaTestFunc = GLVideo::AlphaFunc.Greater;
    GLVideo.alphaTestVal = 0.03+0.011*global.config.darknessDarkness;
    GLVideo.color = 0xff_ff_ff;
    GLVideo.blendFunc = GLVideo::BlendFunc.Max;
    GLVideo.blendMode = GLVideo::BlendMode.Blend; // anything except `Normal`
    GLVideo.colorMask = GLVideo::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) {
        //GLVideo.color = 0xff_ff_ff;
        GLVideo.fillRect(xi-xofs, yi-yofs, e.width*scale, e.height*scale);
      }
      int lrad = e.lightRadius;
      if (lrad < 4) continue; // just in case
      lrad += 8;
      //if (loserGPU && lrad%12 != 0) lrad = (lrad/12)*12;
      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);
    }
    GLVideo.textureFiltering = false;

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

    // filter unlit parts
    GLVideo.stencilFunc(GLVideo::StencilFunc.NotEqual, 1);
    GLVideo.stencilOp(GLVideo::StencilOp.Keep, GLVideo::StencilOp.Keep);
    GLVideo.blendFunc = GLVideo::BlendFunc.Add;
    GLVideo.blendMode = GLVideo::BlendMode.Filter;
    GLVideo.colorMask = GLVideo::CMask.Colors;
    GLVideo.color = 0x00_00_18+0x00_00_10*global.config.darknessDarkness;
    //GLVideo.color = 0x00_00_18;
    //GLVideo.color = 0x00_00_38;
    GLVideo.fillRect(0, 0, GLVideo.screenWidth, GLVideo.screenHeight);

    // restore defaults
    GLVideo.blendFunc = GLVideo::BlendFunc.Add;
    GLVideo.blendMode = GLVideo::BlendMode.Normal;
    GLVideo.colorMask = GLVideo::CMask.All;
    GLVideo.alphaTestFunc = GLVideo::AlphaFunc.Always;
    GLVideo.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 = viewWidth/2;
    int y = viewHeight-64-msgHeight;
    auto oldColor = GLVideo.color;
    GLVideo.color = 0xff_ff_00;
    if (osdTimeLeft < 0.5) {
      int alpha = 255-clamp(int(510*osdTimeLeft), 0, 255);
      GLVideo.color = GLVideo.color|(alpha<<24);
    } else if (ct-osdTimeStart < 0.5) {
      osdTimeStart = ct-osdTimeStart;
      int alpha = 255-clamp(int(510*osdTimeStart), 0, 255);
      GLVideo.color = GLVideo.color|(alpha<<24);
    }
    sprStore.renderMultilineTextCentered(x, y, msg, msgScale, 0x00_ff_00, 0xff_ff_ff);
    GLVideo.color = oldColor;
  }

  int hiColor1, hiColor2;
  msg = osdGetTalkMessage(out hiColor1, out hiColor2);
  if (msg) {
    int msgScale = 2;
    sprStore.loadFont('sFontSmall');
    auto msgWidth = sprStore.getMultilineTextWidth(msg, processHighlights1:true, processHighlights2:true);
    auto msgHeight = sprStore.getMultilineTextHeight(msg);
    auto msgWidthOrig = msgWidth*msgScale;
    auto msgHeightOrig = msgHeight*msgScale;
    if (msgWidth%16 != 0) msgWidth = (msgWidth|0x0f)+1;
    if (msgHeight%16 != 0) msgHeight = (msgHeight|0x0f)+1;
    msgWidth *= msgScale;
    msgHeight *= msgScale;
    int x = (viewWidth-msgWidth)/2;
    int y = 32*msgScale;
    auto oldColor = GLVideo.color;
    // draw text frame and text background
    GLVideo.color = 0;
    GLVideo.fillRect(x, y, msgWidth, msgHeight);
    GLVideo.color = 0xff_ff_ff;
    for (int fdx = 0; fdx < msgWidth; fdx += 16*msgScale) {
      auto spf = sprStore['sMenuTop'].frames[0];
      spf.blitAt(x+fdx, y-16*msgScale, msgScale);
      spf = sprStore['sMenuBottom'].frames[0];
      spf.blitAt(x+fdx, y+msgHeight, msgScale);
    }
    for (int fdy = 0; fdy < msgHeight; fdy += 16*msgScale) {
      auto spf = sprStore['sMenuLeft'].frames[0];
      spf.blitAt(x-16*msgScale, y+fdy, msgScale);
      spf = sprStore['sMenuRight'].frames[0];
      spf.blitAt(x+msgWidth, y+fdy, msgScale);
    }
    {
      auto spf = sprStore['sMenuUL'].frames[0];
      spf.blitAt(x-16*msgScale, y-16*msgScale, msgScale);
      spf = sprStore['sMenuUR'].frames[0];
      spf.blitAt(x+msgWidth, y-16*msgScale, msgScale);
      spf = sprStore['sMenuLL'].frames[0];
      spf.blitAt(x-16*msgScale, y+msgHeight, msgScale);
      spf = sprStore['sMenuLR'].frames[0];
      spf.blitAt(x+msgWidth, y+msgHeight, msgScale);
    }
    GLVideo.color = 0xff_ff_00;
    sprStore.renderMultilineText(x+(msgWidth-msgWidthOrig)/2, y+(msgHeight-msgHeightOrig)/2-3*msgScale, msg, msgScale, (hiColor1 == -1 ? 0x00_ff_00 : hiColor1), (hiColor2 == -1 ? 0xff_ff_ff : hiColor2));
    GLVideo.color = oldColor;
  }

  if (inWinCutscene) renderWinCutsceneOverlay();
  if (inIntroCutscene) renderTitleCutsceneOverlay();
  if (isTransitionRoom()) renderTransitionOverlay();

  /*
  if (doRestoreGL) {
    GLVideo.setScissor(scsave);
    GLVideo.glPopMatrix();
  }
  */

  GLVideo.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) {
  if (!tile || !tile.isInstanceAlive) return false;

  //if (putToGrid) tile.active = true;
  bool 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 || tile.moveable || tile.toSpecialGrid;
  // 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();
      }
    }
    insertObject(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);

  // make tile under exit invulnerable
  if (checkTilesInRect(tile.ix, tile.iy-16, 16, 16, delegate bool (MapTile t) { return t.exit; })) {
    tile.invincible = true;
  }

  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) {
  //writeln("tile at (", mapx, ",", mapy, "): ", aname);
  //if (aname == 'oLush') { MapObject fail; fail.initialize(); }
  //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)) {
    delete tile;
    tile = none;
  }

  return tile;
}


final MapTile MakeMapTileAtPix (int xpix, int ypix, name aname) {
  // 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)) {
    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)) {
    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);
  if (obj.walkableSolid) hasSolidObjects = true;

  return obj;
}


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


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


// ////////////////////////////////////////////////////////////////////////// //
#include "roomTitle.vc"
#include "roomTrans1.vc"
#include "roomTrans2.vc"
#include "roomTrans3.vc"
#include "roomTrans4.vc"
#include "roomOlmec.vc"
#include "roomEnd.vc"
#include "roomIntro.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"