前言
- 其实这个项目再我上半年就想着做一下的，但是一直拖到现在，我现在深刻的理解到，不要想那么多，先做，因为永远不可能准备好，都是边做边学便准备的，完成比完美更重要；
- 使用python，是因为简单，我感觉大多数00后程序员应该都一个实现植物大战僵尸的梦吧；
- 这一次我深刻体会到了业务的重要性，很多时候对业务不理解，是很难做出点什么东西的，更难成为架构师；
- 还有，我深刻体会到了一句话：“仅修改少量代码，就实现功能”。
环境
- python：3.11.7，pygame：2.6.1
- 编译器：vscode
- 游戏运行结果截图
- 游戏任务图
- 游戏架构图
- main.py
import pygame
import sys
from pygame.locals import *
from const import *
from game import *
pygame.init()
DS = pygame.display.set_mode((1280, 600))
game = Game(DS)
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
game.mouseClickHandle(event.button) # 鼠标事件触发
DS.fill((255, 255, 255))
game.draw()
game.update()
pygame.display.update()
- cosnt.py
# 定义一些常量
GAME_SIZE = (1280, 600) # 游戏地图大小
# 网格游戏，一些参数
LEFT_TOP = (200, 65) # 游戏网格，左上角坐标
GRID_SIZE = (76, 96) # 每一个格子大小
GRID_COUNT = (9, 5) # 网格数量，9列5行
# 图片路径
PATH_BACK = "pic/other/back.png"
PATH_LOSS = "pic/other/lose.png"
SUNFLOWER_ID = 3
PEASHOOTER_ID = 4
- data_object.py
# 储存固定参数
data = {
0 : { # 豌豆
'PATH' : 'pic/other/peabullet.png',
'IMAGE_INDEX_MAX' : 0, # 图片索引范围
'IMAGE_INDEX_CD' : 0.0, # 图片更新频率
'POSITION_CD' : 0.008, # 位置更新速度
'SUMMON_CD' : -1, # 产生物的CD
'SIZE' : (44, 44), # 图片缩放大小
'SPEED' : (4, 0), # 速度
'CAN_LOOT' : False, # 是否可以捡
'PRICE' : 0, # 价格为0
'HP' : 1, # 血量
'ATT' : 1, # 攻击力
},
1 : { # 僵尸
'PATH' : 'pic/zombie/0/%d.png',
'IMAGE_INDEX_MAX' : 15,
'IMAGE_INDEX_CD' : 0.2,
'POSITION_CD' : 0.2,
'SUMMON_CD' : -1,
'SIZE' : (100, 128),
'SPEED' : (-2.5, 0),
'CAN_LOOT' : False,
'PRICE' : 0,
'HP' : 5,
'ATT' : 1,
},
2 : { # 阳光
'PATH' : 'pic/other/sunlight/%d.png',
'IMAGE_INDEX_MAX' : 30,
'IMAGE_INDEX_CD' : 0.06,
'POSITION_CD' : 0.05,
'SUMMON_CD' : -1,
'SIZE' : (80, 80),
'SPEED' : (0, 2),
'CAN_LOOT' : True,
'PRICE' : 25,
'HP' : 1000000000,
'ATT' : 0,
},
3 : { # 向日葵
'PATH' : 'pic/plant/sunflower/%d.png',
'IMAGE_INDEX_MAX' : 19,
'IMAGE_INDEX_CD' : 0.07,
'POSITION_CD' : 10000,
'SUMMON_CD' : 8,
'SIZE' : (128, 128),
'SPEED' : (0, 0),
'CAN_LOOT' : False,
'PRICE' : 50,
'HP' : 5,
'ATT' : 0,
},
4 : { # 射手
'PATH' : 'pic/plant/peashooter/%d.png',
'IMAGE_INDEX_MAX' : 15,
'IMAGE_INDEX_CD' : 0.15,
'POSITION_CD' : 10000,
'SUMMON_CD' : 3,
'SIZE' : (128, 128),
'SPEED' : (0, 0),
'CAN_LOOT' : False,
'PRICE' : 100,
'HP' : 5,
'ATT' : 0,
},
}
- game.py
import pygame
import image
import zombiebase
import peabullet
import data_object
import sunlight
import sunflower
import peashooter
import data_object
import time
import random
from const import *
class Game(object):
def __init__(self, ds):
self.ds = ds
self.back = image.Image(PATH_BACK, 0, (0, 0), GAME_SIZE, 0) # 储存背景
self.loss = image.Image(PATH_LOSS, 0, (0, 0), GAME_SIZE, 0) # 游戏结束
self.isGameOver = False
self.plants = []
self.summons = []
self.zombies = []
self.allPrivce = 100 # 初始价格
self.priveFont = pygame.font.Font(None, 60) # 字体
self.zombieGenerateTime = 0 # 上一次生成僵尸的时间
# 打僵尸几分
self.zombie = 0
self.zombieFont = pygame.font.Font(None, 60)
self.hasPlant = []
for i in range(GRID_SIZE[0]): # 赋值的是一个格子的
col = []
for j in range(GRID_SIZE[1]):
col.append(0)
self.hasPlant.append(col)
# 得到要种植的坐标
def getIndexByPos(self, pos): # 得到x，y坐标(注意是那种压缩的，就是x * 每个格子宽度 == 真实位置)
x = (pos[0] - LEFT_TOP[0]) // GRID_SIZE[0]
y = (pos[1] - LEFT_TOP[1]) // GRID_SIZE[1]
return x, y
def renderFont(self):
textImage = self.priveFont.render("Glod: " + str(self.allPrivce), True, (0, 0, 0))
self.ds.blit(textImage, (13, 23))
textImage = self.priveFont.render("Glod: " + str(self.allPrivce), True, (255, 255, 255))
self.ds.blit(textImage, (10, 20))
textImage = self.zombieFont.render("Score: " + str(self.zombie), True, (0, 0, 0))
self.ds.blit(textImage, (13, 83))
textImage = self.zombieFont.render("Score: " + str(self.zombie), True, (255, 255, 255))
self.ds.blit(textImage, (10, 80))
def draw(self):
self.back.draw(self.ds)
for plant in self.plants: # 植物绘制
plant.draw(self.ds)
for summon in self.summons: # 生成物绘制
summon.draw(self.ds)
for zombie in self.zombies:
zombie.draw(self.ds)
# 绘制金额
self.renderFont()
# 是否结束
if self.isGameOver:
self.loss.draw(self.ds)
def update(self):
self.back.update()
for plant in self.plants:
plant.update()
if plant.hasSummon(): # 有生成物
summ = plant.doSummon() # 就生成
self.summons.append(summ) # 给game管理生命周期
for summon in self.summons:
summon.update()
for zombie in self.zombies:
zombie.update()
# 更新一次，看是否能产生僵尸
if time.time() - self.zombieGenerateTime > 10:
self.zombieGenerateTime = time.time()
self.addZombie(14, random.randint(0, 4))
self.checkSummonVsZombie()
self.checkZombieVsPlant()
# 游戏是否结束
for z in self.zombies:
if z.getRect().x < 0:
self.isGameOver = True
# 子弹超出屏幕，需要销毁
for summon in self.summons:
if summon.getRect().x > GAME_SIZE[0] or summon.getRect().y > GAME_SIZE[1]:
self.summons.remove(summon)
break # 退出是因为[]索引会改变
# 僵尸和植物对抗
def checkSummonVsZombie(self):
for summon in self.summons:
for zombie in self.zombies:
if summon.isCollide(zombie): # 僵尸和植物对抗
self.fight(summon, zombie) # 对抗
if zombie.hp <= 0:
self.zombies.remove(zombie) # 移除僵尸
self.zombie += 1 # 加分
if summon.hp <= 0:
self.summons.remove(summon) # 移除植物
return
# 僵尸吃植物
def checkZombieVsPlant(self):
for zombie in self.zombies:
for plant in self.plants:
if zombie.isCollide(plant):
self.fight(zombie, plant)
if plant.hp <= 0:
self.plants.remove(plant)
break
# 产生阳光
def addSunFlower(self, i, j):
pos = LEFT_TOP[0] + i * GRID_SIZE[0], LEFT_TOP[1] + j * GRID_SIZE[1]
sf = sunflower.SunFlower(3, pos)
self.plants.append(sf)
# 产生豌豆
def addPeaShooter(self, x, y):
pos = LEFT_TOP[0] + x * GRID_SIZE[0], LEFT_TOP[1] + y * GRID_SIZE[1]
sf = peashooter.PeaShooter(PEASHOOTER_ID, pos)
self.plants.append(sf)
# 产生僵尸
def addZombie(self, x, y):
pos = LEFT_TOP[0] + x * GRID_SIZE[0], LEFT_TOP[1] + y * GRID_SIZE[1]
zom = zombiebase.ZombieBase(1, pos)
self.zombies.append(zom)
# 对抗
def fight(self, a, b):
while True:
a.hp -= b.attack
b.hp -= a.attack
if b.hp <= 0: # a 打败 b
return True
if a.hp <= 0: # b 打败 a
return False
return False
def checkLoot(self, mousePos):
for summon in self.summons:
if not summon.getIsLoot():
continue
rect = summon.getRect() # 获取图片矩形
if rect.collidepoint(mousePos): # 点击坐标是否在举行区域内
self.summons.remove(summon) # 移除内存
self.allPrivce += summon.getPrice() # 金额增加
return True
return False
# 种
def checkAddPlant(self, mousePos, objjId):
x, y = self.getIndexByPos(mousePos)
# 判断是否能种植
if x < 0 or x >= GRID_COUNT[0]:
return
if y < 0 or y >= GRID_COUNT[1]:
return
# 不能重复种种植判断
if self.hasPlant[x][y] == 1:
return
self.hasPlant[x][y] = 1
# 金币扣除
if self.allPrivce < data_object.data[objjId]['PRICE']:
return
self.allPrivce -= data_object.data[objjId]['PRICE']
if objjId == SUNFLOWER_ID: # 种花
self.addSunFlower(x, y)
elif objjId == PEASHOOTER_ID: # 种射手
self.addPeaShooter(x, y)
# 鼠标事件
def mouseClickHandle(self, btn):
# 游戏结束，鼠标不能种植
if self.isGameOver:
return
mousePos = pygame.mouse.get_pos() # 获取鼠标位置
if self.checkLoot(mousePos): # 触发，不能再种其他东西了
return
if btn == 1: # 鼠标左键
self.checkAddPlant(mousePos, SUNFLOWER_ID)
elif btn == 3:
self.checkAddPlant(mousePos, PEASHOOTER_ID)
- image.py
import pygame
class Image(pygame.sprite.Sprite):
def __init__(self, pathFmt, pathIndex, pos, size=None, pathIndexCount=0):
self.pathFmt = pathFmt
self.pathIndex = pathIndex # 存储索引
self.pos = list(pos) # ()元组不支持修改，但list可以，这里可以修改坐标
self.size = size # 窗口大小
self.pathIndexCount = pathIndexCount # 储存图片索引最大下标
self.updateImage() # 显示图片
# 更新图片
def updateImage(self):
path = self.pathFmt
if self.pathIndexCount != 0: # 更新图片目录
path = path % self.pathIndex
self.image = pygame.image.load(path) # 更新图片，贴图
if self.size: # 有大小，则缩放
self.image = pygame.transform.scale(self.image, self.size)
# 更新图片大小
def updateSize(self):
self.size = size
self.updateImage()
# 更新图片索引
def updateIndex(self, pathIndex):
self.pathIndex = pathIndex
self.updateImage() # 索引更新，则更新图片
# 获取图片大小和坐标
def getRect(self):
rect = self.image.get_rect()
rect.x, rect.y = self.pos # 移动本质是图片坐标的更改(左上角)
return rect
# 僵尸移动
def doLeft(self):
self.pos[0] -= 0.15 # 移动速度，本质是坐标修改
def draw(self, ds):
ds.blit(self.image, self.getRect())
- objectbase.py
import image
import time
import data_object
class ObjectBase(image.Image):
def __init__(self, id, pos):
# 定义时间，实现自驱动
self.preTimeIndex = 0
self.prePositionTime = 0
self.preSummonTime = 0
# 储存不同物体的id
self.id = id
# 血量和攻击力
self.hp = self.getData()['HP']
self.attack = self.getData()['ATT']
# 继承
super(ObjectBase, self).__init__(
self.getData()['PATH'],
0,
pos,
self.getData()['SIZE'],
self.getData()['IMAGE_INDEX_MAX']
)
# 返回不同的数据
def getData(self):
return data_object.data[self.id]
# 返回速度
def getSpeed(self):
return self.getData()['SPEED']
# 返回更新动画的时间
def getPositionCD(self):
return self.getData()['POSITION_CD']
# 返回图片更新时间
def getImageIndexCD(self):
return self.getData()['IMAGE_INDEX_CD']
# 产生物的时间
def getSummonCD(self):
return self.getData()['SUMMON_CD']
# 返回是否可以捡
def getIsLoot(self):
return self.getData()['CAN_LOOT']
# 返回植物相应的价格
def getPrice(self):
return self.getData()['PRICE']
# 相撞
def isCollide(self, other):
return self.getRect().colliderect(other.getRect()) # 相撞
# 更新动画
def update(self):
self.checkImageIndex() # 更新帧动画
self.checkPosition() # 更新图片坐标
self.checkSummon()
# 是否产生了生成物
def checkSummon(self):
if time.time() - self.preSummonTime <= self.getSummonCD():
return
self.preSummonTime = time.time()
# 调用产生阳光
self.preSummon()
def checkImageIndex(self):
#储存更新时间
if time.time() - self.preTimeIndex <= self.getImageIndexCD(): # 间隔时间和位置更新一致
return
self.preTimeIndex = time.time()
idx = self.pathIndex + 1
if idx >= self.pathIndexCount:
idx = 0
self.updateIndex(idx)
def checkPosition(self):
if time.time() - self.prePositionTime <= self.getPositionCD(): # 间隔时间和位置更新一致
return False
self.prePositionTime = time.time()
speed = self.getSpeed()
self.pos = (self.pos[0] + speed[0], self.pos[1] + speed[1])
return True
def preSummon(self):
pass
# 是否有产生物
def hasSummon(self):
pass
# 生产产生物
def doSummon(self):
pass
- peabullet.py
import objectbase
class PeaBullet(objectbase.ObjectBase):
pass
- peashooter.py
import objectbase
import peabullet
import time
class PeaShooter(objectbase.ObjectBase):
def __init__(self, id, pos):
super(PeaShooter, self).__init__(id, pos)
self.hasBullet = False # 可以发射子弹
self.hasShoot = False # 立即发射
def hasSummon(self):
return self.hasBullet
# 产生阳光
def preSummon(self):
self.hasShoot = True # 发射
self.pathIndex = 0 # 索引为0
# 种阳光
def doSummon(self):
if self.hasSummon():
self.hasBullet = False
return peabullet.PeaBullet(0, (self.pos[0] + 20, self.pos[1] + 30))
def checkImageIndex(self):
#储存更新时间
if time.time() - self.preTimeIndex <= self.getImageIndexCD(): # 间隔时间和位置更新一致
return
self.preTimeIndex = time.time()
idx = self.pathIndex + 1
if idx == 8 and self.hasShoot:
self.hasBullet = True # 发送
if idx >= self.pathIndexCount: # 不发射情况
idx = 9
self.updateIndex(idx)
- sunflower.py
import objectbase
import sunlight
class SunFlower(objectbase.ObjectBase):
def __init__(self, id, pos):
super(SunFlower, self).__init__(id, pos)
self.hasSunlight = False
def hasSummon(self):
return self.hasSunlight
# 产生阳光
def preSummon(self):
self.hasSunlight = True
# 种阳光
def doSummon(self):
if self.hasSummon():
self.hasSunlight = False
return sunlight.SunLight(2, (self.pos[0] + 20, self.pos[1] + 10))
- sunlight.py
import objectbase
class SunLight(objectbase.ObjectBase):
pass
- zombiebase.py
import objectbase
class ZombieBase(objectbase.ObjectBase):
pass
