Rocket Bots KOTH

11

Rocket Bots

El año es 3024. La gente se ha convertido en un recurso demasiado escaso para arriesgarse en la guerra, por lo que el combate se ha desplazado a los robots. Tu tarea es construir un bot como ningún otro, cuyos cohetes lloverán destrucción sobre tus enemigos y derribarán todas las amenazas entrantes.

Como se Juega

Bots

El juego tiene lugar en una cuadrícula de 10x15. Su bot está ubicado en el borde inferior y tiene tres ranuras en los puntos 6,7 y 8 de la cuadrícula. Tu oponente se encuentra en la parte superior de la cuadrícula, con tres espacios directamente opuestos al tuyo.

Cohetes

Desde cualquiera de estas ranuras, puedes disparar un cohete, suponiendo que la ranura no haya sido destruida. Un cohete consiste en una lista de direcciones que se le da cuando se crea, y una vez disparado, estas direcciones no se pueden cambiar. Cada turno, el cohete consumirá la parte superior de la lista y se moverá en esa dirección. Los cohetes se mueven simultáneamente. Si dos cohetes terminan en el mismo mosaico, ambos explotarán. Si un cohete se queda sin comandos, explotará. Si un cohete se queda sin combustible, después de 100 movimientos, explotará. Cuando un cohete explota, permanecerá en esa casilla durante 5 turnos, haciendo que también explote cualquier otro cohete que se mueva allí.

Nota: Debido al movimiento simultáneo, dos cohetes pueden cruzarse entre sí sin explotar, siempre que no terminen un turno en la misma casilla.

Objetivo

El objetivo de cada partida es destruir las ranuras de tus oponentes mientras mantienes vivo el tuyo. Se puede disparar un cohete desde cualquier ranura en vivo que tenga, y se le asigna una ruta designada por usted antes de dispararlo. Lanzas un cohete cada segundo turno, lo que significa que los cohetes se moverán dos veces antes de que puedas disparar otro. Un duelo dura 200 turnos, o hasta que se destruyan todas las ranuras de un bot.

Puntuación

Al final del partido, obtienes un punto por cada tragamonedas en vivo que tengas, y un punto por cada tragamonedas de oponentes que destruiste. Esto significa que es un juego de suma cero, y se otorgarán 6 puntos por partido.

Se ejecutará un round robin para que cada bot se enfrente al otro una vez. Si algún bot usa RNG, entonces cada enfrentamiento será de 1000 duelos.

Implementación

El código para la competencia se puede encontrar aquí: https://github.com/Cain93/RocketBots

Cada presentación debe extender la Botclase. Debe anular el fireRocketmétodo. Este método recibe una matriz de Rockets Rocket[][], que representa el tablero de juego. Siempre se encuentran en la parte inferior de la parrilla, con ranuras en los puntos [-1][6], [-1][7], [-1][8]. En la cuadrícula, los puntos desocupados se representarán con null. Si existe un cohete en un mosaico, puede identificar a quién pertenece accediendo al discampo. "^" es tu cohete y "v" son tus oponentes.

Debe devolver una LinkedList of Integers que proporcione las instrucciones para su cohete. Para moverse hacia arriba, use 0. Para moverse hacia arriba y hacia la derecha, use 1, justo a la derecha, use 2, etc. hasta 7 para arriba y a la izquierda. El cohete se moverá en el orden en que presionas los números enteros. Por ejemplo, el siguiente código hará que el cohete se mueva hacia arriba unas pocas vueltas, zigzaguee unas pocas vueltas y luego detonar.

LinkedList<Integer> moves = new LinkedList<Integer>();

moves.push(0);
moves.push(0);
moves.push(0);
moves.push(1);
moves.push(7);
moves.push(1);
moves.push(7);

Para cambiar desde qué ranura disparar el cohete, cambie el curSlotcampo. 0 es su ranura más a la izquierda y 2 es su más a la derecha. Para verificar si una ranura está destruida, use getSlot(int slotNumber).

Si un cohete termina un turno en una ranura, esa ranura será destruida. No necesita detonar manualmente el cohete.

Nota: los cohetes se generan en la ubicación de la ranura desde la que se disparó, pero se moverán una vez antes de evaluar las colisiones. Entonces, si disparas un cohete desde la ranura 0, y el primer movimiento es correcto (2), entonces destruirás tu propia ranura central. Sin embargo, arriba y derecha (1) es un movimiento seguro.

