1 Mem

Realizado por:
Jessica Rivero Espinosa (100025022)

David del Valle Agudo (100025228)
Practica Final: ROBOCODE
Índice
Página
Índice 1
ROBOCODE 2
Explicación del funcionamiento de la práctica 3
Nuestros robots 3
Lucha individual 6
Lucha en equipo 7
Código 9
AcosoYDerribo.java 9
ALoLoco.java 12
Ataque.java 13
Codigo.java 14
Inicio.java 15
JDKRobot.java 16
Jefe.java 19
Orden.java 23
Registro.java 26
RobotColors.java 26
SoldadoRaso.java 27
Solo.java 29
Victoria.java 29
Inteligencia en Redes de Comunicaciones -1- Jessica Rivero Espinosa (100025022)

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. (Jessica & David Killer 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.

Código
En 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;
}
Inteligencia en Redes de Comunicaciones 9 Jessica Rivero Espinosa (100025022)

//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);
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
/*
*Robocode.
*Quipo: JDK.
*/

import robocode.*;
import java.io.*;
/*
*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);
}
//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
/*
*Robocode.
*Quipo: JDK.
*/

import robocode.*;
import java.io.*;
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

//Giramos el cañón para detectar enemigos.
//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
/*
*Robocode.
*Quipo: JDK.
*/
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
/*
*Robocode.
*Quipo: JDK.
*/

import robocode.*;
import java.io.*;
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.

*/
package jdk; // Jessica & David Killer team :-)
import robocode.*;
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
/*
*Robocode.
*Quipo: JDK.
*/

import robocode.*;
import java.io.*;
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.

*/

import robocode.*;
import java.io.*;
/*
*
* 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){
//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;
/**
* 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
/*
*Robocode.
*Quipo: JDK.
*/

import robocode.*;
import java.io.*;
/*
*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);
jdk.fire(1);
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;
if (e.getEnergy() > 16)

jdk.fire(3);
jdk.fire(2);
jdk.fire(1);
jdk.fire(.5);
else if (e.getEnergy() > .4)
jdk.fire(.1);
if(jdk.getEnergy() > e.getEnergy())
jdk.ahead(40);
}
}
Solo.java
/*
*Robocode.
*Quipo: JDK.
*/

import robocode.*;
import java.io.*;
/*
*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{

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.fire(3);
//Y ahora nos ordenamos atacarlo hasta acabar con él.
jdk.nuevaOrden(new Ataque(e.getName(),e.getDistance()));
}
}
}
Victoria.java
import robocode.*;
import java.io.*;
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);
}
}


1 Mem

Încărcat de

Informații document

Descriere originală:

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

1 Mem

Încărcat de

Drepturi de autor:

Formate disponibile

Realizado por:

Jessica Rivero Espinosa (100025022)

Explicación del funcionamiento de la práctica 3

Inteligencia en Redes de Comunicaciones -1- Jessica Rivero Espinosa (100025022)

Se van a desarrollar dos modos de juego:

Balas, condiciones, mensajes… pero sobre todo tanques (robots).

Estos robots representan tanques en la pantalla. Como se

NOTA: El radar es un elemento del que se puede carecer

o broadcastMessage(Serializable message): Envía un mensaje broadcast a todos

Inteligencia en Redes de Comunicaciones -2- Jessica Rivero Espinosa (100025022)

o waitFor(Conditioncondition): Este método no devuelve el mando al programa

Explicación del funcionamiento de la práctica

J.D.K. (Jessica & David Killer Team)

A primera vista un Robot tiene un comportamiento definido y único. Se pasa el tiempo

Inteligencia en Redes de Comunicaciones -3- Jessica Rivero Espinosa (100025022)

Nuestros tanques, JDKRobots, poseen una interesante capacidad. Su comportamiento

Y es la Orden que en un momento concreto lleva asociado un tanque la que le llevará a

Presentamos la tabla de todas las ordenes que presentan nuestros tanques:

Inteligencia en Redes de Comunicaciones -4- Jessica Rivero Espinosa (100025022)

Inicio Orden inicial de los tanques.

Los tanques además pueden comunicarse mandándose Códigos.

- JDKRobots. Ejecuta órdenes.

2. Si estamos ejecutando la orden Solo: Mientras que no detectemos ningún enemigo

3. Si estamos ejecutando la orden Ataque: Nos posicionamos a una distancia prudencial

Inteligencia en Redes de Comunicaciones -6- Jessica Rivero Espinosa (100025022)

Siendo el jefe el intercambio de mensajes que puede haber es el siguiente:

Siendo un tanque aLoLoco puede recibir y enviar las siguientes comunicaciones:

Inteligencia en Redes de Comunicaciones -7- Jessica Rivero Espinosa (100025022)

Inteligencia en Redes de Comunicaciones -8- Jessica Rivero Espinosa (100025022)

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

public class AcosoYDerribo extends Orden{

public AcosoYDerribo(String nombreObjetivo){

Inteligencia en Redes de Comunicaciones 9 Jessica Rivero Espinosa (100025022)

//Lo ejecuta el 'run' del robot.

public void ejecutar(){

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

public void enemigoDetectado(ScannedRobotEvent e){

//Solo atacaremos a nuestro objetivo.

//Tomamos los datos actuales

if(!(x1==0 && y1==0)){

//Hacemos la predicción para la x

//Hacemos la predicción para la y

// Calculamos el ángulo al destino.

Inteligencia en Redes de Comunicaciones 10 Jessica Rivero Espinosa (100025022)

//Guardamos los valores para la próxima predicción.

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

public void ponerEnSuSitio(ScannedRobotEvent e, double theta){

//Cuando otro robot muere

public void enemigoMatado(RobotDeathEvent event){

//Cuando una bala nos da.

public void impactoRecibido(HitByBulletEvent e){

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

public double normalAbsoluteAngle(double angle) {

if (angle >= 0 && angle < 360)

public double normalRelativeAngle(double angle) {

if (angle > -180 && angle <= 180)

Inteligencia en Redes de Comunicaciones 11 Jessica Rivero Espinosa (100025022)

while (fixedAngle <= -180)

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

public class ALoLoco extends Orden{

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

public void ejecutar(){