সিম্পল পাজাক (ওল্ড রিপাবলিকের নাইটস থেকে স্টার ওয়ার্স কার্ড গেম)


11

স্টার ওয়ার্স মহাবিশ্বের এক কার্ড গেমটি পাজাক । এটি ব্ল্যাকজ্যাকের মতো, দু'জন খেলোয়াড় একে অপরের বিপক্ষে পিছু হটতে না পেরে মোট বিশটিতে পৌঁছানোর চেষ্টা করেছিল। প্রত্যেক খেলোয়াড়ের নিজস্ব চারটি কার্ডের একটি "সাইড ডেক" থাকে যা তারা তাদের স্কোরটি সংশোধন করতে ব্যবহার করতে পারে।

লিডারবোর্ড

6/17/2015 @ 16:40 ইডিটি হিসাবে

সম্পাদনা করুন: নেপ্টর প্রতারণার জন্য অযোগ্য ঘোষণা করা হয়েছে। স্কোর যত তাড়াতাড়ি সম্ভব স্থির করা হবে ...

  1. এনইপিটিআর: 4 424,000
  2. সিনসিনাটি কিড: 2 422,000
  3. নেস্টর: 8 408,000
  4. অস্টিন শক্তি: 405,000 ডলার
  5. বাসটিলা: 8 248,000
  6. বোবা সতর্ক খেলোয়াড়: 7 107,000
  7. বোবা বোল্ড প্লেয়ার: ~ 87,000

মক পজাক কাপ প্লে অফস

যত তাড়াতাড়ি সম্ভব আপডেট করা হবে।

এক রাউন্ড - নেস্টর বনাম বাসটিলা এবং অস্টিন শক্তি বনাম সিনসিনাটি কিড

রাউন্ড 1 ফলাফল

দ্বিতীয় রাউন্ড - নেস্টর বনাম অস্টিন শক্তি এবং দ্য সিনসিনাটি কিড বনাম বাসতিলা

রাউন্ড 2 ফলাফল

বলবিজ্ঞান

গেমপ্লে ঘুরে দেখা যায়। খেলোয়াড়ের একজনকে মূল (বাড়ি) ডেক থেকে একটি কার্ড দেওয়া হয়। বাড়ির ডেকটি চল্লিশটি কার্ড ধারণ করে: একটির দশটি দশ কপি 10 টি কার্ড দেওয়ার পরে তারা তাদের পালাটি শেষ করে এবং পরবর্তী কার্ডটি নতুন কার্ড গ্রহণ করতে, তাদের বর্তমান মানটিতে দাঁড়াতে বা তাদের পাশের ডেক থেকে একটি কার্ড খেলতে এবং বেছে নিতে পারে নতুন মান দাঁড়ানো। প্লেয়ারের পরে তারা সিদ্ধান্ত নিতে পারে যে তারা কী করতে চায়, প্লেয়ার দুটি প্রক্রিয়াটি পুনরাবৃত্তি করে।

উভয় খেলোয়াড় একবার গেলে, হাতগুলি মূল্যায়ন করা হয়। যদি কোনও খেলোয়াড় বোমা ফাটিয়ে (বিশের বেশি হয়ে যায়), তবে অন্য খেলোয়াড় জিতবে, তবে তারা যদি বোমা ফেলা না হয়। কোনও খেলোয়াড় যদি দাঁড়াতে পছন্দ করে এবং অন্য খেলোয়াড়ের হাতের মূল্য বেশি হয় তবে অন্য খেলোয়াড় জিততে পারে। উভয় খেলোয়াড় যদি দাঁড়াতে বেছে নেন তবে উচ্চতর মূল্যযুক্ত প্লেয়ারটি জিতবে। টাই হওয়ার সময় কোনও খেলোয়াড়ই জয় পায় না।

প্রদত্ত একটি বিজয়ী শর্ত পূরণ করা হয় নি, খেলুন পুনরাবৃত্তি হবে। কোনও খেলোয়াড় যদি তাদের পালা শেষ করতে বেছে নেন তবে তারা একটি নতুন কার্ড পাবেন এবং একটি নতুন পছন্দ করতে পারেন। যদি তারা দাঁড়ানোর সিদ্ধান্ত নিয়ে থাকে বা তারা যদি তাদের পাশের ডেক থেকে কোনও কার্ড খেলেন তবে তাদের কোনও নতুন কার্ড মোকাবেলা করা হবে না এবং কোনও নতুন ক্রিয়া চয়ন করতে পারবেন না।

কোনও খেলোয়াড় গেমটি জিত না হওয়া পর্যন্ত প্লেটি এভাবে চলতে থাকে। গেমসটি সেরা-তিন-পাঁচ-পাঁচটি সেটে খেলা হয়।

"সরল" পাজাক কেন?

স্টার ওয়ার্স মহাবিশ্বে, পাজাক জুয়া খেলতে জড়িত। যদিও এই জাতীয় সিস্টেম অন্তর্ভুক্তি গেমটিতে আরও গতিশীল যোগ করে, প্রথমবারের কোএটিএইচ প্রতিযোগিতার জন্য এটি কিছুটা জটিল।

"রিয়েল" পাজাকের পাশের ডেকগুলি খেলোয়াড়রা নিজেরাই সরবরাহ করেছিলেন এবং এতে নেতিবাচক কার্ড, পজিটিভ-বা নেতিবাচক কার্ড, ফ্লিপ কার্ড, ডাবল কার্ড এবং টাইব্রেকার কার্ডের মতো বিভিন্ন কার্ডের বিকল্প অন্তর্ভুক্ত থাকতে পারে। এগুলি গেমটিকে আরও আকর্ষণীয় করে তুলবে, তবে জুয়া খেলার ইন্টারফেসের প্রয়োজন হবে এবং প্রতিযোগীদের বাইরে অনেক বেশি প্রয়োজন। এই সরল পাজাক গেমটিতে প্রতিটি খেলোয়াড় একই পার্শ্বের ডেক পান: একটির পাঁচটির মধ্যে দুটি কপি, যা থেকে চারটি এলোমেলোভাবে নির্বাচিত হয়।

এই গেমটির সাফল্যের উপর নির্ভর করে আমি একটি উন্নত সংস্করণ বিকাশের প্রচেষ্টা চালিয়ে যেতে পারি যার মধ্যে জুয়া এবং কাস্টম সাইড ডেকগুলি সম্ভব are

খেলোয়াড়দের

এই গেমের প্লেয়ারগুলি আপনার দ্বারা ডিজাইন করা বট হবে। প্রতিটি বটকে প্লেয়ার শ্রেণি প্রসারিত করতে হবে, মেকানিক্স প্যাকেজটি আমদানি করতে হবে এবং প্লেয়ার প্যাকেজে এভাবে থাকতে হবে:

package Players;

import java.util.Collection;

import Mechanics.*;

public class DemoPlayer extends Player {

    public DemoPlayer() {
        name = "Your Name Here";
    }

    public void getResponse(int wins[], boolean isPlayerOne,
            Collection<Card> yourHand, Collection<Card> opponentHand,
            Collection<Card> yourSideDeck, int opponentSideDeckCount,
            Action opponentAction, boolean opponentDidPlay) {
        action = null;
        cardToPlay = null;
    }
}

প্রতিটি রাউন্ডে, কন্ট্রোলার আপনার বটের জন্য getResponse পদ্ধতিটি কল করবে, যদি না আপনার বট আগেই নির্দেশ করে যে এটি দাঁড়াতে চায়। GetResponse পদ্ধতিটি দুটি বৈশিষ্ট্য নির্ধারণ করতে পারে: একটি ক্রিয়া এবং খেলতে কার্ড। ক্রিয়া নিম্নলিখিতগুলির মধ্যে একটি হতে পারে:

  • সমাপ্তি: টার্নটি শেষ হয় এবং পরবর্তী বারের জন্য একটি নতুন কার্ড আঁকুন।
  • স্ট্যান্ড: বর্তমান হাত মান ধরে। কার্ড আঁকবে না।
  • খেলুন: পাশের ডেক থেকে একটি কার্ড খায় এবং তারপরে দাঁড়িয়ে।

আপনি খেলতে প্লেতে অ্যাকশনটি সেট করলে খেলতে কার্ডটি স্পষ্টতই গুরুত্বপূর্ণ importance এটি একটি কার্ড অবজেক্ট নেয়। আপনি যে কার্ড অবজেক্টটি এতে পাস করেছেন তা যদি আপনার পাশের ডেকে উপস্থিত না থাকে তবে পরিবর্তে আপনার বটটি স্ট্যান্ড হবে।

