亲宝软件园·资讯

展开

python游戏开发案例 python游戏开发的五个案例分享

梁梦婷 人气:0

一、序列应用——猜单词游戏

1. 游戏介绍

猜单词游戏就是计筧机随机产生一个单词,打乱字母顺序,供玩家去猜测。此游戏采用控制字符界面,

2.  程序设计思路

游戏中,可使用序列中的元组存储所有待猜测的单词。因为猜单词游戏需要随机产生某个待猜测单词以及随机数字,所以引入random模块随机数函数。其中,random.choice()可以从序列中随机选取元素。

在游戏中,随机挑出一个单词word后,把单词word的字母顺序打乱的方法是随机单词字符串中选择一个位置position,把position位置的字母加入乱序后的单词jumble,同时将原单词word中position位置的那个字母删去(通过连接position位置前字符串和其后字符串实现)。通过多次循环就可以产生乱序后的新单词jumble。

3.  random模块

random模块可以产生一个随机数或者从序列中获取一个随机元素。

4.  程序设计步骤

(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)
  correct=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 !=correct and guess !="":
    print("对不起不正确")
    guess=input("继续猜:")
  if guess==correct:
    print("真棒,你猜对了!\n")
  iscontinue = input("\n\n是否继续(Y/N):")

二、面向对象设计应用——发牌游戏

1.  游戏介绍

四名牌手打牌,电脑随机將52张牌(不合大、小王)发给四名牌手,并在屏幕上显示每位牌手的牌。

2.  面向对象程序设计

3.  程序设计步骤

设计类,发牌程序设计出三个类: Card类、Hand类和Poke类。

Card类:Card类代表一张牌,其中,FaceNum字段指的是牌面数字1~13,Suit字段指的是花色,”梅”为梅花,”方”为方块,”红”为红桃,”黑”为黑桃。

Hand类:Hand类代表手牌(一个玩家手里拿的牌),可以认为是一位牌手手里的牌,其中,cards列表变量存储牌手手中的牌。可以增加牌、清空手里的牌、把一张牌给别的牌手等操作。

Poke类:Poke类代表一副牌,我们可以将一副牌看作是有52张牌的牌手,所以继承Hand类。由于其中cards列表变量要存储52张牌,而且要进行发牌、洗牌操作,所以增加如下的方法。

主程序:主程序比较简单,因为有四个牌手,所以生成players列表存储初始化的四位牌手。生成一副牌的对象实例poke1,调用populate()方法生成有52张牌的一副牌,调用huffle()方法洗牌打乱顺序,调用deal(players,13)方法分别给每位玩家发13张牌,最后示四位牌手所有的牌。

游戏截图:

参考代码:

class Card():
  """ A playing 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       #指的是牌面数字1-13
    self.suit=suit       #suit指的是花色
    self.is_face_up=face_up  #是否显示牌正面,True为正面,False为牌背面

  def __str__(self): #print()
    if self.is_face_up:
      rep=self.suit+self.rank #+" "+str(self.pic_order())
    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( ):
  """ A hand of playing cards. """
  def __init__(self):
    self.cards=[]
  def __str__(self):
    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):
  """ A deck of playing cards. """
  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):
    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 classed for playing cards.")
  #四个玩家
  players=[Hand(),Hand(),Hand(),Hand()]
  poke1=Poke()
  poke1.populate()      #生成一副牌
  poke1.shuffle()       #洗牌
  poke1.deal(players,13)   #发给玩家每人13张
  #显示四位牌手的牌
  n=1
  for hand in players:
    print("牌手",n,end=":")
    print(hand)
    n=n+1
  input("\nPress the enter key to exit.")

三、图形界面设计——猜数字游戏

1. 游戏介绍

在游戏中,程序随机生成1024以内的数字,再让玩家去猜,如果猜的数字过大过小都会进行提示,程序还会统计玩家猜的次数。使用Tkinter开发猜数字游戏

2.  python图形界面设计

Python提供了多个图形开发界面的库

3.  程序设计步骤

在猜数字游戏程序中导入相关模块:

random.randint(0,1024)随机产生玩家要猜的数字。

猜按钮事件函数从单行文本框entry_a获取猜的数字并转换成数字val a,然后判断是否正确,并根据要猜的数字number判断数字是过大还是过小。

HumGuess()函数修改提示标签文字来显示猜的次数。

关闭按钮事件函数实现窗体关闭。

游戏截图:

参考代码:

import tkinter as tk
import sys
import random
import re

number=random.randint(0,1024)
running=True
num=0
nmaxn=1024
nmin=0

def eBtnClose(event):
  root.destroy()
def eBtnGuess(event):
  global nmaxn
  global nmin
  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>nmin:
        nmin=val_a
        num+=1
        label_tip_min.config(label_tip_min,text=nmin)
      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=nmin)
label_tip_max.pack(side="top",fill="x")
label_tip_min.pack(side="bottom",fill="y")
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()
#创建一个Canvas,设置其背景为白色
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='D:/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]]
  player1.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数组对应的元素,最后通过元素排列顺序来判断是否已经完成游戏。

3.   程序设计步骤

Python处理图片切割

使用PIL中的crop()方法可以从一幅图像中裁剪指定区域。该区域使用四元组来指定,四元组的坐标依次是(左、上、右、下)。PIL中指定坐标系的左上角坐标为(0,0).

在本游戏中,需要把图片分割为3列图片块,在上面的基础上再指定不同的区域即可进行裁剪、保存。为了方便使用,可编写splitimage(src,rownum,colnum,dstpath)函数,实现将指定的src图片文件分隔成rownumxcolnum数量的小图片块。

4.  游戏逻辑的实现

(1)加载图片

(2)图像块(拼块)类

每个图像块(拼块)都是Square对象,具有draw功能,因此,可将本拼块图片绘制到Canvas上。orderID属性是每个图像块(拼块)对应的编号。

(3)初始化游戏

random.shuffle(board)只能按行打乱二维列表,所以使用一维列表来实现打乱图像块的功能,再根据编号生成对应的图像块(拼块)到board列表中。

(4)绘制游戏界面的各个元素

游戏界面中还存在着各个元素,如黑框等,

(5)鼠标事件

将单击位置换算成拼图板上的棋盘坐标,如果单击空位置,则所有图像块都不移动;否则依次检查被单击的当前图像块的上、下、左、右是否有空位置,如果有,就移动当前图像块。

(6)判断输赢

判断拼块的编号是否有序,如果不是有序的,则返回False。

(7)重置游戏

(8)“重新开始”按钮的单击事件

游戏截图:

参考代码:

from tkinter import*
from tkinter.messagebox import *
import random
root=Tk('拼图游戏')
root.title('拼图')
Pics=[]
for i in range(9):
  filename="\\"+str(i)+".gif"
  Pics.append(PhotoImage(file=filename))
WIDTH=400
HEIGHT=315
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='pink')
  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()

加载全部内容

相关教程
猜你喜欢
用户评论