
 MoveClass  v8.10    di Neil James Brown        e         Alan Trewartha
                     neil@highmount.demon.co.uk     alan@alant.demon.co.uk
                     con un ringraziamento per Matthew Russotto
		     traduzione di Marco Falcinelli

 MoveClass.h pu essere trovata sul sito ftp.gmd.de in questa posizione:
   if-archive/infocom/compilers/inform6/library/contributions/moveclass.h

 ed anche all'URL:
   http://www.alant.demon.co.uk/

___________________________________________________________________________




     Contenuti
     ---------
 1. Introduzione
 2. Il movimento dei personaggi non giocatori
 3. Impostazioni           - Usare MoveClass nel proprio gioco
 4. AIMED_MOVEs            - Trovare il percorso da una locazione ad un'altra
 5. PRESET_MOVEs           - Usare percorsi predeterminati
 6. Le propriet *_to
 7. NPCs e le Porte        - Dettagli sulla propriet npc_open per le porte
 8. Percorsi bloccati      - Dettagli sulla propriet npc_blocked
 9. Variabili, Attributi, Propriet e Routine
10. Problemi e difficolt



 1. Introduzione
    ------------

MoveClass  una libreria pensata per aiutare la creazione di
movimenti relativamente sofisticati per i personaggi non giocatori(NPC) in Inform. 
Semplicemente inserendo, con un minimo di codice, oggetti appartenenti 
alla classe 'MoveClass' e scegliendo tra:

   * Movimenti Random
   * Movimenti su un percorso prestabilito
   * Movimenti su un percorso calcolato per una data locazione
   * Stazionario




 2. Muovere un NPC
    --------------

i movimenti non-random di NPC nell'IF vengono normalmente gestiti registrando
le direzioni da prendere in un array, e quindi leggendo quest'ultimo ogni volta
e muovendo l'NPC nella data direzione. Questa tecnica  veloce e funzionale
(si guardi al movimento dei vari personaggi in Christminster), ma restringe le 
possibilit per l'autore ai soli percorsi predeterminati. L'autore deve decidere
nella programmazione del gioco dove l'NPC sta andando e quale strada prende.

Moveclass supporta questo tipo di movimenti, si veda la sezione 5 per maggiori dettagli.

All'occasione, l'autore pu aver bisogno di un approccio pi dinamico,
dove il percorso viene stabilito non in fase di programmazione ma in quella di gioco.
Per esempio, potrebbe esserci un cane che corre intorno al giocatore e che pu
essere catturato in qualsiasi momento usando un guinzaglio. O magari un membro
di un equipaggio di una nave spaziale che sta controllando l'integrit
dello scafo in una di molte locazioni quando il capitano lo chiama sul ponte 
(ad esempio nel momento in cui il giocatore da una informazione al capitano). 
Definire le vie per far arrivare un NPC da ogni locazione possibile ad un'altra 
non  cosa pratica a meno di non avere un gioco con pochissime locazioni.

Moveclass  capace di calcolare il percorso tra qualsiasi due locazioni date, 
purch il percorso esista.

L'intento di questa libreria  evitare al programmatore la stesura del codice 
complesso necessario per il movimento degli NPC, e migliorare il codice evitando 
la duplicazione di codice nei movimenti degli stessi.
E' assunto che l'autore abbia un minimo di competenza con la programmazione 
in inform, dal momento che la libreria prevede alcuni punti di accesso.
Il programmatore pu anche avere bisogno di provvedere ad un certo numero di 
routine specifiche per il gioco perch la libreria funzioni con esso,
sebbene la libreria non assumer automaticamente la loro esistenza, e non
andr in crash ad ogni compilazione se esse non esistono.

Per il resto di questo documento, con "autore" e "programmatore" ci si 
riferir alla persona che desidera usare questa libreria.





 3. Impostazioni
    ------------
Versione Breve:
A) Includere il file della libreria
B) Fare in modo che le locazioni appartengano alla classe 'Room' e
   gli NPC alla classe 'MoveClass'
C) Far partire il daemon dell'NPC
D) Chiamare la routine NPC_Path()

Versione lunga:

A) Includere il file della libreria
   Includerlo dopo 'include verblib.h', o 'include follower.h' se state usando tale modulo

   La libreria supporta l'uso della 'followclass' di Andrew Clover e Gareth
   Rees. Questa classe, come suggerisce il nome, permette al giocatore di
   seguire qualsiasi NPC. Dovrebbe essere inclusa *prima* di MoveClass,
   dal momento che MoveClass controlla per vedere se FollowClass  stata
   gi caricata dal compilatore e si comporta di conseguenza.


B) Fare in modo che le locazioni siano della classe 'Room' e gli NPC della classe 'MoveClass'.
   Le locazioni che non fanno parte della classe 'Room' sono a tutti gli effetti
   zona proibita per gli NPC. Il movimento e il calcolo del percorso si baseranno
   solo alle locazioni appartenenti alla classe Room.
   
   La libreria definisce una classe 'Room', se possedete una vostra classe 'Room',
   assicuratevi che la vostra definizione possieda la propriet link_data 
   che dovrebbe essere inizializzata all'array 0 0 0. 
   (Copiate la definizione dalla libreria se volete.)


C) Far partire il daemon dell'NPC
   Si raccomanda che venga fatto solo quando l'NPC  necessario, cos se l'
   NPC non appare fino alla met del gioco, allora si richiami StartDaemon(NPC)
   solo in tal momento. Se l' NPC ha bisogno di essere avviato all'inizio del gioco, includere 
   una istruzione StartDaemon(NPC) all'interno della routine Initialise, es:

      [ Initialise;
        StartDaemon(Fred);
        StartDaemon(Dobbin);
        "^^Welcome to this game...^";
      ];

   il vostro codice non user pi il daemon dell'oggetto moveclass object. Usa
   'before_action' e 'after_action' invece. (Vedi sezione 9.)


D) Chiamare NPC_Path()
   I primi due paramentri passati a NPC_Path sono sempre l'npc e quindi il tipo
   di movimento che si desidera che esso compia. Il corrente tipo di movimento  conservato
   nella propriet dell'npc 'move_type'. Ulteriori parametri sono necessari
   da alcuni tipi di movimento:

 NPC_Path(npc, NO_MOVE)
   Questa istruzione far si che il nominato npc rimanga fermo.

 NPC_Path(npc, RANDOM_MOVE, [caprice])
   Questa istruzione far si che l'npc si muova in una direzione a caso. Se viene fornito
   il terzo opzionale paramentro, quest'ultimo cambier la propriet 'caprice'.
   Tale propriet dell'npc  la percentuale di probabilit che l'npc decida di
   muoversi in un dato turno.

 NPC_Path(npc, AIMED_MOVE, target_room, [path_type])
   Questa istruzione far si che l'npc si muova verso la locazione definita nel terzo parametro.
   Si veda il paragrafo 4 per magiori dettagli.

 NPC_Path(npc, PRESET_MOVE, path_array, path_length)
   Questa istruzione muover l'npc move sul percorso dato prestabilito nell'array 'path_array'.
   Si veda la sezione 5 per maggiori dettagli.


Questo  tutto. Ci sono molti pi dettagli naturalmente, e dovreste leggere
la sezione 9 per trovare quali altre propriet gestiscono il movimento. particolare
attenzione merita l'impostazione delle proprit *_to e doors (sezione 6 e 7) cos che
l' NPC possa muoversi con maggiore sensibilit.





 4. AIMED_MOVE
    -----------

  NPC_Path(npc, AIMED_MOVE, target_room, [path_type])

Dove:
  target_room   -  la locazione dove si vuole far andare l png
  path_type     -  il tipo di percorso che deve seguire:
                            ANY_PATH usa le porte indiscriminatamente (default)
                       UNLOCKED_PATH non passer attraverso le porte bloccate o chiuse a chiave(locked)
                           OPEN_PATH non passer attraverso porte chiuse
                       DOORLESS_PATH non passer attraverso nessuna porta

E' possibile anche combinare i vari tipi di cammino path_types, es. OPEN_PATH+UNLOCKED_PATH, anche se non
dovrebbe esservene la necessit. Se omettete path_type, sar considerato ANY_PATH, ovvero quello di default.

Se viene trovato un percorso, NPC_Path restituir il valore True, altrimenti riporter False.
Si raccomanda che il codice del gioco controlli il valore restituito dalla funzione e agisca di 
conseguenza.