Si desea nombrar su bot, anule el name()método.

Los bots se reconstruirán para cada duelo, por lo que se restablecerán las variables estáticas.

¡Buena suerte!

Que tus cohetes vuelen de verdad y que tus oponentes no sean más que restos de metal ardiendo.

Insinuación:

Detonar cohetes intencionalmente para crear explosiones es una forma más fácil de defender que intentar derribar cohetes oponentes.

Ejemplo Bot

package bots;

import java.util.LinkedList;

import mechanics.*;




public class SimpleBot extends Bot {

    public String name(){
        return "Simple";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){

        LinkedList<Integer> l = new LinkedList<Integer>();
        for(int i = 0; i < 12; i++){
            l.push(0);
        }
        return l;
    }

}

Puntuaciones

Puntuaciones de 6-24

Simple: 900
Zigzagoon: 3654
Wall-E: 3606
Tortoise: 2248
3 Shot: 2334
HatTrickBot: 4287
Sniper: 2973
SideShooter: 2491
Terminator: 4835
StraightShot: 3378
Defender: 4570
MoreDakka: 4324
Caín
fuente
Solucionado, por lo que el orden no importa, si algún robot usa RNG, aumentaré el funcionamiento a 1000 veces por enfrentamiento
Cain
1
¿Hay alguna manera de verificar si se destruye un espacio del oponente? getSlot (int) es solo para nuestras máquinas tragamonedas, ¿verdad?
Katenkyo
1
@Cain Podría ser interesante no poder lanzar ningún cohete a una ranura destruida: 3
Katenkyo
1
@Manu no es un error, estás mirando el tablero desde tu lado, por lo que las ranuras de la izquierda son relativas
Katenkyo
1
Lo siento, ya solucioné ese error, ¡solo olvidé presionarlo!
Caín

Respuestas:

3

Defensor

El defensor usa un nuevo tipo de defensa: los cohetes patrullan frente a las ranuras. Esto ofrece una gran ventaja, ya que los cohetes viven durante 100 turnos en lugar de 5 turnos (como explosiones).

package bots;

import java.util.LinkedList;
import mechanics.*;

public class Defender extends Bot {
    int turn = 0;

    @Override
    public String name() {
        return "Defender";
    }

    @Override
    public LinkedList<Integer> fireRocket(Rocket[][] grid) {
        LinkedList<Integer> command = new LinkedList<Integer>();
        for (int i = 0; i < 3; i++) {
            if ((grid[0][6+i] == null || grid[0][6+i].getDis().equals("v")) && (grid[1][6+i] == null || grid[1][6+i].getDis().equals("v")) && getSlot(i)) {
                curSlot = i;
                command.push(0);
                for (int j = 0; j < 50; j++) {
                    command.push(0);
                    command.push(4);
                }
                break;
            }
        }

        if (command.isEmpty()) {
            if ((grid[0][9] == null || grid[0][9].getDis().equals("v")) && (grid[0][10] == null || grid[0][10].getDis().equals("v")) && (grid[1][10] == null || grid[1][10].getDis().equals("v")) && getSlot(2)) {
                curSlot = 2;
                command.push(1);
                command.push(1);
                command.push(4);
                for (int i = 0; i < 50; i++) {
                    command.push(6);
                    command.push(2);
                }
            } else if ((grid[0][5] == null || grid[0][5].getDis().equals("v")) && (grid[0][4] == null || grid[0][4].getDis().equals("v")) && (grid[1][4] == null || grid[1][4].getDis().equals("v")) && getSlot(0)) {
                curSlot = 0;
                command.push(7);
                command.push(7);
                command.push(4);
                for (int i = 0; i < 50; i++) {
                    command.push(2);
                    command.push(6);
                }
            }

        }

        if (command.isEmpty()) {
            if (turn % 2 == 0 && getSlot(0)){
                curSlot = 0;
                command.push(7);
                command.push(7);
                for (int i = 0; i < 7; i++) {
                    command.push(0);
                }
                command.push(2);
                for (int i = 0; i < 2; i++) {
                    if (Math.random() < 0.2) command.push(2);
                }
                command.push(1);
            } else {
                curSlot = 2;
                command.push(1);
                command.push(1);
                for (int i = 0; i < 7; i++) {
                    command.push(0);
                }
                command.push(6);
                for (int i = 0; i < 2; i++) {
                    if (Math.random() < 0.5) command.push(6);
                }
                command.push(7);
            }
        }

        turn++;
        return command;
    }
}
CommonGuy
fuente
Wow +1. Impresionante bot. Pero como dices, no funciona bien cuando el bot está del otro lado.
Spikatrix
1
Juego bastante perfecto, felicitaciones
Caín
6

