महान Wumpus हंट

Question

पूर्ण

वम्पस का मौसम समाप्त हो गया है, और कई शातिर Wumpus और बहादुर हंटर के जीवन के साथ। साथ ही साथ कुछ कायर, अनैतिक और नीच मूर्ख शिकारी। लेकिन दिन के अंत में, डॉ। हेक्ले द्वारा NascarHunter सबसे लूट और महिमा के साथ आया था। हम आपको सलाम करते हैं, ओह बहादुर ... ड्राइवर?

यह Wumpuses पर खुला मौसम है, और दुनिया भर के शिकारी मूल्यवान Wumpus Pelts से समृद्ध होने की कोशिश करने के लिए Wumpus गुफाओं में आते हैं।

खेल

क्लासिक हंट पर आधारित डंपस गेम, कुछ भिन्नताओं के साथ।

नक्शा

एक डोडेकेहेड्रॉन । 20 कमरे हैं, जिनमें से प्रत्येक 3 अन्य कमरे से जुड़ा हुआ है, जो मूल रूप से बीच में पुलों के साथ 3 छल्ले बनाते हैं।

द वम्पस

वम्पस एक रहस्यमय जानवर है। कोई भी निश्चित नहीं है कि यह कैसा दिखता है, लेकिन सभी सहमत हैं कि यह क्रूर है। Wumpus गुफाओं में रहता है, और मृत चीजों को खाना पसंद करता है। यदि वम्पस के बगल में एक गुफा में एक शव है, तो वह वहां चले जाएंगे और इसे खाएंगे। यदि वम्पस एक गुफा में शिकारियों को ले जाने के लिए होता है, तो वह उसे भी मार देगा और खा जाएगा। अगर वम्पस उसके पास एक तीर सुनता है, तो वह घबरा जाएगा और एक यादृच्छिक कमरे में भाग जाएगा।

वैकल्पिक लक्षण : ये वर्तमान में खेल को और अधिक रोचक बनाने के लिए शामिल किए गए हैं, लेकिन अगर वे बहुत अधिक यादृच्छिकता जोड़ते हैं, तो उन्हें लोकप्रिय अनुरोध पर हटाया जा सकता है।

क्रोधित Wumpus: यदि Wumpus को गोली मार दी जाती है, तो उसके पास 3 दिनों तक जीवित रहने और भगदड़ करने का 20% हिस्सा होता है। जब वे उग्र होते हैं, तो वह बेतरतीब ढंग से दिन में दो बार हिलेंगे, लेकिन फिर भी लाशों की ओर आकर्षित होंगे। 3 दिनों के बाद, वह मर जाएगा। एक दूसरे तीर का शॉट भी वम्पस को मार देगा।

वंडरिंग वम्पस: प्रत्येक दिन, अगर वम्पस को और कुछ नहीं ट्रिगर किया जाता है, तो उसके पास 25% चलने की संभावना होती है।

शिकारी

एक समय में चार शिकारी गुफाओं में प्रवेश कर सकते हैं। गुफाएँ अंधेरी हैं, इसलिए शिकारी देख नहीं सकते, लेकिन वे अपनी अन्य इंद्रियों का उपयोग कर सकते हैं। शिकारी बगल के कमरे में वम्पस को सूँघ सकते हैं, बगल के कमरे में एक लाश को सूँघ सकते हैं, दूसरे शिकारियों को बगल के कमरे में जाते हुए सुन सकते हैं, और सुन सकते हैं कि एक तीर बगल के कमरे में मार दिया गया है।

शिकारी के दो कार्य हैं: गोली चलाना या चलना। एक शिकारी एक तीर को बगल के कमरे या अपने कमरे में गोली मार सकता है, और इसी तरह आगे बढ़ सकता है।

गेमप्ले

