comparativa de tècniques de control distribuït. aplicació...

Comparativa de tècniques de control distribuït. Aplicació a la plataforma Robot Soccer

TITULACIÓ: Enginyeria Automàtica i Electrònica Industrial

AUTOR: Ricard Nicaforo Reverté.

DIRECTOR: Albert Oller Pujol.

DATA: Juny / 2009.


Índex General

1 Objecte del Projecte ................................................................................1

2 Titular .......................................................................................................2

3 Antecedents ..............................................................................................3

4 Introducció ...............................................................................................4

4.1 El futbol robòtic .................................................................................................4

4.2 El robot mòbil ....................................................................................................4

4.3 Historia del robot mòbil ....................................................................................5

4.4 Tipus de robots ..................................................................................................7

4.5 Classificació dels robots amb rodes ...............................................................10

4.5.1 Configuració diferencial .........................................................................11

4.5.2 Configuració en Tricicle .........................................................................11

4.5.3 Configuració Ackerman .........................................................................12

4.5.4 Rodes Síncrones ......................................................................................12

4.5.5 Tracció omnidireccional .........................................................................13

4.5.6 Pistes de lliscament .................................................................................14

5 Futbol de robots .....................................................................................15

5.1 Intel·ligència artificial (IA) .............................................................................15

5.2 Agents Intel·ligents ..........................................................................................16

5.2.1 Agents reactius ........................................................................................17

5.2.2 Agents deliberatius ..................................................................................18

5.2.3 Agents híbrids ..........................................................................................18

5.3 Sistema multi-agent .........................................................................................18

5.4 Control distribuït .............................................................................................19

6 Simulador Robot Soccer .......................................................................21

6.1 Introducció del Robot Soccer .........................................................................21

6.2 Especificacions del simulador.........................................................................22

6.2.1 Requisits del sistema ...............................................................................22

6.2.2 L’interfície d’usuari ................................................................................23

6.2.3 Terreny de joc i robots ............................................................................23

6.2.4 Menú principal de l’interfície .................................................................25

6.2.5 Menú Strategies.......................................................................................25

6.2.6 Menú Time/Score ....................................................................................26


6.2.7 Menú en joc .............................................................................................27

6.2.8 Menú Replay ...........................................................................................27

6.3 Llenguatge de programació ............................................................................28

6.3.1 Fitxer DLL estàndard .............................................................................29

7 Implementació equips futbol ................................................................33

7.1 Equip dinàmic vs pseudo-dinàmic .................................................................33

7.2 Nivells de programació....................................................................................35

7.3 Estratègia equip dinàmic ................................................................................37

7.4 Estratègia equip pseudo-dinàmic ...................................................................38

7.5 Nivell 4. Accions ...............................................................................................39

7.5.1 Càlcul_angle_relatiu ...............................................................................39

7.5.2 Velocity ....................................................................................................40

7.5.3 Control_posició .......................................................................................40

7.5.3.1 Velocitat de joc ...........................................................................40

7.5.3.2 Control obstacles ........................................................................41

7.5.3.3 Control de velocitat ....................................................................42

7.5.3.4 Control obstrucció robot propi .................................................44

7.5.4 Ir_a_punto ...............................................................................................44

7.5.4.1 Control àrea pròpia....................................................................45

7.6 Nivell 3. Comportaments ................................................................................46

7.6.1 Porter .......................................................................................................46

7.6.1.1 Tapar situat al pal ......................................................................46

7.6.1.2 Allunyar pilota lateral................................................................47

7.6.1.3 Predicció interceptar pilota .......................................................47

7.6.1.4 Reubicar posició .........................................................................48

7.6.1.5 Allunyar pilota moviment giratori ...........................................48

7.6.2 Interceptar_perseguir_pilota ..................................................................49

7.6.2.1 Interceptar pilota .......................................................................49

7.6.2.2 Allunyar pilota moviment giratori ...........................................50

7.6.3 Rematar_perseguir_pilota ......................................................................50

7.6.3.1 Perseguir la pilota ......................................................................52

7.6.3.2 Conduir pilota.............................................................................52

7.6.3.3 Rematar a porteria .....................................................................53

7.6.4 Posicionar_secundari..............................................................................53

7.6.4.1 Situació al punt de defensa ........................................................54


7.6.4.2 Interceptar_perseguir_pilota ....................................................55

7.6.4.3 Control àrea pròpia....................................................................55

7.6.5 Reubicar_robots ......................................................................................55

7.6.5.1 Interceptar oponent ...................................................................58

7.6.5.2 Acompanyament passiu .............................................................58

7.6.5.3 Control de remat ........................................................................60

7.7 Nivell 2. Precondicions ....................................................................................61

7.7.1 PredictBall ...............................................................................................61

7.7.2 PEC (Pelota En Campo) .........................................................................61

7.7.3 MLP (Mejor Llegar Pelota) ....................................................................62

7.7.4 CCP (Contrario Controla Pelota) ...........................................................63

7.8 Nivell 1. Funcions generals .............................................................................64

7.8.1 Assignació_comportaments ....................................................................64

7.8.2 Canvi_coordenades .................................................................................66

7.8.3 Possessió_pilota .......................................................................................67

7.8.4 Temps_costat ...........................................................................................68

7.8.5 Temps_zona .............................................................................................69

8 Resultats .................................................................................................70

8.1 Paràmetres i condicions de joc .......................................................................70

8.2 Recopilatori de resultats .................................................................................71

8.3 Possessió de la pilota........................................................................................75

8.4 Pilota a cada meitat del camp .........................................................................77

8.5 Pilota a cada zona del camp............................................................................79

8.6 Nombre de gols marcats..................................................................................81

8.7 Victòries i empats ............................................................................................82

8.8 Observacions globals .......................................................................................83

9 Conclusions finals ..................................................................................84

10 Bibliografia ............................................................................................85

11 Anexes .....................................................................................................86

11.1 Codi programació Equip Dinàmic .................................................................86

11.2 Codi programació Equip Pseudo-dinàmic ..................................................1211

11.3 Dades resultats Robot Soccer .......................................................................1555


1

1 Objecte del Projecte

L’objectiu principal d’aquest projecte és implementar dues tècniques de control distribuït de dos equips de futbol de robots programades amb C++ i posteriorment, fer competir els dos equips mitjançant la plataforma Robot Soccer analitzant els resultats obtinguts.

Al futbol, ja sigui robòtic com real, ens trobem dins d’un entorn competitiu, és a dir, tots els jugadors competeixen per la seva posició dins el camp i per la possessió de la pilota. Per tant, s’han programat totes les funcions necessàries per tal de poder assignar als jugadors rols de porter, defenses o davanters per tal d’aconseguir un equip competitiu.

Primerament s’han implementat les accions bàsiques per al moviment dels robots com moure’s d’un punt a un altre, girar i avançar. Posteriorment, agrupant aquestes accions s’han aconseguit comportaments de nivell superior com interceptar, parar, allunyar, perseguir i xutar la pilota o posicionar als jugadors. Finalment, a partir dels comportaments i l’estat del joc, s’ha programat l’estratègia on els jugadors es comuniquen entre ells per tal de decidir que fa cadascun per a assolir l’objectiu final que és marcar el màxim nombre de gols i rebre els mínims.

A continuació, per tal de simular aquest projecte s’ha utilitzat un software anomenat “Robot Soccer 1.5a” que està desenvolupat per “The School of Information Technology” de la universitat Griffith University d’Austràlia i està implementat amb el Macromedia Director 8.5 Shockwave Studio. Aquest simulador s’utilitzava a l’assignatura “Robòtica Mòbil” impartida pel Dr. Albert Oller Pujol ja que permet moltes opcions ja sigui a l’hora de la simulació de partits com a l’hora de parar i repetir les jugades.

Per últim, s’analitzen els resultats obtinguts desprès de fer competir els dos equips avaluant els avantatges i desavantatges de cadascuna de les dues tècniques de control distribuït programades.


2

2 Titular

El titular del projecte és el Departament d'Enginyeria Elèctrica, Electrònica i Automàtica (DEEEA) situat a l’avinguda Països Catalans, 26, Sant Pere i Sant Pau, Tarragona. El director del projecte és el Dr. Albert Oller Pujol.


3

3 Antecedents

El present projecte parteix de l’equip de futbol de robots programat per l’autor d’aquest projecte a l’assignatura “Robòtica Mòbil” impartida pel professor Albert Oller i Pujol.

Amb el codi de programació realitzat amb Lingo s’implementava un equip de cinc robots per a jugar a futbol baix la plataforma Robot Soccer 1.5a. En aquest codi es definia un porter, dos defenses i dos davanters amb les seves funcions pertinents per tal de moure’s i posicionar-se en el camp i parar i xutar la pilota.

Amb la programació amb C++ implementada, s’amplien i es milloren les prestacions de cada robot així com l’estratègia global de l’equip on passem de tenir fixat el rol de cada robot a tenir un intercanvi de comportaments i posicions entre ells.


4

4 Introducció

4.1 El futbol robòtic

Segurament, en llegir el títol del projecte, ens poden sorgir algunes preguntes sobre la importància o utilitat del mateix, com ara: ¿Quin interès té el futbol robòtic? ¿Quina aplicació real tenen uns robots futbolistes? ¿Perquè programar robots futbolistes podent programar un microxip amb una altra aplicació? Possiblement, hi hauria un espectre molt gran d’opinions segons quin sigui l’àmbit de cadascú (telecomunicacions, electrònica, dret, química...) però a nivell personal, el motiu és que sempre m’ha il·lusionat qualsevol tema relacionat amb la robòtica i entre ells els robots futbolistes.

A part del paràgraf anterior i entrant a l’àmbit tècnic, el futbol robòtic és un camp de proves interessant que està cobrant major interès any a any. A més del desafiament tecnològic que requereix desenvolupar un sistema complet perceptiu, locomotor, estratègic, que inclogui autolocalització i cooperació entre els seus membres, té l’ingredient extra de ser un entorn competitiu. Un equip de robots s’enfronta a un altre equip amb objectius oposats als seus. Des del punt de vista de la coordinació, és un escenari molt propici per a establir rols entre els membres de cada equip (porter, defensa, davanter…) amb estratègies de posicionament i comportaments específics.

La creació de robots que juguen a futbol involucra el desenvolupament, incorporació i consolidació de molts tipus de tecnologia que cobreix gairebé per complet les àrees d’intel·ligència artificial i robòtica com el disseny d’agents autònoms, fusió sensorial de temps real, disseny de sistemes multi-agent (SMA), adquisició d’estratègies, raonaments i planificació en temps real, mètodes de cooperació i treball en equip, tècniques de predicció, aprenentatge, visió per computadora, presa de decisions estratègica, control de moviments, sistemes de comunicació, etc, etc, etc.

La investigació i desenvolupament de tota aquesta gamma de tecnologies resulta un gran impacte científic, econòmic i social del que moltes altres àrees se’n beneficien directament. Per tant, l’interès de crear i programar robots que juguen a futbol comporta més beneficis que pròpiament els de veure vint-i-dos robots perseguint una pilota (símil de la definició per a qui no li agrada el futbol de “vint-i-dos homes amb pantalons curts corrent darrere una pilota”).

Abans de comentar i explicar en detall l’objectiu del present projecte, farem un petit esment sobre els robots, la seva evolució històrica i la seva classificació per a veure d’on venim i a on anem amb la intenció d’incrementar un mica, si cap, als lectors d’aquest projecte (moltes gràcies) l’interès per la robòtica. 4.2 El robot mòbil

Els robots són màquines en les que s’integren components mecànics, elèctrics, electrònics i de comunicació, i dotats d’un sistema informàtic per al control de temps real, percepció de l’entorn i programació.

No s’ha de confondre el que és un robot mòbil amb els vehicles autònoms utilitzats en les indústries guiats per cables o rails..., amb un entorn fortament estructurat per a la automatització de processos industrials.

Un robot mòbil ha de tenir la suficient intel·ligència com per reaccionar y prendre decisions basant-se en observacions del seu entorn, sense suposar que aquest entorn és perfectament conegut.


5

Un robot mòbil haurà de planificar trajectòries i desprès evitar els obstacles que hi puguin haver en aquestes trajectòries variant així la trajectòria inicial. Un cop feta la planificació de la trajectòria es planifiquen moviments concrets i es controlen. El control d’aquests moviments busca determinar l’angle de direcció tenint en compte la posició i orientació actual respecte a la trajectòria, també és necessari resoldre el problema del control i regulació de velocitats.

4.3 Historia del robot mòbil

La primera vegada que es va utilitzar el terme robot va ser Karel Capek a la seva obra teatral Rossum's Universal Robots. L’obra s’estrenà per primera vegada al 1921 i explica la història de Rossum un inventor que crea robots capaços de servir als humans.

Després del seu perfeccionament els robots es rebel·len contra el seu amo i acaben destruint la vida humana. Aquesta paraula és d’origen txec (robota) i significa “treball de manera forçada”. Històricament, existeixen diversos autòmats molt avançats a la seva època. Exemples com ninots articulats a Egipte, Índia o Xina de segles d’abans de Crist. També el gall rellotge de la catedral d’Estrasburg al 1364, el rellotge i automatismes de la Plaça de San Marcos a Venècia que daten del 1493 o caixes musicals amb ballarines i autòmats diversos.

Figura 4.1. Ninots articulats d’Egipte, Índia o Xina.

Figura 4.2. Robot obra teatral Rossum's Universal Robots.


6

La robòtica tal i com es coneix actualment sorgeix als anys 50 amb l’aparició de la cibernètica però fins l’aparició del microprocessador no s’avança ràpidament. De la dècada dels 50 era Grey Walter que va construir vuit tortugues amb un fototub com a ull capaces de moure’s al voltant d’una llum que transforma en energia elèctrica per emmagatzemar en un acumulador que té dins. Un cop està carregada s’allunya de la llum.

Figura 4.3. Tortugues de Grey Walter.

Al 1969 un equip d’investigació de Standford va crear a Shakey. Era una capsa quadrada, amb una càmera de televisió, amb un telèmetre i una antena de ràdio. El món de Shakey era un micromon de blocs de grandària natural composat de set habitacions connectades entre sí amb vuit portes. A les habitacions hi havia cubs que Shakey podia manipular, apilar i transportar per mitjà d’un teclat.

Als anys 80 amb els ordinadors empotrats, robots amb dos càmeres de visió estereoscòpica feien una reconstrucció 3D del voltant una mica limitada. Reconeixien objectes i navegaven entre ells però eren molt lents i necessitaven molt de temps per recórrer un petit trajecte.

Actualment el concepte de robòtica inclou els sistemes mòbils autònoms, capaços de sortir-se’n per sí mateixos en entorns desconeguts i sense necessitat de supervisió humana.

Per tant, la història de la robòtica es pot dividir en tres generacions:

1) El robot es capaç de repetir una seqüència pre-gravada de moviments, sense realimentació sensorial (control en llaç obert).

2) El robot adquireix informació limitada de l’entorn i actua en conseqüència (control de llaç tancat). Pot localitzar, classificar (mitjançant visió) i detectar esforços per adaptar els seus moviments.

3) El robot utilitza intel·ligència artificial per resoldre el problema plantejat. La seva programació està realitzada en llenguatge d’alt nivell.


7

4.4 Tipus de robots Actualment, existeixen una gran varietat de robots segons la seva funcionalitat i

l’entorn. Per exemple, podem diferenciar en quatre grans grups:

• Terrestres: en molts casos consisteix en dotar d’intel·ligència a un vehicle convencional. Exemples com els vehicles, els robots amb potes o els manipuladors industrials.

Figura 4.4. Robot de Honda.

• Espacials: serveixen per estudiar, fer fotografies i agafar mostres de l’espai exterior i de planetes.

Figura 4.5. Robot espacial.

• Aquàtics: aquests robots són impulsats per hèlix o turbines, altres simulen el moviment d’animals aquàtics amb aletes. Serveixen per explorar, observar i recol·lectar mostres del fons marí.


8

Figura 4.6. Robot aquàtic.

• Aeris: principalment utilitzat en investigacions per aplicacions militars, per exemple en avions d’exploració que tenen com a objectiu principal entrar a les línies enemigues sense ser detectats i realitzar un reconeixement del terreny i de l’enemic.

Figura 4.7. Robot aeri.

Pel que respecta a la temàtica d’aquest projecte, ens centrarem amb els robots mòbils

utilitzats al futbol robòtic. En particular, realitzarem un petit comentari d’uns quants exemples existents a les competicions internacionals.

• Mirosot: robot amb unes dimensions de 7,5 x 7,5 x 7,5 cm. Té dues rodes independents que li permeten girar sobre sí mateix i avançar o retrocedir descrivint arcs.

Figura 4.8. Robot categoria Mirosot.


9

• CMU Hammerhead: les rodes davanteres tenen tracció independent i les trasseres estan muntades sobre el xassís que conté la unitat de procés, les bateries i el sistema de visió.

Figura 4.9. Robot CMU Hammerhead.

• Middle Size League: robots totalment autònoms amb sensors i un sistema individual de visió. Poden mesurar com a màxim 50 x 50 cm amb una altura de 80 cm i un pes de 40 kg.

Figura 4.10. Robots categoria Middle Size League.

• Robot NAIST: posseeix acoplat un PC portátil i està envoltat de sensors táctils.

Figura 4.11. Robot NAIST.


10

• Gossos quadrúpedes Sony: requereixen mecanismes més complexes per a desplaçar-se ja que han de coordinar les quatre potes on una d’elles té 3 graus de llibertat.


• Hurosot: consta de robots humanoides autònoms de dos cames amb una altura màxima de metre i mig i un pes màxim de 30 kg.


4.5 Classificació dels robots amb rodes

Segons com estiguin distribuïts els principals elements que composen un robot la precisió i mesures serà més o menys bona.

En relació a les rodes, existeixen diverses configuracions: diferencial, tricicle, Ackerman, rodes síncrones, tracció omnidireccional i pistes de lliscament.

A continuació s’expliquen totes aquestes configuracions.


11

4.5.1 Configuració diferencial Aquesta configuració és la que tenen els robots Yujin utilitzats en la realització del

present projecte.

La configuració diferencial consta de dos rodes situades en un eix perpendicular a la direcció del robot. Cada una d’elles va dotada d’un motor, de forma que els girs es produeixen donant-los-hi velocitats diferents. Així, si volem girar a la dreta donarem més velocitat al motor que controla la roda esquerra. Per girar a l’esquerra, el motor dret tindrà més velocitat. Però amb dos rodes és impossible mantenir l’horitzontalitat del robot.

Aquest mètode és molt sensible a la relació entre la velocitat de les dues rodes, ja que petits errors en les velocitats de cada roda poden provocar diferents trajectòries.

Figura 4.14. Configuració mode diferencial.

4.5.2 Configuració en Tricicle En aquest cas es disposa de tres rodes situades de manera similar a un tricicle dels

nens. Es tenen dos rodes al darrere que no porten cap motor. La roda davantera és la que té tracció, la que dirigeix al robot.

Un problema associat a aquesta configuració és que el centre de gravetat tendeix a allunyar-se de la roda de tracció en terrenys inclinats quan el robot està pujant. Això produeix una pèrdua de la tracció del robot. Al perdre’s el contacte amb el terra la roda davantera continua girant però el robot no avança.

Figura 4.15. Configuració tricicle.


12

4.5.3 Configuració Ackerman És una configuració utilitzada per l’industria de l’automòbil amb dos rodes amb

tracció del darrere i dos rodes directrius al davant. Aquesta configuració està dissenyada per a que la roda davantera interior en un gir tingui un angle lleugerament més agut que l’exterior i evitar el derrapatge de les rodes.

La relació entre els angles de les rodes directrius ve donada per l’equació d’Ackerman:

(1.1)

On

θi = angle relatiu de la roda interior

θo = angle relatiu de la roda exterior

d = separació lateral entre rodes

l = separació longitudinal entre rodes

La configuració Ackerman constitueix un bon sistema de tracció inclús en terrenys inclinats. No obstant això, la construcció d’un robot amb configuració Ackerman és complicada respecte a les anteriors.

Figura 4.16. Configuració Ackerman.

4.5.4 Rodes Síncrones Aquesta configuració consisteix en tres o més rodes on totes elles van dotades de

tracció i acoblades mecànicament de forma que totes giren a la mateixa direcció o amb la mateixa velocitat. Aquesta configuració necessita una gran sincronització.


13

Figura 4.17. Rodes síncrones.

4.5.5 Tracció omnidireccional Aquesta configuració tracta de dotar al robot amb rodes omnidireccionals. Es basa en

tres rodes directrius i motrius. Així s’aconsegueixen tot tipus de moviments i el robot es pot situar en qualsevol orientació.

Figura 4.18. Roda omnidireccional.

Figura 4.19. Configuració amb tracció Omnidireccional.


14

4.5.6 Pistes de lliscament Aquesta configuració és semblant a un tanc militar. Les rodes són pistes de

lliscament que donen impuls i direcció al robot. S’utilitza en navegació per terrenys irregulars i la seva resistència al desgast és major en front les altres configuracions.

Figura 4.20. Robot anti-bombes.

Figura 4.21. Robot MAARS utilitzat en la guerra d’Afganistan.


15

5 Futbol de robots El futbol de robots pot ser considerat com un joc bastant específic però molt atractiu

al mateix temps, on problemes summament interessants poden ser abordats com objecte d’investigació. Bàsicament, un partit de futbol de robots consisteix en dos equips que competeixen entre sí per a assolir un sol objectiu que és guanyar el partit. Així, cada equip està compost de múltiples agents (Sistemes Multi-Agent) que han de treballar junts per a aconseguir-ho.

Podem veure també que la forma de guanyar un partit pot dividir-se, a la vegada, en dos objectius més específics com marcar la major quantitat de gols i evitar que l’equip contrari marqui. Per a aconseguir-ho, cada agent (jugador) ha d’actuar ràpidament i de forma cooperativa, tenint en compte tant situacions locals com globals, de forma i manera de seguir una estratègia d’equip compartida per tots els agents.

Un dels aspectes més interessants està relacionat amb que els objectius dels dos equips en un partit de futbol són exactament oposats. Això fa que el domini del futbol de robots pot caracteritzar-se com col·laboratiu i advers al mateix temps. És a dir, l’equip contrari es podria veure com un ambient totalment advers amb la capacitat d’obstruir i impedir el compliment de l’objectiu del nostre equip.

Per altra banda, un altre aspecte a considerar és que l’ambient en un partit de futbol canvia contínuament i, per tant, es requereix una ràpida presa de decisions per a poder respondre a aquests canvis.

Per tot això, el futbol de robots es considera una bona plataforma d’investigació i recerca per a poder afrontar i solucionar problemes robòtics amb característiques similars al món industrial.

A continuació passarem a comentar els aspectes més teòrics, anomenats en els anteriors paràgrafs, pel que respecta al futbol robòtic.

5.1 Intel·ligència artificial (IA) Després de la fundació de la federació internacional de robots futbolistes anomenada

FIRA (Federation of International Robot-soccer Association) s’ha celebrat anualment un torneig internacional baix el nom de “FIRA Robot World Cup”.

La “FIRA Robot World Cup” és una iniciativa internacional per a promoure els avanços en Intel·ligència Artificial i Robòtica tot enfocat sobre un problema estàndard pel que fa a la investigació com és el futbol robòtic. No només té a veure amb la investigació i desenvolupament del “hardware” dels robots, sinó que també té a veure amb el “software” de la seva intel·ligència.

Per a assolir el seu objectiu, que és aconseguir que un grup de robots sigui capaç de jugar al futbol de forma autònoma, intel·ligent i coordinada, es requereix desenvolupar i integrar una àmplia gamma de tècniques i algoritmes d’Intel·ligència Artificial i Sistemes Intel·ligents.

El problema estàndard de la “FIRA Robot World Cup” és summament interessant i complexe a la vegada degut a que hi ha múltiples robots movent-se a gran velocitat en un ambient dinàmic i incert. Algunes tècniques d’Intel·ligència Artificial utilitzades són per exemple el disseny d’agents autònoms, algoritmes de coordinació i col·laboració multi-agent, de raonament i aprenentatge automàtic en temps real, etc.


16

La Intel·ligència Artificial (IA) és un subcamp de la Informàtica dedicat a la construcció d’agents que exhibeixen aspectes de comportament intel·ligents, és a dir, que puguin “pensar”. La idea de construir una màquina que pugui executar tasques interpretades com que requereixen d’intel·ligència humana és atractiu.

Altres definicions sobre Intel·ligència Artificial que puguin aclarir aquest terme són: • Disciplina científico-tècnica que tracta de crear sistemes artificials capaços de

comportaments que, de ser realitzats per éssers humans, es diria que requereixen d’intel·ligència.

• La Intel·ligència Artificial és l’estudi de com fer que els ordenadors facin coses que avui en dia són realitzades millor pels éssers humans. (Rich y Knight)

• Estudi dels mecanismes de la intel·ligència i les tecnologies que el sustenten. (Newell)

• Intent de reproduir o modelar la manera en que les persones identifiquen, estructuren i resolen problemes difícils. (Pople)

Però des dels seus inicis fins l’actualitat, la Intel·ligència Artificial ha hagut de fer front a una sèrie de problemes:

• Els computadors no tenen autoconsciència (emocions, sociabilitat, etc.).

• Un computador només pot fer allò per al que està programat.

• Les màquines no poden pensar realment.

5.2 Agents Intel·ligents Un agent pot definir-se com una entitat, semi o completament autònoma, que situat

en algun entorn, actua racionalment d’acord a les seves percepcions de l’exterior i l’estat del seu coneixement. És a dir, l’agent rep entrades sensorials d’un entorn on està situat i realitza accions que canvien l’esmentat entorn.

Els agents es poden caracteritzar pels següents punts:

• Autonomia: els agents operen sense la intervenció directa dels éssers humans i tenen cert tipus de control sobre les seves accions i estats interns.

• Reactiu: els agents perceben el seu ambient (el qual pot ser el món físic, una interfície gràfica, Internet,...) i respon en un temps raonable per a canviar el que succeeix en ell.

• Pro-actiu: els agents no han d’actuar simplement en resposta al seu entorn, sinó que han de ser capaços d’exhibir comportaments dirigits a aconseguir objectius que siguin oportuns i prendre la iniciativa quan convingui.

• Social: els agents han de ser capaços d’interactuar, quan convingui, amb altres agents artificials o humans per a completar el seu propi procés de resolució del problema i ajudar a altres amb les seves activitats.

• Continuïtat temporal: es considera un agent un procés sense fi, executant-se contínuament i desenvolupant la seva funció.


17

• Racionalitat: l’agent sempre realitza “el correcte” a partir de les dades que percep de l’entorn.

• Adaptabilitat: està relacionat amb l’aprenentatge que un agent és capaç de realitzar i si pot canviar el seu comportament basant-se en aquest aprenentatge.

• Mobilitat: capacitat d’un agent per traslladar-se a través d’una xarxa telemàtica.

• Veracitat: donar per entès que un agent no comunica informació falsa a propòsit.

• Benevolència: donar per entès que un agent està disposat a ajudar a altres agents si això no entra en conflicte amb els seus propis objectius.

No existeix un consens sobre el grau d’importància de cadascuna d’aquestes

propietats per a un agent. No obstant això, es pot afirmar que aquestes propietats són les que distingeixen als agents de simples programes.

Una vegada comentades les característiques que ha de tenir un agent per a ser considerat com a tal, els classificarem en tres grans grups:

• Agents reactius

• Agents deliberatius

• Agents híbrids

5.2.1 Agents reactius Es basen en el model percepció-acció. Es limiten a percebre l’ambient i en base a

l’estat del mateix defineixen una acció. En ambients que són totalment observables poden adaptar-se correctament però estan exposats a punts morts en ambients parcialment observables.

Els millors resultats s’obtenen en ambients estables que no pateixen modificacions considerables sobtades causades per la velocitat que imprimeix la presa de decisions. Pel contrari, els comportaments aconseguits solen ser simples i, al no tenir memòria ni capacitat de retenir estats anteriors, són incapaços d’adaptar les seves decisions als canvis.

Habitualment són construïts en base a màquines d’estat o arbres de decisió, és a dir, totes les decisions han d’estar predefinides inicialment incloent-hi la coordinació entre els agents. Aquestes restriccions afecten sobretot als sistemes multi-agent on és important que cadascú pugui anticipar les conseqüències dels seus actes i les dels altres i, per tant, s’obtenen mals resultats pel que fa a la cooperació. El comportament global observat en la majoria dels casos sembla més un cúmul d’agents perseguint objectius individuals que no pas un equip amb objectius globals.

Per altra banda, també existeixen agents reactius basats en un model de l’ambient que els permet conèixer els diferents estats en els quals es poden trobar en cada moment. En base a aquests estats, i les regles d’acció definides per a cadascun d’ells, els agents prenen les decisions i actuen.

Encara que els agents basats en aquest model poden ser eficients al moment de prendre decisions, la incapacitat de planificació a llarg termini poden tornar-los poc útils en sistemes on es requereix que cada agent sigui conscient de les pròpies metes.


18

5.2.2 Agents deliberatius Els sistemes deliberatius, a diferencia dels reactius, basen les seves decisions en el

model condició-cognició-acció. Aquest cicle agrega una etapa on, clàssicament, es realitza reconeixement de la informació de l’entorn i planificació. Solen considerar informació del passat recent a més de la que reben a través dels sensors.

Poden considerar la predicció per a anticipar l’efecte d’accions passades i també l’ús de motors lògics que permeten millorar les regles i proposicions que s’utilitzen per a modelar els diferents escenaris.

D’entre els avantatges que presenten els sistemes deliberatius sobre els sistemes reactius és el poder d’expressivitat, entenent com a tal, la capacitat de modelar aspectes del món, el que els sistemes reactius no tenen. Una debilitat important d’aquest punt de vista és el temps de còmput que pot requerir una única decisió.

Depenent de la quantitat d’aspectes del món tinguts en compte i la complexitat del anàlisi, una sola decisió podria durar des d’una fracció de segon fins a minuts, essent aquest punt de vista prohibitiu en alguns entorns com el futbol de robots.

5.2.3 Agents híbrids Els enfocaments reactius i deliberatius mostren fortaleses i debilitats. Aquest

