大熊狩猎

22

完成

Wumpus季节已经结束，许多邪恶的Wumpus和勇敢的Hunter的生活也随之结束。以及一些怯ward，不道德和彻头彻尾的愚蠢猎人。但是最终，Heckle博士的NascarHunter夺走了最多的战利品和荣耀。我们向您致敬，哦，勇敢...司机？

这是旺普斯的开放季节，来自世界各地的猎人正涌向伍普斯山洞，以尝试从宝贵的伍普斯果皮中致富。

游戏

基于经典的《Hunt the Wumpus》游戏，有一些变化。

地图

一个十二面体。有20个房间，每个房间连接到其他3个房间，基本上形成3个环，中间有桥。

ump

巫婆是个神秘​​的野兽。没有人知道它是什么样，但是所有人都同意它是凶猛的。乌普斯人住在山洞里，喜欢吃死掉的东西。如果Wumpus旁边的山洞里有尸体，他会搬到那里吃掉。如果Wumpus碰巧进入一个包含猎人的洞穴，他也会杀死并吃掉它们。如果Wumpus听到附近有箭，他会惊慌失措，跑进随机房间。

可选特征：当前包括这些特征，以使游戏更有趣，但如果它们增加了太多的随机性，则可以应大众要求将其删除。

愤怒的旺普斯：如果旺普斯被枪杀，他有20％的生存率和狂暴持续3天。横冲直撞时，他每天会随机移动两次，但仍然会被尸体吸引。3天后，他将死亡。第二箭也将杀死伍普斯。

流浪的乌姆普斯：每天，如果没有其他因素触发乌姆普斯，他有25％的机会移动。

猎人们

四个猎人可以一次进入洞穴。洞穴是黑暗的，所以猎人看不见，但他们可以使用其他感觉。猎人可以闻到隔壁房间里的乌姆布斯，闻到隔壁房间里的尸体，听到其他猎人在隔壁房间里移动，并听到是否有箭射入了隔壁房间。

猎人有两个动作：射击或移动。猎人可以向附近的房间或自己的房间射箭，并以类似的方式移动。

游戏玩法

在每一回合中，猎人都会先注意周围的环境，然后再动一动。移动发生在箭头之前，因此，如果将箭射入猎人要移出的房间，猎人将幸免于难。完成所有猎人动作后，将评估箭头。如果单个乘员和箭头在同一房间内，乘员将被枪杀并死亡。如果两个或两个以上的乘客共用一个房间，一个人将被随机打死。注意：尸体是乘员，因此尸体可以作为部分防护罩。

所有猎人移动后，Wumpus会做出反应。如果猎人和Wumpus一起搬进了房间，Wumpus会把他/她吃掉。如果Wumpus搬家，它也会吃掉新房间的住户。

100天后，如果猎人没有杀死Wumpus或下落不明的受害者，他们将在山洞中饿死。

代码

所有源代码都可以在这里找到。除非有人要给我写一个stdIn / stdOut适配器，否则所有提交都应使用Java。

机器人应扩展猎人类。要命名您的Hunter，请添加一个不带参数的构造函数来设置名称字段。要响应，请重写getResponse函数。在此功能中，每回合，您将通过一个5个布尔值的数组来告诉您周围的环境。

状态0 =“您闻到了呕吐物”

状态1 =“您听到了另一个猎人”

状态2 =“您闻到尸体”

状态3 =“您听到了箭声”

状态4 =“您在与您同一个房间里感到另一个猎人”

Hunter类有2个插槽：nextMove和nextDirection，分别使用枚举Move和Direction。移动可以是MOVE或SHOOT，方向可以是LEFT，RIGHT，BACK或HERE。方向是一致的，这意味着返回将始终使您返回到您之前所在的房间，并且如果从同一房间进入，则LEFT和RIGHT将始终相同。但是，如果您从另一个方向进入，则LEFT和RIGHT会将您带到不同的地方。

也可以随意实现自己的方法。记忆在整个比赛中都是持久的，这意味着您的猎人只会被构造一次。但是，在每个回合开始时，都会调用newGame（）方法来使您的猎人知道新游戏已经开始。

计分

一次有四个猎人竞争。如果被杀死，则伍珀斯毛皮价值60分，在所有幸存的猎人中平均分配。全轮巡赛风格，因此4位猎人的每个组合将一起玩。

包括5个示例Hunter：4个具有非常基本的功能，以及一个允许用户输入播放的功能，以进行测试。

