La sfida della Stella di Natale

Si è da poco conclusa la Vintage Computing Christmas Challenge 2022 (VC³ 2022), un simpatico concorso di programmazione organizzato da Logiker per il periodo di Natale.

L’obiettivo della sfida principale, chiamata Christmas Star Challenge, consiste nella realizzazione di un programma per qualsiasi computer e linguaggio (preferibilmente per sistemi vintage), in grado di rappresentare fedelmente la figura mostrata nell’immagine seguente, ottimizzando il codice il più possibile, oppure di migliorarla.

Immagine da realizzare per la Christmas Star Challenge
Immagine da realizzare per la Christmas Star Challenge (fonte: Logiker).

In alternativa, optando per la challenge Wild, era possibile creare un programma completamente differente, purché a tema natalizio.

Centinaia di persone si sono cimentate con la sfida e tutti i programmi in gara sono presentati nel video realizzato dall’organizzatore:

Video dei Logiker con i risultati della sfida e presentazione di tutti i programmi in concorso.

La mia implementazione della Stella di Natale in Tiny BASIC

Ho deciso di partecipare alla Christmas Star Challenge realizzando un programma in Tiny BASIC. La stella, che occupa una superficie quadrata il cui lato misura 17 caratteri, può essere suddivisa in quattro triangoli sovrapposti:

01    *            
02    **           
03    ***          
04    ****         
05    *****        
06    ******       
07    *******      
08    ********     
09    *********    
10    **********   
11    ***********  
12    ************ 
13    *************
14
15
16
17
01            *    
02           **    
03          ***    
04         ****    
05        *****    
06       ******    
07      *******    
08     ********    
09    *********    
10   **********    
11  ***********    
12 ************    
13*************    
14
15
16
17
01
02
03
04
05*************    
06 ************    
07  ***********    
08   **********    
09    *********    
10     ********    
11      *******    
12       ******    
13        *****    
14         ****    
15          ***    
16           **    
17            *    
01
02
03
04
05    *************
06    ************ 
07    ***********  
08    **********   
09    *********    
10    ********     
11    *******      
12    ******       
13    *****        
14    ****         
15    ***          
16    **           
17    *            

L’idea è quindi quella di iterare su ciascuna delle 17*17 posizioni e di stampare un carattere “*” se il “punto” considerato appartiene ad almeno uno dei 4 triangoli, altrimenti uno spazio vuoto ” “:

 100 LET R=0
 110 LET C=0
 120 LET S=0
 130 IF R<13 THEN IF C>3 THEN IF C<R+5 THEN LET S=1
 140 IF R<13 THEN IF C<13 THEN IF C>11-R THEN LET S=1
 150 IF R>3 THEN IF C<13 THEN IF C>R-5 THEN LET S=1
 160 IF R>3 THEN IF C>3 THEN IF C<21-R THEN LET S=1
 800 IF S=0 THEN PRINT " ";
 810 IF S=1 THEN PRINT "*";
 900 LET C=C+1
 910 IF C<17 THEN GOTO 120
 915 PRINT
 920 LET R=R+1
 930 IF R<17 THEN GOTO 110
1000 END

Rimuovendo gli spazi superflui e sfruttando le abbreviazioni delle istruzioni Tiny BASIC, è stato possibile ridurre la dimensione del listato del programma a 203 caratteri:

1R=0
2C=0
3S=0
4IFR<13IFC>3IFC<R+5S=1
5IFR<13IFC<13IFC>11-RS=1
6IFR>3IFC<13IFC>R-5S=1
7IFR>3IFC>3IFC<21-RS=1
8IFS=0PR" ";
9IFS=1PR"*";
10C=C+1
11IFC<17GOTO3
12PR
13R=R+1
14IFR<17GOTO2
15END

Ed ecco l’output:

    *       *    
    **     **    
    ***   ***    
    **** ****    
*****************
 *************** 
  *************  
   ***********   
    *********    
   ***********   
  *************  
 *************** 
*****************
    **** ****    
    ***   ***    
    **     **    
    *       *    

Non ho trovato un modo per ottimizzare ulteriormente il programma prima della fine della sfida; accetto comunque eventuali suggerimenti a riguardo!

Puoi osservare il programma in esecuzione su un computer Cosmac ELF emulato con Emma 02 nel seguente video, oppure eseguirlo e/o modificarne il codice utilizzando l’interprete online TinyBASICBlazor.

La mia implementazione in Tiny BASIC della Stella di Natale, in (lenta) esecuzione su Cosmac ELF, emulato con Emma 02.
La mia implementazione in Tiny BASIC della Stella di Natale, in esecuzione su TinyBASICBlazor, interprete Tiny BASIC per browser web.

Varianti ed evoluzioni

Data la semplicità della sintassi Tiny BASIC, che può essere considerato come un sottoinsieme della maggior parte dei dialetti BASIC disponibili, il programma può essere eseguito su una vastità di piattaform senza alcuna modifica (ad es. BBC Basic) o con modifiche minime. Ad esempio, su Sinclair ZX81 è sufficiente rimuovere l’istruzione “END” o sostituirla con “STOP” per avere una sintassi corretta.

Christmas Star - programma in esecuzione in BBC BASIC for SDL
La mia implementazione della Stella di Natale in esecuzione in BBC BASIC for SDL.

Proprio per il piccolo computer Sinclair, ho provato a compattare ulteriormente il codice del mio programma Tiny BASIC originale, anche se per ottenere risultati migliori in termini di dimensioni sarebbe stato necessario riscriverlo completamente sfruttando le caratteristiche del BASIC Sinclair.

Christmas Star - listato del programma per ZX81
Listato del programma per Sinclair ZX81.
Christmas Star - output del programma per ZX81
Output del programma per ZX81.
Programma per ZX81 in azione.