Zigzagoon

Las ranuras externas van (ligeramente) de ancho, luego se dirigen hacia adelante y regresan hacia las ranuras enemigas. La ranura del medio dispara un patrón en zigzag en el medio.

Cada dos asaltos (3 turnos), entra en modo de defensa y solo explota algunos cohetes cerca de mis propias máquinas tragamonedas. Los cohetes en modo de ataque luego los rodean. Nada demasiado elegante, solo algo para poner en marcha el concurso.

package bots;import java.util.*;import mechanics.*;

public class Zigzagoon extends Bot{
    String[] evenMoves = {"7000000001","0170710170","1000000007"};
    String[] oddMoves = {"0","00","0"};
    boolean even = true;
    public String name(){return "Zigzagoon";}

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        curSlot = (curSlot+1)%3;
        if(curSlot<1)even=!even;
        String[] moves = even?evenMoves:oddMoves;
        LinkedList<Integer> command = new LinkedList<Integer>();
        for(int i=0;i<moves[curSlot].length();i++)
            command.push(moves[curSlot].charAt(i)-'0');
        return command;
    }
}
Geobits
fuente
Solucionado, la mayor parte de la diferencia provenía de si incluso comenzaba como verdadero o falso. Los bots ahora se reconstruyen antes de cada partida.
Caín
Ah, eso tiene sentido. Ni siquiera pensé en variables que no se reiniciaran. Gracias :)
Geobits
5

Terminator

Estoy orgulloso de presentar Terminator !!!

Cada cohete se mueve hacia la izquierda / derecha desde el centro y regresa a una ranura enemiga. Cada dos turnos, se lanza un cohete de defensa recto y explota cerca de la ranura para protegerlo.

package bots;

import java.util.LinkedList;
import mechanics.Bot;
import mechanics.Rocket;

public class Terminator extends Bot {

    int n = 0;
    String[] moves = {"000", "0111107777", "00", "0077700111", "00", "0777701111"};

    public String name() {
        return "Terminator";
    }

    @Override
    public LinkedList<Integer> fireRocket(Rocket[][] g) {
        curSlot = (n+1) % 3;

        LinkedList<Integer> commands = loadCommands(moves[n % moves.length]);
        n++;

        return commands;
    }

    protected LinkedList<Integer> loadCommands(String commands) {
        LinkedList<Integer> linkedList = new LinkedList<Integer>();

        for (int i = 0; i < commands.length(); i++) {
            linkedList.push(commands.charAt(i) - 48);
        }

        return linkedList;
    }

}
guy777
fuente
3

SombreroTrickBot

Tenía DoubleTapBot para CodeBot 3, que estaba golpeando dos veces en un turno, aquí viene HatTrickBot: ¡Golpeando los 3 puntos al mismo tiempo!

Siempre es posible evitar que un cohete golpee si sabe dónde caerá. Pero no creo que haya muchos bot que puedan proteger sus máquinas tragamonedas contra un ataque de 3 cohetes.

Por cierto, sí, es horrible ver tal otra cosa con el cambio repetido. Podría haber creado una var para encender con valores únicos para cada combinación del estado de las ranuras y el turnConter. Pero sería más difícil de leer (tendría que mantener el significado de los valores en un comentario ... ¡aburrido!) :)

package bots;
import java.util.LinkedList;
import mechanics.*;
/*
 * HatTrickBot always tries to destroy all the enemy slots at once
 * In order to achieve this, each slot needs extrem concentration and coordination
 * It explain why they need some turns to re-synchronized the rockets after one of them dies.
 */
