Razzi robot KOTH


11

Robot a razzo

L'anno è il 3024. Le persone sono diventate una risorsa troppo scarsa per rischiare in guerra, quindi il combattimento si è spostato sui robot. Il tuo compito è costruire un robot come nessun altro, i cui missili faranno piovere distruzione sui nemici e abbatteranno tutte le minacce in arrivo.

gameplay

Motori di ricerca

Il gioco si svolge su una griglia 10x15. Il bot si trova sul bordo inferiore e ha tre slot nei punti 6,7 e 8 della griglia. Il tuo avversario si trova nella parte superiore della griglia, con tre slot direttamente di fronte al tuo.

Rockets

Da una di queste slot, puoi sparare un razzo, supponendo che lo slot non sia stato distrutto. Un razzo consiste in un elenco di direzioni che gli vengono date al momento della creazione e che una volta lanciate non possono essere cambiate. Ad ogni turno, il razzo consumerà la cima della lista e si muoverà in quella direzione. I razzi si muovono contemporaneamente. Se due razzi finiscono nella stessa tessera, esploderanno entrambi. Se un razzo esaurisce i comandi, esploderà. Se un razzo esaurisce il carburante, dopo 100 mosse esploderà. Quando un razzo esplode, rimarrà in quella tessera per 5 turni, facendo esplodere anche tutti gli altri razzi che si muovono lì.

Nota: a causa del movimento simultaneo, due razzi possono passare l'un l'altro senza esplodere, purché non finiscano entrambi un turno nella stessa tessera.

Obbiettivo

L'obiettivo di ogni partita è quello di distruggere le slot dei tuoi avversari mantenendo vivo il tuo. Un razzo può essere lanciato da qualsiasi slot dal vivo che hai, e gli viene dato un percorso da te designato prima di essere lanciato. Spari un razzo ogni secondo turno, il che significa che i razzi si muoveranno due volte prima di poter sparare un altro. Un duello dura 200 turni o fino a quando uno slot di robot non viene distrutto.

punteggio

Alla fine della partita, ottieni un punto per ogni slot live che hai e un punto per ogni slot avversario che hai distrutto. Ciò significa che si tratta di una partita a somma zero e che verranno assegnati 6 punti per ogni partita.

Verrà eseguito un round robin in modo che ciascun bot si faccia fronte con l'altro una volta. Se qualche bot usa RNG, ogni matchup sarà invece di 1000 duelli.

Implementazione

Il codice per il concorso è disponibile qui: https://github.com/Cain93/RocketBots

Ogni invio dovrebbe estendere la Botclasse. È necessario sostituire il fireRocketmetodo. Questo metodo riceve una griglia di razzi Rocket[][], che rappresenta il tabellone. Si sono sempre situati nella parte inferiore della griglia, con bande orarie negli spot [-1][6], [-1][7], [-1][8]. Sulla griglia, saranno rappresentati i punti non occupati con null. Se esiste un razzo in una tessera, puoi identificare a chi appartiene accedendo al discampo. "^" è il tuo razzo e "v" sono i tuoi avversari.

Devi restituire un Elenco di numeri interi che fornisce le istruzioni per il tuo razzo. Per spostarti in alto, usa 0. Per spostarti in alto e a destra, usa 1, a destra, usa 2, ecc. Fino a 7 per su e sinistra. Il razzo si sposterà nell'ordine in cui premi Integer. Ad esempio, il codice seguente farà spostare il razzo verso l'alto di alcuni turni, zig-zag di alcuni turni e quindi far esplodere.

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);

Per cambiare da quale slot sparare il razzo, cambia il curSlotcampo. 0 è il tuo slot più a sinistra e 2 è il tuo più a destra. Per verificare se uno slot è distrutto, utilizzare getSlot(int slotNumber).

Se un razzo termina un turno su uno slot, tale slot verrà distrutto. Non è necessario far esplodere manualmente il razzo.

