완전한

Wumpus 시즌은 많은 악의 Wumpus와 용감한 Hunter의 삶을 끝냈습니다. 비겁하고 부도덕하고 멍청한 사냥꾼들도 있습니다. 그러나 마지막 날, Heckle 박사의 NascarHunter는 가장 전리품과 영광을 잃었습니다. 우리는 당신에게 경의를 표합니다.

Wumpuses에서 열린 시즌이며 전 세계의 사냥꾼들이 Wumpus Caves에 몰려 들어 소중한 Wumpus Pelts를 풍부하게 얻습니다.

게임

몇 가지 변형과 함께 고전적인 Hunt the Wumpus 게임을 기반으로합니다 .

지도

십이 면체 . 20 개의 방이 있으며 각각 3 개의 다른 방과 연결되어 있으며 기본적으로 다리가있는 3 개의 고리가 있습니다.

범퍼 스

Wumpus는 신비한 짐승입니다. 어떤 모습인지는 확신 할 수 없지만 모두 사나운 것에 동의합니다. Wumpus는 동굴에 살며 죽은 것을 좋아합니다. Wumpus 옆의 동굴에 시체가 있다면 그곳으로 가서 먹을 것입니다. Wumpus가 사냥꾼이있는 동굴로 이동하면 죽일 수도 있습니다. Wumpus가 그 근처에 화살표를 들으면 당황하고 무작위 방으로 뛰어들 것입니다.

선택적인 특성 : 이것들은 현재 게임을 더욱 흥미롭게 만들기 위해 포함되어 있지만 너무 많은 무작위성을 추가하면 대중의 요청에 따라 제거 될 수 있습니다.

격노 한 Wumpus : Wumpus가 총에 맞으면 3 일 동안 생존 및 상승의 20 %를 차지합니다. 급증 할 때, 그는 하루에 두 번 무작위로 움직일 것이지만 여전히 시체에 끌립니다. 3 일 후에 그는 죽을 것이다. 두 번째 화살은 또한 Wumpus를 죽일 것입니다.

방황하는 Wumpus : 매일 Wumpus를 유발하는 다른 것이 없다면 25 %의 확률로 움직입니다.

사냥꾼

한 번에 네 명의 사냥꾼이 동굴에 들어갈 수 있습니다. 동굴은 어둡기 때문에 사냥꾼은 볼 수 없지만 다른 감각을 사용할 수 있습니다. 사냥꾼은 인접한 방에서 Wumpus 냄새를 맡고, 인접한 방에서 시체 냄새를 맡고, 다른 방에서 움직이는 다른 사냥꾼의 소리를 듣고, 화살이 인접한 방으로 들어 갔는지들을 수 있습니다.

사냥꾼은 두 가지 행동이 있습니다 : 사격 또는 이동. 사냥꾼은 인접한 방이나 자신의 방으로 화살을 쏘아서 비슷하게 움직일 수 있습니다.

게임 플레이

각 라운드에서 사냥꾼은 먼저 주변 환경을 기록한 다음 한 번 움직입니다. 화살보다 움직임이 일어나므로 사냥꾼이 나가는 방으로 화살을 쏘면 사냥꾼은 살아남을 것입니다. 모든 헌터 이동이 완료되면 화살표가 평가됩니다. 한 명의 탑승자와 화살이 같은 방에 있으면 탑승자가 총에 맞고 사망합니다. 두 명 이상의 탑승자가 방을 공유하는 경우, 한 명은 무작위로 명중되어 사망합니다. 참고 : 시체는 점유자이므로 시체는 부분 보호막 역할을 할 수 있습니다.

모든 사냥꾼이 이동하면 Wumpus가 응답합니다. 사냥꾼이 Wumpus와 함께 방으로 이사하면 Wumpus는 그를 먹을 것입니다. Wumpus가 움직이면 새 방의 탑승자를 먹습니다.

100 일이 지나도 사냥꾼이 Wumpus를 죽이지 않았거나 희생자를 쓰지 않으면 동굴 내에서 기아로 죽게됩니다.

코드

모든 소스 코드는 여기 에서 찾을 수 있습니다 . 누군가 stdIn / stdOut 어댑터를 작성하지 않으려면 모든 제출물은 Java로 작성해야합니다.)

