Вражеский спрайт поражен и исчезает, но не исправляется позже, если его ударили по бокам - PullRequest
0 голосов
/ 09 февраля 2020

У меня есть код, решенный для этой проблемы Изображение не остается на экране после выполнения для l oop в Pygame . Поэтому я решил поставить несколько платформ в результате того, что я узнал из pygame . Я также решил заставить ковбой двигаться вправо и влево и go вниз к экрану .

Но когда происходит столкновение справа или слева от ковбоя, как показано на Диаграмме , class PlayerShip не выполняется должным образом в main l oop через функцию def draw_reaction () , потому что я не вижу изображения ковбоя , представленного player_sprite, зафиксированного в положении (60, 48). Это работает правильно только если ковбой поражен снизу .

Активы

missile.png

ковбой .png

Police.png

Диаграмма:

|missile| <--<-- (is touched its right side by the missile)|cowboy| <--<-- direction

   ^
   |
   ^
   | 
(fire missile direction vertical)
   ^
   |
   d
   i
   r
   e
   c
   t
   i
   o
   n

Моя кодировка MWE:

import pygame
import random

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
PURPLE = (255, 0, 255)
GRAY = (128,128,128)
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


class PlayerShip( pygame.sprite.Sprite ):
    def __init__(self):
        super().__init__()
        self.image = pygame.image.load( "cowboy.png" )
        self.image.set_colorkey(BLACK) 
        self.rect  = self.image.get_rect()
        self.rect.topleft = ( 60, 48 ) 
player_sprite = PlayerShip() 


class Platform(pygame.sprite.Sprite):


    def __init__(self, width, height):
        super().__init__()

        self.image = pygame.Surface([width, height])
        self.image.fill(GREEN)

        self.rect = self.image.get_rect()


class MovingPlatform(Platform):

    change_x = 0
    change_y = 0

    boundary_top = 0
    boundary_bottom = 0
    boundary_left = 0
    boundary_right = 0

    player = None

    level = None

    def update(self):
        self.rect.x += self.change_x

        hit = pygame.sprite.collide_rect(self, self.player)
        if hit:

            if self.change_x < 0:
                self.player.rect.right = self.rect.left
            else:
                self.player.rect.left = self.rect.right

        self.rect.y += self.change_y


        hit = pygame.sprite.collide_rect(self, self.player)
        if hit:
            if self.change_y < 0:
                self.player.rect.bottom = self.rect.top
            else:
                self.player.rect.top = self.rect.bottom

        if self.rect.bottom > self.boundary_bottom or self.rect.top < self.boundary_top:
            self.change_y *= -1

        cur_pos = self.rect.x - self.level.world_shift
        if cur_pos < self.boundary_left or cur_pos > self.boundary_right:
            self.change_x *= -1


class Level(object):
    def __init__(self, player):
        self.platform_list = pygame.sprite.Group()
        self.enemy_list = pygame.sprite.Group()
        self.player = player

        self.background = None

        self.world_shift = 0
        self.level_limit = -1000

    def update(self):
        self.platform_list.update()
        self.enemy_list.update()

    def draw(self, screen):
        screen.fill(GRAY)

        self.platform_list.draw(screen)
        self.enemy_list.draw(screen)

    def shift_world(self, shift_x):
        self.world_shift += shift_x

        for platform in self.platform_list:
            platform.rect.x += shift_x

        for enemy in self.enemy_list:
            enemy.rect.x += shift_x

class Room(object):
    wall_list = None
    enemy_sprites = None

    def __init__(self):

        self.wall_list = pygame.sprite.Group()
        self.enemy_sprites = pygame.sprite.Group()


class Level_01(Level):
    def __init__(self, player):
        Level.__init__(self, player)

        self.level_limit = -1500

        level = [[210, 70, 500, 500],
                 [210, 70, 800, 400],
                 [210, 70, 1000, 500],
                 [210, 70, 1120, 280],
                 [210, 70, -120, 500],
                 ]

        for platform in level:
            block = Platform(platform[0], platform[1])
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)


        block = MovingPlatform(70, 40)
        block.rect.x = 1350
        block.rect.y = 280
        block.boundary_left = 1350
        block.boundary_right = 1600
        block.change_x = 10
        block.player = self.player
        block.level = self
        self.platform_list.add(block)