Nota: i razzi si generano nella posizione dello slot da cui sono stati sparati, ma si sposteranno una volta prima di valutare le collisioni. Quindi se spari un razzo dallo slot 0 e la prima mossa è corretta (2), allora distruggerai il tuo slot centrale. Tuttavia, su e destra (1) è una mossa sicura.

Se vuoi dare un nome al tuo bot, sovrascrivi il name()metodo.

I robot verranno ricostruiti per ogni duello, quindi tutte le variabili statiche verranno ripristinate.

In bocca al lupo!

Possano i tuoi missili volare veri e gli avversari essere nient'altro che frammenti di metallo fumanti.

Suggerimento:

Detonare intenzionalmente i razzi per creare esplosioni è un modo più semplice di difendersi che cercare di abbattere i razzi avversari.

Esempio di 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;
    }

}

I punteggi

I punteggi sono 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

Risolto il problema per cui l'ordine non ha importanza, se qualche robot usa RNG, aumenterò la corsa a 1000 volte per matchup
Caino

1
C'è un modo per verificare se uno slot avversario è distrutto? getSlot (int) è solo per i nostri slot, giusto?
Katenkyo,

1
@Cain Potrebbe essere interessante non riuscire a lanciare alcun razzo su uno slot distrutto: 3
Katenkyo,

1
@Manu non è un bug, stai guardando il tabellone dalla tua parte, quindi le slot a sinistra sono relative
Katenkyo

1
Mi dispiace, ho già risolto quel bug, ho appena dimenticato di spingerlo!
Caino

Risposte:


3

Difensore

Il difensore usa un nuovo tipo di difesa: i razzi pattugliano di fronte alle slot. Ciò offre un enorme vantaggio, poiché i razzi vivono per 100 turni invece di 5 turni (come le esplosioni).

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;
    }
}

Wow +1. Bot fantastico. Ma come dici tu, non riesce a giocare bene quando il bot è dall'altra parte.
Spikatrix,

1
Gioco impeccabile, congratulazioni
Caino

6

Zigzagoon

Le fessure esterne vanno (leggermente) in larghezza, quindi vanno avanti e rientrano verso le fessure nemiche. La fessura centrale lancia uno schema a zigzag nel mezzo.

Ogni altro round (3 turni), entra in modalità difesa ed esplode solo alcuni missili vicino alle mie slot. I razzi in modalità Attacco poi li aggirano. Niente di speciale, solo qualcosa per mettere in moto la gara.

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;
    }
}

Risolto, la maggior parte della differenza proveniva dal fatto che fosse anche iniziato come vero o falso. I robot ora vengono ricostruiti prima di ogni partita.
Caino il

Ah, ha senso. Non ho nemmeno pensato alle variabili che non si resettavano. Grazie :)
Geobits il

5

Terminator

Sono orgoglioso di presentare Terminator !!!

Ogni razzo si sposta a sinistra / a destra dal centro e ritorna su uno slot nemico. Ogni due turni, un razzo di difesa viene lanciato dritto ed esplode vicino allo slot per proteggerlo.

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;
    }

}

3

HatTrickBot

Ho avuto DoubleTapBot per CodeBot 3, che stava colpendo due volte in un turno, ecco che arriva HatTrickBot: colpire tutti e 3 i punti contemporaneamente!

È sempre possibile evitare che un razzo colpisca se sai dove cadrà. Ma non credo che ci siano molti bot che saranno in grado di proteggere le loro slot da un attacco a 3 missili.

A proposito, sì, è orribile vedere questo altro se si cambia ripetutamente. Avrei potuto creare una var per accendere con valori univoci per ogni combinazione dello stato degli slot e del turnConter. Ma sarebbe più difficile da leggere (dovrei mantenere il significato dei valori in un commento ... noioso!) :)

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;
    }
}

I razzi sparano solo ogni altro turno, quindi non si ottiene un colpo completo su Hat Trick. Comunque estremamente efficace
Caino il

