Empezamos por un borrado de pantalla a un color de la paleta:
Código: Seleccionar todo
// ___________________________________________
// Borra la pantalla a un color
// ___________________________________________
void cls (int color)
{
#asm
ld hl,2 ;pasamos la variable de entrada al acumulador
add hl,sp
ld a, (hl)
rla ;rotamos 4 bits a la izquierda
rla
rla
rla ;ya tenemos el color del primer pixel
add a, (hl) ;añadimos el color del segundo pixel
ld hl, 16384
ld de, 16385
ld bc, 6143
ld (hl), a
ldir
#endasm
}
Código: Seleccionar todo
// ___________________________________________
// Definir paleta de color
// ___________________________________________
void escribe_paleta (int indice, int color)
{
// Los bits del color van en forma GGGRRRBB
port_out (48955, indice);
port_out (65339, color);
}
Código: Seleccionar todo
// ___________________________________________
// Posiciona un Sprite de 8x8 a color
// ___________________________________________
void put_sprite_x8 (unsigned char *posicion, unsigned int x, unsigned int y)
{
// -------------------------------------------
// RUTINA DE IMPRESION DE UN SPRITE 8x8 PIXELS
// EN CUALQUIER POSICION DE BYTES (cada byte dos pixels horizontales)
// ENTRADAS:
// D será la posición del cursor vertical en pixels
// E será la posición del cursor horizontal en parejas de pixels
// HL es la posición de memoria donde tenemos el sprite
// SALIDAS: se escribe en el mapa de pantalla
// ADVERTENCIAS: no comprueba límites de pantalla
// -------------------------------------------
#asm
ld hl,2 ; Pasamos la variable de entrada al acumulador
add hl,sp
ld d, (hl) ; D es el valor Y
inc hl
inc hl
ld e, (hl) ; E es el valor X
inc hl
inc hl
ld a, (hl)
inc hl
ld h, (hl)
ld l, a ; HL es el puntero al sprite
ld a, d ; recuperamos el valor vertical
rrca
rrca ; rotamos para dejar su valor en múltiplos de 64 (linea, de dos en dos pixels)
and 192 ; borramos el resto de bits por si las moscas
or e ; sumamos el valor horizontal
ld e, a ; e preparado
ld a, d ; cargamos el valor vertical
rrca
rrca ; rotamos para quedarnos con los bits altos
and 63 ; borramos el resto de bits
or 64 ; nos posicionamos a partir de 16384 (16384=64+0 en dos bytes)
ld d, a ; d preparado, ya tenemos la posición en pantalla
ld b,8 ; Indicamos que vamos a pintar 8 líneas
.draw ; dibujamos 8 pixels (4 bytes)
ld c,4 ; Indicamos que vamos a pintar 4 pares de pixels
ldi
ldi
ldi
ldi
ld a,e
add a,60 ; incrementamos una línea y retornamos los pixels dibujados
ld e,a
jr nc, sigue
inc d ; incrementamos D si sale acarrero al incrementar E en 64 bytes
.sigue
djnz, draw
ret
#endasm
}
Código: Seleccionar todo
// ___________________________________________
// Posiciona un Sprite de 8x8 a color con máscara
// ___________________________________________
void put_msprite_x8 (unsigned char *posicion, unsigned int x, unsigned int y)
{
// -------------------------------------------
// RUTINA DE IMPRESION DE UN SPRITE 8x8 PIXELS CON MÁSCARA
// EN CUALQUIER POSICION DE BYTES (cada byte dos pixels horizontales)
// El color de la máscara es el 0, no necesita máscara adicional
// ENTRADAS:
// D será la posición del cursor vertical en pixels
// E será la posición del cursor horizontal en parejas de pixels
// HL es la posición de memoria donde tenemos el sprite
// SALIDAS: se escribe en el mapa de pantalla
// ADVERTENCIAS: no comprueba límites de pantalla
// -------------------------------------------
#asm
ld hl,2 ; Pasamos la variable de entrada al acumulador
add hl,sp
ld d, (hl) ; D es el valor Y
inc hl
inc hl
ld e, (hl) ; E es el valor X
inc hl
inc hl
ld a, (hl)
inc hl
ld h, (hl)
ld l, a ; HL es el puntero al sprite
ld a, d ; recuperamos el valor vertical
rrca
rrca ; rotamos para dejar su valor en múltiplos de 64 (linea, de dos en dos pixels)
and 192 ; borramos el resto de bits por si las moscas
or e ; sumamos el valor horizontal
ld e, a ; e preparado
ld a, d ; cargamos el valor vertical
rrca
rrca ; rotamos para quedarnos con los bits altos
and 63 ; borramos el resto de bits
or 64 ; nos posicionamos a partir de 16384 (16384=64+0 en dos bytes)
ld d, a ; d preparado, ya tenemos la posición en pantalla
ld b,8 ; Indicamos que vamos a pintar 8 líneas
.mdraw1 ; dibujamos 8 pixels (4 bytes)
ld a, (hl)
cp 0
jr z, nodraw1 ;si los pixels son 0 saltamos
ld (de),a
.nodraw1
inc hl
inc de
ld a, (hl)
cp 0
jr z, nodraw2 ;si los pixels son 0 saltamos
ld (de),a
.nodraw2
inc hl
inc de
ld a, (hl)
cp 0
jr z, nodraw3 ;si los pixels son 0 saltamos
ld (de),a
.nodraw3
inc hl
inc de
ld a, (hl)
cp 0
jr z, nodraw4 ;si los pixels son 0 saltamos
ld (de),a
.nodraw4
inc hl
inc de
ld a,e
add a,60 ; incrementamos una línea y retornamos los pixels dibujados
ld e,a
jr nc, msigue
inc d ; incrementamos D si sale acarrero al incrementar E en 64 bytes
.msigue
djnz, mdraw1
ret
#endasm
}
Código: Seleccionar todo
// ___________________________________________
// Recoge un Sprite de 8x8 a color de pantalla
// ___________________________________________
void get_sprite_x8 (unsigned char *posicion, unsigned int x, unsigned int y)
{
// -------------------------------------------
// RUTINA DE CAPTURA DE UN SPRITE 8x8 PIXELS
// EN CUALQUIER POSICION DE BYTES (cada byte dos pixels horizontales)
// ENTRADAS:
// D será la posición del cursor vertical en pixels
// E será la posición del cursor horizontal en parejas de pixels
// HL es la posición de memoria donde tenemos el sprite
// SALIDAS: se escribe en el mapa de pantalla
// ADVERTENCIAS: no comprueba límites de pantalla
// -------------------------------------------
#asm
ld hl,2 ; Pasamos la variable de entrada al acumulador
add hl,sp
ld d, (hl) ; D es el valor Y
inc hl
inc hl
ld e, (hl) ; E es el valor X
inc hl
inc hl
ld a, (hl)
inc hl
ld h, (hl)
ld l, a ; HL es el puntero al sprite
ld a, d ; recuperamos el valor vertical
rrca
rrca ; rotamos para dejar su valor en múltiplos de 64 (linea, de dos en dos pixels)
and 192 ; borramos el resto de bits por si las moscas
or e ; sumamos el valor horizontal
ld e, a ; e preparado
ld a, d ; cargamos el valor vertical
rrca
rrca ; rotamos para quedarnos con los bits altos
and 63 ; borramos el resto de bits
or 64 ; nos posicionamos a partir de 16384 (16384=64+0 en dos bytes)
ld d, a ; d preparado, ya tenemos la posición en pantalla
ex de,hl ; intercambiamos DE y HL
ld b,8 ; Indicamos que vamos a recoger 8 líneas
.gdraw ; recogemos 8 pixels (4 bytes)
ld c,4 ; Indicamos que vamos a pintar 4 pares de pixels
ldi
ldi
ldi
ldi
ld a,l
add a,60 ; incrementamos una línea y retornamos los pixels leidos
ld l,a
jr nc, gsigue
inc h ; incrementamos H si sale acarrero al incrementar E en 64 bytes
.gsigue
djnz, gdraw
ret
#endasm
}
Código: Seleccionar todo
// ___________________________________________
// Pone una pantalla completa
// ___________________________________________
void put_screen (unsigned char *posicion)
{
// -------------------------------------------
// RUTINA DE IMPRESION DE UNA PANTALLA
// 128x96 pixels
// -------------------------------------------
#asm
ld hl,2 ; Pasamos la variable de entrada al acumulador
add hl,sp
ld a, (hl)
inc hl
ld h, (hl)
ld l, a ; HL es el puntero al sprite
ld de, 16384 ; DE es el puntero a pantalla
ld bc, 6144
ldir
ret
#endasm
}
Lo bueno es que no tenéis que preocuparos de convertir los gráficos, ya que podéis usar la herramienta en java que realicé. Con ella podéis crear una paleta y convertir los tiles/sprites a golpe de clic.