Depurando los saltos con colisiones

source/const.h

@@ -29,9 +29,9 @@ const int VIEW_HEIGHT = SCREEN_HEIGHT * 3;
 
 // Zona de juego
 const int PLAY_AREA_TOP = (0 * BLOCK);
-const int PLAY_AREA_BOTTOM = GAMECANVAS_HEIGHT - (4 * BLOCK);
+const int PLAY_AREA_BOTTOM = (16 * BLOCK);
 const int PLAY_AREA_LEFT = (0 * BLOCK);
-const int PLAY_AREA_RIGHT = GAMECANVAS_WIDTH - (0 * BLOCK);
+const int PLAY_AREA_RIGHT = (32 * BLOCK);
 const int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT;
 const int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP;
 const int PLAY_AREA_CENTER_X = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2);
@@ -41,6 +41,11 @@ const int PLAY_AREA_CENTER_Y = PLAY_AREA_TOP + (PLAY_AREA_HEIGHT / 2);
 const int PLAY_AREA_FIRST_QUARTER_Y = PLAY_AREA_HEIGHT / 4;
 const int PLAY_AREA_THIRD_QUARTER_Y = (PLAY_AREA_HEIGHT / 4) * 3;
 
+#define BORDER_TOP 0
+#define BORDER_RIGHT 1
+#define BORDER_BOTTOM 2
+#define BORDER_LEFT 3
+
 // Anclajes de pantalla
 const int GAMECANVAS_CENTER_X = GAMECANVAS_WIDTH / 2;
 const int GAMECANVAS_FIRST_QUARTER_X = GAMECANVAS_WIDTH / 4;

source/director.cpp

@@ -200,6 +200,7 @@ void Director::setFileList()
 	mAsset->add("/data/room/02.room", room);
 	mAsset->add("/media/tilesets/room1.png", bitmap);
 	mAsset->add("/media/enemies/enemy01.png", bitmap);
+	mAsset->add("/media/player/player01.png", bitmap);
 }
 
 // Carga el fichero de configuración

source/game.cpp

@@ -9,8 +9,10 @@ Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang,
 	mLang = lang;
 	mInput = input;
 
+	// Crea los objetos
 	mScreen = new Screen(window, renderer);
 	mRoom = new Room(mAsset->get("01.room"), mRenderer, mAsset);
+	mPlayer = new Player(mAsset->get("player01.png"), mRenderer, mAsset, mInput, mRoom);
 	mEventHandler = new SDL_Event();
 	mTextureText = new LTexture();
 	mText = new Text(mAsset->get("smb2.txt"), mTextureText, renderer);
@@ -19,11 +21,13 @@ Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang,
 
 Game::~Game()
 {
+	// Borra las referencias a los punteros
 	mRenderer = nullptr;
 	mAsset = nullptr;
 	mLang = nullptr;
 	mInput = nullptr;
 
+	// Libera la memoria de los objetos
 	delete mEventHandler;
 	mEventHandler = nullptr;
 
@@ -37,6 +41,9 @@ Game::~Game()
 	delete mRoom;
 	mRoom = nullptr;
 
+	delete mRoom;
+	mRoom = nullptr;
+
 	delete mText;
 	mText = nullptr;
 
@@ -106,8 +113,11 @@ void Game::update()
 			}
 		}
 
-		checkInput();
 		mRoom->update();
+		mPlayer->update();
+		checkPlayerAndWalls(); // Debe ir detras del player update, por si se ha metido en algun muro, sacarlo
+		checkPlayerOnBorder();
+		checkPlayerOnFloor();
 	}
 }
 