Di default, l'algoritmo cercher il percorso in una profondit impostata dalla variabile
globale 'path_size_limit' (di default pari a 10). I tentativi dell'autore di impostare
tale variabili al di fuori dei valori compresi tra 2 e 32 potrebbero mandare in crash il gioco.
Valori molto alti potrebbero inoltre rallentare sensibilmente il gioco (specialmente in giochi
con molte locazioni). Sperimentate per trovare il valore pi adatto al vostro gioco.




 5. PRESET_MOVE
    ------------

  NPC_Path(npc, PRESET_MOVE, path_array, path_length)

Dove:
  path_array  -  il nome dell'array che gestisce le direzioni da seguire
  path_length -  il numero di termini nell'array usata.

Per impostare un NPC su di un percorso predeterminato, definite il sentiero in
un array di byte. Se state lavorando in Glulx, allora usate un array di parole.
Usate il nome delle direzioni della bussola (compass directions) cos come definite
nella libreria 'italian.h' e il numero 0 per far fermare il png per un turno.
(Notate che la propriet after_action viene chiamata solo quando il png cambia
locazione). Ecco un array di esempio:


  Array VersoTesoroNascosto -> n_obj n_obj w_obj  0 u_obj in_obj se_obj d_obj;

(Usate --> in Glulx) Questo array nel dettaglio descrive un percorso che si districa nelle
seguenti direzioni: nord, nord, ovest, aspetta un turno, su, entra, sudest e gi. 
Per fare in modo che il png trovi il tesoro userete pertanto la seguente istruzione:

  NPC_Path(BarbaBlu, PRESET_MOVE, VersoTesoroNascosto, 8);




 6. Le propriet *_to 
    -------------------
MoveClass legge le propriet "<direzione>_to" (ad es. n_to, s_to) di una locazione
per vedere quali direzioni sono disponibili e dove esse conducono. Se la propriet
 una semplice stringa essa viene ignorata. Se la propriet  una routine, allora
MoveClass la eseguir aspettandosi o il valore di una locazione, o il valore False
(se non conduce da nessuna parte).

Se definite la costante NOISY_DIR_TOS, allora MoveClass NON valuter le routine ed
assumer che esse non portino da nessuna parte. (Se non la definite, un messaggio di
avvertimento -warning- verr stampato al momento della compilazione).

Se decidete di non definite NOISY_DIR_TOS dovrete assicurarci che le vostre routine
*_to non contengano azioni o istruzioni di stampa. Ci infatti sarebbe male...

   e_to "Un macigno blocca la strada.",
   w_to [; if (self hasnt general)
           { give self general;
             move footprint to location;
           }
           return West_Location;
        ],
   <etc>

Visto che un npc si sta muovendo da queste parti esso potrebbe causare l'avvio dell'istruzione
'give self general' (etc.) quando non lo si desidera. Sarebbe pertanto meglio fare qualcosa di questo
tipo invece:

   e_to "Un macigno blocca la strada.",
   w_to West_Location,
   before [;
      Go: if (noun==w_obj)
          { if (self hasnt general)
            { give self general;
              move footprint to location;
            }
          }
   ],
    <etc>

Notate che la routine e_to non ha bisogno di essere modificata perch  una routine 'stringa pura'
che  interpretata 'noiselessly' dal momento che non porta da nessuna parte.




 7. NPC e le Porte
    --------------
nelle propriet door_dir e door_to, siate certi che nulla dipenda dal valore
di 'location' (che contiene la corrente locazione del giocatore). Usate invece
l'istruzione 'parent(self)', altrimenti l'NPC non sar in grado di aprire le
porte nelle locazioni dove non si trova il giocatore.

Se l'autore desidera che l'NPC possa sbloccare (unlock) o aprire una porta,
 possibile aggiungere una proprieta alla porta chiamata 'npc_open'. Tale
propriet pu anche essere usata per stampare messagi speciali che indichino
particolari comportamenti. Una porta senza la propriet npc_open potr essere
usata da un NPC solo se questa  aperta.

Quando un NPC vuole attraversare una porta (perch  sul suo percorso), egli
controlla se la porta prevede una propriet 'npc_open', e se  cos, la chiama,
passandogli l'identificativo NPC. La propriet dovrebbe restituire il valore 0, 1 o 2:

           2 - NPC pu usare la porta e walkoff/walkon stamper/eseguir (print/run) come al solito
                      
    (true) 1 - NPC pu usare la porta e walkoff/walkon *NON* staper/eseguir (print/run)
               (si assume che npc_open hha fatto gli onori di casa)
               
   (false) 0 - NPC non pu usare la porta

