LENGKAP

Musim Wumpus telah berakhir, dan dengan, kehidupan banyak Wumpus ganas dan Hunter berani. Serta beberapa Pemburu bodoh pengecut, tidak bermoral dan benar-benar bodoh. Tetapi pada akhir hari, NascarHunter oleh Dr Heckle datang dengan yang paling menjarah dan mulia. Kami salut kepada Anda, oh pemberani ... sopir?

Ini musim terbuka di Wumpus, dan para pemburu dari seluruh dunia berbondong-bondong ke Gua Wumpus untuk mencoba menjadi kaya dari kulit Wumpus yang berharga.

Permainan

Berdasarkan game klasik Hunt the Wumpus , dengan beberapa variasi.

Peta

Sebuah dodecahedron . Ada 20 kamar, masing-masing terhubung ke 3 kamar lain, pada dasarnya membuat 3 cincin dengan jembatan di antaranya.

Wumpus

Wumpus adalah binatang mistis. Tidak ada yang yakin seperti apa itu, tetapi semua setuju bahwa itu ganas. Wumpus hidup di dalam gua, dan suka memakan benda mati. Jika ada mayat di sebuah gua di sebelah Wumpus, ia akan pindah ke sana dan memakannya. Jika Wumpus kebetulan pindah ke gua yang berisi pemburu, ia akan membunuh dan memakannya juga. Jika Wumpus mendengar panah di dekatnya, ia akan panik dan berlari ke ruang acak.

Sifat opsional : Ini saat ini termasuk untuk membuat permainan lebih menarik, tetapi dapat dihapus atas permintaan populer jika mereka menambahkan terlalu banyak keacakan.

Wumpus marah: Jika Wumpus ditembak, ia memiliki 20% bertahan dan mengamuk selama 3 hari. Saat mengamuk, ia akan bergerak secara acak dua kali sehari, tetapi masih tertarik pada mayat. Setelah 3 hari, dia akan mati. Tembakan panah kedua juga akan membunuh Wumpus.

Mengembara Wumpus: Setiap hari, jika tidak ada yang memicu Wumpus, ia memiliki peluang 25% untuk bergerak.

Para pemburu

Empat pemburu dapat memasuki gua sekaligus. Gua-gua itu gelap, sehingga para pemburu tidak bisa melihat, tetapi mereka bisa menggunakan indera mereka yang lain. Pemburu dapat mencium Wumpus di ruangan yang berdekatan, mencium mayat di kamar yang berdekatan, mendengar pemburu lain bergerak di kamar yang berdekatan, dan mendengar jika panah ditembakkan ke ruangan yang berdekatan.

Pemburu memiliki dua tindakan: Menembak atau bergerak. Seorang pemburu dapat menembakkan panah ke ruangan yang berdekatan atau kamarnya sendiri, dan bergerak dengan cara yang sama.

Gameplay

Di setiap ronde, pemburu pertama-tama akan mencatat lingkungan mereka, dan kemudian bergerak. Gerakan terjadi sebelum panah, jadi jika panah ditembakkan ke ruangan tempat pemburu keluar, pemburu akan bertahan hidup. Setelah semua gerakan pemburu telah dilakukan, panah dievaluasi. Jika satu penghuni dan anak panah berada di ruangan yang sama, penghuninya akan ditembak dan mati. Jika dua atau lebih penghuni berbagi kamar, satu akan dipukul dan mati secara acak. Catatan: Mayat adalah penghuni, sehingga mayat bisa berfungsi sebagai perisai parsial.

Setelah semua pemburu bergerak, para Wumpus akan merespons. Jika seorang pemburu telah pindah ke kamar dengan Wumpus, Wumpus akan memakannya. Jika Wumpus bergerak, ia juga akan memakan penghuni kamar baru.

Setelah 100 hari, jika para pemburu belum membunuh Wumpus, atau korban yang jatuh, mereka akan mati kelaparan di dalam gua.

Kode

Semua kode sumber dapat ditemukan di sini . Semua kiriman harus dalam Java, kecuali seseorang ingin menulis saya stdIn / stdOut adapter;)

Bot harus memperluas kelas Hunter. Untuk memberi nama Hunter Anda, tambahkan konstruktor tanpa parameter yang menetapkan bidang nama. Untuk merespons, ganti fungsi getResponse. Dalam fungsi ini, setiap belokan, Anda akan melewati array 5 boolean yang memberi tahu Anda tentang lingkungan Anda.

status 0 = "Kamu mencium wumpus"

status 1 = "Anda mendengar pemburu lain"

status 2 = "Anda mencium bau mayat"

status 3 = "Anda mendengar bunyi tanda panah"

status 4 = "Anda merasakan pemburu lain di ruangan yang sama dengan Anda"

Kelas Hunter memiliki 2 slot: nextMove dan nextDirection, yang masing-masing menggunakan enum Move dan Direction. Bergerak bisa berupa MOVE atau SHOOT, koreksi bisa KIRI, KANAN, KEMBALI, atau DI SINI. Arah konsisten, artinya kembali akan selalu mengembalikan Anda ke kamar sebelumnya, dan jika masuk dari ruangan yang sama, KIRI dan KANAN akan selalu sama. Namun, jika Anda masuk dari arah yang berbeda, KIRI dan KANAN akan membawa Anda ke tempat yang berbeda.

Jangan ragu untuk menerapkan metode Anda sendiri juga. Ingatan tetap ada sepanjang seluruh turnamen, artinya pemburu Anda hanya akan dibangun sekali. Namun, pada awal setiap putaran, metode newGame () dipanggil untuk memberi tahu pemburu Anda bahwa permainan baru telah dimulai.

Mencetak gol

Empat pemburu berkompetisi sekaligus. Jika terbunuh, kulit Wumpus bernilai 60 poin, terbagi rata di antara semua pemburu yang masih hidup. Gaya full round robin, sehingga setiap kombinasi dari 4 pemburu akan bermain bersama.

5 sampel Pemburu disertakan: 4 dengan fungsi yang sangat mendasar, dan satu yang memungkinkan input pengguna untuk dimainkan, untuk tujuan pengujian.

Jika Anda memiliki saran / permintaan, harap beri tahu saya!

Akhir sudah terlihat!

Populasi Wumpus dunia sedang diburu pada tingkat yang mengkhawatirkan. Undang-undang Protect Our Wumpuses diharapkan akan disahkan pada hari Rabu, 17 Juni. Setelah tanggal ini, tidak ada lagi pemburu yang diizinkan di dalam gua, dan pemenang akan dipilih.

Papan angka

Catatan : Maaf, ada bug dalam kode yang dapat menyebabkan Hunters tetap mati melalui beberapa game. Setelah memperbaikinya, itu tidak mengubah peringkat keseluruhan sangat banyak, tetapi sebagian besar mengubah statistik.

Skor ada, menjalankan setiap set pemburu di 1000 game masing-masing. NascarHunter dan FullCoverageHunter memimpin paket, dan meskipun penambahan AntiHunter telah memberikan Wumpus dorongan 2% untuk bertahan hidup, mereka masih gemetaran di kaki yang tersedot pada tingkat kelangsungan hidup 32% dari jenis mereka. Panah dari sesama pemburu adalah ancaman terbesar di gua.

1. NascarHunter : 16557175 (17.08)
2. FullCoverageHunter : 15195545 (15.68)
3. Trig : 14459385 (14.92)
4. Idomeneus : 13428570 (13.85)
5. Eats Shoots and Leaves : 12763945 (13.17)
6. WalkingIdiot : 12329610 (12.72)
7. NealHunter : 12287140 (12.68)
8. Unnamed : 11013720 (11.36)
9. MonsterHunter : 10686035 (11.02)
10. Pacer : 9187000 (9.48)
11. Badger : 9042570 (9.33)
12. Stay : 8721210 (9.0)
13. Emo Wumpus : 7831050 (8.08)
14. Paranoid : 7722965 (7.97)
15. Huddle : 7465420 (7.7)
16. ElmerFudd : 7245995 (7.47)
17. Laomedon : 6963845 (7.18)
18. Pacifist : 6944960 (7.16)
19. ScaredyCat : 6937370 (7.15)
20. Wumpus : 114170 (0.11)



Total rounds: 4845000
Humans killed by arrows: 5289674 (1.09)
Humans dead by starvation: 1046024 (0.21)
Humans killed by wumpus: 1887634 (0.38)
Wumpus victories: 1563372 (0.32)

NascarHunter

Tidak banyak logika untuk itu. Aturannya sederhana: belok kiri, bumi hangus, ulangi. Dan, hei, dia mungkin beruntung!

Sunting 8 Juni:

Ditambahkan dalam logika tambahan ke Nascar untuk memperhitungkan kedekatan dengan Wumpus relatif terhadap langkah terakhirnya. Anggap saja sebagai pemberhentian, untuk tetap dalam tema. Jika merasakan Wumpus setelah menembak jatuh lorong, maka itu pasti telah tiba di salah satu dari dua kamar yang berdekatan, karena itu akan mati karena tembakan yang diambil oleh pemburu. Ini secara efektif memberikan Wumpus 2 belokan untuk hidup jika tidak bergerak lagi, atau Nascar 1 belok untuk hidup jika dia berdiri di atas mayat. Juga menyumbang opsi ketiga jika giliran pertama, tetapi hanya sekali. Saya akan port ke FCH akhirnya, sibuk sibuk.

package Hunters;

import Mechanics.*;

public class NascarHunter extends Hunter {

    private int state;
    private boolean shootHall;
    private boolean newGame;

