200行Python代码实现的2048小游戏

孤独750

　　2048这个小游戏大家都不陌生，应该都玩过，之前已经在网上见过各个版本的2048实现了，有JAVA、HTML5等，今天我就给大家来一个我自己在 实验楼 学到的python版2048。所有代码加起来才200行，不用很麻烦很累就可以写一个 2048 游戏出来。
　　游戏的具体规则什么的就不多说了，自己亲自去玩一下就清楚了。

导入需要的包
　　

    import curses　　from random import randrange, choice
　　from collections import defaultdict
　　

游戏主逻辑

用户行为
　　用户在玩游戏的主要输入分为六种，"上，下，左，右，游戏重置，退出"用 actions 表示
　　

　　actions = ['Up', 'Left', 'Down', 'Right', 'Restart', 'Exit']
　　

　　分别用 W（上），A（左），S（下），D（右），R（重置），Q（退出），进行输入来操作游戏，这里考虑到大写锁定键锁定的情况：
　　

letter_codes = [ord(ch) for ch in 'WASDRQwasdrq']　　

　　将输入与行为进行关联：
　　

actions_dict = dict(zip(letter_codes, actions * 2))　　

用户输入处理
　　阻塞＋循环，直到获得用户有效输入才返回对应行为：
　　

def get_user_action(keyboard):　　char = "N"
　　while char not in actions_dict:   
　　char = keyboard.getch()
　　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]
　　

创建棋盘
　　初始化棋盘的参数，可以指定棋盘的高和宽以及游戏胜利条件，默认是最经典的 4x4～2048。
　　

class GameField(object):
　　
def __init__(self,>
　　self.height =>
　　self.width =>　　self.win_value = 2048      #过关分数
　　self.score = 0             #当前分数
　　self.highscore = 0         #最高分
　　self.reset()               #棋盘重置
　　

棋盘操作

随机生成一个 2 或者 4
　　

def spawn(self):　　new_element = 4 if randrange(100) > 89 else 2
　　(i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[j] == 0])
　　self.field[j] = new_element
　　

重置棋盘
　　

def reset(self):　　if self.score > self.highscore:
　　self.highscore = self.score
　　self.score = 0
　　self.field = [[0 for i in range(self.width)] for j in range(self.height)]
　　self.spawn()
　　self.spawn()
　　

一行向左合并
　　(注：这一操作是在 move 内定义的，拆出来是为了方便阅读)
　　

def move_row_left(row):　　def tighten(row): # 把零散的非零单元挤到一块
　　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)
　　self.score += 2 * row
　　pair = False
　　else:
　　if i + 1 < len(row) and row == row[i + 1]:
　　pair = True
　　new_row.append(0)
　　else:
　　new_row.append(row)
　　assert len(new_row) == len(row)
　　return new_row
　　#先挤到一块再合并再挤到一块
　　return tighten(merge(tighten(row)))
　　

棋盘走一步
　　通过对矩阵进行转置与逆转，可以直接从左移得到其余三个方向的移动操作
　　

def move(self, direction):　　def move_row_left(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):　　return any(any(i >= self.win_value for i in row) for row in self.field)
　　

　　
def is_gameover(self):
　　return not any(self.move_is_possible(move) for move in actions)
　　

判断能否移动
　　

def move_is_possible(self, direction):　　def row_is_left_movable(row):
　　def change(i):
　　if row == 0 and row[i + 1] != 0: # 可以移动
　　return True
　　if row != 0 and row[i + 1] == row: # 可以合并
　　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 draw(self, screen):　　help_string1 = '(W)Up (S)Down (A)Left (D)Right'
　　help_string2 = '     (R)Restart (Q)Exit'
　　gameover_string = '           GAME OVER'
　　win_string = '          YOU WIN!'
　　def cast(string):
　　screen.addstr(string + '\n')
　　
　　#绘制水平分割线
　　def draw_hor_separator():
　　line = '+' + ('+------' * self.width + '+')[1:]
　　separator = defaultdict(lambda: line)
　　if not hasattr(draw_hor_separator, "counter"):
　　draw_hor_separator.counter = 0
　　cast(separator[draw_hor_separator.counter])
　　draw_hor_separator.counter += 1
　　

　　def draw_row(row):
　　cast(''.join('|{: ^5} '.format(num) if num > 0 else '|      ' for num in row) + '|')
　　

　　screen.clear()
　　
　　cast('SCORE: ' + str(self.score))
　　if 0 != self.highscore:
　　cast('HGHSCORE: ' + str(self.highscore))
　　
　　for row in self.field:
　　draw_hor_separator()
　　draw_row(row)
　　
　　draw_hor_separator()
　　
　　if self.is_win():
　　cast(win_string)
　　else:
　　if self.is_gameover():
　　cast(gameover_string)
　　else:
　　cast(help_string1)
　　cast(help_string2)
　　

完成主逻辑
　　完成以上工作后，我们就可以补完主逻辑了！
　　

def main(stdscr):　　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'] = 'Init', 'Exit' #对应不同的行为转换到不同的状态
　　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():
　　return 'Win'
　　if game_field.is_gameover():
　　return 'Gameover'
　　return 'Game'
　　

　　

　　state_actions = {
　　'Init': init,
　　'Win': lambda: not_game('Win'),
　　'Gameover': lambda: not_game('Gameover'),
　　'Game': game
　　}
　　

　　curses.use_default_colors()
　　game_field = GameField(win=32)
　　
　　

　　state = 'Init'
　　

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

运行
　　填上最后一行代码：
　　

curses.wrapper(main)　　

　　运行看看吧！
　　

$ python 2048.py　　


　　详细代码参见：http://git.shiyanlou.com/littlemonkey/shiyanlou_cs368/src/master/2048.py