38 replies to this topic

[Alucard648]

I had a lot of fun with sideview areas in ZC quests such as A New Dawn, The Journey of Link or Swansong Genesis. Too bad the interesting sideview areas are very rare occurence in quests.

So i have decided to build my own one.

One of my deepest dreams is a Simon`s Quest-styled Metroidvania sidescroller quest similar to a NES game Battle of Olympus. I have watched a lot of ZC script showcase videos and really amazed how scripts can do wonders such as Indiana Jones-styled hookshot swinging, 3D raycasting and more!

Once ZC 2.5 Stable has been relased such quest become possible to be created. I have searched PureZC forums for a CV stairs script and found nothing! So why I am placing this script request.

 

The following images are nothing more than mockups constructed and screenshotted with ZQuest.

Link here is noting more than FFC. Bombs sould be grabbable easily.

These crossing staircases are inspired by Castlevania Adventure Rebirth and CV1 hack named Stairs of Doom. Link Should neither be able to get stuck in the wall at top right corner nor fall off ledge at the bottom of both staircases right after exiting stairs.

These golden stairs should act like in 16-bit Castlevania games unlike the red & orange stairs that act like in 8-bit CV games so Link can jump on and off golden stairs freely.

Link shold be able to grab the Triforce piece after killing this Peahat. The side warp here is a classical bottomless pit which is instantly lethal to Link if he falls down it.

 

I am hoping it`s possible for things such as this to become reality in ZC...

Edited by Alucard648, 03 June 2013 - 02:50 PM.

[Timelord]

I think that you are expecting more out of the engine than it wants to give here... For the record, there is a Castlevania quest maker out there for Windows.

You can make the stairs usable by jumping, but I don;t see how you would make Link climb them automatically, without changing core game dynamics.

[MoscowModder]

Well, they possibly could be scripted, but stuff like intersecting staircases would make it really, really complicated. Why don't you want to use a Castlevania engine?

[Alucard648]

Well, they possibly could be scripted, but stuff like intersecting staircases would make it really, really complicated.

 

Did you know that in NES Castlevania games player cannot jump onto the middle of staircase? This is because in level data staircase is nothing more than a pair of special markers which are placed at the both ends of the set of stairs, rest of which is treated as non-solid decoration. So if stair markers are placed properly, intersecting stairs should function without any bugs. This quirk is used to the max in my NES CV1 ROM-hack named Stairs of Doom which can be downloaded here:

http://www.romhacking.net/hacks/996/

This hack is done in "Stake the Castlevania editor" with little to no ASM knowledge.

If you have trouble with emulation you can watch a "Let`s play" video which is here:

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

It covers only level 1 but for this discussion it`s more than enough. As shown in this video crossing stairs are fully functional without any bugs or ability to "break" level design. The shortcut at the end of 1-1 is a predesignated one.

 

In 16-bit games such as Super Castlevania 4 stairs are handled by game code in a completely different manner. Here each stair tile/combo has a special collision type which allows player to jump on and off stairs freely. Which is abused by speed-runners to take many shortcuts especially at room transitions. And obviously crossing stairs are almost out of possibility...

 

Castlevania: Adventure Rebirth uses NES stair mechanics hence why there are intersecting staircases appear and work properly.

 

As for scripting, if possible, you should use "blank" combo flags (General Purpose X) for NES-syled staircases placement and "blank" combo types (General Purpose X) for 16-bit-syled ones. This would make it possible to do bizarre things with staircases via secrets. Enemy/stairs interaction is not needed.

 

Good Luck! And feel free to submit script to database once it`s completed, tested, and proven to be bug-free...

Why don't you want to use a Castlevania engine?

 