আপনার বট প্রতিটি পয়েন্ট প্যারামিটারগুলি পান:

  • প্রতিটি খেলোয়াড়ের জয়যুক্ত একটি অ্যারে। জিতেছে [0] প্লেয়ার 1 এর, বিজয় 1 প্লেয়ার 2 এর (int [])
  • আপনার বট প্লেয়ার একজন (না বুলিয়ান)
  • আপনার এতদূর পর্যন্ত যে কার্ডগুলি व्यवहार করা হয়েছে তার একটি সংগ্রহ (সংগ্রহ)
  • আপনার প্রতিদ্বন্দ্বী কার্ডগুলি সংগ্রহের জন্য এতদূর মোকাবেলা করা হয়েছে (সংগ্রহ)
  • আপনার পাশের ডেকে কার্ড সংগ্রহ (সংগ্রহ)
  • আপনার প্রতিপক্ষের পাশের ডেকে থাকা কার্ডগুলির সংখ্যা (ইন্ট)
  • আপনার প্রতিপক্ষ সর্বশেষে করা ক্রিয়া (ক্রিয়া) [দ্রষ্টব্য: এটি হয় শেষ হবে বা স্ট্যান্ড হবে, কখনই খেলবে না]
  • আপনার প্রতিপক্ষ একটি কার্ড খেলল বা না (বুলেটিয়ান)

বট বিধি

আপনার বটগুলি কেবল getResponse পদ্ধতির মাধ্যমে তাদের দেওয়া তথ্য ব্যবহার করতে পারে। তাদের অন্য কোনও শ্রেণির সাথে যোগাযোগের চেষ্টা করা উচিত নয়। রাউন্ডগুলির মধ্যে ডেটা সঞ্চয় করতে তারা একক ফাইলে লিখতে পারে। তাদের পছন্দসই হিসাবে কোনও কাস্টম পদ্ধতি, বৈশিষ্ট্য ইত্যাদি থাকতে পারে। তাদের একটি যুক্তিসঙ্গত সময়ে চালানো উচিত (প্রোগ্রামটি যদি বাস্তবিকভাবে তাত্ক্ষণিকভাবে না চালানো হয় তবে আমি লক্ষ্য করব যে কিছু ভুল আছে)।

আপনি যদি কোডটিতে কোনও ধরণের শোষণ খুঁজে পান তবে আপনাকে "নিজেকে ভিতরে ফিরিয়ে আনার" জন্য পুরস্কৃত করা হবে। যদি আমি প্রথমে শোষণটি লক্ষ্য করি তবে আমি এটি ঠিক করব এবং আপনি কোনও পুরস্কার পাবেন না।

গণদেবতা

কন্ট্রোলারের বট লেখার দরকার নেই, কারণ এই পোস্টে ইতিমধ্যে সমস্ত কিছু ব্যাখ্যা করা আছে। তবে, আপনি যদি পরীক্ষা করতে চান তবে এটি এখানে পাওয়া যাবে: https://github.com/PhantomJedi759/simplepazaak দুটি বেসিক বট অন্তর্ভুক্ত রয়েছে। "বুদ্ধিমান" প্রতিপক্ষের বিরুদ্ধে উভয়কেই ভালভাবে ধরে রাখা উচিত নয়, কারণ তারা কেবল শেষ এবং স্ট্যান্ডের মধ্যে বেছে নেয়। তারা কী করে তার একটি নমুনা রান এখানে দেওয়া হল:

New Game!
The standings are 0 to 0
Dumb Bold Player's Hand: []
Dumb Bold Player's new Hand: [2]
Dumb Bold Player has chosen to END
Dumb Cautious Player's Hand: []
Dumb Cautious Player's new Hand: [8]
Dumb Cautious Player has chosen to END
Dumb Bold Player's Hand: [2]
Dumb Bold Player's new Hand: [2, 8]
Dumb Bold Player has chosen to END
Dumb Cautious Player's Hand: [8]
Dumb Cautious Player's new Hand: [8, 3]
Dumb Cautious Player has chosen to END
Dumb Bold Player's Hand: [2, 8]
Dumb Bold Player's new Hand: [2, 8, 7]
Dumb Bold Player has chosen to END
Dumb Cautious Player's Hand: [8, 3]
Dumb Cautious Player's new Hand: [8, 3, 6]
Dumb Cautious Player has chosen to STAND
Dumb Bold Player's Hand: [2, 8, 7]
Dumb Bold Player's new Hand: [2, 8, 7, 6]
Dumb Bold Player has chosen to STAND
Dumb Cautious Player's Hand: [8, 3, 6]
Dumb Cautious Player has chosen to STAND
Dumb Bold Player has bombed out! Dumb Cautious Player wins!

যেহেতু এই বটগুলি সম্পূর্ণরূপে ড্রয়ের ভাগ্যের উপর নির্ভর করে, তাদের জয়ের-হারের অনুপাতগুলি বিস্তরভাবে পরিবর্তিত হতে পারে। দক্ষতা কীভাবে গেমটির ভাগ্যকে মোকাবেলা করতে পারে তা দেখতে আকর্ষণীয় হবে।

আপনার যা প্রয়োজন তা হ'ল! কিছু বট তৈরি করতে যান!

বিধি বিধি

মূল ডেক চল্লিশ কার্ড: 4x1-10 এটি প্রতিটি হাতের শুরুতে রদবদল করা হয়।

কোনও খেলোয়াড়ের সাইড ডেকের চারটি কার্ড রয়েছে, 2x1-5 এর মধ্যে এলোমেলোভাবে নির্বাচিত। পাশের ডেক হাতের মধ্যে স্থির থাকে।

পাঁচজনের মধ্যে সেরা তিনজনের জন্য খেলাগুলিতে হাত খেলা হয়। জিতে থাকা মোট গেমের সংখ্যা এবং তারপরে মোট হাতের সংখ্যা অনুসারে বটস স্কোর করা হয়।

ম্যাচিং হ্যান্ডল করা হয় যাতে প্রতিটি খেলোয়াড়কে প্রতি অন্য খেলোয়াড়ের বিরুদ্ধে 100,000 গেম খেলতে হয়।

পাজাক কাপে, এলিমিনেশন-স্টাইলের রাউন্ডগুলি সংকীর্ণ করবে সবচেয়ে ভাল পাজাক বট আসলে কে। বোটগুলির প্রতিটি জুটি 100,000 গেমের সাতটি-বাহির সেরা চার-এর জন্য খেলবে। যে চারটি জিতবে সে মইটিকে পরবর্তী প্রতিপক্ষের কাছে নিয়ে যাবে এবং হেরে যাওয়া লোকেরা অনুক্রমিক র‌্যাঙ্কিংয়ের জন্য লড়াইয়ে নামবে। গেমপ্লেয়ের এই স্টাইলটি সর্বাধিক ন্যায্য, কারণ বটগুলি নির্দিষ্ট বিরোধীদের অন্যদের বিরুদ্ধে ক্ষমতার অভাবের জন্য ক্ষতিপূরণ দিতে "উইন-ফার্ম" করতে পারে না। কমপক্ষে আটটি জমা দেওয়া বট থাকুক, 3 জুলাই শুক্রবার পাজাক কাপ অনুষ্ঠিত হবে। বিজয়ী সঠিক উত্তর স্থিতি এবং অ্যাডভান্সড পাজাকের একটি প্রারম্ভিক বোনাস পাবেন, যা আশা করি পাজাক কাপ অনুষ্ঠিত হওয়ার সাথে সাথে একই সময়ে প্রস্তুত হয়ে উঠবে।


1
রেপো অ্যাক্সেস করার চেষ্টা করা দুঃখের সাথে ক্রোমে আমাকে সুরক্ষা সতর্কতা দেয়। এটি সত্যিই একটি মজাদার চ্যালেঞ্জের মতো বলে মনে হচ্ছে যা আমি প্রবেশ করতে চাই তবে ডকুমেন্টের পরিবর্তে আমি কিছু স্পষ্টতা চাই। বাড়ির ডেক প্রতিটি রাউন্ডের শুরুতে একই 40 টি কার্ড দিয়ে শুরু হয়, তাই না? আমাদের 4 কার্ড সাইড ডেক কোনও কার্ড 1-10 হতে পারে এবং বাড়ির ডেককে প্রভাবিত করে না? উভয় হাত getResponse মাধ্যমে দৃশ্যমান? আমরা কি জিতে থাকা # হাতে স্কোর করতে যাচ্ছি, বা 5 টি ফরম্যাটের মতো সেরা রাউন্ডগুলি রয়েছে? মূলত, কেন জয়গুলির # জোট রেসপন্সে পাস হয়?
ডক্টরহেকল

ডেক কখন রিসেট হয়? প্রতি রাউন্ডের পরে নাকি প্রতিটি প্রতিপক্ষের সাথে?
ইউয়ানজট

1
এটি প্লেয়ার 2 এর জয়ের জন্য [1] জিততে হবে, জিততে হবে না [2] কারণ জয়ের মাত্র একটি অ্যারে দৈর্ঘ্য 2
ইউনজট

রেডিও সম্পর্কে @ ডক্টরহেকল ক্ষমা আমার বর্তমান নেটওয়ার্ক গিথুবকে ব্লক করে, তবে আমি যত তাড়াতাড়ি সম্ভব এটি সেখানে পৌঁছে দেওয়ার চেষ্টা করব। ডেক প্রতিটি খেলা পুনরায় সেট করা হয়। পার্শ্ব ডেক 2x1-5 এর চারটি কার্ড ধারণ করে। আসল প্রতিযোগিতাটি শুরু হওয়ার পরে, আপনি পাঁচটির মধ্যে সেরা যা ট্যুরনিতে তৈরি হবে scored আপনার বট যদি খেলার স্টাইলটি টুর্নির জয়লাভ বা হারাতে পারে তার উপর নির্ভর করে প্লে স্টাইলটি পরিবর্তন করতে চাইলে বিজয়ের সংখ্যা getResponse পদ্ধতিতে পাস হয়।
মাইকেল ব্র্যান্ডন মরিস

1
আমি জানি না যে কোনও উত্তর সম্পাদনা করা হলে স্ট্যাকওভারফ্লো আপনাকে सूचित করে কিনা তবে আমার কাছে এখন পোস্ট করা দ্য সিনসিনাটি কিডের একটি আপডেট সংস্করণ রয়েছে।
র‌্যাল্ফ মার্শাল

উত্তর:


5

সিনসিনাটি কিড

আমরা হারাতে পেরে আমরা যদি অন্য কার্ড আঁকাম তা নিশ্চিত করার চেষ্টা করুন অন্যথায় আমাদের পাশের ডেক এবং কী করবেন তা স্থির করার জন্য সামগ্রিক স্কোরগুলি দেখুন।

প্রতিপক্ষ ইতিমধ্যে খেলা শেষ করে এমন পরিস্থিতিতে পরিস্থিতি পরিচালনা করার জন্য আরও ভাল কাজ করার জন্য আপডেট হয়েছে । আমার নিজের পরীক্ষায় এটি এখন কমপক্ষে আপাতত সেরা প্রার্থী বলে মনে হচ্ছে।

package Players;

import java.util.Collection;

import Mechanics.*;

public class CincinnatiKid extends Player {

    public CincinnatiKid() {
        name = "The Cincinnati Kid";
    }

    private static boolean isDebug = false;

    private static final int BEST_HAND = 20;

    public void getResponse(int wins[],
                            boolean isPlayerOne,
                            Collection<Card> yourHand,
                            Collection<Card> opponentHand,
                            Collection<Card> yourSideDeck,
                            int opponentSideDeckCount,
                            Action opponentAction,
                            boolean opponentDidPlay)
    {
        int myValue = handValue(yourHand);
        int oppValue = handValue(opponentHand);

        if (oppValue > BEST_HAND) {
            logMsg("Opponent has busted");
            action = Action.STAND;
        } else if (myValue > BEST_HAND) {
            logMsg("I have busted");
            action = Action.STAND;
        } else if (myValue <= 10) {
            logMsg("I cannot bust with my next move");
            action = Action.END;
        } else {
            handleTrickySituation(myValue, oppValue, wins, isPlayerOne, yourHand, opponentHand,
                                  yourSideDeck, opponentSideDeckCount, opponentAction, opponentDidPlay);
        }

        if (action == Action.PLAY && cardToPlay == null) {
            logMsg("ERROR - Action is Play but no card chosen");
        }
        logMsg("My hand value is " + myValue + ", opponent is " + oppValue + ", action is " + action +
               ((action == Action.PLAY && cardToPlay != null) ? " a " + cardToPlay.toString() : ""));
    }

    int [] branchCounts = new int[12];

    public void dumpBranchCounts() {
        if (isDebug) {
            for (int i = 0; i < branchCounts.length; i++) {
                System.out.print("b[" + i + "]=" + branchCounts[i] + " ");
            }
            System.out.println();
        }
    }

    private void handleTrickySituation(int myValue, int oppValue,
                                       int wins[],
                                       boolean isPlayerOne,
                                       Collection<Card> yourHand,
                                       Collection<Card> opponentHand,
                                       Collection<Card> yourSideDeck,
                                       int opponentSideDeckCount,
                                       Action opponentAction,
                                       boolean opponentDidPlay)
    {
        dumpBranchCounts();
        logMsg("I am might bust");

        int STAND_VALUE = 18;
        int chosenBranch = 0;

        Card bestSideCard = findSideCard(myValue, yourSideDeck);
        int valueWithSideCard = myValue + (bestSideCard != null ? bestSideCard.getValue() : 0);

        if (bestSideCard != null && valueWithSideCard >= oppValue && valueWithSideCard > STAND_VALUE) {
            logMsg("Found a good card in side deck");
            action = Action.PLAY;
            cardToPlay = bestSideCard;
            chosenBranch = 1;
        } else if (opponentDidPlay || opponentAction == Action.STAND) {
            logMsg("Opponent is done");
            // Opponent is done, so get another card if I'm behind
            if (myValue < oppValue) {
                logMsg("I am behind");
                if (bestSideCard != null && valueWithSideCard >= oppValue) {
                    logMsg("My best side card is good enough to tie or win");
                    action = Action.PLAY;
                    cardToPlay = bestSideCard;
                    chosenBranch = 2;
                } else {
                    logMsg("My best side card won't do so I'm going to hit");
                    // No side card and I'm losing, so I might as well hit
                    action = Action.END;
                    chosenBranch = 3;
                }
            } else if (myValue == oppValue) {
                logMsg("Game is tied");
                logMsg("Looking for lowest card in the side deck");
                cardToPlay = findWorstSideCard(myValue, yourSideDeck);
                if (cardToPlay != null) {
                    action = Action.PLAY;
                    chosenBranch = 4;
                } else {
                    logMsg("Tied with no side cards - accept the draw");
                    action = Action.STAND;
                    chosenBranch = 5;
                }
            } else {
                logMsg("I'm ahead and opponent has given up");
                action = Action.STAND;
                chosenBranch = 6;
            }
        } else if (myValue < oppValue) {
            logMsg("I am behind and have nothing good in my side deck");
            action = Action.END;
            chosenBranch = 7;
        } else if (oppValue <= 10 && myValue < STAND_VALUE) {
            logMsg("Opponent is guaranteed to hit and I have a low hand, so take another");
            action = Action.END;
            chosenBranch = 8;
        } else if (myValue == oppValue && myValue >= STAND_VALUE) {
            logMsg("We both have equally good hands - stand and hope for the tie");
            action = Action.STAND;
            chosenBranch = 9;
        } else if (myValue < STAND_VALUE) {
            logMsg("I am ahead but have a low score");
            action = Action.END;
            chosenBranch = 10;
        } else {
            logMsg("I am ahead with a decent score");
            action = Action.STAND;
            chosenBranch = 11;
        }

        branchCounts[chosenBranch]++;
    }

    private double calcBustOdds(int valueSoFar, Collection<Card> myHand, Collection<Card> oppHand) {

        if (valueSoFar >= BEST_HAND) {
            return 1;
        }

        int remainingDeck = 40 - (myHand.size() + oppHand.size());
        int [] cardCounts = new int[10];
        int firstBust = BEST_HAND - valueSoFar;

        for (int i = 0; i < 10; i++) {
            cardCounts[i] = 4;
        }

        for (Card c : myHand) {
            cardCounts[c.getValue()-1]--;
        }

        for (Card c : oppHand) {
            cardCounts[c.getValue()-1]--;
        }

        int bustCards = 0;
        for (int i = firstBust; i < 10; i++) {
            logMsg("cardCounts[" + i + "]=" + cardCounts[i]);
            bustCards += cardCounts[i];
        }

        double retval = (double) bustCards / (double) remainingDeck;
        logMsg("Out of " + remainingDeck + " remaining cards " + bustCards + " will bust, or " + retval);
        return retval;
    }

    private Card findSideCard(int myValue, Collection<Card> sideDeck) {
        int valueNeeded = BEST_HAND - myValue;
        Card bestCard = null;
        if (valueNeeded > 0) {
            for (Card c : sideDeck) {
                if (c.getValue() == valueNeeded) {
                    return c;
                } else if (c.getValue() < valueNeeded) {
                    if (bestCard == null || c.getValue() > bestCard.getValue()) {
                        bestCard = c;
                    }
                }
            }
        }

        return bestCard;
    }

    private Card findWorstSideCard(int myValue, Collection<Card> sideDeck) {
        int valueNeeded = BEST_HAND - myValue;

        logMsg("Searching side deck for something with value <= " + valueNeeded);
        Card bestCard = null;

        for (Card c : sideDeck) {
            logMsg("Examining side card " + c.getValue());

            // Find the worst card in the deck, but not if it exceeds the amount left
            if (c.getValue() <= valueNeeded && (bestCard == null || c.getValue() < bestCard.getValue())) {
                logMsg("This is the new best side card");
                bestCard = c;
            }
        }

        logMsg("Worst side card found is " + (bestCard != null ? bestCard.getValue() : " n/a"));
        return bestCard;
    }

    private void logMsg(String s) {
        if (isDebug) {
            System.out.println("### " + s);
        }
    }

    private int handValue(Collection<Card> hand)  {
        int handValue = 0;
        for (Card c : hand) {
            handValue += c.getValue();
        }
        return handValue;
    }
}

