SDL / Estado Jugar

Bienvenidos sean a este post, hoy trabajaremos con otro de los estados.

En el post anterior completamos el estado encargado de manejar el menu pero hoy haremos un estado para Jugar. Para ello, necesitaremos el codigo que estuvimos trabajando. Sino lo poseen, les dejo el link para descargarlo:

Proyecto Juego

Descarguen el archivo y extraigan el contenido en el PC. Lo unico que deben hacer es revincular a SDL y SDL_Image. Para ello, les recomiendo este post donde comento como hacerlo para SDL y este otro post donde hago lo mismo para SDL_Image. Una vez que este todo funcionando correctamente, podemos continuar.

Antes de comenzar descarguen el siguiente archivo correspondiente a la nueva lamina de sprites para el jugador:

Una vez descargado procedan a copiarlo dentro de la carpeta assets de nuestro proyecto. Con esto realizado, pasemos a nuestro codigo y para ello iremos a la clase Jugador y modificaremos la funcion manejaEntrada y eliminen o comenten todo el contenido en la funcion y agreguen el siguiente:

void Jugador::manejaEntrada(){
	Vector2D* destino = Controles::instanciar()->getPosicionMouse();
	m_velocidad = *destino - m_posicion;
	m_velocidad /= 50;
}

Primero crearemos un objeto de tipo Vector2D que llamaremos destino para almacenar la ubicacion actual de nuestro mouse gracias a la funcion getPosicionMouse. Despues, estableceremos el valor de m_velocidad mediante la diferencia entre destino y m_posicion. Por ultimo, dividiremos el valor de m_velocidad por 50 para disminuir un poco el desplazamiento del jugador siguiendo al mouse. Nuestro siguiente paso sera ir a la clase EstadoJugar. Primero, iremos al archivo de encabezado y agregaremos las siguientes librerias:

#include <vector>
#include "ObjetoJuego.h"
#include "ManejarTexturas.h"
#include "Juego.h"

En su parte privada agregaremos la siguiente coleccion:

std::vector<ObjetoJuego*> m_objetosJuego;

Esta servira para almacenar todos los objetos que generemos con la clase EstadoJugar. Con esto realizado, nuestro siguiente paso sera modificar a EstadoJugar.cpp donde definiremos las funciones que estaban en blanco y redefiniremos a enIngreso y enSalida. Para ello, modificaremos al archivo de la siguiente manera:

EstadoJugar.cpp

#include "EstadoJugar.h"
#include <Windows.h>

const std::string EstadoJugar::e_idjugar = "JUGAR";

void EstadoJugar::actualizar() {
	for (int i = 0; i < m_objetosJuego.size(); i++)
		m_objetosJuego[i]->actualizar();
}

void EstadoJugar::renderizar() {
	for (int i = 0; i < m_objetosJuego.size(); i++)
		m_objetosJuego[i]->dibujar();
}

bool EstadoJugar::enIngreso() {
	if (!Elmanejador::instanciar()->cargar("assets/helicoptero.png",
		"helicoptero", Eljuego::instanciar()->getRenderer()))
	{
		return false;
	}

	ObjetoJuego* jugador = new Jugador(new CargadorParams(100,
		100, 128, 55, "helicoptero"));
	m_objetosJuego.push_back(jugador);

	OutputDebugStringA("Ingresando al Estado de jugar\n");
	return true;
}

bool EstadoJugar::enSalida() {
	for (int i = 0; i < m_objetosJuego.size(); i++)
		m_objetosJuego[i]->limpiar();

	m_objetosJuego.clear();
	Elmanejador::instanciar()->limpiaMapaTexturas("helicoptero");

	OutputDebugStringA("Saliendo del Estado de jugar\n");
	return true;
}

std::string EstadoJugar::getIdEstado() const { return e_idjugar; }

Si lo observan, las funciones actualizar, renderizar, enIngreso y enSalida son muy similares a EstadoMenu. Porque en la funcion enIngreso tenemos un condicional que verifica si no se cargo la imagen del jugador y procede a salir de la funcion de lo contrario crea el objeto y despues lo agrega en m_objetosJuego como hace Menu y enSalida hace exactamente lo mismo. Inclusive ya eliminando la textura del jugador. Tan solo nos resta una modificacion mas para dejar esto de forma espectacular.

Esta ultima modificacion sera en SDLObjetoJuego y la haremos en la funcion dibujar, veamos su codigo actual:

void SDLObjetoJuego::dibujar() {
	ManejarTexturas::instanciar()->dibujar_frame(m_idTextura,
		m_posicion.getX(), m_posicion.getY(), m_ancho, m_alto,
		m_filaActual, m_frameActual, Eljuego::instanciar()->getRenderer());
}

Y lo reemplazaremos por el siguiente:

void SDLObjetoJuego::dibujar() {
	if (m_velocidad.getX() > 0){
		ManejarTexturas::instanciar()->dibujar_frame(m_idTextura,
			(Uint32)m_posicion.getX(),
			(Uint32)m_posicion.getY(),
			m_ancho, m_alto, m_filaActual, m_frameActual,
			Eljuego::instanciar()->getRenderer(),
			SDL_FLIP_HORIZONTAL);
	}
	else {
		ManejarTexturas::instanciar()->dibujar_frame(m_idTextura,
			(Uint32)m_posicion.getX(),
			(Uint32)m_posicion.getY(),
			m_ancho, m_alto, m_filaActual, m_frameActual,
			Eljuego::instanciar()->getRenderer());
	}
}

Tecnicamente hicimos unos sutiles cambios, el primero fue agregar un condicional que verifica si el valor obtenido por getX es mayor a 0 usaremos a dibujar_frame pero al final agregamos la constante SDL_FLIP_HORIZONTAL. Esto hara que nuestra imagen se invierta, en caso contrario utilizaremos el dibujar_frame que usabamos antes, la unica diferencia es que en lugar de usar a int ahora utilizamos Uint32 para castear los valores de getX y getY. Esto lo hacemos simplemente para que pueda manejar de mejor forma valores mas grandes que los de tipo int. Ya podemos compilarlo y ver como funciona mediante el siguiente video

En el video podemos ver como ahora tambien podemos pasar al estado Jugar y este nos genera el objeto del jugador, en este caso un helicoptero, y vemos como lo controlamos con el mouse.

En resumen, hoy hemos visto como implementar el estado jugar, hemos visto que tecnicamente es muy similar a EstadoMenu, trabaja de forma similar, con muy sutiles diferencias pero muy parecidas, despues vimos una pequeña modificacion para poder hacer que nuestras imagenes creadas por dibujar de SDLObjetoJuego hagan un efecto de espejo e inviertan la imagen sin muchos cambios.. Espero les haya sido de utilidad y les dejo un link a GitHub donde estan los codigos creados hoy:

Estado Jugar / GitHub

Les dejo algunas de mis redes sociales para seguirme o recibir una notificacion cada vez que subo un nuevo post: