C'est la première fois que vous participez à l'activité de rédaction d'un essai sur la création de singes, et il y aura certainement une grande vague ! Σ(⊙▽⊙"a!!!
Avant la fin de l'été, surfons à nouveau, et sentons l'esprit assidu des programmeurs sous le soleil d'été, et nulle part où mettre les fondations.
J'ai appris un peu les compétences de Pygame récemment, et je me sens un peu dépassé. J'ai créé un jeu de "Program Ape Riding the Wind and Waves" avec une vague d'opérations. J'espère que tout le monde l'aime.
1. Affichage du jeu
Le soi-disant : commencez par une image, et tout dépend du montage . Mettez les images et les animations en premier.
Le gameplay est très simple, appuyez sur le singe de l'espace ↑ pour sauter, éviter l'énorme vague d'attaque, plus le temps est long, plus le score est élevé et le jeu se termine lorsque l'énorme vague est rencontrée .
2. Logique du jeu
Par souci de simplicité, il n'est pas expliqué ici en termes de structure de code. Le jeu peut être grossièrement divisé en quatre parties, à savoir :
(1) Contexte du jeu
1. Fond de ciel. Le ciel blanc parsemé de multiples lignes horizontales bleues utilise le code Python pour faire bouger le fond du ciel en continu de droite à gauche , créant ainsi l'illusion que le singe se déplace vers la droite .
Code du sprite d'arrière-plan :
class Background(GameSprite):
"""游戏背景精灵"""
def __init__(self,image_path, is_alt=False):
# 1.调用父类方法实现精灵的创建(image/rect/speed)
super().__init__(image_path)
# 2.判断是否是交替图像，如果是，需要设置初始位置
if is_alt is True:
self.rect.x = self.rect.width
else:
self.rect.x = 0
def update(self):
# 1.调用父类的方法实现
super().update()
# 2.判断是否移出屏幕，如果移出屏幕，将图像设置到屏幕的上方
if self.rect.x <= -SCREEN_RECT.width:
self.rect.x = self.rect.width2. Fond océanique. L'arrière-plan de l'océan utilise deux images d'arrière-plan de l' océan intérieur et de l' océan extérieur , et en même temps rend leur vitesse de déplacement incohérente avec le fond du ciel , et la vitesse de déplacement entre les deux océans intérieur et extérieur est également incohérente , créant ainsi un trois -sens dimensionnel du jeu. , de sorte que les jeux 2D puissent augmenter la sensation tridimensionnelle de la 3D.
def __create_sprites(self):
"""创建背景精灵和精灵组"""
# 天空背景
bg1 = Background("./images/background_16_9.png", False)
bg2 = Background("./images/background_16_9.png", True)
self.back_group = pygame.sprite.Group(bg1, bg2)
# 内层海洋背景
sea_bg_1 = Background("./images/sea_bg_1_16_9.png", False)
sea_bg_2 = Background("./images/sea_bg_1_16_9.png", True)
#移动速度
sea_bg_1.speed = 2
sea_bg_2.speed = 2
sea_bg_1.rect.bottom = SCREEN_RECT.height
sea_bg_2.rect.bottom = SCREEN_RECT.height
self.sea_bg_ground_1 = pygame.sprite.Group(sea_bg_1, sea_bg_2)
# 外层海洋背景
sea_bg_3 = Background("./images/sea_bg_2_16_9.png", False)
sea_bg_4 = Background("./images/sea_bg_2_16_9.png", True)
# 移动速度
sea_bg_3.speed = 3
sea_bg_4.speed = 3
sea_bg_3.rect.bottom = SCREEN_RECT.height
sea_bg_4.rect.bottom = SCREEN_RECT.height
self.sea_bg_ground_2 = pygame.sprite.Group(sea_bg_3, sea_bg_4)(2) Sprite de jeu de singe (joueur)
1. Faites sauter le lutin de singe de haut en bas. Utilisez Python pour surveiller le temps du clavier. Lorsque la barre d'espace du clavier est enfoncée, donnez au sprite du singe une vitesse vers le haut (valeur négative sur l'axe y), et lorsque la barre d'espace du clavier n'est pas enfoncée, donnez au sprite du singe une vitesse vers le bas ( valeur positive sur l'axe y) vitesse. , de sorte que le sprite singe puisse sauter de haut en bas.
Le code principal est le suivant :
# 使用键盘提供的方法获取键盘按键 - 按键元组
keys_pressed = pygame.key.get_pressed()
# 判断用户按下键盘空格键
if keys_pressed[pygame.K_SPACE]:
# 跳起
self.man.speed = -10
else:
# 下降
self.man.speed = 102. Empêchez les singes de voler hors de l'écran de jeu. Utilisez le code Python pour surveiller la position du singe. Lorsque la valeur de l'axe des y du singe est inférieure à 0 (en touchant le bord supérieur de l'écran), la valeur de l'axe des y est réinitialisée à 0 et lorsque la valeur de l'axe des y du singe est supérieure supérieur à 360 (touchant le bord inférieur de l'écran) y L'axe est réinitialisé à 360.
Le code principal est le suivant :
def update(self):
# 猴子在水平方向移动
self.rect.y += self.speed
# 控制猴子不能移出屏幕
if self.rect.y < 0:
self.rect.y = 0
elif self.rect.bottom > self.bottom_to_ground:
self.rect.bottom = self.bottom_to_ground3. Laissez les singes être placés entre l'océan intérieur et l'océan extérieur pour augmenter le sens de la superposition dans le jeu. Lorsque vous appelez la fonction d'interface d'actualisation de Pygame, appelez d'abord la fonction d'actualisation de l'océan intérieur, puis appelez la fonction d'actualisation du sprite de singe et enfin appelez la fonction d'actualisation de l'océan extérieur, qui peut obtenir l'effet souhaité.
Le code principal est le suivant :
def __update_sprites(self):
"""刷新各个精灵组"""
# 先刷新内层海洋
self.sea_bg_ground_1.update()
self.sea_bg_ground_1.draw(self.screen)
# 再刷新猴子
self.man_group.update()
self.man_group.draw(self.screen)
# 最后刷新外层海洋
self.sea_bg_ground_2.update()
self.sea_bg_ground_2.draw(self.screen)(3) Énergie du jeu Julang (ennemi)
1. Une énorme vague est générée à chaque période de temps.L'énorme vague apparaît de droite à gauche, et la vitesse est rapide ou lente. Commencez par hériter de pygame.sprite.Sprite pour créer une classe de sprites à vagues géantes avec des attributs tels que la vitesse.
class Wave(GameSprite):
"""海浪精灵"""
def __init__(self):
# 1.调用父类方法，创建海浪精灵，同时指定海浪图片
super().__init__("./images/wave.png")
# 2.指定海浪的初始随机速度
self.speed = random.randint(2, 4)
# 3.指定海浪的初始随机位置
self.rect.x = SCREEN_RECT.width
self.rect.bottom = SCREEN_RECT.heightCréez ensuite l' événement personnalisé Pygame CREATE_WAVE_EVENT.
# 创建海浪的定时器事件常量
CREATE_WAVE_EVENT = pygame.USEREVENT+1En même temps, utilisez pygame.time.set_timer pour créer une minuterie, qui déclenche l'événement toutes les 3 secondes.
# 4.设置定时器事件——每3秒创建一次海浪
pygame.time.set_timer(CREATE_WAVE_EVENT, 3000)Enfin, si le gestionnaire d'écoute d'événements trouve l'événement , il crée un sprite de vague géant et rejoint le groupe de sprites.
elif event.type == CREATE_WAVE_EVENT:
# 创建海浪精灵
wave = Wave()
# 将海浪精灵添加到海浪精灵组
self.wave_group.add(wave)2. Le jeu se termine après la collision des vagues géantes avec les singes. Chaque image utilise def __check_collide(self) pour détecter si le sprite singe et le sprite vague géant entrent en collision. S'il y a une collision , le jeu se termine ce tour.
Le code de détection de collision est le suivant :
def __check_collide(self):
# 1.撞到海浪
waves = pygame.sprite.spritecollide(self.man, self.wave_group, True)
# 2.判断碰撞列表长度
if len(waves) > 0:
# 该回合游戏结束，显示菜单
self.menu_sprite.display = True
self.game_state = 03. Une fois que la vague géante est sortie de l'écran de gauche, supprimez la vague géante. Pour économiser de la mémoire, le sprite d'onde doit être supprimé lorsqu'une onde non touchée se déplace de droite à gauche sur le bord gauche de l'écran. L'opération de suppression peut être mise en œuvre en jugeant si le côté droit de l'onde géante est plus petit que le bord gauche de l'écran à chaque image .
(4) Chronomètre et pointage
1. Événements de minuterie personnalisés, chaque numéro de 1 seconde moins 1 . Le temps de jeu par défaut du jeu est de 30 secondes. Après le début du jeu, le compte à rebours commence et les nombres 30, 29 et 28 sont mis à jour dans le coin supérieur droit. Semblable à la création d'une énorme vague, vous pouvez d'abord créer un événement de compte à rebours, puis utiliser une minuterie pour déclencher chaque seconde, et enfin effectuer l'opération de rafraîchissement du nombre dans la fonction d'événement d'écouteur.
Le code principal est le suivant :
Créez un événement personnalisé CREATE_I_EVENT .
# 创建游戏倒计时的定时器常量
CREATE_I_EVENT = pygame.USEREVENT+2En même temps, utilisez pygame.time.set_timer pour créer une minuterie, qui déclenche l'événement toutes les 1 seconde.
# 5.设置定时器事件——倒计时每1秒触发一次
pygame.time.set_timer(CREATE_I_EVENT, 1000)Enfin, si le gestionnaire d'écouteur d'événements trouve l'événement , le compte à rebours est décrémenté de 1 .
elif event.type == CREATE_I_EVENT:
# 倒计时减1秒
self.countdown_sprite.start_time = self.countdown_sprite.start_time - 12. Ajoutez dix points pour chaque seconde. C'est la même chose que le compte à rebours, mais ici, il ajoute dix points chaque seconde.
elif event.type == CREATE_I_EVENT:
# 每过1秒加十分
self.score_sprite.score = self.score_sprite.score + 103. Lorsque le jeu redémarre, réinitialisez le chronomètre et le score. Si l'utilisateur clique pour redémarrer le jeu, réinitialisez les propriétés appropriées pour redémarrer le jeu.
3. Le code source complet du jeu
Le jeu est enfin terminé ! Nima ! Je dois à nouveau programmer et écrire des articles. o(╥﹏╥)o, le texte du code n'est pas facile, merci de bien vouloir me soutenir, Merci♪(･ω･)ﾉ, nous ferons une autre vague sur cette base pour enrichir le gameplay.
Enfin, collez le code source complet et les matériaux (certains matériaux proviennent d'Internet, si vous rencontrez des problèmes, veuillez contacter le blogueur pour s'en occuper, merci !) Il peut uniquement être empaqueté et téléchargé.