public class HatTrickBot extends Bot
{
    // Default moves are at [0]
    // moves at [1] are used when there's only 2 slots remaining
    // moves  [2-4] are here for when there's only 1 slot remaining
    // it panicks, and can't establish how to fire to do a hat trick.
    // So he will just spamm every ennemy position, one at a time
    String[] rightSlot = {  "770002000020",
                            "0000000001",
                            "0000000000",
                            "0000000001",
                            "0000000011"};
    String[] midSlot   = {  "0000000000",
                            "11000060000",
                            "0000000000",
                            "0000000010",
                            "0000000700"};
    String[] leftSlot  = {  "11000060007",
                            "777702000020",
                            "0000000000",
                            "0000007000",
                            "0000077000"};
    int turnCounter=-1;
    public String name(){return "HatTrickBot";}
    public LinkedList<Integer> fireRocket(Rocket[][] g)
    {
        turnCounter=(turnCounter+1)%3;
        String[][] moves = {rightSlot,midSlot,leftSlot};
        LinkedList<Integer> ll = new LinkedList<Integer>();
        boolean slotL=getSlot(0),slotM=getSlot(1),slotR=getSlot(2);
        int movePoint=0;
        if(slotL&&slotM&&slotR)
        {
            switch(turnCounter)
            {
            case 0: curSlot=0;
                break;
            case 1: curSlot=2;
                break;
            case 2: curSlot=1;
                break;
                default:break;
            }
            movePoint=0;

        }
        else if(!slotM&&slotL&&slotR)
        {
            switch(turnCounter)
            {
            case 0: curSlot=0;
                    movePoint=0;
                break;
            case 1: curSlot=2;
                    movePoint=0;
                break;
            case 2: curSlot=0;
                    movePoint=1;
                break;
                default:break;
            }
        }
        else if(!slotL&&slotM&&slotR)
        {
            switch(turnCounter)
            {
            case 0: curSlot=0;
                    movePoint=0;
                break;
            case 1: curSlot=1;
                    movePoint=1;
                break;
            case 2: curSlot=0;
                    movePoint=1;
                break;
                default:break;
            }
        }
        else if(!slotR&&slotM&&slotL)
        {

            switch(turnCounter)
            {
            case 0: curSlot=2;
                    movePoint=1;
                break;
            case 1: curSlot=1;
                    movePoint=1;
                break;
            case 2: curSlot=1;
                    movePoint=0;
                break;
                default:break;
            }
        }
        else
        {
            if(slotR)curSlot=0;
            if(slotM)curSlot=1;
            if(slotL)curSlot=2;
            movePoint = 2+turnCounter;
        }
        for(int i=0;i<moves[curSlot][movePoint].length();i++)
            ll.push(Integer.parseInt(moves[curSlot][movePoint].charAt(i)+""));
        return ll;
    }
}
Katenkyo
fuente
Los cohetes solo disparan cada dos turnos, por lo que esto no hace un golpe completo de Hat Trick. Sin embargo, sigue siendo extremadamente eficaz
Caín el
@Cain Ho, triste que es cada 2 turnos: /. De todos modos, veré el resultado de la primera ronda y luego modificaré para hacer un HatTrick real si creo que puede mejorarlo :)
Katenkyo
Los cohetes se mueven dos veces entre cada vez que se llama a fireRocket (). Entonces, en este momento, todos están compensados ​​entre sí por un giro aún. Puede usar el archivo de prueba en el controlador para ver una representación visual de la coincidencia.
Caín
@Cain Estaba en el trabajo cuando escribí esos bots, así que los
basé
Wow, estoy impresionado de que hayas podido escribir eso sin ninguna prueba, felicidades. Actualicé las especificaciones para hacerlo más claro
Cain
2

Tortuga

Si protejo todas mis bases, tengo 3 puntos. Las bases solo se pueden atacar desde 5 ubicaciones si obtengo bien la cuadrícula. El cohete dura 5 turnos en el campo ...

Este bot usa todo esto para cumplir su objetivo: sobrevivir con al menos el 50% de los puntos en el bolsillo. Dispara 3 cohetes, luego se cubre

package bots;

import java.util.LinkedList;