    public NascarHunter(){

        name = "NascarHunter";
        state = 0;
        shootHall = true;
        newGame = true;

    }

    public void newGame(){

        state = 0;
        newGame = true;

    }

    public void getResponse(boolean[] status){

        // Wumpus about - stand and deliver
        if( status[0] ){

            nextMove = Move.SHOOT;

            switch( state ){

            case 0: // Must be in either Right or Back
                if(newGame){

                    // try Left if this is the first turn, just in case
                    nextDirection = Direction.LEFT;
                    newGame = false;

                }
                else if(shootHall) nextDirection = Direction.BACK;
                else               nextDirection = Direction.RIGHT;
                shootHall = !shootHall;
                break;
            case 2: // Must be in either Left or Back
                if(newGame){

                    // try Right if this is the first turn, just in case
                    nextDirection = Direction.RIGHT;
                    newGame = false;

                }
                else if(shootHall) nextDirection = Direction.BACK;
                else               nextDirection = Direction.LEFT;
                shootHall = !shootHall;
                break;
            default: // Must be in either Left or Right
                if(newGame){

                    // try Back if this is the first turn, just in case
                    nextDirection = Direction.BACK;
                    newGame = false;

                }
                else if(shootHall) nextDirection = Direction.RIGHT;
                else               nextDirection = Direction.LEFT;
                shootHall = !shootHall;
                break;

            }

        }else{

            // disregard state, shove out and light 'em up!
            switch( state ){

            case 0: // move out
                nextMove = Move.MOVE;
                nextDirection = Direction.LEFT;
                state++;
                break;
            case 1: // shoot right
                nextMove = Move.SHOOT;
                nextDirection = Direction.RIGHT;
                state++;
                break;
            case 2: // shoot behind
                nextMove = Move.SHOOT;
                nextDirection = Direction.BACK;
                state++;
                break;
            case 3: // shoot left
                nextMove = Move.SHOOT;
                nextDirection = Direction.LEFT;
                state = 0;
                break;

            }

        }

    }

}

FullCoverageHunter

Mengikuti kredo yang sama dari NascarHunter, tetapi berganti jalurnya, yang dijamin untuk membentuk loop 10 kamar unik panjang. Karena setiap kamar unik, dan kami menembaki setiap arah per kamar, semua kamar dipecat. Ini berlaku untuk setiap ruang awal (didalilkan oleh teman saya Neal, terima kasih Neal!). Dodecahedra sangat keren seperti itu!

Saya ingin menunjukkan bahwa ini berbeda dari teman kami, MonsterHunter, karena dia tidak mencoba tipu daya atau "taktik" nyata. Kekuatan dari hal ini adalah kenyataan bahwa setiap ruangan akan ditembakkan, lagi: solusi brute force. Ini memiliki kekuatan teoretis di NascarHunter, karena Nascar hanya akan mencapai 10 dari 20 kamar, yang hanya mencakup setengah area.

Sunting 11 Juni:

Ditambahkan dalam pola logika deteksi Wumpus dari NascarHunter. Harus secara objektif meningkatkan skor.

package Hunters;

import Mechanics.*;

public class FullCoverageHunter extends Hunter {

    private int state;
    private boolean headLeft;
    private boolean shootHall;
    private boolean newGame;

    public FullCoverageHunter(){

        name = "FullCoverageHunter";
        state = 0;
        headLeft = false;
        shootHall = true;

    }

    public void newGame() {
        state = 0;
        headLeft = false;
        newGame = true;
    }


    public void getResponse(boolean[] status){

        // Wumpus about - stand and deliver
        if( status[0] ){

            nextMove = Move.SHOOT;

            switch( state ){

            case 0: // Must be in either Right or Back
                if(newGame){

                    // try Left if this is the first turn, just in case
                    nextDirection = Direction.LEFT;
                    newGame = false;

                }
                else if(shootHall) nextDirection = Direction.BACK;
                else               nextDirection = Direction.RIGHT;
                shootHall = !shootHall;
                break;
            case 2: // Must be in either Left or Back
                if(newGame){

                    // try Right if this is the first turn, just in case
                    nextDirection = Direction.RIGHT;
                    newGame = false;

                }
                else if(shootHall) nextDirection = Direction.BACK;
                else               nextDirection = Direction.LEFT;
                shootHall = !shootHall;
                break;
            default: // Must be in either Left or Right
                if(newGame){

                    // try Back if this is the first turn, just in case
                    nextDirection = Direction.BACK;
                    newGame = false;

                }
                else if(shootHall) nextDirection = Direction.RIGHT;
                else               nextDirection = Direction.LEFT;
                shootHall = !shootHall;
                break;

            }

        }else{

            // disregard state, shove out (in an alternating fashion!) and light 'em up!
            switch( state ){

            case 0: // move out, change alternation state
                nextMove = Move.MOVE;
                if(headLeft) nextDirection = Direction.LEFT;
                else         nextDirection = Direction.RIGHT;
                state++;
                headLeft = !headLeft;
                break;
            case 1: // shoot into non-exit path
                nextMove = Move.SHOOT;
                if(headLeft) nextDirection = Direction.RIGHT;
                else         nextDirection = Direction.LEFT;
                state++;
                break;
            case 2: // shoot behind
                nextMove = Move.SHOOT;
                nextDirection = Direction.BACK;
                state++;
                break;
            default: // shoot into next room,
                nextMove = Move.SHOOT;
                if(headLeft) nextDirection = Direction.LEFT;
                else         nextDirection = Direction.RIGHT;
                state = 0;
                break;

            }

        }

    }

}

