【GPT提问技巧】学会提问才是关键！如何让AI用Python生成完整的2048小游戏实战步骤！

前言

在当今的编程世界中，游戏开发不仅是一个有趣的领域，也是一个充满挑战的领域。2048小游戏因其简单的规则和富有挑战性的玩法而广受欢迎。🤔 本文将带你用AI，一步步的实现一个完整的2048小游戏，让你利用AI的能力，提升你对编程的理解。让你不在盲目的找教程。无论你是初学者还是有经验的开发者，这篇文章都将为你提供实用的指导和技巧，帮助你在编程的道路上更进一步！💪

具体步骤（结尾有完整代码↓）

第一步：选择合适的工具

示例：我们选择GPT-4 mini模型来举例

1. 输入问题描述：在GPT-4 mini的输入框中，清晰地描述你想要实现的功能。
2. 获取代码片段：GPT-4 mini会返回一段代码，对这个代码进行测试。
3. 逐步完善：如果返回的代码不完整，可以继续提问，逐步完善代码。（这里一定要记住，GPT目前已经很智能了，你只需要不断的用语言去跟它对话，让它不断地去完善，它就能生成一篇完整的代码）

对于AI工具的选用，例如：Codemoss能用AI 为例！

第二步：提出你的第一个问题

在这个大数据的时代，懂得提问才是成功的关键。学会如何有效地问问题，你就能超越大多数人。

掌握AI的核心，正是学会如何与AI对话。

第一个问AI的问题

用Python实现一个2048小游戏，要求在页面上有上下左右的按钮，可以通过点击进行连续操作，一直到结束为止

AI返回给我了一串代码，此时打开pycharm把代码粘贴过去。我们进行运行。

import tkinter as tk
import random

class Game2048:
    def __init__(self, master):
        self.master = master
        self.master.title("2048 Game")
        self.grid_size = 4
        self.grid = [[0] * self.grid_size for _ in range(self.grid_size)]
        self.score = 0
        self.create_widgets()
        self.new_tile()
        self.new_tile()
        self.update_grid()

    def create_widgets(self):
        self.canvas = tk.Canvas(self.master, width=400, height=400, bg='lightgray')
        self.canvas.pack()

        self.score_label = tk.Label(self.master, text="Score: 0")
        self.score_label.pack()

        self.button_frame = tk.Frame(self.master)
        self.button_frame.pack()

        self.up_button = tk.Button(self.button_frame, text="Up", command=self.move_up)
        self.up_button.grid(row=0, column=1)

        self.left_button = tk.Button(self.button_frame, text="Left", command=self.move_left)
        self.left_button.grid(row=1, column=0)

        self.right_button = tk.Button(self.button_frame, text="Right", command=self.move_right)
        self.right_button.grid(row=1, column=2)

        self.down_button = tk.Button(self.button_frame, text="Down", command=self.move_down)
        self.down_button.grid(row=2, column=1)

    def new_tile(self):
        empty_tiles = [(r, c) for r in range(self.grid_size) for c in range(self.grid_size) if self.grid[r][c] == 0]
        if empty_tiles:
            r, c = random.choice(empty_tiles)
            self.grid[r][c] = 2 if random.random() < 0.9 else 4

    def update_grid(self):
        self.canvas.delete("all")
        for r in range(self.grid_size):
            for c in range(self.grid_size):
                value = self.grid[r][c]
                x, y = c * 100, r * 100
                self.canvas.create_rectangle(x, y, x + 100, y + 100, fill=self.get_color(value))
                if value != 0:
                    self.canvas.create_text(x + 50, y + 50, text=str(value), font=('Arial', 24), fill='white')
        self.score_label.config(text=f"Score: {self.score}")

    def get_color(self, value):
        colors = {
            0: 'lightgray',
            2: '#eee4da',
            4: '#ede0c8',
            8: '#f2b179',
            16: '#f59563',
            32: '#f67c5f',
            64: '#f67c5f',
            128: '#f9f38e',
            256: '#f9f36f',
            512: '#f9f36f',
            1024: '#f9f36f',
            2048: '#f9f36f',
        }
        return colors.get(value, 'orange')

    def move_left(self):
        moved = self.move(-1, 0)
        if moved:
            self.new_tile()
            self.update_grid()

    def move_right(self):
        moved = self.move(1, 0)
        if moved:
            self.new_tile()
            self.update_grid()

    def move_up(self):
        moved = self.move(0, -1)
        if moved:
            self.new_tile()
            self.update_grid()

    def move_down(self):
        moved = self.move(0, 1)
        if moved:
            self.new_tile()
            self.update_grid()

    def move(self, dx, dy):
        moved = False
        for _ in range(self.grid_size):
            for r in range(self.grid_size):
                for c in range(self.grid_size):
                    if self.grid[r][c] != 0:
                        new_r, new_c = r, c
                        while True:
                            next_r, next_c = new_r + dy, new_c + dx
                            if 0 <= next_r < self.grid_size and 0 <= next_c < self.grid_size:
                                if self.grid[next_r][next_c] == 0:
                                    self.grid[next_r][next_c] = self.grid[new_r][new_c]
                                    self.grid[new_r][new_c] = 0
                                    new_r, new_c = next_r, next_c
                                    moved = True
                                elif self.grid[next_r][next_c] == self.grid[new_r][new_c]:
                                    if self.grid[next_r][next_c] != 0:  # Prevent multiple merges
                                        break
                                    self.grid[next_r][next_c] *= 2
                                    self.grid[new_r][new_c] = 0
                                    self.score += self.grid[next_r][next_c]
                                    moved = True
                                    break
                                else:
                                    break
                            else:
                                break
        return moved

