*
* 6569.asm - VIC-Emulation
*
* Copyright (C) 1994-1995 by Christian Bauer
*

*
* Anmerkungen:
* ------------
*
* Funktionsweise/Periodic:
*  - Die VIC-Emulation arbeitet zeilenweise. Pro (simulierter)
*    C64-Rasterzeile wird vom 6510-Task die Routine Periodic6569
*    aufgerufen, die eine Pixelzeile der Grafik anhand der aktuellen
*    Einstellungen in den VIC-Registern aufbaut. Dadurch können
*    Rastereffekte sehr gut emuliert werden.
*  - Die Emulation setzt eine 8-Bit-Chunky-Bitmap voraus und schreibt
*    ihre Grafikdaten direkt dort hinein
*  - Bei der Darstellung über die Amiga-Chips wird direkt in eine
*    Chunky-Bitmap geschrieben, die beim VIC-VBlank in das planare Format
*    konvertiert wird (mit c2p4), bei EGS/Picasso werden die Grafikdaten
*    für eine Zeile in einen Puffer geschrieben, der am Ende der Zeile
*    in den Grafikspeicher der Karte übertragen wird
*  - Für eine sauberere Darstellung verwendet die Emulation Double
*    Buffering. Es wird jeweils in eine unsichtbare Bitmap gezeichnet
*    und bei einem VIC-VBlank werden die Puffer gewechselt.
*  - Die Farbpalette besteht aus den 16 C64-Farben, 16mal wiederholt.
*    Dadurch spart man sich das Ausmaskieren der unteren 4 Bit bei den
*    VIC-Farbcodes. Allerdings muß dieses bei der Chunky->Planar-
*    Konvertierung für die Amiga-Chips erfolgen (der Algorithmus
*    setzt voraus, daß die oberen Nibbles Null sind).
*  - Die Auswahl der 5 verschiedenen Darstellungsmodi (plus 3 ungültige,
*    die einen schwarzen Bildschirm erzeugen) geschieht über den
*    Zeiger DisplayProc, der auf die entsprechende Routine (z.B. TextStd,
*    BitMapMulti etc.) zeigt und der bei einem Schreibzugriff auf eines
*    der beiden Kontrollregister CTRL1/CTRL2 neu gesetzt wird
*
* 6510-Zyklenzähler
*  - In jeder Rasterzeile wird der Zyklenzähler für die CPU neu gesetzt,
*    und zwar unterschiedlich je nachdem, ob eine Bad Line stattfand
*    oder nicht
*  - Für jedes dargestellte Sprite werden nochmal je 2 Zyklen abgezogen
*
* Bad Lines:
*  - Eine Bad Line ist dann, wenn $30 <= RASTER <= $f7 und
*    die unteren drei Bits von RASTER mit den unteren drei Bits von
*    Reg. $11 (Y-Scroll) übereinstimmen
*  - In einer Bad Line werden 40 Bytes aus Videomatrix und Farb-RAM geholt
*
* Rasterzähler RC/Grafikdarstellung:
*  - Der RC wird in jeder Bad Line auf Null gesetzt, gleichzeitig wird
*    die Darstellung der Grafik angeschaltet (DISPLAYOFF wird gelöscht)
*  - Am Ende einer Rasterzeile wird der RC um 1 erhöht, es sei denn,
*    er steht auf 7. In diesem Fall wird die Darstellung ausgeschaltet.
*  - Ist DISPLAYOFF gesetzt, wird in der Textspalte $3fff dargestellt,
*    ansonsten Text oder Bitmapgrafik
*  - Deshalb wird im oberen/unteren Rahmen immer $3fff dargestellt, weil
*    es dort keine Bad Lines gibt und der RC nie zurückgesetzt wird
*
* Videomatrixzähler VC:
*  - Es gibt zwei Register, VCBASE und VCCOUNT. Zum Zugriff auf die
*    Grafikdaten wird VCCOUNT benutzt.
*  - Beim VBlank wird VCBASE auf Null gesetzt
*  - Zu Beginn jeder Zeile wird VCCOUNT mit dem Wert aus VCBASE geladen
*  - Wenn DISPLAYOFF gelöscht ist und Grafik dargestellt wird, wird
*    VCCOUNT um 40 erhöht (symbolisch für die 40 Zugriffe des VIC)
*  - Wenn die Darstellung abgeschaltet wird, weil RC=7 ist (am Ende
*    einer Zeile) wird VCBASE mit dem Wert aus VCCOUNT geladen
*
* Spritedatenzähler MCx/Spritedarstellung:
*  - Da die Spritedaten beim VIC am Ende einer Rasterzeile geholt werden
*    und daher die Y-Positionen der Sprites eins niedriger als die
*    Rasterzeilennummern sind, werden die Spritedatenzähler in der
*    Emulation am Ende einer Rasterzeile gehandhabt (nachdem die Sprites
*    gezeichnet wurden)
*  - Wenn ein Sprite eingeschaltet ist und die Y-Koordinate gleich den
*    unteren 8 Bit von RASTER ist, wird der Datenzähler auf Null gesetzt
*    und die Darstellung des Sprite eingeschaltet (Bit in SPRITEON).
*    Jede folgende Rasterzeile wird der Zähler um 3 erhöht, solange er
*    kleiner als 60 ist. Erreicht er 60, wird die Darstellung des Sprite
*    ausgeschaltet. Wenn das Sprite Y-expandiert ist, wird der Zähler nur
*    in den Zeilen erhöht, in denen die unteren Bits von Y-Koordinate und
*    Zeilennummer gleich sind.
*
* X-Scroll>0 und 40 Spalten:
*  - Wenn der X-Scroll>0 und die 40-Spalten-Darstellung eingeschaltet
*    ist, hängt das, was am linken Bildrand dargestellt wird, vom
*    aktuellen Grafikmodus ab
*  - Im Standard-Text-, Multicolor-Text- und Multicolor-Bitmap-Modus wird
*    dort die Hintergrundfarbe aus Reg.$21 dargestellt
*  - Im Standard-Bitmap- und ECM-Text-Modus wird die Hintergrundfarbe
*    der letzten 8 Pixel der vorherigen Zeile dargestellt
*
* Inkompatibilitäten:
*  - Effekte, die durch die Änderung von VIC-Registern innerhalb einer
*    Rasterzeile erreicht werden, können nicht emuliert werden
*  - Keine Sprite-Grafik-Priorität
*  - Keine Sprite-Hintergrund-Kollisionen
*  - Sprite-Sprite-Kollisionen werden nur innerhalb des sichtbaren
*    Bereiches erkannt
*  - X-expandierte Sprites mit X-Koordinaten >=$140 werden nicht angezeigt.
*    Genaugenommen sollte ein Sprite nur dann unsichtbar sein, wenn die
*    X-Koordinate zwischen $1f8 und $1ff liegt.
*  - In den Bitmap-Darstellungen ab den Adressen $0000 und $8000 sollte
*    eigentlich ab $1000/$9000 das Char-ROM sichtbar sein. Aus
*    Geschwindigkeitsgründen wird in der Emulation das RAM darunter
*    dargestellt. Dies sollte keine Rolle spielen, da diese Bitmap-Seiten
*    aus dem genannten Grund von keinem Programm komplett verwendet werden.
*  - Der IRQ wird bei jedem Schreibzugriff in das Flag-Register gelöscht.
*    Das ist ein Hack für die RMW-Befehle des 6510, die zuerst den
*    Originalwert schreiben.
*
* Verbesserungen:
*  - Amiga VBlank sollte Double Buffering verwenden
*

		MACHINE	68020

		INCLUDE	"exec/types.i"
		INCLUDE	"exec/macros.i"
		INCLUDE	"exec/memory.i"
		INCLUDE	"intuition/intuition.i"
		INCLUDE	"graphics/displayinfo.i"
		INCLUDE	"egs/egs.i"
		INCLUDE	"devices/inputevent.i"

		XREF	_SysBase	;Main.asm
		XREF	_GfxBase
		XREF	_IntuitionBase
		XREF	_EGSBase
		XREF	_VilIntuiBase

		XREF	TheRAM		;6510.asm
		XREF	TheChar
		XREF	TheColor
		XREF	IntIsVICIRQ
		XREF	CyclesLeft
		XREF	DontPause
		XREF	CPUTask
		XREF	Peri6569Cont

		XREF	CountTODs	;6526.asm
		XREF	KeyPressed

		XREF	_c2p4		;c2p4.asm
		XREF	Initc2p4
		XREF	Exitc2p4

		XDEF	OpenGraphics
		XDEF	CloseGraphics
		XDEF	AmigaToFront
		XDEF	EmulToFront
		XDEF	WaitForClick
		XDEF	ChangedVA
		XDEF	Init6569
		XDEF	Exit6569
		XDEF	ReadFrom6569
		XDEF	WriteTo6569
		XDEF	Periodic6569

		XDEF	DisplayID	;Prefs
		XDEF	ScreenType	;Prefs
		XDEF	NormalCycles	;Prefs
		XDEF	BadLineCycles	;Prefs

		SECTION	"CODE",CODE


**
** Definitionen
**

; VIC-Register
M0X		= $00	;Position von Sprite 0
M0Y		= $01
M1X		= $02	;Position von Sprite 1
M1Y		= $03
M2X		= $04	;Position von Sprite 2
M2Y		= $05
M3X		= $06	;Position von Sprite 3
M3Y		= $07
M4X		= $08	;Position von Sprite 4
M4Y		= $09
M5X		= $0a	;Position von Sprite 5
M5Y		= $0b
M6X		= $0c	;Position von Sprite 6
M6Y		= $0d
M7X		= $0e	;Position von Sprite 7
M7Y		= $0f
MX8		= $10	;Höchste Bits der Sprite X-Positionen
CTRL1		= $11	;Steuerreg. 1
RASTER		= $12	;Rasterzähler
SPREN		= $15	;Sprite eingeschaltet
CTRL2		= $16	;Steuerreg. 2
MYE		= $17	;Sprite Y-Expansion
VBASE		= $18	;Basisadressen
IRQFLAG		= $19	;Interruptreg.
IRQMASK		= $1a
MMC		= $1c	;Sprite Multicolor
MXE		= $1d	;Sprite X-Expansion
CLXSPR		= $1e	;Kollisionsreg.
CLXBGR		= $1f

; Zusätzliche Register
DISPLAYOFF	= $2f	;Flag: $3fff wird dargestellt
IRQRASTER	= $30	;Rasterzeile, bei der ein IRQ ausgelöst wird (Wort)
XSCROLL		= $32	;X-Scroll-Wert (Wort)
YSCROLL		= $34	;Y-Scroll-Wert (Wort)
DXSTART		= $36	;Aktuelle Werte des Randbereichs
DXSTOP		= $38
DYSTART		= $3a
DYSTOP		= $3c
RC		= $3e	;Rasterzähler RC
MATRIXBASE	= $40	;Videomatrix-Basis (Amiga-Adresse)
CHARBASE	= $44	;Zeichengenerator-Basis (Amiga-Adresse)
BITMAPBASE	= $48	;Bitmap-Basis (Amiga-Adresse)
CURRENTA5	= $4c	;Augenblicklicher Zeiger im Bildschirmspeicher
			;Speicher für a5 zwischen Aufrufen von Periodic6569
CURRENTRASTER	= $50	;Augenblickliche Rasterzeile
			;Speicher für d7 zwischen Aufrufen von Periodic6569
LASTBKGD	= $52	;Letzte dargestellte Hintergrundfarbe
SPRITEON	= $53	;Sprite wird dargestellt, pro Sprite ein Bit
BORDERON	= $54	;Flag: Oberer/unterer Rahmen wird dargestellt
IS38COL		= $55	;Flag: 38 Spalten
SCREENOFF	= $56	;Flag: Bildschirm ist abgeschaltet, nur Rahmen darstellen
			;Bei jedem VBlank wird Bit 4 in $D011 getestet und
			; dieses Flag entsprechend gesetzt
MC0		= $58	;Spritedatenzähler 0
MC1		= $5a
MC2		= $5c
MC3		= $5e
MC4		= $60
MC5		= $62
MC6		= $64
MC7		= $66	;Spritedatenzähler 7
VCBASE		= $68	;VC-Zwischenspeicher
VCCOUNT		= $6a	;VC-Zähler

; Anzahl Rasterzeilen
TotalRasters	= $138

; Textfenster-Koordinaten (Stop-Werte sind immer eins mehr)
Row25YStart	= $33
Row25YStop	= $fb
Row24YStart	= $37
Row24YStop	= $f7

Col40XStart	= $18
Col40XStop	= $158
Col38XStart	= $1f
Col38XStop	= $14f

; Erste und letzte mögliche Zeile für Bad Lines
FirstDMALine	= $30
LastDMALine	= $f7

; Erste und letzte dargestellte Zeile
FirstDispLine	= $10
LastDispLine	= $11f	;eigentlich $12b

; Größe der Anzeige
DisplayX	= $170
DisplayY	= LastDispLine-FirstDispLine+1

; ScreenTypes
STYP_EGS	= 0
STYP_PICASSO	= 1
STYP_AMIGA	= 2

; EGS
E_OpenScreen	= -30
E_CloseScreen	= -36
E_ScreenToFront	= -60
E_ScreenToBack	= -66
E_ActivateEGSScreen = -72
E_ActivateAmigaScreen = -78
E_SetRGB8	= -84
E_DisposeBitMap	= -132
E_FlipMap	= -168
E_AllocBitMap	= -198

; Village
OpenVillageScreen = -30
CloseVillageScreen = -36
LockVillageScreen = -42
UnLockVillageScreen = -48
OpenVillageScreenTagList = -114
VillageGetBufAddr = -126
VillageSetDisplayBuf = -132

TAVIS_FIRSTITEM	= TAG_USER+4711
TAVIS_DOUBLE_BUFFER = TAVIS_FIRSTITEM+40
TAVIS_DM_STRUCT	= TAVIS_FIRSTITEM+41


*
* Makros
*

; Aus einer VIC-16-Bit-Adresse die entsprechende Amiga-Adresse berechnen
; -> d0.w: 16-Bit-Adresse
; <- a0.l: 32-Bit-Adresse
GetPhysical	MACRO
		or.w	CiaVABase(pc),d0 ;VA14/15 dazunehmen
		move.w	d0,d1
		and.w	#$7000,d1
		cmp.w	#$1000,d1
		beq	\@1$
		move.l	TheRAM(pc),a0
		moveq	#0,d1
		move.w	d0,d1
		add.l	d1,a0
		bra	\@2$
\@1$		and.w	#$0fff,d0	;$1000-$1fff, $9000-$9fff: Char-ROM
		move.l	TheChar(pc),a0
		add.w	d0,a0
\@2$
		ENDM

; Sprite darstellen
DoSprite	MACRO	;Nummer
		move.b	$27+\1(a4),d2
		lsl.w	#8,d2
		move.b	$27+\1(a4),d2	;d2: Spritefarbe
		move.w	MC\1(a4),d5	;d5: Datenzähler
		moveq	#\1,d6		;d6: Spritenummer
		move.l	MATRIXBASE(a4),a0
		move.b	$03f8+\1(a0),d7	;d7: Datenzeiger
		lea	M\1X(a4),a2	;a2: Zeiger auf X-Koordinate
		bsr	DrawSprite
		ENDM


**
** Bildschirm öffnen
** Rückgabe: d0=0 Alles OK
**           d0=1 Fehler beim Screen-Öffnen
**           d0=2 Kein Speicher
**           d0=3 Kein EGS
**           d0=4 Kein VilIntuiSup
**           d0=5 Probleme mit DisplayID
**           d0=6 Screen zu klein (min. 384×288)
**

; Kollisionsflag-Tabelle berechnen
OpenGraphics	lea	SprCollTab,a0	;Vorgabe: Kollision
		moveq	#256/4-1,d0
1$		move.l	#-1,(a0)+
		dbra	d0,1$

		lea	SprCollTab,a0	;Keine Kollision bei nur einem Sprite
		clr.w	(a0)
		clr.b	2(a0)
		clr.b	4(a0)
		clr.b	8(a0)
		clr.b	16(a0)
		clr.b	32(a0)
		clr.b	64(a0)
		clr.b	128(a0)

; Name des ScreenMode holen
		move.l	_GfxBase,a6
		sub.l	a0,a0
		lea	ModeNameBuf,a1
		moveq	#nif_SIZEOF,d0
		move.l	#DTAG_NAME,d1
		move.l	DisplayID,d2
		JSRLIB	GetDisplayInfoData
		tst.l	d0
		beq	NoDisplayID

; Register vorbereiten
		lea	Registers,a0
		move.w	#7,RC(a0)
		move.w	#-1,CURRENTRASTER(a0)
		move.l	TheRAM,MATRIXBASE(a0)
		move.l	TheRAM,CHARBASE(a0)
		move.l	TheRAM,BITMAPBASE(a0)
		clr.w	CiaVABase
		move.l	#TextStd,DisplayProc

; Screen-Typ auswerten (Amiga)
		cmp.w	#STYP_AMIGA,ScreenType
		beq	OpenAmiga

; EGS/Picasso: Dimensionen holen und prüfen, ob ausreichend
		move.l	_IntuitionBase,a6
		move.l	DisplayID,a0
		lea	TheRect,a1
		moveq	#OSCAN_TEXT,d0
		JSRLIB	QueryOverscan
		tst.l	d0
		beq	NoDisplayID

		lea	TheRect,a0
		move.w	ra_MaxX(a0),d0
		sub.w	ra_MinX(a0),d0
		addq.w	#1,d0
		move.w	d0,ScreenX
		move.w	ra_MaxY(a0),d0
		sub.w	ra_MinY(a0),d0
		addq.w	#1,d0
		move.w	d0,ScreenY

		cmp.w	#384,ScreenX
		blo	TooSmall
		cmp.w	#288,ScreenY
		blo	TooSmall

; Screen-Typ auswerten (EGS/Picasso)
		cmp.w	#STYP_EGS,ScreenType
		beq	OpenEGS
		bra	OpenPicasso

*
* Amiga-Screen öffnen
*

; Screen öffnen
OpenAmiga	move.w	#$180,d0		;Vielfaches von 32 (wegen c2p)
		move.w	d0,ScreenX
		move.w	d0,WindowWidth+2
		move.w	#DisplayY,d0
		move.w	d0,ScreenY
		move.w	d0,WindowHeight+2
		move.l	DisplayID,ScreenDID

		bsr	Initc2p4
		tst.l	d0
		beq	NoMem

		move.l	_IntuitionBase,a6
		sub.l	a0,a0
		lea	ScreenTags,a1
		JSRLIB	OpenScreenTagList
		move.l	d0,TheScreen
		beq	NoScreen
		move.l	d0,WindowScreen

		move.l	TheScreen,a0
		lea	sc_RastPort(a0),a1
		move.l	a1,TheRastPort
		lea	sc_ViewPort(a0),a1
		move.l	a1,TheViewPort

; Speicher für Chunky-BitMap und Comparison Buffer holen
		move.l	_SysBase,a6
		move.w	ScreenX,d0
		mulu.w	#DisplayY,d0
		add.l	d0,d0
		move.l	#MEMF_PUBLIC|MEMF_CLEAR,d1
		JSRLIB	AllocVec
		move.l	d0,InvisibleMap
		beq	NoMem
		move.w	ScreenX,d1
		mulu.w	#DisplayY,d1
		add.l	d1,d0
		move.l	d0,ComparisonBuf

; Fenster öffnen
		move.l	_IntuitionBase,a6
		sub.l	a0,a0
		lea	WindowTags,a1
		JSRLIB	OpenWindowTagList
		move.l	d0,TheWindow
		beq	NoMem

		move.l	TheWindow,a0
		move.l	wd_UserPort(a0),WindowPort

; Farbpalette laden
		move.l	_GfxBase,a6
		moveq	#0,d7		;Registerzähler
		lea	Palette,a2
1$		move.b	d7,d0
		and.w	#$0f,d0
		lea	(a2,d0.w*4),a0
		moveq	#0,d1
		move.b	(a0)+,d1
		lsr.b	#4,d1
		moveq	#0,d2
		move.b	(a0)+,d2
		lsr.b	#4,d2
		moveq	#0,d3
		move.b	(a0)+,d3
		lsr.b	#4,d3
		move.l	d7,d0
		move.l	TheViewPort,a0
		JSRLIB	SetRGB4
		addq.b	#1,d7
		cmp.b	#16,d7		;Hier nur 16 Register
		bne	1$

; Adresse des Bildschirmspeichers setzen
		move.l	InvisibleMap,Registers+CURRENTA5
		clr.w	MustWaitForC2P

; VBlank-Routine setzen
		move.l	#AmigaVBlank,VBlankProc

		moveq	#0,d0
		rts

*
* Picasso-Screen öffnen
*

; VilIntuiSup vorhanden?
OpenPicasso	tst.l	_VilIntuiBase
		beq	NoVilIntuiSup

; Screen öffnen
		move.w	ScreenX,WindowWidth+2
		move.w	ScreenY,WindowHeight+2

		move.l	_VilIntuiBase,a6
		lea	Dimensions,a0
		move.w	ScreenX,4(a0)
		move.w	ScreenY,6(a0)
		lea	VilTags,a0
		jsr	OpenVillageScreenTagList(a6)
		move.l	d0,TheScreen
		beq	NoScreen
		move.l	d0,WindowScreen

		move.l	TheScreen,a0
		lea	sc_ViewPort(a0),a1
		move.l	a1,TheViewPort

; Fenster öffnen
		move.l	_IntuitionBase,a6
		sub.l	a0,a0
		lea	WindowTags,a1
		JSRLIB	OpenWindowTagList
		move.l	d0,TheWindow
		beq	NoMem

		move.l	TheWindow,a0
		move.l	wd_UserPort(a0),WindowPort

; Farbpalette laden
		move.l	_GfxBase,a6
		moveq	#0,d7		;Registerzähler
		lea	Palette,a2
1$		move.b	d7,d0
		and.w	#$0f,d0
		lea	(a2,d0.w*4),a0
		moveq	#0,d1
		move.b	(a0)+,d1
		moveq	#0,d2
		move.b	(a0)+,d2
		moveq	#0,d3
		move.b	(a0)+,d3
		move.l	d7,d0
		move.l	TheViewPort,a0
		JSRLIB	SetRGB4
		addq.b	#1,d7
		bne	1$

; Adresse des Bildschirmspeichers setzen
		move.l	#1,InvBufNum		;Adresse des zweiten Puffers holen
		move.l	_VilIntuiBase,a6
		move.l	TheScreen,a0
		jsr	LockVillageScreen(a6)
		move.l	TheScreen,a0
		move.l	InvBufNum,d0
		jsr	VillageGetBufAddr(a6)
		move.l	d0,Registers+CURRENTA5

; VBlank-Routine setzen
		move.l	#PicassoVBlank,VBlankProc

		moveq	#0,d0
		rts

*
* EGS-Screen öffnen
*

; EGS vorhanden?
OpenEGS		tst.l	_EGSBase
		beq	NoEGS

; Screen öffnen
		move.l	_EGSBase,a6
		lea	NewEScreen,a0
		jsr	E_OpenScreen(a6)
		move.l	d0,TheScreen
		beq	NoScreen

		move.l	TheScreen,a0
		move.l	esc_Port(a0),EGSPort

; Zweite Bitmap für Double Buffering holen
		moveq	#0,d0
		move.w	ScreenX,d0
		moveq	#0,d1
		move.w	ScreenY,d1
		moveq	#8,d2
		moveq	#0,d3
		move.l	#E_EB_DISPLAYABLE|E_EB_CLEARMAP,d4
		move.l	TheScreen,a0
		move.l	esc_Map(a0),a0
		jsr	E_AllocBitMap(a6)
		move.l	d0,InvisibleMap
		beq	NoMem

; Farbpalette laden
		moveq	#0,d7		;Registerzähler
		lea	Palette,a2
1$		move.b	d7,d0
		and.w	#$0f,d0
		lea	(a2,d0.w*4),a0
		moveq	#0,d1
		move.b	(a0)+,d1
		moveq	#0,d2
		move.b	(a0)+,d2
		moveq	#0,d3
		move.b	(a0)+,d3
		move.l	d7,d0
		move.l	TheScreen,a0
		jsr	E_SetRGB8(a6)
		addq.b	#1,d7
		bne	1$

; Adresse des Bildschirmspeichers setzen
		move.l	InvisibleMap,a1
		addq.b	#1,ebm_Lock(a1)
		move.l	ebm_Dest(a1),Registers+CURRENTA5

; VBlank-Routine setzen
		move.l	#EGSVBlank,VBlankProc

		moveq	#0,d0
		rts

; Fehler aufgetreten
NoScreen	moveq	#1,d0
		rts
NoMem		moveq	#2,d0
		rts
NoEGS		moveq	#3,d0
		rts
NoVilIntuiSup	moveq	#4,d0
		rts
NoDisplayID	moveq	#5,d0
		rts
TooSmall	moveq	#6,d0
		rts


**
** Bildschirm schließen
**

CloseGraphics	cmp.w	#STYP_EGS,ScreenType
		beq	CloseEGS
		cmp.w	#STYP_PICASSO,ScreenType
		beq	ClosePicasso

; Amiga
CloseAmiga	move.l	_IntuitionBase,a6
		move.l	TheWindow,d0
		beq	1$
		move.l	d0,a0
		JSRLIB	CloseWindow

1$		move.l	TheScreen,d0
		beq	2$
		move.l	d0,a0
		JSRLIB	CloseScreen

2$		move.l	InvisibleMap,d0
		beq	3$
		move.l	_SysBase,a6
		move.l	d0,a1
		JSRLIB	FreeVec

3$		bsr	Exitc2p4

		rts

; Picasso
ClosePicasso	move.l	_IntuitionBase,a6
		move.l	TheWindow,d0
		beq	1$
		move.l	d0,a0
		JSRLIB	CloseWindow

1$		move.l	_VilIntuiBase,a6
		move.l	TheScreen,d0
		beq	2$
		move.l	d0,a0
		jsr	UnLockVillageScreen(a6)
		move.l	TheScreen,a0
		jsr	CloseVillageScreen(a6)

2$		rts

; EGS
CloseEGS	move.l	_EGSBase,a6
		move.l	TheScreen,d0
		beq	1$
		move.l	d0,a0
		jsr	E_CloseScreen(a6)

1$		move.l	InvisibleMap,d0
		beq	2$
		move.l	d0,a0
		subq.b	#1,ebm_Lock(a0)
		jsr	E_DisposeBitMap(a6)

2$		rts


**
** Amiga-Anzeige nach vorne
**

AmigaToFront	cmp.w	#STYP_EGS,ScreenType
		beq	ATFEGS

; Amiga/Picasso
		move.l	a6,-(sp)
		move.l	_IntuitionBase,a6
		move.l	TheScreen,a0
		JSRLIB	ScreenToBack
		move.l	(sp)+,a6
		rts

; EGS
ATFEGS		move.l	a6,-(sp)
		move.l	_EGSBase,a6
		jsr	E_ActivateAmigaScreen(a6)
		move.l	TheScreen,a0
		jsr	E_ScreenToBack(a6)
		move.l	(sp)+,a6
		rts


**
** Emulator-Anzeige nach vorne
**

EmulToFront	cmp.w	#STYP_EGS,ScreenType
		beq	ETFEGS

; Amiga/Picasso
		move.l	a6,-(sp)
		move.l	_IntuitionBase,a6
		move.l	TheScreen,a0
		JSRLIB	ScreenToFront
		move.l	(sp)+,a6
		rts

; EGS
ETFEGS		move.l	a6,-(sp)
		move.l	_EGSBase,a6
		jsr	E_ActivateEGSScreen(a6)
		move.l	TheScreen,a0
		jsr	E_ScreenToFront(a6)
		move.l	(sp)+,a6
		rts


**
** Auf rechten Mausklick warten, Tastatur handhaben
**

WaitForClick	cmp.w	#STYP_EGS,ScreenType
		beq	WFCEGS

; Amiga/Picasso
WFCAmiga	move.l	_SysBase,a6
		move.l	WindowPort,a0
		JSRLIB	WaitPort

		move.l	WindowPort,a0
		JSRLIB	GetMsg
		tst.l	d0
		beq	WFCAmiga
		move.l	d0,a1
		move.l	20(a1),d2	;d2: Class
		move.w	24(a1),d3	;d3: Code
		move.l	32(a1),d4	;d4: MouseXY
		move.w	26(a1),d5	;d5: Qualifier
		JSRLIB	ReplyMsg

; Klasse auswerten
		cmp.l	#IDCMP_MOUSEBUTTONS,d2
		bne	1$
		cmp.w	#IECODE_RBUTTON,d3 ;Rechte Maustaste: Beenden
		beq	WFCDone
		bra	WFCAmiga

1$		cmp.l	#IDCMP_RAWKEY,d2
		bne	WFCAmiga
		move.b	d3,d0
		bsr	KeyPressed	;Tastaturabfrage
		bra	WFCAmiga

; EGS
WFCEGS		move.l	_SysBase,a6
		move.l	EGSPort,a0
		JSRLIB	WaitPort

		move.l	EGSPort,a0
		JSRLIB	GetMsg
		tst.l	d0
		beq	WFCEGS
		move.l	d0,a1
		move.l	20(a1),d2	;d2: Class
		move.w	24(a1),d3	;d3: Code
		move.l	32(a1),d4	;d4: MouseXY
		move.w	26(a1),d5	;d5: Qualifier
		JSRLIB	ReplyMsg

; Klasse auswerten
		cmp.w	#E_eMOUSEBUTTONS,d2
		bne	1$
		cmp.w	#IECODE_RBUTTON,d3 ;Rechte Maustaste: Beenden
		beq	WFCDone
		bra	WFCEGS

1$		cmp.w	#E_eRAWKEY,d2
		bne	WFCEGS
		move.b	d3,d0
		bsr	KeyPressed	;Tastaturabfrage
		bra	WFCEGS

; Beenden
WFCDone		rts


**
** CIA-VA14/15 hat sich geändert, Video-Bank wechseln
** d0.b: Neue VA ($00-$03)
**

ChangedVA	lea	Registers,a0	;Wichtig für WrVBASE
		clr.w	d1		;VABase speichern
		move.b	d0,d1
		ror.w	#2,d1
		move.w	d1,CiaVABase

		move.b	VBASE(a0),d1 ;Zeiger neu berechnen
		bra	WrVBASE


**
** Initialisierung vom 6510-Task aus
**

; Signal für c2p4 holen
Init6569	move.l	_SysBase,a6
		moveq	#-1,d0
		JSRLIB	AllocSignal
		move.b	d0,GfxSig
		moveq	#0,d1
		bset	d0,d1
		move.l	d1,GfxSet
		rts


**
** Aufräumen vom 6510-Task aus
**

; Ggf. auf Signal von c2p4 warten
Exit6569	tst.w	MustWaitForC2P
		beq	1$
		move.l	_SysBase,a6
		move.l	GfxSet,d0
		JSRLIB	Wait
1$		rts


**
** Aus einem VIC-Register lesen
** d0.w: Registernummer ($00-$3f)
** Rückgabe: d0.b: Byte
**
** Darf das obere Wort von d0 und d1 nicht verändern!
** Darf a1 nicht verändern!
**

ReadFrom6569	move.l	ReadTab(pc,d0.w*4),a0
		jmp	(a0)

		CNOP	0,4
ReadTab		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal

		dc.l	RdNormal
		dc.l	RdCTRL1
		dc.l	RdRASTER
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdCTRL2
		dc.l	RdNormal
		dc.l	RdVBASE
		dc.l	RdIRQFLAG
		dc.l	RdIRQMASK
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdNormal
		dc.l	RdCLXSPR
		dc.l	RdCLXBGR

		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdColor
		dc.l	RdUndef

		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef
		dc.l	RdUndef

RdNormal	lea	Registers,a0
		move.b	(a0,d0.w),d0
		rts

RdColor		lea	Registers,a0
		move.b	(a0,d0.w),d0		;Bei den Farbregistern
		or.b	#$f0,d0			;das obere Nibble setzen
		rts

RdUndef		move.b	#$ff,d0			;Nicht existierendes Register
		rts

RdCTRL1		lea	Registers,a0
		move.b	CTRL1(a0),d0
		and.b	#$7f,d0
		move.b	CURRENTRASTER(a0),d1	;MSB des Rasterzählers lesen
		and.b	#$01,d1
		ror.b	#1,d1
		or.b	d1,d0			;und dazunehmen
		rts

RdRASTER	move.b	Registers+CURRENTRASTER+1,d0 ;Rasterzähler lesen
		rts

RdCTRL2		move.b	Registers+CTRL2,d0
		or.b	#$c0,d0			;Unbenutzte Bits auf 1
		rts

RdVBASE		move.b	Registers+VBASE,d0
		or.b	#$01,d0			;Unbenutzte Bits auf 1
		rts

RdIRQFLAG	move.b	Registers+IRQFLAG,d0
		or.b	#$70,d0			;Unbenutzte Bits auf 1
		rts

RdIRQMASK	move.b	Registers+IRQMASK,d0
		or.b	#$f0,d0			;Unbenutzte Bits auf 1
		rts

RdCLXSPR	lea	Registers+CLXSPR,a0
		move.b	(a0),d0			;Lesen und löschen
		clr.b	(a0)
		rts

RdCLXBGR	lea	Registers+CLXBGR,a0
		move.b	(a0),d0			;Lesen und löschen
		clr.b	(a0)
		rts


**
** In ein VIC-Register schreiben
** d0.w: Registernummer ($00-$3f)
** d1.b: Byte
**
** Darf das obere Wort von d0 und d1 nicht verändern!
**

WriteTo6569	lea	Registers,a0
		move.l	WriteTab(pc,d0.w*4),a1
		jmp	(a1)

		CNOP	0,4
WriteTab	dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal

		dc.l	WrNormal
		dc.l	WrCTRL1
		dc.l	WrRASTER
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrCTRL2
		dc.l	WrNormal
		dc.l	WrVBASE
		dc.l	WrIRQFLAG
		dc.l	WrIRQMASK
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrUndef
		dc.l	WrUndef

		dc.l	WrColor
		dc.l	WrColor
		dc.l	WrColor
		dc.l	WrColor
		dc.l	WrColor
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrNormal
		dc.l	WrUndef

		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef
		dc.l	WrUndef

WrColor		and.b	#$0f,d1
WrNormal	move.b	d1,(a0,d0.w)
WrUndef		rts

WrCTRL1		move.b	d1,CTRL1(a0)
		move.b	d1,d0
		and.w	#7,d0
		move.w	d0,YSCROLL(a0)
		move.b	d1,d0		;MSB Raster
		and.b	#$80,d0
		rol.b	#1,d0
		move.b	d0,IRQRASTER(a0)
		btst	#3,d1		;24/25 Zeilen
		beq	1$
		move.w	#Row25YStart,DYSTART(a0)
		move.w	#Row25YStop,DYSTOP(a0)
		bra	SetDispProc
1$		move.w	#Row24YStart,DYSTART(a0)
		move.w	#Row24YStop,DYSTOP(a0)
		bra	SetDispProc

WrRASTER	move.b	d1,IRQRASTER+1(a0)
		rts

WrCTRL2		move.b	d1,CTRL2(a0)
		move.b	d1,d0
		and.w	#7,d0
		move.w	d0,XSCROLL(a0)
		btst	#3,d1		;38/40 Zeilen
		beq	1$
		clr.b	IS38COL(a0)
		move.w	#Col40XStart,DXSTART(a0)
		move.w	#Col40XStop,DXSTOP(a0)
		bra	SetDispProc
1$		st.b	IS38COL(a0)
		move.w	#Col38XStart,DXSTART(a0)
		move.w	#Col38XStop,DXSTOP(a0)
		bra	SetDispProc

SetDispProc	moveq	#0,d0		;ECM, BMM und MCM holen
		move.b	CTRL1(a0),d0
		and.b	#$60,d0
		move.b	CTRL2(a0),d1
		and.b	#$10,d1
		or.b	d1,d0
		lsr.b	#2,d0		;Als Index in DispProcTab benutzen
		move.l	(DispProcTab,pc,d0.w),DisplayProc
		rts

WrVBASE		move.l	a0,a1		;a1: Zeiger auf Register
		move.b	d1,VBASE(a1)

		move.w	d1,-(sp)
		move.b	d1,d0		;Videomatrixbasis berechnen
		and.w	#$f0,d0
		lsl.w	#6,d0
		GetPhysical
		move.l	a0,MATRIXBASE(a1)
		move.w	(sp),d1		;Nur lesen, nicht entfernen

		move.b	d1,d0		;Zeichengeneratorbasis berechnen
		and.w	#$0e,d0
		ror.w	#6,d0
		GetPhysical
		move.l	a0,CHARBASE(a1)
		move.w	(sp)+,d1

		move.b	d1,d0
		and.w	#$08,d0
		ror.w	#6,d0
		GetPhysical
		move.l	a0,BITMAPBASE(a1)
		rts

WrIRQFLAG	not.b	d1		;Gesetztes Bit: Flag löschen
		and.b	#$0f,d1
		move.b	IRQFLAG(a0),d0
		and.b	d1,d0

		clr.b	IntIsVICIRQ	;IRQ zurücknehmen

		move.b	d0,d1		;Erlaubter IRQ noch gesetzt?
		and.b	IRQMASK(a0),d1
		beq	1$
		or.b	#$80,d0		;Ja, Master-Bit setzen
1$		move.b	d0,IRQFLAG(a0)
		rts

WrIRQMASK	and.b	#$0f,d1
		move.b	d1,IRQMASK(a0)
		rts


**
** Eine Rasterzeile des VIC ausführen
**
** d7: Rasterzeilenzähler
** a4: Zeiger auf VIC-Register
** a5: Zeiger auf das Ziel im Bildschirmspeicher
**

; VBlank: Zähler zurücksetzen und Bitmap wechseln
VICVBlank	move.w	#-1,CURRENTRASTER(a4)
		clr.w	VCBASE(a4)

		btst	#4,CTRL1(a4)		;Bildschirm abschalten, wenn DEN gelöscht
		bne	1$
		st.b	SCREENOFF(a4)
		bra	2$
1$		clr.b	SCREENOFF(a4)
2$
		bsr	CountTODs		;TODs zählen

		move.l	VBlankProc,a0
		jmp	(a0)

; EGS: BitMap wechseln (Double Buffering)
EGSVBlank	move.w	#-1,DontPause		;Nicht hier anhalten
		move.l	a6,-(sp)
		move.l	_EGSBase(pc),a6		;Vorher unsichtbare Bitmap

		move.l	TheScreen,a0		;darstellen
		move.l	InvisibleMap,a1
		subq.b	#1,ebm_Lock(a1)
		jsr	E_FlipMap(a6)
		move.l	d0,InvisibleMap		;In alte Bitmap ab jetzt zeichnen

		move.l	d0,a0			;Adresse ermitteln
		addq.b	#1,ebm_Lock(a0)
		move.l	ebm_Dest(a0),CURRENTA5(a4)

		move.l	(sp)+,a6
		clr.w	DontPause		;Darf wieder angehalten werden
		bra	Periodic6569

; Amiga: Chunky-BitMap in Planar konvertieren
AmigaVBlank	move.w	#-1,DontPause		;Nicht hier anhalten
		movem.l	a4-a6,-(sp)

		tst.w	MustWaitForC2P(pc)	;Ggf. erst auf c2p4 warten
		beq	1$
		move.l	_SysBase,a6
		move.l	GfxSet,d0
		JSRLIB	Wait

1$		move.l	InvisibleMap,a2		;Neue Konvertierung starten
		move.l	ComparisonBuf,a3
		move.l	TheRastPort,a4
		move.l	rp_BitMap(a4),a4
		lea	bm_Planes(a4),a4
		move.l	CPUTask,a5
		move.l	GfxSet,d0
		jsr	_c2p4

		movem.l	(sp)+,a4-a6
		move.l	InvisibleMap,CURRENTA5(a4)
		move.w	#-1,MustWaitForC2P
		clr.w	DontPause		;Darf wieder angehalten werden
		bra	Periodic6569

; Picasso: Nichts
PicassoVBlank	move.w	#-1,DontPause		;Nicht hier anhalten
		move.l	a6,-(sp)
		move.l	_VilIntuiBase(pc),a6

		move.l	TheScreen,a0
		jsr	UnLockVillageScreen(a6)

		move.l	TheScreen,a0		;Vorher unsichtbare Bitmap
		move.l	InvBufNum,d0		;darstellen
		jsr	VillageSetDisplayBuf(a6)

		eor.l	#1,InvBufNum		;Puffer wechseln
		move.l	TheScreen,a0
		jsr	LockVillageScreen(a6)
		move.l	TheScreen,a0		;Adresse ermitteln
		move.l	InvBufNum,d0
		jsr	VillageGetBufAddr(a6)
		move.l	d0,CURRENTA5(a4)

		move.l	(sp)+,a6
		clr.w	DontPause		;Darf wieder angehalten werden
		bra	Periodic6569

*
* Aktuelle Rasterzeile holen
*

		CNOP	0,4
Periodic6569	lea	Registers,a4
		move.w	CURRENTRASTER(a4),d7

*
* Rasterzähler erhöhen (muß hier geschehen, damit bei einem Raster-IRQ
*  der Wert des Rasterzählers mit der IRQ-Zeile übereinstimmt)
*

		addq.w	#1,d7
		move.w	d7,CURRENTRASTER(a4)
		cmp.w	#TotalRasters,d7	;Bildende erreicht?
		beq	VICVBlank

*
* Raster-IRQ auslösen, wenn Vergeichswert erreicht
*

		cmp.w	IRQRASTER(a4),d7	;IRQ-Zeile erreicht?
		bne	NoRasterIRQ
		or.b	#$01,IRQFLAG(a4)	;Ja, IRST-Bit setzen
		btst	#0,IRQMASK(a4)		;Raster-IRQ erlaubt?
		beq	NoRasterIRQ
		or.b	#$80,IRQFLAG(a4)	;Ja, IRQ-Bit setzen
		st.b	IntIsVICIRQ		;Und Interrupt auslösen
NoRasterIRQ

*
* Neue Anzahl CPU-Zyklen setzen
*

		move.w	NormalCycles,CyclesLeft

*
* Innerhalb des sichtbaren Bereichs?
*

		cmp.w	#FirstDispLine,d7
		blo	VICNop
		cmp.w	#LastDispLine,d7
		bhi	VICNop

*
* Zeiger in Bildschirmspeicher nach a5 holen
*

		cmp.w	#STYP_AMIGA,ScreenType
		bne	1$
		move.l	CURRENTA5(a4),a5	;Amiga: In die Chunky-Map schreiben
		bra	2$
1$		lea	LineStore,a5		;EGS/Picasso: In LineStore schreiben
2$

*
* Bei abgeschaltetem Bildschirm nur Rahmen zeichnen
*

		tst.b	SCREENOFF(a4)
		bne	TBBorderDraw

*
* VC-Zähler setzen
*

		move.w	VCBASE(a4),VCCOUNT(a4)

*
* "Bad Lines"-Videomatrixzugriff:
* 40 Bytes aus Videomatrix und Farb-RAM lesen und zwischenspeichern
*

		cmp.w	#FirstDMALine,d7 ;Innerhalb des DMA-Bereiches?
		blo	NoBadLine
		cmp.w	#LastDMALine,d7
		bhi	NoBadLine

		move.b	d7,d0		;Ja, stimmen die unteren Bits
		and.b	#7,d0		;der Rasterzeile mit dem Y-Scroll
		cmp.b	YSCROLL+1(a4),d0 ;überein?
		bne	NoBadLine

IsBadLine	move.w	VCCOUNT(a4),d2	;d2: VC Videomatrix-Zähler

		move.l	MATRIXBASE(a4),a0 ;Videomatrixbasis holen
		add.w	d2,a0		;Videomatrixzähler dazunehmen

		move.l	TheColor(pc),a2	;Zeiger auf Farb-RAM holen
		add.w	d2,a2		;Videomatrixzähler dazunehmen

		lea	MatrixLine,a1	;Videomatrix- und Farb-RAM-Zeile lesen
		lea	ColorLine,a3
		moveq	#40/4-1,d0	;Jeweils 40 Byte kopieren
1$		move.l	(a0)+,(a1)+
		move.l	(a2)+,(a3)+
		dbra	d0,1$

		clr.w	RC(a4)		;RC zurücksetzen
		clr.b	DISPLAYOFF(a4)	;Darstellung anschalten

		move.w	BadLineCycles,CyclesLeft ;Andere Anzahl Zyklen
NoBadLine

*
* Oberen und unteren Rahmen handhaben
*

		cmp.w	DYSTOP(a4),d7	;Unteres Ende des Fensters erreicht
		bne	1$		; -> Rahmen einschalten
		st.b	BORDERON(a4)
		bra	TBBorderDraw

1$		cmp.w	DYSTART(a4),d7	;Oberes Ende des Fensters erreicht
		bne	TBBorderDone	; -> Rahmen abschalten
		clr.b	BORDERON(a4)
		bra	TBNoBorder

TBBorderDone	tst.b	BORDERON(a4)	;Rahmen an?
		beq	TBNoBorder

TBBorderDraw	move.l	CURRENTA5(a4),a0 ;Ja, Rahmen malen. Und zwar in jedem
					; Fall direkt in die Bitmap schreiben
					; (kein Umweg über LineStore)
		move.b	$20(a4),d0	;Rahmenfarbe
		lsl.w	#8,d0
		move.b	$20(a4),d0	;Nochmaliger Zugriff auf $20(a4) ist
		move.w	d0,d1		; schneller als der Umweg über ein
		swap	d0		; Datenregister
		move.w	d1,d0
		move.w	#DisplayX/4-1,d1
1$		move.l	d0,(a0)+
		dbra	d1,1$
		bra	VICIncA5	;Sonst nix
TBNoBorder

*
* Inhalt des Fensters: Darstellung eingeschaltet?
*

		lea	Col40XStart(a5),a1
		add.w	XSCROLL(a4),a1	;a1: Ziel in Bildschirmspeicher
		lea	MatrixLine,a2	;a2: Zeichencodes
		lea	ColorLine,a3	;a3: Farbcodes

		tst.b	DISPLAYOFF(a4)	;$3FFF darstellen?
		bne	Show3FFF

		move.l	DisplayProc,a0	;Nein, Routine entsprechend
		jmp	(a0)		;dem Darstellungsmodus anspringen

*
* Standard-Text: Zeichendaten holen und darstellen
*

TextStd		add.w	#40,VCCOUNT(a4)	;VC erhöhen (wird nicht verwendet)

		move.l	CHARBASE(a4),a0	;a0: Zeichengeneratorbasis
		add.w	RC(a4),a0	;RC dazunehmen

		move.b	$21(a4),d3	;d3.l: Hintergrundfarbe
		lsl.w	#8,d3		;Für OnlyBack auf Langwort bringen
		move.b	$21(a4),d3
		move.w	d3,d0
		swap	d3
		move.w	d0,d3

		move.l	d3,Col40XStart(a5) ;Hintergrund, wenn X-Scroll>0
		move.l	d3,Col40XStart+4(a5)

; Schleife für 40 Zeichen
		moveq	#39,d1		;d1: Zeichenzähler
		moveq	#0,d0
CharLoop	move.b	(a2)+,d0	;Zeichencode lesen
		move.b	(a3)+,d2	;d2: Zeichenfarbe
		move.b	(a0,d0.w*8),d0	;Zeichendaten lesen
		beq	OnlyBack

; 8 Pixel konvertieren
		add.b	d0,d0
		bcc	11$
		move.b	d2,(a1)+
		bra	12$
11$		move.b	d3,(a1)+

12$		add.b	d0,d0
		bcc	21$
		move.b	d2,(a1)+
		bra	22$
21$		move.b	d3,(a1)+

22$		add.b	d0,d0
		bcc	31$
		move.b	d2,(a1)+
		bra	32$
31$		move.b	d3,(a1)+

32$		add.b	d0,d0
		bcc	41$
		move.b	d2,(a1)+
		bra	42$
41$		move.b	d3,(a1)+

42$		add.b	d0,d0
		bcc	51$
		move.b	d2,(a1)+
		bra	52$
51$		move.b	d3,(a1)+

52$		add.b	d0,d0
		bcc	61$
		move.b	d2,(a1)+
		bra	62$
61$		move.b	d3,(a1)+

62$		add.b	d0,d0
		bcc	71$
		move.b	d2,(a1)+
		bra	72$
71$		move.b	d3,(a1)+

72$		add.b	d0,d0
		bcc	81$
		move.b	d2,(a1)+
		bra	82$
81$		move.b	d3,(a1)+

82$		dbra	d1,CharLoop
		bra	DoSprites

; Nur Hintergrund
OnlyBack	move.l	d3,(a1)+
		move.l	d3,(a1)+
		dbra	d1,CharLoop
		bra	DoSprites

*
* Multicolor-Text: Zeichendaten holen und darstellen
*

TextMulti	add.w	#40,VCCOUNT(a4)	;VC erhöhen (wird nicht verwendet)

		move.l	CHARBASE(a4),a0	;a0: Zeichengeneratorbasis
		add.w	RC(a4),a0	;RC dazunehmen

		move.b	$21(a4),d3	;d3.w: Farbe 0
		lsl.w	#8,d3
		move.b	$21(a4),d3

		move.b	$22(a4),d4	;d4.w: Farbe 1
		lsl.w	#8,d4
		move.b	$22(a4),d4

		move.b	$23(a4),d5	;d5.w: Farbe 2
		lsl.w	#8,d5
		move.b	$23(a4),d5

		move.w	d3,Col40XStart(a5) ;Hintergrund, wenn X-Scroll>0
		move.w	d3,Col40XStart+2(a5)
		move.w	d3,Col40XStart+4(a5)
		move.w	d3,Col40XStart+6(a5)

; Schleife für 40 Zeichen
		moveq	#39,d1		;d1: Zeichenzähler
		moveq	#0,d0
CharMLoop	move.b	(a2)+,d0	;Zeichencode lesen
		move.b	(a3)+,d2	;d2: Farbnibble
		move.b	(a0,d0.w*8),d0	;Zeichendaten lesen
		bclr	#3,d2		;Standard oder Multi?
		beq	StdInMulti

; Multicolor: 4 Pixel konvertieren
		add.b	d0,d0
		bcc	11$
		add.b	d0,d0
		bcc	12$
		move.b	d2,(a1)+	;11
		move.b	d2,(a1)+
		bra	20$
12$		move.w	d5,(a1)+	;10
		bra	20$
11$		add.b	d0,d0
		bcc	13$
		move.w	d4,(a1)+	;01
		bra	20$
13$		move.w	d3,(a1)+	;00

20$		add.b	d0,d0
		bcc	21$
		add.b	d0,d0
		bcc	22$
		move.b	d2,(a1)+
		move.b	d2,(a1)+
		bra	30$
22$		move.w	d5,(a1)+
		bra	30$
21$		add.b	d0,d0
		bcc	23$
		move.w	d4,(a1)+
		bra	30$
23$		move.w	d3,(a1)+

30$		add.b	d0,d0
		bcc	31$
		add.b	d0,d0
		bcc	32$
		move.b	d2,(a1)+
		move.b	d2,(a1)+
		bra	40$
32$		move.w	d5,(a1)+
		bra	40$
31$		add.b	d0,d0
		bcc	33$
		move.w	d4,(a1)+
		bra	40$
33$		move.w	d3,(a1)+

40$		add.b	d0,d0
		bcc	41$
		add.b	d0,d0
		bcc	42$
		move.b	d2,(a1)+
		move.b	d2,(a1)+
		bra	50$
42$		move.w	d5,(a1)+
		bra	50$
41$		add.b	d0,d0
		bcc	43$
		move.w	d4,(a1)+
		bra	50$
43$		move.w	d3,(a1)+

50$		dbra	d1,CharMLoop
		bra	DoSprites

; Standard: 8 Pixel konvertieren
StdInMulti	add.b	d0,d0
		bcc	11$
		move.b	d2,(a1)+
		bra	12$
11$		move.b	d3,(a1)+

12$		add.b	d0,d0
		bcc	21$
		move.b	d2,(a1)+
		bra	22$
21$		move.b	d3,(a1)+

22$		add.b	d0,d0
		bcc	31$
		move.b	d2,(a1)+
		bra	32$
31$		move.b	d3,(a1)+

32$		add.b	d0,d0
		bcc	41$
		move.b	d2,(a1)+
		bra	42$
41$		move.b	d3,(a1)+

42$		add.b	d0,d0
		bcc	51$
		move.b	d2,(a1)+
		bra	52$
51$		move.b	d3,(a1)+

52$		add.b	d0,d0
		bcc	61$
		move.b	d2,(a1)+
		bra	62$
61$		move.b	d3,(a1)+

62$		add.b	d0,d0
		bcc	71$
		move.b	d2,(a1)+
		bra	72$
71$		move.b	d3,(a1)+

72$		add.b	d0,d0
		bcc	81$
		move.b	d2,(a1)+
		bra	82$
81$		move.b	d3,(a1)+

82$		dbra	d1,CharMLoop
		bra	DoSprites

*
* Extended Color Mode: Grafikdaten holen und darstellen
*

TextECM		add.w	#40,VCCOUNT(a4)	;VC erhöhen (wird nicht verwendet)

		move.l	CHARBASE(a4),a0	;a0: Zeichengeneratorbasis
		add.w	RC(a4),a0	;RC dazunehmen

		move.b	$21(a4),d3	;d3: Hintergrund 0
		move.b	$22(a4),d4	;d4: Hintergrund 1
		move.b	$23(a4),d5	;d5: Hintergrund 2
		move.b	$24(a4),d6	;d6: Hintergrund 3

		move.b	LASTBKGD(a4),d0	;Letzter Hintergrund, wenn X-Scroll>0
		lsl.w	#8,d0
		move.b	LASTBKGD(a4),d0

		move.w	d0,Col40XStart(a5)
		move.w	d0,Col40XStart+2(a5)
		move.w	d0,Col40XStart+4(a5)
		move.w	d0,Col40XStart+6(a5)

