Sideview stairs in ZC.

stairs.zh

import "std.zh"

////////////////////////////////////////////////////////////////
//// Engine Constants.

// Combo Flag for soft platforms.
const int CF_SOFT = 98;

//// Block Types.
// An empty block.
const int BLOCK_EMPTY = 0;
// A fallthrough block.
const int BLOCK_SOFT = 1;
// A standard block.
const int BLOCK_HARD = 2;

//// Stair combo types.
const int CT_NEG = 142;
const int CT_CROSS = 143;
const int CT_POS = 144;

//// Custom Engine Constants.
// Link's walk speed.
const float LINK_WALK = 1.5;
// Link's gravitic acceleration.
const float LINK_GRAV = 0.16;
// Link's terminal velocity.
const float LINK_TERM = 3.2;

////////////////////////////////////////////////////////////////
//// Global Variables

////////////////
//// Link's State

//// How to handle Link's movement.
// We're letting the ZC engine handle movement.
const int LINK_MODE_ENGINE = 0;
// We're dealing with Link's movement ourselves.
const int LINK_MODE_CUSTOM = 1;
// We're moving link accourding to the stair system.
const int LINK_MODE_STAIR = 2;
// Link's current movement mode.
int LinkMode = LINK_MODE_ENGINE;

// Link's Location. This is so we can have fractional movement.
float LinkX = 0;
float LinkY = 0;
// Link's Vertical Velocity.
float LinkVy = 0;
// What Link is standing on.
int LinkBlock = BLOCK_HARD;

// Link's jump speed.
float LinkJump = -4;
// Link's hop speed.
float LinkHop = -1;

//// Fake input since we're cancelling it.
bool InputJump = false;
bool PressJump = false;

//// Various parts of Link's state from last frame.
// Link's Position.
float OldLinkX = 0;
float OldLinkY = 0;
int OldLinkAction = LA_NONE;

//// Stair State.
// On a down-left up-right stair.
const int STAIR_NEG = -1;
// Not on any stairs.
const int STAIR_NONE = 0;
// On an up-left down-right stair.
const int STAIR_POS = 1;
//// Stair Positioning - where we are on a stair.
// We're in the middle of the stair.
const int STAIR_MIDDLE = 0;
// We're anchored to the side of a stair.
const int STAIR_BOTTOM = 1;
// We're anchored to a stair diagonally.
const int STAIR_TOP = 2;

// The current kind of stair that Link is standing on.
int StairMode = STAIR_NONE;
// If the stairs were mounted this frame.
bool StairMount = false;
// The combo position fo the stair that Link is anchored to.
int StairLoc = -1;
// Where we are on the stair.
int StairPos = STAIR_MIDDLE;
// The x position of the edge of the stairs.
int StairEdgeX = -1;
// The left edge of the stairs that Link is on.
int StairLeft = 0;
// The right edge of the stairs that Link is on.
int StairRight = 0;
// If the anchored stair has another above it.
bool StairAbove = false;
// If the anchored stair has another below it.
bool StairBelow = false;
// The y offset of the current stair.
int StairY = 0;


////////////////
//// Screen Change

//// Screen State on the previous frame.
// DMap from last frame.
int OldDMap = -1;
// DMap Screen from last frame.
int OldDScreen = -1;
// If the dmap has changed from the last frame.
bool DMapChanged = false;
// If the screen has changed from the last frame.
bool ScreenChanged = false;
// Used so that ScreenChanged is only set on the first frame
// of a scrolling screen change.
bool _ScreenChanged_ScrollFlag = false;
// The ScreenChange FFC sets this so that maze screens can be used.
bool _ScreenChanged_ForceFlag = false;
// If the screen change has been handled by custom code.
bool ScreenChangeHandled = true;
// We're pretty sure that the screen change was caused by a warp of
// some sort.
const int SCREEN_CHANGE_WARP = -1;
// Best guess for which direction we changed screens in
// based on Link's current position.
int ScreenChangeDir = SCREEN_CHANGE_WARP;

