Pygame Video Games

O Pygame é um módulo em Python usado para design de videogame; Esses videogames variam de um toque tic tic tic a lutadores espaciais. Se você deseja projetar um jogo simples ou complicado, você deve começar com o básico de como o Pygame funciona. Neste tutorial, revisaremos o básico do Pygame criando um videogame.

Instale o Pygame usando:

PIP Instale o pygame

Etapa 1: Criando a janela inicial

O primeiro passo na criação de um videogame é inicializar o pygame usando o método init (). Em seguida, definimos a geometria da tela usando pygame.mostrar.set_mode (), onde passamos a largura e a altura da tela (nessa ordem). Essas duas linhas de código criarão uma janela que desaparecerá rapidamente, por isso precisamos de um loop principal para manter a janela funcionando. Dentro deste principal, vamos adicionar uma estratégia de saída. A estratégia de saída é criada selecionando um evento na lista de eventos (esta lista de eventos está dentro do Pygame.evento.get () que abriga todos os eventos disponíveis). Em seguida, afirmamos que, se o evento que selecionamos for pygame.Desistir, depois saia. Este último criará um loop principal para a janela, o que manterá a janela funcionando até que você pressione o botão de desativação.

importar pygame
Importar sistemas
pygame.iniciar()
tamanho = largura, altura = 800, 600
tela = pygame.mostrar.set_mode (tamanho)
enquanto é verdade:
para evento no pygame.evento.pegar():
Se o evento.tipo == pygame.DESISTIR:
sys.saída()

Etapa 2: Adicionando títulos, ícones, cores de fundo e imagens

Nesta seção, adicionaremos títulos, cores e imagens de fundo e ícones à janela.

(a) O título é adicionado usando:

# Defina o título da janela
pygame.mostrar.set_caption ("videogame")

(b) Recebi meu logotipo de https: // icons8.com/icon/set/computador-hardware/doodle. Se você estiver usando PyCharm, coloque o ícone que você baixar na pasta apropriada (no meu caso, era C: \ Usuários \ Never \ PyCharmProjects \ pythonproject2 \ icon.png). O logotipo é adicionado usando:

# Defina o ícone
imagem = pygame.imagem.carregar ("ícone.png ")
pygame.mostrar.set_icon (imagem)

(c) Você também pode alterar a cor de backgound. Para isso, usamos tela.preench () que leva uma cor RGB. No meu caso, eu o configurei como (0,0,0). Depois de definir a cor, você também deve atualizar o pygame para a mudança de cor para entrar em vigor.

# Preencha o fundo
tela.encher ((0, 0, 0))
pygame.mostrar.atualizar()

(d) E se você quisesse definir uma foto de fundo na tela? Isso também é possível. Como você deseja que a imagem seja executada o tempo todo, ela deve ser colocada dentro do loop enquanto. De fato, qualquer coisa que deve correr constantemente deve ser colocada no loop principal. Usamos pygame.imagem.carregar () para selecionar uma imagem que queremos carregar e o método blit () para colocá -la. Aqui, tela.blit () leva dois argumentos - a imagem carregada, a tupla do local onde o canto superior esquerdo da imagem será colocado. Além disso, pygame.mostrar.Update () deve ser colocado no final para atualizar a tela! Ao projetar videogames, a ordem em que você coloca o código é importante!!! Por exemplo, a atualização não pode vir antes das fotos!

# Crie a imagem de fundo
bg_image = pygame.imagem.carregamento ("bg_image.jpg ")
tela.blit (bg_image, (-15, -25))
pygame.mostrar.atualizar()

Como alternativa, também podemos despejá -lo em uma função de fundo (que será útil posteriormente), por isso reescrevemos o plano de fundo da seguinte maneira:

# Crie a imagem de fundo
bg_image = pygame.imagem.carregamento ("bg_image_3.jpg ")
def Background ():
tela.blit (bg_image, (-15, -25))

Observe que colocamos o plano de fundo em uma função chamada Background (), que ativaremos no While Loop mais tarde.

Etapa 3: Adicionando imagens do jogador à janela