class Level_02(Level):


    def __init__(self, player):



        Level.__init__(self, player)

        self.level_limit = -1000


        level = [[210, 70, 500, 550],
                 [210, 70, 800, 400],
                 [210, 70, 1000, 500],
                 [210, 70, 1120, 280],
                 ]


        for platform in level:
            block = Platform(platform[0], platform[1])
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)


        block = MovingPlatform(70, 70)
        block.rect.x = 1500
        block.rect.y = 300
        block.boundary_top = 100
        block.boundary_bottom = 550
        block.change_y = -1
        block.player = self.player
        block.level = self
        self.platform_list.add(block)




class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()

        width = 40
        height = 60
        self.image = pygame.image.load("police.png").convert()

        self.rect = self.image.get_rect()
        self.image.set_colorkey(BLACK) 


        self.rect = self.image.get_rect()


        self.change_x = 0
        self.change_y = 0


        self.level = None

    def update(self):
        self.calc_grav()

        self.rect.x += self.change_x

        block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False)
        for block in block_hit_list:
            if self.change_x > 0:
                self.rect.right = block.rect.left
            elif self.change_x < 0:

                self.rect.left = block.rect.right
        self.change_y += 0


        self.rect.y += self.change_y


        block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False)
        for block in block_hit_list:


            if self.change_y > 0:
                self.rect.bottom = block.rect.top
            elif self.change_y < 0:
                self.rect.top = block.rect.bottom


            self.change_y = 0

            if isinstance(block, MovingPlatform):
                self.rect.x += block.change_x

    def calc_grav(self):

        if self.change_y == 0:
            self.change_y = 1
        else:
            self.change_y += .35


        if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0:
            self.change_y = 0
            self.rect.y = SCREEN_HEIGHT - self.rect.height

    def jump(self):


        self.rect.y += 2
        platform_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False)
        self.rect.y -= 2


        if len(platform_hit_list) > 0 or self.rect.bottom >= SCREEN_HEIGHT:
            self.change_y = -10


    def go_left(self):

        self.change_x = -6

    def go_right(self):

        self.change_x = 6

    def stop(self):

        self.change_x = 0
class Cowboy(pygame.sprite.Sprite):
      def __init__(self):
          super().__init__()
          self.image = pygame.image.load("cowboy.png").convert()
          self.rect = self.image.get_rect()
          self.image.set_colorkey(BLACK) 

class Missile(pygame.sprite.Sprite):
      def __init__(self):
          super().__init__()
          self.image = pygame.image.load("missile.png").convert()
          self.image.set_colorkey(BLACK) 
          self.rect = self.image.get_rect()
      def update(self):
         self.rect.y += -3

