Haunting Mansion (draft)

[Blizzard]

ciao!
vi posto la prima bozza del gioco (quasi completo) che sto scrivendo per C64
manca il teatrino della vittoria!
e manca l'immancabile blocco DATA
comunque la meccanica di gioco forse è conclusa.
Si tratta di una mezza stupidata in stile pacman :P in pratica tu sei un prode avventuriero... che si avventura in un parco condominiale medievale (in pratica un castello) e capisce che non è solo... ma che ci sono un mucchio di creature che vogliono giocare con lui... o con la sua testa.
Ad ogni piano del castello ci sono 4 chiavi quando le hai prese tutte puoi salire di un piano.
Quando sei arrivato in cima... tutte le creature scompaiono magicamente! e hai vinto
Storia banale a parte... l'ho inventata adesso mentre la scrivevo... questo è il mio primo gioco non testuale su c64.
Sfrutta per i personaggi una ridefinizione dei caratteri e il movimento è affidato al joystick.
Ci saranno 4 tipi di mostri che si differenziano per velocità di azione e tutti gli eventi si basano sul contatto.
Ovviamente come al solito randomizzo parecchie cose.
Prima di scriverlo sul c64 l'ho scritto sul gedit in modo da poterlo anche rilasciare su internet e in modo da evitare di riscrivere troppo codice quando dovevo cambiare qualche linea
A parte gli scherzi il mio coinquilino non è ancora tornato e non tocco il commodore da 2 settimane... quindi dovevo fare qualcosa
Il codice è commentato in maniera ordinaria REM e anche con qualche aggiunta :P // perdonatemela... è l'ultima volta che lo faccio... dal prossimo si programma come si deve o come si sarebbe dovuto 20 anni fa.

ecco il codice... commentate

Codice: Seleziona tutto

5 PRINT "{CLS}"
10 REM HAUNTING MANSION
20 PRINT "xxxxxxxxxxxxxxxxHAUNTING MANSIONxxxxxxxx"
30 PRINT "xxxDEVELOPED BY SANTOSTEFANO GIOVANNIxxx"
40 PRINT : PRINT
50 PRINT "xxxxxxxxHIT BUTTON 1 TO CONTINUExxxxxxxx"
60 IF(PEEK(564321)AND16)<>0THEN60
70 SCR=1024 : PRINT "{CLS}"
80 REM DISABILITA INTERRUPT E RIVELA ROM DEI CARATTERI
90 POKE56334,PEEK(56334)AND254
100 POKE1,PEEK(1)AND251
110 REM COPIA DEI CARATTERI IN RAM
120 PRINT "NOW LOADING" 
130 WALL=CHR$("v") //AL POSTO DI v IL CARATTERE PIENO... IL MURO
//QUESTO BLOCCO SERVE PER CREARE LA BARRA DI LOADING
140 FORI=0TO19
150 POKESCR+12*40+10+I,WALL
150 NEXTI
//END BARRA LOADING
160 J=100:K=1
170 FORI=0TO2048
180 POKE12288+I,PEEK(53248+I)
190 J=J-1
200 IFJ<>0THEN240
210 POKESCR+12*40+10+K,WALL
220 K=K+1
230 J=100
240 NEXTI
250 REM NASCONDE ROM CARATTERI E RIABILITA INTERRUPT
260 POKE1,PEEK(1)OR4
270 POKE56334,PEEK(56334)OR1
280 REM ABILITA NUOVO SET DI CARATTERI
290 POKE 53272,28
300 REM MEMORIZZA GRAFICA GIOCO
310 FORI=0TO47
320 READA
330 POKE12296+I+25,A
340 NEXTI
//END MEMORIZZAZIONE DELLA NUOVA GRAFICA
350 REM INIZIALIZZAZIONE DEL GIOCO
360 NUMLEVELS=10 : ACTLEVEL=1 :LIVES=4
370 DIM EX(5):DIM EY(5):DIM ESPEED(5):DIM ETYPE(5)
380 DIM EDIR(5):DIM EMOVE(5):ECOUNTER=0
390 PX=0:PY=0:ANIM=1//ANIM È IL NUMERO DEL FRAME
400 GP1=//CHARFRAME1PLAYER:GP2=CHARFRAME2PLAYER
410 DIM GFX(8)
420 GFX(0)=//GRAFICA MURO
425 GFX(1)=//GRAFICA VUOTO
430 GFX(2)=//GRAFICA CHIAVE
440 GFX(3)=//MOSTRO5
450 GFX(4)=//MOSTRO6
460 GFX(5)=//MOSTRO7
470 GFX(6)=//MOSTRO8
480 IFACTLEVEL>NUMLEVELSTHENGOTO6500  //RIGA DELLA VITTORIA
490 PRINT "{CLS}" : REM CARICA IL LIVELLO ATTUALE
500 FORI=1TO10
510 FORJ=1TO20
520 READA
530 IFA=1THENPOKESCR+I*40+J,GFX(0):GOTO660 //<NEXTJ>
540 IFA=0THENPOKESCR+I*40+J,GFX(1):GOTO660 //<NEXTJ>
550 IFA=2THENGOTO580
560 IFA=3THENPOKESCR+I*40+J,GFX(2):GOTO660 //<NEXTJ>
570 REM THIS IS THE PLAYER
580 POKESCR+I*40+J,GP1
590 PX=J:PY=I:GOTO660 //<NEXTJ>
600 REM THIS IS MONSTER
610 EX(ECOUNTER)=J:EY(COUNTER)=I:ETYPE(COUNTER)=A
620 EDIR(ECOUNTER)= INT(4*RND(1))+1
630 ESPEED(ECOUNTER)=9-A
640 EMOVE(ECOUNTER)=INT((3*A)/2) //CALCOLO DEL NUMERO DI MOSSE
650 ECOUNTER=ECOUNTER+1 
660 NEXTJ
670 NEXTI
680 REM CREAZIONE DEL CONTATORE DELLE VITE
690 REM SCRITTURA DELLA PAROLA LIVES
700 POKESCR+12*40+2,ASC("L")
710 POKESCR+12*40+3,ASC("I")
720 POKESCR+12*40+4,ASC("V")
730 POKESCR+12*40+5,ASC("E")
740 POKESCR+12*40+6,ASC("S")
750 REM DISEGNO DELLE VITE
760 FORI=1TOLIVES
770 POKESCR+13*40+I+1,GP1
780 NEXTI
790 NUMKEY=0 //NUMERO DI CHIAVI PRESE
800 REM CICLO DI GIOCO
810 FORI=0TO100:NEXTI:REM CICLO DI COMPENSAZIONE //...ANZI DI RALLENTAMENTO SE SERVE
820 REM ABBASSA VELOCITÀ E NUMMOSSE DI TUTTI I MOSTRI



