Python代码实现2048-功能拓展

本文是在200 行 Python 代码实现 2048的功能基础上进行的拓展功能开发

具体增加功能如下:

1.增加支持方向键
2.达到胜利分数值可以选择继续游戏或者结束游戏
3.在控制台输出不同的颜色
4.连接sqlite,将最高成绩存入其中,每次启动游戏时读取

完整代码如下:

#-*- coding:utf-8 -*-

import curses
from random import randrange, choice # generate and place new tile
from collections import defaultdict
from itertools import chain
import sqlite3
from colorama import init

init(autoreset=True)

#有效健值列表
letter_codes = [ord(ch) for ch in 'WASDRQYwasdrqy']
#print(letter_codes)#打印结果为WASDRQwasdrq对应的ascii码
letter_list=[259,260,258,261,10,27,121]#上左下右EscEnterY键对应的ascii码,通过get_user_action中的char来获取
letter_codes=letter_codes+letter_list

#用户行为
actions = ['Up', 'Left', 'Down', 'Right', 'Restart', 'Exit','Continue']
#将输入与行为进行关联
actions_dict = dict(zip(letter_codes, actions * 3))

#sqlite数据库操作,读取最高分数
class sqliteOperate():
    def __init__(self):
        self.conn=sqlite3.connect('2048.db')
        
    def select(self):
        score=self.conn.execute("select SCORE from HighScore")
        for row in score:
            return row[0]
            
    def update(self,score):
        self.conn.execute("update HighScore set SCORE ={0} where ID=1".format(score))
        self.conn.commit()
        self.conn.close() 
        
sqliteoperate=sqliteOperate()              
Highscore=sqliteoperate.select()

#用户输入处理
def get_user_action(keyboard):    
    char = "N"
    #阻塞+循环,直到获得用户有效输入才返回对应行为
    while char not in actions_dict:    
        char = keyboard.getch()#从控制台读取一个字符,但不显示在屏幕上
#         print(char)#通过这里打印对应按键的数字找到上下左右等按键的对应的ascii码
    return actions_dict[char]

#矩阵转置,行和列的转换
def transpose(field):
    return [list(row) for row in zip(*field)]

#矩阵逆转,每行倒着排列
def invert(field):
    return [row[::-1] for row in field]

#创建棋盘
class GameField(object):
    def __init__(self, height=4, width=4, win=8):
        self.height=height #高
        self.width=width  #宽
        self.win_value=8   #过关分数
        self.score=0   #当前分数
        self.highscore=Highscore  #从数据库获取最高分
        self.reset()   #棋盘重置
    
    ##重置棋盘
    def reset(self):
        if self.score > self.highscore:
            self.highscore = self.score
            sqliteoperate.update(self.highscore) 
        self.score = 0        
        self.field = [[0 for i in range(self.width)] for j in range(self.height)]#创建一个4*4值全为0的二维数组
        self.spawn()#棋盘上初始状态显示2个数字,随机生成两个数字,调两次spawn方法
        self.spawn()

    def move(self, direction):
        #一行向左合并   
        def move_row_left(row):
            def tighten(row): #squeese non-zero elements together
                #把零散的非零单元挤到一块,先打印出非零的元素,然后在后面空白位置补0
                new_row = [i for i in row if i != 0]
                new_row += [0 for i in range(len(row) - len(new_row))]
                return new_row

            def merge(row):#对邻近元素进行合并
                pair = False
                new_row = []
                for i in range(len(row)):
                    if pair:
                        new_row.append(2 * row[i])
                        self.score += 2 * row[i]
                        pair = False
                    else:
                        if i + 1 < len(row) and row[i] == row[i + 1]:
                            pair = True
                            new_row.append(0)
                        else:
                            new_row.append(row[i])
                assert len(new_row) == len(row)#assert断言是声明其布尔值必须为真的判定,如果发生异常就说明表达示为假
                return new_row
            #先挤到一块再合并再挤到一起
            return tighten(merge(tighten(row)))

        moves = {}
        moves['Left']  = lambda field:                              \
                [move_row_left(row) for row in field]
        moves['Right'] = lambda field:                              \
                invert(moves['Left'](invert(field)))
        moves['Up']    = lambda field:                              \
                transpose(moves['Left'](transpose(field)))
        moves['Down']  = lambda field:                              \
                transpose(moves['Right'](transpose(field)))

        if direction in moves:
            if self.move_is_possible(direction):
                self.field = moves[direction](self.field)
                self.spawn()
                return True
            else:
                return False

    def is_win(self):
        #any(x)判断x对象是否为空对象,如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true
        #遍历每个元素查看是否大于win_value
