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;
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.
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 ;)
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...
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 +
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 ;)
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...
La verdad es que a veces dificulta la programación, bueno a veces no, bastantes veces.
Creo que es una genial idea.
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);
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.