Download Source Separately (right click to save)
; Combat for Atari by Larry Wagner
;
; Original disassembly by Harry Dodgson
; Commented further by Nick Bensema (1997)
; Major overhaul by Roger Williams (2002)
;
; My intent in overhauling this classic disassembly is to finish it
; so that the purpose of every instruction, memory location, and
; table is made completely clear.
;
; For some reason the NBCOMBAT file ORG statements all point to
; the region $1000-$1FFF; this would play in a VCS but the cartridge
; .BIN I have is mapped from $F000-$FFFF. This file compiles with
; DASM to an image which differs from this ROM only in the few
; unwritten bytes between the end of data and the startup vectors.
; DASM sets these to zero, typical of unwritten RAM, but in the cart
; they are $FF, typical of unprogrammed PROM.
;
; Thanks to Brian Prescott for pointing me to Joe DeCuir's
; presentation notes, which revealed Atari's original names
; for the main loop toplevel routines and offered some guidance
; on their separation of function.
;
; I have removed some of the breathless intro-to-VCS and historical
; comments. This version assumes a basic familiarity with VCS
; programming, and is meant as a basis for hacking the COMBAT game
; itself. There are plenty of resources outside of this file if
; you don't know how the VCS works.
;
; For reference, as this is rather important when reading the,
; code, here is the game variation matrix (it is not trivially
; obvious how this corresponds to GAMVAR):
;
; Game No. Open Field
; | Straight Missiles | Easy Maze
; | | Guided Missiles | | Complex Maze
; | | | Machine Guns | | | Clouds
; | | | | Direct Hit | | | |
; | | | | | Billiard | | | |
; | | | | | | Hit | | | |
; | | | | | | | | | |
; | | | | | | | | | |
;
;TANK 1 - X - - - X - - -
; 2 - X - - - - X - -
; 3 X - - - - - X - -
; 4 - X - - - - - X -
; 5 X - - - - - - X -
;--------------------------------------------------
;TANK-PONG 6 - - - X X - X - -
; 7 - - - X X - - X -
; 8 - - - - X X - - -
; 9 - - - - X - X - -
;--------------------------------------------------
;INVISIBLE TANK 10 - X - - - X - - -
; 11 - X - - - - X - -
;--------------------------------------------------
;INVISIBLE 12 - - - X X - X - -
;TANK-PONG 13 - - - - X X - - -
; 14 - - - - X - X - -
;--------------------------------------------------
;BI-PLANE 15 - X - - - - - - X
; 16 X - - - - - - - X
; 17 - - X - - - - - X
; 18 - - X - - X - - -
; 2 vs. 2 19 - X - - - X - - -
; 1 vs. 3 20 X - - - - X - - -
;--------------------------------------------------
;JET 21 - X - - - - - - X
; 22 X - - - - - - - X
; 23 - X - - - X - - -
; 24 X - - - - X - - -
; 2 vs. 2 25 - X - - - - - - X
; 1 vs. 3 26 - X - - - X - - -
; 2 vs. 2 27 X - - - - X - - -
processor 6502
include vcs.h
; RAM is cleared in blocks beginning at various addresses and
; always ending at $A2 (though this isn't the highest address
; used). I have placed \\\/// comments to mark these points.
BINvar = $80 ; Master Game Variation Control (binary)
; (When BINvar is reset or incremented,
; BCDvar is reset or BCD-imcremented and
; GAMVAR flag is read from VARMAP+BINvar)
BCDvar = $81 ; Game Variation in BCD
;
;\\\///
;
; $82 thru $85 contain flags built from GAMVAR for quick testing via BIT.
;
PF_PONG = $82 ; bit 7 DIS-able playfield flag
; ; bit 6 Pong missiles (bounce off playfield)
GUIDED = $83 ; bit 7 = guided missile game
; ; bit 6 = machine gun game
BILLIARD = $84 ; Just bit 6 = billiard hit game (missiles can't
; ; hit tank until at least 1 bounce off playfield)
GAMSHP = $85 ; Shape of player and game type
; ; 0 = Tank
; ; 1 = Biplane
; ; 2 = Jet Fighter
;
CLOCK = $86 ; Master timer inc'd every frame during VSYNC
; ; in NBCOMBAT this was misleadingly labelled GTIMER
SHOWSCR = $87 ; Show/hide RIGHT player score (left only is used
; ; to indicate game selection in attract mode) To
; ; inhibit both scores, KLskip is set to $0E vs. $02
GameOn = $88 ; $00=attract mode, $FF=game going on. Bits 7, 1,
; ; and "all" tested in various places. Incorrectly set
; ; to $10 at START, but must not be a problem :-)
;\\\///
;
SelDbnce = $89 ; Select Switch Debounce flag which prevents a
; ; hold-down from registering as 60 presses/second
StirTimer = $8A ; Bit 0 = identity of loser during tank stir
; ; Bits 2-7 = countdown timer controlling stir after loss
Vtemp = $8B ; Temp storage for current velocity
FwdTimer = $8D ; FwdTimer must count $F0 to $00 between changes in
; thru $8E ; forward motion control; also used for momentum pacing
; $8F ; ...
; thru $90 ; seem to be reserved too (missiles?) but not used
LastTurn = $91 ; Flag indicating direction of last turn, used
; thru $92 ; to inhibit whipsaw direction changes (may
; ; have been intended for rotational momentum)
TurnTimer = $93 ; Countdown timer between 22.5-degree rotates
; thru $94 ; for P0 and P1
DIRECTN = $95 ; Players and missiles' current bearing.
; thru $98 ; (4 bytes P0,P1,M0,M1)
MisLife = $99 ; Missile Lifetime down-counters
; thru $9A
BounceCount = $9B ; (1) Billiard bounced-once flag, via any value other
; thru $9C ; than $1F init value; (2) Pong sound tone freq, which
; ; ascends in tone as BounceCount DECed with each bounce
MxPFcount = $9D ; During Pong bounce, count of collision duration in
; thru $9E ; frames, used to try different heading adjustments
; ; until "desired" reflection achieved
AltSnd = $9F ; Alt Player Sound flag/counter; 0=normal motor sound,
; thru $A0 ; else counts up to $04 to time Pong sound
SCORE = $A1 ; Player scores in BCD.
; thru $A2 ;
;
;\\\/// Addresses beyond here aren't ever cleared by ClearMem.
;
GAMVAR = $A3 ; Game Variation bitwise descriptor via VARMAP
TankY0 = $A4 ; Tank 0's Y-position
TankY1 = $A5 ; and tank 1
MissileY0 = $A6 ; Missile 0's Y-position
MissileY1 = $A7 ; and missile 1
MVadjA = $A8 ; First-half FwdTimer-Velocity adjustments
; thru $A9 ; for each player. By an amazing coincidence
; ; in all games these seem to be the same as
; ; the *current* velocity.
MVadjB = $AA ; Second-half FwdTimer-Velocity adjustments,
; thru $AB ; which seem to be the same as the *final* velocity.
MPace = $AC ; Pacing counter; never initialized! INC'd and
; ; masked to pace certain actions slower than
; thru $AF ; once/frame, for each player & missile
XOFFS = $B0 ; X-offset for pending Hmove.
XoffBase = $B1 ; $0, $10, $20, or $30 offset into X-offset tbl
OldMisDir = $B2 ; Missile bearing before a Pong-bounce began
; thru $B3 ;
ScanLine = $B4 ; Current scanline on the playfield.
LORES = $B5 ; lo-res indirect addresses.
; thru $BA ; 6 bytes / 3 16-bit pointers
SHAPES = $BB ; Pointer to player sprites
HIRES = $BD ; Hi-res (sprite) shape buffer. Left player's shape
; thru $CC ; stored in even bytes, right player's in odd.
TEMP1 = $D1 ; Temp storage for several quick save/math operations
TEMP = $D2 ; "score conversion temporary"
TMPSTK = $D3 ; Temporary storage for stack.
DIFSWCH = $D5 ; Hold & shift temp for console switches
Color0 = $D6 ; Colors loaded from ColorTbl for player 0 and 1
Color1 = $D7 ; These may be changed e.g. invisible tanks
XColor0 = $D8 ; Repeated P0 and P1 Colors for reference, used
XColor1 = $D9 ; to restore ColorX after a change
ColorPF = $DA ; BK and PF colors loaded in same block as XColorX.
ColorBK = $DB ; Never changed, so no reference versions are kept.
KLskip = $DC ; Kernal lines to skip before score, or main w/o score
; ; (Also used in Kernal as flag whether to show score)
GameTimer = $DD ; Master game timer set to $80 when game starts,
; ; incremented until overflow at $FF-->$00 ends game
; ; Bit 7 indicates game in play, also used w/GameOn to
; ; flash score. During attract mode GameTimer is used
; ; to cycle colors; this is OK since it only assumes
; ; its game-timing function if GameOn != $00.
NUMG0 = $DE ; Storage for current byte
NUMG1 = $DF ; of score number graphics.
SCROFF = $E0 ; Score pattern offsets (4 bytes)
; thru $E3 ; lo nibble 0, lo 1, hi 0, hi 1
COLcount = $E4 ; Counter keeps tank-tank and tank-PF collisions from
; thru $E5 ; affecting a stationary tank's bearing unless the
; ; collision lasts at least 4 cycles
;
StkTop = $FF ; Top of stack (which IS used, at least 8 bytes)
;
; So much for the RAM. Here's the ROM:
org $F000
START SEI ; Disable interrupts
CLD ; Clear decimal bit
LDX #StkTop
TXS ; Init Stack
LDX #$5D
JSR ClearMem ; zero out RAM except address $A2
LDA #$10 ;
STA SWCHB+1 ; Port B data direction register and
STA GameOn ; GameOn (tho not quite a valid value)...
JSR ClrGam ; clear game RAM $82-$A2
;
MLOOP JSR VCNTRL ; Generate a VSYNC and begin VBLANK
;
; VBLANK logic:
;
JSR GSGRCK ; Parse console switches
JSR LDSTEL ; Load Stella Registers
JSR CHKSW ; Check Joystick Switches
JSR COLIS ; Check Collision Registers
JSR STPMPL ; Setup Player, Missile Motion
JSR ROT ; Rotate Sprites
JSR SCROT ; Calculate Score Offsets
;
JSR VOUT ; do the Kernal (trashes the stack ptr,
; but then restores it because it IS
JMP MLOOP ; used when we reiterate this loop)
;
; ------------------------------------------------------------
;
; Vertical CoNTRoL
;
; Vertical sync, basic frame-start housekeeping
;
VCNTRL INC CLOCK ; Master frame count timer
STA HMCLR ; Clear horizontal move registers.
LDA #2 ; Get this ready...
STA WSYNC ; for start of next line...
STA VBLANK ; Start vertical blank.
STA WSYNC
STA WSYNC ; and do three lines
STA WSYNC
STA VSYNC ; Now start vertical sync
STA WSYNC
STA WSYNC ; and do three lines
LDA #0 ; get this ready
STA WSYNC
STA VSYNC ; End of vertical sync pulse
LDA #43 ; And set VBLANK timer
STA TIM64T ; with 64 clock interval.
RTS
;
; ------------------------------------------------------------
;
; Video OUT -- THE KERNAL
;
; We start with the score, then we render the playfield, players,
; and missiles simultaneously. All in all, an average day for a VCS.
;
VOUT LDA #$20
STA ScanLine ; We're assuming scanline $20.
STA WSYNC
STA HMOVE ; Move sprites horizontally.
VOUT_VB LDA INTIM
BNE VOUT_VB ; Wait for INTIM to time-out.
STA WSYNC
STA CXCLR ; Clear collision latches
STA VBLANK ; End vertical blank
TSX
STX TMPSTK ; Save stack pointer
LDA #$02
STA CTRLPF ; Double, instead of reflect.
LDX KLskip
Vskip1 STA WSYNC ; Skip a few scanlines...
DEX
BNE Vskip1
LDA KLskip
CMP #$0E ; "No Score" value of KLskip
BEQ Vmain
;
; KLskip is set as such so that when the score is
; to be displayed, it waits for just the right time
; to start drawing the score, but if the score is
; not to be displayed, as when the score flashes
; signifying "time's almost up", it waits for just
; the right time to start drawing the rest of the
; screen.
;
; Draw the score:
;
LDX #$05 ; Score is five bytes high.
LDA #$00 ; Clear number graphics.
STA NUMG0 ; They won't be calculated yet,
STA NUMG1 ; but first time through the loop
; the game will try to draw with
; them anyway.
VSCOR STA WSYNC ; Start with a fresh scanline.
LDA NUMG0 ; Take last scanline's left score,
STA PF1 ; and recycle it,
;
; Here, we begin drawing the next scanline's
; left score, as the electron beam moves towards
; the right score's position in this scanline.
;
LDY SCROFF+2
LDA NUMBERS,Y ; Get left digit.
AND #$F0
STA NUMG0
LDY SCROFF
LDA NUMBERS,Y ; Get right digit.
AND #$0F
ORA NUMG0
STA NUMG0 ; Left score is ready to ship.
LDA NUMG1 ; Take last scanline's right score,
STA PF1 ; and recycle it.
LDY SCROFF+3
LDA NUMBERS,Y ; Left digit...
AND #$F0
STA NUMG1
LDY SCROFF+1
LDA NUMBERS,Y ; right digit...
AND SHOWSCR
;
; Now, we use our fresh, new score graphics in this next scanline.
;
STA WSYNC ; *COUNT*
ORA NUMG1 ;Finish calculating (0) +3
STA NUMG1 ;right score. (3) +3
LDA NUMG0 ; (6) +3
STA PF1 ; *9* +3
;
; We use this time to check whether we're at the end of our loop.
;
DEX ; (12)+2
BMI Vmain ; (14)+2 No Branch
;
; If so, we're out of here. Don't worry, the score will be
; cleared immediately, so nobody will know that we've gone
; past five bytes and are displaying garbage.
;
INC SCROFF ; (16)+5
INC SCROFF+2 ; Get ready to draw the next
INC SCROFF+1 ; line of the byte.
INC SCROFF+3
LDA NUMG1
STA PF1 ; Right score is in place.
JMP VSCOR ; Go to next scanline,
;
; Main Kernal Display loop for the game itself
;
Vmain LDA #$00 ; Inner Display Loop
STA PF1 ; Clear the score.
STA WSYNC
LDA #$05
STA CTRLPF ; Reflecting playfield.
LDA Color0
STA COLUP0 ; How often must THIS be done?
LDA Color1
STA COLUP1
Vfield LDX #$1E ; Very Sneaky -
TXS ; Set stack to missile registers
SEC
;
; This yields which line of player 0 to draw.
;
LDA TankY0
SBC ScanLine ; A=TankY0-ScanLine
AND #$FE ; Force an even number
TAX ; Only sixteen bytes of
AND #$F0 ; sprite memory, so...
BEQ VdoTank ; If not valid,
LDA #$00 ; blank the tank.
BEQ VnoTank ; (unconditional branch)
VdoTank LDA HIRES,X ; Else, load the appropriate byte.
VnoTank STA WSYNC ; ----END OF ONE LINE----
STA GRP0 ; Just for player 0.
;
; The infamous Combat Stack Trick:
;
; Keep in mind that at this point, the stack pointer
; is set to the missile registers, and the "zero-result"
; bit of the P register is the same at the bit ENAM0/1
; looks at.
;
LDA MissileY1
EOR ScanLine
AND #$FE
PHP ; This turns the missle 1 on/off
LDA MissileY0
EOR ScanLine
AND #$FE
PHP ; This turns the missle 0 on/off
;
; We've got the missile taken care of.
; Now let's see which line of the playfield to draw.
;
LDA ScanLine
BPL VvRefl ; If on the bottom half of the screen,
EOR #$F8 ; reverse direction so we can mirror.
VvRefl CMP #$20
BCC VfDone ; Branch if at bottom.
LSR
LSR
LSR ; Divide by eight,
TAY ; and stow it in the Y-register.
;
; By now, the electron beam is already at the next
; scanline, so we don't have to do a STA WSYNC.
;
; This yields which line of Tank 1 to draw.
;
VfDone LDA TankY1 ; TankY1 is other player's position.
SEC
SBC ScanLine ; A=TankY1 - ScanLine
INC ScanLine ; Increment the loop.
NOP
ORA #$01 ; Add bit 0, force odd number.
TAX
;
AND #$F0 ; There are only sixteen bytes of
BEQ VdoT1 ; sprite memory, so...
LDA #$00 ; If tank is not ready, blank it.
BEQ VnoT1
VdoT1 LDA HIRES,X ; Else, draw the tank
VnoT1 BIT PF_PONG
STA GRP1
BMI VnoPF ; If PF_PONG bit 7 set, don't write PF
LDA (LORES),Y ; (this means game variation has blank
STA PF0 ; background)
LDA (LORES+2),Y
STA PF1
LDA (LORES+4),Y
STA PF2
VnoPF INC ScanLine ; One more up in the loop.
LDA ScanLine
EOR #$EC ; When we've reached the $ECth line,
BNE Vfield ; we've had enough.
LDX TMPSTK ; Restore stack pointer, which is
TXS ; is used for calls in main game loop
STA ENAM0 ; Clear a bunch of registers.
STA ENAM1
STA GRP0
STA GRP1
STA GRP0 ; In case GRP0 isn't COMPLETELY zeroed.
STA PF0
STA PF1
STA PF2
RTS
; ------------------------------------------------------------
;
; Game Select Game Reset ChecK
;
; Executed immediately after VCNTRL, this subroutine parses all
; the console switches.
;
GSGRCK ;
LDA SWCHB ; Start/Reset button....
LSR ; Shove bit 0 into carry flag,
BCS NoNewGM ; and if it's pushed...
;
; Start a new game.
;
LDA #$0F
STA SHOWSCR ; Show right score.
LDA #$FF ; Set all bits
STA GameOn ; in GameOn.
LDA #$80
STA GameTimer ; and bit 7 of GameTimer (this is not too
; significant, as GameTimer rollover is
; only checked if GameOn<>$00)
LDX #$E6
JSR ClearMem ; zero out $89 thru $A2
BEQ ResetField ; Unconditional branch
;
NoNewGM LDY #$02 ; Assume score to be drawn
LDA GameTimer ; If game in play (GameOn=$FF) AND
AND GameOn ; GameTimer < 7/8 finished @ $F0,
CMP #$F0 ; draw the score unconditionally.
BCC SCdrawn
LDA CLOCK ; CLOCK used to flash score near end
AND #$30 ; of play, note the peripheral synchronization
BNE SCdrawn ; with GameTimer's timing of the game, which
; always ends when CLOCK & $3F = 0. CLOCK
; is used here because the score blink
; off duty cycle is a too quick for
; GameTimer to handle, being about 1/3 sec.
LDY #$0E ; Set this for no score
SCdrawn STY KLskip ; where the Kernal will find it
LDA CLOCK
AND #$3F ; CLOCK also used to slow debounce reset
BNE ChkSel
;
; GameTimer is incremented and SelDbnce reset when
; CLOCK & $3F = 0. This occurs 1 frame out of 64 or
; about once/second. Thus the game is 128*64 frames
; or about 2 minutes long.
;
STA SelDbnce ; Reset Select Debounce Flag. This is
; what keeps incrementing the selection
; if you hold Select down for a long time.
INC GameTimer ; increment the Main Game ~1-sec Timer.
BNE ChkSel ; if GameTimer rolls over,
STA GameOn ; zero GameOn -- game over
;
ChkSel LDA SWCHB ; Select button???
AND #$02
BEQ SelDown
STA SelDbnce ; Set flag: Sel has not been down
BNE CS_RTS ; Unconditional branch
;
SelDown BIT SelDbnce ; If Sel has been down,
BMI CS_RTS ; don't select a new game.
;
INC BINvar ; SELECT: Go to next game.
ClrGam LDX #$DF ; Clear data from current game ($82-$A2)
ClrGRST JSR ClearMem
LDA #$FF
STA SelDbnce ; Set flag: Sel has been down.
LDY BINvar
LDA VARMAP,Y ; Get feature bits for this variation.
STA GAMVAR
EOR #$FF ; #$FF signifies end of variations
BNE SelGO ; Not at end yet, set up new game
LDX #$DD ; Clear $80-$A2; resets BINvar, BCDvar
BNE ClrGRST ; so we start over. BNE is unconditional.
;
SelGO LDA BCDvar ; Since we have incremented BINvar, we
SED ; must increment BCDvar in BCD to keep
CLC ; it in sync. Note BCDvar is actually
ADC #1 ; BinVar+1, since it's incremented when
STA BCDvar ; we reset but don't increment BINvar.
STA SCORE ; Display variation as score 0
CLD
BIT GAMVAR ; GAMSHP was reset at ClrGam...
BPL ResetField ; if this is a plane game,
INC GAMSHP ; increase GAMSHP.
BVC ResetField ; if this is a jet game,
INC GAMSHP ; increase GAMSHP further still.
;
; Branches here when game is started, too.
;
ResetField
JSR InitPF
;
; Assuming plane game for now, we set the right player
; at a slightly higher position than the left player,
; and the position of the right player is irrelevant.
;
LDA #50
STA TankY1
LDA #134
STA TankY0
BIT GAMVAR ; Check to see if it is a tank game.
BMI CS_RTS ; Nope, bail.
; It is a tank game, so
STA TankY1 ; Right tank has same Y value,
STA RESP1 ; and tank is at opposite side.
LDA #$08
STA DIRECTN+1 ; and right player faces left.
LDA #$20
STA HMP0
STA HMP1
STA WSYNC
STA HMOVE
CS_RTS RTS
; ------------------------------------------------------------
;
; SCoRe OffseT
;
; Convert BCD scores to score pattern offset.
; This involves the horrible, horrible implications
; involved in multiplying by five.
;
; If it weren't for the geniuses at NMOS using BCD,
; this routine would be a nightmare.
;
; This routine starts with Player 1, writes bytes 1 & 3 of
; the table, then decrements X to write bytes 0 & 2 for P0.
;
SCROT LDX #$01
SCROT0 LDA SCORE,X
AND #$0F ; Lo nibble
STA TEMP
ASL ; *2
ASL ; *4
CLC
ADC TEMP ; + original * 1 = original * 5
STA SCROFF,X
LDA SCORE,X
AND #$F0 ; Repeat for hi nibble. Starts *16
LSR ; *8
LSR ; *4
STA TEMP
LSR ; *2
LSR ; *1
CLC
ADC TEMP ; + (*4) = original * 5
STA SCROFF+2,X
DEX
BPL SCROT0 ;Decrement & repeat once for P0
RTS
; ------------------------------------------------------------
;
; SeTuP Motion for PLayers
;
; Apply horizontal and vertical motion
;
STPMPL BIT GUIDED
BVC STPnoMG ; Branch if not machine gun game.
LDA #$30 ; (Machine gun bullets move faster)
BPL STPMG ; Unconditional JMP.
STPnoMG LDA #$20
STPMG STA XoffBase ; $30=machine gun, $20=normal
LDX #$03
JSR STPM ; Do the honors for X=3, Missile 1
DEX
JSR STPM ; Now X=2, M0
;
DEX ; Now X=1, P1; we will DEX and loop
STPnext LDA FwdTimer,X ; back to run this code block again
AND #$08 ; with X=0 for P0.
LSR ; (to 4) This bit on means FwdTimer has
LSR ; (to 2) run half of the FwdTimer period
; ($F0 to $FF and roll)
; This bit will index MVadjA or MVadjB
STX TEMP1 ; Player # --> TEMP1
CLC
ADC TEMP1
TAY ; Player # + FwdTimer half done*2 --> Y
LDA MVadjA,Y ; And retrieve MVadjA or MVadjB via Y
;
SEC ; assume bit 7 on
BMI STP7set ; OK, it is
CLC ; whoops, backtrack
STP7set ROL ; carry=bit 7, now ROL; net effect is to
; ; rotate left inserting duplicate MSB
STA MVadjA,Y ; instead of original Carry, and save it
BCC STPnoV ; Skip next code block if bit wasn't 1
;
LDA MPace,X ; Tweak velocity by changing XoffBase
AND #$01 ; but only every other time we get here
ASL
ASL
ASL
ASL
STA XoffBase ; XoffBase=$0 or $10 via (MPace & 1) << 4
JSR STPM ; Note this is where we INC MPace
STPnoV
DEX ; Move to _previous_ player.
BEQ STPnext ; Stop if about to do player -1. :)
RTS
;
; This routine will move both tanks and missiles.
; Special cases are made for missiles, which are
; otherwise treated as players 2 and 3.
;
; It doesn't change the X register, but it does
; utilize it.
;
STPM INC MPace,X
LDA DIRECTN,X
AND #$0F
CLC
ADC XoffBase ; Pick table offset by game condition
TAY
LDA Xoffsets,Y ; X-offset by orientation.
STA XOFFS ; Store the default HMPV code.
BIT PF_PONG
BVS STPgo ; Branch if (fast) Pong missiles
LDA DIRECTN,X
SEC
SBC #$02 ; If motion is near X or Y axis,
AND #$03
BNE STPgo ; don't apply delay
LDA MPace,X ; but if very diagonal, slow a bit by
AND #$03 ; moving only 3 of every 4 frames
BNE STPgo ;
LDA #$08 ; HMPV for no motion X or Y
STA XOFFS ; no motion this frame
STPgo LDA XOFFS
;
; (This falls through, but PhMove is also called from elsewhere)
;
; Physically move a tank (0,1) or missile (2,3)
; according to the HMPV code in A
;
PhMove STA HMP0,X ; Hi nibble sets HMPx horizontal motion
AND #$0F ; Lo nibble...
SEC
SBC #$08 ; less 8 for 2's complement 4-bit...
STA $D4 ; (save this offset)
CLC
ADC TankY0,X ; add to Y-coordinate
BIT GAMVAR
BMI PhNoTank ; Branch if a plane game.
CPX #$02
BCS PhNoWrap ; Branch if moving a tank player
PhNoTank
CMP #$DB ; Perform vertical wrap-around
BCS PhNoWrapTop ; branch if over top (wrap)
CMP #$25
BCS PhNoWrap ; branch if over bottom (no wrap)
PhNoWrapTop
LDA #$D9 ; Assume we wrapped bottom to top
BIT $D4 ; Meaning offset was negative
BMI PhNoWrap
LDA #$28 ; Otherwise, we wrapped top to bottom
PhNoWrap
STA TankY0,X ; The tank/missile is moved here.
CPX #$02
BCS PhnoVD ; Skip if moving a missile.
STA VDELP0,X ; Vertical Delay Player X...
PhnoVD RTS
; ------------------------------------------------------------
;
; ROTate player sprites
;
; This subroutine sets up the sprite data for each player by copying
; them into sixteen bytes of RAM.
;
; The X-register starts at $0E plus player number and goes down by two
; each time through the loop, until it hits zero. This way, after calling
; this subroutine twice, every even-numbered byte contains the left player
; shape, and every odd-numbered byte contains the right player shape. Since
; each player is updated every two scanlines, this saves us some math.
;
; Only the first 180 degrees of rotation has been drawn into ROM. In the
; case of the other 180 degrees, this subroutine renders a flipped version
; by doing the following:
;
; 1. It sets the TIA's reflection flag for that player, taking care of
; the horizontal aspect rather easily.
;
; 2. It copies the bytes into memory last-to-first instead of first-to-
; last, using the carry bit as a flag for which to do.
;
ROT LDA #$01 ; The LO byte of CLOCK used to
AND CLOCK ; select alternate players on
TAX ; alternate frames
LDA DIRECTN,X
STA REFP0,X ; Step 1 taken care of.
AND #$0F
TAY ; Y = DIRECTN[X] & 0x0F.
BIT GUIDED
BPL ROTnoGM ; If it's a guided missile game,
STY DIRECTN+2,X ; copy player bearings to missile
ROTnoGM TXA ; X ^= $0E,
EOR #$0E
TAX
TYA
ASL
ASL
ASL
CMP #$3F ; And so step 2 begins...
CLC
BMI ROTnoFlip ; Branch if <180 deg.
SEC
EOR #$47 ;The EOR sets bits 0-2, and clears bit 4
; to subtract 180 degrees from the memory
; pointer, too.
ROTnoFlip TAY
;
;Put all the shapes where they ought to be.
;
ROTnext LDA (SHAPES),Y
STA HIRES,X
BCC ROTinc
DEY ; Decrement instead of increment
DEY ; plus cancel the upcoming INY.
ROTinc INY ; More of step 2.
DEX
DEX ; X-=2.
BPL ROTnext ; Do for both, 1 then 0 then stop.
RTS
; ------------------------------------------------------------
;
; CHecK joystick SWitches
;
; If we are in the interval while a loser's tank is stirring,
; he stirs and the winner freezes or goes forward. Otherwise,
; parse the joystick inputs and move the tanks appropriately.
;
CHKSW LDA StirTimer ; We must dec StirTimer by 2
SEC ; since bit 0 is identity of
SBC #$02 ; the stirree
BCC NoStir ; If no tank is exploding,
; parse joystick instead.
STA StirTimer
CMP #$02
BCC StirRTS ; RTS if tank has
; just finished exploding.
AND #$01 ; Stir the LOSER's tank.
TAX
;One of these is the tank's bearings.
INC DIRECTN,X
LDA XColor0,X
STA Color0,X
LDA StirTimer
CMP #$F7 ; We only rush the tank for a
BCC NoStirRush ; small part of the stir interval
JSR RushTank
NoStirRush
LDA StirTimer
BPL StirRTS ; Don't start decrementing
; volume until halfway through.
LSR
LSR ; StirTimer scales audio volume
LSR ;
BoomSnd STA AUDV0,X ; Set explosion sound to volume in A
LDA #$08 ; and pitch according to player X
STA AUDC0,X
LDA AudPitch,X
STA AUDF0,X
StirRTS RTS
;
; Process joysticks.
;
NoStir LDX #$01 ; Start with P1
LDA SWCHB ; Console switches.
STA DIFSWCH ; Store switches. Before we return
; via DEX to do P0, we will ASL this
; byte so difficulty bit for working
; player appears in bit 7.
LDA SWCHA ; Joysticks. Before we return via
; DEX to do P0, we will reload and
; LSR this 4 times so controls for
; the working player appear in the
NextPJS BIT GameOn ; LO nibble.
BMI NoFreezeJS ; Branch if game on (via bit 7).
LDA #$FF ; Freeze all joystick movement.
NoFreezeJS
EOR #$FF ; Reverse all bits
AND #$0F ; Keep low four bits (working player)
;
; At this point, the joystick's switches are in
; the A-register, with a bit set wherever the
; joystick is pointed.
;
; Bit 0 = up Bit 1 = down
; Bit 2 = left Bit 3 = right
;
STA TEMP
LDY GAMSHP
LDA CtrlBase,Y ; Account for two-dimensional array
CLC
ADC TEMP
TAY
LDA CTRLTBL,Y
AND #$0F ; Get rotation from CTRLTBL.
STA TEMP1 ; Stash it here
BEQ NoTurn ; Branch if no turn.
CMP LastTurn,X ; If new turn is different direction
BNE TurnReset ; from last turn, reset the...
NoTurn DEC TurnTimer,X ; ...turn pacing delay and...
BNE DoFwdMotion ; ...inhibit turn this interval.
TurnReset ; We do turn-wait counts even when
STA LastTurn,X ; we aren't turning, for consistency
LDA #$0F ; Initial countdown value to delay
STA TurnTimer,X ; 22.5-degree turns
;
LDA TEMP1 ; Retrieve rotation code
CLC ; Turn +/- 22.5-degrees or zero,
ADC DIRECTN,X ; per DIRECTN
STA DIRECTN,X
;
; For reference, we do get here every frame (~60Hz) during game.
; COMBAT does not change player speed instantaneously; it has
; an elaborate momentum system, which is just barely noticeable
; in the course of game play.
;
DoFwdMotion
INC FwdTimer,X ; Inc FwdTImer and if it doesn't
BMI SkipFwdCtrl ; roll over, don't acknowledge velocity
LDA CTRLTBL,Y ; changes yet
LSR
LSR
LSR
LSR ; Get forward velocity from CTRLTBL
;
; This is the desired _final_ velocity of the player. If
; it is different from the player's _current_ velocity, we
; won't reach it until the end of the FwdTimer period.
;
BIT DIFSWCH
BMI FwdPro ; Branch if difficulty="Pro"
; (reduces A and branches back to FwdNorm)
FwdNorm STA Vtemp,X ; Stash velocity in Vtemp
ASL ; Multiply by two
TAY ; Stash in Y.
LDA MVtable,Y ; Indexed by velocity * 2, even
STA MVadjA,X ; V+MVtable goes to MVadjA+X
INY ; Why not LDA MVtable+1,Y?
LDA MVtable,Y
STA MVadjB,X ; odd V+MVtable goes to MVadjB+X
LDA #$F0 ; Initialize FwdTimer
STA FwdTimer,X ; (Counts up to $00 before fwd
; ; motion change is final)
SkipFwdCtrl
JSR ChkVM
LDA SWCHA ; Joysticks..
LSR
LSR
LSR
LSR ; Keep bottom four bits (Left Player)
ASL DIFSWCH ; Use other difficulty switch.
DEX
BEQ NextPJS
RTS
;
FwdPro SEC ; Velocity is in A
SBC GAMSHP ; subtract 0/tank, 1/biplane, 2/jet
BPL FwdNorm ; Not obvious, but this is unconditional
; ------------------------------------------------------------
;
; Check invisible tank visibility, missile lifetime expiration;
; read trigger if appropriate and launch a new missile
;
ChkVM LDA GAMVAR
BMI NoInvis ; Branch if plane game
AND #$01 ; check also for bit 0 (invisible).
BEQ NoInvis
LDA ColorBK ; Make invisible tank invisible
STA Color0,X
NoInvis LDA MisLife,X
BEQ RdTrig ; Branch if no missile in flight
LDA XColor0,X ; Reset tank to normal color
STA Color0,X
LDA MisLife,X ; How long does missile have to go?
CMP #$07
BCC MisKill ; Branch to go ahead and kill it
BIT DIFSWCH ; Check difficulty
BPL MisEZ ; If game is hard,
CMP #$1C ; Compare mislife to this
BCC MisKill ; and expire it early.
MisEZ CMP #$30 ; If MisLife < 30 do motor
BCC MotMis ; do motor, not shot sound
CMP #$37 ; If MisLife >= 37
BCS MisFly ; do sliding boom sound (shot)
BIT GUIDED
BVC MisFly ; Branch if machine gun.
MisKill LDA #$00 ; Reset missile's life, killing it
STA MisLife,X
LDA #$FF ; And reset its position
ResRTS STA RESMP0,X ; to player.
RTS
;
; If game in progress, Read the trigger
;
RdTrig BIT GameOn ; Branch if no game on
BPL RDnoGame ; (via bit 7 being clear)
LDA INPT4,X ; Read Input (Trigger) X.
BPL Launch ; unconditional branch -- Launch missile
;
RDnoGame
JSR MOTORS
JMP MisKill
MotMis JSR MOTORS
JMP MisAge
MisFly LDA AltSnd,X
BEQ MisBoom
JSR MOTORS
LDA #$30
STA MisLife,X
JMP MisAge
;
MisBoom LDA MisLife,X
JSR BoomSnd
MisAge LDA CLOCK ; Missile aging rate depends on type
AND #$03
BEQ MisDec ; Only do this test 3/4 of the time
BIT BILLIARD
BVS MisDSkp ; branch if Billiard (must bounce before hit)
BIT PF_PONG
BVC BMisDec ; branch if not Pong game (PF_PONG bit 6)
AND #$01 ; Upshot of this is, in non-billiard Pong
BNE MisDSkp ; game, missiles last about twice as long
MisDec DEC MisLife,X ; I'm getting older!
MisDSkp LDA #$00
BEQ ResRTS ; Unconditional -- DO NOT Reset missile to tank
; ; (we'd need $02 on to do that) but RTS
;
; Launch a missile
;
Launch LDA #$3F
STA MisLife,X ; Init MisLife to $3F
SEC
LDA TankY0,X ; Copy Y-position... Tank Y-position points
; to top of sprite, but missile is launched
SBC #$06 ; from its center 6 scanlines down.
STA MissileY0,X
LDA DIRECTN,X ; Copy player bearing to missile.
STA DIRECTN+2,X
LDA #$1F
STA BounceCount,X ; Init BounceCount to $1F
LDA #$00
STA MxPFcount,X ; Reset MxPFcount
JMP MisFly ; Proceed w/missile in flight
; ------------------------------------------------------------
;
; This routine generates engine or Pong sound as appropriate.
;
MOTORS LDA AltSnd,X
BEQ DOMOTOR
; Pong sound.
LDA #$04
STA AUDC0,X
LDA #$07
STA AUDV0,X
LDA BounceCount,X
STA AUDF0,X
RTS
; Engine sound.
DOMOTOR LDY GAMSHP
LDA SNDV,Y
AND GameOn ; Kills sound if no game on by ANDing
STA AUDV0,X ; volume value w/$00 no-game value
LDA SNDC,Y
STA AUDC0,X
CLC
LDA #$00
MOPIT0 DEY ; This loop sets start value for sound
BMI MOPIT1 ; pitch based on GAMSHP in Y (tank,
ADC #$0C ; biplane, or jet)
BPL MOPIT0
MOPIT1 ADC Vtemp,X ; Use saved velocity to adjust
TAY ; sound pitch via SNDP table
TXA
ASL
ADC SNDP,Y
STA AUDF0,X
RTS
; ------------------------------------------------------------
;
; COLISion check
;
; 150 lines of angel-hair spaghetti code
;
; Check to see whether, during all that drawing,
; a missile hit one of the tanks, or a tank hit
; the wall or the other tank, and if so let
; the consequences fall.
;
COLIS LDX #$01 ; Do first for P1, DEX, P0, etc.
COLnext LDA CXM0P,X
BPL COLnoHit ; No missile collision
BIT BILLIARD
BVC COLDET ; Not Billiard game, go ahead & do it
LDA BounceCount,X
CMP #$1F
BEQ COLnoHit ; Billiard 1st bounce not satisfied
;
; A touch, a touch! I do confess.
;
COLDET INC DIRECTN,X ; Turn both tanks 22.5 degrees.
INC DIRECTN+2,X
;
; Increase player's score. A simple INC SCORE,X
; won't do because we're doing it in BCD.
;
SED
LDA SCORE,X
CLC
ADC #$01
STA SCORE,X
CLD
TXA
CLC
ADC #$FD
STA StirTimer
;
; Now StirTimer contains loser's ID in bit 0,
; victor's ID in bit 1, and set bits 2-7.
; Bit 1 ID is never used, and just creates a
; slight, unnoticeable difference in stir time.
;
LDA #$FF
STA RESMP0 ; Reset both missiles.
STA RESMP1
LDA #$00
STA AUDV0,X ; Turn off the victor's engine.
STA MisLife ; clear MisLife (no missile)
STA $9A ; and 9A.
RTS
;
; We didn't just end the game, so we deal with some
; sound and bounce logic
;
COLnoHit
BIT GAMVAR
BPL COLTNK ; Branch if a tank game.
JMP COLPD ; Skip this code if NOT a tank game
COLTNK LDA AltSnd,X
BEQ COLnoAlt
CMP #$04 ; See if alt sound has played out
INC AltSnd,X ; Increment if it has not
BCC COLnoAlt
LDA #$00 ; if played out, reset to 0 "no alt sound"
STA AltSnd,X
COLnoAlt
LDA CXM0FB,X ; Missile collision with playfield?
BMI COLMPF ; If true, bounce or obliterate...
LDA #$00
STA MxPFcount,X ; ...else clear MxPFcount
JMP COLTCK
;
COLMPF BIT PF_PONG
BVC COLMISX ; Branch if not Pong (bit 6 clear)
;
LDA MxPFcount,X ; It's Pong, so we bounce
BNE COLMPFX ; Branch if collision is already ongoing
INC AltSnd,X ; NEW COLLISION, set alt sound flag
DEC BounceCount,X
LDA DIRECTN+2,X ; First try at reflecting
STA OldMisDir,X ; Stash current missile heading
EOR #$FF ; reverse heading by complement,
STA DIRECTN+2,X ; then increment=additive inverse
INC DIRECTN+2,X ; same as subtracting from zero
LDA DIRECTN+2,X ; check new heading
AND #$03 ; See if it's moving exactly N,S,E, or W
BNE COLXY0
INC DIRECTN+2,X ; and add 22.5 degrees if so
COLXY0 JMP COLMPFdone
;
; I always wondered how this works. Stella does not know the
; orientation of the wall that was hit, so this is how it
; reflects:
;
; Immediately after a collision, it tries a vertical reflection,
; jiggering the result so that it won't be exactly vertical or
; exactly horizontal.
;
; If this is the next frame (MxPFcount=$01) that failed, so
; we reverse direction 180 degrees to turn it into a horizontal
; reflection.
;
; On MxPfcount=$02 we take no action, since the missile may need
; the cycle to re-emerge from a wall.
;
; On MxPFcount=$03 or higher, we retrieve the original heading and
; turn it 180 degrees, assuming a corner reflection. And we keep
; applying this same bearing until it's out of the #*%@ wall.
;
COLMPFX CMP #$01 ; branch if
BEQ Rev180 ; exactly 1 previous collision frame
CMP #$03 ; branch if
BCC COLMPFdone ; less than 3 collision frames
BNE COLMPFdone ; or more than three
LDA OldMisDir,X ; retrieve pre-bounce missile heading
JMP Bump180 ; and reverse it 180 degrees
;
; Exactly 1 previous collision: Do a 180-degree reversal, meaning
; 90 degrees the *other* way from our initial course.
;
Rev180 LDA DIRECTN+2,X ; Here to add 180 degrees
Bump180 CLC ; Here to add A to missile dir
ADC #$08
STA DIRECTN+2,X
JMP COLMPFdone
;
COLMISX LDA #$01 ; If it's not Pong, we come here and
STA MisLife,X ; set the missile's life to 1 to kill it.
;
COLMPFdone ; When we're done, increase collision
INC MxPFcount,X ; frame count & move on.
;
; Check for tank collisions
;
COLTCK LDA CXP0FB,X
BMI COLTW ; check if tank collided with a wall.
LDA CXPPMM ; check for a tank-tank collision.
BPL COLTCLR ; branch if NO tank collisions at all
COLTW LDA StirTimer ; See if we are stirring a tank
CMP #$02
BCC COLTnk1 ; No, branch & block
JSR RushTank ; We are stirring, send it scooting
;
COLTCLR LDA #$03 ; No tank collision, reset counter
STA COLcount,X
BNE COLPD ; unconditional branch, player done
;
COLTnk1 DEC COLcount,X ; Tank colliding
BMI COLbonk ; COLcount rolled, ignore collision
LDA Vtemp,X
BEQ COLPD ; No boink if velocity=0, player done
BNE COLreverse ; else skip INC, needed for elsewhere
;
COLbonk INC DIRECTN,X ; Jigger direction 22.5 for disorientation
COLreverse
LDA DIRECTN,X
CLC
ADC #$08 ; Add 180 degrees to direction
JSR BumpTank ; to bump tank back
;
; COLIS Player Done
;
COLPD DEX
BMI COLrts ;Return if X<0.
JMP COLnext ;Else do the other player
COLrts RTS
;
; Bump the tank in the direction
; the other player's missile is moving
;
RushTank
TXA
EOR #$01 ; Get OTHER player #
TAY ; in Y
LDA DIRECTN+2,Y ; OTHER player Missile's Direction
;
; Bump the tank in the direction of a standard
; 22.5-degree bearing code
;
BumpTank
AND #$0F
TAY
LDA HDGTBL,Y ;Nove
JSR PhMove ;Move object in that direction.
LDA #$00
STA MVadjA,X
STA MVadjB,X
STA FwdTimer,X ;Stop it dead in its tracks....
LDA XColor0,X
STA Color0,X
RTS
; ------------------------------------------------------------
;
; This was probably a toplevel routine early in development,
; but ended up getting called from GSGRCK. It sets everything
; up to draw the playfield based on the current game selection.
;
InitPF LDX GAMSHP ; 0=tank, 1=biplane, 2=jet
LDA SPRLO,X ; Set up base pointer to all
STA SHAPES ; sprite shapes which will
LDA SPRHI,X ; be used in this game.
STA SHAPES+1
;
LDA GAMVAR ; Now set up PF_PONG and playfield type
LSR
LSR
AND #$03 ; bits 0,1=maze (playfield) type.
TAX ; send it to X.
LDA GAMVAR
BPL IFgo ; Branch not plane game, PF_PONG=GAMVAR
AND #$08 ; Test for clouds
BEQ IF80 ; Branch if no clouds
LDX #$03 ; change "maze type" in X to 3 ("clouds")
BPL IFskip ; Unconditional skip to next test,
; leaving PF_PONG set to 0.
IF80 LDA #$80 ; Change PF_PONG to #$80
; (enable playfield, no Pong)
IFgo STA PF_PONG ; store GAMVAR or #$80 in PF_PONG.
IFskip LDA GAMVAR ; Next test..
ASL
ASL ; Do this again....
BIT GAMVAR
BMI IFnoPlane ; Branch if a plane game.
STA WSYNC ; This MUST be something that dropped
; through the cracks, there is NO reason!
STA BILLIARD ; Store GAMVAR*4 in 84 (bit 6 = Billiard Hit)
AND #$80 ; IF it's a tank game.
IFnoPlane
STA GUIDED ; set guided missile flag.
;
; GUIDED is ZERO if a tank game
; it is negative if a guided missile game,
; it is overflowed if a machine gun game.
; (Inapplicable in tank games, hence the
; previous branch trick)
;
LDA #>PF0_0 ; Store page of first PF map
STA LORES+1 ; as high order byte
STA LORES+3 ; for all of these pointers,
STA LORES+5 ; 'cause that's where it is.
;
; Store the proper offsets for each column of
; playfield from the vectors given
;
LDA PLFPNT,X
STA RESP0 ; Reset player 0 while we're at it.
STA LORES
LDA PLFPNT+4,X
STA LORES+2
LDA PLFPNT+8,X
STA LORES+4
RTS
; ------------------------------------------------------------
;
; LoaD STELla
;
; Set the number and size of player sprites, color, and
; disable the joysticks if game is not in play
;
LDSTEL LDA GAMVAR
AND #$87
BMI LDmult
;
; If bit 7 is set, we are playing with one or more
; planes. If not, well, we can only have one tank,
; so...
;
LDA #$00
LDmult ASL
TAX
LDA WIDTHS,X ; The TIA's NUSIZ registers make
STA NUSIZ0 ; it as easy to play with two or
LDA WIDTHS+1,X ; three planes as it is for one
STA NUSIZ1 ; freakin' huge bomber.
LDA GAMVAR
AND #$C0
LSR
LSR
LSR
LSR ; Our hardware is now in bits 3 and 2.
TAY ; Of the Y-register.
;
; Render joysticks immobile if game not in play, and
; select player and field colors according to Y
;
LDA GameOn ; Enable joysticks via bit 1
STA SWCHB ; of $FF game-on value
EOR #$FF ; now $FF=no game, $00=game on
AND GameTimer ; Cycle tank colors only when NO
STA TEMP1 ; game on (attract mode)
LDX #$FF
LDA SWCHB
AND #$08 ; Color/BW switch
BNE LDcolor ; Branch if set to Color
LDY #$10 ; Force B&W colors
LDX #$0F
LDcolor STX TEMP
LDX #$03 ; We loop 3 times to get 4 values
LDcol0 LDA ColorTbl,Y
EOR TEMP1 ; Apply color-cycle if no game on
AND TEMP ; Apply B&W massage
STA COLUP0,X ; Color the real item.
STA Color0,X ; Color the virtual item. This can
; be changd, e.g. invisible tanks
STA XColor0,X ; Color the deep virtual item. This
; is used to restore ColorX.
INY
DEX
BPL LDcol0
RTS
;
; ------------------------------------------------------------
;
; Zero out zero-page memory starting with ($A3+X) MOD $100,
; through $A2 wrapping around at $100.
;
; Calling with:
; X=$5D will clear $00-$A2
; X=$DD will clear $80-$A2
; X=$DF will clear $82-$A2
; X=$E6 will clear $89-$A2
;
; Returns with zero bit set.
;
ClearMem
LDA #$00
ClrLoop INX
STA $A2,X
BNE ClrLoop ;Continue until X rolls over.
RTS
; Patterns for numbers
;
NUMBERS .byte $0E ; | XXX | $F5C5 Leading zero is not drawn
.byte $0A ; | X X | $F5C6 because it's never used.
.byte $0A ; | X X | $F5C7
.byte $0A ; | X X | $F5C8
.byte $0E ; | XXX | $F5C9
.byte $22 ; | X X | $F5CA
.byte $22 ; | X X | $F5CB
.byte $22 ; | X X | $F5CC
.byte $22 ; | X X | $F5CD
.byte $22 ; | X X | $F5CE
.byte $EE ; |XXX XXX | $F5CF
.byte $22 ; | X X | $F5D0
.byte $EE ; |XXX XXX | $F5D1
.byte $88 ; |X X | $F5D2
.byte $EE ; |XXX XXX | $F5D3
.byte $EE ; |XXX XXX | $F5D4
.byte $22 ; | X X | $F5D5
.byte $66 ; | XX XX | $F5D6
.byte $22 ; | X X | $F5D7
.byte $EE ; |XXX XXX | $F5D8
.byte $AA ; |X X X X | $F5D9
.byte $AA ; |X X X X | $F5DA
.byte $EE ; |XXX XXX | $F5DB
.byte $22 ; | X X | $F5DC
.byte $22 ; | X X | $F5DD
.byte $EE ; |XXX XXX | $F5DE
.byte $88 ; |X X | $F5DF
.byte $EE ; |XXX XXX | $F5E0
.byte $22 ; | X X | $F5E1
.byte $EE ; |XXX XXX | $F5E2
.byte $EE ; |XXX XXX | $F5E3
.byte $88 ; |X X | $F5E4
.byte $EE ; |XXX XXX | $F5E5
.byte $AA ; |X X X X | $F5E6
.byte $EE ; |XXX XXX | $F5E7
.byte $EE ; |XXX XXX | $F5E8
.byte $22 ; | X X | $F5E9
.byte $22 ; | X X | $F5EA
.byte $22 ; | X X | $F5EB
.byte $22 ; | X X | $F5EC
.byte $EE ; |XXX XXX | $F5ED
.byte $AA ; |X X X X | $F5EE
.byte $EE ; |XXX XXX | $F5EF
.byte $AA ; |X X X X | $F5F0
.byte $EE ; |XXX XXX | $F5F1
.byte $EE ; |XXX XXX | $F5F2
.byte $AA ; |X X X X | $F5F3
.byte $EE ; |XXX XXX | $F5F4
.byte $22 ; | X X | $F5F5
.byte $EE ; |XXX XXX | $F5F6
;
; Horizontal and vertical offsets for movement by orientation.
; Basic table is $10 bytes long (22.5-degree increments), but
; XoffBase is added to it to alter for game options. High
; nibble is raw HMPx value for horizontal offset, low nibble
; is vertical offset in scan lines.
;
Xoffsets
.BYTE $F8 ,$F7 ,$F6 ,$06 ;XoffBase=0
.BYTE $06 ,$06 ,$16 ,$17
.BYTE $18 ,$19 ,$1A ,$0A
.BYTE $0A ,$0A ,$FA ,$F9
.BYTE $F8 ,$F7 ,$F6 ,$F6 ;XoffBase=$10
.BYTE $06 ,$16 ,$16 ,$17
.BYTE $18 ,$19 ,$1A ,$1A
.BYTE $0A ,$FA ,$FA ,$F9
.BYTE $E8 ,$E6 ,$E4 ,$F4 ;XoffBase=$20
.BYTE $04 ,$14 ,$24 ,$26 ;normal missiles
.BYTE $28 ,$2A ,$2C ,$1C
.BYTE $0C ,$FC ,$EC ,$EA
; This Xoffsets entry is also used directly for "bumping"
; a player after a hit or to back away from playfield collision
;
HDGTBL .BYTE $C8 ,$C4 ,$C0 ,$E0 ;XoffBase=$30
.BYTE $00 ,$20 ,$40 ,$44 ;machine guns, "bump"
.BYTE $48 ,$4C ,$4F ,$2F
.BYTE $0F ,$EF ,$CF ,$CC
;
; Player velocity momentum adjustments. Table of two-byte
; entries, indexed by player's desired final velocity. Even
; locations go to MVadjA to be applied during the first half of
; the FwdTimer cycle, and odd locations goe to MVadjB to be
; applied during the second half.
;
; During each half, the byte is rotated left one bit; if
; the bit which emerges is 1, XoffBase is tweaked by $10
; to adjust the velocity for that frame only. Since FwdTimer
; goes through 16 cycles or 2 8-bit halves in its course from,
; $F0 to $00, this gives us a bitwise "adjust this frame" flag
; for each frame in the course of FwdTimer's run. This is
; used to obscure the suddenness of transition from one
; velocity to another.
;
; The adjustment is only done once for each two ON bits
; since the MPace 1 bit is used for the adjustment, and
; MPace is INCed in the same code block that does the
; tweak. The tweak consists of replacing whatever XoffBase
; the final velocity calls for with $10, an intermediate value.
;
MVtable .BYTE $00 ,$00
.BYTE $80 ,$80
.BYTE $84 ,$20
.BYTE $88 ,$88
.BYTE $92 ,$48
.BYTE $A4 ,$A4
.BYTE $A9 ,$52
.BYTE $AA ,$AA
.BYTE $D5 ,$AA
.BYTE $DA ,$DA
.BYTE $DB ,$6D
.BYTE $EE ,$EE
;
; These are all the sprite shapes.
; The most I suspect any of you will do is
; modify these. And/or the number shapes.
;
TankShape
.byte $00 ; | | $F64F
.byte $FC ; |XXXXXX | $F650
.byte $FC ; |XXXXXX | $F651
.byte $38 ; | XXX | $F652
.byte $3F ; | XXXXXX| $F653
.byte $38 ; | XXX | $F654
.byte $FC ; |XXXXXX | $F655
.byte $FC ; |XXXXXX | $F656
.byte $1C ; | XXX | $F657
.byte $78 ; | XXXX | $F658
.byte $FB ; |XXXXX XX| $F659
.byte $7C ; | XXXXX | $F65A
.byte $1C ; | XXX | $F65B
.byte $1F ; | XXXXX| $F65C
.byte $3E ; | XXXXX | $F65D
.byte $18 ; | XX | $F65E
.byte $19 ; | XX X| $F65F
.byte $3A ; | XXX X | $F660
.byte $7C ; | XXXXX | $F661
.byte $FF ; |XXXXXXXX| $F662
.byte $DF ; |XX XXXXX| $F663
.byte $0E ; | XXX | $F664
.byte $1C ; | XXX | $F665
.byte $18 ; | XX | $F666
.byte $24 ; | X X | $F667
.byte $64 ; | XX X | $F668
.byte $79 ; | XXXX X| $F669
.byte $FF ; |XXXXXXXX| $F66A
.byte $FF ; |XXXXXXXX| $F66B
.byte $4E ; | X XXX | $F66C
.byte $0E ; | XXX | $F66D
.byte $04 ; | X | $F66E
.byte $08 ; | X | $F66F
.byte $08 ; | X | $F670
.byte $6B ; | XX X XX| $F671
.byte $7F ; | XXXXXXX| $F672
.byte $7F ; | XXXXXXX| $F673
.byte $7F ; | XXXXXXX| $F674
.byte $63 ; | XX XX| $F675
.byte $63 ; | XX XX| $F676
.byte $24 ; | X X | $F677
.byte $26 ; | X XX | $F678
.byte $9E ; |X XXXX | $F679
.byte $FF ; |XXXXXXXX| $F67A
.byte $FF ; |XXXXXXXX| $F67B
.byte $72 ; | XXX X | $F67C
.byte $70 ; | XXX | $F67D
.byte $20 ; | X | $F67E
.byte $98 ; |X XX | $F67F
.byte $5C ; | X XXX | $F680
.byte $3E ; | XXXXX | $F681
.byte $FF ; |XXXXXXXX| $F682
.byte $FB ; |XXXXX XX| $F683
.byte $70 ; | XXX | $F684
.byte $38 ; | XXX | $F685
.byte $18 ; | XX | $F686
.byte $38 ; | XXX | $F687
.byte $1E ; | XXXX | $F688
.byte $DF ; |XX XXXXX| $F689
.byte $3E ; | XXXXX | $F68A
.byte $38 ; | XXX | $F68B
.byte $F8 ; |XXXXX | $F68C
.byte $7C ; | XXXXX | $F68D
.byte $18 ; | XX | $F68E
JetShape
.byte $60 ; | XX | $F68F
.byte $70 ; | XXX | $F690
.byte $78 ; | XXXX | $F691
.byte $FF ; |XXXXXXXX| $F692
.byte $78 ; | XXXX | $F693
.byte $70 ; | XXX | $F694
.byte $60 ; | XX | $F695
.byte $00 ; | | $F696
.byte $00 ; | | $F697
.byte $C1 ; |XX X| $F698
.byte $FE ; |XXXXXXX | $F699
.byte $7C ; | XXXXX | $F69A
.byte $78 ; | XXXX | $F69B
.byte $30 ; | XX | $F69C
.byte $30 ; | XX | $F69D
.byte $30 ; | XX | $F69E
.byte $00 ; | | $F69F
.byte $03 ; | XX| $F6A0
.byte $06 ; | XX | $F6A1
.byte $FC ; |XXXXXX | $F6A2
.byte $FC ; |XXXXXX | $F6A3
.byte $3C ; | XXXX | $F6A4
.byte $0C ; | XX | $F6A5
.byte $0C ; | XX | $F6A6
.byte $02 ; | X | $F6A7
.byte $04 ; | X | $F6A8
.byte $0C ; | XX | $F6A9
.byte $1C ; | XXX | $F6AA
.byte $FC ; |XXXXXX | $F6AB
.byte $FC ; |XXXXXX | $F6AC
.byte $1E ; | XXXX | $F6AD
.byte $06 ; | XX | $F6AE
.byte $10 ; | X | $F6AF
.byte $10 ; | X | $F6B0
.byte $10 ; | X | $F6B1
.byte $38 ; | XXX | $F6B2
.byte $7C ; | XXXXX | $F6B3
.byte $FE ; |XXXXXXX | $F6B4
.byte $FE ; |XXXXXXX | $F6B5
.byte $10 ; | X | $F6B6
.byte $40 ; | X | $F6B7
.byte $20 ; | X | $F6B8
.byte $30 ; | XX | $F6B9
.byte $38 ; | XXX | $F6BA
.byte $3F ; | XXXXXX| $F6BB
.byte $3F ; | XXXXXX| $F6BC
.byte $78 ; | XXXX | $F6BD
.byte $60 ; | XX | $F6BE
.byte $40 ; | X | $F6BF
.byte $60 ; | XX | $F6C0
.byte $3F ; | XXXXXX| $F6C1
.byte $1F ; | XXXXX| $F6C2
.byte $1E ; | XXXX | $F6C3
.byte $1E ; | XXXX | $F6C4
.byte $18 ; | XX | $F6C5
.byte $18 ; | XX | $F6C6
.byte $00 ; | | $F6C7
.byte $83 ; |X XX| $F6C8
.byte $7F ; | XXXXXXX| $F6C9
.byte $3E ; | XXXXX | $F6CA
.byte $1E ; | XXXX | $F6CB
.byte $0C ; | XX | $F6CC
.byte $0C ; | XX | $F6CD
.byte $0C ; | XX | $F6CE
PlaneShape
.byte $00 ; | | $F6CF
.byte $8E ; |X XXX | $F6D0
.byte $84 ; |X X | $F6D1
.byte $FF ; |XXXXXXXX| $F6D2
.byte $FF ; |XXXXXXXX| $F6D3
.byte $04 ; | X | $F6D4
.byte $0E ; | XXX | $F6D5
.byte $00 ; | | $F6D6
.byte $00 ; | | $F6D7
.byte $0E ; | XXX | $F6D8
.byte $04 ; | X | $F6D9
.byte $8F ; |X XXXX| $F6DA
.byte $7F ; | XXXXXXX| $F6DB
.byte $72 ; | XXX X | $F6DC
.byte $07 ; | XXX| $F6DD
.byte $00 ; | | $F6DE
.byte $10 ; | X | $F6DF
.byte $36 ; | XX XX | $F6E0
.byte $2E ; | X XXX | $F6E1
.byte $0C ; | XX | $F6E2
.byte $1F ; | XXXXX| $F6E3
.byte $B2 ; |X XX X | $F6E4
.byte $E0 ; |XXX | $F6E5
.byte $40 ; | X | $F6E6
.byte $24 ; | X X | $F6E7
.byte $2C ; | X XX | $F6E8
.byte $5D ; | X XXX X| $F6E9
.byte $1A ; | XX X | $F6EA
.byte $1A ; | XX X | $F6EB
.byte $30 ; | XX | $F6EC
.byte $F0 ; |XXXX | $F6ED
.byte $60 ; | XX | $F6EE
.byte $18 ; | XX | $F6EF
.byte $5A ; | X XX X | $F6F0
.byte $7E ; | XXXXXX | $F6F1
.byte $5A ; | X XX X | $F6F2
.byte $18 ; | XX | $F6F3
.byte $18 ; | XX | $F6F4
.byte $18 ; | XX | $F6F5
.byte $78 ; | XXXX | $F6F6
.byte $34 ; | XX X | $F6F7
.byte $36 ; | XX XX | $F6F8
.byte $5A ; | X XX X | $F6F9
.byte $78 ; | XXXX | $F6FA
.byte $2C ; | X XX | $F6FB
.byte $0C ; | XX | $F6FC
.byte $06 ; | XX | $F6FD
.byte $0C ; | XX | $F6FE
.byte $08 ; | X | $F6FF
.byte $6C ; | XX XX | $F700
.byte $70 ; | XXX | $F701
.byte $B8 ; |X XXX | $F702
.byte $DC ; |XX XXX | $F703
.byte $4E ; | X XXX | $F704
.byte $07 ; | XXX| $F705
.byte $06 ; | XX | $F706
.byte $38 ; | XXX | $F707
.byte $10 ; | X | $F708
.byte $F0 ; |XXXX | $F709
.byte $7C ; | XXXXX | $F70A
.byte $4F ; | X XXXX| $F70B
.byte $E3 ; |XXX XX| $F70C
.byte $02 ; | X | $F70D
.byte $00 ; | | $F70E
;
; These are sub-pointers, used to set up the
; two-dimensional array at CTRLTBL.
;
CtrlBase .BYTE $00 ,$0B ,$16
;
; Two-dimensional array, 12x3.
;
; This array specifies what the joystick does
; in each game. Looking at it now the format looks
; like this:
;
; Low nybble = Amount to rotate object (signed)
; $00 = Not at all
; $01 = Clockwise (+1)
; $0F = Counter-clockwise (-1)
; High nybble = Speed to move object (unsigned)
; $00 = Not moving
; $F0 = Warp speed
;
; Observe the $FF's. Notice how indexing out of bounds with impossible
; joystick movements will cause strange behavior.
;
; Tank movement
; UP DOWN (No reverse)
CTRLTBL .BYTE $00 ,$10 ,$00 ,$FF
.BYTE $01 ,$11 ,$01 ,$FF ;LEFT
.BYTE $0F ,$1F ,$0F ;RIGHT
;
; Biplane movement (This is why controls are sideways)
; UP DOWN
.BYTE $50 ,$5F ,$51 ,$FF ;
.BYTE $30 ,$3F ,$31 ,$FF ;LEFT
.BYTE $70 ,$7F ,$71 ;RIGHT
;
; Jet fighter movement
; UP DOWN
.BYTE $90 ,$B0 ,$70 ,$FF ;
.BYTE $91 ,$B1 ,$71 ,$FF ;LEFT
.BYTE $9F ,$BF ,$7F ;RIGHT
;
;
; Sound information for different game types.
; Different tools of destruction make different
; sound.
;
; There is some more data below which looks to
; be other information; different machines at
; different speeds. The pitch table is 3D,
; having 12-entry records for each GAMSHP.
;
; Tanks Biplane, Jet Fighter
SNDV .BYTE $08 ,$02 ,$02 ; sound volumes
SNDC .BYTE $02 ,$03 ,$08 ; sound types
SNDP .BYTE $1D ,$05 ,$00 ; sound pitches indexed by velocity
.BYTE $00 ,$00 ,$00 ; for TANKS
.BYTE $00 ,$00 ,$00
.BYTE $00 ,$00 ,$00
.BYTE $00 ,$00 ,$1D ; for BIPLANES
.BYTE $1D ,$16 ,$16
.BYTE $0F ,$0F ,$00
.BYTE $00 ,$00 ,$00
.BYTE $00 ,$00 ,$00 ; for JETS
.BYTE $00 ,$00 ,$12
.BYTE $10 ,$10 ,$0C
.BYTE $0C ,$07 ,$07
;
; Player widths for various plane games.
; Through the miracle of the Atari 2600's NUSIZ
; register, the difference between a 1 vs. 1 game
; and a Bomber vs. 3 game is contained in just
; two bytes.
;
WIDTHS .BYTE $00 ,$00 ;1 vs. 1
.BYTE $01 ,$01 ;2 vs. 2
.BYTE $00 ,$03 ;1 vs. 3
.BYTE $27 ,$03 ;Bomber vs. 3
; Table of color combinations. Each 4 byte entry specifies
; Player 0, Player1, Playfield, and Background colors.
; (By a not-so-odd coincidence, these 4 color registers are
; addressed consecutively in the same order in the TIA.)
; Table is indexed by the high 2 bits of GAMVAR << 2, or
; forced to +$10 if B&W switch selected.
;
ColorTbl
byte $EA ,$3C ,$82 ,$44 ; 00 = Regular Tanks
.byte $32 ,$2C ,$8A ,$DA ; 01 = Tank Pong
.byte $80 ,$9C ,$DA ,$3A ; 10 = Jets
.byte $64 ,$A8 ,$DA ,$4A ; 11 = Biplanes
.byte $08 ,$04 ,$00 ,$0E ; special B&W
PF0_0 .byte $F0 ; |XXXX | $F779
.byte $10 ; | X | $F77A
.byte $10 ; | X | $F77B
.byte $10 ; | X | $F77C
.byte $10 ; | X | $F77D
.byte $10 ; | X | $F77E
.byte $10 ; | X | $F77F
.byte $10 ; | X | $F780
.byte $10 ; | X | $F781
.byte $10 ; | X | $F782
.byte $10 ; | X | $F783
.byte $10 ; | X | $F784
PF1_0 .byte $FF ; |XXXXXXXX| $F785
.byte $00 ; | | $F786
.byte $00 ; | | $F787
.byte $00 ; | | $F788
.byte $38 ; | XXX | $F789
.byte $00 ; | | $F78A
.byte $00 ; | | $F78B
.byte $00 ; | | $F78C
.byte $60 ; | XX | $F78D
.byte $20 ; | X | $F78E
.byte $20 ; | X | $F78F
.byte $23 ; | X XX| $F790
PF2_0 .byte $FF ; |XXXXXXXX| $F791
.byte $80 ; |X | $F792
.byte $80 ; |X | $F793
.byte $00 ; | | $F794
.byte $00 ; | | $F795
.byte $00 ; | | $F796
.byte $1C ; | XXX | $F797
.byte $04 ; | X | $F798
.byte $00 ; | | $F799
.byte $00 ; | | $F79A
.byte $00 ; | | $F79B
.byte $00 ; | | $F79C
PF1_1 .byte $FF ; |XXXXXXXX| $F79D
PF0_3 .byte $00 ; | | $F79E
.byte $00 ; | | $F79F
.byte $00 ; | | $F7A0
PF1_3 .byte $00 ; | | $F7A1
.byte $00 ; | | $F7A2
.byte $00 ; | | $F7A3
.byte $00 ; | | $F7A4
.byte $00 ; | | $F7A5
.byte $00 ; | | $F7A6
.byte $00 ; | | $F7A7
.byte $00 ; | | $F7A8
.byte $00 ; | | $F7A9
.byte $07 ; | XXX| $F7AA
.byte $1F ; | XXXXX| $F7AB
.byte $3F ; | XXXXXX| $F7AC
.byte $7F ; | XXXXXXX| $F7AD
PF1_2 .byte $FF ; |XXXXXXXX| $F7AE
.byte $00 ; | | $F7AF
.byte $00 ; | | $F7B0
.byte $00 ; | | $F7B1
.byte $00 ; | | $F7B2
.byte $00 ; | | $F7B3
.byte $00 ; | | $F7B4
.byte $00 ; | | $F7B5
.byte $00 ; | | $F7B6
.byte $60 ; | XX | $F7B7
.byte $20 ; | X | $F7B8
.byte $21 ; | X X| $F7B9
PF2_2 .byte $FF ; |XXXXXXXX| $F7BA
.byte $00 ; | | $F7BB
.byte $00 ; | | $F7BC
.byte $00 ; | | $F7BD
.byte $80 ; |X | $F7BE
.byte $80 ; |X | $F7BF
.byte $80 ; |X | $F7C0
.byte $80 ; |X | $F7C1
.byte $00 ; | | $F7C2
.byte $00 ; | | $F7C3
.byte $00 ; | | $F7C4
.byte $07 ; | XXX| $F7C5
; Addresses for Sprite Graphics
SPRLO .BYTE #PlaneShape, #TankShape, #>PlaneShape, #>JetShape
; Playfield address data. Kernal timing requires that
; these addresses point 4 bytes before the real start
; of data.
;
; Complex , None
; Simple , Clouds
PLFPNT .BYTE #<(PF0_0-4) ,#<(PF0_0-4)
.BYTE #<(PF0_0-4) ,#<(PF0_3-4) ;PF0
.BYTE #<(PF1_0-4) ,#<(PF1_1-4)
.BYTE #<(PF1_2-4) ,#<(PF1_3-4) ;PF1
.BYTE #<(PF2_0-4) ,#<(PF1_1-4)
.BYTE #<(PF2_2-4) ,#<(PF1_3-4) ;PF2
; Game features, indexed by game number-1.
;
; bits
; 1,0: TANKS PLANES
; X0 = Normal
; X1 = Invisible
; 00 = 1 vs. 1
; 01 = 2 vs. 2
; 10 = 3 vs. 1
; 11 = 3 vs. Giant
; 3,2: 01 = No maze
; 10 = Simple maze
; 00 = Complex maze
; 1X = Clouds
; 0X = No clouds
; 4: 0 = Direct Hit Normal Gun
; 1 = Billiard Hit Machine Gun
; 5: 0 = Straight Missiles
; 1 = Guided Missiles
; 6: 0 = Tanks Jets
; 1 = Tank Pong Biplanes
; 7: 0 = Tank Game
; 1 = Plane Game
;
VARMAP .BYTE $24 ;Game 1: 0010 0100 TANK
.BYTE $28 ;Game 2: 0010 1000
.BYTE $08 ;Game 3: 0000 1000
.BYTE $20 ;Game 4: 0010 0000
.BYTE $00 ;Game 5: 0000 0000
.BYTE $48 ;Game 6: 0100 1000 TANK PONG
.BYTE $40 ;Game 7: 0100 0000
.BYTE $54 ;Game 8: 0101 0100
.BYTE $58 ;Game 9: 0101 1000
.BYTE $25 ;Game 10: 0010 0101 INVISIBLE TANK
.BYTE $29 ;Game 11: 0010 1001
.BYTE $49 ;Game 12: 0100 1001 INVISIBLE TANK-PONG
.BYTE $55 ;Game 13: 0101 0101
.BYTE $59 ;Game 14: 0101 1001
.BYTE $A8 ;Game 15: 1010 1000 BIPLANE
.BYTE $88 ;Game 16: 1000 1000
.BYTE $98 ;Game 17: 1001 1000
.BYTE $90 ;Game 18: 1001 0000
.BYTE $A1 ;Game 19: 1010 0001
.BYTE $83 ;Game 20: 1000 0011
.BYTE $E8 ;Game 21: 1110 1000 JET FIGHTER
.BYTE $C8 ;Game 22: 1100 1000
.BYTE $E0 ;Game 23: 1110 0000
.BYTE $C0 ;Game 24: 1100 0000
.BYTE $E9 ;Game 25: 1110 1001
.BYTE $E2 ;Game 26: 1110 0010
.BYTE $C1 ;Game 27: 1100 0001
;
; $FF to signify end of game variations.
;
.BYTE $FF
; If you were changing this to a 4K cart, you'd
; want to change this ORG to $FFFC. You might also
; want to move AudPitch out of the interrupt vector...
;
ORG $F7FC
.word $f000 ; Reset IRQ
;
AudPitch
.BYTE $0F, $11 ; Motor sound pitch table by player