प्रत्येक दौर में, शिकारी पहले अपने परिवेश पर ध्यान देंगे, और फिर एक चाल चलेंगे। आंदोलन तीर से पहले होता है, इसलिए यदि एक तीर एक कमरे में गोली मार दी जाती है जो एक शिकारी से बाहर निकल रही है, तो शिकारी बच जाएगा। सभी शिकारी चाल चलने के बाद, तीर का मूल्यांकन किया जाता है। यदि एक एकल रहने वाला और तीर एक ही कमरे में हैं, तो कब्जा करने वाले को गोली मार दी जाएगी और मर जाएगा। यदि दो या अधिक रहने वाले एक कमरे को साझा करते हैं, तो एक बेतरतीब ढंग से मारा जाएगा और मर जाएगा। नोट: लाशें रहने वाली हैं, इसलिए एक मृत शरीर आंशिक ढाल के रूप में काम कर सकता है।

सभी शिकारी चालों के बाद, वम्पस जवाब देगा। यदि कोई शिकारी वम्पस के साथ कमरे में चला गया है, तो वम्पस उसे खा जाएगा। यदि वम्पस चलता है, तो यह नए कमरे के रहने वालों को भी खा जाएगा।

100 दिनों के बाद, यदि शिकारियों ने वम्पस को नहीं मारा है, या पीड़ित को गिरा दिया है, तो वे गुफाओं के भीतर भुखमरी से मर जाएंगे।

कोड

सभी स्रोत कोड यहां देखे जा सकते हैं । सभी प्रस्तुतियाँ जावा में होनी चाहिए, जब तक कि कोई मुझे stdIn / stdOut एडेप्टर नहीं लिखना चाहता;)

बॉट्स को हंटर क्लास का विस्तार करना चाहिए। अपने हंटर को नाम देने के लिए, एक निर्माता जोड़ें जिसमें कोई पैरामीटर नहीं है जो नाम फ़ील्ड सेट करता है। T o प्रतिक्रिया, getResponse फ़ंक्शन को ओवरराइड करें। इस फ़ंक्शन में, प्रत्येक मोड़, आपको 5 बूलियन की एक सरणी दी जाएगी जो आपको अपने परिवेश के बारे में बताती है।

स्थिति 0 = "आप एक गंध को सूंघते हैं"

स्थिति 1 = "आप एक और शिकारी सुनें"

स्थिति 2 = "आप एक लाश को सूंघते हैं"

स्थिति 3 = "आप एक तीर का आवरण सुनें"

स्थिति 4 = "आप के रूप में उसी कमरे में एक और शिकारी महसूस करते हैं"

हंटर क्लास में 2 स्लॉट हैं: नेक्स्टमोव और नेक्स्टडायरेक्शन, जो क्रमशः एनम मूव और डायरेक्शन का उपयोग करते हैं। मूव या तो मूव हो सकता है या SHOOT हो सकता है, डाइरेक्शन लेफ्ट, राइट, बैक या HERE हो सकता है। दिशाएं सुसंगत हैं, जिसका अर्थ है कि आप हमेशा उस पिछले कमरे में वापस आएँगे जहाँ आप थे, और यदि उसी कमरे से प्रवेश करते हैं, तो LEFT और RIGHT हमेशा समान रहेगी। हालाँकि, यदि आप किसी भिन्न दिशा से प्रवेश करते हैं, तो LEFT और RIGHT आपको अलग-अलग स्थानों पर ले जाएगी।

अपने स्वयं के तरीकों को भी लागू करने के लिए स्वतंत्र महसूस करें। मेमोरी पूरे टूर्नामेंट में बनी रहती है, जिसका अर्थ है कि आपका शिकारी केवल एक बार निर्माण करेगा। हालाँकि, प्रत्येक दौर की शुरुआत में, अपने शिकारी को एक नया खेल शुरू होने देने के लिए नया नाम () विधि कहा जाता है।

स्कोरिंग

एक समय में चार शिकारी प्रतिस्पर्धा करते हैं। अगर मार दिया गया, तो वम्पस पेल्ट 60 अंक के बराबर है, सभी जीवित शिकारियों के बीच समान रूप से विभाजित। पूर्ण राउंड रॉबिन शैली, इसलिए 4 शिकारी के प्रत्येक संयोजन एक साथ खेलेंगे।

