Rocket Bots

O ano é 3024. As pessoas se tornaram um recurso muito escasso para arriscar na guerra, então o combate mudou para os robôs. Sua tarefa é construir um bot como nenhum outro, com foguetes que derrubarão a destruição de seus inimigos e abaterão todas as ameaças recebidas.

Jogabilidade

Bots

A jogabilidade ocorre em uma grade de 10x15. Seu bot está localizado na extremidade inferior e possui três slots nos pontos 6,7 e 8 da grade. Seu oponente está localizado no topo da grade, com três slots diretamente opostos aos seus.

Foguetes

De qualquer um desses slots, você pode disparar um foguete, assumindo que o slot não foi destruído. Um foguete consiste em uma lista de direções que são dadas a ele quando criadas e, uma vez disparadas, essas direções não podem ser alteradas. A cada turno, o foguete consumirá o topo da lista e se moverá nessa direção. Foguetes se movem simultaneamente. Se dois foguetes terminarem no mesmo bloco, os dois explodirão. Se um foguete ficar sem comandos, ele explodirá. Se um foguete ficar sem combustível, após 100 movimentos, ele explodirá. Quando um foguete explode, ele permanece nesse ladrilho por 5 turnos, fazendo com que outros foguetes que se movem para lá também explodam.

Nota: Devido ao movimento simultâneo, dois foguetes podem se cruzar sem explodir, desde que ambos não terminem um turno no mesmo bloco.

Objetivo

O objetivo de cada partida é destruir os slots de seus oponentes, mantendo o seu vivo. Um foguete pode ser disparado de qualquer slot ativo que você possui e recebe um caminho designado por você antes de ser disparado. Você dispara um foguete a cada segundo turno, o que significa que os foguetes se moverão duas vezes antes que você possa disparar outro. Um duelo dura 200 turnos, ou até que todos os slots de bots sejam destruídos.

Pontuação

No final da partida, você ganha um ponto para cada slot ao vivo que você possui e um ponto para cada slot que você destruiu. Isso significa que é um jogo de soma zero, e 6 pontos serão concedidos a cada partida.

Um round robin será executado para que cada bot enfrente um ao outro uma vez. Se algum bots usar RNGs, cada confronto será de 1000 duelos.

Implementação

O código para a competição pode ser encontrado aqui: https://github.com/Cain93/RocketBots

Cada submissão deve estender a Botaula. Você deve substituir o fireRocketmétodo Este método recebe uma matriz de foguetes Rocket[][],, que representa o tabuleiro de jogo. Você está sempre localizado na parte inferior da grelha, com ranhuras em pontos [-1][6], [-1][7], [-1][8]. Na grade, pontos desocupados serão representados com null. Se um foguete existir em um bloco, você poderá identificar a quem ele pertence acessando o discampo. "^" é seu foguete e "v" são seus oponentes.

Você deve retornar um LinkedList de números inteiros que fornece as instruções para seu foguete. Para mover para cima, use 0. Para mover para cima e para a direita, use 1, apenas para a direita, use 2, etc. até 7 para cima e esquerda. O foguete se moverá na ordem em que você pressiona Inteiros. Por exemplo, o código a seguir fará com que o foguete suba algumas voltas, zigue-zague algumas vezes e depois detone.

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 alterar de qual slot disparar o foguete, altere o curSlotcampo. 0 é o slot mais à esquerda e 2 é o mais à direita. Para verificar se um slot está destruído, use getSlot(int slotNumber).

Se um foguete terminar uma curva em um slot, esse slot será destruído. Você não precisa detonar manualmente o foguete.

Nota: Os foguetes aparecem no local do slot disparado, mas se moverão uma vez antes de as colisões serem avaliadas. Portanto, se você disparar um foguete do slot 0 e o primeiro movimento for certo (2), você destruirá seu próprio slot do meio. No entanto, para cima e para a direita (1) é uma jogada segura.

Se você quiser nomear seu bot, substitua o name()método

Os robôs serão reconstruídos para cada duelo, para que todas as variáveis ​​estáticas sejam redefinidas.

Boa sorte!

Que seus foguetes voem verdadeiros e seus oponentes não sejam nada além de pedaços de metal fumegantes.

Dica:

Detonar propositalmente foguetes para criar explosões é uma maneira mais fácil de defender do que tentar derrubar foguetes oponentes.

Bot de exemplo

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

}

Pontuações

Pontuações 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

Defensor

O Defender usa um novo tipo de defesa: os foguetes estão patrulhando na frente dos slots. Isso dá uma enorme vantagem, já que os foguetes vivem por 100 turnos em vez de 5 turnos (como explosões).

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

Zigzagoon

Os slots externos vão (um pouco) largamente, então siga em frente e volte para os slots inimigos. O slot do meio dispara em ziguezague no meio.

A cada duas rodadas (3 turnos), entra no modo de defesa e explode alguns foguetes perto dos meus próprios slots. Os foguetes do modo Attack então os rodeiam. Nada muito chique, apenas algo para colocar o concurso em funcionamento.

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

o Exterminador do Futuro

Tenho orgulho de apresentar o Terminator !!!

Cada foguete se move para a esquerda / direita do meio e retorna para um slot inimigo. A cada duas voltas, um foguete de defesa é lançado reto e explode perto do slot para protegê-lo.

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

}

HatTrickBot

Eu tinha o DoubleTapBot para o CodeBot 3, que estava acertando duas vezes em um turno, eis o HatTrickBot: acertar todos os três pontos ao mesmo tempo!

Sempre é possível impedir que um foguete atinja se você souber onde ele cairá. Mas acho que não há muitos robôs capazes de proteger seus slots contra um ataque com três foguetes.

By the way, sim, é horrível ver tal outra coisa com a troca repetida. Eu poderia ter criado um var para ativar valores únicos para cada combinação do status dos slots e do turnConter. Mas seria mais difícil de ler (eu teria que manter o significado dos valores em um comentário ... chato!) :)

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

Tartaruga

Se eu proteger todas as minhas bases, tenho 3 pontos. Bases só podem ser atacadas em 5 locais se eu melhorar a grade. Foguete dura 5 turnos no campo ...

Este bot usa tudo isso para atingir seu objetivo: sobreviver com pelo menos 50% dos pontos no bolso. Atira 3 foguetes e depois se cobre

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

SideShooter

Dispara primeiro pela primeira torre (mais à direita) de uma de duas maneiras diferentes. Em seguida, ele dispara pela última torre (mais à esquerda) de uma de duas maneiras diferentes. Em seguida, ele cria uma "parede" com a segunda torre (média), explodindo foguetes na frente de cada torre. Este processo é repetido.

Se o jogo durar mais de 30 turnos, o SideShooter fica entediado e muda um pouco. Em vez de fazer uma "parede" com a segunda torre (média), ela dispara reta. O resto das torres se comporta da mesma maneira.

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

}

Franco atirador

Sniper primeiro bloqueia seus dois lados e depois começa a atirar em linha reta.

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

}

Três tiros

Temos algumas fotos esquisitas voando. Nenhuma defesa verdadeira, mas o padrão é tal que será difícil conseguir um tiro além desse bizarro granizo de mísseis. (ou essa é a ideia. provavelmente não funcionará).

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

MoreDakka

Dakaka atira em cinco direções sem parar (até as torres serem destruídas por outros mísseis).

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

StraightShot

Apenas atire neles.

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

Aqui está a minha própria entrada

WallE

Atira alguns foguetes deslocados e constrói paredes nas bordas e no centro. Após 100 turnos, começa a mirar no slot do meio.

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;










    }

}