Tutorial Java

El Entorno de la competencia

Se divide en dos paneles que permiten administrar las batallas y los torneos de forma sencilla. Además posee un menú con algunas opciones y configuraciones:
Panel de torneos: visualiza el nombre de cada colonia oponente y su respectiva energía acumulada en dicho torneo. En la parte inferior hay una lista de botones que permiten: agregar/eliminar una nueva colonia, navegar los torneos, visualizar el ranking, agregar/eliminar algún torneo.
Panel de batallas: permite crear y ejecutar batallas en el torneo actual. Se pueden seleccionar (usando las listas selecionables que están en la parte superior del panel) los oponentes y distribución de nutrientes, y a continuación usar el botón "agregar batalla seleccionada" para agregar una batalla. También se puede usar el botón "agregar todo" para agregar las batallas que aún no se han agregado a la lista.
Para correr las batallas hay dos opciones: "run" y "run all", donde "run" corre la batalla seleccionada y "run all" las ejecuta secuencialmente a todas y cada una.
Menu: se divide en tres opciones (File, Tools y Help),
Menu File: administraciones básicas del "contest".
Menu Tools: configuraciones(preferences) y reportes (report). En preferences se puede configurar el nombre del contest, el path del proyecto, el tiempo de pausa (en milisegundos) entre cada batalla, el modo en que corre la aplicación (programador o competencia), la distribución de nutrientes permitida en el contest y la interface gráfica que muestra las batallas.
Menu Help: ayuda e información del entorno.

Frame Principal:
frameppal.eps

Qué hay que saber para comenzar?

Simplemente 2 cosas:

1) Cómo setear los modos del entorno:
Modo programador: está ideado para los programadores, ya que la aplicación no guarda la información respectiva a las batallas que se van realizando.
Modo competencia: se usa solamente cuando se realizan los encuentros.

2) Cómo hacer correr los MOs: sólo hay que copiar su código en la carpeta Contest-"año"/MOs del proyecto y abrir la aplicación. Luego creamos una batalla con el botón "add selected battle" del panel de batallas y por último click en "run". El entorno provee varios MOs simples de ejemplo que se cargan al abrir la aplicación.

Qué hay que hacer para escribir un MO?

La clase abstracta Microorganismo es la que declara los métodos necesarios para definir el comportamiento de una colonia.
El código del concursante deberá heredarla:

public abstract class Microorganism {
// Posicion absoluta del Microorganismo en el entorno.
protected Position pos;

// Energía del microorganismo
protected float ene;

// Identificador del microorganismo
protected int id;

// Permite a un Microorganismo moverse a una posicion relativa de su posicion actual (pos).
public abstract void move(Movement mov);

// Permite a un microorganismo duplicarse.
public abstract boolean mitosis();

// Nombre de la colonia de Microorganismos.
public abstract String getName();

// Autor del codigo.
public abstract String getAuthor();

// Filiacion del autor del codigo!!
public abstract String getAffiliation();
}

Creando un MO simple

Supongamos que queremos crear un MO cuya táctica sea moverse en forma aleatoria.
Para ello heredamos de la clase Microorganismo como indicamos en el párrafo anterior e implementamos los siguientes métodos abstractos (a continuacion se ejemplifica una posible implementacion):

// archivo RandomColony.java.

package MOs;

import controller.java.Microorganism;
import controller.java.Movement;

public class RandomColony extends Microorganism{

    public void move(Movement mov) {
       try {
         myStrategy(mov);
       } catch(Exception ex){
          System.out.println(":(");
          ex.printStackTrace();
          mov.dx = 0;
          mov.dy = 0;
       }
    }

    public boolean mitosis() {
         return false;
    }

    public String getName() {
        return "Random_java";
    }

    public String getAuthor() {
        return "autor";
    }

    public String getAffiliation() {
        return "filiación";
    }

   private void myStrategy(Movement mov) {
        mov.dx = new java.util.Random().nextInt(3)-1;
        mov.dy = new java.util.Random().nextInt(3)-1;
   }
}

Creando un MO más interesante:

La clase Petri declara los métodos necesarios para que un MO pueda obtener información necesaria para tomar decisiones.
Los métodos que posee esta clase son los siguientes:
public Class getOponent(int x, int y) : Retorna la clase del MO que se encuentra en la posición (x,y). si la posición está libre se retorna null.
public float getEnergy(int x, int y) : Retorna la enegia del MO que se encuentra en la posicion (x,y). si la posición está libre se retorna 0.
public float getNutrient(int x, int y) : Retorna la cantidad de nutrientes que hay en la posición (x, y).
Además, la clase Petri provee dos métodos para facilitar la programacion de un MO:
public boolean canCompite(): retorna true si el MO en la posición (x1,x2) es oponente del MO en la posicion (y1,y2).
public boolean inDish(): retorna true si el MO en la posición (x,y) esta dentro del entorno, es decir, pertenece al círculo del centro (Defs.Radious, Defs.Radious) y radio Defs.Radious. Defs es una clase que define las constantes importantes para la competencia, por ejemplo: cantidad de energía inicial de cada MO(E_INITIAL), radio del entorno (RADIOUS), cantidad de MOs que se crean al inicio de la competencia (MO_INITIAL), entre otras.
public int getBattleId(): retorna un identificador que es único para cada batalla.
public int getLiveTime(): representa el tiempo de simulación en una batalla.

Ahora usando la información que nos provee la Clase Petri, podemos crear un MO que realice movimientos más avanzados, por ejemplo tratando de atacar al enemigo adyacente:

public void move (Movement mov)
{
    Position p = new Position();

    for(int i=-1; i < 2; i++){
        for(int j=-1; j < 2; j++){
            // la posicion “pos” es la posicion actual del MO.
            p.x = pos.x+i;
            p.y = pos.y+j;

            if(petri.inDish(p) && petri.canCompite(pos, p)){ // me muevo a esa Posicion!!
                mov.dx = i;
                mov.dy = j;

                return;
            }
        }
    }
}
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License