Python实现植物大战僵尸
一、概述
大二暑期python项目，使用pygame编写，仅实现了冒险模式一关及我是僵尸，均使用原版贴图和音效，并尽量完整复刻了动画效果
资源链接：https://download.csdn.net/download/qq_39033469/87373063
二、整体展示
冒险模式：
经典关卡，合理运用阳光种植植物抵挡僵尸，消灭所有僵尸后获胜
目前共有7种植物，3种僵尸
迷你游戏 我是僵尸（僵尸公敌）：
角色互换，合理运用阳光放置僵尸，以消灭确定阵型的植物，僵尸吃掉所有植物后面的脑子后获胜
除樱桃炸弹外的6种植物和3种僵尸都有涉及
三、细节展示
所有界面均可点击菜单键暂停，并可调整音乐和音效音量
大部分按钮均有鼠标高亮显示和点击时下降效果凸显立体感
进入游戏前会检测文件完整性，文件缺失会有提示界面
放置植物或僵尸时会有跟随鼠标的植物或僵尸在草地上会显示预览位置
四、基本思路
将完整界面分为各个部分，植物、僵尸、界面元素等。几乎每个部分都有相应的类对应。
游戏时每个部分首先绘制当前帧，并自行计算下一帧，不同位置的鼠标操作会影响下一帧。只有可能有多帧动画的部分使用了类，其他动画很少或者静态图片都用不同状态的图片显示
由于游戏全程每秒60帧，每次循环绘制的帧都会持续1/60秒，从而也是一种计时器，游戏中与时间相关的数据，如冷却时间，动画效果，移动速度等都以帧来计算。不同的对象有互相独立的帧动画，帧与帧之间的时间间隔也不同，因此在每个有帧动画的类中内置了帧率参数cur，FPSVar和FPSDiv
cur代表该对象需要绘制的帧，每次加一代表下一张需要绘制的帧
FPSVar代表外部帧数，初始化之后与整体循环帧率同步
FPSDiv代表该对象帧率与游戏帧率的比例，如果值为6，则该对象每6帧绘制下一帧
这样就能使每个对象都独立流畅地绘制动画文章来源：https://www.toymoban.com/news/detail-425091.html
五、全部代码
因个人编码能力及经验限制，代码风格极其简陋，仅供学习。
贴图、音效等资源见https://download.csdn.net/download/qq_39033469/87373063
目前未发现较大bug文章来源地址https://www.toymoban.com/news/detail-425091.html
import pygame
import random
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600
WINDOW_SIZE = (WINDOW_WIDTH, WINDOW_HEIGHT)
FONT = 'gbk.ttf'
FONT_COLOR = ((18, 179, 24), (16, 217, 14), (226, 188, 107),
(111, 111, 135), (59, 39, 15), (213, 160, 36),
(220, 220, 220), (46, 46, 93))
# 显示位置
POS_X = 0
POS_Y = 0
POS = (POS_X, POS_Y)
SUN_POS = (10, 0)
CARD_POS = (90, 8)
CARD_SIZE = (51, 70)
GRASS_POS = (36, 78)
GRASS_SIZE = (80, 100)
GRASS_NUM = (9, 5)
# 位移误差
GROW_PLUSX = (5, 5, -15, 0, 0, 5, -10)
GROW_PLUSY = (10, 5, 8, 0, 40, 10, -30)
MINIGAMES_ZOMBIE_PLUSX = -75
MINIGAMES_ZOMBIE_PLUSY = -70
ZOMBIE_PLUSY = 30
FPS = 60
# 草地是否被占用
GRASS = []
"""
Code
0 Peashooter
1 Sunflower
2 Cherrybomb
3 Wallnut
4 Potatomine
5 Doublepeashooter
6 Chomper
0 NormalZombie
1 ConeheadZombie
2 BucketheadZombie
"""
ZOMBIE_SUN_COST = (50, 75, 125)
SUN_COST = (100, 50, 150, 50, 25, 200, 150)
FROZEN_TIME = (7.5, 7.5, 3.5, 30, 30, 7.5, 7.5)
PLANT_SIZE = ((71, 71), (73, 74), (112, 81), (100, 100), (75, 55), (73, 71), (130, 114))
ZOMBIE_SIZE = ((166, 144), (166, 144), (166, 144))
INDEX_Zombie = [22, 11, 20]
ZOMBIE_SPEED = 122.24 / FPS
BULLET_START_POS = (53, 11)
BULLET_SIZE = (28, 28)
# 按钮位置
ADVENTURE_BUTTON = (384, 72)
MINIGAMES_BUTTON = (385, 203)
ADVENTURE_TEXT = ((552, 90), (575, 92))
HELP_BUTTON = (650, 530)
QUIT_BUTTON = (731, 510)
OPTIONS_BUTTON = (561, 486)
PAUSE_BUTTON = ((680, -10), (716, -10), (762, -10))
PAUSE_BUTTON_ALPHA = (683, -9)
BACK_TO_GAME = (224, 438)
BACK_TO_GAME_ALPHA = (224, 440)
PAUSE_OPTION_DOWN = ((298, 350), (334, 350), (380, 350), (426, 350), (472, 350))
PAUSE_OPTION_DOWN_ALPHA = (298, 354)
PAUSE_OPTION_UP = ((298, 280), (334, 280), (380, 280), (426, 280), (472, 280))
PAUSE_OPTION_UP_ALPHA = (298, 284)
LOST_RESTART = ((295, 347), (331, 347), (377, 347), (423, 347), (469, 347))
LOST_RESTART_ALPHA = (295, 351)
# 音乐播放位置
MUSIC_POS = 0.0
MUSIC_VOLUME = 0.5
SOUND_VOLUME = 0.15
USEREVENT_COUNT = 0
LEVEL = 1
TOTAL_ZOMBIE = 37
INIT_SUN = 1500
class Button(object):
def __init__(self, position, file, alpha=None):
self.image = file
self.image_alpha = alpha
self.pos = position
def draw(self):
window.blit(self.image, self.pos)
# 高亮显示
def draw_alpha(self):
window.blit(self.image_alpha, self.pos)
class Trophy(object):
size = (166, 136)
def __init__(self, posx, posy):
self.posx = posx
self.posy = posy
self.endx = posx - 80
self.endy = posy - 80
falling_time = FPS * 2
self.speed_x = (self.endx - posx) / falling_time
self.speed_y = 0
self.images = IMAGE_Trophy
self.cur = 0
self.FPSVar = 0
self.index = 9
def fall(self):
if self.posy >= self.endy:
return
self.posx += self.speed_x
self.posy += self.speed_y
self.speed_y += 0.16
def draw(self):
window.blit(self.images[self.cur % self.index], (self.posx, self.posy))
self.FPSVar = (self.FPSVar + 1) % 5
if self.FPSVar == 0:
self.cur += 1
class Head(object):
def __init__(self, posx, posy):
self.posx = random.randint(int(posx) + 20, int(posx) + 40)
self.posy = posy - 30
self.cur = 0
self.FPSVar = 0
self.images = IMAGE_Zombie_head
def draw(self):
window.blit(self.images[self.cur], (self.posx, self.posy))
self.FPSVar = (self.FPSVar + 1) % 7
if self.FPSVar == 0:
self.cur += 1
if self.cur == 17:
head_list.remove(self)
class Body(object):
def __init__(self, posx, posy, status, speed=None):
self.posx = posx
self.posy = posy
self.cur = 0
self.FPSVar = 0
self.images = IMAGE_Zombie_body
self.images_walking_dead = IMAGE_Zombie_body_walking
self.images_eating_dead = IMAGE_Zombie_body_eating
self.status = status
self.speed = speed
def draw(self):
self.FPSVar = (self.FPSVar + 1) % 7
if self.FPSVar == 0:
self.cur += 1
if self.status == 0:
window.blit(self.images_walking_dead[self.cur], (self.posx, self.posy))
self.move()
if self.cur == 17:
load_sound(random.randint(11, 12))
self.cur = 0
self.FPSVar = 0
self.posx -= 10
self.status = 2
elif self.status == 1:
window.blit(self.images_eating_dead[self.cur], (self.posx, self.posy))
if self.cur == 10:
load_sound(random.randint(11, 12))
self.cur = 0
self.FPSVar = 0
self.posx -= 10
self.status = 2
if self.status == 2:
window.blit(self.images[self.cur], (self.posx, self.posy))
if self.cur == 16:
body_list.remove(self)
def move(self):
if self.status == 0:
self.posx -= self.speed
def draw_walking(self):
self.cur = 0
self.FPSVar = (self.FPSVar + 1) % 7
if self.FPSVar == 0:
self.cur += 1
if self.cur == 17:
body_list.remove(self)
def draw_eating(self):
self.cur = 0
window.blit(self.images_eating_dead[self.cur], (self.posx, self.posy))
self.FPSVar = (self.FPSVar + 1) % 7
if self.FPSVar == 0:
self.cur += 1
if self.cur == 17:
body_list.remove(self)
class MinigamesZombie(object):
def __init__(self, code, speed, health, images, move, initpos=None,
posx=None, grassy=None, cur=0, FPSVar=0, eating_flag=False):
self.code = code
self.index = INDEX_Zombie
self.cur = cur
self.FPSVar = FPSVar
self.move = move
self.images_normal = images[0]
self.images_eating = images[1]
self.images_boom = images[2]
self.eating_flag = eating_flag
self.alpha_image = self.images_normal[0].copy()
self.alpha_image.set_alpha(100)
self.speed = speed
self.health = health
if move:
grass_x = (initpos[0] - GRASS_POS[0]) // GRASS_SIZE[0]
grass_y = (initpos[1] - GRASS_POS[1]) // GRASS_SIZE[1] + 1
self.posx = GRASS_POS[0] + grass_x * GRASS_SIZE[0] + MINIGAMES_ZOMBIE_PLUSX
self.grassy = grass_y
self.posy = self.grassy * GRASS_SIZE[1] + MINIGAMES_ZOMBIE_PLUSY
if posx is not None:
self.grassy = grassy
self.posx = posx
self.posy = self.grassy * GRASS_SIZE[1] + ZOMBIE_PLUSY
def draw(self, pos):
window.blit(self.images_normal[0], pos)
def draw_on_grass(self):
eat_flag = check_eat(self.posx, self.posy)
if eat_flag is None:
if self.eating_flag:
self.cur = 0
self.eating_flag = False
pos = (self.posx, self.posy)
window.blit(self.images_normal[self.cur % self.index[0]], pos)
self.FPSVar = (self.FPSVar + 1) % 8
if self.FPSVar == 0:
self.cur += 1
self.move_on_grass()
else:
if not self.eating_flag:
self.cur = 0
self.eating_flag = True
pos = (self.posx, self.posy)
window.blit(self.images_eating[self.cur % self.index[1]], pos)
self.FPSVar = (self.FPSVar + 1) % 8
if self.FPSVar == 0:
self.cur += 1
if self.cur % self.index[1] == 5:
eat_flag.hurt(70)
load_sound(random.randint(0, 1) * 2 + 1)
elif self.cur % self.index[1] == 10:
eat_flag.hurt(70)
load_sound(2)
def draw_alpha(self, pos):
x = (pos[0] - GRASS_POS[0]) // GRASS_SIZE[0]
y = (pos[1] - GRASS_POS[1]) // GRASS_SIZE[1]
grow_pos = (GRASS_POS[0] + x * GRASS_SIZE[0] + MINIGAMES_ZOMBIE_PLUSX,
GRASS_POS[1] + y * GRASS_SIZE[1] + MINIGAMES_ZOMBIE_PLUSY + 20)
window.blit(self.alpha_image, grow_pos)
def move_on_grass(self):
self.posx -= self.speed
if self.posx < -150:
zombie_list.remove(self)
def hurt(self, num, status=None):
self.health -= num
if self.health <= 0:
if status == 'mine':
zombie_list.remove(self)
else:
self.die()
def die(self):
load_sound(10)
head_list.append(Head(self.posx, self.posy))
if self.eating_flag:
body_list.append(Body(self.posx, self.posy, 1))
else:
body_list.append(Body(self.posx, self.posy, 0, self.speed / 8))
zombie_list.remove(self)
class MinigamesNormalZombie(MinigamesZombie):
def __init__(self, move, initpos=None, posx=None, grassy=None, cur=0, FPSVar=0, eating_flag=False):
MinigamesZombie.__init__(self, 0, ZOMBIE_SPEED, 300, IMAGE_Normal_zombie, move, initpos,
posx, grassy, cur, FPSVar, eating_flag)
class MinigamesConeZombie(MinigamesZombie):
def __init__(self, move, initpos=None, posx=None, grassy=None):
MinigamesZombie.__init__(self, 1, ZOMBIE_SPEED, 370, IMAGE_Conehead_zombie, move, initpos, posx=posx, grassy=grassy)
def hurt(self, num, status=None):
self.health -= num
if self.health <= 0:
if status == 'mine':
zombie_list.remove(self)
else:
zombie_list.remove(self)
zombie_list.append(MinigamesNormalZombie(True, posx=self.posx + 10, grassy=self.grassy, cur=self.cur,
FPSVar=self.FPSVar, eating_flag=self.eating_flag))
class MinigamesBucketZombie(MinigamesZombie):
def __init__(self, move, initpos=None, posx=None, grassy=None):
MinigamesZombie.__init__(self, 2, ZOMBIE_SPEED, 1100, IMAGE_Buckethead_zombie, move, initpos, posx=posx, grassy=grassy)
def hurt(self, num, status=None):
self.health -= num
if self.health <= 0:
if status == 'mine':
zombie_list.remove(self)
else:
zombie_list.remove(self)
zombie_list.append(MinigamesNormalZombie(True, posx=self.posx + 10, grassy=self.grassy, cur=self.cur,
FPSVar=self.FPSVar, eating_flag=self.eating_flag))
class MinigamesPlant(object):
def __init__(self, code, index, FPSDiv, images, grassx, grassy):
self.code = code
self.index = index
self.cur = 0
self.FPSVar = 0
self.FPSDiv = FPSDiv
self.images = images
self.health = 300
self.grassx = grassx
self.grassy = grassy
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
window.blit(self.images[self.cur % self.index], grow_pos)
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
def hurt(self, num):
self.health -= num
if self.health <= 0:
self.die()
def die(self):
load_sound(30)
plant_list.remove(self)
class MinigamesSunflower(MinigamesPlant):
def __init__(self, grassx, grassy):
MinigamesPlant.__init__(self, 1, 18, 5, IMAGE_Sunflower, grassx, grassy)
def produce(self):
sun_falling.append(Sun(self.grassx, self.grassy))
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
window.blit(self.images[self.cur % self.index], grow_pos)
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
def hurt(self, num):
self.health -= num
sun_falling.append(Sun(self.grassx, self.grassy))
if self.health <= 0:
self.die()
class MinigamesPeashooter(MinigamesPlant):
def __init__(self, grassx, grassy):
MinigamesPlant.__init__(self, 0, 13, 6, IMAGE_Peashooter, grassx, grassy)
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
window.blit(self.images[self.cur % self.index], grow_pos)
return self.next()
def next(self):
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if self.cur % self.index == 2 and self.FPSVar == 0:
if minigames_discover_zombie(self.grassx, self.grassy):
return MinigamesBullet(self.grassx, self.grassy)
return None
class MinigamesWallNut(MinigamesPlant):
def __init__(self, grassx, grassy):
MinigamesPlant.__init__(self, 3, 3, 6, IMAGE_Wallnut, grassx, grassy)
self.health = 4000
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
if self.health >= 8000 / 3:
window.blit(self.images[0], grow_pos)
elif self.health >= 4000 / 3:
window.blit(self.images[1], grow_pos)
else:
window.blit(self.images[2], grow_pos)
class MinigamesPotatoMine(MinigamesPlant):
def __init__(self, grassx, grassy):
MinigamesPlant.__init__(self, 4, 8, 10, IMAGE_Potatomine, grassx, grassy)
self.initimage = IMAGE_Potatomine_init
self.blowimage = IMAGE_Potatomine_blow
self.ready = True
self.blowing = False
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
if self.ready:
zombie_to_blow = self.check_collision()
if zombie_to_blow is not None:
grow_pos_v = (grow_pos[0] - 30, grow_pos[1] - 25)
window.blit(self.blowimage, grow_pos_v)
self.ready = False
self.blowing = True
load_sound(23)
zombie_to_blow.hurt(1800, 'mine')
self.cur = 0
else:
window.blit(self.images[self.cur % self.index], grow_pos)
else:
if self.blowing:
grow_pos_v = (grow_pos[0] - 40, grow_pos[1] - 60)
window.blit(self.blowimage, grow_pos_v)
if self.cur == 8:
plant_list.remove(self)
else:
grow_pos_v = (grow_pos[0] + 20, grow_pos[1] + 10)
window.blit(self.initimage, grow_pos_v)
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if not self.blowing and not self.ready and self.cur == 15 * FPS / self.FPSDiv:
self.ready = True
def check_collision(self):
for each in zombie_list:
temp_posx = GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code]
if -90 <= each.posx - temp_posx <= -10 and each.grassy == self.grassy + 1:
return each
return None
class MinigamesDoublePea(MinigamesPeashooter):
def __init__(self, grassx, grassy):
MinigamesPeashooter.__init__(self, grassx, grassy)
self.code = 5
self.index = 15
self.images = IMAGE_Doublepea
def next(self):
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if (self.cur % self.index == 2 or self.cur % self.index == 8) and self.FPSVar == 0:
if minigames_discover_zombie(self.grassx, self.grassy):
return MinigamesBullet(self.grassx, self.grassy)
return None
class MinigamesChomper(MinigamesPlant):
def __init__(self, grassx, grassy):
MinigamesPlant.__init__(self, 6, (13, 9, 6), 8, IMAGE_Chomper, grassx, grassy)
self.attackimages = IMAGE_Chomper_attack
self.digestimages = IMAGE_Chomper_digest
self.chewingtime = 42 * FPS / self.FPSDiv
self.attack = False
self.ready = True
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
if not self.attack:
if self.ready:
window.blit(self.images[self.cur % self.index[0]], grow_pos)
if self.check_collision():
self.attack = True
self.cur = 0
else:
window.blit(self.digestimages[self.cur % self.index[2]], grow_pos)
if self.cur == self.chewingtime:
self.cur = 0
self.ready = True
else:
window.blit(self.attackimages[self.cur], grow_pos)
if self.cur == 6 and self.FPSVar == 0:
load_sound(24)
self.eat()
if self.cur == self.index[1] - 1:
self.cur = 0
self.attack = False
self.ready = False
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
def check_collision(self):
for each in zombie_list:
temp_posx = GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code]
if -40 <= each.posx - temp_posx <= 80 and self.grassy == each.grassy - 1:
return True
def eat(self):
for each in zombie_list:
temp_posx = GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code]
if -40 <= each.posx - temp_posx <= 80 and self.grassy == each.grassy - 1:
each.hurt(1800, 'mine')
return
class Zombie(object):
def __init__(self, code, speed, health, images, posx=None, grassy=None, cur=0, FPSVar=0, eating_flag=False):
self.code = code
self.cur = cur
self.FPSVar = FPSVar
self.speed = speed
self.health = health
self.index = INDEX_Zombie
if posx is None:
self.grassy = random.randint(0, 4)
self.posx = 730
self.posy = self.grassy * GRASS_SIZE[1] + ZOMBIE_PLUSY
else:
self.grassy = grassy
self.posx = posx
self.posy = self.grassy * GRASS_SIZE[1] + ZOMBIE_PLUSY
self.images_normal = images[0]
self.images_eating = images[1]
self.images_boom = images[2]
self.eating_flag = eating_flag
self.boom = False
def draw(self):
# print(self.code, self.health, self.posx, self.posy, self.grassy)
eat_flag = check_eat(self.posx, self.posy)
if self.boom:
pos = (self.posx, self.posy)
window.blit(self.images_boom[self.cur % self.index[2]], pos)
self.FPSVar = (self.FPSVar + 1) % 6
if self.FPSVar == 0:
self.cur += 1
if self.cur == self.index[2]:
self.boom_die()
return
if eat_flag is None:
if self.eating_flag:
self.cur = 0
self.eating_flag = False
pos = (self.posx, self.posy)
window.blit(self.images_normal[self.cur % self.index[0]], pos)
self.FPSVar = (self.FPSVar + 1) % 8
if self.FPSVar == 0:
self.cur += 1
self.move()
else:
if not self.eating_flag:
self.cur = 0
self.eating_flag = True
pos = (self.posx, self.posy)
window.blit(self.images_eating[self.cur % self.index[1]], pos)
self.FPSVar = (self.FPSVar + 1) % 8
if self.FPSVar == 0:
self.cur += 1
if self.cur % self.index[1] == 5:
eat_flag.hurt(70)
load_sound(random.randint(0, 1) * 2 + 1)
elif self.cur % self.index[1] == 10:
eat_flag.hurt(70)
load_sound(2)
def move(self):
if self.posx < -150:
global fail
fail = True
self.posx -= self.speed
def hurt(self, num, status=None):
self.health -= num
if self.health <= 0:
if num == 10000:
self.instant_die()
elif status == 'boom':
self.boom = True
self.cur = 0
self.speed = 0
elif status == 'mine':
zombie_list.remove(self)
if win and len(zombie_list) == 0:
global trophy
trophy = Trophy(self.posx, self.posy)
else:
if self.boom:
return
self.die()
def die(self):
load_sound(10)
head_list.append(Head(self.posx, self.posy))
if self.eating_flag:
body_list.append(Body(self.posx, self.posy, 1))
else:
body_list.append(Body(self.posx, self.posy, 0, self.speed / 8))
zombie_list.remove(self)
if win and len(zombie_list) == 0:
global trophy
trophy = Trophy(self.posx, self.posy)
def instant_die(self):
load_sound(10)
head_list.append(Head(self.posx, self.posy))
body_list.append(Body(self.posx, self.posy, 2))
zombie_list.remove(self)
if win and len(zombie_list) == 0:
global trophy
trophy = Trophy(self.posx, self.posy)
def boom_die(self):
zombie_list.remove(self)
if win and len(zombie_list) == 0:
global trophy
trophy = Trophy(self.posx, self.posy)
class NormalZombie(Zombie):
def __init__(self, posx=None, grassy=None, cur=0, FPSVar=0, eating_flag=False):
Zombie.__init__(self, 0, ZOMBIE_SPEED, 300, IMAGE_Normal_zombie, posx, grassy, cur, FPSVar, eating_flag)
class ConeHeadZombie(Zombie):
def __init__(self, posx=None, grassy=None, cur=0, FPSVar=0, eating_flag=False):
Zombie.__init__(self, 1, ZOMBIE_SPEED, 370, IMAGE_Conehead_zombie, posx, grassy, cur, FPSVar, eating_flag)
def hurt(self, num, status=None):
self.health -= num
if self.health <= 0:
if num == 10000:
self.instant_die()
elif status == 'boom':
self.boom = True
self.cur = 0
self.speed = 0
elif status == 'mine':
zombie_list.remove(self)
if win and len(zombie_list) == 0:
global trophy
trophy = Trophy(self.posx, self.posy)
else:
if self.boom:
return
zombie_list.remove(self)
zombie_list.append(NormalZombie(self.posx + 10, self.grassy, self.cur, self.FPSVar, self.eating_flag))
class BucketHeadZombie(Zombie):
def __init__(self, posx=None, grassy=None, cur=0, FPSVar=0, eating_flag=False):
Zombie.__init__(self, 2, ZOMBIE_SPEED, 1100, IMAGE_Buckethead_zombie, posx, grassy, cur, FPSVar, eating_flag)
def hurt(self, num, status=None):
self.health -= num
# print(self.posx, self.grassy, self.health)
if self.health <= 0:
if num == 10000:
self.instant_die()
elif status == 'boom':
# print(self.posx, self.grassy, self.health, 'boom')
self.boom = True
self.cur = 0
self.speed = 0
elif status == 'mine':
zombie_list.remove(self)
if win and len(zombie_list) == 0:
global trophy
trophy = Trophy(self.posx, self.posy)
else:
if self.boom:
return
zombie_list.remove(self)
zombie_list.append(NormalZombie(self.posx, self.grassy, self.cur, self.FPSVar, self.eating_flag))
class Plant(object):
def __init__(self, move, code, index, FPSDiv, images, pos=None):
self.code = code
self.index = index
self.cur = 0
self.FPSVar = 0
self.FPSDiv = FPSDiv
self.move = move
self.images = images
self.alpha_image = self.images[0].copy()
self.alpha_image.set_alpha(100)
self.health = 300
if move:
self.grassx = (pos[0] - GRASS_POS[0]) // GRASS_SIZE[0]
self.grassy = (pos[1] - GRASS_POS[1]) // GRASS_SIZE[1]
def draw(self, pos):
window.blit(self.images[0], pos)
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
window.blit(self.images[self.cur % self.index], grow_pos)
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
def draw_alpha(self, pos):
x = (pos[0] - GRASS_POS[0]) // GRASS_SIZE[0]
y = (pos[1] - GRASS_POS[1]) // GRASS_SIZE[1]
grow_pos = (GRASS_POS[0] + x * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + y * GRASS_SIZE[1] + GROW_PLUSY[self.code])
window.blit(self.alpha_image, grow_pos)
def hurt(self, num):
self.health -= num
if self.health <= 0:
self.die()
def die(self):
load_sound(30)
plant_list.remove(self)
remove_plant_in_GRASS(self)
class Sunflower(Plant):
def __init__(self, move, pos=None):
Plant.__init__(self, move, 1, 18, 5, IMAGE_Sunflower, pos)
def produce(self):
sun_falling.append(Sun(self.grassx, self.grassy))
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
window.blit(self.images[self.cur % self.index], grow_pos)
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if (self.cur + 9) % 288 == 0:
self.produce()
class Peashooter(Plant):
def __init__(self, move, pos=None):
Plant.__init__(self, move, 0, 13, 6, IMAGE_Peashooter, pos)
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
window.blit(self.images[self.cur % self.index], grow_pos)
return self.next()
def next(self):
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if self.cur % self.index == 2 and self.FPSVar == 0:
if discover_zombie(self.grassx, self.grassy):
return Bullet(self.grassx, self.grassy)
return None
class CherryBomb(Plant):
def __init__(self, move, pos=None):
Plant.__init__(self, move, 2, 11, 6, IMAGE_Cherrybomb, pos)
self.health = 3000
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
if self.cur >= 7:
grow_pos_v = (grow_pos[0] - 50, grow_pos[1] - 30)
window.blit(self.images[self.cur], grow_pos_v)
else:
window.blit(self.images[self.cur], grow_pos)
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if self.cur == self.index - 4:
load_sound(22)
self.blow()
if self.cur == self.index - 1:
plant_list.remove(self)
remove_plant_in_GRASS(self)
def blow(self):
for each in zombie_list:
# temp_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
# GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
temp_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1])
# if ((each.posx - temp_pos[0]) ** 2 + (each.posy - temp_pos[1]) ** 2) ** 0.5 <= GRASS_SIZE[0] * 2:
# if -GRASS_SIZE[0] <= each.posx - temp_pos[0] <= GRASS_SIZE[0] and -GRASS_SIZE[0] <= each.posx - temp_pos[0] <= GRASS_SIZE[0]:
if -GRASS_SIZE[0] * 2.5 <= each.posx - temp_pos[0] <= GRASS_SIZE[0] and -GRASS_SIZE[1] * 2 <= each.posy - \
temp_pos[1] <= GRASS_SIZE[1]:
each.hurt(1800, 'boom')
class WallNut(Plant):
def __init__(self, move, pos=None):
Plant.__init__(self, move, 3, 3, 6, IMAGE_Wallnut, pos)
self.health = 4000
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
if self.health >= 8000 / 3:
window.blit(self.images[0], grow_pos)
elif self.health >= 4000 / 3:
window.blit(self.images[1], grow_pos)
else:
window.blit(self.images[2], grow_pos)
class PotatoMine(Plant):
def __init__(self, move, pos=None):
Plant.__init__(self, move, 4, 8, 10, IMAGE_Potatomine, pos)
self.initimage = IMAGE_Potatomine_init
self.blowimage = IMAGE_Potatomine_blow
self.ready = False
self.blowing = False
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
if self.ready:
zombie_to_blow = self.check_collision()
if zombie_to_blow is not None:
grow_pos_v = (grow_pos[0] - 30, grow_pos[1] - 25)
window.blit(self.blowimage, grow_pos_v)
self.ready = False
self.blowing = True
load_sound(23)
zombie_to_blow.hurt(1800, 'mine')
self.cur = 0
else:
window.blit(self.images[self.cur % self.index], grow_pos)
else:
if self.blowing:
grow_pos_v = (grow_pos[0] - 40, grow_pos[1] - 60)
window.blit(self.blowimage, grow_pos_v)
if self.cur == 8:
plant_list.remove(self)
remove_plant_in_GRASS(self)
else:
grow_pos_v = (grow_pos[0] + 20, grow_pos[1] + 10)
window.blit(self.initimage, grow_pos_v)
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if not self.blowing and not self.ready and self.cur == 15 * FPS / self.FPSDiv:
self.ready = True
def check_collision(self):
for each in zombie_list:
temp_posx = GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code]
if -90 <= each.posx - temp_posx <= -10 and each.grassy == self.grassy:
return each
return None
class DoublePea(Peashooter):
def __init__(self, move, pos=None):
Peashooter.__init__(self, move, pos)
self.code = 5
self.index = 15
self.images = IMAGE_Doublepea
self.alpha_image = self.images[0].copy()
self.alpha_image.set_alpha(100)
def next(self):
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
if (self.cur % self.index == 2 or self.cur % self.index == 8) and self.FPSVar == 0:
if discover_zombie(self.grassx, self.grassy):
return Bullet(self.grassx, self.grassy)
return None
class Chomper(Plant):
def __init__(self, move, pos=None):
Plant.__init__(self, move, 6, (13, 9, 6), 8, IMAGE_Chomper, pos)
self.attackimages = IMAGE_Chomper_attack
self.digestimages = IMAGE_Chomper_digest
self.chewingtime = 42 * FPS / self.FPSDiv
self.attack = False
self.ready = True
def draw_on_grass(self):
grow_pos = (GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code],
GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + GROW_PLUSY[self.code])
if not self.attack:
if self.ready:
window.blit(self.images[self.cur % self.index[0]], grow_pos)
if self.check_collision():
self.attack = True
self.cur = 0
else:
window.blit(self.digestimages[self.cur % self.index[2]], grow_pos)
if self.cur == self.chewingtime:
self.cur = 0
self.ready = True
else:
window.blit(self.attackimages[self.cur], grow_pos)
if self.cur == 6 and self.FPSVar == 0:
load_sound(24)
self.eat()
if self.cur == self.index[1] - 1:
self.cur = 0
self.attack = False
self.ready = False
self.FPSVar = (self.FPSVar + 1) % self.FPSDiv
if self.FPSVar == 0:
self.cur += 1
def check_collision(self):
for each in zombie_list:
temp_posx = GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code]
if -40 <= each.posx - temp_posx <= 80 and self.grassy == each.grassy:
return True
def eat(self):
for each in zombie_list:
temp_posx = GRASS_POS[0] + self.grassx * GRASS_SIZE[0] + GROW_PLUSX[self.code]
if -40 <= each.posx - temp_posx <= 80 and self.grassy == each.grassy:
each.hurt(1800, 'mine')
return
class Bullet(object):
def __init__(self, x, start_y):
self.grassy = start_y
self.posx = GRASS_POS[0] + x * GRASS_SIZE[0] + BULLET_START_POS[0]
self.posy = GRASS_POS[1] + start_y * GRASS_SIZE[1] + BULLET_START_POS[1]
self.speed = GRASS_SIZE[0] * 0.05
self.image_normal = IMAGE_Pea_bullet
self.image_explode = IMAGE_Pea_bullet_explode
def draw(self):
window.blit(self.image_normal, (self.posx, self.posy))
def move(self):
collision_flag = check_collision(self.posx, self.grassy, 20)
if self.posx <= GRASS_POS[0] + GRASS_NUM[0] * GRASS_SIZE[0] + 5:
if collision_flag is None:
self.posx += self.speed
else:
if collision_flag.code == 0:
load_sound(random.randint(7, 9))
elif collision_flag.code == 1:
load_sound(random.randint(26, 27))
elif collision_flag.code == 2:
load_sound(random.randint(28, 29))
window.blit(self.image_explode, (self.posx, self.posy))
bullets.remove(self)
else:
bullets.remove(self)
class MinigamesBullet(Bullet):
def __init__(self, x, start_y):
Bullet.__init__(self, x, start_y)
def move(self):
collision_flag = minigames_check_collision(self.posx, self.grassy, 20)
if self.posx <= GRASS_POS[0] + GRASS_NUM[0] * GRASS_SIZE[0] + 5:
if collision_flag is None:
self.posx += self.speed
else:
if collision_flag.code == 0:
load_sound(random.randint(7, 9))
elif collision_flag.code == 1:
load_sound(random.randint(26, 27))
elif collision_flag.code == 2:
load_sound(random.randint(28, 29))
window.blit(self.image_explode, (self.posx, self.posy))
bullets.remove(self)
else:
bullets.remove(self)
class Sun(object):
sun_size = (78, 78)
sun_point = 25
def __init__(self, grassx=None, grassy=None):
self.index = 22
self.cur = 0
self.stop_cur = 0
self.FPSVar = 0
self.images = IMAGE_Sun
self.produced = False
if grassx is None and grassy is None:
self.posx = random.randint(GRASS_POS[0] - 40, GRASS_POS[0] + GRASS_NUM[0] * GRASS_SIZE[0] - 40)
self.posy = -80
self.endy = random.randint(GRASS_POS[1], GRASS_POS[1] + GRASS_NUM[1] * GRASS_SIZE[1] - Sun.sun_size[1] + 20)
else:
self.posx = random.randint(GRASS_POS[0] + grassx * GRASS_SIZE[0] - 40,
GRASS_POS[0] + (grassx + 1) * GRASS_SIZE[0] - 40)
self.posy = GRASS_POS[1] + grassy * GRASS_SIZE[1] + 10
self.endy = random.randint(GRASS_POS[1] + grassy * GRASS_SIZE[1] + 30,
GRASS_POS[1] + (grassy + 1) * GRASS_SIZE[1] - 50)
self.produced = True
self.speed = 1
def fall(self):
if self.posy >= self.endy:
self.speed = 0
return
if self.produced:
return
self.posy += self.speed
def draw(self):
if self.produced:
highlight = self.images[0]
highlight.set_alpha(int(255 * self.cur / 15))
window.blit(highlight, (self.posx, self.posy))
else:
window.blit(self.images[self.cur % self.index], (self.posx, self.posy))
self.FPSVar = (self.FPSVar + 1) % 3
if self.FPSVar == 0:
self.cur += 1
if self.cur == 15 and self.produced:
self.produced = False
if self.speed != 0:
self.stop_cur = self.cur
if self.cur - self.stop_cur == 160:
sun_falling.remove(self)
class SunCollecting(object):
endx = 20
endy = 10
collect_time = FPS
def __init__(self, initpos):
self.posx = initpos[0]
self.posy = initpos[1]
self.image = IMAGE_Sun[10]
delta_x = initpos[0] + Sun.sun_size[0] // 2 - SunCollecting.endx
delta_y = initpos[1] + Sun.sun_size[1] // 2 - SunCollecting.endy
temp_total = (delta_x ** 2 + delta_y ** 2) ** 0.5
temp_speed = temp_total / SunCollecting.collect_time * 2
temp_acc = temp_speed ** 2 / (2 * temp_total)
self.speed_x = temp_speed * delta_x / temp_total
self.speed_y = temp_speed * delta_y / temp_total
self.acc_x = temp_acc * delta_x / temp_total
self.acc_y = temp_acc * delta_y / temp_total
def move(self):
self.posx -= int(self.speed_x)
self.speed_x -= self.acc_x
self.posy -= int(self.speed_y)
self.speed_y -= self.acc_y
if self.speed_x <= 0.5 and self.speed_y <= 0.5:
sun_collecting.remove(self)
def draw(self):
window.blit(self.image, (self.posx, self.posy))
class Brain(object):
def __init__(self, grassy):
self.code = -1
self.grassy = grassy
self.image = IMAGE_Brain
self.health = 300
def draw_on_grass(self):
window.blit(self.image, (5, GRASS_POS[1] + self.grassy * GRASS_SIZE[1] + 42))
def hurt(self, num):
self.health -= num
if self.health <= 0:
load_sound(30)
brain_list.remove(self.grassy)
plant_list.remove(self)
if len(brain_list) == 0:
global trophy
trophy = Trophy(GRASS_POS[0], GRASS_POS[1] + GRASS_SIZE[1] * self.grassy)
class Lawnmower(object):
cross_time = 4 * FPS
readyx = -26
endx = WINDOW_WIDTH
def __init__(self, posx, grassy):
self.posx = posx
self.posy = GRASS_POS[1] + grassy * GRASS_SIZE[1] + 35
self.grassy = grassy
self.ready = False
self.set_off = False
self.speed = (Lawnmower.endx + 26) / Lawnmower.cross_time
def draw(self):
window.blit(IMAGE_Lawnmower, (self.posx, self.posy))
def move(self):
if not self.ready:
self.posx += self.speed
if self.posx >= Lawnmower.readyx:
self.ready = True
elif not self.set_off:
collision_flag = check_collision(self.posx, self.grassy, 0)
if collision_flag is not None:
load_sound(19)
self.set_off = True
else:
self.posx += self.speed
check_collision(self.posx, self.grassy, 10000)
if self.posx >= Lawnmower.endx:
lawnmower_list.remove(self)
# 占用的草地
class PlantedGrass(object):
def __init__(self, pos, code):
self.code = code
self.grassx = (pos[0] - GRASS_POS[0]) // GRASS_SIZE[0]
self.grassy = (pos[1] - GRASS_POS[1]) // GRASS_SIZE[1]
# 选卡动画
class MovingCard(object):
def __init__(self, image, startpos, endpos, code):
self.image = image
self.endpos = endpos
self.posx = startpos[0]
self.posy = startpos[1]
self.movingtime = 0.1 * FPS
self.code = code
delta_x = endpos[0] - startpos[0]
delta_y = endpos[1] - startpos[1]
total = (delta_x ** 2 + delta_y ** 2) ** 0.5
speed = total / self.movingtime
self.speed_x = speed * delta_x / total
self.speed_y = speed * delta_y / total
def draw(self):
window.blit(self.image, (self.posx, self.posy))
def move(self):
if -3 <= self.posx - self.endpos[0] <= 3 and -3 <= self.posy - self.endpos[1] <= 3:
moving_card_list.remove(self)
self.posx += self.speed_x
self.posy += self.speed_y
class FlagMeter(object):
def __init__(self):
self.cur = 0
self.FPSVar = 0
self.images = IMAGE_Flagmeter
self.index = 37
def draw(self):
window.blit(self.images[self.cur], (601, 561))
if self.cur == 36:
return
self.FPSVar = (self.FPSVar + 1) % 300
if self.FPSVar == 0:
self.cur += 1
def show_text(textstr1, size, color, pos1, textstr2=None, pos2=None):
# file = pygame.font.SysFont(font_name, size)
file = pygame.font.Font(FONT, size)
text1 = file.render(textstr1, True, color)
window.blit(text1, pos1)
if textstr2 is not None:
text2 = file.render(textstr2, True, color)
window.blit(text2, pos2)
# 加载素材
def load_peashooter():
temp_pea = []
for i in range(13):
file = pygame.image.load('images/Peashooter/Peashooter_{0}.png'.format(i)).convert_alpha()
temp_pea.append(file)
return temp_pea
def load_sunflower():
temp_flower = []
for i in range(18):
file = pygame.image.load('images/Sunflower/Sunflower_{0}.png'.format(i)).convert_alpha()
temp_flower.append(file)
return temp_flower
def load_cherrybomb():
temp_bomb = []
for i in range(1, 12):
file = pygame.image.load('images/CherryBomb/CherryBomb-{0}.png'.format(i)).convert_alpha()
temp_bomb.append(file)
return temp_bomb
def load_wallnut():
temp_wallnut = []
for i in range(3):
file = pygame.image.load('images/WallNut/Wallnut_{0}.png'.format(i)).convert_alpha()
file = pygame.transform.rotozoom(file, 0, 0.8)
temp_wallnut.append(file)
return temp_wallnut
def load_potatomine():
temp_mine = []
for i in range(1, 9):
file = pygame.image.load('images/PotatoMine/PotatoMine/PotatoMine-{0}.png'.format(i)).convert_alpha()
temp_mine.append(file)
return temp_mine
def load_chomper():
chomper = []
for i in range(13):
file = pygame.image.load('images/Chomper/Chomper/Chomper_{0}.png'.format(i)).convert_alpha()
chomper.append(file)
return chomper
def load_chomper_attack():
chomper = []
for i in range(9):
file = pygame.image.load('images/Chomper/ChomperAttack/ChomperAttack_{0}.png'.format(i)).convert_alpha()
chomper.append(file)
return chomper
def load_chomper_digest():
chomper = []
for i in range(6):
file = pygame.image.load('images/Chomper/ChomperDigest/ChomperDigest_{0}.png'.format(i)).convert_alpha()
chomper.append(file)
return chomper
def load_doublepea():
doublepea = []
for i in range(15):
file = pygame.image.load('images/RepeaterPea/RepeaterPea_{0}.png'.format(i)).convert_alpha()
doublepea.append(file)
return doublepea
def load_sun():
temp_sun = []
for i in range(22):
file = pygame.image.load('images/Sun/Sun_{0}.png'.format(i)).convert_alpha()
temp_sun.append(file)
return temp_sun
def load_normal_zombie():
temp_zombie = []
for i in range(22):
file = pygame.image.load('images/NormalZombie/Zombie/Zombie_{0}.png'.format(i)).convert_alpha()
temp_zombie.append(file)
return temp_zombie
def load_eating_zombie():
temp_zombie = []
for i in range(11):
file = pygame.image.load('images/NormalZombie/ZombieAttack/ZombieAttack_{0}.png'.format(i)).convert_alpha()
temp_zombie.append(file)
return temp_zombie
def load_conehead_zombie():
temp_zombie = []
for i in range(22):
file = pygame.image.load(
'images/ConeheadZombie/ConeheadZombie/ConeheadZombie_{0}.png'.format(i)).convert_alpha()
temp_zombie.append(file)
return temp_zombie
def load_eating_conehead():
temp_zombie = []
for i in range(11):
file = pygame.image.load(
'images/ConeheadZombie/ConeheadZombieAttack/ConeheadZombieAttack_{0}.png'.format(i)).convert_alpha()
temp_zombie.append(file)
return temp_zombie
def load_buckethead_zombie():
temp_zombie = []
for i in range(22):
file = pygame.image.load(
'images/BucketheadZombie/BucketheadZombie/BucketheadZombie_{0}.png'.format(i)).convert_alpha()
temp_zombie.append(file)
return temp_zombie
def load_eating_buckethead():
temp_zombie = []
for i in range(11):
file = pygame.image.load(
'images/BucketheadZombie/BucketheadZombieAttack/BucketheadZombieAttack_{0}.png'.format(i)).convert_alpha()
temp_zombie.append(file)
return temp_zombie
def load_head():
temp_head = []
for i in range(17):
file = pygame.image.load('images/NormalZombie/ZombieHead/ZombieHead_{0}.png'.format(i)).convert_alpha()
temp_head.append(file)
return temp_head
def load_body():
temp_body = []
for i in range(17):
file = pygame.image.load('images/NormalZombie/ZombieDie/ZombieDie_{0}.png'.format(i)).convert_alpha()
temp_body.append(file)
return temp_body
def load_body_walking():
temp_body = []
for i in range(18):
file = pygame.image.load('images/NormalZombie/ZombieLostHead/ZombieLostHead_{0}.png'.format(i)).convert_alpha()
temp_body.append(file)
return temp_body
def load_body_eating():
temp_body = []
for i in range(11):
file = pygame.image.load(
'images/NormalZombie/ZombieLostHeadAttack/ZombieLostHeadAttack_{0}.png'.format(i)).convert_alpha()
temp_body.append(file)
return temp_body
def load_booming_zombie():
temp_zombie = []
for i in range(20):
file = pygame.image.load('images/NormalZombie/BoomDie/BoomDie_{0}.png'.format(i)).convert_alpha()
temp_zombie.append(file)
return temp_zombie
def load_flagmeter():
temp = []
for i in range(37):
file = pygame.image.load('images/FlagMeter/FlagMeter_{0}.png'.format(i)).convert_alpha()
temp.append(file)
return temp
def load_trophy():
trophy_file = []
for i in range(9):
file = pygame.image.load('images/Trophy/trophy_{0}.png'.format(i)).convert_alpha()
trophy_file.append(file)
return trophy_file
def load_images():
global IMAGE_Start_menu # (384, 72)
global IMAGE_Adventure_button
global IMAGE_Adventure_button_alpha
global IMAGE_Minigames_button
global IMAGE_Minigames_button_alpha
global IMAGE_Minigames_back
global IMAGE_Minigames_window
global IMAGE_Minigames_window_alpha
global IMAGE_Minigames_imzombie
global IMAGE_Minigames_back_button
global IMAGE_Minigames_back_button_alpha
global IMAGE_Background_night
global IMAGE_Help_button
global IMAGE_Help_button_alpha
global IMAGE_Quit_button
global IMAGE_Quit_button_alpha
global IMAGE_Options_button
global IMAGE_Options_button_alpha
global IMAGE_Help
global IMAGE_Back_button_alpha
global IMAGE_Background
global IMAGE_Background_full
global IMAGE_Choose_seeds
global IMAGE_Ready_button
global IMAGE_Start_planting
global IMAGE_Sun_count
global IMAGE_Pause_button_left
global IMAGE_Pause_button_middle
global IMAGE_Pause_button_right
global IMAGE_Pause_button_alpha
global IMAGE_Volume_knob
global IMAGE_Volume
global IMAGE_Pause_screen
global IMAGE_Long_button_alpha
global IMAGE_Back_to_game
global IMAGE_Back_to_game_alpha
global IMAGE_Peashooter
global IMAGE_Card_peashooter
global IMAGE_Card_peashooter_alpha
global IMAGE_Sun
global IMAGE_Lawnmower
global IMAGE_Sunflower
global IMAGE_Card_sunflower
global IMAGE_Card_sunflower_alpha
global IMAGE_Pea_bullet
global IMAGE_Pea_bullet_explode
global IMAGE_Cherrybomb
global IMAGE_Card_cherrybomb
global IMAGE_Card_cherrybomb_alpha
global IMAGE_Wallnut
global IMAGE_Card_wallnut
global IMAGE_Card_wallnut_alpha
global IMAGE_Potatomine
global IMAGE_Potatomine_init
global IMAGE_Potatomine_blow
global IMAGE_Card_potatomine
global IMAGE_Card_potatomine_alpha
global IMAGE_Chomper
global IMAGE_Chomper_attack
global IMAGE_Chomper_digest
global IMAGE_Card_chomper
global IMAGE_Card_chomper_alpha
global IMAGE_Doublepea
global IMAGE_Card_doublepea
global IMAGE_Card_doublepea_alpha
global IMAGE_Normal_zombie
global IMAGE_Conehead_zombie
global IMAGE_Buckethead_zombie
global IMAGE_Zombie_head
global IMAGE_Zombie_body
global IMAGE_Zombie_body_walking
global IMAGE_Zombie_body_eating
global IMAGE_Shovel
global IMAGE_Shovel_bank
global IMAGE_Flagmeter
global IMAGE_Huge_wave
global IMAGE_Final_wave
global IMAGE_Lost
global IMAGE_Dialog
global card_image_list
global IMAGE_Trophy
global IMAGE_Trophy_get
global IMAGE_Card_normal_zombie
global IMAGE_Card_normal_zombie_alpha
global IMAGE_Card_cone_zombie
global IMAGE_Card_cone_zombie_alpha
global IMAGE_Card_bucket_zombie
global IMAGE_Card_bucket_zombie_alpha
global IMAGE_Zombie_line
global IMAGE_Brain
IMAGE_Start_menu = pygame.image.load('images/MainMenu.png').convert()
IMAGE_Adventure_button = pygame.image.load('images/Buttons/SelectorScreen_Adventure_button.png').convert_alpha()
IMAGE_Adventure_button_alpha = pygame.image.load(
'images/Buttons/SelectorScreen_Adventure_highlight.png').convert_alpha()
IMAGE_Minigames_button = pygame.image.load('images/Buttons/SelectorScreen_Survival_button.png').convert_alpha()
IMAGE_Minigames_button_alpha = pygame.image.load('images/Buttons/SelectorScreen_Survival_highlight.png').convert_alpha()
IMAGE_Minigames_back = pygame.image.load('images/Buttons/Challenge_Background.jpg').convert_alpha()
IMAGE_Minigames_window = pygame.image.load('images/Buttons/Challenge_Window.png').convert_alpha()
IMAGE_Minigames_window_alpha = pygame.image.load('images/Buttons/Challenge_Window_Highlight.png').convert_alpha()
IMAGE_Minigames_imzombie = pygame.image.load('images/Buttons/minigames_imzombie.png').convert_alpha()
IMAGE_Minigames_back_button = pygame.image.load('images/Buttons/Almanac_IndexButton.png').convert_alpha()
IMAGE_Minigames_back_button_alpha = pygame.image.load('images/Buttons/Almanac_IndexButtonHighlight.png').convert_alpha()
IMAGE_Background_night = pygame.image.load('images/Background_3.png').convert()
IMAGE_Help_button = pygame.image.load('images/Buttons/SelectorScreen_Help1.png').convert_alpha()
IMAGE_Help_button_alpha = pygame.image.load('images/Buttons/SelectorScreen_Help2.png').convert_alpha()
IMAGE_Quit_button = pygame.image.load('images/Buttons/SelectorScreen_Quit1.png').convert_alpha()
IMAGE_Quit_button_alpha = pygame.image.load('images/Buttons/SelectorScreen_Quit2.png').convert_alpha()
IMAGE_Options_button = pygame.image.load('images/Buttons/SelectorScreen_Options1.png').convert_alpha()
IMAGE_Options_button_alpha = pygame.image.load('images/Buttons/SelectorScreen_Options2.png').convert_alpha()
IMAGE_Help = pygame.image.load('images/Help.png').convert()
IMAGE_Back_button_alpha = pygame.image.load('images/Buttons/BackButton.png').convert_alpha()
IMAGE_Background = pygame.image.load('images/Background_0.png').convert()
IMAGE_Background_full = pygame.image.load('images/Backgroundfull.png').convert()
IMAGE_Choose_seeds = pygame.image.load('images/SeedChooser_Background.png').convert_alpha()
IMAGE_Ready_button = [pygame.image.load('images/Buttons/SeedChooser_Button_Disabled.png').convert_alpha(),
pygame.image.load('images/Buttons/SeedChooser_Button.png').convert_alpha(),
pygame.image.load('images/Buttons/SeedChooser_Button_Glow.png').convert_alpha()]
for i in range(3):
IMAGE_Ready_button[i] = pygame.transform.rotozoom(IMAGE_Ready_button[i], 0, 2)
IMAGE_Start_planting = [pygame.image.load('images/StartReady.png').convert_alpha(),
pygame.image.load('images/StartSet.png').convert_alpha(),
pygame.image.load('images/StartPlant.png').convert_alpha()]
IMAGE_Sun_count = pygame.image.load('images/sun_count.png').convert_alpha() # 76x87
IMAGE_Pause_button_left = pygame.image.load('images/Buttons/button_left.png').convert_alpha()
IMAGE_Pause_button_middle = pygame.image.load('images/Buttons/button_middle.png').convert_alpha()
IMAGE_Pause_button_right = pygame.image.load('images/Buttons/button_right.png').convert_alpha()
IMAGE_Pause_button_alpha = pygame.image.load('images/Buttons/button.png').convert_alpha()
IMAGE_Volume = pygame.image.load('images/Buttons/options_sliderslot.png').convert_alpha()
IMAGE_Volume_knob = pygame.image.load('images/Buttons/options_sliderknob2.png').convert_alpha()
IMAGE_Pause_screen = pygame.image.load('images/Buttons/PauseScreen.png').convert_alpha()
IMAGE_Long_button_alpha = pygame.image.load('images/Buttons/long_button2.png').convert_alpha()
IMAGE_Back_to_game = pygame.image.load('images/Buttons/options_backtogamebutton0.png').convert_alpha()
IMAGE_Back_to_game_alpha = pygame.image.load('images/Buttons/options_backtogamebutton2.png').convert_alpha()
IMAGE_Peashooter = load_peashooter()
IMAGE_Card_peashooter = pygame.image.load('images/Cards/card_peashooter.png').convert_alpha() # 65x90
IMAGE_Card_peashooter_alpha = pygame.image.load('images/Cards/card_peashooter_alpha.png').convert_alpha()
IMAGE_Sun = load_sun()
IMAGE_Lawnmower = pygame.image.load('images/lawnmower.png').convert_alpha()
IMAGE_Sunflower = load_sunflower()
IMAGE_Card_sunflower = pygame.image.load('images/Cards/card_sunflower.png').convert_alpha()
IMAGE_Card_sunflower_alpha = pygame.image.load('images/Cards/card_sunflower_alpha.png').convert_alpha()
IMAGE_Pea_bullet = pygame.image.load('images/Peashooter/PeaNormal.png').convert_alpha()
IMAGE_Pea_bullet_explode = pygame.image.load('images/Peashooter/PeaNormalExplode_0.png').convert_alpha()
IMAGE_Cherrybomb = load_cherrybomb()
IMAGE_Card_cherrybomb = pygame.image.load('images/Cards/card_cherrybomb.png').convert_alpha()
IMAGE_Card_cherrybomb_alpha = pygame.image.load('images/Cards/card_cherrybomb_alpha.png').convert_alpha()
IMAGE_Wallnut = load_wallnut()
IMAGE_Card_wallnut = pygame.image.load('images/Cards/card_wallnut.png').convert_alpha()
IMAGE_Card_wallnut_alpha = pygame.image.load('images/Cards/card_wallnut_alpha.png').convert_alpha()
IMAGE_Potatomine = load_potatomine()
IMAGE_Potatomine_init = pygame.image.load('images/PotatoMine/PotatoMineInit.png').convert_alpha()
IMAGE_Potatomine_blow = pygame.image.load('images/PotatoMine/PotatoMine_mashed.png').convert_alpha()
IMAGE_Potatomine_blow = pygame.transform.rotozoom(IMAGE_Potatomine_blow, 0, 1.2)
IMAGE_Card_potatomine = pygame.image.load('images/Cards/card_potatomine.png').convert_alpha()
IMAGE_Card_potatomine_alpha = pygame.image.load('images/Cards/card_potatomine_alpha.png').convert_alpha()
IMAGE_Chomper = load_chomper()
IMAGE_Chomper_attack = load_chomper_attack()
IMAGE_Chomper_digest = load_chomper_digest()
IMAGE_Card_chomper = pygame.image.load('images/Cards/card_chomper.png').convert_alpha()
IMAGE_Card_chomper_alpha = pygame.image.load('images/Cards/card_chomper_alpha.png').convert_alpha()
IMAGE_Doublepea = load_doublepea()
IMAGE_Card_doublepea = pygame.image.load('images/Cards/card_doublepea.png').convert_alpha()
IMAGE_Card_doublepea_alpha = pygame.image.load('images/Cards/card_doublepea_alpha.png').convert_alpha()
IMAGE_Normal_zombie = [load_normal_zombie(), load_eating_zombie(), load_booming_zombie()]
IMAGE_Conehead_zombie = [load_conehead_zombie(), load_eating_conehead(), load_booming_zombie()]
IMAGE_Buckethead_zombie = [load_buckethead_zombie(), load_eating_buckethead(), load_booming_zombie()]
IMAGE_Zombie_head = load_head()
IMAGE_Zombie_body = load_body()
IMAGE_Zombie_body_walking = load_body_walking()
IMAGE_Zombie_body_eating = load_body_eating()
IMAGE_Shovel = pygame.image.load('images/Shovel.png').convert_alpha()
IMAGE_Shovel_bank = pygame.image.load('images/ShovelBank.png').convert_alpha()
IMAGE_Flagmeter = load_flagmeter()
IMAGE_Huge_wave = pygame.image.load('images/APPROACHING.png').convert_alpha()
IMAGE_Final_wave = pygame.image.load('images/FinalWave.png').convert_alpha()
IMAGE_Lost = pygame.image.load('images/Lost.png').convert_alpha()
IMAGE_Dialog = pygame.image.load('images/Buttons/Dialog.png').convert_alpha()
card_image_list = [IMAGE_Card_peashooter, IMAGE_Card_sunflower, IMAGE_Card_cherrybomb,
IMAGE_Card_wallnut, IMAGE_Card_potatomine, IMAGE_Card_doublepea, IMAGE_Card_chomper]
IMAGE_Trophy = load_trophy()
IMAGE_Trophy_get = pygame.image.load('images/trophy.png').convert_alpha()
IMAGE_Card_normal_zombie = pygame.image.load('images/Cards/card_normal_zombie.png').convert()
IMAGE_Card_normal_zombie_alpha = pygame.image.load('images/Cards/card_normal_zombie_alpha.png').convert()
IMAGE_Card_cone_zombie = pygame.image.load('images/Cards/card_cone_zombie.png').convert()
IMAGE_Card_cone_zombie_alpha = pygame.image.load('images/Cards/card_cone_zombie_alpha.png').convert()
IMAGE_Card_bucket_zombie = pygame.image.load('images/Cards/card_bucket_zombie.png').convert()
IMAGE_Card_bucket_zombie_alpha = pygame.image.load('images/Cards/card_bucket_zombie_alpha.png').convert()
IMAGE_Zombie_line = pygame.image.load('images/Wallnut_bowlingstripe.png').convert_alpha()
IMAGE_Brain = pygame.image.load('images/brain.png').convert_alpha()
def load_music(num, times, paused=False, loading_flag=False):
# print(MUSIC_POS)
if loading_flag:
pygame.mixer.music.load('music/start0.mp3')
pygame.mixer.music.load('music/grasswalk0.mp3')
pygame.mixer.music.load('music/Choose your seeds.mp3')
pygame.mixer.music.load('music/mountains.mp3')
return
if num == 0:
music = 'music/start0.mp3'
elif num == 1:
music = 'music/grasswalk0.mp3'
elif num == 2:
music = 'music/Choose your seeds.mp3'
elif num == 4:
music = 'music/mountains.mp3'
if pygame.mixer.music.get_busy():
pygame.mixer.music.stop()
if paused:
if num == 0:
music = 'music/start0.mp3'
elif num == 1:
music = 'music/grasswalk0.mp3'
elif num == 2:
music = 'music/Choose your seeds.mp3'
elif num == 4:
music = 'music/mountains.mp3'
pygame.mixer.music.load(music)
pygame.mixer.music.set_volume(MUSIC_VOLUME)
if paused:
pygame.mixer.music.play(times, MUSIC_POS)
else:
pygame.mixer.music.play(times)
def load_sound(num, loading_flag=False):
file = ['sound/plant.ogg', 'sound/chomp0.ogg', 'sound/chomp1.ogg', 'sound/chomp2.ogg', 'sound/seedlift.ogg',
'sound/shovel.ogg', 'sound/tap.ogg', 'sound/splat0.ogg', 'sound/splat1.ogg', 'sound/splat2.ogg',
'sound/limbs_pop.ogg', 'sound/zombie_falling_1.ogg', 'sound/zombie_falling_2.ogg', 'sound/tap2.ogg',
'sound/buzzer.ogg', 'sound/bleep.ogg', 'sound/paper.ogg', 'sound/gravebutton.ogg', 'sound/pause.ogg',
'sound/lawnmower.ogg', 'sound/scream.ogg', 'sound/losemusic.ogg', 'sound/cherrybomb.ogg',
'sound/potato_mine.ogg', 'sound/bigchomp.ogg', 'sound/frozen.ogg', 'sound/plastichit.ogg',
'sound/plastichit2.ogg', 'sound/shieldhit.ogg', 'sound/shieldhit2.ogg', 'sound/gulp.ogg',
'sound/readysetplant.ogg', 'sound/finalwave.ogg', 'sound/hugewave.ogg', 'sound/awooga.ogg',
'sound/winmusic.ogg', 'sound/buttonclick.ogg', 'sound/siren.ogg']
if loading_flag:
pygame.mixer.Sound(file[num])
return
sound = pygame.mixer.Sound(file[num])
sound.set_volume(SOUND_VOLUME)
sound.play()
# 设置部件
def set_background(num, pos=None):
if num == 0:
window.blit(IMAGE_Start_menu, POS)
return
if num == 1:
window.blit(IMAGE_Background, POS)
return
if num == 2:
window.blit(IMAGE_Background_full, pos)
return
if num == 3:
window.blit(IMAGE_Background_night, POS)
return
def set_window(title, size):
global window
window = pygame.display.set_mode(size)
pygame.display.set_caption(title)
def set_shovel(pos=(GRASS_POS[0] + 7 * GRASS_SIZE[0], 0)):
window.blit(IMAGE_Shovel_bank, pos)
def set_sun(sun, pos=SUN_POS):
text_pos = (47 - len(sun) * 6, 55)
if pos != SUN_POS:
text_pos = (text_pos[0] - SUN_POS[0] + pos[0], text_pos[1] + pos[1] - SUN_POS[1])
sun_box = Button(pos, IMAGE_Sun_count)
sun_box.draw()
show_text(sun, 25, (0, 0, 0), text_pos)
def set_minigames_card(zombie, pos, type=None):
if zombie == 0:
if type is None:
window.blit(IMAGE_Card_normal_zombie, pos)
return
window.blit(IMAGE_Card_normal_zombie_alpha, pos)
return
if zombie == 1:
if type is None:
window.blit(IMAGE_Card_cone_zombie, pos)
return
window.blit(IMAGE_Card_cone_zombie_alpha, pos)
return
if zombie == 2:
if type is None:
window.blit(IMAGE_Card_bucket_zombie, pos)
return
window.blit(IMAGE_Card_bucket_zombie_alpha, pos)
return
def set_cards(plant, pos, type=None):
if plant == 0:
if type is None:
window.blit(IMAGE_Card_peashooter, pos)
return
window.blit(IMAGE_Card_peashooter_alpha, pos)
return
if plant == 1:
if type is None:
window.blit(IMAGE_Card_sunflower, pos)
return
window.blit(IMAGE_Card_sunflower_alpha, pos)
return
if plant == 2:
if type is None:
window.blit(IMAGE_Card_cherrybomb, pos)
return
window.blit(IMAGE_Card_cherrybomb_alpha, pos)
return
if plant == 3:
if type is None:
window.blit(IMAGE_Card_wallnut, pos)
return
window.blit(IMAGE_Card_wallnut_alpha, pos)
return
if plant == 4:
if type is None:
window.blit(IMAGE_Card_potatomine, pos)
return
window.blit(IMAGE_Card_potatomine_alpha, pos)
return
if plant == 5:
if type is None:
window.blit(IMAGE_Card_doublepea, pos)
return
window.blit(IMAGE_Card_doublepea_alpha, pos)
return
if plant == 6:
if type is None:
window.blit(IMAGE_Card_chomper, pos)
return
window.blit(IMAGE_Card_chomper_alpha, pos)
return
def set_frozen_time(code, last_time, cur_time, pos):
size = CARD_SIZE[1] * (last_time + FROZEN_TIME[code] * FPS - cur_time) / (FROZEN_TIME[code] * FPS)
if size > 0:
temp_card = pygame.Surface((CARD_SIZE[0], size))
temp_card.fill((0, 0, 0))
temp_card.set_alpha(100)
window.blit(temp_card, pos)
def set_pause_button(status, pos, lost=False):
if on_pause(pos) and status == 2:
window.blit(IMAGE_Pause_button_alpha, PAUSE_BUTTON_ALPHA)
else:
window.blit(IMAGE_Pause_button_left, PAUSE_BUTTON[0])
window.blit(IMAGE_Pause_button_middle, PAUSE_BUTTON[1])
window.blit(IMAGE_Pause_button_right, PAUSE_BUTTON[2])
if lost:
text_pos1 = (712, 2)
text_pos2 = (715, 1)
text = '主菜单'
else:
text_pos1 = (721, 2)
text_pos2 = (724, 1)
text = '菜单'
if on_pause(pos):
if status == 2:
show_text(text, 18, FONT_COLOR[1], text_pos2)
else:
show_text(text, 18, FONT_COLOR[1], text_pos1)
else:
show_text(text, 18, FONT_COLOR[0], text_pos1)
def set_back_to_game(clicked, pos):
if 242 <= pos[0] <= 556 and 452 <= pos[1] <= 520:
if clicked == 1:
window.blit(IMAGE_Back_to_game_alpha, BACK_TO_GAME_ALPHA)
show_text('返回游戏', 42, FONT_COLOR[1], (316, 462))
else:
window.blit(IMAGE_Back_to_game, BACK_TO_GAME)
show_text('返回游戏', 42, FONT_COLOR[1], (316, 460))
else:
window.blit(IMAGE_Back_to_game, BACK_TO_GAME)
show_text('返回游戏', 42, FONT_COLOR[0], (316, 460))
def set_option_up(clicked, pos):
if PAUSE_OPTION_UP[0][0] <= pos[0] <= PAUSE_OPTION_UP[4][0] + 35 and PAUSE_OPTION_UP[0][1] <= pos[1] <= \
PAUSE_OPTION_UP[0][1] + 46:
if clicked == 3:
window.blit(IMAGE_Long_button_alpha, PAUSE_OPTION_UP_ALPHA)
show_text('主菜单', 18, FONT_COLOR[1], (PAUSE_OPTION_UP[0][0] + 76, PAUSE_OPTION_UP[0][1] + 12))
else:
window.blit(IMAGE_Pause_button_left, PAUSE_OPTION_UP[0])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_UP[1])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_UP[2])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_UP[3])
window.blit(IMAGE_Pause_button_right, PAUSE_OPTION_UP[4])
show_text('主菜单', 18, FONT_COLOR[1], (PAUSE_OPTION_UP[0][0] + 76, PAUSE_OPTION_UP[0][1] + 10))
else:
window.blit(IMAGE_Pause_button_left, PAUSE_OPTION_UP[0])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_UP[1])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_UP[2])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_UP[3])
window.blit(IMAGE_Pause_button_right, PAUSE_OPTION_UP[4])
show_text('主菜单', 18, FONT_COLOR[0], (PAUSE_OPTION_UP[0][0] + 76, PAUSE_OPTION_UP[0][1] + 10))
def set_option_down(clicked, pos):
if PAUSE_OPTION_DOWN[0][0] <= pos[0] <= PAUSE_OPTION_DOWN[4][0] + 35 and PAUSE_OPTION_DOWN[0][1] <= pos[1] <= \
PAUSE_OPTION_DOWN[0][1] + 46:
if clicked == 2:
window.blit(IMAGE_Long_button_alpha, PAUSE_OPTION_DOWN_ALPHA)
show_text('退出游戏', 18, FONT_COLOR[1], (PAUSE_OPTION_DOWN[0][0] + 67, PAUSE_OPTION_DOWN[0][1] + 12))
else:
window.blit(IMAGE_Pause_button_left, PAUSE_OPTION_DOWN[0])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_DOWN[1])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_DOWN[2])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_DOWN[3])
window.blit(IMAGE_Pause_button_right, PAUSE_OPTION_DOWN[4])
show_text('退出游戏', 18, FONT_COLOR[1], (PAUSE_OPTION_DOWN[0][0] + 67, PAUSE_OPTION_DOWN[0][1] + 10))
else:
window.blit(IMAGE_Pause_button_left, PAUSE_OPTION_DOWN[0])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_DOWN[1])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_DOWN[2])
window.blit(IMAGE_Pause_button_middle, PAUSE_OPTION_DOWN[3])
window.blit(IMAGE_Pause_button_right, PAUSE_OPTION_DOWN[4])
show_text('退出游戏', 18, FONT_COLOR[0], (PAUSE_OPTION_DOWN[0][0] + 67, PAUSE_OPTION_DOWN[0][1] + 10))
def set_start_again(clicked, pos):
text_pos1 = (364, 356)
text_pos2 = (365, 359)
if LOST_RESTART[0][0] <= pos[0] <= LOST_RESTART[4][0] + 46 and LOST_RESTART[0][1] <= pos[1] <= LOST_RESTART[0][
1] + 46:
if clicked == 1:
window.blit(IMAGE_Long_button_alpha, LOST_RESTART_ALPHA)
show_text('重新尝试', 18, FONT_COLOR[1], text_pos2)
else:
window.blit(IMAGE_Pause_button_left, LOST_RESTART[0])
window.blit(IMAGE_Pause_button_middle, LOST_RESTART[1])
window.blit(IMAGE_Pause_button_middle, LOST_RESTART[2])
window.blit(IMAGE_Pause_button_middle, LOST_RESTART[3])
window.blit(IMAGE_Pause_button_right, LOST_RESTART[4])
show_text('重新尝试', 18, FONT_COLOR[1], text_pos1)
else:
window.blit(IMAGE_Pause_button_left, LOST_RESTART[0])
window.blit(IMAGE_Pause_button_middle, LOST_RESTART[1])
window.blit(IMAGE_Pause_button_middle, LOST_RESTART[2])
window.blit(IMAGE_Pause_button_middle, LOST_RESTART[3])
window.blit(IMAGE_Pause_button_right, LOST_RESTART[4])
show_text('重新尝试', 18, FONT_COLOR[0], text_pos1)
def on_card(pos):
if pos[0] < CARD_POS[0] or pos[0] > CARD_POS[0] + CARD_SIZE[0] * len(card_list):
return -1
if pos[1] < CARD_POS[1] or pos[1] > CARD_POS[1] + CARD_SIZE[1]:
return -1
return (pos[0] - CARD_POS[0]) // CARD_SIZE[0]
def minigames_on_grass(pos):
if GRASS_POS[0] + 4 * GRASS_SIZE[0] <= pos[0] <= GRASS_POS[0] + GRASS_NUM[0] * GRASS_SIZE[0]:
if GRASS_POS[1] <= pos[1] <= GRASS_POS[1] + GRASS_NUM[1] * GRASS_SIZE[1]:
return True
return False
def on_grass(pos):
if GRASS_POS[0] <= pos[0] <= GRASS_POS[0] + GRASS_NUM[0] * GRASS_SIZE[0]:
if GRASS_POS[1] <= pos[1] <= GRASS_POS[1] + GRASS_NUM[1] * GRASS_SIZE[1]:
return True
return False
def on_adventure_button(pos):
if 390 <= pos[0] <= 648 and 102 <= pos[1] <= 198:
return True
if 606 <= pos[0] <= 743 and 123 <= pos[1] <= 215:
return True
return False
def on_minigames_button(pos):
if 413 <= pos[0] <= 558 and 193 <= pos[1] <= 251:
return True
if 490 <= pos[0] <= 568 and 203 <= pos[1] <= 261:
return True
if 561 <= pos[0] <= 625 and 212 <= pos[1] <= 274:
return True
if 625 <= pos[0] <= 707 and 224 <= pos[1] <= 292:
return True
return False
def on_help_button(pos):
if 655 <= pos[0] <= 697 and 530 <= pos[1] <= 552:
return True
return False
def on_quit_button(pos):
if 731 <= pos[0] <= 776 and 513 <= pos[1] <= 537:
return True
return False
def on_options_button(pos):
if 572 <= pos[0] <= 628 and 492 <= pos[1] <= 517:
return True
return False
def on_shovel(pos):
if GRASS_POS[0] + 7 * GRASS_SIZE[0] <= pos[0] <= GRASS_POS[0] + 8 * GRASS_SIZE[0] and pos[1] <= 80:
return True
return False
def on_pause(pos):
# if 700 <= pos[0] <= 812 and pos[1] <= 32:
if 680 <= pos[0] <= 792 and pos[1] <= 32:
return True
return False
def on_sun(sun_list, pos):
for each in sun_list:
if each.posx + 10 <= pos[0] <= each.posx + 70 and each.posy + 10 <= pos[1] <= each.posy + 70:
sun_list.remove(each)
return each
return None
def can_grow(pos):
for each in GRASS:
if GRASS_POS[0] + each.grassx * GRASS_SIZE[0] <= pos[0] <= GRASS_POS[0] + (each.grassx + 1) * GRASS_SIZE[0]:
if GRASS_POS[1] + each.grassy * GRASS_SIZE[1] <= pos[1] <= GRASS_POS[1] + (each.grassy + 1) * GRASS_SIZE[1]:
return False
return True
def remove_plant_in_GRASS(plant):
for each in GRASS:
if each.grassx == plant.grassx and each.grassy == plant.grassy:
GRASS.remove(each)
return
def exist_plant(pos):
grass_x = (pos[0] - GRASS_POS[0]) // GRASS_SIZE[0]
grass_y = (pos[1] - GRASS_POS[1]) // GRASS_SIZE[1]
for plant in plant_list:
if plant.grassx == grass_x and plant.grassy == grass_y:
plant_list.remove(plant)
remove_plant_in_GRASS(plant)
return True
return False
def check_collision(bullet_x, grassy, healthdecrease):
for each in zombie_list:
if each.grassy == grassy:
if -50 < each.posx - bullet_x < -40:
each.hurt(healthdecrease)
return each
return None
def minigames_check_collision(bullet_x, grassy, healthdecrease):
for each in zombie_list:
if each.grassy == grassy + 1:
if -50 < each.posx - bullet_x < -40:
each.hurt(healthdecrease)
return each
return None
def check_eat(posx, posy):
grassy = (posy - GRASS_POS[1]) // GRASS_SIZE[1]
for each in plant_list:
if grassy == each.grassy - 1:
if each.code != -1:
temp_grassx = GRASS_POS[0] + each.grassx * GRASS_SIZE[0] - 40
if -25 <= posx - temp_grassx <= 5:
return each
else:
if -95 <= posx <= -65:
return each
return None
def minigames_discover_zombie(grassx, grassy):
for each in zombie_list:
if each.grassy == grassy + 1 and each.posx > GRASS_POS[0] + grassx * GRASS_SIZE[0]:
return True
return False
def discover_zombie(grassx, grassy):
for each in zombie_list:
if each.grassy == grassy and each.posx > GRASS_POS[0] + grassx * GRASS_SIZE[0] and not each.boom:
return True
return False
def plant_object(card_num, move, pos=None):
if card_num == 0:
return Peashooter(move, pos)
if card_num == 1:
return Sunflower(move, pos)
if card_num == 2:
return CherryBomb(move, pos)
if card_num == 3:
return WallNut(move, pos)
if card_num == 4:
return PotatoMine(move, pos)
if card_num == 5:
return DoublePea(move, pos)
if card_num == 6:
return Chomper(move, pos)
def find_moving_card(code):
for each in moving_card_list:
if each.code == code:
return True
return False
def zombie_object(zombie_num, posx=None, grassy =None):
if zombie_num == 0:
return NormalZombie( posx=posx, grassy=grassy)
if zombie_num == 1:
return ConeHeadZombie(posx=posx, grassy=grassy)
if zombie_num == 2:
return BucketHeadZombie(posx=posx,grassy=grassy)
def minigames_zombie_object(zombie_num, move, pos=None):
if pos is not None:
# temp_pos = (pos[0], (pos[1] - GRASS_POS[1]) // GRASS_SIZE[1])
if zombie_num == 0:
return MinigamesNormalZombie(move, initpos=pos)
if zombie_num == 1:
return MinigamesConeZombie(move, initpos=pos)
if zombie_num == 2:
return MinigamesBucketZombie(move, initpos=pos)
else:
if zombie_num == 0:
return MinigamesNormalZombie(move)
if zombie_num == 1:
return MinigamesConeZombie(move)
if zombie_num == 2:
return MinigamesBucketZombie(move)
def check_files():
load_font_flag = True
while load_font_flag:
try:
file = pygame.font.Font(FONT, 32)
except FileNotFoundError:
loading = True
while loading:
font = pygame.font.SysFont('华文宋体', 32)
text1 = font.render('字体文件gbk.ttf缺失 请检查文件完整性', True, (255, 255, 255))
text2 = font.render('按a键重新加载', True, (255, 255, 255))
window.blit(text1, (130, 200))
window.blit(text2, (296, 400))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.KEYDOWN:
if chr(event.key) == 'a':
loading = False
else:
load_font_flag = False
load_image_flag = True
while load_image_flag:
try:
load_images()
except FileNotFoundError:
text1 = '图片文件或images目录缺失 请检查文件完整性'
text2 = '按a键重新加载'
loading = True
while loading:
window.fill((0, 0, 0))
show_text(text1, 32, (255, 255, 255), (70, 200), text2, (296, 400))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.KEYDOWN:
if chr(event.key) == 'a':
loading = False
else:
load_image_flag = False
load_music_flag = True
while load_music_flag:
try:
load_music(0, 0, loading_flag=True)
except pygame.error:
text1 = '音乐文件或music目录缺失 请检查文件完整性'
text2 = '按a键重新加载'
loading = True
while loading:
window.fill((0, 0, 0))
show_text(text1, 32, (255, 255, 255), (70, 200), text2, (296, 400))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.KEYDOWN:
if chr(event.key) == 'a':
loading = False
else:
load_music_flag = False
load_sound_flag = True
while load_sound_flag:
try:
for i in range(38):
load_sound(0, loading_flag=True)
except FileNotFoundError:
text1 = '音效文件或sound目录缺失 请检查文件完整性'
text2 = '按a键重新加载'
loading = True
while loading:
window.fill((0, 0, 0))
show_text(text1, 32, (255, 255, 255), (72, 200), text2, (296, 400))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.KEYDOWN:
if chr(event.key) == 'a':
loading = False
else:
load_sound_flag = False
return
# 选小游戏True 主菜单False
def minigames_screen():
load_music(2, -1)
minigames_flag = True
while minigames_flag:
clock.tick(FPS)
window.blit(IMAGE_Minigames_back, POS)
window.blit(IMAGE_Minigames_imzombie, (59, 108))
show_text('迷你游戏', 32, FONT_COLOR[6], (336, 32))
temp_pos = pygame.mouse.get_pos()
if 22 <= temp_pos[0] <= 258 and 98 <= temp_pos[1] <= 338:
window.blit(IMAGE_Minigames_window_alpha, (22, 98))
else:
window.blit(IMAGE_Minigames_window, (22, 98))
show_text('我是僵尸', 32, FONT_COLOR[7], (74, 264))
if 22 <= temp_pos[0] <= 181 and 570 <= temp_pos[1] <= 591:
window.blit(IMAGE_Minigames_back_button_alpha, (20, 568))
else:
window.blit(IMAGE_Minigames_back_button, (20, 568))
show_text('主菜单', 16, FONT_COLOR[7], (79, 573))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.MOUSEBUTTONDOWN:
global mode_num
if 22 <= event.pos[0] <= 258 and 98 <= event.pos[1] <= 338:
mode_num = 1
load_sound(36)
return True
elif 22 <= event.pos[0] <= 181 and 570 <= event.pos[1] <= 591:
load_sound(36)
return False
pygame.display.update()
return False
def start(fromscreen=None):
load_music(0, -1)
on_click = 0
stay_on_button_flag = 0
start_flag = True
while start_flag:
clock.tick(FPS)
set_background(0)
adventure = Button(ADVENTURE_BUTTON, IMAGE_Adventure_button, IMAGE_Adventure_button_alpha)
minigames = Button(MINIGAMES_BUTTON, IMAGE_Minigames_button, IMAGE_Minigames_button_alpha)
help_button = Button(HELP_BUTTON, IMAGE_Help_button, IMAGE_Help_button_alpha)
quit_button = Button(QUIT_BUTTON, IMAGE_Quit_button, IMAGE_Quit_button_alpha)
options_button = Button(OPTIONS_BUTTON, IMAGE_Options_button, IMAGE_Options_button_alpha)
temp_pos = pygame.mouse.get_pos()
set_background(0)
if on_adventure_button(temp_pos):
if stay_on_button_flag != 1:
load_sound(15)
stay_on_button_flag = 1
adventure.draw_alpha()
else:
if stay_on_button_flag == 1:
stay_on_button_flag = 0
adventure.draw()
if on_minigames_button(temp_pos):
if stay_on_button_flag != 4:
load_sound(15)
stay_on_button_flag = 4
minigames.draw_alpha()
else:
if stay_on_button_flag == 4:
stay_on_button_flag = 0
minigames.draw()
if on_help_button(temp_pos):
if stay_on_button_flag != 2:
load_sound(15)
stay_on_button_flag = 2
help_button.draw_alpha()
else:
if stay_on_button_flag == 2:
stay_on_button_flag = 0
help_button.draw()
if on_quit_button(temp_pos):
if stay_on_button_flag != 3:
load_sound(15)
stay_on_button_flag = 3
quit_button.draw_alpha()
else:
if stay_on_button_flag == 3:
stay_on_button_flag = 0
quit_button.draw()
if on_options_button(temp_pos):
if stay_on_button_flag != 5:
load_sound(15)
stay_on_button_flag = 5
options_button.draw_alpha()
else:
if stay_on_button_flag == 5:
stay_on_button_flag = 0
options_button.draw()
show_text('1', 25, (255, 255, 255), ADVENTURE_TEXT[0], str(LEVEL), ADVENTURE_TEXT[1])
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
if on_quit_button(event.pos):
on_click = 1
elif on_adventure_button(event.pos):
on_click = 2
elif on_help_button(event.pos):
on_click = 3
elif on_minigames_button(event.pos):
on_click = 4
elif on_options_button(event.pos):
on_click = 5
elif event.type == pygame.MOUSEBUTTONUP:
global mode_num
if on_quit_button(event.pos) and on_click == 1:
load_sound(13)
pygame.quit()
exit()
elif on_adventure_button(event.pos) and on_click == 2:
mode_num = 0
if fromscreen == 'imzombie':
return False
return True
elif on_help_button(event.pos) and on_click == 3:
pygame.mixer.music.stop()
load_sound(13)
load_sound(16)
help_screen()
pygame.mixer.music.play()
elif on_minigames_button(event.pos) and on_click == 4:
load_sound(17)
if minigames_screen():
mode_num = 1
if fromscreen == 'adventure':
return False
return True
elif on_options_button(event.pos) and on_click == 5:
load_sound(13)
if not pause('start'):
mode_num = 0
return
on_click = 0
pygame.mixer.music.stop()
def pause(fromscreen=None):
global MUSIC_POS
MUSIC_POS = MUSIC_POS + pygame.mixer.music.get_pos() / 1000
MUSIC_POS = MUSIC_POS % 300
global MUSIC_VOLUME
global SOUND_VOLUME
pygame.mixer.music.pause()
temp = window.copy()
click_flag = 0
pause_flag = True
while pause_flag:
clock.tick(FPS)
window.blit(temp, POS)
window.blit(IMAGE_Pause_screen, (194, 58))
temp_pos = pygame.mouse.get_pos()
set_back_to_game(click_flag, temp_pos)
if fromscreen != 'start':
set_option_up(click_flag, temp_pos)
set_option_down(click_flag, temp_pos)
posx = temp_pos[0]
if posx < 400:
posx = 400
if posx > 535:
posx = 535
if click_flag == 4:
MUSIC_VOLUME = (posx - 400) / 135
elif click_flag == 5:
SOUND_VOLUME = (posx - 400) / 135
music_knob_pos = (390 + 135 * MUSIC_VOLUME, 190)
sound_knob_pos = (390 + 135 * SOUND_VOLUME, 230)
window.blit(IMAGE_Volume, (400, 200))
window.blit(IMAGE_Volume_knob, music_knob_pos)
window.blit(IMAGE_Volume, (400, 240))
window.blit(IMAGE_Volume_knob, sound_knob_pos)
show_text('音量：音乐', 20, FONT_COLOR[3], (290, 190), '音量：音效', (290, 230))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
if 244 <= event.pos[0] <= 556 and 452 <= event.pos[1] <= 520:
click_flag = 1
elif PAUSE_OPTION_UP[0][0] <= event.pos[0] <= PAUSE_OPTION_UP[4][0] + 35 and PAUSE_OPTION_DOWN[0][
1] <= event.pos[1] <= PAUSE_OPTION_DOWN[0][1] + 35:
click_flag = 2
elif PAUSE_OPTION_UP[0][0] <= event.pos[0] <= PAUSE_OPTION_UP[4][0] + 35 and PAUSE_OPTION_UP[0][
1] <= event.pos[1] <= PAUSE_OPTION_UP[0][1] + 46 and fromscreen != 'start':
click_flag = 3
elif music_knob_pos[0] <= event.pos[0] <= music_knob_pos[0] + 21 and music_knob_pos[1] + 3 <= \
event.pos[1] <= music_knob_pos[1] + 27:
# print(MUSIC_VOLUME)
click_flag = 4
elif sound_knob_pos[0] <= event.pos[0] <= sound_knob_pos[0] + 21 and sound_knob_pos[1] + 3 <= \
event.pos[1] <= sound_knob_pos[1] + 27:
# print(SOUND_VOLUME)
click_flag = 5
elif event.type == pygame.MOUSEBUTTONUP:
if event.button == 1 and click_flag != 0:
if 242 <= event.pos[0] <= 556 and 452 <= event.pos[1] <= 520:
load_sound(17)
pause_flag = False
elif PAUSE_OPTION_UP[0][0] <= event.pos[0] <= PAUSE_OPTION_UP[4][0] + 35:
if PAUSE_OPTION_DOWN[0][1] <= event.pos[1] <= PAUSE_OPTION_DOWN[0][1] + 35 and click_flag == 2:
pygame.quit()
exit()
if PAUSE_OPTION_UP[0][1] <= event.pos[1] <= PAUSE_OPTION_UP[0][1] + 46 and fromscreen != 'start' and click_flag == 3:
load_sound(17)
global mode_num
if fromscreen == 'choose' or fromscreen == 'adventure':
if not start('adventure'):
mode_num = 1
return False
if fromscreen == 'imzombie':
if not start('imzombie'):
return False
click_flag = 0
pygame.display.update()
if fromscreen is None:
load_music(1, -1, True)
if fromscreen == 'start':
load_music(0, -1, True)
elif fromscreen == 'choose':
load_music(2, -1, True)
elif fromscreen == 'imzombie':
load_music(4, -1, True)
return True
# 0 无 1 按下回到游戏 2 按下退出游戏 3 按下主菜单
def fail_screen(fromscreen=None):
pygame.mixer.music.stop()
load_sound(21)
temp_window = window.copy()
click_flag = 0
i = 1
lost_flag = True
global mode_num
while lost_flag:
clock.tick(FPS)
if fromscreen is None and i <= 3 * FPS and i % FPS == 0:
if i // FPS == 2:
load_sound(20)
load_sound(i // FPS)
window.blit(temp_window, POS)
if fromscreen is None and i <= 2 * FPS:
temp_screen = pygame.transform.rotozoom(IMAGE_Lost, 0, i / (2 * FPS))
wid, hei = temp_screen.get_size()
temp_pos = ((WINDOW_WIDTH - wid) / 2, (WINDOW_HEIGHT - hei) / 2)
window.blit(temp_screen, temp_pos)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
elif fromscreen is None and i <= 8 * FPS:
temp_back = pygame.Surface(WINDOW_SIZE)
temp_back.fill((0, 0, 0))
temp_back.set_alpha(int((150 * i - 300 * FPS) / (6 * FPS)))
window.blit(temp_back, POS)
window.blit(IMAGE_Lost, (118, 66))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
else:
temp_back = pygame.Surface(WINDOW_SIZE)
temp_back.fill((0, 0, 0))
temp_back.set_alpha(150)
window.blit(temp_back, POS)
window.blit(IMAGE_Dialog, (245, 182))
show_text('游戏结束', 25, FONT_COLOR[2], (350, 280))
temp_pos = pygame.mouse.get_pos()
set_start_again(click_flag, temp_pos)
set_pause_button(click_flag, temp_pos)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
if LOST_RESTART[0][0] <= event.pos[0] <= LOST_RESTART[4][0] + 46 and LOST_RESTART[0][1] <= \
event.pos[1] <= LOST_RESTART[0][1] + 46:
click_flag = 1
elif PAUSE_BUTTON[0][0] <= event.pos[0] <= PAUSE_BUTTON[2][0] + 46:
click_flag = 2
elif event.type == pygame.MOUSEBUTTONUP:
if event.button == 1 and click_flag != 0:
if LOST_RESTART[0][0] <= event.pos[0] <= LOST_RESTART[4][0] + 204 and LOST_RESTART[0][1] <= \
event.pos[1] <= LOST_RESTART[0][1] + 46:
load_sound(17)
return True
elif PAUSE_BUTTON[0][0] <= event.pos[0] <= PAUSE_BUTTON[2][0] + 46 and PAUSE_BUTTON[0][1] <= \
event.pos[1] <= PAUSE_BUTTON[0][1] + 46:
load_sound(17)
if fromscreen == 'adventure':
if not start('adventure'):
mode_num = 1
return False
if fromscreen == 'imzombie':
if not start('imzombie'):
mode_num = 0
return False
return True
click_flag = 0
pygame.display.update()
# 0 no 1 click restart 2 click menu
i += 1
def winscreen():
pygame.mixer.music.fadeout(1000)
load_sound(35)
timer = 0
posx = trophy.posx
posy = trophy.posy + 61
while True:
clock.tick(FPS)
if timer <= 2 * FPS:
trophy_image = IMAGE_Trophy_get
temp_screen = pygame.Surface(WINDOW_SIZE)
temp_screen.fill((255, 255, 255))
temp_screen.set_alpha(int(50 * timer / (7 * FPS)))
window.blit(temp_screen, POS)
window.blit(trophy_image, (posx, posy))
elif timer <= 7 * FPS:
trophy_image = IMAGE_Trophy_get
window.blit(trophy_image, (posx, posy))
temp_screen = pygame.Surface(WINDOW_SIZE)
temp_screen.fill((255, 255, 255))
temp_screen.set_alpha(int(255 * (timer - 2 * FPS) / (5 * FPS)))
window.blit(temp_screen, POS)
else:
return
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
pygame.display.update()
timer += 1
def imzombie():
load_music(4, -1)
global card_list
card_list = [0, 1, 2]
mouse_zombie = None
on_click = False
global plant_list
plant_list = [MinigamesSunflower(0, 0), MinigamesPeashooter(1, 0),
MinigamesSunflower(2, 0), MinigamesPeashooter(3, 0),
MinigamesWallNut(0, 1), MinigamesPeashooter(1, 1),
MinigamesSunflower(2, 1), MinigamesPeashooter(3, 1),
MinigamesChomper(0, 2), MinigamesSunflower(1, 2),
MinigamesPeashooter(2, 2), MinigamesSunflower(3, 2),
MinigamesSunflower(0, 3), MinigamesWallNut(1, 3),
MinigamesSunflower(2, 3), MinigamesDoublePea(3, 3),
MinigamesPotatoMine(0, 4), MinigamesSunflower(1, 4),
MinigamesPeashooter(2, 4), MinigamesSunflower(3, 4)]
global brain_list
brain_list = []
for i in range(5):
brain_list.append(i)
plant_list.append(Brain(i))
global bullets
global zombie_list
global head_list
global body_list
bullets = []
zombie_list = []
head_list = []
body_list = []
global sun_falling
global sun_collecting
sun_falling = []
sun_collecting = []
initsun = INIT_SUN
pause_click_flag = 0
global win
win = False
global trophy
trophy = None
global mode_num
while True:
clock.tick(FPS)
set_background(3)
window.blit(IMAGE_Zombie_line, (347, 71))
set_sun(str(initsun))
card_pos = CARD_POS
for i in card_list:
if initsun < ZOMBIE_SUN_COST[i]:
set_minigames_card(i, card_pos, 'alpha')
else:
set_minigames_card(i, card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0], card_pos[1])
for each in plant_list:
if each.code == 0:
temp_bullet = each.draw_on_grass()
if temp_bullet is not None:
bullets.append(temp_bullet)
elif each.code == 5:
temp_bullet = each.draw_on_grass()
if temp_bullet is not None:
bullets.append(temp_bullet)
else:
each.draw_on_grass()
temp_pos = pygame.mouse.get_pos()
for each in bullets:
each.draw()
each.move()
for each in zombie_list:
each.draw_on_grass()
for each in head_list:
each.draw()
for each in body_list:
each.draw()
for each in sun_falling:
each.draw()
each.fall()
for each in sun_collecting:
each.draw()
each.move()
if trophy is not None:
trophy.draw()
trophy.fall()
if initsun < 50 and len(brain_list) > 0 and len(zombie_list) == 0:
fail_screen('imzombie')
return
set_pause_button(pause_click_flag, temp_pos)
if on_click and mouse_zombie is not None:
if minigames_on_grass(temp_pos):
alpha = minigames_zombie_object(mouse_zombie.code, False)
alpha.draw_alpha(temp_pos)
temp_zombie_size = ZOMBIE_SIZE[mouse_zombie.code]
temp_pos = (temp_pos[0] - temp_zombie_size[0] * 2 / 3, temp_pos[1] - temp_zombie_size[1] * 2 / 3)
mouse_zombie.draw(temp_pos)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
card_flag = on_card(event.pos)
flag = on_sun(sun_falling, event.pos)
if on_pause(event.pos):
pause_click_flag = 2
elif flag is not None:
if not on_click:
temp_sun = SunCollecting((flag.posx, flag.posy))
sun_collecting.append(temp_sun)
initsun += Sun.sun_point
elif card_flag != -1:
if not on_click:
if initsun >= ZOMBIE_SUN_COST[card_list[card_flag]]:
load_sound(4)
mouse_zombie = minigames_zombie_object(card_list[card_flag], False)
on_click = True
else:
load_sound(14)
else:
load_sound(6)
on_click = False
mouse_zombie = None
elif minigames_on_grass(event.pos):
if on_click:
zombie_list.append(minigames_zombie_object(mouse_zombie.code, True, event.pos))
load_sound(0)
on_click = False
initsun -= ZOMBIE_SUN_COST[mouse_zombie.code]
if on_grass(event.pos):
if trophy is not None:
if trophy.posx + 5 < event.pos[0] < trophy.posx + 77 and trophy.posy + 54 < event.pos[1] < trophy.posy + 115:
winscreen()
if not start('imzombie'):
mode_num = 0
return
elif event.type == pygame.MOUSEBUTTONUP:
if event.button == 1 and pause_click_flag == 2:
if on_pause(event.pos):
load_sound(17)
load_sound(18)
if not pause('imzombie'):
mode_num = 0
return
pause_click_flag = 0
def game():
# plant(code) sequence in card bank
global card_list
# card_list = [0, 1, 2, 3, 4, 5, 6]
card_list = []
mouse_plant = None
on_click = False
global plant_list
plant_list = []
global lawnmower_list
lawnmower_list = []
global bullets
global zombie_list
global head_list
global body_list
bullets = []
zombie_list = []
head_list = []
body_list = []
flagmeter = FlagMeter()
global sun_falling
global sun_collecting
sun_falling = []
sun_collecting = []
initsun = INIT_SUN
shovel_flag = False
pause_click_flag = 0
timer = 0
last_selected_time = [4 * FPS, -3.5 * FPS, 4 * FPS, 4 * FPS, 4 * FPS, 4 * FPS, 4 * FPS]
# last_selected_time = [-30 * FPS] * 7
global moving_card_list
moving_card_list = []
selecting_flag = True
speed_back = 380 / (1.5 * FPS)
speed_cards_up = 87 / (0.2 * FPS)
speed_cards_down = 513 / (0.2 * FPS)
speed_pause_button = 46 / (0.2 * FPS)
speed_cards_up_back = 10 / (1.5 * FPS)
speed_shovel = 80 / (1.5 * FPS)
global USEREVENT_COUNT
SUN_FALL = pygame.USEREVENT + USEREVENT_COUNT
USEREVENT_COUNT += 1
pygame.time.set_timer(SUN_FALL, 3000)
zombie_count = 0
wave_count = 0
huge_wave = 1e8
final_wave = 1e8
ZOMBIE_CRAETE = pygame.USEREVENT + USEREVENT_COUNT
USEREVENT_COUNT += 1
ZOMBIE_WAVE = pygame.USEREVENT + USEREVENT_COUNT
USEREVENT_COUNT += 1
for i in [4, 3, 2, 1, 0]:
initpos = i * 20 - 160
lawnmower = Lawnmower(initpos, i)
lawnmower_list.append(lawnmower)
global fail
global win
fail = False
win = False
global trophy
trophy = None
global GRASS
GRASS = []
global mode_num
while True:
clock.tick(FPS)
# print(timer)
# (0, 87) (22, 123) (75, 123)
if selecting_flag:
if timer == 0:
load_music(2, -1)
if timer <= 2 * FPS:
set_background(2, POS)
elif timer <= 3.5 * FPS:
posx = POS[0] - speed_back * (timer - 2 * FPS)
set_background(2, (posx, 0))
elif timer <= 3.7 * FPS:
posy_up = -87 + speed_cards_up * (timer - 3.5 * FPS)
posy_down = 600 - speed_cards_down * (timer - 3.5 * FPS)
posy_cards = 636 - speed_cards_down * (timer - 3.5 * FPS)
posy_ready = 994 - speed_cards_down * (timer - 3.5 * FPS)
posy_pause = PAUSE_BUTTON[0][1] - 46 + speed_pause_button * (timer - 3.5 * FPS)
posy_text = -44 + speed_pause_button * (timer - 3.5 * FPS)
set_sun(str(initsun), (0, posy_up))
window.blit(IMAGE_Choose_seeds, (0, posy_down))
window.blit(IMAGE_Ready_button[0], (76, posy_ready))
show_text('开始战斗', 36, FONT_COLOR[4], (160, posy_down + 19))
window.blit(IMAGE_Pause_button_left, (PAUSE_BUTTON[0][0], posy_pause))
window.blit(IMAGE_Pause_button_middle, (PAUSE_BUTTON[1][0], posy_pause))
window.blit(IMAGE_Pause_button_right, (PAUSE_BUTTON[2][0], posy_pause))
show_text('菜单', 18, FONT_COLOR[0], (721, posy_text))
card_pos = (22, posy_cards)
for i in range(7):
set_cards(i, card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0] + 2, posy_cards)
else:
set_background(2, (-380, 0))
set_sun(str(initsun), (0, 0))
window.blit(IMAGE_Choose_seeds, (0, 87))
card_pos = (22, 123)
for i in range(7):
if i not in card_list:
if not find_moving_card(i):
set_cards(i, card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0] + 2, card_pos[1])
card_pos = (80, 8)
for i in range(len(card_list)):
if not find_moving_card(card_list[i]):
set_cards(card_list[i], card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0], card_pos[1])
for each in moving_card_list:
each.draw()
each.move()
pos = pygame.mouse.get_pos()
set_pause_button(pause_click_flag, pos)
# print(pos)
if len(card_list) < 7:
window.blit(IMAGE_Ready_button[0], (76, 481))
show_text('开始战斗', 36, FONT_COLOR[4], (160, 500))
else:
window.blit(IMAGE_Ready_button[1], (76, 481))
if 80 <= pos[0] <= 383 and 486 <= pos[1] <= 552:
window.blit(IMAGE_Ready_button[2], (76, 481))
show_text('开始战斗', 36, FONT_COLOR[5], (160, 500))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
if on_pause(event.pos):
pause_click_flag = 2
card_pos = (22, 123)
if card_pos[1] <= event.pos[1] <= card_pos[1] + CARD_SIZE[1]:
if len(card_list) < 7:
card_pos = (22, 123)
for i in range(7):
if i not in card_list:
if card_pos[0] <= event.pos[0] <= card_pos[0] + CARD_SIZE[0] + 2:
load_sound(6)
endpos = (80 + len(card_list) * CARD_SIZE[0], 8)
card_list.append(i)
moving_card_list.append(MovingCard(card_image_list[i],
card_pos, endpos, i))
break
card_pos = (card_pos[0] + CARD_SIZE[0] + 2, card_pos[1])
if 80 <= event.pos[0] <= 383 and 486 <= event.pos[1] <= 552:
if len(card_list) == 7:
load_sound(6)
selecting_flag = False
timer = 0
continue
if 80 <= event.pos[0] <= 80 + len(card_list) * CARD_SIZE[0]:
if 8 <= event.pos[1] <= 8 + CARD_SIZE[1]:
load_sound(6)
removed_num = (event.pos[0] - 80) // CARD_SIZE[0]
plant_removed = card_list[removed_num]
card_pos = (80 + removed_num * CARD_SIZE[0], 8)
endpos = (22 + plant_removed * (CARD_SIZE[0] + 2), 123)
moving_card_list.append(MovingCard(card_image_list[plant_removed], card_pos,
endpos, plant_removed))
card_pos = (80 + (removed_num + 1) * CARD_SIZE[0], 8)
endpos = (80 + removed_num * CARD_SIZE[0], 8)
for i in range(removed_num + 1, len(card_list)):
moving_card_list.append(MovingCard(card_image_list[card_list[i]],
card_pos, endpos, card_list[i]))
card_pos = (card_pos[0] + CARD_SIZE[0], 8)
endpos = (endpos[0] + CARD_SIZE[0], 8)
card_list.remove(plant_removed)
# print(card_list)
elif event.type == pygame.MOUSEBUTTONUP:
if event.button == 1:
if pause_click_flag == 2:
if on_pause(event.pos):
load_sound(17)
load_sound(18)
if not pause('choose'):
mode_num = 1
return
# return False
pause_click_flag = 0
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
pygame.display.update()
timer += 1
continue
if timer == 1:
# pygame.mixer.music.stop()
pygame.mixer.music.fadeout(1500)
if timer == 1.5 * FPS:
load_sound(31)
if timer == 4 * FPS:
load_music(1, -1)
if timer <= 1.5 * FPS:
posx = -380 + speed_back * timer
set_background(2, (posx, 0))
else:
set_background(1)
for each in lawnmower_list:
each.draw()
each.move()
if timer <= 0.2 * FPS:
posy_down = 87 + speed_cards_down * timer
posy_cards = 123 + speed_cards_down * timer
posy_ready = 481 + speed_cards_down * timer
window.blit(IMAGE_Choose_seeds, (0, posy_down))
window.blit(IMAGE_Ready_button[0], (76, posy_ready))
show_text('开始战斗', 36, FONT_COLOR[4], (160, posy_ready + 19))
card_pos = (22, posy_cards)
for i in range(7):
if i not in card_list:
set_cards(i, card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0] + 2, posy_cards)
if timer <= 1.5 * FPS:
posx_up = speed_cards_up_back * timer
posy_shovel = -80 + speed_shovel * timer
set_sun(str(initsun), (posx_up, 0))
set_shovel((GRASS_POS[0] + 7 * GRASS_SIZE[0], posy_shovel))
window.blit(IMAGE_Shovel, (GRASS_POS[0] + 7 * GRASS_SIZE[0], posy_shovel))
card_pos = (posx_up + 80, 8)
# print(card_list)
for i in card_list:
set_cards(i, card_pos)
temp_alpha = pygame.Surface(CARD_SIZE)
temp_alpha.fill((0, 0, 0))
temp_alpha.set_alpha(int(100 * timer / (1.5 * FPS)))
window.blit(temp_alpha, card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0], card_pos[1])
pygame.display.update()
elif timer <= 4 * FPS:
set_sun(str(initsun), SUN_POS)
set_shovel((GRASS_POS[0] + 7 * GRASS_SIZE[0], 0))
window.blit(IMAGE_Shovel, (GRASS_POS[0] + 7 * GRASS_SIZE[0], 0))
card_pos = (90, 8)
for i in card_list:
set_cards(i, card_pos)
temp_alpha = pygame.Surface(CARD_SIZE)
temp_alpha.fill((0, 0, 0))
temp_alpha.set_alpha(100)
window.blit(temp_alpha, card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0], card_pos[1])
if 1.5 * FPS <= timer <= 2 * FPS:
image_size = (int(28.8 + 1.92 * (timer - 1.5 * FPS)), int(11.55 + 0.77 * (timer - 1.5 * FPS)))
ready_image = pygame.transform.scale(IMAGE_Start_planting[0], image_size)
window.blit(ready_image, ((WINDOW_WIDTH - image_size[0]) / 2, (WINDOW_HEIGHT - image_size[1]) / 2))
elif 2 * FPS < timer <= 2.5 * FPS:
image_size = (int(24.45 + 1.63 * (timer - 2 * FPS)), int(14.4 + 0.96 * (timer - 2 * FPS)))
set_image = pygame.transform.scale(IMAGE_Start_planting[1], image_size)
window.blit(set_image, ((WINDOW_WIDTH - image_size[0]) / 2, (WINDOW_HEIGHT - image_size[1]) / 2))
elif timer <= 3.5 * FPS:
window.blit(IMAGE_Start_planting[2], (295, 251))
pygame.display.update()
if timer == 4 * FPS:
pygame.time.set_timer(ZOMBIE_CRAETE, 5000) # zombie_create_time()
pygame.time.set_timer(ZOMBIE_WAVE, 60000)
else:
set_sun(str(initsun))
set_shovel()
flagmeter.draw()
card_pos = CARD_POS
for i in card_list:
if initsun < SUN_COST[i]:
set_cards(i, card_pos, 'alpha')
else:
set_cards(i, card_pos)
set_frozen_time(i, last_selected_time[i], timer, card_pos)
card_pos = (card_pos[0] + CARD_SIZE[0], card_pos[1])
for each in plant_list:
if each.code == 0:
temp_bullet = each.draw_on_grass()
if temp_bullet is not None:
bullets.append(temp_bullet)
elif each.code == 5:
temp_bullet = each.draw_on_grass()
if temp_bullet is not None:
bullets.append(temp_bullet)
else:
each.draw_on_grass()
for each in lawnmower_list:
each.draw()
each.move()
temp_pos = pygame.mouse.get_pos()
if not shovel_flag:
window.blit(IMAGE_Shovel, (GRASS_POS[0] + 7 * GRASS_SIZE[0], 0))
else:
window.blit(IMAGE_Shovel, (temp_pos[0] - 40, temp_pos[1] - 40))
for each in bullets:
each.draw()
each.move()
for each in zombie_list:
each.draw()
for each in head_list:
each.draw()
for each in body_list:
each.draw()
for each in sun_falling:
each.draw()
each.fall()
for each in sun_collecting:
each.draw()
each.move()
if trophy is not None:
trophy.draw()
trophy.fall()
if fail:
fail_screen()
return
if timer >= final_wave:
if timer == final_wave:
load_sound(32)
for i in range(10):
zombie_list.append(zombie_object(random.randint(0, 2)))
if 0 <= final_wave - timer <= FPS:
image_size = (int(341 + 34.1 * (timer - final_wave)), int(80 + 8 * (timer - final_wave)))
final_image = pygame.transform.scale(IMAGE_Final_wave, image_size)
window.blit(final_image, ((WINDOW_WIDTH - image_size[0])/2, (WINDOW_HEIGHT - image_size[1])/2))
elif 0 <= timer - final_wave <= FPS * 1.5:
image_size = (341, 80)
final_image = pygame.transform.scale(IMAGE_Final_wave, image_size)
window.blit(final_image, ((WINDOW_WIDTH - image_size[0]) / 2, (WINDOW_HEIGHT - image_size[1]) / 2))
if timer >= huge_wave:
if timer - huge_wave == 1:
load_sound(33)
if timer - huge_wave == FPS:
load_sound(37)
for i in range(10):
zombie_list.append(zombie_object(random.randint(0, 2)))
if 0 <= huge_wave - timer <= FPS:
image_size = (int(492 + 49.2 * (timer - huge_wave)), int(80 + 8 * (timer - huge_wave)))
wave_image = pygame.transform.scale(IMAGE_Huge_wave, image_size)
window.blit(wave_image,
((WINDOW_WIDTH - image_size[0]) / 2, (WINDOW_HEIGHT - image_size[1]) / 2))
elif 0 <= timer - huge_wave <= FPS * 1.5:
image_size = (492, 80)
wave_image = pygame.transform.scale(IMAGE_Huge_wave, image_size)
window.blit(wave_image,
((WINDOW_WIDTH - image_size[0]) / 2, (WINDOW_HEIGHT - image_size[1]) / 2))
elif timer - huge_wave > FPS * 1.5:
huge_wave = 1e8
set_pause_button(pause_click_flag, temp_pos)
if on_click and mouse_plant is not None:
if on_grass(temp_pos) and can_grow(temp_pos):
alpha = plant_object(mouse_plant.code, False)
alpha.draw_alpha(temp_pos)
temp_plant_size = PLANT_SIZE[mouse_plant.code]
temp_pos = (temp_pos[0] - temp_plant_size[0] // 2, temp_pos[1] - temp_plant_size[1] // 2)
mouse_plant.draw(temp_pos)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
elif event.type == SUN_FALL:
sun_falling.append(Sun())
elif event.type == ZOMBIE_CRAETE:
if zombie_count == 0:
load_sound(34)
if zombie_count < TOTAL_ZOMBIE:
zombie_list.append(zombie_object(random.randint(0, 2)))
zombie_count += 1
if zombie_count == TOTAL_ZOMBIE:
win = True
elif event.type == ZOMBIE_WAVE:
wave_count += 1
huge_wave = timer + 1
if wave_count == 2:
final_wave = timer + 66 * FPS
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
card_flag = on_card(event.pos)
flag = on_sun(sun_falling, event.pos)
if on_pause(event.pos):
pause_click_flag = 2
elif flag is not None:
if not on_click and not shovel_flag:
temp_sun = SunCollecting((flag.posx, flag.posy))
sun_collecting.append(temp_sun)
initsun += Sun.sun_point
elif card_flag != -1:
if not on_click:
if initsun >= SUN_COST[card_list[card_flag]] and timer - last_selected_time[card_list[card_flag]] >= FROZEN_TIME[card_list[card_flag]] * FPS:
load_sound(4)
mouse_plant = plant_object(card_list[card_flag], False)
on_click = True
else:
load_sound(14)
else:
load_sound(6)
on_click = False
mouse_plant = None
elif on_shovel(event.pos):
if not on_click:
if shovel_flag:
load_sound(6)
shovel_flag = False
else:
load_sound(5)
shovel_flag = True
elif on_grass(event.pos):
if on_click:
if can_grow(event.pos):
last_selected_time[mouse_plant.code] = timer
plant_list.append(plant_object(mouse_plant.code, True, event.pos))
GRASS.append(PlantedGrass(event.pos, mouse_plant.code))
load_sound(0)
on_click = False
initsun -= SUN_COST[mouse_plant.code]
elif shovel_flag:
if exist_plant(event.pos):
load_sound(0)
shovel_flag = False
elif trophy is not None:
if trophy.posx + 5 < event.pos[0] < trophy.posx + 77 and trophy.posy + 54 < event.pos[1] < trophy.posy + 115:
winscreen()
if not start('adventure'):
mode_num = 1
return
# print('win')
elif event.type == pygame.MOUSEBUTTONUP:
if event.button == 1 and pause_click_flag == 2:
if on_pause(event.pos):
load_sound(17)
load_sound(18)
if not pause('adventure'):
mode_num = 1
return
pause_click_flag = 0
timer += 1
BACK_BUTTON = (325, 520)
def help_screen():
help_flag = True
while help_flag:
clock.tick(FPS)
back_button = Button(BACK_BUTTON, IMAGE_Back_button_alpha)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if 325 <= event.pos[0] <= 480 and 520 <= event.pos[1] <= 562:
load_sound(13)
help_flag = False
temp_pos = pygame.mouse.get_pos()
window.blit(IMAGE_Help, POS)
if 325 <= temp_pos[0] <= 480 and 520 <= temp_pos[1] <= 562:
back_button.draw()
pygame.display.update()
def choose_game(num):
if num == 0:
game()
elif num == 1:
imzombie()
def main():
pygame.init()
global clock
clock = pygame.time.Clock()
global mode_num
mode_num = 0
set_window('Python PVZ', WINDOW_SIZE)
check_files()
start()
while True:
choose_game(mode_num)
if __name__ == '__main__':
main()
到了这里，关于Python实现植物大战僵尸的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
