ইয়াহটজি একটি খেলা খেলুন

18

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

বিভাগগুলি নিম্নরূপ:

  • আপার সেকশন
    • টেক্কা : 1 পিপ দেখানো পাশের সমষ্টি
    • দ্বাদশ : 2 পিপ দেখানো পাশের সমষ্টি
    • ত্রয়ী : 3 পিপস দেখানো পাশার সমষ্টি
    • চার : পাশা এর সমষ্টি 4 পিপস দেখাচ্ছে
    • পাঁচটি: পাইস যোগফল 5 পিপস দেখায়
    • ছক্কা : 6 পাইপ দেখানো পাশার সমষ্টি
  • লোয়ার সেকশন
    • এক ধরণের তিনটি : একই মান সহ 3 ডাইস, স্কোর সমস্ত ডাইসের সমষ্টি
    • এক ধরণের চারটি : একই মান সহ 4 ডাইস, স্কোর হ'ল সমস্ত পাশ্বের যোগফল
    • ফুল হাউস : একটি মান সহ 3 পাশা এবং অন্যের সাথে 2, স্কোর 25
    • ছোট সোজা : 4 অনুক্রমিক পাশা, স্কোর 30
    • বড় সোজা : 5 অনুক্রমিক পাশা, স্কোর 40
    • ইয়াহ্তজি : একই মান সহ সমস্ত 5 ডাইস, স্কোর 50
    • সম্ভাবনা : পাশা যে কোনও সংমিশ্রণ, স্কোর সমস্ত পাশা যোগফল

বিভাগের পছন্দগুলি সম্পর্কে কয়েকটি নিয়ম রয়েছে:

  • যদি কোনও খেলোয়াড় কোনও বিভাগ নির্বাচন করে যা তাদের রোলের সাথে মেলে না, তবে তারা এই বিভাগের জন্য 0 এর একটি স্কোর পাবে।
  • যদি কোনও খেলোয়াড় উপরের অংশে কমপক্ষে 63৩ স্কোর অর্জন করে তবে তারা 35 বোনাস পয়েন্ট পান।
  • যদি কোনও খেলোয়াড় কোনও ইয়াহ্তজি ঘূর্ণিত করে তবে ইয়াহ্তজি বিভাগটি ইতিমধ্যে নেওয়া হয় (অন্য ইয়াহ্তজি দ্বারা - একটি মিসের জন্য 0 পূরণ করা হয় না), তারা 100 পয়েন্টের বোনাস পান। এই বোনাসটি প্রথম ইয়াহতজির জন্য প্রথম দেওয়া হয়।
    • অতিরিক্তভাবে, খেলোয়াড়কে এখনও একটি বিভাগ পূরণ করতে বেছে নিতে হবে। তাদের অবশ্যই তাদের রোল অনুসারে উপরের বিভাগের বিভাগটি বেছে নিতে হবে (উদাহরণস্বরূপ 5 6 এর রোলটি সিক্সস বিভাগে স্থাপন করা উচিত)। সংশ্লিষ্ট উচ্চতর বিভাগ বিভাগটি ইতিমধ্যে ব্যবহার করা থাকলে, ইয়াহটজি একটি নিম্ন বিভাগের বিভাগের জন্য ব্যবহার করা যেতে পারে (এক্ষেত্রে ফুল হাউস, ছোট স্ট্রেইট বা বড় স্ট্রেইট পুরষ্কারগুলি 0 এর চেয়ে সাধারণ পরিমাণের পয়েন্টগুলি বেছে নেওয়া)। নীচের বিভাগের সমস্ত বিভাগ যদি নেওয়া হয়, তবে ইয়াহটজি 0 টি স্কোর সহ একটি অব্যবহৃত উপরের বিভাগে প্রয়োগ করা যেতে পারে।

চ্যালেঞ্জ

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

নিয়ামক

এই গিটহাব সংগ্রহস্থলে সম্পূর্ণ নিয়ামক কোডটি পাওয়া যাবে । এখানে এমন সর্বজনীন ইন্টারফেস রয়েছে যার সাথে খেলোয়াড়রা ইন্টারঅ্যাক্ট করবে:

public interface ScorecardInterface {

    // returns an array of unused categories
    Category[] getFreeCategories();

    // returns the current total score
    int getScore();

    // returns the current Yahtzee bonus
    int getYahtzeeBonus();

    // returns the current Upper Section bonus
    int getUpperBonus();

    // returns the current Upper Section total
    int getUpperScore();

}
public interface ControllerInterface {

    // returns the player's scorecard (cloned copy, so don't try any funny business)
    ScorecardInterface getScoreCard(Player p);

