realizado por: jessica rivero espinosa (100025022) david ... · cooperación necesita más bien una...

Realizado por: Jessica Rivero Espinosa (100025022) David del Valle Agudo (100025228)

Practica Final: ROBOCODE

Inteligencia en Redes de Comunicaciones - 1 - Jessica Rivero Espinosa (100025022) David del Valle Agudo (100025228)

Índice

PáginaÍndice 1

ROBOCODE 2

Explicación del funcionamiento de la práctica 3

Nuestros robots 3Lucha individual 6Lucha en equipo 7

Código 9

AcosoYDerribo.java 9ALoLoco.java 12Ataque.java 13Codigo.java 14Inicio.java 15JDKRobot.java 16Jefe.java 19Orden.java 23Registro.java 26RobotColors.java 26SoldadoRaso.java 27Solo.java 29Victoria.java 29



ROBOCODE

Robocode es un entorno gratuito de simulación de guerras de robots, desarrollado por Alphaworks de IBM, en el que hay que programar uno o varios tanques en Java para pelear en el campo de batalla contra tanques programados por otros jugadores. Se van a desarrollar dos modos de juego: - batalla individual, en el que cada robot sin equipo lucha contra todos los demás. - batalla en equipo, en el que un ejército de robots lucha por la victoria de modo colaborativo contra otro ejércitos. Para ello cuenta con un completo API con clases que representan los elementos más diversos que intervienen en la batalla: Todo tipo de eventos que deben afectar al comportamiento del tanque, como impactos recibidos, balas o enemigos detectados, choques contra paredes u otros tanques… Balas, condiciones, mensajes… pero sobre todo tanques (robots). Los robots vienen estructurados de forma jerárquica, desde el Robot simple hasta el AdvancedRobot(que permite llamadas no bloqueantes) o el TeamRobot(tipo de robot avanzado que tiene constancia de la existencia de más robots pertenecientes a un mismo equipo y soporta el paso de mensajes entre sus integrantes).

Estos robots representan tanques en la pantalla. Como se puede ver en la figura, un tanque cuenta con cañón y un radar.

NOTA: El radar es un elemento del que se puede carecer implementando la interfaz Droide. La ventaja es la mayor cantidad de puntos con los que contará, el lado negativo: está ciego y necesitará la ayuda de otros tanques para ver. En

nuestro caso no usamos Droides con el fin de permitir que todos nuestros tanques tengan la posibilidad de vivir de forma autónoma. Definir su comportamiento pasa por dar contenido a los métodos del robot que gestionan los eventos, así como de su método run. Para ello se utilizan los métodos que ofrecen las clases de la jerarquía Robot, que permiten la rotación y desplazamiento del tanque, el retroceso. También el giro del cañón y del radar o métodos que informan de determinados aspectos del tanque o de su posición, orientación, estado. Se contempla también la posibilidad de envío de mensajes entre tanques, etc. Ejemplos: En el API nos encontramos con los siguientes métodos (muy usados en nuestro programa):

o broadcastMessage(Serializable message): Envía un mensaje broadcast a todos los componentes de su equipo. Este método pertenece a la clase TeamRobot.

o setTurnRight(double degrees) o setTurnLeft(double degrees): Dice al robot que gire a la derecha o a la izquierda el número de grados indicados en el argumento. Este método pertenece a la clase AdvancedRobot.



o waitFor(Conditioncondition): Este método no devuelve el mando al programa hasta que condition.test() no devuelva true. Este método pertenece a la clase AdvancedRobot.

o …

Explicación del funcionamiento de la práctica

Nuestros robots

J.D.K.J.D.K.J.D.K.J.D.K. ( ( ((JJJJessica & essica & essica & essica & DDDDavid avid avid avid KKKKiller Team)iller Team)iller Team)iller Team)

A primera vista un Robot tiene un comportamiento definido y único. Se pasa el tiempo desempeñando las acciones de una rutina principal y solo sale de ella cuando salta un evento que se debe gestionar, para volver a comportarse igual que al principio una vez que le ha atendido. Así mismo, la respuesta a estos eventos es también bastante estática. De algún modo, un tanque nace para desempeñar una misión de una determinada forma y solo de esa forma. Pero nosotros queríamos ir más allá: ¿Debe un tanque comportarse igual cuando todo su ejercito ha sido derribado y se encuentra solo en el campo de batalla? ¿Debe un tanque ser capaz de recibir ordenes concretas de un superior que le obliguen a modificar completamente su comportamiento? ¿Debe un tanque en función del estado de la batalla, cambiar su estrategia si las condiciones cambian? ¿Sería útil que los tanques fuesen capaces de cambiar sus cargos entre ellos si la situación lo requiere o si alguno de ellos está demasiado débil como para continuar con su labor? …Desde nuestro punto de vista sí. De echo, en esta capacidad de adaptarse de forma dinámica radica la mayor ventaja durante la lucha. Por eso nosotros hemos desarrollado un modelo de tanque de comportamiento ‘cambiable’. Esto es lo que permite al jefe de un JDKRobot delegar su cargo en otro tanque cuando él va a morir. Más aún, de decidir si merece la pena nombrar a un nuevo jefe cuando el actual ha sido derribado o si el equipo está tan mermado que más que un plan de cooperación necesita más bien una estrategia del tipo ‘sálvese quien pueda’. O lo que hace posible que los tanques distingan momentos de ataque individual (cada uno otea por ahí y elige sus propios objetivos) o que sepan adaptarse y colaborar para organizar una emboscada a un único rival a la orden de su jefe.



