Criando Jogo com Python - Pygame - Parte 3 - Game class e primeiro sprite

[haunter224]

Criando Jogo com Python - Game class e primeiro sprite​

Para quem chegou agora neste tópico, não deixe de rever os tutoriais anteriores

Preparar ambiente para python - pygame
Primeira janela do jogo

Continuando com o tutorial,

Primeiro vamos criar algumas pastas dentro do nosso projecto
Vamos criar uma pasta com o nome de  res.
Dentro dessa pasta vamos criar mais 2 pastas audio e graphics.
E agora dentro da pasta graphics vamos criar mais 4 pastas  backgrounds , charaters, tilesets, images

Ficando assim
-res
  -- audio
  -- graphics
      -- backgrounds
      -- characters
      -- tilesets
      -- images

vamos adicionar a imagem que está em anexo na pasta images com o nome de condado_logo.png

agora que criamos a estrutura do nosso protejo, vamos passar ao código

vamos criar mais 2 arquivos no root do protejo,  game.py e graphics.py

Començando com o game.py

__author__ = 'Fabio almeida'
__version__ = "0.1"
__description__ = "Class GAME, classe responsavel por tratar de todo o jogo"

import pygame
import graphics
import os

class Game:

    # Construtor da class Game
    # aqui defenimos todas as variaveis de instancia
    # no python basta crialas dentro do __init__ usando a palavra self
    def __init__(self, width=800, height=600, title="Condado Breaveheart", fullscreen=True):
        pass

    def update(self, gametime=None):
      pass

    def draw(self, surface=None):
      pass

    def tick(self, fps):
       pass

    def get_last_gametime(self):
        return 0

    def load_content(self):
        pass

    def unload_content(self):
        pass

Nota: a palavra pass serve para fechar um bloco sem código

Agora vamos criar o escleto do graphics.py

__author__ = 'Fabio almeida'
__version__ = "0.1"
__description__ = "Modulo graphics, modulo responsavel por tratar dos graphicos do jogo"

import pygame

class Graphics:

    def __init__(self, width, height, title):
        pass

    def update(self):
        pass

    def fullscreen(self,fullscreen):
        pass

    def bitmap(self):
        return self.surface

feito isto vamos então começar a adicionar código a nossa classe game. No nosso def __init__(self):
vamos adicionar as seguintes linhas, ficando assim.

def __init__(self, width=800, height=600, title="Condado Breaveheart", fullscreen=True):
        # criamos o nosso objeto Graphics
        self.Graphics = graphics.Graphics(width, height, title)

        # verificamos se apresentamos em fullscreen ou janela
        if fullscreen:
            pygame.display.toggle_fullscreen()
        # criamos um objeto clock para tratarmos os fps do nosso jogo
        self.clock = pygame.time.Clock()
        # iniciamos esta flag para verdadeiro, assim para fecharmos o processo do jogo
        # basta defenir esta variavel como False
        self.running = True

Dentro do update vamos escrever algumas linhas, para este tutorial o update não será usado mas ja fica para o proximo tutorial

def update(self, gametime=None):
        if gametime is None:
            gametime = self.get_last_gametime()

Para já , não precisamos mais nada no nosso script game.py.

Vamos então codificar o nosso modulo graphics.py.
Inicialmente este modulo será bem basico mas mais para a frente será um dos modulos mais importantes
Começando com o def __init__(self):

def __init__(self, width, height, title):
        self.surface = pygame.display.set_mode((width, height), pygame.HWSURFACE)
        pygame.display.set_caption(title)
        pygame.display.flip()

agora no update temos que trocar o buffer de escrita, para o apresentarmos ao ecrâ

def update(self):
        pygame.display.update()

Vamos agora alterar de novo o nosso __main__.py para usarmos as classes que criamos
na parte onde importamos os modulos, vamos adicionar o nosso modulo game.py.
Ficando assim:

# importamos os modulos necessarios
import pygame
import sys
import game

Agora entre o try: e o while True, vamos apagar e escrever o seguinte

    # como disse anteriormente ao importarmos um modulo(script python)
    # esse modulo fica disponível ao nosso script pelo nome dele
    # então para acessarmos a class Game devemos chamar game.Game(args, kwargs)
    # args sao os parametros pela ordem inderida
    # kwargs sao os parametros com nome
    # no caso do game eu defeni os argumentos para semrem kwargs mas podemos
    # invocar os args vou deixar aqui os 2 exemplos

    # remover o # para usarem este construtor
    # meu_game = game.Game(800,600,"Meu primeiro jogo", False)

    # como podem ver abaixo ao usarmos kwargs nao importa a ordem
    meu_game = game.Game(title="Meu primeiro jogo", fullscreen=False, width=800, height=600)

    # carregamos os recursos necessarios ao jogo
    meu_game.load_content()
    # Iniciamos o loop do jogo
    # Aqui vamos desenhar tudo e actualizar o nosso jogo

