;//////////////////////////////////////////////////////////////////////////////
;
;            Procedury wspomagajâce animacjë programu Grawitacja.
;                Autor: Grzegorz Malewicz   Kielce, 1993-10-03
;
;                                 Mój adres:
;                   ul. Alabastrowa 56 Kielce  25705 POLAND
;
;   Jeôli chcesz wykorzystaê którâô z poniûszych procedur lub dokonaê zmian
;                 w programie MUSISZ uzyskaê zgodë autora!!!
;
;   DO ASEMBLACJI SAS/C 680x0 Assembler V6.00. Uzyskany object file naleûy
;                doîâczyê przy konsolidacji programu gîównego
;
;\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

bm_BytesPerRow	EQU	0
bm_Rows		EQU	2
bm_Flags	EQU	4
bm_Depth	EQU	5
bm_Pad		EQU	6
bm_Planes	EQU	8

MEMF_ANY	EQU	0

_LVOAllocMem	EQU	-198
_LVOFreeMem	EQU	-210

		XDEF	_CircleInit
		XDEF	_Circle
		XDEF	_RemoveCircles
		XDEF	_ResetBoxPtrs
		XDEF	_CircleEnd

		XDEF	_ClearPlaneInit
		XDEF	_ClearPlane
                
                XDEF    _LMB
                XDEF    _RMB

		section	code,code

;------------------------------------------------------------------------------
;   Procedura inicjuje tablicë przesuniëê do linii ekranu oraz tablicë do
; usuwania kóî _RemoveCircles. Procedura _CircleInit powinna byê wywoîana
; przed rysowaniem kóîek. Kóîka mogâ byê rysowane tylko gdy zwróci TRUE
;   WEJÔCIE: a4=BitMap
;            d0=screen width
;   WYJÔCIE: d0=0 - BÎÂD (FALSE)
;            d0=1 - OK   (TRUE)
;------------------------------------------------------------------------------

MAXCIAL		EQU	20	;Uwaga zdefiniowana takûe w Graw.c, obie muszâ
				;byê równe
box_x		EQU	0
box_y		EQU	2
box_s		EQU	4
box_sizeof	EQU	6

_CircleInit
		movem.l	d2/a4/a6,-(a7)
		move.w	d0,cir_width
		move.l	bm_Planes(a4),cir_firstbpl
	;przydziel pamiëê na tablicë przesuniëê do linii
		moveq.l	#0,d0
		move.w	bm_Rows(a4),d0
		beq	cirinit_err2
		lsl.w	#2,d0
		move.l	d0,cir_tabsize
		move.l	#MEMF_ANY,d1
		move.l	4,a6
		jsr	_LVOAllocMem(a6)
		move.l	d0,cir_tabaddr
		beq	cirinit_err2
	;przydziel pamiëê na box do czyszczenia narysowanych kóîek
		move.w	#MAXCIAL,d0
		mulu.w	#box_sizeof,d0
		add.l	d0,d0
		move.l	d0,cir_boxessize
		move.l	#MEMF_ANY,d1
		move.l	4,a6
		jsr	_LVOAllocMem(a6)
		move.l	d0,cir_boxesaddr
		beq	cirinit_err1
		move.l	d0,cir_box1begin
		move.l	d0,cir_box1ptr
		move.l	cir_boxessize,d1
		lsr.l	#1,d1
		add.l	d1,d0
		move.l	d0,cir_box2begin
		move.l	d0,cir_box2ptr
	;zapisz wysokoôê bitplanu
		move.w	bm_Rows(a4),cir_height
	;okreôê szerokoôê widocznej czëôci bitplanu w bajtach
		move.w	cir_width,d0
		move.w	d0,d1
		lsr.w	#3,d0
		and.w	#$0007,d1
		beq	cirinit_d1
		addq.w	#1,d0
