2020-11-08 Windows应用程序设计作业（Python版实现）（五）综合作业 - 汉字版俄罗斯方块+2048

Windows应用程序设计作业（Python版实现）

作业5-综合作业

要求：在作业3的基础上，每个方块随机设置偏旁部首或简单汉字。方块下落停止后，改变俄罗斯方块的消除规则。规则定义为：如果相邻的块能够构成一个汉字就消除这些块，合并为一个汉字；如果这些字能够组成一个成语、一句唐诗或宋词，就完全消除。数据文件不能存在本地，只能联网读取。
作业考察重点：访问网络文件，数据结构设计和存储数据，检索符合规则的数据。
参考网址：
1、汉字俄罗斯方块，你能过几关？https://zhuanlan.zhihu.com/p/120710579
2、简体拆字库，https://github.com/fighting41love/funNLP/blob/master/data/%E6%8B%86%E5%AD%97%E8%AF%8D%E5%BA%93/chaizi-jt.txt
3、成语词库，https://github.com/fighting41love/funNLP/blob/master/data/%E6%88%90%E8%AF%AD%E8%AF%8D%E5%BA%93/ChengYu_Corpus%EF%BC%885W%EF%BC%89.txt
4、诗词短句词库，https://github.com/fighting41love/funNLP/blob/master/data/%E8%AF%97%E8%AF%8D%E7%9F%AD%E5%8F%A5%E8%AF%8D%E5%BA%93/THUOCL_poem.txt

已实现：
版本一：汉字 -> 成语消去版（将可以组成成语的相邻汉字消去）
版本二：偏旁部首 -> 汉字消去不显示或消去后显示在画布中
版本三：先偏旁部首 -> 汉字，再由汉字 -> 成语 （先将可以构成汉字的偏旁部首消去，将组成的汉字显示在画布中，然后汉字相邻位置若有能组成成语的，则进行消去、加分操作

下面的这张是成语消去时的照片，和上面三张不是一次执行过程测试的，目的是为了显示右侧中会显示下一个文字或偏旁部首~

第三版本的部分代码
（一）board_operation.py

from tetris_initialize import Status
from tetris_shape import Tetris_shape
import random

class Board_op:

    def __init__(self, tetris, nw_canvas, option = False):  
        self.tetris = tetris
        self.nw_canvas = nw_canvas
        self.R, self.C, self.cell_size = tetris.R, tetris.C, tetris.cell_size
        self.height, self.width = tetris.R * tetris.cell_size, tetris.C * tetris.cell_size
        self.screenwidth, self.screenheight = tetris.win.winfo_screenwidth(), tetris.win.winfo_screenheight() 
        self.opt = option                

    def draw_cell_by_cr(self, canvas, c, r, color="lightgray"):
        x0, y0 = c * self.cell_size, r * self.cell_size  
        x1, y1 = c * self.cell_size  + self.cell_size, r * self.cell_size + self.cell_size      
        canvas.create_rectangle(x0, y0, x1, y1, fill = color, outline = "white", width = 2)     
    
    def draw_cell_by_cr_word(self, canvas, c, r, word, color="lightgray"):
        x0, y0 = c * self.cell_size, r * self.cell_size  
        x1, y1 = c * self.cell_size  + self.cell_size, r * self.cell_size + self.cell_size      
        canvas.create_rectangle(x0, y0, x1, y1, fill = color, outline = "white", width = 2)     
        canvas.create_text((x0 + 15, y0 + 15), text = word, font = ('华文新魏', 20, 'bold'), fill = 'black')

    def draw_cells(self, canvas, c, r, cell_list, color = "lightgray", show = False):
        for cell in cell_list:
            cell_c, cell_r = cell
            ci, ri = cell_c + c, cell_r + r
            if 0 <= c < self.C and 0 <= r < self.R :              
                self.draw_cell_by_cr(canvas, ci, ri, color)
            if show is True:
                self.draw_cell_by_cr(canvas, ci, ri, color) 

    def draw_board(self, canvas, inner = False):
        for ri in range(self.R):
            for ci in range(self.C):
                word_type = Status.block_list[ri][ci]    
                if not self.opt:      
                    if word_type:
                        self.draw_cell_by_cr(canvas, ci, ri,Tetris_shape.SHAPESCOLOR[word_type])
                    else:
                        self.draw_cell_by_cr(canvas, ci, ri)
                else:
                    if word_type:
                        self.draw_cell_by_cr_word(canvas, ci, ri, word_type, Status.radical_color[ri][ci])
                    else:
                        self.draw_cell_by_cr_word(canvas, ci, ri, '')  
        if inner:
            for ri in range(4, 8):
                for ci in range(13, 17):
                    self.draw_cell_by_cr_word(canvas, ci, ri, '',color = "white")   
                    self.draw_cell_by_cr(canvas, ci, ri, color = "white")       
        else:
            for ri in range(3, 9):
                for ci in range(12, 18):
                    self.draw_cell_by_cr_word(canvas, ci, ri, '',color = "white")     
                    self.draw_cell_by_cr(canvas, ci, ri, color = "white")  

