驭码CodeRider 2.0 产品体验：使用CodeRider的Loom模式

发现CodeRider有Loom模式，这个模式是AI自动处理代码写入的，跟Roo、Trae等一样。于是在Loom模式下，像雷电游戏一样，为小游戏加上了僚机和放炸弹的功能。

天马行空skywalk

870人浏览 · 2025-06-12 08:56:27

天马行空skywalk · 2025-06-12 08:56:27 发布

在体验CodeRider 2.0的过程中：驭码CodeRider 2.0 产品体验：在VSCode安装并创建一个雷电小游戏-CSDN博客

发现CodeRider有Loom模式，这个模式是AI自动处理代码写入的，跟Roo、Trae等一样。

于是在Loom模式下，像雷电游戏一样，为小游戏加上了僚机和放炸弹的功能。

CodeRider的Loom模式简介

CodeRider的Loom模式是一种基于生成式人工智能的端到端编程协作模式，通过自然语言交互实现复杂任务拆解、代码生成与全流程自动化，其核心特点及优势如下：

‌一、核心功能与交互方式‌

‌自然语言任务拆解与执行‌
- ‌多层级需求分解‌：支持将模糊需求（如“开发登录系统”）自动拆解为独立子任务（如验证码生成、数据库连接），用户可通过分点描述或模板化字段（任务、目标、步骤、限制条件）细化需求。
- ‌跨文件代码生成‌：支持跨多个文件解析和修改代码，实现智能代码生成与重构，并自动生成中英文注释及代码差异对比（Diff）。
‌全流程自动化与权限控制‌
- ‌计划模式与执行模式‌：计划模式下需用户批准每一步操作，执行模式下可一键完成代码生成与依赖安装；读写系统文件权限需用户授权，确保安全性。（实践下来读写都可以自动完成，执行如python leidian.py需要用户确认一下）
- ‌GitLab深度集成‌：支持直接处理GitLab中的Issue，通过“Loom执行”读取需求并自动生成代码，同时关联需求文档与代码变更，实现可追溯性。（这个没测试）

‌二、技术实现与优势‌

‌仓库级上下文理解‌
- ‌精准代码补全‌：基于项目代码仓库内容实时生成代码推荐，准确率显著提升，支持复杂任务的全流程智能开发。
- ‌多语言支持‌：覆盖Python、Go、JavaScript、Java等主流语言，适应多样化技术栈需求。
‌DevOps工作流融合‌
- ‌智能评审与安全扫描‌：在代码评审阶段自动聚合变更与安全报告，提升审核效率与准确性；支持安全扫描智能解析，确保代码合规性。
- ‌流水线管理‌：与GitLab DevOps流水线深度融合，实现需求理解、代码编写、合并请求处理、代码审查等环节的AI赋能。

‌三、典型应用场景‌

‌快速项目搭建‌
- ‌全栈代码生成‌：从零生成完整项目架构，包括技术方案、代码实现与单元测试，大幅缩短开发周期。
- ‌企业级私有化部署‌：支持本地化部署或私有云部署，确保代码、数据及知识资产全程隔离，满足数据隐私与安全性要求。
‌复杂任务自动化‌
- ‌端到端需求执行‌：以“移除管理仪表盘二维码”为例，用户输入需求后，Loom可全自动完成编码、改码及运行，实现需求的一次性成功交付。
- ‌智能优化建议‌：根据代码文件生成单元测试、代码优化建议等，辅助开发者提升代码质量。

‌四、用户体验与效率提升‌

‌沉浸式代码辅助‌
- ‌多轮对话技术问答‌：支持与企业私有文档、代码库联动，高效解决工作中的问题，提升企业内部数字资源的应用价值。
- ‌实时反馈与迭代‌：若输出结果不符预期，用户可提供错误代码片段并指定修改方向（如“循环逻辑冗余，请改用哈希表优化”），实现快速迭代优化。
‌开发效率显著提升‌
- ‌减少重复劳动‌：通过AI生成代码、注释与测试用例，开发者可专注于业务逻辑实现。
- ‌降低协作成本‌：需求文档与代码的双向关联，减少沟通误差，提升团队协作效率。

实践

