devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python开发植物大战僵尸游戏_python写植物大战僵尸

作者：AllinToyou | 2024-04-08 00:10:59

赞

踩

python写植物大战僵尸

开发思路

完整项目地址：https://github.com/371854496/pygame  
觉得还OK的话，点下Star,作者不易，thank you！

1.引入需要的模块，配置图片路径，设置界面宽高背景颜色，创建游戏主入口。
 

   

  1.  #1引入需要的模块
  2.     import pygame
  3.     import random
  4.     #1配置图片地址
  5.     IMAGE_PATH = 'imgs/'
  6.     #1设置页面宽高
  7.     scrrr_width=800
  8.     scrrr_height =560
  9.     #1创建控制游戏结束的状态
  10.     GAMEOVER = False
  11.     #1主程序
  12.     class MainGame():
  13.          #1加载游戏窗口
  14.         def init_window(self):
  15.             #1调用显示模块的初始化
  16.             pygame.display.init()
  17.             #1创建窗口
  18.             MainGame.window = pygame.display.set_mode([scrrr_width,scrrr_height])  #
  19.         #1开始游戏
  20.         def start_game(self):
  21.             #1初始化窗口
  22.             self.init_window()
  23.             #1只要游戏没结束，就一直循环
  24.             while not GAMEOVER:
  25.                 #1渲染白色背景
  26.                 MainGame.window.fill((255, 255, 255))
  27.                 #1实时更新
  28.                 pygame.display.update()
  29.     #1启动主程序
  30.     if __name__ == '__main__':
  31.         game = MainGame()
  32.         game.start_game()


        

2.文本绘制，创建要动态改变的属性，渲染的位置

   

  1.  #2 创建关数，得分，剩余分数，钱数
  2.     shaoguan = 1
  3.     score = 0
  4.     remnant_score = 100
  5.     money = 200
  6.     #2 文本绘制
  7.     def draw_text(self, content, size, color):
  8.         pygame.font.init()
  9.         font = pygame.font.SysFont('kaiti', size)
  10.         text = font.render(content, True, color)
  11.         return text
  12.     #2 加载帮助提示
  13.     def load_help_text(self):
  14.         text1 = self.draw_text('1.按左键创建向日葵 2.按右键创建豌豆射手', 26, (255, 0, 0))
  15.         MainGame.window.blit(text1, (5, 5))
  16.     
  17.     #2 渲染的文字和坐标位置
  18.             MainGame.window.blit(self.draw_text('当前钱数$: {}'.format(MainGame.money), 26, (255, 0, 0)), (500, 40))
  19.             MainGame.window.blit(self.draw_text(
  20.                 '当前关数{}，得分{},距离下关还差{}分'.format(MainGame.shaoguan, MainGame.score, MainGame.remnant_score), 26,
  21.                 (255, 0, 0)), (5, 40))
  22.             self.load_help_text()

3.创建地图类，初始化地图和坐标


   

  1.  #3 创建地图类
  2.     class Map():
  3.         #3 存储两张不同颜色的图片名称
  4.         map_names_list = [IMAGE_PATH + 'map1.png', IMAGE_PATH + 'map2.png']
  5.         #3 初始化地图
  6.         def __init__(self, x, y, img_index):
  7.             self.image = pygame.image.load(Map.map_names_list[img_index])
  8.             self.position = (x, y)
  9.             # 是否能够种植
  10.             self.can_grow = True
  11.         #3 加载地图
  12.         def load_map(self):
  13.              MainGame.window.blit(self.image,self.position)
  14.         
  15.         #3 存储所有地图坐标点
  16.         map_points_list = []
  17.         #3 存储所有的地图块
  18.         map_list = []
  19.         
  20.         #3 初始化坐标点
  21.         def init_plant_points(self):
  22.             for y in range(1, 7):
  23.                 points = []
  24.                 for x in range(10):
  25.                     point = (x, y)
  26.                     points.append(point)
  27.                 MainGame.map_points_list.append(points)
  28.                 print("MainGame.map_points_list", MainGame.map_points_list)
  29.     
  30.         #3 初始化地图
  31.         def init_map(self):
  32.             for points in MainGame.map_points_list:
  33.                 temp_map_list = list()
  34.                 for point in points:
  35.                     # map = None
  36.                     if (point[0] + point[1]) % 2 == 0:
  37.                         map = Map(point[0] * 80, point[1] * 80, 0)
  38.                     else:
  39.                         map = Map(point[0] * 80, point[1] * 80, 1)
  40.                     # 将地图块加入到窗口中
  41.                     temp_map_list.append(map)
  42.                     print("temp_map_list", temp_map_list)
  43.                 MainGame.map_list.append(temp_map_list)
  44.             print("MainGame.map_list", MainGame.map_list)
  45.     
  46.         #3 将地图加载到窗口中
  47.         def load_map(self):
  48.             for temp_map_list in MainGame.map_list:
  49.                 for map in temp_map_list:
  50.                     map.load_map()
  51.         
  52.         #3 初始化坐标和地图
  53.         self.init_plant_points()
  54.         self.init_map()
  55.         
  56.         #3 需要反复加载地图
  57.         self.load_map()


        

