38 replies to this topic

[grayswandir]

Code

import "std.zh"
////////////////////////////////////////////////////////////////
//// Constants
//// Physics.
const float GRAV = 0.16;
const float TERM = 3.2;
//// Platform.
// In freefall.
const int PLATFORM_AIR = 0;
// Standing on a hard platform.
const int PLATFORM_HARD = 1;
// Standing on a soft platform.
const int PLATFORM_SOFT = 2;
//// Stairs
const int STAIR_NONE = 0;
// Standing on a up-left down-right stair.
const int STAIR_POS = 1;
// Standing on a up-right down-left stair.
const int STAIR_NEG = -1;
// Soft platforms
const int CF_SOFT = 98;
// Stairs.
const int CT_NEG = 142;
const int CT_CROSS = 143;
const int CT_POS = 144;
//// Link Movement
const int JUMP = -4;
const int LOW_JUMP = -1;
const float WALK = 1.5;
////////////////////////////////////////////////////////////////
//// Misc Indices
//// NPCs
// Vertical speed.
const int MISC_NPC_VY = 0;
////////////////////////////////////////////////////////////////
//// Global Variables.
//// Link State
// Link's actual location. Every frame Link->X and Link->Y are
// set to these values. This is so Link can have partial-pixel movement.
float LinkX = 0;
float LinkY = 0;
// Link's vertical velocity.
float LinkVy = 0;
// What Link is currently standing on.
int LinkPlatform = PLATFORM_AIR;
// If Link is on a stair.
int LinkStair = STAIR_NONE;
// The y offset for being on a stair.
int LinkStairY = 0;
// The left edge of the stair.
int LinkStairLeft = 0;
// The right edge of the stair.
int LinkStairRight = 0;
// If the stairs need to be recalculated.
bool LinkStairRecalc = false;

// If we are overriding link's position this frame.
bool LinkPosOverride = false;
//// Link's State last frame.
int LinkLastX = -1;
int LinkLastY = -1;
int LinkLastAction = LA_NONE;
//// Inputs last frame.
bool LastInputUp = false;
bool LastInputDown = false;
bool LastInputLeft = false;
bool LastInputRight = false;
global script Active {
  void run() {
    LinkX = Link->X;
    LinkY = Link->Y;
    while (true) {
      LinkUpdate();
      ActionJump();
      //EnemyUpdate();
      InputsUpdate();
      Waitdraw();
      ScreenChange_Update();

      LinkUpdate2();
      InputsUpdate2();
      Waitframe();}}}
int PlatformType(int x, int y) {
  if (!Screen->isSolid(x, y)) {
    return PLATFORM_AIR;}
  else if (ComboFI(x, y, CF_SOFT) || IsStair(x, y)) {
    return PLATFORM_SOFT;}
  else {
    return PLATFORM_HARD;}}
bool IsStair(int x, int y) {
  return IsStair(ComboAt(x, y));}
bool IsStair(int loc) {
  int ct = Screen->ComboT[loc];
  return ct >= CT_NEG && ct <= CT_POS;}
// Update Link's variables.
void LinkUpdate() {
  // Update Last frame variables.
  LinkLastX = LinkX;
  LinkLastY = LinkY;
  LinkLastAction = Link->Action;
  // If the screen changed and we're on a stair, update
  // stair information for the new screen once we stop scrolling.
  if (LinkStair != STAIR_NONE && ScreenChanged) {
    LinkStairRecalc = true;}
  // Check if we're no longer on a stair.
  if (LinkStair != STAIR_NONE && Link->Action != LA_SCROLLING) {
    // Recalculate stairs
    if (LinkStairRecalc) {
      int loc = ComboAt(Link->X + 8, Link->Y + 20);
      if (IsStair(loc)) {
          StairLocate(loc);}
      else {
        if (LinkStair == STAIR_POS) {
          loc = ComboAt(Link->X - 2, Link->Y + 12);}
        else if (LinkStair == STAIR_NEG) {
          loc = ComboAt(Link->X + 18, Link->Y + 12);}
        if (IsStair(loc)) {
          StairLocate(loc);}
        else {
          LinkStair = STAIR_NONE;}}}
    // We were hurt, so fall off.
    if (Link->Action == LA_GOTHURTLAND) {
      LinkStair = STAIR_NONE;}
    else {
      // Check if we're no longer on a stair.
      int under = ComboAt(LinkX + 8, LinkY + 20);
      int forward = -1;
      if (LinkStair == STAIR_POS) {forward = ComboAt(LinkX - 2, LinkY + 12);}
      else if (LinkStair == STAIR_NEG) {forward = ComboAt(LinkX + 18, LinkY + 12);}
      int ct = Screen->ComboT[under];
      bool hasStair = ct == CT_CROSS || ct == CT_CROSS + LinkStair;
      if (!hasStair && forward != -1) {
        ct = Screen->ComboT[forward];
        hasStair = ct == CT_CROSS || ct == CT_CROSS + LinkStair;}
      if (!hasStair) {
        LinkStair = STAIR_NONE;}}}
  // Move accordinng to our special movement.
  if (LinkPosOverride) {
    LinkOverridePosition();}
  // Or we're relying on the engine for something,
  // so change our x and y to theirs.
  else {
    LinkX = Link->X;
    LinkY = Link->Y;}
  // If we've moved and have no action, set the action to walking.
  if (Link->Action == LA_NONE &&
      (Link->InputLeft || Link->InputRight)) {
    Link->Action = LA_WALKING;}}
void LinkUpdate2() {
  // Check if we're using the engine's movement this frame.
  LinkPosOverride =
    Link->Action != LA_FROZEN &&
    Link->Action != LA_SCROLLING &&
    Link->Action != LA_GOTHURTLAND &&
    !ScreenChanged;
  // If we're on a stair and the screen is scrolling, then
  // change Link's X to match a change in Y and vice versa.
  //if (Link->Action == LA_SCROLLING && LinkStair != STAIR_NONE) {
  //  int dx = LinkX - LinkLastX;
  //  int dy = LinkY - LinkLastY;
  //  if (dy != 0) {
  //    LinkY = LinkX * LinkStair + LinkStairY;}
  //  else if (dx != 0) {
  //    LinkX = (LinkY - LinkStairY) / LinkStair;}}
  // Move Link to new location.
  // If we're frozen, it probably means the hookshot is being used.
  if (LinkPosOverride) {
    Link->X = Round(LinkX);
    Link->Y = Round(LinkY);}
  // Clear Jump and Z.
  Link->Jump = 0;
  Link->Z = 0;
  // Set direction.
  if (Link->Action != LA_FROZEN &&
      Link->Action != LA_SCROLLING) {
    if (LastInputUp) {Link->Dir = DIR_UP;}
    else if (LastInputDown) {Link->Dir = DIR_DOWN;}
    else if (Link->InputLeft) {Link->Dir = DIR_LEFT;}
    else if (Link->InputRight) {Link->Dir = DIR_RIGHT;}}}
