Letztes Mal habe ich die Deck-Funktion von Trump wie in [hier] gezeigt erstellt (https://qiita.com/p-t-a-p-1/items/ef34310e5a58fce8d217).
Mit der vorherigen Deck-Funktion habe ich diesmal versucht, die Hauptspielfunktion von Blackjack zu implementieren. Wie würden Sie tatsächlich ein Programm schreiben und das, was Sie gesagt haben, aus den bestehenden Anforderungen erweitern? Ich glaube, ich habe viel gelernt, indem ich darüber nachgedacht habe!
Die grundlegenden Regeln und Anforderungen finden Sie in Entwicklung von "Blackjack" für Abschlussprüfungen von Programmieranfängern. Vielen Dank!
- Die erste Karte ist 52. Stellen Sie sicher, dass beim Zeichnen keine doppelten Karten vorhanden sind
- Zwei Spieler und Dealer. Spieler laufen, Händler laufen automatisch
- Zu Beginn der Ausführung ziehen der Spieler und der Dealer jeweils zwei Karten. Die gezogene Karte wird auf dem Bildschirm angezeigt. Allerdings ** kenne die zweite Karte des Dealers nicht **
- Danach zieht der Spieler zuerst die Karte. Wenn die Anzahl der Spieler 21 überschreitet, endet das Spiel an diesem Punkt
- Spieler können jedes Mal, wenn sie eine Karte ziehen, die nächste Karte ziehen
- Sobald der Spieler das Zeichnen beendet hat, zieht der Dealer weiter, bis seine Hand 17 oder höher ist.
- Ein Spiel, bei dem der Spieler und der Dealer mit dem Zeichnen fertig sind. Derjenige, der näher an 21 ist, gewinnt
- J, Q und K werden als 10 behandelt
- ** A wird vorerst nur als "1" behandelt. ** Nicht auf "11" einstellen
- Keine Verdoppelung, keine Trennung, keine Kapitulation, keine anderen Sonderregeln
Dieses Mal habe ich zusätzlich zu diesen Anforderungen die folgenden Funktionen hinzugefügt.
Wir haben die folgenden Klassen vorbereitet und jede Datei getrennt. Die Kartenklasse und die Deckklasse haben keine Blackjack-spezifischen Spezifikationen, sodass sie in anderen Trump-Spielen verwendet werden können.
Ich habe den in diesem Artikel erstellten verwendet.
from bj import BlackJack
class Player:
"""
Kind (Spieler, der manuell bedient werden kann)
"""
def __init__(self):
self.win_count = 0
self.hands = []
self.card_current_score = 0
self.card_current_score_sub = 0
self.has_A_card = False
def keep_drawing_card(self, deck):
"""
Lassen Sie den Spieler entscheiden, ob er schlagen oder stehen möchte
(Stand beendet den Zug des Spielers)
Parameters
----------
deck : deck
Ein Kartensatz
"""
want_to_draw = True
while want_to_draw:
hit_or_stand_msg = "\nHit(1) or Stand(2) : "
hit_or_stand_res = input(hit_or_stand_msg)
if hit_or_stand_res == "1":
#1 Unentschieden für Treffer
self.draw_card(deck)
print(f"player draw card is : {self.hands[-1]}")
BlackJack.calc_current_score(self)
sub_score = ""
if self.has_A_card is True:
sub_score = \
f", {self.card_current_score_sub}"
print(
f"players's total_score : \
{self.card_current_score}{sub_score}")
#Erzwungene Beendigung des Spielzugs mit Burst
if BlackJack.is_score_bust(int(self.card_current_score)) and \
BlackJack.is_score_bust(
int(self.card_current_score_sub)):
print("player bust!!!")
want_to_draw = False
if self.card_current_score == 21 or \
self.card_current_score_sub == 21:
#Zwangsbeendigung bei Erreichen von 21
want_to_draw = False
elif hit_or_stand_res == "2":
#Im Falle eines Standes endet die Drehung
want_to_draw = False
else:
# 1,Geben Sie andere Befehle als 2 erneut ein
print("Ist nutzlos")
def draw_card(self, deck, num=1):
"""
Ziehe eine Karte aus dem Stapel und lege sie deiner Hand hinzu
* Auch wenn unterschiedliche Zahlen gezogen werden, ist dies in Ordnung
Parameters
----------
num : int, default 1
Häufigkeit, mit der eine Karte gezogen wird
Examples
--------
>>> player.draw_card(2) #2 Unentschieden[♠︎-J, ♠︎-10]
>>> player.draw_card(3) # [♦︎-9, ♣️-10, ♠︎-2]
>>> print(player.hands)
[♠︎-J, ♠︎-10, ♦︎-9, ♣️-10, ♠︎-2]
"""
self.hands_store = deck.pick_card(num)
self.hands.extend(self.hands_store)
class Dealer(Player):
"""
Eltern (automatischer Betrieb)
"""
def keep_drawing_card(self, deck):
"""
Der Dealer zieht automatisch Karten, bis sie 17 überschreiten
Beenden Sie, wenn 17 überschritten wird
Parameters
----------
deck : object
Aktuelle Hand
"""
self.has_A_card = False
while self.card_current_score < 17 or \
self.card_current_score_sub < 17:
self.draw_card(deck)
print(f"dealer draw card is : {self.hands[-1]}")
BlackJack.calc_current_score(self)
sub_score = ""
if self.has_A_card:
sub_score = \
f", {self.card_current_score_sub}"
print(
f"dealer's total_score : {self.card_current_score}{sub_score}")
if BlackJack.is_score_bust(self.card_current_score) and \
BlackJack.is_score_bust(
int(self.card_current_score_sub)):
print("dealer bust!!!")
from deck import stock
import role
from bj import BlackJack
class Game:
"""
Hauptspiel (Spieler- und Dealer-Instanz beim Erstellen der Instanz erstellen)
Examples
--------
>>> game = Game()
>>> game.main() #Spielstart (zeigt die Anfangsphase unten an)
dealer's hands : [❤︎-7, *-*]
player's hands : [♠︎-9, ♦︎-J]
players's total_score : 19
Hit(1) or Stand(2) :
"""
def __init__(self):
#Spieler und Dealer erstellen
self.player = role.Player()
self.dealer = role.Dealer()
def get_nearest_score(self, score_list):
"""
Gibt die Zahl zurück, die 21 unter 21 aus den Haupt- und Nebenergebnissen am nächsten kommt
Gibt 0 zurück, wenn beide 21 überschreiten
Parameters
----------
score_list : list
Liste der Haupt- und Nebenergebnisse
Returns
--------
main_score : int
Eine Zahl nahe 21 der beiden Punkte (0, wenn beide größer als 21 sind)
"""
main_score = 0
for score in score_list:
if score > 21:
#Zahlen größer als 21 platzen
continue
elif main_score < score:
main_score = score
return main_score
def judge_winner(self, player, dealer):
"""
Gewinn / Verlust-Urteil
Parameters
----------
dealer : object
Elternteil
player : object
Kind
"""
# player,Holen Sie sich und vergleichen Sie die Annäherung an 21 von 21 oder weniger in der Punktzahl jedes Händlers
player_score_list = [
player.card_current_score,
player.card_current_score_sub]
player_score = self.get_nearest_score(player_score_list)
dealer_score_list = [
dealer.card_current_score,
dealer.card_current_score_sub]
dealer_score = self.get_nearest_score(dealer_score_list)
judge_win = ""
#Beide Bursts werden gezogen
if player_score == 0 and dealer_score == 0:
judge_win = "---draw---"
if dealer_score < \
player_score <= 21:
# dealer < player <=Mit 21 gewinnt der Spieler
judge_win = "player win!"
player.win_count += 1
elif player_score <= 21 \
< dealer_score:
#Der Spieler gewinnt, wenn der Spieler 21 oder weniger ist, der Dealer platzt
judge_win = "player win!"
player.win_count += 1
elif player_score == dealer_score \
and player_score <= 21:
#Keiner platzt, und wenn die Zahlen gleich sind, ein Unentschieden
judge_win = "---draw---"
else:
#Ansonsten verlieren alle Spieler
judge_win = "dealer win!"
dealer.win_count += 1
#Konsolenanzeige
print(f"\n/***********/\n/{judge_win}/\n/***********/")
def display_final_result(
self,
player_win_count,
dealer_win_count,
total_count):
"""
Gewinn / Verlust-Urteil
Parameters
----------
player_win_count : int
Anzahl der Spieler gewinnt
dealer_win_count : int
Händler gewinnt
total_count : int
Gesamtzahl der Spiele
"""
#Berechnen Sie die Anzahl der Ziehungen, indem Sie die Anzahl der Gewinne von Spieler und Dealer von der Gesamtzahl der Spiele abziehen
draw_count = total_count - player_win_count - dealer_win_count
return f"""\
*-*-*-*-*-*-*-*
total：{total_count}
win：{player_win_count}
lose：{dealer_win_count}
draw：{draw_count}
*-*-*-*-*-*-*-*\
"""
def main(self):
"""
Blackjack Hauptspielfunktion
"""
#Deck-Set (Anzahl der Sets bestimmen)
deck = stock.Deck()
total_count = 0
can_play_game = True
#Wenn noch 5 oder mehr Karten übrig sind
while can_play_game and len(deck.cards) > 5:
self.player.hands = []
self.dealer.hands = []
#Anzahl von Spielen+1
total_count += 1
#Zeichne zuerst zwei
self.player.draw_card(deck, 2)
self.dealer.draw_card(deck, 2)
#Berechnung der anfänglichen Punktzahl des Spielers
BlackJack.calc_current_score(self.player)
#Wenn A subtrahiert wird, wird auch die Teilpunktzahl angezeigt.
player_sub_score = BlackJack.check_draw_A(self.player)
#Punkteanzeige zum Zeitpunkt der ersten Ziehung (eine auf der Händlerseite ist abgelehnt)
print("\n--Game Start--\n")
first_msg = f"""\
dealer's hands : [{self.dealer.hands[0]}, *-*]
player's hands : {self.player.hands}
players's total_score : {self.player.card_current_score}{player_sub_score}\
"""
print(f"{first_msg}")
#Lassen Sie den Spieler entscheiden, ob er trifft oder steht (der Stand beendet den Zug des Spielers)
self.player.keep_drawing_card(deck)
print("\n--Result--\n")
#Berechnung der Händlerpunktzahl
BlackJack.calc_current_score(self.dealer)
#Wenn A subtrahiert wird, wird auch die Teilpunktzahl angezeigt.
dealer_sub_score = BlackJack.check_draw_A(self.dealer)
dealer_msg = f"""\
dealer's hands : {self.dealer.hands}
dealer's total_score : {self.dealer.card_current_score}{dealer_sub_score}\
"""
print(f"{dealer_msg}")
#Zeichnen Sie, bis die Hand des Dealers 17 beträgt
self.dealer.keep_drawing_card(deck)
#Gewinn / Verlust-Urteil
self.judge_winner(self.player, self.dealer)
print("\n--Game End--\n")
#Spiel neu starten
restart_msg = "Q beendet das Spiel, andernfalls beginnt das Spiel:"
start_res = input(restart_msg)
if start_res == 'Q':
can_play_game = False
#Berechnen Sie die Anzahl der Spiele und die Anzahl der Gewinne und zeigen Sie sie an
final_score_str = self.display_final_result(
self.player.win_count, self.dealer.win_count, total_count)
print(final_score_str)
if __name__ == '__main__':
game = Game()
game.main()
class BlackJack:
"""
Blackjack Regeln
"""
RANKS = (*"A23456789", "10", *"JQK")
values = list(range(1, 11)) # 1〜10
values.extend([10, 10, 10]) # JQK
VALUES = (values)
#Verknüpfen Sie die Anzeigemarke mit der Partitur
# {'A': 1, '2': 2, '3': 3, '4': 4, '5': 5,
# '6': 6, '7': 7, '8': 8, '9': 9, '10': 10,
# 'J': 10, 'Q': 10, 'K': 10}
RANK_TO_VALUES = dict(zip(RANKS, VALUES))
@classmethod
def calc_current_score(cls, person):
"""
Berechnen Sie die aktuelle Punktzahl
Parameters
----------
person : object
Aktuelle Hand
Returns
--------
card_current_score : int
Momentaner Punktestand
"""
person.card_current_score = 0
person.card_current_score_sub = 0
person.has_A_card = False
for card in person.hands:
card_rank = str(card).split("-")[1]
card_value = cls.RANK_TO_VALUES[card_rank]
#Betrachten Sie die Zeit von A.
person.card_current_score += card_value
person.card_current_score_sub += card_value
if card_value == 1:
if person.has_A_card:
#Wenn A stetig ist, wird der Unterpunkt verdoppelt und der Unterpunkt hinzugefügt.+10(+11-1)
person.card_current_score_sub += 10
print(person.card_current_score_sub)
continue
person.has_A_card = True
person.card_current_score_sub += 11
@classmethod
def is_score_bust(cls, total_score):
"""
Berechnen Sie die aktuelle Punktzahl
Parameters
----------
current_hands : list
Aktuelle Hand
Returns
--------
True or False
Richtig im Burst
"""
return total_score > 21
@classmethod
def check_draw_A(cls, person):
"""
Wenn Sie ein A in der Hand haben, wird auch der Unterpunkt angezeigt
Parameters
----------
person : object
player or dealer
Returns
--------
person_sub_score : str
Unterstrich-Zeichenfolge (leeres Zeichen, wenn Sie kein A in der Hand haben)
"""
person_sub_score = ""
if person.has_A_card is True:
person_sub_score = f", {person.card_current_score_sub}"
return person_sub_score
Ich war darüber besorgt, aber ich habe von Anfang an einen Subcore vorbereitet, und als ich A subtrahierte, die Konsolenanzeige, Bei der Berechnung der Punktzahl habe ich sie als +1 für die Haupt- und +11 für die Nebenpartie implementiert. Ich denke, es gibt andere bessere Möglichkeiten. Ich konnte es ziemlich reibungslos implementieren, bis ich die Punktzahl mit A als 1 berechnet habe. Indem Sie es zu einer Möglichkeit machen, Unterpunkte vorzubereiten Ich denke, es war ein kleiner Fehler, dass die Verarbeitung der Punkteberechnung zugenommen hat.
Dieses Mal haben wir jeweils 2 Punkte für Spieler und Dealer In der Liste des jeweils anderen wurde die Punktzahl, die näher an 21 lag, ohne 21 zu überschreiten, als Bewertungspunktzahl verwendet.
Wenn beide Punktzahlen geplatzt sind, ist die Punktzahl 0, und wenn eine geplatzt ist, ist die andere die Beurteilungspunktzahl. → Es gibt keinen Spieler mehr als 17 (da es bei 16 ein Unentschieden gibt) → Der Händler zieht automatisch, bis beide Punkte 17 überschreiten
Wenn es ausgeführt wird, sieht es so aus. Schließlich werden die Anzahl der Spiele und die Anzahl der Spielergewinne angezeigt.
$ python main.py
--Game Start--
dealer's hands : [❤︎-J, *-*]
player's hands : [♦︎-3, ♠︎-3]
players's total_score : 6
Hit(1) or Stand(2) : 1
player draw card is : ♠︎-Q
players's total_score : 16
Hit(1) or Stand(2) : 1
player draw card is : ♠︎-5
players's total_score : 21
--Result--
dealer's hands : [❤︎-J, ♦︎-5]
dealer's total_score : 15
dealer draw card is : ❤︎-Q
dealer's total_score : 25
dealer burst!!!
/***********/
/player win!/
/***********/
--Game End--
Q beendet das Spiel, andernfalls beginnt das Spiel:
--Game Start--
dealer's hands : [♠︎-10, *-*]
player's hands : [♠︎-8, ♦︎-8]
players's total_score : 16
Hit(1) or Stand(2) : 2
--Result--
dealer's hands : [♠︎-10, ♣️-A]
dealer's total_score : 11, 22
dealer draw card is : ♣️-5
dealer's total_score : 16, 27
dealer draw card is : ♣️-Q
dealer's total_score : 26, 37
dealer burst!!!
/***********/
/player win!/
/***********/
--Game End--
Q beendet das Spiel, andernfalls beginnt das Spiel:
--Game Start--
dealer's hands : [❤︎-K, *-*]
player's hands : [♦︎-A, ♠︎-7]
players's total_score : 8, 19
Hit(1) or Stand(2) : 2
--Result--
dealer's hands : [❤︎-K, ♠︎-J]
dealer's total_score : 20
/***********/
/dealer win!/
/***********/
--Game End--
Beende das Spiel mit Q, starte das Spiel ansonsten: Q.
*-*-*-*-*-*-*-*
total：3
win：2
lose：1
draw：0
*-*-*-*-*-*-*-*
Double Down und Split sind zukünftige Themen.
Recommended Posts