5 नमूना हंटर्स शामिल हैं: 4 बहुत बुनियादी कार्यक्षमता के साथ, और एक जो उपयोगकर्ता इनपुट को परीक्षण के प्रयोजनों के लिए खेलने की अनुमति देता है।

यदि आपके कोई सुझाव / अनुरोध हैं, तो कृपया मुझे बताएं!

अंत अब सामने है!

दुनिया में वम्पस की आबादी खतरनाक दर पर शिकार हो रही है। प्रोटेक्ट अवर वम्पस एक्ट बुधवार, 17 जून को पारित होने की उम्मीद है। इस तारीख के बाद, गुफाओं में और अधिक शिकारियों की अनुमति नहीं दी जाएगी, और एक विजेता चुना जाएगा।

स्कोरबोर्ड

नोट: मेरी क्षमा याचना, कोड में एक बग था जो हंटर्स को कई खेलों के माध्यम से मृत रहने का कारण बन सकता था। इसे ठीक करने के बाद, यह समग्र रैंकिंग को बहुत अधिक नहीं बदलता है, लेकिन आँकड़े को काफी हद तक बदल देता है।

स्कोर 1000 गेम में शिकारी के प्रत्येक सेट को चलाने में हैं। NascarHunter और FullCoverageHunter पैक का नेतृत्व करते हैं, और हालांकि एंटीहंटर के अतिरिक्त ने 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)

Comments

क्या आप एक और शिकारी को तीर से मार सकते हैं?

— मेगाटॉम

Yessir, या अपने आप को अगर आप यहाँ पर एक तीर मारते हैं

— Cain

5 बूलियन के लिए एक सरणी के बजाय, क्यों न केवल एक intमूल्यवान 0-31 पास किया जाए ? हम यहां बड़े लड़के हैं, हम थोड़ा ऑपरेशन कर सकते हैं :)

— डॉक्टरहेकले

@DoctorHeckle यकीन है कि हम कर रहे हैं, लेकिन यह अभी भी एक एकल int ^ ^ के बजाय एक सरणी के लिए अधिक देव के अनुकूल है।

— केटेनको

तीरों और लाशों के लिए, यदि आप एक ही कमरे में हैं, तो आपको उसी तरह की स्थिति मिलती है जैसे कि यह आसन्न है। शिकारी केवल वे हैं जिन्हें आप कमरे के बगल में या कमरे में होने के बीच अंतर कर सकते हैं।

— कैन

Answer 1

NascarHunter

इसके लिए ज्यादा तर्क नहीं। इसके नियम सरल हैं: बाईं ओर मुड़ें, झुलसी हुई पृथ्वी, दोहराएं। और, हे, वह भाग्यशाली हो सकता है!

8 जून संपादित करें:

Nascar के लिए अतिरिक्त तर्क में जोड़ा गया है कि इसकी आखिरी चाल के सापेक्ष एक वम्पस के निकटता के कारण। थीम पर बने रहने के लिए इसे गड्ढे बंद करने पर विचार करें। अगर यह एक दालान की शूटिंग के बाद एक वम्पस समझ में आता है, तो यह अन्य दो आसन्न कमरों में से एक में आ गया होगा, क्योंकि यह गोली लगने से मरने वाले शिकारी को बस ले गई होगी। यह प्रभावी रूप से या तो वम्पस 2 को चालू करने के लिए देता है अगर यह फिर से नहीं बढ़ता है, या यदि वह एक लाश पर खड़ा है तो Nascar 1 बारी में रहने के लिए। तीसरे विकल्प के लिए भी खाता है अगर यह पहली बारी है, लेकिन सिर्फ एक बार। मैं एफसीएच के लिए अंततः पोर्ट करूंगा, व्यस्त व्यस्त।

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 की तरह बहुत अच्छा कर रहे हैं!

मैं यह बताना चाहता हूं कि यह हमारे दोस्त, मॉन्स्टर हंटर से अलग है, क्योंकि वह किसी भी तरह की चालबाजी या किसी भी वास्तविक "रणनीति" की कोशिश नहीं करता है। इस की ताकत तथ्य यह है कि हर कमरे में फिर से निकाल दिया जाता है: जानवर बल समाधान। यह NascarHunter पर एक सैद्धांतिक पैर है, क्योंकि Nascar केवल 20 कमरों में से 10 को मार देगी, जो केवल आधे क्षेत्र को कवर करेगी।

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;

            }

        }

    }

}

