कैमल अप कप: एक एआई बोर्ड गेम टूर्नामेंट

कपल कप 2k18

इस चुनौती में, हम सेमी-पॉपुलर बोर्ड गेम कैमल अप खेलेंगे।

ऊंट ऊपर! एक बोर्ड गेम है जिसमें खिलाड़ियों को ऊंटों पर दांव लगाने, राउंड जीतने, गेम जीतने या गेम हारने, जाल को प्रभावित करने या एक ऊंट को स्थानांतरित करने के लिए सेट किया गया है। इनमें से प्रत्येक निर्णय आपको कुछ धन प्राप्त करने के अवसर से पुरस्कृत करता है, जो कि विजेता को निर्धारित करता है। खिलाड़ियों को अपने निर्णय लेने के लिए संभाव्यता, खेल-राज्य के विचारों और प्रतिद्वंद्वी किरायेदारी का उपयोग करना चाहिए। यहां एक छोटा वीडियो है जिसमें खिलाड़ियों को दिखाया जाता है कि कैसे खेलना है ।

कैसे खेलें

यहाँ कैसे खेलने के लिए एक मोटा विचार है। किसी एक वीडियो को देखना अधिक मददगार हो सकता है क्योंकि उनके पास दृश्य हैं :)

अपनी बारी पर आपके पास 4 विकल्प हैं।

एक ऊंट को हिलाओ। यह उन लोगों से ऊंट उठाता है जो स्थानांतरित नहीं हुए हैं और इसे 1-3 स्थानों के बीच स्थानांतरित करते हैं। आपको 1 सिक्का मिलता है। सभी पाँच ऊँटों के चले जाने पर घाव समाप्त हो जाते हैं, फिर वे सभी चल सकते हैं
एक जाल रखें। यह गोल के अंत तक बोर्ड पर जाता है। आप + 1 / -1 ट्रैप चुनें। यदि ऊंट या ऊँट उस पर ज़मीन रखते हैं तो वे + 1 / -1 चलते हैं और आपको एक सिक्का मिलता है। आप वर्ग 0. पर एक जाल नहीं रख सकते। आप एक जाल बिछा सकते हैं जहाँ ऊँट होते हैं, हालाँकि यह ऊँटों को प्रभावित करेगा जो इसके बाद उस पर उतरते हैं।
गोल विजेता बाजी। आप एक गोल विजेता पर दांव लगाते हैं। वे जीतते हैं कि आप 5/3/2/1 पर निर्भर करते हैं कि आप उस ऊंट पर दांव लगाने के लिए 1/2 / 3rd थे।
खेल विजेता / हारे हुए। आप इस बात पर दांव लगाते हैं कि खेल के अंत में कौन पहले या अंतिम स्थान पर रहेगा। यदि आप उस ऊँट को दांव पर लगाने के लिए 8/5/3/1/1 (मुझे लगता है) पर आधारित हैं

टिप्पणियाँ:

5 ऊंट हैं। वे 0-2 से बेतरतीब ढंग से एक स्थिति पर शुरू करते हैं।
जब एक ऊंट को स्थानांतरित किया जाता है (ऊपर जो इसके लिए ट्रिगर होता है उसके लिए देखें) वे 1-3 वर्गों को स्थानांतरित करते हैं। यदि उन्हें दूसरे ऊंट के साथ एक वर्ग पर रखा जाता है, तो उन्हें दूसरे के "शीर्ष" पर रखा जाता है, जिससे ऊंट का ढेर बन जाता है। अगर एक ऊंट को स्थानांतरित करना है तो वह ऊंट के ऊपर सभी ऊंटों को ले जाए। स्टैक के शीर्ष पर ऊंट को लीड में माना जाता है
यदि आप +1 ट्रैप पर उतरते हैं (ऊपर देखें कि इससे क्या ट्रिगर होता है) तो आप एक वर्ग को आगे बढ़ाते हैं। मानक स्टैकिंग नियम लागू होते हैं।
हालाँकि यदि आप -1 ट्रैप से टकराते हैं तो आप एक वर्ग को पीछे की ओर ले जाते हैं। आप ऊंटों के ढेर के नीचे जाते हैं, जो उस वर्ग पर हैं, यदि कोई हो।
जब ऊंट 16 वर्ग में आता है तो खेल समाप्त हो जाता है। यह तुरंत राउंड एंड और गेम एंड ट्रिगर्स को आमंत्रित करता है
खेल विजेता / हारे हुए दांव को केवल एक बार ऊंट के अनुसार किया जा सकता है। यानी आप गेम जीतने और हारने के लिए ऊंट पर दांव नहीं लगा सकते

