로켓 봇

년은 3024 년입니다. 사람들은 전쟁에서 위험에 처할 자원이 너무 부족 해져서 전투가 로봇으로 옮겨갔습니다. 당신의 임무는 다른 사람과 같이 봇을 구성하는 것입니다. 누가 로켓을 쓰면 적을 파괴하고 들어오는 모든 위협을 격추시킵니다.

게임 플레이

봇

게임 플레이는 10x15 그리드에서 이루어집니다. 봇은 아래쪽 가장자리에 있으며 그리드의 6,7 및 8 지점에 3 개의 슬롯이 있습니다. 상대는 당신의 맞은 편에 3 개의 슬롯이있는 그리드의 상단에 있습니다.

로켓

이 슬롯 중 하나에서 슬롯이 파괴되지 않았다고 가정하면 로켓을 발사 할 수 있습니다. 로켓은 생성 될 때 주어진 방향 목록으로 구성되며, 일단 발사되면 방향을 변경할 수 없습니다. 매 턴마다 로켓은 목록의 맨 위를 소비하고 그 방향으로 움직입니다. 로켓은 동시에 움직입니다. 두 개의 로켓이 같은 타일에서 끝나면 둘 다 폭발합니다. 로켓에 명령이 없으면 폭발합니다. 로켓에 연료가 부족하면 100 번 움직 인 후 폭발합니다. 로켓이 폭발하면 그 타일에 5 턴 동안 남아 다른 로켓도 폭발합니다.

참고 : 두 개의 로켓이 동시에 움직이므로 동일한 타일에서 턴을 끝내지 않는 한 두 개의 로켓이 폭발하지 않고 서로 통과 할 수 있습니다.

골

각 경기의 목표는 당신의 슬롯을 살리면서 상대 슬롯을 파괴하는 것입니다. 귀하가 가진 라이브 슬롯에서 로켓을 발사 할 수 있으며, 발사되기 전에 귀하가 지정한 경로가 제공됩니다. 매 초마다 로켓을 발사합니다. 즉, 다른 로켓을 발사하기 전에 로켓이 두 번 움직입니다. 결투는 200 턴 동안 또는 하나의 봇 슬롯이 모두 파괴 될 때까지 지속됩니다.

채점

경기가 끝나면, 당신은 당신이 가진 각각의 라이브 슬롯에 대해 하나의 포인트를, 당신이 파괴 한 각 상대 슬롯에 대해 하나의 포인트를 얻습니다. 즉, 제로섬 게임이며 각 경기마다 6 점을 얻습니다.

라운드 로빈이 실행되어 각 봇이 서로 봇을 한 번만 향하도록합니다. 봇이 RNG를 사용하는 경우 각 매치업은 1000 개의 결투가됩니다.

이행

대회 코드는 https://github.com/Cain93/RocketBots 에서 확인할 수 있습니다.

각 제출물은 Bot수업을 연장해야합니다 . fireRocket메소드 를 대체해야합니다 . 이 방법 Rocket[][]은 게임 보드를 나타내는 로켓의 그리드 배열을받습니다 . 당신은 항상 지점에서 슬롯, 그리드의 하단에 위치하고 있습니다 [-1][6], [-1][7], [-1][8]. 그리드에서 빈 점은로 표시됩니다 null. 로켓이 타일에 존재하면 dis필드 에 액세스하여 로켓이 속한 사람을 식별 할 수 있습니다 . "^"는 로켓이고 "v"는 상대입니다.

로켓에 대한 지침을 제공하는 연결된 정수 목록을 반환해야합니다. 위로 이동하려면 0을 사용하십시오. 위와 오른쪽으로 이동하려면 1을 사용하고, 오른쪽, 2를 사용하여 위와 왼쪽에 7을 사용하십시오. 정수를 누른 순서대로 로켓이 움직입니다. 예를 들어, 다음 코드는 로켓을 몇 차례 위로 움직이고 지그재그로 몇 차례 돌리면 폭발합니다.

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

로켓을 발사 할 슬롯을 변경하려면 curSlot필드를 변경하십시오 . 0은 가장 왼쪽 슬롯이고 2는 가장 오른쪽 슬롯입니다. 슬롯이 손상되었는지 확인하려면을 사용하십시오 getSlot(int slotNumber).

로켓이 슬롯을 켜면 해당 슬롯이 파괴됩니다. 로켓을 수동으로 폭발시킬 필요는 없습니다.

참고 : 발사 된 슬롯 위치에 로켓이 생성되지만 충돌이 평가되기 전에 한 번 이동합니다. 따라서 슬롯 0에서 로켓을 발사하고 첫 번째 이동이 올바른 경우 (2) 자신의 중간 슬롯을 파괴하게됩니다. 그러나 위와 오른쪽 (1)은 안전한 이동입니다.

