Sugerencia para get_angle() y fget_angle()

[Erkosone]

Hola buenas, tengo una sugerencia que creo que va a ayudar bastante a todos, la comento por que me parece que es algo bastante útil en todos los casos.


Actualmente en bennuGD como era en Div y Div2 las funciones que devuelven un angulo expresan su resultado en 2 rangos posibles:
de 0 a 260 grados "escalados claro.."
y
de 0 a -90 grados "también escalados".


El caso es que para cualquier operación de física básica es necesario disponer de un angulo de 0 a 360 grados "escalado también por supuesto".


Y la sugerencia es esta, que las funciones fget_angle() y get_angle() retornen valores siempre positivos, esto ayuda mucho en los cálculos cuando estamos haciendo juegos, en mi caso estoy liado con la mod_chipmunk y las explosiones, y lo que me sucede es que tengo que hacer una conversión del valor que me retornan estas funciones "si el angulo es negativo" y bueno.. no es que sea demasiado trabajo hacerlo.. pero claro.. uno piensa y ve que si esto lo hiciera directamente bennu pues es trabajo que nos ahorramos.




Yo lo hago así, si se pudiera incluir en las funciones sería de gran ayuda:



angulo_explosion_ = fget_angle(id_.x, id_.y, x, y);
if(angulo_explosion_ < 0)
   angulo_explosion_ = (90000 - angulo_explosion_*-1) + 260000;
end




La formula para retornar siempre grados positivos es:
Si el valor es positivo no se hace nada..
Si el valor es negativo entonces se hace esto:  angulo_positivo_resultante_de_un_angulo_negativo = (90000 - angulo_ * -1) + 260000;

[SplinterGU]

como es eso que retornan de -90 a 260?

nunca me di cuenta de eso...

por otro lado, no se porque complicas la formula...

por que haces -angulo*-1? si angulo es < 0 entonces simplemente has +angulo.

[Erkosone]

nop, eso fue lo primero que probé pero no funciona bien, por que no es un angulo del primer cuadrante, es del cuarto..
Es algo bien curioso jeje.. pruebalo y me cuentas, intenta hacer que un proceso rebote al colisionar con otro.. verás el problema con esto claramente ;)

[SplinterGU]

a ver... yo digo esto

angulo_explosion_ = 90000 + angulo_explosion + 260000;

bueno, mas bien digo

angulo_explosion_ = 350000 + angulo_explosion_;

pero vamos que eso tampoco esta bien... ya que te estan faltando 10 grados

la cosa es

if ( angulo_explosion_ < 0 ) angulo_explosion_ += 360000; end

eso es lo que va...

[SplinterGU]

explicacion matematica


angulo es negativo, tu restas... entonces:

- * - = +

y luego lo multiplicas por -1, con lo que vuelves a cambiar el signo al original... resumiendo, el - de la resta con el *-1 de la multiplicacion se cancelan a si mismos, y te queda +

[Erkosone]

Pues parece lógico jeje.. aveces me complico yo solo haciendo pruebas  :-[
La sugerencia sigue en pie, si crees que merece la pena que retorne angulos de entre 0 y 360000 por mi encantado ya que ese if no haría falta ;)

[SplinterGU]

el problema es que para calculos donde necesitas saber el angulo mas cercano, haciendo un abs del angulo, se va a perder esa posibilidad

lo que me extraña es que retorne de -90 a 270...

[Arcontus]

La verdad es que a veces dificulta la programación, bueno a veces no, bastantes veces.

Creo que es una genial idea.

[Kloppix]

Para mantener los ángulos negativos o mayores a 360º en el rango 0-360000 lo que yo hice fué:

  #Define to360(numero) ((360000 + numero%360000)%360000);

con el caso de get_angle sería entonces usar algo como:

  direccion=to360(get_angle(id_otroProceso));

Ahora supongamos que tenemos un proceso con angulo variable y queremos saber el ángulo entre un segundo proceso y el ángulo que ya tiene el proceso principal. Por ejemplo una nave que puede rotar y que tiene un poder que dispara automaticamente a un enemigo.

direccion=to360(get_angle(id_otroProceso)-angle);

[Drumpi]

Sé que esto es antiguo, pero...
Creo que lo de tener ángulos negativos tiene que ver con las comparaciones. Un ángulo de 300º es mayor que 0º, mientras que uno de -30º es menor que uno de 0º. Es más, parece que lo más correcto sería tener ángulos desde -179999 hasta 180000.

Pero bueno, es un poco divagar. Hasta las calculadoras científicas tienen problemas con esto. Y es que trabajar con ángulos es muy peliagudo, porque no estamos en un espacio lineal, sino circular, y te pongas como te pongas, problemas cón ángulos vas a tener siempre.
Intenta implementar un contador de vueltas usando el ratón respecto al centro de la pantalla, pero en el que no se pueda hacer trampas y haya que dar la vuelta en un único sentido.