Taller de programación video-juego. Nivel 1.

[badaman]

La imagen (que por cierto, le he cambiado el fondo que no me acababa de convecer) no es que sea gran cosa, pero para el tema da el pego.

Hablaba con Zerover hoy sobre como aprvechar las rutinas que ya tenemos para el juego.

Teniendo en memoria la pantalla del juego, y contando con la runita sprite_maq para pintar sprites con transparencia, sólo necesitaríamos una pequeña rutina que restaure de la memoria donde está almacenada la pantalla, un rectangulo de imagen para volcar en la memoria de pantalla. Es decir, es como si tuviesemos dos pantallas, la real y la de respaldo. Para restaurar lo que los sprites pinten solo hay que coger lo que necesitemos de la patalla de respaldo y volcarlo a la pantalla real. estos trozos tendrian forma rectangular, y las medidas del propio sprite.

Esto nos será de gran ayuda también cuando tengamos que pintar el suelo en la zona donde estén los ladrillos, y agiliza y facilita mucho más la tarea de usar sprites en este juego.

Mientras no tengamos esa rutina, lo que puedes hacer es pintar una ventana negra encima de las baldosas rosas y azules, y pintar rectangulos negros sobre los sprites cuando quieras borrarlos. Esto ultimo, se sustituirá en su momento por la rutina en C/M de la que hablaba en el parrafo anterior, y entonces tambien quitaremos el fondo negro.

Para borrar los marcadores por cierto sólo necesitas pintar recuadros azules encima de los números.

Si no me he explicado con claridad, indicamelo, porque todo esto suena un poco lioso.

[Zerover]

Aquí pongo un par de subrutinas en código ensamblador para el trabajo de pantalla. Todavía no las he compilado ni probado, pero las avanzo para que podáis probarlas si tenéis un rato antes que yo.

Código: Seleccionar todo

; Copiar la pantalla
; CALL copiar_pantalla,origen,destino
; Parametros: D1->A0 = dirección origen
;             D2->A1 = dirección destino
COPPAN_SB:      MOVEA.L D1,A0
                MOVEA.L D2,A1
COPPAN:         MOVE.L #$2000,D0
CP_BUCLE:       MOVE.L (A0)+,(A1)+
                DBRA D0,CP_BUCLE
                RTS

Se puede usar tanto para guardar la pantalla en la memoria como para recuperar de la memoria una pantalla o copiar una pantalla de memoria a memoria siempre que no se solapen.

Código: Seleccionar todo

; Recuperar un rectángulo dentro de la pantalla
; CALL recurect,x,y,an,al,respaldo,montaje
; Parametros: D1 = x
;             D2 = y
;             D3 = anchura
;             D4 = altura
;             D5->A1 = direccion de la pantalla de respaldo
;             D6->A0 = direccion de la pantalla de montaje
RECREC_SB:      MOVEA.L D5,A1
                MOVEA.L D6,A0
RECREC:         ; d2 = 64 * d2 + d1 DIV 4
                ASL.L #6,D2
                MOVE.L D1,D0
                ASR.L #2,D0
                ADD.L D0,D2
                ; a1 = a1 + d2
                ADDA.L D2,A1
                ; a0 = a0 + d2
                ADDA.L D2,A0
                ; d1 = (d1 MOD 4 + d3 - 1) DIV 4 + 1
                AND.L #3,D1
                ADD.L D3,D1
                SUBQ.L #1,D1
                ASR.L #2,D1
                ADDQ.L #1,D1
                ; d2 = 64 - d1
                MOVEQ.L #64,D2
                SUB.L D1,D2
RR_LINEA:       MOVE.L D1,D3
RR_PALABRA:     MOVE.W (A1)+,(A0)+
                DBRA D3,RR_PALABRA
                ADDA.L D2,A1
                ADDA.L D2,A0
                DBRA D4,RR_LINEA
                MOVEQ.L #0,D0
                RTS

Se usa para recuperar un rectángulo dentro de la pantalla. Este rectángulo no tiene la medida exacta sino que se ajusta para que el tamaño horizontal sea múltiplo de 4 de tal forma que contenga a las medidas pasadas en los parámetros. La pantalla de montaje puede ser la misma pantalla de visualización (131072).

Ninguna de las subrutinas tiene código de comprobación de los límites de la pantalla. Hay que ponérselo.

[badaman]

