# !/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è)置游戲窗口相對(duì)電腦屏幕居中"""
    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():
    """隨機(jī)播放背景音樂"""
    # 判斷是否是靜音模式
    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("無法加載音頻，請(qǐng)檢查電腦配置" + 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            # 用于標(biāo)識(shí)單詞拼寫成功
    game_pause_flag = False     # 游戲暫停標(biāo)志
    game_over_flag = False      # 游戲結(jié)束標(biāo)志
    game_quit_flag = False      # 游戲退出標(biāo)志
    game_total_blood = Game_Info.GAME_BLOOD_RECT.width  # 游戲總能量(血條)
 
    # 游戲等級(jí)對(duì)照字典
    game_level_dict = {
        1: {"word_fall_speed": 0.3, "level_text": u"簡(jiǎn)單", "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è)置游戲標(biāo)題和圖標(biāo)
        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)建單詞的定時(shí)器
        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                    # 游戲默認(rèn)音量
        self.use_time = 0                               # 記錄游戲使用的時(shí)間
        self.total_score = 0                            # 記錄游戲拼寫成功了多少個(gè)單詞
        self.word_content = ""                          # 鍵盤輸入的單詞
        self.backspace_count = 0                        # 回刪鍵按下的次數(shù)
 
        # 預(yù)先創(chuàng)建動(dòng)畫對(duì)象
        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ù)游戲屏幕的大小適配背景圖(可能會(huì)導(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)建顯示游戲時(shí)間精靈
        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)
 
        # 游戲分?jǐn)?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"游戲等級(jí): " + 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"游戲分?jǐn)?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)
 
        # 計(jì)算游戲使用時(shí)間
        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("游戲等級(jí): " + 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()
 
        # 單詞精靈拼寫成功動(dòng)畫
        for animate in self.animates:
            if animate.visible:
                animate.draw()
 
    def start_game(self):
        """打字游戲開啟"""
        # 隨機(jī)播放背景音樂
        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é)束且沒有音樂在播放就隨機(jī)下一首
                    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)
 
            # 鼠標(biāo)移動(dòng)事件
            elif event.type == pygame.MOUSEMOTION:
                x, y = event.pos  # 獲取屏幕坐標(biāo)位置
                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é)束鼠標(biāo)懸浮在確定按鈕上變色
                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é)束鼠標(biāo)懸浮在重玩按鈕上變色
                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)
 
            # 鼠標(biāo)點(diǎn)擊事件
            elif event.type == pygame.MOUSEBUTTONDOWN:
                x, y = event.pos  # 獲取屏幕坐標(biāo)位置
 
                # 點(diǎn)擊游戲設(shè)置
                if self.__is_on_set(x, y):
                    # 判斷游戲是否暫停
                    if not self.game_pause_flag:
                        TypingGame.game_pause_flag = True
 
                # 游戲結(jié)束鼠標(biāo)點(diǎn)擊退出按鈕
                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é)束鼠標(biāo)點(diǎn)擊重玩按鈕
                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:
                # 英文單引號(hào)的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:
                        # 如果單詞拼寫成功再按下鍵盤時(shí)清空內(nèi)容
                        self.word_content = ""
                        self.spell_ok = False
 
                    # 控制單詞長(zhǎng)度
                    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
 
        # 實(shí)現(xiàn)長(zhǎng)按backspace連續(xù)回刪
        # 使用鍵盤提供的方法獲取鍵盤按鍵 - 按鍵元組
        keys_pressed = pygame.key.get_pressed()
 
        # 判斷元組中對(duì)應(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 鼠標(biāo)的位置
        """
        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:
                # 如果單詞拼寫成功再按下鍵盤回刪鍵時(shí)清空內(nèi)容
                self.word_content = ""
                self.spell_ok = False
 
    def __random_generate_word(self, word_num=5):
        """
        隨機(jī)生成單詞精靈
        :param word_num:精靈數(shù)量 默認(rèn)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))
            )
 
            # 單詞位置隨機(jī)
            word_sprite.random_pos()
 
            # 檢查新單詞精靈是否與單詞精靈組中的精靈碰撞(重疊)
            words = pygame.sprite.spritecollide(
                word_sprite, self.word_group, False,
                pygame.sprite.collide_circle_ratio(1)
            )
 
            # 碰撞(釋放內(nèi)存重新隨機(jī)生成單詞精靈)
            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"游戲分?jǐn)?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)建完畢的動(dòng)畫中取出一個(gè)動(dòng)畫對(duì)象
                for animate in self.animates:
                    if not animate.visible:
                        # 設(shè)置動(dòng)畫位置
                        animate.set_pos(word_sprite.rect.x, word_sprite.rect.y)
                        # 動(dòng)畫對(duì)象狀態(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ù)不同游戲等級(jí)掉血
                self.game_clock.tick(int(self.game_conf.game_level))
                self.game_blood -= 1
 
    def __animate_action(self):
        """開啟單詞拼寫成功動(dòng)畫"""
        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()
    # 啟動(dòng)游戲開始界面
    GameStartWin(title="Word Sprite").run()
 
 
