Component::Jumper

#ifndef GAMECOMPONENT_H_INCLUDED
#define GAMECOMPONENT_H_INCLUDED

#include "MyGame.h"

namespace Component
{

    #define JUMPER _THIS->get<Component::Jumper>()
    #define _JUMPER get<Component::Jumper>()
    struct Jumper : public Component::Helper<Jumper>
    {

        bool _keyJump = false;


        bool _jump = false;

        bool _isJump = false;
        bool _isFall = false;
        bool _isLand = true;

        bool _moveL = false;
        bool _moveR = false;

        bool _canMoveL = false;
        bool _canMoveR = false;


        bool _hitU = false;
        bool _hitD = false;
        bool _hitL = false;
        bool _hitR = false;


        VAR _gravity = 0;

        VAR _vy = 0;
        VAR _vx = 0;
        VAR _vyMax = 0;
        VAR _vxMax = 0;
        VAR _dy = 0;
        VAR _dx = 0;

        int _posMapX = 0;
        int _posMapY = 0;

        int _posMapAbsX = 0;
        int _posMapAbsY = 0;

        // 4 corners

        VAR _left = 0;
        VAR _top = 0;
        VAR _right = 0;
        VAR _bottom = 0;

        int _leftMap = 0;
        int _topMap = 0;
        int _rightMap = 0;
        int _bottomMap = 0;

        // Map2D
        Component::TileMap2D* _tileMap2D = nullptr;

        Jumper();
        Jumper(VAR gravity);
        Clip* setTileMap(Component::TileMap2D* tileMap2D);
        Clip* setSpeedMax(VAR vxMax, VAR vyMax);
        void doJump();
        void doFall();
        void doGravity();
        void doLand(VAR y);
        void doMove(VAR dx);
        void doFriction(VAR fx);


        void testCollision();

        void update();
        void render();

    }__attribute__((packed));

}

#endif // GAMECOMPONENT_H_INCLUDED


//---------------------------------------------------------------------------------------------------------

#include "gameComponent.h"

namespace Component
{
        Jumper::Jumper()
        {
            _type = Component::type("JUMPER", true);
        }

        Jumper::Jumper(VAR gravity)
        {
            _type = Component::type("JUMPER", true);
            _gravity = gravity;
        }

        Clip* Jumper::setTileMap(Component::TileMap2D* tileMap2D)
        {
            _tileMap2D = tileMap2D;
            return _clip;
        }

        Clip* Jumper::setSpeedMax(VAR vxMax, VAR vyMax)
        {
            _vxMax = vxMax;
            _vyMax = vyMax;
            return _clip;
        }

        void Jumper::doJump()
        {
            if (!_jump)
            {
                _jump = true;
                _isLand = false;
                _vy = -_vyMax;
                _dy = _gravity;
            }

        }

        void Jumper::doFall()
        {
            if (!_isFall)
            {
                _jump = true;
                _isLand = false;
                if (_vy < 0) _vy = 0;
                _dy = _gravity;
            }
        }

        void Jumper::doGravity()
        {
            _vy += _dy;

            _isFall = _vy > 0;
            _isJump = _vy < 0;

            if (_isJump && _vy >=0) doFall();
            if (_vy > _vyMax) _vy = _vyMax;
        }


        void Jumper::doLand(VAR y)
        {
            if (!_isLand)
            {
                _isLand = true;
                _jump = false;
                _vy = 0;
                _dy = 0;
                _clip->_y = y;
            }

        }

        void Jumper::doMove(VAR dx)
        {
            //if (!_jump)
            {
                _dx = dx;
                _vx += _dx;

                _moveL = _vx<0;
                _moveR = _vx>0;

                if (_moveL && _vx < -_vxMax) _vx = -_vxMax;
                if (_moveR && _vx >  _vxMax) _vx =  _vxMax;
            }
        }

        void Jumper::doFriction(VAR fx)
        {
            if (!_jump)
            {
                if (_moveL)
                {
                    _vx += fx;
                    if (_vx >= 0) _vx = 0;
                }
                if (_moveR)
                {
                    _vx -= fx;
                    if (_vx <= 0) _vx = 0;
                }
            }
        }

