關於python小遊戲開發

1. 猜單詞遊戲
2. 發牌遊戲
3. 猜數字遊戲
4. 圖片版發牌遊戲
5. 人物拼圖

1、猜單詞遊戲

運行截圖：

代碼及步驟：

1．在猜單詞遊戲程序中導入相關模塊。

import random

2．建立全部待猜想的單詞序列元組WORDS。

words=("python","jumble","easy","difficult","answer","continue","phone","posistion","game","position")

3．顯示遊戲歡迎界面。

print(

"""
歡迎參加猜單詞遊戲
把字母組合成一個正確的單詞
"""

)

4．實現遊戲的邏輯。

首先，從序列中隨機挑出一個單詞，如「easy」；而後打亂這個單詞的字母順序；接着，經過屢次循環就能夠產生新的亂序後的單詞jumble；最後，將亂序後的單詞顯示給玩家。玩家輸入猜想單詞，程序判斷對錯。若玩家猜錯，則能夠繼續猜。

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")

5．須要再嵌套一個循環，判斷玩家是否須要再進行猜單詞遊戲

iscontinue="y" while iscontinue=="y" or iscontinue=="Y":

iscontinue=input("\n\n是否繼續（Y/N）：")

完整代碼截圖：

2、發牌遊戲

運行截圖

代碼及步驟：

一、發牌程序設計出三個類： Card類、Hand類和Poke類。

class Card():
	pass
class Hand():
	pass
class Poke(Hand):
	pass

二、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()是翻牌方法，改變牌面是否顯示的屬性值。

class Card():
RANKS = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]  # 牌面數字
SUITS = ["梅", "方", "紅", "黑"]

def __init__(self, rank, suit, face_up=True):
    self.rank = rank  # 指的是牌面數字
    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

三、Hand類

Hand類表明手牌（一個玩家手裏拿的牌），能夠認爲是一位牌手手裏的牌，其中，cards列表變量存儲牌手手中的牌。能夠增長牌、清空手裏的牌、把一張牌給別的牌手等操做。

class Hand():
"""A hand of playing cards."""

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)

四、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張牌，只不過最後仍有牌沒發完。

class Poke(Hand):
"""A desk 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)

五、主程序

主程序比較簡單，由於有四個牌手，因此生成players列表存儲初始化的四位牌手。生成一副牌的對象實例poke1，調用populate()方法生成有52張牌的一副牌，調用huffle()方法洗牌打亂順序，調用deal(players，13)方法分別給每位玩家發13張牌，最後示四位牌手全部的牌。

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("\n Press the enter key to exit.")

3、猜數字遊戲

運行截圖：

代碼及步驟：

一、在猜數字遊戲程序中導入相關模塊：

import tkinter as tk
import sys
import random
import re

二、random.randint(0，1024)隨機產生玩家要猜的數字。

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

三、猜按鈕事件函數從單行文本框entry_a獲取猜的數字並轉換成數字val a，而後判斷是否正確，並根據要猜的數字number判斷數字是過大仍是太小。

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("你已經答對了")

四、HumGuess()函數修改提示標籤文字來顯示猜的次數。

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")`

完整代碼截圖：

4、圖形版發牌程序遊戲

運行截圖：

代碼及步驟：

將要發的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=圖像文件）將牌顯示在指定位置。

利用canvas圖形繪製，繪製出小型窗口，

代碼以下：

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=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()

5、人物拼圖遊戲

運行截圖：

代碼及步驟： 一、圖片進行分割，放在代碼的文件下

二、定義常量及加載圖片

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=700
HEIGHT=623

三、圖像塊（拼塊）類

每一個圖像塊（拼塊）都是Square對象，具備draw功能，所以，可將本拼塊圖片繪製到Canvas上。orderID屬性是每一個圖像塊（拼塊）對應的編號。

#圖像塊邊長
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)

四、初始化遊戲

random.shuffle(board)只能按行打亂二維列表，因此使用一維列表來實現打亂圖像塊的功能，再根據編號生成對應的圖像塊（拼塊）到board列表中。

#初始化拼盤
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 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="拼圖完成")`

七、判斷輸贏

判斷拼塊的編號是否有序，若是不是有序的，則返回False。

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)

完整代碼：

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=700
HEIGHT=623
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()

感想：關於這次的python遊戲開發中，咱們主要了解到python的多方應用，輕重對tkinter的包的應用和random的應用是最爲常見的，也能更好得開發，其中當運用圖片時，最好將圖片和代碼放在同一個文件夾下，否則路徑老師會出錯，固然，若是圖片路徑可以對是最好不過，保險起見最好仍是放在一塊不容易出錯。