adjust collisions

David Arutiunian · David Arutiunian · commit 1a9b5b2a3f2c · 2017-12-22T23:41:52.000+03:00
now playable
refactor code
diff --git a/Doodler.cpp b/Doodler.cpp
@@ -20,34 +20,38 @@ Doodler::Doodler()
 
 void Doodler::updatePosition(const float deltaTime)
 {
-    checkCollision();
-    setVerticalPosition(MOVE_SPEED, deltaTime);
-    m_timeAccumulator += deltaTime * TIME_ACCELERATOR;
-    double nextY = m_position.y - m_initialSpeed * m_timeAccumulator + 0.5 * G * std::pow(m_timeAccumulator, 2);
-    const sf::Vector2f nextPosition = {m_position.x, static_cast<float>(nextY)};
-    m_shape.setPosition(nextPosition);
-    setFallingState(static_cast<float>(nextY));
-    setPosition(nextPosition);
+    const float dtPhysics = deltaTime / MAX_PRECISION_COUNT;
+    for (unsigned i = 0; i < MAX_PRECISION_COUNT; ++i)
+    {
+        setVerticalPosition(MOVE_SPEED, dtPhysics);
+        m_timeAccumulator += dtPhysics * TIME_ACCELERATOR;
+        const float nextY = getNextY();
+        const sf::Vector2f nextPosition = {m_position.x, nextY};
+        m_shape.setPosition(nextPosition);
+        setFallingState(nextY);
+        setPosition(nextPosition);
+        checkCollision();
+    }
 }
 
 void Doodler::checkCollision()
 {
-    const float currentBottomPosition = m_shape.getPosition().y + m_size.x / 2 + m_outlineThickness;
+    const float currentBottomPosition = getBounds().height;
     const bool isAtZeroLevel = m_areFuzzyEqual(currentBottomPosition, m_floor);
-    const bool isGameOverLevel = m_floor == WINDOW_HEIGHT;
+    const bool isGameOverLevel = m_areFuzzyEqual(m_floor, WINDOW_HEIGHT);
     if (isAtZeroLevel && m_isFalling && !isGameOverLevel)
     {
-        printf("%f\n", m_floor);
+        setNextY();
         m_timeAccumulator = 0;
     }
 }
 
-// TODO: fix side collision check
 void Doodler::setVerticalPosition(const float nextX, const float deltaTime)
 {
     const KeysMap &keysMap = m_p_keyboardState->getKeysMap();
-    const bool isMaxRightPosition = m_position.x + m_size.x / 2 + m_outlineThickness < WINDOW_WIDTH;
-    const bool isMaxLeftPosition = m_position.x - m_size.x / 2 - m_outlineThickness > 0;
+    const sf::FloatRect bounds = getBounds();
+    const bool isMaxRightPosition = bounds.width < WINDOW_WIDTH;
+    const bool isMaxLeftPosition = bounds.left > 0;
     if (keysMap.at(sf::Keyboard::Right) && isMaxRightPosition)
     {
         m_position.x += nextX * deltaTime;
@@ -62,7 +66,7 @@ Types Doodler::getType() const
     return Types::Doodler;
 }
 
-const sf::Vector2f &Doodler::getBounds() const
+const sf::Vector2f &Doodler::getSize() const
 {
     return m_size;
 }
@@ -74,15 +78,14 @@ void Doodler::setFloor(const float nextFloor)
         return;
     }
     m_floor = nextFloor;
-    m_position.y = m_floor - m_size.x / 2 - m_outlineThickness;
 }
 
 void Doodler::setFallingState(float nextY)
 {
     m_isFalling = getPosition().y - nextY <= 0;
 }
 
-void Doodler::addKeyboardState(const std::shared_ptr<KeyboardState> p_keyboardState)
+void Doodler::addKeyboardState(const std::shared_ptr<KeyboardState> &p_keyboardState)
 {
     m_p_keyboardState = p_keyboardState;
 }
@@ -91,3 +94,25 @@ bool Doodler::getFallingState() const
 {
     return m_isFalling;
 }