// Override where the engine would have placed Link.
void LinkOverridePosition() {
  // Move by inputs.
  if (Link->Action == LA_NONE ||
      Link->Action == LA_WALKING ||
      (Link->Action == LA_ATTACKING &&
       LinkPlatform == PLATFORM_AIR)) {
    if (Link->InputLeft) {
      LinkX -= WALK;}
    else if (Link->InputRight) {
      LinkX += WALK;}}
  bool movedLeft = false;
  // Check if we can move left.
  if (LinkX < LinkLastX) {
    movedLeft = true;
    int left1 = PlatformType(LinkX, LinkY);
    int left2 = PlatformType(LinkX, LinkY + 8);
    int left3 = PlatformType(LinkX, LinkY + 15);
    if (LinkStair == STAIR_NONE &&
        (left1 == PLATFORM_HARD ||
         left2 == PLATFORM_HARD ||
         left3 == PLATFORM_HARD)) {
      LinkX += 8 - (LinkX % 8);}}
  bool movedRight = false;
  // Check if we can move right.
  if (LinkX > LinkLastX) {
    movedRight = true;
    int left1 = PlatformType(LinkX + 15, LinkY);
    int left2 = PlatformType(LinkX + 15, LinkY + 8);
    int left3 = PlatformType(LinkX + 15, LinkY + 15);
    if (LinkStair == STAIR_NONE &&
        (left1 == PLATFORM_HARD ||
         left2 == PLATFORM_HARD ||
         left3 == PLATFORM_HARD)) {
      LinkX &= 0x1FFF8;}}
  // Move by vertical velocity.
  LinkY += LinkVy;
  // Move according to a staircase.
  if (LinkStair != STAIR_NONE) {
    int x = Clamp(LinkX, LinkStairLeft, LinkStairRight);
    LinkY = x * LinkStair + LinkStairY;}
  // Not on a stair, check regular platforms
  else {
    // Check if we hit our head on something.
    if (LinkVy < 0) {
      int overLinkLeft = PlatformType(LinkX + 5, LinkY);
      int overLinkRight = PlatformType(LinkX + 11, LinkY);
      // We ran into a hard block.
      if (overLinkLeft == PLATFORM_HARD || overLinkRight == PLATFORM_HARD) {
        LinkVy = 0;
        // Move to the next multiple of 8.
        LinkY += 8 - (LinkY % 8);}}
    // See if we're standing on a platform.
    int underLinkLeft = PlatformType(LinkX + 5, LinkY + 16);
    int underLinkRight = PlatformType(LinkX + 11, LinkY + 16);
    // We're on a hard platform.
    if (LinkVy >= 0 &&
        (underLinkLeft == PLATFORM_HARD || underLinkRight == PLATFORM_HARD)) {
      LinkPlatform = PLATFORM_HARD;
      LinkVy = 0;
      // Round down to nearest multiple of 8.
      LinkY &= 0x1FFF8;}
    // We're on a soft platform.
    else if (LinkVy >= 0 &&
             (underLinkLeft == PLATFORM_SOFT ||
              underLinkRight == PLATFORM_SOFT)) {
      // If we're falling and holding down, or we started below it,
      // go through it.
      if ((LinkVy > 0 && Link->InputDown) ||
          (LinkLastY > (LinkY & 0x1FFF8))) {
        LinkPlatform = PLATFORM_AIR;
        // Accelerate from gravity.
        LinkVy += GRAV;
        if (LinkVy >= TERM) {
          LinkVy = TERM;}}
      // Otherwise stop.
      else {
        LinkPlatform = PLATFORM_SOFT;
        LinkVy = 0;
        // Round down to nearest multiple of 8.
        LinkY &= 0x1FFF8;}}
    // We're in freefall.
    else {
      LinkPlatform = PLATFORM_AIR;
      // Accelerate from gravity.
      LinkVy += GRAV;
      if (LinkVy >= TERM) {
        LinkVy = TERM;}}}
  // Check for stairs.
  if (LinkStair == STAIR_NONE &&
      (LinkPlatform == PLATFORM_HARD ||
       LinkPlatform == PLATFORM_SOFT)) {
    // Up-going stairs.
    if (movedLeft && Link->InputUp) {
      int loc = ComboAt(LinkX, LinkY + 15);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_POS) {
        LinkStair = STAIR_POS;
        StairLocate(loc);}}
    else if (movedRight && Link->InputUp) {
      int loc = ComboAt(LinkX + 15, LinkY + 15);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_NEG) {
        LinkStair = STAIR_NEG;
        StairLocate(loc);}}
    // Down-going stairs.
    if (movedLeft && Link->InputDown) {
      int loc = ComboAt(LinkX, LinkY + 18);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_NEG) {
        LinkStair = STAIR_NEG;
        StairLocate(loc);}}
    else if (movedRight && Link->InputDown) {
      int loc = ComboAt(LinkX + 15, LinkY + 18);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_POS) {
        LinkStair = STAIR_POS;
        StairLocate(loc);}}}}
// Jump if Link has been set to.
void ActionJump() {
  if ((LinkPlatform != PLATFORM_AIR || LinkStair != STAIR_NONE) &&
      Link->PressL &&
      (Link->Action == LA_NONE || Link->Action == LA_WALKING)) {
    LinkStair = STAIR_NONE;
    if (Link->InputDown) {
      LinkVy = LOW_JUMP;}
    else {
      LinkVy = JUMP;}
    Game->PlaySound(SFX_JUMP);}}
// Clear inputs that we don't want the engine to use.
void InputsUpdate() {
  LastInputUp = Link->InputUp;
  LastInputDown = Link->InputDown;
  LastInputLeft = Link->InputLeft;
  LastInputRight = Link->InputRight;
  Link->InputL = false;
  Link->PressL = false;
  if (Link->Action == LA_FROZEN) {return;}
  // Cancel left/right movement for drawing if there is up/down movement.
  if (Link->InputUp || Link->InputDown) {
    Link->InputLeft = false;
    Link->PressLeft = false;
    Link->InputRight = false;
    Link->PressRight = false;}
  //Link->InputUp = false;
  //Link->InputDown = false;
}
void StairLocate(int start) {
  LinkStairY = ComboY(start) - 16 - ComboX(start) * LinkStair;
  //// Right edge.
  int x = start % 16;
  int y = start >> 4;
  int ct = Screen->ComboT[start];
  while (x <= 15 && y >= 0 && y <= 10 &&
         (ct == CT_CROSS || ct == CT_CROSS + LinkStair)) {
    x++;
    y += LinkStair;
    ct = Screen->ComboT[y * 16 + x];}
  LinkStairRight = (x + Cond(LinkStair == STAIR_POS, 0, -1)) * 16;
  // We fell off the edge of the screen, so let Link keep going.
  if (ct == CT_CROSS || ct == CT_CROSS + LinkStair) {
    LinkStairRight += 16;}
  //// Left edge.
  x = start % 16;
  y = start >> 4;
  ct = Screen->ComboT[start];
  while (x >= 0 && y >= 0 && y <= 10 &&
         (ct == CT_CROSS || ct == CT_CROSS + LinkStair)) {
    x--;
    y -= LinkStair;
    ct = Screen->ComboT[y * 16 + x];}
  LinkStairLeft = (x + Cond(LinkStair == STAIR_POS, 1, 0)) * 16;
  // We fell off the edge of the screen, so let Link keep going.
  if (ct == CT_CROSS || ct == CT_CROSS + LinkStair) {
    LinkStairLeft -= 16;}
  LinkStairRecalc = false;}