cirinit_d1	subq.w	#1,d0
		move.w	d0,cir_bwidth
	;wypeîï tablicë przesuniëciami do linii
		move.l	cir_tabaddr,a0
		moveq.l	#0,d0
		move.l	d0,d2
		move.w	bm_Rows(a4),d1
		move.w	bm_BytesPerRow(a4),d2
		subq.w	#1,d1
cirinit_p1	move.l	d0,(a0)+
		add.l	d2,d0
		dbf	d1,cirinit_p1
		movem.l	(a7)+,d2/a4/a6
		moveq.l	#1,d0
		rts
cirinit_err1	move.l	cir_tabaddr,a1
		move.l	cir_tabsize,d0
		move.l	4,a6
		jsr	_LVOFreeMem(a6)
cirinit_err2	movem.l	(a7)+,d2/a4/a6
		moveq.l	#0,d0
		rts

cir_tabaddr	dc.l	0
cir_tabsize	dc.l	0

cir_boxesaddr	dc.l	0
cir_boxessize	dc.l	0

cir_box1begin	dc.l	0
cir_box1ptr	dc.l	0
cir_box2begin	dc.l	0
cir_box2ptr	dc.l	0

cir_width	dc.w	0
cir_bwidth	dc.w	0
cir_height	dc.w	0

cir_firstbpl	dc.l	0

;------------------------------------------------------------------------------
;   Procedura zwalniajâca pamiëê po inicjacji _CircleInit. Powinna byê
; wywoîana po narysowyniu kóîek. Moûna jâ woîaê nawet gdy inicjacja zwróciîa
; FALSE
;------------------------------------------------------------------------------

_CircleEnd
		movem.l	a6,-(a7)
		move.l	cir_tabaddr,d0
		beq	cirend_d1
		move.l	d0,a1
		move.l	#0,cir_tabaddr
		move.l	cir_tabsize,d0
		move.l	4,a6
		jsr	_LVOFreeMem(a6)
cirend_d1	move.l	cir_boxesaddr,d0
		beq	cirend_d2
		move.l	d0,a1
		move.l	#0,cir_boxesaddr
		move.l	cir_boxessize,d0
		move.l	4,a6
		jsr	_LVOFreeMem(a6)
cirend_d2	movem.l	(a7)+,a6
		rts
		
;------------------------------------------------------------------------------
;  Procedura przygotowuje parametry dla _ClearPlane
; WEJÔCIE: a4=BitMap
;------------------------------------------------------------------------------

_ClearPlaneInit
		movem.l	d2/d3/a4,-(a7)
	;zapisz rozmiar bitplanu
		moveq.l	#0,d0
		move.l	d0,d2
		move.w	bm_Rows(a4),d1
		move.w	bm_BytesPerRow(a4),d2
		move.w	d1,d3
		mulu.w	d2,d3
		move.l	d3,clr_planesize
	;zapisz iloôê paczek po 52 bajty zawartych w bitplanie - 1
		divu.w	#52,d3
		subq.w	#1,d3
		move.w	d3,clr_ilepack
	;zapisz iloôê pozostaîych bajtów - 1
		swap	d3
		subq.w	#1,d3
		move.w	d3,clr_ileleft
		movem.l	(a7)+,d2/d3/a4
		rts

clr_planesize	dc.l	0
clr_ilepack	dc.w	0
clr_ileleft	dc.w	0

;------------------------------------------------------------------------------
;   Procedura czyôci bitplan. Jego rozmiar jest ustalany przez _ClearPlaneInit
; Z tego wzglëdu naleûy obowiâzkowo wywoîaê _ClearPlaneInit przed _ClearPlane
; WEJÔCIE: a6=adres bitplanu
;------------------------------------------------------------------------------

_ClearPlane
		movem.l	d2-d7/a2-a6,-(a7)
	;weú adres koïca bitplanu
		move.l	clr_planesize,d0
		add.l	d0,a6
	;wyzeruj rejestry
		sub.l	d1,d1
		move.w	clr_ilepack,d0
		bmi	cp_d1
		move.l	d1,d2
		move.l	d1,d3
		move.l	d1,d4
		move.l	d1,d5
		move.l	d1,d6
		move.l	d1,d7
		move.l	d1,a0
		move.l	d1,a1
		move.l	d1,a2
		move.l	d1,a3
		move.l	d1,a4
		move.l	d1,a5
	;wypeîï packi