अगर कोई त्रुटियां हैं, तो मुझे बताएं, पैकेज मेरी आईडीई के साथ अच्छा नहीं खेला :(

Comments

मुझे पूरा यकीन है कि इसे MadMaxHunter कहा जाना चाहिए, क्योंकि मुझे वाहनों के बीच गोलाबारी से जुड़े कई NASCAR दौड़ याद नहीं हैं। अच्छा करने के लिए लगता है!

— राल्फ मार्शल

अगर काम करने के लिए FullCoverageHunter प्राप्त करने के लिए मुझे स्टेटमेंट में हेडलाइट के चारों ओर कोष्ठक लगाना था। आपके दोनों बॉट बहुत अच्छे

— NascarHunter

FullCoverageHunter में परिवर्तनशील नया नाम कभी घोषित नहीं किया गया है। मैंने एक निजी बूलियन newGame जोड़ा और newGame () विधि में इसे सही पर सेट किया है, क्या यह आपका इरादा है?

— कैन

@ कैन उफ़! हाँ, मुझ से बड़ा निरीक्षण, मैं यहाँ संपादित करूँगा, मेरा बुरा।

— डॉक्टरहेकले

Answer 2

बिज्जू

वह आगंतुकों को पसंद नहीं करता है।

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

Answer 3

एल्मर फड

"Shhh। वीवी शांत रहो, मैं शिकार कर रहा हूँ"

एल्मर शिकार पर ठीक किया जाता है और लाशों और वम्पस को छोड़कर सबकुछ अनदेखा कर देता है। वह एक लाश खोजने की कोशिश करता है और फिर वापस शूटिंग शुरू कर देता है। यदि वह एक वम्पस को सूंघता है, तो वह वापस आ जाएगा और यदि वह अभी भी उसे बदबू आ रही है तो वह गोली मार देगा।

सभी जावा प्रोग्रामर के लिए मेरी क्षमायाचना, यह शायद बहुत बदसूरत है, वाक्यविन्यास त्रुटियों से भरा है और मैंने शायद अपने तर्क को गड़बड़ कर दिया है।

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

Comments

मुझे लगता है कि यह काम कर सकता है। आपको बस एक गेम में करना है, उम्मीद है कि कोई आपको मिलने से पहले ही विकेट ले लेता है और आपको पूरा क्रेडिट मिल जाता है।

— राल्फ मार्शल

यह सामान्य विचार था। दूसरों को कड़ी मेहनत करने दें :-)

— मिकट

इसीलिए मैंने आपको इसे कोड करने के लिए इंतजार किया, भले ही मैंने इसके बारे में सबसे पहले सोचा था :-)

— मग

Answer 4

दैत्य शिकारी

हम एक राक्षस का शिकार कर रहे हैं और हम 4 हैं ... यह मुझे मेरे पसंदीदा खेल की याद दिलाता है! यह शिकारी वैकल्पिक रूप से बाएं-दाएं घूमकर अधिकांश नक्शे को चलाएगा, और अगर वम्पस पास है, तो वह उसे ठीक करने के लिए सक्षम होने के लिए पिछड़े जाकर उसे लुभाएगा।

मैं lastDirection से छुटकारा पा सकता था, लेकिन मैं शब्दार्थ और पठनीयता के लिए रखता हूँ :)। दरअसल, यह काफी हद तक मर जाता है, लेकिन नियंत्रक अक्सर शुरुआत में एक ही कमरे में 2/3 शिकारी डालता है, और अक्सर वम्पस के पास (एक ही कमरे में भी हो सकता है) ... तो इंस्टा डेथ ^ ^ '।

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

Comments

उस ओर इशारा करने के लिए धन्यवाद, नियंत्रक तय किया गया है ताकि प्रत्येक रहने वाले के लिए एक अनूठी शुरुआत हो