// Clear inputs that we don't want the engine to use.
void InputsUpdate2() {
  if (Link->Action == LA_FROZEN) {return;}
  Link->InputLeft = false;
  Link->InputRight = false;}
void EnemyUpdate() {
  for (int i = 1; i <= Screen->NumNPCs(); i++) {
    EnemyUpdate(Screen->LoadNPC(i));}}
void EnemyUpdate(npc enemy) {
  enemy->Z = 0;
  // Don't let them go up or down.
  if (enemy->Dir == DIR_UP || enemy->Dir == DIR_DOWN) {
    int dir = DIR_LEFT + Rand(2);
    if (CanWalk(enemy->X, enemy->Y, dir, Max(1, enemy->Step), true)) {
      enemy->Dir = dir;}
    else {
      dir ^= 1;
      if (CanWalk(enemy->X, enemy->Y, dir, Max(1, enemy->Step), true)) {
        enemy->Dir = dir;}}}
  // Check if we hit our head on something.
  if (enemy->Misc[MISC_NPC_VY] < 0) {
    int overLeft = PlatformType(enemy->X + 5, enemy->Y);
    int overRight = PlatformType(enemy->Y + 11, enemy->Y);
    // We ran into a hard block.
    if (overLeft == PLATFORM_HARD || overRight == PLATFORM_HARD) {
      enemy->Misc[MISC_NPC_VY] = 0;
      // Move to the next multiple of 8.
      enemy->Y += 8 - (enemy->Y % 8);}}
  // See if we're standing on a platform.
  int underLeft = PlatformType(enemy->X + 5, enemy->Y + 16);
  int underRight = PlatformType(enemy->Y + 11, enemy->Y + 16);
  int platform;
  // We're on a hard platform.
  if (enemy->Misc[MISC_NPC_VY] >= 0 &&
      (underLeft == PLATFORM_HARD || underRight == PLATFORM_HARD)) {
    platform = PLATFORM_HARD;
    enemy->Misc[MISC_NPC_VY] = 0;
    // Round down to nearest multiple of 8.
    enemy->Y &= 0x1FFF8;}
  // We're on a soft platform.
  else if (enemy->Misc[MISC_NPC_VY] >= 0 &&
           (underLeft == PLATFORM_SOFT ||
            underRight == PLATFORM_SOFT)) {
    platform = PLATFORM_SOFT;
    enemy->Misc[MISC_NPC_VY] = 0;
    // Round down to nearest multiple of 8.
    enemy->Y &= 0x1FFF8;}
  // We're in freefall.
  else {
    platform = PLATFORM_AIR;
    enemy->Misc[MISC_NPC_VY] += GRAV;}
  // Move by velocity.
  enemy->Y += enemy->Misc[MISC_NPC_VY];}
// Test for changes in screen.
// Last noticed DMap.
int LastDMap = -1;
// Last noticed DScreen.
int LastDScreen = -1;
// If the screen has changed.
bool ScreenChanged = false;
// If the dmap has changed.
bool DMapChanged = false;
void ScreenChange_Update() {
  int dMap = Game->GetCurDMap();
  int dScreen = Game->GetCurDMapScreen();
  DMapChanged = dMap != LastDMap;
  ScreenChanged = DMapChanged || dScreen != LastDScreen;
  LastDMap = dMap;
  LastDScreen = dScreen;}

 

Here's another update. This should fix all the weird Link teleporting bugs and such.

 

For the crossing stairs in the first area, you set them up wrong. Those staircases just pass right by each other, so you don't actually need to have the 'cross' type stair in there. If they were one tile further apart, they'd meet in the middle - that's when you use the cross type.

 

Having stairs span multiple screens is harder than I thought it would be. Apparently you can't manipulate Link at all while the screen is scrolling, so at the very least you couldn't have him smoothly walking up the steps while the screen is changing.

 

 

 

 

 

 

And the quest looks really nice, by the way.

[Alucard648]

Here's another update. This should fix all the weird Link teleporting bugs and such.

Bug fixes are confirmed.

http://www.mediafire...tlevania(2).qst

 

The only thing left to do is screen-connecting stairs... Lack of which currently prevents Link from completing 1-2 in this quest without cheats.

[grayswandir]

Code

import "std.zh"
////////////////////////////////////////////////////////////////
//// Constants
//// Physics.
const float GRAV = 0.16;
const float TERM = 3.2;
//// Platform.
// In freefall.
const int PLATFORM_AIR = 0;
// Standing on a hard platform.
const int PLATFORM_HARD = 1;
// Standing on a soft platform.
const int PLATFORM_SOFT = 2;
//// Stairs
const int STAIR_NONE = 0;
// Standing on a up-left down-right stair.
const int STAIR_POS = 1;
// Standing on a up-right down-left stair.
const int STAIR_NEG = -1;
// Soft platforms
const int CF_SOFT = 98;
// Stairs.
const int CT_NEG = 142;
const int CT_CROSS = 143;
const int CT_POS = 144;
//// Link Movement
const int JUMP = -4;
const int LOW_JUMP = -1;
const float WALK = 1.5;
////////////////////////////////////////////////////////////////
//// Misc Indices
//// NPCs
// Vertical speed.
const int MISC_NPC_VY = 0;
////////////////////////////////////////////////////////////////
//// Global Variables.
//// Link State
// Link's actual location. Every frame Link->X and Link->Y are
// set to these values. This is so Link can have partial-pixel movement.
float LinkX = 0;
float LinkY = 0;
// Link's vertical velocity.
float LinkVy = 0;
// What Link is currently standing on.
int LinkPlatform = PLATFORM_AIR;
// If Link is on a stair.
int LinkStair = STAIR_NONE;
// The y offset for being on a stair.
int LinkStairY = 0;
// The left edge of the stair.
int LinkStairLeft = 0;
// The right edge of the stair.
int LinkStairRight = 0;
// If we are overriding link's position this frame.
bool LinkPosOverride = false;
// Master override for Link's position.
int LinkOverrideX = 0;
int LinkOverrideY = 0;
bool LinkOverridePos = false;
//// Link's State last frame.
int LinkLastX = -1;
int LinkLastY = -1;
int LinkLastAction = LA_NONE;
//// Inputs last frame.
bool LastInputUp = false;
bool LastInputDown = false;
bool LastInputLeft = false;
bool LastInputRight = false;
global script Active {
  void run() {
    LinkX = Link->X;
    LinkY = Link->Y;
    while (true) {
      LinkUpdate();
      ActionJump();
      //EnemyUpdate();
      InputsUpdate();
      Waitdraw();
      ScreenChange_Update();

      LinkUpdate2();
      InputsUpdate2();
      Waitframe();}}}