cp_p1		movem.l	d1-d7/a0-a5,-(a6)	;13*4=52 bajtów na raz
		dbf	d0,cp_p1
	;dopeîï resztë
cp_d1		move.w	clr_ileleft,d0
		bmi	cp_d2
cp_p2		move.b	d1,-(a6)
		dbf	d0,cp_p2
cp_d2		movem.l	(a7)+,d2-d7/a2-a6
		rts

;------------------------------------------------------------------------------
;   Procedura rysujâca linië poziomâ poczâwszy od punktu (x,y) o szerokoôci d.
; Linia jest rysowana w prawo od punktu. Przy rysowaniu zastosowany jest
; clipping. Z tego wzglëdu naleûy podaê szerokoôê i wysokoôê ekranu.
; WEJÔCIE: d6.w=x
;          d7.w=y
;          d2.w=d
;          a0=adres li_T1
;          a4=adres cir_bwidth
;          a5=adres cir_width
;          a6=adres cir_height
;          a2=adres spod adresu cir_tabaddr
;          a3=adres bitplanu
;------------------------------------------------------------------------------

Linia
		movem.w	d0/d2/d6/d7,-(a7)
	;sprawdú szerokoôê
		cmp.w	#1,d2
		blt	li_niewidoczny
	;czy mieôci sië w zakresie na y
		tst.w	d7
		bmi	li_nad
		move.w	(a6),d0
		cmp.w	d0,d7
		bcc	li_pod
	;co z x
		tst.w	d6
		bmi	li_xujemny
		beq	li_xzerowy
		move.w	(a5),d0
		cmp.w	d6,d0
		bls	li_poprawej
		sub.w	d6,d0
		cmp.w	d2,d0
		bls	li_tillend
;na ôrodku
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
		move.w	d6,d7
		lsr.w	#3,d7
		lea	0(a1,d7.w),a1		;adres bajtu
		andi.w	#$0007,d6
		beq	li_sd1
		add.w	d6,d2
		subq.w	#8,d2
		bcs	li_sd3
		move.b	8(a0,d6.w),d6
		or.b	d6,(a1)+
li_sd1		move.w	d2,d7			;zaczyna sië równo z bajtem
		lsr.w	#3,d7
		beq	li_sd2
		subq.w	#1,d7
		moveq.l	#-1,d6
li_p4		move.b	d6,(a1)+		;wypeîï bajtami $ff
		dbf	d7,li_p4
li_sd2		andi.w	#$0007,d2		;dopisz prawy koniec
		beq	li_sd4
		move.b	0(a0,d2.w),d2
		or.b	d2,(a1)
li_sd4		movem.w	(a7)+,d0/d2/d6/d7
		rts
li_sd3		move.b	8(a0,d6.w),d6		;wszystko w jednym bajcie
		move.b	8(a0,d2.w),d7
		and.b	d7,d6
		or.b	d6,(a1)
		movem.w	(a7)+,d0/d2/d6/d7
		rts
		
li_xujemny	neg.w	d6
		sub.w	d6,d2
		bls	li_polewej
li_xzerowy
		move.w	(a5),d0
		cmp.w	d2,d0
		bls	li_fullline
;od lewego brzegu do ôrodka
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
		move.w	d2,d7
		lsr.w	#3,d7
		beq	li_lsd1
		subq.w	#1,d7
		moveq.l	#-1,d6
li_p2		move.b	d6,(a1)+
		dbf	d7,li_p2
li_lsd1		andi.w	#$0007,d2
		beq	li_lsd2
		move.b	0(a0,d2.w),d2
		or.b	d2,(a1)
li_lsd2		movem.w	(a7)+,d0/d2/d6/d7
		rts