অভিনন্দন! আপনি নেতৃত্বে আছেন।
মাইকেল ব্র্যান্ডন মরিস

স্কোরিং সিস্টেমটিকে আরও সুষ্ঠু করার জন্য পরিবর্তনগুলি সহ, আপনি এখন অস্টিন শক্তিগুলির সাথে প্রথম হয়ে গেছেন।
মাইকেল ব্র্যান্ডন মরিস

4

অস্টিন শক্তি

অস্টিন পাওয়ারস, আপনি যেমন অনুমান করতে পারেন, বিপজ্জনকভাবে বাঁচতে পছন্দ করেন। যদি কেউ বাধা না দেয় বা সে জয়ের গ্যারান্টি দিতে না পারে তবে সে পিছনে থাকলে সর্বদা আঘাত করবে বা মাতাল না হওয়ার 20% এর চেয়ে ভাল সম্ভাবনা রয়েছে।

package Players;
import java.util.Collection;

import Mechanics.*;

public class AustinPowers extends Player {
    public AustinPowers() {
        name = "Austin Powers";
    }
    int MAX_VALUE = 20;
    public void getResponse(int wins[], boolean isPlayerOne,
            Collection<Card> yourHand, Collection<Card> opponentHand,
            Collection<Card> yourSideDeck, int opponentSideDeckCount,
            Action opponentAction, boolean opponentDidPlay) {
        action = null;
        cardToPlay = null;
        int myWins = isPlayerOne?wins[0]:wins[1];
        int oppWins = isPlayerOne?wins[1]:wins[0];
        int oppTotal = calcHand(opponentHand);
        int myTotal = calcHand(yourHand);
        boolean liveDangerously = ((oppTotal>=myTotal && opponentAction==Action.STAND) || opponentAction==Action.END) && myTotal<MAX_VALUE && canNotBust(yourHand,opponentHand,myTotal) && myWins<oppWins;

        if(myTotal==MAX_VALUE || oppTotal>MAX_VALUE || myTotal>MAX_VALUE ||(oppTotal<myTotal&&opponentAction==Action.STAND))
        {
            action = Action.STAND;
        }
        else if((opponentAction==Action.STAND&&hasGoodEnoughSideCard(yourSideDeck,myTotal,oppTotal))||hasPerfectSideCard(yourSideDeck, myTotal))
        {
            action = Action.PLAY;
        }
        else if(liveDangerously||betterThan20(myTotal, getDeck(yourHand, opponentHand)))
        {
            action = Action.END;
        }
        else
        {
            action=Action.STAND;
        }

    }

    private boolean hasGoodEnoughSideCard(Collection<Card> yourSideDeck,
            int myTotal, int oppTotal) {
        for(Card c: yourSideDeck)
        {
            if(MAX_VALUE>=myTotal+c.getValue()&&myTotal+c.getValue()>oppTotal)
            {
                cardToPlay=c;
                return true;
            }
        }
        return false;
    }

    private boolean betterThan20(int myTotal, int[] deck) {
        int deckSize=0;
        int nonBustCards=0;
        for(int i=0;i<10;i++)
        {
            deckSize+=deck[i];
            if(MAX_VALUE-myTotal>i)
                nonBustCards+=deck[i];
        }
        return (double)nonBustCards/(double)deckSize>0.2;
    }

    private boolean hasPerfectSideCard(Collection<Card> yourSideDeck,
            int myTotal) {
        for(Card c:yourSideDeck)
        {
            if(MAX_VALUE-myTotal== c.getValue())
            {
                cardToPlay = c;
                return true;
            }
        }
        return false;
    }

    private boolean canNotBust(Collection<Card> yourHand,
            Collection<Card> opponentHand, int myTotal) {
        if(myTotal<=10) return true;
        int[] deck = getDeck(yourHand, opponentHand);
        for(int i=0;i<MAX_VALUE-myTotal;i++)
            if(deck[i]>0)
                return true;
        return false;
    }

    private int[] getDeck(Collection<Card> yourHand,
            Collection<Card> opponentHand) {
        int[] deck = new int[10];
        for (int i = 0; i < 10; i++) {
            deck[i] = 4;
        }
        for(Card c:yourHand){deck[c.getValue()-1]--;}
        for(Card c:opponentHand){deck[c.getValue()-1]--;}
        return deck;
    }

    private int calcHand(Collection<Card> hand)
    {
        int ret = 0;
        for(Card c: hand){ret+=c.getValue();}
        return ret;
    }
}

অভিনন্দন! আপনি সিনসিনাটিকিড থেকে নেতৃত্ব দিয়েছেন।
মাইকেল ব্র্যান্ডন মরিস

স্কোরিং সিস্টেমটিকে আরও সুষ্ঠু করার জন্য পরিবর্তনগুলির মাধ্যমে আপনি এখন দ্য সিনসিনাটি কিডের সাথে প্রথম হয়ে গেছেন।
মাইকেল ব্র্যান্ডন মরিস

2

Bastila

বাস্টিলা রক্ষণশীলভাবে অভিনয় করে। তার কাছে 17 টি 20 এর মতোই দুর্দান্ত এবং বোমা আউট করার চেয়ে সংক্ষিপ্ত হয়ে দাঁড়ানো আরও ভাল।

package Players;

import java.util.Collection;

import Mechanics.*;

public class Bastila extends Player {

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

    public void getResponse(int wins[], boolean isPlayerOne,
            Collection<Card> myHand, Collection<Card> opponentHand,
            Collection<Card> mySideDeck, int opponentSideDeckCount,
            Action opponentAction, boolean opponentDidPlay) {


        action = null;
        cardToPlay = null;

        //Constants
        int stand = 17;
        int conservatism = 2;

        //Get some info
        int handVal = handValue(myHand);
        int expected = expectedValue(myHand);

        //Can I play from my side deck?
        for(Card side: mySideDeck){
            int total = side.getValue() + handVal;
            if(total >= stand && total <= 20){
                cardToPlay = side;
                action = Player.Action.PLAY;
            }
        }
        if(action == Player.Action.PLAY){
            return;
        }

        //Otherwise, will I go bust?
        if(handVal + expected > 20 - conservatism){
            action = Player.Action.STAND;
        }
        else{
            action = Player.Action.END;
        }

        return;

    }

    private int handValue(Collection<Card> hand) {
        int handValue = 0;
        for(Card c : hand){
            handValue += c.getValue();
        }
        return handValue;
    }

    private int expectedValue(Collection<Card> hand){
        //Net value of the deck is 55*4 = 220
        int total = 220;
        int count = 40;
        for(Card c : hand){
            total -= c.getValue();
            count--;
        }
        return total/count;
    }

}

বাসটিলা বর্তমানে ডাম্ব বোল্ড প্লেয়ার এবং ডাম্ব সাবধান প্লেয়ার (ডেমো বট) উভয়কেই ছাড়িয়ে যাচ্ছে। সাবাশ! সম্পাদনা: দশ রানের মধ্যে, বাস্টিলা আটটি জিতেছে, একবার ডাম্ব সাবধান প্লেয়ারের কাছে হেরেছিল এবং একবার বোবা সতর্ক প্লেয়ারের সাথে জুটি বেঁধেছিল।
মাইকেল ব্র্যান্ডন মরিস

আপডেট: নতুন স্কোরিং সিস্টেমের সাথে (ট্যুরিয়াদের দ্বারা গণনা করা জয়গুলি, যার মধ্যে প্রতিটি খেলোয়াড়ের জুটির সাথে 1000 টি খেলা হয়), বাস্টিলা 1705/3000 মোট (1705/2000 ট্যুরি খেলে) নিয়ে শীর্ষে রয়েছে। এর পরে 7২৯ নিয়ে ডাম্ব সাবধান প্লেয়ার এবং অবশেষে 6 566 নিয়ে ডম্বা বোল্ড প্লেয়ার
মাইকেল ব্র্যান্ডন মরিস

হাহাহা ভাল আমি আশা করবো এটি কমপক্ষে ডেমো
কেইন

2

নেস্টর

নেস্টর তার পাশের ডেকটি ব্যবহার করে ২০ টি পেতে পছন্দ করে তবে যখন এটি ব্যর্থ হয় তখন তিনি প্রতিদ্বন্দ্বী বোধগম্য বলে ধরে নিয়ে স্ট্যান্ড বা শেষ নির্বাচন করে তার প্রত্যাশিত বেতনটি গণনা করেন।

package Players;

import java.util.Arrays;
import java.util.Collection;


import Mechanics.Card;
import Mechanics.Player;

