
 CORSO DI ASSEMBLER - LEZIONE 3

Ora procederemo nella pratica, ma prima vi consiglio di caricarvi in un
buffer di testo il file 68000.TXT che  un riassunto della lezione2. Questo
potr esservi utile nel caso che non ricordaste un indirizzamento o una
istruzione leggendo i listati di questa lezione, che presuppongono la
familiarit con gli indirizzamenti e le istruzioni affrontate prima.
Il quel testo sono spiegati tutti gli indirizzamenti, anche quelli che non
sono quasi mai usati, dunque leggetelo ma non preoccupatevi se non capite
gli indirizzamenti con INDICE, tanto nella lezione3 non saranno usati!

In questa lezione si comincia a visualizzare qualcosa sullo schermo: per
fare questo dobbiamo scrivere una COPPERLIST, cio un programma per il
chip COPPER che si occupa della grafica, che abbiamo gi usato per
cambiare di colore lo schermo ($dff180  un registro del copper, che si
chiama COLOR00).
Per ora per abbiamo solo fatto delle modifiche col processore
direttamente nei registri, e come avete potuto notare eseguendo i listati
con AD un istruzione alla volta, quando mettiamo un valore nel COLOR00 (ossia
$dff180) avviene solo un brevissimo lampo, e subito torna il colore normale del
sistema operativo, ossia dell'ASMONE. Solo facendo un ciclo in cui si
immette continuamente un numero si pu colorare tutto lo schermo, ma una
volta usciti dal programmino il colore ritorna inesorabilmente quello
normale. Questo avviene perch lo schermo che vediamo con finestre, scritte
e tutto il resto  il frutto di una COPPERLIST, e precisamente di una
COPPERLIST di sistema. La copperlist non  altro che una specie di:

	MOVE.W	#$123,$dff180	; COLOR00 - immetti il colore 0
	MOVE.W	#$123,$dff182	; COLOR01 - immetti il colore 1
	eccetera...

Che viene eseguito continuamente, quindi ecco spiegato perch se col
processore cambiamo il colore subito torna quello di sistema: perch
la copperlist ridefinisce ogni cinquantesimo di secondo tutti i colori!!!!
Intuirete che per visualizzarsi delle figure in pace non  possibile
continuare a fare loop tentando di combattere con la copperlist di sistema
che ridefinisce simultaneamente tutto, ma dovremo togliere di mezzo
la copperlist di sistema e farcene una tutta nostra. NIENTE DI PI FACILE!
Come ho gipremesso, la copperlist non  altro che una sfilza di MOVE
che mettono dei valori nei registri del COPPER, ossia quelli $dffxxx;
comunque non sono dei move fatti col processore, ma fatti dal copper
stesso, che, non a caso, esegue questa COPPERLIST indipendentemente mentre
col processore stiamo facendo altre cose... questo  uno dei motivi per
cui su PC non hanno LIONHEARTH o PROJECT X dell'Amiga.
Dovremo quindi scrivergli proprio un LISTATO, come facciamo per il 68000,
dopodich dovremo informare il COPPER dove si trova il nostro per farglielo
leggere ed eseguire al posto di quello del WorkBench.
Il copper ha SOLO 3 istruzioni, di cui in pratica ne vengono usate solo 2:
le due usate sono il MOVE ed il WAIT; quella che non usa nessuno  lo
SKIP, quindi di quella ne parleremo solo se la troveremo in un listato
di esempio.
Il MOVE  FACILISSIMO: avete presente un:

	MOVE.W	#$123,$dff180	; Immetti il colore RGB nel COLOR00

Si traduce in copperlist in:

	dc.w	$180,$123	; si mettono in memoria direttamente i
				; numeri col dc.w, tanto basta
				; impararci 2 istruzioni solamente!

