• python快速实现2048小游戏

    《2048》是一款比较流行的数字游戏，最早于2014年3月20日发行。原版2048首先在GitHub上发布，原作者是Gabriele Cirulli，后被移植到各个平台。这款游戏是基于《1024》和《小3传奇》的玩法开发而成的新型数字游戏。

    操作指南：

    每次可以选择上下左右其中一个方向去滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢外，系统也会在空白的地方乱数出现一个数字方块，相同数字的方块在靠拢、相撞时会相加。不断的叠加最终拼凑出2048这个数字就算成功。

    游戏技巧：

    1. 最大数尽可能放在角落。

    2. 数字按顺序紧邻排列。

    3. 首先满足最大数和次大数在的那一列/行是满的。

    4. 时刻注意活动较大数（32以上）旁边要有相近的数。

    5. 以大数所在的一行为主要移动方向

    6. 不要急于“清理桌面”。

    完整代码如下：

    logic.py

    1. import random
    2. import constants as c
    3.  
    4.  
    5.  
    6. def new_game(n):
    7.     matrix = []
    8.     for i in range(n):
    9.         matrix.append([0] * n)
    10.     matrix = add_two(matrix)
    11.     matrix = add_two(matrix)
    12.     return matrix
    13.  
    14.  
    15.  
    16. def add_two(mat):
    17.     a = random.randint(0, len(mat)-1)
    18.     b = random.randint(0, len(mat)-1)
    19.     while mat[a][b] != 0:
    20.         a = random.randint(0, len(mat)-1)
    21.         b = random.randint(0, len(mat)-1)
    22.     mat[a][b] = 2
    23.     return mat
    24.  
    25.  
    26.  
    27. def game_state(mat):
    28.     # check for win cell
    29.     for i in range(len(mat)):
    30.         for j in range(len(mat[0])):
    31.             if mat[i][j] == 2048:
    32.                 return 'win'
    33.     # check for any zero entries
    34.     for i in range(len(mat)):
    35.         for j in range(len(mat[0])):
    36.             if mat[i][j] == 0:
    37.                 return 'not over'
    38.     # check for same cells that touch each other
    39.     for i in range(len(mat)-1):
    40.         # intentionally reduced to check the row on the right and below
    41.         # more elegant to use exceptions but most likely this will be their solution
    42.         for j in range(len(mat[0])-1):
    43.             if mat[i][j] == mat[i+1][j] or mat[i][j+1] == mat[i][j]:
    44.                 return 'not over'
    45.     for k in range(len(mat)-1):  # to check the left/right entries on the last row
    46.         if mat[len(mat)-1][k] == mat[len(mat)-1][k+1]:
    47.             return 'not over'
    48.     for j in range(len(mat)-1):  # check up/down entries on last column
    49.         if mat[j][len(mat)-1] == mat[j+1][len(mat)-1]:
    50.             return 'not over'
    51.     return 'lose'
    52.  
    53.  
    54.  
    55. def reverse(mat):
    56.     new = []
    57.     for i in range(len(mat)):
    58.         new.append([])
    59.         for j in range(len(mat[0])):
    60.             new[i].append(mat[i][len(mat[0])-j-1])
    61.     return new
    62.  
    63.  
    64.  
    65. def transpose(mat):
    66.     new = []
    67.     for i in range(len(mat[0])):
    68.         new.append([])
    69.         for j in range(len(mat)):
    70.             new[i].append(mat[j][i])
    71.     return new
    72.  
    73.  
    74.  
    75. def cover_up(mat):
    76.     new = []
    77.     for j in range(c.GRID_LEN):
    78.         partial_new = []
    79.         for i in range(c.GRID_LEN):
    80.             partial_new.append(0)
    81.         new.append(partial_new)
    82.     done = False
    83.     for i in range(c.GRID_LEN):
    84.         count = 0
    85.         for j in range(c.GRID_LEN):
    86.             if mat[i][j] != 0:
    87.                 new[i][count] = mat[i][j]
    88.                 if j != count:
    89.                     done = True
    90.                 count += 1
    91.     return new, done
    92.  
    93. def merge(mat, done):
    94.     for i in range(c.GRID_LEN):
    95.         for j in range(c.GRID_LEN-1):
    96.             if mat[i][j] == mat[i][j+1] and mat[i][j] != 0:
    97.                 mat[i][j] *= 2
    98.                 mat[i][j+1] = 0
    99.                 done = True
    100.     return mat, done
    101.  
    102. def up(game):
    103.     print("up")
    104.     # return matrix after shifting up
    105.     game = transpose(game)
    106.     game, done = cover_up(game)
    107.     game, done = merge(game, done)
    108.     game = cover_up(game)[0]
    109.     game = transpose(game)
    110.     return game, done
    111.  
    112. def down(game):
    113.     print("down")
    114.     # return matrix after shifting down
    115.     game = reverse(transpose(game))
    116.     game, done = cover_up(game)
    117.     game, done = merge(game, done)
    118.     game = cover_up(game)[0]
    119.     game = transpose(reverse(game))
    120.     return game, done
    121.  
    122. def left(game):
    123.     print("left")
    124.     # return matrix after shifting left
    125.     game, done = cover_up(game)
    126.     game, done = merge(game, done)
    127.     game = cover_up(game)[0]
    128.     return game, done
    129.  
    130. def right(game):
    131.     print("right")
    132.     # return matrix after shifting right
    133.     game = reverse(game)
    134.     game, done = cover_up(game)
    135.     game, done = merge(game, done)
    136.     game = cover_up(game)[0]
    137.     game = reverse(game)
    138.     return game, done

    constants.py

    1. SIZE = 400
    2. GRID_LEN = 4
    3. GRID_PADDING = 10
    4.  
    5. BACKGROUND_COLOR_GAME = "#92877d"
    6. BACKGROUND_COLOR_CELL_EMPTY = "#9e948a"
    7.  
    8. BACKGROUND_COLOR_DICT = {
    9. 2:      "#eee4da",
    10. 4:      "#ede0c8",
    11. 8:      "#f2b179",
    12. 16:     "#f59563",
    13. 32:     "#f67c5f",
    14. 64:     "#f65e3b",
    15. 128:    "#edcf72",
    16. 256:    "#edcc61",
    17. 512:    "#edc850",
    18. 1024:   "#edc53f",
    19. 2048:   "#edc22e",
    20. 4096:   "#eee4da",
    21. 8192:   "#edc22e",
    22. 16384:  "#f2b179",
    23. 32768:  "#f59563",
    24. 65536:  "#f67c5f",
    25. }
    26.  
    27. CELL_COLOR_DICT = {
    28. 2:      "#776e65",
    29. 4:      "#776e65",
    30. 8:      "#f9f6f2",
    31. 16:     "#f9f6f2",
    32. 32:     "#f9f6f2",
    33. 64:     "#f9f6f2",
    34. 128:    "#f9f6f2",
    35. 256:    "#f9f6f2",
    36. 512:    "#f9f6f2",
    37. 1024:   "#f9f6f2",
    38. 2048:   "#f9f6f2",
    39. 4096:   "#776e65",
    40. 8192:   "#f9f6f2",
    41. 16384:  "#776e65",
    42. 32768:  "#776e65",
    43. 65536:  "#f9f6f2",
    44. }
    45.  
    46. FONT = ("Verdana",40,"bold")
    47.  
    48. KEY_QUIT = "Escape"
    49. KEY_BACK = "b"
    50.  
    51. KEY_UP = "Up"
    52. KEY_DOWN = "Down"
    53. KEY_LEFT = "Left"
    54. KEY_RIGHT = "Right"
    55.  
    56. KEY_UP_ALT1 = "w"
    57. KEY_DOWN_ALT1 = "s"
    58. KEY_LEFT_ALT1 = "a"
    59. KEY_RIGHT_ALT1 = "d"
    60.  
    61. KEY_UP_ALT2 = "i"
    62. KEY_DOWN_ALT2 = "k"
    63. KEY_LEFT_ALT2 = "j"
    64. KEY_RIGHT_ALT2 = "l"

    run.py

    1. from tkinter import Frame, Label, CENTER
    2. import random
    3. import logic
    4. import constants as c
    5.  
    6. def gen():
    7.     return random.randint(0, c.GRID_LEN - 1)
    8.  
    9. class GameGrid(Frame):
    10.     def __init__(self):
    11.         Frame.__init__(self)
    12.  
    13.         self.grid()
    14.         self.master.title('2048')
    15.         self.master.bind("", self.key_down)
    16.  
    17.         self.commands = {
    18.             c.KEY_UP: logic.up,
    19.             c.KEY_DOWN: logic.down,
    20.             c.KEY_LEFT: logic.left,
    21.             c.KEY_RIGHT: logic.right,
    22.             c.KEY_UP_ALT1: logic.up,
    23.             c.KEY_DOWN_ALT1: logic.down,
    24.             c.KEY_LEFT_ALT1: logic.left,
    25.             c.KEY_RIGHT_ALT1: logic.right,
    26.             c.KEY_UP_ALT2: logic.up,
    27.             c.KEY_DOWN_ALT2: logic.down,
    28.             c.KEY_LEFT_ALT2: logic.left,
    29.             c.KEY_RIGHT_ALT2: logic.right,
    30.         }
    31.  
    32.         self.grid_cells = []
    33.         self.init_grid()
    34.         self.matrix = logic.new_game(c.GRID_LEN)
    35.         self.history_matrixs = []
    36.         self.update_grid_cells()
    37.  
    38.         self.mainloop()
    39.  
    40.     def init_grid(self):
    41.         background = Frame(self, bg=c.BACKGROUND_COLOR_GAME,width=c.SIZE, height=c.SIZE)
    42.         background.grid()
    43.  
    44.         for i in range(c.GRID_LEN):
    45.             grid_row = []
    46.             for j in range(c.GRID_LEN):
    47.                 cell = Frame(
    48.                     background,
    49.                     bg=c.BACKGROUND_COLOR_CELL_EMPTY,
    50.                     width=c.SIZE / c.GRID_LEN,
    51.                     height=c.SIZE / c.GRID_LEN
    52.                 )
    53.                 cell.grid(
    54.                     row=i,
    55.                     column=j,
    56.                     padx=c.GRID_PADDING,
    57.                     pady=c.GRID_PADDING
    58.                 )
    59.                 t = Label(
    60.                     master=cell,
    61.                     text="",
    62.                     bg=c.BACKGROUND_COLOR_CELL_EMPTY,
    63.                     justify=CENTER,
    64.                     font=c.FONT,
    65.                     width=5,
    66.                     height=2)
    67.                 t.grid()
    68.                 grid_row.append(t)
    69.             self.grid_cells.append(grid_row)
    70.  
    71.     def update_grid_cells(self):
    72.         for i in range(c.GRID_LEN):
    73.             for j in range(c.GRID_LEN):
    74.                 new_number = self.matrix[i][j]
    75.                 if new_number == 0:
    76.                     self.grid_cells[i][j].configure(text="",bg=c.BACKGROUND_COLOR_CELL_EMPTY)
    77.                 else:
    78.                     self.grid_cells[i][j].configure(
    79.                         text=str(new_number),
    80.                         bg=c.BACKGROUND_COLOR_DICT[new_number],
    81.                         fg=c.CELL_COLOR_DICT[new_number]
    82.                     )
    83.         self.update_idletasks()
    84.  
    85.     def key_down(self, event):
    86.         key = event.keysym
    87.         print(event)
    88.         if key == c.KEY_QUIT: exit()
    89.         if key == c.KEY_BACK and len(self.history_matrixs) > 1:
    90.             self.matrix = self.history_matrixs.pop()
    91.             self.update_grid_cells()
    92.             print('back on step total step:', len(self.history_matrixs))
    93.         elif key in self.commands:
    94.             self.matrix, done = self.commands[key](self.matrix)
    95.             if done:
    96.                 self.matrix = logic.add_two(self.matrix)
    97.                 # record last move
    98.                 self.history_matrixs.append(self.matrix)
    99.                 self.update_grid_cells()
    100.                 if logic.game_state(self.matrix) == 'win':
    101.                     self.grid_cells[1][1].configure(text="You", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
    102.                     self.grid_cells[1][2].configure(text="Win!", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
    103.                 if logic.game_state(self.matrix) == 'lose':
    104.                     self.grid_cells[1][1].configure(text="You", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
    105.                     self.grid_cells[1][2].configure(text="Lose!", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
    106.  
    107.     def generate_next(self):
    108.         index = (gen(), gen())
    109.         while self.matrix[index[0]][index[1]] != 0:
    110.             index = (gen(), gen())
    111.         self.matrix[index[0]][index[1]] = 2
    112.  
    113. game_grid = GameGrid()

    操作方式：

    方向键:上下左右

    26键中的:WSAD

    26键中的:IKJL

    ESC键退出游戏，b键返回上一步

    为增加游戏可玩性，此游戏最大叠加数为65536

    运行结果如下所示：

    运行run.py即可开始游戏

     

     

  • 相关阅读:
    C++中类和动态内存分配
    kafka分区迁移失败任务的处理
    npm中的.package-lock.json包管理配置文件 package.json自己创建的包配置文件（npm init -y）
    推荐6个AI工具网站
    Web前端开发具有哪些特点？
    当贝投影4K激光投影X3 Pro获得一致好评：万元投影仪首选
    vscode Coder Runner 运行C++
    使用InstantOC实现动态遮挡剔除 + LOD效果
    MacOS lldb 使用记录
    HCIP--IPV6综合实验
  • 原文地址：https://blog.csdn.net/qq_38563206/article/details/128212265