植物大战僵尸Python版，附带源码注解

最新推荐文章于 2024-05-16 07:06:58 发布
最新推荐文章于 2024-05-16 07:06:58 发布
阅读量4.1k 收藏 43
点赞数 19
文章标签： pygame python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47151388/article/details/137376148
版权

目录

一、实现功能

二、安装环境要求

三、如何开始游戏

四、怎么玩

五、演示

六、部分源码注释

6.1main.py

6.2map.py

6.3Menubar.py

七、自定义

7.1plant.json

7.2zombie.json

一、实现功能

  • 实施植物：向日葵、豌豆射手、壁桃、雪豆射手、樱桃炸弹、三豌豆射手、大口蘑菇，海扁蘑菇，土豆，尖刺草，惊吓蘑菇，南瓜，惊吓蘑菇，墨西哥辣椒，太阳蘑菇，冰蘑菇，催眠蘑菇。
  • 实现僵尸：僵尸、旗帜僵尸、锥头僵尸、桶头僵尸、报纸僵尸。
  • 使用JSON文件存储关卡数据（例如僵尸的位置和时间，背景信息）
  • 支持在关卡开始时选择植物卡
  • 支持日间关卡、夜间关卡、移动卡选择关卡和壁桃保龄球关卡

二、安装环境要求

  • Python 3.7
  • Notice:建议使用 python 3.7 版本，但不是必需的。对于 LINUX：如果您的 Linux 系统预装了 python 3+，则可以运行此游戏。直接更新到 python 3.7 可能会破坏 LINUX Mint。
  • Python-Pygame 1.9

三、如何开始游戏

python main.py

四、怎么玩

  • 使用鼠标收集阳光，选择植物卡片并播种植物
  • 您可以通过更改 source/constants.py 中的START_LEVEL_NUM值来设置起始级别
    • 级别 1 和 2：天级别
    • 第 3 级：夜间级别
    • 第 4 级：移动卡片选择级别
    • 第5级：墙果保龄球级别

五、演示

六、部分源码注释

项目结构如下：

6.1main.py

import pygame as pg
from source.main import main

if __name__=='__main__':
    main()
    pg.quit()

6.2map.py

   定义了一个地图类 Map，包含了地图的初始化、位置验证、可移动性检查、位置转换等方法。

__author__ = 'marble_xu'

# 导入必要的模块
import random
import pygame as pg
from .. import tool
from .. import constants as c

# 地图类定义
class Map():
    def __init__(self, width, height):
        # 初始化地图的宽度和高度
        self.width = width
        self.height = height
        # 创建一个二维数组来表示地图，初始值为0
        self.map = [[0 for x in range(self.width)] for y in range(self.height)]

    # 检查指定位置是否在地图范围内
    def isValid(self, map_x, map_y):
        if (map_x < 0 or map_x >= self.width or
            map_y < 0 or map_y >= self.height):
            return False
        return True
    
    # 检查指定位置是否可移动
    def isMovable(self, map_x, map_y):
        return (self.map[map_y][map_x] == c.MAP_EMPTY)
    
    # 根据实际坐标获取地图索引
    def getMapIndex(self, x, y):
        x -= c.MAP_OFFSET_X
        y -= c.MAP_OFFSET_Y
        return (x // c.GRID_X_SIZE, y // c.GRID_Y_SIZE)
    
    # 根据地图索引获取网格的中心位置坐标
    def getMapGridPos(self, map_x, map_y):
        return (map_x * c.GRID_X_SIZE + c.GRID_X_SIZE//2 + c.MAP_OFFSET_X,
                map_y * c.GRID_Y_SIZE + c.GRID_Y_SIZE//5 * 3 + c.MAP_OFFSET_Y)
    
    # 设置指定位置的地图网格类型
    def setMapGridType(self, map_x, map_y, type):
        self.map[map_y][map_x] = type

    # 获取一个随机的地图索引
    def getRandomMapIndex(self):
        map_x = random.randint(0, self.width-1)
        map_y = random.randint(0, self.height-1)
        return (map_x, map_y)

    # 在指定位置显示植物，返回植物显示的位置
    def showPlant(self, x, y):
        pos = None
        map_x, map_y = self.getMapIndex(x, y)
        # 检查位置是否有效且可移动
        if self.isValid(map_x, map_y) and self.isMovable(map_x, map_y):
            # 获取植物显示的位置
            pos = self.getMapGridPos(map_x, map_y)
        return pos

6.3Menubar.py

# 导入必要的模块
import random
import pygame as pg
from .. import tool
from .. import constants as c

# 面板初始位置及间距
PANEL_Y_START = 87
PANEL_X_START = 22
PANEL_Y_INTERNAL = 74
PANEL_X_INTERNAL = 53
CARD_LIST_NUM = 8

# 植物卡片名称列表
card_name_list = [c.CARD_SUNFLOWER, c.CARD_PEASHOOTER, c.CARD_SNOWPEASHOOTER, c.CARD_WALLNUT,
                  c.CARD_CHERRYBOMB, c.CARD_THREEPEASHOOTER, c.CARD_REPEATERPEA, c.CARD_CHOMPER,
                  c.CARD_PUFFSHROOM, c.CARD_POTATOMINE, c.CARD_SQUASH, c.CARD_SPIKEWEED,
                  c.CARD_JALAPENO, c.CARD_SCAREDYSHROOM, c.CARD_SUNSHROOM, c.CARD_ICESHROOM,
                  c.CARD_HYPNOSHROOM, c.CARD_WALLNUT, c.CARD_REDWALLNUT]
# 植物名称列表
plant_name_list = [c.SUNFLOWER, c.PEASHOOTER, c.SNOWPEASHOOTER, c.WALLNUT,
                   c.CHERRYBOMB, c.THREEPEASHOOTER, c.REPEATERPEA, c.CHOMPER,
                   c.PUFFSHROOM, c.POTATOMINE, c.SQUASH, c.SPIKEWEED,
                   c.JALAPENO, c.SCAREDYSHROOM, c.SUNSHROOM, c.ICESHROOM,
                   c.HYPNOSHROOM, c.WALLNUTBOWLING, c.REDWALLNUTBOWLING]
# 植物所需阳光值列表
plant_sun_list = [50, 100, 175, 50, 150, 325, 200, 150, 0, 25, 50, 100, 125, 25, 25, 75, 75, 0, 0]
# 植物冷冻时间列表
plant_frozen_time_list = [7500, 7500, 7500, 30000, 50000, 7500, 7500, 7500, 7500, 30000,
                          30000, 7500, 50000, 7500, 7500, 50000, 30000, 0, 0]
# 所有卡片索引列表
all_card_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

# 获取阳光值图片
def getSunValueImage(sun_value):
    font = pg.font.SysFont(None, 22)
    width = 32
    msg_image = font.render(str(sun_value), True, c.NAVYBLUE, c.LIGHTYELLOW)
    msg_rect = msg_image.get_rect()
    msg_w = msg_rect.width

    image = pg.Surface([width, 17])
    x = width - msg_w

    image.fill(c.LIGHTYELLOW)
    image.blit(msg_image, (x, 0), (0, 0, msg_rect.w, msg_rect.h))
    image.set_colorkey(c.BLACK)
    return image

# 获取卡片池
def getCardPool(data):
    card_pool = []
    for card in data:
        tmp = card['name']
        for i, name in enumerate(plant_name_list):
            if name == tmp:
                card_pool.append(i)
                break
    return card_pool

# 卡片类
class Card():
    def __init__(self, x, y, name_index, scale=0.78):
        self.loadFrame(card_name_list[name_index], scale)
        self.rect = self.orig_image.get_rect()
        self.rect.x = x
        self.rect.y = y
        
        self.name_index = name_index
        self.sun_cost = plant_sun_list[name_index]
        self.frozen_time = plant_frozen_time_list[name_index]
        self.frozen_timer = -self.frozen_time
        self.refresh_timer = 0
        self.select = True

    # 加载卡片帧
    def loadFrame(self, name, scale):
        frame = tool.GFX[name]
        rect = frame.get_rect()
        width, height = rect.w, rect.h

        self.orig_image = tool.get_image(frame, 0, 0, width, height, c.BLACK, scale)
        self.image = self.orig_image

    # 检查鼠标点击位置
    def checkMouseClick(self, mouse_pos):
        x, y = mouse_pos
        if(x >= self.rect.x and x <= self.rect.right and
           y >= self.rect.y and y <= self.rect.bottom):
            return True
        return False

    # 检查是否可以点击
    def canClick(self, sun_value, current_time):
        if self.sun_cost <= sun_value and (current_time - self.frozen_timer) > self.frozen_time:
            return True
        return False

    # 检查是否可选中
    def canSelect(self):
        return self.select

    # 设置是否选中
    def setSelect(self, can_select):
        self.select = can_select
        if can_select:
            self.image.set_alpha(255)
        else:
            self.image.set_alpha(128)

    # 设置冷冻时间
    def setFrozenTime(self, current_time):
        self.frozen_timer = current_time

    # 创建卡片图片以显示冷却状态或阳光值不足状态
    def createShowImage(self, sun_value, current_time):
        time = current_time - self.frozen_timer
        if time < self.frozen_time: # 冷却状态
            image = pg.Surface([self.rect.w, self.rect.h])
            frozen_image = self.orig_image.copy()
            frozen_image.set_alpha(128)
            frozen_height = (self.frozen_time - time)/self.frozen_time * self.rect.h
            
            image.blit(frozen_image, (0,0), (0, 0, self.rect.w, frozen_height))
            image.blit(self.orig_image, (0,frozen_height),
                       (0, frozen_height, self.rect.w, self.rect.h - frozen_height))
        elif self.sun_cost > sun_value: # 阳光值不足状态
            image = self.orig_image.copy()
            image.set_alpha(192)
        else:
            image = self.orig_image
        return image

    # 更新卡片状态
    def update(self, sun_value, current_time):
        if (current_time - self.refresh_timer) >= 250:
            self.image = self.createShowImage(sun_value, current_time)
            self.refresh_timer = current_time

    # 绘制卡片
    def draw(self, surface):
        surface.blit(self.image, self.rect)

# 菜单栏类
class MenuBar():
    def __init__(self, card_list, sun_value):
        self.loadFrame(c.MENUBAR_BACKGROUND)
        self.rect = self.image.get_rect()
        self.rect.x = 10
        self.rect.y = 0
        
        self.sun_value = sun_value
        self.card_offset_x = 32
        self.setupCards(card_list)

    # 加载背景帧
    def loadFrame(self, name):
        frame = tool.GFX[name]
        rect = frame.get_rect()
        frame_rect = (rect.x, rect.y, rect.w, rect.h)

        self.image = tool.get_image(tool.GFX[name], *frame_rect, c.WHITE, 1)

    # 更新菜单栏状态
    def update(self, current_time):
        self.current_time = current_time
        for card in self.card_list:
            card.update(self.sun_value, self.current_time)

    # 创建图片
    def createImage(self, x, y, num):
        if num == 1:
            return
        img = self.image
        rect = self.image.get_rect()
        width = rect.w
        height = rect.h
        self.image = pg.Surface((width * num, height)).convert()
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        for i in range(num):
            x = i * width
            self.image.blit(img, (x,0))
        self.image.set_colorkey(c.BLACK)
    
    # 设置卡片
    def setupCards(self, card_list):
        self.card_list = []
        x = self.card_offset_x
        y = 8
        for index in card_list:
            x += 55
            self.card_list.append(Card(x, y, index))

    # 检查卡片点击
    def checkCardClick(self, mouse_pos):
        result = None
        for card in self.card_list:
            if card.checkMouseClick(mouse_pos):
                if card.canClick(self.sun_value, self.current_time):
                    result = (plant_name_list[card.name_index], card)
                break
        return result
    
    # 检查菜单栏点击
    def checkMenuBarClick(self, mouse_pos):
        x, y = mouse_pos
        if(x >= self.rect.x and x <= self.rect.right and
           y >= self.rect.y and y <= self.rect.bottom):
            return True
        return False

    # 减少阳光值
    def decreaseSunValue(self, value):
        self.sun_value -= value

    # 增加阳光值
    def increaseSunValue(self, value):
        self.sun_value += value

    # 设置卡片冷冻时间
    def setCardFrozenTime(self, plant_name):
        for card in self.card_list:
            if plant_name_list[card.name_index] == plant_name:
                card.setFrozenTime(self.current_time)
                break

    # 绘制阳光值
    def drawSunValue(self):
        self.value_image = getSunValueImage(self.sun_value)
        self.value_rect = self.value_image.get_rect()
        self.value_rect.x = 21
        self.value_rect.y = self.rect.bottom - 21
        
        self.image.blit(self.value_image, self.value_rect)

    # 绘制菜单栏
    def draw(self, surface):
        self.drawSunValue()
        surface.blit(self.image, self.rect)
        for card in self.card_list:
            card.draw(surface)

# 面板类
class Panel():
    def __init__(self, card_list, sun_value):
        self.loadImages(sun_value)
        self.selected_cards = []
        self.selected_num = 0
        self.setupCards(card_list)

    # 加载图片
    def loadFrame(self, name):
        frame = tool.GFX[name]
        rect = frame.get_rect()
        frame_rect = (rect.x, rect.y, rect.w, rect.h)

        return tool.get_image(tool.GFX[name], *frame_rect, c.WHITE, 1)

    # 加载图片及设置
    def loadImages(self, sun_value):
        self.menu_image = self.loadFrame(c.MENUBAR_BACKGROUND)
        self.menu_rect = self.menu_image.get_rect()
        self.menu_rect.x = 0
        self.menu_rect.y = 0

        self.panel_image = self.loadFrame(c.PANEL_BACKGROUND)
        self.panel_rect = self.panel_image.get_rect()
        self.panel_rect.x = 0
        self.panel_rect.y = PANEL_Y_START

        
        self.value_image = getSunValueImage(sun_value)
        self.value_rect = self.value_image.get_rect()
        self.value_rect.x = 21
        self.value_rect.y = self.menu_rect.bottom - 21

        self.button_image =  self.loadFrame(c.START_BUTTON)
        self.button_rect = self.button_image.get_rect()
        self.button_rect.x = 155
        self.button_rect.y = 547

    # 设置卡片
    def setupCards(self, card_list):
        self.card_list = []
        x = PANEL_X_START - PANEL_X_INTERNAL
        y = PANEL_Y_START + 43 - PANEL_Y_INTERNAL
        for i, index in enumerate(card_list):
            if i % 8 == 0:
                x = PANEL_X_START - PANEL_X_INTERNAL
                y += PANEL_Y_INTERNAL
            x += PANEL_X_INTERNAL
            self.card_list.append(Card(x, y, index, 0.75))

    # 检查卡片点击
    def checkCardClick(self, mouse_pos):
        delete_card = None
        for card in self.selected_cards:
            if delete_card: # 当删除卡片时，将右边的卡片左移
                card.rect.x -= 55
            elif card.checkMouseClick(mouse_pos):
                self.deleteCard(card.name_index)
                delete_card = card

        if delete_card:
            self.selected_cards.remove(delete_card)
            self.selected_num -= 1

        if self.selected_num == CARD_LIST_NUM:
            return

        for card in self.card_list:
            if card.checkMouseClick(mouse_pos):
                if card.canSelect():
                    self.addCard(card)
                break

    # 添加卡片
    def addCard(self, card):
        card.setSelect(False)
        y = 8
        x = 78 + self.selected_num * 55
        self.selected_cards.append(Card(x, y, card.name_index))
        self.selected_num += 1

    # 删除卡片
    def deleteCard(self, index):
        self.card_list[index].setSelect(True)

    # 检查开始按钮点击
    def checkStartButtonClick(self, mouse_pos):
        if self.selected_num < CARD_LIST_NUM:
            return False

        x, y = mouse_pos
        if (x >= self.button_rect.x and x <= self.button_rect.right and
            y >= self.button_rect.y and y <= self.button_rect.bottom):
           return True
        return False

    # 获取选中卡片
    def getSelectedCards(self):
        card_index_list = []
        for card in self.selected_cards:
            card_index_list.append(card.name_index)
        return card_index_list

    # 绘制面板
    def draw(self, surface):
        self.menu_image.blit(self.value_image, self.value_rect)
        surface.blit(self.menu_image, self.menu_rect)
        surface.blit(self.panel_image, self.panel_rect)
        for card in self.card_list:
            card.draw(surface)
        for card in self.selected_cards:
            card.draw(surface)

        if self.selected_num == CARD_LIST_NUM:
            surface.blit(self.button_image, self.button_rect)

# 移动卡片类
class MoveCard():
    def __init__(self, x, y, card_name, plant_name, scale=0.78):
        self.loadFrame(card_name, scale)
        self.rect = self.orig_image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.rect.w = 1
        self.image = self.createShowImage()

        self.card_name = card_name
        self.plant_name = plant_name
        self.move_timer = 0
        self.select = True

    # 加载帧
    def loadFrame(self, name, scale):
        frame = tool.GFX[name]
        rect = frame.get_rect()
        width, height = rect.w, rect.h

        self.orig_image = tool.get_image(frame, 0, 0, width, height, c.BLACK, scale)
        self.orig_rect = self.orig_image.get_rect()
        self.image = self.orig_image

    # 检查鼠标点击位置
    def checkMouseClick(self, mouse_pos):
        x, y = mouse_pos
        if(x >= self.rect.x and x <= self.rect.right and
           y >= self.rect.y and y <= self.rect.bottom):
            return True
        return False

    # 创建图片
    def createShowImage(self):
        '''create a part card image when card appears from left'''
        if self.rect.w < self.orig_rect.w: #create a part card image
            image = pg.Surface([self.rect.w, self.rect.h])
            image.blit(self.orig_image, (0, 0), (0, 0, self.rect.w, self.rect.h))
            self.rect.w += 1
        else:
            image = self.orig_image
        return image

    # 更新卡片位置
    def update(self, left_x, current_time):
        if self.move_timer == 0:
            self.move_timer = current_time
        elif (current_time - self.move_timer) >= c.CARD_MOVE_TIME:
            if self.rect.x > left_x:
                self.rect.x -= 1
                self.image = self.createShowImage()
            self.move_timer += c.CARD_MOVE_TIME

    # 绘制卡片
    def draw(self, surface):
        surface.blit(self.image, self.rect)

# 移动菜单栏类
class MoveBar():
    def __init__(self, card_pool):
        self.loadFrame(c.MOVEBAR_BACKGROUND)
        self.rect = self.image.get_rect()
        self.rect.x = 90
        self.rect.y = 0
        
        self.card_start_x = self.rect.x + 8
        self.card_end_x = self.rect.right - 5
        self.card_pool = card_pool
        self.card_list = []
        self.create_timer = -c.MOVEBAR_CARD_FRESH_TIME

    # 加载背景帧
    def loadFrame(self, name):
        frame = tool.GFX[name]
        rect = frame.get_rect()
        frame_rect = (rect.x, rect.y, rect.w, rect.h)

        self.image = tool.get_image(tool.GFX[name], *frame_rect, c.WHITE, 1)

    # 创建卡片
    def createCard(self):
        if len(self.card_list) > 0 and self.card_list[-1].rect.right > self.card_end_x:
            return False
        x = self.card_end_x
        y = 6
        index = random.randint(0, len(self.card_pool) - 1)
        card_index = self.card_pool[index]
        card_name = card_name_list[card_index] + '_move'
        plant_name = plant_name_list[card_index]
        self.card_list.append(MoveCard(x, y, card_name, plant_name))
        return True

    # 更新状态
    def update(self, current_time):
        self.current_time = current_time
        left_x = self.card_start_x
        for card in self.card_list:
            card.update(left_x, self.current_time)
            left_x = card.rect.right + 1

        if(self.current_time - self.create_timer) > c.MOVEBAR_CARD_FRESH_TIME:
            if self.createCard():
                self.create_timer = self.current_time

    # 检查卡片点击
    def checkCardClick(self, mouse_pos):
        result = None
        for index, card in enumerate(self.card_list):
            if card.checkMouseClick(mouse_pos):
                result = (card.plant_name, card)
                break
        return result
    
    # 检查菜单栏点击
    def checkMenuBarClick(self, mouse_pos):
        x, y = mouse_pos
        if(x >= self.rect.x and x <= self.rect.right and
           y >= self.rect.y and y <= self.rect.bottom):
            return True
        return False

    # 删除卡片
    def deleateCard(self, card):
        self.card_list.remove(card)

    # 绘制
    def draw(self, surface):
        surface.blit(self.image, self.rect)
        for card in self.card_list:
            card.draw(surface)

七、自定义

在PythonPlantsVsZombies-master\source\data，我们可以进行自定义配置，例如僵尸的位置和时间，背景信息。

7.1plant.json

{
    "plant_image_rect":{
        "PeaNormal":{"x":28, "y":0, "width":28, "height":34},
        "PeaIce":{"x":26, "y":0, "width":30, "height":34},
        "Chomper":{"x":0, "y":0, "width":100, "height":114},
        "PuffShroom":{"x":0, "y":28, "width":35, "height":38},
        "PuffShroomSleep":{"x":1, "y":0, "width":39, "height":65},
        "BulletMushRoom":{"x":0, "y":1, "width":55, "height":21},
        "PotatoMine":{"x":0, "y":0, "width":75, "height":55},
        "Squash":{"x":10, "y":140, "width":80, "height":86},
        "SquashAim":{"x":10, "y":140, "width":80, "height":86},
        "Spikeweed":{"x":3, "y":0, "width":80, "height":35}
    }
}

7.2zombie.json

{
    "zombie_image_rect":{
        "Zombie":{"x":62, "width":90},
        "ZombieAttack":{"x":62, "width":90},
        "ZombieLostHead":{"x":62, "width":90},
        "ZombieLostHeadAttack":{"x":62, "width":90},
        "ZombieDie":{"x":0, "width":164},
        "BoomDie":{"x":68, "width":80},
        "ConeheadZombie":{"x":80, "width":80},
        "ConeheadZombieAttack":{"x":79, "width":87},
        "BucketheadZombie":{"x":54, "width":90},
        "BucketheadZombieAttack":{"x":46, "width":90},
        "FlagZombie":{"x":56, "width":110},
        "FlagZombieAttack":{"x":60, "width":100},
        "FlagZombieLostHead":{"x":55, "width":110},
        "FlagZombieLostHeadAttack":{"x":55, "width":110},
        "NewspaperZombie":{"x":48, "width":92},
        "NewspaperZombieAttack":{"x":48, "width":92},
        "NewspaperZombieNoPaper":{"x":40, "width":98},
        "NewspaperZombieNoPaperAttack":{"x":48, "width":92},
        "NewspaperZombieLostHead":{"x":44, "width":96},
        "NewspaperZombieLostHeadAttack":{"x":48, "width":92},
        "NewspaperZombieDie":{"x":0, "width":100}
    }
}

参考：

https://blog.csdn.net/m0_68089732/article/details/137202714
松小白song
关注
  • 19
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
C语言实现植物大战僵尸(完整版）
2301_79811170的博客
12-06 8万+
实现这个游戏需要Easy_X 这个在我前面一篇C++之番外篇爱心代码有程序教你怎么下载，大家可自行查看 然后就是需要植物大战僵尸的素材和音乐，需要的可以在评论区留言
python植物大战僵尸代码，目前全网最好版本
11-17
python版本植物大战僵尸，目前全网最好版本，功能实现如下： - 支持的植物类型：太阳花，豌豆射手，寒冰射手，坚果，樱桃炸弹,双重豌豆射手，三重豌豆射手，食人花 ，小喷菇，土豆地雷，倭瓜。 - 支持的僵尸类型：普通僵尸，棋子僵尸，路障僵尸，铁桶僵尸,读报僵尸。 - 使用json文件保存关卡信息，设置僵尸出现的时间和位置。 - 支持每关开始时选择上场植物。 - 增加除草机。
Python植物大战僵尸源代码
12-29
Python植物大战僵尸源程序包含一个game.py及一个图片素材包
最全C语言实现植物大战僵尸(完整版）_简易的植物大战僵尸c语言代码，2024年最新C C++程序员面试必备的知识点
最新发布
2401_84976395的博客
05-16 2209
void _putimagePNG(int picture_x, int picture_y, IMAGE* picture) //x为载入图片的X坐标，y为Y坐标。void _putimagePNG(int picture_x, int picture_y, IMAGE* picture) //x为载入图片的X坐标，y为Y坐标。else if (msg.message == WM_MOUSEMOVE&&status==1)//WM_MOUSEMOVE鼠标移动。//获取绘图区的宽度，EASYX自带。
植物大战僵尸python源码打包
06-25
利用Python实现的植物大战僵尸的简易游戏源码，可供python游戏开发学习使用，运行只需安装pygame库即可正常执行与运行，是学习游戏制作的优秀代码。
植物大战僵尸-python源码
06-27
植物大战僵尸（代码；素材）全有了，下载下来能直接用
【C语言课设】经典植物大战僵尸丨完整开发教程+笔记+源码
C语言实战大全
02-21 4016
用C语言，开发完整的植物大战僵尸。 覆盖C语言的核心知识点，可以快速提升项目开发能力。 初学者的必备项目，可作为课设。
python开发植物大战僵尸游戏
qq_38978654的博客
06-08 1万+
开发思路 完整项目地址：https://github.com/371854496/pygame 觉得还OK的话，点下Star,作者不易，thank you！ 1.引入需要的模块，配置图片路径，设置界面宽高背景颜色，创建游戏主入口。 #1引入需要的模块 import pygame import random #1配置图片地址 IMAGE...
植物大战僵尸源码
09-08
植物大战僵尸的修改源码请参考，内容丰富简单。
【Python小游戏】植物大战僵尸的实现与源码分享
苏凉.py的博客
04-18 3129
地图搭建（部分） 定义植物类 （部分） 定义僵尸类（部分） 游戏运行入口 游戏源码获取 关注vx公众号【苏凉闲谈社】回复“777””即可免费领取游戏源码，同时还为大家准备了相关图书资料、视频资料以及其他python小游戏源码等等。
python 游戏源码植物大战僵尸
02-06
python 游戏源码植物大战僵尸
Python实现植物大战僵尸小游戏源码.zip
05-18
Python版植物大战僵尸小游戏源码，植物大战僵尸游戏的Python实现 已有的植物：向日葵，豌豆射手，坚果墙，寒冰射手，樱桃炸弹，双发射手，三线射手，大嘴花，小喷菇，土豆雷，地刺，胆小菇，倭瓜，火爆辣椒，阳光菇，寒冰菇，魅惑菇，火炬树桩，睡莲，杨桃，咖啡豆，海蘑菇，高坚果，缠绕水草，毁灭菇，墓碑吞噬者，大喷菇 已有的僵尸：普通僵尸，旗帜僵尸，路障僵尸，铁桶僵尸，读报僵尸，橄榄球僵尸，鸭子救生圈僵尸，铁门僵尸，撑杆跳僵尸，冰车僵尸 使用 JSON 文件记录关卡信息数据 支持选择植物卡片 支持白昼模式，夜晚模式，泳池模式，传送带模式和坚果保龄球模式 支持背景音乐播放 支持音效 支持全屏模式 按F键进入全屏模式，按U键恢复至窗口模式 支持用小铲子移除植物 支持分波生成僵尸 支持“关卡进程”进度条显示 夜晚模式支持墓碑以及从墓碑生成僵尸 含有泳池的模式也支持在最后一波时从泳池中自动冒出僵尸 环境要求 Python >= 3.7，最好使用最新版 Python-Pygame >= 1.9，最好使用最新版
植物大战僵尸python
06-30
这是植物大战僵尸python的源代码，运行时需要自己改一下文件的位置，可以自己在网上找图片或者联系我。
python版植物大战僵尸源码
10-10
对于这个Python版的“植物大战僵尸”源码，开发者可能还运用了一些高级技术，比如对象导向编程（OOP）来创建各种游戏对象（如植物、僵尸），以及状态机来管理游戏的不同阶段（如游戏开始、游戏进行、游戏结束）。...
Java版【植物大战僵尸+源码】
小新的博客
04-10 6618
小伙伴儿们大家好，我们又见面啦。在上一篇文章中，我向大家介绍了如何使用Python编程语言来实现经典的游戏——植物大战僵尸，并且分享了完整的源代码。这篇文章发布后，反响热烈，受到了众多小伙伴的热情追捧和积极反馈。在众多留言中，我注意到有不少小伙伴对Java版本的实现表现出了浓厚的兴趣。为了满足大家的期待，今天我特别准备了一份精心制作的内容——深入剖析Java版“植物大战僵尸”的实现原理，并细致解读其代码结构。 今天，我就为大家带来了另一款同样精彩的游戏分享——Java版的植物大战僵尸。在这篇文章中，我们将
python植物大战僵尸源码教学
wenangou的博客
09-22 3786
大家好，给大家分享一下一个有趣的事情，很多人还不知道这一点。下面详细解释一下。现在让我们来看看！下面给大家带来python实现植物大战僵尸的的源码分享，只含有冒险模式。
Python 植物大战僵尸代码实现(2):植物卡片选择和种植
热门推荐
marble_xu的博客
11-23 4万+
这篇文章要介绍的是： - 上方植物卡片栏的实现。 - 点击植物卡片，鼠标切换为植物图片。 - 鼠标移动时，判断当前在哪个方格中，并显示半透明的植物作为提示。
python植物大战僵尸源码
06-06
植物大战僵尸是一款商业游戏，其游戏源码并不公开，因此我无法提供其完整的Python源代码。不过，您可以通过学习Python编程语言和Pygame游戏开发库，自己编写类似的游戏。在编写过程中，您可以参考植物大战僵尸的游戏规则、场景设置、角色设计等方面的内容，以及其他类似游戏的实现方式，来帮助您完成您的游戏项目。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值