Muy interesante, y muy fácil la primera rutina. Hace casi lo mismo que el listado SuperBASIC, ilustrando perfectamente su funcionamiento, salvo que el valor $2000 (el tamaño de pantalla) se pasa como parámetro en el CALL y aquí es un dato implícito en el código.

El código, pasando como parámetro el tamaño del bloque a copiar entonces sería, (que alguien me corrija...):

Código: Seleccionar todo

; Copiar la pantalla
; CALL copiar_pantalla,origen,tamaño,destino
; Parametros: D1->A0 = dirección origen
;             D2->D0 = tamaño o longitud de datos a copiar
;             D3->A1 = dirección destino
COPPAN_SB:      MOVEA.L D1,A0
                MOVEA.L D3,A1
COPPAN:         MOVE.L D2,D0
CP_BUCLE:       MOVE.L (A0)+,(A1)+
                DBRA D0,CP_BUCLE
                MOVEQ #0,D0
                RTS

Todo el meollo está en las lineas:

MOVE.L (A0)+,(A1)+

que incrementan en 1 las direcciones de origen y destino respectivamente, y

DBRA D0,CP_BUCLE

Que vuelve a la linea CP_BUCLE tantas veces como indica D0.

Como se recomienda en el apartado de palabras clave del Manual de Usuario del QL, añado la línea:

MOVEQ #0,D0

Para poner a cero D0 y volver al SuperBASIC con

RTS

[Zerover]

El código, pasando como parámetro el tamaño del bloque a copiar entonces sería, (que alguien me corrija...):

Código: Seleccionar todo

; Copiar la pantalla
; CALL copiar_pantalla,origen,tamaño,destino
; Parametros: D1->A0 = dirección origen
;             D2->D0 = tamaño o longitud de datos a copiar
;             D3->A1 = dirección destino
COPPAN_SB:      MOVEA.L D1,A0
                MOVEA.L D3,A1
COPPAN:         MOVEA.L D2,D0
CP_BUCLE:       MOVE.L (A0)+,(A1)+
                DBRA D0,CP_BUCLE
                MOVEQ #0,D0
                RTS

1. Yo pondría el nuevo parámetro en tercer lugar, sólo por que me gusta más (y contra gustos...) . Si el parámetro pasado son bytes, hay que dividir entre 4 porque la subrutina mueve palabras largas, y confiar en que el parámetro sea múltiplo de 4.

2. No hace falta recolocar un registro de datos en otro registro de datos, además, MOVEA sólo se usa cuando el registro destino es de direcciones. Eliminaría la línea 8.

3. Las etiquetas COPPAN_SB y COPPAN las he puesto para indicar dónde empieza la subrutina a colocar los parámetros que recibe de SuperBASIC y dónde empieza de verdad la subrutina que hace el trabajo. Por lo tanto COPPAN no quedaría colocada ahí en este caso.

las lineas:

MOVE.L (A0)+,(A1)+

que incrementan en 1 las direcciones de origen y destino respectivamente

Esta instrucción incrementa las direcciones de 4 en 4, porque mueve palabras largas.

añado la línea:

MOVEQ #0,D0

Para poner a cero D0 y volver al SuperBASIC con

RTS

Muy buena apreciación.

Al final la subrutina generalizada quedaría así:

Código: Seleccionar todo

; Copiar un bloque de bytes (sin solapamiento)
; CALL copiar,origen,destino,tamaño
; Parametros: D1->A0 = dirección origen
;             D2->A1 = dirección destino
;             D3 = tamaño o longitud de datos a copiar
COPPAN_SB:      MOVEA.L D1,A0
                MOVEA.L D2,A1
COPPAN:         ASR.L #2,D3
CP_BUCLE:       MOVE.L (A0)+,(A1)+
                DBRA D3,CP_BUCLE
                MOVEQ #0,D0
                RTS

Hay que advertir que las direcciones pasadas en los parámetros deben ser pares y que el tamaño en bytes se espera que sea múltiplo de 4 para no tener problemas.

[badaman]

No hace falta recolocar un registro de datos en otro registro de datos, además, MOVEA sólo se usa cuando el registro destino es de direcciones. Eliminaría la línea 8.

Sí, me di cuenta de ello posteriormente y cambié MOVEA por MOVE. Respecto a mover D2 a D0, pues también me pareció inecesario (hubiera sido suficiente con borrar la línea y pasar D2 como valor a DBRA), pero se me ocurrió que de esa forma sería más estándar. Cosas de novatos