Nuestros tanques, JDKRobots, poseen una interesante capacidad. Su comportamiento está determinado por ‘partículas de código’ reemplazables. Un JDKRobot no tiene implementado ningún comportamiento por defecto, no sigue ninguna secuencia de líneas escritas dentro de los métodos de la clase. Solo un JDKRobot al que se le ha asociado una partícula de comportamiento que denominaremos ‘Orden’, tendrá definida su acción. Y es la Orden que en un momento concreto lleva asociado un tanque la que le llevará a Órdenes siguientes según se desarrolle el juego, o puede ser el jefe el que ordene reemplazar una orden por otras nuevas…

La Orden que lleva el tanque en cada momento es la que se encarga de responder a los eventos que recoge el robot, en lugar de ser el robot quien directamente lo hace. Es decir, dependiendo de la situación que se esté dando en el combate nuestros robots actúan de una determinada manera o de otra (ejecutará una orden u otra). Así no será raro observar que un tanque inicialmente se comporte como jefe y luego como soldado, o que en principio pasee ‘a lo loco’ casi sin disparar por toda la pantalla y al final se dedique a buscar objetivos y arremeter contra ellos. Presentamos la tabla de todas las ordenes que presentan nuestros tanques:



Inicio Orden inicial de los tanques. Decidirá si es un tanque solo o si no lo es. En el segundo caso elegirá jefe. Se define el color del equipo.

SoldadoRaso Gira buscando objetivo, cuando encuentra uno avanza contra el y dispara hasta acabar con él. Se ejecuta cuando quedan pocos tanques del equipo.

AcosoYDerrivo Se acerca hasta una distancia prudencial en torno al enemigo fijado por el Jefe y le ataca realizando un sencilla predicción de la posición que tendrá el objetivo cuando la bala le impacte.

ALoLoco El tanque se desplaza por toda la pantalla realizando muchos cambios de dirección para dificultar ser alcanzado hasta recibir una orden del Jefe.

Ataque Dispara a un objetivo desde una distancia prudencial hasta reducirlo. Moviéndose en círculos par dificultar ser dado.

Solo Similar a ALoLoco para tanques sin equipo. Victoria Ejecuta una leve oscilación para evitar seguir realizando

acciones como disparar que pueden perjudicar al equipo una vez ha ganado.

Jefe Bordea la pantalla buscando objetivos que les pasará a el resto de soldados. Atiende a mensajes de AYUDA que puedan recibirse de miembros del equipo con poca energía.

Solo existe un único tipo de tanque JDKRobot, y dependerá de que al iniciar la partida encuentre a más integrantes de su equipo o no el que adquiera un comportamiento colaborativo (esperará ordenes de su jefe o se proclamará jefe y antepondrá los objetivos del equipo a los suyos propios) o autónomo (buscará sus propios objetivos e intentará llegar hasta donde el solo pueda). Además de esto el equipo dispone del Jefe que cuando lo vea necesario mandará al equipo nuevas órdenes que determinarán sus comportamientos a partir de este momento. El líder es capaz de delegar su poder en otro tanque cuando es derribado, o incluso de intercambiar su función con otro tanque más debilitado (puesto que el jefe se limita a estar en un segundo plano detectando enemigos sin tomar partido en las batallas de forma demasiado arriesgada, por lo que siempre tendrá mas vida que los que se están arriesgando por luchar). Los tanques además pueden comunicarse mandándose Códigos. Con todo esto conseguimos que todos los tanques tengan idea de todo lo que ocurre en el terreno de juego consiguiendo una coordinación absoluta entre todos. Vamos a realizar a continuación un pequeño esquema que dejará más claro cómo es esta comunicación entre componentes del equipo: - JDKRobots. Ejecuta órdenes. - Las ordenes son ‘particulas’ de código que determinan el comportamiento del tanque, pues determinan la forma en la que se responde a los eventos.



- El JDKRobot tiene una Orden inicial denominada Inicio. Se encarga de detectar si hay compañeros o no, y si los hay de elegir jefe. - En función de que esté solo o no, siendo jefe o no siéndolo, la orden siguiente será distinta. - Cuando un tanque que está solo encuentra un enemigo se auto ordena atacarle (cambia su orden por otra que lleve a cabo el ataque al enemigo elegido). Cuando un jefe detecta enemigos ordena a los soldados disponibles atacarle. Una vez que el tanque sabe si hay compañeros o no en el terreno de juego puede suceder lo siguiente:

Lucha individual

En este apartado vamos a explicar lo que ocurre en nuestro programa cuando se realiza una lucha individual (está luchando un solo JDKRobot). Para ello explicaremos paso a paso lo que ocurre desde que se inicia la batalla hasta que esta termina. 1. Inicialmente todo tanque ejecuta la orden Inicio para saber cual es el papel que tiene asignado en este combate. En este caso al ver que no hay equipo se asigna un color y un nombre y empieza a ejecutar la orden Solo. 2. Si estamos ejecutando la orden Solo: Mientras que no detectemos ningún enemigo actuamos como actuaría un tanque que ejecutase la orden ALoLoco, pues la orden Solo hereda de ella. Es decir:

- Si no se produce ningún evento nuestro tanque avanzará mientras va girando hacia un lado y hacia el otro. - Si nos chocamos contra una pared cambiamos de dirección.

Si detectamos un enemigo: - Disparamos - Disparamos a aquel punto en el que habíamos detectado el enemigo.

- Pasamos a ejecutar la orden Ataque. 3. Si estamos ejecutando la orden Ataque: Nos posicionamos a una distancia prudencial del enemigo abatir y le disparamos mientras giramos en círculo, para dificultar ser dado. Una vez que le hemos matado volvemos a ejecutar la orden Solo. 4. Si detectamos que hemos ganado pasamos a ejecutar la orden Victoria: Tiritamos, nos movemos para adelante y para atrás unos pocos píxeles. Esto tiene como fin evitar ejecutar otro tipo de acciones que puedan ponernos en peligro, es decir, acciones que nos quiten vida (por ejemplo chocar contra paredes).