चुनौती

इस चुनौती में, आप एक चार खिलाड़ी खेलने के लिए पायथन 3 कार्यक्रम लिखेंगे, विजेता ऊंट के सभी शानदार खेल लेता है

आपके कार्यक्रम को गेमस्टेट प्राप्त होगा, जिसमें निम्न शामिल हैं:

ऊंट_ट्रैकट : ऊंटों के स्थानों के साथ
trap_track : जाल के स्थान के साथ (फार्म की प्रविष्टि [trap_type (-1,1), खिलाड़ी])
player_has_placed_trap : एक सरणी आपको बताती है कि क्या खिलाड़ियों ने इस दौर में एक जाल रखा है
राउंड_बेट्स : बेटों की एक सरणी ने इस दौर को रखा। फॉर्म का [ऊंट, खिलाड़ी]
game_winner_bets / game_loser_bets : गेम जीतने या हारने के लिए ऊंटों के लिए बनाए गए दांव खिलाड़ियों के सरणियाँ। आप केवल उन खिलाड़ियों के मूल्य देख पाएंगे जिन्होंने दांव लगाया था, न कि वे जिन्होंने दांव लगाया था। आप जान सकते हैं कि आप किस पर दांव लगाते हैं। # फॉर्म के लिए [ऊंट, खिलाड़ी]
player_game_bets : game_winner_bets / game_loser_bets का एक और प्रतिनिधित्व। फिर, केवल उन दांव को देखें जो आपके बॉट ने बनाए थे।
player_money_values : प्रत्येक खिलाड़ी के पास धनराशि दिखाने वाली एक सरणी।
camel_yet_to_move : एक सरणी दिखा रहा है कि क्या एक ऊंट इस दौर में चला गया है।

गेमस्टेट के शीर्ष पर भी आपको मिलता है:

खिलाड़ी : एक पूर्णांक आपको बताता है कि आप किस खिलाड़ी की संख्या (0-3) हैं।

खिलाड़ियों को क्या लौटाना चाहिए, इसके लिए सिंटैक्स:

[०]: हटो ऊंट
[1, trap_type, trap_location]: प्लेस ट्रैप
[२, प्रोजेक्टेड_रेड_विनर]: राउंड विनर बेट बनाएं
[3, अनुमानित_गेम_विनर]: गेम विनर बेट बनाओ
[४, प्रक्षेपित_गेमोसोलर]: गेम को हारिएर बेट

इसे एक चाल (खिलाड़ी, गेमस्टेट) विधि में लपेटा जाना चाहिए

उदाहरण के लिए, यहां एक खिलाड़ी है जो अंतिम स्थान पर होने पर एक गोल विजेता दांव लगाएगा। यदि वे नहीं हैं, तो वे एक यादृच्छिक वर्ग पर एक जाल डाल देंगे।

class Player1(PlayerInterface):
     def move(player,g):
         if min(g.player_money_values) == g.player_money_values[player]:
            return [2,random.randint(0,len(g.camels)-1)]
        return [1,math.floor(2*random.random())*2-1,random.randint(1,10)]

खेल को कई कारणों से चुना गया था: इसमें विकल्पों में से एक अपेक्षाकृत छोटा पूल है (लगभग 20 विकल्प प्रति बारी, आसानी से लगभग 3-4 के लिए नीचे संकुचित), खेल कम हैं और भाग्य का एक तत्व है (इसे बनाता है) तो भी "बुरा" बॉट जीत सकते हैं)।

