Ракетні боти

Рік 3024. Люди стали надто дефіцитним ресурсом, щоб ризикувати війною, тому боротьба перейшла до роботів. Ваше завдання - сконструювати бота, як ніхто інший, хто ракети дощу знищить на ваших ворогів і збиває всі вхідні загрози.

Ігровий процес

Боти

Гра відбувається на сітці 10х15. Ваш бот розташований від нижнього краю та має три прорізи в місцях 6,7 та 8 сітки. Ваш опонент розташований у верхній частині сітки, з трьома слотами навпроти вашого.

Ракети

З будь-якого з цих слотів ви можете вистрілити ракету, якщо припустити, що гніздо не було знищено. Ракета складається зі списку напрямків, які даються їй під час створення, і щойно вистрілені ці напрямки не можуть бути змінені. Кожного повороту ракета буде споживати верхню частину списку і рухатись у цьому напрямку. Ракети рухаються одночасно. Якщо дві ракети закінчуються в одній плитці, вони обидві вибухнуть. Якщо у ракети не вистачить команд, вона вибухне. Якщо у ракети закінчиться паливо, через 100 рухів вона вибухне. Коли ракета вибухне, вона залишиться в цій плитці протягом 5 оборотів, внаслідок чого будь-які інші ракети, які рухаються туди, також вибухнуть.

Примітка: Через одночасний рух дві ракети можуть проходити одна одну, не вибухаючи, якщо вони не закінчать поворот у одній плитці.

Мета

Мета кожного матчу - знищити опонентів, залишаючи живими. Ракету можна вистрілити з будь-якого живого слота, і їй буде наданий шлях, визначений вами до того, як він буде вистрілений. Ви вистрілюєте ракету кожен другий хід, тобто ракети рухатимуться двічі, перш ніж ви зможете вистрілити ще одну. Поєдинок триває 200 оборотів або поки всі боти не будуть знищені.

Оцінка балів

В кінці матчу ви отримуєте один бал за кожний живий слот, який ви маєте, і один бал за кожен винищений слот суперника. Це означає, що це гра з нульовою сумою, і 6 балів будуть присуджуватися за кожен матч.

Круглий робот буде запускатися так, що кожен бот стикається один з одним ботом один раз. Якщо будь-які боти використовують RNG, то на кожний матч буде 1000 дуелів.

Впровадження

Код змагань можна знайти тут: https://github.com/Cain93/RocketBots

Кожне подання повинно розширити Botклас. Ви повинні перекрити fireRocketметод. Цей метод отримує сітчастий масив Rockets Rocket[][], який представляє ігровий майданчик. Ви завжди розташовані в нижній частині сітки, з прорізами в точках [-1][6], [-1][7], [-1][8]. На сітці незайняті плями будуть представлені с null. Якщо ракета існує в плитці, ви можете визначити, кому вона належить, відкривши disполе. "^" - це ваша ракета, а "v" - ваші опоненти.

Ви повинні повернути LinkedList of Integers, який дає інструкції для вашої ракети. Щоб рухатись вгору, використовуйте 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

Захисник

Захисник використовує новий тип захисту: Ракети патрулюють перед гніздами. Це дає величезну перевагу, оскільки ракети живуть на 100 оборотів замість 5 обертів (як вибухи).

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

У мене був DoubleTapBot для CodeBot 3, який двічі по черзі бив, ось приходить HatTrickBot: Вдаючи всі 3 плями одночасно!

Завжди можна запобігти удару ракети, якщо знати, куди вона впаде. Але я не думаю, що існує багато ботів, які зможуть захистити свої слоти від 3-х ракетних атак.

До речі, так, жахливо бачити такі речі з повторним перемиканням. Я міг би створити вар для включення унікальних значень для кожної комбінації статусу слотів і turnConter. Але це було б важче читати (я мав би зберігати значення значень у коментарі ... нудно!) :)

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

SideShooter

Спочатку стріляє через першу (праву) башту одним з двох різних способів. Потім він стріляє через останню (ліву) башту одним з двох різних способів. Тоді він робить "стіну" з другою (середньою) баштою, вибухаючи ракети перед кожною башточкою. Цей процес повторюється.

Якщо гра триває більше 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;
    }

}

Три постріли

У нас вилітали кілька дивних пострілів. Немає справжньої оборони, але закономірність така, що важко буде прострілити цей химерний град ракет. (або це ідея. це, швидше за все, не вийде.)

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

Примітка

MoreDakka

MoreDakka стріляє в п'ятьох напрямках без зупинки (поки башточки не будуть розбиті іншими ракетами).

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

Просто стріляй прямо по них.

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;










    }

}