봇은 헌터 클래스를 확장해야합니다. Hunter의 이름을 지정하려면 이름 필드를 설정하는 매개 변수가없는 생성자를 추가하십시오. 응답, getResponse 함수를 대체하십시오. 이 기능에서는 매 턴마다 5 개의 부울 배열이 전달되어 주변에 대해 알려줍니다.

status 0 = "당신은 부랑자 냄새가 난다"

상태 1 = "다른 사냥꾼의 소리가 들립니다"

상태 2 = "당신은 시체 냄새"

status 3 = "화살표 소리가 들립니다."

상태 4 = "당신은 같은 방에 다른 사냥꾼을 느낀다"

Hunter 클래스에는 2 개의 슬롯이 있습니다 : nextMove 및 nextDirection은 각각 열거 형 Move 및 Direction을 사용합니다. 이동은 MOVE 또는 SHOOT 일 수 있으며, 방향은 LEFT, RIGHT, BACK 또는 HERE 일 수 있습니다. 길 찾기는 일관성이 있습니다. 즉, 뒤로 돌아 가면 항상 이전 방으로 돌아갑니다. 같은 방에서 들어 오면 왼쪽과 오른쪽이 항상 동일합니다. 그러나 다른 방향으로 들어가면 왼쪽과 오른쪽이 다른 곳으로 이동합니다.

자신 만의 메소드도 자유롭게 구현하십시오. 토너먼트 전체에서 기억력이 지속되므로 사냥꾼은 한 번만 구성됩니다. 그러나 각 라운드가 시작될 때 사냥꾼에게 새로운 게임이 시작되었음을 알리기 위해 newGame () 메서드가 호출됩니다.

채점

한 번에 네 명의 사냥꾼이 경쟁합니다. Wumpus 펠트를 죽이면 60 포인트의 가치가 있으며 살아남은 모든 사냥꾼들에게 균등하게 분할됩니다. 풀 라운드 로빈 스타일이므로 4 명의 헌터 조합이 함께 플레이합니다.

5 개의 샘플 헌터가 포함되어 있습니다. 4 개의 매우 기본적인 기능과 테스트 목적으로 사용자 입력을 할 수있는 것.

제안 / 요청이 있으시면 알려주세요!

끝이 보인다!

세계 Wumpus 인구는 놀라운 속도로 사냥되고 있습니다. 우리의 충돌 방지법은 6 월 17 일 수요일에 통과 될 것으로 예상됩니다. 이 날짜 이후에는 더 이상 사냥꾼이 동굴에 들어갈 수 없으며 승자가 선택됩니다.

스코어 보드

참고 : 사과합니다. 코드에 버그가있어 헌터가 여러 게임을 통해 죽어있을 수 있습니다. 그것을 고치면 전체 순위는 크게 변경되지 않지만 통계는 크게 변경됩니다.

점수는 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 일 편집 :

마지막 이동과 관련하여 Wumpus와의 인접성을 설명하기 위해 Nascar에 추가 논리가 추가되었습니다. 주제를 유지하기 위해 피트 스탑을 고려하십시오. 복도에서 총을 쏘고 난 후 Wumpus를 감지하면 사냥꾼이 방금 찍은 총알로 죽었 기 때문에 인접한 두 개의 방 중 하나에 도착했을 것입니다. 그것은 다시 움직이지 않으면 Wumpus 2 턴을 살게하거나, 시체에 서 있으면 Nascar 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 개의 독특한 방을 형성합니다. 모든 방은 독특하고 방마다 모든 방향으로 발사되기 때문에 모든 방이 해고됩니다. 이것은 모든 시작 방에 해당됩니다 (내 친구 닐이 가정했습니다, 닐 감사합니다!). Dodecahedra는 그렇게 멋지다!

나는 이것이 속임수 나 실제 "전술"을 시도하지 않기 때문에 이것이 친구 인 MonsterHunter와 다르다는 점을 지적하고 싶습니다. 이것의 강점은 모든 방이 다시 해고된다는 사실입니다. Nascar는 20 개 방 중 10 개를 겨냥하여 면적의 절반 만 차지하기 때문에 NascarHunter에 이론적 근거가 있습니다.

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