li_tillend
;od ôrodka do prawego brzegu
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
		move.w	d6,d7
		lsr.w	#3,d7
		lea	0(a1,d7.w),a1		;adres bajtu
		andi.w	#$0007,d6
		beq	li_spd1
		move.b	8(a0,d6.w),d6
		or.b	d6,(a1)+
		addq.w	#1,d7
li_spd1		move.w	(a4),d6
		sub.w	d7,d6
		bcs	li_spd2
		moveq.l	#-1,d7
li_p3		move.b	d7,(a1)+
		dbf	d6,li_p3
li_spd2		movem.w	(a7)+,d0/d2/d6/d7
		rts

li_fullline
;od lewego brzegu do prawego brzegu
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
		move.w	(a4),d7
		moveq.l	#-1,d6
li_p1		move.b	d6,(a1)+
		dbf	d7,li_p1
		movem.w	(a7)+,d0/d2/d6/d7
		rts

;jeôli linia jest poza ekranem
li_niewidoczny
li_poprawej
li_polewej
li_nad
li_pod
		movem.w	(a7)+,d0/d2/d6/d7
		rts

li_T1		dc.b	%00000000
		dc.b	%10000000
		dc.b	%11000000
		dc.b	%11100000
		dc.b	%11110000
		dc.b	%11111000
		dc.b	%11111100
		dc.b	%11111110

		dc.b	%11111111
		dc.b	%01111111
		dc.b	%00111111
		dc.b	%00011111
		dc.b	%00001111
		dc.b	%00000111
		dc.b	%00000011
		dc.b	%00000001

;------------------------------------------------------------------------------
;   Makro stawiajâce punkt. Lewy górny róg to (0,0). Iksy rosnâ w prawo,
; a igreki w dóî
; WEJÔCIE: \1.w=x
;          \2.w=y
;          a2=wartoôê komórki cir_tabaddr
;          a3=adres bitplanu
; WYJÔCIE: a1=adres bajtu
;          a5=adres cir_width
;          a6=adres cir_height
;          niszczy \2.l, d7
;------------------------------------------------------------------------------

PUNKT		MACRO
		move.w	(a5),d7
		cmp.w	d7,\1
		bcc	\@pkt_end
		move.w	(a6),d7
		cmp.w	d7,\2
		bcc	\@pkt_end
		move.w	d0,-(a7)
		lsl.w	#2,\2
		move.l	0(a2,\2.w),\2
		move.l	a3,a1
		adda.l	\2,a1			;adres linii
		move.w	\1,\2
		lsr.w	#3,\2
		lea	0(a1,\2.w),a1		;adres bajtu
		andi.b	#$07,\1
		neg.b	\1
		addq.b	#7,\1
		bset.b	\1,(a1)
		move.w	(a7)+,d0
\@pkt_end
		ENDM
		
;------------------------------------------------------------------------------
;   Procedura rysujâca wypeînione kîóka i zapisuje ich pozycjë do tablicy,
; by moûna je byîo póúniej usunâê _RemoveCircles. Przed uûyciem _Circle naleûy
; wywoîaê _CircleInit. Nie moûna narysowaê wiëcej kóîek niû MAXCIAL
; WEJÔCIE: a3=adres bitplanu
;          d0.l=x
;          d1.l=y
;          d2.l=r
;------------------------------------------------------------------------------

_Circle
		movem.l	d2-d7/a2-a6,-(a7)
	;kontrola czy x,y naleûa <-10000,10000> oraz r<=10000
		cmp.l	#10000,d0
		bgt	cir_end
		cmp.l	#10000,d1
		bgt	cir_end
		cmp.l	#10000,d2
		bgt	cir_end
		cmp.l	#-10000,d0
		blt	cir_end
		cmp.l	#-10000,d1
		blt	cir_end
	;zapisz kwadrat, w którym rysowane bëdzie kóîko
		cmpa.l	cir_firstbpl,a3
		beq	cir_d2
		lea	cir_box2ptr,a1			;second bitplan
		bra	cir_d3
cir_d2		lea	cir_box1ptr,a1			;first bitplan
cir_d3		move.l	(a1),a0
		move.w	d0,d3
		sub.w	d2,d3
		move.w	d3,(a0)+
		move.w	d1,d3
		sub.w	d2,d3
		move.w	d3,(a0)+
		move.w	d2,d3
		add.w	d3,d3
		move.w	d3,(a0)+
		move.l	a0,(a1)
	;ustaw rejestry adresowe
		move.l	cir_tabaddr,a2
		lea	cir_width(pc),a5
		lea	cir_height(pc),a6
		tst.w	d2
		bne	cir_d1
		PUNKT	d0,d1
		movem.l	(a7)+,d2-d7/a2-a6
		rts
cir_d1		lea	li_T1(pc),a0
		lea	cir_bwidth(pc),a4
	;parametry poczâtkowe pëtli
		moveq.l	#0,d3			;d3=xp
		move.w	d2,d4			;d4=yp
		moveq.l	#3,d5
		add.w	d2,d2
		sub.w	d2,d5			;d5=par
	;poczâtkowe punkty i linia
		move.w	d1,d6
		add.w	d4,d6
		PUNKT	d0,d6			;x, y+yp
		move.w	d1,d6
		sub.w	d4,d6
		PUNKT	d0,d6			;x, y-yp
		move.w	d0,d6
		sub.w	d4,d6
		move.w	d1,d7
		bsr	Linia			;d6,d7,d2   x-yp, y, 2*r
	;pëtla
cir_do		tst.w	d5			;if( par>=0 )
		bmi	cir_ujemne
		move.w	d3,d6
		sub.w	d4,d6
		add.w	d6,d6
		add.w	#10,d6
		add.w	d6,d5			;par+=((xp-yp)<<2)+10
		subq.w	#1,d4			;yp--
		bra	cir_ifend
cir_ujemne	move.w	d3,d6			;else
		add.w	d6,d6
		addq.w	#6,d6
		add.w	d6,d5			;par+=(xp<<2)+6
cir_ifend	addq.w	#1,d3			;xp++

		move.w	d3,d2
		add.w	d2,d2
		move.w	d0,d6
		sub.w	d3,d6
		move.w	d1,d7
		add.w	d4,d7
		bsr	Linia			;d6,d7,d2   x-xp, y+yp, 2*xp
		move.w	d1,d7
		sub.w	d4,d7
		bsr	Linia			;d6,d7,d2   x-xp, y-yp, 2*xp

		move.w	d4,d2
		add.w	d2,d2
		move.w	d0,d6
		sub.w	d4,d6
		move.w	d1,d7
		add.w	d3,d7
		bsr	Linia			;d6,d7,d2   x-yp, y+xp, 2*yp
		move.w	d1,d7
		sub.w	d3,d7
		bsr	Linia			;d6,d7,d2   x-yp, y-xp, 2*yp

		cmp.w	d3,d4
		bpl	cir_do			;while( xp<yp )
cir_end		movem.l	(a7)+,d2-d7/a2-a6
		rts

;------------------------------------------------------------------------------
;   Procedura kasuje prostokât o szerokoôci d i wysokoôci d+1. Jego lewy-górny
; wierzchoîek znajduje sië w punkcie (x,y). Przy kasowaniu zastosowany jest
; clipping. Z tego wzglëdu naleûy podaê szerokoôê i wysokoôê ekranu. Kasowany
; prostokât jest równany do bajtu.
; WEJÔCIE: d6.w=x
;          d7.w=y
;          d2.w=d
;          a4=adres cir_bwidth
;          a5=adres cir_width
;          a6=adres cir_height
;          a2=adres spod adresu cir_tabaddr
;          a3=adres bitplanu
;------------------------------------------------------------------------------

ClearSquare
		move.w	d2,d1			;operuj na kopii
	;czy nie punkt
		tst.w	d1
		bne	csq_d1
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
		move.w	d6,d7
		lsr.w	#3,d7
		lea	0(a1,d7.w),a1		;adres bajtu
		move.b	#0,(a1)
		bra	csq_end
	;sprawdú czy szerokoôê<1