Lucha en equipo

En este apartado vamos a explicar lo que ocurre en nuestro programa cuando se realiza una lucha en equipo (están luchando cinco JDKRobots). Para ello explicaremos paso a paso lo que ocurre desde que se inicia la batalla hasta que esta termina. 1. Inicialmente todo tanque ejecuta la orden Inicio para saber cual es el papel que tiene asignado en este combate. Si es el que tiene nombre menor se autoasigna como el jefe (Ejecuta la orden Jefe) y guarda en una lista los nombres de los tanques de su equipo. Y manda al resto de los componentes del equipo el color del mismo (elegido aleatoriamente) y la orden que deben llevar a cabo: ALoLoco. En lo referente al color es fácil distinguir al jefe del resto, pues es de color ligeramente más oscuro que los demás miembros del equipo y con el cañón negro. 2. Si es el jefe: Da vueltas pegado a los bordes de la pantalla girando el visor para ver donde están los enemigos. En el momento que detecta uno puede reaccionar de dos maneras distintas: - Si estoy en condiciones que no me suponen una gran posibilidad de fallo, disparo. - Si disparar implica poder fallar, no dispara, y mando por broadcast una nueva orden para todos los demás integrantes del equipo: AcosoYDerribo. Siendo el jefe el intercambio de mensajes que puede haber es el siguiente: - He muerto, por lo tanto como era el jefe le asigno mi cargo a otro y los demás siguen haciendo lo que hacían. - Ayuda: Un soldado raso tiene poca vida. Lo que se hace en este caso es ponerlo a ejecutar la orden de Jefe, y al jefe ponerlo a ejecutar la orden de SoldadoRaso. - Recibo la muerte de un componente del equipo. En el caso de recibir esta orden, si solo quedo yo en el equipo dejo mi orden de Jefe y paso a ser SoldadoRaso. 3. Si no es el jefe: Ejecuta la orden de ALoLoco mientras que el que está ejecutando la orden Jefe no le mande ninguna orden nueva. Esta orden lo que hace es que el tanque no esté nunca quieto, y que cuando encuentre un tanque enemigo dispare. Siendo un tanque aLoLoco puede recibir y enviar las siguientes comunicaciones: -Orden de convertirse en Jefe porque el anterior Jefe ha muerto. -Orden de convertirse en jefe porque anteriormente solicito que se le sustituyese porque tenia poco vida. - Código de que tengo poca vida y necesito auxilio. - Comunicación de que he muerto. - Orden AcosoYDerribo: Me la manda el Jefe para atacar a un determinado tanque que el determina. Una vez que se acaba con el enemigo se vuelve a ejecutar la orden ALoLoco.



Tanto en un caso como en el otro, cuando se gana se ejecuta al orden Victoria. Lo que hace esta orden es hacer que el tanque tiemble para que no haga cosas que le perjudiquen.


Inteligencia en Redes de Comunicaciones 9 Jessica Rivero Espinosa (100025022) David del Valle Agudo (100025228)

CódigoEn este apartado vamos a pasar a mostrar nuestro código convenientemente comentado para el fácil entendimiento del mismo.

AcosoYDerribo.java

/* *Robocode. *Quipo: JDK. *David del Valle Agudo Y Jessica Rivero Espinosa. */

package jdk; //Jessi & David Killer team. :-) import robocode.*;

import java.io.*; import java.awt.Color; import java.util.*; /* *Orden AcosoYDerribo. *Cuando se da esta orden el tanque que la recibe sigue y ataca hasta acabar con el al enemigo de nombre *pasado como parámetro en el constructor. **Implementa un algoritmo de predicción de la trayectoria del enemigo para acertar con más facilidad si el *enemigo está en movimiento. **Su principal utilidad es para realizar emboscadas a un tanque enemigo entre varios miembros del equipo. **Cuando se recibe un impacto de un aliado nos retiramos de la trayectoria de este. De esta forma *fácilmente todos los tanques que realizan la emboscada se sitúan más o menos en círculo en torno al *enemigo. */