+
+void Doodler::setNextY()
+{
+    m_position.y = m_floor - m_size.y / 2 - m_outlineThickness;
+}
+
+float Doodler::getNextY() const
+{
+    const float lhs = m_initialSpeed * m_timeAccumulator;
+    const auto rhs = static_cast<const float>(0.5 * G * std::pow(m_timeAccumulator, 2));
+    return m_position.y - lhs + rhs;
+}
+
+sf::FloatRect Doodler::getBounds() const
+{
+    const sf::Vector2f position = m_shape.getPosition();
+    const float left = position.x - m_size.x / 2 - m_outlineThickness;
+    const float right = position.x + m_size.x / 2 + m_outlineThickness;
+    const float top = position.y - m_size.y / 2 - m_outlineThickness;
+    const float bottom = position.y + m_size.y / 2 + m_outlineThickness;
+    return sf::FloatRect(left, top, right, bottom);
+}
diff --git a/Doodler.h b/Doodler.h
@@ -19,9 +19,9 @@ class Doodler : public IEntity
 
     Types getType() const override;
 
-    const sf::Vector2f &getBounds() const override;
+    const sf::Vector2f &getSize() const override;
 
-    void addKeyboardState(std::shared_ptr<KeyboardState> p_keyboardState);
+    void addKeyboardState(const std::shared_ptr<KeyboardState> &p_keyboardState);
 
     bool getFallingState() const override;
 
@@ -65,6 +65,12 @@ class Doodler : public IEntity
     void checkCollision() override;
 
     void setVerticalPosition(float nextX, float deltaTime);
+
+    void setNextY();
+
+    sf::FloatRect getBounds() const;
+
+    float getNextY() const;
 };
 
 #endif //DOODLE_JUMP_DOODLER_H
diff --git a/Engine.cpp b/Engine.cpp
@@ -21,14 +21,13 @@ void Engine::processCollision(const std::shared_ptr<IEntity> &p_entity)
     if (doesIntersect(p_entity) && m_p_doodler->getFallingState() && !m_shouldSetFloor)
     {
         m_shouldSetFloor = true;
-        m_floor = p_entity->getPosition().y - p_entity->getBounds().y;
+        m_floor = p_entity->getPosition().y - p_entity->getSize().y;
     }
 }
 
-// TODO: adjust intersection check
 bool Engine::doesIntersect(const std::shared_ptr<IEntity> &p_entity) const
 {
-    sf::Rect<float> rhs(p_entity->getPosition(), p_entity->getBounds());
-    sf::Rect<float> lhs(m_p_doodler->getPosition(), m_p_doodler->getBounds());
+    sf::Rect<float> rhs(p_entity->getPosition(), p_entity->getSize());
+    sf::Rect<float> lhs(m_p_doodler->getPosition(), m_p_doodler->getSize());
     return lhs.intersects(rhs);
 }
diff --git a/EventLoop.cpp b/EventLoop.cpp
@@ -63,12 +63,12 @@ const sf::RenderWindow &EventLoop::getWindow() const
     return m_window;
 }
 
-void EventLoop::addKeyboardState(const std::shared_ptr<KeyboardState> p_keyboardState)
+void EventLoop::addKeyboardState(const std::shared_ptr<KeyboardState> &p_keyboardState)
 {
     m_p_keyboardState = p_keyboardState;
 }
 
-void EventLoop::addView(const std::shared_ptr<View> p_view)
+void EventLoop::addView(const std::shared_ptr<View> &p_view)
 {
     m_p_view = p_view;
 }
diff --git a/EventLoop.h b/EventLoop.h
@@ -21,9 +21,9 @@ class EventLoop
 
     void redrawFrame(const Entities &entities);
 
-    void addKeyboardState(std::shared_ptr<KeyboardState> p_keyboardState);
+    void addKeyboardState(const std::shared_ptr<KeyboardState> &p_keyboardState);
 
-    void addView(std::shared_ptr<View> p_view);
+    void addView(const std::shared_ptr<View> &p_view);
 
     const sf::RenderWindow &getWindow() const;
 
diff --git a/IPhysicsObject.h b/IPhysicsObject.h
@@ -7,9 +7,11 @@
 class IPhysicsObject
 {
 public:
-    virtual const sf::Vector2f &getBounds() const = 0;
+    virtual const sf::Vector2f &getSize() const = 0;
 
     virtual Types getType() const = 0;
+
+    virtual sf::FloatRect getBounds() const = 0;
 };
 
 #endif //DOODLE_JUMP_IPHYSICSOBJECT_H