गेमप्ले

टूर्नामेंट धावक यहां पाया जा सकता है: ऊंट-कप । खेल चलाने के camelup.pyलिए एक टूर्नामेंट या फ़ंक्शन PlayGame चलाने के लिए चलाएँ। मैं उस रिपॉजिटरी को नए सबमिशन के साथ अपडेट करता रहूंगा। उदाहरण कार्यक्रम में पाया जा सकता है players.py।

एक टूर्नामेंट में प्रति 10 खिलाड़ियों में 100 खेल होते हैं (गोल किया जाता है, इसलिए 14 खिलाड़ियों का मतलब है 200 खेल)। प्रत्येक खेल चार पदों को भरने के लिए खिलाड़ियों के पूल से चुने गए चार यादृच्छिक खिलाड़ी होंगे। खिलाड़ी दो बार खेल में नहीं हो पाएंगे।

स्कोरिंग

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

जमा किए गए खिलाड़ियों को पूल में जोड़ा जाएगा। मैंने तीन वास्तव में गूंगा बॉट जोड़ा और एक जिसे मैंने शुरू करने के लिए बनाया था।

चेतावनियां

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

अपने बॉट द्वारा उठाए गए समय को ~ 10s प्रति मोड़ तक सीमित करें।

प्रस्तुतियाँ पहले के सबमिशन की नकल नहीं कर सकती हैं।

कृपया अन्य खिलाड़ियों के game_winner या game_loser दांव न देखें। यह बहुत आसान है लेकिन अभी भी धोखा दे रहा है।

यदि आपका कोई प्रश्न है, तो कृपया पूछिए।

जीतना

नई प्रस्तुतियाँ तैनात होने के बाद प्रतियोगिता अनिश्चित काल तक खुली रहेगी। हालाँकि, मैं इस सवाल के पोस्ट किए जाने के एक महीने बाद (20 जुलाई) परिणामों के आधार पर एक विजेता (एक उत्तर स्वीकार करूंगा) की घोषणा करूंगा।

परिणाम

Player0: 12
Player1: 0
Player2: 1
Sir_Humpfree_Bogart: 87

king-of-the-hill python board-game

— टायलर बैरन
स्रोत

शायद मैं इसे पढ़ता हूं, लेकिन खेलने के लिए कितने ऊंट हैं? इसके अलावा, दूसरी तरफ जाने के लिए उन्हें कितने चौकों पर यात्रा करनी होगी? आपके GitHub कोड के आधार पर मुझे पूरा यकीन है कि यह 5 ऊंट और 25 वर्ग का है, लेकिन मैंने इसे चुनौती विवरण में उल्लेखित नहीं देखा। दांव लगाने के लिए, क्या हम किसी भी राशि को दांव पर लगा सकते हैं, या यह डिफ़ॉल्ट रूप से 1 दांव लगाएगा? क्या हमारे पास खर्च की सीमा है, या हम हर दौर को अनिश्चित काल तक दांव पर लगा सकते हैं? ऊँट को चलाने वाले खिलाड़ियों के लिए, किस ऊँट को ले जाया जाता है? ऊंट आपके मेल खिलाडी-एनआर के साथ? यदि हाँ, तो 4 खिलाड़ी क्यों हैं लेकिन 5 ऊंट हैं?

— केविन क्रूज़सेन

Perl जवाब देने के लिए एकदम सही होगा

— यादृच्छिक आदमी

PPCG में आपका स्वागत है!

— AdmBorkBork

प्रति 10 खिलाड़ियों में 100 गेम बहुत कम आईएमओ लगता है, विशेष रूप से इतने यादृच्छिकता के साथ एक खेल के साथ

— नाथन मेरिल

@AdmBorkBork धन्यवाद! मैं इसके लिए नया हूँ इसलिए सभी संकेतकर्ताओं का स्वागत करता हूँ। यह वास्तविक जीवन में अच्छी तरह से काम करता है - यह देखने के लिए कि वह यहां कैसे खेलता है