public class AcosoYDerribo extends Orden{ //Objetivo protected String nombreObjetivo=null;//Nombre del objetivo //Distancia al objetivo protected double minDist=200;//Mínima distancia al objetivo a la que queremos estar.

protected double maxDist=300;//Máxima distancia al objetivo a la que queremos estar. //Para trazar la trayectoria:

private double x1=0;//última coordenada x del enemigo medida. private double y1=0;//última coordenada y del enemigo medida. private long t1=0;//Momento en el que se midió por última vez la posición del enemigo. private double vel=.1;// (píxeles/ mseg.). Es una estimación de la velocidad de la bala. Medida a ojímetro.

private double velX=0;//Para almacenar la estimación de la velocidad en el eje x. Depende del ángulo entre los tanques. Inicialmente suponemos orientación del cañón en vertical.

private double velY=vel;//Para almacenar la estimación de la velocidad en el eje y. Depende del ángulo entre los tanques. Inicialmente suponemos orientación del cañón en vertical.

private double mover=50; //Lo que se desplaza el tanque en su oscilación para dificultar ser alcanzado por ataques enemigos.

public AcosoYDerribo(String nombreObjetivo){

this.nombreObjetivo=nombreObjetivo; }



//Lo ejecuta el 'run' del robot.

public void ejecutar(){

//El cañón dará vueltas para encontrar al enemigo y dispararle lo antes posible. jdk.setTurnGunLeft(1000); //Nos vamos moviendo un poco. jdk.ahead(mover); jdk.back(mover); }

//Se ha detectado un enemigo. Lo ejecuta 'onScannedRobot' del robot.

public void enemigoDetectado(ScannedRobotEvent e){

//Solo atacaremos a nuestro objetivo. if (!nombreObjetivo .equals(e.getName())){ return; }

//Tomamos los datos actuales long t2=(new GregorianCalendar()).getTimeInMillis(); double suAngulo = jdk.getHeading() + e.getBearing(); double x2=jdk.getX() + e.getDistance() * Math.sin(Math.toRadians(suAngulo)); double y2=jdk.getY() + e.getDistance() * Math.cos(Math.toRadians(suAngulo));

if(!(x1==0 && y1==0)){ velX=x2/Math.pow(Math.pow(x2-jdk.getX(),2)+Math.pow(y2-jdk.getY(),2),1/2);

//Hacemos la predicción para la x double x=0; if((jdk.getX()-x2)/(t1-t2*velX+x1-x2)>0){ x=(jdk.getX()*(x1-x2)+(t1-t2)*velX*x2)/(velX*(t1-t2)+x1-x2); }

else{ x=((t1-t2)*velX*x2-jdk.getX()*(x1-x2))/(velX*(t1-t2)-x1+x2); }

//Hacemos la predicción para la y double y=0; if((jdk.getY()-y2)/(t1-t2*velY+y1-y2)>0){ y=(jdk.getY()*(y1-y2)+(t1-t2)*velY*y2)/(velY*(t1-t2)+y1-y2); }

else{ y=((t1-t2)*velY*y2-jdk.getY()*(y1-y2))/(velY*(t1-t2)-y1+y2); }

// Calculamos el ángulo al destino. double theta = Math.toDegrees(Math.atan2(x-jdk.getX(),y-jdk.getY())); // orientamos el cañón al destino.

jdk.turnGunRight(normalRelativeAngle(theta - jdk.getGunHeading())); // Ahora podemos disparar al enemigo jdk.fire(3); //Vamos a colocar al tanque en la zona correcta ponerEnSuSitio(e,theta); }



//Guardamos los valores para la próxima predicción. x1=x2+5; y1=y2+5; t1=t2;

//Hacemos un barrido con el cañón en un margen estrechito para volver a localizar al objetivo jdk.setTurnGunRight(20); }

//Método para corregir la posición del tanque en torno al objetivo.

public void ponerEnSuSitio(ScannedRobotEvent e, double theta){

if(e.getDistance()<minDist){ jdk.turnRight(normalRelativeAngle(theta - jdk.getHeading())); jdk.back(minDist-e.getDistance()); }

if(e.getDistance()>maxDist){ jdk.turnRight(normalRelativeAngle(theta - jdk.getHeading())); jdk.ahead(e.getDistance()-minDist); }

}

//Cuando otro robot muere

public void enemigoMatado(RobotDeathEvent event){

if(event.getName().equals(nombreObjetivo)){ jdk.nuevaOrden(new ALoLoco()); }

}

//Cuando una bala nos da.

public void impactoRecibido(HitByBulletEvent e){

jdk.turnRight(90); jdk.setTurnGunLeft(90); mover=150; }

//Métodos para la simplificación de los ángulos

public double normalAbsoluteAngle(double angle) {

if (angle >= 0 && angle < 360) return angle; double fixedAngle = angle; while (fixedAngle < 0) fixedAngle += 360; while (fixedAngle >= 360) fixedAngle -= 360; return fixedAngle; }

public double normalRelativeAngle(double angle) {

if (angle > -180 && angle <= 180) return angle; double fixedAngle = angle;



while (fixedAngle <= -180) fixedAngle += 360; while (fixedAngle > 180) fixedAngle -= 360; return fixedAngle; }

}

ALoLoco.java



import java.io.*; import java.awt.Color; /* *Orden ALoLoco. *La ejecutarán los tanques cuando no tengan otra orden que ejecutar con el fin de que su posición sea *difícil de predecir. *Se mueven 'pseudoaleatoriamente' y cuando detectan un objetivo además le disparan. */

public class ALoLoco extends Orden{

private boolean movingForward; //Variable para controlar si se avanza o retrocede.


//El tanque por defecto avanzará hacia adelante mucho. //Sobre este desplazamiento iremos modificando el ángulo. jdk.setAhead(40000); movingForward = true; //Iremos girando el tanque hacia unos lados y otros. jdk.setTurnRight(90); jdk.waitFor(new TurnCompleteCondition(jdk)); jdk.setTurnLeft(180); jdk.waitFor(new TurnCompleteCondition(jdk)); jdk.setTurnRight(180); jdk.waitFor(new TurnCompleteCondition(jdk)); }

//Cuando chocamos con otro robot (onHitRobot)

public void colision(HitRobotEvent event){

//Si he sido yo el que ha topado mejor me voy. if (event.isMyFault()) reverseDirection(); }

//Cuando chocamos con la pared (onHitWall)

public void pared(HitWallEvent event){



//Nos damos la vuelta reverseDirection(); }

//Otro tanque detectado (onScannedRobot)


//Solo dispara si es enemigo y si no hay indicios de que es difícil darle, en función de su velocidad y //su distancia. if (!jdk.isTeammate(e.getName()) && e.getVelocity()*e.getDistance()<50) jdk.fire(3); }

//Método para invertir la dirección del tanque.

public void reverseDirection() {

if (movingForward){ jdk.setBack(40000); movingForward = false; }

else{ jdk.setAhead(40000); movingForward = true; }

}}

Ataque.java



import java.io.*; import java.awt.Color; import java.util.*; /* *Orden Ataque. *Esta orden es una variante de AcosoYDerribo. La ejecutarán los tanques que están sin equipo cuando *han fijado un objetivo. *La principal variación es que con esta orden se colocará más cerca del objetivo y girará en círculo hasta *acabar con el enemigo. */

public class Ataque extends AcosoYDerribo{

private double distance;//Distancia inicial a la que está el enemigo

public Ataque(String nombreObjetivo, double distance){

super(nombreObjetivo); this.distance=distance;



//Queremos estar más cerca del enemigo de lo que está previsto para emboscadas. maxDist=100; minDist=150; }

public void inicio(){

//Nos colocamos a la distancia requerida en torno al enemigo, disparamos y nos posicionamos para //empezar a girar en círculo. if(distance>maxDist)jdk.ahead(distance - maxDist); else jdk.back(minDist -distance); jdk.fire(3); jdk.turnRight(45); jdk.turnGunLeft(45); }


//Giramos poco a poco jdk.setTurnRight(20); //Giramos el cañón para detectar enemigos. jdk.setTurnGunLeft(1000); //Nos vamos moviendo un poco. jdk.ahead(40);

}

//Anulamos la funcionalidad de este método en la clase padre. //Una vez decidido donde queremos estar no nos interesará movernos.

public void ponerEnSuSitio(ScannedRobotEvent e, double theta){

}

//Cuando otro robot muere (onRobotDeath)


//Si el que ha muerto es nuestro objetivo, empezamos a buscar de nuevo objetivo. if(event.getName().equals(nombreObjetivo)){ jdk.nuevaOrden(new Solo()); }

}}

Codigo.java


package jdk; /* *Cuando los tanques quieren comunicarse entre ellos se enviarán códigos.



*/

public class Codigo implements java.io.Serializable{ //LISTA DE CODIGOS ÚTILIZADOS

public static final int MUERTO=0;//Cuando un tanque ha muerto. public static final int RELEVO=1;//Cuando un tanque está débil. //------------------ //Codigo que se envía private int c;

public Codigo(int c){

this.c=c; }

public int getCodigo(){

return c; }

}

Inicio.java



import java.io.*; import java.awt.Color; import java.lang.Math; import java.util.*; /* *Orden Inicio. *Es la 'orden' que ejecutarán todos los tanques al inicio de la batalla para tomar conciencia de quienes son *los integrantes del equipo, decidir quien es el jefe e inicializar sus colores y actividad en la partida. */

public class Inicio extends Orden{


boolean jefe=true;//Soy jefe? //Conocemos nuestro equipo

String [] equipo=jdk.getTeammates(); String miNombre=jdk.getName(); //Si hay compañeros en el terreno de juego habrá que decidir quien es el jefe, if(equipo!=null){ //Solo si soy el que tenga el nombre menor (un criterio cualquiera) me proclamo jefe del equipo. for(int i=0;i<equipo.length;i++) if(equipo[i].compareTo(miNombre)<0)jefe=false; if(jefe){ //Establezco los colores del equipo



RobotColors c=new RobotColors(); jdk.setColors(c.getBodyColorL(),c.getGunColorL(),c.getRadarColorL());

try{ //Mando los colores jdk.broadcastMessage(c); //Pongo a los demás a moverse a lo loco para evitar que sean alcanzados fácilmente hasta nueva //orden. jdk.broadcastMessage(new ALoLoco()); }

catch(IOException ioe){

//Se ha lanzado una IOException }

//Yo soy jefe. Configuro mi acción. //Inicializamos el registro con los miembros del equipo Vector registro=new Vector(); for(int i=0;i<equipo.length;i++){ Registro r=new Registro(); r.nombre=equipo[i]; registro.addElement(r); }

//Mi tarea será dirigir el equipo y buscar objetivos. jdk.nuevaOrden(new Jefe(registro,new Vector())); }

}else{

//Llegados a este punto la conclusión es que estoy solo en el campo de batalla. //Me busco la vida: me establezco mis colores y me hago autosuficiente. RobotColors c=new RobotColors(); jdk.setColors(c.getBodyColorL(),c.getGunColorL(),c.getRadarColorL()); jdk.nuevaOrden(new Solo()); }

}


//Avanzamos por hacer algo. Si no hasta que se reciba la 1º orden no sabremos que hacer y podemos //entrar en un bucle vacío. jdk.ahead(100); }

//En la orden de inicio, solo voy a aceptar (aparte de lo que se recoge en RobotJDK) el color del equipo.

public void mensajeRecibido(MessageEvent e){

if (e.getMessage() instanceof RobotColors){ //Recibimos color, y nos vestimos con él para que se nos reconozca como miembros del equipo. RobotColors c = (RobotColors)e.getMessage(); jdk.setColors(c.getBodyColor(),c.getGunColor(),c.getRadarColor()); }

}}

JDKRobot.java

/* *Robocode. *Quipo: JDK.



*David del Valle Agudo Y Jessica Rivero Espinosa. */ package jdk; // Jessica & David Killer team :-)

import robocode.*; import java.awt.Color; import java.io.*; import java.util.*; /* *JDKRobot: Robots que forman los JDKs *Estos robots extienden toda la funcionalidad de los TeamRobots para conseguir un comportamiento más *complejo y adaptable a la situación. Además permite que los integrantes de estos equipos tengan un alto *grado de colaboración en equipo. **Para conseguirlo cada JDKRobot contiene una 'unidad de comportamiento' denominada 'Orden' que se *encarga de responder a los eventos que recoge el robot, en lugar de ser el robot quien directamente lo *hace. **Para adaptarse a las nuevas condiciones de entorno que se presenten, el tanque simplemente cambiará la *Orden que ejecuta. **Cuando el líder desee que los tanques del equipo ejecuten una determinada acción, enviará a los tanques *que considere oportuno nuevos objetos Ordenes que determinarán sus comportamientos a partir de este *momento. **Los tanques además pueden comunicarse mandándose Códigos. */

public class JDKRobot extends TeamRobot{

//PROPIEDADES private Orden orden;//Ordenes que ejecuta el tanque actualmente.

//MÉTODOS //Método run: Comportamiento por defecto.

public void run() {

//Debe comenzarse la ejecución con orden de inicialización. nuevaOrden(new Inicio()); //Después de ejecutará siempre este bucle, salvo que se atiendan eventos. while(true) orden.ejecutar();

}

//Método para gestionar todo lo que se recibe: Ordenes, Códigos...

public void onMessageReceived(MessageEvent e){ if (e.getMessage() instanceof Orden){ //Recibimos una orden, la acatamos. nuevaOrden((Orden)e.getMessage()); }

else if (e.getMessage() instanceof Codigo){ //Recibimos un código, lo estudiamos. orden.codigoRecibido((Codigo)e.getMessage(),e.getSender()); }

else{ //Si no es nada de esto, pasamos el mensaje a la Orden por si es un tipo de dato útil para ella en la



//acción que está realizando. orden.mensajeRecibido(e); }

}

//Nueva orden //Método que se ejecuta para cambiar de orden.

public void nuevaOrden(Orden o){

orden=o; orden.soy(this);//indicamos quien soy a la orden que voy a realizar. }

//Cual es mi orden actual.

public Orden getOrden(){

return orden; }

//Reencamino todos los eventos para que se ejecuten en el contexto de la orden actual encomendada.

public void onBulletHitBullet(BulletHitBulletEvent event){

orden.impactoAImpacto(event);}

public void onBulletHit(BulletHitEvent event){

orden.impactoAcertado(event);}

public void onBulletMissed(BulletMissedEvent event){

orden.impactoFallido(event);}

public void onHitByBullet(HitByBulletEvent event){

orden.impactoRecibido(event);}

public void onHitRobot(HitRobotEvent event){

orden.colision(event);}

public void onHitWall(HitWallEvent event){

orden.pared(event);}

public void onDeath(DeathEvent event){

orden.muerte(event);}

public void onScannedRobot(ScannedRobotEvent event){

orden.enemigoDetectado(event);}

public void onRobotDeath(RobotDeathEvent event){

orden.enemigoMatado(event);}

public void onSkippedTurn(SkippedTurnEvent event){



orden.penalizacion(event);}

public void onCustomEvent(CustomEvent event){

orden.eventoPrivado(event);}

public void onWin(WinEvent event){

orden.victoria(event);} }

Jefe.java


package jdk; //Jessi & David Killer team. :-) import robocode.*; import java.io.*; import java.awt.Color; import java.lang.Math; import java.util.*; /* *Orden Jefe. *Es la Orden que ejecutará el tanque que se declara líder del equipo. Su misión será la de buscar *objetivos, ordenar a los tanques del equipo atacarlos, dejar heredero si muere... **Intentará en la medida de lo posible salvar el pellejo dando vueltas por los bordes del terreno de juego. *Solo se despegará del borde ante ataques. */

public class Jefe extends Orden{

private Vector registroEquipo=new Vector(); //Registro de los miembros del equipo. private Vector registroEnemigos=new Vector(); //Registro de los robots enemigos. private double moveAmount; //Indica cuantos píxeles se debe mover.

private String aPor =null;//Variable que se activa cuando hay una emboscada en curso con el nombre del objetivo

//METODOS

public Jefe(Vector registroEquipo, Vector registroEnemigos){

this.registroEquipo=registroEquipo; this.registroEnemigos=registroEnemigos; }

//Inicialización del jefe.


jdk.setTurnGunRight(2000);//Empezamos a dar vueltas el cañón (con el radar) moveAmount = Math.max(jdk.getBattleFieldWidth(),jdk.getBattleFieldHeight());

//Giro los grados que me faltan hasta estar en perpendicular a alguna pared. jdk.turnLeft(jdk.getHeading() % 90);



}

//Acción normal del jefe. Dar vueltas sin separarse de las paredes.


//como mínimo llegamos a la otra pared. jdk.ahead(moveAmount); }

//Cuando se detecta un enemigo


if (!jdk.isTeammate(e.getName())){ //Si no es del equipo, no se mueve mucho, no está muy lejos y me encuentro suficientemente bien le //ataco, para evitar perder energía a lo tonto. Somos el jefe y tenemos la obligación de mantenernos //vivos todo lo que podamos.

if(jdk.getEnergy()>80 && e.getVelocity()*e.getDistance()<50){ jdk.fire(3); }

//Mandamos un mensaje para hacer una emboscada a el robot enemigo detectado: if(aPor==null){ aPor=e.getName();//A por este!!

try{ jdk.broadcastMessage(new AcosoYDerribo(aPor)); }

catch (IOException ex) {

}}

}}

//Hemos chocado con otro.

public void colision(HitRobotEvent e){

//Si le tenemos en frente mejor cambiamos la trayectoria puesto que si no nos moveremos hacia //él y seremos fácilmente alcanzables. if (e.getBearing() > -90 && e.getBearing() < 90){ jdk.turnRight(45); jdk.back(100); jdk.turnRight(45); }

//Si no avanzamos y ya está else jdk.ahead(100); jdk.setTurnGunRight(2000);//Seguimos dando vueltas al cañón (con el radar).

}

//Método para recibir un código

public void codigoRecibido(Codigo c, String robotOrigen){



int codigo=c.getCodigo(); if (codigo==Codigo.MUERTO){ //Si se nos ha muerto uno: //Le eliminamos de nuestro registro y llamamos a la familia: una baja más. Registro r=buscarEnEquipo(robotOrigen); if(r!=null)registroEquipo.remove(r); //Si solo quedo yo o quedamos menos de dos, tengo que cambiar de estrategia, será mejor si cada //uno intenta salvar su pellejo por si solo. Todos soldado raso y que sea lo que dios quiera. if(registroEquipo.size()<2){ jdk.nuevaOrden(new SoldadoRaso()); try{ jdk.broadcastMessage(new SoldadoRaso());//Por si queda otro.

}


//IOException }

}}

}

//Lo que debe ejecutar el 'onHitByBullet' del tanque


if((e.getBearing()%90)==0){ //Me están disparando desde la dirección en la que me desplazo. jdk.turnRight(45);//Cambiamos de dirección

jdk.ahead(moveAmount);//Y avanzamos. }

}



if((jdk.getHeading() % 90)==0)jdk.turnRight(90);//Si estamos perpendiculares a la pared else jdk.turnRight(90-jdk.getHeading() % 90);//Si no estamos perpendiculares a la pared. jdk.setTurnGunRight(2000);//Empezamos a dar vueltas el cañón de nuevo(con el radar).

}



//Le eliminamos del registro. Uno menos. Registro r=buscarEnEnemigos(event.getName()); registroEnemigos.remove(r); if(event.getName().equals(aPor)){ aPor=null; }

}

//Me matan:

public void muerte(DeathEvent event){



//Si quedan más de dos miembros del equipo deberíamos reorganizar el grupo antes de morir heroicamente. if(registroEquipo.size()>2){ //El primero será el nuevo jefe. Registro jefe=(Registro)registroEquipo.elementAt(0); registroEquipo.remove(jefe); try{ jdk.sendMessage(jefe.nombre,new Jefe(registroEquipo,registroEnemigos));//Defiende lo que yo no he podido defender.

}


//IOException }

}else{

try{ //Con los que quedan no hay para reorganizar el equipo. Cada uno que haga lo que pueda. jdk.broadcastMessage(new SoldadoRaso()); }


//IOException }

}}

//Para buscar un soldado en el registro

public Registro buscarEnEquipo(String s){

for(int i=0;i<registroEquipo.size();i++) if(!(((Registro)registroEquipo.elementAt(i)).nombre.equals(s))) return (Registro)registroEquipo.elementAt(i); return null; }

//Para buscar un enemigo en el registro

public Registro buscarEnEnemigos(String s){

for(int i=0;i<registroEnemigos.size();i++) if(!(((Registro)registroEnemigos.elementAt(i)).nombre.equals(s))) return (Registro)registroEnemigos.elementAt(i); //Pero si hemos encontrado un enemigo nuevo del que no teníamos constancia, lo creamos Registro r=new Registro(); r.nombre=s; registroEnemigos.addElement(r); return r; }

}

Orden.java

/* *Robocode. *Quipo: JDK.



*David del Valle Agudo Y Jessica Rivero Espinosa. */

package jdk; //Jessi & David Killer team. :-) import robocode.*; import java.io.*; import java.awt.Color; /* * * Clase Orden. * * Las clases que extienden de esta representan el comportamiento de tanques. * Todo tanque contendrá un objeto 'Orden' y todo lo que hace el tanque viene determinado por las * acciones que contiene su 'Orden'. * * Cuando el mando del equipo quiere encomendar otra misión a este tanque le envía un nuevo * objeto Orden, a partir de este momento, y hasta nueva orden, el comportamiento del tanque en * todos los aspectos estará determinado por lo que contiene el nuevo objeto Orden. * * La clase Orden responde a todos los posibles eventos que puede recibir un tanque. * * En ningún caso es necesario definir la acción de todos los métodos, solo las de los métodos que * se consideren oportunos para cumplir una orden. * */

public class Orden implements java.io.Serializable{

//PROPIEDADES JDKRobot jdk; //Robot cuya acción ahora está controlando esta Orden.

//MÉTODOS

//IDENTIFICACIÓN

public void soy(JDKRobot jdk){

//Se identifica a quien se controla this.jdk=jdk; //Se coloca el cañón mirando al frente. jdk.turnGunRight(jdk.getHeading()-jdk.getGunHeading());//Al iniciarse tiene que estar el cañón orientado hacia el frente para que funcione bien. //Se ejecutan las acciones de inicio. inicio(); }

//EJECUCIÓN //-------- //Lo que debe ejecutar el 'run' del tanque al que se le ha mandado esta orden. //En inicio se ejecutan las acciones de inicialización que se suelen incluir al comienzo del método run. //En ejecutar se realizan las acciones que se suelen realizar dentro del bucle while que hay dentro del run //normalmente. //Nota. no hay que poner en código el buche, el método ejecutar se ejecuta en un bucle dentro del 'run' //del robot .

//Método para inicializar




}


}

//METODOS PARA LA GESTION DE EVENTOS DEL ROBOT //-------------------------------------------- //Cuando morimos se ejecuta 'Ondead' es para que hagamos algo antes de morir.

public void muerte(DeathEvent event){

try{ jdk.broadcastMessage(new Codigo(Codigo.MUERTO)); }


//IOException }

}

//Cuando no hacemos nada en mucho tiempo el juego nos avisa. Tiene penalización (onSkippedTurn)

public void penalizacion(SkippedTurnEvent event){

}

//Se ejecutará con 'onCustomEvent'

public void eventoPrivado(CustomEvent event){

}

//Cuando una bala que hemos lanzado acierta (onBulletHit)

public void impactoAcertado(BulletHitEvent event){

}//Cuando nuestra bala choca con otra bala (onBulletHitBullet)

public void impactoAImpacto(BulletHitBulletEvent event){

}

//Lo que debe ejecutar el 'onHitByBullet' del tanque


}

//Método que se ejecuta cuando una bala que hemos lanzado se pierde (onBulletMissed)

public void impactoFallido(BulletMissedEvent event){

}

//Cuando chocamos con otro robot (onHitRobot)



public void colision(HitRobotEvent event){

}



}



}

//Otro tanque detectado (onScannedRobot)


}

