Tên lửa

Năm 3024. Mọi người đã trở nên quá khan hiếm tài nguyên để mạo hiểm trong chiến tranh, vì vậy chiến đấu đã chuyển sang các robot. Nhiệm vụ của bạn là xây dựng một bot không giống ai, những tên lửa sẽ phá hủy kẻ thù của bạn và bắn hạ tất cả các mối đe dọa sắp tới.

Trò chơi

Bots

Trò chơi diễn ra trên lưới 10x15. Bot của bạn nằm ở cạnh dưới cùng và có ba vị trí tại các điểm 6,7 và 8 của lưới. Đối thủ của bạn nằm ở đầu lưới, với ba khe đối diện trực tiếp với bạn.

Tên lửa

Từ bất kỳ vị trí nào trong số này, bạn có thể bắn tên lửa, giả sử vị trí đó chưa bị phá hủy. Một tên lửa bao gồm một danh sách các hướng được đưa cho nó khi được tạo ra, và một khi đã bắn thì các hướng này không thể thay đổi. Mỗi lượt, tên lửa sẽ tiêu thụ đầu danh sách và di chuyển theo hướng đó. Tên lửa di chuyển đồng thời. Nếu hai tên lửa kết thúc trong cùng một ô, cả hai sẽ phát nổ. Nếu một tên lửa hết lệnh, nó sẽ phát nổ. Nếu một tên lửa hết nhiên liệu, sau 100 lần di chuyển, nó sẽ phát nổ. Khi một tên lửa phát nổ, nó sẽ ở lại trong viên gạch đó trong 5 lượt, khiến bất kỳ tên lửa nào khác di chuyển đến đó cũng phát nổ.

Lưu ý: Do chuyển động đồng thời, hai tên lửa có thể vượt qua nhau mà không phát nổ, miễn là cả hai không kết thúc một lượt trong cùng một ô.

Mục tiêu

Mục tiêu của mỗi trận đấu là tiêu diệt các đối thủ của bạn trong khi vẫn giữ cho bạn sống sót. Một tên lửa có thể được bắn từ bất kỳ vị trí trực tiếp nào bạn có và được cung cấp một đường dẫn do bạn chỉ định trước khi nó được bắn. Bạn bắn một tên lửa mỗi lượt thứ hai, có nghĩa là tên lửa sẽ di chuyển hai lần trước khi bạn có thể bắn một tên lửa khác. Một cuộc đấu tay đôi kéo dài trong 200 lượt, hoặc cho đến khi một khe bot bị phá hủy.

Chấm điểm

Vào cuối trận đấu, bạn nhận được một điểm cho mỗi vị trí trực tiếp bạn có và một điểm cho mỗi vị trí đối thủ bạn đã phá hủy. Điều này có nghĩa là đây là một trò chơi có tổng bằng 0 và 6 điểm sẽ được trao cho mỗi trận đấu.

Một vòng tròn sẽ được chạy để mỗi bot đối mặt với bot một lần. Nếu bất kỳ bot nào sử dụng RNG, thì mỗi trận đấu sẽ là 1000 đấu tay đôi.

Thực hiện

Mã cho cuộc thi có thể được tìm thấy ở đây: https://github.com/Cain93/RocketBots

Each submission should extend the Bot class. You must override the fireRocket method. This method receives a grid array of Rockets, Rocket[][], that represents the gameboard. You are always located at the bottom of the grid, with slots at spots [-1][6], [-1][7], [-1][8]. On the grid, unoccupied spots will be represented with null. If a rocket exists in a tile, you can identify who it belongs to by accessing the dis field. "^" is your rocket, and "v" is your opponents.

Bạn phải trả về một Danh sách liên kết các số nguyên cung cấp các hướng dẫn cho tên lửa của bạn. Để di chuyển lên, sử dụng 0. Để di chuyển lên và sang phải, sử dụng 1, vừa phải, sử dụng 2, v.v ... cho đến 7 và lên trên. Tên lửa sẽ di chuyển theo thứ tự bạn đẩy Integers. Ví dụ, đoạn mã sau sẽ khiến tên lửa di chuyển lên trên một vài lượt, ngoằn ngoèo vài vòng rồi kích nổ.

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

Để thay đổi vị trí nào để bắn tên lửa từ đó, hãy thay đổi curSlottrường. 0 là vị trí ngoài cùng bên trái của bạn và 2 là vị trí ngoài cùng bên phải của bạn. Để kiểm tra nếu một khe bị phá hủy, sử dụng getSlot(int slotNumber).

Nếu một tên lửa kết thúc một lượt trên một khe, khe đó sẽ bị phá hủy. Bạn không cần phải tự kích nổ tên lửa.

Lưu ý: Tên lửa sinh sản tại vị trí của khe được bắn ra, nhưng sẽ di chuyển một lần trước khi va chạm được đánh giá. Vì vậy, nếu bạn bắn một tên lửa từ khe 0, và bước đầu tiên là đúng (2), thì bạn sẽ phá hủy khe giữa của chính mình. Tuy nhiên, lên và phải (1) là một động thái an toàn.