봇 이름을 지정하려면 name()메소드를 재정의하십시오 .

각 결투마다 봇이 다시 작성되므로 정적 변수가 재설정됩니다.

행운을 빕니다!

로켓이 날아가고 상대방이 금속 조각처럼 번쩍이기를 바랍니다.

힌트:

의도적으로 로켓을 폭발시켜 폭발을 일으키는 것은 상대 로켓을 격추시키는 것보다 방어하기 쉬운 방법입니다.

봇 예

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

}

점수

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

방어자

수비수는 새로운 유형의 방어를 사용합니다. 로켓 이 슬롯 앞에서 순찰 하고 있습니다. 로켓은 폭발처럼 5 턴 대신 100 턴 동안 살기 때문에 큰 이점을 제공합니다.

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

지그 고온

바깥 쪽 슬롯은 (약간) 넓게 뻗은 다음 앞으로 가고 적의 슬롯으로 돌아옵니다. 중간 슬롯은 중간에 지그재그 패턴을 촬영합니다.

다른 모든 라운드 (3 턴)는 방어 모드로 들어가고 내 슬롯 근처에서 로켓을 폭발시킵니다. 공격 모드 로켓은 주위를 돌고 있습니다. 너무 화려하지는 않지만 콘테스트를 시작하기 위해 무언가가 필요합니다.

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

터미네이터

터미네이터를 소개하게 된 것을 자랑스럽게 생각합니다 !!!

각 로켓은 중앙에서 왼쪽 / 오른쪽으로 움직이며 적의 슬롯으로 돌아갑니다. 두 차례마다 방어 로켓이 똑바로 발사되고 슬롯 근처에서 폭발하여 보호합니다.

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

한 번에 두 번 타격을 가한 CodeBot 3 용 DoubleTapBot이있었습니다. 여기에 HatTrickBot이 있습니다.

로켓이 떨어지는 위치를 알고 있으면 로켓이 충돌하는 것을 항상 방지 할 수 있습니다. 그러나 나는 3 번의 로켓 공격으로부터 슬롯을 보호 할 수있는 많은 봇이 있다고 생각하지 않습니다.

그건 그렇고, 반복 스위치로 다른 사람을 보는 것은 끔찍합니다. 슬롯 상태와 turnConter의 각 조합에 대해 고유 한 값으로 설정하는 var를 만들 수있었습니다. 그러나 읽기가 더 어려울 것입니다 (댓글에 값의 의미를 유지해야합니다 ... 지루합니다!) :)

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

남생이

모든 기지를 보호하면 3 점이 있습니다. 그리드를 잘 얻으면 5 곳에서만 기지를 공격 할 수 있습니다. 로켓은 필드에서 5 턴 동안 지속됩니다 ...

이 봇은이 모든 것을 목표에 맞추기 위해 사용합니다 : 주머니에있는 포인트의 50 % 이상 생존. 3 개의 로켓을 쏘고 스스로를 덮습니다

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

사이드 슈터

첫 번째 포탑을 통해 두 가지 방법 중 하나로 발사합니다. 그런 다음 마지막 (가장 왼쪽) 터렛을 통해 두 가지 방법 중 하나로 촬영합니다. 그런 다음 각 포탑 앞에서 로켓을 폭발시켜 두 번째 (중간) 포탑으로 "벽"을 만듭니다. 이 과정이 반복됩니다.

게임이 30 턴 이상 지속되면 SideShooter는 지루해지며 조금씩 바뀝니다. 두 번째 (중간) 포탑으로 "벽"을 만드는 대신 똑바로 쏴집니다. 나머지 포탑도 같은 방식으로 작동합니다.

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

}

저격병

스나이퍼는 먼저 양면을 차단 한 다음 바로 촬영을 시작합니다.

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

}

3 발의 탄

이상한 장면이 날아갔습니다. 진정한 방어는 아니지만 패턴은이 기이 한 미사일을지나 치기 어려울 것입니다. (또는 그 아이디어입니다. 대부분 작동하지 않을 것입니다.)

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

노트

다카

다카는 정지없이 5 방향으로 발사합니다 (포탑이 다른 미사일에 의해 망칠 때까지).

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

스트레이트 샷

그들에게 바로 발사하십시오.

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

여기 내 자신의 항목이 있습니다

WallE

오프셋 로켓을 발사하고 가장자리와 중앙에 벽을 만듭니다. 100 턴 후 중간 슬롯을 목표로 시작합니다.

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;










    }

}