//Lo que se ejecuta cuando nuestro robot gana (onWin). //Paramos todo para evitar perder vida a lo tonto, por ejemplo chocando contra paredes...

public void victoria(WinEvent event){

jdk.nuevaOrden(new Victoria()); }

//RECEPCIÓN DE CÓDIGOS //-------------------- //Método para recibir un código. Un código es un entero que indica una tiene un significado para el que //lo recibe. este significado está definido en la clase Código.

public void codigoRecibido(Codigo c, String robotOrigen){

}

//RECEPCIÓN DE MENSAJES: Puede haber objetos pasados como mensajes específicos para esta orden.

public void mensajeRecibido(MessageEvent e){

}}

Registro.java

package jdk; /** * Donde el jefe guarda los datos de los miembros del equipo y de los enemigos. */

public class Registro{ public String nombre; }



RobotColors.java

package jdk; import java.awt.Color; import java.lang.Math;

/** * RobotColors - A serializable class to send Colors to teammates */

public class RobotColors implements java.io.Serializable{ private Color bodyColor; private Color gunColor; private Color radarColor; private Color bodyColorL; private Color gunColorL; private Color radarColorL;

public RobotColors(){ //El color se elige aleatoriamente int rL=(int)Math.round(Math.random()*200); int gL=(int)Math.round(Math.random()*200); int bL=(int)Math.round(Math.random()*200); int r=rL+55; int g=gL+55; int b=bL+55; this.bodyColor = new Color(r,g,b); this.gunColor = new Color(r,g,b); this.radarColor = new Color(r,g,b); this.bodyColorL = new Color(rL,gL,bL); this.gunColorL = new Color(0,0,0); this.radarColorL = new Color(0,0,0); }

public Color getBodyColor(){ return bodyColor; }

public Color getGunColor(){ return gunColor; }

public Color getRadarColor(){ return radarColor; }

public Color getBodyColorL(){ return bodyColorL; }

public Color getGunColorL(){ return gunColorL; }

public Color getRadarColorL(){ return radarColorL; }

}



SoldadoRaso.java


package jdk; //Jessi & David Killer team. :-) import robocode.*; import java.io.*; import java.awt.Color; /* *Orden SoldadoRaso. *La ejecutan los tanques cuando el equipo está muy mermado. *Tienen un comportamiento 'camicace'. Buscan cualquier objetivo y van contra el hasta que mueren o *muere. *No obstante si tiene poca energía pide relevo a el jefe (por si todavía esta vivo que le releve). */

public class SoldadoRaso extends Orden{ int turnDirection = 1; // Estamos buscando en un sentido o en otro.

//METODOS //Acción normal del soldadoRaso. Gira sobre si mismo buscando objetivos.


jdk.turnRight(5 * turnDirection);

}

//Hemos detectado un enemigo.


//Si es miembro de nuestro equipo no hacemos nada. if(jdk.isTeammate(e.getName())) return; //En función de nuestra orientación establecemos el sentido de giro uno u otro if (e.getBearing() >= 0) turnDirection = 1; else turnDirection = -1; //Giramos y disparamos en función de su energía antes de acercarnos. jdk.turnRight(e.getBearing()); if (e.getEnergy() > 16) jdk.fire(3); else if (e.getEnergy() > 10) jdk.fire(2); else if (e.getEnergy() > 4) jdk.fire(1); else if (e.getEnergy() > 2) jdk.fire(.5); else if (e.getEnergy() > .4) jdk.fire(.1); //Nos acercamos y ponemos el radar a funcionar para no perderle.



jdk.ahead(e.getDistance() - 20); jdk.scan(); }