        void Jumper::testCollision()
        {

            _posMapX = std::floor(_clip->_x/_tileMap2D->_tileW);
            _posMapY = std::floor(_clip->_y/_tileMap2D->_tileH);

            // Test Collision 4 Direction , Test 4 Corners

            _left   = _clip->_x - _clip->_oX;
            _top    = _clip->_y - _clip->_oY;

            _right  = _left + _clip->_rect._w-1; // Important -1 for test the collision of TileMap at Right
            _bottom = _top + _clip->_rect._h-1; // Important -1 for test the collision of TileMap at Bottom

            _leftMap   = std::floor(_left/_tileMap2D->_tileW);
            _topMap    = std::floor(_top/_tileMap2D->_tileH);
            _rightMap  = std::floor(_right/_tileMap2D->_tileW);
            _bottomMap = std::floor(_bottom/_tileMap2D->_tileH);

            // Test LEFT
            if (_tileMap2D->getTileHit(_leftMap-1, _topMap) || _tileMap2D->getTileHit(_leftMap-1, _bottomMap))
                if (Collision2D::pointRect(Vec2{_left,_top}, _tileMap2D->getTileRect(_leftMap-1, _topMap, 2+std::abs(_vx)) ) ||
                    Collision2D::pointRect(Vec2{_left,_bottom}, _tileMap2D->getTileRect(_leftMap-1, _bottomMap, 2+std::abs(_vx)) ) )
                {
                    _hitL = true;
                }
            // Test RIGHT
            if (_tileMap2D->getTileHit(_rightMap+1, _topMap) || _tileMap2D->getTileHit(_rightMap+1, _bottomMap))
                if (Collision2D::pointRect(Vec2{_right,_top}, _tileMap2D->getTileRect(_rightMap+1, _topMap, 2+_vx)) ||
                    Collision2D::pointRect(Vec2{_right,_bottom}, _tileMap2D->getTileRect(_rightMap+1, _bottomMap, 2+_vx)) )
                {
                    _hitR = true;
                }
            // Test UP
            if (_tileMap2D->getTileHit(_leftMap, _topMap-1) || _tileMap2D->getTileHit(_rightMap, _topMap-1) )
                if (Collision2D::pointRect(Vec2{_left,_top}, _tileMap2D->getTileRect(_leftMap, _topMap-1,   -_vy)) ||
                    Collision2D::pointRect(Vec2{_right,_top}, _tileMap2D->getTileRect(_rightMap, _topMap-1,  -_vy)))
                {
                    _hitU = true;

                }
            // Test DOWN
            if (_tileMap2D->getTileHit(_leftMap, _bottomMap+1) || _tileMap2D->getTileHit(_rightMap, _bottomMap+1) )
                if (Collision2D::pointRect(Vec2{_left,_bottom}, _tileMap2D->getTileRect(_leftMap, _bottomMap+1,  2+_vy)) ||
                    Collision2D::pointRect(Vec2{_right,_bottom}, _tileMap2D->getTileRect(_rightMap, _bottomMap+1,  2+_vy)))
                {
                    _hitD = true;
                }

            if (!_tileMap2D->getTileHit(_leftMap, _bottomMap+1) && !_tileMap2D->getTileHit(_rightMap, _bottomMap+1) )
            {
                //printf("< VOID >");
                if (_isLand)
                {
                    doFall();
                }
            }
        }

        void Jumper::update()
        {

            // Reset All collisions !
            _hitU = false;
            _hitD = false;
            _hitL = false;
            _hitR = false;

            _canMoveL = true;
            _canMoveR = true;

            testCollision();

            if (_hitL)
            {
                //printf("< L >");
                _canMoveL = false;
                if (_moveL) _vx = 0;
            }
            if (_hitR)
            {
                //printf("< R >");
                _canMoveR = false;
                if (_moveR) _vx = 0;
            }

            if (_hitU)
            {
                //printf("< U >");
                //_clip->_y = (_topMap-1) * _tileMap2D->_tileH + _tileMap2D->_tileH;
                if (_isJump)
                {
                    printf("< U > : %i, %i \n", _posMapX, _topMap-1);
                    doFall();
                }
            }

            if (_hitD)
            {
                if (_isFall)
                {
                    printf("< D > : %i, %i \n", _posMapX, _bottomMap+1);
                    doLand(_tileMap2D->getTileRect(_leftMap, _bottomMap+1,4)._y-4);
                }
                    //doLand(_clip->_y);
            }

            doGravity();

            // Move the Jumper !
            _clip->_x += _vx;
            _clip->_y += _vy;

        }
        void Jumper::render()
        {

            if (Clip::_showClipInfo)
            {
                Draw::rect(_tileMap2D->getTileRect(_posMapX-1,_posMapY)+Rect{_clip->_parent->absX(),_clip->_parent->absY(),0,0},al_map_rgb(50,150,40),0);
                Draw::rect(_tileMap2D->getTileRect(_posMapX+1,_posMapY)+Rect{_clip->_parent->absX(),_clip->_parent->absY(),0,0},al_map_rgb(50,40,150),0);
                Draw::rect(_tileMap2D->getTileRect(_posMapX,_posMapY-1)+Rect{_clip->_parent->absX(),_clip->_parent->absY(),0,0},al_map_rgb(150,150,40),0);
                Draw::rect(_tileMap2D->getTileRect(_posMapX,_posMapY+1)+Rect{_clip->_parent->absX(),_clip->_parent->absY(),0,0},al_map_rgb(150,40,150),0);

                Draw::rect(_tileMap2D->getTileRect(_posMapX,_posMapY)+Rect{_clip->_parent->absX(),_clip->_parent->absY(),0,0},al_map_rgb(250,0,40),0);

                Draw::rect(_tileMap2D->getTileRect(_posMapX,_posMapY,24*2)+Rect{_clip->_parent->absX(),_clip->_parent->absY(),0,0},al_map_rgb(250,0,40),0);
            }


        }

}