int PlatformType(int x, int y) {
  if (!Screen->isSolid(x, y)) {
    return PLATFORM_AIR;}
  else if (ComboFI(x, y, CF_SOFT) || IsStair(x, y)) {
    return PLATFORM_SOFT;}
  else {
    return PLATFORM_HARD;}}
bool IsStair(int x, int y) {
  return IsStair(ComboAt(x, y));}
bool IsStair(int loc) {
  int ct = Screen->ComboT[loc];
  return ct >= CT_NEG && ct <= CT_POS;}
// Update Link's variables.
void LinkUpdate() {
  // Update Last frame variables.
  LinkLastX = LinkX;
  LinkLastY = LinkY;
  LinkLastAction = Link->Action;
  // Master override.
  if (Link->Action != LA_SCROLLING && LinkOverridePos) {
    Link->X = LinkOverrideX;
    LinkX = LinkOverrideX;
    Link->Y = LinkOverrideY;
    LinkY = LinkOverrideY;
    LinkOverridePos = false;}
  // Check if we're no longer on a stair.
  if (LinkStair != STAIR_NONE && Link->Action != LA_SCROLLING) {
    if (// We were hurt, so fall off.
        Link->Action == LA_GOTHURTLAND ||
        // Moved past the left edge.
        (LinkX < LinkStairLeft - Cond(LinkStair == STAIR_POS, 18, 2)) ||
        // Moved past the right edge.
        (LinkX > LinkStairRight + Cond(LinkStair == STAIR_POS, 2, 18))) {
      LinkStair = STAIR_NONE;}}
  // Move accordinng to our special movement.
  if (LinkPosOverride) {
    LinkOverridePosition();}
  // Or we're relying on the engine for something,
  // so change our x and y to theirs.
  else {
    LinkX = Link->X;
    LinkY = Link->Y;}
  // If we've moved and have no action, set the action to walking.
  if (Link->Action == LA_NONE &&
      (Link->InputLeft || Link->InputRight)) {
    Link->Action = LA_WALKING;}}
void LinkUpdate2() {
  // Check if we're using the engine's movement this frame.
  LinkPosOverride =
    Link->Action != LA_FROZEN &&
    Link->Action != LA_SCROLLING &&
    Link->Action != LA_GOTHURTLAND &&
    !ScreenChanged;
  // Adjust positioning if we're on stairs and walked off the edge of the screen.
  if (ScreenChanged && Link->Action == LA_SCROLLING &&
      LinkStair != STAIR_NONE) {
    //// Find the new starting location.
    int loc;
    // Positive Stairs.
    if (LinkStair == STAIR_POS) {
      if (ScreenScrollDirection == DIR_UP) {
        LinkOverrideX = LinkStairLeft + 16;
        LinkOverrideY = 160;
        loc = ComboAt(LinkStairLeft, 160);}
      else if (ScreenScrollDirection == DIR_DOWN) {
        LinkOverrideX = LinkStairRight;
        LinkOverrideY = 0;
        loc = ComboAt(LinkStairRight - 16, 0);}
      else if (ScreenScrollDirection == DIR_LEFT) {
        LinkOverrideX = 240;
        LinkOverrideY = LinkStairY;
        loc = ComboAt(240, LinkStairY);}
      else if (ScreenScrollDirection == DIR_RIGHT) {
        LinkOverrideX = 0;
        LinkOverrideY = LinkStairY + 240;
        loc = ComboAt(0, LinkStairY + 272);}}
    // Negative Stairs.
    else {
      if (ScreenScrollDirection == DIR_UP) {
        LinkOverrideX = LinkStairRight - 16;
        LinkOverrideY = 160;
        loc = ComboAt(LinkStairRight, 160);}
      else if (ScreenScrollDirection == DIR_DOWN) {
        LinkOverrideX = LinkStairLeft;
        LinkOverrideY = 0;
        loc = ComboAt(LinkStairLeft + 16, 0);}
      else if (ScreenScrollDirection == DIR_LEFT) {
        LinkOverrideX = 240;
        LinkOverrideY = LinkStairY + 16;
        loc = ComboAt(240, LinkStairY + 32);}
      else if (ScreenScrollDirection == DIR_RIGHT) {
        LinkOverrideX = 0;
        LinkOverrideY = LinkStairY - 256;
        loc = ComboAt(0, LinkOverrideY + 16);}}
    StairLocate(loc);
    LinkOverridePos = true;}
  // Move Link to new location.
  // If we're frozen, it probably means the hookshot is being used.
  if (LinkPosOverride) {
    Link->X = Round(LinkX);
    Link->Y = Round(LinkY);}
  // Clear Jump and Z.
  Link->Jump = 0;
  Link->Z = 0;
  // Set direction.
  if (Link->Action != LA_FROZEN &&
      Link->Action != LA_SCROLLING) {
    if (LastInputUp) {Link->Dir = DIR_UP;}
    else if (LastInputDown) {Link->Dir = DIR_DOWN;}
    else if (Link->InputLeft) {Link->Dir = DIR_LEFT;}
    else if (Link->InputRight) {Link->Dir = DIR_RIGHT;}}}
// Override where the engine would have placed Link.
void LinkOverridePosition() {
  // Move by inputs.
  if (Link->Action == LA_NONE ||
      Link->Action == LA_WALKING ||
      (Link->Action == LA_ATTACKING &&
       LinkPlatform == PLATFORM_AIR)) {
    if (Link->InputLeft) {
      LinkX -= WALK;}
    else if (Link->InputRight) {
      LinkX += WALK;}}
  bool movedLeft = false;
  // Check if we can move left.
  if (LinkX < LinkLastX) {
    movedLeft = true;
    int left1 = PlatformType(LinkX, LinkY);
    int left2 = PlatformType(LinkX, LinkY + 8);
    int left3 = PlatformType(LinkX, LinkY + 15);
    if (LinkStair == STAIR_NONE &&
        (left1 == PLATFORM_HARD ||
         left2 == PLATFORM_HARD ||
         left3 == PLATFORM_HARD)) {
      LinkX += 8 - (LinkX % 8);}}
  bool movedRight = false;
  // Check if we can move right.
  if (LinkX > LinkLastX) {
    movedRight = true;
    int left1 = PlatformType(LinkX + 15, LinkY);
    int left2 = PlatformType(LinkX + 15, LinkY + 8);
    int left3 = PlatformType(LinkX + 15, LinkY + 15);
    if (LinkStair == STAIR_NONE &&
        (left1 == PLATFORM_HARD ||
         left2 == PLATFORM_HARD ||
         left3 == PLATFORM_HARD)) {
      LinkX &= 0x1FFF8;}}
  // Move by vertical velocity.
  LinkY += LinkVy;
  // Move according to a staircase.
  if (LinkStair != STAIR_NONE) {
    int x = Clamp(LinkX, LinkStairLeft, LinkStairRight);
    LinkY = x * LinkStair + LinkStairY;}
  // Not on a stair, check regular platforms
  else {
    // Check if we hit our head on something.
    if (LinkVy < 0) {
      int overLinkLeft = PlatformType(LinkX + 5, LinkY);
      int overLinkRight = PlatformType(LinkX + 11, LinkY);
      // We ran into a hard block.
      if (overLinkLeft == PLATFORM_HARD || overLinkRight == PLATFORM_HARD) {
        LinkVy = 0;
        // Move to the next multiple of 8.
        LinkY += 8 - (LinkY % 8);}}
    // See if we're standing on a platform.
    int underLinkLeft = PlatformType(LinkX + 5, LinkY + 16);
    int underLinkRight = PlatformType(LinkX + 11, LinkY + 16);
    // We're on a hard platform.
    if (LinkVy >= 0 &&
        (underLinkLeft == PLATFORM_HARD || underLinkRight == PLATFORM_HARD)) {
      LinkPlatform = PLATFORM_HARD;
      LinkVy = 0;
      // Round down to nearest multiple of 8.
      LinkY &= 0x1FFF8;}
    // We're on a soft platform.
    else if (LinkVy >= 0 &&
             (underLinkLeft == PLATFORM_SOFT ||
              underLinkRight == PLATFORM_SOFT)) {
      // If we're falling and holding down, or we started below it,
      // go through it.
      if ((LinkVy > 0 && Link->InputDown) ||
          (LinkLastY > (LinkY & 0x1FFF8))) {
        LinkPlatform = PLATFORM_AIR;
        // Accelerate from gravity.
        LinkVy += GRAV;
        if (LinkVy >= TERM) {
          LinkVy = TERM;}}
      // Otherwise stop.
      else {
        LinkPlatform = PLATFORM_SOFT;
        LinkVy = 0;
        // Round down to nearest multiple of 8.
        LinkY &= 0x1FFF8;}}
    // We're in freefall.
    else {
      LinkPlatform = PLATFORM_AIR;
      // Accelerate from gravity.
      LinkVy += GRAV;
      if (LinkVy >= TERM) {
        LinkVy = TERM;}}}
  // Check for stairs.
  if (LinkStair == STAIR_NONE &&
      (LinkPlatform == PLATFORM_HARD ||
       LinkPlatform == PLATFORM_SOFT)) {
    // Up-going stairs.
    if (movedLeft && Link->InputUp) {
      int loc = ComboAt(LinkX, LinkY + 15);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_POS) {
        LinkStair = STAIR_POS;
        StairLocate(loc);}}
    else if (movedRight && Link->InputUp) {
      int loc = ComboAt(LinkX + 15, LinkY + 15);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_NEG) {
        LinkStair = STAIR_NEG;
        StairLocate(loc);}}
    // Down-going stairs.
    if (movedLeft && Link->InputDown) {
      int loc = ComboAt(LinkX, LinkY + 18);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_NEG) {
        LinkStair = STAIR_NEG;
        StairLocate(loc);}}
    else if (movedRight && Link->InputDown) {
      int loc = ComboAt(LinkX + 15, LinkY + 18);
      int ct = Screen->ComboT[loc];
      if (ct == CT_CROSS || ct == CT_POS) {
        LinkStair = STAIR_POS;
        StairLocate(loc);}}}}
// Jump if Link has been set to.
void ActionJump() {
  if ((LinkPlatform != PLATFORM_AIR || LinkStair != STAIR_NONE) &&
      Link->PressL &&
      (Link->Action == LA_NONE || Link->Action == LA_WALKING)) {
    LinkStair = STAIR_NONE;
    if (Link->InputDown) {
      LinkVy = LOW_JUMP;}
    else {
      LinkVy = JUMP;}
    Game->PlaySound(SFX_JUMP);}}
// Clear inputs that we don't want the engine to use.
void InputsUpdate() {
  LastInputUp = Link->InputUp;
  LastInputDown = Link->InputDown;
  LastInputLeft = Link->InputLeft;
  LastInputRight = Link->InputRight;
  Link->InputL = false;
  Link->PressL = false;
  if (Link->Action == LA_FROZEN) {return;}
  // Cancel left/right movement for drawing if there is up/down movement.
  if (Link->InputUp || Link->InputDown) {
    Link->InputLeft = false;
    Link->PressLeft = false;
    Link->InputRight = false;
    Link->PressRight = false;}
  //Link->InputUp = false;
  //Link->InputDown = false;
}
void StairLocate(int start) {
  LinkStairY = ComboY(start) - 16 - ComboX(start) * LinkStair;
  //// Right edge.
  int x = start % 16;
  int y = start >> 4;
  int ct = Screen->ComboT[start];
  while (x <= 15 && y >= 0 && y <= 10 &&
         (ct == CT_CROSS || ct == CT_CROSS + LinkStair)) {
    x++;
    y += LinkStair;
    ct = Screen->ComboT[y * 16 + x];}
  LinkStairRight = (x + Cond(LinkStair == STAIR_POS, 0, -1)) * 16;
  // We fell off the edge of the screen, so let Link keep going.
  if (y == -1 || y == 11) {
    LinkStairRight += 16;}
  //// Left edge.
  x = start % 16;
  y = start >> 4;
  ct = Screen->ComboT[start];
  while (x >= 0 && y >= 0 && y <= 10 &&
         (ct == CT_CROSS || ct == CT_CROSS + LinkStair)) {
    x--;
    y -= LinkStair;
    ct = Screen->ComboT[y * 16 + x];}
  LinkStairLeft = (x + Cond(LinkStair == STAIR_POS, 1, 0)) * 16;
  // We fell off the edge of the screen, so let Link keep going.
  if (y == 11 || y == -1) {
    LinkStairLeft -= 16;}}
// Clear inputs that we don't want the engine to use.
void InputsUpdate2() {
  if (Link->Action == LA_FROZEN) {return;}
  Link->InputLeft = false;
  Link->InputRight = false;}
// Test for changes in screen.
// Last noticed DMap.
int LastDMap = -1;
// Last noticed DScreen.
int LastDScreen = -1;
// If the screen has changed.
bool ScreenChanged = false;
// If the dmap has changed.
bool DMapChanged = false;
// Direction we scrolled into this screen in.
int ScreenScrollDirection = -1;
void ScreenChange_Update() {
  int dMap = Game->GetCurDMap();
  int dScreen = Game->GetCurDMapScreen();
  DMapChanged = dMap != LastDMap;
  ScreenChanged = DMapChanged || dScreen != LastDScreen;
  LastDMap = dMap;
  LastDScreen = dScreen;
  // Grab the scrolling direction.
  if (Link->Action != LA_SCROLLING) {
    ScreenScrollDirection = -1;}
  else if (ScreenChanged) {
    if (Link->Y == 176) {ScreenScrollDirection = DIR_UP;}
    else if (Link->Y == -16) {ScreenScrollDirection = DIR_DOWN;}
    else if (Link->X == 256) {ScreenScrollDirection = DIR_LEFT;}
    else if (Link->X == -16) {ScreenScrollDirection = DIR_RIGHT;}
    else {ScreenScrollDirection = -1;}}}