if __name__ == "__main__":
    root = tk.Tk()
    game = Game2048(root)
    root.mainloop()

运行后，果然出现了一个2048的页面。但是在玩的过程中，他出现了一个bug，那就是无法对相同的数字进行添加。通过这个bug，我想到了规则。那就是没有告诉AI一个完整的游戏规则。

第三步：对AI进行第二次提问

对AI进行二次提问，那就是把游戏的规则告诉AI。问题如下：

请根据这个2048的规则，重新生成一套完整的代码，规则如下：


2048游戏的基本规则如下‌：游戏界面是一个4x4的方格，每个方格可以存储一个数字或为空。数字的取值为2、4、8、16、32、64、128、256、512、1024、2048。游戏开始时，界面上只有一个方格，其值为2。玩家可以向四个方向（上下左右）滑动，每次滑动时，所有方格向对应方向移动。每次滑动后，系统会在空白处随机生成一个值为2或4的方格。如果两个相同的数字方格相邻，它们会合并，数值相加，例如2和2合并为4，4和4合并为8，以此类推。当棋盘上出现2048的方格时，游戏胜利；当棋盘被数字填满，无法进行有效移动时，游戏失败‌12。

‌详细规则说明‌：
‌初始状态‌：游戏开始时，棋盘内随机出现两个数字，通常为2或4。
‌移动规则‌：玩家可以选择上下左右四个方向之一进行滑动。如果棋盘内的数字方格发生位移或合并，视为有效移动。
‌合并规则‌：如果棋盘上的数字方格移动后，相同的数字方格相邻，则它们会合并，数值相加。例如，两个2合并为4，两个4合并为8，以此类推。
‌生成规则‌：每次有效移动后，棋盘的空位（无数字处）会随机出现一个新的数字方格，数值为2或4。
‌结束条件‌：当棋盘上出现2048的方格时，游戏胜利；当棋盘被数字填满，无法进行有效移动时，游戏失败‌13。
‌游戏技巧‌：
‌大数靠边‌：让最大的数靠边放置，避免被卡住无法合并。
‌有效利用空间‌：善用16宫格，确保每个格子都能得到有效利用。
‌形成势‌：形成一种“势”，即大数在一边，小数在一边，这样相同的数字更容易结合‌