    // returns the current scores for all players, in no particular order
    // this allows players to compare themselves with the competition,
    //  without allowing them to know exactly who has what score (besides their own score),
    //  which (hopefully) eliminates any avenues for collusion or sabotage
    int[] getScores();

}
public enum Category {
    ACES,
    TWOS,
    THREES,
    FOURS,
    FIVES,
    SIXES,
    THREE_OF_A_KIND,
    FOUR_OF_A_KIND,
    FULL_HOUSE,
    SMALL_STRAIGHT,
    LARGE_STRAIGHT,
    YAHTZEE,
    CHANCE;

    // determines if the category is part of the upper section
    public boolean isUpper() {
        // implementation
    }

    // determines if the category is part of the lower section
    public boolean isLower() {
        // implementation
    }

    // determines if a given set of dice fits for the category
    public boolean matches(int[] dice) {
        // implementation
    }

    // calculates the score of a set of dice for the category
    public int getScore(int[] dice) {
        // implementation
    }

    // returns all categories that fit the given dice
    public static Category[] getMatchingCategories(int[] dice) {
        // implementation
    }
}
public class TurnChoice {

    // save the dice with the specified indexes (0-4 inclusive)
    public TurnChoice(int[] diceIndexes) {
        // implementation
    }

    // use the current dice for specified category
    public TurnChoice(Category categoryChosen) {
        // implementation
    }

}

public abstract class Player {

    protected ControllerInterface game;

    public Player(ControllerInterface game) {
        this.game = game;
    }

    public String getName() {
        return this.getClass().getSimpleName();
    }

    // to be implemented by players
    // dice is the current roll (an array of 5 integers in 1-6 inclusive)
    // stage is the current roll stage in the turn (0-2 inclusive)
    public abstract TurnChoice turn(int[] dice, int stage);

}

অতিরিক্তভাবে, এখানে কিছু ইউটিলিটি পদ্ধতি রয়েছে Util.java। তারা নিয়ামক কোডটি সরল করতে মূলত সেখানে রয়েছে, তবে তারা ইচ্ছা করলে প্লেয়াররা তাদের ব্যবহার করতে পারে।

বিধি

  • খেলোয়াড়দের Scorecard.getScoresসমস্ত খেলোয়াড়ের বর্তমান স্কোর দেখতে পদ্ধতিটি বাদ দিয়ে কোনওভাবেই ইন্টারঅ্যাক্ট করার অনুমতি নেই । এর মধ্যে অন্যান্য খেলোয়াড়দের সাথে জড়িত হওয়া বা জনসাধারণের ইন্টারফেসের অংশ নয় এমন সিস্টেমের অংশগুলিকে ম্যানিপুলেট করার মাধ্যমে অন্যান্য খেলোয়াড়দের নাশকতা অন্তর্ভুক্ত রয়েছে।
  • কোনও খেলোয়াড় যদি অবৈধ পদক্ষেপ নেয়, তাদের টুর্নামেন্টে অংশ নিতে দেওয়া হবে না। টুর্নামেন্ট পরিচালনার আগে যে কোনও সমস্যা অবৈধ পদক্ষেপের কারণ হতে হবে তা সমাধান করা উচিত।
  • টুর্নামেন্টটি চালানোর পরে যদি অতিরিক্ত জমা দেওয়া হয় তবে নতুন জমা দেওয়া (গুলি) নিয়ে একটি নতুন টুর্নামেন্ট পরিচালিত হবে এবং সেই অনুসারে বিজয়ী জমাটি আপডেট করা হবে। তবে, নতুন টুর্নামেন্টটি চালানোর ক্ষেত্রে আমি তাত্ক্ষণিকতার কোনও গ্যারান্টি রাখি না।
  • জমাগুলি কন্ট্রোলার কোডের কোনও বাগ ব্যবহার করতে পারে না যার ফলে এটি আসল গেমের বিধি থেকে বিচ্যুত হয়। আমার কাছে বাগগুলি চিহ্নিত করুন (একটি মন্তব্যে এবং / অথবা একটি গিটহাব ইস্যুতে) এবং আমি সেগুলি ঠিক করব।
  • জাভার প্রতিবিম্ব সরঞ্জামগুলির ব্যবহার নিষিদ্ধ।
  • JVM- তে চলমান বা জাভা বা জেভিএম বাইটকোড (যেমন স্কেলা বা জাইথন) তে সংকলন করা যায় এমন কোনও ভাষা ব্যবহার করা যেতে পারে, যতক্ষণ না আপনি জাভা দিয়ে ইন্টারফেস করার জন্য প্রয়োজনীয় কোনও অতিরিক্ত কোড সরবরাহ করেন।

চূড়ান্ত মন্তব্য

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

