Applying constant gravity ends up tresspassing tile. (Video, code and all data provided)

[rudiHammad]

Hi, so something a bit strange is happening and I have spent a couple of days without understanding what is happening.
I am doing a simple collision of a sprite with a tile. The tile map is 32*32 and so is the sprite size. I am applying constant gravity on the sprite and if the next position is colliding with a collision tile, which is in a metaLayer, the sprite will correct its position to but on top of it.
As you can see in the video every thing works as expected. The sprite is detecting the metalayer collision tile bellow, and sets its position properly. until some time passes. Then suddenly, it tresspases the collision tile.
This happens with gravity values lower that -600. I set it to -1000 to make it happen faster.
This happens after around 15/20 seconds of waiting. I don't understand why it ends up breaking after a while.
I have printed out the velocity and there it no peak in the speed or anything strange. With the same value it just breaks after a while.
Any idea of what could be happening?
thanks

Here is the code and I have also attached the required data files to make easy for any one to test it.

appDelegate.cpp (removed the resolution scale)

#include "AppDelegate.h"
#include "HelloWorldScene.h"

#define USE_AUDIO_ENGINE 1

#if USE_AUDIO_ENGINE
#    include "audio/AudioEngine.h"
#endif

USING_NS_AX;

//static ax::Size designResolutionSize = ax::Size(1280, 720);
static ax::Size designResolutionSize = ax::Size(970, 540);
static ax::Size smallResolutionSize  = ax::Size(480, 320);
static ax::Size mediumResolutionSize = ax::Size(1024, 768);
static ax::Size largeResolutionSize  = ax::Size(2048, 1536);

AppDelegate::AppDelegate() {}

AppDelegate::~AppDelegate() {}

// if you want a different context, modify the value of glContextAttrs
// it will affect all platforms
void AppDelegate::initGLContextAttrs()
{
    // set OpenGL context attributes: red,green,blue,alpha,depth,stencil,multisamplesCount
    GLContextAttrs glContextAttrs = {8, 8, 8, 8, 24, 8, 0};

    GLView::setGLContextAttrs(glContextAttrs);
}

// if you want to use the package manager to install more packages,
// don't modify or remove this function
static int register_all_packages()
{
    return 0;  // flag for packages manager
}

bool AppDelegate::applicationDidFinishLaunching()
{
    // initialize director
    auto director = Director::getInstance();
    auto glView   = director->getOpenGLView();
    if (!glView)
    {
#if (AX_TARGET_PLATFORM == AX_PLATFORM_WIN32) || (AX_TARGET_PLATFORM == AX_PLATFORM_MAC) || \
    (AX_TARGET_PLATFORM == AX_PLATFORM_LINUX)
        glView = GLViewImpl::createWithRect(
            "PlatforLearning", ax::Rect(0, 0, designResolutionSize.width, designResolutionSize.height));
#else
        glView = GLViewImpl::create("PlatforLearning");
#endif
        director->setOpenGLView(glView);
    }

    // turn on display FPS
    director->setStatsDisplay(true);

    // set FPS. the default value is 1.0/60 if you don't call this
    director->setAnimationInterval(1.0f / 60);


    register_all_packages();

    // create a scene. it's an autorelease object
    auto scene = utils::createInstance<HelloWorld>();

    // run
    director->runWithScene(scene);

    return true;
}

// This function will be called when the app is inactive. Note, when receiving a phone call it is invoked.
void AppDelegate::applicationDidEnterBackground()
{
    Director::getInstance()->stopAnimation();

#if USE_AUDIO_ENGINE
    AudioEngine::pauseAll();
#endif
}

// this function will be called when the app is active again
void AppDelegate::applicationWillEnterForeground()
{
    Director::getInstance()->startAnimation();

#if USE_AUDIO_ENGINE
    AudioEngine::resumeAll();
#endif
}

header file

#include "axmol.h"


class HelloWorld : public ax::Scene
{
     
public:
    bool init() override;
    void update(float delta) override;
    void playerMove(float delta);
    ax::Vec2 getTileCoordinatesFromPosition(ax::Vec2 position);
    ax::Vec2 getTiledMapSizeResolution();

    // Player attributes
    ax::Sprite* playerSprite;
    float playerPosX;
    float playerPosY;
    float playerVelocityX;
    float playerVelocityY;


    // Physics attributes
    float gravity = -1000; 


