Tabla de contenidos

Introducción

En este tutorial, vamos a crear un juego controlado por voz, donde se mueve un aterrizaje en Marte Rover. Vamos a utilizar 2 servicios diferentes de Azure cognitivos Servicios de Microsoft:. Luis y el habla en texto

juego controlado por voz hizo con Unity

Puede descargar los archivos del proyecto aquí.

No se pierda! extremos de la oferta en

  • Accede a los más de 200 cursos
  • Nuevos cursos añadió mensual
  • Cancelar en cualquier momento
  • Los certificados de terminación

    ACCESO ahora

    Configuración de LUIS

    Luis es un complemento de Microsoft, el servicio de aprendizaje de máquina que puede convertir frases y oraciones en los intentos y entidades. Esto nos permite hablar fácilmente a un ordenador y tienen que entender lo que queremos. En nuestro caso, nos vamos a mover un objeto en la pantalla.

    Para configurar LUIS, ir a www.luis.ai e inscribirse.

    página de inicio para Microsoft LUIS cognitivo Servicios

    Una vez que se inscribe, debe le llevará a la página Mis Apps. Aquí, queremos crear una nueva aplicación.

    Mi página de Aplicaciones para Azure cognitivo Servicios

    Cuando se crea la aplicación se le llevará a la pantalla Intentos. Aquí, queremos crear un nuevo intento llamada Mover . La intención es básicamente el contexto de una frase. Aquí, estamos creando un intento de mover el objeto.

    Opciones Propósitos para el VoiceControlApp

    A continuación, vaya a la Entidades pantalla y crear dos nuevas entidades. MoveDirection y MOVEDISTANCE (ambos tipos de entidad simple). En una frase, LUIS buscará estas entidades.

    Entidades para App Control de voz

    Ahora vamos a volver a la pantalla los intentos y seleccionar nuestra Mover intención. Esto nos llevará a una pantalla donde podemos entrar en frases de ejemplo. Tenemos que entrar en ejemplos para que LUIS puede aprender acerca de nuestra intención y entidades. Cuanto más, mejor.

    Asegúrese de que hace referencia a todos los tipos de direcciones de movimiento al menos una vez:


    • hacia delante
    • hacia atrás
    • Atrás
    • izquierdo
    • derecho

      Mover elementos para el proyecto de Luis

      Ahora, para cada fase, seleccionar la dirección y adjuntar un entidad MoveDirection a ella. Para la distancia (números) adjuntar un MOVEDISTANCE entidad a la misma. Las frases más que tiene y cuanto más diferentes son -. Mejores serán los resultados finales serán

      Configuración de dirección Move para aplicación controlada de voz

      Una vez hecho esto, haga clic en el botón de tren para entrenar a la aplicación. Esto no debería tomar mucho tiempo.

      Configuración de la aplicación con el botón LUIS tren ha destacado

      Cuando se haya completado, puede hacer clic en el botón Test para probar la aplicación. Prueba a introducir en una frase y mirar las entidades resultantes. Estos deben ser los correctos.

      Una vez que eso es todo lo buena que ir, haga clic en el botón Publicar para publicar la aplicación -. Que nos permite utilizar la API

      Configuración de la aplicación con el botón LUIS texto seleccionado

      La información que necesitamos cuando se utiliza la API, se encuentra haciendo clic en el botón Administrar e ir a los Cayos y puntos finales . Aquí, tenemos que copiar el Punto final url.

      Autoría de Key para la aplicación de control de voz en LUIS

      Pruebas de la API con el cartero

      Antes de saltar a la Unidad, la prueba de dejar salir el API utilizando cartero. Para la URL, pegue en el Punto final hasta el primer signo de interrogación (?).

      página del cartero con CLAVES ha destacado

      A continuación, para los parámetros, queremos tener la siguiente:


      • verbosa – si es verdad, devolverá todos los intentos en lugar de sólo la parte superior anotando intención
      • timezoneOffset – el desplazamiento para la ubicación de la solicitud en cuestión de minutos zona horaria
      • suscripción clave – la clave de autoría (al final del Punto Final)
      • q – la pregunta que debe

        Parámetros del cartero con pestaña abierta

        A continuación, si apretamos Enviar , un archivo JSON con nuestros resultados debe ser enviada.

        cartero con la respuesta JSON se muestra

        Servicios del habla

        LUIS se utiliza para la conversión de una frase para los intentos y entidades. Todavía necesitamos algo para convertir la voz en texto. Para ello, vamos a utilizar los servicios de voz cognitivas de Microsoft.

        Lo que necesitamos del tablero de instrumentos es la Punto final ubicación (en mi caso westus ) y clave 1 .

        Punto final y clave para los servicios de Microsoft de voz a texto

        A continuación, desea descargar el SDK de Voz para la unidad aquí. Este es un archivo .unitypackage que puede simplemente arrastrar y soltar en el proyecto.

        instrucciones de instalación SDK de Voz

        Crear el proyecto de la Unidad

        Crear un nuevo proyecto Unity o usar los archivos de proyecto incluidos (que va a utilizar esos). Importar el paquete SDK de Voz.

        Nuevo proyecto de la Unidad con la carpeta SDK de Voz ha destacado

        Para el SDK para el trabajo, tenemos que ir a nuestro Configuración del proyecto ( Editar> Ajustes del proyecto … ) y establecer el Scripting Runtime Versión a .Net 4.x equivalente . Esto se debe a que el SDK e incluso nos va a utilizar algunas nuevas características de C #.

        Configuración del proyecto en la Unidad con la configuración ajustada jugador

        Script LUIS Administrador

        Crear un nuevo guión C # (botón derecho del ratón Proyecto > Crear> C # script ) y lo llaman LUISManager .

        Vamos a la necesidad de acceso a unos espacios de nombres fuera de este script.
        utilizando UnityEngine.Networking; using System.IO; usando System.Text; 123usingUnityEngine.Networking; usingSystem.IO; usingSystem.Text;

        Para nuestras variables, tenemos la clave url y suscripción. Estos se utilizan para conectarse a LUIS.
        // url para enviar solicitud topublic string url // LUIS suscripción keypublic subscriptionKey cadena; 12345 // url para enviar solicitud topublicstringurl; // LUIS suscripción keypublicstringsubscriptionKey;

        Nuestro resultTarget será el objeto que ‘re en movimiento. Es de tipo Mover , que todavía no hemos creado lo que acaba de comentar que por ahora.
        // destino para enviar la solicitud de la clase topublic Mover resultTarget; 12 // destino para enviar la solicitud de la clase topublicMover resultTarget;

        A continuación, tenemos nuestros eventos. onSendCommand que se llama cuando el comando está listo para ser enviado. onStartRecordVoice se llama cuando empezamos a grabar nuestra voz y onEndRecordVoice se llama cuando dejamos de grabar nuestra voz.
        // evento llamado cuando un comando está listo para ser delegado sentpublic (cadena de comando) sendCommand vacío; sendCommand pública onSendCommand; // llamada cuando el jugador empieza a grabar su voicepublic System.Action onStartRecordVoice; // llama cuando el jugador se detiene la grabación de su voicepublic System.Action onEndRecordVoice; // 123456789 evento llamado cuando un comando está listo para ser sentpublicdelegatevoidSendCommand (stringcommand); publicSendCommand onSendCommand; // llamada cuando el jugador comienza a grabar su onStartRecordVoice voicepublicSystem.Action; // llamada cuando el jugador se detiene la grabación de su voicepublicSystem .action onEndRecordVoice;.

        Finalmente, tenemos nuestro ejemplo – que nos permite acceder fácilmente a la secuencia de comandos
        // instancia LUISManager estática instancepublic; nula Awake () {// set instancia a esta instancia de este script =;} // 12345678 ejemplo instancepublicstaticLUISManager; voidAwake () {// set instancia a esta scriptinstance = presente;}

        Vamos a suscribirse a la onSendCommand evento -. llamar a la OnSendCommand , función
        OnEnable vacío () {// suscribirse al evento onSendCommand onSendCommand + = OnSendCommand;} void OnDisable () {// anular la suscripción a eventos onSendCommand onSendCommand – = OnSendCommand;} 1234567891011voidOnEnable () {// suscribirse a onSendCommand eventonSendCommand + = OnSendCommand;} voidOnDisable () {// anular la suscripción a onSendCommand eventonSendCommand- = OnSendCommand;}

        la OnSendCommand función simplemente iniciar el CalculateCommand co-rutina, que es el aspecto principal de este script.
        // llama cuando un comando está listo para ser sentvoid OnSendCommand (cadena de comando) {StartCoroutine (CalculateCommand (comando));} // 12345 llama cuando un comando está listo para ser sentvoidOnSendCommand (stringcommand) {StartCoroutine (CalculateCommand (comando)); }

        Cálculo del comando

        LUISManager guión, crear una co-rutina llamada CalculateCommand que se lleva en una cadena.
        // envía el comando de cadena a la API web y recibe un resultado como JSON fileIEnumerator CalculateCommand (cadena de comando) {} // 12345 envía el comando de cadena a la API web y recibe un resultado como una fileIEnumerator CalculateCommand JSON (stringcommand) {}

        lo primero que haremos, es comprobar si el comando está vacía. Si es así, el retorno.
        // si el comando es nada, returnif (String.IsNullOrEmpty (comando)) producir una rentabilidad nula; 123 // si el comando es nada, returnif (String.IsNullOrEmpty (comando)) returnnull rendimiento;

        A continuación, creamos nuestra solicitud web, descargar controlador, establecer la dirección URL y enviar la solicitud.
        // crear nuestra web requestUnityWebRequest webReq = new UnityWebRequest (); webReq.downloadHandler = new DownloadHandlerBuffer ();? WebReq.url = string.Format ( «{0} = false verbosa y timezoneOffsset = 0 & = suscripción de clave {1} & q = {2 }», url, subscriptionKey, comandos); // enviar el webReq.SendWebRequest retorno requestyield web (); // 12345678 crear nuestra web requestUnityWebRequest webReq = newUnityWebRequest (); webReq.downloadHandler = newDownloadHandlerBuffer ();? WebReq.url = string.Format ( «{0} = false verbosa y timezoneOffsset = 0 & suscripción clave = {1} & q = {2}», url, subscriptionKey, comandos); // enviar la web requestyield returnwebReq.SendWebRequest ();

        Una vez que tengamos la solicitud web, tenemos que convertirlo de un archivo JSON a nuestra costumbre LUISResult clase, entonces informar el objeto motor.
        // convertir el JSON para que podamos leer itLUISResult resultado = JsonUtility.FromJson (Encoding.Default.GetString (webReq.downloadHandler.data)); // enviar el resultado al objetivo objectresultTarget.ReadResult (resultado); 12345 / / convertir el JSON para que podamos leer itLUISResult resultado = JsonUtility.FromJson (Encoding.Default.GetString (webReq.downloadHandler.data)); // enviar el resultado al objetivo objectresultTarget.ReadResult (resultado);

        LUIS Resultado

        La clase de resultado LUIS es básicamente una colección de tres clases para edificación de la estructura del archivo LUIS JSON. Crear tres nuevos guiones:. LUISResult , LUISIntent y LUISEntity

        LUISResult:
        [System.Serializable] LUISResult public class {string consulta pública; LUISIntent topScoringIntent pública; pública LUISEntity entidades [];} [1234567 System.Serializable] publicclassLUISResult {publicstringquery; publicLUISIntent topScoringIntent; publicLUISEntity [] entidades;}

        LUISIntent:
        [System.Serializable] public class LUISIntent {public string intención; puntuación de flotación pública;} 123456 [System.Serializable] publicclassLUISIntent {publicstringintent; publicfloatscore;}

        LUISEntity:
        [System.Serializable] LUISEntity public class {entidad cadena pública; tipo de cadena pública; startIndex int pública; public int endIndex; puntuación de flotación pública;} 123456789 [System.Serializable] publicclassLUISEntity {publicstringentity; publicstringtype; publicintstartIndex; publicintendIndex; publicfloatscore;}

        De vuelta en la Unidad, vamos a crear un nuevo objeto de juego (click derecho Jerarquía > Crea vacío ) y lo llaman LUISManager . Una el LUISManager script para él y relleno en los detalles.


        • Url – el punto final url entramos en cartero (URL de punto final hasta el primer signo de interrogación)
        • clave de suscripción – su autoría clave (el mismo que entramos en el cartero)

          objeto LUISManager en el inspector de la unidad

          Grabación nuestra voz

          El siguiente paso en el proyecto, es crear el script que va a escuchar nuestra voz y convertirlo en texto. Crear un nuevo guión C # llamado VoiceRecorder .

          Al igual que con el último, tenemos que incluir los espacios de nombres externos que vamos a acceder.
          utilizando System.Threading.Tasks; usando UnityEngine.Networking; usando Microsoft.CognitiveServices.Speech; 123usingSystem.Threading.Tasks; usingUnityEngine.Networking; usingMicrosoft.CognitiveServices.Speech; región

          Nuestras primeras variables del sub clave y el servicio para el discurso servicio.
          // Microsoft servicio de voz cognitiva infopublic subscriptionKey cadena; serviceRegion cadena pública; 123 // Microsoft cognitiva infopublicstringsubscriptionKey servicio de voz; publicstringserviceRegion;

          A continuación, necesitamos saber si estamos grabando actualmente, lo que nuestro comando actual es enviar y es el comandar listo para ser enviado?
          // están actualmente grabando un comando a través de nuestro micrófono recordingCommand private bool; // comando actual vamos a curCommand cadena sendprivate; // TRUE cuando un comando ha sido createdprivate commandReadyToSend bool; // 12345678 Actualmente estamos grabando un comando a través de nuestro micrófono privateboolrecordingCommand;? // mandato actual vamos a sendprivatestringcurCommand; // TRUE cuando un comando ha sido createdprivateboolcommandReadyToSend;

          Finalmente, nos dieron la finalización de las tareas. Esta es una parte del nuevo sistema de tareas C #, que vamos a utilizar como una alternativa al uso de co-rutinas, ya que eso es lo que los usos Speech SDK.
          // tarea fuente de finalización de la grabación parada micprivate TaskCompletionSource = stopRecognition nueva TaskCompletionSource (); // 12 de tareas Origen de finalización para detener la grabación micprivateTaskCompletionSource = stopRecognition newTaskCompletionSource ();

          Empecemos con el , función RecordAudio. asíncrono es básicamente una alternativa al uso de co-rutinas. Estos permiten hacer una pausa y esperar funciones determinadas cantidades de tiempo antes de continuar. En nuestro caso, necesitamos esto para permitir el tiempo SDK para convertir el audio a texto.
          // registra el micrófono y convierte el audio a textasync RecordAudio void () {} // 12345 registra el micrófono y convierte el audio a textasyncvoidRecordAudio () {}

          En primer lugar, digamos que estamos grabando y crean una clase de configuración que posee nuestra datos.
          recordingCommand = true; SpeechConfig config = SpeechConfig.FromSubscription (subscriptionKey, serviceRegion); 123recordingCommand = true; SpeechConfig config = SpeechConfig.FromSubscription (subscriptionKey, serviceRegion);

          A continuación, podemos crear nuestro reconocedor. Esto es lo que va a convertir la voz en texto.

          Dentro de la mediante , vamos a crear un evento para establecer el curCommand cuando el reconocimiento se ha completado. A continuación, vamos a empezar a escuchar la voz. Cuando se activa la finalización de las tareas, vamos a dejar de escuchar y convertir el audio -. Etiquetarlo como listo para ser enviado
          // crear un recognizerusing (SpeechRecognizer reconocedor = new SpeechRecognizer (config)) {// cuando el discurso ha sido reconocido, juego curCommand al resultado recognizer.Recognized + = (s, e) => {curCommand = e.Result.Text ; }; // iniciar la grabación del micrófono recognizer.StartContinuousRecognitionAsync Await () ConfigureAwait (falso).; Task.WaitAny (nuevo [] {stopRecognition.Task}); // grabación del micrófono recognizer.StopContinuousRecognitionAsync Await stop () ConfigureAwait (falso).; commandReadyToSend = true; recordingCommand = false;} return; 12345678910111213141516171819202122 // crear un recognizerusing (SpeechRecognizer reconocedor = newSpeechRecognizer (config)) {// cuando el discurso ha sido reconocido, juego curCommand a la resultrecognizer.Recognized + = (s, e) => {curCommand = e.Result.Text;}; // iniciar la grabación del micawaitrecognizer.StartContinuousRecognitionAsync () ConfigureAwait (falso);. Task.WaitAny (new [] {} stopRecognition.Task);. // grabar el micawaitrecognizer.StopContinuousRecognitionAsync stop () ConfigureAwait (falso); commandReadyToSend = true; recordingCommand = false;} return;.

          la CommandCompleted se llama a la función cuando el mando está listo para ser enviado
          // llamada cuando el jugador ha dejado de hablar y se crea un comando // envía el comando al LUISManager listo para ser calculatedvoid CommandCompleted () {LUISManager.instance.onSendCommand.Invoke (curCommand);} // 123456 llamada cuando el jugador tiene dejado de hablar y se crea un comando // envía el comando al LUISManager listo para ser calculatedvoidCommandCompleted () {LUISManager.instance.onSendCommand.Invoke (curCommand);}

          En el Actualizar función, desee comprobar para la entrada de teclado en la tecla de retorno. Esto cambiará la grabación.
          // marco cuando la tecla ENTER / RETURN es downif (Input.GetKeyDown (KeyCode.Return)) {// si no estamos grabando el mic – iniciar la grabación si (recordingCommand!) {LUISManager.instance.onStartRecordVoice.Invoke (); stopRecognition = nuevo TaskCompletionSource (); Grabar audio(); } // de lo contrario el sistema terminado la tarea else {stopRecognition.TrySetResult (0); LUISManager.instance.onEndRecordVoice.Invoke (); }} // 1234567891011121314151617 marco cuando la tecla ENTER / RETURN es downif (Input.GetKeyDown (KeyCode.Return)) {// si no estamos grabando el mic – recordingif de partida (recordingCommand!) {LUISManager.instance.onStartRecordVoice.Invoke ( ); stopRecognition = newTaskCompletionSource (); RecordAudio ();} // de otra manera conjunto completedelse tarea {stopRecognition.TrySetResult (0); LUISManager.instance.onEndRecordVoice.Invoke ();}}

          A continuación, debajo de ese (todavía en el Actualizar función), comprobamos para cuando estamos listos para enviar un comando, y hacerlo.
          // si está listo para salir del comando, enviar ITIF (commandReadyToSend) {commandReadyToSend = false; CommandCompleted ();} 123 456 // si el está listo para ir, enviar ITIF (commandReadyToSend) {commandReadyToSend = false comando; CommandCompleted ();.}

          Coloque este script también a la LUISManager objetivo < / p>


          • SubscriptionKey – clave de servicio de voz 1
          • Servicio Región – región de servicio de voz

            componente de la grabadora de voz Guión añadido a LUIS Manager

            Motor de secuencias de comandos

            Crear un nuevo guión C # llamado Mover . Esto va a controlar el reproductor.

            Nuestros variables son sólo nuestra velocidad de movimiento, velocidad de caída, distancia de movimiento predeterminada, la posición en el suelo para la posición del jugador y el objetivo.
            // unidades por segundo para mover flotador atpublic movespeed; // unidades por segundo a caer hacia abajo del flotador atpublic fallSpeed; // distancia para mover si no defaultMoveDist flotador specifiedpublic; // posición Y para este objeto cuando en el floorYPos flotador floorpublic; // condiciones de avanzar toprivate Vector3 TargetPos; 1234567891011121314 // unidades por segundo para mover atpublicfloatmoveSpeed; // unidades por segundo a caer hacia abajo atpublicfloatfallSpeed; // distancia para mover si no specifiedpublicfloatdefaultMoveDist; // posición Y para este objeto cuando en el floorpublicfloatfloorYPos; // posición para mover toprivateVector3 TargetPos;.

            Inicio función, vamos a establecer la posición de destino para ser nuestra posición
            vacío Inicio () {// establece nuestra posición de destino para que sean nuestros TargetPos posición actual = transform.position;} 12345voidStart () {// establecer nuestra posición de destino para que sean nuestros actuales positiontargetPos = transform.position;}

            En el < strong> actualización función /, vamos a avanzar hacia la posición de destino y caer hacia abajo hasta que llegamos a la posición y suelo.
            vacío Update () {// si no estamos en nuestros puntos de venta de destino, no se mueven con el tiempo si (transform.position! =) TargetPos transform.position = Vector3.MoveTowards (transform.position, TargetPos, movespeed * Time.deltaTime) ; si (targetPos.y> floorYPos) targetPos.y – = * fallSpeed ​​Time.deltaTime;} 123456789voidUpdate () {// si no estamos en nuestros puntos de venta de destino, mueva allí durante timeif (! = transform.position TargetPos) transformar. de posición = Vector3.MoveTowards (transform.position, TargetPos, movespeed * Time.deltaTime); si (targetPos.y> floorYPos) targetPos.y- = fallSpeed ​​* Time.deltaTime;}

            ReadResult toma en un LUISResult y figuras fuera una dirección movimiento y movimiento distancia -. actualización de la posición de destino
            // llamada cuando un comando obtiene un resultado posterior – se mueve el cubepublic ReadResult vacío (resultado LUISResult) {// ¿hay incluso un resultado y la intención de puntuación superior es «Mover»? si (resultado = null && result.topScoringIntent.intent == «Mover»!) {Vector3 Mover directorio = Vector3.zero; flotar moveDist = defaultMoveDist; // bucle a través de cada una de las entidades foreach (entidad LUISEntity en result.entities) {// si la entidad es MoveDirection si (entity.type == «MoveDirection») Mover directorio = GetEntityDirection (entity.entity); // si la entidad es MOVEDISTANCE else if (entity.type == «MOVEDISTANCE») moveDist = float.Parse (entity.entity); } // aplicar el movimiento TargetPos + = Mover directorio * moveDist; }} // 123456789101112131415161718192021222324 llamada cuando un comando obtiene un resultado posterior – se mueve el cubepublicvoidReadResult (resultado LUISResult) {// también hay de resultado y la intención de puntuación superior es «Mover» si (resultado = null && result.topScoringIntent.intent == «movimiento») {Vector3 Mover directorio = Vector3.zero; floatmoveDist = defaultMoveDist; // bucle a través de cada uno de los inresult.entities entitiesforeach (entidad LUISEntity) {// si la entidad es MoveDirectionif (entity.type == «MoveDirection» ) Mover directorio = GetEntityDirection (entity.entity); // si la entidad es MoveDistanceelseif (entity.type == «MOVEDISTANCE») moveDist = float.Parse (entity.entity);} // aplicar los movementtargetPos + = Mover directorio * moveDist;} }

            GetEntityDirection realiza en una dirección como una cadena y la convierte en una dirección Vector3.
            // devuelve una dirección Vector3 basado en texto sentVector3 GetEntityDirection (cadena directionText) {switch (directionText) {case «hacia delante»: retorno Vector3.forward; de casos «hacia atrás»: retorno Vector3.back; caso «atrás»: retorno Vector3.back; caso «izquierda»: retorno Vector3.left; caso «derecho»: el regreso Vector3.right; } Return Vector3.zero;} 12345678910111213141516171819 // devuelve una dirección Vector3 basado en texto sentVector3 GetEntityDirection (stringdirectionText) {switch (directionText) {case «hacia delante»: returnVector3.forward; casos «hacia atrás»: returnVector3.back, y el caso de «atrás» : returnVector3.back; caso «izquierda»: returnVector3.left; caso «derecho»: returnVector3.right;} returnVector3.zero;}

            Configuración de la escena

            De nuevo en el editor, crear un nuevo cubo (botón derecho del ratón Jerarquía > 3D Objeto> Cubo ) y lo llaman Mover . Una el Mover guión y establecer las propiedades:


            • Mover velocidad – 2
            • Fall velocidad – 1
            • Por defecto Mover Dist – 1
            • Planta Y Pos – 0

              también establecer la posición Y a 15.

              escritura añadido al objeto Rover en la unidad

              En el suelo, vamos a crear un nuevo objeto del juego vacío llamado Medio ambiente . A continuación, crear un nuevo plano que un niño llamado Suelo .

              Plano blanco creado dentro del proyecto Unidad

              Arrastre en la MarsMaterial en el plano ( Texturas carpeta). Entonces los padres la cámara al motor.

              Opciones de la cámara en el Inspector de la Unidad

              Ahora vamos a girar la luz direccional por lo que se enfrenta directamente hacia abajo. Esto hace que podamos ver que el motor va a la tierra en el suelo -. Que permite al jugador finamente posicionarlo


              • establecer la rotación a 90, -30, 0

                Light Unidad girar en el eje X

                Vamos a añadir también en un objeto de destino. No habrá ninguna lógica detrás de él, al igual que un objetivo para el jugador.

                objeto de destino dentro de proyecto Unity

                Creación de la interfaz de usuario

                Crear un lienzo con dos elementos de texto -. Mostrando la altitud y la frase movimiento actual

                Configuración de la unidad de interfaz de usuario para el juego controlado por voz

                Ahora vamos a crear el interfaz de usuario guión y adjuntarlo a la objeto LUISManager. Puesto que estamos utilizando TextMeshPro, tendremos que hacer referencia al espacio de nombres.
                utilizando TMPro;

                Para nuestras variables, sólo vamos a tener nuestra información de texto, texto del discurso y el objeto motor .
                // de texto que muestra informationpublic TextMeshProUGUI texto de ayuda; // de texto que muestra de voz a texto feedbackpublic TextMeshProUGUI speechText; // objeto que el jugador puede controlpublic GameObject moverObject; 12345678 // texto que muestra informationpublicTextMeshProUGUI texto de ayuda; // texto que muestra discurso a feedbackpublicTextMeshProUGUI texto speechText; // objeto que el jugador puede controlpublicGameObject moverObject;

                OnEnable función, vamos a suscribirse a los eventos que necesitamos y anular la suscripción a ellos en el OnDisable función.
                OnEnable vacío () {// suscribirse a eventos LUISManager.instance.onSendCommand + = OnSendCommand; LUISManager.instance.onStartRecordVoice + = OnStartRecordVoice; LUISManager.instance.onEndRecordVoice + = OnEndRecordVoice;} void OnDisable () {// anular la suscripción a eventos LUISManager.instance.onSendCommand – = OnSendCommand; LUISManager.instance.onStartRecordVoice – = OnStartRecordVoice; LUISManager.instance.onEndRecordVoice – = OnEndRecordVoice;} 123456789101112131415voidOnEnable () {// suscribirse a eventsLUISManager.instance.onSendCommand + = OnSendCommand; LUISManager.instance.onStartRecordVoice + = OnStartRecordVoice; LUISManager.instance.onEndRecordVoice + = OnEndRecordVoice;} voidOnDisable () {// ONU suscríbase a partir eventsLUISManager.instance.onSendCommand- = OnSendCommand; LUISManager.instance.onStartRecordVoice- = OnStartRecordVoice; LUISManager.instance.onEndRecordVoice- = OnEndRecordVoice;}

                En el Actualizar función, vamos que acaba de actualizar la información de texto para mostrar la posición Y del jugador.
                vacío Update () {// Actualización de información de texto infoText.text = « Altitud: » + (int) moverObject.transform.position.y + «m»;} 12345voidUpdate () {// información de actualización textinfoText.text = « Altitud: «+ (int) moverObject.transform.position.y +» m»;}

                Aquí hay las funciones de los eventos de llamada. Básicamente se actualiza el texto del discurso para mostrar cuando su grabación de su voz, el cálculo y ejecutarlo.
                // llama cuando un comando está listo para ser enviado // mostrar el texto del discurso si era una voz commandvoid OnSendCommand (cadena de comando) {speechText.text = comando;} // llamados cuando empezamos a grabar nuestro OnStartRecordVoice voicevoid () {speechText .text = «…»;} // llamamos cuando nos detenemos a grabar nuestro OnEndRecordVoice voicevoid () {speechText.text = «calcular …»;} // 123456789101112131415161718 llama cuando un comando está listo para ser enviado // pantalla el texto del discurso si fuera un commandvoidOnSendCommand voz (stringcommand) {speechText.text = comando;} // llaman cuando empezamos a grabar nuestro voicevoidOnStartRecordVoice () {speechText.text = «…»;} // llamada cuando la grabación Detener nuestra voicevoidOnEndRecordVoice () {speechText.text = «calcular …»;}.

                Asegúrese de conectar los elementos de texto y objetos motor

                componente Unidad UI guión desde el inspector de la unidad

                Conclusión

                Ahora hemos terminado! Puede presionar el juego y comandar el cubo con su voz! Si se ha perdido algunos de los enlaces se puede encontrar aquí:

                Mensajes relacionados
                Una introducción a la ML-Agentes de la unidad

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *