! ---------------------------------------------------------------------------- ! Negozio 040324 Uno dei giochi standard di Inform 6 ! ! Una traduzione italiana di TOYSHOP di Graham Nelson -- uno dei giochi ! standard di esempio per Inform. ! ! Basato sulla Release 4, Serial 961111 di Toyshop.inf ! ! Copyright (c) 1999 - 2004 by Giovanni Riccardi ! ! Questo non è un vero e proprio gioco. Il gioco di esempio più importante per ! Inform è "Avventura", una traduzione di "Advent" che è una versione di ! Colossal Cave. Siccome "Avventura" è abbastanza vecchio, e molti degli ! oggetti contenuti sono piuttosto semplici, allora "Negozio" è una ! collezione di esempi più esotici e oggetti particolari. Notare che ! "Avventura" è piena di porte interessanti, una buona lanterna e una ! bottiglia che può contenere olio e acqua, così queste cose non sono state ! incluse in "negozio". ! ! NOTA: I commenti che trovate nel codice sorgente sono, per la maggior parte ! traduzioni dei commenti originali scritti da Graham Nelson durante ! la programmazione del gioco. (Giovanni Riccardi) ! ! Questo gioco necessita di Inform 6, libreria 6/10, Infit 2.2 ! ! Release 3: 040324 (piccole correzioni qua e là) ! Release 2: 021014 (seconda versione riveduta a correnta in molti punti) ! ! Per vincere, devi semplicemente trovare 6 cose interessanti da fare e ! poi trovare l'uscita principale! ! ! ---------------------------------------------------------------------------- Constant DEBUG; Constant Story "TOYSHOP -- Negozio di Giocattoli"; Constant Headline "^Una Dimostrazione Interattiva^ Copyright (c) 1994 by Graham Nelson. All rights given away^ Traduzione e Adattamento (c) 2000 - 2004 by Giovanni Riccardi.^^"; Release 3; Serial "040324"; ! Questa istruzione imposta il numero seriale alla data del ! sorgente, non alla data di compilazione. ! Ora dobbiamo avvisare Inform che non vogliamo utilizzare la routine standard ! per l'azione "Brucia, Incendia" (Burn), e che invece ne includiamo una ! nostra: Replace BurnSub; ! Poi includiamo il primo dei file standard della libreria: Include "Parser"; ! ---------------------------------------------------------------------------- ! Poco generosamente, il giocatore può portare al massimo 4 cose, ma c'è ! una cartella che può portarne altre... ! ---------------------------------------------------------------------------- Constant MAX_CARRIED = 4; Constant SACK_OBJECT = satchel; Object satchel "cartella" with description "@`E molto grande e ha una faccia sorridente stampata sopra.", name "cartella", article "la tua", when_closed "La tua cartella @`e qui sul pavimento.", when_open "La tua cartella giace aperta sul pavimento.", has container open openable female; ! Ora stiamo per usare il più elaborato sistema di punteggio che ! ha la libreria (diamo a ciascuno dei 6 task un solo ! punto), quindi definiamo... Constant TASKS_PROVIDED; Constant NUMBER_TASKS = 6; Array task_scores -> 1 1 1 1 1 1; Constant MAX_SCORE = 6; ! E includiamo la libreria dei verbi e delle azioni standard. Include "VerbLib"; ! INFIT, al contrario delle avventure scritte in inglese, necessita di un ! ulteriore file di libreria... Include "replace"; ! ---------------------------------------------------------------------------- ! Entriamo nel Negozio di Giocattoli... ! ---------------------------------------------------------------------------- Class Toyroom has light; Toyroom Toyshop "Negozio di Giocattoli" with description "Il centro di una lunga sala che va da est a ovest. Gli scaffali sono pieni di giocattoli, dei clown dipinti si affacciano dalle pareti e il pavimento @`e rivestito di stuoie colorate. Una porta conduce a nord, e c'@`e un triangolo rosso di pericolo dipinto sopra.", name "clown" "dipinti" "scaffali" "scaffale" "triangolo" "sala", e_to East_End, w_to West_End, n_to Danger_Zone; Object -> chair "sedia alta" with name "sedia" "alta", before [; Climb: <>; ] has supporter enterable female; ! ---------------------------------------------------------------------------- ! Il codice che gestisce il volo del palloncino non funziona se non viene ! prima attivato. Date un'occhiata alla routine Initialise() se volete sapere ! come attivarlo. ! ! Notare che "after" per il verbo Drop toglie l'attributo "moved". ! Questo è un modo per assicurarsi che il messaggio "initial" sarà sempre ! quello già visualizzato. (Alternativamente, possiamo dare una "describe" ! property.) ! ---------------------------------------------------------------------------- Object -> balloon "palloncino di elio" with description "Blu, con una faccia gialla sorridente.", name "elio" "palloncino" "blu" "cordicella", initial "Un palloncino svolazza sul soffitto, la sua cordicella pende verso il basso.", before [; Attack: remove self; StopDaemon(self); "Con estrema facilit@`a fai scoppiare il palloncino. Pop!^^ Ora non c'@`e pi@`u, veramente."; ], after [; Take: "Prendi il palloncino dalla cordicella. Sta svolazzando!"; Drop: give balloon ~moved; "Il palloncino raggiunge il soffitto con estrema tranquillit@`a ."; ], daemon [ from_room to_room; if (random(3)~=1) rfalse; from_room=parent(self); if (from_room==East_End or West_End) to_room=Toyshop; if (from_room==Toyshop) { if (random(2)==1) to_room=East_End; else to_room=West_End; } if (to_room==0) rfalse; move self to to_room; if (location==from_room) "^Una brezza spinge il palloncino verso ~", (name) to_room, "~."; if (location==to_room) "^Una brezza spinge il palloncino da ~", (name) from_room, "~."; ]; ! ---------------------------------------------------------------------------- ! Le regole ordinarie del parser non ci permettono di gestire i veicoli e ! gli oggetti che possono essere spinti("PushDir") da posto all'altro: questa ! macchina dimostra allo stesso tempo l'uso di entrambi. ! ! "before" per PushDir (spinge in una direzione) deve richiamare ! AllowPushDir e quindi ritornare true che significa che si può spingere in ! quella direzione ! ! "before" per Go ritorna true che significa che si può viaggiare ! mentre si è all'interno (notare che la macchina deve esser "enterable"). ! ---------------------------------------------------------------------------- Object -> car "piccola macchina rossa" with name "piccola" "rossa" "macchina" "kar1", description "Grande abbastanza per sedersi dentro. Tra i controlli c'@`e una grossa leva on/off. La targa @`e KAR 1.", when_on "La macchina rossa @`e ferma qui, ancora col motore acceso.", when_off "Una piccola macchina rossa @`e parcheggiata qui.", before [; PushDir: AllowPushDir(); rtrue; Go: if (car has on) { Achieved(1); "Brmm! Brmm!"; } print "(@`E spenta in questo momento.)^"; ], after [; SwitchOn: "Hai acceso la piccola macchina rossa."; PushDir: "La macchina si muove molto lentamente."; ], has switchable enterable static container open female; Object -> -> "piccola nota" with name "piccola" "nota", description " !!!! FROBOZZ MAGIC CAR COMPANY !!!!^ ^Benvenuto, Pilota!^ ^Istruzioni per l'uso:^ ^Spingere ~ON~ per muoversi!^ ^Garanzia:^ ^Questa macchina @`e garantita contro tutti i difetti per un periodo di 76 millisecondi dalla data di acquisto o fino al momento dell'uso (qualunque cosa avvenga per prima).^ ^Buona Fortuna!", has female; ! ---------------------------------------------------------------------------- ! Un esempio di un oggetto distribuito attraverso diverse (tre) stanze, ! implementato tramite la proprietà found_in. ! ---------------------------------------------------------------------------- Object padded_floor "pavimento" with name "pavimento" "stuoie", description "Per proteggere i bambini e gli avventurieri.", before [; Take: "@`E protetto dai bambini e dagli avventurieri."; ], found_in East_End Toyshop West_End has scenery; ! ---------------------------------------------------------------------------- Toyroom Danger_Zone "Zona di Pericolo" with description "Questa @`e una zona di pericolo, in cui faresti meglio a non entrare. Un'unica porta conduce indietro verso sud.", s_to Toyshop; ! ---------------------------------------------------------------------------- ! Un esempio classico di timer. Per mostrare come si ferma un timer ! prima della fine (e per divertimento), c'è anche un gancio. ! ---------------------------------------------------------------------------- Object -> grenade "bomba a mano pericolosa" with name "a mano" "bomba" "granata" "pericolosa", initial "Una pericolosa bomba a mano sta rotolando sul pavimento.", description "Non raccomandata per bambini di et@`a inferiore ai 90 anni.", before [; Pull: if (self has general) "Troppo tardi per questo."; StartTimer(self, 5); give self general; move the_pin to player; "Tiri il gancio dalla bomba, un atto irreversibile."; ], time_left 0, time_out [; deadflag=1; "^Un'immensa esplosione demolisce il negozio di giocattoli!^^ Non imparerai mai, vero?"; ], has transparent female; Object -> -> the_pin "gancio" with name "gancio", description "Il gancio @`e progettatto per essere tirato fuori con molta facilit@`a.", before [; Take, Pull: if (self in grenade) <>; Insert: if (self notin grenade && second==grenade) { StopTimer(grenade); move self to grenade; give grenade ~general; "Stupefaciente! Hai rimesso il gancio nella granata!"; } ]; ! ---------------------------------------------------------------------------- ! Questa è una scatola con 5 fiammiferi. E' piuttosto semplice perché si ! può tenere in mano un solo fiammifero alla volta. In tutti i modi ! è un'implementazione piuttosto completa. Notare che il codice ! dell'oggetto include anche alcune linee per gestire l'inventario. ! Notare inoltre che l'oggetto fiammifero ("match") fa sempre riferimento ! alla scatola anche quando è vuota. ! ! La scatola ha un daemon il cui compito è di riordinare i fiammiferi persi. ! Forse la soluzione più semplice sarebbe stata l'implementazione di una ! routine "after" che fermasse il giocatore nel buttare via i fiammiferi, ! aa se nel gioco ci fosse una gazza ladra che ruba solo i fiammiferi ! lasciando la scatole? ! ---------------------------------------------------------------------------- Object -> matchbook "scatola di fiammiferi" with name "scatola" "di" "fiammiferi", number 5, before [; SwitchOn: <>; Burn: if (match has light) { remove match; remove matchbook; "Che spreco di fiammiferi!"; } ], invent [; if (inventory_stage==2) { switch(self.number) { 0: print " (vuota)"; 1: print " (1 fiammifero rimasto)"; default: print " (", self.number, " fiammiferi rimasti)"; } } ], description [; print "Un messaggio stampato sulla scatola dice: ~Curses - Avventura di una pausa pranzo~. La scatola "; switch(self.number) { 0: "@`e vuota."; 1: "ha un solo fiammifero."; default: print_ret "contiene ", self.number, " fiammiferi."; } ], daemon [; if (match notin matchbook && match notin player) { move match to matchbook; if (match has light) { give match ~light; StopTimer(match); } StopDaemon(self); } ], has transparent female; Object -> -> match "fiammifero" with parse_name [ i j; if (self has light) j='acceso'; else j='spento'; while (NextWord()=='fiammifero' or j) i++; return i; ], article "un", before [ i; if (self in matchbook) { i=matchbook.number; if (i==0) "Non ci sono pi@`u fiammiferi nella scatola."; i--; matchbook.number=i; move self to player; StartDaemon(matchbook); print "(prendi un fiammifero dalla scatola, che "; if (i==0) print "@`e vuota ora)^"; if (i==1) print "contiene ancora un fiammifero)^"; if (i>1) print " ne contiene ancora ", i, ")^"; self.article = "un"; } Take, Remove: if (self in player) "Fatto."; SwitchOn: <>; Burn: if (self has light) "Il fiammifero @`e gi@`a acceso."; if (matchbook notin player) "Hai bisogno della scatola per accendere il fiammifero."; give self light; StartTimer(self, 2+random(3)); self.article = "un"; "Hai acceso il fiammifero."; ], short_name [; if (self has light) print "fiammifero acceso"; else print "fiammifero spento"; rtrue; ], time_left, time_out [; move self to matchbook; give self ~light; "^Appena la fiamma raggiunge il tuo dito, fai cadere il fiammifero per terra."; ]; ! ---------------------------------------------------------------------------- ! Una scatola con 8 candele. ! ! Questo è un semplice modo per programmare diversi oggetti di uno stesso ! tipo. Notare che il comando ! > prendi candele ! non funziona come ci si aspetta: verrebbe presa infatti solo una candela ! (anche se "> prendi quattro candele" funziona). Vedi la classe "Block", ! più avanti, per un modo di programmare questa cosa. ! ! Se avessimo avuto bisogno di un numero maggiore di candele, avremmo ! potuto usare la creazione e la distruzione degli oggetti durante il ! gioco. Vedi la classe "Ticket" nel gioco di esempio "Balances". ! ---------------------------------------------------------------------------- Class Candle with name "candela" "candele" "di" "cera", short_name "candela di cera", plural "candele di cera", description "Ogni candela sembra identica a tutte le altre.", before [; Burn: "Che delusione! Lo stoppino rifiuta di accendersi."; ], has female; Object -> "scatola grigia di latta" with name "scatola" "grigia" "di" "latta", description "Una scatola di latta grigia di ~Candele Major~.", has container openable female; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Toyroom East_End "Il lato Est del Negozio" with name "bambole" "nurses", description "Il lato est del negozio di giocattoli @`e rosa, e le bambole riempiono gli scaffali fino alla finestra pi@`u alta. Uno scuro passaggio conduce ad una sala a nord.", w_to Toyshop, n_to DarkRoom; ! ---------------------------------------------------------------------------- ! Il seguente esempio, suggerito da Richard Tucker, dimostra un caso ! apparentemente complicato di oggetti con associati sotto-oggetti. Il paio ! di guanti bianchi si comporta come ogni altro oggetto di vestiario - ma ! il giocatore può anche usare il guanto destro e sinistro ! indipendentemente, prenderne uno, indossarlo, ecc. Quando tornano di ! nuovo insieme (anche in un armadio, oppure su una mensola) tornano di ! nuovo ad essere "un paio di guanti". ! ! Possiamo fare tutto questo con tre oggetti, un daemon e una regola. ! ! Quando i guanti sono insieme, e il giocatore vi si riferisce ! individualmente, la regola in "before" separa il paio e inizializza ! il daemon. Una volta attivo, il daemon tenta ad ogni turno di riunirli ! insieme in un paio. (Se ci riesce, il damenon viene fermato.) ! ! Notare che l'oggetto "paio di guanti" ha un attributo "general" ! esattamente quando i guanti sono separati. Altrimenti contiene entrambi ! gli oggetti "guanti", e ha un attributo "transparent" così che il parser ! possa sapere se il giocatore può vederli e riferirsi ad essi. ! ---------------------------------------------------------------------------- Object -> gloves "guanti bianchi" with article "un paio di", name "bianchi" "guanti" "paio" "di", daemon [; if (parent(right_glove) ~= parent(left_glove)) return; if ((left_glove has worn && right_glove hasnt worn) || (left_glove hasnt worn && right_glove has worn)) return; if (left_glove has worn) give gloves worn; else give gloves ~worn; move gloves to parent(right_glove); give gloves ~general; move right_glove to gloves; move left_glove to gloves; give right_glove ~worn; give left_glove ~worn; StopDaemon(self); ], has clothing transparent pluralname; Class Glove with article "il", name "guanto" "bianco", before [; if (self notin gloves) rfalse; move left_glove to parent(gloves); move right_glove to parent(gloves); if (gloves has worn) { give left_glove worn; give right_glove worn; } give gloves general; remove gloves; StartDaemon(gloves); ], has clothing; Glove -> -> left_glove "guanto sinistro" with description "Di seta bianca, con una R rossa ricamata.", name "sinistro" "sinistra"; Glove -> -> right_glove "guanto destro" with description "Di seta bianca, con una T rossa ricamata.", name "destro" "destra"; ! ---------------------------------------------------------------------------- ! ...e con questo è tutto:. ! ! Esercizio per il lettore: nascondi un gioiello (tagliente) dentro il ! guanto sinistro. (Altera la classe glove in modo che si comporti come ! container che è aperto solo quando il guanto non è indossato. Aggiungi ! due regole "after" per avvertire il giocatore che c'è qualcosa di ! tagliente, una quando vengono indossati insieme, ouna quando viene ! indossato un solo guanto.) ! ---------------------------------------------------------------------------- ! ---------------------------------------------------------------------------- ! Un esempio tradizionale di oggetto in Inform: ! ---------------------------------------------------------------------------- Object -> cone "cono verde" with name "verde" "cono" "di" "smeraldo" "marzapane", describe [; if (cone has moved) "^Un cono deformato di marzapane verde @`e posato qui."; "^Qui vicino c'@`e un cono verde smeraldo, alto 30 cm."; ], description "Il cono sembra fatto di marzapane di color smeraldo.", before [; Eat: if (random(100) <= 30) { deadflag = 1; "Sfortunatamente, sembra che tu sia allergico alle mandorle."; } "Rosicchi il cono ad un angolo."; ], after [; Take: "Preso. (Le tue mani sono impiastricciate di marzapane.)"; Drop: cone.description = "Il cono @`e un pasticcio di un verde sbiadito."; "Il cono si posa sul pavimento afflosciandosi un po'."; ], has edible; ! ---------------------------------------------------------------------------- ! C'è uno spiffero che proviene dalla finestra che spinge via il ! palloncino: ! ---------------------------------------------------------------------------- Object -> "finestra alta" with name "alta" "finestra", description [; print "Una stretta, alta finestra "; if (self has open) "da dove soffia uno spiffero d'aria."; "che @`e chiusa."; ], after [; Open: StartDaemon(balloon); Close: Achieved(2); StopDaemon(balloon); ], has scenery openable open female; ! ---------------------------------------------------------------------------- ! Un tipico contenitore chiuso a chiave, contenente un regalo piuttosto ! patetico ... ! ---------------------------------------------------------------------------- Object -> "armadio bullonato" with name "sprangato" "armadio", describe [; if (self hasnt open) "^Un armadio chiuso @`e bullonato ad un muro."; "^Bullonato ad una parete c'@`e un armadio aperto."; ], with_key key has locked container openable lockable static; Object -> -> "dolce bollente" with name "bollente" "dolce", after [; Eat: Achieved(0); "Ci vuole molto tempo per mangiarlo."; ], has edible; ! ---------------------------------------------------------------------------- ! La scatola di vetro è per dimostrare l'uso di "transparent". Mettendoci la ! palla fluorescente dentro non si rende buia la stanza. Invece la stanza ! diventa buia se si fa la stessa cosa con la scatola di acciaio. ! Inoltre, gli oggetti nella scatola di vetro possono essere esaminati ! anche quando è chiusa. ! (Notare anche che la Stanza Scura è esplicitamente impostata per non ! avere la luce, che invece avrebbe ereditato dalla classe "Toyroom".) ! ---------------------------------------------------------------------------- Toyroom DarkRoom "Stanza Scura" with description "Un ripostiglio senza niente di speciale, che non merita alcuna illuminazione.", cant_go "L'unica uscita @`e indietro verso sud.", s_to East_End has ~light; Object -> "scatola di vetro con un coperchio" with name "scatola" "di" "vetro" "con" "coperchio" has container transparent openable open female; Object -> "scatola di acciaio con un coperchio" with name "scatola" "di" "acciaio" "con" "coperchio" has container openable open female; Toyroom West_End "Il lato Ovest del Negozio" with name "soldati" "modellino" "aerei" "velivoli" "aereoplani", description "La parte ovest del negozio di giocattoli @`e blu, e soldati e modellini di aerei riempiono gli scaffali. A sud c'@`e un piccolo ufficio.", e_to Toyshop, s_to Office; ! ---------------------------------------------------------------------------- ! La classe Block costruisce dei cubi per costruzioni. ! ! Notare che se mancasse la routine "describe", il gioco descriverebbe ! ancora correttamente la pila di cubi, solo meno elegantemente. ! ---------------------------------------------------------------------------- Class Block with description "Solo un pezzo delle costruzioni, 10 cm per lato.", ! La routine parse_name fa in modo che "> prendi costruzioni" ! funzioni correttamente: parse_name [ i j; for (::) { j=NextWord(); if (j=='pezzo' or 'cubo' or (self.name)) i++; else { if (j=='costruzioni' or 'cubi' or 'pezzi') { parser_action=##PluralFound; i++; } else return i; } } ], describe [ c d e; d = child(self); while (d~=0 && d ofclass Block) { c++; e=d; d=child(d); } if (c==0) rfalse; print "^C'@`e una pila di costruzioni qui, "; while (c>=0) { print (address) e.name; ! stampa il nome ("name") if (c>0) print " su "; ! usando il dictionary address c--; e=parent(e); } "."; ], before [ c; PutOn: if (second ofclass Block) { if (child(second)~=0 && child(second) ofclass Block) "Non c'@`e spazio sopra un cubo per altri due, messi uno a fianco all'altro."; } else print "(Sono veramente fatti per essere impilati uno sopra l'altro..)^"; c=second; while (c ofclass Block) c=parent(c); if (c~=location or mantelpiece) "Una base troppo instabile."; ], after [ c stack; PutOn: stack=noun; while (parent(stack) ofclass Block) { stack=parent(stack); c++; } if (c<2) { if (Chris has general) rtrue; rfalse; } if (c==2) "La pila di tre cubi @`e instabile, ma regge."; if (Chris has general) { Achieved(3); "^In modo esperto rende stabile la pila di quattro cubi."; } stack=noun; while (parent(stack) ofclass Block) { c=stack; stack=parent(stack); move c to location; } "La pila di quattro cubi vacilla, vacilla... e improvvisamente collassa in pezzi!"; Take: stack=child(noun); if (stack==0) rfalse; while (stack~=0) { c=stack; stack=child(stack); move c to location; } "Come risultato la tua pila di cubi @`e collassata in pezzi."; ], has supporter; Block -> "cubo verde" with name "verde"; Block -> "cubo rosso" with name "rosso"; Block -> "cubo giallo" with name "giallo"; Block -> "cubo blu" with name "blu"; ! ---------------------------------------------------------------------------- ! Una apparizione di mio cugino Christopher, di 6 anni (*), che gioca con ! una cosa alla volta (dimenticando facilmente con cosa stava giocando). ! Essendo "transparent", il parser permette al giocatore di esaminare tutto ! quello con cui sta giocando... ma non di prenderlo. ! (* Nel 1993, quando il gioco è stato scritto per la prima volta.) ! ---------------------------------------------------------------------------- Object -> Chris "Christopher" with name "bambino" "ragazzo" "chris" "christopher", describe [; print "^Un bambino di nome Christopher @`e seduto qui vicino"; if (child(Chris) ~= nothing) print ", a giocare con ", (a) child(Chris); "."; ], life [ x; Ask: switch(second) { 'fluorescente', 'palla' : "~@`E mia!~"; 'elio', 'palloncino', 'di': "Christopher sbadiglia."; 'cubo', 'cubi': "~Scommetto che riesco a fare una torre pi@`u alta della tua.~"; 'giocattoli', 'negozio': "~Non @`e favoloso qui?~"; default: "~Non so.~"; } Answer: switch(noun) { 'ciao': "~Ciao~, dice Christopher allegramente."; default: "Christopher sembra preoccupato."; } Attack: remove self; "Christopher si mette a correre, sgusciando via senza sforzo!"; Kiss: "~Troppo sentimentale!~"; Give: if (noun==balloon) "@`E troppo annoiato dal palloncino."; x=child(Chris); if (x~=0) { move x to location; print "Si @`e dimenticato ", (the) x, " e "; } else print "Christopher "; print "avidamente ", (itorthem) noun, " afferra"; move noun to Chris; "."; ], orders [; Drop: if (noun in Chris) "~Non puoi! @`E mio!~"; Take: "Christopher non vuole esssere disturbato."; Give: if (second==player) "~Fallo da solo!~"; Go: "~Ma a me piace qui!~"; PutOn: if (noun notin Chris) "Ora @`e piuttosto confuso."; if (~~(noun ofclass Block && second ofclass Block)) "Christopher non riesce a capire come si fa."; print "Christopher tende le mani con grande concentrazione e riesce a farlo.^"; move noun to player; give self general; ; give self ~general; rtrue; ], each_turn [; if (random(3)~=1) rtrue; print "^Christopher "; switch(random(4)) { 1: "sbadiglia."; 2: "sbatte le ciglia."; 3: "si stiracchia."; 4: "canticchia stonatamente."; } ], has animate proper transparent; Object "palla fluorescente" Chris with initial "Sul pavimento c'@`e una palla fluorescente", name "fluorescente" "palla", description "@`E illuminata da una luce fioca." has light female; ! ---------------------------------------------------------------------------- ! Una semplice regola di movimento. ! ---------------------------------------------------------------------------- Toyroom Office "Ufficio" with description "Un piccolo, grigio ufficio, con una grossa mensola di pietra. Nella parete est c'@`e una porta con scritto ~Uscita~, e il Negozio, naturalmente, si trova a nord.", cant_go "Il negozio si trova a nord.", n_to West_End, e_to [; if (score~=MAX_SCORE) "Suona un gong. ~Non puoi lasciare il Negozio di Giocattoli fino a che non hai fatto sei cose interessanti!~"; deadflag=2; "Suona un gong. ~Congratulazioni! Ora puoi lasciare il Negozio di Giocattoli e cominciare a scrivere il tuo gioco in Inform!~"; ]; ! ---------------------------------------------------------------------------- ! Un contenitore "ladro"... ma puoi insegnargli le buone maniere. ! ---------------------------------------------------------------------------- Object -> "borsa dentata" with name "dentata" "borsa", initial "In un angolo c'@`e una curiosa, borsa dentata.", description "Un borsa molto capace con una bocca dentata.", before [; LetGo: "La borsa provocatoriamente serra i denti sulla tua mano fino a che non la rilasci."; ], after [; Receive: if (noun==cone) { self.before=0; self.after=0; "La borsa si divincola interminabilmente provando a mangiare l'enorme massa di marzapane. Ora ha imparato come ci si comporta."; } "La borsa si divincola in maniera ripugnante mentre inghiottisce ", (the) noun, "."; ], has container open female; ! ---------------------------------------------------------------------------- ! Una livella che può essere messa su una mensola: la prima volta che questo ! viene fatto, il gioco decide casualmente (random) quale delle estremità ! è più in alto.. ! ---------------------------------------------------------------------------- Object -> -> spirit_level "livella" with name "livella" "level" "wood" "flask", number 0, description "Un pezzo di legno contenente un tubicino riempito con un verde liquido vischioso, in cui è intrappolata una bolla.", before [; Examine: if (spirit_level in mantelpiece) { print "La bolla si trova all'estremità "; if (self.number==1) "nordest."; "sudovest."; } ], after [; PutOn: if (second~=mantelpiece) rfalse; if (spirit_level hasnt general) self.number=random(2); give spirit_level general; Achieved(4); print "Appena metti la livella sulla mensola, la bolla lentamente scorre verso "; if (self.number==1) "nordest."; "sudovest."; ], has female; Object -> mantelpiece "mensola" with name "mensola" "ripiano", has scenery supporter female; Object -> -> key "chiave di ferro" with name "chiave" "di" "ferro", article "una", has female; ! ---------------------------------------------------------------------------- ! Una lavagna che può essre scritta oppure cancellata. ! ---------------------------------------------------------------------------- Object -> -> chalk "gesso" with name "gesso" "gessetto"; Array boardtext string 64; Object -> blackboard "lavagna" with name "lavagna", describe [; <>; ], before [ i f; Examine: for (i=1:i<=boardtext->0:i++) if (boardtext->i~=' ' or 0) f=1; if (f==0) { print "^La lavagna dell'ufficio @`e ben pulita.^"; if (self hasnt general) { give self general; "^[Per scriverci sopra, prova > scrivi ~messaggio...~]"; } rtrue; } print "^Sulla lavagna @`e scritto:^ "; for (i=1:i<=boardtext->0:i++) { f=boardtext->i; if (f~=0) print (char) f; } new_line; rtrue; Rub: for (i=1:i<=boardtext->0:i++) boardtext->i = ' '; "Ha cancellato tutto dalla lavagna."; ], has static female; Global from_char; Global to_char; [ QuotedText i j f; i = WordAddress(wn++); i=i-buffer; if (buffer->i=='"') { for (j=i+1:j<=(buffer->1)+1:j++) if (buffer->j=='"') f=j; if (f==0) return -1; from_char = i+1; to_char=f-1; if (from_char>to_char) return -1; while (buffer+f > WordAddress(wn)) wn++; wn++; return 1; } return -1; ]; [ WriteSub i j; if (chalk notin player) "Non hai nulla con cui scrivere."; if (blackboard notin location) "La lavagna @`e da qualche altra parte."; for (i=from_char,j=1:i<=to_char && j0:i++,j++) boardtext->j = buffer->i; for (:j0:j++) boardtext->j=0; Achieved(5); <>; ]; ! ---------------------------------------------------------------------------- ! Fine della definizione degli oggetti. ! ---------------------------------------------------------------------------- ! ! Routine e Inizializzazione del gioco ! ! (Esempi più completi possono essere trovati nel gioco di esempio ! "Avventura") ! ! Initialise() imposta solo lo stato iniziale di un gioco. ! Si richiede solo di impostare "location" alla locazione iniziale del ! giocatore; il resto è opzionale. ! ! StartDaemon(balloon) inizializza il processo che fa svolazzare il ! palloncino qua e là. ! ---------------------------------------------------------------------------- [ Initialise; location=chair; move satchel to player; print "^^^~Che cosa ha tanto di speciale questo Inform?~ @`E l'ultima cosa che ricordi di aver detto al pazzo alchimista. Grosso errore...^^"; StartDaemon(balloon); ]; ! ---------------------------------------------------------------------------- ! Stampa i nomi dei task (quando richiamato dalla libreria). Nota che sono ! numerati da 0 a NUMBER_TASKS-1. ! ---------------------------------------------------------------------------- [ PrintTaskName achievement; switch(achievement) { 0: "mangiando un dolce"; 1: "guidando la macchina"; 2: "fermando lo spiffero dalla finestra"; 3: "costruendo una torre di quattro costruzioni"; 4: "vedendo da che parte pende la mensola"; 5: "scrivendo sulla lavagna"; } ]; [ PrintRank; print ", e hai raggiunto il rango di "; if (score >= 6) "manager del Negozio di Giocattoli."; if (score >= 5) "apprendista manager."; if (score >= 4) "studente."; if (score >= 3) "scolaretto."; if (score >= 2) "bambino da scuola materna."; if (score >= 1) "bambino ai primi passi."; "neonato."; ]; ! ---------------------------------------------------------------------------- ! Ora (come promesso all'inizio) sostituiamo BurnSub, in modo da ! adattarla alle regole di Toyshop: ! ---------------------------------------------------------------------------- [ BurnSub; if (match hasnt light) "Non hai nessuna sorgente di fuoco."; if (noun has animate) <>; if (noun==padded_floor) { deadflag=1; "Suona un gong, ma prima che una voce sepolcrale si schiarisca la gola, l'intero pavimento si trasforma in un inferno."; } "Suona un gong, e una voce sepolcrale, piuttosto delusa, dice: ~@`E proibito giocare col fuoco nel Negozio di Giocattoli.~"; ]; ! ---------------------------------------------------------------------------- ! Ora aggiungiamo una nuova azione, "Burst" (che non fa altro che richiamare ! "Attack") più una, "Write", per scrivere sulla lavagna: ! ---------------------------------------------------------------------------- [ BurstSub; <>; ]; Include "italiang"; Extend "fai" * "scoppiare" "esplodere" noun -> Burst; Verb "pungi" "pizzica" "buca" * noun -> Burst; Verb "scrivi" * QuotedText -> Write; ! ----------------------------------------------------------------------------