Infine, dato che lo scopo principale della competizione era quello di divertirsi, ho realizzato una versione Teletext della Stella di Natale, che riprende l’immagine di riferimento della sfida:

Christmas Star - versione Teletext
La Stella di Natale, versione Teletext.

La classifica ordinata per dimensione del codice sorgente è disponibile, insieme ai download di tutte le entry, su demozoo.org. Complimenti all’impareggiabile Dr. BEEP, che si è aggiudicato le prime posizioni con le versioni in Assembly per ZX81 e ZX Spectrum, il cui codice occupa solamente 27 e 29 byte rispettivamente!

Read in English

Marco’s Teletext Adventures – Monstober

Blocktober è un evento dedicato agli appassionati di Teletext, che si svolge per tutto il mese di ottobre. Una parte significativa dell’evento è costituita dal concorso artistico, la cui parola chiave per l’edizione 2020 è Monstober.

Ho partecipato al contest con 4 opere:

The mirror

Un uomo che osserva la mostruosa immagine riflessa da uno specchio (disponibile alla pagina 266 di ChunkyText):

Reveal your fear

La notte è quieta… finché non premi il tasto “reveal”! Della serie: “c’è qualcosa sotto il letto!” (pagina 242 di ChunkyText):

Monsober

Un evento sobrio: vietata la vendita di alcolici dopo le ore 21 (pagina 253 di ChunkyText):

Vaporwave/Outrun

L’unico frame non collegato alla parola Monstober e il primo in ordine cronologico di realizzazione. Rappresenta la versione teletext di una famosa immagine ispirata all’estetica Vaporwave/Outrun (pagina 220 di ChunkyText):

Puoi osservare tutte le opere in concorso e votare per le due preferite (o per quelle non relative a Monstober) fino alla 19:00 (GMT) di sabato 31 ottobre.

Infine, tutte le registrazioni delle sessioni di Blocktober 2020, con interessanti discussioni sul mondo Teletext, sono disponibili sul canale Twitch di ZX Guesser.

Read in English

Marco’s Teletext Adventures – Capitolo 1

Recentemente, tramite il progetto NXtel (grazie, Robin & D!), mi sono avvicinato al “mondo” Teletext, che è molto più vivace di quanto potessi immaginare! Ho così appreso che ci sono vari servizi attivi (NXtel, TELSTAR, TeeFax), fruibili tramite una moltitudine di “client” (NXtel stesso, incluso anche nell’emulatore #CSpect, telstar.bbc, fornito con BBC BASIC for SDL, oppure gli ottimi client web Online Teletext Viewer e vd-view), che è possibile realizzare un “server” Teletext con un Raspberry PI, oppure recuperare pagine a partire da vecchie videocassette VHS e infine sono entrato in contatto con una community molto attiva (Teletext – The Facebook Group), che organizza anche eventi e contest dedicati alla Teletext art.

Proprio riguardo alla Teletext art, mi sono cimentato con la produzione di alcune pagine e ho deciso di partecipare all’evento Block Party 2020. Ecco di seguito alcune delle mie creazioni, con tanto di fotografie dei soggetti che mi hanno ispirato e link per aprirle nel visualizzatore online:

Tonco @ sunset

Una vista del paese in cui vivo, al tramonto:

Vespa 50 Special

La mia Vespa 50 Special (in ricordo di Nonno Gianni):

Daffodil

Un narciso, fotografato nel mio giardino:

Drive Me Crazy!

Il modellino di BMW che mi è stato di ispirazione per il videogioco di guida Drive Me Crazy!, che sto realizzando in BASIC per il computer ZX Spectrum:

Enjoy the party!

Read in English

Il triangolo di Sierpiński con lo ZX81: aggiornamento

Triangolo di Sierpinski su ZX81 - versione migliorata
Triangolo di Sierpinski su ZX81 – versione migliorata

Recentemente, sono venuto a conoscenza del BASIC 10Liner Contest e ho immediatamente pensato che il mio programma per generare il frattale noto come Triangolo di Sierpinski sul Sinclair ZX81, con le opportune modifiche, avrebbe potuto essere incluso a buon diritto tra i partecipanti della categoria “SCHAU”. Infatti, questa categoria è dedicata a demo, strumenti e applicazioni realizzati in 10 righe di codice (con lunghezza massima di 256 caratteri), mentre le altre categorie sono specifiche per i giochi.

Così, ho colto l’opportunità di riscrivere il codice, in modo da:

  • ridurre la lunghezza del programma (massimo 10 righe),
  • migliorare la qualità dell’immagine generata.

Il listato risultante è mostrato di seguito: il programma è effettivamente lungo 9 linee; inoltre, la scelta dei punti (X=0, Y=0), (X=30, Y=40) e (X=0, Y=60) quali vertici del triangolo garantisce un’immagine perfettamente simmetrica.

Listato del programma
Implementazione del programma di generazione del Triangolo di Sierpinski con algoritmo chaos game in 10 (anzi, 9!) righe

Bonus: per un’autentica esperienza retrocomputeristica, qui puoi trovare la versione TELETEXT/TELEVIDEO del listato BASIC e dell’output del programma!

Puoi scaricare un archivio zip contenente il codice sorgente, la documentazione completa e i file pronti per l’utilizzo con gli emulatori, oppure semplicemente vedere il programma in azione con l’emulatore online di ZX81.
Al completamento del caricamento, dovrebbe apparire una schermata bianca, con in fondo il messaggio “0/0”. A questo punto, per eseguire il programma, occorre premere il tasto “R” (ora dovrebbe essere visibile la scritta “RUN”, seguita da un cursore nero) ed infine il tasto “ENTER”.

Enjoy the SCHAU! 😉

Read in English