Nếu bạn muốn đặt tên cho bot của mình, ghi đè name()phương thức.

Bots sẽ được xây dựng lại cho mỗi trận đấu, vì vậy mọi biến tĩnh sẽ được đặt lại.

Chúc may mắn!

Có thể tên lửa của bạn bay thật và đối thủ của bạn chẳng là gì ngoài những mảnh kim loại âm ỉ.

Dấu:

Cố ý kích nổ tên lửa để tạo ra vụ nổ là một cách dễ dàng hơn để phòng thủ hơn là cố gắng bắn hạ tên lửa đối thủ.

Bot ví dụ

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ểm số

Điểm từ 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

Hậu vệ

Hậu vệ sử dụng một loại phòng thủ mới: Các tên lửa đang tuần tra trước các khe. Điều này mang lại lợi thế rất lớn, vì tên lửa sống trong 100 lượt thay vì 5 lượt (như vụ nổ).

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

Các khe bên ngoài đi (hơi) rộng, sau đó tiến về phía trước và quay trở lại về phía các khe của kẻ thù. Các khe ở giữa bắn một mô hình zigzag lên giữa.

Mỗi vòng khác (3 lượt), nó chuyển sang chế độ phòng thủ và chỉ phát nổ một số tên lửa gần các khe của riêng tôi. Tên lửa chế độ tấn công sau đó đi xung quanh chúng. Không có gì quá lạ mắt, chỉ là một cái gì đó để có được cuộc thi và chạy.

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

Kẻ hủy diệt

Tôi tự hào giới thiệu Terminator !!!

Mỗi tên lửa di chuyển xa trái / phải từ giữa và quay trở lại vào khe của kẻ thù. Cứ sau hai lượt, một tên lửa phòng thủ được phóng thẳng và phát nổ gần khe để bảo vệ nó.

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

Tôi đã có DoubleTapBot cho CodeBot 3, người đã đánh hai lần trong một lượt, đến đây HatTrickBot: Đánh cả 3 điểm cùng một lúc!

Luôn luôn có thể ngăn chặn một tên lửa để bắn nếu bạn biết nó sẽ rơi ở đâu. Nhưng tôi không nghĩ rằng có nhiều bot sẽ có thể bảo vệ các khe của chúng trước một cuộc tấn công bằng tên lửa.

Nhân tiện, vâng, thật kinh khủng khi thấy những thứ khác như vậy với công tắc lặp đi lặp lại. Tôi có thể đã tạo một var để bật với các giá trị duy nhất cho mỗi kết hợp trạng thái của vị trí và TurnConter. Nhưng nó sẽ khó đọc hơn (tôi sẽ phải giữ ý nghĩa của các giá trị trong một bình luận ... nhàm chán!) :)

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

Con rùa

Nếu tôi bảo vệ tất cả các căn cứ của mình, tôi có 3 điểm. Căn cứ chỉ có thể bị tấn công từ 5 địa điểm nếu tôi có được lưới điện tốt. Tên lửa kéo dài 5 lượt trên sân ...

Bot này sử dụng tất cả những điều này để phù hợp với mục tiêu của nó: sống sót với ít nhất 50% số điểm trong túi. Nó bắn 3 quả rocket, sau đó tự bao phủ

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

Lần đầu tiên bắn qua tháp pháo đầu tiên (ngoài cùng bên phải) theo một trong hai cách khác nhau. Sau đó, nó bắn qua tháp pháo cuối cùng (ngoài cùng bên trái) theo một trong hai cách khác nhau. Sau đó, nó tạo ra một "bức tường" với tháp pháo thứ hai (giữa) bằng cách nổ tên lửa trước mỗi tháp pháo. Quá trình này được lặp lại.

Nếu trò chơi kéo dài hơn 30 lượt, SideShooter sẽ phát chán và thay đổi theo một cách nhỏ. Thay vì tạo một "bức tường" bằng tháp pháo thứ hai (giữa), nó bắn thẳng. Các tháp pháo còn lại hoạt động theo cùng một cách.

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

}

Kẻ bắn tỉa

Đầu tiên Sniper chặn hai bên của nó và sau đó bắt đầu bắn thẳng.

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

}

Ba cú sút

Chúng tôi có một số bức ảnh kỳ lạ bay. Không có phòng thủ thực sự, nhưng mô hình là như vậy sẽ khó có thể có được một cú bắn qua cơn mưa tên lửa kỳ quái này. (hoặc đó là ý tưởng. rất có thể nó sẽ không hoạt động.)

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

Ghi chú

ThêmDakka

MoreDakka bắn theo năm hướng mà không dừng lại (cho đến khi tháp pháo bị phá hủy bởi các tên lửa khác).

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

Máy ảnh thẳng

Chỉ cần bắn ngay vào họ.

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

Đây là mục của riêng tôi

WallE

Bắn một số tên lửa bù, và xây tường trên các cạnh và trung tâm của mình. Sau 100 lượt, bắt đầu nhắm mục tiêu vào khe giữa.

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;










    }

}