O pygame.

init ()
4. # Configurar pygame
5. pygame.init ()

A biblioteca Pygame software tem um código inicial que precisa ser executado antes
que possamos utilizá-lo. Todos os programas PyGame deve executar este código
chamando o pygame.init () depois de importar o módulo pygame, mas antes de chamar
qualquer função PyGame outros.

O pygame.display.set_mode () e
pygame.display.set_caption ()
7. # Configurar a janela
8. windowSurface pygame.display.set_mode = ((500, 400), 0, 32)
9. pygame.display.set_caption ('Olá mundo!')

Linha 8, cria uma janela GUI para o nosso programa, chamando o set_mode () método
no módulo pygame.display. (O módulo de visualização é um módulo dentro do módulo
pygame. PyGame é tão avançado que até mesmo o módulo pygame tem seus próprios
módulos!)
Só para evitar confusão, você deve saber a diferença entre a janela que é criado é
diferente eo sistema operacional Windows. A interface gráfica é impresso como
"janela" (em minúsculas e no singular) e do sistema operacional da Microsoft é
"Windows" (maiúsculas e plural).
Há três parâmetros para o set_mode () método. O primeiro parâmetro é uma tupla de
dois inteiros para a largura e altura da janela, em pixels. Um pixel é o mais ínfimo ponto
na tela do computador. Um único pixel na tela pode se transformar em qualquer cor.
Todos os pixels em sua tela trabalhar juntos para mostrar todas as imagens que você vê.
Para ver como um pixel é minúsculo, olhe para o canto inferior direito da "Olá Mundo!"
janela. Este programa define apenas como um pixel branco.
Nós queremos que a janela a ser 500 pixels de largura e 400 pixels de altura, por isso
usamos a tupla (500, 400) para o primeiro parâmetro. Para obter o número total de
pixels na nossa janela, multiplicar a largura ea altura. Nossa janela é composta por
20.000 pixels, e nem sequer ocupam toda a tela do computador!
O segundo parâmetro é a janela de opções avançadas GUI. Você realmente não precisa
disto para seus jogos, assim você pode sempre passar 0 para esse parâmetro. O terceiro
parâmetro é uma outra opção avançada chamada de profundidade de cor. Você também
não precisa saber o que isso significa, e só pode sempre passar o valor 32.
O set_caption () retorna um objeto chamar pygame.Surface (que chamaremos de objetos
de superfície para o short). Os objetos são valores de um tipo de dados que têm
métodos, bem como de dados. Por exemplo, strings são objetos em Python, porque eles
têm dados (a seqüência em si) e métodos (como menor () e split ()). Você pode
armazenar referências a objetos em variáveis como valores de referência da lista. O
objeto de superfície representa a janela e vamos incluir a variável windowSurface em
todas as nossas chamadas para funções de desenho.

Cores em Pygame
11. # Configurar as cores
12. BLACK = (0, 0, 0)
13. BRANCO = (255, 255, 255)
14. VERMELHO = (255, 0, 0)
15. VERDE = (0, 255, 0)
16. AZUL = (0, 0, 255)

Tabela 17-1: Cores e seus valores

