 Autor
|
Tema: Función para colisiones - c++ /SFML (Leído 9,267 veces)
|
LuKyTa14
 Desconectado
Mensajes: 6
|
Hola estoy teniendo un problema para poder hacer que varios rectángulos colisiones con el jugador para armar una especie de laberinto, este es el código de la función que quiero hacer: void intersecciona(RectangleShape jugador, RectangleShape pared) { FloatRect jug = jugador.getGlobalBounds(); FloatRect pare = pared.getGlobalBounds(); if(jug.intersects(pare)){ if(jugador.getPosition().x<pared.getPosition().x) jugador.setPosition(jugador.getPosition().x-10, jugador.getPosition().y); if(jugador.getPosition().x>pared.getPosition().x) jugador.setPosition(jugador.getPosition().x+10, jugador.getPosition().y); if(jugador.getPosition().y<pared.getPosition().y) jugador.setPosition(jugador.getPosition().x, jugador.getPosition().y-10); if(jugador.getPosition().y>pared.getPosition().y) jugador.setPosition(jugador.getPosition().x, jugador.getPosition().y+10); } }
El programa asi funciona para una pared, pero seria incorrecto hacer los if para cada pared: #include <SFML/Graphics.hpp> #include <iostream> using namespace sf; using namespace std; int main(){ //Creamos la ventana RenderWindow window(sf::VideoMode(800, 600), "LABERINTO XD"); //Rectangualo RectangleShape rec(Vector2f(40, 40)); rec.setFillColor(Color::Cyan); //rec2es RectangleShape rec2(Vector2f(50, 300)); rec2.setFillColor(Color::Magenta); rec2.setPosition(400, 300); RectangleShape rec20(Vector2f(50, 230)); rec20.setFillColor(Color::Magenta); rec20.setPosition(400, 0); RectangleShape rec3(Vector2f(50, 500)); rec3.setFillColor(Color::Magenta); rec3.setPosition(300,0); RectangleShape rec4(Vector2f(50, 350)); rec4.setFillColor(Color::Magenta); rec4.setPosition(200, 250); RectangleShape rec5(Vector2f(50, 150)); rec5.setFillColor(Color::Magenta); rec5.setPosition(1000, 100); window.setFramerateLimit(120); //Si la ventana está abierta while(window.isOpen()){ //Creamos un evento Event ventana; //Llamamos a los eventos while(window.pollEvent(ventana)){ //Cerramos la ventana cuando se solicite if(ventana.type == Event::Closed){ window.close(); } } //Movimiento rectangulo if(Keyboard::isKeyPressed(Keyboard::Up)){ rec.move(0, -1); } if(Keyboard::isKeyPressed(Keyboard::Down)){ rec.move(0, 1); } if(Keyboard::isKeyPressed(Keyboard::Left)){ rec.move(-1, 0); } if(Keyboard::isKeyPressed(Keyboard::Right)){ rec.move(1, 0); } //Colisiones if(rec.getPosition().x<0){ rec.setPosition(0, rec.getPosition().y); } if(rec.getPosition().x>750){ rec.setPosition(750, rec.getPosition().y); } if(rec.getPosition().y<0){ rec.setPosition(rec.getPosition().x, 0); } if(rec.getPosition().y>550){ rec.setPosition(rec.getPosition().x, 550); } FloatRect rect = rec.getGlobalBounds(); FloatRect rect2 = rec2.getGlobalBounds(); FloatRect rect3 = rec3.getGlobalBounds(); FloatRect rect4 = rec4.getGlobalBounds(); FloatRect rect5 = rec5.getGlobalBounds(); if(rect.intersects(rect2)){ if(rec.getPosition().x<rec2.getPosition().x) rec.setPosition(rec.getPosition().x-10, rec.getPosition().y); if(rec.getPosition().x>rec2.getPosition().x) rec.setPosition(rec.getPosition().x+10, rec.getPosition().y); if(rec.getPosition().y<rec2.getPosition().y) rec.setPosition(rec.getPosition().x, rec.getPosition().y-10); if(rec.getPosition().y>rec2.getPosition().y) rec.setPosition(rec.getPosition().x, rec.getPosition().y+10); } //Limpiamos ventana window.clear(); //Dibujamos el rectangulo window.draw(rec); window.draw(rec2); window.draw(rec20); window.draw(rec3); window.draw(rec4); window.draw(rec5); //Actualizamos ventana window.display(); } }
|
|
|
|
« Última modificación: 17 Febrero 2022, 21:12 pm por LuKyTa14 »
|
En línea
|
|
|
|
|
Serapis
|
Antes de mover el jugador, necesitas una función 'SiPuedeMoverseA(x,y)' que devuelva un buleano. Si devuelve TRUE, es entonces cuando lo mueves, no antes. Y una vez movido, no cabe preguntar de nuevo hasta que vuelva a moverse. supongamos que el jugador está en la casilla 3,7 y quiere avanzar 1 a la derecha: +1, -1 y 0, para el eje vertical u horizontal es algo que obtienes por las teclas pulsadas. Lógicamente +1, -1 , 0 se pasan en variables x,y Si puedeMoverse(jugador.x +1, jugador.y + 0, accion) = TRUE
jugador.x += x
jugador.y += y
Si (accion >0)
// además de haberse movido se espera que suceda alguna acción (por ejemplo señalar que ha recogido una llave, abierto una puerta, accedido a otra planta-habitación, etc...)
fin si
sino
beep //un sonido o alguna ación, que exprese la imposibilidad de moverse ahí.
fin si
Por su parte el puede moverse, no parece tener sentido que pases una 'pared' salvo que sepas que esa pared está ahí... localizar una pared, no deja de ser algo costoso. Los incrementos +10, -10... he de suponer que son valores unitarios, es decir que no pueden ubicarse en valores 5, 13, etc, si no siempre en múltiplos de 10. Si tienes un laberinto, lo mejor no es tener 'paredes', si no un array de X*Y de ancho y alto, el laberinto lo presentas cada casilla con valores numéricos, por ejemplo una casilla libre con valor 0, una pared con valor 255, una puerta abierta con valor 1, cerrada con valor 254 (de existir escaleras; escaleras arriba con valor 249, abajo con valor 248) , objetos recogibles por el jugador con otros valores... Reserva los valores 250 a 254 para otros objetos que aunque no sean paredes no pueden el jugador moverse ahí (imagina por ejemplo un agujero en el suelo rodeado de una barandilla) . Si hay muchos objetos accesibles, casi tantos como inaccesibles, considera usar valores pares para los accesible e impares para los no accesibles (como puerta abierta y cerrada, etc...). Entonces ahora tu función simplemente trata de verificar si la casilla a la que el jugador quiere acceder es accesible o no. buleano = funcion puedeMoverse(x,y, accion)
byte valor
valor = tablero(x,y)
si (valor >= 250) // una pared, puerta cerrada, etc...
devolver false
o si (valor <= 10) // pasillo, área libre, puerta abierta, escaleras, ascensor abierto
devolver TRUE
si (valor=2) // puerta abierta
accion = 2 // cruzar a otra habitación (cargar su mapa, posicionando al jugador en la casilla de dicha puerta)
si (valor= 3) // hay una llave en dicha casilla.
accion = 3 // coger la llave
etc...
otros valores
devolver TRUE o FALSe según caso.
etc, etc...
fin funcion Si diseñas adecuadamente los valores, para que las casillas accesible queden juntos y los inaccesibles juntos, se simplifica la operatoria, además si dejas los valores más extremos los que simplemente devuelven true y false y nada más y el resto más internamente para los que además hay que hacer alguna acción, por ejemplo si sube escaleras (7-10-15 peldanos (pasos), muestras el mapa de la planta a la que se accede (guardas el mapa del tablero actual y cargas el de dicha planta), o si se coge un objeto mostrar un mensaje (el jugador tiene la llave de la puerta 3, por ejemplo), etc... Los laberintos se realizan básicamente como te he explicado, cada casilla está representada en un array bidimensional, con un valor que señala el tipo de casilla. Una enumeración señala los diferentes tipos de casillas, que además te sirven para dibujar el mapa acorde al valor de la casilla.
|
|
|
|
|
En línea
|
|
|
|
|
Serapis
|
Hola serapis, te hablo por el mensaje que me dejaste en el foro, quería consultarte si tienes discord o algo para charlarlo en llamada, ya que avance con el proyecto, y tengo ganas de que lo mires y me des tu opinión acerca de ello...
Disculpa si te molesto, pero gracias por las recomendaciones
Hola no es necesario escribir mensajes por privado para esto. En todo caso sí para pasar datos. Y no, lo lamento no tengo Discord. No es necesario que expongas todo el proyecto, solo las dudas que te vayan surgiendo o lo problemas que no sepas como resolver.
|
|
|
|
|
En línea
|
|
|
|
LuKyTa14
Desconectado
Mensajes: 6
|
Hola, gracias
Mi pregunta es, seria como que haga antes de todo el desarrollo del juego en una clase mapa dividida en una matriz n*m asignando a cada cuadrado el valor como si fuera un tablero de ajedrez con su numero respectivo 1 y -1?
y que el jugador se mueva por cada paso o movimiento cada cuadrado de esa matriz y si el resultado da un x sea un lugar donde no este permitido pasar y esa sea la pared del laberinto?
Si es ese la idea no se muy bien como formar esa clase si tienes algún video explicativo o un link de alguna pagina me encantaría que me lo pases...
|
|
|
|
|
En línea
|
|
|
|
|
|
|
Serapis
|
el desarrollo del juego en una clase mapa dividida en una matriz n*m asignando a cada cuadrado el valor como si fuera un tablero de ajedrez con su numero respectivo 1 y -1? Básicamente sí... y que el jugador se mueva por cada paso o movimiento cada cuadrado de esa matriz y si el resultado da un x sea un lugar donde no este permitido pasar y esa sea la pared del laberinto? Si, te pongo un mapa inicial de ejemplo y una captura del juego... En el mapa en vez de cifras, se han usado letras... no tiene importancia, en tanto uno interprete correctamente el significado de cada una. Usar valores de byte, es adecuado si la cantidad de casillas disitntas es elevada, si solo hay 2 o 3 decenas a lo sumo, las letras y números y poco más debería valer igual de bien.
ancho= 27
alto= 17
###########################
#----##--#D--#-##---2---U##
#-2---------2#-#-2----#-2##
##-----U-----#-----##-#2###
##############---------2###
#----------2#---U--##---2##
#2----------#-#---#-------#
#2-----#------#-----------#
#2---#----U2--------#-----#
#----#----2--------###2---#
#--------#------------22#-#
#2-----------U2--------##-#
#2#-#-----------##--------#
#-#-------------#------#--#
#-----2-----2-###2----##22#
##S-----###-------##-----##
###########################
El juego tiene por objeto partir de una casilla dada y llegar a la meta. Se mueve una 'bola' (por simplicidad en vez de dibujar un monigote con forma humana). La principal particularidad de este juego, es que nos e mueve una casilla por vez, una vez 'empujada' en una dirección avanza hasta chocar con un obstáculo que le impide seguir, lo que dificulta el camino a seguir para llegar a la meta. Fácilmente se intuye que las casillas con el carácter # son paredes y las casillas con el carácter '-' son espacios libres (puede haber casillas ocultas, tanto en paredes como en espacios libres). El carácter 'S', marca la posición inicial (salida) del jugador. El carácter '2' marca esas estrellas que dan la puntuación, por cada una recogido (cuandose visita la casilla, se muta en una de espacio libre, esto es si mapa(x,y)= 2 luego mapa(x,y)= # El carácter 'D' es la meta, como se ve está encerrada, luego tiene que haber alguna forma de entrar... El carácter 'U' es una especie de túnel, los naranjas, por ejemplo entran por uno y salen por otro (están conectados dos entre sí, esto se indica en el mapa después del tablero (dibujado más arriba) algo como: U: 16,5 = 10,8 U: 10,8 = 16,5 Que quiere decir, el 'túnel de la casilla X=5,y=16' mueve la bola al túnel en la casilla 10,8 El otro devuelve al mismo sitio, aunque no es obligatorio, moverá siempre adónde se indique. Hay 2 parámetros adicionales más que no he puesto que indican desde qué orietación admite la 'entrada al túnel' y en qué direcciones permite la salida por el otro (como hay 4 orientaciones, N,S.E.O se representan con un valor: 1+2+4+8, es decir si la entrada vale 9, quiere decir que admite entrada por Norte y Oeste (8+1). Como se vé ciertas casillas al llegar a ellas requieren una acción. lo adecuado es predefinir las acciones y asociarlas a cada tipo de casilla distinta. Si requiren más datos adicionales, tras el 'dibujo del mapa', se pone el tipo de casilla especial, sus cordenadas y los parámetros que la misma precise. Lo ideal es poder dibujar mapas aleatoriamente, pero iniciamente debes dibujarlos a mano, para ir probando el funcionamiento de las características que vas añadiendo. Aquí una captura poco después del comienzo del juego (el mapa es de 17x27 casillas): La casilla 'verde' representa la bola que maneja el jugador...  Si es ese la idea no se muy bien como formar esa clase si tienes algún video explicativo o un link de alguna pagina me encantaría que me lo pases...
Empieza por dibujar una mapa en un fichero de texto, similar al que te he puesto, de momento solo casillas libres y paredes.... luego programa la lectura del fichero a un array (precede el mapa de su tamaño, para antes de crear el array del tamaño adecuado) una vez leído dibújalo... Luego añade un símbolo para el jugador, bibújalo, haz que se mueva sin rebasar las paredes... Después añade más características y finalmente dale las reglas al juego. Define un objetivo y las reglas de movimiento del jugador y de cada casilla.
|
|
|
|
|
En línea
|
|
|
|
LuKyTa14
Desconectado
Mensajes: 6
|
Dale muchas gracias por todos los detalles y comentarios, esta noche me pongo a ver la idea e intentar plantear el programa, solo una pregunta.
Cuando me decís:
"Empieza por dibujar una mapa en un fichero de texto, similar al que te he puesto, de momento solo casillas libres y paredes.... luego programa la lectura del fichero a un array"
Para crear ese array o matriz definido anteriormente, su lectura la hago a través de un archivo de texto como binario o normal? Así luego pueda crear mas archivos, que tengan distintas paredes y objetos pero del mismo tamaño para poder hacer que el programa o el usuario elija uno de esos archivos para ir haciendo metódicamente mas niveles?
|
|
|
|
|
En línea
|
|
|
|
|
Serapis
|
Para crear ese array o matriz definido anteriormente, su lectura la hago a través de un archivo de texto como binario o normal? Da igual el método que elijas para leerlo, tu tienes que luego que interpretarlo. Yo sugiero que o bien lo leas entero de una tacada, o línea por línea. Eso sí, empieza por señalar el tamaño del mismo en 1 o dos lineas: Ancho = x Alto = y ó... x,y Considera cada casilla como una unidad... luego en el programa tu tendrás una variable 'factorEscala = n', donde n puede ser un valor que represente el tamaño en píxeles de cada celda, así puede ser 10, 11, 15, 22, 23, 25... es decir independizas el mapa del tamaño que ocupa al dibujarlo. Ese factor podrás cambiarlo desde menú (por ejemplo) o fijarlo al empear el programa en función del tamaño de la ventana. Considera el mapa rectangular, así sea que luego el mapa tenga una figura irregular, por ejemplo:
30,30
##########=# #
#-------#--#
#-------#--#
####-####--#
#-#--#--#########
#-####----------#
#---------------#
####---------------####
#-------#######-------#
####----------#######-#
#--###----###########-#
#----###-##-----------#
#---------#-------#---###
#-------###-------#-----#
###-#####---------#-----#
#-#------########-----#
#-#####------#------###
#-#---#------#------#
#-#---#------##-#####
#-###-##-#------#
#---###---###---############
###-#---#####-#--------------=
#-----#--#------#####---######
##-####----#-####-------#
#-###########----------#
#-#-------------########
##-#-------------####
=--###--------------####
###--#-----########----####
#-#####-------###----#
#=# ####=# #
Nota que ahí las casillas con el carácter '=', señalan una puerta a otra habitación del laberinto. Tras el dibujo del mapa, pondrias =: 11,1, 6 Que vendria a interpretarse como: la puerta ubicada en la casilla (11,1) comunica con el laberinto numero 6... Nota como todas las casillas especiales que haya que considerar algo en especial, tras el laberinto (que sabes las lineas que ocupa), las detallas, primero el indicador asociado a la casilla, luego las cordenadas donde se localiza, y luego si proceden otros valores, que pueden significar cosas distintas para cada tipo de casilla. Tener una plantilla vacía para crear los mapas, facilitará la rapidez en el diseño... empiezas con un cuadrado o rectángulo de un tamaño fijo, que copias y pegas y luego modificas, algo como esto:
30,30
##############################
#----------------------------#
#----------------------------#
#----------------------------#
...
#----------------------------#
#----------------------------#
#----------------------------#
##############################Así luego pueda crear mas archivos, que tengan distintas paredes y objetos pero del mismo tamaño para poder hacer que el programa o el usuario elija uno de esos archivos para ir haciendo metódicamente mas niveles? Esto ya es un poco cosa de tu imaginación... Podrías por ejemplo tener ficheros del mismo nivel en diferentes carpetas, las carpetas tienen un nombre que señala su nivel 1,2,3... y los ficheros en cada carpeta, igual, nombres como 1,2,3... .txt. Sería acorde crear x mapas en una planta, donde cada mapa-laberinto, se comunica con otros por una puerta (esto te permite fraccionar un laberinto gigante en varios más pequeños). Conviene eso sí que aunque el mapa sea irregular ocupen siempre el mismo número de casillas de ancho y alto... Primero, por supuesto empieza con un solo mapa... y le añades características, a media que te vaya funcionando, vas añadiendo más características, cuando todo funciones bastante bien, entonces creas puertas, escaleras, ascensores... las puertas comunican con otros laberintos (en realidad habitaciones en el mismo laberinto), pero que se representa con su propio mapa y fichero aparte (así tampoco sobrecarga la memoria. Un ejemplo rápido de dibjado de un laberinto compuesto de múltiples laberintos:  Nota que al abandonar una habitación para acceder a otra, esta quese acaba de abandonar, debe guardarse a fichero pero ahora en vez de un txt, le das por ejemplo una extensión .temp, si vuelves a ella verificas si existe el fichero (por ejemplo), 6.temp, si lo hay se abre ese (que indica que tiene el estado de como se dejó la última vez que se visitó), si no se localiza, es que nunca se entró en él, en tal caso abres el 6.txt... Cuandos se termine la partida, se eliminan todos los temp. Los niveles, pueden ser creados por dificultad. La dificultad en una parte de las más complejas en los juegos (a la hora de programar)... pero en un laberinto pueden hacerse facilmente haciendo casillas ocultas... Casillas ocultas, son casillas que externamente (visiblemente) su imagen es la misma que una pared o una vacía, pero al pasar sobre ella se activa y se dibuja de su verdadero valor (el jugador debe intentar acceder a ella, para que se revele dicha casilla). Por ejemplo si esto es una pared #######, podría poner una casilla libre pero que se deja oculta, por ejemplo así: ####@###, '@' señalaría que es una casilla libre (igual que '-' pero que se dibuja como una pared y una vez pisada, ya se dibuja como libre, es decir en tu array (después de intentar acceder a ella) cambias el valor de la casilla de '@' a '-', así posteriores veces que se deba dibujar, se dibuja como libre... el mismo procedimiento puede emplearse, al revés una casilla que parece libre, que en realidad sea una pared... el ugador no podrá avanzar y ahí está la salida, deberá descubrir como, y esa casilla luego se dibuja como pared (al intentar acceder a ella)... Puedes hacer creer al jugador que los niveles se encuentran a diferentes alturas, cuando suba niveles, son más complicados de resolver, o les cuesta más tiempo, pero puedes asi ocultar habitaciones... en los niveles más simples. Eso sí para darle a entender al jugador los diferentes tipos de casillas, crea un nivel donde en cada habitación dle laberinto, le enseñas una o dos casillas distintas, para que se familiarice con lo que implica, incluso en ese nivel, podría crear casillas 'info' 'i', que cuando se pise, debajo muestre un texto de ayuda algo como: "Cuando veas una llave recógela, te servirá para abrir alguna puerta cerrada." Y en el mensaje previo se me olvidó indicarte, hay un muy buen libro que trata este tipo de juegos, aunque es viejo, aunque el código que trae es espagueti (sin apenas estructura y repleto de goto y gosub (está en un Basic primitivo d elos spectrum Sinclair, sin embargo sigue vigente en cuanto a la estrategia para realizar ciertos tipos de juegos, eso sí está en inglés, aunque también sacaron la vrsión en español (yo la que tengo está en inglés): "Spectrum Adventures" 
|
|
|
|
« Última modificación: 21 Febrero 2022, 02:26 am por Serapis »
|
En línea
|
|
|
|
|
|
|
|
|
| Mensajes similares |
|
Asunto |
Iniciado por |
Respuestas |
Vistas |
Último mensaje |
|
|
|
colisiones en vb6?
Programación Visual Basic
|
koopa2
|
5
|
2,129
|
11 Noviembre 2006, 03:23 am
por koopa2
|
|
|
|
Colisiones en juego SDL
Programación C/C++
|
Guillermo575
|
3
|
5,213
|
28 Marzo 2011, 02:15 am
por oxydec
|
|
|
|
programas de colisiones de hash md5
Dudas Generales
|
omegas
|
3
|
3,872
|
9 Septiembre 2011, 22:56 pm
por omegas
|
|
|
|
Colisiones simples en VBScript + HTA
Scripting
|
JohnConnor
|
0
|
1,867
|
3 Mayo 2012, 10:06 am
por JohnConnor
|
|
|
|
[SFML] Colisiones con borde de ventana
Programación C/C++
|
DeMoNcRaZy
|
8
|
3,757
|
23 Junio 2015, 14:29 pm
por ivancea96
|
 |