— टायलर बैरन

`Sir_Humpfree_Bogart.py`

यह एक बॉट है जिसे मैंने कैमल अप कप टूर्नामेंट के लिए बनाया था ।

सबसे पहले, वे उन सभी संभावित विन्यासों को देखते हैं जो ऊंट गोल के अंत में समाप्त हो सकते थे। फिर वे एक ऊंट पर दांव लगाने के अपेक्षित मूल्य का निर्धारण करते हैं, जिसका उपयोग करके गोल जीतते हैं

EV_roundwin = (chance_1st)*(payout) + (chance_2nd)*(payout) - (chance_3rd_or_worse)*(cost)

फिर वे ऊंटों को बेतरतीब ढंग से हिलाते हैं जब तक कि एक ऊंट जीत नहीं जाता। कुछ हज़ार बार ऐसा करने के बाद आप अनुमान लगा सकते हैं कि प्रत्येक ऊंट जीत जाएगा और हार जाएगा। दोबारा, हमें इन उपयोगों के अपेक्षित मूल्य मिलते हैं

EV_gamewin = (chance_1st)*(payout) - (chance_2nd_or_worse)*(cost)

केवल अन्य विकल्प एक ऊंट को आगे बढ़ा रहे हैं (जो हमेशा एक सिक्के की पैदावार करता है, इसलिए इसका अपेक्षित मूल्य एक है) और एक जाल रखकर। दोनों टीमों ने महसूस किया कि जाल को पूरी तरह से नजरअंदाज करना एक कमजोर विकल्प था। इस जानकारी के साथ बॉट्स ने उच्चतम अपेक्षित मूल्य के साथ विकल्प चुना।

चूंकि टूर्नामेंट ने दूसरे स्थान को अंतिम स्थान के रूप में देखा था, इसलिए अंतिम स्थान के खत्म होने के साथ ही यह समझ में आता है कि क्या आप पहले स्थान पर आने की संभावना रखते हैं। SBH ने यह निर्धारित करने के लिए दूरी_from_first_place और nearness_to_end का उपयोग किया कि बॉट कितना जोखिम भरा होना चाहिए, जहां अगर आप पहले से दूर हैं और अंत तक बंद हैं तो जोखिम अधिक होगा और यदि आप खेल के अंत से पहले या दूर हैं तो जोखिम कम होगा । कम जोखिम के साथ बॉट एक उच्च प्रत्याशित मूल्य विकल्प के साथ एक कार्रवाई का फैसला करेगा और एक उच्च जोखिम के साथ विकल्प देने वाला उच्च जोखिम होगा। सटीक समीकरण था

Functional_EV = EV + (upshot-EV) * riskiness

जहां अपशॉट उच्चतम भुगतान है, आप एक निर्णय से प्राप्त कर सकते हैं और जोखिम 0 से 1 तक है।

— टायलर बैरन
स्रोत

`players.py`

टूर्नामेंट में जाने के लिए ये अविश्वसनीय रूप से गूंगे बॉट हैं। उनके पास लगभग कोई तर्क नहीं है लेकिन लोगों के उपयोग के लिए रूपरेखा के रूप में कार्य करते हैं

import random
import math
from playerinterface import PlayerInterface

class Player0(PlayerInterface):
    def move(player,g):
        #This dumb player always moves a camel
        return [0]

class Player1(PlayerInterface):
    def move(player,g):
        #This player is less dumb. If they have the least amount of money they'll make a round winner bet
        #If they aren't in last then they'll place a trap on a random square. Still p dumb though
        if min(g.player_money_values) == g.player_money_values[player]:
            return [2,random.randint(0,len(g.camels)-1)]
        return [1,math.floor(2*random.random())*2-1,random.randint(1,10)]

class Player2(PlayerInterface):
    def move(player,g):
        #This dumb player always makes a round winner bet
        return [2,random.randint(0,len(g.camels)-1)]

— टायलर बैरन
स्रोत