RGB.
Cor Valores RGB
Aqua (0, 255, 255)
Black (0, 0, 0)
Blue (0, 0, 255)
Cornflower Blue (100, 149, 237)
Fúcsia (255, 0, 255)
Gray (128, 128, 128)
Verde (0, 128, 0)
Cal (0, 255, 0)
Maroon (128, 0, 0)
Marinha Azul (0, 0, 128)
Azeitona (128, 128, 0)
Purple (128, 0, 128)
Vermelho (255, 0, 0)
Prata (192, 192, 192)
Cerceta (0, 128, 128)
Branco (255, 255, 255)
Amarelo (255, 255, 0)
Existem três cores primárias da luz: vermelho, verde e azul. Ao combinar diferentes
quantidades dessas três cores pode formar qualquer outra cor. Em Python, que
representam as cores com tuplas de três inteiros. O primeiro valor na tupla é a
quantidade de vermelho na cor. Um valor de 0 significa que não há nesta cor vermelha, e
um valor de 255 significa que há uma quantidade máxima de vermelho na cor. O
segundo valor é para o verde eo terceiro valor é para o azul.
Por exemplo, vamos criar a tupla (0, 0, 0) e armazená-lo em uma variável chamada
BLACK. Com nenhuma quantidade de vermelho, verde ou azul, a cor resultante é
completamente preto. A cor preta é a ausência de qualquer cor.
Na linha 13, usamos a tupla (255, 255, 255) para um montante máximo de vermelho,
verde e azul para o resultado em branco. A cor branca é a combinação completa de
vermelho, verde e azul. Nós armazenamos esta tupla na variável BRANCO. A tupla
(255, 0, 0) representa a quantidade máxima de vermelho, mas nenhuma quantidade de
verde e azul, assim que a cor resultante é vermelho. Da mesma forma, (0, 255, 0) é verde
e (0, 0, 255) é azul.
Estes são os nomes das variáveis em todas as capitais, pois são variáveis constantes. É
apenas mais fácil de BLACK tipo em nosso código de (0, 0, 0) toda vez que quiser
especificar a cor preta, de modo que configurar essas variáveis de cor no início do nosso
programa.
Se você quiser fazer uma cor mais clara, tente adicionar uma quantidade igual de todos
os três valores. Por exemplo, o valor RGB cinza é (128, 128, 128). Você pode obter o
valor RGB de uma cor cinza clara com adição de 20 para cada valor a receber (148, 148,
148). Você pode obter o valor RGB de um cinza escuro, subtraindo 20 de cada valor
para obter (108, 108, 108). E você pode obter o valor RGB de um cinza levemente
avermelhado pela adição de 20 para apenas vermelha para obter o valor (148, 128, 128).
Tabela 17-1 tem algumas cores comuns e seus valores RGB.

Fontes, e do pygame.font.SysFont ()
18. # Configurar fontes
19. basicFont = pygame.font.SysFont (None, 48)

Figura 17-3: Exemplos de fontes diferentes.

Uma fonte é um conjunto completo de letras, números, símbolos e personagens
desenhados em um estilo único. Figura 17-3 é um exemplo da mesma frase impressa em
diferentes fontes.
Nos nossos jogos anteriores, só disse Python para imprimir o texto. A cor, tamanho e
tipo de letra que foi usado para mostrar que este texto foi completamente determinado
por qualquer fonte do seu sistema operacional usa para as janelas do console. Nossos
programas não poderia mudar a fonte de todo. No entanto, uma vez que irá redigir cartas
para uma janela da GUI é preciso dizer exatamente o que PyGame fonte a ser usada na
elaboração do texto.
Na linha 19 criamos um objeto pygame.font.Font (que só vai chamar objetos Font, para
abreviar), chamando o pygame.font.SysFont () função. O primeiro parâmetro é o nome
da fonte, mas vamos passar o valor None para usar a fonte padrão do sistema. O segundo
parâmetro será o tamanho da fonte (que é medido em unidades chamadas pontos). Na
nossa chamada na linha 19, nós queremos o tamanho da fonte a ser 48 pontos.

O método render () para Font