@@ -115,22 +125,32 @@ void Game::update()
 void Game::draw()
 {
 	// Prepara para dibujar el frame
-	const color_t color = {0xAA, 0x55, 0x55};
 	mScreen->start();
-	mScreen->clean(color);
 	mScreen->clean(mRoom->getBGColor());
 
 	mRoom->drawMap();
 	mRoom->drawEnemies();
+	mPlayer->draw();
 
 	// Texto en el centro de la pantalla
-	mText->writeCentered(GAMECANVAS_CENTER_X, 18 * 8, mRoom->getName());
+	SDL_Rect rect = {0, 16 * 8, PLAY_AREA_RIGHT, 8};
+	color_t color = stringToColor("light_black");
+	SDL_SetRenderDrawColor(mRenderer, color.r, color.g, color.b, 0xFF);
+	SDL_RenderFillRect(mRenderer, &rect);
+
+	mText->writeCentered(GAMECANVAS_CENTER_X, 16 * 8, mRoom->getName());
+
+	// Debug info
+	std::string text;
+	text = "status: " + std::to_string(mPlayer->status);
+	mText->write(0, 17 * 8, text);
 
 	// Actualiza la pantalla
 	mScreen->blit();
 }
 
 // Comprueba la entrada
+/*
 void Game::checkInput()
 {
 if (mInput->checkInput(INPUT_UP, REPEAT_FALSE))
@@ -145,6 +165,7 @@ void Game::checkInput()
 if (mInput->checkInput(INPUT_RIGHT, REPEAT_FALSE))
 	changeRoom(mRoom->getRoomRight());
 }
+*/
 
 // Cambia de habitación
 bool Game::changeRoom(std::string file)
@@ -163,8 +184,67 @@ bool Game::changeRoom(std::string file)
 			// Crea un objeto habitación nuevo a partir del fichero
 			mRoom = new Room(mAsset->get(file), mRenderer, mAsset);
 
+			// Comunica al jugador la nueva referencia para la habitación
+			mPlayer->setRoom(mRoom);
+
 			success = true;
 		}
 
 	return success;
 }
+
+// Comprueba si el jugador esta en el borde de la pantalla
+void Game::checkPlayerOnBorder()
+{
+	if (mPlayer->getOnBorder())
+	{
+		changeRoom(mRoom->getRoom(mPlayer->getBorder()));
+		mPlayer->switchBorders();
+	}
+}
+
+// Comprueba si el jugador esta sobre el suelo
+void Game::checkPlayerOnFloor()
+{
+	// Comprueba ambos pies
+	if ((mRoom->isFloor(mPlayer->getLeftFoot())) || (mRoom->isFloor(mPlayer->getRightFoot())))
+	{
+		mPlayer->setStatus(STATUS_STANDING);
+	}
+	else
+	{
+		mPlayer->setStatus(STATUS_FALLING);
+	}
+}
+
+// Comprueba que el jugador no atraviese ninguna pared
+void Game::checkPlayerAndWalls()
+{
+	// Hayque comprobar las cuatro esquinas del tile superior
+	// y las cuatro del tile inferior
+	SDL_Rect rect = mPlayer->getRect();
+	SDL_Point p1 = {rect.x, rect.y};
+	SDL_Point p2 = {rect.x + 7, rect.y};
+	SDL_Point p3 = {rect.x + 7, rect.y + 7};
+	SDL_Point p4 = {rect.x, rect.y + 7};
+
+	SDL_Point p5 = {rect.x, rect.y + 8};
+	SDL_Point p6 = {rect.x + 7, rect.y + 8};
+	SDL_Point p7 = {rect.x + 7, rect.y + 15};
+	SDL_Point p8 = {rect.x, rect.y + 15};
+
+	bool test = mRoom->isFloor(p1);
+	test |= mRoom->isFloor(p2);
+	test |= mRoom->isFloor(p3);
+	test |= mRoom->isFloor(p4);
+	test |= mRoom->isFloor(p5);
+	test |= mRoom->isFloor(p6);
+	test |= mRoom->isFloor(p7);
+	test |= mRoom->isFloor(p8);
+
+	if (test)
+	{
+		mPlayer->undoLastMove();
+		// mPlayer->setStatus(STATUS_STANDING);
+	}
+}

source/game.h

@@ -2,7 +2,6 @@
 #include "ifdefs.h"
 #include "const.h"
 #include "utils.h"
-
 #include "sprite.h"
 #include "movingsprite.h"
 #include "text.h"
@@ -14,6 +13,7 @@
 #include "screen.h"
 #include "asset.h"
 #include "room.h"
