利用Python编写2048游戏小项目
2048游戏介绍
《2048》作为一款风靡全球的益智类数字小游戏，应该大部分朋友都有玩过。《2048》是20岁的Gabriele Cirulli开发的一款数字游戏。初衷就是觉得好玩，在将其开源版本放到Github上后，意外走红。这款游戏的玩法很简单，每次可以选择上下左右滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢，系统也会在空白的地方乱数出现一个数字方块，相同数字的方块在靠拢、相撞时会相加。不断的叠加最终拼凑出2048这个数字就算成功。
官方2048网址：http://2048game.com/
我们将要实现的2048操作基本和原版类似，只不过我们会用上下左右键替换原版的上下左右滑动。
游戏规则：
1.一开始方格内会出现2或者4这两个小数字；玩家只需要上下左右其中一个方向来移动出现的数字，所有的数字就会向对应的方向靠拢，而剩余的空白方块就会随机出现一个数字（2或4）；
2.相同的数字相撞时会叠加靠拢，然后一直这样，不断的叠加最终拼凑出2048这个数字就算成功。
3.如果向上向下向左向右均不可移动，那么Game Over！否则游戏将继续执行！
接下来就开始分开多个步骤模块进行游戏的编写。
1.游戏方格的绘制
import random
# 1.生成4*4的方格数据
# 方格宽度的变量值
width = 4
# 循环width(4)次， 生成列表， 列表元素为width(4)个
data = [[0 for j in range(width)] for i in range(width)]
# 2. 开始游戏时，随机生成2或者4, 2出现的几率比较大
def random_create():
while True:
# 获取随机修改信息的行数；
row = random.randint(0, 3)
# 获取随机修改信息的列数
column = random.randint(0, 3)
# 生成随机填充的值;2出现的几率比较大
value = random.choice([2, 2, 2, 2, 2, 4])
# 判断方格指定位置原先是否有数据， 如果有， 则继续随机获取行或者列； 如果没有， 填充信息;
if data[row][column] == 0:
data[row][column] = value
break
# 3. 绘制方格的分隔符
def draw_sep():
"""+----+----+----+----+"""
print("+----" * 4 + "+")
# 4. 绘制每一行的数据
def draw_one_row(row):
# [0, 0, 2, 2], 如果有值， 内容填充
# | | | 2 | 2 |
for item in row:
if item == 0:
print('| ', end='')
else:
print('|' + str(item).center(4), end='')
print('|')
if __name__ == '__main__':
random_create()
random_create()
print("开始游戏时， 方格的数据显示:")
draw_sep()
for row in data:
draw_one_row(row)
draw_sep()运行后，可以看到游戏的方格已经画好了，如下：
2.判断方格的数字是否可以向左移动
在移动的时候，我们可能会想到下面几个问题：
问题一：如何判断方格中数字是否可以向左移动?
只要方格的任意一行可以数字可以向左移动， 就返回True；
问题二：如何判断方格的一行数字是否可以向左移动?
只要这一行的任意两个元素可以向左移动， 则返回True；
问题三： 如何判断两个元素可以向左移动?
- 如果第一个数值为0， 第二个数值不为0， 则说明可以向左移动； eg：0 2，0 4 ，0 8
- 如果第一个数值不为0， 第二个数值与第一个元素相等， 则说明可以向左移动；eg： 4 4，2 2
def is_row_left(row: list) -> bool:
"""用户传入一行数据， 判断是否可以向左移动， 返回Bool"""
# 任意两个元素是否可以向左移动?
def is_item_left(index): # index指的是索引值
"""判断当前索引值和下一个索引值， 是否可以向左移动"""
# - 如果第一个数值为0， 第二个数值不为0， 则说明可以向左移动； eg: 0 2 , 0 4 , 0 8
if row[index] == 0 and row[index + 1] != 0:
return True
# - 如果第一个数值不为0， 第二个数值与第一个元素相等， 则说明可以向左移动；eg: 4 4, 2 2,
if row[index] != 0 and row[index] == row[index+1]:
return True
return False
# 只要这一行的任意两个元素可以向左移动， 认为这一行可以向左移动， 返回True；
# any(): 传递可迭代对象， 如果有任意一个为True， 则返回True；
# all(): 传递可迭代对象， 如果有任意一个为False， 则返回False；
return any([is_item_left(index) for index in range(3)])
def is_move_left(data):
"""判断方格数字是否可以向左移动"""
return any([is_row_left(row) for row in data])
3.实现矩阵的反转和转置
def invert(data):
"""
:param data: 方格中的数据
:return: 反转后的方格数据
"""
return [row[::-1] for row in data]
def transpose(data):
"""
实现矩阵的转置
"""
return [list(row) for row in zip(*data)]加入这两个操作可以大大节省我们的代码量，减少重复劳动。我们只需要编写数字向左移动的代码，在需要数字向右移动时，先将方格中的数字反转，再将其向左移动就会实现数字向右移动了；在需要数字向上移动时，先将方格中的数字进行转置，再将其向左移动就会实现数字向上移动了。
4.判断方格中数字是否可以向右向上向下方移动
def is_move_right(data):
"""
判断2048能否向右移动
"""
invertData = invert(data)
return is_move_left(invertData)
def is_move_up(data):
"""
判断2048能否向上移动
"""
transposeData = transpose(data)
return is_move_left(transposeData)
def is_move_down(data):
"""
判断2048能否向下移动
源数据:
[2, 0, 4, 2],
[4, 0, 2, 2],
[0, 0, 4, 2],
[0, 0, 4, 2],
处理之后: 判断是否可以向右移动, 也就是判断源数据是否可以向下移动.
[2, 4, 0, 0],
[0, 0, 0, 0],
[4, 2, 4, 4],
[2, 2, 2, 2]
"""
transposeData = transpose(data)
return is_move_right(transposeData)5.方格中的数字上下左右移动
def tight(row):
"""将这一行所有的非0数字向前放， 0向后放."""
return sorted(row, key=lambda x: 1 if x == 0 else 0)
def merge(row):
"""
依次循环判断两个数是否相等， 如果相等， 第一个元素*2， 第二个元素归0； [4 0 4 0]
"""
# 比较的次数
for index in range(3):
# 如果相等， 第一个元素*2， 第二个元素归0；
if row[index] == row[index + 1]:
# row[index] = row[index] * 2
row[index] *= 2
row[index + 1] = 0
return row
def row_left(row):
"""将某一行数据向左移动"""
# 三部曲
return tight(merge(tight(row)))
def move_left(data):
"""2048整体向左移动"""
return [row_left(row) for row in data]
def move_right(data): # 反转====反转回来
"""
2048整体向右移动
源数据:
[2 0 2 0]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
反转
[0 2 0 2]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
向左移动
[4 0 0 0]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
反转:
[0 0 0 4]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
"""
invertData = invert(data)
return invert(move_left(invertData))
def move_up(data):
"""2048整体向上移动"""
transposeData = transpose(data)
return transpose(move_left(transposeData))
def move_down(data):
"""2048整体向下移动"""
transposeData = transpose(data)
return transpose(move_right(transposeData))6.游戏结束的判断
问题一：何时用户游戏胜利?
当棋盘中出现num=2048时， 则代表用户胜利。
问题二：何时game over?
当用户在任何方向都不能移动时， 则代表游戏结束， 用户失败。
from itertools import chain
def is_win(data):
"""
2048里面有一个数字大于或者等于2048， 游戏胜利
"""
# 将嵌套的元素连成一个列表
# print(*data) # 解包
# print(list(chain(*data)))
# maxNum = max(chain(*data))
# print(maxNum)
return max(chain(*data)) >= 2048
# 只要有任意一个方向可以移动， 那就没有结束
def is_gameover(data):
return not any([is_move_left(data), is_move_right(data),
is_move_up(data), is_move_down(data)])
7.获取键盘的输入
利用cursor模块中的getch()方法实现键盘输入的获取。
def get_user_action(stdscr):
"""获取用户输入的函数封装"""
action = stdscr.getch()
if action == curses.KEY_UP:
return 'Up'
elif action == curses.KEY_DOWN:
return 'Down'
elif action == curses.KEY_LEFT:
return 'Left'
elif action == curses.KEY_RIGHT:
return 'Right'
# ord方法查看字母对应的ACII
elif action == ord('r'):
return 'Restart'
elif action == ord('e'):
return 'Exit'2048完整代码
以上就是所有的2048游戏基本的步骤模块了，接下来，再通过主程序的编写和所有模块的连接，就可以实现最终的2048游戏了，拼接后的完整代码如下：
import random
import curses
from itertools import chain
class GameField(object):
"""游戏类"""
# 初始化信息
def __init__(self, width=4, height=4, win_value=2048):
self.width = width # 方格的宽度
self.height = height
self.win_value = win_value
self.score = 0 # 当前得分， 默认为0
self.highscore = 0 # 最高分
self.is_moves = {
'Up': self.is_move_up,
'Down': self.is_move_down,
'Left': self.is_move_left,
'Right': self.is_move_right
}
self.moves = {
'Up': self.move_up,
'Down': self.move_down,
'Left': self.move_left,
'Right': self.move_right
}
def random_create(self):
"""在随机位置生成2或者4"""
while True:
# 获取随机修改信息的行数；
row = random.randint(0, self.height - 1)
# 获取随机修改信息的列数
column = random.randint(0, self.width - 1)
# 生成随机填充的值;2出现的几率比较大
value = random.choice([2, 2, 2, 2, 2, 4])
# 判断方格指定位置原先是否有数据， 如果有， 则继续随机获取行或者列； 如果没有， 填充信息;
if self.data[row][column] == 0:
self.data[row][column] = value
break
def reset(self): # 重新开始2048游戏
# 更新最高分
if self.score > self.highscore:
self.highscore = self.score
self.score = 0
self.data = [[0 for j in range(self.width)] for i in range(self.height)]
self.random_create()
self.random_create()
def draw(self, stdscr):
"""接收一个参数stdscr， 标准屏幕， 将来在该屏幕上绘制数据"""
# . 绘制棋盘的分隔符
def draw_sep():
"""+----+----+----+----+"""
stdscr.addstr("+----" * 4 + "+" + '\n')
# . 绘制每一行的数据
def draw_one_row(row):
# [0, 0, 2, 2], 如果有值， 内容填充
# | | | 2 | 2 |
for item in row:
if item == 0:
stdscr.addstr('| ')
else:
stdscr.addstr('|' + str(item).center(4))
stdscr.addstr('|\n')
# *** 清空窗口绘制的图形信息
stdscr.clear()
stdscr.addstr("2048游戏".center(40, '*') + '\n')
# 绘制方格
draw_sep()
for row in self.data:
draw_one_row(row)
draw_sep()
# 游戏的相关信息
stdscr.addstr("\n当前分数: %s" % (self.score))
stdscr.addstr("\n当前最高分数: %s" % (self.highscore))
stdscr.addstr("\n游戏帮助: 上下左右键 E(xit) R(estart)")
def is_win(self):
"""
2048里面有一个数字大于或者等于2048， 游戏胜利
"""
return max(chain(*self.data)) >= 2048
def is_gameover(self):
return not any([self.is_move_left(self.data), self.is_move_right(self.data),
self.is_move_up(self.data), self.is_move_down(self.data)])
# [0, 2, 0, 2] ==>01 12 23
@staticmethod
def is_row_left(row: list) -> bool:
"""用户传入一行数据， 判断是否可以向左移动， 返回Bool"""
# 任意两个元素是否可以向左移动?
def is_item_left(index): # index指的是索引值
"""判断当前索引值和下一个索引值， 是否可以向左移动"""
# - 如果第一个数值为0， 第二个数值不为0， 则说明可以向左移动； eg: 0 2 , 0 4 , 0 8
if row[index] == 0 and row[index + 1] != 0:
return True
# - 如果第一个数值不为0， 第二个数值与第一个元素相等， 则说明可以向左移动；eg: 4 4, 2 2,
if row[index] != 0 and row[index] == row[index + 1]:
return True
return False
# 只要这一行的任意两个元素可以向左移动， 认为这一行可以向左移动， 返回True；
# any(): 传递可迭代对象， 如果有任意一个为True， 则返回True；
# all(): 传递可迭代对象， 如果有任意一个为False， 则返回False；
return any([is_item_left(index) for index in range(3)])
def is_move_left(self, data):
"""判断方格数字是否可以向左移动"""
return any([self.is_row_left(row) for row in data])
@staticmethod
def invert(data):
"""
:param data: 方格的数据
:return: 反转后的方格数据
"""
return [row[::-1] for row in data]
@staticmethod
def transpose(data):
"""
实现矩阵的转置
"""
return [list(row) for row in zip(*data)]
def is_move_right(self, data):
"""
判断2048能否向右移动
"""
invertData = self.invert(data)
return self.is_move_left(invertData)
def is_move_up(self, data):
"""
判断2048能否向上移动
"""
transposeData = self.transpose(data)
return self.is_move_left(transposeData)
def is_move_down(self, data):
"""
判断2048能否向下移动
"""
transposeData = self.transpose(data)
return self.is_move_right(transposeData)
def move_left(self, data):
# 判断是否可以移动
def tight(row):
"""将这一行所有的非0数字向前放， 0向后放."""
return sorted(row, key=lambda x: 1 if x == 0 else 0)
def merge(row):
"""
依次循环判断两个数是否相等， 如果相等， 第一个元素*2， 第二个元素归0； [4 0 4 0]
"""
# 比较的次数
for index in range(3):
# 如果相等， 第一个元素*2， 第二个元素归0；
if row[index] == row[index + 1]:
# row[index] = row[index] * 2
row[index] *= 2
row[index + 1] = 0
self.score += row[index] #
return row
def row_left(row):
"""将某一行数据向左移动"""
# 三部曲
return tight(merge(tight(row)))
return [row_left(row) for row in data]
def move_right(self, data): # 反转====反转回来
invertData = self.invert(data)
return self.invert(self.move_left(invertData))
def move_up(self, data):
"""2048整体向上移动"""
transposeData = self.transpose(data)
return self.transpose(self.move_left(transposeData))
def move_down(self, data):
"""2048整体向下移动"""
transposeData = self.transpose(data)
return self.transpose(self.move_right(transposeData))
def move(self, direction):
"""
1. 判断这个方向是否可以移动？
2. 执行移动操作；
3. 再随机生成一个2或者4
:param direction:
:return:
"""
if direction in self.moves:
if self.is_moves[direction](self.data):
self.data = self.moves[direction](self.data)
self.random_create()
# PEP8
def main(stdscr):
gameObj = GameField(win_value=32)
def get_user_action(stdscr):
"""获取用户输入的函数封装"""
action = stdscr.getch()
if action == curses.KEY_UP:
return 'Up'
elif action == curses.KEY_DOWN:
return 'Down'
elif action == curses.KEY_LEFT:
return 'Left'
elif action == curses.KEY_RIGHT:
return 'Right'
# ord方法查看字母对应的ACII
elif action == ord('r'):
return 'Restart'
elif action == ord('e'):
return 'Exit'
def init():
"""初始化函数， 初始化结束后， 游戏进入‘Game’状态"""
gameObj.reset()
gameObj.draw(stdscr)
return 'Game'
def game():
gameObj.draw(stdscr)
action = get_user_action(stdscr)
if action == 'Restart':
return 'Init'
elif action == 'Exit':
return 'Exit'
else:
if gameObj.move(action):
# 判断win or gameover?
if gameObj.is_win():
return 'Win'
elif gameObj.is_gameover():
return 'GameOver'
return 'Game'
def not_game():
"""当游戏状态为Win或者GameOver时执行的逻辑"""
action = get_user_action(stdscr)
if action == 'Restart':
return 'Init'
elif action == 'Exit':
return 'Exit'
state_dict = {
'Init': init,
'Game': game,
'Win': not_game,
'GameOver': not_game,
'Exit': exit
}
state = 'Init' # 刚开始玩游戏， 游戏状态为Init
while True:
state = state_dict.get(state)()
curses.wrapper(main)程序运行后操作示例
由于curses模块只能获取在命令窗口的键盘输入，所以程序最终需要在Terminal中运行：
[kiosk@foundation ~]$ cd /home/kiosk/Desktop
[kiosk@foundation Desktop]$ python3 2048.py
运行之后，界面如下：
按上键，向上移动：
按下键 ，向下移动：
按 左键，向左移动：
按右键，向右移动：
按 r 键，重新开始游戏：
需要退出时，就按下 e 键，即可退出。
一个粗糙的2048游戏就完成了，但是基本功能很完整，若发现有什么需要改进的地方，欢迎大家在评论区评论。