Listo, ahora si quedó bien:

            // 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:

    /**
     * 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
        );
    }

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.

            // 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

            // 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.

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:

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

Finalmente quedó así:

/**
     * 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);
            }else{
                this.angle -= (diff_millisecond / 10);
            }
            // Previene el desbordamiento
            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
        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.1 a 3.1
        Float alpha = -(((6.2F * angle_percent) / 100.0F) - 3.1F);
 
        // Posiciona el objeto al centro del circulo
        this.matrix.postTranslate(
                this.start_circle.getLeft() + (this.start_circle.getWidth() / 2) - (this.image.getWidth() / 2) +
                        (((Double)Math.sin(alpha)).floatValue() * (this.start_circle.getWidth() / 2)),
                this.start_circle.getTop() + (this.start_circle.getHeight() / 2) - this.image.getHeight() +
                        (((Double)Math.cos(alpha)).floatValue() * (this.start_circle.getHeight() / 2))
        );
    }

Le agregué la opción para rotar en sentido contrario cuando sea necesario.

Me di cuenta que la función cos y sin no inician directamente desde el grado 0 al 360 sino que utiliza valores mas extraños, por ejemplo el valor de alpha del 0 al 6.2 da una vuelta en 360 grados pero este inicia a partir de un costado y no desde el grado cero que es la parte superior central del circulo, por lo cual calculé que la posición de grado cero es 3.1 y para 360 es -3.1, por lo cual 180 grados son 0 en alpha, asi que lo que hice sin tener que utilizar el valor del tiempo dle frame como en el ejemplo que me diste, me basé mejor en el grado de inclinación haciendo que sea mas fluido para cualquier cantidad de fps, entonces tomé el porcentaje de 0 a 360 y me dió un valor, luego de 0 a 6.2 le saqué el valor de ese porcentaje y luego le resté 3.1 para que volviera otraves de 3.1 a -3.1 y listo! me anda de lujo en el pc y en el movil.



Muchas gracias por la ayuda.

Saludos.

jajajaja pues si, tenía varias opciones para controlar los fps, al comienzo solo sabia manejar animaciones en base al while del update del canvas, pero con el tiempo me di cuenta que la velocidad del while era diferente en diferentes dispositivos, en el pc era rápido, en el movil era mas lento y no siempre era una velocidad constante, a veces la velocidad variaba de muy rápido a muy lento o a veces producía pequeños cortes, entonces como el audio se desincronizaba con la animación se me vino la pregunta de como corregir esto:

Una opción era enviar el numero del frame al controlador para que la animación y la pista de audio se sincronizara en base a la velocidad del frame, pero despues de esto tuve otro problema, este problema consistia en que cuando se bloqueaba la app por un tiempo muy corto (menos de un segundo) tanto la animación como el juego se cortaban, entonces cuando el lagg era muy grande la animación se veia muy cortado y los controles ya no funcionaban bien porque para terminar una acción con un botón tenias que mantenerlos sostenido o perdias la acción. Despues me di cuenta que este tipo de desface tambien lo sufrian la mayoría de los juegos de videos antiguos como los de ps1, snes, emuladores, etc, y ahi me di cuenta que todos esos juegos viejos se basan en la sincronización por frames.

Cuando me pasó eso me di cuenta que los juegos de hoy no sucede eso, por ejemplo si la animación se está ejecutando y hay lagg entonces el desface hace que por ejemplo si lanzas una pelota y a mitad de camino se bloquea la app lo verás al final del camino cuando se desbloquee, eso quiere decir que la sincronización ya no depende del frame sino del tiempo, a diferencia de la sincronización por frame que cuando se desbloquea la app ahi recien se ve la siguiente posicion de la pelota.

Me di cuenta que esto solucionaría el problema del desface del audio ya que a pesar de que la animación se bloquee este no impide que la animación se siga sincronizando con el audio, a demás permite que pequeños lags no afecte a la experiencia final del juego ya que podrás seguir jugando a la velocidad que acostumbras a pesar de que dejes de ver un par de frames.

Por eso se me ocurrió calcular la diferencia del tiempo en milisegundos y en base a eso calcular la siguiente posición del dibujado del canvas, de esa manera no limito la animación a x cantidad de frames por segundo sino que en ves de eso en cada frame la app calculará la posición y la posicionará donde debe ir, de otra manera si el juego se sincroniza por frames y tiempos (frameskip) hará que un juego diseñado a 60fps no se vea a mayor velocidad en dispositivos con una taza de refresco mas alta, pero de esta manera la animación se adapta a la taza de animación soportada por el hardware y le da una mejor experiencia al usuario final.

Realmente no lo leí de otros lados, lo saqué en base a conclusiones solamente.

Estoy creando un motor de animación en android con físicas, un framework para crear cosas como juegos, animaciones tipo power point, presentación de documentos, animaciones en general de todo tipo, quiero hacer algo como unity 3d pero en lenguaje nativo usando librerías en ves de embeber una app dentro de otra, esto hará que el motor sea mucho mas optimizado que unity y las animaciones sean mucho mas fluidas ya que no necesitarás embeber un sistema en mono (c#) utilizando la interpretación de la interpretación de un código, sino de manera nativa directamente sin una interfaz gráfica, solamente utilizando código. Mas que nada para facilitar el uso de animaciones en apps incluyendo físicas. Como ejemplo estoy probando crear la animación de un cohete despegando de planeta en planeta.

Muy bien!, ahora me toca ajustar la relación entre grados y el alpha que se le asignó, porque si le paso como alpha directamente el angulo, rota muy rápido, por ejemplo mi circulo rota 360 grados cada 5 segundos aprox y el valor del alpha que se ajusta perfectamente es 0.022, asi que tocará ajustar eso que no creo que sea tan dificil.

Por lo menos lo que me tenía mas preocupado funciona de lujo.

float alfa= 360;
 
    @Override
    public synchronized void update() {
        super.update();
 
        // Control de frames
        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
        if(!this.launched) {
            this.angle = this.angle + (diff_millisecond / 10);
            this.angle = (this.angle % 360); // Previene el desbordamiento
        }else{
            this.diameter_rotation_ship = this.diameter_rotation_ship + (diff_millisecond / 12);
        }
 
        // Controlador
 
        // Cambia el tamaño
        this.matrix.setScale(1, 1);
 
        // Rota la imagen a partir de su centro
        this.matrix.postRotate(this.angle, this.image.getWidth() / 2, this.image.getHeight());
 
        // Posiciona el objeto al centro del circulo
        this.matrix.postTranslate(
                this.start_circle.getLeft() + (this.start_circle.getWidth() / 2) - (this.image.getWidth() / 2) +
                        (((Double)Math.sin(alfa)).floatValue() * (this.start_circle.getWidth() / 2)),
                this.start_circle.getTop() + (this.start_circle.getHeight() / 2) - this.image.getHeight() +
                        (((Double)Math.cos(alfa)).floatValue() * (this.start_circle.getHeight() / 2))
        );
 
        /*
        this.matrix.postTranslate(
                this.start_circle.getLeft() + (((Double)Math.sin(alfa)).floatValue() * (this.start_circle.getWidth() / 2)),
                this.start_circle.getTop() + (((Double)Math.cos(alfa)).floatValue() * (this.start_circle.getHeight() / 2))
        );
        */
 
        alfa -= 0.022;//cambio 0.03 grados por frame
        alfa %= 360; // limito a 360 grados
        if(alfa == 0)
            alfa = 360;
    }

