SFML movement not working with delta time C++ - c++

Question

I have a Player class that inherits from RectangleShape and I have created a function to move my player left and right on the A & D keys, but when enabling and disabling VSync I find that the movement speeds up rapidly, my guess is that my delta time implementation is incorrect but it seems to be the same as most tutorials online:
class Player : public sf::RectangleShape {
private:
sf::Vector2f velocity;
sf::Vector2f acceleration;
const float maxSpeed = 20.f;
public:
Player(sf::Vector2f size) : sf::RectangleShape(size) {
velocity = sf::Vector2f(0.f, 0.f);
acceleration = sf::Vector2f(0.05f, 27.f);
}
void Move(int& dt) {
if (Keyboard::isKeyPressed(Keyboard::D)) {
if (velocity.x < maxSpeed) {
velocity.x += acceleration.x * dt;
}
}
else if (Keyboard::isKeyPressed(Keyboard::A)) {
if (velocity.x > -maxSpeed) {
velocity.x -= acceleration.x * dt;
}
}
else if (velocity.x < 0.2f && velocity.x > - 0.2f) {
velocity.x = 0;
}
else {
if (velocity.x > 0.f) {
velocity.x -= acceleration.x * dt;
}
else {
velocity.x += acceleration.x * dt;
}
}
}
This is my main loop (stripped down)(I also have a custom Window class):
sf::Clock dtClock;
int dt;
int main() {
Window win("Test Window", sf::VideoMode::getDesktopMode().width, sf::VideoMode::getDesktopMode().height, false);
Player player(sf::Vector2f(50.f, 50.f));
player.setFillColor(sf::Color::Blue);
player.move(sf::Vector2f(200.f, 150.f));
sf::Clock clock;
float lastTime = 0;
while (win.IsOpen()) {
dt = dtClock.restart().asMilliseconds();
player.Move(dt);
win.SetCenter(player.getPosition());
float currentTime = clock.restart().asSeconds();
short int fps = 1 / currentTime;
lastTime = currentTime;
win.Clear();
win.Draw(player);
win.Disp(fps);
}
}
EDIT: here is the minimal reproducible code:
#include <string>
#define BAR_SIZE 16.f
//this is where scale will be 1:1
#define STANDARD_WIDTH 1920
sf::Font firaCode;
enum class RenderObjectType {
Rectangle = 0,
Circle,
Sprite,
count
};
typedef RenderObjectType TROT;
struct TestRenderObject { //node
RenderObjectType type;
void* val;
TestRenderObject(void* val, RenderObjectType type) { this->val = val; this->type = type; }
};
typedef TestRenderObject TRO;
class Window {
private:
std::string title;
sf::RenderWindow win;
sf::View view;
sf::View staticView; //for use with GUI and cinematic bars
sf::Event evnt;
sf::Color background;
bool vsyncEnabled = true;
public:
Window(std::string name = "", unsigned pWidth = 1920, unsigned pHeight = 1080, bool fullscreen = false, sf::Color backgroundColour = sf::Color(135, 206, 235)) {
this->title = name;
this->win.create(sf::VideoMode(pWidth, pHeight), name, (fullscreen ? sf::Style::Fullscreen : sf::Style::Default));
this->win.setVerticalSyncEnabled(this->vsyncEnabled);
this->view.setSize(sf::Vector2f(pWidth, pHeight));
this->view.setCenter(pWidth / 2, pHeight / 2);
this->staticView.setSize(sf::Vector2f(pWidth, pHeight));
this->staticView.setCenter(pWidth / 2, pHeight / 2);
this->background = backgroundColour;
}
inline void toggleVSync() {
this->vsyncEnabled = !this->vsyncEnabled;
this->win.setVerticalSyncEnabled(this->vsyncEnabled);
}
inline void Clear() {
this->win.clear(background);
this->win.setView(this->view);
}
inline void Draw(sf::RectangleShape& r) {
this->win.draw(r);
}
inline void Draw(sf::CircleShape& c) {
this->win.draw(c);
}
inline void Draw(sf::Sprite& s) {
this->win.draw(s);
}
inline void Draw(std::initializer_list<TestRenderObject>& renderObjects) { //multiple types for debugging
for (auto& ele : renderObjects) {
switch (ele.type)
{
case(RenderObjectType::Rectangle):
this->Draw(*((sf::RectangleShape*)ele.val));
break;
case(RenderObjectType::Circle):
this->Draw(*((sf::CircleShape*)ele.val));
break;
case(RenderObjectType::Sprite):
this->Draw(*((sf::Sprite*)ele.val));
break;
default:
break;
}
}
}
inline void Draw(std::initializer_list<sf::Sprite> renderObjects) {
for (auto& ele : renderObjects)
this->win.draw(ele);
}
inline void Disp() {
this->win.setView(this->staticView); //UI elements
this->win.setView(this->view); //game elements
this->win.display();
}
inline bool IsOpen() {
return this->win.isOpen();
}
inline bool PollEvnt() {
return this->win.pollEvent(this->evnt);
}
inline sf::Event& GetEvnt() {
return this->evnt;
}
inline sf::Vector2f GetPosition() {
return sf::Vector2f(this->win.getPosition().x, this->win.getPosition().y);
}
inline void Shift(sf::Vector2f amount) {
this->view.move(amount);
} inline void Move(sf::Vector2f amount) { this->Shift(amount); }
inline void SetCenter(sf::Vector2f position) {
this->view.setCenter(position);
}
inline void Rotate(float amount) {
this->view.rotate(amount);
}
inline void Zoom(float amount) {
this->view.zoom(amount);
}
inline void ResetRotation() {
this->view.setRotation(0);
}
inline void ResetZoom() {
this->view.setSize(sf::Vector2f(this->win.getSize()));
} inline void ResetScale() { this->ResetZoom(); }
inline void ResetViewRatio() {
this->ResetZoom();
}
void Close() {
this->win.close();
}
};
typedef Window Win;
using Keyboard = sf::Keyboard;
using WinEvnt = sf::Event;
const float gravity{ 1.f };
class Player : public sf::RectangleShape {
private:
sf::Vector2f velocity;
sf::Vector2f acceleration;
const float maxSpeed = 20.f;
const float maxFallSpeed = 30.f;
public:
Player(sf::Vector2f size) : sf::RectangleShape(size) {
velocity = sf::Vector2f(0.f, 0.f);
acceleration = sf::Vector2f(0.05f, 27.f);
}
void Move(const int& dt) {
if (Keyboard::isKeyPressed(Keyboard::D)) {
if (velocity.x < maxSpeed) {
velocity.x += acceleration.x * dt;
}
}
else if (Keyboard::isKeyPressed(Keyboard::A)) {
if (velocity.x > -maxSpeed) {
velocity.x -= acceleration.x * dt;
}
}
else if (velocity.x < 0.2f && velocity.x > -0.2f) {
velocity.x = 0;
}
else {
if (velocity.x > 0.f) {
velocity.x -= acceleration.x * dt;
}
else {
velocity.x += acceleration.x * dt;
}
}
if (this->getPosition().y >= 500) {
velocity.y = 0;
if (this->getPosition().y >= 500)
this->setPosition(this->getPosition().x, 500);
if (Keyboard::isKeyPressed(Keyboard::Space) || Keyboard::isKeyPressed(Keyboard::W)) {
velocity.y -= acceleration.y;
}
}
else {
if (velocity.y < maxFallSpeed)
velocity.y += gravity;
}
this->move(velocity);
}
};
sf::Clock dtClock;
int dt;
int main() {
Window win("Test Window", sf::VideoMode::getDesktopMode().width, sf::VideoMode::getDesktopMode().height, false);
sf::CircleShape c(100.f);
c.setFillColor(sf::Color::Green);
Player player(sf::Vector2f(50.f, 50.f));
player.setFillColor(sf::Color::Blue);
player.move(sf::Vector2f(200.f, 150.f));
sf::RectangleShape rect(sf::Vector2f(100.f, 50.f));
rect.setFillColor(sf::Color::Magenta);
rect.move(sf::Vector2f(600.f, 200.f));
sf::CircleShape circle(200.f);
circle.setFillColor(sf::Color::Yellow);
circle.setOutlineThickness(-15);
circle.setOutlineColor(sf::Color(255, 99, 200));
circle.move(sf::Vector2f(1000.f, 1000.f));
sf::RectangleShape big(sf::Vector2f(6000.f, 3000.f));
big.setFillColor(sf::Color::Red);
big.move(sf::Vector2f(900.f, 600.f));
std::initializer_list<TestRenderObject> objects =
{
TRO((void*)&c, TROT::Circle),
TRO((void*)&rect, TROT::Rectangle),
TRO((void*)&big, TROT::Rectangle),
TRO((void*)&circle, TROT::Circle)
};
sf::Clock clock;
float lastTime = 0;
while (win.IsOpen()) {
while (win.PollEvnt()) {
if (win.GetEvnt().type == WinEvnt::KeyReleased && win.GetEvnt().key.code == Keyboard::V) {
win.toggleVSync();
}
else if (win.GetEvnt().type == sf::Event::Resized) {
win.ResetViewRatio();
}
else if (win.GetEvnt().type == WinEvnt::Closed) {
win.Close();
}
}
dt = dtClock.restart().asMilliseconds();
player.Move(dt);
win.SetCenter(player.getPosition());
float currentTime = clock.restart().asSeconds();
short int fps = 1 / currentTime;
lastTime = currentTime;
win.Clear();
win.Draw(objects);
win.Draw(player);
win.Disp();
}
}

Answer 1

With basic drawing code and modern GPUs you can easily get up to 2-3k frames per second, which can then turn into a frame time of 1f / 3000fps = 0.00033s which is less than one millisecond, thus when you call asMilliseconds() you may end up with 0.
An easy workaround here is to always work with seconds (asSeconds()) and floats, that way you should never hit 0. Keep in mind though, that you should always set a limit, either by enabling VSync or calling setFramerateLimit().
As for a design point of view, I recommend to not derive from sf::RectangleShape and instead use composition over inheritance. You can then derive from the more interface-like classes such as `sf