Problema con el algoritmo advance

[Altair]

Muy buenas,

usando C/C++ intento implementar esto: tenemos un objeto en las coordenadas X e Y, dado un angulo "angle" queremos que avance una DISTANCIA determinada en pixels. Una vez haya avanzado esa distancia en dicha direccion, en las variables X e Y estaran las nuevas coordenadas.

Informacion util:
objeto.x; // int
objeto.y; // int
objeto.angle; // float

Escenario:
objeto.x=50;
objeto.y=60;
objeto.angle=25.35;

Creo que esto se hace con alguna formula de trigonometria, estoy probando con estas formulas pero no me funciona, y las matematicas se me dan bastante mal

radian=(float)(3.1415926535897931/180)*angulo; // Pasamos el angulo a radianes.
entity_id->x=entity_id->x+(distance*cos(radian));
entity_id->y=entity_id->y+(distance*sin(radian));

[Juanxo]

buenas altair,

como comentabas se tienen que usar funciones de trigonometría, específicamente seno y coseno.

Tu tienes la longitud de la distancia que quieres mover "d"
Para hallar las componentes x e y de "d", tienes que hacer lo siguiente:

- Si multiplicas la longitud de un vector("d") por el coseno del angulo que forma (angulo), tienes la componente X de ese vector d.x
obj.x += distancia * cos(angulo);

- Si multiplicas la longitud de un vector("d") por el seno del ángulo que forma (ángulo), tienes la componente Y
obj.y += distancia * sin(angulo)

Pero tu problema creo que radica aquí:
Los senos y cosenos están delimitados al rango [-1,1], por lo que el producto de distancia * sin ( o cos), va a ser generalmente pequeño, y encima vas a perder los decimales por ser obj.x y obj.y integers. Mira a ver si los puedes pasar a float

Prueba a imprimir distancia * sin(angulo) y verás como seguramente será cercano a 0

[Altair]

En efecto da resultados muy pequeños.

Lo malo es que no parece que pasar obj.x y obj.y a float solucione nada, porque son las coordenadas X e Y en pantalla.

[carlostex]

El problema esta en que estas tratando al objeto como si fuera estático, cuando lo que tu quieres hacer es que se mueva. la distancia al ser pequeña hará que que los cambios sean pequeños, la solución es que tienes que combinar trigonometría con física pues estas realizando una animación, debes definir una velocidad, por ejemplo 3 pixeles/seg, y la distancia va a ser el tiempo que transcurre entre cada frame por la velocidad, de esa forma veras un resultado mejor.

[Altair]

No estoy muy seguro de que sea una animacion. Yo lo entiendo asi, estoy cambiando las coordenadas XY de un objeto, desde sus coordenadas iniciales a las finales. No me importan las coordenadas XY intermedias que hay por medio.

Por ejemplo, con estos datos:
ob.x=0
ob.y=0
ob.angle=0

lo hago avanzar 100 pixels en X, se que quedan asi las coordenadas XY
ob.x=100
ob.y=0

Por otra parte he hecho un sistema, un tanto cutre, pero que parece funcionar:

El eje X es horizontal y es positivo hacia la derecha
El eje Y es vertical y es positivo hacia abajo
Los 0 grados estan en el eje X positivo y crecen en sentido horario

x=0
y=0
distancia=100
angulo=80

Esto nos pone un objeto en las coordenadas X e Y indicadas, que avanzara 100 pixels con un angulo de 80 grados. Teniendo en cuenta como van los angulos, eso indica que va hacia abajo casi en linea recta, un poco a la derecha del eje Y positivo.

Finales teoricos:
x=0+100=100
y=0+100=100

Teniendo en cuenta solamente las coordenadas X e Y y la distancia, las coordenadas destino quedarian asi.

Lado X:
100 -> 100%
X -> 10 grados
X= 100*10/100=1000/100=10
x=0+10=10

Si avanzamos un 100%, recorremos 100 pixels.
El lado opuesto del angulo tiene 10 grados (recordemos que tenemos un giro de 80 grados, 90-80=10) y tenemos que calcular los pixels correspondientes.
Haciendo una regla de tres, nos da que tenemos una "ganancia" de 10 pixels.

Lado Y:
100 -> 100%
Y -> 80 grados
y=100*80/100=8000/100=80
y=0+80=80

Muy parecido a lo de antes.
Si avanzamos un 100%, recorremos 100 pixels.
El lado opuesto del angulo tiene ahora 80 grados (90-10).
Hacemos regla de tres y sale una ganancia en Y de 80 pixels

Coordenadas finales
x=0+10=10
y=0+80=80

A la coordenada X original (0) le sumamos la "ganancia" en X (10).
Hacemos lo mismo con la coordenada Y.

Lo que me tiene un tanto escamado es que 10+80 no suman 100 (la distancia que buscamos recorrer). Creo que eso indica que este metodo puede ser valido pero que falta pulirlo de alguna forma.

[kaiser]

Si quieres que el objeto avance 100px en un ángulo de 80º simplemente calcula lo siguiente:

Coordenada X --> cos(80º) = 0.1736, lo multiplicamos por 100 que es la cantidad de px que queremos avanzar --> 17.36px.
Coordenada Y --> sen(80º) = 0.9848 lo multiplicamos por 100 que es la cantidad de px que queremos avanzar --> 98.48px.

Con el teorema de Pitágoras se puede comprobar que efectivamente la distancia recorrida es de 100px, además avanzamos mucho en el eje Y y muy poco en el X, lo que concuerda con los 80º.

Un Saludo!

[Altair]

Entiendo el ejemplo que pones, que ya es mucho decir en mi caso, y me sirve para algunas cosas.

De todas formas, como tengo previsto sacar la version 0.2 de mi proyecto pronto, pondre un archivo explicando exactamente lo que necesito, a ver si alguno de los que controlais las matematicas podeis implementarlo. Asi son las cosas conmigo y las matematicas, al que se le dan mal, se le dan mal.

Os adelanto que esta version le da al tema de funciones graficas avanzadas: distintos tipos de lineas, circulos, cuadrados, arcos, etc. He dividido los tutoriales en 12 secciones, para que los conceptos sean mas sencillos. Luego estan los capitulos, que explican para que sirve cada cosa. Por ultimo esta la documentacion "tecnica" que indica los parametros de cada funcion.

Solo me queda terminar de arreglar eso y ya esta