189 lines
11 KiB
C++
189 lines
11 KiB
C++
#pragma once
|
|
|
|
#include <SDL3/SDL.h>
|
|
|
|
#include <array> // Para array
|
|
#include <memory> // Para shared_ptr, __shared_ptr_access
|
|
#include <string> // Para string
|
|
#include <utility>
|
|
#include <vector> // Para vector
|
|
|
|
#include "core/rendering/surface_animated_sprite.hpp" // Para SAnimatedSprite
|
|
#include "game/gameplay/room.hpp"
|
|
#include "utils/defines.hpp" // Para BORDER_TOP, BLOCK
|
|
#include "utils/utils.hpp" // Para Color
|
|
struct JA_Sound_t; // lines 13-13
|
|
|
|
class Player {
|
|
public:
|
|
// --- Enums y Structs ---
|
|
enum class State {
|
|
STANDING,
|
|
JUMPING,
|
|
FALLING,
|
|
};
|
|
|
|
enum class Direction {
|
|
LEFT,
|
|
RIGHT,
|
|
STAY
|
|
};
|
|
|
|
struct SpawnData {
|
|
float x = 0;
|
|
float y = 0;
|
|
float vx = 0;
|
|
float vy = 0;
|
|
int last_grounded_position = 0;
|
|
State state = State::STANDING;
|
|
SDL_FlipMode flip = SDL_FLIP_NONE;
|
|
|
|
// Constructor por defecto
|
|
SpawnData() = default;
|
|
|
|
// Constructor con parámetros
|
|
SpawnData(float x, float y, float vx, float vy, int last_grounded_position, State state, SDL_FlipMode flip)
|
|
: x(x),
|
|
y(y),
|
|
vx(vx),
|
|
vy(vy),
|
|
last_grounded_position(last_grounded_position),
|
|
state(state),
|
|
flip(flip) {}
|
|
};
|
|
|
|
struct Data {
|
|
SpawnData spawn_data;
|
|
std::string animations_path;
|
|
std::shared_ptr<Room> room = nullptr;
|
|
|
|
// Constructor por defecto
|
|
Data() = default;
|
|
|
|
// Constructor con parámetros
|
|
Data(SpawnData spawn_data, const std::string& texture_path, std::string animations_path, std::shared_ptr<Room> room)
|
|
: spawn_data(spawn_data),
|
|
animations_path(std::move(animations_path)),
|
|
room(std::move(room)) {}
|
|
};
|
|
|
|
// --- Constructor y Destructor ---
|
|
explicit Player(const Data& player);
|
|
~Player() = default;
|
|
|
|
// --- Funciones ---
|
|
void render(); // Pinta el enemigo en pantalla
|
|
void update(float delta_time); // Actualiza las variables del objeto
|
|
[[nodiscard]] auto isOnBorder() const -> bool { return is_on_border_; } // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
|
|
[[nodiscard]] auto getBorder() const -> Room::Border { return border_; } // Indica en cual de los cuatro bordes se encuentra
|
|
void switchBorders(); // Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
|
|
auto getRect() -> SDL_FRect { return {x_, y_, WIDTH, HEIGHT}; } // Obtiene el rectangulo que delimita al jugador
|
|
auto getCollider() -> SDL_FRect& { return collider_box_; } // Obtiene el rectangulo de colision del jugador
|
|
auto getSpawnParams() -> SpawnData { return {x_, y_, vx_, vy_, last_grounded_position_, state_, sprite_->getFlip()}; } // Obtiene el estado de reaparición del jugador
|
|
void setColor(); // Establece el color del jugador
|
|
void setRoom(std::shared_ptr<Room> room) { room_ = std::move(room); } // Establece la habitación en la que se encuentra el jugador
|
|
[[nodiscard]] auto isAlive() const -> bool { return is_alive_; } // Comprueba si el jugador esta vivo
|
|
void setPaused(bool value) { is_paused_ = value; } // Pone el jugador en modo pausa
|
|
|
|
private:
|
|
// --- Constantes ---
|
|
static constexpr int WIDTH = 8; // Ancho del jugador
|
|
static constexpr int HEIGHT = 16; // ALto del jugador
|
|
static constexpr int MAX_FALLING_HEIGHT = TILE_SIZE * 4; // Altura maxima permitida de caída en pixels
|
|
|
|
// --- Constantes de física (per-second values) ---
|
|
static constexpr float HORIZONTAL_VELOCITY = 40.0F; // Velocidad horizontal en pixels/segundo (0.6 * 66.67fps)
|
|
static constexpr float MAX_VY = 80.0F; // Velocidad vertical máxima en pixels/segundo (1.2 * 66.67fps)
|
|
static constexpr float JUMP_VELOCITY = -80.0F; // Velocidad inicial del salto en pixels/segundo
|
|
static constexpr float GRAVITY_FORCE = 155.6F; // Fuerza de gravedad en pixels/segundo² (0.035 * 66.67²)
|
|
|
|
// --- Constantes de sonido ---
|
|
static constexpr float SOUND_DISTANCE_INTERVAL = 3.0F; // Distancia en píxeles entre cada sonido de salto/caída
|
|
|
|
// --- --- Objetos y punteros --- ---
|
|
std::shared_ptr<Room> room_; // Objeto encargado de gestionar cada habitación del juego
|
|
std::unique_ptr<SurfaceAnimatedSprite> sprite_; // Sprite del jugador
|
|
|
|
// --- Variables de posición y física ---
|
|
float x_ = 0.0F; // Posición del jugador en el eje X
|
|
float y_ = 0.0F; // Posición del jugador en el eje Y
|
|
float y_prev_ = 0.0F; // Posición Y del frame anterior (para detectar hitos de distancia en sonidos)
|
|
float vx_ = 0.0F; // Velocidad/desplazamiento del jugador en el eje X
|
|
float vy_ = 0.0F; // Velocidad/desplazamiento del jugador en el eje Y
|
|
|
|
Direction wannaGo = Direction::STAY;
|
|
bool wannaJump = false;
|
|
|
|
// --- Variables de estado ---
|
|
State state_ = State::STANDING; // Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
|
|
State previous_state_ = State::STANDING; // Estado previo en el que se encontraba el jugador
|
|
|
|
// --- Variables de colisión ---
|
|
SDL_FRect collider_box_; // Caja de colisión con los enemigos u objetos
|
|
std::array<SDL_FPoint, 8> collider_points_{}; // Puntos de colisión con el mapa
|
|
std::array<SDL_FPoint, 2> under_feet_{}; // Contiene los puntos que hay bajo cada pie del jugador
|
|
std::array<SDL_FPoint, 2> feet_{}; // Contiene los puntos que hay en el pie del jugador
|
|
|
|
// --- Variables de juego ---
|
|
bool is_on_border_ = false; // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
|
|
bool is_alive_ = true; // Indica si el jugador esta vivo o no
|
|
bool is_paused_ = false; // Indica si el jugador esta en modo pausa
|
|
bool auto_movement_ = false; // Indica si esta siendo arrastrado por una superficie automatica
|
|
Room::Border border_ = Room::Border::TOP; // Indica en cual de los cuatro bordes se encuentra
|
|
int last_grounded_position_ = 0; // Ultima posición en Y en la que se estaba en contacto con el suelo (hace doble función: tracking de caída + altura inicial del salto)
|
|
|
|
// --- Variables de renderizado y sonido ---
|
|
Uint8 color_ = 0; // Color del jugador
|
|
std::vector<JA_Sound_t*> jumping_sound_; // Vecor con todos los sonidos del salto
|
|
std::vector<JA_Sound_t*> falling_sound_; // Vecor con todos los sonidos de la caída
|
|
|
|
void handleHorizontalMovement(float delta_time);
|
|
void handleVerticalMovement(float delta_time);
|
|
void handleConveyorBelts();
|
|
void handleShouldFall();
|
|
void updateState();
|
|
void moveAndCollide(float delta_time);
|
|
|
|
// --- Funciones de inicialización ---
|
|
void initSprite(const std::string& animations_path); // Inicializa el sprite del jugador
|
|
void initSounds(); // Inicializa los sonidos de salto y caida
|
|
void applySpawnValues(const SpawnData& spawn); // Aplica los valores de spawn al jugador
|
|
|
|
// --- Funciones de procesamiento de entrada ---
|
|
void handleInput(); // Comprueba las entradas y modifica variables
|
|
|
|
// --- Funciones de gestión de estado ---
|
|
void handleState(float delta_time); // Comprueba el estado del jugador y actualiza variables
|
|
void transitionToState(State value); // Cambia el estado del jugador
|
|
|
|
// --- Funciones de física ---
|
|
void applyGravity(float delta_time); // Aplica gravedad al jugador
|
|
|
|
// --- Funciones de movimiento y colisión ---
|
|
void move(float delta_time); // Orquesta el movimiento del jugador
|
|
void moveHorizontal(float delta_time, int direction); // Maneja el movimiento horizontal (-1: izq, 1: der)
|
|
void moveVerticalUp(float delta_time); // Maneja el movimiento vertical hacia arriba
|
|
void moveVerticalDown(float delta_time); // Maneja el movimiento vertical hacia abajo
|
|
void handleSlopeMovement(int direction); // Maneja el movimiento sobre rampas
|
|
|
|
// --- Funciones de detección de superficies ---
|
|
auto isOnFloor() -> bool; // Comprueba si el jugador tiene suelo debajo de los pies
|
|
auto isOnConveyorBelt() -> bool; // Comprueba si el jugador esta sobre una superficie automática
|
|
auto isOnDownSlope() -> bool; // Comprueba si el jugador está sobre una rampa hacia abajo
|
|
|
|
// --- Funciones de actualización de geometría ---
|
|
void updateColliderGeometry(); // Actualiza collider_box y collision points
|
|
void updateColliderPoints(); // Actualiza los puntos de colisión
|
|
void updateFeet(); // Actualiza los puntos de los pies
|
|
void placeSprite(); // Coloca el sprite en la posición del jugador
|
|
|
|
// --- Funciones de finalización ---
|
|
void animate(float delta_time); // Establece la animación del jugador
|
|
void handleBorders(); // Comprueba si se halla en alguno de los cuatro bordes
|
|
void handleJumpEnd(); // Comprueba si ha finalizado el salto al alcanzar la altura de inicio
|
|
auto handleKillingTiles() -> bool; // Comprueba que el jugador no toque ningun tile de los que matan
|
|
void playJumpSound(); // Calcula y reproduce el sonido de salto
|
|
void playFallSound(); // Calcula y reproduce el sonido de caer
|
|
void handleDeathByFalling(); // Gestiona la muerte al caer desde muy alto
|
|
void updateVelocity(); // Calcula la velocidad en x
|
|
}; |