global script Active {
  void run() {

    LinkX = Link->X;
    LinkY = Link->Y;

    while (true) {

      OldLink_Update1();
      ScreenChange_Update1();
      Stair_Update1();
      Input_Update1();
      //Input_Update2();

      // Performs Game Logic.
      Waitdraw();

      ScreenChange_Update2();
      DetermineLinkMode();

      // If we're not using custom movement, update Link's positioning
      // variables to match whatever the engine says.
      if (LinkMode == LINK_MODE_ENGINE) {
        LinkX = Link->X;
        LinkY = Link->Y;}

      // Perform custom movement.
      if (LinkMode == LINK_MODE_CUSTOM) {
        StairMode = STAIR_NONE;
        LinkCustomOnScreenChange();
        LinkCustomUpdatePosition();
        LinkCustomJump();
        LinkCustomMountStair();}

      // We could possibly switch to stair movement at this point.
      if (LinkMode == LINK_MODE_STAIR) {
        Link->Jump = 0;
        LinkStairOnScreenChange();
        LinkStairFindStair();
        LinkStairFallOff();}

      // And away from it at this point.
      if (LinkMode == LINK_MODE_STAIR) {
        LinkStairUpdatePosition();
        LinkStairJump();}

      LinkAdjust();

      // Wait for the screen to draw.
      // (You wouldn't think it from the name, right?)
      Waitframe();}}}

// If the combo location (in units of tiles) is valid, it is returned.
// otherwise, -1 is returned.
int FindLoc(int tx, int ty) {
  if (tx < 0 || tx > 15 || ty < 0 || ty > 10) {
    return -1;}
  return tx + (ty << 4);}

// Determine whether we'll be relying on the ZC engine for movement
// or on this custom code.
// Place after Waitdraw, and before anything that needs to know Link's mode.
void DetermineLinkMode() {
  // Check for various situations in which we want to fallback on
  // the built-in ZC engine.
  if (// If we're not a sideview screen, we definitely want
      // to use the ZC engine.
      !IsSideview() ||
      // If Link is Frozen, he's probably using the hookshot.
      Link->Action == LA_FROZEN ||
      // If the screen is scrolling, we can't do anything anyway.
      Link->Action == LA_SCROLLING ||
      // If he's hurt, we want to rely on the built-in knockback.
      Link->Action == LA_GOTHURTLAND ||
      Link->Action == LA_GOTHURTWATER) {
    // Rely on the engine.
    LinkMode = LINK_MODE_ENGINE;}
  // There's on reason not to, so use our custom engine or stairs..
  else if (StairMode != STAIR_NONE) {
    LinkMode = LINK_MODE_STAIR;}
  else {
    LinkMode = LINK_MODE_CUSTOM;}}

// Return true if the combo at the given position is a stair.
bool IsStair(int x, int y) {
  if (x < 0 || x >= 256 || y < 0 || y >= 176) {return false;}
  else {return IsStair((y & 240) + (x >> 4));}}

bool IsStair(int loc) {
  if (loc == -1) {return false;}
  int ct = Screen->ComboT[loc];
  return CT_NEG <= ct && ct <= CT_POS;}

bool IsValidStair(int loc) {
  if (StairMode == STAIR_NEG) {return IsNegStair(loc);}
  else if (StairMode == STAIR_POS) {return IsPosStair(loc);}}

bool IsValidStair(int x, int y) {
  if (StairMode == STAIR_NEG) {return IsNegStair(x, y);}
  else if (StairMode == STAIR_POS) {return IsPosStair(x, y);}}

bool IsPosStair(int x, int y) {
  if (x < 0 || x > 255 || y < 0 || y > 175) {return false;}
  else {return IsPosStair((y & 240) + (x >> 4));}}

bool IsPosStair(int loc) {
  if (loc == -1) {return false;}
  int ct = Screen->ComboT[loc];
  return ct == CT_CROSS || ct == CT_POS;}

bool IsNegStair(int x, int y) {
  if (x < 0 || x > 255 || y < 0 || y > 175) {return false;}
  else {return IsNegStair((y & 240) + (x >> 4));}}

bool IsNegStair(int loc) {
  if (loc == -1) {return false;}
  int ct = Screen->ComboT[loc];
  return ct == CT_CROSS || ct == CT_NEG;}

// Gets the block type at the given position on screen.
int GetBlockType(int x, int y) {
  // Outside the screen is always considered open.
  if (x < 0 || x >= 256 || y < 0 || y >= 176) {return BLOCK_EMPTY;}
  // Non-solid blocks are always empty.
  else if (!Screen->isSolid(x, y)) {return BLOCK_EMPTY;}
  // Otherwise, if has the soft flag or is a stair,
  // it is a soft block.
  else if (ComboFI(x, y, CF_SOFT) || IsStair(x, y)) {return BLOCK_SOFT;}
  // Otherwise it is hard.
  else {return BLOCK_HARD;}}