4.创建植物类，图片加载报错处理，加载植物方法


   

  1.  #4 图片加载报错处理
  2.     LOG = '文件:{}中的方法:{}出错'.format(__file__,__name__)
  3.     #4 植物类
  4.     class Plant(pygame.sprite.Sprite):
  5.         def __init__(self):
  6.             super(Plant, self).__init__()
  7.             self.live=True
  8.     
  9.         # 加载图片
  10.         def load_image(self):
  11.             if hasattr(self, 'image') and hasattr(self, 'rect'):
  12.                 MainGame.window.blit(self.image, self.rect)
  13.             else:
  14.                 print(LOG)
  15.             
  16.     #4 存储所有植物的列表
  17.     plants_list = []
  18.   


    
5.创建向日葵类

   

  1.  #5 向日葵类
  2.     class Sunflower(Plant):
  3.         def __init__(self,x,y):
  4.             super(Sunflower, self).__init__()
  5.             self.image = pygame.image.load('imgs/sunflower.png')
  6.             self.rect = self.image.get_rect()
  7.             self.rect.x = x
  8.             self.rect.y = y
  9.             self.price = 50
  10.             self.hp = 100
  11.             #5 时间计数器
  12.             self.time_count = 0
  13.     
  14.         #5 功能：生成阳光（生产钱）
  15.         def produce_money(self):
  16.             self.time_count += 1
  17.             if self.time_count == 25:
  18.                 MainGame.money += 5
  19.                 self.time_count = 0
  20.         #5 向日葵加入到窗口中
  21.         def display_sunflower(self):
  22.             MainGame.window.blit(self.image,self.rect)
  23.             
  24.           

6.创建豌豆射手类

       

  1.  #6 豌豆射手类
  2.     class PeaShooter(Plant):
  3.         def __init__(self,x,y):
  4.             super(PeaShooter, self).__init__()
  5.             # self.image 为一个 surface
  6.             self.image = pygame.image.load('imgs/peashooter.png')
  7.             self.rect = self.image.get_rect()
  8.             self.rect.x = x
  9.             self.rect.y = y
  10.             self.price = 50
  11.             self.hp = 200
  12.             #6 发射计数器
  13.             self.shot_count = 0
  14.     
  15.         #6 增加射击方法
  16.         def shot(self):
  17.             #6 记录是否应该射击
  18.             should_fire = False
  19.             for zombie in MainGame.zombie_list:
  20.                 if zombie.rect.y == self.rect.y and zombie.rect.x < 800 and zombie.rect.x > self.rect.x:
  21.                     should_fire = True
  22.             #6 如果活着
  23.             if self.live and should_fire:
  24.                 self.shot_count += 1
  25.                 # 计数器到25发射一次
  26.                 if self.shot_count == 25:
  27.                     #6 基于当前豌豆射手的位置，创建子弹
  28.                     peabullet = PeaBullet(self)
  29.                     #6 将子弹存储到子弹列表中
  30.                     MainGame.peabullet_list.append(peabullet)
  31.                     self.shot_count = 0
  32.     
  33.         #6 将豌豆射手加入到窗口中的方法
  34.         def display_peashooter(self):
  35.             MainGame.window.blit(self.image,self.rect)
  36.             
  37.         #6 增加豌豆射手发射处理
  38.         def load_plants(self):
  39.             for plant in MainGame.plants_list:
  40.                 #6 优化加载植物的处理逻辑
  41.                 if plant.live:
  42.                     if isinstance(plant, Sunflower):
  43.                         plant.display_sunflower()
  44.                         plant.produce_money()
  45.                     elif isinstance(plant, PeaShooter):
  46.                         plant.display_peashooter()
  47.                         plant.shot()
  48.                 else:
  49.                     MainGame.plants_list.remove(plant)
  50.          #6 调用加载植物的方法
  51.          self.load_plants()


     
