PLEN 80
		PWID 136
****************************
*     Color Hunter  1.2    *
*    1987  Stefan Kemeny   *
****************************

ExecBase    =        4		;Routinen aus
OldOpenLib  = -30 -378		;EXEC-Library
CloseLib    = -30 -384

OpenScreen  = -30 -168		;Routinen aus
CloseScreen = -30 - 36		;INTUITION-Library

LoadRGB4    = -30 -162		;Routinen aus
SetRGB4     = -30 -258		;GRAPHICS-Library
Text        = -30 - 30
Move        = -30 -210
SetAPen     = -30 -312

Anfang:
 bsr.L OpenInt			;Oeffnen der Libraries
 bsr.L OpenGfx
 bsr.L ScreenOpen		;Oeffnen ein HAM-Screens
 bsr.L SetColor			;Setzen der Grundfarben
 bsr.L SetzeAlle		;Aufbau des Screens

Haupt:
 clr.l d0			;Hauptschleife
 clr.l d1
 move.l ScreenHandle,a5		;Einlesen der Maus-
 move.w $10(a5),d1		;koordinaten aus der
 move.w $12(a5),d0		;Handle des Screens

 jsr XAusgabe			;Ausgabe dieser
 jsr YAusgabe			;Koordinaten

 move.l d0,d2
 move.l #$30303030,BitMuster	;Initialisieren einiger
 move.l #$30300000,BitMuster+4	;Speicherstellen

 bsr.L FindeBitMuster		;BitPlane des Pixels
 bsr.L AusgabeMuster		;x=d0,y=d1 ermitteln

SucheGrundFarbe:		;Suchen eines Bit-Musters,
 bsr.L FindeBitMuster		;das eine der 16 Grundfarben
 cmpi.l #16,d6			;anzeigt
 blo.S GrundF
dbra d0,SucheGrundFarbe

GrundF:
 lea.l RGB,a0			;Grundfarbe in d6
 move.b (a0),d7			;wird zur Ausgabe
 add.b d6,d7			;vorbereitet
 move.b d7,(a0)+
 move.b d7,(a0)+
 move.b d7,(a0)
 cmp.l d0,d2			;falls Maus auf Grundfarbe
 beq.S FarbeBestimmt		;kein weiterbearbeiten
GrundF1:
 addq.l #1,d0			;von der Grundfarbe
 bsr.L FindeBitMuster		;ausgehend wird die Farbe
 btst #4,d6			;nach dem HAM-Prinzip
 beq.S Rot			;ermittelt
 btst #5,d6
 beq.S Blau
Gruen:
 andi.l #%1111,d6		;Ausmaskieren der Farbe
 lea.l RGB+1,a0			;setzen des Ergebnisses
 addi.l #48,d6
 move.b d6,(a0)
bra.S GrundF2
Rot:
 andi.l #%1111,d6
 lea.l RGB,a0
 addi.l #48,d6
 move.b d6,(a0)
bra.S GrundF2
Blau:
 andi.l #%1111,d6
 lea.l RGB+2,a0
 addi.l #48,d6
 move.b d6,(a0)
GrundF2:
 cmp.l d0,d2			;naechster Punkt
bne.S GrundF1

FarbeBestimmt:
 bsr.S Hintergrund		;Aendern des Hintergrundes

 move.l #2,d7			;Korrektur
 lea.l RGB,a0			;der Ausgabe
Korrektur:			;in HEX
 move.b (a0),d6
 cmpi.b #58,d6			;falls Zahl
 blo.S KorrekturEnde		;groesser als 9,
 addi.b #7,d6			;als $A-$F darstellen
 move.b d6,(a0)
KorrekturEnde:
 move.b (a0)+,d6
dbra d7,Korrektur

 bsr.L AusgabeRGB		;Farbe liegt nun in
 move.l #$30303030,BitMuster	;ASCII-Form ab #RBG,
 move.l #$30300000,BitMuster+4	;Ausgabe und Neu-
 move.l #$30303000,RGB		;Initialisieren

 btst #10,$dff016		;mit Druck auf rechte
bne.L Haupt			;Maustaste beenden
 andi.b #64,$bfe001
bne.L Haupt

Ende:
 bsr.L ScreenClose		;Schliessen des
 bsr.L CloseGfx			;Screens und der
 bsr.L CloseInt			;Libraries
 move.l #0,d0			;Kein DOS-Error
rts				;Ruecksprung