    // Tile map attributes
    ax::FastTMXTiledMap* tileMap;
    int tileWidth;
    int tileHeight;
    ax::TMXLayer* metaLayer;

    // Other
    ax::Sprite* backgroundSprite;
    bool keys[255] = { false };
};

cpp file

#include "HelloWorldScene.h"

USING_NS_AX;


bool HelloWorld::init()
{
    //////////////////////////////
    // 1. super init first
    if (!Scene::init())
    {
        return false;
    }

    auto visibleSize = _director->getVisibleSize();
    auto origin = _director->getVisibleOrigin();
    auto safeArea = _director->getSafeAreaRect();
    auto safeOrigin = safeArea.origin;


    playerSprite = ax::Sprite::create("playerSquare.png");

    // TO KEEP THIS LESSON SIMPLE, THE PIVOT IS AT 0, 0 (bottom, left)
    playerSprite->setAnchorPoint(ax::Vec2(0,0));
    this->addChild(playerSprite, 10);


    // Creating the TileMap and accessing its data (tmx)
    tileMap = new ax::FastTMXTiledMap();
    tileMap->initWithTMXFile("tiled/tilesmapTest.tmx");
    this->addChild(tileMap);
    tileWidth = tileMap->getTileSize().width;
    tileHeight = tileMap->getTileSize().height;

    TMXObjectGroup* playerSpawnTMXObjGroup = tileMap->getObjectGroup("playerSpawnObjectLayer");
    auto spawnPointObject = playerSpawnTMXObjGroup->getObject("SpawnPoint_1");
    playerPosX = spawnPointObject.at("x").asFloat();
    playerPosY = spawnPointObject.at("y").asFloat();

    metaLayer = tileMap->getLayer("meta");
    metaLayer->setVisible(false);


    // Update
    scheduleUpdate();

    return true;
}


void HelloWorld::playerMove(float delta)
{

    playerVelocityY = 300.f * keys[int(EventKeyboard::KeyCode::KEY_W)] + -300.f * keys[int(EventKeyboard::KeyCode::KEY_S)] ;

    //Apply gravity
    playerVelocityY += gravity ;

    // Calculate potential new position
    float playerNextPosX = playerPosX + playerVelocityX * delta;
    float playerNextPosY = playerPosY + playerVelocityY * delta;

    
    auto lowLeftCornerTileId = getTileCoordinatesFromPosition(ax::Vec2(playerNextPosX + 0.0, playerNextPosY ));
    auto lowRightCornerTileId = getTileCoordinatesFromPosition(ax::Vec2(playerNextPosX + (tileWidth - 0.1), playerNextPosY)); 

    if (metaLayer->getTileGIDAt(lowLeftCornerTileId) || (metaLayer->getTileGIDAt(lowRightCornerTileId)))
    {
        playerNextPosY = (int( (playerNextPosY / tileHeight) ) * tileHeight) + (tileHeight + 0.1); 
        playerVelocityY = 0;                                                                       
    }

    
    // Apply new position
    playerPosX = playerNextPosX;
    playerPosY = playerNextPosY;

    playerSprite->setPosition(playerPosX, playerPosY);
}


ax::Vec2 HelloWorld::getTiledMapSizeResolution()
{
    auto tileMapXRes = tileMap->getMapSize().width * tileWidth;
    auto tileMapYRes = tileMap->getMapSize().height * tileHeight;
    return Vec2(tileMapXRes, tileMapYRes);
}


ax::Vec2 HelloWorld::getTileCoordinatesFromPosition(ax::Vec2 position)
{
    int tileXCoord = position.x / tileMap->getTileSize().width;                                      // e.g, for position.x = 15,763(px) -> 15.763(px) / 32(px)  = 0.49 --> int(0.49) is 0
    int tileYCoord = (getTiledMapSizeResolution().y - position.y) / tileMap->getTileSize().height;   // Since cocos2dx Y origin is bottom we have to reverse it
    return Vec2(tileXCoord, tileYCoord);
}



void HelloWorld::update(float delta)
{
    playerMove(delta);
}

data.zip

2023-07-29 22-54-36.zip

[rudiHammad]