enfocament intenta ser una solució que engloba el millor dels dos minimitzant les seves debilitats. La proposta de l’aproximació híbrida és prendre l’expressivitat de l’aproximació deliberativa i el temps de processament de l’aproximació reactiva, intentant prendre decisions intel·ligents garantint el temps de resposta. Per això, els sistemes híbrids es componen de dos components de presa de decisions: un de deliberatiu i un altre reactiu.

Aquests components s’executen en paral·lel tot el temps. Normalment, s’utilitzen les decisions adoptades pel component deliberatiu però si la presa de decisió s’allarga, s’utilitza la component reactiva. La decisió reactiva no és tan bona com la deliberativa però és millor que no fer res.

5.3 Sistema multi-agent Del apartat anterior sabem que un agent pot ser vist com una entitat ubicada en un

cert entorn amb la capacitat de percebre i actuar sobre ell per a assolir els seus objectius. Però quan en el mateix entorn es troben varis agents formant un sistema, aquests necessiten comunicar-se i coordinar-se entre sí. En aquest cas, ens trobem en presencia de Sistemes Multi-agent (SMA).

Concretament, podem definir un Sistema Multi-agent com una xarxa d’agents amb un objectiu particular treballant conjuntament per a resoldre, més enllà de les capacitats o del coneixement de cadascun, problemes més complexes.

Tècnicament, els Sistemes Multi-agent són un camp de la Intel·ligència Artificial (IA) amb l’ànim de proporcionar principis per a la construcció de sistemes complexes amb múltiples agents i mecanismes per coordinar comportaments d’agents independents.


19

Encara que la major dificultat d’aquests sistemes se centra en la resolució de la comunicació i coordinació entre els agents que composen el sistema, els motius per a l’elecció d’un SMA pel que respecta al futbol de robots són els següents:

• Els sistemes estan geogràficament distribuïts. És a dir, els agents tenen diferents zona d’influència encara que aquestes puguin coincidir en alguns casos.

• Els sistemes tenen molts components. Per tant, és necessària una coordinació i una comunicació entre ells.

• Els sistemes són fortament heterogenis. Els agents tenen comportaments diferents entre ells (porter, defensa, davanter,...) i necessiten d’una cooperació per a assolir l’objectiu final.

A continuació comentarem les característiques i l’elecció del control per a poder

coordinar els robots entre sí fins a assolir l’objectiu comú.

5.4 Control distribuït La decisió més fonamental que es pren al definir l’arquitectura d’un grup és si el

sistema de control és centralitzat o distribuït. Les arquitectures centralitzades estan caracteritzades per un únic agent de control mentre que les arquitectures distribuïdes manquen d’aquest agent. Concretament, en arquitectures distribuïdes tots els agents són iguals en termes de control.

A continuació es mostren les principals característiques de cada tipus de control:

• Centralitzat

o Permet obtenir una solució òptima.

o Requereix comunicació global.

o Requereix molta informació.

o Es pot crear un coll d’ampolla.

o És molt lent.

o No és robust (punt únic d’error).

• Distribuït

o Cada robot decideix que fer pel seu compte.

o No es necessita acumular informació.

o Es minimitza la comunicació.

o Els robots o subgrups poden fallar.

o El grup es pot redimensionar dinàmicament.

o Els robots es poden adaptar (comportaments).


20

La categoria Middle League MiroSot o Simurosot a primera vista pot pertànyer a un control bàsicament centralitzat. La raó principal és l’existència d’una entitat de processament clarament privilegiada com l’ordinador que rep la imatge de vídeo i emet les comandes als robots.

No obstant això, podem considerar que ens trobem dins d’un control distribuït. Més enllà de la distribució física dels elements del sistema, tots els robots són iguals pel que fa al control. A més, en cas d’error d’algun robot no tenim una fallada del sistema i aquests poden adquirir diferents comportaments comunicant-se amb els altres i decidint que fer entre ells.

En el següents capítols s’explica amb detall la programació de les tècniques de control distribuït per a controlar i coordinar a la plataforma Robot Soccer un Sistema Multi-agent d’agents intel·ligents, o dit d’una altra forma, un equip Simurosot de 5 jugadors.


21

6 Simulador Robot Soccer 6.1 Introducció del Robot Soccer

Robot Soccer va ser desenvolupat pel professor Jong-Hwan Kim del KAIST (Korean Institute of Technology) l’octubre de 1995 per aprendre i aplicar intel·ligència artificial, sensors, control i també software i hardware. Des de llavors i fins ara ha crescut contínuament la participació de joves científics.

El primer torneig Robot Soccer World Cup va tenir lloc a KAIST el novembre de 1996 i el segon es va jugar al mateix lloc el juny de 1997. Només tres anys després es va fundar una federació internacional de robots futbolistes composta por 34 països anomenada FIRA (Federation of International Robot-soccer Association). Després de la inauguració oficial de la FIRA, tots els partits internacionals s’han anomenat “FIRA Robot World Cup”. La meta final d’aquesta federació seria que a mitjans del segle XXI un equips de robots humanoides completament autònoms guanyin, d’acord amb les regles oficials de la FIFA, al guanyador de la copa del món de futbol més recent.

Ja que diàriament està creixent l’entusiasme per la competició “FIRA Robot World Cup”, es va desenvolupar “The Robot Soccer Simulator™” amb el propòsit de simular els moviments físics dels robots Yujin a una plataforma de simulació. D’aquesta manera, es va expandir internacionalment la competició per a la majoria de gent ja que entre les utilitats de “The Robot Soccer Simulator™” està inclòs el desenvolupament d’estratègies que podran ser utilitzades posteriorment pels robots Yujin a la competició “FIRA Robot World Cup”.

Figura 6.1. Robot Yujin.

Hi ha dos plataformes de Robot Soccer, en una hi juguen onze jugadors contra onze (Large League SimuroSot) i en l’altra cinc jugadors contra cinc (Middle League SimuroSot). El simulador utilitzat en aquest projecte és un software anomenat “Robot Soccer 1.5a” que està desenvolupat per “The School of Information Technology” de la universitat Griffith University d’Austràlia i està implementat amb el Macromedia Director 8.5 Shockwave Studio. Es va realitzar aquesta plataforma per la FIRA Simurosot Game, que és un torneig de simulació de robots futbolistes on cada equip realitza la seva estratègia.

Concretament, s’ha escollit el simulador de cinc contra cinc (Middle League SimuroSot) ja que el “Robot Soccer 1.5a” és el software que s’utilitzava a l’assignatura “Robòtica Mòbil” impartida pel Dr. Albert Oller Pujol i també perquè permet moltes opcions ja sigui a l’hora de la simulació de partits com a l’hora de parar i repetir les jugades.


22

Figura 6.2. Simulador Robot Soccer 1.5a..

A continuació es comentaran les característiques d’aquest software on la idea és que pugui ser usat com a manual bàsic.

6.2 Especificacions del simulador

6.2.1 Requisits del sistema Els requisits mínims del sistema que es recomana que s’utilitzi el simulador de Robot

Soccer en ordinadors són els següents:

• Pentium III 600 MHz

• 256 megabytes de memòria RAM

• Tarjeta 3d Graphics accelerator amb 32 megabytes de RAM

• CD-ROM amb velocitat de 24x

• Resolució de pantalla de 800 x 600 píxels

• Tarja de so de 16 bit

• Sistema operatiu: Microsoft Windows XP

• DirectX 8.0

• 10 megabytes lliures de disc dur


23

6.2.2 L’interfície d’usuari Quan s’obre el programa es presenta la següent pantalla on es mostra el terreny de

joc i a la dreta de la pantalla hi ha els menús i la informació de la plataforma.

Figura 6.3. Vista general del simulador Robot Soccer 1.5a..

L’usuari pot seleccionar els robots, col·locar-los en la posició desitjada i rotar-los. Per rotar-los es necessita seleccionar el robot i llavors polsar:

Tecla “←” per rotar el robot en sentit anti-horari.

Tecla “→” per rotar el robot en sentit horari.

L’usuari pot polsar el menú per desplegar les opcions incloses. Sota el menú està situat el comptador de temps i el marcador de gols.

6.2.3 Terreny de joc i robots El terreny de joc de la plataforma està basat en un de real de mida 220 cm x 180 cm.,

Com a curiositat, a l’hora de programar s’ha de tenir en compte que el valor de les variables donades pel simulador són en polzades.

Per tant, si es vol realitzar un canvi de polzades a centímetres només haurem de tenir compte la següent relació:

1 polzada (inch) = 2,54 cm (1.2)


24

Figura 6.4. Mesures del terreny de joc real en cm.

Pel que fa als robots, cada equip està format per cinc jugadors en forma de cub amb

unes dimensions reals de 7,5 × 7,5 × 7,5 cm amb una petita ranura a la part frontal per a dominar millor la pilota. Una altra característica és que, per a permetre la identificació de les posicions i orientacions dels robots dins al terreny de joc, cadascun posseeix a la part superior un adhesiu de 3,5 x 3,5 cm amb el color corresponent de l’equip (groc o blau) i un altre color per a diferenciar-se dels altres.

Els robots Yujin reals tenen dues rodes i són robots amb tracció diferencial. Per a cada roda es determina una velocitat on la diferencia entre les dues, permetrà modificar la posició i la orientació. Segons si la diferencia de velocitat és positiva o negativa, el robot girarà en sentit horari o en sentit anti-horari.

Pel que respecta al simulador Robot Soccer 1.5a, per defecte els jugadors es localitzen a les posicions de la següent figura, on els jugadors Y (yellow) són els 5 jugadors de l’equip groc i els jugadors B (blue) són els 5 jugadors de l’equip blau. També podem observar la diferencia de colors per a identificar individualment cada robot.

Figura 6.5. Distribució i color dels robots dels dos equips al terreny de joc.


25

6.2.4 Menú principal de l’interfície En aquest apartat és comentaran els diferents botons del menú principal:

• Strategies: l’usuari ha de polsar aquí per carregar les estratègies de cada equip, segons sigui l’equip Blue o el Yellow.

• Estats possibles del joc: aquests botons són per a l’àrbitre per marcar una falta a un equip determinat i declara qui tindrà la possessió de la bola. Una vegada polsat el missatge serà mostrat a la pantalla sota del terreny de joc.

• Start: Per començar el joc.

• Time: Mostra el temps jugat.

• Score: la puntuació actual.

• Time/Score: aquest botó porta a l’usuari a poder modificar el temps i la puntuació

• New Game: reinicia tot i prepara per a un nou joc.

• Help: l’usuari pot prémer aquest botó per a accedir a una versió electrònica del manual ja sigui al inici o mentre s’està jugant.

Figura 6.6. Menú principal del simulador Robot Soccer 1.5a.

6.2.5 Menú Strategies

Aquestes estratègies estan col·locades a la carpeta “c:\Strategy” situada al disc dur. Dins d’aquesta carpeta hi ha dos carpetes amb els noms dels dos equips: yellow i blue. S’ha d’assegurar que l’estratègia que volem que realitzi l’equip està situada dins la carpeta corresponent.


26

• Se selecciona el llenguatge de programació utilitzat prement Lingo/C++.

• S’introdueix l’estratègia teclejant el nom de l’arxiu que conté l’estratègia per l’equip blau o l’equip groc. L’estratègia ha d’estar situada per l’equip blau a la carpeta “c:\strategy\blue” i per l’equip groc a “c:\strategy\yellow”.

• Send: polsant aquest botó es carreguen les estratègies al simulador.

• Open Viewer: s’obre el visor que permet veure les coordenades dels jugadors i la pilota mentre s’està jugant. També permet veure les mesures del terreny de joc.

Figura 6.7. Menú Strategies del simulador Robot Soccer 1.5a.

6.2.6 Menú Time/Score Si el temps o el nombre de gols necessita ser modificat l’àrbitre pot utilitzar aquesta

interfície per fer ajustaments.

• Time: l’àrbitre pot ajustar el temps amb qualsevol d’aquests botons, pot afegir o treure minuts o segons.

• Score: es pot alterar el marcador. L’àrbitre ha de polsar damunt del nombre de gols que es vol modificar i teclejar el valor desitjat.

• Time/Score: si es polsa una altra vegada es torna al menú principal amb els canvis que s’han realitzat.

Figura 6.8. Menú Time/Score del simulador Robot Soccer 1.5a.


27

6.2.7 Menú en joc Aquest menú s’observa quan s’ha iniciat el joc i mentre s’està jugant es pot polsar:

• Replay: tornar a veure la jugada.

• Pause: pausar el joc.

• Stop: permet parar el joc i tornar al menú per prendre decisions.

Figura 6.9. Menú en joc del simulador Robot Soccer 1.5a.

6.2.8 Menú Replay Quan s’està veient la repetició de la jugada a la dreta de la pantalla apareix el menú

següent:

Figura 6.10. Elecció de vistes al menú Replay del simulador Robot Soccer 1.5a.


28

• A: visió des de la pilota i la segueix durant tot el seu moviment.

• B: es veu tot el camp tal i com es veu mentre es juga. És la visió que ofereix per defecte.

• C: es veu només la porteria de l’equip blau.

• D: es veu només la porteria de l’equip groc.

• E: es veu tot el terreny de joc des de la porteria de l’equip blau.

• F: es veu tot el terreny de joc des de la porteria de l’equip groc.

• G: és una vista amb l’equip blau a la dreta i el groc a l’esquerra.

• H: és una vista amb l’equip groc a la dreta i el blau a l’esquerra.

Per altra banda, també apareix el següent menú que ens permet avançar o retrocedir

la jugada a l’hora de la repetició:

Figura 6.11. Menú Replay del simulador Robot Soccer 1.5a.

• <<►: rebobina al principi de la jugada i la torna a mostrar.

• <<\►: rebobina els últims 300 fotogrames i els tornar a mostrar.

• NORM: mostra la repetició a velocitat normal.

• SLOW: mostra la repetició lentament

• STOP FRAME: es para en un fotograma.

• ◄║: avança un fotograma.

• ║►: rebobina un fotograma

• EXIT REPLAY: surt de la repetició actualitzant el gol al marcador.

• NO GOAL: surt de la repetició sense pujar el gol al marcador.

6.3 Llenguatge de programació

El “Robot Soccer 1.5a” accepta la programació d’estratègies ja sigui amb llenguatge C++ o en Lingo. El llenguatge C++ necessita d’un compilador en canvi amb Lingo no. No obstant això, s’ha escollit programar amb llenguatge C++ amb el programa “Microsoft Visual C++ 6.0” ja que permet l’aplicació de més funcions i llibreries que el Lingo no accepta. A més, amb el compilador podrem detectar els possibles errors de programació que per altra banda, amb el Lingo és molt difícil.

Com hem comentat anteriorment, podrem seleccionar el llenguatge de programació utilitzat prement el botó Lingo/C++ del menú Strategies del simulador.


29

Figura 6.12. Llenguatges de programació de Robot Soccer 1.5a.

A continuació descriurem l’interfície C++ definida per a la comunicació amb el simulador que es correspon d’un fitxer DLL que conté, a part de la programació de l’estratègia, l’estructura de funcions bàsica per a poder programar els comportaments dels robots de l’equip.

6.3.1 Fitxer DLL estàndard En aquest apartat és descriurà el fitxer estàndard inicial compost per un fitxer on

cada usuari programarà la seva estratègia (*.cpp) i una llibreria (*.h).

En posteriors apartats es comenta la programació detallada de l’estratègia ja que inicialment no està programada. Per aquest motiu, ens centrarem en el fitxer llibreria anomenat Strategy.h que conté les diferents variables i les funcions bàsiques per a poder realitzar la programació de l’estratègia de l’equip.

Concretament, la llibreria consta de tres funcions per a poder interactuar entre l’interfície C++ i el simulador Robot Soccer.

Funcions de Strategy.h

void Create(Environment *)

void Destroy(Environment *)

void Strategy(Environment *)

Taula 6.1. Funcions existents dins el fitxer llibreria Strategy.h.

La funció Create(…) s’invoca només una vegada, al moment en que es carga el fitxer DLL de l’equip, és a dir, serveix per a inicialitzar certes variables dins de l’estratègia, mentre que la funció Destroy(…) es crida amb la finalitat d’alliberar recursos (memòria, fitxers, etc.) utilitzats durant el joc.

Finalment, la més important és la funció Strategy(…), la qual és invocada pel simulador a cada pas de simulació. D’aquesta manera, a partir d’aquesta funció, s’intercanviaran les dades entre el simulador i l’estratègia mitjançant un punter a la estructura Environment (entorn).

En aquesta estructura, el simulador actualitzarà entre altres variables, les posicions i orientacions actuals de tots els robots, així com també la posició actual de la pilota. Per la seva part, l’estratègia haurà d’actualitzar a cada pas de simulació, les velocitats de la roda esquerra i la dreta dels diferents robots on aquesta informació serà enviada també a través del punter Environment.


30

Concretament, les estructures de dades definides a la llibreria Strategy.h que serviran de guia per a poder realitzar la programació de l’estratègia de l’equip són les següents:

Estructura Descripció

typedef struct { double x, y, z; } Vector3D;

Estructura auxiliar que representa un vector a l’espai tridimensional. Actualment, la component z de les variables d’aquest tipus no s’utilitzen mai.

typedef struct { long left, right, top, bottom; } Bounds;

Estructura auxiliar que representa els límits de la superfície rectangular de joc.

typedef struct { Vector3D pos; double rotation; double velocityLeft, velocityRight; } Robot;

Estructura auxiliar que representa un robot propi. Els camps pos i rotation s’omplen pel simulador a cada pas de simulació de la funció Strategy( ). En canvi, els altres dos camps de les velocitats de les rodes, seran emplenats obligatòriament per l’estratègia de l’equip realitzada per l’usuari.

typedef struct { Vector3D pos; double rotation; } OpponentRobot;

Estructura auxiliar que representa un robot contrari. A diferencia de l’estructura Robot, aquesta conté només informació passada del simulador cap a l’estratègia.

typedef struct { Vector3D pos; } Ball;

Estructura auxiliar que representa la pilota. La única informació proporcionada per a la pilota és la seva posició.

typedef struct { Robot home[PLAYERS_PER_SIDE]; OpponentRobot opponent[PLAYERS_PER_SIDE]; Ball currentBall, lastBall, predictedBall; Bounds fieldBounds, goalBounds; long gameState; long whosBall; void *userData; } Environment;

Estructura principal de la interfície. En ella, s’emmagatzemen totes les dades intercanviades entre el simulador i l’estratègia (i viceversa). El camp predictedBall pot ser definit per l’usuari per a predir la posició de la pilota. Actualment, els camps fieldBounds i goalBounds no s’utilitzen, és a dir, el simulador no actualitza aquests camps. El camp userData està pensat per a emmagatzemar informació, al llarg del joc, definida per l’usuari.

Taula 6.2. Estructures de dades definides dins el fitxer llibreria Strategy.h.

Al fitxer Strategy.h es defineixen també certes constants que seran d’utilitat ja que indiquen els estats possibles del joc (que seran actualitzades al camp gameState del Environment), i la informació de qui té la possessió de la pilota després del servei inicial (aquesta informació es passa a través del camp whosBall del Environment).


31

Constant Valor Descripció

FREE_BALL 1 Disputa pilota

PLACE_KICK 2 Servei mig camp

PENALTY_KICK 3 Tir de penal

FREE_KICK 4 Tir de falta

GOAL_KICK 5 Servei de porteria

Taula 6.3. Constants que defineixen els estats de joc per al camp gameState del Environment.

És important comentar que no es defineix cap constant quan el valor del camp gameState és zero. Això passa quan al simulador no s’actualitza cap dels estats anteriors.

Constant Valor Descripció

ANYONES_BALL 0 Ningú té la pilota

BLUE_KICK 1 L’equip blau té la pilota

YELLOW_KICK 2 L’equip groc té la pilota

Taula 6.4. Constants que defineixen la possessió de la pilota per al camp whosBall del Environment.

Per altra banda, es defineixen també constants que indiquen els límits del camp i els límits de les dues porteries. Com a comentari, dir que tant les unitats del camp com les de les posicions dels robots i la pilota estan en polzades.

Figura 6.13. Constants relacionades amb els límits del camp i les dues porteries.


32

Constant Valor (polzades) Descripció

FTOP 77,2392 Coordenada y superior del camp

FBOT 6,3730 Coordenada y inferior del camp

FLEFTX 6,8118 Coordenada x del límit de l’esquerra del camp

FRIGHTX 93,4259 Coordenada x del límit de la dreta del camp

GTOPY 49,6801 Coordenada y superior de les porteries

GBOTY 33,9320 Coordenada y inferior de les porteries

GLEFT 2,8748 Coordenada x dins la porteria de l’esquerra

GRIGHT 97,3632 Coordenada x dins la porteria de la dreta

Taula 6.5. Constants que defineixen els límits del camp i de les porteries.

Finalment, cal comentar que els angles dels camps “rotation” de les estructures Robot

i OpponentRobot estan en graus i pertanyen a l’interval [-180, 180]. Així, un robot tindrà un angle de 0º o 180º si es troba paral.lel a l’eix horitzontal i de 90º o -90º si es troba paral.lel a l’eix vertical. La següent figura mostra l’assignació dels graus que realitza Robot Soccer.

Figura 6.14. Assignació dels graus per a la orientació dels robots.


33

7 Implementació equips futbol

L’objectiu d’aquest projecte és fer competir dos equips implementant dues estratègies de control distribuït i comentar els resultats obtinguts. La diferencia entre aquest projecte i altres sobre equips programats sota la plataforma Robot Soccer radica en les següents premisses:

• Tots els robots de camp són iguals, és a dir, no hi ha preassignació sobre quin robot de camp fa de defensa o davanter.

• Els robots poden intercanviar-se les posicions segons les condicions de joc. Es pot observar una certa intel·ligència en el comportament dels equips ja que els robots no van tots cap a la pilota sinó que, com al futbol real, existeix una tàctica.

• Es realitza un canvi de coordenades i un canvi d’escala de forma que amb el mateix programa podem jugar indistintament amb l’equip groc o amb el blau. En altres projectes es programa només des del punt de vista d’un dels dos.

• Es pot modificar la velocitat dels robots sense necessitat de compilar i parar el partit. La velocitat s’indica en un fitxer de text extern.

• Es poden bolcar tots els valors de les variables que es desitgin en un fitxer de text per a poder analitzar i realitzar un control estadístic dels resultats.

• Com que els robots són cubs, aquests poden anar indistintament en els dos sentits (velocitat positiva o velocitat negativa). D’aquesta forma, els robots són més ràpids i no perden, com altres, temps per a girar.

En els següents apartats, es comenten i s’expliquen en detall les característiques de programació i funcionament dels dos equips de robots.

7.1 Equip dinàmic vs pseudo-dinàmic

Com que hem de fer competir dos equips amb estratègies de control distribuït, a continuació comentarem les característiques de cadascun i en conseqüència, les seves diferencies.

EQUIP DINÀMIC

Figura 7.1. Estratègia de l’equip dinàmic.


34

La idea d’aquest equip és que tots els robots són iguals i es podran moure per tot el camp intercanviant-se les posicions excepte el porter que és fix, tal com es pot veure a la figura anterior. D’aquí el nom de dinàmic.

La tàctica és la següent:

1- El millor robot anirà a per la pilota (Robot 1).

2- Assignarem un robot per a la defensa situat entre la pilota i la seva porteria (Robot 2).

3- Dels altres dos robots que queden, el que està més prop del robot que duu la pilota realitzarà un acompanyament passiu per a poder recuperar la pilota en cas de pèrdua (Robot 3).

4- L’últim robot és col·locarà com a davanter a una posició més avançada respecte a la pilota. D’aquesta manera, sempre tindrem un robot que pugi rematar a porteria o agafar la pilota a una zona avançada (Robot 4).

EQUIP PSEUDO-DINÀMIC

Figura 7.2. Estratègia de l’equip pseudo-dinàmic.

La diferencia respecte a l’equip dinàmic és que ara hi ha dos robots fixats a la defensa i altres dos fixats a la davantera. És a dir, ni els defenses ni els davanters poden passar del mig camp. El nom de pseudo-dinàmic és que els defenses i els davanters poden intercanviar-se les posicions però només estan limitats a mig camp. D’aquí el nom de pseudo-dinàmic. La tàctica és la següent:

1- Si la pilota està al mig camp propi, el millor dels dos defenses anirà a per la pilota (Robot 1) i l’altre es col·locarà entre la pilota i la seva porteria (Robot 2). Els dos davanters (Robot 3 i 4) es col·locaran al mig camp interceptant els contraris que vagin a per la pilota i esperaran a que aquesta passi del mig camp.

2- Si la pilota està al mig camp contrari, el millor dels dos davanters anirà a per la pilota (Robot 1) i l’altre farà un acompanyament passiu o es situarà en zona de remat si la pilota està en zona d’atac (Robot 2). D’altra banda, un dels dos defenses es col·locarà entre la pilota i la seva porteria (Robot 3) i l’altre esperarà la pilota situat al mig camp (Robot 4).


35

7.2 Nivells de programació

Per a poder explicar i que s’entengui amb més facilitat la programació realitzada, s’han dividit les funcions implementades en quatre nivells diferents. Els diferents nivells considerats són els següents:

1. Funcions generals: és on es troba EL COR DE CADA EQUIP. Agrupa tots els nivells anteriors per a poder tenir un conjunt de robots jugant a futbol amb una estratègia definida. A part, també hi ha funcions generals per a poder realitzar el control estadístic posterior.

2. Precondicions: són funcions que ens ajuden a saber la situació del joc i d’aquesta manera actuarem d’una forma o d’una altra segons convingui.

3. Comportaments: són funcions que ens determinen quin rol ha d’adquirir cada robot, és a dir, si el robot a d’atacar, defensar, porter, acompanyar, ....

4. Accions: són funcions per a que el robot realitzi moviments bàsics com calcular angles, anar a un punt, velocitats a les rodes,...

FuncionsGenerals

Precondicions

Comportaments

Accions

Nivell 1

Nivell 2

Nivell 3

Nivell 4

Figura 7.3. Nivells de programació.

A continuació, es comenten les funcions utilitzades a cada nivell per a tenir una idea general de tot el conjunt.


36

Nivell 1. Funcions generals

Capçalera de la funció Descripció

Assignació_comportaments ( ) És la funció més important de totes. Aquí és on s’implementa l’estratègia de l’equip

Canvi_coordenades ( ) Canvia el sistema de referència de Robot Soccer i passa les mesures del camp de polzades a cm.

Possessió_pilota ( ) Funció estadística que indica quin dels dos equips té la possessió de la pilota.

Temps_costat ( ) Funció estadística que indica a quina meitat del camp es desenvolupa el joc.

Temps_zona ( ) Funció estadística que divideix el camp en 4 parts iguals i indica en quina part es juga més.

Nivell 2. Precondicions


PEC ( ) (Pelota En Campo) Indica la zona del camp on es troba la pilota.

MLP ( ) (Mejor Llegar Pelota)

Indica quin robot, excepte el porter, és el millor per a agafar la pilota.

CCP ( ) (Contrario Controla Pelota)

Indica si un robot contrari està en possessió de la pilota.

PredictBall ( ) Indica la situació futura de la pilota.

Nivell 3. Comportaments


Porter ( ) Els moviments del porter.

Interceptar_perseguir_pilota ( ) Indica segons la situació del joc si el robot intercepta la pilota o va a buscar-la.

Rematar_Perseguir_pilota ( ) Indica segons la situació del joc si el robot remata a porteria o va a buscar la pilota.

Posicionar_secundari ( ) Indica el millor robot per a situar-se entre la pilota i la porteria.

Reubicar_robots ( ) Indica quins robots han d’actuar d’acompanyants passius o col·locar-se en zones d’utilitat.


37

Nivell 4. Accions


Control_posició ( ) Calcula la velocitat que ha de tenir cada roda per tal d’evitar els obstacles o robots propis.

Ir_a_punto ( ) Calcula les variables necessàries per a que el robot vagi cap al seu objectiu.

Càlcul_angle_relatiu ( ) Indica l’angle que ha de girar el robot per a encarar-se a l’objectiu.

Velocity ( ) Indica la velocitat que ha de tenir cada roda.

7.3 Estratègia equip dinàmic

Una vegada comentades totes les funcions implementades, en aquest apartat es mostra l’organigrama de l’equip dinàmic comentat anteriorment (7.1) per a tenir una idea general.

Millor robot busca pilota ( )

Control_posicio ( )

Contrari porta pilota ( )

Porter ( )

Interceptar_perseguir_pilota ( )

Posicionar_secundari ( )

Situacio pilota ( )

Reubicar_robots ( )

Robot 0 fixe

1ª Precondició (MLP)

2ª Precondició (CCP)

1r Robot

2n Robot

3ª Precondició (PEC)

3r i 4t Robot

Inici Estrategia Dinamic

Fi Estrategia Dinamic

Canvi_coordenades ( )

Control_estadistic ( )

Prediccio_pilota ( )


38

7.4 Estratègia equip pseudo-dinàmic

Com en l’apartat anterior, es mostra l’organigrama de l’equip pseudo-dinàmic per a tenir també una idea general tal i com s’ha comentat a l’apartat 7.1.

Millor defensa busca pilota ( )


Porter ( )



Reubicar_davanters ( )

Robot 0 fixe



1r Robot

2n Robot

3r i 4t Robot

Inici Estrategia PseudoDinamic

Canvi_coordenades ( )

Control_estadistic ( )

Prediccio_pilota ( )

Pilota encamp propi

Control_posicio ( )

Fi Estrategia PseudoDinamic

SI NO

Millor davanter busca pilota ( )




Reubicar 3r robot

Reubicar 4t robot


39

7.5 Nivell 4. Accions

7.5.1 Càlcul_angle_relatiu Indica l’angle que ha de girar el robot per a encarar-se a l’objectiu. Aquest angle

vindrà determintat per la posició de l’objectiu respecte al robot i l’angle d’orientació del mateix tal i com s’observa a la següent figura.

Figura 7.4. Posició relativa entre el robot i la pilota.

Primerament es calcula la distancia X i Y entre el robot i l’objectiu: dx = robot->pos.x - punto_x; dy = robot->pos.y - punto_y;

Aleshores, es calcula l’angle existent entre ells dos mitjançant la següent fòrmula:

Una vegada s’ha calculat l’angle absolut, es calcula l’angle relatiu segons a quin

quadrant estigui l’objectiu aplicant les següents relacions:

if ( dx < 0 ){ I→ if ( dy < 0 ) angulo_obstaculo = angulo_obstaculo + 180; II→ else if ( dy > 0 )angulo_obstaculo = 180 - angulo_obstaculo; } else{ III→ if ( dy < 0 ) angulo_obstaculo = - angulo_obstaculo; IV→ else if ( dy > 0 )angulo_obstaculo = angulo_obstaculo; }


40

7.5.2 Velocity Indica la velocitat que ha de tenir cada roda. robot->velocityRight = vr; robot->velocityLeft = vl;

7.5.3 Control_posició Calcula la velocitat que ha de tenir cada roda per tal d’evitar els obstacles o robots

propis. Aquest control de posició és el mateix per als dos equips programats. A continuació es mostra l’organigrama d’aquesta funció.

EQUIP DINÀMIC = EQUIP PSEUDO-DINÀMIC

Control obstacles

Variables entrada

Inici Control Posicio

Fi Control Posicio

Posicio RobotPosicio Objectiu

Angle relatiuVelocitat de joc

Variables sortida

Velocitat roda dretaVelocitat roda esquerra

Control velocitat

Control obstruccio robot propi

7.5.3.1 Velocitat de joc Com que estem programant amb C++, a l’hora de realitzar qualsevol canvi es

necessita tornar a compilar i actualitzar el fitxer *.dll. Això és un problema ja que per a realitzar el control estadístic (veurem més endavant) és necessari canviar la velocitat de joc dels jugadors moltes vegades. Per aquest motiu, s’ha utilitzat la comanda ifstream de manera que sense necessitat de compilar, llegim la velocitat de joc desitjada des d’un fitxer de text.

ifstream ficher("DIRECTORI");

ficher >>VALOR FITXER TEXT;


41

7.5.3.2 Control obstacles S’ha considerat realitzar un control d’obstacles de manera d’evitar la col.lisió ja sigui

amb un robot propi com un contrari. Bàsicament, si es detecta una col.lisió aplicarem un increment de velocitat a una de les dues rodes. L’organigrama següent mostra una idea general sobre el control d’obstacles.

Buscar l'obstacle més proper

Variables entrada

Inici Control Obstacles

Fi Control Obstacles

Posicio RobotRadi Col.lisioPunt de Tall

Variables sortida

Velocitat roda dretaVelocitat roda esquerra

Col.lisió?

Apliquem un deltaa una de les rodes

NO

SI

Primerament, es busca quin obstacle és el més proper ja sigui amb un robot propi o contrari i posteriorment es mira, trigonomètricament, si l’obstacle està situat entre l’objectiu i el robot. Si l’obstacle no està entre la pilota i el robot no s’aplicarà el control de col·lisions. En cas contrari, s’observa el punt de tall amb la condició que no tenim conflicte mentre el radi de l’obstacle sigui superior a 20 cm. Finalment, s’aplica un increment de velocitat a una de les dues rodes.

Figura 7.5. Control de col·lisions.


42

7.5.3.3 Control de velocitat Per a calcular la velocitat que tindrà cada una de les dues rodes dels robots dependrà

de l’estat de joc, és a dir, la velocitat final d’una roda vindrà determinada per la composició de la distancia i l’orientació del robot fins a l’objectiu i el control d’obstacles.

Distancia objectiu Orientació Obstacles+ +Velocitat roda =

Figura 7.6. Paràmetres per al càlcul de la velocitat de les rodes.

El segon paràmetre (orientació) està comentat a l’apartat “7.5.1 Càlcul angle relatiu”

i el tercer paràmetre (obstacles) a l’apartat “7.5.3.2 Control obstacles”.

Pel que respecta al primer paràmetre (distancia a l’objectiu), per al control de velocitat dels robots es volia que aquests paressin correctament quan estessin arrivant al seu objectiu i que anessin a la màxima velocitat (Y) quan l’objectiu (X) estigués lluny. Per tant, s’ha escollit la funció SIGMOIDE on la seva evolució és com la funció escaló peró amb una pendent (m) variable.

Figura 7.7. Funció Sigmoide utilitzada per al control de velocitat.

Les característiques principals d’aquesta funció és que és estrictament creixent i

lineal, és constant quan assoleix un punt desitja i és pot modificar la pendent variant un sol paràmetre, tal i com es pot observar a la següent figura.

Figura 7.8. Velocitat del robot en funció de la distancia a l’objectiu mitjançant la funció Sigmoide.


43

Aleshores, si multipliquem per un valor la funció Sigmoide aquesta tendeix a aquest valor per a valors alts de la distancia a l’objectiu. És a dir, la velocitat màxima que tindrà el robot serà la desitjada.

Figura 7.9. Velocitat màxima del robot en funció de la velocitat desitjada.

A la següent figura es pot veure la variació de la velocitat màxima assolida pel robot segons la velocitat d’entrada inicial. Podem observar també que el robot disminueix suaument la velocitat a mesura que la distancia a l’objectiu es redueix.

El valor d’aquest paràmetre és la velocitat de joc comentada anteriorment a l’apartat “7.5.3.1 Velocitat de joc”.

Figura 7.10. Gràfica de la velocitat màxima del robot en funció de la velocitat desitjada amb la funció Sigmoide.

Finalment, a la següent figura es pot veure la variació de la pendent (m) fixant una velocitat de 50. A partir dels valors obtiguts s’ha escollit una pendent de valor 3.

Figura 7.11. Gràfica de la variació de la pendent de la funció Sigmoide.


44

Per tant, després d’explicar tots els paràmetres, les velocitats de les rodes vindran determinades per les següents expressions finals sabent que els robots poden anar indistintament amb els dos sentits (velocitat positiva o velocitat negativa).

Velocitat positiva (el robot es mou de cara)

deltatiuangle_rela*ke1

1*desitjada)velocitat_(roda_dreta _pilota)*distancia3( ++⎟⎠⎞

⎜⎝⎛+

+= −


1*desitjada)velocitat_(rraroda_esque _pilota)*distancia3( +−⎟⎠⎞

⎜⎝⎛+

+= −

Velocitat negativa (el robot es mou d’esquena)


1*desitjada)velocitat_(roda_dreta pilota)distancia_*3( ++⎟⎠⎞

⎜⎝⎛+

−= −


1*desitjada)velocitat_(rraroda_esque pilota)distancia_*3( +−⎟⎠⎞

⎜⎝⎛+

−= −

7.5.3.4 Control obstrucció robot propi A part del control respecte els obstacles, també s’ha realitzat un control d’obsturcció

cap a un robot del mateix equip. Això s’ha fet en el cas quan un altre robot del propi equip porti la pilota i hi hagi un robot que pugui interrompre o dificultar el seu avanç. La solució en aquests casos és que el robot que obstrueix el pas s’aparta del camí del que porta la pilota. A continuació, es mostra un exemple del control d’obstrucció on el robot rosa deixa el camí lliure al robot lila.

Figura 7.12. Control obstrucció robot propi..

7.5.4 Ir_a_punto Calcula les variables necessàries per a que el robot vagi cap al seu objectiu. La idea

d’aquesta funció és que el robot vagi cap a un punt en concret i es pari. També es té en compte un control d’area propia ja que s’evitarà que un robot propi entri dins l’area del porter per a evitar que es pugui fer un gol o obstruir al porter.

Entrant en detall, primerament es farà el comentat control d’àrea i posteriorment mentre el robot estigui a una distancia de l’objectiu superior a 2 cm es realitzarà el control de posició comentat a l’apartat anterior.


45

Aquesta funció és la mateixa per als dos equips programats i l’organigrama es mostra a continuació:


Control area propia

Variables entrada

Inici Ir_a_punto

Fi Ir_a_punto

Posicio RobotPosicio Objectiu

Variables sortida

Velocitat roda dreta = 0Velocitat roda esquerra = 0

Parar robot

Control posicioDistancia objectiuinferior a 2 cm ?

NO

SI

7.5.4.1 Control àrea pròpia La idea per a realitzar aquest control és fer una circumferencia de 30 cm de radi des

del centre de la porteria sabent que la seva coordenada es (0,90). Aleshores, si l’objectiu del robot cau dins aquesta circumferencia es cosiderarà que està situat a 30 cm del centre de la porteria i per tant, el robot no entrarà dins l’àrea. La següent figura mostra aquest control:

Figura 7.13. Control d’àrea pròpia.


46

7.6 Nivell 3. Comportaments

7.6.1 Porter Aquí s’implementen tots els moviments del porter com són: allunyar la pilota,

interceptar la pilota, reubicar posició i tapar la porteria.



Inici Porter

Fi Porter

Robot 0

Velocitat rodesó

Ir_a_punto

NO

Pilota allateral ?

Tapar situatal pal

Pilota dinsde l'area ?

Pilota s'allunyaporteria i distancia

superior 60 ?

Distancia pilotainferior 10 ?

Allunyar pilotalateral

SISI

NO

Reubicarposicio

SI

NO

Allunyar pilotamoviment giratori

SI

Predicciointerceptar pilota

NO

A continuació es comenten amb més detall les funcions esmentades a l’organigrama anterior i d’aquesta manera es podrà entendre millor el comportament del porter.

7.6.1.1 Tapar situat al pal

El porter es situarà tapant el pal sempre que la pilota estigui al lateral de l’àrea però sense entrar en ella. Aquesta posició es per a mantenir el porter a l’espera ja que si va cap a la pilota deixaria la porteria desprotegida.


47

Figura 7.14. Porter situat al pal.

7.6.1.2 Allunyar pilota lateral El porter allunyarà la pilota mitjançant un cop frontal sempre que aquesta es trobi

dins l’àrea al lateral. D’aquesta manera el porter frenaria un robot contrari que dugués la pilota.

Figura 7.15. Porter allunyant la pilota dins l’àrea i al lateral.

7.6.1.3 Predicció interceptar pilota El porter realitzarà una predicció per a poder interceptar la pilota quan vagi dins a

porteria sempre que aquesta no estigui al lateral o la distancia respecte la porteria sigui superior a 60 cm. El mètode per a calcular el punt de tall és realitzar la intersecció entre les trajectòries del porter i la pilota a partir de les equacions d’una recta.

//calculem pendent de la trajectoria de la pilota ballX = posicio X pilota futura – posicio X pilota actual ballY = posicio Y pilota futura – posicio Y pilota actual m = ballY/ballX; //terme independent de la equacio de la pilota b = posicio Y pilota actual - m * posicio X pilota actual; //calculem el punt on s’ha de situar el porter Punt de tall X = porter posicio X Punt de tall Y = m * Punt de tall X + b


48

Figura 7.16. Porter interceptant la pilota.

7.6.1.4 Reubicar posició

El porter es reubicarà al mig de la porteria sempre que la pilota no es trobi al lateral o que aquesta s’allunyi de la porteria amb una distancia mínima de 60 cm. D’aquesta manera evitem que el porter es resitui mentre la pilota està en una situació de perill o que es quedi en una posició fora de la porteria.

Figura 7.17. Reubicació del porter al mig de la porteria.

7.6.1.5 Allunyar pilota moviment giratori El porter allunyarà la pilota aplicant un moviment giratori sempre que aquesta estigui

a menys de 10 cm del porter i no estigui al lateral. S’evita que el poter surti de la porteria i s’aconsegueix que la pilota s’allunyi amb força. El moviment giratori s’aconsegueix donant un valor positiu a una roda i un valor negatiu a l’altra.

Figura 7.18. El porter allunya la pilota girant sobre sí mateix.


49

7.6.2 Interceptar_perseguir_pilota Indica segons la situació del joc si el robot intercepta la pilota o va a buscar-la.

Primerament es mirarà si un robot contrari està en possessió de la pilota i en direcció a la porteria pròpia. En aquest cas, el nostre robot interceptarà la pilota i quan l’hagi interceptat l’allunyarà per a que el robot contrari perdi la possessió de la pilota. Per altra banda, si la pilota no està en possessió d’un contrari o aquest no es dirigeix cap a la nostra porteria, el nostre robot perseguirà la pilota fins a tenir la possessió.



Rematar_perseguir_pilota

Variables entrada

Inici Interceptar_perseguir_pilota

Fi Interceptar_perseguir_pilota

Posicio RobotPosicio Oponent

Allunyar pilota moviment giratori

NO

SI

Oponent ambpilota i a prop ?

Distancia pilotainferior 10 cm ?

NO

SI

Interceptar pilota

7.6.2.1 Interceptar pilota

El jugador realitzarà una predicció per a poder interceptar la pilota quan aquesta vingui cap a ell conduïda per un oponent. El mètode per a calcular el punt de tall és realitzar la intersecció entre les trajectòries del jugador i la pilota a partir de les equacions d’una recta.

//calculem pendent de la trajectoria de la pilota ballX = posicio X pilota futura – posicio X pilota actual ballY = posicio Y pilota futura – posicio Y pilota actual m = ballY/ballX; //terme independent de la equacio de la pilota b = posicio Y pilota actual - m * posicio X pilota actual; //calculem el punt on s’ha de situar el jugador Punt de tall X = jugador posicio X Punt de tall Y = m * Punt de tall X + b


50

Figura 7.19. El jugador intercepta la pilota conduïda per un contrari.

7.6.2.2 Allunyar pilota moviment giratori El jugador allunyarà la pilota aplicant un moviment giratori sempre que aquesta

estigui a menys de 10 cm. Com que la pilota està en possessió d’un robot contrari, amb un moviment giratori s’intenta allunyar la pilota que, d’altra banda, no es podria fer si es fés un atac frontal. El moviment giratori s’aconsegueix donant un valor positiu a una roda i un valor negatiu a l’altra.

Figura 7.20. El jugador allunya la pilota girant sobre sí mateix.

7.6.3 Rematar_perseguir_pilota

Indica segons la situació del joc si el robot remata a porteria o va a buscar la pilota. En aquest cas, diferenciarem entre l’equip dinàmic i el pseudo-dinàmic ja que el seu comportament és diferent.

Pel que fa a l’equip dinàmic, primerament es mira si el nostre jugador està situat a la frontal o dins l’àrea contraria. En aquest cas, si el jugador està en possessió de la pilota rematarà a porteria i sinó anirà a buscar-la. Per altra banda, si el jugador no està en zona d’atac, conduirà la pilota si té la possessió o la perseguirà fins a agafar-la.

Pel que fa a l’equip pseudo-dinàmic, inicialment es mirarà si el robot que ha de perseguir o està en possessió de la pilota és defensa o davanter. Si el jugador és un defensa, aquest només perseguirà la pilota o la conduirà fins al mig camp, ja que com s’ha comentat anteriorment a l’apartat “7.1 Equip dinàmic vs pseudo-dinàmic” els defenses no poden situar-se al mig camp contrari ni els davanters al mig camp propi. Si el robot és un davanter, si té la possessió de la pilota i està en zona d’atac rematarà a porteria i sinó la conduirà cap a la porteria contraria. En el cas que no tingui la possessió de la pilota, la perseguirà.


51

A continuació es mostren els diferents organigrames de cada equip per tal de tenir una idea general del comportament de cadascun.

EQUIP DINÀMIC

Conduir pilota capa porteria contraria

Variables entrada

Inici Rematar_perseguir_pilota

Fi Rematar_perseguir_pilota

Posicio Robot

NO

SI

El robot situatarea contaria ?

NO

SI

Possessiopilota ?

Perseguir pilota(control posicio)

SI

NO

Rematar pilota

Possessiopilota ?


Conduir pilota capa porteria contraria

Variables entrada

Inici Rematar_perseguir_pilota

Fi Rematar_perseguir_pilota

Posicio Robot

NO

SI

El robot situatarea contaria ?

NO

SI

Possessiopilota ?

Perseguir plilotamig camp contrari(control posicio)

SI

NO

Rematar pilota

Possessiopilota ?

El robot ésun defensa ?

Possessiopilota ?

Conduir pilota capal mig camp

Perseguir pilotamig camp propi(control posicio)

SI

NO

SI

NO


52

7.6.3.1 Perseguir la pilota Aquesta funció és bàsicament l’acció “Control posició” comentada a l’apartat 7.5.3

ja que el que es vol és anar cap a la pilota evitant els obstacles i controlant la velocitat del robot.

7.6.3.2 Conduir pilota Per a conduir la pilota cap a la porteria contraria necessitem que el robot tingui la

possessió de la pilota (distancia inferior a 10 cm) i que estigui situat darrere la pilota per a poder empènyer-la. Hem de diferenciar dues situacions segons si el robot està situat a la zona dels extrems o a la zona central.

En el cas que el jugador dugui la pilota per la zona central, aquest la conduirà fins a la porteria contraria. Per fer-ho es considerarà que l’objectiu del robot està situat al centre de la porteria contraria, és a dir, a la posició (220,90).

Si el jugador duu la pilota per la zona lateral, aquest continuarà el seu moviment fins al final del camp per a aprofitar que els cantons no són rectes sinó que tenen uns xamfrans. D’aquesta manera s’aconseguirà que la pilota reboti produint una passada de la mort per a que un altre robot remati cap a porteria. A continuació es poden observar les dues situacions diferents i també el codi programat.

Figura 7.21. Passada de la mort o conduir cap a la porteria contraria.

//codi programacio conduir pilota dx = posicio X jugador - posicio X pilota; dy = posicio Y jugador - posicio Y pilota; distancia = sqrt(dx * dx + dy * dy); angle_relatiu = Calcul_angle_relatiu (dx,dy,rotacio_robot); //el jugador condueix la pilota per la zona central if ( (distancia < 10) && (dx < 0) && (pos Y jugador > 30) && && (posicio Y jugador < 150 )) Ir_a_punto (robot,env,220,90); //el jugador condueix la pilota per la zona central else Control_posicio (robot, ballx, bally, angle_relatiu);


53

7.6.3.3 Rematar a porteria Aquesta funció només s’utilitzarà quan el jugador amb la pilota estigui situat a la

frontal o dintre de l’àrea contraria. Bàsicament hi ha dos formes principals per a que el robot remati a porteria.

La primera forma de remat serà acompanyant la pilota. S’utilitzarà quan la pilota vagi en direcció a la porteria contraria i aleshores, s’augmentarà la velocitat d’una de les dues rodes, segons la situació al camp, aconseguint que la pilota surti impulsada cap endavant.

Figura 7.22. Remat a porteria acompanyant la pilota.

La segona forma de remat serà mitjançant moviment giratori. Al contrari que el remat anterior, aquest s’usarà quan la pilota vingui cap al robot ja que d’aquesta forma la pilota sortirà amb força cap endavant. Com a comentari, dir que la direcció de sortida de la pilota és imprevisible ja que depèn de la velocitat i trajectòria de la pilota i la situació del robot. Per aquest motiu aquest remat és efectiu quan hi ha una passada de la mort ja que el porter contrari no pot preveure al cent per cent a on anirà la pilota.

Figura 7.23. Remat a porteria amb moviment giratori.

7.6.4 Posicionar_secundari

Indica quin és el millor robot per a situar-se entre la pilota i la porteria o el millor robot per a interceptar un robot propi que vagi cap a la pròpia porteria amb la pilota.

La programació d’aquesta funció es considera pràcticament igual per als dos equips ja que la única diferencia existent entre l’equip dinàmic i el pseudo-dinàmic és que el robot secundari dinàmic s’elegeix entre tots els robots de camp mentre que el robot secundari pseudo-dinàmic s’elegeix entre un dels dos defensors.

La funció consisteix en col·locar un defensa situat a mitja distancia entre la pilota i la porteria pròpia sense entrar dins a l’àrea del porter. D’aquesta forma, sempre hi haurà un robot darrera la pilota per a parar un possible atac d’un robot contrari o interceptar o agafar la pilota si ve cap al propi camp.


54

A continuació es mostra l’organigrama d’aquesta funció per tal de tenir una idea general del comportament.


Variables entrada

Inici Posicionar_secundari

Fi Posicionar_secundari

Posicio Robot Principal

NORobot propi cap aporteria propiaamb la pilota ?

SIBuscar secundarimes a prop pilota

Buscar secundarimes a prop punt defensa

Interceptar_perseguir_pilota

Control area propia

Situació punt defensa

Calcul punt defensa

7.6.4.1 Situació al punt de defensa Aquesta funció consisteix en calcular el punt on s’ha de situar el robot defensor per

tal d’evitar que un robot contrari tingui camí lliure cap a la pròpia porteria i també per a tenir sempre un robot darrere la pilota per a interceptar-la o perseguir-la.

Concretament, aquest punt es situarà a mitja distancia entre la pilota i el centre de la porteria. Així, obtenim un robot defensor més òptim ja que no es situa en una posició prefixada sinó que aquesta anirà variant segons la posició de la pilota al camp.

Figura 7.24. Col.locació del defensor a mitja distancia entre la pilota i el centre de porteria.


55

Per al càlcul del punt es considerarà com si agaféssim una circumferència de radi la meitat de distancia entre la pilota i la porteria on l’origen se situa al centre de la porteria. Per tant, a continuació es mostren els càlculs trigonomètrics emprats per al càlcul d’aquest punt.

//distancia de la pilota fins al centre de la porteria (0,90) px = ballx - 0; py = bally - 90; distancia = sqrt (px*px + py*py); //calcul de l’angle if (py == 0) angle = 0; else angle = atan2(py,px); //colocarem el secundari a la meitat de distancia radi = distancia/2; //control d’area propia if (radi < 30) radi = 30; //coordenades on s’ha de col.locar el secundari x = radi * cos (angle); y = radi * sin (angle) + 90;

7.6.4.2 Interceptar_perseguir_pilota

Aquesta funció s’ha explicat i comentat a l’apartat 7.6.2.

7.6.4.3 Control àrea pròpia Aquesta funció s’ha explicat i comentat a l’apartat 7.5.4.1.

7.6.5 Reubicar_robots

Indica quins robots han d’actuar d’acompanyants passius o col·locar-se en zones d’utilitat sabent que dos robots ja tenen assignats el seu comportament arribats a aquest punt. En aquest cas, es diferencia entre l’equip dinàmic i el pseudo-dinàmic ja que el seu comportament és diferent.

Pel que respecta a l’equip dinàmic, dels dos robots que queden per assignar es busca el que estigui més a prop de la pilota com a tercer i l’altre com a quart. El tercer robot tindrà la funció d’obstaculitzar els robots contraris que vagin a buscar la pilota i el de fer un acompanyament passiu al robot del mateix equip que porti la pilota. En la situació que aquest perdi la pilota, el tercer robot intentarà interceptar-la i aconseguir la possessió. Quan la pilota es trobi en zona d’atac, el tercer robot es col·locarà en una bona posició dins l’àrea per tal de fer un bon remat. També pararà l’avanç d’un robot propi que vagi cap a la pròpia porteria amb la pilota.

Per altra banda, el quart robot només tindrà l’objectiu de situar-se en una bona posició per a rematar quan la pilota estigui en zona d’atac. En cas contrari, farà un acompanyament passiu al jugador que porta la pilota però bastant més avançat per tal de tenir sempre un robot col·locat a la davantera.

Per a entendre millor l’explicació dels anteriors paràgrafs, a continuació es mostra l’organigrama de l’equip dinàmic.


56

EQUIP DINÀMIC

Variables entrada

Inici Reubicar_robots

Fi Reubicar_robots

Robot PrincipalRobot Secundari

Posicio Pilota

Pilota area propiao direccio porteria

contraria ?

SI

Interceptar oponent

Robot entrepilota i contrari a

camp propi?

Assignar 3r i 4t robot

Pilota enzona d'atac ?

Pilota cap a areapropia amb unrobot propi ?

Acompanyamentpassiu

Control de remat

Interceptar pilota

Perseguir pilota

SI

SI

SI

NO

NO

NO

NO

3r ROBOT


Acompanyamentpassiu

Control de remat

SI

NO

4t ROBOT

Pel que fa a l’equip pseudo-dinàmic, la idea és la mateixa que a l’equip dinàmic però amb la diferencia que segons el camp on es troba la pilota, l’assignació del tercer i quart robot serà diferent en cada cas. Hem de recordar que l’equip pseudo-dinàmic es caracteritza per tenir dos robots fixats a la defensa (camp propi) i dos robots fixats a la davantera (camp contrari) que no poden passar del seu mig camp.

Per tant, si la pilota es troba al camp propi un defensor anirà a per la pilota i l’altre defensarà la porteria. El tercer i quart robot seran els dos davanters.


57

Si la pilota es troba al camp contrari un davanter anirà a per la pilota i un dels dos defenses es situarà entre la pilota i la porteria. El tercer robot serà el segon davanter i el quart robot el segon defensor.

A continuació es mostra l’organigrama de l’equip pseudo-dinàmic.


Variables entrada

Inici Reubicar_robots

Fi Reubicar_robots

Robot PrincipalRobot Secundari

Posicio Pilota

Pilota area propiao direccio porteria

contraria ?

SI

Interceptar oponent

Robot entrepilota i contrari a

camp propi?



Pilota cap a areapropia amb unrobot propi ?

Acompanyamentpassiu

Control de remat

Interceptar pilota

Perseguir pilota

SI

SI

SI

NO

NO

NO

NO

3r ROBOT

4t robot esun defensa ?

Acompanyamentpassiu

Situar al mig camp

SI

NO

4t ROBOT


Pilota encamp propi ?

SI NO


58

7.6.5.1 Interceptar oponent Aquesta funció és la mateixa que la d’interceptar la pilota comentada anteriorment,

però amb la diferencia que s’intercanvia la pilota pel robot contrari. El mètode per a calcular el punt de tall és realitzar la intersecció entre les trajectòries del jugador i l’oponent-pilota a partir de les equacions d’una recta.

//calculem pendent de la trajectoria de l’oponent ballX = posicio X oponent – posicio X pilota actual ballY = posicio Y oponent – posicio Y pilota actual m = ballY/ballX; //terme independent de la equacio de la pilota b = posicio Y oponent - m * posicio X oponent; //calculem el punt on s’ha de situar el jugador Punt de tall X = jugador posicio X Punt de tall Y = m * Punt de tall X + b

Figura 7.25. El jugador intercepta l’oponent que va a buscar la pilota.

7.6.5.2 Acompanyament passiu

Aquesta funció tindrà l’objectiu de calcular el punt on s’han de situar els robots que realitzin l’acompanyament passiu.

El comportament escollit per al tercer robot és que aquest vagi seguint la pilota però amb un desplaçament de ±30 cm segons estigui per sobre o sota la pilota. El quart robot té el mateix comportament que el tercer però es col·loca 50 cm més avançat a la pilota.

La següent figura mostra la ubicació del tercer i quart robot respecte la pilota.

Figura 7.26. Situació del tercer i quart robot respecte la pilota.


59

Per altra banda, diferenciarem les zones d’acció de l’acompanyament passiu de l’equip dinàmic del pseudo-dinàmic ja que els jugadors de l’equip dinàmic poden desplaçar-se per tot el camp mentre que els del pseudo-dinàmic estan limitats al seu mig camp segons siguin defenses o davanters.

Pel que fa a l’equip dinàmic, l’acompanyament es realitzarà sempre que la pilota es trobi a l’àrea pròpia o al mig camp desplaçant-se cap a l’àrea contraria. El jugador passiu es mourà per tota la zona del mig camp compresa entre els 40 i 165 cm.

Els motius d’aquest comportament és que es desitja l’acompanyament passiu sempre i quan el robot que porti la pilota vagi cap a la porteria contraria. En el cas que la pilota vagi cap a la porteria pròpia, no tindria sentit realitzar un acompanyament sinó que, com s’ha comentat a l’anterior apartat, s’interceptaria la pilota. Tampoc es vol que el robot passiu entri dins l’àrea pròpia ja que podria obstruir la sortida de la pilota pel que s’ha limitat a 40 cm. Finalment, quan la pilota es trobi en zona d’atac tampoc es realitzarà l’acompanyament sinó que s’intentarà rematar-la.

Pel que fa a l’equip pseudo-dinàmic, el comportament és el mateix que el de l’equip dinàmic però amb la variació que la zona estarà compresa entre 110 cm (mig camp) i 165 cm. Això és degut a que l’acompanyament només es podrà realitzar per un davanter i mai per un defensa ja que un dels dos defenses anirà a buscar la pilota i l’altre defensarà.

Figura 7.27. Zones d’acció de l’acompanyament passiu per als dos equips.


60

7.6.5.3 Control de remat En aquesta funció s’especifica el comportament del tercer i/o quart robot quan la

pilota es situa en zona d’atac. La idea és col·locar-los a la frontal de l’àrea contraria per a poder rematar la pilota quan el jugador que porta la condueix realitza una passada de la mort.

Concretament, el tercer robot és col·locarà a la posició (185,105) si la pilota ve del lateral superior o al punt (185,75) si ve de l’inferior mentre que el quart robot sempre es situarà al punt (185,90).

Figura 7.28. Zones d’acció de l’acompanyament passiu per als dos equips.

Els jugadors sempre intentaran rematar la pilota cap a porteria sempre i quan estigui situada entre un límit superior i un límit inferior ja que sinó no rematarien a porteria. Com que el remat depèn de la velocitat de la pilota, s’ha considerat que els límits puguin ser variables segons la velocitat de joc determinada per l’usuari. Els límits es desplaçaran cap als laterals quan més ràpida vagi la pilota i cap a l’àrea quan vagi més lenta. D’aquesta forma s’evita que el jugador remati abans d’hora o que remati una vegada la pilota ja ha passat.

//velocitat desitjada de joc ifstream fitxer("c:\\Strategy\\fitxer.txt"); fitxer >> vc; if (vc == 20) limit inferior = 70; //limit superior = 180 - inferior else if (vc == 30) limit inferior = 65; //limit superior = 180 - inferior else if (vc == 40) limit inferior = 60; //limit superior = 180 - inferior else if (vc == 50) limit inferior = 55; //limit superior = 180 – inferior else if (vc == 60) limit inferior = 50; //limit superior = 180 – inferior else if (vc == 70) limit inferior = 45; //limit superior = 180 – inferior else if (vc == 80) limit inferior = 40; //limit superior = 180 – inferior else if (vc == 90) limit inferior = 35; //limit superior = 180 – inferior else if (vc >= 100) limit inferior = 30; //limit superior = 180 – inferior


61

7.7 Nivell 2. Precondicions Les precondicions són funcions utilitzades per tal d’avaluar les condicions del partit

mirant la situació de la pilota i els jugadors. Aquesta avaluació ens servirà per a assignar els comportaments que ha de realitzar cada jugador com defensar, interceptar o perseguir la pilota, acompanyar o rematar comentats a l’apartat “7.6 Nivell 3. Comportaments”.

7.7.1 PredictBall

Calcula la posició futura de la pilota.

dx = posicio X actual – posicio X anterior; dy = posicio Y actual – posicio Y anterior; Posicio X futura = posicio X actual + dx; Posicio X futura = posicio Y actual + dy;

7.7.2 PEC (Pelota En Campo)

Bàsicament aquesta funció indica la zona del camp on es troba la pilota. Diferenciarem entre l’equip dinàmic i el pseudo-dinàmic.

EQUIP DINÀMIC

if (env->predictedBall.pos.x <= 40) pilota = 0;//zona area propia else if (env->predictedBall.pos.x > 40 && env->predictedBall.pos.x <= 165) pilota = 1;//zona mig camp else if (env->predictedBall.pos.x > 165) pilota = 2;//zona atac

EQUIP PSEUDO-DINÀMIC if (env->predictedBall.pos.x <= 40) pilota = 0;//zona area propia else if (env->predictedBall.pos.x > 40 && env->predictedBall.pos.x <= 110) pelota = 1;//zona mig camp propi else if (env->predictedBall.pos.x > 110 && env->predictedBall.pos.x <= 165) pelota = 2;//zona mig camp contrari else if (env->predictedBall.pos.x > 165) pelota = 3;//zona atac

Figura 7.29. Zones del camp on es troba la pilota per als dos equips.


62

7.7.3 MLP (Mejor Llegar Pelota) Indica quin robot, excepte el porter, és el millor per a agafar la pilota. La idea és

similar al futbol real on el jugador que està de cara a la pilota va a per ella excepte el cas que hi hagi un altre robot en possessió o a prop de la pilota. S’ha pensat d’aquesta forma ja que els robots són cubs i per tant, un mateix robot no pot parar la pilota i donar el tomb cap a la porteria contraria.

Ja que la situació de l’estat de joc varia contínuament al ser un partit de futbol, és en aquesta funció on s’aprecia amb més detall l’intercanvi de posicions entre els jugadors ja que cada cop s’elegeix quin és el millor jugador de camp per a buscar la pilota.


Inici MLP ( )

Fi MLP ( )

Eleccio millor robot

NOAlgun robotdarrere la pilota ?

SI

Millor robot el queesta mes a prop

de la pilota

NOAlgun robotdarrere la pilota ?

SI

A continuació es mostren dues situacions per a l’elecció del millor robot per a buscar la pilota. En els dos casos, el millor robot és el número 1.

Figura 7.30. Situacions per a l’elecció del millor robot.


63

7.7.4 CCP (Contrario Controla Pelota) Indica si un robot contrari està en possessió de la pilota. El motiu d’aquesta funció és

avaluar si hi ha un robot contrari amb possibilitats reals de crear perill a la pròpia porteria. En cas d’haver-hi aquesta situació, s’assignarà que el robot principal intercepti al jugador contrari per a fer-se amb la possessió de la pilota i en conseqüència eliminar el perill.


Inici CCP ( )

Fi CCP ( )

Eleccio oponent mes perillos

NOAlgun oponenta menys de

20 cm pilota ?

SI

NO hi ha perillNODireccio propia

porteria ?

SI

A continuació es mostren tres situacions per a l’avaluació de perill cap a la pròpia porteria. Només existeix perill en el cas 3.

Figura 7.31. Situacions per a la avaluació de perill.


64

7.8 Nivell 1. Funcions generals

7.8.1 Assignació_comportaments Aquí és on s’implementa l’estratègia que ha de tenir cada equip. Això s’aconsegueix

assignant als diferents robots de l’equip els comportaments comentats a l’apartat 7.6 segons la situació i l’estat de joc avaluat mitjançant les precondicions comentades a l’apartat 7.7. A continuació, es comenta l’assignació de comportaments de l’equip dinàmic i el pseudo-dinàmic.

Pel que fa a l’equip dinàmic, com s’ha definit en anteriors apartats, la idea és que tots els robots són iguals i es podran moure per tot el camp intercanviant-se les posicions excepte el porter que és fix. A partir d’aquí, l’assignació dels comportaments és la següent:

1- Es fixa un robot com a porter (Robot 0).

2- S’avalua l’estat de joc amb les precondicions MLP ( ) i CPP ( ) per a que el millor robot vagi a per la pilota (Robot 1)

3- Assignarem un robot per a la defensa situat entre la pilota i la seva porteria (Robot 2).

4- Es mira la situació de la pilota al camp amb la precondició PEC ( ).

5- Dels altres dos robots que queden, el que està més prop del robot que duu la pilota realitzarà un acompanyament passiu per a poder recuperar la pilota en cas de pèrdua (Robot 3).

6- L’últim robot és col·locarà com a davanter a una posició més avançada respecte a la pilota. D’aquesta manera, sempre tindrem un robot que pugi rematar a porteria o agafar la pilota a una zona avançada (Robot 4).

EQUIP DINÀMIC

Millor robot busca pilota ( )


Porter ( )



Situacio pilota ( )

Robot 0 fixe



1r Robot

2n Robot

3ª Precondició (PEC)

3r Robot

Inici Assignacio Dinamic

Fi Assignacio Dinamic

Reubicar 3r robot

Reubicar 4t robot4t Robot


65

Pel que fa a l’equip pseudo-dinàmic, la diferencia respecte a l’equip dinàmic és que ara hi ha dos robots fixats a la defensa i altres dos fixats a la davantera. És a dir, ni els defenses ni els davanters poden passar del mig camp. L’assignació dels comportaments és la següent:

1- Si la pilota està al mig camp propi, el millor dels dos defenses anirà a per la pilota (Robot 1) i l’altre es col·locarà entre la pilota i la seva porteria (Robot 2). Els dos davanters (Robot 3 i 4) es col·locaran al mig camp interceptant els contraris que vagin a per la pilota i esperaran a que aquesta passi del mig camp.

2- Si la pilota està al mig camp contrari, el millor dels dos davanters anirà a per la pilota (Robot 1) i l’altre farà un acompanyament passiu o es situarà en zona de remat si la pilota està en zona d’atac (Robot 2). D’altra banda, un dels dos defenses es col·locarà entre la pilota i la seva porteria (Robot 3) i l’altre esperarà la pilota situat al mig camp (Robot 4).


Millor defensa busca pilota ( )


Porter ( )



Reubicar_davanters ( )

Robot 0 fixe



1r Robot

2n Robot

3r i 4t Robot

Inici Assignacio PseudoDinamic

Pilota encamp propi ?

Fi Assignacio PseudoDinamic

SI NO

Millor davanter busca pilota ( )




Reubicar 3r robot

Reubicar 4t robot

Situacio pilota ( )1ª Precondició (PEC)


66

7.8.2 Canvi_coordenades Canvia el sistema de referència de Robot Soccer i passa les mesures del camp de

polzades a cm. S’ha considerat realitzar un canvi de referència de l’origen de coordenades de l’equip blau i l’equip groc per tal que els valors que venen per defecte al Robot Soccer no afectin a l’hora de programar cadascun.

També s’ha canviat les unitats que venen per defecte en polzades a cm, per tal de tenir valors exactes pel que fa a les dimensions del camp, ja que realment mesura 220 x 180 cm.

Figura 7.32. Canvis de referència per a l’equip groc i l’equip blau.

Primerament, pel que fa a la conversió de polzades a cm, s’ha aplicat el següent

factor d’escala mitjançant els límits del camp. També, es pot aplicar directament la relació que 1 polzada = 2,54 cm.

Factor_escala = 220 /(FRIGHTX - FLEFTX) = 2,54 cm

Aleshores, aplicant les següents relacions, s’han obtingut els nous canvis de coordenades dels sistemes de referència de cada equip a cm.

Xyellow = (Valor_X_defecte - FLEFTX) * factor_escala Yyellow = (Valor_Y_defecte - FBOT) * factor_escala Angleyellow = Angle_per_defecte Xblue = (FRIGHTX - Valor_X_defecte) * factor_escala Yblue = (FTOP - Valor_Y_defecte) * factor_escala Angleblue = Angle_per_defecte + 180º


67

7.8.3 Possessió_pilota Funció estadística que indica el % de possessió de la pilota de l’equip groc i de

l’equip blau.

Primerament, es busca el jugador de cada equip que està més a prop de la pilota i s’avalua la situació entre aquests dos jugadors. Aleshores, s’incrementa una variable que compta el temps de possessió de la pilota segons si el jugador de camp que està més a prop d’ella és de l’equip groc o blau.

Finalment, sabent el temps total de joc i el temps de possessió de la pilota de cada equip s’obté el % de possessió de cada equip.

Figura 7.33. Distancia entre els millors robots de cada equip i la pilota.

El codi de programació utilitzat per a obtenir el % de possessió de cada equip és el següent:

//es busca el robot propi més a prop de la pilota if (distancia[0] < distancia[1]) millor_propi = 0; else millor_propi = 1; if (distancia[millor_propi] > distancia[2]) millor_propi = 2; if (distancia[millor_propi] > distancia[3]) millor_propi = 3; if (distancia[millor_propi] > distancia[4]) millor_propi = 4; //es busca el robot contrari més a prop de la pilota if (distancia_op[0] < distancia_op[1]) millor_oponent = 0; else millor_oponent = 1; if (distancia_op[millor_oponent] > distancia_op[2]) millor_oponent = 2; if (distancia_op[millor_oponent] > distancia_op[3]) millor_oponent = 3; if (distancia_op[millor_oponent] > distancia_op[4]) millor_oponent = 4; //s’incrementa la variable de possessió de cada equip if (distancia[millor_propi] < distancia_op[millor_oponent]) possessio_equip_groc++; else possessio_equip_blau++; //es calcula el temps total de joc temps_total = possessio_equip_groc + possessio_equip_blau; //es calcula el % de possessió de cada equip percentatge_groc = (possessio_equip_groc / temps_total) * 100; percentatge_blau = (possessio_equip_blau / temps_total) * 100;


68

7.8.4 Temps_costat Funció estadística que indica a quina meitat del camp es desenvolupa el joc.

Primerament, es mira si la pilota està al camp propi o al camp contrari i aleshores, s’incrementa una variable que compta el temps que està la pilota en cada camp.

Finalment, sabent el temps total de joc i el temps que està la pilota al camp propi o al camp contrari, s’obté el % de temps en cada meitat de camp.

Figura 7.34. Situació de la pilota en camp propi o camp contrari.

El codi de programació utilitzat per a obtenir el % de temps que passa la pilota en cada meitat del camp és el següent:

//es mira a quina meitat del camp es troba la pilota if (posicio_X_pilota <= 110) camp_groc++; else camp_blau++; //es calcula el temps total de joc temps_camp = camp_groc + camp_blau; //es calcula el % temps que passa la pilota en cada camp percentatge_groc = (camp_groc / temps_camp) * 100; percentatge_blau = (camp_blau / temps_camp) * 100;


69

7.8.5 Temps_zona Funció estadística que divideix el camp en 4 parts iguals i indica en quina part del

camp es desenvolupa el partit i d’aquesta forma saber quin dels dos equips ataca més. Primerament, es mira a quina de les quatre zones és troba la pilota i aleshores, s’incrementa una variable que compta el temps que està la pilota en cadascuna de les diferents zones.

Finalment, sabent el temps total de joc i el temps que està la pilota en cada part del camp, s’obté el % de temps en cada zona.

Figura 7.34. Situació de la pilota en cada zona del camp.

El codi de programació utilitzat per a obtenir el % de temps que passa la pilota en cada zona del camp és el següent:

//es mira la zona on es troba la pelota if (posicio_X_pilota <= 55) zona1++; else if (posicio_X_pilota > 55 && posicio_X_pilota <= 110) zona2++; else if (posicio_X_pilota > 110 && posicio_X_pilota <= 165 ) zona3++; else if (posicio_X_pilota > 165) zona4++; //es calcula el temps total de joc temps_zona = zona1 + zona2 + zona3 + zona4; //es calcula el % temps que passa la pilota en cada zona percentatge_zona1 = (zona1 / temps_zona) * 100; percentatge_zona2 = (zona2 / temps_zona) * 100; percentatge_zona3 = (zona3 / temps_zona) * 100; percentatge_zona4 = (zona4 / temps_zona) * 100;


70

8 Resultats 8.1 Paràmetres i condicions de joc

En aquest apartat es mostren i s’analitzen els resultats obtinguts desprès de fer jugar l’equip dinàmic (groc) contra el pseudo-dinàmic (blau). Concretament, per a poder realitzar una comparativa entre els dos equips s’han observat els següents paràmetres comentats en anteriors apartats:

1- Temps de possessió de la pilota. 2- Temps de la pilota a cada meitat del camp. 3- Temps de la pilota a cada zona del camp. 4- Nombre de gols realitzats. 5- Nombre de victòries i empats.

Per a dur a terme aquesta comparativa, s’han realitzat els diferents partits a diferents velocitats de joc per tal de veure com afecta a la variació dels paràmetres anteriorment citats. S’han realitzat cinc partits per a cada velocitat de joc escollida amb les següents condicions:

• Cada partit dura 5 minuts.

• El partit s’acaba quan algun equip fa 3 gols.

• No es pot col·lisionar amb el porter contrari per a fer gol.

• Si la lluita per la pilota dura 5 segons es considera falta.

Figura 8.1. Condicions de joc.

A l’annex es poden veure els valors obtinguts del Robot Soccer, utilitzats per a realitzar les taules que es comentaran als següents apartats. A continuació, es realitza l’estudi comparatiu dels dos equips a partir de les estadístiques obtingudes dels paràmetres considerats.

Comparativa de técnicas de control distribuido. Aplicación en la plataforma RoboSoccer

71

8.2 Recopilatori de resultats Abans d’entrar en detall amb l’anàlisi dels resultats per cadascun dels paràmatres segons la velocitat de joc, es mostren els resultats

obtinguts mitjançant el Robot Soccer (apartat 11.3 de l’annex) per a veure com es va desenvolupar cada partit. S’ha composat una taula per a cada velocitat de joc les quals mostren els percentatges de cada equip pel que fa a la possessió, meitat de camp i zona de moviment de la pilota així com els gols marcats i la durada de cada partit.

Finalment, s’obté una mitjana total dels 5 partits disputats a cada velocitat per a observar a cada paràmetre si domina més l’equip dinàmic (groc) o l’equip pseudo-dinàmic (blau).

Dinàmic (groc)

Pseudo (blau)

Nº Proba

Possessió Dinàmic

(%)

PossessióPseudo

(%)

Camp Dinàmic

(%)

Camp Pseudo

(%)

Zona1 (%)

Zona2 (%)

Zona3 (%)

Zona4 (%)

Gols Dinàmic

Gols Pseudo

Temps partit

1 45,9 54,1 43,6 56,4 21,7 21,9 25,0 31,4 3 2 3:43

2 45,9 54,1 46,8 53,2 28,3 18,5 19,9 33,3 2 1 5:00

3 48,3 51,7 50,9 49,1 27,1 23,8 17,9 31,2 3 1 3:52

4 45,3 54,7 47,5 52,5 27,3 20,2 22,5 30,0 1 0 5:00

Velocitat 30

5 40,1 59,9 44,5 55,5 18,3 26,2 25,4 30,1 2 2 5:00

Mitja Final (%) 45 55 47 53 25 22 22 31 2,2 1,2


72

Dinàmic (groc)

Pseudo (blau)

Nº Proba

Possessió Dinàmic

(%)

PossessióPseudo

(%)

Camp Dinàmic

(%)

Camp Pseudo

(%)

Zona1 (%)

Zona2 (%)

Zona3 (%)

Zona4 (%)

Gols Dinàmic

Gols Pseudo

Temps partit

1 44,3 55,7 46,5 53,5 22,5 23,9 24,8 28,8 2 0 5:00

2 57,1 42,9 52,1 47,9 28,7 23,5 23,4 24,4 1 0 5:00

3 54,8 45,2 54,3 45,7 30,6 23,7 24,3 21,4 1 1 5:00

4 51,4 48,6 52,8 47,2 27,2 25,6 18,9 28,3 2 1 5:00

Velocitat 40

5 47,3 52,7 48,4 51,6 23,3 25,1 20,5 31,1 2 2 5:00

Mitja Final (%) 51 49 51 49 26 24 23 27 1,6 0,8

Dinàmic (groc)

Pseudo (blau)

Nº Proba

Possessió Dinàmic

(%)

PossessióPseudo

(%)

Camp Dinàmic

(%)

Camp Pseudo

(%)

Zona1 (%)

Zona2 (%)

Zona3 (%)

Zona4 (%)

Gols Dinàmic

Gols Pseudo

Temps partit

1 51,8 48,2 58,7 41,3 28,0 30,7 11,6 29,6 3 0 4:50

2 50,9 49,1 53,7 46,3 30,4 23,3 24,6 21,6 2 3 3:57

3 44,2 55,8 54,3 45,7 22,5 31,8 19,9 25,8 1 1 5:00

4 49,4 50,6 52,6 47,4 24,1 28,5 26,5 20,8 3 2 3:17

Velocitat 50

5 45,4 54,6 54,8 45,2 31,4 23,3 23,0 22,2 2 2 5:00

Mitja Final (%) 48 52 55 45 27 28 21 24 2,2 1,6


73

Dinàmic (groc)

Pseudo (blau)

Nº Proba

Possessió Dinàmic

(%)

PossessióPseudo

(%)

Camp Dinàmic

(%)

Camp Pseudo

(%)

Zona1 (%)

Zona2 (%)

Zona3 (%)

Zona4 (%)

Gols Dinàmic

Gols Pseudo

Temps partit

1 48,9 51,1 54,6 45,4 29,4 25,2 18,9 26,5 1 0 5:00

2 47,9 52,1 50,7 49,3 27,1 23,7 20,3 29,0 1 0 5:00

3 50,8 49,2 48,4 51,6 25,4 23,0 26,9 24,7 1 2 5:00

4 50,2 49,8 52,4 47,6 28,2 24,2 26,3 21,3 2 1 5:00

Velocitat 60

5 46,8 53,2 69,2 30,8 36,5 32,7 18,6 12,2 1 3 4:43

Mitja Final (%) 49 51 55 45 29 26 22 23 1,2 1,2

Dinàmic (groc)

Pseudo (blau)

Nº Proba

Possessió Dinàmic

(%)

PossessióPseudo

(%)

Camp Dinàmic

(%)

Camp Pseudo

(%)

Zona1 (%)

Zona2 (%)

Zona3 (%)

Zona4 (%)

Gols Dinàmic

Gols Pseudo

Temps partit

1 45,3 54,7 54,3 45,7 34,0 20,3 21,9 23,8 1 3 4:16

2 52,0 48,0 48,7 51,3 23,5 25,2 24,9 26,4 1 1 5:00

3 57,4 42,6 47,1 52,9 26,5 20,6 20,3 32,6 2 1 5:00

4 51,8 48,2 51,3 48,7 28,0 23,3 23,8 24,9 2 3 4:09

Velocitat 70

5 47,1 52,9 54,1 45,9 31,5 22,7 20,5 25,3 1 3 3:36

Mitja Final (%) 51 49 51 49 29 22 22 27 1,4 2,2


74

Dinàmic (groc)

Pseudo (blau)

Nº Proba

Possessió Dinàmic

(%)

PossessióPseudo

(%)

Camp Dinàmic

(%)

Camp Pseudo

(%)

Zona1 (%)

Zona2 (%)

Zona3 (%)

Zona4 (%)

Gols Dinàmic

Gols Pseudo

Temps partit

1 46,6 53,4 56,0 44,0 37,7 18,3 19,6 24,4 1 2 5:00

2 54,3 45,7 50,5 49,5 28,9 21,5 19,7 29,8 2 2 5:00

3 52,2 47,8 58,7 41,3 31,4 22,7 18,6 27,3 1 2 5:00

4 50,1 49,9 48,3 51,7 28,1 20,3 23,4 28,2 2 2 5:00

Velocitat 80

5 47,4 52,6 53,5 46,5 28,1 23,4 23,1 25,5 2 3 4:01

Mitja Final (%) 50 50 53 47 31 21 21 27 1,6 2,2

Dinàmic (groc)

Pseudo (blau)

Nº Proba

Possessió Dinàmic

(%)

PossessióPseudo

(%)

Camp Dinàmic

(%)

Camp Pseudo

(%)

Zona1 (%)

Zona2 (%)

Zona3 (%)

Zona4 (%)

Gols Dinàmic

Gols Pseudo

Temps partit

1 52,1 47,9 54,6 45,4 27,7 26,9 24,7 20,7 2 2 5:00

2 53,4 46,6 53,3 46,7 26,7 26,6 25,7 20,9 2 3 3:27

3 52,1 47,9 56,1 43,9 29,0 27,1 21,0 22,9 2 2 5:00

4 50,2 49,8 58,2 41,8 31,8 26,4 20,4 21,4 3 1 3:59

Velocitat 90

5 50,1 49,9 52,4 47,6 27,3 25,1 29,3 18,4 3 2 3:35

Mitja Final (%) 52 48 55 45 29 26 24 21 2,4 2

Comparativa de técnicas de control distribuido. Aplicación en la plataforma RoboSoccer

75

8.3 Possessió de la pilota En aquest apartat es comenten els resultats obtinguts pel que fa a la possessió de la

pilota. La idea d’observar aquest paràmetre és per a determinar si algun dels dos equips s’imposa considerablement sobre l’altre ja que es pot considerar que a més possessió de la pilota més probabilitat de marcar un gol i, en conseqüència, de guanyar el partit.

La següent taula mostra els percentatges finals de possessió de la pilota de cadascun dels dos equips per a cada velocitat de joc. Tanmateix, s’obté la possessió global dels dos equips.

Velocitat Possessió dinàmic

Possessió pseudo

Velocitat 30 45 55 Velocitat 40 51 49 Velocitat 50 48 52 Velocitat 60 49 51 Velocitat 70 51 49 Velocitat 80 50 50 Velocitat 90 52 48

Mitja (%) 49 51

A continuació, es mostren els valors de l’anterior taula de forma gràfica per tal de poder interpretar millor visualment l’evolució d’aquest paràmetre a mesura que s’incrementa la velocitat de joc.

Possessió de la pilota

44

45

46

47

48

49

50

51

52

53

54

55

56

Velocitat 30 Velocitat 40 Velocitat 50 Velocitat 60 Velocitat 70 Velocitat 80 Velocitat 90

(%)

Possessió Dinàmic

Posessio Pseudo

Figura 8.2. Possessió de la pilota segons la velocitat de joc.


76

Velocitat 30

Possessió dinàmic

45%

Possessió pseudo

55%

Velocitat 40

Possessió dinàmic

51%

Possessió pseudo

49%

Velocitat 50

Possessió pseudo

52%

Possessió dinàmic

48%

Velocitat 60

Possessió pseudo

51%

Possessió dinàmic

49%

Velocitat 70

Possessió pseudo

49%

Possessió dinàmic

51%

Velocitat 80

Possessió pseudo

50%

Possessió dinàmic

50%

Velocitat 90

Possessió pseudo

48%

Possessió dinàmic

52%

Total Possessió

Possessió dinàmic

49%

Possessió pseudo

51%

Com a anàlisi de la possessió de la pilota, es pot dir que tant l’equip dinàmic (groc) com el pseudo-dinàmic (blau) tenen la mateixa possessió de la pilota per a totes les simulacions a velocitats diferents. El motiu és que amb la tàctica de joc programada per als dos equips, sempre hi haurà almenys un robot de cada equip estarà situat a les proximitats de la pilota i, per tant, la distancia respecte d’aquesta serà la mateixa per als dos jugadors ja que no es pot determinar quins dels dos està controlant la pilota. Per tant, la velocitat de joc no influeix sobre la possessió de la pilota.


77

8.4 Pilota a cada meitat del camp En aquest apartat es comenten els resultats obtinguts pel que fa a la situació de la

pilota a cadascuna de les meitats del camp. La idea d’analitzar aquest paràmetre és per a observar numèricament en quina part del camp es desenvolupa el partit.

La següent taula mostra els percentatges finals que indiquen a quin camp ha estat més temps la pilota, així com també el valor global.

Velocitat Camp dinàmic Camp pseudo


Mitja (%) 52 48

A continuació, es mostren els valors de l’anterior taula de forma gràfica per tal de poder interpretar millor visualment l’evolució d’aquest paràmetre a mesura que s’incrementa la velocitat de joc.

Temps meitat de camp

44

45

46

47

48

49

50

51

52

53

54

55

56


(%)

Camp Dinàmic

Camp Pseudo

Figura 8.3. Possessió de la pilota segons la velocitat de joc.


78

Velocitat 30

Camp pseudo

53%

Camp dinàmic

47%

Velocitat 40

Camp pseudo

49%

Camp dinàmic

51%

Velocitat 50

Camp pseudo

45%

Camp dinàmic

55%

Velocitat 60

Camp pseudo

45%

Camp dinàmic

55%

Velocitat 70

Camp pseudo

49%

Camp dinàmic

51%

Velocitat 80

Camp pseudo

47%

Camp dinàmic

53%

Velocitat 90

Camp pseudo

45%

Camp dinàmic

55%

Total Costat Camp

Camp dinàmic

52%

Camp pseudo

48%

Com a anàlisi de la situació de la pilota a cada meitat del camp, es pot dir que el partit es desenvolupa més temps al camp dinàmic que al pseudo-dinàmic. El motiu és que amb la tàctica de joc programada per a l’equip pseudo-dinàmic, un dels dos defenses està situat al mig camp pel que intercepta tots els jugadors que venen del camp dinàmic. Per tant, la tàctica del pseudo-dinàmic predomina sobre la velocitat de joc.


79

8.5 Pilota a cada zona del camp En aquest apartat, s’amplia el paràmetre de l’anterior apartat especificant en quina

zona de cada meitat del camp es desenvolupa el partit. La idea d’analitzar aquest paràmetre és per a observar, apart d’on es desenvolupa el partit, quin dels dos equips ataca més.

La següent taula mostra els percentatges finals que indiquen a quina zona del camp ha estat més la pilota així com també el valor global.

Figura 8.4. Distribució del camp per zones.

Velocitat Zona 1 Zona 2 Zona 3 Zona 4

Velocitat 30 25 22 22 31 Velocitat 40 26 24 23 27 Velocitat 50 27 28 21 24 Velocitat 60 29 26 22 23 Velocitat 70 29 22 22 27 Velocitat 80 31 21 21 27 Velocitat 90 29 26 24 21

Mitja (%) 28 24 22 26 A continuació, es mostren els valors de l’anterior taula de forma gràfica per tal de

poder interpretar millor visualment l’evolució d’aquest paràmetre a mesura que s’incrementa la velocitat de joc.


80

Temps per Zona del camp

16

18

20

22

24

26

28

30

32


(%)Zona 1 Zona 2 Zona 3 Zona 4

Temps per Zona del camp

30

30 30

30

40

40

40

4050 50

50

50

60

60

606070 70

70

80 80

8090

90

90

70

80

90

16

18

20

22

24

26

28

30

32

Zona1 Zona2 Zona3 Zona4

(%)

Figura 8.5. Temps de la pilota en les zones del camp.

Com a anàlisi de la situació de la pilota a cada zona del camp, es pot dir que a velocitats baixes l’equip dinàmic arriba més vegades a l’àrea contraria que el pseudo-dinàmic. A mesura que la velocitat de joc es va incrementant, els papers es van intercanviant i aleshores és l’equip pseudo-dinàmic el que ataca més.

També es pot observar que el joc pràcticament no es desenvolupa al mig camp sinó que el joc se situa a cadascuna de les dues àrees. El motiu és que l’objectiu dels dos equips és el d’atacar i no el de controlar i anar basculant la pilota al mig camp com passa al futbol real. Es pot considerar la zona del mig camp com un camí de pas quan un equip ha robat la pilota en defensa i aleshores marxa cap a l’atac.

Un altre motiu per a entendre perquè el joc es desenvolupa a les dues àrees és degut a que és en aquestes zones on els robots defensors intercepten als jugadors contraris que porten la pilota i aleshores, es quan es produeixen les lluites per la pilota fins que és xiula falta al cap de cinc segons.

Per tant, es pot dir que per a velocitats baixes l’equip dinàmic ataca més que el pseudo-dinàmic o almenys els seus jugadors estan situats a l’àrea contraria i a mesura que s’augmenta la velocitat de joc és el pseudo-dinàmic el que s’imposa.


81

8.6 Nombre de gols marcats En aquest apartat s’observen el nombre de gols marcats per cada equip. No cal dir

que aquest paràmetre és el més important a l’hora de jugar a futbol ja que evidentment determina quins dels dos equips guanya el partit.

A continuació, es mostra una taula amb els gols marcats per cada equip segons la velocitat de joc del partit i el respectiu gràfic per tal de poder interpretar millor visualment l’evolució d’aquest paràmetre a mesura que s’incrementa la velocitat de joc.

Velocitat Gols dinàmic

Gols pseudo


Total 63 56 Mitja (%) 53 47

Gols Dinàmic i Pseudo-dinàmic

0

1

2

3

4

5

6

7

8

9

10

11

12


Nombre de gols

Gols Dinàmic Gols Pseudo

Figura 8.6. Nombre de gols marcats a diferents velocitats de joc.

Com a anàlisi dels gols marcats, es pot dir que a velocitats baixes l’equip dinàmic

marca més gols que l’equip pseudo-dinàmic i a mesura que la velocitat de joc es va incrementant aleshores és l’equip pseudo-dinàmic el que aconsegueix marcar més gols.

Es pot observar que quan la velocitat de joc és de 60, existeix una igualtat entre els dos equips ja que marquen els mateixos gols i és el moment que entre els dos equips marquen el menor nombre. En aquest cas, cap davantera s’imposa sobre la defensa de l’equip contrari. També es pot afirmar, agrupant l’anàlisi de l’anterior apartat, que l’equip que més ataca també és aproximadament l’equip que marca més gols.

Per tant, es pot dir que a velocitats baixes l’equip dinàmic marca més gols que el pseudo-dinàmic i viceversa a velocitats altes.


82

8.7 Victòries i empats En aquest apartat es comenta finalment quina influencia han tingut els paràmetres

anteriorment comentats sobre l’objectiu principal d’un equip de futbol que és guanyar el partit. D’aquesta forma, es pot veure globalment quin dels dos equips és el millor desprès de realitzar tota la bateria de simulacions a diferents velocitats.

La següent taula mostra el nombre de victòries de cada equip i el nombre d’empats a cadascuna de les diferents velocitats de joc.

Velocitat Victòries dinàmic Empats Victòries

pseudo

Velocitat 30 4 1 0 Velocitat 40 3 2 0 Velocitat 50 2 2 1 Velocitat 60 3 0 2 Velocitat 70 1 1 3 Velocitat 80 0 2 3 Velocitat 90 2 2 1

Total 15 10 10

Mitja (%) 42 29 29

A continuació, es mostren els valors de l’anterior taula de forma gràfica per tal de

poder interpretar millor visualment l’evolució d’aquest paràmetre a mesura que s’incrementa la velocitat de joc.

Victòries i Empats

0

1

2

3

4


Victoria DinàmicEmpatVictoria Pseudo

Figura 8.7. Nombre de victòries i empats a diferents velocitats de joc.


83

Com a anàlisi del nombre de victòries i empats es pot dir que és una conseqüència directa dels gols marcats comentats a l’anterior apartat. Com que a velocitats baixes l’equip dinàmic (groc) marca més gols que el pseudo-dinàmic (blau), això condueix a que el nombre de victòries del dinàmic sigui superior. Per contra l’equip pseudo-dinàmic pràcticament només pot empatar.

Per altra banda, l’equip pseudo-dinàmic s’imposa clarament a velocitats de joc altes essent en aquest cas quan marca més gols. Quan la velocitat de joc és 60 es manifesta una igualtat quasi completa entre els dos equips ja que a més de marcar el mateix nombre de gols també aconsegueixen pràcticament les mateixes victòries.

Pel que fa a la velocitat 90, no es pot determinar com afecta al domini d’un o altre equip ja que en aquest cas, la gran velocitat de la pilota provoca que cap equip pugui tenir un control d’aquesta i els jugadors estan contínuament canviant de rol a causa dels canvis de posició de la pilota. A conseqüència d’això, la tàctica programada per als dos equips no té influencia sobre els gols marcats sinó que es produeixen a partir de rebots i cops d’atzar.

Per tant, l’equip dinàmic s’imposa a velocitats baixes, existeix igualtat entre els dos quan la velocitat és 60 i, en endavant, és l’equip pseudo-dinàmic el que guanya.

8.8 Observacions globals Després de comentar detalladament els paràmetres anteriors com el nombre de gols i

victòries de cada equip i la possessió i la situació de la pilota al camp, a continuació es realitza un anàlisi general englobant els resultats obtinguts i les característiques de programació de cadascun dels dos equips. Les conclusions extretes són les següents:

1. A velocitats baixes (30-40-50) predomina la "intel·ligència" i l’intercanvi de posicions entre tots els jugadors de l’equip dinàmic per a controlar la pilota i així marcar un gran nombre de gols. Es poden veure molt bé els moviments de l’equip, les ajudes entre ells i els remats a porteria. En aquest cas s’imposa clarament l’atac amb tres jugadors mentre que l’equip pseudo-dinàmic només pot defensar amb 2 robots.

2. Quan la velocitat és 60, s’observa una igualtat entre els dos equips on no es pot dir que un s’imposi sobre l’altre. L’atac amb tres robots de l’equip dinàmic es compensa amb el defensor de pseudo-dinàmic situat al mig camp que intercepta la pilota. En aquesta velocitat ja es comença a veure que tots els jugadors no són tan precisos a l’hora de perseguir la pilota, de conduir-la o d’anar a un punt en concret.

3. A mesura que es va augmentant la velocitat (70-80), el domini de l’equip pseudo-dinàmic és bastant important a causa de la tàctica dels dos equips i de la gran velocitat de la pilota. Concretament, com que els rebots de la pilota contra la paret són bastant forts, quan els defenses pseudo-dinàmics l’allunyen de la seva àrea, aleshores es produeix un atac de dos robots contra un defensa dinàmic. És a dir, com que l’equip dinàmic ataca amb tres robots i a velocitats tan altes perden precisió, no són tan efectius per a fer gols i aleshores el pseudo-dinàmic aprofita per a guanyar amb superioritat numèrica al contraatac i marcar. En aquest cas, el joc se centra bàsicament als cantons del camp ja que cap equip pot conduir la pilota i és en aquestes zones on els defenses lluiten amb els davanters.

4. Finalment, si s’augmenta la velocitat fins a 90, en aquest cas no existeix ni tàctica ni assignació lògica dels comportaments entre els jugadors. Aquí ja no hi ha intel·ligència per culpa de la velocitat de la pilota i existeixen molts gols a pròpia porteria. Els robots no tenen precisió a l’hora de xutar la pilota i bàsicament els joc se centra en el moviment aleatori d’aquesta per tot el camp i els robots intentant tocar-la sense cap tàctica d’equip.


84

9 Conclusions finals En aquest projecte s’ha realitzat satisfactòriament la implementació de dues

tècniques de control distribuït de dos equips de futbol de robots sota l’entorn C++. Posteriorment, mitjançant la plataforma Robot Soccer s’ha comprovat que el comportament dels dos equips compleix amb l’objectiu proposat inicialment.

Aquest objectiu era poder aconseguir que els robots futbolistes tinguessin principis d’intel·ligència mostrant com es comunicaven entre ells decidint què fer en cada moment segons les condicions de joc i a partir d’una estratègia competitiva. Es volia que els robots no tinguessin un comportament preassignat des d’un principi com al futbol real, sinó que es volia aprofitar el fet que tots els robots són iguals per a que aquests intercanviessin els rols de davanter o defensa segons la situació del partit.

Aconseguir que els robots puguin comportar-se d’aquesta manera no ha estat fàcil. El problema ha estat la complexitat per a interrelacionar el gran nombre de funcions per tal que els robots realitzin els moviments correctes en cada moment evitant que hi hagi conflictes entre ells a l’hora de perseguir la pilota, d’atacar o defensar.

Altres aportacions, apart de les estrictament referents a la tàctica de l’equip i als moviments dels jugadors, ha estat poder realitzar un canvi de coordenades del sistema de referència predefinit inicialment pel Robot Soccer aconseguint que amb un mateix codi de programació es pugui jugar amb els dos equips. S’ha pogut variar la velocitat de joc sense necessitat de tornar a compilar el codi sinó que aquesta es llegeix des d’un fitxer de text extern i també, s’han pogut guardar els valors de les variables desitjades en un altre fitxer de text per tal de poder realitzar els anàlisis estadístics.

Pel que fa a la comparativa entre els dos equips programats, la diferència recau amb l’efectivitat de cadascun d’ells segons la velocitat de joc. Per a velocitats baixes l’equip predominant és l’equip dinàmic on l’atac amb tres davanters s’imposa als dos defensors pseudo-dinàmics, mentre que a velocitats altes l’equip pseudo-dinàmic s’aprofita del contraatac de dos jugadors contra un defensa dinàmic.

Com que l’objectiu final d’aquest projecte no és implementar un equip que realitzi el major nombre de gols sinó que és aconseguir un bon comportament global dels seus jugadors, es conclou que jugar a velocitats altes distorsiona el funcionament dels dos equips. És a dir, quan la velocitat de joc és elevada, no existeix cap tàctica ja que els jugadors intenten perseguir la pilota sense cap lògica i a causa de la seva velocitat perden tota la precisió. En aquesta situació, la gran velocitat de la pilota provoca problemes a l’hora d’assignar els comportaments als jugadors ja que aquests estan contínuament canviant. Per aquest motiu, l’elecció del millor equip s’ha avaluat a partir de les velocitats baixes.

Per tant, desprès de la programació dels dos equips i els posteriors enfrontaments entre ells, es conclou que és l’equip dinàmic el que ha donat les millors prestacions ja sigui a l’hora d’obtenir bons resultats com a l’hora d’aconseguir que el comportament entre tots els seus jugadors sigui òptim.


85

10 Bibliografia [1] Aníbal Ollero, Robótica manipuladores y robots móviles, Barcelona Marcombo Boixareu, 2001.

[2] G. Weiss, Multiagent Systems, M.I.T. Press, 2000.

[3] Gregory Dudek, Computational principlies of mobile robotics, Cambridge University Press, 2000.

[4] Antonio Barrientos, Fundamentos de robótica, Mc Graw-Hill, 1997.

[5] Marta Rodriguez Aguila, Control de robots mòbils des de robot soccer, Projecte Final de Carrera, Universitat Rovira i Virgili, 2007.

[6] Gonzalo Tejera, Proyecto FIBRA Estado del arte, Universidad de la República de Montevideo , 2006.

[7] Juan Pablo Ferrari, Sistemas de control distribuído, Universidad Nacional de Rosario, 2005.

[8] Victor García Castaño, Programació de comportaments per a un equip de cinc robots futbolistes reals, Projecte Final de Carrera, Universitat Rovira i Virgili, 2004.

[9] Néstor Adrián Balich, Aspectos básicos de robots autónomos y lineamientos para la construcción de un equipo de fútbol robótico, Universidad Abierta Interamericana, 2004.

[10] Pedro Salcedo Lagos, Inteligencia Artificial Distribuida y Razonamiento: conocimiento para la educación a distancia, Universidad de Concepción, 2004.

[11] S. González i E. Milanese, Equipo Simul-ARLT: El Fútbol de Robots como Entorno Educativo, Escuela de Educación Media Roberto Arlt, Buenos Aires, 2003.

[12] Bodey R. Baker, Mark Reynolds i Wei Liu, Strategy Specification for Teamwork in Robot Soccer, University of Western Australia, 2002.

[13] Luca Iocchi i Daniele Nardi, Distributed coordination in heterogeneous multi-robot systems, Kluwer Academic Publishers, 2002.

[14] Rubén Rodríguez Tamayo, Lenguaje ANSI C, Universidad de Navarra, 1998.

[15] Robot Soccer Simulator Inc, 3D Robot Soccer Simulator Help, Robot Soccer Simulator v1.5a, 2003.

[16] FIRA (Federation of International Robot-soccer Association): http://fira.net/soccer/simurosot/overview.html


86

11 Anexes

11.1 Codi programació Equip Dinàmic /////////////////////////////////////////////////////////////////////////////////////// //EQUIP DINAMIC /////////////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "Strategy.h" #include <math.h> #include <iostream> #include <fstream> using namespace std; BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { switch (ul_reason_for_call) { case DLL_PROCESS_ATTACH: case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; } const double PI = 3.1415923; /////////////////////////////////////////////////////////////////////////////////////// //funciones de las acciones void Velocity (Robot *robot, double vl, double vr); double Calculo_angulo_relativo (double dx, double dy, double R); void Ir_a_punto (Robot *robot, Environment *env, double punto_x, double punto_y); void Control_posicion (Environment *env,Robot *robot,double punto_x, double punto_y,double angulo_relativo); void Ir_a_punto_portero ( Robot *robot, Environment *env, double punto_x, double punto_y); void Control_posicion_portero (Environment *env,Robot *robot,double punto_x, double punto_y,double angulo_relativo); //funciones de las precondiciones int PEC (Environment *env); int MLP (Environment *env,int pelota); int CCP (Environment *env,int mejor_robot); void PredictBall (Environment *env); //funciones de los comportamientos void Portero (Robot *robot, Environment *env); void Interceptar_perseguir_pelota (Environment *env, int mejor_robot, int


87

mejor_oponente); void Rematar_perseguir_pelota (Robot *robot, Environment *env); int Posicionar_secundario (Environment *env, int mejor_robot); void Reubicar_robots (Environment *env, int mejor_robot, int secundario, int pelota); //funciones generales void Asignacion_comportamientos (Environment *env); void Cambio_coordenadas (Environment *env ); void Posesion_pelota (Environment *env); void Tiempo_campo (Environment *env); void Tiempo_zona (Environment *env); /////////////////////////////////////////////////////////////////////////////////////// extern "C" STRATEGY_API void Create ( Environment *env ) { // allocate user data and assign to env->userData // eg. env->userData = ( void * ) new MyVariables (); } extern "C" STRATEGY_API void Destroy ( Environment *env ) { // free any user data created in Create ( Environment * ) // eg. if ( env->userData != NULL ) delete ( MyVariables * ) env->userData; } extern "C" STRATEGY_API void Strategy ( Environment *env ) { Cambio_coordenadas (env); PredictBall (env); Posesion_pelota (env); Tiempo_lado (env); Tiempo_zona (env); Asignacion_comportamientos (env); } /////////////////////////////////////////////////////////////////////////////////////// void Ir_a_punto ( Robot *robot, Environment *env, double punto_x, double punto_y) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); double R = robot->rotation; double dx,dy; double angulo_relativo, distancia; double px,py,angulo,radio; //evitaremos que los robots defiendan dentro del area pequeña //distancia del punto hasta centro porteria (0,90) px = punto_x - 0; py = punto_y - 90; distancia = sqrt (px*px + py*py);


