【pygame实现星露谷物语风格游戏】19.收获作物

一.目的

当作物成熟后，玩家与作物发生碰撞，会触发收获作物的效果，此时作物会消失，并且会有白色的粒子效果，此外玩家背包里会多出来一份相应的作物

二.代码的完成

收割植物的函数写在level.py中，基本都是调用之前写过的函数，十分简单

接下来在run函数中不断调用这个函数即可

三.完整代码

level.py:

import pygame

from settings import *

from player import Player

from overlay import Overlay

from sprites import *

from pytmx.util_pygame import load_pygame

from support import *

from transition import Transition

from soil import SoilLayer

from sky import Rain


class Level():

    def __init__(self):

        #得到屏幕的画面，得到的这个画面与main.py中的screen相同

        self.display_surface = pygame.display.get_surface()


        #创建精灵组

        self.all_sprites = CameraGroup()

        #具有碰撞箱的精灵组

        self.collision_sprites = pygame.sprite.Group()

        #树木精灵组

        self.tree_sprites = pygame.sprite.Group()

        #特殊区域精灵组

        self.interaction_sprites = pygame.sprite.Group()


        #调用setup方法

        self.setup()

        #创建工具和种子显示图层

        self.overlay = Overlay(self.player)

        #创建transition对象

        self.transition = Transition(self.reset,self.player)


        #实例化Rain对象

        self.rain = Rain(self.all_sprites)

        #一个bool值，表示是否正在下雨，有1/10的概率为true

        self.raining = randint(0,10) > 8

        self.soil_layer.raining = self.raining


    def setup(self):


        #土地管理类

        self.soil_layer = SoilLayer(self.all_sprites,self.collision_sprites)


        #载入.tmx文件

        tmx_data = load_pygame('../data/map.tmx')


        #绘制房子与栅栏，他们都属于Generic类

        for layer in ['HouseFloor', 'HouseFurnitureBottom']:

            for x, y, surf in tmx_data.get_layer_by_name(layer).tiles():

                Generic((x * TILE_SIZE, y * TILE_SIZE), surf, self.all_sprites, LAYERS['house bottom'])


        for layer in ['HouseWalls', 'HouseFurnitureTop','Fence']:

            for x, y, surf in tmx_data.get_layer_by_name(layer).tiles():

                Generic((x * TILE_SIZE, y * TILE_SIZE), surf, [self.all_sprites, self.collision_sprites])




        #水流

        water_frames = import_folder('../graphics/water')

        for x, y, surf in tmx_data.get_layer_by_name('Water').tiles():

            Water((x * TILE_SIZE, y * TILE_SIZE), water_frames, self.all_sprites)


        #树木

        for obj in tmx_data.get_layer_by_name('Trees'):

            Tree(

                pos=(obj.x, obj.y),

                surf=obj.image,

                groups=[self.all_sprites, self.collision_sprites, self.tree_sprites],

                name=obj.name,

                player_add=self.player_add)

        #野花

        for obj in tmx_data.get_layer_by_name('Decoration'):

            WildFlower((obj.x, obj.y), obj.image,[self.all_sprites, self.collision_sprites])


        #空气墙

        for x, y, surf in tmx_data.get_layer_by_name('Collision').tiles():

            Generic((x * TILE_SIZE, y * TILE_SIZE), pygame.Surface((TILE_SIZE, TILE_SIZE)), self.collision_sprites)


        #玩家

        for obj in tmx_data.get_layer_by_name('Player'):

            if obj.name == 'Start':

                self.player = Player(

                    pos=(obj.x, obj.y),

                    group=self.all_sprites,

                    collision_sprites=self.collision_sprites,

                    tree_sprites=self.tree_sprites,

                    interaction = self.interaction_sprites,

                    soil_layer = self.soil_layer)


            if obj.name == 'Bed':

                Interaction((obj.x, obj.y), (obj.width, obj.height), self.interaction_sprites, obj.name)


        Generic(

            pos = (0,0),

            surf = pygame.image.load('../graphics/world/ground.png').convert_alpha(),

            groups = self.all_sprites,

            z = LAYERS['ground']

        )


    def run(self,dt):

        #窗口的背景设为黑色

        self.display_surface.fill('black')

        #调用精灵组的draw方法

        self.all_sprites.custom_draw(self.player)

        #调用精灵组的update方法

        self.all_sprites.update(dt)

        #收获植物

        self.plant_collision()


        self.overlay.display()


        #如果在睡觉，执行相应的函数

        if self.player.sleep:

            self.transition.play()


        #如果在下雨，就生成雨滴

        if self.raining:

            self.rain.update()


    def player_add(self, item):

        #item是一个str类型的数据，代表要对哪一种物品加一

        self.player.item_inventory[item] += 1


    def reset(self):

        #更新植物状态

        self.soil_layer.update_plants()


        # 清除农田里的水渍

        self.soil_layer.remove_water()


        #每天重新随机一下是否要下雨

        self.raining = randint(0, 10) > 8

        self.soil_layer.raining = self.raining

        #如果新的一天下雨了，就自动灌溉所有被开垦过的土地

        if self.raining:

            self.soil_layer.water_all()


        #苹果重新长在树上

        for tree in self.tree_sprites.sprites():

            for apple in tree.apple_sprites.sprites():

                apple.kill()

            tree.create_fruit()


    def plant_collision(self):

        #如果plant_sprite这个精灵组不为空

        if self.soil_layer.plant_sprites:

            #遍历精灵组中的所有精灵

            for plant in self.soil_layer.plant_sprites.sprites():

                #如果作物成熟了并且与玩家发生了碰撞

                if plant.harvestable and plant.rect.colliderect(self.player.hitbox):

                    #背包增加相应的作物

                    self.player_add(plant.plant_type)

                    #消除植物

                    plant.kill()

                    self.soil_layer.grid[plant.rect.centery // TILE_SIZE][plant.rect.centerx // TILE_SIZE].remove('P')

                    #绘制粒子效果

                    Particle(plant.rect.topleft, plant.image, self.all_sprites, z=LAYERS['main'])

class CameraGroup(pygame.sprite.Group):

    def __init__(self):

        super().__init__()

        #获取窗口

        self.display_surface = pygame.display.get_surface()

        #这是一个偏移量，代表的是玩家的实际位置与屏幕中间的矢量

        self.offset = pygame.math.Vector2()

    def custom_draw(self,player):

        self.offset.x = player.rect.centerx - SCREEN_WIDTH / 2

        self.offset.y = player.rect.centery - SCREEN_HEIGHT / 2


        for layer in LAYERS.values():#按照z轴从小到达绘制

            for sprite in sorted(self.sprites(),key = lambda sprite: sprite.rect.centery):

                if sprite.z == layer:#如果该精灵的z值等于当前要绘制的z值，才绘制

                    offset_rect = sprite.rect.copy()

                    offset_rect.center -= self.offset

                    #if sprite == player:

                        #print("player.rect.center为：（" +

                             # str(player.rect.centerx)+"，" + str(player.rect.centery)+"）")

                        #print("offset_rect为：（" + str(offset_rect.x)

                             # +"，" +str(offset_rect.y)+"）")

                    self.display_surface.blit(sprite.image,offset_rect)