IRC Practica final 0405jvillena/irc/practicas/04-05/11mem.pdf · Coderuler es un simulador de...

INTELIGENCIA EN REDES DE COMUNICACIONES

CURSO 04/05

CODERULER

JOSÉ PABLO MARTÍNEZ CASTAÑO 100025200 RICARDO LUCENA RODRÍGUEZ 100025110

INTELIGENCIA EN REDES DE COMUNICACIONES CODERULER

1

ÍNDICE Página

1. Coderuler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.1 Introducción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Elementos de Coderuler. . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.1 El peón. 1.2.2 El caballero. 1.2.3 El Castillo.

1.3 El monarca: The Ruler. . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.4 El escenario de la batalla y puntuación. . . . . . . . . . . . . 6

2. Agentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 3. Programando Coderuler. . . . . . . . . . . . . . . . . . . . . . . 9


2

1. Coderuler

1.1 Introducción

Coderuler es un simulador de batallas basado en un mundo medieval imaginario en el que los diferentes jugadores pueden considerarse monarcas de su propio reino del medievo. Es una aplicación Java sobre la plataforma Eclipse para dar a la programación en java nuevos alicientes que animen a los programadores a buscar nuevas funcionalidades e incluso mejorar sus habilidades en este campo. Su origen data de 2004, concebido para el ACM Internacional Collegiate Programming Competition de dicho año para demostrar las habilidades de los programadores de las diferentes instituciones en un juego de simulación puramente visual y sin intervención humana.

En el juego, cada jugador tiene a su disposición una serie de elementos que se

detallarán en el próximo apartado, para ganar la contienda contra un máximo de 5 oponentes con los que tendrá que luchar para conseguir el dominio del mapa.

Fig.1 Ejemplo de batalla con 6 jugadores en Coderuler En cada turno los diferentes jugadores deben realizar sus movimientos para

conseguir adquirir siempre el mayor número de puntos, a través de la captura de otros castillos, la destrucción de unidades enemigas y la conquista de territorio.


3

1.2 Elementos de Coderuler

En Coderuler tenemos a nuestra disposición tres tipos de elementos fundamentales para elaborar nuestras estrategias, ya que el juego gira en torno a ellos: el peón, el caballero y el castillo. La conquista del castillo de cada rival, la derrota de sus caballeros y peones así como la expansión de tus peones por todo el mapa son los tres tipos de objetivos que debes alcanzar para conseguir la más grande de las victorias. 1.2.1 El peón

El peón es la unidad encargada de la conquista de territorio para tu reino. Su única acción es la de moverse pero, eso sí, cada vez que se mueve a una posición del mapa que no es de tu propiedad, la cambia a tu color (azul para el jugador 1, morado para el dos) independientemente de si estaba sin ocupar o de si ya pertenecía a otro jugador.

Tanto el peón como el caballero tienen hasta 9 posibilidades a la hora de moverse, correspondientes a las 8 direcciones cardinales genéricas más el movimiento nulo (es decir, imposibilidad para mover). Los peones podrán moverse en cualquier dirección si no existe ningún obstáculo que se lo impida, ya sea otro elemento del tablero ocupando dicha posición o bien cualquiera de los bordes exteriores. Podemos ver un gráfico de dicho movimiento a continuación.

Para programar el movimiento del peón se ha buscado seguir una estrategia que nos permita conquistar de la manera más rápida y por tanto eficiente el tablero. Esta se basa en un movimiento que se asemeja a una espiral en sentido horario en el cual los peones siempre intentar tomar las posiciones que, siguiendo este movimiento, bordean las ya tomadas. Hay varios eventos que pueden modificar este movimiento, que son el encontrarse con un borde del tablero o con otro de los tres elementos. En cualquier caso, si puede ser


4

rodeado el obstáculo, se rodea procediendo con el mismo movimiento que llevaba; si no puede rodearse por el contrario, el movimiento procede a cambiar el sentido de giro, de horario a antihorario o viceversa.

Fig.2 Ejemplo de movimiento de los peones

Además cuando se crean nuevos peones, así como cuando estos no pueden moverse en un sentido de giro ni otro (es decir, todas las posiciones de los alrededores o bien están ocupadas o bien ya nos pertenecen) estos buscan la casilla no conquistada mas cercana. Si no la encuentran se les dirige a una dirección aleatoria que va cambiando según se vuelven a encontrar en la misma situación (siguen sin haber llegado a una posición que tomar).

Por otra parte dicha secuencia de movimiento se ve interrumpida si aparecen

caballeros enemigos. En este caso se desplazaran alejándose de estos en cualquiera de las 3 direcciones posibles

1.2.2 El caballero

El caballero es la unidad encargada de capturar unidades enemigas de entre los tres tipos de elementos existentes. Además de mover, ya explicado en el apartado del peón, puede realizar la acción de captura. Capturar varía dependiendo de sobre qué elemento se ejecute:

- capturar un peón lo elimina inmediatamente del mapa. - capturar un castillo lo cambia a tu color y te permite sacar unidades como si fuera

tu castillo inicial.


5

- capturar un caballero quita entre 15 y 30 puntos de fuerza aleatoriamente al oponente de un máximo de 100 iniciales. Cada vez que se derrota un caballero enemigo se recuperan 20 puntos.

La táctica seguida por nuestros caballeros consiste en: Primero ven su zona circundante. Si tienen enemigos contiguos los atacan (entre

ellos al más débil). A continuación se encargan de la defensa de los castillos asignando un área circular

alrededor de este donde los caballeros se mueven aleatoriamente para dirigirse a los caballeros enemigos en cuanto entran en su rango de visión (un radio de tamaño un número de posiciones determinado).

Si no hubiera enemigos en el área de defensa se dedicarían atacar a las unidades

según las prioridades indicadas a continuación (de mayor a menor): - captura de caballeros enemigos, no pasando a la siguiente hasta que no hayan

capturado todos. - captura de castillos enemigos. - captura de peones enemigos.

Estas dos últimas podrían intercambiar su prioridad si hay peones enemigos en el

camino al castillo a capturar. Además, comentar que siempre ataca al elemento más cercano de cada uno de estos grupos, ya sea caballero, peón o castillo, ya que de no ser así los caballeros enemigos ganarían más fácilmente.

Sin embargo dicha prioridad se cambia en el caso de quedarse sin castillo. En este

caso la prioridad de ataque es a los castillos. Por ultimo y en casos extremos (cuando queden muy pocos caballeros) estos tienen

orden de huir para así poder sobrevivir ya que lo más normal es que este caso lleve a la toma de nuestro castillo y poder posteriormente retomarlo

1.2.3 El castillo

El castillo es el único elemento que no se mueve, ni ataca, ni interactúa directamente con otros elementos. Un monarca (Ruler) puede llegar a tener hasta 6 castillos, uno por cada jugador, y todos se rigen por las mismas reglas ya que no existe distinción entre castillo principal o secundarios.

Su tarea es la de generar unidades, ya sean peones o caballeros según el algoritmo que se le haya asignado para diferentes situaciones. Por defecto genera peones, aunque


6

tanto ellos como los caballeros se crean según una tasa definida por el número de posiciones conquistadas en el mapa:

Posiciones conquistadas Tasa de creación (Turnos) 124 o menos No se crean

125 14 250 12 500 10 1000 82000 6

Más de 4000 4

Nuestra estrategia consiste en la creación de caballeros si estos están en una cantidad inferior a la inicial, que implica un refuerzo debido a una batalla que está aconteciendo y peones en caso de que este número se mantenga constante. Así mismo si no hay caballeros suficientes para la defensa el castillo construye caballeros.

1.3 El monarca: The Ruler

El Ruler es el encargado de la inicialización de todas y cada una de las unidades del reino, la posterior creación de las diferentes unidades y las prioridades en su construcción en el castillo según la situación global, además de dar las órdenes de movimiento a los peones así como la de ataque a los diferentes caballeros.

1.4 El escenario de la batalla

El escenario, el mapa, el terreno de la contienda es un tablero de 4.608 posiciones con unas dimensiones de 72 cuadrados de ancho por 64 de alto donde cada posición podemos asignarle unas coordenados (x,y) según los ejes cartesianos (siempre positivas) donde (0,0) es la posición superior izquierda.

Junto al marco principal tenemos tres indicadores que nos proporcionan información de la batalla: el indicador de puntuación de cada jugador y de posiciones tomadas (Fig. 3.a), el minimapa de ocupación global del tablero (Fig. 3.b) y el reloj de turnos que tras una vuelta finaliza la partida (Fig 3.c).


7

Fig. 3.a Fig 3.b Fig 3.c

El sistema de puntuación es acorde con el número de posiciones conquistadas (1 punto por cada 10 posiciones), el número de unidades vencidas (castillos 15, caballeros 6 y peones 4) y número de unidades que poseas al dar el reloj la vuelta completa (castillos 25, caballeros 2 y peones 1).

Finalmente solo nos queda comentar que nuestro algoritmo de expansión como puede verse en la Fig 3.b es el más eficiente que hemos alcanzado a discurrir dado que una mayor profundización en la inteligencia individual de cada peón nos ha llevado a pasarnos del límite temporal de medio segundo para cada turno. Sin embargo el algoritmo de los caballeros sabemos que puede mejorarse, ya que hay infinidad de tácticas que funcionarán mejor o peor según el adversario, porque no puede existir el enemigo imbatible, de modo que se trabajará en su continua búsqueda de mayor eficiencia.


8

2. Agentes

La resolución de la práctica se ha efectuado programando las unidades como si fueran agentes.

Todas las unidades tienen programadas unas pautas de conducta en función del medio, tanto del tablero (posesión de tierras) como de los otros agentes: -Los peones se mueven a las zonas cercanas que no estén controladas por nuestro reino. -Los caballeros atacan en función de los alrededores. -Los castillos actúan como un agente que en función de sus necesidades solicita la colaboración de los caballeros para su defensa, así como toma sus propias decisiones sobre lo que debe construir.

Todas las decisiones de movimiento y conquista las toman solo teniendo en cuenta estos parámetros y no requieren de intervención de nadie más. Además debido a este estudio hemos visto que aparecen conductas que en principio no se habían programado específicamente ni se esperaban, como es el caso de que los peones siguen a los peones enemigos que se acerquen a sus zonas ya que tienden a recuperar el terreno que se les ha quitado o que los caballeros tienden a perseguir a los caballeros enemigos que persiguen a peones, ya que esto se suele dar en las proximidades del área de defensa del castillo y cuando se alejan resultan ser su unidad enemiga mas próxima.

Así pues todas nuestras unidades tienen las características principales de un agente: -Autonomía: deciden por si mismos (o a petición de otros) sus objetivos. -Reactividad: Reaccionan al entorno (atacan, huyen, buscan expandirse). -Proactividad: Se mueven intentando expandirse (peones), no ser tomados (castillos) o eliminar a los enemigos (caballeros). -habilidad social: reaccionan a otros agentes (huyen, contraatacan, piden a las unidades que les defiendan). No obstante no hay capacidades de autoaprendizaje debido a las características del problema (limitación del tiempo de cómputo) si bien dichas características hubieran sido interesantes.


9

3. Programando Coderuler A continuación se adjunta el código comentado de nuestra aplicación: CLASE MYRULER: import java.util.Random; import com.ibm.ruler.*; /** * La clase MyRuler implementa el comportamiento general del sistema. Contiene 2 * metodos fundamentales. El primero initialize genera las estructuras de datos * que se van a usar para lograr los comportamientos programados. El segundo * orderSubjects indica a cada tipo de objeto (castillo, peones y caballeros) que * realize las tareas asignadas. * * @author José Pablo Martínez Castaño 100025200 * @author Ricardo Lucena Rodríguez 100025110 * */ public class MyRuler extends Ruler { /** Numero aleatorio*/ private Random rand; /** * Define la relacion entre el numero de caballeros que debemos tener y * los que tiene cada uno de los otros jugadores */ private final static float KNIGHTRATIO=(float)1.5; /** * Minimo absoluto de caballeros que debemos disponer en un cualquier turno */ private final static int MINIMUMKNIGHT=15; /** * Distancia maxima entre 2 puntos cualesquiera del tablero */ private final static int MAXBOARDDISTANCE = 72;

/** * Nombre del Ruler * @see com.ibm.ruler.Ruler#getRulerName() * @return El nombre del Ruler */ public String getRulerName() { return "R. Lucena, J.P. Martinez"; }

/** * Nombre de la escuela * @see com.ibm.ruler.Ruler#getSchoolName() * @return El nombre de la escuela */ public String getSchoolName() { return "UC3M"; }

/** * Metodo que se invoca, una única vez, al comenzar el juego. * En el se inicializan las matrices que contienen los datos para * determinar los comportamientos en base al turno anterior *


10

* @see com.ibm.ruler.Ruler#initialize() */ public void initialize() { // Se inicializan las estructuras de los 3 tipos de unidades rand=new Random(); Peasant.initializePeasant(this); Knight.initialization(this); Castle.initializeCastles(this); }

/** * Se invoca en cada turno de juego. Da las ordenas a las unidades del * jugador. Debe durar menos de 0.5 segundos. Los ordenes se dan siguiendo * este orden: * - Los caballeros que tengan enemigos contiguos los atacan * - Si hay pocos caballeros, ordenamos crear mas. * - Los castillos solicitan las unidades necesarias para la defensa * - Los caballeros restantes atacan * - Movimiento de peones *

* @param lastMoveTime Tiempo consumido en el turno anterior, * @see com.ibm.ruler.Ruler#orderSubjects(int) */ public void orderSubjects(int lastMoveTime) { //Obtenemos todos nuestras unidades IPeasant[] myPeasants = getPeasants(); IKnight[] myKnights = getKnights(); ICastle[] myCastles = getCastles();

//Todos los caballeros se defienden for (int i=0;i<myKnights.length;i++) { if (Knight.underAttack(myKnights[i])) { myKnights[i]= null; }

}

//Establecemos la defensa de los castillos for (int i=0;i<myCastles.length;i++) { //Por defecto el castillo crea peones createPeasants(myCastles[i]); /* Indicamos a cada castillo que tome los caballeros necesarios para * su defensa */ int numCabDisp=myKnights.length; for (int j=0;j<myKnights.length;j++) { if (myKnights[j]==null) numCabDisp--; }

if (getKnights().length<4) { IKnight[] knights=getKnights(); for (int j=0;j<knights.length;j++) { Knight.evade(knights[i]); }

} else { myKnights= Castle.defenderCastillo(myCastles[i],myKnights,numCabDisp);

}//Si hubiera pocos caballeros ordenamos que sean contruidos

if ((myKnights.length<MINIMUMKNIGHT) ||(myKnights.length <=(int)(World.getOtherKnights().length/World.getOtherRulers() .length*KNIGHTRATIO))) {

this.createKnights(myCastles[i]); }

}


11

//Atacamos con los caballeros restantes

for (int i=0;i<myKnights.length;i++) { if (myKnights[i]!=null) { /*Definimos el area en la que pueden atacar. Esta crece según avanza * al juego. Esto permite que al principio se concentren cerca * del castillo inicial y luego se expandan*/ int dist = 17*World.getOtherRulers().length +

World.getCurrentTurn()/2 -World.getOtherKnights().length; Knight.attack(myKnights[i],dist); }

}

//Por ultimo movemos los peones for (int i=0;i<myPeasants.length;i++) { Peasant.move(myPeasants[i]); }

}}

