Olá a todos, este artigo se concentrará nas 100 linhas de código de jogo python simples. O que o código de jogo python pode usar é algo que muitas pessoas querem entender. Para descobrir o código-fonte do programa de jogo python, você precisa entender o seguinte: primeiro.
Desta vez, Python é usado para implementar um pequeno jogo de pegar bolas e acertar tijolos. O módulo pygame precisa ser importado. Existem dois resumos de experiência, como segue:
1. Herança de múltiplas classes pai 2. Modelo matemático de detecção de colisão
Falaremos sobre os pontos de conhecimento mais tarde. Vejamos primeiro os efeitos e a implementação do jogo:
1. Efeito do jogo
2. Código do jogo
#Importar módulo
importar pygame
da importação de pygame.locals *
importar sys, aleatório, hora, matemática
classe GameWindow (objeto):
'''Criar classe de janela de jogo'''
def __init__(self,*args,**kw):
self.window_length = 600
self.window_wide = 500
#Desenhe a janela do jogo e defina o tamanho da janela
self.game_window = pygame.display.set_mode((self.window_length,self.window_wide))
#Definir título da janela do jogo
pygame.display.set_caption("CatchBallGame")
#Definir parâmetros de cor de fundo da janela do jogo
self.window_color = (135.206.250)
def fundo(auto):
#Desenhe a cor de fundo da janela do jogo
self.game_window.fill(self.window_color)
classe Bola (objeto):
'''Crie uma bola'''
def __init__(self,*args,**kw):
#Defina os parâmetros de raio, cor e velocidade de movimento da bola
self.ball_color = (255.215,0)
self.move_x = 1
self.move_y = 1
raio próprio = 10
def ballready(self):
#Defina a posição inicial da bola,
self.ball_x = self.mouse_x
self.ball_y = self.window_wide-self.rect_wide-self.radius
#Desenhe a bola e defina as condições de acionamento do rebote
pygame.draw.circle(self.game_window,self.ball_color,(self.ball_x,self.ball_y),self.radius)
def ballmove(self):
#Desenhe a bola e defina as condições de acionamento do rebote
pygame.draw.circle(self.game_window,self.ball_color,(self.ball_x,self.ball_y),self.radius)
self.ball_x += self.move_x
self.ball_y -= self.move_y
#Chamar função de detecção de colisão
self.ball_window()
self.ball_rect()
#A velocidade da bola dobra a cada 5 vezes que a bola é pega
se self.distance <self.radius:
frequência própria += 1
se self.frequency == 5:
frequência própria = 0
self.move_x += self.move_x
self.move_y += self.move_y
self.point += self.point
#Definir condições de falha do jogo
se self.ball_y > 520:
self.gameover = self.over_font.render("Fim de jogo",Falso,(0,0,0))
self.game_window.blit(self.gameover,(100.130))
self.over_sign = 1
classe Rect (objeto):
'''Criar classe de raquete'''
def __init__(self,*args,**kw):
#Definir parâmetros de cores da raquete
self.rect_color = (255,0,0)
self.rect_length = 100
self.rect_wide = 10
def rectmove(self):
#Obter parâmetros de posição do mouse
self.mouse_x,self.mouse_y = pygame.mouse.get_pos()
#Desenhe a raquete e limite os limites horizontais
se self.mouse_x >= self.window_length-self.rect_length //2:
self.mouse_x = self.window_length-self.rect_length //2
se self.mouse_x <= self.rect_length //2:
self.mouse_x = self.rect_length //2
pygame.draw.rect(self.game_window,self.rect_color,((self.mouse_x-self.rect_length//2),(self.window_wide-self.rect_wide),self.rect_length,self.rect_wide))
classe Tijolo (objeto):
def __init__(self,*args,**kw):
#Definir parâmetros de cor do tijolo
self.brick_color = (139.126.102)
self.brick_list = [[1,1,1,1,1,1],[1,1,1,1,1,1],[1,1,1,1,1,1],[1, 1,1,1,1,1],[1,1,1,1,1,1]]
self.brick_length = 80
self.brick_wide = 20
def tilearrange(self):
para i no intervalo (5):
para j no intervalo (6):
self.brick_x = j*(self.brick_length+24)
self.brick_y = i*(self.brick_wide+20)+40
se self.brick_list[i][j] == 1:
#desenhar tijolos
pygame.draw.rect(self.game_window,self.brick_color,(self.brick_x,self.brick_y,self.brick_length,self.brick_wide))
#Chamar função de detecção de colisão
self.ball_brick()
se self.distanceb <self.radius:
self.brick_list[i][j] = 0
self.score += self.point
#Definir condições de vitória no jogo
se self.brick_list == [[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[ 0,0,0,0,0,0],[0,0,0,0,0,0]]:
self.win = self.win_font.render("Você ganhou",Falso,(0,0,0))
self.game_window.blit(self.vitória,(100.130))
self.win_sign = 1
pontuação da classe (objeto):
'''Criar classe fracionária'''
def __init__(self,*args,**kw):
#Definir pontuação inicial
auto.pontuação = 0
#Definir fonte de fração
self.score_font = pygame.font.SysFont('arial',20)
#Definir pontos de bônus iniciais
ponto próprio = 1
#Defina o número inicial de capturas
frequência própria = 0
def pontuação de contagem (self):
#Plot pontuações dos jogadores
minha_pontuação = self.score_font.render(str(self.score),Falso,(255.255.255))
self.game_window.blit(minha_pontuação,(555,15))
classe GameOver (objeto):
'''Criar jogo ao longo da aula'''
def __init__(self,*args,**kw):
#Definir fonte Game Over
self.over_font=pygame.font.SysFont('arial',80)
#Define o logotipo do GameOver
self.over_sign = 0
classe Win (objeto):
'''Criar classe de vitória no jogo'''
def __init__(self,*args,**kw):
#Definir a fonte You Win
self.win_font=pygame.font.SysFont('arial',80)
#Define o logotipo do Win
self.win_sign = 0
classe Colisão (objeto):
'''Classe de detecção de colisão'''
#Detecção de colisão entre a bola e a borda da janela
def ball_window(self):
se self.ball_x <= self.radius ou self.ball_x >= (self.window_length-self.radius):
self.move_x = -self.move_x
se self.ball_y <= self.radius:
self.move_y = -self.move_y
#Detecção de colisão de bola e raquete
def ball_rect(self):
#Definir identificador de colisão
self.collision_sign_x = 0
self.collision_sign_y = 0
se self.ball_x <(self.mouse_x-self.rect_length//2):
self.closestpoint_x = self.mouse_x-self.rect_length //2
self.collision_sign_x = 1
elif self.ball_x > (self.mouse_x+self.rect_length //2):
self.closestpoint_x = self.mouse_x+self.rect_length //2
self.collision_sign_x = 2
outro:
self.ponto mais próximo_x = self.ball_x
self.collision_sign_x = 3
se self.ball_y <(self.window_wide-self.rect_wide):
self.closestpoint_y = (self.window_wide-self.rect_wide)
self.collision_sign_y = 1
elif self.ball_y > self.window_wide:
self.closestpoint_y = self.window_wide
self.collision_sign_y = 2
outro:
self.ponto mais próximo_y = self.ball_y
self.collision_sign_y = 3
#Defina a distância entre a raquete e o ponto mais próximo do centro do círculo e do centro do círculo
self.distance = math.sqrt(math.pow(self.closestpoint_x-self.ball_x,2)+math.pow(self.closestpoint_y-self.ball_y,2))
#Detecção de colisão da bola nas situações esquerda, superior central e superior direita da raquete
se self.distance <self.radius e self.collision_sign_y == 1 e (self.collision_sign_x == 1 ou self.collision_sign_x == 2):
se self.collision_sign_x == 1 e self.move_x > 0:
self.move_x = -self.move_x
self.move_y = - self.move_y
se self.collision_sign_x == 1 e self.move_x < 0:
self.move_y = - self.move_y
se self.collision_sign_x == 2 e self.move_x < 0:
self.move_x = -self.move_x
self.move_y = - self.move_y
se self.collision_sign_x == 2 e self.move_x > 0:
self.move_y = - self.move_y
se self.distance <self.radius e self.collision_sign_y == 1 e self.collision_sign_x == 3:
self.move_y = - self.move_y
#Detecção de colisão da bola no meio dos lados esquerdo e direito da raquete
se self.distance <self.radius e self.collision_sign_y == 3:
self.move_x = -self.move_x
#Detecção de colisão entre bola e tijolo
def bola_tijolo(self):
#Definir identificador de colisão
self.collision_sign_bx = 0
self.collision_sign_by = 0
se self.ball_x <self.brick_x:
self.ponto mais próximo_bx = self.brick_x
self.collision_sign_bx = 1
elif self.ball_x > self.brick_x+self.brick_length:
self.ponto mais próximo_bx = self.brick_x+self.brick_length
self.collision_sign_bx = 2
outro:
self.ponto mais próximo_bx = self.ball_x
self.collision_sign_bx = 3
se self.ball_y <self.brick_y:
self.ponto mais próximo_by = self.brick_y
self.collision_sign_by = 1
elif self.ball_y > self.brick_y+self.brick_wide:
self.ponto mais próximo_by = self.brick_y+self.brick_wide
self.collision_sign_by = 2
outro:
self.ponto mais próximo_by = self.ball_y
self.collision_sign_by = 3
#Defina a distância entre o tijolo e o ponto mais próximo do centro do círculo e do centro do círculo
self.distanceb = math.sqrt(math.pow(self.closestpoint_bx-self.ball_x,2)+math.pow(self.closestpoint_by-self.ball_y,2))
#Detecção de colisão da bola em três situações: esquerda, meio superior e superior direito no tijolo
se self.distanceb < self.radius e self.collision_sign_by == 1 e (self.collision_sign_bx == 1 ou self.collision_sign_bx == 2):
se self.collision_sign_bx == 1 e self.move_x > 0:
self.move_x = -self.move_x
self.move_y = - self.move_y
se self.collision_sign_bx == 1 e self.move_x < 0:
self.move_y = - self.move_y
se self.collision_sign_bx == 2 e self.move_x < 0:
self.move_x = -self.move_x
self.move_y = - self.move_y
se self.collision_sign_bx == 2 e self.move_x > 0:
self.move_y = - self.move_y
se self.distanceb <self.radius e self.collision_sign_by == 1 e self.collision_sign_bx == 3:
self.move_y = - self.move_y
# Detecção de colisão da bola em três situações: esquerda, centro inferior e inferior direito sob os tijolos
se self.distanceb < self.radius e self.collision_sign_by == 2 e (self.collision_sign_bx == 1 ou self.collision_sign_bx == 2):
se self.collision_sign_bx == 1 e self.move_x > 0:
self.move_x = -self.move_x
self.move_y = - self.move_y
se self.collision_sign_bx == 1 e self.move_x < 0:
self.move_y = - self.move_y
se self.collision_sign_bx == 2 e self.move_x < 0:
self.move_x = -self.move_x
self.move_y = - self.move_y
se self.collision_sign_bx == 2 e self.move_x > 0:
self.move_y = - self.move_y
se self.distanceb <self.radius e self.collision_sign_by == 2 e self.collision_sign_bx == 3:
self.move_y = - self.move_y
#Detecção de colisão da bola no meio dos lados esquerdo e direito do tijolo
se self.distanceb <self.radius e self.collision_sign_by == 3:
self.move_x = -self.move_x
classe Principal (GameWindow, Rect, Bola, Tijolo, Colisão, Pontuação, Vitória, GameOver):
'''Crie a classe principal do programa'''
def __init__(self,*args,**kw):
super(Principal,self).__init__(*args,**kw)
super(GameWindow,self).__init__(*args,**kw)
super(Ret,self).__init__(*args,**kw)
super(bola,self).__init__(*args,**kw)
super(Brick,self).__init__(*args,**kw)
super(colisão,self).__init__(*args,**kw)
super(pontuação,self).__init__(*args,**kw)
super(Win,self).__init__(*args,**kw)
#Define o identificador de início do jogo
sinal_inicial = 0
enquanto Verdadeiro:
self.background()
self.rectmove()
self.countscore()
se self.over_sign == 1 ou self.win_sign == 1:
quebrar
#Obter status da janela do jogo
para evento em pygame.event.get():
se evento.type == pygame.QUIT:
sys.exit()
se evento.type == MOUSEBUTTONDOWN:
matriz_pressionada = pygame.mouse.get_pressed()
se matriz_pressionada[0]:
sinal_inicial = 1
se start_sign == 0:
self.ballready()
outro:
self.ballmove()
self.brickarrange()
#Atualizar janela do jogo
pygame.display.update()
#Controle a frequência de atualização da janela do jogo
tempo.sleep(0,010)
se __nome__ == '__principal__':
pygame.init()
pygame.font.init()
catchball = Principal()
3. Pontos de conhecimento 1. Herança de múltiplas classes pai
Os métodos de herança do Python são divididos em profundidade e largura. Python2 é dividido em dois tipos: herança de pesquisa em profundidade de classe clássica (classe A:), herança de pesquisa em largura de classe de novo estilo (classe A (objeto): ), Classe clássica Python3 O método de herança de classes de novo estilo é consistente com o método de herança de classe de novo estilo de python2, e ambos são métodos de herança em largura.
Método de herança de pesquisa em profundidade de classes clássicas:
como mostra a imagem
classe B(A)
classe C(A)
classe D(B,C)
(1) Se a classe D tiver um construtor, reescreva a herança de todas as classes pai
(2) Se a classe D não tiver construtor e a classe B tiver um construtor, então a classe D herdará o construtor da classe B.
(3) Se a classe D não tiver construtor e a classe B não tiver construtor, a classe D herdará o construtor da classe A em vez do construtor da classe C.
(4) Se a classe D não tem construtor, a classe B não tem construtor e a classe A não tem construtor, então a classe D herdará o construtor da classe C.
Herança de pesquisa em amplitude para classes de novo estilo:
como mostra a imagem
classe B(A)
classe C(A)
classe D(B,C)
(1) Se a classe D tiver um construtor, reescreva a herança de todas as classes pai
(2) Se a classe D não tiver construtor e a classe B tiver um construtor, então a classe D herdará o construtor da classe B.
(3) Se a classe D não tiver construtor e a classe B não tiver construtor, a classe D herdará o construtor da classe C em vez do construtor da classe A.
(4) Se a classe D não tem construtor, a classe B não tem construtor e a classe C não tem construtor, então a classe D herdará o construtor da classe A.
Através da análise acima, todos devem ter clareza sobre a ordem de herança das classes em Python. Então surge a pergunta: se eu não quiser reescrever o construtor da classe pai, o que devo fazer se quiser que ambos os construtores da classe pai subclasse e a classe pai tenham efeito? A solução requer o uso da palavra-chave super, que se refere ao objeto direto da classe pai. Você pode usar super para acessar métodos ou propriedades na classe pai que são substituídas pela subclasse.
classe A (objeto):
def __init__(self,*args,**kw)
classe B(A):
def __init__(self,*args,**kw)
super(B,self).__init__(*args,**kw)
classe C(A):
def __init__(self,*args,**kw)
super(C,self).__init__(*args,**kw)
classe D(B,C):
def __init__(self,*args,**kw)
super(D,self).__init__(*args,**kw)
super(B,self).__init__(*args,**kw)
2. Modelo matemático de detecção de colisão
Na verdade, os problemas de programação são, em última análise, problemas matemáticos. Este jogo envolve o problema de detecção de colisão de círculos e retângulos 2D:
O princípio da detecção de colisão: encontrando o ponto no retângulo mais próximo do centro do círculo e, em seguida, julgando se a distância entre o ponto e o centro do círculo é menor que o raio do círculo, se for menor, é é uma colisão.
Então, como encontrar o ponto no retângulo mais próximo do centro do círculo? A seguir, pesquisamos nas direções do eixo x e do eixo y, respectivamente. Por conveniência de descrição, primeiro concordamos com as seguintes variáveis:
(1) O ponto no retângulo mais próximo do centro do círculo é uma variável: ponto mais próximo = [x, y]
(2) Retângulo retângulo = [x, y, l, w] canto superior esquerdo e comprimento, largura
(3) Círculo círculo = [x, y, r] centro e raio
Primeiro o eixo x:
Se o centro do círculo estiver no lado esquerdo do retângulo (se círculo_x < rect_x), então ponto mais próximo_x = rect_x.
Se o centro do círculo estiver no lado direito do retângulo (elif círculo_x > rect_x + rect_l), então ponto mais próximo_x = rect_x + rect_l.
Se o centro do círculo estiver diretamente acima e abaixo do retângulo (caso contrário), então ponto mais próximo_x = círculo_x.
Da mesma forma, para o eixo y:
Se o centro do círculo estiver acima do retângulo (se círculo_y < rect_y), então ponto mais próximo_y = rect_y.
Se o centro do círculo estiver abaixo do retângulo (elif círculo_y > rect_y + rect_w), então ponto mais próximo_y = rect_y + rect_w.
O centro do círculo está nos lados esquerdo e direito do retângulo (caso contrário), então ponto mais próximo_y = círculo_y.
Portanto, o método acima pode ser usado para encontrar o ponto no retângulo mais próximo do centro do círculo e, em seguida, usar a "fórmula da distância entre dois pontos" para obter a distância entre o "ponto mais próximo" e o "centro do círculo" e, finalmente, compará-lo com o raio da proporção do círculo, você pode determinar se ocorreu uma colisão.
distância=math.sqrt(math.pow(ponto mais próximo_x-círculo_x,2)+math.pow(ponto mais próximo_y-círculo_y,2))
se distância < círculo.r :
return True �C colisão ocorreu
outro :
return False �C Nenhuma colisão ocorreu
O texto acima é a integração detalhada do jogo Python Brickbreaker apresentado pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe-me uma mensagem e o editor responderá a tempo. Gostaria também de agradecer a todos pelo apoio ao site da Script House!