KOMPLETT

Die Wumpus-Saison ist zu Ende gegangen, und damit auch das Leben vieler bösartiger Wumpus- und tapferer Jäger. Sowie einige feige, unmoralische und geradezu dumme Jäger. Aber am Ende des Tages kam NascarHunter von Dr. Heckle mit der meisten Beute und Herrlichkeit davon. Wir grüßen dich, oh mutiger ... Fahrer?

Wumpus-Jäger aus der ganzen Welt strömen in die Wumpus-Höhlen, um reich an wertvollen Wumpus-Pelts zu werden.

Das Spiel

Basierend auf dem klassischen Spiel Hunt the Wumpus mit einigen Variationen.

Die Karte

Ein Dodekaeder . Es gibt 20 Räume, die jeweils mit 3 anderen Räumen verbunden sind und im Grunde 3 Ringe mit dazwischen liegenden Brücken bilden.

Der Wumpus

Der Wumpus ist ein mystisches Tier. Keiner ist sich sicher, wie es aussieht, aber alle sind sich einig, dass es grausam ist. Der Wumpus lebt in den Höhlen und isst gerne tote Dinge. Wenn sich in einer Höhle neben dem Wumpus eine Leiche befindet, wird er dorthin ziehen und sie essen. Wenn der Wumpus in eine Höhle mit Jägern zieht, wird er sie auch töten und essen. Wenn der Wumpus einen Pfeil in seiner Nähe hört, gerät er in Panik und rennt in einen zufälligen Raum.

Optionale Merkmale : Diese sind derzeit enthalten, um das Spiel interessanter zu machen. Sie können jedoch auf vielfachen Wunsch entfernt werden, wenn sie zu zufällig sind.

Wütender Wumpus: Wenn der Wumpus angeschossen wird, überlebt er zu 20% und tobt 3 Tage lang. Wenn er tobt, bewegt er sich zufällig zweimal am Tag, wird aber immer noch von Leichen angezogen. Nach 3 Tagen wird er sterben. Ein zweiter Pfeilschuss tötet auch den Wumpus.

Wandernder Wumpus: Jeden Tag, wenn nichts anderes den Wumpus auslöst, hat er eine Chance von 25%, sich zu bewegen.

Die Jäger

Vier Jäger können die Höhlen gleichzeitig betreten. Die Höhlen sind dunkel, so dass die Jäger nicht sehen können, aber sie können ihre anderen Sinne benutzen. Jäger können den Wumpus in einem angrenzenden Raum riechen, eine Leiche in einem angrenzenden Raum riechen, andere Jäger in angrenzenden Räumen bewegen hören und hören, ob ein Pfeil in einen angrenzenden Raum geschossen wird.

Jäger haben zwei Aktionen: Schießen oder Bewegen. Ein Jäger kann einen Pfeil in einen angrenzenden Raum oder in seinen eigenen Raum schießen und sich auf ähnliche Weise bewegen.

Gameplay

In jeder Runde nehmen die Jäger zuerst ihre Umgebung zur Kenntnis und machen dann einen Zug. Die Bewegung erfolgt vor den Pfeilen. Wenn also ein Pfeil in einen Raum geschossen wird, aus dem sich ein Jäger herausbewegt, überlebt der Jäger. Nachdem alle Jägerzüge ausgeführt wurden, werden die Pfeile ausgewertet. Wenn sich ein einzelner Insasse und ein Pfeil im selben Raum befinden, wird der Insasse erschossen und stirbt. Wenn sich zwei oder mehr Personen einen Raum teilen, wird einer zufällig getroffen und stirbt. Hinweis: Leichen sind Insassen, daher kann ein toter Körper als Teilschutz dienen.

Nachdem sich alle Jäger bewegt haben, reagiert der Wumpus. Wenn ein Jäger mit dem Wumpus in das Zimmer gezogen ist, frisst der Wumpus ihn. Wenn sich der Wumpus bewegt, frisst er auch die Bewohner des neuen Raumes.

Wenn die Jäger nach 100 Tagen den Wumpus nicht getötet haben oder zum Opfer gefallen sind, sterben sie in den Höhlen an Hunger.

Der Code

Den gesamten Quellcode finden Sie hier . Alle Einsendungen sollten in Java sein, es sei denn, jemand möchte mir einen stdIn / stdOut-Adapter schreiben;)

Bots sollten die Hunter-Klasse erweitern. Fügen Sie zum Benennen Ihres Jägers einen Konstruktor ohne Parameter hinzu, der das Namensfeld festlegt. Um zu antworten, überschreiben Sie die Funktion getResponse. In dieser Funktion erhalten Sie in jeder Runde ein Array von 5 Booleschen Werten, die Sie über Ihre Umgebung informieren.

status 0 = "Du riechst einen Wumpus"

status 1 = "Sie hören einen anderen Jäger"

status 2 = "Du riechst eine Leiche"

status 3 = "Sie hören ein Klappern des Pfeils"

status 4 = "Du fühlst einen anderen Jäger im selben Raum wie du."

Die Hunter-Klasse hat zwei Slots: nextMove und nextDirection, die die Aufzählungen Move und Direction verwenden. Move kann entweder MOVE oder SHOOT sein, Direction kann LEFT, RIGHT, BACK oder HERE sein. Die Anweisungen sind konsistent, dh, Sie kehren immer zum vorherigen Raum zurück, in dem Sie sich befanden. Wenn Sie vom selben Raum aus betreten, sind LINKS und RECHTS immer gleich. Wenn Sie jedoch aus einer anderen Richtung einsteigen, gelangen Sie mit LINKS und RECHTS zu verschiedenen Orten.

Sie können auch Ihre eigenen Methoden implementieren. Der Speicher bleibt während des gesamten Turniers erhalten, was bedeutet, dass Ihr Jäger nur einmal konstruiert wird. Zu Beginn jeder Runde wird jedoch die newGame () -Methode aufgerufen, um Ihren Jäger darüber zu informieren, dass ein neues Spiel gestartet wurde.

Wertung

Es treten jeweils vier Jäger gegeneinander an. Wenn der Wumpus getötet wird, erhält er 60 Punkte, die gleichmäßig auf alle überlebenden Jäger verteilt sind. Voller Round Robin-Stil, so dass jede Kombination von 4 Jägern zusammen spielt.

5 Beispieljäger sind enthalten: 4 mit grundlegender Funktionalität und einer, mit der Benutzereingaben zu Testzwecken abgespielt werden können.

Wenn Sie Anregungen / Wünsche haben, lassen Sie es mich bitte wissen!

Das Ende ist in Sicht!

Die Weltbevölkerung der Wumpus wird mit alarmierender Geschwindigkeit gejagt. Das Gesetz zum Schutz unserer Wumpuses wird voraussichtlich am Mittwoch, dem 17. Juni, verabschiedet. Nach diesem Datum dürfen keine Jäger mehr in die Höhlen und es wird ein Gewinner ermittelt.

Anzeigetafel

Hinweis: Ich entschuldige mich dafür, dass der Code einen Fehler enthält, der dazu führen kann, dass Hunters während mehrerer Spiele tot bleibt. Nachdem es behoben wurde, ändert es nicht viel an der Gesamtwertung, aber es ändert die Statistiken stark.

Es gibt Scores, in denen jeder Jägersatz in jeweils 1000 Spielen ausgeführt wird. NascarHunter und FullCoverageHunter führen das Rudel an, und obwohl die Wumpuses durch die Zugabe von AntiHunter einen 2% igen Überlebensschub erhalten haben, zittern sie immer noch mit der 32% igen Überlebensrate ihrer Art. Pfeile von Mitjägern sind mehr denn je die größte Bedrohung in den Höhlen.

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

Nicht viel Logik dazu. Seine Regeln sind einfach: links abbiegen, verbrannte Erde, wiederholen. Und hey, er könnte Glück haben!

8. Juni bearbeiten:

Nascar wurde als zusätzliche Logik hinzugefügt, um die Nähe zu einem Wumpus im Verhältnis zu seinem letzten Zug zu berücksichtigen. Betrachten Sie es als einen Boxenstopp, um im Thema zu bleiben. Wenn es einen Wumpus spürt, nachdem er einen Flur heruntergeschossen hat, muss er in einem der beiden anderen angrenzenden Räume angekommen sein, da er für den Schuss gestorben wäre, den der Jäger gerade aufgenommen hat. Es gibt entweder dem Wumpus 2 Runden, um zu leben, wenn er sich nicht wieder bewegt, oder Nascar 1 Runde, um zu leben, wenn er auf einer Leiche steht. Berücksichtigt auch eine dritte Option, wenn es die erste Runde ist, aber nur die einmalige. Ich werde irgendwann zu FCH portieren, beschäftigt beschäftigt.

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

