C64 Bedtime Coding (ITA) – PrintAT e Colore (#10)

(Article by Phaze101)

PrintAT e Colore

Aggiornamento

Mi chiedevo come poter gestire il supporto in relazione a questi articoli. In passato ho fornito supporto a tutti quelli che mi hanno scritto un messaggio email, contattato via FB o Reddit, chiesto aiuto in uno dei siti dove gli articoli sono stati pubblicati e cosi via. È stata molto complicato da gestire poiché le richieste arrivavano da troppi posti differenti e in qualche occasione, ne ho perso traccia.

Ho quindi deciso di cambiare qualcosa. Mi prende troppo tempo. Ho deciso che dall’articolo 11 in poi, la sola via per richiedere supporto è unirsi al gruppo Phaze101 Facebook e commentare sotto l’articolo. Questo mi darà visibilità di tutte le questioni, richieste o commenti in un unico posto.

Inoltre, gli aggiornamenti che farò di volta in volta sui precedenti articoli, saranno fatti solo nei documenti PDF. Questi saranno reperibili nel gruppo FB Phaze101 sotto la sezione file e nel gruppo FB RetroProgramming Italia (RPI) sotto la sezione file. Il gruppo FB Phaze101 manterrà le versioni in inglese degli articoli e gli aggiornamenti. Analogamente, il gruppo FB RetroProgramming Italia (RPI) manterrà entrambe le versioni, inglese e italiano, e tutti i rispettivi aggiornamenti. Non aggiornerò altro eccetto questi documenti.

Per tenere traccia degli aggiornamenti, ho incluso nel template PDF dell’articolo il numero di versione.

Così facendo, le cose dovrebbero essere più semplici gestendo tutto in un unico posto o al massimo due.

Il futuro di questi articoli

Mi piace mantenere le cose semplici e spero di aver raggiunto questo obiettivo. Mi piace anche usare un inglese semplice perché penso che molti di voi, non di madre lingua inglese, possono leggere l’articolo. Infine, non meno importante, mi piace scrivere in una forma che sembri che vi stia parlando direttamente.

Detto questo, questi articoli e il prossimo saranno sempre gratuiti e non andrò su Patreon per chiedere il vostro supporto. Semplicemente amo quello che faccio e mi piacerebbe aiutare quelli che veramente vogliono imparare.  Tutto questo materiale rappresenta proprio quello che quando ero giovane mi è mancato e ho dovuto imparare tutto seguendo la strada più difficile.

Quando il mio amore per questi articoli svanirà, non ne usciranno più. Fino a quel momento gli articoli continueranno il loro flusso con la speranza che riusciranno a coprire gli argomenti più avanzati in futuro.

È difficile adesso rilasciare questi articoli frequentemente, tuttavia come anticipato molte volte, il sabato pomeriggio saranno rilasciati, basta che non chiediate quale sabato 😊.

Ok, cominciamo.

PrintAT  – prosegue

 

PrintAT – Esempio 1

Nell’ultimo nostro articolo PrintAT la routine stampava una stringa al centro dello schermo. La lunghezza massima della stringa è 256 caratteri. E se invece, volessimo stampare molte stringhe?

Questa è la prima soluzione

https://pastebin.com/W9srcVH9

Non cambia molto eccetto l’aggiunta di 2 subroutine. La prima chiamata DisplayScreen. Questa routine è richiamata dalla subroutine Main del programma.

La seconda è chiamata ClearBuffers.

Inoltre, avrete notato che alla fine del nostro programma abbiamo più stringhe di testo da stampare nel nostro schermo. 

DisplayScreen – La spiegazione

Abbiamo un totale di 5 stringhe da stampare. Il codice è un po’ ripetitivo, ma raggiunge il nostro obiettivo.

Linea 182

Questa è la chiamata a ClearBuffers che spiegherò successivamente.

Linee 184 – 186

Questa è la nostra routine SetCurs, come spiegato nell’articolo 9. Non è cambiata. Passiamo i valori Y e X e calcoliamo lo scostamento sullo schermo da dove cominceremo a scrivere il testo.

Linee 188 – 190

Qui come nell’articolo 9 stampiamo il nostro primo carattere della stringa. Anche qui nulla è cambiato.

Il resto è una ripetizione come in precedenza. Calcoliamo di nuovo lo scostamento e stampiamo il prossimo carattere di testo sullo schermo

Lo stesso codice è ripetuto per 5 volte come il nostro numero di stringhe.

L’unica cosa che è nuova è il ClearBuffers.

ClearBuffers – La spiegazione

Questa è una semplice routine che cancella i 4 bytes dove calcoliamo e memorizziamo lo scostamento. Se non lo facciamo, aggiungeremo il precedente valore all’offset. Se volete vederlo in azione non vi resta che provarlo.

Quanto detto significa che i valori nella locazione di memoria Buf2 e Buf3 a 16-bit sono resettati al valore zero.

È tutto.

Se lanciate il codice con il SYS49152 dovreste vedere la seguente schermata.

La memoria del colore

È tempo di scoprire un altro argomento di programmazione per l’hardware del Commodore 64.

Se ricordate, avevamo settato il colore dei bordi e il colore dello sfondo, ma non abbiamo settato il colore del testo. Questo colore è sempre il blu classico o di default quando voi accendete il vostro Commodore 64 o fate partire il vostro emulatore.

Cosi come esistono 1000 bytes per la memoria dei caratteri nello schermo, ci sono altri 1000 bytes per la memoria del colore. Ci sono diverse modalità di colore, ma per semplificare, cominceremo con la modalità dove ogni carattere nel nostro schermo può avere un valore colore tra 0 e 15. I valori del colore del Commodore 64 sono indicati di seguito

Questa tabella è stata presa dal CBM Prg Studio Tools –> Options –> Palette (C64). Per maggiori dettagli potete verificare la C64 Wiki. Sono rappresentati maggiori informazioni nella seguente

Qui il link alla tabella colori nella C64.

https://www.c64-wiki.com/wiki/Color

La memoria colore o la RAM colore parte dalla locazione di memoria 55296 (\$D800) per il primo carattere in alto a sinistra e finisce al 56595 (\$DBEF) per il carattere in basso a destra.

Tutto quello che dobbiamo fare e salvare un valore da 0 a 15 nella locazione di memoria corrispondente alla posizione del carattere e il carattere cambierà il proprio colore.

Questo significa che se cambiamo il valore di memoria alla locazione 55296 (\$D800) il nostro carattere alla locazione 1024 (\$400) cambierà il proprio colore.

Immaginate che la memoria colore è sovrapposta alla memoria dello schermo e ogni carattere salvato nella memoria dello schermo ha il corrispondente valore nella memoria colore con il proprio colore. Il valore di scostamento, da dove il carattere è memorizzato nella memoria dello schermo, comincia al \$400 ed è lo stesso modo il valore di scostamento da dove inizia la memoria del colore è al \$D800.

Una nota finale riguardo la memoria del colore: il valore che memorizzi nella memoria del colore da 0 a 15 utilizza solo i 4 bit meno significativi. Memorizzare o usare il commando POKE con il valore 16 è lo stesso che salvare il valore 0, cioè il nero. In altre parole, gli altri 4 bit sono ignorati.

PrintAT Esempio 2

In questo esempio includeremo la scrittura della memoria colore e la stampa di alcuni testi in colori differenti oltre al classico blu leggero, che è il colore 14 (\$0E).

Qui il link al codice in Pastebin:

https://pastebin.com/xjmkHedC

Andiamo ad analizzare il codice e esaminiamo le differenze che sono state introdotte dal precedente esempio, partendo dall’inizio. Sorvolerò le routine discusse precedentemente che non hanno avuto cambiamenti.

Linee 24 – 21

Questa è l’area dove andiamo a definire le nostre costanti. Avrete notato che dopo le costanti della memoria dello schermo ho definito le costanti della memoria colore chiamata ColMem.

Abbiamo inoltre definite uno spazio di memorizzazione in pagina zero per mantenere qualche valore.

Abbiamo bisogno di scegliere le locazioni di memoria in pagina zero in modo oculato poiché molte di esse sono utilizzate dal system Kernal o dal Basic. Non ricordo quante volte ho utilizzato la locazione sbagliata e quando ritornavo al Basic il C64, questo non rispondeva più, poiché avevo corrotto il Basic da qualche parte 😊.

Linee 33 – 58

Questo è il nostro loop main o ciclo generale. A prima vista sembra molto differente, in pratica, non lo è.

Cominciamo con il settare il colore di sfondo e il bordo. La routine SetBgBorder è sempre la stessa.

Poi viene la routine ScrFill. Questa sembra nuova, in realtà, rimpiazza la routine che abbiamo usato per chiamare la ClearScreen . Di base fa la stessa cosa, ma ha un nuovo parametro. Il nuovo parametro è per il colore del testo. Quando puliamo lo schermo, dobbiamo settare il colore del testo dello schermo usando questo parametro.

Chiamiamo la routine DisplayScreen, che ho cambiato completamente dalla precedente versione pur mantenendo lo stesso nome. Andremo nel dettaglio fra poco.

Una volta che lo schermo è mostrato, dobbiamo attendere la pressione della barra spaziatrice da parte dell’utente. Questa è la routine WaitForSpace come dai precedenti articoli.

Le seguenti parti sono nuove ma non sono particolarmente speciali.

Dopo che la barra spaziatrice è stata premuta, ripristiniamo il bordo e lo sfondo ai colori classici del Commodore 64 nel momento che lo accendiamo.

Inoltre, puliamo lo schermo e fissiamo il colore del testo al solito blu leggero 14 or \$0E.

Adesso, andiamo a vedere le Subroutine che sono state cambiate: avrete notato che ho aggiornato i commenti in testata per ogni routine specificando i parametri che ognuna prende e per cosa vengono utilizzati. Questo è molto utile per ricordare meglio in futuro quando riutilizzeremo la subroutine.

La Subroutine The ScrFill

Come anticipato, questa routine è un’estensione della ClearScreen. Prende due parametri; il carattere di riempimento che bisogna memorizzare nel registro A e il valore del colore del carattere che è memorizzato nel registro Y.

Linee 83 – 84

Salviamo il valore del registro A nell’indirizzo di memoria temporaneo in pagina zero. Dopo inizializziamo X a zero.

Linee 87 – 91

Di base, è lo stesso della routine ClearScreen. Riempiamo lo schermo con il carattere specificato nell’accumulatore.

Linee 93 – 97

Per prima cosa trasferiamo il parametro del colore memorizzato in Y al registro A. Il resto è identico al precedente fatta eccezione che invece di utilizzare la ScrBase utilizziamo la ColMem. Questo scrive il colore nella locazione di memoria del colore.

Il resto è lo stesso. Compariamo per 250 (\$FA) e se non uguale continuiamo con il ciclo fino a quando abbiamo scritto tutte le locazioni di memoria.

DisplayScreen

Questa routine è un po’ più corta del precedente esempio. Qui abbiamo passato solo l’inizio della serie delle stringhe multiple. Tutto ciò è possibile grazie al modo in cui memorizziamo le stringhe.

Guardiamo insieme le nostre serie di stringhe multiple alla fine del codice.

Linee 295 – 296

Nella locazione di memoria con etichetta NoStrs abbiamo memorizzato il numero di stringhe che passeremo alla subroutine DisplayScreen. In questo caso abbiamo dichiarato che passeremo 6 stringhe.

Avremmo potuto passare questo valore come parametro alla routine, tuttavia, ho preferito memorizzarlo il più vicino possibile alle stringhe.

Linee 229 – 300

I primi 2 bytes, dove la nostra prima stringa è memorizzata è nella locazione di memoria etichettata Strings, sono la posizione X e Y per la prima stringa. Nel precedente articolo, questi erano parametri della routine SetCurs, ma adesso sono utilizzati qui. La nostra stringa finirà con il valore a zero byte ma comincerà dopo il secondo valore da destra, che sono le coordinate di X e Y dove andranno a essere rappresentate nello schermo.

Così facendo abbiamo risolto un’attività ripetitiva. Nell’ esempio 1 uno di questo articolo, era necessario richiamare e ripetere lo stesso codice per ogni stringa: abbiamo dovuto impostare la locazione in cui la stringa è memorizzata sullo schermo e poi l’abbiamo mostrata. La nuova routine PrintAT è più intelligente ed è capace di conoscere quante stringhe necessita di stampare e dove verranno stampate nello schermo.

Le prossime 5 stringhe seguono lo stesso comportamento – un paio di coordinate e una stringa che termina con zero byte.

Il miglioramento della routine Print AT

Linee 188 – 190

Questo è lo stesso della vecchia versione. Abbiamo salvato l’indirizzo sorgente da dove cominciano le stringhe multiple.

Linee 192 – 193

Qui abbiamo salvato il numero di stringhe in una locazione di memoria temporanea per future referenze.

Linee 197 – 205

Dobbiamo essere sicuri che le locazioni di memoria usate dalla routine SerCurs sono inizializzate a zero.

Dobbiamo leggere i primi due byte della stringa puntata dall’indirizzo sorgente nella memoria nella Zero Page. Salviamo nei registri X e Y e chiamiamo la solita subroutine SetCurs per impostare la posizione dove verranno scritte nello schermo.

Linee 207 – 214

Questa è una semplice addizione che somma 2 dei nostri indirizzi sorgente 16bit che puntano al carattere attuale della stringa e che vogliamo stampare.

Linee 216 – 220

Questo è lo stesso della vecchia routine di stampa. Di base impostiamo l’indirizzo di destinazione dove dobbiamo scrivere la stringa nello schermo.

Linee 222 – 230

Anche questo è lo stesso della vecchia routine di stampa del precedente articolo 9 e del primo esempio di questo articolo. Semplicemente stampiamo un carattere alla volta dall’indirizzo sorgente nell’indirizzo di destinazione fino a che raggiungiamo il byte zero che termina e annulla la stringa. Possiamo passare al prossimo step.

Ripresa delle linee 196 – 230

Tutte queste linee di base impostano la posizione della stringa nello schermo e la stampano. Precedentemente, avevamo separato la subroutine SetCurs e chiamato prima la PrintAt. Adesso, SetCurs è parte della PrintAt ed è la routine PrintAt che la richiama. PrintAT ha ancora bisogno di settare i parametri che la SetCurs necessita prima di chiamarla.

Linee 233 – 241

Ricorderete che in TempMem abbiamo salvato il numero di stringhe che dobbiamo stampare. Dal momento che stampiamo la prima stringa, decrementiamo il valore di TempMem e quando questo è 0 sappiamo che non ci saranno ulteriori stringhe da stampare e possiamo uscire saltando al PrintExit

Se non ci sono più stringhe da stampare, possiamo passare alla prossima parte.

 

Linee 243 – 256

Incrementiamo il registro Y che punta all’inizio della prossima stringa formattata. Aggiungiamo il valore del registro Y all’indirizzo sorgente 16-bit. Questo punterà all’indirizzo sorgente dei primi 2

byte della prossima stringa formattata che rappresentato le coordinate X e Y della posizione della prossima stringa che verrà stampata nello schermo.

Finché sappiamo che esiste una stringa da stampare e l’indirizzo sorgente della routine di stampa punta già ad esso, possiamo saltare alla SetPos e ricominciare di nuovo con il posizionamento della stringa nella posizione dove deve essere stampata e stamparla.

Di base è tutto qui. Non ci sono altre routine che ho cambiato

Se scriviamo la solita SYS49152 dovreste vedere il seguente schermo

Come potete vedere, oltre a impostare i colori del bordo e dello sfondo, questa volta abbiamo impostato anche il colore nero del testo in primo piano.

Prossimo articolo

PrintAT è una routine molto efficace. Nel prossimo articolo finirò la serie di articoli della PrintAt e finirà con una sorpresa che vi illustrerà la vera forza di questa routine.

Come sempre, se avete domande per favore scrivetemi su tutti i gruppi FB Phaze101 Facebook group o il gruppo FB Retroprogramming Italia. Che la forza del codice sia con voi.

Coding is Fun 😊

Un ringraziamento a

English proofreading: Colin Vella

Translation to Italian: Davide Aldegheri

Italian proofreading: David La Monaca

Coding Check: Daniele Verzotto

Other team members: Pinov Vox and John Sherwood

e Retro Programming Italia

 

Potete leggere tutti gli articoli precedenti su SYS32768.ORG

Articolo 9
https://sys64738.org/2019/06/c64-bedtime-coding-ita-print-at-09/

Articolo 8
https://sys64738.org/2019/05/c64-bedtime-coding-ita-stampare-sullo-schermo-08/

Articolo 7
https://sys64738.org/2019/05/c64-bedtime-coding-ita-cancellare-lo-schermo-07/

Articolo 6
https://sys64738.org/2019/04/c64-bedtime-coding-ita-primi-passi-06/

Articolo 5
https://sys64738.org/2019/04/c64-bedtime-coding-ita-il-set-di-istruzioni/

Articolo 4
https://sys64738.org/2019/03/c64-bedtime-coding-ita-modalita-di-indirizzamento-04/

Articolo 3
https://sys64738.org/2019/03/c64-bedtime-coding-ita-i-registri-della-cpu-03/

Articolo 2
https://sys64738.org/2019/03/c64-bedtime-coding-ita-linguaggio-macchina-02/

Articolo 1
https://sys64738.org/2019/03/c64-bedtime-coding-introduzione-e-basi-01/

 

 

Have your say