Mejores prácticas de animación de sprites

Me gustaría tener una mejor idea de cómo las personas en el mundo real manejan su animación.

¿Carga 1 imagen grande y luego dibuja diferentes rectángulos basados ​​en el cuadro de animación?

¿Carga archivos de imagen X en una matriz y dibuja el elemento en la matriz según el marco de animación?

¿Cómo manejas tener diferentes longitudes de animaciones para varios sprites?

Digamos que un personaje caminando toma de 4 a 8 cuadros, y las olas en la playa solo toman de 2 a 3 cuadros. ¿Cómo manejarías esa situación? Vea abajo

Dim Waves(1) as Sprite
Dim Char(5) as Sprite

Sub Animate()
     Frame += 1
     Draw Char(Frame)
     Draw Waves(Frame)
     If Frame = 5 Then Frame = 0
End Sub

Obviamente, Waves terminaría con un error fuera de límites.

¿O tiene su sprite preocupado por su propia animación, y no le importa el marco en absoluto? ¿Hacer que cada sprite conozca su propio ciclo de animación?

La forma en que lo hice en el pasado es separando los datos de animación de la reproducción de animación . AnimationLuego, una puede convertirse básicamente en una matriz Framesy algunas propiedades que describen cómo debe comportarse la animación (si se repite, etc.).

Normalmente cargo una imagen y dibujo partes de ella.

Cada una Framede las animaciones es esencialmente un rectángulo y un período de tiempo. Esto permite que algunos cuadros se muestren más tiempo que otros, lo que puede o no ser lo que desee. Si desea que todos los cuadros de su animación se muestren durante el mismo período de tiempo, guárdelos en su Animationobjeto.

Cualquier cosa que necesite reproducir una animación tiene su propia AnimationPlayerque se puede señalar a una Animation. El objeto reproductor se encarga de reproducir la animación y pone a disposición el "cuadro actual".

La ventaja de esto para mí fue que podía tener una sola instancia de una a la Animationque muchos objetos podían apuntar y estar jugando diferentes partes al mismo tiempo. También fue fácil cambiar las animaciones simplemente apuntando AnimationPlayera un Animationobjeto diferente y reiniciando la reproducción.

Editar : Aquí hay una implementación de JavaScript bastante básica del sistema descrito anteriormente . Lo junté en unos minutos como demostración . El código "real" tendría más funciones. Sin embargo, necesitará un navegador moderno que sea compatible con Canvas y URI de datos para que funcione.

Me gustaría que una animación supiera cuántos fotogramas tiene. Dónde y cómo se almacenan estos es relativamente irrelevante, excepto por problemas de rendimiento (como puede quererlos en la misma textura). Nunca agregaría 1 al número de cuadros, agregaría deltaTime * animSpeed ​​y convertiría ese valor a un entero cuando se muestre. De esta forma, puede ralentizar o acelerar las animaciones y es independiente de la velocidad de fotogramas.

Entonces un sprite tendría una animación que se actualizaría.

¿Por qué no simplemente tener un número de cuadros para cada uno de sus objetos almacenados? Personalmente, paso el número de cuadros en la animación a mis objetos en sus constructores, luego tengo una función Animate () estándar que toma la cantidad de cuadros en la animación.

Depende de la implementación. En mi motor, hago animación en Direct3D y DirectDraw.

En DirectDraw creo una imagen grande. De todos modos, todo se almacena en la memoria del sistema, que finalmente se reduce a un bloque de datos unidimensional.

Pros:

• Fácil de mover entre cuadros. Cambie el puntero de inicio, agregue el tono (el ancho total de la imagen) cada y y estará dorado.

Contras:

• No puede simplemente copiar un cuadro en la pantalla, debe hacerlo manualmente.

• Bloque gigante de memoria. El apresuramiento de los marcos tiene una penalización

En Direct3D utilizo texturas separadas. Esto se debe a que no tengo idea de las limitaciones de textura de un dispositivo, por lo que no sé si incluso admite texturas del tamaño de toda la imagen.

Pros:

• Puede copiar un marco directamente a la pantalla, porque son todas entidades separadas.

Contras:

• Falta de alineación de la memoria.

En mis juegos , he dado a mi clase base de Sprite el conocimiento sobre cómo dibujarse, y todos los elementos animados heredan ese conocimiento: número y duración de los cuadros de animación, posición en la pantalla, etc. El ciclo principal del juego simplemente repite todo de los sprites, pidiéndole a cada uno que se dibuje como mejor le parezca. Parece funcionar bastante bien, y es un poco más modular para arrancar: si agrega un nuevo sprite que tiene un ciclo de animación diferente (o incluso más complejo: múltiples estados de animación), no tiene que regresar y reescribir su Animate () rutina para acomodar la complejidad adicional:

Dim Waves as Sprite
Dim Char as Sprite

Sub Animate()
     Char.update()
     Waves.update()
End Sub

Cada vez que se llama al método update () de un sprite, sabe si debe volver a dibujar el mismo cuadro que la última vez, pasar al siguiente cuadro en su animación actual, cambiar a una nueva animación, etc.

Esto tiene el beneficio adicional de hacer que sea mucho más fácil ajustar la velocidad de fotogramas para acomodar diferentes velocidades de representación de reloj / plataforma, porque el único cambio es la frecuencia con la que llama a Animate ().