Beri tahu saya jika ada kesalahan, paket tidak cocok dengan IDE saya :(

Luak

Dia tidak suka pengunjung.

package Hunters;

import Mechanics.*;

public class Badger extends Hunter {

    public Badger(){
        name = "Badger";
    }

    @Override
    public void getResponse(boolean[] status){
        nextMove = Move.SHOOT;
        nextDirection = Direction.values()[((int) (Math.random() * 3))];
    }
}

Elmer Fudd

"Shhh. Bersikaplah sangat sunyi, aku berburu wumpus"

Elmer terpaku pada mangsa dan mengabaikan segalanya kecuali mayat dan Wumpus. Dia mencoba menemukan mayat kemudian mundur dan mulai menembak. Jika dia mencium bau Wumpus, dia akan mundur dan jika dia masih menciumnya dia akan menembak.

Saya minta maaf kepada semua programmer java, ini mungkin sangat jelek, penuh dengan kesalahan sintaks dan saya mungkin telah mengacaukan logika saya.

package Hunters;

import Mechanics.*;

public class ElmerFudd extends Hunter {

    private state int;
    private previousDir int;

    public ElmerFudd(){
        name = "ElmerFudd";
    }

    public void newGame() {
        state=0;
        previousDir = Direction.LEFT;
    }

    public void getResponse(boolean[] status){

        nextMove = Move.MOVE;
        switch (previousDir) {
            case Direction.LEFT:
                nextDirection = Direction.RIGHT;
                break;
            case Direction.RIGHT:
                nextDirection = Direction.LEFT;
                break;
        }   

        if(status[2]&&state==0) {
            state = 1;
            return;
        }

        if(state==1){
            if(status[2]){
                state=2;
            };
            nextDirection = Direction.BACK;
            return;
        }

        if(state==2){
            nextMove = Move.SHOOT;
            nextDirection = Direction.BACK;
            return;
        }

        if(state==3&&status[0])
            nextMove = Move.SHOOT;
            nextDirection = Direction.BACK;
            return;
        }

        if(state==3) {
            state = 0;
        }

        if(status[0]){
            state=3;
            nextDirection = Direction.BACK;
        }

    }
}

Pasif

Pria ini secara moral menentang segala jenis olahraga darah dan bertanya-tanya bagaimana dia muncul dalam situasi ini sama sekali. Dia akan lari dari segala jenis kontak dan tidak pernah mengambil gambar.

package Hunters;

import Mechanics.*;

public class Pacifist extends Hunter {


    public Pacifist(){
        name = "Pacifist";
    }

    public void getResponse(boolean[] status){
        nextMove = Move.MOVE;
        if(status[0]||status[1]||status[2]||status[3]||status[4]){
            nextDirection = Direction.values()[((int) (Math.random() * 3))];
            return;
        }
        nextDirection = Direction.HERE;
    }
}

Pemburu monster

Kami sedang berburu monster dan kami berusia 4 tahun ... Ini mengingatkan saya pada game favorit saya! Pemburu ini akan berjalan di sebagian besar peta dengan bergerak ke kiri-kanan secara bergantian, dan jika Wumpus dekat, ia akan memancingnya dengan mundur untuk dapat menentukan dengan tepat apakah itu.

Saya bisa menyingkirkan lastDirection, tapi saya tetap menggunakan semantik dan mudah dibaca :). Sebenarnya, itu mati cukup banyak, tetapi controller sering menempatkan 2/3 pemburu di ruangan yang sama di awal, dan sering dengan Wumpus dekat (bisa juga di ruangan yang sama) ... jadi mati insta ^^ '.

package Hunters;

import Mechanics.*;

public class MonsterHunter extends Hunter 
{
    private Direction lastDirection=Direction.HERE;
    private boolean[] lastStatus=new boolean[5];
    private int   shooted=0;
    private boolean   walkMode=true;
    private int         turnStayed=0;

    public MonsterHunter(){
        super();
        name = "MonsterHunter";
    }