+#include "player.h"
 #include "jail_audio.h"
 
 #ifndef GAME_H
@@ -27,6 +27,7 @@ private:
 	SDL_Event *mEventHandler; // Manejador de eventos
 	Screen *mScreen;		  // Objeto encargado de manejar el renderizador
 	Room *mRoom;			  // Objeto encargado de gestionar cada habitación del juego
+	Player *mPlayer;		  // Objeto con el jugador
 	Asset *mAsset;			  // Objeto con la ruta a todos los ficheros de recursos
 	Lang *mLang;			  // Objeto para gestionar los textos en diferentes idiomas
 	Input *mInput;			  // Objeto pata gestionar la entrada
@@ -49,12 +50,21 @@ private:
 	// Pinta los objetos en pantalla
 	void draw();
 
-	// Comprueba la entrada
+	// Comprueba la entrada y actua
-	void checkInput();
+	//void checkInput();
 
 	// Cambia de habitación
 	bool changeRoom(std::string file);
 
+	// Comprueba si el jugador esta en el borde de la pantalla y actua
+	void checkPlayerOnBorder();
+
+	// Comprueba si el jugador esta sobre el suelo
+	void checkPlayerOnFloor();
+
+	// Comprueba que el jugador no atraviese ninguna pared
+	void checkPlayerAndWalls();
+
 public:
 	// Constructor
 	Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang, Input *input);

source/movingsprite.cpp

@@ -30,9 +30,12 @@ void MovingSprite::clear()
 
 	mAngle = 0.0;		 // Angulo para dibujarlo
 	mRotate = false;	 // Indica si ha de rotar
+	mCenter = {0, 0};	 // Centro de rotación
 	mRotateSpeed = 0;	 // Velocidad de giro
 	mRotateAmount = 0.0; // Cantidad de grados a girar en cada iteración
 	mCounter = 0;		 // Contador interno
+
+	mFlip = SDL_FLIP_NONE; // Establece como se ha de voltear el sprite
 }
 
 // Iniciador
@@ -96,7 +99,7 @@ void MovingSprite::move()
 void MovingSprite::render()
 {
 	if (mEnabled)
-		mTexture->render(mRenderer, (int)mPosX, (int)mPosY, &mSpriteClip, mZoomW, mZoomH, mAngle);
+		mTexture->render(mRenderer, (int)mPosX, (int)mPosY, &mSpriteClip, mZoomW, mZoomH, mAngle, &mCenter, mFlip);
 }
 
 // Obtiene el valor de la variable
@@ -284,3 +287,9 @@ void MovingSprite::switchRotate()
 {
 	mRotateAmount *= -1;
 }
+
+// Establece el valor de la variable
+void MovingSprite::setFlip(SDL_RendererFlip flip)
+{
+	mFlip = flip;
+}

source/movingsprite.h

@@ -26,6 +26,8 @@ protected:
     Uint16 mRotateSpeed;    // Velocidad de giro
     double mRotateAmount;   // Cantidad de grados a girar en cada iteración
     Uint16 mCounter;        // Contador interno
+    SDL_Point mCenter;      // Centro de rotación
+    SDL_RendererFlip mFlip; // Indica como se voltea el sprite
 
 public:
     // Constructor
@@ -132,6 +134,9 @@ public:
 
     // Cambia el sentido de la rotación
     void switchRotate();
+
+    // Establece el valor de la variable
+    void setFlip(SDL_RendererFlip flip);
 };
 
 #endif

source/player.cpp

@@ -2,12 +2,16 @@
 #include <fstream>
 #include <sstream>
 
+// CAUTION!!!!! si no se gasta al final, quitar la referencia a la habitación
+
 // Constructor
-Player::Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset)
+Player::Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset, Input *_input, Room *_room)
 {
     // Obten punteros a objetos
     asset = _asset;
     renderer = _renderer;
+    input = _input;
+    room = _room;
 
     // Crea objetos
     texture = new LTexture();
@@ -18,6 +22,30 @@ Player::Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset)
 
     // Inicializa variables
     color = stringToColor("white");