CLASE PEASANT: import java.awt.Point; import java.util.Random; import com.ibm.ruler.*; /** * Controla el comportamiento de los perones. Estos tiene dos comportamientos * basicos: huida y expansion. Para la huida simplemente se muven alejandose * de los enemigos. La expansion se realiza creando circulos en torno a su * posicion inicial. Si no puede busaca la casilla que no sea propiedad del * jugador mas cercana y se mueve hacia ella. SI no encuentra ninguna cerca * se mueve en una direccion aleatoria * * @author José Pablo Martínez Castaño 100025200 * @author Ricardo Lucena Rodríguez 100025110 */ public class Peasant{ /** * Distancia minima que debe haber entre cada peon y un caballero enemigo * en todo momento (mientras sea posible) */ public final static int MINDISTTOENEMY=2;

/** estructura que contiene los datos para el movimiento del peon. El * primer valor indica la coordenada x, el segundo la y y el tercero la * direccion y el sentido de giro (Contra o a favor del rreloj ) */ private static int[][][] mapaDir; /** Referencia al jugador**/ private static MyRuler myRuler; /** Generador de numeros aleatorios*/ private static Random rand;

/** * Inicializa la tabla que contiene el ultimo movimiento del peon a 0 * (Es decir no se movio y el sentido de giro es el de agujas del reloj). * Asigna ademas el Ruler * @param myRuler EL Ruler del jugador


12

*/ public static void initializePeasant(MyRuler myRuler) { //Asigna el Ruler Peasant.myRuler=myRuler; //Crea el numero aleatorio rand=new Random(); //Inicializa el mapa de ultima direccion mapaDir = new int[72][64][2]; for (int i= 0; i<72; i++) { for (int j= 0; j<64; j++) { for(int k=0;k<2;k++) { mapaDir[i][j][k]=Ruler.MOVE_NONE; }

}}

}

/** * El metodo busca enemigos proximos ( a menos de 2 casillas) y si los * hay se mueve en direccion contraria a ellos * @param peasant El peon que se esta moviendo * @return Devuelve true si ha tenido que huir. Falso si no se ha movido */ public static boolean evade(IPeasant peasant) { //Obtenemos la lista de enemigos IKnight[] knight = World.getOtherKnights(); //Obtenemos la posicon del peon int x=peasant.getX(); int y=peasant.getY(); //Direccion a moverse int dir=0; Point afterMove=null; for (int i=0;i<knight.length;i++) { // Si encontramos uin enemigo cerca... if(knight[i].getDistanceTo(x,y)<=MINDISTTOENEMY) { dir = knight[i].getDirectionTo(x,y); afterMove=World.getPositionAfterMove(x,y,dir); /*Nos movemos en la dirección contraria u otra de los dos que mantendrian la distancia*/ //Para ser valida debemos poder mmovernos alli (no debe haber

//otro objeto) if ((afterMove!=null)

&&(World.getObjectAt(afterMove.x,afterMove.y)==null)) { myRuler.move(peasant,dir); //Se ha movido return true; }

//La segunda dirección valida de huida dir = dir + 1; if (dir>8) dir =dir%8; afterMove=World.getPositionAfterMove(x,y,dir); if ((afterMove!=null)

&&(World.getObjectAt(afterMove.x,afterMove.y)==null)) { myRuler.move(peasant,dir); //Se movió return true; }

//La tercera dirección de huida dir = dir + 6; if (dir>8) dir =dir%8; afterMove=World.getPositionAfterMove(x,y,dir); if ((afterMove!=null)

&&(World.getObjectAt(afterMove.x,afterMove.y)==null)) {


13

myRuler.move(peasant,dir); //Tambien se movió return true; }

}}//No ha tenido que huir

return false; }

/** * Controla el movimiento del peon. Primero comprueba si tiene que huir. * Si no se mueve en circulo (siempre que suponga conquistar zona). Si * tomar tierras no fuera posible prueba girando al reves. *

* El movimiento circular se obtiene indicadondole que efectue un giro de 90, * 45 o 0 (seguir recto) en el sentido indicado por el anterior movimiento *

* En caso de que en circulo no haya nadie, localiza la tierra no poseida * mas cercana y de no haber se mueve aleatoriamente * @param peasant Peon a mover */ public static void move(IPeasant peasant) { //Comprobamos si tiene que huir if (evade(peasant)) return; //Movimiento circular //Obtiene la posicion int x= peasant.getX(); int y= peasant.getY(); int intentos=0; //Obtiene la direccion del turno anterior int direccion=mapaDir[x][y][0]; int nextDir=Ruler.MOVE_NONE; boolean salirBucle=false; while (!salirBucle) { int giro = mapaDir[x][y][1]; switch (giro) { case 0: //Giro agujas reloj //Girar 90º nextDir = direccion+2; if (nextDir > 8) nextDir= nextDir%8; // Si se puede mover sale if (moveTo(x,y,nextDir,peasant)) { salirBucle=true; break; }

//Girar 45º nextDir = direccion+1; if (nextDir > 8) nextDir= nextDir%8; if (moveTo(x,y,nextDir,peasant)) { salirBucle=true; break; }

//Girar 0º (seguir recto) nextDir = direccion; if (nextDir > 8) nextDir= nextDir%8; if (moveTo(x,y,nextDir,peasant)) { salirBucle=true; break; }

//Si no puede prueba en la direccion de giro contraria mapaDir[x][y][1]=1; direccion=direccion+7; if(direccion>8)direccion =direccion%8;


14

mapaDir[x][y][0]= direccion;

case 1: //Giro contraio agujas reloj //Giro de 90º nextDir = direccion+6; if (nextDir > 8) nextDir= nextDir%8; if (moveTo(x,y,nextDir,peasant)) { salirBucle=true; break; }

//Giro de 45º nextDir = direccion+7; if (nextDir > 8) nextDir= nextDir%8; if (moveTo(x,y,nextDir,peasant)) { salirBucle=true; break; }

//Seguir recto nextDir = direccion; if (moveTo(x,y,nextDir,peasant)) { salirBucle=true; break; }

//No es posible moverse. Cambia direccion de giro mapaDir[x][y][1]=0; direccion=direccion+1; if(direccion>8)direccion =direccion%8; mapaDir[x][y][0]= direccion; break; }

//Incrementamos el numero de intentos (solo 2 para el sentido //giratorio intentos++; if(intentos==2) { //Buscar la zona no tomada mas cercana if(nearestNotOwnedPosition(peasant)) { } else { //Moviemiento aleatorio int indice=0; if (mapaDir[x][y][0]==0) mapaDir[x][y][0]=rand.nextInt(8)+1; while ((indice<8) &&(!salirBucle)) { //Calcula el punto destino Point afterMove=

World.getPositionAfterMove(x,y,mapaDir[x][y][0]); //Si se puede mover a ese punto lo hace if((afterMove!=null)

&&(World.getObjectAt(afterMove.x,afterMove.y)==null)){ myRuler.move(peasant,mapaDir[x][y][0]);

mapaDir[afterMove.x][afterMove.y][0]=mapaDir[x][y][0];

mapaDir[afterMove.x][afterMove.y][1]=mapaDir[x][y][1]; mapaDir[x][y][0]=0; mapaDir[x][y][1]=0; salirBucle=true; //Si no prueba con otradireccion } else { mapaDir[x][y][0]= mapaDir[x][y][0]+3; if (mapaDir[x][y][0]>8)

mapaDir[x][y][0]=mapaDir[x][y][0]%8; indice++; }

}


