Orden en el código

En este post vamos a organizar un poco el proyecto. Hasta ahora estabamos trabajando todo en un solo archivo, lo cual si bien es comodo al principio, en cuanto metemos un par de cositas se vuelve inmanejable.
Para ello vamos a separar el archivo en varios modulos. CBM Prg Studio nos permite fraccionar el codigo en distintos archivos, y luego especificar como estos archivos tienen que estar ordenados (al momento de compilar). Esto es necesario porque, por ejemplo, las definiciones de macros deben estar ANTES de ser invocadas.

Vamos a separar todo nuestro codigo en 6 archivos diferentes: main.asm, macros.asm, vars.asm, sprites.asm, animatePlayer1.asm, animatePlayer1Fire.asm. A medida que el proyecto crezca se iran agregando mas archivos. Los archivos vamos a ordenarlos de la siguiente manera (esta ventana es la de Project Properties):

 

En el frame ‘Project Files (shown in build order)’ tenemos que seleccionar ‘use specific build order’, asi de esa manera le decimos al compilador el orden correcto de los archivos.
Nótese que el primer archivo no es el main.asm, sino sprites.asm, y si observamos mas en detalle podemos ver que la columna ‘Start’ de dicho archivo dice ‘$840’. Ahi está especificando que el contenido de dicho archivo lo cargue en la posicion $840 de memoria. De esta manera nos evitamos las macros movedata y la duplicacion de datos (en las definiciones del sprite que luego copiabamos a una direccion accesible por el VIC II). Asi queda mas eficiente, mas bonito y nos ahorramos unos cuantos bytes.

Archivos

sprites.asm

*         = $0840
; dejamos 2 kbytes para la definicion de los sprites, ya quedan mapeados en un area de memoria que
; puede acceder el VIC II

jetpac    
          bits           ..........BBBB..........
          bits           .........BBB............
          bits           .......B.BB.BBBB........
          bits           .......B.BBB.BBB........
          bits           .......B.BBB.BBB........
          bits           ......BB..BBBBB.........
          bits           ......BB................
          bits           ......B.B.BBBB..........
          bits           ......BBB.B..BB.B.......
          bits           ......B.B.B..BB.B.......
          bits           ......BBB.B....BBBBB....
          bits           ......B.BB.BBBB.........
          bits           ......BBBB.BBB..........
          bits           .......BBBB.BBBBBB......
          bits           .......B.B..BBBBBB......
          bits           ......B.B.B.....BB......
          bits           ......BBBBB.............
          bits           ................BBB.....
          bits           .......BB.B.....BBBB....
          bits           .......B..B.............
          bits           .....B..B...............
          byte           0                          ; byte que se desperdicia

jetpacFire
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           B..B..BBBBBBBBBBBBBBBB.B
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................
          bits           ........................

Notese que al final de la definicion jetpac hay un byte, con valor 0, que no estaba antes. Esto es asi ya que el puntero de sprites del VIC accede de a 64 bytes, y el sprite necesita 63 bytes, por lo que necesariamente se va a desperdiciar 1 byte en cada sprite. Mas adelante veré si le puedo dar alguna utilidad (guardar algun estado, que se yo…)

vars.asm

raster    = $d012
cborde    = $d020
cfondo    = $d021
spractive = $d015
sprxpandX = $d01d          

; direcciones jetpac 
sprcolor  = $d027
sprpoint  = $07f8
sprx      = $d000
spry      = $d001
joy2      = $dc00
fire1     = $02         ; zero page direccion sin usar

; direcciones disparo
sprcolorFire  = $d028
sprpointFire  = $07f9
sprxFire      = $d002
spryFire      = $d003

skiprt    = $03         ; para pausar la ejecucion

