Bonjour à tous, cet article se concentrera sur les 100 lignes de code de jeu Python simple. Ce que le code de jeu Python peut utiliser est quelque chose que beaucoup de gens veulent comprendre. Pour comprendre le code source du programme de jeu Python, vous devez comprendre les choses suivantes d'abord.
Cette fois, Python est utilisé pour implémenter un petit jeu consistant à attraper des balles et à frapper des briques. Le module pygame doit être importé. Il y a deux résumés d'expérience comme suit :
1. Héritage de plusieurs classes parentes 2. Modèle mathématique de détection de collision
Nous parlerons des points de connaissance plus tard. Voyons d'abord les effets et la mise en œuvre du jeu :
1. Effet de jeu
2.Code du jeu
#Module d'importation
importer pygame
depuis l'importation de pygame.locals *
importer le système, aléatoire, temps, mathématiques
classe GameWindow (objet):
'''Créer une classe de fenêtre de jeu'''
def __init__(self,*args,**kw) :
self.window_length = 600
self.window_wide = 500
#Dessinez la fenêtre de jeu et définissez la taille de la fenêtre
self.game_window = pygame.display.set_mode((self.window_length,self.window_wide))
#Définir le titre de la fenêtre de jeu
pygame.display.set_caption("CatchBallGame")
#Définir les paramètres de couleur d'arrière-plan de la fenêtre de jeu
self.window_color = (135 206 250)
arrière-plan def (soi):
#Dessinez la couleur de fond de la fenêtre de jeu
self.game_window.fill(self.window_color)
classe Ball (objet):
'''Créer une boule'''
def __init__(self,*args,**kw) :
#Définissez les paramètres de rayon, de couleur et de vitesse de déplacement de la balle
self.ball_color = (255 215,0)
self.move_x = 1
self.move_y = 1
self.rayon = 10
def ballready(soi):
#Définissez la position initiale de la balle,
self.ball_x = self.mouse_x
self.ball_y = self.window_wide-self.rect_wide-self.radius
#Dessinez la balle et définissez les conditions de déclenchement du rebond
pygame.draw.circle(self.game_window,self.ball_color,(self.ball_x,self.ball_y),self.radius)
def ballmove (soi):
#Dessinez la balle et définissez les conditions de déclenchement du rebond
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
#Fonction de détection de collision d'appel
self.ball_window()
self.ball_rect()
#La vitesse du ballon double toutes les 5 fois où le ballon est attrapé
si self.distance < self.radius :
auto.fréquence += 1
si self.frequence == 5 :
auto.fréquence = 0
self.move_x += self.move_x
self.move_y += self.move_y
soi.point += soi.point
#Définir les conditions d'échec du jeu
si self.ball_y > 520 :
self.gameover = self.over_font.render("Game Over",False,(0,0,0))
self.game_window.blit(self.gameover,(100,130))
self.over_sign = 1
classe Rect (objet):
'''Créer une classe de raquette'''
def __init__(self,*args,**kw) :
#Définir les paramètres de couleur de la raquette
self.rect_color = (255,0,0)
self.rect_length = 100
self.rect_wide = 10
par défaut rectmove (soi):
#Obtenir les paramètres de position de la souris
self.mouse_x,self.mouse_y = pygame.mouse.get_pos()
#Dessinez la raquette et limitez les limites horizontales
si self.mouse_x >= self.window_length-self.rect_length//2 :
self.mouse_x = self.window_length-self.rect_length//2
si 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 Brick (objet):
def __init__(self,*args,**kw) :
#Définir les paramètres de couleur des briques
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 tuileorganiser (auto):
pour moi dans la plage (5):
pour j dans la plage (6):
self.brick_x = j*(self.brick_length+24)
self.brick_y = i*(self.brick_wide+20)+40
si self.brick_list[i][j] == 1 :
#dessiner des briques
pygame.draw.rect(self.game_window,self.brick_color,(self.brick_x,self.brick_y,self.brick_length,self.brick_wide))
#Fonction de détection de collision d'appel
soi.ball_brick()
si self.distanceb < self.radius :
self.brick_list[i][j] = 0
soi.score += soi.point
#Définir les conditions de victoire du jeu
si 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("Vous gagnez",False,(0,0,0))
self.game_window.blit(self.win,(100,130))
self.win_sign = 1
Score de classe (objet):
'''Créer une classe fractionnaire'''
def __init__(self,*args,**kw) :
#Définir le score initial
self.score = 0
#Définir la police des fractions
self.score_font = pygame.font.SysFont('arial',20)
#Définir des points bonus initiaux
soi.point = 1
#Définir le nombre initial de captures
auto.fréquence = 0
def countscore (soi):
# Tracer les scores des joueurs
mon_score = self.score_font.render(str(self.score),False,(255,255,255))
self.game_window.blit(mon_score,(555,15))
classe GameOver (objet):
'''Créer un jeu par classe'''
def __init__(self,*args,**kw) :
#Définir la police Game Over
self.over_font = pygame.font.SysFont('arial',80)
#Définir le logo GameOver
self.over_sign = 0
classe Win (objet):
'''Créer une classe de victoire de jeu'''
def __init__(self,*args,**kw) :
#Définissez la police You Win
self.win_font = pygame.font.SysFont('arial',80)
#Définir le logo Win
self.win_sign = 0
Collision de classe (objet):
'''Classe de détection de collision'''
#Détection de collision entre la boule et le bord de la fenêtre
def ball_window(soi) :
si self.ball_x <= self.radius ou self.ball_x >= (self.window_length-self.radius) :
self.move_x = -self.move_x
si self.ball_y <= self.radius :
self.move_y = -self.move_y
#Détection de collision balle et raquette
def ball_rect(soi) :
#Définir l'identifiant de collision
self.collision_sign_x = 0
self.collision_sign_y = 0
si 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
autre:
self.closestpoint_x = self.ball_x
self.collision_sign_x = 3
si 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
autre:
self.closestpoint_y = self.ball_y
self.collision_sign_y = 3
#Définir la distance entre la raquette et le point le plus proche du centre du cercle et du centre du cercle
self.distance = math.sqrt(math.pow(self.closestpoint_x-self.ball_x,2)+math.pow(self.closestpoint_y-self.ball_y,2))
#Détection de collision de balle dans trois situations : gauche, haut milieu et haut droit de la raquette
si self.distance < self.radius et self.collision_sign_y == 1 et (self.collision_sign_x == 1 ou self.collision_sign_x == 2) :
si self.collision_sign_x == 1 et self.move_x > 0 :
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_x == 1 et self.move_x < 0 :
self.move_y = - self.move_y
si self.collision_sign_x == 2 et self.move_x < 0 :
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_x == 2 et self.move_x > 0 :
self.move_y = - self.move_y
si self.distance < self.radius et self.collision_sign_y == 1 et self.collision_sign_x == 3 :
self.move_y = - self.move_y
#Détection de collision de la balle au milieu des côtés gauche et droit de la raquette
si self.distance < self.radius et self.collision_sign_y == 3 :
self.move_x = - self.move_x
#Détection de collision entre la balle et la brique
def ball_brick(soi) :
#Définir l'identifiant de collision
self.collision_sign_bx = 0
self.collision_sign_by = 0
si self.ball_x < self.brick_x :
self.closestpoint_bx = self.brick_x
self.collision_sign_bx = 1
elif self.ball_x > self.brick_x+self.brick_length :
self.closestpoint_bx = self.brick_x+self.brick_length
self.collision_sign_bx = 2
autre:
self.closestpoint_bx = self.ball_x
self.collision_sign_bx = 3
si self.ball_y < self.brick_y :
self.closestpoint_by = self.brick_y
self.collision_sign_by = 1
elif self.ball_y > self.brick_y+self.brick_wide :
self.closestpoint_by = self.brick_y+self.brick_wide
self.collision_sign_by = 2
autre:
self.closestpoint_by = self.ball_y
self.collision_sign_by = 3
#Définissez la distance entre la brique et le point le plus proche du centre du cercle et du centre du cercle
self.distanceb = math.sqrt(math.pow(self.closestpoint_bx-self.ball_x,2)+math.pow(self.closestpoint_by-self.ball_y,2))
#Détection de collision de la balle dans trois situations : gauche, en haut au milieu et en haut à droite sur la brique
si self.distanceb < self.radius et self.collision_sign_by == 1 et (self.collision_sign_bx == 1 ou self.collision_sign_bx == 2) :
si self.collision_sign_bx == 1 et self.move_x > 0 :
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 1 et self.move_x < 0 :
self.move_y = - self.move_y
si self.collision_sign_bx == 2 et self.move_x < 0 :
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 2 et self.move_x > 0 :
self.move_y = - self.move_y
si self.distanceb < self.radius et self.collision_sign_by == 1 et self.collision_sign_bx == 3 :
self.move_y = - self.move_y
# Détection de collision du ballon dans trois situations : gauche, bas au milieu et bas à droite sous les briques
si self.distanceb < self.radius et self.collision_sign_by == 2 et (self.collision_sign_bx == 1 ou self.collision_sign_bx == 2) :
si self.collision_sign_bx == 1 et self.move_x > 0 :
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 1 et self.move_x < 0 :
self.move_y = - self.move_y
si self.collision_sign_bx == 2 et self.move_x < 0 :
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 2 et self.move_x > 0 :
self.move_y = - self.move_y
si self.distanceb < self.radius et self.collision_sign_by == 2 et self.collision_sign_bx == 3 :
self.move_y = - self.move_y
#Détection de collision de la balle au milieu des côtés gauche et droit de la brique
si self.distanceb < self.radius et self.collision_sign_by == 3 :
self.move_x = - self.move_x
classe Main (GameWindow, Rect, Ball, Brick, Collision, Score, Win, GameOver):
'''Créer la classe principale du programme'''
def __init__(self,*args,**kw) :
super(Principal, soi).__init__(*args,**kw)
super(GameWindow,self).__init__(*args,**kw)
super(Rect,self).__init__(*args,**kw)
super(Ball,self).__init__(*args,**kw)
super(Brique,self).__init__(*args,**kw)
super(Collision,self).__init__(*args,**kw)
super(Score,self).__init__(*args,**kw)
super(Gagner, soi).__init__(*args,**kw)
#Définir l'identifiant de début de jeu
signe_début = 0
tandis que Vrai :
soi.backgroud()
auto.rectmove()
soi.countscore()
si self.over_sign == 1 ou self.win_sign == 1 :
casser
#Obtenir l'état de la fenêtre de jeu
pour l'événement dans pygame.event.get() :
si event.type == pygame.QUIT :
sys.exit()
si event.type == MOUSEBUTTONDOWN :
pressé_array = pygame.mouse.get_pressed()
si pressé_array[0] :
signe_début = 1
si start_sign == 0 :
soi.ballready()
autre:
soi.ballmove()
self.brickarrange()
#Mettre à jour la fenêtre de jeu
pygame.display.update()
#Contrôlez la fréquence de rafraîchissement de la fenêtre de jeu
temps.sommeil (0,010)
si __name__ == '__main__' :
pygame.init()
pygame.font.init()
catchball = Principal()
3. Points de connaissance 1. Héritage de plusieurs classes parentes
Les méthodes d'héritage de Python sont divisées en profondeur d'abord et en largeur d'abord. Python2 est divisé en deux types : l'héritage de recherche en profondeur d'abord de classe classique (classe A :), l'héritage de recherche en largeur d'abord de classe de nouveau style (classe A (objet) : ), Classe classique Python3 La méthode d'héritage de la classe de nouveau style est cohérente avec la méthode d'héritage de la classe de nouveau style de python2, et les deux sont des méthodes d'héritage en largeur.
Méthode d'héritage de recherche en profondeur des classes classiques :
comme le montre la photo
classe B(A)
classe C(A)
classe D(B,C)
(1) Si la classe D a un constructeur, réécrivez l'héritage de toutes les classes parentes
(2) Si la classe D n'a pas de constructeur et que la classe B a un constructeur, alors la classe D héritera du constructeur de la classe B.
(3) Si la classe D n'a pas de constructeur et que la classe B n'a pas de constructeur, alors la classe D héritera du constructeur de la classe A au lieu du constructeur de la classe C.
(4) Si la classe D n'a pas de constructeur, la classe B n'a pas de constructeur et la classe A n'a pas de constructeur, alors la classe D héritera du constructeur de la classe C.
Héritage de recherche en largeur pour les classes de nouveau style :
comme le montre la photo
classe B(A)
classe C(A)
classe D(B,C)
(1) Si la classe D a un constructeur, réécrivez l'héritage de toutes les classes parentes
(2) Si la classe D n'a pas de constructeur et que la classe B a un constructeur, alors la classe D héritera du constructeur de la classe B.
(3) Si la classe D n'a pas de constructeur et que la classe B n'a pas de constructeur, alors la classe D héritera du constructeur de la classe C au lieu du constructeur de la classe A.
(4) Si la classe D n'a pas de constructeur, la classe B n'a pas de constructeur et la classe C n'a pas de constructeur, alors la classe D héritera du constructeur de la classe A.
Grâce à l'analyse ci-dessus, tout le monde devrait être clair sur l'ordre d'héritage des classes en Python. La question se pose alors : si je ne veux pas réécrire le constructeur de la classe parent, que dois-je faire si je veux à la fois le constructeur de la classe parent la sous-classe et la classe parent prennent effet ? La solution nécessite l'utilisation du mot-clé super, qui fait référence à l'objet de classe parent direct. Vous pouvez utiliser super pour accéder aux méthodes ou propriétés de la classe parent qui sont remplacées par la sous-classe.
classe A (objet):
def __init__(soi,*args,**kw)
classe B(A) :
def __init__(soi,*args,**kw)
super(B,self).__init__(*args,**kw)
classe C(A):
def __init__(soi,*args,**kw)
super(C,self).__init__(*args,**kw)
classe D(B,C):
def __init__(soi,*args,**kw)
super(D,self).__init__(*args,**kw)
super(B,self).__init__(*args,**kw)
2. Modèle mathématique de détection de collision
En fait, les problèmes de programmation sont en fin de compte des problèmes mathématiques. Ce jeu implique la détection de collisions entre des cercles et des rectangles 2D :
Le principe de la détection de collision : en trouvant le point sur le rectangle le plus proche du centre du cercle, puis en jugeant si la distance entre le point et le centre du cercle est inférieure au rayon du cercle, si elle est inférieure, elle est une collision.
Alors comment trouver le point du rectangle le plus proche du centre du cercle ? Ensuite, nous recherchons respectivement dans les deux directions de l’axe des x et de l’axe des y. Pour faciliter la description, nous nous accordons d’abord sur les variables suivantes :
(1) Le point du rectangle le plus proche du centre du cercle est une variable : point le plus proche = [x, y]
(2) Rectangle rect = [x, y, l, w] coin supérieur gauche et longueur, largeur
(3) Cercle cercle = [x, y, r] centre et rayon
Tout d'abord l'axe des x :
Si le centre du cercle est sur le côté gauche du rectangle (si circle_x < rect_x), alors closepoint_x = rect_x.
Si le centre du cercle est sur le côté droit du rectangle (elif circle_x > rect_x + rect_l), alors closepoint_x = rect_x + rect_l.
Si le centre du cercle est directement au-dessus et en dessous du rectangle (sinon), alors closepoint_x = circle_x.
De même, pour l'axe y :
Si le centre du cercle est au-dessus du rectangle (si circle_y < rect_y), alors closepoint_y = rect_y.
Si le centre du cercle est en dessous du rectangle (elif circle_y > rect_y + rect_w)), alors closepoint_y = rect_y + rect_w.
Le centre du cercle se trouve sur les côtés gauche et droit du rectangle (sinon), alors closepoint_y = circle_y.
Par conséquent, la méthode ci-dessus peut être utilisée pour trouver le point du rectangle le plus proche du centre du cercle, puis utiliser la « formule de distance entre deux points » pour obtenir la distance entre le « point le plus proche » et le « centre du cercle", et enfin comparez-le avec le rayon du rapport du cercle, vous pouvez déterminer si une collision s'est produite.
distance=math.sqrt(math.pow(point le plus proche_x-circle_x,2)+math.pow(point le plus proche_y-circle_y,2))
si distance < cercle.r :
retour Vrai collision �C survenue
autre :
return False �C Aucune collision ne s'est produite
Ce qui précède est l'intégration détaillée du jeu Python Brickbreaker présenté par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Je voudrais également remercier tout le monde pour votre soutien au site Web de Script House !