I have yet to find one. Kotai`s Castlevania Online is a total mess and Game Maker games lag horribly on my ancient PC.

 

P.S. I have already created a test quest so I can test any related scriptwork and provide constructive criticism properly.

[Timelord]

I never examined why staircases in Castlevania/Ajumajou Dracula were solid only when you performed certain actions, but not solid otherwise. That does make sense, although it can make the game damned irritating at times, particularly in one unfair spot where you can easily walk to the right of the stairs, and turn left and fall to nowhere. It makes sense, now that you describe how the mechanics work...

I do wonder why the X68000 version--by far the best IMHO--did not use the SNES/SFC style staircases and weapon controls (which make ghat game superior in terms of control). I had every version of it on my multi arcade at one time: A mate of mine is a huge Castlevania fan, but a horrible (stubborn) player. He <em>hates to make good use of sub-weapons</em>, but he went mad trying all of the versions of his favourite game, including that terrible arcade-only release.

He was not keen on the MSX version, which i can understand, as it has such a different feel and is nearly impossible to play without a cheat code, and then he spent many days playing the X68K release and it aced his feelings on every other version as well.

I have seen dome demo footage of CV PC engines, and they seem good from the perspective of watching an LP. What is wrong with them that makes them a bad choice for you?

Edited by ZoriaRPG, 25 June 2013 - 11:47 AM.

[Alucard648]

I never examined why staircases in Castlevania/Ajumajou Dracula were solid only when you performed certain actions, but not solid otherwise. That does make sense, although it can make the game damned irritating at times, particularly in one unfair spot where you can easily walk to the right of the stairs, and turn left and fall to nowhere. It makes sense, now that you describe how the mechanics work...

I have described stair mechanics just to help someone who wants to take on this scripting challenge. As for fairness/unfairness this is why I have initially requested for both stairs mechanics to be scripted. Each mechanic has it`s pro`s and con`s. NES stair mechanic allows more creativity in puzzles and mazes(intersecting stairs!) while SNES one takes care on certain frustrating factors like the one you have explained as well as allowing things such as detached staircases for bizarre platforming areas.

 

I have seen dome demo footage of CV PC engines, and they seem good from the perspective of watching an LP. What is wrong with them that makes them a bad choice for you?

 

Link to footage, please.

[grayswandir]

Here's a first attempt at (something like) the flag style. Helping with that Jump script the other day made me want to do more sideview stuff.

 

This builds off of that jump script. You can't use the roc's feather directly here (except for basic jumping), and must use the L/R buttons to jump.

To start climbing stairs, you walk onto them. You can jump off of them any time you want - so long as you don't pass the left/right edge of the staircase that you're on, you land back on that same staircase.

If you hold down while you jump, you instead jump directly off of the staircase.

 

 

 

I can't do the second example you gave. You can cross stairs just fine, but there's no way to put a stair through a solid block like that.

 

Code

import "std.zh"
const int CF_STAIR_UL = 98;
const int CF_STAIR_UR = 99;
const int CF_STAIR_DL = 100;
const int CF_STAIR_DR = 101;
 
// Not on a stair.
const int STAIR_OFF = 0;
// On an up-right down-left stair.
const int STAIR_NEG = 1;
// On an up-left down-right stair.
const int STAIR_POS = -1;
 
// If Link is on a staircase, and what kind.
int StairState = STAIR_OFF;
// If Link was standing directly on the staircase last frame.
bool StairDirectLast = false;
 