Muchas gracias, probaré lo de cos y sin.

Hola, tengo una duda, me he dado muchas vueltas y no llego a puerto aun.

Tengo un plano de 100x100, tengo un objeto en la posición 30x30, ¿cómo lo puedo mover de posición x cantidad de espacios usando un grado de inclinación?.

Por ejemplo, quiero moverlo en dirección hacia arriba y a la derecha en 45 grados.

El problema central es el siguiente: Tengo un circulo y un objeto que se mueve al rededor de el en su superficie, ambos objetos se mueven de manera independiente pero necesito que el objeto se mueva de manera que simule estar unido al borde del circulo, despues de esto tengo una función que debiera aumentar la separación entre el circulo y el objeto sin perder la sincronización de rotación ya que este circulo va rotando en una dirección al azar (ccw o cw).

Actualmente hice sin problemas que el objeto esté centrado con respecto al circulo y que este rote en la misma velocidad del circulo usando su base y no su centro, ahora solo necesito establecer su distancia, pero esta distancia esta relacionada con la cantidad de grados de rotación del objeto y ahi es donde quedé.

Hice este post en programación general porque no necesito que me hagan el código, quiero entenderlo para aplicarlo en muchas situaciones. De todas maneras este es el código que uso para hacer rotar el objeto sobre el circulo:

// Cambia el tamaño
        this.matrix.setScale(1, 1);
 
        // Rota la imagen a partir de su centro
        this.matrix.postRotate(this.angle, this.image.getWidth() / 2, this.image.getHeight());
 
        // Posiciona la nave al centro del circulo
        this.matrix.postTranslate(
                this.start_circle.getLeft() + (this.start_circle.getWidth() / 2) - (this.image.getWidth() / 2),
                this.start_circle.getTop() + (this.start_circle.getHeight() / 2) - this.image.getHeight()
        );

Es código Java para Android + canvas.

Una solución que encontré fue tomar el punto de rotación vertical muy abajo, para que simulara la rotación sobre un circulo, pero esto significaba que a la posición final tenía que restarle pixeles y cuando tenia que mover el objeto se me hacia todo un desmadre incontrolable y para solucionarlo tenía que crear condicionales para saber si el opbjeto estaba rotando o habia que aumentar el espacio y tenia un código muy mal optimizado, asi que lo eliminé y ando en busca de algo mas óptimo.

El tema debiera quedar algo así:

• Si el grado es 0 entonces se suma la distancia el 100% sobre vertical
• Si el grado es 45 entonces se suma la distancia el 50% sobre vertical y 50% horizontal
• Si el grado es 90 entonces se suma la distancia el 100% sobre horizontal
• si el grado es 135 entonces se suma la distancia el 50% horizontal y se resta el 50% vertical
• si el grado es 180 entonces se resta la distancia el 100% vertical
• si el grado es 225 entonces se resta la distancia el 50% sobre vertical y 50% horizontal
• si el grado es 270 entonces se resta la distancia 100% sobre horizontal
• Si el grado es 315 entonces se resta la distancia 50% sobre horizontal y se suma 50% sobre vertical
• Si el grado es 360 entonces se suma la distancia el 100% sobre vertical

Saludos.

He encontrado un proyecto en github que me ha hecho reir bastante, me ha cambiado el día xD

https://github.com/keroserene/rickrollrc

Los que usan Linux pueden ejecutar el script así:


No es nada malicioso. Enjoy.

Hola, tengo algunas apps instaladas en un servidor con centos7 como zimbra, confluence, bitbucket, etc, y cada app tardaa una ifinidad en iniciar, zimbra se que usa muchos servicios asi que es normal, pero hay otros en que despues de iniciar el servicio debo esperar por lo menos 15 minutos para que el sitio web pueda ser accesible.

Esto es normal en un proyecto java transaccional hecho con con hibernate? ya que quiero probar hacer algunos desarrollos, pero si realmente es tan lento en iniciar y es tan problemático como servicios, mejor prefiero usar otro lenguaje mas flexible y rápido como python.