软件工程第二次作业

这个作业属于哪个课程	<首页 - 软件工程2024 - 福州大学 - 班级博客 - 博客园>
这个作业要求在哪里	<2024秋软件工程个人作业（第二次） - 作业 - 软件工程2024 - 班级博客 - 博客园>
这个作业的目标	<使用Python编写一个“羊了个羊”风格的消除类小游戏>
学号	<102202116>

项目代码已上传至GitHub仓库：Mr0due/-: 瓦了个瓦 (github.com)

1.准备

1.1设计理念

本小游戏主要依托于游戏valorant，中文名无畏契约开发，游戏中图标与背景均取自与valorant。

1.2 工具使用

**· **pygame的下载与使用

· AI工具：chatgpt、kimi

2.游戏介绍

2.1游戏特色

• 简洁的图形界面：使用Pygame库创建直观的用户界面。
• 多模式选择：设置一般模式（较为简单）和竞技模式（较为困难），困难模式三消，增加了图案数量，提高游戏难度。
• 时间限制：设置倒计时，增加游戏的紧张感。
• 加时道具：玩家可以通过点击加时道具来增加额外的游戏时间。

加时道具每局只能加一次，且只会加五秒

2.2游戏玩法

• 玩家通过点击图案选择图案。
• 当选中的图案达到两个或三个时，这些图案将被消除，玩家获得分数。
• 游戏在限定时间内结束，玩家需要在时间耗尽前尽可能获得更多分数。

限定时间原本设为100秒，发现时间还会剩下很多，最终调整为30秒，一不留神时间就不够了。

2.3界面设计

• 主菜单：包含“简单模式”、“困难模式”和“退出游戏”按钮。
• 游戏界面：显示图案网格、倒计时和道具。
• 结束界面：显示得分、“重新开始”和“返回主菜单”按钮。

2.4技术实现

• 使用Python语言和Pygame库进行游戏开发。
• 图像资源通过Pygame加载和缩放。
• 游戏逻辑包括图案生成、事件处理和得分计算。

2.5游戏流程

启动游戏：玩家启动游戏并进入主菜单。

选择难度：玩家选择一般或竞技模式开始游戏。

游戏进行：玩家在限定时间内点击消除图案，可使用加时道具。

游戏结束：时间耗尽或图案消除完毕，显示得分和结束界面。

结束界面：玩家选择“重新开始”或“返回主菜单”。

2.6代码结构

• Start 类：处理主菜单的显示和用户输入。
• Game 类：管理游戏逻辑和游戏界面的更新。
• End 类：处理游戏结束界面的显示和用户输入。

3游戏界面及代码展示

3.1界面展示

主页面

游戏界面

结算界面

成功：

失败：

3.2代码

``

import pygame
import sys
import random
from pygame import *
from time import time

# 初始化Pygame
pygame.init()
pygame.font.init()
# 定义颜色
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

# 定义常量
SCREEN_WIDTH = 600
SCREEN_HEIGHT = 800
tile_size = 100  # 定义图片方块的大小

add_time_icon = pygame.image.load("./pictures/add time icon.png")  # 加载加时间道具图片
add_time_icon = pygame.transform.scale(add_time_icon, (50, 50))  # 缩放道具图片

# 定义游戏变量
clock = pygame.time.Clock()
total_time = 30  # 倒计时30秒
start_time = time()
game_over = False
game_win = False
layer_count = 3  # 图案分层数
can_add_time = True  # 可以加时间的标志

# 加载人物图片
img1 = pygame.image.load("./pictures/1.png")
img2 = pygame.image.load("./pictures/2.png")
img3 = pygame.image.load("./pictures/3.png")
img6 = pygame.image.load("./pictures/6.png")
img4 = pygame.image.load("./pictures/4.png")
img5 = pygame.image.load("./pictures/5.png")
img7 = pygame.image.load("./pictures/7.png")
img8 = pygame.image.load("./pictures/8.png")
img9 = pygame.image.load("./pictures/9.png")

