Rakietowe boty

Jest rok 3024. Ludzie stali się zbyt rzadkim zasobem, aby ryzykować wojną, więc walka przeniosła się na roboty. Twoim zadaniem jest zbudowanie bota, jak żaden inny, którego rakiety spowodują zniszczenie wrogów i zestrzelą wszystkie nadchodzące zagrożenia.

Rozgrywka

Boty

Rozgrywka odbywa się na siatce 10 x 15. Twój bot znajduje się poza dolną krawędzią i ma trzy miejsca w punktach 6,7 i 8 siatki. Twój przeciwnik znajduje się na górze siatki, a trzy miejsca znajdują się naprzeciwko twojego.

Rakiety

Z dowolnego z tych miejsc możesz wystrzelić rakietę, zakładając, że nie został on zniszczony. Rakieta składa się z listy kierunków, która jest jej przekazywana podczas tworzenia, a po wystrzeleniu tych kierunków nie można zmienić. W każdej turze rakieta zjedzie górę listy i ruszy w tym kierunku. Rakiety poruszają się jednocześnie. Jeśli dwie rakiety zakończą się tym samym kafelkiem, obie eksplodują. Jeśli rakiety zabraknie poleceń, wybuchnie. Jeśli rakiety zabraknie paliwa, po 100 ruchach eksploduje. Kiedy rakieta eksploduje, pozostanie w tym kafelku przez 5 tur, powodując również eksplozję wszystkich innych rakiet, które się tam poruszą.

Uwaga: Z powodu jednoczesnego ruchu dwie rakiety mogą przelatywać między sobą bez eksplozji, o ile obie nie kończą tury na tym samym kafelku.

Cel

Celem każdego meczu jest zniszczenie miejsc przeciwników przy jednoczesnym utrzymaniu twojego przy życiu. Rakietę można wystrzelić z dowolnego posiadanego automatu na żywo, a przed wystrzeleniem ma ona wyznaczoną przez ciebie ścieżkę. Strzelasz rakietą co drugą turę, co oznacza, że ​​rakiety poruszą się dwukrotnie, zanim będziesz mógł wystrzelić kolejną. Pojedynek trwa 200 tur lub do momentu zniszczenia jednego z botów.

Punktacja

Na koniec meczu otrzymujesz jeden punkt za każde miejsce na żywo, które posiadasz, i jeden punkt za każde miejsce przeciwnika, które zniszczyłeś. Oznacza to, że jest to gra o sumie zerowej, a za każdy mecz zostanie przyznanych 6 punktów.

Uruchomiony zostanie okrągły robin, dzięki czemu każdy bot skierowany będzie do siebie. Jeśli któryś z botów używa RNG, każdy pojedynek będzie zamiast tego 1000 pojedynkami.

Realizacja

Kod konkursu można znaleźć tutaj: https://github.com/Cain93/RocketBots

Każde zgłoszenie powinno rozszerzyć Botklasę. Musisz zastąpić fireRocketmetodę. Ta metoda otrzymuje tablicę siatki Rakiet Rocket[][], która reprezentuje planszę. Jesteś zawsze znajduje się w dolnej części siatki, z otworami w miejscach [-1][6], [-1][7], [-1][8]. Na siatce będą wyświetlane niezajęte miejsca null. Jeśli rakieta istnieje na kafelku, możesz zidentyfikować, do kogo należy, wchodząc na dispole. „^” to twoja rakieta, a „v” to twoi przeciwnicy.

Musisz zwrócić LinkedList of Integers, który podaje instrukcje dla twojej rakiety. Aby przejść w górę, użyj 0. Aby poruszać się w górę i w prawo, użyj 1, w prawo, użyj 2 itd. Aż do 7 w górę i w lewo. Rakieta porusza się w kolejności, w której naciskasz liczby całkowite. Na przykład poniższy kod spowoduje, że rakieta przesunie się w górę o kilka obrotów, zygzakiem o kilka obrotów, a następnie wybuchnie.

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

Aby zmienić, z którego miejsca wystrzelić rakietę, zmień curSlotpole. 0 to twój lewy skraj, a 2 to twój skrajny prawy. Aby sprawdzić, czy miejsce jest zniszczone, użyj getSlot(int slotNumber).

Jeśli rakieta zakończy turę na polu, miejsce to zostanie zniszczone. Nie musisz ręcznie detonować rakiety.

Uwaga: Rakiety spawnują się w miejscu, z którego wystrzelono miejsce, ale poruszą się raz, zanim zostaną ocenione kolizje. Jeśli więc wystrzelisz rakietę ze szczeliny 0, a pierwszy ruch jest właściwy (2), zniszczysz swój środkowy otwór. Jednak strzałka w górę i w prawo (1) to bezpieczny ruch.