// Like ComboAt, but returns -1 for offscreen.
int ComboAt2(int x, int y) {
  if (x < 0 || x > 255 || y < 0 || y > 175) {return -1;}
  return (y & 240) + (x >> 4);}

 

This should let stairs work between screens, but it looks real jumpy. I'm not really sure how to fix that.

[Alucard648]

Installed new version of the script into my quest. And while testing found more bugs.

 

1. If Link goes into horizontally adjacent screen right after exiting stairs he will phase trough solid floor.

Apparently the script assumes there would be more stairs further in the Link`s direction, but actually stairs end one combo before the edge of the screen.

2.Attempt to work around jumpy "multi-screen-stairs" animation by turning on "No screen scrolling" quest rule results in a royal warping madness that destroys the quest like a building made of playing cards.

 

Download updated. http://www.mediafire...castlevania.qst

 

Edit: another bug.

 

3. Going trough scrolling side warp while on stairs causes Link to fall off stairs.

http://www.mediafire...tlevanialv3.qst

Edited by Alucard648, 03 July 2013 - 04:40 PM.

[grayswandir]

Code

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 jump speed.
const float LINK_JUMP = -4;
// Link's hop speed.
const float LINK_HOP = -1;
// 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;
//// 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;
// 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 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;
// 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;
// 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();
        LinkStairFallOff();}
      // And 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();}}}
// 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 > 255 || y < 0 || y > 175) {return false;}
  else {return IsStair((y & 240) + (x >> 4));}}
bool IsStair(int loc) {
  int ct = Screen->ComboT[loc];
  return CT_NEG <= ct && ct <= CT_POS;}
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) {
  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) {
  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) {
  // Non-solid blocks are always empty.
  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;}}
// 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;
  // 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 = LINK_HOP;}
  // Otherwise do the full jump.
  else {LinkVy = LINK_JUMP;}}
// 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);}
  // 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);}
  // We're moving down-left, so check a down-left going stair on the
  // tile below Link.
  if (Link->InputLeft && Link->InputDown && IsNegStair(LinkX, LinkY + 18)) {
    MountStair(LinkX, LinkY + 18, STAIR_NEG);}
  // We're moving down-right, so check a down-right going stair on the
  // tile below Link.
  if (Link->InputRight && Link->InputDown &&
      IsPosStair(LinkX + 15, LinkY + 18)) {
    MountStair(LinkX + 15, LinkY + 18, STAIR_POS);}}
// 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 > 255 || y < 0 || y > 175 || !IsStair(start)) {
    LinkMode = LINK_MODE_CUSTOM;
    StairMode = STAIR_NONE;
    return false;}
  // Change to stair movement mode.
  LinkMode = LINK_MODE_STAIR;
  StairMode = mode;
  // 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;
  //// Find the left edge.
  x = start % 16;
  y = start >> 4;
  int ct = Screen->ComboT[start];
  bool inBound = true;
  // Keep moving along the stair until
  while (// We hit the edge of the screen
         inBound &&
         // or we are no longer on the right kind of stair.
         (ct == CT_CROSS || ct == CT_CROSS + StairMode)) {
    x--;
    y -= StairMode;
    if (x < 0 || y < 0 || y > 10) {inBound = false;}
    else {ct = Screen->ComboT[y * 16 + x];}}
  x++;
  y += StairMode;
  // If we fell off the edge, assume there's one more stair outside the screen.
  // so we can move smoothly.
  if (!inBound) {x--;}
  // If this is a negative stair, we've reached the bottom, so extend
  // by another tile.
  if (StairMode == STAIR_NEG) {x--;}
  // Set the left edge to where we stopped.
  StairLeft = x * 16;
  //// Find the right edge.
  x = start % 16;
  y = start >> 4;
  ct = Screen->ComboT[start];
  inBound = true;
  // Keep moving along the stair until
  while (// We hit the edge of the screen
         inBound &&
         // or we are no longer on the right kind of stair.
         (ct == CT_CROSS || ct == CT_CROSS + StairMode)) {
    x++;
    y += StairMode;
    if (x > 15 || y < 0 || y > 10) {inBound = false;}
    else {ct = Screen->ComboT[y * 16 + x];}}
  x--;
  y -= StairMode;
  // If we fell off the edge, assume there's one more stair outside the screen.
  // so we can move smoothly.
  if (!inBound) {x++;}
  // If this is a positive stair, we've reached the bottom, so extend
  // by another tile.
  if (StairMode == STAIR_POS) {x++;}
  // Set the right edge to where we stopped.
  StairRight = x * 16;
  return true;}
 
void Stair_Update1() {
  StairMount = false;}
// Adjust Link's position if the screen changed.
void LinkStairOnScreenChange() {
  if (ScreenChangeHandled) {return;}
  // If we walked off the top of the screen.
  if (ScreenChangeDir == DIR_UP) {
    if (StairMode == STAIR_POS) {
      LinkX = StairLeft + 16;
      LinkY = 160;
      MountStair(StairLeft, 160, STAIR_POS);}
    else {
      LinkX = StairRight - 16;
      LinkY = 160;
      MountStair(StairRight, 160, STAIR_NEG);}}
  // We walked off the bottom of the screen.
  else if (ScreenChangeDir == DIR_DOWN) {
    if (StairMode == STAIR_NEG) {
      LinkX = StairLeft;
      LinkY = 0;
      MountStair(StairLeft + 16, 0, STAIR_NEG);
      // Move over if there's no stair that we went down when we change screens.
      if (StairMode == STAIR_NONE) {
        LinkX += 16;}}
    else {
      LinkX = StairRight;
      LinkY = 0;
      MountStair(StairRight - 16, 0, STAIR_POS);
      // Move over if there's no stair that we went down when we change screens.
      if (StairMode == STAIR_NONE) {
        LinkX -= 16;}}}
  // 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 && StairLeft < 0) {
    if (StairMode == STAIR_POS) {
      // Here we're coming off the top of the stair, so we'll actually
      // end up in different locations depending on whether or not
      // there's a stair on this screen. Just put Link where he'd end
      // up if there wasn't a stair, and then let the stair code move
      // him to where he's supposed to be later.
      LinkX = 240;
      LinkY = StairY; // A whole lot of stuff cancelled out.
      MountStair(LinkX, LinkY, STAIR_POS);}
    else {
      LinkX = 240;
      LinkY = StairY + 16;
      MountStair(240, StairY + 32, STAIR_NEG);}}
  // 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 && StairRight > 240) {
    if (StairMode == STAIR_NEG) {
      // Here we're coming off the top of the stair, so we'll actually
      // end up in different locations depending on whether or not
      // there's a stair on this screen. Just put Link where he'd end
      // up if there wasn't a stair, and then let the stair code move
      // him to where he's supposed to be later.
      LinkX = 0;
      LinkY = StairY - 240;
      MountStair(LinkX, LinkY, STAIR_NEG);}
    else {
      LinkX = 0;
      LinkY = StairY + 256;
      MountStair(0, StairY + 272, STAIR_POS);}}
  // Otherwise, cancel stairs.
  else {
    LinkX = Link->X;
    LinkY = Link->Y;
    StairMode = STAIR_NONE;
    LinkMode = LINK_MODE_CUSTOM;}
  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;}}
  // Then adjust y positioning.
  int x = Clamp(LinkX, StairLeft, StairRight);
  LinkY = x * StairMode + StairY;}
// 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 ||
      // Link moved past the left edge.
      (LinkX < StairLeft - Cond(StairMode == STAIR_POS, 18, 2)) ||
      // Link moved past the right edge.
      (LinkX > StairRight + Cond(StairMode == STAIR_POS, 2, 18))) {
    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;
  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;}}

 

This should fix all three of those problems. It does look a lot better without the scrolling.

Edited by grayswandir, 05 July 2013 - 02:50 AM.

[Alucard648]

Script fails to compile.

[grayswandir]

Oh, sorry, I forgot the import line at the top. I fixed the above post, or you can just stick the following line it top:

 

import "std.zh"

[Alucard648]

Ok. I have installed new version of the script into the quest. I can confirm first two bugs to be fixed but the scrolling side warp bug is still here. And it becomes much nastier with "No screen scrolling" quest rule turned on. Also same kind of bug occurs when stairs used in conjunction with maze paths.

Also while testing found another bug: Link does not fall and still walks on air if stair combos underneath Link change into another combo via combo cycling or triggering secrets.

As usual new test quest download:

http://www.mediafire...tlevaniav31.qst

[grayswandir]

Code

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 jump speed.
const float LINK_JUMP = -4;
// Link's hop speed.
const float LINK_HOP = -1;
// 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;
//// 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;
// 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 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;
// 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();
        LinkStairFallOff();}
      // And 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();}}}
// 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 > 255 || y < 0 || y > 175) {return false;}
  else {return IsStair((y & 240) + (x >> 4));}}
bool IsStair(int loc) {
  int ct = Screen->ComboT[loc];
  return CT_NEG <= ct && ct <= CT_POS;}
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) {
  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) {
  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) {
  // Non-solid blocks are always empty.
  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;}}
// 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;
  // 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 = LINK_HOP;}
  // Otherwise do the full jump.
  else {LinkVy = LINK_JUMP;}}
// 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);}
  // 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);}
  // We're moving down-left, so check a down-left going stair on the
  // tile below Link.
  if (Link->InputLeft && Link->InputDown && IsNegStair(LinkX, LinkY + 18)) {
    MountStair(LinkX, LinkY + 18, STAIR_NEG);}
  // We're moving down-right, so check a down-right going stair on the
  // tile below Link.
  if (Link->InputRight && Link->InputDown &&
      IsPosStair(LinkX + 15, LinkY + 18)) {
    MountStair(LinkX + 15, LinkY + 18, STAIR_POS);}}
// 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 > 255 || y < 0 || y > 175 || !IsStair(start)) {
    LinkMode = LINK_MODE_CUSTOM;
    StairMode = STAIR_NONE;
    return false;}
  // Change to stair movement mode.
  LinkMode = LINK_MODE_STAIR;
  StairMode = mode;
  // 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;
  //// Find the left edge.
  x = start % 16;
  y = start >> 4;
  int ct = Screen->ComboT[start];
  bool inBound = true;
  // Keep moving along the stair until
  while (// We hit the edge of the screen
         inBound &&
         // or we are no longer on the right kind of stair.
         (ct == CT_CROSS || ct == CT_CROSS + StairMode)) {
    x--;
    y -= StairMode;
    if (x < 0 || y < 0 || y > 10) {inBound = false;}
    else {ct = Screen->ComboT[y * 16 + x];}}
  x++;
  y += StairMode;
  // If we fell off the edge, assume there's one more stair outside the screen.
  // so we can move smoothly.
  if (!inBound) {x--;}
  // If this is a negative stair, we've reached the bottom, so extend
  // by another tile.
  if (StairMode == STAIR_NEG) {x--;}
  // Set the left edge to where we stopped.
  StairLeft = x * 16;
  //// Find the right edge.
  x = start % 16;
  y = start >> 4;
  ct = Screen->ComboT[start];
  inBound = true;
  // Keep moving along the stair until
  while (// We hit the edge of the screen
         inBound &&
         // or we are no longer on the right kind of stair.
         (ct == CT_CROSS || ct == CT_CROSS + StairMode)) {
    x++;
    y += StairMode;
    if (x > 15 || y < 0 || y > 10) {inBound = false;}
    else {ct = Screen->ComboT[y * 16 + x];}}
  x--;
  y -= StairMode;
  // If we fell off the edge, assume there's one more stair outside the screen.
  // so we can move smoothly.
  if (!inBound) {x++;}
  // If this is a positive stair, we've reached the bottom, so extend
  // by another tile.
  if (StairMode == STAIR_POS) {x++;}
  // Set the right edge to where we stopped.
  StairRight = x * 16;
  return true;}
 
void Stair_Update1() {
  StairMount = false;}
// Adjust Link's position if the screen changed.
void LinkStairOnScreenChange() {
  if (ScreenChangeHandled) {return;}
  // If we walked off the top of the screen.
  if (ScreenChangeDir == DIR_UP) {
    if (StairMode == STAIR_POS) {
      LinkX = StairLeft + 16;
      LinkY = 160;
      MountStair(StairLeft, 160, STAIR_POS);}
    else {
      LinkX = StairRight - 16;
      LinkY = 160;
      MountStair(StairRight, 160, STAIR_NEG);}}
  // We walked off the bottom of the screen.
  else if (ScreenChangeDir == DIR_DOWN) {
    if (StairMode == STAIR_NEG) {
      LinkX = StairLeft;
      LinkY = 0;
      MountStair(StairLeft + 16, 0, STAIR_NEG);
      // Move over if there's no stair that we went down when we change screens.
      if (StairMode == STAIR_NONE) {
        LinkX += 16;}}
    else {
      LinkX = StairRight;
      LinkY = 0;
      MountStair(StairRight - 16, 0, STAIR_POS);
      // Move over if there's no stair that we went down when we change screens.
      if (StairMode == STAIR_NONE) {
        LinkX -= 16;}}}
  // 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 && StairLeft < 0) {
    if (StairMode == STAIR_POS) {
      // Here we're coming off the top of the stair, so we'll actually
      // end up in different locations depending on whether or not
      // there's a stair on this screen. Just put Link where he'd end
      // up if there wasn't a stair, and then let the stair code move
      // him to where he's supposed to be later.
      LinkX = 240;
      LinkY = StairY; // A whole lot of stuff cancelled out.
      MountStair(LinkX, LinkY, STAIR_POS);}
    else {
      LinkX = 240;
      LinkY = StairY + 16;
      MountStair(240, StairY + 32, STAIR_NEG);}}
  // 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 && StairRight > 240) {
    if (StairMode == STAIR_NEG) {
      // Here we're coming off the top of the stair, so we'll actually
      // end up in different locations depending on whether or not
      // there's a stair on this screen. Just put Link where he'd end
      // up if there wasn't a stair, and then let the stair code move
      // him to where he's supposed to be later.
      LinkX = 0;
      LinkY = StairY - 240;
      MountStair(LinkX, LinkY, STAIR_NEG);}
    else {
      LinkX = 0;
      LinkY = StairY + 256;
      MountStair(0, StairY + 272, STAIR_POS);}}
  // Otherwise, cancel stairs.
  else {
    LinkX = Link->X;
    LinkY = Link->Y;
    StairMode = STAIR_NONE;
    LinkMode = LINK_MODE_CUSTOM;}
  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;}}
  // Then adjust y positioning.
  int x = Clamp(LinkX, StairLeft, StairRight);
  LinkY = x * StairMode + StairY;}
// 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 ||
      // Link moved past the left edge.
      (LinkX < StairLeft - Cond(StairMode == STAIR_POS, 18, 2)) ||
      // Link moved past the right edge.
      (LinkX > StairRight + Cond(StairMode == STAIR_POS, 2, 18))) {
    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;}}

 

This should fix the side warps - I hadn't considered a side warp to the same screen.

This will work without any effort if you leave scrolling on.

 

If you turn scrolling off, you'll need to place the ScreenChange FFC on any screen which warps to itself. Set the FFC to use Combo 1 (or anything other than 0), the ScreenChange script, and then give it the 'Run Script at Screen Init' and 'Script Restarts When Carried Over' flags. (And maybe turn off FFC carryover altogether? I've never really used that, so I'm a bit fuzzy on some of the details.)

 

Sorry about resorting to using an FFC, but I couldn't think of a better way to detect the screen 'changing' when you're ending up on the same exact screen.

 

 

 

I hadn't planned on the stairs changing. I'll see what I can do about it.

 

[Alucard648]

Scrolling warp bug fix confirmed.

I hadn't planned on the stairs changing. I'll see what I can do about it.

I am waiting for it...

 

P.S. Currently testing stairs that can be jumped on.

 

Update. Another bug.

 

Link can get stuck in the wall if stairs are paced so they end up against column of solid combos.

Here those orange rocky pillars are solid combos.

It`s possible to reproduce this bug in stage 4-1.

 