@Cain Ho, triste che è ogni 2 turni: /. Ad ogni modo, vedrò il risultato del primo round e poi modificherò per fare un vero HatTrick se penso che possa migliorarlo :)
Katenkyo,

I razzi si muovono due volte ogni volta che viene chiamato fireRocket (). Quindi in questo momento, sono tutti compensati l'uno dall'altro di un giro fermo. È possibile utilizzare il file di prova nel controller per visualizzare una rappresentazione visiva della corrispondenza.
Caino,

@Cain ero al lavoro quando ho scritto quei robot, quindi li ho basati solo sulle specifiche :)
Katenkyo,

Wow, sono impressionato che tu sia riuscito a scriverlo senza nessun test, complimenti. Ho aggiornato le specifiche per renderlo più chiaro
Caino

2

Tartaruga

Se proteggo tutte le mie basi, ho 3 punti. Le basi possono essere attaccate da 5 posizioni solo se ottengo bene la griglia. Il razzo dura 5 turni sul campo ...

Questo bot usa tutto questo per raggiungere il suo obiettivo: sopravvivere con almeno il 50% dei punti nella tasca. Spara 3 missili, poi si copre

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;
    }
}

I razzi sparano solo ogni altro turno, quindi puoi davvero mantenere solo 2 muri e mezzo
Caino

@Cain Oh, quindi lo modificherò per avere un vero rifugio :)
Katenkyo,

2

SideShooter

Innanzitutto spara tramite la prima torretta (all'estrema destra) in uno dei due modi diversi. Quindi, spara attraverso l'ultima torretta (all'estrema sinistra) in uno dei due modi diversi. Quindi crea un "muro" con la seconda torretta (centrale) facendo esplodere i razzi di fronte a ciascuna torretta. Questo processo si ripete.

Se il gioco dura più di 30 turni, SideShooter si annoia e cambia leggermente. Invece di fare un "muro" con la seconda torretta (centrale), spara dritto. Il resto delle torrette si comporta allo stesso modo.

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;
    }

}

la do...whiledichiarazione fa un ciclo infinito ...
guy777,

@ guy777, No non lo è. Si avvolge fino a trovare una torretta non rotta.
Spikatrix,

ok ! la prima volta che lancio il codice con tutti i bot, SideShooter e altri bot (non so quale) non riesco a finire il gioco !!!
guy777,

Alcuni giochi non sono definibili. Il controller dovrebbe avere un limite di virata.
guy777,

1
@CoolGuy Ho votato per approvare la sua modifica. Assicurati di rivederlo / testarlo tu stesso.
mbomb007,

2

Cecchino

Il cecchino prima blocca i suoi due lati e poi inizia a sparare dritto.

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;
    }

}

Vedi i commenti su SideShooter, stesso problema qui.
Caino il

2

Tre colpi

Abbiamo avuto alcuni strani colpi in volo. Nessuna vera difesa, ma lo schema è tale che sarà difficile sparare a questa bizzarra grandine di missili. (o questa è l'idea. Molto probabilmente non funzionerà.)

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


2

MoreDakka

Il Dakka spara in cinque direzioni senza sosta (fino a quando le torrette non vengono distrutte da altri missili).

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;
    }
}

1

StraightShot

Basta sparare proprio contro di loro.

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;
    }
}

1
Nel caso in cui non fossi a conoscenza, questo è fondamentalmente lo stesso di WaveBot , uno dei robot di esempio inclusi con il controller.
Geobits il

@Geobits Non avevo idea che esistessero dei robot di esempio.
MegaTom,

Il mio male per non mettere i Sample Bots in un posto più facile da vedere. Eliminerò WaveBot e lascerò questa voce in piedi
Caino,

1

Ecco la mia voce

WallE

Spara alcuni missili offset e costruisce muri sui suoi bordi e al centro. Dopo 100 turni, inizia a colpire la fessura centrale.

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;










    }

}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.