public class Tortoise extends Bot
{
    int turnCounter=-1;
    boolean attacked=false;
    int[] moves={7,0,0,0,1};
    public String name(){return "Tortoise";}
    public LinkedList<Integer> fireRocket(Rocket[][] g)
    {
         LinkedList<Integer> rocket = new LinkedList<Integer>();
         turnCounter++;
         if(!attacked)
         {
             curSlot=turnCounter;
             for(int i=0;i<11;i++)
                 rocket.push(0);
             if(turnCounter==2)
                 attacked=true;
             return rocket;
         }
         turnCounter%=5;
         switch(turnCounter)
         {
         case 0:
         case 1:curSlot=0;break;
         case 2:curSlot=1;break;
         case 3:
         case 4:curSlot=2;break;
            default:break;
         }
         rocket.push(moves[turnCounter]);
         return rocket;
    }
}
Katenkyo
fuente
Cohetes sólo el fuego todos los demás a su vez, por lo que en realidad sólo puede mantener un 2 y medias paredes
Cain
@Cain Oh, así que lo modificaré para que tenga un refugio real :)
Katenkyo
2

SideShooter

Primeros disparos a través de la primera torreta (más a la derecha) en una de dos formas diferentes. Luego, dispara a través de la última torreta (más a la izquierda) en una de dos formas diferentes. Luego forma una "pared" con la segunda torreta (del medio) haciendo estallar cohetes frente a cada torreta. Este proceso se repite.

Si el juego dura más de 30 turnos, SideShooter se aburre y cambia de una manera pequeña. En lugar de hacer una "pared" con la segunda torreta (central), dispara en línea recta. El resto de las torretas se comportan de la misma manera.

import java.util.LinkedList;

public class SideShooter extends Bot {

    int[] launcher = new int[]{1, 3, 2, 2, 2};
    String[] right = {"1100000077", "100000007"};
    String[] left  = {"7700000011", "700000001"}; 
    int position = -1;
    int turns = 0;

    public String name(){
        return "SideShooter";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){
      LinkedList<Integer> directions = new LinkedList<Integer>();

      if(getSlot(0) || getSlot(1) || getSlot(2))      
          do{
              position = (position + 1) % 5;
              curSlot = launcher[position] - 1;
          }while(!getSlot(curSlot));

      if(position == 0)
      {
          String shoot = left[((int) (Math.random() * left.length))];
          for(int i=0; i < shoot.length(); i++)
              directions.push(shoot.charAt(i)-'0');
      }else if(position == 1)
      {
          String shoot = right[((int) (Math.random() * right.length))];
          for(int i=0; i < shoot.length(); i++)
              directions.push(shoot.charAt(i)-'0');
      }else
      {
          if(turns < 30)
          {
            if(position == 2 )
                directions.push(0);
            else if(position == 3)
                directions.push(1);
            else if(position == 4)
                directions.push(7);
          }else
              for(int i=0; i < 10; i++)
                  directions.push(0); 
      }
      turns ++;
      return directions;
    }

}
Spikatrix
fuente
la do...whiledeclaración hacer un bucle infinito ...
guy777
@ guy777, no, no lo es. Se enrolla hasta que encuentra una torreta no rota.
Spikatrix
Okay ! ¡¡¡Las dos primeras veces que lanzo el código con todos los bots, SideShooter y otros bot (no sé cuál) no pueden terminar el juego !!!
guy777
Algunos juegos son inacabables. El controlador debe tener un límite de giro.
guy777
1
@CoolGuy He votado para aprobar su edición. Asegúrese de revisarlo / probarlo usted mismo.
mbomb007
2

Francotirador

Sniper primero bloquea sus dos lados y luego comienza a disparar en línea recta.

import java.util.LinkedList;

public class Sniper extends Bot {

    int[] launcher = new int[]{1, 3, 1, 2, 3};
    String[] moves = {"7", "1", "0000000000", "0000000000", "0000000000"}; 
    int position = -1, move = 0;

    public String name(){
        return "Sniper";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        LinkedList<Integer> directions = new LinkedList<Integer>();

        if(getSlot(0) || getSlot(1) || getSlot(2))
        do{
            position = (position + 1) % launcher.length;
            curSlot = launcher[position] - 1;
        }while(!getSlot(curSlot));

        for(int i=0; i < moves[move].length(); i++)
            directions.push(moves[move].charAt(i)-'0');

        move = (move + 1) % moves.length;

        return directions;
    }

}
Spikatrix
fuente
Vea los comentarios en SideShooter, el mismo problema aquí.
Caín
2

Tres disparos

Tenemos algunos disparos extraños volando. No es una verdadera defensa, pero el patrón es tal que será difícil disparar más allá de esta extraña lluvia de misiles. (o esa es la idea. Lo más probable es que no funcione).

