Rocket Bots

Nous sommes en 3024. Les gens sont devenus une ressource trop rare pour risquer la guerre, alors le combat est passé aux robots. Votre tâche consiste à construire un bot pas comme les autres, dont les roquettes feront pleuvoir la destruction sur vos ennemis et abattront toutes les menaces entrantes.

Gameplay

Bots

Le gameplay se déroule sur une grille 10x15. Votre bot est situé sur le bord inférieur et dispose de trois emplacements aux points 6,7 et 8 de la grille. Votre adversaire est situé en haut de la grille, avec trois emplacements directement en face du vôtre.

Fusées

Depuis n'importe lequel de ces emplacements, vous pouvez tirer une fusée, en supposant que l'emplacement n'a pas été détruit. Une fusée se compose d'une liste de directions qui lui est donnée lors de sa création, et une fois tirée, ces directions ne peuvent plus être modifiées. À chaque tour, la fusée consommera le haut de la liste et se déplacera dans cette direction. Les roquettes se déplacent simultanément. Si deux roquettes se terminent sur la même tuile, elles exploseront toutes les deux. Si une fusée manque de commandes, elle explosera. Si une fusée manque de carburant, après 100 mouvements, elle explosera. Lorsqu'une fusée explose, elle reste dans cette tuile pendant 5 tours, provoquant ainsi l'explosion de toute autre fusée qui s'y déplace.

Remarque: En raison du mouvement simultané, deux roquettes peuvent se croiser sans exploser, tant qu'elles ne se terminent pas toutes les deux un tour dans la même tuile.

Objectif

Le but de chaque match est de détruire les emplacements de vos adversaires tout en gardant le vôtre en vie. Une fusée peut être tirée à partir de n'importe quel emplacement en direct que vous possédez, et on vous donne un chemin que vous avez désigné avant de tirer. Vous tirez une roquette tous les deux tours, ce qui signifie que les roquettes se déplaceront deux fois avant de pouvoir en tirer une autre. Un duel dure 200 tours, ou jusqu'à ce qu'un emplacement de bots soit détruit.

Notation

À la fin du match, vous obtenez un point pour chaque emplacement en direct que vous avez, et un point pour chaque emplacement d'adversaire que vous avez détruit. Cela signifie que c'est un jeu à somme nulle, et 6 points seront attribués à chaque match.

Un tournoi à la ronde sera exécuté afin que chaque bot se fasse face une fois. Si des robots utilisent des RNG, chaque match sera à la place de 1000 duels.

la mise en oeuvre

Le code du concours peut être trouvé ici: https://github.com/Cain93/RocketBots

Chaque soumission devrait prolonger la Botclasse. Vous devez remplacer la fireRocketméthode. Cette méthode reçoit une grille de roquettes Rocket[][], qui représente le plateau de jeu. Vous êtes toujours situé au bas de la grille, avec des fentes à des endroits [-1][6], [-1][7], [-1][8]. Sur la grille, les spots inoccupés seront représentés avec null. Si une fusée existe dans une tuile, vous pouvez identifier à qui elle appartient en accédant au disterrain. "^" est votre fusée et "v" est votre adversaire.

Vous devez renvoyer une LinkedList of Integers qui donne les instructions pour votre fusée. Pour vous déplacer vers le haut, utilisez 0. Pour vous déplacer vers le haut et vers la droite, utilisez 1, juste à droite, utilisez 2, etc. jusqu'à 7 pour le haut et la gauche. La fusée se déplacera dans l'ordre dans lequel vous appuyez sur Entiers. Par exemple, le code suivant fera avancer la fusée de quelques tours, zigzaguer de quelques tours puis exploser.

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

Pour changer de quel emplacement tirer la fusée, changez de curSlotchamp. 0 est votre emplacement le plus à gauche et 2 est votre emplacement le plus à droite. Pour vérifier si un emplacement est détruit, utilisez getSlot(int slotNumber).

Si une fusée termine un tour sur un emplacement, cet emplacement sera détruit. Vous n'avez pas besoin de faire exploser manuellement la fusée.

