【Python】【原创】21点游戏

简介      

        21点（Blackjack）是一款非常流行的纸牌游戏，玩家的目标是通过手中的牌尽量接近21点，且不能超过21点。如果玩家点数超过21点，则视为“爆掉”，庄家获胜。如果庄家的点数超过21点，则玩家获胜。本游戏的规则遵循经典的21点游戏规则。


安装与配置      
        在使用此代码之前，您需要安装Python环境，并确保具备安装有Python 3.10及以上版本：本游戏代码是用Python编写的。您可以从Python官网下载并安装Python。


安装步骤      
        从Python官网下载安装包，按照安装向导安装Python。安装过程中确保勾选了“Add Python to PATH”选项，这样您可以在终端或命令行中直接使用Python。安装完成后，打开命令行（Windows用户可以打开CMD，Mac用户可以打开终端），输入以下命令以验证安装是否成功：

1. python --version

复制代码

        如果显示Python版本号，则安装成功。
将提供的21点游戏代码文件保存为一个.py文件，例如blackjack.py。
        确保代码文件位于您可以方便访问的位置。
        在命令行中，导航到存储代码的文件夹，并运行以下命令来启动游戏：

1. python blackjack.py

复制代码

实例化对象      
      要玩游戏，请在命令行输入：

1. bj = Blackjack()
   
2. bj.start_game()

复制代码

看牌      
        若想知道你的手牌，请在命令行输入：

1. bj.your_cards()

复制代码

        游戏未结束前，你可以查看庄家的第一张牌（明牌）：

1. bj.peek()

复制代码

        游戏结束后，你可以看庄家的手牌，复盘你的得失：

1. bj.see_banker_cards()

复制代码

你的回合      
        输入窗口会在你的回合中提醒你是否要牌，或者结束你的回合：

1. During your turn, you can continue choose "hit" for one more card until you get 21, or fail to bust, or choose "stand" your turn.

复制代码

        你可以选择要牌，在你得到21点获得胜利，或者因爆牌输掉之前：

1. hit
   
2. hit
   
3. hit

复制代码

        再或者你觉得你势在必得，或者见好就收，你可以停牌：

1. stand

复制代码

        很快，你将验收你的成果，或是赢的游戏，或是输掉结局，更或者你会罕见地获得一份“和平”：

1. win

复制代码

1. fail

复制代码

1. even

复制代码

        无论如何，这都是一份很简单的游戏，你只负责做出选择，还是说，并不是？


源代码      
        源代码见下，非常简单易懂：

1. import random
   
2. 
   
3. SUITS = ['梅花', '方块', '红心', '黑桃']
   
4. RANKS = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
   
5. DOT = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10, 'J': 10,  'Q': 10, 'K': 10}
   
6. 
   
7. class Blackjack:
   
8.    
   
9.     def __init__(self):
   
10.         self._deck = []
    
11.         self._banker = []
    
12.         self._player = []
    
13.         self.is_start = False
    
14.         self.has_end = False
    
15.     def _shuffle(self):
    
16.         deck = [(suit, rank) for suit in SUITS for rank in RANKS]
    
17.         random.shuffle(deck)
    
18.         return deck
    
19.     def _hit(self):
    
20.         return self._deck.pop()
    
21.     def peek(self):
    
22.         if self.is_start:
    
23.             return self._banker[0]
    
24.         return None
    
25.     def start_game(self):
    
26.         self.has_end = False
    
27.         self._deck = self._shuffle()
    
28.         self._player.clear()
    
29.         self._banker.clear()
    
30.         self._player.append(self._hit())
    
31.         self._banker.append(self._hit())
    
32.         self._player.append(self._hit())
    
33.         self._banker.append(self._hit())
    
34.         self.is_start = True
    
35.         self.is_your_turn = True
    
36.         result = self._player_turn()
    
37.         print(result)
    
38.         self.is_start = False
    
39.     def _dot(self):
    
40.         banker_dots = 0
    
41.         player_dots = 0
    
42.         banker_aces = 0
    
43.         player_aces = 0
    
44.         for _, rank in self._player:
    
45.             match rank:
    
46.                 case 'A':
    
47.                     player_aces += 1
    
48.                 case _:
    
49.                     player_dots += DOT[rank]
    
50.         if player_dots + 11 + player_aces - 1 <= 21 and player_aces != 0:
    
