基于python的游戏制作案列
一、序列应用——猜单词游戏
1．在猜单词游戏程序中导入相关模块。
2．创建所有待猜测的单词序列元组WORDS。
3．显示游戏欢迎界面。
4．实现游戏的逻辑。
首先，从序列中随机挑出一个单词，如“easy”；然后打乱这个单词的字母顺序；接着，通过多次循环就可以产生新的乱序后的单词jumble；最后，将乱序后的单词显示给玩家。
5．玩家输入猜测单词，程序判断对错。若玩家猜错，则可以继续猜。
参考代码：
import random
WORDS=("python","jumble","easy","difficult","answer","continue","phone","position","game")
print("欢迎参加猜单词游戏，把字母组合成一个正确的单词")
iscontinue="y"
while iscontinue=="y"or iscontinue=="Y":
word=random.choice(WORDS)
corrent=word
jumble=""
while word:
position=random.randrange(len(word))
jumble+=word[position]
word=word[:position]+word[(position+1):]
print("乱序后单词：",jumble)
guess=input("\n请你猜：")
while guess != corrent and guess !="":
print("对不起不正确")
guess=input("继续猜：")
if guess==corrent:
print("真棒，你猜对了！\n")
iscontinue=input("\n\n是否继续(Y/N):")
运行结果如图：
二、面向对象设计应用——发牌游戏
（一）、设计类
发牌程序设计出三个类： Card类、Hand类和Poke类。
1.Card类
Card类代表一张牌，其中，FaceNum字段指的是牌面数字1～13，Suit字段指的是花色，”梅”为梅花，”方”为方块，”红”为红桃，”黑”为黑桃。
其中：Card构造函数根据参数初始化封装的成员变量，实现牌面大小和花色的初始化，以及是否显示牌面，默认True为显示牌正面；str()方法用来输出牌面大小和花色；pic_order()方法获取牌的顺序号，牌面按梅花1～13，方块14- 26，红桃27-39，黑桃40- 52顺序编号（未洗牌之前），也就是说，梅花2顺序号为2，方块A顺序号为14，方块K顺序号为26（这个方法为图形化显示牌面预留的方法）； flip()是翻牌方法，改变牌面是否显示的属性值。
2.Hand类
Hand类代表手牌（一个玩家手里拿的牌），可以认为是一位牌手手里的牌，其中，cards列表变量存储牌手手中的牌。可以增加牌、清空手里的牌、把一张牌给别的牌手等操作。
3.Poke类
Poke类代表一副牌，我们可以将一副牌看作是有52张牌的牌手，所以继承Hand类。由于其中cards列表变量要存储52张牌，而且要进行发牌、洗牌操作，所以增加如下的方法。
populate(self)生成存储了52张牌的一副牌，当然这些牌是按梅花1～13，方块14- 26，红桃27～39，黑桃40- 52的顺序（未洗牌之前）存储在cards列表变量。 shuffle(self)洗牌，使用Python的random模块shuffle()方法打乱牌的存储顺序即可。deal( self., hands,per_hand=13)可完成发牌动作，发给四个牌人默认13张牌。当然，若令per_hand=10，则给每个牌手发1 0张牌，只不过最后仍有牌没发完。
（二）主程序
主程序比较简单，因为有四个牌手，所以生成players列表存储初始化的四位牌手。生成一副牌的对象实例poke1，调用populate()方法生成有52张牌的一副牌，调用huffle()方法洗牌打乱顺序，调用deal(players，13)方法分别给每位玩家发13张牌，最后示四位牌手所有的牌。
参考代码：
class Card():
Ranks=["A","2","3","4","5","6","7","8","9","10","J","Q","K"]#牌面数字1-13
Suits=["梅","方","红","黑"]#四个花色
def __init__(self,rank,suit,face_up=True):
self.rank=rank
self.suit=suit
self.is_face_up=face_up #是否显示牌正面，True为正面，Flase为背面
def __str__(self):
if self.is_face_up:
rep=self.suit+self.rank
else:
rep="XX"
return rep
def flip(self): #翻牌方法
self.is_face_up=not self.is_face_up
def pic_order(self): #牌的顺序号
if self.rank=="A":
FaceNum=1
elif self.rank=="J":
FaceNum=11
elif self.rank=="Q":
FaceNum=12
elif self.rank=="K":
FaceNum=13
else:
FaceNum=int(self.rank)
if self.suit=="梅":
Suit=1
elif self.suit=="方":
Suit=2
elif self.suit=="红":
Suit=3
else:
Suit=4
return (Suit-1)*13+FaceNum
class Hand():
def __init__(self):
self.cards=[]
def __str__(self): #重写print()方法
if self.cards:
rep=""
for card in self.cards:
rep+=str(card)+"\t"
else:
rep="无牌"
return rep
def clear(self):
self.cards=[]
def add(self,card):
self.cards.append(card)
def give(self,card,other_hand):
self.cards.remove(card)
other_hand.add(card)
class Poke(Hand):
def populate(self): #生成一副牌
for suit in Card.Suits:
for rank in Card.Ranks:
self.add(Card(rank,suit))
def shuffle(self): #洗牌
import random
random.shuffle(self.cards)
def deal(self,hands,per_hand=13): #发牌，发给玩家，每人默认13张
for rounds in range(per_hand):
for hand in hands:
top_card=self.cards[0]
self.cards.remove(top_card)
hand.add(top_card)
if __name__=="__main__":
print("This is a module with classes for playing cards.")
players=[Hand(),Hand(),Hand(),Hand()]
poke1=Poke()
poke1.populate() #生成一副牌
poke1.shuffle() #洗牌
poke1.deal(players,13) #发给玩家每人13张
#显示4位牌手的牌
n=1
for hand in players:
print("牌手",n,end=":")
print(hand)
n=n+1
input("\nPress the enter key to exit.")
运行结果如图：
三、图形界面设计——猜数字游戏
1.在猜数字游戏程序中导入相关模块：
random.randint(0，1024)随机产生玩家要猜的数字。
2.猜按钮事件函数从单行文本框entry_a获取猜的数字并转换成数字val a，然后判断是否正确，并根据要猜的数字number判断数字是过大还是过小。
3.HumGuess()函数修改提示标签文字来显示猜的次数。
4.关闭按钮事件函数实现窗体关闭。
参考代码：
import tkinter as tk
import sys
import random
import re
number=random.randint(0,1024)
running=True
num=0
nmaxn=1024
nminn=0
def eBtnClose(event):
root.destory()
def eBtnGuess(event):
global nmaxn
global nminn
global num
global running
if running:
val_a=int(entry_a.get())
if val_a==number:
labelqval("恭喜你答对了")
num+=1
running=False
numGuess()
elif val_a<number:
if val_a>nminn:
nminn=val_a
num+=1
label_tip_min.config(label_tip_min,text=nminn)
labelqval("小了哦")
else:
if val_a<nmaxn:
nmaxn=val_a
num+=1
label_tip_max.config(label_tip_max,text=nmaxn)
labelqval("大了哦")
else:
labelqval("你已经答对啦...")
def numGuess():
if num==1:
labelqval("哇，竟然一次答对")
elif num<10:
labelqval("厉害，十次之内就答对了，尝试次数："+str(num))
elif num<50:
labelqval("还行哦尝试次数："+str(num))
else:
labelqval("您都超过50次了，尝试次数："+str(num))
def labelqval(vText):
label_val_q.config(label_val_q,text=vText)
root=tk.Tk(className="猜数字游戏")
root.geometry("400x90+200+200")
line_a_tip=tk.Frame(root)
label_tip_max=tk.Label(line_a_tip,text=nmaxn)
label_tip_min=tk.Label(line_a_tip,text=nminn)
label_tip_max.pack(side="top",fill="x")
label_tip_min.pack(side="bottom",fill="x")
line_a_tip.pack(side="left",fill="y")
line_question=tk.Frame(root)
label_val_q=tk.Label(line_question,width="80")
label_val_q.pack(side="left")
line_question.pack(side="top",fill="x")
line_input=tk.Frame(root)
entry_a=tk.Entry(line_input,width="40")
btnGuess=tk.Button(line_input,text="猜")
entry_a.pack(side="left")
entry_a.bind('<Return>',eBtnGuess)
btnGuess.bind('<Button-1>',eBtnGuess)
btnGuess.pack(side="left")
line_input.pack(side="top",fill="x")
line_btn=tk.Frame(root)
btnClose=tk.Button(line_btn,text="关闭")
btnClose.bind('<Button-1>',eBtnClose)
btnClose.pack(side="left")
line_btn.pack(side="top")
labelqval("请输入0-1024之间得任意整数：")
entry_a.focus_set()
print(number)
root.mainloop()
运行结果如图：
四、Tkinter图形绘制——图形版发牌程序
1.程序功能介绍
机随机将52张牌（不含大王和小王）发给四位牌手，在屏幕上显示每位牌手的牌，程序的运行效果如图5-1所示。接下来，我们以使用Canvas绘制Tkinter模块图形为例，介绍建立简单GUI（图形用户界面）游戏界面的方法。
2.程序设计思路
将要发的52张牌，按梅花0～12，方块13- 25，红桃26- 38，黑桃39- 51的顺序编号并存储在pocker列表c未洗牌之前l，列表元素存储的是某张牌c实际上是牌的编号）。同时，按此编号将扑克牌图片顺序存储在imgs列表中。也就是说，imgs[0]存储梅花A的图片，imgs[1]存储梅花2的图片，imgs[14]存储方块2的图片，依次类推。
发牌后，根据每位牌手(pl,p2，p3，p4)各自牌的编号列表，从imgs获取对应牌的图片，并使用create- image《x坐标，y坐标)，image=图像文件）将牌显示在指定位置。
参考代码：
from tkinter import *
import random
n=52
def gen_pocker(n):
x=100
while (x>0):
x=x-1
p1=random.randint(0,n-1)
p2=random.randint(0,n-1)
t=pocker[p1]
pocker[p1]=pocker[p2]
pocker[p2]=t
return pocker
pocker=[i for i in range(n)]
pocker=gen_pocker(n)
print(pocker)
(player1,player2,player3,player4)=([],[],[],[])
(p1,p2,p3,p4)=([],[],[],[])
root=Tk()
cv=Canvas(root,bg='white',width=700,height=600)
imgs=[]
for i in range(1,5):
for j in range(1,14):
imgs.insert((i-1)*13+(j-1),PhotoImage(file="images\\"+str(i)+'-'+str(j)+'.gif'))
for x in range(13):
m=x*4
p1.append(pocker[m])
p2.append(pocker[m+1])
p3.append(pocker[m+2])
p4.append(pocker[m+3])
p1.sort()
p2.sort()
p3.sort()
p4.sort()
for x in range(0,13):
img=imgs[p1[x]]
player1.append(cv.create_image((200+20*x,80),image=img))
img=imgs[p2[x]]
player2.append(cv.create_image((100,150+20*x),image=img))
img=imgs[p3[x]]
player3.append(cv.create_image((200+20*x,500),image=img))
img=imgs[p4[x]]
player4.append(cv.create_image((560,150+20*x),image=img))
print("player1:",player1)
print("player2:",player2)
print("player3:",player3)
print("player4:",player4)
cv.pack()
root.mainloop()
运行结果如图：
五、Python图像处理——人物拼图游戏
1.游戏介绍
拼图游戏将一幅图片分割咸若干拼块并将它们随机打乱顺序，当将所有拼块都放回原位置时，就完成了拼图（游戏结束）。本人物拼图游戏为3行3列，拼块以随机顺序排列，玩家用鼠标单击空白块四周的交换它们位置，直到所有拼块都回到原位置。拼图游戏运行界面
2.程序设计思路
游戏程序首先将图片分割成相应3行3列的拼块，并按顺序编号。动态地生成一个＼为3x3的列表board，用于存放数字0一8，其中，每个数字代表一个拼块，8号拼块不显示。
游戏开始时，随机打乱这个数组board，如board[0l[0]是5号拼块，则在左上角显示编号是5的拼块。根据玩家用鼠标单击的拼块和空白块所在位置，来交换该board数组对应的元素，最后通过元素排列顺序来判断是否已经完成游戏。
0 1 2
3 4 5
6 7 8
打乱后
5 8 2
4 6 3
1 7 0
参考代码：
from tkinter import *
from tkinter.messagebox import *
import random
root=Tk('拼图游戏')
root.title("拼图")
Pics=[]
for i in range(9):
filename='ka'+str(i)+'.png'
Pics.append(PhotoImage(file=filename))
WIDTH=720
HEIGHT=720
IMAGE_WIDTH=WIDTH//3
IMAGE_HEIGHT=HEIGHT//3
ROWS=3
COLS=3
steps=0
board=[[0,1,2],[3,4,5],[6,7,8]]
class Square:
def __init__(self,orderID):
self.orderID=orderID
def draw(self,canvas,board_pos):
img=Pics[self.orderID]
canvas.create_image(board_pos,image=img)
def init_board():
L=list(range(8))
L.append(None)
random.shuffle(L)
for i in range(ROWS):
for j in range(COLS):
idx=i*ROWS+j
orderID=L[idx]
if orderID is None:
board[i][j]=None
else:
board[i][j]=Square(orderID)
def play_game():
global steps
steps=0
init_board()
def drawBoard(canvas):
canvas.create_polygon((0,0,WIDTH,0,WIDTH,HEIGHT,0,HEIGHT),width=1,outline='Black',fill='green')
for i in range(ROWS):
for j in range(COLS):
if board[i][j] is not None:
board[i][j].draw(canvas,(IMAGE_WIDTH*(j+0.5),IMAGE_HEIGHT*(i+0.5)))
def mouseclick(pos):
global steps
r=int(pos.y//IMAGE_HEIGHT)
c=int(pos.x//IMAGE_WIDTH)
print(r,c)
if r<3 and c<3:
if board[r][c] is None:
return
else:
current_square=board[r][c]
if r-1>=0 and board[r-1][c] is None:
board[r][c]=None
board[r-1][c]=current_square
steps+=1
elif c+1<=2 and board[r][c+1] is None:
board[r][c]=None
board[r][c+1]=current_square
steps+=1
elif r+1<=2 and board[r+1][c] is None:
board[r][c]=None
board[r+1][c]=current_square
steps+=1
elif c-1>=0 and board[r][c-1] is None:
board[r][c]=None
board[r][c-1]=current_square
steps+=1
Label1["text"]=str(steps)
cv.delete('all')
drawBoard(cv)
if win():
showinfo(title="恭喜",message="你成功了！")
def win():
for i in range(ROWS):
for j in range(COLS):
if board[i][j] is not None and board[i][j].orderID!=i*ROWS+j:
return False
return True
def callBack2():
print("重新开始")
play_game()
cv.delete('all')
drawBoard(cv)
cv=Canvas(root,bg='white',width=WIDTH,height=HEIGHT)
b1=Button(root,text="重新开始",command=callBack2,width=20)
Label1=Label(root,text="0",fg='red',width=20)
Label1.pack()
cv.bind('<Button-1>',mouseclick)
cv.pack()
b1.pack()
play_game()
drawBoard(cv)
root.mainloop()
运行结果如图：
来源：oschina
链接：https://my.oschina.net/u/4463347/blog/3190509