Raketen-Bots

Wir schreiben das Jahr 3024. Die Menschen sind zu knapp geworden, um im Krieg ein Risiko einzugehen, und der Kampf hat sich auf die Roboter verlagert. Ihre Aufgabe ist es, einen Bot wie keinen anderen zu konstruieren, dessen Raketen die Zerstörung auf Ihre Feinde regnen und alle eingehenden Bedrohungen abschießen.

Spielweise

Bots

Das Gameplay findet in einem 10x15-Raster statt. Ihr Bot befindet sich am unteren Rand und hat drei Steckplätze an den Stellen 6, 7 und 8 des Gitters. Ihr Gegner befindet sich oben im Raster, mit drei Slots direkt gegenüber Ihrem.

Raketen

Von jedem dieser Slots aus können Sie eine Rakete abfeuern, vorausgesetzt, der Slot wurde nicht zerstört. Eine Rakete besteht aus einer Liste von Richtungen, die ihr beim Erstellen gegeben werden. Sobald sie abgefeuert wurde, können diese Richtungen nicht mehr geändert werden. In jeder Runde verbraucht die Rakete den Anfang der Liste und bewegt sich in diese Richtung. Raketen bewegen sich gleichzeitig. Wenn zwei Raketen auf demselben Plättchen enden, explodieren beide. Wenn einer Rakete die Befehle ausgehen, explodiert sie. Wenn einer Rakete nach 100 Bewegungen der Treibstoff ausgeht, explodiert sie. Wenn eine Rakete explodiert, bleibt sie 5 Runden lang auf diesem Plättchen, wodurch auch alle anderen Raketen, die sich dorthin bewegen, explodieren.

Hinweis: Aufgrund der gleichzeitigen Bewegung können zwei Raketen ohne Explosion aneinander vorbeifahren, sofern nicht beide eine Runde auf demselben Plättchen beenden.

Tor

Das Ziel jedes Spiels ist es, die Slots deines Gegners zu zerstören und deine am Leben zu erhalten. Eine Rakete kann von jedem Live-Slot aus abgefeuert werden und erhält vor dem Abfeuern einen von Ihnen festgelegten Pfad. Sie feuern jede zweite Runde eine Rakete ab, was bedeutet, dass sich die Raketen zweimal bewegen, bevor Sie eine weitere abfeuern können. Ein Duell dauert 200 Runden oder bis alle Slots eines Bots zerstört sind.

Wertung

Am Ende des Spiels erhalten Sie einen Punkt für jeden Live-Slot und einen Punkt für jeden gegnerischen Slot, den Sie zerstört haben. Dies bedeutet, dass es sich um ein Nullsummenspiel handelt und jedes Spiel 6 Punkte erhält.

Ein Round Robin wird ausgeführt, so dass sich jeder Bot einmal gegenübersteht. Wenn Bots RNGs verwenden, besteht jedes Matchup stattdessen aus 1000 Duellen.

Implementierung

Den Code für den Wettbewerb finden Sie hier: https://github.com/Cain93/RocketBots

Jede Einreichung sollte die BotKlasse erweitern. Sie müssen die fireRocketMethode überschreiben . Diese Methode empfängt ein Gitterarray von Raketen Rocket[][], das das Spielbrett darstellt. Sie werden immer an der Unterseite des Gitters befindet, mit Schlitzen an Stellen [-1][6], [-1][7], [-1][8]. In der Tabelle werden nicht belegte Stellen mit dargestellt null. Wenn eine Rakete in einem Plättchen vorhanden ist, können Sie identifizieren, wem sie gehört, indem Sie auf das disFeld zugreifen . "^" ist deine Rakete und "v" ist deine Gegner.

Sie müssen eine LinkedList of Integers zurückgeben, die die Anweisungen für Ihre Rakete enthält. Um nach oben zu gelangen, verwenden Sie 0. Um nach oben und rechts zu gelangen, verwenden Sie 1, genau rechts, verwenden Sie 2 usw. bis 7 für oben und links. Die Rakete bewegt sich in der Reihenfolge, in der Sie Ganzzahlen drücken. Mit dem folgenden Code bewegt sich die Rakete beispielsweise einige Umdrehungen nach oben, einige Umdrehungen im Zick-Zack und detoniert dann.

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

Ändern Sie das curSlotFeld , um zu ändern, aus welchem ​​Steckplatz die Rakete abgefeuert werden soll. 0 ist Ihr Slot ganz links und 2 ist Ihr Slot ganz rechts. Verwenden Sie, um zu überprüfen, ob ein Steckplatz zerstört wurde getSlot(int slotNumber).

Wenn eine Rakete eine Runde in einem Slot beendet, wird dieser Slot zerstört. Sie müssen die Rakete nicht manuell zur Detonation bringen.

Hinweis: Raketen erscheinen an der Stelle, an der der Slot abgefeuert wurde, bewegen sich jedoch einmal, bevor Kollisionen ausgewertet werden. Wenn Sie also eine Rakete aus Steckplatz 0 abfeuern und der erste Zug richtig ist (2), zerstören Sie Ihren eigenen mittleren Steckplatz. Nach oben und rechts (1) ist jedoch ein sicherer Zug.

Wenn Sie Ihren Bot benennen möchten, überschreiben Sie die name()Methode.

Die Bots werden für jedes Duell neu erstellt, sodass alle statischen Variablen zurückgesetzt werden.

Viel Glück!

Mögen Ihre Raketen wahr fliegen und Ihre Gegner nichts als schwelende Metallreste sein.

Hinweis:

Die gezielte Detonation von Raketen zur Erzeugung von Explosionen ist eine einfachere Möglichkeit zur Verteidigung als der Versuch, gegnerische Raketen abzuschießen.

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

}

Scores

Ergebnisse von 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

Verteidiger

Der Verteidiger verwendet eine neue Art der Verteidigung: Die Raketen patrouillieren vor den Slots. Dies bietet einen großen Vorteil, da Raketen 100 statt 5 Runden (wie Explosionen) leben.

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

Zickzack

Die äußeren Schlitze sind (leicht) breit, gehen dann nach vorne und kehren in Richtung der feindlichen Schlitze zurück. Der mittlere Schlitz schießt ein Zickzackmuster in die Mitte.

In jeder zweiten Runde (3 Runden) geht es in den Verteidigungsmodus und explodiert nur einige Raketen in der Nähe meiner eigenen Slots. Raketen im Angriffsmodus umgehen sie dann. Nichts Besonderes, nur etwas, um den Wettbewerb zum Laufen zu bringen.

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

Ich bin stolz Terminator zu präsentieren !!!

Jede Rakete bewegt sich weit links / rechts von der Mitte und kehrt auf einen feindlichen Platz zurück. Alle zwei Runden wird eine Verteidigungsrakete gerade abgefeuert und explodiert in der Nähe des Schlitzes, um sie zu schützen.

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

Ich hatte DoubleTapBot für CodeBot 3, der zweimal in einer Runde traf. Hier kommt HatTrickBot: Alle 3 Punkte gleichzeitig treffen!

Es ist immer möglich zu verhindern, dass eine Rakete trifft, wenn Sie wissen, wo sie fallen wird. Aber ich glaube nicht, dass es viele Bot gibt, die ihre Slots vor einem 3-Raketen-Angriff schützen können.

Übrigens, ja, es ist schrecklich, so etwas anderes mit wiederholtem Wechsel zu sehen. Ich hätte eine Variable zum Einschalten mit eindeutigen Werten für jede Kombination aus dem Status der Slots und dem TurnConter erstellen können. Aber es wäre schwieriger zu lesen (ich müsste die Bedeutung der Werte in einem Kommentar behalten ... langweilig!) :)

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

Schildkröte

Wenn ich alle meine Basen schütze, habe ich 3 Punkte. Basen können nur von 5 Orten aus angegriffen werden, wenn ich das Gitter gut bekomme. Rakete dauert 5 Runde auf dem Feld ...

Dieser Bot nutzt all dies, um sein Ziel zu erreichen: Überleben mit mindestens 50% der Punkte in der Tasche. Es schießt 3 Raketen und deckt sich dann ab

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

Erste Schüsse über den ersten (ganz rechts) Turm auf zwei verschiedene Arten. Dann schießt es auf zwei verschiedene Arten über den letzten (ganz linken) Turm. Dann bildet es eine "Wand" mit dem zweiten (mittleren) Turm, indem Raketen vor jedem Turm explodieren. Dieser Vorgang wird wiederholt.

Wenn das Spiel länger als 30 Runden dauert, wird SideShooter langweilig und ändert sich geringfügig. Anstatt mit dem zweiten (mittleren) Turm eine "Wand" zu bilden, schießt er gerade. Der Rest der Türme verhält sich genauso.

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

}

Scharfschütze

Sniper blockiert zuerst seine beiden Seiten und beginnt dann gerade zu schießen.

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

}

Drei Schüsse

Wir haben ein paar seltsame Schüsse bekommen. Keine echte Verteidigung, aber das Muster ist so, dass es schwierig sein wird, an diesem bizarren Raketenhagel vorbei zu schießen. (oder das ist die Idee. Es wird höchstwahrscheinlich nicht funktionieren.)

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

Hinweis

MoreDakka

MoreDakka schießt ohne Unterbrechung in fünf Richtungen (bis die Türme von anderen Raketen zerstört werden).

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

Feuern Sie einfach direkt auf sie.

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

Hier ist mein eigener Eintrag

Wall-E

Schießt einige versetzte Raketen ab und baut Wände an seinen Kanten und in der Mitte. Beginnt nach 100 Runden, auf den mittleren Schlitz zu zielen.

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;










    }

}