Necesito una mano para calcular distancias XY

[WHK]

no está en sexagesimale, sino en radian XD casualmente media vuelta era 3.1416 grados cuando un circulo tiene incluso 2 pi de perimetro jejeje

hombre te has dado cuenta de detalles base de la ciencia rapido jejeje, en poco seguro das con turing u otro teorema de otra ciencia XD

exito con el programa

Eaaa!! tienes razón, no sabía eso, por eso cuando dejaba funcionando la animación, despues de un minuto aprox la imagen de la nave se desfasaba un poco con respecto al planeta y daba la impresión que la nave se acostaba sobre el planeta en ves de estar de pie xD, me dije... creo que es un poco mas que 3.1 , despues leí tu post y bingo! era PI xD, asi que he modificado el script reemplazando 3.1 por pi y funciona mucho mejor:

Código (java) [Seleccionar] Expandir

Float alpha = -(((( ((Double)Math.PI).floatValue() * 2.0F) * angle_percent) / 100.0F) - ((Double)Math.PI).floatValue());

Como pi no es perfecto supongo que si dejo la animación varios dias temrinaré con la nave desfasada con respecto al planeta, eso pasó porque comenté la línea que hacia módulo de 360 para que despues de 360 vuelva a cero, pero da problemas cuando necesito invertir el valor (para hacer que gire en sentido contrario), pero ese es un problema mucho menor y solucionable.

Lo que haré para prevenir el desface es descomentar la función de módulo para que solo funcione entre 0 y 360 y buscar otro alternativo para invertir los valores dependiendo de la orientación.

Muchas gracias otraves

[engel lex]

usa un if para volver alfa a 0 si alfa mayor que PI, así el defecto como mucho será un salto de (suponiendo pi a 3.1400000) 0.0016... cosa que es imperceptible y no acumulativo (porque alfa vuelve a 0)

[WHK]

Asi es, tienes razón, el valor modular en ambos sentidos siempre es el mismo porque el resto es igual con valor negativo y valor positivo.

Código (java) [Seleccionar] Expandir


           // CW o CCW
           if(clock_wise) {
               this.angle += (diff_millisecond / 10);
               if(this.angle > 360)
                   this.angle = 0.0F;
           }else{
               this.angle -= (diff_millisecond / 10);
               if(this.angle < 0)
                   this.angle = 360.0F;
           }

           // El valor modular es el mismo en ambos sentidos asi que deja de funcionar
           // el sentido de rotación dinámico
           // this.angle = (this.angle % 360);

Me di cuenta que también tendré que agregar la diferencia, por ejemplo si de 359 pasa a 361 entonces el grado debe quedar en 1 y no en 0 jajaja

Código (java) [Seleccionar] Expandir


            // CW o CCW
            if(clock_wise) {
                this.angle += (diff_millisecond / 10);
                if(this.angle >= 360)
                    this.angle = 0.0F + (this.angle - 360);
            }else{
                this.angle -= (diff_millisecond / 10);
                if(this.angle <= 0)
                    this.angle = 360.0F + this.angle;
            }

            // El valor modular es el mismo en ambos sentidos asi que deja de funcionar
            // el sentido de rotación dinámico
            // this.angle = (this.angle % 360);

Si el grado es 365 entonces queda en 0 + (365 - 360) = 5 grados, el problema es cuando la cantidad de grados ha aumentado mas de una vuelta completa en un lagg, por ejemplo que de 1 grado haya llegado a 800, entonces: 0+(800-360)=440 entonces debo volver a disminuir el valor, en ese caso podría utilizar un resto o el módulo y vuelvo al mismo problema xD, creo que usar condicionales no era una buena opción a menos que use un while para recorrer todas las posibles disminuciones y el uso de CPU se va a elevar considerablemente cuando tenga muchos objetos, asi que trataré de pensar como voltear el valor aun usando módulo.

Saludos.

[WHK]

Listo, ahora si quedó bien:

Código (java) [Seleccionar] Expandir


           // CW o CCW
           if(clock_wise) {
               this.angle += (diff_millisecond / 10);
                if(this.angle >= 360)
                    this.angle = 0.0F + (this.angle % 360);
           }else{
               this.angle -= (diff_millisecond / 10);
               if(this.angle <= 0)
                    this.angle = 360.0F + (this.angle % 360);
           }

He usado el módulo a modo de diferencia sobre el calculo real basado en condicionales, de esa manera puedo invertir el valor de la rotación sin tener el problema del desface ni desbordamiendo numérico

Acá va el código completo de la función de rotación:

Código (java) [Seleccionar] Expandir


   /**
    * Actualiza la posición de los objetos
    */
   @Override
   public synchronized void update() {
       super.update();

       /**
        * Control de frames.
        * Controla los frames dependiendo del tiempo transcurrido,
        * esto prefieve en desface por lagg.
        */
       if (last_millisecond == null) {
           this.last_millisecond = Calendar.getInstance().getTimeInMillis();
       }

       Long current_millisecond = Calendar.getInstance().getTimeInMillis();
       Long diff_millisecond = current_millisecond - this.last_millisecond;
       this.last_millisecond = current_millisecond;


       /**
        * Contexto.
        * Calcula el grado de inclinación de los objetos y todo aquello
        * que sea necesario para calcular distancias y posicionamiento.
        */
       if(!this.launched) {
           // CW o CCW
           if(clock_wise) {
               this.angle += (diff_millisecond / 10);

               // Previene el desbordamiento (solo de 0 a 360)
               if(this.angle >= 360)
                   this.angle = 0.0F + (this.angle % 360);
           }else{
               this.angle -= (diff_millisecond / 10);

               // Previene el desbordamiento (solo de 360 a 0)
               if(this.angle <= 0)
                   this.angle = 360.0F + (this.angle % 360);
           }

           // El valor modular es el mismo en ambos sentidos asi que deja de funcionar
           // el sentido de rotación dinámico
           // this.angle = (this.angle % 360);

       }else{
           this.diameter_rotation_ship = this.diameter_rotation_ship + (diff_millisecond / 12);
       }


       /**
        * Controlador.
        * Controla el posicionamiento de los objetos para ser dibujado.
        */

       // Cambia el tamaño
       this.matrix.setScale(1, 1);

       // Rota la imagen a partir de su centro y base inferior vertical
       this.matrix.postRotate(this.angle, this.image.getWidth() / 2, this.image.getHeight());

       // % del angulo de 0 a 360
       Float angle_percent = ((this.angle * 100.0F) / 360);

       // -3.1415 a 3.1415 (-pi a pi)
       // PI es la posición de grado 0 de inclinación y -PI es 360 grados, por lo cual 0 es 180 grados
       // comenzando desde el punto superior vertical y centro horizontal.
       // Calcula el porcentaje entre -pi y pi, en ves de esto se usa pi*2 y luego se resta pi.
       Float alpha = -(((( ((Double)Math.PI).floatValue() * 2.0F) * angle_percent) / 100.0F) - ((Double)Math.PI).floatValue());

       // Añadidura de espacio en dirección hacia el grado de rotación del circulo principal
       Float horizontal_padding = ((Double)Math.sin(alpha)).floatValue();
       Float vertical_padding = ((Double)Math.cos(alpha)).floatValue();

       // Cantidad de espacio añadido (desde el centro hacia el borde del circulo principal,
       // es la mitad del diametro o su radio)
       horizontal_padding *= (this.start_circle.getWidth() / 2);
       vertical_padding *= (this.start_circle.getHeight() / 2);

       // Posiciona el objeto al centro del circulo
       this.matrix.postTranslate(
               this.start_circle.getLeft() + (this.start_circle.getWidth() / 2) - (this.image.getWidth() / 2) + horizontal_padding,
               this.start_circle.getTop() + (this.start_circle.getHeight() / 2) - this.image.getHeight() + vertical_padding
       );
   }