用AI写游戏3——python实现坦克大战1

用python实现一个坦克大战小游戏，屏幕大小宽高1000x800px 敌人有10个坦克，会发射子弹，会随机自由移动，碰撞到屏幕边界会反弹， 我方是一个黄颜色坦克，能发子弹，能移动，子弹集中敌人坦克就爆炸消失，并得到10分，所有坦克消灭后游戏胜利，我方被敌人坦克子弹击中则爆炸消失，游戏结束。

1、KIMI实现

实现效果：

实现一个完整的坦克大战小游戏需要使用Python的图形库，比如pygame。以下是一个简单的实现代码，满足你的基本需求。请注意，这个代码是一个基础版本，你可以根据需要进一步优化和扩展。

安装依赖

在运行代码之前，请确保安装了pygame库：

pip install pygame

代码实现

import pygame
import random
import sys

# 初始化pygame
pygame.init()

# 设置屏幕大小
SCREEN_WIDTH, SCREEN_HEIGHT = 1000, 800
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("坦克大战")

# 颜色定义
BLACK = (0, 0, 0)
YELLOW = (255, 255, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)

# 坦克和子弹的大小
TANK_SIZE = 50
BULLET_SIZE = 10
TANK_SPEED = 5
BULLET_SPEED = 10

# 我方坦克
class PlayerTank:
    def __init__(self):
        self.rect = pygame.Rect(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2, TANK_SIZE, TANK_SIZE)
        self.color = YELLOW
        self.bullets = []

    def move(self, dx, dy):
        self.rect.x += dx
        self.rect.y += dy
        # 边界检测
        if self.rect.left < 0:
            self.rect.left = 0
        if self.rect.right > SCREEN_WIDTH:
            self.rect.right = SCREEN_WIDTH
        if self.rect.top < 0:
            self.rect.top = 0
        if self.rect.bottom > SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT

    def shoot(self):
        bullet = pygame.Rect(self.rect.centerx, self.rect.top, BULLET_SIZE, BULLET_SIZE)
        self.bullets.append(bullet)

    def update_bullets(self):
        for bullet in self.bullets[:]:
            bullet.y -= BULLET_SPEED
            if bullet.bottom < 0:
                self.bullets.remove(bullet)

# 敌方坦克
class EnemyTank:
    def __init__(self):
        self.rect = pygame.Rect(random.randint(0, SCREEN_WIDTH - TANK_SIZE),
                                random.randint(0, SCREEN_HEIGHT - TANK_SIZE),
                                TANK_SIZE, TANK_SIZE)
        self.color = RED
        self.direction = random.choice(['up', 'down', 'left', 'right'])
        self.bullets = []

    def move(self):
        if self.direction == 'up':
            self.rect.y -= TANK_SPEED
            if self.rect.top < 0:
                self.direction = 'down'
        elif self.direction == 'down':
            self.rect.y += TANK_SPEED
            if self.rect.bottom > SCREEN_HEIGHT:
                self.direction = 'up'
        elif self.direction == 'left':
            self.rect.x -= TANK_SPEED
            if self.rect.left < 0:
                self.direction = 'right'
        elif self.direction == 'right':
            self.rect.x += TANK_SPEED
            if self.rect.right > SCREEN_WIDTH:
                self.direction = 'left'

    def shoot(self):
        if random.randint(0, 100) < 5:  # 5%的概率发射子弹
            bullet = pygame.Rect(self.rect.centerx, self.rect.top, BULLET_SIZE, BULLET_SIZE)
            self.bullets.append(bullet)

    def update_bullets(self):
        for bullet in self.bullets[:]:
            bullet.y += BULLET_SPEED
            if bullet.top > SCREEN_HEIGHT:
                self.bullets.remove(bullet)

