Non c’è cosa peggiore che vedere il proprio lavoro,
frutto di anni di applicazione, buttato la da una parte all’interno di una cartella in un luogo remoto dell’hard disk.

Si perché di grafica no ho disegnata parecchia in quasi 20 anni e in alcuni casi sono anche riuscito a sfruttarla per qualche progetto amatoriale che si trova tutt’ora in rete. Il problema è che lavorare da soli implica un sacrificio notevole e spesso la frustrazione per un progetto che avanza troppo lentamente fa si che non si riesca a concluderne neanche uno.

Ci si ritrova quindi con una serie di giochi che stagnano, ognuno dei quali ad un differente stadio di sviluppo.

Torre della Terra

L’ultimo progetto che avevo in mente consisteva in un platform game a schermo fisso per Commodore 64 il cui stile di gioco doveva somigliare ad una sorta di Bubble Bobble/Solomon’s Key/Bomb Jack/Ghosts’n Goblins.Lo so, sembrerebbe un’accozzaglia indefinibile ma nella mia testa tutto filava perfettamente.

Foresta

Tutto questo accadeva due anni fa e il progetto inizió con alcuni mockup comprendenti  schermate di gioco e animazioni varie. Per la modalitá grafica scelsi la bitmap 16 colori alla maniera di The Last Ninja, Stormlord o Poseidon che per dirla in breve,  consiste nel caricare in memoria l’immagine desiderata per poi scomporla in “tile” con cui creare tutti i fondali.

Torre della Magia

A livello di codice non è semplice ottenere un buon risultato ma i vantaggi di natura estetica  sono notevoli. Fatto sta che dopo aver disegnato cinque o sei schermate decisi di postarle su qualche forum nella speranza di trovare un coder all’altezza del lavoro che avevo in mente di realizzare.

Shop

Parlai anche con Papá Santoro, un mio vecchio amico che all’epoca era stato un “enfant prodige” del cracking, uno che a 14 anni faceva “raw coding” utilizzando un semplice editior ASCII e un “language monitor” ma mi disse che non avrebbe mai avuto tempo da dedicargli e voglia di ricominciare daccapo con l’assembly del 6510.

Intro

Deluso ma fiducioso di venirne a capo andai avanti con la grafica e produssi persino una demo per PC (windows)  cosí da poter mostrare la mia idea in modo piú efficace.  Arriviamo quindi a sette mesi fa, quando una sera chiacchierando su skype con Papá Santoro mi sento fare una richiesta che mi diede da pensare: Massi, perché non mi mandi qualche sprite del tuo progetto Magot? E io: a che ti servono? Papá Santoro: tranquillo volevo solo fare un paio di esperimenti.

Fatto sta che qualche giorno dopo mi ricontatta il mio amico inviandomi un file “prg” da visionare. Incuriosito avvio Hoxs64 e lancio il prg e quello che mi ritrovo davanti è un platform game (molto rudimentale) a schermo fisso in cui le mie creazioni saltellano qua e la, finalmente vive!

Nell’ambito della nostra iniziativa votata a riaccendere nei nostri lettori la fiamma dell’interesse nei confronti della programmazione cominciamo con le basi. 

Un breve riassunto dei comandi del Commodore Basic V2 utilizzato dal Commodore64 (oltre che dal VIC20 e i Commodore PET). Attenzione! Questo non è un tutorial sul Commodore Basic ma una sorta di guida di riferimento per riaccendere in neuroni spenti (o mai accesi…).

Nel basic V2 sono disponibili unicamente i seguenti tipi di variabili:

• Float: È il tipo usato più frequentemente ed indica i numeri positivi e negativi dotati di parte intera e decimale. Non hanno indicatore di tipo nella loro dichiarazione.
  Valori possibili: +/- [2.94E-39 ... 1.70E+38] (+/- [2^-128 ... 2¹²⁷])
  Precisione: mantissa a 32 bit (approx. 9.6 decimali) + esponente a 8 bit
• Interi (16 Bit): Tipo di tati raramente utilizzato. Le variabili ntere si caratterizzano per un ‘%’ alla fine della loro ‘etichetta’ (es. X%).  È bene notare che tutti i calcoli computazionali sono effettuati con precisione FLOAT e la conversione a Intero è effettuata solo quando il valore è assegnato alla variabile. Quindi la matematica di tipo intero è PIÙ LENTA che quella di tipo float!
• Booleani: I risultati sono espressi con interi. FALSO è rappresentato da 0 (0×0000) mentre VERO da -1 (0xFFFF) o qualunque risultato NON-ZERO
• Stringhe:  Le variabili “stringa” si identificano per il simbolo ‘$’ posto dopo l’etichetta identificativa (es. X$). Le stringhe non possono essere più lunghe di 255 caratteri.