//Si nos dan giramos, al desviarnos de nuestra trayectoria es menos probable que nos den de nuevo.


jdk.turnRight(15); }

//Si chocamos con otro tanque:

public void colision(HitRobotEvent e){

//Si es de los nuestros no hacemos nada. if(jdk.isTeammate(e.getName())) return; //Pero si no le freímos y avanzamos sobre él. if (e.getBearing() >= 0) turnDirection = 1; else turnDirection = -1; jdk.turnRight(e.getBearing());

if (e.getEnergy() > 16) jdk.fire(3); else if (e.getEnergy() > 10) jdk.fire(2); else if (e.getEnergy() > 4) jdk.fire(1); else if (e.getEnergy() > 2) jdk.fire(.5); else if (e.getEnergy() > .4) jdk.fire(.1); if(jdk.getEnergy() > e.getEnergy()) jdk.ahead(40); }

}

Solo.java



import java.io.*; import java.awt.Color; /* *Orden Solo. *Es una modificación de la clase ALoLoco para permitir al tanque desenvolverse solo. **Para tanques que están solos en el terreno de juego. *Son autosuficientes. Fijan un objetivo y se auto ordenan atacarle.



*/

public class Solo extends ALoLoco{ //Otro tanque detectado (onScannedRobot)


if (!jdk.isTeammate(e.getName())){ //Si no es del equipo lo disparamos antes de nada. jdk.fire(3); //Nos orientamos hacia el y volvemos a disparar. jdk.turnRight(e.getBearing()); jdk.fire(3); //Y ahora nos ordenamos atacarlo hasta acabar con él. jdk.nuevaOrden(new Ataque(e.getName(),e.getDistance())); }

}}

Victoria.java


import java.io.*; import java.awt.Color; import java.lang.Math; import java.util.*; /** *Orden que se ejecuta en cuanto se detecta la victoria de nuestro equipo. Es para evitar hacer cualquier *otra cosa que pueda perjudicar al equipo, por ejemplo seguir disparando. */

public class Victoria extends Orden{


//Simplemente oscilamos. jdk.ahead(2); jdk.back(2); }

}

realizado por: jessica rivero espinosa (100025022) david ... · cooperación necesita más bien una...

Documents