def main():
    pygame.init()


    size = [SCREEN_WIDTH, SCREEN_HEIGHT]
    screen = pygame.display.set_mode(size)
    block_list = pygame.sprite.Group()
    all_sprites_list = pygame.sprite.Group()
    bullet_list = pygame.sprite.Group() 
    pygame.display.set_caption("Platformer with moving platforms")
    apple = pygame.image.load("missile.png").convert()
    block = Cowboy()
    player_image = pygame.image.load("cowboy.png").convert()


    player = Player()


    level_list = []
    level_list.append(Level_01(player))
    level_list.append(Level_02(player))


    current_level_no = 0
    current_level = level_list[current_level_no]
    block_list.add(block)
    all_sprites_list.add(block)
    all_sprites_list.add(player)

    active_sprite_list = pygame.sprite.Group()
    player.level = current_level

    player.rect.x = 340
    player.rect.y = SCREEN_HEIGHT - player.rect.height
    active_sprite_list.add(player)


    done = False


    clock = pygame.time.Clock()
    x_speed = 0
    y_speed = 0

    rect_x = 50
    rect_y = 50
    rect_change_x = 1
    rect_change_y = 90
    x = rect_x

    y = rect_y
    player.rect.y = rect_x

    player.rect.y = 480
    score = 0
    size = (1366, 768)
    screen = pygame.display.set_mode(size, pygame.RESIZABLE) 
    while not done:
        x += x_speed
        y += y_speed
        rect_x += rect_change_x

        if rect_x > 280:
           rect_change_x *= -1
           rect_x += rect_change_x
           rect_y += rect_change_y
        if rect_x < 0:
           rect_change_x *= -1
           rect_x += rect_change_x
           rect_y += rect_change_y       

        block.rect.x = rect_x
        block.rect.y = rect_y



        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                done = True

            elif event.type == pygame.MOUSEBUTTONDOWN:

                bullet = Missile()

                bullet.rect.x = player.rect.x
                bullet.rect.y = player.rect.y

                all_sprites_list.add(bullet)
                bullet_list.add(bullet)

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    player.go_left()
                if event.key == pygame.K_RIGHT:
                    player.go_right()
                if event.key == pygame.K_UP:
                    player.jump()

            if event.type == pygame.KEYUP:
                if event.key == pygame.K_LEFT and player.change_x < 0:
                    player.stop()
                if event.key == pygame.K_RIGHT and player.change_x > 0:
                    player.stop()

        for bullet in bullet_list:
            block_hit_list = pygame.sprite.spritecollide(bullet, block_list, True)
            for block in block_hit_list:
                bullet_list.remove(bullet)
                all_sprites_list.remove(bullet)
                score += 1
                print(score)
                screen.blit(player_image, [60, 48]) 
            if bullet.rect.y < -10:
               bullet_list.remove(bullet)
               all_sprites_list.remove(bullet)
        def draw_reaction():
            for bullet in bullet_list:
                block_hit_list = pygame.sprite.spritecollide(bullet, block_list, True)
                for block in block_hit_list:
                    all_sprites_list.add( player_sprite )
                    break
        all_sprites_list.update()

        active_sprite_list.update()


        current_level.update()


        if player.rect.right >= 1500:
            diff = player.rect.right - 500
            player.rect.right = 500
            current_level.shift_world(-diff)


        if player.rect.left <= 120: 
            diff = 120 - player.rect.left 
            player.rect.left = 120 
            current_level.shift_world(diff)


        current_position = player.rect.x + current_level.world_shift
        if current_position < current_level.level_limit:
            if current_level_no < len(level_list)-1:
                player.rect.x = 120
                current_level_no += 1
                current_level = level_list[current_level_no]
                player.level = current_level
            else:
                done = True


        current_level.draw(screen)
        active_sprite_list.draw(screen)
        x += x_speed
        y += y_speed
        all_sprites_list.draw(screen)
        draw_reaction()




        clock.tick(60)


        pygame.display.flip()

    pygame.quit()

if __name__ == "__main__":
    main()

ОБНОВЛЕНИЕ ОБНОВЛЕНИЯ: Если current_level.draw(screen) не используется в главном l oop, тогда код работает должным образом. Но я до сих пор не знаю, чем это вызвано.

1 Ответ

0 голосов
/ 09 февраля 2020

Я просто добавил all_sprites_list.add (player_sprite) к for block in block_hit_list:. На мой взгляд, это было бы необходимо для отслеживания self.image.get_rect (). Затем:

До:

for bullet in bullet_list:
    block_hit_list = pygame.sprite.spritecollide(bullet, block_list, True)
    for block in block_hit_list:
        bullet_list.remove(bullet)
        all_sprites_list.remove(bullet)
        score += 1
        print(score)
        screen.blit(player_image, [60, 48]) 
    if bullet.rect.y < -10:
       bullet_list.remove(bullet)
       all_sprites_list.remove(bullet)

Позже:

for bullet in bullet_list:
            block_hit_list = pygame.sprite.spritecollide(bullet, block_list, True)
            for block in block_hit_list:
                all_sprites_list.add(player_sprite)     
                bullet_list.remove(bullet)
                all_sprites_list.remove(bullet)
                score += 1
                print(score)
                screen.blit(player_image, [60, 48]) 
            if bullet.rect.y < -10:
               bullet_list.remove(bullet)
               all_sprites_list.remove(bullet)

Но я бы хотел, чтобы кто-то объяснил мне, как это на самом деле произошло за кодом, сделав более опытным ссылки на документацию или стиль самого кода. Благодарен, если кто-нибудь может дать такое объяснение.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...