Routine Flash

[zimox]

 salve
ho fatto un piccolo programmino in basic...
e' sconfortante il fatto che il basic del c64 non possegga un comando
apposito di flash per una visualizzazione piu' efficace come nel c16
questa subroutine...

Codice: [Seleziona]

1000 print "[cursor up]testo":for t=0 to250:next:rem lettere o variabile in testo
1010 print"[rvs on][cursor up]testo":fort=0 to250:next
1020 get a$:if a$=""then 1000
mi fa perdere i punti   :D
come puo' essere fatta in lm considerando che il tempo 250 del 2  for e'
adatto per lo scopo ma sarebbe cmq interessante che si possa variare a piacimento evitando le continue chiamate con il gosub
utile considerare il seguente comando...
sys xxxxx,time flash on,time flash off,"testo o stringa"(;variabile)
e' perche no' ! utilizzabile anche, come si puo' vedere, con input
saluti
ps:se e' ben spiegata e' meglio  

[iAN CooG]

 Il c16 ha un bit/attributo apposta per il flash di ogni carattere, credo come per i colori, che il c64 non ha. Io ho provato a fare una routine MOLTO spartana che gestisce UNA sola stringa flashante alla volta...

Codice: [Seleziona]

; print flashing string
; v0.1 iAN CooG/HokutoForce
; sys 49152,delay,method,x,y,string
; sys 49152,0

    *= $c000

    JSR getnumpar  ; 1o param; 0 spegne, >0 durata del ritardo
    sta $02
    sta $fe
    beq deactivateirq

    jsr getnumpar  ; 2o param
    STA method    ; 0 norm/rev, >0  norm/spazi (flash)


    jsr getnumpar  ; 3o param; X coord
    STA $04

    jsr getnumpar  ; 4o param; Y coord
    STA $05

  ; 5o param, stringa
    JSR getstrparam
    sta $fb; lunghezza
    stx $fc;<indirizzo della stringa
    sty $fd;>indirizzo della stringa

    sei
    lda $02
    bne activateirq
deactivateirq
    jsr $fd15
    lda #0
    jmp fine

activateirq
    lda irqflag; irq installato?
    bne irqok
    lda #<irq
    ldx #>irq
    sta $0314
    stx $0315

irqok
    ldy $fb       ; prepara le stringhe
    lda #$92    ; aggiunge alla stringa il rvsoff
    sta stringa,y; altrimenti rimarrebbe settato
    lda #0
    sta stringa+1,y;terminatore di stringa
    sta spaces,y
loopcopy
    dey
    lda ($fc),y
    sta stringa,y
    lda #$20    ;spazio
    sta spaces,y
    cpy #$0
    bne loopcopy
    sty $06

    lda #1
fine
    sta irqflag
    cli
    rts

;--------------------
irq
    lda $fe  ; counter del blink
    bne exitirq

    lda $02  ; resetta il counter innazitutto
    sta $fe
    sei
    jsr decidi; decide come stampare

    cli
exitirq
    dec $fe
    jmp $ea31

decidi
    inc $06
    lda $06  ; flipflop
    and #$01  ; tiene buono solo 0 e 1 (pari e dispari)
    bne norm
    lda method
    beq rev
    lda #<spaces;stampa gli spazi anziche' la stringa
    ldy #>spaces
    jmp printstr
rev
    lda #$12;revs on
    bne *+4
norm
    lda #$92;revs off
    sta reverse
    lda #<reverse
    ldy #>reverse
printstr
    sta printptrs+1
    sty printptrs+3

    ldx $D6;salva la pos cursore corrente
    stx repoint+1
    ldx $D3
    stx repoint+3
    ldx $05;cursorey
    stx $D6
    ldx $04;cursorex
    stx $D3
    JSR $E56C
printptrs
    lda #00
    ldy #00
    jsr $ab1e; stampa la stringa in YA
repoint
    lda #00  ; riposiziona il cursore
    ldx #00
    sta $D6
    stx $D3
    JSR $E56C
    rts

;--------------------
getnumpar
    JSR $AEFD; salta la virgola
    jsr $ad9e; BASIC prmeval
    jsr $b7f7; converte in int in $14-$15
    lda $14  ; restituiamo il byte basso in A
    rts

getstrparam
    JSR $AEFD
    JSR $ad9e; evaluta espressione, crea var temp, A=Lunghezza
    JSR $B6A3; de-alloca var temp e restituisce l'indirizzo in YX
    rts

;------------
irqflag .byte 0
method  .byte 0

;reverse on o off, parte a scrivere la stringa da qua
reverse .byte 0
stringa
;lasciamo 256byte+1 flag reverse+1 per 0 terminatore di stringa
    *= stringa +$102
;stringa dummy per flash
spaces



[zimox]

 ciao
ti ringrazio per l' interessamento
non l' ho ancora provata perche' a dir la verita' credevo in  ad un routine
molto piu' corta
il fatto che e' estremamente semplice poter agire in basic
prima di saltare alla subroutine e' sufficiente impostare 2 variabili numeriche come tempo nei for e utilizzare una e solita varibile stringa di scambio
...ma!?
saluti

[MarC=ello]

 

Il c16 ha un bit/attributo apposta per il flash di ogni carattere, credo come per i colori, che il c64 non ha.

Già, non è una questione di BASIC o Sistema Operativo... è proprio il TED che ha questa feature.


Pensavo da me da me su un altro metodo per poter emulare questo attributo che il VIC-II non ha. Ad esempio, uno potrebbe realizzare una routine che controlla, per ogni cella dello schermo, se il colore del carattere è uguale a quello dello sfondo ($d021). Se sì, fai l'effetto reverse on/off su quel carattere. Cioè, siccome *generalmente* non servono, ad esempio, dei caratteri blu su uno sfondo blu, questa condizione potrebbe fungere da "attributo" per l'effetto reverse on/off.

Confesso di essere fuori allenamento con l'assembler e non mi ci metto, ma si tratterebbe di implementare una routine di interruzione che controlla il contenuto della memoria dello schermo ed individua i caratteri da visualizzare in reverse. Ripartendo il lavoro in più frame, magari non so, anche usando un double buffering se necessario, l'interrupt job non dovrebbe essere troppo pesante.

In questo modo installata la routine, se si ha ad esempio:

POKE 646,PEEK(53281):PRINT "CIAO";:POKE 646,1: PRINT " A TUTTI"

CIAO dovrebbe subire l'effetto REVERSE ON/OFF, mentre A TUTTI dovrebbe essere visualizzato normalmente. Ho usato la POKE a 646 solo per comodità di scrittura qui, ma uno può usare tranquillamente la combinazione CTRL-numero (o C= numero) ovviamente... (entro virgolette).

Potrebbe essere un'idea (sperando di essermi spiegato)?

Ciao!

 

[MarC=ello]

 Ah, intanto ecco una soluzione in BASIC per un flashare una stringa e attendere la pressione di un tasto... in questo modo non appena viene premuto un tasto il processo si interrompe, senza dover attendere il termine del ciclo for... next come nell'esempio di Zimox:

Codice: [Seleziona]

5 d = 150: rem ritardo
10 c = 0 : print "[cursor up]testo"
20 c=c+1: if c = d then 100
30 geta$:ifa$<>""then 1000
40 goto 20
100 c=0:print"[reverse] [cursor up]testo"
110 c=c+1:if c = d then 10
120 geta$:ifa$<> "" then 1000
130 goto 110
1000 print "fatto"

In pratica anche mettendo un valore elevato del ritardo, la pressione di un tasto comporta immediatamente l'uscita dal ciclo di flashing.