diff --git a/Platform.cpp b/Platform.cpp
@@ -11,8 +11,10 @@ Platform::Platform()
     m_position.x = rand() % WINDOW_WIDTH;
     m_position.y = rand() % WINDOW_HEIGHT;
 
-    const bool isOverRightSide = m_position.x + m_size.x > WINDOW_WIDTH;
-    const bool isOverLeftSide = m_position.x - m_size.x < 0;
+    const sf::FloatRect bounds = getBounds();
+    const bool isOverRightSide = bounds.width > WINDOW_WIDTH;
+    const bool isOverLeftSide = bounds.left < 0;
+
     if (isOverRightSide)
     {
         m_position.x -= m_size.x;
@@ -44,7 +46,17 @@ Types Platform::getType() const
     return Types::Platform;
 }
 
-const sf::Vector2f &Platform::getBounds() const
+const sf::Vector2f &Platform::getSize() const
 {
     return m_size;
 }
+
+sf::FloatRect Platform::getBounds() const
+{
+    const sf::Vector2f position = m_shape.getPosition();
+    const float left = position.x - m_size.x / 2 - m_outlineThickness;
+    const float right = position.x + m_size.x / 2 + m_outlineThickness;
+    const float top = position.y - m_size.y / 2 - m_outlineThickness;
+    const float bottom = position.y + m_size.y / 2 + m_outlineThickness;
+    return sf::FloatRect(left, top, right, bottom);
+}
diff --git a/Platform.h b/Platform.h
@@ -18,7 +18,7 @@ class Platform : public IEntity
 
     Types getType() const override;
 
-    const sf::Vector2f &getBounds() const override;
+    const sf::Vector2f &getSize() const override;
 
 private:
     sf::RectangleShape m_shape;
@@ -28,6 +28,8 @@ class Platform : public IEntity
     const unsigned m_outlineThickness = 2;
 
     void draw(sf::RenderTarget &target, sf::RenderStates states) const override;
+
+    sf::FloatRect getBounds() const;
 };
 
 #endif //DOODLE_JUMP_PLATFORM_H
diff --git a/View.cpp b/View.cpp
@@ -7,7 +7,7 @@ View::View()
     m_view.setViewport(sf::FloatRect(0, 0, 1, 1));
 }
 
-void View::followTo(const std::shared_ptr<Doodler> p_doodler)
+void View::followTo(const std::shared_ptr<Doodler> &p_doodler)
 {
     m_view.setCenter(WINDOW_WIDTH / 2, p_doodler->getPosition().y);
 }
diff --git a/View.h b/View.h
@@ -11,7 +11,7 @@ class View
 
     const sf::View &getView() const;
 
-    void followTo(std::shared_ptr<Doodler> p_doodler);
+    void followTo(const std::shared_ptr<Doodler> &p_doodler);
 
 private:
     sf::View m_view;
diff --git a/consts.h b/consts.h
@@ -17,9 +17,10 @@ static const sf::Vector2u ICON_SIZE = {32, 32};
 
 /// Game params
 static const float G = 9.8f;
-static const float TIME_ACCELERATOR = 15.f;
+static const float TIME_ACCELERATOR = 7.5f;
 static const float MOVE_SPEED = 500.f;
 static const size_t PLATFORM_COUNT = 30;
+static const unsigned MAX_PRECISION_COUNT = 128;
 
 template<typename Signature>
 using Lambda = std::function<Signature>;