; Schleife für 40 Zeichen
		move.w	d7,-(sp)	;d7: Aktuelle Hintergrundfarbe
		moveq	#39,d1		;d1: Zeichenzähler
		moveq	#0,d0
CharELoop	move.b	(a2)+,d0	;Zeichencode lesen
		move.b	(a3)+,d2	;d2: Farbnibble
		bclr	#7,d0
		bne	1$
		bclr	#6,d0
		bne	2$
		move.b	d3,d7		;00: Hintergrund 0
		bra	4$
2$		move.b	d4,d7		;01: Hintergrund 1
		bra	4$
1$		bclr	#6,d0
		bne	3$
		move.b	d5,d7		;10: Hintergrund 2
		bra	4$
3$		move.b	d6,d7		;11: Hintergrund 3
4$		move.b	(a0,d0.w*8),d0	;Zeichendaten lesen

; 8 Pixel konvertieren
		add.b	d0,d0
		bcc	11$
		move.b	d2,(a1)+
		bra	12$
11$		move.b	d7,(a1)+

12$		add.b	d0,d0
		bcc	21$
		move.b	d2,(a1)+
		bra	22$
21$		move.b	d7,(a1)+

22$		add.b	d0,d0
		bcc	31$
		move.b	d2,(a1)+
		bra	32$
31$		move.b	d7,(a1)+

32$		add.b	d0,d0
		bcc	41$
		move.b	d2,(a1)+
		bra	42$
41$		move.b	d7,(a1)+

42$		add.b	d0,d0
		bcc	51$
		move.b	d2,(a1)+
		bra	52$
51$		move.b	d7,(a1)+

52$		add.b	d0,d0
		bcc	61$
		move.b	d2,(a1)+
		bra	62$
61$		move.b	d7,(a1)+

62$		add.b	d0,d0
		bcc	71$
		move.b	d2,(a1)+
		bra	72$
71$		move.b	d7,(a1)+

72$		add.b	d0,d0
		bcc	81$
		move.b	d2,(a1)+
		bra	82$
81$		move.b	d7,(a1)+

82$		dbra	d1,CharELoop

		move.b	d7,LASTBKGD(a4)	;Letzte Hintergrundfarbe merken
		move.w	(sp)+,d7
		bra	DoSprites

*
* Standard-BitMap: Grafikdaten holen und darstellen
*

BitMapStd	move.l	BITMAPBASE(a4),a0 ;a0: Bitmap-Basis
		move.w	VCCOUNT(a4),d0	;VC holen
		lsl.w	#3,d0		;*8
		add.w	RC(a4),d0	;RC dazunehmen
		add.w	d0,a0		;und zur Bitmap-Basis dazunehmen

		add.w	#40,VCCOUNT(a4)	;VC erhöhen

		move.b	LASTBKGD(a4),d0	;Letzter Hintergrund, wenn X-Scroll>0
		lsl.w	#8,d0
		move.b	LASTBKGD(a4),d0

		move.w	d0,Col40XStart(a5)
		move.w	d0,Col40XStart+2(a5)
		move.w	d0,Col40XStart+4(a5)
		move.w	d0,Col40XStart+6(a5)

; Schleife für 40 Bytes
		moveq	#39,d1		;d1: Zeichenzähler
BitMapLoop	move.b	(a2)+,d2	;Farbe holen
		move.b	d2,d3		;d3: Hintergrundfarbe
		move.b	(a0),d0		;Byte holen
		lsr.b	#4,d2		;d2: Vordergrundfarbe

; 8 Pixel konvertieren
		add.b	d0,d0
		bcc	11$
		move.b	d2,(a1)+
		bra	12$
11$		move.b	d3,(a1)+

12$		add.b	d0,d0
		bcc	21$
		move.b	d2,(a1)+
		bra	22$
21$		move.b	d3,(a1)+

22$		add.b	d0,d0
		bcc	31$
		move.b	d2,(a1)+
		bra	32$
31$		move.b	d3,(a1)+

32$		add.b	d0,d0
		bcc	41$
		move.b	d2,(a1)+
		bra	42$
41$		move.b	d3,(a1)+

42$		add.b	d0,d0
		bcc	51$
		move.b	d2,(a1)+
		bra	52$
51$		move.b	d3,(a1)+

52$		add.b	d0,d0
		bcc	61$
		move.b	d2,(a1)+
		bra	62$
61$		move.b	d3,(a1)+

62$		add.b	d0,d0
		bcc	71$
		move.b	d2,(a1)+
		bra	72$
71$		move.b	d3,(a1)+

72$		add.b	d0,d0
		bcc	81$
		move.b	d2,(a1)+
		bra	82$
81$		move.b	d3,(a1)+

82$		addq.l	#8,a0		;Quellzeiger erhöhen
		dbra	d1,BitMapLoop

		move.b	d3,LASTBKGD(a4)	;Letzte Hintergrundfarbe merken
		bra	DoSprites

*
* Multicolor-Bitmap: Grafikdaten holen und darstellen
*

BitMapMulti	move.l	BITMAPBASE(a4),a0 ;a0: Bitmap-Basis
		move.w	VCCOUNT(a4),d0	;VC holen
		lsl.w	#3,d0		;*8
		add.w	RC(a4),d0	;RC dazunehmen
		add.w	d0,a0		;und zur Bitmap-Basis dazunehmen

		add.w	#40,VCCOUNT(a4)	;VC erhöhen

		move.b	$21(a4),d5	;d5.w: Farbe 0
		lsl.w	#8,d5
		move.b	$21(a4),d5

		move.w	d5,Col40XStart(a5) ;Hintergrund, wenn X-Scroll>0
		move.w	d5,Col40XStart+2(a5)
		move.w	d5,Col40XStart+4(a5)
		move.w	d5,Col40XStart+6(a5)

; Schleife für 40 Bytes
		moveq	#39,d1
BitMapMLoop	move.b	(a2)+,d2	;Farbe 1/2 holen
		move.b	d2,d3		;d3.b: Farbe 2
		move.b	(a0),d0		;Byte holen
		lsr.b	#4,d2		;d2.b: Farbe 1
		move.b	(a3)+,d4	;d4.b: Farbe 3

; 4 Pixel konvertieren
		add.b	d0,d0
		bcc	11$
		add.b	d0,d0
		bcc	12$
		move.b	d4,(a1)+	;11
		move.b	d4,(a1)+
		bra	20$
12$		move.b	d3,(a1)+	;10
		move.b	d3,(a1)+
		bra	20$
11$		add.b	d0,d0
		bcc	13$
		move.b	d2,(a1)+	;01
		move.b	d2,(a1)+
		bra	20$
13$		move.w	d5,(a1)+	;00

20$		add.b	d0,d0
		bcc	21$
		add.b	d0,d0
		bcc	22$
		move.b	d4,(a1)+
		move.b	d4,(a1)+
		bra	30$
22$		move.b	d3,(a1)+
		move.b	d3,(a1)+
		bra	30$
21$		add.b	d0,d0
		bcc	23$
		move.b	d2,(a1)+
		move.b	d2,(a1)+
		bra	30$
23$		move.w	d5,(a1)+

30$		add.b	d0,d0
		bcc	31$
		add.b	d0,d0
		bcc	32$
		move.b	d4,(a1)+
		move.b	d4,(a1)+
		bra	40$
32$		move.b	d3,(a1)+
		move.b	d3,(a1)+
		bra	40$
31$		add.b	d0,d0
		bcc	33$
		move.b	d2,(a1)+
		move.b	d2,(a1)+
		bra	40$
33$		move.w	d5,(a1)+

40$		add.b	d0,d0
		bcc	41$
		add.b	d0,d0
		bcc	42$
		move.b	d4,(a1)+
		move.b	d4,(a1)+
		bra	50$
42$		move.b	d3,(a1)+
		move.b	d3,(a1)+
		bra	50$
41$		add.b	d0,d0
		bcc	43$
		move.b	d2,(a1)+
		move.b	d2,(a1)+
		bra	50$
43$		move.w	d5,(a1)+

50$		addq.l	#8,a0		;Quellzeiger erhöhen
		dbra	d1,BitMapMLoop
		bra	DoSprites

*
* Ungültiger Darstellungsmodus: Schwarzen Bildschirm anzeigen
*

BlackScreen	add.w	#40,VCCOUNT(a4)	;VC erhöhen

		moveq	#39,d0		;40 Zeichen schwarz
1$		clr.l	(a1)+
		clr.l	(a1)+
		dbra	d0,1$
		bra	DoSprites

*
* $3FFF darstellen
*

Show3FFF	move.b	$21(a4),d3	;d3.w: Hintergrundfarbe
		lsl.w	#8,d3
		move.b	$21(a4),d3

		move.w	d3,Col40XStart(a5) ;Hintergrund, wenn X-Scroll>0
		move.w	d3,Col40XStart+2(a5)
		move.w	d3,Col40XStart+4(a5)
		move.w	d3,Col40XStart+6(a5)

		btst	#6,CTRL1(a4)
		bne	11$
		move.w	#$3fff,d0	;Byte bei $3FFF lesen
		bra	12$
11$		move.w	#$39ff,d0	;ECM: Byte bei $39FF lesen
12$		GetPhysical
		move.b	(a0),d0		;Byte lesen

; 4 Pixel nach d1 konvertieren, 0: Hintergrund, 1: schwarz
		moveq	#0,d1
		add.b	d0,d0
		bcs	1$
		move.b	d3,d1
1$		lsl.w	#8,d1
		add.b	d0,d0
		bcs	2$
		move.b	d3,d1
2$		lsl.l	#8,d1
		add.b	d0,d0
		bcs	3$
		move.b	d3,d1
3$		lsl.l	#8,d1
		add.b	d0,d0
		bcs	4$
		move.b	d3,d1
4$

; 4 Pixel nach d2 konvertieren
		moveq	#0,d2
		add.b	d0,d0
		bcs	5$
		move.b	d3,d2
5$		lsl.w	#8,d2
		add.b	d0,d0
		bcs	6$
		move.b	d3,d2
6$		lsl.l	#8,d2
		add.b	d0,d0
		bcs	7$
		move.b	d3,d2
7$		lsl.l	#8,d2
		add.b	d0,d0
		bcs	8$
		move.b	d3,d2
8$

; Zeile schreiben
		moveq	#39,d0		;d0: Bytezähler
Loop3FFF	move.l	d1,(a1)+
		move.l	d2,(a1)+
		dbra	d0,Loop3FFF

*
* Sprites
*

DoSprites	tst.b	SPRITEON(a4)	;Ist überhaupt ein Sprite z.Z. sichtbar?
		beq	DrawLRBorder	;Nein, dann schenken wir uns das

