COMPLETARE

La stagione di Wumpus è finita e con le vite di molti Wumpus viziosi e coraggiosi cacciatori. Così come alcuni cacciatori stupidi codardi, immorali e decisamente stupidi. Ma alla fine della giornata, NascarHunter del dott. Heckle è uscito con il maggior bottino e gloria. Ti salutiamo, oh coraggioso ... autista?

È una stagione aperta su Wumpuses, e cacciatori di tutto il mondo si stanno riversando nelle Grotte di Wumpus per cercare di arricchirsi di preziosi Wumpus Pelts.

Il gioco

Basato sul classico gioco Hunt the Wumpus , con alcune varianti.

La mappa

Un dodecaedro . Ci sono 20 stanze, ognuna collegata ad altre 3 stanze, formando sostanzialmente 3 anelli con ponti in mezzo.

The Wumpus

Il Wumpus è una bestia mistica. Nessuno è sicuro di come sia, ma tutti concordano sul fatto che sia feroce. Il Wumpus vive nelle grotte e ama mangiare cose morte. Se c'è un cadavere in una grotta vicino al Wumpus, si sposterà lì e lo mangerà. Se il Wumpus si sposta in una grotta contenente cacciatori, ucciderà e mangerà anche loro. Se il Wumpus sente una freccia vicino a lui, si farà prendere dal panico e si imbatterà in una stanza a caso.

Tratti opzionali : questi sono attualmente inclusi per rendere il gioco più interessante, ma possono essere rimossi su richiesta popolare se aggiungono troppa casualità.

Wumpus infuriato: se il Wumpus viene colpito, ha un 20% di sopravvissuti e si scatena per 3 giorni. Quando si scatena, si sposterà casualmente due volte al giorno, ma sarà comunque attratto dai cadaveri. Dopo 3 giorni, morirà. Un secondo colpo di freccia ucciderà anche il Wumpus.

Wumpering Wumpus: ogni giorno, se nient'altro innesca il Wumpus, ha una probabilità del 25% di muoversi.

I cacciatori

Quattro cacciatori possono entrare nelle grotte alla volta. Le grotte sono buie, quindi i cacciatori non possono vedere, ma possono usare gli altri sensi. I cacciatori possono annusare il Wumpus in una stanza adiacente, annusare un cadavere in una stanza adiacente, ascoltare altri cacciatori che si muovono in stanze adiacenti e sentire se una freccia viene lanciata in una stanza adiacente.

I cacciatori hanno due azioni: sparare o muovere. Un cacciatore può scoccare una freccia in una stanza adiacente o nella propria stanza e muoversi in modo simile.

gameplay

In ogni round, i cacciatori prenderanno prima nota ciò che li circonda, quindi faranno una mossa. Il movimento avviene prima delle frecce, quindi se una freccia viene lanciata in una stanza dalla quale un cacciatore si sta allontanando, il cacciatore sopravviverà. Dopo aver effettuato tutte le mosse dei cacciatori, le frecce vengono valutate. Se un singolo occupante e una freccia si trovano nella stessa stanza, l'occupante verrà colpito e morirà. Se due o più occupanti condividono una stanza, uno verrà colpito e morirà a caso. Nota: i cadaveri sono occupanti, quindi un cadavere può servire da scudo parziale.

Dopo tutte le mosse dei cacciatori, il Wumpus risponderà. Se un cacciatore si è trasferito nella stanza con il Wumpus, il Wumpus lo mangerà. Se il Wumpus si muove, mangerà anche gli occupanti della nuova stanza.

Dopo 100 giorni, se i cacciatori non hanno ucciso il Wumpus, o sono caduti vittima, moriranno di fame nelle caverne.

Il codice

Tutto il codice sorgente può essere trovato qui . Tutti gli invii dovrebbero essere in Java, a meno che qualcuno non voglia scrivermi un adattatore stdIn / stdOut;)

I robot dovrebbero estendere la classe Hunter. Per nominare il tuo cacciatore, aggiungi un costruttore senza parametri che imposta il campo del nome. Per rispondere, sovrascrivere la funzione getResponse. In questa funzione, ad ogni turno, ti verrà superata una serie di 5 booleani che ti raccontano ciò che ti circonda.

status 0 = "Senti l'odore di un wumpus"

status 1 = "Senti un altro cacciatore"

status 2 = "Senti l'odore di un cadavere"

status 3 = "Senti un rumore di frecce"

status 4 = "Ti senti un altro cacciatore nella tua stessa stanza"

La classe Hunter ha 2 slot: nextMove e nextDirection, che usano rispettivamente gli enumerati Move e Direction. Lo spostamento può essere SPOSO o SCATTO, la direzione può essere SINISTRA, DESTRA, INDIETRO o QUI. Le indicazioni sono coerenti, il che significa che torna sempre ti riporterà alla stanza precedente in cui ti trovavi, e se entri dalla stessa stanza, SINISTRA e DESTRA saranno sempre le stesse. Tuttavia, se si entra da una direzione diversa, SINISTRA e DESTRA vi condurranno in luoghi diversi.