15

}salirBucle=true;

}}

}/**

* Comprueba si el peon se puede mover en la dirección especificada *

* @param x Coordenada x del peon * @param y Coordenada y del peon * @param nextDir Direccion a moverse * @param peasant Peon a mover * @return Devuelve si se ha movido a esa posición */ public static boolean moveTo(int x, int y, int nextDir, IPeasant peasant) { //Obtenemos el punto destino Point afterMove= World.getPositionAfterMove(x,y,nextDir); //Comprobamos si nos podemos mover a ese punto y si es de nuestra

//propiedad if ((afterMove !=null)

&& (World.getLandOwner(afterMove.x,afterMove.y) != myRuler)) { //Comprobamos que la casilla este vacia if (World.getObjectAt(afterMove.x,afterMove.y)==null) { //Nos movemos a la posicion indicada myRuler.move(peasant,nextDir); //actualizamos la tabla de datos con el movimiento //La posicion nueva toma los valores correctos mapaDir[afterMove.x][afterMove.y][0]=nextDir; mapaDir[afterMove.x][afterMove.y][1]=mapaDir[x][y][1]; //Reseteamos la anterior mapaDir[x][y][0]=0; mapaDir[x][y][1]=0; //Devolvemos que se ha movido return true; }

}//devolvemos que no se ha movido

return false; }

/** *

* Busca el punto mas cercano que no sea propiedad del jugador * Recorre las casillas desde las mas cercanas a las mas lejanas realizando * circulos *

* @param peasant El peón que movemos * @return Si se ha movido el peón */ public static boolean nearestNotOwnedPosition(IPeasant peasant) { //if (myRuler.getPeasants().length>20) return false; //Obtenemos la posicion del peón int x=peasant.getX(); int y=peasant.getY(); int direccion; //Distancia de la casilla comprobada al peón int inc=0; Point afterMove=null; while (inc<20) { //Incrementamos la distancia a comprobar inc++; if(y-inc>=0) {


16

//Comprobamos las casillas por encima del peón a la distancia inc for (int i=x-inc;i<=x+inc;i++) { if((i>=0) && (i<72)) { //Comprobamos que la tierra no sea nuestra if (World.getLandOwner(i,y-inc)!=myRuler) { direccion = peasant.getDirectionTo(i,y-inc); afterMove=

World.getPositionAfterMove(x,y,direccion); //Comprobamos que nos podemos mover hacia allí if((World.getObjectAt(i,y-inc)==null)

&&(afterMove!=null) &&(World.getObjectAt(afterMove.x,afterMove.y)==null)) {

myRuler.move(peasant,direccion); return true; }

}}

}}if(y+inc<64) {

//Misma comprobacion con las casillas inferiores for (int i=x-inc;i<=x+inc;i++) { if((i>=0) && (i<72)) { if (World.getLandOwner(i,y+inc)!=myRuler) { direccion = peasant.getDirectionTo(i,y+inc); afterMove=

World.getPositionAfterMove(x,y,direccion); if ((World.getObjectAt(i,y+inc)==null)

&&(afterMove!=null) &&(World.getObjectAt(afterMove.x,afterMove.y)==null)) { myRuler.move(peasant,direccion); return true; }

}}

}}if(x-inc>=0) {

//Comprobamos las casillas a ala izquierda del peon for (int i=y-inc+1;i<=x+inc-1;i++) { if((i>=0) && (i<64)) { if (World.getLandOwner(x-inc,i)!=myRuler) { direccion=peasant.getDirectionTo(x-inc,i); afterMove=

World.getPositionAfterMove(x,y,direccion); if((World.getObjectAt(x-inc,i)==null)



}}

}}if(x+inc<72) {

//Por ultimo las de la derecha for (int i=y-inc+1;i<=x+inc-1;i++) { if((i>=0) && (i<64)) { if (World.getLandOwner(x+inc,i)!=myRuler) { direccion = peasant.getDirectionTo(x+inc,i);


17

afterMove=World.getPositionAfterMove(x,y,direccion); if((World.getObjectAt(x+inc,i)==null)



}}

}}

}//No se ha encontrado una casilla valida a menos de 20 casillas