; Kollisions-Puffer löschen
		lea	SprCollBuf,a0
		moveq	#DisplayX/4-1,d0
5$		clr.l	(a0)+
		dbra	d0,5$

		move.b	$25(a4),d3	;d3.l: Multicolor #0
		lsl.w	#8,d3
		move.b	$25(a4),d3
		move.w	d3,d0
		swap	d3
		move.w	d0,d3

		move.b	$26(a4),d4	;d4.l: Multicolor #1
		lsl.w	#8,d4
		move.b	$26(a4),d4
		move.w	d4,d0
		swap	d4
		move.w	d0,d4

; Sprites malen
		move.l	d7,-(sp)
		DoSprite 7
		DoSprite 6
		DoSprite 5
		DoSprite 4
		DoSprite 3
		DoSprite 2
		DoSprite 1
		DoSprite 0
		move.l	(sp)+,d7

; Kollisions-Puffer auswerten
		lea	SprCollBuf,a0
		lea	SprCollTab,a1
		moveq	#0,d0
		move.w	#DisplayX-1,d2
1$		move.b	(a0)+,d0	;Byte aus Puffer holen
		tst.b	(a1,d0.w)	;Entspricht die Bitkombination einer
		bne	2$		; Kollision?
		dbra	d2,1$		;Nein, weitertesten
		bra	4$

2$		move.b	CLXSPR(a4),d1	;Ja, Kollision erkannt
		or.b	d0,CLXSPR(a4)	;Bits im Kollisionsregister setzen
		tst.b	d1		;Wenn bereits Kollisionen stattgefunden
		bne	3$		; haben, keinen IRQ mehr auslösen
		or.b	#$04,IRQFLAG(a4) ;IMMC-Bit setzen
		btst	#2,IRQMASK(a4)	;IRQ erlaubt?
		beq	3$
		or.b	#$80,IRQFLAG(a4) ;Ja, IRQ-Bit setzen
		st.b	IntIsVICIRQ	;Und Interrupt auslösen
3$		dbra	d2,1$
4$

*
* Linken und rechten Rahmen zeichnen
*

; 40-Spalten-Rahmen direkt in die Bitmap
DrawLRBorder	move.l	CURRENTA5(a4),a0
		move.b	$20(a4),d0	;d0.l: Rahmenfarbe
		lsl.w	#8,d0
		move.b	$20(a4),d0
		move.w	d0,d1
		swap	d0
		move.w	d1,d0

		move.l	d0,(a0)+	;Links: $00..$17
		move.l	d0,(a0)+
		move.l	d0,(a0)+
		move.l	d0,(a0)+
		move.l	d0,(a0)+
		move.l	d0,(a0)+

		lea	Col40XStop-Col40XStart(a0),a0
		move.l	d0,(a0)+	;Rechts: $158..$16f
		move.l	d0,(a0)+
		move.l	d0,(a0)+
		move.l	d0,(a0)+
		move.l	d0,(a0)+
		move.l	d0,(a0)

; 38-Spalten-Rahmen nach (a5) (Puffer oder Bitmap)
		tst.b	IS38COL(a4)
		beq	1$

		lea	Col40XStart(a5),a0
		move.l	d0,(a0)+	;Links: $18..$1e
		move.w	d0,(a0)+
		move.b	d0,(a0)

		lea	Col38XStop(a5),a0
		move.b	d0,(a0)+	;Rechts: $14f..$157
		move.l	d0,(a0)+
		move.l	d0,(a0)+
1$

*
* Ende einer sichtbaren Zeile: Bei EGS/Picasso Zeile in die Karte schreiben
* Es wird nur der Bereich zwischen Col40XStart und Col40XStop geschrieben,
* der Rest ist immer Rahmen und der wird in DrawLRBorder direkt in die
* Bitmap geschrieben.
*

VICNext		cmp.w	#STYP_AMIGA,ScreenType
		beq	VICIncA5
		move.l	CURRENTA5(a4),a1
		lea	Col40XStart(a1),a1
		lea	LineStore+Col40XStart,a0
		moveq	#(Col40XStop-Col40XStart)/4-1,d0
1$		move.l	(a0)+,(a1)+
		dbra	d0,1$

*
* Zeiger in Bitmap erhöhen
*

VICIncA5	moveq	#0,d0
		move.w	ScreenX,d0
		add.l	d0,CURRENTA5(a4)

*
* RC erhöhen, Darstellung abschalten, wenn gleich 7
* (braucht nur im sichtbaren Bereich zu geschehen)
*

		cmp.w	#7,RC(a4)
		beq	1$
		addq.w	#1,RC(a4)
		bra	2$
1$		st.b	DISPLAYOFF(a4)
		move.w	VCCOUNT(a4),VCBASE(a4)
2$

*
* MCs erhöhen (muß in jeder Rasterzeile geschehen, damit die Sprites
*  auch im Overscan-Bereich korrekt dargestellt werden)
*

VICNop		lea	SPRITEON(a4),a3

		move.b	M0Y(a4),d0	;Y-Koordinate
		moveq	#0,d6		;Spritenummer
		lea	MC0(a4),a2	;Zeiger auf MC
		bsr	IncMC

		move.b	M1Y(a4),d0	;Y-Koordinate
		moveq	#1,d6		;Spritenummer
		lea	MC1(a4),a2	;Zeiger auf MC
		bsr	IncMC

		move.b	M2Y(a4),d0	;Y-Koordinate
		moveq	#2,d6		;Spritenummer
		lea	MC2(a4),a2	;Zeiger auf MC
		bsr	IncMC

		move.b	M3Y(a4),d0	;Y-Koordinate
		moveq	#3,d6		;Spritenummer
		lea	MC3(a4),a2	;Zeiger auf MC
		bsr	IncMC

		move.b	M4Y(a4),d0	;Y-Koordinate
		moveq	#4,d6		;Spritenummer
		lea	MC4(a4),a2	;Zeiger auf MC
		bsr	IncMC

		move.b	M5Y(a4),d0	;Y-Koordinate
		moveq	#5,d6		;Spritenummer
		lea	MC5(a4),a2	;Zeiger auf MC
		bsr	IncMC

		move.b	M6Y(a4),d0	;Y-Koordinate
		moveq	#6,d6		;Spritenummer
		lea	MC6(a4),a2	;Zeiger auf MC
		bsr	IncMC

		move.b	M7Y(a4),d0	;Y-Koordinate
		moveq	#7,d6		;Spritenummer
		lea	MC7(a4),a2	;Zeiger auf MC
		bsr	IncMC

; In 6510-Task zurückspringen
		bra	Peri6569Cont


**
** Spritedatenzähler erhöhen, zurücksetzen wenn nötig
** d0.b: Y-Koordinate
** d6.l: Spritenummer (0..7)
** a2  : Zeiger auf MC
** a3  : Zeiger auf SPRITEON
**

		CNOP	0,4
IncMC		btst	d6,SPREN(a4)	;Sprite angeschaltet?
		beq	3$
		cmp.b	d0,d7		;Ja, Y-Koord. gleich den unteren
		bne	3$		; 8 Bit des Rasterzählers?
		clr.w	(a2)		;Ja, Zähler zurücksetzen
		bset	d6,(a3)		;Und Sprite ab jetzt darstellen
		rts

3$		cmp.w	#60,(a2)	;MC kleiner als 60?
		bhs	4$
		btst	d6,MYE(a4)	;Ja, Sprite Y-expandiert?
		beq	1$
		eor.b	d7,d0		;Ja, nur erhöhen, wenn Bit 0
		and.b	#$01,d0		; der Y-Koordinate gleich Bit 0
		bne	2$		; des Rasterzählers ist
1$		addq.w	#3,(a2)		;MC erhöhen
		subq.w	#2,CyclesLeft	;2 Zyklen vom 6510 abziehen
		rts
4$		bclr	d6,(a3)		;MC gleich 60, Sprite nicht mehr darstellen
2$		rts


**
** Ein Sprite zeichnen
** d2.w: Spritefarbe
** d3.l: Multicolor #0
** d4.l: Multicolor #1
** d5.w: MC
** d6.l: Spritenummer (0..7)
** d7.b: Spritedatenzeiger
** a2  : Zeiger auf X-Koordinate
**

		CNOP	0,4
DrawSprite	btst	d6,SPRITEON(a4)	;Wird das Sprite dargestellt?
		beq	SpriteDone

		moveq	#0,d0		;Ja, Basisadresse berechnen
		move.b	d7,d0		;Spritedatenzeiger
		lsl.w	#6,d0
		add.w	d5,d0		;MC dazunehmen
		GetPhysical		;a0: Spritedaten

		moveq	#0,d5		;X-Position zusammenbauen
		move.b	(a2),d5
		btst	d6,MX8(a4)
		beq	1$
		or.w	#$0100,d5	;d5: Sprite-X-Position
1$		cmp.w	#DisplayX-24,d5
		bhs	SpriteDone
		move.l	a5,a1
		add.w	d5,a1		;a1: Ziel in Bildschirmspeicher
		lea	SprCollBuf,a2
		add.w	d5,a2		;a2: Ziel im Kollisionspuffer

		btst	d6,MMC(a4)	;Multicolor?
		bne	SprMulti

		btst	d6,MXE(a4)	;Nein, X-expandiert?
		bne	SprStdExp

; Standard-Sprite: 3 Byte mit je 8 Pixeln konvertieren
		moveq	#0,d5
		bset	d6,d5		;d5: Bitmaske für Kollisionspuffer

		moveq	#2,d1		;Bytezähler
SprLoop		move.b	(a0)+,d0	;Byte lesen
		beq	18$		;Null: Nichts darstellen

		add.b	d0,d0
		bcc	11$
		move.b	d2,(a1)
		or.b	d5,(a2)

11$		add.b	d0,d0
		bcc	12$
		move.b	d2,1(a1)
		or.b	d5,1(a2)

12$		add.b	d0,d0
		bcc	13$
		move.b	d2,2(a1)
		or.b	d5,2(a2)

13$		add.b	d0,d0
		bcc	14$
		move.b	d2,3(a1)
		or.b	d5,3(a2)

14$		add.b	d0,d0
		bcc	15$
		move.b	d2,4(a1)
		or.b	d5,4(a2)

15$		add.b	d0,d0
		bcc	16$
		move.b	d2,5(a1)
		or.b	d5,5(a2)

16$		add.b	d0,d0
		bcc	17$
		move.b	d2,6(a1)
		or.b	d5,6(a2)

17$		add.b	d0,d0
		bcc	18$
		move.b	d2,7(a1)
		or.b	d5,7(a2)

18$		addq.l	#8,a1
		addq.l	#8,a2
		dbra	d1,SprLoop
SpriteDone	rts

; X-expandiertes Standard-Sprite: 3 Byte mit je 8 Pixeln konvertieren
SprStdExp	cmp.w	#DisplayX-48,d5	;Sprite sichtbar?
		bhs	SpriteDone

		moveq	#0,d5
		bset	d6,d5
		lsl.w	#8,d5
		bset	d6,d5		;d5: Bitmaske für Kollisionspuffer

		moveq	#2,d1		;Bytezähler