#         return any(any(i >= self.win_value for i in row) for row in self.field)
        #找出当前二维数组中的最大值与win_value比较
        #chain把二维数组转化成序列
#         print(max(chain(*self.field)),self.win_value)
        return max(chain(*self.field))>=self.win_value
        
        
        
    def is_gameover(self):
        #所有的行都不能移动则游戏结束
        return not any(self.move_is_possible(move) for move in actions)

    def draw(self, screen):
#         init(autoreset=True)
        help_string1 = '(↑)Up(↓)Down(←)Left(→)Right'
        help_string2 = '   (Enter)Restart (Esc)Exit'
        help_string3 = '(Enter)Restart(Y)Continue(Esc)Exit'
        gameover_string = '           GAME OVER'
        win_string = '          YOU WIN!'           
        
        def set_color():#设置颜色
            #使用颜色首先需要调用这个方法
            curses.start_color()    
            #文字和背景色设置,设置了三个color pair,分别为1,2,3
            curses.init_pair(1,curses.COLOR_YELLOW,curses.COLOR_BLACK)
            curses.init_pair(2,curses.COLOR_GREEN,curses.COLOR_BLACK)
            curses.init_pair(3,curses.COLOR_RED,curses.COLOR_BLACK)
        
        
        def cast(string):#绘制字符串      
#             screen.addstr(string+ '\n')     
            set_color()
            screen.addstr(string+ '\n',curses.color_pair(1))

            
        def cast2(string):#绘制字符串 ,成功时显示绿色的提示语     
#             curses.start_color()
            set_color()
            screen.addstr(string+ '\n',curses.color_pair(2))

        def cast3(string):#将分数和最高分显示为红色   
#             curses.start_color()
            set_color()
            screen.addstr(string+ '\n',curses.color_pair(3))
         
            
        def draw_hor_separator():#绘制分割线
#             line = '+' + ('+------' * self.width + '+')[1:]
            line =  ('+------' * self.width + '+')
            separator = defaultdict(lambda: line)#创建一个字典,默认值为line
            if not hasattr(draw_hor_separator, "counter"):#hasattr判断draw_hor_separator对象中是否存在counter属性,有为True,没有False
                draw_hor_separator.counter = 0
            cast(separator[draw_hor_separator.counter])
            draw_hor_separator.counter += 1

        def draw_row(row):#绘制包含数字的行
            #^是居中显式,<是左对齐,>是右对齐,冒号后面有一个空格,意思是空格填充
            #如果单元格中数字大于0,则将该数字格式化为居中显示,否者仅打印斜杠和空格
            cast(''.join('|{: ^5} '.format(num) if num > 0 else '|      ' for num in row) + '|')

        screen.clear()
        
        cast3('SCORE: ' + str(self.score))#绘制当前分数
     
        cast3('HIGHSCORE: ' + str(self.highscore))#绘制当前最高分数
#         if 0 != self.highscore:#绘制最高分
#             cast('HIGHSCORE: ' + str(self.highscore))
        for row in self.field:#遍历二维数组绘制4*4棋盘
            draw_hor_separator()
            draw_row(row)
        draw_hor_separator()
        
        if self.is_win():
            cast2(win_string)
            cast(help_string3)
        else:
            if self.is_gameover():
                cast(gameover_string)
            else:
                cast(help_string1)
            cast(help_string2)

    def spawn(self):
        new_element = 4 if randrange(100) > 89 else 2#9:1的比例生成2或4
        #通过choice随机选择一个未被占领的位置来放置new_element
        (i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[i][j] == 0])
        self.field[i][j] = new_element

    def move_is_possible(self, direction):
        def row_is_left_movable(row): 
            def change(i): # true if there'll be change in i-th tile
                if row[i] == 0 and row[i + 1] != 0: # Move
                    return True
                if row[i] != 0 and row[i + 1] == row[i]: # Merge
                    return True
                return False
            return any(change(i) for i in range(len(row) - 1))#判断是否有任意一行可以向左移动

        check = {}
        check['Left']  = lambda field:                              \
                any(row_is_left_movable(row) for row in field)

        check['Right'] = lambda field:                              \
                 check['Left'](invert(field))

        check['Up']    = lambda field:                              \
                check['Left'](transpose(field))

        check['Down']  = lambda field:                              \
                check['Right'](transpose(field))

        if direction in check:
            return check[direction](self.field)
        else:
            return False