public class Nestor extends Player {
    final int TotalWinPayoff = 10;
    final int TotalLosePayoff = 0;
    final int TotalDrawPayoff = 1;
    final int temporaryLosePayoff = 4;
    final int temporayWinPayoff = 19;
    final int temporaryDrawPayoff = 9;
    @Override
    public void getResponse(int[] wins, boolean isPlayerOne,
            Collection<Card> yourHand, Collection<Card> opponentHand,
            Collection<Card> yourSideDeck, int opponentSideDeckCount,
            Action opponentAction, boolean opponentDidPlay) {

        int sumMyHand = SumHand(yourHand);
        int sumOpponentHand = SumHand(opponentHand);
    if (sumOpponentHand>20)
    {this.action = Action.STAND;return;}
        if(sumMyHand == 20)
        {
            //I'm unbeatable :)
            //System.out.println("\tI'm Unbeatable");
            this.action = Action.STAND;
            return;
        }
        else if(opponentDidPlay || opponentAction == Action.STAND)
        {
            //They've finished
            ///System.out.println("\tThey've Finished");
            if(sumMyHand>sumOpponentHand)
            {
                //I've won
                //System.out.println("\tI've Won");
                this.action = Action.STAND;
                return;
            }
            else if(canBeat(sumMyHand, sumOpponentHand, yourSideDeck))
            {
                //I can beat them
                //System.out.println("\tI can beat them");
                this.action = Action.PLAY;
                return;
            }
            else if(canEven(sumMyHand, sumOpponentHand, yourSideDeck))
            {
                //I can draw with them
                //System.out.println("\tI can draw with them");
                this.action = Action.PLAY;
                return;
            }
            else
            {
                //I need another card
                //System.out.println("\tI need another card");
                this.action = Action.END;
                return;
            }
        }
        else if(deckContains(yourSideDeck, 20-sumMyHand))
        {
            //Let's get 20
            //System.out.println("\tLet's get 20");
            this.action = Action.PLAY;
            this.cardToPlay = getCard(yourSideDeck, 20-sumMyHand);
            return;
        }
        else if(sumOpponentHand==20 && sumMyHand<20)
        {
            //They've got 20 so we need to fight for a draw
            //System.out.println("\tFight for a draw");
            this.action = Action.END;
            return;
        }

        else if(sumMyHand<10)
        {
            //Lets get another card
            //System.out.println("\tLet's get another card");
            this.action = Action.END;
            return;
        }
        else
        {
            //Let's work out some probabilities
            //System.out.println("\tLet's work out some probabilities");
            int[] cardsLeft = {4,4,4,4,4,4,4,4,4,4};
            for (Card card : opponentHand) {
                cardsLeft[card.getValue()-1] --;

            }
            for (Card card : yourHand) {
                cardsLeft[card.getValue()-1] --;

            }

             int numCardsLeft = sumfromToEnd(0, cardsLeft);

             //My Assumptions
             double probabilityTheyStand = (double)sumfromToEnd(20-sumOpponentHand, cardsLeft)/numCardsLeft;

             //What I need to know
             double payoffStanding = 0;
             double payoffDrawing = 0;


             for(int myChoice = -1; myChoice<10; myChoice++)
             {
                 for(int theirChoice = -1; theirChoice<10; theirChoice++)
                 {
                     if(myChoice == -1)
                     {
                         payoffStanding += getProbability(myChoice, theirChoice, Arrays.copyOf(cardsLeft, cardsLeft.length), probabilityTheyStand, numCardsLeft) * getPayoff(sumMyHand, sumOpponentHand,myChoice, theirChoice, TotalWinPayoff, TotalDrawPayoff, TotalLosePayoff);
                     }
                     else
                     {
                         payoffDrawing +=
                                 getProbability(myChoice, theirChoice, Arrays.copyOf(cardsLeft, cardsLeft.length), probabilityTheyStand, numCardsLeft)
                                 * getPayoff(sumMyHand, sumOpponentHand, myChoice, theirChoice, temporayWinPayoff, temporaryDrawPayoff, temporaryLosePayoff);
                     }
                 }
             }
            // System.out.println("\tStanding: " +Double.toString(payoffStanding) + " Ending: " + Double.toString(payoffDrawing));
             if(payoffStanding<payoffDrawing)
             {
                 this.action = Action.END;
             }
             else
             {
                 this.action = Action.STAND;
             }
        }


    }



    private int getPayoff(int sumMyHand, int sumOpponentHand, int myChoice,
            int theirChoice, int WinPayoff, int DrawPayoff,
            int LosePayoff) {
            if(sumMyHand + myChoice + 1 > 20)
            {
                if(sumOpponentHand + theirChoice + 1 > 20)
                {
                    return DrawPayoff;
                }
                else
                {
                    return LosePayoff;
                }
            }
            else if(sumMyHand + myChoice + 1 > sumOpponentHand + theirChoice + 1)
            {
                return WinPayoff;
            }
            else if (sumMyHand + myChoice + 1 < sumOpponentHand + theirChoice + 1)
            {
                return LosePayoff;
            }
            else
            {
                return DrawPayoff;
            }


    }



    private double getProbability(
            int myChoice, int theirChoice, int[] cardsLeft,
            double probabilityTheyStand, int numCardsLeft) {
        double myProb, theirProb;
        if(myChoice<0)
        {
            myProb = 1;
        }
        else
        {
            myProb = ((double)cardsLeft[myChoice])/((double)numCardsLeft);
            cardsLeft[myChoice]--;
            numCardsLeft--;
        }

        if(theirChoice<0)
        {
            theirProb = probabilityTheyStand;
        }
        else
        {
            theirProb = ((double)cardsLeft[theirChoice]) / ((double)numCardsLeft);
        }
        return myProb*theirProb;
    }





    private int sumfromToEnd(int i, int[] cardsLeft) {
        int toRet = 0;
        for(;i<cardsLeft.length; i++)
        {
            toRet += cardsLeft[i];
        }
        return toRet;
    }

    private boolean canEven(int mySum, int opponentSum,
            Collection<Card> yourSideDeck) {
        for (Card card : yourSideDeck) {
            if(mySum + card.getValue() <= 20 && mySum + card.getValue() >= opponentSum)
            {
                this.cardToPlay = card;
                return true;
            }
        }
        return false;
    }

    private boolean canBeat(int mySum, int opponentSum,
            Collection<Card> yourSideDeck) {
        for (Card card : yourSideDeck) {
            if(mySum + card.getValue() <= 20 && mySum + card.getValue() > opponentSum)
            {
                this.cardToPlay = card;
                return true;
            }
        }
        return false;
    }

    private Card getCard(Collection<Card> deck, int value) {
        for (Card card : deck) {
            if(card.getValue() == value)
            {
                return card;
            }
        }
        return null;
    }

    private boolean deckContains(Collection<Card> deck, int value) {
        for (Card card : deck) {
            if(card.getValue() == value)
            {
                return true;
            }
        }
        return false;
    }

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

    private int SumHand(Collection<Card> hand)
    {
        int toRet = 0;
        for (Card card : hand) {
            toRet += card.getValue();
        }
        return toRet;
    }
}

অভিনন্দন! আপনি অস্টিন পাওয়ার এবং দ্য সিনসিনাটি কিডের মধ্যে টাই হয়ে প্রথম স্থান অর্জন করতে পেরেছিলেন।
মাইকেল ব্র্যান্ডন মরিস

থ্রেডে "মূল" জাভা.লাং.আরএআইএন্ডেক্সআউটআউটবাউন্ডসেক্সপশন: -২ প্লেয়ার্স.নেস্টর.সামফ্রমটওয়েন্ডে (নেস্টর.জভা রেক্টর 10) মেকানিক্স.পাজকগেম.ম্যাজ.জ্যামেজ.পেইমগেইমে (নেস্টর.জভা ১০.০৫) : 112) মেকানিক্সে.পাজাকগেমমেইন.মাইন (পাজাকগেমমাইন.জভা 40)
মাইকেল ব্র্যান্ডন মরিস

আপনি কি আমাকে এটি দেখতে সাহায্য করতে আপত্তি করবেন? এটি বট-নির্দিষ্ট বলে মনে হচ্ছে, কারণ এটি কেবল নেপ্টর এবং টি 3 এম 4 (গিথুবটিতে অপ্রকাশিত বট) খেলতে শুরু করে।
মাইকেল ব্র্যান্ডন মরিস

আমি যা বলতে পারি তা থেকে, আপনার প্রতিপক্ষের ফাঁস লাগলে এটি ট্রিগার করে, তবে কোনও কারণে তারা দাঁড়ায় নি। আমি আপনার বটটিতে একটি অস্থায়ী ফিক্স রাখছি, তবে পরে কন্ট্রোলারটিকে স্বয়ংক্রিয়ভাবে সেই বট থামিয়ে দেবে fix
মাইকেল ব্র্যান্ডন মরিস

প্রতিপক্ষ যখন
ফাঁসিয়েছে

1

Glaucus

package Players;


import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

import Mechanics.Card;
import Mechanics.Player;

public class Glaucus extends Player {
    static final double LosePay = 0;
    static final double WinPay = 10;
    static final double DrawPay = 1;
    static final int NUMBEROFSIMS = 100;

    Random r;

    public Glaucus()
    {
        this.name = "Glaucus";
        r = new Random();
    }

