Neste artigo, aprenderemos como adicionar diferentes níveis aos nossos jogos de arcade em Python.

Adicionando Níveis

Podemos adicionar facilmente vários níveis ao nosso jogo Arcade, seguindo os passos abaixo:

• Crie uma nova variável para armazenar o nível atual.

self.level = 1

• Carregue os sprites que você vai usar no nível atual com a ajuda da variável self.level. Para este exemplo, vamos carregar sprites nomeados 'Platform1' para o nível 1, sprite nomeado 'Platform2' para o nível 2 e assim por diante. Para isso, podemos carregar as plataformas usando o código abaixo.

platform = arcade.Sprite(f"Platform{self.level}.png", 1)

• Se o jogador cruzar o lado direito da tela, vamos aumentar o valor da variável self.level para ir para o próximo nível.

 if self.player_sprite.center_x>690:
    self.level += 1

Funções usadas:

• Camera(): a classe Camera é usada para controlar a janela de exibição visível.

Sintaxe: arcade.Camera (largura, altura, janela)

Parâmetros:

• largura: largura da janela de visualização
• altura: altura da janela de visualização
• janela: janela para associar a esta câmera

• Scene(): uma classe que representa um objeto de cena.

Sintaxe: arcade.Scene (sprite_lists, name_mapping)

Parâmetros:

• sprite_lists: uma lista de objetos SpriteList
• name_mapping: Um dicionário de objetos SpriteList

• PhysicsEnginePlatformer(): mecanismo de física simplista para uso em um jogo de plataformas.

Sintaxe: arcade.PhysicsEnginePlatformer (player_sprite, plataformas, gravidade, escadas)

Parâmetros:

• player_sprite: sprite do jogador
• plataformas: os sprites pelos quais ele não pode se mover
• gravidade: aceleração para baixo por quadro
• escadas: escadas em que o usuário pode subir

Sprites usados:

No exemplo abaixo, vamos criar uma classe MainGame(). Dentro desta classe primeiro, vamos inicializar algumas variáveis ​​para velocidade, câmera, nível e sprite do jogador, em seguida, criaremos 6 funções dentro desta classe.

• on_draw(): Dentro desta função, usaremos nossa câmera e desenharemos a cena.
• setup(): Nesta função, inicializaremos nossa câmera e objeto de cena, em seguida, carregaremos nossos sprites de jogador e plataforma. Depois disso, chamaremos a função PhysicsEnginePlatformer().
• on_update(): Nesta função, vamos atualizar as coordenadas x do sprite, câmera e mecanismo de física do jogador. Também mudaremos nosso nível nesta função.
• on_key_press() e on_key_release(): Nesta função, vamos alterar o valor da variável de velocidade de acordo com a tecla do teclado que é pressionada ou solta.
• camera_move(): Nesta função, moveremos nossa câmera de acordo com a posição atual do nosso jogador.

Abaixo está a implementação:

# Importing arcade module
import arcade
  
# Creating MainGame class
class MainGame(arcade.Window):
    def __init__(self):
        super().__init__(600, 600,
                         title = "Player Movement")
  
        # Initializing a variable to store
        # the velocity of the player
        self.vel_x = 0
  
        # Creating variable for Camera
        self.camera = None
  
        # Creating variable to store current level
        self.level = 1
  
        # Creating scene object
        self.scene = None
  
        # Creating variable to store player sprite
        self.player = None
  
        # Creating variable for our game engine
        self.physics_engine = None
  
    # Creating on_draw() function to draw on the screen
    def on_draw(self):
        arcade.start_render()
  
        # Using the camera
        self.camera.use()
          
        # Drawing our scene
        self.scene.draw()
  
    def setup(self):
         # Initialize Scene object
        self.scene = arcade.Scene()
          
        # Using Camera() function
        self.camera = arcade.Camera(600, 600)
  
        # Creating different sprite lists
        self.scene.add_sprite_list("Player")
        self.scene.add_sprite_list("Platforms",
                                   use_spatial_hash=True)
  
        # Adding player sprite
        self.player_sprite = arcade.Sprite("Player.png", 1)
  
        # Adding coordinates for the center of the sprite
        self.player_sprite.center_x = 64
        self.player_sprite.center_y = 600
  
        # Adding Sprite in our scene
        self.scene.add_sprite("Player", self.player_sprite)
  
        # Adding platform sprite according to level
        platform = arcade.Sprite(f"Platform{self.level}.png", 1)
          
        # Adding coordinates for the center of the platform
        platform.center_x = 300
        platform.center_y = 32
        self.scene.add_sprite("Platforms", platform)
  
        # Creating Physics engine
        self.physics_engine = arcade.PhysicsEnginePlatformer(
            self.player_sprite, self.scene.get_sprite_list("Platforms"), 0.5
        )
  
    # Creating on_update function to
    # update the x coordinate
    def on_update(self, delta_time):
  
        # Changing x coordinate of player
        self.player_sprite.center_x += self.vel_x * delta_time
          
        # Updating the physics engine to move the player
        self.physics_engine.update()
  
        # Calling the camera_move function
        self.camera_move()
  
        # Changing level if player crosses the right
        # end of screen
        if self.player_sprite.center_x > 690:
            self.level += 1
            self.setup()
  
    # Creating function to change the velocity
    # when button is pressed
    def on_key_press(self, symbol, modifier):
  
        # Checking the button pressed
        # and changing the value of velocity
        if symbol == arcade.key.LEFT:
            self.vel_x = -300
        elif symbol == arcade.key.RIGHT:
            self.vel_x = 300
  
    # Creating function to change the velocity
    # when button is released
    def on_key_release(self, symbol, modifier):
  
        # Checking the button released
        # and changing the value of velocity
        if symbol == arcade.key.LEFT:
            self.vel_x = 0
        elif symbol == arcade.key.RIGHT:
            self.vel_x = 0
  
    def camera_move(self):
        
        # Getting the x coordinate for the center of camera
        screen_x = self.player_sprite.center_x - \
            (self.camera.viewport_width / 2)
          
        # Getting the y coordinate for the center of camera
        screen_y = self.player_sprite.center_y - \
            (self.camera.viewport_height / 2)
  
        # Moving the camera
        self.camera.move_to([screen_x, screen_y])
  
  
# Calling MainGame class
game = MainGame()
game.setup()
arcade.run()

Saída:

 Atenção geek! Fortaleça suas bases com o Python Programming Foundation Course e aprenda o básico.