if __name__ == '__main__':
    main()

# !/usr/bin/env python
# -*- coding: utf-8 -*-
import ctypes
import pygame
import configparser
 
 
class GameConfig(object):
    """游戲配置文件類"""
 
    GAME_INFO = "game_info"                     # 配置文件游戲信息結(jié)點(diǎn)名稱
    GAME_STYLE = "game_style"                   # 配置文件游戲樣式結(jié)點(diǎn)名稱
    GAME_SCORE = "game_score"                   # 配置文件游戲分?jǐn)?shù)結(jié)點(diǎn)名稱
 
    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          # 游戲等級(jí)
        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è)置游戲等級(jí)"""
        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}           # 游戲困難等級(jí)與單詞下落速度相互匹配字典
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"     # 游戲單詞文本
 
# 單詞拼寫成功后的消失動(dòng)畫
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)建單詞的時(shí)間間隔(毫秒)
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()

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):
        """啟動(dòng)游戲開始窗口"""
        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):
    """游戲運(yùn)行窗口"""
    pass
 
 
class GameEndWin(object):
    """游戲結(jié)束窗口"""
 
    def __init__(self):
        pass
 
 
class GameSetWin(BaseWin):
    """游戲配置信息窗口"""
 
    # 游戲等級(jí)對(duì)照字典
    game_level_dict = {
        1: {"game_level_num": 5, "game_level_text": u"簡(jiǎn)單", "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'游戲難度等級(jí):', 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'暫時(shí)保存', 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':
                # 點(diǎn)擊按鈕切換游戲等級(jí)
                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()  # 讓游戲配置窗口不可用，不讓用戶亂點(diǎn)擊，防止多開
                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()  # 讓游戲配置窗口不可用，不讓用戶亂點(diǎn)擊，防止多開
                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):
        """臨時(shí)保存游戲配置信息(臨時(shí)有效，重開還原)"""
        """
               {
                   '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):
    """游戲歷史分?jǐn)?shù)窗口"""
    heads = [
        '{:4}'.format(u'游戲等級(jí)'),
        '{:4}'.format(u'最高分'),
        '{:6}'.format(u'耗 時(shí)'),
        '{:4}'.format(u'創(chuàng)建時(shí)間'),
    ]
    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'簡(jiǎn)單', 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):
        """啟動(dòng)游戲歷史分?jǐn)?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()

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)建顯示對(duì)象(文字)    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ù)存儲(chǔ)單詞降落的位置(方可設(shè)置成小數(shù))
 
    def random_pos(self):
        """隨機(jī)位置"""
        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ù)不同游戲等級(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)
 
        # 游戲分?jǐn)?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):
    """動(dòng)畫特效類"""
 
    def __init__(self, screen):
        """初始化動(dòng)畫資源"""
        self.main_screen = screen
        # 加載動(dòng)畫資源
        self.images = [pygame.image.load(img) for img in Game_Info.KILL_ANIMATION]
        # 設(shè)置當(dāng)前動(dòng)畫播放索引
        self.index = 0
        # 動(dòng)畫播放間隔
        self.interval = 2
        self.interval_index = 0
        # 動(dòng)畫位置
        self.position = [0, 0]
        # 是否可見
        self.visible = False
 
    # 設(shè)置動(dòng)畫播放的位置
    def set_pos(self, x, y):
        self.position[0] = x
        self.position[1] = y
 
    # 動(dòng)畫播放
    def action(self):
        # 如果爆炸對(duì)象狀態(tài)不可見，則不計(jì)算坐標(biāo)
        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
 
    # 繪制動(dòng)畫
    def draw(self):
        # 如果對(duì)象不可見，則不繪制
        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