JavaFx 2.0: un enfoque para la animación de sprites de juegos

Guau... JavaFx 2 me ha hecho perder el control cuando se trata de programación de juegos. Estoy tratando de determinar cuál es la mejor manera de abordar la animación de sprites controlada por el jugador. (es decir, hacer que los enemigos y las cosas y el jugador se animen).

Sé cómo escribir código para leer una hoja de sprites y configurar un bucle de juego en AS3 o Java swing... pero me está costando mucho entender cómo debería interactuar el bucle de animación en mi juego con cualquier componente. de FX es que renderiza.

He estudiado la api. Hay una clase TranslateTransition. Pero me parece excesivo en comparación con otros idiomas. Y todo lo demás parece completamente basado en la interfaz o simplemente demasiado limitado.

Estoy leyendo Pro JavaFx2 de Weaver... y hombre, ¿tengo problemas para replicar ese estilo de codificación? Pero puedo leerlo encontrar :) Aún no sé si amar u odiar a esta bestia.

¿Alguna sugerencia?

preguntado el 22 de mayo de 12 a las 20:05

2 Respuestas

Lea esta entrada de blog: http://blog.netopyr.com/2012/03/09/creating-a-sprite-animation-with-javafx/

Esta es la mejor realización de la animación de sprites de JavaFX :)

contestado el 22 de mayo de 12 a las 22:05

Llegué un poco tarde a la fiesta en este caso, pero pensé en contribuir con mi solución para la animación de sprites con JavaFX. Aquí hay una clase que puede pegar en sus propios proyectos para mostrar una animación de sprite usando ImageView, la animación es independiente de la velocidad de fotogramas.

import javafx.animation.AnimationTimer;
import javafx.geometry.Rectangle2D;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;

public class ImageViewSprite extends AnimationTimer {


    private final ImageView imageView; //Image view that will display our sprite

    private final int totalFrames; //Total number of frames in the sequence
    private final float fps; //frames per second I.E. 24

    private final int cols; //Number of columns on the sprite sheet
    private final int rows; //Number of rows on the sprite sheet

    private final int frameWidth; //Width of an individual frame
    private final int frameHeight; //Height of an individual frame

    private int currentCol = 0;
    private int currentRow = 0;

    private long lastFrame = 0;

    public ImageViewSprite(ImageView imageView, Image image, int columns, int rows, int totalFrames, int frameWidth, int frameHeight, float framesPerSecond) {
        this.imageView = imageView;
        imageView.setImage(image);
        imageView.setViewport(new Rectangle2D(0, 0, frameWidth, frameHeight));

        cols = columns;
        this.rows = rows;
        this.totalFrames = totalFrames;
        this.frameWidth = frameWidth;
        this.frameHeight = frameHeight;
        fps = framesPerSecond;

        lastFrame = System.nanoTime();
    }

    @Override
    public void handle(long now) {
        int frameJump = (int) Math.floor((now - lastFrame) / (1000000000 / fps)); //Determine how many frames we need to advance to maintain frame rate independence

        //Do a bunch of math to determine where the viewport needs to be positioned on the sprite sheet
        if (frameJump >= 1) {
            lastFrame = now;
            int addRows = (int) Math.floor((float) frameJump / (float) cols);
            int frameAdd = frameJump - (addRows * cols);

            if (currentCol + frameAdd >= cols) {
                currentRow += addRows + 1;
                currentCol = frameAdd - (cols - currentCol);
            } else {
                currentRow += addRows;
                currentCol += frameAdd;
            }
            currentRow = (currentRow >= rows) ? currentRow - ((int) Math.floor((float) currentRow / rows) * rows) : currentRow;

            //The last row may or may not contain the full number of columns
            if ((currentRow * cols) + currentCol >= totalFrames) {
                currentRow = 0;
                currentCol = Math.abs(currentCol - (totalFrames - (int) (Math.floor((float) totalFrames / cols) * cols)));
            }

            imageView.setViewport(new Rectangle2D(currentCol * frameWidth, currentRow * frameHeight, frameWidth, frameHeight));
        }
    }
}

Implemente esto con lo siguiente:

ImageViewSprite anim = new ImageViewSprite(ImageView, new Image("/pathToImage"), columns, rows, totalNumberOfFrames, FrameWidth, FrameHeight, FPS);
anim.start();

respondido 17 mar '14, 22:03

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.