    @Override
    public void getResponse(boolean[] status)
    {
        if(status[0])
        {
            if(!lastStatus[0]||shooted==0)
            {
                nextDirection=(walkMode)?Direction.RIGHT:Direction.LEFT;;
                nextMove=Move.SHOOT;
            }
            else if(lastStatus[0]&&shooted==1)
            {
                nextDirection=Direction.BACK;
                nextMove=Move.MOVE;
            }
            else
            {
                nextDirection=Direction.BACK;
                nextMove=Move.SHOOT;
            }
        }

        else if(status[2])
        {
            nextMove=Move.MOVE;
            if(Math.random()*6<turnStayed)
            {
                nextDirection=Direction.HERE;
                turnStayed++;
            }
            else
                nextDirection=(walkMode)?Direction.RIGHT:Direction.LEFT;
        }
        else
        {
            nextMove=(!status[1]&&Math.random()<0.5)?Move.MOVE:Move.SHOOT;
            nextDirection=(walkMode)?Direction.RIGHT:Direction.LEFT;
        }

        if(nextMove==Move.MOVE)
        {
            if(shooted>0)
                walkMode=walkMode^(shooted>0);
            if(lastStatus[0]&&shooted==1)
                shooted++;
            else
                shooted=0;
            lastDirection=nextDirection;
        }
        else
            shooted++;
        for(int i=0;i<status.length;i++)
            lastStatus[i]=status[i];
    }
}

PacingHunter

Bolak-balik, antara kamar. jika berbau Wumpus atau mendengar pemain itu menembak ke kiri lalu ke kanan. jika seorang Wumpus berada di sampingnya untuk memulai maka dia akan menembak kamar yang akan dia pindahkan.

package Hunters;

import Mechanics.Direction;
import Mechanics.Hunter;
import Mechanics.Move;

public class PacingHunter extends Hunter {

    int state = 0;//Pacing
    int turn = 0;

    public PacingHunter() {
        name = "Pacer";
    }

    public void newGame() {
        turn =  0;
        state = 0;
    }

    public void getResponse(boolean[] status){
        turn += 1;
        if(state == 0 && status[0] && turn == 1){
            nextMove = Move.SHOOT;
            nextDirection = Direction.BACK;
            return;
        }
        if(state == 0 &&(status[0] || status[1])){
            nextMove = Move.SHOOT;
            nextDirection = Direction.LEFT;
            state = 1;
            return;
        }
        if(state == 1 && (status[0] || status[1])){
            nextMove = Move.SHOOT;
            nextDirection = Direction.RIGHT;
            state = 0;
            return;
        }
        if(status[1] && state == 0){
            nextMove = Move.SHOOT;
            nextDirection = Direction.BACK;
            state = 0;
            return;

    }
    nextMove = Move.MOVE;
    nextDirection = Direction.BACK;
}

}

ScaredyCat

ScaredyCat takut akan segalanya. Jika mencium wumpus atau mayat atau mendengar panah atau pemburu, itu berjalan ke arah acak. Kalau tidak, itu hanya terus menembak panah ke arah acak.

package Hunters;

import Mechanics.*;

public class ScaredyCat extends Hunter {

    public ScaredyCat(){
        name = "ScaredyCat";
    }

    @Override
    public void getResponse(boolean[] status){

        for(int i=0; i<status.length; i++)
            if(status[i])
            {
                nextMove = Move.MOVE;
                nextDirection = Direction.values()[((int) (Math.random() * 3))];
                return;
            }

        nextMove = Move.SHOOT;
        nextDirection = Direction.values()[((int) (Math.random() * 3))];
    }
}

Makan Tunas dan Daun

Tidak seperti Panda dari ketenaran buku tata bahasa, pemburu ini tidak benar-benar makan apa pun, tapi kami menembak jika Wumpus sudah dekat atau kami meninggalkan jejak yang semoga membuat kami tidak berjalan berputar-putar.

package Hunters;

import java.util.Random;

import Mechanics.Hunter;
import Mechanics.Move;
import Mechanics.Direction;
import Mechanics.Room;

public class EatsShootsAndLeaves extends Hunter {

    private static Direction [] allDirections = { Direction.LEFT, Direction.RIGHT, Direction.BACK, Direction.HERE };
    private static Direction [] movePath = { Direction.LEFT, Direction.RIGHT, Direction.LEFT, Direction.BACK, Direction.RIGHT, Direction.BACK };

    private static int numGames = 0;
    private static int totalLife = 0;

    private static class RoomInfo  {

        public boolean hasWumpus = false;
        public boolean hasLocalHunter = false;
        public boolean hasNeighborHunter = false;
        public boolean hasCorpse = false;
        public boolean hasArrow = false;
        public RoomInfo(Room r) {
            boolean [] status = r.getInfo();
            hasWumpus = status[0];
            hasNeighborHunter = status[1];
            hasCorpse = status[2];
            hasArrow = status[3];
            hasLocalHunter = status[4];
        }