La routine non deve dare alla porta l'attributo 'open'. E' per posibile
per la routine restituire True e 'chiudi la porta dietro di te'. Se restituite
True attraverso l'istruzione print_ret (o "blsh";) ci previene il classico
messaggio walkoff/walkon, cos che npc_open pu stampare un messagio pi sofisticato
per indicare il passaggio attraverso la porta.

Una semplice routine di npc_open potrebbe essere la seguente:

    npc_open [ act_npc;                   ! - parametro passato dalla libreria
        give self open;
        if (TestScope(act_npc))           ! - stampa un messaggio speciale di uscita 'walkoff'
            print_ret (The) act_npc, " apre la porta di quercia e sguscia attraverso di essa.";
        rtrue;                            ! - altrimenti restituisci true.
      ],

Una routine npc_open leggermente pi complessa, presa da un gioco vero,  quella che segue:

    npc_open [ act_npc;
      if (self hasnt open)
      {   give self open;
          StartTimer(self,3);
          if (TestScope(act_npc))
            "^", (The) act_npc, " fa un gesto alla luce rossa sulla porta.
              la luce diventa verde con un breve trillo elettronico,
              la porta si apre scorrendo e ", (the) act_npc, " la attraversa.";
          if (TestScope(self))
            "^C' un piccolo trillo, la porta chiusa si apre scorrendo
              ed entra ", (the) act_npc, ".";
          rtrue;
      }
      if (TestScope(act_npc))
        "^",(The) act_npc, " attraversa la porta aperta.";
      if (TestScope(self))
        "^", (The) act_npc, " arriva attraverso la porta aperta.";
      return 2;
    ],

Notate che in questo esempio la porta si trova 'found_in' in due locazioni.
TestScope(act_npc)  usato per vedere se l'NPC  nella stessa locazione del giocatore,
in tal caso un messaggio speciale di uscita walkoff viene stampato. Questo  seguito
da TestScope(self) per vedere se la porta  nella medesima locazione del giocatore,
in tal caso un messaggio speciale di entrata walkon pu essere stampato nel momento in
cui l'NPC st arrivando.

Una porta pu anche essere usata come barriera, invisibile al giocatore, per
prevenire che gli NPC (o alcuni NPC) viaggino in alcune direzioni. Per esempio,
se il giocatore e tutti gli NPC ad eccezione di una persona veramente superstiziosa
sono felici di entrare in un caverna stregata, potrebbe essere utile creare una porta che
il ignora giocatore, ma che impedisce alla persona superstiziosa di attraversarla, il tutto 
attraverso l'uso di una propriet npc_open adeguata.



 8. Percorsi bloccati
    -----------------

Ci sono tre possibili cause perch un NPC, impostato fermamente su di un percorso
predeterminato o calcolato, venga bloccato:

   * La locazione successiva sul suo cammino sembra essere inesistente (0)
   * La porta sul suo cammino ha una npc_open che restituisce false
   * La porta sul suo cammino non  aperta e non ha la propriet npc_open

In tuti e tre i casi la propriet npc_blocked dell'NPC verr chiamata.
Di default questa propriet chima NPC_Path(self, RANDOM_MOVE). Un'altro
approccio, pi semplice, potrebbe essere quello di non fare nulla,ovvero
aspettare fino a quando la causa del blocco del percorso venga rimossa e 
ricaricare il percorso. Una proprit pi sofisticata potrebbe andare a cercare un
percorso libero da blocchi pi lungo per aggirare le porte.

Esiste una propriet libera, npc_ifblocked, che pu essere impostata e letta
cos che npc_blocked pu rispondere pi intelligentemente alle condizioni che
bloccano il percorso. Un buon uso di npc_ifblocked potrebbe essere quello di 
mantenere il 'path_type' usto per calcolare il percorso corrente. Potrete poi
lavorare con tipi di percorsi sempre pi facili fino a arrendersi e provare qualcosa
d'altro. Per esempio:

    do
    {   switch (self.npc_ifblocked)
        {    ANY_PATH: self.npc_ifblocked=UNLOCKED_PATH;
        UNLOCKED_PATH: self.npc_ifblocked=    OPEN_PATH;
            OPEN_PATH: self.npc_ifblocked=DOORLESS_PATH;
        DOORLESS_PATH: self.npc_ifblocked=-1;
        }
    }
    until (self.npc_ifblocked==-1 ||
           NPC_Path(self, AIMED_MOVE, target, self.npc_ifblocked))
    if (self.npc_ifblocked==-1) NPC_Path(self,RANDOM_MOVE);

