Vertikales scrolling...

[Dr. Irata]

Bei der Aufarbeitung der "Probleme", die ich mit Battle of Eris hatte, habe ich mich nochmal mit dem Scrolling beschäftigt. Dies war bei mir ein großes Problem, da ich den Grobscroll so gemacht habe, daß ich einen sichtbaren und einen nicht sichtbaren Bildschirm hatte, im nicht sichtbaren dann den gesamten Bildschirminhalt - also 1kB - um eine Zeile nach oben bewegt habe und dann umgeschaltet habe. Das kostet natürlich Speicher aber vor allem Rechenzeit. Auch die Kollisionserkennung bei dem Schritt ist problematisch. Dieses Kernproblem muss man also natürlich ganz anders lösen und es gibt da ein paar gute Ansätze und Beschreibungen im Netz.
Gestern habe ich mit Janko darüber geschrieben - er hatte mir mal eine kleine Demo gesendet, wo er Graphics 9 scrollt mit Displaylistmanipulation - und hier gibt es mindestens 2 gute Lösungsansätze, die von der Theorie her klar und logisch sind.
Hier im Forum habe ich aber dazu keinen Post gefunden und daher würde ich hier an der Stelle auch quasi als Nachschlagsmöglichkeit mit euch zusammen einen möglichst effektiven, verständlichen Code für MADS/Eclipse/WUDSN entwickeln mit folgenden Vorgaben:

1. Verticales Softscrolling mittels DL-Manipulation
2. Antic 4 mit 20 Zeilen, die untersten 3 Zeilen Antic 2 ohne Scrolling für die Anzeige.
3. Zeile 1 verschmindet, in Zeile 20 wird per Random ein oder mehrere Zeichen geprintet. Zeile 20 scrollt auch soft rein...
4. Einfacher für jeden verständlicher Code

Falls dieses Thema doch schon entsprechend irgendwo im Forum steht, dann habe ich es übersehen....
Mag das Thema auch für die Profis hier langweilig erscheinen, wird es dem Neuling vielleicht aber eine gute Basis geben können.

LG
Peter

[DjayBee]

Nicht in Deutsch, aber schau mal da:

https://playermissile.com/scrolling_tutorial/index.html

Ich finde Robs Tutorials einfach nur gut.

[Dr. Irata]

die Seite kenne ich sehr gut und finde sie auch excellent... aber halt in englisch und der Code ist mit den ganze includes unübersichtlich für Anfänger...

vielleicht ist das Thema hier auch uninteressant, dann gerne entsprechendes Feedback!

[Kveldulfur]

Moin!

Wie man beim ATARI die Bildinhalte scrollt, wird wahrscheinlich den "Programmierern" bekannt sein.
Aber es geht ja drum, dass man auch Wissen austauscht und so andere oder vielleicht sogar bessere Ansätze/Routinen kennenlernt.
Auch hat man so ein (deutsches) Nachschlagewerk, damit der künftige Programmierer von morgen leichter einsteigen kann.

Ich persönlich fände es toll, wenn gute Ansätze vllt. auch den Weg auf die ABBUC-Seite schaffen, in einem Bereich "Programmierung".
Manchmal ist es doch ganz schön anstrengend etwas im Forum wiederzufinden

Grüße
Janko

[Dr. Irata]

... vielleicht in einer Art Bibliothek für Assembler und Basic. Hier liegen dann z.B. Subroutinen, auf die man gut und schnell zugreifen kann...

[Kveldulfur]

Hallo!

Der Normalfall ist ja, dass man eine Map, z.B. 80 x 40 Zeichen, im Speicher vorhält und dann per Displaylist(-manipulation) und den Registern VSCROL und HSCROL das Scrolling realisiert. Das ist relativ einfach auf dem ATARI und geht auch ohne (großen) Rechenaufwand.

Das Anliegen ist aber, dass man einen Shooter programmieren möchte, der eine sehr lange Map horizontal ODER vertikal hat.
Wenn man die Map komplett im RAM ablegt, bleibt einem nicht viel Speicher für das eigentliche Programm. Zumal die Map nach einer Runde auch ggf. resettet werden muss.
Gerade wenn man gerne das Spiel auf ein Modul bringen möchte, sollte man sich gut überlegen, wie man den Speicherplatz einteilt.

Die Idee ist es, nur einen kleinen RAM-Bereich für die Bildschirmdarstellung zu nutzen und die MAP (ggf. komprimiert) im Speicher vorzuhalten und nur die angeforderte Zeile in den Bildschirm zu kopieren.

Eine Möglichkeit beim vertikalen Scrollen wäre, die Zeile, die gerade aus dem Bildschirm herausgescrollt wurde, an der anderen Seite wieder durch Displaylistmanipultaion einzufügen, nur mit neuem Inhalt. Den Bildschirmspeicher selber kopiert man nicht um, da dies zu viel Zeit in Anspruch nehmen würde.
Diese Variante ist sehr RAM-sparend, aber der Umgang bei z.B. der Kollisionserkennung ist erschwert.

Eine andere Möglichkeit wäre, dass man zwei Bildschirme untereinander im RAM vorhält und nun den Bildschirmausschnitt vom einem Bereich in den anderen scrollt. Am Ende angekommen beginnt man wieder von vorne. Während des scrollens baut man im nicht sichtbaren Bereich den Inhalt auf.
Diese Methode würde auch beim horizontalen Scrollen funktionieren.

Das ist jetzt sehr theoretisch, aber wir sollten ersteinmal Ideen sammeln und dann die favorisierte Idee ggf. anhand von Bildern und Quelltext erarbeiten.

Grüße
Janko

[DjayBee]

die Seite kenne ich sehr gut und finde sie auch excellent... aber halt in englisch und der Code ist mit den ganze includes unübersichtlich für Anfänger...

vielleicht ist das Thema hier auch uninteressant, dann gerne entsprechendes Feedback!

Ich wollte es dir nicht ausreden, dachte aber dass der Aufbau und die Beispiele ein guter Start sein könnten.

Mach weiter, ich finde die Idee gut.

[Erhard]

Hi,

ich hab vor nicht allzu langer Zeit mal ein bisschen horizontales Scrolling ausprobiert und obwohl ich dachte, daß ich es richtig gemacht hatte waren da Ruckler drin...

Also ich hab bestimmt nichts gegen "erleuchtet mich"

CU, Erhard

[Dr. Irata]

... wie gesagt, diese Woche habe ich noch großen Zeitmangel, danach starte ich hier mit euch zusammen den Vertekalscroll...

[Erhard]

Ich habe eh superwenig Zeit und drängele bestimmt nicht.

[patjomki]

In diesem Thread

viewtopic.php?f=7&t=2070&p=16789&hilit= ... cke#p16789

findet man Peter Finzels Assemblerecke.

In Teil fünf und sieben sollte das, was Ihr sucht, zu finden sein.

[Dr. Irata]

... danke für den Link!
Habe mir mal kurz Teil 5 angeschaut und ja, das sieht gut aus... die Beispiele von Peter Finzel sind einfach gut. Das können wir hier sehr gut als Grundlage nutzen und hier tiefer analysieren und dann für MADS umarbeiten denke ich...

[Erhard]

Hi,

für MADS umarbeiten

noch besser fände ich "plain Assember", also keine MADS-Vereinfachungen wie MVA.

Quelltext in MADS kann gerne zusätzlich, dann lernt man gleichzeitig MADS.

Was meint ihr?

CU, Erhard

[Kveldulfur]

Moin,

bin ich auch dafür!

Grüße
Janko

[Olix]

In diesem Thread

viewtopic.php?f=7&t=2070&p=16789&hilit= ... cke#p16789

findet man Peter Finzels Assemblerecke.

In Teil fünf und sieben sollte das, was Ihr sucht, zu finden sein.

Die Assemblercke zum Scrolling war mein Einstieg ins Scrolling und mit dem Wissen habe ich auch mein vertikales Scrolling für mein "Geisterhaus" umgesetzt. Ist definitiv eine gute Grundlage zu dem Thema.

[patjomki]

noch besser fände ich "plain Assember", also keine MADS-Vereinfachungen wie MVA.

Quelltext in MADS kann gerne zusätzlich, dann lernt man gleichzeitig MADS.

Was meint ihr?

CU, Erhard

Also die Assemblereckenroutinen für's Scrolling habe ich 1:1 in MADS übernommen, da musste nix angepasst werden. Benutze den MADS ohnehin ohne die ganzen Zusatzfeatures, ja selbst Makros benutze ich nicht.

Von daher: Dafür

[Dr. Irata]

... nun ja, ich nutze bei MADS eigentlich auch nur MVA und MWA .... das finde ich ganz praktisch - meistens

[Erhard]

Könnte ja auch sein, daß es jemand nativ auf dem Atari machen will.

Ich würde die MADS Vereinfachung als Kommentar einfügen, so a la:

LDA #17 ; Erläuterung bla bla (MVA #17 18)
STA 18
...

CU, Erhard

[Dr. Irata]

Hallöle,
anbei mein erster kleiner Code für ein einfaches vertikales Scrolling für Antic 4 mit Anzeigefeld unten!
Ich habe jetzt mich für die relativ einfache Variante entschieden mit Manipulation der BS-Startadresse in der Displaylist - hier arbeite ich dann mit 2 Bildschirmen und kann somit ein wirklich laufendes Bild erzeugen und in die unterste Zeile entsprechend Zufallszeichen reinprinten... später kann man hier dann Landschaft kontinuierlich einprinten.
Ich habe alles so gehalten, daß man es leicht lesen und verwenden kann.
Verbesserungen oder Optimierungen gerne...
Liebe Grüße
Peter

Code: Alles auswählen

		org $4000
			
RANDOM   = $d20a
RTCLOK   = $0012
SDLSTL   = $0230
VSCROL   = $d405
			
dlx = 240
dlx2 = 242

xrandom		.by 00
zaehler		.by 00
zaehlerbs	.by 00

			;----------------- BS Start bei 0/16 = 4096 -
			;----------------- Antic 4		 ------------
dlist		.byte 112,112,112
dl1			.byte 68+32,248,18
:18			.byte 04+32
			.byte 112
			.byte 66,112,17
:4			.byte 02
			.byte 65
			.word dlist
			;-------------- Start Hauptprogramm -----------------------------	
			.proc main
start		
			lda <dlist 		; Adresse der Displaylist wird 
			sta sdlstl		; ins Register eingetragen
			lda >dlist 
			sta sdlstl+1
			lda #208		; Bildschirmspeicher 1 untere Reihe
			sta dlx
			lda #18
			sta dlx+1
			lda #200		; Bildschirmspeicher 2 untere Reihe
			sta dlx2
			lda #21
			sta dlx2+1
loop1						
			inc zaehler		; Feinscrollzähler
			lda zaehler
			cmp #8			; bei 8 wird der Grobscroll ausgeführt
			bne loop2
			jsr grobscrol
			lda #0 			; anschließend Zähler auf Null
			sta zaehler
loop2		
			lda zaehler 	; Wert vom FeinscrollzählerZähler
			sta vscrol		; ins Register speichern
			jsr wartes		; einmal auf den Takt warten - ersetzt VBI
			jmp loop1
			.endp
			.proc grobscrol
			;------- zunächst wird jeweils die letzte Zeile BS1 und BS2
			;------- gelöscht 
			ldy #40
loop3		
			lda #0
			sta (dlx),y
			sta (dlx2),y
			iny
			cpy #80
			bne loop3
			;----------------------------------------------------------
			;------- hier passiert der eigentliche Grobscroll indem die
			;------- Bildschirmstartadresse in der Displaylist um 40
			;------- also eine Zeile erhöht wird
			clc
			lda dl1+1
			adc #40
			sta dl1+1
			lda dl1+2
			adc #0
			sta dl1+2
			;----------------------------------------------------------
			;------- die letzten Zeilen BS1 und BS2 müssen auch 
			;------- weiterwandern... statt zu addieren würde ich 
			;------- aber mittels Tabellen machen!! Spart CPU-Zeit
			clc
			lda dlx
			adc #40
			sta dlx
			lda dlx+1
			adc #0
			sta dlx+1
			clc
			lda dlx2
			adc #40
			sta dlx2
			lda dlx2+1
			adc #0
			sta dlx2+1
			;-----------------------------------------------------------
			;------- hier jetzt noch eine kleine Random-Füll-Routine, die
			;------- immer in die letzte Zeile ein Randomzeichen an eine 
			;------- Randomstelle in der Zeile printet.... 
			;------- ... später muss hier die Landschaft Zeile für Zeil
			;------- aus einer Tabelle reingeprintet werden...
			lda random
			lsr 
			clc
			adc #16
			lsr
			lsr
			tay
			lda random
			sta (dlx),y
			sta (dlx2),y
			;-------- nach 19 Zeilen muss der Zeilenzähler auf Null
			;-------- gesetzt werden, außerdem müssen die Werte für 
			;-------- dl1  dlx und dlx2 rückgesetzt werden
			inc zaehlerbs
			lda zaehlerbs
			cmp #19
			bne loop4
			lda #0 
			sta zaehlerbs
			lda #208
			sta dlx
			lda #18
			sta dlx+1
			lda #200
			sta dlx2
			lda #21
			sta dlx2+1
			lda #248 
			sta dl1+1
			lda #18 
			sta dl1+2			
loop4			
			rts
			.endp
			.proc wartes
			lda RTCLOK+2
loop5   
			cmp RTCLOK+2
        	beq loop5
        	rts
     		.endp  
     		
		
			run main

[cas]

Hier meine Routine für feines Scrolling in Graphics 0 (alle Richtungen via Joystick) in ACTION!

Code: Alles auswählen

;  Programmname    : ScrollDemo
;  Filename        : SCROLL.ACT
;  von             : Carsten Strotmann
;  letzte Aenderung: 20.12.91
;  Bemerkung       :

;INCLUDE "D2:SYSTEM.ACT"

MODULE;

BYTE shscrol=$70, svscrol=$71,
      hscrol=$D404,vscrol=$D405,
      vcount=$D40B

CARD POINTER dlptr=$72, adr, dlstart

CARD sdlstl=$230, sdlstlsav

BYTE ARRAY displayList =
[$70$70$70
 $72$00$00$72$00$00$72$00$00$72$00$00
 $72$00$00$72$00$00$72$00$00$72$00$00
 $72$00$00$72$00$00$72$00$00$72$00$00
 $72$00$00$72$00$00$72$00$00$72$00$00
 $72$00$00$72$00$00$72$00$00$72$00$00
 $72$00$00$72$00$00$72$00$00$72$00$00
 $52$00$00$41$00$00]

PROC SetDL ()

BYTE u

 sdlstlsav=sdlstl
 sdlstl=displaylist

 dlstart=displaylist+4
 adr=0
 dlptr=dlstart

 FOR u=0 TO 24
 DO
  dlptr^=adr
  dlptr==+3
  adr==+40
 OD
  
 shscrol=2
 svscrol=4

RETURN

PROC ScrollUp ()

BYTE u

 svscrol==&$F ; Groessere Werte ausblenden
 svscrol==+1

; SYNCRONISATION MIT DEM VBI, VER-
; MEIDET FLACKERN!
 
 DO
 UNTIL vcount>120
 OD

; Scrollregister zuruecksetzen und
; Bildschirmspeicher scrollen

 IF svscrol>=8 THEN
  svscrol=0
  dlptr=displaylist+4
  FOR u=0 TO 24
  DO
   dlptr^==+40
   dlptr==+3
  OD
 FI

 vscrol=svscrol

RETURN

PROC ScrollDwn ()

BYTE u

 svscrol==&$F
 svscrol==-1

 DO
 UNTIL vcount>120
 OD

 IF svscrol=$FF THEN
  svscrol=7
  dlptr=displaylist+4
  FOR u=0 TO 24
  DO
   dlptr^==-40
   dlptr==+3
  OD
 FI

 vscrol=svscrol

RETURN

PROC ScrollLft ()

BYTE u

 shscrol==&7
 shscrol==-1

 DO
 UNTIL vcount>120
 OD

 IF shscrol<=0 THEN
  shscrol=4
  dlptr=displaylist+4
  FOR u=0 TO 24
  DO
   dlptr^==+1
   dlptr==+3
  OD
 FI

 hscrol=shscrol

RETURN

PROC ScrollRght ()

BYTE u

 shscrol==&7
 shscrol==+1
 
 DO
 UNTIL vcount>120
 OD

 IF shscrol>=4 THEN
  shscrol=0
  dlptr=displaylist+4
  FOR u=0 TO 24
  DO
   dlptr^==-1
   dlptr==+3
  OD
 FI

 hscrol=shscrol

RETURN

PROC Err (BYTE errnum)

 Graphics (0)
 DO
  PrintB (errnum)
 OD

RETURN
 
PROC Pause (BYTE times)

BYTE u

 FOR u=0 TO times
 DO
  DO
  UNTIL vcount<12
  OD
 OD
  
RETURN

PROC Main ()

BYTE sti

 Error=Err 

 SetDL ()
 
 DO
  sti=Stick(0) ! $F
  IF sti&2 THEN
   ScrollDwn ()
  FI
  IF sti&1 THEN
   ScrollUp ()
  FI
  IF sti&4 THEN
   ScrollLft ()
  FI
  IF sti&8 THEN
   ScrollRght ()
  FI

  Pause (1)

 UNTIL Strig(0)=0
 OD

Graphics (0)

RETURN

[Dr. Irata]

... von Janko kam gerade noch der Tip für die DL:

Code: Alles auswählen

dlist			.byte 112,112,112
dl1			.byte 68+32,248,18
:17			.byte 04+32
			.byte 04
			.byte 112
			.byte 66,112,17
:4			.byte 02
			.byte 65
			.word dlist

... damit scrollt man die letzte Reihe schön sanft rein!! Danke!

[Erhard]

Hi,

von Janko kam gerade noch der Tip für die DL:

bei Assembler Quellcodes bitte in eine der ersten Zeilen den verwendeten Assembler reinschreiben.

Zumindest ich erkenne nicht an der Art des Codes mal eben den verwendeten Assembler...

Ansonsten auf jeden Fall Danke.

Jetzt brauch ich nur noch Zeit das auszuprobieren ..

CU, Erhard

[Dr. Irata]

... gute Idee... ich nehme bekanntlich MADS

[Dr. Irata]

In den letzten Tagen habe ich noch an der Scrollroutine gearbeitet und sie etwas erweitert:
Man kann jetzt mit dem Joystick nach oben oder unten scrollen... dabei wird jeweils entweder oben oder unten per Zufall ein Zeichen geprintet.
Der Code funktioniert sehr stabil und absolut "ruckelfrei" - man muss schon ein wenig Aufwand treiben und sehr genau coden, um das so hinzubekommen.... bis ich den allerletzten Ruckler weg hatte, waren etliche kleine Stellschrauben nötig...
Der Gesamtaspekt ist dem von Peter Finzel gar nicht so unähnlich - scheinbar - allerdings viel komplexer. Peter Finzel läßt ja sein Scrolling nach oben und unten über einen ganz fest definierten Speicherbereich scrollen und wenn man zum jeweiligen Ende kommt, ist Feierabend!
Mein Code ist ohne Ende in beide Richtungen und kann sehr schön für einen Scroller genutzt werden. Man könnte nun sehr einfach statt der Zufallszeichen eine ganz definierte Landschaft printen. Das geht mit dem Code von Finzel nicht!

Code: Alles auswählen

; MADS Crossassembler
			
			
			org $4000
			
RANDOM   = $d20a
RTCLOK   = $0012
SDLSTL   = $0230
VSCROL   = $d405
STICK0   = $278
			
dlx = 240
dlx2 = 242

xrandom		.by 00
zaehler		.by 04
zaehlerbs	.by 00


		;----------------- BS1 Start bei 0/16  = 4096
		;                  BS1 Ende bei        = 4816
		;                  BS2 Start bei       = 4856
		;                  BS2 Ende bei        = 5576
		;                  DL Start bei 248/16 = 4856 
		;----- Antic 4 normales Spielfeld a 40 ------

dlist			.byte 112,112,112
dl1			.byte 68+32
dl			.byte 248,18
:17			.byte 04+32
			.byte 04
			.byte 112
			.byte 66,220,14
:3			.byte 02
			.byte 65
			.word dlist
			
			;-------------- Start Hauptprogramm -----------------------------	
			.proc main
start		
			lda <dlist 		; Adresse der Displaylist wird 
			sta sdlstl		; ins Register eingetragen
			lda >dlist 
			sta sdlstl+1
			
			
			lda #208
			sta dlx2
			lda #18
			sta dlx2+1
			lda #240
			sta dlx
			lda #21
			sta dlx+1
			
			lda #$66
			sta 708			;Farbe 1
			lda #$7f			
			sta 709			;Farbe 2
			lda #$00
			sta 710			;Farbe 3
			lda #$22
			sta 711			;Farbe 4 
			lda #$00
			sta 712			;Farbe 5 Hitergrund
			
			
			
loop			
			lda stick0
			cmp #13
			bne @+
			inc zaehler
		
@			lda stick0
			cmp #14
			bne @+
			dec zaehler
			
@			lda zaehler
			cmp #8
			bne @+
			jsr scrolup
			lda #0 
			sta zaehler
			
@			lda zaehler
			cmp #255
			bne @+
			jsr scroldown
			lda #7 
			sta zaehler

@			lda zaehler 
			sta vscrol
			jsr wartes
	
			jmp loop
			.endp
			.proc scroldown
		
			ldy #0
@			lda #0
			sta (dlx),y
			sta (dlx2),y
			iny
			cpy #40
			bne @-
		
			lda random
			lsr 
			clc
			adc #16
			lsr
			lsr
			tay
			lda #7
			sta (dlx),y
			sta (dlx2),y
		
			sec
			lda dl
			sbc #40
			sta dl
			lda dl+1
			sbc #0
			sta dl+1
		
			sec
			lda dlx
			sbc #40
			sta dlx
			lda dlx+1
			sbc #0
			sta dlx+1
			sec
			lda dlx2
			sbc #40
			sta dlx2
			lda dlx2+1
			sbc #0
			sta dlx2+1
			
			dec zaehlerbs
			lda zaehlerbs
			cmp #0
			bne @+
			jmp decr
@			lda zaehlerbs
			cmp #255
			bne @+
		
decr	
			lda #20 
			sta zaehlerbs
		
			lda #208
			sta dlx2
			lda #18
			sta dlx2+1
			lda #240
			sta dlx
			lda #21
			sta dlx+1
			lda #248 
			sta dl		
			lda #18 
			sta dl+1
@			
			rts
			.endp
			.proc scrolup
			
			ldy #40
@			lda #0
			sta (dlx),y
			sta (dlx2),y
			iny
			cpy #80
			bne @-
			clc
			lda dl1+1
			adc #40
			sta dl1+1
			bcc @+
			inc dl1+2
@
			clc
			lda dlx
			adc #40
			sta dlx
			bcc @+
			inc dlx+1
@
			clc
			lda dlx2
			adc #40
			sta dlx2
			bcc @+
			inc dlx2+1
@			
			lda random
			lsr 
			clc
			adc #16
			lsr
			lsr
			tay	
			lda #7
			sta (dlx),y
			sta (dlx2),y	
			inc zaehlerbs
			lda zaehlerbs
			cmp #20
			bne @+
			lda #0 
			sta zaehlerbs
			lda #208
			sta dlx
			lda #18
			sta dlx+1
			lda #240
			sta dlx2
			lda #21
			sta dlx2+1
			lda #248 
			sta dl	
			lda #18 
			sta dl+1
@
			rts
			.endp
			.proc wartes
			lda RTCLOK+2
loop5   
			cmp RTCLOK+2
        	beq loop5
        	rts
     		.endp  
     		
		
			run main

[Dr. Irata]

Hallo in die Runde,
ich habe jetzt diese gesamte Routine noch um eine relativ einfache horizontal scrolling Möglichkeit ergänzt.
Man kann jetzt zusätzlich noch um jeweils 10 Schritte nach links und rechts feinscrollen - also um insgesamt 20 Zeichen.
Wenn man das horizontale Feinscrolling implementiert, wird die Zeilenbreite von 40 auf 48 erhöht, um das auszugleichen (ich wollte jetzt für dieses Beispiel nicht die ganzen Adressen ändern) habe ich die Bildschirmbreite von 40 auf 32 reduziert (schmales Anzeigefeld) und somit die plus 8 ausgeglichen, ohne alles ändern zu müssen.
Dies ist jetzt der letzte Beitrag hinsichtlich vertikales (und damit auch gleichzeitig horizontales) Feinscrolling.
LG
Peter

Code: Alles auswählen

			; MADS Crossassembler
			
			
			org $4000
			
RANDOM   = $d20a
RTCLOK   = $0012
SDLSTL   = $0230
SDMCTL   = $022f
VSCROL   = $d405
HSCROL   = $d404
STICK0   = $278
			
dlx = 240
dlx2 = 242

xrandom		.by 00
zaehlerv	.by 04
zaehlerh	.by 04
zaehlerbs	.by 00
zaehlerhs   	.by 70


		;----------------- BS1 Start bei 0/16  = 4096
		;                  BS1 Ende bei        = 4816
		;                  BS2 Start bei       = 4856
		;                  BS2 Ende bei        = 5576
		;                  DL Start bei 248/16 = 4856 
		;----- Antic 4 schmales Spielfeld a 32 ------

dlist		.byte 112,112,112
dl1			.byte 68+32+16
dl			.byte 248,18
:17			.byte 04+32+16
			.byte 04+16
			.byte 112
			.byte 66,220,14
:3			.byte 02
			.byte 65
			.word dlist
			
			;-------------- Start Hauptprogramm -----------------------------	
			.proc main
start		
			lda <dlist 		; Adresse der Displaylist wird 
			sta sdlstl		; ins Register eingetragen
			lda >dlist 
			sta sdlstl+1
			dec sdmctl				;schmales Anzeigefeld 
			
			lda #208
			sta dlx2
			lda #18
			sta dlx2+1
			lda #240
			sta dlx
			lda #21
			sta dlx+1
			
			lda #$66
			sta 708			;Farbe 1
			lda #$7f			
			sta 709			;Farbe 2
			lda #$00
			sta 710			;Farbe 3
			lda #$22
			sta 711			;Farbe 4 
			lda #$00
			sta 712			;Farbe 5 Hitergrund
			
			
			
loop		
			
			lda stick0
			cmp#11
			bne weiter1
			lda zaehlerhs
			cmp #1
			bcc @+
			dec zaehlerhs
			dec zaehlerh
@
			lda zaehlerh
			cmp #255
			bne weiter1
			jsr scrolleft
			lda #7 
			sta zaehlerh
			
			
weiter1			
			lda stick0
			cmp #7
			bne weiter2
			
			lda zaehlerhs
			cmp #140
			bcs @+
			inc zaehlerhs
			inc zaehlerh
@
			lda zaehlerh
			cmp #8
			bne weiter2
			jsr scrolright
			lda #0 
			sta zaehlerh
			

weiter2
			
			lda stick0
			cmp #13
			bne @+
			inc zaehlerv
		
@			lda stick0
			cmp #14
			bne @+
			dec zaehlerv
			
@			lda zaehlerv
			cmp #8
			bne @+
			jsr scrolup
			lda #0 
			sta zaehlerv
			
@			lda zaehlerv
			cmp #255
			bne @+
			jsr scroldown
			lda #7 
			sta zaehlerv

@			lda zaehlerv 
			sta vscrol
			lda zaehlerh
			sta hscrol
			jsr wartes
	
			jmp loop
			.endp
			.proc scrolleft
			
			inc dl
			inc dl
				
			rts
			.endp
			.proc scrolright
			
			dec dl
			dec dl
			
			rts
			.endp
			.proc scroldown
		
			ldy #0
@			lda #0
			sta (dlx),y
			sta (dlx2),y
			iny
			cpy #40
			bne @-
		
			lda random
			lsr 
			clc
			adc #16
			lsr
			lsr
			tay
			lda #7
			sta (dlx),y
			sta (dlx2),y
		
			sec
			lda dl
			sbc #40
			sta dl
			lda dl+1
			sbc #0
			sta dl+1
		
			sec
			lda dlx
			sbc #40
			sta dlx
			lda dlx+1
			sbc #0
			sta dlx+1
			sec
			lda dlx2
			sbc #40
			sta dlx2
			lda dlx2+1
			sbc #0
			sta dlx2+1
			
			dec zaehlerbs
			lda zaehlerbs
			cmp #0
			bne @+
			jmp decr
@			lda zaehlerbs
			cmp #255
			bne @+
		
decr	
			lda #20 
			sta zaehlerbs
		
			lda #208
			sta dlx2
			lda #18
			sta dlx2+1
			lda #240
			sta dlx
			lda #21
			sta dlx+1
			lda #248 
			sta dl		
			lda #18 
			sta dl+1
@			
			rts
			.endp
			.proc scrolup
			
			ldy #48
@			lda #0
			sta (dlx),y
			sta (dlx2),y
			iny
			cpy #80
			bne @-
			clc
			lda dl
			adc #40
			sta dl
			bcc @+
			inc dl+1
@
			clc
			lda dlx
			adc #40
			sta dlx
			bcc @+
			inc dlx+1
@
			clc
			lda dlx2
			adc #40
			sta dlx2
			bcc @+
			inc dlx2+1
@			
			lda random
			lsr 
			clc
			adc #16
			lsr
			lsr
			tay	
			lda #7
			sta (dlx),y
			sta (dlx2),y	
			inc zaehlerbs
			lda zaehlerbs
			cmp #20
			bne @+
			lda #0 
			sta zaehlerbs
			lda #208
			sta dlx
			lda #18
			sta dlx+1
			lda #240
			sta dlx2
			lda #21
			sta dlx2+1
			lda #248 
			sta dl	
			lda #18 
			sta dl+1
@
			rts
			.endp
			.proc wartes
			lda RTCLOK+2
loop5   
			cmp RTCLOK+2
        	beq loop5
        	rts
     		.endp  
     		
		
			run main

[pps]

Ich hatte da beim kurzen Überfliegen den Eindruck, dass man einige kleine Optimierungen am Code vornehmen könnte. Ich hoffe, dass ich am Wochenende die Zeit finde, das genauer zu ergründen.

Ich mache in jedem Fall Meldung, wenn ich das gesichtet habe

[Dr. Irata]

... sehr gerne !!!!

[pps]

Code: Alles auswählen

			; MADS Crossassembler
			
			
			org $4000
			
RANDOM   = $d20a
RTCLOK   = $0012
SDLSTL   = $0230
SDMCTL   = $022f
VSCROL   = $d405
HSCROL   = $d404
STICK0   = $278
			
dlx = 240
dlx2 = 242

xrandom		.by 00
zaehlerv	.by 04
zaehlerh	.by 04
zaehlerbs	.by 00
zaehlerhs   	.by 70


		;----------------- BS1 Start bei 0/16  = 4096
		;                  BS1 Ende bei        = 4816
		;                  BS2 Start bei       = 4856
		;                  BS2 Ende bei        = 5576
		;                  DL Start bei 248/16 = 4856 
		;----- Antic 4 schmales Spielfeld a 32 ------

dlist			.byte 112,112,112
dl1			.byte 68+32+16
dl			.byte 248,18
:17			.byte 04+32+16
			.byte 04+16
			.byte 112
			.byte 66,220,14
:3			.byte 02
			.byte 65
			.word dlist
			
			;-------------- Start Hauptprogramm -----------------------------	
			.proc main
start		
			lda <dlist 		; Adresse der Displaylist wird 
			sta sdlstl		; ins Register eingetragen
			lda >dlist 
			sta sdlstl+1
			dec sdmctl				;schmales Anzeigefeld 
			
			lda #208
			sta dlx2
			lda #18
			sta dlx2+1
			lda #240
			sta dlx
			lda #21
			sta dlx+1
			
			lda #$66
			sta 708			;Farbe 1
			lda #$7f			
			sta 709			;Farbe 2
			lda #$00
			sta 710			;Farbe 3
			lda #$22
			sta 711			;Farbe 4 
			lda #$00
			sta 712			;Farbe 5 Hintergrund
			
			
			
loop		
			
			lda stick0
			cmp #11
			bne weiter1
			lda zaehlerhs
			beq @+			; 0 ist kleiner als 1
		;	cmp #1
		;	bcc @+			; := Wenn kleiner als 1 springe weiter.
			dec zaehlerhs
			dec zaehlerh
@
			lda zaehlerh
			beq weiter1		; := 0 oder "Plus" Flag gesetzt?
			bpl weiter1
		;	cmp #255
		;	bne weiter1		; := kleiner als 0, dann weiter
			jsr scrolleft
			lda #7 
			sta zaehlerh
			
			
weiter1			
			lda stick0
			cmp #7
			bne weiter2
			
			lda zaehlerhs
			cmp #140
			bcs @+
			inc zaehlerhs
			inc zaehlerh
@
			lda zaehlerh
			cmp #8
			bne weiter2
			jsr scrolright
			lda #0 
			sta zaehlerh
			

weiter2
			
			lda stick0
			cmp #13
			bne @+
			inc zaehlerv
		
@			lda stick0
			cmp #14
			bne @+
			dec zaehlerv
			
@			lda zaehlerv
			cmp #8
			bne @+
			jsr scrolup
			lda #0 
			sta zaehlerv
			
@			lda zaehlerv
			beq @+			; Programm läuft auch ohne dieses beq, dann spart man 2 Bytes
			bpl @+
		;	cmp #255
		;	bne @+			; := nicht kleiner als 0, dann weiter
			jsr scroldown
			lda #7 
			sta zaehlerv

@			lda zaehlerv 
			sta vscrol
			lda zaehlerh
			sta hscrol
			jsr wartes
	
			jmp loop
			.endp
			.proc scrolleft
			
			inc dl
			inc dl
				
			rts
			.endp
			.proc scrolright
			
			dec dl
			dec dl
			
			rts
			.endp
			.proc scroldown
		
		;	ldy #0
			ldy #39			; Loop gedreht, spart 2 Byte und etwas Zeit
@			lda #0
			sta (dlx),y
			sta (dlx2),y
		;	iny
		;	cpy #40
		;	bne @-
			dey
			bpl @-
		
			lda random
			lsr 
			clc
			adc #16
			lsr
			lsr
			tay
			lda #7
			sta (dlx),y
			sta (dlx2),y
		
			sec
			lda dl
			sbc #40
			sta dl
			lda dl+1
			sbc #0
			sta dl+1
		
			sec
			lda dlx
			sbc #40
			sta dlx
			lda dlx+1
			sbc #0
			sta dlx+1
			sec
			lda dlx2
			sbc #40
			sta dlx2
			lda dlx2+1
			sbc #0
			sta dlx2+1
			
			dec zaehlerbs
			lda zaehlerbs
		;	cmp #0			; unnötig
			bne @+
			jmp decr
@			lda zaehlerbs
			beq @+			; Programm läuft auch ohne dieses beq, dann spart man 2 Bytes
			bpl @+
		;	cmp #255
		;	bne @+			; := nicht kleiner als 0, dann weiter
		
decr	
			lda #20 
			sta zaehlerbs
		
			lda #208
			sta dlx2
			lda #18
			sta dlx2+1
			lda #240
			sta dlx
			lda #21
			sta dlx+1
			lda #248 
			sta dl		
			lda #18 
			sta dl+1
@			
			rts
			.endp
			.proc scrolup
			
			ldy #48
@			lda #0
			sta (dlx),y
			sta (dlx2),y
			iny
			cpy #80
			bne @-
			clc
			lda dl
			adc #40
			sta dl
			bcc @+
			inc dl+1
@
			clc
			lda dlx
			adc #40
			sta dlx
			bcc @+
			inc dlx+1
@
			clc
			lda dlx2
			adc #40
			sta dlx2
			bcc @+
			inc dlx2+1
@			
			lda random
			lsr 
			clc
			adc #16
			lsr
			lsr
			tay	
			lda #7
			sta (dlx),y
			sta (dlx2),y	
			inc zaehlerbs
			lda zaehlerbs
			cmp #20
			bne @+
			lda #0 
			sta zaehlerbs
			lda #208
			sta dlx
			lda #18
			sta dlx+1
			lda #240
			sta dlx2
			lda #21
			sta dlx2+1
			lda #248 
			sta dl	
			lda #18 
			sta dl+1
@
			rts
			.endp
			.proc wartes
			lda RTCLOK+2
loop5   
			cmp RTCLOK+2
 		       	beq loop5
        		rts
     			.endp  
     		
		
			run main

So, hier meine kleinen Anpassungen. Das Programm ist dadurch, statt 495 Bytes "nur" noch 489 Bytes groß, kommentiert man noch die beiden BEQ @+ aus, sogar nur noch 485 Bytes. Einen Hauch schneller wird es sicherlich auch, was bei größeren Aktionen sicherlich auch nicht unwichtig ist.

Edit: Mir ist gerade noch aufgefallen, dass es Sprünge gibt, wenn man Rechts/Links gescrollt hatte und dann Hoch und Runter etwas weiter scrollt. Das liegt nicht an meinen Änderungen. Das muss man sich also nochmal genauer anschauen, wenn man beide Scrollrichtungen haben möchte.

[Dr. Irata]

... ja, er springt weil ich relativ einfach beim scrollen nach rechts und links den Wert von dl hochsetze oder runtersetze. Da bekomme ich natürlich einen rechts bzw links - Versatz. Wenn ich dann zusätzlich hoch- und runterscrolle und nach 20 Zeilen den dl-Wert rücksetze, dann passt das natürlich mit dem Seitversatz nicht mehr. Das müsste man entsprechend mit einberechnen....
Wer Lust und Zeit hat, kann sich gerne daran verdingen...