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

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.
  

  
  

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

  
  

  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.
  

  
  

  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.
  

  
  

  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
    
    

    
    

    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
    

    
    

    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.
    

    
    

    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
    

    
    

    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.
    

    
    

    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 (?).
    

    
    

    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
      
      

      
      

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

      
      

      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 .
      

      
      

      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.
      

      
      

      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.
      

      
      

      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 #.
      

      
      

      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)
        
        

        
        

        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
          
          

          
          

          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.
            

            
            

            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 .
            

            
            

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

            
            

            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
              
              

              
              

              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.
              

              
              

              Creación de la interfaz de usuario
              

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

              
              

              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
              

              
              

              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