88

if (distancia < 30) { //calculamos el angulo if (py == 0) angulo = 0; else angulo = atan2(py,px); //colocaremos robot a un radio de 30cm del centro de la porteria radio = 30; //nuevas coordenadas donde se tiene que colocar el robot punto_x = radio * cos (angulo); punto_y = radio * sin (angulo) + 90; } //distancia del robot hasta el punto dx = robot->pos.x - punto_x; dy = robot->pos.y - punto_y; angulo_relativo = Calculo_angulo_relativo (dx,dy,R); distancia = sqrt(dx * dx + dy * dy); if (distancia > 2) Control_posicion (env,robot,punto_x,punto_y,angulo_relativo); else Velocity ( robot,0,0); fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Rematar_perseguir_pelota ( Robot *robot, Environment *env) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); double R = robot->rotation; double bx = env->predictedBall.pos.x; double by = env->predictedBall.pos.y; double dx,dy,angulo_relativo; double distancia; double px,py,angulo,radio; double ballX; //miramos sentido de la pelota ballX = env->predictedBall.pos.x - env->currentBall.pos.x; //evitaremos que los robots defiendan dentro del area pequeña //distancia del punto hasta centro porteria (0,90) px = bx - 0; py = by - 90; distancia = sqrt (px*px + py*py); if (distancia < 30 && env->home[0].pos.x < 30) {


89

//calculamos el angulo if (py == 0) angulo = 0; else angulo = atan2(py,px); //colocaremos robot a un radio de 30cm del centro de la porteria radio = 30; //nuevas coordenadas donde "estara" la pelota bx = radio * cos (angulo); by = radio * sin (angulo) + 90; } dx = robot->pos.x - bx; dy = robot->pos.y - by; angulo_relativo = Calculo_angulo_relativo (dx,dy,R); distancia = sqrt(dx * dx + dy * dy); //control en zona de ataque if ( robot->pos.x < 165 ) { if ( distancia<8.5 && dx<0 && robot->pos.y>30 && robot->pos.y<150 ) Ir_a_punto (robot,env,220,90); else Control_posicion (env,robot,bx,by,angulo_relativo); } else if ( robot->pos.x >= 165 && robot->pos.x < 205 ) { dx = robot->pos.x - env->predictedBall.pos.x; dy = robot->pos.y - env->predictedBall.pos.y; distancia = sqrt(dx * dx + dy * dy); if ( ballX <= 0 && distancia < 10 && robot->pos.y > 55 && robot->pos.y < 125) Velocity (robot,50,-50); else if ( distancia<10 && dx<0 && robot->pos.y>60 && robot->pos.y<120 ) { if (robot->pos.y <= env->predictedBall.pos.y) { if (robot->rotation > -75 && robot->rotation < 75) Velocity (robot,100,20); else if (robot->rotation > 135 && robot->rotation < -135) Velocity (robot,-20,-100); } else if (robot->pos.y > env->predictedBall.pos.y) { if (robot->rotation > -75 && robot->rotation < 75) Velocity (robot,20,100); else if (robot->rotation > 135 && robot->rotation < -135) Velocity (robot,-100,-20); } else Control_posicion (env,robot,bx,by,angulo_relativo); }


90

else Control_posicion (env,robot,bx,by,angulo_relativo); } else if ( robot->pos.x > 205 ) { if (distancia<12 && robot->pos.y>55 && robot->pos.y<125) { if (robot->pos.y>55 && robot->pos.y<90) { if (robot->rotation < 135 && robot->rotation > 75) Velocity (robot,100,20); else if (robot->rotation > -135 && robot->rotation < -75) Velocity (robot,-20,-100); } else if (robot->pos.y>90 && robot->pos.y<125) { if (robot->rotation < 135 && robot->rotation > 75) Velocity (robot,20,100); else if (robot->rotation > -135 && robot->rotation < -75) Velocity (robot,-100,-20); } else Control_posicion (env,robot,bx,by,angulo_relativo); } else Control_posicion (env,robot,bx,by,angulo_relativo); } else Control_posicion (env,robot,bx,by,angulo_relativo); fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Control_posicion (Environment *env,Robot *robot,double punto_x, double punto_y,double angulo_relativo) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); int i,players = 4,mejor_op=0,mejor_robot=0; int area=0,colision=0; double dx[4],dy[4],distancia[4]; double dxop[5],dyop[5],distanciaop[5]; double angulo_oponente,R; double px,py,dist; double dx_pelota,dy_pelota,distancia_pelota; double mejor_x,mejor_y,mejor_dx,mejor_dy,mejor_distancia; double corte_x,corte_y,distancia_corte; double corte_pelota_x,corte_pelota_y,distancia_corte_pelota; double robot_corte_x,robot_corte_y,distancia_robot_corte; double m1,b1,m2,b2,punto_corte_x,punto_corte_y; double vr,vl,delta,delta_right=0,delta_left=0; double vc,kpa=0.1,distancia_colision;


91

//******************************* //velocidad deseada de los robots // vc = FICHERO TEXTO; //******************************* ifstream ficher("c:\\Strategy\\vel_dinamic.txt"); ficher >>vc; //deteccion de obstaculos //distancia respecto a nuestros robots for (i=0;i<=players;i++) { if (env->home[i].pos.x != robot->pos.x && env->home[i].pos.y != robot->pos.y) { dx[i] = robot->pos.x - env->home[i].pos.x; dy[i] = robot->pos.y - env->home[i].pos.y; distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); } else distancia[i] = 300; } //buscamos a nuestro compañero mas cercano if (distancia[0] < distancia [1]) mejor_robot = 0; else mejor_robot = 1; if (distancia[mejor_robot] > distancia [2]) mejor_robot = 2; if (distancia[mejor_robot] > distancia [3]) mejor_robot = 3; if (distancia[mejor_robot] > distancia [4]) mejor_robot = 4; //distancia respecto a los oponentes for (i=0;i<=players;i++) { dxop[i] = robot->pos.x - env->opponent[i].pos.x; dyop[i] = robot->pos.y - env->opponent[i].pos.y; distanciaop[i] = sqrt (dxop[i]*dxop[i] + dyop[i]*dyop[i]); } //buscamos el oponente mas cercano if (distanciaop[0] < distanciaop[1]) mejor_op = 0; else mejor_op = 1; if (distanciaop[mejor_op] > distanciaop[2]) mejor_op = 2; if (distanciaop[mejor_op] > distanciaop[3]) mejor_op = 3; if (distanciaop[mejor_op] > distanciaop[4]) mejor_op = 4; //buscamos el robot mas cercano if (distancia[mejor_robot] < distanciaop[mejor_op]) { mejor_x = env->home[mejor_robot].pos.x; mejor_y = env->home[mejor_robot].pos.y; mejor_dx = dx[mejor_robot]; mejor_dy = dy[mejor_robot]; mejor_distancia = distancia[mejor_robot]; }


92

else { mejor_x = env->opponent[mejor_op].pos.x; mejor_y = env->opponent[mejor_op].pos.y; mejor_dx = dxop[mejor_op]; mejor_dy = dyop[mejor_op]; mejor_distancia = distanciaop[mejor_op]; } //control de obstaculos px = punto_x - robot->pos.x; py = punto_y - robot->pos.y; if ( px != 0 && py !=0 ) { m1 = py/px; //pendiente de la trayectoria del objetivo m2 = -1/m1; } else { m1 = 0; m2 = 0; } b1 = punto_y - m1 * punto_x; //termino independiente de la ecuacion del objetivo b2 = mejor_y - m2 * mejor_x; if ( m1 != 0 && m2 !=0 ) punto_corte_x = (b2 - b1)/(m1 - m2); else punto_corte_x = 0; punto_corte_y = m2 * punto_corte_x + b2; //trigonometricamente miramos si el "oponente" esta entre el robot y el objetivo //distancia del oponente mas cercano a la trayectoria del robot corte_x = punto_corte_x - mejor_x; corte_y = punto_corte_y - mejor_y; distancia_corte = sqrt (corte_x*corte_x + corte_y*corte_y); //distancia del punto de corte al objetivo corte_pelota_x = punto_corte_x - punto_x; corte_pelota_y = punto_corte_y - punto_y; distancia_corte_pelota = sqrt (corte_pelota_x*corte_pelota_x + corte_pelota_y*corte_pelota_y); //distancia del robot al punto de corte robot_corte_x = punto_corte_x - robot->pos.x; robot_corte_y = punto_corte_y - robot->pos.y; distancia_robot_corte = sqrt (robot_corte_x*robot_corte_x + robot_corte_y*robot_corte_y); //distancia del robot respecto al objetivo dx_pelota = robot->pos.x - punto_x; dy_pelota = robot->pos.y - punto_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota);


93

//miramos si se cumplen las condiciones para tener colision colision =0; if (distancia_corte < 20) { if (distancia_corte_pelota > 0 && distancia_robot_corte > 0) { if (distancia_pelota == distancia_robot_corte + distancia_corte_pelota) colision = 1; } } //distancia y delta deseada para evitar colision if (distancia_pelota < 10) { distancia_colision = 50; delta = 40; } else { distancia_colision = 30; delta = 20; } //evitaremos el robot entre en el area pequeña //distancia del punto hasta centro porteria (0,90) px = robot->pos.x - 0; py = robot->pos.y - 90; dist = sqrt (px*px + py*py); if (dist <= 30) area = 1; //controlador de velocidad segun la distancia,angulo,oponentes y portero //valor de kpa segun la distancia al objetivo if (distancia_pelota > 100.) kpa = 0.19; else if (distancia_pelota > 50) kpa = 0.21; else if (distancia_pelota > 30) kpa = 0.24; else if (distancia_pelota > 20) kpa = 0.26; else kpa = 0.28; if (angulo_relativo < 85 && angulo_relativo > -85) //el robot ataca de frente a la pelota { //control de colisiones y area pequeña if (area == 1) { if (env->predictedBall.pos.y > robot->pos.y) delta_left = delta; else delta_right = delta; } //control de area pequeña


94

else if (mejor_distancia < distancia_colision && colision == 1) { //miramos el sentido de giro del robot R = robot->rotation; angulo_oponente = Calculo_angulo_relativo (mejor_dx,mejor_dy,R); if (angulo_oponente < 85 && angulo_oponente > -85) { if (angulo_relativo < angulo_oponente) delta_left = delta; else if (angulo_relativo == angulo_oponente) { if (robot->pos.y <= 110) delta_left = delta; else delta_right = delta; } else if (angulo_relativo > angulo_oponente) delta_right = delta; } } //calculamos la velocidad (distancia,angulo relativo y delta) vr = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) + kpa * angulo_relativo) + delta_right; vl = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) - kpa * angulo_relativo) + delta_left; //control de velocidad en caso de "lucha" con un robot nuestro dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.y - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia[mejor_robot]<20 && distancia_pelota<12 && dx_pelota>0 && dx[mejor_robot]>0 && robot->pos.x>10) { if ( env->predictedBall.pos.y <= 90 ) { vl=-50; vr=-10; } else if ( env->predictedBall.pos.y > 90 ) { vl=-10; vr=-50; } } else if (distancia[mejor_robot]<20 && distancia_pelota<12 && robot->pos.x<=10) { if (env->predictedBall.pos.y <= 90 && dy_pelota<0 && dy[mejor_robot]<0) { vl=-50; vr=-10; } else if (env->predictedBall.pos.y > 90 && dy_pelota>0 && dy[mejor_robot]>0) {


95

vl=-10; vr=-50; } } } else if (angulo_relativo > 95 || angulo_relativo < -95) //el robot ataca de espaldas a la pelota { //control de colisiones y area pequeña if (area == 1) { if (env->predictedBall.pos.y > robot->pos.y) delta_right = delta; else delta_left = delta; } else if (mejor_distancia < distancia_colision && colision == 1) { //miramos el sentido de giro del robot R = robot->rotation; angulo_oponente = Calculo_angulo_relativo (mejor_dx,mejor_dy,R); if (angulo_oponente > 95 || angulo_oponente < -95) { if (angulo_oponente < 0) angulo_oponente += 360; if (angulo_relativo < 0) angulo_relativo += 360; if (angulo_relativo < angulo_oponente) delta_right = delta; else if (angulo_relativo == angulo_oponente) { if (robot->pos.y <= 110) delta_right = delta; else delta_left = delta; } else if (angulo_relativo > angulo_oponente) delta_left = delta; if (angulo_oponente > 180) angulo_oponente -= 360; if (angulo_relativo > 180) angulo_relativo -= 360; } } angulo_relativo += 180; if (angulo_relativo > 180) angulo_relativo -= 360; angulo_oponente += 180; if (angulo_oponente > 180) angulo_oponente -= 360; //calculamos la velocidad (distancia,angulo relativo y delta) vr = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) + kpa * angulo_relativo) - delta_right; vl = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) - kpa * angulo_relativo) - delta_left; //control de velocidad en caso de "lucha" con un robot nuestro


96

dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.y - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia[mejor_robot]<20 && distancia_pelota<12 && dx_pelota>0 && dx[mejor_robot]>0 && robot->pos.x>10) { if ( env->predictedBall.pos.y <= 90 ) { vl=10; vr=50; } else if ( env->predictedBall.pos.y > 90 ) { vl=50; vr=10; } } else if (distancia[mejor_robot]<20 && distancia_pelota<12 && robot->pos.x<=10) { if (env->predictedBall.pos.y <= 90 && dy_pelota<0 && dy[mejor_robot]<0) { vl=10; vr=50; } else if (env->predictedBall.pos.y > 90 && dy_pelota>0 && dy[mejor_robot]>0) { vl=50; vr=10; } } } else { if (angulo_relativo <= 95 && angulo_relativo >= 85) { vr = (+.5 * angulo_relativo); vl = (-.5 * angulo_relativo); } else if (angulo_relativo >= -95 && angulo_relativo <= -85) { vl = (+.5 * angulo_relativo); vr = (-.5 * angulo_relativo); } } Velocity ( robot,vl,vr ); fichero.close(); ficher.close(); } ///////////////////////////////////////////////////////////////////////////////////////


97

void Ir_a_punto_portero ( Robot *robot, Environment *env, double punto_x, double punto_y) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); double R = robot->rotation; double dx,dy; double angulo_relativo, distancia; //distancia del robot hasta el punto dx = robot->pos.x - punto_x; dy = robot->pos.y - punto_y; angulo_relativo = Calculo_angulo_relativo (dx,dy,R); distancia = sqrt(dx * dx + dy * dy); if (distancia > 2) Control_posicion_portero (env,robot,punto_x,punto_y, angulo_relativo); else Velocity (robot,0,0); fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Control_posicion_portero (Environment *env,Robot *robot,double punto_x, double punto_y,double angulo_relativo) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); double dx_pelota,dy_pelota,distancia_pelota; double vr,vl; double vc,kpa=0.1; //******************************* //velocidad deseada de los robots vc = 70; //******************************* //distancia del robot respecto a la pelota dx_pelota = robot->pos.x - punto_x; dy_pelota = robot->pos.y - punto_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); //controlador de velocidad segun la distancia,angulo,oponentes y portero //valor de kpa segun la distancia al objetivo if (distancia_pelota > 100.) kpa = 0.19; else if (distancia_pelota > 50) kpa = 0.21; else if (distancia_pelota > 30) kpa = 0.24; else if (distancia_pelota > 20) kpa = 0.26; else kpa = 0.28; if (angulo_relativo < 85 && angulo_relativo > -85) //el robot ataca de frente a la pelota {


98

//calculamos la velocidad (distancia,angulo relativo y delta) vr = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) + kpa * angulo_relativo); vl = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) - kpa * angulo_relativo); } else if (angulo_relativo > 95 || angulo_relativo < -95) //el robot ataca de espaldas a la pelota { angulo_relativo += 180; if (angulo_relativo > 180) angulo_relativo -= 360; //calculamos la velocidad (distancia,angulo relativo y delta) vr = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) + kpa * angulo_relativo); vl = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota))) - kpa * angulo_relativo); } else { if (angulo_relativo <= 95 && angulo_relativo >= 85) { vr = (+.5 * angulo_relativo); vl = (-.5 * angulo_relativo); } else if (angulo_relativo >= -95 && angulo_relativo <= -85) { vl = (+.5 * angulo_relativo); vr = (-.5 * angulo_relativo); } } Velocity ( robot,vl,vr ); fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Velocity ( Robot *robot, double vl, double vr ) { robot->velocityRight = vr; robot->velocityLeft = vl; } /////////////////////////////////////////////////////////////////////////////////////// void PredictBall ( Environment *env ) { double dx_p = env->currentBall.pos.x - env->lastBall.pos.x; double dy_p = env->currentBall.pos.y - env->lastBall.pos.y; env->predictedBall.pos.x = env->currentBall.pos.x + dx_p; env->predictedBall.pos.y = env->currentBall.pos.y + dy_p; } ///////////////////////////////////////////////////////////////////////////////////////


99