def main(stdscr):#stdscr由curses传入,主要用于命令行的操作
    def init():
        #重置游戏棋盘
        game_field.reset()
        return 'Game'

    def not_game(state):#胜利或失败的状态
        #画出 GameOver 或者 Win 的界面
        game_field.draw(stdscr)
        #读取用户输入得到action,判断是重启游戏还是结束游戏
        action = get_user_action(stdscr)
        responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
        responses['Restart'], responses['Exit'],responses['Continue'] = 'Init', 'Exit','Continue' #对应不同的行为转换到不同的状态
        return responses[action]

    def game():
        #画出当前棋盘状态
        game_field.draw(stdscr)
        #读取用户输入得到action
        action = get_user_action(stdscr)
        
        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if game_field.move(action): # move successful
            if game_field.is_win():
                if action=='Continue':
                    return 'Continue'
                else:
                    return 'Win'
            if game_field.is_gameover():
                return 'Gameover'
        return 'Game'    
    
    def game_suc():
        #画出游戏成功后当前棋盘状态
        game_field.draw(stdscr)
        #读取用户输入得到action
        action = get_user_action(stdscr)

        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if game_field.move(action): # move successful            
            return 'GameSuc'
        return 'GameSuc'
    
    def game_continue():#达到胜利分数值选择继续游戏
        game_field.draw(stdscr)
#         #读取用户输入得到action
        action = get_user_action(stdscr)
        
        if game_field.move(action): # move successful
            if game_field.is_gameover():
                return 'Gameover'
            else: 
                return 'GameSuc'
        return 'GameSuc'
                
    state_actions = {
            'Init': init,
            'Win': lambda: not_game('Win'),
            'Gameover': lambda: not_game('Gameover'),
            'Game': game,
            'Continue':game_continue,
            'GameSuc':game_suc            
        }

    curses.use_default_colors()

    # 设置终结状态最大数值为 8
    game_field = GameField(win=8)

    state = 'Init'

    #状态机开始循环
    while state != 'Exit':
        state = state_actions[state]()


#curses库提供了控制字符屏幕的独立于终端的方法
#不能用任何IDE来运行有curses包的python文件,否则提示Redirection is not supported.
curses.wrapper(main) #初始化curses

运行结果

初始化页面:

Python代码实现2048-功能拓展_第1张图片

胜利页面:

Python代码实现2048-功能拓展_第2张图片

用面向对象方法重构代码

#-*- coding:utf-8 -*-

import curses
from random import randrange, choice # generate and place new tile
from collections import defaultdict
from itertools import chain
import sqlite3
from colorama import init

class Action():
    #有效健值列表
    letter_codes = [ord(ch) for ch in 'WASDRQYwasdrqy']
    #print(letter_codes)#打印结果为WASDRQwasdrq对应的ascii码
    letter_list=[259,260,258,261,10,27,121]#上左下右EscEnterY键对应的ascii码,通过get_user_action中的char来获取
    letter_codes=letter_codes+letter_list
    
    #用户行为
    actions = ['Up', 'Left', 'Down', 'Right', 'Restart', 'Exit','Continue']
    #将输入与行为进行关联
    actions_dict = dict(zip(letter_codes, actions * 3))
    
    def __init__(self):
        pass
    
    #用户输入处理
    def get_user_action(self,keyboard):    
        char = "N"
        #阻塞+循环,直到获得用户有效输入才返回对应行为
        while char not in self.actions_dict:    
            char = keyboard.getch()#从控制台读取一个字符,但不显示在屏幕上
    #         print(char)#通过这里打印对应按键的数字找到上下左右等按键的对应的ascii码
        return self.actions_dict[char]

#sqlite数据库操作,读取最高分数
class sqliteOperate():
    def __init__(self):
        self.conn=sqlite3.connect('2048.db')
        
    def select(self):
        score=self.conn.execute("select SCORE from HighScore")
        for row in score:
            return row[0]
            
    def update(self,score):
        self.conn.execute("update HighScore set SCORE ={0} where ID=1".format(score))
        self.conn.commit()
        self.conn.close() 
        
