• 【Python小系统】四级考满分的学姐告诉你这样学英语逢考必过，赶紧康康叭~（捷径分享）

    导语

    哈喽哈喽！很久没更新啦，有没有小伙伴儿想我呀~（举手🙋‍）

    今天开始恢复更新啦——希望大家多多支持，爆文我就爆更哦~嘿嘿嘿👇

    1. A Deep-sworn Vow
    2.  
    3. Others because you did notkeep,
    4.  
    5. That deep-sworn vow have beenfriends of mine;
    6.  
    7. Yet always  when I look death in the face,
    8.  
    9. When I clamber to the heightsof sleep,
    10.  
    11. Or when I grow excited withwine,
    12.  
    13. Suddenly I meet your face.
    14.  
    15.                                                                   ——John Keats

    （这是木子分享给大家的一首小诗，想知道这段小诗的中文意思吗？在文末哦~）

    所有文章完整的素材+源码都在👇👇

    粉丝白嫖源码福利，请移步至CSDN社区或文末公众hao即可免费。

    相信大家对于英语四级一点都不陌生了吧？

    很多学校都是要求学生必须考过英语四级，不然就不能毕业。

    一开始我抱着侥幸心理，心想上高中的时候英语不错，四级应该也很容易。不过成

    绩出来我就傻眼了，没有通过。然后我就制定了周密的学习计划，开始有计划地学习英语，等

    到第二次考试的时候终于通过啦。今天，小编给大家制作一款Python编程代码版本的四级考试

    打字小游戏，边玩儿游戏还能复习单词还能保持学习的积极性，这款代码游戏真的是考级姐妹

    的灵魂首先，让我们开正式康康叭👇

    ​正文

    一、敲代码之前的小tips——（仅个人观点勿喷）

    四级之前，大家要很认真的备考啦，每天做做各种类型的四级题，可以量不多，但是会用心的

    做，做完之后都会认真的总结，就算那种不仔细的原因也会写在错题旁边，借以提醒自己。每

    天这样去做的原因就是保持题感，毕竟四级是一门考试，好多题还是有很多套路的，但只要持

    之以恒地去联系，虽然套路深，铁杵磨成针。

     

     听力方面：每次听完并对过答案之后会继续听那一份听力材料，因为第一次是泛听，只需要抓

    住关键词的信息成功get到答案就好，那么后面就要开始精听，这一次我们的目标就是听懂这个

    人到底在说什么，争取听懂每一句，好了，接下来，当我反复听一句话却怎么也听不懂其中的

    某几个词的时候，那我就找到可以收入宝囊的法器了，然后你就把这几个词好好地在牛津字典

    里查一查，记在自己的收集本上，还要多多巩固，因为这些词语出现在考试中，从某种程度上

    来说就属于高频词汇的。另外呢，在精听的时候，我们要多多注意朗读者说英语时的感觉，包

    括他的发音、语调，都很重要，所以也可以跟着他一起读英语，在边听边说的过程中，我们的

    耳朵对英语会更加地敏感。

    阅读方面：在就应对四级考试的时候，刷题当然是不二选择，前面已经提到过四级套路深，所

    以考试之前，我每天大概会做一篇阅读，设定时间是很重要的，这样可以把握自己的考试节

    奏，不会太慌张。四级阅读题，一般都会按照文章的顺序来设计题目，一般情况下，四级阅读

    题的内容不会太少，信息量比较多，而我需要的又仅仅只是那几条有用的信息。那么，首先就

    先看文章后面的问题，带着问题去读文章，会起到事半功倍的效果，也节省时间。做完一篇阅

    读之后，需要认真总结错误原因，那么你错的题就错得很有意义，如果只是不停地做题，而不

    停下来反思原因，那做一万道题也不如做一道题。总结错误之后，同样需要仔细查阅陌生的单

    词，不断积累，方可在英语阅读中做到游刃有余。

    写作翻译方面：毋庸置疑，它们都是一种全面输出的体现，因此，更需要扎实地进行练习。我

    在四级考试之前，会准备一个本子，认真写好每一篇作文或是翻译，字迹工整，仔细构思，写

    完以后和优秀范文对比，学习它的用法，在平时就养成好的习惯，到了考场上才会更加从容。

    我觉得，写得越多，就会写得越好，优美而实用的句型才会信手拈来。总之，这同样是个坚持

    的过程，但终究会破茧成蝶、妙笔生花的。

    二、运行环境

    小编使用的环境：Python3、Pycharm社区版、Pygame模块。内置模块 你安装 好python环

    境就可以了。

     模块安装：pip install -i https://pypi.douban.com/simple/ +pygame

    三、素材（图片等）

    图片多，装不下，仅部分哈👇（懒.jpg）还有字体，音乐背景等等都没展示了哈。

    下面是提前准备的单词，大家每天可以更新一下的哈如下几百个是我准备的👇截图部分。

    四、代码展示

    1）主程序（英文打字小游戏主入口模块）

    1. # !/usr/bin/env python
    2. # -*- coding: utf-8 -*-
    3. """
    4. Author: 顾木子吖
    5. """
    6. import os
    7. import sys
    8. import time
    9. import traceback
    10. import Game_View
    11. from Game_View import *
    12. from Game_Sprite import *
    13.  
    14.  
    15. def center_pos():
    16.     """设置游戏窗口相对电脑屏幕居中"""
    17.     game_x = (Game_Info.SCREEN_X - Game_Info.SCREEN_RECT.width) / 2
    18.     game_y = (Game_Info.SCREEN_Y - Game_Info.SCREEN_RECT.height) / 2
    19.     os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (game_x, game_y)
    20.  
    21.  
    22. def random_music():
    23.     """随机播放背景音乐"""
    24.     # 判断是否是静音模式
    25.     print(Game_View.GameStartWin.voice_flag())
    26.     try:
    27.         pygame.mixer.init()
    28.         pygame.mixer.music.load(random.choice(Game_Info.GAME_MUSICS))
    29.         pygame.mixer.music.play(loops=0)
    30.     except Exception as e:
    31.         print("无法加载音频，请检查电脑配置" + str(e))
    32.         print(traceback.format_exc())
    33.  
    34.     if not Game_View.GameStartWin.voice_flag():
    35.         pygame.mixer_music.set_volume(0)
    36.  
    37.  
    38. def parser_words() -> dict:
    39.     """
    40.     解析英语单词
    41.     :return {"eng_word": val, "cn_comment": val}
    42.     """
    43.     english_words = []
    44.     word_contents = open(Game_Info.GAME_WORD_TEXT, encoding="gbk")
    45.     for value in word_contents:
    46.         value = value.lstrip()
    47.         word_list = value.split(" ")
    48.         words = [i for i in word_list if i != '']
    49.         if len(words) >= 2:
    50.             # 把解析好的单词和注释封装到字典中，然后加入列表
    51.             english_words.append(
    52.                 {"eng_word": words[0], "cn_comment": words[1]})
    53.     return english_words
    54.  
    55.  
    56. class TypingGame(object):
    57.     """打字游戏主类"""
    58.  
    59.     spell_ok = False            # 用于标识单词拼写成功
    60.     game_pause_flag = False     # 游戏暂停标志
    61.     game_over_flag = False      # 游戏结束标志
    62.     game_quit_flag = False      # 游戏退出标志
    63.     game_total_blood = Game_Info.GAME_BLOOD_RECT.width  # 游戏总能量(血条)
    64.  
    65.     # 游戏等级对照字典
    66.     game_level_dict = {
    67.         1: {"word_fall_speed": 0.3, "level_text": u"简单", "level_color": "green"},
    68.         2: {"word_fall_speed": 0.5, "level_text": u"上手", "level_color": "blue"},
    69.         3: {"word_fall_speed": 1.0, "level_text": u"中等", "level_color": "orange"},
    70.         4: {"word_fall_speed": 1.5, "level_text": u"困难", "level_color": "red"},
    71.         5: {"word_fall_speed": 2.0, "level_text": u"魔鬼", "level_color": "purple"}
    72.     }
    73.  
    74.     @staticmethod
    75.     def game_init():
    76.         """游戏初始化"""
    77.         # 初始化游戏字体
    78.         pygame.font.init()
    79.  
    80.         # 设置游戏标题和图标
    81.         pygame.display.set_caption(Game_Info.GAME_NAME)
    82.         pygame.display.set_icon(pygame.image.load(Game_Info.GAME_ICON_32))
    83.  
    84.     @staticmethod
    85.     def set_game_event():
    86.         """设置游戏事件"""
    87.         # 设置创建单词的定时器
    88.         pygame.time.set_timer(Game_Info.CREATE_WORD_EVENT, Game_Info.CREATE_WORD_INTERVAL)
    89.  
    90.         # 设置游戏音乐结束事件
    91.         try:
    92.             pygame.mixer.music.set_endevent(Game_Info.MUSIC_END_EVENT)
    93.         except Exception as e:
    94.             print("无法设置音乐结束事件\t" + str(e))
    95.             print(traceback.format_exc())
    96.  
    97.     def __init__(self):
    98.         self.words = parser_words()
    99.         self.game_conf = GameConfig()                   # 游戏配置信息
    100.         self.game_default_voice = 20                    # 游戏默认音量
    101.         self.use_time = 0                               # 记录游戏使用的时间
    102.         self.total_score = 0                            # 记录游戏拼写成功了多少个单词
    103.         self.word_content = ""                          # 键盘输入的单词
    104.         self.backspace_count = 0                        # 回删键按下的次数
    105.  
    106.         # 预先创建动画对象
    107.         self.animates = [Animation(self) for _ in range(5)]
    108.  
    109.         # 游戏初始血条值
    110.         self.game_blood = int(self.game_conf.game_init_blood) * 10
    111.         self.game_clock = pygame.time.Clock()
    112.         self.screen = pygame.display.set_mode(Game_Info.SCREEN_RECT.size)
    113.  
    114.         self.game_init()
    115.         self.set_game_event()       # 设置游戏事件
    116.         self.__create_sprite()      # 创建游戏精灵
    117.  
    118.     def __create_sprite(self):
    119.         """创建精灵和精灵组"""
    120.  
    121.         # 背景精灵
    122.         back_sprite = ImageSprite(Game_Info.GAME_BACKGROUND)
    123.         # 根据游戏屏幕的大小适配背景图(可能会导致背景图变形)
    124.         back_sprite.transform_scale(
    125.             back_sprite.image,
    126.             (Game_Info.SCREEN_RECT.width, Game_Info.SCREEN_RECT.height)
    127.         )
    128.         self.back_group = pygame.sprite.Group(back_sprite)
    129.  
    130.         # 英文单词显示框
    131.         input_rect_sprite = ImageSprite(Game_Info.INPUT_BACKGROUND)
    132.         # 缩放图片
    133.         input_rect_sprite.transform_scale(
    134.             input_rect_sprite.image,
    135.             (Game_Info.INPUT_RECT_WIDTH, Game_Info.INPUT_RECT_HEIGHT)
    136.         )
    137.         # 水平居中显示
    138.         input_rect_sprite.hor_center(Game_Info.SCREEN_RECT)
    139.         self.input_rect_group = pygame.sprite.Group(input_rect_sprite)
    140.  
    141.         # 创建“游戏设置”图片
    142.         self.game_set_sprite = ImageSprite(Game_Info.GAME_SET_PINK)
    143.         set_x = Game_Info.SCREEN_RECT.width - self.game_set_sprite.rect.width - 10
    144.         set_y = Game_Info.SCREEN_RECT.height - self.game_set_sprite.rect.height - 10
    145.         self.game_set_sprite.set_pos(set_x, set_y)
    146.         self.game_set_sprite_group = pygame.sprite.Group(self.game_set_sprite)
    147.  
    148.         # 拼写的单词
    149.         spell_word_sprite = SpellSprite(
    150.             "",
    151.             size=26,
    152.             color=pygame.color.Color(self.game_conf.spell_ok_color)
    153.         )
    154.         spell_word_sprite.hor_center(Game_Info.SCREEN_RECT)
    155.         spell_word_sprite.set_pos(spell_word_sprite.rect.x, 40)
    156.         self.spell_word_group = pygame.sprite.Group(spell_word_sprite)
    157.  
    158.         # 创建单词精灵组
    159.         self.word_group = pygame.sprite.Group()
    160.         self.__random_generate_word(Game_Info.GENERATE_WORD_NUM)
    161.  
    162.         # 创建显示游戏时间精灵
    163.         time_sprite = TextSprite(text="Time: 0", size=28, color=Game_Info.BLUE)
    164.         time_sprite.set_pos(5, 0)
    165.         self.time_group = pygame.sprite.Group(time_sprite)
    166.  
    167.         # 游戏分数
    168.         self.score_sprite = TextSprite("Score: 0", size=30, color=Game_Info.BLUE)
    169.         self.score_sprite.set_pos(Game_Info.SCREEN_RECT.width - self.score_sprite.rect.width - 20, 3)
    170.         self.score_group = pygame.sprite.Group(self.score_sprite)
    171.  
    172.         # 游戏结束精灵(组)
    173.         self.__game_over_sprite()
    174.  
    175.     def __game_over_sprite(self):
    176.         """创建游戏结束的精灵(组)"""
    177.         self.game_over_group = pygame.sprite.Group()
    178.  
    179.         game_over_sprite = TextSprite("Game  Over", 100, Game_Info.BLUE)
    180.         game_over_sprite.rect.y = (Game_Info.SCREEN_RECT.height - game_over_sprite.rect.height - 400) / 2
    181.         game_over_sprite.hor_center(Game_Info.SCREEN_RECT)
    182.  
    183.         game_level_text = self.game_level_dict[int(self.game_conf.game_level)]["level_text"]
    184.         game_level_color = pygame.color.Color(self.game_level_dict[int(self.game_conf.game_level)]["level_color"])
    185.         self.game_level_sprite = TextSprite(u"游戏等级: " + game_level_text, 50, game_level_color)
    186.         self.game_level_sprite.rect.y = game_over_sprite.rect.y + 100 + 50
    187.         self.game_level_sprite.hor_center(Game_Info.SCREEN_RECT)
    188.  
    189.         self.game_score_sprite = TextSprite(u"游戏分数: ", 50, Game_Info.BLUE)
    190.         self.game_score_sprite.rect.y = game_over_sprite.rect.y + 200 + 50
    191.         self.game_score_sprite.hor_center(Game_Info.SCREEN_RECT)
    192.  
    193.         self.highest_sprite = TextSprite(u"历史最高: ", 50, Game_Info.BLUE)
    194.         self.highest_sprite.rect.y = game_over_sprite.rect.y + 300 + 50
    195.         self.highest_sprite.hor_center(Game_Info.SCREEN_RECT)
    196.  
    197.         self.quit_sprite = TextSprite(u"退出", 50, Game_Info.BLUE)
    198.         self.quit_sprite.set_pos(
    199.             game_over_sprite.rect.x - self.quit_sprite.rect.width,
    200.             game_over_sprite.rect.y + 400 + 10
    201.         )
    202.  
    203.         self.reset_sprite = TextSprite(u"重 玩", 50, Game_Info.BLUE)
    204.         self.reset_sprite.set_pos(
    205.             game_over_sprite.rect.x + game_over_sprite.rect.width,
    206.             game_over_sprite.rect.y + 400 + 10
    207.         )
    208.  
    209.         self.game_over_group.add(
    210.             game_over_sprite,
    211.             self.game_level_sprite,
    212.             self.game_score_sprite,
    213.             self.highest_sprite,
    214.             self.quit_sprite, self.reset_sprite
    215.         )
    216.  
    217.     def __update_sprite(self):
    218.         """更新精灵"""
    219.         self.back_group.update()
    220.         self.back_group.draw(self.screen)
    221.  
    222.         self.game_set_sprite_group.update()
    223.         self.game_set_sprite_group.draw(self.screen)
    224.  
    225.         self.input_rect_group.update()
    226.         self.input_rect_group.draw(self.screen)
    227.  
    228.         # 计算游戏使用时间
    229.         if not self.game_pause_flag and not self.game_over_flag:
    230.             self.use_time += 0.1
    231.  
    232.         display_time = "Time: " + str(self.use_time / 6)
    233.         self.time_group.update(display_time[:12])
    234.         self.time_group.draw(self.screen)
    235.  
    236.         self.score_sprite.set_pos(Game_Info.SCREEN_RECT.width - self.score_sprite.rect.width - 20, 3)
    237.         self.score_group.update("Score: " + str(self.total_score))
    238.         self.score_group.draw(self.screen)
    239.  
    240.         # 判断是否游戏结束
    241.         if self.game_over_flag:
    242.             self.__game_over()
    243.             game_level_text = self.game_level_dict[int(self.game_conf.game_level)]["level_text"]
    244.             self.game_level_sprite.update("游戏等级: " + str(game_level_text))
    245.             self.game_over_group.draw(self.screen)
    246.         else:
    247.             if not self.game_pause_flag:
    248.                 self.word_group.update(self)
    249.             self.word_group.draw(self.screen)
    250.  
    251.             spell_ok_color = pygame.Color(self.game_conf.spell_ok_color)
    252.             self.spell_word_group.update(self.word_content, spell_ok_color)
    253.             self.spell_word_group.draw(self.screen)
    254.  
    255.             # 更新游戏能量条
    256.             if 0 <= self.game_blood <= self.game_total_blood:
    257.                 self.__draw_game_blood()
    258.  
    259.         # 单词精灵拼写成功动画
    260.         for animate in self.animates:
    261.             if animate.visible:
    262.                 animate.draw()
    263.  
    264.     def start_game(self):
    265.         """打字游戏开启"""
    266.         # 随机播放背景音乐
    267.         random_music()
    268.  
    269.         # 利用多线程完成游戏持续掉血
    270.         drop_blood_t = threading.Thread(target=self.__drop_blood)
    271.         drop_blood_t.start()
    272.  
    273.         while True:
    274.             # 是否设置成静音
    275.             if not Game_View.GameStartWin.voice_flag():
    276.                 pygame.mixer_music.set_volume(0)
    277.             else:
    278.                 pygame.mixer_music.set_volume(self.game_default_voice)
    279.  
    280.             # 设置游戏刷新帧率
    281.             self.game_clock.tick(Game_Info.FRAME_PRE_SEC)
    282.  
    283.             # 判断游戏结束
    284.             if self.game_blood < 0:
    285.                 TypingGame.game_over_flag = True
    286.             else:
    287.                 self.__animate_action()
    288.                 self.__check_spell_word()
    289.  
    290.             self.__update_sprite()
    291.             self.__event_handle()
    292.             pygame.display.update()
    293.  
    294.     def __event_handle(self):
    295.         """游戏事件监听"""
    296.  
    297.         # 遍历所有事件
    298.         for event in pygame.event.get():
    299.             try:
    300.                 if pygame.mixer.music.get_endevent() == Game_Info.MUSIC_END_EVENT and \
    301.                         not pygame.mixer.music.get_busy():
    302.                     # 如果music播放结束且没有音乐在播放就随机下一首
    303.                     print("下一首")
    304.                     random_music()
    305.             except:
    306.                 pass
    307.  
    308.             # 如果单击关闭窗口，则退出
    309.             if event.type == pygame.QUIT and not self.game_pause_flag:
    310.                 pygame.quit()
    311.                 TypingGame.game_quit_flag = True
    312.                 sys.exit()
    313.  
    314.             # 创建单词事件
    315.             elif event.type == Game_Info.CREATE_WORD_EVENT:
    316.                 if not self.game_over_flag and not self.game_pause_flag:
    317.                     # 游戏结束或者暂停就停止生成单词了
    318.                     self.__random_generate_word(word_num=3)
    319.  
    320.             # 鼠标移动事件
    321.             elif event.type == pygame.MOUSEMOTION:
    322.                 x, y = event.pos  # 获取屏幕坐标位置
    323.                 if self.__is_on_set(x, y):
    324.                     self.game_set_sprite.image = pygame.image.load(Game_Info.GAME_SET_BLUE)
    325.                 else:
    326.                     self.game_set_sprite.image = pygame.image.load(Game_Info.GAME_SET_PINK)
    327.  
    328.                 # 游戏结束鼠标悬浮在确定按钮上变色
    329.                 if self.quit_sprite.rect.x <= x <= self.quit_sprite.rect.x + self.quit_sprite.rect.width and \
    330.                         self.quit_sprite.rect.y <= y <= self.quit_sprite.rect.y + self.quit_sprite.rect.height:
    331.                     self.quit_sprite.color = Game_Info.PINK
    332.                     self.quit_sprite.update(self.quit_sprite.text)
    333.                 else:
    334.                     self.quit_sprite.color = Game_Info.BLUE
    335.                     self.quit_sprite.update(self.quit_sprite.text)
    336.  
    337.                 # 游戏结束鼠标悬浮在重玩按钮上变色
    338.                 if self.reset_sprite.rect.x <= x <= self.reset_sprite.rect.x + self.reset_sprite.rect.width and \
    339.                         self.reset_sprite.rect.y <= y <= self.reset_sprite.rect.y + self.reset_sprite.rect.height:
    340.                     self.reset_sprite.color = Game_Info.PINK
    341.                     self.reset_sprite.update(self.reset_sprite.text)
    342.                 else:
    343.                     self.reset_sprite.color = Game_Info.BLUE
    344.                     self.reset_sprite.update(self.reset_sprite.text)
    345.  
    346.             # 鼠标点击事件
    347.             elif event.type == pygame.MOUSEBUTTONDOWN:
    348.                 x, y = event.pos  # 获取屏幕坐标位置
    349.  
    350.                 # 点击游戏设置
    351.                 if self.__is_on_set(x, y):
    352.                     # 判断游戏是否暂停
    353.                     if not self.game_pause_flag:
    354.                         TypingGame.game_pause_flag = True
    355.  
    356.                 # 游戏结束鼠标点击退出按钮
    357.                 if self.quit_sprite.rect.x <= x <= self.quit_sprite.rect.x + self.quit_sprite.rect.width and \
    358.                         self.quit_sprite.rect.y <= y <= self.quit_sprite.rect.y + self.quit_sprite.rect.height:
    359.                     pygame.quit()
    360.                     TypingGame.game_quit_flag = True
    361.                     sys.exit()
    362.  
    363.                 # 游戏结束鼠标点击重玩按钮
    364.                 if self.reset_sprite.rect.x <= x <= self.reset_sprite.rect.x + self.reset_sprite.rect.width and \
    365.                         self.reset_sprite.rect.y <= y <= self.reset_sprite.rect.y + self.reset_sprite.rect.height:
    366.                     self.__reset_game()
    367.  
    368.             # 键盘事件
    369.             elif event.type == pygame.KEYDOWN and not self.game_over_flag and not self.game_pause_flag:
    370.                 # 英文单引号的ASCII值是39、-是45、.是46
    371.                 # print(event.key)
    372.                 if (pygame.K_a <= event.key <= pygame.K_z) or event.key in (39, 45, 46):
    373.                     if self.spell_ok:
    374.                         # 如果单词拼写成功再按下键盘时清空内容
    375.                         self.word_content = ""
    376.                         self.spell_ok = False
    377.  
    378.                     # 控制单词长度
    379.                     if len(self.word_content) < 40:
    380.                         # 记录键盘输入的字符
    381.                         self.word_content += pygame.key.name(event.key)
    382.                     else:
    383.                         print("Word to long")
    384.                     print(self.word_content)
    385.                 if event.key == pygame.K_BACKSPACE:
    386.                     self.__delete_words()
    387.             elif event.type == pygame.KEYUP:
    388.                 self.backspace_count = 0
    389.  
    390.         # 实现长按backspace连续回删
    391.         # 使用键盘提供的方法获取键盘按键 - 按键元组
    392.         keys_pressed = pygame.key.get_pressed()
    393.  
    394.         # 判断元组中对应的按键索引值 1
    395.         if keys_pressed[pygame.K_BACKSPACE]:
    396.             self.backspace_count += 1
    397.             if self.backspace_count > 20:
    398.                 self.__delete_words()
    399.  
    400.     def __is_on_set(self, x, y):
    401.         """
    402.         检查是否在设置图片上
    403.         :param x,y 鼠标的位置
    404.         """
    405.         img_set_x = self.game_set_sprite.rect.x
    406.         img_set_y = self.game_set_sprite.rect.y
    407.         img_set_w = self.game_set_sprite.rect.width
    408.         img_set_h = self.game_set_sprite.rect.height
    409.  
    410.         if (img_set_x <= x <= img_set_x + img_set_w) and \
    411.                 (img_set_y <= y <= img_set_y + img_set_h):
    412.             return True
    413.         else:
    414.             return False
    415.  
    416.     def __delete_words(self):
    417.         """单词回删"""
    418.         if self.word_content != "":
    419.             self.word_content = self.word_content[:-1]
    420.             print(self.word_content + "---" + str(len(self.word_content)))
    421.             if self.spell_ok:
    422.                 # 如果单词拼写成功再按下键盘回删键时清空内容
    423.                 self.word_content = ""
    424.                 self.spell_ok = False
    425.  
    426.     def __random_generate_word(self, word_num=5):
    427.         """
    428.         随机生成单词精灵
    429.         :param word_num:精灵数量 默认5
    430.         :return:
    431.         """
    432.         count = 0
    433.         while len(self.word_group.sprites()) <= 30:
    434.             index = random.randint(0, len(self.words) - 1)
    435.             eng_word = self.words[index]["eng_word"]
    436.             cn_comment = self.words[index]["cn_comment"]
    437.             # print(eng_word + "----" + cn_comment)
    438.             word_sprite = WordSprite(
    439.                 eng_word,
    440.                 cn_comment,
    441.                 speed=self.game_level_dict[int(self.game_conf.game_level)]['word_fall_speed'],
    442.                 size=int(self.game_conf.word_size),
    443.                 color=pygame.color.Color(str(self.game_conf.word_normal_color))
    444.             )
    445.  
    446.             # 单词位置随机
    447.             word_sprite.random_pos()
    448.  
    449.             # 检查新单词精灵是否与单词精灵组中的精灵碰撞(重叠)
    450.             words = pygame.sprite.spritecollide(
    451.                 word_sprite, self.word_group, False,
    452.                 pygame.sprite.collide_circle_ratio(1)
    453.             )
    454.  
    455.             # 碰撞(释放内存重新随机生成单词精灵)
    456.             if len(words) > 0:
    457.                 word_sprite.kill()
    458.                 continue
    459.             else:
    460.                 self.word_group.add(word_sprite)
    461.                 count += 1
    462.             if count >= word_num:
    463.                 break
    464.  
    465.     def __game_over(self):
    466.         """游戏结束"""
    467.         self.game_score_sprite.hor_center(Game_Info.SCREEN_RECT)
    468.         self.highest_sprite.hor_center(Game_Info.SCREEN_RECT)
    469.         self.game_score_sprite.update(u"游戏分数: %s" % self.total_score)
    470.  
    471.         """
    472.         history_score_dict
    473.         {
    474.             'level_0': "{'score': None,'use_time': None,'create_time': None}",
    475.             'level_1': "{'score': None,'use_time': None,'create_time': None}",
    476.             'level_2': "{...}",
    477.             ...
    478.         }
    479.         """
    480.         # 显示历史最高
    481.         highest_score_str = self.game_conf.history_score_dict['level_' + str(int(self.game_conf.game_level))]
    482.         highest_score_dict = eval(highest_score_str)
    483.         highest_score = highest_score_dict['score']
    484.         if highest_score is None or int(self.total_score) > int(highest_score):
    485.             # 更新历史记录
    486.             highest_score = self.total_score
    487.             highest_score_dict['score'] = str(self.total_score)
    488.             highest_score_dict['use_time'] = str(self.use_time)[:5] + 's'
    489.             highest_score_dict['create_time'] = str(time.strftime("%Y-%m-%d %H:%M"))
    490.             self.game_conf.set_highest_score(str(highest_score_dict), 'level_' + str(int(self.game_conf.game_level)))
    491.         else:
    492.             highest_score = highest_score_dict['score']
    493.  
    494.         self.highest_sprite.update(u"历史最高: %s" % highest_score)
    495.  
    496.     def __check_spell_word(self):
    497.         """检查拼写单词是否正确"""
    498.         word_sprites = self.word_group.sprites()
    499.         for word_sprite in word_sprites:
    500.  
    501.             # 判断单词内容是否相同
    502.             if self.word_content.lower() == word_sprite.text.lower():
    503.  
    504.                 # 判断血条是否超过总血条数
    505.                 if self.game_blood < self.game_total_blood:
    506.                     self.game_blood += 10
    507.  
    508.                 self.total_score += 1
    509.                 self.spell_ok = True
    510.                 self.word_content = self.word_content + "\t" + str(word_sprite.cn_comment)
    511.                 word_sprite.kill()
    512.  
    513.                 # 从预先创建完毕的动画中取出一个动画对象
    514.                 for animate in self.animates:
    515.                     if not animate.visible:
    516.                         # 设置动画位置
    517.                         animate.set_pos(word_sprite.rect.x, word_sprite.rect.y)
    518.                         # 动画对象状态设置为True
    519.                         animate.visible = True
    520.                         break
    521.  
    522.     def __draw_game_blood(self, color=Game_Info.GREEN):
    523.         """绘制游戏能量"""
    524.  
    525.         if self.game_blood <= 3 * 10:
    526.             color = Game_Info.RED
    527.         if self.game_blood >= 25 * 10:
    528.             color = Game_Info.BLUE
    529.         if self.game_total_blood-30 <= self.game_blood <= self.game_total_blood:
    530.             color = Game_Info.ORANGE
    531.  
    532.         # 绘制游戏能量
    533.         pygame.draw.rect(
    534.             self.screen, color,
    535.             pygame.Rect(
    536.                 Game_Info.GAME_BLOOD_RECT.x + 2,
    537.                 Game_Info.GAME_BLOOD_RECT.y,
    538.                 self.game_blood,
    539.                 Game_Info.GAME_BLOOD_RECT.height
    540.             )
    541.         )
    542.         pygame.draw.rect(self.screen, Game_Info.WHITE, Game_Info.GAME_BLOOD_RECT, 2)
    543.  
    544.     def __drop_blood(self):
    545.         """持续掉血"""
    546.         # if not self.game_pause_flag:
    547.         #     if int(self.use_time) > 0 and (int(self.use_time) / 6) % 2 == 0:
    548.         #         self.game_blood -= 0.5
    549.  
    550.         while not self.game_over_flag:
    551.             if self.game_pause_flag:
    552.                 self.game_clock.tick(60)
    553.             else:
    554.                 # 根据不同游戏等级掉血
    555.                 self.game_clock.tick(int(self.game_conf.game_level))
    556.                 self.game_blood -= 1
    557.  
    558.     def __animate_action(self):
    559.         """开启单词拼写成功动画"""
    560.         for animate in self.animates:
    561.             if animate.visible:
    562.                 animate.action()
    563.  
    564.     def __reset_game(self):
    565.         """游戏重玩"""
    566.         del self  # 释放内存
    567.         pygame.quit()
    568.         pygame.init()
    569.         random_music()
    570.         TypingGame.game_over_flag = False
    571.         TypingGame.game_quit_flag = False
    572.         TypingGame().start_game()
    573.  
    574.  
    575. def main():
    576.     center_pos()
    577.     # 启动游戏开始界面
    578.     GameStartWin(title="Word Sprite").run()
    579.  
    580.  
    581. if __name__ == '__main__':
    582.     main()

    2）游戏配置信息模块

    1. # !/usr/bin/env python
    2. # -*- coding: utf-8 -*-
    3. import ctypes
    4. import pygame
    5. import configparser
    6.  
    7.  
    8. class GameConfig(object):
    9.     """游戏配置文件类"""
    10.  
    11.     GAME_INFO = "game_info"                     # 配置文件游戏信息结点名称
    12.     GAME_STYLE = "game_style"                   # 配置文件游戏样式结点名称
    13.     GAME_SCORE = "game_score"                   # 配置文件游戏分数结点名称
    14.  
    15.     config_file_path = "resource/config.cfg"    # 游戏配置文件路径
    16.  
    17.     # 把配置文件类设置成单例模式
    18.     _instance = None
    19.  
    20.     def __new__(cls, *args, **kwargs):
    21.         if cls._instance is None:
    22.             cls._instance = super().__new__(cls)
    23.         return cls._instance
    24.  
    25.     def __init__(self):
    26.  
    27.         self.author = None
    28.         self.game_name = None
    29.         self.version = None
    30.         self.e_mail = None
    31.  
    32.         self.frame_pre_sec = None       # 游戏帧率
    33.         self.word_size = None           # 英文单词的大小
    34.         self.word_normal_color = None   # 单词的正常颜色
    35.         self.spell_ok_color = None      # 单词拼写成功的颜色
    36.         self.game_level = None          # 游戏等级
    37.         self.game_init_blood = None     # 游戏初始血量
    38.         self.history_score_dict = None  # 游戏历史记录
    39.         self.__parser_config()
    40.  
    41.     def __parser_config(self):
    42.         """解析游戏配置文件"""
    43.         self.conf_parser = configparser.ConfigParser()
    44.         self.conf_parser.read(self.config_file_path, encoding='utf-8')
    45.  
    46.         # 游戏开发者信息
    47.         self.author = self.conf_parser.get(self.GAME_INFO, 'author')
    48.         self.game_name = self.conf_parser.get(self.GAME_INFO, 'game_name')
    49.         self.version = self.conf_parser.get(self.GAME_INFO, 'version')
    50.         self.e_mail = self.conf_parser.get(self.GAME_INFO, 'e-mail')
    51.  
    52.         # 游戏样式信息
    53.         self.frame_pre_sec = self.conf_parser.get(self.GAME_STYLE, "frame_pre_sec")
    54.         self.word_size = self.conf_parser.get(self.GAME_STYLE, "word_size")
    55.         self.word_normal_color = self.conf_parser.get(self.GAME_STYLE, "word_normal_color")
    56.         self.spell_ok_color = self.conf_parser.get(self.GAME_STYLE, "spell_ok_color")
    57.         self.game_level = self.conf_parser.get(self.GAME_STYLE, "game_level")
    58.         self.game_init_blood = self.conf_parser.get(self.GAME_STYLE, "game_init_blood")
    59.  
    60.         # {
    61.         #   'level_0': "{'score': None,'use_time': None,'create_time': None}",
    62.         #   'level_1': "{...}",
    63.         #   }
    64.         # 历史最高信息
    65.         self.history_score_dict = dict(self.conf_parser.items(self.GAME_SCORE))
    66.  
    67.     def set_word_size(self, word_size):
    68.         """设置单词大小"""
    69.         self.word_size = word_size
    70.         self.conf_parser.set(self.GAME_STYLE, "word_size", str(word_size))
    71.         self.conf_parser.write(open(self.config_file_path, mode='w'))
    72.  
    73.     def set_game_level(self, game_level):
    74.         """设置游戏等级"""
    75.         self.game_level = game_level
    76.         self.conf_parser.set(self.GAME_STYLE, "game_level", str(game_level))
    77.         self.conf_parser.write(open(self.config_file_path, mode='w'))
    78.  
    79.     def set_game_init_blood(self, game_init_blood):
    80.         """设置游戏的初始血条"""
    81.         self.game_init_blood = game_init_blood
    82.         self.conf_parser.set(self.GAME_STYLE, "game_init_blood", str(game_init_blood))
    83.         self.conf_parser.write(open(self.config_file_path, mode='w'))
    84.  
    85.     def set_word_normal_color(self, word_normal_color):
    86.         """设置单词的正常颜色"""
    87.         self.word_normal_color = word_normal_color
    88.         self.conf_parser.set(self.GAME_STYLE, "word_normal_color", str(word_normal_color))
    89.         self.conf_parser.write(open(self.config_file_path, mode='w'))
    90.  
    91.     def set_spell_ok_color(self, spell_ok_color):
    92.         """设置单词拼写成功后的颜色"""
    93.         self.spell_ok_color = spell_ok_color
    94.         self.conf_parser.set(self.GAME_STYLE, "spell_ok_color", str(spell_ok_color))
    95.         self.conf_parser.write(open(self.config_file_path, mode='w'))
    96.  
    97.     def set_highest_score(self, score_dict, game_level):
    98.         """更新历史最高记录"""
    99.         self.conf_parser.set(self.GAME_SCORE, str(game_level), str(score_dict))
    100.         self.conf_parser.write(open(self.config_file_path, mode='w'))
    101.         self.history_score_dict = dict(self.conf_parser.items(self.GAME_SCORE))
    102.  
    103.  
    104. # 获取系统屏幕分辨率(缩放比例后)
    105. win_api = ctypes.windll.user32
    106. SCREEN_X = win_api.GetSystemMetrics(0)
    107. SCREEN_Y = win_api.GetSystemMetrics(1)
    108.  
    109. game_conf = GameConfig()
    110.  
    111. GAME_MUSICS = ["resource/music/bgm1.mp3", "resource/music/bgm2.mp3"]
    112. GAME_NAME = game_conf.game_name
    113. GAME_LEVEL = {'1': 0.3, '2': 0.5, '3': 1, '4': 1.5, '5': 2}           # 游戏困难等级与单词下落速度相互匹配字典
    114. SCREEN_RECT = pygame.Rect(0, 0, SCREEN_X * 0.85, SCREEN_Y * 0.85)     # 游戏窗口大小(电脑分辨率 * 0.85)
    115. INPUT_RECT_WIDTH = 600
    116. INPUT_RECT_HEIGHT = 100
    117. GAME_BLOOD_RECT = pygame.Rect(SCREEN_RECT.width / 2 - 250, SCREEN_RECT.height - 26, 500, 25)
    118.  
    119. GAME_ICON = "resource/image/rabbit.ico"
    120. GAME_ICON_32 = "resource/image/rabbit_32.png"
    121. GAME_ICON_48 = "resource/image/rabbit_48.png"
    122. VOICE_ICO = "resource/image/voice.png"
    123. MUTE_ICO = "resource/image/mute.png"
    124. GAME_BACKGROUND = "resource/image/game_bg.png"
    125. GAME_OVER_BACKGROUND = "resource/image/game_over.png"
    126. INPUT_BACKGROUND = "resource/image/input_bg.png"
    127. GAME_SET_BLUE = "resource/image/set_blue.png"
    128. GAME_SET_PINK = "resource/image/set_pink.png"
    129.  
    130. GAME_FONT = "resource/font/HUI.TTF"         # 游戏字体
    131. GAME_WORD_TEXT = "resource/en_word.txt"     # 游戏单词文本
    132.  
    133. # 单词拼写成功后的消失动画
    134. KILL_ANIMATION = ["resource/image/animation/" + str(img_num).zfill(3) + ".png" for img_num in range(8)]
    135.  
    136. FRAME_PRE_SEC = int(game_conf.frame_pre_sec)        # 游戏的刷新帧率
    137. WORD_SIZE = int(game_conf.word_size)                # 单词大小
    138. WORD_FALL_SPEED = GAME_LEVEL[str(game_conf.game_level)]  # 单词下落速度
    139. INIT_BLOOD = int(game_conf.game_init_blood)         # 游戏初始血条
    140.  
    141. # 创建单词的时间间隔(毫秒)
    142. CREATE_WORD_INTERVAL = 1000 * 5
    143.  
    144. # 首次生成单词的数量
    145. GENERATE_WORD_NUM = 5
    146.  
    147. # 游戏单词正常颜色和拼写颜色
    148. WORD_NORMAL_COLOR = str(game_conf.word_normal_color)
    149. SPELL_OK_COLOR = str(game_conf.spell_ok_color)
    150. WORD_COLOR = pygame.color.Color(WORD_NORMAL_COLOR)
    151. WORD_SPELL_OK_COLOR = pygame.color.Color(SPELL_OK_COLOR)
    152.  
    153. # 字体颜色
    154. RED = pygame.color.Color("RED")
    155. YELLOW = pygame.color.Color("YELLOW")
    156. BLUE = pygame.color.Color("#70f3ff")
    157. GREEN = pygame.color.Color("GREEN")
    158. WHITE = pygame.color.Color("WHITE")
    159. ORANGE = pygame.color.Color("ORANGE")
    160. PINK = pygame.color.Color("#ff4777")
    161.  
    162. # 创建单词事件
    163. CREATE_WORD_EVENT = pygame.USEREVENT
    164. # 游戏结束事件
    165. GAME_OVER_EVENT = pygame.USEREVENT + 1
    166. # 游戏音乐结束事件
    167. MUSIC_END_EVENT = pygame.USEREVENT + 2
    168.  
    169.  
    170. def main():
    171.     game_conf1 = GameConfig()
    172.     game_conf2 = GameConfig()
    173.     game_conf1.word_size = 100
    174.     game_conf2.game_init_blood = 50
    175.     print(id(game_conf1))
    176.     print(id(game_conf2))
    177.     print(game_conf1.game_init_blood)
    178.     print(game_conf2.word_size)
    179.     socre_dict = game_conf.history_score_dict
    180.     print(dict(socre_dict))
    181.     print(eval(socre_dict['level_1']))
    182.  
    183.     print(GAME_BLOOD_RECT)
    184.     # print(SCREEN_X, SCREEN_Y)
    185.     # print(SCREEN_RECT)
    186.     # print(SCREEN_RECT.size)
    187.     # print(game_conf.frame_pre_sec)
    188.     # print(game_conf.game_level)
    189.     # print(game_conf.word_size)
    190.     # print(game_conf.word_normal_color)
    191.     # print(game_conf.spell_ok_color)
    192.  
    193.     # print(WORD_NORMAL_COLOR)
    194.     # print(SPELL_OK_COLOR)
    195.     # print(int(10.000000001))
    196.     # print(SCREEN_X, SCREEN_Y)
    197.     # print(SCREEN_RECT.size)
    198.  
    199.  
    200. if __name__ == '__main__':
    201.     main()

    3）游戏视图模块

    1. import Game_Info
    2. import threading
    3. import PySimpleGUI as sg
    4. from Game_Info import GameConfig
    5. from tkinter import colorchooser
    6. from Game_Main import TypingGame
    7.  
    8.  
    9. class BaseWin(object):
    10.     """窗口父类"""
    11.     WIN_THEME = sg.theme('DarkBlue1')
    12.     text_color = 'white'
    13.     game_conf = GameConfig()    # 游戏信息配置类
    14.  
    15.     def __init__(self, title):
    16.         self.title = title
    17.         self.window = None
    18.         self.layout = list()
    19.  
    20.     def close_win(self):
    21.         """关闭窗口"""
    22.         if self.window is not None:
    23.             self.window.close()
    24.  
    25.  
    26. class GameStartWin(BaseWin):
    27.     """游戏开始窗口"""
    28.     _voice_flag = True
    29.  
    30.     def __init__(self, title):
    31.         super().__init__(title)
    32.         self.__init_layout()
    33.  
    34.     def __init_layout(self):
    35.         """初始化窗口布局"""
    36.         if self._voice_flag:
    37.             voice_img = Game_Info.VOICE_ICO
    38.         else:
    39.             voice_img = Game_Info.MUTE_ICO
    40.         self.layout = [
    41.             [sg.Text(size=(70, 0)), sg.Image(filename=voice_img, key='voice_control', enable_events=True)],
    42.             [sg.Text(size=(10, 10)), sg.Text('Word  Sprite', font=(u'宋体', 50)), sg.Text(size=(10, 10))],
    43.             [sg.Text(size=(23, 10)), sg.Button(u'开始游戏', font=(u'宋体', 30), key='start_game'), sg.Text(size=(23, 10))],
    44.             [sg.Text(size=(23, 5)), sg.Button(u'游戏设置', font=(u'宋体', 30), key='game_set'), sg.Text(size=(23, 5))],
    45.             [sg.Text(size=(23, 10)), sg.Button(u'历史最高', font=(u'宋体', 30), key='show_score'), sg.Text(size=(23, 10))],
    46.             [
    47.                 sg.Text(size=(70, 0)),
    48.                 sg.Image(
    49.                     filename=Game_Info.GAME_ICON_48,
    50.                     key='game_ico',
    51.                     enable_events=True
    52.                 )
    53.              ]
    54.         ]
    55.  
    56.     def run(self):
    57.         """启动游戏开始窗口"""
    58.         self.window = sg.Window(
    59.             title=self.title,
    60.             icon=Game_Info.GAME_ICON,
    61.             layout=self.layout
    62.         )
    63.         self.__event_handler()
    64.  
    65.     def __event_handler(self):
    66.         """窗口事件监听"""
    67.         while True:
    68.             event, value_dict = self.window.read(timeout=20)
    69.             print(event, value_dict)
    70.  
    71.             # 静音控制
    72.             if self._voice_flag:
    73.                 self.window.find_element('voice_control').update(filename=Game_Info.VOICE_ICO)
    74.             else:
    75.                 self.window.find_element('voice_control').update(filename=Game_Info.MUTE_ICO)
    76.  
    77.             if event in (sg.WIN_CLOSED, 'Quit'):
    78.                 break
    79.             elif event in 'voice_control':
    80.                 self.voice_control()
    81.             elif event in 'game_ico':
    82.                 self.author_win()
    83.             elif event in 'start_game':
    84.                 print('开始游戏')
    85.                 self.window.Hide()
    86.                 TypingGame.game_over_flag = False
    87.                 TypingGame.game_quit_flag = False
    88.                 threading.Thread(target=self.start_game).start()    # 利用线程开启游戏防止窗口卡死
    89.             elif event in 'game_set' or TypingGame.game_pause_flag:
    90.                 print('游戏设置')
    91.                 self.window.Disable()
    92.                 self.game_set()
    93.             elif event in 'show_score':
    94.                 print('历史最高')
    95.                 self.window.Disable()
    96.                 self.show_score()
    97.             elif TypingGame.game_quit_flag:
    98.                 self.window.UnHide()
    99.         self.window.close()
    100.  
    101.     def voice_control(self):
    102.         """游戏静音状态控制"""
    103.         if self._voice_flag:
    104.             GameStartWin._voice_flag = False
    105.             self.window.find_element('voice_control').update(filename=Game_Info.MUTE_ICO)
    106.         else:
    107.             GameStartWin._voice_flag = True
    108.             self.window.find_element('voice_control').update(filename=Game_Info.VOICE_ICO)
    109.  
    110.     def author_win(self):
    111.         """游戏开发信息窗口"""
    112.         self.window.Disable()
    113.         game_conf = Game_Info.GameConfig()
    114.  
    115.         show_text = '游戏作者: \t' + game_conf.author + '\n\n'\
    116.                     '游戏名称: \t' + game_conf.game_name + '\n\n'\
    117.                     '游戏版本: \t' + game_conf.version + '\n\n'\
    118.                     '作者邮箱: \t' + game_conf.e_mail + '\n'
    119.         sg.Popup(
    120.             show_text,
    121.             title=u'关于作者',
    122.             icon=Game_Info.GAME_ICON,
    123.             font=(u'宋体', 18),
    124.             custom_text=(u'  ★  ', u'  ❤  '),
    125.             button_color=('red', '#063288'),
    126.             line_width=50,
    127.         )
    128.         self.window.Enable()
    129.  
    130.     def game_set(self):
    131.         """游戏设置"""
    132.         GameSetWin(u"游戏配置", self).run()
    133.  
    134.     def show_score(self):
    135.         """查看历史最高分"""
    136.         GameScoreWin(u'历史最高', self).run()
    137.  
    138.     @staticmethod
    139.     def start_game():
    140.         """开始游戏"""
    141.         TypingGame().start_game()
    142.  
    143.     @classmethod
    144.     def voice_flag(cls):
    145.         return cls._voice_flag
    146.  
    147.  
    148. class GameExecuteWin(object):
    149.     """游戏运行窗口"""
    150.     pass
    151.  
    152.  
    153. class GameEndWin(object):
    154.     """游戏结束窗口"""
    155.  
    156.     def __init__(self):
    157.         pass
    158.  
    159.  
    160. class GameSetWin(BaseWin):
    161.     """游戏配置信息窗口"""
    162.  
    163.     # 游戏等级对照字典
    164.     game_level_dict = {
    165.         1: {"game_level_num": 5, "game_level_text": u"简单", "game_level_color": "green"},
    166.         2: {"game_level_num": 15, "game_level_text": u"上手", "game_level_color": "blue"},
    167.         3: {"game_level_num": 25, "game_level_text": u"中等", "game_level_color": "orange"},
    168.         4: {"game_level_num": 35, "game_level_text": u"困难", "game_level_color": "red"},
    169.         5: {"game_level_num": 50, "game_level_text": u"魔鬼", "game_level_color": "purple"}
    170.     }
    171.  
    172.     def __init__(self, title, parent_win=None):
    173.         """初始化游戏配置界面"""
    174.         super().__init__(title)
    175.         self.parent_win = parent_win
    176.         self.word_normal_color = self.game_conf.word_normal_color
    177.         self.spell_ok_color = self.game_conf.spell_ok_color
    178.         self.__init_layout()
    179.  
    180.     def __init_layout(self):
    181.         game_level_num = self.game_level_dict[int(self.game_conf.game_level)]["game_level_num"]
    182.         game_level_text = self.game_level_dict[int(self.game_conf.game_level)]["game_level_text"]
    183.         game_level_color = self.game_level_dict[int(self.game_conf.game_level)]["game_level_color"]
    184.  
    185.         self.layout = [
    186.             [
    187.                 sg.Text(u'游戏难度等级:', text_color=self.text_color),
    188.                 sg.Slider(
    189.                     range=(1, 50), default_value=game_level_num,
    190.                     size=(26, 18), orientation='h', key="game_level",
    191.                     enable_events=True, disable_number_display=True,
    192.                 ),
    193.                 sg.Button(
    194.                     game_level_text, key='game_level_btn',
    195.                     button_color=(self.text_color, game_level_color),
    196.                 ),
    197.             ],
    198.             [
    199.                 sg.Text(u'游戏字体大小:', text_color=self.text_color),
    200.                 sg.Slider(
    201.                     range=(15, 35), default_value=int(self.game_conf.word_size),
    202.                     size=(26, 18), enable_events=True,
    203.                     orientation='h', disable_number_display=True, key="word_size"
    204.                 ),
    205.                 sg.Text(
    206.                     str(self.game_conf.word_size), text_color=self.text_color, size=(3, 1),
    207.                     font=("宋体", int(self.game_conf.word_size)),
    208.                     key='word_size_num'
    209.                 ),
    210.             ],
    211.             [
    212.                 sg.Text(u'游戏初始血条:', text_color=self.text_color),
    213.                 sg.Slider(
    214.                     range=(5, 30), default_value=int(self.game_conf.game_init_blood),
    215.                     size=(26, 18), orientation='h',
    216.                     enable_events=True, disable_number_display=True, key='init_blood'
    217.                 ),
    218.                 sg.Text(
    219.                     str(self.game_conf.game_init_blood), size=(3, 1),
    220.                     text_color=self.text_color, key='blood_num'
    221.                 )
    222.             ],
    223.             [
    224.                 sg.Text(u'游戏静音状态:', text_color=self.text_color),
    225.                 sg.Radio(
    226.                     ' ', default=GameStartWin.voice_flag(), key='voice_open',
    227.                     group_id=1, text_color=self.text_color, enable_events=True
    228.                 ),
    229.                 sg.Image(filename=Game_Info.VOICE_ICO),
    230.                 sg.Text(' ' * 5),
    231.                 sg.Radio(
    232.                     ' ', default=not GameStartWin.voice_flag(), key='mute',
    233.                     group_id=1, text_color=self.text_color, enable_events=True
    234.                 ),
    235.                 sg.Image(filename=Game_Info.MUTE_ICO)
    236.             ],
    237.             [
    238.                 sg.Text(u'游戏字体颜色:', text_color=self.text_color),
    239.                 sg.Text(
    240.                     '', size=(17, 1),
    241.                     background_color=self.game_conf.word_normal_color,
    242.                     enable_events=True, key='word_normal_color'
    243.                 ),
    244.                 sg.Text(
    245.                     'HUI', key='word_color_test',
    246.                     text_color=self.game_conf.word_normal_color,
    247.                 ),
    248.                 sg.Button(u'颜色选择', key='normal_ccb')
    249.             ],
    250.             [
    251.                 sg.Text(u'单词拼写颜色:', text_color=self.text_color),
    252.                 sg.Text(
    253.                     '', size=(17, 1),
    254.                     background_color=self.game_conf.spell_ok_color,
    255.                     enable_events=True, key='spell_ok_color'
    256.                 ),
    257.                 sg.Text(
    258.                     'HUI', key='spell_color_test',
    259.                     text_color=self.game_conf.spell_ok_color,
    260.                 ),
    261.                 sg.Button(u'颜色选择', key='spell_ccb')
    262.             ],
    263.             [
    264.                 sg.Submit(u'暂时保存', key='temp_save', pad=((10, 350), (0, 0))),
    265.                 sg.Button(u'永久保存', key='permanent')
    266.             ]
    267.         ]
    268.  
    269.     def run(self):
    270.         """开启游戏设置界面"""
    271.         self.window = sg.Window(
    272.             title=self.title,
    273.             icon=Game_Info.GAME_ICON,
    274.             layout=self.layout,
    275.             font=("宋体", 18),
    276.             element_padding=(10, 30),
    277.         )
    278.         # 开启事件监听
    279.         self.__event_handler()
    280.  
    281.     @staticmethod
    282.     def color_callback(color=None):
    283.         """颜色按钮回调方法"""
    284.         return colorchooser.askcolor(color)
    285.  
    286.     def __event_handler(self):
    287.         while True:
    288.             event, value_dict = self.window.read()
    289.             # print(event, value_dict)
    290.             if event in (None, 'Quit'):
    291.                 break
    292.             elif event in ('voice_open', 'mute'):
    293.                 if value_dict['voice_open']:
    294.                     GameStartWin._voice_flag = True
    295.                 else:
    296.                     GameStartWin._voice_flag = False
    297.             elif event in 'game_level':
    298.                 game_level = self.get_game_level(int(value_dict[event]))
    299.                 game_level_text = self.game_level_dict[game_level]['game_level_text']
    300.                 game_level_color = self.game_level_dict[game_level]['game_level_color']
    301.                 self.window.find_element('game_level_btn').update(
    302.                     game_level_text,
    303.                     button_color=(self.text_color, game_level_color)
    304.                 )
    305.             elif event in 'game_level_btn':
    306.                 # 点击按钮切换游戏等级
    307.                 game_level = self.get_game_level(int(value_dict['game_level']))
    308.                 if game_level == 5:
    309.                     game_level = 0
    310.                 game_level_num = self.game_level_dict[game_level + 1]['game_level_num']
    311.                 game_level_text = self.game_level_dict[game_level + 1]['game_level_text']
    312.                 game_level_color = self.game_level_dict[game_level + 1]['game_level_color']
    313.  
    314.                 self.window.find_element('game_level').update(game_level_num)
    315.                 self.window.find_element('game_level_btn').update(
    316.                     game_level_text,
    317.                     button_color=(self.text_color, game_level_color)
    318.                 )
    319.             elif event in 'word_size':
    320.                 word_size_num = value_dict[event]
    321.                 self.window.find_element('word_size_num').update(int(word_size_num), font=(u'宋体', int(word_size_num)))
    322.             elif event in 'init_blood':
    323.                 blood_num = int(value_dict[event])
    324.                 self.window.find_element('blood_num').update(str(blood_num))
    325.             elif event in 'normal_ccb':
    326.                 # 游戏单词颜色选择
    327.                 self.window.Disable()  # 让游戏配置窗口不可用，不让用户乱点击，防止多开
    328.                 choose_colors = self.color_callback(self.game_conf.word_normal_color)
    329.                 self.window.Enable()  # 恢复游戏配置窗口
    330.                 if None not in choose_colors:
    331.                     self.window.find_element('word_normal_color').update(background_color=choose_colors[1])
    332.                     self.window.find_element('word_color_test').update(text_color=choose_colors[1])
    333.                     self.word_normal_color = choose_colors[1]
    334.             elif event in 'spell_ccb':
    335.                 # 单词拼写颜色选择
    336.                 self.window.Disable()  # 让游戏配置窗口不可用，不让用户乱点击，防止多开
    337.                 choose_colors = self.color_callback(self.game_conf.spell_ok_color)
    338.                 self.window.Enable()  # 恢复游戏配置窗口
    339.                 if None not in choose_colors:
    340.                     self.window.find_element('spell_ok_color').update(background_color=choose_colors[1])
    341.                     self.window.find_element('spell_color_test').update(text_color=choose_colors[1])
    342.                     self.spell_ok_color = choose_colors[1]
    343.             elif event in ('temp_save', 'permanent'):
    344.                 GameSetWin.SAVE_STATUS = True
    345.                 game_level = self.get_game_level(int(value_dict['game_level']))
    346.                 value_dict['game_level'] = game_level
    347.                 value_dict['normal_ccb'] = self.word_normal_color
    348.                 value_dict['spell_ccb'] = self.spell_ok_color
    349.                 if event in 'temp_save':
    350.                     self.temp_save(value_dict)
    351.                 elif event in 'permanent':
    352.                     self.permanent(value_dict)
    353.                 break
    354.  
    355.         self.window.close()
    356.         TypingGame.game_pause_flag = False
    357.  
    358.         # 恢复父窗口可用
    359.         if self.parent_win is not None:
    360.             self.parent_win.window.Enable()
    361.  
    362.     def temp_save(self, game_dict):
    363.         """临时保存游戏配置信息(临时有效，重开还原)"""
    364.         """
    365.                {
    366.                    'game_level': 2, 
    367.                    'word_size': 26.0, 
    368.                    'init_blood': 20.0, 
    369.                    'voice_open': True, 
    370.                    'mute': False,
    371.                    'normal_ccb': '#00ffff', 
    372.                    'spell_ccb': '#ff0000'
    373.                }
    374.         """
    375.         self.game_conf.game_level = game_dict['game_level']
    376.         self.game_conf.word_size = game_dict['word_size']
    377.         self.game_conf.game_init_blood = game_dict['init_blood']
    378.         self.game_conf.word_normal_color = game_dict['normal_ccb']
    379.         self.game_conf.spell_ok_color = game_dict['spell_ccb']
    380.  
    381.     def permanent(self, game_dict):
    382.         """永久保存游戏配置信息(写入配置文件)"""
    383.  
    384.         # 修改配置文件
    385.         self.game_conf.set_game_level(game_dict['game_level'])
    386.         self.game_conf.set_word_size(int(game_dict['word_size']))
    387.         self.game_conf.set_game_init_blood(int(game_dict['init_blood']))
    388.         self.game_conf.set_word_normal_color(game_dict['normal_ccb'])
    389.         self.game_conf.set_spell_ok_color(game_dict['spell_ccb'])
    390.  
    391.     @staticmethod
    392.     def get_game_level(data):
    393.         game_level = 1
    394.         if data <= 10:
    395.             game_level = 1
    396.         elif data <= 20:
    397.             game_level = 2
    398.         elif data <= 30:
    399.             game_level = 3
    400.         elif data <= 40:
    401.             game_level = 4
    402.         elif data <= 50:
    403.             game_level = 5
    404.         return game_level#
    405.  
    406.  
    407. class GameScoreWin(BaseWin):
    408.     """游戏历史分数窗口"""
    409.     heads = [
    410.         '{:4}'.format(u'游戏等级'),
    411.         '{:4}'.format(u'最高分'),
    412.         '{:6}'.format(u'耗 时'),
    413.         '{:4}'.format(u'创建时间'),
    414.     ]
    415.     levels = ['level_1', 'level_2', 'level_3', 'level_4', 'level_5']
    416.  
    417.     def __init__(self, title, parent_win=None):
    418.         super().__init__(title)
    419.         self.parent_win = parent_win
    420.         self.__init_layout()
    421.  
    422.     def __init_layout(self):
    423.         """初始化窗口布局"""
    424.         score_dict = Game_Info.game_conf.history_score_dict       # 游戏历史记录
    425.         level_0, level_1 = eval(score_dict[self.levels[0]]), eval(score_dict[self.levels[1]])
    426.         level_2, level_3 = eval(score_dict[self.levels[2]]), eval(score_dict[self.levels[3]])
    427.         level_4 = eval(score_dict[self.levels[4]])
    428.  
    429.         header = [[sg.Text(h, pad=(31, 30)) for h in self.heads]]
    430.         body = [
    431.             [
    432.                 sg.Button(u'简单', button_color=('white', 'green')),
    433.                 sg.Text('{:4}'.format(str(level_0['score']))),
    434.                 sg.Text('{:6}'.format(str(level_0['use_time']))),
    435.                 sg.Text('{:4}'.format(str(level_0['create_time'])))
    436.             ],
    437.             [
    438.                 sg.Button(u'上手', button_color=('white', 'blue')),
    439.                 sg.Text('{:4}'.format(str(level_1['score']))),
    440.                 sg.Text('{:6}'.format(str(level_1['use_time']))),
    441.                 sg.Text('{:4}'.format(str(level_1['create_time'])))
    442.             ],
    443.             [
    444.                 sg.Button(u'中等', button_color=('white', 'orange')),
    445.                 sg.Text('{:4}'.format(str(level_2['score']))),
    446.                 sg.Text('{:6}'.format(str(level_2['use_time']))),
    447.                 sg.Text('{:4}'.format(str(level_2['create_time'])))
    448.             ],
    449.             [
    450.                 sg.Button(u'困难', button_color=('white', 'red')),
    451.                 sg.Text('{:4}'.format(str(level_3['score']))),
    452.                 sg.Text('{:6}'.format(str(level_3['use_time']))),
    453.                 sg.Text('{:4}'.format(str(level_3['create_time'])))
    454.             ],
    455.             [
    456.                 sg.Button(u'魔鬼', button_color=('white', 'purple')),
    457.                 sg.Text('{:4}'.format(str(level_4['score']))),
    458.                 sg.Text('{:6}'.format(str(level_4['use_time']))),
    459.                 sg.Text('{:4}'.format(str(level_4['create_time'])))
    460.             ]
    461.         ]
    462.         self.layout = header + body
    463.  
    464.     def run(self):
    465.         """启动游戏历史分数窗口"""
    466.         self.window = sg.Window(
    467.             title=self.title,
    468.             icon=Game_Info.GAME_ICON,
    469.             layout=self.layout,
    470.             font=('宋体', 20),
    471.             element_padding=(46, 30)
    472.         )
    473.         self.__event_handler()
    474.  
    475.     def __event_handler(self):
    476.         """窗口事件监听"""
    477.         while True:
    478.             event, value_dict = self.window.read()
    479.             print(event, value_dict)
    480.             if event in (sg.WIN_CLOSED, 'Quit'):
    481.                 self.parent_win.window.Enable()
    482.                 break
    483.         self.window.close()
    484.  
    485.  
    486. def main():
    487.     GameStartWin(title="Word Sprite").run()
    488.  
    489.  
    490. if __name__ == '__main__':
    491.     main()

    4）PyGame游戏精灵模块

    1. import pygame
    2. import random
    3. import Game_Info
    4. from Game_Info import GameConfig
    5.  
    6.  
    7. class BaseSprite(pygame.sprite.Sprite):
    8.     """游戏精灵基类"""
    9.     def __init__(self):
    10.         super().__init__()
    11.         self.image = None
    12.         self.rect = None
    13.  
    14.     def set_pos(self, x, y):
    15.         """设置精灵位置"""
    16.         self.rect.x = x
    17.         self.rect.y = y
    18.  
    19.     def hor_center(self, screen_rect):
    20.         """
    21.         水平居中显示
    22.         :param screen_rect: 游戏屏幕大小
    23.         :return:
    24.         """
    25.         x = screen_rect.width / 2 - self.rect.width / 2
    26.         self.set_pos(x, self.rect.y)
    27.  
    28.  
    29. class ImageSprite(BaseSprite):
    30.     """图片精灵基类"""
    31.  
    32.     def __init__(self, image):
    33.         super().__init__()
    34.         self.image = pygame.image.load(image)
    35.         self.rect = self.image.get_rect()
    36.  
    37.     def transform_scale(self, image, size: tuple):
    38.         """缩放图片大小"""
    39.         self.image = pygame.transform.scale(image, size)
    40.         self.rect = self.image.get_rect()
    41.  
    42.  
    43. class TextSprite(BaseSprite):
    44.     """文字精灵基类"""
    45.  
    46.     def __init__(self, text, size=Game_Info.WORD_SIZE, color=Game_Info.WHITE):
    47.         super().__init__()
    48.         self.text = text
    49.         self.size = size
    50.         self.color = color
    51.  
    52.         # 创建字体
    53.         self.font = pygame.font.Font(Game_Info.GAME_FONT, self.size)
    54.  
    55.         # 根据字体创建显示对象(文字)    render(self,text,antialias,color,background = None)
    56.         self.image = self.font.render(text, True, self.color)
    57.         self.rect = self.image.get_rect()
    58.  
    59.     def update(self, display_text):
    60.         """更新显示的文字"""
    61.         self.text = display_text
    62.         rect_x = self.rect.x
    63.         rect_y = self.rect.y
    64.         self.image = self.font.render(self.text, True, self.color)
    65.         self.rect = self.image.get_rect()
    66.         self.rect.x = rect_x
    67.         self.rect.y = rect_y
    68.  
    69.  
    70. class SpellSprite(TextSprite):
    71.     """文字精灵基类"""
    72.  
    73.     def __init__(self, text, size=Game_Info.WORD_SIZE, color=Game_Info.WORD_SPELL_OK_COLOR):
    74.         super().__init__(text, size, color)
    75.  
    76.     def update(self, display_text, color):
    77.         """更新拼写的单词"""
    78.         self.text = display_text
    79.         self.color = color
    80.         self.image = self.font.render(self.text, True, self.color)
    81.         self.rect = self.image.get_rect()
    82.         # 居中显示
    83.         self.hor_center(Game_Info.SCREEN_RECT)
    84.         self.set_pos(self.rect.x, 40)
    85.  
    86.  
    87. class WordSprite(TextSprite):
    88.     """单词精灵类"""
    89.     game_conf = GameConfig()
    90.  
    91.     def __init__(self, text, cn_comment, speed: float, size=28, color=Game_Info.WORD_COLOR):
    92.         super().__init__(text, size, color)
    93.         self.speed = speed              # 单词下落的速度
    94.         self.cn_comment = cn_comment    # 英文单词的意思
    95.         self.y = float(self.rect.y)     # 用小数存储单词降落的位置(方可设置成小数)
    96.  
    97.     def random_pos(self):
    98.         """随机位置"""
    99.         word_x = random.randint(0, Game_Info.SCREEN_RECT.width - self.rect.width)
    100.         word_y = random.randint(-50, 10)
    101.         self.rect.x = word_x
    102.         self.rect.y = word_y
    103.         self.y = float(self.rect.y)
    104.  
    105.     def update(self, game):
    106.         """更新单词精灵"""
    107.  
    108.         # 判断游戏是否暂停
    109.         if game.game_pause_flag:
    110.             self.speed = 0
    111.         else:
    112.             self.y += self.speed
    113.             self.rect.y = self.y
    114.  
    115.         # 超出游戏屏幕，删除精灵
    116.         if self.rect.y >= Game_Info.SCREEN_RECT.height:
    117.             self.kill()
    118.             # 根据不同游戏等级掉血
    119.             game.game_blood -= int(self.game_conf.game_level) * 3
    120.  
    121.         # 游戏配置信息改变，更新单词
    122.         self.size = int(self.game_conf.word_size)
    123.         self.font = pygame.font.Font(Game_Info.GAME_FONT, self.size)
    124.         self.speed = game.game_level_dict[int(self.game_conf.game_level)]['word_fall_speed']
    125.         self.color = pygame.color.Color(self.game_conf.word_normal_color)
    126.  
    127.         # 游戏分数是10的倍数单词下落速度提升
    128.         if game.total_score > 0 and game.total_score % 100 == 0:
    129.             self.speed += 0.5
    130.  
    131.         # 游戏血条在[45 - 50]区间单词下落速度提升
    132.         if 45 * 10 <= game.game_blood <= 50 * 10:
    133.             self.speed += 1
    134.  
    135.         # 拼写的字母与单词匹配
    136.         if len(str(game.word_content)) >= 1 and \
    137.                 str(game.word_content)[0].lower() in str(self.text)[0].lower() and \
    138.                 str(game.word_content).lower() in str(self.text).lower():
    139.             self.color = pygame.color.Color(self.game_conf.spell_ok_color)
    140.  
    141.         # 更新单词颜色
    142.         self.image = self.font.render(self.text, True, self.color)
    143.  
    144.  
    145. class Animation(object):
    146.     """动画特效类"""
    147.  
    148.     def __init__(self, screen):
    149.         """初始化动画资源"""
    150.         self.main_screen = screen
    151.         # 加载动画资源
    152.         self.images = [pygame.image.load(img) for img in Game_Info.KILL_ANIMATION]
    153.         # 设置当前动画播放索引
    154.         self.index = 0
    155.         # 动画播放间隔
    156.         self.interval = 2
    157.         self.interval_index = 0
    158.         # 动画位置
    159.         self.position = [0, 0]
    160.         # 是否可见
    161.         self.visible = False
    162.  
    163.     # 设置动画播放的位置
    164.     def set_pos(self, x, y):
    165.         self.position[0] = x
    166.         self.position[1] = y
    167.  
    168.     # 动画播放
    169.     def action(self):
    170.         # 如果爆炸对象状态不可见，则不计算坐标
    171.         if not self.visible:
    172.             return
    173.  
    174.         # 控制每一帧图片的播放间隔
    175.         self.interval_index += 1
    176.         if self.interval_index < self.interval:
    177.             return
    178.         self.interval_index = 0
    179.  
    180.         self.index = self.index + 1
    181.         if self.index >= len(self.images):
    182.             self.index = 0
    183.             self.visible = False
    184.  
    185.     # 绘制动画
    186.     def draw(self):
    187.         # 如果对象不可见，则不绘制
    188.         if not self.visible:
    189.             return
    190.         self.main_screen.screen.blit(self.images[self.index], (self.position[0], self.position[1]))
    191.  
    192.  
    193. def main():
    194.     pass
    195.  
    196.  
    197. if __name__ == '__main__':
    198.     pass

    五、效果展示

    1）游戏界面

    ​2）游戏设置

    ​3）随机截图

    （打字开始掉下来各种单词，打完之后还会出现相应的单词中文解释）

    4）游戏结束

    （相应的时间打英文单词一个单词一分，又背景音乐的哦🎵）

    1. 你们要找的英语意思在这里
    2.  
    3.  ▼
    4.  
    5.  
    6. 重誓
    7.  
    8. 因为你没把重誓守住，
    9.  
    10. 别的人成了我的朋友
    11.  
    12. 但是每一次我面对死亡，
    13.  
    14. 或者攀登梦想高处，
    15.  
    16. 或心情振奋，喝了点酒，
    17.  
    18. 突然间我总看见你脸庞.

    总结

    ​还有很多功能小编没有展示出来的啦~大家自己运行的时候可以一个一个看下子，嘿嘿~

    真的超级推荐这款游戏真的玩儿的时候音乐好听运行之后的界面也很好哦~

    科能是截图展示不了游戏本来的亚子，有点儿拉跨了，但是视频展示的话录制比较麻烦来着。

    （其实还是自己懒的弄视频的嘿嘿，勿怪勿怪）代码的哈找我记得撒👇

    老规矩，木子的文章汇总可以看到分类好的各种不同类型的文章，滴滴我大部分源码都在滴。

    🎯完整的免费源码领取处：找我吖！文末公众hao可自行领取，滴滴我也可！

    🔨推荐往期文章——

    项目4.7 电影订票选座系统

    【Python订票系统】这才是看电影选座的正确方法，原来我们都上当了~(选座位、一键购票)

    项目 3.9  码住雪景漫天飘雪小程序

    【Python码住雪景小程序】雪景人像最强攻略：让你一下美10倍、美醉了（中国人不骗中国人）

     项目 4.0 GIF制作神奇（斗罗大陆为例）

    【Python神器】推荐这款傻瓜式GIF制作工具，以后别再说不会了（好用到爆~）

    项目3.2  自动换壁纸

    【Python高级技能】超炫酷，电脑每天自动换壁纸，这个神器适合你。

    项目3.3  艺术字签名

    【艺术字签名生成器】】试卷家长签字居然被嫌弃了|“我觉得我还能再抢救一下，你看行嘛？“

    🎄文章汇总——

    汇总合集  Python—2022 |已有文章汇总 | 持续更新，直接看这篇就够了

    （更多内容+源码都在✨文章汇总哦！！欢迎阅读喜欢的文章🎉~）

  • 相关阅读:
    进程创建时自动打开的三个文件描述符
    跨时钟域（Clock Domain Crossing，CDC）
    第二十三章 使用任务管理器（一）
    flink 批处理和流式 wordcount
    A-LEVEL计算机科学得A*难吗？
    《面试八股文》之Zookeeper12卷
    企业微信服务商代开发应用验证CallBackUrl失败
    开发眼里的网络
    区分何时使用内连接或者外连接
    C语言，求一个整数的全部素数因子
  • 原文地址：https://blog.csdn.net/weixin_55822277/article/details/126311890