Strange behavior of a sprite

Question

I am coding a simple game with roguelike in C ++ using the SDL library, and I am having problems moving my character on the screen. Every time I need to render a frame, I update the position of the sprite using the update () function, which does nothing if the player stands still. To issue a move command and thus start the animation, I use the step () function, which is called only once for each movement of the player from one tile to another. Having received the “up” command, the game behaves perfectly, and the character smoothly moves in one second to a new position. However, when the “down” command is given, it moves about half the speed, and, obviously, after one second it instantly “teleports” to the final position with a sudden flicker. The code for the movement is basically identical, but for the fact that in one case the delta movement is summed with the y-position, in the other case it is subtracted. Perhaps the fact that the position is an integer and the delta is double causes problems? Does sum and similarity do things differently (maybe a different rounding)? Here is the relevant code (sorry for the length):

void Player::step(Player::Direction dir) { if(m_status != STANDING) // no animation while standing return; switch(dir) { case UP: if(m_currMap->tileAt(m_xPos, m_yPos - m_currMap->tileHeight())->m_type == Tile::FLOOR) { // if next tile is not a wall, set up animation m_status = WALKING_UP; m_yDelta = m_currMap->tileHeight(); // sprite have to move by a tile m_yVel = m_currMap->tileHeight() / 1000.0f; // in one second m_yNext = m_yPos - m_currMap->tileHeight(); // store final destination } break; case DOWN: if(m_currMap->tileAt(m_xPos, m_yPos + m_currMap->tileHeight())->m_type == Tile::FLOOR) { m_status = WALKING_DOWN; m_yDelta = m_currMap->tileHeight(); m_yVel = m_currMap->tileHeight() / 1000.0f; m_yNext = m_yPos + m_currMap->tileHeight(); } break; //... default: break; } m_animTimer = SDL_GetTicks(); } void Player::update() { m_animTimer = SDL_GetTicks() - m_animTimer; // get the ms passed since last update switch(m_status) { case WALKING_UP: m_yPos -= m_yVel * m_animTimer; // update position m_yDelta -= m_yVel * m_animTimer; // update the remaining space break; case WALKING_DOWN: m_yPos += m_yVel * m_animTimer; m_yDelta -= m_yVel * m_animTimer; break; //... default: break; } if(m_xDelta <= 0 && m_yDelta <= 0) // if i'm done moving { m_xPos = m_xNext; // adjust position m_yPos = m_yNext; m_status = STANDING; // and stop } else m_animTimer = SDL_GetTicks(); // else update timer } 

EDIT: I deleted some variables and left only the elapsed time, speed and end position. Now it moves without flickering, but moving down and to the right is noticeably slower than the top and left. Still wondering why ...

EDIT 2: Well, I understood why this is happening. As I suggested in the first place, there is a different rounding from double to integer when it comes to sum and subtraction. If I do the throw as follows:

 m_xPos += (int)(m_xVel * m_animTimer); 

the animation speed is the same and the problem is resolved.

Answer 1

Consider the following:

 #include <iostream> void main() { int a = 1, b = 1; a += 0.1f; b -= 0.1f; std::cout << a << std::endl; std::cout << b << std::endl; } 

If you implicitly convert float to int when assigning a and b, everything that passes after the decimal point will be truncated and not rounded. The result of this program is:

 1 0 

You said that m_yPos is an integer and m_yVel is a double. Consider what happens in Player::update if the result of m_yVel * m_animTimer less than 1. In the case of UP result will be that your sprite moves one pixel, but in the case of DOWN your sprite won’t at all, because if you add less than one to an integer, nothing will happen. Try to keep your positions as paired and only convert them to integers when you need to pass them to the drawing functions.

The trick you can do so that rounding instead of truncating during conversion is to always add 0.5 to the floating point value when assigning to an integer.

For instance:

 double d1 = 1.2; double d2 = 1.6; int x = d1 + 0.5; int y = d2 + 0.5; 

In this case, x becomes 1, and y becomes 2.

Answer 2

I would prefer not to do incremental calculations. It is simpler, will give the correct results, even if you return on time, will not suffer from a loss of accuracy and will be as fast, if not faster, on modern equipment:

 void Player::step(Player::Direction dir) { // ... case UP: if(m_currMap->tileAt(m_xPos, m_yPos - m_currMap->tileHeight())->m_type == Tile::FLOOR) { // if next tile is not a wall, set up animation m_status = WALKING_UP; m_yStart = m_yPos; m_yDelta = -m_currMap->tileHeight(); // sprite have to move by a tile m_tStart = SDL_GetTicks(); // Started now m_tDelta = 1000.0f; // in one second } break; case DOWN: if(m_currMap->tileAt(m_xPos, m_yPos + m_currMap->tileHeight())->m_type == Tile::FLOOR) { m_status = WALKING_DOWN; m_yStart = m_yPos; m_yDelta = m_currMap->tileHeight(); m_tStart = SDL_GetTicks(); // Started now m_tDelta = 1000.0f; // in one second } break; // ... } void Player::update() { auto tDelta = SDL_GetTicks() - m_tStart; switch(m_status) { case WALKING_UP: case WALKING_DOWN: m_yPos = m_yStart + m_yDelta*tDelta/m_tDelta; // update position break; default: break; } if(tDelta >= m_tDelta) // if i'm done moving { m_xPos = m_xStart + m_xDelta; // adjust position m_yPos = m_yStart + m_yDelta; m_status = STANDING; // and stop } }