// Updates Old Link position when the screen changes.
void LinkUpdateOldOnScreenChange() {
  // Set old link position to the edge of the screen we came in from.
  if (ScreenChangeDir == DIR_UP) {
    OldLinkY = 160;}
  else if (ScreenChangeDir == DIR_DOWN) {
    OldLinkY = 0;}
  else if (ScreenChangeDir == DIR_LEFT) {
    OldLinkX = 240;}
  else if (ScreenChangeDir == DIR_RIGHT) {
    OldLinkX = 0;}}


// Various actions to perform if the screen changed on us.
void LinkCustomOnScreenChange() {
  if (ScreenChangeHandled) {return;}

  // Respect any warps or such.
  LinkX = Link->X;
  LinkY = Link->Y;

  LinkUpdateOldOnScreenChange();

  // Mark as being handled.
  ScreenChangeHandled = true;}

// Perform the actual movement of Link.
void LinkCustomUpdatePosition() {

  // First, move according to player input.
  if (// We can only move if we're standing still or walking.
      Link->Action == LA_NONE || Link->Action == LA_WALKING ||
      // Or we're in the air and attacking.
      (Link->Action == LA_ATTACKING && LinkBlock == BLOCK_EMPTY)) {
    // Then move left or right, but not both.
    if (Link->InputLeft) {LinkX -= LINK_WALK;}
    else if (Link->InputRight) {LinkX += LINK_WALK;}}

  // Check against running into a wall to the left.
  if (// First check that we moved left.
      LinkX < OldLinkX &&
      (// Then check for hard blocks at Link's top, middle, and bottom.
       GetBlockType(LinkX, LinkY) == BLOCK_HARD ||
       GetBlockType(LinkX, LinkY + 8) == BLOCK_HARD ||
       GetBlockType(LinkX, LinkY + 15) == BLOCK_HARD)) {
    // If he hit, move Link right to the next multiple of 8.
    LinkX += 8 - (LinkX % 8);}

  // Check against running into a wall to the right.
  if (// First check that we moved right.
      LinkX > OldLinkX &&
      (// Then check for hard blocks at Link's top, middle, and bottom.
       GetBlockType(LinkX + 15, LinkY) == BLOCK_HARD ||
       GetBlockType(LinkX + 15, LinkY + 8) == BLOCK_HARD ||
       GetBlockType(LinkX + 15, LinkY + 15) == BLOCK_HARD)) {
    // If he hit, move Link left to the previous multiple of 8.
    LinkX &= 0x1FFF8;}

  // Then move Link according to his vertical velocity.
  LinkY += LinkVy;

  // Check against running into a hard block above.
  if (// First check that we're moving up.
      LinkY < OldLinkY &&
      (// Then check against Link's middle-left and middle-right.
       GetBlockType(LinkX + 5, LinkY) == BLOCK_HARD ||
       GetBlockType(LinkX + 11, LinkY) == BLOCK_HARD)) {
    // If he hit, move Link down to the next multiple of 8.
    LinkY += 8 - (LinkY % 8);
    // and get rid of his vertical velocity.
    LinkVy = 0;}

  // Check against running into a block below, and assign the block type
  // below Link to LinkBlock for this round.
  // First check to make sure we're moving down.
  if (LinkY > OldLinkY) {
    // Get the hardest type of platform below Link.
    // Check against his middle-left and middle-right.
    LinkBlock = Max(GetBlockType(LinkX + 5, LinkY + 16),
                    GetBlockType(LinkX + 11, LinkY + 16));
    // See if we ran into a block.
    if (// A hard block always counts.
        LinkBlock == BLOCK_HARD ||
        // A soft block counts as long as we're not holding the jump
        // button down, or we started out past it.
        (LinkBlock == BLOCK_SOFT &&
         !InputJump &&
         !(OldLinkY > (LinkY & 0x1FFF8)))) {
      // If he hit, move Link up to the previous multiple of 8.
      LinkY &= 0x1FFF8;
      // and get rid of his vertical velocity.
      LinkVy = 0;}}
  // Otherwise, we're in the air.
  else {
    LinkBlock = BLOCK_EMPTY;}

  Link->Jump = 0;
  Link->Z = 0;

  // Gravity.
  LinkVy = Min(LinkVy + LINK_GRAV, LINK_TERM);}