Folgt dem gleichen Credo wie der NascarHunter, wechselt jedoch seinen Weg, der garantiert eine Schleife von 10 einzigartigen Räumen bildet. Da jeder Raum einzigartig ist und wir in jede Richtung pro Raum schießen, werden alle Räume beschossen. Dies gilt für jedes Startzimmer (postuliert von meinem Kumpel Neal, danke Neal!). Dodekaeder sind so ziemlich cool!

Ich möchte darauf hinweisen, dass dies anders ist als unser Freund, der Monsterjäger, da er keine Tricks oder wirklichen "Taktiken" ausprobiert. Die Stärke davon ist die Tatsache, dass jeder Raum erneut beschossen wird: die Brute-Force-Lösung. Dies hat einen theoretischen Vorsprung vor dem NascarHunter, da Nascar nur 10 der 20 Räume trifft und nur die Hälfte der Fläche abdeckt.

11. Juni bearbeiten:

Hinzugefügt im Wumpus-Erkennungslogikmuster von NascarHunter. Sollte objektiv die Punktzahl verbessern.

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;

            }

        }

    }

}

Lassen Sie mich wissen, wenn Fehler aufgetreten sind, das Paket hat mit meiner IDE nicht funktioniert :(

Dachs

Er mag keine Besucher.

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. Sei vewy vewy leise, ich jage wumpus"

Elmer ist auf die Beute fixiert und ignoriert alles außer Leichen und dem Wumpus. Er versucht eine Leiche zu finden, zieht sich dann zurück und beginnt zu schießen. Wenn er einen Wumpus riecht, zieht er sich zurück und wenn er ihn immer noch riecht, schießt er.

Ich entschuldige mich bei allen Java-Programmierern, dies ist wahrscheinlich extrem hässlich, voller Syntaxfehler und ich habe wahrscheinlich meine Logik durcheinander gebracht.

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

    }
}

Pazifist

Dieser Typ ist moralisch gegen jede Art von Blutsport und fragt sich, wie er überhaupt in dieser Situation aufgetaucht ist. Er wird vor jeglichem Kontakt davonlaufen und niemals einen Schuss machen.

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

Monsterjäger

Wir jagen ein Monster und wir sind 4 ... Es erinnert mich an mein Lieblingsspiel! Dieser Jäger wandert den größten Teil der Karte von links nach rechts, und wenn der Wumpus in der Nähe ist, lockt er ihn zurück, um genau zu bestimmen, wo er ist.

Ich könnte lastDirection loswerden, aber ich halte für Semantik und Lesbarkeit :). Eigentlich stirbt es ziemlich oft, aber der Controller hat zu Beginn oft 2/3 Jäger in den gleichen Raum gesetzt und oft mit dem Wumpus in der Nähe (kann auch im gleichen Raum sein) ... also insta death ^^ '.

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

Hin und her, zwischen zu Räumen. Wenn es einen Wumpus riecht oder einen Spieler hört, schießt es nach links und nach rechts. Wenn zu Beginn ein Wumpus neben ihm ist, schießt er auf den Raum, in den er sich begeben wird.

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 hat vor allem Angst. Wenn es einen Wumpus oder eine Leiche riecht oder einen Pfeil oder einen Jäger hört, läuft es in eine zufällige Richtung. Ansonsten schießt es einfach weiter in zufällige Richtungen.

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

Isst Triebe und Blätter

Anders als der Panda des Grammatikbuchs frisst dieser Jäger eigentlich nichts, aber wir schießen entweder, wenn der Wumpus in der Nähe ist, oder wir gehen auf eine Spur, die uns hoffentlich davon abhalten sollte, im Kreis zu laufen.

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 ist ganz einfach - wenn der Wumpus oder ein anderer Jäger in der Nähe ist, sengt er überall Feuer und betet, dass die Göttin der Jagd auf seiner Seite ist. Wenn er in der Nähe einer Leiche ist, wartet er auf den Wumpus. Er mag keine anderen Jäger und rennt davon, wenn sie in seiner Nähe Pfeile abschießen oder sich im selben Raum wie er befinden. Wenn er sich gelangweilt fühlt, läuft er schließlich willkürlich durch die ewigen Gänge.

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 (Jäger)