//PARTE DEDICATA AL MOVIMENTO DEI MOSTRI

830 FORI=0TO4
840 ESPEED(I)=ESPEED(I)-1
850 EMOVE(I)=EMOVE(I)-1
860 IFEMOVE(I)>0THENGOTO890
870 EMOVE(I)=INT(((INT(4*RND(1))+1)*ETYPE(I))/4) //CALCOLO DEL NUMERO DI MOSSE
880 EDIR(I)= INT(4*RND(1))+1
890 IFESPEED(I)>0THENGOTO 1480 //SALTA LA PARTE DEL MOVIMENTO
900 ESPEED(I)=9-ETYPE(I)


1000 IFEDIR<>1THENGOTO1120  //ALLA FINE DELLA DIREZIONE1
1010 REM EDIR==1 MUOVI MOSTRO SU
1020 IFPEEK(SCR+(EY(I)-1)*40+EX(I))<>GFX(1)THENGOTO1070
1030 POKESCR+EY(I)*40+EX(I),GFX(1) //SCRIVO IL VUOTO
1040 EY=EY-1
1050 POKESCR+EY(I)*40+EX(I),GFX(ETYPE(I)) //SCRIVO IL MOSTRO
1060 GOTO1120 //ALLA FINE DELLA DIREZIONE1
1070 REM VERIFICA KILL DEL PLAYER
1080 IF EX(I)=PX AND (EY(I)-1)=PY THENGOTO5000----------//PLAYER KILL
1090 NEMICO URTA OSTACOLO
1100 EMOVE(I)=0
1110 GOTO 1480 //FINE PARTE MOVIMENTO


