我要评论目录
一、实现功能
- 实施植物：向日葵、豌豆射手、壁桃、雪豆射手、樱桃炸弹、三豌豆射手、大口蘑菇，海扁蘑菇，土豆，尖刺草，惊吓蘑菇，南瓜，惊吓蘑菇，墨西哥辣椒，太阳蘑菇，冰蘑菇，催眠蘑菇。
- 实现僵尸：僵尸、旗帜僵尸、锥头僵尸、桶头僵尸、报纸僵尸。
- 使用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
发表评论