jaildoctors_dilemma/source/player.h

#pragma once

#include <SDL2/SDL_rect.h>	 // Para SDL_Rect, SDL_Point
#include <SDL2/SDL_render.h> // Para SDL_Renderer
#include <string>			 // Para basic_string, string
#include <vector>			 // Para vector
#include <memory>			 // Para shared_ptr
#include "utils.h"			 // Para color_t
#include "defines.h"		 // Para BLOCK
#include "room.h"
class AnimatedSprite;
class Asset;
class Debug;
class Input;
class Resource;
class Room;
struct JA_Sound_t;

enum state_e
{
	s_standing,
	s_jumping,
	s_falling
};

struct playerSpawn_t
{
	float x;
	float y;
	float vx;
	float vy;
	int jump_init_pos;
	state_e state;
	SDL_RendererFlip flip;
};

struct player_t
{
	playerSpawn_t spawn;
	std::string png;
	std::string animation;
	std::shared_ptr<Room> room;
};

class Player
{
public:
	// Constantes
	static constexpr int MAX_FALLING_HEIGHT_ = BLOCK * 4; // Altura maxima permitida de caída.
	static constexpr float MAX_VY_ = 1.2f;				  // Velocidad máxima que puede alcanzar al desplazarse en vertical

	// Objetos y punteros
	SDL_Renderer *renderer_;				 // El renderizador de la ventana
	Input *input_;							 // Objeto para gestionar la entrada
	Resource *resource_;					 // Objeto con los recursos
	Asset *asset_;							 // Objeto con la ruta a todos los ficheros de recursos
	Debug *debug_;							 // Objeto para gestionar la información de debug
	std::shared_ptr<Room> room_;			 // Objeto encargado de gestionar cada habitación del juego
	std::shared_ptr<AnimatedSprite> sprite_; // Sprite del jugador

	// Variables
	float x_;								  // Posición del jugador en el eje X
	float y_;								  // Posición del jugador en el eje Y
	float vx_;								  // Velocidad/desplazamiento del jugador en el eje X
	float vy_;								  // Velocidad/desplazamiento del jugador en el eje Y
	int w_;									  // Ancho del jugador
	int h_;									  // ALto del jugador
	Color color_;							  // Color del jugador
	SDL_Rect collider_box_;					  // Caja de colisión con los enemigos u objetos
	std::vector<SDL_Point> collider_points_;  // Puntos de colisión con el mapa
	std::vector<SDL_Point> under_feet_;		  // Contiene los puntos que hay bajo cada pie del jugador
	std::vector<SDL_Point> feet_;			  // Contiene los puntos que hay en el pie del jugador
	state_e state_;							  // Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
	state_e previous_state_;				  // Estado previo en el que se encontraba el jugador
	bool is_on_border_;						  // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
	int border_;							  // Indica en cual de los cuatro bordes se encuentra
	bool auto_movement_;					  // Indica si esta siendo arrastrado por una superficie automatica
	bool is_paused_;						  // Indica si el jugador esta en modo pausa
	SDL_Rect last_position_;				  // Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento
	int jump_init_pos_;						  // Valor del eje Y en el que se inicia el salto
	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
	int jumping_counter_;					  // Cuenta el tiempo de salto
	int falling_counter_;					  // Cuenta el tiempo de caida
	bool is_alive_;							  // Indica si el jugador esta vivo o no

#ifdef DEBUG
	SDL_Rect rx;		  // Rectangulo de desplazamiento para el modo debug
	SDL_Rect ry;		  // Rectangulo de desplazamiento para el modo debug
	Color debugColor;	  // Color del recuadro de debug del jugador
	SDL_Point debugPoint; // Punto para debug
#endif

	// Comprueba las entradas y modifica variables
	void checkInput();

	// Comprueba si se halla en alguno de los cuatro bordes
	void checkBorders();

	// Comprueba el estado del jugador
	void checkState();

	// Asigna velocidad negativa en el eje Y al jugador
	void jump();

	// Aplica gravedad al jugador
	void applyGravity();

	// Recalcula la posición del jugador y su animación
	void move();

	// Establece la animación del jugador
	void animate();

	// Comprueba si ha finalizado el salto al alcanzar la altura de inicio
	void checkJumpEnd();

	// Calcula y reproduce el sonido de salto
	void playJumpSound();

	// Calcula y reproduce el sonido de caer
	void playFallSound();

	// Comprueba si el jugador tiene suelo debajo de los pies
	bool isOnFloor();

	// Comprueba si el jugador esta sobre una superficie automática
	bool isOnAutoSurface();

	// Comprueba si el jugador está sobre una rampa hacia abajo
	bool isOnDownSlope();

	// Comprueba que el jugador no toque ningun tile de los que matan
	bool checkKillingTiles();

	// Actualiza los puntos de colisión
	void updateColliderPoints();

	// Actualiza los puntos de los pies
	void updateFeet();

	// Cambia el estado del jugador
	void setState(state_e value);

public:
	// Constructor
	Player(player_t player);

	// Destructor
	~Player() = default;

	// Pinta el enemigo en pantalla
	void render();

	// Actualiza las variables del objeto
	void update();

	// Indica si el jugador esta en uno de los cuatro bordes de la pantalla
	bool getOnBorder();

	// Indica en cual de los cuatro bordes se encuentra
	int getBorder();

	// Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
	void switchBorders();

	// Obtiene el rectangulo que delimita al jugador
	SDL_Rect getRect();

	// Obtiene el rectangulo de colision del jugador
	SDL_Rect &getCollider();

	// Obtiene algunos parametros del jugador
	playerSpawn_t getSpawnParams();

	// Recarga la textura
	void reLoadTexture();

	// Recarga la paleta
	void reLoadPalette();

	// Establece el valor de la variable
	void setRoom(std::shared_ptr<Room> room);

	// Comprueba si el jugador esta vivo
	bool isAlive();

	// Pone el jugador en modo pausa
	void pause();

	// Quita el modo pausa del jugador
	void resume();
};