un'altra variazione su questo tema potrebbe essere giocherellare (ovvero aumentare)
la variabile globale 'path_size_limit' e poi passare ancora per il preferito tipo di 
percorso (path_type). Tutto dipende da come sono realmente connesse le Locazioni nel vostro
gioco.

Ecco un altro trucco: Quando una porta non  una porta?!

Se volete trovare un percorso che non tenga conto solo di alcune porte
indicate, allora rendetele temporaneamente NON porte (dando bad_door ~door) 
e usate ANY_PATH come al solito. In questo modo la libreria le tratta come
locazioni, ma dal momento che esse non sono della classe 'Room? esse
non sono attraversabili! Quando il percorso  stato calcolato, semplicemnete
restituite le porte a 'doordom' (dando bad_door door). Ta da!



 9. Variabili, Attributi, Propriet e Routine
    -----------------------------------------

VARIABILI GLOBALI
path_size_limit - Limite alla profondita della ricerca impiegata dalla routine
                  NPC_Path(). Pu essere aumentata o abbassata all'interno del gioco
                  per adattarsi, e influenzare solamente la ricerca iniziale e non
                  il vero movimento dell'NPC. Pu assumere qualsiasi valore compreso 
		  tra 2 e 32. Il valore di default  10.



PROPRIETA'
link_data     - E' usata dall'algoritmo del calcolo del percorso per compilare 
		una lista di possibili locazioni in una 'catena di collegamenti'
		e per annotare il percorso cercato.

move_type     - Determina come e se l'NPC si sta muovendo. Viene impostata
		chiamando la routine NPC_Path(), tuttavia l'autore pu 'manualmente'
		impostarla in qualsiasi momento a RANDOM_MOVE o NO_MOVE. Impostarla
                su AIMED_MOVE o PRESET_MOVE potrebbe avere effetti imprevedibili
		e pu causare errori e crash del gioco.

caprice       - La probabilit in percentuale che un NPC impostato su move_type=RANDOM_MOVE
                si sposti ad ogni turno di gioco. 20 di default.

before_action - Deve essere usata dagli autori negli oggetti NPC al posto della
		propriet daemon (che non  disponibile, dal momento che  usata
		da moveclass).
		Questa propriet, se esiste, viene eseguita prima del movimento
		(se c'), e viene chiamata ad ogni turno, *anche se l'npc non si muove*.
		Se restituisce True, allora l'NPC non si muover.


after_action  - Se questa propriet esiste all'interno di un oggetto NPC, allora
                viene chimata dopo che l'NPC si  mosso con successo da una locazione
		ad un'altra, ed  utile per occasioni dove l'NPC deve reagire
		istantaneamente a oggetti, eventi o altri NPC all'interno
		della nuova locazione. *Non viene chiamata se l'NPC non si muove*.


walkoff       - Il messaggio che viene visualizzato se un NPC esce dalla locazione
                in cui il giocatore si trova al momento. L'impostazione di default 
		"si allontana". Pu essere definita come stringa (nel qual caso moveclass
		porr automaticamente il nome dell'NPC all'inizio e "verso 
		<direction>" alla fine - vedi i dettagli di GiveDir pi in basso)
		o una routine. Se definita come routine, moveclass passa ad essa un
		parametro - la direzione in cui si muove l'NPC. L'autore
		dovrebbe stampare un messagio appropriato, con un ritorno a capo
		prima e dopo di esso (ad es. "^Il Personaggio si allontana.", o l'equivalente
		print "^Il Personaggio si allontana.^").


walkon        - Come walkoff, ma questa volta contiene il messaggio stampato quando 
		l'NPC entra nella locazione dove si trova il giocatore. Pu essere
		definita come una stringa nella forma "arriva" (moveclass aggiunger
		il nome dell'NPC all'inizio e un punto alla fine) o come una
		routine, a cui moveclass passer un parametro, la direzione da
		cui arriva l'NPC.

npc_dirs      - Una propriet array usata da moveclass per custodire le direzioni.

prepath_name  - Il nome dell'ultimo o del corrente array usato come percorso Predeterminato.

prepath_size  - Il numero di passi in un percorso predeterminato o calcolato.

npc_stage     - Tiene traccia di quanto, al momento, sia ancora lungo il percorso di un NPC.
                Normalmente non dovrebbe essere cambiato dall'autore.

npc_target    - Usato da moveclass per contenere la locazione obiettivo di un NPC.

npc_blocked   - Una routine che viene chiamata quando un NPC trova il suo percorso bloccato.

npc_ifblocked - Una propriet libera che pu essere usata per determinare
		cosa dovrebbe accadere quando viene chiamata npc_blocked.

npc_arrived   - Chiamata quando un NPC arriva alla sua destinazione dopo aver
		seguito un percorso predeterminato o un percorso calcolato
		specificatamente. La routine DEVE terminare con un chiamata
		con successo a NPC_Path, altrimenti potrebbe sopravvenire un crash
		del gioco.
                
follow_action } Inclusa con Moveclass per gestire un problema quando
follow_object } si usa anche la libreria Follower.h.


