Roket Bot KOTH

11

Bot Roket

Tahun ini adalah 3024. Orang-orang menjadi sumber daya yang terlalu langka untuk dipertaruhkan dalam perang, jadi pertempuran telah bergeser ke robot. Tugas Anda adalah membuat bot tidak seperti yang lain, roket siapa yang akan menghujani musuh Anda dan menembak semua ancaman yang masuk.

Gameplay

Bot

Gameplay berlangsung di grid 10x15. Bot Anda terletak di tepi bawah, dan memiliki tiga slot di titik 6,7 dan 8 dari kisi. Lawan Anda terletak di bagian atas grid, dengan tiga slot tepat di hadapan Anda.

Roket

Dari salah satu slot ini, Anda dapat menembakkan roket, dengan asumsi slot belum dihancurkan. Roket terdiri dari daftar arah yang diberikan padanya saat dibuat, dan sekali menembakkan arah ini tidak dapat diubah. Setiap belokan, roket akan mengkonsumsi bagian atas daftar, dan bergerak ke arah itu. Roket bergerak secara bersamaan. Jika dua roket berakhir di ubin yang sama, keduanya akan meledak. Jika roket kehabisan perintah, itu akan meledak. Jika roket kehabisan bahan bakar, setelah 100 bergerak, itu akan meledak. Ketika sebuah roket meledak, ia akan tetap berada di ubin itu selama 5 putaran, menyebabkan roket lain yang bergerak di sana meledak juga.

Catatan: Karena gerakan simultan, dua roket dapat saling melintas tanpa meledak, selama keduanya tidak mengakhiri putaran di ubin yang sama.

Tujuan

Tujuan dari setiap pertandingan adalah untuk menghancurkan slot lawan Anda sambil menjaga Anda tetap hidup. Sebuah roket dapat ditembakkan dari slot langsung apa pun yang Anda miliki, dan diberikan jalur yang ditentukan oleh Anda sebelum diluncurkan. Anda menembakkan roket setiap belokan kedua, artinya roket akan bergerak dua kali sebelum Anda dapat menembakkan roket lainnya. Duel berlangsung selama 200 putaran, atau sampai satu slot bot dihancurkan.

Mencetak gol

Di akhir pertandingan, Anda mendapatkan satu poin untuk setiap slot langsung yang Anda miliki, dan satu poin untuk setiap slot lawan yang Anda hancurkan. Ini berarti ini adalah pertandingan zero-sum, dan 6 poin akan diberikan setiap pertandingan.

Robin robin akan dijalankan sehingga setiap bot saling berhadapan satu sama lain. Jika ada bot yang menggunakan RNG, maka setiap pertarungan akan menjadi 1000 duel sebagai gantinya.

Penerapan

Kode untuk kompetisi dapat ditemukan di sini: https://github.com/Cain93/RocketBots

Setiap pengajuan harus memperluas Botkelas. Anda harus mengganti fireRocketmetode. Metode ini menerima larik kisi-kisi Rockets Rocket[][],, yang mewakili gameboard. Anda selalu terletak di bagian bawah dari grid, dengan slot di tempat [-1][6], [-1][7], [-1][8]. Di grid, tempat yang tidak dihuni akan diwakili dengan null. Jika roket ada di ubin, Anda dapat mengidentifikasi siapa pemiliknya dengan mengakses disbidang. "^" adalah roket Anda, dan "v" adalah lawan Anda.

Anda harus mengembalikan LinkedList of Integers yang memberikan instruksi untuk roket Anda. Untuk bergerak ke atas, gunakan 0. Untuk bergerak ke atas dan ke kanan, gunakan 1, tepat, gunakan 2, dll hingga 7 untuk naik dan turun. Roket akan bergerak sesuai urutan Anda mendorong Integer. Sebagai contoh, kode berikut akan membuat roket bergerak ke atas beberapa putaran, zig-zag beberapa putaran dan kemudian meledak.

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

Untuk mengubah slot tempat menembakkan roket, ubah curSlotbidang. 0 adalah slot paling kiri Anda, dan 2 adalah slot paling kanan Anda. Untuk memeriksa apakah ada slot yang hancur, gunakan getSlot(int slotNumber).

Jika roket mengakhiri giliran pada slot, slot itu akan dihancurkan. Anda tidak perlu meledakkan roket secara manual.

