TL;DR Ich habe den mit TypeScript in Java während des GW-Zeitraums im letzten Jahr erstellten Blackjack neu erstellt, damit das Arbeitsprotokoll.
Card
////////////////////////////////////////////////////////////////////////////////
/// @file Card.java
/// @kurze Kartenklasse
/// @author Yuta Yoshinaga
/// @date 2019.04.27
/// $Version: $
/// $Revision: $
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Kopieren (Kopieren) eines Teils oder der gesamten Software ohne Erlaubnis
///Dies ist eine Urheberrechtsverletzung und verboten.
/// -In Bezug auf die Verletzung oder Verletzung von Patentrechten oder anderen Rechten, die durch die Verwendung dieses Produkts verursacht werden
///Wir übernehmen keine Verantwortung.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;
////////////////////////////////////////////////////////////////////////////////
/// @class Card
/// @kurze Kartenklasse
///
////////////////////////////////////////////////////////////////////////////////
public class Card {
public static final int DEF_CARD_TYPE_JOKER = 0;
public static final int DEF_CARD_TYPE_SPADE = 1;
public static final int DEF_CARD_TYPE_CLOVER = 2;
public static final int DEF_CARD_TYPE_HEART = 3;
public static final int DEF_CARD_TYPE_DIAMOND = 4;
public static final int DEF_CARD_TYPE_MIN = DEF_CARD_TYPE_JOKER;
public static final int DEF_CARD_TYPE_MAX = DEF_CARD_TYPE_DIAMOND;
public static final int DEF_CARD_VALUE_JOKER = 0;
public static final int DEF_CARD_VALUE_MIN = 0;
public static final int DEF_CARD_VALUE_MAX = 13;
private int type; //!<Speicherkarten-Typ
private int value; //!<Kartenwert
private boolean drowFlag; //!<Kartenauszahlungsflagge
private String ext; //!<Kartenerweiterungsinformationen usw.(Beim Senden einer Nachricht für jede Karte usw.)
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Konstruktor
/// @fn public Card()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public Card() {
this.type = DEF_CARD_TYPE_JOKER;
this.value = DEF_CARD_VALUE_JOKER;
this.drowFlag = false;
this.ext = "";
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public int getType()
/// @Rückgabekartentyp
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int getType() {
return type;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setType(int type)
/// @param[in]int type Kartentyp
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setType(int type) {
if(DEF_CARD_TYPE_MIN <= type && type <= DEF_CARD_TYPE_MAX){
this.type = type;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public getValue(): number
/// @Rückgabekartenwert
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int getValue() {
return value;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setValue(int value)
/// @param[in]int value card value
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setValue(int value) {
if(DEF_CARD_VALUE_MIN <= value && value <= DEF_CARD_VALUE_MAX){
this.value = value;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public boolean getDrowFlag()
/// @Auszahlungsflag der Rückgabekarte
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public boolean getDrowFlag() {
return drowFlag;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setDrowFlag(boolean drowFlag)
/// @param[in]boolean drowFlag Kartenauszahlungsflag
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setDrowFlag(boolean drowFlag) {
this.drowFlag = drowFlag;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public String getExt()
/// @Auszahlungsflag der Rückgabekarte
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public String getExt() {
return ext;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setExt(String ext)
/// @param[in]String ext Kartenerweiterungsinformationen usw.(Beim Senden einer Nachricht für jede Karte usw.)
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setExt(String ext) {
this.ext = ext;
}
}
Eine Klasse, die Trump-Karteninformationen enthält.
TrumpCards
////////////////////////////////////////////////////////////////////////////////
/// @file TrumpCards.java
/// @kurze Trump-Kartenklasse
/// @author Yuta Yoshinaga
/// @date 2019.04.27
/// $Version: $
/// $Revision: $
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Kopieren (Kopieren) eines Teils oder der gesamten Software ohne Erlaubnis
///Dies ist eine Urheberrechtsverletzung und verboten.
/// -In Bezug auf die Verletzung oder Verletzung von Patentrechten oder anderen Rechten, die durch die Verwendung dieses Produkts verursacht werden
///Wir übernehmen keine Verantwortung.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;
import java.util.ArrayList;
import java.util.Collections;
////////////////////////////////////////////////////////////////////////////////
/// @class TrumpCards
/// @kurze Trump-Kartenklasse
///
////////////////////////////////////////////////////////////////////////////////
public class TrumpCards {
public static final int DEF_CARD_CNT = (13 * 4);
private ArrayList<Card> deck; //!<Deck
private int deckDrowCnt; //!<Anzahl der verteilten Karten
private int deckCnt; //!<Anzahl der Decks
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Konstruktor
/// @fn public TrumpCards(int jokerCnt)
/// @param[in]int jokerCnt Anzahl der Joker
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public TrumpCards(int jokerCnt) {
this.deckCnt = DEF_CARD_CNT + jokerCnt;
this.cardsInit();
this.deckInit();
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public ArrayList<Card> getDeck()
/// @Deck zurück
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public ArrayList<Card> getDeck() {
return deck;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setDeck(ArrayList<Card> deck)
/// @param[in] ArrayList<Card>Deck Deck
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setDeck(ArrayList<Card> deck) {
this.deck = deck;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public int getDeckDrowCnt()
/// @return Anzahl der behandelten Decks
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int getDeckDrowCnt() {
return deckDrowCnt;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setDeckDrowCnt(int deckDrowCnt)
/// @param[in]int deckDrowCnt Anzahl der behandelten Decks
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setDeckDrowCnt(int deckDrowCnt) {
this.deckDrowCnt = deckDrowCnt;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public int getDeckCnt()
/// @return Anzahl der Decks
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int getDeckCnt() {
return deckCnt;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setDeckCnt(int deckCnt)
/// @param[in]int deckCnt Anzahl der Decks
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setDeckCnt(int deckCnt) {
this.deckCnt = deckCnt;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurze Karteninitialisierung
/// @fn private void cardsInit()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
private void cardsInit() {
this.deck = new ArrayList<Card>();
for (int i = 0; i < this.deckCnt; i++) {
Card curCard = new Card();
curCard.setDrowFlag(false);
if (0 <= i && i <= 12) {
// ***Spaten*** //
curCard.setType(Card.DEF_CARD_TYPE_SPADE);
curCard.setValue(i + 1);
} else if (13 <= i && i <= 25) {
// ***Kleeblatt*** //
curCard.setType(Card.DEF_CARD_TYPE_CLOVER);
curCard.setValue((i - 13) + 1);
} else if (26 <= i && i <= 38) {
// ***Herz*** //
curCard.setType(Card.DEF_CARD_TYPE_HEART);
curCard.setValue((i - 26) + 1);
} else if (39 <= i && i <= 51) {
// ***Diamant*** //
curCard.setType(Card.DEF_CARD_TYPE_DIAMOND);
curCard.setValue((i - 39) + 1);
} else {
// ***Joker*** //
curCard.setType(Card.DEF_CARD_TYPE_JOKER);
curCard.setValue((i - 52) + 1);
}
this.deck.add(curCard);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurze Initialisierung des Decks
/// @fn private void deckInit()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
private void deckInit() {
this.deckDrowFlagInit();
this.deckDrowCnt = 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurz Initialize Deck Draw Flag
/// @fn private deckDrowFlagInit(): void
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
private void deckDrowFlagInit() {
for (int i = 0; i < this.deckCnt; i++) {
this.deck.get(i).setDrowFlag(false);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzes Deck mischen
/// @fn public shuffle(): void
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void shuffle() {
Collections.shuffle(this.deck);
this.deckDrowFlagInit();
this.deckDrowCnt = 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurz Verteilen Sie das Deck
/// @fn public drowCard(): Card
/// @Rückgabekartenklasse
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public Card drowCard() {
Card res = null;
if (this.deckDrowCnt < this.deckCnt) {
this.deck.get(this.deckDrowCnt).setDrowFlag(true);
res = this.deck.get(this.deckDrowCnt++);
}
return res;
}
}
Eine Klasse, die Kartenspiele verwaltet.
Player
////////////////////////////////////////////////////////////////////////////////
/// @file Player.java
/// @kurze Spielerklasse
/// @author Yuta Yoshinaga
/// @date 2019.04.27
/// $Version: $
/// $Revision: $
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Kopieren (Kopieren) eines Teils oder der gesamten Software ohne Erlaubnis
///Dies ist eine Urheberrechtsverletzung und verboten.
/// -In Bezug auf die Verletzung oder Verletzung von Patentrechten oder anderen Rechten, die durch die Verwendung dieses Produkts verursacht werden
///Wir übernehmen keine Verantwortung.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;
import java.util.ArrayList;
////////////////////////////////////////////////////////////////////////////////
/// @class Player
/// @kurze Spielerklasse
///
////////////////////////////////////////////////////////////////////////////////
public class Player {
private ArrayList<Card> cards; //!<Spielerkarte
private int cardsCnt; //!<Anzahl der Spielerkarten
private int score; //!<Spielerwertung
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Konstruktor
/// @fn public Player()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public Player() {
this.cards = new ArrayList<Card>();
this.cardsCnt = 0;
this.score = 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn ArrayList<Card> getCards()
/// @Spielerkarte zurückgeben
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public ArrayList<Card> getCards() {
return cards;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setCards(ArrayList<Card> cards)
/// @param[in] ArrayList<Card>Karten Spielerkarten
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setCards(ArrayList<Card> cards) {
this.cards = cards;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public int getCardsCnt()
/// @return Anzahl der Spielerkarten
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int getCardsCnt() {
return cardsCnt;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setCardsCnt(int cardsCnt)
/// @param[in]int cardCnt Anzahl der Spielerkarten
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setCardsCnt(int cardsCnt) {
this.cardsCnt = cardsCnt;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public int getScore()
/// @Spieler-Punktzahl zurückgeben
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int getScore() {
return score;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setScore(int score)
/// @param[in]int score player score
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setScore(int score) {
this.score = score;
}
}
Klasse, die Spielerinformationen für Blackjack enthält
BlackJack
////////////////////////////////////////////////////////////////////////////////
/// @file BlackJack.java
/// @kurze Blackjack Klasse
/// @author Yuta Yoshinaga
/// @date 2019.04.27
/// $Version: $
/// $Revision: $
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Kopieren (Kopieren) eines Teils oder der gesamten Software ohne Erlaubnis
///Dies ist eine Urheberrechtsverletzung und verboten.
/// -In Bezug auf die Verletzung oder Verletzung von Patentrechten oder anderen Rechten, die durch die Verwendung dieses Produkts verursacht werden
///Wir übernehmen keine Verantwortung.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;
import java.util.ArrayList;
////////////////////////////////////////////////////////////////////////////////
/// @class BlackJack
/// @kurze Blackjack Klasse
///
////////////////////////////////////////////////////////////////////////////////
public class BlackJack {
public static final int DEF_SHUFFLE_CNT = 10;
private TrumpCards trumpCards; //!<Trumpfkarte
private Player player; //!<Spieler
private Player dealer; //!<Händler
private boolean gameEndFlag; //!<Flag zum Ende des Spiels
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Konstruktor
/// @fn public BlackJack()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public BlackJack() {
this.trumpCards = new TrumpCards(0);
this.player = new Player();
this.dealer = new Player();
this.gameInit();
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn TrumpCards getTrumpCards()
/// @Trump-Karte zurückgeben
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public TrumpCards getTrumpCards() {
return trumpCards;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setTrumpCards(TrumpCards trumpCards)
/// @param[in]TrumpCards trumpCards Trump Cards
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setTrumpCards(TrumpCards trumpCards) {
this.trumpCards = trumpCards;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public Player getPlayer()
/// @Spieler zurück
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public Player getPlayer() {
return player;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setPlayer(Player player)
/// @param[in]Spieler Spieler Spieler
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setPlayer(Player player) {
this.player = player;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public Player getDealer()
/// @Händler zurückgeben
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public Player getDealer() {
return dealer;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setDealer(Player dealer)
/// @param[in]Spieler Dealer
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setDealer(Player dealer) {
this.dealer = dealer;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Getter
/// @fn public boolean getGameEndFlag()
/// @Händler zurückgeben
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public boolean getGameEndFlag() {
return gameEndFlag;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Setter
/// @fn public void setGameEndFlag(boolean gameEndFlag)
/// @param[in]boolean gameEndFlag Spielende-Flag
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void setGameEndFlag(boolean gameEndFlag) {
this.gameEndFlag = gameEndFlag;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurze Spielinitialisierung
/// @fn public void gameInit()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void gameInit() {
this.gameEndFlag = false;
// ***Deck mischen*** //
for (int i = 0; i < DEF_SHUFFLE_CNT; i++) {
this.trumpCards.shuffle();
}
// ***Player / Dealer-Initialisierung*** //
this.player.setCards(new ArrayList<Card>());
this.player.setCardsCnt(0);
this.dealer.setCards(new ArrayList<Card>());
this.dealer.setCardsCnt(0);
// ***Deal jeweils 2 Spieler / Dealer*** //
for (int i = 0; i < 2; i++) {
this.player.getCards().add(this.trumpCards.drowCard());
this.player.setCardsCnt(this.player.getCardsCnt() + 1);
this.dealer.getCards().add(this.trumpCards.drowCard());
this.dealer.setCardsCnt(this.dealer.getCardsCnt() + 1);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Spielertreffer
/// @fn public void playerHit()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void playerHit() {
if (this.gameEndFlag == false) {
this.player.getCards().add(this.trumpCards.drowCard());
this.player.setCardsCnt(this.player.getCardsCnt() + 1);
int score = this.getScore(this.player.getCards(), this.player.getCardsCnt());
if (22 <= score)
this.playerStand(); //Erzwungene Beendigung, weil es platzte
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Spielerstand
/// @fn public void playerStand()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void playerStand() {
this.dealerHit();
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Dealer getroffen
/// @fn private void dealerHit()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
private void dealerHit() {
for (;;) {
int score = this.getScore(this.dealer.getCards(), this.dealer.getCardsCnt());
if (score < 17) {
// ***Dealer bis die Gesamtzahl der Karten, die sie haben, "17" oder höher ist*** //
// ***Schlagen Sie weiter (ziehen Sie weiter Karten)*** //
this.dealer.getCards().add(this.trumpCards.drowCard());
this.dealer.setCardsCnt(this.dealer.getCardsCnt() + 1);
} else {
// ***Händler sollten insgesamt "17" oder mehr auf ihren Karten haben*** //
// ***Bleib (ziehe keine Karte).*** //
this.dealerStand();
break;
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzer Händlerstand
/// @fn private void dealerStand()
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
private void dealerStand() {
this.gameEndFlag = true;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurz Holen Sie sich die aktuelle Punktzahl aus Ihrer Hand
/// @fn public int getScore(ArrayList<Card> cards,int cardsCnt)
/// @param[in] ArrayList<Card>Karten Hand
/// @param[in]int cardCnt Anzahl der Karten in der Hand
/// @return Aktuelle Punktzahl
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int getScore(ArrayList<Card> cards, int cardsCnt) {
int res = 0;
boolean aceFlag = false;
for (int i = 0; i < cardsCnt; i++) {
if (2 <= cards.get(i).getValue() && cards.get(i).getValue() <= 10) {
// *** 2～10 *** //
res += cards.get(i).getValue();
} else if (11 <= cards.get(i).getValue() && cards.get(i).getValue() <= 13) {
// *** 11～13 *** //
res += 10;
} else {
if (aceFlag) {
// ***Das zweite Ass wird gewaltsam in 1 umgewandelt.*** //
res += 1;
} else {
// ***Ass wird später berechnet*** //
aceFlag = true;
}
}
}
if (aceFlag) {
// ***Assberechnung*** //
var tmpScore1 = res + 1;
var tmpScore2 = res + 11;
var diff1 = 21 - tmpScore1;
var diff2 = 21 - tmpScore2;
if ((22 <= tmpScore1) && (22 <= tmpScore2)) {
// ***1 Ass, wenn beide platzen*** //
res = tmpScore1;
} else if ((22 <= tmpScore1) && (tmpScore2 <= 21)) {
// ***Wenn das Ass bei 1 platzt, ist das Ass 11*** //
res = tmpScore2;
} else if ((tmpScore1 <= 21) && (22 <= tmpScore2)) {
// ***Wenn das Ass bei 11 platzt, 1 Ass*** //
res = tmpScore1;
} else {
// ***Wenn keiner platzt, verwenden Sie den mit dem kleineren Unterschied von 21.*** //
if (diff1 < diff2)
res = tmpScore1;
else
res = tmpScore2;
}
}
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @kurzes Spielgewinn / -verlust-Urteil
/// @fn public int gameJudgment()
/// @Rückgewinn / Verlust-Urteil des Spiels
/// - 1 :Spielersieg
/// - 0 :zeichnen
/// - -1 :Niederlage des Spielers
///
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public int gameJudgment() {
int res = 0;
int score1 = this.getScore(this.player.getCards(), this.player.getCardsCnt());
int score2 = this.getScore(this.dealer.getCards(), this.dealer.getCardsCnt());
int diff1 = 21 - score1;
int diff2 = 21 - score2;
if (22 <= score1 && 22 <= score2) {
// ***Verlieren, weil sowohl Spieler als auch Dealer platzen*** //
res = -1;
} else if (22 <= score1 && score2 <= 21) {
// ***Verlieren, weil der Spieler platzt*** //
res = -1;
} else if (score1 <= 21 && 22 <= score2) {
// ***Gewinnen Sie, weil der Dealer platzt*** //
res = 1;
} else {
if (diff1 == diff2) {
// ***Zeichnen Sie, wenn die Punktzahl gleich ist*** //
res = 0;
if (score1 == 21 && this.player.getCardsCnt() == 2 && this.dealer.getCardsCnt() != 2) {
// ***Wenn nur der Spieler reiner Blackjack ist, gewinnt der Spieler*** //
res = 1;
}
} else if (diff1 < diff2) {
// ***Der Spieler ist näher an 21 und gewinnt*** //
res = 1;
} else {
// ***Der Dealer ist näher an 21, also verliere ich*** //
res = -1;
}
}
return res;
}
}
Blackjack Eine Klasse, die das Spiel und den Spielerstatus verwaltet.
BlackJackMain
////////////////////////////////////////////////////////////////////////////////
/// @file BlackJackMain.java
/// @kurze Blackjack Hauptklasse
/// @author Yuta Yoshinaga
/// @date 2019.04.27
/// $Version: $
/// $Revision: $
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Kopieren (Kopieren) eines Teils oder der gesamten Software ohne Erlaubnis
///Dies ist eine Urheberrechtsverletzung und verboten.
/// -In Bezug auf die Verletzung oder Verletzung von Patentrechten oder anderen Rechten, die durch die Verwendung dieses Produkts verursacht werden
///Wir übernehmen keine Verantwortung.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;
import java.util.ArrayList;
import java.util.Scanner;
////////////////////////////////////////////////////////////////////////////////
/// @class BlackJackMain
/// @kurze Blackjack Hauptklasse
///
////////////////////////////////////////////////////////////////////////////////
public class BlackJackMain {
////////////////////////////////////////////////////////////////////////////////
/// @kurze Hauptmethode
/// @fn public static void main(String[] args)
/// @param[in] String[] args
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
BlackJackMain blackJackMain = new BlackJackMain();
BlackJack blackJack = new BlackJack();
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("Please enter a command.");
System.out.println("q ・ ・ ・ beenden");
System.out.println("r ・ ・ ・ zurücksetzen");
System.out.println("h ・ ・ ・ getroffen");
System.out.println("s ・ ・ ・ stehen");
blackJackMain.showStatus(blackJack);
String inputStr = sc.nextLine();
switch (inputStr) {
case "q":
case "quit":
// quit
System.out.println("bye.");
sc.close();
System.exit(0);
break;
case "r":
case "reset":
// reset
blackJack.gameInit();
break;
case "h":
case "hit":
// hit
blackJack.playerHit();
break;
case "s":
case "stand":
// stand
blackJack.playerStand();
break;
default:
// Unsupported command
System.out.println("Unsupported command.");
break;
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurze Statusanzeige
/// @fn public void showStatus(BlackJack blackJack)
/// @param[in] BlackJack blackJack
/// @keine Rückkehr
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public void showStatus(BlackJack blackJack) {
System.out.println("----------");
// dealer
ArrayList<Card> dc = blackJack.getDealer().getCards();
int dcc = blackJack.getDealer().getCardsCnt();
System.out.println("dealer score " + (blackJack.getGameEndFlag() ? blackJack.getScore(dc, dcc) : ""));
String cardStr = "";
if (blackJack.getGameEndFlag()) {
for (int i = 0; i < dcc; i++) {
if (i != 0)
cardStr += ",";
cardStr += getCardStr(dc.get(i));
}
} else {
cardStr = getCardStr(dc.get(0)) + ",*";
}
System.out.println(cardStr);
System.out.println("----------");
// player
ArrayList<Card> pc = blackJack.getPlayer().getCards();
int pcc = blackJack.getPlayer().getCardsCnt();
System.out.println("player score " + blackJack.getScore(pc, pcc));
cardStr = "";
for (int i = 0; i < pcc; i++) {
if (i != 0)
cardStr += ",";
cardStr += getCardStr(pc.get(i));
}
System.out.println(cardStr);
System.out.println("----------");
if (blackJack.getGameEndFlag()) {
if (blackJack.gameJudgment() == 1) {
System.out.println("You are the winner.");
} else if (blackJack.gameJudgment() == 0) {
System.out.println("It is a draw.");
} else {
System.out.println("It is your loss.");
}
System.out.println("----------");
}
}
////////////////////////////////////////////////////////////////////////////////
/// @kurz Karteninformationszeichenfolge abrufen
/// @fn public String getCardStr(Card card)
/// @param[in] Card card
/// @return Karteninformationszeichenfolge abrufen
/// @author Yuta Yoshinaga
/// @date 2019.04.27
///
////////////////////////////////////////////////////////////////////////////////
public String getCardStr(Card card) {
String res = "";
switch (card.getType()) {
case Card.DEF_CARD_TYPE_SPADE:
res = "SPADE ";
break;
case Card.DEF_CARD_TYPE_CLOVER:
res = "CLOVER ";
break;
case Card.DEF_CARD_TYPE_HEART:
res = "HEART ";
break;
case Card.DEF_CARD_TYPE_DIAMOND:
res = "DIAMOND ";
break;
default:
res = "Unsupported card";
break;
}
res = res + card.getValue();
return res;
}
}
Eine Klasse zum Spielen von Blackjack-Spielen auf der Konsole. Führen Sie die entsprechende Aktion als Reaktion auf Eingaben von der Konsole aus.
Recommended Posts