yo hice lo siguiente... a ver si te sirve, pq la teoria la tenia, pero en la practica algo fallaba

Quizas soy mu bruto...yo tengo en ram una copia del buffer de los planos de sprites  (de todos) 4 bytes por cada 1 (posY,posX,color,patron)(32*4 = 128 bytes). Y lo volco cada vez. Lo que cambio cada vez que volvo a VRAM es el orden,pero en RAM siempre tienen el mismo numero de sprite. Es decir...planteo ejemplo que se vera claro.

SPRITE en RAM
00-01-02-03-04-05 ... 30-31 (32 planos eran no?)
Marco que los 2 primeros son fijos

A cada interrupcion en VRAM se suben asi:
00-01-03-04-05...30-31-02
00-01-04-05...30-31-02-03
00-01-05...30-31-02-03-04

De esta manera la referencia RAM siempre es la misma, pero la rutina de subida es la que cambia el orden.
Para tu programa que escribe en RAM, le da igual en que plano se pinte el sprite, el numero que tu usas para el calculo de datos es siempre el mismo.

Esto tiene un problema...que no puedes tratar los sprites con profundidad Z, es decir, controlar quien va delante o quien va detras, pero en muchos juegos eso es irrelevante.
Esta rotacion la haria SIEMPRE, independientemente de que haya bit de 5o Sprite o no, porque aunque si no la hay se verán todos bien y si la hay, ya parpadeará to solito

Lo que me fallaba de esta teoria , era algo de punteros, que hacia un sprite de mas y tal, pero la rutina funcionaba bien y el parpadeo era soportable.

Creo recordar que esto me lo explicó viejo_archivero en un post por aquí.

Os digo como lo hago yo. Por un lado, los sprites del prota no me gusta que flickeen, así que siempre los dejo fijos, pero vamos, que podéis hacerlo como queráis, incluyendo al prota o no. Esto es lo que hago en cada frame:

- Esto es el loop del juego
- Gestiono el juego, y todo lo relativo a atributos sprites lo guardo en RAM en un buffer (4 bytes por cada sprite), que lo llamo SPRATR.
- Cuando ya tengo todo listo, y antes de la interrupción, DUPLICO el contenido en otro buffer que está justo seguido en la RAM (llamemosle SPRATR2) con un simple LDIR. De esta forma, tengo 2 buffers con los atributos de sprites duplicados, uno JUSTO SEGUIDO del otro y que ocupan lo mismo.
- Tengo otra variable, que es el PUNTERO desde donde tengo que empezar a leer dichos datos para transferirlos a VRAM. Le sumo 4 y listos. Si ha llegado al tope, lo reinicio al valor incial.

- HALT - synch!

- Transfiero los sprites a VRAM a partir de mi PUNTERO. La cantidad a transferir siempre es la misma, pero el orden no lo será, al ir aumentando +4 el puntero. Cuando se "pase" del buffer normal SPRATR, como tiene una copia exacta seguida en SPRATR2 empezarán los datos desde el primer sprite. Así la rotación es "automática" y solo depende de gestionar ese puntero.

- Vuelvo al loop


Así es como lo hago yo, por ejemplo en Infinity y en British Bob , y corre bastante finito.