We just reached 30,000 articles on this wiki! 🥳
If you appreciate the work done within the wiki, please consider supporting The Cutting Room Floor on Patreon. Thanks for all your support!

Starglider (Atari ST)

From The Cutting Room Floor
Jump to navigation Jump to search

Title Screen

Starglider

Developer: Argonaut Software
Publisher: Rainbird Software
Platform: Atari ST
Released in EU: December 1986

SourceIcon.png This game has uncompiled source code.
DevTextIcon.png This game has hidden development-related text.

PrereleaseIcon.png This game has a prerelease article

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

Read about prerelease information and/or media for this game.
Prerelease Info

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	#$070

At 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		* Las

0x061777: 

	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 position

0x062508, 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)
Retrieved from "https://tcrf.net/index.php?title=Starglider_(Atari_ST)&oldid=1237252"