Como zerar o contador de mortes, maior numero de mortes, ultima quantidades de mortes, executar um SPRITE ao apertar o botão de ataque e botão de pulo. pygame

SEAL ADVENTURE - JOGO 1º SEMESTRE

GRUPO 3

CAIO GUIMARÃES SA SILVA

MARCO AURÉLIO SODRÉ

SAMIRA DE BARROS CAVALCANTE

TAIGUARA TALES DA SILVA VITORINO

import pygame
from pygame.locals import* #
import math, random, sys, os

class Game():
def init(self):
pygame.init()
pygame.display.set_caption(“Seal Adventure”)
self.running, self.playing = True, False
self.UP_KEY, self.DOWN_KEY, self.START_KEY, self.BACK_KEY = False, False, False, False
self.DISPLAY_W, self.DISPLAY_H = 800, 600 # Tamanho da tela
self.display = pygame.Surface((self.DISPLAY_W,self.DISPLAY_H))
self.window = pygame.display.set_mode(((self.DISPLAY_W,self.DISPLAY_H)))
self.font_name = ‘fonte/PressStart2P-vaV7.ttf’
#self.font_name = pygame.font.get_default_font()
self.BLACK,self. BLUE = (0, 0, 0), (63, 255, 223) #Definindo cores
self.main_menu = MainMenu(self) #Classes
self.options = OptionsMenu(self)
self.credits = CreditsMenu(self)
self.curr_menu = self.main_menu

def game_loop(self):
    while self.playing:
        self.check_events()
        if self.START_KEY:
            self.playing= False

