animate "$" on held item

[k8vacspelynky.git] / PlayerPawn.vc

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

//#define HANG_DEBUG
#define EASIER_HANG

const int hangCountMax = 3;

array!PlayerPowerup powerups; // created in initializer

int cameraBlockX; // >0: don't center camera
int cameraBlockY; // >0: don't center camera

float xFric, yFric;

// swimming
int bubbleTimer;
const int bubbleTimerMax = 20;
int jetpackFlaresTime;

// gambling
int bet;
bool point;

//bool walkSndToggle;

bool damsel;
bool tunnelMan;

bool justdied = true; // so dead body won't spill blood endlessly
bool madeOffer;
bool whipping;
bool kJumped;
bool bowArmed;
bool movementBlocked;
int cantJump;
int firing;
const int firingMax = 20;
const int firingPistolMax = 20;
const int firingShotgunMax = 40;
float bowStrength;
int jetpackFuel;

int hotkeyPressed = -1;
bool kExitPressed;

// used with Kapala
int redColor;
bool redToggle;

// poison
/*
int greenColor;
bool greenToggle;
*/
//!!!global.poisonStrength = max(global.poisonStrength-0.5, 1);

//string holdItemType = "";
//string pickupItemType = "";

// this is what we had picked up
// picked item will be stored here by bomb/rope/item switcher
MapObject pickedItem;

bool canDropStuff = true;
bool kItemPressed;
//bool kItemReleased;
bool kRopePressed;
bool kBombPressed;
bool kPayPressed;
//bool kRope;
//bool kBomb;
//bool kPay;

int holdArrow;
bool holdArrowToggle;
int bombArrowCounter = 80;

int hangCount;
int runHeld;

// other
int blink;
bool blinkHidden;

// the keys that the platform character will use (don't edit)
bool kLeft;
bool kLeftPressed;
bool kLeftReleased;
bool kRight;
bool kRightPressed;
bool kRightReleased;
bool kUp;
bool kDown;
bool kJump;
bool kJumpPressed;
bool kJumpReleased;
bool jumpButtonReleased; // whether the jump button was released. (Stops the user from pressing the jump button many times to get extra jumps)
bool kAttack;
bool kAttackPressed;
bool kAttackReleased;

const float gravNorm = 1;
//float grav = 1; // the gravity

const float initialJumpAcc = -2; // relates to how high the character will jump
const int jumpTimeTotal = 10;  // how long the user must hold the jump button to get the maximum jump height

float climbAcc = 0.6; // how fast the character will climb
float climbAnimSpeed = 0.4; // relates to how fast the climbing animation should go
int climbSndSpeed = 8;
int climbSoundTimer;
bool climbSndToggle;

// these flags are used to recreate ball and chain when player is moved at a new level
//bool chained;
//bool holdingBall;

const float departLadderXVel = 4;  // how fast character should be moving horizontally when he leaves the ladder
const float departLadderYVel = -4; // how fast the character should be moving vertically when he leaves the ladder

const float frictionRunningX = 0.6;      // friction obtained while running
const float frictionRunningFastX = 0.98; // friction obtained while holding the shift button for some time while running
const float frictionClimbingX = 0.6;     // friction obtained while climbing
const float frictionClimbingY = 0.6;     // friction obtained while climbing
const float frictionDuckingX = 0.8;      // friction obtained while ducking
const float frictionFlyingX = 0.99;      // friction obtained while "flying"

const float runAnimSpeed = 0.1; // relates to the how fast the running animation should go

// hidden variables (don't edit)
protected int statePrev;
protected int statePrevPrev;
protected float gravityIntensity = grav; // this variable describes the current force due to gravity (this variable is altered for variable jumping)
protected float jumpTime = jumpTimeTotal; // current time of the jump (0=start of jump, jumpTimeTotal=end of jump)
protected int ladderTimer; // relates to whether the character can climb a ladder
protected int kLeftPushedSteps;
protected int kRightPushedSteps;

transient protected bool skipCutscenePressed;


//int score;

//PlayerWeapon actWeapon; // active weapon object


enum {
  ARROW_NORM = 1,
  ARROW_BOMB = 2,
}

int viewOffset;
int viewCount;
int lookOff0;


// ////////////////////////////////////////////////////////////////////////// //
bool mustBeChained;
bool wasHoldingBall;

ItemBall myBall;

final ItemBall getMyBall () {
  ItemBall res = myBall;
  if (res && !res.isInstanceAlive) { res = none; myBall = none; }
  return res;
}


void spawnBallAndChain (optional bool levelStart) {
  if (levelStart) {
    auto owh = wasHoldingBall;
    removeBallAndChain();
    wasHoldingBall = owh;
  }
  mustBeChained = true;
  auto ball = getMyBall();
  if (!ball) {
    if (levelStart) writeln("::: respawning ball; old ball is missing (it is ok)");
    writeln("creating new ball");
    ball = ItemBall(level.MakeMapObject(ix, iy, 'oBall'));
    if (ball) {
      ball.attachTo(self, levelStart);
      writeln("ball created");
    }
  }
  if (ball) {
    if (levelStart) writeln("::: attaching ball to player");
    ball.attachTo(self, levelStart);
    if (wasHoldingBall) {
      if (levelStart) writeln("::: picking ball");
      if (pickedItem) {
        pickedItem.instanceRemove();
        pickedItem = none;
      }
      if (holdItem && holdItem != ball) {
        holdItem.instanceRemove();
        holdItem = none;
      }
      holdItem = none;
      holdItem = ball;
    }
    if (myBall != ball) FatalError("error in ball management");
    if (levelStart) writeln("ballpos=(", ball.ix, ",", ball.iy, "); plrpos=(", ix, ",", iy, "); ballalive=", ball.isInstanceAlive);
  } else {
    writeln("failed to create a new ball");
    mustBeChained = false;
  }
  wasHoldingBall = false;
}


void removeBallAndChain (optional bool temp) {
  auto ball = getMyBall();
  if (ball) {
    writeln("removing ball and chain...", (temp ? " (temporarily)" : ""));
    wasHoldingBall = (holdItem == ball);
    writeln("  has ball, holding=", wasHoldingBall);
    mustBeChained = true;
    ball.attachTo(none);
    ball.instanceRemove();
    myBall = none;
  }
  if (temp) return;
  wasHoldingBall = false;
  mustBeChained = false;
}


// ////////////////////////////////////////////////////////////////////////// //
final PlayerPowerup findPowerup (name id) {
  foreach (PlayerPowerup pp; powerups) if (pp.id == id) return pp;
  return none;
}


final bool setPowerupState (name id, bool active) {
  auto pp = findPowerup(id);
  if (!pp) return false;
  return (active ? pp.onActivate() : pp.onDeactivate());
}


final bool togglePowerupState (name id) {
  auto pp = findPowerup(id);
  if (!pp) return false;
  return (pp.active ? pp.onDeactivate() : pp.onActivate());
}


final bool activatePowerup (name id) { return setPowerupState(id, true); }
final bool deactivatePowerup (name id) { return setPowerupState(id, false); }


final bool isActivePowerup (name id) {
  auto pp = findPowerup(id);
  return (pp && pp.active);
}


// ////////////////////////////////////////////////////////////////////////// //
override void Destroy () {
  foreach (PlayerPowerup pp; powerups) delete pp;
  powerups.length = 0;
}


void unpressAllKeys () {
  kLeft = false;
  kLeftPressed = false;
  kLeftReleased = false;
  kRight = false;
  kRightPressed = false;
  kRightReleased = false;
  kUp = false;
  kDown = false;
  kJump = false;
  kJumpPressed = false;
  kJumpReleased = false;
  kAttack = false;
  kAttackPressed = false;
  kAttackReleased = false;
  kItemPressed = false;
  kRopePressed = false;
  kBombPressed = false;
  kPayPressed = false;
  kExitPressed = false;
}


// ////////////////////////////////////////////////////////////////////////// //
// called on level start too
void resurrect () {
  justSpawned = true;
  holdArrow = 0;
  bowStrength = 0;
  bowArmed = false;
  skipCutscenePressed = false;
  movementBlocked = false;
  if (global.plife < 1) global.plife = max(1, global.config.scumStartLife);
  dead = false;
  xVel = 0;
  yVel = 0;
  grav = default.grav;
  myGrav = default.myGrav;
  bounced = false;
  stunned = false;
  burning = 0;
  depth = default.depth;
  status = default.status;
  fallTimer = 0;
  stunTimer = 0;
  wallHurt = 0;
  pushTimer = 0;
  whoaTimer = 0;
  distToNearestLightSource = 999;
  flying = false;
  justdied = default.justdied;
  whipping = false;
  if (holdItem isa PlayerWeapon) {
    auto w = holdItem;
    holdItem = none;
    w.instanceRemove();
  }
  invincible = 0;
  blink = default.blink;
  blinkHidden = default.blinkHidden;
  status = STANDING;
  characterSprite();
  active = true;
  visible = true;
  unpressAllKeys();
  level.clearKeysPressRelease();
  climbSoundTimer = 0;
  bet = 0;
  //scrSwitchToPocketItem(forceIfEmpty:false);
}


// ////////////////////////////////////////////////////////////////////////// //
bool isExitingSprite () {
  auto spr = getSprite();
  return (spr.Name == 'sPExit' || spr.Name == 'sDamselExit' || spr.Name == 'sTunnelExit');
}


// ////////////////////////////////////////////////////////////////////////// //
override void playSound (name aname, optional bool unique) {
  if (unique && global.sndIsPlaying(0, aname)) return;
  global.playSound(0, 0, 0, aname); // it is local
}


override bool sndIsPlaying (name aname) {
  return global.sndIsPlaying(0, aname);
}


override void sndStopSound (name aname) {
  global.sndStopSound(0, aname);
}


// ////////////////////////////////////////////////////////////////////////// //
transient ItemDice currDie;

void onDieRolled (ItemDice die) {
  if (!die.forSale) return;
  // only law-abiding players can play
  if (global.thiefLevel > 0 || global.murderer) return;
  if (bet == 0) return;
  auto odie = currDie;
  currDie = die;
  level.forEachObject(delegate bool (MapObject o) {
    MonsterShopkeeper sc = MonsterShopkeeper(o);
    if (sc && !sc.dead && !sc.angered) return sc.onDiePlayed(self, currDie);
    return false;
  });
  currDie = odie;
}


// ////////////////////////////////////////////////////////////////////////// //
override bool onExplosionTouch (MapObject xplo) {
  //writeln("PlayerPawn: on explo touch! ", invincible);
  if (invincible) return false;
  if (global.config.scumExplosionHurt) {
    global.plife -= global.config.explosionDmg;
    if (!dead && global.plife <= 0 /*&& isRealLevel()*/) {
      auto xp = MapObjExplosion(xplo);
      if (xp && xp.suicide) level.addDeath('suicide'); else level.addDeath('explosion');
    }
    burning = 50;
    if (global.config.scumExplosionStun) {
      stunned = true;
      stunTimer = 100;
    }
    spillBlood();
  }
  if (xplo.ix < ix) xVel = global.randOther(4, 6); else xVel = -global.randOther(4, 6);
  yVel = -6;
  return true;
}


// ////////////////////////////////////////////////////////////////////////// //
// start new game when exiting from title, and process other custom exits
void scrPlayerExit () {
  level.playerExited = true;
  status = STANDING;
  characterSprite();
}


// ////////////////////////////////////////////////////////////////////////// //
bool scrHideItemToPocket (optional bool forBombOrRope) {
  if (!holdItem) return true;
  if (holdItem isa PlayerWeapon) return false;
  if (holdItem.forSale) return false;
  if (!forBombOrRope) {
    if (holdItem isa ItemBall) return false;
  }

  // cannot hide armed bomb
  ItemBomb bomb = ItemBomb(holdItem);
  if (bomb && bomb.armed) return false;
  if (bomb || holdItem isa ItemRopeThrow) {
    holdItem.instanceRemove();
    holdItem = none;
    return true;
  }

  // cannot hide enemy
  if (holdItem isa MapEnemy) return false;
  //writeln("hiding: '", GetClassName(holdItem.Class), "'");

  if (pickedItem) FatalError("we are already holding '%n'", GetClassName(pickedItem.Class));
  pickedItem = holdItem;
  holdItem = none;
  pickedItem.active = false;
  pickedItem.visible = false;
  pickedItem.sellOfferDone = false;
  if (pickedItem.heldBy) FatalError("oooops (scrHideItemToPocket)");
  return true;
}


bool scrSwitchToBombs () {
  if (holdItem isa PlayerWeapon) return false;

  if (global.bombs < 1) return false;
  if (ItemBomb(holdItem)) return true;
  if (!scrHideItemToPocket(forBombOrRope:true)) return false;

  ItemBomb bomb = ItemBomb(level.MakeMapObject(ix, iy, 'oBomb'));
  if (!bomb) return false;
  bomb.setSticky(global.stickyBombsActive);
  holdItem = bomb;
  whoaTimer = whoaTimerMax;
  return true;
}


bool scrSwitchToStickyBombs () {
  if (holdItem isa PlayerWeapon) return false;
  if (!global.hasStickyBombs) {
    global.stickyBombsActive = false;
    return false;
  }

  global.stickyBombsActive = !global.stickyBombsActive;
  return true;
}


bool scrSwitchToRopes () {
  if (holdItem isa PlayerWeapon) return false;

  if (global.rope < 1) return false;
  if (ItemRopeThrow(holdItem)) return true;
  if (!scrHideItemToPocket(forBombOrRope:true)) return false;

  ItemRopeThrow rope = ItemRopeThrow(level.MakeMapObject(ix, iy, 'oRopeThrow'));
  if (!rope) return false;
  holdItem = rope;
  whoaTimer = whoaTimerMax;
  return true;
}


bool isHoldingBombOrRope () {
  auto hit = holdItem;
  if (!hit) return false;
  return (hit isa ItemBomb || hit isa ItemRopeThrow);
}


bool isHoldingBomb () {
  auto hit = holdItem;
  if (!hit) return false;
  return (hit isa ItemBomb);
}


bool isHoldingArmedBomb () {
  auto hit = ItemBomb(holdItem);
  if (!hit) return false;
  return hit.armed;
}


bool isHoldingRope () {
  auto hit = holdItem;
  if (!hit) return false;
  return (hit isa ItemRopeThrow);
}


bool scrSwitchToPocketItem (bool forceIfEmpty) {
  if (holdItem isa PlayerWeapon) return false;
  if (holdItem && holdItem.forSale) return false;

  if (holdItem == pickedItem) {
    pickedItem = none;
    whoaTimer = whoaTimerMax;
    if (holdItem) holdItem.sellOfferDone = false;
    return true;
  }

  if (!forceIfEmpty && !pickedItem) return false;

  // destroy currently holded item if it is a bomb or a rope
  if (holdItem) {
    // you cannot do it with an armed bomb
    if (holdItem isa MapEnemy) return false; // cannot hide an enemy
    ItemBomb bomb = ItemBomb(holdItem);
    if (bomb && bomb.armed) return false;
    if (bomb || holdItem isa ItemRopeThrow) {
      //delete holdItem;
      holdItem.instanceRemove();
      holdItem = none;
    } /*else {
      if (pickedItem) {
        writeln(va("cannot switch to pocket item while carrying '%n' ('%n' is in pocket, why?)", GetClassName(holdItem.Class), GetClassName(pickedItem.Class)));
        return false;
      }
    }*/
  }

  auto oldHold = holdItem;
  holdItem = pickedItem;
  pickedItem = oldHold;
  // all flag management is done in property handler
  if (oldHold) {
    oldHold.active = false;
    oldHold.visible = false;
    oldHold.sellOfferDone = false;
  }
  if (holdItem) holdItem.sellOfferDone = false;
  whoaTimer = whoaTimerMax;
  return true;
}