Update #2: Found another bug.

F6 -> Continue while in midair causes Link`s velocity to be carried over to "Continue Here"`s warp return point which causes wierdness if the point is placed too close to the top of the screen, like in stage 4-1.

http://www.mediafire...u8wxnzrhq7u6im5

Updated quest.

Edited by Alucard648, 11 July 2013 - 12:44 PM.

[Timelord]

Link to footage, please.

Just so that you know that I haven't been ignoring this: I will have to scan through all of my media cards (some twenty or more) to find the demo/LP videos. I had downloaded them about two years back, and I haven't any recollection of the name of the game or the engine, nor do I have them bookmarkd... I tend to download all videos, rather than streaming them, using tools such as IDM. At the time, I expected that it was well-known, and something I would try at some point, and not somethong I would have to search for to rediscover. I stumbled on them while harvesting Akumajou game LPs for a mate so that I could show him the difference between releases, such as the DOS and C64 versions, etc..

I do recall that it seemed, in terms of graphics, to be styled after 'Dracula II: Noroi no Fuuin', but seemed to use 'Akumajuo Dracula' type items and was running on Windows (version unknown, but I suspect XP). It was clearly not a ROM-hack, although IMHO, the best of those is 'Chorus of Mysteries', as the ASM changes are especially fantastic, and it was a serious challenge without being stupidly unfair. (I particularly liked the laurel item.)