game  king-of-the-hill 
— ঐ মেগো
সূত্র
ACES? মানে ONES? এগুলি পাশা, কার্ড নয়।
— mbomb007
— মেগো
আমি যখন এটি খেলেছি তখন এটি বলা দেখে মনে পড়ে না তবে ঠিক আছে।
— mbomb007
পাশা সেট দিয়ে একটি প্রদত্ত বিভাগের জন্য স্কোর পাওয়ার জন্য কি কোনও পদ্ধতি আছে?
— mbomb007
@ mbomb007 না, তবে আমি অবশ্যই এটি তৈরি করতে পারি :)
— মেগো

উত্তর:

4

DummyPlayer

package mego.yahtzee;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class DummyPlayer extends Player {

    public DummyPlayer(ControllerInterface game) {
        super(game);
    }

    @Override
    public TurnChoice turn(int[] dice, int stage) {
        Category[] choices = game.getScoreCard(this).getFreeCategories();
        Category choice = choices[new Random().nextInt(choices.length)];
        if(IntStream.of(dice).allMatch(die -> die == dice[0])) {
            if(Stream.of(choices).filter(c -> c == Category.YAHTZEE).count() > 0) {
                choice = Category.YAHTZEE;
            } else if(Stream.of(choices).filter(c -> c == Util.intToUpperCategory(dice[0])).count() > 0) {
                choice = Util.intToUpperCategory(dice[0]);
            } else {
                choices = Stream.of(game.getScoreCard(this).getFreeCategories()).filter(c -> c.isLower()).toArray(Category[]::new);
                if(choices.length > 0) {
                    choice = choices[new Random().nextInt(choices.length)];
                } else {
                    choices = game.getScoreCard(this).getFreeCategories();
                    choice = choices[new Random().nextInt(choices.length)];
                }
            }
        }
        return new TurnChoice(choice);
    }

}

ইয়াহ্তজি নিয়ন্ত্রকের উপস্থিত সরঞ্জামগুলি কীভাবে ব্যবহার করতে হয় তার জন্য এই খেলোয়াড়টি এখানে একটি মৌলিক রূপরেখা হিসাবে পরিবেশন করতে এসেছেন। এটি যখনই সম্ভব ইয়াহটজি চয়ন করে এবং কঠোর জোকার বিধি মেনে চলার সময় অন্যথায় এলোমেলো পছন্দ করে।

— ঐ মেগো
সূত্র
1

Aces এবং আট

ঠিক আছে, আমি ইদানীং কতটা ব্যস্ত ছিলাম তার জন্য ধন্যবাদটি পছন্দ করতে আমার অনেক বেশি সময় নিয়েছিল took

package mego.yahtzee;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import static mego.yahtzee.Category.*;

public class AcesAndEights extends Player {
    private Category[] freeCategories, matchingCategories, usableCategories;

    public AcesAndEights(ControllerInterface game) {
        super(game);
    }