通过规则的完善，AI又给我生成了一套全新的代码。然后在把代码复制到pycharm里面。

import tkinter as tk
import random

class Game2048:
    def __init__(self, master):
        self.master = master
        self.master.title("2048 Game")
        self.grid_size = 4
        self.grid = [[0] * self.grid_size for _ in range(self.grid_size)]
        self.score = 0
        self.game_over = False
        self.create_widgets()
        self.start_game()

    def create_widgets(self):
        self.canvas = tk.Canvas(self.master, width=400, height=400, bg='lightgray')
        self.canvas.pack()

        self.score_label = tk.Label(self.master, text="Score: 0")
        self.score_label.pack()

        self.button_frame = tk.Frame(self.master)
        self.button_frame.pack()

        self.up_button = tk.Button(self.button_frame, text="Up", command=self.move_up)
        self.up_button.grid(row=0, column=1)

        self.left_button = tk.Button(self.button_frame, text="Left", command=self.move_left)
        self.left_button.grid(row=1, column=0)

        self.right_button = tk.Button(self.button_frame, text="Right", command=self.move_right)
        self.right_button.grid(row=1, column=2)

        self.down_button = tk.Button(self.button_frame, text="Down", command=self.move_down)
        self.down_button.grid(row=2, column=1)

        self.restart_button = tk.Button(self.master, text="Restart", command=self.restart)
        self.restart_button.pack()

    def start_game(self):
        self.reset_grid()
        self.add_new_tile()
        self.add_new_tile()
        self.update_grid()

    def reset_grid(self):
        self.grid = [[0] * self.grid_size for _ in range(self.grid_size)]
        self.score = 0
        self.game_over = False

    def add_new_tile(self):
        empty_tiles = [(r, c) for r in range(self.grid_size) for c in range(self.grid_size) if self.grid[r][c] == 0]
        if empty_tiles:
            r, c = random.choice(empty_tiles)
            self.grid[r][c] = 2 if random.random() < 0.9 else 4

    def update_grid(self):
        self.canvas.delete("all")
        for r in range(self.grid_size):
            for c in range(self.grid_size):
                value = self.grid[r][c]
                x, y = c * 100, r * 100
                self.canvas.create_rectangle(x, y, x + 100, y + 100, fill=self.get_color(value))
                if value != 0:
                    self.canvas.create_text(x + 50, y + 50, text=str(value), font=('Arial', 24), fill='white')
        self.score_label.config(text=f"Score: {self.score}")
        if self.game_over:
            self.canvas.create_text(200, 200, text="Game Over", font=('Arial', 48), fill='red')

    def get_color(self, value):
        colors = {
            0: 'lightgray',
            2: '#eee4da',
            4: '#ede0c8',
            8: '#f2b179',
            16: '#f59563',
            32: '#f67c5f',
            64: '#f67c5f',
            128: '#f9f38e',
            256: '#f9f36f',
            512: '#f9f36f',
            1024: '#f9f36f',
            2048: '#f9f36f',
        }
        return colors.get(value, 'orange')

    def move_left(self):
        if self.game_over: return
        moved = self.move(-1, 0)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move_right(self):
        if self.game_over: return
        moved = self.move(1, 0)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move_up(self):
        if self.game_over: return
        moved = self.move(0, -1)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move_down(self):
        if self.game_over: return
        moved = self.move(0, 1)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move(self, dx, dy):
        moved = False
        for _ in range(self.grid_size):
            for r in range(self.grid_size):
                for c in range(self.grid_size):
                    if self.grid[r][c] != 0:
                        new_r, new_c = r, c
                        while True:
                            next_r, next_c = new_r + dy, new_c + dx
                            if 0 <= next_r < self.grid_size and 0 <= next_c < self.grid_size:
                                if self.grid[next_r][next_c] == 0:
                                    self.grid[next_r][next_c] = self.grid[new_r][new_c]
                                    self.grid[new_r][new_c] = 0
                                    new_r, new_c = next_r, next_c
                                    moved = True
                                elif self.grid[next_r][next_c] == self.grid[new_r][new_c]:
                                    if self.grid[next_r][next_c] != 0:  # Prevent multiple merges
                                        break
                                    self.grid[next_r][next_c] *= 2
                                    self.grid[new_r][new_c] = 0
                                    self.score += self.grid[next_r][next_c]
                                    moved = True
                                    if self.grid[next_r][next_c] == 2048:
                                        self.game_over = True  # Winning condition
                                    break
                                else:
                                    break
                            else:
                                break
        return moved

    def check_game_over(self):
        if all(self.grid[r][c] != 0 for r in range(self.grid_size) for c in range(self.grid_size)):
            self.game_over = not any(self.can_merge(r, c) for r in range(self.grid_size) for c in range(self.grid_size))

    def can_merge(self, r, c):
        value = self.grid[r][c]
        if value == 0:
            return False
        for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            nr, nc = r + dr, c + dc
            if 0 <= nr < self.grid_size and 0 <= nc < self.grid_size and self.grid[nr][nc] == value:
                return True
        return False

    def restart(self):
        self.start_game()

