コンプリート

Wumpusシーズンは終了し、多くの悪質なWumpusと勇敢なハンターの生活が終わりました。some病で不道徳で実に愚かなハンターもいます。しかし、その日の終わりに、ヘックル博士のNascarHunterは、略奪品と栄光を手に入れました。私たちはあなたに敬意を表します、ああ勇敢な...ドライバー？

Wumpusesはオープンシーズンで、世界中のハンターがWumpus Cavesに集まり、貴重なWumpus Peltを手に入れようとしています。

ゲーム

いくつかのバリエーションを持つ、古典的なハンプザワンパスゲームに基づいています。

地図

十二面体。20の部屋があり、それぞれが他の3つの部屋に接続されており、基本的に3つのリングが間に橋を架けています。

ザ・ワンプス

Wumpusは神秘的な獣です。それがどのように見えるかは確かではありませんが、すべてが凶暴であることに同意します。Wumpusは洞窟に住んでいて、死んだものを食べるのが好きです。Wumpusの隣の洞窟に死体がある場合、彼はそこに移動してそれを食べます。Wumpusがたまたまハンターを含む洞窟に移動した場合、Wumpusはハンターを殺して食べます。Wumpusが彼の近くに矢印を聞くと、彼はパニックしてランダムな部屋に走ります。

オプションの特性：これらは現在、ゲームをより面白くするために含まれていますが、あまりにも多くのランダム性を追加する場合、人気のリクエストで削除できます。

怒りに満ちた怒り：怒りに満ちた怒りは、3日間、20％の生存と暴れを持っています。暴れ回ると、彼は1日に2回ランダムに動きますが、それでも死体に引き付けられます。3日後、彼は死ぬでしょう。2回目の矢の射撃もWumpusを殺します。

さまようワンプス：毎日、ワンプスを誘発するものが他にない場合、25％の確率で移動します。

ハンターたち

4人のハンターが一度に洞窟に入ることができます。洞窟は暗いため、ハンターは見ることができませんが、他の感覚を使用できます。ハンターは、隣接する部屋でWumpusの匂いを嗅ぎ、隣接する部屋で死体の匂いを嗅ぎ、隣接する部屋で動いている他のハンターの音を聞き、隣接する部屋に矢が放たれるのを聞くことができます。

ハンターには2つのアクションがあります。撮影または移動です。ハンターは矢を隣の部屋や自分の部屋に向けて発射し、同様に移動できます。

ゲームプレイ

各ラウンドでは、ハンターはまず自分の周囲に注意を払い、次に1動きます。移動は矢印の前に発生するため、ハンターが移動する部屋に矢印が放たれた場合、ハンターは生き残ります。すべてのハンターの移動が行われた後、矢印が評価されます。1人の居住者と矢が同じ部屋にいる場合、居住者は撃たれて死亡します。2人以上の居住者が部屋を共有している場合、1人がランダムにヒットして死亡します。注：死体は居住者であるため、死体は部分的なシールドとして機能する場合があります。

すべてのハンターが移動した後、Wumpusが応答します。ハンターがWumpusと一緒に部屋に移動した場合、Wumpusは彼/彼女を食べます。Wumpusが移動すると、Wumpusは新しい部屋の居住者も食べます。

100日後、ハンターがWumpusを殺さなかった場合、またはfall落した犠牲者がいない場合、洞窟内で飢starで死にます。

コード

すべてのソースコードは、ここにあります。誰かが私にstdIn / stdOutアダプタを書きたくない限り、すべての提出はJavaで行われるべきです;）

ボットはHunterクラスを拡張する必要があります。Hunterに名前を付けるには、名前フィールドを設定するパラメーターなしでコンストラクターを追加します。応答するには、getResponse関数をオーバーライドします。この関数では、毎ターン、周囲の状況を知らせる5つのブール値の配列が渡されます。

ステータス0 =「おかしな匂いがする」

ステータス1 =「別のハンターが聞こえます」

ステータス2 =「死体の匂いがする」

ステータス3 =「矢印のカチャカチャという音が聞こえます」

ステータス4 =「同じ部屋で別のハンターを感じている」

Hunterクラスには2つのスロットがあります：nextMoveとnextDirection、それぞれ列挙型MoveとDirectionを使用します。移動はMOVEまたはSHOOTのいずれかであり、方向はLEFT、RIGHT、BACK、またはHEREです。方向は一貫しています。つまり、戻ると常に前の部屋に戻り、同じ部屋から入る場合、左と右は常に同じになります。ただし、別の方向から入る場合は、LEFTおよびRIGHTで別の場所に移動します。