+    onBorder = false;
+    border = BORDER_TOP;
+    status = STATUS_STANDING;
+
+    sprite->setPosX(2 * 8);
+    sprite->setPosX(10 * 8);
+    sprite->setPosY(12 * 8);
+    sprite->setPosY(6 * 8);
+    sprite->setVelX(0);
+    sprite->setVelY(0);
+    sprite->setWidth(8);
+    sprite->setHeight(16);
+    sprite->setCurrentFrame(0);
+    sprite->setAnimationCounter(0);
+    sprite->setAnimationNumFrames(0, 4);
+    sprite->setAnimationSpeed(0, 5);
+    sprite->setAnimationLoop(0, true);
+    sprite->setAnimationFrames(0, 0, 8 * 0, 0, 8, 16);
+    sprite->setAnimationFrames(0, 1, 8 * 1, 0, 8, 16);
+    sprite->setAnimationFrames(0, 2, 8 * 2, 0, 8, 16);
+    sprite->setAnimationFrames(0, 3, 8 * 3, 0, 8, 16);
+    sprite->setSpriteClip(sprite->getAnimationClip(0, 0));
+
+    lastPosition = getRect();
 }
 
 // Destructor
@@ -42,6 +70,179 @@ void Player::draw()
 // Actualiza las variables del objeto
 void Player::update()
 {
+    setLastPosition();
+    checkInput();
     sprite->update();
-    sprite->animate(0);
+    checkBorders();
+    applyGravity();
+}
+
+// Comprueba las entradas y modifica variables
+void Player::checkInput()
+{
+    // Se mueve en horizontal solo cuando no esté cayendo
+    if ((input->checkInput(INPUT_LEFT, REPEAT_TRUE)) && (status != STATUS_FALLING))
+    {
+        sprite->setVelX(-0.6f);
+        sprite->animate(0);
+        sprite->setFlip(SDL_FLIP_HORIZONTAL);
+    }
+    else if ((input->checkInput(INPUT_RIGHT, REPEAT_TRUE)) && (status != STATUS_FALLING))
+    {
+        sprite->setVelX(0.6f);
+        sprite->animate(0);
+        sprite->setFlip(SDL_FLIP_NONE);
+    }
+    else
+    {
+        sprite->setVelX(0);
+    }
+
+    if (input->checkInput(INPUT_UP, REPEAT_FALSE))
+    {
+        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
+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);
+    }
+    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;
+}
+
+// Establece el valor de la variable
+void Player::setRoom(Room *_room)
+{
+    room = _room;
+}
+
+// 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(-2.0f);
+    }
+
+    // Si se quiere cambiar a cayendo, ha de ser desde quieto
+    if ((value == STATUS_FALLING) && (status == STATUS_STANDING))
+    {
+        status = STATUS_FALLING;
+        sprite->setVelY(0.5f);
+    }
+
+    // Si se quiere cambiar a quieto, no hay resticciones
+    if (value == STATUS_STANDING)
+    {
+        status = STATUS_STANDING;
+        sprite->setVelY(0.0f);
+    }
+}
+
+// Aplica gravedad al jugador
+void Player::applyGravity()
+{
+    if (status == STATUS_JUMPING)
+    {
+        sprite->setVelY(sprite->getVelY() + 0.1f);
+        if (sprite->getVelY() > 0.5f)
+        {
+            sprite->setVelY(0.5f);
+            // status = STATUS_FALLING;
+        }
+    }
+}
+
+// Obtiene el rectangulo que delimita al jugador
+SDL_Rect Player::getRect()
+{
+    SDL_Rect rect = {(int)sprite->getPosX(), (int)sprite->getPosY(), sprite->getWidth(), sprite->getHeight()};
+    return rect;
+}
+
+// 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);
 }

source/player.h

@@ -1,28 +1,58 @@
 #pragma once
 #include "ifdefs.h"
+#include "const.h"
 #include "utils.h"
 #include "asset.h"
+#include "room.h"
 #include "animatedsprite.h"