51.             player_dots += 11 + player_aces - 1
    
52.         else:
    
53.             player_dots += player_aces
    
54.         for _, rank in self._banker:
    
55.             match rank:
    
56.                 case 'A':
    
57.                     banker_aces += 1
    
58.                 case _:
    
59.                     banker_dots += DOT[rank]
    
60.         if banker_dots + 11 + banker_aces - 1 <= 21 and banker_aces != 0:
    
61.             banker_dots += 11 + banker_aces - 1
    
62.         else:
    
63.             banker_dots += banker_aces
    
64.         return player_dots, banker_dots
    
65.     def your_cards(self):
    
66.         return self._player[:]
    
67.     def _player_turn(self):
    
68.         player_dots, banker_dots = self._dot()
    
69.         if player_dots == 21 and banker_dots == 21:
    
70.             return 'even'
    
71.         elif player_dots == 21:
    
72.             return 'win'
    
73.         elif banker_dots == 21:
    
74.             return 'fail'
    
75.         while True:
    
76.             match input('During your turn, you can continue choose "hit" for one more card until you get 21, or fail to bust, or choose "stand" your turn.'):
    
77.                 case 'hit':
    
78.                     self._player.append(self._hit())
    
79.                     player_dots, _ = self._dot()
    
80.                     if player_dots > 21:
    
81.                         return 'fail'
    
82.                     elif player_dots == 21:
    
83.                         return 'win'
    
84.                 case 'stand':
    
85.                     result = self._banker_turn()
    
86.                     return result
    
87.                 case _:
    
88.                     continue
    
89.     def see_banker_cards(self):
    
90.         if self.has_end:
    
91.             return self._banker[:]
    
92.     def _banker_turn(self):
    
93.         while True:
    
94.             player_dots, banker_dots = self._dot()
    
95.             if banker_dots < 17:
    
96.                 self._banker.append(self._hit())
    
97.             elif 17 <= banker_dots <= 21:
    
98.                 if player_dots < banker_dots:
    
99.                     self.has_end = True
    
100.                     return 'fail'
     
101.                 elif player_dots == banker_dots:
     
102.                     self.has_end = True
     
103.                     return 'even'
     
104.                 else:
     
105.                     self.has_end = True
     
106.                     return 'win'
     
107.             elif banker_dots > 21:
     
108.                 self.has_end = True
     
109.                 return 'win'
     
110.         

复制代码

感觉这个游戏设计虽然简单，人多的时候玩起来真的还挺上头的

21点从规则设置上本质还是庄家有利的游戏

真尴尬。不会只有我心里幻想的是某一种用身体做赌注的游戏才进来的吧

感觉像是学python的大学生写的课程作业这是可以说的吗

21点基本是赌博类游戏的入门了,基本多多少少都接触过,简单的规则和玩法吸引不少人,看过一些赌博类动画,好像挺多作弊或者一些细节的特殊手段

对于我这种啥也不懂的人来说，看上去真的好厉害啊

天呢在这个版块还能看到这种东西，来支持一下

惹，刚从如山的python代码里出来（晕），可以用代码每步算一算概率，决定是继续抽还是停牌，当然赌狗赌到最后应有尽有（

很有趣的样子耶，要是身边有人能一起玩就好了

有玩的截图吗，还是全代码游戏？

所以说，这个就是单纯的用py做了一个21点游戏吗？还是说有隐藏的玄机？

之前也在部分游戏里见过内置21点的小游戏，有些为了避免玩家太大心理落差会做成有保底机制，或者rpg类型的做成和幸运挂钩，毕竟游戏里的不是要坑玩家钱而且让玩家玩的

感觉看上去超有意思呢，要是身边能有伙伴一起参与玩就太棒啦。

看了下代码确实非常经典的规则，甚至连庄家的17点默认规则也是一样

这个很经典的游戏了 难得在这里遇到这种

挺经典的游戏，第一次了解这个游戏是在星露谷上（雾）

当年大一作业就是用递归写21点的计算器，不过规则放宽了可以用四则运算

我确实知道21点这游戏，但不知道Python也能直接用代码做呢？感觉很多游戏里的小游戏都一样是这么制造的？

之前玩过一个脱衣扑克的3D小黄油
不过可以逃课就没看玩法惹