独自のメソッドも自由に実装してください。記憶はトーナメント全体を通して持続します。つまり、ハンターは一度だけ構築されます。ただし、各ラウンドの開始時に、新しいゲームが開始されたことをハンターに知らせるためにnewGame（）メソッドが呼び出されます。

得点

一度に4人のハンターが競います。殺された場合、Wumpusの毛皮は60ポイントの価値があり、生存しているすべてのハンターに均等に分割されます。フルラウンドロビンスタイルなので、4人のハンターの各組み合わせが一緒にプレイします。

5つのサンプルハンターが含まれています。4つは非常に基本的な機能で、もう1つはテストのためにユーザー入力を再生できます。

提案/リクエストがあれば、教えてください！

終わりが見えます！

世界のWumpusの人口は驚くべき速さで狩られています。6月17日水曜日にWumpuses保護法が可決されます。この日を過ぎると、洞窟でこれ以上ハンターは許可されなくなり、勝者が選ばれます。

スコアボード

注：謝罪、コードにバグがあり、複数のゲームでハンターが死んでいる可能性がありました。それを修正したので、全体的なランキングはあまり変わりませんが、統計は大きく変わります。

スコアが入り、ハンターの各セットをそれぞれ1000ゲームで実行します。NascarHunterとFullCoverageHunterがパックをリードし、AntiHunterの追加によりWumpusesの生存率が2％向上しましたが、彼らは今でも32％の生存率で吸盤足で揺れています。仲間のハンターからの矢は、これまで以上に洞窟の最大の脅威です。

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)

ナスカハンター

あまりロジックはありません。そのルールは単純です：左に曲がり、焦げた地球を繰り返します。そして、ちょっと、彼は幸運になるかもしれません！

6月8日編集：

Naumpに追加のロジックを追加して、Wumpusの最後の動きに対する隣接関係を説明します。テーマにとどまるために、それをピットストップと考えてください。廊下を撃った後、それがハンプを感知した場合、ハンターがちょうど撮ったショットで死んだので、それは他の2つの隣接する部屋の1つに到着したに違いありません。Wumpus 2が再び動いていない場合、Wumpus 2が生きているか、死体の上に立っている場合はNascar 1が生きているかのいずれかを効果的に与えます。また、最初のターンの場合は3回目のオプションですが、1回だけです。最終的にはFCHに移植します。

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

NascarHunterの同じ信条に従いますが、彼のパスを交互にします。これにより、10個のユニークな部屋のループが形成されます。すべての部屋はユニークであり、部屋ごとにあらゆる方向に発砲するため、すべての部屋が発砲されます。これはすべてのスターティングルームに当てはまります（私の友人のNealが仮定、Nealに感謝！）。十二面体はそのようにかなりクールです！

私は、これが友人であるMonsterHunterとは異なることを指摘したいと思います。彼は、トリックや実際の「戦術」を試みていないからです。これの強みは、すべての部屋が解雇されるという事実であり、それはブルートフォースソリューションです。NascarHunterには理論上の優位性があります。なぜなら、Nascarは20室のうち10室しかヒットせず、エリアの半分しかカバーしていないからです。

6月11日編集：

NascarHunterのWumpus検出ロジックパターンに追加されました。客観的にスコアを改善する必要があります。

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;

            }

        }

    }

}

エラーがあるかどうかを教えてください、私のIDEでパッケージがうまく動作しませんでした:(

狸

彼は訪問者が好きではありません。

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

エルマー・ファッド

「シッ。静かで、うるさくて、私はおびただしい狩りをしている」

エルマーは獲物に執着し、死体とWumpus以外のすべてを無視します。彼は死体を見つけようとし、後退して射撃を開始します。彼がWumpusの匂いを嗅いでいる場合、彼は立ち去り、それでも彼の匂いがする場合、彼は撃ちます。

すべてのJavaプログラマに謝罪します。これはおそらく非常に見苦しく、構文エラーでいっぱいであり、おそらくロジックを台無しにしてしまいました。

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

    }
}

平和主義者

この男は、あらゆる種類の血液スポーツに道徳的に反対しており、この状況でどのように現れたのか疑問に思っています。彼はあらゆる種類の接触から逃げ出し、決して撃たない。

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

モンスターハンター

私たちはモンスターを狩っていて、4歳です...それは私のお気に入りのゲームを思い出させます！このハンターは、左右に交互に移動してマップの大部分を歩きます。Wumpusが近くにある場合、後方に移動して正確に判断できるように誘います。