Sentiti libero di implementare anche i tuoi metodi. La memoria è persistente per tutto il torneo, il che significa che il tuo cacciatore sarà costruito solo una volta. Tuttavia, all'inizio di ogni round, viene chiamato il metodo newGame () per far sapere al tuo cacciatore che è iniziata una nuova partita.

punteggio

Quattro cacciatori competono alla volta. Se ucciso, la pelle di Wumpus vale 60 punti, divisa equamente tra tutti i cacciatori sopravvissuti. Stile round round robin, quindi ogni combinazione di 4 cacciatori giocherà insieme.

Sono inclusi 5 cacciatori di esempio: 4 con funzionalità di base e uno che consente l'input dell'utente per giocare, a scopo di test.

Se avete suggerimenti / richieste, per favore fatemi sapere!

La fine è vicina!

La popolazione Wumpus dei mondi viene cacciata a un ritmo allarmante. Il Protect Our Wumpuses Act dovrebbe essere approvato mercoledì 17 giugno. Dopo questa data, non saranno più ammessi cacciatori nelle caverne e verrà scelto un vincitore.

tabellone segnapunti

Nota: mi scuso, c'era un bug nel codice che poteva far morire i cacciatori attraverso più giochi. Una volta risolto, non cambia molto le classifiche generali, ma cambia in gran parte le statistiche.

I punteggi sono in, eseguendo ogni serie di cacciatori in 1000 partite ciascuno. NascarHunter e FullCoverageHunter guidano il gruppo, e sebbene l'aggiunta di AntiHunter abbia dato ai Wumpus una spinta di sopravvivenza del 2%, stanno ancora tremando nei loro piedi succhiati al tasso di sopravvivenza del 32% nel loro genere. Le frecce dei compagni cacciatori sono più che mai la più grande minaccia nelle grotte.

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

Non molta logica ad esso. Le sue regole sono semplici: gira a sinistra, terra bruciata, ripeti. E, ehi, potrebbe essere fortunato!

8 giugno modifica:

Aggiunto nella logica aggiuntiva a Nascar per spiegare l'adiacenza a un Wumpus rispetto alla sua ultima mossa. Consideralo un pit stop, per rimanere in tema. Se avverte un Wumpus dopo aver sparato in un corridoio, deve essere arrivato in una delle altre due stanze adiacenti, dal momento che sarebbe morto per lo sparo che il cacciatore ha appena fatto. Dà effettivamente i turni di Wumpus 2 per vivere se non si muove di nuovo, o Nascar 1 per vivere se si trova su un cadavere. Rappresenta anche una terza opzione se è il primo turno, ma solo una volta. Porterò a FCH alla fine, occupato.

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

Segue lo stesso credo di NascarHunter, ma alterna il suo percorso, che è garantito per formare un ciclo di 10 stanze uniche. Poiché ogni stanza è unica e spariamo in ogni direzione per stanza, tutte le stanze vengono colpite. Questo è vero per qualsiasi stanza di partenza (postulata dal mio amico Neal, grazie Neal!). I Dodecaedri sono così belli!

Vorrei sottolineare che questo è diverso dal nostro amico, il MonsterHunter, in quanto non prova alcun trucco o nessuna vera "tattica". Il punto di forza di questo è il fatto che ogni stanza viene sparata di nuovo: la soluzione della forza bruta. Questo ha un vantaggio teorico su NascarHunter, poiché Nascar colpirà solo 10 delle 20 stanze, coprendo solo metà dell'area.

11 giugno modifica:

Aggiunto nel modello logico di rilevamento di Wumpus da NascarHunter. Dovrebbe migliorare obiettivamente il punteggio.

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;

            }

        }

    }

}

Fammi sapere se ci sono errori, il pacchetto non ha funzionato bene con il mio IDE :(

Tasso

Non gli piacciono i visitatori.

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. Sii vorticosamente tranquillo, sto cacciando Wumpus"

Elmer è fissato sulla preda e ignora tutto tranne i cadaveri e il Wumpus. Prova a trovare un cadavere, poi indietreggia e inizia a sparare. Se sente l'odore di un Wumpus, si ritirerà e se lo sente ancora sparerà.

Mi scuso con tutti i programmatori Java, questo è probabilmente estremamente brutto, pieno di errori di sintassi e probabilmente ho incasinato la mia logica.

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

    }
}

Pacifista

Questo ragazzo è moralmente contrario a qualsiasi tipo di sport del sangue e si chiede come sia arrivato in questa situazione. Scapperà da qualsiasi tipo di contatto e non prenderà mai un colpo.

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

Cacciatore di mostri

Stiamo dando la caccia a un mostro e siamo in 4 ... Mi ricorda il mio gioco preferito! Questo cacciatore percorrerà la maggior parte della mappa spostandosi da sinistra a destra in alternativa, e se il Wumpus è vicino, lo attirerà andando indietro per essere in grado di determinare esattamente dove si trova.

