Poległe projekty - porażka czy lekcja?

#pragma once
#ifndef LIBWORMS_COMMON_UNITPHYSICS_HPP
#define LIBWORMS_COMMON_UNITPHYSICS_HPP

#include <ddt/graphics/Camera.hpp>
#include <SFML/System/Vector2.hpp>
#include <SFML/Graphics.hpp>
#include <functional>
#include <list>

#include "SpriteCollision.hpp"

namespace worms
{
    namespace cmn
    {
        //===================================================================//
        class WormsMap;
        //===================================================================//
        // Klasa do liczenia fizyki.
        class UnitPhysics final
        {
        public:
            typedef std::function < sf::Vector2f( sf::Vector2f ) > ActionUpdateVelocity;
           
            // Domyślny konstruktor.
            UnitPhysics();
           
            // Ustawia położenie początkowe obiektu.
            void setPosition( const sf::Vector2f & _position );
           
            // Zwraca aktualne położenie obiektu.
            const sf::Vector2f & getPosition() const;
           
            // Ustawia prędkość wiatru w osi X.
            void setWind( float _fWindVelocityX );
           
            // Ustawia poziom wody (wartość graniczna w osi Y).
            // Jeżeli obiekt przekroczy granicę poziomu wody to będzie stosowany opór dla wody zamiast dla powietrza.
            void setWaterLevel( float _fWaterY );
           
            // Ustawia wagę obiektu.
            // Aktualnie waga wpływa tylko na to jak mocno wiatr działa na jednostkę.
            void setObjectWeight( float _fWeight );
           
            // Ustawia siłę odbicia obiektu. Wartość powinna być z przedziału od 0.0f do 1.0f.
            void setReflection( float _fReflection );
           
            // Zwraca siłę odbicia obiektu.
            float getReflection() const;
           
            // Ustawia prędkość początkową obiektu.
            void setVelocity( const sf::Vector2f & _velocity );
           
            // Zwiększa prędkość obiektu.
            void addVelocity( const sf::Vector2f & _velocityDelta );
           
            // Zwraca aktualną prędkość obiektu.
            const sf::Vector2f & getVelocity() const;
           
            // Ustawia obraz jaki ma być używany do kolizji jednostki.
            void setCollisionImage( const sf::Image & _image, bool _bCalcCollisionAngle = false );
           
            // Ustawia współczynnik tarcia jaki ma być stosowany dla gruntu (z przedziału od 0.0f do 1.0f).
            void setGroundFriction( float _friction );
           
            // Zwraca współczynnik tarcia jaki jest stosowany dla gruntu (z przedziału od 0.0f do 1.0f).
            float getGroundFriction() const;
           
            // Zwraca true, jeżeli jest włączone obliczanie kąta odbicia.
            bool isCalculatingCollisionAngle() const;
           
            // Zwraca współczynnik oporu jaki jest stosowany dla wiatru (z przedziału od 0.0f do 1.0f).
            float getAirFriction() const;
           
            // Zwraca współczynnik oporu jaki jest stosowany w wodzie (z przedziału od 0.0f do 1.0f).
            float getWaterFriction() const;
           
            // Zwraca prędkość wiatru.
            float getWindVelocity() const;
           
            // Aktualizuje położenie obiektu.
            void update( float _fDeltaTime, const WormsMap & _map, const sf::Vector2f & _origin );
           
            // Zwraca true, jeżeli worms stoi na terenie.
            bool isOnGround() const;
           
            // Zwraca true, jeżeli obiekt jest poniżej poziomu wody.
            bool isBelowWaterLevel() const;
           
            // Zwraca aktualny stan kolizji.
            const SpriteCollision::State & getCollisionState() const { return m_actualCollisionState; }
           
            // Ustawia delegat jaki będzie wywoływany w celu modyfikacji prędkości na gruncie.
            void setGroundVelocityDelegate( ActionUpdateVelocity _delegate ) { m_delegateGroundVelocity = _delegate; }
           
            // Ustawia delegat jaki będzie wywoływany w celu modyfikacji prędkości na gruncie.
            void setAirVelocityDelegate( ActionUpdateVelocity _delegate ) { m_delegateAirVelocity = _delegate; }
           
            // Renderuje pomocnicze diagnostyczne informacje związane z kolizją.
            void renderDebugCollision( const ddt::gfx::Camera & _camera ) const;
           
            // Zwraca ostatnią znaną prędkość przed wystąpieniem kolizji.
            float getSpeedBeforeCollision() const;
           
            // Czyści ostatnią znaną prędkość przed wystąpieniem kolizji.
            void clearSpeedBeforeCollision();
        private:
            // Zwraca stan kolizji jednostki z mapą dla nowej pozycji.
            SpriteCollision::State calcCollision( const WormsMap & _map, const sf::Vector2f & _newPosition, const sf::Vector2f & _origin );
           
            // Zwraca stan kolizji jednostki z mapą dla nowej pozycji.
            // Zapobiega występowaniu efektu przechodzenia przez ściany.
            // W przypadku wykrycia kolizji modyfikowane jest położenie _newPosition.
            SpriteCollision::State calcCollisionProtectTunneling( const WormsMap & _map, sf::Vector2f & _newPosition, const sf::Vector2f & _origin, float _fMaxStepSize = 1.0f );
           
            // Zapobiega zapadaniu się obiektu w grunt oraz podnosi obiekt do góry tak, aby stał on na terenie.
            sf::Vector2f keepObjectAtGround( const WormsMap & _map, const sf::Vector2f & _origin, const sf::Vector2f & _oldPosition, SpriteCollision::State _oldCollisionState, const sf::Vector2f & _newPosition );
           
        private:
            sf::Vector2f m_position;
            sf::Vector2f m_velocity;
            float m_fWindVelocityX;
            float m_fObjectWeight;
            float m_fReflection;
            float m_fGroundFriction;
            float m_fWaterLevelY;
            float m_fSpeedBeforeCollision;
            SpriteCollision::State m_actualCollisionState;
            SpriteCollision m_collisionDetector;
            ActionUpdateVelocity m_delegateGroundVelocity;
            ActionUpdateVelocity m_delegateAirVelocity;
            std::list < std::pair < sf::Vector2f, int > > m_debugContainer;
        }; //class UnitPhysics
        //===================================================================//
       
    } // namespace cmn
} // namespace worms

#endif //LIBWORMS_COMMON_UNITPHYSICS_HPP