global script Active {
  void run() {
    // The starting (left-most) location of the staircase.
    int stairStartLoc = -1;
    // The ending (right-most) location of the staircase.
    int stairEndLoc = -1;
    // Link's maximum Y.
    int stairMaxY = -1;
    // Link's last x position.
    int linkLastX = Link->X;
 
    while (true) {
      if (IsSideview()) {
 
        // We're not on a stair currently.
        if (StairState == STAIR_OFF) {
          // Here we check if we moved into a staircase.
          int loc;
 
          // First, we have to be walking.
          if (Link->Action == LA_WALKING || true) {
            // We're moving right.
            if (Link->Dir == DIR_RIGHT) {
              // Get the combo at Link's right edge.
              loc = ComboAt(Link->X + 15, Link->Y + 15);
              // See if we hit an up-right stair on its left edge.
              if (ComboFI(loc, CF_STAIR_UR) &&
                  Link->X % 16 <= 3) {
                StairState = STAIR_NEG;
                stairStartLoc = loc;
                //// Find the end point.
                stairEndLoc = stairStartLoc;
                while (// Break out of looking if we hit the
                       // right or top side of the screen.
                       (stairEndLoc % 16 != 15 &&
                        stairEndLoc > 15)
                       // Also break out if we find the end.
                       && !ComboFI(stairEndLoc, CF_STAIR_DL)) {
                  // Move up 1 right 1.
                  stairEndLoc -= 15;}}
 
              // Get the combo at Link's left edge, below him.
              loc = ComboAt(Link->X, Link->Y + 16);
              // See if we hit a down-right stair on its right edge.
              if (ComboFI(loc, CF_STAIR_DR)) {
                StairState = STAIR_POS;
                stairStartLoc = loc;
                // Force to walk down the steps, not fall.
                StairDirectLast = true;
                //// Find the end point.
                stairEndLoc = stairStartLoc;
                while (// Break out of looking if we hit the
                       // right or bottom side of the screen.
                       (stairEndLoc % 16 != 15 &&
                        stairEndLoc < 160)
                       // Also break out if we find the end.
                       && !ComboFI(stairEndLoc, CF_STAIR_UL)) {
                  // Move down 1 right 1.
                  stairEndLoc += 17;}}}
 
            // We're moving left.
            if (Link->Dir == DIR_LEFT && Link->X % 16 >= 12) {
 
              // Get the combo at Link's left edge.
              loc = ComboAt(Link->X, Link->Y + 15);
              // See if we hit an up-left stair on its right edge.
              if (ComboFI(loc, CF_STAIR_UL) &&
                  Link->X % 16 >= 12) {
                StairState = STAIR_POS;
                stairEndLoc = loc;
                //// Find the start point.
                stairStartLoc = stairEndLoc;
                while (// Break out of looking if we hit the
                       // left or top side of the screen.
                       (stairStartLoc % 16 != 0 &&
                        stairStartLoc > 15)
                       // Also break out if we find the start.
                       && !ComboFI(stairStartLoc, CF_STAIR_DR)) {
                  // Move up 1 left 1.
                  stairStartLoc -= 17;}}
 
              // Get the combo at Link's right edge, below him.
              loc = ComboAt(Link->X + 15, Link->Y + 16);
              // See if we hit a down-left stair.
              if (ComboFI(loc, CF_STAIR_DL)) {
                StairState = STAIR_NEG;
                stairEndLoc = loc;
                // Force to walk down the steps, not fall.
                StairDirectLast = true;
                //// Find the start point.
                stairStartLoc = stairEndLoc;
                while (// Break out of looking if we hit the
                       // left or bottom side of the screen.
                       (stairStartLoc % 16 != 0 &&
                        stairStartLoc < 160)
                       // Also break out if we find the start.
                       && !ComboFI(stairStartLoc, CF_STAIR_UR)) {
                  // Move down 1 left 1.
                  stairStartLoc += 15;}}}}}
 
        // We're on a staircase. See if we've moved off of it.
        else if ((StairState == STAIR_NEG &&
                  (Link->X < ComboX(stairStartLoc) - 18 ||
                   Link->X > ComboX(stairEndLoc) + 2)) ||
                 (StairState == STAIR_POS &&
                  (Link->X < ComboX(stairStartLoc) - 2 ||
                   Link->X > ComboX(stairEndLoc) + 18))) {
          StairState = STAIR_OFF;}
 
        // We're on a negative (up-right down-left) staircase.
        if (StairState == STAIR_NEG) {
          if (Link->X < ComboX(stairStartLoc) - 16) {
            stairMaxY = ComboY(stairStartLoc);}
          else if (Link->X > ComboX(stairEndLoc)) {
            stairMaxY = ComboY(stairEndLoc) - 16;}
          else {
            stairMaxY = ComboY(stairStartLoc) +
              ComboX(stairStartLoc) - Link->X - 16;}}
 
        // We're on a positive (down-right up-left) staircase.
        else if (StairState == STAIR_POS) {
          if (Link->X < ComboX(stairStartLoc)) {
            stairMaxY = ComboY(stairStartLoc) - 16;}
          else if (Link->X > ComboX(stairEndLoc) + 16) {
            stairMaxY = ComboY(stairEndLoc);}
          else {
            stairMaxY = ComboY(stairStartLoc) -
              ComboX(stairStartLoc) + Link->X - 16;}}}
 
      // Not in sideview, so cancel being on a stair.
      else {
        StairState = STAIR_OFF;}
 
      // If Link was directly on the stairs last turn, and is falling,
      // that means he was walking down the stairs. So move him to the
      // right y position.
      if (StairDirectLast && Link->Jump <= 0 &&
          ((StairState == STAIR_POS && linkLastX < Link->X) ||
           (StairState == STAIR_NEG && linkLastX > Link->X))) {
        Link->Y = stairMaxY;
        Link->Jump = 0;}
 
      // Update Loop variables.
      linkLastX = Link->X;
      StairDirectLast = false;
 
      // Don't let Link fall below the staircase.
      if (StairState != STAIR_OFF) {
        if (Link->Y >= stairMaxY) {
          StairDirectLast = true;
          Link->Y = stairMaxY;
          if (Link->Jump < 0) {
            Link->Jump = 0;}}}
 
      Jump();
      Waitdraw();
 
      // Don't let Link fall below the staircase.
      // Repeated because I think that Waitdraw messes with some
      // of these variables.
      if (StairState != STAIR_OFF) {
        if (Link->Y >= stairMaxY) {
          StairDirectLast = true;
          Link->Y = stairMaxY;
          if (Link->Jump < 0) {
            Link->Jump = 0;}}}
      Waitframe();}}}
 
// If Link can currently Jump.
bool IsSideviewLinkOnGroundOrStair() {
  return
    // Is a sideview screen.
    IsSideview() &&
    // If we're standing on a solid tile.
    (Screen->isSolid(Link->X + 04, Link->Y + 16) ||
     Screen->isSolid(Link->X + 12, Link->Y + 16) ||
     (StairState != STAIR_OFF && StairDirectLast));}
 
 
void Jump() {
  if (// If the L or R button is pressed.
      (Link->PressL || Link->PressR) &&
      // and Link is on the ground in a sideview room.
      IsSideviewLinkOnGroundOrStair() &&
      // and Link has the roc's feather.
      Link->Item[I_ROCSFEATHER] ){
 
    // Then do the jump.
    Link->Jump = 3.2; // Set to whatever you want
    Game->PlaySound(SFX_JUMP);
    // Take Link off of the staircase if he's holding down.
    if (Link->InputDown && StairState != STAIR_OFF) {
      StairState = STAIR_OFF;
      Link->Jump = 1;}}
 
  // Cancel item switching if we're in a sideview room.
  if (IsSideview()) {
    Link->PressL = false;
    Link->InputL = false;
    Link->PressR = false;
    Link->InputR = false;}}

[Alucard648]

 

Here's a first attempt at (something like) the flag style. Helping with that Jump script the other day made me want to do more sideview stuff.

Off to a great start, grayswandir! The script compiles properly and works well... Almost. Here are few bugs and suggestions for next version.

 1. Bug. If Link gets hurt while on stairs he will have wierd falling animation. This sometimes causes Link to get stuck on the top end of a staircase.

Link should get knocked off stairs completely on damage.

2. Bug. Switching screens while on stairs (such as going from one screen to adjacent one or going trough side warp especially scrolling side warp) causes bizarre glitches ranging from falling off stairs to screen flipping.

3. Suggestion for entering stairs. As for now as soon as Link hits flagged combo in the direction of stairs (right for flags 99 &101 and left for 98 &100), he starts climbing stairs immediately. While this can prevent falling trough stairs like ZoriaRPG mentioned here, this can be annoying because jumping is required to avoid stair climbing (especially annoying in narrow passages). So unless combo under stairs is not solid (for flags 98 & 99 it`s a combo under flagged stair, for flags 100 & 101 it`s flagged combo itself) player should be needed to press UP for flags 98 & 99 or DOWN for flags 100 &101 to start climbing stairs just like in original CV games.

4.Proposal workaround for "no stairs trough solids" limitation. How about a combo type that changes to the next combo when Link is on stairs and reverts back as soon as Link exits stairs? This could be used to temporally change certain solid combos into non-solid ones and allow Link to go through them without getting stuck.

5. Bug. Link can`t cast spells like Farore`s Winds, Din`s Fire or Nayru`s Love while on stairs.

[TheLegend_njf]

Ain't the stairs one of the most annoying thing about Castlevania 3? It was overused to create unnecessary and unfair challenges which should not been done the way it did, I believe that's when the stair mechanic started to lose popularity in the Castlevania series, even though they appeared in Super Castlevania 4, they slowly lost their significance after that.

My question is, why would you want to add something like this, it only exists because a programmer wanted to see if they can successfully make a sprite walk up some steps, which later became a series staple, but than eventually got scrapped.

