python棋牌游戏开发之斗地主
斗地主这个游戏的流程主要有，洗牌，发牌，出牌，而最重要的便是出牌了，出牌里包含着游戏的牌型，所以这里就先给大家讲讲我进行牌型判断的思路。
"""
牌型定义：1.单张
2.对子
3.三不带
4.炸
5.三带一
6.连对
7.顺子
8.飞机不带
9.飞机带单
10.飞机带对子/三带二
11.四带2
12.四带一对
牌型判断前提：1.输入的列表为已经从上到下排列的列表
2.只针对一副牌的情况
3.一组列表可能代表着多种牌型，这里没有进行并行判断。
4.这里的列表用“0-13”分别对应扑克牌的“3-鬼”，这里暂时不判大小不区分大小鬼
"""
class doudizhu:
#单张
def dan(self):
return 1
#对子
def dui(self, l):
if l[0] == l[1]:
return 2
else:
return 99
#三不带
def san(self, l):
if l[0] == l[2]:
return 3
else:
return 99
#炸弹
def zha(self, l):
if l[0] == l[3]:
return 4
else:
return 0
#三带一
def sanyi(self, l):
if l[0] == l[2] or l[1] == l[3]:
return 5
else:
return 0
#三带二(未用，与飞机2合并)
def saner(self, l):
if (l[0] == l[2] and l[3] == l[4]) or (l[2] == l[4] and l[0] == l[1]):
return 6
else:
return 0
#顺子（思路：后一个数要比当前数1，有一个发生错误直接返回0）
def shunzi(self,l):
paixing = 0
for i in range(len(l)-1):
if l[i+1]-l[i] == 1:
paixing = 7
else:
return 0
return paixing
#连对（思路：先将长度对半折，同样要判断后2个数比当前数大1，且后一个数与当前数相等）
def liandui(self,l):
paixing = 0
for i in range(int(len(l)/2)-1):
if l[(i+1)*2]-l[i*2] == 1 and l[i*2] == l[i*2+1]:
paixing = 6
else:
return 0
return paixing
#飞机0（思路：每隔3个数后一个数都要比当前数大1，3个数内，后一个数要相等于当前数，未符合条件直接返回0）
def feiji0(self,l):
paixing = 0
for i in range(len(l)-1):
if (i+1)%3 == 0 and l[i+1] - l[i] == 1:
paixing = 8
elif l[i] == l[i+1]:
paixing = 8
else:
return 0
return paixing
#飞机1（思路：计算3个数相同的组合有几组，再与其他未达到3个相同的总牌数比较，相等则正确）
def feiji1(self, l):
a = 1
m = []
for i in range(len(l)-1):
if l[i] == l[i+1]:
a += 1
else:
a = 1
if a == 3:
m.append(l[i])
a = 1
if len(l) - len(m) == len(m)*3:
return 9
else:
return 0
#飞机2（思路：与飞机1类似，不同的是，此处的对子也需要统计,还需要考虑特殊情况（用炸做对子））
def feiji2(self, l):
a = 1
b = 0
m = []
for i in range(len(l)-1):
if l[i] == l[i+1]:
a += 1
if a == 3:
if l[i] != l[i+2]:
m.append(l[i])
a = 1
elif a == 2:
if l[i] != l[i+2]:
b += 1
a = 1
elif a == 4:
b += 2
else:
a = 1
if b == len(m):
return 10
else:
return 0
#四带2（思路，四带2就3种情况，我就不多说了）
def sidaier1(self,l):
if l[0] == l[3] or l[1] == l[4] or l[2] == l[5]:
return 11
else:
return 0
#四代两对（思路：与四带二一样也就3种情况，就是条件还要多加对子判断）
def sidaier2(self, l):
if l[0] == l[3] and l[4] == l[5] and l[6] == l[7]:
return 12
if l[2] == l[5] and l[0] == l[1] and l[6] == l[7]:
return 12
if l[7] == l[4] and l[0] == l[1] and l[2] == l[3]:
return 12
return 0
#这个函数主要就是，对牌型判断前的筛选工作，比如，一张牌就只能是单张，2张牌要先判断是不是王炸等等
def paixing(self, l):
m = len(l)
paixing = 0
if m == 1:
paixing = self.dan()
elif m == 2:
#判断王炸
if l[0] == 13:
paixing = 4
else:
paixing = self.dui(l)
elif m == 3:
paixing = self.san(l)
elif m == 4:
#优先判断炸
paixing = self.zha(l)
#再三带一
if paixing == 0:
paixing = self.sanyi(l)
elif m >= 5:
# 这里的判断基本是并行的，前提是前面的判断没获取到类型
#大于5张都判断一次顺子
paixing = self.shunzi(l)
if paixing == 0:
#然后就是连对判断
if m%2 == 0:
paixing = self.liandui(l)
if paixing == 0:
#飞机不带
if m%3 == 0:
paixing = self.feiji0(l)
if paixing == 0:
#飞机带一
if m%4 == 0:
paixing = self.feiji1(l)
if paixing == 0:
#飞机带对子
if m % 5 == 0:
paixing = self.feiji2(l)
if paixing == 0:
#四带二
if m == 6:
paixing = self.sidaier1(l)
if paixing == 0:
#四带一对
if m == 8:
paixing = self.sidaier2(l)
if paixing == 0:
paixing = 99
return paixing
def chupai(self):
l = [3,3,3,4,4,4,5,5,5,5]
paixing = self.paixing(l)
if paixing == 1:
print("单张")
elif paixing == 2:
print("对子")
elif paixing == 3:
print("三不带")
elif paixing == 4:
print("炸")
elif paixing == 5:
print("三带一")
elif paixing == 6:
print("连对")
elif paixing == 7:
print("顺子")
elif paixing == 8:
print("飞机不带")
elif paixing == 9:
print("飞机带一")
elif paixing == 10:
if len(l) == 5:
print("三带二")
else:
print("飞机带对子")
elif paixing == 11:
print("四带二")
elif paixing == 12:
print("四带两对")
elif paixing == 99:
print("牌型错误")
else:
pass
if __name__ == "__main__":
dou = doudizhu()
dou.chupai()
思路基本都写在代码的注释里了，我想到的牌型基本都验证完毕了，如果有其他牌型却未出现在代码里的，或者你们有更优的想法或思路，或者是我的代码里会有某些错误，都可以通过博客下面的留言跟我一起探讨哦
7.15更新
上次只是基本判断牌型，这次更新弄了个文字版的斗地主，通信协议用的是socket/tcp, 传送数据格式为JSON，这里将牌型判断统一放到服务器上弄，但是如果是为了高效通信，建议将牌型判断转移到客户端上，我这里就不再转移了。话不多说，上代码。
一、斗地主常用流程模块
1.牌型判断
class doudizhu:
#单张
def dan(self):
return 1
#对子
def dui(self, l, paixing):
if l[0] == l[1]:
paixing = 2
return paixing, l[0]
#三不带
def san(self, l,paixing):
if l[0] == l[2]:
paixing = 3
return paixing, l[0]
#炸弹
def zha(self, l,paixing):
if l[0] == l[3]:
paixing = 4
return paixing, l[0]
#三带一
def sanyi(self, l, paixing):
if l[0] == l[2] or l[1] == l[3]:
paixing = 5
return paixing, l[2]
#三带二(未用，与飞机2合并)
def saner(self, l, paixing):
if (l[0] == l[2] and l[3] == l[4]) or (l[2] == l[4] and l[0] == l[1]):
paixing = 6
return paixing, l[2]
#顺子（思路：后一个数要比当前数大1，有一个发生错误直接返回0）
def shunzi(self, l, paixing):
now = 0
print(l)
if l[-1] < 12:
for i in range(len(l)-1):
if l[i+1]-l[i] == 1:
now = 7
else:
return paixing, l[-1]
paixing = now
return paixing, l[-1]
#连对（思路：先将长度对半折，同样要判断后2个数比当前数大1，且后一个数与当前数相等）
def liandui(self, l, paixing):
now = 0
print(l[-1])
if l[-1] < 12:
for i in range(int(len(l)/2)-1):
if l[(i+1)*2]-l[i*2] == 1 and l[i*2] == l[i*2+1]:
now = 6
else:
return paixing, l[-1]
paixing = now
return paixing, l[-1]
#飞机0（思路：每隔3个数后一个数都要比当前数大1，3个数内，后一个数要相等于当前数，未符合条件直接返回0）
def feiji0(self, l, paixing):
now = 0
for i in range(len(l)-1):
if (i+1)%3 == 0 and l[i+1] - l[i] == 1:
now = 8
elif l[i] == l[i+1]:
now = 8
else:
return paixing, l[-1]
paixing = now
return paixing, l[-1]
#飞机1（思路：计算3个数相同的组合有几组，再与其他未达到3个相同的总牌数比较，相等则正确）
def feiji1(self, l, paixing):
a = 1
m = []
for i in range(len(l)-1):
if l[i] == l[i+1]:
a += 1
else:
a = 1
if a == 3:
m.append(l[i])
a = 1
if len(m)*3 == len(l):#特殊情况（4个3张）
if m[-1] - m[1] == len(m) - 2:
paixing = 9
a = m[-1]
elif m[-2] - m[0] == len(m) - 2:
paixing = 9
a = m[-2]
if len(m) != 0:#排除无3个杂牌，避免后免的m[0],m[-1]出错
if len(l) - len(m) == len(m)*3 and m[-1] - m[0] == len(m) - 1:
paixing = 9
a = m[-1]
return paixing, a
#飞机2（思路：与飞机1类似，不同的是，此处的对子也需要统计,还需要考虑特殊情况（用炸做对子））
def feiji2(self, l, paixing):
a = 1
b = 0
m = []
for i in range(len(l)-1):
if l[i] == l[i+1]:
a += 1
if a == 3:
if i+2 > len(l) or l[i] != l[i+2]:
m.append(l[i])
a = 1
elif a == 2:
if l[i] != l[i+2]:
b += 1
a = 1
elif a == 4:
b += 2
else:
a = 1
if len(m) != 0:#情况同上
if b == len(m) and m[-1] - m[0] == len(m) - 1:
paixing = 10
b = m[-1]
else:
b = l[-1]
return paixing, b
#四带2（思路，四带2就3种情况，我就不多说了）
def sidaier1(self, l, paixing):
if l[0] == l[3] or l[1] == l[4] or l[2] == l[5]:
paixing = 11
return paixing, l[2]
#四代两对（思路：与四带二一样也就3种情况，就是条件还要多加对子判断）
def sidaier2(self, l, paixing):
m = 0
if l[0] == l[3] and l[4] == l[5] and l[6] == l[7]:
paixing = 11
m = l[0]
if l[4] == l[7]:
m = l[4]
elif l[2] == l[5] and l[0] == l[1] and l[6] == l[7]:
paixing = 11
m = l[2]
elif l[7] == l[4] and l[0] == l[1] and l[2] == l[3]:
paixing = 11
m = l[4]
return paixing, m
def first(self, l):
m = len(l)
print("len m =",m)
paixing = 0#牌型的中间变量
n = []#用列表存牌型，用来应对多种牌型情况
bf_max = []#用列表存比对值，用来应对多种牌型情况
y = 0#判断同牌型的中间变量
if m == 2:
#判断王炸
if l[0] == 13:
print("wangzha")
paixing = 4
n.append(paixing)
bf_max.append(13)
else:
paixing, y = self.dui(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
elif m == 3:
paixing, y = self.san(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
elif m == 4:
#优先判断炸
print("zha")
paixing, y = self.zha(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
#再三带一
paixing, y = self.sanyi(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
paixing = 0
elif m >= 5:
#大于5张都判断一次顺子
paixing, y = self.shunzi(l, paixing)
paixing, y = self.saner(l, paixing)
#然后就是连对判断
if m%2 == 0:
paixing, y = self.liandui(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
#飞机不带
if m%3 == 0:
paixing, y = self.feiji0(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
#飞机带一
if m%4 == 0:
paixing, y = self.feiji1(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
#飞机带对子
if m % 5 == 0:
paixing, y = self.feiji2(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
#四带二
if m == 6:
paixing, y = self.sidaier1(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
#四带两对
if m == 8:
paixing, y = self.sidaier2(l, paixing)
if paixing:
n.append(paixing)
paixing = 0
bf_max.append(y)
y = 0
return n, bf_max
这个部分跟上次的对比更新了一些判断方式，不仅使得判断更加准确，而且适配了下面的出牌大小比较，而first()函数更是几乎包括了所有的牌的判断，除了单张类型。
2、出牌比较
def comp(self, bf_type, bf_max, bf_lenth, l, socket):
m = len(l)#当前出牌的长度
x = 0#临时接收客户端信息
n = []#存放经过转化排列的出牌
#转化出牌，使得与之前的设计相符
for i in l:
n.append(int(i/4))
n.sort()#排列，这里有个易错点，sort()函数没有返回值，不需要也不能用其他列表去复制它，直接调用便能将n排列好
now_type = []#当前出牌牌型
now_max = []#当前出牌值
if m == 1:
if l[0] < 52:#小鬼大鬼单独算
now_type.append(1)
now_max.append(n[0])
else:
now_type.append(1)
now_max.append(l[0])
else:
now_type, now_max = self.first(n)
if len(now_type) != 0:#如果长度为0，则代表没有牌型，也就是出牌错误
if bf_type == 0:#未出牌，不需要与上次牌型比较
if len(now_type) > 1:#多种牌型判断
data = {
'type': "select",
'paixing': now_type
}
socket.send(json.dumps(data).encode())#像客户端发起牌型判断请求
x = socket.recv(1024)
if now_type[x] != 0:#0为无牌型，排除错误情况
return True, now_type[x], now_max[x], m
else:
j = 0#计算合理有效牌型数量
r = 0#存放第一个合理牌型
for i in range(len(now_type)):
if now_type[i] == 4 and bf_type != 4:#目前出牌牌型为炸弹，前一刻不为炸弹
j += 1
elif now_type[i] == 4 and bf_type == 4 and now_max[i] > bf_max:
j += 1
elif now_type[i] == bf_type and now_max[i] > bf_max and m == bf_lenth:
j += 1
if j == 1:
r = i
if j > 1:#多种牌型，请求用户抉择
data = {
'type': "select",
'paixing': now_type
}
socket.send(json.dumps(data).encode())
x = socket.recv(1024).decode()
if now_type[x] != 0:
return True, now_type[x], now_max[x], m
elif j == 1:#一种牌型，直接返回
return True, now_type[r], now_max[r], m
return False, bf_type, bf_max, bf_lenth
这里就是斗地主游戏过程中经常要做的事，将上次出牌与下次出牌进行比较。
3、模拟洗牌、发牌
def beginer(self):#洗牌函数
a = [x for x in range(54)]#初始化列表0-53
random.shuffle(a)#随机打乱列表
a1 = a[1::3]#切片取数
a2 = a[2::3]
a3 = a[3::3]
a4 = a[-3:]#底牌
del a1[-1]#删除多余数
del a2[-1]#删除多余数
return a1, a2, a3, a4
这部分就比较简单，用0-53代表扑克牌，用随机打乱列表的函数来模拟洗牌。
4、叫地主
def jdz(self, client, i):#叫地主函数
a = 0#叫地主次数统计
b = 0#不叫次数统计
now = ""#记录当前拥有地主权的玩家
restart = False#重开标志
z = random.randint(0, 2)#随机取数，优先叫地主
n = z#复制此变量
client_ls = client[i]#临时存放当前房间用户的名字
while True:
jdz = "叫地主"
if a != 0:#模拟抢地主流程，有人叫地主之后便是抢地主
jdz = "抢地主"
if a == len(client_ls) and a > 1:#模拟先叫地主的人，有一次我抢的机会
jdz = "我抢"
#json格式传送信息
data = json.dumps({
"type": "jdz",
"message": jdz
})
client[client_ls[n]].send(data.encode())
recv = client[client_ls].recv(1024).decode()#接收抢地主信息
if recv == 0:
print("wait for user %s" % client_ls[n])
else:
recv = json.loads(recv)
if recv["message"] == "yes":#用户选择抢地主
a += 1
now = client[i][n]
else:
b += 1
data = json.dumps({
"type": "warning",
"message": client[i][n]+":"+jdz
})
#给其他用户发送抢地主信息
client[client[i][(n + 1) % 3]].send(data.encode())
client[client[i][(n + 2) % 3]].send(data.encode())
#抢地主全部情况
if a == 0 and b == 3:
restart = True
now = client[i][z]
break
elif a == 1 and b == 2:
break
elif a + b == 4:
break
if a == 0:#假如不抢
del client_ls[n]#去除此人的抢地主机会
if n > len(client_ls):#顺位改变
n = n % len(client_ls)
else:
n = (n+1) % len(client_ls)
return now, restart
这部分函数就是模拟平常欢乐斗地主的叫地主、抢地主流程。
二、服务器模块
1、监听用户连接模块
def connect(s):
while True:
print('server socket waiting...')
obj, addr = s.accept() # 阻塞等待链接
client[obj] = 1#开启用户通信
t1 = threading.Thread(target=user, args=(obj,))#独立线程处理用户通信
t1.start()
简单的阻塞监听，多线程处理，这里可以用线程池代替普通线程去管理资源，我就不多介绍了。
2、用户的普通通信
def user(socket):
while True:
if client[socket]:
data = socket.recv(1024).decode()
if data == 0:#异常断开
break
else:
data = json.loads(data)#json解码
if data["type"] == "login":#登录信息处理
if data["name"] in client:
message = json.dumps({
"type": "warning",
"message": "昵称已存在，请重新输入"
})
socket.send(message.encode())#重复昵称判断
else:
client[data["name"]] = socket#字典存通信地址与用户名
print("玩家加入:%s" % data["name"])#显示玩家加入
elif data["type"] == "ready":#玩家准备才会进入游戏
for i in range(33):#遍历房间
if i == 32 and len(client[i]) == 3:#预设定房间是否满人判断
message = json.dumps({
"type": "warnning",
"message": "房间已满"
})
socket.send(message.encode())
if len(client[i]) < 3:#自动寻找未满房间进入
client[i].append(data["name"])#i房间添加用户
message = json.dumps({
"type": "warning",
"message": "已加入房间%s" % i
})
socket.send(message.encode())
break
client[socket] = 0#关闭正常通信
#退出房间（未使用）
elif data["type"] == "cancel":
i = 0
j = 0
for i in range(33):
for j in range(len(client[i])):
if client[i][j] == data["name"]:
break
message = json.dumps({
"type": "warning",
"message": "已退出房间%s" % i
})
socket.send(message.encode())
client[i][j].delect()
station[i] = 0
#断开链接（未使用）
elif data["type"] == "exit":
break
#继续游戏（未使用）
elif data["type"] == "continue":
client[socket] = 2
socket.close()
#向其他玩家发送出牌的消息
这里就是用来与用户游戏前的通信逻辑。
3、可复用函数
#向其他玩家发送出牌的消息
def message(l, client, now ,i):
for j in range(3):
data = json.dumps({
"type": "chupai1",
"name": now,
"card": l
})
if client[i][j] != now:
client[client[i][j]].send(data.encode())
#更新用户的牌与牌数
def fapai(usercard, client, i):
for j in range(3):
data = json.dumps({
"type": "fapai",
"player1": client[i][(j + 1) % 3] + ":" + str(len(usercard[client[i][(j + 1) % 3]])),
"player2": client[i][(j + 2) % 3] + ":" + str(len(usercard[client[i][(j + 2) % 3]])),
client[i][j]: usercard[client[i][j]]
})
client[client[i][j]].send(data.encode())
#删除已出的牌，以及是否结束游戏判断
def up_card(usercard, now,l):
i = 0
j = 0
for i in l:#遍历出牌的列表
for j in range(len(usercard[now])):
if usercard[now][j] == i:#找到相同的牌
break
del usercard[now][j]#删除此牌
j = 0
fapai(usercard, client, i)#更新用户的牌
for i in usercard:#遍历用户的牌
if len(usercard[i]) == 0:#是否有人已经出完牌了
return True, i
return False, i
#游戏模式
这里主要是将一些重要的逻辑单独隔离出来写。
4、游戏中的通信
#游戏模式
def player(i, client):
restart = True#不抢地主重开
result = True#结果，用来终止循环
count = 0#重开计数，模拟3次重开后不能再重开
buchu = 0#不出计数，模拟其他两个不出后，可以随意出牌型
now = ""#存放当前通信玩家
begin = 0#抢地主流程结束标志
usercard = {}#存放用户的牌
dizhu_name = ""#本次游戏的地主
nongming1 = ""#本次游戏的农民1
nongming2 = ""#本次游戏的农民2
doudizhu = chupai.doudizhu()#创建对象
bf_type = 0#上次出牌类型
bf_max = 0#上次出牌值
bf_lenth = 0#上次出牌长度
a = [[], [], [], []]#初始化a
a[0], a[1], a[2], a[3] = doudizhu.beginer()#用a列表来存放底牌以及各用户的初始牌
for j in range(3):
usercard[client[i][j]] = a[j]#将牌存入usercard中
fapai(usercard, client, i)#给用户发牌
while result:
if restart and count < 3:
if count > 0:#重开
for j in [0, 1, 2, 3]:
a[j].clear()
a[0], a[1], a[2], a[3] = doudizhu.beginer()
for j in range(3):
usercard[client[i][j]] = a[j]
fapai(usercard, client, i)
now, restart = doudizhu.jdz(client, i)#进入叫地主流程
count += 1#计数
else:
if not begin:
usercard[now] += a[3]#给地主加底牌
dizhu_name = now#存地主名字
fapai(usercard, client, i)
for j in [0,1,2]:
if client[i][j] == now:#存农民名字
nongming1 = client[i][int((j+1)/3)]
nongming2 = client[i][int((j + 2) / 3)]
break
begin = 1#进入出牌流程
if begin:
data = json.dumps({
"type": "chupai"
})
client[now].send(data.encode())
recv = json.loads(client[now].recv(1024).decode())
if recv["type"] == "chupai":#出牌标志
l = recv["card"]#存放出牌的列表
res, bf_type, bf_max, bf_lenth = doudizhu.comp(bf_type, bf_max, bf_lenth, l, client[now])#判断出牌是否错误
if res:#正确牌型
buchu = 0
data = json.dumps({
"type": "chupai2"
})#通知出牌用户的打印出牌消息
client[now].send(data.encode())
message(l, client, now, i)#通知其他用户的打印出牌消息
res1, winner = up_card(usercard, now, l)#去牌和胜负判断
for j in [0, 1, 2]:
if res1:#胜负标志
data3 = []
if winner == dizhu_name:#赢家是地主
data3.append(json.dumps({
"type": "win"
}))
data3.append((json.dumps({
"type": "false"
})))
else:#赢家是农民
data3.append(json.dumps({
"type": "false"
}))
data3.append((json.dumps({
"type": "win"
})))
client[dizhu_name].send(data3[0].encode())
client[nongming1].send(data3[1].encode())
client[nongming2].send(data3[1].encode())
result = not res1
break
else:
if client[i][j] == now:
now = client[i][(j + 1) % 3]
break
else:
data = json.dumps({
"type": "error"
})
client[now].send(data.encode())
elif recv["type"] == "buchu":
buchu += 1#不出计数
for j in [0, 1, 2]:
if client[i][j] == now:
now = client[i][(j + 1) % 3]
break
if buchu == 2:#两个不出，第三个人可以随意
bf_type = 0
bf_lenth = 0
bf_max = 0
buchu = 0
这里的通信主要用阻塞式的，单个房间的通信用单个线程去处理，对于斗地主这个游戏来说是够的。如果你要多线程，建议先将通信逻辑与算法逻辑完全隔离封装。
5、启动代码
if __name__ == "__main__":
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#TCP/IP流
HostPort = ('127.0.0.1', 6666)#ip与端口
s.bind(HostPort) # 绑定地址端口
s.listen(99) # 监听连接数，超过次数会拒绝之后的用户
client = {}#主字典，存放房间信息，登录用的名称与地址
station = [0 for x in range(33)]#存放房间状态，0代表等待，1代表游戏中
for i in range(33):
client[i] = []
t = threading.Thread(target=connect, args=(s,))#线程开启处理连接
t.start()
while True:
for i in range(33):
if station[i] == 1 and client[i][0] == 2 and client[i][1] == 2 and client[i][2] == 2:#暂无用处，预设定
station[i] = 0
if len(client[i]) == 3 and station[i] == 0:#房间状态判断
t2 = threading.Thread(target=player, args=(i, client))#开线程处理游戏
t2.start()
print("房间%s启动" % i)
station[i] = 1
这里包含了房间的预创建，房间状态的管理等，是服务器的启动代码。
三、客户端
#接收信息处理函数
def recv(s, d):
l = []
name = input("请输入用户名：")#输名字，用于存储地址和识别
data2 = json.dumps({
"type": "login",
"name": name
})
s.send(data2.encode())
inp = input("开始匹配：")#预设定，可改为可选房间（目前无用）
data2 = json.dumps({
"type": "ready",
"name": name
})
s.send(data2.encode())
while True:
rec = s.recv(1024).decode()
if rec == 0:
break
else:
rec = json.loads(rec)
if rec["type"] == "fapai":#显示自己的牌与其他玩家的牌数
card = ""
rec[name].sort()#对牌排序，使得显示的时候更加美观
for i in rec[name]:#用空格拼接牌
card = card + d[i] + " "
sys.stdout.write("{}\n{}\n我：{}\n".format(rec["player1"], rec["player2"], card))#显示排序，可用print()代替
sys.stdout.flush()
elif rec["type"] == "warning":#服务器通知用户显示通知
sys.stdout.write("{}\n".format(rec["message"]))#显示通知
sys.stdout.flush()
elif rec["type"] == "chupai":#服务器通知用户出牌
l.clear()#预清空
data = {
"type":"chupai",
"card": l
}
while True:
try:#用try防止使程序结束
inp = input("请出牌：")
if inp == "buchu":
data["type"] = "buchu"
else:
inp = inp.split()#规定每张牌以空格隔开
for i in inp:
l.append(d[i])
data["card"] = l
break
except KeyError:
print("输入错误，请检查")#出错通知
data1 = json.dumps(data)
s.send(data1.encode())
elif rec["type"] == "chupai1":#打印别的用户出的牌，这里可以改的更高大上，显示牌时同时显示其牌型
card = ""
rec["card"].sort()#排序
for i in rec["card"]:
card = d[i] + ""
sys.stdout.write("{}出牌:{}\n".format(rec["name"], card))
sys.stdout.flush()
elif rec["type"] == "chupai2":#显示自己出的牌
card = ""
for i in l:
card = d[i] + ""
sys.stdout.write("我出牌:{}\n".format(card))
sys.stdout.flush()
elif rec["type"] == "win":#显示胜利信息
sys.stdout.write("I'm win")
sys.stdout.flush()
elif rec["type"] == "false":#显示失败信息
sys.stdout.write("You are false")
sys.stdout.flush()
elif rec["type"] == "error":#显示出牌错误信息
l.clear()
sys.stdout.write("牌型错误，请重新出牌")
sys.stdout.flush()
elif rec["type"] == "jdz":#叫地主流程
s1 = "不叫"
if not rec["message"] == "叫地主":
s1 = "不抢"
sys.stdout.write("1.{} 2.{}\n".format(rec["message"], s1))
sys.stdout.flush()
inp = input("请输入：")
data = {
"type": "jdz",
"message": "no"
}
try:#与上面的try用处一致
inp = int(inp)
if inp == 1:
data["message"] = "yes"
except:
pass
data = json.dumps(data)
s.send(data.encode())
elif rec["type"] == "select":#显示多牌型选择
data1 = 0
while True:
try:
inp = int(input("请输入0-%s:%s：" % (len(rec["paixing"]), rec["paixing"])))
data1 = rec["paixing"][inp]
data1 = inp
break
except:
print("输入错误")
s.send(data1)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
HostPort = ('127.0.0.1', 6666)
s.connect(HostPort)#连接
d = show()
recv(s, d)
由于游戏中的通信是阻塞模式，所以客户端我也只用单线程去处理就可以了，用这套代码应该能跑完一次完整的游戏，当然具体是否能跑完我还没测试完过，还有代码要是含有什么错误或者缺漏希望你们能留言告诉我哦，交流交流，共同进步。
下面放组效果图：
在这里插入图片描述