# 缩放图片
img1 = pygame.transform.scale(img1, (tile_size, tile_size))
img2 = pygame.transform.scale(img2, (tile_size, tile_size))
img3 = pygame.transform.scale(img3, (tile_size, tile_size))
img4 = pygame.transform.scale(img4, (tile_size, tile_size))
img5 = pygame.transform.scale(img5, (tile_size, tile_size))
img6 = pygame.transform.scale(img6, (tile_size, tile_size))
img7 = pygame.transform.scale(img7, (tile_size, tile_size))
img8 = pygame.transform.scale(img8, (tile_size, tile_size))
img9 = pygame.transform.scale(img9, (tile_size, tile_size))


# 随机生成成对的人物图片
def generate_tiles(layer_count):
    tiles = []
    images = [img1, img2, img3, img4, img5, img6, img7, img8, img9]  # 动物图片列表
    tile_pairs = []

    # 创建成对的图片
    for img in images:
        for _ in range(layer_count * 2):  # 每个动物生成两对
            tile_pairs.append({"image": img, "rect": pygame.Rect(random.randint(0, SCREEN_WIDTH - tile_size),
                                                                 random.randint(0, SCREEN_HEIGHT - tile_size),
                                                                 tile_size, tile_size), "layer": 0})

    # 随机打乱这些方块的位置
    random.shuffle(tile_pairs)

    return tile_pairs


# 绘制图案
def draw_tiles(tiles, screen):
    for tile in tiles:
        screen.blit(tile["image"], tile["rect"])
        selected_tiles = []
        if tile in selected_tiles:
            pygame.draw.rect(screen, (255, 255, 0), tile["rect"], 2)  # 绘制选中框


# 主游戏循环
def game_loop(screen, font):
    global game_over, game_win
    tiles = generate_tiles(layer_count)
    selected_tiles = []

    while not game_over:
        screen.fill(WHITE)
        elapsed_time = time() - start_time
        remaining_time = total_time - elapsed_time

        if remaining_time <= 0:
            game_over = True
            break

        # 绘制倒计时
        timer_text = font.render(f"剩余时间: {int(remaining_time)}", True, BLACK)
        screen.blit(timer_text, (10, 10))

        # 绘制图案
        draw_tiles(tiles, screen)

        # 检测事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                pos = pygame.mouse.get_pos()
                for tile in tiles:
                    if tile["rect"].collidepoint(pos):
                        if tile in selected_tiles:
                            selected_tiles.remove(tile)
                        else:
                            selected_tiles.append(tile)
                        break

        # 匹配逻辑：如果有两个选择的图案相同则消除
        if len(selected_tiles) == 2:
            if selected_tiles[0]["image"] == selected_tiles[1]["image"]:
                tiles.remove(selected_tiles[0])
                tiles.remove(selected_tiles[1])
            selected_tiles = []

        # 检测胜利条件
        if not tiles:
            game_win = True
            game_over = True

        pygame.display.update()
        clock.tick(30)


# 定义常量
GRID_SIZE = 10
ICON_SIZE = 50
GRID_WIDTH = SCREEN_WIDTH // GRID_SIZE
GRID_HEIGHT = SCREEN_HEIGHT // GRID_SIZE
ICON_COUNT = 9
SLOT_COUNT = 7

# 加载图片和音乐
bg_image = pygame.image.load('./pictures/bg.png')
music = pygame.mixer.music.load('./music/bgm.mp3')
pygame.mixer.music.play(-1)


