Staaaaaarglider ... by Rainbird!
The game was a major step forward for Argonaut, with them treading into 3D territory and pushing the boundary for 16-bit computer games further than ever. They later did this again with Star Fox, which even had the same name at one point.
Sub-Page#
Developer Text#
At 0x002A44 in the .stx dump, there's a small string noting its completion date.
StarGlider, (c)1986 Argonaut Software Ltd., by Jez San.
Published by BT Rainbird, London, UK.
Completed, Sept 1986.
Source Code#
Large chunks of assembler code has been scattered through the game's disk. The fragments can be found at the hex addresses listed below in the .stx dump.
0x058D10:
TO MY OWN VBLANK
* ENDLESS LOOP
WAIT rts
* BRA.S WAIT
MYKEY MOVE #$2500,SR
DC.W $4EF9
OLDKEY DS.L 1
sVBLANK MOVE.W D0,-(SP)
MOVE.W 2(SP),D0
AND.W #$FFFF-$700,D0
OR.W #$100,D0
* MOVE.W D0,2(SP)
MOVE.W (SP)+,D0
MOVE.B #0,$FFFA1B
VB0 MOVE.B #4,$FFFA21 * 3!??
CMPI.B #4,$FFFA21
BNE.S VB0
MOVE.B #8,$FFFA1B
MOVE.L A6,-(SP)
MOVE.W D0,-(SP)
* LEA MYVARS(PC),A6
ADDQ.B #1,FTIMER0(A6)
CMPI.B #24,FTIMER0(A6)
BNE.S VB1
CLR.B FTIMER0(A6)
ADDQ.B #$01,PF5+1(A6)
ADDQ.B #$01,PF6+1(A6)
VB1 BTST #0,FTIMER0(A6)
BEQ.S VB2
ADD.W #$100,PF6(A6)
SUB.W #$100,PF5(A6)
AND.W #$070At 0x0611E0:
rts
* Horizontal is fast, but could be faster by using first & last MASKS
colrhori cmp.w #17,d2 * Optimised routine if long line!
bcs colrhor2
bra colrhor2
* Following routine is not debugged as yet!!!
* ----------
colrhor1 and.w #15,d4
move.w d4,d3 * Save starting bit position
asl.w #1,d4 * Make BitPos into a Word index
lea wordmask(pc),a1
move.w 0(a1,d4.w),d0 * Get Starting word mask
or.w d0,(a0)+ * Draw first Word's set of pixels
sub.w d3,d2 * Subtract no. of pixels already
subq.w #1,d2 * drawn!
move.w d2,d4 * no. of filled Words in d4
lsr.w #4,d4
and.w #15,d2 * Las0x061777:
d6,a3
ror.w #1,d0 * Next pixel to Right
bcc.s cdrorfar * Was okay
addq.l #8,a0 * Skip to next address
addq.l #8,a1
addq.l #8,a2
addq.l #8,a3
cdrorfar dbra d2,colrdiag
rts
*
* Sets pixel (d1,d2) on the screen, d3 is Z coord!
* Be careful not to draw pixels offscreen!!!
*
drawpix move.l pixaddr(a6),a5
jmp (a5)
* Colour version of pixel draw...
pixcolr move.l scrnaddr(a6),a0
lsl.w #5,d2 * Multiply Y by 32
add.w d2,a0
lsl.w #2,d2 * Multiply Y by 4, to give y*128
add.w d2,a0 * Now Y*160 has been added
move.w d1,d2 * x div 2
lsr.w #1,d2
and.w #255-7,d2 * Lose ºplaneº bits
add.w d2,a0 * Now a0 has x offset added to give
move.l a0,a1 * plane 1 address
move.l a0,a2 * plane 2 address
move.l a0,a3 * plane 3 address
* Take into account the ColourPlane offsets here here...
add.w plane0(a6),a0
add.w plane1(a6),a1
add.w plane2(a6),a2
add.w plane3(a6),a3
not.b d1 * true bit position in the byte on screen
and.w #15,d1
moveq #0,d2
bset d1,d2
cmp.w #pixelz2,d3
bcc.s exitpix1
subq.w #1,d1 * Set pixel to the right of last one
bmi.s exitpix1
bset d1,d2
exitpix1 or.w d2,(a0) * Word modification!!
or.w d2,(a1)
or.w d2,(a2)
or.w d2,(a3)
cmp.w #pixelz1,d3 * Medium sized pixel!?
bcc.s exitpix2
or.w d2,160(a0)
or.w d2,160(a1)
or.w d2,160(a2)
or.w d2,160(a3)
tst.w d1 * Did the right pixel overflow Word
bpl.s exitpix2
move.w #32768,d2
or.w d2,8(a0)
or.w d2,8(a1)
or.w d2,8(a2)
or.w d2,8(a3)
or.w d2,168(a0)
or.w d2,168(a1)
or.w d2,168(a2)
or.w d2,168(a3)
exitpix2 rts
* Draws pixels in 3 sizes!
pixmono move.l scrnaddr(a6),a0
lsl.w #4,d2 * Multiply Y by 16
add.w d2,a0
lsl.w #2,d2 * Multiply Y by 4, to give y*64
add.w d2,a0 * Now Y*80 has been added
move.w d1,d2 * x div 8
lsr.w #3,d2
add.w d2,a0 * Now a0 has x offset added to give
not.b d1 * true byte position on screen
and.w #7,d1
* First Pixel, always set
bset d1,(a0) * Byte modification!! << 1st pixel
* Is Z nearer than pixelz1
cmp.w #pixelz1,d3
bcc.s exitpix
bset d1,80(a0) * Set pixel immediately underneath too
cmp.w #pixelz2,d3
bcc.s exitpix
subq.w #1,d1 * next pixel
bpl.s nnxtbt1
bset #7,1(a0) * First pixel on next location
bset #7,81(a0) * and pixel underneath too
exitpix rts
nnxtbt1 bset d1,(a0) * pixel next to it...
bset d1,80(a0) * and underneath
rts
*
* Sprite - High Level interface to DrawSprite
* Entry: d1 X coordinate (0 - 319)
* d2 Y coordinate (0 - 199)
* a0 shape data.
*
* All registers lost.
*
sprite move.l spriteaddr(a6),a5
jmp (a5)
csprite move.w (a0)+,temp(a6) * Number of Words wide
move.w (a0)+,d6 * Number of Lines deep
sub.w (a0)+,d1 * Incorporate Centre of object
sub.w (a0)+,d2
move.l scrnaddr(a6),a1 * Determine Screen Memory
lsl.w #5,d2 * Multiply Y by 32
add.w d2,a1 * And update screen pointer
lsl.w #2,d2 * Multiply Y by 4, to give y*128
add.w d2,a1 * Now Y*160 has been added
move.w d1,d2 * Restore x
lsr.w #1,d2 * Divide by 2
and.w #255-7,d2 * Lose ºplaneº bits
add.w d2,a1 * A1 now has x and y offsets added
move.w d1,d5 * Restore X
and.w #15,d5 * Determine alignment position0x062508, 0x0639B0, 0x064E60:
* ... fall through, into DrawSprite
*
* DrawSprite - Low Level Colour Sprite routine.
* Entry: a0 points to shape data
* a1 points to screen
* d7 number of words across (multiples of 4)
* d6 number of lines down
* d5 pixel offset from aligned word (0 - 15)
*
* Exit: All registers stomped on (Serve's Em Right!!)
*
cdrawsprite
move.w #bytecolr,a3 * Bytes per line in colour mode
sub.w temp(a6),a3 * Amount to move down a line
sub.w temp(a6),a3 * ... in bytes!
subq.w #1,temp(a6) * Setup for DBRA
bmi.s nosprite
subq.w #1,d6 * Setup for DBRA
bmi.s nosprite
lea sprmask(pc),a2 * Determine alignment masks
move.w d5,d1 * Save the bit modulo
add.w d5,d5 * Prepare for indexing tables
move.w 0(a2,d5.w),d3 * Usable alignment mask
move.w 32(a2,d5.w),d4 * Overflow alignment mask
move.w d1,d5 * Restore the bit modulo
clr.w d1 * Bitplane modulo counter
lea bitplanes(PC),a2 * Bitplane Alignment overflow list
tst.w d5 * Normally aligned?
beq spriteal1
spritelp move.w temp(a6),d7
clr.l (a2) * Initialise the list
clr.l 4(a2) * .. some more
spritel2 move.w (a0)+,d0 * Get some Sprite data
ror.w d5,d0 * De-Align the data
move.w d0,d2 * Retain for later use
and.w d3,d0 * Mask data leaving useful bits
and.w d4,d2 * Mask data leaving overflow bits
or.w 0(a2,d1.w),d0 * Insert previous overflow bits
move.w d2,0(a2,d1.w) * Provide new overflow bits
addq.w #2,d1 * Increment bitplane modulo
and.w #7,d1 * Ensure it remains a modulo!
move.w d0,(a1)+ * Shove Sprite data onto Screen
dbra d7,spritel2 * Go back for rest of line
move.w (a2),(a1) * Final Overflow becomes last word
move.w 2(a2),2(a1) * plane 1
move.w 4(a2),4(a1) * plane 2
move.w d2,6(a1) * plane 3
add.w a3,a1 * Bump Screen to next scanline
dbra d6,spritelp * Do more sprite lines
nosprite rts
* Normally aligned sprite...
spriteal1
move.w temp(a6),d7
spriteal2
move.w (a0)+,(a1)+ * Get some Sprite data on screen
dbra d7,spriteal2 * Go back for rest of line
add.w a3,a1 * Bump Screen to next scanline
dbra d6,spriteal1 * Do more sprite lines
rts
bitplanes dc.w 0,0,0,0 * Temporary storage of bitplane modulo's
* Sprite masks for usable portion of a data word
sprmask dc.w $ffff,$7fff,$3fff,$1fff,$0fff,$07ff,$03ff,$01ff
dc.w $00ff,$007f,$003f,$001f,$000f,$0007,$0003,$0001
* Masks for overflow portion of a data word
dc.w $0000,$8000,$c000,$e000,$f000,$f800,$fc00,$fe00
dc.w $ff00,$ff80,$ffc0,$ffe0,$fff0,$fff8,$fffc,$fffe
*
* Draw a Monochrome Sprite..
*
msprite move.w (a0)+,temp(a6) * Number of Words wide
move.w (a0)+,d6 * Number of Lines deep
sub.w (a0)+,d1 * Incorporate Centre of object
sub.w (a0)+,d2
move.l scrnaddr(a6),a1 * Determine Screen Memory
lsl.w #4,d2 * Multiply Y by 16
add.w d2,a1 * And update screen pointer
lsl.w #2,d2 * Multiply Y by 4, to give y*64
add.w d2,a1 * Now Y*80 has been added
move.w d1,d2 * Restore x
lsr.w #3,d2 * Divide by 8
and.w #126,d2 * bottom bit lost!
add.w d2,a1 * A1 now has x and y offsets added
move.w d1,d5 * Restore X
and.w #15,d5 * Determine alignment position
* ... fall through, into DrawSprite
*
* DrawSprite - Low Level Mono Sprite routine.
* Entry: a0 points to shape data
* a1 points to screen
* d7 number of words across
* d6 number of lines down
* d5 pixel offset from aligned word (0 - 15)
*
* Exit: All registers stomped on (Serve's Em Right!!)
*
mdrawsprite
move.w #bytemono,a3 * Bytes per line in colour mode
sub.w temp(a6),a3 * Amount to move down a line
sub.w temp(a6),a3 * ... in bytes!
subq.w #1,temp(a6) * Setup for DBRA
bmi.s mnosprite
subq.w #1,d6 * Setup for DBRA
bmi.s mnosprite
lea sprmask(pc),a2 * Determine alignment masks
move.w d5,d1 * Save the bit modulo
add.w d5,d5 * Prepare for indexing tables
move.w 0(a2,d5.w),d3 * Usable alignment mask
move.w 32(a2,d5.w),d4 * Overflow alignment mask
move.w d1,d5 * Restore the bit modulo
tst.w d5 * Normally aligned?
beq mspriteal1
mspritelp
move.w temp(a6),d7
clr.w overflo(a6)
mspritel2
move.w (a0)+,d0 * Get some Sprite data
ror.w d5,d0 * De-Align the data
move.w d0,d2 * Retain for later use
and.w d3,d0 * Mask data leaving useful bits
and.w d4,d2 * Mask data leaving overflow bits
or.w overflo(a6),d0 * Insert previous overflow bits
move.w d2,overflo(a6) * Provide new overflow bits
move.w d0,(a1)+ * Shove Sprite data onto Screen
dbra d7,mspritel2 * Go back for rest of line
move.w overflo(a6),(a1) * Final Overflow becomes last word
add.w a3,a1 * Bump Screen to next scanline
dbra d6,mspritelp * Do more sprite lines
mnosprite
rts
* Normally aligned sprite...
mspriteal1
move.w temp(a6),d7
mspriteal2
move.w (a0)+,(a1)+ * Get some Sprite data on screen
dbra d7,mspriteal2 * Go back for rest of line
add.w a3,a1 * Bump Screen to next scanline
dbra d6,mspriteal1 * Do more sprite lines
rts
ifeq 1
*
* Polygon Clip subroutine...
* (Havent eevn started this one yet.. .but soon!)
*
polyclip rts
* Polygon draw subroutine (yea yea, we`ve all heard the dead parrot joke)
* Draws a filled polygon at coordinates specified by the edges provided.
*
* Entry: edgaddr(a6) points to list of edges, and numedges is how many there are.
* Exit: All registers preserved.
*
* Edge List contains X,Y lines in Words.
polyfill movem.l d0-d7/a0-a5,-(sp)
* Polygon EDGE pre-processing...
move.w numedgs(a6),d0
subq.w #1,d0
move.l edgaddr(a6),a4
moveq #0,d1
* Make sure Y`s are right way round... ** Optimize this!
presort move.w 0(a4,d1.w),d4 * x1
move.w 2(a4,d1.w),d5 * y1
move.w 4(a4,d1.w),d6 * x2
move.w 6(a4,d1.w),d7 * y2
cmp.w d5,d7 * y1 > y2?
bpl.s bdntswp
move.w d4,4(a4,d1.w) * Swap p1 & p2
move.w d5,6(a4,d1.w)
move.w d6,0(a4,d1.w)
move.w d7,2(a4,d1.w)
addq.w #8,d1 * Bump index
bdntswp dbra d0,presort
* Now perform Insertion Sort of ascending Y coords
* Takes N passes for N elements, to sort them properly.
* However, each pass has n-1 elements than each previous pass, so its
* quite quick.
move.w numedgs(a6),d7
subq.w #1,d7
moveq #0,d2 * Zero the Front index
psort1 move.w numedgs(a6),d0 * Do one iteration.
subq.w #1,d0
move.w d2,d1 * Point index to front of edge list
moveq #0,d3 * Ptr to minimum element
move.w #$7fff,d5 * The ongoing minimum set to temp(a6)orary max
psort2 cmp.w 2(a4,d1.w),d5 * Is y of p1 smaller than my minimum?
blt.s notamin
* Set a new minimum, and pointer
move.w 2(a4,d1.w),d5 * Make element the new minimum
move.w d1,d3 * Ptr to minimum element
notamin addq.w #8,d1 * Find next edge
dbra d0,psort2 * Fulfill the current pass
* Okay, we now have a minimum, so time to do the swapsies...
* (Swap the Front element of the list with the minimum one),
* and increment the pointer to signify a new `front` which bypasses
* the element we just added.
move.w 0(a4,d2.w),d4 * temp(a6)orary Front element
move.w 0(a4,d3.w),0(a4,d2.w)
move.w d4,0(a4,d3.w)
move.w 2(a4,d2.w),d4
move.w 2(a4,d3.w),2(a4,d2.w)
move.w d4,2(a4,d3.w)
move.w 4(a4,d2.w),d4
move.w 4(a4,d3.w),4(a4,d2.w)
move.w d4,4(a4,d3.w)
move.w 4(a4,d2.w),d4
move.w 4(a4,d3.w),4(a4,d2.w)
move.w d4,4(a4,d3.w)
addq.w #8,d2 * Point to next start of edge list
dbra d7,psort1 * Next pass ... n
* Continues...
movem.l (sp)+,d0-d7/a5
rts
* Draws a scanline`s worth of polygon
* Entry: a1 points to memory start, and d1 is start mask
* d2 is number of words to fill
* Exit: Nothing special, no saved reggies etc.
* Not quite right, must OR the first and last ones on.
oneline move.w #$ffff,d3 * Fill pattern, all 1`s
move.w d1,(a1)+
subq.w #1,d2
bmi.s finiline
beq.s lastline
onelin2: move.w d3,(a1)+
dbra d2,onelin2
lastline move.w d4,(a1)+
finiline rts
endc
* *******************************************
* * CLEAR WINDOW/SCREEN routines *
* *******************************************
* Clear the graphics area of the screen very quickly... 23840 bytes to 0
* Entry: Nothing special, No registers required.
* Exit: All registers lost, for speed.
clsgraf move.l clsaddr(a6),a5
jmp (a5)
*
* Colour clear graphics area
*
clscolr move.l a6,-(sp)
move.l scrnaddr(a6),a5
add.w #colrlen+152,a5 * Ensure Positive!
moveq #2,d0
moveq #0,d1
moveq #0,d2 * Zero 12 registers in all
moveq #0,d3 * to allow 48 bytes zeroed each.
moveq #0,d4
moveq #0,d5
moveq #0,d6
moveq #0,d7
sub.l a0,a0
sub.l a1,a1
sub.l a2,a2
sub.l a3,a3
sub.l a4,a4
move.w #16,a6 * Amount to skip, each scanline
clsqlp1 movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
dbra d0,clsqlp1
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5
movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)(Source: counterDiving)
References#
- StarGlider↩︎
- Computer Entertainer issue 5-6, p. 14."Starglider (FIR)"↩︎
- Popular Computing Weekly (1986-08-07), Special Supplement, p. vii. "Together with sophisticated sound effects, sampled speech and full control panel read-outs, Starglider, scheduled for an August release, looks like being a winner."↩︎