--------------- A - R O B O T S --------------- VERSIONE 1.09b by Nicola Marangon FidoNet (2:333/723.4) MPBNetwork (77:1/1.4) Copyright (C) 1995 - LED Soft Engineering Tavola dei contenuti 1. Convenevoli 1-1. Registrazione 1-2. Copyrights 1-3. Requisiti di sistema 1-4. Introduzione 1-5. Cos'e` A-Robots? 2. Descrizione di A-Robots 2-1. Caratteristiche generali degli A-Robots 2-2. Architettura del robot ed orientamento nell'arena 2-3. I processori 2-4. Lo scanner 2-5. Il cannone 2-6. Le mine 2-7. I flares 2-8. I razzi 2-9. Gli scudi 2-10. Il cloaking 2-11. Il movimento 2-12. I danni 2-13. I consumi 2-14. L'arena 2-15. Le regole del gioco 3. Il linguaggio FROM (Figthing Robots Manager) 3-1. Caratteristische generali del linguaggio 3-2. I metodi d'indirizzamento 3-3. Le variabili di stato del robot 3-4. Il set di istruzioni 4. Il manuale FROM 5. La versione shareware di A-Robots 6. Considerazioni finali 6-1. Consigli per la programmazione in linguaggio FROM 6-2. Quali sono i passi da seguire per creare un A-Robot? 6-3. Prospettive e ringraziamenti 1. Convenevoli 1-1. Registrazione Questo software e` da intendersi shareware, per cui dopo un periodo di prova di qualche giorno (diciamo anche un paio di settimane), la vostra coscienza dovrebbe obbligarvi a far pervenire alla mia persona (vedi indirizzo alla fine del testo) una certa somma di denaro e segnatamente L. 10.000 (o piu`, se preferite); se proprio non disponete di tale ingente somma, consideratevi in dovere di spedirmi almeno una cartolina dalla vostra citta`! In ogni caso, ritenetevi soggetti all'obbligo irrinunciabile di copiare il presente software in ogni dove, cyberspace compreso. La registrazione, dato il costo irrisorio, non comporta per chi la effettua speciali benefici, se non la comunicazione da parte del sottoscritto dell'uscita di nuove versioni e dello svolgimento di tornei a cui gli utenti registrati potranno partecipare (gratis...). Ovviamente A-ROBOTS deve essere tassativamente distribuito nella sua forma completa (file compresso contenente eseguibili, documentazione piu` esempi), e non puo` essere preteso il pagamento di nessuna cifra, se non in misura tale da coprire le sole spese di distribuzione. Eventuali usi commerciali e/o a scopo di lucro sono obbligatoriamente da concordarsi con l'autore. L'autore declina ogni responsabilita` per quanto riguarda il funzionamento del software od eventuali danni provocati da uno scorretto uso dello stesso. 1-2. Copyrights * CRobots e` proprieta` di Tom Poindexter ** P-Robots e` proprieta` di David Malmberg 1-3. Requisiti di sistema A-Robots gira senza problemi su macchine con almeno 640Kb. E` consigliabile la presenza di una scheda VGA o superiore per poter apprezzare in pieno le potenzialita del software. In mancanza di tale scheda A-Robots potra` essere utilizzato esclusivamente in modo testo. 1-4. Introduzione Se siete dei programmatori (piu` o meno bravi), se l'odio simulato vi infervora il sangue e non sapete come sfogarvi... allora A-Robots e` quello che fa per voi!!! Robots multprocessor assetati del sangue dei loro antagonisti fanno ricorso alle armi piu` svariate e cruente per essere al fine riconosciuti come gli unici veri bellicosi padroni dell'arena di A-Robots. Intelligenza, astuzia, fortuna ed odio si intrecciano in questo gioco ideato per chi di computer sa tutto o quasi (commercialmente parlando va bene anche poco) ma non per questo si sente appagato. Sfide e tornei al chiarore della luna rossa di Vega vi incolleranno attorno ad un monitor in compagnia dei vostri truculenti amici... Beh, forse ho esagerato un po`, ma in fondo in fondo lo spirito e` quello. Signore e signori, benvenuti nel mondo di A-Robots... 1-5. Cos'e` A-Robots? A-Robots e` un gioco per programmatori ideato dal sottoscritto dopo aver letto alcuni articoli su CRobots (C) e P-Robots (C). A quei tempi (1993) non avevo ancora a disposizione uno dei suddetti programmi, ma l'idea di poter controllare dei robots per farli combattere tra di loro mi affascinava non poco. Sostanzialmente A-Robots e` molto diverso dai suoi predecessori, sia perche` utilizza un linguaggio piu` vicino alle macchine, sia perche` i robots sono concettualmente diversi, e anche perche` e` stata curata e resa particolarmente gradevole la rappresentazione grafica degli scontri. Per chi non conoscesse il software summenzionato, occorre ricordare che il gioco principalmente consiste in questo: il giocatore crea un programma per la gestione di un robot combattente, dopodiche` il robot in questione viene posto nell'arena assieme ad altri robots guidati a loro volta da altri programmi. A questo punto lo scopo di ogni robot diventa quello di distruggere gli altri robots e sopravvivere allo stesso tempo. Nessuna trasgressione alle leggi della robotica di Asimov quindi, anche se a dire il vero qualche stupido di mia conoscenza ce l'avrei messo volentieri nell'arena... Ma procediamo per fasi all'illustrazione del gioco. 2. Descrizione di A-Robots 2-1. Caratteristiche degli A-Robots Premetto prima di tutto che i robots dati in dotazione ad ogni programmatore sono identici tra di loro, sta al programmatore l'arduo compito di far diventare il proprio "mostro" il piu` cattivo possibile (comportamento questo davvero apprezzato dal sottoscritto e dalla routine contapunti del simulatore). Elenco qui di seguito le caratteristiche salienti dei robots: - 4 processori con possibilta` di multitasking reale central process unit (CPU: sovraintende a tutte le attivita`) scan process unit (SPU: controlla il radar) gun process unit (GPU: controlla i sistemi d'arma) drive process unit (DPU: controlla il movimento) - scanner - cannone - mine - flares - razzi - scudi - cloaking - velocita` massima raggiungibile di 5 metri/ciclo 2-2. Architettura del robot ed orientamento nell'arena Il robot e` composto da 4 stadi sovrapposti l'uno all'altro (come da schema numero 1 sottostante) che durante il movimento risultano essere indipendenti tra di loro: in realta` cio` vale principalmente per il cannone in quanto e` l'unico dispositivo che possiede un reale orientamento rispetto allo zero (NORD) dell'arena. In poche parole se il cannone di un robot fermo punta a NORD, lo stesso cannone puntera` sempre a NORD anche se il robot comincera` a gironzolare per l'arena come un ubriaco. Questo tipo di regolazione degli angoli (vedi schema 2) facilita enormemente la progettazione del robot soprattutto se questi deve adottare una tecnica che lo vede molto mobile. Il range di specificazione degli angoli va da 0 a 359, anche se risulta possibile riferirsi ad angoli esterni all'intervallo, dato che tutte le funzioni che operano con angoli controllano che i valori rientrino sempre nell'intervallo 0..359. (esempio: il valore -24 e` trattato come 336 e il valore 390 come 30). Da questo momento in poi quando faro` riferimento ad un punto nell'arena rispetto ad un'altro punto utilizzero` la sintassi [ANGOLO,DISTANZA] per semplificare gli esempi. Tornando alla descrizione della struttura dei robots, immaginateli come dei grossi cilindri del diametro alla base di 1 metro, da cui sporge un rozzo ma efficace cannone. Dalla figura 1 potrete notare due cose: l'altezza del muro fa` si che le azioni del cannone e dello scanner siano interdette, mentre gli effetti dei colpi interessano lo stesso i processori del robot piu` o meno vicino all'esplosione. [ SCHEMA N.1 ] +-----------------+ | SEDE PROCESSORI | +-----------------+ ********** <-- ALTEZZA MURO | CANNONE |=========== ********** +-----------------+ ********** | SCANNER | ********** +-----------------+ ********** | MOTORE | ********** --+-----------------+--------------------------------- [ SCHEMA N.2 ] 315 0 45 \ | / \ | / 270 --- ROBOT --- 90 / | \ / | \ 225 180 135 2-3. I processori I processori sono diversi tra di loro ed ognuno svolge compiti differenti: La CPU controlla le attivita` principali del robot. Essa puo` accedere a qualsiasi dispositivo (anche se con priorita` minore rispetto ai processori dedicati), ma ha l'importantissimo compito di coordinare l'andamento degli altri processori. E` possibile per esempio fare in modo che mentre un processore controlla l'arena al fine di trovare un nemico, un'altro processore si occupi di far muovere il robot; la CPU potrebbe nel frattempo controllare le attivita` in corso ed intervenire in caso di guasti, attacchi, o qualsiasi altra cosa venga in mente al programmatore. Ogni processore ha la capacita` di controllare una serie di dispostivi dedicati a particolari attivita` (Spostamento del cannone, lancio dei razzi, etc...), ma non puo` accedere ai dispositivi che non siano i suoi. La CPU, come gia` premesso puo` invece prendere il controllo, per esempio, del cannone se questi non e` occupato dal processore GPU. Tutto questo per far capire che il robot puo` essere controllato non solo sequenzialmente ma anche in multitasking e tramite l'ausilio del trapping degli eventi (caratteristica questa che permette la sincronizzazione delle istruzioni). Ogni processore e` dotato di uno stack proprio delle dimensioni di 128 elementi; superato tale limite viene generato un errore di STACK OVERFLOW (STK OVFL) con conseguenze inenarrabili (per il robot). 2-4. Lo scanner Lo scanner (o radar) e` un elemento vitale per il robot perche` risulta essere l'unico dispositivo che permette al robot di capire che cosa lo circonda. Per utilizzare il radar bisogna effettuare una scansione di una parte dell'arena, decidendo l'angolo e l'apertura angolare. Il radar sara` quindi in grado di dirci cosa ha trovato (ostacolo, nemico, nulla, alleato). Se piu` possibili bersagli si trovano nella zona coperta dalla scansione, il radar ci fornira` i dati riguardanti quello piu` vicino. Il radar ritorna, dopo la scansione, la distanza e il tipo del bersaglio individuato, ma non l'angolo rispetto alla nostra posizione. Cio` costringe un robot che stia cercando un nemico ad operare scansioni mirate e precise. Effettuare una scansione di 90 gradi di ampiezza puo` essere utile solo se vogliamo sapere in che quadrante si trova il bersaglio ma non qual'e` la sua posizione; d'altro canto trovare qualcosa con una scansione di pochi gradi di ampiezza fara` si` che i nostri colpi siano precisi ed efficaci. Una buona tecnica di scansione permette al robot di colpire velocemente, mentre una scansione lenta dara` agli avversari tutto il tempo per demolirci, per cui non perdete troppo tempo nel creare routine complesse, a volte le cose semplici (ma non per questo meno intelligenti) sono le migliori. E` possibile anche impostare la distanza operativa dello scanner che di default e` di 1000 metri. 2-5. Il cannone Il cannone e` uno dei mezzi d'offesa a disposizione del robot e probabilmente il piu` utile. Il cannone deve essere prima di tutto regolato tramite l'alzo ed l'angolo desiderati, dopodiche` sara` possibile fare fuoco. Il numero dei colpi non e` definito, dato che ogni colpo sparato togliera` energia alla nostra riserva. E` importante per un robot ottenere l'iniziativa in uno scontro a fuoco con il cannone, dato che ogni colpo messo a segno spostera` il cannone avversario e gli impedira` di puntare lo stesso e contrapporsi al fuoco. N.B.: Gli angoli fanno sempre riferimento (lo ripeto perche` ritengo indispensabile la comprensione di questo concetto) ad uno zero comune per tutti i robots che e` il NORD. Questo comporta che qualunque sia la direzione presa da un robot (sempreche` sia in movimento), l'angolo del cannone sara` sempre uguale e rimarra` fisso anche se il robot cambiera` direzione. 2-6. Le mine Ogni robot dispone attualmente di 4 mine. Le mine devono essere programmate e successivamente piazzate da fermi (pena l'esplosione in corsa della stessa) con conseguenze nefande per il robot incriminato. La programmazione di una mina consiste nello specificare all'ordigno il proprio raggio d'attivazione e il tempo di ritardo a cominciare dalla sua posa. Il tempo di ritardo ci permettera` di allontanarci prima dell'attivazione (le mine non riconoscono chi le ha posate ed esplodono anche se siamo stati noi a piazzarle), mentre il raggio d'azione permettera` alla mina di essere piu` o meno efficace. Tra le varie tecniche d'uso delle mine vi posso assicurare che non c'e` niente di cosi` sadico come l'avvicinarsi ad un robot nemico senza che questi se ne accorga e infilargli una mina sotto la scheda madre, arh, arh... 2-7. I flares I flares sono proiettili particolari che lanciati alla velocita` desiderata (da 1 a 5 metri/ciclo) confondono i radar nemici che li fanno oggetto di una scansione. Lanciare un flare permette ad un robot di creare un proprio duplicato agli occhi degli altri robot che non potranno cosi` distinguere se il bersaglio inquadrato sia un robot od un flare. A questo proposito e` necessario specificare che se lo scanner trova un robot avversario, possiamo sapere chi abbiamo trovato tramite l'accesso ad una locazione contenente il codice identificativo del bersaglio (da -1 a -4). Il numero di flares in dotazione e` di 4, utilizzabili nel numero di uno alla volta. 2-8. I razzi Ogni robot ha in dotazione 4 razzi. Questi razzi sono in grado di seguire il segnale emesso dai robots avversari. Per utilizzare un razzo bisogna prima di tutto individuare il bersaglio tramite una scansione con il radar, puntare il tubo lancia-razzi (questo lo si fa puntando il cannone dato che i 2 dispositivi sono vincolati), dopodiche` diventa possibile lanciare uno o piu` razzi contro il bersaglio. Una volta lanciato, il razzo comincia ad accelerare fino al raggiungimento della velocita` di regime (in questo tratto di percorso l'ordigno non puo` curvare di molto verso l'obiettivo). Ad ogni ciclo la testata attiva del razzo identifica il segnale da ricercare piu` vicino, cio` permette al robot predestinato come vittima dell'attacco di lanciare un flare per disturbare la corsa del razzo. I razzi non sono sempre precisi ma se ben usati possono portare forti danni agli avversari. La tecnica migliore per lanciare un razzo dovrebbe essere quella di portarsi ad una distanza di 800-1000 metri dall'avversario (ancora meglio se l'altro robot e` adiacente al muro) e puntare diritto il bersaglio. Lanciare poi tutti e 4 i razzi assieme potrebbe si` risultare efficace, ma se il bersaglio ha gia` lanciato un flare, tutti i razzi potrebbero essere disturbati e le loro probabilita` di successo diminuirebbero fortemente. A voi comunque trovare il metodo piu` intelligente per usare queste armi. Dimenticavo di dire che un razzo arriva ad una velocita` di 25 metri/ciclo e possiede una potenza distruttiva pari a circa 13 colpi di cannone e quindi risulta anche pari a mezza mina. 2-9. Gli scudi Gli scudi sono proprio come quelli dei cartoni animati, niente di piu` niente di meno. L'uso degli scudi permette ad un robot di assorbire i colpi a lui diretti senza subire danni, ma con un calo di energia proporzionale all'entita` del colpo stesso. Gli scudi possono essere alzati ed abbassati a piacere con la sola limitazione che comunque c'e` un consumo minimo di energia per ciclo. Gli scudi se alzati impediscono il fuoco del cannone. E` inoltre possibile utilizzare gli scudi con fattori di assorbimento inferiori al 100% del colpo. Cio` permette al robot di risparmiare energia e di limitare leggermente i danni. 2-10. Il cloaking Ogni robot puo` decidere di mascherarsi elettronicamente e nascondersi alle scansioni dei radar nemici. Questa operazione risulta si` utilissima ma richiede uno spreco di energia non indifferente (vedi tabella dei consumi). Chiaramente anche se attivo il cloaking non difende il robot dagli effetti delle esplosioni che gli cadono vicine. Visto il grosso consumo di energia, ogni robot puo` decidere di utilizzare il cloaking con una percentuale di efficienza inferiore al 100% in modo da ridurre drasticamente i consumi. Impostando un'efficienza minore, il mascheramento non potra` sempre evitare al robot che lo sta utilizzando di non essere scoperto ma produrra` effetti sicuramente negativi sull'opera di scansione degli avversari. Ah, dimenticavo di dire che la probabilita` di essere scoperti (quando si usa il cloaking) diminuisce oltre che in base all'efficienza del cloaking anche in base alla distanza tra i due robots. 2-11. Il movimento I robots possono muoversi nell'arena, sfruttando una serie di propulsori dislocati tutt'attorno alla base del robot stesso. Il robot si muove utlizzando un grosso pneumatico sferico alla base e mantenendosi in equilibrio tramite sofisticati dispostivi di stabilizzazione. I consumi dovuti al movimento non sono di grossa entita` e sono comunque diversificati a seconda delle fasi. In accelerazione il consumo e` maggiore rispetto alla fase di movimento con i motori gia` a regime; frenare non costa nulla. 2-12. I danni I danni subiti dai robot a causa di esplosioni o collisioni (ebbene si` attenti a dove vi muovete) vanno interpretati in due modi diversi. Quando un colpo esplode ad una certa distanza e con un certo angolo crea una certa percentuale di danni sia strutturali (lesioni al rivestimento e cosi` via) che relativi all'efficienza dei 4 processori. Mentre per i danni strutturali questo e` sempre verificato (cioe` i danni sono sempre applicati a tutti i robots in gioco), per il calo d'efficienza invece il colpo deve interessare un processore non ancora distrutto. L'individuazione del processore danneggiato e` semplice, basta calcolare il quadrante relativo al robot in cui e` caduto il colpo e diminuire l'efficienza del processore posto in quel quadrante. Naturalmente di tutto questo se ne occupera` il simulatore di scontri che esamineremo in altra sede. L'eliminazione di un processore, non significa l'impossibilita` di usare i suoi dispositivi dedicati; per esempio se la GPU viene distrutta, la CPU puo` benissimo sostituirla ed usare il cannone al suo posto. Oltre a provocare dei danni al robot ed ai processori le esplosioni creano uno spostamento d'aria tale da spostare il cannone (cosa che rende piuttosto interessanti i duelli a due) e anche il robot. Anche le collisioni con muri esterni ed ostacoli interni provocano dei danni anche se piu` leggeri e comunque dipendenti dalla velocita` dell'impatto. Vorrei far notare che il persistere nello sbattere contro lo stesso muro oltre a non giovare fisicamente al robot non lo potra` certo far spiccare per intelligenza... 2-13. I consumi Riporto qui di seguito una tabella dei consumi indispensabile per una corretta pianificazione del comportamento degli a-robots. AZIONE O DISPOSITIVO CONSUMO % ENERGIA ------------------------------------------------- Scudi 0.01 * Eff% Cloaking 0.25 * Eff% Movimento 0.07 in accelerazione 0.05 a regime Assorbimento di un colpo da parte degli scudi (Danni% / 8) * Eff% Sparare un colpo di cannone 0.2 Scansione Apertura * Distanza / 3M N.B. Dove uso la notazione " Valore * Eff% " e` da intendersi un consumo pari alla percentuale Eff di Valore. 2-14. L'arena L'arena e` un'area quadrata di (1000 x 1000) metri recintata da un muro molto alto al cui interno avviene lo scontro. L'arena puo` essere vuota oppure puo` contenere fino a 10 ostacoli piazzati in modo casuale. Gli ostacoli in questione sono dei muretti lunghi da 1 a 300 metri. L'origine delle coordinate dell'arena (il punto 0,0) si trova in alto a sinistra (NORD-OVEST). 2-15. Le regole del gioco All'inizio dello scontro i robot (da 1 a 4) vengono posti casualmente nell'arena. A questo punto il simulatore comincia ad eseguire le istruzioni dei programmi caricati nella memoria di ciascun robot. Lo scopo e` di accumulare piu` punti degli avversari e per fare questo e` necessario distruggere gli altri robots. Una partita ha una durata massima di 3000 cicli al termine della quale vince il robot che ha piu` punti. Come vedremo in seguito ai fini di un torneo contano proprio questi punti e non punteggi falsi tipo "3 punti al primo", "2 al secondo" e cosi` via. Cio` permette che un robot dimostri davvero quello che vale (un robot che vince con scarto di pochi punti non merita di essere premiato tanto quanto un robot molto forte). Dato che in alcune situazioni i robot non sono cosi` intelligenti da riuscire a trovarsi o non possono perche` danneggiati o nascosti dagli ostacoli, ho introdotto la regola dell'inattivita` massima di 500 cicli per evitare noiosi stalli. Se per 500 cicli non accade nulla (cioe` almeno un'unita` percentuale di danno viene inflitta ad un robot) la partita termina come se si fossero raggiunti i 3000 cicli. Chiaramente ogni qualvolta viene superata questa soglia dell'1% il conteggio ricomincia da 500. L'assegnazione dei punteggi avviene tramite la formula: Punti = Danni_Inflitti * 3 + (100 - Danni_Percentuale) * 2 + Energia Nel comportamento di un robot si considerano quindi in ordine di importanza: 1 - Cattiveria 2 - Capacita` di sottrarsi ai nemici 3 - Strategia dei consumi Un cosa pero` vorrei sottolineare particolarmente: cercate di far sopravvivere sempre il vostro robot fino al termine dell'incontro. 3. IL LINGUAGGIO FROM (Fighting RObots Manager) 3-1. Caratteristiche generali del linguaggio Premetto che per meglio comprendere il linguaggio non sarebbe affatto male una conoscenza seppur minima di un qualsiasi assembler. Se affrontate per la prima volta un linguaggio a basso livello, non spaventatevi, FROM non e` certo cosi` complesso come un vero assembler ma richiede comunque uno sforzo iniziale non indifferente (come tutti gli altri linguaggi). Vi consiglio di studiare con attenzione gli esempi ed i programmi forniti come demo. Eventualmente non vi farebbe neanche male imparare il linguaggio RED-CODE (Un assembler essenziale) usato per gli scontri di CORE WARS. A tale proposito rimando alla lettura del file LED.TXT gli appassionati della guerra dei nuclei: ci sono golose novita` per voi! Il linguaggio FROM e` molto simile ad un linguaggio assembler e come tale le istruzioni sono rappresentate da codici mnemonici seguiti dai relativi operandi. Le istruzioni vanno usate nel formato: [] [],[],...,[] Le etichette hanno una lunghezza massima di 16 caratteri e devono cominciare con una lettera dell'alfabeto. Non vi possono essere righe contenenti solamente un'etichetta. I commenti si possono inserire sia all'inizio di una riga che alla fine e devono essere preceduti da uno dei seguenti caratteri: (') o (;). Tutti i valori rientrano nel range di un LONG INTEGER (32 bit) con segno, percio` andiamo a finire nell'intervallo (+)(-) 2.147.483.648, oltre tale limite i processori del robot vanno in OVERFLOW (cosi` ho deciso...ugh!). Vi assicuro comunque che non c'e` assolutamente bisogno di oltrepassare tali limiti (non credo avrete bisogno di far calcolare distanze stellari ai vostri robots). Per chi stesse gia` pensando a programmi auto-modificanti, anticipo subito che tutte le operazioni di somma, sottrazione, confronto, spostamento, etc... vanno ad agire solo sul primo campo dell'indirizzo specificato. ESEMPIO: ;DISASSEMBLATO: ;------------- ;TOKEN CAMPO1 CAMPO2 ; mov Label1,Label2 ;MOV $1 $2 Label1 add #4,10 ;ADD #4 $10 Label2 dc 8 ;DC #8 Il MOV nell'esempio porta il valore #4 nel campo 1 di Label2, cioe` al posto del valore #8. N.B. Tutte le istruzioni abbisognano di 1 solo ciclo. Uniche eccezioni a questa regola sono i tokens DRIVE e STOP. Per maggiori chiarimenti fare riferimento al sezione del manuale dedicata a queste due istruzioni. 3-2. I metodi d'indirizzamento FROM supporta 3 tipi di indirizzamento: $ relativo (default) (A) # diretto (B) @ indiretto (C) A) L'indirizzamento relativo specifica l'offset della locazione indicata. ESEMPIO: mov Label1,Label2 ;mov $1,$2 Label1 dc 10 ; Label2 dc 0 ;Label2 = 10 B) L'indirizzamento diretto specifica il valore contenuto nella locazione indicata. ESEMPIO: mov #10,Label1 ;mov #10,$2 Label1 dc 0 ;Label1 = 10 C) L'indirizzamento indiretto specifica il valore contenuto nella locazione puntata dalla locazione indicata (argh!!!!). ESEMPIO: mov @Label1,Label2 ;mov @1,$2 Label1 dc Label3 ;dc $2 --+ Label2 dc 0 ; | Label2 = 10 Label3 dc 10 ; <-+ 3-3. Le variabili di stato del robot Il robot possiede un'area di memoria riservata e a sola lettura che va dalla locazione 0 alla locazione 49. Entro quest'area ci sono una serie di locazioni (definite variabili di stato) che permettono al programmatore di avere un resoconto sempre aggiornato durante la battaglia della situazione del robot e di quello che sta facendo. E` possibile fare accesso a tali locazioni mediante delle labels predefinite e quindi riservate dal linguaggio. L'accesso in scrittura ad una di queste locazioni genera un errore "RES. AREA". Ecco qui di seguito l'elenco delle suddette variabili: _HEADING Direzione del robot _GUNHEADING Angolo verso cui punta il cannone _CRX Coordinata X del robot all'interno dell'arena _CRY Coordinata Y del robot all'interno dell'arena _TARGETDISTANCE Distanza dell'obiettivo _METERS Metri percorsi dall'inizio dello scontro _ENERGY Energia percentuale rimasta _GUNDISTANCE Distanza verso cui punta il cannone _VELOCITY Velocita` attuale del robot _MOVING TRUE (-1) se il robot si sta muovendo FALSE (0) se e` fermo _SHIELDSTATUS Stato degli scudi: TRUE alzati FALSE abbassati _OBJECTSCANNED Tipo del bersaglio identificato dallo scanner: 0 -> Niente -1,-2,-3,-4 -> Numero del robot avversario 1 -> Ostacolo 2 -> Alleato _CPUDAMAGE Danno % alla CPU _GUNDAMAGE Danno % alla GPU _DRIVEDAMAGE Danno % alla DPU _SCANDAMAGE Danno % alla SPU _GLOBALDAMAGE Danno % strutturale del robot. Se 100 il robot e` morto _SCANDISTANCE Raggio massimo di una scansione _SHIELDEFFICENCY Efficienza % degli scudi _CYCLE Numero di ciclo dall'inizio della battaglia _MINES Numero di mine presenti ed utilizzabili _FLARES Numero di flares presenti ed utilizzabili _ROCKETS Numero di razzi presenti ed utilizzabili 3-4. Il set di istruzioni Per meglio aiutare il lettore nella consultazione del manuale ho diviso le istruzioni per processori abilitati all'uso delle stesse e per sezioni. TOKEN OPERANDI ----- -------- .DIRETTIVE equ expression dc value ds number_of_locations,value defstr message_number,message .ISTRUZIONI D'USO GENERALE add value,address sub value,address mul value,address div value,address mov value,address djn counter,address push value pop address lea address_to_load,address cmp value1,value2 jmp address jsr address jgt address jge address jeq address jne address jle address jlt address bgt address bge address beq address bne address ble address blt address rts lddrv address ldscan address ldgun address rsdrv rsscan rsgun trap address_to_check,value,address,condition untrap sqr value,address rnd max,address mod module,address sin value,address cos value,address delay cycles dist x1,y1,x2,y2,address angle x1,y1,x2,y2,address say message_number (pseudo-istruzione) .RISERVATE GPU aim angle,distance fire setmine range,delay dropmine launch flare velocity setshld percentual upshld dnshld .RISERVATE DPU drive angle,meters,velocity stop .RISERVATE SPU setscan distance scan angle,delta setclk percentual cloakon cloakoff 4. Il manuale FROM ---------------- EQU Expression ---------------- La direttiva EQU permette di assegnare a delle label dei valori che potranno essere usati solo a livello di compilazione. La label in questione viene trattata alla stregua di una costante e in fase di compilazione viene sostituito ad ogni suo riferimento il valore corrispondente. La routine che valuta le espressioni e` abbastanza potente (20 livelli di parentesi) e rispetta tutte le regole di priorita` degli operandi. Il numero massimo di EQU utilizzabili e` pari a 50. Le EQU devono precedere le linee di codice che fanno ad esse riferimento. PARAMETRI: Expression -> Una qualsiasi espressione ESEMPIO: Label1 equ 100 Label2 equ (20+2*4) Label3 equ -(30*(2-3)+(-2)) Label4 equ Label1+Label2 ;Label4 = 100+28 = 128 ---------- DC value ---------- Acronimo di "define constant", questa direttiva indica al compilatore che la label interessata deve essere trattata come una variabile e che deve assumere come valore iniziale quello indicato. In pratica tale direttiva riserva una locazione a cui ci si puo` riferire con il nome della label. PARAMETRI: Value -> valore da assegnare ESEMPIO: Indirizzo dc Loop Counter dc #100 Loop . . djn Counter,@Indirizzo ------------------------------ DS number_of_locations,value ------------------------------ La direttiva DS (DEFINE SPACE) corrisponde ad una definizione multipla della direttiva DC, solo che invece di una variabile, definisce un vettore di locazioni che iniziano all'indirizzo indicato dalla label. PARAMETRI: number_of_locations -> Numero di locazioni da usare value -> Valore con cui settare le locazioni interessate ESEMPIO: Array ds 100,2 ;Usa 100 locazioni e setta ;il campo di tali locazioni a 2 Ptr dc Array ;Puntatore al primo elemento ;di Array ------------------------------- DEFSTR message_number,message ------------------------------- Definisce un messaggio che potra` poi essere visualizzato. Il messaggio non puo` essere piu` lungo di 30 caratteri (in caso contrario verra` troncato) e non deve contenere il carattere ",", perche` usato come separatore degli operandi. PARAMETRI: message number -> Numero del messaggio da definire (Da 1 a 20) message -> Messaggio ESEMPIO: defstr 1,Prendi questo !!! Attack say #1 ;Visualizza il messaggio ;N.1 prima di sparare fire fire rts ------------------- ADD value,address ------------------- Somma VALUE al contenuto di ADDRESS. PARAMETRI: value -> Il primo operando address -> Indirizzo che contiene l'altro operando ed in cui sara` posto il risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: V1 dc 4 add #10,V1 ;V1 = 4+10 = 14 ------------------- SUB value,address ------------------- Sottrae VALUE al contenuto di ADDRESS. PARAMETRI: value -> Il valore da sottrarre address -> Indirizzo che contiene l'altro operando ed in cui sara` posto il risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: V1 dc 10 sub #4,V1 ;V1 = 10-4 = 6 ------------------- MUL value,address ------------------- Moltiplica VALUE per il contenuto di ADDRESS e pone il risultato in ADDRESS. PARAMETRI: value -> Il moltiplicatore address -> Indirizzo del moltiplicando e del risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: mul #3,V1 ;V1 = V1*3 = 4*3 = 12 V1 dc 4 ------------------- DIV value,address ------------------- Divide il contenuto di ADDRESS per VALUE e pone il risultato in ADDRESS. Una divisione per zero genera un errore "ZERO DIV". PARAMETRI: value -> Divisore address -> Indirizzo del dividendo e del risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: div #3,V1 ;V1 = V1/3 = 12*3 = 4 V1 dc 12 ------------------- MOV value,address ------------------- Muove VALUE nel campo 1 di ADDRESS. PARAMETRI: value -> Un qualsiasi valore address -> L'indirizzo di destinazione di VALUE PROCESSORI ABILITATI: (Tutti) ESEMPIO: V1 dc 0 mov #1,V1 ;V1 = 1 --------------------- DJN counter,address --------------------- Decrementa il contatore COUNTER e salta ad ADDRESS se COUNTER <> 0. PARAMETRI: Counter -> Indirizzo del contatore Address -> Indirizzo a cui saltare se il contatore non e` 0 PROCESSORI ABILITATI: (Tutti) ESEMPIO: (Vedi CMP) ------------ PUSH value ------------ Pone VALUE nello stack del processore che esegue l'istruzione. Se lo stack e` pieno viene generato un errore STK OVFL. PARAMETRI: value -> Valore che deve essere posto nello stack PROCESSORI ABILITATI: (Tutti) ESEMPIO: mov #10,A ;A=10 push A ;A nello stack mov #20,A ;A=20 pop A ;Recupera A dallo stack: A=10 ------------- POP address ------------- Recupera l'ultimo valore posto nello stack tramite PUSH,Jcc o Bcc. PARAMETRI: address -> Indirizzo di destinazione del valore recuperato PROCESSORI ABILITATI: (Tutti) ESEMPIO: (Vedi PUSH) ----------------------------- LEA address_to_load,address ----------------------------- Carica in ADDRESS l'indirizzo ADDRESS_TO_LOAD inteso come offset tra i due. Cio` permette di utilizzare ADDRESS come puntatore ad ADDRESS_TO_LOAD. PARAMETRI: address_to_load -> Indirizzo da caricare (come offset) in ADDRESS address -> Indirizzo del puntatore PROCESSORI ABILITATI: (Tutti) ESEMPIO: lea Table,Ptr ;equivale a 'Ptr dc Table' Ptr dc 0 Table ds 100,0 ------------------- CMP value1,value2 ------------------- Confronta i due valori e setta il flag di confronto della CPU interessata. Il confronto dovra` essere fatto tra il secondo operando rispetto al primo. PARAMETRI: value1,value2 -> 2 valori qualsiasi da confrontare PROCESSORI ABILITATI: (Tutti) ESEMPIO: mov #5,C Loop cmp #0,V1 jlt Label1 ;Salta a Label1 se V1 < 0 ;(In questo caso si`) djn C,Loop ;Effettua 5 volte il controllo ;sulla variabile jmp Main ;V1, dopodiche` torna a MAIN V1 dc -2 C dc 0 Label1 fire ------------- JMP address ------------- Salta all'indirizzo ADDRESS. PARAMETRI: address -> Indirizzo a cui saltare PROCESSORI ABILITATI: (Tutti) ESEMPIO: jmp Label1 . . Label1 ------------- JSR address ------------- Salta ad una subroutine che comincia all'indirizzo ADDRESS. L'indirizzo di ritorno viene memorizzato nello stack del processore utilizzato. PARAMETRI: address -> Indirizzo d'inizio della subroutine PROCESSORI ABILITATI: (Tutti) ESEMPIO: jsr Label1 ;Salta a Label1 . . Label1 rts ;Ritorna a ------------- Jcc address ------------- Salto condizionato dove "cc" indica la condizione da soddisfare. "cc" viene descritto nella tabella sottostante. cc | Condizione ---+----------- GT | > GE | >= EQ | = NE | <> LE | <= LT | < La condizione e` verificata o meno a seguito di un'istruzione CMP che va a settare il corrispondente FLAG di confronto. Ogni processore dispone di un registro di FLAG proprio in modo che non ci sia la possibilita` di condizionare il salto degli altri processori. PARAMETRI: address -> Indirizzo di destinazione del salto PROCESSORI ABILITATI: (Tutti) ESEMPIO: (Vedi CMP) ------------- Bcc address ------------- Diramazione condizionata dove cc e` specificato nella tabella sottostante. cc | Condizione ---+----------- GT | > GE | >= EQ | = NE | <> LE | <= LT | < La condizione e` verificata o meno a seguito di un'istruzione CMP che va a settare il corrispondente FLAG di salto. Ogni processore dispone di un registro di FLAG proprio in modo che non ci sia la possibilita` di condizionare il salto degli altri processori. A differenza dei vari JGT, JEQ, etc..., l'istruzione Bcc carica nello stack l'indirizzo di ritorno. In pratica viene effettuata una chiamata ad una sub-routine che dovra` terminare con RTS. Cio` permette di ottimizzare il codice e di risparmiare tempo oltre che di incrementare le prestazioni del robot. PARAMETRI: address -> Indirizzo di destinazione del salto PROCESSORI ABILITATI: (Tutti) ESEMPIO: Delta equ #20 Loop scan Ang,#Delta ;Effettua una scansione cmp #0,_ObjectScanned ;Se rilevato un nemico salta blt Attack ;ad Attack add #Delta,Ang jmp Loop Attack aim Ang,_TargetDistance fire rts ----- RTS ----- Ritorna da una subroutine chiamata con JSR. L'indirizzo di ritorno si trova nello stack del processore corrispondente. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: (Tutti) ESEMPIO: (Vedi JSR) --------------- LDDRV address --------------- Carica nel Program Counter della DPU l'indirizzo ADDRESS. PARAMETRI: address -> L'indirizzo della routine che il processore dovra` cominciare ad eseguire PROCESSORI ABILITATI: CPU ESEMPIO: lddrv Label1 ;Carica nel PC interessato ;l'indirizzo di ;Label1 e attiva il processore ;dedicato . . rsdrv ;Pone a 0 il PC e disattiva il ;processore Label1 . . ---------------- LDSCAN address ---------------- Carica nel Program Counter dell'SPU l'indirizzo ADDRESS. (vedi LDDRV) --------------- LDGUN address --------------- Carica nel Program Counter della GPU l'indirizzo ADDRESS. (vedi LDDRV) ------- RSDRV ------- Resetta il PC della DPU e disattiva il processore stesso. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: DPU,CPU ESEMPIO: (vedi LDDRV) -------- RSSCAN -------- Resetta il PC dell'SPU e disattiva il processore stesso. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: SPU,CPU ESEMPIO: (vedi LDDRV) ------- RSGUN ------- Resetta il PC della GPU e disattiva il processore stesso. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: GPU,CPU ESEMPIO: (vedi LDDRV) ----------------------------------------------- TRAP address_to_check,value,address,condition ----------------------------------------------- L'istruzione TRAP permette ad un processore di catturare un evento senza doversi preoccupare di controllare continuamente l'evento stesso. Per evento e` da intendersi il verificarsi della condizione impostata tra un certo valore e il contenuto di una locazione. In parole povere possiamo dire al processore interessato di controllare ad ogni ciclo lo stato di una variabile e di saltare ad una routine di gestione dell'evento nel caso di condizione verificata. Tutto questo risulta trasparente al processore che nel frattempo puo` continuare ad eseguire altre istruzioni. E` ammessa una sola TRAP per ogni processore, infatti l'ultima TRAP eseguita e` sempre quella attiva. Questa istruzione risulta molto utile per sincronizzare le operazioni di piu` processori (la GPU puo` per esempio attendere che l'SPU trovi un bersaglio ed attivare di conseguenza una routine che usi il cannone in modo adeguato). PARAMETRI: address_to_check -> Indirizzo da controllare value -> Valore che deve assumere la locazione address_to_check perche` sia verificato l'evento address -> Indirizzo della routine a cui saltare nel caso si verifichi l'evento condition -> Valore che indica il tipo di condizione da verificare condizione confronto ------------------------ -2 < -1 <= 0 = 1 >= 2 > 3 <> PROCESSORI ABILITATI: (Tutti) ESEMPIO: ;In questo esempio lo scanner controlla l'arena fino a che ;il robot non si muove (altri processori decideranno quando) ; ;Cattura l'evento: trap _Moving,#-1,Moving_Robot,0 Scan_Loop scan Ang,#20 ;_Moving = -1 cmp #0,_ObjectScanned jlt Enemy_Found add #20,Ang jmp Scan_Loop Ang dc 0 Moving_Robot untrap ;Annulla la trap -------- UNTRAP -------- Annulla l'ultima TRAP attiva del processore interessato. E` un'operazione necessaria se non vogliamo che il PC del processore continui a tornare all'indirizzo d'inizio della routine di gestione dell'evento. Altro modo di far questo e` quello di modificare il valore contenuto nella locazione controllata; in tal modo la TRAP attiva non trovera` verificata la condizione ed il programma potra` continuare normalmente. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: (Tutti) ESEMPIO: (Vedi TRAP) ------------------- SQR value,address ------------------- Calcola la radice quadrata di VALUE e pone il risultato nel campo 1 della locazione ADDRESS. Un valore di VALUE <= 0 genera un errore SQR ERR. PARAMETRI: value -> Il valore di cui calcolare la radice quadrata address -> L'indirizzo di destinazione del risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: sqr V1,V2 ;V2 = SQR(V1) = SQR(16) = 4 V1 dc 16 V2 dc 0 ----------------- RND max,address ----------------- Pone in ADDRESS un valore casuale compreso tra 0 e MAX compresi. PARAMETRI: max -> Massimo valore casuale address -> Indirizzo di destinazione del risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: rnd #90,Label1 ;Pone un valore casuale tra 0 e 90 in Label1 dc 0 ;Label1 ------------------- MOD value,address ------------------- Carica in ADDRESS il valore modulo MODULE del contenuto di ADDRESS. PARAMETRI: value -> Valore del modulo da calcolare. address -> Indirizzo del valore di cui calcolare il modulo e destinazione del risultato. PROCESSORI ABILITATI: (Tutti) ESEMPIO: Loop add #3,Angolo ;Incrementa l'angolo e ne mod #360,Angolo ;calcola il valore modulo 360 jmp Loop Angolo dc 0 ------------------- SIN value,address ------------------- Ritorna in ADDRESS il seno di VALUE nel range 0..1000. PARAMETRI: value -> Un qualsiasi valore di cui calcolare il seno address -> Indirizzo di destinazione del risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: angle _CRX,_CRY,#500,#500,Ang ;Angolo dal robot ;al centro. sin Ang,SinA ;Calcola seno e cos Ang,CosA ;coseno dell'angolo ;ricavato. Ang dc 0 SinA dc 0 CosA dc 0 ------------------- COS value,address ------------------- Ritorna in ADDRESS il coseno di VALUE nel range [0,1000] PARAMETRI: value -> Un qualsiasi valore di cui calcolare il coseno address -> Indirizzo di destinazione del risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: (Vedi SIN) -------------- DELAY cycles -------------- Imposta un ritardo di CYCLES cicli per il processore interessato. Il ciclo utilizzato per l'esecuzione dell'istruzione non e` considerata come parte del tempo di ritardo. PARAMETRI: cycles -> Numero di cicli del ritardo. PROCESSORI ABILITATI: (Tutti) ESEMPIO: upshld delay #99 ;Alza gli scudi per (99 + 1) cicli dnshld -------------------------- DIST x1,y1,x2,y2,address -------------------------- Calcola la distanza in metri (arrotondata per difetto) tra i 2 punti (X1,Y1)-(X2,Y2) e pone il risultato in ADDRESS. PARAMETRI: x1,y1,x2,y2 -> Coordinate X e Y dei 2 punti address -> Indirizzo di destinazione del risultato PROCESSORI ABILITATI: (Tutti) ESEMPIO: angle _CRX,_CRY,#500,#500,A ;Calcola angolo e dist _CRX,_CRY,#500,#500,D ;distanza dalla propria D dc 0 ;posizione al centro A dc 0 ;dell'arena --------------------------- ANGLE x1,y1,x2,y2,address --------------------------- Calcola l'angolo tra il punto (X1,Y1) e il punto (X2,Y2). (Vedi DIST) -------------------- SAY message_number -------------------- Questa pseudo-istruzione visualizza un messaggio definito tramite la direttiva DEFSTR. Ho definito SAY come pseudo-istruzione perche` anche se eseguita normalmente durante lo scontro, SAY non ruba cicli al robot rallentandolo. Questa pseudo-istruzione puo` essere utile in fase di sviluppo come debug ma soprattutto durante lo scontro per lanciare terrificanti minacce agli avversari. Eventualmente potreste anche invocare pieta`... PARAMETRI: message_number -> Numero del messaggio da visualizzare ESEMPIO: (Vedi DEFSTR) -------------------- AIM angle,distance -------------------- Punta il cannone verso il punto distante DISTANCE metri in direzione ANGLE. All'inizio il cannone punta verso [0,1]. La velocita` di spostamento del cannone e` di 10 gradi/ciclo PARAMETERI: angle -> Angolo di puntamento distance -> Distanza di puntamento PROCESSORI ABILITATI: GPU,CPU ESEMPIO: aim #90,#300 ;Punta il cannone verso [90,300] fire ;e spara ------ FIRE ------ Spara un colpo nella zona puntata dal cannone. Non possibile se gli scudi sono alzati. Se il cannone non viene puntato il colpo cadra` in direzione [0,1] con effetti disastrosi per chi spara (Non escludo suicidi di massa). L'effetto di un colpo su di un robot si calcola tramite la formula: Effetto % del colpo = 40 / Distanza dal colpo Cio` implica che a 40 metri il danno % sara` di 1, a 30 metri di 1.5 e cosi` via. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: GPU,CPU ESEMPIO: (Vedi AIM) --------------------- SETMINE range,delay --------------------- Programma la prossima mina che verra` depositata a terra dal robot. Tutte le mine sono programmate di default con un ritardo pari a 100 cicli e un raggio di attivazione di 100 metri. PARAMETRI: range -> raggio di attivazione in metri delay -> numero di cicli di ritardo dalla posa al momento dell'attivazione dell'ordigno PROCESSORI ABILITATI: GPU,CPU ESEMPIO: (Vedi DROPMINE) ---------- DROPMINE ---------- Posa una mina nel punto in cui si trova il robot. Il robot deve essere fermo (non importa se volontariamente o no), pena l'esplosione dell'ordigno innescato. La posa di una mina quando le stesse sono finite provoca un errore NO MINES. Una mina ha un fattore % di efficienza pari a 25 volte un singolo colpo di cannone. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: GPU,CPU ESEMPIO: stop ;Blocca il robot Loop cmp #-1,_Moving jeq Loop ;Aspetta che il robot sia ;davvero fermo setmine #10,#100 ;Programma la mina: ;raggio=10 e delay=100 dropmine ;Posa la mina drive #0,#300,#5 ;Si allontana -------- LAUNCH -------- Lancia un razzo nella direzione puntata dal tubo lancia-razzi (la stessa del cannone). Il razzo segue il bersaglio individuato dall'ultima scansione, infatti va ad esaminare il contenuto di _ObjectScanned (peraltro non modificabile) ed e` del tipo lancia e dimentica. Nel puntamento del cannone non ha nessuna importanza la distanza. N.B.:Se il razzo viene lanciato quando _ObjectScanned non contiene un codice identificativo di un nemico il razzo non potra` agganciare nessuno bersaglio e puntera` diritto contro il muro antistante. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: GPU,CPU ESEMPIO: aim #90,#300 ;Punta il cannone verso [90] launch ;e lancia un razzo ---------------- FLARE velocity ---------------- Lancia un flare nella direzione puntata dal cannone. Non e` possibile lanciare un flare se ne esiste gia` uno dello stesso robot all'interno dell'arena. Un flare scompare quando incontra un ostacolo od il muro. L'esecuzione di questa istruzione nel caso di serbatoio vuoto genera un errore NO FLARE. PARAMETRI: velocity -> Velocita` alla quale si deve spostare il flare PROCESSORI ABILITATI: GPU,CPU ESEMPIO: angle _CRX,_CRY,#500,#500,A aim A,#2000 ;Lancia un flare verso flare #1 ;il centro dell'arena A dc 0 -------------------- SETSHLD percentual -------------------- Imposta la percentuale di assorbimento degli scudi. Una percentuale del 50% fara` si` che meta` colpo sia assorbito ed il resto danneggi il robot. Il valore di default e` del 100%. PARAMETRI: percentual -> Percentuale di assorbimento degli scudi PROCESSORI ABILITATI: GPU,CPU ESEMPIO: dnshld ;Abbassa gli scudi (Non necessario ;per usare SETSHLD) setshld #90 ;Porta l'efficienza al 90% upshld ;Rialza gli scudi -------- UPSHLD -------- Alza gli scudi. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: GPU,CPU ESEMPIO: (Vedi SETSHLD) -------- DNSHLD -------- Abbassa gli scudi. (Vedi UPSHLD) ----------------------------- DRIVE angle,meters,velocity ----------------------------- Attiva il motore del robot verso [ANGLE,METERS] con velocita` VELOCITY. Se il robot e` fermo, comincera` ad accelerare fino a raggiungere la velocita` specificata, mentre se il robot si trova gia` in movimento comincera` a virare verso l'angolo impostato dalla nuova istruzione, con raggio di curvatura dipendente dalla velocita` attuale. Chiaramente il robot scegliera` la via piu` breve per raggiungere l'angolatura desiderata. Al termine dell'istruzione (che durera` per il numero di cicli necessari a coprire i metri impostati) il robot non si fermera` ma continuera` a correre con moto uniforme nella direzione in cui si sta dirigendo. Tale comportamento permette al programmatore di far compiere al robot traiettorie elaborate mantenendo il robot in movimento. Se invece vogliamo bloccare il robot al termine della corsa bastera` dare l'istruzione STOP e il robot comincera` a decelerare fino a fermarsi completamente. Eventuali ostacoli incontrati sul percorso impostato dal robot lo bloccheranno impedendogli di completare in breve tempo l'istruzione DRIVE. Se un robot quindi va a sbattere contro un muro con 50 metri ancora da percorrere, li percorrera` a rilento, dato che il robot continuera` a rimbalzare contro il muro e a spostarsi di poco per volta. L'accelerazione e` di 0.05 metri/ciclo. PARAMETRI: angle -> Direzione meters -> Metri da percorrere prima di terminare l'esecuzione dell'istruzione velocity -> velocita` di regime della corsa. PROCESSORI ABILITATI: DPU,CPU ESEMPIO: drive #90,#100,#3 ;Corre in direzione [90,100] con ;velocita` 3 drive #180,#100,#1 ;Rallenta e ruota di 90 gradi ;a destra stop ;dopodiche` si blocca ------ STOP ------ Blocca la corsa del robot con una decelerazione di 1 metro/ciclo. Questa istruzione al pari della precedente, cioe` DRIVE dura il numero di cicli necessario perche` il robot si fermi. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: DPU,CPU ESEMPIO: (Vedi DRIVE) ------------------ SETSCAN distance ------------------ Imposta il raggio della scansione a DISTANCE metri. Il valore di default e` di 1000 metri. PARAMETRI: distance -> Raggio in metri della scansione PROCESSORI ABILITATI: SPU,CPU ESEMPIO: (vedi SCAN) ------------------ SCAN angle,delta ------------------ Effettua una scansione in direzione ANGLE con ampiezza DELTA. PARAMETRI: angle -> Angolo di scansione delta -> Ampiezza in gradi della scansione PROCESSORI ABILITATI: SPU,CPU ESEMPIO: setscan #500 ;Imposta il raggio della ;scansione: 500 metri scan #90,#20 ;Effettua una scansione a ;90 gradi di 20 gradi di ampiezza ------------------ SETCLK efficency ------------------ Imposta l'efficienza percentuale del cloaking. PARAMETRI: efficency -> Percentuale di efficienza PROCESSORI ABILITATI: SPU,CPU ESEMPIO: setclk #60 ;Efficienza del mascheramento al 60% cloakon ;Attiva il mascheramento Loop djn C,Loop ;Attende 100 cicli cloakoff ;Disattiva il mascheramento C dc 100 --------- CLOAKON --------- Attiva il mascheramento elettronico che permette al robot di diventare invisible agli occhi degli altri robot. Un robot puo` rimanere mascherato, sfruttando tutta l'energia, per 1500 cicli circa. PARAMETRI: (Nessuno) PROCESSORI ABILITATI: SPU,CPU ESEMPIO: (Vedi SETCLK) ---------- CLOAKOFF ---------- Disattiva il mascheramento. (Vedi CLOAKON) 5. La versione shareware di A-Robots Il pacchetto shareware di A-Robots si compone di un dischetto o di un file zippato (a seconda di dove ve lo siate procurato) contenente la seguente lista di files: FROM.EXE Simulatore degli scontri + Ambiente FRODE FROMINT.EXE Simulatore degli scontri + Ambiente FRODE (Versione per calcolatori privi di coprocessore matematico) FROMC.EXE Compilatore dei programmi in linguaggio FROM FROMD.EXE Disassemblatore FROTAD.EXE Gestore dei tornei A-ROBOTS.DOC Manuale di A-Robots e del linguaggio FROM FROM.DOC Documentazione per FROM.EXE FROMC.DOC Documentazione per FROMC.EXE FROTAD.DOC Documentazione per FROTAD.EXE FROMD.DOC Documentazione per FROMD.EXE _ *.FRS | *.MAP |---- Raccolta di esempi di programmi FROM *.FRO _| A-R_DEMO.BAT Batch che lancia una partita demo NEWS.TXT History di A-Robots LED.TXT Novita` riguardanti la LED Soft Engineering Assieme ad A-Robots viene distribuito anche una versione essenziale, priva di compilatore ed estrattore delle Leonard Guides (prodotte dalla Led Soft Engineering di cui faccio parte). Per maggiori chiarimenti o per ottenere la versione completa delle Leonard Guides fate riferimento al file LED.TXT LG.COM Help ipertestuale residente LG.DOC Documentazione di LG.COM A-ROBOTS.LG File A-ROBOTS.DOC compilato per le Leonard Guides 6. Considerazioni finali 6-1. Consigli per la programmazione in linguaggio FROM I consigli che qui di seguito propongo non vogliono essere dogmi, ma semplici considerazioni per i meno esperti, basate su esperienze provate di persona con chi affronta per la prima volta il FROM. Sia chiaro che non e` mia intenzione insegnare l'arte della programmazione a chiccessia in nessun caso, ritengo anzi indispensabili i concetti basilari della programmazione per affrontare con un minimo di serenita` il primo approccio al FROM. Non voglio nemmeno assillarvi con discorsi del tipo: "Fate il flow chart del vostro programma!" (bleah... disgustoso), percio` in bocca al lupo. 1. Esaminate con molta attenzione i listati forniti come esempi: oltre a spiegare le tattiche seguite sono commentati esaurientemente e non solo dal sottoscritto ma anche da altri autori. 2. Cominciate con il programmare robots in maniera molto semplice: per esempio una sola CPU attiva, una routine di scansione e una di fuoco. Poi quando vi sentirete piu` sicuri provate ad aggiungere pezzi di routines sino al completamento dell'opera. 3. Evitate la stesura di programmi cervellotici e/o invasi da salti incrociati: non funzionera` mai (o quasi...). E` preferibile scrivere un programma strutturato, facendo uso di salti (Bcc,JSR) a delle sub-routines, ed e` sempre meglio esagerare in questo senso che nell'altro, ricordatelo... 4. Tenete bene a mente che non tutti i processori hanno accesso a tutte le attivita` del robot. Eviterete cosi` di perdere tempo nel cercare di capire perche` certe volte il vostro robot non spara o non si muove. 5. Se qualcosa non funziona, partite dal presupposto di essere voi stessi a sbagliare (assioma di Marangon), cercate di scoprire il perche` tramite l'uso del FRODE e della documentazione. Se dopo tutto questo non verrete a capo del problema, contattate il sottoscritto perche` potreste anche aver scoperto un bug. 6-2. Quali sono i passi da seguire per creare un A-Robot? Il primo passo consiste nello scrivere un programma in linguaggio FROM. Dotatevi quindi di un editor di testo qualsiasi e passate alla stesura del programma. Il file dovra` avere un'estensione FRS (Figthing Robots Source). Nella fase di scrittura dei programmi vi sara` sicuramente d'aiuto l'utility LG.COM. Lanciatela all'inizio e poi attivetela all'interno dell'editor tramite l'hot-key CTRL-F12. Potrete a questo punto disporre di una guida on-line ad A-Robots completa di riferimenti ipertestuali, search-mode, etc...etc... Una volta salvato il programma compilatelo tramite il programma FROMC: C:\A-ROBOTS>FROMC Otterrete a questo punto, previa segnalazione di errori piu` o meno volontari, un codice oggetto con l'estensione FRO (Fighting Robots Object code). Potrete percio` lanciare una partita nel modo seguente: C:\A-ROBOTS>FROM GUNDAM MKH ZACK942 Il vostro robot combattera` contro Gundam, Mkh e Zack942 (forniti come demo) e potrete ammirare il vostro robot impegnato in combattimento. Errori ed eventuali dubbi potranno essere fugati dalla vostra mente tramite l'utilizzo dell'ambiente di debugging FRODE compreso nel programma FROM. N.B. Leggete attentamente la documentazione relativa a tutti i tools che compongono il Kit di A-Robots. 6-3. Prospettive e ringraziamenti A-Robots uscira` nella prossima release con novita` abbastanza interessanti. Sicuramente oltre alla normale disinfestazione da bugs piu` o meno evidenti verra` implementata la gestione degli scontri in team (2 contro 2) con possibilita` di comunicazione tra i 2 robots della stessa squadra (idea questa, palesemente rubata da P-Robots, ehm...ehm...). Porgo inoltre a tutti voi che siete arrivati sin qui i miei piu` sentiti ringraziamenti e invito tutti gli interessati a mettersi in contatto con me per scambi di idee, consigli, notificazione di eventuali bugs riscontrati, dubbi, etc, etc... Ringrazio i signori (in ordine alfabetico): Furlanetto Leonardo, Martin Andrea, Pastrello Massimo e Pontello Marco. Preziosi collaboratori, critici attenti e consiglieri oltre che amici carissimi ed ideatori di molte caratteristiche di A-Robots. Infine, quale membro fondatore della LED Soft Engineering invito tutte le persone che fossero interessate ad avere una copia dei nostri prodotti (per ora rigorosamente shareware) a mettersi in contatto con uno di noi (vedi LED.TXT); ci impegniamo sin d'ora nel rispondere a tutti con la massima sollecitudine e serieta`. Cordiali saluti Nicola Marangon Via Bassa, 20 Cappella - Peseggia 30037 (VE) - Italy Tel. 041/449177