One thing that I noticed is that when the sprite goes inside the collision tile is because at the line
if (metaLayer->getTileGIDAt(lowLeftCornerTileId) || (metaLayer->getTileGIDAt(lowRightCornerTileId))) metaLayer->getTileGIDAt(lowLeftCornerTileId) and
(metaLayer->getTileGIDAt(lowRightCornerTileId) suddenly return 0, which doesn't make many sense.
getTileGIDAt returns 1 if there is a collision tile at a specific coordinate right? If you print out the values it returns 1 all the time which is correct. But as I said, suddenlty it returns 0, meaning that there is no collision tile, so the sprite trespass the tile.
...weird.. I'll keep investigating

[rh101]

If you haven't done so already, try to use conditional breakpoints to stop only when those functions return 0, and then follow the callstack up the chain till you find out why.

[rudiHammad]

Yes. I did this:

if (!metaLayer->getTileGIDAt(lowLeftCornerTileId ))
        {
            ax::log("%i", metaLayer->getTileGIDAt(lowLeftCornerTileId));  // Break point
            ax::log("no collision detected anymore at low left");
        }
  if (!metaLayer->getTileGIDAt(lowRightCornerTileId))
        {
            ax::log("%i", metaLayer->getTileGIDAt(lowRightCornerTileId ));  // Break point
            ax::log("no collision detect anymore at low right");
        }
 if (metaLayer->getTileGIDAt(lowLeftCornerTileId) || (metaLayer->getTileGIDAt(lowRightCornerTileId)))
    {
        playerNextPosY = (int( (playerNextPosY / tileHeight) ) * tileHeight) + (tileHeight + 0.1); 
        playerVelocityY = 0;                                                                       
    }

What happens is as you see in the video. It holds up for 15 seconds where it is detecting a collision (so both getTileGIDat() return 1 and therefore the if statement that keeps the sprite on top( playerNextPosY = (int( (playerNextPosY / tileHeight) ) * tileHeight) + (tileHeight + 0.1); and playerVelocityY = 0;) work perfectly. But then,as the break point show, sudenly it doesn't detect collisions anymore, so that if
statement is ignored and the sprite goes down.

And some times it seems to happen randomly. There is no problem if the gravity value is around -600. But lower than that it does happen, BUT, not always. For instance, I tried -800 and it runs perfectly. I tried it again, without changing anything, just hitting play again, and it did happen.

[rudiHammad]

okey, I find a work around it. The issue happens for big gravity when the player is on top of a tile of tile collision.
So I just lowered the gravity when the player is on top of the collision tile, and increased the gravity when he is in the air.

if (previousPosY - playerPosY == 0)
        gravity = -10;  // when player is on ground
    else
        gravity = -1000;

It still bothers me not know why the issue happens if I just left gravity to -1000, but it is a work around.
Just to be clear, if the gravity was always -1000, the player doesn't trespass the collision tile intermediately. It does it after some time has passed.
Any way, that at least a solution for now.

[DelinWorks]

It feels like the problem you have is fps, try to implement the system so that it runs an X amount of times a second at minimum, I'd start at 240 ticks per second and gradually decrease it until you find the gravity bug

[rudiHammad]

aha! yes, that's it. The gravity (probably combine with relatively small tiles 32*32) is to high for the frame rate. Even if I set it to 600 fps ( which is by doing that director->setAnimationInterval(1.0f / 600); right?)
it ends up crashing, but for director->setAnimationInterval(1.0f / 700) and above it is stable; Of course this isn't realistic. I want my game to run at 60 fps. But I thought that I forced that by multiplying by delta float playerNextPosY = playerPosY + playerVelocityY * delta;.
Multiplying by delta and having director->setAnimationInterval(1.0f / 60) isn't how you ensure that the system is running at exactly at 60 fps?

[DelinWorks]

you're doing it incorrectly, you should divide the delta time into 4 substeps at minimum, or you can make the system run at a fixed delta time by decoupling it from the update method, first store the current time of the physics system and another time for the game itself and each update while the physics time is lower than the game time you step with a delta time of (1.0 / 60) until the condition in the while loop is no longer met, this way if your game runs at 4 fps the physics will run at 60 no matter what, back to 4 substeps at 60 fps it will yield 240 steps a second, if you find that you need more than 240 tps for your system to be stable then that's inefficient you'd need to fix the root of the problem, the point of this system is if the fame stutters (which always happens on most of the devices) then your physics system won't step through a big delta time which causes tunneling through objects.

[rudiHammad]

can you provide a quick snippet in pseudo code? I understand what you are saying but I am no sure how to implement it.

[DelinWorks]

the code I sent you in discord has a solid example, look in the update function

[rudiHammad]

I will thanks