SprELoop	move.b	(a0)+,d0	;Byte lesen
		beq	18$		;Null: Nichts darstellen

		add.b	d0,d0
		bcc	11$
		move.w	d2,(a1)
		or.w	d5,(a2)

11$		add.b	d0,d0
		bcc	12$
		move.w	d2,2(a1)
		or.w	d5,2(a2)

12$		add.b	d0,d0
		bcc	13$
		move.w	d2,4(a1)
		or.w	d5,4(a2)

13$		add.b	d0,d0
		bcc	14$
		move.w	d2,6(a1)
		or.w	d5,6(a2)

14$		add.b	d0,d0
		bcc	15$
		move.w	d2,8(a1)
		or.w	d5,8(a2)

15$		add.b	d0,d0
		bcc	16$
		move.w	d2,10(a1)
		or.w	d5,10(a2)

16$		add.b	d0,d0
		bcc	17$
		move.w	d2,12(a1)
		or.w	d5,12(a2)

17$		add.b	d0,d0
		bcc	18$
		move.w	d2,14(a1)
		or.w	d5,14(a2)

18$		lea	16(a1),a1
		lea	16(a2),a2
		dbra	d1,SprELoop
		rts

; Multicolor-Sprite: 3 Byte mit je 4 Pixeln konvertieren
SprMulti	btst	d6,MXE(a4)	;X-expandiert?
		bne	SprMultiExp

		moveq	#0,d5
		bset	d6,d5
		lsl.w	#8,d5
		bset	d6,d5		;d5: Bitmaske für Kollisionspuffer

		moveq	#2,d1		;Bytezähler
SprMLoop	move.b	(a0)+,d0	;Byte lesen
		beq	50$		;Null: Nichts darstellen

		add.b	d0,d0
		bcc	11$
		or.w	d5,(a2)
		add.b	d0,d0
		bcc	12$
		move.w	d4,(a1)		;11
		bra	20$
12$		move.w	d2,(a1)		;10
		bra	20$
11$		add.b	d0,d0
		bcc	20$
		move.w	d3,(a1)		;01
		or.w	d5,(a2)

20$		add.b	d0,d0
		bcc	21$
		or.w	d5,2(a2)
		add.b	d0,d0
		bcc	22$
		move.w	d4,2(a1)
		bra	30$
22$		move.w	d2,2(a1)
		bra	30$
21$		add.b	d0,d0
		bcc	30$
		move.w	d3,2(a1)
		or.w	d5,2(a2)

30$		add.b	d0,d0
		bcc	31$
		or.w	d5,4(a2)
		add.b	d0,d0
		bcc	32$
		move.w	d4,4(a1)
		bra	40$
32$		move.w	d2,4(a1)
		bra	40$
31$		add.b	d0,d0
		bcc	40$
		move.w	d3,4(a1)
		or.w	d5,4(a2)

40$		add.b	d0,d0
		bcc	41$
		or.w	d5,6(a2)
		add.b	d0,d0
		bcc	42$
		move.w	d4,6(a1)
		bra	50$
42$		move.w	d2,6(a1)
		bra	50$
41$		add.b	d0,d0
		bcc	50$
		move.w	d3,6(a1)
		or.w	d5,6(a2)

50$		addq.l	#8,a1
		addq.l	#8,a2
		dbra	d1,SprMLoop
SpriteDone1	rts

; X-expandiertes Multicolor-Sprite: 3 Byte mit je 4 Pixeln konvertieren
SprMultiExp	cmp.w	#DisplayX-48,d5	;Sprite sichtbar?
		bhs	SpriteDone1

		moveq	#0,d5
		bset	d6,d5
		lsl.w	#8,d5
		bset	d6,d5
		move.w	d5,d0
		swap	d5
		move.w	d0,d5		;d5: Bitmaske für Kollisionspuffer

		move.w	d2,d0		;d2 auf Langwort erweitern
		swap	d2
		move.w	d0,d2

		moveq	#2,d1
SprMELoop	move.b	(a0)+,d0	;Byte lesen
		beq	50$		;Null: Nichts darstellen

		add.b	d0,d0
		bcc	11$
		or.l	d5,(a2)
		add.b	d0,d0
		bcc	12$
		move.l	d4,(a1)		;11
		bra	20$
12$		move.l	d2,(a1)		;10
		bra	20$
11$		add.b	d0,d0
		bcc	20$
		move.l	d3,(a1)		;01
		or.l	d5,(a2)

20$		add.b	d0,d0
		bcc	21$
		or.l	d5,4(a2)
		add.b	d0,d0
		bcc	22$
		move.l	d4,4(a1)
		bra	30$
22$		move.l	d2,4(a1)
		bra	30$
21$		add.b	d0,d0
		bcc	30$
		move.l	d3,4(a1)
		or.l	d5,4(a2)

30$		add.b	d0,d0
		bcc	31$
		or.l	d5,8(a2)
		add.b	d0,d0
		bcc	32$
		move.l	d4,8(a1)
		bra	40$
32$		move.l	d2,8(a1)
		bra	40$
31$		add.b	d0,d0
		bcc	40$
		move.l	d3,8(a1)
		or.l	d5,8(a2)

40$		add.b	d0,d0
		bcc	41$
		or.l	d5,12(a2)
		add.b	d0,d0
		bcc	42$
		move.l	d4,12(a1)
		bra	50$
42$		move.l	d2,12(a1)
		bra	50$
41$		add.b	d0,d0
		bcc	50$
		move.l	d3,12(a1)
		or.l	d5,12(a2)

50$		lea	16(a1),a1
		lea	16(a2),a2
		dbra	d1,SprMELoop
		rts


**
** Konstanten
**

; Farbpalette
		CNOP	0,4
Palette		dc.b	0,0,0,0		;Schwarz
		dc.b	255,255,255,0	;Weiß
		dc.b	204,0,0,0	;Rot
		dc.b	0,255,204,0	;Cyan
		dc.b	255,0,255,0	;Magenta
		dc.b	0,204,0,0	;Grün
		dc.b	0,0,204,0	;Blau
		dc.b	255,255,0,0	;Gelb
		dc.b	255,128,0,0	;Orange
		dc.b	128,64,0,0	;Braun
		dc.b	255,128,128,0	;Hellrot
		dc.b	64,64,64,0	;Dunkelgrau
		dc.b	128,128,128,0	;Mittelgrau
		dc.b	128,255,128,0	;Hellgrün
		dc.b	128,128,255,0	;Hellblau
		dc.b	192,192,192,0	;Hellgrau

; Tabelle der Display-Routinen
DispProcTab	dc.l	TextStd
		dc.l	TextMulti
		dc.l	BitMapStd
		dc.l	BitMapMulti
		dc.l	TextECM
		dc.l	BlackScreen
		dc.l	BlackScreen
		dc.l	BlackScreen


**
** Datenbereich
**

; Taglist für den Screen (Amiga)
ScreenTags	dc.l	SA_DisplayID
ScreenDID	dc.l	0
		dc.l	SA_Width,$180	;Vielfaches von 32
		dc.l	SA_Height,DisplayY
		dc.l	SA_Depth,4
		dc.l	SA_Quiet,-1
		dc.l	SA_AutoScroll,-1
		dc.l	SA_Overscan,OSCAN_STANDARD
		dc.l	0,0

; Taglist für das Fenster (Picasso/Amiga)
WindowTags	dc.l	WA_Left,0
		dc.l	WA_Top,0
		dc.l	WA_Width
WindowWidth	dc.l	0
		dc.l	WA_Height
WindowHeight	dc.l	0
		dc.l	WA_NoCareRefresh,-1
		dc.l	WA_Borderless,-1
		dc.l	WA_Activate,-1
		dc.l	WA_RMBTrap,-1
		dc.l	WA_CustomScreen
WindowScreen	dc.l	0
		dc.l	WA_IDCMP,IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY
		dc.l	0,0

; Struktur für E_OpenScreen (EGS)
NewEScreen	dc.l	ModeNameBuf+16
		dc.w	8,0	;Tiefe 8
		dc.l	0
		dc.l	0
		dc.l	0
		dc.l	0
		dc.l	E_eMOUSEBUTTONS|E_eRAWKEY
		dc.l	0

; Taglist für den Screen (Picasso)
VilTags		dc.l	TAVIS_DM_STRUCT,Dimensions
		dc.l	TAVIS_DOUBLE_BUFFER,-1
		dc.l	0,0

; VilIntuiSup-Dimensions (Picasso)
Dimensions	dc.w	0,0,0,0,8,0	;8: Tiefe

; Variablen
		CNOP	0,4
DisplayID	dc.l	0	;Prefs: DisplayID des Screens
TheScreen	dc.l	0	;Screen
TheWindow	dc.l	0	;Window (Picasso/Amiga)
EGSPort		dc.l	0	;EDCMP-Port (EGS)
WindowPort	dc.l	0	;IDCMP-Port (Amiga/Picasso)
TheRastPort	dc.l	0	;RastPort (Amiga)
TheViewPort	dc.l	0	;ViewPort (Amiga/Picasso)
InvisibleMap	dc.l	0	;Zeiger auf unsichtbare BitMap
InvBufNum	dc.l	0	;Nummer des unsichtbaren Puffers (Picasso)
VBlankProc	dc.l	0	;Zeiger auf VBlank-Routine
DisplayProc	dc.l	0	;Zeiger auf die Display-Routine (Text/Bitmap etc.)

ComparisonBuf	dc.l	0	;Puffer für c2p4
GfxSet		dc.l	0	;Signal für c2p4
GfxSig		dc.w	0

ScreenType	dc.w	0	;Prefs: Typ der Screen-Ansteuerung
NormalCycles	dc.w	0	;Prefs: Anzahl 6510-Zyklen pro Rasterzeile
BadLineCycles	dc.w	0	;Prefs: Anzahl 6510-Zyklen in einer Bad Line
CiaVABase	dc.w	0	;16-Bit Basisadresse durch Cia-VA14/15
ScreenX		dc.w	0	;Ausmaße des Screens
ScreenY		dc.w	0
MustWaitForC2P	dc.w	0	;Es muß auf das Signal von c2p gewartet werden

		CNOP	0,4
Registers	ds.b	128	;VIC-Register
MatrixLine	ds.b	40	;Eine Bildschirmzeile
ColorLine	ds.b	40	;Eine Farb-RAM-Zeile

**
** Nicht initialisierte Daten
**

		SECTION	"BSS",BSS
LineStore	ds.b	DisplayX	;Puffer für eine Zeile
SprCollBuf	ds.b	DisplayX	;Puffer für Sprite-Kollisionen

SprCollTab	ds.b	256		;Welche Bitkombinationen lösen eine Kollision aus?

ModeNameBuf	ds.b	nif_SIZEOF	;Puffer für GetDisplayInfoData
TheRect		ds.b	ra_SIZEOF	;Puffer für QueryOverscan
		END