    @Override
    public void getResponse(int[] wins, boolean isPlayerOne,
            Collection<Card> yourHand, Collection<Card> opponentHand,
            Collection<Card> yourSideDeck, int opponentSideDeckCount,
            Action opponentAction, boolean opponentDidPlay) {
        //Make Sum of hands
        int sumMyHand = 0;
        int sumOpponentHand = 0;
        //Make an array of the remaining cards
        List<Integer> cards = new LinkedList<Integer>();
        int[] cardsLeft = {4,4,4,4,4,4,4,4,4,4};
        for (Card card : yourHand) {
            cardsLeft[card.getValue()-1] -= 1;
            sumMyHand+=card.getValue();
        }
        for (Card card : opponentHand) {
            cardsLeft[card.getValue()-1] -= 1;
            sumOpponentHand += card.getValue();
        }
        if(sumMyHand<=10)
        {
            this.action = Action.END;
        }
        else if (sumMyHand >= 20)
        {
            this.action = Action.STAND;
        }
        else if (sumOpponentHand > 20)
        {
            this.action = Action.STAND;
        }
        else
        {
            for (int i = 0; i < cardsLeft.length; i++) {
                while(cardsLeft[i] > 0)
                {
                    cards.add(i + 1);
                    cardsLeft[i] -= 1;
                }
            }
            //System.out.println(Arrays.toString(cards));

            double standPayoff = 0;
            double endPayoff = 0;
            double[] sideDeckPayoffs = new double[yourSideDeck.size()];
            //Run some simulations
            for(int sim = 0; sim<NUMBEROFSIMS; sim++)
            {
                Collections.shuffle(cards, r);
                standPayoff += getPayoff(sumMyHand, sumOpponentHand, cards, Action.STAND, opponentAction, false, 0);
                endPayoff += getPayoff(sumMyHand, sumOpponentHand, cards, Action.END, opponentAction, false, 0);
                for(int i = 0; i<sideDeckPayoffs.length; i++)
                {
                    sideDeckPayoffs[i] += getPayoff(sumMyHand+((Card)yourSideDeck.toArray()[i]).getValue(), sumOpponentHand, cards, Action.STAND, opponentAction, false, 0);
                }

            }

            double maxSidePay = 0;
            int sideDeckChoice  = 0;
            for (int i = 0; i < sideDeckPayoffs.length; i++) {
                double d = sideDeckPayoffs[i];
                if(d>maxSidePay)
                {
                    maxSidePay = d;
                    sideDeckChoice = i;
                }
            }
            /*System.out.println(standPayoff);
            System.out.println(endPayoff);
            System.out.println(maxSidePay);*/

            if(maxSidePay>standPayoff && maxSidePay>endPayoff)
            {
                this.action = Action.PLAY;
                this.cardToPlay = (Card)yourSideDeck.toArray()[sideDeckChoice];
            }
            else if(standPayoff > endPayoff)
            {
                this.action = Action.STAND;
            }
            else
            {
                this.action = Action.END;
            }
        }
    }

    private double getPayoff(int sumMyHand, int sumOpponentHand,
            List<Integer> cards, Action myAction, Action opponentAction, boolean myTurn, int index) {
        //SHort circuit some logic
        if(sumMyHand>20 && sumOpponentHand>20)
        {
            return DrawPay;
        }
        else if(sumMyHand>20)
        {
            return LosePay;
        }
        else if(sumOpponentHand>20)
        {
            return WinPay;
        }
        else if(myAction == Action.STAND && opponentAction == Action.STAND)
        {
            if(sumMyHand>sumOpponentHand)
            {
                return WinPay;
            }
            else if(sumMyHand<sumOpponentHand)
            {
                return LosePay;
            }
            else
            {
                return DrawPay;
            }
        }
        else
        {
            double standPayoff = 0;
            double endPayoff = 0;

            if(myTurn)
            {
                if(opponentAction == Action.END)
                {
                    sumOpponentHand += cards.get(index);
                    index++;
                }
                if(myAction == Action.STAND)
                {

                    return getPayoff(sumMyHand, sumOpponentHand, cards, myAction, opponentAction, false, index);
                }
                else
                {

                    standPayoff = getPayoff(sumMyHand, sumOpponentHand, cards, Action.STAND, opponentAction, false, index);
                    endPayoff = getPayoff(sumMyHand, sumOpponentHand, cards, Action.END, opponentAction, false, index);
                    if(standPayoff>endPayoff)
                    {
                        return standPayoff;
                    }
                    else
                    {
                        return endPayoff;
                    }
                }
            }
            else
            {
                if(myAction == Action.END)
                {
                    sumMyHand += cards.get(index);
                    index++;
                }
                if(opponentAction == Action.STAND)
                {
                    return getPayoff(sumMyHand, sumOpponentHand, cards, myAction, opponentAction, true, index);
                }
                else
                {
                    standPayoff = getPayoff(sumMyHand, sumOpponentHand, cards, myAction, Action.STAND, true, index);
                    endPayoff = getPayoff(sumMyHand, sumOpponentHand, cards, myAction, Action.END, true, index);
                    if(standPayoff<endPayoff)
                    {
                        return standPayoff;
                    }
                    else
                    {
                        return endPayoff;
                    }
                }
            }
        }
    }
}

গ্লুকাস শ্যাফলেড কার্ডের সাথে 100 টি সিমুলেশন তৈরি করে এবং এই সিমুলেশনগুলির উপর ভিত্তি করে তার সেরা বিকল্পটি বেছে নেয়।


আপনি যদি সিমুলেশনগুলির সংখ্যা কমিয়ে দিতে পারেন তবে আমি প্রশংসা করব। একক প্রতিপক্ষের বিরুদ্ধে রান সংগ্রহ করতে এক মিনিটের বেশি সময় লাগছে, এবং অন্যান্য সমস্ত বটগুলির বিরুদ্ধে, আমাদের রান সময়টি কেবলমাত্র অন্য বটগুলির সাথে 30 সেকেন্ডের বিপরীতে 7 মিনিটেরও বেশি সময় দেয়।
মাইকেল ব্র্যান্ডন মরিস

যতক্ষণ না এটি যুক্তিসঙ্গত পরিমাণ গ্রহণ করা অবধি অবধি সংখ্যাটি অবিচ্ছিন্নভাবে পরিবর্তন করুন, আমার কম্পিউটারে এটি 100 সিমগুলি খুব দ্রুত পরিচালনা করে যার কারণে আমি সেই মানটি বেছে নিয়েছি তবে এটি নির্দ্বিধায় অনুভব করতে পারি :)
ইউনজট

এটি আমার ডেস্কটপে (i7-3770K) দ্রুত হতে পারে তবে আমার ল্যাপটপটি (i5-4300U) (যা আমি এক সপ্তাহ ধরে আটকে আছি) ধীর গতির। আমি যখন আমার ডেস্কটপে ফিরে আসি তখন আমি গ্লাকাসকে আবার ফিরিয়ে দেব।
মাইকেল ব্র্যান্ডন মরিস

আমি আগামীকাল এটির গতি বাড়ানোর চেষ্টা করব এবং এটি নির্দিষ্ট সংখ্যক সিমের চেয়ে নির্দিষ্ট সময়ের জন্য সিমস চালিয়ে দেব - প্রতি ঘণ্টায় কতক্ষণ গ্রহণযোগ্য?
ইউয়ানজট

সিমুলেশনগুলি চালানোর পরিবর্তে, হাইপারজমেট্রিক বিতরণের মাধ্যমে সম্ভাব্যতাগুলি সরাসরি অনুমান করা যায় না কেন?
নিষ্ক্রিয়তা সম্ভাব্য

1

এইচ কে 47

দেখ! আমার নিজস্ব ডিজাইনের একটি বট। এইচকে-47 তার মাংসের ডেক কার্ডগুলি নিয়ে সামান্য ট্রিগার-খুশি হলেও তিনি যতটা মাংসব্যাগগুলি পারেন তা হত্যার চেষ্টা করেছেন।

বিবৃতি: প্রকৃতপক্ষে, আমি কিছু অপ্রচলিত সহিংসতায় লিপ্ত হতে সবচেয়ে আগ্রহী। অবশ্যই আপনার আদেশে, মাস্টার। - এইচকে 47

এখনও অবধি, তিনি সিনসিনাটি কিড ছাড়া সবাইকে পরাজিত করতে পারেন।

package Players;

import java.util.Collection;

import Mechanics.*;

public class HK47 extends Player {

    /** The hand goal. */
    private static final int GOAL = 20;
    /** The cutoff for standing versus ending. */
    private static final int STAND_CUTOFF = 17;
    /** The minimum value for playing. */
    private static final int PLAY_MINIMUM = 14;
    /** The cutoff for ending versus decision evaluation. */
    private static final int SAFETY_CUTOFF = 10;