Hintergrund:
 lea.l RGB,a0			;Der gewaehlte
 move.l (a0),d0			;Farbwert wird
 lsr.l #8,d0			;als Hintergrund-
 move.l d0,d3			;Farbe dargestellt
 andi.l #%1111,d3
 lsr.l #8,d0
 move.l d0,d2
 andi.l #%1111,d2
 lsr.l #8,d0
 move.l d0,d1
 andi.l #%1111,d1
 move.l ViewPort,a0
 move.l #0,d0
 move.l GfxBase,a6		;Setzt Farbe #00 mit
 jsr SetRGB4(a6)		;gewaehltem R,G und B-Teil
rts

FindeBitMuster:			;ermittelt
 movem.l d0-d2,-(sp)		;Bit-Muster
 move.l ScreenHandle,a5		;des Punktes mit
 addi.l #$c0,a5			;den Koordinaten
 move.l #6,d7			;x=d0 und y=d1
 clr.l d6
 lea.l BitMuster+5,a0
FindeBit1:
 movem.l d0/d1,-(sp)		;Offset zu
 move.l (a5)+,a1		;den Addressen
 divu #8,d0			;der BitPlanes
 mulu #40,d1			;errechnen
 add.w d0,d1
 swap d0
 move.b #7,d2
 sub.b d0,d2
 btst d2,(a1,d1)		;pruefen des Bits
beq.S NichtGesetzt
 move.b #49,(a0)		;falls gesetzt,in Speicher
 bset #7,d6			;und d6 setzen
NichtGesetzt:
 lsr #1,d6
 move.b -(a0),d0		;bei der Ausgabe ist das
 movem.l (sp)+,d0/d1		;Muster ab #BitMuster
dbra d7,FindeBit1		;und in d6 zu finden
 movem.l (sp)+,d0-d2
 andi.l #%111111,d6		;nur sechs BitPlanes
rts