// Perform a sideview jump.
void SideviewJump() {
  Game->PlaySound(SFX_JUMP);
  // We're holding down, so only hop.
  if (Link->InputDown) {LinkVy = LinkHop;}
  // Otherwise do the full jump.
  else {LinkVy = LinkJump;}}

// Jump according to custom mode rules.
void LinkCustomJump() {
  if (// The Jump button is pressed.
      PressJump &&
      // Can't jump in the air.
      LinkBlock != BLOCK_EMPTY &&
      // Must have positive y velocity.
      LinkVy >= 0 &&
      // Can't be doing anything but walking.
      (Link->Action == LA_NONE || Link->Action == LA_WALKING)) {
    // Jump!
    SideviewJump();}}

// Check if we need to get onto stairs from custom mode.
void LinkCustomMountStair() {
  // We never get on a stair unless we're standing on something.
  if (LinkBlock == BLOCK_EMPTY) {return;}

  // We must have a positive or 0 y velocity.
  if (LinkVy < 0) {return;}

  // We're moving up-left, so check an up-left going stair on the same
  // tile as Link.
  if (Link->InputLeft && Link->InputUp && IsPosStair(LinkX, LinkY + 15)) {
    MountStair(LinkX, LinkY + 15, STAIR_POS);
    StairPos = STAIR_BOTTOM;}

  // We're moving up-right, so check an up-right going stair on the same
  // tile as Link.
  else if (Link->InputRight && Link->InputUp &&
           IsNegStair(LinkX + 15, LinkY + 15)) {
    MountStair(LinkX + 15, LinkY + 15, STAIR_NEG);
    StairPos = STAIR_BOTTOM;}

  // We're moving down-left, so check a down-left going stair on the
  // tile below Link.
  if (Link->InputLeft && Link->InputDown && IsNegStair(LinkX + 2, LinkY + 18)) {
    MountStair(LinkX + 2, LinkY + 18, STAIR_NEG);
    StairPos = STAIR_TOP;}

  // We're moving down-right, so check a down-right going stair on the
  // tile below Link.
  if (Link->InputRight && Link->InputDown &&
      IsPosStair(LinkX + 13, LinkY + 18)) {
    MountStair(LinkX + 13, LinkY + 18, STAIR_POS);
    StairPos = STAIR_TOP;}}

// Causes Link to mount the stair at the given position.
// Returns true if the stair was mounted.
bool MountStair(int x, int y, int mode) {

  // First, make sure there's actually a stair there.
  int start = (y & 240) + (x >> 4);
  if (x < 0 || x >= 256 || y < 0 || y >= 176 || !IsStair(start)) {
    LinkMode = LINK_MODE_CUSTOM;
    StairMode = STAIR_NONE;
    return false;}

  // Change to stair movement mode.
  LinkMode = LINK_MODE_STAIR;
  StairMode = mode;
  StairLoc = ComboAt(x, y);

  // Mark the stairs being mounted this frame.
  StairMount = true;

  // Set the Y offset.
  x = ComboX(start);
  y = ComboY(start);

  StairY =
    // Start with the y position of the stair combo.
    y
    // Move to 1 cell above it.
    - 16
    // Adjust for the x position of the stair combo in the stair direction.
    - x * StairMode;

  return true;}

void Stair_Update1() {
  StairMount = false;}