— कैन

Answer 5

PacingHunter

पीछे-पीछे, कमरों के बीच। यदि यह एक वम्पस को सूँघता है या एक खिलाड़ी को सुनता है जिसे वह बाएं से दाएं शूट करता है। यदि एक वेम्पस उसके बगल से शुरू होता है, तो वह कमरे में जाने से पहले उस कमरे को गोली मार देता है।

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

}

Answer 6

डरी हुई बिल्ली

डरपोक हर चीज से डरता है। यदि यह एक ढेले या लाश को सूंघता है या तीर या शिकारी को सुनता है, तो यह एक यादृच्छिक दिशा में चलता है। अन्यथा, यह बस यादृच्छिक दिशाओं में तीर शूटिंग करता रहता है।

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

Comments

Lol मुझे नहीं पता कि यह जानबूझकर था, लेकिन वह तीर मारकर खुद को डराएगा और फिर भाग जाएगा।

— कैन

Answer 7

ईट्स शूट्स एंड लीव्स

व्याकरण की पुस्तक प्रसिद्धि के पांडा के विपरीत, यह शिकारी वास्तव में कुछ भी नहीं खाता है, लेकिन हम या तो शूट करते हैं यदि वम्पस के बारे में है या हम एक निशान पर छोड़ते हैं जो हमें उम्मीद है कि हमें मंडलियों में चलने से रोकना चाहिए।

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

Answer 8

Idomeneus

आइडोमेनस काफी सरल है- अगर वम्पस या कोई अन्य शिकारी पास में है, तो वह हर जगह आग लगाता है और प्रार्थना करता है कि शिकार की देवी उसकी तरफ है। यदि वह एक लाश के पास है तो वह वम्पस के इंतजार में है। वह अन्य शिकारियों को पसंद नहीं करता है और भाग जाएगा यदि वे उसके पास तीर चलाना शुरू करते हैं, या यदि वे उसके समान कमरे में हैं। अंत में अगर वह बोर महसूस कर रहा है तो वह अनन्त गलियारों को बेतरतीब ढंग से पेस करता है।

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



}

Comments

सावधान रहें: @ कैन के अनुसार, यदि आप अपने कमरे में आग लगाते हैं तो आप खुद को गोली मार सकते हैं।

— डॉक्टर हेकल

Answer 9

इमो वंपस (हंटर)

Emo Wumpuses ( Emo Wolves से संबंधित) जो कभी-कभी बंदूक और उड़ने वाले विमानों का उपयोग करते हैं करते हैं) सब कुछ (विशेष रूप से जावा) से नफरत करते हैं। वे हंटर्स और वम्पस के बीच कोई अंतर नहीं करते हैं, और उन सभी को शूट करने की कोशिश करते हैं। वे नस्कर ड्राइवरों से भी नफरत करते हैं, और हमेशा सही गोली मारेंगे। यदि कोई भी शूटिंग के आसपास नहीं है, तो वे सही कदम उठाते हैं, लेकिन यह तेरह बार एक पंक्ति में करेंगे, इससे पहले कि वे अकेले होने के बारे में और अधिक उदास हो जाएं और खुद को गोली मारने की कोशिश करें (तेरह एक अशुभ संख्या है)। 99 साल की उम्र में, अगर वे अभी भी जीवित हैं, तो वे खुद को गोली मारने का प्रयास करेंगे क्योंकि भुखमरी मरने के लिए एक लंगड़ा रास्ता है।

भेड़ियों की तुलना में Wumpuses बड़े (और भारी) हैं, लेकिन यह अभी भी 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++;}}

सिर्फ पहली जगह में आत्महत्या क्यों नहीं? इमो वम्पस का मानना ​​है कि अच्छा काम करने वाला व्यक्ति खुद को मारने से पहले दूसरों की पीड़ा को समाप्त कर सकता है। इसलिए, वे मरने से पहले वह सब कुछ मार देंगे जो वे कर सकते हैं।

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

}

Comments

अब और मजाक नहीं।

— मार्टिन एंडर