엘머 퍼드

"S. 조용히 해봐, 난 고래를 사냥하고있어"

엘머 는 먹이에 고정되어 있으며 시체와 부 푸스를 제외한 모든 것을 무시합니다. 그는 시체를 찾으려고 물러서서 사격을 시작한다. 그가 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];
    }
}

페이싱 헌터

앞뒤로 방 사이. 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는 모든 것을 무서워합니다. 울퉁불퉁하거나 시체 냄새가 나거나 화살이나 사냥꾼 소리가 들리면 임의의 방향으로 움직입니다. 그렇지 않으면 단순히 화살표를 무작위 방향으로 계속 유지합니다.

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

이도 메네 우스

Idomeneus는 매우 간단합니다-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(){}



}

이모 Wumpus (헌터)

Emo Wumpuses ( 때때로 총 과 비행 비행기를 사용 하는 Emo Wolves 관련) )는 모든 것 (특히 Java)을 싫어합니다. 그들은 헌터와 Wumpuses를 구별하지 않고 모두 동일하게 쏴보십시오. 그들은 또한 Nascar 드라이버를 싫어하며 항상 올바르게 촬영합니다. 아무도 사격을 할 수 없다면, 그들은 오른쪽으로 움직입니다. 그러나 혼자있는 것에 대해 더욱 우울 해지고 스스로 사격을 시도하기 전에이 열세 번만 행할 것입니다. 99 세에 그들이 아직 살아 있다면 기아는 죽을 정도로 절름발이이기 때문에 스스로 쏘려고 시도 할 것입니다.

Wumpuses는 Wolves보다 더 크고 무겁지만,이 중 하나는 NascarHunter의 2.72kb와는 달리 424 바이트로 굶어 죽었습니다.

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는 무엇을하고 있습니까? 이 사람은 인간이 자신의 친족을 죽이고 있다는 사실에 화를 냈으므로 그는 그들 중 한 명으로 옷을 입히고 사냥에 참여하기로 결정했습니다. 그의 주요 목표는 사냥꾼을 죽이는 것입니다. 그는 시체 근처에 숨기려고 시도하여 사냥꾼으로부터 방패를 얻을 수 있습니다. 근처에 사냥꾼이 없으면 사냥꾼이 감지 될 때까지 한 방향으로 움직입니다.이 경우 다른 방향으로 움직이기 전에 죽이려고합니다.

불행히도, 대부분의 Wumpuses는 바보이며 여전히 그를 죽이려고합니다. 어쨌든, 그는 도처에 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;
    }
}

}

라오 돈

Laomedon은 시체를 찾으려고 무의식적으로 방황합니다. 그가 발견 한 곳이 어디인지 알아 내면 시체 옆의 같은 곳에 머무 릅니다. 그가 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과 이것에 대해 이야기 한 후에, 나는 그것을 직접 시도하는 것이 재미있을 것이라고 생각했다. 대부분의 지역을 다루기 위해 왼쪽과 오른쪽을 번갈아 가며 아이디어를 사용하고 주에 약간의 응답을 추가하기로 결정했지만 Wumpus 또는 사냥꾼이 근처에 있는지 여부에 관계없이 0과 1 만 추가했습니다. 처음에는 나를 놀라게 한 NascarHunter만큼 성능이 좋지 않습니다. 그러나 몇 가지 생각을 한 후에, 사냥꾼의 소리를 듣고 / 혹은 Wumpus 냄새를 맡은 후 화살표를 임의의 방향으로 화살을 쏘는 것은 화살이 방으로 쏠리 기 때문에 그 턴에 움직이면 아무 것도하지 않을 것이라는 것을 깨달았습니다. 그들을 죽이기 전에 수행됩니다. 내가 생각했던 것만 큼 효과적이지는 않지만 ... 여전히 잘 작동합니다!

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

걷는 바보

이것은 그가 부비를 찾을 때까지 걷습니다. 그런 다음 그는 바로 쏴. 고비가 여전히 남아 있으면 왼쪽에 있어야하므로 다시 한 번 촬영하십시오. 도중에, 그는 다른 사냥꾼이나 시체를 신경 쓰지 않으므로 이름입니다.

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