        public String toString() {
            return new String("Status: "
                              + (hasWumpus ? "Wumpus " : "")
                              + (hasNeighborHunter ? "Close Hunter " : "")
                              + (hasCorpse ? "Corpse " : "")
                              + (hasArrow ? "Arrow " : "")
                              + (hasLocalHunter ? "Local Hunter " : ""));
        }
    }

    int turnsAlive = 0;
    int shots = 0, moves = 0;

    public EatsShootsAndLeaves(){
        name = "Eats Shoots and Leaves";
    }

    public void newGame() {

        totalLife += turnsAlive;
        numGames++;

        turnsAlive = shots = moves = 0;
    }

    public void getResponse(boolean[] status){

        turnsAlive++;

        RoomInfo info = new RoomInfo(this.getRoom());
        if (info.hasNeighborHunter || info.hasWumpus) {
            nextMove = Move.SHOOT;
            nextDirection = allDirections[shots++ % 3];
        } else {
            nextMove = Move.MOVE;
            nextDirection = movePath[moves++ % movePath.length];
        }
    }
}

Idomeneus

Idomeneus cukup sederhana - jika Wumpus atau pemburu lain ada di dekatnya, ia menembakkan sarrow ke mana-mana dan berdoa agar dewi berburu ada di sisinya. Jika dia dekat mayat dia berbaring menunggu Wumpus. Dia tidak suka pemburu lain dan akan melarikan diri jika mereka mulai menembakkan panah di dekatnya, atau jika mereka berada di ruangan yang sama dengannya. Akhirnya jika dia merasa bosan dia secara acak mondar-mandir di koridor abadi.

package Hunters;
import Mechanics.Direction;
import Mechanics.Hunter;
import Mechanics.Move;
import java.util.Random;



public class Idomeneus extends Hunter
{
    int direction;
    Random r;
    public Idomeneus()
    {
        super();
        name = "Idomeneus";
        direction = 0;
        r = new Random();
    }

    @Override
    public void getResponse(boolean[] status){
        boolean wumpusNear = status[0];
        boolean hunterNear = status[1];
        boolean corpseNear = status[2];
        boolean arrowNear = status[3];
        boolean hunterHere = status[4];
        direction++;

        if(wumpusNear)
        {
            //ATTACK!!!
            nextMove = Move.SHOOT;
            nextDirection = Direction.values()[direction%3];
        }
        else if(hunterHere || arrowNear)
        {
            //Run away
            nextMove = Move.MOVE;
            nextDirection = Direction.values()[r.nextInt(3)];
        }
        else if(hunterNear)
        {
            //ATTACK!!!
            nextMove = Move.SHOOT;
            nextDirection = Direction.values()[direction%3];
        }
        else if(corpseNear)
        {
            //Stay and wait...
            nextMove = Move.MOVE;
            nextDirection = Direction.HERE;
        }
        else
        {
            //wander around
            nextMove = Move.MOVE;
            nextDirection = Direction.values()[r.nextInt(3)];
        }

    }

    public void newGame(){}



}

Emo Wumpus (Hunter)

Emo Wumpuses (terkait dengan Emo Wolves yang terkadang menggunakan senjata dan menerbangkan pesawat ) membenci segalanya (terutama Jawa). Mereka tidak membuat perbedaan antara Pemburu dan Wumpus, dan mencoba untuk menembak mereka semua sama. Mereka juga membenci pembalap Nascar, dan akan selalu menembak dengan benar. Jika tidak ada yang ada di sekitar untuk menembak, mereka bergerak ke kanan, tetapi hanya akan melakukan ini tiga belas kali berturut-turut sebelum mereka semakin tertekan karena sendirian dan mencoba menembak diri mereka sendiri (tiga belas adalah angka sial). Pada giliran 99, jika mereka masih hidup, mereka akan berusaha menembak diri mereka sendiri karena kelaparan adalah cara mati yang lumpuh.

Wumpus lebih besar (dan lebih berat) daripada Wolves, tetapi yang ini masih kelaparan sampai 424 byte (berbeda dengan NascarHunter yang besar dan berat 2,72 kb).

package Hunters;import Mechanics.*;public class EmoWumpus extends Hunter{private int c, t;public EmoWumpus(){name="Emo Wumpus";this.c=0;this.t=0;}public void newGame(){this.c=0;this.t=0;}public void getResponse(boolean[] status){nextMove=Move.SHOOT;if(c<13 && t<100){if(status[0]||status[1]){nextDirection=Direction.RIGHT;}else{nextMove=Move.MOVE;nextDirection=Direction.RIGHT;c++;}}else{nextDirection=Direction.HERE;}t++;}}

Mengapa tidak bunuh diri saja? Emo Wumpus percaya bahwa satu tindakan kebaikan yang dapat dilakukan adalah mengakhiri penderitaan orang lain sebelum bunuh diri. Karena itu, mereka akan membunuh semua yang mereka bisa sebelum tiba waktunya untuk mati.

Wumpus? (Anti-Hunter)

