Es la primera vez que participa en la actividad de escritura de ensayos de creación de simios, ¡y definitivamente habrá una gran ola! Σ(⊙▽⊙"a!!!
Antes de que termine el verano, volvamos a surfear y sintamos el espíritu asiduo de los programadores bajo el sol de verano, y sin ningún lugar donde poner los cimientos.
Aprendí un poco de las habilidades de Pygame recientemente, y me siento un poco exagerado. Creé un juego de "Program Ape Riding the Wind and Waves" con una ola de operaciones. Espero que a todos les guste.
1. Visualización del juego
Los llamados: comienzan con una imagen, y todo depende de la edición . Pon imágenes y animaciones primero.
El modo de juego es muy simple, presione el mono espacial ↑ para saltar, evitar el ataque de la gran ola, cuanto más tiempo, mayor será la puntuación, y el juego termina cuando se encuentra la gran ola .
2. Lógica del juego
En aras de la simplicidad, no se explica aquí en términos de estructura de código. El juego se puede dividir aproximadamente en cuatro partes, a saber:
(1) Fondo del juego
1. Fondo del cielo. El cielo blanco salpicado de múltiples líneas horizontales azules utiliza el código Python para hacer que el fondo del cielo se mueva continuamente de derecha a izquierda , creando así la ilusión de que el mono se mueve hacia la derecha .
Código de imagen de fondo:
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. Fondo del océano. El fondo del océano utiliza dos imágenes de fondo del océano interior y el océano exterior , y al mismo tiempo hace que su velocidad de movimiento sea inconsistente con el fondo del cielo , y la velocidad de movimiento entre los dos océanos interior y exterior también es inconsistente , creando así un tres -sentido dimensional del juego. , para que los juegos 2D puedan aumentar la sensación tridimensional de 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 del juego del mono (jugador)
1. Haz que el sprite del mono salte arriba y abajo. Usa Python para controlar el tiempo del teclado. Cuando se presiona la barra espaciadora del teclado, dale al sprite del mono una velocidad hacia arriba (valor negativo en el eje y), y cuando no se presiona la barra espaciadora del teclado, dale al sprite del mono una velocidad hacia abajo ( valor positivo en el eje y) speed. , de modo que el sprite del mono pueda saltar hacia arriba y hacia abajo.
El código principal es el siguiente:
# 使用键盘提供的方法获取键盘按键 - 按键元组
keys_pressed = pygame.key.get_pressed()
# 判断用户按下键盘空格键
if keys_pressed[pygame.K_SPACE]:
# 跳起
self.man.speed = -10
else:
# 下降
self.man.speed = 102. Evita que los monos salgan volando de la pantalla del juego. Use el código Python para monitorear la posición del mono. Cuando el valor del eje y del mono es menor que 0 (tocando el borde superior de la pantalla), el valor del eje y se restablece a 0, y cuando el valor del eje y del mono es mayor de 360 (tocando el borde inferior de la pantalla) y El eje se restablece a 360.
El código principal es el siguiente:
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. Deje que los monos se coloquen entre el océano interior y el océano exterior para aumentar la sensación de estratificación en el juego. Al llamar a la función de interfaz de actualización de Pygame, primero llame a la función de actualización del océano interior, luego llame a la función de actualización del sprite de mono y finalmente llame a la función de actualización del océano exterior, que puede lograr el efecto deseado.
El código principal es el siguiente:
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) Energía del juego Julang (enemigo)
1. Cada período de tiempo se genera una gran ola. La gran ola aparece de derecha a izquierda, y la velocidad es rápida o lenta. Primero herede pygame.sprite.Sprite para crear una clase de sprite de onda gigante con atributos como la velocidad.
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.heightLuego crea el evento personalizado de Pygame CREATE_WAVE_EVENT.
# 创建海浪的定时器事件常量
CREATE_WAVE_EVENT = pygame.USEREVENT+1Al mismo tiempo, use pygame.time.set_timer para crear un temporizador, que activa el evento cada 3 segundos.
# 4.设置定时器事件——每3秒创建一次海浪
pygame.time.set_timer(CREATE_WAVE_EVENT, 3000)Finalmente, si el controlador de escucha de eventos encuentra el evento , crea un sprite de onda gigante y se une al grupo de sprite.
elif event.type == CREATE_WAVE_EVENT:
# 创建海浪精灵
wave = Wave()
# 将海浪精灵添加到海浪精灵组
self.wave_group.add(wave)2. El juego termina después de que las olas gigantes chocan con los monos. Cada cuadro usa def __check_collide(self) para detectar si el sprite del mono y el sprite de la ola gigante chocan. Si hay una colisión , el juego termina esta ronda.
El código de detección de colisión es el siguiente:
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. Después de que la ola gigante salga de la pantalla izquierda, elimine la ola gigante. Para ahorrar memoria, el sprite de onda debe eliminarse cuando una onda intacta se mueve de derecha a izquierda desde el borde izquierdo de la pantalla. La operación de borrado se puede implementar juzgando si el lado derecho de la onda gigante es más pequeño que el borde izquierdo de la pantalla en cada cuadro .
(4) Temporizador y puntuación
1. Eventos de temporizador personalizados, cada número de 1 segundo menos 1 . El tiempo de reproducción predeterminado del juego es de 30 segundos. Después de que comienza el juego, comienza la cuenta regresiva y los números 30, 29 y 28 se actualizan en la esquina superior derecha. De manera similar a la creación de una gran ola, primero puede crear un evento de cuenta regresiva, luego usar un temporizador para activar cada segundo y finalmente realizar la operación de número de actualización en la función de evento de escucha.
El código principal es el siguiente:
Crear evento personalizado CREATE_I_EVENT .
# 创建游戏倒计时的定时器常量
CREATE_I_EVENT = pygame.USEREVENT+2Al mismo tiempo, use pygame.time.set_timer para crear un temporizador, que activa el evento cada 1 segundo.
# 5.设置定时器事件——倒计时每1秒触发一次
pygame.time.set_timer(CREATE_I_EVENT, 1000)Finalmente, si el controlador de escucha de eventos encuentra el evento , la cuenta regresiva se reduce en 1 .
elif event.type == CREATE_I_EVENT:
# 倒计时减1秒
self.countdown_sprite.start_time = self.countdown_sprite.start_time - 12. Suma diez puntos por cada segundo. Es lo mismo que la cuenta atrás, pero aquí suma diez puntos cada segundo.
elif event.type == CREATE_I_EVENT:
# 每过1秒加十分
self.score_sprite.score = self.score_sprite.score + 103. Cuando se reinicie el juego, reinicie el cronómetro y la puntuación. Si el usuario hace clic para reiniciar el juego, restablezca las propiedades relevantes para reiniciar el juego.
3. El código fuente completo del juego.
¡El juego finalmente está listo! Nima! Tengo que programar y escribir artículos de nuevo ¡Cansado! o(╥﹏╥)o, el texto del código no es fácil, apóyenme mucho, gracias♪(･ω･)ﾉ, haremos otra ola sobre esta base para enriquecer el juego.
Finalmente, pegue el código fuente completo y los materiales (algunos materiales provienen de Internet, si tiene algún problema, comuníquese con el blogger para solucionarlo, ¡gracias!) Solo se puede empaquetar y descargar.