Solo i primi DUE caratteri dell’etichetta di una variabile sono presi in considerazione dall’interprete BASIC. Quindi ‘CO’, ‘COCCO’ e ‘COLOSSEO’ sono nomi equivalenti di una singola variabile (ma non ‘C’ o ‘CA’).

L’identificatore di tipo, invece, identifica e distingue variabili con la stessa etichetta. Quindi ‘CO’, ‘CO%’ e ‘CO$’ sono TRE variabili diverse.

Controllo del flusso del programma

FOR...TO...STEP...NEXT - L’unico costrutto di ciclo del BASIC V2

Sintassi:
FOR <Var> = <Start> TO <End> [STEP <Size>]
<Ciclo>
NEXT [<Var>]

Esempi:

FOR I=1 TO 5: PRINT I;: NEXT -> 1 2 3 4 5
FOR I=1 TO 5 STEP 2: PRINT I;: NEXT -> 1 3 5
FOR I=5 TO 1 STEP -2: PRINT I;: NEXT I -> 5 3 1
FOR I=3 TO 1: PRINT I;: NEXT -> 3 (!)

IF...THEN - Esecuzione condizionale

Nota: Non esiste nulla di similare ai costrutti ELSE o ENDIF. (tra l’altro NESSUN BASIC eccetto l’MSX BASIC implementa l’ELSE)

Sintassi:
IF <Condizione> THEN <Istruzione> or
IF <Condizione> GOTO <NrLinea> or
IF <Condizione> THEN <NrLinea>

Esempio:
100 IF A < B THEN MN = A: GOTO 120
110 MN = B
120 ....

GOTO oppure GO TO - Salto incondizionale

Sintassi:
GOTO <NrLinea> oppure
GO TO <NrLinea>

GOSUB -  Salto incondizionale a Subroutine

Notare che non è possibile passare parametri formali ad una subroutine. Tutto deve essere gestito con l’uso di variabili globali.

Sintassi:
GOSUB <NrLinea>

Esempio:
10 PRINT "Programma principale"
20 GOSUB 100
30 PRINT "Ritorno a Programma principale"
40 GOSUB 100
50 PRINT "Di nuovo Programma principale"
60 END
100 PRINT "Questa è la Subroutine"
110 RETURN

RETURN - Ritorno dalla Subroutine

Sintassi:
RETURN

Esempio:
Vedi: GOSUB

ON...GOTO oppure ON...GOSUB - Salto multi direzionale

Sintassi:
ON <EspressioneIntera> GOTO <NrLinea1>, <NrLinea2> …
oppure ON <EspressioneIntera> GOSUB <NrLinea1>, <NrLinea2> …

Esempio:
ON X GOTO 100, 200, 300
È equivalente a :
IF X = 1 THEN GOTO 100
IF X = 2 THEN GOTO 200
IF X = 3 THEN GOTO 300

DEF FN- Definisce una Funzione/Subroutine in BASIC 

Sintassi:
DEF FN <Nome>(<Param>) = <Espressione a Linea Singola>

Esempio:
DEF FN SI(X) = SIN(X)/X
FN SI(π/3) -> 0.816993343

Input/Output

GET - Legge un singolo carattere dallo standard input (normalmente tastiera) senza attendere 

Sintassi:
GET <NomeVariabile>

Esempio:
100 GET A$: IF A$ = "" THEN GOTO 100 -> Attende la pressione di un tasto

INPUT -Legge i dati dallo standard input (normalmente tastiera)

Sintassi:
INPUT [<Prompt>;] <NomeVariabile> [, <NomeVariabile> ...]

Esempi:
INPUT "LOGIN:"; LG$
INPUT "Introdurre valori di A, B e C"; A, B, C
INPUT A

PRINT - Scrive sullo standard output (normalmente schermo)

Sintassi:
PRINT <Dati> oppure
? <Dati>

Esempi:
PRINT "Ciao Mondo"
PRINT "Queste", "sono", "Tabulazioni" -> Notare le ','
PRINT "Prima Linea"; -> Notare il ';'
PRINT "Still the same line"
PRINT "Risultato="; 2*32