ROUTINES
NPC_Path(npc, movement_type, target_room, path_type)
             -  Vedi sezione 4 per i dettagli.

NPCPrePath(npc, name_of_array, array_length)
             -  Viene chiamata da NPC_Path se il tipo di movimento 
		movement_type=PRESET_MOVE. E' mantenuta come una routine
		separata per pulizia e retrocompatibilit.

GiveDir(dir) - Usata da moveclass per inserire "verso <dir>" (o un messaggio pi
               appropriato per gli spostamenti dentro, fuori, su e gi) alla fine
	       della stringa walkoff. Pu essere usata dall'autore, se walkoff 
	       definita come routine, specialmente dal momento che pu essere usata
	       come regola di stampa, ad es.
                 print "Il muro nord  ", (GiveDir) n_obj, ".";

Leadsto(dir, room, path_type)
             - Usata per trovare la locazione 'Room' nella data direzione dalla
		data locazione. 'path_type'  come per NPC_Path, la definizione
		del grado di accesso alle porte.

MoveNPCDir(npc, dir)
             - Usata per spostare un NPC in una data direzione. Essa usa Leadsto()
               e quindi chiama MoveNPC().

MoveNPC(npc,destination,-,-)
             - Viene definita solo se follower.h non viene usata. Moveclass  stata
	     scritta per essere compatibile con gli inseguimenti gestiti da follower.h,
	     e chiama MoveNPC quando sposta un NPC da una locazione ad un'altra.
	     Se follwer.h non  stata inclusa, allora MoveNPC non sar stata definita,
	     e moveclass provvede ad inserire un versione pi semplice della routine
	     stessa.


10. Problemi e difficolt
    ---------------------

MoveClass, prima di cambiare nella versione 8,  stata testata con numerosi
file di esempio risultando piuttosto robusta. I cambiamenti hanno semplificato
un poco il codice, ma come tutti le modifiche, ci potrebbe aver fatto
comparire dei bug. un grande sforzo  stato profuso per rendere la libreria
retrocompatibile con vecchio codice.

MoveClass produrr informazioni di debug per suo conto se la direttiva DEBUG
del compilatore  stata attivata e il livello di tracciamento  impostato
a 2 o pi. Questo, con l'aggiunta di altri messaggi di debug, potr aiutarvi
a localizzare i problemi del vostro sorgente. Se trovate dei difetti in MoveClass,
contattami per favore, Alan Trewartha, all'indirizzo email posto all'inizio
di questo file. Se possibile, includete una trascrizione delle informazioni di 
debug. Per favore non mandate file enormi, senza avvertire prima.

Dovrebbe porsi attenzione a che alcuni vecchi port dell'interprete Zip
(come !Zip per Acorn e WinZip per Windows 3.1x) contengono errori che
causano problemi con i giochi compilati con Inform 6.1x e libreria 6/5+. 
In particolare, alcuni crash possono accadere quando si fa un uso esteso
della routine NPC_Path. Se state usando un vecchio interprete ZIP,
allora  raccomandato aggiornarlo ad una versione pi recente 
(Frotz  normalmente una scelta pi sicura) o altrimenti usate Inform 6.05 
e libraria 6/2.