return false; }

}

CLASE KNIGHT: import java.awt.Point; import java.util.Random; import com.ibm.ruler.*; /** * Define el comportamiento de las unidades caballero. * A estas se les define dos comportamientos: Defensa y ataque * * @author José Pablo Martínez Castaño 100025200 * @author Ricardo Lucena Rodríguez 100025110 */ public class Knight { /** Referencia al jugador*/ private static MyRuler myRuler; /** Numero aleatorio estatico (para asi mantener la semilla) */ private static Random rand;

private static IKnight lastKnight;

/** * Inicializa los datos usados en las tacticas de los caballeros * Estos son un numero aleatorio(hay movimiento aleatorio cuando * no tienen objetivos a la vista) y el jugador para poder manipular * realmente las unidades (metodos move y capture principalmente) *

* @param yo El jugador */ public static void initialization(MyRuler yo){ myRuler =yo; rand = new Random(); }

/** *

*Ordena al caballero atacar al enemigo especificado mas cercano al centro *del area a defender. Esta area es una zona cuadrada, cuyo centro y tamaño *viene definido por los parametros. *


18

* @param caballero Unidad que se esta manejando * @param enemies Unidades enemigos a considerar * @param x Coordenada x del centro * @param y Coordenada y del centro * @param dist Radio de la zona a cubir * @return Devuelve si ha realizado alguna accion */ public static boolean defense(IKnight caballero, IObject[] enemies,int x,

int y, int dist) { /*Contiene la distancia desde el caballero a la unidad enemiga mas cercana que este en la zona a defender*/

int minDist=72; IObject enemy=null; //Comprobamos cada uno de los enemigos for (int i=0;i<enemies.length;i++){ if (enemies[i].isAlive()) { //Obtenemos la posicion del enemigo int xenemigo=enemies[i].getX(); int yenemigo=enemies[i].getY(); //calculamos la distancia del centro del area al enemigo int distancia = enemies[i].getDistanceTo(x,y); //Si esta dentro del area a defender if (dist>=distancia) { //Comprobamos si es el enemigo mas cercano al centro if (enemies[i].getDistanceTo(x,y)<minDist) { enemy=enemies[i];

minDist=caballero.getDistanceTo(xenemigo,yenemig); }

}}

}//Si habia enemigos en el area (si hay varios el mas cercano al caballero)

if (enemy!=null){ //Nos movemos hacia el int direccion = caballero.getDirectionTo(enemy.getX(),enemy.getY()); Point aftermove =

World.getPositionAfterMove(caballero.getX(), caballero.getY(),direccion);

/*Si en el camino hacia el enemigo hay una unidad atacarla * Esta unidad puede ser el propio objetivo u otra */ if ((World.getObjectAt(aftermove.x,aftermove.y)!=null)

&&(World.getObjectAt(aftermove.x,aftermove.y).getRuler() !=myRuler)){

myRuler.capture(caballero,direccion); } else { //Si no hay obstaculo solo nos movemos myRuler.move(caballero,direccion); }

//Indicamos que nos hemos movido return true; }

//No habia enemigos. Luego no se ha movido return false; } /** *Como el anterior pero especifico para atacar a unidades de tipo caballero. *La diferencia se debe a que en caso de igual distancia debemos atacar al *de menor fuerza ya que es mas facil que sea destruido, reduciendo los *ataques del enemigo mas eficientemente *


19

* @see defense * @param caballero Unidad que controlamos * @param enemies Unidades del enemigo * @param x Coordenada x del centro * @param y Coordenada y del centro * @param dist Radio de la zona a cubir * @return Devuelve si ha realizado alguna accion */ public static boolean defenseKnight(IKnight caballero, IKnight[] enemies,int x, int y, int dist) { /*Contiene la distancia desde el caballero a la unidad enemiga mas cercana que este en la zona a defender*/ int minDist=72; IKnight enemy=null; //Comprobamos cada uno de los caballeros enemigos for (int i=0;i<enemies.length;i++){ if ((enemies[i]!=null)&&(enemies[i].isAlive())) { int xenemigo=enemies[i].getX(); int yenemigo=enemies[i].getY(); //obtenemos la distancia al centro del area int distancia = enemies[i].getDistanceTo(x,y); //Si esta dentro del area a defender if (dist>=distancia) { //Vemos si es el enemigo mas cercano al centro if (enemies[i].getDistanceTo(x,y)<minDist) { enemy=enemies[i]; minDist=caballero.getDistanceTo

(xenemigo,yenemigo); //Si el enemigo esta a la misma distancia

//escogemos el mas debil }else if

(caballero.getDistanceTo(xenemigo,yenemigo) == minDist) {

if(enemy.getStrength() >enemies[i].getStrength()) {

enemy=enemies[i]; }

}}

}}//Si hay un enemigo seleccionado

