目錄
- 一、界面應用
- 1、計算器
- 2、記事本
- 3、登錄和注冊
- 二、游戲開發
- 1、2048
- 2、貪吃蛇
- 3、俄羅斯方塊
- 4、連連看
一、界面應用
1、計算器
1. 案例介紹
本例利用 Python 開發一個可以進行簡單的四則運算的圖形化計算器，會用到 Tkinter 圖形組件進行開發，主要知識點：Python Tkinter 界面編程；計算器邏輯運算實作，本例難度為初級，適合具有 Python 基礎和 Tkinter 組件編程知識的用戶學習，
2. 設計原理
要制作一個計算器，首先需要知道它由哪些部分組成，示意如下圖所示，
從結構上來說，一個簡單的圖形界面，需要由界面組件、組件的事件監聽器(回應各類事件的邏輯)和具體的事件處理邏輯組成，界面實作的主要作業是創建各個界面組件物件，對其進行初始化，以及控制各組件之間的層次關系和布局，
3. 示例效果
4. 示例原始碼
import tkinter
import math
import tkinter.messagebox
class Calculator(object):
# 界面布局方法
def __init__(self):
# 創建主界面，并且保存到成員屬性中
self.root = tkinter.Tk()
self.root.minsize(280, 450)
self.root.maxsize(280, 470)
self.root.title('計算器')
# 設定顯式面板的變數
self.result = tkinter.StringVar()
self.result.set(0)
# 設定一個全域變數 運算元字和f符號的串列
self.lists = []
# 添加一個用于判斷是否按下運算子號的標志
self.ispresssign = False
# 界面布局
self.menus()
self.layout()
self.root.mainloop()
# 計算器選單界面擺放
def menus(self):
# 添加選單
# 創建總選單
allmenu = tkinter.Menu(self.root)
# 添加子選單
filemenu = tkinter.Menu(allmenu, tearoff=0)
# 添加選項卡
filemenu.add_command(
label='標準型(T) Alt+1', command=self.myfunc)
filemenu.add_command(
label='科學型(S) Alt+2', command=self.myfunc)
filemenu.add_command(
label='程式員(P) Alt+3', command=self.myfunc)
filemenu.add_command(label='統計資訊(A) Alt+4', command=self.myfunc)
# 添加分割線
filemenu.add_separator()
# 添加選項卡
filemenu.add_command(label='歷史記錄(Y) Ctrl+H', command=self.myfunc)
filemenu.add_command(label='數字分組(I)', command=self.myfunc)
# 添加分割線
filemenu.add_separator()
# 添加選項卡
filemenu.add_command(
label='基本(B) Ctrl+F4', command=self.myfunc)
filemenu.add_command(label='單位轉換(U) Ctrl+U', command=self.myfunc)
filemenu.add_command(label='日期計算(D) Ctrl+E', command=self.myfunc)
menu1 = tkinter.Menu(filemenu, tearoff=0)
menu1.add_command(label='抵押(M)', command=self.myfunc)
menu1.add_command(label='汽車租賃(V)', command=self.myfunc)
menu1.add_command(label='油耗(mpg)(F)', command=self.myfunc)
menu1.add_command(label='油耗(l/100km)(U)', command=self.myfunc)
filemenu.add_cascade(label='作業表(W)', menu=menu1)
allmenu.add_cascade(label='查看(V)', menu=filemenu)
# 添加子選單2
editmenu = tkinter.Menu(allmenu, tearoff=0)
# 添加選項卡
editmenu.add_command(label='復制(C) Ctrl+C', command=self.myfunc)
editmenu.add_command(label='粘貼(V) Ctrl+V', command=self.myfunc)
# 添加分割線
editmenu.add_separator()
# 添加選項卡
menu2 = tkinter.Menu(filemenu, tearoff=0)
menu2.add_command(label='復制歷史記錄(I)', command=self.myfunc)
menu2.add_command(
label='編輯(E) F2', command=self.myfunc)
menu2.add_command(label='取消編輯(N) Esc', command=self.myfunc)
menu2.add_command(label='清除(L) Ctrl+Shift+D', command=self.myfunc)
editmenu.add_cascade(label='歷史記錄(H)', menu=menu2)
allmenu.add_cascade(label='編輯(E)', menu=editmenu)
# 添加子選單3
helpmenu = tkinter.Menu(allmenu, tearoff=0)
# 添加選項卡
helpmenu.add_command(label='查看幫助(V) F1', command=self.myfunc)
# 添加分割線
helpmenu.add_separator()
# 添加選項卡
helpmenu.add_command(label='關于計算器(A)', command=self.myfunc)
allmenu.add_cascade(label='幫助(H)', menu=helpmenu)
self.root.config(menu=allmenu)
# 計算器主界面擺放
def layout(self):
# 顯示屏
result = tkinter.StringVar()
result.set(0)
show_label = tkinter.Label(self.root, bd=3, bg='white', font=(
'宋體', 30), anchor='e', textvariable=self.result)
show_label.place(x=5, y=20, width=270, height=70)
# 功能按鈕MC
button_mc = tkinter.Button(self.root, text='MC', command=self.wait)
button_mc.place(x=5, y=95, width=50, height=50)
# 功能按鈕MR
button_mr = tkinter.Button(self.root, text='MR', command=self.wait)
button_mr.place(x=60, y=95, width=50, height=50)
# 功能按鈕MS
button_ms = tkinter.Button(self.root, text='MS', command=self.wait)
button_ms.place(x=115, y=95, width=50, height=50)
# 功能按鈕M+
button_mjia = tkinter.Button(self.root, text='M+', command=self.wait)
button_mjia.place(x=170, y=95, width=50, height=50)
# 功能按鈕M-
button_mjian = tkinter.Button(self.root, text='M-', command=self.wait)
button_mjian.place(x=225, y=95, width=50, height=50)
# 功能按鈕←
button_zuo = tkinter.Button(self.root, text='←', command=self.dele_one)
button_zuo.place(x=5, y=150, width=50, height=50)
# 功能按鈕CE
button_ce = tkinter.Button(
self.root, text='CE', command=lambda: self.result.set(0))
button_ce.place(x=60, y=150, width=50, height=50)
# 功能按鈕C
button_c = tkinter.Button(self.root, text='C', command=self.sweeppress)
button_c.place(x=115, y=150, width=50, height=50)
# 功能按鈕±
button_zf = tkinter.Button(self.root, text='±', command=self.zf)
button_zf.place(x=170, y=150, width=50, height=50)
# 功能按鈕√
button_kpf = tkinter.Button(self.root, text='√', command=self.kpf)
button_kpf.place(x=225, y=150, width=50, height=50)
# 數字按鈕7
button_7 = tkinter.Button(
self.root, text='7', command=lambda: self.pressnum('7'))
button_7.place(x=5, y=205, width=50, height=50)
# 數字按鈕8
button_8 = tkinter.Button(
self.root, text='8', command=lambda: self.pressnum('8'))
button_8.place(x=60, y=205, width=50, height=50)
# 數字按鈕9
button_9 = tkinter.Button(
self.root, text='9', command=lambda: self.pressnum('9'))
button_9.place(x=115, y=205, width=50, height=50)
# 功能按鈕/
button_division = tkinter.Button(
self.root, text='/', command=lambda: self.presscalculate('/'))
button_division.place(x=170, y=205, width=50, height=50)
# 功能按鈕%
button_remainder = tkinter.Button(
self.root, text='//', command=lambda: self.presscalculate('//'))
button_remainder.place(x=225, y=205, width=50, height=50)
# 數字按鈕4
button_4 = tkinter.Button(
self.root, text='4', command=lambda: self.pressnum('4'))
button_4.place(x=5, y=260, width=50, height=50)
# 數字按鈕5
button_5 = tkinter.Button(
self.root, text='5', command=lambda: self.pressnum('5'))
button_5.place(x=60, y=260, width=50, height=50)
# 數字按鈕6
button_6 = tkinter.Button(
self.root, text='6', command=lambda: self.pressnum('6'))
button_6.place(x=115, y=260, width=50, height=50)
# 功能按鈕*
button_multiplication = tkinter.Button(
self.root, text='*', command=lambda: self.presscalculate('*'))
button_multiplication.place(x=170, y=260, width=50, height=50)
# 功能按鈕1/x
button_reciprocal = tkinter.Button(
self.root, text='1/x', command=self.ds)
button_reciprocal.place(x=225, y=260, width=50, height=50)
# 數字按鈕1
button_1 = tkinter.Button(
self.root, text='1', command=lambda: self.pressnum('1'))
button_1.place(x=5, y=315, width=50, height=50)
# 數字按鈕2
button_2 = tkinter.Button(
self.root, text='2', command=lambda: self.pressnum('2'))
button_2.place(x=60, y=315, width=50, height=50)
# 數字按鈕3
button_3 = tkinter.Button(
self.root, text='3', command=lambda: self.pressnum('3'))
button_3.place(x=115, y=315, width=50, height=50)
# 功能按鈕-
button_subtraction = tkinter.Button(
self.root, text='-', command=lambda: self.presscalculate('-'))
button_subtraction.place(x=170, y=315, width=50, height=50)
# 功能按鈕=
button_equal = tkinter.Button(
self.root, text='=', command=lambda: self.pressequal())
button_equal.place(x=225, y=315, width=50, height=105)
# 數字按鈕0
button_0 = tkinter.Button(
self.root, text='0', command=lambda: self.pressnum('0'))
button_0.place(x=5, y=370, width=105, height=50)
# 功能按鈕.
button_point = tkinter.Button(
self.root, text='.', command=lambda: self.pressnum('.'))
button_point.place(x=115, y=370, width=50, height=50)
# 功能按鈕+
button_plus = tkinter.Button(
self.root, text='+', command=lambda: self.presscalculate('+'))
button_plus.place(x=170, y=370, width=50, height=50)
# 計算器選單功能
def myfunc(self):
tkinter.messagebox.showinfo('', '預留介面，學成之后，你是不是有沖動添加該功能.')
# 數字方法
def pressnum(self, num):
# 全域化變數
# 判斷是否按下了運算子號
if self.ispresssign == False:
pass
else:
self.result.set(0)
# 重置運算子號的狀態
self.ispresssign = False
if num == '.':
num = '0.'
# 獲取面板中的原有數字
oldnum = self.result.get()
# 判斷界面數字是否為0
if oldnum == '0':
self.result.set(num)
else:
# 連接上新按下的數字
newnum = oldnum + num
# 將按下的數字寫到面板中
self.result.set(newnum)
# 運算函式
def presscalculate(self, sign):
# 保存已經按下的數字和運算子號
# 獲取界面數字
num = self.result.get()
self.lists.append(num)
# 保存按下的運算子號
self.lists.append(sign)
# 設定運算子號為按下狀態
self.ispresssign = True
# 獲取運算結果
def pressequal(self):
# 獲取所有的串列中的內容（之前的數字和操作）
# 獲取當前界面上的數字
curnum = self.result.get()
# 將當前界面的數字存入串列
self.lists.append(curnum)
# 將串列轉化為字串
calculatestr = ''.join(self.lists)
# 使用eval執行字串中的運算即可
endnum = eval(calculatestr)
# 將運算結果顯示在界面中
self.result.set(str(endnum)[:10])
if self.lists != 0:
self.ispresssign = True
# 清空運算串列
self.lists.clear()
# 暫未開發說明
def wait(self):
tkinter.messagebox.showinfo('', '更新中......')
# ←按鍵功能
def dele_one(self):
if self.result.get() == '' or self.result.get() == '0':
self.result.set('0')
return
else:
num = len(self.result.get())
if num > 1:
strnum = self.result.get()
strnum = strnum[0:num - 1]
self.result.set(strnum)
else:
self.result.set('0')
# ±按鍵功能
def zf(self):
strnum = self.result.get()
if strnum[0] == '-':
self.result.set(strnum[1:])
elif strnum[0] != '-' and strnum != '0':
self.result.set('-' + strnum)
# 1/x按鍵功能
def ds(self):
dsnum = 1 / int(self.result.get())
self.result.set(str(dsnum)[:10])
if self.lists != 0:
self.ispresssign = True
# 清空運算串列
self.lists.clear()
# C按鍵功能
def sweeppress(self):
self.lists.clear()
self.result.set(0)
# √按鍵功能
def kpf(self):
strnum = float(self.result.get())
endnum = math.sqrt(strnum)
if str(endnum)[-1] == '0':
self.result.set(str(endnum)[:-2])
else:
self.result.set(str(endnum)[:10])
if self.lists != 0:
self.ispresssign = True
# 清空運算串列
self.lists.clear()
# 實體化物件
my_calculator = Calculator()
2、記事本
1. 案例介紹
tkinter 是 Python下面向 tk 的圖形界面介面庫，可以方便地進行圖形界面設計和互動操作編程，tkinter 的優點是簡單易用、與 Python 的結合度好，tkinter 在 Python 3.x 下默認集成，不需要額外的安裝操作；不足之處為缺少合適的可視化界面設計工具，需要通過代碼來完成視窗設計和元素布局，
本例采用的 Python 版本為 3.8，如果想在 python 2.x下使用 tkinter，請先進行安裝，需要注意的是，不同 Python 版本下的 tkinter 使用方式可能略有不同，建議采用 Python3.x 版本，
本例難度為中級，適合具有 Python 基礎和 Tkinter 組件編程知識的用戶學習，
2. 示例效果
3. 示例原始碼
from tkinter import *
from tkinter.filedialog import *
from tkinter.messagebox import *
import os
filename = ""
def author():
showinfo(title="作者", message="Python")
def power():
showinfo(title="著作權資訊", message="課堂練習")
def mynew():
global top, filename, textPad
top.title("未命名檔案")
filename = None
textPad.delete(1.0, END)
def myopen():
global filename
filename = askopenfilename(defaultextension=".txt")
if filename == "":
filename = None
else:
top.title("記事本" + os.path.basename(filename))
textPad.delete(1.0, END)
f = open(filename, 'r')
textPad.insert(1.0, f.read())
f.close()
def mysave():
global filename
try:
f = open(filename, 'w')
msg = textPad.get(1.0, 'end')
f.write(msg)
f.close()
except:
mysaveas()
def mysaveas():
global filename
f = asksaveasfilename(initialfile="未命名.txt", defaultextension=".txt")
filename = f
fh = open(f, 'w')
msg = textPad.get(1.0, END)
fh.write(msg)
fh.close()
top.title("記事本 " + os.path.basename(f))
def cut():
global textPad
textPad.event_generate("<<Cut>>")
def copy():
global textPad
textPad.event_generate("<<Copy>>")
def paste():
global textPad
textPad.event_generate("<<Paste>>")
def undo():
global textPad
textPad.event_generate("<<Undo>>")
def redo():
global textPad
textPad.event_generate("<<Redo>>")
def select_all():
global textPad
# textPad.event_generate("<<Cut>>")
textPad.tag_add("sel", "1.0", "end")
def find():
t = Toplevel(top)
t.title("查找")
t.geometry("260x60+200+250")
t.transient(top)
Label(t, text="查找：").grid(row=0, column=0, sticky="e")
v = StringVar()
e = Entry(t, width=20, textvariable=v)
e.grid(row=0, column=1, padx=2, pady=2, sticky="we")
e.focus_set()
c = IntVar()
Checkbutton(t, text="不區分大小寫", variable=c).grid(row=1, column=1, sticky='e')
Button(t, text="查找所有", command=lambda: search(v.get(), c.get(),
textPad, t, e)).grid(row=0, column=2, sticky="e" + "w", padx=2,
pady=2)
def close_search():
textPad.tag_remove("match", "1.0", END)
t.destroy()
t.protocol("WM_DELETE_WINDOW", close_search)
def mypopup(event):
# global editmenu
editmenu.tk_popup(event.x_root, event.y_root)
def search(needle, cssnstv, textPad, t, e):
textPad.tag_remove("match", "1.0", END)
count = 0
if needle:
pos = "1.0"
while True:
pos = textPad.search(needle, pos, nocase=cssnstv, stopindex=END)
if not pos:
break
lastpos = pos + str(len(needle))
textPad.tag_add("match", pos, lastpos)
count += 1
pos = lastpos
textPad.tag_config('match', fg='yellow', bg="green")
e.focus_set()
t.title(str(count) + "個被匹配")
top = Tk()
top.title("記事本")
top.geometry("600x400+100+50")
menubar = Menu(top)
# 檔案功能
filemenu = Menu(top)
filemenu.add_command(label="新建", accelerator="Ctrl+N", command=mynew)
filemenu.add_command(label="打開", accelerator="Ctrl+O", command=myopen)
filemenu.add_command(label="保存", accelerator="Ctrl+S", command=mysave)
filemenu.add_command(label="另存為", accelerator="Ctrl+shift+s", command=mysaveas)
menubar.add_cascade(label="檔案", menu=filemenu)
# 編輯功能
editmenu = Menu(top)
editmenu.add_command(label="撤銷", accelerator="Ctrl+Z", command=undo)
editmenu.add_command(label="重做", accelerator="Ctrl+Y", command=redo)
editmenu.add_separator()
editmenu.add_command(label="剪切", accelerator="Ctrl+X", command=cut)
editmenu.add_command(label="復制", accelerator="Ctrl+C", command=copy)
editmenu.add_command(label="粘貼", accelerator="Ctrl+V", command=paste)
editmenu.add_separator()
editmenu.add_command(label="查找", accelerator="Ctrl+F", command=find)
editmenu.add_command(label="全選", accelerator="Ctrl+A", command=select_all)
menubar.add_cascade(label="編輯", menu=editmenu)
# 關于 功能
aboutmenu = Menu(top)
aboutmenu.add_command(label="作者", command=author)
aboutmenu.add_command(label="著作權", command=power)
menubar.add_cascade(label="關于", menu=aboutmenu)
top['menu'] = menubar
# shortcutbar = Frame(top, height=25, bg='light sea green')
# shortcutbar.pack(expand=NO, fill=X)
# Inlabe = Label(top, width=2, bg='antique white')
# Inlabe.pack(side=LEFT, anchor='nw', fill=Y)
textPad = Text(top, undo=True)
textPad.pack(expand=YES, fill=BOTH)
scroll = Scrollbar(textPad)
textPad.config(yscrollcommand=scroll.set)
scroll.config(command=textPad.yview)
scroll.pack(side=RIGHT, fill=Y)
# 熱鍵系結
textPad.bind("<Control-N>", mynew)
textPad.bind("<Control-n>", mynew)
textPad.bind("<Control-O>", myopen)
textPad.bind("<Control-o>", myopen)
textPad.bind("<Control-S>", mysave)
textPad.bind("<Control-s>", mysave)
textPad.bind("<Control-A>", select_all)
textPad.bind("<Control-a>", select_all)
textPad.bind("<Control-F>", find)
textPad.bind("<Control-f>", find)
textPad.bind("<Button-3>", mypopup)
top.mainloop()
3、登錄和注冊
1. 案例介紹
本例設計一個用戶登錄和注冊模塊，使用 Tkinter 框架構建界面，主要用到畫布、文本框、按鈕等組件，涉及知識點：Python Tkinter 界面編程、pickle 資料存盤，本例實作了基本的用戶登錄和注冊互動界面，并提供用戶資訊存盤和驗證，
pickle 是 python 語言的一個標準模塊，安裝 python 后已包含 pickle 庫，不需要單獨再安裝，pickle 模塊實作了基本的資料序列化和反序列化，通過 pickle 模塊的序列化操作能夠將程式中運行的物件資訊保存到檔案中去，永久存盤；通過 pickle 模塊的反序列化操作，能夠從檔案中創建上一次程式保存的物件，
本例難度為中級，適合具有 Python 基礎和 Tkinter 組件編程知識的用戶學習，
2. 示例效果
3. 示例原始碼
import tkinter as tk
import pickle
import tkinter.messagebox
from PIL import Image, ImageTk
# 設定視窗---最開始的母體視窗
window = tk.Tk() # 建立一個視窗
window.title('歡迎登錄')
window.geometry('450x300') # 視窗大小為300x200
# 畫布
canvas = tk.Canvas(window, height=200, width=900)
# 加載圖片
im = Image.open("images/01.png")
image_file = ImageTk.PhotoImage(im)
# image_file = tk.PhotoImage(file='images/01.gif')
image = canvas.create_image(100, 40, anchor='nw', image=image_file)
canvas.pack(side='top')
# 兩個文字標簽，用戶名和密碼兩個部分
tk.Label(window, text='用戶名').place(x=100, y=150)
tk.Label(window, text='密 碼').place(x=100, y=190)
var_usr_name = tk.StringVar() # 講文本框的內容，定義為字串型別
var_usr_name.set('amoxiang@163.com') # 設定默認值
var_usr_pwd = tk.StringVar()
# 第一個輸入框-用來輸入用戶名的，
# textvariable 獲取文本框的內容
entry_usr_name = tk.Entry(window, textvariable=var_usr_name)
entry_usr_name.place(x=160, y=150)
# 第二個輸入框-用來輸入密碼的，
entry_usr_pwd = tk.Entry(window, textvariable=var_usr_pwd, show='*')
entry_usr_pwd.place(x=160, y=190)
def usr_login():
usr_name = var_usr_name.get()
usr_pwd = var_usr_pwd.get()
try:
with open('usrs_info.pickle', 'rb') as usr_file:
usrs_info = pickle.load(usr_file)
except FileNotFoundError:
with open('usrs_info.pickle', 'wb') as usr_file:
usrs_info = {'admin': 'admin'}
pickle.dump(usrs_info, usr_file)
if usr_name in usrs_info:
if usr_pwd == usrs_info[usr_name]:
tk.messagebox.showinfo(
title='歡迎光臨', message=usr_name + '： 請進入個人首頁，查看最新資訊')
else:
tk.messagebox.showinfo(message='錯誤提示：密碼不對，請重試')
else:
is_sign_up = tk.messagebox.askyesno('提示', '你還沒有注冊，請先注冊')
print(is_sign_up)
if is_sign_up:
usr_sign_up()
# 注冊按鈕
def usr_sign_up():
def sign_to_Mofan_Python():
np = new_pwd.get()
npf = new_pwd_confirm.get()
nn = new_name.get()
# 上面是獲取資料，下面是查看一下是否重復注冊過
with open('usrs_info.pickle', 'rb') as usr_file:
exist_usr_info = pickle.load(usr_file)
if np != npf:
tk.messagebox.showerror('錯誤提示', '密碼和確認密碼必須一樣')
elif nn in exist_usr_info:
tk.messagebox.showerror('錯誤提示', '用戶名早就注冊了！')
else:
exist_usr_info[nn] = np
with open('usrs_info.pickle', 'wb') as usr_file:
pickle.dump(exist_usr_info, usr_file)
tk.messagebox.showinfo('歡迎', '你已經成功注冊了')
window_sign_up.destroy()
# 點擊注冊之后，會彈出這個視窗界面，
window_sign_up = tk.Toplevel(window)
window_sign_up.title('歡迎注冊')
window_sign_up.geometry('360x200') # 中間是x，而不是*號
# 用戶名框--這里輸入用戶名框，
new_name = tk.StringVar()
new_name.set('amoxiang@163.com') # 設定的是默認值
tk.Label(window_sign_up, text='用戶名').place(x=10, y=10)
entry_new_name = tk.Entry(window_sign_up, textvariable=new_name)
entry_new_name.place(x=100, y=10)
# 新密碼框--這里輸入注冊時候的密碼
new_pwd = tk.StringVar()
tk.Label(window_sign_up, text='密 碼').place(x=10, y=50)
entry_usr_pwd = tk.Entry(window_sign_up, textvariable=new_pwd, show='*')
entry_usr_pwd.place(x=100, y=50)
# 密碼確認框
new_pwd_confirm = tk.StringVar()
tk.Label(window_sign_up, text='確認密碼').place(x=10, y=90)
entry_usr_pwd_confirm = tk.Entry(
window_sign_up, textvariable=new_pwd_confirm, show='*')
entry_usr_pwd_confirm.place(x=100, y=90)
btn_confirm_sign_up = tk.Button(
window_sign_up, text=' 注 冊 ', command=sign_to_Mofan_Python)
btn_confirm_sign_up.place(x=120, y=130)
# 創建注冊和登錄按鈕
btn_login = tk.Button(window, text=' 登 錄 ', command=usr_login)
btn_login.place(x=150, y=230) # 用place來處理按鈕的位置資訊，
btn_sign_up = tk.Button(window, text=' 注 冊 ', command=usr_sign_up)
btn_sign_up.place(x=250, y=230)
window.mainloop()
二、游戲開發
1、2048
1. 游戲簡介
2048 是一款比較流行的數字游戲，游戲規則：每次可按上、下、左、右方向鍵滑動數字，每滑動一次，所有數字都會往滑動方向靠攏，同時在空白位置隨機出現一個數字，相同數字在靠攏時會相加，不斷疊加最終拼出 2048 這個數字算成功，
2048 最早于 2014年3月20日發行，原版 2048 首先在 GitHub 上發布，原作者是 Gabriele Cirulli，后被移植到各個平臺，
本例難度為初級，適合具有 Python 基礎和 Pygame 編程知識的用戶學習，
2. 設計原理
這個游戲的本質是二維串列，就以 4*4 的二位串列來分析關鍵的邏輯以及實作，二維串列如下圖：
所有的操作都是對這個二維串列的資料的操作，分為上下左右四個方向，先說向左的方向(如圖)，
向左操作的結果如下圖；當向左的方向是，所有的資料沿著水平方向向左跑，
水平說明操作的是二維串列的一行，而垂直操作的則是二位串列的一列，這樣就可以將二維串列的操作變成遍歷后對一維串列的操作，向左說明資料的優先考慮的位置是從左開始的，這樣就確定了一維串列的遍歷開始的位置，
上面第 2 個圖共四行，每一個行都能得到一個串列，
list1：[0,0,2,0]
list2：[0,4,2,0]
list3：[0,0,4,4]
list4：[2,0,2,0]
這樣一來向左的方向就變成，從上到下獲得每一行的串列，方向向左，引數(row,left)，
其他的三個方向在開始的時候記住是怎樣獲得以為串列的，等操作完才放回去這樣就能實作了，
3. 示例效果
4. 示例原始碼
import random
import sys
import pygame
from pygame.locals import *
PIXEL = 150
SCORE_PIXEL = 100
SIZE = 4
# 地圖的類
class Map:
def __init__(self, size):
self.size = size
self.score = 0
self.map = [[0 for i in range(size)] for i in range(size)]
self.add()
self.add()
# 新增2或4，有1/4概率產生4
def add(self):
while True:
p = random.randint(0, self.size * self.size - 1)
if self.map[int(p / self.size)][int(p % self.size)] == 0:
x = random.randint(0, 3) > 0 and 2 or 4
self.map[int(p / self.size)][int(p % self.size)] = x
self.score += x
break
# 地圖向左靠攏，其他方向的靠攏可以通過適當旋轉實作，回傳地圖是否更新
def adjust(self):
changed = False
for a in self.map:
b = []
last = 0
for v in a:
if v != 0:
if v == last:
b.append(b.pop() << 1)
last = 0
else:
b.append(v)
last = v
b += [0] * (self.size - len(b))
for i in range(self.size):
if a[i] != b[i]:
changed = True
a[:] = b
return changed
# 逆時針旋轉地圖90度
def rotate90(self):
self.map = [[self.map[c][r]
for c in range(self.size)] for r in reversed(range(self.size))]
# 判斷游戲結束
def over(self):
for r in range(self.size):
for c in range(self.size):
if self.map[r][c] == 0:
return False
for r in range(self.size):
for c in range(self.size - 1):
if self.map[r][c] == self.map[r][c + 1]:
return False
for r in range(self.size - 1):
for c in range(self.size):
if self.map[r][c] == self.map[r + 1][c]:
return False
return True
def moveUp(self):
self.rotate90()
if self.adjust():
self.add()
self.rotate90()
self.rotate90()
self.rotate90()
def moveRight(self):
self.rotate90()
self.rotate90()
if self.adjust():
self.add()
self.rotate90()
self.rotate90()
def moveDown(self):
self.rotate90()
self.rotate90()
self.rotate90()
if self.adjust():
self.add()
self.rotate90()
def moveLeft(self):
if self.adjust():
self.add()
# 更新螢屏
def show(map):
for i in range(SIZE):
for j in range(SIZE):
# 背景顏色塊
screen.blit(map.map[i][j] == 0 and block[(i + j) % 2]
or block[2 + (i + j) % 2], (PIXEL * j, PIXEL * i))
# 數值顯示
if map.map[i][j] != 0:
map_text = map_font.render(
str(map.map[i][j]), True, (106, 90, 205))
text_rect = map_text.get_rect()
text_rect.center = (PIXEL * j + PIXEL / 2,
PIXEL * i + PIXEL / 2)
screen.blit(map_text, text_rect)
# 分數顯示
screen.blit(score_block, (0, PIXEL * SIZE))
score_text = score_font.render((map.over(
) and "Game over with score " or "Score: ") + str(map.score), True, (106, 90, 205))
score_rect = score_text.get_rect()
score_rect.center = (PIXEL * SIZE / 2, PIXEL * SIZE + SCORE_PIXEL / 2)
screen.blit(score_text, score_rect)
pygame.display.update()
map = Map(SIZE)
pygame.init()
screen = pygame.display.set_mode((PIXEL * SIZE, PIXEL * SIZE + SCORE_PIXEL))
pygame.display.set_caption("2048")
block = [pygame.Surface((PIXEL, PIXEL)) for i in range(4)]
# 設定顏色
block[0].fill((152, 251, 152))
block[1].fill((240, 255, 255))
block[2].fill((0, 255, 127))
block[3].fill((225, 255, 255))
score_block = pygame.Surface((PIXEL * SIZE, SCORE_PIXEL))
score_block.fill((245, 245, 245))
# 設定字體
map_font = pygame.font.Font(None, int(PIXEL * 2 / 3))
score_font = pygame.font.Font(None, int(SCORE_PIXEL * 2 / 3))
clock = pygame.time.Clock()
show(map)
while not map.over():
# 12為實驗引數
clock.tick(12)
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
# 接收玩家操作
pressed_keys = pygame.key.get_pressed()
if pressed_keys[K_w] or pressed_keys[K_UP]:
map.moveUp()
elif pressed_keys[K_s] or pressed_keys[K_DOWN]:
map.moveDown()
elif pressed_keys[K_a] or pressed_keys[K_LEFT]:
map.moveLeft()
elif pressed_keys[K_d] or pressed_keys[K_RIGHT]:
map.moveRight()
show(map)
# 游戲結束
pygame.time.delay(3000)
2、貪吃蛇
1. 案例介紹
貪吃蛇是一款經典的益智游戲，簡單又耐玩，該游戲通過控制蛇頭方向吃蛋，從而使得蛇變得越來越長，
通過上下左右方向鍵控制蛇的方向，尋找吃的東西，每吃一口就能得到一定的積分，而且蛇的身子會越吃越長，身子越長玩的難度就越大，不能碰墻，不能咬到自己的身體，更不能咬自己的尾巴，等到了一定的分數，就能過關，然后繼續玩下一關，
本例難度為中級，適合具有 Python 基礎和 Pygame 編程知識的用戶學習，
2. 設計要點
游戲是基于 PyGame 框架制作的，程式核心邏輯如下：
游戲界面解析度是 640*480，蛇和食物都是由 1 個或多個 20*20 像素的正方形塊兒(為了方便，下文用點表示 20*20 像素的正方形塊兒) 組成，這樣共有 32*24 個點，使用 pygame.draw.rect 來繪制每一個點；
初始化時蛇的長度是 3，食物是 1 個點，蛇初始的移動的方向是右，用一個陣列代表蛇，陣列的每個元素是蛇每個點的坐標，因此陣列的第一個坐標是蛇尾，最后一個坐標是蛇頭；游戲開始后，根據蛇的當前移動方向，將蛇運動方向的前方的那個點 append 到蛇陣列的末位，再把蛇尾去掉，蛇的坐標陣列就相當于往前挪了一位；如果蛇吃到了食物，即蛇頭的坐標等于食物的坐標，那么在第 2 點中蛇尾就不用去掉，就產生了蛇長度增加的效果；食物被吃掉后，隨機在空的位置(不能與蛇的身體重合) 再生成一個；通過 PyGame 的 event 監控按鍵，改變蛇的方向，例如當蛇向右時，下一次改變方向只能向上或者向下；當蛇撞上自身或墻壁，游戲結束，蛇頭裝上自身，那么蛇坐標陣列里就有和舌頭坐標重復的資料，撞上墻壁則是蛇頭坐標超過了邊界，都很好判斷；其他細節：做了個開始的歡迎界面；食物的顏色隨機生成；吃到實物的時候有聲音提示等，
3. 示例效果
4. 示例原始碼
import pygame
from os import path
from sys import exit
from time import sleep
from random import choice
from itertools import product
from pygame.locals import QUIT, KEYDOWN
def direction_check(moving_direction, change_direction):
directions = [['up', 'down'], ['left', 'right']]
if moving_direction in directions[0] and change_direction in directions[1]:
return change_direction
elif moving_direction in directions[1] and change_direction in directions[0]:
return change_direction
return moving_direction
class Snake:
colors = list(product([0, 64, 128, 192, 255], repeat=3))[1:-1]
def __init__(self):
self.map = {(x, y): 0 for x in range(32) for y in range(24)}
self.body = [[100, 100], [120, 100], [140, 100]]
self.head = [140, 100]
self.food = []
self.food_color = []
self.moving_direction = 'right'
self.speed = 4
self.generate_food()
self.game_started = False
def check_game_status(self):
if self.body.count(self.head) > 1:
return True
if self.head[0] < 0 or self.head[0] > 620 or self.head[1] < 0 or self.head[1] > 460:
return True
return False
def move_head(self):
moves = {
'right': (20, 0),
'up': (0, -20),
'down': (0, 20),
'left': (-20, 0)
}
step = moves[self.moving_direction]
self.head[0] += step[0]
self.head[1] += step[1]
def generate_food(self):
self.speed = len(
self.body) // 16 if len(self.body) // 16 > 4 else self.speed
for seg in self.body:
x, y = seg
self.map[x // 20, y // 20] = 1
empty_pos = [pos for pos in self.map.keys() if not self.map[pos]]
result = choice(empty_pos)
self.food_color = list(choice(self.colors))
self.food = [result[0] * 20, result[1] * 20]
def main():
key_direction_dict = {
119: 'up', # W
115: 'down', # S
97: 'left', # A
100: 'right', # D
273: 'up', # UP
274: 'down', # DOWN
276: 'left', # LEFT
275: 'right', # RIGHT
}
fps_clock = pygame.time.Clock()
pygame.init()
pygame.mixer.init()
snake = Snake()
sound = False
if path.exists('eat.wav'):
sound_wav = pygame.mixer.Sound("eat.wav")
sound = True
title_font = pygame.font.SysFont('simsunnsimsun', 32)
welcome_words = title_font.render(
'貪吃蛇', True, (0, 0, 0), (255, 255, 255))
tips_font = pygame.font.SysFont('simsunnsimsun', 20)
start_game_words = tips_font.render(
'點擊開始', True, (0, 0, 0), (255, 255, 255))
close_game_words = tips_font.render(
'按ESC退出', True, (0, 0, 0), (255, 255, 255))
gameover_words = title_font.render(
'游戲結束', True, (205, 92, 92), (255, 255, 255))
win_words = title_font.render(
'蛇很長了，你贏了！', True, (0, 0, 205), (255, 255, 255))
screen = pygame.display.set_mode((640, 480), 0, 32)
pygame.display.set_caption('貪吃蛇')
new_direction = snake.moving_direction
while 1:
for event in pygame.event.get():
if event.type == QUIT:
exit()
elif event.type == KEYDOWN:
if event.key == 27:
exit()
if snake.game_started and event.key in key_direction_dict:
direction = key_direction_dict[event.key]
new_direction = direction_check(
snake.moving_direction, direction)
elif (not snake.game_started) and event.type == pygame.MOUSEBUTTONDOWN:
x, y = pygame.mouse.get_pos()
if 213 <= x <= 422 and 304 <= y <= 342:
snake.game_started = True
screen.fill((255, 255, 255))
if snake.game_started:
snake.moving_direction = new_direction # 在這里賦值，而不是在event事件的回圈中賦值，避免按鍵太快
snake.move_head()
snake.body.append(snake.head[:])
if snake.head == snake.food:
if sound:
sound_wav.play()
snake.generate_food()
else:
snake.body.pop(0)
for seg in snake.body:
pygame.draw.rect(screen, [0, 0, 0], [
seg[0], seg[1], 20, 20], 0)
pygame.draw.rect(screen, snake.food_color, [
snake.food[0], snake.food[1], 20, 20], 0)
if snake.check_game_status():
screen.blit(gameover_words, (241, 310))
pygame.display.update()
snake = Snake()
new_direction = snake.moving_direction
sleep(3)
elif len(snake.body) == 512:
screen.blit(win_words, (33, 210))
pygame.display.update()
snake = Snake()
new_direction = snake.moving_direction
sleep(3)
else:
screen.blit(welcome_words, (240, 150))
screen.blit(start_game_words, (246, 310))
screen.blit(close_game_words, (246, 350))
pygame.display.update()
fps_clock.tick(snake.speed)
if __name__ == '__main__':
main()
3、俄羅斯方塊
1. 案例介紹
俄羅斯方塊是由 4 個小方塊組成不同形狀的板塊，隨機從螢屏上方落下，按方向鍵調整板塊的位置和方向，在底部拼出完整的一行或幾行，這些完整的橫潭訓消失，給新落下來的板塊騰出空間，并獲得分數獎勵，沒有被消除掉的方塊不斷堆積，一旦堆到頂端，便告輸，游戲結束，
本例難度為高級，適合具有 Python 進階和 Pygame 編程技巧的用戶學習，
2. 設計要點
邊框――由 15*25 個空格組成，方塊就落在這里面，
盒子――組成方塊的其中小方塊，是組成方塊的基本單元，
方塊――從邊框頂掉下的東西，游戲者可以翻轉和改變位置，每個方塊由 4 個盒子組成，
形狀――不同型別的方塊，這里形狀的名字被叫做 T, S, Z ,J, L, I , O，如下圖所示：
模版――用一個串列存放形狀被翻轉后的所有可能樣式，全部存放在變數里，變數名字如 S or J，
著陸――當一個方塊到達邊框的底部或接觸到在其他的盒子話，就說這個方塊著陸了，那樣的話，另一個方塊就會開始下落，
3. 示例效果
4. 示例原始碼
import pygame
import random
import os
pygame.init()
GRID_WIDTH = 20
GRID_NUM_WIDTH = 15
GRID_NUM_HEIGHT = 25
WIDTH, HEIGHT = GRID_WIDTH * GRID_NUM_WIDTH, GRID_WIDTH * GRID_NUM_HEIGHT
SIDE_WIDTH = 200
SCREEN_WIDTH = WIDTH + SIDE_WIDTH
WHITE = (0xff, 0xff, 0xff)
BLACK = (0, 0, 0)
LINE_COLOR = (0x33, 0x33, 0x33)
CUBE_COLORS = [
(0xcc, 0x99, 0x99), (0xff, 0xff, 0x99), (0x66, 0x66, 0x99),
(0x99, 0x00, 0x66), (0xff, 0xcc, 0x00), (0xcc, 0x00, 0x33),
(0xff, 0x00, 0x33), (0x00, 0x66, 0x99), (0xff, 0xff, 0x33),
(0x99, 0x00, 0x33), (0xcc, 0xff, 0x66), (0xff, 0x99, 0x00)
]
screen = pygame.display.set_mode((SCREEN_WIDTH, HEIGHT))
pygame.display.set_caption("俄羅斯方塊")
clock = pygame.time.Clock()
FPS = 30
score = 0
level = 1
screen_color_matrix = [[None] * GRID_NUM_WIDTH for i in range(GRID_NUM_HEIGHT)]
# 設定游戲的根目錄為當前檔案夾
base_folder = os.path.dirname(__file__)
def show_text(surf, text, size, x, y, color=WHITE):
font_name = os.path.join(base_folder, 'font/font.ttc')
font = pygame.font.Font(font_name, size)
text_surface = font.render(text, True, color)
text_rect = text_surface.get_rect()
text_rect.midtop = (x, y)
surf.blit(text_surface, text_rect)
class CubeShape(object):
SHAPES = ['I', 'J', 'L', 'O', 'S', 'T', 'Z']
I = [[(0, -1), (0, 0), (0, 1), (0, 2)],
[(-1, 0), (0, 0), (1, 0), (2, 0)]]
J = [[(-2, 0), (-1, 0), (0, 0), (0, -1)],
[(-1, 0), (0, 0), (0, 1), (0, 2)],
[(0, 1), (0, 0), (1, 0), (2, 0)],
[(0, -2), (0, -1), (0, 0), (1, 0)]]
L = [[(-2, 0), (-1, 0), (0, 0), (0, 1)],
[(1, 0), (0, 0), (0, 1), (0, 2)],
[(0, -1), (0, 0), (1, 0), (2, 0)],
[(0, -2), (0, -1), (0, 0), (-1, 0)]]
O = [[(0, 0), (0, 1), (1, 0), (1, 1)]]
S = [[(-1, 0), (0, 0), (0, 1), (1, 1)],
[(1, -1), (1, 0), (0, 0), (0, 1)]]
T = [[(0, -1), (0, 0), (0, 1), (-1, 0)],
[(-1, 0), (0, 0), (1, 0), (0, 1)],
[(0, -1), (0, 0), (0, 1), (1, 0)],
[(-1, 0), (0, 0), (1, 0), (0, -1)]]
Z = [[(0, -1), (0, 0), (1, 0), (1, 1)],
[(-1, 0), (0, 0), (0, -1), (1, -1)]]
SHAPES_WITH_DIR = {
'I': I, 'J': J, 'L': L, 'O': O, 'S': S, 'T': T, 'Z': Z
}
def __init__(self):
self.shape = self.SHAPES[random.randint(0, len(self.SHAPES) - 1)]
# 骨牌所在的行列
self.center = (2, GRID_NUM_WIDTH // 2)
self.dir = random.randint(0, len(self.SHAPES_WITH_DIR[self.shape]) - 1)
self.color = CUBE_COLORS[random.randint(0, len(CUBE_COLORS) - 1)]
def get_all_gridpos(self, center=None):
curr_shape = self.SHAPES_WITH_DIR[self.shape][self.dir]
if center is None:
center = [self.center[0], self.center[1]]
return [(cube[0] + center[0], cube[1] + center[1])
for cube in curr_shape]
def conflict(self, center):
for cube in self.get_all_gridpos(center):
# 超出螢屏之外，說明不合法
if cube[0] < 0 or cube[1] < 0 or cube[0] >= GRID_NUM_HEIGHT or \
cube[1] >= GRID_NUM_WIDTH:
return True
# 不為None，說明之前已經有小方塊存在了，也不合法
if screen_color_matrix[cube[0]][cube[1]] is not None:
return True
return False
def rotate(self):
new_dir = self.dir + 1
new_dir %= len(self.SHAPES_WITH_DIR[self.shape])
old_dir = self.dir
self.dir = new_dir
if self.conflict(self.center):
self.dir = old_dir
return False
def down(self):
# import pdb; pdb.set_trace()
center = (self.center[0] + 1, self.center[1])
if self.conflict(center):
return False
self.center = center
return True
def left(self):
center = (self.center[0], self.center[1] - 1)
if self.conflict(center):
return False
self.center = center
return True
def right(self):
center = (self.center[0], self.center[1] + 1)
if self.conflict(center):
return False
self.center = center
return True
def draw(self):
for cube in self.get_all_gridpos():
pygame.draw.rect(screen, self.color,
(cube[1] * GRID_WIDTH, cube[0] * GRID_WIDTH,
GRID_WIDTH, GRID_WIDTH))
pygame.draw.rect(screen, WHITE,
(cube[1] * GRID_WIDTH, cube[0] * GRID_WIDTH,
GRID_WIDTH, GRID_WIDTH),
1)
def draw_grids():
for i in range(GRID_NUM_WIDTH):
pygame.draw.line(screen, LINE_COLOR,
(i * GRID_WIDTH, 0), (i * GRID_WIDTH, HEIGHT))
for i in range(GRID_NUM_HEIGHT):
pygame.draw.line(screen, LINE_COLOR,
(0, i * GRID_WIDTH), (WIDTH, i * GRID_WIDTH))
pygame.draw.line(screen, WHITE,
(GRID_WIDTH * GRID_NUM_WIDTH, 0),
(GRID_WIDTH * GRID_NUM_WIDTH, GRID_WIDTH * GRID_NUM_HEIGHT))
def draw_matrix():
for i, row in zip(range(GRID_NUM_HEIGHT), screen_color_matrix):
for j, color in zip(range(GRID_NUM_WIDTH), row):
if color is not None:
pygame.draw.rect(screen, color,
(j * GRID_WIDTH, i * GRID_WIDTH,
GRID_WIDTH, GRID_WIDTH))
pygame.draw.rect(screen, WHITE,
(j * GRID_WIDTH, i * GRID_WIDTH,
GRID_WIDTH, GRID_WIDTH), 2)
def draw_score():
show_text(screen, u'得分：{}'.format(score), 20, WIDTH + SIDE_WIDTH // 2, 100)
def remove_full_line():
global screen_color_matrix
global score
global level
new_matrix = [[None] * GRID_NUM_WIDTH for i in range(GRID_NUM_HEIGHT)]
index = GRID_NUM_HEIGHT - 1
n_full_line = 0
for i in range(GRID_NUM_HEIGHT - 1, -1, -1):
is_full = True
for j in range(GRID_NUM_WIDTH):
if screen_color_matrix[i][j] is None:
is_full = False
continue
if not is_full:
new_matrix[index] = screen_color_matrix[i]
index -= 1
else:
n_full_line += 1
score += n_full_line
level = score // 20 + 1
screen_color_matrix = new_matrix
def show_welcome(screen):
show_text(screen, u'俄羅斯方塊', 30, WIDTH / 2, HEIGHT / 2)
show_text(screen, u'按任意鍵開始游戲', 20, WIDTH / 2, HEIGHT / 2 + 50)
running = True
gameover = True
counter = 0
live_cube = None
while running:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if gameover:
gameover = False
live_cube = CubeShape()
break
if event.key == pygame.K_LEFT:
live_cube.left()
elif event.key == pygame.K_RIGHT:
live_cube.right()
elif event.key == pygame.K_DOWN:
live_cube.down()
elif event.key == pygame.K_UP:
live_cube.rotate()
elif event.key == pygame.K_SPACE:
while live_cube.down() == True:
pass
remove_full_line()
# level 是為了方便游戲的難度，level 越高 FPS // level 的值越小
# 這樣螢屏重繪的就越快，難度就越大
if gameover is False and counter % (FPS // level) == 0:
# down 表示下移骨牌，回傳False表示下移不成功，可能超過了螢屏或者和之前固定的
# 小方塊沖突了
if live_cube.down() == False:
for cube in live_cube.get_all_gridpos():
screen_color_matrix[cube[0]][cube[1]] = live_cube.color
live_cube = CubeShape()
if live_cube.conflict(live_cube.center):
gameover = True
score = 0
live_cube = None
screen_color_matrix = [[None] * GRID_NUM_WIDTH for i in range(GRID_NUM_HEIGHT)]
# 消除滿行
remove_full_line()
counter += 1
# 更新螢屏
screen.fill(BLACK)
draw_grids()
draw_matrix()
draw_score()
if live_cube is not None:
live_cube.draw()
if gameover:
show_welcome(screen)
pygame.display.update()
4、連連看
1. 案例介紹
連連看是一款曾經非常流行的小游戲，游戲規則：
- 點擊選中兩個相同的方塊，
- 兩個選中的方塊之間連接線的折點不超過兩個(接線由X軸和Y軸的平行線組成)，
- 每找出一對，它們就會自動消失，
- 連線不能從尚未消失的圖案上經過，
- 把所有的圖案全部消除即可獲得勝利，
2. 設計思路
- 生成成對的圖片元素，
- 將圖片元素打亂排布，
- 定義什么才算
相連(兩張圖片的連線不多于3跟直線，或者說轉角不超過2個)， - 實作
相連判斷演算法， - 消除圖片元素并判斷是否消除完畢，
3. 示例效果
4. 示例原始碼
from tkinter import *
from tkinter.messagebox import *
from threading import Timer
import time
import random
class Point:
# 點類
def __init__(self, x, y):
self.x = x
self.y = y
# --------------------------------------
'''
判斷選中的兩個方塊是否可以消除
'''
def IsLink(p1, p2):
if lineCheck(p1, p2):
return True
if OneCornerLink(p1, p2): # 一個轉彎（折點）的聯通方式
return True
if TwoCornerLink(p1, p2): # 兩個轉彎（折點）的聯通方式
return True
return False
# ---------------------------
def IsSame(p1, p2):
if map[p1.x][p1.y] == map[p2.x][p2.y]:
print("clicked at IsSame")
return True
return False
def callback(event): # 滑鼠左鍵事件代碼
global Select_first, p1, p2
global firstSelectRectId, SecondSelectRectId
# print ("clicked at", event.x, event.y,turn)
x = (event.x) // 40 # 換算棋盤坐標
y = (event.y) // 40
print("clicked at", x, y)
if map[x][y] == " ":
showinfo(title="提示", message="此處無方塊")
else:
if Select_first == False:
p1 = Point(x, y)
# 畫選定（x1,y1)處的框線
firstSelectRectId = cv.create_rectangle(x * 40, y * 40, x * 40 + 40, y * 40 + 40, width=2, outline="blue")
Select_first = True
else:
p2 = Point(x, y)
# 判斷第二次點擊的方塊是否已被第一次點擊選取，如果是則回傳，
if (p1.x == p2.x) and (p1.y == p2.y):
return
# 畫選定（x2,y2)處的框線
print('第二次點擊的方塊', x, y)
# SecondSelectRectId=cv.create_rectangle(100,20,x*40+40,y*40+40,width=2,outline="yellow")
SecondSelectRectId = cv.create_rectangle(x * 40, y * 40, x * 40 + 40, y * 40 + 40, width=2,
outline="yellow")
print('第二次點擊的方塊', SecondSelectRectId)
cv.pack()
# 判斷是否連通
if IsSame(p1, p2) and IsLink(p1, p2):
print('連通', x, y)
Select_first = False
# 畫選中方塊之間連接線
drawLinkLine(p1, p2)
# clearTwoBlock()
# time.sleep(0.6)
# clearFlag=True
t = Timer(timer_interval, delayrun) # 定時函式
t.start()
else: # 重新選定第一個方塊
# 清除第一個選定框線
cv.delete(firstSelectRectId)
cv.delete(SecondSelectRectId)
# print('清除第一個選定框線')
# firstSelectRectId=SecondSelectRectId
# p1=Point(x,y) #設定重新選定第一個方塊的坐標
Select_first = False
timer_interval = 0.3 # 0.3秒
# --------------------------------------
def delayrun():
clearTwoBlock() # 清除連線及方塊
def clearTwoBlock(): # 清除連線及方塊
# 延時0.1秒
# time.sleep(0.1)
# 清除第一個選定框線
cv.delete(firstSelectRectId)
# 清除第2個選定框線
cv.delete(SecondSelectRectId)
# 清空記錄方塊的值
map[p1.x][p1.y] = " "
cv.delete(image_map[p1.x][p1.y])
map[p2.x][p2.y] = " "
cv.delete(image_map[p2.x][p2.y])
Select_first = False
undrawConnectLine() # 清除選中方塊之間連接線
def drawQiPan(): # 畫棋盤
for i in range(0, 15):
cv.create_line(20, 20 + 40 * i, 580, 20 + 40 * i, width=2)
for i in range(0, 15):
cv.create_line(20 + 40 * i, 20, 20 + 40 * i, 580, width=2)
cv.pack()
def print_map(): # 輸出map地圖
global image_map
for x in range(0, Width): # 0--14
for y in range(0, Height): # 0--14
if (map[x][y] != ' '):
img1 = imgs[int(map[x][y])]
id = cv.create_image((x * 40 + 20, y * 40 + 20), image=img1)
image_map[x][y] = id
cv.pack()
for y in range(0, Height): # 0--14
for x in range(0, Width): # 0--14
print(map[x][y], end=' ')
print(",", y)
'''
* 同行同列情況消除方法 原理：如果兩個相同的被消除元素之間的 空格數
spaceCount等于他們的（行/列差-1）則 兩者可以聯通消除
* x代表列，y代表行
* param p1 第一個保存上次選中點坐標的點物件
* param p2 第二個保存上次選中點坐標的點物件
'''
# 直接連通
def lineCheck(p1, p2):
absDistance = 0
spaceCount = 0
if (p1.x == p2.x or p1.y == p2.y): # 同行同列的情況嗎？
print("同行同列的情況------")
# 同列的情況
if (p1.x == p2.x and p1.y != p2.y):
print("同列的情況")
# 絕對距離(中間隔著的空格數)
absDistance = abs(p1.y - p2.y) - 1
# 正負值
if p1.y - p2.y > 0:
zf = -1
else:
zf = 1
for i in range(1, absDistance + 1):
if (map[p1.x][p1.y + i * zf] == " "):
# 空格數加1
spaceCount += 1
else:
break; # 遇到阻礙就不用再探測了
# 同行的情況
elif (p1.y == p2.y and p1.x != p2.x):
print(" 同行的情況")
absDistance = abs(p1.x - p2.x) - 1
# 正負值
if p1.x - p2.x > 0:
zf = -1
else:
zf = 1
for i in range(1, absDistance + 1):
if (map[p1.x + i * zf][p1.y] == " "):
# 空格數加1
spaceCount += 1
else:
break; # 遇到阻礙就不用再探測了
if (spaceCount == absDistance):
# 可聯通
print(absDistance, spaceCount)
print("行/列可直接聯通")
return True
else:
print("行/列不能消除！")
return False
else:
# 不是同行同列的情況所以直接回傳false
return False;
# --------------------------------------
# 第二種，直角連通
'''
直角連接，即X,Y坐標都不同的，可以用這個方法嘗試連接
param first:選中的第一個點
param second:選中的第二個點
'''
def OneCornerLink(p1, p2):
# 第一個直角檢查點，如果這里為空則賦予相同值供檢查
checkP = Point(p1.x, p2.y)
# 第二個直角檢查點，如果這里為空則賦予相同值供檢查
checkP2 = Point(p2.x, p1.y);
# 第一個直角點檢測
if (map[checkP.x][checkP.y] == " "):
if (lineCheck(p1, checkP) and lineCheck(checkP, p2)):
linePointStack.append(checkP)
print("直角消除ok", checkP.x, checkP.y)
return True
# 第二個直角點檢測
if (map[checkP2.x][checkP2.y] == " "):
if (lineCheck(p1, checkP2) and lineCheck(checkP2, p2)):
linePointStack.append(checkP2)
print("直角消除ok", checkP2.x, checkP2.y)
return True
print("不能直角消除")
return False;
# -----------------------------------------
'''
#第三種，雙直角連通
雙直角聯通判定可分兩步走：
1. 在p1點周圍4個方向尋找空格checkP
2. 呼叫OneCornerLink(checkP, p2)
3. 即遍歷 p1 4 個方向的空格，使之成為 checkP,然后呼叫 OneCornerLink(checkP,
p2)判定是否為真，如果為真則可以雙直角連同，否則當所有的空格都遍歷完而沒有找
到一個checkP使OneCornerLink(checkP, p2)為真，則兩點不能連同
具體代碼：
雙直角連接方法
@param p1 第一個點
@param p2 第二個點
'''
def TwoCornerLink(p1, p2):
checkP = Point(p1.x, p1.y)
# 四向探測開始
for i in range(0, 4):
checkP.x = p1.x
checkP.y = p1.y
# 向下
if (i == 3):
checkP.y += 1
while ((checkP.y < Height) and map[checkP.x][checkP.y] == " "):
linePointStack.append(checkP)
if (OneCornerLink(checkP, p2)):
print("下探測OK")
return True
else:
linePointStack.pop()
checkP.y += 1
print("ssss", checkP.y, Height - 1)
# 補充兩個折點都在游戲區域底側外部
if checkP.y == Height: # 出了底部，則僅需判斷p2能否也達到底部邊界
z = Point(p2.x, Height - 1) # 底部邊界點
if lineCheck(z, p2): # 兩個折點在區域外部的底側
linePointStack.append(Point(p1.x, Height))
linePointStack.append(Point(p2.x, Height))
print("下探測到游戲區域外部OK")
return True
# 向右
elif (i == 2):
checkP.x += 1
while ((checkP.x < Width) and map[checkP.x][checkP.y] == " "):
linePointStack.append(checkP)
if (OneCornerLink(checkP, p2)):
print("右探測OK")
return True
else:
linePointStack.pop()
checkP.x += 1
# 補充兩個折點都在游戲區域右側外部
if checkP.x == Width: # 出了右側，則僅需判斷p2能否也達到右部邊界
z = Point(Width - 1, p2.y) # 右部邊界點
if lineCheck(z, p2): # 兩個折點在區域外部的底側
linePointStack.append(Point(Width, p1.y))
linePointStack.append(Point(Width, p2.y))
print("右探測到游戲區域外部OK")
return True
# 向左
elif (i == 1):
checkP.x -= 1
while ((checkP.x >= 0) and map[checkP.x][checkP.y] == " "):
linePointStack.append(checkP)
if (OneCornerLink(checkP, p2)):
print("左探測OK")
return True
else:
linePointStack.pop()
checkP.x -= 1
# 向上
elif (i == 0):
checkP.y -= 1
while ((checkP.y >= 0) and map[checkP.x][checkP.y] == " "):
linePointStack.append(checkP)
if (OneCornerLink(checkP, p2)):
print("上探測OK")
return True
else:
linePointStack.pop()
checkP.y -= 1
# 四個方向都尋完都沒找到適合的checkP點
print("兩直角連接沒找到適合的checkP點")
return False;
# ---------------------------
# 畫連接線
def drawLinkLine(p1, p2):
if (len(linePointStack) == 0):
Line_id.append(drawLine(p1, p2))
else:
print(linePointStack, len(linePointStack))
if (len(linePointStack) == 1):
z = linePointStack.pop()
print("一折連通點z", z.x, z.y)
Line_id.append(drawLine(p1, z))
Line_id.append(drawLine(p2, z))
if (len(linePointStack) == 2):
z1 = linePointStack.pop()
print("2折連通點z1", z1.x, z1.y)
Line_id.append(drawLine(p2, z1))
z2 = linePointStack.pop()
print("2折連通點z2", z2.x, z2.y)
Line_id.append(drawLine(z1, z2))
Line_id.append(drawLine(p1, z2))
# 洗掉連接線
def undrawConnectLine():
while len(Line_id) > 0:
idpop = Line_id.pop()
cv.delete(idpop)
def drawLine(p1, p2):
print("drawLine p1,p2", p1.x, p1.y, p2.x, p2.y)
# cv.create_line( 40+20, 40+20,200,200,width=5,fill='red')
id = cv.create_line(p1.x * 40 + 20, p1.y * 40 + 20, p2.x * 40 + 20, p2.y * 40 + 20, width=5, fill='red')
# cv.pack()
return id
# --------------------------------------
def create_map(): # 產生map地圖
global map
# 生成隨機地圖
# 將所有匹配成對的動物物種放進一個臨時的地圖中
tmpMap = []
m = (Width) * (Height) // 10
print('m=', m)
for x in range(0, m):
for i in range(0, 10): # 每種方塊有10個
tmpMap.append(x)
random.shuffle(tmpMap)
for x in range(0, Width): # 0--14
for y in range(0, Height): # 0--14
map[x][y] = tmpMap[x * Height + y]
# --------------------------------------
def find2Block(event): # 自動查找
global firstSelectRectId, SecondSelectRectId
m_nRoW = Height
m_nCol = Width
bFound = False;
# 第一個方塊從地圖的0位置開始
for i in range(0, m_nRoW * m_nCol):
# 找到則跳出回圈
if (bFound):
break
# 算出對應的虛擬行列位置
x1 = i % m_nCol
y1 = i // m_nCol
p1 = Point(x1, y1)
# 無圖案的方塊跳過
if (map[x1][y1] == ' '):
continue
# 第二個方塊從前一個方塊的后面開始
for j in range(i + 1, m_nRoW * m_nCol):
# 算出對應的虛擬行列位置
x2 = j % m_nCol
y2 = j // m_nCol
p2 = Point(x2, y2)
# 第二個方塊不為空 且與第一個方塊的動物相同
if (map[x2][y2] != ' ' and IsSame(p1, p2)):
# 判斷是否可以連通
if (IsLink(p1, p2)):
bFound = True
break
# 找到后自動消除
if (bFound): # p1（x1,y1）與p2（x2,y2）連通
print('找到后', p1.x, p1.y, p2.x, p2.y)
# 畫選定（x1,y1)處的框線
firstSelectRectId = cv.create_rectangle(x1 * 40, y1 * 40, x1 * 40 + 40, y1 * 40 + 40, width=2, outline="red")
# 畫選定（x2,y2)處的框線
secondSelectRectId = cv.create_rectangle(x2 * 40, y2 * 40, x2 * 40 + 40, y2 * 40 + 40, width=2, outline="red")
# t=Timer(timer_interval,delayrun)#定時函式
# t.start()
return bFound
# 游戲主邏輯
root = Tk()
root.title("Python連連看 ")
imgs = [PhotoImage(file='images\\bar_0' + str(i) + '.gif') for i in range(0, 10)] # 所有圖示圖案
Select_first = False # 是否已經選中第一塊
firstSelectRectId = -1 # 被選中第一塊地圖物件
SecondSelectRectId = -1 # 被選中第二塊地圖物件
clearFlag = False
linePointStack = []
Line_id = []
Height = 10
Width = 10
map = [[" " for y in range(Height)] for x in range(Width)]
image_map = [[" " for y in range(Height)] for x in range(Width)]
cv = Canvas(root, bg='green', width=440, height=440)
# drawQiPan( )
cv.bind("<Button-1>", callback) # 滑鼠左鍵事件
cv.bind("<Button-3>", find2Block) # 滑鼠右鍵事件
cv.pack()
create_map() # 產生map地圖
print_map() # 列印map地圖
root.mainloop()
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/280978.html
標籤：其他
上一篇：C語言實作：陣列：三子棋游戲