#INICIO
# # # CONFIGURAÇÕES DE TELA ------------------------------------------------------------------
larguraTela, alturaTela = 1000, 500
metadeLargura = larguraTela / 2
metadeAltura = alturaTela / 2
areaTela = larguraTela * alturaTela
tela = pygame.display.set_mode((larguraTela, alturaTela))
bg = pygame.image.load(“Cenario/cenariogelo.jpeg”)
background = pygame.transform.scale(bg, (larguraTela, alturaTela))
pygame.display.set_caption(“Seal Adventure”)

        pygame.init()
        CLOCK = pygame.time.Clock()
        FPS = 45
        BLACK = (0, 0, 0)


        # # # MUSICA DO JOGO -----------------------------------------------------------------------------------

        pygame.mixer.music.load('Musicas/Snow02.ogg')
        pygame.mixer.music.play(-1)

        # # # PERSONAGEM ---------------------------------------------------------------------------------
        scale_hero=[100,100]
        left = [pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'desenhoesquerda.png')),(scale_hero)),
                pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'correndo 2.0.png')),(scale_hero)),
                pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'correndo 3.0.png')),(scale_hero)),
                pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'pertras1.png')),(scale_hero))
                ]
        right = [pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'desenho.png')),(scale_hero)),
                 pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'correndo 2.png')),(scale_hero)),
                 pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'correndo 3.png')),(scale_hero)),
                 pygame.transform.scale(pygame.image.load(os.path.join('Personagens', 'perfren1.png')),(scale_hero))
                 ]

        scale_bullet=[35,35]
        bullet_img = pygame.transform.scale(pygame.image.load(os.path.join('Bullets', 'poder.png')), (scale_bullet))
        x = 100
        y = 395
        radius = 80
        vel = 5
        move_left = False
        move_right = False
        stepIndex = 0

        class Hero:
            def __init__(self, x, y):
                # walk
                self.x = x
                self.y = y
                self.velx = 6
                self.vely = 15
                self.face_right = True
                self.face_left = False
                self.stepIndex = 0
                # Jump
                self.jump = False
                # Bullet
                self.bullets = []
                self.cool_down_count = 0
                # Health
                self.hitbox = (self.x, self.y, 64, 64)
                self.health = 40
                self.lives = 1
                self.alive = True
                # kills
                #self.kills = 0


            def move_hero(self, userInput):
                if userInput[pygame.K_RIGHT] and self.x <= larguraTela - radius:
                    self.x += self.velx
                    self.face_right = True
                    self.face_left = False
                elif userInput[pygame.K_LEFT] and self.x >= 0:
                    self.x -= self.velx
                    self.face_right = False
                    self.face_left = True
                else:
                    self.stepIndex = 0

            def draw(self, tela):
                self.hitbox = (self.x, self.y, 78, 90)
                pygame.draw.rect(tela, (255, 0, 0), (self.x + 30, self.y - 10, 40, 10))
                if self.health >= 0:
                    pygame.draw.rect(tela, (0, 255, 0), (self.x + 30, self.y - 10, self.health, 10))
                if self.stepIndex >= 16:
                    self.stepIndex = 0
                if self.face_left:
                    tela.blit(left[self.stepIndex // 4], (self.x, self.y))
                    self.stepIndex += 1
                if self.face_right:
                    tela.blit(right[self.stepIndex // 4], (self.x, self.y))
                    self.stepIndex += 1

            def jump_motion(self, userInput):
                if userInput[pygame.K_SPACE] and self.jump is False:
                    jumpvar = pygame.mixer.Sound('Musicas/SFX_Jump_17.wav')
                    jumpvar.play()
                    self.jump = True
                if self.jump:
                    self.y -= self.vely * 2
                    self.vely -= 1
                if self.vely < -15:
                    self.jump = False
                    self.vely = 15

            def direction(self):
                if self.face_right:
                    return 1
                if self.face_left:
                    return -1

            def cooldown(self):
                if self.cool_down_count >= 20:
                    self.cool_down_count = 0
                elif self.cool_down_count > 0:
                    self.cool_down_count += 1

            def shoot(self):
                self.hit()
                self.cooldown()
                if (userInput[pygame.K_f] and self.cool_down_count == 0):

                    shootvar=pygame.mixer.Sound('Musicas/fogo.wav')
                    shootvar.play()

                    bullet = Bullet(self.x, self.y, self.direction())
                    self.bullets.append(bullet)
                    self.cool_down_count = 1
                    #scale_hero = [100, 100]
                    ataque = pygame.image.load(os.path.join('Personagens', 'ataque.png'))

                    tela.blit(ataque, (90,90))
                for bullet in self.bullets:
                    bullet.move()
                    if bullet.off_screen():
                        self.bullets.remove(bullet)

            def hit(self):
                for enemy in enemies:
                    for bullet in self.bullets:
                        if enemy.hitbox[0] < bullet.x < enemy.hitbox[0] + enemy.hitbox[2] and enemy.hitbox[
                            1] < bullet.y < enemy.hitbox[1] + enemy.hitbox[3]:
                            dano = pygame.image.load(os.path.join('Personagens', 'dano.png'))
                            tela.blit(dano, (100, 100))
                            enemy.health -= 25
                            player.bullets.remove(bullet)



        class Bullet:
            def __init__(self, x, y, direction):
                self.x = x + 70
                self.y = y + 30
                self.direction = direction

            def draw_bullet(self):
                tela.blit(bullet_img, (self.x, self.y))

            def move(self):
                if self.direction == 1:
                    self.x += 15
                if self.direction == -1:
                    self.x -= 15

            def off_screen(self):
                return not (self.x >= 0 and self.x <= larguraTela)

        # INIMIGO ----------------------------------------------------------------------------------------
        scale_enimy=[100,100]
        left_enemy = [pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIM1.png')),(scale_enimy)),
                      pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIMATAQUE1.png')),(scale_enimy)),
                      pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIM1.png')),(scale_enimy)),
                      pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIMATAQUE1.png')),(scale_enimy))
                      ]
        right_enemy = [pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIM1.0.png')),(scale_enimy)),
                       pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIMATAQUE1.0.png')),(scale_enimy)),
                       pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIM1.0.png')),(scale_enimy)),
                       pygame.transform.scale(pygame.image.load(os.path.join('Inimigos', 'PINGUIMATAQUE1.0.png')),(scale_enimy))
                       ]

        class Enemy:
            def __init__(self, x, y, direction):
                self.x = x
                self.y = y
                self.direction = direction
                self.stepIndex = 0
                # Health
                self.hitbox = (self.x, self.y, 64, 64)
                self.health = 40
                self.kills=0
                #self.ultimakills=0

            def step(self):
                if self.stepIndex >= 32:
                    self.stepIndex = 0

            def draw(self, tela):
                self.hitbox = (self.x, self.y, 78, 90)
                pygame.draw.rect(tela, (255, 0, 0), (self.x + 20, self.y - 10, 40, 10))
                if self.health >= 0:
                    pygame.draw.rect(tela, (0, 255, 0), (self.x + 20, self.y - 10, self.health, 10))
                self.step()
                if self.direction == left:
                    tela.blit(left_enemy[self.stepIndex // 8], (self.x, self.y))
                if self.direction == right:
                    tela.blit(right_enemy[self.stepIndex // 8], (self.x, self.y))
                self.stepIndex += 1

            def move(self):
                self.hit()
                if self.direction == left:
                    self.x -= 10
                if self.direction == right:
                    self.x += 9

            def hit(self):
                if player.hitbox[0] < enemy.x + 32 < player.hitbox[0] + player.hitbox[2] and player.hitbox[1] < enemy.y + 32 < player.hitbox[1] + player.hitbox[3]:
                    if player.health > 0:
                        player.health -= 1
                        if player.health == 0 and player.lives > 0:
                            player.lives -= 1
                            player.health = 40
                        elif player.health == 0 and player.lives == 0:
                            player.alive = False

            def off_screen(self):
                return not (self.x >= -80 and self.x <= larguraTela + 30)

        # # # FUNÇÃO TELA ------------------------------------------------------------------------------
        def draw_game():

            tela.fill(BLACK)
            tela.blit(background, (0, 0))
            # Draw Playerf
            player.draw(tela)

            # Draw Bullets
            for bullet in player.bullets:
                bullet.draw_bullet()
            # Draw Enemies
            for enemy in enemies:
                enemy.draw(tela)
            # Player Health

            if player.alive == False:
                tela.fill((0, 0, 0))

                SCALE_FUNDO=[1000,500]
                SCALE_FUNDO= pygame.transform.scale(pygame.image.load(os.path.join('Cenario/menu.jpeg')), (SCALE_FUNDO))
                tela.blit(SCALE_FUNDO, (0,0))
                font = pygame.font.Font('fonte/PressStart2P-vaV7.ttf', 32)
                text = font.render('GAME OVER! pressione R', True, (138, 47, 47))
                textRect = text.get_rect()
                textRect.center = (metadeLargura, metadeAltura)
                tela.blit(text, textRect)
                #self.game.display.blit(menuprincipal2, (0, 0))  # Preenchendo tela com imagem






            if userInput[pygame.K_r]:
                player.alive = True
                player.lives = 1
                player.health = 40
                #kills = 0

            font = pygame.font.Font('fonte/PressStart2P-vaV7.ttf', 27)
            text = font.render('Mortos: ' + str(kills) + '  Vidas: ' + str(player.lives), True, (63, 255, 223))
            # text2 = font.render('Última pontuação de mortes: ' + str(ultimakills) , True, (63, 255, 223))
            # text3 = font.render('Recorde de mortes: ' + str(highkills) , True, (63, 255, 223))

            tela.blit(text, (180, 20))
            #tela.blit(text2, (180, 55))
            #tela.blit(text3, (180, 90))

            pygame.display.update()

            CLOCK.tick(FPS)


       # ultimakills=0
        #highkills=kills
        #contador = kills
        player = Hero(250, 320)
        enemies = []
        kills=0







        # # # LOOP ------------------------------------------------------------------------
        run = True
        while run:

            # # # FECHAR TELA ------------------------------------------------------------
            for i in pygame.event.get():
                if i.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
            # Input
            userInput = pygame.key.get_pressed()

            # shoot
            player.shoot()

            # Movement
            player.move_hero(userInput)
            player.jump_motion(userInput)

            # # # CONTROLE INIMIGOS
            if len(enemies) == 0:
                rand_nr = random.randint(0, 1)
                if rand_nr == 1:
                    enemy = Enemy(1010, 320, left)
                    enemies.append(enemy)
                if rand_nr == 0:
                    enemy = Enemy(0, 320, right)
                    enemies.append(enemy)
            for enemy in enemies:
                enemy.move()


                if enemy.off_screen() or enemy.health <= 0:
                    enemies.remove(enemy)
                if enemy.health <= 0:
                    kills += 1



            # Draw game in windows
            draw_game()

#FIM


def check_events(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            self.running, self.playing = False, False
            self.curr_menu.run_display = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RETURN:
                self.START_KEY = True
            if event.key == pygame.K_BACKSPACE or event.key == pygame.K_ESCAPE:
                self.BACK_KEY = True
            if event.key == pygame.K_DOWN or event.key == pygame.K_s:
                self.DOWN_KEY = True
            if event.key == pygame.K_UP or event.key == pygame.K_w:
                self.UP_KEY = True

def reset_keys(self):
    self.UP_KEY, self.DOWN_KEY, self.START_KEY, self.BACK_KEY = False, False, False, False

def draw_text(self, text, size, x, y ): #Cor da letra, tamanho
    font = pygame.font.Font(self.font_name,size)
    text_surface = font.render(text, True, self.BLUE)
    text_rect = text_surface.get_rect()
    text_rect.center = (x,y)
    self.display.blit(text_surface,text_rect)

class Menu():
def init(self, game):
self.game = game
self.mid_w, self.mid_h = self.game.DISPLAY_W / 2, self.game.DISPLAY_H / 2
self.run_display = True
self.cursor_rect = pygame.Rect(0, 0, 130, 130)
self.offset = - 100

def draw_cursor(self):
    self.game.draw_text('▶', 20, self.cursor_rect.x, self.cursor_rect.y)

def blit_screen(self):
    self.game.window.blit(self.game.display, (0, 0))
    pygame.display.update()
    self.game.reset_keys()

class MainMenu(Menu):
def init(self, game):
Menu.init(self, game)
self.state = “Iniciar”
self.startx, self.starty = self.mid_w, self.mid_h+80
self.tutorialx, self.tutorialy = self.mid_w, self.mid_h + 120
self.creditsx, self.creditsy = self.mid_w, self.mid_h + 160
self.exitx, self.exity = self.mid_w, self.mid_h + 200
self.cursor_rect.midtop = (self.startx + self.offset, self.starty)

def display_menu(self):  # Aparência do Menu
    self.run_display = True

    menuprincipal = pygame.image.load('Cenario/menu.jpeg')
    menuprincipal2 = pygame.transform.scale(menuprincipal, (800, 600))


    pygame.mixer.music.load('Musicas/prologue.mp3')
    pygame.mixer.music.play(-1)

    while self.run_display:

        self.game.check_events()
        self.check_input()
        self.game.display.blit(menuprincipal2,(0,0)) # Preenchendo tela com imagem

        self.game.draw_text("Jogar", 20, self.startx, self.starty)
        self.game.draw_text("Como Jogar?", 20, self.tutorialx, self.tutorialy)
        self.game.draw_text("Créditos", 20, self.creditsx, self.creditsy)
        self.game.draw_text("Sair", 20, self.exitx, self.exity)
        self.game.draw_text("Voltar: ESC", 10, self.mid_w - 200, self.mid_h + 260)
        self.game.draw_text("Avançar: Enter", 10, self.mid_w + 200, self.mid_h + 260)
        self.draw_cursor()
        self.blit_screen()

def move_cursor(self):  # Movimentação do Cursor (Setinha)
    if self.game.DOWN_KEY:  # Usando seta pra baixo
        if self.state == 'Iniciar':
            self.cursor_rect.midtop = (self.tutorialx + self.offset, self.tutorialy)
            self.state = 'Como Jogar?'
        elif self.state == 'Como Jogar?':
            self.cursor_rect.midtop = (self.creditsx + self.offset, self.creditsy)
            self.state = 'Créditos'
        elif self.state == 'Créditos':
            self.cursor_rect.midtop = (self.exitx + self.offset, self.exity)
            self.state = 'Sair'
        elif self.state == 'Sair':
            self.cursor_rect.midtop = (self.startx + self.offset, self.starty)
            self.state = 'Iniciar'
    elif self.game.UP_KEY:  # Usando ceta pra cima
        if self.state == 'Iniciar':
            self.cursor_rect.midtop = (self.exitx + self.offset, self.exity)
            self.state = 'Sair'
        elif self.state == 'Sair':
            self.cursor_rect.midtop = (self.creditsx + self.offset, self.creditsy)
            self.state = 'Créditos'
        elif self.state == 'Como Jogar?':
            self.cursor_rect.midtop = (self.startx + self.offset, self.starty)
            self.state = 'Iniciar'
        elif self.state == 'Créditos':
            self.cursor_rect.midtop = (self.tutorialx + self.offset, self.tutorialy)
            self.state = 'Como Jogar?'

def check_input(self):
    self.move_cursor()
    if self.game.START_KEY:
        if self.state == 'Iniciar':
            self.game.playing = True
        elif self.state == 'Como Jogar?':
            self.game.curr_menu = self.game.options
        elif self.state == 'Créditos':
            self.game.curr_menu = self.game.credits
        elif self.state == 'Sair':
            self.game.exiting = sys.exit()
        self.run_display = False

class OptionsMenu(Menu):
def init(self, game):
Menu.init(self, game)
self.arrowx, self.arrowy = self.mid_w, self.mid_h + 0
self.rightx, self.righty = self.mid_w, self.mid_h + 60
self.leftx, self.lefty = self.mid_w, self.mid_h + 90
self.shotx, self.shoty = self.mid_w, self.mid_h + 120
self.shotz, self.shoth = self.mid_w, self.mid_h + 150

def display_menu(self):

    self.run_display = True

    menuprincipal = pygame.image.load('Cenario/menu.jpeg')
    menuprincipal2 = pygame.transform.scale(menuprincipal, (800, 600))
    self.game.display.blit(menuprincipal2, (0, 0))  # Preenchendo tela com imagem

    while self.run_display:

        self.game.check_events()
        self.check_input()
        self.game.display.fill((0, 0, 0))
        self.game.display.blit(menuprincipal2, (0, 0))  # Preenchendo tela com imagem
        self.game.draw_text('Tutorial', 40, self.game.DISPLAY_W / 2, self.game.DISPLAY_H / 2 - 120)
        self.game.draw_text("Teclado", 30, self.arrowx, self.arrowy)
        self.game.draw_text("Andar para Direita:  →", 15, self.rightx, self.righty)
        self.game.draw_text("Andar para Esquerda: ←", 15, self.leftx, self.lefty)
        self.game.draw_text("Disparar Tiro:  F", 15, self.shotx, self.shoty)
        self.game.draw_text("Pular:  Barra de Espaço", 15, self.shotz, self.shoth)
        self.game.draw_text("Voltar: ESC", 10, self.mid_w - 200, self.mid_h + 260)
        self.game.draw_text("Avançar: Enter", 10, self.mid_w + 200, self.mid_h + 260)
        self.blit_screen()

def check_input(self):
    if self.game.BACK_KEY:
        self.game.curr_menu = self.game.main_menu
        self.run_display = False
    elif self.game.START_KEY:
        pass

class CreditsMenu(Menu):
def init(self, game):
Menu.init(self, game)

def display_menu(self):
    self.run_display = True
    menuprincipal = pygame.image.load('Cenario/menu.jpeg')
    menuprincipal2 = pygame.transform.scale(menuprincipal, (800, 600))

    while self.run_display:
        self.game.check_events()
        if self.game.START_KEY or self.game.BACK_KEY:
            self.game.curr_menu = self.game.main_menu
            self.run_display = False
        self.game.display.fill(self.game.BLACK)
        self.game.display.blit(menuprincipal2, (0, 0))  # Preenchendo tela com imagem
        self.game.draw_text('CRIADORES DO SEAL ADVENTURE', 20, self.game.DISPLAY_W / 2, self.game.DISPLAY_H / 4 - 20)
        self.game.draw_text('CAIO GUIMARÃES SA SILVA', 15, self.game.DISPLAY_W / 2, self.game.DISPLAY_H / 2 + 10)
        self.game.draw_text('MARCO AURÉLIO SODRÉ', 15, self.game.DISPLAY_W / 2, self.game.DISPLAY_H / 2 + 30)
        self.game.draw_text('SAMIRA DE BARROS CAVALCANTE FIGUEIREDO', 15, self.game.DISPLAY_W / 2, self.game.DISPLAY_H / 2 + 50)
        self.game.draw_text('TAIGUARA TALES DA SILVA VITORINO', 15, self.game.DISPLAY_W / 2, self.game.DISPLAY_H / 2 + 70)
        self.game.draw_text("Voltar: ESC", 10, self.mid_w - 200, self.mid_h + 260)
        self.game.draw_text("Avançar: Enter", 10, self.mid_w + 200, self.mid_h + 260)
        self.blit_screen()

def check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running, self.playing = False, False
self.curr_menu.run_display = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
self.START_KEY = True
if event.key == pygame.K_BACKSPACE or event.key == pygame.K_ESCAPE:
self.BACK_KEY = True
if event.key == pygame.K_DOWN or event.key == pygame.K_s:
self.DOWN_KEY = True
if event.key == pygame.K_UP or event.key == pygame.K_w:
self.UP_KEY = True

INICIALIDADOR DO JOGO

g = Game()

while g.running:
g.curr_menu.display_menu()
g.game_loop()

Gostaria de algumas ajuda ,do arquivo abaixo:

1º - Não estou conseguindo zerar o contador de mortes, quando se inicia uma nova partida. Contador fica acumulado.

2º - Não estou conseguindo executar um sprite ,quando eu aperto o botão de pulo (space) e o botão de ataque (Tecla F).

3º - Não estou conseguindo fazer o placar de mais mortes e última quantidade de mortes.