#创建棋盘
class GameField(object):
    
    def __init__(self, height=4, width=4,win=0):
        self.height=height #高
        self.width=width  #宽
        self.win_value=win  #过关分数
        self.score=0   #当前分数
        self.highscore=Highscore  #从数据库获取最高分
        self.reset()   #棋盘重置
        self.action=Action()
    
    #如果该方法没有引用对象的资源,可以采用静态方法,并且不需要传入self
    @staticmethod
    #矩阵转置,行和列的转换
    def transpose(field):
        return [list(row) for row in zip(*field)]
    
    @staticmethod
    #矩阵逆转,每行倒着排列
    def invert(field):
        return [row[::-1] for row in field]
        
    #重置棋盘
    def reset(self):
        if self.score > self.highscore:
            self.highscore = self.score
            sqliteoperate.update(self.highscore) #更新数据库中的最高分
        self.score = 0        
        self.field = [[0 for i in range(self.width)] for j in range(self.height)]#创建一个4*4值全为0的二维数组
        self.spawn()#棋盘上初始状态显示2个数字,随机生成两个数字,调两次spawn方法
        self.spawn()
    
    def spawn(self):
        new_element = 4 if randrange(100) > 89 else 2#9:1的比例生成2或4
        #通过choice随机选择一个未被占领的位置来放置new_element
        (i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[i][j] == 0])
        self.field[i][j] = new_element
    
    def move(self, direction):
        #一行向左合并   
        def move_row_left(row):
            def tighten(row): #squeese non-zero elements together
                #把零散的非零单元挤到一块,先打印出非零的元素,然后在后面空白位置补0
                new_row = [i for i in row if i != 0]
                new_row += [0 for i in range(len(row) - len(new_row))]
                return new_row

            def merge(row):#对邻近元素进行合并
                pair = False
                new_row = []
                for i in range(len(row)):
                    if pair:
                        new_row.append(2 * row[i])
                        self.score += 2 * row[i]
                        pair = False
                    else:
                        if i + 1 < len(row) and row[i] == row[i + 1]:
                            pair = True
                            new_row.append(0)
                        else:
                            new_row.append(row[i])
                assert len(new_row) == len(row)#assert断言是声明其布尔值必须为真的判定,如果发生异常就说明表达示为假
                return new_row
            #先挤到一块再合并再挤到一起
            return tighten(merge(tighten(row)))

        moves = {}
        moves['Left']  = lambda field:                              \
                [move_row_left(row) for row in field]
        moves['Right'] = lambda field:                              \
                self.invert(moves['Left'](self.invert(field)))
        moves['Up']    = lambda field:                              \
                self.transpose(moves['Left'](self.transpose(field)))
        moves['Down']  = lambda field:                              \
                self.transpose(moves['Right'](self.transpose(field)))

        if direction in moves:
            if self.move_is_possible(direction):
                self.field = moves[direction](self.field)
                self.spawn()
                return True
            else:
                return False
    
    def move_is_possible(self, direction):
        def row_is_left_movable(row): 
            def change(i): # true if there'll be change in i-th tile
                if row[i] == 0 and row[i + 1] != 0: # Move
                    return True
                if row[i] != 0 and row[i + 1] == row[i]: # Merge
                    return True
                return False
            return any(change(i) for i in range(len(row) - 1))#判断是否有任意一行可以向左移动
        
        check = {}
        check['Left']  = lambda field:                              \
                any(row_is_left_movable(row) for row in field)

        check['Right'] = lambda field:                              \
                 check['Left'](self.invert(field))

        check['Up']    = lambda field:                              \
                check['Left'](self.transpose(field))

        check['Down']  = lambda field:                              \
                check['Right'](self.transpose(field))

        if direction in check:
            return check[direction](self.field)
        else:
            return False       
        
    def is_win(self):
        #any(x)判断x对象是否为空对象,如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true
        #遍历每个元素查看是否大于win_value
#         return any(any(i >= self.win_value for i in row) for row in self.field)
        #找出当前二维数组中的最大值与win_value比较
        #chain把二维数组转化成序列
#         print(max(chain(*self.field)),self.win_value)
        return max(chain(*self.field))>=self.win_value        
        
    def is_gameover(self):
        #所有的行都不能移动则游戏结束
        return not any(self.move_is_possible(move) for move in self.action.actions)

    def draw(self, screen):     
        def set_color():#设置颜色
            #使用颜色首先需要调用这个方法
            curses.start_color()    
            #文字和背景色设置,设置了三个color pair,分别为1,2,3
            curses.init_pair(1,curses.COLOR_YELLOW,curses.COLOR_BLACK)
            curses.init_pair(2,curses.COLOR_GREEN,curses.COLOR_BLACK)
            curses.init_pair(3,curses.COLOR_RED,curses.COLOR_BLACK)
                
        def cast(string):#绘制字符串      
