SDL / Velocidad y Aceleracion

Bienvenidos sean a este post, hoy veremos la primera aplicacion de los vectores.

Hasta el post anterior, convertimos a dos parametros independientes en un solo objeto o vector y esto nos facilitara como poder manejar su velocidad y aceleracion.

Como dijimos cambiamos los parametros de los ejes en uno solo y nosotros podemos incrementar a este con otro vector al cual podemos denominar velocidad y podemos considerarlo como una cantidad para moverlo en una sola direccion, su formula sera similar a esta:

posicion_vector+velocidad_vector=(posicionX + velocidadX, posicionY + velocidadY)

Donde el incremento de los dos vectores es al incremento de los ejes del vector en base a los valores de los ejes del vector de velocidad. Esto deberemos agregarlo a SDLObjetoJuego para que todos los objetos herederos se actualicen de la misma forma.

Para ello, necesitamos del codigo generado hasta ahora. Sino lo poseen les dejo un 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. Vamos a poner manos a la obra, iremos a SDLObjetoJuego.h y en la parte protegida de la clase agregaremos la siguiente linea:

Vector2D m_velocidad;

Nuestra siguiente modificacion sera en SDLObjetoJuego.cpp, nuestra primera modificacion sera cambiar la definicion del constructor de la siguiente manera:

SDLObjetoJuego::SDLObjetoJuego(const CargadorParams* pParams): 
	ObjetoJuego(pParams), 
	m_posicion((float)pParams->getX(), (float)pParams->getY()),
	m_velocidad(0,0) {
	m_ancho = pParams->getAncho();
	m_alto = pParams->getAlto();
	m_idTextura = pParams->getIdTextura();
	m_frameActual = 1;
	m_filaActual = 1;
}

En este caso tal como vimos en el post anterior vamos a iniciar a nuestra nueva variable miembro (m_velocidad) pero para la ocasion le enviaremos dos datos fijos. El resto del codigo sigue siendo el mismo. La siguiente modificacion sera en la funcion actualizar de SDLObjetoJuego.cpp donde la modificaremos de la siguiente manera:

void SDLObjetoJuego::actualizar(){
	m_posicion += m_velocidad;
}

Nuestra funcion paso de estar vacia a incrementar el valor de la posicion (m_posicion) en base a la velocidad que le informamos, la siguiente modificacion sera en la funcion actualizar del jugador donde modificaremos la funcion de la siguiente manera:

void Jugador::actualizar() {
	m_frameActual = int(((SDL_GetTicks() / 100) % 6));
	m_velocidad.setX(1);
	SDLObjetoJuego::actualizar();
}

En esta ocasion volvimos a la funcion anterior donde actualizaremos a m_frameActual para recrear la animacion. Luego estableceremos el valor del eje X para el vector de velocidad, y el ultimo paso sera llamar al metodo actualizar pero de SDLObjetoJuego. Esto es para hacer el incremento de m_posicion y hacer el efecto de desplazamiento. Solo nos resta una modificacion mas, y para ello debemos ir a la funcion iniciar en Juego.cpp donde debemos modificar el siguiente bloque:

    m_objetosJuego.push_back(new Jugador(
        new CargadorParams(300, 100, 128, 82, "animado")));

De la siguiente manera:

    m_objetosJuego.push_back(new Jugador(
        new CargadorParams(50, 100, 128, 82, "animado")));

Modificamos desde donde va a colocar la imagen para poder ver mejor el desplazamiento porque de lo contrario desaparecera inmediatamente, compilemos y probemos mediante el siguiente video

Como pueden ver en el video tenemos de nuevo un sprite animado y que se desplaza en sentido horizontal por nuestra pantalla y todo con vectores, pasemos a nuestro siguiente tema.

Tanto en la vida real como en los video juegos nadie inicia con la velocidad final y de manera constante sino que necesitamos que esta se incremente paulatinamente y aqui entra en accion la aceleracion. Para poder lograr esto debemos ir nuevamente a SDLObjetoJuego.h y en la parte protegida debemos crear la siguiente variable:

Vector2D m_aceleracion;

Lo siguiente sera modificar nuevamente el encabezado del constructor de SDLObjetoJuego para que inicie a nuestra nueva variable miembro:

SDLObjetoJuego::SDLObjetoJuego(const CargadorParams* pParams): 
	ObjetoJuego(pParams), 
	m_posicion((float)pParams->getX(), (float)pParams->getY()),
	m_velocidad(0,0), m_aceleracion(0,0) {
	m_ancho = pParams->getAncho();
	m_alto = pParams->getAlto();
	m_idTextura = pParams->getIdTextura();
	m_frameActual = 1;
	m_filaActual = 1;
}

El resto del codigo sigue siendo el mismo. La siguiente modificacion le haremos en la funcion actualizar de SDLObjetoJuego.cpp:

void SDLObjetoJuego::actualizar(){
	m_velocidad += m_aceleracion;
	m_posicion += m_velocidad;
}

En este caso m_posicion se sigue incrementando con m_velocidad pero ahora m_velocidad se incrementara con el valor informado en m_aceleracion, nuestra ultima modificacion sera en la funcion actualizar pero de Jugador.cpp:

void Jugador::actualizar() {
	m_frameActual = int(((SDL_GetTicks() / 100) % 6));
	m_aceleracion.setX(1);
	SDLObjetoJuego::actualizar();
}

Cual es la unica diferencia con respecto al codigo anterior? En lugar de setear el valor de X de m_velocidad ahora lo haremos en m_aceleracion y al llamar a actualizar de SDLObjetoJuego hara el incremento de velocidad visto anteriormente. Con esto tenemos todo listo para volver a probar a nuestro «juego» , compilemos y veamos que sucede mediante el siguiente video

Como pueden observar ahora nuestro sprite se movio pero demasiado rapido, vamos a hacer una pequeña modificacion en la funcion actualizar de Jugador donde cambiaremos esta linea:

m_aceleracion.setX(1);

Por esta otra linea:

m_aceleracion.setX(0.1f);

Esto producira que haga un incremento un poco mas pequeño dando un mejor efecto de aceleracion, si se preguntan porque la f? Es para decirle al compilador que es de tipo float y no double, esto nos evitara notificaciones de error y algunos posibles fallos de compilacion. Compilemos nuevamente y veamos que sucede mediante el siguiente video

Con esto ya tenemos una mejor forma de desplazarnos por medio de vectores, tenemos un factor para la velocidad y otro para controlar la forma de como se incrementa esa velocidad.

En resumen, hoy hemos visto como agregar dos factores fisicos que afectan a nuestros juegos como son la velocidad y la aceleracion, hemos agregado un vector para la velocidad y como con este vector hemos afectado el movimiento de nuestro sprite y tambien vimos como las sobrecarga de nuestros operadores funcionaron correctamente, lo mismo hemos hecho con la aceleracion pero en este caso para ajustar el incremento de la velocidad. Espero les haya sido de utilidad y les dejo un link a GitHub donde estan los codigos creados hoy:

Velocidad y aceleracion / GitHub

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