（二）tetris_operation.py

from tetris_initialize import Status
from tetris_shape import Tetris_shape
from board_operation import Board_op
import tkinter.messagebox
import tkinter as tk
import pyautogui 
import random

class Tetris_op:
    
    def __init__(self, tetris, nw_canvas, board_op):
        self.tetris = tetris
        self.nw_canvas = nw_canvas
        self.board_op = board_op
        self.R, self.C, self.cell_size = tetris.R, tetris.C, tetris.cell_size
        self.height, self.width = tetris.R * tetris.cell_size, tetris.C * tetris.cell_size
        self.screenwidth, self.screenheight = tetris.win.winfo_screenwidth(), tetris.win.winfo_screenheight() 

    def draw_block_move(self, canvas, block, direction = [0, 0]):
        shape_type = block['kind']          
        cell_list = block['cell_list']      
        c, r = block['cr']                    
        self.board_op.draw_cells(canvas, c, r, cell_list)    
        dc, dr = direction                
        new_c, new_r = c + dc, r + dr       
        block['cr'] = [new_c, new_r]       
        self.board_op.draw_cells(canvas, new_c, new_r, cell_list, Tetris_shape.SHAPESCOLOR[shape_type])    

    def generate_new_block(self):       
        cr = [self.C//2, 0]   
        new_block = {
            'kind': Status.next_block['kind'],                        
            'cell_list': Status.next_block['cell_list'],        
            'cr': cr                               
        }
        if Status.flag_clear is True:
            pre_shape_type = Status.next_block['kind']
            pre_cell_list = Status.next_block['cell_list']
            pre_c, pre_r = Status.next_block['cr']
            for cell in pre_cell_list:
                cell_c, cell_r = cell
                ci = cell_c + pre_c
                ri = cell_r + pre_r
                x0 = ci * self.cell_size                   
                y0 = ri * self.cell_size  
                x1 = ci * self.cell_size  + self.cell_size 
                y1 = ri * self.cell_size + self.cell_size
                self.nw_canvas.create_rectangle(x0, y0, x1, y1, fill = "white", outline = "white", width = 2) 
            Status.flag_clear = False
        Status.next_block = self.generate_next_block()
        self.draw_next_block(self.nw_canvas, Status.next_block, Status.next_block_pre)
        return new_block

    def generate_next_block(self):
        kind = random.choice(list(Tetris_shape.SHAPES.keys()))
        next_cr = [15, 6]
        next_tetris_block = {
            'kind': kind,
            'cell_list': Tetris_shape.SHAPES[kind],
            'cr': next_cr
        }
        return next_tetris_block

    def draw_next_block(self, canvas, block, block_pre):
        shape_type = block['kind']                
        cell_list = block['cell_list']            
        c, r = block['cr']    
        for cell in cell_list:
            cell_c, cell_r = cell
            ci = cell_c + c
            ri = cell_r + r
            x0 = ci * self.cell_size                  
            y0 = ri * self.cell_size  
            x1 = ci * self.cell_size  + self.cell_size 
            y1 = ri * self.cell_size + self.cell_size
            canvas.create_rectangle(x0, y0, x1, y1, fill = Tetris_shape.SHAPESCOLOR[shape_type], outline = "white", width = 2) 

    def check_move(self, block, direction=[0, 0]):
        cc, cr = block['cr']
        cell_list = block['cell_list']
        for cell in cell_list:
            cell_c, cell_r = cell
            c = cell_c + cc + direction[0]
            r = cell_r + cr + direction[1]
            if c < 0 or c >= self.C or r >= self.R:
                return False
            if r >= 0 and Status.block_list[r][c]:
                return False
        return True

    def save_block_to_list(self, block):
        shape_type = block['kind']
        cell_list = block['cell_list']
        cc, cr = block['cr']
        for cell in cell_list:
            cell_c, cell_r = cell
            c = cell_c + cc
            r = cell_r + cr
            Status.block_list[r][c] = shape_type

    def check_and_clear(self):
        has_complete_row = False
        for ri in range(len(Status.block_list)):
            jd_complete_row = True
            for ci in Status.block_list[ri]:
                if ci == '':
                    jd_complete_row = False
            if jd_complete_row:
                has_complete_row = True
                if ri > 0:
                    for cur_ri in range(ri, 0, -1):
                        Status.block_list[cur_ri] = Status.block_list[cur_ri - 1][:]
                    Status.block_list[0] = ['' for j in range(self.C)]
                else: 
                    Status.block_list[ri] = ['' for j in range(self.C)]
                Status.score += 10 
        if has_complete_row:
            self.board_op.draw_board(self.nw_canvas, True)
            self.nw_canvas.delete('SCORE')
            score_str = str(Status.score)
            self.nw_canvas.create_text((15 * self.cell_size, 3 * (self.height / 4) ), text = score_str, font = ('Helvetica', 80, 'bold'), fill = 'DarkCyan', tag = 'SCORE')  

    def game_loop(self):
        if Status.mouse_click == 1:
            x, y = (self.screenwidth - self.width)/2 + 100 , (self.screenheight - self.height)/2 + 100
            pyautogui.moveTo(x, y)        
            pyautogui.click()             
            Status.mouse_click += 1
            Status.next_block_pre = self.generate_next_block()   
            Status.next_block = Status.next_block_pre
        if Status.current_block is None:
            Status.new_block = self.generate_new_block()
            self.draw_block_move(self.nw_canvas, Status.new_block)    
            Status.current_block = Status.new_block
            if not self.check_move(Status.current_block, [0, 0]):
                tk.messagebox.showinfo("Game Over！","Your Score is %s " % Status.score)
                self.tetris.win.destroy()                     
                return                       
        else:
            if self.check_move(Status.current_block, [0, 1]):              
                self.draw_block_move(self.nw_canvas, Status.current_block, [0, 1]) 
            else:     
                self.save_block_to_list(Status.current_block)          
                Status.flag_clear = True                                
                Status.current_block = None                               
        self.check_and_clear()                                         
        self.tetris.win.after(Status.FPS, self.game_loop)

（三）main.py

from tetris_initialize import Tetris_init
from tetris_initialize import Status
from tetris_bg_show import Background_show
from idiom_data import Idiom_data
from word_data import Word_data
from PIL import ImageTk,Image
import tkinter as tk

f1 = open('0_test_data_idiom6.txt','r', encoding = 'utf-8-sig')     
f2 = open('0_test_data_word21.txt','r', encoding = 'utf-8-sig')     
iid_data = Idiom_data(f1, Status.word_list_shuffle, Status.idiom_dictionary)
wid_data = Word_data(f2, Status.radical_list_shuffle, Status.word_dictionary)
iid_data.get_idiom_data()
wid_data.get_shape_change_rule()
win = tk.Tk()
tetris = Tetris_init(win, 20, 12, 30, 400)   # R，C，cell_size，FPS
img = ImageTk.PhotoImage(Image.open(r'F:\2020_C#_assignments\background.gif'))
bk_canvas = Background_show(win, tetris, img)
bk_canvas.BK_canvas()
win.mainloop()

（四）word_data.py

from tetris_initialize import Status 
from tetris_shape import Tetris_shape    
from idiom_data import Idiom_data    
import string
import random

class Word_data:

    def __init__(self, f, list_shuffle, dictionary):
        self.f = f
        self.list_shuffle = list_shuffle
        self.dictionary = dictionary
        self.new_five_blocks = {}

    def get_word_data(self):
        lines = self.f.readlines()            
        for i in range(0, lines.__len__(), 1):     
            word = []                         
            word_list = []     
            for wi in lines[i].split():
                wi = wi.strip(string.whitespace)
                word.append(wi)
            word_cut = word[1:]
            for wci in word_cut:
                self.list_shuffle.append(wci)
            word_cut.sort()
            self.dictionary[str(word_cut)] = word[0]
        random.shuffle(self.list_shuffle)

    def get_rorate_list(self, cell_list, key):
        for i in range(4):
            new_rorate_list = []
            for cell in cell_list:
                cell_c, cell_r = cell
                rorate_cell = (cell_r, -cell_c)
                new_rorate_list.append(rorate_cell)
            new_rorate_list.sort()
            k_cnt = i + 1
            self.new_five_blocks[key + str(k_cnt)] = new_rorate_list
            rorate_list = new_rorate_list

那写看似毫无波澜的日复一日，会在某一天 让你突然发现努力的意义。
无悔昨天 & 感谢今天 & 喜欢明天~

一以贯之的努力，不得懈怠的人生。每天的微小积累，会决定最终的结果，这 就是答案！