lastDirectionを取り除くことができますが、セマンティクスと読みやすさのために維持します:)。実際、それはかなり多く死にますが、コントローラーはしばしば開始時に同じ部屋に2/3のハンターを置き、しばしば同じ場所にWumpusを置いています（同じ部屋にいることもあります）...

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

部屋の間を行き来します。Wumpusの匂いがするか、プレイヤーの声が聞こえたら、左から右に撃ちます。Wumpusが最初に彼の隣にいる場合、彼は移動する部屋を撮影します。

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はすべてが怖いです。しこりや死体の匂いを嗅いだり、矢やハンターを聞いたりすると、ランダムな方向に走ります。それ以外の場合は、単純にランダムな方向に矢を放ち続けます。

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

シュートと葉を食べる

文法書の名声のパンダとは異なり、このハンターは実際には何も食べませんが、Wumpusが近づいている場合は撃つか、うまく行かないようにトレイルを離れます。

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

イドメネウス

イドメネウスは非常に単純です。もし、Wumpusまたは他のハンターが近くにいる場合、彼はいたるところに矢を放ち、狩りの女神が彼の側にいることを祈ります。彼が死体の近くにいる場合、彼はWumpusを待っています。彼は他のハンターが好きではなく、彼らが彼の近くで矢を放ち始めた場合、または彼らが彼と同じ部屋にいる場合、逃げます。最後に、彼が退屈していると感じたら、彼はランダムに永遠の廊下を歩きます。

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 Wumpuses（時々、銃や飛行機を使用するEmo Wolvesに関連）は、すべて（特にJava）を嫌います。彼らはハンターとウンプスを区別せず、すべて同じように撃とうとします。彼らはまた、ナスカーのドライバーを嫌い、常に正しく撃ちます。誰も撃っていない場合、彼らは正しく動きますが、一人でいることにさらに落ち込んで自分自身を撃とうとする前に、これを13回続けて行います（13は不運な数字です）。ターン99で、もし彼らがまだ生きているなら、飢vは死ぬためのそのような不十分な方法であるので、彼らは彼ら自身を撃つことを試みるでしょう。

WumpuseはWolvesよりも大きく（そして重い）ですが、これはまだ424バイトになります（NascarHunterの巨大な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++;}}

そもそも自殺してみませんか？Emo Wumpusesは、できる善の行為は、自殺する前に他人の苦しみを終わらせることだと信じています。したがって、彼らは死ぬ時が来る前に、できる限りのことをすべて殺します。

わんぱく？（反ハンター）

ええと、ハンプターの名簿でWumpusは何をしていますか？この男は人間が彼の親族を殺していることに非常に腹を立てたので、彼は彼らの一人として服を着て狩りに参加することに決めました。彼の主な目標は、ハンターを殺すことです。彼は死体の近くに隠れようとしますが、それはハンターからの盾にチャンスを与えます。近くにハンターがいない場合、ハンターが検出されるまで一方向に移動します。その場合、彼はハンターを殺してから他の方向に移動します。

残念ながら、ほとんどのWumpuseは愚かであり、まだ彼を殺そうとしています。とにかく、彼はどこでもWumpusesの善のために自分の犠牲が必要だと考えています。

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

}

ラオメドン

ラオメドンは死体を見つけようとしてあてもなくさまよう。彼が見つかったら、死体の隣の同じ場所にとどまるところを見つけます。彼がWumpusのにおいをかぐとき、彼は死体の部屋に矢を放ちます。

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

彼にとって残念なことに、他のハンターは彼のスキルに感謝せず、彼らは彼をたくさん撃つようです...

ニールハンター

これについて友人のDoctorHeckleと話し合った後、自分で試してみるのは楽しいと思いました。左右を交互に使用してほとんどのエリアをカバーするというアイデアを使用してから、状態に少し反応することを決定しましたが、0と1のみ-Wumpusまたはハンターが近くにいるかどうかにかかわらず。NascarHunterほどパフォーマンスが良くないので、最初は驚きました。少し考えた後、ハンター/臭いを聞いた後、ランダムな方向に矢印を撃つと（このように）、矢印が部屋に撃たれるので、そのターンに動いている場合は何もしませんが、殺す前に実行されます。思ったほど効果的ではありません...それでもうまくいきます！

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

これは彼がしこりを見つけるまで歩きます。その後、彼は正しく撃ちます。しこりがまだ残っている場合は、左側にあるはずなので、もう一度撃ちます。途中で、彼は他のハンターや死体のことを気にしません。

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

滞在

滞在は歩くのが好きではありません。それは単に撃ち、ハンターを撃ったかどうかを覚えています。

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