Catatan: Roket muncul di lokasi slot yang ditembakkan, tetapi akan bergerak satu kali sebelum tabrakan dievaluasi. Jadi jika Anda menembakkan roket dari slot 0, dan langkah pertama benar (2), maka Anda akan menghancurkan slot tengah Anda sendiri. Namun, atas dan kanan (1) adalah langkah yang aman.

Jika Anda ingin memberi nama bot Anda, ganti name()metode tersebut.

Bot akan dibangun kembali untuk setiap duel, sehingga setiap variabel statis akan diatur ulang.

Semoga berhasil!

Semoga roket Anda terbang dengan benar dan lawan Anda hanyalah serpihan logam yang membara.

Petunjuk:

Dengan sengaja meledakkan roket untuk menciptakan ledakan adalah cara yang lebih mudah untuk bertahan daripada mencoba menembak jatuh roket lawan.

Bot Contoh

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

}

Skor

Skor dari 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
king-of-the-hill  java 
— Kain
sumber
Memperbaiki pesanan jadi tidak masalah, jika ada bot yang menggunakan RNG maka saya akan meningkatkan berlari ke 1000 kali per pertarungan
— Cain
1
Apakah ada cara untuk memeriksa apakah slot lawan hancur? getSlot (int) hanya untuk slot kami, bukan?
— Katenkyo
1
@Cain Ini bisa menarik, untuk tidak dapat meluncurkan roket ke slot yang hancur: 3
— Katenkyo
1
@ Manu itu bukan bug, Anda melihat ke papan dari sisi Anda, jadi slot kiri relatif
— Katenkyo
1
Maaf, sudah memperbaiki bug itu, saya hanya lupa untuk mendorongnya!
— Kain

Jawaban:

3

Pembela

Bek menggunakan jenis pertahanan baru: Roket berpatroli di depan slot. Ini memberi keuntungan besar, karena roket hidup untuk 100 putaran, bukan 5 putaran (seperti ledakan).

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;
    }
}
— CommonGuy
sumber
Wow +1. Bot yang luar biasa. Tapi seperti yang Anda katakan, gagal bermain bagus saat bot ada di sisi lain.
— Spikatrix
1
Permainan yang cukup sempurna, selamat
— Kain
6

Zigzagoon

Slot luar melebar (sedikit), lalu maju dan kembali ke slot musuh. Slot tengah memotret pola zig-zag di tengah.

Setiap putaran lainnya (3 putaran), masuk ke mode pertahanan dan hanya meledak beberapa roket di dekat slot saya sendiri. Modus serangan roket kemudian pergi di sekitar mereka. Tidak ada yang terlalu mewah, hanya sesuatu untuk membuat kontes berjalan.

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;
    }
}
— Geobit
sumber
Diperbaiki, sebagian besar perbedaan berasal dari mana apakah dimulai sebagai benar atau salah. Bot sekarang dibangun kembali sebelum setiap pertandingan.
— Kain
Ah, itu masuk akal. Saya bahkan tidak memikirkan variabel yang tidak diatur ulang. Terima kasih :)
— Geobits
5

Terminator

Saya bangga mempersembahkan Terminator !!!

Setiap roket bergerak paling kiri / kanan dari tengah dan kembali pada slot musuh. Setiap dua belokan, roket pertahanan diluncurkan lurus dan meledak di dekat slot untuk melindunginya.

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

}
— guy777
sumber
3

HatTrickBot

Saya punya DoubleTapBot untuk CodeBot 3, yang memukul dua kali secara bergantian, inilah HatTrickBot: Menekan semua 3 tempat sekaligus!

Selalu mungkin untuk mencegah roket mengenai jika Anda tahu di mana itu akan jatuh. Tapi saya tidak berpikir ada banyak bot yang akan dapat melindungi slot mereka terhadap serangan 3 roket.

