植物大战僵尸简化版

import pygame
import random
import sys

初始化pygame

pygame.init()

屏幕设置

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("植物大战僵尸简化版 - 2023")

颜色定义

GREEN = (0, 255, 0)
BROWN = (139, 69, 19)
BLUE = (0, 0, 255)
RED = (255, 0, 0)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

游戏参数

FPS = 60
clock = pygame.time.Clock()

草坪网格

GRID_SIZE = 80
GRID_ROWS = 5
GRID_COLS = 9
LAWN_LEFT = 100
LAWN_TOP = 100

植物类

class Plant:
def init(self, row, col):
self.row = row
self.col = col
self.x = LAWN_LEFT + col * GRID_SIZE
self.y = LAWN_TOP + row * GRID_SIZE
self.health = 100
self.attack_cooldown = 0

def update(self):
    if self.attack_cooldown > 0:
        self.attack_cooldown -= 1

def draw(self, surface):
    pygame.draw.circle(surface, GREEN, (self.x + GRID_SIZE//2, self.y + GRID_SIZE//2), 30)
    # 显示生命值
    font = pygame.font.SysFont(None, 24)
    health_text = font.render(str(self.health), True, BLACK)
    surface.blit(health_text, (self.x + GRID_SIZE//2 - 10, self.y + GRID_SIZE//2 - 10))

豌豆射手类

class Peashooter(Plant):
def init(self, row, col):
super().init(row, col)
self.attack_speed = 60 # 攻击速度(帧)

def update(self, zombies, peas):
    super().update()
    
    # 检查同一行是否有僵尸
    zombies_in_row = [z for z in zombies if z.row == self.row and z.x > self.x]
    
    if zombies_in_row and self.attack_cooldown <= 0:
        peas.append(Pea(self.row, self.col))
        self.attack_cooldown = self.attack_speed

def draw(self, surface):
    pygame.draw.circle(surface, GREEN, (self.x + GRID_SIZE//2, self.y + GRID_SIZE//2), 30)
    # 绘制豌豆射手特征
    pygame.draw.rect(surface, (0, 100, 0), (self.x + GRID_SIZE//2 - 5, self.y + 10, 10, 20))
    # 显示生命值
    font = pygame.font.SysFont(None, 24)
    health_text = font.render(str(self.health), True, BLACK)
    surface.blit(health_text, (self.x + GRID_SIZE//2 - 10, self.y + GRID_SIZE//2 - 10))

向日葵类

class Sunflower(Plant):
def init(self, row, col):
super().init(row, col)
self.sun_production_time = 300 # 生产阳光的间隔(帧)
self.timer = 0

def update(self, suns):
    self.timer += 1
    if self.timer >= self.sun_production_time:
        suns.append(Sun(self.x + GRID_SIZE//2, self.y + GRID_SIZE//2))
        self.timer = 0

def draw(self, surface):
    pygame.draw.circle(surface, (255, 255, 0), (self.x + GRID_SIZE//2, self.y + GRID_SIZE//2), 30)
    # 绘制向日葵特征
    for i in range(8):
        angle = i * 45
        end_x = self.x + GRID_SIZE//2 + 40 * pygame.math.Vector2(1, 0).rotate(angle).x
        end_y = self.y + GRID_SIZE//2 + 40 * pygame.math.Vector2(1, 0).rotate(angle).y
        pygame.draw.line(surface, (255, 165, 0), 
                        (self.x + GRID_SIZE//2, self.y + GRID_SIZE//2), 
                        (end_x, end_y), 5)
    # 显示生命值
    font = pygame.font.SysFont(None, 24)
    health_text = font.render(str(self.health), True, BLACK)
    surface.blit(health_text, (self.x + GRID_SIZE//2 - 10, self.y + GRID_SIZE//2 - 10))

豌豆类

class Pea:
def init(self, row, col):
self.row = row
self.col = col
self.x = LAWN_LEFT + (col + 1) * GRID_SIZE
self.y = LAWN_TOP + row * GRID_SIZE + GRID_SIZE//2
self.speed = 5
self.damage = 20

def update(self):
    self.x += self.speed

def draw(self, surface):
    pygame.draw.circle(surface, GREEN, (self.x, self.y), 10)

def is_off_screen(self):
    return self.x > SCREEN_WIDTH

def collides_with(self, zombie):
    return (self.row == zombie.row and 
            abs(self.x - zombie.x) < 30 and 
            abs(self.y - zombie.y) < 50)

阳光类

class Sun:
def init(self, x, y):
self.x = x
self.y = y
self.target_y = y + random.randint(50, 150)
self.speed = 1
self.lifetime = 300 # 帧数
self.collected = False

def update(self):
    if self.y < self.target_y:
        self.y += self.speed
    self.lifetime -= 1

def draw(self, surface):
    pygame.draw.circle(surface, (255, 255, 0), (self.x, self.y), 20)

def is_expired(self):
    return self.lifetime <= 0 or self.collected

def is_clicked(self, pos):
    distance = ((pos[0] - self.x) ** 2 + (pos[1] - self.y) ** 2) ** 0.5
    return distance <= 20

僵尸类

class Zombie:
def init(self, row):
self.row = row
self.x = SCREEN_WIDTH
self.y = LAWN_TOP + row * GRID_SIZE + GRID_SIZE//2
self.speed = 0.5
self.health = 100
self.attack_cooldown = 0
self.attack_damage = 1
self.attack_speed = 30 # 帧

def update(self, plants):
    # 检查前方是否有植物
    plant_in_front = None
    for plant in plants:
        if plant.row == self.row and abs(plant.x - self.x) < GRID_SIZE:
            plant_in_front = plant
            break
    
    if plant_in_front:
        if self.attack_cooldown <= 0:
            plant_in_front.health -= self.attack_damage
            self.attack_cooldown = self.attack_speed
        else:
            self.attack_cooldown -= 1
    else:
        self.x -= self.speed

def draw(self, surface):
    # 绘制僵尸身体
    pygame.draw.rect(surface, (100, 100, 100), (self.x - 20, self.y - 40, 40, 80))
    # 绘制僵尸头
    pygame.draw.circle(surface, (150, 150, 150), (self.x, self.y - 50), 20)
    # 显示生命值
    font = pygame.font.SysFont(None, 24)
    health_text = font.render(str(self.health), True, WHITE)
    surface.blit(health_text, (self.x - 15, self.y - 60))

def is_off_screen(self):
    return self.x < -50

def is_dead(self):
    return self.health <= 0

游戏主类

class Game:
def init(self):
self.plants = []
self.zombies = []
self.peas = []
self.suns = []
self.sun_count = 100
self.zombie_timer = 0
self.zombie_spawn_time = 300 # 帧
self.selected_plant = None
self.game_over = False
self.font = pygame.font.SysFont(None, 36)

    # 植物选择区域
    self.plant_options = [
        {"type": "peashooter", "cost": 100, "rect": pygame.Rect(10, 100, 70, 70)},
        {"type": "sunflower", "cost": 50, "rect": pygame.Rect(10, 180, 70, 70)}
    ]

def handle_events(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            return False
        
        if event.type == pygame.MOUSEBUTTONDOWN:
            pos = pygame.mouse.get_pos()
            
            # 检查是否点击了阳光
            for sun in self.suns:
                if sun.is_clicked(pos):
                    sun.collected = True
                    self.sun_count += 25
            
            # 检查是否点击了植物选择区域
            for option in self.plant_options:
                if option["rect"].collidepoint(pos) and self.sun_count >= option["cost"]:
                    self.selected_plant = option["type"]
            
            # 检查是否在草坪上放置植物
            if self.selected_plant:
                col = (pos[0] - LAWN_LEFT) // GRID_SIZE
                row = (pos[1] - LAWN_TOP) // GRID_SIZE
                
                if 0 <= row < GRID_ROWS and 0 <= col < GRID_COLS:
                    cell_empty = True
                    for plant in self.plants:
                        if plant.row == row and plant.col == col:
                            cell_empty = False
                            break
                    
                    if cell_empty:
                        if self.selected_plant == "peashooter" and self.sun_count >= 100:
                            self.plants.append(Peashooter(row, col))
                            self.sun_count -= 100
                            self.selected_plant = None
                        elif self.selected_plant == "sunflower" and self.sun_count >= 50:
                            self.plants.append(Sunflower(row, col))
                            self.sun_count -= 50
                            self.selected_plant = None
    
    return True

def update(self):
    if self.game_over:
        return
    
    # 更新植物
    for plant in self.plants[:]:
        if isinstance(plant, Peashooter):
            plant.update(self.zombies, self.peas)
        elif isinstance(plant, Sunflower):
            plant.update(self.suns)
        
        if plant.health <= 0:
            self.plants.remove(plant)
    
    # 更新豌豆
    for pea in self.peas[:]:
        pea.update()
        
        # 检查豌豆是否击中僵尸
        for zombie in self.zombies:
            if pea.collides_with(zombie):
                zombie.health -= pea.damage
                if pea in self.peas:
                    self.peas.remove(pea)
                break
        
        if pea.is_off_screen() and pea in self.peas:
            self.peas.remove(pea)
    
    # 更新僵尸
    for zombie in self.zombies[:]:
        zombie.update(self.plants)
        
        if zombie.is_off_screen():
            self.game_over = True
        
        if zombie.is_dead():
            self.zombies.remove(zombie)
    
    # 更新阳光
    for sun in self.suns[:]:
        sun.update()
        if sun.is_expired():
            self.suns.remove(sun)
    
    # 生成僵尸
    self.zombie_timer += 1
    if self.zombie_timer >= self.zombie_spawn_time:
        row = random.randint(0, GRID_ROWS - 1)
        self.zombies.append(Zombie(row))
        self.zombie_timer = 0
        # 随着游戏进行，僵尸生成速度加快
        self.zombie_spawn_time = max(100, self.zombie_spawn_time - 5)

def draw(self, surface):
    surface.fill((200, 200, 200))
    
    # 绘制草坪网格
    for row in range(GRID_ROWS):
        for col in range(GRID_COLS):
            rect = pygame.Rect(
                LAWN_LEFT + col * GRID_SIZE,
                LAWN_TOP + row * GRID_SIZE,
                GRID_SIZE,
                GRID_SIZE
            )
            pygame.draw.rect(surface, (144, 238, 144), rect)
            pygame.draw.rect(surface, BLACK, rect, 1)
    
    # 绘制植物选择区域
    pygame.draw.rect(surface, (200, 200, 200), (0, 0, 90, SCREEN_HEIGHT))
    for option in self.plant_options:
        color = (0, 255, 0) if self.sun_count >= option["cost"] else (100, 100, 100)
        pygame.draw.rect(surface, color, option["rect"])
        pygame.draw.rect(surface, BLACK, option["rect"], 2)
        
        # 绘制植物图标
        if option["type"] == "peashooter":
            pygame.draw.circle(surface, GREEN, 
                               (option["rect"].x + option["rect"].width//2, 
                                option["rect"].y + option["rect"].height//2), 20)
            pygame.draw.rect(surface, (0, 100, 0), 
                           (option["rect"].x + option["rect"].width//2 - 5, 
                            option["rect"].y + 15, 10, 20))
        elif option["type"] == "sunflower":
            pygame.draw.circle(surface, (255, 255, 0), 
                             (option["rect"].x + option["rect"].width//2, 
                              option["rect"].y + option["rect"].height//2), 20)
        
        # 显示花费
        cost_text = self.font.render(str(option["cost"]), True, BLACK)
        surface.blit(cost_text, (option["rect"].x + 5, option["rect"].y + 5))
    
    # 绘制阳光计数
    sun_text = self.font.render(f"阳光: {self.sun_count}", True, BLACK)
    surface.blit(sun_text, (10, 10))
    
    # 绘制选中的植物
    if self.selected_plant:
        pos = pygame.mouse.get_pos()
        if self.selected_plant == "peashooter":
            pygame.draw.circle(surface, GREEN, pos, 30)
        elif self.selected_plant == "sunflower":
            pygame.draw.circle(surface, (255, 255, 0), pos, 30)
    
    # 绘制植物
    for plant in self.plants:
        plant.draw(surface)
    
    # 绘制豌豆
    for pea in self.peas:
        pea.draw(surface)
    
    # 绘制阳光
    for sun in self.suns:
        sun.draw(surface)
    
    # 绘制僵尸
    for zombie in self.zombies:
        zombie.draw(surface)
    
    # 游戏结束显示
    if self.game_over:
        game_over_text = self.font.render("游戏结束! 僵尸吃掉了你的脑子!", True, RED)
        surface.blit(game_over_text, (SCREEN_WIDTH//2 - 200, SCREEN_HEIGHT//2))
    
    # 绘制特殊标志
    signature = self.font.render("2023", True, BLACK)
    surface.blit(signature, (SCREEN_WIDTH - 50, SCREEN_HEIGHT - 30))
    
    pygame.display.flip()

def run(self):
    running = True
    while running:
        clock.tick(FPS)
        
        running = self.handle_events()
        self.update()
        self.draw(screen)
    
    pygame.quit()
    sys.exit()

运行游戏

if name == "main":
game = Game()
game.run()