Em seguida, vamos criar uma pessoa. Isso é feito primeiro carregando a imagem e depois usando a tela.blit () para colocar a imagem.

# imagem da pessoa
image_person = pygame.imagem.carga ("pessoa.png ")
tela.blit (image_person, (400, 550))

Observe que a ordem em que você coloca o código também importa! Se você colocar o código para o fundo após o código para o inimigo, nem a pessoa nem o inimigo serão visíveis!

No entanto, mais uma vez, para fins de código inteiro, vamos colocá -lo em uma função. Portanto, o código pode ser reescrito da seguinte maneira:

# imagem da pessoa
Person_x = 400
Person_Y = 550
image_person = pygame.imagem.carregar ("garota.png ")
Def Pessoa (x, y):
tela.blit (image_person, (x, y))

Esta função pode ser ativada no while loop da seguinte forma:

pessoa (pessoa_x, pessoa_y)

Etapa 4: Mover Pessoa ()

Agora, fica complicado, então preste atenção. Precisamos pressionar as chaves para mover a pessoa para a direita, para que as inseriremos no while loop da seguinte maneira:

Pressed_Keys = pygame.chave.get_pressed ()
se pressed_keys [pygame.K_right]:
Person_x += 0.1
se pressed_keys [pygame.K_left]:
Person_x += -0.1

Usamos pygame.chave.get_pressed () para obter a tecla pressionada e verifique. Se a tecla pressionada for a tecla de seta correta (pygame.K_right), então nossa variável Person_x é incrementada por um valor de 0.1. Se, por outro lado, a tecla pressionada é a seta esquerda (pygame.K_left), então diminuímos em 0.1. O que estamos fazendo é mudar a localização da imagem no console. Se a seta direita for pressionada, a tupla inicial de (400, 550) se tornará (400.1, 550) - e esta é a localização da imagem!

Também devemos ativar as funções - Background () e Person (). O fundo da função () limpa a tela cada vez que o loop iniciar e, sem ele, você terá um "arrasto".

O código como um direito inteiro neste momento ficaria assim:

importar pygame
Importar sistemas
# Inicialize
pygame.iniciar()
# Definir geometria da tela
tamanho = largura, altura = 800, 600
tela = pygame.mostrar.set_mode (tamanho)
# Defina o título da janela
pygame.mostrar.set_caption ("videogame")
# Defina o ícone
imagem = pygame.imagem.carregar ("ícone.png ")
pygame.mostrar.set_icon (imagem)
# Crie a imagem de fundo
bg_image = pygame.imagem.carregamento ("bg_image_3.jpg ")
def Background ():
tela.blit (bg_image, (-15, -25))
# imagem da pessoa
Person_x = 400
Person_Y = 550
image_person = pygame.imagem.carregar ("garota.png ")
Def Pessoa (x, y):
tela.blit (image_person, (x, y))
# Mainloop
enquanto é verdade:
para evento no pygame.evento.pegar():
Se o evento.tipo == pygame.DESISTIR:
sys.saída()
# Verifique se há chaves pressionadas
Pressed_Keys = pygame.chave.get_pressed ()
# Se a tecla pressionada for a seta direita,
# então mova para a direita
se pressed_keys [pygame.K_right]:
Person_x += 0.1
# Se a tecla pressionada for a seta esquerda,
# então mova para a esquerda
se pressed_keys [pygame.K_left]:
Person_x += -0.1
# Ative a função de fundo
fundo()
# Ative a função da pessoa
pessoa (pessoa_x, pessoa_y)
# atualize tudo
pygame.mostrar.atualizar()

Etapa 5: Defina os limites de fronteira

Quando pressionamos a tecla de seta direita ou esquerda, no momento, a pessoa (ou o personagem principal) em nosso jogo continuará se movendo e se move, mesmo fora do alcance ou fora da janela do console. Portanto, a próxima coisa que devemos fazer é estabelecer limites para o movimento.

Definir limites é fácil. Vamos para nossos prensed_keys [pygame.K_right] argumento e adicione uma condição. Adicionamos a condição de que X deve ser menor que a largura da tela - largura do personagem.

No meu caso, a largura do personagem era de 50 pixels e a largura x da minha tela era 800. Então eu defino meu lado direito para 800 - 50 = 750 pixels. O que isso faz é limitar o movimento do meu personagem. Meu personagem não pode ir além de 750 pixels e, portanto, permanecerá na tela do console o tempo todo.

Pressed_Keys = pygame.chave.get_pressed ()
# Se a tecla pressionada for a seta direita,
# então mova para a direita
se pressed_keys [pygame.K_right] e pessoa_x < 750:
Person_x += 0.1
# Se a tecla pressionada for a seta esquerda,
# então mova para a esquerda
se pressed_keys [pygame.K_left] e pessoa_x> 0:
Person_x += -0.1

Etapa 6: Criando o inimigo

Criar o inimigo é a parte mais fácil. Fazemos isso da mesma maneira que criamos o personagem principal. Aqui, gostaríamos de randomizar o local onde o inimigo aparece, então usaremos o módulo aleatório para fazer isso. Usamos aleatório.Randint () para definir um local aleatório.

importar aleatório
# imagem inimiga
inimigo_x = aleatório.Randint (0, 750)
inimigo_y = aleatório.Randint (0, 300)
image_enemy = pygame.imagem.carga ("inimigo.png ")
def inimigo (x, y):
tela.blit (image_enemy, (x, y))

Lembre -se de ativo o inimigo no While Loop:

# Ative o inimigo
inimigo (inimigo_x, inimigo_y)

Etapa 7: movendo o inimigo

Mover o inimigo requer um pouco de imaginação. Inicializamos as variáveis ​​(fora do loop while):

#Initialize variáveis
inimy_diff = 0.6
inimigo_x = 0

E dentro do while loop, escrevemos:

# Mova o inimigo
inimigo_x += inimigo_diff
se inimigo_x <= 0:
inimigo_x = 0
inimy_diff = 0.6
Se inimigo_x> = 730:
inimigo_x = 730
inimigo_diff = -0.6

O que isso faz é que, se a imagem do inimigo estiver dentro dos limites (neste caso, entre 0 e 730), ele calculará a equação inimy_x = inimy_x + inimy_diff e moverá. Se, por outro lado, a localização do inimigo for maior que 730, definimos o local inimigo_x para 730 e revertemos a velocidade escrevendo -0.6 em vez de 0.6. Se a localização do inimigo for menor que 0, definimos a variável inimy_x como 0 e dizemos para avançar por 0.6 pixels. Como estamos lidando com um loop de tempo, toda vez que o loop começa de novo, faz com que a variável inimigo_x mude e, portanto, a localização do inimigo para mudar. No final, tudo isso fará é mover o inimigo para frente e para trás para a esquerda e para a direita para sempre.

Etapa 8: Criando e disparando várias balas

No meu caso, vou jogar livros na bola de fogo. Então minha bala é um livro ou vários livros. Vamos primeiro inicializar todas as variáveis ​​de que precisamos:

#Initialize variáveis
Books_diff = 4
Books_Y = 520
Books_x = 420

Books_x e Books_Y são sua localização inicial; Eu os coloquei perto do personagem principal. Books_diff é sua velocidade. Em seguida, inicializamos seu estado, que "não está se movendo" e carregamos a imagem.

# Livros Imagem
books_state = "não se movendo"
image_books = pygame.imagem.carga ("livros.png ")

Em seguida, criamos uma função que leva os Books_state. Se colocarmos o livro na grade, então mudamos seu estado para "mover -se". Esta função é a principal função que colocará a bala no mapa/console. Além disso, nos livros de função (), escrevi x+15 e y+1 para centralizar a imagem. Sem o último, os livros olham para um lado.

Def Books (x, y):
Global Books_state
Books_state = "Moving"
tela.blit (image_books, (x + 15, y + 1))

E dentro do loop principal, você escreveria:

# movimento de livros
Se Books_Y <= 0:
Books_Y = 420
books_state = "não se movendo"
Se Books_state estiver "movendo":
Books_x = Person_x
Livros (Books_x, Books_Y)
Books_Y -= Books_diff
# fogo se o botão de espaço for pressionado
se pressed_keys [pygame.K_space]:
Books_x = Person_x
Livros (Books_x, Books_Y)