Ossia: si deve mettere prima l'indirizzo di destinazione, senza il $dff
come abbiamo gi visto quando mettiamo $dff000 in a0, basta fare $180(a0):
allo stesso modo i progettisti hanno pensato bene di risparmiarci la
fatica di fare $DFF tutte le volte e cos basta mettere il $180, o il
$182 o qualsiasi altro registro del COPPER, infatti SOLO i registri del
Copper possono essere scritti dalla COPPERLIST, e si pu accedere solo
ai registri PARI, come $180,$182... mai $181,$183!!!!, inoltre potete
modificare solo una WORD alla volta. Come avete visto, la COPPERLIST non
viene assemblata come i comandi del 68000 che vengono trasformati da
ISTRUZIONI come RTS, MOVE.. a $4e75, etc., bens si devono mettere i BYTES come
sono realmente in memoria e come sono letti dal coprocessore COPPER: per la
COPPERLIST appunto dobbiamo usare il comando DC per metterla in memoria a
forza di BYTES, ma  facilissimo. Per esempio per definire i primi 4 colori:

COPPERLIST:
	dc.w	$180,$000	; COLORE 0 = NERO
	dc.w	$182,$f00	; COLORE 1 = ROSSO
	dc.w	$184,$0F0	; COLORE 3 = VERDE
	dc.w	$186,$00F	; COLORE 4 = BLU

Vi ricordate come  il formato dei colori? RGB=RED, GREEN, BLU.
Per avere un aiuto in ogni momento sul significato dei registri $dffXXX
fate "=C 180" oppure "=C numero" e avrete un breve riassunto (in inglese).
Per esempio fate "=c 006" e vedrete il nome e la spiegazione del registro
che avete usato per far lampeggiare il colore. Per vedere tutti i registri
fate semplicemente un "=C".

Il WAIT invece serve per aspettare una certa linea dello schermo, ad esempio
se si vuol fare il colore di sfondo (color0) nero fino a met, mentre
nella met inferiore si vuole blu, basta mettere un

	dc.w	$180,0		; colore 0 NERO

seguito da un WAIT che aspetta la met dello schermo, dopodich

	dc.w	$180,$00F	; colore 0 BLU

Con questo stratagemma si pu cambiare l'intera palette (i colori) a qualsiasi
linea del video, cosa che invece su PC in VGA nemmeno si sognano, infatti
anche se i giochi Amiga solitamente hanno schermi di soli 32 colori,
cambiando la tavolozza dei colori ogni tanto man mano che lo schermo scende
si possono fare pi tonalit di una VGA a 256 colori, specialmente se
si considera che con un solo colore di sfondo si pu fare una sfumatura
cambiando il colore ad ogni linea, come faremo nel primo listato di
questa lezione. Il comando WAIT si presenta in questa forma:

	dc.w	$1007,$FFFE	; WAIT coordinata X= $10, Y= $07