// Adjust Link's position if the screen changed.
void LinkStairOnScreenChange() {
  if (ScreenChangeHandled) {return;}

  int stairTX = StairLoc % 16;
  int stairTY = StairLoc >> 4;

  LinkUpdateOldOnScreenChange();

  // If we walked off the top of the screen.
  if (ScreenChangeDir == DIR_UP) {
    int adjust = (StairLoc >> 4) + 1;
    stairTX -= adjust * StairMode;
    stairTY = 10;
    StairLoc = FindLoc(stairTX, stairTY);
    LinkX = (stairTX + StairMode) * 16;
    LinkY = 160;}

  // We walked off the bottom of the screen.
  else if (ScreenChangeDir == DIR_DOWN) {
    int adjust = 11 - stairTY;
    // First check if there is actually a stair on the top of the new screen.
    int loc = FindLoc(stairTX + StairMode * adjust, 0);
    if (!IsValidStair(loc)) {
      // If there isn't then just set Link's X to where that stair would be.
      LinkX = ComboX(loc);
      StairLoc = -1;}
    // If there is, proceed as normal.
    else {
      stairTX += 2 * StairMode;
      stairTY = 1;
      StairLoc = FindLoc(stairTX, stairTY);
      LinkX = stairTX * 16;}
    LinkY = 0;}

  // We walked off the left edge of the screen. Make sure that the
  // stairs actually reached all the way to the left as well.
  else if (ScreenChangeDir == DIR_LEFT &&
           (// If we were on the edge stair, then we know it existed.
            stairTX == 0 ||
            // Check above or below based on stair direction
            Cond(StairMode == STAIR_POS, StairAbove, StairBelow))) {
    stairTX = 15;
    // How far away the stair we're anchored to is from the wall.
    int adjust = (StairLoc % 16) + 1;
    stairTY -= adjust * StairMode;
    StairLoc = FindLoc(stairTX, stairTY);
    LinkX = 240;
    LinkY = (stairTY - 1) * 16;
    // If there isn't a valid stair there, and we were moving up, then
    // move Link down a tile, because he never climbed it while the
    // screen was scrolling.
    if (StairMode == STAIR_POS && !IsValidStair(StairLoc)) {
      LinkY += 16;}}

  // We walked off the right edge of the screen. Make sure that the
  // stairs actually reached all the way to the right as well.
  else if (ScreenChangeDir == DIR_RIGHT &&
           (// If we were on the edge stair, then we know it existed.
            stairTX == 15 ||
            // Check above or below based on stair direction
            Cond(StairMode == STAIR_POS, StairBelow, StairAbove))) {
    stairTX = 0;
    // How far away the stair we're anchored to is from the wall.
    int adjust = 16 - (StairLoc % 16);
    stairTY += adjust * StairMode;
    StairLoc = FindLoc(stairTX, stairTY);
    LinkX = 0;
    LinkY = (stairTY - 1) * 16;
    // If there isn't a valid stair there, and we were moving up, then
    // move Link down a tile, because he never climbed it while the
    // screen was scrolling.
    if (StairMode == STAIR_NEG &&  !IsValidStair(StairLoc)) {
      LinkY += 16;}}

  // Otherwise, cancel stairs.
  else {
    LinkX = Link->X;
    LinkY = Link->Y;
    StairMode = STAIR_NONE;
    LinkMode = LINK_MODE_CUSTOM;}

  if (StairMode != STAIR_NONE) {
    MountStair(stairTX << 4, stairTY << 4, StairMode);}

  ScreenChangeHandled = true;}

// Update Link's position based on the stair he's on.
void LinkStairUpdatePosition() {
  // First, move according to player input.
  if (// We can only move if we're standing still or walking.
      Link->Action == LA_NONE || Link->Action == LA_WALKING) {
    // Then move left or right, but not both.
    if (Link->InputLeft) {LinkX -= LINK_WALK;}
    else if (Link->InputRight) {LinkX += LINK_WALK;}}

  // If we're at the top or bottom of the stair, check against running
  // into walls.
  if (StairPos != STAIR_MIDDLE) {
    // Check against running into a wall to the left.
    if (// First check that we moved left.
        LinkX < OldLinkX &&
        // Then check that we're not at the top of a negative stair.
        (StairPos != STAIR_TOP || StairMode != STAIR_NEG) &&
        (// Then check for hard blocks at Link's top, middle, and bottom.
         GetBlockType(LinkX, LinkY) == BLOCK_HARD ||
         GetBlockType(LinkX, LinkY + 8) == BLOCK_HARD ||
         GetBlockType(LinkX, LinkY + 15) == BLOCK_HARD)) {
      // If he hit, move Link right to the next multiple of 8.
      LinkX += 8 - (LinkX % 8);}

    // Check against running into a wall to the right.
    if (// First check that we moved right.
        LinkX > OldLinkX &&
        // Then check that we're not at the top of a positive stair.
        (StairPos != STAIR_TOP || StairMode != STAIR_POS) &&
        (// Then check for hard blocks at Link's top, middle, and bottom.
         GetBlockType(LinkX + 15, LinkY) == BLOCK_HARD ||
         GetBlockType(LinkX + 15, LinkY + 8) == BLOCK_HARD ||
         GetBlockType(LinkX + 15, LinkY + 15) == BLOCK_HARD)) {
      // If he hit, move Link left to the previous multiple of 8.
      LinkX &= 0x1FFF8;}}

  //// Then adjust y positioning.
  // If we're at the middle of the stair, use the standard formula.
  LinkY = LinkX * StairMode + StairY;

  // If we're at the bottom, align Link with the anchored stair.
  if (StairPos == STAIR_BOTTOM &&
      ((StairMode == STAIR_NEG && LinkX <= ComboX(StairLoc) - 16) ||
       (StairMode == STAIR_POS && LinkX >= ComboX(StairLoc) + 16))) {
    LinkY = ComboY(StairLoc);}
  // If we're at the top, align Link with the cell above the anchored stair.
  else if (StairPos == STAIR_TOP &&
           ((StairMode == STAIR_NEG && LinkX >= ComboX(StairLoc) - 1) ||
            (StairMode == STAIR_POS && LinkX <= ComboX(StairLoc) + 1))) {
    LinkY = ComboY(StairLoc) - 16;}}