Primeiro definimos o que acontece quando a bala/livros sai da grade ou está na posição y<0. In this case, we change the state back to “not moving” and place the books back on the y-axis at 420. If, on the other hand, the state of the book is “moving”, we say that we want it to move (books_y -= books_diff where books_diff is its speed). Next, we also state that if the key is pressed, we want the books() function to be activated, placing the books' image onto the console grid.

O código como um todo neste momento seria algo assim:

importar pygame
Importar sistemas
# Inicialize
pygame.iniciar()
# Inicialize o relógio
relógio = pygame.tempo.Relógio()
# Definir geometria da tela
tamanho = largura, altura = 800, 600
tela = pygame.mostrar.set_mode (tamanho)
# Defina o título da janela
pygame.mostrar.set_caption ("videogame")
# Defina o ícone
imagem = pygame.imagem.carregar ("ícone.png ")
pygame.mostrar.set_icon (imagem)
# Crie a imagem de fundo
bg_image = pygame.imagem.carregamento ("bg_image_3.jpg ")
def Background ():
tela.blit (bg_image, (-15, -25))
# imagem da pessoa
Person_x = 400
Person_Y = 550
image_person = pygame.imagem.carregar ("garota.png ")
Def Pessoa (x, y):
tela.blit (image_person, (x, y))
importar aleatório
# imagem inimiga
inimigo_x = aleatório.Randint (0, 750)
inimigo_y = aleatório.Randint (0, 300)
image_enemy = pygame.imagem.carga ("inimigo.png ")
def inimigo (x, y):
tela.blit (image_enemy, (x, y))
#Initialize variáveis ​​inimigas
inimy_diff = 0.6
inimigo_x = 0
#Initialize variáveis
Books_diff = 4
Books_Y = 520
Books_x = 420
# Livros Imagem
books_state = "não se movendo"
image_books = pygame.imagem.carga ("livros.png ")
Def Books (x, y):
Global Books_state
Books_state = "Moving"
tela.blit (image_books, (x + 15, y + 1))
# Mainloop
enquanto é verdade:
para evento no pygame.evento.pegar():
Se o evento.tipo == pygame.DESISTIR:
sys.saída()
# Verifique se há chaves pressionadas
Pressed_Keys = pygame.chave.get_pressed ()
# Se a tecla pressionada for a seta direita,
# então mova para a direita
se pressed_keys [pygame.K_right] e pessoa_x < 750:
Person_x += 0.8
# Se a tecla pressionada for a seta esquerda,
# então mova para a esquerda
se pressed_keys [pygame.K_left] e pessoa_x> 0:
Person_x += -0.8
# Ative a função de fundo
fundo()
# Ative a função da pessoa
pessoa (pessoa_x, pessoa_y)
# Mova o inimigo
inimigo_x += inimigo_diff
se inimigo_x <= 0:
inimigo_x = 0
inimy_diff = 0.6
Se inimigo_x> = 730:
inimigo_x = 730
inimigo_diff = -0.6
# movimento de livros
Se Books_Y <= 0:
Books_Y = 420
books_state = "não se movendo"
Se Books_state estiver "movendo":
Books_x = Person_x
Livros (Books_x, Books_Y)
Books_Y -= Books_diff
# fogo se o botão de espaço for pressionado
se pressed_keys [pygame.K_space]:
Books_x = Person_x
Livros (Books_x, Books_Y)
# Ative o inimigo
inimigo (inimigo_x, inimigo_y)
# atualize tudo
pygame.mostrar.atualizar()
relógio.Tick ​​(60)

Este código disparará vários livros um após o outro quando a tecla de espaço for pressionada.

Etapa 9: Detecção de colisão

O próximo passo é detectar uma colisão, e isso parece bastante direto. Você usaria o pygame.Ret (x, y, largura, altura) para definir um retângulo. Em seguida, use o método colliderect () para detectar colisão entre dois retângulos. Também dizemos que, se detectar uma colisão, incrementamos a pontuação em 1, re-localizará o inimigo e removemos a bala, redefinindo-o.

# Detecção de colisão
inimigo_rect = pygame.Rect (inimigo_x, inimigo_y, 64, 64)
books_rect = pygame.Rect (Books_X, Books_Y, 64, 64)
Se Books_rect.Colliderect (inimigo_rect):
inimigo_x = aleatório.RandRange (0, 800)
inimigo_y = aleatório.RandRange (0, 300)
pontuação += 1
Bullet_state = "não se movendo"
inimigo (inimigo_x, inimigo_y)
Books_Y = 0

Etapa 10: exibindo texto

Fora do The Mainloop, você escreveria:

pontuação = 0
#Initialize Fonte
pygame.Fonte.iniciar()
myfont = pygame.Fonte.Sysfont ('Comic Sans MS', 50)
def text_score (x, y):
text_score = myFont.render ('pontuação:'+ str (pontuação), true, (0, 0, 0))
tela.blit (text_score, (x, y))

Dentro do loop principal, você escreveria:

# Ative a pontuação de texto
text_score (6, 6)

Aqui, as fontes devem ser inicializadas; portanto, inicialize usando pygame.Fonte.iniciar(). Então você escolhe sua fonte usando pygame.Fonte.Sysfont () onde você passa a fonte e o tamanho. Em seguida, vamos definir uma função em que usamos o método de renderização para renderizá -lo. Aqui, como a pontuação é um número inteiro, usamos STR (pontuação). E então, nós os colocamos na tela usando o método blit ().

Neste ponto, todo o código seria assim:

importar pygame
Importar sistemas
# Inicialize
pygame.iniciar()
# Inicialize o relógio
relógio = pygame.tempo.Relógio()
# Definir geometria da tela
tamanho = largura, altura = 800, 600
tela = pygame.mostrar.set_mode (tamanho)
# Defina o título da janela
pygame.mostrar.set_caption ("videogame")
# Defina o ícone
imagem = pygame.imagem.carregar ("ícone.png ")
pygame.mostrar.set_icon (imagem)
# Crie a imagem de fundo
bg_image = pygame.imagem.carregamento ("bg_image_3.jpg ")
def Background ():
tela.blit (bg_image, (-15, -25))
# imagem da pessoa
Person_x = 400
Person_Y = 550
image_person = pygame.imagem.carregar ("garota.png ")
Def Pessoa (x, y):
tela.blit (image_person, (x, y))
importar aleatório
# imagem inimiga
inimigo_x = aleatório.Randint (0, 750)
inimigo_y = aleatório.Randint (0, 300)
image_enemy = pygame.imagem.carga ("inimigo.png ")
def inimigo (x, y):
tela.blit (image_enemy, (x, y))
#Initialize variáveis ​​inimigas
inimy_diff = 0.6
inimigo_x = 0
#Initialize variáveis
Books_diff = 4
Books_Y = 520
Books_x = 420
# Livros Imagem
books_state = "não se movendo"
image_books = pygame.imagem.carga ("livros.png ")
Def Books (x, y):
Global Books_state
Books_state = "Moving"
tela.blit (image_books, (x + 15, y + 1))
pontuação = 0
#Initialize Fonte
pygame.Fonte.iniciar()
myfont = pygame.Fonte.Sysfont ('Comic Sans MS', 50)
def text_score (x, y):
text_score = myFont.render ('pontuação:'+ str (pontuação), true, (0, 0, 0))
tela.blit (text_score, (x, y))
# Mainloop
enquanto é verdade:
para evento no pygame.evento.pegar():
Se o evento.tipo == pygame.DESISTIR:
sys.saída()
# Verifique se há chaves pressionadas
Pressed_Keys = pygame.chave.get_pressed ()
# Se a tecla pressionada for a seta direita,
# então mova para a direita
se pressed_keys [pygame.K_right] e pessoa_x < 750:
Person_x += 0.8
# Se a tecla pressionada for a seta esquerda,
# então mova para a esquerda
se pressed_keys [pygame.K_left] e pessoa_x> 0:
Person_x += -0.8
# Ative a função de fundo
fundo()
# Ative a função da pessoa
pessoa (pessoa_x, pessoa_y)
# Mova o inimigo
inimigo_x += inimigo_diff
se inimigo_x <= 0:
inimigo_x = 0
inimy_diff = 0.6
Se inimigo_x> = 730:
inimigo_x = 730
inimigo_diff = -0.6
# movimento de livros
Se Books_Y <= 0:
Books_Y = 420
books_state = "não se movendo"
Se Books_state estiver "movendo":
Books_x = Person_x
Livros (Books_x, Books_Y)
Books_Y -= Books_diff
# fogo se o botão de espaço for pressionado
se pressed_keys [pygame.K_space]:
Books_x = Person_x
Livros (Books_x, Books_Y)
# Ative o inimigo
inimigo (inimigo_x, inimigo_y)
# Detecção de colisão
inimigo_rect = pygame.Rect (inimigo_x, inimigo_y, 64, 64)
books_rect = pygame.Rect (Books_X, Books_Y, 64, 64)
Se Books_rect.Colliderect (inimigo_rect):
inimigo_x = aleatório.RandRange (0, 800)
inimigo_y = aleatório.RandRange (0, 300)
pontuação += 1
Bullet_state = "não se movendo"
inimigo (inimigo_x, inimigo_y)
Books_Y = 0
# Ative a pontuação de texto
text_score (6, 6)
# atualize tudo
pygame.mostrar.atualizar()
relógio.Tick ​​(60)

