Consulte las otras partes de esta serie:

En el blog anterior creamos nuestros obstáculos, así que vamos a comenzar el desove ellos. Si no ha leído la parte 1, sin embargo, es muy recomendable. Muchas de las características de este blog requerirán lo que hemos aprendido en la Parte 1.

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

    Tabla de contenidos

    El desove de los obstáculos

    En primer lugar, crear un GameObject vacío llamado “GameManager”. Esto mantendrá nuestra desovador obstáculo, así como otros scripts. A continuación, cree un nuevo guión C # llamado “ObstacleSpawner” y adjuntarlo al administrador de juego.

    objeto GameManger añadido a la unidad

    Esta es la forma en que va a funcionar. Cuando desovar un obstáculo, estamos en primer lugar va a decidir si va a venir del lado izquierdo o derecho de la pantalla. Luego, con ese lado decidió, elegimos un valor del eje Y aleatorio desde un mínimo pre-definido y max. El objeto se genera y arrojado por la pantalla.

    El array “obstáculos” llevará a cabo todas las casas prefabricadas de obstáculos. “MinSpawnY” y “maxSpawnY” es el rango vertical a los objetos de regeneración a lo largo. “LeftSpawnX” y “rightSpawnX” son las posiciones X del lado izquierdo / derecho de la pantalla.
    pública GameObject [] obstáculos; // matriz de todos los diferentes tipos de flotador obstaclespublic minSpawnY; // objetos altura mínima pueden generar flotador atpublic maxSpawnY; objetos // altura máxima puede desovar flotador atprivate leftSpawnX; // lado izquierdo de la rightSpawnX screenprivate flotador; // lado derecho de la spawnRate flotador screenpublic; // tiempo en segundos entre cada lastSpawn flotador spawnprivate; // time.time de la última spawn123456789publicGameObject [] obstáculos; // matriz de todos los diferentes tipos de obstaclespublicfloatminSpawnY; // objetos de altura mínima pueden generar atpublicfloatmaxSpawnY; // objetos de altura máxima pueden generar atprivatefloatleftSpawnX; // lado izquierdo de la screenprivatefloatrightSpawnX ; // lado derecho de la screenpublicfloatspawnRate; // tiempo en segundos entre cada spawnprivatefloatlastSpawn; // time.time del último desove

    también vamos a estar puesta en común de nuestros obstáculos. Esto ayuda con el rendimiento a medida que instanciar todos ellos en el inicio del juego.
    // puesta en común Lista privada pooledObstacles = new List (); // lista de objetos en la piscina privada int initialPoolSize = 20; // tamaño del Pool123 // poolingprivateList pooledObstacles = newList (); // lista de objetos en el poolprivateintinitialPoolSize = 20; // tamaño de la piscina

    Ahora en el “Inicio” la función que necesitamos para calcular las variables desove X izquierda y derecha. Para ello, en primer lugar hay que obtener el ancho de la cámara. Por desgracia, eso no es algo que sólo puede conseguir, por lo que sólo tenemos que hacer un poco de matemáticas. Desde mediados de la cámara es X = 0, podemos determinar que desovan izquierda X será -camWidth / 2, con semillas derecha siendo la misma, pero positivo.

    También vamos a llamar a la función para crear nuestra piscina, que estaremos creando siguiente.
    vacío Inicio () {// ajuste de la izquierda y la derecha de la freza fronteras // hacer esto consiguiendo leva horizontal de la cámara fronteras de la cámara = Camera.main; flotar camWidth = (2.0f * cam.orthographicSize) * cam.aspect; leftSpawnX = -camWidth / 2; rightSpawnX = camWidth / 2; // crear nuestra CreateInitialPool grupo inicial ();} 12345678910111213voidStart () {// ajuste de la izquierda y la derecha de la freza fronteras // hacer esto consiguiendo horizontal de la cámara bordersCamera leva = Camera.main; floatcamWidth = (2.0f * cam.orthographicSize) * leva .aspect; leftSpawnX = -camWidth / 2; rightSpawnX = camWidth / 2; // crear nuestra poolCreateInitialPool inicial ();}

    “CreateInitialPool” una instancia de un determinado número de obstáculos, ellos se desactiva y los añade a la lista “pooledObstacles” . a continuación, nos pondremos objetos de esa lista más adelante a ‘engendro’ ellos.
    // instancia los objetos iniciales para añadir a la CreateInitialPool poolvoid () {for (int index = 0; index “GetPooledObstacle” devuelve un objeto inactivo de la “ lista pooledObstacles”. Vamos a llamar a esta función en lugar de “Instantiate”.
    // devuelve un nuevo obstáculo agrupada listo para ser usedGameObject GetPooledObstacle () {GameObject pooledObj = null; // encontrar un objeto agrupado que no está activa foreach (GameObject obj en pooledObstacles) {if (obj.activeInHierarchy!) PooledObj = obj; (! PooledObj)} // si no pudimos encontrar uno, el error de registro si Debug.LogError ( «Tamaño de la piscina no es lo suficientemente grande!»); // activarlo pooledObj.SetActive (true); // luego enviarlo de regreso pooledObj;} // devuelve 12345678910111213141516171819202122 un nuevo obstáculo agrupada listo para ser usedGameObject GetPooledObstacle () {GameObject pooledObj = null; // encontrar un objeto que no está agrupada activeforeach (GameObject obj inpooledObstacles) {if (obj! .activeInHierarchy) pooledObj = obj;} // si no pudimos encontrar uno, errorif registro (pooledObj) Debug.LogError ( «tamaño de la piscina no es lo suficientemente grande!»);! // Activar itpooledObj.SetActive (true); / / luego enviar itreturnpooledObj;.}

    Ahora es el momento para la función “SpawnObstacle”, que permita hacer surgir un obstáculo al azar

    En primer lugar, conseguir un obstáculo a disposición de la función “GetPooledObstacle” y establece una posición para que desde la función “GetSpawnPosition”. Vamos a llegar a eso pronto. Luego, con el objeto generado, fijamos la dirección movimiento para ser horizontalmente a través de la pantalla.
    // genera un obstáculo al azar a una semilla aleatoria pointvoid SpawnObstacle () {// obtener el obstáculo obstáculo GameObject = GetPooledObstacle (); // conjunto su posición obstacle.transform.position = GetSpawnPosition (); . Dirección de // set obstáculo para moverse en obstacle.GetComponent () Mover directorio = nuevo Vector3 (obstacle.transform.position.x> 0 -1: 1, 0, 0);} 123456789101112 // genera un obstáculo al azar a una pointvoidSpawnObstacle spawn aleatorio () {// obtener el obstáculo obstacleGameObject = GetPooledObstacle (); // establecer su positionobstacle.transform.position = GetSpawnPosition ();. dirección de // set obstáculo para mover inobstacle.GetComponent () mover directorio = newVector3 (obstacle.transform.position.x> 0 -1: 1,0,0?);}

    los retornos “GetSpawnPosition” un vector3, que es la posición aleatoria para el objeto a desovar al. Dentro de la función, en primer lugar determinar la posición X. Esta es una oportunidad 50/50 de estar a la izquierda oa la derecha. A continuación, la posición Y es un valor aleatorio entre el min y max gama Y desove.
    // devuelve una posición desovar al azar para un obstacleVector3 GetSpawnPosition () {float x = Random.Range (0, 2) == 1? leftSpawnX: rightSpawnX; flotar y = Random.Range (minSpawnY, maxSpawnY); volver nuevo Vector3 (x, y, 0);} 12345678 // devuelve una posición desovar al azar para un GetSpawnPosition obstacleVector3 () {floatx = Random.Range (0,2) == 1 leftSpawnX: rightSpawnX; floaty = Random.Range? (minSpawnY, maxSpawnY); returnnewVector3 (x, y, 0);}

    Para generar estas horas extras, comprobamos cada fotograma de la función “Actualizar” si el tiempo entre ahora y la última vez que dio lugar a más de la semilla Velocidad. Si es así, reiniciamos la última vez desove y desovar un obstáculo.
    vacío Update () {// cada segundo ‘spawnRate’, generar un nuevo obstáculo si (time.time – spawnRate> = lastSpawn) {lastSpawn = time.time; SpawnObstacle (); }} 123456789voidUpdate () {// cada segundo ‘spawnRate’, un nuevo engendro obstacleif (time.time-spawnRate> = lastSpawn) {lastSpawn = time.time; SpawnObstacle ();}}

    Ahora, de vuelta en el que el editor puede llenar las variables de proceso. Añadir todas las casas prefabricadas de obstáculos en la matriz obstáculos. He establecido la freza Min Y para ser -3.5 y máximo para estar 2. Este huevas de ellos sólo el suelo justo por debajo de la nave. Para la tasa de desove lo fijo a 0,75, pero se puede probar y ajustar este valor.

    GameManager objeto en la ventana de inspección Unidad

    Así es como debe ser similar a cuando se juega el juego! Asegúrese de que usted consigue aturdido cuando choca con los obstáculos.

    Jugador jetpacking y evitando enemigos en la Unidad juego

    Creación de la base de la Clase Problema

    El director de juego va a ser un script que contiene todos nuestros problemas de matemáticas y se ejecuta en bucle del juego.

    Así que por primera vez, crear un nuevo guión C # llamado “problema”. Esto va a ser la clase base para nuestros problemas de matemáticas.

    En la clase pre-hechos, crear un nuevo enumerador llamado “MathsOperation”. Para nuestro juego el formato va a ser: [número] [operación] [número]. La forma en los dos números van a ser calculado juntos se determina por el operador. La suma, resta, multiplicación y división son los que vamos a utilizar.
    MathsOperation public enum {suma, resta, multiplicación, división} {1234567publicenumMathsOperation suma, resta, multiplicación, división}

    Entonces, necesitamos cambiar la clase de “problema” pre-hechos. En primer lugar, eliminar el texto “MonoBehaviour” al final de la definición de clase y añadir “[System.Serializable]” justo por encima.

    eliminar mono comportamiento porque no necesitamos ninguna de las funciones pre-hechos de la unidad y por el hecho de que este script no va a ser unido a cualquier secuencia de comandos. La propiedad System.Serializable lo hace de manera que esta clase se puede visualizar en el Inspector con todos sus valores dispuestas a editar.

    Con nuestras variables, tenemos nuestros dos números y nuestro operador. “Respuestas” es una red de flotadores que llevará a cabo todas las posibles respuestas, entre ellas la correcta. “CorrectTube” es el número de índice de la respuesta correcta en la matriz “respuestas”.
    [System.Serializable] public class Problema {float pública FirstNumber; // primer número de la secondNumber pública problema de flotación; // segundo número en la operación pública MathsOperation problema; // operador entre los dos números de flotación pública [] respuestas; // matriz de todas las respuestas posibles, incluyendo el correcto [Rango (0, 3)] int público correctTube; // índice del tubo correcto} 1234567891011 [System.Serializable] publicclassProblem {publicfloatfirstNumber; // primer número en el problempublicfloatsecondNumber; // segundo número en la operación problempublicMathsOperation; // operador entre los dos numberspublicfloat [] respuestas; // array de todas las respuestas posibles, incluyendo el correcto [Rango (0,3)] publicintcorrectTube; // índice del tubo correcto}

    Scripting el Administrador de juego

    Ahora que tenemos nuestra clase de problema, vamos a hacer el administrador de juego. Crear un nuevo guión C # llamado “GameManager” y adjuntarlo al objeto “GameManager”.

    A continuación nuestras variables. “Problemas” es un arreglo que contiene todos nuestros problemas de matemáticas. “CurProblem” es el número de índice de la matriz “problemas”, señalando el problema actual del jugador está en.
    Problema pública [] problemas; // lista de todos int problemspublic curProblem; // problema actual que necesita el jugador a timePerProblem flotador solvepublic; // tiempo permitido para responder a cada REMAININGTIME flotador problempublic; // tiempo restante para el jugador PlayerController problempublic actual; // jugador object1234567publicProblem problemas []; // lista de todos problemspublicintcurProblem; // problema actual que necesita el jugador a solvepublicfloattimePerProblem; // tiempo permitido para responder a cada problempublicfloatremainingTime; // tiempo restante para el jugador problempublicPlayerController actual; // objeto de reproductor

    también queremos crear una instancia de esta secuencia de comandos (o Singleton). Esto significa que podemos acceder fácilmente a la secuencia de comandos con sólo ir GameManager.instance. […] sin necesidad de hacer referencia a ella. El único inconveniente, es que sólo se puede tener una instancia de la secuencia de comandos.
    // instancia instancepublic GameManager estática; nula Awake () {// instancia asignadas a este script. = instancia esto;} // 12345678 ejemplo instancepublicstaticGameManager; voidAwake () {// set instancia a esta script.instance = presente;}

    Empecemos con las funciones de “perder” “Win” y. En este momento ellos sólo establecen la escala de tiempo en o (pausar el juego). Más adelante vamos a llamar a una función de interfaz de usuario para mostrar el texto que dice “You Win!” o “Juego encima”.
    // llamada cuando el jugador responde a todas las victorias problemsvoid () {Time.timeScale = 0.0f; // set texto UI} // llamada si el tiempo restante en un problema de alcances 0void Lose () {Time.timeScale = 0.0f; // conjunto de texto UI} // 12345678910111213 llamada cuando el jugador contesta a todo el problemsvoidWin () {Time.timeScale = 0.0f; // conjunto de texto UI} // llamada si el tiempo restante de un problema alcanza 0voidLose () {Tiempo. timeScale = 0.0f; // conjunto de texto UI}

    Ahora necesitamos una forma de presente / set un problema. La función “SetProblem” llevará a lo largo de un número de índice de la matriz problema y conjunto que como el problema actual.
    // establece el SetProblem problemvoid actual (int problema) {curProblem = problema; REMAININGTIME = timePerProblem; // conjunto de texto para mostrar la interfaz de usuario de problemas y respuestas} 1234567 // establece el problemvoidSetProblem actual (intproblem) {= curProblem problema; REMAININGTIME = timePerProblem; // conjunto de texto para mostrar la interfaz de usuario de problemas y respuestas}

    Cuando el jugador obtiene la correcta respuesta “CorrectAnswer” se llamará. “IncorrectAnswer” se llamará si es la respuesta equivocada. Si se equivocan, sólo tendremos que aturdir a ellos.
    // llama cuando el jugador entra en el tubevoid correcta CorrectAnswer () {// este es el último problema? si (problems.Length – 1 == curProblem) Win (); SetProblem más (curProblem + 1);} // llama cuando el jugador entra en el tubevoid incorrecta IncorrectAnswer () {player.Stun ();} // 123456789101112131415 llama cuando el jugador entra en el tubevoidCorrectAnswer correcta () {// esta es la última problema si (problems.Length-1 == curProblem) Win ();? elseSetProblem (curProblem + 1);} // llama cuando el jugador entra en el tubevoidIncorrectAnswer incorrecta () {player.Stun ();}

    cuando el jugador entra en un tubo, la función “OnPlayerEnterTube” será llamado, en libros sobre el ID del tubo, que se correlaciona de nuevo a la matriz “respuestas” en la clase “problema”.
    // llamada cuando el jugador entra en un OnPlayerEnterTube vacío (tubo int) {// tubepublic hicieron entrar en el tubo correcto? if (tubo == problemas [curProblem] .correctTube) CorrectAnswer (); otra cosa IncorrectAnswer ();} // 123456789 llamada cuando el jugador entra en un tubepublicvoidOnPlayerEnterTube (inttube) {// hicieron entrar en el tubo correcto si (== tubo problemas [curProblem] .correctTube) CorrectAnswer ();? elseIncorrectAnswer ();}

    Dado que estamos teniendo un temporizador para cada problema, necesitamos comprobar si es agotó. Si es así, entonces el jugador pierde.
    vacío Update () {REMAININGTIME – = Time.deltaTime; // tiene el tiempo restante se acabó? si (REMAININGTIME <= 0.0f) {Pierde (); }} 12345678910voidUpdate () {remainingTime- = Time.deltaTime; // tiene el tiempo restante se quedó sin si (REMAININGTIME <= 0.0f) Pierde {();}}

    Por último, tenemos que establecer el problema inicial cuando se inicia el juego.
    vacío Inicio () {// establecer el SetProblem inicial del problema (0);} 12345voidStart () {// establecer el problemSetProblem inicial (0);}

    De nuevo en el editor podemos empezar a crear nuestros problemas. Aquí, tengo 3 problemas, una suma, multiplicación y división. Asegúrese de que su matriz “respuestas” es el mayor número de tubos que tiene y establecer el control deslizante “correctTube” para ser el número de elemento con la respuesta correcta.

    componente de script Juego Manager con problemas matriz

    Creación de la interfaz de usuario Elementos

    Va a ser muy difícil de jugar el juego en este momento sin alguna interfaz de usuario, por lo que vamos a entrar en eso.

    Lo que queremos hacer es tener un lienzo espacio del mundo que puede contener nuestros elementos de texto. La creación de un espacio de lona mundo puede ser un poco fastidioso, aunque, por lo que en primer lugar, vamos a crear un lienzo.

    A continuación, cambiar el “Render Mode” para el espacio de pantalla – la cámara. Arrastre la cámara principal a la propiedad “Render cámara” y debería ver que el lienzo se convierte en el mismo tamaño que el de la cámara.

    objeto Unidad de interfaz de usuario de la lona en el Inspector

    Ahora podemos cambiar el “Render Mode” para Mundial del Espacio y clasificación de capa a “interfaz de usuario”. Esta situación no permite necesidad de escalar manualmente el lienzo hasta el tamaño de la cámara.

    objeto Unidad de interfaz de usuario de la lona se trasladó a la interfaz de usuario Clasificación Capa

    Crear un nuevo elemento de texto como un niño del lienzo (clic derecho lienzo> interfaz de usuario> texto). A continuación, coloque en el centro del rectángulo grande en blanco y cambiar los límites para que se ajuste.

    Para las propiedades de texto, define en negrita , con un tamaño de 30 y el centro horizontal y verticalmente.

    objeto de texto llamado añadido a la Unidad juego de matemáticas 'Problema de texto'

    A continuación, crear otro elemento de texto para la respuesta. Esto va a ser similar al problema de uno, pero más pequeño, por supuesto.

    Número objeto de texto añadido por encima de objeto tubo en la unidad

    Ahora acaba de duplicarla para cada tubo problema.

    interfaz de usuario de la Unidad con varias plantillas problema de matemáticas

    Para mostrar al jugador la cantidad de tiempo que les queda, añadiremos en una línea que se retraiga el paso del tiempo. Crear un nuevo elemento de imagen (clic derecho lienzo> interfaz de usuario> Imagen). A continuación, establezca la “Fuente de la imagen” para ser el UIDial y cambiar el tamaño de la anchura y altura que ser 50. Ahora bien, para que la imagen sea realmente ser capaz de reducir como un reloj, tenemos que cambiar el “Tipo de imagen” para Llenado y ajuste la “Llenar origen” al principio. Ahora posicionar a la derecha del texto problema.

    /

    Cuando el juego termina, tenemos que el texto que se mostrará si se gana o no. Crear un nuevo texto y lo coloca en el centro de la pantalla. He añadido un componente de esquema ya que estaremos cambiando el color del texto más adelante en la escritura. También desactivarlo, por lo que no aparece cuando comenzamos a jugar.

    objeto Texto 'texto final' en vista Escena Unidad

    Scripting la interfaz de usuario

    Crear un nuevo guión C # denominado “interfaz de usuario” y adjuntarlo al objeto “GameManager”.

    En primer lugar, es necesario hacer referencia a la biblioteca UnityEngine.UI, ya que por supuesto que vamos a ser la modificación de elementos de interfaz de usuario.
    utilizando UnityEngine.UI;

    Para nuestras variables, tenemos el texto problema, respuestas de texto como una matriz. La tasa de línea de tiempo restante de línea de tiempo, termina el texto y el restante. Voy a explicar que en breve.
    problemText Texto pública; // texto se muestra el texto de matemáticas problempublic [answersTexts]; // conjunto de las 4 respuestas textspublic imagen remainingTimeDial; imagen tiempo con fillprivate radial remainingTimeDialRate flotador // restante; // 1,0 / hora por ENDTEXT texto problempublic; // texto que se muestra un final del juego (ganar o más de juego) 1234567publicText problemText; // texto que muestra las matemáticas problempublicText [] answersTexts; // array de los 4 respuestas textspublicImage remainingTimeDial; // imagen tiempo restante con fillprivatefloatremainingTimeDialRate radial; // 1,0 / hora por problempublicText ENDTEXT;. // texto que se muestra un final del juego (ganar o más de juego)

    también vamos a crear una instancia con la secuencia de comandos de interfaz de usuario, como el GameManager
    // ejemplo de interfaz de usuario estático instancepublic; void Awake () {// set instancia sea esta instancia script = esta;} 12345678 // instancepublicstaticUI ejemplo; voidAwake () {// set instancia sea este scriptinstance = esta;}

    con nuestra línea de tiempo, estamos usando una imagen que está “llena”. Esto significa que podemos elegir qué porcentaje de esta imagen es visible. En nuestro caso, tenemos que radial, de manera que se llena como la forma de una mano va alrededor de un reloj.

    La “cantidad de llenado” es 0,0 a 1,0. Desde nuestro tiempo restante será de alrededor de 15 segundos, necesitamos una manera de convertir 15 a 1 para usar en el valor de la cantidad de llenado.
    void Start () {// establecer la tasa de tiempo restante de línea // se utiliza para convertir el tiempo por un problema (8 segundos, por ejemplo) // y convertidos que ser utilizado en un 0,0-1,0 escala remainingTimeDialRate = 1.0f / GameManager.instance .timePerProblem;} 1234567voidStart () {// establecer la tasa de tiempo restante de línea // se utiliza para convertir el tiempo por un problema (8 segundos, por ejemplo) // y convertidos que ser utilizado en un 0,0-1,0 scaleremainingTimeDialRate = 1.0f / GameManager .instance.timePerProblem;.}

    En la función “Actualizar”, vamos a estar constantemente actualizando el dial de tiempo
    vacío Update () {// actualizar la cantidad de llenado de línea de tiempo restante remainingTimeDial.fillAmount = remainingTimeDialRate * GameManager.instance.remainingTime;} 12345voidUpdate () {// actualizar el relleno de línea de tiempo restante amountremainingTimeDial.fillAmount = remainingTimeDialRate * GameManager.instance.remainingTime ;}

    Ahora tenemos que configurar la función “SetProblemText”, que consigue un problema y lo muestra en la interfaz de usuario .
    // establece la interfaz de usuario nave para mostrar el nuevo SetProblemText vacío problempublic (problema Problema) {string operatorText = «»; // convertir el operador problema desde una enumeración a un conmutador real símbolo de texto (problem.operation) {case MathsOperation.Addition: operatorText = «+»; descanso; MathsOperation.Subtraction caso: operatorText = «-«; descanso; caso MathsOperation.Multiplication: operatorText = «x»; descanso; caso MathsOperation.Division: operatorText = «÷»; descanso; } // establecer el texto problema para visualizar el problema problemText.text = problem.firstNumber + operatorText + problem.secondNumber; // establecer los textos respuestas para mostrar las respuestas correctas e incorrectas para (int index = 0; index Además, cuando el juego termina (ganar o perder) que necesitamos para establecer el texto en pantalla. “SetEndText” enviará durante un bool (= true ganar, perder = false). Si se trata de una victoria, el texto final será “You Win!” y el color será verde. Si se trata de una pérdida, el texto final será “Juego encima!” y el color será rojo.
    // establece el texto final de la pantalla si el jugador gana o se lostpublic SetEndText vacío (bool ganar) {// habilitar la endText.gameObject.SetActive termina el texto objeto (true); // ganó el jugador? si (ganar) {endText.text = «You Win!»; endText.color = Color.green; } // hizo el jugador pierda? else {endText.text = «Juego encima!»; endText.color = Color.red; }} // 12345678910111213141516171819 establece el texto final de la pantalla si el jugador gana o se lostpublicvoidSetEndText (boolwin) {// permitir que el texto final objectendText.gameObject.SetActive (true); // hizo el jugador victoria si (ganar) {ENDTEXT?. text = «You Win!»; endText.color = Color.green;} // hizo el jugador pierda else {endText.text = «Juego encima!»;? endText.color = Color.red;}}

    Ahora tenemos que volver a la secuencia de comandos “GameManager” y conectar los dos guiones. En el “SetProblem” función de complemento …
    UI.instance.SetProblemText (problemas [curProblem]); 1UI.instance.SetProblemText (problemas [curProblem]);.

    En el “Win” función de complemento …
    UI.instance.SetEndText (true); 1UI.instance.SetEndText (true);

    En la función de complemento “perder” …
    UI.instance.SetEndText (falso); 1UI.instance.SetEndText (falso);.

    Ahora que hemos terminado con eso, regresamos al editor y añadimos los objetos a la secuencia de comandos de interfaz de usuario

    Terminando el problema Tubos

    La última cosa que necesitamos hacer es añadir funcionalidad a los tubos de problemas. Crear un nuevo guión C # llamado “ProblemTube” y adjuntarlo a la totalidad del tubo 4 problema objetos que hicimos.

    Esto es todo lo que necesitamos código. Comprobamos para introducir un disparador con el jugador y si eso ocurre, llame a la función “OnPlayerEnterTube” en “GameManager” y enviar a través de la Identificación del tubo.
    public int tubeId; // identificador de número de este tubo // llama cuando algo entra collidervoid (col Collider2D) OnTriggerEnter2D del tubo {// era que el jugador? si (col.CompareTag ( «Jugador»)) {// decirle al gerente de juego que el jugador entró en este tubo GameManager.instance.OnPlayerEnterTube (tubeId); }} 123456789101112publicinttubeId; // número identificador para este tubo // llamada cuando algo entra collidervoidOnTriggerEnter2D (Collider2D col) del tubo {// fue todo si el jugador (col.CompareTag ( «Jugador»)) {// decirle al gerente de juego? que el jugador entró en este tubeGameManager.instance.OnPlayerEnterTube (tubeId);}}

    Ahora vuelve al editor y entrar en el diámetro interior del tubo para cada tubo. 0, 1, 2 y 3.

    Conclusión

    Enhorabuena! Ahora ha terminado su juego de matemáticas! Probarlo por ti mismo, o compartirlo con tus amigos. De cualquier manera, usted ha aprendido no sólo a establecer temporizadores, enemigos, y mover un personaje, pero cómo proporcionar un desafío lógica también.

    Ritmo rápido de la Unidad juego de matemáticas juego

    Mensajes relacionados

Deja una respuesta

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