Um, apa yang dilakukan Wumpus pada daftar pemburu? Pria ini menjadi sangat kesal karena manusia membunuh kerabatnya, jadi dia memutuskan untuk berpakaian sebagai salah satu dari mereka dan bergabung dalam perburuan. Tujuan utamanya adalah membunuh pemburu. Dia mencoba bersembunyi di dekat mayat, yang akan memberinya kesempatan melindungi dari pemburu. Jika tidak ada pemburu di dekatnya, ia akan bergerak ke arah sampai pemburu terdeteksi, dalam hal ini ia akan mencoba membunuh mereka sebelum bergerak ke arah lain.

Sayangnya, sebagian besar Wumpus bodoh, dan masih akan mencoba membunuhnya. Apapun itu, ia menganggap pengorbanannya diperlukan untuk kebaikan Wumpus di mana pun.

package Hunters;

import Mechanics.*;

public class AntiHunter extends Hunter {

private boolean left;

public AntiHunter() {
    name = "Wumpus";
    this.left = true;
}

public void newGame() {
    this.left = true;
}

public void getResponse(boolean[] status) {
    if(status[4]) {
        nextMove = Move.SHOOT;
        nextDirection = Direction.HERE;
    }
    else if(status[2] || status[1]) {
        nextMove = Move.SHOOT;
        if(this.left) {
            this.left = false;
            nextDirection = Direction.LEFT;
        }
        else {
            this.left = true;
            nextDirection = Direction.RIGHT;
        }
    }
    else {
        nextMove = Move.MOVE;
        if(this.left)
            nextDirection = Direction.LEFT;
        else
            nextDirection = Direction.RIGHT;
    }
}

}

Laomedon

Laomedon mengembara tanpa tujuan mencoba menemukan mayat. Begitu dia menemukan satu dan mencari tahu di mana dia tinggal di tempat yang sama di sebelah mayat. Ketika dia mencium Wumpus, dia menembakkan panah ke kamar Mayat.

package Hunters;
import Mechanics.Direction;
import Mechanics.Hunter;
import Mechanics.Move;
public class Laomedon extends Hunter {
    private enum status
    {
        START,
        SEARCHED_LEFT,
        SEARCHED_RIGHT,
        INITIAL_CORPSE_LEFT,
        INITIAL_CORPSE_RIGHT,
        SMELT_CORPSE,
        CORPSE_BEHIND,
        CORPSE_LEFT
    }

    status myState;
    public Laomedon() {
        this.name = "Laomedon";
    }
    @Override
    public void getResponse(boolean[] status) {
        boolean wumpusNear = status[0];
        boolean hunterNear = status[1];
        boolean corpseNear = status[2];
        boolean arrowNear = status[3];
        boolean hunterHere = status[4];
        switch (myState) {
        case CORPSE_BEHIND:
            if(wumpusNear)
            {
                this.nextDirection = Direction.BACK;
                this.nextMove = Move.SHOOT;
            }
            else
            {
                this.nextDirection = Direction.HERE;
                this.nextMove = Move.MOVE;
            }
            break;
        case CORPSE_LEFT:
            if(wumpusNear)
            {
                this.nextDirection = Direction.LEFT;
                this.nextMove = Move.SHOOT;
            }
            else
            {
                this.nextDirection = Direction.HERE;
                this.nextMove = Move.MOVE;
            }
            break;
        case INITIAL_CORPSE_LEFT:
            if(corpseNear)
            {
                this.nextDirection = Direction.RIGHT;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.INITIAL_CORPSE_RIGHT;
            }
            else
            {
                this.nextDirection = Direction.BACK;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.SEARCHED_LEFT;
            }
            break;
        case INITIAL_CORPSE_RIGHT:
            if(corpseNear)
            {
                this.nextDirection = Direction.LEFT;
                this.nextMove = Move.MOVE;
                myState = Laomedon.status.INITIAL_CORPSE_LEFT;
            }
            else
            {
                this.nextDirection = Direction.BACK;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.SEARCHED_LEFT;
            }
            break;
        case SEARCHED_LEFT:
            if(corpseNear)
            {
                this.nextDirection = Direction.LEFT;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.SMELT_CORPSE;
            }
            else
            {
                this.nextDirection = Direction.RIGHT;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.SEARCHED_RIGHT;
            }
            break;
        case SEARCHED_RIGHT:
            if(corpseNear)
            {
                this.nextDirection = Direction.LEFT;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.SMELT_CORPSE;
            }
            else
            {
                this.nextDirection = Direction.LEFT;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.SEARCHED_LEFT;
            }
            break;
        case SMELT_CORPSE:
            if(corpseNear)
            {
                this.nextDirection = Direction.BACK;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.CORPSE_BEHIND;
            }
            else
            {
                this.nextDirection = Direction.BACK;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.CORPSE_LEFT;
            }
            break;
        case START:
            if(corpseNear)
            {
                this.nextDirection = Direction.LEFT;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.INITIAL_CORPSE_LEFT;
            }
            else
            {
                this.nextDirection = Direction.LEFT;
                this.nextMove = Move.MOVE;
                this.myState = Laomedon.status.SEARCHED_LEFT;
            }
            break;
        }
    }

    @Override
    public void newGame() {

        super.newGame();
        myState = status.START;
    }
}

Sial baginya, para pemburu lainnya tidak menghargai keahliannya dan mereka sepertinya menembaknya banyak ...

NealHunter

Setelah membicarakan hal ini dengan teman saya DoctorHeckle, saya pikir akan menyenangkan untuk mencobanya sendiri. Menggunakan ide untuk berganti-ganti kiri dan kanan untuk menutupi sebagian besar wilayah, dan kemudian memutuskan untuk menambahkan sedikit respons ke negara bagian, tetapi hanya 0 dan 1 - apakah Wumpus atau pemburu ada di dekatnya. Tidak berkinerja sebaik NascarHunter, yang mengejutkan saya pada awalnya. Namun setelah beberapa pemikiran, saya menyadari bahwa menembakkan panah ke arah yang acak (seperti ini) setelah mendengar seorang pemburu / mencium seekor Wumpus tidak akan melakukan apa pun jika mereka bergerak pada belokan itu, karena panah ditembakkan ke ruangan, tetapi gerakan dilakukan sebelum membunuh mereka. Tidak seefektif yang saya kira ... masih berkinerja baik!

package Hunters;

import Mechanics.*;
import java.util.Random;

public class NealHunter extends Hunter {

    private boolean goLeft;

    public NealHunter(){
        name = "NealHunter";
        goLeft = false;
    }

    public void newGame() {
        goLeft = false;
    }

    public void getResponse(boolean[] status){

        Random rand = new Random();

        if(status[0] || status[1]){
            nextMove = Move.SHOOT;

            switch ( rand.nextInt(3) ){
                case 0:
                    nextDirection = Direction.LEFT;
                    break;
                case 1:
                    nextDirection = Direction.BACK;
                    break;
                case 2:
                    nextDirection = Direction.RIGHT;
                    break;
            }
        } else {
            nextMove = Move.MOVE;
            if (goLeft) {
                nextDirection = Direction.LEFT;
            } else {
                nextDirection = Direction.RIGHT;
            }

            goLeft = !goLeft;
        }
    }
}

WalkingIdiot

Yang ini berjalan sampai dia menemukan wumpus. Lalu, dia menembak dengan benar. Jika wumpus masih ada, itu harus di sebelah kiri, jadi tembak sekali lagi. Dalam perjalanan, ia tidak peduli dengan pemburu atau mayat lain, karena itu namanya.

package Hunters;

import Mechanics.*;

public class WalkingIdiot extends Hunter {
    private boolean wumpusNear = false;

    @Override
    public void newGame() {
        wumpusNear = false;
    }

    public WalkingIdiot(){
        name = "WalkingIdiot";
    }

    @Override
    public void getResponse(boolean[] status){
        boolean wumpusWasNear = wumpusNear;
        wumpusNear = status[0];
        if (status[0]) {
            nextMove = Move.SHOOT;
            if (wumpusWasNear) {
                nextDirection = Direction.LEFT;
            } else {
                nextDirection = Direction.RIGHT;
            }
            return;
        }
        nextMove = Move.MOVE;
        nextDirection = Math.random() < 0.5 ? Direction.LEFT : Direction.RIGHT;
    }
}

Tinggal

Tetap tidak suka berjalan. Itu hanya menembak dan mengingat jika dia menembak seorang pemburu.

package Hunters;

import Mechanics.*;

public class Stay extends Hunter {
    private Direction lastShot = Direction.LEFT;
    private Direction corpse = null;
    private boolean hunterNear = false;

    public Stay(){
        name = "Stay";
    }

    @Override
    public void newGame() {
        corpse = null;
        hunterNear = false;
        lastShot = Direction.LEFT;
    }

    @Override
    public void getResponse(boolean[] status){
        nextMove = Move.SHOOT;//always
        boolean hunterWasNear = hunterNear;
        hunterNear = status[1];

        if (hunterWasNear && status[2] && !status[1]) {
            corpse = lastShot;
        }

        if (status[0]) {
            if (corpse != null) {
                nextDirection = corpse;
                return;
            }
        }
        if ((status[1] && !status[4]) || status[0]) {
            switch (lastShot) {
                case LEFT: lastShot = nextDirection = Direction.RIGHT; break;
                case RIGHT: lastShot = nextDirection = Direction.BACK; break;
                case BACK: lastShot = nextDirection = Direction.LEFT; break;
            }
            return;
        }

        //default
        lastShot = nextDirection = Direction.LEFT;
    }
}