class Start:
    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption('瓦了个瓦')
        self.big_font = pygame.font.Font('./font/kai.ttf', 130)
        self.font = pygame.font.Font('./font/laihu.ttf', 50)
        self.small_font = pygame.font.Font('./font/msyh.ttf', 20)
        self.start_button_easy = pygame.Rect(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2 - 100, 200, 50)
        self.start_button_hard = pygame.Rect(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2, 200, 50)
        self.exit_button = pygame.Rect(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2 + 100, 200, 50)

    def start(self):
        running = True
        current_difficulty = 'easy'  # 假设默认难度是简单，你可以根据需要调整
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                if event.type == MOUSEBUTTONDOWN:
                    if self.start_button_easy.collidepoint(event.pos):
                        game = Game(difficulty='easy')
                        game.run()
                        running = False
                    elif self.start_button_hard.collidepoint(event.pos):
                        game = Game(difficulty='hard')
                        game.run()
                        running = False
                    elif self.exit_button.collidepoint(event.pos):
                        pygame.quit()
                        sys.exit()
            # 保存当前难度设置
            self.current_difficulty = current_difficulty
            self.draw_main_menu()

    def draw_main_menu(self):
        bg_image = pygame.transform.scale(pygame.image.load('./pictures/bg.png'), (SCREEN_WIDTH, SCREEN_HEIGHT))
        self.screen.blit(bg_image, (0, 0))

        title_text = self.big_font.render('瓦了个瓦', True, WHITE)
        title_rect = title_text.get_rect(center=(SCREEN_WIDTH // 2, 150))
        self.screen.blit(title_text, title_rect)

        start_easy_text = self.font.render('一般模式', True, WHITE)
        self.screen.blit(start_easy_text, (self.start_button_easy.x + 0, self.start_button_easy.y + 10))

        start_hard_text = self.font.render('竞技模式', True, WHITE)
        self.screen.blit(start_hard_text, (self.start_button_hard.x + 0, self.start_button_hard.y + 10))

        exit_text = self.font.render('退出游戏', True, WHITE)
        self.screen.blit(exit_text, (self.exit_button.x + 0, self.exit_button.y + 10))

        # 分行显示游戏规则
        rules_lines = [
            "游戏规则：",
            "1. 一般模式：两个相同图案消除得1分。",
            "2. 竞技模式：三个相同图案消除得1分。",
            "3. 右上角加时道具一次可以加五秒钟。"
        ]
        rules_height = 650  # 规则文本起始的 Y 坐标，位于屏幕垂直方向300像素的位置
        for line in rules_lines:
            rules_text = self.small_font.render(line, True, WHITE)
            rules_rect = rules_text.get_rect(center=(SCREEN_WIDTH // 2, rules_height))
            self.screen.blit(rules_text, rules_rect)
            rules_height += 40  # 更新 Y 坐标以换行

        pygame.display.flip()


class End:
    def __init__(self, screen, result, game):
        self.screen = screen
        self.result = result
        self.game = game
        self.font = pygame.font.Font('./font/laihu.ttf', 70)
        self.button_font = pygame.font.Font('./font/laihu.ttf', 30)
        self.start_button = pygame.Rect(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2 + 100, 200, 50)
        self.menu_button = pygame.Rect(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2 + 180, 200, 50)
        self.background = pygame.image.load(f"./pictures/{result}.png")
        self.background = pygame.transform.scale(self.background, (SCREEN_WIDTH, SCREEN_HEIGHT))

    def draw(self):
        self.screen.blit(self.background, (0, 0))
        result_text = self.font.render("Cheers！" if self.result == "win" else "Time Out！", True, WHITE)
        result_rect = result_text.get_rect(center=(SCREEN_WIDTH // 2 + 5, SCREEN_HEIGHT // 2 - 300))
        self.screen.blit(result_text, result_rect)

        score_text = self.font.render(f"得分: {self.game.score}", True, WHITE)
        score_rect = score_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2-200))
        self.screen.blit(score_text, score_rect)

        start_text = self.button_font.render("重新开始", True, WHITE)
        self.screen.blit(start_text, (self.start_button.x + 35, self.start_button.y + 50))
        menu_text = self.button_font.render("返回主菜单", True, WHITE)
        self.screen.blit(menu_text, (self.menu_button.x + 25, self.menu_button.y + 50))

        pygame.display.update()

    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                if self.start_button.collidepoint(event.pos):
                    self.restart_game()
                elif self.menu_button.collidepoint(event.pos):
                    self.return_to_menu()

    def restart_game(self):
        self.game.reset_game(self.game.difficulty)
        self.game.run()

    def return_to_menu(self):
        self.game.game_over = False
        start = Start()
        start.start()


class Game:
    def __init__(self, difficulty='easy'):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption('瓦了个瓦')
        self.font = pygame.font.Font('./font/kai.ttf', 24)
        self.clock = pygame.time.Clock()
        self.total_time = 30
        self.start_time = time()
        self.game_over = False
        self.game_win = False
        self.layer_count = 3
        self.tiles = self.generate_tiles(self.layer_count)
        self.selected_tiles = []
        self.add_time_button = pygame.Rect(SCREEN_WIDTH - 60, 10, 50, 50)
        self.can_add_time = True
        self.score = 0
        self.difficulty = difficulty

    def generate_tiles(self, layer_count):
        tiles = []
        images = [img1, img2, img3, img4, img5, img6, img7, img8, img9]
        for img in images:
            for _ in range(layer_count * 2):
                tile = {"image": img, "rect": pygame.Rect(random.randint(0, SCREEN_WIDTH - tile_size),
                                                          random.randint(0, SCREEN_HEIGHT - tile_size),
                                                          tile_size, tile_size), "layer": layer_count}
                tiles.append(tile)
        return tiles

    def run(self):
        result = "running"
        while result == "running":
            self.screen.fill(WHITE)
            self.handle_events()
            self.update_game()
            self.draw_game()
            pygame.display.update()
            self.clock.tick(30)
            result = self.check_game_over()

        if result in ["win", "lose"]:
            end_screen = End(self.screen, result, self)
            end_screen.draw()
            while True:
                end_screen.handle_events()

    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.game_over = True
            elif event.type == pygame.MOUSEBUTTONDOWN:
                pos = pygame.mouse.get_pos()
                if self.add_time_button.collidepoint(pos) and self.can_add_time:
                    self.total_time += 5
                    self.start_time += 5
                    self.can_add_time = False
                top_tile = None
                for tile in reversed(self.tiles):
                    if tile["rect"].collidepoint(pos):
                        top_tile = tile
                        break
                if top_tile and top_tile not in self.selected_tiles:
                    self.selected_tiles.append(top_tile)
                    if self.difficulty == 'easy' and len(self.selected_tiles) == 2:
                        if self.selected_tiles[0]["image"] == self.selected_tiles[1]["image"]:
                            for tile in self.selected_tiles:
                                if tile in self.tiles:
                                    self.tiles.remove(tile)
                            self.score += 1
                        self.selected_tiles = []
                    elif self.difficulty == 'hard' and len(self.selected_tiles) == 3:
                        if (self.selected_tiles[0]["image"] == self.selected_tiles[1]["image"] ==
                                self.selected_tiles[2]["image"]):
                            for tile in self.selected_tiles:
                                if tile in self.tiles:
                                    self.tiles.remove(tile)
                            self.score += 1
                        self.selected_tiles = []

    def update_game(self):
        elapsed_time = time() - self.start_time
        self.total_time = 30 - elapsed_time
        if self.total_time <= 0:
            self.game_over = True

    def draw_game(self):
        self.draw_background()
        self.draw_tiles()
        self.draw_add_time_button()
        timer_text = self.font.render(f"剩余时间: {int(self.total_time)}", True, BLACK)
        self.screen.blit(timer_text, (10, 10))

    def draw_add_time_button(self):
        self.screen.blit(add_time_icon, self.add_time_button)  # 绘制加时间按钮

    def draw_background(self):
        bg_image = pygame.transform.scale(pygame.image.load("./pictures/background.png"), (SCREEN_WIDTH, SCREEN_HEIGHT))
        self.screen.blit(bg_image, (0, 0))  # 绘制背景图

    def draw_tiles(self):
        for tile in self.tiles:
            self.screen.blit(tile["image"], tile["rect"])
            if tile in self.selected_tiles:
                pygame.draw.rect(self.screen, (255, 255, 0), tile["rect"], 2)  # 绘制选中框

    def check_game_over(self):
        if not self.tiles:
            self.game_win = True
            self.game_over = True
            return "win"
        elif self.total_time <= 0:
            self.game_over = True
            return "lose"
        return "running"

    def reset_game(self, difficulty):
        self.__init__(difficulty)  # 重置游戏状态并保留难度设置


if __name__ == '__main__':
    start = Start()
    start.start()

4.博客要求

4.1项目介绍

这是一个使用Pygame库编写的基于valorant仿照羊了个羊的简单匹配游戏。玩家需要在限定时间内，通过点击来选择并匹配相同的valorant英雄图案，达到消除并获得分数的目的。游戏有两种难度模式：一般模式和竞技模式。一般模式下，两个相同的图案即可消除并获得分数；竞技模式下，需要三个相同的图案才能消除并获得分数。

前端设计与特色功能：

1. 图形用户界面（GUI）：游戏使用Pygame库创建图形界面，包括开始菜单、游戏界面和结束界面。
2. 计时器：游戏有一个倒计时功能，玩家需要在时间耗尽前尽可能多地消除图案。
3. 加时道具：游戏中包含一个加时道具，玩家可以在关键时刻使用它来增加游戏时间。
4. 难度选择：玩家可以在开始游戏前选择简单模式或困难模式，适应不同玩家的需求。
5. 得分系统：根据玩家消除的图案数量计算得分，并在游戏结束时显示最终得分。

使用的技术和算法：

1. Pygame库：用于创建游戏的图形界面和处理用户输入。
2. 事件驱动编程：游戏循环通过监听事件（如鼠标点击）来响应玩家操作。
3. 随机数生成：使用Python的random模块来随机生成动物图案的位置。
4. 图像处理：使用Pygame的图像处理功能来加载、缩放和渲染动物图案和背景图片。
5. 计时和时间管理：使用time模块来管理游戏的倒计时和加时道具的效果。

实现思路：

1. 初始化：游戏开始时，初始化Pygame库，设置屏幕大小，加载和缩放动物图案以及背景图片。
2. 主游戏循环：游戏的主循环负责处理用户输入、更新游戏状态、绘制界面并更新显示。
3. 图案生成：通过generate_tiles函数随机生成成对的valorant英雄图案，并在游戏区域内随机分布。
4. 图案匹配：在用户点击时，检查是否有两个（一般模式）或三个（竞技模式）相同的图案被选中，如果是，则消除这些图案并更新得分。
5. 计时器：游戏开始时启动一个计时器，实时更新剩余时间，并在时间耗尽时结束游戏。
6. 加时道具：在游戏界面上显示加时道具图标，当玩家点击且道具可用时，增加游戏时间。
7. 游戏结束：当所有图案被消除或时间耗尽时，显示游戏结束界面，并显示最终得分。

图表展示：

[开始游戏]
|
V
[选择难度模式] --> [进入游戏界面]
|
V
[游戏主循环]
|----> [处理用户输入]
|----> [更新游戏状态]
|----> [绘制游戏界面]
|----> [检查游戏结束条件]
|
V
[显示游戏结束界面] --> [显示得分] --> [选择重新开始或退出]

4.2测试

测试用例

1. 测试用例 1：启动游戏
   • 目的：验证游戏能否正常启动并显示主菜单。
   • 步骤：运行游戏。
   • 预期结果：游戏窗口打开，显示主菜单界面。
2. 测试用例 2：选择难度模式
   • 目的：验证玩家能否选择游戏难度。
   • 步骤：点击简单模式或困难模式按钮。
   • 预期结果：游戏开始，难度设置为所选模式。
3. 测试用例 3：图案生成
   • 目的：验证游戏能否正确生成并显示动物图案。
   • 步骤：开始游戏，观察图案。
   • 预期结果：所有动物图案正确生成并随机分布在游戏区域内。
4. 测试用例 4：图案匹配（简单模式）
   • 目的：验证简单模式下两个相同图案能否正确消除。
   • 步骤：在简单模式下，选择两个相同的图案。
   • 预期结果：选中的图案消除，得分增加。
5. 测试用例 5：图案匹配（困难模式）
   • 目的：验证困难模式下三个相同图案能否正确消除。
   • 步骤：在困难模式下，选择三个相同的图案。
   • 预期结果：选中的图案消除，得分增加。
6. 测试用例 6：加时道具使用
   • 目的：验证加时道具能否正确增加游戏时间。
   • 步骤：在游戏时间内点击加时道具。
   • 预期结果：游戏时间增加5秒，加时道具变为不可用状态。
7. 测试用例 7：游戏结束条件
   • 目的：验证游戏在时间耗尽或图案消除完时能否正确结束。
   • 步骤：等待时间耗尽或消除所有图案。
   • 预期结果：游戏结束，显示得分和结束界面。
8. 测试用例 8：重新开始或退出
   • 目的：验证玩家能否在游戏结束后选择重新开始或返回主菜单。
   • 步骤：在游戏结束后点击重新开始或返回主菜单。
   • 预期结果：游戏重新开始或进入主菜单界面。

** 测试结果展示**

测试内容	预期结果	测试结果
图案匹配与消除	点击相同图案三次时图案消除，得分增加	通过
音效播放	不同场景播放不同音效	通过

测试设计评价

本次测试覆盖了项目的主要功能和用户交互逻辑，能够验证游戏基本功能的正确性。

结论

测试用例基本上满足了程序测试需求，能够验证游戏的主要功能和玩家交互。然而，还可以进一步增加一些测试用例，例如：

• 异常输入测试：验证游戏对异常输入（如非常快速的连续点击）的处理。
• 用户界面测试：验证游戏界面在不同分辨率和屏幕尺寸下的显示效果。

4.3AIGC表格

子任务	借助何种AIGC技术	实现了什么功能	效果如何？
游戏逻辑开发	chatgpt	辅助编写游戏循环、事件处理和图案匹配逻辑	显著提高了编码速度和代码质量，减少了编写样板代码的时间
图像资源生成	chatgpt	优化游戏图案和背景	提高了游戏的视觉吸引力，使游戏界面更加生动有趣
文档和注释编写	kimi	辅助编写项目文档和代码注释	提高了文档的质量和专业性，减少了语法和拼写错误

AIGC技术的优缺点

优点：

1. 提高效率：自动化生成内容，减少人工重复劳动。
2. 创意辅助：提供创意灵感，辅助设计师和开发者快速迭代。
3. 个性化定制：根据用户反馈和偏好生成个性化内容。
4. 质量提升：通过AI辅助，提高代码和文档的专业质量。

缺点：

1. 独创性限制：AIGC可能缺乏真正的创新和个性化表达。
2. 依赖数据：生成内容的质量受限于训练数据的质量和多样性。
3. 道德和法律风险：可能涉及版权、隐私和伦理问题。
4. 技术限制：某些复杂任务和高度创造性工作难以完全由AI替代。

适合与不适合的应用

适合应用：

• 内容创作：自动生成文章、图像、音乐等。
• 辅助设计：辅助UI/UX设计，提供布局和视觉设计建议。
• 代码开发：辅助编写和测试代码，提高开发效率。
• 文档撰写：自动生成和校对技术文档和项目报告。

不适合应用：

• 高度创新性工作：需要深度创意和个性化表达的任务。
• 复杂情感交互：需要深刻理解人类情感和文化背景的交流。
• 法律和伦理敏感领域：涉及隐私、版权和伦理判断的任务。
• 专业决策：需要专业知识和经验的复杂决策过程。

学习内容	收获
Pygame 框架使用	精通了Pygame框架的核心机制，包括图形渲染、事件处理和用户输入管理，为复杂游戏逻辑的实现奠定了技术基础。
图案加载与动态调整	掌握了资源动态加载和自适应布局技术，确保了游戏界面在不同设备和分辨率下均能提供一致的用户体验。
图案分布随机性优化	实现了高级随机分布算法，优化了游戏图案的生成逻辑，增强了游戏的挑战性和重玩价值。
时间管理与倒计时逻辑	设计并实现了精确的时间管理系统，通过倒计时机制有效提升了游戏的节奏和玩家的参与度。
AIGC工具应用	有效利用了人工智能辅助生成内容（AIGC）工具，如GitHub Copilot，以提高编码效率和创新设计，探索了AIGC在游戏开发中的前沿应用。

心得体会

• 技术深度与广度：通过本项目，我不仅深化了Pygame框架的技术应用，还拓宽了对游戏设计、界面设计和用户体验的理解。Python的简洁性和Pygame库的强大功能使得游戏开发变得容易上手，同时也让我对游戏开发有了更深的理解。
• 创新与效率：AIGC工具的应用极大地提高了开发效率，例如，GitHub Copilot在编写代码时提供了智能的代码补全，而DALL-E则帮助我快速生成了吸引人的游戏图案和背景。

总的来说，AIGC技术在游戏开发中的应用不仅提高了我的工作效率，也让我对游戏开发的各个方面有了更深入的了解。这些经验对我的未来学习和职业发展都有很大的帮助。

4.4PSP表格

PSP	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	20	20
• Estimate	• 估计这个任务需要多少时间	20	20
Development	开发	535	525
• Analysis	• 需求分析 （包括学习新技术）	40	30
• Design Spec	• 生成设计文档	20	15
• Design Review	• 设计复审	20	10
• Design	• 具体设计	60	75
• Coding	• 具体编码	300	310
• Code Review	• 代码复审	45	40
• Test	• 测试（自我测试，修改代码，提交修改）	50	45
Reporting	报告	125	125
• Test Repor	• 报告	90	100
• Size Measurement	• 计算工作量	15	10
• Postmortem & Process Improvement Plan	• 事后总结, 并提出过程改进计划	20	15
	合计	680	670

4.5用户文档

1. 游戏介绍

《瓦了个瓦》是一款基于Pygame库开发的匹配类游戏。玩家需要在限定时间内，通过点击相同的valorant英雄图案进行消除，以获得分数。游戏提供一般和竞技两种模式，一般模式下两个相同图案消除得1分，竞技模式下三个相同图案消除得1分。

2. 游戏安装

游戏不需要额外安装，只需确保计算机上已安装Python和Pygame库。如果未安装Pygame，可以通过Python的包管理器pip进行安装：

pip install pygame

3. 游戏启动

游戏通过运行主程序文件启动。在命令行中导航到游戏文件所在目录，然后运行以下命令：

python game.py

请确保替换game.py为实际的主程序文件名。

4. 游戏玩法

• 选择模式：游戏开始时，玩家可以选择简单模式或困难模式。
• 图案消除：在游戏区域内，点击选择图案，若选中两个（简单模式）或三个（困难模式）相同的图案，则消除它们并获得分数。
• 加时道具：游戏中有一个加时间道具，点击使用可以增加5秒游戏时间，但每局游戏只能使用一次。
• 游戏结束：当所有图案被消除或时间耗尽时，游戏结束。游戏结束后，玩家可以选择重新开始或返回主菜单。

5. 控制说明

• 鼠标点击：用于选择和消除图案。

6. 游戏设置

• 音效：游戏内置音效。

7. 游戏退出

玩家可以通过点击游戏界面的退出按钮或在游戏菜单中选择退出游戏。

8. 故障排除

如果游戏运行出现问题，可以尝试以下步骤：

• 确保Python和Pygame库是最新版本。
• 检查游戏文件是否完整，无缺失。
• 尝试重新启动游戏或计算机。

9. 版权信息

《瓦了个瓦》由本文作者开发。