# 游戏主逻辑
def main():
    clock = pygame.time.Clock()
    player = PlayerTank()
    enemies = [EnemyTank() for _ in range(10)]
    score = 0
    font = pygame.font.Font(None, 36)

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    player.shoot()

        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            player.move(-TANK_SPEED, 0)
        if keys[pygame.K_RIGHT]:
            player.move(TANK_SPEED, 0)
        if keys[pygame.K_UP]:
            player.move(0, -TANK_SPEED)
        if keys[pygame.K_DOWN]:
            player.move(0, TANK_SPEED)

        # 更新玩家子弹
        player.update_bullets()

        # 更新敌方坦克和子弹
        for enemy in enemies[:]:
            enemy.move()
            enemy.shoot()
            enemy.update_bullets()

            # 检测玩家子弹是否击中敌方坦克
            for bullet in player.bullets[:]:
                if enemy.rect.colliderect(bullet):
                    player.bullets.remove(bullet)
                    enemies.remove(enemy)
                    score += 10
                    break

            # 检测敌方子弹是否击中玩家
            for bullet in enemy.bullets:
                if player.rect.colliderect(bullet):
                    print("游戏结束！")
                    pygame.quit()
                    sys.exit()

        # 检测胜利条件
        if not enemies:
            print("游戏胜利！")
            pygame.quit()
            sys.exit()

        # 绘制游戏界面
        screen.fill(BLACK)
        pygame.draw.rect(screen, player.color, player.rect)
        for bullet in player.bullets:
            pygame.draw.rect(screen, GREEN, bullet)
        for enemy in enemies:
            pygame.draw.rect(screen, enemy.color, enemy.rect)
            for bullet in enemy.bullets:
                pygame.draw.rect(screen, RED, bullet)

        # 显示分数
        score_text = font.render(f"Score: {score}", True, GREEN)
        screen.blit(score_text, (10, 10))

        pygame.display.flip()
        clock.tick(60)  #这里生成的时候是60太快了，改成了20就正常一些

if __name__ == "__main__":
    main()

代码说明

1. 玩家坦克：

   • 可以通过键盘方向键控制移动。
   • 按下空格键发射子弹。
   • 子弹击中敌方坦克后，敌方坦克消失，玩家得分。

2. 敌方坦克：

   • 随机在屏幕上生成。
   • 随机选择方向移动，碰撞到边界会反弹。
   • 有一定概率发射子弹。

3. 游戏逻辑：

   • 玩家被敌方子弹击中，游戏结束。
   • 所有敌方坦克被消灭，游戏胜利。

4. 显示：

   • 分数实时显示在屏幕左上角。

扩展建议

• 增加音效和背景音乐。
• 添加更多关卡和难度设置。
• 优化坦克和子弹的动画效果。
• 增加玩家生命值和复活机制。

希望这个代码对你有帮助！

2、小艺实现

好的，我现在需要帮用户用Python实现一个坦克大战的小游戏。用户的需求比较明确，屏幕大小是1000x800像素，敌人有10个坦克，会发射子弹和随机移动，碰到边界会反弹。玩家是黄色坦克，可以移动和射击，击中敌人得10分，全部消灭后胜利，被击中则游戏结束。

首先，我得考虑使用哪个Python库。Pygame是比较常用的游戏开发库，适合2D游戏，所以应该选择它。接下来需要规划游戏的主要结构，包括游戏窗口的初始化、坦克和子弹的类设计、碰撞检测、分数显示和游戏结束的条件。

敌人坦克需要随机移动，这里可能需要一个随机方向的生成，每隔一段时间改变方向。同时，敌人发射子弹的频率也需要控制，比如每隔一定时间发射一次。碰撞到边界反弹的话，可以通过检测坦克的位置，当碰到边缘时反转移动方向。

玩家坦克的控制需要响应键盘事件，比如上下左右移动，以及空格键发射子弹。子弹的移动需要持续更新位置，并且检测是否击中敌方或玩家坦克。碰撞检测可以使用pygame的sprite碰撞方法，或者自己计算矩形区域是否重叠。

分数显示应该在屏幕的某个角落，比如左上角，使用pygame的字体模块来渲染文本。游戏结束的条件有两个：玩家被击中或者所有敌人被消灭。这时候需要显示相应的胜利或失败信息，并可能提供重新开始的选项。

接下来需要设计类结构。可能有一个Tank类作为基类，PlayerTank和EnemyTank继承它。子弹类Bullet需要包含位置、方向和速度。每个坦克都有自己的子弹列表，用于管理发射的子弹。

敌人的随机移动可以通过在EnemyTank类中设置一个移动方向，每隔几秒随机改变方向。同时，敌人发射子弹的逻辑可能需要一个定时器，每隔一定时间生成一个子弹，并添加到子弹列表中。

碰撞检测方面，需要检查玩家子弹是否击中敌人，以及敌人子弹是否击中玩家。当击中时，相应的坦克或子弹应该被移除，并增加分数。如果敌人全部被消灭，游戏胜利；如果玩家被击中，游戏结束。

还需要处理窗口的刷新，比如每帧清空屏幕，绘制所有坦克和子弹，更新分数，并处理事件循环。游戏的主循环会不断处理输入、更新对象位置、检测碰撞，并重绘画面。

可能遇到的问题包括子弹和坦克的碰撞检测精度，可能需要调整碰撞框的大小。另外，敌人的AI移动可能需要调整随机方向变化的频率，以避免移动过于混乱或呆板。还有游戏性能，如果对象太多，需要优化，但10个敌人应该没问题。

测试的时候需要确保所有功能按预期工作，比如敌人移动和反弹，子弹发射和碰撞，分数更新，游戏结束条件触发等。可能还需要调整坦克和子弹的速度，使得游戏体验更佳。

最后，代码结构要清晰，方便后续修改和扩展。比如将不同类分开，使用不同的方法处理不同的事件，保持代码的可读性。

以下是一个使用Pygame实现的坦克大战游戏示例代码：

import pygame
import random
import math

# 初始化Pygame
pygame.init()

# 游戏窗口设置
SCREEN_WIDTH = 1000
SCREEN_HEIGHT = 800
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("坦克大战")

# 颜色定义
YELLOW = (255, 255, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

# 坦克类
class Tank(pygame.sprite.Sprite):
    def __init__(self, color, x, y):
        super().__init__()
        self.image = pygame.Surface((40, 40))
        self.image.fill(color)
        self.rect = self.image.get_rect(center=(x, y))
        self.speed = 3
        self.direction = random.choice(["up", "down", "left", "right"])
        self.bullets = pygame.sprite.Group()
        self.last_shot = 0

    def move(self):
        if self.direction == "up":
            self.rect.y -= self.speed
        elif self.direction == "down":
            self.rect.y += self.speed
        elif self.direction == "left":
            self.rect.x -= self.speed
        elif self.direction == "right":
            self.rect.x += self.speed

        # 边界检测
        if self.rect.left < 0:
            self.rect.left = 0
            self.direction = random.choice(["up", "down", "right"])
        if self.rect.right > SCREEN_WIDTH:
            self.rect.right = SCREEN_WIDTH
            self.direction = random.choice(["up", "down", "left"])
        if self.rect.top < 0:
            self.rect.top = 0
            self.direction = random.choice(["down", "left", "right"])
        if self.rect.bottom > SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
            self.direction = random.choice(["up", "left", "right"])

    def shoot(self):
        current_time = pygame.time.get_ticks()
        if current_time - self.last_shot > 1000:
            bullet = Bullet(self.rect.centerx, self.rect.centery, self.direction)
            self.bullets.add(bullet)
            self.last_shot = current_time

# 子弹类
class Bullet(pygame.sprite.Sprite):
    def __init__(self, x, y, direction):
        super().__init__()
        self.image = pygame.Surface((8, 8))
        self.image.fill(RED)
        self.rect = self.image.get_rect(center=(x, y))
        self.speed = 5
        self.direction = direction

    def update(self):
        if self.direction == "up":
            self.rect.y -= self.speed
        elif self.direction == "down":
            self.rect.y += self.speed
        elif self.direction == "left":
            self.rect.x -= self.speed
        elif self.direction == "right":
            self.rect.x += self.speed

        # 移除屏幕外的子弹
        if not (0 < self.rect.x < SCREEN_WIDTH and 0 < self.rect.y < SCREEN_HEIGHT):
            self.kill()

# 初始化游戏对象
player = Tank(YELLOW, SCREEN_WIDTH//2, SCREEN_HEIGHT-50)
enemies = pygame.sprite.Group()
for _ in range(10):
    enemy = Tank(BLUE, random.randint(50, SCREEN_WIDTH-50), random.randint(50, SCREEN_HEIGHT-200))
    enemies.add(enemy)

all_sprites = pygame.sprite.Group()
all_sprites.add(player)
all_sprites.add(enemies)

score = 0
game_over = False
win = False

# 游戏主循环
running = True
clock = pygame.time.Clock()

while running:
    screen.fill(BLACK)
    
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    if not game_over and not win:
        # 玩家控制
        keys = pygame.key.get_pressed()
        if keys[pygame.K_UP]:
            player.rect.y -= player.speed
        if keys[pygame.K_DOWN]:
            player.rect.y += player.speed
        if keys[pygame.K_LEFT]:
            player.rect.x -= player.speed
        if keys[pygame.K_RIGHT]:
            player.rect.x += player.speed
        if keys[pygame.K_SPACE]:
            player.shoot()

        # 敌人行为
        for enemy in enemies:
            enemy.move()
            if random.random() < 0.02:  # 2%概率改变方向
                enemy.direction = random.choice(["up", "down", "left", "right"])
            if random.random() < 0.01:  # 1%概率射击
                enemy.shoot()

        # 碰撞检测
        for bullet in player.bullets:
            hit_enemies = pygame.sprite.spritecollide(bullet, enemies, True)
            if hit_enemies:
                bullet.kill()
                score += 10

        for enemy in enemies:
            if pygame.sprite.spritecollide(player, enemy.bullets, True):
                game_over = True

        # 检查胜利条件
        if len(enemies) == 0:
            win = True

    # 更新和绘制
    all_sprites.update()
    player.bullets.update()
    for enemy in enemies:
        enemy.bullets.update()

    all_sprites.draw(screen)
    player.bullets.draw(screen)
    for enemy in enemies:
        enemy.bullets.draw(screen)

    # 显示分数
    font = pygame.font.Font(None, 36)
    text = font.render(f"Score: {score}", True, WHITE)
    screen.blit(text, (10, 10))

    # 显示游戏结束信息
    if game_over:
        text = font.render("GAME OVER!", True, RED)
        screen.blit(text, (SCREEN_WIDTH//2-100, SCREEN_HEIGHT//2))
    elif win:
        text = font.render("YOU WIN!", True, WHITE)
        screen.blit(text, (SCREEN_WIDTH//2-80, SCREEN_HEIGHT//2))

    pygame.display.flip()
    clock.tick(60)

pygame.quit()

这个游戏包含以下主要功能：

1. 玩家控制黄色坦克，使用方向键移动，空格键射击
2. 10个蓝色敌方坦克会自动移动和随机射击
3. 所有坦克碰撞到屏幕边界会反弹
4. 击中敌方坦克得10分
5. 玩家被击中或消灭所有敌人坦克时游戏结束
6. 显示实时分数和游戏结果

游戏操作说明：

• 方向键控制移动
• 空格键射击
• 消灭所有敌人坦克获胜
• 避免被敌人子弹击中

你可以根据需要调整以下参数来修改游戏体验：

• 坦克速度（修改Tank类的speed属性）
• 子弹速度（修改Bullet类的speed属性）
• 敌人射击概率（修改0.01这个值）
• 敌人改变方向的概率（修改0.02这个值）
• 射击冷却时间（修改1000这个值，单位毫秒）

3、DeepSeek实现

用python实现一个坦克大战小游戏，屏幕大小宽高1000x800px 敌人有10个坦克，会发射子弹，会随机自由移动，碰撞到屏幕边界会反弹， 我方是一个黄颜色坦克，能发子弹，能移动，移动方向子弹方向也要跟着改变，子弹击中敌人坦克就爆炸消失，并得到10分，所有坦克消灭后游戏胜利，我方被敌人坦克子弹击中则爆炸消失，游戏结束。

好，我需要帮用户用Python实现一个坦克大战小游戏。首先，用户已经给出了详细的需求，包括屏幕大小、敌方坦克数量、移动方式、碰撞处理、我方坦克功能以及得分和游戏结束的条件。

我应该先确定使用什么库。Pygame是一个不错的选择，因为它适合制作2D游戏，而且文档齐全，适合新手。

接下来，我需要规划游戏的结构。通常，游戏会分为几个主要部分：初始化、游戏循环、事件处理、更新游戏状态和渲染画面。

首先，初始化Pygame，设置屏幕大小为1000x800，设置标题，初始化时钟，确定帧率（比如60帧每秒）。

然后，创建我方坦克。我方坦克应该是黄色的，能移动和发射子弹。我需要定义坦克的属性，比如位置、方向、速度，以及子弹的发射频率。

接下来，生成10个敌方坦克。这些坦克应该随机分布在屏幕的另一侧，比如右边，避免初始位置重叠。每个敌方坦克也有自己的位置、方向、速度，以及发射子弹的能力。它们需要随机移动，碰到屏幕边界反弹，这可以通过检测边界并反转速度方向来实现。

关于子弹，我方和敌方的子弹都需要跟踪，包括位置和速度。当子弹与敌方坦克碰撞时，敌方坦克爆炸消失，得分增加。同样，我方的坦克如果被敌方子弹击中，游戏结束。

我还需要处理用户输入，比如键盘事件来控制我方坦克的移动和射击。移动方向会影响炮口的方向，这可以通过旋转图像或调整方向变量来实现。

在游戏循环中，每帧需要更新所有对象的位置，处理碰撞检测，更新得分，渲染所有对象到屏幕上。

最后，游戏胜利或失败的条件需要明确。当所有敌方坦克被消灭时，显示胜利消息；如果我方被击中，显示失败消息，并结束游戏。

考虑到代码结构，可能需要创建多个类，比如Tank类和Bullet类，来封装各自的属性和方法。这样代码会更清晰，维护也更容易。

在编写代码时，需要注意以下几点：

坦克的移动和边界反弹：检测位置是否超出屏幕范围，反转速度方向。
子弹的发射和管理：使用列表存储子弹，定期检查是否需要移除超出屏幕的子弹。
碰撞检测：使用矩形碰撞检测，检查子弹是否与坦克碰撞。
渲染：每帧绘制所有对象，确保画面流畅。

可能遇到的问题包括性能问题（如果对象太多）、碰撞检测不够精确、子弹的追踪等。但作为初步实现，可以先满足基本功能，后续再优化。

现在，我可以开始编写代码了。首先导入Pygame，初始化，设置屏幕。然后创建我方坦克和敌方坦克。接着进入游戏循环，处理事件，更新状态，渲染画面。

在实现过程中，注意处理事件，比如按键控制坦克移动和射击。同时，确保敌方坦克随机移动，并且子弹发射有一定的间隔，避免过于频繁。

测试每个部分的功能，确保移动、射击、碰撞和得分都能正常工作。最后，处理游戏结束的条件，显示相应的消息，并退出游戏。

总的来说，这个项目需要分解成几个部分逐步实现，确保每一步都能正常工作，再整合起来。这样可以避免问题堆积，更容易调试和修复。

以下是用 Python 实现坦克大战小游戏的代码。使用了 Pygame 库来实现游戏逻辑和图形渲染。

import pygame
import random
from pygame.math import Vector2

# 初始化 Pygame
pygame.init()

# 设置屏幕大小
SCREEN_WIDTH = 1000
SCREEN_HEIGHT = 800
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("坦克大战")

# 定义颜色
WHITE = (255, 255, 255)
YELLOW = (255, 255, 0)
RED = (255, 0, 0)
BLACK = (0, 0, 0)

# 设置帧率
clock = pygame.time.Clock()
FPS = 60

# 定义坦克类
class Tank:
    def __init__(self, x, y, color, player=False):
        self.player = player
        self.color = color
        self.rect = pygame.Rect(x, y, 40, 40)
        self.direction = Vector2(0, -1)  # 初始方向向上
        self.speed = 5
        self.bullets = []
        self.score = 0
        self.last_shot = 0

    def move(self, dx, dy):
        self.rect.x += dx * self.speed
        self.rect.y += dy * self.speed

        # 碰撞屏幕边界
        if self.rect.left < 0:
            self.rect.left = 0
        elif self.rect.right > SCREEN_WIDTH:
            self.rect.right = SCREEN_WIDTH
        if self.rect.top < 0:
            self.rect.top = 0
        elif self.rect.bottom > SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT

    def shoot(self):
        current_time = pygame.time.get_ticks()
        if current_time - self.last_shot > 500:  # 500ms 冷却时间
            self.bullets.append(Bullet(self.rect.centerx, self.rect.centery, self.direction))
            self.last_shot = current_time

    def update(self):
        for bullet in self.bullets:
            bullet.update()
            if not bullet.active:
                self.bullets.remove(bullet)

    def draw(self, screen):
        # 绘制坦克
        pygame.draw.rect(screen, self.color, self.rect)
        # 绘制炮口
        cannon_pos = Vector2(self.rect.center) + self.direction * 15
        pygame.draw.line(screen, self.color, self.rect.center, (int(cannon_pos.x), int(cannon_pos.y)), 5)

# 定义子弹类
class Bullet:
    def __init__(self, x, y, direction):
        self.rect = pygame.Rect(x, y, 5, 5)
        self.direction = direction.normalize()
        self.speed = 10
        self.active = True

    def update(self):
        self.rect.center += self.direction * self.speed

        # 检查边界
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH or self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.active = False

    def draw(self, screen):
        pygame.draw.rect(screen, BLACK, self.rect)

# 游戏对象
player_tank = Tank(SCREEN_WIDTH // 2, SCREEN_HEIGHT - 60, YELLOW, True)
enemy_tanks = [Tank(random.randint(SCREEN_WIDTH // 2 + 100, SCREEN_WIDTH - 50), random.randint(50, SCREEN_HEIGHT - 50), RED) for _ in range(10)]

# 游戏循环
running = True
game_over = False
win = False

while running:
    screen.fill(WHITE)

    # 处理事件
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    if not game_over and not win:
        # 处理玩家输入
        keys = pygame.key.get_pressed()
        if keys[pygame.K_UP]:
            player_tank.move(0, -1)
            player_tank.direction = Vector2(0, -1)
        if keys[pygame.K_DOWN]:
            player_tank.move(0, 1)
            player_tank.direction = Vector2(0, 1)
        if keys[pygame.K_LEFT]:
            player_tank.move(-1, 0)
            player_tank.direction = Vector2(-1, 0)
        if keys[pygame.K_RIGHT]:
            player_tank.move(1, 0)
            player_tank.direction = Vector2(1, 0)
        if keys[pygame.K_SPACE]:
            player_tank.shoot()

        # 敌方坦克移动
        for enemy in enemy_tanks:
            # 随机移动方向
            if random.random() < 0.02:
                enemy.direction.x = random.choice([-1, 1])
                enemy.direction.y = random.choice([-1, 1])
                enemy.direction.normalize()

            enemy.move(enemy.direction.x, enemy.direction.y)

            # 发射子弹
            if random.random() < 0.02:
                enemy.shoot()

        # 更新和绘制玩家坦克
        player_tank.update()
        player_tank.draw(screen)

        # 更新和绘制敌方坦克
        for enemy in enemy_tanks:
            enemy.update()
            enemy.draw(screen)

            # 检查玩家子弹是否击中敌方坦克
            for bullet in player_tank.bullets:
                if enemy.rect.colliderect(bullet.rect):
                    enemy_tanks.remove(enemy)
                    player_tank.score += 10
                    bullet.active = False

            # 检查敌方子弹是否击中玩家坦克
            for bullet in enemy.bullets:
                if player_tank.rect.colliderect(bullet.rect):
                    game_over = True

        # 绘制子弹
        for enemy in enemy_tanks:
            for bullet in enemy.bullets:
                bullet.draw(screen)

        for bullet in player_tank.bullets:
            bullet.draw(screen)

        # 检查胜利条件
        if not enemy_tanks:
            win = True

    # 绘制得分
    font = pygame.font.Font(None, 36)
    score_text = font.render(f"Score: {player_tank.score}", True, BLACK)
    screen.blit(score_text, (10, 10))

    # 游戏结束
    if game_over:
        game_over_text = font.render("Game Over!", True, RED)
        screen.blit(game_over_text, (SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2))
    elif win:
        win_text = font.render("You Win!", True, RED)
        screen.blit(win_text, (SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2))

    # 更新屏幕
    pygame.display.flip()
    clock.tick(FPS)

# 退出游戏
pygame.quit()

代码说明：

初始化和设置：

初始化 Pygame 库。
设置屏幕大小为 1000x800。
设置标题和帧率。

类定义：

Tank 类：表示坦克，包括玩家坦克和敌方坦克。包含属性如位置、方向、速度、子弹列表等。方法包括移动、射击、更新和绘制。
Bullet 类：表示子弹，包含位置、方向、速度和绘制方法。

游戏对象：

创建玩家坦克和 10 个敌方坦克。

游戏循环：

处理玩家输入，控制玩家坦克移动和射击。
敌方坦克随机移动和发射子弹。
更新和绘制所有游戏对象。
检查碰撞（子弹击中坦克）。
更新得分和游戏状态。

结束条件：

如果玩家被击中，游戏结束。
如果所有敌方坦克被消灭，玩家胜利。
注意：
确保安装了 Pygame 库，可以使用 pip install pygame 安装。
这是基础版本，可以根据需要添加更多功能，如音效、爆炸动画等。