Newsgroup: it.comp.giochi.avventure.testuali
Titolo: inform e glurx: difficile intrico

Salve a tutti,
Questa mi sa che è davvero difficile!Osservate qui:
Constant Story "nome";
Constant Headline "headline";
Replace KeyboardPrimitive;
notate che gli include per glurx ora sono commentati
! Include "infglk";
! include "sgw";
include "Parser";
Include "VerbLib";
Include "Replace";
[ Initialise;
   location = inizio;
];
include "italianG";
object inizio "locazione di
inizio"
   with description "da fare",
   has light;
[ KeyboardPrimitive b p k;
b->1 = 0; p->1 = 0; @aread b p 100 fxx -> k;
];
[ fxx; istruzioni; rfalse; ];
Se compilo con inform, funziona benissimo!
Se poi tolgo i ! per includere glurx, e compilo con /G, l'opcode @aread non 
è più considerato come tale! Come mai?
Dalle istruzioni si evince facilmente l'effetto che voglio ottenere, forse 
includendo glurx queste istruzioni non funzionano e c'è un altro modo?
Grazie, gli esperti si facciano avanti!!
Cordialmente 

 includendo glurx queste istruzioni non funzionano e c'è un altro modo?
Perche' @aread e' un operatore zmachine, ma non e' un operatore glulx. 
Dovresti ridefinire due volte KeyboardPrimitive, per le due macchine 
virtuali:
#Ifdef TARGET_ZCODE;
   [KeyboardPrimitive.........
     ! instruzioni per zcode
     .....
   ];
#Ifnot
   [KeyboardPrimitive.........
     ! isruzioni per glulx
     .....
   ];
Se posso quando ho tempo cerchero' di capire come si fa in glulx quello 
che hai fatto in zcode...
btw: sei sicuro di voler ridefinire KeyboardPrimitive?
bye
-- 
Paolo Lucchesi
email: plucchesiNOSPAM(at)NOSPAMtin(dot)NOSPAMit
homepage: 
http://www.paololucchesi.it
"Non viviamo in un mondo perfetto (per fortuna)"


Ti ringrazio Paolo,
Fortunatamente riesco a gestire bene la KeyBoardprimitive, nel senso che ne 
ho compreso il funzionamento
Il problema sta solo nel fatto che non riesco a farlo in glurx, che è 
essenziale!! 

 essenziale!! 
Beh, dovresti vedere e cercare di capire cosa fanno le due 
KeyboardPrimitive in parserm.h
Cosa dovrebbe fare la tua KeyboardPrimitive?


 bye
Te lo spiego! Ecco, osserva qui, te li riporto per chiarezza:
[ KeyboardPrimitive b p k;
b->1 = 0; p->1 = 0; @aread b p 100 fxx -> k;
];
[ fxx; istruzioni; rfalse; ];
Tu sai bene che per ogni turno, il parser legge automaticamente la linea di 
input del giocatore dopo che si è premuto invio (codice 13). Però, con 
@aread, c'è la possibilità di intercettare (senza ad ogni modo interrompere) 
la pressione dei singoli caratteri che compongono la linea mentre viene 
digitata. Inoltre,
 nelle ultime versioni dei compilatori è permessa la funzione di waiting 
(non in turni, ma in tempo vero, cioè in 10 di secondo).
Ciò singifica che, mentre il giocatore scrive, io posso sapere carattere per 
carattere cosa sta scrivendo e, in teoria, interromperlo! Se, ad esempio, il 
giocatore sta scrivendo vaffa e non termina la parola, se io leggo che nel 
buffer text c'è vaffa, lo interrompo e gli stampo con il print (tramite la 
funzione fxx) appositamente predisposta.
Ecco la sintassi:
@aread text_parse time function -> result
Ogni volta che il parser interpreta una linea di input, chiama la routine 
(function) ogni time tempo.
Tale processo di interpretazione della linea viene bloccato se function 
restituisce true, cosa che però, da come vedi, (rfalse) non mi riguarda.
result invece, ogni volta conterrà l'ultimo carattere che è stato digitato 
immediatamente prima che  è stata chiamata la routine function.
Questo significa, ovviamente, che io posso, senza interrompere il processo 
di scrittura e di input, far scrivere con i print mentre il giocatore digita 
le azioni!! Spero di essere stato chiaro sull'idea che ho.
In questomodo, si potrebbe realizzare, a mio avviso, una delle cose più 
difficili nelle at testuali con questi linguaggi, cioè il tempo vero! Non il 
tempo in turni con i timers, ma il tempo vero! In secondi! Ad esempio, 
immagina che il giocatore sia in una strada, e le automobili stanno 
passando. Immagina che l'auto si trovi nel punto x al turno 1. Con i timers, 
tu puoi fare in modo che l'auto si trovi al punto y al turno 3, ma non dopo 
3 secondi, ammenoché non adotti questo sistema. In quei 3 secondi però, il 
giocatore deve poter continuare a muoversi. In questomodo, ad esempio, puoi 
realizzare un'avventura in cui il giocatore, se entro 10 secondi reali (non 
10 turni) non si sposta dalla strada, viene investito dall'auto! Questo per 
me significa dare al giocatore la sensazione del tempo vera e propria. Con 
inform ci sono riuscito, ora tocca a glurx!! Forza e coraggio, spero che tu 
possa darmi una  mano! Chi ha scritto il bibbione per glurx? Si faccia 
avanti!! Questa è bella anche per lui.... 

 è più considerato come tale! Come mai?
l'opcode @aread è solo per z-machine, per glulx rivolgi il tuo sguardo 
alle funzioni glk, le trovi descritte in italiano in appendice alla 
Guida a Inform-Glulx. E forse anche nel bibbione di Lorenzo (che però 
non ho avuto ancora modo di leggere).
ciao
marco

 ha scritto nel messaggio 
news:46e3eab1$0$36441$4faf...@reader5.news.tin.it...

Ciao Maroc,
ti ringrazio per questa risorsa, non ne ero a conoscenza.
Ad ogni modo, se ti interessa capire ciò che volevo fare, leggi senz'altro 
la conversazione, potrebbe interessarti... Forse tu lo sai già fare e 
potresti aiutarmi...
Cordialmente 


Ehi, ce l'ho fatta!! request_timer, vero?

 non ho avuto ancora modo di leggere).
Solo un puntatore alle parti rilevanti di parserm.h ... IMHO chi va a
toccare la KeyboardPrimitive e' moralmente obbligato a guardarsi il
pezzo di libreria che la implementa :D

 Ehi, ce l'ho fatta!! request_timer, vero?
yes
non hai alcun bisogno di andare a toccare le librerie del parser per 
ottenere il risultato di implementare eventi "realtime".
Devi 'solo' imparare ad usare la glk_request_timer (non dimenticarti 
della gestalt adeguata) e opportunamente posizionarla nell'entrypoint 
handleglkevent. Il libro segnalato riporta un approccio completo ed un 
esempio a tal proposito (10.3)
ciao
marco