Notese: agregamos una variable skiprt, con un valor arbitrario de $03. Esta variable se utiliza en una nueva rutina para controlar la velocidad de ejecucion. Anteriormente frenabamos la ejecucion en cada refresco de pantalla, lo cual era excesivamente lento. Ahora lo que hacemos es frenar cada 3 refrescos, con lo que aceleramos un poco el juego. Seguramente mas adelante quitaremos la macro waitrt, y la sustituiremos por una interrupcion, lo que seguramente es lo correcto de hacer. De momento es lo que hay…

macros.asm

defm      waitrt
          ldx            skiprt    
          cpx            #$00
          bne            @next     
          ldx            #$03      
          stx            skiprt    

@loop     ldx            raster
          cpx            #$0       
          bne            @loop     
@next     
          dec            skiprt    
          endm

defm      initVars
          lda            #$00      ; borde y fondo negro
          sta            cborde     
          sta            cfondo

          lda            #$03      ; inicializo skiprt (conteo hasta hacer un wait retrace)
          sta            skiprt

          ldx            #172      ; posicionamos jetpac
          stx            sprx
          ldx            #139       
          stx            spry

          ldx            #196      ; posicionamos disparo
          stx            sprxFire
          ldx            #139       
          stx            spryFire

          lda            #$01      
          sta            spractive ;activamos el sprite 0 

          lda            #$01      
          sta            sprcolor  ; jetpac color blanco

          lda            #$07      
          sta            sprcolorFire; fire color amarillo

          lda            #$02      
          sta            sprxpandX ; expandimos X el disparo.

          lda            #$21      
          sta            sprpoint  ; sprite 0 en $0840

          lda            #$22 
          sta            sprpointFire  ; sprite 0 en $0880

          lda            #$0       ; fire flag 0      
          sta            fire1     
          endm

main.asm

*         = $1000

          initVars

main_loop
          jsr            animatePlayer1
          jsr            animatePlayer1Fire

          waitrt
          jmp            main_loop 

exit
          rts                      ; BASIC

animatePlayer1.asm

animatePlayer1
          lda            joy2      
          cmp            #127      
          beq            next      

          lda            joy2      
          and            #1        ; up
          bne            chkDown   
          dec            spry      

chkDown   lda            joy2      
          and            #2        ; down
          bne            chkLeft   
          inc            spry      

chkLeft   lda            joy2      
          and            #4        ; left
          bne            chkRight  
          dec            sprx      

chkRight  lda            joy2      
          and            #8        ; right
          bne            chkFire   
          inc            sprx      

chkFire   lda            joy2      
          and            #16       ; fire
          bne            next      

          ldx            fire1     
          cpx            #0        
          bne            next      ; checkeo si ya disparo

          lda            #1        ; setea status fire1 
          sta            fire1     
          lda            #$03      
          sta            spractive ;activamos el sprite 1 

;         end check joystick          

next
          rts

animatePlayer1Fire.asm

animatePlayer1Fire
          ldx            fire1     
          cpx            #$0       
          bne            @initFire
          rts                      ; vuelve si status fire es 0

@initFire
          ldx            fire1     
          cpx            #$1       
          bne            @loop     
                                   ; init fire (status 1)          
          ldx            spry
          stx            spryFire  

          lda            sprx      
          adc            #12
          sta            sprxFire
          inc            fire1     ; paso a status 2 (disparando)

@loop
          lda            #1        
          adc            sprxFire  ; incremento 3 x disparo
          sta            sprxFire  

          bcs            @setStatus0
          jmp            @next     

@setStatus0          
          ldx            #$0       ; si no seteo flag en 0
          stx            fire1     
          lda            #$01      
          sta            spractive ; desactivamos el sprite 1 

@next          
          rts

Como es un bodrio poner todos estos archivos, a partir de ahora tengo todo subido a github, pueden clonarse el repo, y actualizar a medida que vamos avanzando con el juego:
https://github.com/moonorongo/jp_wars.git
En los próximos posts trataré de centrarme en el bloque de codigo que trabaje, y el resto se lo bajan de github.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s