转载请注明出处http://www.cnblogs.com/Wxtrkbc/p/5519453.html

　　以前游戏2048火的时候，正好用其他的语言编写了一个，现在学习python，正好想起来，便决定用python写一个2048，由于没学过python里面的界面编程，所以写了一个极其简单的无界面2048。游戏2048的原理和实现都不难，正好可以拿来练手，要是不知道这游戏的话，可以去网上查一下，或者下载一个到手机来玩一下，我就不在说其原理。我知道不放图的话大家一点兴趣都没，下面首先放一张游戏成型图，然后我们在来讲如何一步步用最基础的知识来实现。

　　　　　　　　　　

一、生成4*4的矩阵

　　游戏的第一步便是生成一个4*4的矩阵，当作我们游戏的主界面，其实说起来也比较简单，这里用了最原始的方法，直接用print将其打印出来。首先我们要生成一个全为0的4*4二维列表，然后用一些类似  '┌ ├└,┤,┘┐│,─,┬,┴'这样的字符来组成我们的边框，下面来看一下代码的实现

  1. matix=[[0 for i in range(4)] for i in range(4)]        # 用列表推导式初始化生成一个4*4的列表，列表元素全为 0
  2.  
  3. # notzero函数的作用：游戏界面上非零的时候才显示，当为0的时候，让其显示空，
  4. def notzero(s):
  5.     return s if s!=0 else ''                          # 非零的话返回本身，否则返回 ''
  6.  
  7. def display():　　　　　　　　　　　　　　　　　　　　　　　　# 显示界面函数，用┌ ├└,┤,┘┐│,─,┬,┴ 等显示边框，中间显示4*4矩阵里的的元素
  8.     print("\r\
  9. ┌──┬──┬──┬──┐\n\
  10. │%4s│%4s│%4s│%4s│\n\
  11. ├──┬──┬──┬──┤\n\
  12. │%4s│%4s│%4s│%4s│\n\
  13. ├──┬──┬──┬──┤\n\
  14. │%4s│%4s│%4s│%4s│\n\
  15. ├──┬──┬──┬──┤\n\
  16. │%4s│%4s│%4s│%4s│\n\
  17. └──┴──┴──┴──┘"\
  18. %(notzero(matix[0][0]),notzero(matix[0][1]),notzero(matix[0][2]),notzero(matix[0][3]),\
  19.   notzero(matix[1][0]),notzero(matix[1][1]),notzero(matix[1][2]),notzero(matix[1][3]),\
  20.   notzero(matix[2][0]),notzero(matix[2][1]),notzero(matix[2][2]),notzero(matix[2][3]), \
  21.   notzero(matix[3][0]),notzero(matix[3][1]),notzero(matix[3][2]),notzero(matix[3][3]),)
  22.           )
  23. display()

　　来看一下上面代码的效果，是不是感觉一个游戏的框架已经到搭好了，由于初始化的时候，矩阵元素都为零，下面的图也就没有显示出0，是不是很简单，一个游戏的界面就被我们搭好了，不过毕竟没学过界面，所以大家就不要抱怨这界面有多么丑了哈。

　　　　　　　　　　　　

二、初始化生成随机数

这个游戏每次开始的时候都会随机在上面的一个矩阵中生成两个随机数2或4，那么我们要如何来实现在上面矩阵中随机的一个位置生成一个随机数2或4了，当然是用到我们前面学过的random模块以及divmod()，下面我们就来看一下如何用random模块实现着一功能。

  1. def init():                                           # 初始化矩阵
  2.     initNumFlag = 0
  3.     while 1:
  4.         k = 2 if random.randrange(0, 10) > 1 else 4   # 当生成随机数大于1的时候k=2否则k=4 生成2和4的概率为9：1
  5.         s = divmod(random.randrange(0, 16), 4)        # 生成矩阵初始化的下标 比如divmod（15，4）的话，s为（3，3）正好可以作为矩阵下标
  6.         if matix[s[0]][s[1]] == 0:                    # 只有当其值不为0的时候才赋值，避免第二个值重复
  7.             matix[s[0]][s[1]] = k
  8.             initNumFlag += 1
  9.             if initNumFlag == 2:                      # 当initNumFlag==2 的话表示矩阵里两个随机数都已经生成了，退出循环
  10.                 break
  11. init()
  12. display()

　　来看一下上面代码的效果，是不是已经在两个随机的位置生成了两个数，如果大家有时间的试一下，可以看见每次执行的时候，出现在矩阵上面位置不一样，而且每次出现的数也不一样，因为我上面设置了出现2：4的概率为9：1所以大多时候出现2，这也是游戏的需要。到了这里矩阵已经可以动起来了，游戏的功能也可以说完成了一半。