AusgabeMuster:
 movem.l d0-d2,-(sp)		;das Muster des Pixels
 move.l GfxBase,a6		;wird als Text
 move.l #10,d0			;auf dem Screen ausgegeben
 move.l RastPort,a1
 jsr SetAPen(a6)		;Farbe hellgrau (#10)
 move.l RastPort,a1
 move.l #18,d0			;ab 18/40
 move.l #40,d1
 jsr Move(a6)			;neun Zeichen
 move.l RastPort,a1		;ausgeben
 lea.l RGBBit,a0
 move.l #9,d0
 jsr Text(a6)

 move.l RastPort,a1		;ausgeben
 move.l #29,d0			;ab 29/61
 move.l #61,d1
 jsr Move(a6)			;sechs Zeichen
 move.l RastPort,a1		;ausgeben
 lea.l BitMuster,a0
 move.l #6,d0
 jsr Text(a6)
 movem.l (sp)+,d0-d2
rts

AusgabeRGB:			;Ausgabe des
 move.l GfxBase,a6		;ermittelten
 move.l #14,d0			;RGB-Wertes
 move.l RastPort,a1
 jsr SetAPen(a6)		;in hellen Farben
 move.l RastPort,a1		;fuer dunklen
 move.l #96,d0			;Hintergrund
 move.l #24,d1
 jsr Move(a6)
 move.l RastPort,a1
 lea.l RGBCol,a0
 move.l #15,d0
 jsr Text(a6)

 move.l #4,d0			;sowie auch dunkel fuer
 move.l RastPort,a1		;hellen Hintergrund
 jsr SetAPen(a6)
 move.l RastPort,a1
 move.l #96,d0
 move.l #36,d1
 jsr Move(a6)
 move.l RastPort,a1
 lea.l RGBCol,a0
 move.l #15,d0
 jsr Text(a6)
rts

XAusgabe:
 movem.l d0/d1,-(sp)		;Ausgabe der
 move.l d0,d1			;X-Koordinate
 lea.l X,a0
 jsr Convert1
 move.l GfxBase,a6
 move.l #12,d0
 move.l RastPort,a1
 jsr SetAPen(a6)
 move.l RastPort,a1
 move.l #233,d0
 move.l #40,d1
 jsr Move(a6)
 move.l RastPort,a1
 lea.l XPos,a0
 move.l #7,d0
 jsr Text(a6)
 movem.l (sp)+,d0/d1
rts

YAusgabe:
 movem.l d0/d1,-(sp)		;Ausgabe der Y-Koordinate
 lea.l Y,a0
 jsr Convert1
 move.l GfxBase,a6
 move.l RastPort,a1
 move.l #233,d0
 move.l #61,d1
 jsr Move(a6)
 move.l RastPort,a1
 lea.l YPos,a0
 move.l #7,d0
 jsr Text(a6)
 movem.l (sp)+,d0/d1
rts

Convert1:			;Routine, um
 move.l #100,d2			;Words in Strings
Convert2:			;zu veraendern
 divu d2,d1
 addi.w #48,d1			;Uebergabe-parameter
 move.b d1,(a0)+		;d1 = Zahl 0-65535
 clr.w d1			;a0 = Start des Strings
 swap d1
 cmp.l #1,d2			;in der Zeile 255 wird statt
 bne.S Convert3			;#100 (fuer 0-999)
rts				;#1000 (fuer 0-9999) oder
Convert3:			;#10000 (fuer 0-65535) eingesetzt
 divu #10,d2			;Die Laenge des Stringfeldes
bra.S Convert2			;sollte 5 betragen

SetzeAlle:
 move.l #103,d0			;Haupt-Routine, um alle
 move.l #43,d1			;4096 Farben zu setzen
 move.l #0,d5
 bsr.S SetzeRGB
 move.l #0,d0
 move.l #76,d1
 move.l #1,d5
Setze1bis5:
 bsr.S SetzeRGB
 addi.l #$20,d1
 addq.l #1,d5
 cmp.l #6,d5
bne.S Setze1bis5
 addi.l #105,d0
 move.l #76,d1
Setze6bis10:
 bsr.S SetzeRGB
 addi.l #$20,d1
 addq.l #1,d5
 cmp.l #11,d5
bne.S Setze6bis10
 addi.l #105,d0
 move.l #76,d1
Setze11bis15:
 bsr.S SetzeRGB
 addi.l #$20,d1
 addq.l #1,d5
 cmp.l #16,d5
bne.S Setze11bis15
rts

SetzeRGB:
 movem.l d0/d1,-(sp)
 move.l #%100000,d6		;Rot,Gruen und Blau-
 move.l #%010000,d7		;Variationen
 bsr.L Vertical			;der selben Grundfarbe
 addi.l #35,d0			;zeichnen
 move.l #%110000,d6
 move.l #%100000,d7
 bsr.L Vertical
 addi.l #35,d0
 move.l #%010000,d6
 move.l #%110000,d7
 bsr.S Vertical
 movem.l (sp)+,d0/d1
rts

GrundLinie:
 movem.l d0-d1/d5,-(sp)		;setzt eine
 move.l d5,d2			;senkrechte Linie
 move.l #15,d5			;mit der Grundfarbe,
GrundLinie1:			;von der ausgehend
 bsr.S GrundLinie2		;die Variationen
 bsr.S GrundLinie2		;aufgebaut werden
dbra d5,GrundLinie1
 movem.l (sp)+,d0-d1/d5
 addq.l #3,d0
 cmpi.l #0,d5
 bne.S GrundNormal
 addq.l #1,d0
GrundNormal:
rts

GrundLinie2:
 movem.l d0-d2/d5,-(sp)		;Unterroutine, um
 bsr.L SetzePunkt		;Senkrechte mit der Grund-
 addq.l #1,d0			;Farbe zu zeichnen
 cmp.l #0,d2
 bne.S Grund4			;falls Grundfarbe=0 (schwarz),
 move.l #%110000,d2		;also Hintergrund-Farbe,
 bsr.L SetzePunkt		;muss die Grundfarbe anders
 addq.l #1,d0			;aufgebaut werden
 move.l #%010000,d2		;(Hintergrund aendert sich ja
 bsr.L SetzePunkt		; staendig...)
 addq.l #1,d0
 move.l #%100000,d2
 bsr.S SetzePunkt
 bra.S Grund3
Grund4:
 clr.l d2			;Teil, um Grundfarben ab 1
 or.l d6,d2			;zu setzen
 bsr.S SetzePunkt
 addq.l #1,d0
 clr.l d2
 or.l d7,d2
 bsr.S SetzePunkt
Grund3:
 movem.l (sp)+,d0-d2/d5
 addq.l #1,d1
rts

Vertical:
 movem.l d0/d1,-(sp)		;diese Routine setzt
 bsr.S GrundLinie		;die Abweichung in
 move.l #%0000,d2		;Richtung Y-Achse
Vertical1:			;und ruft dann
 move.l d2,-(sp)
 or.l d6,d2
 bsr.S SetzeQuadrat
 move.l (sp)+,d2
 bsr.S Horizontal
 addq.l #2,d1
 addq.l #1,d2
 cmpi.b #16,d2
bne.S Vertical1
 movem.l (sp)+,d0/d1
rts

Horizontal:
 movem.l d0-d2,-(sp)		;diese Routine auf,
 addq.l #2,d0			;die von nun schon
 move.l #%0001,d2		;zwei gegebenen Farbteilen