bool scrSwitchToNextItem () {
  if (holdItem isa PlayerWeapon) return false;
  if (holdItem && holdItem.forSale) return false;

  // holding a bomb?
  if (ItemBomb(holdItem)) {
    if (ItemBomb(holdItem).armed) return false; // cannot switch out of armed bomb
    if (scrSwitchToRopes()) return true;
    return scrSwitchToPocketItem(forceIfEmpty:true);
  }

  // holding a rope?
  if (ItemRopeThrow(holdItem)) {
    if (scrSwitchToPocketItem(forceIfEmpty:true)) return true;
    if (scrSwitchToBombs()) return true;
    return scrHideItemToPocket();
  }

  // either nothing, or normal item
  bool tryPocket = !!holdItem;
  if (scrSwitchToBombs()) return true;
  if (scrSwitchToRopes()) return true;
  if (holdItem isa ItemBall) return false;
  if (tryPocket) return scrSwitchToPocketItem(forceIfEmpty:true);
  return false;
}


// ////////////////////////////////////////////////////////////////////////// //
bool scrPickupItem (MapObject obj) {
  if (holdItem isa PlayerWeapon) return false;

  if (!obj) return false;

  if (holdItem) {
    if (pickedItem) return false;
    if (isHoldingArmedBomb()) return false;
    if (isHoldingBombOrRope()) {
      if (!scrSwitchToPocketItem(forceIfEmpty:true)) return false;
    }
    if (holdItem) return false;
  } else {
    // just in case
    if (pickedItem) return false;
  }

       if (obj isa ItemBomb && !ItemBomb(obj).armed) ++global.bombs;
  else if (obj isa ItemRopeThrow) ++global.rope;
  holdItem = obj;
  whoaTimer = whoaTimerMax;
  obj.onPickedUp(self);
  return true;
}


// drop currently held item
bool scrDropItem (LostCause cause, optional float xVel, optional float yVel) {
  if (holdItem isa PlayerWeapon) return false;

  if (!holdItem) return false;

  if (!onLoosingHeldItem(cause)) return false;

  auto hi = holdItem;
  holdItem = none;

  if (!hi.onLostAsHeldItem(self, cause, xVel!optional, yVel!optional)) {
    // oops, regain it
    holdItem = hi;
    return false;
  }

       if (hi isa ItemRopeThrow) global.rope = max(0, global.rope-1);
  else if (hi isa ItemBomb && !ItemBomb(hi).armed) global.bombs = max(0, global.bombs-1);

  madeOffer = false;

  scrSwitchToPocketItem(forceIfEmpty:true);
  return true;
}


// ////////////////////////////////////////////////////////////////////////// //
void scrUseThrowIt (MapObject it) {
  if (!it) return;

  it.onBeforeThrowBy(self);

  it.resaleValue = 0;
  it.makeSafe();

  if (dir == Dir.Left) {
    it.xVel = (it.heavy ? -4+xVel : -8+xVel);
    //foreach (; 0..8) if (level.isSolidAtPoint(ix-8, iy)) it.shiftX(1);
    //while (!level.isSolidAtPoint(ix-8, iy)) it.shiftX(1); // prevent getting stuck in wall
  } else if (dir == Dir.Right) {
    it.xVel = (it.heavy ? 4+xVel : 8+xVel);
    //foreach (; 0..8) if (level.isSolidAtPoint(ix+8, iy)) it.shiftX(-1);
    //while (!level.isSolidAtPoint(ix+8, iy)) it.shiftX(-1); // prevent getting stuck in wall
  }
  it.yVel = (it.heavy ? (kUp ? -4 : -2) : (kUp ? -9 : -3));
  if (kDown || scrPlayerIsDucking()) {
    if (platformCharacterIs(ON_GROUND)) {
      it.shiftY(-2);
      it.xVel *= 0.6;
      it.yVel = 0.5;
    } else {
      it.yVel = 3;
    }
  } else if (!global.hasMitt) {
    if (dir == Dir.Left) {
      if (level.isSolidAtPoint(ix-8, iy-10)) {
        it.yVel = 0;
        it.xVel -= 1;
      }
    } else if (dir == Dir.Right) {
      if (level.isSolidAtPoint(ix+8, iy-10)) {
        it.yVel = 0;
        it.xVel += 1;
      }
    }
  }

  if (global.hasMitt && !scrPlayerIsDucking()) {
    it.xVel += (it.xVel < 0 ? -6 : 6);
         if (!kUp && !kDown) it.yVel = -0.4;
    else if (kDown) it.yVel = 6;
    it.myGrav = 0.1;
  }

  // prevent getting stuck in a wall
  if (it.isCollision()) {
    //foreach (; 0..8) if (level.isSolidAtPoint(ix-8, iy)) it.shiftX(1);
    if (it.xVel < 0) {
      if (level.isSolidAtPoint(it.ix-8, it.iy)) it.shiftX(8);
    } else if (it.xVel > 0) {
      if (level.isSolidAtPoint(it.ix+8, it.iy)) it.shiftX(-8);
    } else if (it.isCollision()) {
      int dx = (it.isCollisionLeft(0) ? 1 : it.isCollisionRight(0) ? -1 : 0);
      if (dx) {
        foreach (; 0..8) {
          it.shiftX(dx);
          if (!it.isCollision()) break;
        }
      }
    }
    /*
    int dx = 1;
    while (dx > 8 && it.isCollisionLeft(dx)) ++dx;
    if (dx < 8) it.shiftX(8);
    else {
      dx = 1;
      while (dx > 8 && it.isCollisionRight(dx)) ++dx;
      if (dx < 8) it.shiftX(-8);
    }
    */
  }

  /*
  if (it.sprite_index == sBombBag ||
      it.sprite_index == sBombBox ||
      it.sprite_index == sRopePile)
  {
      // do nothing
  } else*/ {
    playSound('sndThrow');
  }

  auto proj = ItemProjectile(it);
  if (proj) proj.launchedByPlayer = true;
}


bool scrUseThrowItem () {
  if (holdItem isa PlayerWeapon) return false;

  auto hitem = holdItem;

  if (!hitem) return false;
  if (!onLoosingHeldItem(LostCause.Unknown)) return false;

  holdItem = none;
  madeOffer = false;

  scrUseThrowIt(hitem);

  // if we throwing away armed bomb, get previous item back into our hands
  //FIXME
  if (/*ItemBomb(hitem)*/isHoldingBombOrRope()) scrSwitchToPocketItem(forceIfEmpty:false);

  return true;
}


// ////////////////////////////////////////////////////////////////////////// //
bool scrPlayerIsDucking () {
  if (dead) return false;
  auto spr = getSprite();
  //if (!spr) return false;
  return
    spr.Name == 'sDuckLeft' ||
    spr.Name == 'sCrawlLeft' ||
    spr.Name == 'sDamselDuckL' ||
    spr.Name == 'sDamselCrawlL' ||
    spr.Name == 'sTunnelDuckL' ||
    spr.Name == 'sTunnelCrawlL';
}


bool scrFireBow () {
  if (holdItem !isa ItemWeaponBow) return false;
  sndStopSound('sndBowPull');
  if (!bowArmed) return false;
  if (!holdItem.onTryUseItem(self)) return false;
  return true;
}


void scrUsePutItOnGroundHelper (MapObject it, optional float xVelMult, optional float yVelNew) {
  if (!it) return;

  if (!specified_xVelMult) xVelMult = 0.4;
  if (!specified_yVelNew) yVelNew = 0.5;

  //writeln("putting '", GetClassName(hi.Class), "'");

  if (dir == Dir.Left) {
    it.xVel = (it.heavy ? -4 : -8);
  } else if (dir == Dir.Right) {
    it.xVel = (it.heavy ? 4 : 8);
  }
  it.xVel += xVel;
  it.xVel *= xVelMult;
  it.yVel = yVelNew;

  //hi.fltx = ix;
  it.flty = iy+2;
  if (ItemGoldIdol(it)) it.flty = iy;

  foreach (; 0..16) {
    if (it.isCollisionBottom(0) && !it.isCollisionTop(1)) {
      it.flty -= 1;
    } else {
      break;
    }
  }

  foreach (; 0..16) {
    if (it.isCollisionLeft(0)) {
      if (it.isCollisionRight(1)) break;
      it.fltx += 1;
    } else if (it.isCollisionRight(0)) {
      if (it.isCollisionLeft(1)) break;
      it.fltx -= 1;
    } else {
      break;
    }
  }
}


// put item which player holds in his hands on the ground if player is ducking
// return `true` if item was put
bool scrUsePutItemOnGround (optional float xVelMult, optional float yVelNew) {
  if (holdItem isa PlayerWeapon) return false;

  auto hi = holdItem;
  if (!hi || !scrPlayerIsDucking()) return false;

  if (!onLoosingHeldItem(LostCause.Unknown)) return false;

  //writeln("putting '", GetClassName(hi.Class), "'");

  if (global.bombs > 0) {
    auto bomb = ItemBomb(hi);
    if (bomb && !bomb.armed) global.bombs -= 1;
  }

  if (global.rope > 0) {
    auto rope = ItemRopeThrow(hi);
    if (rope) {
      global.rope -= 1;
      rope.falling = false;
      rope.flying = false;
    }
  }

  holdItem = none;
  hi.resaleValue = 0;
  madeOffer = false;
  hi.makeSafe();

  scrUsePutItOnGroundHelper(hi, xVelMult!optional, yVelNew!optional);

  return true;
}


bool launchRope (bool goDown, bool doDrop) {
  if (global.rope < 1) {
    global.rope = 0;
    if (ItemRopeThrow(holdItem)) scrSwitchToPocketItem(forceIfEmpty:false);
    return false;
  }

  --global.rope;

  bool wasHeld = false;
  ItemRopeThrow rp = ItemRopeThrow(holdItem);
  int xdelta = (doDrop ? 12 : 16)*(dir == Dir.Left ? -1 : 1);
  if (rp) {
    //FIXME: call handler
    wasHeld = true;
    holdItem = none;
    rp.setXY(ix+xdelta, iy);
  } else {
    rp = ItemRopeThrow(level.MakeMapObject(ix+xdelta, iy, 'oRopeThrow'));
  }
  if (rp.heldBy) FatalError("PlayerPawn::launchRope: hold management fucked");
  rp.armed = true;
  rp.flying = false;
  //rp.resaleValue = 0;

  rp.px = ix;
  rp.py = iy;
  if (platformCharacterIs(ON_GROUND)) rp.startY = iy; // YASM 1.7

  if (!goDown) {
    // launch rope up
    rp.setX(fltx);
    rp.xVel = 0;
    rp.yVel = -12;
  } else {
    // launch rope down
    bool t = true;
    rp.moveSnap(16, 1);
    if (ix < rp.ix) {
      if (!level.isSolidAtPoint(ix+(doDrop ? 2 : 8), iy)) { //2
             if (!level.checkTilesInRect(rp.ix-8, rp.iy, 2, 17)) rp.shiftX(-8);
        else if (!level.checkTilesInRect(rp.ix+7, rp.iy, 2, 17)) rp.shiftX(8);
        else t = false;
      } else {
        t = false;
      }
    } else if (!level.isSolidAtPoint(ix-(doDrop ? 2 : 8), iy)) { //2
           if (!level.checkTilesInRect(rp.ix+7, rp.iy, 2, 17)) rp.shiftX(8);
      else if (!level.checkTilesInRect(rp.ix-8, rp.iy, 2, 17)) rp.shiftX(-8);
      else t = false;
    } else {
      t = false;
    }
    //writeln("t=", t);
    if (!t) {
      // cannot launch rope
      /* was commented in the original
      if (oPlayer1.facing == 18) {
        obj = instance_create(oPlayer1.x-4, oPlayer1.y+2, oRopeThrow);
        obj.xVel = -3.2;
      } else {
        obj = instance_create(oPlayer1.x+4, oPlayer1.y+2, oRopeThrow);
        obj.xVel = 3.2;
      }
      obj.yVel = 0.5;
      */
      //writeln("!!! goDown=", goDown, "; doDrop=", doDrop, "; wasHeld=", wasHeld);
      rp.armed = false;
      rp.flying = false;
      if (!wasHeld) doDrop = true;
      if (doDrop) {
        /*
        rp.setXY(ix, iy);
        if (dir == Dir.Left) rp.xVel = -3.2; else rp.xVel = 3.2;
        rp.yVel = 0.5;
        */
        rp.forceFixHoldCoords(self);
        if (goDown) {
          scrUsePutItOnGroundHelper(rp);
        } else {
          scrUseThrowIt(rp);
        }
        if (wasHeld) scrSwitchToPocketItem(forceIfEmpty:false);
      } else {
        //writeln("NO DROP!");
        ++global.rope;
        if (wasHeld) {
          // regain it
          //rp.resaleValue = 1; //k8:???
          holdItem = rp;
        } else {
          rp.instanceRemove();
          if (wasHeld) scrSwitchToPocketItem(forceIfEmpty:false);
        }
      }
      return false;
    } else {
      level.MakeMapObject(rp.ix, rp.iy, 'oRopeTop');
      rp.armed = false;
      rp.falling = true;
      rp.xVel = 0;
      rp.yVel = 0;
    }
  }
  if (wasHeld) scrSwitchToPocketItem(forceIfEmpty:false);
  playSound('sndThrow');
  return true;
}


bool scrLaunchBomb () {
  if (whipping || global.bombs < 1) return false;
  --global.bombs;

  ItemBomb bomb = ItemBomb(level.MakeMapObject(ix, iy, 'oBomb'));
  if (!bomb) return false;
  bomb.forceFixHoldCoords(self);
  bomb.setSticky(global.stickyBombsActive);
  bomb.armIt(80);
  bomb.resaleValue = 0;

  if (kDown || scrPlayerIsDucking()) {
    scrUsePutItOnGroundHelper(bomb);
  } else {
    scrUseThrowIt(bomb);
  }

  return true;
}


bool scrUseItem () {
  auto it = holdItem;
  if (!it) return false;
  //writeln(GetClassName(holdItem.Class));

  //auto spr = holdItem.getSprite();
  /+
  } else if (holdItem.type == "Sceptre") {
    if (kDown) scrUsePutItemOnGround(0.4, 0.5);
    if (firing == 0 && !scrPlayerIsDucking()) {
      if (facing == LEFT) {
        asleft = true;
        xsgn = -1;
      } else {
        asleft = false;
        xsgn = 1;
      }
      xofs = 12*xsgn;
      repeat(3) {
        obj = instance_create(x+xofs, y+4, oPsychicCreateP);
        obj.xVel = xsgn*rand(1, 3);
        obj.yVel = -random(2);
      }
      obj = instance_create(x+xofs, y-2, oPsychicWaveP);
      obj.xVel = xsgn*6;
      playSound(global.sndPsychic);
      firing = firingPistolMax;
    }
  } else if (holdItem.type == "Teleporter II") {
    scrUseTeleporter2();
  } else if (holdItem.type == "Bow") {
    if (kDown) {
      scrUsePutItemOnGround(0.4, 0.5);
    } else if (firing == 0 && !scrPlayerIsDucking() && !bowArmed && global.arrows > 0) {
      bowArmed = true;
      playSound(global.sndBowPull);
    } else if (global.arrows <= 0) {
      global.message = "I'M OUT OF ARROWS!";
      global.message2 = "";
      global.messageTimer = 80;
    }
  } else {
  +/


  if (whipping) return false;

  if (kDown) {
    if (scrPlayerIsDucking()) scrUsePutItemOnGround();
    return true;
  }

  // you cannot throw away shop items, but can throw dices
  if (it.forSale && it !isa ItemDice) {
    if (!level.isInShop(ix/16, iy/16)) {
      it.forSale = false;
    } else {
      // allow throw/use shop items
      //return false;
    }
  }

  //if (it.forSale) writeln(":::FORSALE 000: '", GetClassName(it.Class), "'");
  if (!it.onTryUseItem(self)) {
    //if (it.forSale) writeln(":::FORSALE 001: '", GetClassName(it.Class), "'");
    // throw item
    scrUseThrowItem();
  }

  return true;
}