if (enemy!=null){ //Trazamos la direccion a el int direccion = caballero.getDirectionTo(enemy.getX(),enemy.getY()); Point aftermove =

World.getPositionAfterMove (caballero.getX(),caballero.getY(),direccion);

//Si hay algo en ese camino lo atacamos if(World.getObjectAt(aftermove.x,aftermove.y)!=null) {

if (World.getObjectAt(aftermove.x,aftermove.y).getRuler() !=myRuler) {

//Caso particular caballero-castillo-enemigo. Hay que evitarlo //para no tener bloquesos boolean esCastillo=false; IObject objetivo

=World.getObjectAt(aftermove.x,aftermove.y); ICastle[] cast = World.getOtherCastles(); for (int i=0;i<cast.length;i++ ) { if(cast[i].getId()==objetivo.getId()) { esCastillo=true; }


20

}if((minDist>=2)&&(esCastillo)) {

int dir1= direccion+1; int dir2=direccion +7; if (dir1>8) dir1=dir1%8; if (dir2>8) dir2=dir2%8; Point afterMove1 = World.getPositionAfterMove

(caballero.getX(),caballero.getY(),dir1); Point afterMove2 = World.getPositionAfterMove

(caballero.getX(),caballero.getY(),dir2); if ((afterMove1!=null)

&&(enemy.getDistanceTo(afterMove1.x,afterMove1.y) <=enemy.getDistanceTo

(caballero.getX(),caballero.getY()))) { if(World.getObjectAt

(afterMove1.x,afterMove1.y)!=null){ myRuler.capture(caballero,dir1); } else { myRuler.move(caballero,direccion); }

}else if ((afterMove2!=null)

&&(enemy.getDistanceTo(afterMove2.x,afterMove2.y) <=enemy.getDistanceTo

(caballero.getX(),caballero.getY()))) { if(World.getObjectAt

(afterMove2.x,afterMove2.y)!=null){ myRuler.capture(caballero,dir2); } else { myRuler.move(caballero,direccion); }

}}//Caso general

myRuler.capture(caballero,direccion); }

//Si no solo movemos } else { myRuler.move(caballero,direccion); }

//en este caso la unidad ha realizado un movimiento return true; }

//No se ha movido return false; } /** *Indica a un caballero que es libre de atacar a cualquiera situado a menos *de la distancia indicada por el parametro. Se ataca a las unidades segun *el orden caballero,castillo, peon. Hay una excepcion: Si estamos sin *castillo la prioridad es reconquistar uno. *

* @param caballero La unidad a mover * @param dist La zona en la que puede atacar */ public static void attack(IKnight caballero, int dist) { //Si no tenemos castillos debemos tomar uno if (myRuler.getCastles().length==0) { Knight.defense

(caballero,World.getOtherCastles(), caballero.getX(),caballero.getY(),dist);


21

}else { /*En otro caso ataca primero a caballeros, luego castillos y luego peones*/ if (Knight.defenseKnight

(caballero,World.getOtherKnights(), caballero.getX(),caballero.getY(),dist));

else if (Knight.defense

(caballero,World.getOtherCastles(), caballero.getX(),caballero.getY(),dist));

else if (Knight.defense (caballero,World.getOtherPeasants(), caballero.getX(),caballero.getY(),dist));

else { //Si no hay enemigos muevete a donde quieras int dir = rand.nextInt(8)+1; myRuler.move(caballero,dir); }

}}

/** * Ordena a los caballeros que tengan enemigos contiguos que los ataquen * @param caballero Caballero que ataca * @return Devuelve true si ha atacado. */ public static boolean underAttack(IKnight caballero) { IKnight[] enemies=World.getOtherKnights(); int x= caballero.getX(); int y= caballero.getY(); IKnight objetivo=null; for (int i=0;i<enemies.length;i++) { if(enemies[i].getDistanceTo(x,y)== 1) { if ((objetivo==null) || (enemies[i].getStrength()<objetivo.getStrength())) { objetivo=enemies[i]; }

}}if (objetivo!=null) {

int dir= caballero.getDirectionTo (objetivo.getX(),objetivo.getY());

myRuler.capture(caballero,dir); return true; }

return false; }

/** * El metodo busca enemigos proximos ( a menos de 2 casillas) y si los * hay se mueve en direccion contraria a ellos * @param peasant El caballero que se esta moviendo * @return Devuelve true si ha tenido que huir. Falso si no se ha movido */ public static boolean evade(IKnight peasant) { //Obtenemos la lista de enemigos IKnight[] knight = World.getOtherKnights(); //Obtenemos la posicon del peon int x=peasant.getX(); int y=peasant.getY(); //Direccion a moverse int dir=0; Point afterMove=null;


22

for (int i=0;i<knight.length;i++) { // Si encontramos uin enemigo cerca... if(knight[i].getDistanceTo(x,y)<=2) { dir = knight[i].getDirectionTo(x,y); afterMove=World.getPositionAfterMove(x,y,dir); /*Nos movemos en la dirección contraria u otra de los dos que mantendrian la distancia*/ //Para ser valida debemos poder mmovernos alli (no debe haber

//otro objeto) if((afterMove!=null)

&&(World.getObjectAt(afterMove.x,afterMove.y)==null)) { myRuler.move(peasant,dir); //Se ha movido return true; }

//La segunda dirección valida de huida dir = dir + 1; if (dir>8) dir =dir%8; afterMove=World.getPositionAfterMove(x,y,dir); if((afterMove!=null)

&&(World.getObjectAt(afterMove.x,afterMove.y)==null)) { myRuler.move(peasant,dir); //Se movió return true; }

//La tercera dirección de huida dir = dir + 6; if (dir>8) dir =dir%8; afterMove=World.getPositionAfterMove(x,y,dir); if ((afterMove!=null)

&&(World.getObjectAt(afterMove.x,afterMove.y)==null)) { myRuler.move(peasant,dir); //Tambien se movió return true; }

}}//No ha tenido que huir

return false; }

}