void Cambio_coordenadas (Environment *env) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); int i; double factor_escala = 220/(FRIGHTX - FLEFTX); //pasamos de pulgadas a cm if (env->home[0].pos.x < 50) //equipo amarillo { env->predictedBall.pos.x = (env->predictedBall.pos.x - FLEFTX) * factor_escala; env->predictedBall.pos.y = (env->predictedBall.pos.y - FBOT) * factor_escala; env->currentBall.pos.x = (env->currentBall.pos.x - FLEFTX) * factor_escala; env->currentBall.pos.y = (env->currentBall.pos.y - FBOT) * factor_escala; env->lastBall.pos.x = (env->lastBall.pos.x - FLEFTX) * factor_escala; env->lastBall.pos.y = (env->lastBall.pos.y - FBOT) * factor_escala; for (i=0;i<5;i++) { env->home[i].pos.x = (env->home[i].pos.x - FLEFTX) * factor_escala; env->home[i].pos.y = (env->home[i].pos.y - FBOT) * factor_escala; env->opponent[i].pos.x = (env->opponent[i].pos.x - FLEFTX) * factor_escala; env->opponent[i].pos.y = (env->opponent[i].pos.y - FBOT) * factor_escala; } } else //(env->home[0].pos.x > 50) equipo azul { env->predictedBall.pos.x = (FRIGHTX - env->predictedBall.pos.x) * factor_escala; env->predictedBall.pos.y = (FTOP - env->predictedBall.pos.y) * factor_escala; env->currentBall.pos.x = (FRIGHTX - env->currentBall.pos.x) * factor_escala; env->currentBall.pos.y = (FTOP - env->currentBall.pos.y) * factor_escala; env->lastBall.pos.x = (FRIGHTX - env->lastBall.pos.x) * factor_escala; env->lastBall.pos.y = (FTOP - env->lastBall.pos.y) * factor_escala; for (i=0;i<5;i++) { env->home[i].pos.x = (FRIGHTX - env->home[i].pos.x) * factor_escala; env->home[i].pos.y = (FTOP - env->home[i].pos.y) * factor_escala; env->home[i].rotation = env->home[i].rotation - 180; env->opponent[i].pos.x = (FRIGHTX - env->opponent[i].pos.x) * factor_escala; env->opponent[i].pos.y = (FTOP - env->opponent[i].pos.y) * factor_escala; env->opponent[i].rotation = env->opponent[i].rotation - 180; if (env->home[i].rotation < -180) env->home[i].rotation += 360; if (env->opponent[i].rotation < -180) env->opponent[i].rotation += 360; } } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// double Calculo_angulo_relativo (double dx, double dy, double R)


100

{ double angulo_obstaculo, angulo_relativo, variable; if ( dx == 0 ) { if ( dy > 0 ) angulo_obstaculo = -90; else angulo_obstaculo = 90; } else if ( dy == 0 ) { if ( dx > 0 ) angulo_obstaculo = 180; else angulo_obstaculo = 0; } else { angulo_obstaculo = atan2(fabs(dy),fabs(dx))*(180.0/ PI); //angulo segun cuadrante if ( dx > 0 ) { if ( dy > 0 ) angulo_obstaculo = angulo_obstaculo + 180; else if ( dy < 0 ) angulo_obstaculo = 180 - angulo_obstaculo; } else // dx < 0 { if ( dy > 0 ) angulo_obstaculo = - angulo_obstaculo; else if ( dy < 0 ) angulo_obstaculo = angulo_obstaculo; } } while ( angulo_obstaculo < -180 ) angulo_obstaculo += 360; while ( angulo_obstaculo > 180 ) angulo_obstaculo -= 360; angulo_relativo = ( angulo_obstaculo - R ); if ( dx > 0 ) { if ( dy > 0 ) { variable = angulo_obstaculo + 180; if (R > variable ) angulo_relativo += 360; } else { variable = angulo_obstaculo - 180; if (R < variable ) angulo_relativo -= 360; } } return (angulo_relativo); } /////////////////////////////////////////////////////////////////////////////////////// int PEC (Environment *env)


101

{//A_pelota_nuestro_campo. 0->zona area, 1->medio campo, 2->area contraria int pelota; if (env->predictedBall.pos.x <= 40) pelota = 0; //zona de nuestra area else if (env->predictedBall.pos.x > 40 && env->predictedBall.pos.x <= 165) pelota = 1; //pelota en el medio del campo else if (env->predictedBall.pos.x > 165) pelota = 2; //zona area contraria return(pelota); } /////////////////////////////////////////////////////////////////////////////////////// int MLP (Environment *env) {//D_mejor_llegar_pelota. env->home[i]== 1 a 4; ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); int i,players=4; int mejor_robot,cercanos_pelota=0; int robot_cercano1=0,robot_cercano2=0,robot_cercano3=0,robot_cercano4=0; double bx = env->predictedBall.pos.x; double by = env->predictedBall.pos.y; double dx[4],dy[4],distancia[4]; for (i=1;i<=players;i++) { dx[i] = env->home[i].pos.x - env->predictedBall.pos.x; dy[i] = env->home[i].pos.y - env->predictedBall.pos.y; distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); } bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //miramos los robots mas cercanos a la pelota if (dx[1]<0 || dx[2]<0 || dx[3]<0 || dx[4]<0) { for (i=1;i<=players;i++) { if ( dx[i]>0 && distancia[i]>20 && env->predictedBall.pos.x<185) distancia[i] = 300; if (distancia[i] <= 20) { cercanos_pelota++; if (cercanos_pelota == 1) robot_cercano1 = i; if (cercanos_pelota == 2) robot_cercano2 = i; if (cercanos_pelota == 3) robot_cercano3 = i; if (cercanos_pelota == 4) robot_cercano4 = i; } } }


102

//escogemos el robot mejor situado if (cercanos_pelota == 1) mejor_robot = robot_cercano1; else if (cercanos_pelota > 1) { if (dx[robot_cercano1] < 0 && dx[robot_cercano2] < 0) { if (distancia[robot_cercano1] < distancia [robot_cercano2]) mejor_robot = robot_cercano1; else mejor_robot = robot_cercano2; } else if (dx[robot_cercano1] > 0 && dx[robot_cercano2] > 0) { if (distancia[robot_cercano1] < distancia [robot_cercano2]) mejor_robot = robot_cercano1; else mejor_robot = robot_cercano2; } else { if (dx[robot_cercano1] < 0) mejor_robot = robot_cercano1; else mejor_robot = robot_cercano2; } if (cercanos_pelota > 2) { if (dx[mejor_robot] < 0 && dx[robot_cercano3] < 0) { if (distancia[mejor_robot] > distancia [robot_cercano3]) mejor_robot = robot_cercano3; } else if (dx[mejor_robot] > 0 && dx[robot_cercano3] > 0) { if (distancia[mejor_robot] > distancia [robot_cercano3]) mejor_robot = robot_cercano3; } else { if (dx[robot_cercano3] < 0) mejor_robot = robot_cercano3; } } if (cercanos_pelota > 3) { if (dx[mejor_robot] < 0 && dx[robot_cercano4] < 0) { if (distancia[mejor_robot] > distancia [robot_cercano4]) mejor_robot = robot_cercano4; } else if (dx[mejor_robot] > 0 && dx[robot_cercano4] > 0)


103

{ if (distancia[mejor_robot] > distancia [robot_cercano4]) mejor_robot = robot_cercano4; } else { if (dx[robot_cercano4] < 0) mejor_robot = robot_cercano4; } } } else if (cercanos_pelota == 0) { if (distancia[1] < distancia [2]) mejor_robot = 1; else mejor_robot = 2; if (distancia[mejor_robot] > distancia [3]) mejor_robot = 3; if (distancia[mejor_robot] > distancia [4]) mejor_robot = 4; } fichero.close(); return (mejor_robot); } /////////////////////////////////////////////////////////////////////////////////////// int CCP (Environment *env, int mejor_robot) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); int i,players = 4; int mejor_op,peligro = 0; double dx_robot,dy_robot,distancia_robot; double dx_op[4],dy_op[4],distancia_op[4]; //distancias de los oponentes a la pelota for (i=1;i<=players;i++) { dx_op[i] = env->opponent[i].pos.x - env->predictedBall.pos.x; dy_op[i] = env->opponent[i].pos.y - env->predictedBall.pos.y; distancia_op[i] = sqrt (dx_op[i]*dx_op[i] + dy_op[i]*dy_op[i]); //robot por delante y cerca de la pelota y mas alla de nuestra area if (dx_op[i] > 0 && env->opponent[i].pos.x > 40 && distancia_op[i] < 20) peligro++; else distancia_op[i] = 300; } if (peligro!=0) //algun oponente esta bien posicionado


104

{ //buscamos el oponente mas "peligroso" a la pelota if (distancia_op[1] < distancia_op[2]) mejor_op = 1; else mejor_op = 2; if (distancia_op[mejor_op] > distancia_op[3]) mejor_op = 3; if (distancia_op[mejor_op] > distancia_op[4]) mejor_op = 4; //distancia de nuestro mejor robot a la pelota dx_robot = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy_robot = env->home[mejor_robot].pos.y - env->predictedBall.pos.y; distancia_robot = sqrt(dx_robot*dx_robot + dy_robot*dy_robot); //comparamos con nuestro mejor robot if (distancia_robot < distancia_op[mejor_op]) mejor_op = -1; } else //no hay "peligro" mejor_op = -1; fichero.close(); return (mejor_op); } /////////////////////////////////////////////////////////////////////////////////////// void Interceptar_perseguir_pelota (Environment *env, int mejor_robot, int mejor_oponente) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); double m,b,bx,by; double ballX,ballY; double punto_corte_x,punto_corte_y; double dx,dy,distancia; double dx_pelota,dy_pelota,distancia_pelota; bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; ballX = bx - env->currentBall.pos.x; ballY = by - env->currentBall.pos.y; //calculamos la distancia entre el mejor robot y la pelota dx = env->home[mejor_robot].pos.x - bx; dy = env->home[mejor_robot].pos.y - by; distancia = sqrt (dx*dx + dy*dy); //la pelota viene hacia nuestra porteria con un oponente //nuestro mejor robot esta detras y cerca de la pelota if( ballX < 0 && dx < 0 && distancia < 50 && mejor_oponente != -1)


105

{ bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m=0; b = by - m * bx; //termino independiente de la ecuacion de la pelota punto_corte_x = env->home[mejor_robot].pos.x; punto_corte_y = m * punto_corte_x + b; //distancia entre el mejor robot y el punto de corte dx = env->home[mejor_robot].pos.x - punto_corte_x; dy = env->home[mejor_robot].pos.y - punto_corte_y; distancia = sqrt (dx*dx + dy*dy); //distancia entre la pelota y el punto de corte dx_pelota = env->predictedBall.pos.x - punto_corte_x; dy_pelota = env->predictedBall.pos.y - punto_corte_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia_pelota < 10 && fabs(dx) < 2 && fabs(dy) < 2) //Raqueteo Velocity (&env->home[mejor_robot],-50,50); else Ir_a_punto (&env->home[mejor_robot],env,punto_corte_x,punto_corte_y); } else { Rematar_perseguir_pelota ( &env->home[mejor_robot],env ); } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// int Posicionar_secundario (Environment *env, int mejor_robot) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); int mejor_secundario,delante_pelota=0; int i,players = 4; double bx = env->predictedBall.pos.x; double by = env->predictedBall.pos.y; double dx[4],dy[4],distancia[4]; double ballX,ballY,angulo; double dist,x=0,y=0,radio,px,py; double m,b,d; double punto_corte_x=0,punto_corte_y=0; double dx_corte,dy_corte,distancia_corte; //miramos la direccion de la pelota


106

ballX = bx - env->currentBall.pos.x; ballY = by - env->currentBall.pos.y; //calculamos la distancia entre el mejor robot y la pelota dx[mejor_robot] = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy[mejor_robot] = env->home[mejor_robot].pos.y - env->predictedBall.pos.y; distancia[mejor_robot] = sqrt (dx[mejor_robot]*dx[mejor_robot] + dy[mejor_robot]*dy[mejor_robot]); bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //buscamos el secundario mas cercano a la pelota for (i=1;i<=players;i++) { if ( i != mejor_robot) { dx[i] = env->home[i].pos.x - env->predictedBall.pos.x; dy[i] = env->home[i].pos.y - env->predictedBall.pos.y; distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); } else distancia[i] = 300; } if (distancia[1] < distancia [2]) mejor_secundario = 1; else mejor_secundario = 2; if (distancia[mejor_secundario] > distancia [3]) mejor_secundario = 3; if (distancia[mejor_secundario] > distancia [4]) mejor_secundario = 4; bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; dx[mejor_robot] = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy[mejor_robot] = env->home[mejor_robot].pos.y - env->predictedBall.pos.y; distancia[mejor_robot] = sqrt (dx[mejor_robot]*dx[mejor_robot] + dy[mejor_robot]*dy[mejor_robot]); //la pelota viene hacia nuestra porteria con nuestro robot y el secundario detras pelota if( ballX < 0 && distancia[mejor_robot] < 15 && dx[mejor_robot] > 0 && dx[mejor_secundario] < 0 ) { d = env->home[mejor_robot].pos.y - env->home[mejor_secundario].pos.y; if( fabs(d) < 40 ) { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 )


107

m = ballY/ballX; //pendiente de la trayectoria de la pelota else m = 0; b = by - m * bx; //termino independiente de la ecuacion de la pelota //calculamos el punto de corte del mejor secundario punto_corte_x = env->home[mejor_secundario].pos.x; punto_corte_y = m * punto_corte_x + b; //distancia entre el mejor secundario y el punto de corte dx_corte = env->home[mejor_secundario].pos.x - punto_corte_x; dy_corte = env->home[mejor_secundario].pos.y - punto_corte_y; distancia_corte = sqrt (dx_corte*dx_corte + dy_corte*dy_corte); if (distancia_corte < 15 && fabs(dx_corte) < 2 && fabs(dy_corte) < 2) //Raqueteo Velocity (&env->home[mejor_secundario],-50,50); else Ir_a_punto (&env->home[mejor_secundario],env,punto_corte_x, punto_corte_y); } else Rematar_perseguir_pelota ( &env->home[mejor_secundario],env ); } else { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //distancia de la pelota hasta centro porteria (0,90) px = bx - 0; py = by - 90; dist = sqrt (px*px + py*py); bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //calculamos el angulo if (py == 0) angulo = 0; else angulo = atan2(py,px); //colocaremos el secundario a la mitad de distancia radio = dist/2; if (radio < 30) radio = 30; //coordenadas donde se tiene que colocar el secundario x = radio * cos (angulo); y = radio * sin (angulo) + 90; for (i=1;i<=players;i++) { if ( i != mejor_robot)


108

{ dx[i] = env->home[i].pos.x - x; dy[i] = env->home[i].pos.y - y; distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); } else distancia [i] = 300; } if (distancia[1] < distancia [2]) mejor_secundario = 1; else mejor_secundario = 2; if (distancia[mejor_secundario] > distancia [3]) mejor_secundario = 3; if (distancia[mejor_secundario] > distancia [4]) mejor_secundario = 4; if (dist < 40 && fabs(dx[mejor_secundario])<2 && fabs(dy[mejor_secundario])<2) //Raqueteo Velocity (&env->home[mejor_secundario],-50,50); else Ir_a_punto (&env->home[mejor_secundario],env,x,y); } fichero.close(); return (mejor_secundario); } /////////////////////////////////////////////////////////////////////////////////////// void Reubicar_robots (Environment *env, int mejor_robot, int secundario, int pelota) {//0->zona area, 1->medio campo, 2->area contraria ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); int tercer,cuarto; int mejor_op,vc,limite; int i,players = 4; double ballX,ballY; double dx[4],dy[4],distancia[4]; double dx_op[4],dy_op[4],distancia_op[4]; double m,d,b,bx,by,px,py; double punto_corte_x=0,punto_corte_y=0; double dx_corte,dy_corte,distancia_corte; //buscamos el robot mas cercano a la pelota for (i=1;i<=players;i++) { if (i == mejor_robot) distancia[i] = 300; else if (i == secundario) distancia[i] = 300;


109

else { dx[i] = env->home[i].pos.x - env->predictedBall.pos.x; dy[i] = env->home[i].pos.y - env->predictedBall.pos.y; distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); } } //asignamos el tercer robot if (distancia[1] < distancia[2]) tercer = 1; else tercer = 2; if (distancia[tercer] > distancia[3]) tercer = 3; if (distancia[tercer] > distancia[4]) tercer = 4; //asignamos el cuarto robot cuarto = 10 - mejor_robot - secundario - tercer; dx[tercer] = env->home[tercer].pos.x - env->predictedBall.pos.x; dy[tercer] = env->home[tercer].pos.y - env->predictedBall.pos.y; distancia[tercer] = sqrt (dx[tercer]*dx[tercer] + dy[tercer]*dy[tercer]); //oponente mas cercano al tercer robot for (i=1;i<=players;i++) { dx_op[i] = env->opponent[i].pos.x - env->home[tercer].pos.x; dy_op[i] = env->opponent[i].pos.y - env->home[tercer].pos.y; distancia_op[i] = sqrt (dx_op[i]*dx_op[i] + dy_op[i]*dy_op[i]); if (dx[tercer] < 0 && dx_op[i] > 0) distancia_op[i] = 300; else if (dx[tercer] > 0 && dx_op[i] < 0) distancia_op[i] = 300; else if (distancia[tercer] < 30) distancia_op[i] = 300; } if (distancia_op[1] < distancia_op[2]) mejor_op = 1; else mejor_op = 2; if (distancia_op[mejor_op] > distancia_op[3]) mejor_op = 3; if (distancia_op[mejor_op] > distancia_op[4]) mejor_op = 4; dx[mejor_robot] = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy[mejor_robot] = env->home[mejor_robot].pos.y - env->predictedBall.pos.y; distancia[mejor_robot] = sqrt (dx[mejor_robot]*dx[mejor_robot] + dy[mejor_robot]*dy[mejor_robot]);


110

//ubicamos el tercer robot if (distancia_op[mejor_op] != 300 && env->predictedBall.pos.x < 110 && env->home[tercer].pos.x < 110) { //tercer intercepta un robot contrario //pendiente para interceptar oponente con el tercer robot bx = env->opponent[mejor_op].pos.x; by = env->opponent[mejor_op].pos.y; ballX = bx - env->predictedBall.pos.x; ballY = by - env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m = 0; b = by - m * bx; //termino independiente de la ecuacion de la pelota //calculamos el punto de corte con el oponente punto_corte_x = env->home[tercer].pos.x; punto_corte_y = m * punto_corte_x + b; if (punto_corte_x < 40) punto_corte_x = 40; if (punto_corte_y < 15) punto_corte_y = 15; if (punto_corte_y > 165) punto_corte_y = 165; Ir_a_punto (&env->home[tercer],env,punto_corte_x,punto_corte_y); } else { //acompañamos a nuestro mejor robot //miramos el sentido de la pelota bx = env->currentBall.pos.x; by = env->currentBall.pos.y; ballX = env->predictedBall.pos.x - bx; ballY = env->predictedBall.pos.y - by; if ((pelota == 0) || (pelota == 1 && ballX > 0)) { if (env->predictedBall.pos.y <= env->home[tercer].pos.y) { px = env->predictedBall.pos.x; py = env->predictedBall.pos.y + 30; if (px < 40) px = 40; if (py > 165) py = 165; } else if (env->predictedBall.pos.y > env->home[tercer].pos.y) { px = env->predictedBall.pos.x; py = env->predictedBall.pos.y - 30; if (px < 40) px = 40; if (py < 15) py = 15; }


111

Ir_a_punto (&env->home[tercer],env,px,py); } else if (pelota == 2) { //leemos la velocidad deseada de los robots del fichero de texto ifstream ficher("c:\\Strategy\\vel_estatic.txt"); ficher >> vc; if (vc == 20) limite = 65; else if (vc == 30) limite = 60; else if (vc == 40) limite = 55; else if (vc == 50) limite = 50; else if (vc == 60) limite = 50; else if (vc == 70) limite = 45; else if (vc == 80) limite = 45; else if (vc == 90) limite = 30; else if (vc >= 100) limite = 30; else limite = 50; if (env->predictedBall.pos.y > 90) { if (env->predictedBall.pos.y < limite || env->predictedBall.pos.y > (180-limite)) Ir_a_punto (&env->home[tercer],env,185,105); else { if (env->home[mejor_robot].pos.y>60 && env->home[mejor_robot].pos.y < 120 && env->home[mejor_robot].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,105); else if (env->home[secundario].pos.y>60 && env->home[secundario].pos.y<120 && env->home[secundario].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,105); else if (env->home[cuarto].pos.y >60 && env->home[cuarto].pos.y < 120 && env->home[cuarto].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,105); else Rematar_perseguir_pelota (&env->home[tercer],env); } } else { if (env->predictedBall.pos.y < limite || env->predictedBall.pos.y > (180-limite)) Ir_a_punto (&env->home[tercer],env,185,75); else { if (env->home[mejor_robot].pos.y>60 && env->home[mejor_robot].pos.y<120 && env->home[mejor_robot].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,75); else if (env->home[secundario].pos.y>60 && env->home[secundario].pos.y<120 && env->home[secundario].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,75); else if (env->home[cuarto].pos.y>60 && env->home[cuarto].pos.y<120 && env->home[cuarto].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,75); else Rematar_perseguir_pelota (&env->home[tercer],env);


112

} } } else { //la pelota viene hacia nuestra porteria con nuestro robot y el tercer robot detras pelota if( ballX < 0 && distancia[mejor_robot] < 15 && dx[mejor_robot] > 0 && dx[tercer] < 0 ) { //tercer intercepta a nuestro mejor robot d = env->home[mejor_robot].pos.y - env->home[tercer].pos.y; if( fabs(d) < 40 ) { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m = 0; b = by - m * bx; //termino independiente ecuacion de la pelota //calculamos el punto de corte del tercer robot punto_corte_x = env->home[tercer].pos.x; punto_corte_y = m * punto_corte_x + b; //distancia entre el tercer robot y el punto de corte dx_corte = env->home[tercer].pos.x - punto_corte_x; dy_corte = env->home[tercer].pos.y - punto_corte_y; distancia_corte = sqrt (dx_corte*dx_corte + dy_corte*dy_corte); if (distancia_corte < 15 && fabs(dx_corte)<2 && fabs(dy_corte)< 2) //Raqueteo Velocity (&env->home[tercer],-50,50); else Ir_a_punto (&env-home[tercer],env,punto_corte_x,punto_corte_y); } else { Rematar_perseguir_pelota ( &env->home[tercer],env ); } } else { Rematar_perseguir_pelota ( &env->home[tercer],env ); } } } //ubicacion el cuarto robot segun situacion de la pelota if (pelota == 0) {


113

if (env->predictedBall.pos.y <= 90) { px = env->predictedBall.pos.x + 50; py = env->predictedBall.pos.y + 30; if (px < 110) px = 110; } else if (env->predictedBall.pos.y > 90) { px = env->predictedBall.pos.x + 50; py = env->predictedBall.pos.y - 30; if (px < 110) px = 110; } Ir_a_punto (&env->home[cuarto],env,px,py); } else if (pelota == 1) { if (env->predictedBall.pos.y <= 90) { px = env->predictedBall.pos.x + 50; py = env->predictedBall.pos.y + 30; if (px < 110) px = 110; if (px > 185) { px = 185; py = 75; } } else if (env->predictedBall.pos.y > 90) { px = env->predictedBall.pos.x + 50; py = env->predictedBall.pos.y - 30; if (px < 110) px = 110; if (px > 185) { px = 185; py = 105; } } Ir_a_punto (&env->home[cuarto],env,px,py); } else if (pelota == 2) { //leemos la velocidad deseada de los robots del fichero de texto ifstream ficher("c:\\Strategy\\vel_estatic.txt"); ficher >> vc; if (vc == 20) limite = 65;


114

else if (vc == 30) limite = 60; else if (vc == 40) limite = 55; else if (vc == 50) limite = 50; else if (vc == 60) limite = 50; else if (vc == 70) limite = 45; else if (vc == 80) limite = 45; else if (vc == 90) limite = 30; else if (vc >= 100) limite = 30; else limite = 50; if (env->predictedBall.pos.y < limite || env->predictedBall.pos.y > (180-limite)) Ir_a_punto (&env->home[cuarto],env,182.5,90); else { if (env->home[mejor_robot].pos.y>60 && env->home[mejor_robot].pos.y<120 && env->home[mejor_robot].pos.x>200) Ir_a_punto (&env->home[cuarto],env,182.5,90); else if (env->home[secundario].pos.y>60 && env->home[secundario].pos.y<120 && env->home[secundario].pos.x>200) Ir_a_punto (&env->home[cuarto],env,182.5,90); else if (env->home[tercer].pos.y>60 && env->home[tercer].pos.y<120 && env->home[tercer].pos.x>200) Ir_a_punto (&env->home[cuarto],env,182.5,90); else Rematar_perseguir_pelota (&env->home[cuarto],env); } } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Portero ( Robot *robot, Environment *env ) { ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); double R = robot->rotation; double ballX,ballY; double m,b,bx,by,angulo_relativo; double punto_corte_x,punto_corte_y; double dx,dy,distancia,vr,vl; double dx_pelota,dy_pelota,distancia_pelota; //miramos sentido de la pelota ballX = env->predictedBall.pos.x - env->currentBall.pos.x; bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //distancia entre la pelota y el portero dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.x - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota);


115

//la pelota esta en nuestro lateral if ( bx < 10 && (by < 70 || by > 110) ) { //distancia entre la pelota y el portero dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.y - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (by < 65 && distancia_pelota > 20) Ir_a_punto_portero (&env->home[0],env,5,70); else if (by > 115 && distancia_pelota > 20) Ir_a_punto_portero (&env->home[0],env,5,110); else { angulo_relativo = Calculo_angulo_relativo (dx_pelota,dy_pelota,R); if (distancia_pelota < 20 && by > 50 && by < 130 ) { if (angulo_relativo < 85 && angulo_relativo > -85) { vr = 100; vl = 100; } else if (angulo_relativo > 95 || angulo_relativo < -95) { vr = -100; vl = -100; } } else { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if (by < 50) Ir_a_punto_portero (&env->home[0],env,5,70); else if (by > 130) Ir_a_punto_portero (&env->home[0],env,5,110); else Control_posicion_portero (env,robot,bx,by,angulo_relativo); } } } else if (ballX > 0 && distancia_pelota > 60) { //distancia del robot hasta el centro de la porteria (0,90) dx = robot->pos.x - 0; dy = robot->pos.y - 90; distancia = sqrt (dx*dx + dy*dy); //el portero esta lejos del centro de la porteria if (distancia > 25 || env->predictedBall.pos.x > 40 || robot->pos.x < 0) Ir_a_punto_portero(robot,env,5,90); else if (distancia_pelota < 10) Velocity (&env->home[0],-70,70); }


116

//la pelota viene hacia nuestra porteria y esta cerca else { //interceptamos la pelota bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; ballX = bx - env->currentBall.pos.x; ballY = by - env->currentBall.pos.y; //calculamos la distancia entre el portero y la pelota dx = env->home[0].pos.x - bx; dy = env->home[0].pos.y - by; distancia = sqrt (dx*dx + dy+dy); if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m=0; b = by - m * bx; //termino independiente de la ecuacion de la pelota punto_corte_x = env->home[0].pos.x; punto_corte_y = m * punto_corte_x + b; //evitamos que el portero salga de los limites de la porteria if (punto_corte_x < 5) punto_corte_x = 5; if (punto_corte_y > 115) punto_corte_y = 115; else if (punto_corte_y < 65) punto_corte_y = 65; //distancia entre el mejor robot y el punto de corte dx = env->home[0].pos.x - punto_corte_x; dy = env->home[0].pos.y - punto_corte_y; distancia = sqrt (dx*dx + dy*dy); //distancia entre la pelota y el punto de corte dx_pelota = env->predictedBall.pos.x - punto_corte_x; dy_pelota = env->predictedBall.pos.y - punto_corte_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia_pelota < 10 && fabs(dx) < 2 && fabs(dy) < 2) //Raqueteo Velocity (&env->home[0],-70,70); else Ir_a_punto_portero (&env->home[0],env,punto_corte_x,punto_corte_y); } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// //Estrategia del equipo DINAMICO /////////////////////////////////////////////////////////////////////////////////////// void Asignacion_comportamientos (Environment *env) {


117

ofstream fichero("c:\\Strategy\\pos.txt",ofstream::app); //inicializamos las precondiciones int A_pelota_en_campo = 0; int C_contrario_controla_pelota = 0; int D_mejor_llegar_pelota = 0; int D_secundario = 0; //1r comportamiento Portero (&env->home[0],env); //el robot 0 es el portero //1ª precondicion D_mejor_llegar_pelota = MLP(env); //Robot 1 a 4; //2ª precondicion C_contrario_controla_pelota = CCP(env,D_mejor_llegar_pelota); //si-> 1 a 4, no->-1 //2º comportamiento Interceptar_perseguir_pelota(env,D_mejor_llegar_pelota,C_contrario_controla_pelota); //colocamos el primer robot //3r comportamiento D_secundario = Posicionar_secundario(env,D_mejor_llegar_pelota); //colocamos el segundo robot //3ª precondicion A_pelota_en_campo = PEC(env); //0->zona area, 1->medio campo, 2->area contraria //4º comportamiento Reubicar_robots (env,D_mejor_llegar_pelota,D_secundario,A_pelota_en_campo); //colocamos el tercer y cuarto robot fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// //CONTROL ESTADÍSTICO /////////////////////////////////////////////////////////////////////////////////////// void Posesion_pelota (Environment *env) { //cambiamos la opcion "app" por "trunc" para empezar a escribir de nuevo ofstream fichero("c:\\Strategy\\pos_dinamic.txt",ofstream::trunc); int i,players=4; int mejor_robot,mejor_op; double per1=0,per2=0,per3=0; double dx[4],dy[4],distancia[4]; double dx_op[4],dy_op[4],distancia_op[4]; //distancia de nuestros robots respecto a la pelota for (i=0;i<=players;i++) { dx[i] = env->home[i].pos.x - env->predictedBall.pos.x; dy[i] = env->home[i].pos.y - env->predictedBall.pos.y;


118

distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); //fichero <<i<<"-> "<<distancia[i]<<"\n"; } //buscamos a nuestro robot mas cercano a la pelota if (distancia[0] < distancia[1]) mejor_robot = 0; else mejor_robot = 1; if (distancia[mejor_robot] > distancia[2]) mejor_robot = 2; if (distancia[mejor_robot] > distancia[3]) mejor_robot = 3; if (distancia[mejor_robot] > distancia[4]) mejor_robot = 4; //fichero <<"mejor_robot: "<<mejor_robot<<"\n"; //distancias de los oponentes a la pelota for (i=0;i<=players;i++) { dx_op[i] = env->opponent[i].pos.x - env->predictedBall.pos.x; dy_op[i] = env->opponent[i].pos.y - env->predictedBall.pos.y; distancia_op[i] = sqrt (dx_op[i]*dx_op[i] + dy_op[i]*dy_op[i]); //fichero <<i<<"----> "<<distancia_op[i]<<"\n"; } //buscamos al oponente mas cercano a la pelota if (distancia_op[0] < distancia_op[1]) mejor_op = 0; else mejor_op = 1; if (distancia_op[mejor_op] > distancia_op[2]) mejor_op = 2; if (distancia_op[mejor_op] > distancia_op[3]) mejor_op = 3; if (distancia_op[mejor_op] > distancia_op[4]) mejor_op = 4; //buscamos el robot mas cercano a la pelota y sumamos al contador //equipo,oponente,tiempo_total son variables globales if (distancia[mejor_robot] < distancia_op[mejor_op]) equipo++; else oponente++; tiempo_total = equipo + oponente; per1 = (double)equipo/tiempo_total; per2 = (double)oponente/tiempo_total; per3 = (double)tiempo_total/tiempo_total; fichero <<"TIEMPO POSESION PELOTA\n"; fichero <<"Posesion Dinamico: "<<equipo<<" -> "<<per1*100<<" %\n"; fichero <<"Posesion Estatico: "<<oponente<<" -> "<<per2*100<<" %\n"; fichero <<"TOTAL Posesion: "<<tiempo_total<<" -> "<<per3*100<<" %\n\n"; fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Tiempo_lado (Environment *env) { ofstream fichero("c:\\Strategy\\pos_dinamic.txt",ofstream::app);


119

double per1=0,per2=0,per3=0; //miramos si la pelota esta en nuestro campo o en el contrario //campo_propio,campo_contrario,tiempo_campo son variables globales if (env->predictedBall.pos.x <= 110) campo_propio++; else campo_contrario++; tiempo_campo = campo_propio + campo_contrario; per1 = (double)campo_propio/tiempo_campo; per2 = (double)campo_contrario/tiempo_campo; per3 = (double)tiempo_campo/tiempo_campo; fichero <<"TIEMPO LADO CAMPO\n"; fichero <<"Lado Dinamico: "<<campo_propio<<" -> "<<per1*100<<" %\n"; fichero <<"Lado Estatico: "<<campo_contrario<<" -> "<<per2*100<<" %\n"; fichero <<"TOTAL Lado: "<<tiempo_campo<<" -> "<<per3*100<<" %\n\n"; fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Tiempo_zona (Environment *env) { ofstream fichero("c:\\Strategy\\pos_dinamic.txt",ofstream::app); double per1=0,per2=0,per3=0,per4=0,per5=0; //miramos la zona donde se encuentra la pelota //zona1,zona2,zona3,zona4,tiempo_zona son variables globales if (env->predictedBall.pos.x <= 55) zona1++; //pelota de nuestra area else if (env->predictedBall.pos.x > 55 && env->predictedBall.pos.x <= 110) zona2++; //pelota en el medio campo propio else if (env->predictedBall.pos.x > 110 && env->predictedBall.pos.x <= 165 ) zona3++; //pelota en el medio campo contririo else if (env->predictedBall.pos.x > 165) zona4++; //pelota area contraria tiempo_zona = zona1 + zona2 + zona3 + zona4; per1 = (double)zona1/tiempo_zona; per2 = (double)zona2/tiempo_zona; per3 = (double)zona3/tiempo_zona; per4 = (double)zona4/tiempo_zona; per5 = (double)tiempo_zona/tiempo_zona; fichero <<"TIEMPO ZONA CAMPO\n"; fichero <<"ZONA 1: "<<zona1<<" -> "<<per1*100<<" %\n"; fichero <<"ZONA 2: "<<zona2<<" -> "<<per2*100<<" %\n"; fichero <<"ZONA 3: "<<zona3<<" -> "<<per3*100<<" %\n";


120

fichero <<"ZONA 4: "<<zona4<<" -> "<<per4*100<<" %\n"; fichero <<"TOTAL Zona: "<<tiempo_zona<<" -> "<<per5*100<<" %\n\n"; fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////


121

11.2 Codi programació Equip Pseudo-dinàmic /////////////////////////////////////////////////////////////////////////////////////// //EQUIP PSEUDO-DINAMIC /////////////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "Strategy.h" #include <math.h> #include <iostream> #include <fstream> using namespace std; BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { switch (ul_reason_for_call) { case DLL_PROCESS_ATTACH: case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; } const double PI = 3.1415923; ///////////////////////////////////////////////////////////////////////////////// //funciones de las acciones void Velocity (Robot *robot, double vl, double vr); double Calculo_angulo_relativo (double dx, double dy, double R); void Ir_a_punto (Robot *robot, Environment *env, double punto_x, double punto_y); void Control_posicion (Environment *env,Robot *robot,double punto_x, double punto_y,double angulo_relativo); void Ir_a_punto_portero ( Robot *robot, Environment *env, double punto_x, double punto_y); void Control_posicion_portero (Environment *env,Robot *robot,double punto_x, double punto_y,double angulo_relativo); //funciones de las precondiciones int PEC (Environment *env); int MLP (Environment *env,int pelota); int CCP (Environment *env,int mejor_robot); void PredictBall (Environment *env); //funciones de los comportamientos void Portero (Robot *robot, Environment *env); void Interceptar_perseguir_pelota (Environment *env, int mejor_robot, int mejor_oponente);


122

void Rematar_perseguir_pelota (Robot *robot, Environment *env); int Posicionar_secundario (Environment *env, int mejor_robot); void Reubicar_robots (Environment *env, int mejor_robot, int secundario, int pelota); //funciones generales void Asignacion_comportamientos (Environment *env); void Cambio_coordenadas (Environment *env ); void Posesion_pelota (Environment *env); void Tiempo_campo (Environment *env); void Tiempo_zona (Environment *env); ////////////////////////////////////////////////////////////////////////////////// extern "C" STRATEGY_API void Create ( Environment *env ) { // allocate user data and assign to env->userData // eg. env->userData = ( void * ) new MyVariables (); } extern "C" STRATEGY_API void Destroy ( Environment *env ) { // free any user data created in Create ( Environment * ) // eg. if ( env->userData != NULL ) delete ( MyVariables * ) env->userData; } extern "C" STRATEGY_API void Strategy ( Environment *env ) { Cambio_coordenadas (env); PredictBall (env); Posesion_pelota (env); Tiempo_campo (env); Tiempo_zona (env); Asignacion_comportamientos (env); } /////////////////////////////////////////////////////////////////////////////////////// void Ir_a_punto ( Robot *robot, Environment *env, double punto_x, double punto_y) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int i,mejor_robot; double R = robot->rotation; double dx,dy; double angulo_relativo, distancia; double px,py,angulo,radio; for (i=1;i<=4;i++) { if (env->home[i].pos.x == robot->pos.x && env->home[i].pos.y == robot->pos.y) mejor_robot = i; } //evitaremos que los robots defiendan dentro del area pequeña


123

//distancia del punto hasta centro porteria (0,90) px = punto_x - 0; py = punto_y - 90; distancia = sqrt (px*px + py*py); if (distancia < 30) { //calculamos el angulo if (py == 0) angulo = 0; else angulo = atan2(py,px); //colocaremos robot a un radio de 30cm del centro de la porteria radio = 30; //nuevas coordenadas donde se tiene que colocar el robot punto_x = radio * cos (angulo); punto_y = radio * sin (angulo) + 90; } //distancia del robot hasta el punto dx = robot->pos.x - punto_x; dy = robot->pos.y - punto_y; angulo_relativo = Calculo_angulo_relativo (dx,dy,R); distancia = sqrt(dx * dx + dy * dy); if (distancia > 2) Control_posicion (env,robot,punto_x,punto_y,angulo_relativo); else Velocity ( robot,0,0); fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Rematar_perseguir_pelota ( Robot *robot, Environment *env) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int i,mejor_robot; double R = robot->rotation; double bx = env->predictedBall.pos.x; double by = env->predictedBall.pos.y; double dx,dy,angulo_relativo; double distancia; double px,py,angulo,radio; double ballX; for (i=1;i<=4;i++) { if (env->home[i].pos.x == robot->pos.x && env->home[i].pos.y == robot->pos.y) mejor_robot = i;


124

} if (mejor_robot < 3) { //evitaremos que los robots defiendan dentro del area pequeña //distancia del punto hasta centro porteria (0,90) px = bx - 0; py = by - 90; distancia = sqrt (px*px + py*py); if (distancia < 30 && env->home[0].pos.x < 30) { //calculamos el angulo if (py == 0) angulo = 0; else angulo = atan2(py,px); //colocaremos robot a un radio de 30cm del centro de la porteria radio = 30; //nuevas coordenadas donde "estara" la pelota bx = radio * cos (angulo); by = radio * sin (angulo) + 90; } dx = robot->pos.x - bx; dy = robot->pos.y - by; angulo_relativo = Calculo_angulo_relativo (dx,dy,R); distancia = sqrt(dx * dx + dy * dy); if (env->predictedBall.pos.x > 110) bx = 110; Control_posicion (env,robot,bx,by,angulo_relativo); } else if (mejor_robot > 2) { //miramos sentido de la pelota ballX = env->predictedBall.pos.x - env->currentBall.pos.x; dx = robot->pos.x - bx; dy = robot->pos.y - by; angulo_relativo = Calculo_angulo_relativo (dx,dy,R); distancia = sqrt(dx * dx + dy * dy); if (env->predictedBall.pos.x < 110) bx = 110; //control en zona de ataque if ( robot->pos.x < 165 ) {


125

if ( distancia<8.5 && dx<0 && robot->pos.y>30 && robot->pos.y<150 ) Ir_a_punto (robot,env,220,90); else Control_posicion (env,robot,bx,by,angulo_relativo); } else if ( robot->pos.x >= 165 && robot->pos.x < 205 ) { dx = robot->pos.x - env->predictedBall.pos.x; dy = robot->pos.y - env->predictedBall.pos.y; distancia = sqrt(dx * dx + dy * dy); if ( ballX <= 0&&distancia < 10 && robot->pos.y > 55 && robot->pos.y < 125) Velocity (robot,50,-50); else if ( distancia<10 && dx<0 && robot->pos.y>60 && robot->pos.y<120 ) { if (robot->pos.y <= env->predictedBall.pos.y) { if (robot->rotation > -75 && robot->rotation < 75) Velocity (robot,100,20); else if (robot->rotation > 135 && robot->rotation < -135) Velocity (robot,-20,-100); } else if (robot->pos.y > env->predictedBall.pos.y) { if (robot->rotation > -75 && robot->rotation < 75) Velocity (robot,20,100); else if (robot->rotation > 135 && robot->rotation < -135) Velocity (robot,-100,-20); } else Control_posicion (env,robot,bx,by,angulo_relativo); } else Control_posicion (env,robot,bx,by,angulo_relativo); } else if ( robot->pos.x > 205 ) { if (distancia<12 && robot->pos.y>55 && robot->pos.y<125) { if (robot->pos.y>55 && robot->pos.y<90) { if (robot->rotation < 135 && robot->rotation > 75) Velocity (robot,100,20); else if (robot->rotation > -135 && robot->rotation < -75) Velocity (robot,-20,-100); } else if (robot->pos.y>90 && robot->pos.y<125) { if (robot->rotation < 135 && robot->rotation > 75) Velocity (robot,20,100); else if (robot->rotation > -135 && robot->rotation < -75) Velocity (robot,-100,-20); }


126

else Control_posicion (env,robot,bx,by,angulo_relativo); } else Control_posicion (env,robot,bx,by,angulo_relativo); } else Control_posicion (env,robot,bx,by,angulo_relativo); } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Control_posicion (Environment *env,Robot *robot,double punto_x, double punto_y, double angulo_relativo) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int i,players = 4,mejor_op=0,mejor_robot=0; int area=0,colision=0; double dx[4],dy[4],distancia[4]; double dxop[5],dyop[5],distanciaop[5]; double angulo_oponente,R; double px,py,dist; double dx_pelota,dy_pelota,distancia_pelota; double mejor_x,mejor_y,mejor_dx,mejor_dy,mejor_distancia; double corte_x,corte_y,distancia_corte; double corte_pelota_x,corte_pelota_y,distancia_corte_pelota; double robot_corte_x,robot_corte_y,distancia_robot_corte; double m1,b1,m2,b2,punto_corte_x,punto_corte_y; double vr,vl,delta,delta_right=0,delta_left=0; double vc,kpa=0.1,distancia_colision; //******************************* //velocidad deseada de los robots // vc = FICHERO TEXTO; //******************************* //leemos la velocidad deseada de los robots del fichero de texto ifstream ficher("c:\\Strategy\\vel_estatic.txt"); ficher >> vc; //deteccion de obstaculos //distancia respecto a nuestros robots for (i=0;i<=players;i++) { if (env->home[i].pos.x != robot->pos.x && env->home[i].pos.y != robot->pos.y) { dx[i] = robot->pos.x - env->home[i].pos.x; dy[i] = robot->pos.y - env->home[i].pos.y; distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); }


127

else distancia[i] = 300; } //buscamos a nuestro compañero mas cercano if (distancia[0] < distancia [1]) mejor_robot = 0; else mejor_robot = 1; if (distancia[mejor_robot] > distancia [2]) mejor_robot = 2; if (distancia[mejor_robot] > distancia [3]) mejor_robot = 3; if (distancia[mejor_robot] > distancia [4]) mejor_robot = 4; //distancia respecto a los oponentes for (i=0;i<=players;i++) { dxop[i] = robot->pos.x - env->opponent[i].pos.x; dyop[i] = robot->pos.y - env->opponent[i].pos.y; distanciaop[i] = sqrt (dxop[i]*dxop[i] + dyop[i]*dyop[i]); } //buscamos el oponente mas cercano if (distanciaop[0] < distanciaop[1]) mejor_op = 0; else mejor_op = 1; if (distanciaop[mejor_op] > distanciaop[2]) mejor_op = 2; if (distanciaop[mejor_op] > distanciaop[3]) mejor_op = 3; if (distanciaop[mejor_op] > distanciaop[4]) mejor_op = 4; //buscamos el robot mas cercano if (distancia[mejor_robot] < distanciaop[mejor_op]) { mejor_x = env->home[mejor_robot].pos.x; mejor_y = env->home[mejor_robot].pos.y; mejor_dx = dx[mejor_robot]; mejor_dy = dy[mejor_robot]; mejor_distancia = distancia[mejor_robot]; } else { mejor_x = env->opponent[mejor_op].pos.x; mejor_y = env->opponent[mejor_op].pos.y; mejor_dx = dxop[mejor_op]; mejor_dy = dyop[mejor_op]; mejor_distancia = distanciaop[mejor_op]; } //control de obstaculos px = punto_x - robot->pos.x; py = punto_y - robot->pos.y; if ( px != 0 && py !=0 ) { m1 = py/px; //pendiente de la trayectoria del objetivo m2 = -1/m1; } else


128

{ m1 = 0; m2 = 0; } b1 = punto_y - m1 * punto_x; //termino independiente de la ecuacion del objetivo b2 = mejor_y - m2 * mejor_x; if ( m1 != 0 && m2 !=0 ) punto_corte_x = (b2 - b1)/(m1 - m2); else punto_corte_x = 0; punto_corte_y = m2 * punto_corte_x + b2; //trigonometricamente miramos si el "oponente" esta entre el robot y el objetivo //distancia del oponente mas cercano a la trayectoria del robot corte_x = punto_corte_x - mejor_x; corte_y = punto_corte_y - mejor_y; distancia_corte = sqrt (corte_x*corte_x + corte_y*corte_y); //distancia del punto de corte al objetivo corte_pelota_x = punto_corte_x - punto_x; corte_pelota_y = punto_corte_y - punto_y; distancia_corte_pelota = sqrt (corte_pelota_x*corte_pelota_x + corte_pelota_y*corte_pelota_y); //distancia del robot al punto de corte robot_corte_x = punto_corte_x - robot->pos.x; robot_corte_y = punto_corte_y - robot->pos.y; distancia_robot_corte = sqrt (robot_corte_x*robot_corte_x + robot_corte_y*robot_corte_y); //distancia del robot respecto al objetivo dx_pelota = robot->pos.x - punto_x; dy_pelota = robot->pos.y - punto_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); //miramos si se cumplen las condiciones para tener colision colision =0; if (distancia_corte < 20) { if (distancia_corte_pelota > 0 && distancia_robot_corte > 0) { if (distancia_pelota == distancia_robot_corte + distancia_corte_pelota) colision = 1; } } //distancia y delta deseada para evitar colision if (distancia_pelota < 10) { distancia_colision = 50;


129

delta = 40; } else { distancia_colision = 30; delta = 20; } //evitaremos el robot entre en el area pequeña //distancia del punto hasta centro porteria (0,90) px = robot->pos.x - 0; py = robot->pos.y - 90; dist = sqrt (px*px + py*py); if (dist <= 30) area = 1; //controlador de velocidad segun la distancia,angulo,oponentes y portero //valor de kpa segun la distancia al objetivo if (distancia_pelota > 100.) kpa = 0.19; else if (distancia_pelota > 50) kpa = 0.21; else if (distancia_pelota > 30) kpa = 0.24; else if (distancia_pelota > 20) kpa = 0.26; else kpa = 0.28; if (angulo_relativo < 85 && angulo_relativo > -85) //el robot ataca de frente a la pelota { //control de colisiones y area pequeña if (area == 1) { if (env->predictedBall.pos.y > robot->pos.y) delta_left = delta; else delta_right = delta; } //control de area pequeña else if (mejor_distancia < distancia_colision && colision == 1) { //miramos el sentido de giro del robot R = robot->rotation; angulo_oponente = Calculo_angulo_relativo (mejor_dx,mejor_dy,R); if (angulo_oponente < 85 && angulo_oponente > -85) { if (angulo_relativo < angulo_oponente) delta_left = delta; else if (angulo_relativo == angulo_oponente) { if (robot->pos.y <= 110) delta_left = delta; else delta_right = delta; } else if (angulo_relativo > angulo_oponente)


130

delta_right = delta; } } //calculamos la velocidad (distancia,angulo relativo y delta) vr = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) + kpa * angulo_relativo) + delta_right; vl = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) - kpa * angulo_relativo) + delta_left; //control de velocidad en caso de "lucha" con un robot nuestro dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.y - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia[mejor_robot]<20 && distancia_pelota<12 && dx_pelota>0 && dx[mejor_robot]>0 && robot->pos.x>10) { if ( env->predictedBall.pos.y <= 90 ) { vl=-50; vr=-10; } else if ( env->predictedBall.pos.y > 90 ) { vl=-10; vr=-50; } } else if (distancia[mejor_robot]<20 && distancia_pelota<12 && robot->pos.x<=10) { if (env->predictedBall.pos.y <= 90 && dy_pelota<0 && dy[mejor_robot]<0) { vl=-50; vr=-10; } else if (env->predictedBall.pos.y > 90 && dy_pelota>0 && dy[mejor_robot]>0) { vl=-10; vr=-50; } } } else if (angulo_relativo > 95 || angulo_relativo < -95) //el robot ataca de espaldas a la pelota { //control de colisiones y area pequeña if (area == 1) { if (env->predictedBall.pos.y > robot->pos.y) delta_right = delta; else delta_left = delta; } else if (mejor_distancia < distancia_colision && colision == 1) {


131

//miramos el sentido de giro del robot R = robot->rotation; angulo_oponente = Calculo_angulo_relativo (mejor_dx,mejor_dy,R); if (angulo_oponente > 95 || angulo_oponente < -95) { if (angulo_oponente < 0) angulo_oponente += 360; if (angulo_relativo < 0) angulo_relativo += 360; if (angulo_relativo < angulo_oponente) delta_right = delta; else if (angulo_relativo == angulo_oponente) { if (robot->pos.y <= 110) delta_right = delta; else delta_left = delta; } else if (angulo_relativo > angulo_oponente) delta_left = delta; if (angulo_oponente > 180) angulo_oponente -= 360; if (angulo_relativo > 180) angulo_relativo -= 360; } } angulo_relativo += 180; if (angulo_relativo > 180) angulo_relativo -= 360; angulo_oponente += 180; if (angulo_oponente > 180) angulo_oponente -= 360; //calculamos la velocidad (distancia,angulo relativo y delta) vr = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) + kpa * angulo_relativo) - delta_right; vl = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) - kpa * angulo_relativo) - delta_left; //control de velocidad en caso de "lucha" con un robot nuestro dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.y - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia[mejor_robot]<20 && distancia_pelota<12 && dx_pelota>0 && dx[mejor_robot]>0 && robot->pos.x>10) { if ( env->predictedBall.pos.y <= 90 ) { vl=10; vr=50; } else if ( env->predictedBall.pos.y > 90 ) { vl=50; vr=10; } }


132

else if (distancia[mejor_robot]<20 && distancia_pelota<12 && robot->pos.x<=10) { if (env->predictedBall.pos.y <= 90 && dy_pelota<0 && dy[mejor_robot]<0) { vl=10; vr=50; } else if (env->predictedBall.pos.y > 90 && dy_pelota>0 && dy[mejor_robot]>0) { vl=50; vr=10; } } } else { if (angulo_relativo <= 95 && angulo_relativo >= 85) { vr = (+.5 * angulo_relativo); vl = (-.5 * angulo_relativo); } else if (angulo_relativo >= -95 && angulo_relativo <= -85) { vl = (+.5 * angulo_relativo); vr = (-.5 * angulo_relativo); } } Velocity ( robot,vl,vr ); fichero.close(); ficher.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Ir_a_punto_portero ( Robot *robot, Environment *env, double punto_x, double punto_y) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); double R = robot->rotation; double dx,dy; double angulo_relativo, distancia; //distancia del robot hasta el punto dx = robot->pos.x - punto_x; dy = robot->pos.y - punto_y; angulo_relativo = Calculo_angulo_relativo (dx,dy,R); distancia = sqrt(dx * dx + dy * dy); if (distancia > 2) Control_posicion_portero (env,robot,punto_x,punto_y,angulo_relativo);


133

else Velocity (robot,0,0); fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Control_posicion_portero (Environment *env,Robot *robot,double punto_x, double punto_y,double angulo_relativo) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); double dx_pelota,dy_pelota,distancia_pelota; double vr,vl; double vc,kpa=0.1; //******************************* //velocidad deseada de los robots vc = 70; //******************************* //distancia del robot respecto a la pelota dx_pelota = robot->pos.x - punto_x; dy_pelota = robot->pos.y - punto_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); //controlador de velocidad segun la distancia,angulo,oponentes y portero //valor de kpa segun la distancia al objetivo if (distancia_pelota > 100.) kpa = 0.19; else if (distancia_pelota > 50) kpa = 0.21; else if (distancia_pelota > 30) kpa = 0.24; else if (distancia_pelota > 20) kpa = 0.26; else kpa = 0.28; if (angulo_relativo < 85 && angulo_relativo > -85) //el robot ataca de frente a la pelota { //calculamos la velocidad (distancia,angulo relativo y delta) vr = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) + kpa * angulo_relativo); vl = ( vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) - kpa * angulo_relativo); } else if (angulo_relativo > 95 || angulo_relativo < -95) //el robot ataca de espaldas a la pelota { angulo_relativo += 180; if (angulo_relativo > 180) angulo_relativo -= 360; //calculamos la velocidad (distancia,angulo relativo y delta) vr = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) + kpa * angulo_relativo); vl = (-vc * (1.0 / (1.0 + exp(-3.0 * distancia_pelota)) - 0.3) - kpa * angulo_relativo); } else


134

{ if (angulo_relativo <= 95 && angulo_relativo >= 85) { vr = (+.5 * angulo_relativo); vl = (-.5 * angulo_relativo); } else if (angulo_relativo >= -95 && angulo_relativo <= -85) { vl = (+.5 * angulo_relativo); vr = (-.5 * angulo_relativo); } } Velocity ( robot,vl,vr ); fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Velocity ( Robot *robot, double vl, double vr ) { robot->velocityRight = vr; robot->velocityLeft = vl; } /////////////////////////////////////////////////////////////////////////////////////// void PredictBall ( Environment *env ) { double dx_p = env->currentBall.pos.x - env->lastBall.pos.x; double dy_p = env->currentBall.pos.y - env->lastBall.pos.y; env->predictedBall.pos.x = env->currentBall.pos.x + dx_p; env->predictedBall.pos.y = env->currentBall.pos.y + dy_p; } /////////////////////////////////////////////////////////////////////////////////////// void Cambio_coordenadas (Environment *env) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int i; double factor_escala = 220/(FRIGHTX - FLEFTX); //pasamos de pulgadas a cm if (env->home[0].pos.x < 50) //equipo amarillo { env->predictedBall.pos.x = (env->predictedBall.pos.x - FLEFTX) * factor_escala; env->predictedBall.pos.y = (env->predictedBall.pos.y - FBOT) * factor_escala; env->currentBall.pos.x = (env->currentBall.pos.x - FLEFTX) * factor_escala; env->currentBall.pos.y = (env->currentBall.pos.y - FBOT) * factor_escala; env->lastBall.pos.x = (env->lastBall.pos.x - FLEFTX) * factor_escala; env->lastBall.pos.y = (env->lastBall.pos.y - FBOT) * factor_escala; for (i=0;i<5;i++)


135

{ env->home[i].pos.x = (env->home[i].pos.x - FLEFTX) * factor_escala; env->home[i].pos.y = (env->home[i].pos.y - FBOT) * factor_escala; env->opponent[i].pos.x = (env->opponent[i].pos.x - FLEFTX) * factor_escala; env->opponent[i].pos.y = (env->opponent[i].pos.y - FBOT) * factor_escala; } } else //(env->home[0].pos.x > 50) equipo azul { env->predictedBall.pos.x= (FRIGHTX - env->predictedBall.pos.x) * factor_escala; env->predictedBall.pos.y = (FTOP - env->predictedBall.pos.y) * factor_escala; env->currentBall.pos.x = (FRIGHTX - env->currentBall.pos.x) * factor_escala; env->currentBall.pos.y = (FTOP - env->currentBall.pos.y) * factor_escala; env->lastBall.pos.x = (FRIGHTX - env->lastBall.pos.x) * factor_escala; env->lastBall.pos.y = (FTOP - env->lastBall.pos.y) * factor_escala; for (i=0;i<5;i++) { env->home[i].pos.x = (FRIGHTX - env->home[i].pos.x) * factor_escala; env->home[i].pos.y = (FTOP - env->home[i].pos.y) * factor_escala; env->home[i].rotation = env->home[i].rotation - 180; env->opponent[i].pos.x= (FRIGHTX - env->opponent[i].pos.x) * factor_escala; env->opponent[i].pos.y = (FTOP - env->opponent[i].pos.y) * factor_escala; env->opponent[i].rotation = env->opponent[i].rotation - 180; if (env->home[i].rotation < -180) env->home[i].rotation += 360; if (env->opponent[i].rotation < -180) env->opponent[i].rotation += 360; } } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// double Calculo_angulo_relativo (double dx, double dy, double R) { double angulo_obstaculo, angulo_relativo, variable; if ( dx == 0 ) { if ( dy > 0 ) angulo_obstaculo = -90; else angulo_obstaculo = 90; } else if ( dy == 0 ) { if ( dx > 0 ) angulo_obstaculo = 180; else angulo_obstaculo = 0; } else { angulo_obstaculo = atan2(fabs(dy),fabs(dx))*(180.0/ PI); //angulo segun cuadrante if ( dx > 0 )


136

{ if ( dy > 0 ) angulo_obstaculo = angulo_obstaculo + 180; else if ( dy < 0 ) angulo_obstaculo = 180 - angulo_obstaculo; } else // dx < 0 { if ( dy > 0 ) angulo_obstaculo = - angulo_obstaculo; else if ( dy < 0 ) angulo_obstaculo = angulo_obstaculo; } } while ( angulo_obstaculo < -180 ) angulo_obstaculo += 360; while ( angulo_obstaculo > 180 ) angulo_obstaculo -= 360; angulo_relativo = ( angulo_obstaculo - R ); if ( dx > 0 ) { if ( dy > 0 ) { variable = angulo_obstaculo + 180; if (R > variable ) angulo_relativo += 360; } else { variable = angulo_obstaculo - 180; if (R < variable ) angulo_relativo -= 360; } } return (angulo_relativo); } /////////////////////////////////////////////////////////////////////////////////////// int PEC (Environment *env) {//A_pelota_nuestro_campo. 0->zona area, 1->medio campo, 2->3/4, 3->ataque int pelota; if (env->predictedBall.pos.x <= 40) pelota = 0; //zona de nuestra area else if (env->predictedBall.pos.x > 40 && env->predictedBall.pos.x <= 110) pelota = 1; //pelota en el medio del campo else if (env->predictedBall.pos.x > 110 && env->predictedBall.pos.x <= 165 ) pelota = 2; //pelota en el medio del campo else if (env->predictedBall.pos.x > 165) pelota = 3; //zona area contraria return(pelota); } /////////////////////////////////////////////////////////////////////////////////////// int MLP (Environment *env,int pelota) {//D_mejor_llegar_pelota. env->home[i]== 1 a 4;


137

ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int i; int mejor_robot,cercanos_pelota=0; int robot_cercano1=0,robot_cercano2=0; double dx[4],dy[4],distancia[4]; if (pelota < 2) //escogemos entre el robot 1 y 2 { //calculamos la distancia respecto la pelota dx[1] = env->home[1].pos.x - env->predictedBall.pos.x; dy[1] = env->home[1].pos.y - env->predictedBall.pos.y; distancia[1] = sqrt (dx[1]*dx[1] + dy[1]*dy[1]); dx[2] = env->home[2].pos.x - env->predictedBall.pos.x; dy[2] = env->home[2].pos.y - env->predictedBall.pos.y; distancia[2] = sqrt (dx[2]*dx[2] + dy[2]*dy[2]); //miramos los robots mas cercanos a la pelota if (dx[1]<0 || dx[2]<0) { for (i=1;i<=2;i++) { if (dx[i]>0 && distancia[i]>20) distancia[i] = 300; if (distancia[i] <= 20) { cercanos_pelota++; if (cercanos_pelota == 1) robot_cercano1 = i; if (cercanos_pelota == 2) robot_cercano2 = i; } } } } else if (pelota > 1) //escogemos entre el robot 3 y 4 { //calculamos la distancia respecto la pelota dx[3] = env->home[3].pos.x - env->predictedBall.pos.x; dy[3] = env->home[3].pos.y - env->predictedBall.pos.y; distancia[3] = sqrt (dx[3]*dx[3] + dy[3]*dy[3]); dx[4] = env->home[4].pos.x - env->predictedBall.pos.x; dy[4] = env->home[4].pos.y - env->predictedBall.pos.y; distancia[4] = sqrt (dx[4]*dx[4] + dy[4]*dy[4]); //miramos los robots mas cercanos a la pelota if (dx[3]<0 || dx[4]<0) { for (i=3;i<=4;i++) { if (dx[i]>0 && distancia[i]>20) distancia[i] = 300; if (distancia[i] <= 20) {


