Dans le jeu Yahtzee, les joueurs lancent à tour de rôle 5 dés à 6 faces jusqu'à trois fois par tour, économisant éventuellement des dés entre les lancers, puis sélectionnant une catégorie qu'ils souhaitent utiliser pour leur lancer. Cela continue jusqu'à ce qu'il n'y ait plus de catégories (ce qui se produit après 13 tours). Ensuite, les scores des joueurs sont comptabilisés et le joueur avec le score le plus élevé gagne.
Les catégories sont les suivantes («somme des dés» signifie additionner le nombre de pips sur les dés spécifiés):
- Section supérieure
- As : somme des dés montrant 1 pip
- Deux : somme des dés montrant 2 pips
- Trois : somme des dés montrant 3 pips
- Fours : somme des dés montrant 4 pips
- Fives : somme des dés montrant 5 pips
- Sixes : somme des dés montrant 6 pips
- Section inférieure
- Trois d'un genre : 3 dés avec la même valeur, le score est la somme de tous les dés
- Four of a Kind : 4 dés de même valeur, le score est la somme de tous les dés
- Full House : 3 dés avec une valeur et 2 avec une autre, le score est de 25
- Petite ligne droite : 4 dés séquentiels, le score est de 30
- Grande ligne droite : 5 dés séquentiels, le score est de 40
- Yahtzee : tous les 5 dés avec la même valeur, le score est de 50
- Chance : toute combinaison de dés, le score est la somme de tous les dés
Il existe quelques règles concernant les choix de catégorie:
- Si un joueur choisit une catégorie qui ne correspond pas à son jet, il reçoit un score de 0 pour cette catégorie.
- Si un joueur gagne un score d'au moins 63 dans la section supérieure, il reçoit 35 points bonus.
- Si un joueur a lancé un Yahtzee mais que la catégorie Yahtzee est déjà prise (par un autre Yahtzee - remplir 0 pour un échec ne compte pas), il reçoit un bonus de 100 points. Ce bonus est accordé pour chaque Yahtzee après le premier.
- De plus, le joueur doit toujours choisir de remplir une catégorie. Ils doivent choisir la catégorie de section supérieure correspondant à leur jet (par exemple un jet de 5 6 doit être placé dans la catégorie Sixes). Si la catégorie de section supérieure correspondante a déjà été utilisée, le Yahtzee peut être utilisé pour une catégorie de section inférieure (dans ce cas, choisir Full House, Small Straight ou Large Straight attribue le nombre normal de points plutôt que 0). Si toutes les catégories de la section inférieure sont prises, le Yahtzee peut être appliqué à une catégorie de section supérieure inutilisée, avec un score de 0.
Le défi
Dans ce défi, les concurrents joueront 1000 matchs de Yahtzee. À la fin de chaque partie, la ou les soumissions ayant obtenu le meilleur score recevront 1 point. Une fois tous les jeux terminés, la soumission avec le plus de points gagnera. S'il y a égalité, des parties supplémentaires seront jouées avec seulement les soumissions à égalité jusqu'à ce que l'égalité soit rompue.
Manette
Le code complet du contrôleur se trouve sur ce référentiel GitHub . Voici les interfaces publiques avec lesquelles les joueurs interagiront:
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);
}De plus, il existe certaines méthodes utilitaires dans Util.java. Ils sont principalement là pour simplifier le code du contrôleur, mais ils peuvent être utilisés par les joueurs s'ils le souhaitent.
Règles
- Les joueurs ne sont pas autorisés à interagir de quelque manière que ce soit, sauf en utilisant la
Scorecard.getScoresméthode pour voir les scores actuels de tous les joueurs. Cela inclut la collusion avec d'autres joueurs ou le sabotage d'autres joueurs via la manipulation de parties du système qui ne font pas partie de l'interface publique. - Si un joueur fait un mouvement illégal, il ne sera pas autorisé à participer au tournoi. Tous les problèmes qui provoquent des mouvements illégaux doivent être résolus avant le déroulement du tournoi.
- Si des soumissions supplémentaires sont faites après la fin du tournoi, un nouveau tournoi sera organisé avec les nouvelles soumissions et la soumission gagnante sera mise à jour en conséquence. Cependant, je ne garantis pas la rapidité du déroulement du nouveau tournoi.
- Les soumissions ne peuvent exploiter aucun bogue dans le code du contrôleur qui pourrait le faire dévier des règles de jeu réelles. Signalez-moi des bugs (dans un commentaire et / ou dans un problème GitHub), et je les corrigerai.
- L'utilisation des outils de réflexion de Java est interdite.
- Tout langage qui s'exécute sur la JVM, ou qui peut être compilé en Java ou en bytecode JVM (comme Scala ou Jython) peut être utilisé, tant que vous fournissez tout code supplémentaire nécessaire pour l'interfacer avec Java.
Commentaires finaux
S'il y a une méthode utilitaire que vous aimeriez que j'ajoute au contrôleur, demandez simplement dans les commentaires et / ou faites un problème sur GitHub, et je l'ajouterai, en supposant qu'il ne permet pas de briser les règles ou d'exposer des informations à quels joueurs ne sont pas au courant. Si vous voulez l'écrire vous-même et créer une pull request sur GitHub, c'est encore mieux!
ACES? Tu veux direONES? Ce sont des dés, pas des cartes.