csq_d1		cmp.w	#1,d1
		blt	csq_niewidoczny
		addq.w	#1,d1
	;sprawdú czy lewy-górny poniûej bitmapy
		cmp.w	(a6),d7
		bge	csq_niewidoczny
	;sprawdú czy lewy-górny nie jest powyûej bitmapy
		tst.w	d7
		bpl	csq_ydodatni
	;sprawdú czy kwadrat powyûej
		neg.w	d7
		sub.w	d1,d7
		bpl	csq_niewidoczny
		move.w	d7,d1
		neg.w	d1
		moveq.l	#0,d7
	;sprawdú czy nie wystaje poniûej bitmapy
csq_ydodatni	move.w	d7,d0
		add.w	d1,d0
		cmp.w	(a6),d0
		ble	csq_sprx
	;wystaje
		sub.w	(a6),d0
		sub.w	d0,d1
csq_sprx
		subq.w	#1,d1
	;w tym momencie d7 i d1 zawierajâ wartoôci po obciëciu niewidocznych

	;co z x
		tst.w	d6
		bmi	csq_xujemny
		beq	csq_xzerowy
		move.w	(a5),d0
		cmp.w	d6,d0
		bls	csq_poprawej
		sub.w	d6,d0
		cmp.w	d2,d0
		bls	csq_tillend
;na ôrodku
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
		move.w	d6,d7
		lsr.w	#3,d7
		lea	0(a1,d7.w),a1		;adres bajtu
	;oblicz szerokoôê paska w bajtach
		moveq.l	#-1,d0
		andi.w	#7,d6			;lewy (poczâtek)
		beq	csq_sd1
		addq.w	#1,d0
		add.w	d6,d2
		subq.w	#8,d2
		bcs	csq_sd2
csq_sd1		move.w	d2,d7			;zaczyna sië równo z bajtem
		lsr.w	#3,d7
		add.w	d7,d0
		andi.w	#$0007,d2		;dopisz prawy koniec
		beq	csq_sd2
		addq.w	#1,d0
		tst.w	d0
		bmi	csq_sd3
	;wyczyôê prostokât
csq_sd2		moveq.l	#0,d6
		move.l	4(a2),d7
csq_sp1		move.l	a1,a0
		move.w	d0,d2
csq_sp2		move.b	d6,(a0)+
		dbf	d2,csq_sp2
		add.l	d7,a1
		dbf	d1,csq_sp1
csq_sd3		rts

csq_xujemny	neg.w	d6
		sub.w	d6,d2
		bls	csq_polewej
csq_xzerowy
		move.w	(a5),d0
		cmp.w	d2,d0
		bls	csq_fullline
;od lewego brzegu do ôrodka
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
	;oblicz szerokoôê paska w bajtach
		move.w	d2,d7
		lsr.w	#3,d7
		andi.w	#7,d2
		beq	csq_lsd1
		addq.w	#1,d7
csq_lsd1	tst.w	d7
		beq	csq_lsd2
		subq.w	#1,d7
	;wyczyôê prostokât
		moveq.l	#0,d6
		move.l	4(a2),d0
csq_lsp1	move.l	a1,a0
		move.w	d7,d2
csq_lsp2	move.b	d6,(a0)+
		dbf	d2,csq_lsp2
		add.l	d0,a1
		dbf	d1,csq_lsp1
csq_lsd2	rts

csq_tillend
;od ôrodka do prawego brzegu
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
		move.w	d6,d7
		lsr.w	#3,d7
		lea	0(a1,d7.w),a1		;adres bajtu
	;oblicz szerokoôê paska w bajtach
		move.w	(a4),d2
		sub.w	d7,d2
		andi.w	#7,d6
		beq	csq_spd1
		addq.w	#1,d2
csq_spd1	tst.w	d2
		beq	csq_spd2
		subq.w	#1,d2
	;wyczyôê prostokât
		moveq.l	#0,d6
		move.l	4(a2),d0