138

cercanos_pelota++; if (cercanos_pelota == 1) robot_cercano1 = i; if (cercanos_pelota == 2) robot_cercano2 = i; } } } } //escogemos el robot mejor situado if (cercanos_pelota == 1) mejor_robot = robot_cercano1; else if (cercanos_pelota > 1) { if (dx[robot_cercano1] < 0 && dx[robot_cercano2] < 0) { if (distancia[robot_cercano1] < distancia [robot_cercano2]) mejor_robot = robot_cercano1; else mejor_robot = robot_cercano2; } else if (dx[robot_cercano1] > 0 && dx[robot_cercano2] > 0) { if (distancia[robot_cercano1] < distancia [robot_cercano2]) mejor_robot = robot_cercano1; else mejor_robot = robot_cercano2; } else { if (dx[robot_cercano1] < 0) mejor_robot = robot_cercano1; else mejor_robot = robot_cercano2; } } else if (cercanos_pelota == 0) { if (pelota < 2) { if (distancia[1] < distancia [2]) mejor_robot = 1; else mejor_robot = 2; } else if (pelota > 1) { if (distancia[3] < distancia [4]) mejor_robot = 3; else mejor_robot = 4; } } return (mejor_robot); }


139

/////////////////////////////////////////////////////////////////////////////////////// int CCP (Environment *env, int mejor_robot) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int i,players = 4; int mejor_op,peligro = 0; double dx_robot,dy_robot,distancia_robot; double dx_op[4],dy_op[4],distancia_op[4]; //distancias de los oponentes a la pelota for (i=1;i<=players;i++) { dx_op[i] = env->opponent[i].pos.x - env->predictedBall.pos.x; dy_op[i] = env->opponent[i].pos.y - env->predictedBall.pos.y; distancia_op[i] = sqrt (dx_op[i]*dx_op[i] + dy_op[i]*dy_op[i]); //robot por delante y cerca de la pelota y mas alla de nuestra area if (dx_op[i] > 0 && env->opponent[i].pos.x > 40 && distancia_op[i] < 20) peligro++; else distancia_op[i] = 300; } if (peligro!=0) //algun oponente esta bien posicionado { //buscamos el oponente mas "peligroso" a la pelota if (distancia_op[1] < distancia_op[2]) mejor_op = 1; else mejor_op = 2; if (distancia_op[mejor_op] > distancia_op[3]) mejor_op = 3; if (distancia_op[mejor_op] > distancia_op[4]) mejor_op = 4; //distancia de nuestro mejor robot a la pelota dx_robot = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy_robot = env->home[mejor_robot].pos.y - env->predictedBall.pos.y; distancia_robot = sqrt(dx_robot*dx_robot + dy_robot*dy_robot); //comparamos con nuestro mejor robot if (distancia_robot < distancia_op[mejor_op]) mejor_op = -1; } else //no hay "peligro" mejor_op = -1; fichero.close(); return (mejor_op); }


140

/////////////////////////////////////////////////////////////////////////////////////// void Interceptar_perseguir_pelota (Environment *env, int mejor_robot, int mejor_oponente) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); double m,b,bx,by; double ballX,ballY; double punto_corte_x,punto_corte_y; double dx,dy,distancia; double dx_pelota,dy_pelota,distancia_pelota; bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; ballX = bx - env->currentBall.pos.x; ballY = by - env->currentBall.pos.y; //calculamos la distancia entre el mejor robot y la pelota dx = env->home[mejor_robot].pos.x - bx; dy = env->home[mejor_robot].pos.y - by; distancia = sqrt (dx*dx + dy*dy); //la pelota viene hacia nuestra porteria con un oponente //nuestro mejor robot esta detras y cerca de la pelota if( ballX < 0 && dx < 0 && distancia < 50 && mejor_oponente != -1) { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m=0; b = by - m * bx; //termino independiente de la ecuacion de la pelota punto_corte_x = env->home[mejor_robot].pos.x; punto_corte_y = m * punto_corte_x + b; //distancia entre el mejor robot y el punto de corte dx = env->home[mejor_robot].pos.x - punto_corte_x; dy = env->home[mejor_robot].pos.y - punto_corte_y; distancia = sqrt (dx*dx + dy*dy); //distancia entre la pelota y el punto de corte dx_pelota = env->predictedBall.pos.x - punto_corte_x; dy_pelota = env->predictedBall.pos.y - punto_corte_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia_pelota < 10 && fabs(dx) < 2 && fabs(dy) < 2) //Raqueteo Velocity (&env->home[mejor_robot],-50,50); else


141

Ir_a_punto (&env->home[mejor_robot],env,punto_corte_x,punto_corte_y); } else { Rematar_perseguir_pelota ( &env->home[mejor_robot],env ); } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// int Posicionar_secundario (Environment *env, int mejor_robot) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int mejor_secundario,delante_pelota=0; int players = 4; double bx = env->predictedBall.pos.x; double by = env->predictedBall.pos.y; double dx[4],dy[4],distancia[4]; double ballX,ballY,angulo; double dist,x=0,y=0,radio,px,py; double m,b,d; double punto_corte_x=0,punto_corte_y=0; double dx_corte,dy_corte,distancia_corte; //miramos la direccion de la pelota ballX = bx - env->currentBall.pos.x; ballY = by - env->currentBall.pos.y; //calculamos la distancia entre el mejor robot y la pelota dx[mejor_robot] = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy[mejor_robot] = env->home[mejor_robot].pos.y - env->predictedBall.pos.y; distancia[mejor_robot] = sqrt (dx[mejor_robot]*dx[mejor_robot] + dy[mejor_robot]*dy[mejor_robot]); bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if (mejor_robot < 3) { if (mejor_robot == 2) mejor_secundario = 1; else if (mejor_robot == 1) mejor_secundario = 2; } else if (mejor_robot > 2) { //buscamos el robot mas cercano a la pelota dx[1] = env->home[1].pos.x - env->predictedBall.pos.x; dy[1] = env->home[1].pos.y - env->predictedBall.pos.y; distancia[1] = sqrt (dx[1]*dx[1] + dy[1]*dy[1]); dx[2] = env->home[2].pos.x - env->predictedBall.pos.x;


142

dy[2] = env->home[2].pos.y - env->predictedBall.pos.y; distancia[2] = sqrt (dx[2]*dx[2] + dy[2]*dy[2]); //asignamos el tercer robot if (distancia[1] < distancia[2]) mejor_secundario = 2; else mejor_secundario = 1; } bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; dx[mejor_robot] = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy[mejor_robot] = env->home[mejor_robot].pos.y - env->predictedBall.pos.y; distancia[mejor_robot] = sqrt (dx[mejor_robot]*dx[mejor_robot] + dy[mejor_robot]*dy[mejor_robot]); //la pelota viene hacia nuestra porteria con nuestro robot y el secundario detras pelota if( ballX < 0 && distancia[mejor_robot] < 15 && dx[mejor_robot] > 0 && dx[mejor_secundario] < 0 ) { d = env->home[mejor_robot].pos.y - env->home[mejor_secundario].pos.y; if( fabs(d) < 40 ) { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m = 0; b = by - m * bx; //termino independiente de la ecuacion de la pelota //calculamos el punto de corte del mejor secundario punto_corte_x = env->home[mejor_secundario].pos.x; punto_corte_y = m * punto_corte_x + b; //distancia entre el mejor secundario y el punto de corte dx_corte = env->home[mejor_secundario].pos.x - punto_corte_x; dy_corte = env->home[mejor_secundario].pos.y - punto_corte_y; distancia_corte = sqrt (dx_corte*dx_corte + dy_corte*dy_corte); if (distancia_corte < 15 && fabs(dx_corte) < 2 && fabs(dy_corte) < 2) //Raqueteo Velocity (&env->home[mejor_secundario],-50,50); else Ir_a_punto (&env->home[mejor_secundario],env,punto_corte_x, punto_corte_y); } else Rematar_perseguir_pelota ( &env->home[mejor_secundario],env ); } else


143

{ bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //distancia de la pelota hasta centro porteria (0,90) px = bx - 0; py = by - 90; dist = sqrt (px*px + py*py); bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //calculamos el angulo if (py == 0) angulo = 0; else angulo = atan2(py,px); //colocaremos el secundario a la mitad de distancia radio = dist/2; if (radio < 30) radio = 30; if (radio > 95) radio = 95; //coordenadas donde se tiene que colocar el secundario x = radio * cos (angulo); y = radio * sin (angulo) + 90; if (dist< 40 && fabs(dx[mejor_secundario])<2 && fabs(dy[mejor_secundario]) < 2) //Raqueteo Velocity (&env->home[mejor_secundario],-50,50); else Ir_a_punto (&env->home[mejor_secundario],env,x,y); } fichero.close(); return (mejor_secundario); } /////////////////////////////////////////////////////////////////////////////////////// void Reubicar_robots (Environment *env, int mejor_robot, int secundario, int pelota) {//0->zona area, 1->medio campo, 2->area contraria ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); int tercer,cuarto; int mejor_op,vc,limite; int i,players = 4; double ballX,ballY; double dx[4],dy[4],distancia[4]; double dx_op[4],dy_op[4],distancia_op[4]; double m,d,b,bx,by,px,py; double punto_corte_x=0,punto_corte_y=0;


144

double dx_corte,dy_corte,distancia_corte; if (pelota < 2) //la pelota en nuestro campo { //buscamos el robot mas cercano a la pelota dx[3] = env->home[3].pos.x - env->predictedBall.pos.x; dy[3] = env->home[3].pos.y - env->predictedBall.pos.y; distancia[3] = sqrt (dx[3]*dx[3] + dy[3]*dy[3]); dx[4] = env->home[4].pos.x - env->predictedBall.pos.x; dy[4] = env->home[4].pos.y - env->predictedBall.pos.y; distancia[4] = sqrt (dx[4]*dx[4] + dy[4]*dy[4]); //asignamos el tercer robot if (distancia[3] < distancia[4]) tercer = 3; else tercer = 4; cuarto = 7 - tercer; } else if (pelota > 1) //la pelota en campo contrario { tercer = mejor_robot; mejor_robot = 7 - tercer; cuarto = secundario; } //oponente mas cercano al tercer robot for (i=1;i<=players;i++) { dx_op[i] = env->opponent[i].pos.x - env->home[tercer].pos.x; dy_op[i] = env->opponent[i].pos.y - env->home[tercer].pos.y; distancia_op[i] = sqrt (dx_op[i]*dx_op[i] + dy_op[i]*dy_op[i]); if (dx[tercer] < 0 && dx_op[i] > 0) distancia_op[i] = 300; else if (dx[tercer] > 0 && dx_op[i] < 0) distancia_op[i] = 300; else if (distancia[tercer] < 30) distancia_op[i] = 300; } if (distancia_op[1] < distancia_op[2]) mejor_op = 1; else mejor_op = 2; if (distancia_op[mejor_op] > distancia_op[3]) mejor_op = 3; if (distancia_op[mejor_op] > distancia_op[4]) mejor_op = 4; dx[mejor_robot] = env->home[mejor_robot].pos.x - env->predictedBall.pos.x; dy[mejor_robot] = env->home[mejor_robot].pos.y - env->predictedBall.pos.y;


145

distancia[mejor_robot] = sqrt (dx[mejor_robot]*dx[mejor_robot] + dy[mejor_robot]*dy[mejor_robot]); //ubicamos el tercer robot if (distancia_op[mejor_op] != 300 && env->predictedBall.pos.x > 110 && env->home[tercer].pos.x < 110) { //tercer intercepta un robot contrario //pendiente para interceptar oponente con el tercer robot bx = env->opponent[mejor_op].pos.x; by = env->opponent[mejor_op].pos.y; ballX = bx - env->predictedBall.pos.x; ballY = by - env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m = 0; b = by - m * bx; //termino independiente de la ecuacion de la pelota //calculamos el punto de corte con el oponente punto_corte_x = env->home[tercer].pos.x; punto_corte_y = m * punto_corte_x + b; if (punto_corte_x < 110) punto_corte_x = 110; if (punto_corte_y < 15) punto_corte_y = 15; if (punto_corte_y > 165) punto_corte_y = 165; Ir_a_punto (&env->home[tercer],env,punto_corte_x,punto_corte_y); } else { //acompañamos a nuestro mejor robot //miramos el sentido de la pelota bx = env->currentBall.pos.x; by = env->currentBall.pos.y; ballX = env->predictedBall.pos.x - bx; ballY = env->predictedBall.pos.y - by; if ((pelota == 0)||((pelota == 1)&&(ballX > 0))||((pelota == 2)&&(ballX > 0))) { if (env->predictedBall.pos.y <= env->home[tercer].pos.y) { px = env->predictedBall.pos.x; py = env->predictedBall.pos.y + 30; if (px < 110) px = 110; if (py > 165) py = 165; } else if (env->predictedBall.pos.y > env->home[tercer].pos.y) { px = env->predictedBall.pos.x; py = env->predictedBall.pos.y - 30; if (px < 110) px = 110;


146

if (py < 15) py = 15; } Ir_a_punto (&env->home[tercer],env,px,py); } else if (pelota == 3) { //leemos la velocidad deseada de los robots del fichero de texto ifstream ficher("c:\\Strategy\\vel_estatic.txt"); ficher >> vc; if (vc == 20) limite = 65; else if (vc == 30) limite = 60; else if (vc == 40) limite = 55; else if (vc == 50) limite = 50; else if (vc == 60) limite = 50; else if (vc == 70) limite = 45; else if (vc == 80) limite = 45; else if (vc == 90) limite = 30; else if (vc >= 100) limite = 30; else limite = 50; if (env->predictedBall.pos.y > 90) { if (env->predictedBall.pos.y < limite || env->predictedBall.pos.y > (180-limite)) Ir_a_punto (&env->home[tercer],env,185,105); else { if (env->home[mejor_robot].pos.y>60 && env->home[mejor_robot].pos.y<120 && env->home[mejor_robot].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,105); else Rematar_perseguir_pelota (&env->home[tercer],env); } } else { if (env->predictedBall.pos.y < limite || env->predictedBall.pos.y > (180-limite)) Ir_a_punto (&env->home[tercer],env,185,75); else { if (env->home[mejor_robot].pos.y>60 && env->home[mejor_robot].pos.y<120 && env->home[mejor_robot].pos.x>200) Ir_a_punto (&env->home[tercer],env,185,75); else Rematar_perseguir_pelota (&env->home[tercer],env); } } } else { //la pelota viene hacia nuestra porteria con nuestro robot y el tercer robot detras pelota if( ballX < 0 && distancia[mejor_robot] < 15 && dx[mejor_robot] > 0 && dx[tercer] < 0 )


147

{ //tercer intercepta a nuestro mejor robot d = env->home[mejor_robot].pos.y - env->home[tercer].pos.y; if( fabs(d) < 40 ) { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m = 0; b = by - m * bx; //termino independiente ecuacion de la pelota //calculamos el punto de corte del tercer robot punto_corte_x = env->home[tercer].pos.x; punto_corte_y = m * punto_corte_x + b; //distancia entre el tercer robot y el punto de corte dx_corte = env->home[tercer].pos.x - punto_corte_x; dy_corte = env->home[tercer].pos.y - punto_corte_y; distancia_corte = sqrt (dx_corte*dx_corte + dy_corte*dy_corte); if (distancia_corte<15 && fabs(dx_corte)< 2 && fabs(dy_corte) < 2) //Raqueteo Velocity (&env->home[tercer],-50,50); else Ir_a_punto (&env->home[tercer],env,punto_corte_x, punto_corte_y); } else { Rematar_perseguir_pelota ( &env->home[tercer],env ); if (env->home[tercer].pos.x < 110) Ir_a_punto (&env->home[tercer],env,110,env->predictedBall.pos.y); } } else { Rematar_perseguir_pelota ( &env->home[tercer],env ); if (env->home[tercer].pos.x < 110) Ir_a_punto (&env->home[tercer],env,110,env->predictedBall.pos.y); } } } //ubicacion el cuarto robot segun situacion de la pelota if (cuarto > 2) //colocamos el robot 3 o 4 en el medio campo { if (env->predictedBall.pos.y <= 90)


148

{ px = env->predictedBall.pos.x + 50; py = env->predictedBall.pos.y + 30; if (px < 125) px = 125; if (px > 185) { px = 185; py = 65; } } else if (env->predictedBall.pos.y > 90) { px = env->predictedBall.pos.x + 50; py = env->predictedBall.pos.y - 30; if (px < 125) px = 125; if (px > 185) { px = 185; py = 115; } } Ir_a_punto (&env->home[cuarto],env,px,py); } else if (cuarto < 3) //colocamos el robot 1 o 2 en el medio campo { //se colocara en el medio campo siguiendo la coordenada "y" de la pelota punto_corte_x = 110; punto_corte_y = env->predictedBall.pos.y; if (fabs(env->home[cuarto].pos.x - env->predictedBall.pos.x) < 10) //Raqueteo Velocity (&env->home[cuarto],-50,50); else Ir_a_punto (&env->home[cuarto],env,punto_corte_x,punto_corte_y); } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Portero ( Robot *robot, Environment *env ) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); double R = robot->rotation; double ballX,ballY; double m,b,bx,by,angulo_relativo; double punto_corte_x,punto_corte_y; double dx,dy,distancia,vr,vl; double dx_pelota,dy_pelota,distancia_pelota;


149

//miramos sentido de la pelota ballX = env->predictedBall.pos.x - env->currentBall.pos.x; bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; //distancia entre la pelota y el portero dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.x - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); //la pelota esta en nuestro lateral if ( bx < 10 && (by < 70 || by > 110) ) { //distancia entre la pelota y el portero dx_pelota = robot->pos.x - env->predictedBall.pos.x; dy_pelota = robot->pos.y - env->predictedBall.pos.y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (by < 65 && distancia_pelota > 20) Ir_a_punto_portero (&env->home[0],env,5,70); else if (by > 115 && distancia_pelota > 20) Ir_a_punto_portero (&env->home[0],env,5,110); else { angulo_relativo = Calculo_angulo_relativo (dx_pelota,dy_pelota,R); if (distancia_pelota < 20 && by > 50 && by < 130 ) { if (angulo_relativo < 85 && angulo_relativo > -85) { vr = 100; vl = 100; } else if (angulo_relativo > 95 || angulo_relativo < -95) { vr = -100; vl = -100; } } else { bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; if (by < 50) Ir_a_punto_portero (&env->home[0],env,5,70); else if (by > 130) Ir_a_punto_portero (&env->home[0],env,5,110); else Control_posicion_portero (env,robot,bx,by,angulo_relativo); } } } else if (ballX > 0 && distancia_pelota > 60)


150

{ //distancia del robot hasta el centro de la porteria (0,90) dx = robot->pos.x - 0; dy = robot->pos.y - 90; distancia = sqrt (dx*dx + dy*dy); //el portero esta lejos del centro de la porteria if (distancia > 25 || env->predictedBall.pos.x > 40 || robot->pos.x < 0) Ir_a_punto_portero(robot,env,5,90); else if (distancia_pelota < 10) Velocity (&env->home[0],-70,70); } //la pelota viene hacia nuestra porteria y esta cerca else { //interceptamos la pelota bx = env->predictedBall.pos.x; by = env->predictedBall.pos.y; ballX = bx - env->currentBall.pos.x; ballY = by - env->currentBall.pos.y; //calculamos la distancia entre el portero y la pelota dx = env->home[0].pos.x - bx; dy = env->home[0].pos.y - by; distancia = sqrt (dx*dx + dy+dy); if ( ballX != 0 && ballY !=0 ) m = ballY/ballX; //pendiente de la trayectoria de la pelota else m=0; b = by - m * bx; //termino independiente de la ecuacion de la pelota punto_corte_x = env->home[0].pos.x; punto_corte_y = m * punto_corte_x + b; //evitamos que el portero salga de los limites de la porteria if (punto_corte_x < 5) punto_corte_x = 5; if (punto_corte_y > 115) punto_corte_y = 115; else if (punto_corte_y < 65) punto_corte_y = 65; //distancia entre el mejor robot y el punto de corte dx = env->home[0].pos.x - punto_corte_x; dy = env->home[0].pos.y - punto_corte_y; distancia = sqrt (dx*dx + dy*dy); //distancia entre la pelota y el punto de corte dx_pelota = env->predictedBall.pos.x - punto_corte_x; dy_pelota = env->predictedBall.pos.y - punto_corte_y; distancia_pelota = sqrt (dx_pelota*dx_pelota + dy_pelota*dy_pelota); if (distancia_pelota < 10 && fabs(dx) < 2 && fabs(dy) < 2) //Raqueteo Velocity (&env->home[0],-70,70);


151

else Ir_a_punto_portero (&env->home[0],env,punto_corte_x,punto_corte_y); } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// //Estrategia del equipo ESTATICO /////////////////////////////////////////////////////////////////////////////////////// void Asignacion_comportamientos (Environment *env) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); //inicializamos las precondiciones int A_pelota_en_campo = 0; int C_contrario_controla_pelota = 0; int D_mejor_llegar_pelota = 0; int D_secundario = 0; int Primer_robot = 0; int Segundo_robot = 0; int H_pelota_delanteros = 0; int U_tercero = 0; Portero (&env->home[0],env); //el robot 0 es el portero A_pelota_en_campo = PEC(env); //0->zona area, 1->medio campo, 2->3/4, 3->area contraria if (A_pelota_en_campo < 2) //pelota en nuestro campo { D_mejor_llegar_pelota = MLP(env,A_pelota_en_campo); //Robot 1 y 2; C_contrario_controla_pelota=CCP(env,D_mejor_llegar_pelota); //si->1 a 4, no->-1 Interceptar_perseguir_pelota(env,D_mejor_llegar_pelota,C_contrario_controla_pelota); //colocamos el primer robot D_secundario = Posicionar_secundario(env,D_mejor_llegar_pelota); //colocamos el segundo robot Reubicar_robots (env,D_mejor_llegar_pelota,D_secundario,A_pelota_en_campo); //colocamos el tercer y cuarto robot } else if (A_pelota_en_campo > 1) //pelota en campo contrario { D_mejor_llegar_pelota = MLP(env,A_pelota_en_campo); //Robot 3 y 4; C_contrario_controla_pelota = CCP(env,D_mejor_llegar_pelota); //si-> 1 a 4, no->-1 Interceptar_perseguir_pelota(env,D_mejor_llegar_pelota,C_contrario_controla_pelota); //colocamos el primer robot Segundo_robot = Posicionar_secundario(env,D_mejor_llegar_pelota); //colocamos


152

el mejor defensa entre 1 y 2 Primer_robot = 3 - Segundo_robot; //entre robot 1 y 2 para ir al medio campo D_secundario = 7 - D_mejor_llegar_pelota; //entre robot 3 y 4 para ir a punto de remate Reubicar_robots (env,D_secundario,Primer_robot,A_pelota_en_campo); //colocamos el primer robot y D_secundario } fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// //CONTROL ESTADÍSTICO /////////////////////////////////////////////////////////////////////////////////////// void Posesion_pelota (Environment *env) { //cambiamos la opcion "app" por "trunc" para empezar a escribir de nuevo ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::trunc); int i,players=4; int mejor_robot,mejor_op; double dx[4],dy[4],distancia[4]; double dx_op[4],dy_op[4],distancia_op[4]; //distancia de nuestros robots respecto a la pelota for (i=0;i<=players;i++) { dx[i] = env->home[i].pos.x - env->predictedBall.pos.x; dy[i] = env->home[i].pos.y - env->predictedBall.pos.y; distancia[i] = sqrt (dx[i]*dx[i] + dy[i]*dy[i]); //fichero <<i<<"-> "<<distancia[i]<<"\n"; } //buscamos a nuestro robot mas cercano a la pelota if (distancia[0] < distancia[1]) mejor_robot = 0; else mejor_robot = 1; if (distancia[mejor_robot] > distancia[2]) mejor_robot = 2; if (distancia[mejor_robot] > distancia[3]) mejor_robot = 3; if (distancia[mejor_robot] > distancia[4]) mejor_robot = 4; fichero <<"mejor_robot: "<<mejor_robot<<"\n"; //distancias de los oponentes a la pelota for (i=0;i<=players;i++) { dx_op[i] = env->opponent[i].pos.x - env->predictedBall.pos.x; dy_op[i] = env->opponent[i].pos.y - env->predictedBall.pos.y; distancia_op[i] = sqrt (dx_op[i]*dx_op[i] + dy_op[i]*dy_op[i]); //fichero <<i<<"----> "<<distancia_op[i]<<"\n"; } //buscamos al oponente mas cercano a la pelota


153

if (distancia_op[0] < distancia_op[1]) mejor_op = 0; else mejor_op = 1; if (distancia_op[mejor_op] > distancia_op[2]) mejor_op = 2; if (distancia_op[mejor_op] > distancia_op[3]) mejor_op = 3; if (distancia_op[mejor_op] > distancia_op[4]) mejor_op = 4; fichero <<"mejor_op: "<<mejor_op<<"\n"; //buscamos el robot mas cercano a la pelota y sumamos al contador //equipo,oponente,tiempo_total son variables globales if (distancia[mejor_robot] < distancia_op[mejor_op]) equipo++; else oponente++; tiempo_total = equipo + oponente; fichero <<"Equipo: "<<equipo<<"\n"; fichero <<"Oponente: "<<oponente<<"\n"; fichero <<"TOTAL: "<<tiempo_total<<"\n\n"; fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Tiempo_campo (Environment *env) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); //miramos si la pelota esta en nuestro campo o en el contrario //campo_propio,campo_contrario,tiempo_campo son variables globales if (env->predictedBall.pos.x <= 110) campo_propio++; else campo_contrario++; tiempo_campo = campo_propio + campo_contrario; fichero <<"campo_propio: "<<campo_propio<<"\n"; fichero <<"campo_contrario: "<<campo_contrario<<"\n"; fichero <<"TOTAL: "<<tiempo_campo<<"\n\n"; fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// void Tiempo_zona (Environment *env) { ofstream fichero("c:\\Strategy\\pos_estatic.txt",ofstream::app); //miramos la zona donde se encuentra la pelota //zona1,zona2,zona3,zona4,tiempo_zona son variables globales if (env->predictedBall.pos.x <= 55)


154

zona1++; //pelota de nuestra area else if (env->predictedBall.pos.x > 55 && env->predictedBall.pos.x <= 110) zona2++; //pelota en el medio campo propio else if (env->predictedBall.pos.x > 110 && env->predictedBall.pos.x <= 165 ) zona3++; //pelota en el medio campo contrario else if (env->predictedBall.pos.x > 165) zona4++; //pelota area contraria tiempo_zona = zona1 + zona2 + zona3 + zona4; fichero <<"zona1: "<<zona1<<"\n"; fichero <<"zona2: "<<zona2<<"\n"; fichero <<"zona3: "<<zona3<<"\n"; fichero <<"zona4: "<<zona4<<"\n"; fichero <<"TOTAL: "<<tiempo_zona<<"\n\n"; fichero.close(); } /////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////


155

11.3 Dades resultats Robot Soccer A continuació es mostren tots els valors obtinguts a partir de les diferents

simulacions dels partits mitjançant Robot Soccer. Les taules contenen totes les dades utilitzades per al control estadístic a diferents velocitats de joc.

VELOCITAT 30

Nº Proba Valors obtinguts

1

TIEMPO POSESION PELOTA Posesion Dinamico: 6000 -> 45.847 % Posesion Estatico: 7087 -> 54.153 % TOTAL Posesion: 13087 -> 100 % TIEMPO LADO CAMPO Lado Dinamico: 5707 -> 43.6082 % Lado Estatico: 7380 -> 56.3918 % TOTAL Lado: 13087 -> 100 % TIEMPO ZONA CAMPO ZONA 1: 2840 -> 21.7009 % ZONA 2: 2867 -> 21.9072 % ZONA 3: 3270 -> 24.9866 % ZONA 4: 4110 -> 31.4052 % TOTAL Zona: 13087 -> 100 %

2


3

TIEMPO POSESION PELOTA Posesion Dinamico: 6654 -> 48.2664 % Posesion Estatico: 7132 -> 51.7336 % TOTAL Posesion: 13786 -> 100 %


156

TIEMPO LADO CAMPO Lado Dinamico: 7018 -> 50.9067 % Lado Estatico: 6768 -> 49.0933 % TOTAL Lado: 13786 -> 100 % TIEMPO ZONA CAMPO ZONA 1: 3741 -> 27.1362 % ZONA 2: 3277 -> 23.7705 % ZONA 3: 2470 -> 17.9167 % ZONA 4: 4298 -> 31.1766 % TOTAL Zona: 13786 -> 100 %

4


5



157

VELOCITAT 40


1


2


3

TIEMPO POSESION PELOTA Posesion Dinamico: 9737 -> 54.8255 % Posesion Estatico: 8023 -> 45.1745 % TOTAL Posesion: 17760 -> 100 % TIEMPO LADO CAMPO Lado Dinamico: 9637 -> 54.2624 % Lado Estatico: 8123 -> 45.7376 % TOTAL Lado: 17760 -> 100 %


158

TIEMPO ZONA CAMPO ZONA 1: 5436 -> 30.6081 % ZONA 2: 4201 -> 23.6543 % ZONA 3: 4314 -> 24.2905 % ZONA 4: 3809 -> 21.4471 % TOTAL Zona: 17760 -> 100 %

4


5



159

VELOCITAT 50


1


2


3



160


4


5



161

VELOCITAT 60


1


2


3



162


4


5



163

VELOCITAT 70


1


2


3



164


4


5



165

VELOCITAT 80


1


2


3



166


4


5



167

VELOCITAT 90


1


2


3



168


4


5


comparativa de tècniques de control distribuït. aplicació...

Documents