1
0
mirror of https://github.com/sehugg/8bitworkshop.git synced 2024-12-25 15:30:03 +00:00
8bitworkshop/presets/vcs/examples/multisprite1.a

275 lines
6.2 KiB
Plaintext

processor 6502
include "vcs.h"
include "macro.h"
include "xmacro.h"
; Given all the heavy lifting it requires to put a single
; sprite on the screen, we'd like to abstract away the process
; of putting multiple sprites on the screen so we can actually
; make a game. This is called the "kernel" because it is
; particularly timing-sensitive and the CPU will spend a lot
; of time in that loop.
; We'll start with drawing two overlapping sprites with full
; resolution (1 scanline per sprite line) and full color
; (1 color per scanline). To do this our kernel (DrawSprites)
; will have to update four TIA registers after each WSYNC,
; pulling from four lookup tables, and handling edge cases
; where sprites overlap partially in the Y-dimension.
; This will use up almost an entire scanline of CPU time.
; Right now we'll just hard-code the horizontal position
; of each sprite, limiting ourselves to two sprites.
seg.u Variables
org $80
Counter byte ; increments each frame
Scanline byte ; scanline to draw next
PData0 word ; pointer (lo/hi) to player 0 bitmap data
PData1 word ; pointer to player 1 bitmap data
PColr0 word ; pointer to player 0 color data
PColr1 word ; pointer to player 1 color data
SIndx0 byte ; index into player data (0 = inactive)
SIndx1 byte ; index into player data (0 = inactive)
SSize0 byte ; sprite size for each player
SSize1 byte ; sprite size for each player
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
seg Code
org $f000
; Initialize and set initial offsets of objects.
Start CLEAN_START
; Hard-code the horizontal player positions.
lda #70
ldx #0
jsr SetHorizPos ; set player 0 horiz. pos
lda #73
ldx #1
jsr SetHorizPos ; set player 1 horiz. pos
sta WSYNC
sta HMOVE
; Next frame loop
NextFrame
TIMER_SETUP 37
VERTICAL_SYNC
; Set some colors
lda #$80
sta COLUBK ; set the background color
; Setup the two sprites
lda #50
sta SIndx0
lda Counter ; changes every frame
sta SIndx1
lda #17
sta SSize0
sta SSize1
lda #<Frame0
sta PData0
lda #>Frame0
sta PData0+1
lda #<ColorFrame0
sta PColr0
lda #>ColorFrame0
sta PColr0+1
lda #<Frame1
sta PData1
lda #>Frame1
sta PData1+1
lda #<ColorFrame0
sta PColr1
lda #>ColorFrame0
sta PColr1+1
TIMER_WAIT
; Scanline loop
lda #0
sta Scanline
NextScanline
jsr DrawSprites
inc Scanline
; WSYNC and then clear sprite data
sta WSYNC
lda #0
stx GRP0
stx GRP1
; repeat until all scanlines drawn
lda Scanline
cmp #192
bcc NextScanline
; Clear all colors to black before overscan
stx COLUBK
stx COLUP0
stx COLUP1
stx COLUPF
; 30 lines of overscan
TIMER_SETUP 30
TIMER_WAIT
; Jump to next frame
inc Counter
jmp NextFrame
; Here is our sprite kernel.
; Inputs:
; ssize0, ssize1 (size in lines of each sprite)
; sindx0, sindx1 (# scanlines to bottom of sprites)
; pdata0, pdata1 (ptr to sprite bitmaps)
; pcolr0, pcolr0 (ptr to sprite color tables)
DrawSprites
; Find out the maximum # of lines to draw
; by taking the maximum of the two sprite heights
lda SIndx0
cmp SIndx1
bpl Cmp1 ; sindx0 < sindx1
lda SIndx1
Cmp1 tax ; X = # of lines left to draw
cmp #0 ; no lines?
beq NoSprites
; add total draw height to scanline count
clc
adc Scanline
sta Scanline
DrawNextScanline
; Fetch next pixels/colors for sprite 0
ldy SIndx0
cpy SSize0
bcs Inactive0 ; index >= size? (unsigned)
lda (PData0),y
; Do WSYNC and then quickly store pixels/colors for player 0
sta WSYNC
sta GRP0
lda (PColr0),y
sta COLUP0
DrawSprite1
; Fetch next pixels/colors for sprite 1
ldy SIndx0+1
cpy SSize0+1
bcs Inactive1 ; index >= size? (unsigned)
lda (PData1),y
sta GRP1
lda (PColr1),y
sta COLUP1
Inactive1
; Decrement the two sprite indices
dey
sty SIndx0+1
dec SIndx0
dex
bne DrawNextScanline
NoSprites
; Clear player data on exit
rts
Inactive0
; Alternate sprite 0 path when inactive
lda #0
sta WSYNC
sta GRP0
sta COLUP0
beq DrawSprite1 ; always taken due to lda #0
; SetHorizPos - Sets the horizontal position of an object.
; The X register contains the index of the desired object:
; X=0: player 0
; X=1: player 1
; X=2: missile 0
; X=3: missile 1
; X=4: ball
; This routine does a WSYNC and HMOVE before executing,
; so whatever you do here will not take effect until you
; call the routine again or do your own WSYNC and HMOVE.
SetHorizPos
sta WSYNC ; start a new line
sta HMOVE ; apply the previous fine position(s)
sta HMCLR ; reset the old horizontal position(s)
sec ; set carry flag
DivideLoop
sbc #15 ; subtract 15
bcs DivideLoop ; branch until negative
eor #7 ; calculate fine offset
asl
asl
asl
asl
sta RESP0,x ; fix coarse position
sta HMP0,x ; set fine offset
rts ; return to caller
; Height of our sprite in lines
SpriteHeight equ 18
; To avoid nasty timing issues,
; we'll start the bitmap data at a page boundary
org $f800
; Bitmap data "standing" position
Frame0
.byte #0
.byte #%01101100;$F6
.byte #%00101000;$86
.byte #%00101000;$86
.byte #%00111000;$86
.byte #%10111010;$C2
.byte #%10111010;$C2
.byte #%01111100;$C2
.byte #%00111000;$C2
.byte #%00111000;$16
.byte #%01000100;$16
.byte #%01111100;$16
.byte #%01111100;$18
.byte #%01010100;$18
.byte #%01111100;$18
.byte #%11111110;$F2
.byte #%00111000;$F4
; Bitmap data "throwing" position
Frame1
.byte #0
.byte #%01101100;$F6
.byte #%01000100;$86
.byte #%00101000;$86
.byte #%00111000;$86
.byte #%10111010;$C2
.byte #%10111101;$C2
.byte #%01111101;$C2
.byte #%00111001;$C2
.byte #%00111000;$16
.byte #%01101100;$16
.byte #%01111100;$16
.byte #%01111100;$18
.byte #%01010100;$18
.byte #%01111100;$18
.byte #%11111110;$F2
.byte #%00111000;$F4
; Color data for each line of sprite
ColorFrame0
.byte #$FF;
.byte #$F6;
.byte #$86;
.byte #$86;
.byte #$86;
.byte #$C2;
.byte #$C2;
.byte #$C2;
.byte #$C2;
.byte #$16;
.byte #$16;
.byte #$16;
.byte #$18;
.byte #$18;
.byte #$18;
.byte #$F2;
.byte #$F4;
; Epilogue
org $fffc
.word Start
.word Start