• 【Pygame实战】打扑克牌嘛？赢了输了？这款打牌游戏，竟让我废寝忘食。

    导语

    我小时候能玩的东西，远没有现在这么丰富，打扑克是其中之一。

    什么“三打哈”、“丰收”、“二百四”啊！不知道你们那各种方言玩法都叫啥，我这个是湖南老家的。

    我的话不经常打牌，大学的时候有手机之后就直接一个宿舍偶尔联网玩一下。

    工作这几年，和朋友一起打牌的次数用一只手也能数过来。

    BUT每年回湖南老家过年，少不了和亲戚一起打麻将打牌一起嗨皮一下，这是逃不掉的一个法

    则了~（当然打牌的话大家不要沉迷哈，你们都懂的.....）

    今天小编就给大家编写一个扑克牌的小游戏叭！希望大家喜欢哈，可以先来拿代码练练手~

    所有文章完整的素材+源码都在👇👇

    粉丝白嫖源码福利，请移步至CSDN社区或文末公众hao即可免费。

    正文

    一、项目介绍

    1）玩家模块规范标准

    用一个长度为2的字符串表示一张牌：(D,C,H,S) + (A,2,3,4,5,6,7,8,9,0,J,Q,K) 用"jk"、"JK"分别

    表示小王、大王 游戏顺序是逆时针方向 角色用一个字符串表示。

    ("banker","banker_opposite","banker_left","banker_right")分别表示庄家、庄家的对家、庄

    家的左边、庄家的右边 不考虑甩牌，使用python进行设计 。

     player模块设计：

    1.1 设计函数：

    1. de add_card_and_is_snatch(current_card): 表示玩家摸到一张牌curernt_card，并选择是否
    2.  
    3. 抢庄。 current_card表示一张牌(长度为2的字符串) 如果抢庄，返回相应的牌的字符串，否则
    4.  
    5. 返回'' 设计函数： def add_left_cards(left_cards): 只需要庄家才会用到，表示底牌是
    6.  
    7. left_cards，left_cards是一个长度为2的字符串的list 需要返回玩家准备埋到底牌的牌，返回值
    8.  
    9. 也是一个长度为2的字符串的list 。

    1.2  设计函数：

    1. def finish_one_round(current_turn_out_cards): 表示这一轮出牌结束，玩家被告知这一轮的
    2.  
    3. 出牌信息， current_turn_out_cards表示一个三元组(order,role,card)的list， 每一个三元组表
    4.  
    5. 示这一轮你出牌之前的某一个人出的牌的信息， order是一个整数，表示出牌顺序(1,2,3,4)
    6.  
    7. role是一个字符串，表示角色("banker","banker_opposite","banker_left","banker_right")
    8.  
    9. card是一张牌。

     1.3 设计函数：

    1. def set_main_value(main_value): 玩家被告知主面值是什么，main_value是一个字符
    2.  
    3. (A,2,3,4,5,6,7,8,9,0,J,Q,K)表示主面值 。

    1.4  设计函数： 

    1. def set_main_color(main_color): 玩家被告知主花色是什么，main_color是一个字符(D,C,H,S)
    2.  
    3. 表示主花色 。

    1.5 设计函数：

    1. def player_init(): 表示现在开始一局新的游戏，并初始化相关变量 设计函数： def
    2.  
    3. set_role(role): 玩家被告知自己的角色是什么，role是一个字符串
    4.  
    5. ("banker","banker_opposite","banker_left","banker_right") 。

    1.6  设计函数：

    1. def play_out_cards(turn, current_turn_out_cards): turn表示当前是第几轮出牌，
    2.  
    3. current_turn_out_cards表示一个三元组(order,role,card)的list， 每一个三元组表示这一轮你
    4.  
    5. 出牌之前的某一个人出的牌的信息， order是一个整数，表示出牌顺序(1,2,3,4) role是一个字
    6.  
    7. 符串，表示角色("banker","banker_opposite","banker_left","banker_right") card是一张牌
    8.  
    9. 函数需要返回决定出的一张牌 。

    1.7  设计函数： 

    def show_cards(): 需要返回当前玩家的手牌(长度为2的字符串的list) 。

    2）UI说明

    1.1 import UI 

    1.2  在游戏初始化模块添加代码：

    1. # Initialize pygame
    2. pygame.init()
    3. setting = UI.Setting()
    4. SCREEN_WIDTH, SCREEN_HEIGHT = setting.SCREEN_WIDTH, setting.SCREEN_HEIGHT
    5. x, y = 150, 60
    6. os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)
    7. screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    8. pygame.display.set_caption("升级")
    9. background = UI.Background(screen, setting)

    1.3  使用接口说明：

    1. a) initial(self)： 每轮游戏初始化函数，重置卡组等功能；
    2.  
    3. b) add_card(self, card, turn)： 发牌阶段，turn 为目的发牌玩家的位置 0-3，card 为所发牌
    4.  
    5. 值；
    6.  
    7. c) add_cards_over(self, inputs, outputs, main_color, master)： 发牌阶段结束后调用此
    8.  
    9. 函数；input 为发给庄家的 6 张底牌，output 为庄家压底的 6 张牌；mian_color 为此局的主
    10.  
    11. 色，master 是庄家玩家的位置 0-3；
    12.  
    13. d) push_cards(self, cards, turn)： 打牌阶段，函数意义是 turn 玩家打出 cards，cards 为
    14.  
    15. card 列表，即所有打出的牌 值；
    16.  
    17. e) turn_over(self)： 一轮牌结束阶段；清空四位玩家打出的所有牌；
    18.  
    19. f) update_point (self, point, level1, level2)： 一轮牌结束阶段，更新当前得分和级数；point
    20.  
    21. 为当前得分，level1 为东西位置玩 家当前的级数，level2 为南北玩家当前的级数 。

    1.4  传递变量说明： 

    1. a) card： (D,C,H,S) + (A,2,3,4,5,6,7,8,9,0,J,Q,K) 用"jk"、"JK"分别表示小王、大王 黑桃-
    2.  
    3. spade 红桃-heart 方快-diamond 草花-club 黑桃 3 : card = ‘s3’
    4.  
    5. b) turn： 整数 0-3 (0, 1, 2, 3) 等价于 ('East', 'North', 'West', 'South')

    二、运行环境

    1）小编使用的环境：Python3、Pycharm社区版、Pygame 模块部分自带就不一一

    展示啦。

     模块安装：pip install -i https://pypi.douban.com/simple/+模块名

    2）素材（图片等）

    背景、扑克牌等（图片过多仅展示部分素材）

    三、代码展示

    参考demo: judge 为裁判模块，myPlayer 为 AI 玩家，运行 judge.py。

    主程序judge.py：

    1. # coding:utf-8
    2.  
    3. import random
    4. import pygame
    5. import os
    6. import time
    7.  
    8. import myPlayer as p1
    9. import myPlayer as p2
    10. import myPlayer as p3
    11. import myPlayer as p4
    12.  
    13. import UI
    14.  
    15. # H S D C
    16. # Heart Spade Diamond Club
    17. # K - King  0 - small king , 1 - big king 
    18.  
    19. class Judge():
    20.     def __init__(self):
    21.         self.cards = None
    22.         self.players = []
    23.         self.players.append(p1.Player('East'))
    24.         self.players.append(p2.Player('North'))
    25.         self.players.append(p3.Player('West'))
    26.         self.players.append(p4.Player('South'))
    27.         
    28.         self.level = [2,2]
    29.  
    30.         self.master = None
    31.  
    32.         self.false = [0 , 0, 0, 0]     #记录每个人犯错次数
    33.  
    34.         self.main_color = None
    35.         self.main_num = 2
    36.  
    37.         self.loser = 0      # 记录先犯错的一方，最后判输
    38.  
    39.     def covert(self, s):
    40.         if s == 1 or s == 14:
    41.             return 'A'
    42.         elif s < 10:
    43.             return str(s)
    44.         elif s == 10:
    45.             return '0'
    46.         elif s == 11:
    47.             return 'J'
    48.         elif s == 12:
    49.             return 'Q'
    50.         elif s == 13:
    51.             return 'K'
    52.         
    53.     # 新游戏，初始化
    54.     def new_game(self, background):
    55.         self.main_color = None
    56.         self.false = [0 , 0, 0, 0]
    57.         self.loser = -1
    58.         self.bottom = []
    59.         self.point = 0
    60.         self.biggest = [0, 0, 0, 0]
    61.         self.player_cards = [[],[],[],[]]
    62.  
    63.         
    64.  
    65.         cards = self.create_card()
    66.         random.shuffle(cards)
    67.         for i in range(4):
    68.             self.players[i].player_init()
    69.         l = ['a', 'b', 'c', 'd']
    70.         for i in range(4):
    71.             self.players[i].set_role(l[i])
    72.         for y in self.players:
    73.             #y.initial_new_game()
    74.             y.set_main_value(self.covert(self.main_num))
    75.         # 发牌
    76.         turn = 0
    77.         for i in range(48):
    78.             x = self.players[turn].add_card_and_is_snatch(cards[i])
    79.             self.player_cards[turn].append(cards[i])
    80.             if x != '' and x[1] == self.covert(self.main_num) and self.main_color == None:
    81.                 self.main_color = x[0]
    82.                 if self.master == None:
    83.  
    84.                     self.master = turn
    85.                 for y in self.players:
    86.                     y.set_main_color(self.main_color)
    87.             elif x == '':
    88.                 None
    89.             else:
    90.                 self.false[turn] += 1
    91.                 if self.loser == -1:
    92.                     self.loser = turn
    93.  
    94.             background.add_card(cards[i], turn)
    95.  
    96.             turn += 1
    97.             turn %= 4
    98.         if self.main_color == None:
    99.             col = ['H', 'C', 'D', 'S']
    100.             self.main_color = random.choice(col)
    101.             for y in self.players:
    102.                 y.set_main_color(self.main_color)
    103.         if self.master == None:
    104.             self.master = random.randint(0, 3)
    105.         self.bottom = self.players[self.master].add_left_cards(cards[48:])
    106.         for x in cards[48:]:
    107.             self.player_cards[self.master].append(x)
    108.         
    109.         
    110.         if len(self.bottom) != 6:
    111.             self.false[self.master] += 1
    112.             if self.loser == -1:
    113.                 self.loser = self.master
    114.         else:
    115.             for x in self.bottom:
    116.                 if x in self.player_cards[self.master]:
    117.                     self.player_cards[self.master].remove(x)
    118.                 else:
    119.                     if self.loser == -1:
    120.                         self.loser = self.master
    121.         
    122.         background.add_cards_over(cards[48:], self.bottom, self.main_color, self.master)
    123.  
    124.     '''生成一副牌'''
    125.     def create_card(self):
    126.         colors = ['H', 'S', 'D', 'C']
    127.         nums = 'A234567890JQK'
    128.         cards = []
    129.         for color in colors:
    130.             for i in range(13):
    131.                 c = color + nums[i]
    132.                 cards.append(c)
    133.         cards.append('jk')
    134.         cards.append('JK')
    135.  
    136.         return cards
    137.  
    138.     # 判断玩家手里是否有该花色的牌，y表示该轮是否要出主牌
    139.     def find_color(self,p_cards, this_color, y):
    140.         for x in p_cards:
    141.             if y == True:
    142.                 if x == this_color or x == 'jk' or x=='JK' or x ==self.covert(self.main_num):
    143.                     return True
    144.             else:
    145.                 if x == this_color:
    146.                     return True
    147.         return False
    148.  
    149.     # a先出， 判断b的数字是否大于a
    150.     def is_big(self,b, a):
    151.         num_order = ['A', 'K', 'Q', 'J', '0', '9','8','7','6','5','4','3','2']
    152.         for x in num_order:
    153.             if x == a:
    154.                 return False
    155.             if x == b:
    156.                 return True
    157.  
    158.     # 判断a 是否大于b，a先出
    159.     def is_bigger(self,a , b, this_color):
    160.         if a == 'JK':
    161.             return True
    162.         if a == 'jk':
    163.             if b == 'JK':
    164.                 return False
    165.             else :
    166.                 return True
    167.         if a[1] == self.main_num:
    168.             if b == 'jk' or b=='JK' or b[0]==self.main_color and b[1]==self.covert(self.main_num):
    169.                 return False
    170.             else:
    171.                 return True
    172.         if a[0] == self.main_color:
    173.             if b =='jk' or b=='JK' or b[1]==self.covert(self.main_num) or b[0]==self.main_color and self.is_big(b[1],a[1]):
    174.                 return False
    175.             else:
    176.                 return True
    177.         if a[0] == this_color:
    178.             if b =='jk' or b=='JK' or b[1]==self.covert(self.main_num) or b[0]==self.main_color or b[0]==this_color and self.is_big(b[1],a[1]):
    179.                 return False
    180.             else:
    181.                 return True
    182.         
    183.         if b =='jk' or b=='JK' or b[1]==self.covert(self.main_num) or b[0]==self.main_color or b[0]==this_color or self.is_big(b[1],a[1]):
    184.             return False
    185.         else:
    186.             return True
    187.         
    188.  
    189.     def add_points(self, cards):
    190.         for x in cards:
    191.             if x[1] == '5':
    192.                 self.point += 5
    193.             elif x[1] == '0' or x[1] == 'K':
    194.                 self.point += 10
    195.             
    196.     # 判断一轮中最大的牌是谁出的，是否加分
    197.     def get_max_index_and_add_points(self, cards, turn, this_color):
    198.         index = 0
    199.         max_card = cards[0]
    200.         for i in range(1,4):
    201.             if not self.is_bigger(max_card, cards[i], this_color):
    202.                 index = i
    203.                 max_card = cards[i]
    204.         
    205.         if index % 2 != self.master % 2:
    206.             self.add_points(cards)
    207.  
    208.         return (turn + index) % 4
    209.  
    210.     def is_a_card(self, s):
    211.         if s == 'jk' or s == 'JK':
    212.             return True
    213.         if s[0] in ['H', 'S', 'D', 'C'] and s[1] in ['A', 'K', 'Q', 'J', '0', '9','8','7','6','5','4','3','2']:
    214.             return True
    215.         else:
    216.             return False
    217.  
    218.  
    219.     # 出牌到结束
    220.     def run_game(self, background):
    221.         turn = self.master
    222.         for i in range(12):
    223.             UI.check_events()
    224.             this_turn_cards = []
    225.             first_card = self.players[turn].play_out_cards(0 , this_turn_cards)
    226.             this_turn_cards.append(first_card)
    227.  
    228.             if first_card in self.player_cards[turn]:
    229.                 self.player_cards[turn].remove(first_card)
    230.             else:
    231.                 if self.loser == -1:
    232.                     self.loser = turn
    233.             
    234.             background.push_cards([first_card], turn)
    235.  
    236.             turn += 1
    237.             turn %= 4
    238.  
    239.             if not self.is_a_card(first_card):
    240.                 print('Please input a card')
    241.                 self.false[turn] += 1
    242.             if first_card == 'jk' or first_card == 'JK' or first_card[0]==self.main_color or first_card[1]==self.covert(self.main_num):
    243.                 this_color = self.main_color
    244.             else:
    245.                 this_color = first_card[0]
    246.  
    247.             for j in range(1, 4):
    248.                 a_cards = self.players[turn].play_out_cards(j, this_turn_cards)
    249.                 if a_cards in self.player_cards[turn]:
    250.                     self.player_cards[turn].remove(a_cards)
    251.                 else:
    252.                     if self.loser == -1:
    253.                         self.loser = turn
    254.                 this_turn_cards.append(a_cards)
    255.                 #p_cards = self.players[turn].show_cards()
    256.                 p_cards = self.player_cards[turn]
    257.                 #print('a_cards = ', a_cards)   ###############
    258.                 if a_cards[0] == this_color:
    259.                     None
    260.                 elif this_color == self.main_color:
    261.                     if a_cards == 'jk' or a_cards == 'JK' or a_cards[1]==self.covert(self.main_num):
    262.                         None
    263.                     elif not self.find_color(p_cards, this_color, True):
    264.                         None
    265.                     else:
    266.                         self.false[turn] += 1
    267.                         if self.loser == -1:
    268.                             self.loser = turn
    269.                 else:
    270.                     if self.find_color(p_cards, this_color, False):
    271.                         self.false[turn] += 1
    272.                         if self.loser == -1:
    273.                             self.loser = turn
    274.  
    275.                 background.push_cards([a_cards], turn)
    276.  
    277.                 turn += 1
    278.                 turn %= 4
    279.  
    280.             # 告诉所有玩家本轮出的牌
    281.             for i in range(4):
    282.                 self.players[i].finish_one_round(this_turn_cards, (i + turn ) % 4 )
    283.  
    284.             max_index = self.get_max_index_and_add_points(this_turn_cards, turn, this_color)
    285.             turn = max_index
    286.             self.biggest[max_index] += 1
    287.  
    288.             background.update_point(self.point, self.level[0], self.level[1])
    289.             background.turn_over()
    290.  
    291.         # 底牌是否得分
    292.         if turn % 2 != self.master % 2:
    293.             self.add_points(self.bottom)
    294.         
    295.         
    296.         if self.loser % 2 == self.master:
    297.             self.main_num = self.level[(self.master + 1) % 2]
    298.             self.master = (self.master + 1) % 2
    299.         elif self.loser % 2 != self.master and self.loser != -1:
    300.             self.level[self.master % 2] += 1
    301.             self.main_num = self.level[self.master % 2]
    302.             if self.master == self.master % 2:
    303.                 self.master += 2
    304.             else:
    305.                 self.master %= 2
    306.         elif self.point < 40:
    307.             self.level[self.master % 2] += 1
    308.             self.main_num = self.level[self.master % 2]
    309.             if self.master == self.master % 2:
    310.                 self.master += 2
    311.             else:
    312.                 self.master %= 2
    313.         else:
    314.             self.main_num = self.level[(self.master + 1) % 2]
    315.             self.master = (self.master + 1) % 2
    316.         # print(self.biggest)
    317.  
    318.         
    319. if __name__ == '__main__':
    320. 	# Initialize pygame
    321. 	pygame.init()
    322. 	setting = UI.Setting()
    323.  
    324. 	SCREEN_WIDTH, SCREEN_HEIGHT = setting.SCREEN_WIDTH, setting.SCREEN_HEIGHT
    325. 	x, y = 150, 60
    326. 	os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)
    327. 	screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    328. 	pygame.display.set_caption("升级")
    329.  
    330. 	background = UI.Background(screen, setting)
    331. 	judge = Judge()
    332. 	#judge.level = [12,13]
    333. 	while True:
    334. 		
    335. 		time.sleep(0.5)
    336. 		judge.new_game(background)
    337. 		judge.run_game(background)
    338. 		background.initial()
    339.  
    340. 		if judge.level[0] == 13 or judge.level[1] == 13:
    341. 			print(judge.level)
    342. 			if judge.level[0] > judge.level[1]:
    343. 				print('East and West WIN')
    344. 			else:
    345. 				print('South and North WIN')
    346. 			break

    四、效果展示

    ​​运行截图——

    总结

    好啦好啦！这款简单的小游戏写到这里就结束了，看到这里是谁的DNA动了呢？嘻嘻嘻

    小编友情提醒：小赌怡情，大赌伤身伤感情。打牌要尽兴，但切记得失心太重哦！

    老规矩的撒素材完整的资料源码等关注我的都知道的啦自己去拿哈👇

    🎯完整的免费源码领取处：找我吖！文末公众hao可自行领取，滴滴我也可！

    🔨推荐往期文章——

    项目1.0  超级玛丽

    程序员自制游戏：超级玛丽100%真实版，能把你玩哭了~【附源码】

    项目1.1   扫雷

     Pygame实战：据说这是史上最难扫雷游戏，没有之一，你们感受下......

    ​项目1.4  水果忍者

    【Pygame实战】风靡全球的切水果游戏升级版“水果忍者”上线啦，你敢来PK嘛？

    项目2.0  联网、人机一体五子棋游戏

    Pygame实战：下五子棋吗？信不信我让你几步你也赢不了？

    项目2.1   宇宙激战射击游戏

    【Pygame实战】飞机射击大作：宇宙激战一触即发...这款超经典的射击游戏也该拿出来重启了~

    🎄文章汇总——

    项目1.0 Python—2021 |已有文章汇总 | 持续更新，直接看这篇就够了

    （更多内容+源码都在文章汇总哦！！欢迎阅读~）

  • 相关阅读:
    JVM栈帧的内部结构
    PostgreSQL文本搜索（一）——简介
    Apache Paimon 使用之 Querying Tables
    大数据----Hadoop与数据仓库
    k8s-statefulset创建mongo集群
    关键节点与邻居搜索：K-Core算法对比K-Hop算法的效能较量
    银行ATM系统
    Stream竟然还有应用进阶学习？作为程序员的你知道吗
    2020年中职组“网络安全”赛项广东省竞赛任务书
    UDS入门至精通系列：Service 27
  • 原文地址：https://blog.csdn.net/weixin_55822277/article/details/125917658