Remarque: les roquettes apparaissent à l'emplacement de l'emplacement de tir, mais se déplaceront une fois avant que les collisions ne soient évaluées. Donc, si vous tirez une fusée depuis l'emplacement 0 et que le premier coup est à droite (2), vous détruirez votre propre emplacement central. Cependant, monter et droite (1) est un mouvement sûr.

Si vous souhaitez nommer votre bot, remplacez la name()méthode.

Les bots seront reconstruits pour chaque duel, donc toutes les variables statiques seront réinitialisées.

Bonne chance!

Que vos fusées volent véritablement et que vos adversaires ne soient que des morceaux de métal fumants.

Allusion:

Exploser délibérément des roquettes pour créer des explosions est un moyen plus facile de défendre que d'essayer d'abattre des roquettes adverses.

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

}

Les scores

Partitions de 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

Défenseur

Le défenseur utilise un nouveau type de défense: les roquettes patrouillent devant les emplacements. Cela donne un énorme avantage, car les fusées vivent pendant 100 tours au lieu de 5 tours (comme des explosions).

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

Les fentes extérieures vont (légèrement) larges, puis se dirigent vers l'avant et reviennent vers les fentes ennemies. La fente du milieu tire un motif en zigzag au milieu.

Tous les deux tours (3 tours), il passe en mode défense et fait exploser quelques roquettes près de mes propres emplacements. Les fusées en mode attaque les contournent ensuite. Rien d'extraordinaire, juste quelque chose pour lancer le concours.

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

Je suis fier de vous présenter Terminator !!!

Chaque fusée se déplace loin à gauche / à droite du milieu et revient sur un emplacement ennemi. Tous les deux tours, une fusée de défense est lancée directement et explose près de la fente pour la protéger.

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

J'ai eu DoubleTapBot pour CodeBot 3, qui frappait deux fois sur un tour, voici HatTrickBot: Frapper tous les 3 spots en même temps!

Il est toujours possible d'empêcher une fusée de frapper si vous savez où elle tombera. Mais je ne pense pas qu'il y ait beaucoup de bots qui pourront protéger leurs emplacements contre une attaque à 3 roquettes.

Soit dit en passant, oui, c'est horrible de voir un tel autre avec un interrupteur répété. J'aurais pu créer un var pour allumer des valeurs uniques pour chaque combinaison de l'état des emplacements et du turnConter. Mais ce serait plus difficile à lire (il faudrait que je garde le sens des valeurs dans un commentaire ... ennuyeux!) :)

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

Tortue

Si je protège toutes mes bases, j'ai 3 points. Les bases ne peuvent être attaquées qu'à partir de 5 emplacements si je comprends bien la grille. La fusée dure 5 tours sur le terrain ...

Ce bot utilise tout cela pour atteindre son objectif: survivre avec au moins 50% des points dans la poche. Il tire 3 roquettes, puis se couvre

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

Premiers tirs via la première tourelle (la plus à droite) de deux manières différentes. Ensuite, il tire via la dernière tourelle (la plus à gauche) de deux manières différentes. Ensuite, il fait un "mur" avec la deuxième tourelle (au milieu) en faisant exploser des roquettes devant chaque tourelle. Ce processus se répète.

Si le jeu dure plus de 30 tours, SideShooter s'ennuie et change légèrement. Au lieu de faire un "mur" avec la deuxième tourelle (centrale), il tire droit. Les autres tourelles se comportent de la même manière.

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

}

Tireur d'élite

Sniper bloque d'abord ses deux côtés puis commence à tirer droit.

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

}

Trois coups

Nous avons eu des clichés étranges en vol. Pas de véritable défense, mais le schéma est tel qu'il sera difficile d'obtenir un coup de feu après cette grêle bizarre de missiles. (ou c'est l'idée. cela ne fonctionnera probablement pas.)

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

Remarque

PlusDakka

Dakka tire dans cinq directions sans s'arrêter (jusqu'à ce que les tourelles soient détruites par d'autres missiles).

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

Tirez juste dessus.

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

Voici ma propre entrée

WallE

Tire des roquettes décalées et construit des murs sur ses bords et son centre. Après 100 tours, commence à cibler l'emplacement du milieu.

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;










    }

}