Potrei liberarmi di lastDirection, ma tengo per la semantica e la leggibilità :). In realtà, muore parecchio, ma il controller spesso mette 2/3 cacciatori nella stessa stanza all'inizio, e spesso con il Wumpus vicino (può anche essere nella stessa stanza) ... quindi morte instabile ^^ '.

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

Avanti e indietro, tra le stanze. se odora un Wumpus o sente un giocatore spara a sinistra poi a destra. se un Wumpus è accanto a lui per cominciare, allora spara alla stanza in cui si sposterà.

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

}

Fifone

ScaredyCat ha paura di tutto. Se odora un wumpus o un cadavere o sente una freccia o un cacciatore, corre in una direzione casuale. Altrimenti, continua semplicemente a sparare frecce in direzioni casuali.

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

Mangia germogli e foglie

A differenza della Panda della fama del libro di grammatica, questo cacciatore in realtà non mangia nulla, ma spariamo se il Wumpus è in giro o usciamo su un sentiero che si spera ci impedisca di camminare in cerchio.

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

Idomeneo

Idomeneus è abbastanza semplice: se il Wumpus o un altro cacciatore si trova nelle vicinanze, spara ovunque e prega che la dea della caccia sia dalla sua parte. Se è vicino a un cadavere, sta aspettando il Wumpus. Non gli piacciono gli altri cacciatori e scapperanno se iniziano a scoccare frecce vicino a lui, o se si trovano nella sua stessa stanza. Alla fine, se si sente annoiato, cammina a caso per gli eterni corridoi.

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 (legati a Emo Wolves che a volte usano pistole e aerei volanti ) odiano tutto (specialmente Java). Non fanno distinzioni tra Cacciatori e Wumpus e provano a sparare lo stesso. Odiano anche i conducenti di Nascar e spareranno sempre bene. Se nessuno è in giro a sparare, si muovono bene, ma lo faranno solo tredici volte di seguito prima di diventare ancora più depressi per essere soli e provare a spararsi (tredici è un numero sfortunato). Al turno 99, se sono ancora vivi, proveranno a spararsi perché la fame è un modo così pessimo di morire.

I wumpus sono più grandi (e più pesanti) dei lupi, ma questo è ancora morto di fame a 424 byte (al contrario dei 2.72 kb di 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++;}}

Perché non suicidarsi in primo luogo? Emo Wumpuses crede che l'unico atto del bene che può fare sia porre fine alla sofferenza degli altri prima di uccidersi. Pertanto, uccideranno tutto ciò che possono prima che sia il loro momento di morire.

Wumpus? (Anti-Hunter)

Cosa sta facendo un Wumpus nel registro dei cacciatori? Questo ragazzo si è incazzato molto sul fatto che gli umani stessero uccidendo il suo parente, così ha deciso di travestirsi da uno di loro e partecipare alla caccia. Il suo obiettivo principale è quello di uccidere solo i cacciatori. Cerca di nascondersi vicino ai cadaveri, il che gli darà la possibilità di uno scudo dai cacciatori. Se non ci sono cacciatori nelle vicinanze, si sposterà in una direzione fino a quando non verranno rilevati i cacciatori, nel qual caso cercherà di ucciderli prima di spostarsi nell'altra direzione.

Sfortunatamente, la maggior parte dei Wumpus sono stupidi e stanno ancora cercando di ucciderlo. Indipendentemente da ciò, considera i suoi sacrifici necessari per il bene di Wumpuses ovunque.

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

}

Laomedonte

Laomedon vaga senza meta cercando di trovare un cadavere. Una volta che ne ha trovato uno e capisce dove si trova, rimane nello stesso posto vicino al cadavere. Quando sente l'odore del Wumpus, lancia frecce nella stanza del cadavere.

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

Sfortunatamente per lui, gli altri cacciatori non apprezzano le sue abilità e sembrano sparargli molto ...

NealHunter

Dopo averne parlato con il mio amico DoctorHeckle, ho pensato che sarebbe stato divertente provarlo da solo. Ho usato l'idea di alternare sinistra e destra per coprire la maggior parte dell'area, quindi ho deciso di aggiungere un po 'di risposta agli stati, ma solo 0 e 1 - indipendentemente dal fatto che un Wumpus o un cacciatore si trovino nelle vicinanze. Non si esibisce bene come NascarHunter, che all'inizio mi ha sorpreso. Dopo aver riflettuto un po ', mi sono reso conto che sparare una freccia in una direzione casuale (come fa) dopo aver sentito un cacciatore / annusare un Wumpus non farà nulla se si muovono in quel turno, poiché le frecce vengono lanciate nelle stanze, ma il movimento viene eseguito prima di ucciderli. Non abbastanza efficace come pensavo ... comunque si comporta bene!

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

Questo cammina finché non trova il wumpus. Quindi spara a destra. Se il wumpus è ancora lì, deve essere sulla sinistra, quindi spara ancora una volta. Sulla strada, non gli importa di altri cacciatori o cadaveri, da cui il nome.

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

Restare

Al soggiorno non piace camminare. Spara semplicemente e ricorda se ha sparato a un cacciatore.

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