// ////////////////////////////////////////////////////////////////////////// //
// called by characterStepEvent
// help player jump up through one block wide gaps by nudging them to one side so they don't hit their head
void scrJumpHelper () {
  int d = 4; // max distance to nudge player
  int x = ix, y = iy;
  if (!level.checkTilesInRect(x, y-12, 1, 7)) {
    if (level.checkTilesInRect(x-5, y-12, 1, 7) &&
        level.checkTilesInRect(x+14, y-12, 1, 7))
    {
      while (d > 0 && level.checkTilesInRect(x-5, y-12, 1, 7)) { ++x; shiftX(1); --d; }
    } else if (level.checkTilesInRect(x+5, y-12, 1, 7) &&
               level.checkTilesInRect(x-14, y-12, 1, 7))
    {
      while (d > 0 && level.checkTilesInRect(x+5, y-12, 1, 7)) { --x; shiftX(-1); --d; }
    }
  }
  /+
  if (!collision_line(x, y-6, x, y-12, oSolid, 0, 0)) {
    if (collision_line(x-5, y-6, x-5, y-12, oSolid, 0, 0) &&
        collision_line(x+14, y-6, x+14, y-12, oSolid, 0, 0))
    {
      while (collision_line(x-5, y-6, x-5, y-12, oSolid, 0, 0) && d > 0) {
        x += 1;
        d -= 1;
      }
    }
    else if (collision_line(x+5, y-6, x+5, y-12, oSolid, 0, 0) and
             collision_line(x-14, y-6, x-14, y-12, oSolid, 0, 0))
    {
      while (collision_line(x+5, y-6, x+5, y-12, oSolid, 0, 0) && d > 0) {
        x -= 1;
        d -= 1;
      }
    }
  }
  +/
}


// ////////////////////////////////////////////////////////////////////////// //
/*
 * Returns whether a GENERAL trait about a character is true.
 * Only the platform character should run this script.

 * `tp` can be one of the following:
 *   ON_GROUND
 *   IN_AIR
 *   ON_LADDER
 */
final bool platformCharacterIs (int tp) {
  if (tp == ON_GROUND && (status == RUNNING || status == STANDING || status == DUCKING || status == LOOKING_UP)) return true;
  if (tp == IN_AIR && (status == JUMPING || status == FALLING)) return true;
  if (tp == ON_LADDER && status == CLIMBING) return true;
  return false;
}


// ////////////////////////////////////////////////////////////////////////// //
// sets the sprite of the character depending on his/her status
final void characterSprite () {
  if (status == STOPPED) {
         if (global.isDamsel) setSprite('sDamselLeft');
    else if (global.isTunnelMan) setSprite('sTunnelLeft');
    else setSprite('sStandLeft');
    return;
  }

  int x = ix, y = iy;
  if (global.isTunnelMan && !stunned && !whipping) {
    // Tunnel Man
    if (status == STANDING) {
      if (!level.isSolidAtPoint(x-2, y+9)) {
        imageSpeed = 0.6;
        setSprite('sTunnelWhoaL');
      } else {
        setSprite('sTunnelLeft');
      }
    }
    if (status == RUNNING) {
      if (kUp) setSprite('sTunnelLookRunL'); else setSprite('sTunnelRunL');
    }
    if (status == DUCKING) {
           if (xVel == 0) setSprite('sTunnelDuckL');
      else if (fabs(xVel) < 3) setSprite('sTunnelCrawlL');
      else setSprite('sTunnelRunL');
    }
    if (status == LOOKING_UP) {
      if (fabs(xVel) > 0) setSprite('sTunnelRunL'); else setSprite('sTunnelLookL');
    }
    if (status == JUMPING) setSprite('sTunnelJumpL');
    if (status == FALLING && statePrev == FALLING && statePrevPrev == FALLING) setSprite('sTunnelFallL');
    if (status == HANGING) setSprite('sTunnelHangL');
    if (pushTimer > 20) setSprite('sTunnelPushL');
    if (status == DUCKTOHANG) setSprite('sTunnelDtHL');
    if (status == CLIMBING) {
      if (level.isRopeAtPoint(x, y)) {
        if (kDown) setSprite('sTunnelClimb3'); else setSprite('sTunnelClimb2');
      } else {
        setSprite('sTunnelClimb');
      }
    }
  } else if (global.isDamsel && !stunned && !whipping) {
    // Damsel
    if (status == STANDING) {
      if (!level.isSolidAtPoint(x-2, y+9)) {
        imageSpeed = 0.6;
        setSprite('sDamselWhoaL');
        /* was commented out in the original
        if (holdItem && whoaTimer < 1) {
          holdItem.held = false;
          if (facing == LEFT) holdItem.xVel = -2; else holdItem.xVel = 2;
          if (holdItem.type == "Damsel") playSound('sndDamsel');
          if (holdItem.type == pickupItemType) { holdItem = 0; pickupItemType = ""; } else scrSwitchToPocketItem();
        }
        */
      } else {
        setSprite('sDamselLeft');
      }
    }
    if (status == RUNNING) {
      if (kUp) setSprite('sDamselRunL'); else setSprite('sDamselRunL');
    }
    if (status == DUCKING) {
           if (xVel == 0) setSprite('sDamselDuckL');
      else if (fabs(xVel) < 3) setSprite('sDamselCrawlL');
      else setSprite('sDamselRunL');
    }
    if (status == LOOKING_UP) {
      if (fabs(xVel) > 0) setSprite('sDamselRunL'); else setSprite('sDamselLookL');
    }
    if (status == JUMPING) setSprite('sDamselDieLR');
    if (status == FALLING && statePrev == FALLING && statePrevPrev == FALLING) setSprite('sDamselFallL');
    if (status == HANGING) setSprite('sDamselHangL');
    if (pushTimer > 20) setSprite('sDamselPushL');
    if (status == DUCKTOHANG) setSprite('sDamselDtHL');
    if (status == CLIMBING) {
      if (level.isRopeAtPoint(x, y)) {
        if (kDown) setSprite('sDamselClimb3'); else setSprite('sDamselClimb2');
      } else {
        setSprite('sDamselClimb');
      }
    }
  } else if (!stunned && !whipping) {
    // Spelunker
    if (status == STANDING) {
      if (!level.checkTileAtPoint(x-(dir == Dir.Left ? 2 : 0), y+9, &level.cbCollisionForWhoa)) {
        imageSpeed = 0.6;
        setSprite('sWhoaLeft');
        /* was commented out in the original
        if (holdItem && whoaTimer < 1) {
          holdItem.held = false;
          if (facing == LEFT) holdItem.xVel = -2; else holdItem.xVel = 2;
          if (holdItem.type == "Damsel") playSound('sndDamsel');
          if (holdItem.type == pickupItemType) { holdItem = 0; pickupItemType = ""; } else scrSwitchToPocketItem();
        }
        */
      } else {
        setSprite('sStandLeft');
      }
    }
    if (status == RUNNING) {
      if (kUp) setSprite('sLookRunL'); else setSprite('sRunLeft');
    }
    if (status == DUCKING) {
           if (xVel == 0) setSprite('sDuckLeft');
      else if (fabs(xVel) < 3) setSprite('sCrawlLeft');
      else setSprite('sRunLeft');
    }
    if (status == LOOKING_UP) {
      if (fabs(xVel) > 0) setSprite('sLookRunL'); else setSprite('sLookLeft');
    }
    if (status == JUMPING) setSprite('sJumpLeft');
    if (status == FALLING && statePrev == FALLING && statePrevPrev == FALLING) setSprite('sFallLeft');
    if (status == HANGING) setSprite('sHangLeft');
    if (pushTimer > 20) setSprite('sPushLeft');
    if (status == CLIMBING) {
      if (level.isRopeAtPoint(x, y)) {
        if (kDown) setSprite('sClimbUp3'); else setSprite('sClimbUp2');
      } else {
        setSprite('sClimbUp');
      }
    }
    if (status == DUCKTOHANG) setSprite('sDuckToHangL');
  }

}