Del nuevo listado, no acabo de pillar como funciona la línea:

COPPAN: ASR.L #2,D3

Saludos

[Zerover]

no acabo de pillar como funciona la línea:

COPPAN: ASR.L #2,D3

Sirve para dividir el número de bytes por 4, así tenemos el número de palabras largas en D3.

Para más información puedes consultar el libro "Assembly Language Programming on the Sinclair QL" en las páginas 35 y 81.

[badaman]

Adjunto primeros sprites para ir probando.



Las medidas son:

ladrillo: 16x10
bola: 4x6
paleta: 24x10

EL archivo con los esprites para descargar aquí.

Nota: Con este diseño de ladrillo, y sin usar tramas, pueden hacerse 6 modelos distintos, sin emplear el blanco y el negro.

[afx]

Me pondré a extraer el código superbasic del programa de zerover y a jugar con estos sprites .... (entretenimiento para rato).

Sobre los ejemplo de CM de este hilo ....uffff .... chicos ... voy con la lengua fuera ...

A ver si me pongo al día con el curso de CM.

[badaman]

Se ve muy fácil:

Código: Seleccionar todo

sprt=RESPR(200):LBYTES SPRITE_MAQ,sprt

para cargar el c/m de la rutina sprite_maq, aunque sería mejor usar ALCHP

Siendo "ds" la dirección de almacenamiento del sprite:

Código: Seleccionar todo

ds=RESPR(tamaño_del_sprite):LBYTES nombre_del_sprite_spr,ds

El tamaño del sprite debe conocerse de antemano claro.

Por cierto, con:

Código: Seleccionar todo

al=PEEK(ds)+1
an=PEEK(ds+1)+1

averiguaremos la altura y anchura del sprite, aunque estos datos tambien podemos saberlos de antemano, sobre todo si el sprite lo hemos creado nosotros.

Por último, con:

Código: Seleccionar todo

CALL sprt,ds,x,y

Mostramos el sprite (con transparencia y todo) en pantalla.

x e y son los valores en pixels de la posición en pantalla del margen superior izquierdo del sprite, claro.

NOTA: No hay que olvidarse de que esta rutina sólo hace la mitad de lo que necesitamos, es decir, estamba el sprite en pantalla, pero no guarda el fondo donde dibujaremos el sprite ni lo restaura luego. Para eso está la rutina que prepara Zerover.

Mientras tenemos la rutina, puedes usar el sprite con fondo de un solo color, y restaurar el fondo a base de pintar rectángulos del tañaño del sprite encima del mismo.

[badaman]

Este es un pequeño programa de demostración que usa el sprite mano_spr que acompaña al programa defsprite. Por cierto, este srprite lo prepare allá por el 87 para un juego de tragaperras. Iba a ser la mano que tirase de la palanca.

Este programa requiere TK2

Código: Seleccionar todo

100 MODE 8
110 OPEN #5,scr_512x256a0x0
120 color = 2 : PAPER#5,color : CLS #5
125 :
130 sprt=ALCHP(200):LBYTES SPRITE_MAQ,sprt
140 ds = ALCHP(386) : LBYTES mano_spr,ds
145 :
150 al = PEEK(ds)+1
160 an = PEEK(ds+1)+1
170 x = 10 : y = 10
180 oldx = x : oldy = y
190 desx = 4 : desy = 4
200 topx = 255 - an
210 topy = 255 - al
215 :
220 REPeat bucle
230   a$=INKEY$
240   IF a$<>"" THEN EXIT bucle
245 :
250   BLOCK #5,an*2,al,oldx*2,oldy,color
260   CALL sprt,ds,x,y
265 :
270   oldx = x : oldy = y
280   x = x + desx : y = y + desy
290   IF x < 0 THEN x=0 : desx=-desx
300   IF x > topx : x=topx : desx=-desx
310   IF y < 0 THEN y=0 : desy=-desy
320   IF y > topy : y=topy : desy=-desy
330 END REPeat bucle
335 :
340 CLOSE #5
350 CLCHP

Lo unico que hace el programa es pintar un sprite y hacerlo chocar contra los bordes de la pantalla cual pelota de ping-pong, borrando el fondo.

Para terminar, es suficiente con pulsar una tecla.

[afx]

Así de detallado da gusto. A ver si este fin de semana me pongo a jugar con esto.