En la entrada
animación 2D escribimos un programa muy sencillo que simulaba un circulo que rebotaba en los limites de la ventana que creamos en SFML como muestra la Pantalla 1 y el movimiento del circulo se ilustra en la parte izquierda de la figura A . Basado en el mismo principio y en el algoritmo convertimos en un programa, vamos a desarrollar un juego tipo
Arkanoid muy sencillo en C++ y SFML conservando los limites
derecho,superior e izquierdo, como lo muestra la pantalla 1 y dejamos el limite inferior o piso en control del usuario, para ello colocamos un pequeño rectángulo que el usuario puede mover hacia la derecha o izquierda y evitar que la pelota caiga al vacío como lo muestra la Pantalla 2 y la parte derecha de la figura A.
Como vemos en la Figura A el circulo se va a mover de manera autónoma entre los limites izquierdo-derecho-superior, incrementando o disminuyendo el valor de su coordenadas x, y dependiendo del limite donde se encuentre.
Figura B
Los valores de las variables
incremento_x_cir e incremento_y_cir determinan el sentido y la velocidad del circulo(pelota o balón). Por lo momentos, esa velocidad va ser fija, pero si queremos aumentar la dificultad del juego, podemos aumentarla a medida que se avance en los niveles del juego. En cuanto al sentido o dirección del circulo, cuando ambos valores del los incrementos de x , y son positivos (+) el circulo se desplaza hacia abajo y a la derecha, cuando incremento de y es negativo hacia abajo y a la derecha y cuando el incremento de x es negativo el movimiento es hacia la izquierda hacia arriba o abajo, en pocas palabras el signo del incremento de x determina la dirección horizontal y el signo del incremento de y determina el sentido vertical como vemos en el siguiente gráfico donde el valor del incremento es 1 (+1 o -1).
Movimiento del Rectángulo
En éste escenario que queremos crear, además del circulo en movimiento, debemos dibujar un rectángulo en la parte inferior de la ventana. El rectángulo o barra debe moverse a voluntad del usuario en sentido horizontal hacia la derecha o a la izquierda dentro de los limites derecho e izquierdo respondiendo a la orden de las teclas <-- o -->.
Hasta el momento solo hemos hemos manejado el evento cuando se cierra la ventana. Ahora vamos a manejar los eventos del teclado que nos interesa para mover un rectángulo de acuerdo a los eventos del teclado. Para ello debemos tener presente los cuatro pasos siguientes
Primero: debemos crear un objeto rectángulo
sf::RectangleShape barra(sf::Vector2f(largo_barra, altura_barra));
Segundo: Le damos una acción a los eventos del teclado únicamente a las teclas derecha e izquierda.
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
if(x_rec <= limite_der - largo_barra){
x_rec = x_rec + incremento_x_rec;
}
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
if(x_rec >= limite_izq){
x_rec = x_rec - incremento_x_rec;
}
Tercero: teniendo las nuevas coordenadas del rectángulo se la pasamos al objeto rectángulo.
barra.setPosition(x_rec,y_rec);
Cuarto: se dibuja el rectángulo en la posición que fijamos con
set.Position.
ventana.draw(barra); // dibujamos el rectángulo en la ventana
Manejo de colisiones con SFML
Colisión de circulo con la barra
Hasta el momento las tres condiciones limites planteadas en el movimiento del circulo aplican para el limite izquierdo, el limite superior y el limite derecho. En limite inferior o piso, depende del jugador. Si el jugador ubica el rectángulo en la trayectoria del circulo antes de pasar el limite inferior, entonces la condición hace que cambie el sentido d
el incremento (+) de y, es decir incremento_y_cir a negativo (-), para que simule el rebote como se ve en la pantalla 2. Para cambiar el signo del valor del incremento simplemente lo multiplicamos por (-1).
incremento_y_cir = -1*incremento_y_cir;
Para poder determinar si ambos objetos (circulo y rectángulo) se tocan debemos determinar si sus coordenadas se interceptan. La librería SFML ofrece soporte de colisiones que nos permite hacer el manejo de las mimas de una manera fácil e intuitiva. Lo primero que debemos hacer, es crear las entidades rectangulares o cajas (
ver figura C) para cada objeto al cual nos interesa manejar si se intercepta con otro. Dichas cajas encierra a cada objeto como se ve la figura.
Figura C
Como vemos en ejemplo de la
figura C tenemos un circulo con radio 5 y un rectángulo de 20 x 10. Las coordenadas del borde del circulo inicia en 160,220 y terminan en
170,230 y las del rectángulo inicia en
170,230 y terminan en 240,190. Ya creadas las cajas de cada objeto, SFML ofrece una función que determina si ambos rectángulos se interceptan.
Primero creamos las cajas rectangulares circulo1Box y barraBox que encierran al circulo y la barra utilizando el nombre del objeto que creamos:
sf::FloatRect circulo1Box = circulo1.getGlobalBounds();
sf::FloatRect barraBox = barra.getGlobalBounds();
y luego podemos determinar si hay colisión con la siguiente función:
if (circulo1Box.intersects(barraBox)){
// acciones de la colisión
incremento_y_cir = -1* incremento_y_cir;//rebote
}
Ya tenemos nuestro cuarto limite si hay colisión entre el circulo y la barra hay rebote de lo contrario colocamos el circulo en la posición inicial para que empiece de nuevo.
Básicamente nuestro programa tiene que tener la siguiente estructura
Comentarios
Publicar un comentario