// ////////////////////////////////////////////////////////////////////////// //
void addScore (int delta) {
  if (!level.isNormalLevel()) return;
  //score += delta;
  if (delta == 0) return;
  level.stats.addMoney(delta);
  if (delta > 0) {
    level.xmoney += delta;
    level.collectCounter = min(100, level.collectCounter+20);
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// for dead players too
// first, the code will call `onObjectTouched()` for player
// if it returned `false`, the code will call `obj.onTouchedByPlayer()`
// note that player's handler is called *after* its frame thinker,
// but object handler is called *before* frame thinker for the object
// i.e. return `true` to block calling `obj.onTouchedByPlayer()`,
// (but NOT object thinker)
bool onObjectTouched (MapObject obj) {
  // is player dead?
  if (dead || global.plife <= 0) return false; // player may be rendered dead, but not yet transited to dead state

  if (obj isa ItemProjectileArrow && holdItem isa ItemWeaponBow && !stunned && global.arrows < 99) {
    if (fabs(obj.xVel) < 1 && fabs(obj.yVel) < 1 && !obj.stuck) {
      ++global.arrows;
      playSound('sndPickup');
      obj.instanceRemove();
      return true;
    }
  }

  // collect treasure
  auto treasure = ItemTreasure(obj);
  if (treasure && treasure.canCollect) {
    if (treasure.value) addScore(treasure.value);
    treasure.onCollected(self); // various other effects
    playSound(treasure.soundName);
    treasure.instanceRemove();
    return true;
  }

  // collect blood
  if (global.hasKapala && obj isa MapObjBlood) {
    global.bloodLevel += 1;
    level.MakeMapObject(obj.ix, obj.iy, 'oBloodSpark');
    obj.instanceRemove();

    if (global.bloodLevel > 8) {
      global.bloodLevel = 0;
      global.plife += 1;
      level.MakeMapObject(ix, iy-8, 'oHeart');
      playSound('sndKiss');
    }

    if (redColor < 55) redColor += 5;
    redToggle = false;
  }

  // other objects will take care of themselves
  return false;
}


// return `false` to prevent
// holdItem is valid
bool onLoosingHeldItem (LostCause cause) {
  if (level.inWinCutscene != 0) return false;
  return true;
}


// ////////////////////////////////////////////////////////////////////////// //
// k8: don't even ask me! the following mess is almost straightforward port of the original Derek's code!
private final void closeCape () {
  auto pp = PPCape(findPowerup('Cape'));
  if (pp) pp.open = false;
}


private final void switchCape () {
  auto pp = PPCape(findPowerup('Cape'));
  if (pp) pp.open = !pp.open;
}


final bool isCapeActiveAndOpen () {
  auto pp = PPCape(findPowerup('Cape'));
  return (pp && pp.active && pp.open);
}


final bool isParachuteActive () {
  auto pp = findPowerup('Parachute');
  return (pp && pp.active);
}


// ////////////////////////////////////////////////////////////////////////// //
// for cutscenes
bool checkSkipCutScene () {
  if (skipCutscenePressed) {
    return level.isKeyReleased(GameConfig::Key.Pay);
  } else {
    skipCutscenePressed = level.isKeyPressed(GameConfig::Key.Pay);
    return false;
  }
}

int transKissTimer;


bool forcePlayerControls () {
  if (level.inWinCutscene) {
    unpressAllKeys();
    level.winCutscenePlayerControl(self);
    return true;
  } else if (level.inIntroCutscene) {
    unpressAllKeys();
    level.introCutscenePlayerControl(self);
    //return false;
    return true;
  } else if (level.levelKind == GameLevel::LevelKind.Transition) {
    unpressAllKeys();

    if (checkSkipCutScene()) {
      level.playerExited = true;
      return true;
    }

    auto door = level.checkTileAtPoint(ix, iy, &level.cbCollisionExitTile);
    if (door) {
      kExitPressed = true;
      return true;
    }

    if (status == STOPPED) {
      if (--transKissTimer > 0) return true;
      status = STANDING;
    }

    transKissTimer = 0;
    auto dms = MonsterDamselKiss(level.isObjectAtPoint(ix+8, iy+4, delegate bool (MapObject o) { return (o isa MonsterDamselKiss); }));
    if (dms && !dms.kissed) {
      status = STOPPED;
      xVel = 0;
      yVel = 0;
      dms.kiss();
      transKissTimer = 30;
      return true;
    }

    kRight = true;
    kRightPressed = true;
    return true;
  }
  return false;
}


// ////////////////////////////////////////////////////////////////////////// //
private final void checkControlKeys (SpriteImage spr) {
  if (forcePlayerControls()) {
    if (movementBlocked) unpressAllKeys();
    if (kLeft) kLeftPushedSteps += 1; else kLeftPushedSteps = 0;
    if (kRight) kRightPushedSteps += 1; else kRightPushedSteps = 0;
    return;
  }

  kLeft = level.isKeyDown(GameConfig::Key.Left);
  if (movementBlocked) kLeft = false;
  if (kLeft) kLeftPushedSteps += 1; else kLeftPushedSteps = 0;
  kLeftPressed = level.isKeyPressed(GameConfig::Key.Left);
  kLeftReleased = level.isKeyReleased(GameConfig::Key.Left);

  kRight = level.isKeyDown(GameConfig::Key.Right);
  if (movementBlocked) kRight = false;
  if (kRight) kRightPushedSteps += 1; else kRightPushedSteps = 0;
  kRightPressed = level.isKeyPressed(GameConfig::Key.Right);
  kRightReleased = level.isKeyReleased(GameConfig::Key.Right);

  kUp = level.isKeyDown(GameConfig::Key.Up);
  kDown = level.isKeyDown(GameConfig::Key.Down);

  kJump = level.isKeyDown(GameConfig::Key.Jump);
  kJumpPressed = level.isKeyPressed(GameConfig::Key.Jump);
  kJumpReleased = level.isKeyReleased(GameConfig::Key.Jump);

  if (movementBlocked) unpressAllKeys();

  if (cantJump > 0) {
    kJump = false;
    kJumpPressed = false;
    kJumpReleased = false;
    --cantJump;
  } else if (spr && global.isTunnelMan && spr.Name == 'sTunnelAttackL' && !holdItem) {
    kJump = false;
    kJumpPressed = false;
    kJumpReleased = false;
    cantJump = max(0, cantJump-1);
  }

  kAttack = level.isKeyDown(GameConfig::Key.Attack);
  kAttackPressed = level.isKeyPressed(GameConfig::Key.Attack);
  kAttackReleased = level.isKeyReleased(GameConfig::Key.Attack);

  kItemPressed = level.isKeyPressed(GameConfig::Key.Switch);
  kRopePressed = level.isKeyPressed(GameConfig::Key.Rope);
  kBombPressed = level.isKeyPressed(GameConfig::Key.Bomb);

  kPayPressed = level.isKeyPressed(GameConfig::Key.Pay);

  if (movementBlocked) unpressAllKeys();

  kExitPressed = false;
  if (global.config.useDoorWithButton) {
    if (kPayPressed) kExitPressed = true;
  } else {
    if (kUp) kExitPressed = true;
  }

  if (stunned || dead) {
    unpressAllKeys();
    //level.clearKeysPressRelease();
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// knock off monkeys that grabbed you
void knockOffMonkeys () {
  level.forEachObject(delegate bool (MapObject o) {
    auto mk = EnemyMonkey(o);
    if (mk && !mk.dead && mk.status == GRAB) {
      mk.xVel = global.randOther(0, 1)-global.randOther(0, 1);
      mk.yVel = -4;
      mk.status = BOUNCE;
      mk.vineCounter = 20;
      mk.grabCounter = 60;
    }
    return false;
  });
}


// ////////////////////////////////////////////////////////////////////////// //
// fix collision with boulder (bug with non-aligned boulder)
void hackBoulderCollision () {
  auto bld = level.checkTilesInRect(x0, y0, width, height, delegate bool (MapTile o) { return (o isa ObjBoulder); });
  if (bld && fabs(bld.xVel) <= 1) {
    writeln("IN BOULDER!");
    if (x0 < bld.x0) {
      int dx = bld.x0-x0;
      writeln("  LEFT: dx=", dx);
      if (dx <= 2) fltx = x0-dx;
    } else if (x1 > bld.x1) {
      int dx = x1-bld.x1;
      writeln("  RIGHT: dx=", dx);
      if (dx <= 2) fltx = x1-dx;
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
bool checkHangTileDG (MapTile t) { return (t.solid || t.tree); }


void checkPerformHang (bool colLeft, bool colRight) {
  if (status == HANGING || platformCharacterIs(ON_GROUND)) return;
  if ((kLeft && kRight) || (!kLeft && !kRight)) return;
  if (kLeft && !colLeft) {
#ifdef HANG_DEBUG
    writeln("checkPerformHang: no left solid");
#endif
    return;
  }
  if (kRight && !colRight) {
#ifdef HANG_DEBUG
    writeln("checkPerformHang: no right solid");
#endif
    return;
  }
  if (hangCount != 0) {
#ifdef HANG_DEBUG
    writeln("checkPerformHang: hangCount=", hangCount);
#endif
    return;
  }
  if (iy <= 16) return;
  int dx = (kLeft ? -9 : 9);
#ifdef HANG_DEBUG
  writeln("checkPerformHang: trying to hang at ", dx);
#endif

  bool doHang = false;

  if (global.hasGloves) {
    doHang = (yVel > 0 && !!level.checkTilesInRect(ix+dx, iy-6, 1, 2, &checkHangTileDG));
  } else {
    // hang on tree?
    doHang = !!level.checkTilesInRect(ix+dx, iy-6, 1, 2, &level.cbCollisionAnyTree);
#ifdef HANG_DEBUG
    writeln("  tree: ", doHang);
#endif
    // hang on solid?
    if (!doHang) {
      doHang = level.checkTilesInRect(ix+dx, iy-6, 1, 2) &&
               !level.isSolidAtPoint(ix+dx, iy-9) && !level.isSolidAtPoint(ix, iy+9);
#ifdef HANG_DEBUG
      writeln("  solid: ", doHang);
#endif
    }
    if (!doHang) {
#ifdef HANG_DEBUG
      writeln("    solid at dx, -6(1): ", !!level.checkTilesInRect(ix+dx, iy-6, 1, 2));
      writeln("    solid at dx, -9(0): ", !!level.isSolidAtPoint(ix+dx, iy-9));
      writeln("    solid at  0, +9(0): ", !!level.isSolidAtPoint(ix, iy-9));
#endif
#ifdef EASIER_HANG
      doHang = level.checkTilesInRect(ix+dx, iy-6, 1, 2) &&
               !level.isSolidAtPoint(ix+dx, iy-10) && !level.isSolidAtPoint(ix, iy+9);
#ifdef HANG_DEBUG
      if (!doHang) writeln("    easier hang failed");
#endif
      /*
      if (!level.isSolidAtPoint(ix, iy-9)) {
        foreach (int dy; 6..24) {
          writeln("    solid at dx:-", dy, "(0): ", !!level.isSolidAtPoint(ix+dx, iy-dy));
        }
        writeln("   ix=", ix, "; iy=", iy);
      }
      */
#endif
    }
  }

  if (doHang) {
    status = HANGING;
    moveSnap(1, 8);
    yVel = 0;
    yAcc = 0;
    grav = 0;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final void characterStepEvent () {
  if (climbSoundTimer > 0) {
    if (--climbSoundTimer == 0) {
      playSound(climbSndToggle ? 'sndClimb2' : 'sndClimb1');
      climbSndToggle = !climbSndToggle;
    }
  }

  auto spr = getSprite();
  checkControlKeys(spr);

  float xPrev = fltx, yPrev = flty;
  int x = ix, y = iy;

  // check collisions in various directions
  bool colSolidLeft = !!getPushableLeft(1);
  bool colSolidRight = !!getPushableRight(1);
  bool colLeft = !!isCollisionLeft(1);
  bool colRight = !!isCollisionRight(1);
  bool colTop = !!isCollisionTop(1);
  bool colBot = !!isCollisionBottom(1);
  bool colLadder = !!isCollisionLadder();
  bool colPlatBot = !!isCollisionBottom(1, &level.cbCollisionPlatform);
  bool colPlat = !!isCollision(&level.cbCollisionPlatform);
  //bool colWaterTop = !!isCollisionTop(1, &level.cbCollisionWater);
  bool colWaterTop = !!level.checkTilesInRect(x0, y0-1, width, 3, &level.cbCollisionWater);
  bool colIceBot = !!level.isIceAtPoint(x, y+8);

  bool runKey = false;
  if (level.isKeyDown(GameConfig::Key.Run)) { runHeld = 100; runKey = true; }
  if (level.isKeyDown(GameConfig::Key.Attack) && !whipping) { runHeld += 1; runKey = true; }
  if (!runKey || (!kLeft && !kRight)) runHeld = 0;

  // allows the character to run left and right
  // if state!=DUCKING and state!=LOOKING_UP and state!=CLIMBING
  if (status != CLIMBING && status != HANGING) {
    if (kLeftReleased && fabs(xVel) < 0.0001) xAcc -= 0.5;
    if (kRightReleased && fabs(xVel) < 0.0001) xAcc += 0.5;
    if (kLeft && !kRight) {
      if (colSolidLeft) {
        //xVel = 3; // in orig
        if (platformCharacterIs(ON_GROUND) && status != DUCKING) {
          xAcc -= 1;
          pushTimer += 10;
          //playSound('sndPush', unique:true);
        }
      } else if (kLeftPushedSteps > 2 && (dir == Dir.Left || fabs(xVel) < 0.0001)) {
        xAcc -= runAcc;
      }
      dir = Dir.Left;
      //if (platformCharacterIs(ON_GROUND) && fabs(xVel) > 0 && alarm[3] < 1) alarm[3] = floor(16/-xVel);
    }
    if (kRight && !kLeft) {
      if (colSolidRight) {
        //xVel = 3; // in orig
        if (platformCharacterIs(ON_GROUND) && status != DUCKING) {
          xAcc += 1;
          pushTimer += 10;
          //playSound('sndPush', unique:true);
        }
      } else if ((kRightPushedSteps > 2 || colSolidLeft) && (dir == Dir.Right || fabs(xVel) < 0.0001)) {
        xAcc += runAcc;
      }
      dir = Dir.Right;
      //if (platformCharacterIs(ON_GROUND) && fabs(xVel) > 0 && alarm[3] < 1) alarm[3] = floor(16/xVel);
    }
  }

  // ladders
  if (status == CLIMBING) {
    closeCape();
    kJumped = false;
    ladderTimer = 10;
    auto ladder = level.isLadderAtPoint(x, y);
    if (ladder) { x = ladder.ix+8; setX(x); }
    if (kLeft) dir = Dir.Left; else if (kRight) dir = Dir.Right;
    if (kUp) {
      // checks both ladder and laddertop
      if (level.isAnyLadderAtPoint(x, y-8)) {
        //writeln("LADDER00! old yAcc=", yAcc, "; climbAcc=", climbAcc, "; new yAcc=", yAcc-climbAcc);
        yAcc -= climbAcc;
        if (climbSoundTimer < 1) climbSoundTimer = climbSndSpeed;
        //!if (alarm[2] < 1) alarm[2] = climbSndSpeed;
      } else {
        /*
        for (int dy = -6; dy > -12; --dy) {
          ladder = level.isAnyLadderAtPoint(x, y+dy);
          if (ladder) {
            writeln("::: ", dy, ": plrx=", x, "; ladder.xy0=(", ladder.x0, ",", ladder.y0, "); ladder.ixy=(", ladder.ix, ",", ladder.iy, "); wdt=", ladder.width, "; hgt=", ladder.height, "; ladder class=", GetClassName(ladder.Class));
          }
        }
        */
        /*
        auto grid = level.miscTileGrid;
        foreach (MapTile t; grid.inCellPix(48, 96, grid.nextTag(), precise:false)) {
          writeln("at 48, 96: ", GetClassName(t.Class), "; pos=(", t.ix, ",", t.iy, ")");
        }
        foreach (MapTile t; grid.inCellPix(48, 94, grid.nextTag(), precise:false)) {
          writeln("at 48, 94: ", GetClassName(t.Class), "; pos=(", t.ix, ",", t.iy, ")");
        }
        foreach (int dy; 90..102) {
          ladder = level.isAnyLadderAtPoint(48, dy);
          if (ladder) {
            writeln("::: ", dy, ": plrx=", x, "; ladder.xy0=(", ladder.x0, ",", ladder.y0, "); ladder.ixy=(", ladder.ix, ",", ladder.iy, "); wdt=", ladder.width, "; hgt=", ladder.height, "; ladder class=", GetClassName(ladder.Class));
          }
        }
        */
      }
    } else if (kDown) {
      // checks both ladder and laddertop
      if (level.isAnyLadderAtPoint(x, y+8)) {
        yAcc += climbAcc;
        //!if (alarm[2] < 1) alarm[2] = climbSndSpeed;
        if (climbSoundTimer < 1) climbSoundTimer = climbSndSpeed;
      } else {
        status = FALLING;
      }
      if (colBot) status = STANDING;
    }
    // jump from ladder
    if (kJumpPressed && !whipping) {
      if (kLeft) xVel = -departLadderXVel; else if (kRight) xVel = departLadderXVel; else xVel = 0;
      //yAcc += departLadderYVel;
      //k8: was `0.6`, but with `0.4` we can jump onto the wall above, and with `0.6` we cannot
      yAcc = 0.4+departLadderYVel; // YASM 1.8.1 Fix for extra air when jumping off ladders due to increased climb speed option
      status = JUMPING;
      jumpButtonReleased = false;
      jumpTime = 0;
      ladderTimer = 5;
    }
  } else {
    if (ladderTimer > 0) ladderTimer -= 1;
  }

  if (platformCharacterIs(IN_AIR) && status != HANGING) yAcc += gravityIntensity;

  // player has landed
  if ((colBot || colPlatBot) && platformCharacterIs(IN_AIR) && yVel >= 0) {
    if (!colPlat || colBot) {
      yVel = 0;
      yAcc = 0;
      status = RUNNING;
    }
    playSound('sndLand');
  }
  if ((colBot || colPlatBot) && !colPlat) yVel = 0;

  // player has just walked off of the edge of a solid
  if (colBot == 0 && (!colPlatBot || colPlat) && platformCharacterIs(ON_GROUND)) {
    status = FALLING;
    yAcc += grav;
    kJumped = true;
    if (global.hasGloves) hangCount = 5;
  }

  if (colTop) {
         if (dead || stunned) yVel = -yVel*0.8;
    else if (status == JUMPING) yVel = fabs(yVel*0.3);
  }

  if ((colLeft && dir == Dir.Left) || (colRight && dir == Dir.Right)) {
    if (dead || stunned) xVel = -xVel*0.5; else xVel = 0;
  }

  // jumping
  if (kJumpReleased && platformCharacterIs(IN_AIR)) {
    kJumped = true;
  } else if (platformCharacterIs(ON_GROUND)) {
    closeCape();
    kJumped = false;
  }

  MapObject oWeb = none, oBlob = none;
  if (kJumpPressed) {
    oWeb = level.isObjectAtPoint(x, y, &level.cbIsObjectWeb);
    if (!oWeb) oBlob = level.isObjectAtPoint(x, y, &level.cbIsObjectBlob);
  }

  bool invokeJumpHelper = false;

  if (kJumpPressed && oWeb) {
    ItemWeb(oWeb).tear(1);
    yAcc += initialJumpAcc*2;
    yVel -= 3;
    xAcc += xVel/2;

    status = JUMPING;
    jumpButtonReleased = false;
    jumpTime = 0;

    grav = gravNorm;
    invokeJumpHelper = true;
  } else if (kJumpPressed && oBlob) {
    oBlob.hp -= 5;
    scrCreateBloblets(oBlob.x0+8, oBlob.y0+8, 1);
    playSound('sndHit');
    yAcc += initialJumpAcc*2;
    yVel -= 2;
    xAcc += xVel/2;
    status = JUMPING;
    jumpButtonReleased = false; // k8: was `jumpButtonRelease`
    jumpTime = 0;
    invokeJumpHelper = true;
  } else if (kJumpPressed && colWaterTop) {
    yAcc += initialJumpAcc*2;
    yVel -= 3;
    xAcc += xVel/2;

    status = JUMPING;
    jumpButtonReleased = false;
    jumpTime = 0;

    grav = gravNorm;
    invokeJumpHelper = true;
  } else if (global.hasCape && kJumpPressed && kJumped && platformCharacterIs(IN_AIR)) {
    switchCape();
  } else if (global.hasJetpack && !swimming && kJump && kJumped && platformCharacterIs(IN_AIR) && jetpackFuel > 0) {
    yAcc += initialJumpAcc;
    yVel = -1;
    jetpackFuel -= 1;
    if (jetpackFlaresTime < 1) jetpackFlaresTime = 3;
    //!if (alarm[10] < 1) alarm[10] = 3; // jetpack flares
    fallTimer = 0;

    status = JUMPING;
    jumpButtonReleased = false;
    jumpTime = 0;

    grav = 0;
    invokeJumpHelper = true;
  } else if (platformCharacterIs(ON_GROUND) && kJumpPressed && fallTimer == 0) {
    if (fabs(xVel) > 3 /*xVel > 3 || xVel < -3*/) {
      yAcc += initialJumpAcc*2;
      xAcc += xVel*2;
    } else {
      yAcc += initialJumpAcc*2;
      xAcc += xVel/2;
      //scrJumpHelper(); // move to location where player doesn't have to be on ground
    }
    if (global.hasJordans) {
      yAcc *= 3;
      yAccLimit = 12;
      grav = 0.5;
    } else if (global.hasSpringShoes) {
      yAcc *= 1.5;
    } else {
      yAccLimit = 6;
      grav = gravNorm;
    }

    playSound('sndJump');

    pushTimer = 0;

    // the "state" gets changed to JUMPING later on in the code
    status = FALLING;
    // "variable jumping" states
    jumpButtonReleased = false;
    jumpTime = 0;
    invokeJumpHelper = true;
  }

  if (kJumpPressed && invokeJumpHelper) scrJumpHelper(); // YASM 1.8.1

  if (jumpTime < jumpTimeTotal) jumpTime += 1;
  // let the character continue to jump
  if (!kJump) jumpButtonReleased = true;
  if (jumpButtonReleased) jumpTime = jumpTimeTotal;

  gravityIntensity = (jumpTime/jumpTimeTotal)*grav;

  if (kUp && platformCharacterIs(ON_GROUND) && !colLadder) {
    //k8:!!!looking = UP;
    if (xVel == 0 && xAcc == 0) status = LOOKING_UP;
  } else {
    //k8:!!!looking = 0;
  }

  if (!kUp && status == LOOKING_UP) status = STANDING;

  // hanging
  if (!colTop) {
    checkPerformHang(colLeft, colRight);
    x = ix;
    y = iy;

    // hang on stuck arrow
    if (status == FALLING && hangCount == 0 && y > 16 && !platformCharacterIs(ON_GROUND) &&
        !level.isSolidAtPoint(x, y+12)) // from Spelunky Natural
    {
      auto arrow = level.isObjectInRect(ix, iy, 16, 16, delegate bool (MapObject o) {
        /*
        writeln("---");
        writeln(" ARROW : (", o.x0, ",", o.y0, ")-(", o.x1, ",", o.y1, "); coll=", o.collidesWith(self));
        writeln(" PLAYER: (", x0, ",", y0, ")-(", x1, ",", y1, "); coll=", self.collidesWith(o), "; dy=", iy-o.iy);
        */
        if (o.stuck && iy-o.iy >= -6 && iy-o.iy <= -5 && o.collidesWith(self)) {
          //writeln(" *** HANG IS POSSIBLE! p5=", !!level.isObjectAtPoint(ix, iy-5, &level.cbIsObjectArrow), "; p6=", !!level.isObjectAtPoint(ix, iy-6, &level.cbIsObjectArrow));
          return true;
        }
        return false;
      }, castClass:ItemProjectileArrow, precise:false);
      if (arrow) {
        status = HANGING;
        // move_snap(1, 8); // was commented out in the original
        yVel = 0;
        yAcc = 0;
        grav = 0;
      }
      /*
      writeln("TRYING ARROW HANG ALLOWED");
      writeln("  Z00: ", !level.isObjectAtPoint(x, y-9, &level.cbIsObjectArrow));
      writeln("  Z01: ", !level.isObjectAtPoint(x, y+9, &level.cbIsObjectArrow));
      writeln("  Z02: ", !!level.isObjectAtPoint(x, y-5, &level.cbIsObjectArrow));
      writeln("  Z03: ", !!level.isObjectAtPoint(x, y-6, &level.cbIsObjectArrow));
      level.isObjectInRect(ix, iy, 16, 16, delegate bool (MapObject o) {
        writeln("---");
        writeln(" ARROW : (", o.x0, ",", o.y0, ")-(", o.x1, ",", o.y1, "); coll=", o.collidesWith(self));
        writeln(" PLAYER: (", x0, ",", y0, ")-(", x1, ",", y1, "); coll=", self.collidesWith(o), "; dy=", iy-o.iy);
        if (iy-o.iy >= -6 && iy-o.iy <= -5 && o.collidesWith(self)) {
          writeln(" *** HANG IS POSSIBLE! p5=", !!level.isObjectAtPoint(ix, iy-5, &level.cbIsObjectArrow), "; p6=", !!level.isObjectAtPoint(ix, iy-6, &level.cbIsObjectArrow));
        }
        return false;
      }, castClass:ItemProjectileArrow, precise:false);
      */
    }

    // hang on stuck arrow
    /*k8: this is not working due to collision issues; see the fixed code above
    if (status == FALLING && hangCount == 0 && y > 16 && !platformCharacterIs(ON_GROUND) &&
        !level.isSolidAtPoint(x, y+12) && // from Spelunky Natural
        !level.isObjectAtPoint(x, y-9, &level.cbIsObjectArrow) && !level.isObjectAtPoint(x, y+9, &level.cbIsObjectArrow))
    {
      //obj = instance_nearest(x, y-5, oArrow);
      auto arr0 = level.isObjectAtPoint(x, y-5, &level.cbIsObjectArrow);
      auto arr1 = level.isObjectAtPoint(x, y-6, &level.cbIsObjectArrow);
      if (arr0 || arr1) {
        writeln("ARROW HANG!");
        // get nearest arrow
        MapObject arr;
        if (arr1 && arr0) {
          arr = (arr0.distanceToPoint(x, y-5) < arr1.distanceToPoint(x, y-5) ? arr0 : arr1);
        } else {
          arr = (arr0 ? arr0 : arr1);
        }
        if (arr.stuck) {
          status = HANGING;
          // move_snap(1, 8); // was commented out in the original
          yVel = 0;
          yAcc = 0;
          grav = 0;
        }
      }
    }
    */
    /* this was commented in the original
    if (hangCount == 0 && y > 16 && !platformCharacterIs(ON_GROUND) && state == FALLING &&
        (collision_point(x, y-5, oTreeBranch, 0, 0) || collision_point(x, y-6, oTreeBranch, 0, 0)) &&
        !collision_point(x, y-9, oTreeBranch, 0, 0) && !collision_point(x, y+9, oTreeBranch, 0, 0))
    {
      state = HANGING;
      // move_snap(1, 8); // was commented out in the original
      yVel = 0;
      yAcc = 0;
      grav = 0;
    }
    */
  }

  if (hangCount > 0) --hangCount;

  if (status == HANGING) {
    closeCape();
    kJumped = false;
    if (kJumpPressed) {
      if (kDown) {
        if (global.hasGloves) {
          if (hangCount == 0 && y > 16 && !platformCharacterIs(ON_GROUND)) {
            if (kRight && colRight &&
                (level.isSolidAtPoint(x+9, y-5) || level.isSolidAtPoint(x+9, y-6)))
            {
              grav = gravNorm;
              status = FALLING;
              yAcc -= grav;
              hangCount = 10;
            } else if (kLeft && colLeft &&
                       (level.isSolidAtPoint(x-9, y-5) || level.isSolidAtPoint(x-9, y-6)))
            {
              grav = gravNorm;
              status = FALLING;
              yAcc -= grav;
              hangCount = 10;
            } else {
              grav = gravNorm;
              status = FALLING;
              yAcc -= grav;
              hangCount = 5;
            }
          }
        } else {
          grav = gravNorm;
          status = FALLING;
          yAcc -= grav;
          hangCount = 5;
        }
      } else {
        grav = gravNorm;
        status = JUMPING;
        yAcc += initialJumpAcc*2;
        shiftX(dir == Dir.Right ? -2 : 2);
        x = ix;
        cameraBlockX = 3;
        hangCount = hangCountMax;
        if (level.isObjectAtPoint(x, y-5, &level.cbIsObjectArrow) || level.isObjectAtPoint(x, y-6, &level.cbIsObjectArrow)) hangCount /= 2; //Spelunky Natural
      }
    }
    if ((dir == Dir.Left && !isCollisionLeft(2)) ||
        (dir == Dir.Right && !isCollisionRight(2)))
    {
      grav = gravNorm;
      status = FALLING;
      yAcc -= grav;
      hangCount = 4;
    }
  } else {
    grav = gravNorm;
  }

  // pressing down while standing
  if (kDown && platformCharacterIs(ON_GROUND) && !whipping) {
    if (colBot) {
      status = DUCKING;
    } else if (colPlatBot) {
      // climb down ladder if possible, else jump down
      fallTimer = 0;
      if (!colBot) {
        //ladder = instance_place(x, y+16, oLadder);

        // from Spelunky Natural
        /*
        ladder = collision_line(x-4, y+16, x+4, y+16, oLadder, 0, 0);
        if (!ladder) ladder = collision_line(x-4, y+16, x+4, y+16, oLadderTop, 0, 0);
        */
        auto ladder = level.checkTilesInRect(x-4, y+16, 9, 1, &level.cbCollisionAnyLadder);
        //writeln("DOWN; cpb=", colPlatBot, "; cb=", colBot, "; ladder=", !!ladder);

        if (ladder) {
          if (abs(x-(ladder.x0+8)) < 4) {
            x = ladder.ix+8;
            setX(x);
            xVel = 0;
            yVel = 0;
            xAcc = 0;
            yAcc = 0;
            status = CLIMBING;
          }
        } else {
          shiftY(1);
          y = iy;
          status = FALLING;
          yAcc += grav;
          kJumped = true; // Spelunky Natural
        }
      }
      else {
        // the character can't move down because there is a solid in the way
        status = RUNNING;
      }
    }
  }
  if (!kDown && status == DUCKING) {
    status = STANDING;
    xVel = 0;
    xAcc = 0;
  }
  if (xVel == 0 && xAcc == 0 && status == RUNNING) status = STANDING;
  if (xAcc != 0 && status == STANDING) status = RUNNING;
  if (yVel < 0 && platformCharacterIs(IN_AIR) && status != HANGING) status = JUMPING;
  if (yVel > 0 && platformCharacterIs(IN_AIR) && status != HANGING) status = FALLING;
  setCollisionBounds(-5, -6, 5, 8);

  // CLIMB LADDER
  bool colPointLadder = !!level.isAnyLadderAtPoint(x, y);

  /* this was commented in the original
  if ((kUp && platformCharacterIs(IN_AIR) && collision_point(x, y-8, oLadder, 0, 0) && ladderTimer == 0) ||
      (kUp && colPointLadder && ladderTimer == 0) ||
      (kDown && colPointLadder && ladderTimer == 0 && platformCharacterIs(ON_GROUND) && collision_point(x, y+9, oLadderTop, 0, 0) && xVel == 0))
  {
    ladder = 0;
    ladder = instance_place(x, y-8, oLadder);
    if (instance_exists(ladder)) {
      if (abs(x-(ladder.x0+8)) < 4) {
        x = ladder.ix+8;
        setX(x);
        if (!collision_point(x, y, oLadder, 0, 0) && !collision_point(x, y, oLadderTop, 0, 0)) { y = ladder.iy+14; setY(y); }
        xVel = 0;
        yVel = 0;
        xAcc = 0;
        yAcc = 0;
        state = CLIMBING;
      }
    }
  }*/

  // Spelunky Natural - Multiple changes to this big "if" condition
  if ((kUp && platformCharacterIs(IN_AIR) && ladderTimer == 0 && level.checkTilesInRect(x-2, y-8, 5, 1, &level.cbCollisionLadder)) ||
      (kUp && colPointLadder && ladderTimer == 0) ||
      (kDown && colPointLadder && ladderTimer == 0 && platformCharacterIs(ON_GROUND) && xVel == 0 && level.isLadderTopAtPoint(x, y+9)) ||
      ((kUp || kDown) && status == HANGING && level.checkTilesInRect(x-2, y, 5, 1, &level.cbCollisionLadder)))
  {
    //ladder = 0;
    //auto ladder = instance_place(x, y-8, oLadder);
    auto ladder = level.isLadderAtPoint(x, y-8);
    if (ladder) {
      //writeln("LADDER01! plrx=", x, "; ladder.x0=", ladder.x0, "; ladder.ix=", ladder.ix, "; ladder class=", GetClassName(ladder.Class));
      if (abs(x-(ladder.x0+8)) < 4) {
        x = ladder.ix+8;
        setX(x);
        if (!level.isAnyLadderAtPoint(x, y)) { y = ladder.y0+14; setY(y); }
        xVel = 0;
        yVel = 0;
        xAcc = 0;
        yAcc = 0;
        status = CLIMBING;
      }
    }
  }

  /* this was commented in the original
  if (sprite_index == sDuckToHangL || sprite_index == sDamselDtHL) {
    ladder = 0;
    if (facing == LEFT && collision_rectangle(x-8, y, x, y+16, oLadder, 0, 0) && !collision_point(x-4, y+16, oSolid, 0, 0)) {
      ladder = instance_nearest(x-4, y+16, oLadder);
    } else if (facing == RIGHT && collision_rectangle(x, y, x+8, y+16, oLadder, 0, 0) && !collision_point(x+4, y+16, oSolid, 0, 0)) {
      ladder = instance_nearest(x+4, y+16, oLadder);
    }
    if (ladder) {
      x = ladder.ix+8;
      setX(x);
      xVel = 0;
      yVel = 0;
      xAcc = 0;
      yAcc = 0;
      state = CLIMBING;
    }
  }

  if (colLadder && state == CLIMBING && kJumpPressed && !whipping) {
    if (kLeft) xVel = -departLadderXVel; else if (kRight) xVel = departLadderXVel; else xVel = 0;
    yAcc += departLadderYVel;
    state = JUMPING;
    jumpButtonReleased = false;
    jumpTime = 0;
    ladderTimer = 5;
  }
  */

  // calculate horizontal/vertical friction
  if (status == CLIMBING) {
    xFric = frictionClimbingX;
    yFric = frictionClimbingY;
  } else {
    //if (runKey && platformCharacterIs(ON_GROUND) && runHeld >= 10)
    if ((runKey && runHeld >= 10) && (platformCharacterIs(ON_GROUND) || global.config.toggleRunAnywhere)) {
      // YASM 1.8.1
      if (kLeft) {
        // run
        xVel -= 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      } else if (kRight) {
        xVel += 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      }
    } else if (status == DUCKING) {
      if (xVel < 2 && xVel > -2) {
        xFric = 0.2;
        xVelLimit = 3;
        imageSpeed = 0.8;
      } else if (kLeft && global.config.downToRun) {
        // run
        xVel -= 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      } else if (kRight && global.config.downToRun) {
        xVel += 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      } else {
        xVel *= 0.8;
        if (xVel < 0.5) xVel = 0;
        xFric = 0.2;
        xVelLimit = 3;
        imageSpeed = 0.8;
      }
    } else {
      // decrease the friction when the character is "flying"
      if (platformCharacterIs(IN_AIR)) {
        if (dead || stunned) xFric = 1.0; else xFric = 0.8;
      } else {
        xFric = frictionRunningX;
      }
    }

    /* // ORIGINAL RUN/WALK xVel/xFric code  this was commented in the original
    if (runKey && platformCharacterIs(ON_GROUND) && runHeld >= 10) {
      if (kLeft) {
        // run
        xVel -= 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      } else if (kRight) {
        xVel += 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      }
    } else if (state == DUCKING) {
      if (xVel < 2 && xVel > -2) {
        xFric = 0.2
        xVelLimit = 3;
        imageSpeed = 0.8;
      } else if (kLeft && global.downToRun) {
        // run
        xVel -= 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      } else if (kRight && global.downToRun) {
        xVel += 0.1;
        xVelLimit = 6;
        xFric = frictionRunningFastX;
      } else {
        xVel *= 0.8;
        if (xVel < 0.5) xVel = 0;
        xFric = 0.2
        xVelLimit = 3;
        imageSpeed = 0.8;
      }
    } else {
      // decrease the friction when the character is "flying"
      if (platformCharacterIs(IN_AIR)) {
        if (dead || stunned) xFric = 1.0; else xFric = 0.8;
      } else {
        xFric = frictionRunningX;
      }
    }
    */

    // stuck on web or underwater
    if (level.isObjectAtPoint(x, y, &level.cbIsObjectWeb)) {
      xFric = 0.2;
      yFric = 0.2;
      fallTimer = 0;
    } else if (level.isObjectAtPoint(x, y, &level.cbIsObjectBlob)) {
      // blob enemy
      //obj = instance_place(x, y, oBlob); this was commented in the original
      //xVel += obj.xVel; this was commented in the original
      xFric = 0.1;
      yFric = 0.3;
      fallTimer = 0;
    } else if (level.isWaterAtPoint(x, y/*, oWater, -1, -1*/)) {
      closeCape();
      //if (!runKey && global.toggleRunAnywhere) xFric = frictionRunningX; // YASM 1.8.1 this was commented in the original
      if (!platformCharacterIs(ON_GROUND)) xFric = frictionRunningX;
      if (status == FALLING && yVel > 0) {
        // Spelunky Natural
             if (global.config.naturalSwim && kUp) yFric = 0.2;
        else if (global.config.naturalSwim && kDown) yFric = 0.8;
        else yFric = 0.5;
      } else if (!level.isWaterAtPoint(x, y-9/*, oWater, -1, -1*/)) {
        yFric = 1;
      } else {
        yFric = 0.9;
      }
      if (yVel < -6 && global.config.noDolphin) {
        // Spelunky Natural (changed from -4 to -6)
        yVel = -6;
      }
    } else {
      swimming = false;
      yFric = 1;
    }
  }

  if (colIceBot && status != DUCKING && !global.hasSpikeShoes) {
    xFric = 0.98;
    yFric = 1;
  }

  // YASM 1.8.1
  if (global.config.toggleRunAnywhere) {
    if (!kJump && !kDown && !runKey) xVelLimit = 3;
  }

  // RUNNING
  if (platformCharacterIs(ON_GROUND)) {
         if (status == RUNNING && kLeft && colLeft) pushTimer += 1;
    else if (status == RUNNING && kRight && colRight) pushTimer += 1;
    else pushTimer = 0;

    //if (platformCharacterIs(ON_GROUND) && !kJump && !kDown && !runKey) this was commented in the original
    if (!kJump && !kDown && !runKey) xVelLimit = 3;

    /* this was commented in the original
    // ledge flip
    if (state == DUCKING && fabs(xVel) < 3 && facing == LEFT &&
        //collision_point(x, y+9, oSolid, 0, 0) && !collision_point(x-1, y+9, oSolid, 0, 0) && kLeft)
        collision_point(x, y+9, oSolid, 0, 0) && !collision_line(x-1, y+9, x-10, y+9, oSolid, 0, 0) && kLeft)
    */

    // ledge flip
    int dhdir = 0;
         if (kLeft && dir == Dir.Left) dhdir = -1;
    else if (kRight && dir == Dir.Right) dhdir = 1;

    if (dhdir && status == DUCKING && fabs(xVel) < 3+(dhdir < 0 ? 1 : 0) &&
        level.isSolidAtPoint(x, y+9) && !level.checkTilesInRect(x+(dhdir < 0 ? -8 : 1), y+9, 8, 8))
    {
      status = DUCKTOHANG;
      if (holdItem) {
        if (!global.config.scumFlipHold || holdItem.heavy) {
          /*
          holdItem.heldBy = none;
          if (holdItem.objName == 'GoldIdol') holdItem.shiftY(-8);
          */
          //else if (holdItem.type == "Block Item") { with (oBlockPreview) instance_destroy(); }
          scrDropItem(LostCause.Hang, (dir == Dir.Left ? -1 : 1), -4);
        }
      }
      knockOffMonkeys();
    }
  }

  if (status == DUCKTOHANG) {
    setXY(xPrev, yPrev);
    x = ix;
    y = iy;
    xVel = 0;
    yVel = 0;
    xAcc = 0;
    yAcc = 0;
    grav = 0;
  }

  // parachute and cape
  if (!level.inWinCutscene) {
    if (isParachuteActive() || isCapeActiveAndOpen()) yFric = 0.5;
  }

  if (pushTimer > 100) pushTimer = 100;

  // limits the acceleration if it is too extreme
  xAcc = fclamp(xAcc, -xAccLimit, xAccLimit);
  yAcc = fclamp(yAcc, -yAccLimit, yAccLimit);

  // applies the acceleration
  xVel += xAcc;
  if (dead || stunned) yVel += 0.6; else yVel += yAcc;

  // nullifies the acceleration
  xAcc = 0;
  yAcc = 0;

  // applies the friction to the velocity, now that the velocity has been calculated
  xVel *= xFric;
  yVel *= yFric;

  auto oBall = getMyBall();
  // apply ball and chain
  if (oBall) {
    int distsq = (ix-oBall.ix)*(ix-oBall.ix)+(iy-oBall.iy)*(iy-oBall.iy);
    if (distsq >= 24*24) {
      if (xVel > 0 && oBall.ix < ix && abs(oBall.ix-ix) > 24) xVel = 0;
      if (xVel < 0 && oBall.ix > ix && abs(oBall.ix-ix) > 24) xVel = 0;
      if (yVel > 0 && oBall.iy < iy && abs(oBall.iy-iy) > 24) {
        if (abs(oBall.ix-ix) < 1) {
          //teleportTo(destx:oBall.ix);
          fltx = oBall.fltx;
          prevFltX = oBall.prevFltX;
          x = ix;
        } else if (oBall.ix < ix && !kRight) {
               if (xVel > 0) xVel *= -0.25;
          else if (xVel == 0) xVel -= 1;
        } else if (oBall.ix > ix && !kLeft) {
               if (xVel < 0) xVel *= -0.25;
          else if (xVel == 0) xVel += 1;
        }
        yVel = 0;
        fallTimer = 0;
      }
      if (yVel < 0 && oBall.iy > iy && abs(oBall.iy-iy) > 24) yVel = 0;
    }
  }

  // apply the limits since the velocity may be too extreme
  if (!dead && !stunned) xVel = fclamp(xVel, -xVelLimit, xVelLimit);
  yVel = fclamp(yVel, -yVelLimit, yVelLimit);

  // approximates the "active" variables
  if (fabs(xVel) < 0.0001) xVel = 0;
  if (fabs(yVel) < 0.0001) yVel = 0;
  if (fabs(xAcc) < 0.0001) xAcc = 0;
  if (fabs(yAcc) < 0.0001) yAcc = 0;

  bool wasInWall = !!isCollision();
  moveRel(xVel, yVel);

  // don't go out of level (if we're not in ending sequence)
  if (!level.inWinCutscene && !level.inIntroCutscene) {
         if (ix < 0) fltx = 0;
    else if (ix > level.tilesWidth*16-16) fltx = level.tilesWidth*16-16;
    if (iy < 0) flty = 0;

    if (!dead) hackBoulderCollision();

    if (!wasInWall && isCollision()) {
      writeln("** FUUUU (XXX)");
      if (isCollisionBottom(0) && !isCollisionBottom(-2)) {
        flty = iy-2;
      }
      // we can stuck in the wall with this
      if (isCollisionLeft(0)) {
        writeln("** FUUUU (001: left)");
        while (isCollisionLeft(0) && !isCollisionRight(1)) shiftX(1);
      } else if (isCollisionRight(0)) {
        writeln("** FUUUU (001: right)");
        while (isCollisionRight(0) && !isCollisionLeft(1)) shiftX(-1);
      }
    }

    if (!dead) hackBoulderCollision();

    // move out of wall by 1 px, if possible
    if (!dead && isCollision()) {
      if (isCollisionBottom(0) && !isCollisionBottom(-1)) flty = iy-1;
      if (isCollisionTop(0) && !isCollisionTop(1)) flty = iy+1;
      if (isCollisionLeft(0) && !isCollisionLeft(1)) fltx = ix+1;
      if (isCollisionRight(0) && !isCollisionRight(-1)) fltx = ix-1;
    }

    if (!dead && isCollision()) {
      //k8:HACK: try to duck
      bool wallDeath = true;
      if (platformCharacterIs(ON_GROUND)) {
        setCollisionBounds(-5, -6, 5, 8);
        auto ohbX = hitboxX, ohbY = hitboxY;
        auto ohbW = hitboxW, ohbH = hitboxH;
        wallDeath = !!isCollision();
        if (wallDeath) {
          //setCollisionBounds(-8, -6, 8, 8);
          hitboxX = ohbX; hitboxY = ohbY;
          hitboxW = ohbW; hitboxH = ohbH;
        } else {
          // force ducking
          status = DUCKING;
        }
      }

      if (wallDeath) {
        foreach (; 0..6) {
          if (isCollision()) {
                 if (isCollisionLeft(0) && !isCollisionRight(4)) fltx = ix+1;
            else if (isCollisionRight(0) && !isCollisionLeft(4)) fltx = ix-1;
            else if (isCollisionBottom(0) && !isCollisionTop(4)) flty = iy-1;
            else if (isCollisionTop(0) && !isCollisionBottom(4)) flty = iy+1;
            else break;
          }
        }

        if (wallDeath && isCollision()) {
          if (!dead) level.addDeath('wall');
          //visible = false;
          dead = true;
          writeln("PLAYER KILLED BY WALL");
          global.plife = 0; // oops
        }
      }
    }
  } else {
    // in cutscene
    //writeln("flty=", flty, "; iy=", iy);
    if (flty <= 0) {
      status = STANDING;
    }
  }

  // figures out what the sprite index of the character should be
  characterSprite();

  // sets the previous state and the previously previous state
  statePrevPrev = statePrev;
  statePrev = status;

  // calculates the imageSpeed based on the character's velocity
  if (status == RUNNING || status == DUCKING || status == LOOKING_UP) {
    if (status == RUNNING || status == LOOKING_UP) imageSpeed = fabs(xVel)*runAnimSpeed+0.1;
  }

  if (status == CLIMBING) imageSpeed = sqrt(xVel*xVel+yVel*yVel)*climbAnimSpeed;

  if (xVel >= 4 || xVel <= -4) {
    imageSpeed = 1;
    if (platformCharacterIs(ON_GROUND)) {
      setCollisionBounds(-8, -6, 8, 8);
    } else {
      setCollisionBounds(-5, -6, 5, 8);
    }
  } else {
    setCollisionBounds(-5, -6, 5, 8);
  }

  if (whipping) imageSpeed = 1;

  if (status == DUCKTOHANG) {
    imageFrame = 0;
    imageSpeed = 0.8;
  }

  // limit the imageSpeed at 1 so the animation always looks good
  if (imageSpeed > 1) imageSpeed = 1;

  //if (kItemPressed) writeln("ITEM! dead=", dead, "; stunned=", stunned, "; active=", active);
  if (dead || stunned || !active) {
    // do nothing
  } else if (/*inGame &&*/ kItemPressed && !whipping) {
    // SWITCH
    if (kUp) scrSwitchToStickyBombs(); else scrSwitchToNextItem();
  } else if (/*inGame &&*/ kRopePressed && global.rope > 0 && !whipping) {
    if (!kDown && colTop) {
      // do nothing
    } else {
      launchRope(kDown, doDrop:true);
    }
  } else if (/*inGame &&*/ kBombPressed && global.bombs > 0 && !whipping) {
    if (holdItem isa ItemWeaponBow && bowArmed) {
      if (holdArrow != ARROW_BOMB) {
        //writeln("set bow arrows to bomb");
        holdArrow = ARROW_BOMB;
      } else {
        //writeln("set bow arrows to normal");
        holdArrow = ARROW_NORM;
      }
    } else {
      scrLaunchBomb();
    }
  }


  // open chest/crate
  if (!dead && !stunned && kUp && kAttackPressed) {
    auto octr = ItemOpenableContainer(level.isObjectInRect(ix, iy, width, height, delegate bool (MapObject o) {
      return (o isa ItemOpenableContainer);
    }));
    if (octr) {
      if (octr.openMe()) kAttackPressed = false;
    }
  }


  // use weapon / attack
  if (!dead && !stunned && kAttackPressed && !holdItem /*&& !pickedItem*/) {
    bowArmed = false;
    bowStrength = 0;
    sndStopSound('sndBowPull');
    if (status != DUCKING && status != DUCKTOHANG && !whipping && !isExitingSprite()) {
      imageSpeed = 0.6;
      if (global.isTunnelMan) {
        if (platformCharacterIs(ON_GROUND) || platformCharacterIs(IN_AIR)) {
          setSprite('sTunnelAttackL');
          whipping = true;
        }
      } else if (global.isDamsel) {
        setSprite('sDamselAttackL');
        whipping = true;
      } else {
        setSprite('sAttackLeft');
        whipping = true;
      }
    } else if (kDown && !pickedItem) {
      // pick up item
      //HACK: always select dice to throw if there are two dices there
      MapObject diceToThrow = level.isObjectInRect(x-8, y, 9, 9, delegate bool (MapObject o) {
        if (o.spectral || !o.canPickUp) return false;
        if (ItemDice(o).isReadyToThrowForBet) return o.collidesWith(self);
        return false;
      }, precise:false, castClass:ItemDice);
      MapObject obj;
      if (diceToThrow) {
        obj = diceToThrow;
      } else {
        obj = level.isObjectInRect(x-8, y, 9, 9, delegate bool (MapObject o) {
          if (o.spectral || !o.canPickUp) return false;
          if (!o.collidesWith(self)) return false;
          return o.onCanBePickedUp(self);
          /*
          if (o isa MapItem) return (o.active && o.canPickUp && !o.spectral);
          if (o isa MapEnemy) return (o.active && o.canPickUp && !o.spectral && (o.dead || o.status >= MapObject::STUNNED || o.meGoldMonkey));
          */
          return false;
        }, precise:false);
      }
      if (!obj && diceToThrow) obj = diceToThrow;
      if (obj) {
        // `canPickUp` is checked in callback
        if (/*obj.canPickUp &&*/ true /*k8: do we really need this? !level.isSolidAtPoint(obj.ix+2, obj.iy)*/) {
          //pickupItemType = holdItem.type;
          //!if (isAshShotgun(holdItem)) pickupItemType = "Boomstick";
          //!if (isGoldMonkey(obj) and obj.status &lt; 98) obj.status = 0; // do not play walk animation while held

          if (!obj.onTryPickup(self)) {
            if (obj.isInstanceAlive) scrPickupItem(obj);
          }

          /+!
          if (holdItem.type == "Bow" and holdItem.new) {
            holdItem.new = false;
            global.arrows += 6;
            if (global.arrows &gt; 99) global.arrows = 99;
          }
          +/
        }
      }
    }
  } else if (!dead && !stunned) {
    if (holdItem isa ItemWeaponBow) {
      //writeln("BOW! kAttack=", kAttack, "; kAttackPressed=", kAttackPressed, "; bowArmed=", bowArmed, "; bowStrength=", bowStrength, "; holdArrow=", holdArrow);
      if (kAttackPressed) {
        if (scrPlayerIsDucking()) {
          scrUsePutItemOnGround();
        } else if (!bowArmed) {
          bowStrength = 0;
          ItemWeaponBow(holdItem).armBow(self);
        }
      }
      if (kAttack) {
        if (bowArmed && bowStrength < 12) {
          bowStrength += 0.2;
          //writeln("arming: ", bowStrength);
        } else {
          sndStopSound('sndBowPull');
        }
      } else {
        //writeln("   xxBOW!");
        // ...and shoot
        scrFireBow();
      }
      if (!holdArrow) holdArrow = ARROW_NORM;
    } else {
      if (kAttackPressed && holdItem) scrUseItem();
    }
  }

  // remove held item offer
  if (!level.isInShop(ix/16, iy/16)) {
    if (holdItem) holdItem.sellOfferDone = false;
    if (pickedItem) pickedItem.sellOfferDone = false;
  }

  // buy items
  if (!dead && !stunned && kPayPressed) {
      // find nearest shopkeeper
    auto sc = MonsterShopkeeper(level.findNearestObject(ix, iy, delegate bool (MapObject o) {
      auto sc = MonsterShopkeeper(o);
      if (!sc) return false;
      //if (needCraps && sc.stype != 'Craps') return false;
      if (sc.dead || sc.angered || sc.outlaw) return false;
      return sc.canSellItem(self, holdItem);
    }));
    if (level.isInShop(ix/16, iy/16)) {
      // if no shopkeepers found, just use it
      if (!sc) {
        if (holdItem) {
          holdItem.forSale = false;
          holdItem.onTryPickup(self);
        }
      } else if (global.thiefLevel == 0 && !global.murderer) {
        // only law-abiding players can buy/sell items or play games
        if (holdItem) writeln("shop item interaction: ", holdItem.objName, "; cost=", holdItem.cost);
        if (sc.doSellItem(self, holdItem)) {
          // use it
          if (holdItem) {
            holdItem.forSale = false;
            holdItem.onTryPickup(self);
          }
        }
        if (holdItem && !holdItem.isInstanceAlive) {
          holdItem = none;
          scrSwitchToPocketItem(forceIfEmpty:false); // just in case
        }
      }
    } else {
      // use pickup, if any
      if (holdItem isa ItemPickup) {
        // make nearest shopkeeper angry (an unlikely situation, but still...)
        if (sc && holdItem.forSale) level.scrShopkeeperAnger(GameLevel::SCAnger.ItemStolen);
        holdItem.forSale = false;
        holdItem.onTryPickup(self);
      } else {
        pickupsAround.clear();
        level.isObjectInRect(x0, y0, width, height, delegate bool (MapObject o) {
          auto pk = ItemPickup(o);
          if (pk && pk.collidesWith(self)) {
            bool found = false;
            foreach (auto opk; pickupsAround) if (opk == pk) { found = true; break; }
            if (!found) pickupsAround[$] = pk;
          }
          return false;
        }, precise:false);
        // now try to use all pickups
        foreach (ItemPickup pk; pickupsAround) {
          if (pk.isInstanceAlive) {
            if (sc && pk.forSale) level.scrShopkeeperAnger(GameLevel::SCAnger.ItemStolen);
            pk.forSale = false;
            pk.onTryPickup(self);
          }
        }
        pickupsAround.clear();
      }
    }
  }
}

transient array!ItemPickup pickupsAround;


// ////////////////////////////////////////////////////////////////////////// //
override bool initialize () {
  if (!::initialize()) return false;

  powerups.length = 0;
  powerups[$] = SpawnObject(PPParachute);
  powerups[$] = SpawnObject(PPCape);

  foreach (PlayerPowerup pp; powerups) pp.owner = self;

  if (global.isDamsel) {
    desc = "Damsel";
    desc2 = "An athletic, unfittingly-dressed woman with extremely awkward running form.";
    setSprite('sDamselLeft');
  } else if (global.isTunnelMan) {
    desc = "Tunnel Man";
    desc2 = "A miner from the desert. His tools are a cut above the rest.";
    setSprite('sTunnelLeft');
  } else {
    desc = "Spelunker";
    desc2 = "A strange little man who spends his time exploring caverns. He wants to be just like Indiana Jones when he grows up.";
    setSprite('sStandLeft');
  }

  swimming = false;

  dir = Dir.Right;

  // scum ClimbSpeed
  switch (global.config.scumClimbSpeed) {
    case 2:
      climbAcc = 0.9;
      climbAnimSpeed = 0.4;
      climbSndSpeed = 6;
      break;
    case 3:
      climbAcc = 1.2;
      climbAnimSpeed = 0.45;
      climbSndSpeed = 5;
      break;
    case 4:
      climbAcc = 1.5;
      climbAnimSpeed = 0.5;
      climbSndSpeed = 4;
      break;
    case 5:
      climbAcc = 1.8;
      climbAnimSpeed = 0.5;
      climbSndSpeed = 3;
      break;
    default:
      climbAcc = 0.6;       // how fast the character will climb
      climbAnimSpeed = 0.4; // relates to how fast the climbing animation should go
      climbSndSpeed = 8;
      break;
  }

  // sets the collision bounds to fit the default sprites (you can edit the arguments of the script)
  setCollisionBounds(-5, -5, 5, 8); // setCollisionBounds(-5, -8, 5, 8);

  statePrev = status;
  statePrevPrev = statePrev;
  gravityIntensity = grav;  // this variable describes the current force due to gravity (this variable is altered for variable jumping)
  jumpTime = jumpTimeTotal; // current time of the jump (0=start of jump, jumpTimeTotal=end of jump)

  return true;
}


// ////////////////////////////////////////////////////////////////////////// //
override void onAnimationLooped () {
  auto spr = getSprite();
  if (spr.Name == 'sAttackLeft' || spr.Name == 'sDamselAttackL' || spr.Name == 'sTunnelAttackL') {
    whipping = false;
    if (holdItem) holdItem.visible = true;
  } else if (spr.Name == 'sDuckToHangL' || spr.Name == 'sDamselDtHL' || spr.Name == 'sTunnelDtHL') {
    shiftY(16);
    moveSnap(1, 8);
    int x = ix, y = iy;
    xVel = 0;
    yVel = 0;
    xAcc = 0;
    yAcc = 0;
    grav = 0;
    MapTile obj;
    if (dir == Dir.Left) {
      // left
      obj = level.isAnyLadderAtPoint(x-8, y);
    } else {
      // right
      obj = level.isAnyLadderAtPoint(x+8, y);
    }
    if (obj) {
      status = CLIMBING;
      setX(obj.ix+8);
    } else if (dir == Dir.Left) {
      status = HANGING;
      dir = Dir.Right;
      shiftX(-6);
      shiftX(1);
    } else {
      status = HANGING;
      dir = Dir.Left;
      shiftX(6);
    }
  } else if (isExitingSprite()) {
    scrPlayerExit();
    //!global.cleanSolids = true;
  }
}


void activatePlayerWeapon () {
  if (dead) {
    if (holdItem isa PlayerWeapon) {
      auto wep = holdItem;
      holdItem = none;
      wep.instanceRemove();
      return;
    }
  }
  if (global.config.unarmed) return;

  if (holdItem isa PlayerWeapon) {
    if (!whipping) {
      /*
      writeln("000: !!!!!!!");
      if (holdItem) writeln("  H(", GetClassName(holdItem.Class), "): '", holdItem.objType, "'");
      if (pickedItem) writeln("  P(", GetClassName(pickedItem.Class), "): '", pickedItem.objType, "'");
      */
      auto wep = holdItem;
      holdItem = none;
      wep.instanceRemove();
      return;
    }
  }

  if (holdItem) return;

  auto spr = getSprite();
  if (spr.Name != 'sAttackLeft' && spr.Name != 'sDamselAttackL' && spr.Name != 'sTunnelAttackL') return;

  if (imageFrame > 4) {
    //bool hitEnemy = (PlayerWeapon(holdItem) ? PlayerWeapon(holdItem).hitEnemy : false);
    if (global.isTunnelMan || pickedItem isa ItemWeaponMattock) {
      holdItem = level.MakeMapObject(ix+(dir == Dir.Left ? -16 : 16), iy, 'oMattockHit');
      if (imageFrame < 7) playSound('sndWhip');
    } else if (pickedItem isa ItemWeaponMachete) {
      holdItem = level.MakeMapObject(ix+(dir == Dir.Left ? -16 : 16), iy, 'oSlash');
      playSound('sndWhip');
    } else {
      holdItem = level.MakeMapObject(ix+(dir == Dir.Left ? -16 : 16), iy, 'oWhip');
      playSound('sndWhip');
    }
    /+ not needed anymore
    if (holdItem) {
      holdItem.active = true;
      //if (PlayerWeapon(holdItem)) PlayerWeapon(holdItem).hitEnemy = hitEnemy;
    }
    +/
  } else if (imageFrame < 2) {
    if (global.isTunnelMan || pickedItem isa ItemWeaponMattock) {
      holdItem = level.MakeMapObject(ix+(dir == Dir.Left ? -16 : 16), iy, 'oMattockPre');
    } else if (pickedItem isa ItemWeaponMachete) {
      holdItem = level.MakeMapObject(ix+(dir == Dir.Left ? -16 : 16), iy, 'oMachetePre');
    } else {
      holdItem = level.MakeMapObject(ix+(dir == Dir.Left ? 16 : -16), iy, 'oWhipPre');
    }
    /+ not needed anymore
    if (holdItem) holdItem.active = true;
    +/
  }

  /*
  if (holdItem) {
    if (holdItem.type == "Machete") {
      obj = instance_create(x-16, y, oSlash);
      obj.sprite_index = sSlashLeft;
      playSound(global.sndWhip);
    } else if (holdItem.type == "Mattock") {
      obj = instance_create(x-16, y, oMattockHit);
      obj.sprite_index = sMattockHitL;
      if (image_index &lt; 7) playSound(global.sndWhip);
    }
  } else {
    if (global.isTunnelMan) {
      obj = instance_create(x-16, y, oMattockHit);
      obj.sprite_index = sMattockHitL;
      if (image_index &lt; 7) playSound(global.sndWhip);
    } else {
      obj = instance_create(x-16, y, oWhip);
      if (global.scumWhipUpgrade == 1) obj.sprite_index = sWhipLongLeft; else obj.sprite_index = sWhipLeft;
      playSound(global.sndWhip);
    }
  }
  */
}


//bool webHit = false;

bool doBreakWebsCB (MapObject o) {
  if (o isa ItemWeb) {
    writeln("IN WEB!");
    /*if (!webHit)*/ {
      if (fabs(xVel) > 1) {
        xVel = xVel*0.2;
        if (!o.dying) ItemWeb(o).life -= 5;
      } else {
        xVel = 0;
      }
      if (fabs(yVel) > 1) {
        yVel = yVel*0.2;
        if (!o.dying) ItemWeb(o).life -= 5;
      } else {
        yVel = 0;
      }
    }
  }
  return false;
}


void initiateExitSequence () {
  writeln("exit sequence initiated...");
       if (global.isDamsel) setSprite('sDamselExit');
  else if (global.isTunnelMan) setSprite('sTunnelExit');
  else setSprite('sPExit');

  imageSpeed = 0.5;
  active = false;
  invincible = 999;
  depth = 999;

  /*k8: the following is done in `GameLevel`
  if (global.thiefLevel > 0) global.thiefLevel -= 1;
  //orig dbg:if (global.currLevel == 1) global.currLevel += firstLevelSkip; else global.currLevel += levelSkip;
  global.currLevel += 1;
  */
  playSound('sndSteps');
}


void processLevelExit () {
  if (dead || stunned || whipping || level.playerExited) return;
  if (!platformCharacterIs(ON_GROUND)) return;
  if (isExitingSprite()) return; // just in case

  auto hld = holdItem;
  if (hld isa PlayerWeapon) return; // oops

  //if (!kExitPressed && !hld) return false;

  auto door = level.checkTileAtPoint(ix, iy, &level.cbCollisionExitTile);
  if (!door || !door.visible) return; // note that `invisible` doors still works

  // sell idol, or free damsel
  if (hld isa ItemGoldIdol) {
    //!if (isRealLevel()) global.idolsConverted += 1;
    //not thisglobal.money += hld.value*(global.levelType+1);
    ItemGoldIdol(hld).registerConverted();
    addScore(hld.value*(global.levelType+1));
    //!if (hld.sprite_index == sCrystalSkull) global.skulls += 1; else global.idols += 1;
    playSound('sndCoin');
    level.MakeMapObject(ix, iy-8, 'oBigCollect');
    holdItem = none;
    hld.instanceRemove();
    //!with (hld) instance_destroy();
    //!hld = 0;
    //!pickupItemType = "";
  } else if (hld isa MonsterDamsel) {
    holdItem = none;
    MonsterDamsel(hld).exitAtDoor(door);
  }

  if (!kExitPressed) {
    if (!door.invisible) {
      string msg = door.getExitMessage();
      if (msg.length == 0) {
        level.osdMessage(va("PRESS %s TO ENTER.", (global.config.useDoorWithButton ? "$PAY" : "$UP")), -666);
      } else if (msg[$-1] != '\n') {
        level.osdMessage(va("%s\nPRESS %s TO ENTER.", msg, (global.config.useDoorWithButton ? "$PAY" : "$UP")), -666);
      } else {
        level.osdMessage(msg, -666);
      }
    }
    return;
  }

  // exiting
  holdArrow = 0;
  bowArmed = false;

  // drop armed bomb
  if (isHoldingArmedBomb()) scrUseThrowItem();

  if (isHoldingBombOrRope()) scrSwitchToPocketItem(forceIfEmpty:true);

  wasHoldingBall = false;
  hld = holdItem;
  if (hld) {
    if (hld isa ItemGoldIdol) {
      //!if (isRealLevel()) global.idolsConverted += 1;
      //not thisglobal.money += hld.value*(global.levelType+1);
      ItemGoldIdol(hld).registerConverted();
      addScore(hld.value*(global.levelType+1));
      //!if (hld.sprite_index == sCrystalSkull) global.skulls += 1; else global.idols += 1;
      playSound('sndCoin');
      level.MakeMapObject(ix, iy-8, 'oBigCollect');
      holdItem = none;
      hld.instanceRemove();
      //!with (hld) instance_destroy();
      //!hld = 0;
      //!pickupItemType = "";
    } else if (hld isa MonsterDamsel) {
      holdItem = none;
      MonsterDamsel(hld).exitAtDoor(door);
    } else if (hld.heavy || hld isa MapEnemy) {
      // drop heavy items, characters and enemies (but not ball)
      if (hld !isa ItemBall) scrUseThrowItem();
    } else if (hld isa ItemBall) {
    } else {
      // other items are carried thru
      if (hld.cannotBeCarriedOnNextLevel) {
        scrUseThrowItem();
        holdItem = none; // just in case
      } else {
        scrHideItemToPocket();
      }
      /*
      global.pickupItem = hld.type;
      if (isAshShotgun(hld)) global.pickupItem = "Boomstick";
      with (hld) {
        breakPieces = false;
        instance_destroy();
      }
      */
      //scrHideItemToPocket();
    }
  }

  knockOffMonkeys();

  //door = instance_place(x, y, oExit); // done above
  door.snapToExit(self);

  initiateExitSequence();

  level.playerExitDoor = door;
}


override bool onFellInWater (MapTile water) {
  level.MakeMapObject(ix, iy-8, 'oSplash');
  swimming = true;
  playSound('sndSplash');
  myGrav = 0.2; //k8:???
  return false;
}


override bool onOutOfWater () {
  swimming = false;
  myGrav = 0.6;
  return false;
}


// ////////////////////////////////////////////////////////////////////////// //
override void thinkFrame () {
  // remove whip, etc. when dead
  if (dead && holdItem isa PlayerWeapon) {
    auto pw = holdItem;
    holdItem = none;
    pw.instanceRemove();
    scrSwitchToPocketItem(forceIfEmpty:false);
  }

  setPowerupState('Cape', global.hasCape);

  foreach (PlayerPowerup pp; powerups) if (pp.active) pp.onPreThink();

  // kapala
  if (redColor > 0) {
         if (redToggle) redColor -= 5;
    else if (redColor < 20) redColor += 5;
    else redToggle = true;
  } else {
    redColor = 0;
  }

  if (dead) justdied = false;

  if (!dead) {
    if (invincible > 0) --invincible;
  } else {
    invincible = 0;
  }

  if (blink > 0) {
    blinkHidden = !blinkHidden;
    --blink;
  } else {
    blinkHidden = false;
  }

  auto spr = getSprite();
  int x = ix, y = iy;

  cameraBlockX = max(0, cameraBlockX-1);
  cameraBlockY = max(0, cameraBlockY-1);

  // WHOA
  if (spr.Name == 'sWhoaLeft' || spr.Name == 'sDamselWhoaL' || spr.Name == 'sTunnelWhoaL') {
    if (whoaTimer > 0) {
      whoaTimer -= 1;
    } else if (holdItem && onLoosingHeldItem(LostCause.Whoa)) {
      auto hi = holdItem;
      holdItem = none;
      if (!hi.onLostAsHeldItem(self, LostCause.Whoa)) {
        // oops, regain it
        holdItem = hi;
      } else {
        scrSwitchToPocketItem(forceIfEmpty:true);
      }
    }
  } else {
    whoaTimer = whoaTimerMax;
  }

  // firing
  if (firing > 0) firing -= 1;

  // water
  auto wtile = level.isWaterAtPoint(x, y/*, oWaterSwim, -1, -1*/);
  if (wtile) {
    if (!swimming) {
      if (onFellInWater(wtile) || !isInstanceAlive) return;
    }
  } else {
    if (swimming) {
      if (onOutOfWater() || !isInstanceAlive) return;
    }
  }

  // burning
  if (burning > 0) {
    if (global.randOther(1, 5) == 1) level.MakeMapObject(x-8+global.randOther(4, 12), y-8+global.randOther(4, 12), 'oBurn');
    burning -= 1;
  }

  // lava
  if (!dead && level.isLavaAtPoint(x, y+6/*, oLava, 0, 0*/)) {
    //!if (isRealLevel()) global.miscDeaths[11] += 1;
    level.addDeath('lava');
    playSound('sndFlame');
    global.plife -= 99;
    dead = true;
    xVel = 0;
    yVel = 0.1;
    grav = 0;
    myGrav = 0;
    bounced = true;
    burning = 100;
    depth = 999;
  }


  // jetpack
  if (global.hasJetpack && platformCharacterIs(ON_GROUND)) {
    jetpackFuel = 50;
  }

  // fall off bottom of screen
  if (!level.inWinCutscene && !level.inIntroCutscene) {
    if (!dead && y > level.tilesHeight*16+16) {
      //!if (isRealLevel()) global.miscDeaths[10] += 1;
      level.addDeath('void');
      global.plife = -90; // spill blood
      xVel = 0;
      yVel = 0;
      grav = 0;
      myGrav = 0;
      bounced = true;
      scrDropItem(LostCause.Falloff);
      playSound('sndThud'); //???
      playSound('sndDie'); //???
    }

    if (dead && y > level.tilesHeight*16+16) {
      xVel = 0;
      yVel = 0;
      grav = 0;
      myGrav = 0;
    }
  }

  if (/*active*/true) {
    if (spr.Name == 'sStunL' || spr.Name == 'sDamselStunL' || spr.Name == 'sTunnelStunL') {
      if (stunTimer > 0) {
        imageSpeed = 0.4;
        stunTimer -= 1;
      }
      if (stunTimer < 1) {
        stunned = false;
        canDropStuff = true;
      }
    }

    if (!level.inWinCutscene) {
      if (isParachuteActive() || isCapeActiveAndOpen()) fallTimer = 0;
    }

    // changed to yVel > 1 from yVel > 0
    if (yVel > 1 && status != CLIMBING) {
      fallTimer += 1;
      if (fallTimer > 16) wallHurt = 0; // no sense in them taking extra damage from being thrown here
      int paraOpenHeight = (global.config.scumSpringShoesReduceFallDamage && (global.hasSpringShoes || global.hasJordans) ? 22 : 14);
      //paraOpenHeight = 4;
      if (global.hasParachute && !stunned && fallTimer > paraOpenHeight) {
        //if (not collision_point(x, y+32, oSolid, 0, 0)) // was commented in the original code
        //!*if (not collision_line(x, y+16, x, y+32, oSolid, 0, 0))
        if (!level.checkTilesInRect(x, y+16, 1, 17, &level.cbCollisionAnySolid)) {
          // drop parachute
          //!instance_create(x-8, y-16, oParachute);
          fallTimer = 0;
          global.hasParachute = false;
          activatePowerup('Parachute');
          //writeln("parachute state: ", isParachuteActive());
        }
      }
    } else if (fallTimer > 16 && platformCharacterIs(ON_GROUND) &&
               !level.checkTilesInRect(x-8, y-8, 17, 17, &level.cbCollisionSpringTrap) /* not onto springtrap */)
    {
      // long drop -- player has just landed
      bool reducedDamage = (global.config.scumSpringShoesReduceFallDamage && (global.hasSpringShoes || global.hasJordans));
      if (reducedDamage && fallTimer <= 24) {
        // land without taking damage
        fallTimer = 0;
      } else {
        stunned = true;
             if (fallTimer > (reducedDamage ? 72 : 48)) global.plife -= 10*global.config.scumFallDamage;
        else if (fallTimer > (reducedDamage ? 48 : 32)) global.plife -= 2*global.config.scumFallDamage;
        else global.plife -= 1*global.config.scumFallDamage;
        if (global.plife < 1) {
          if (!dead) level.addDeath('fall');
          spillBlood();
        }
        bounced = true;
        if (global.config.scumFallDamage > 0) stunTimer += 60;
        yVel = -3;
        fallTimer = 0;
        auto obj = level.MakeMapObject(x-4, y+6, 'oPoof');
        if (obj) obj.xVel = -0.4;
        obj = level.MakeMapObject(x+4, y+6, 'oPoof');
        if (obj) obj.xVel = 0.4;
        playSound('sndThud');
      }
    } else if (yVel <= 0) {
      fallTimer = 0;
      if (isParachuteActive()) {
        deactivatePowerup('Parachute');
        level.MakeMapObject(ix-8, iy-16-8, 'oParaUsed');
      }
    }

    // if (stunned) fallTimer = 0; // was commented in the original code

    if (swimming && !level.isLavaAtPoint(x, y/*, oLava, 0, 0*/)) {
      fallTimer = 0;
      if (bubbleTimer > 0) {
        bubbleTimer -= 1;
      } else {
        if (level.isWaterAtPoint(x, (y&~0x0f)-8)) level.MakeMapObject(x, y-4, 'oBubble');
        bubbleTimer = bubbleTimerMax;
      }
    } else {
      bubbleTimer = bubbleTimerMax;
    }

    //TODO: k8: move spear checking to spear handler
    if (!isExitingSprite()) {
      auto spear = MapObjectSpearsBase(level.isObjectInRect(ix-6, iy-6, 13, 14, delegate bool (MapObject o) {
        auto tt = MapObjectSpearsBase(o);
        if (!tt) return false;
        return tt.isHitFrame;
      }));
      if (spear) {
        // stunned = true;
        // bounced  = false;
        global.plife -= global.config.spearDmg; // 4
        if (!dead && global.plife <= 0 /*and isRealLevel()*/) level.addDeath('spear');
        xVel = global.randOther(4, 6)*(spear.isLeft ? -1 : 1);
        yVel = -6;
        flty -= 1;
        y = iy;
        // state = FALLING;
        spillBlood(); //1?
      }
    }

    if (status != DUCKTOHANG && !stunned && !dead && !isExitingSprite()) {
      bounced = false;
      characterStepEvent();
    } else {
      if (status != DUCKING && status != DUCKTOHANG) status = STANDING;
      checkControlKeys(getSprite());
    }
  }

  // if (dead or stunned)
  if (dead || stunned) {
    if (holdItem) {
      if (holdItem isa ItemWeaponBow && bowArmed) scrFireBow();
      scrDropItem(dead ? LostCause.Dead : LostCause.Stunned, xVel, -3);
    }

    yVel += (bounced ? 1.0 : 0.6);

    if (isCollisionTop(1) && yVel < 0) yVel = -yVel*0.8;
    if (isCollisionLeft(1) || isCollisionRight(1)) xVel = -xVel*0.5;

    bool collisionbottomcheck = !!isCollisionBottom(1);
    if (collisionbottomcheck || isCollisionBottom(1, &level.cbCollisionPlatform)) {
      // bounce
      if (collisionbottomcheck) {
        if (yVel > 2.5) yVel = -yVel*0.5; else yVel = 0;
      } else {
        // after falling onto a platform don't take extra damage after recovering from stunning
        fallTimer -= 1;
      }
      /* was commented in the original code
      if (isCollisionBottom(1)) {
        if (yVel &gt; 2.5) yVel = -yVel*0.5; else yVel = 0;
      } else {
        fallTimer -= 1;
      }
      */

      // friction
           if (fabs(xVel) < 0.1) xVel = 0;
      else if (fabs(xVel) != 0 && level.isIceAtPoint(x, y+16)) xVel *= 0.8;
      else if (fabs(xVel) != 0) xVel *= 0.3;

      bounced = true;
    }

    //webHit = false;
    //level.forEachObjectInRect(ix, iy, width, height, &doBreakWebsCB);

    // apply the limits since the velocity may be too extreme
    xVelLimit = 10;
    xVel = fclamp(xVel, -xVelLimit, xVelLimit);
    yVel = fclamp(yVel, -yVelLimit, yVelLimit);

    moveRel(xVel, yVel);
    x = ix;
    y = iy;

    // fix sprites, spawn blood from spikes
    if (isParachuteActive()) {
      deactivatePowerup('Parachute');
      level.MakeMapObject(ix-8, iy-16-8, 'oParaUsed');
    }

    if (whipping) {
      whipping = false;
      //!with (oWhip) instance_destroy();
    }

    if (global.isDamsel) {
      if (xVel == 0) {
             if (dead) setSprite('sDamselDieL');
        else if (stunned) setSprite('sDamselStunL');
      } else if (bounced) {
        if (yVel < 0) setSprite('sDamselBounceL'); else setSprite('sDamselFallL');
      } else {
        if (xVel < 0) setSprite('sDamselDieLL'); else setSprite('sDamselDieLR');
      }
    } else if (global.isTunnelMan) {
      if (xVel == 0) {
             if (dead) setSprite('sTunnelDieL');
        else if (stunned) setSprite('sTunnelStunL');
      } else if (bounced) {
        if (yVel < 0) setSprite('sTunnelLBounce'); else setSprite('sTunnelFallL');
      } else {
        if (xVel < 0) setSprite('sTunnelDieLL'); else setSprite('sTunnelDieLR');
      }
    } else {
      if (xVel == 0) {
             if (dead) setSprite('sDieL');
        else if (stunned) setSprite('sStunL');
      } else if (bounced) {
        if (yVel < 0) setSprite('sDieLBounce'); else setSprite('sDieLFall');
      } else {
        if (xVel < 0) setSprite('sDieLL'); else setSprite('sDieLR');
      }
    }

    x = ix;
    y = iy;

    auto colobj = isCollisionRight(1);
    if (!colobj) colobj = isCollisionLeft(1);
    if (!colobj) colobj = isCollisionBottom(1);
    if (colobj) {
      if (wallHurt > 0) {
        scrCreateBlood(colobj.x0, colobj.y0, 3);
        global.plife -= 1;
        if (!dead && global.plife <= 0 /*&& isRealLevel()*/) {
          if (thrownBy) {
            writeln("thrown to death by '", thrownBy, "'");
            level.addDeath(thrownBy);
          }
        }
        wallHurt -= 1;
        if (wallHurt <= 0) thrownBy = '';
        playSound('sndHurt'); //???
      }
    }

    colobj = isCollisionBottom(1);
    if (colobj && !bounced) {
      bounced = true;
      scrCreateBlood(colobj.x0, colobj.y0, 2);
      if (wallHurt > 0) {
        global.plife -= 1;
        if (!dead && global.plife <= 0 /*and isRealLevel()*/) {
          if (thrownBy) {
            writeln("thrown to death by '", thrownBy, "'");
            level.addDeath(thrownBy);
          }
        }
        wallHurt -= 1;
        if (wallHurt <= 0) thrownBy = '';
      }
    }
  } else {
    // look up and down
    bool kPay = level.isKeyDown(GameConfig::Key.Pay);
    if (kPay) {
      // gnounc's quick look
      if (!kRight && !kLeft && (platformCharacterIs(ON_GROUND) || status == HANGING)) {
             if (kDown) { if (viewCount <= 6) viewCount += 3; else viewOffset += 6; }
        else if (kUp) { if (viewCount <= 6) viewCount += 3; else viewOffset -= 6; }
        else viewCount = 0;
      } else {
        viewCount = 0;
      }
    } else {
      // default look up/down with delay if pay button not held
      if (!kRight && !kLeft && (platformCharacterIs(ON_GROUND) || status == HANGING)) {
             if (kDown) { if (viewCount <= 30) viewCount += 1; else viewOffset += 4; }
        else if (kUp) { if (viewCount <= 30) viewCount += 1; else viewOffset -= 4; }
        else viewCount = 0;
      } else {
        viewCount = 0;
      }
    }
  }
  if (viewCount == 0 && viewOffset) viewOffset = (viewOffset < 0 ? min(0, viewOffset+8) : max(0, viewOffset-8));
  viewOffset = clamp(viewOffset, -16*6, 16*6);

  if (!dead) activatePlayerWeapon();

  if (!dead) processLevelExit();

  // hurt too much
  if (global.plife < -99 && visible && justdied) spillBlood();

  if (global.plife < 1) {
    dead = true;
  }

  // spikes, and other shit
  if (global.plife >= -99 && visible && !isExitingSprite()) {
    auto colSpikes = level.checkTilesInRect(x-4, y-4, 9, 13, &level.cbCollisionSpikes);

    if (colSpikes && dead) {
      grav = 0;
      if (!level.isSolidAtPoint(x, y+9)) { shiftY(0.02); y = iy; } //0.05;
      //else myGrav = 0.6;
    } else {
      myGrav = 0.6;
    }

    if (colSpikes && yVel > 0 && (fallTimer > 3 || stunned)) { // originally fallTimer &gt; 4
      if (!dead) {
        // spikes will always instant-kill in Moon room
        /*if (isRoom("rMoon")) global.plife -= 99; else*/ global.plife -= global.config.scumSpikeDamage;
        if (/*isRealLevel() &&*/ global.plife <= 0) level.addDeath('spike');
        if (global.plife > 0) playSound('sndHurt');
        spillBlood();
        xVel = 0;
        yVel = 0;
        myGrav = 0;
      }
      colSpikes.makeBloody();
    }
    //else if (not dead) myGrav = 0.6;
  }


  // sacrifice
  if (visible && (status >= STUNNED || stunned || dead || status == DUCKING)) {
    bool onAltar;
    checkAndPerformSacrifice(out onAltar);
    // block looking down if we're trying to sacrifire ourselves
    if (onAltar) viewCount = max(0, viewCount-1);
  } else {
    sacCount = default.sacCount;
  }

  // activate ankh
  if (dead && global.hasAnkh) {
    writeln("*** ACTIVATED ANKH");
    global.hasAnkh = false;
    dead = false;
    int newLife = (global.isTunnelMan ? global.config.scumTMLife : global.config.scumStartLife);
    global.plife = max(global.plife, newLife);
    level.osdMessage("THE ANKH SHATTERS!\nYOU HAVE BEEN REVIVED!", 4);
    // find moai
    auto moai = level.forEachTile(delegate bool (MapTile t) { return (t.objType == 'oMoai'); });
    if (moai) {
      level.forEachTile(delegate bool (MapTile t) {
        if (t.objType == 'oMoaiInside') {
          teleportTo(t.ix+8, t.iy+8);
          t.instanceRemove();
        }
        return false;
      });
      //teleportTo(moai.ix+16+8, moai.iy+16+8);
    } else {
      if (level.allEnters.length) {
        teleportTo(level.allEnters[0].ix+8, level.allEnters[0].iy-8);
      }
    }
    level.centerViewAtPlayer();
    auto ball = getMyBall();
    if (ball) ball.teleportToPrisoner();
    //k8:???depth = 50;
    xVel = 0;
    yVel = 0;
    blink = 60;
    invincible = 60;
    fallTimer = 0;
    visible = true;
    active = true;
    dead = false;
    stunned = false;
    status = STANDING;
    burning = 0;
    //alarm[8] = 60; // this starts music; but we don't need it, 'cause we won't stop the music on player death
    playSound('sndTeleport');
  }


  if (dead) level.stats.gameOver();

  // step end
  if (status == DUCKTOHANG) {
    spr = getSprite();
    if (spr.Name != 'sDuckToHangL' && spr.Name != 'sDamselDtHL' && spr.Name != 'sTunnelDtHL') status = STANDING;
  }

  foreach (PlayerPowerup pp; powerups) if (pp.active) pp.onPostThink();

  if (jetpackFlaresTime > 0) {
    if (--jetpackFlaresTime == 0) {
      auto obj = level.MakeMapObject(ix+global.randOther(0, 3)-global.randOther(0, 3), iy+global.randOther(0, 3)-global.randOther(0, 3), 'oFlareSpark');
      if (obj) {
        obj.yVel = global.randOther(1, 3);
        obj.xVel = global.randOther(0, 3)-global.randOther(0, 3);
      }
      playSound('sndJetpack');
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
void drawPrePrePowerupWithOfs (int xpos, int ypos, int scale, float currFrameDelta) {
  // so ducking player will have it's cape correctly rendered
  foreach (PlayerPowerup pp; powerups) {
    if (pp.active) pp.prePreDrawWithOfs(xpos, ypos, scale, currFrameDelta);
  }
}


override void drawWithOfs (int xpos, int ypos, int scale, float currFrameDelta) {
  //if (heldBy) return; // owner will take care of this
  if (blinkHidden) return;

  bool renderJetpackBack = false;
  if (global.hasJetpack) {
    // render jetpack
    if ((status == CLIMBING || isExitingSprite()) && !whipping) {
      // later
      renderJetpackBack = true;
    } else {
      int xi, yi;
      getInterpCoords(currFrameDelta, scale, out xi, out yi);
      yi -= 1;
      SpriteImage spr;
      if (dir == Dir.Right) {
        spr = level.sprStore['sJetpackRight'];
        xi -= 4;
      } else {
        spr = level.sprStore['sJetpackLeft'];
        xi += 4;
      }
      if (spr) {
        auto spf = spr.frames[0];
        if (spf && spf.width > 0 && spf.height > 0) spf.tex.blitAt(xi-xpos-spf.xofs*scale, yi-ypos-spf.yofs*scale, scale);
      }
    }
  }

  bool ducking = (status == DUCKING);
  foreach (PlayerPowerup pp; powerups) {
    if (pp.active) pp.preDrawWithOfs(xpos, ypos, scale, currFrameDelta);
  }

  auto oldColor = Video.color;
  if (redColor > 0) Video.color = clamp(200+redColor, 0, 255)<<16;
  ::drawWithOfs(xpos, ypos, scale, currFrameDelta);
  Video.color = oldColor;

  if (renderJetpackBack) {
    int xi, yi;
    getInterpCoords(currFrameDelta, scale, out xi, out yi);
    SpriteImage spr = level.sprStore['sJetpackBack'];
    if (spr) {
      auto spf = spr.frames[0];
      if (spf && spf.width > 0 && spf.height > 0) spf.tex.blitAt(xi-xpos-spf.xofs*scale, yi-ypos-spf.yofs*scale, scale);
    }
  }

  foreach (PlayerPowerup pp; powerups) if (pp.active) pp.postDrawWithOfs(xpos, ypos, scale, currFrameDelta);
}


void lastDrawWithOfs (int xpos, int ypos, int scale, float currFrameDelta) {
  foreach (PlayerPowerup pp; powerups) {
    if (pp.active) pp.lastDrawWithOfs(xpos, ypos, scale, currFrameDelta);
  }
}


defaultproperties {
  objName = 'Player';
  objType = 'oPlayer';

  desc = "Spelunker";
  desc2 = "A strange little man who spends his time exploring caverns. He wants to be just like Indiana Jones when he grows up.";

  negateMirrorXOfs = true;

  status = FALLING; // the character state, must be one of the following: STANDING, RUNNING, DUCKING, LOOKING_UP, CLIMBING, JUMPING, or FALLING

  bloodless = false;

  stunned = false;
  bounced = false;

  fallTimer = 0;
  stunTimer = 0;
  wallHurt = 0;
  //thrownBy = ""; // "Yeti", "Hawkman", or "Shopkeeper" for stat tracking deaths by being thrown
  pushTimer = 0;
  whoaTimer = 0;
  //whoaTimerMax = 30;
  distToNearestLightSource = 999;

  sacCount = 60;

  flying = false;
  myGrav = 0.6;
  myGravNorm = 0.6;
  myGravWater = 0.2;
  yVelLimit = 10;
  bounceFactor = 0.5;
  frictionFactor = 0.3;

  xVelLimit = 16; // limits the xVel: default 15
  yVelLimit = 10; // limits the yVel
  xAccLimit = 9;  // limits the xAcc
  yAccLimit = 6;  // limits the yAcc
  runAcc = 3;     // the running acceleration

  grav = 1;

  bloodLeft = 999999;

  depth = 5;
  //lightRadius = 96; //???
}