1120 IFEDIR<>2THENGOTO1240  //ALLA FINE DELLA DIREZIONE2
1130 REM EDIR==2 MUOVI MOSTRO GIU
1140 IFPEEK(SCR+(EY(I)+1)*40+EX(I))<>GFX(1)THENGOTO1190
1150 POKESCR+EY(I)*40+EX(I),GFX(1) //SCRIVO IL VUOTO
1160 EY=EY+1
1170 POKESCR+EY(I)*40+EX(I),GFX(ETYPE(I)) //SCRIVO IL MOSTRO
1180 GOTO1240 //ALLA FINE DELLA DIREZIONE2
1190 REM VERIFICA KILL DEL PLAYER
1200 IF EX(I)=PX AND (EY(I)+1)=PY THENGOTO5000----------//PLAYER KILL
1210 NEMICO URTA OSTACOLO
1220 EMOVE(I)=0
1230 GOTO 1480 //FINE PARTE MOVIMENTO


1240 IFEDIR<>3THENGOTO1360  //ALLA FINE DELLA DIREZIONE3
1250 REM EDIR==3 MUOVI MOSTRO DX
1260 IFPEEK(SCR+EY(I)*40+(EX(I)+1))<>GFX(1)THENGOTO1310
1270 POKESCR+EY(I)*40+EX(I),GFX(1) //SCRIVO IL VUOTO
1280 EX=EX+1
1290 POKESCR+EY(I)*40+EX(I),GFX(ETYPE(I)) //SCRIVO IL MOSTRO
1300 GOTO1360 //ALLA FINE DELLA DIREZIONE3
1310 REM VERIFICA KILL DEL PLAYER
1320 IF (EX(I)+1)=PX AND EY(I)=PY THENGOTO5000----------//PLAYER KILL
1330 NEMICO URTA OSTACOLO
1340 EMOVE(I)=0
1350 GOTO 1480 //FINE PARTE MOVIMENTO


1360 IFEDIR<>4THENGOTO1480  //ALLA FINE DELLA DIREZIONE3
1370 REM EDIR==4 MUOVI MOSTRO SX
1380 IFPEEK(SCR+EY(I)*40+(EX(I)-1))<>GFX(1)THENGOTO1430
1390 POKESCR+EY(I)*40+EX(I),GFX(1) //SCRIVO IL VUOTO
1400 EX=EX-1
1410 POKESCR+EY(I)*40+EX(I),GFX(ETYPE(I)) //SCRIVO IL MOSTRO
1420 GOTO1480 //ALLA FINE DELLA DIREZIONE3
1430 REM VERIFICA KILL DEL PLAYER
1440 IF (EX(I)-1)=PX AND EY(I)=PY THENGOTO5000----------//PLAYER KILL
1450 NEMICO URTA OSTACOLO
1460 EMOVE(I)=0
1480 REM FINE PARTE DEL MOVIMENTO
1490 NEXTI
//FINE PARTE DEL MOVIMENTO

//PARTE DEL MOVIMENTO PLAYER
1500 REM MOVIMENTO PLAYER
1510 V=15-(PEEK(56321)AND15)
1520 IFV=0THENGOTO2050 //SALTA LA PARTE DEL MOVIMENTO

//NORD
1530 IFV<>1THENGOTO1660 //FINE MOVIMENTO NORD
1540 REM VERIFICA CHIAVI MOSTRO E MURO
1550 CELL=PEEK(SCR+(PY-1)*40+PX)
1560 FORI=3TO6
1570 IFCELL=GFX(I)THENGOTO5000--------------//PLAYER KILL
1580 NEXTI
1590 IFCELL=GFX(0)THENGOTO2050 //SALTA LA PARTE DEL MOVIMENTO
1600 IFCELL=GFX(2)THENNUKEY=NUMKEY+1
//PLAYER RENDERING
1610 POKESCR+PY*40+PX,GFX(1)
1620 PY=PY-1
1630 IFANIM=1THENANIM=2:CELL=GP1:GOTO1650
1640 IFANIM=2THENANIM=1:CELL=GP2
1650 POKESCR+PY*40+PX,CELL:GOTO2050

//SUD
1660 IFV<>2THENGOTO1790 //FINE MOVIMENTO SUD
1670 REM VERIFICA CHIAVI MOSTRO E MURO
1680 CELL=PEEK(SCR+(PY+1)*40+PX)
1690 FORI=3TO6
1700 IFCELL=GFX(I)THENGOTO5000--------------//PLAYER KILL
1710 NEXTI
1720 IFCELL=GFX(0)THENGOTO2050 //SALTA LA PARTE DEL MOVIMENTO
1730 IFCELL=GFX(2)THENNUKEY=NUMKEY+1
//PLAYER RENDERING
1740 POKESCR+PY*40+PX,GFX(1)
1750 PY=PY+1
1760 IFANIM=1THENANIM=2:CELL=GP1:GOTO1780
1770 IFANIM=2THENANIM=1:CELL=GP2
1780 POKESCR+PY*40+PX,CELL:GOTO2050

//SINISTRA
1790 IFV<>4THENGOTO1920 //FINE MOVIMENTO SINISTRA
1800 REM VERIFICA CHIAVI MOSTRO E MURO
1810 CELL=PEEK(SCR+PY*40+(PX-1))
1820 FORI=3TO6
1830 IFCELL=GFX(I)THENGOTO5000--------------//PLAYER KILL
1840 NEXTI
1850 IFCELL=GFX(0)THENGOTO2050 //SALTA LA PARTE DEL MOVIMENTO
1860 IFCELL=GFX(2)THENNUKEY=NUMKEY+1
//PLAYER RENDERING
1870 POKESCR+PY*40+PX,GFX(1)
1880 PX=PX-1
1890 IFANIM=1THENANIM=2:CELL=GP1:GOTO1910
1900 IFANIM=2THENANIM=1:CELL=GP2
1910 POKESCR+PY*40+PX,CELL:GOTO2050

//DESTRA
1920 IFV<>8THENGOTO2050 //FINE MOVIMENTO DESTRA
1930 REM VERIFICA CHIAVI MOSTRO E MURO
1940 CELL=PEEK(SCR+PY*40+(PX+1))
1950 FORI=3TO6
1960 IFCELL=GFX(I)THENGOTO5000--------------//PLAYER KILL
1970 NEXTI
1980 IFCELL=GFX(0)THENGOTO2050 //SALTA LA PARTE DEL MOVIMENTO
1990 IFCELL=GFX(2)THENNUKEY=NUMKEY+1
//PLAYER RENDERING
2000 POKESCR+PY*40+PX,GFX(1)
2010 PX=PX+1
2020 IFANIM=1THENANIM=2:CELL=GP1:GOTO2040
2030 IFANIM=2THENANIM=1:CELL=GP2
2040 POKESCR+PY*40+PX,CELL:GOTO2050

//FINE MOVIMENTO
2050 REM VERIFICA FINE LIVELLO
2060 IFNUMKEY>=4THENACTLEVEL=ACTLEVEL+1:GOTO480
2070 GOTO800 //SALTA AL CICLO PRINCIPALE

//KILL DEL PLAYER
5000 LIVES=LIVES-1
5010 IFLIVES=0THENGOTO6000
5020 POKESCR+13*40+LIVES+1,GFX(1) //CONTROLLA QUESTA RIGA... DOVREBBE CANCELLARE L'ULTIMO OMINO
5030 REM VISUALIZZA IL PLAYER CON L'ANIMAZIONE DELLA KILL
5040 FORI=1TO100
5050 POKESCR+PY*40+PX,GP1
5060 POKESCR+PY*40+PX,GP2
5070 NEXTI
5080 POKESCR+PY*40+PX,GFX(1) //CANCELLO IL PLAYER
5090 REM RIPIAZZAMENTO RAND DEL PLAYER
5100 PX=INT(19*RND(1))+1
5110 PY=INT(9*RND(1))+1
5120 IFPEEK(SCR+PY*40+PX)<>GFX1THENGOTO5100
5130 GOTO800

6000 REM GAMEOVER
6010 PRINT"{CLS}"
6020 PRINT"GAME OVER!"
6030 PRINT"PRESS THE JOYSTICK BUTTON TO RESTART A NEW GAME"
6040 IF(PEEK(564321)AND16)<>0THEN6040
6050 GOTO390

6500 REM END GAME YOU WIN

[nuitari]

Sono commosso T_T quanto tempo che non vedevo codice del genere... TROPPO tempo...
Stasera, quando avrò tempo, lo caricherò dentro un emulatore o lo sposto su floppy da 5 1/4 e lo provo direttamente sul C64.