SPC - Muove in avanti il cursore di un determinato numero di spazi

Sintassi:
SPC(<Cnt>)

Esempio:
SPC(6)

TAB- Muove in avanti il cursore ad una specifica posizione

Sintassi:
TAB(<Posizione>)

Esempio:
TAB(6)

POS - Indica la posizione corrente del cursore

Sintassi (Dummy = valore non rilevante) ;
POS(<Dummy>)

Esempio:
POS(6)

Files

LOAD- Carica un programma da disco o nastro

Sintassi:
LOAD <FileName> [, <Dispositivo> [, <SecondoDisp>]]

Esempi:
LOAD "SuperGame", 8, 1 -> Carica il programma da disco #8
LOAD "*", 9 -> Carica il primo programma da disco #9
LOAD "", 1 -> Carica il primo programma da nastro(#1)

SAVE - Salva un programma su disco o nastro

Sintassi:
SAVE <FileName> [, <Dispositivo> [, <SecondoDisp>]]

Esempi:
SAVE "SuperGame", 8 -> Salva su disco #8
Per sovrascrivere un file esistente su disko, far precedere il nome del file dal carattere ‘@’

Esempio:
SAVE "@SuperGame",8 ->  Salva su disco #8, sovrascrive vecchio file

VERIFY - Controlla se il programma in memoria e quello registrato su disco o nastro coincidono. Non modifica nulla.

Sintassi:
VERIFY <FileName> [, <Dispositivo> [, <SecondoDisp>]]

Examples:
VERIFY "SuperGame", 8 -> Verifica SuperGame da disco #8
VERIFY "*", 9 -> Verifica il primo programma da disco #9
VERIFY "", 1 -> Verifica il primo programma da nastro #1

OPEN- Apre un flusso dati (File)

Sintassi:
OPEN <FileID>, <Dispositivo> [, <SecondoDisp> [, <FNameMode>]]
Il parametro <SecondoDisp> è un intero opzionale compreso tra 0-15 che,secondo il valore assegnato ,assume i seguenti significati:
0..Utilizzato per  LOAD, 1..Utilizzto per SAVE, 2-14..Liberamente utilizzabile per accesso a file utente, 15..Canale di Comando/Errore.
<FNameMode> usa il formato format: “<NomeFile> [,<TipoFile> [,<ModoAccesso>]]" dove <TipoFile> può essere uno tra: P (Programma), S (Sequenziale), L (Relativo) or U (Utente)

<ModoAccesso> può essere uno tra: R (Lettura),W (Scrittura), A (Aggiunta) o il numero di Bytes/Record di un file relativo.

Esempi:
OPEN 1, 4 -> Apre un file di output sulla stampante #4
OPEN 1, 8, 2, "My File,P,R" -> Apre un programma, per la lettura, da disco #8
OPEN 1, 8, 2, "My File,S,W" -> Apre un file sequenziale, per la scrittura su disco #8
OPEN 1, 8, 2, "My File,L,"+CHR$(40) -> Apre un file relativo con 40 Bytes/Record su disco #8
OPEN 1, 8, 15 -> Apre il canale Comando/Errore su disco #8

CLOSE - Chiude un flusso dati (File)

Sintassi:
CLOSE <FileID>

Esempio:
CLOSE 1

GET# - Legge un singolo carattere da un file

Sintassi:
GET# <FileID>, <VarName>

Esempio:
GET#1, A$

Notare che NON c’è spazio tra ‘GET‘ e ‘#‘.

INPUT# - Recupera dati da un File

Sintassi:
INPUT# <FileID>, <VarName> [, <VarName>...]

Esempio:
INPUT#1, EN$, ER$, TR$, SC$

Notare che NON c’è spazio tra ’INPUT‘ e ‘#‘.

PRINT# - Stampa dati su un File 

Sintassi:
PRINT# <FileID>, <Dati>

Esempio:
PRINT#1, "Power64"

Notare che NON c’è spazio tra ‘PRINT‘ e  ’#‘. Notare anche che ?# NON è PRINT# anche se appaiono uguali in un listato.

CMD - Redireziona lo standard output (Input non è modificato ) e scrive messaggi su esso

Sintassi:
CMD <FileID> [, <Messaggio>]

Esempio:
OPEN 1, 4 ; Apre un File#1 su Stampante#4
CMD 1 ; Rende #1 lo standard output
PRINT "Messaggio"
PRINT "Messaggio2"
PRINT#1
CLOSE 1

ST - Stato di un dispositivo (Variabile interna)

ST = 0 .. Dispositivo Ok
Bit 6: 1 .. Fine del File
Bit 7: 1 .. Dispositivo non presente

READ - Legge dati statici dalle istruzioni DATA nel programma

Sintassi:
READ <Var> [, <Var>...]

Esempio:
10 RESTORE
20 READ X$
30 PRINT X$;
40 S = 0
50 FOR I=1 TO 3
60 READ X
70 S = S + X
80 NEXT I
90 PRINT S
100 DATA "Power", 12, 34, 18

L’output dell’esempio sarebbe Power 64

RESTORE - Resetta al primo elemento DATA del programma il puntatore a DATA.

Sintassi:
RESTORE

Esempio:
Vedi READ

DATA- Immagazzina dati statici

Sintassi:
DATA <Dati> [, <Dati>...]

Esempio:
Vedi READ

Funzioni Matematiche

LET - assegna valore a un variabile

Sintassi:
LET <Variabile> = <Valore>

Esempio:

LET A = 6.25

Notare che il comando LET è innecessario e ridondante. <Variabile> = <Valore> è tutto ciò che serve per assegnare un valore a una variabile. LET rallenta l’intero processo, quindi NON USATELO!

DIM - Dichiarazione Array

Sintassi:
DIM <Nome>(<Dimensione1> [, <Dimensione2>...])

Esempi:
DIM A(7) -> Array di 8(!) elementi indicizzati [0..7]
DIM B$(4,5) -> Array di  30(!) stringhe [0..5 x 0..6]
Uso degli elementi: A(3) = 17 : B$(2,3) = "Power64"

+, -, *, /, ^ - Operatori Aritmetici

Esempio:
9 + 5 * (15 - 1) / 7 + 2^4 -> 35

<, <=, =, <>, >=, > - Operatori di confronto

Esempio:
3 <> 6 -> -1 (VERO)
3 > 4 -> 0 (FALSO)

SIN - Seno (Argomenti in Radianti)

Sintassi:
SIN(<Valore>)

Esempio:
SIN(π/3) -> 0.866025404

COS - Coseno (Argomenti in Radianti)

Sintassi:
COS(<Valore>)

Esempio:
COS(π/3) -> 0.5

TAN - Tangente (Argomenti in Radianti)

Sintassi:
TAN(<Valore>)

Esempio:
TAN(π/3) -> 1.73205081

ATN - Arco Tangente (Risultato in [-π/2 .. π/2])

Sintassi:
ATN(<Valore>)

Esempio:
ATN(1) -> 0.785398163 ( = π/4)

EXP - Esponentr (e^x dove e = 2.71828183…)

Sintassi:
EXP(<Valore>)

Esempio:
EXP(6.25) -> 518.012825

LOG - Logaritmo Naturale

Sintassi:

LOG(<Value>)

Esempio:
LOG(6.25) -> 1.83258146

SQR - Radice quadrata

Sintassi:
SQR(<Valore>)

Esempio:
SQR(6.25) -> 2.5

ABS - Valore Assoluto

Sintassi:
ABS(<Valore>)

Esempi:
ABS(-6.25) -> 6.25
ABS(0) -> 0
ABS(6.25) -> 6.25

SGN - Segno

Sintassi:
SGN(<Valore>)

Esempi:
SGN(-6.25) -> -1
SGN(0) -> 0
SGN(6.25) -> 1

INT - Intero (Arrotonda all’intero minore o uguale all’argomento.)

Sintassi:
INT(<Valore>)

Esempi:
INT(-6.25) -> -7 (!)
INT(-5) -> -5
INT(0) -> 0
INT(5) -> 5
INT(6.25) -> 6

RND - Numero casuale tra [0.0 .. 1.0]

Sintassi:
RND(<Seed>)
Se (<Seed> < 0) il generatore di numeri casuali viene inizializzato.

Esempi:
RND(-625) -> 3.85114436E-06
RND(0) -> 0.464844882
RND(0) -> 0.0156260729

Operatori Logici e Binari

Ricordiamo la codifica dei valori Booleani
FALSO <--> 0 (0x0000) e VERO <--> -1 (0xFFFF) or o qualunque valore non-zero.

AND- AND logico e binario

Sintassi:
<Expr> AND <Expr>

Esempi:
A>5 AND X<=Y
12 AND 10 -> 8 (%1100 AND %1010 = %1000) - operazione di confronto sui bit

OR - OR logico e binario

Sintassi:
<Expr> OR <Expr>

Esempi:
A>5 OR X<=Y
12 OR 10 -> 14 (%1100 OR %1010 = %1110) - operazione di confronto sui bit

NOT- NOT logico e binario

Sintassi:
NOT <Expr>

Esempi:
NOT A>5
NOT 2 -> -3 (NOT $0002 = $FFFD) - operazione di confronto sui bit

Manipolazione di Caratteri e Stringhe

+ - Concatena Stringhe

Esempio:
"Pow" + "er64" -> "Power64"

<, <=, =, <>, >=, > - Operatori di confronto

Esempi:
"C64" < "Power64" -> -1 (VERO)
"Alpha" > "Omega" -> 0 (FALSO)

LEN - Lunghezza stringa

Sintassi:
LEN(<Stringa>)

Esempio:
LEN("Power64") -> 7

LEFT$ - Parte sinistra della stringa

Sintassi:
LEFT$(<String>, <Lung>)

Esempio:
LEFT$("Power64", 5) -> "Power"

RIGHT$ - Parte destra della stringa

Sintassi:
RIGHT$(<String>, <Lung>)

Esempio:
RIGHT$("Power64", 5) -> "wer64"

MID$ - Parte centrale della stringa

Sintassi:
MID$(<String>, <Inizio>, <Lung>)

Esempio:
MID$("Power64 per Macintosh", 13, 3) -> "Mac"
/* -- 123456789012345678901 -- */

STR$ - Converte un numero in una stringa

Sintassi:
STR$(<Valore>)

Esempi:
STR$(6.25) -> " 6.25"
STR$(-6.25) -> "-6.25"

VAL - Converte una stringa in numero

Sintassi:
VAL(<String>)

Esempi:
VAL("6.25") -> 6.25
VAL("6xx25") -> 6
VAL("x6x25") -> 0

ASC- Codice ASCII del primo carattere di una stringa

Sintassi:
ASC(<String>)

Esempio:
ASC("P") -> 80
ASC("Power64") -> 80

CHR$ - Carattere corrispondente ad uno specifico codice ASCII

Sintassi:
CHR$(<Valore>)

Esempio:
CHR$(80) -> "P"

Accesso alla Memoria

PEEK - Legge un byte dalla locazione di memoria

Sintassi:
PEEK(<Loc>)

Esempio:
PEEK(53280) -> Valore corrente del byte che determina il colore del bordo dello schermo

POKE - Scrive un byte in una locazione di memoria

Sintassi:
POKE <Loc>, <Valore>

Esempio:
POKE 53280, 7 -> Imposta a 7 il valore del che determina il colore del bordo dello schermo, ottenendo il bordo giallo

WAIT - Attende finché il byte di una locazione di memoria assume un certo valore 

Sintassi:
WAIT <Loc>, <Maschera> [, <Inverti>]
WAIT il programma si arresterà fino a che ((PEEK(<Loc>) EXOR <Inverti>) AND <Maschera>) != 0
Se <Inverti> non è specificato assume valore di default 0.

Esempio:
WAIT 198, 255 -> Attende la pressione di un tasto nel buffer tastiera.

Interfaccia a programmi in Assembly

SYS - System – Richiama un programma assembler da una locazione di memoria

Sintassi:
SYS <Loc> [, <Param> ...]

Il numero di parametri dipende dal programma chiamato.

USR- Comando utente

Sintassi:
USR(<Param>)

Simile a SYS ma la locazione di memoria <Loc>a cui si punta è fissa a $0310 ed il primo ed unico parametro <Param> è sempre valutato e memorizzato nel FloatAccu1 (FAC1) quando il programma assembly viene chiamato. Meno flessibile di SYS e quindi raramente utilizzato.

Esecuzione Programmi

RUN - Avvia un programma BASIC

Sintassi:
RUN [<Linea>]

Se  <Linea> non è specificato il programma inizia dalla prima linea.

Esempio:
RUN

STOP- Arresta l’esecuzione di un programma

Sintassi:
STOP

STOP è simile ad END, ma stampa il messaggio BREAK IN <Linea> .

END - Conclude l’esecuzione di un programma

Sintassi:
END

CONT - Continua l’esecuzione di un  program 

Sintassi:
CONT

Quando l’esecuzione di un programma è interrotta da by STOP, END o dalla pressione del tasto Run/Stop il comando CONT viene usato per riprendere l’esecuzione.

Vari

REM - Commento

Sintassi:
REM <Testo>

Esempio:
REM Questa linea è un commento

LIST - Mostra il listato del programma BASIC corrente

Sintassi:
LIST [<Linea> | <Da>- | -<A> | <Da>-<A>]
Senza parametri l’intero programma viene listato.

Esempi:
LIST
LIST -40
LIST 100-200

NEW - Cancella il programma corrente e tutte le variabili dalla memoria

Sintassi:
NEW

CLR - Cancella tutte le variabili 

Sintassi:
CLR

FRE - Indica la memoria disponibili

Sintassi:
FRE(<Dummy>)

Esempio:
FRE(0) -> -26627 (immediatamente dopo l’accensione)

Restituisce il numero di Bytes liberi per i programmi BASIC come un intero a 16 bit con segno. Se la memoria libera eccede i 38KByte viene indicato un numero negativo. Quindi -26627 dovrebbe essere interpretato come 65536-26627 = 38909.

π - Pi = 3.14159265

TI - Timer Ticks trascorsi dall’accensione (1 Tick = 1/60 Second)

TI$ - Timer dall’accensione in Ore/Minuti/Secondi 

             A TI$ (ma non a TI) può essere assegnato un valore!

La precisione del timer è piuttosto scarsa (scarto >1%)

Continuo l’aggiornamento sulla mia missione autolesionista ovvero lo sviluppo di un emulatore Z80 per NeoGeo CD. Questa volta l’emu inizia a dare segni di vita riconoscibile emulando la rom di PHOENIX (uno dei miei arcade preferiti in assoluto!).

Purtroppo emulare uno Z80 a 2Mhz su un NeoGeo con Motorola 68000 a 12Mhz è da associare a una missione impossibile sia in termini di peso computazionale che per differenza abissale dell’HW SNK rispetto un PC.

In questo caso non abbiamo la possibilità di renderizzare grafica direttamente in VRAM perché il NeoGeo è capace solo di rappresentare a video o sprite o testo (modalità fix) quindi il “barbatrucco” sta nell’inventare un trick di programmazione atualmente in fase di analisi…

Continua a seguire gli aggiornamenti sullo sviluppo –> http://www.iocero.com/eventdetail.aspx?idevent=27312

RetroIsTheOnlyFuture!

BEY

http://www.IoCero.com

Visto che nessuno l’ha mai fatto mi sono detto: “perché non realizzare un emulatore di galaxian su NeoGeo CD?”…..Non l’avessi mai fatto  

Devo ammettere che il “progettino” richiede più tempo di quanto immaginassi ma l’importante è iniziare con un minimo di analisi.

Ad oggi sono riuscito a far funzionare un mini core Z80 atto a emulare la scheda arcade del gioco con output a video di soli char ASCII per verificare il corretto avviamento del mini emulatore. Quello che manca è una interfaccia grafica che traduca il contenuto della VRAM della scheda originale e lo converte per il chip video del NGCD.

Chi si vuole aggregare nell’impresa? Ok ok continuerò da solo….. 

SCARICA L’ISO PER NEOGEO CD –> http://www.filedropper.com/neogalagaemu

News e Blog Dev Link -> http://www.iocero.com/eventdetail.aspx?idEvent=21009

Stay Tuned!

RetroIsTheOnlyFuture!

BEY From St@ff www.IoCero.com

Approfittando del fine settimana ho cercato di mettere un po’ di ordine nel marasma di documentazione retroinformatica che ho accumulato nei miei hard disk. Sscansioni di documenti, manuali e libri vari affollavano i miei supporti magnetici senza una minima catalogazione e spesso capitava di ignorare persino ciò che avevo o l’ubicazione di ciò che ero sicuro di avere. L’idea era di organizzare uno “spazio di lavoro” per poter approfondire la programmazione di alcune macchine in maniera più ragionata.

Lungi dall’aver terminato di sistemare il caos imperante (la lotta in questo senso sarà lunga) devo dire che i frutti che tuttavia ho ottenuto da questo lavoro sono stati davvero piacevolmente sorprendenti!

Ho scoperto infatti di avere  già da tempo immagazzinato tra la varia documentazione, le scansioni dell’edizione italiana del libro MSX2 Basic + MSX DOS di A. Sickler e A. Van Utteren, l’edizione distribuita da Philips coi suoi MSX2.

Sembra sia un libro abbastanza ricercato nella nostra lingua, io stesso, ignorando fin’ora di averlo, avevo precedentemente contattato diversi utenti MSX molto più navigati di me per trovarlo ma sembra che fosse proprio difficile ottenerlo.

E invece, quando mi ero rassegnato a usare il PDF dell’edizione francese e stavo valutando l’acquisto di una copia spagnola, frugando in un bell’archivione MSX che avevo già da diverso tempo tra i libri italiani guarda un po’ cosa ti salta fuori!

La scansione proprio di quest’oggettino del desiderio (almeno mio).

Lesto monto un PDF dalle scan delle singole pagine e subito mi balena l’idea che forse anche qualcun altro potrebbe esserne alla ricerca, e quindi lo metto a disposizione di tutti tramite il link alla fine di quest’articolo che potrete incontrare anche nella sezione “Download” del blog.

Spero che vi possa essere utile, fatemi sapere.
Link: (Libri – MSX) MSX2 Basic + MSX DOS Philips (A. Sickler – A. Van Utteren)

Un ottimo IDE cross-platform per sviluppo di codice per macchine retro.

Se avete sempre sognato di scrivere in maniera facile e veloce un giochino sul vostro computer di 30 anni fa, TommyGun è lo strumento che fa per voi.

TommyGun non si può certo definire un progetto recente e sicuramente coloro che bazzicano l’ambito della retro programmazione ne avranno sentito parlare, ma per tutti gli altri può essere interessante.

Si tratta di un ambiente integrato di sviluppo che comprende una console di sviluppo codice, uno sprite editor, strumenti per il debug e quanto possa essere necessario per sviluppare un gioco con estrema facilità.

Sono compresi i vari dialetti BASIC delle varie macchine, l’assembly specifico per le CPU utilizzate e le relative mappe di memoria di ogni computer e addirittura e previsto uno specifico compilatore C!

Il progetto ha il suo punto di forza nella possibilità di scrivere codice NATIVO per tutte le macchine che sono/saranno supportate. Ovvero come spiegato dall’autore l’IDE è attualmente volontariamente limitato al supporto di varie macchine 8 e 16 bit (per ora essenzialmente Spectrum, C64 e Amstrad), ma è teroicamente un IDE modulare e aperto a qualunque piattaforma, infatti nei TODO l’autore si prefigge di realizzare il supporto per una varia quantità di macchine, console incluse.

Il progetto sfortunatamente è fermo (ma non ufficialmente cancellato) dal 2009, si spera che l’autore voglia e/o possa riprenderlo al più presto e completare i moduli di supporto delle altre macchine, magari mandargli una tonnellata di mail all’indirizzo tommygun.ide@gmail.com potrebbe invogliarlo a riprendere il lavoro e magari qualcuno volenteroso potrebbe dargli una mano.

A onor del vero l’unico screen shot presente sul sito cita in basso un supporto a Windows7 (non ufficialmente supportato da TommyGun anche se funzionante) e l’anno 2010 riferendosi però a un “fantomatico” ZX Game Studio (di cui non si rova traccia su internet) con supporto esclusivo per ZX Spectrum anche se le finestre dell’editor sono charamente quelle di TommyGun… Mistero!

Intanto potete divertirvi con quello che c’è, da parte mia se riuscirò a concludere qualcosa di produttivo con questo strumento o altri simili (come l’eccellente CBM .prg Studio esclusivo per sistemi Commodore di cui vi parlerò prossimamente) magari realizzerò una serie di piccole “lezioni” (scusate la parolona) per realizzare un semplice giochino sul vostro vecchio, caro mostriciattolo di silicio.

Link a TommyGun retro development IDE: http://www.users.on.net/~tonyt73/TommyGun/

Update 11/03/2014

Come gentilmente fatto notare dall amico Farox, in un commento al post che trovate più sotto, sebbene il sito originale non sia più raggiungibile il progetto pare essersi spostato su Sourceforge (quindi opensource) dove potrete trovare una versione del 2011 ( la 0.10.0) che però da compilare. Speriamo che l’autore continui con lo sviluppo di questo interessante tool.

L’URL per il download è il seguente:
http://sourceforge.net/projects/tommygun/