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 (Não se preocupem se não entenderem alguma coisa, pois o
código vai ser analisado linha a linha):
GeSHi (python):
#!/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()
Created by GeSHI 1.0.7.20
GeSHi (python):
#!/usr/bin/env python
Created by GeSHI 1.0.7.20
Esta linha é só para o pessoal que 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.
Bem, após este aparte (e foi um aparte grande), vamos ao que interessa:
GeSHi (python):
import pygame
from pygame.locals import *
Created by GeSHI 1.0.7.20
O Pygame é um módulo para o Python (parto do principio que já o têm instalado, caso contrário devem de o
encontrar nos repositórios da vossa distro de Linux, ou então dirigem-se para o site oficial em
http://www.pygame.org/download.shtml onde podem encontrar ports para o Windows e Mac, ou então as
sources, caso queiram compilar vocês mesmos).
Sendo o Pygame um módulo, é necessário importa-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.
GeSHi (python):
if not pygame.font:
print 'Atenção, não existem fontes.'
if not pygame.mixer:
print 'Atenção, não existe som.'
Created by GeSHI 1.0.7.20
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.
GeSHi (python):
pygame.init()
Created by GeSHI 1.0.7.20
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 tiverem a usar um
interpreter 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).
GeSHi (python):
vermelho = (255, 0, 0)
preto = (0, 0, 0)
Created by GeSHI 1.0.7.20
Acho que quando se está num tutorial, não deve de aparecer conjuntos de números assim do nada, por isso
crio variáveis para as cores que vão ser usadas. 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 (ja explico isso). 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).
GeSHi (python):
comprimento_ecra = 640
altura_ecra = 480
Created by GeSHI 1.0.7.20
Tal como em cima, não gosto de por números mágicos, que parecem aparecer (digam isto muito depressa
)
do nada, por isso, estão aqui definidas o tamanho do ecrã do pygame. Neste caso, a janela resultante
terá uma resolução de 640x480. Caso queiram mudar o tamanho da janela, é só mudar os valores. Simples
GeSHi (python):
ecra = pygame.display.set_mode((comprimento_ecra, altura_ecra))
Created by GeSHI 1.0.7.20
Esta linha cria uma janela, de tamanho 640x480 (por causa das variaveis que criamos 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)).
GeSHi (python):
raio_circulo = 10
xpos = 50
ypos = 50
Created by GeSHI 1.0.7.20
A variável
raio_circulo vai definir o raio do círculo em pixeis (podiam não ter reparado nisso
).
As variáveis
xpos e
ypos vão definir a posição onde o círculo vai aparecer na primeira
frame.
GeSHi (python):
circulo = pygame.draw.circle(ecra, vermelho, (xpos, ypos), raio_circulo)
Created by GeSHI 1.0.7.20
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 definimos atrás), com um raio de 10.
GeSHi (python):
movimento_em_x = 5
movimento_em_y = 5
Created by GeSHI 1.0.7.20
Isto vai servir para definir o número de pixels que o círculo se vai mover, no eixo dos "x" e no eixo
dos "y" (Isto vai ser visto mais à frente).
GeSHi (python):
pygame.display.flip()
Created by GeSHI 1.0.7.20
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() (por acaso também existe outra maneira, mas é mais complicado
)).
GeSHi (python):
pygame.key.set_repeat(1000, 100)
Created by GeSHI 1.0.7.20
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 pixels, depois irá
parar durante um segundo, e depois começará a mover-se a 5 pixels por 100 milésimos de segundo (ou 50
pixels por segundo). Isto é um pouco complicado de explicar por escrito, o melhor é mesmo modificarem os
valores, e verem como afecta o programa.
GeSHi (python):
while True:
Created by GeSHI 1.0.7.20
Tudo o que é jogo, tem de ter um main loop, para poder processar o input durante as frames.
GeSHi (python):
for evento in pygame.event.get():
pass
Created by GeSHI 1.0.7.20
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).
GeSHi (python):
tecla_pressionada = pygame.key.get_pressed()
Created by GeSHI 1.0.7.20
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.
GeSHi (python):
if tecla_pressionada[K_LEFT]:
xpos -= movimento_em_x
Created by GeSHI 1.0.7.20
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.
GeSHi (python):
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
Created by GeSHI 1.0.7.20
Agora que o programa já sabe a posição que o círculo vai tomar, está na hora de o colocar no ecrã.
GeSHi (python):
screen.fill(black)
Created by GeSHI 1.0.7.20
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).
Nós não tivemos que fazer isto ao início, porque a cor da janela já é o preto por default.
GeSHi (python):
circulo = pygame.draw.circle(ecra, vermelho, (xpos, ypos), raio_circulo)
Created by GeSHI 1.0.7.20
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) ).
GeSHi (python):
pygame.display.flip()
Created by GeSHI 1.0.7.20
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()
E já está, agora devem de ter um programa que vos permite mexer uma bola numa janela preta (Ok, não é o
Unreal 2007 ou o Starcraft 2, mas todos temos de começar em algum lado certo?).
Agora podem modificar o código, para obterem vários efeitos (mudem a cor de fundo, o tamanho da janela,
a cor, o tamanho do círculo, etc.)
