From 3ca7b09012d10fd19393d237ff3d93e3abe9c22c Mon Sep 17 00:00:00 2001 From: Misa Date: Tue, 15 Jun 2021 19:18:58 -0700 Subject: [PATCH] Fix regression: quick stopping changing drawframe This fixes a regression that desyncs my Nova TAS after re-removing the 1-frame input delay. Quick stopping is simply holding left/right but for less than 5 frames. Viridian doesn't decelerate when you let go and they immediately stop in place. (The code calls this tapping, but "quick stopping" is a better name because you can immediately counter-strafe to stop yourself from decelrating in the first place, and that works because of this same code.) So, the sequence of events in 2.2 and previous looks like this: - gameinput() - If quick stopping, set vx to 0 - gamerender() - Change drawframe depending on vx - gamelogic() - Use drawframe for collision (whyyyyyyyyyyyyyyyyyyyyyyyyyyy) And now (ignoring the intermediate period where the whole loop order was wrong), the sequence of events in 2.3 looks like this: - gamerenderfixed() - Change drawframe depending on vx - gamerender() - gameinput() - If quick stopping, set vx to 0 - gamelogic() - Use drawframe for collision (my mind has become numb to pain) So, this means that all the player movement stuff is completely the same. Except their drawframe is going to be different. Unfortunately, I had overlooked that gameinput() sets vx and that animateentities() (in gamerenderfixed()) checks vx. Although, to be fair, it's a pretty dumb decision to make collision detection be based on the actual sprites' pixels themselves, instead of a hitbox, in the first place, so you'd expect THAT to be the end of the dumb parade. Or maybe you shouldn't, I don't know. So, what's the solution? What I've done here is added duplicates of framedelay, drawframe, and walkingframe, for collision use only. They get updated in gamelogic(), after gameinput(), which is after when vx could be set to 0. I've kept the original framedelay, drawframe, and walkingframe around, to keep the same visuals as closely as possible. However, due to the removal of the input delay, whenever you quick stop, your sprite will be wrong for just 1 frame - because when you let go of the direction key, the game will set your vx to 0 and the logical drawframe will update to reflect that, but the previous frame cannot know in advance that you'll release the key on the next frame, and so the visual drawframe will assume that you keep holding the key. Whereas in 2.2 and below, when you release a direction key, the player's position will only update to reflect that on the next frame, but the current frame can immediately recognize that and update the drawframe now, instead of retconning it later. Basically the visual drawframe assumes that you keep holding the key, and if you don't, then it takes on the value of the collision drawframe anyway, so it's okay. And it's only visual, anyway - the collision drawframe of the next frame (when you release the key) will be the same as the drawframe of the frame you release the key in 2.2 and below. But I really don't care to try and fix this for if you re-enable the input delay because it's minor and it'd be more complicated. --- desktop_version/src/Ent.cpp | 3 ++ desktop_version/src/Ent.h | 1 + desktop_version/src/Entity.cpp | 98 +++++++++++++++++++++++++++++++++- desktop_version/src/Entity.h | 2 + desktop_version/src/Logic.cpp | 2 + 5 files changed, 105 insertions(+), 1 deletion(-) diff --git a/desktop_version/src/Ent.cpp b/desktop_version/src/Ent.cpp index a8ef5588..073dbc64 100644 --- a/desktop_version/src/Ent.cpp +++ b/desktop_version/src/Ent.cpp @@ -46,6 +46,9 @@ void entclass::clear(void) gravity = false; onground = 0; onroof = 0; + collisionframedelay = 0; + collisiondrawframe = 0; + collisionwalkingframe = 0; visualonground = 0; visualonroof = 0; diff --git a/desktop_version/src/Ent.h b/desktop_version/src/Ent.h index b1a58774..046fbd68 100644 --- a/desktop_version/src/Ent.h +++ b/desktop_version/src/Ent.h @@ -49,6 +49,7 @@ public: int onground, onroof; //Animation int framedelay, drawframe, walkingframe, dir, actionframe; + int collisionframedelay, collisiondrawframe, collisionwalkingframe; int visualonground, visualonroof; int yp;int xp; diff --git a/desktop_version/src/Entity.cpp b/desktop_version/src/Entity.cpp index fbefd0a4..c58e90d3 100644 --- a/desktop_version/src/Entity.cpp +++ b/desktop_version/src/Entity.cpp @@ -3748,6 +3748,102 @@ void entityclass::animateentities( int _i ) } } +void entityclass::animatehumanoidcollision(const int i) +{ + /* For some awful reason, drawframe is used for actual collision. + * And removing the input delay changes collision drawframe + * because vx is checked in animateentities(). + * So we need to separate the collision drawframe from the visual drawframe + * and update it separately in gamelogic. + * Hence this function. + */ + entclass* entity; + + if (!INBOUNDS_VEC(i, entities)) + { + puts("animatehumanoidcollision() out-of-bounds!"); + return; + } + + entity = &entities[i]; + + if (!entity->ishumanoid()) + { + return; + } + + if (entity->statedelay > 0) + { + return; + } + + --entity->collisionframedelay; + + if (entity->dir == 1) + { + entity->collisiondrawframe = entity->tile; + } + else + { + entity->collisiondrawframe = entity->tile + 3; + } + + if (entity->visualonground > 0 || entity->visualonroof > 0) + { + if (entity->vx > 0.0f || entity->vx < -0.0f) + { + /* Walking */ + if (entity->collisionframedelay <= 1) + { + entity->collisionframedelay = 4; + ++entity->collisionwalkingframe; + } + + if (entity->collisionwalkingframe >= 2) + { + entity->collisionwalkingframe = 0; + } + + entity->collisiondrawframe += entity->collisionwalkingframe + 1; + } + + if (entity->visualonroof > 0) + { + entity->collisiondrawframe += 6; + } + } + else + { + ++entity->collisiondrawframe; + + if (entity->type == 0 && game.gravitycontrol == 1) + { + entity->collisiondrawframe += 6; + } + } + + /* deathseq shouldn't matter, but handling it anyway just in case */ + if (game.deathseq > -1) + { + entity->collisiondrawframe = 13; + + if (entity->dir == 1) + { + entity->collisiondrawframe = 12; + } + + if ((entity->type == 0 && game.gravitycontrol == 1) + || (entity->type != 0 && entity->rule == 7)) + { + entity->collisiondrawframe += 2; + } + } + + entity->framedelay = entity->collisionframedelay; + entity->drawframe = entity->collisiondrawframe; + entity->walkingframe = entity->collisionwalkingframe; +} + int entityclass::getcompanion(void) { //Returns the index of the companion with rule t @@ -4653,7 +4749,7 @@ void entityclass::collisioncheck(int i, int j, bool scm /*= false*/) point colpoint2; colpoint2.x = entities[j].xp; colpoint2.y = entities[j].yp; - int drawframe1 = entities[i].drawframe; + int drawframe1 = entities[i].collisiondrawframe; int drawframe2 = entities[j].drawframe; std::vector& spritesvec = graphics.flipmode ? graphics.flipsprites : graphics.sprites; if (INBOUNDS_VEC(drawframe1, spritesvec) && INBOUNDS_VEC(drawframe2, spritesvec) diff --git a/desktop_version/src/Entity.h b/desktop_version/src/Entity.h index 8a567a4d..309e02a0 100644 --- a/desktop_version/src/Entity.h +++ b/desktop_version/src/Entity.h @@ -88,6 +88,8 @@ public: void animateentities(int i); + void animatehumanoidcollision(const int i); + int getcompanion(void); int getplayer(void); diff --git a/desktop_version/src/Logic.cpp b/desktop_version/src/Logic.cpp index 7f1fb3b4..4b492e66 100644 --- a/desktop_version/src/Logic.cpp +++ b/desktop_version/src/Logic.cpp @@ -152,6 +152,8 @@ void gamelogic(void) { --obj.entities[i].onroof; } + + obj.animatehumanoidcollision(i); } }