package bots;import java.util.*;import mechanics.*;

public class ThreeShot extends Bot{
    public String name(){state = 0;return "3 Shot";}
    private int state;

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        LinkedList<Integer> command = new LinkedList<Integer>();
        if(state < 2){
           state++;
           return fireLeft();
        }
        if(state < 4){
           state++;
           return fireCenter();
        }
        state=(state+1)%6;
        return fireRight();
    }
    LinkedList<Integer> fireCenter(){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = 1;
        while(command.size()<90){
            command.push(1);
            command.push(7);
            command.push(6);
            command.push(1);
        }
        return command;
    }
    LinkedList<Integer> fireRight(){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = 2;
        command.push(1);
        for(int i=0;i<8;i++){
            command.push(0);
        }
        command.push(7);
        return command;
    }
    LinkedList<Integer> fireLeft(){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = 0;
        command.push(7);
        for(int i=0;i<8;i++){
            command.push(6);
            command.push(1);
        }
        command.push(1);
        return command;
    }
}

Nota

MegaTom
fuente
2

MásDakka

MoreDakka dispara en cinco direcciones sin parar (hasta que las torretas sean destruidas por otros misiles).

import java.util.LinkedList;

public class MoreDakka extends Bot
{
    String[] moves={"70000000001", "0000000000", "0000000000", "0000000000", "1000000007"};
    int[] launcher = new int[]{0, 0, 1, 2, 2};
    int position = -1;

    public String name(){
        return "MoreDakka";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g)
    {
         LinkedList<Integer> directions = new LinkedList<Integer>();

         if(getSlot(0) || getSlot(1) || getSlot(2))
            do{
                position = (position + 1) % launcher.length;
                curSlot = launcher[position];
            }while(!getSlot(curSlot));

         for(int i=0; i < moves[position].length(); i++)
            directions.push(moves[position].charAt(i)-'0');

         return directions;
    }
}
Spikatrix
fuente
1

StraightShot

Solo dispara directamente a ellos.

package bots;import java.util.*;import mechanics.*;

public class StraightShot extends Bot{
    public String name(){return "StraightShot";}

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = (curSlot+1)%3;
        for(int i=0;i<100;i++)
            command.push(0);
        return command;
    }
}
MegaTom
fuente
1
En caso de que no lo supiera , esto es básicamente lo mismo que WaveBot , uno de los bots de ejemplo incluidos con el controlador.
Geobits
@Geobits No tenía idea de que existían bots de ejemplo.
MegaTom
Mi mal por no poner los Sample Bots en un lugar más fácil de ver. Solo voy a eliminar WaveBot y dejar que esta entrada permanezca
Cain
1

Aquí está mi propia entrada

WallE

Dispara algunos cohetes compensados ​​y construye muros en sus bordes y centro. Después de 100 turnos, comienza a apuntar a la ranura del medio.

package bots;

import java.util.LinkedList;
import java.util.Random;

import mechanics.*;


public class WallE extends Bot {

    int turn = 2;

    public String name(){
        return "Wall-E";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        turn++;
        LinkedList<Integer> moves = new LinkedList<Integer>();
        curSlot = 1;
        switch(turn%4){
        case 0: 
            //Check the right wall
            if(getSlot(2)){
                curSlot = 2;
                moves.push(1);
                return moves;
            }
        case 1:
            //Check the left wall
            if(getSlot(0)){
                curSlot = 0;
                moves.push(7);
                return moves;
            }
        case 2:
            //Check the center wall
            if(getSlot(1)){
                curSlot = 1;
                moves.push(0);
                return moves;
            }
            break;
        default:
            //Fire a sneaky rocket
            Random rand = new Random();
            int direction = rand.nextInt(2);
            int back = 0;
            if(direction == 0 && getSlot(2)){ direction = 1; back = 7; curSlot = 2;}
            else{ direction = 7; back = 1; curSlot = 0; }
            moves.push(0);
            moves.push(direction);
            moves.push(direction);
            for(int i = 0; i < 5; i++){
                moves.push(0);
            }

            //Go for the center after turn 100
            if(turn > 104){
                moves.pop();
                moves.push(back);
            }
            moves.push(back);
            moves.push(back);


        }

        return moves;










    }

}
Caín
fuente