Ready64 Forum
Commodore 64 => Programmazione, Grafica e Musica => Topic aperto da: zimox - 17 Novembre 2004, 19:08:14
-
un saluto
non avendo le necessarie capacita' in lm per poter programmare un comando del tipo print using "x.xx"
ho proceduto cosi' in basic sperando di non aver fatto una .........di codice ;)
5 a=numero:a$=str$(a)
10 if a-int(a)=0 then a$=a$+".00"
oppure
10 fort=1to len(a$):if mid$(a$,t,1)<>"."then next t:a$=a$+".00"
poi
20 if mid$(a$,len(a$)-1,1)="."then a$=a$+"0"
non sempre va tutto bene perche' capita dopo moltiplicazioni multiple di trovarmi a=x.00000001... addio controlli
e sono insopportabilmente dispendiose e lente perche' sono all' interno di for next con matrici :sonno:
si puo' fare qualcosa di piu' efficiente?
saluti e finalmente dopo un po' sono ancora tra voi :)
zimox
:)
-
Ciao
ho proceduto cosi' in basic
Il problema è che per implementare una nuova istruzione serve modificare la rom del computer che gestisce l'istruzione PRINT in modo che tutte le volte che digiti
un'istruzione del tipo
PRINT USING "$[formato]",%[valore]
Il C64 esamini il parametro [formato],quindi il parametro [valore],e lo stampi di conseguenza;per questo serve l'assembler.
Senza toccare la rom del Basic,puoi usare un programmino di questo genere:
;*** SEMPLICE EMULAZIONE DI UNA PRINT USING ***
; USO DA BASIC: SYS 49152,formato,valore
; ESEMPIO:
; SYS 49152,X.XXX,3
; 3.000
; READY.
* = $c000
lda #$2e
jsr param ; calcola il n.di cifre prima di .
stx $fb
lda #$2c
jsr param ; calcola il n.di cifre dopo .
stx $fc
skip lda #$00
jsr param
sec
cpx $fb
beq ok
bcc ok
jmp $b248 ; errore di formato
ok beq print
fill lda #$30
jsr $ffd2
dec $fb
cpx $fb
bne fill ; riempie la parte intera con gli zeri
print sec
lda $7a
sbc $fb
sta $7a
ldy #$00
go lda ($7a),y
jsr $ffd2
iny
cpy $fb
bne go
lda #$2e
jsr $ffd2 ; stampa .
loop dec $fc
bmi exit
lda #$30
jsr $ffd2
jmp loop ; stampa gli zeri finali
exit jmp $a474 ; torna al prompt
param sta $02
ldx #$ff ; inizializza contatore per le cifre prima di .
ldy #$00
read lda ($7a),y; legge il carattere attuale
cmp $02 ; se è . esce
beq ret
inx ; incrementa puntatore
inc $7a ; incrementa puntatore al carattere
bne cont
inc $7b
cont jmp read
ret rts
-
Qualcosa di meglio.Questa routine supporta anche i numeri con parte frazionaria non nulla.
;*** SEMPLICE EMULAZIONE DI UNA PRINT USING ***
; USO DA BASIC: SYS 49152,formato,valore
; ESEMPIO:
; SYS 49152,X.XXX,3.5
; 3.500
; READY.
* = $c000
lda #$2e
jsr param
stx $fb ; salva n.cifre da rappresentare (parte intera)
lda #$2c
jsr param
sta $02
inc $02
stx $fc ; salva n.cifre da rappr.(parte frazionaria) + spiazzamento
lda #$2e
jsr param
sta $03
inc $03
stx $fd ; calcola n.di cifre parte intera + spiazzamento
lda #$00
jsr param
stx $fe
lda $fc
cmp $fe
bcc error
lda $fb
cmp $fd
bcc error
beq ok
ldx $fb
jsr fill
ok ldx $02
lda #$2e
sta $ff
jsr print ; scrive la parte intera
lda #$2e
jsr $ffd2 ; scrive .
ldx $03
lda #$00
sta $ff
jsr print
fill2 lda $fe
cmp $fc
beq exit
ldx $fc
sta $fd
jsr fill
exit jmp $a474 ; torna al prompt
print lda $0200,x
cmp $ff
beq done
jsr $ffd2 ; scrive la parte intera
inx
jmp print
done rts
fill lda #$30
jsr $ffd2
dex
cpx $fd
bne fill ; riempie di zeri la parte intera e frazionaria
rts
error jmp $b248 ; errore di formato
param sta $0313
ldx #$ff ; inizializza contatore per le cifre prima di .
ldy #$00
read lda ($7a),y ; legge il carattere attuale
cmp $0313 ; se è il simbolo cercato,esce
beq ret
inx ; incrementa puntatore
inc $7a ; incrementa puntatore al carattere
bne cont
inc $7b
cont jmp read
ret lda $7a
rts
-
ciao Alberto
ti ringrazio per la routine
anche la sys come comando e' perfetta per lo scopo
provero' ad implementarla con linee data in testa al programmino basic che ho fatto
saluti :)
-
print lda $0200,x
In questo modo funziona solo da immediate mode, e non da programma. Bisognerebbe stabilire in testa alla funzione un puntatore copiando $7a-$7b in un puntatore utility e usare quello. Ho tentato di modificarlo ma anche cosi' non va "sempre" bene, perche' puo' trovare le stringhe da leggere a cavallo di 2 pagine.
* = $c000
lda #0
sta $22; $22-23 ptr buffer ($0200 imm. mode o indir. prg basic)
lda $7b
sta $23
lda #$2e
jsr param
stx $fb ; salva n.cifre da rappresentare (parte intera)
lda #$2c
jsr param
sta $02
inc $02
stx $fc ; salva n.cifre da rappr.(parte frazionaria) + spiazzamento
inc1
lda #$2e
jsr param
sta $03
inc $03
stx $fd ; calcola n.di cifre parte intera + spiazzamento
lda #$00
jsr param
stx $fe
lda $fc
cmp $fe
bcc error
lda $fb
cmp $fd
bcc error
beq ok
ldx $fb
jsr fill
ok ldy $02
lda #$2e
sta $ff
jsr print; scrive la parte intera
lda #$2e
jsr $ffd2; scrive .
ldy $03
lda #$00
sta $ff
jsr print
fill2 lda $fe
cmp $fc
beq exit
ldx $fc
sta $fd
jsr fill
exit rts ;jmp $a474; torna al prompt
print lda ($22),y
cmp $ff
beq done
cmp #$3a ;":"
beq done
jsr $ffd2; scrive la parte intera
iny
jmp print
done rts
fill lda #$30
jsr $ffd2
dex
cpx $fd
bne fill ; riempie di zeri la parte intera e frazionaria
rts
error jmp $b248; errore di formato
param sta $0313
ldx #$ff ; inizializza contatore per le cifre prima di .
ldy #$00
read lda ($7a),y; legge il carattere attuale
cmp $0313; se è il simbolo cercato,esce
beq ret
cmp #$3a ;":"
beq ret
inx ; incrementa puntatore
inc $7a ; incrementa puntatore al carattere
bne cont
inc $7b
cont jmp read
ret lda $7a
rts
Infatti se si prova un prg del genere
start tok64 testprtu.prg
0 dv=peek(186)
1 SYS57812"prtusing.prg",dv,0:POKE780,0:POKE781,0:POKE782,192:SYS65493
10 print"test print using"
11 print"test print using"
12 print"test print using"
13 print"test print using"
14 print"test print using"
15 print"test print using"
16 print"test print using"
17 print"test print using"
18 print"test print using"
19 print"test print using"
20 print"test print using"
21 print"test print using"
22 print"test print using"
23 print"test print using"
100 print "123.4 using xxx.xxx=";:sys49152,XXX.XXX,123.4:print" ok"
110 print "23.41 using xxx.xxx=";:sys49152,XXX.XXX,23.41:print" ok"
stop tok64
si vedra' che la riga 110 stampera' del garbage, mentre eliminando la riga 23 funziona.
Bisogna anche tenere conto che si potrebbe voler stampare una variabile e non un valore immediato.
-
Bisogna anche tenere conto che si potrebbe voler stampare una variabile e non un valore immediato.
E' vero:non ci avevo pensato :huh:
Mò vedo se riesco a scrivere qualcosa che risolva il problema del garbage e funzioni con le variabili...
Bye
-
Ok,sono riuscito ad agganciarmi ad alcune routine del sistema operativo:adesso è possibile usare l'istruzione con variabili inserite in un programma Basic.
Non ho ancora testato il problema del garbage,domani vedrò che si può fare.
Ciauz
; PRINT USING MIGLIORATA USANDO ALCUNE ROUTINE DEL SISTEMA OPERATIVO
;
; USO
;
; SYS 49152,formato,[valore/variabile]
;
* = $c000
textchar = $0073
illegal = $b248
getvar = $af28
convert = $bddd
ldx #$00
ldy #$00
stx $fb
sty $fc
stx $fd
sty $fe
stx $02
l1 jsr textchar
cmp #$2e ; "."
beq l2
inx
jmp l1
l2 jsr textchar
cmp #$2c ; ","
beq l3
iny
jmp l2
l3 lda $7a
sta $fd
lda $7b
sta $fe
jsr textchar
beq flag ; fine riga
cmp #$2e ; "."
beq l4
cmp #$3a ; fine istruzione
beq flag
cmp #$30 ; carattere non valido
bcc error
cmp #$41 ; variabile
bcs var
inc $fb
jmp l3+8
flag inc $02 ; flag indicatore di un numero intero
l4 cpx $fb
bcs l5
error jmp illegal
l5 lda $02
bne l6
jsr textchar
beq l6
cmp #$3a
beq l6
inc $fc
jmp l5
l6 cpy $fc
bcs cont
jmp error
cont cpx $fb
beq print
jsr fill
print clc
lda $fb
adc $fc
sta $fb
inc $fb
inc $fb
tya
pha
ldy #$01
lda ($fd),y ; stampa il numero
cmp #$3a
beq chk
jsr $ffd2
iny
cpy $fb
bne print+15
chk lda $02
beq skp ; stampa "." solo per i numeri decimali
lda #$2e
jsr $ffd2
skp pla
tax
cpx $fc
beq ret
lda $fc
sta $fb
jsr fill
ret rts
fill lda #$30 ; riempie di zeri
jsr $ffd2
dex
cpx $fb
bne fill+2
rts
var tya
pha
txa
pha
jsr getvar ; risale all'indirizzo della variabile
jsr convert ; la converte in formato ASCII
ldx #$00
ldy #$00
count lda $0101,x
beq exit1
cmp #$2e
beq exit1+2
inx
jmp count
exit1 inc $02 ; flag indicatore di un numero intero
stx $fb
pla
cmp $fb
bcs ok
jmp illegal
ok inx
sta $fc
lda $02
bne exit2
lda $0101,x ; stampa il numero
cmp #$00
beq exit2
inx
iny
jmp ok+3
exit2 sty $fd
pla
cmp $fd
bcs ok2
jmp illegal
ok2 sta $fe
cmpr ldx $fc
cpx $fb
beq prnt2
jsr fill
prnt2 ldx #$00
lda $0101,x
beq prnt3
jsr $ffd2
inx
jmp prnt2+2
prnt3 lda $02
beq pass
lda #$2e
jsr $ffd2 ; stampa "." (per i numeri interi)
pass ldx $fe
cpx $fd
beq end
lda $fd
sta $fb
jsr fill
end rts
-
Ok,sono riuscito ad agganciarmi ad alcune routine del sistema operativo:adesso è possibile usare l'istruzione con variabili inserite in un programma Basic.
Non ho ancora testato il problema del garbage,domani vedrò che si può fare.
Complimenti per l'ottimo lavoro, funziona perfettamente, gia' provato anche nel caso che i parametri si trovino a cavallo tra le pagine, sia come var che come val. immediati :metallica:
-
Complimenti per l'ottimo lavoro, funziona perfettamente
Grazie,meno male che nel Kernal c'era una routine bella bella per la conversione virgola mobile/ASCII,altrimenti sai che fatica scrivere una routine su misura... :doh: :overkiller:
C'era ancora un piccolo problema con i valori immediati e i : (risolto inserendo un flag di controllo).La versione modificata è nel post sopra. :)
P.S.:Se riscontrate ancora problemi,o qualcuno ha qualcosa di meglio (soprattutto, di più breve) da proporre,soluzioni alternative sono ben accette.
Bye
:ciauz:
-
; PRINT USING MIGLIORATA USANDO ALCUNE ROUTINE DEL SISTEMA
; OPERATIVO (CON SUPPORTO DEL TRONCAMENTO)
; USO
;
; SYS 49152,formato,[valore/variabile/espressione]
* = $c000
textchar = $0073
illegal = $b248
print = $aaa0
char = $ffd2
; COPIA LA ROM BASIC CAMBIANDO ALCUNI BYTE PER EVITARE LA PRINT
lda $0313
bne ready ; controllo per la modifica del Basic
inc $0313
ldy #$00
lda #$00
sta $fb
lda #$a0
sta $fc
copy lda ($fb),y
sta ($fb),y
iny
bne copy
inc $fc
lda $fc
cmp #$c0
bne copy
lda #$4c
ldx #$e5
ldy #$aa
sta $aad9
stx $aada
sty $aadb ; modifica parte del Basic per evitare la stampa
lda #$60 ; nel formato predefinito
sta $ab29
ready jsr switch ; attiva la RAM sotto la ROM
ldx #$00
ldy #$00
stx $02
l1 jsr textchar
cmp #$2e ; "."
beq l2
inx
jmp l1
l2 stx $fb
jsr textchar
cmp #$2c ; ","
beq l3
iny
jmp l2
l3 sty $fd
jsr textchar
jsr print ; valuta l'espressione e ne deposita
; il risultato sulla pila :))
ldx #$00
scan1 lda $0101,x
beq exit1
cmp #$2e
beq exit1+2
inx
jmp scan1
exit1 inc $02
cpx $fb ; compara la parte intera del numero
bcc ok1 ; con quella da rappresentare
beq ok1
jsr switch
jmp illegal
ok1 stx $fc
lda $0100
jsr char ; stampa segno
ldx $fb
cpx $fc
beq skip1
jsr fill
skip1 ldx #$00
lda $0101,x ; stampa parte intera
beq next
cmp #$2e
beq next
jsr char
inx
jmp skip1+2
next lda #$2e
jsr char ; stampa "."
lda $02
beq skip2
ldx $fd
ldy #$00
sty $fc
jsr fill ; riempie di zeri fino alla fine
jmp ret
skip2 inx
lda $0101,x
beq check ; finite le cifre decimali
jsr char
inx
dec $fd ; stampa la parte decimale (con il troncamento)
bne skip2+1
check lda $fd ; troncamento delle cifre decimali
beq ret
ldx $fd
ldy #$00
sty $fc
jsr fill ; riempimento con zeri
ret lda #$0d
jsr char ; stampa l'invio dopo il numero
jsr switch ; riattiva la ROM
rts
fill lda #$30 ; riempie di zeri
jsr char
dex
cpx $fc
bne fill+2
rts
switch lda $01
eor #$01
sta $01
rts
-
Per migliorare le prestazioni di questa v3 bisognerebbe controllare se il basic e' gia' stato copiato e patchato ad esempio
jsr switch
ldx $aac2
jsr switch
cpx #$ea
beq inizio
(trasf basic)
lda #$ea
patchloop
ldx #$05
sta $aac2,x
dex
bpl patchloop
inizio
(resto della routine)
Pero' occhio che questa versione con alcuni valori da' ?FORMULA TOO COMPLEX
ad esempio
1 sys49152,xxx.xxx,1.5
2 goto 1
prima o poi stampera' valori strani o l'errore.
Io intanto ho preso la tua V2 e l'ho ridotta di dimensioni. Ho usato pero' dasm come compilatore.
org $c000
;Basic/Kernal routines
textchar = $0073
illegal = $b248
getvar = $af28
convert = $bddd
CHROUT = $ffd2
;ZP variabili,5 bytes
zpcntr1 = $fb
zpcntr2 = zpcntr1+1
zpadd = zpcntr1+2
zpflag = zpcntr1+4
;---------------------------
lda #0
ldx #(zpflag-zpcntr1+1)
tay
inix sta zpcntr1-1,x
dex
bne inix
;---------------------------
l1 jsr textchar
cmp #$2e ; "."
beq l2
inx
bne l1
l2 jsr textchar
cmp #$2c ; ","
beq l3
iny
bne l2
l3 lda $7a
sta zpadd
lda $7b
sta zpadd+1
l3p8 jsr textchar
beq flag ; fine riga
cmp #$2e ; "."
beq l4
cmp #$3a ; fine istruzione
beq flag
cmp #$30 ; carattere non valido
bcc error
cmp #$41 ; variabile
bcs var
;---------------------------
inc zpcntr1
bne l3p8
flag inc zpflag ; flag indicatore di un numero intero
l4 cpx zpcntr1
bcc error
l5 lda zpflag
bne l6
jsr textchar
beq l6
cmp #$3a
beq l6
inc zpcntr2
bne l5
l6 cpy zpcntr2
bcc error
cont cpx zpcntr1
beq print
jsr fill
print clc
lda zpcntr1
adc zpcntr2
;sta zpcntr1
adc #$02 ;inc zpcntr1
sta zpcntr1 ;inc zpcntr1
tya
pha
ldy #$01
print15 lda (zpadd),y ; stampa il numero
cmp #$3a
beq chk
jsr CHROUT
iny
cpy zpcntr1
bne print15
chk lda zpflag
beq skp ; stampa "." solo per i numeri decimali
lda #$2e
jsr CHROUT
skp pla
tax
cpx zpcntr2
beq end
lda zpcntr2
sta zpcntr1
jmp fill
;---------------------------
error jmp illegal
;---------------------------
var tya
pha
txa
pha
jsr getvar ; risale all'indirizzo della variabile
jsr convert ; la converte in formato ASCII
;ldx #$00
;ldy #$00; a/x = 0 al ritorno da $bddd
tay
count lda $0101,x
beq exit1
cmp #$2e
beq exit12
inx
bne count
;---------------------------
exit1 inc zpflag ; flag indicatore di un numero intero
exit12 stx zpcntr1
pla
cmp zpcntr1
bcc error
ok inx
sta zpcntr2
ok3 lda zpflag
bne exit2
lda $0101,x ; stampa il numero
beq exit2
inx
iny
bne ok3
exit2 sty zpadd
pla
cmp zpadd
bcc error
ok2 sta zpadd+1
cmpr ldx zpcntr2
cpx zpcntr1
beq prnt2
jsr fill
prnt2 ldx #$00
prnt22 lda $0101,x
beq prnt3
jsr CHROUT
inx
bne prnt22
prnt3 lda zpflag
beq pass
lda #$2e
jsr CHROUT ; stampa "." (per i numeri interi)
pass ldx zpadd+1
cpx zpadd
beq end
lda zpadd
sta zpcntr1
;---------------------------
fill lda #$30 ; riempie di zeri
fill2 jsr CHROUT
dex
cpx zpcntr1
bne fill2
end rts
-
Ho anche messo QUA (http://iancoog.altervista.org/hid/prtusing.rar) un rar con i sorgenti e d64 di prova
-
Ok,vedo che si può fare per risolvere il ?FORMULA TOO COMPLEX.Proverò a togliere le parti della PRINT inutili.
Bye
-
Pero' occhio che questa versione con alcuni valori da' ?FORMULA TOO COMPLEX
ad esempio
1 sys49152,xxx.xxx,1.5
2 goto 1
prima o poi stampera' valori strani o l'errore.
un saluto
desidero ringraziare iAN e Alberto per l' interessamento... ;)
pero ' a me e' da 20 minuti che sul mio c64c fa questo goto 1 ma tutto va alla perfezione ...anche cambiando il valore va tutto bene...meglio cosi' :)
zimox
modifica....
naturalmente intendevo la routine gia' bella e pronta di iAN :P
-
Versione 3 corretta:risolto il problema del ?FORMULA TOO COMPLEX e inserito un semplice controllo per skippare la modifica del Basic quando non più necessaria.
Ciauz :)
-
Altro approccio;stavolta la routine consente il troncamento della parte decimale (ho dovuto inserirlo per evitare errori ?ILLEGAL QUANTITY causati dalle approssimazioni difettose,che purtroppo si vedono anche con il troncamento alla seconda cifra decimale).
Rimane il problema dei numeri molto piccoli (da 0.001) e molto grandi
(da 1000000000),per i quali il C64 usa la notazione esponenziale (ad esempio
0.0001 = 1E-04,1000000000 = 1E+09);il prossimo passo è convertire questi valori in decimale.
:ciauz:
-
Rimane il problema dei numeri molto piccoli (da 0.001) e molto grandi
(da 1000000000),per i quali il C64 usa la notazione esponenziale (ad esempio
0.0001 = 1E-04,1000000000 = 1E+09);il prossimo passo è convertire questi valori in decimale.
Ciao Alberto
guarda che io sarei a posto anche cosi' :D
a tua scelta se trovi l' argomento ancora da approfondire :)
-
Ciao zimox :)
Tranquillo,questo surplus lo sto facendo io per divertirmi (e poi,visto che se ne ha la possibilità,perchè non fare le cose per bene? ;) ),e poi credo che possa essere utile alla comunità vedere qualcosa di simile ogni tanto (hey,ma nessuno propone qualcosa a parte le solite 4 o 5 persone? :D ).
Bye
:c64:
-
Ottimo ottimo! :mavieni:
Tranquillo,questo surplus lo sto facendo io per divertirmi
Esattamente, non e' che mi serva fare una print using perche' da LM si fa molto prima, ma e' intressante riuscire a scrivere routine che sfruttano le "complicate" chiamate alla Rom Basic...
hey,ma nessuno propone qualcosa a parte le solite 4 o 5 persone?
Di' pure 1-2, Alberto :stordita:
Purtroppo cio' e' sempre piu' demoralizzante.
-
Di' pure 1-2, Alberto :stordita:
Purtroppo cio' e' sempre piu' demoralizzante.
Purtroppo la programmazione è già di per sè un fatto di nicchia, la maggior parte delle persone non si trova a suo agio con numeri esadecimali e compagnia bella... ed inoltre bisogna tenere presente il numero limitato di persone che sono interessate all'emulazione del C64 o del C64 in senso stretto.
Se ci penso e unisco le due cose, ti dico che secondo me la situazione potrebbe anche essere molto peggiore, vi confesso che sinceramente non mi aspettavo un successo così grande per la sezione programmazione!
Stiamo spezzando le reni (passatami l'espressione scherzosa, spero di non irritare nessuno) alla sezione "Cerco un Gioco" e questo è un dato mooolto confortante per me, tenendo conto che la sezione Cerco un gioco (poco interessante imho) è online da 2 anni, mentre la sezione "Programmazione" avrà si è no 10 mesi.
Ma soprattutto: non si può costringere la gente ad interessarsi alla programmazione... anche a me piacerebbe ci fossero più artisti Bitmap, mentre invece mi risulta che non ci sia proprio nessuno.
Come se non bastasse bisogna tenere presente la freddezza delle maggior parte delle persone, allorchè si tratta di portare il proprio contributo anche solo - ad esempio - partecipando alle discussioni sul forum.
Pensate che - provo a fare un esempio parallelo - per 1 anno ho tenuto in home page l'invito a spedirmi DOX dei giochi perchè ritenevo utile che ci fosse anche in Italia una bibilioteca online del Commodore64. L' idea era quella di creare una specie di "Project64" fatte le debite proporzioni.
Bè Sapete quanti mi hanno risposto?
NESSUNO
Proprio così, in 1 anno di pubblicazione nella index (e ora nelle pagine interne) ho ricevuto ZERO manuali da pubblicare, e questo è il risultato:
http://ready64.altervista.org/italiano/manuali/ (http://ready64.altervista.org/italiano/manuali/)
Praticamente online ci sono solo le cose che ho trascritto io.
LE uniche 2 persone che mi hanno offerto collaborazione per la sezione sono stati ANX e MarC=Ello, ovvero due persone che sono già impegnate da sempre per la comunità e hanno già il loro bel da fare. Senza contare l'onnipresente Pyrat che ha donato Rampage, gioco del quale ho provveduto subito a fare i doc. (Il .tap esiste già).
Visto gli impegni di Marcello non me la sono sentita di chiedergli di impegnarsi nella scansione. In realtà speravo che si facesse avanti qualcun'altro visto che sicuramente esistono almeno 1 centinaio di persone in possesso di giochi originali (bacino molto più vasto rispetto ai potenziali programmatori, dunque) eppure nessuno si è mai fatto avanti.
Ops, scusate il mio sfogo, mi rendo conto di essere anddato un pò out topic sfogando tutti i miei dolori di giovane webmaster (Werther docet), ma spero che il mio messaggio sia arrivato, ed è un messaggio sicuramente positivo. Almeno i non la vedo così dura per quanto riguarda la programmazione, almeno finche voi terrete duro con il vostro entusiasmo... cosa che vi invito di continuare a fare ;)
PS
Riassunto di quanto scritto: non demoralizzatevi :stordita:
-
Purtroppo la programmazione è già di per sè un fatto di nicchia, la maggior parte delle persone non si trova a suo agio con numeri esadecimali e compagnia bella...
Ma soprattutto: non si può costringere la gente ad interessarsi alla programmazione...
Attenzione,forse il mio messaggio è stato frainteso:quando intendo "proporre qualcosa" intendo proporre QUALSIASI cosa (ovviamente,inerente al C64); non a tutti interessa la programmazione e non tutti sanno programmare (giusto e condivisibile,per carità),ma mezz'oretta di tempo per scrivere una (e dico UNA) recensione su un gioco che è piaciuto particolarmente,o su un programma di utilità,o ancora su un fenomeno di costume degli anni '80 legato al C64,credo che lo possa fare chiunque abbia avuto il C64.
Oppure ancora,qualcosa di hardware (come ha fatto Hiryu) o manualistica per gli emulatori (per esempio l'autocostruzione del cavo per l'mtap o anche una semplice guida all'uso del VICE e del CCS64,se non si vuol muovere nessuno lo farò io...);insomma,cose fattibilissime che richiedono pochissimo tempo e,di fatto,dànno tantissima soddisfazione per un nostalgico del mitico 8-bit :P .
bisogna tenere presente la freddezza delle maggior parte delle persone
Forse per alcune si tratta di freddezza,ma sono convinto che per altre si tratti di "timore" di proporre qualcosa di "stupido":e a queste persone vorrei dire che niente che possa arricchire di informazioni il sito (intendo proprio il sito,non soltanto il forum) è stupido o di poco conto.Ciascuno dà il suo (piccolo o grande) contributo,e il sito cresce automaticamente (spazio permettendo,eh Roberto :mattsid: )...
Praticamente online ci sono solo le cose che ho trascritto io.
Dal canto mio avevo inviato il manuale del datassette,e un altro membro aveva proposto la scansione del manuale del drive (e se avessi uno scanner sarei a cavallo...).
In definitiva,vorrei che da tutto questo emerga che CHIUNQUE è in grado di contribuire al sito:e siccome a frequentare questo forum non sono tre persone,ma (fortunatamente) un pò di più,spero che tutto questo venga recepito dalla comunità come un incoraggiamento,e non come una polemica.
...E anche chi si ferma solo a chiedere il nome di un gioco,se legge queste righe faccia un pensierino sulla possibilità di inviare un paio di recensioni (come dice Giobbe Covatta, eccheccevò??)...
Tornando a noi,in serata conto di pubblicare la routine definitiva.
Bye
:c64:
-
Ultima versione della routine simil print-using:
Bug conosciuti ( :angry: ): nessuno.
Note :maximo: :
- Per i numeri molto grandi le unità non vengono conteggiate (questo è un limite del sistema operativo,non risolvibile a meno di riscrivere interi pezzi dell'interprete Basic :doh: )
Ad esempio
PRINT 10000000001 = 1E+10
- La routine è venuta abbastanza lunga (circa 400 byte,speravo di occupare una pagina di memoria o poco più e ho dovuto persino adattare due routine per evitare di usare altra RAM...)
- La velocità di esecuzione è buona per i numeri grandi,meno per i numeri infinitesimali.
E' tutto. :)
; PRINT USING MIGLIORATA USANDO ALCUNE ROUTINE DEL SISTEMA OPERATIVO
;
; USO
;
; SYS 49152,formato,[valore/variabile/espressione]
* = $c000
textchar = $0073
illegal = $b248
print = $aaa0
char = $ffd2
; COPIA LA ROM BASIC CAMBIANDO ALCUNI BYTE PER EVITARE LA PRINT
lda $0313
bne ready ; controllo per la modifica del Basic
inc $0313
ldy #$00
lda #$00
sta $fb
lda #$a0
sta $fc
copy lda ($fb),y
sta ($fb),y
iny
bne copy
inc $fc
lda $fc
cmp #$c0
bne copy
lda #$4c
ldx #$e5
ldy #$aa
sta $aad9
stx $aada
sty $aadb ; modifica parte del Basic per evitare la stampa
lda #$60 ; nel formato predefinito
sta $ab29
ready jsr switch ; attiva la RAM sotto la ROM
ldx #$00
ldy #$00
stx $02
l1 jsr textchar
cmp #$2e ; "."
beq l2
inx
jmp l1
l2 stx $fb
jsr textchar
cmp #$2c ; ","
beq l3
iny
jmp l2
l3 sty $fd
jsr textchar
jsr print ; valuta l'espressione e ne deposita
; il risultato sulla pila :))
jsr ctrexp
ldx #$00
scan1 lda $0101,x
beq exit1
cmp #$2e
beq exit1+2
inx
jmp scan1
exit1 inc $02
cpx $fb ; compara la parte intera del numero
bcc ok1 ; con quella da rappresentare
beq ok1
jsr switch
jmp illegal
ok1 stx $fc
lda $0100
jsr char ; stampa segno
ldx $fb
cpx $fc
beq skip1
jsr fill
skip1 ldx #$00
lda $0101,x ; stampa parte intera
beq next
cmp #$2e
beq next
jsr char
inx
jmp skip1+2
next lda #$2e
jsr char ; stampa "."
lda $02
beq skip2
ldx $fd
ldy #$00
sty $fc
jsr fill ; riempie di zeri fino alla fine
jmp ret
skip2 inx
lda $0101,x
beq check ; finite le cifre decimali
jsr char
inx
dec $fd ; stampa la parte decimale (con il troncamento)
bne skip2+1
check lda $fd ; troncamento delle cifre decimali
beq ret
ldx $fd
ldy #$00
sty $fc
jsr fill ; riempimento con zeri
ret lda #$0d
jsr char ; stampa l'invio dopo il numero
jsr switch ; riattiva la ROM
rts
ctrexp ldx #$00
lda $0101,x
beq ret+8
cmp #$45 ; "E"
beq succ
inx
jmp ctrexp+2
succ inx
lda $0101,x
pha
inx
lda $0101,x
sec
sbc #$30
sta $03
inx
lda $0101,x
sbc #$30
sta $04
trdec lda $03
beq expo ; 0-9
ldx #$0a
cmp #$01
beq expo-1 ; 10-19
ldx #$14
cmp #$02
beq expo-1 ; 20-29
ldx #$1e ; 30-38
txa
expo ldx #$ff
ldy #$00
sec
adc $04
sta $fe
pla
cmp #$2b ; "+"
bne neg
lda #$01
sta $03
sta $04
jsr norm
lda #$30
jsr done
lda #$00
sta $0101,y
rts
neg dec $fe ; "-"
dec $fe
lda $fe
pha
stx $fe
lda #<buff
sta $03
lda #>buff
sta $04
jsr norm ; salva le cifre nel buffer
lda #$00
sta buff,y ; aggiunge il terminatore
lda #$30
sta $0101 ; "0"
lda #$2e
sta $0102 ; "."
ldy #$02
pla
sta $fe
lda #$30
jsr done ; riempie di 0
ldx #$00
queue lda buff,x
beq neg-6
sta $0101,y
inx
iny
jmp queue ; inserisce la coda
;*************************
; convertitore exp.-dec.
;*************************
norm inx
lda $0101,x
cmp #$2e
beq norm
cmp #$45
beq done-1
sta ($03),y
iny
dec $fe
bne norm
rts
done sta $0101,y
iny
dec $fe
bne done
rts
;*************************
fill lda #$30 ; riempie di zeri
jsr char
dex
cpx $fc
bne fill+2
rts
switch lda $01
eor #$01
sta $01
rts
buff
-
Per fortuna basta guardare la pagina "Team" del sito per vedere che ci sono molte persone che hanno contribuito, quindi la mia considerazione non vuole essere negativa al 100%. Questo avrei dovuto vspecificarlo :)
Anzi, sono molto contento di questo gruppo che si è creato.
E' anche vero che circa il 70% (!) delle persone che mi contattano per collaborare poi spariscono nel nulla costringendomi a perdite di tempo per leggere e rispondere alle mail, tanto che avevo pensato di chiudere il sito alle nuove collaborazioni, non potendo in alcun modo filtrare questi messaggi.
Per tutti coloro che mi hanno inviato materiale, te compreso, sto cercando di tornare a dedicarmi agli aggiornamenti, mi scuso per i ritardi nella pubblicazione. Cercherò di portarmi in piano al più presto.
scusate l'off topic ! chiudo qui :mechico:
-
Va bene,se nessuno ha niente da aggiungere ringrazio iAN CooG della collaborazione e voi tutti dell'attenzione.
Bye
:c64:
-
Complimenti veramente per il lavoro svolto! :metallica:
Di' pure 1-2, Alberto
Purtroppo cio' e' sempre piu' demoralizzante.
Il mio invito agli utenti e ai nostri lettori è quello di postare programmi, domande, consigli, trucchi e quant'altro venga loro in mente senza timore. Nessuno sarà mai preso in giro se posterà qualcosa di sbagliato. Anzi. Penso anche che l'assembly 6502/6510 non sia conosciuto da molte persone, e colgo l'occasione per precisare che anche il BASIC va bene; io ad esempio ho postato due programmi BASIC qualche tempo fa, ed esorto altri amici che come me fanno degli esperimenti anche in BASIC a farlo. Giusto per condividere una passione in comune ed imparare, insieme, nuovi trucchi e nuove tecniche. Magari anche dai programmi più banali possono nascere delle discussioni interessanti e costruttive.
Ciao!
-
Certo,condividere i propri dubbi e/o le proprie conoscenze serve a tutti. :)