Questo comando sognifica: ATTENDI LA LINEA ORIZZONTALE $10, colonna 7 (cio
al settimo punto a partire da sinistra; i punti sono detti PIXEL).
Il $FFFE significa WAIT, e va messo comunque tutte le volte, mentre il
primo byte  la linea orizzontale (x) da aspettare e il secondo  quella
verticale (y).
Lo schermo infatti  fatto di molti punti disposti l'uno accanto all'altro,
come un foglio a quadretti molto piccoli, ad esempio la carta millimetrata.
Per indicare il punto (pixel) situato (come nella battaglia navale) alla
posizione 16,7, ossia a 16 punti dal bordo superiore del foglio verso il
basso e 7 dal bordo sinistro verso destra, indichero $1007. ($10=16!).
Di solito basta indicare la linea orizzontale al suo inizio, (la posizione
e` $07 anzich $01 perch tanto quest'ultima  fuori del monitor all'estrema
sinistra).
L'istruzione WAIT  usata anche per terminare la COPPERLIST: infatti
per indicare la fine della COP va messo un

	dc.w	$FFFF,$FFFE	; Fine Copperlist

Che per convenzione il Copper considera la fine, anche perch indica di
attendere una linea che non esiste! (la copperlist poi riparte da capo).
Si  sparsa la voce tempo fa che sarebbero necessarie due istruzioni di fine
copperlist anzich una sola per alcuni vecchi modelli di Amiga, ma sembra
sia una psicosi di massa, dato che nessuno ne ha mai messe due e ha sempre
funzionato tutto.

Un ultima cosa: per fare la nostra copperlist che per ora  priva di
disegni, ha solo sfumature, bisogna disabilitare i BITPLANE, ovvero
i PIANI di BIT che sovrapponendosi danno luogo alle figure.
per fare questo basta aggiungere la linea DC.W $100,$200, ossia mettiamo
il valore $200 nel $dff100, che  il registro di controllo dei bitplane.

ORA SIAMO IN GRADO DI FARE COMPLETAMENTE LA COPPERLIST CHE ASPETTA LA
MET DEL VIDEO E CAMBIA IL COLORE!

COPPERLIST:
	dc.w	$100,$200	; BPLCON0 Nessuna figura, solo lo sfondo
	dc.w	$180,0		; Color 0 NERO
	dc.w	$7f07,$FFFE	; WAIT - Aspetta la linea $7f (127)
	dc.w	$180,$00F	; Color 0 BLU
	dc.w	$FFFF,$FFFE	; FINE DELLA COPPERLIST

COnsiderando che per verificare il funzionamento delle vostre copperlist
dovrete fare delle sfumature di colore, ecco una TABELLA DI RIFERIMENTO PER
LA SCELTA DEI COLORI COL COPPER:

L'Amiga ha 32 registri colore per 32 colori diversi:

	$dff180		; color0 (sfondo)
	$dff182		; color1
	$dff184		; color2
	$dff186		; color3
	...
	$dff1be		; color31

In ognuno si questi 32 registri colore si pu selezionare uno dei 4096 colori
visualizzabili, "mischiando" i 3 colori fondamentali ROSSO,VERDE,BLU.
Ognuno di questi 3 colori pu avere una intensit da 0 a 15, ossia 16 toni.
Infatti il massimo numero di combinazioni  16*16*16=4096, ossia 16 ROSSI
moltiplicato 16 VERDI moltiplicato 16 BLU.
Il valore del colore si pu mettere col processore o col COPPER:

	move.w	#$000,$dff180	; colore NERO in color0

	dc.w	$180,$FFF	; colore BIANCO in color0

In questo esempio abbiamo visto i due estremi: $FFF, ossia BIANCO, e $000,
ossia NERO. Per scegliere il colore infatti occorre tener presente che la
WORD del colore  composta cos:

	dc.w	$0RGB

	dove il quarto zero  inutilizzato, mentre:

	R	=	componente ROSSA (RED)
	G	=	componente VERDE (GREEN)
	B	=	componente BLU   (BLU)

Infatti i bit dal 15 al 12 non sono utilizzati, i bit dall'11 all'8 sono il
ROSSO, quelli dal 7 al 4 sono il VERDE, quelli dal 3 allo 0 sono il BLU.

Ogni colore RGB come gi detto pu avere un valore da 0 a 15, ossia da 0
a $F in esadecimale, dunque  facile scegliere il colore:

	$FFF	=	Bianco
	$D00	=	Rosso mattone
	$F00	=	Rosso
	$F80	=	Rosso-Arancio
	$F90	=	Arancione
	$fb0	=	Giallo-oro
	$fd0	=	Giallo-Cadmio
	$FF0	=	Limone
	$8e0	=	Verde chiaro
	$0f0	=	Verde
	$2c0	=	Verde scuro
	$0b1	=	Verde albero
	$0db	=	Acqua
	$1fb	=	Acqua chiaro
	$6fe	=	Blu cielo
	$6ce	=	Blu chiaro
	$00f	=	Blu
	$61f	=	Blu brillante
	$06d	=	Blu scuro
	$c1f	=	Violetto
	$fac	=	Rosa
	$db9	=	Beige
	$c80	=	Marrone
	$a87	=	Marrone scuro
	$999	=	Grigio medio
	$000	=	nero


Ora il problema  solo come costringere il copper ad eseguire ordini dalla
nostra COPPERLIST sviando la sua attenzione da quella del WorkBench; ma
c' anche un altro problema: se facciamo eseguire la nostra, come facciamo
dopo essere usciti a fargli rileggere quella di sistema???
risposta: Bisogna segnarsi su un foglietto dove era!!!
Ovvero: lo segnamo in un apposita longword denominata OLDCOP, ovvero
VECCHIA COPPERLIST, quella di sistema.
Ma a chi lo dobbiamo chiedere dove  la copperlist di sistema? al sistema
operativo ovviamente!! Per chiederglielo dovremo eseguire delle routines
che sono nel CHIP del kickstart!!! Per fare questo bisogna sempre
prendere come riferimento l'indirizzo che si trova nell'indirizzo $4, che
viene scritto dal kickstart e contiene appunto l'indirizzo da cui si possono
fare le distanze di indirizzamento prefissate, di cui parleremo in seguito.
per raccogliere la long all'indirizzo $4 basta fare un:

	MOVE.L	$4,a6	; In a6 ora abbiamo l'ExecBAse

O meglio

	MOVE.L	4.w,a6	; Infatti 4  un numero piccolo e si pu scrivere
			; 4.w, il che risparmia spazio. (scrive l'istruzione
			; con $0004 invece di scriverla con $00000004, in cui
			; i primi zeri non servono. VIENE COMUNQUE SPOSTATA
			; UNA LONGWORD! la long contenuta nei 4 bytes 4,5,6,7.

Messo l'indirizzo che era contenuto in $4 in a6, possiamo eseguire le
routines del kickstart facendo dei JSR con la distanza di indirizzamento
giusta, infatti esistono delle distanze di indirizzamento precise che
corrispondono a certe routines gi pronte nel kickstart.
Ora sappiamo che se facciamo, ad esempio, un JSR -$78(a6) disabilitiamo
il multitasking!!! Ovvero viene eseguito solo il nostro programma!
facciamolo subito! Caricate LEZIONE3a.s in un buffer Fx ed eseguitelo.

Per la Exec non si occupa di tutto: il kickstart, lungo 256k se  la
versione 1.2 o 1.3, oppure lungo 512k se  2.0 o 3.0,  diviso in
library, ossia delle "raccolte" di routine gi pronte che possono essere
chiamate, e siccome ogni kickstart  diverso proprio fisicamente, nel
senso che ad esempio la routine della Exec che disabilita il sistema
operativo nel kick 1.3 potrebbe essere a $fc1000, mentre nell'1.2 o nel 2.0
a diversi indirizzi ancora, i cari progettisti hanno avuto una delle
loro clamorose idee: "PERCH NON METTIAMO UN INDIRIZZO ALLA LOCAZIONE 4
DA CUI SI POSSA SEMPRE ESEGUIRE LA STESSA ROUTINE FACENDO UN JSR ALLO STESSO
OFFSET (OVVERO DISTANZA DI INDIRIZZAMENTO)? (P.S. JSR  come BSR, solo che
pu eseguire routines in qualsiasi parte della memoria, mentre il bsr le
pu eseguire se sono entro 32768 bytes in avanti o indietro).

Ed  questo quello che hanno fatto! Per eseguire ad esempio il Disable,
che disabilita il sistema operativo, su tutti i kickstart basta fare:

	move.l	4.w,a6		; Indirizzo della Exec in a6
	jsr	-$78(a6)	; Disable - blocca multitask
	bsr.w	mioprogramma
	jsr	-$7e(a6)	; Enable - riabilita multitask

In ogni kickstart la routine sar ad un indirizzo diverso, ma facendo in
questo modo siamo sempre sicuri di eseguire quella routine.
Basta sapere tutte le distanze di indirizzamento delle varie routines
del sistema operativo per eseguirle, ma a noi interessa soltanto di
salvare l'indirizzo della copperlist di sistema, e per farlo dobbiamo
rivolgerci ad una parte delle routines del kick che si chiama:
graphics.library, ossia quella che si occupa della GRAFICA, sia chiaro solo
a livello di sistema operativo, non a livello hardware.
Per accedere alla libreria grafica va APERTA, ossia dobbiamo fare cos:

	move.l	4.w,a6		; Execbase in a6
	lea	GfxName,a1	; Indirizzo del nome della lib da aprire in a1
	jsr	-$198(a6)	; OpenLibrary, routine della EXEC che apre
				; le librerie, e da in uscita l'indirizzo
				; di base di quella libreria da cui fare le
				; distanze di indirizzamento (Offset)
	move.l	d0,GfxBase	; salvo l'indirizzo base GFX in GfxBase
	....

GfxName:
	dc.b	"graphics.library",0,0	; NOTA: per mettere in memoria
					; dei caratteri usare sempre il dc.b
GfxBase:				; e metterli tra "", oppure ''
	dc.l	0

In questo caso abbiamo usato la routine della Exec OpenLibrary che richiede
che sia messo in A1 l'indirizzo del testo con il nome della libreria da
aprire. Per esempio potevamo aprire altre librerie come "dos.library" per
caricare dei file o simili, "intuition.library" per aprire finestre ecc.
Una volta eseguita al ritorno da in d0 l'indirizzo della libreria in
questione, per intenderci un indirizzo come GfxBase da cui fare dei JSR
con degli offset a proposito della grafica. Oltre ai JSR, sappiamo anche
che, per esempio, l'indirizzo della COPPERLIST di sistema attuale 
situata a $26 bytes dopo il GfxBase, quindi continueremo il nostro
programma salvando quell'indirizzo in una label OldCop:

	move.l	4.w,a6		; Execbase in a6
	lea	GfxName,a1	; Indirizzo del nome della lib da aprire in a1
	jsr	-$198(a6)	; OpenLibrary, routine della EXEC che apre
				; le librerie, e da in uscita l'indirizzo
				; di base di quella libreria da cui fare le
				; distanze di indirizzamento (Offset)
	move.l	d0,GfxBase	; salvo l'indirizzo base GFX in GfxBase
	move.l	d0,a6
	move.l	$26(a6),OldCop	; salviamo l'indirizzo della copperlist
	....			; di sistema

GfxName:
	dc.b	"graphics.library",0,0	; NOTA: per mettere in memoria
					; dei caratteri usare sempre il dc.b
GfxBase:				; e metterli tra "", oppure ''
	dc.l	0

OldCop:
	dc.l	0

Ora possiamo puntare la nostra copperlist, possiamo mettere un MouseWait
e dopo ristabilire la vecchia cop; per puntare intendo mettere l'indirizzo
della nostra copperlist nel registro COP1LC, ossia $dff080, che  il
puntatore alla copperlist nel senso che il copper esegue la copperlist il
cui indirizzo si trova in $dff080: baster dunque mettere l'indirizzo in
$dff080, poi per far partire la copperlist basta scrivere nel registro
$dff088 (COPJMP1) qualsiasi cosa, basta che ci si scriva o che si legga che fa
partire la copperlist,  un registro detto STROBE, come fosse un bottone
che basta toccarlo (NON USATE PER CLR.W $dff088, da dei problemi).
Verr cos eseguita ripetutamente ogni fotogramma la nostra copperlist fino
a che non ne sar messa un'altra nel $dff080 (COP1LC).
Un problema  che il $dff080  a sola scrittura, infatti se provare a fare
un "=c 080" noterete il W di WRITE.
Per poter rimettere a posto la copperlist di sistema, quella che visualizza
l'asmone o il workbench, non potendone leggere l'indirizzo dal $dff080, dovremo
chiedere al sistema operativo quale ci ha messo, e questo si pu fare
con delle routine del kickstart: una volta ottenuto l'indirizzo di quella
copperlist lo salveremo in una LONGWORD del nostro programma, poi punteremo
la nostra copperlist, e all'uscita del programma rimetteremo a posto quella
vecchia.

	move.l	4.w,a6		; Execbase in a6
	jsr	-$78(a6)	; Disable - ferma il multitasking
	lea	GfxName,a1	; Indirizzo del nome della lib da aprire in a1
	jsr	-$198(a6)	; OpenLibrary, routine della EXEC che apre
				; le librerie, e da in uscita l'indirizzo
				; di base di quella libreria da cui fare le
				; distanze di indirizzamento (Offset)
	move.l	d0,GfxBase	; salvo l'indirizzo base GFX in GfxBase
	move.l	d0,a6
	move.l	$26(a6),OldCop	; salviamo l'indirizzo della copperlist
				; di sistema
	move.l	#COPPERLIST,$dff080	; COP1LC - Puntiamo la nostra COP
	move.w	d0,$dff088		; COPJMP1 - Facciamo partire la COP
mouse:
	btst	#6,$bfe001
	bne.s	mouse

	move.l	OldCop(PC),$dff080	; COP1LC - Puntiamo la cop di sistema
	move.w	d0,$dff088		; COPJMP1 - facciamo partire la cop

	move.l	4.w,a6
	jsr	-$7e(a6)	; Enable - riabilita il Multitasking
	move.l	gfxbase(PC),a1	; Base della libreria da chiudere
				; (vanno aperte e chiuse le librerie!!!)
	jsr	-$19e(a6)	; Closelibrary - chiudo la graphics lib
	rts

GfxName:
	dc.b	"graphics.library",0,0	; NOTA: per mettere in memoria
					; dei caratteri usare sempre il dc.b
GfxBase:				; e metterli tra "", oppure ''
	dc.l	0

OldCop:
	dc.l	0

COPPERLIST:
	dc.w	$100,$200	; BPLCON0 - Nessuna figura, solo lo sfondo
	dc.w	$180,0		; Color 0 NERO
	dc.w	$7f07,$FFFE	; WAIT - Aspetta la linea $7f (127)
	dc.w	$180,$00F	; Color 0 BLU
	dc.w	$FFFF,$FFFE	; FINE DELLA COPPERLIST

Troverete questo esempio con suggerimenti e modifiche in Lezione3b.s
Caricatevelo nel buffer F2 o un altro qualsiasi ed ammirate il primo
programma del corso che "BATTE NEL METALLO" dei CHIP dell'Amiga.

Avete fatto i vostri esperimenti sulla copperlist? Bene, ora vediamo di
fare qualche effetto in movimento. Per cominciare per devo informarvi che
per fare un qualsiasi movimento bisogna sincronizzare le routines con il
pennello elettronico che ridisegna lo schermo. Per chi non lo sapesse infatti
lo schermo viene ridisegnato 50 volte al secondo, e i movimenti che ci appaiono
fluidi, ad esempio quelli dei videogames meglio programmati, sono spostamenti
che coincidono con il cinquantesimo di secondo. Abbiamo gi usato il registro
$dff006, che come abbiamo visto cambia di valore continuamente, proprio
perch c' la posizione del pennello elettronico, il quale parte da zero,
ossia dalla parte pi alta dello schermo, e arriva in fondo 50 volte al
secondo. Se facciamo una routine che fa dei movimenti sul video senza
temporizzarla, andr alla velocit effettiva del processore, dunque troppo
veloce per vedere qualcosa. Per attendere una certa linea video basta leggere
il primo byte del $dff006, in cui troviamo la linea raggiunta, ossia la
posizione verticale (uguale al WAIT del COPPER):

WaitLinea:
	CMPI.B	#$f0,$dff006	; VHPOSR - Siamo alla linea $f0? (240)
	bne.s	WaitLinea	; se no, ricontrolla
	...

questo ciclo aspetta la linea 240, dopodich l'esecuzione continua con
le istruzioni seguenti, come la routine del Mouse che aspetta la pressione
del tasto, dopodich continua l'esecuzione. Inseriamo anche il WaitMouse:

mouse:
	cmpi.b	#$f0,$dff006	; VHPOSR - Siamo alla linea 240?
	bne.s	mouse		; Se non ancora, non andare avanti

	bsr.s	RoutineTemporizzata	; Questa routine viene eseguita 1
					; volta sola per ogni fotogramma

	bsr.s	MuoviCopper	; Il primo movimento sullo schermo!!!!!
	btst	#6,$bfe001	; tasto sinistro del mouse premuto?
	bne.s	mouse		; se no, torna a mouse:
	rts

A questo punto abbiamo una routine che esegue una routine 1 sola volta per
ogni FRAME video, ossia per ogni fotogramma, ossia 1 volta ogni cinquantesimo
di secondo, e pi esattamente viene eseguita non appena siamo arrivati alla
linea 240, dopodich, una volta eseguita, non sar eseguita nuovamente
fino a ch non saremo nuovamente alla linea 240, il fotogramma successivo.

NOTA: L'immagine viene disegnata con la tecnica RASTER tramite un pennello
elettronico, che parte a disegnare dalla prima linea in alto a sinistra,
prosegue verso destra fino alla fine della linea, poi riparte dall'estrema
sinistra della linea 2, per andare verso destra ecc, analogamente al
percorso che facciamo noi per leggere: ogni linea da sinistra verso destra,
partendo dalla prima in altro fini all'ultima in basso, DOPODICH il
pennello eletronico riparte dalla prima linea, primo punto a sinistra, come
se noi avendo finito di leggere una pagina di libro ricominciassimo a leggerla
anzich leggere la pagina seguente. D'altronde il monotor  uno solo e
deve scrivere su quello solamente, il pennello non scrive sul muro.

Caricatevi l'esempio LEZIONE3c.s in un altro buffer di testo e provatelo.
Questo esempio fa muovere in basso una WAIT e quindi il colore seguente
quando premete il tasto destro del mouse. Tasto sinistro per uscire.

Avete compreso Lezione3c.s? Allora complichiamo leggermente le cose! Caricate
la Lezione3c2.s in un buffer e studiatelo, ho aggiunto un controllo della linea
raggiunta per fermare lo scroll.

Tutto chiaro in Lezione3c2.s?? Bene, continuiamo con la pratica caricando la
Lezione3c3.s, in cui viene spostata una barretta sfumata fatta con 10 wait
anzich una sola linea WAIT. Sempre pi difficile!!!

Siete sempre vivi dopo la Lezione3c3.s? Massacratevi il cervello con la lezione
seguente, la Lezione3c4.s, in cui passiamo da 10 label BARRA ad una sola label
eseguendo delle distanze di indirizzamento.

Beh, non era poi cos difficile. Il difficile viene ora con Lezione3d.s, in
cui la barra va su e gi, e cambieremo anche la velocit della barra.

Avete capito Lezione3d.s? Si? Non ci credo! Vi sembra di aver capito, non pu
essere.... io lo rivedrei un attimo prima di proseguire... lo avere rivisto?
Beh... allora caricatevi una variazione sul tema, Lezione3d2.s

Ora siete pronti per affrontare la Lezione3e.s, in cui  spiegato come fare
una RASTERBAR ossia un effetto di scorrimento ciclico dei colori.

Un altro caso particolare: Come si fa a raggiungere la zona PAL (dopo $FF)
con i wait del copper in Lezione3f.s.

Per completare la lezione3.txt, caricatevi la Lezione3g.s, e Lezione3h.s,
concernenti uno scorrimento a destra e sinistra anzich in basso ed in alto,
dopodich sarete pronti per la LEZIONE4.TXT, in cui sar trattata la gestione
delle immagini colorate e dei possibili effetti su di esse! 


NOTA:
Gli Esempi4x.s della LEZIONE4.TXT si trovano nella directory SORGENTI2,
dunque dovete fare un "V DF0:SORGENTI2" per rendere possibile il caricamento
delle immagini da quella directory. Dopodich caricate la LEZIONE4.TXT in
questo o in un altro buffer di testo. (con "r")

* Complimenti per essere arrivati qua! Il grosso  fatto! Ora andando avanti
capirete con facilit, essendo entrati nella logica della programmazione ASM!.

