HOME PAGE
ENGLISH
INDICE
QUATTRO CHIACCHIERE SU P-ROBOTS
ISTRUZIONI CONTROLLO ROBOT
LINKS
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'ambiente 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 compilatore 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 bubba leader, dove
Bubba e Leader 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,
dir,head,tail: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);
var angi,angi2,angf,angf2,vr,vr2,
(*x,y,x2,y2,*)
distang,distrng: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 *)
distrng:=round((vr2-vr-cos(angi2-dir)*speed/2)*vr2/275);
distang:=(angi2-angi)*(1000-vr2) div 335;
spara(angi2+distang,vr2+distrng); (* 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);
var xp,yp:real;
begin
dir:=90+head*90+head*deg;
xp:=loc_x;
yp:=loc_y;
drive(dir,100);
while round(sqrt(sqr(loc_x-xp)+sqr(loc_y-yp)))<150 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
LINKS
Alcuni link utili:
Inizio