Either way, this can be easily done with multi directional raft. If a raft can be scripted to move diagonally, it would be as simple as removing the raft graphics (because Link's feet still moves). However, you would not be able to make Link stop walking.

That's the closes ZC resemblance I know to what you are describing.

[grayswandir]

Yeah, I expected a whole ton of bugs.

 

I'm not really sure when I'll be able to get a new version out. Sometime in the next couple of days, I guess?

 

1. Yeah, I'm not really sure how to avoid that weird animation. As far as I can tell there's no way to tell if he has that animation in the code. Falling off when getting hit should be pretty easy, though. And getting stuck - I'll have to play around with it.

 

2. I didn't put in any support for switching screens, but I don't see any reason why it couldn't be done.

 

3. This is trivial to fix. You can actually also avoid entering stairs right now - if you're facing up or down while walking past a stair, you don't get on.

 

4. I don't like the idea of changing combos around - what if an enemy is standing on those combos. Speaking of that, do you know if enemies can walk on non-solid no-ground-enemy flags?

 

5. I don't think it's possible to tell the engine that 'Link should act like he's on the ground right now'. That's why I forced the use of the scripted jump - the standard one wouldn't let Link jump on the stairs because he's not 'on the ground'. So any items that don't work in the air are going to be flat-out unusable unless you fake them with a script like I did with the jump.

[Alucard648]

3. This is trivial to fix. You can actually also avoid entering stairs right now - if you're facing up or down while walking past a stair, you don't get on.

4. I don't like the idea of changing combos around - what if an enemy is standing on those combos. Speaking of that, do you know if enemies can walk on non-solid no-ground-enemy flags?

3. I have already discovered this while testing the script.
4. Damn! I have recently tested this and zombies fall through both "no enemy" flags (96 & 97)! I am hoping flags can be re-scripted to work properly. Otherwise I have to work around this by crafty placement of enemy placement and "no enemy" flags.

 

EDIT: Hoookshot related bugs.

1. If Link hookshoots trough stair flag he will be dragged upstairs/downstairs away from hookshot grab combo.

2. The same thing occurs when Link uses hookshot while on stairs.

Edited by Alucard648, 26 June 2013 - 08:16 PM.

[grayswandir]

I tried a completely different approach for this one.

 

It does let you walk through solids while on a staircase. I also added in soft (one-way) platforms that you can jump up through, and you can fall through if you're holding down.

 

Just the L key to jump on this one - no R.

 

You do need to hold up/down to get on a staircase now.

 

Still no moving between screens on staircases. I still think it's doable, I just haven't tried yet.

 

I still can't figure out a way around that floating animation - For this one I just changed his jump animation to his walking one.

 

The hookshot graphics will sometimes bug out and I have no idea why.

 

More 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;
//// 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) {
      ScreenChange_Update();
      LinkUpdate();
      ActionJump();
      //EnemyUpdate();
      InputsUpdate();
      Waitdraw();
      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 Link is in the frozen action, it probably means he is using
  // the hookshot, so Update position based on where Link moved.
  if (Link->Action == LA_FROZEN ||
      Link->Action == LA_SCROLLING ||
      Link->Action == LA_GOTHURTLAND ||
      ScreenChanged) {
    LinkX = Link->X;
    LinkY = Link->Y;
    LinkVy = 0;}
  // 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;
  // If we're on a stair.
  if (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;}
      // Otherwise move according to the stair.
      if (hasStair) {
        int x = Clamp(LinkX, LinkStairLeft, LinkStairRight);
        LinkY = x * LinkStair + LinkStairY;}}}
  // Not on a stair, check regular platforms
  if (LinkStair == STAIR_NONE) {
    // 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 (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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) - ComboX(loc) - 16;}}
    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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) + ComboX(loc) - 16;}}
    // 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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) + ComboX(loc) - 16;}}
    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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) - ComboX(loc) - 16;}}}
  // 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() {
  if (Link->Action == LA_FROZEN) {return;}
  // Move Link to new location.
  // If we're frozen, it probably means the hookshot is being used.
  if (Link->Action != LA_FROZEN &&
      Link->Action != LA_SCROLLING &&
      Link->Action != LA_GOTHURTLAND &&
      !ScreenChanged) {
    Link->X = Round(LinkX);
    Link->Y = Round(LinkY);}
  // Set direction.
  if (Link->Action != LA_FROZEN) {
    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;}}}