Agora alteramos o while True, para :

while meu_game.running:

e depois do

       elif event.type == pygame.KEYDOWN:
            # se essa tecla for o ESC
            if event.key == pygame.K_ESCAPE:
                # Saimos do processo
                sys.exit()

Vamos adicionar estas linhas

 # agora damos um update e um draw no nosso jogo
        meu_game.update()
        meu_game.draw()

ficando assim:

 while meu_game.running:
        # Obtemos os eventos SDL
        event = pygame.event.wait()
        # Se clicarmos no X para fechar a janela
        if event.type == pygame.QUIT:
            meu_game.running = False  # Finalizaamos o loop
            # Se carrgar-mos numa tecla
        elif event.type == pygame.KEYDOWN:
            # se essa tecla for o ESC
            if event.key == pygame.K_ESCAPE:
                # Saimos do processo
                sys.exit()
        # agora damos um update e um draw no nosso jogo
        meu_game.update()
        meu_game.draw()

e agora subestituimos o finaly..... por:

# aqui vamos tratar das excepcoes do nosso codigo
except Exception as ex:
    print(ex.message)

finally:

    # caso aconteca algum erro,
    # limpamos os recursos
    # e saimos do processo
    meu_game.unload_content()
    pygame.quit()

Passemos então a parte de desenhar algo no ecra. vamos voltar ao nosso game.py e logo por baixo da class Game vamos adicionar esta linha:

class Game:
    
    # vamos criar uma variavel logo
    # apenas para o tutorial
    # ao defenirmos uma variavel dentro de uma class
    # esta passa a ser uma variavel de class
    # no ruby seria algo como
    # @@logo
    logo = None

e no metodo load_content()

 def load_content(self):
        # vamos carregar o nosso logo tipo
        # como estamos a chamar uma variavel de class
        # temos que chamar a class e nao o self
        # pygame.image.load(caminho)  -> carrega imagens do disco
        Game.logo =  pygame.image.load(os.path.dirname(os.path.realpath(__file__)) +
                                       "/res/graphics/images/condado_logo.png")

e finalmente no nosso draw():

def draw(self, surface=None):
        if surface is None:
            surface = self.Graphics.bitmap()
        # limpamos o ecra
            surface.fill([30,30,30])
        # agora desenhamos o nosso logo no centro do ecra
        surface.blit(Game.logo, [280, 190])

        self.Graphics.update()

Ao correrem novamente o __main__.py devem ter algo como isto aqui

Download do Tutorial
[descarga]https://dl.dropboxusercontent.com/u/42148742/Tuts/PythonPygame/Tutorial_2.zip[/descarga]

 

[Jazz]

Haunter, tô com uma dúvida:
Por que às vezes colocamos dois underlines (__), antes e depois de declarar certas variáveis e métodos, e as vezes não? O que faz a gente ter que colocar ou não ter que colocar?
E a propósito, tô com um erro:

Spoiler: erro

Tá dando um erro aqui: "'bool' object is not callable".

Ele abre e fecha, sem mostrar nada. =/

import pygame
import sys
import game

try:
    meu_game = game.Game(title="Meu primeiro jogo", fullscreen=False, width=800, height=600)

    meu_game.__load_content__()

    while meu_game.running():
        event = pygame.event.wait()
        if event.type == pygame.QUIT:
            meu_game.running = False
        elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            sys.exit()

        meu_game.__update__()
        meu_game.__draw__()

except Exception as e:
    print(e.message)

finally:
    meu_game.__unload_content__()
    pygame.quit()

 

[haunter224]

Ola,

Isso é apenas por convenção

uso com _ _ para identificar uma variavel que não vou usar,

Tipo __author__, __description__ , são apenas variaveis informativas.

Com 1 _  , por exemplo:
self._data  serve para mostrar a quem for  ler o código,(pode ser voce), que é uma variável / método privado.

mas como disse apenas para informar, visto que python não tem variaveis nem metodos privados.

o seu erro está no while game.runing() , o running é uma variavel bool (true, false) e não é um metodo. remova o ()


de uma vista de olhos no while porque assim o codigo fica e espera ate ter um evento

event = pygame.event.wait() fica a espera;

veja como está aqui

events = pygame.event.get()
        for event in events:
            # Se clicarmos no X para fechar a janela
            if event.type == pygame.QUIT:
                meu_game.running = False  # Finalizamos o loop
            # agora damos um update e um draw no nosso jogo
        meu_game.update()
        meu_game.draw()