三、游戏逻辑部分实现

　　如果玩过这游戏的话就知道，游戏中每次向上下左右移动的时候，比如像下移动的话，所有的数都会向下移动，碰到相同的数，就会成一个新的数，比如2和2碰到的话，就会生成4，然后再随机在其他位置生成一个2或4 ，同理4和4碰到的话也会生成8，直到合成了2048游戏就算成功了，或者说矩阵中的数字都不能移动那就是Game Over。当然我们在手机上玩游戏的话，随便滑动一下，所有的数字就可以向其中一个方向滑动，但是这里没有界面，条件比较艰苦，所以只能从控制台读入用户输入的字母，然后一个个来判断是向哪里移动了，所以我们要写4个函数来分别处理用户的上下左右移动，让后一个函数处理在每次用户移动后，如何添加一个随机数，下面先写一段伪代码来解释流程

  1. def addRandomNum():　　　　　　　　　  　　#每次移动后随机在矩阵中在生成一个数
  2.     pass    　　　　　　
  3. def moveDown()：　　　　　　　　　　　　　　#向上移动的处理函数
  4.     pass
        addRandomNum()　　　　　　　　　　　　 #移动处理完成后，随机生成一个数
  5. def moveLeft():　　　　　　　　　　　　　　 #向左移动的处理函数
  6.     pass
  7.     addRandomNum()
  8. def moveUp():　　　　　　　　　　　　　　   #向上移动的处理函数
  9.     pass
  10.     addRandomNum()
  11. def moveRight():　　　　　　　　　　　　   #向右移动的处理函数
  12.     pass
  13.     addRandomNum()
  14.  
  15. def main():
  16.     while flag:　　　　　　　　　　　　　　　　　　　　　　　　　　#定义一个死循环，不断读入用户的输入，然后在做判断，看是向哪里移动
  17.         d = input(' (↑:w) (↓:s) (←:a) (→:d),q(uit) :“)
  18.         if d == 'a':
  19.             moveLeft()
  20.         elif d == 's':
  21.             moveDown()
  22.         elif d == 'w':
  23.             moveUp()
  24.         elif d == 'd':
  25.             moveRight()
  26.         elif d == 'q':
  27.             break
  28.         else:
  29.             pass

上面是一段为了理解的伪代码，下面我们来看一下如何实现移动处理函数，这里是整个游戏中最难处理的部分，完成了这一部分的话，整个游戏也就基本上实现了，这里我以向下的移动处理函数为例，其他的都一样，当用户输入向下移动的时候，所有的数字都向下移动，如果碰到相同的数字要和并，有数字的方块向没有数字的方块移动。这里需要用循环实现，有4列所以最外层的循环有4次，每一列里面又需要循环处理，下面来看一下具体怎么实现，

  1. def addRandomNum():　　　　　　　　　　　　　　　　　　　　　　　　# 跟初始化生成随机数一样，只不过这里只是生成一个随机数
  2.     while 1:
  3.         k = 2 if random.randrange(0, 10) > 1 else 4
  4.         s = divmod(random.randrange(0, 16), 4)
  5.         if matix[s[0]][s[1]] == 0:
  6.             matix[s[0]][s[1]] = k
  7.             break
  8.     display()　　　　　　　　　　　　　　　　　　　　　　　　　　　# 随机数添加完成后就直接调用显示函数，直接显示一下游戏界面
  9.  
  10. def moveDown():　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#处理向下移动的函数
  11.     for i in range(4):　　　　　　　　　　　　　　　　　　　　　　　　　　　　#外层4次循环处理4例，内层两个3层循环，来处理相邻的两个数
  12.         for j in range(3, 0, -1):
  13.             for k in range(j - 1, -1, -1):
  14.                 if matix[k][i] > 0:　　　　　　　　　　　　　　　　　　　　# 从最下面的数开始处理相邻的两个数
  15.                     if matix[j][i] == 0:
  16.                         matix[j][i] = matix[k][i]　　　　　　　　　　　 # 如果下面的数为空，上面的数字不为空就移动上面的数为下面的数
  17.                         matix[k][i] = 0
  18.                     elif matix[j][i] == matix[k][i]:　　　　　　　　　　# 如果相邻的两个数相等的话，就和并，并把上面的输置零，下面的数变成两倍
  19.                         matix[j][i] *= 2
  20.                         matix[k][i] = 0
  21.                     break
  22.     addRandomNum()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 移动完成后再随机生成一个数

写完了向下移动的处理函数，那么向其他方向的移动函数也一样，照着写，就可以，到这里游戏中最难的部分就完成，可以说胜利就在眼前了，好了在这之前，我们还需要处理一下其他问题，那就是每次移动后都要检查，游戏是不是Game Over了，还有就是定义一个变量来纪录分数了，这些实现起来都比较简单。

四、游戏纪录分数和检查游戏是否结束

　　游戏结束的标志是矩阵中所有的数都不为0，而且所有相邻的数都不能合并，根据这个我们就可以来写一个函数来判断游戏是否GG，至于分数纪录，我们只需定义一个变量，然后每次有何并的时候，就加上一定的分数即可。下面我们来看检查函数的实现。

  1. def check():　　　　　　　　　　　　
  2.     for i in range(4):　　　　　　　　#按每一排循环4 次
  3.         for j in range(3):　　　　　 # 如果矩阵中有0存在，或者有相邻的数就表示游戏还可以继续经行，否则就是GG
  4.             if matix[i][j] == 0 or matix[i][j] == matix[i][j + 1] or matix[j][i] == matix[j + 1][i]:
  5.                 return True
  6.     else:
  7.         return False

五、完整游戏源码　　

　　完成了上面的部分，整个游戏的过程就实现了，下面附上整个游戏的源码。游戏还有很多不够完善的地方，比如说游戏中如果出现2048的话，就表示玩家胜利，游戏结束，但是我这里没有做处理，所以这个游戏可以一直玩到4096....没有结束，除非你游戏中GG了，要处理也很简单，还可以将矩阵存在文件中，完成一个游戏存档的功能。有兴趣的话大家去实现一下。

  1. import random
  2.  
  3. score = 0　　　　　　　　　　　　　　　　　　　　　　　　　# 纪录游戏的分数
  4. matix = [[0 for i in range(4)] for i in range(4)]  # 初始化生成一个4*4的列表
  5.  
  6. def notzero(s):
  7.     return s if s != 0 else ''
  8. def display():
  9.     print("\r\
  10.           ┌──┬──┬──┬──┐\n\
  11.           │%4s│%4s│%4s│%4s│\n\
  12.           ├──┬──┬──┬──┤\n\
  13.           │%4s│%4s│%4s│%4s│\n\
  14.           ├──┬──┬──┬──┤\n\
  15.           │%4s│%4s│%4s│%4s│\n\
  16.           ├──┬──┬──┬──┤\n\
  17.           │%4s│%4s│%4s│%4s│\n\
  18.           └──┴──┴──┴──┘" \
  19.           % (notzero(matix[0][0]), notzero(matix[0][1]), notzero(matix[0][2]), notzero(matix[0][3]), \
  20.              notzero(matix[1][0]), notzero(matix[1][1]), notzero(matix[1][2]), notzero(matix[1][3]), \
  21.              notzero(matix[2][0]), notzero(matix[2][1]), notzero(matix[2][2]), notzero(matix[2][3]), \
  22.              notzero(matix[3][0]), notzero(matix[3][1]), notzero(matix[3][2]), notzero(matix[3][3]),)
  23.           )
  24.  
  25. def init():  　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 初始化矩阵
  26.     initNumFlag = 0
  27.     while 1:
  28.         k = 2 if random.randrange(0, 10) > 1 else 4  　　　　　　# 随机生成 2 或 4
  29.         s = divmod(random.randrange(0, 16), 4)  　　　　　　　　　# 生成矩阵初始化的下标
  30.         if matix[s[0]][s[1]] == 0:  　　　　　　　　　　　　　　　　 # 只有当其值不为0的时候才赋值，避免第二个值重复
  31.             matix[s[0]][s[1]] = k
  32.             initNumFlag += 1
  33.             if initNumFlag == 2:
  34.                 break
  35.     display()
  36.  
  37. def addRandomNum():　　　　　　　　　　　　　　　　　　　　　　　　#处理完移动后添加一个新的随机数
  38.     while 1:
  39.         k = 2 if random.randrange(0, 10) > 1 else 4
  40.         s = divmod(random.randrange(0, 16), 4)
  41.         if matix[s[0]][s[1]] == 0:
  42.             matix[s[0]][s[1]] = k
  43.             break
  44.     display()
  45.  
  46. def check():　　　　　　　　　　　　　　　　　　　　　　　　　　　　#检查游戏是否GG
  47.     for i in range(4):
  48.         for j in range(3):
  49.             if matix[i][j] == 0 or matix[i][j] == matix[i][j + 1] or matix[j][i] == matix[j + 1][i]:
  50.                 return True
  51.     else:
  52.         return False
  53.  
  54. def moveRight():　　　　　　　　　　　　　　　　　　　　　　　　 # 向右移动处理函数
  55.     global score
  56.     for i in range(4):
  57.         for j in range(3, 0, -1):
  58.             for k in range(j - 1, -1, -1):
  59.                 if matix[i][k] > 0:
  60.                     if matix[i][j] == 0:
  61.                         matix[i][j] = matix[i][k]
  62.                         matix[i][k] = 0
  63.                     elif matix[i][j] == matix[i][k]:
  64.                         matix[i][j] *= 2
  65.                         score += matix[i][j]　　　　　　　#将当前数作为score加上
  66.                         matix[i][k] = 0
  67.                     break
  68.     addRandomNum()
  69.  
  70. def moveUp():
  71.     global score
  72.     for i in range(4):
  73.         for j in range(3):
  74.             for k in range(j + 1, 4):
  75.                 if matix[k][i] > 0:
  76.                     if matix[j][i] == 0:
  77.                         matix[j][i] = matix[k][i]
  78.                         matix[k][i] = 0
  79.                     elif matix[k][i] == matix[j][i]:
  80.                         matix[j][i] *= 2
  81.                         score += matix[j][i]
  82.                         matix[k][i] = 0
  83.                     break
  84.     addRandomNum()
  85.  
  86. def moveDown():
  87.     global score
  88.     for i in range(4):
  89.         for j in range(3, 0, -1):
  90.             for k in range(j - 1, -1, -1):
  91.                 if matix[k][i] > 0:
  92.                     if matix[j][i] == 0:
  93.                         matix[j][i] = matix[k][i]
  94.                         matix[k][i] = 0
  95.                     elif matix[j][i] == matix[k][i]:
  96.                         matix[j][i] *= 2
  97.                         score += matix[j][i]
  98.                         matix[k][i] = 0
  99.                     break
  100.     addRandomNum()
  101.  
  102. def moveLeft():
  103.     global score
  104.     for i in range(4):
  105.         for j in range(3):
  106.             for k in range(1 + j, 4):
  107.                 if matix[i][k] > 0:
  108.                     if matix[i][j] == 0:
  109.                         matix[i][j] = matix[i][k]
  110.                         matix[i][k] = 0
  111.                     elif matix[i][j] == matix[i][k]:
  112.                         matix[i][j] *= 2
  113.                         score += matix[i][j]
  114.                         matix[i][k] = 0
  115.                     break
  116.     addRandomNum()
  117.  
  118. def main():
  119.     print("       \033[33;1mWelcome to the Game of 2048!\033[0m")
  120.     flag = True
  121.     init()
  122.     while flag:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#循环的标志
  123.         print('               \033[33;1m You Score:%s\033[0m' % (score))
  124.         d = input('\033[33;1m (↑:w) (↓:s) (←:a) (→:d),q(uit) :\033[0m')    #不断处理用户输入
  125.         if d == 'a':　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
  126.             moveLeft()
  127.             if not check():　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#检查游戏是否GG
  128.                 print('GG')
  129.                 flag = False　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #GG的话直接退出
  130.         elif d == 's':
  131.             moveDown()
  132.             if not check():
  133.                 print('GG')
  134.                 flag = False
  135.         elif d == 'w':
  136.             moveUp()
  137.             if not check():
  138.                 print('GG')
  139.                 flag = False
  140.         elif d == 'd':
  141.             moveRight()
  142.             if not check():
  143.                 print('GG')
  144.                 flag = False
  145.         elif d == 'q':　　　　　　　　　　　　　　　　　　　　　　　　　　# 退出
  146.             break
  147.         else:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # 对用户的其他输入不做处理
  148.             pass
  149.  
  150. if __name__ == '__main__':
  151.     main()

最后在附上一张图片最为结束

　　　　　　　　　　　　　　

用python实现一个无界面的2048的更多相关文章

  1. 用delphi制作无界面的activex控件

    首先,您要了解: •COM的基本原理 •能被网页调用的非可视ActiveX控件必须是一种至少实现了IOleObject接口的TAutoObject组件 •利用Delphi向导生成的ActiveX控件必 ...

  2. python之Phantomjs无界面浏览器引擎自动化测试

    文字搬运工,本文主要介绍PhantomJS功能,其中有屏幕快照功能,为后面更新[python接口自动化脚本更新版本],其中新版本中新增自动发送邮件功能正文带图片,使用PhantomJS截取图片后发送邮 ...

  3. powershell字符界面的，powershell加WPF界面的，2048游戏

    ------[序言]------ 1 2048游戏,有段时间很火,我在地铁上看有人玩过.没错,坐地铁很无聊,人家玩我就一直盯着看. 2 我在电脑上找了一个,试玩了以下,没几次格子就满了.我就气呼呼的放 ...

  4. python concurrent.futures.Threadpoolexcutor的有界队列和无界队列

    1.默认是无界队列,如果生产任务的速度大大超过消费的速度,则会把生产任务无限添加到无界队列中,这样一来控制不了生产速度,二来是会造成系统内存会被队列中的元素堆积增多而耗尽. 2.改写为有界队列 cla ...

  5. 【Python】如何基于Python写一个TCP反向连接后门

    首发安全客 如何基于Python写一个TCP反向连接后门 https://www.anquanke.com/post/id/92401 0x0 介绍 在Linux系统做未授权测试,我们须准备一个安全的 ...

  6. tkinter+pickle+python的一个登录界面设计

    1.代码: #导出模块 import tkinter as tk from tkinter import messagebox import pickle #定义登录的窗口.标题.大小和位置 wind ...

  7. Python：一个闹钟

    随着一个<霍格沃茨:一段校史>风格的大字(呃,这字好像并不大--)标题的出现,无聊的我没事干,又开始整活了~ 之前我做的程序,一个使用了Tkinter库,一个则是Pygame,总之都是带有 ...

  8. 用Python写一个简单的Web框架

    一.概述 二.从demo_app开始 三.WSGI中的application 四.区分URL 五.重构 1.正则匹配URL 2.DRY 3.抽象出框架 六.参考 一.概述 在Python中,WSGI( ...

  9. 如何自定义wordpress登录界面的Logo

    每次登录wp后台都会看到wordpress的logo,会不会有点烦呢?想不想换个新的.自己设定一个呢?那么如何自定义wordpress登录界面的Logo呢? 把代码复制到当前主题的 functions ...

随机推荐

  1. bzoj5月月赛订正

    已完成2/9(要准备中考啊QwQ) T1 考虑对所有数分解质因数,其中因子>sqrt(100000)的因子最多有一个,于是我们可以暴力维护<sqrt(100000)的因子个数的前缀和. 剩 ...

  2. Linux上查看文件大小的用法（转载）

    具体用法可以参考:https://blog.csdn.net/linfanhehe/article/details/78560887 当磁盘大小超过标准时会有报警提示,这时如果掌握df和du命令是非常 ...

  3. 浅谈移动端 View 的显示过程

    作者:个推安卓开发工程师 一七 随着科技的发展,各种移动端早已成为人们日常生活中不可或缺的部分,人们使用移动端产品工作.社交.娱乐……移动端界面的流畅性已经成为影响用户体验的重要因素之一.那么你是否思 ...

  4. Hadoop基础-常见异常剖析之防坑小技巧

    Hadoop基础-常见异常剖析之防坑小技巧 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.

  5. JVM调优命令-jps

    JVM Process Status Tool,显示指定系统内所有的HotSpot虚拟机进程. 命令格式 1 jps [options] [hostid] options参数-l : 输出主类全名或j ...

  6. Solr记录-solr检索和查询数据

    Solr检索数据 在本章中,我们将讨论如何使用Java Client API检索数据.假设有一个名为sample.csv的.csv文档,其中包含以下内容. 001,9848022337,Hyderab ...

  7. Git 操作指南

    http://blog.csdn.net/troy__/article/details/40082657

  8. JavaScript事件模拟元素拖动

    一.前言: 最近要实现一个元素拖放效果,鼠标拖动元素并且定位元素,首先想到的是HTML5中的拖放,在HTML5中,有一个draggable属性,且有dragstart, dragover, drop等 ...

  9. [转载]HTML5浏览器测试网站汇总

    http://www.cnblogs.com/javawebsoa/archive/2012/04/19/2458224.html 浏览器支持情况统计 When Can IUse:图表经常更新,展示了 ...

  10. HTML5 JavaScript实现图片文字识别与提取

    8月底的时候,@阿里巴巴 推出了一款名为“拯救斯诺克”的闯关游戏,作为前端校园招聘的热身,做的相当不错,让我非常喜欢.后来又传出了一条消息,阿里推出了A-star(阿里星)计划,入职阿里的技术培训生, ...