7.创建子弹类

    

  1. #7 豌豆子弹类
  2.     class PeaBullet(pygame.sprite.Sprite):
  3.         def __init__(self,peashooter):
  4.             self.live = True
  5.             self.image = pygame.image.load('imgs/peabullet.png')
  6.             self.damage = 50
  7.             self.speed  = 10
  8.             self.rect = self.image.get_rect()
  9.             self.rect.x = peashooter.rect.x + 60
  10.             self.rect.y = peashooter.rect.y + 15
  11.     
  12.         def move_bullet(self):
  13.             #7 在屏幕范围内，实现往右移动
  14.             if self.rect.x < scrrr_width:
  15.                 self.rect.x += self.speed
  16.             else:
  17.                 self.live = False
  18.     
  19.         #7 新增，子弹与僵尸的碰撞
  20.         def hit_zombie(self):
  21.             for zombie in MainGame.zombie_list:
  22.                 if pygame.sprite.collide_rect(self,zombie):
  23.                     #打中僵尸之后，修改子弹的状态，
  24.                     self.live = False
  25.                     #僵尸掉血
  26.                     zombie.hp -= self.damage
  27.                     if zombie.hp <= 0:
  28.                         zombie.live = False
  29.                         self.nextLevel()
  30.         #7闯关方法
  31.         def nextLevel(self):
  32.             MainGame.score += 20
  33.             MainGame.remnant_score -=20
  34.             for i in range(1,100):
  35.                 if MainGame.score==100*i and MainGame.remnant_score==0:
  36.                         MainGame.remnant_score=100*i
  37.                         MainGame.shaoguan+=1
  38.                         MainGame.produce_zombie+=50
  39.     
  40.     
  41.     
  42.         def display_peabullet(self):
  43.             MainGame.window.blit(self.image,self.rect)
  44.        
  45.         #7 存储所有豌豆子弹的列表
  46.         peabullet_list = []
  47.         
  48.         #7 加载所有子弹的方法
  49.     def load_peabullets(self):
  50.         for b in MainGame.peabullet_list:
  51.             if b.live:
  52.                 b.display_peabullet()
  53.                 b.move_bullet()
  54.                 #7  调用子弹是否打中僵尸的方法
  55.                 b.hit_zombie()
  56.             else:
  57.                 MainGame.peabullet_list.remove(b) 
  58.         #7 调用加载所有子弹的方法
  59.         self.load_peabullets()         


        

8.事件处理

   

  1. #8事件处理
  2.     def deal_events(self):
  3.         #8 获取所有事件
  4.         eventList = pygame.event.get()
  5.         #8 遍历事件列表，判断
  6.         for e in eventList:
  7.             if e.type == pygame.QUIT:
  8.                 self.gameOver()
  9.             elif e.type == pygame.MOUSEBUTTONDOWN:
  10.                 # print('按下鼠标按键')
  11.                 print(e.pos)
  12.                 # print(e.button)#左键1  按下滚轮2 上转滚轮为4 下转滚轮为5  右键 3
  13.  
  14.                 x = e.pos[0] // 80
  15.                 y = e.pos[1] // 80
  16.                 print(x, y)
  17.                 map = MainGame.map_list[y - 1][x]
  18.                 print(map.position)
  19.                 #8 增加创建时候的地图装填判断以及金钱判断
  20.                 if e.button == 1:
  21.                     if map.can_grow and MainGame.money >= 50:
  22.                         sunflower = Sunflower(map.position[0], map.position[1])
  23.                         MainGame.plants_list.append(sunflower)
  24.                         print('当前植物列表长度:{}'.format(len(MainGame.plants_list)))
  25.                         map.can_grow = False
  26.                         MainGame.money -= 50
  27.                 elif e.button == 3:
  28.                     if map.can_grow and MainGame.money >= 50:
  29.                         peashooter = PeaShooter(map.position[0], map.position[1])
  30.                         MainGame.plants_list.append(peashooter)
  31.                         print('当前植物列表长度:{}'.format(len(MainGame.plants_list)))
  32.                         map.can_grow = False
  33.                         MainGame.money -= 50
  34.                         
  35.                         #8 调用事件处理的方法
  36.                         self.deal_events()


                        

