HOME PAGE
ENGLISH
INDICE
QUATTRO CHIACCHIERE SU P-ROBOTS
ISTRUZIONI CONTROLLO ROBOT
ASCOLTATE IL COACH
CREATURINE SI FANNO A PEZZI
Al giorno d'oggi in Rete esistono parecchi simulatori di
combattimento per IA di tipo imperativo, qui ci si occupa di P-Robots
poichè lo si reputa il più chiaro e completo fra tutti. Se non avete
idea di cosa possa significare questa parola date un'occhiata al
paragrafo
introduttivo più sotto, altrimenti continuate pure a leggere.
Questo spazio è stato allestito per avere una qualche idea
sull'efficienza di alcuni
robottini
in Pascal che si reputano paricolarmente interessanti, nel caso in
questione quelli creati da me e alcuni amici. Inoltre nel file è
incluso un articolo su come fare geometria in un modo un po'
inusitato - ma divertente.
Allo scopo di non perdere tempo veniamo subito al nocciolo, cioè alle
modalità con cui si è svolto il test. Preso atto che la bontà dei
commenti al codice non ha peso nel giudicare il robot più forte (per
fortuna), basta tenere solamente presente che il sistema di punteggio
assegna 3 punti per la vittoria sotto il 30% di danno, 2 sotto il
70%, 1 per il restante danno e -5 per ogni errore a run-time. Infine
la formula della competizione si espleta in un girone unico in cui i
robots si affronteranno quattro alla volta nelle combinazioni
necessarie ad esaurire un totale di 5000 tornate. Il gestore di
torneo cui ci si è affidati è Club mentre l'interprete P-Robots è
quello nella versione Stout, dove non saranno applicate le modalità
avanzate quali Scudi e Bombe e verrà disattivata la limitazione del
carburante.
La tabella seguente mostra i risultati, dove la colonna RTE
rappresenta il numero di errori in run-time per ogni partecipante.
RTE Punti
Buffy 0 2397
Grue 0 2453
Metallik 0 882
Metallo 0 2104
Phobos 0 1828
Rugrat 0 1283
Inizio
QUATTRO CHIACCHIERE SU P-ROBOTS
Materiale necessario: un computer x86, il
pacchetto
P-Robots
con il relativo eseguibile nella versione corretta nominata Stout
(compilabile sia con il Turbo Pascal che con il Free Pascal), la
vostra fantasia e un po' di pazienza. Prima di tutto bisogna capire
alcune cose importanti a proposito di questo nome, come si può
immaginare dall'acronimo P-Robots è un interprete Pascal ridotto però
soltanto a un sottoinsieme di istruzioni noto come Co-Pascal,
inizialmente sviluppato da Nicklaus Wirth. Ma robots? Significa che
con questo linguaggio ci si prefigge lo scopo di creare delle routine
che controllino e determinino il comportamento di quella entità
virtuale che chiameremo appunto robot, sarà così possibile attraverso
apposite istruzioni in aggiunta al Co-Pascal standard farlo muovere,
fargli acquisire informazioni dall'ambiente che lo circonda e
sparare. Sparare? Sì, una volta costruito (programmato) il nostro
robot verrà calato in una arena dove dovrà battersi con gli altri
suoi simili fino a che non ne resterà uno solo che non sia stato
ridotto in briciole, tutti i robots all'inizio sono dotati dello
stesso equipaggiamento bellico (anche se tra le caratteristiche
avanzate c'è la possibilità di variarlo) e della stessa capacità di
ricevere colpi rimanendo comunque efficiente fino a quello fatale.
Insomma questo non è un gioco interattivo che avviene in tempo reale:
una volta che la battaglia ha avuto inizio non è più possibile
controllare il robot attraverso un joystick o qualunque dispositivo
esterno, esso potrà contare solo sulla "intelligenza artificiale"
impressa nei suoi bit dal suo creatore. Se questa introduzione è
riuscita a destare il vostro entusiasmo sappiate tra l'altro che
questo è un ottimo metodo per affinare la propria abilità di
programmazione, dare man forte al Free Software permettendo la libera
circolazione dei sorgenti dei robots e naturalmente divertirsi
sfidando gli altri giocatori in duelli appassionanti!
Adesso è il momento di lasciare le schermaglie iniziali per
addentrarsi nella comprensione pratica di quanto detto, si era prima
parlato di un'arena in cui i robots vanno a combattere, essa non è
altro che un quadrato di 1000x1000 misure disegnata sullo schermo dal
sistema di gestione in cui i robots sono rappresentati da numeri di
diverso colore, mentre i missili in volo sono rappresentati da un
quadratino il quale poi deflagra in un cerchio d'influenza del
medesimo colore del robot che lo ha sparato. Questa arena ha
naturalmente bisogno di un sistema di riferimento affinché i robots
vi possano svolgere le loro attività di battaglia (cioè
principalmente muoversi, individuare un bersaglio e sparargli,
tramite i rispettivi comandi drive, scan, cannon riportati più
sotto),
in realtà ce ne sono ben due: uno è cartesiano ed è fisso per tutti i
robots dove l'angolo in basso a sinistra ha coordinate (0,0) e quello
in alto a destra (999,999), l'altro è polare (semplicemente come una
bussola in cui un punto viene definito tramite l'angolo e la
distanza) ed è centrato su ogni robot per il quale le direzioni
relative sono poste essere 0 gradi per l'est e aumentando poi in
senso antiorario fino ai 359 gradi. Con queste informazioni è facile
adesso capire gli indicatori dei robots presenti nell'arena riportati
nella parte destra dello schermo, accanto al nome e al numero di
ciascuno ci sono:
E' da notare che la direzione che può assumere l' "occhio" del radar
è indipendente da quella di marcia, cioè propio come in un
carroarmato la torretta è completamente ruotabile in modo da poter
far fuoco su ogni arco di tiro. Adesso per vedere in opera questa
descrizione portatevi nella directory dove avete scompattato P-Robots
e lanciate a linea di comando p-robots leader hidnseek, dove
Leader e Hidnseek sono i nomi di due robots già confezionati. Sono
previste anche alcune opzioni come /Sn per regolare la
velocità di visualizzazione a schermo dove n è un numero da 1 a 10 (5
di default) e /Mn per disputare di seguito n scontri ma in
modalità non visuale.
Ed eccoci al cuore di questa guida per robomeccanici, prendiamo gli
arnesi e vediamo di costruire il nostro robot personale. Esso non è
altro che un file di testo con estensione .pr scritto in
Pascal, a cui si dà per esempio il nome Waldo, che deve rispettare la
seguente struttura di base:
PROCEDURE Waldo;
...
PROCEDURE FaiQuesto;
...
FUNCTION FaiQuello:Tipo;
...
BEGIN
REPEAT
...
UNTIL Dead OR Winner;
END;
Siccome il miglior modo di capire è servirsi di un esempio se ne
presenta uno che ha il vantaggio di essere ben commentato,
relativamente breve e che comunque può costituire una buona base per
ulteriori sviluppi. Per le istruzioni specifiche di controllo del
robot si faccia riferimento al
fondo
della pagina.
File RUGRAT.PR:
procedure Rugrat;
(* Basato su un progetto di Mola *)
var ang1,r1,ang2,r2,ang1a,r1a,ang2a,r2a,
angi,angi2,angf,angf2,vr,vr2,x,y,x2,y2,
distangi,distx,disty,dir,head,tail,count:integer;
procedure angoli;
begin
ang1:=10;
ang2:=350;
ang1a:=100;
ang2a:=260;
if loc_x<500 then head:=1
else head:=-1;
if loc_y<500 then tail:=-1
else tail:=1;
end;
procedure spara(angs,rs:integer);
begin
if rs>40 then cannon(angs,rs);
end;
procedure aggancia(ang,r:integer);
begin
angi:=ang-10; (* setta gli angoli a precisione 5 *)
angf:=ang+10;
repeat (* primo scan *)
vr:=scan(angi,5);
angi:=angi+5;
until (angi=angf) or (vr>0);
(*x:=loc_x+sin(angi)*vr;*)
(*y:=loc_y+cos(angi)*vr;*)
angi2:=angi-6; (* setta gli angoli a precisione 3 *)
angf2:=angi+6;
repeat (* secondo scan *)
vr2:=scan(angi2,3);
angi2:=angi2+3;
until (angi2=angf2) or (vr2>0);
(*x2:=loc_x+sin(angi2)*vr2;*)
(*y2:=loc_y+cos(angi2)*vr2;*)
(* adesso posso sapere di quanto devo anticipare lo *)
(* sparo con le correzioni di fuoco prese da Leader *)
distx:=round((vr2-vr-cos(angi2-dir)*speed/2)*vr2/275);
distangi:=(angi2-angi)*vr2 div 200;
spara(angi2+distangi,vr2+distx); (* qui spara *)
end;
procedure stanavolpe;
begin
(* sistema radar con avanzamento contemporaneo *)
(* su quattro vertici *)
r1a:=scan(ang1a,10);
if r1a>0 then aggancia(ang1a,r1a);
ang1a:=(ang1a+20) mod 360;
r2a:=scan(ang2a,10);
if r2a>0 then aggancia(ang2a,r2a);
ang2a:=(ang2a+340) mod 360;
r1:=scan(ang1,10);
if r1>0 then aggancia(ang1,r1);
ang1:=(ang1+20) mod 360;
r2:=scan(ang2,10);
if r2>0 then aggancia(ang2,r2);
ang2:=(ang2+340) mod 360;
end;
procedure timone(deg:integer);
begin
dir:=90+head*90+head*deg;
drive(dir,100);
for count:=1 to 50 do stanavolpe;
drive(dir,40);
while speed>=50 do stanavolpe;
end;
procedure muovi;
begin
if loc_x<200 then head:=-1;
if loc_x>800 then head:=1;
(* zig *)
timone(tail*60);
(* zag *)
timone(-tail*60);
end;
begin
angoli;
repeat
muovi;
until dead or winner;
end;
Inizio
ISTRUZIONI CONTROLLO ROBOT
Quella di seguito è solo una lista essenziale, per maggior
completezza e per costruire robots veramente efficaci bisogna leggere
da cima a fondo il manuale di P-Robots che purtroppo è in lingua
inglese.
Se vi sono rimasti dei dubbi o semplicemente volete scambiare qualche
idea, proporre una sfida o lavorare a quattro mani su un robot
postate
tranquillamente e cercherò di rispondere il prima possibile.
Ricordate:
"E' possibile essere a conoscenza del piano perfetto, ma ritrovarsi
nell'impossibilità di metterlo in pratica."
"Siediti sulla riva del fiume e aspetta che il tuo nemico sia
trascinato via dalla corrente."
Inizio
ASCOLTATE IL COACH
Il programma Coach è un addestratore automatico per P-Robots, è stato
creato per essere d'aiuto in quelle situazioni in cui abbiamo un
robot il cui funzionamento dipende da un parametro numerico ma non
siamo sicuri di quale sia il valore più efficiente ai fini della
vittoria. Coach s'incarica di risolvere questo problema in maniera
elegante ed empirica: una volta istruito sulla serie di valori che si
vuole testare e sulla batteria di robots con cui confrontarsi, esegue
una serie di scontri (anche questi definibili) scegliendo ogni volta
un valore a caso tra quelli impostati e registrando sconfitte e
vittorie tramite un meccanismo di apprendimento, alla fine emetterà i
risultati sotto forma di punti-vittoria per ogni valore.
Per ottenere in pratica quanto finora detto bisogna per prima cosa
aprire il file .pr del robot in esame e inserire alla destra
dell'assegnamento del parametro che ci interessa la speciale
direttiva $coach$, poi creiamo un file di testo con nome
Coach.dat con le regole che verranno spiegate. Nella prima
riga si metta il numero di scontri che si vuole far combattere al
nostro robot, ovviamente maggiore sarà questo numero maggiore sarà
l'affidabilità dei risultati. Nella seconda riga si metta il nome di
tale robot completo dell'estensione .pr. Nella terza riga si
mettano i nomi dei robots che faranno da avversari. Infine nella
quarta riga andranno messi i valori - che devono essere
obbligatoriamente di tipo intero, separati da spazi - da noi scelti e
che andranno a sostituire $coach$; sebbene poi non è necessario siano
in ordine crescente in molti casi questa è una scelta consigliabile.
I risultati verranno poi stampati in fondo allo stesso file
Coach.dat e al posto di $coach$ verrà sostituito il valore con
il più alto conseguimento di punti-combattimento.
A eccezione di quanto detto finora se il numero di valori è pari a
due non viene compiuta l'analisi descritta, bensì un test statistico
basato sulla distribuzione binomiale. Esso permette di calcolare la
probabilità che in un eguale numero di scontri alternando un valore
all'altro, nell'ipotesi che in entrambe le situazioni il robot abbia
la stessa possibilità di vincere (chiamata ipotesi nulla), la
disparità di vittorie sia solo una fluttuazione casuale. In caso
questa probabilità sia bassa si concluderà che il valore maggiormente
vincente apporta un significativo miglioramento al robot.
Inizio