if __name__ == "__main__":
    root = tk.Tk()
    game = Game2048(root)
    root.mainloop()

运行成功后，但是又出现了一个bug，那就是两个数字相加，只能添加一次，于是我就让AI再次完善代码。

第四步：修复合并逻辑的bug

问题如下：

按完按钮后，相同的数字无法进行相加，导致游戏无法进行，请修复这个bug。保证游戏可以正常进行

这次生成的代码是彻底修复了我所有的bug。

import tkinter as tk
import random

class Game2048:
    def __init__(self, master):
        self.master = master
        self.master.title("2048 Game")
        self.grid_size = 4
        self.grid = [[0] * self.grid_size for _ in range(self.grid_size)]
        self.score = 0
        self.game_over = False
        self.create_widgets()
        self.start_game()

    def create_widgets(self):
        self.canvas = tk.Canvas(self.master, width=400, height=400, bg='lightgray')
        self.canvas.pack()

        self.score_label = tk.Label(self.master, text="Score: 0")
        self.score_label.pack()

        self.button_frame = tk.Frame(self.master)
        self.button_frame.pack()

        self.up_button = tk.Button(self.button_frame, text="Up", command=self.move_up)
        self.up_button.grid(row=0, column=1)

        self.left_button = tk.Button(self.button_frame, text="Left", command=self.move_left)
        self.left_button.grid(row=1, column=0)

        self.right_button = tk.Button(self.button_frame, text="Right", command=self.move_right)
        self.right_button.grid(row=1, column=2)

        self.down_button = tk.Button(self.button_frame, text="Down", command=self.move_down)
        self.down_button.grid(row=2, column=1)

        self.restart_button = tk.Button(self.master, text="Restart", command=self.restart)
        self.restart_button.pack()

    def start_game(self):
        self.reset_grid()
        self.add_new_tile()
        self.add_new_tile()
        self.update_grid()

    def reset_grid(self):
        self.grid = [[0] * self.grid_size for _ in range(self.grid_size)]
        self.score = 0
        self.game_over = False

    def add_new_tile(self):
        empty_tiles = [(r, c) for r in range(self.grid_size) for c in range(self.grid_size) if self.grid[r][c] == 0]
        if empty_tiles:
            r, c = random.choice(empty_tiles)
            self.grid[r][c] = 2 if random.random() < 0.9 else 4

    def update_grid(self):
        self.canvas.delete("all")
        for r in range(self.grid_size):
            for c in range(self.grid_size):
                value = self.grid[r][c]
                x, y = c * 100, r * 100
                self.canvas.create_rectangle(x, y, x + 100, y + 100, fill=self.get_color(value))
                if value != 0:
                    self.canvas.create_text(x + 50, y + 50, text=str(value), font=('Arial', 24), fill='white')
        self.score_label.config(text=f"Score: {self.score}")
        if self.game_over:
            self.canvas.create_text(200, 200, text="Game Over", font=('Arial', 48), fill='red')

    def get_color(self, value):
        colors = {
            0: 'lightgray',
            2: '#eee4da',
            4: '#ede0c8',
            8: '#f2b179',
            16: '#f59563',
            32: '#f67c5f',
            64: '#f67c5f',
            128: '#f9f38e',
            256: '#f9f36f',
            512: '#f9f36f',
            1024: '#f9f36f',
            2048: '#f9f36f',
        }
        return colors.get(value, 'orange')

    def move_left(self):
        if self.game_over: return
        moved = self.move(-1, 0)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move_right(self):
        if self.game_over: return
        moved = self.move(1, 0)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move_up(self):
        if self.game_over: return
        moved = self.move(0, -1)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move_down(self):
        if self.game_over: return
        moved = self.move(0, 1)
        if moved:
            self.add_new_tile()
            self.update_grid()
            self.check_game_over()

    def move(self, dx, dy):
        moved = False
        merged = [[False] * self.grid_size for _ in range(self.grid_size)]  # Track merged tiles
        for _ in range(self.grid_size):
            for r in range(self.grid_size):
                for c in range(self.grid_size):
                    if self.grid[r][c] != 0:
                        new_r, new_c = r, c
                        while True:
                            next_r, next_c = new_r + dy, new_c + dx
                            if 0 <= next_r < self.grid_size and 0 <= next_c < self.grid_size:
                                if self.grid[next_r][next_c] == 0:
                                    self.grid[next_r][next_c] = self.grid[new_r][new_c]
                                    self.grid[new_r][new_c] = 0
                                    new_r, new_c = next_r, next_c
                                    moved = True
                                elif self.grid[next_r][next_c] == self.grid[new_r][new_c] and not merged[next_r][next_c]:
                                    self.grid[next_r][next_c] *= 2
                                    self.score += self.grid[next_r][next_c]
                                    self.grid[new_r][new_c] = 0
                                    merged[next_r][next_c] = True  # Mark as merged
                                    moved = True
                                    if self.grid[next_r][next_c] == 2048:
                                        self.game_over = True  # Winning condition
                                    break
                                else:
                                    break
                            else:
                                break
        return moved

    def check_game_over(self):
        if all(self.grid[r][c] != 0 for r in range(self.grid_size) for c in range(self.grid_size)):
            self.game_over = not any(self.can_merge(r, c) for r in range(self.grid_size) for c in range(self.grid_size))

    def can_merge(self, r, c):
        value = self.grid[r][c]
        if value == 0:
            return False
        for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            nr, nc = r + dr, c + dc
            if 0 <= nr < self.grid_size and 0 <= nc < self.grid_size and self.grid[nr][nc] == value:
                return True
        return False

    def restart(self):
        self.start_game()

if __name__ == "__main__":
    root = tk.Tk()
    game = Game2048(root)
    root.mainloop()

所以合理的进行提问，那么AI就会提高我们的编程能力，我们不仅可以利用AI编程，更是可以学习AI生成的代码思路。

其实我这次用的是用 Codemoss能用AI里面的 GPT4o mini 实现的，你也可以用更高级的模型按照这个步骤去实现。这样效果会更好！

第五步：整合测试代码

正常的时候只要你的提问没问题，那么AI生成的代码，就会很完善，甚至不用进行整合就可以直接使用。

如果AI给你生成的代码是零零散散的，那么就需要进行这个步骤。那就是对上面的代码进行整合，输出一套完整的代码。

这一步通常是你最后对所有代码非常认可的情况下进行的。