When I do find the videos, I will try to find you links, but if they aren't on-line at this point, I will upload them to my server for you.

[Alucard648]

I do recall that it seemed, in terms of graphics, to be styled after 'Dracula II: Noroi no Fuuin', but seemed to use 'Akumajuo Dracula' type items and was running on Windows (version unknown, but I suspect XP).

Aren`t they named "Castlevania Quest" and "Dracula`s Shadow"?

http://www.youtube.c...h?v=O3LM_NWmZNo

http://www.youtube.c...h?v=rCyNXwCVVA0

 

 

On topic: looks like the script uses hardcoded constant for Link`s jump height. I am planning to implement a late-game item called Roc`s Wing that boosts Link`s jump height and suggesting to use "height muptiplier" varibale in Roc`s feather item data. 

[Timelord]

I will have to watch those videos to confirm if either are right; my Internet connection via my mobile isn't terribly fast at present, so it will take a while to download them.
 
I have been discussing this quest on its Development Page... The latest changes to the Demo Database and Quest Projects area (which are probably the result of some of my requests to LinkTheMaster regarding being able to update demos) made finding this very difficult again...

The bug in stairs ending on a solid combo may still exist, as it happened to me in the game, however jumping out of the wall tended to work. I would advise that this is less of a bug in the stairs, and more of an issue with combo placement... If you put a walkable combo on a screen and a solid combo on the screen adjacent to it, the same problem occurs; it's a Zelda quirk that you can't bypass.

One of the quirks that bothered me deals with getting on and off the stairs. I think that you should press up and down to climb the stairs, and right and left should exit; when climbing up, on reaching a platform, I often find myself pressing left and going back down, or right and going back up. This of course is critical for the entry and exit combos, and less important for the rest of the staircase unless you want to be able to accidentally fall to your death.

In CV, you were latched to the staircase until your reached the top or bottom, and exiting or entering was smooth. I found that while it isn't terribly hard to enter a staircase, I often has cheap hits exiting because I was continually goung up and down, when pressing left or right to get off the staircase.

What is the most current version of this script?

Edited by ZoriaRPG, 19 July 2013 - 10:59 PM.

[Alucard648]

What is the most current version of this script?

The one which is installed in the current demo.

[grayswandir]

So the code finally got too long to post.

 

Sorry for the delay. I've been quite busy lately and adding in the disappearing stairs was quite difficult - I had to try a couple different approaches before I found one that worked.

 

I added in an OnContinue global script that should fix the continue bug, but haven't tested it. Let me know if it doesn't work.

 

I noticed that this version has a small bug, where you can't enter stairs directly below you, you have to be at least a pixel over.

 

In the next day or two I'll post a version with a script for the Roc's Wing, and hopefully a fix for that bug. It should be easy enough to get at.

 

Now to go catch up on everything else I missed...