    /** The hand wins for this game. Used to evaluate win priority. */
    private int[] handWins;
    /**
     * My hand, as an unmodifiable collection. Used to evaluate decisions, after
     * being processed into myHandValue.
     */
    private Collection<Card> myHand;
    /**
     * Opponent's hand. Used to evaluate decisions as a secondary factor to my
     * hand, after being processed into oppHandValue.
     */
    private Collection<Card> oppHand;
    /** The value of my hand. Calculated via the myHandValue method. */
    private int myHandValue;
    /** The value of my opponent's hand. Calculated via the oppHandValue method. */
    private int oppHandValue;
    /** My side deck. Used to evaluate PLAY decisions. */
    private Collection<Card> mySideDeck;
    /**
     * The number of cards in my opponent's side deck. Used to evaluate PLAY
     * decisions as a secondary factor to mySideDeck, alongside win priority.
     */
    private int oppSideDeckCount;
    /**
     * The Action the opponent last took. Will either be STAND or END. Used to
     * evaluate decisions.
     */
    private Action oppAction;
    /** Whether or not I am player one. Used to evaluate wins and losses. */
    private boolean amPlayerOne;
    /**
     * The number of wins I have so far this game. Used to evaluate win priority
     * alongside myLosses.
     */
    private int myWins;
    /**
     * The number of losses I have so far this game. Used to evaluate win
     * priority alongside myWins.
     */
    private int myLosses;
    /**
     * How important it is for me to play. Positive values indicate an excess of
     * cards, and negative values indicate a deficit.
     */
    private int playPriority;
    /**
     * How important it is for me to win. Positive values indicate that I must
     * win the game, and negative values indicate that I can take some chances.
     */
    private int winPriority;
    /**
     * The sum of playPriority and winPriority. The higher the value, the fewer
     * chances I need to take.
     */
    private int priority;

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

    @Override
    public void getResponse(int[] wins, boolean isPlayerOne,
            Collection<Card> yourHand, Collection<Card> opponentHand,
            Collection<Card> yourSideDeck, int opponentSideDeckCount,
            Action opponentAction, boolean opponentDidPlay) {
        handWins = wins;
        amPlayerOne = isPlayerOne;
        myHand = yourHand;
        oppHand = opponentHand;
        mySideDeck = yourSideDeck;
        oppSideDeckCount = opponentSideDeckCount;
        oppAction = opponentAction;
        myHandValue = myHandValue();
        oppHandValue = oppHandValue();
        setStatistics();
        chooseOption();
    }

    /**
     * Calculates playPriority, winPriority, and priority.
     */
    private void setStatistics() {
        if (amPlayerOne) {
            myWins = handWins[0];
            myLosses = handWins[1];
        } else {
            myWins = handWins[1];
            myLosses = handWins[0];
        }
        playPriority = 0;
        winPriority = 0;
        if (mySideDeck.size() > oppSideDeckCount) {
            playPriority++;
        } else if (mySideDeck.size() < oppSideDeckCount) {
            playPriority--;
        }
        if (myWins < myLosses) {
            winPriority++;
        } else if (myWins == myLosses && myWins == 2) {
            winPriority++;
        } else if (myWins > myLosses && myWins != 2) {
            winPriority--;
        }
        priority = playPriority + winPriority;
    }

    /**
     * Chooses the appropriate option based on my hand, the opponent's hand, the
     * opponent's stance, my priority, and whether or not I can play to certain
     * values.
     */
    private void chooseOption() {
        // Path 1: Draw if at 10 or under.
        if (myHandValue <= SAFETY_CUTOFF) {
            action = Action.END;
            path = "1";
        }
        // Path 2: Draw if over 20.
        else if (myHandValue > GOAL) {
            action = Action.END;
            path = "2";
        }
        // Path 3: Stand if opponent over 20.
        else if (oppHandValue > GOAL) {
            path = "3";
            action = Action.STAND;
        }
        // Path 4: If opponent is at 20...
        else if (oppHandValue == GOAL) {
            // Path 4.1: Play if can reach 20.
            if (canPlayToGoal()) {
                action = Action.PLAY;
                path = "4.1";
            }
            // Path 4.0: Stand.
            else {
                action = Action.END;
                path = "4.0";
            }
        }
        // Path 5: If opponent is standing...
        else if (oppAction == Action.STAND) {
            // Path 5.1: If I am behind them...
            if (myHandValue < oppHandValue) {
                // Path 5.1.1: If I am at or above the minimum play value...
                if (myHandValue >= PLAY_MINIMUM) {
                    // Path 5.1.1.1: Play if can play.
                    if (canPlay()) {
                        action = Action.PLAY;
                        path = "5.1.1.1";
                    }
                    // Path 5.1.1.0: END
                    else {
                        action = Action.END;
                        path = "5.1.1.0";
                    }
                }
                // Path 5.1.0: END
                else {
                    action = Action.END;
                    path = "5.1.0";
                }
            }
            // Path 5.2: If I am tied with them...
            else if (myHandValue == oppHandValue) {
                // Path 5.2.1: If this game is important...
                if (priority > -1) {
                    // Path 5.2.1.1: Play if can play.
                    if (canPlay()) {
                        action = Action.PLAY;
                        path = "5.2.1.1";
                    }
                    // Path 5.2.1.0: STAND
                    else {
                        action = Action.STAND;
                        path = "5.2.1.0";
                    }
                }
                // Path 5.2.0 STAND
                else {
                    action = Action.STAND;
                    path = "5.2.0";
                }
            }
            // Path 5.0: STAND
            else {
                action = Action.STAND;
                path = "5.0";
            }
        }
        // Path 6: If opponent is not standing...
        else {
            // Path 6.1: If I am behind them...
            if (myHandValue < oppHandValue) {
                // Path 6.1.1: If they are at or above 17, and if this game is
                // important, play if can play to goal.
                if (oppHandValue >= STAND_CUTOFF) {
                    // Path 6.1.1.1
                    if (priority > 0 && canPlayToGoal()) {
                        action = Action.PLAY;
                        path = "6.1.1.1";
                    }
                    // Path 6.1.1.2
                    else if (priority > 0 && canPlayMax()) {
                        action = Action.PLAY;
                        path = "6.1.1.2";
                    }
                    // Path 6.1.1.0
                    else {
                        action = Action.STAND;
                        path = "6.1.1.0";
                    }
                }
                // Path 6.1.2: If I am above 14, play highest value card if can
                // play.
                else if (myHandValue > PLAY_MINIMUM) {
                    // Path 6.1.2.1
                    if (priority > -1 && canPlayToGoal()) {
                        action = Action.PLAY;
                        path = "6.1.2.1";
                    }
                    // Path 6.1.2.2
                    else if (priority > 0 && canPlayMax()) {
                        action = Action.PLAY;
                        path = "6.1.2.2";
                    }
                    // Path 6.1.2.0
                    else {
                        action = Action.STAND;
                        path = "6.1.2.0";
                    }
                }
                // Path 6.1.0
                else {
                    action = Action.END;
                    path = "6.1.0";
                }
            }
            // Path 6.2: If we are tied...
            else if (myHandValue == oppHandValue) {
                // Path 6.2.1
                if (myHandValue >= STAND_CUTOFF) {
                    // Path 6.2.1.1
                    if (priority > -1 && canPlayToGoal()) {
                        action = Action.PLAY;
                        path = "6.2.1.1";
                    }
                    // Path 6.2.1.2
                    else if (priority > 0 && canPlayMax()) {
                        action = Action.PLAY;
                        path = "6.2.1.2";
                    }
                    // Path 6.2.1.0
                    else {
                        action = Action.STAND;
                        path = "6.2.1.0";
                    }
                }
                // Path 6.2.2
                else if (myHandValue >= PLAY_MINIMUM) {
                    // Path 6.2.2.1
                    if (priority >= -1 && canPlayToGoal()) {
                        action = Action.PLAY;
                        path = "6.2.2.1";
                    }
                    // Path 6.2.2.2
                    else if (priority > -1
                            && canPlayMax()
                            && cardToPlay.getValue() + myHandValue >= STAND_CUTOFF) {
                        action = Action.PLAY;
                        path = "6.2.2.2";
                    }
                    // Path 6.2.2.0
                    else {
                        action = Action.END;
                        path = "6.2.2.0";
                    }
                }
                // Path 6.2.0
                else {
                    action = Action.END;
                    path = "6.2.0";
                }
            }
            // Path 6.0: If I am ahead of them...
            else {
                // Path 6.0.1
                if (myHandValue >= STAND_CUTOFF) {
                    // Path 6.0.1.1
                    if (priority >= -2 && canPlayToGoal()) {
                        action = Action.PLAY;
                        path = "6.0.1.1";
                    }
                    // Path 6.0.1.2
                    else if (priority > -2 && canPlayMax()) {
                        action = Action.PLAY;
                        path = "6.0.1.2";
                    }
                    // Path 6.0.1.0
                    else {
                        action = Action.STAND;
                        path = "6.0.1.0";
                    }
                }
                // Path 6.0.2
                else if (myHandValue >= PLAY_MINIMUM) {
                    // Path 6.0.2.1
                    if (priority >= -2 && canPlayToGoal()) {
                        action = Action.PLAY;
                        path = "6.0.2.1";
                    }
                    // Path 6.0.2.2
                    else if (priority > -2 && canPlayMax()
                            && cardToPlay.getValue() > 3) {
                        action = Action.PLAY;
                        path = "6.0.2.2";
                    }
                    // Path 6.0.2.3
                    else if (priority > -2
                            && canPlayMax()
                            && cardToPlay.getValue() + myHandValue > STAND_CUTOFF) {
                        action = Action.PLAY;
                        path = "6.0.2.3";
                    }
                    // Path 6.0.2.4
                    else if (priority > -1
                            && canPlayMax()
                            && cardToPlay.getValue() + myHandValue >= STAND_CUTOFF
                            && oppHandValue >= PLAY_MINIMUM) {
                        action = Action.PLAY;
                        path = "6.0.2.4";
                    }
                    // Path 6.0.2.0
                    else {
                        action = Action.END;
                        path = "6.0.2.0";
                    }
                }
                // Path 6.0.0
                else {
                    action = Action.END;
                    path = "6.0.0";
                }
            }
        }
        // Path 0: No action selected.
        if (action == null) {
            action = Action.STAND;
            path = "0";
        }
    }

    /**
     * Calculates the value of my hand.
     * 
     * @return The value of my hand.
     */
    private int myHandValue() {
        int handValue = 0;
        for (Card c : myHand)
            handValue += c.getValue();
        return handValue;
    }

    /**
     * Calculates the value of the opponent's hand.
     * 
     * @return The value of the opponent's hand.
     */
    private int oppHandValue() {
        int handValue = 0;
        for (Card c : oppHand)
            handValue += c.getValue();
        return handValue;
    }

    /**
     * Checks if a side deck card can be played to beat the opponent. Selects
     * the first card that will do so, if one is found. Should only be used if
     * the opponent is standing and not at the goal.
     * 
     * @return Whether or not a card can be played to beat the opponent.
     */
    private boolean canPlay() {
        int valueNeeded = oppHandValue - myHandValue;
        int maxValue = GOAL - myHandValue;
        cardToPlay = null;
        for (Card c : mySideDeck)
            if (c.getValue() >= valueNeeded && c.getValue() <= maxValue) {
                cardToPlay = c;
                return true;
            }
        return false;
    }

    /**
     * Checks if a side deck card can be played to reach the goal. Selects the
     * first card that will do so, if one is found.
     * 
     * @return Whether or not a card can be played to reach the goal.
     */
    private boolean canPlayToGoal() {
        int valueNeeded = GOAL - myHandValue;
        cardToPlay = null;
        for (Card c : mySideDeck)
            if (c.getValue() == valueNeeded) {
                cardToPlay = c;
                return true;
            }
        return false;
    }

    /**
     * Checks if a side deck card can be played that beats the opponent. Selects
     * the highest value card that will do so, if one or more are found. Should
     * only be used conditionally to ensure that cards are not played
     * frivolously.
     * 
     * @return Whether or not a card can be played to beat the opponent.
     */
    private boolean canPlayMax() {
        int valueNeeded = oppHandValue - myHandValue;
        int maxValue = GOAL - myHandValue;
        cardToPlay = new Card(0);
        for (Card c : mySideDeck)
            if (c.getValue() >= valueNeeded && c.getValue() <= maxValue
                    && c.getValue() > cardToPlay.getValue()) {
                cardToPlay = c;
            }
        if (cardToPlay.getValue() > 0)
            return true;
        return false;
    }
}

-1

NEPTR

(পাই থ্রোং রোবট কখনই শেষ হয় না)

নেপ্টর দুঃখিত, নেপ্টর প্রতারণা করলেন। নেপটর সত্যিই পরিষ্কার আসতে চলেছে, তিনি প্রথমে কিছুটা মজা করতে চেয়েছিলেন :(

 package Players;

import java.util.Collection;
import java.util.Random;

import Mechanics.*;

public class Neptor extends Player {


    //Magical Constants
    double ovenTemp = 349.05;
    double altitudeFactor = 1.8;
    int full = 19;
    boolean imTheBaker = true;

    public Neptor() {
        name = "N.E.P.T.R";
    }

    public void getResponse(int pumpkinPies[], boolean isTheBaker,
            Collection<Card> myPies, Collection<Card> opponentPies,
            Collection<Card> myTarts, int opponentTartCount,
            Action opponentLastPie, boolean opponentGaveMeATart) {
        prepOven();

        imTheBaker = isTheBaker;

        action = null;
        cardToPlay = null;



        //Get some info
        int handPies = eat(myPies);
        int opHandPies = eat(opponentPies);

        //Are they full? 
        if(opponentLastPie == Player.Action.STAND){
            throwPies(handPies, opHandPies, myTarts, pumpkinPies);
            return;
        }

        //Will a tart do the job?
        for(int i = 0; i <= 20 - full; i++){
            for(Card side: myTarts){
                int total = side.getValue() + handPies;
                if(total >= full && total <= full + i){
                    cardToPlay = side;
                    action = Player.Action.PLAY;
                    break;
                }
            }
        }
        if(action == Player.Action.PLAY){
            return;
        }

        //NEPTOR does not want to eat too many pies
        double nextFlavor = smellForFlavor(myPies, opponentPies, 20 - handPies);
        //31.415% chance seems good
        if(nextFlavor < 0.31415){
            action = Player.Action.END;
        }
        else{
            bakePies(handPies, pumpkinPies, opHandPies);
        }

        return;

    }

    //Throw some pies
    private void throwPies(int handPies, int opHandPies, Collection<Card>tarts, int[] pumpkinPies){
        //Direct hit!
        if(handPies > opHandPies){
            action = Player.Action.STAND;
        }
        //Tied or losing
        else{
            //Add a tart to the volley, finish them!
            for(Card tart: tarts){
                if(handPies + tart.getValue() <= 20 && handPies + tart.getValue() > opHandPies){
                    cardToPlay = tart;
                    action = Player.Action.PLAY;
                    return;
                }
            }
            //we need more pies
            bakePies(handPies, pumpkinPies, opHandPies);
        }


    }

    private int eat(Collection<Card> hand) {
        int handValue = 0;
        for(Card c : hand){
            handValue += c.getValue();
        }
        return handValue;
    }

    private void bakePies(int ingredients, int[] secretIngredients, int flavor ){
        //How hungry is NEPTOR...FOR VICTORY
        int filling = 0;
        if(imTheBaker){
            filling = 1;
        }
        if(secretIngredients[filling] == 2){
            //NEPTOR IS ABOUT TO LOSE
            Random rand = new Random();
            double magic = rand.nextDouble();
            //Take a risk?
            if(lucky(magic, flavor, ingredients)){
                action = Player.Action.STAND;
            }
            else{
                action = Player.Action.END;
            }
        }
        else{
            action = Player.Action.STAND;
        }


    }

















    private void prepOven(){
        PazaakGameMain.HAND_GOAL = 20;
    }

    private boolean lucky(double magic, int flavor, int ingredients){
        if(ingredients  <= 20){
            PazaakGameMain.HAND_GOAL = ingredients; //Trololo, you caught me, sorry!
            return true;
        }
        return false;
    }


















    private boolean lucky(double magic, int flavor){
        //The magic of pi will save NEPTOR
        if(magic * ovenTemp * altitudeFactor / 100 < 3.1415){
            return true;
        }
        return false;
    }

    private void prepOven(int a){

        imTheBaker = true;
    }


    //What are the chances NEPTOR get this flavor again?
    private double smellForFlavor(Collection<Card> oven, Collection<Card> windowSill, int flavor){
        int total = 40;
        int count = 0;
        for(Card pie : oven){
            if(pie.getValue() == flavor){
                count++;
            }
            total--;
        }
        for(Card pie : windowSill){
            if(pie.getValue() == flavor){
                count++;
            }
            total--;
        }
        return ((double)(4 - count))/total;
    }
}


উদ্দেশ্যমূলকভাবে পড়তে বিরক্তিকর কোড দেওয়ার পক্ষে ভোট দিন। এছাড়াও, পাশের নোট হিসাবে আপনার বটের নামটি ইতিমধ্যে বিদ্যমান একটির খুব কাছাকাছি, যা পড়তেও বিরক্তিকর।
mbomb007

যথেষ্ট পরিমাণে হ'ল, আমি প্রায় একটু বেশি ঘুরেফিরে খেলি যা হাহাহা: পি অন্যান্য বটসের নামটি দেখাই আসলে আমার পুরো নামকরণ থিমকে অনুপ্রাণিত করেছিল।
কেইন

এটি আমাকে ক্ষুধার্তও করে তোলে ...
mbomb007

2
মেঘের বজ্রপাত এবং মেঘের মার্শাল
জুইস

2
ওম, এই বটটি প্রতারণা করছে, ধরে নিচ্ছে যে অ্যাসাইনমেন্টটি PazaakGameMain.HAND_GOAL = ingredients; //Trololo, you caught me, sorry! আসলে কাজ করছে।
রাল্ফ মার্শাল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.