// Find the stair that Link is currently standing on.
void LinkStairFindStair() {

  if (StairLoc == -1) {return;}

  //// First, check if we've moved off of the stair we're currently anchored to.
  // Get the edge closest to the stair.
  int x = LinkX + Cond(StairMode == STAIR_POS, 0, 15);
  int stairX = ComboX(StairLoc);
  int stairTX = StairLoc % 16;
  int stairTY = StairLoc >> 4;
  // Direction we've shifted.
  int shiftDir = 0;
  // We've moved off the left side of the stair, so move the StairLoc
  // 1 to the left, plus up or down as appropriate.
  if (x < stairX) {
    stairTX--;
    stairTY -= StairMode;
    shiftDir = -1;}
  // We've moved off the right side of the stair, so move the StairLoc
  // 1 to the right, plus up or down as appropriate.
  else if (x >= stairX + 16) {
    stairTX++;
    stairTY += StairMode;
    shiftDir = 1;}

  StairLoc = FindLoc(stairTX, stairTY);
  StairPos = STAIR_MIDDLE;

  // If we found the stairs, but we're on the top edge of a stair (and
  // not on the edge of a screen), set to the top edge anyway.
  if (IsValidStair(StairLoc) &&
      ((StairMode == STAIR_POS && stairTX != 0) ||
       (StairMode == STAIR_NEG && stairTX != 15))) {
    int aboveLoc = FindLoc(stairTX - StairMode, stairTY - 1);
    if (!IsValidStair(aboveLoc)) {
      StairPos = STAIR_TOP;}}

  // Check for a stair to the side.
  if (// First, make sure that we didn't already find a stair.
      !IsValidStair(StairLoc) &&
      // And then also make sure that we didn't shift up the stair,
      // because we're shifting up again and a double shift doesn't
      // make sense.
      shiftDir * StairMode != -1) {
    StairLoc = FindLoc(stairTX - StairMode, stairTY - 1);
    // If we're on the bottom of the screen, assume there's more
    // stairs on the next screen.
    if (stairTY - 1 < 10) {
      StairPos = STAIR_BOTTOM;}}

  // Then check for a stair diagonally downward.
  if (!IsValidStair(StairLoc)) {
    StairLoc = FindLoc(stairTX + StairMode, stairTY + 1);
    StairPos = STAIR_TOP;}

  // Check if we failed.
  if (!IsValidStair(StairLoc)) {
    StairLoc = -1;
    return;}

  // Set StairLeft and StairRight to the proper values for Link's position.
  if (StairPos == STAIR_MIDDLE) {
    StairLeft = 0;
    StairRight = 255;}
  else {
    stairTX = StairLoc % 16;
    StairLeft = (stairTX - 1) * 16 - 2;
    StairRight = (stairTX + 1) * 16 + 2;}

  // Find if there's a stair above and below.
  StairAbove = IsValidStair(FindLoc(stairTX - StairMode, stairTY - 1));
  StairBelow = IsValidStair(FindLoc(stairTX + StairMode, stairTY + 1));}

// See if Link is leaving the stairs.
void LinkStairFallOff() {
  if (// Getting hurt knocks you off of stairs.
      Link->Action == LA_GOTHURTLAND || Link->Action == LA_GOTHURTWATER ||
      // If we couldn't locate a stair earlier, that means we fall off, too.
      StairLoc == -1 ||
      // Or if we've moved too far off of the top or bottom of a stair.
      LinkX < StairLeft || LinkX > StairRight) {
    StairMode = STAIR_NONE;
    LinkMode = LINK_MODE_CUSTOM;}}