Ngomong-ngomong, ya, itu mengerikan untuk melihat yang lain jika dengan saklar berulang. Saya bisa membuat var untuk menghidupkan dengan nilai-nilai unik untuk setiap kombinasi status slot dan turnConter. Tetapi akan lebih sulit untuk membaca (saya harus menyimpan makna dari nilai-nilai dalam komentar ... membosankan!) :)

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;
    }
}
— Katenkyo
sumber
Roket hanya menembakkan setiap belokan lainnya, jadi ini tidak membuat Hat Trick penuh. Namun masih sangat efektif
— Kain
@ Kain Ho, sedih karena setiap 2 putaran: /. Ngomong-ngomong, saya akan melihat hasil dari putaran pertama kemudian memodifikasi untuk melakukan HatTrick nyata jika saya pikir itu dapat memperbaikinya :)
— Katenkyo
Roket bergerak dua kali antara setiap kali fireRocket () dipanggil. Jadi sekarang, mereka semua diimbangi satu sama lain dengan diam. Anda dapat menggunakan file tes di controller untuk melihat representasi visual dari pertandingan.
— Kain
@ Kain saya sedang bekerja ketika saya menulis bot itu, jadi saya mendasarkannya hanya pada spesifikasi :)
— Katenkyo
Wow, saya terkesan Anda berhasil menulis itu tanpa pengujian, selamat. Saya memperbarui spesifikasi untuk membuatnya lebih jelas
— Cain
2

Kura-kura darat

Jika saya melindungi semua markas saya, saya punya 3 poin. Basis hanya dapat diserang dari 5 lokasi jika saya mendapatkan grid dengan baik. Rocket bertahan 5 giliran di lapangan ...

Bot ini menggunakan semua ini untuk mencocokkan tujuannya: bertahan dengan setidaknya 50% poin di saku. Ia menembakkan 3 roket, lalu menutupi dirinya sendiri

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;
    }
}
— Katenkyo
sumber
Roket hanya menembakkan setiap belokan lainnya, sehingga Anda benar-benar hanya dapat mempertahankan 2 setengah dinding
— Kain
@ Kain Oh, Jadi saya akan memodifikasinya untuk memiliki tempat berlindung :)
— Katenkyo
2

SideShooter

Pemotretan pertama melalui menara pertama (paling kanan) dengan salah satu dari dua cara berbeda. Kemudian, ia menembak melalui menara terakhir (paling kiri) dengan salah satu dari dua cara berbeda. Kemudian ia membuat "dinding" dengan menara kedua (tengah) dengan meledakkan roket di depan setiap menara. Proses ini diulangi.

Jika permainan berlangsung selama lebih dari 30 putaran, SideShooter menjadi bosan dan berubah sedikit. Alih-alih membuat "dinding" dengan menara kedua (tengah), ia menembak lurus. Sisa-sisa menara berperilaku dengan cara yang sama.

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

}
— Spikatrix
sumber
yang do...whilepernyataan melakukan loop tak terbatas ...
— guy777
@ guy777, Tidak. Itu loop sampai menemukan menara tidak rusak.
— Spikatrix
baik ! dua kali pertama saya meluncurkan kode dengan semua bot, SideShooter dan bot lainnya (saya tidak tahu yang mana) tidak bisa menyelesaikan permainan !!!
— guy777
Beberapa permainan tidak dapat diselesaikan. Pengontrol harus memiliki batas putaran.
— guy777
1
@ CoolGuy Saya memilih untuk menyetujui hasil editnya. Pastikan untuk mengulas / mengujinya sendiri.
— mbomb007
2

Penembak jitu

Sniper pertama kali memblokir kedua sisi dan kemudian mulai menembak lurus.

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

}
— Spikatrix
sumber
Lihat komentar di SideShooter, masalah yang sama di sini.
— Kain
2

Tiga Tembakan

Kami mendapat beberapa tembakan aneh. Tidak ada pertahanan sejati, tetapi polanya sedemikian rupa sehingga akan sulit untuk menembus tembakan rudal yang aneh ini. (atau itulah idenya. kemungkinan besar tidak akan berhasil.)

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

Catatan

— MegaTom
sumber
2

MoreDakka

MoreDakka menembak ke lima arah tanpa henti (sampai menara dihancurkan oleh rudal lainnya).

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;
    }
}
— Spikatrix
sumber
1

StraightShot

Menembaki mereka.

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;
    }
}
— MegaTom
sumber
1
Jika Anda tidak sadar, ini pada dasarnya sama dengan WaveBot , salah satu contoh bot yang disertakan dengan pengontrol.
— Geobits
@ Geobits saya tidak tahu bahwa ada bot contoh.
— MegaTom
Buruknya saya karena tidak menempatkan Sampel Bot di tempat yang lebih mudah dilihat. Saya hanya akan menghapus WaveBot dan membiarkan entri ini berdiri
— Cain
1

Ini entri saya sendiri

WallE

Menembak beberapa roket offset, dan membangun dinding di tepi dan tengahnya. Setelah 100 putaran, mulai menargetkan slot tengah.

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;










    }

}
— Kain
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.