CLASE CASTLE: import com.ibm.ruler.*; /** * Controla las tacticas para los castillos. Esta es la de defender el castillo * y su zona proxima. Ademas selecciona si debe construir peones o caballeros. * El area defendida esta acotada entre 10 y 20 casillas alrededor * * @author José Pablo Martínez Castaño 100025200 * @author Ricardo Lucena Rodríguez 100025110 */ public class Castle { // CONSTANTES /**Indica en cuenta debe modificarse la zona que considera el castillo

* segura de un turno al siguiente */ public final static float DISTANCEINCREASEPERTURN=(float)0.25; /** Factor en el que debe incrementarse la zona si se detectan enemigos*/


23

public final static int MULTIPLICADORPORENEMIGO = 12; /** Numero de caballeros que deben atender a ña defensa si hay un enemigo*/ public final static int CABALLEROSPORENEMIGO=6;

/** Tabla de datos donde se almacena el tamaño de area a defender en cada turno*/

private static float[][]mapaCastillo; /** Referencia al jugador para poder manipular objetos*/ private static MyRuler myRuler; /** *Al inicializar se asigna a todos los castillos que tenemos el tamaño de la * zona que debe estar defendida * @param mR Referencia al Ruler del jugador */ public static void initializeCastles(MyRuler mR) { //Asignamos al jugador myRuler=mR; mapaCastillo = new float[72][64]; ICastle[] castillos= mR.getCastles(); for (int i=0;i<castillos.length;i++) { //A cada castillo le asignamos su zona a defender por defecto (20) mapaCastillo[castillos[i].getX()][castillos[i].getY()] =20; }

}/**

* Fija el valor en los castillos enemigos del area a defender al valor * por defecto. Esto permite que al tomarlos su valor sea el correcto y no * bajo u alto. *

*/ public static void resetCastles() { //Obtenemos el castillo ICastle[] others = World.getOtherCastles(); int x; int y; for (int i=0;i<others.length;i++) { //Obetenemos la posicion de cada castillo x=others[i].getX(); y=others[i].getY(); //La asignamos elñ valor por defecto a esa posicion mapaCastillo[x][y]=20; }

}/**

* El metodo comprueba si en las cercanias del castillo hay enemigos. * Si es así envia caballeros contra ellos y aumenta el area a defender * Si no los hay disminuye su area protegida. * @param cast Catillo al que estamos preparando su defensa * @param caballeros Caballeros con los que contamos para la misma. Puede * elementos null. Estos serían caballeros previamente usados * @return Devuleve la lista de caballeros que no han sido utilizados */ public static IKnight[] defenderCastillo

(ICastle cast,IKnight[] caballeros,int numCabDisp) { IKnight cab=null; int xenemy; int yenemy; //Obtenemos los caballeros enemigos IKnight[] enemigos = World.getOtherKnights(); /*Obtenemos el area a defender del castillo y comprobamos que esta

*dentro de los limites permitidos*/ int x=cast.getX(); int y=cast.getY();


24

if (mapaCastillo[x][y]<10) mapaCastillo[x][y]=10; if (mapaCastillo[x][y]>25) mapaCastillo[x][y]=25; int distancia = (int)mapaCastillo[x][y]; int distmin=100; int distenemy; int indice=-1; //Indica cuantos enemigos hay en el area int numEnemigos=0; //Buscamos enemigos en el area a defender for(int i=0;i<enemigos.length;i++) { if ((enemigos[i]!=null)&&(enemigos[i].getDistanceTo(x,y)

<= distancia)) { //En el caso de encontrar un enemigo en al area... xenemy=enemigos[i].getX(); yenemy=enemigos[i].getY(); //Incrementamos el area a defender mapaCastillo[x][y]=mapaCastillo[x][y]+

DISTANCEINCREASEPERTURN*MULTIPLICADORPORENEMIGO; numEnemigos++; //Buscamos los caballeros mas cercanos al enemigo para

//que defiendan int numCab=0; while((numCab<CABALLEROSPORENEMIGO) &&(numCabDisp>0)) { numCab++; for (int j=0;j<caballeros.length;j++) { //Comprobamos si hay caballero en esa

//posicion del array o es null if (caballeros[j]!=null) { //Comprobamos la distancia

//caballero-enemigo distenemy=caballeros[j].getDistanceTo(x,y); if (distenemy<distmin) { //Si es el mas cercano nos quedamos con el indice=j; cab=caballeros[j]; distmin=distenemy; }

}}if (cab!=null) {

/*Si hay un caballero cerca le mandamos defender el area *con esto el caballero atacara al enemigo en el area

*defendida mas cercano a el (no tiene porque ser el que *obligo a reclutar pero si estar en la zona)*/

Knight.defenseKnight(cab,enemigos,x,y,distancia);

//Le eliminamos de la lista caballeros[indice]=null; numCabDisp--; } else { //No hay caballeros para la defensa. Crearlos myRuler.createKnights(cast); }

}}

}//Si no hay enemigos reducimos el area defendida

if (numEnemigos==0) mapaCastillo[x][y] =mapaCastillo[x][y]- DISTANCEINCREASEPERTURN;

//Devolvemos los caballeros no usados return caballeros; } }

IRC Practica final 0405jvillena/irc/practicas/04-05/11mem.pdf · Coderuler es un simulador de...

Documents

Transcript of IRC Practica final 0405jvillena/irc/practicas/04-05/11mem.pdf · Coderuler es un simulador de...