9.创建僵尸类

   

  1.  #9 僵尸类
  2.     class Zombie(pygame.sprite.Sprite):
  3.         def __init__(self,x,y):
  4.             super(Zombie, self).__init__()
  5.             self.image = pygame.image.load('imgs/zombie.png')
  6.             self.rect = self.image.get_rect()
  7.             self.rect.x = x
  8.             self.rect.y = y
  9.             self.hp = 1000
  10.             self.damage = 2
  11.             self.speed = 1
  12.             self.live = True
  13.             self.stop = False
  14.         #9 僵尸的移动
  15.         def move_zombie(self):
  16.             if self.live and not self.stop:
  17.                 self.rect.x -= self.speed
  18.                 if self.rect.x < -80:
  19.                     #8 调用游戏结束方法
  20.                     MainGame().gameOver()
  21.     
  22.         #9 判断僵尸是否碰撞到植物，如果碰撞，调用攻击植物的方法
  23.         def hit_plant(self):
  24.             for plant in MainGame.plants_list:
  25.                 if pygame.sprite.collide_rect(self,plant):
  26.                     #8  僵尸移动状态的修改
  27.                     self.stop = True
  28.                     self.eat_plant(plant)
  29.         #9 僵尸攻击植物
  30.         def eat_plant(self,plant):
  31.             #9 植物生命值减少
  32.             plant.hp -= self.damage
  33.             #9 植物死亡后的状态修改，以及地图状态的修改
  34.             if plant.hp <= 0:
  35.                 a = plant.rect.y // 80 - 1
  36.                 b = plant.rect.x // 80
  37.                 map = MainGame.map_list[a][b]
  38.                 map.can_grow = True
  39.                 plant.live = False
  40.                 #8 修改僵尸的移动状态
  41.                 self.stop = False
  42.     
  43.     
  44.     
  45.         #9 将僵尸加载到地图中
  46.         def display_zombie(self):
  47.             MainGame.window.blit(self.image,self.rect)
  48.         
  49.         #9 新增存储所有僵尸的列表
  50.         zombie_list = []
  51.         count_zombie = 0
  52.         produce_zombie = 100     
  53.            
  54.         #9 新增初始化僵尸的方法
  55.         def init_zombies(self):
  56.             for i in range(1, 7):
  57.                 dis = random.randint(1, 5) * 200
  58.                 zombie = Zombie(800 + dis, i * 80)
  59.                 MainGame.zombie_list.append(zombie)
  60.     
  61.         #9将所有僵尸加载到地图中
  62.         def load_zombies(self):
  63.             for zombie in MainGame.zombie_list:
  64.                 if zombie.live:
  65.                     zombie.display_zombie()
  66.                     zombie.move_zombie()
  67.                     # v2.0 调用是否碰撞到植物的方法
  68.                     zombie.hit_plant()
  69.                 else:
  70.                     MainGame.zombie_list.remove(zombie)                 
  71.     
  72.         #9 调用初始化僵尸的方法
  73.             self.init_zombies()
  74.             
  75.         #9 调用展示僵尸的方法
  76.                 self.load_zombies()
  77.                 #9 计数器增长，每数到100，调用初始化僵尸的方法
  78.                 MainGame.count_zombie += 1
  79.                 if MainGame.count_zombie == MainGame.produce_zombie:
  80.                     self.init_zombies()
  81.                     MainGame.count_zombie = 0
  82.                 #9 pygame自己的休眠
  83.                 pygame.time.wait(10)    

10.游戏结束方法

   

  1.  #10 程序结束方法
  2.     def gameOver(self):
  3.         MainGame.window.blit(self.draw_text('游戏结束', 50, (255, 0, 0)), (300, 200))
  4.         pygame.time.wait(400)
  5.         global GAMEOVER
  6.         GAMEOVER = True

    

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/381604
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号