El segundo bebé estará en primer grado dentro de un año, pero no puede aprender pinyin en esta etapa. Compré un gráfico mural en pinyin y lo puse en la pared, pero ni siquiera puedo colocarlo al lado. Tuve una idea repentina, ¿por qué no usar el pygame de Python para crear un juego pequeño? ¡Puedes aprender mientras juegas, haciendo que el aprendizaje sea divertido! Esto es pan comido para los programadores, así que comencé a hacerlo y tomó forma en dos noches. Lo resumiré aquí y lo compartiré con amigos que lo necesiten.
prefacio
Esto no es sólo un juego, sino también una película de divulgación científica que te llevará a experimentar los viajes interestelares. Aprenda sobre galaxias, galaxias, constelaciones y agujeros negros. El cielo está lleno de estrellas y el deslumbrante cielo estrellado siempre puede traer a las personas una imaginación infinita, estimular el deseo de explorar y estimular el instinto de buscar conocimiento.
El minijuego de pygame "Plane Pinyin Battle" es un juego especialmente diseñado para niños, cuyo objetivo es ayudarlos a aprender las letras Pinyin y estimular su interés por la programación y su curiosidad por el espacio. Este juego es divertido y educativo. A través del sencillo proceso de producción de juegos de Python, los niños pueden experimentar el desarrollo de juegos y aprender los conceptos básicos de programación.
El interés es el mejor maestro.
El fondo del juego tiene como tema el espacio y la aviación, lo que proporciona un espacio maravilloso para que los niños exploren. Pueden jugar a ser astronautas y volar en el espacio mientras aprenden el alfabeto Pinyin. El plan de seguimiento es que en el juego, los niños deben usar las letras pinyin correctas para derrotar enemigos o superar obstáculos según las letras o caracteres chinos que aparecen en la pantalla. A través de este método interactivo aprenderán mientras se divierten, aumentarán sus conocimientos, cultivarán su exploración e imaginación sobre el futuro del universo, y aumentarán su curiosidad, deseo de explorar y sed de conocimiento sobre el futuro.
El propósito de este juego es permitir que los niños mejoren sus habilidades de memoria y reconocimiento de letras pinyin mientras disfrutan del juego. Al interactuar con el juego, se irán familiarizando gradualmente con la pronunciación y escritura de las letras Pinyin, sentando una base sólida para su futuro aprendizaje del idioma. Además, al participar en el proceso de creación de juegos, los niños pueden desarrollar el pensamiento lógico, las habilidades de resolución de problemas y la creatividad mientras experimentan la diversión de la programación.
De hecho, lo he pensado desde el principio, dado que a los niños les encantan los juegos, ¿por qué la mayoría de los juegos en el mercado se centran en la adicción y en las luchas y mejoras contra monstruos sin sentido? ¿Por qué no crear algunos juegos con temas de aprendizaje a través del juego, popularizar el conocimiento científico, explorar lo desconocido, aumentar la curiosidad y crecer simultáneamente?
El minijuego de pygame Airplane: Pinyin Battle gira en torno al concepto de aprender a través del juego, popularizar el conocimiento científico y estimular la curiosidad. Proporciona a los niños una práctica de aprendizaje interesante y educativa, aumenta su interés en aprender las letras pinyin y les proporciona un base sólida para el aprendizaje futuro. ¡Exploremos el universo juntos, aprendamos conocimientos y comencemos la diversión de la programación!
Si te gusta, dale me gusta y guárdalo, puede usarse como regalo para tu bebé.
El código fuente contiene todos los materiales y se puede ejecutar.
Enlace de descarga: https://download.csdn.net/download/qq8864/88314308
Descargue recursos y agrégueme como amigo y le brindaremos soporte técnico gratuito. Para que tú también puedas jugar con tu bebé.
Primero echemos un vistazo a las representaciones:
¿Recuerdas la película clásica "Interstellar"? ¡Este pequeño juego te permite experimentar viajes interestelares y ver agujeros negros!
Mirar las estrellas siempre provoca en la gente un ensueño sin fin.
Introducción al juego
La jugabilidad es muy simple, el juego de guerra de aviones original está rediseñado para tocar letras pinyin y se calcula la puntuación. Cada vez que se pulsa una letra, se emite correspondientemente su pronunciación. Presione las teclas arriba, abajo, izquierda y derecha para controlar el movimiento del avión hacia arriba, abajo, izquierda y derecha. Pulsa la barra espaciadora para enviar balas. La bala golpea la letra pinyin y luego envía la pronunciación de la letra correspondiente. Entre ellos, hay meteoritos en movimiento que no pueden ser alcanzados, y se deducirán puntos si son alcanzados. Los fondos de los juegos son diferentes y los maravillosos mundos cósmicos se seleccionan de Internet, incluida la Tierra, la Luna, los meteoritos, Marte y otros planetas importantes, la Vía Láctea, las constelaciones, los agujeros negros y el brillante cielo estrellado.
El plan de seguimiento es que en el juego, los niños deben usar las letras pinyin correctas para derrotar enemigos o superar obstáculos según las letras o caracteres chinos que aparecen en la pantalla. A través de esta forma interactiva aprenderán mientras se divierten, aumentarán sus conocimientos y cultivarán su exploración e imaginación sobre el futuro del universo.
Configura una serie de niveles, cada uno con una imagen de fondo diferente, para que los niños puedan apreciar el misterioso universo al mismo tiempo. Primero despegue de la tierra, vuele más allá de la luna, conozca los ocho planetas, viaje a través del sistema solar, evite los meteoritos y finalmente vuele al universo y al cielo estrellado para explorar el universo brillante.
Volando sobre la Tierra:
Volar a la luna:
Sobrevuelo de Marte:
Sobrevuelo de ocho planetas:
Más tarde saldremos de la Vía Láctea, la constelación de Sagitario, y veremos el misterioso agujero negro. Equivalente a un viaje interestelar, ¡el misterioso universo combinado con la animación de vuelo es bastante impactante!
Preparación ambiental
1. Descargue e instale python3
Sitio web oficial de Python: Bienvenido a Python.org
2. Instale módulos dependientes: pygame, pygame-pgu
Python agrega variables de entorno
3. Reemplace la imagen del recurso instalado por pip (de lo contrario, la descarga del módulo será muy lenta)
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple4. Imágenes y materiales de voz.
5. Herramienta de síntesis de voz sin conexión iFlytek
6.herramienta de recorte y producción de voz goldwave
Implementación del código fuente
La implementación del código fuente es muy simple y cualquiera con un poco de conocimiento básico puede entenderla fácilmente. No entraré en demasiadas introducciones aquí, son básicamente algunos usos básicos de pygame. Si el desafío falla, aparecerá un cuadro de diálogo utilizando el módulo pygame-pgu.
cuadro de diálogo emergente
Ejemplo simple de diálogo emergente:
#退出对话框
class QuitDialog(gui.Dialog):
def __init__(this,main):
title = gui.Label("Dialog Box")
gui.Dialog.__init__(this, title, main)
def close():
pygame.quit()
exit()
app = gui.App() #初始化gui
con = gui.Container() #生成gui的容器
quitDlg = QuitDialog(con) #生成弹窗abc
btn = gui.Button("game over") #生成文字为a的按钮
btn.connect(gui.CLICK, quitDlg.close, None)#将按钮与弹窗的弹出绑定
label = gui.Label("Are you sure you want to quit?")
quitDlg.add(label, 2, 2)
quitDlg.add(btn,2,3) #将按钮安放在容器(0,0)位置
app.init(con) Puntuación de visualización alcanzada
Implementación de visualización de partituras, letras y caracteres chinos:
# 加载字体文件
font_path = "./font/SIMYOU.ttf" # 替换为你的字体文件路径
font_size = 24
font = pygame.font.Font(font_path, font_size)
score = 0
score_txt = "得分:"+str(score) # 要显示的文本
text_surface = font.render(score_txt, True, (255, 255, 255))
#......
score_txt = "得分:"+str(score)
text_surface = font.render(score_txt, True, (255, 0, 255))
screen.blit(text_surface, (680, 10))
if show_image:
screen.blit(fail_image, (300, 100)) # 绘制图像
app.paint()
pygame.display.update()Implementación de animación de sprites.
Principio de la animación: de hecho, la animación consiste en mostrar imágenes estáticas en secuencia. Si la secuencia se muestra más rápido, el cerebro humano entenderá que los caracteres son continuos. La animación en este minijuego, como el efecto de explosión después del impacto de una bala, es una implementación de animación. De hecho, significa cargar tres imágenes por adelantado y luego dejar que el método de actualización de la clase elf actualice las imágenes por sí solo en ciertos intervalos.
La implementación es la siguiente:
class Explode(pygame.sprite.Sprite):
def __init__(self):
super().__init__()
self.images = [pygame.image.load('./image/explode' + str(i) + '.png') for i in range(1, 4)]
self.image_index = 0
self.image = self.images[self.image_index]
self.rect = self.image.get_rect()
self.readt_to_change = 0
sound = pygame.mixer.Sound('./sound/enemyExplode.wav')
sound.play()
def update(self, *args):
if self.image_index < 2:
self.readt_to_change += 1
if self.readt_to_change % 4 == 0:
self.image_index += 1
self.image = self.images[self.image_index]
else:
self.kill()Sprites en Pygame
En Pygame, los sprites (Sprites) son los elementos básicos de varios personajes, objetos y efectos del juego. Los sprites pueden contener imágenes, posiciones, velocidades y otros atributos. Utilice la clase de sprites en Pygame para administrar y actualizar de manera eficiente múltiples objetos de sprites.
Puedes definir tu propia clase de sprite heredando la clase pygame.sprite.Sprite en Pygame. Al definir una clase de elfo, normalmente es necesario establecer la posición inicial, la imagen y otras propiedades del elfo en el método __init__. Por ejemplo, el siguiente código define una clase de sprite simple MySprite:
import pygame
class MySprite(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((50, 50))
self.image.fill((255, 0, 0))
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y Manejo de objetos y eventos sprites
En los juegos, a menudo es necesario manejar interacciones y eventos con objetos sprites. Por ejemplo, detectar colisiones entre sprites, mover sprites, responder a eventos de teclado y mouse, etc. Para manejar objetos y eventos sprites, puedes usar el siguiente código:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# 处理键盘事件
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
my_sprite.rect.x -= 5
if keys[pygame.K_RIGHT]:
my_sprite.rect.x += 5
if keys[pygame.K_UP]:
my_sprite.rect.y -= 5
if keys[pygame.K_DOWN]:
my_sprite.rect.y += 5
# 处理碰撞事件
collision_list = pygame.sprite.spritecollide(my_sprite, my_group, False)
for sprite in collision_list:
El método pygame.event.get() se utiliza para obtener todos los eventos de Pygame. El método pygame.key.get_pressed() se utiliza para detectar el estado de las teclas del teclado. El método pygame.sprite.spritecollide() se utiliza para detectar colisiones entre objetos sprites. Puede agregar código de manejo de eventos adicional según corresponda.
Implementación completa del código fuente
import pygame
import random
from pgu import gui,timer
# 常量
WIDTH, HEIGHT = 800, 600
# 初始化操作
pygame.init()
pygame.mixer.init()
# 创建游戏窗口
screen = pygame.display.set_mode((WIDTH, HEIGHT))
# 设置游戏标题
pygame.display.set_caption('飞机拼音大作战--关注作者：blog.csdn.net/qq8864')
# 添加音乐
pygame.mixer.music.load('./sound/bgLoop.wav')
pygame.mixer.music.set_volume(0.5) # 音量
pygame.mixer.music.play(-1, 0)
# 添加系统时钟
FPS = 40
clock = pygame.time.Clock()
# 创建用户自定义事件，每隔2000毫秒触发一次事件，随机创建敌人
CREATE_ENEMY = pygame.USEREVENT
pygame.time.set_timer(CREATE_ENEMY, 2000)
# 加载字体文件
font_path = "./font/SIMYOU.ttf" # 替换为你的字体文件路径
font_size = 24
font = pygame.font.Font(font_path, font_size)
score = 0
score_txt = "得分:"+str(score) # 要显示的文本
text_surface = font.render(score_txt, True, (255, 255, 255))
fail_image = pygame.image.load("./image/failed.png")
show_image = False # 控制是否显示图片
tup_target = ('a','o','e','i','u','ü','b','p','m','f','d','t','n','l')
#退出对话框
class QuitDialog(gui.Dialog):
def __init__(this,main):
title = gui.Label("Dialog Box")
gui.Dialog.__init__(this, title, main)
def close():
pygame.quit()
exit()
app = gui.App() #初始化gui
con = gui.Container() #生成gui的容器
quitDlg = QuitDialog(con) #生成弹窗abc
btn = gui.Button("game over") #生成文字为a的按钮
btn.connect(gui.CLICK, quitDlg.close, None)#将按钮与弹窗的弹出绑定
label = gui.Label("Are you sure you want to quit?")
quitDlg.add(label, 2, 2)
quitDlg.add(btn,2,3) #将按钮安放在容器(0,0)位置
app.init(con)
# ========游戏开始页面静态效果==========
# class Hero(pygame.sprite.Sprite)
# class Bullet(pygame.sprite.Sprite)
# class Enemy(pygame.sprite.Sprite)
# class Explode(pygame.sprite.Sprite)
# class BackGround(pygame.sprite.Sprite)
# 主角
class Hero(pygame.sprite.Sprite):
def __init__(self, speed):
super().__init__()
self.image = pygame.image.load('./image/plane.png')
self.images = [pygame.image.load('./image/planeDie' + str(i) + '.png') for i in range(1, 4)]
self.image_index = 0
self.readt_to_change = 0
self.dired = 0 #默认三条命
self.rect = self.image.get_rect()
self.rect.width *= 0.5
self.rect.height *= 0.5
self.image = pygame.transform.scale(self.image, (self.rect.width, self.rect.height))
self.rect.x, self.rect.y = 0, 100
self.speed = speed
self.ready_to_fire = 0
def update(self, *args):
keys = pygame.key.get_pressed()
if keys[pygame.K_UP]:
self.rect.y -= self.speed
if keys[pygame.K_DOWN]:
self.rect.y += self.speed
if keys[pygame.K_LEFT]:
self.rect.x -= self.speed
if keys[pygame.K_RIGHT]:
self.rect.x += self.speed
if keys[pygame.K_SPACE]:
if self.ready_to_fire == 0:
self.fire()
self.ready_to_fire += 1
if self.ready_to_fire > 5:
self.ready_to_fire = 0
else:
self.ready_to_fire = 0
if self.rect.x < 0:
self.rect.x = 0
if self.rect.y < 0:
self.rect.y = 0
if self.rect.y > HEIGHT - self.rect.height:
self.rect.y = HEIGHT - self.rect.height
if self.dired != 0:
if self.image_index <= 2:
self.readt_to_change += 1
if self.readt_to_change % 4 == 0:
self.image = self.images[self.image_index]
self.image_index += 1
else:
self.image_index = 0
self.kill()
def fire(self):
bullet = Bullet(10)
bullet.rect.x = self.rect.right
bullet.rect.centery = self.rect.centery
bullet_sprite.add(bullet)
# 音效
sound = pygame.mixer.Sound('./sound/laser.wav')
sound.play()
class Bullet(pygame.sprite.Sprite):
def __init__(self, speed):
super().__init__()
self.image = pygame.image.load('./image/bullet.png')
self.rect = self.image.get_rect()
self.speed = speed
def update(self, *args):
self.rect.x += self.speed
if self.rect.x > WIDTH:
self.kill()
class Enemy(pygame.sprite.Sprite):
count_ = 0
def __init__(self, speed):
super().__init__()
Enemy.count_ += 1
self.image = pygame.image.load('./image/'+'enemy'+str( Enemy.count_)+".png")
self.rect = self.image.get_rect()
self.rect.x = 800
self.rect.y = random.randint(0, HEIGHT)
self.speed = speed
self.id = Enemy.count_
self.name = 'enemy'+str( Enemy.count_)
print("self.id=",self.id)
print("Enemy.count=",Enemy.count_)
if Enemy.count_ >= 50:
Enemy.count_=0
def update(self, *args):
self.rect.x -= self.speed
if self.rect.right < 0:
self.kill()
class Explode(pygame.sprite.Sprite):
def __init__(self):
super().__init__()
self.images = [pygame.image.load('./image/explode' + str(i) + '.png') for i in range(1, 4)]
self.image_index = 0
self.image = self.images[self.image_index]
self.rect = self.image.get_rect()
self.readt_to_change = 0
sound = pygame.mixer.Sound('./sound/enemyExplode.wav')
sound.play()
def update(self, *args):
if self.image_index < 2:
self.readt_to_change += 1
if self.readt_to_change % 4 == 0:
self.image_index += 1
self.image = self.images[self.image_index]
else:
self.kill()
class BackGround(pygame.sprite.Sprite):
def __init__(self):
super().__init__()
self.image = pygame.image.load('./image/background1.jpg')
self.rect = self.image.get_rect()
self.ready_to_move = 0
self.index = 1
def update(self, *args):
self.rect.x -= 3
if self.rect.right <= 0:
self.index+=1
self.image = pygame.image.load('./image/background'+str(self.index)+'.jpg')
self.rect = self.image.get_rect()
self.rect.x = self.rect.width
if self.index == 4:
self.index = 3
# 初始化精灵组
bg_sprite = pygame.sprite.Group()
hero_sprite = pygame.sprite.Group()
enemy_sprite = pygame.sprite.Group()
bullet_sprite = pygame.sprite.Group()
explode_sprite = pygame.sprite.Group()
# 定义人物
hero1 = Hero(4)
hero_sprite.add(hero1)
enemy1 = Enemy(5)
enemy2 = Enemy(7)
bg1 = BackGround()
bg2 = BackGround()
bg2.rect.x = bg2.rect.width
bg_sprite.add(bg1, bg2)
# 保持游戏运行状态(游戏循环）
while True:
# ===========游戏帧的刷新===========
clock.tick(FPS)
# 检测事件
for event in pygame.event.get():
# 检测关闭按钮被点击的事件
if event.type == pygame.QUIT:
# 退出
pygame.quit()
exit()
if event.type == CREATE_ENEMY:
enemy_sprite.add(Enemy(random.randint(1, 4)))
app.event(event) #将pygame的事件传递给pgu，很重要
# 碰撞检测,返回字典，得到二者信息
collision = pygame.sprite.groupcollide(enemy_sprite, bullet_sprite, True, True)
for enemy in collision.keys():
explode = Explode()
explode.rect = enemy.rect
explode_sprite.add(explode)
print("enemy.id:"+str(enemy.id))
score+=1
# 碰撞检测,返回字典，得到二者信息
collision1 = pygame.sprite.groupcollide(enemy_sprite, hero_sprite, True, False)
for enemy in collision1.keys():
hero1.dired += 1
quitDlg.open()
show_image = True
break
#explode = Explode()
#explode.rect = enemy.rect
#explode_sprite.add(explode)
#quitDlg.open()
# screen.fill((0,0,0))
for group in [bg_sprite, hero_sprite, enemy_sprite, bullet_sprite, explode_sprite]:
group.update()
group.draw(screen)
#screen.fill((0,0,0)) #生成一个屏幕
score_txt = "得分:"+str(score)
text_surface = font.render(score_txt, True, (255, 0, 255))
screen.blit(text_surface, (680, 10))
if show_image:
screen.blit(fail_image, (300, 100)) # 绘制图像
app.paint()
pygame.display.update()
#app.paint() #将pgu容器的内容画出
Producción de material de voz.
Un juego divertido es definitivamente indispensable para producir imágenes y sonidos exquisitos. Aquí creamos imágenes de fondo y seleccionamos algunas imágenes hermosas e impactantes del universo de Internet como fondos. Para otras letras Pinyin, se interceptan hermosas y coloridas letras Pinyin de Internet.
Aquí nos centramos en la producción de archivos de pronunciación Pinyin. Es casi difícil encontrar un único archivo WAV listo para usar de Pinyin chino en Internet. Aquí hay dos métodos. Uno es encontrar archivos de audio que cubran las pronunciaciones de todas las letras Pinyin regulares y completas y usar el software Goldwave para editarlos. La ventaja es que la pronunciación es más estándar, pero la edición es más problemática y es necesario busque los archivos de audio correspondientes.
Otro método consiste en utilizar la tecnología de síntesis de voz fuera de línea de iFlytek para sintetizar la voz. Por ejemplo, ingresa la letra 'a' y deja que sintetice la pronunciación. Pero lo probé y descubrí que estaba en inglés. Pero todavía hay una manera: simplemente ingrese los caracteres chinos correspondientes de a - a o - oh e - uh i - 一 u - wu, sintetice todo el discurso y luego córtelo a través del software Goldwave.
const char* text = "啊,我，额，一，无，与，波，破，摸，佛，的，特，呢，了，个，可，和，及，器，洗，之，吃，时，日，子，此，思，一，无"; //合成文本Por ejemplo, utilice la tecnología de síntesis de lenguaje fuera de línea de iFlytek para sintetizar el párrafo anterior, separado por comas. Luego use la herramienta de producción y corte de audio Goldwave para cortar cada pieza de audio y guardarla en un archivo de audio en formato wav con letras pinyin. Sin embargo, es posible que la pronunciación no sea estándar debido al tono, así que trate de encontrar palabras con una pronunciación precisa y un solo tono.
La pronunciación más cercana que encontré es la siguiente:
韵母：a, o, e, i, u, ü, ai, ei, ui, ao, ou, iu, ie, üe, er, an, en, in, un, ün, ang, eng, ing, ong
阿，窝，额，一，屋，迂，挨，诶，微，凹，欧，优，页，约，儿，安，恩，音，温，晕，盎，鞥，英，翁
声母：b, p, m, f, d, t, n, l, g, k, h, j, q, x, zh, ch, sh, r, z, c, s ,y,w
播，泼，摸，佛，的，特，呢，嘞,哥，蝌，喝，机，其，西，织，吃，狮，日，资，疵，丝，衣，屋La edición también es muy conveniente porque está separada por comas. Cada pequeña forma de onda verde a continuación es un archivo de pronunciación.
Código C para síntesis de sonido:
/*
* 语音合成（Text To Speech，TTS）技术能够自动将任意文字实时转换为连续的
* 自然语音，是一种能够在任何时间、任何地点，向任何人提供语音信息服务的
* 高效便捷手段，非常符合信息时代海量数据、动态更新和个性化查询的需求。
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include "../../include/qtts.h"
#include "../../include/msp_cmn.h"
#include "../../include/msp_errors.h"
typedef int SR_DWORD;
typedef short int SR_WORD ;
/* wav音频头部格式 */
typedef struct _wave_pcm_hdr
{
char riff[4]; // = "RIFF"
int size_8; // = FileSize - 8
char wave[4]; // = "WAVE"
char fmt[4]; // = "fmt "
int fmt_size; // = 下一个结构体的大小 : 16
short int format_tag; // = PCM : 1
short int channels; // = 通道数 : 1
int samples_per_sec; // = 采样率 : 8000 | 6000 | 11025 | 16000
int avg_bytes_per_sec; // = 每秒字节数 : samples_per_sec * bits_per_sample / 8
short int block_align; // = 每采样点字节数 : wBitsPerSample / 8
short int bits_per_sample; // = 量化比特数: 8 | 16
char data[4]; // = "data";
int data_size; // = 纯数据长度 : FileSize - 44
} wave_pcm_hdr;
/* 默认wav音频头部数据 */
wave_pcm_hdr default_wav_hdr =
{
{ 'R', 'I', 'F', 'F' },
0,
{'W', 'A', 'V', 'E'},
{'f', 'm', 't', ' '},
16,
1,
1,
16000,
32000,
2,
16,
{'d', 'a', 't', 'a'},
0
};
/* 文本合成 */
int text_to_speech(const char* src_text, const char* des_path, const char* params)
{
int ret = -1;
FILE* fp = NULL;
const char* sessionID = NULL;
unsigned int audio_len = 0;
wave_pcm_hdr wav_hdr = default_wav_hdr;
int synth_status = MSP_TTS_FLAG_STILL_HAVE_DATA;
if (NULL == src_text || NULL == des_path)
{
printf("params is error!\n");
return ret;
}
fp = fopen(des_path, "wb");
if (NULL == fp)
{
printf("open %s error.\n", des_path);
return ret;
}
/* 开始合成 */
sessionID = QTTSSessionBegin(params, &ret);
if (MSP_SUCCESS != ret)
{
printf("QTTSSessionBegin failed, error code: %d.\n", ret);
fclose(fp);
return ret;
}
ret = QTTSTextPut(sessionID, src_text, (unsigned int)strlen(src_text), NULL);
if (MSP_SUCCESS != ret)
{
printf("QTTSTextPut failed, error code: %d.\n",ret);
QTTSSessionEnd(sessionID, "TextPutError");
fclose(fp);
return ret;
}
printf("正在合成 ...\n");
fwrite(&wav_hdr, sizeof(wav_hdr) ,1, fp); //添加wav音频头，使用采样率为16000
while (1)
{
/* 获取合成音频 */
const void* data = QTTSAudioGet(sessionID, &audio_len, &synth_status, &ret);
if (MSP_SUCCESS != ret)
break;
if (NULL != data)
{
fwrite(data, audio_len, 1, fp);
wav_hdr.data_size += audio_len; //计算data_size大小
}
if (MSP_TTS_FLAG_DATA_END == synth_status)
break;
}
printf("\n");
if (MSP_SUCCESS != ret)
{
printf("QTTSAudioGet failed, error code: %d.\n",ret);
QTTSSessionEnd(sessionID, "AudioGetError");
fclose(fp);
return ret;
}
/* 修正wav文件头数据的大小 */
wav_hdr.size_8 += wav_hdr.data_size + (sizeof(wav_hdr) - 8);
/* 将修正过的数据写回文件头部,音频文件为wav格式 */
fseek(fp, 4, 0);
fwrite(&wav_hdr.size_8,sizeof(wav_hdr.size_8), 1, fp); //写入size_8的值
fseek(fp, 40, 0); //将文件指针偏移到存储data_size值的位置
fwrite(&wav_hdr.data_size,sizeof(wav_hdr.data_size), 1, fp); //写入data_size的值
fclose(fp);
fp = NULL;
/* 合成完毕 */
ret = QTTSSessionEnd(sessionID, "Normal");
if (MSP_SUCCESS != ret)
{
printf("QTTSSessionEnd failed, error code: %d.\n",ret);
}
return ret;
}
int main(int argc, char* argv[])
{
int ret = MSP_SUCCESS;
const char* login_params = "appid = 99999, work_dir = .";//登录参数,appid与msc库绑定,请勿随意改动
/*
* rdn: 合成音频数字发音方式
* volume: 合成音频的音量
* pitch: 合成音频的音调
* speed: 合成音频对应的语速
* voice_name: 合成发音人
* sample_rate: 合成音频采样率
* text_encoding: 合成文本编码格式
*
*/
const char* session_begin_params = "engine_type = local,voice_name=xiaoyan, text_encoding = UTF8, tts_res_path = fo|res/tts/xiaoyan.jet;fo|res/tts/common.jet, sample_rate = 16000, speed = 50, volume = 50, pitch = 50, rdn = 2";
const char* filename = "tts_sample.wav"; //合成的语音文件名称
const char* text = "啊,我，额，一，无，与，波，破，摸，佛，的，特，呢，了，个，可，和，及，器，洗，之，吃，时，日，子，此，思，一，无"; //合成文本
/* 用户登录 */
ret = MSPLogin(NULL, NULL, login_params); //第一个参数是用户名，第二个参数是密码，第三个参数是登录参数，用户名和密码可在http://www.xfyun.cn注册获取
if (MSP_SUCCESS != ret)
{
printf("MSPLogin failed, error code: %d.\n", ret);
goto exit ;//登录失败，退出登录
}
printf("\n###########################################################################\n");
printf("###########################################################################\n\n");
/* 文本合成 */
printf("开始合成 ...\n");
ret = text_to_speech(text, filename, session_begin_params);
if (MSP_SUCCESS != ret)
{
printf("text_to_speech failed, error code: %d.\n", ret);
}
printf("合成完毕\n");
exit:
printf("按任意键退出 ...\n");
getchar();
MSPLogout(); //退出登录
return 0;
}Archivo MAKE correspondiente:
#common makefile header
DIR_INC = ../../include
DIR_BIN = ../../bin
DIR_LIB = ../../libs
TARGET = tts_offline_sample
BIN_TARGET = $(DIR_BIN)/$(TARGET)
CROSS_COMPILE =
CFLAGS = -g -Wall -I$(DIR_INC)
ifdef LINUX64
LDFLAGS := -L$(DIR_LIB)/x64
else
LDFLAGS := -L$(DIR_LIB)/x86
endif
LDFLAGS += -lmsc -lrt -ldl -lpthread -lstdc++
OBJECTS := $(patsubst %.c,%.o,$(wildcard *.c))
$(BIN_TARGET) : $(OBJECTS)
$(CROSS_COMPILE)gcc $(CFLAGS) $^ -o $@ $(LDFLAGS)
%.o : %.c
$(CROSS_COMPILE)gcc -c $(CFLAGS) $< -o $@
clean:
@rm -f *.o $(BIN_TARGET)
.PHONY:clean
#common makefile foot
Resumen del proceso de desarrollo de juegos con Pygame
El siguiente es el proceso de uso general:
1. Configure Pygame: use pip para instalar la biblioteca Pygame e impórtela en el script de Python.
2. Inicializar Pygame: utilícelo para pygame.init()inicializar el módulo Pygame.
3. Configurar la ventana del juego: Úselo pygame.display.set_mode()para crear una ventana de juego. Establezca el tamaño de la ventana, el título y otras propiedades.
4. Bucle del juego: crea un bucle para ejecutar el juego continuamente. Este bucle maneja la entrada del usuario, actualiza la lógica del juego y representa los gráficos del juego.
5. Manejar eventos: dentro del bucle del juego, utilícelo pygame.event.get()para manejar varios eventos, como la entrada del teclado o del mouse. Responde a estos eventos según las necesidades del juego.
6. Actualizar el estado del juego: actualiza el estado del juego según la entrada del usuario y otros factores. Incluyendo mover objetos del juego, detectar colisiones, actualizar puntuaciones, etc.
7. Renderizar gráficos: use las funciones pygame.Surfacey pygame.drawpara renderizar gráficos del juego en la ventana del juego. Esto incluye dibujar objetos del juego, fondos, texto y otros elementos visuales.
8. Actualización de pantalla: use pygame.display.flip()o pygame.display.update()para actualizar la ventana del juego para mostrar los cambios en el cuadro actual.
9. Lógica del juego: implementar lógica, reglas y mecánicas específicas del juego. Esto puede incluir niveles, puntuaciones, accesorios, IA enemiga, etc.
10. Salir del juego: maneja el evento de salida del juego y úsalo pygame.quit()para limpiar recursos.
Aquí hay un ejemplo simple de un juego de Pygame que muestra una ventana y un personaje en movimiento:
import pygame
from pygame.locals import *
# 初始化Pygame
pygame.init()
# 设置游戏窗口
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption('我的游戏')
# 游戏循环
running = True
while running:
# 处理事件
for event in pygame.event.get():
if event.type == QUIT:
running = False
# 更新游戏状态
# 渲染图形
screen.fill((0, 0, 0)) # 用黑色填充屏幕
pygame.draw.rect(screen, (255, 0, 0), (100, 100, 50, 50)) # 在(100, 100)处绘制一个红色矩形
# 显示更新
pygame.display.flip()
# 退出游戏
pygame.quit()Finalmente, si necesita un programa ejecutable completo, agregue la cuenta WeChat del autor en la página de inicio o siga la cuenta oficial y deje un mensaje para solicitarlo.
Otros recursos
Verificación de seguridad de Baidu
Explicación detallada del proceso de empaquetar módulos de Python en archivos .exe - Zhihu
Habilidades de lucha de Python Xuanji - biblioteca tkinter_blog de Ma Xiaoyao-blog CSDN
Resumen de bibliotecas de terceros de uso común en Python - Zhihu