基于Python實現(xiàn)英語單詞小游戲
更新時間：2022年11月11日 14:10:46 作者：顧木子吖
這篇文章主要為大家詳細介紹了如何通過Python實現(xiàn)一個簡單的英語單詞小游戲，四級考滿分的學(xué)姐告訴你這樣學(xué)英語逢考必過，趕緊康康叭
導(dǎo)語
相信大家對于英語四級一點都不陌生了吧？
很多學(xué)校都是要求學(xué)生必須考過英語四級，不然就不能畢業(yè)。
一開始我抱著僥幸心理，心想上高中的時候英語不錯，四級應(yīng)該也很容易。不過成績出來我就傻眼了，沒有通過。然后我就制定了周密的學(xué)習(xí)計劃，開始有計劃地學(xué)習(xí)英語，等到第二次考試的時候終于通過啦。今天，小編給大家制作一款Python編程代碼版本的四級考試打字小游戲，邊玩兒游戲還能復(fù)習(xí)單詞還能保持學(xué)習(xí)的積極性，這款代碼游戲真的是考級姐妹的靈魂首先，讓我們開正式康康叭
一、敲代碼之前的小tips
僅個人觀點勿噴
四級之前，大家要很認真的備考啦，每天做做各種類型的四級題，可以量不多，但是會用心的做，做完之后都會認真的總結(jié)，就算那種不仔細的原因也會寫在錯題旁邊，借以提醒自己。每天這樣去做的原因就是保持題感，畢竟四級是一門考試，好多題還是有很多套路的，但只要持之以恒地去聯(lián)系，雖然套路深，鐵杵磨成針。
聽力方面：每次聽完并對過答案之后會繼續(xù)聽那一份聽力材料，因為第一次是泛聽，只需要抓住關(guān)鍵詞的信息成功get到答案就好，那么后面就要開始精聽，這一次我們的目標就是聽懂這個人到底在說什么，爭取聽懂每一句，好了，接下來，當我反復(fù)聽一句話卻怎么也聽不懂其中的某幾個詞的時候，那我就找到可以收入寶囊的法器了，然后你就把這幾個詞好好地在牛津字典里查一查，記在自己的收集本上，還要多多鞏固，因為這些詞語出現(xiàn)在考試中，從某種程度上來說就屬于高頻詞匯的。另外呢，在精聽的時候，我們要多多注意朗讀者說英語時的感覺，包括他的發(fā)音、語調(diào)，都很重要，所以也可以跟著他一起讀英語，在邊聽邊說的過程中，我們的耳朵對英語會更加地敏感。
閱讀方面：在就應(yīng)對四級考試的時候，刷題當然是不二選擇，前面已經(jīng)提到過四級套路深，所以考試之前，我每天大概會做一篇閱讀，設(shè)定時間是很重要的，這樣可以把握自己的考試節(jié)奏，不會太慌張。四級閱讀題，一般都會按照文章的順序來設(shè)計題目，一般情況下，四級閱讀題的內(nèi)容不會太少，信息量比較多，而我需要的又僅僅只是那幾條有用的信息。那么，首先就先看文章后面的問題，帶著問題去讀文章，會起到事半功倍的效果，也節(jié)省時間。做完一篇閱讀之后，需要認真總結(jié)錯誤原因，那么你錯的題就錯得很有意義，如果只是不停地做題，而不停下來反思原因，那做一萬道題也不如做一道題?？偨Y(jié)錯誤之后，同樣需要仔細查閱陌生的單詞，不斷積累，方可在英語閱讀中做到游刃有余。
寫作翻譯方面：毋庸置疑，它們都是一種全面輸出的體現(xiàn)，因此，更需要扎實地進行練習(xí)。我
在四級考試之前，會準備一個本子，認真寫好每一篇作文或是翻譯，字跡工整，仔細構(gòu)思，寫完以后和優(yōu)秀范文對比，學(xué)習(xí)它的用法，在平時就養(yǎng)成好的習(xí)慣，到了考場上才會更加從容。我覺得，寫得越多，就會寫得越好，優(yōu)美而實用的句型才會信手拈來?？傊?，這同樣是個堅持的過程，但終究會破繭成蝶、妙筆生花的。
二、運行環(huán)境
小編使用的環(huán)境：Python3、Pycharm社區(qū)版、Pygame模塊。內(nèi)置模塊 你安裝 好python環(huán)
境就可以了。
模塊安裝：pip install -i https://pypi.douban.com/simple/ +pygame
三、素材（圖片等）
圖片多，裝不下，僅部分哈（懶.jpg）還有字體，音樂背景等等都沒展示了哈。
下面是提前準備的單詞，大家每天可以更新一下的哈如下幾百個是我準備的截圖部分。
四、代碼展示
1）主程序（英文打字小游戲主入口模塊）
# !/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Author: 顧木子吖
"""
import os
import sys
import time
import traceback
import Game_View
from Game_View import *
from Game_Sprite import *
def center_pos():
"""設(shè)置游戲窗口相對電腦屏幕居中"""
game_x = (Game_Info.SCREEN_X - Game_Info.SCREEN_RECT.width) / 2
game_y = (Game_Info.SCREEN_Y - Game_Info.SCREEN_RECT.height) / 2
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (game_x, game_y)
def random_music():
"""隨機播放背景音樂"""
# 判斷是否是靜音模式
print(Game_View.GameStartWin.voice_flag())
try:
pygame.mixer.init()
pygame.mixer.music.load(random.choice(Game_Info.GAME_MUSICS))
pygame.mixer.music.play(loops=0)
except Exception as e:
print("無法加載音頻，請檢查電腦配置" + str(e))
print(traceback.format_exc())
if not Game_View.GameStartWin.voice_flag():
pygame.mixer_music.set_volume(0)
def parser_words() -> dict:
"""
解析英語單詞
:return {"eng_word": val, "cn_comment": val}
"""
english_words = []
word_contents = open(Game_Info.GAME_WORD_TEXT, encoding="gbk")
for value in word_contents:
value = value.lstrip()
word_list = value.split(" ")
words = [i for i in word_list if i != '']
if len(words) >= 2:
# 把解析好的單詞和注釋封裝到字典中，然后加入列表
english_words.append(
{"eng_word": words[0], "cn_comment": words[1]})
return english_words
class TypingGame(object):
"""打字游戲主類"""
spell_ok = False # 用于標識單詞拼寫成功
game_pause_flag = False # 游戲暫停標志
game_over_flag = False # 游戲結(jié)束標志
game_quit_flag = False # 游戲退出標志
game_total_blood = Game_Info.GAME_BLOOD_RECT.width # 游戲總能量(血條)
# 游戲等級對照字典
game_level_dict = {
1: {"word_fall_speed": 0.3, "level_text": u"簡單", "level_color": "green"},
2: {"word_fall_speed": 0.5, "level_text": u"上手", "level_color": "blue"},
3: {"word_fall_speed": 1.0, "level_text": u"中等", "level_color": "orange"},
4: {"word_fall_speed": 1.5, "level_text": u"困難", "level_color": "red"},
5: {"word_fall_speed": 2.0, "level_text": u"魔鬼", "level_color": "purple"}
}
@staticmethod
def game_init():
"""游戲初始化"""
# 初始化游戲字體
pygame.font.init()
# 設(shè)置游戲標題和圖標
pygame.display.set_caption(Game_Info.GAME_NAME)
pygame.display.set_icon(pygame.image.load(Game_Info.GAME_ICON_32))
@staticmethod
def set_game_event():
"""設(shè)置游戲事件"""
# 設(shè)置創(chuàng)建單詞的定時器
pygame.time.set_timer(Game_Info.CREATE_WORD_EVENT, Game_Info.CREATE_WORD_INTERVAL)
# 設(shè)置游戲音樂結(jié)束事件
try:
pygame.mixer.music.set_endevent(Game_Info.MUSIC_END_EVENT)
except Exception as e:
print("無法設(shè)置音樂結(jié)束事件\t" + str(e))
print(traceback.format_exc())
def __init__(self):
self.words = parser_words()
self.game_conf = GameConfig() # 游戲配置信息
self.game_default_voice = 20 # 游戲默認音量
self.use_time = 0 # 記錄游戲使用的時間
self.total_score = 0 # 記錄游戲拼寫成功了多少個單詞
self.word_content = "" # 鍵盤輸入的單詞
self.backspace_count = 0 # 回刪鍵按下的次數(shù)
# 預(yù)先創(chuàng)建動畫對象
self.animates = [Animation(self) for _ in range(5)]
# 游戲初始血條值
self.game_blood = int(self.game_conf.game_init_blood) * 10
self.game_clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(Game_Info.SCREEN_RECT.size)
self.game_init()
self.set_game_event() # 設(shè)置游戲事件
self.__create_sprite() # 創(chuàng)建游戲精靈
def __create_sprite(self):
"""創(chuàng)建精靈和精靈組"""
# 背景精靈
back_sprite = ImageSprite(Game_Info.GAME_BACKGROUND)
# 根據(jù)游戲屏幕的大小適配背景圖(可能會導(dǎo)致背景圖變形)
back_sprite.transform_scale(
back_sprite.image,
(Game_Info.SCREEN_RECT.width, Game_Info.SCREEN_RECT.height)
)
self.back_group = pygame.sprite.Group(back_sprite)
# 英文單詞顯示框
input_rect_sprite = ImageSprite(Game_Info.INPUT_BACKGROUND)
# 縮放圖片
input_rect_sprite.transform_scale(
input_rect_sprite.image,
(Game_Info.INPUT_RECT_WIDTH, Game_Info.INPUT_RECT_HEIGHT)
)
# 水平居中顯示
input_rect_sprite.hor_center(Game_Info.SCREEN_RECT)
self.input_rect_group = pygame.sprite.Group(input_rect_sprite)
# 創(chuàng)建“游戲設(shè)置”圖片
self.game_set_sprite = ImageSprite(Game_Info.GAME_SET_PINK)
set_x = Game_Info.SCREEN_RECT.width - self.game_set_sprite.rect.width - 10
set_y = Game_Info.SCREEN_RECT.height - self.game_set_sprite.rect.height - 10
self.game_set_sprite.set_pos(set_x, set_y)
self.game_set_sprite_group = pygame.sprite.Group(self.game_set_sprite)
# 拼寫的單詞
spell_word_sprite = SpellSprite(
"",
size=26,
color=pygame.color.Color(self.game_conf.spell_ok_color)
)
spell_word_sprite.hor_center(Game_Info.SCREEN_RECT)
spell_word_sprite.set_pos(spell_word_sprite.rect.x, 40)
self.spell_word_group = pygame.sprite.Group(spell_word_sprite)
# 創(chuàng)建單詞精靈組
self.word_group = pygame.sprite.Group()
self.__random_generate_word(Game_Info.GENERATE_WORD_NUM)
# 創(chuàng)建顯示游戲時間精靈
time_sprite = TextSprite(text="Time: 0", size=28, color=Game_Info.BLUE)
time_sprite.set_pos(5, 0)
self.time_group = pygame.sprite.Group(time_sprite)
# 游戲分數(shù)
self.score_sprite = TextSprite("Score: 0", size=30, color=Game_Info.BLUE)
self.score_sprite.set_pos(Game_Info.SCREEN_RECT.width - self.score_sprite.rect.width - 20, 3)
self.score_group = pygame.sprite.Group(self.score_sprite)
# 游戲結(jié)束精靈(組)
self.__game_over_sprite()
def __game_over_sprite(self):
"""創(chuàng)建游戲結(jié)束的精靈(組)"""
self.game_over_group = pygame.sprite.Group()
game_over_sprite = TextSprite("Game Over", 100, Game_Info.BLUE)
game_over_sprite.rect.y = (Game_Info.SCREEN_RECT.height - game_over_sprite.rect.height - 400) / 2
game_over_sprite.hor_center(Game_Info.SCREEN_RECT)
game_level_text = self.game_level_dict[int(self.game_conf.game_level)]["level_text"]
game_level_color = pygame.color.Color(self.game_level_dict[int(self.game_conf.game_level)]["level_color"])
self.game_level_sprite = TextSprite(u"游戲等級: " + game_level_text, 50, game_level_color)
self.game_level_sprite.rect.y = game_over_sprite.rect.y + 100 + 50
self.game_level_sprite.hor_center(Game_Info.SCREEN_RECT)
self.game_score_sprite = TextSprite(u"游戲分數(shù): ", 50, Game_Info.BLUE)
self.game_score_sprite.rect.y = game_over_sprite.rect.y + 200 + 50
self.game_score_sprite.hor_center(Game_Info.SCREEN_RECT)
self.highest_sprite = TextSprite(u"歷史最高: ", 50, Game_Info.BLUE)
self.highest_sprite.rect.y = game_over_sprite.rect.y + 300 + 50
self.highest_sprite.hor_center(Game_Info.SCREEN_RECT)
self.quit_sprite = TextSprite(u"退出", 50, Game_Info.BLUE)
self.quit_sprite.set_pos(
game_over_sprite.rect.x - self.quit_sprite.rect.width,
game_over_sprite.rect.y + 400 + 10
)
self.reset_sprite = TextSprite(u"重 玩", 50, Game_Info.BLUE)
self.reset_sprite.set_pos(
game_over_sprite.rect.x + game_over_sprite.rect.width,
game_over_sprite.rect.y + 400 + 10
)
self.game_over_group.add(
game_over_sprite,
self.game_level_sprite,
self.game_score_sprite,
self.highest_sprite,
self.quit_sprite, self.reset_sprite
)
def __update_sprite(self):
"""更新精靈"""
self.back_group.update()
self.back_group.draw(self.screen)
self.game_set_sprite_group.update()
self.game_set_sprite_group.draw(self.screen)
self.input_rect_group.update()
self.input_rect_group.draw(self.screen)
# 計算游戲使用時間
if not self.game_pause_flag and not self.game_over_flag:
self.use_time += 0.1
display_time = "Time: " + str(self.use_time / 6)
self.time_group.update(display_time[:12])
self.time_group.draw(self.screen)
self.score_sprite.set_pos(Game_Info.SCREEN_RECT.width - self.score_sprite.rect.width - 20, 3)
self.score_group.update("Score: " + str(self.total_score))
self.score_group.draw(self.screen)
# 判斷是否游戲結(jié)束
if self.game_over_flag:
self.__game_over()
game_level_text = self.game_level_dict[int(self.game_conf.game_level)]["level_text"]
self.game_level_sprite.update("游戲等級: " + str(game_level_text))
self.game_over_group.draw(self.screen)
else:
if not self.game_pause_flag:
self.word_group.update(self)
self.word_group.draw(self.screen)
spell_ok_color = pygame.Color(self.game_conf.spell_ok_color)
self.spell_word_group.update(self.word_content, spell_ok_color)
self.spell_word_group.draw(self.screen)
# 更新游戲能量條
if 0 <= self.game_blood <= self.game_total_blood:
self.__draw_game_blood()
# 單詞精靈拼寫成功動畫
for animate in self.animates:
if animate.visible:
animate.draw()
def start_game(self):
"""打字游戲開啟"""
# 隨機播放背景音樂
random_music()
# 利用多線程完成游戲持續(xù)掉血
drop_blood_t = threading.Thread(target=self.__drop_blood)
drop_blood_t.start()
while True:
# 是否設(shè)置成靜音
if not Game_View.GameStartWin.voice_flag():
pygame.mixer_music.set_volume(0)
else:
pygame.mixer_music.set_volume(self.game_default_voice)
# 設(shè)置游戲刷新幀率
self.game_clock.tick(Game_Info.FRAME_PRE_SEC)
# 判斷游戲結(jié)束
if self.game_blood < 0:
TypingGame.game_over_flag = True
else:
self.__animate_action()
self.__check_spell_word()
self.__update_sprite()
self.__event_handle()
pygame.display.update()
def __event_handle(self):
"""游戲事件監(jiān)聽"""
# 遍歷所有事件
for event in pygame.event.get():
try:
if pygame.mixer.music.get_endevent() == Game_Info.MUSIC_END_EVENT and \
not pygame.mixer.music.get_busy():
# 如果music播放結(jié)束且沒有音樂在播放就隨機下一首
print("下一首")
random_music()
except:
pass
# 如果單擊關(guān)閉窗口，則退出
if event.type == pygame.QUIT and not self.game_pause_flag:
pygame.quit()
TypingGame.game_quit_flag = True
sys.exit()
# 創(chuàng)建單詞事件
elif event.type == Game_Info.CREATE_WORD_EVENT:
if not self.game_over_flag and not self.game_pause_flag:
# 游戲結(jié)束或者暫停就停止生成單詞了
self.__random_generate_word(word_num=3)
# 鼠標移動事件
elif event.type == pygame.MOUSEMOTION:
x, y = event.pos # 獲取屏幕坐標位置
if self.__is_on_set(x, y):
self.game_set_sprite.image = pygame.image.load(Game_Info.GAME_SET_BLUE)
else:
self.game_set_sprite.image = pygame.image.load(Game_Info.GAME_SET_PINK)
# 游戲結(jié)束鼠標懸浮在確定按鈕上變色
if self.quit_sprite.rect.x <= x <= self.quit_sprite.rect.x + self.quit_sprite.rect.width and \
self.quit_sprite.rect.y <= y <= self.quit_sprite.rect.y + self.quit_sprite.rect.height:
self.quit_sprite.color = Game_Info.PINK
self.quit_sprite.update(self.quit_sprite.text)
else:
self.quit_sprite.color = Game_Info.BLUE
self.quit_sprite.update(self.quit_sprite.text)
# 游戲結(jié)束鼠標懸浮在重玩按鈕上變色
if self.reset_sprite.rect.x <= x <= self.reset_sprite.rect.x + self.reset_sprite.rect.width and \
self.reset_sprite.rect.y <= y <= self.reset_sprite.rect.y + self.reset_sprite.rect.height:
self.reset_sprite.color = Game_Info.PINK
self.reset_sprite.update(self.reset_sprite.text)
else:
self.reset_sprite.color = Game_Info.BLUE
self.reset_sprite.update(self.reset_sprite.text)
# 鼠標點擊事件
elif event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos # 獲取屏幕坐標位置
# 點擊游戲設(shè)置
if self.__is_on_set(x, y):
# 判斷游戲是否暫停
if not self.game_pause_flag:
TypingGame.game_pause_flag = True
# 游戲結(jié)束鼠標點擊退出按鈕
if self.quit_sprite.rect.x <= x <= self.quit_sprite.rect.x + self.quit_sprite.rect.width and \
self.quit_sprite.rect.y <= y <= self.quit_sprite.rect.y + self.quit_sprite.rect.height:
pygame.quit()
TypingGame.game_quit_flag = True
sys.exit()
# 游戲結(jié)束鼠標點擊重玩按鈕
if self.reset_sprite.rect.x <= x <= self.reset_sprite.rect.x + self.reset_sprite.rect.width and \
self.reset_sprite.rect.y <= y <= self.reset_sprite.rect.y + self.reset_sprite.rect.height:
self.__reset_game()
# 鍵盤事件
elif event.type == pygame.KEYDOWN and not self.game_over_flag and not self.game_pause_flag:
# 英文單引號的ASCII值是39、-是45、.是46
# print(event.key)
if (pygame.K_a <= event.key <= pygame.K_z) or event.key in (39, 45, 46):
if self.spell_ok:
# 如果單詞拼寫成功再按下鍵盤時清空內(nèi)容
self.word_content = ""
self.spell_ok = False
# 控制單詞長度
if len(self.word_content) < 40:
# 記錄鍵盤輸入的字符
self.word_content += pygame.key.name(event.key)
else:
print("Word to long")
print(self.word_content)
if event.key == pygame.K_BACKSPACE:
self.__delete_words()
elif event.type == pygame.KEYUP:
self.backspace_count = 0
# 實現(xiàn)長按backspace連續(xù)回刪
# 使用鍵盤提供的方法獲取鍵盤按鍵 - 按鍵元組
keys_pressed = pygame.key.get_pressed()
# 判斷元組中對應(yīng)的按鍵索引值 1
if keys_pressed[pygame.K_BACKSPACE]:
self.backspace_count += 1
if self.backspace_count > 20:
self.__delete_words()
def __is_on_set(self, x, y):
"""
檢查是否在設(shè)置圖片上
:param x,y 鼠標的位置
"""
img_set_x = self.game_set_sprite.rect.x
img_set_y = self.game_set_sprite.rect.y
img_set_w = self.game_set_sprite.rect.width
img_set_h = self.game_set_sprite.rect.height
if (img_set_x <= x <= img_set_x + img_set_w) and \
(img_set_y <= y <= img_set_y + img_set_h):
return True
else:
return False
def __delete_words(self):
"""單詞回刪"""
if self.word_content != "":
self.word_content = self.word_content[:-1]
print(self.word_content + "---" + str(len(self.word_content)))
if self.spell_ok:
# 如果單詞拼寫成功再按下鍵盤回刪鍵時清空內(nèi)容
self.word_content = ""
self.spell_ok = False
def __random_generate_word(self, word_num=5):
"""
隨機生成單詞精靈
:param word_num:精靈數(shù)量 默認5
:return:
"""
count = 0
while len(self.word_group.sprites()) <= 30:
index = random.randint(0, len(self.words) - 1)
eng_word = self.words[index]["eng_word"]
cn_comment = self.words[index]["cn_comment"]
# print(eng_word + "----" + cn_comment)
word_sprite = WordSprite(
eng_word,
cn_comment,
speed=self.game_level_dict[int(self.game_conf.game_level)]['word_fall_speed'],
size=int(self.game_conf.word_size),
color=pygame.color.Color(str(self.game_conf.word_normal_color))
)
# 單詞位置隨機
word_sprite.random_pos()
# 檢查新單詞精靈是否與單詞精靈組中的精靈碰撞(重疊)
words = pygame.sprite.spritecollide(
word_sprite, self.word_group, False,
pygame.sprite.collide_circle_ratio(1)
)
# 碰撞(釋放內(nèi)存重新隨機生成單詞精靈)
if len(words) > 0:
word_sprite.kill()
continue
else:
self.word_group.add(word_sprite)
count += 1
if count >= word_num:
break
def __game_over(self):
"""游戲結(jié)束"""
self.game_score_sprite.hor_center(Game_Info.SCREEN_RECT)
self.highest_sprite.hor_center(Game_Info.SCREEN_RECT)
self.game_score_sprite.update(u"游戲分數(shù): %s" % self.total_score)
"""
history_score_dict
{
'level_0': "{'score': None,'use_time': None,'create_time': None}",
'level_1': "{'score': None,'use_time': None,'create_time': None}",
'level_2': "{...}",
...
}
"""
# 顯示歷史最高
highest_score_str = self.game_conf.history_score_dict['level_' + str(int(self.game_conf.game_level))]
highest_score_dict = eval(highest_score_str)
highest_score = highest_score_dict['score']
if highest_score is None or int(self.total_score) > int(highest_score):
# 更新歷史記錄
highest_score = self.total_score
highest_score_dict['score'] = str(self.total_score)
highest_score_dict['use_time'] = str(self.use_time)[:5] + 's'
highest_score_dict['create_time'] = str(time.strftime("%Y-%m-%d %H:%M"))
self.game_conf.set_highest_score(str(highest_score_dict), 'level_' + str(int(self.game_conf.game_level)))
else:
highest_score = highest_score_dict['score']
self.highest_sprite.update(u"歷史最高: %s" % highest_score)
def __check_spell_word(self):
"""檢查拼寫單詞是否正確"""
word_sprites = self.word_group.sprites()
for word_sprite in word_sprites:
# 判斷單詞內(nèi)容是否相同
if self.word_content.lower() == word_sprite.text.lower():
# 判斷血條是否超過總血條數(shù)
if self.game_blood < self.game_total_blood:
self.game_blood += 10
self.total_score += 1
self.spell_ok = True
self.word_content = self.word_content + "\t" + str(word_sprite.cn_comment)
word_sprite.kill()
# 從預(yù)先創(chuàng)建完畢的動畫中取出一個動畫對象
for animate in self.animates:
if not animate.visible:
# 設(shè)置動畫位置
animate.set_pos(word_sprite.rect.x, word_sprite.rect.y)
# 動畫對象狀態(tài)設(shè)置為True
animate.visible = True
break
def __draw_game_blood(self, color=Game_Info.GREEN):
"""繪制游戲能量"""
if self.game_blood <= 3 * 10:
color = Game_Info.RED
if self.game_blood >= 25 * 10:
color = Game_Info.BLUE
if self.game_total_blood-30 <= self.game_blood <= self.game_total_blood:
color = Game_Info.ORANGE
# 繪制游戲能量
pygame.draw.rect(
self.screen, color,
pygame.Rect(
Game_Info.GAME_BLOOD_RECT.x + 2,
Game_Info.GAME_BLOOD_RECT.y,
self.game_blood,
Game_Info.GAME_BLOOD_RECT.height
)
)
pygame.draw.rect(self.screen, Game_Info.WHITE, Game_Info.GAME_BLOOD_RECT, 2)
def __drop_blood(self):
"""持續(xù)掉血"""
# if not self.game_pause_flag:
# if int(self.use_time) > 0 and (int(self.use_time) / 6) % 2 == 0:
# self.game_blood -= 0.5
while not self.game_over_flag:
if self.game_pause_flag:
self.game_clock.tick(60)
else:
# 根據(jù)不同游戲等級掉血
self.game_clock.tick(int(self.game_conf.game_level))
self.game_blood -= 1
def __animate_action(self):
"""開啟單詞拼寫成功動畫"""
for animate in self.animates:
if animate.visible:
animate.action()
def __reset_game(self):
"""游戲重玩"""
del self # 釋放內(nèi)存
pygame.quit()
pygame.init()
random_music()
TypingGame.game_over_flag = False
TypingGame.game_quit_flag = False
TypingGame().start_game()
def main():
center_pos()
# 啟動游戲開始界面
GameStartWin(title="Word Sprite").run()
if __name__ == '__main__':
main()2）游戲配置信息模塊
# !/usr/bin/env python
# -*- coding: utf-8 -*-
import ctypes
import pygame
import configparser
class GameConfig(object):
"""游戲配置文件類"""
GAME_INFO = "game_info" # 配置文件游戲信息結(jié)點名稱
GAME_STYLE = "game_style" # 配置文件游戲樣式結(jié)點名稱
GAME_SCORE = "game_score" # 配置文件游戲分數(shù)結(jié)點名稱
config_file_path = "resource/config.cfg" # 游戲配置文件路徑
# 把配置文件類設(shè)置成單例模式
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self):
self.author = None
self.game_name = None
self.version = None
self.e_mail = None
self.frame_pre_sec = None # 游戲幀率
self.word_size = None # 英文單詞的大小
self.word_normal_color = None # 單詞的正常顏色
self.spell_ok_color = None # 單詞拼寫成功的顏色
self.game_level = None # 游戲等級
self.game_init_blood = None # 游戲初始血量
self.history_score_dict = None # 游戲歷史記錄
self.__parser_config()
def __parser_config(self):
"""解析游戲配置文件"""
self.conf_parser = configparser.ConfigParser()
self.conf_parser.read(self.config_file_path, encoding='utf-8')
# 游戲開發(fā)者信息
self.author = self.conf_parser.get(self.GAME_INFO, 'author')
self.game_name = self.conf_parser.get(self.GAME_INFO, 'game_name')
self.version = self.conf_parser.get(self.GAME_INFO, 'version')
self.e_mail = self.conf_parser.get(self.GAME_INFO, 'e-mail')
# 游戲樣式信息
self.frame_pre_sec = self.conf_parser.get(self.GAME_STYLE, "frame_pre_sec")
self.word_size = self.conf_parser.get(self.GAME_STYLE, "word_size")
self.word_normal_color = self.conf_parser.get(self.GAME_STYLE, "word_normal_color")
self.spell_ok_color = self.conf_parser.get(self.GAME_STYLE, "spell_ok_color")
self.game_level = self.conf_parser.get(self.GAME_STYLE, "game_level")
self.game_init_blood = self.conf_parser.get(self.GAME_STYLE, "game_init_blood")
# {
# 'level_0': "{'score': None,'use_time': None,'create_time': None}",
# 'level_1': "{...}",
# }
# 歷史最高信息
self.history_score_dict = dict(self.conf_parser.items(self.GAME_SCORE))
def set_word_size(self, word_size):
"""設(shè)置單詞大小"""
self.word_size = word_size
self.conf_parser.set(self.GAME_STYLE, "word_size", str(word_size))
self.conf_parser.write(open(self.config_file_path, mode='w'))
def set_game_level(self, game_level):
"""設(shè)置游戲等級"""
self.game_level = game_level
self.conf_parser.set(self.GAME_STYLE, "game_level", str(game_level))
self.conf_parser.write(open(self.config_file_path, mode='w'))
def set_game_init_blood(self, game_init_blood):
"""設(shè)置游戲的初始血條"""
self.game_init_blood = game_init_blood
self.conf_parser.set(self.GAME_STYLE, "game_init_blood", str(game_init_blood))
self.conf_parser.write(open(self.config_file_path, mode='w'))
def set_word_normal_color(self, word_normal_color):
"""設(shè)置單詞的正常顏色"""
self.word_normal_color = word_normal_color
self.conf_parser.set(self.GAME_STYLE, "word_normal_color", str(word_normal_color))
self.conf_parser.write(open(self.config_file_path, mode='w'))
def set_spell_ok_color(self, spell_ok_color):
"""設(shè)置單詞拼寫成功后的顏色"""
self.spell_ok_color = spell_ok_color
self.conf_parser.set(self.GAME_STYLE, "spell_ok_color", str(spell_ok_color))
self.conf_parser.write(open(self.config_file_path, mode='w'))
def set_highest_score(self, score_dict, game_level):
"""更新歷史最高記錄"""
self.conf_parser.set(self.GAME_SCORE, str(game_level), str(score_dict))
self.conf_parser.write(open(self.config_file_path, mode='w'))
self.history_score_dict = dict(self.conf_parser.items(self.GAME_SCORE))
# 獲取系統(tǒng)屏幕分辨率(縮放比例后)
win_api = ctypes.windll.user32
SCREEN_X = win_api.GetSystemMetrics(0)
SCREEN_Y = win_api.GetSystemMetrics(1)
game_conf = GameConfig()
GAME_MUSICS = ["resource/music/bgm1.mp3", "resource/music/bgm2.mp3"]
GAME_NAME = game_conf.game_name
GAME_LEVEL = {'1': 0.3, '2': 0.5, '3': 1, '4': 1.5, '5': 2} # 游戲困難等級與單詞下落速度相互匹配字典
SCREEN_RECT = pygame.Rect(0, 0, SCREEN_X * 0.85, SCREEN_Y * 0.85) # 游戲窗口大小(電腦分辨率 * 0.85)
INPUT_RECT_WIDTH = 600
INPUT_RECT_HEIGHT = 100
GAME_BLOOD_RECT = pygame.Rect(SCREEN_RECT.width / 2 - 250, SCREEN_RECT.height - 26, 500, 25)
GAME_ICON = "resource/image/rabbit.ico"
GAME_ICON_32 = "resource/image/rabbit_32.png"
GAME_ICON_48 = "resource/image/rabbit_48.png"
VOICE_ICO = "resource/image/voice.png"
MUTE_ICO = "resource/image/mute.png"
GAME_BACKGROUND = "resource/image/game_bg.png"
GAME_OVER_BACKGROUND = "resource/image/game_over.png"
INPUT_BACKGROUND = "resource/image/input_bg.png"
GAME_SET_BLUE = "resource/image/set_blue.png"
GAME_SET_PINK = "resource/image/set_pink.png"
GAME_FONT = "resource/font/HUI.TTF" # 游戲字體
GAME_WORD_TEXT = "resource/en_word.txt" # 游戲單詞文本
# 單詞拼寫成功后的消失動畫
KILL_ANIMATION = ["resource/image/animation/" + str(img_num).zfill(3) + ".png" for img_num in range(8)]
FRAME_PRE_SEC = int(game_conf.frame_pre_sec) # 游戲的刷新幀率
WORD_SIZE = int(game_conf.word_size) # 單詞大小
WORD_FALL_SPEED = GAME_LEVEL[str(game_conf.game_level)] # 單詞下落速度
INIT_BLOOD = int(game_conf.game_init_blood) # 游戲初始血條
# 創(chuàng)建單詞的時間間隔(毫秒)
CREATE_WORD_INTERVAL = 1000 * 5
# 首次生成單詞的數(shù)量
GENERATE_WORD_NUM = 5
# 游戲單詞正常顏色和拼寫顏色
WORD_NORMAL_COLOR = str(game_conf.word_normal_color)
SPELL_OK_COLOR = str(game_conf.spell_ok_color)
WORD_COLOR = pygame.color.Color(WORD_NORMAL_COLOR)
WORD_SPELL_OK_COLOR = pygame.color.Color(SPELL_OK_COLOR)
# 字體顏色
RED = pygame.color.Color("RED")
YELLOW = pygame.color.Color("YELLOW")
BLUE = pygame.color.Color("#70f3ff")
GREEN = pygame.color.Color("GREEN")
WHITE = pygame.color.Color("WHITE")
ORANGE = pygame.color.Color("ORANGE")
PINK = pygame.color.Color("#ff4777")
# 創(chuàng)建單詞事件
CREATE_WORD_EVENT = pygame.USEREVENT
# 游戲結(jié)束事件
GAME_OVER_EVENT = pygame.USEREVENT + 1
# 游戲音樂結(jié)束事件
MUSIC_END_EVENT = pygame.USEREVENT + 2
def main():
game_conf1 = GameConfig()
game_conf2 = GameConfig()
game_conf1.word_size = 100
game_conf2.game_init_blood = 50
print(id(game_conf1))
print(id(game_conf2))
print(game_conf1.game_init_blood)
print(game_conf2.word_size)
socre_dict = game_conf.history_score_dict
print(dict(socre_dict))
print(eval(socre_dict['level_1']))
print(GAME_BLOOD_RECT)
# print(SCREEN_X, SCREEN_Y)
# print(SCREEN_RECT)
# print(SCREEN_RECT.size)
# print(game_conf.frame_pre_sec)
# print(game_conf.game_level)
# print(game_conf.word_size)
# print(game_conf.word_normal_color)
# print(game_conf.spell_ok_color)
# print(WORD_NORMAL_COLOR)
# print(SPELL_OK_COLOR)
# print(int(10.000000001))
# print(SCREEN_X, SCREEN_Y)
# print(SCREEN_RECT.size)
if __name__ == '__main__':
main()3）游戲視圖模塊
import Game_Info
import threading
import PySimpleGUI as sg
from Game_Info import GameConfig
from tkinter import colorchooser
from Game_Main import TypingGame
class BaseWin(object):
"""窗口父類"""
WIN_THEME = sg.theme('DarkBlue1')
text_color = 'white'
game_conf = GameConfig() # 游戲信息配置類
def __init__(self, title):
self.title = title
self.window = None
self.layout = list()
def close_win(self):
"""關(guān)閉窗口"""
if self.window is not None:
self.window.close()
class GameStartWin(BaseWin):
"""游戲開始窗口"""
_voice_flag = True
def __init__(self, title):
super().__init__(title)
self.__init_layout()
def __init_layout(self):
"""初始化窗口布局"""
if self._voice_flag:
voice_img = Game_Info.VOICE_ICO
else:
voice_img = Game_Info.MUTE_ICO
self.layout = [
[sg.Text(size=(70, 0)), sg.Image(filename=voice_img, key='voice_control', enable_events=True)],
[sg.Text(size=(10, 10)), sg.Text('Word Sprite', font=(u'宋體', 50)), sg.Text(size=(10, 10))],
[sg.Text(size=(23, 10)), sg.Button(u'開始游戲', font=(u'宋體', 30), key='start_game'), sg.Text(size=(23, 10))],
[sg.Text(size=(23, 5)), sg.Button(u'游戲設(shè)置', font=(u'宋體', 30), key='game_set'), sg.Text(size=(23, 5))],
[sg.Text(size=(23, 10)), sg.Button(u'歷史最高', font=(u'宋體', 30), key='show_score'), sg.Text(size=(23, 10))],
[
sg.Text(size=(70, 0)),
sg.Image(
filename=Game_Info.GAME_ICON_48,
key='game_ico',
enable_events=True
)
]
]
def run(self):
"""啟動游戲開始窗口"""
self.window = sg.Window(
title=self.title,
icon=Game_Info.GAME_ICON,
layout=self.layout
)
self.__event_handler()
def __event_handler(self):
"""窗口事件監(jiān)聽"""
while True:
event, value_dict = self.window.read(timeout=20)
print(event, value_dict)
# 靜音控制
if self._voice_flag:
self.window.find_element('voice_control').update(filename=Game_Info.VOICE_ICO)
else:
self.window.find_element('voice_control').update(filename=Game_Info.MUTE_ICO)
if event in (sg.WIN_CLOSED, 'Quit'):
break
elif event in 'voice_control':
self.voice_control()
elif event in 'game_ico':
self.author_win()
elif event in 'start_game':
print('開始游戲')
self.window.Hide()
TypingGame.game_over_flag = False
TypingGame.game_quit_flag = False
threading.Thread(target=self.start_game).start() # 利用線程開啟游戲防止窗口卡死
elif event in 'game_set' or TypingGame.game_pause_flag:
print('游戲設(shè)置')
self.window.Disable()
self.game_set()
elif event in 'show_score':
print('歷史最高')
self.window.Disable()
self.show_score()
elif TypingGame.game_quit_flag:
self.window.UnHide()
self.window.close()
def voice_control(self):
"""游戲靜音狀態(tài)控制"""
if self._voice_flag:
GameStartWin._voice_flag = False
self.window.find_element('voice_control').update(filename=Game_Info.MUTE_ICO)
else:
GameStartWin._voice_flag = True
self.window.find_element('voice_control').update(filename=Game_Info.VOICE_ICO)
def author_win(self):
"""游戲開發(fā)信息窗口"""
self.window.Disable()
game_conf = Game_Info.GameConfig()
show_text = '游戲作者: \t' + game_conf.author + '\n\n'\
'游戲名稱: \t' + game_conf.game_name + '\n\n'\
'游戲版本: \t' + game_conf.version + '\n\n'\
'作者郵箱: \t' + game_conf.e_mail + '\n'
sg.Popup(
show_text,
title=u'關(guān)于作者',
icon=Game_Info.GAME_ICON,
font=(u'宋體', 18),
custom_text=(u' ★ ', u' ? '),
button_color=('red', '#063288'),
line_width=50,
)
self.window.Enable()
def game_set(self):
"""游戲設(shè)置"""
GameSetWin(u"游戲配置", self).run()
def show_score(self):
"""查看歷史最高分"""
GameScoreWin(u'歷史最高', self).run()
@staticmethod
def start_game():
"""開始游戲"""
TypingGame().start_game()
@classmethod
def voice_flag(cls):
return cls._voice_flag
class GameExecuteWin(object):
"""游戲運行窗口"""
pass
class GameEndWin(object):
"""游戲結(jié)束窗口"""
def __init__(self):
pass
class GameSetWin(BaseWin):
"""游戲配置信息窗口"""
# 游戲等級對照字典
game_level_dict = {
1: {"game_level_num": 5, "game_level_text": u"簡單", "game_level_color": "green"},
2: {"game_level_num": 15, "game_level_text": u"上手", "game_level_color": "blue"},
3: {"game_level_num": 25, "game_level_text": u"中等", "game_level_color": "orange"},
4: {"game_level_num": 35, "game_level_text": u"困難", "game_level_color": "red"},
5: {"game_level_num": 50, "game_level_text": u"魔鬼", "game_level_color": "purple"}
}
def __init__(self, title, parent_win=None):
"""初始化游戲配置界面"""
super().__init__(title)
self.parent_win = parent_win
self.word_normal_color = self.game_conf.word_normal_color
self.spell_ok_color = self.game_conf.spell_ok_color
self.__init_layout()
def __init_layout(self):
game_level_num = self.game_level_dict[int(self.game_conf.game_level)]["game_level_num"]
game_level_text = self.game_level_dict[int(self.game_conf.game_level)]["game_level_text"]
game_level_color = self.game_level_dict[int(self.game_conf.game_level)]["game_level_color"]
self.layout = [
[
sg.Text(u'游戲難度等級:', text_color=self.text_color),
sg.Slider(
range=(1, 50), default_value=game_level_num,
size=(26, 18), orientation='h', key="game_level",
enable_events=True, disable_number_display=True,
),
sg.Button(
game_level_text, key='game_level_btn',
button_color=(self.text_color, game_level_color),
),
],
[
sg.Text(u'游戲字體大小:', text_color=self.text_color),
sg.Slider(
range=(15, 35), default_value=int(self.game_conf.word_size),
size=(26, 18), enable_events=True,
orientation='h', disable_number_display=True, key="word_size"
),
sg.Text(
str(self.game_conf.word_size), text_color=self.text_color, size=(3, 1),
font=("宋體", int(self.game_conf.word_size)),
key='word_size_num'
),
],
[
sg.Text(u'游戲初始血條:', text_color=self.text_color),
sg.Slider(
range=(5, 30), default_value=int(self.game_conf.game_init_blood),
size=(26, 18), orientation='h',
enable_events=True, disable_number_display=True, key='init_blood'
),
sg.Text(
str(self.game_conf.game_init_blood), size=(3, 1),
text_color=self.text_color, key='blood_num'
)
],
[
sg.Text(u'游戲靜音狀態(tài):', text_color=self.text_color),
sg.Radio(
' ', default=GameStartWin.voice_flag(), key='voice_open',
group_id=1, text_color=self.text_color, enable_events=True
),
sg.Image(filename=Game_Info.VOICE_ICO),
sg.Text(' ' * 5),
sg.Radio(
' ', default=not GameStartWin.voice_flag(), key='mute',
group_id=1, text_color=self.text_color, enable_events=True
),
sg.Image(filename=Game_Info.MUTE_ICO)
],
[
sg.Text(u'游戲字體顏色:', text_color=self.text_color),
sg.Text(
'', size=(17, 1),
background_color=self.game_conf.word_normal_color,
enable_events=True, key='word_normal_color'
),
sg.Text(
'HUI', key='word_color_test',
text_color=self.game_conf.word_normal_color,
),
sg.Button(u'顏色選擇', key='normal_ccb')
],
[
sg.Text(u'單詞拼寫顏色:', text_color=self.text_color),
sg.Text(
'', size=(17, 1),
background_color=self.game_conf.spell_ok_color,
enable_events=True, key='spell_ok_color'
),
sg.Text(
'HUI', key='spell_color_test',
text_color=self.game_conf.spell_ok_color,
),
sg.Button(u'顏色選擇', key='spell_ccb')
],
[
sg.Submit(u'暫時保存', key='temp_save', pad=((10, 350), (0, 0))),
sg.Button(u'永久保存', key='permanent')
]
]
def run(self):
"""開啟游戲設(shè)置界面"""
self.window = sg.Window(
title=self.title,
icon=Game_Info.GAME_ICON,
layout=self.layout,
font=("宋體", 18),
element_padding=(10, 30),
)
# 開啟事件監(jiān)聽
self.__event_handler()
@staticmethod
def color_callback(color=None):
"""顏色按鈕回調(diào)方法"""
return colorchooser.askcolor(color)
def __event_handler(self):
while True:
event, value_dict = self.window.read()
# print(event, value_dict)
if event in (None, 'Quit'):
break
elif event in ('voice_open', 'mute'):
if value_dict['voice_open']:
GameStartWin._voice_flag = True
else:
GameStartWin._voice_flag = False
elif event in 'game_level':
game_level = self.get_game_level(int(value_dict[event]))
game_level_text = self.game_level_dict[game_level]['game_level_text']
game_level_color = self.game_level_dict[game_level]['game_level_color']
self.window.find_element('game_level_btn').update(
game_level_text,
button_color=(self.text_color, game_level_color)
)
elif event in 'game_level_btn':
# 點擊按鈕切換游戲等級
game_level = self.get_game_level(int(value_dict['game_level']))
if game_level == 5:
game_level = 0
game_level_num = self.game_level_dict[game_level + 1]['game_level_num']
game_level_text = self.game_level_dict[game_level + 1]['game_level_text']
game_level_color = self.game_level_dict[game_level + 1]['game_level_color']
self.window.find_element('game_level').update(game_level_num)
self.window.find_element('game_level_btn').update(
game_level_text,
button_color=(self.text_color, game_level_color)
)
elif event in 'word_size':
word_size_num = value_dict[event]
self.window.find_element('word_size_num').update(int(word_size_num), font=(u'宋體', int(word_size_num)))
elif event in 'init_blood':
blood_num = int(value_dict[event])
self.window.find_element('blood_num').update(str(blood_num))
elif event in 'normal_ccb':
# 游戲單詞顏色選擇
self.window.Disable() # 讓游戲配置窗口不可用，不讓用戶亂點擊，防止多開
choose_colors = self.color_callback(self.game_conf.word_normal_color)
self.window.Enable() # 恢復(fù)游戲配置窗口
if None not in choose_colors:
self.window.find_element('word_normal_color').update(background_color=choose_colors[1])
self.window.find_element('word_color_test').update(text_color=choose_colors[1])
self.word_normal_color = choose_colors[1]
elif event in 'spell_ccb':
# 單詞拼寫顏色選擇
self.window.Disable() # 讓游戲配置窗口不可用，不讓用戶亂點擊，防止多開
choose_colors = self.color_callback(self.game_conf.spell_ok_color)
self.window.Enable() # 恢復(fù)游戲配置窗口
if None not in choose_colors:
self.window.find_element('spell_ok_color').update(background_color=choose_colors[1])
self.window.find_element('spell_color_test').update(text_color=choose_colors[1])
self.spell_ok_color = choose_colors[1]
elif event in ('temp_save', 'permanent'):
GameSetWin.SAVE_STATUS = True
game_level = self.get_game_level(int(value_dict['game_level']))
value_dict['game_level'] = game_level
value_dict['normal_ccb'] = self.word_normal_color
value_dict['spell_ccb'] = self.spell_ok_color
if event in 'temp_save':
self.temp_save(value_dict)
elif event in 'permanent':
self.permanent(value_dict)
break
self.window.close()
TypingGame.game_pause_flag = False
# 恢復(fù)父窗口可用
if self.parent_win is not None:
self.parent_win.window.Enable()
def temp_save(self, game_dict):
"""臨時保存游戲配置信息(臨時有效，重開還原)"""
"""
{
'game_level': 2,
'word_size': 26.0,
'init_blood': 20.0,
'voice_open': True,
'mute': False,
'normal_ccb': '#00ffff',
'spell_ccb': '#ff0000'
}
"""
self.game_conf.game_level = game_dict['game_level']
self.game_conf.word_size = game_dict['word_size']
self.game_conf.game_init_blood = game_dict['init_blood']
self.game_conf.word_normal_color = game_dict['normal_ccb']
self.game_conf.spell_ok_color = game_dict['spell_ccb']
def permanent(self, game_dict):
"""永久保存游戲配置信息(寫入配置文件)"""
# 修改配置文件
self.game_conf.set_game_level(game_dict['game_level'])
self.game_conf.set_word_size(int(game_dict['word_size']))
self.game_conf.set_game_init_blood(int(game_dict['init_blood']))
self.game_conf.set_word_normal_color(game_dict['normal_ccb'])
self.game_conf.set_spell_ok_color(game_dict['spell_ccb'])
@staticmethod
def get_game_level(data):
game_level = 1
if data <= 10:
game_level = 1
elif data <= 20:
game_level = 2
elif data <= 30:
game_level = 3
elif data <= 40:
game_level = 4
elif data <= 50:
game_level = 5
return game_level#
class GameScoreWin(BaseWin):
"""游戲歷史分數(shù)窗口"""
heads = [
'{:4}'.format(u'游戲等級'),
'{:4}'.format(u'最高分'),
'{:6}'.format(u'耗 時'),
'{:4}'.format(u'創(chuàng)建時間'),
]
levels = ['level_1', 'level_2', 'level_3', 'level_4', 'level_5']
def __init__(self, title, parent_win=None):
super().__init__(title)
self.parent_win = parent_win
self.__init_layout()
def __init_layout(self):
"""初始化窗口布局"""
score_dict = Game_Info.game_conf.history_score_dict # 游戲歷史記錄
level_0, level_1 = eval(score_dict[self.levels[0]]), eval(score_dict[self.levels[1]])
level_2, level_3 = eval(score_dict[self.levels[2]]), eval(score_dict[self.levels[3]])
level_4 = eval(score_dict[self.levels[4]])
header = [[sg.Text(h, pad=(31, 30)) for h in self.heads]]
body = [
[
sg.Button(u'簡單', button_color=('white', 'green')),
sg.Text('{:4}'.format(str(level_0['score']))),
sg.Text('{:6}'.format(str(level_0['use_time']))),
sg.Text('{:4}'.format(str(level_0['create_time'])))
],
[
sg.Button(u'上手', button_color=('white', 'blue')),
sg.Text('{:4}'.format(str(level_1['score']))),
sg.Text('{:6}'.format(str(level_1['use_time']))),
sg.Text('{:4}'.format(str(level_1['create_time'])))
],
[
sg.Button(u'中等', button_color=('white', 'orange')),
sg.Text('{:4}'.format(str(level_2['score']))),
sg.Text('{:6}'.format(str(level_2['use_time']))),
sg.Text('{:4}'.format(str(level_2['create_time'])))
],
[
sg.Button(u'困難', button_color=('white', 'red')),
sg.Text('{:4}'.format(str(level_3['score']))),
sg.Text('{:6}'.format(str(level_3['use_time']))),
sg.Text('{:4}'.format(str(level_3['create_time'])))
],
[
sg.Button(u'魔鬼', button_color=('white', 'purple')),
sg.Text('{:4}'.format(str(level_4['score']))),
sg.Text('{:6}'.format(str(level_4['use_time']))),
sg.Text('{:4}'.format(str(level_4['create_time'])))
]
]
self.layout = header + body
def run(self):
"""啟動游戲歷史分數(shù)窗口"""
self.window = sg.Window(
title=self.title,
icon=Game_Info.GAME_ICON,
layout=self.layout,
font=('宋體', 20),
element_padding=(46, 30)
)
self.__event_handler()
def __event_handler(self):
"""窗口事件監(jiān)聽"""
while True:
event, value_dict = self.window.read()
print(event, value_dict)
if event in (sg.WIN_CLOSED, 'Quit'):
self.parent_win.window.Enable()
break
self.window.close()
def main():
GameStartWin(title="Word Sprite").run()
if __name__ == '__main__':
main()4）PyGame游戲精靈模塊
import pygame
import random
import Game_Info
from Game_Info import GameConfig
class BaseSprite(pygame.sprite.Sprite):
"""游戲精靈基類"""
def __init__(self):
super().__init__()
self.image = None
self.rect = None
def set_pos(self, x, y):
"""設(shè)置精靈位置"""
self.rect.x = x
self.rect.y = y
def hor_center(self, screen_rect):
"""
水平居中顯示
:param screen_rect: 游戲屏幕大小
:return:
"""
x = screen_rect.width / 2 - self.rect.width / 2
self.set_pos(x, self.rect.y)
class ImageSprite(BaseSprite):
"""圖片精靈基類"""
def __init__(self, image):
super().__init__()
self.image = pygame.image.load(image)
self.rect = self.image.get_rect()
def transform_scale(self, image, size: tuple):
"""縮放圖片大小"""
self.image = pygame.transform.scale(image, size)
self.rect = self.image.get_rect()
class TextSprite(BaseSprite):
"""文字精靈基類"""
def __init__(self, text, size=Game_Info.WORD_SIZE, color=Game_Info.WHITE):
super().__init__()
self.text = text
self.size = size
self.color = color
# 創(chuàng)建字體
self.font = pygame.font.Font(Game_Info.GAME_FONT, self.size)
# 根據(jù)字體創(chuàng)建顯示對象(文字) render(self,text,antialias,color,background = None)
self.image = self.font.render(text, True, self.color)
self.rect = self.image.get_rect()
def update(self, display_text):
"""更新顯示的文字"""
self.text = display_text
rect_x = self.rect.x
rect_y = self.rect.y
self.image = self.font.render(self.text, True, self.color)
self.rect = self.image.get_rect()
self.rect.x = rect_x
self.rect.y = rect_y
class SpellSprite(TextSprite):
"""文字精靈基類"""
def __init__(self, text, size=Game_Info.WORD_SIZE, color=Game_Info.WORD_SPELL_OK_COLOR):
super().__init__(text, size, color)
def update(self, display_text, color):
"""更新拼寫的單詞"""
self.text = display_text
self.color = color
self.image = self.font.render(self.text, True, self.color)
self.rect = self.image.get_rect()
# 居中顯示
self.hor_center(Game_Info.SCREEN_RECT)
self.set_pos(self.rect.x, 40)
class WordSprite(TextSprite):
"""單詞精靈類"""
game_conf = GameConfig()
def __init__(self, text, cn_comment, speed: float, size=28, color=Game_Info.WORD_COLOR):
super().__init__(text, size, color)
self.speed = speed # 單詞下落的速度
self.cn_comment = cn_comment # 英文單詞的意思
self.y = float(self.rect.y) # 用小數(shù)存儲單詞降落的位置(方可設(shè)置成小數(shù))
def random_pos(self):
"""隨機位置"""
word_x = random.randint(0, Game_Info.SCREEN_RECT.width - self.rect.width)
word_y = random.randint(-50, 10)
self.rect.x = word_x
self.rect.y = word_y
self.y = float(self.rect.y)
def update(self, game):
"""更新單詞精靈"""
# 判斷游戲是否暫停
if game.game_pause_flag:
self.speed = 0
else:
self.y += self.speed
self.rect.y = self.y
# 超出游戲屏幕，刪除精靈
if self.rect.y >= Game_Info.SCREEN_RECT.height:
self.kill()
# 根據(jù)不同游戲等級掉血
game.game_blood -= int(self.game_conf.game_level) * 3
# 游戲配置信息改變，更新單詞
self.size = int(self.game_conf.word_size)
self.font = pygame.font.Font(Game_Info.GAME_FONT, self.size)
self.speed = game.game_level_dict[int(self.game_conf.game_level)]['word_fall_speed']
self.color = pygame.color.Color(self.game_conf.word_normal_color)
# 游戲分數(shù)是10的倍數(shù)單詞下落速度提升
if game.total_score > 0 and game.total_score % 100 == 0:
self.speed += 0.5
# 游戲血條在[45 - 50]區(qū)間單詞下落速度提升
if 45 * 10 <= game.game_blood <= 50 * 10:
self.speed += 1
# 拼寫的字母與單詞匹配
if len(str(game.word_content)) >= 1 and \
str(game.word_content)[0].lower() in str(self.text)[0].lower() and \
str(game.word_content).lower() in str(self.text).lower():
self.color = pygame.color.Color(self.game_conf.spell_ok_color)
# 更新單詞顏色
self.image = self.font.render(self.text, True, self.color)
class Animation(object):
"""動畫特效類"""
def __init__(self, screen):
"""初始化動畫資源"""
self.main_screen = screen
# 加載動畫資源
self.images = [pygame.image.load(img) for img in Game_Info.KILL_ANIMATION]
# 設(shè)置當前動畫播放索引
self.index = 0
# 動畫播放間隔
self.interval = 2
self.interval_index = 0
# 動畫位置
self.position = [0, 0]
# 是否可見
self.visible = False
# 設(shè)置動畫播放的位置
def set_pos(self, x, y):
self.position[0] = x
self.position[1] = y
# 動畫播放
def action(self):
# 如果爆炸對象狀態(tài)不可見，則不計算坐標
if not self.visible:
return
# 控制每一幀圖片的播放間隔
self.interval_index += 1
if self.interval_index < self.interval:
return
self.interval_index = 0
self.index = self.index + 1
if self.index >= len(self.images):
self.index = 0
self.visible = False
# 繪制動畫
def draw(self):
# 如果對象不可見，則不繪制
if not self.visible:
return
self.main_screen.screen.blit(self.images[self.index], (self.position[0], self.position[1]))
def main():
pass
if __name__ == '__main__':
pass五、效果展示
1）游戲界面
2）游戲設(shè)置
?3）隨機截圖
（打字開始掉下來各種單詞，打完之后還會出現(xiàn)相應(yīng)的單詞中文解釋）
4）游戲結(jié)束
（相應(yīng)的時間打英文單詞一個單詞一分，又背景音樂的哦）
到此這篇關(guān)于基于Python實現(xiàn)英語單詞小游戲的文章就介紹到這了,更多相關(guān)Python英語單詞游戲內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
三元運算符也稱為條件表達式，是根據(jù)條件為真或假來評估某些內(nèi)容的運算符。它在2.5 版本中被添加到 Python 中。 本文將通過示例詳細說說三元運算符的使用，需要的可以參考一下2022-09-09
這篇文章主要介紹了Python 讀取.txt,.md等文本文件的操作，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-05-05
這篇文章主要介紹了python實現(xiàn)圖像高斯金字塔的示例代碼，幫助大家更好的利用python處理圖片，感興趣的朋友可以了解下2020-12-12
情人節(jié)送玫瑰花千篇一律？本文將為大家介紹利用Python繪制多種3D立體花朵的示例代碼，讓女友感受一下程序員的浪漫！快來跟隨小編一起學(xué)習(xí)一下吧2021-12-12
這篇文章主要介紹了python-opencv如何讀取圖片及尺寸修改，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-11-11
Python使用Flask框架獲取當前查詢參數(shù)的方法
這篇文章主要介紹了Python使用Flask框架獲取當前查詢參數(shù)的方法,實例分析了query_string獲取查詢參數(shù)的技巧,需要的朋友可以參考下
2015-03-03 
這篇文章主要介紹了numpy中關(guān)于where函數(shù)的用法,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
2024-02-02 
這篇文章主要介紹了Python批量更改文件名的實現(xiàn)方法的相關(guān)資料,希望通過本文能幫助到大家，讓大家掌握這樣的方法，需要的朋友可以參考下
2017-10-10 
Python提供了多種方式來轉(zhuǎn)換字符串為數(shù)字類型,但是每一種方式都有其優(yōu)缺點,這篇文章主要介紹了Python中將字符串變成數(shù)字的5種方法,文中通過代碼示例介紹的非常詳細,需要的朋友可以參考下
2022-10-10