Original file line number	Diff line number	Diff line change
`@@ -20,34 +20,38 @@ Doodler::Doodler()`
`20`	`20`
`21`	`21`	`void Doodler::updatePosition(const float deltaTime)`
`22`	`22`	`{`
`23`		`- checkCollision();`
`24`		`- setVerticalPosition(MOVE_SPEED, deltaTime);`
`25`		`- m_timeAccumulator += deltaTime * TIME_ACCELERATOR;`
`26`		`- double nextY = m_position.y - m_initialSpeed * m_timeAccumulator + 0.5 * G * std::pow(m_timeAccumulator, 2);`
`27`		`- const sf::Vector2f nextPosition = {m_position.x, static_cast<float>(nextY)};`
`28`		`- m_shape.setPosition(nextPosition);`
`29`		`- setFallingState(static_cast<float>(nextY));`
`30`		`- setPosition(nextPosition);`
	`23`	`+ const float dtPhysics = deltaTime / MAX_PRECISION_COUNT;`
	`24`	`+ for (unsigned i = 0; i < MAX_PRECISION_COUNT; ++i)`
	`25`	`+ {`
	`26`	`+ setVerticalPosition(MOVE_SPEED, dtPhysics);`
	`27`	`+ m_timeAccumulator += dtPhysics * TIME_ACCELERATOR;`
	`28`	`+ const float nextY = getNextY();`
	`29`	`+ const sf::Vector2f nextPosition = {m_position.x, nextY};`
	`30`	`+ m_shape.setPosition(nextPosition);`
	`31`	`+ setFallingState(nextY);`
	`32`	`+ setPosition(nextPosition);`
	`33`	`+ checkCollision();`
	`34`	`+ }`
`31`	`35`	`}`
`32`	`36`
`33`	`37`	`void Doodler::checkCollision()`
`34`	`38`	`{`
`35`		`- const float currentBottomPosition = m_shape.getPosition().y + m_size.x / 2 + m_outlineThickness;`
	`39`	`+ const float currentBottomPosition = getBounds().height;`
`36`	`40`	`const bool isAtZeroLevel = m_areFuzzyEqual(currentBottomPosition, m_floor);`
`37`		`- const bool isGameOverLevel = m_floor == WINDOW_HEIGHT;`
	`41`	`+ const bool isGameOverLevel = m_areFuzzyEqual(m_floor, WINDOW_HEIGHT);`
`38`	`42`	`if (isAtZeroLevel && m_isFalling && !isGameOverLevel)`
`39`	`43`	`{`
`40`		`- printf("%f\n", m_floor);`
	`44`	`+ setNextY();`
`41`	`45`	`m_timeAccumulator = 0;`
`42`	`46`	`}`
`43`	`47`	`}`
`44`	`48`
`45`		`-// TODO: fix side collision check`
`46`	`49`	`void Doodler::setVerticalPosition(const float nextX, const float deltaTime)`
`47`	`50`	`{`
`48`	`51`	`const KeysMap &keysMap = m_p_keyboardState->getKeysMap();`
`49`		`- const bool isMaxRightPosition = m_position.x + m_size.x / 2 + m_outlineThickness < WINDOW_WIDTH;`
`50`		`- const bool isMaxLeftPosition = m_position.x - m_size.x / 2 - m_outlineThickness > 0;`
	`52`	`+ const sf::FloatRect bounds = getBounds();`
	`53`	`+ const bool isMaxRightPosition = bounds.width < WINDOW_WIDTH;`
	`54`	`+ const bool isMaxLeftPosition = bounds.left > 0;`
`51`	`55`	`if (keysMap.at(sf::Keyboard::Right) && isMaxRightPosition)`
`52`	`56`	`{`
`53`	`57`	`m_position.x += nextX * deltaTime;`
`@@ -62,7 +66,7 @@ Types Doodler::getType() const`
`62`	`66`	`return Types::Doodler;`
`63`	`67`	`}`
`64`	`68`
`65`		`-const sf::Vector2f &Doodler::getBounds() const`
	`69`	`+const sf::Vector2f &Doodler::getSize() const`
`66`	`70`	`{`
`67`	`71`	`return m_size;`
`68`	`72`	`}`
`@@ -74,15 +78,14 @@ void Doodler::setFloor(const float nextFloor)`
`74`	`78`	`return;`
`75`	`79`	`}`
`76`	`80`	`m_floor = nextFloor;`
`77`		`- m_position.y = m_floor - m_size.x / 2 - m_outlineThickness;`
`78`	`81`	`}`
`79`	`82`
`80`	`83`	`void Doodler::setFallingState(float nextY)`
`81`	`84`	`{`
`82`	`85`	`m_isFalling = getPosition().y - nextY <= 0;`
`83`	`86`	`}`
`84`	`87`
`85`		`-void Doodler::addKeyboardState(const std::shared_ptr<KeyboardState> p_keyboardState)`
	`88`	`+void Doodler::addKeyboardState(const std::shared_ptr<KeyboardState> &p_keyboardState)`
`86`	`89`	`{`
`87`	`90`	`m_p_keyboardState = p_keyboardState;`
`88`	`91`	`}`
`@@ -91,3 +94,25 @@ bool Doodler::getFallingState() const`
`91`	`94`	`{`
`92`	`95`	`return m_isFalling;`
`93`	`96`	`}`
	`97`	`+`
	`98`	`+void Doodler::setNextY()`
	`99`	`+{`
	`100`	`+ m_position.y = m_floor - m_size.y / 2 - m_outlineThickness;`
	`101`	`+}`
	`102`	`+`
	`103`	`+float Doodler::getNextY() const`
	`104`	`+{`
	`105`	`+ const float lhs = m_initialSpeed * m_timeAccumulator;`
	`106`	`+ const auto rhs = static_cast<const float>(0.5 * G * std::pow(m_timeAccumulator, 2));`
	`107`	`+ return m_position.y - lhs + rhs;`
	`108`	`+}`
	`109`	`+`
	`110`	`+sf::FloatRect Doodler::getBounds() const`
	`111`	`+{`
	`112`	`+ const sf::Vector2f position = m_shape.getPosition();`
	`113`	`+ const float left = position.x - m_size.x / 2 - m_outlineThickness;`
	`114`	`+ const float right = position.x + m_size.x / 2 + m_outlineThickness;`
	`115`	`+ const float top = position.y - m_size.y / 2 - m_outlineThickness;`
	`116`	`+ const float bottom = position.y + m_size.y / 2 + m_outlineThickness;`
	`117`	`+ return sf::FloatRect(left, top, right, bottom);`
	`118`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -21,14 +21,13 @@ void Engine::processCollision(const std::shared_ptr<IEntity> &p_entity)`
`21`	`21`	`if (doesIntersect(p_entity) && m_p_doodler->getFallingState() && !m_shouldSetFloor)`
`22`	`22`	`{`
`23`	`23`	`m_shouldSetFloor = true;`
`24`		`- m_floor = p_entity->getPosition().y - p_entity->getBounds().y;`
	`24`	`+ m_floor = p_entity->getPosition().y - p_entity->getSize().y;`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`-// TODO: adjust intersection check`
`29`	`28`	`bool Engine::doesIntersect(const std::shared_ptr<IEntity> &p_entity) const`
`30`	`29`	`{`
`31`		`- sf::Rect<float> rhs(p_entity->getPosition(), p_entity->getBounds());`
`32`		`- sf::Rect<float> lhs(m_p_doodler->getPosition(), m_p_doodler->getBounds());`
	`30`	`+ sf::Rect<float> rhs(p_entity->getPosition(), p_entity->getSize());`
	`31`	`+ sf::Rect<float> lhs(m_p_doodler->getPosition(), m_p_doodler->getSize());`
`33`	`32`	`return lhs.intersects(rhs);`
`34`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,12 +63,12 @@ const sf::RenderWindow &EventLoop::getWindow() const`
`63`	`63`	`return m_window;`
`64`	`64`	`}`
`65`	`65`
`66`		`-void EventLoop::addKeyboardState(const std::shared_ptr<KeyboardState> p_keyboardState)`
	`66`	`+void EventLoop::addKeyboardState(const std::shared_ptr<KeyboardState> &p_keyboardState)`
`67`	`67`	`{`
`68`	`68`	`m_p_keyboardState = p_keyboardState;`
`69`	`69`	`}`
`70`	`70`
`71`		`-void EventLoop::addView(const std::shared_ptr<View> p_view)`
	`71`	`+void EventLoop::addView(const std::shared_ptr<View> &p_view)`
`72`	`72`	`{`
`73`	`73`	`m_p_view = p_view;`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ View::View()`
`7`	`7`	`m_view.setViewport(sf::FloatRect(0, 0, 1, 1));`
`8`	`8`	`}`
`9`	`9`
`10`		`-void View::followTo(const std::shared_ptr<Doodler> p_doodler)`
	`10`	`+void View::followTo(const std::shared_ptr<Doodler> &p_doodler)`
`11`	`11`	`{`
`12`	`12`	`m_view.setCenter(WINDOW_WIDTH / 2, p_doodler->getPosition().y);`
`13`	`13`	`}`