comunque, per caricare la grafica ti consiglio di usare le funzioni di salvataggio/caricameto della memoria. Mettere una ridefinizione caratteri tutta in blocchi DATA è imho da pazzi (per quanto ai tempi l'abbia fatto anch'io, prima d'imparare ad usare certi registri).

[Blizzard]

Sono commosso T_T quanto tempo che non vedevo codice del genere... TROPPO tempo...

già! fa un certo effetto

Sono commosso T_T quanto tempo che non vedevo codice del genere... TROPPO tempo...
Stasera, quando avrò tempo, lo caricherò dentro un emulatore o lo sposto su floppy da 5 1/4 e lo provo direttamente sul C64.

wow! riesci a caricarlo su emulatore??? quando l'ho completato me lo devi convertire così lo rilascio direttamente come .D64

comunque, per caricare la grafica ti consiglio di usare le funzioni di salvataggio/caricameto della memoria. Mettere una ridefinizione caratteri tutta in blocchi DATA è imho da pazzi (per quanto ai tempi l'abbia fatto anch'io, prima d'imparare ad usare certi registri).

Hehehe... non è che l'idea mi abbia fatto impazzire (ti ricordi la mongolfiera che scendeva per lo schermo??? gia al tempo mi aveva reso perplesso sui blocchi data )

In che senso parli di funzioni di salvataggio/caricamento dalla memoria??? intendi caricare tutto direttamente da nastro???
In pratica se non sto andando a pallino... dovrei fare qualcosa del tipo... creo un editor dove piazzo visualmente i pixel dei caratteri o i blocchi del livello e poi automaticamente me lo converte in dati e lo memorizzo su nastro giusto???
Se è così devo informarmi sul salvataggio/caricamento via codice che finora non ho mai usato

thx
ciao
Gio

[gallows]

Cacchio, non vedevo listati in basic per il C64 da anni, ricordo le mie avventure testuali di quando ero piccolo, nelle nottate in cui non riuscivo a dormire prendevo un quaderno e iniziavo a scrivere storie improbabili...
Ah, il for per simulare il caricamento....

Sarebbe bello se esistesse un terminale virtuale per un*x che imiti il C64 in tutti gli aspetti, esiste qualcosa del genere? Chissà, magari sarebbe un progetto interessante da iniziare... Anche solo per poter incollare i listati in maniera semplice...

[nuitari]

Mi spiego:

Puoi caricare blocchi di dati in 3 modi diversi:

1) all'interno del codice stesso con DATA
2) da storage tramite un ciclo e le funzioni di I/O (open, input, close).
3) da storage usando la funzione di caricamento del BASIC

La prima la conosci.

La seconda consiste nel fare quel che hai detto, un editor che ti salva i dati su storage in un file probabilmente sequenziale per poi caricarli con un ciclo dal basic (leeeeeeeeento).

La terza consiste nello sfruttare il LOAD del BASIC.
Normalmente, quando carichi un programma da storage con LOAD, il BASIC usa una sua funzione asm che carica dati a partire da un indirizzo, molto rapida.
L'indirizzo è deciso da dei registri (6 in tutto, se non ricordo male) e può essere alterato a piacere. La procedura è la seguente:

1) alteri i registri per indicare la zona di memoria in cui sono presenti i dati da salvare (ad esempio la zona in cui hai ridefinito i caratteri, con un editor o meno)
2) usi SAVE per salvare su storage
3) quando carichi, carchi con LOAD passando il parametro giusto (valore 1) che dice di caricare lo stream esattamente dove si trovava quando è stato salvato. Ad esempio, per caricare il file "caratteri" da floppy scrivi LOAD "caratteri", 8, 1 (il parametro 8 indica il primo drive, il CBM64 ne poteva usare funo a 4).

In questo modo puoi salvare blocchi di memoria molto grandi per poi ricaricarli in un lampo.
Quando ho tempo, ti faccio un esempio pratico, così vedi come si fa.

[Blizzard]

La terza consiste nello sfruttare il LOAD del BASIC.
Normalmente, quando carichi un programma da storage con LOAD, il BASIC usa una sua funzione asm che carica dati a partire da un indirizzo, molto rapida.
L'indirizzo è deciso da dei registri (6 in tutto, se non ricordo male) e può essere alterato a piacere. La procedura è la seguente:

1) alteri i registri per indicare la zona di memoria in cui sono presenti i dati da salvare (ad esempio la zona in cui hai ridefinito i caratteri, con un editor o meno)
2) usi SAVE per salvare su storage
3) quando carichi, carchi con LOAD passando il parametro giusto (valore 1) che dice di caricare lo stream esattamente dove si trovava quando è stato salvato. Ad esempio, per caricare il file "caratteri" da floppy scrivi LOAD "caratteri", 8, 1 (il parametro 8 indica il primo drive, il CBM64 ne poteva usare funo a 4).

cavolo! ti fa tantissimo!
vedo di informarmi su come funziona sta cosa.

In questo modo puoi salvare blocchi di memoria molto grandi per poi ricaricarli in un lampo.
Quando ho tempo, ti faccio un esempio pratico, così vedi come si fa.

