Rutina de rebote con efecto raro

[Eskema]

Hola de nuevo a todos, aqui sigo probando cosas y hoy me he encontrado algo curioso, estoy creando una rutina para hacer que una pelota rebote por la pantalla y curiosidades de la vida no funciona como deberia. Lo mas curioso es que esa misma rutina sin tocar ni una sola coma la tengo en otro proyecto y funciona perfectamente. A ver si algun alma caritativa le da un vistazo y me dice si es algo mio, o cosa de la SDL,

void mover_bola(void){

int xMax=630,xMin=10,yMax=465,yMin=10; //una pantalla de 640x480
int direccion_bola=0;
//direccion 0 abajo-derecha
//direccion 1 arriba-derecha
//direccion 2 arriba-izquierda
//direccion 3 abajo-izquierda

if (direccion_bola == 0 && pelota.x < xMax && pelota.y < yMax) {
pelota.x++;pelota.x++;
pelota.y++;pelota.y++;
}
if (direccion_bola == 0 && (pelota.x >= xMax || pelota.y >= yMax )) {
if (pelota.x >= xMax)
{direccion_bola = 3;}
else
{direccion_bola = 1;}
}


if (direccion_bola == 1 && pelota.x < xMax && pelota.y > yMin){
pelota.x++;pelota.x++;
pelota.y--;pelota.y--;
}

if (direccion_bola == 1 && (pelota.x >= xMax || pelota.y <= yMin )){
if (pelota.x >= xMax)
{direccion_bola = 2;}
else
{direccion_bola = 0;}

}

if (direccion_bola == 2 && pelota.x > xMin && pelota.y > yMin){
pelota.x--;pelota.x--;
pelota.y--;pelota.y--;
}
if (direccion_bola == 2 && (pelota.x <= xMin || pelota.y <= yMin )){
if (pelota.x <= xMin)
{direccion_bola = 1;}
else
{direccion_bola = 3;}
}


if (direccion_bola == 3 && pelota.x > xMin && pelota.y < yMax){
pelota.x--;pelota.x--;
pelota.y++;pelota.y++;
}
if (direccion_bola == 3 && (pelota.x <= xMin || pelota.y >= yMax)){
if (pelota.x <= xMin)
{direccion_bola = 0;}
else
{direccion_bola = 2;}
}


}

Lo curioso del tema es que empieza a bajar y al llegar abajo, deberia rebotar hacia arriba, sin embargo se queda quieta abajo ¿?
Saludos, Eskema

[Lizardos]

int xMax=630,xMin=10,yMax=465,yMin=10; //una pantalla de 640x480

La pantalla de la GP32 es de 320x240. Cambia tus coordenadas a xMax=310,yMax=215; (por ejemplo).
Saludos

[Eskema]

En efecto lizardos, pero ¿quien dice que yo estoy usando la gp? normalmente mis ejemplillos los hago en pc y luego cuando tenga las cosas claras ya me pondre a hacer algun juegecillo con todo lo aprendido en gp.
Lo que yo pregunto es si alguien ha probado esta rutina tal cual y le funciona o le da algun fallo como a mi. Tambien acepto sugerencias sobre como se puede mejorar,etc. Como digo esta rutina me funciona en una prueba que hize sobre gba, un proyecto de fenix para gp(si con 320x240) y sin embargo en pc pues no me rula ¿?

Saludos, Eskema

[Logann]

Bueno yo no puedo decirte ahora mismo la solución, pero si te sugiero que te replantes un poco el codigo, por ejemplo crea dos variables para la dirección (dirx diry que pueden ser -1, 0 ó 1) de la bola y podras juntar todos los incrementos y los if no tendran tantas condiciones.

[oankali]

Creo que tu problema viene del hecho que direccion_bola se encuentra dentro de la función, cuando su sitio es estar dentro de la estructura pelota.
En tu caso, siempre está a 0 cuando empieza la función.
Como chapuza siempre puedes declararla así

static int direccion_bola=0; pero como he dicho antes, ese no es su lugar.

Y creo que este código hace lo mismo:


void mover_bola(void){

const int xMax=630,xMin=10,yMax=465,yMin=10; //una pantalla de 640x480

if ((pelota.x + pelota.deltax < xMin) || (pelota.x + pelota.deltax > xMax))
pelota.deltax = -pelota.deltax;

if ((pelota.y + pelota.deltay < yMin) || (pelota.y + pelota.deltay > yMax))
pelota.deltay = -pelota.deltay;

pelota.x += pelota.deltax;
pelota.y += pelota.deltay;
}

Con este sistema, hasta puedes hacer variar la velocidad de la pelota con más facilidad.
Por cierto, no lo he probado, así que a lo mejor la he cagado. :rolleyes:

Oankali

[oankali]

Bueno yo no puedo decirte ahora mismo la solución, pero si te sugiero que te replantes un poco el codigo, por ejemplo crea dos variables para la dirección (dirx diry que pueden ser -1, 0 ó 1) de la bola y podras juntar todos los incrementos y los if no tendran tantas condiciones.

Jeje, mientras estaba con lo mío, ya le habías dado parte de la solución :brindis:

[Lizardos]

Juas, lo siento, parece que me he colado, la verdad es que no miré mucho el código.Saludos.

[avalancha]

Efectivamente, cada vez que se vuelve a invocar de nuevo al método se fija de nuevo la dirección de abajo-derecha.

Lo que yo no sabía es que esto se podía meter en la GP32 O_o

Yo había oido que pa la GP32 se programaba en Fenix o algo así, y me encuentro que hablais de portar este código a la GP32, y resulta que si no es Java (que es el lenguaje que yo conozco), es idéntico...

Pos nada, me daré un paseo por el foro programación pa ver como se hace esto pa la GP :)

[Logann]

:) La gramatica de java es heredada de el lenguaje C

[Eskema]

Hmmm cierto la direccion_bola esta dentro de la funcion y en c deberia estar fuera. Que curioso la forma de comportarse que tienen los lenguajes, en fenix estando tal cual rula perfectamente. Como bien decis este codigo es de los mas simple que hay y bastante chapuza, pero como hay que ir probando cosas para aprender ;)
Gracias a todos, Eskema