Player.h

#pragma once
#include <string>
#include <vector>

#include "Sprite.h"

class Player
{
public:
    Player(SDL_Renderer *renderer, int x, int y);
    ~Player();

    void Draw(SDL_Renderer *renderer);
    void Update();

    void StartMove();
    void StopMove();
    void ResetMove();

    void Jump();
    void StartJump(int value);
    void resetJump();

    void MoveAnimation();

    void UpdatePosX(int moveSpeed);
    void UpdatePosY(int moveSpeed);

    bool getMove();

    bool getChangeDirection();
    void setChangeDirection();

    void setMoveDirection(bool value);
    bool getMoveDirection();

    int getMoveSpeed();
private:

    std::vector<Sprite*> p;
    int spriteID;
    unsigned int moveAnimationTime;

    float posX, posY;
    int numOfLives;
    int health;

//----------move-------------
    bool moveDir;
    bool Move;
    bool changeMoveDir;
    bool newMoveDir;

    static const int maxMoveSpeed = 4;
    int currentMoveSpeed;
    int moveSpeed;
    unsigned int passedTime;
//---------------------------
//----------Jump-------------
    int jumpState;

    float startJumpSpeed;
    float currentJumpSpeed;
    float jumpDistance;
    float currentJumpDistance;

    float currentFallingSpeed;

    bool springJump;
//---------------------------

    void movePlayer();
    void setSpriteID(int id);
};

///////////////////////////////////////////////////////////////////
player.cpp

#include "Player.h"

Player::Player(SDL_Renderer *renderer, int x, int y)
{
    this->posX = x;
    this->posY = y;
    this->numOfLives = 3;
    this->health = 100;
    this->moveAnimationTime = 0;

    this->spriteID = 0;

    this->moveDir = true;
    this->Move = false;
    this->changeMoveDir = false;

    this->currentMoveSpeed = 4;
    this->moveSpeed = 0;
    this->passedTime = SDL_GetTicks();

    this->jumpState = 0;
    this->startJumpSpeed = 8;

    this->currentFallingSpeed = 3;

    this->springJump = false;

    std::vector<std::string> tempS;
    std::vector<unsigned int> tempI;
//------------------ 1 ------------------------
    tempS.push_back("Player/playerRight1");
    tempI.push_back(0);
    p.push_back(new Sprite(tempS, tempI, renderer));
    tempS.clear();
//------------------ 2 ------------------------
    tempS.push_back("Player/playerRight2");
    tempI.push_back(0);
    p.push_back(new Sprite(tempS, tempI, renderer));
    tempS.clear();
//------------------ 3 ------------------------
    tempS.push_back("Player/playerRight3");
    tempI.push_back(0);
    p.push_back(new Sprite(tempS, tempI, renderer));
    tempS.clear();
//------------------ 4 ------------------------
    tempS.push_back("Player/playerLeft1");
    tempI.push_back(0);
    p.push_back(new Sprite(tempS, tempI, renderer));
    tempS.clear();
//------------------ 5 ------------------------
    tempS.push_back("Player/playerLeft2");
    tempI.push_back(0);
    p.push_back(new Sprite(tempS, tempI, renderer));
    tempS.clear();
//------------------ 6 ------------------------
    tempS.push_back("Player/playerLeft3");
    tempI.push_back(0);
    p.push_back(new Sprite(tempS, tempI, renderer));
    tempS.clear();

}

Player::~Player()
{
    for (std::vector<Sprite*>::iterator i = p.begin(); i != p.end(); i++)
    {
        delete (*i);
    }
}

void Player::Draw(SDL_Renderer *renderer)
{
    p[spriteID]->getTexture()->Draw(posX, posY, renderer);
}

void Player::Update()
{
    movePlayer();
}

void Player::movePlayer()
{
    if (Move && !changeMoveDir)
    {
        if (moveSpeed > currentMoveSpeed)
        {
            --moveSpeed;
        }
        else if (SDL_GetTicks() - moveSpeed >= passedTime && moveSpeed < currentMoveSpeed)
        {
            ++moveSpeed;
            passedTime = SDL_GetTicks();
        }
        else if (moveSpeed == 0)
        {
            moveSpeed = 1;
        }
    }
    else
    {
        if (changeMoveDir && moveSpeed <= 1)
        {
            moveDir = newMoveDir;
            changeMoveDir = false;
            Move = true;
        }
    }

    if (moveSpeed > 0)
    {
        if (moveDir)
        {
            UpdatePosX(moveSpeed);
        }
        else
        {
            UpdatePosX(-moveSpeed);
        }

        if (!changeMoveDir && jumpState == 0 && Move)
        {
            MoveAnimation();
        }
    }
    else if (jumpState == 0)
    {
        setSpriteID(0);
        UpdatePosX(0);
    }
    else
    {
        UpdatePosX(0);
    }
}
void Player::StartMove()
{
    moveAnimationTime = SDL_GetTicks();
    passedTime = SDL_GetTicks();
    moveSpeed = 1;
    Move = true;
}
void Player::StopMove()
{
    moveSpeed = 0;
    Move = false;
    changeMoveDir = false;
    setSpriteID(0);
}
void Player::ResetMove()
{
    moveSpeed--;
    Move = false;
}

void Player::Jump()
{
    if (jumpState == 0)
    {
        StartJump(5);
    }
}
void Player::StartJump(int value)
{
    currentJumpSpeed = startJumpSpeed;
    jumpDistance = 32 * value;
    currentJumpDistance = 0;
    setSpriteID(0);

    jumpState = 1;
}
void Player::resetJump()
{
    jumpState = 0;
    jumpDistance = 0;
    currentJumpDistance = 0;
    currentJumpSpeed = 3;
}

void Player::UpdatePosX(int moveSpeed)
{
    if (moveSpeed > 0)
    {
        posX += moveSpeed;
    }
    else if (moveSpeed<0)
    {
        posX += moveSpeed;
    }
}
void Player::UpdatePosY(int moveSpeed)
{
    if (moveSpeed > 0)
    {
        posY += moveSpeed;
    }
    else if (moveSpeed < 0)
    {
        posY += moveSpeed;
    }
}

void Player::MoveAnimation()
{
    if (SDL_GetTicks() + moveSpeed > moveAnimationTime)
    {
        moveAnimationTime = SDL_GetTicks();
        if (spriteID >= 2)
        {
            setSpriteID(2);
        }
        else
        {
            ++spriteID;
        }
    }
}

void Player::setSpriteID(int id)
{
    spriteID = id;
}

bool Player::getMove()
{
    return Move;
}
bool Player::getChangeDirection()
{
    return changeMoveDir;
}
void Player::setChangeDirection()
{
    changeMoveDir = true;
    this->newMoveDir = !moveDir;
}
void Player::setMoveDirection(bool value)
{
    this->moveDir = value;
}
bool Player::getMoveDirection()
{
    return moveDir;
}
int Player::getMoveSpeed()
{
    return moveSpeed;
}