    @Override
    public TurnChoice turn(int[] dice, int stage) {
        List<Integer> holdIndices = new java.util.ArrayList<>();

        freeCategories = game.getScoreCard(this).getFreeCategories();

        matchingCategories = Category.getMatchingCategories(dice);
        Arrays.sort(matchingCategories);

        usableCategories = Arrays.stream(freeCategories)
                                 .filter(this::isMatchingCategory)
                                 .toArray(Category[]::new);
        Arrays.sort(usableCategories);

        if (isMatchingCategory(YAHTZEE))
            return doYahtzeeProcess(dice);

        if (isUsableCategory(FULL_HOUSE))
            return new TurnChoice(FULL_HOUSE);

        if (stage == 0 || stage == 1) {
            if (isMatchingCategory(THREE_OF_A_KIND)) {
                int num = 0;
                for (int i : dice) {
                    if (Util.count(Util.boxIntArray(dice), i) >= 3) {
                        num = i;
                        break;
                    }
                }
                for (int k = 0; k < 5; k++) {
                    if (dice[k] == num)
                        holdIndices.add(k);
                }
                return new TurnChoice(toIntArray(holdIndices.toArray(new Integer[0])));
            }

            if (isFreeCategory(LARGE_STRAIGHT) || isFreeCategory(SMALL_STRAIGHT)) {
                if (isUsableCategory(LARGE_STRAIGHT))
                    return new TurnChoice(LARGE_STRAIGHT);

                if (isMatchingCategory(SMALL_STRAIGHT)) {
                    if (!isFreeCategory(LARGE_STRAIGHT))
                        return new TurnChoice(SMALL_STRAIGHT);

                    int[] arr = Arrays.stream(Arrays.copyOf(dice, 5))
                                      .distinct()
                                      .sorted()
                                      .toArray();
                    List<Integer> l = Arrays.asList(Util.boxIntArray(dice));
                    if (Arrays.binarySearch(arr, 1) >= 0 && Arrays.binarySearch(arr, 2) >= 0) {
                        holdIndices.add(l.indexOf(1));
                        holdIndices.add(l.indexOf(2));
                        holdIndices.add(l.indexOf(3));
                        holdIndices.add(l.indexOf(4));
                    }
                    else if (Arrays.binarySearch(arr, 2) >= 0 && Arrays.binarySearch(arr, 3) >= 0) {
                        holdIndices.add(l.indexOf(2));
                        holdIndices.add(l.indexOf(3));
                        holdIndices.add(l.indexOf(4));
                        holdIndices.add(l.indexOf(5));
                    }
                    else {
                        holdIndices.add(l.indexOf(3));
                        holdIndices.add(l.indexOf(4));
                        holdIndices.add(l.indexOf(5));
                        holdIndices.add(l.indexOf(6));
                    }
                    return new TurnChoice(toIntArray(holdIndices.toArray(new Integer[0])));
                }
            }

            if (isFreeCategory(FULL_HOUSE)) {
                int o = 0, t = o;
                for (int k = 1; k <= 6; k++) {
                    if (Util.count(Util.boxIntArray(dice), k) == 2) {
                        if (o < 1)
                            o = k;
                        else
                            t = k;
                    }
                }

                if (o > 0 && t > 0) {
                    for (int k = 0; k < 5; k++) {
                        if (dice[k] == o || dice[k] == t)
                            holdIndices.add(k);
                    }
                    return new TurnChoice(toIntArray(holdIndices.toArray(new Integer[0])));
                }
            }
        }
        else {
            Arrays.sort(freeCategories, Comparator.comparingInt((Category c) -> c.getScore(dice))
                                                  .thenComparingInt(this::getPriority)
                                                  .reversed());
            return new TurnChoice(freeCategories[0]);
        }

        return new TurnChoice(new int[0]);
    }

    private TurnChoice doYahtzeeProcess(int[] dice) {
        if (isUsableCategory(YAHTZEE))
            return new TurnChoice(YAHTZEE);

        Category c = Util.intToUpperCategory(dice[0]);
        if (isUsableCategory(c))
            return new TurnChoice(c);

        Category[] arr = Arrays.stream(freeCategories)
                               .filter(x -> x.isLower())
                               .sorted(Comparator.comparing(this::getPriority)
                                                 .reversed())
                               .toArray(Category[]::new);
        if (arr.length > 0)
            return new TurnChoice(arr[0]);

        Arrays.sort(freeCategories, Comparator.comparingInt(this::getPriority));
        return new TurnChoice(freeCategories[0]);
    }

    private boolean isFreeCategory(Category c) {
        return Arrays.binarySearch(freeCategories, c) >= 0;
    }

    private boolean isMatchingCategory(Category c) {
        return Arrays.binarySearch(matchingCategories, c) >= 0;
    }

    private boolean isUsableCategory(Category c) {
        return Arrays.binarySearch(usableCategories, c) >= 0;
    }

    private int getPriority(Category c) {
        switch (c) {
            case YAHTZEE: return -3;        // 50 points
            case LARGE_STRAIGHT: return -1; // 40 points
            case SMALL_STRAIGHT: return -2; // 30 points
            case FULL_HOUSE: return 10;     // 25 points
            case FOUR_OF_A_KIND: return 9;  // sum
            case THREE_OF_A_KIND: return 8; // sum
            case SIXES: return 7;
            case FIVES: return 6;
            case FOURS: return 5;
            case THREES: return 4;
            case TWOS: return 3;
            case ACES: return 2;
            case CHANCE: return 1;          // sum
        }
        throw new RuntimeException();
    }

    private int[] toIntArray(Integer[] arr) {
        int[] a = new int[arr.length];
        for (int k = 0; k < a.length; k++)
            a[k] = arr[k];
        return a;
    }
}

বটটি পাশ্বের নিদর্শনগুলির সন্ধান করে যা নির্দিষ্ট বিভাগগুলির সাথে মেলে এবং প্রয়োজনীয়গুলি ধারণ করে। এটি যদি পাওয়া যায় তবে তাৎক্ষণিকভাবে একটি উচ্চ-অগ্রাধিকার মেলা বিভাগটি চয়ন করে; অন্যথায় এটি এমন একটি বিভাগ নির্বাচন করে যা সর্বোচ্চ স্কোর দেয়। গড়ে প্রতি খেলায় প্রায় 200 পয়েন্ট স্কোর করে।

— টিঅ্যান্ডটি
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.