21. # Configurar o texto
 22. basicFont.render text = ('Olá mundo! ", True, white , blue)
23. text.get_rect TextRect = ()

Figura 17-4: Uma linha de alias e uma linha de anti-aliasing.

O objeto fonte que temos armazenado na variável basicFont tem um método chamado
render (). Este método irá criar um objeto de superfície com o texto elaborado sobre ele.
O primeiro parâmetro para render () é a seqüência do texto para desenhar. O segundo
parâmetro é um valor booleano para saber se queremos ou não anti-aliasing. Anti-
aliasing é uma técnica para fazer um desenho olhar menos blocos. Na linha 22, nós
passamos a verdade dizer que queremos usar anti-aliasing. Figura 17-4 é um exemplo do
que uma linha (quando se aumentar os pixels individuais) se parece com e sem anti-
aliasing.
Anti-aliasing pode fazer seu texto e linhas olhar embaçado, mas mais suaves. Demora
um pouco mais tempo de computação para fazer anti-aliasing, por isso, embora os
gráficos podem ter melhor aspecto, o programa pode ficar mais lento (mas só um
pouco).

Atributos
24. windowSurface.get_rect textRect.centerx = (). CenterX
25. windowSurface.get_rect textRect.centery = (). centery

O tipo de dados pygame.Rect (que só vai chamar Rect para o short) torna o trabalho
com as coisas em forma de retângulo fácil. Para criar um objeto novo Rect pygame.Rect
chamar a função (). Os parâmetros são inteiros para as coordenadas XY do canto
superior esquerdo, seguido pela largura e altura. Esses números inteiros descrever o
tamanho em número de pixels.
O nome da função com os parâmetros parecido com este: pygame.Rect (esquerda, topo,
largura, altura)
Assim como os métodos são funções que são associadas com um objeto, os atributos
são variáveis que estão associadas a um objeto. O Rect tipo de dados (ou seja, o tipo de
dados de todos os objetos Rect) tem muitos atributos que descrevem o retângulo que
eles representam. Aqui está uma lista de atributos de um objeto chamado Rect myRect:

Atributo pygame.Rect Descrição

myRect.left O valor inteiro da coordenada X do lado esquerdo do retângulo.
myRect.right O valor inteiro da coordenada X do lado direito do retângulo.
myRect.top O valor inteiro da coordenada Y do lado superior do retângulo.
myRect.bottom O valor inteiro da coordenada Y do lado inferior do retângulo.

myRect.centerx O valor inteiro da coordenada X do centro do retângulo.

myRect.centery O valor inteiro da coordenada Y do centro do retângulo.

myRect.width O valor inteiro da largura do retângulo.

myRect.height O valor inteiro da altura do rectângulo.
myRect.size Uma tupla de dois inteiros: (largura, altura)

myRect.topleft Uma tupla de dois inteiros: (da esquerda, em cima)

myRect.topright Uma tupla de dois inteiros: (à direita, em cima)
myRect.bottomleft Uma tupla de dois inteiros: (da esquerda, em baixo)
myRect.bottomright Uma tupla de dois inteiros: (à direita, em baixo)

myRect.midleft Uma tupla de dois inteiros: (da esquerda, centery)

myRect.midright Uma tupla de dois inteiros: (direita, centery)
myRect.midtop Uma tupla de dois inteiros: (CenterX, em cima)
myRect.midbottom Uma tupla de dois inteiros: (CenterX, inferior)

A grande coisa sobre os objetos Rect é que se você modificar qualquer uma dessas
variáveis, todas as outras variáveis automaticamente modificar-se também. Por
exemplo, se você criar um Rect que é de 20 pixels de largura e 20 pixels de altura, e tem
o canto superior esquerdo nas coordenadas (30, 40), a coordenada X do lado direito será
definido automaticamente para 50 ( porque 20 + 30 = 50). Entretanto, se você alterar o
atributo esquerda com o myRect.left = linha 100, então PyGame irá mudar
automaticamente o atributo direito a 120 (porque 20 + 100 = 120). Cada outro atributo
para esse objeto Rect também será atualizado.

O get_rect () Métodos para pygame.font.Font e objetos

pygame.Surface
Observe que ambas as fontes objeto (armazenado na variável de texto) eo objeto de
superfície (armazenado na variável windowSurface) ambos têm um método chamado
get_rect (). Tecnicamente, estes são dois métodos diferentes. Mas os programadores do
PyGame deu-lhes o mesmo nome, porque ambos fazem a mesma coisa e retornar
objetos Rect que representa o tamanho e posição da fonte ou objeto de superfície.
Além disso, lembre-se que pygame é um módulo que nós importamos, e dentro do
módulo pygame são os módulos de fonte e de superfície. Dentro desses módulos são os
tipos de fontes e dados de superfície. Os programadores PyGame fez os módulos
começam com uma letra minúscula, e os tipos de dados começa com uma letra
maiúscula. Isto torna mais fácil distinguir os tipos de dados e os módulos que os tipos
de dados podem ser encontrados dentro