अच्छी बात यह कोड गोल्फ नहीं है। सोच रहा था कि जब तक कोई इमो बॉट, लोल नहीं दिखाएगा, तब तक कैसा रहेगा।

— DoctorHeckle

@Martin ध्यान दें कि यह सिर्फ आत्महत्या नहीं है। परीक्षण के लिए उपलब्ध बॉट में से, यह अंतिम स्थान पर नहीं था।

— माइकल ब्रैंडन मॉरिस

EmoSolution हमेशा हास्यास्पद है!

— मावग

Answer 10

Laomedon

लोमेदॉन भटकते हुए एक लाश को खोजने की कोशिश कर रहा था। एक बार जब वह मिल जाता है और काम करता है, तो वह लाश के बगल में उसी जगह पर रहता है। जब वह वम्पस को सूंघता है तो वह कॉर्पस के कमरे में तीर मारता है।

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

दुर्भाग्य से उसके लिए, अन्य शिकारी उसके कौशल की सराहना नहीं करते हैं और वे उसे बहुत गोली मारते हैं ...

Answer 11

NealHunter

अपने दोस्त डॉक्टर हेकल के साथ इस बारे में बात करने के बाद, मैंने सोचा कि इसे स्वयं आज़माने में मज़ा आएगा। सबसे अधिक क्षेत्र को कवर करने के लिए बाएं और दाएं को वैकल्पिक करने के लिए विचार का उपयोग किया, और फिर राज्यों को थोड़ा सा जवाब देने का फैसला किया, लेकिन केवल 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;
        }
    }
}

Answer 12

WalkingIdiot

यह तब तक चलता है जब तक वह वम्पस को नहीं पाता। फिर, वह सही गोली मारता है। यदि वम्पस अभी भी है, तो यह बाईं ओर होना चाहिए, इसलिए एक बार फिर से शूट करें। रास्ते में, वह अन्य शिकारी या लाशों के बारे में परवाह नहीं करता है, इसलिए नाम।

package Hunters;

import Mechanics.*;

public class WalkingIdiot extends Hunter {
    private boolean wumpusNear = false;

    @Override
    public void newGame() {
        wumpusNear = false;
    }

    public WalkingIdiot(){
        name = "WalkingIdiot";
    }

    @Override
    public void getResponse(boolean[] status){
        boolean wumpusWasNear = wumpusNear;
        wumpusNear = status[0];
        if (status[0]) {
            nextMove = Move.SHOOT;
            if (wumpusWasNear) {
                nextDirection = Direction.LEFT;
            } else {
                nextDirection = Direction.RIGHT;
            }
            return;
        }
        nextMove = Move.MOVE;
        nextDirection = Math.random() < 0.5 ? Direction.LEFT : Direction.RIGHT;
    }
}

रहना

ठहरना पसंद नहीं है। यह बस के आसपास गोली मारता है और याद करता है अगर उसने एक शिकारी को गोली मार दी।

package Hunters;

import Mechanics.*;

public class Stay extends Hunter {
    private Direction lastShot = Direction.LEFT;
    private Direction corpse = null;
    private boolean hunterNear = false;

    public Stay(){
        name = "Stay";
    }

    @Override
    public void newGame() {
        corpse = null;
        hunterNear = false;
        lastShot = Direction.LEFT;
    }

    @Override
    public void getResponse(boolean[] status){
        nextMove = Move.SHOOT;//always
        boolean hunterWasNear = hunterNear;
        hunterNear = status[1];

        if (hunterWasNear && status[2] && !status[1]) {
            corpse = lastShot;
        }

        if (status[0]) {
            if (corpse != null) {
                nextDirection = corpse;
                return;
            }
        }
        if ((status[1] && !status[4]) || status[0]) {
            switch (lastShot) {
                case LEFT: lastShot = nextDirection = Direction.RIGHT; break;
                case RIGHT: lastShot = nextDirection = Direction.BACK; break;
                case BACK: lastShot = nextDirection = Direction.LEFT; break;
            }
            return;
        }

        //default
        lastShot = nextDirection = Direction.LEFT;
    }
}