csq_spp1	move.l	a1,a0
		move.w	d2,d7
csq_spp2	move.b	d6,(a0)+
		dbf	d7,csq_spp2
		add.l	d0,a1
		dbf	d1,csq_spp1
csq_spd2	rts

csq_fullline
;od lewego brzegu do prawego brzegu
		lsl.w	#2,d7
		move.l	0(a2,d7.w),d7
		move.l	a3,a1
		adda.l	d7,a1			;adres linii
	;oblicz szerokoôê paska w bajtach
		move.w	(a4),d2
		bmi	csq_fld1
	;wyczyôê prostokât
		moveq.l	#0,d6
		move.l	4(a2),d0
csq_flp1	move.l	a1,a0
		move.w	d2,d7
csq_flp2	move.b	d6,(a0)+
		dbf	d7,csq_flp2
		add.l	d0,a1
		dbf	d1,csq_flp1
csq_fld1	rts

;jeôli linia jest poza ekranem
csq_end
csq_niewidoczny
csq_poprawej
csq_polewej
csq_nad
csq_pod
		rts

;------------------------------------------------------------------------------
;  Procedura usuwajâca narysowane przez _Circle kóîka. Procedura _RemoveCircles
; odôwieûa tablicë.
; WEJÔCIE: a3=adres bitplanu
;------------------------------------------------------------------------------

_RemoveCircles
		movem.l	d2-d4/d6/d7/a2-a6,-(a7)
	;weú odpowiedni adres zapamiëtanych kóîek i odôwieû odpowiedniâ tablicë
		cmpa.l	cir_firstbpl,a3
		beq	rc_d1
		move.l	cir_box2begin,d3		;z second bpl
		move.l	cir_box2ptr,d4
		move.l	cir_box2begin,cir_box2ptr
		bra	rc_d2		
rc_d1		move.l	cir_box1begin,d3		;z first bpl
		move.l	cir_box1ptr,d4
		move.l	cir_box1begin,cir_box1ptr
rc_d2
	;parametry potrzebne dla ClearSquare
		move.l	cir_tabaddr,a2
		lea	cir_width(pc),a5
		lea	cir_height(pc),a6
		lea	cir_bwidth(pc),a4
	;kasuj kwadraty
rc_p1		cmp.l	d3,d4
		beq	rc_d3
		move.l	d3,a1
		move.w	(a1)+,d6
		move.w	(a1)+,d7
		move.w	(a1)+,d2
		move.l	a1,d3
		bsr	ClearSquare
		bra	rc_p1
	;odôwieû tablicë
rc_d3		movem.l	(a7)+,d2-d4/d6/d7/a2-a6
		rts

;------------------------------------------------------------------------------
;  Procedura ustawia na poczâtek tablic wskaúniki do danych o kwadratach do
; skasowania. Procedura _ResetBoxPtrs jest potrzebna przy animowaniu ze ôladem
;------------------------------------------------------------------------------

_ResetBoxPtrs
		move.l	cir_box1begin,cir_box1ptr
		move.l	cir_box2begin,cir_box2ptr
		rts

;------------------------------------------------------------------------------
;  Procedura sprawdza, czy przyciôniëty jest LMB. Zwraca d0.l=1 jeôli tak
; w przeciwnym wypadku d0.l=0
;------------------------------------------------------------------------------

_LMB
		moveq.l	#0,d0
		move.b	$bfe001,d0
		andi.b	#$40,d0
		lsr.b	#6,d0
		bchg.l	#0,d0
		rts

;------------------------------------------------------------------------------
;  Procedura sprawdza, czy przyciôniëty jest RMB. Zwraca d0.l=1 jeôli tak
; w przeciwnym wypadku d0.l=0
;------------------------------------------------------------------------------

_RMB
		moveq.l	#0,d0
		move.w	$dff016,d0
		andi.w	#$400,d0
		rol.w	#6,d0
		bchg.l	#0,d0
		rts

                END