Emo Wumpuses (verwandt mit Emo Wolves, die manchmal Waffen und Flugzeuge benutzen ) hassen alles (besonders Java). Sie machen keinen Unterschied zwischen Jägern und Wumpusen und versuchen, sie trotzdem zu erschießen. Sie hassen auch Nascar-Fahrer und werden immer richtig schießen. Wenn niemand da ist, um zu schießen, bewegen sie sich nach rechts, tun dies aber nur dreizehn Mal hintereinander, bevor sie noch depressiver werden, wenn sie alleine sind und versuchen, sich selbst zu schießen (dreizehn ist eine unglückliche Zahl). Wenn sie in Runde 99 noch am Leben sind, werden sie versuchen, sich selbst zu erschießen, weil der Hunger eine so lahme Art ist, zu sterben.

Wumpuses sind größer (und schwerer) als Wolves, aber dieser hat sich immer noch auf 424 Bytes verkürzt (im Gegensatz zu den kräftigen 2,72 kb von NascarHunter).

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

Warum nicht gleich Selbstmord begehen? Emo Wumpuses glaubt, dass der einzige Akt des Guten darin besteht, das Leiden anderer zu beenden, bevor sie sich selbst töten. Deshalb werden sie alles töten, was sie können, bevor es an der Zeit ist, zu sterben.

Wumpus? (Anti-Jäger)

Was macht ein Wumpus auf der Jägerliste? Dieser Typ war super sauer, dass Menschen seine Verwandten töteten, also beschloss er, sich als einer von ihnen zu verkleiden und sich der Jagd anzuschließen. Sein Hauptziel ist es, nur Jäger zu töten. Er versucht, sich in der Nähe von Leichen zu verstecken, was ihm die Chance gibt, einen Schild vor den Jägern zu erhalten. Wenn sich keine Jäger in der Nähe befinden, bewegt er sich in eine Richtung, bis Jäger erkannt werden. In diesem Fall versucht er, sie zu töten, bevor er sich in die andere Richtung bewegt.

Leider sind die meisten Wumpuses dumm und werden immer noch versuchen, ihn zu töten. Unabhängig davon hält er seine Opfer für das Wohl von Wumpuses überall notwendig.

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 streift ziellos umher, um eine Leiche zu finden. Sobald er eines gefunden hat und herausfindet, wo es ist, bleibt er an der gleichen Stelle neben der Leiche. Wenn er den Wumpus riecht, schießt er Pfeile in das Zimmer der Leiche.

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

Leider schätzen die anderen Jäger seine Fähigkeiten nicht und scheinen ihn sehr zu erschießen ...

NealHunter

Nachdem ich mit meinem Freund DoctorHeckle darüber gesprochen hatte, dachte ich, es würde Spaß machen, es selbst zu versuchen. Verwendete die Idee, links und rechts zu wechseln, um den größten Teil des Gebiets abzudecken, und entschloss sich dann, ein wenig auf die Zustände zu reagieren, aber nur 0 und 1 - ob ein Wumpus oder ein Jäger in der Nähe sind oder nicht. Funktioniert nicht so gut wie NascarHunter, was mich zuerst überrascht hat. Nach einigem Nachdenken wurde mir klar, dass das Schießen eines Pfeils in eine zufällige Richtung (wie dies der Fall ist) nach dem Hören eines Jägers / Riechens eines Wumpus nichts bringt, wenn sie sich in dieser Kurve bewegen, da Pfeile in Räume geschossen werden, aber Bewegung wird ausgeführt, bevor es sie tötet. Nicht ganz so effektiv, wie ich dachte ... funktioniert aber immer noch gut!

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

Dieser geht, bis er den Wumpus findet. Dann schießt er richtig. Wenn der Wumpus noch da ist, muss er sich links befinden, also schießen Sie noch einmal. Auf dem Weg interessiert er sich nicht für andere Jäger oder Leichen, daher der Name.

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

Bleibe

Stay geht nicht gern spazieren. Es schießt einfach herum und erinnert sich, ob er einen Jäger erschossen hat.

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