Jeśli chcesz nazwać swojego bota, zastąp name()metodę.

Boty zostaną odbudowane dla każdego pojedynku, więc wszelkie zmienne statyczne zostaną zresetowane.

Powodzenia!

Niech wasze rakiety latają prawdziwie, a przeciwnicy będą tylko tlącymi się skrawkami metalu.

Wskazówka:

Celowe detonowanie rakiet w celu wywołania eksplozji jest łatwiejszym sposobem obrony niż próba zestrzelenia rakiet przeciwnika.

Przykład 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;
    }

}

Wyniki

Wyniki od 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

Obrońca

Defender używa nowego rodzaju obrony: rakiety patrolują przed gniazdami. Daje to ogromną przewagę, ponieważ rakiety żyją przez 100 tur zamiast 5 tur (jak eksplozje).

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

Zygzak

Zewnętrzne miejsca mają szerokość (nieco) szeroką, następnie skieruj się do przodu i wróć w kierunku miejsc wroga. Środkowy otwór wystrzeliwuje zygzakowaty wzór w górę środka.

Co drugą rundę (3 tury) przechodzi w tryb obrony i po prostu eksploduje kilka rakiet w pobliżu moich miejsc. Rakiety w trybie ataku następnie ominą je. Nic nadzwyczajnego, po prostu coś, co umożliwi uruchomienie konkursu.

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

Terminator

Z dumą prezentuję Terminator !!!

Każda rakieta porusza się daleko w lewo / prawo od środka i wraca na miejsce wroga. Co dwie tury rakieta obronna wystrzeliwuje prosto i eksploduje w pobliżu szczeliny, aby ją chronić.

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

Miałem DoubleTapBota dla CodeBot 3, który uderzał dwa razy na turę, oto HatTrickBot: trafienie wszystkich 3 miejsc jednocześnie!

Zawsze można zapobiec trafieniu rakiety, jeśli wiesz, gdzie spadnie. Ale nie sądzę, aby wielu botów mogło zabezpieczyć swoje automaty przed atakiem 3 rakiet.

Nawiasem mówiąc, tak, okropnie jest widzieć takie coś przy powtarzającym się przełączaniu. Mógłbym stworzyć var ​​do włączania z unikalnymi wartościami dla każdej kombinacji statusu slotów i turnConter. Ale trudniej byłoby go odczytać (musiałbym zachować znaczenie wartości w komentarzu ... nudne!) :)

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

Żółw

Jeśli ochronię wszystkie moje bazy, mam 3 punkty. Bazy mogą być atakowane tylko z 5 lokalizacji, jeśli dobrze dostanę siatkę. Rakieta trwa 5 tur na boisku ...

Ten bot wykorzystuje to wszystko, aby osiągnąć swój cel: przetrwać z co najmniej 50% punktów w kieszeni. Wystrzeliwuje 3 rakiety, a następnie się osłania

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

Najpierw strzelaj przez pierwszą (skrajnie prawą) wieżę na jeden z dwóch różnych sposobów. Następnie strzela przez ostatnią (skrajnie lewą) wieżę na jeden z dwóch różnych sposobów. Następnie tworzy „ścianę” z drugą (środkową) wieżą, eksplodując rakiety przed każdą wieżą. Ten proces się powtarza.

Jeśli gra trwa dłużej niż 30 tur, SideShooter znudzi się i zmienia w niewielkim stopniu. Zamiast robić „ścianę” za pomocą drugiej (środkowej) wieży, strzela prosto. Reszta wieżyczek zachowuje się w ten sam sposób.

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

}

Snajper

Snajper najpierw blokuje dwie strony, a następnie zaczyna strzelać prosto.

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

}

Three Shot

Mamy dziwne ujęcia. Nie ma prawdziwej obrony, ale wzór jest taki, że ciężko będzie strzelić obok tego dziwnego gradu pocisków. (lub taki jest pomysł. najprawdopodobniej nie zadziała).

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

Uwaga

WięcejDakka

Dalka strzela w pięciu kierunkach bez zatrzymania (dopóki wieżyczki nie zostaną zniszczone przez inne pociski).

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

Po prostu strzelaj do nich.

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

Oto mój własny wpis

WallE

Wystrzeliwuje niektóre rakiety offsetowe i buduje ściany na jego krawędziach i środku. Po 100 turach zaczyna celować w środkowe miejsce.

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;










    }

}