如果您有任何建议/要求，请告诉我！

尽头已尽！

世界上的Wumpus人口正在以惊人的速度被猎杀。预计将于6月17日星期三通过《保护我们的臀部法案》。在此日期之后，将不再允许猎人进入洞穴，而将选择获胜者。

计分板

注意：抱歉，代码中存在一个错误，可能会导致Hunters在多个游戏中丧命。修复后，它不会对整体排名产生很大的影响，但会极大地改变统计数据。

得分不断提高，每组猎人在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)
king-of-the-hill  java 
— 该隐
source
1
你能用箭打另一个猎人吗？
— MegaTom 2015年
1
是的，或者您自己，如果您在这里射箭
— 该隐2015年
1
为什么不只传递一个0到31的值，而不是一个5个布尔值的数组int？我们在这里是大男孩，我们可以做位手术:)
— DoctorHeckle
1
@DoctorHeckle当然可以，但是拥有数组而不是单个int ^^仍然对开发人员更友好。
— Katenkyo 2015年
1
对于箭和尸体，如果一个与您同在一个房间内，您将获得与相邻状态相同的状态。猎人是您唯一可以区分在房间旁边还是在房间里的人。
— 该隐2015年

Answers:

11

纳斯卡·亨特

没有太多的逻辑。它的规则很简单：左转，焦土，重复。而且，嘿，他可能会很幸运！

6月8日编辑：

在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个独特房间的循环。由于每个房间都是唯一的，并且我们朝每个房间的每个方向射击，因此所有房间都会被射击。对于任何起步室都是如此（由我的伙伴尼尔（Neal）假设，谢谢尼尔（Neal）！）。十二面体很酷！

我想指出的是，这与我们的朋友MonsterHunter不同，因为他不尝试任何诡计或任何真正的“战术”。这样做的优点是，每个房间都被再次开火：蛮力解决方案。从理论上讲，NascarHunter有优势，因为Nascar只会打20个房间中的10个，只覆盖一半的面积。

6月11日编辑：

从NascarHunter中添加了Wumpus检测逻辑模式。应该客观地提高成绩。

package Hunters;

import Mechanics.*;

public class FullCoverageHunter extends Hunter {

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

    public FullCoverageHunter(){

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

    }

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


    public void getResponse(boolean[] status){

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

            nextMove = Move.SHOOT;

            switch( state ){

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

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

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

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

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

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

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

            }

        }else{

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

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

            }

        }

    }

}

让我知道是否有任何错误，程序包在我的IDE中表现不佳:(

— 赫克医生
source
1
我非常确定这应该称为MadMaxHunter，因为我不记得有太多涉及车辆之间开火的NASCAR比赛。好像做得好！
— 拉尔夫·马歇尔
我必须在if语句的headLeft上加上括号，以使FullCoverageHunter正常工作。您的两个机器人都做得很好-NascarHunter略胜一筹
— euanjt 2015年
FullCoverageHunter中的变量newGame似乎从未声明过。我添加了一个私有布尔型newGame，并在newGame（）方法中将其设置为true，这就是您想要的吗？
— 该隐2015年
@该隐！是的，我的疏忽大意，我要在这里编辑，我的错。
— DoctorHeckle
7

獾

他不喜欢访客。

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))];
    }
}
— 头号
source
6

埃尔默·富德

“嘘。保持安静，保持安静，我在猎狼。”

埃尔默（Elmer）专注于猎物，并且忽略了尸体和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;
    }
}
— 米奇
source
1
我认为这可能有效。您在游戏中要做的就是希望有人在得到您之前先获得了奖励，您才能获得充分的信誉。
— 拉尔夫·马歇尔
1
那是一般的想法。让其他人来做艰苦的工作：-)
— MickyT 2015年
1
这就是为什么我等你先编写代码的原因，尽管我首先想到了它：-)
— Mawg
5

怪物猎人

我们正在寻找一个怪物，我们4岁...这让我想起了我最喜欢的游戏！这位猎人将通过左右移动来遍历大部分地图，如果Wumpus在附近，他会向后引诱他，从而能够准确地确定它的位置。

我可以摆脱lastDirection，但我会保留其语义和可读性:)。实际上，它死了很多，但是控制器一开始常常将2/3猎人放置在同一房间里，并且经常在Wumpus附近（也可以在同一房间里）……所以insta死亡^^'。

package Hunters;