Te ne sarei grato...almeno potrei dare un'occhiata ad un esempio concreto, anche se in linea generale sei stato molto chiaro.
Tieni solo presente che non ho il drive del floppy... quindi qualsiasi cosa la passerò su cassetta (non penso comunque sia un problema giusto??)

ciao
Gio

[nuitari]

No non lo è =) il tape ha un altro numero ad indicare il dispositivo, che non ricordo .

[Blizzard]

misà era il 4 ma ho seri dubbi... anche perchè per caricare da tape un programma mi bastava ometterlo

[Blizzard]

Ah, il for per simulare il caricamento....

hahah... non sai per quanto tempo ho avuto questo vizio ... è tipo il bambino che si fa la barba per sembrare grande... un piccolo programmatore che aggiunge codice per simulare un caricamento come il programmatore adulto che si ammazza per accorciarne invece i tempi

Sarebbe bello se esistesse un terminale virtuale per un*x che imiti il C64 in tutti gli aspetti, esiste qualcosa del genere? Chissà, magari sarebbe un progetto interessante da iniziare... Anche solo per poter incollare i listati in maniera semplice...

Wow! sarebbe forte!

[OT]
Mentre scrivo sto ascoltando una musica a tratti popolare, molto allegra.... l'emoticon che applade qua di fianco va incredibilmente a tempo con la musica e mi sto crepando dalle risate.
E il momento buono per spegnere il computer???
[/OT]

[nuitari]

Allora, ho riguardato la cosa del LOAD.

A conti fatti, non lo puoi usare con il basic .
Mi spiego: per usarla, devi alterare i registri che indicano dove si trova il programma BASIC in quel momento, per cui caricheresti si i dati, ma perderesti il programma caricato in quel momento. In effetti io la chiamavo con una funzione ASM ora che mi ricordo.

Forse, e dico forse, potresti usarla per caricare il programma basic ed il blocco dati in un colpo solo, entrambi contemporaneamente. Poi posto qui tutto quel che mi ricordo e vediamo .

[Blizzard]

Allora, ho riguardato la cosa del LOAD.

A conti fatti, non lo puoi usare con il basic .
Mi spiego: per usarla, devi alterare i registri che indicano dove si trova il programma BASIC in quel momento, per cui caricheresti si i dati, ma perderesti il programma caricato in quel momento. In effetti io la chiamavo con una funzione ASM ora che mi ricordo.

Doh!

Forse, e dico forse, potresti usarla per caricare il programma basic ed il blocco dati in un colpo solo, entrambi contemporaneamente.

mmm... qui mi perdo un attimo.
Da quello che sono riuscito a capire... dovrei avere un blocco DATA normale, scritto via codice... solo che non lo carico con un for???

Poi posto qui tutto quel che mi ricordo e vediamo .

heheh sono ansioso di dare un occhiata ad un dump del tuo cervello

ciao
Gio

[nuitari]

No, intendo: supponi di mappare la ridefinizione caratteri dalla locazione 40000 in poi (un numero a caso). Con i DATA dovresti mettere tutta la mappatura caratteri nel prog BASIC e spostarla dalla 40000 in poi con un for/read.

Quando carichi un prog basic viene caricato un blocco dati agli indirizzi specificati da quei registri famosi. Supponi di estendere artificiosamente l'area occupata dal prog basic e di caricare insieme ad esso anche i dati già posizionati nella memoria... ti risparmieresti il ciclo for. Dovrebbe funzionare, credo. Oppure potresti usare l'ASM .

[Blizzard]

No, intendo: supponi di mappare la ridefinizione caratteri dalla locazione 40000 in poi (un numero a caso). Con i DATA dovresti mettere tutta la mappatura caratteri nel prog BASIC e spostarla dalla 40000 in poi con un for/read.

Ahhhh! capito! effettivamente ci vogliono 30 sec per fare quel lavoretto di copia dei caratteri

Quando carichi un prog basic viene caricato un blocco dati agli indirizzi specificati da quei registri famosi. Supponi di estendere artificiosamente l'area occupata dal prog basic e di caricare insieme ad esso anche i dati già posizionati nella memoria... ti risparmieresti il ciclo for.

Hihihi! sei diabolico

Oppure potresti usare l'ASM .

zszszszszzs non penso che al momento sono in grado di scrivere asm

Preferisco l'idea di pigliare in giro la routine di caricamento e fargli caricare anche i caratteri in memoria

ciao
Gio