// 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;
  if (Link->Action == LA_FROZEN) {return;}
  Link->InputL = false;
  Link->PressL = false;
  // 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 StairFindEdges(int start) {
  // 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;
  // 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;}
// 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;}

[Alucard648]

 

I tried a completely different approach for this one.

This variant has even more bugs than previous.

1. Goofy animation while climbing stairs.

2. As soon as Link enters a screen from bottom he will immediately falls to previous one rendering Link unable to get here.

3. Link can get from one staircase to another via intersection. I am suggesting this would be impossible to do.

4. Warps are royally screwed up to the point when warp return points are completely ignored.

On the first screenshot Link gets "stunned" until get hit by skeletons after going trough castle entrance tile warp.

Also link is dropped in wrong place (should be on the left side of the screen). Stage name is "Haunted Halls".

On the second screenshot Link gets trapped in the wall right after unlocking the end-of-sub-stage door and going trough side warp beyond it. Screenie is captured right during scrolling between adjacent screens.

 

Haven`t tested this throughly but such serious bugs are probably hard to fix...

Edited by Alucard648, 28 June 2013 - 09:38 AM.

[grayswandir]

Update. This should fix some of the bugs.

 

Could you send me a copy of your quest you're working on? It would help if I had the actual errors to work with, instead of going off of your description.

 

Haven`t tested this throughly but such serious bugs are probably hard to fix...

Why would the seriousness of the bug have anything to do with how hard it is to fix?

 

 

 

The reason there were so many bugs this time isn't necessarily because the approach is flawed. It's just that, to get Link to move through solid tiles, I ended up manually controlling his movement - but this leaves a lot more edge cases open that I didn't consider at first.

 

 

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;
//// 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) {
      ScreenChange_Update();
      LinkUpdate();
      ActionJump();
      //EnemyUpdate();
      InputsUpdate();
      Waitdraw();
      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 Link is in the frozen action, it probably means he is using
  // the hookshot, so Update position based on where Link moved.
  if (Link->Action == LA_FROZEN ||
      Link->Action == LA_SCROLLING ||
      Link->Action == LA_GOTHURTLAND ||
      ScreenChanged ||
      Abs(LinkX - Link->X) > 8 ||
      Abs(LinkY - Link->Y) > 8) {
    LinkX = Link->X;
    LinkY = Link->Y;
    LinkVy = 0;}
  // 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;
  // If we're on a stair.
  if (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;}
      // Otherwise move according to the stair.
      if (hasStair) {
        int x = Clamp(LinkX, LinkStairLeft, LinkStairRight);
        LinkY = x * LinkStair + LinkStairY;}}}
  // Not on a stair, check regular platforms
  if (LinkStair == STAIR_NONE) {
    // 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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) - ComboX(loc) - 16;}}
    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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) + ComboX(loc) - 16;}}
    // 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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) + ComboX(loc) - 16;}}
    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;
        StairFindEdges(loc);
        LinkStairY = ComboY(loc) - ComboX(loc) - 16;}}}
  // 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() {
  if (Link->Action == LA_FROZEN) {return;}
  // Move Link to new location.
  // If we're frozen, it probably means the hookshot is being used.
  if (Link->Action != LA_FROZEN &&
      Link->Action != LA_SCROLLING &&
      Link->Action != LA_GOTHURTLAND &&
      !ScreenChanged) {
    Link->X = Round(LinkX);
    Link->Y = Round(LinkY);}
  // If we're on stairs, set the jump to 0.
  if (LinkStair != STAIR_NONE) {
    Link->Jump = 0;
    Link->Z = 0;}
  // Set direction.
  if (Link->Action != LA_FROZEN) {
    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;}}}
// 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;
  if (Link->Action == LA_FROZEN) {return;}
  Link->InputL = false;
  Link->PressL = false;
  // 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 StairFindEdges(int start) {
  // 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;
  // 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;}
// 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;}

[Alucard648]

Could you send me a copy of your quest you're working on? It would help if I had the actual errors to work with, instead of going off of your description.

Here is the quest i am working on. Currently it`s a 2 stages demo.

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

 

As for update the goofy stair climbing animation is gone.

But all other bugs are still here.

Edited by Alucard648, 30 June 2013 - 06:44 AM.