jdd_opendingux/source/player.cpp

#include "player.h"
#include <fstream>
#include <sstream>

// CAUTION!!!!! si no se gasta al final, quitar la referencia a la habitación

// Constructor
Player::Player(player_t ini, std::string tileset, std::string animation, SDL_Renderer *renderer, Asset *asset, Input *input, Room *room)
{
    // Obten punteros a objetos
    this->asset = asset;
    this->renderer = renderer;
    this->input = input;

    // Crea objetos
    texture = new LTexture(renderer, asset->get(tileset));
    sprite = new AnimatedSprite(texture, renderer, animation);

    // Inicializa variables
    color = stringToColor("white");
    onBorder = false;
    border = BORDER_TOP;

    jump_ini = ini.jump_ini;
    status = ini.status;

    sprite->setPosX(ini.x);
    sprite->setPosY(ini.y);
    sprite->setVelX(ini.vx);
    sprite->setVelY(ini.vy);
    sprite->setWidth(8);
    sprite->setHeight(16);

    sprite->setFlip(ini.flip);

    lastPosition = getRect();
    collider = getRect();
}

// Destructor
Player::~Player()
{
    delete texture;
    delete sprite;
}

// Pinta el jugador en pantalla
void Player::render()
{
    sprite->getTexture()->setColor(color.r, color.g, color.b);
    sprite->render();
}

// Actualiza las variables del objeto
void Player::update()
{

    setLastPosition();    // Guarda la posición actual en la variable lastPosition
    checkInput();         // Comprueba las entradas y modifica variables
    move();               // Recalcula la posición del jugador y su animación
    checkBorders();       // Comprueba si está situado en alguno de los cuatro bordes de la habitación
    applyGravity();       // Aplica gravedad al jugador
    checkJump();          // Comprueba si ha finalizado el salto
    collider = getRect(); // Obtiene el rectangulo que delimita al jugador
}

// Comprueba las entradas y modifica variables
void Player::checkInput()
{
    // Solo comprueba las entradas de dirección cuando está de pie
    if ((input->checkInput(INPUT_LEFT, REPEAT_TRUE)) && (status == STATUS_STANDING))
    {
        sprite->setVelX(-0.6f);
        sprite->setFlip(SDL_FLIP_HORIZONTAL);
    }
    else if ((input->checkInput(INPUT_RIGHT, REPEAT_TRUE)) && (status == STATUS_STANDING))
    {
        sprite->setVelX(0.6f);
        sprite->setFlip(SDL_FLIP_NONE);
    }
    else if (status == STATUS_STANDING)
    {
        sprite->setVelX(0);
    }

    if (input->checkInput(INPUT_UP, REPEAT_TRUE))
    {
        setStatus(STATUS_JUMPING);
    }
}

// Indica si el jugador esta en uno de los cuatro bordes de la pantalla
bool Player::getOnBorder()
{
    return onBorder;
}

// Indica en cual de los cuatro bordes se encuentra
int Player::getBorder()
{
    return border;
}

// Comprueba si está situado en alguno de los cuatro bordes de la habitación
void Player::checkBorders()
{
    if (sprite->getPosX() < PLAY_AREA_LEFT)
    {
        border = BORDER_LEFT;
        onBorder = true;
    }
    else if (sprite->getPosX() > PLAY_AREA_RIGHT - sprite->getWidth())
    {
        border = BORDER_RIGHT;
        onBorder = true;
    }
    else if (sprite->getPosY() < PLAY_AREA_TOP)
    {
        border = BORDER_TOP;
        onBorder = true;
    }
    else if (sprite->getPosY() > PLAY_AREA_BOTTOM - sprite->getHeight())
    {
        border = BORDER_BOTTOM;
        onBorder = true;
    }
    else
    {
        onBorder = false;
    }
}

// Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
void Player::switchBorders()
{
    if (border == BORDER_TOP)
    {
        sprite->setPosY(PLAY_AREA_BOTTOM - sprite->getHeight() - 1);
        jump_ini += 128;
    }
    else if (border == BORDER_BOTTOM)
    {
        sprite->setPosY(PLAY_AREA_TOP + 1);
    }
    else if (border == BORDER_RIGHT)
    {
        sprite->setPosX(PLAY_AREA_LEFT + 1);
    }
    if (border == BORDER_LEFT)
    {
        sprite->setPosX(PLAY_AREA_RIGHT - sprite->getWidth() - 1);
    }

    onBorder = false;
}

// Obtiene el valor del pixel inferior izquierdo del jugador
SDL_Point Player::getLeftFoot()
{
    SDL_Point point = {(int)sprite->getPosX(), (int)sprite->getPosY() + sprite->getHeight()};
    return point;
}

// Obtiene el valor del pixel inferior derecho del jugador
SDL_Point Player::getRightFoot()
{
    SDL_Point point = {(int)sprite->getPosX() + sprite->getWidth() - 1, (int)sprite->getPosY() + sprite->getHeight()};
    return point;
}

// Cambia el estado del jugador
void Player::setStatus(int value)
{
    // Si quiere cambiar a saltando, ha de ser desde quieto
    if ((value == STATUS_JUMPING) && (status == STATUS_STANDING))
    {
        status = STATUS_JUMPING;
        sprite->setVelY(-MAX_VY);
        jump_ini = sprite->getPosY();
    }

    // Modifica el estado a 'cayendo'
    if (value == STATUS_FALLING)
    {
        status = STATUS_FALLING;
        sprite->setVelY(MAX_VY);
        sprite->setVelX(0);
    }

    // Modifica el estado a 'de pie'
    if (value == STATUS_STANDING)
    {
        status = STATUS_STANDING;
        sprite->setVelY(0.0f);
    }
}

// Obtiene el estado del jugador
int Player::getStatus()
{
    return status;
}

// Obtiene la velocidad en el eje Y del jugador
float Player::getVelY()
{
    return sprite->getVelY();
}

// Aplica gravedad al jugador
void Player::applyGravity()
{
    if (status == STATUS_JUMPING)
    {
        sprite->setVelY(sprite->getVelY() + GRAVITY);
        if (sprite->getVelY() > MAX_VY)
        {
            sprite->setVelY(MAX_VY);
        }
    }
}

// Obtiene el rectangulo que delimita al jugador
SDL_Rect Player::getRect()
{
    return sprite->getRect();
}

// Obtiene el rectangulo de colision del jugador
SDL_Rect &Player::getCollider()
{
    return collider;
}

// Guarda la posición actual en la variable lastPosition
void Player::setLastPosition()
{
    lastPosition = getRect();
}

// Deshace el ultimo movimiento
void Player::undoLastMove()
{
    sprite->setPosX(lastPosition.x);
    sprite->setPosY(lastPosition.y);
}

// Recalcula la posición del jugador y su animación
void Player::move()
{
    sprite->update();
    if (sprite->getVelX() != 0)
    {
        sprite->setCurrentAnimation("walk");
    }
    else
    {
        sprite->setCurrentAnimation("stand");
    }
}

// Comprueba si ha finalizado el salto
void Player::checkJump()
{
    if (status == STATUS_JUMPING)
        if (sprite->getVelY() > 0)
            if (sprite->getPosY() > jump_ini)
            {
                setStatus(STATUS_FALLING);
            }
}

// Obtiene algunos parametros del jugador
player_t Player::getSpawnParams()
{
    player_t params;

    params.x = sprite->getPosX();
    params.y = sprite->getPosY();
    params.vx = sprite->getVelX();
    params.vy = sprite->getVelY();
    params.jump_ini = jump_ini;
    params.status = status;
    params.flip = sprite->getFlip();

    return params;
}

// Recarga la textura
void Player::reLoadTexture()
{
    //texture->loadFromFile(asset->get(tileset), renderer);
}