+#include "input.h"
 #include <string>
 
 #ifndef PLAYER_H
 #define PLAYER_H
 
+//#define VX 0.6
+#define STATUS_STANDING 0
+#define STATUS_JUMPING 1
+#define STATUS_FALLING 2
+
 // Clase Player
 class Player
 {
 private:
 	LTexture *texture;		// Textura con los graficos del enemigo
 	AnimatedSprite *sprite; // Sprite del enemigo
+	Input *input;			// Objeto para gestionar la entrada
+	Room *room;				// Objeto con el mapa del juego
 
 	SDL_Renderer *renderer; // El renderizador de la ventana
 	Asset *asset;			// Objeto con la ruta a todos los ficheros de recursos
 	color_t color;			// Color del jugador
+	SDL_Rect lastPosition;	// Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento
 
+	bool onBorder; // 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
+
+	// Comprueba las entradas y modifica variables
+	void checkInput();
+
+	// Comprueba si se halla en alguno de los cuatro bordes
+	void checkBorders();
+
+	// Asigna velocidad negativa en el eje Y al jugador
+	void jump();
+
+	// Aplica gravedad al jugador
+	void applyGravity();
+
+	// Guarda la posición actual en la variable lastPosition
+	void setLastPosition();
 
 public:
+	int status;				// Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
+
 	// Constructor
-	Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset);
+	Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset, Input *_input, Room *_room);
 
 	// Destructor
 	~Player();
@@ -32,6 +62,33 @@ public:
 
 	// 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();
+
+	// Establece el valor de la variable
+	void setRoom(Room *_room);
+
+	// Obtiene el valor del pixel inferior izquierdo del jugador
+	SDL_Point getLeftFoot();
+
+	// Obtiene el valor del pixel inferior derecho del jugador
+	SDL_Point getRightFoot();
+
+	// Cambia el estado del jugador
+	void setStatus(int value);
+
+	// Obtiene el rectangulo que delimita al jugador
+	SDL_Rect getRect();
+
+	// Deshace el ultimo movimiento
+	void undoLastMove();
 };
 
 #endif

source/room.cpp

@@ -281,26 +281,45 @@ void Room::update()
     }
 }
 
-// Devuelve el valor de la variable
+// Devuelve la cadena del fichero de la habitación contigua segun el borde
-std::string Room::getRoomUp()
+std::string Room::getRoom(int border)
 {
+    switch (border)
+    {
+    case BORDER_TOP:
         return room_up;
-}
+        break;
 
-// Devuelve el valor de la variable
+    case BORDER_BOTTOM:
-std::string Room::getRoomDown()
-{
         return room_down;
-}
+        break;
 
-// Devuelve el valor de la variable
+    case BORDER_RIGHT:
-std::string Room::getRoomLeft()
-{
-    return room_left;
-}
-
-// Devuelve el valor de la variable
-std::string Room::getRoomRight()
-{
         return room_right;
+        break;
+
+    case BORDER_LEFT:
+        return room_left;
+        break;
+
+    default:
+        break;
+    }
+    return "";
+}
+
+// Indica si el tile al que pertenece el pixel es sólido o no
+bool Room::isFloor(SDL_Point point)
+{
+    int tile = ((point.y / 8) * 32) + (point.x / 8);
+    
+    if (tile < 512)
+    {
+        if (tilemap[tile] != 0)
+        {
+            return true;
+        }
+    }
+
+    return false;
 }

source/room.h

@@ -78,17 +78,11 @@ public:
 	// Actualiza las variables y objetos de la habitación
 	void update();
 
-	// Devuelve el valor de la variable
+	// Devuelve la cadena del fichero de la habitación contigua segun el borde
-	std::string getRoomUp();
+	std::string getRoom(int border);
 
-	// Devuelve el valor de la variable
+	// Indica si el tile al que pertenece el pixel es sólido o no
-	std::string getRoomDown();
+	bool isFloor(SDL_Point point);
-
-	// Devuelve el valor de la variable
-	std::string getRoomLeft();
-
-	// Devuelve el valor de la variable
-	std::string getRoomRight();
 };
 
 #endif