// Jump according to stair mode rules.
void LinkStairJump() {
  if (// The Jump button is pressed.
      PressJump &&
      // Can't be doing anything but walking.
      (Link->Action == LA_NONE || Link->Action == LA_WALKING)) {
    StairMode = STAIR_NONE;
    LinkMode = LINK_MODE_CUSTOM;
    // Jump!
    SideviewJump();}}

// Assigns all the OldLink variables for the upcoming frame.
// Place before Waitdraw().
void OldLink_Update1() {
  OldLinkX = Link->X;
  OldLinkY = Link->Y;
  OldLinkAction = Link->Action;}

// Record the current dmap and dscreen right before they are changed.
// Place before Waitdraw().
void ScreenChange_Update1() {
  OldDMap = Game->GetCurDMap();
  OldDScreen = Game->GetCurDMapScreen();}

// Updates information dealing with changing screens.
// Place after Waitdraw(), when the screen changes happen.
void ScreenChange_Update2() {
  // Grab current values.
  int dMap = Game->GetCurDMap();
  int dScreen = Game->GetCurDMapScreen();
  // Compare with old values.
  DMapChanged = dMap != OldDMap;
  ScreenChanged = DMapChanged || dScreen != OldDScreen;

  // Check for scrolling change to the same screen.
  if (Link->Action == LA_SCROLLING) {
    if (!ScreenChanged && !_ScreenChanged_ScrollFlag) {
      ScreenChanged = true;
      _ScreenChanged_ScrollFlag = true;}}
  // We're no longer scrolling, so reset scroll flag.
  else {
    _ScreenChanged_ScrollFlag = false;}

  // Check for a forced screen change flag.
  if (_ScreenChanged_ForceFlag) {
    ScreenChanged = true;
    _ScreenChanged_ForceFlag = false;}

  // Find the screen change direction.
  if (ScreenChanged) {
    // Mark the screen change as needing to be handled.
    ScreenChangeHandled = false;
    // Try to guess the direction.
    if (Link->Y >= 160) {ScreenChangeDir = DIR_UP;}
    else if (Link->Y <= 0) {ScreenChangeDir = DIR_DOWN;}
    else if (Link->X >= 240) {ScreenChangeDir = DIR_LEFT;}
    else if (Link->X <= 0) {ScreenChangeDir = DIR_RIGHT;}
    else {ScreenChangeDir = SCREEN_CHANGE_WARP;}}}

// Adjust some of Link's variables after all the mechanical
// manipulation is done.
void LinkAdjust() {
  // Don't do anything in engine mode.
  if (LinkMode == LINK_MODE_ENGINE) {return;}

  // Update Link's actual position.
  Link->X = Round(LinkX);
  Link->Y = Round(LinkY);

  // Force the walking animation if we moved and have no other action.
  if (Link->Action == LA_NONE && (LinkX != OldLinkX || LinkY != OldLinkY)) {
    Link->Action = LA_WALKING;}

  // Set the direction according to input.
  if (Link->InputUp) {Link->Dir = DIR_UP;}
  else if (Link->InputDown) {Link->Dir = DIR_DOWN;}
  else if (Link->InputLeft) {Link->Dir = DIR_LEFT;}
  else if (Link->InputRight) {Link->Dir = DIR_RIGHT;}}

// Don't scroll through items on sideview screens with L.
void Input_Update1() {
  // Ignore L if this is a sideview screen.
  if (IsSideview()) {
    InputJump = Link->InputL;
    PressJump = Link->PressL;
    Link->InputL = false;
    Link->PressL = false;}}

// Change the inputs so the engine doesn't set Link facing a weird
// direction or something else we don't want.
void Input_Update2() {

  // If we're not in engine mode, up and down take preference for
  // direction.
  if (LinkMode != LINK_MODE_ENGINE &&
      (Link->InputUp || Link->InputDown)) {
    Link->InputLeft = false;
    Link->InputRight = false;
    Link->PressLeft = false;
    Link->PressRight = false;}}

ffc script ScreenChange {
  void run() {
    _ScreenChanged_ForceFlag = true;}}

// Don't carry over velocity or stair state.
global script OnContinue {
  void run() {
    StairMode = STAIR_NONE;
    LinkVy = 0;}}

// Set first argument to Link's full jump speed.
// Set second argument to Link's jump speed while holding down.
item script AdjustLinkJump {
  void run (int jumpSpeed, int hopSpeed) {
    LinkJump = jumpSpeed;
    LinkHop = hopSpeed;}}