import Mechanics.*;

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

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

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

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

        if(nextMove==Move.MOVE)
        {
            if(shooted>0)
                walkMode=walkMode^(shooted>0);
            if(lastStatus[0]&&shooted==1)
                shooted++;
            else
                shooted=0;
            lastDirection=nextDirection;
        }
        else
            shooted++;
        for(int i=0;i<status.length;i++)
            lastStatus[i]=status[i];
    }
}
— Katenkyo
source
感谢您指出这一点，控制器已固定，因此每个乘员都有一个独特的起点
— 该隐2015年
4

起搏猎人

来回之间，到房间。如果闻到了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;
}

}

— 超级汤姆
source
4

惊吓猫

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))];
    }
}
— 斯皮卡特里克斯
source
6
大声笑我不知道这是否是故意的，但是他会射箭然后逃跑来吓scar自己。
— 该隐2015年
4

吃芽和叶子

与《熊猫书》中的语法书大相径庭，这位猎人实际上并没有吃任何东西，但是我们要么在伍普斯（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];
        }
    }
}
— 拉尔夫·马歇尔
source
3

伊多摩尼

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(){}



}
— uan
source
注意：根据@Cain的说法，如果您开枪进入自己的房间，您可能会自杀。
— DoctorHeckle
3

Emo Wumpus（猎人）

Emo Wumpuses（与有时使用枪支和飞机的Emo Wolves有关）讨厌一切（尤其是Java）。他们没有区分猎人和熊熊，并试图将它们全部射击。他们也讨厌纳斯卡赛车手，并且总是会正确射门。如果没有人在附近射击，他们会向右移动，但只会连续13次这样做，直到他们对独自一人感到沮丧并尝试射击为止（十三是不幸的数字）。在第99回合，如果他们还活着，他们将尝试自杀，因为饥饿是一种to脚的死亡方式。

Wumpuses比Wolves更大（更重），但是它仍然饿死了424字节（与NascarHunter的2.72 kb庞大相比）。

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

为什么不首先自杀呢？Emo Wumpuses认为，可以做的一件善事就是在自杀之前结束他人的痛苦。因此，在死亡之前，他们将杀死所有可能的东西。

ump？（反猎人）

嗯，Wumpus在猎人名册上做什么？这个家伙非常生气，因为有人杀死了他的亲戚，因此他决定打扮成他们中的一员并加入狩猎。他的主要目标是杀死猎人。他试图躲在尸体附近，这将使他有机会被猎人挡住。如果附近没有猎人，他将朝一个方向移动直到发现猎人为止，在这种情况下，他将尝试杀死他们，然后再朝另一个方向移动。

不幸的是，大多数熊熊都是愚蠢的，并且仍然会试图杀死他。无论如何，他认为自己的牺牲对于各地的乌节博物馆都是必要的。

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

}

— 迈克尔·布兰登·莫里斯
source
1
— Martin Ender 2015年
好东西，这不是编码高尔夫球。想知道Emo机器人要出现多久，哈哈。
— DoctorHeckle
@Martin注意，这不只是自杀。在可测试的机器人中，它排名倒数第二。
— Michael Brandon Morris
1
EmoSolution 总是很有趣！
— Mawg '17
2

Laomedon

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

对于他来说不幸的是，其他猎人并不欣赏他的技能，他们似乎向他开了很多枪。

— uan
source
2

尼尔·亨特

与我的朋友DoctorHelckle医生讨论了这一点之后，我想自己尝试一下会很有趣。使用将左右交替覆盖大部分区域的想法，然后决定添加一些对状态的响应，但仅添加0和1-无论附近是否有Wumpus或猎人。表现不如NascarHunter出色，起初让我感到惊讶。经过一番思考之后，我意识到，听到猎人/闻到乌姆普斯的声音之后，在随机方向上射箭（像这样）是不会的，因为他们在转弯时移动，因为箭头被射入房间，但是会移动在杀死他们之前进行。效果不如我想像的...但是仍然表现不错！

package Hunters;

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

public class NealHunter extends Hunter {

    private boolean goLeft;

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

    public void newGame() {
        goLeft = false;
    }

    public void getResponse(boolean[] status){

        Random rand = new Random();

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

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

            goLeft = !goLeft;
        }
    }
}
— 尼尔
source
1

白痴

这个人走直到他发现了乌贼。然后，他射门正确。如果wumpus仍在那儿，它一定在左边，所以再拍一次。在途中，他不在乎其他猎人或尸体，因此不在乎。

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;
    }
}
— 普通人
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.