#             screen.addstr(string+ '\n')     
            set_color()
            screen.addstr(string+ '\n',curses.color_pair(1))
            
        def cast2(string):#绘制字符串 ,成功时显示绿色的提示语     
            set_color()
            screen.addstr(string+ '\n',curses.color_pair(2))

        def cast3(string):#将分数和最高分显示为红色   
            set_color()
            screen.addstr(string+ '\n',curses.color_pair(3))

        def draw_row(row):#绘制包含数字的行
            #^是居中显式,<是左对齐,>是右对齐,冒号后面有一个空格,意思是空格填充
            #如果单元格中数字大于0,则将该数字格式化为居中显示,否者仅打印斜杠和空格
            cast(''.join('|{: ^5} '.format(num) if num > 0 else '|      ' for num in row) + '|')
   
        help_string1 = '(↑)Up(↓)Down(←)Left(→)Right'
        help_string2 = '   (Enter)Restart (Esc)Exit'
        help_string3 = '(Enter)Restart(Y)Continue(Esc)Exit'
        gameover_string = '           GAME OVER'
        win_string = '          YOU WIN!'      

        screen.clear()
        cast3('SCORE: ' + str(self.score))#绘制当前分数
        cast3('HIGHSCORE: ' + str(self.highscore))#绘制当前最高分数
        for row in self.field:
            cast('+------' * self.width + '+')
            draw_row(row)
        cast('+------' * self.width + '+')        
        
        if self.is_win():
            cast2(win_string)
            cast(help_string3)
        else:
            if self.is_gameover():
                cast(gameover_string)
            else:
                cast(help_string1)
            cast(help_string2)
        
def main(stdscr):#stdscr由curses传入,主要用于命令行的操作
    def init():
        #重置游戏棋盘
        game_field.reset()
        return 'Game'

    def not_game(state):#胜利或失败的状态
        #画出 GameOver 或者 Win 的界面
        game_field.draw(stdscr)
        #读取用户输入得到action,判断是重启游戏还是结束游戏
        action = actionoperate.get_user_action(stdscr)
        responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
        responses['Restart'], responses['Exit'],responses['Continue'] = 'Init', 'Exit','Continue' #对应不同的行为转换到不同的状态
        return responses[action]

    def game():
        #画出当前棋盘状态
        game_field.draw(stdscr)
        #读取用户输入得到action
        action = actionoperate.get_user_action(stdscr)
        
        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if game_field.move(action): # move successful
            if game_field.is_win():
                if action=='Continue':
                    return 'Continue'
                else:
                    return 'Win'
            if game_field.is_gameover():
                return 'Gameover'
        return 'Game'    
    
    def game_suc():
        #画出游戏成功后当前棋盘状态
        game_field.draw(stdscr)
        #读取用户输入得到action
        action = actionoperate.get_user_action(stdscr)

        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if game_field.move(action): # move successful            
            return 'GameSuc'
        return 'GameSuc'
    
    def game_continue():#达到胜利分数值选择继续游戏
        game_field.draw(stdscr)
#         #读取用户输入得到action
        action = actionoperate.get_user_action(stdscr)
        
        if game_field.move(action): # move successful
            if game_field.is_gameover():
                return 'Gameover'
            else: 
                return 'GameSuc'
        return 'GameSuc'
                
    state_actions = {
            'Init': init,
            'Win': lambda: not_game('Win'),
            'Gameover': lambda: not_game('Gameover'),
            'Game': game,
            'Continue':game_continue,
            'GameSuc':game_suc            
        }
   

#     curses.use_default_colors()

    # 设置终结状态最大数值为 8
    game_field = GameField(win=8)
    actionoperate=Action()

    state = 'Init'

    #状态机开始循环
    while state != 'Exit':
        state = state_actions[state]()

sqliteoperate=sqliteOperate()              
Highscore=sqliteoperate.select()
#curses库提供了控制字符屏幕的独立于终端的方法
#不能用任何IDE来运行有curses包的python文件,否则提示Redirection is not supported.
curses.wrapper(main) #初始化curses

Python代码实现2048-功能拓展_第3张图片

你可能感兴趣的:(python)