Horizontal1:			;(Grundfarbe, eben
 move.l d2,-(sp)		; gesetzte Y-Verschiebung)
 or.l d7,d2			;ausgehend den
 bsr.S SetzeQuadrat		;dritten Farbteil
 move.l (sp)+,d2		;setzt
 add.l #2,d0
 addq.l #1,d2
 cmpi.b #16,d2
bne.S Horizontal1
 movem.l (sp)+,d0-d2
rts

SetzeQuadrat:			;statt eines
 bsr.S SetzeReihe		;schwer zu treffenden
 addq.l #1,d1			;Pixels
 bsr.S SetzeReihe		;wird ein Quadrat aus 2
 subq.l #1,d1			;mal 2 Pixeln gezeichnet
rts

SetzeReihe:
 bsr.S SetzePunkt		;Unterroutine zu
 addq.l #1,d0			;SetzeQuadrat
 bsr.S SetzePunkt
 subq.l #1,d0
rts

SetzePunkt:
 move.l d2,-(sp)		;diese Routine
 move.l ScreenHandle,a4		;setzt (als Gegenstueck
 addi.l #$c0,a4			;zu FindeBitMuster)
 move.l #6,d3			;einen Punkt
SetzePunkt1:			;bei d0/d1 mit dem
 move.l (a4)+,a5		;Muster d2
 lsr #1,d2
 bcc.S Loeschen
 movem.l d0-d2/a5,-(sp)
 divu #8,d0
 mulu #40,d1
 add.w d0,d1
 swap d0
 move.b #7,d2
 sub.b d0,d2
 bset d2,(a5,d1)
 movem.l (sp)+,d0-d2/a5
Loeschen:
 dbra d3,SetzePunkt1
 move.l (sp)+,d2
rts

SetColor:			;Die Grundfarben
 move.l GfxBase,a6		;werden gesetzt
 move.l ViewPort,a0
 lea.l Color,a1
 move.l #16,d0
 jsr LoadRGB4(a6)
rts

OpenInt:			;Oeffnen von
 move.l ExecBase,a6		;INTUITION
 lea.l IntName,a1
 jsr OldOpenLib(a6)
 move.l d0,IntBase
rts

CloseInt:			;Schliessen von
 move.l ExecBase,a6		;INTUITION
 move.l IntBase,a1
 jsr CloseLib(a6)
rts

OpenGfx:			;GRAPHICS
 move.l ExecBase,a6
 lea.l GfxName,a1
 jsr OldOpenLib(a6)
 move.l d0,GfxBase
rts

CloseGfx:			;GRAPHICS
 move.l ExecBase,a6
 move.l GfxBase,a1
 jsr CloseLib(a6)
rts

ScreenOpen:			;Oeffnen eines
 move.l IntBase,a6		;HAM-Screens,
 lea NewScreen,a0		;Ermitteln
 jsr OpenScreen(a6)		;einiger Port-
 move.l d0,ScreenHandle		;Addressen
 addi.l #44,d0
 move.l d0,ViewPort
 move.l ScreenHandle,a0
 addi.l #84,a0
 move.l a0,RastPort
rts

ScreenClose:
 move.l IntBase,a6		;Schliessen des
 move.l ScreenHandle,a0		;Screens
 jsr CloseScreen(a6)
rts

align 4				;es kommen die Daten...

IntBase:       dc.l 0		;...wie Zeiger
GfxBase:       dc.l 0
ScreenHandle:  dc.l 0
ViewPort:      dc.l 0
RastPort:      dc.l 0

IntName:    dc.b 'intuition.library',0	; oder Strings
GfxName:    dc.b 'graphics.library',0
ScreenName: dc.b "Color-Hunter 1.2   (C) 1988 by S.K.",0

even

NewScreen:			;oder die Screen-
 dc.w 0,0,320,236,6		;Struktur
 dc.b 0,12
 dc.w $800,15			;$800 steht fuer HAM
 dc.l 0,ScreenName,0,0

Color:				;Die Grundfarben (Grauwerte)
 dc.w $0000,$0111,$0222,$0333,$0444,$0555
 dc.w $0666,$0777,$0888,$0999,$0aaa,$0bbb
 dc.w $0ccc,$0ddd,$0eee,$0fff

even

RGBBit:
 dc.b "BitMuster   "
BitMuster:			;und last not least
 dc.b "000000",0,0		;Speicher fuer die
RGBCol:
 dc.b "RGB-Farbe : "
RGB:				;Ausgabe
 dc.b "000",0
XPos:
 dc.b "X : "
X:
 dc.b "000",0
YPos:
 dc.b "Y : "
Y:
 dc.b "000",0