prompt1：帮我优化leidian.py文件，这是一个雷电游戏的python代码文件，请帮我加上僚机系统

僚机系统已基本实现，包括：
添加了Wingman僚机类
修改了Player类以支持僚机
在游戏初始化时创建僚机
获得激光武器时解锁僚机
现在需要测试僚机功能是否正常工作
建议用户运行游戏查看僚机效果
僚机功能包括：
跟随玩家移动
自动射击
与玩家武器系统联动

prompt2：请加上炸弹系统，即按“b” ，则全屏的敌机等全被消灭。

已成功添加炸弹系统功能：

在系统初始化部分添加了炸弹系统实例化
在按键检测中添加了'b'键检测，用于激活炸弹
炸弹功能会消灭所有敌机和敌机子弹，并有5秒冷却时间
消灭的敌机会正常计分并计入关卡进度
现在可以运行游戏，按'b'键测试炸弹功能。

注意：这里的'b'键，实测下来是Alt+b的组合键。

小波折

中间碰到过一次VSCode异常退出的问题。

VSCode异常退出，导致CodeRider 代码可能是写到一半就中断了，导致游戏代码根本没法运行。

不过并没有明确的告诉它VSCode异常退出，只是让它完成诸如加入僚机或炸弹的功能，它就顺便自动修复了代码，还是挺值得夸赞的！

中间碰到过一次Diff Edit Failed

This usually happens when the model uses search patterns that don't match anything in the file. Retrying...

CodeRider 自动发现了问题，并进行解决：

之前的替换失败是因为SEARCH块没有完全匹配文件内容
需要更精确地匹配文件中的代码段
将分步骤实现僚机系统：
先添加Wingman类定义
然后修改Player类
最后更新游戏主循环
这次使用更精确的SEARCH块匹配

最终代码

雷电游戏还是挺好玩的，大家都来玩啊！

把文件存盘为leidian.py，然后执行python leidian.py 节课。需要安装pygame这个依赖库。

import pygame
import random
import sys
import math

# 初始化pygame
pygame.init()

# 屏幕设置
SCREEN_WIDTH = 480
SCREEN_HEIGHT = 640
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("雷电游戏 Leidian Game")

# 颜色定义
WHITE = (255, 255, 255)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)
YELLOW = (255, 255, 0)
PURPLE = (200, 0, 200)
CYAN = (0, 255, 255)
ORANGE = (255, 165, 0)

# 僚机类
class Wingman(pygame.sprite.Sprite):
    def __init__(self, player, offset_x):
        super().__init__()
        self.image = pygame.Surface((30, 25))
        self.image.fill(CYAN)
        self.rect = self.image.get_rect()
        self.player = player
        self.offset_x = offset_x
        self.speed = 8
        self.shoot_timer = 0
        
    def update(self):
        # 跟随玩家移动
        self.rect.centerx = self.player.rect.centerx + self.offset_x
        self.rect.centery = self.player.rect.centery - 30
        
        # 自动射击
        self.shoot_timer += 1
        if self.shoot_timer >= 30:  # 每30帧射击一次
            self.shoot_timer = 0
            bullet = Bullet(self.rect.centerx, self.rect.top, 5, 15, damage=5)
            all_sprites.add(bullet)
            bullets.add(bullet)

# 玩家飞机类
class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((50, 40))
        self.image.fill(BLUE)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH // 2
        self.rect.bottom = SCREEN_HEIGHT - 10
        self.speed = 8
        self.health = 100
        self.wingmen = pygame.sprite.Group()
        
    def update(self):
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT] and self.rect.left > 0:
            self.rect.x -= self.speed
        if keys[pygame.K_RIGHT] and self.rect.right < SCREEN_WIDTH:
            self.rect.x += self.speed
        if keys[pygame.K_UP] and self.rect.top > 0:
            self.rect.y -= self.speed
        if keys[pygame.K_DOWN] and self.rect.bottom < SCREEN_HEIGHT:
            self.rect.y += self.speed

# 子弹类
# class Bullet(pygame.sprite.Sprite):
#     def __init__(self, x, y, width=5, height=10, damage=1):
#         super().__init__()
#         self.image = pygame.Surface((width, height))
#         self.image.fill(WHITE)
#         self.rect = self.image.get_rect()
#         self.rect.centerx = x
#         self.rect.bottom = y
#         self.speed = 10
#         self.damage = damage

#     def update(self):
#         self.rect.y -= self.speed
#         if self.rect.bottom < 0:
#             self.kill()
# 修改子弹类以支持横向移动
class Bullet(pygame.sprite.Sprite):
    def __init__(self, x, y, width=5, height=10, damage=1):
        super().__init__()
        self.image = pygame.Surface((width, height))
        self.image.fill(WHITE)  # 默认颜色，具体颜色由武器系统设置
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.bottom = y
        self.speed_y = -10  # 默认向上速度
        self.speed_x = 0    # 初始无横向移动
        self.damage = damage

    def update(self):
        self.rect.y += self.speed_y
        self.rect.x += self.speed_x
        if (self.rect.bottom < 0 or self.rect.top > SCREEN_HEIGHT or
            self.rect.right < 0 or self.rect.left > SCREEN_WIDTH):
            self.kill()

# 敌机类
class Enemy(pygame.sprite.Sprite):
    def __init__(self, enemy_type="normal"):
        super().__init__()
        self.enemy_type = enemy_type
        if enemy_type == "normal":
            self.image = pygame.Surface((30, 30))
            self.image.fill(RED)
            self.health = 1
            self.speedy = random.randrange(2, 4)
        elif enemy_type == "fast":
            self.image = pygame.Surface((24, 24))
            self.image.fill(YELLOW)
            self.health = 1
            self.speedy = random.randrange(4, 7)
        elif enemy_type == "tank":
            self.image = pygame.Surface((40, 38))
            self.image.fill((100, 100, 255))
            self.health = 4
            self.speedy = random.randrange(1, 3)

        self.rect = self.image.get_rect()
        self.rect.x = random.randrange(SCREEN_WIDTH - self.rect.width)
        self.rect.y = random.randrange(-100, -40)

    def update(self):
        self.rect.y += self.speedy
        if self.rect.top > SCREEN_HEIGHT:
            self.rect.x = random.randrange(SCREEN_WIDTH - self.rect.width)
            self.rect.y = random.randrange(-100, -40)
            if self.enemy_type == "normal":
                self.speedy = random.randrange(2, 4)
            elif self.enemy_type == "fast":
                self.speedy = random.randrange(4, 7)
            elif self.enemy_type == "tank":
                self.speedy = random.randrange(1, 3)

    def take_damage(self, amount):
        self.health -= amount
        if self.health <= 0:
            self.kill()
            return True
        return False

# Boss敌机类
class BossEnemy(pygame.sprite.Sprite):
    def __init__(self, tier):
        super().__init__()
        self.enemy_type = "boss"
        self.image = pygame.Surface((80, 80))
        self.image.fill(PURPLE)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH // 2
        self.rect.y = -100
        self.speed = 1
        # self.health = tier * 100
        # self.max_health = tier * 100
        # self.attack_pattern = "move_down"
        # self.attack_timer = 0
        # self.tier = tier
        self.tier = max(1, tier)  # 确保tier至少为1
        self.health = self.tier * 100
        self.max_health = self.tier * 100  # 确保max_health永远不会为0
        self.attack_pattern = "move_down"
        self.attack_timer = 0
        
    def update(self):
        self._movement_pattern()
        self._attack_pattern()
        
    def _movement_pattern(self):
        if self.attack_pattern == "move_down":
            self.rect.y += self.speed
            if self.rect.top >= 100:
                self.attack_pattern = "left_right"
        elif self.attack_pattern == "left_right":
            self.rect.x += self.speed * (1 if self.rect.centerx < SCREEN_WIDTH // 2 else -1)
            if self.rect.left <= 0 or self.rect.right >= SCREEN_WIDTH:
                self.speed *= -1
    
    def _attack_pattern(self):
        self.attack_timer += 1
        if self.attack_timer % (60 - self.tier * 5) == 0:
            self._shoot_bullets()
    
    def _shoot_bullets(self):
        for angle in range(-30, 31, 15):
            bullet = EnemyBullet(self.rect.centerx, self.rect.bottom, 
                               speed=3, angle=math.radians(angle), damage=10)
            all_sprites.add(bullet)
            enemy_bullets.add(bullet)
    
    def take_damage(self, amount):
        self.health -= amount
        if self.health <= 0:
            self.kill()
            power_up = PowerUp(self.rect.centerx, self.rect.centery)
            all_sprites.add(power_up)
            power_ups.add(power_up)
            return True
        return False

# 敌机子弹类
class EnemyBullet(pygame.sprite.Sprite):
    def __init__(self, x, y, speed=3, angle=0, damage=10):
        super().__init__()
        self.image = pygame.Surface((8, 16))
        self.image.fill((255, 128, 0))
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.top = y
        self.speed = speed
        self.angle = angle
        self.damage = damage
        self.vx = speed * math.sin(angle)
        self.vy = speed * math.cos(angle)

    def update(self):
        self.rect.x += int(self.vx)
        self.rect.y += int(self.vy)
        if (self.rect.top > SCREEN_HEIGHT or 
            self.rect.bottom < 0 or 
            self.rect.right < 0 or 
            self.rect.left > SCREEN_WIDTH):
            self.kill()

# 激光类
class LaserBeam(pygame.sprite.Sprite):
    def __init__(self, x, y, width, height, damage=30):
        super().__init__()
        # 激光高度直接设为屏幕高度
        self.image = pygame.Surface((width, SCREEN_HEIGHT-4), pygame.SRCALPHA)
        # 创建渐变效果
        for i in range(width):
            alpha = 255 - int(i * 100 / width)
            pygame.draw.line(self.image, (0, 255, 255, alpha), (i, 0), (i, SCREEN_HEIGHT), 1)
        
        self.rect = self.image.get_rect()
        self.rect.x = x - width // 2  # 居中激光
        self.rect.y = 0  # 从屏幕顶部开始
        self.damage = damage
        self.lifetime = 30  # 激光持续时间

    def update(self):
        self.lifetime -= 1
        if self.lifetime <= 0:
            self.kill()

    def draw(self, surface):
        # 自定义绘制方法确保透明效果正确
        surface.blit(self.image, self.rect)

# 道具类
class PowerUp(pygame.sprite.Sprite):
    def __init__(self, x, y, kind="weapon"):
        super().__init__()
        self.image = pygame.Surface((24, 24))
        self.image.fill(GREEN)
        self.rect = self.image.get_rect()
        self.rect.center = (x, y)
        self.kind = kind
        self.speed = 3

    def update(self):
        self.rect.y += self.speed
        if self.rect.top > SCREEN_HEIGHT:
            self.kill()

# 武器系统
class WeaponSystem:
    def __init__(self, player):
        self.player = player
        self.current_weapon = "single"
        self.weapon_cooldown = {"single": 10, 
                                "double": 15, 
                                "laser": 60,
                                "shotgun": 20  # 霰弹枪冷却时间
                                }
        self.cooldown = 0
        self.active_lasers = pygame.sprite.Group()
        self.auto_fire = False  # 新增自动射击模式标志

        # 武器颜色映射
        self.weapon_colors = {
            "single": WHITE,
            "double": YELLOW,
            "laser": (0, 255, 255),  # 青色
            "shotgun": ORANGE  # 霰弹枪子弹颜色
            }
        
    def update(self):
        if self.cooldown > 0:
            self.cooldown -= 1

        # 自动射击模式下持续发射子弹
        if self.auto_fire and self.cooldown <= 0:
            self._fire_weapon()

    # 新增方法处理武器发射逻辑
    def _fire_weapon(self):
        if self.current_weapon == "single":
            self._shoot_single()
        elif self.current_weapon == "double":
            self._shoot_double()
        elif self.current_weapon == "laser":
            self._shoot_laser()
        elif self.current_weapon == "shotgun":
            self._shoot_shotgun()
        self.cooldown = self.weapon_cooldown[self.current_weapon]
        
    def shoot(self):
        # 只在非自动模式下或手动触发时发射
        if not self.auto_fire and self.cooldown <= 0:
            self._fire_weapon()
    
    def _shoot_single(self):
        bullet = Bullet(self.player.rect.centerx, self.player.rect.top, 5, 20, damage=10)
        all_sprites.add(bullet)
        bullets.add(bullet)
    
    def _shoot_double(self):
        bullet_left = Bullet(self.player.rect.left + 10, self.player.rect.top, 5, 15, damage=8)
        bullet_right = Bullet(self.player.rect.right - 10, self.player.rect.top, 5, 15, damage=8)
        all_sprites.add(bullet_left, bullet_right)
        bullets.add(bullet_left, bullet_right)
    
    def _shoot_laser(self):
        # 创建贯穿全屏的激光
        # laser = LaserBeam(self.player.rect.centerx, 0, 8, damage=50)  # 更宽更强大的激光
        laser = LaserBeam(self.player.rect.centerx - 2, 0, 4, SCREEN_HEIGHT)
        all_sprites.add(laser)
        lasers.add(laser)

    # 新增霰弹枪射击方法
    def _shoot_shotgun(self):
        # 发射5发散弹，中间3发有20度扩散角度
        spread_angle = 20  # 扩散角度
        bullets_count = 5
        middle_bullet = bullets_count // 2
        
        for i in range(bullets_count):
            # 计算每发散弹的角度偏移
            angle_offset = (i - middle_bullet) * (spread_angle / middle_bullet)
            radian = math.radians(angle_offset)
            
            # 创建子弹并设置初始位置
            bullet = Bullet(
                x=self.player.rect.centerx,
                y=self.player.rect.top,
                width=8,  # 霰弹枪子弹稍大
                height=15,
                damage=6  # 单发伤害略低
            )
            bullet.image.fill(self.weapon_colors["shotgun"])  # 使用橙色
            
            # 设置子弹速度方向
            bullet.speed_x = 3 * math.sin(radian)  # 水平速度分量
            bullet.speed_y = -10  # 固定向上速度
            
            all_sprites.add(bullet)
            bullets.add(bullet)

# 关卡系统
class LevelSystem:
    def __init__(self):
        self.current_level = 1
        self.enemy_count = 8
        self.enemy_speed_range = (1, 4)
        self.spawn_rate = 60
        self.timer = 0
        self.enemies_defeated = 0
        self.enemies_required = 20
        self.total_levels = 10  # 总关卡数
        
    def update(self):
        self.timer += 1
        if self.timer == 1 or (self.timer % self.spawn_rate == 0 and len(enemies) < self.enemy_count):
            self._spawn_enemy()
        
        if self._is_level_complete():
            self._next_level()
            
    def _spawn_enemy(self):
        enemy_types = ["normal", "fast", "tank"]
        weights = [0.6, 0.3, 0.1]
        enemy_type = random.choices(enemy_types, weights=weights)[0]
        enemy = Enemy(enemy_type)
        
        enemy.rect.x = random.randrange(SCREEN_WIDTH - enemy.rect.width)
        enemy.rect.y = random.randrange(-100, -40)
        
        all_sprites.add(enemy)
        enemies.add(enemy)
    
    def enemy_defeated(self, enemy_type):
        self.enemies_defeated += 1
        
    def _is_level_complete(self):
        return self.enemies_defeated >= self.enemies_required
    
    def is_game_complete(self):
        return self.current_level >= self.total_levels
    
    def _next_level(self):
        if self.is_game_complete():
            return
            
        self.current_level += 1
        self.enemies_defeated = 0
        self.enemies_required = 20 + self.current_level * 5
        self.enemy_count = 8 + self.current_level * 2
        self.enemy_speed_range = (1, min(4 + self.current_level // 2, 8))
        self.spawn_rate = max(30, 60 - self.current_level * 5)
        
        # if self.current_level % 5 == 0:
        if self.current_level % 2 == 0:
            self._spawn_boss()
            self.enemies_required = 1
    
    def _spawn_boss(self):
        boss = BossEnemy(self.current_level // 5)
        all_sprites.add(boss)
        bosses.add(boss)
        enemies.add(boss)

# 计分系统
class ScoreSystem:
    def __init__(self):
        self.score = 0
        self.multiplier = 1
        self.combo = 0
        self.combo_timer = 0
        self.high_score = 0
        
    def add_score(self, enemy_type):
        base_scores = {
            "normal": 100,
            "fast": 150,
            "tank": 200,
            "boss": 1000
        }
        self.combo += 1
        self.combo_timer = 180
        
        if self.combo >= 20:
            self.multiplier = 4
        elif self.combo >= 10:
            self.multiplier = 2
        else:
            self.multiplier = 1
            
        # self.score += base_scores[enemy_type] * self.multiplier
        self.score += base_scores.get(enemy_type, 0) * self.multiplier  # 使用get方法提供默认值以防万一
    
    def update(self):
        if self.combo_timer > 0:
            self.combo_timer -= 1
        else:
            self.combo = 0
            self.multiplier = 1
    
    def draw(self, screen):
        font = pygame.font.SysFont(None, 36)
        score_text = font.render(f"分数Sco: {self.score}", True, WHITE)
        screen.blit(score_text, (SCREEN_WIDTH - 150, 10))
        
        if self.multiplier > 1:
            combo_text = font.render(f"x{self.multiplier} {self.combo}连击连击", True, YELLOW)
            screen.blit(combo_text, (SCREEN_WIDTH - 150, 50))

def draw_health_bar(surface, player, x=10, y=50, width=120, height=18):
    pygame.draw.rect(surface, WHITE, (x, y, width, height), 2)
    health_width = int(width * max(player.health, 0) / 100)
    color = GREEN if player.health > 50 else YELLOW if player.health > 20 else RED
    pygame.draw.rect(surface, color, (x+2, y+2, health_width-4, height-4))
    font = pygame.font.SysFont(None, 20)
    text = font.render(f'HP {player.health}', True, WHITE)
    surface.blit(text, (x + width//2 - 25, y+1))

def draw_boss_health_bar(surface, boss):
    if not bosses:
        return
        
    width = SCREEN_WIDTH - 40
    height = 15
    x = 20
    y = 20
    
    # 防止max_health为0的情况
    max_hp = max(1, boss.max_health)  # 确保分母不会为0
    current_hp = max(0, boss.health)  # 确保血量不会为负
    
    # 计算血条宽度
    health_width = int(width * current_hp / max_hp)
    
    # 绘制血条背景和外框
    pygame.draw.rect(surface, (50, 50, 50), (x, y, width, height))  # 背景
    pygame.draw.rect(surface, WHITE, (x, y, width, height), 2)      # 外框
    
    # 绘制当前血量
    color = (255, 0, 0)  # 红色血条
    pygame.draw.rect(surface, color, (x+2, y+2, health_width-4, height-4))
    
    # 绘制Boss血量和等级信息
    font = pygame.font.SysFont(None, 20)
    text = font.render(f'Boss HP {current_hp}/{max_hp} (LV:{boss.tier})', True, WHITE)
    surface.blit(text, (x + width//2 - text.get_width()//2, y-20))

def draw_game_over(screen, win=False):
    screen.fill((0, 0, 0))
    font_large = pygame.font.SysFont(None, 72)
    font_small = pygame.font.SysFont(None, 36)
    
    title_text = font_large.render("游戏胜利Victory" if win else "游戏结束Game Over", True, GREEN if win else RED)
    score_text = font_small.render(f"最终分数Score: {score_system.score}", True, WHITE)
    restart_text = font_small.render("按空格键重新开始Press Space to Restart", True, WHITE)
    
    screen.blit(title_text, (SCREEN_WIDTH//2 - title_text.get_width()//2, SCREEN_HEIGHT//2 - 100))
    screen.blit(score_text, (SCREEN_WIDTH//2 - score_text.get_width()//2, SCREEN_HEIGHT//2))
    screen.blit(restart_text, (SCREEN_WIDTH//2 - restart_text.get_width()//2, SCREEN_HEIGHT//2 + 50))

# 炸弹系统
class BombSystem:
    def __init__(self):
        self.cooldown = 0
        self.max_cooldown = 300  # 5秒冷却(60帧/秒)
        
    def update(self):
        if self.cooldown > 0:
            self.cooldown -= 1
            
    def activate(self):
        if self.cooldown <= 0:
            # 消灭所有敌机和敌机子弹
            for enemy in enemies:
                score_system.add_score(enemy.enemy_type)
                level_system.enemy_defeated(enemy.enemy_type)
                enemy.kill()
                
            for bullet in enemy_bullets:
                bullet.kill()
                
            self.cooldown = self.max_cooldown
            return True
        return False

# 添加重置游戏函数
def reset_game():
    # 清空所有精灵组
    all_sprites.empty()
    enemies.empty()
    bullets.empty()
    lasers.empty()
    enemy_bullets.empty()
    power_ups.empty()
    bosses.empty()
    
    # 重置玩家
    global player
    player = Player()
    all_sprites.add(player)
    
    # 重置系统
    global weapon_system, level_system, score_system, bomb_system
    weapon_system = WeaponSystem(player)
    level_system = LevelSystem()
    score_system = ScoreSystem()
    bomb_system = BombSystem()
    
    # 生成初始敌人和僚机
    for i in range(5):
        level_system._spawn_enemy()
        
    # 创建初始僚机
    wingman_left = Wingman(player, -30)
    wingman_right = Wingman(player, 30)
    player.wingmen.add(wingman_left, wingman_right)
    all_sprites.add(wingman_left, wingman_right)
    
    # 重置游戏状态
    return "playing"

# 创建精灵组
all_sprites = pygame.sprite.Group()
enemies = pygame.sprite.Group()
bullets = pygame.sprite.Group()
lasers = pygame.sprite.Group()
enemy_bullets = pygame.sprite.Group()
power_ups = pygame.sprite.Group()
bosses = pygame.sprite.Group()

# 创建玩家和系统
player = Player()
all_sprites.add(player)
weapon_system = WeaponSystem(player)
level_system = LevelSystem()
score_system = ScoreSystem()
bomb_system = BombSystem()  # 初始化炸弹系统

# 创建初始僚机
wingman_left = Wingman(player, -30)
wingman_right = Wingman(player, 30)
player.wingmen.add(wingman_left, wingman_right)
all_sprites.add(wingman_left, wingman_right)

# 初始敌机
for i in range(5):
    level_system._spawn_enemy()

# 游戏主循环
clock = pygame.time.Clock()
running = True
game_state = "playing"  # playing, game_over, victory, pause

while running:
    clock.tick(60)
    
    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE and game_state == "playing":
                weapon_system.shoot()
            elif event.key == pygame.K_0:  # 按4切换自动射击模式
                weapon_system.auto_fire = not weapon_system.auto_fire
            elif event.key == pygame.K_1 and game_state == "playing":
                weapon_system.current_weapon = "single"
            elif event.key == pygame.K_2 and game_state == "playing":
                weapon_system.current_weapon = "double"
            elif event.key == pygame.K_3 and game_state == "playing":
                weapon_system.current_weapon = "laser"
            if event.key == pygame.K_4:  # 按4切换霰弹枪
                weapon_system.current_weapon = "shotgun"
            elif event.key == pygame.K_b and game_state == "playing":  # 按b键使用炸弹
                bomb_system.activate()
            elif event.key == pygame.K_p and game_state == "playing":
                game_state = "pause"
            elif event.key == pygame.K_p and game_state == "pause":
                game_state = "playing"
            elif event.key == pygame.K_SPACE and game_state == "victory":
                game_state = reset_game()
            elif event.key == pygame.K_SPACE and game_state == "game_over":
                game_state = reset_game()
    
    # 按住空格键持续射击
    if game_state == "playing" and pygame.key.get_pressed()[pygame.K_SPACE]:
        weapon_system.shoot()
    
    if game_state == "playing":
        # 更新系统
        all_sprites.update()
        weapon_system.update()
        level_system.update()
        score_system.update()
        
        # 检查游戏胜利条件
        if level_system.is_game_complete() and not bosses :
        # if level_system.is_game_complete() and not bosses and len(enemies) == 0:
            
            game_state = "victory"
        
        # 碰撞检测
        hits = pygame.sprite.groupcollide(bullets, enemies, True, False)
        for bullet, enemy_list in hits.items():
            for enemy in enemy_list:
                if enemy.take_damage(bullet.damage):
                    score_system.add_score(enemy.enemy_type)
                    level_system.enemy_defeated(enemy.enemy_type)
        
        hits = pygame.sprite.groupcollide(lasers, enemies, False, False)
        for laser, enemy_list in hits.items():
            for enemy in enemy_list:
                if enemy.take_damage(laser.damage):
                    score_system.add_score(enemy.enemy_type)
                    level_system.enemy_defeated(enemy.enemy_type)
        
        if pygame.sprite.spritecollide(player, enemies, True):
            player.health -= 1
            if player.health <= 0:
                game_state = "game_over"
                
        if pygame.sprite.spritecollide(player, enemy_bullets, True):
            player.health -= 5
            if player.health <= 0:
                game_state = "game_over"
                
        hits = pygame.sprite.spritecollide(player, power_ups, True)
        for powerup in hits:
            if weapon_system.current_weapon == "single":
                weapon_system.current_weapon = "double"
            elif weapon_system.current_weapon == "double":
                weapon_system.current_weapon = "laser"
                # 获得激光武器时解锁僚机
                if len(player.wingmen) < 2:
                    wingman_left = Wingman(player, -30)
                    wingman_right = Wingman(player, 30)
                    player.wingmen.add(wingman_left, wingman_right)
                    all_sprites.add(wingman_left, wingman_right)
        
        # 渲染
        screen.fill((0, 0, 0))
        all_sprites.draw(screen)
        score_system.draw(screen)
        draw_health_bar(screen, player)
        
        if bosses:
            draw_boss_health_bar(screen, bosses.sprites()[0])
        
        font = pygame.font.SysFont(None, 28)
        weapon_text = font.render(f"武器Weapon: {'普通' if weapon_system.current_weapon == 'single' else '双发' if weapon_system.current_weapon == 'double' else '激光'}", 
                                True, CYAN)
        screen.blit(weapon_text, (10, SCREEN_HEIGHT - 40))
        
        level_text = font.render(f"关卡Ka:{level_system.current_level}/{level_system.total_levels}", True, CYAN)
        screen.blit(level_text, (10, SCREEN_HEIGHT - 70))
        
        # 显示调试信息
        debug_font = pygame.font.SysFont(None, 20)
        debug_info = f"FPS: {int(clock.get_fps())}"
        debug_text = debug_font.render(debug_info, True, (200, 200, 200))
        screen.blit(debug_text, (10, 10))
        
    elif game_state == "pause":
        screen.fill((0, 0, 0))
        font = pygame.font.SysFont(None, 72)
        pause_text = font.render("游戏暂停Pause", True, WHITE)
        continue_text = pygame.font.SysFont(None, 36).render("按P键继续游戏", True, WHITE)
        
        screen.blit(pause_text, (SCREEN_WIDTH//2 - pause_text.get_width()//2, SCREEN_HEIGHT//2 - 50))
        screen.blit(continue_text, (SCREEN_WIDTH//2 - continue_text.get_width()//2, SCREEN_HEIGHT//2 + 30))
    
    elif game_state == "game_over":
        draw_game_over(screen, win=False)
    
    elif game_state == "victory":
        draw_game_over(screen, win=True)
    
    pygame.display.flip()

pygame.quit()
sys.exit()

调试

碰到报错Requested token count exceeds the model's maximum context length of 65536 tokens

Requested token count exceeds the model's maximum context length of 65536 tokens. You requested a total of 66156 tokens: 57964 tokens from the input messages and 8192 tokens for the completion. Please reduce the number of tokens in the input messages or the completion to fit within the limit.

最大64ktoken，这个确实有点小了，怎么也要256k才比较好用。

天启AI社区

GitCode 天启AI是一款由 GitCode 团队打造的智能助手，基于先进的LLM（大语言模型）与多智能体 Agent 技术构建，致力于为用户提供高效、智能、多模态的创作与开发支持。它不仅支持自然语言对话，还具备处理文件、生成 PPT、撰写分析报告、开发 Web 应用等多项能力，真正做到“一句话，让 Al帮你完成复杂任务”。

更多推荐