Esta tarefa é projetar um jogo 2D de forma independente usando o módulo pygame.
O jogo produzido desta vez foi inspirado em jumpKing, que é um jogo de alta tecnologia vendido no Steam.
Escolhemos seu método de operação: as teclas A e D são necessárias para controlar o movimento do personagem, e a barra de espaço faz o personagem pular, e quanto mais tempo a barra de espaço se acumula, mais alto é o salto
Vamos apresentar o processo de produção do nosso jogo.
Um, projete a lógica básica e a interface do jogo.
Esta é uma interface básica e julgamento de gatilho de evento desenhado no rascunho.
O design completo do jogo não é totalmente mostrado no interior.
Em segundo lugar, o design da classe no jogo
1, a classe player
Na classe Player, fornecemos as propriedades básicas de si mesma:
Rect é a posição inicial do personagem. Colocamos a posição inicial do personagem no topo do meio da primeira plataforma que aparece aleatoriamente, por isso precisa ser importada quando o personagem é criado para facilitar o desenho da posição inicial do personagem.
O atributo faceR determina a direção do movimento do personagem, 1 representa o movimento para a direita e 2 representa o movimento para a esquerda.
O atributo de velocidade é a velocidade de movimento do personagem no eixo x.
O atributo gravidade é a velocidade de pouso do personagem no eixo y.
O atributo live serve para determinar se o personagem está vivo.
Função de soltar para controlar o pouso do personagem.
A função Mover controla o movimento do personagem no eixo y. Você precisa inserir o tempo. Este é o momento em que o jogador pressiona a barra de espaço para controlar a duração do movimento do personagem no eixo y.
class Player ():
def init (self, pos):
self.rect = pos
self.faceR = 1 # 1 está à direita, 2 está à esquerda
self.speed = 2
self.gravity = 10
self.live = True #whether Survive
def Drop (self): self.rect.top + = self.gravity def Move (self, time): tmp = 0.2 * self.speed * time * time - self.gravity if tmp <= 0: tmp = 0 self. rect.top - = tmp self.rect.left + = self.speed * time * self.faceR
2. Classe
de terreno Nesta classe, damos os atributos básicos da classe de terreno:
O atributo de imagem é usado para armazenar fotos de terrenos,
O atributo rect define o atributo Rect do terreno e gera diferentes valores à esquerda através da função aleatória posteriormente para controlar as diferentes posições do terreno.
rect.topleft recebe o valor init_pos fornecido pelo mundo exterior, que é o valor esquerdo da terra.
O atributo gravidade é a velocidade de pouso da terra no eixo y.
A função Mover controla o pouso da classe de terreno.
classe Land (pygame.sprite.Sprite):
def init (self, land_img, init_pos):
pygame.sprite.Sprite. init (self)
self.image = land_img
self.rect = pygame.Rect (0,0,100,20)
self .rect.topleft = init_pos
self.gravity = 4
def Move (self):
self.rect.top + = self.gravity
Terceiro, o código básico do programa
abaixo é baseado nas configurações básicas do pygame para definir a largura e altura da tela. E alguns valores de atributo que serão usados a seguir. Deve ser descrito em detalhes abaixo quando for especificamente usado.
pygame.init ()
largura = 800
altura = 800
window = pygame.display.set_mode ((largura, altura))
pygame.display.set_caption ('jumpK')
pygame.font.init ()
tempo = 0
branco = 255, 255, 255
preto = 0, 0, 0
land_frequency = 0
land_width = 100
#Save todas as terras geradas = pygame.sprite.Group ()
#player = Player ()
create_player = True
player_rect = pygame.Rect (0,0,30,54,) #Judge criação de personagem
jk_begin = Verdadeiro
jk_space = Falso
jk_left = Falso
jk_right = Falso
max_time = 0
#fração
pontuação = 0
clock = pygame.time.Clock ()
Abaixo estão algumas fotos e efeitos sonoros que carregamos.
# 载入 图片
background = pygame.image.load ('tmp / images / back_img.png')
land = pygame.image.load ('tmp / images / land.png')
game_over = pygame.image.load ('tmp /images/gameover.png ')
player1 = pygame.image.load ('tmp / images / player_1.png')
player2 = pygame.image.load ('tmp / images / player_2.png')
player3 = pygame.image.load ('tmp / images / player_3 .png ')
player4 = pygame.image.load (' tmp / images / player_4.png ')
# 载入 游戏 音效
jump = pygame.mixer.Sound (' tmp / sons / jump.wav ')
jump.set_volume (15 )
game_over_sound = pygame.mixer.Sound ('tmp / sons / game_over.wav')
game_over_sound.set_volume (0,05)
pygame.mixer.music.load ('tmp / sons / background.mp3')
pygame.mixer.music.play (-1, 0,0)
pygame.mixer.music.set_volume (0,5)
接下来 ， 就是 需要 不断 更新 的 信息。
running = True #Se o jogo terminar
durante a execução:
basta definir a taxa de quadros do jogo, plano de fundo ou algo assim.
clock.tick (30) window.blit (background, (0, 0)) pygame.draw.rect (window, white, [260, 740, 260, 50], 0)
Aqui está a barra de velocidade de exibição, o comprimento é exibido de acordo com o tempo e iremos zerar o tempo mais tarde.
#Exibir a barra de velocidade pygame.draw.rect (janela, preto, [260, 740, tempo / 20 * 260, 50], 0)
Aqui, a velocidade gerada pela plataforma é controlada pelo land_frequency definido por você.
# 产生 下落 的 平台 if land_frequency% 50 == 0: land1_pos = [random.randint (0, width-land_width), 0] land1 = Land (land, land1_pos) lands.add (land1) land_frequency + = 1 if land_frequency> = 100: land_frequency = 0
O julgamento é usado aqui para garantir que o código seja executado apenas uma vez. Impedir o controle estranho de jogadores posteriores.
#Create characters if create_player: create_player = False player_rect.left = land1.rect.left + 40 player_rect.top = land1.rect.top-55 player = Player (player_rect) #Create caracteres iniciais window.blit (player1, player. Rect )
Vamos armazenar o terreno gerado a cada vez em um grupo posteriormente, para que possamos desenhar continuamente aqui, usando a função Mover terreno.
E aqui para julgar se existe uma colisão entre o personagem e o terreno, e definir a classe Booleana no início de "jk_", que controlará o programa posteriormente.
E quando a plataforma estiver abaixo de uma certa altura, vamos eliminar essa parte do terreno do grupo.
para tmp_land em terras: #Desenhe a plataforma de queda window.blit (land, tmp_land.rect) # 下落 tmp_land.Move () if pygame.sprite.collide_circle (tmp_land, player): #score + = 100 jk_right = False jk_left = False jk_space = False jk_begin = True player.gravity = 4 #Remova a plataforma na parte inferior se tmp_land.rect.y> = 650: lands.remove (tmp_land)
Quando o atributo ao vivo do jogador é True, aceitamos o valor do teclado,
Se for um espaço, altere os atributos relevantes do jogador.
adicione 0,5 ao tempo, desenhe a barra de velocidade,
Quando o tempo chega a 20, o tempo não aumentará.
Se houver um clique com o botão esquerdo ou com o botão direito ao mesmo tempo, mudaremos a propriedade faceR do jogador para controlar a direção do movimento do eixo x do personagem.
# 人物 空格 移动 if player.live: if jk_begin: key_pressed = pygame.key.get_pressed () if key_pressed [pygame.K_SPACE]: jump.play () jk_space = True jk_left = False jk_right = False window.blit (player2, player .rect) player.faceR = 0 player.gravity = 10 time + = 0.5 player.Move (time) else: jump.stop () jk_begin = False time = 0 se time> = 20: jump.stop () time = 20 max_time + = 1 if max_time> = 10: jk_begin = False time = 0 if key_pressed [pygame.K_LEFT] e key_pressed [pygame.K_SPACE]: jk_space = False jk_left = True jk_right = False window.blit (player3, player.rect) player.faceR = -1 player.Move (tempo) se key_pressed [pygame.K_RIGHT] e key_pressed [pygame.K_SPACE]: jk_space = False jk_left = False jk_right = True window.blit (player4, player.rect) player.faceR = 1 jogador. Movimento (tempo)
Precisamos fazer algumas correções nos personagens para evitar que a imagem dos personagens ultrapasse os limites da imagem.
#Corrija o caractere sobre a borda se player.rect.y <= -54: player.rect.y = -54 se player.rect.x <= 0: player.rect.x = 0 tempo = 0 jk_begin = Falso se jogador. rect.x> = 770: player.rect.x = 770
Ao mesmo tempo, quando a retidão do personagem ultrapassar 750, a imagem game over será exibida. Além disso, o atributo ao vivo do jogador é FALSE para que não continue a aceitar os comandos de teclado do jogador.
#Jogo over if player.rect.y > = 750: game_over_sound.play () player.live = False window.blit (game_over, (0, 0))
No final, atualizamos uniformemente o desenho do personagem e quando o jogador digita diferentes teclas, as diferentes ações do personagem (incluindo ficar de pé normalmente, agachar, olhar para a esquerda, olhar para a direita)
# 更新 人物, 判断 人物 动作 if (not jk_right) e (not jk_left) e (not jk_space): window.blit (player1, player.rect) if jk_space: window.blit (player2, player.rect) if jk_left: window .blit (player3, player.rect) if jk_right: window.blit (player4, player.rect) player.Drop () para evento em pygame.event.get (): if event.type == pygame.QUIT: running = False pygame.display.update ()
4. Conclusão
Esta é a primeira vez que usamos o pygame para desenvolver nossos próprios jogos .
Aqui, excluímos a operação de pressionar as teclas esquerda, direita e A, D na plataforma para controlar o movimento dos personagens, e usar apenas as teclas esquerda, direita e A, D para controlar a maneira como os personagens se movem.
Ao mesmo tempo, não criamos um grande número de terrenos para enriquecer a riqueza e a diversão do jogo, mas apenas usamos uma plataforma em descida constante em vez de um terreno fixo.
Existem também desvantagens que a estranha trajetória de movimento, o personagem pode penetrar na plataforma por baixo, e o personagem vai flutuar no ar (isso deve estar relacionado ao julgamento do pygame)
Se houver outro momento, espero corrigir essas deficiências.