Ferramentas de Utilizador

Ferramentas de Site


dev_geral:python:turorial_simples_pygame

Tutorial simples do Pygame

Neste tutorial, vamos ver como colocar um circulo no ecrã, e movê-lo usando as setas do teclado.

No final deverão ter algo assim parecido o código deverá ser similar a este (mais à frente será analisado mais em pormenor):

#!/usr/bin/env python
 
import pygame
from pygame.locals import *
 
if not pygame.font:
    print 'Atenção, não existem fontes.'
 
if not pygame.mixer:
    print 'Atenção, não existe som.'
 
pygame.init()
 
 
vermelho = (255, 0, 0)
preto = (0, 0, 0)
 
 
comprimento_ecra = 640
altura_ecra = 480
 
ecra = pygame.display.set_mode((comprimento_ecra, altura_ecra))
 
 
raio_circulo = 10
 
xpos = 50
ypos = 50
 
circulo = pygame.draw.circle(ecra, vermelho, (xpos, ypos), raio_circulo)
 
movimento_em_x = 5
movimento_em_y = 5
 
pygame.display.flip()
 
pygame.key.set_repeat(100, 100)
 
while True:
    for event in pygame.event.get():
        pass
 
    tecla_pressionada = pygame.key.get_pressed()
 
    if tecla_pressionada[K_LEFT]:
        xpos -= movimento_em_x
 
    if tecla_pressionada[K_RIGHT]:
        xpos += movimento_em_x
 
 
    if tecla_pressionada[K_UP]:
        ypos -= movimento_em_y
 
    if tecla_pressionada[K_DOWN]:
        ypos += movimento_em_y
 
    ecra.fill(preto)
    circulo = pygame.draw.circle(ecra, vermelho, (xpos, ypos), raio_circulo)
    pygame.display.flip()
#!/usr/bin/env python

Esta linha é só para quem usa Linux, e serve para mostrar onde se encontra o executável do Python. Existem duas versões para esta linha. o "#!/usr/bin/env python" e o "#!/usr/bin/python". Esta linha tem de ser a primeira do ficheiro (neste caso, whitespace conta). Existem algumas diferenças entre as duas, mas são irrelevantes numa base diária, e não são apropriadas para este tutorial.

import pygame
from pygame.locals import *

O Pygame é um módulo para o Python (caso ainda não tenham instalado, devem encontrá-lo nos repositórios da vossa distro de Linux, ou no site oficial em http://www.pygame.org/download.shtml onde podem encontrar ports para o Windows e Mac, ou mesmo o source, caso queiram compilar vocês mesmos.

Sendo o Pygame um módulo, é necessário importá-lo, usando o comando "import pygame".

O pygame.locals contêm coisas como as teclas do teclado, e para ser mais rápido aceder-mos a elas, importamos o módulo directamente.

if not pygame.font:   
    print 'Atenção, não existem fontes.'
 
if not pygame.mixer:
    print 'Atenção, não existe som.'

Estes dois blocos são opcionais, mas dá sempre jeito usar. Caso o programa não consiga carregar as fontes do pygame, ou não consiga aceder ao som, ele imprime uma mensagem de erro na consola.

pygame.init()

Este comando inicia todos os módulos que são importados quando se usa o "import pygame". Se quiserem, é possível iniciar os módulos um a um, mas normalmente, tal não é necessário. Se estiverem a usar um interprete como o IDLE, deverão de receber uma tuple, que vos indica os módulos que foram iniciados com sucesso, e os que não foram iniciados. (Em condições normais, este comando deve de fazer um return de (6, 0), ou seja, 6 módulos iniciados correctamente, e 0 não iniciados).

vermelho = (255, 0, 0)
preto = (0, 0, 0)

O vermelho, vai ser a cor da bola, e o preto vai ser a cor que vamos usar para limpar o ecrã no fim de cada frame. As cores são dadas no formato RGB, ou seja, Vermelho, Verde e Azul, sendo que também têm que ser dadas numa tuple. Logo, (255, 0, 0), é o vermelho mais forte, e o (0, 0, 0) é o preto (ausência de cor vermelha, verde e azul).

comprimento_ecra = 640
altura_ecra = 480

Neste caso, a janela resultante terá uma resolução de 640x480. Caso queiram mudar o tamanho da janela, é só mudar os valores.

ecra = pygame.display.set_mode((comprimento_ecra, altura_ecra))

Esta linha cria uma janela, de tamanho 640x480 (por causa das variáveis que criada acima). Reparem que têm que dar uma tuple de dois membros para criar a janela ( ou seja, ecra = pygame.display.set_mode(comprimento_ecra, altura_ecra) não dava (reparem nos dois parênteses acima)).

raio_circulo = 10
 
xpos = 50
ypos = 50

A variável raio_circulo vai definir o raio do círculo em pixeis.

As variáveis xpos e ypos vão definir a posição onde o círculo vai aparecer na primeira frame.

circulo = pygame.draw.circle(ecra, vermelho, (xpos, ypos), raio_circulo)

Agora vamos criar o circulo, usando o módulo draw do pygame. Assim podemos criar as imagens, sem termos que usar sprites criadas noutros programas (é claro que o draw só faz figuras básicas como as figuras geométricas). O draw pode criar também, por exemplo, rectângulos. Para verem tudo o que ele pode criar, vão à documentação oficial sobre o módulo, que pode ser encontrada aqui.

Em relação ao pygame.draw.circle, ele requer os seguintes argumentos: o nome da variável da janela onde ele irá desenhar o círculo, a cor que o círculo deverá ter, uma tuple com a posição do centro do círculo (x, y), e o raio que o círculo deverá ter.

Ou seja, este círculo será criado na nossa janela, com a cor vermelha, na posição (50, 50) (por causa das variáveis que foram definidas atrás), com um raio de 10.

movimento_em_x = 5
movimento_em_y = 5   

Isto vai servir para definir o número de pixeis que o círculo se vai mover, no eixo dos "x" e no eixo dos "y".

pygame.display.flip()

Este comando faz com que o Pygame actualize todo a janela, ou seja, caso haja algum tipo de movimento, este comando "cola" tudo no ecrã para nos vermos. (Ou seja, mesmo que movimentem o círculo, nunca verão o resultado, se não usarem o flip().

pygame.key.set_repeat(1000, 100)

Em condições normais, o Pygame não "aceita" um tecla pressionada, como uma repetição. Ou seja, se pressionarem a seta para a esquerda, e deixarem lá estar o dedo, ele só irá mover o círculo para a esquerda uma vez. Para fazer com que ele voltasse a mover o círculo para a esquerda, tínhamos que levantar o dedo da tecla, e depois voltar a pressionar. Para combater isso, usámos o "set_repeat".

O primeiro valor, é o tempo que temos de deixar o dedo na tecla, até o Pygame aceitar a primeira repetição, e o segundo valor, é o tempo de intervalo que existe entre cada repetição. Todos os valores são dados em milissegundos (ou seja, 1000 neste caso é um segundo). Neste exemplo, quando carregarem para a esquerda, e deixarem lá estar o dedo, o círculo irá mover-se para a esquerda 5 pixeis, depois irá parar durante um segundo, e depois começará a mover-se a 5 pixeis por 100 milésimos de segundo (ou 50 pixeis por segundo). Isto é um pouco complicado de explicar por escrito, o melhor é mesmo modificarem os valores, e verem como afecta o programa.

while True:

Tudo o que é jogo, tem de ter um main loop, para poder processar o input durante as frames.

    for evento in pygame.event.get():
        pass

O modulo "event" do pygame é o que trata de todos os eventos que ocorrem. A função get() faz return de uma lista, com tudo o que se passa num determinado momento (para experimentarem, tentem trocar o "pass" por "print evento"). Como uma lista dessas ocupa muito espaço na memória se deixada a correr durante muito tempo, o melhor é ir limpando-a com o "pass" (para ela não ficar na memória).

    tecla_pressionada = pygame.key.get_pressed()

Esta variável, vai armazenar as teclas que são carregadas, para depois comparar com os "if"s que temos À frente, e caso encontre a tecla que pressionamos num "if", ele executa o bloco.

    if tecla_pressionada[K_LEFT]:
        xpos -= movimento_em_x

Caso a tecla que carregamos seja a seta esquerda (lembrem-se que ela deriva do pygame.locals, que importamos separadamente), modificamos a posição do círculo (lembrem-se que a posição do círculo é dada pelo conjunto (xpox, ypos).

Como a "grelha" é do tipo:

    y^
     |
     |
     |
--------->
     |0   x
     |
     |

Para fazer-mos o círculo andar para a esquerda, temos que subtrair ao valor de x, para o fazer andar para a direita, somar ao valor de x, para fazer andar para cima, adicionar ao valor de y, e para fazer andar para baixo, subtrair ao valor de y.

E é isso que os próximo blocos fazem o mesmo que este, excepto que mudam os eixos e as teclas a carregar.

    if tecla_pressionada[K_RIGHT]:
        xpos += movimento_em_x
 
 
    if tecla_pressionada[K_UP]:
        ypos -= movimento_em_y
 
    if tecla_pressionada[K_DOWN]:
        ypos += movimento_em_y

Agora que o programa já sabe a posição que o círculo vai tomar, está na hora de o colocar no ecrã.

    screen.fill(black)

No entanto, antes de colocar o círculo no ecrã, temos que voltar a preencher o background da janela, para apagar o círculo anterior (senão vão ficar com "rastos" do caminho por onde o círculo percorre. Se quiserem, apaguem esta linha e corram o programa outra vez, para verem o efeito).

Neste caso não é necessário fazer isto ao inicio, porque a cor da janela já é o preto por defeito.

    circulo = pygame.draw.circle(ecra, vermelho, (xpos, ypos), raio_circulo)

Agora que a janela já foi limpa do círculo que estava antes, está na hora de desenhar o círculo na sua nova posição (a única coisa que mudou foi o par (xpos, ypos) ).

    pygame.display.flip()

No entanto, para fazer o círculo aparecer na janela, temos que a actualizar e como vimos antes, isso é feito usando o pygame.display.flip()

Agora devem ter um programa que vos permite mexer uma bola numa janela preta. Agora é fácil modificar o código, para obter vários efeitos (mudem a cor de fundo, o tamanho da janela, a cor, o tamanho do círculo, etc.)

dev_geral/python/turorial_simples_pygame.txt · Esta página foi modificada pela última vez em: 2018/05/14 21:37 (Edição externa)