Etapa 11: Adicionando sons

Adicionar sons é super fáceis!

Fora do loop principal, você escreveria:

# Inicialize sons
pygame.misturador.iniciar()
pygame.misturador.música.Carga ("Cocking-01 de pistola.wav ")

Dentro do loop principal, vou ativar o som se houver uma colisão! Aqui, usamos pygame.misturador.música.jogar().

# Detecção de colisão
inimigo_rect = pygame.Rect (inimigo_x, inimigo_y, 64, 64)
books_rect = pygame.Rect (Books_X, Books_Y, 64, 64)
Se Books_rect.Colliderect (inimigo_rect):
inimigo_x = aleatório.RandRange (0, 800)
inimigo_y = aleatório.RandRange (0, 300)
pontuação += 1
Bullet_state = "não se movendo"
inimigo (inimigo_x, inimigo_y)
Books_Y = 0
pygame.misturador.música.jogar()

Etapa 12: terminando o jogo

Vou definir este jogo para uma vitória se a pontuação for maior que 5. Então, fora do loop principal, escrevemos o seguinte código:

text_game_over = pygame.Fonte.Sysfont ('Comic Sans MS', 80)
# Game Over Function
def game_over (x, y):
text_game_over_2 = myfont.render ('you won', verdadeiro, (0, 0, 0))
tela.blit (text_game_over_2, (x, y))

E dentro do loop principal, você escreveria:

# Verifique a vitória
Se pontuação> 5:
game_over (400, 300)
pygame.mostrar.virar()
tempo.sono (5)
quebrar
# Ative a pontuação de texto
text_score (6, 6)
Timer (500, 6)

Isso significa que, se a pontuação for maior que 5, a função game_over () será ativada, a tela será atualizada e depois dizemos, durma um pouco antes de desistir.

Todo o código ficaria assim:

importar pygame
Importar sistemas
tempo de importação
# Inicialize
pygame.iniciar()
# Inicialize o relógio
relógio = pygame.tempo.Relógio()
# Definir geometria da tela
tamanho = largura, altura = 800, 600
tela = pygame.mostrar.set_mode (tamanho)
# Defina o título da janela
pygame.mostrar.set_caption ("videogame")
# Defina o ícone
imagem = pygame.imagem.carregar ("ícone.png ")
pygame.mostrar.set_icon (imagem)
# Crie a imagem de fundo
bg_image = pygame.imagem.carregamento ("bg_image_3.jpg ")
def Background ():
tela.blit (bg_image, (-15, -25))
# imagem da pessoa
Person_x = 400
Person_Y = 550
image_person = pygame.imagem.carregar ("garota.png ")
Def Pessoa (x, y):
tela.blit (image_person, (x, y))
importar aleatório
# imagem inimiga
inimigo_x = aleatório.Randint (0, 750)
inimigo_y = aleatório.Randint (0, 300)
image_enemy = pygame.imagem.carga ("inimigo.png ")
def inimigo (x, y):
tela.blit (image_enemy, (x, y))
#Initialize variáveis ​​inimigas
inimy_diff = 0.6
inimigo_x = 0
#Initialize variáveis
Books_diff = 4
Books_Y = 520
Books_x = 420
# Livros Imagem
books_state = "não se movendo"
image_books = pygame.imagem.carga ("livros.png ")
Def Books (x, y):
Global Books_state
Books_state = "Moving"
tela.blit (image_books, (x + 15, y + 1))
pontuação = 0
#Initialize Fonte
pygame.Fonte.iniciar()
myfont = pygame.Fonte.Sysfont ('Comic Sans MS', 50)
def text_score (x, y):
text_score = myFont.render ('pontuação:'+ str (pontuação), true, (0, 0, 0))
tela.blit (text_score, (x, y))
# Inicialize sons
pygame.misturador.iniciar()
pygame.misturador.música.Carga ("Cocking-01 de pistola.wav ")
text_game_over = pygame.Fonte.Sysfont ('Comic Sans MS', 80)
# Game Over Function
def game_over (x, y):
text_game_over_2 = myfont.render ('you won', verdadeiro, (0, 0, 0))
tela.blit (text_game_over_2, (x, y))
Def Timer (x, y):
text_timer = myfont.render ('time:'+ str (pygame.tempo.get_ticks ()), verdadeiro, (0, 0, 0))
tela.blit (text_timer, (x, y))
# Mainloop
enquanto é verdade:
para evento no pygame.evento.pegar():
Se o evento.tipo == pygame.DESISTIR:
sys.saída()
# Verifique se há chaves pressionadas
Pressed_Keys = pygame.chave.get_pressed ()
# Se a tecla pressionada for a seta direita,
# então mova para a direita
se pressed_keys [pygame.K_right] e pessoa_x < 750:
Person_x += 0.8
# Se a tecla pressionada for a seta esquerda,
# então mova para a esquerda
se pressed_keys [pygame.K_left] e pessoa_x> 0:
Person_x += -0.8
# Ative a função de fundo
fundo()
# Ative a função da pessoa
pessoa (pessoa_x, pessoa_y)
# Mova o inimigo
inimigo_x += inimigo_diff
se inimigo_x <= 0:
inimigo_x = 0
inimy_diff = 0.6
Se inimigo_x> = 730:
inimigo_x = 730
inimigo_diff = -0.6
# movimento de livros
Se Books_Y <= 0:
Books_Y = 420
books_state = "não se movendo"
Se Books_state estiver "movendo":
Books_x = Person_x
Livros (Books_x, Books_Y)
Books_Y -= Books_diff
# fogo se o botão de espaço for pressionado
se pressed_keys [pygame.K_space]:
Books_x = Person_x
Livros (Books_x, Books_Y)
# Ative o inimigo
inimigo (inimigo_x, inimigo_y)
# Detecção de colisão
inimigo_rect = pygame.Rect (inimigo_x, inimigo_y, 64, 64)
books_rect = pygame.Rect (Books_X, Books_Y, 64, 64)
Se Books_rect.Colliderect (inimigo_rect):
inimigo_x = aleatório.RandRange (0, 800)
inimigo_y = aleatório.RandRange (0, 300)
pontuação += 1
Bullet_state = "não se movendo"
inimigo (inimigo_x, inimigo_y)
Books_Y = 0
pygame.misturador.música.jogar()
# Verifique a vitória
Se pontuação> 5:
game_over (400, 300)
pygame.mostrar.virar()
tempo.sono (5)
quebrar
# Ative a pontuação de texto
text_score (6, 6)
Timer (500, 6)
# atualize tudo
pygame.mostrar.atualizar()
relógio.Tick ​​(60)

É claro que este é o mais simples de todos os jogos que você pode criar! No entanto, é um começo para quem deseja aprender pygame e projetar melhores videogames.

Jogos felizes!