/// <summary>
    /// Este método se encarga de controlar el estado actual del juego
    /// De mostrar la pantalla de juego actual correspondiente al estado
    /// De configurar distintas "lógicas" dependiendo del estado actual del juego
    /// </summary>
    /// <param name="estadoJuego">Estado juego.</param>
    public void CambiarEstadoJuego(EstadoJuego estadoJuego)
    {
        estadoActualJuego = estadoJuego;
        // Controla la pantalla de juego (Elementos de UI) actual
        ControlarEstadoUI();

        switch (estadoActualJuego)
        {
        case EstadoJuego.INICIAR_JUEGO:
            // desactiva el barco jugador
            barcoJugador.gameObject.SetActive(false);
            break;

        case EstadoJuego.JUGANDO:
            // Activa el barco jugador
            barcoJugador.gameObject.SetActive(true);
            // Realiza invocación repetidamente del método con nombre: CrearBarcosEnemigos, asignando valores aleatorios en los intervalos de tiempo de creación
            InvokeRepeating("CrearBarcosEnemigos", 0f, Random.Range(3f, 6f));
            break;

        case EstadoJuego.JUEGO_TERMINADO:
            // Obtiene de la pantalla de juego terminado un componente Text y asigna el número de enemigos destruidos
            uiEstadosDeJuego[2].GetComponentInChildren <Text>().text = "Enemigos destruidos: " + enemigosDestruidos;

            // Destruye cada barco enemigo instanciado en la escena
            foreach (GameObject barcoEnemigoActual in barcosEnemigosInstanciados)
            {
                Destroy(barcoEnemigoActual);
            }
            // Limpia la lsiata de barcos enemigos instanciados en la escena
            barcosEnemigosInstanciados.Clear();
            break;
        }
    }
Esempio n. 2
0
        private void Juego_Load(object sender, EventArgs e)
        {
            p        = ControladorPersonajes.retPersonaje(VarGlobal.percodigo, SplashScreen.conexion);
            vidaP    = MetodosGenerales.retVidaPersonaje(VarGlobal.percodigo, SplashScreen.conexion);
            vidaPIni = MetodosGenerales.retVidaPersonaje(VarGlobal.percodigo, SplashScreen.conexion);

            EstadoJuego.aCaminar();
            Controladores.Helpers.actualizarEtiquetasCoord(lblCoordX, lblCoordY, p.CoordX, p.CoordY);
            Controladores.Helpers.actualizarEtiquetasAtt(lblUs, lblPer, lblNivel, lblExp, lblAta, lblDef, lblEne, lblVit,
                                                         p.UsuarioN, p.Nombre, p.Nivel, p.PuntosExp, p.PuntosAtaque, p.PuntosDefensa,
                                                         p.PuntosEnergia, p.PuntosVida);

            agregarMasCercanos();


            txtJuego.Multiline = true;
            // Add vertical scroll bars to the TextBox control.
            txtJuego.ScrollBars = ScrollBars.Vertical;
            // Allow the TAB key to be entered in the TextBox control.
            txtJuego.AcceptsReturn = true;
            // Allow the TAB key to be entered in the TextBox control.
            txtJuego.AcceptsTab = true;
            // Set WordWrap to true to allow text to wrap to the next line.
            txtJuego.WordWrap = true;

            txtJuego.ReadOnly = true;

            txtJuego.Text = "Bienvenido al juego!" + l;
        }
Esempio n. 3
0
 private void Button_Click(object sender, RoutedEventArgs e)
 {
     canvasMenu.Visibility      = Visibility.Collapsed;
     canvasPrincipal.Visibility = Visibility.Visible;
     canvasPrincipal.Focus();
     estadoActual = EstadoJuego.Gameplay;
 }
Esempio n. 4
0
 private void btnQuesadilla_Click(object sender, RoutedEventArgs e)
 {
     tortuga = new Quesadilla(imgTurtle);
     canvasChoosePlayer.Visibility = Visibility.Collapsed;
     miCanvas.Visibility           = Visibility.Visible;
     estadoActual = EstadoJuego.Gameplay;
 }
Esempio n. 5
0
        public void JugarLetra(char letra)
        {
            EstadoJuego estado = m_juego.Estado;

            if (estado == EstadoJuego.Jugando)
            {
                Letra letraJugada = new Letra(letra);
                bool  letraUsada  = m_juego.LetraUtilizada(letraJugada);

                if (letraUsada)
                {
                    m_ctlAhorcado.EtiquetarMensaje("Letra Ya Jugada");
                }
                else if (!(m_juego.JugarLetra(letraJugada)) && !letraUsada)
                {
                    m_ctlAhorcado.EtiquetarMensaje("Incorrecto");
                }
                else
                {
                    m_ctlAhorcado.EtiquetarMensaje(String.Empty);
                }

                m_ctlAhorcado.Actualizar();
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Juega una letra específica.
        /// </summary>
        /// <param name="letra">Letra a jugar.</param>
        /// <returns><em>true</em> si la letra pertenece a la palbra; <em>false</em> en caso contrario.</returns>
        public bool JugarLetra(Letra letra)
        {
            if (m_estado != EstadoJuego.Jugando)
            {
                return(false);
            }

            m_jugadas.Add(letra);

            bool pertenece = m_actual.EstaLetra(letra);


            if (!pertenece)
            {
                --m_intentosDisponibles;

                if (m_intentosDisponibles == 0)
                {
                    m_estado = EstadoJuego.Ahorcado;
                }
            }
            else
            {
                if (m_actual.EstaCompleta(m_jugadas))
                {
                    m_estado = EstadoJuego.Ganador;
                }
            }

            return(pertenece);
        }
Esempio n. 7
0
 private void btnNextEnemigos_Click(object sender, RoutedEventArgs e)
 {
     canvasEnemigos.Visibility = Visibility.Collapsed;
     canvasGamePlay.Visibility = Visibility.Visible;
     this.estadoActual         = EstadoJuego.GamePlay;
     canvasGamePlay.Focus();
 }
Esempio n. 8
0
 public void comenzarJuego()
 {
     estado = EstadoJuego.EnJuego;
     //zanahoria.GetComponent<Rigidbody2D> ().isKinematic = false;
     zanahoria.activar();
     marcaBarra.SetActive(true);
     //tituloUI.PlayReverse();
     foreach (TweenPosition t in juegoUI)
     {
         t.PlayForward();
     }
     //print (PlayerPrefs.GetInt ("primeraEjecucion", 0)+"||"+ PlayerPrefs.GetInt ("maximoPlanetas", 0));
     if (PlayerPrefs.GetInt("primeraEjecucion", 0) == 0 || PlayerPrefs.GetInt("maximoPlanetas", 0) <= 1)
     {
         //transicion.delay = 0.3f;
         instrucciones.SetActive(true);
     }
     else
     {
         camaraLogo.SetActive(false);
     }
     PlayerPrefs.SetInt("primeraEjecucion", 1);
     revivido = false;
     print("stop");
     resumenEstrellas.Stop();
 }
 /// <summary>
 ///     Constructor que toma el control del juego y el panel sobre el que va a dibujar los componentes.
 /// </summary>
 /// <param name="j">
 ///     Control del que se sacará el juego
 /// </param>
 /// <param name="p">
 ///     Panel sobre el que se hará el dibujado
 /// </param>
 public UtilidadDibujo(EstadoJuego ej, Panel p)
 {
     rg      = new RecursosGraficos();
     this.ej = ej;
     panel   = p;
     calcularOffsets();
     font = new Font("RETRO COMPUTER", 10);
 }
Esempio n. 10
0
 void restaurarJuego()
 {
     estado = EstadoJuego.Jugando;
     foreach (ControladorBasico c in controladores)
     {
         c.juegoRestaurado();
     }
 }
Esempio n. 11
0
 void pausarJuego()
 {
     estado = EstadoJuego.Pausa;
     foreach (ControladorBasico c in controladores)
     {
         c.juegoEnPausa();
     }
 }
Esempio n. 12
0
    void CambiarACarrera()
    {
        //Debug.Log("CambiarACarrera()");

        Esqueleto1.transform.position = PosEsqsCarrera[0];

        for (int i = 0; i < ObjsCarrera.Length; i++)
        {
            ObjsCarrera[i].SetActiveRecursively(true);
        }

        /*
         * for(int i = 0; i < ObjsTuto1.Length; i++)
         * {
         *      ObjsTuto1[i].SetActiveRecursively(false);
         *      ObjsTuto2[i].SetActiveRecursively(false);
         * }
         */


        //desactivacion de la calibracion
        PlayerInfo1.FinCalibrado = true;

        for (int i = 0; i < ObjsTuto1.Length; i++)
        {
            ObjsTuto1[i].SetActiveRecursively(true);
        }

        for (int i = 0; i < ObjsCalibracion1.Length; i++)
        {
            ObjsCalibracion1[i].SetActiveRecursively(false);
        }

        //posiciona los camiones dependiendo de que lado de la pantalla esten
        if (PlayerInfo1.LadoAct == Visualizacion.Lado.Izq)
        {
            Player1.gameObject.transform.position = PosCamionesCarrera[0];
        }
        else
        {
            Player1.gameObject.transform.position = PosCamionesCarrera[1];
        }

        Player1.transform.forward = Vector3.forward;
        Player1.GetComponent <Frenado>().Frenar();
        Player1.CambiarAConduccion();

        //los deja andando
        Player1.GetComponent <Frenado>().RestaurarVel();
        //cancela la direccion
        Player1.GetComponent <ControlDireccion>().Habilitado = false;
        //les de direccion
        Player1.transform.forward = Vector3.forward;

        EstAct = GameManager1.EstadoJuego.Jugando;
    }
Esempio n. 13
0
 void Awake()
 {
     rutaArchivo = Application.persistentDataPath + "/datos.dat";
     if(estadoJuego==null){
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
     }else if(estadoJuego!=this){
         Destroy(gameObject);
     }
 }
Esempio n. 14
0
 private void btnPlayAgain_Click(object sender, RoutedEventArgs e)
 {
     Canvas.SetLeft(carro, 180);
     estadoActual              = EstadoJuego.Gameplay;
     miCanvas.Visibility       = Visibility.Visible;
     canvasGameOver.Visibility = Visibility.Collapsed;
     miCanvas.Focus();
     velocidadCarro     = 300;
     vidas              = 4;
     lblVidas.Text      = "Vidas: " + (vidas);
     miCanvas.Focusable = true;
 }
Esempio n. 15
0
        void actualizar()
        {
            while (true)
            {
                Dispatcher.Invoke(
                    () =>
                {
                    var tiempoActual = stopwatch.Elapsed;
                    var deltaTime    = tiempoActual - tiempoAnterior;
                    if (estadoActual == EstadoJuego.Gameplay)
                    {
                        miCanvas.Focus();
                        moverTurtle(deltaTime);
                        MovimientoPopote(deltaTime);

                        //colisiones
                        foreach (Popotes popote in popotes)
                        {
                            double xTurtle  = Canvas.GetLeft(imgTurtle);
                            double xPopotes = Canvas.GetLeft(popote.Imagen);
                            double yTurtle  = Canvas.GetTop(imgTurtle);
                            double yPopotes = Canvas.GetTop(popote.Imagen);

                            if (xPopotes + popote.Imagen.Width >= xTurtle && xPopotes <= xTurtle + imgTurtle.Width &&
                                yPopotes + popote.Imagen.Height >= yTurtle && yPopotes <= yTurtle + imgTurtle.Height)
                            {
                                estadoActual              = EstadoJuego.Gameover;
                                miCanvas.Visibility       = Visibility.Collapsed;
                                canvasGameOver.Visibility = Visibility.Visible;
                            }
                        }

                        if (score >= 200)
                        {
                            lblNivel1.Visibility = Visibility.Collapsed;
                            lblNivel2.Visibility = Visibility.Visible;
                            imgFondo2.Visibility = Visibility.Collapsed;
                            imgFondo1.Visibility = Visibility.Visible;
                        }

                        if (score >= 350)
                        {
                            lblNivel2.Visibility = Visibility.Collapsed;
                            lblNivel3.Visibility = Visibility.Visible;
                            imgFondo1.Visibility = Visibility.Collapsed;
                            imgFondo3.Visibility = Visibility.Visible;
                        }

                        tiempoAnterior = tiempoActual;
                    }
                });
            }
        }
Esempio n. 16
0
 void Awake()
 {
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
     }
     else if (estadoJuego != this)
     {
         Destroy(gameObject);
     }
 }
Esempio n. 17
0
 void Awake()
 {
     directorioArchivo = Application.persistentDataPath + "/datosJuego.dat";
     //Impide que se destruya EstadoObjto al cambiar de escena
     if (estadoJuego == null) {
         estadoJuego = this;
         DontDestroyOnLoad (gameObject);
         objetos_guardados = Utilidad.crearDiccionarioPuntuacion();
     } else if (estadoJuego != this) {
         Destroy(gameObject);
     }
 }
Esempio n. 18
0
    // Start is called before the first frame update
    void Start()
    {
        estado = EstadoJuego.Fase1;
        Instantiate(background);
        if (!hayPower)
        {
            hayPower = true;
        }
        CargarMapa();
        primerMapa = false;

        tiempo = Mathf.Sqrt(2 * _DISTANCIA * aceleracion) / aceleracion;
    }
Esempio n. 19
0
    void Awake()
    {
        rutaArchivo = Application.persistentDataPath + "/datos.dat"; //carga la ruta de los puntos
        //condicion para saber si ya hay una instancia del objeto, si la hay
        //entonces la elimina, sino la crea, asi se pasa un objeto entre escenas

        if(estadoJuego==null){
            estadoJuego = this;
            DontDestroyOnLoad(gameObject);
        }else if(estadoJuego!=this){
            Destroy(gameObject);
        }
    }
Esempio n. 20
0
 void Awake()
 {
     rutaArchivo = Application.persistentDataPath + "/datos.dat";
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
     }
     else if (estadoJuego != this)
     {
         Destroy(gameObject);
     }
 }
Esempio n. 21
0
    void CambiarACarrera()
    {
        for (int i = 0; i < ObjsCarrera.Length; i++)
        {
            ObjsCarrera[i].SetActive(true);
        }

        for (int i = 0; i < ObjsTurorial.Length; i++)
        {
            ObjsTurorial[i].SetActive(false);
        }

        PlayerInfo2.FinTutorial = true;

        //posiciona los camiones dependiendo de que lado de la pantalla esten
        if (PlayerInfo1.LadoAct == Visualization.Lado.Izq)
        {
            Player1.gameObject.transform.position = PosCamionesCarrera[0];
            Player2.gameObject.transform.position = PosCamionesCarrera[1];
        }
        else
        {
            Player1.gameObject.transform.position = PosCamionesCarrera[1];
            Player2.gameObject.transform.position = PosCamionesCarrera[0];
        }

        Player1.transform.forward = Vector3.forward;
        Player1.GetComponent <Break>().Frenar();
        Player1.CambiarAConduccion();

        if (GameOptionsManager.instance.gameMode == GameOptionsManager.GameMode.LocalMultiplayer)
        {
            Player2.transform.forward = Vector3.forward;
            Player2.GetComponent <Break>().Frenar();
            Player2.CambiarAConduccion();

            Player2.GetComponent <Break>().RestaurarVel();
            Player2.GetComponent <InputController>().active = false;
            Player2.transform.forward = Vector3.forward;

            player2Inventory.SetActive(true);
        }

        Player1.GetComponent <Break>().RestaurarVel();
        Player1.GetComponent <InputController>().active = false;
        Player1.transform.forward = Vector3.forward;

        player1Inventory.SetActive(true);

        EstAct = EstadoJuego.Jugando;
    }
Esempio n. 22
0
	public Logro ActualizarLogros(EstadoJuego e) {
		Logro logroDesbloqueado = null;
		for (int i = 0; i < logros.Length; i++) {

			if (!logros[i].desbloqueado) {
				logros[i].desbloqueado = logros[i].condicion(e);
				if (logros[i].desbloqueado) {
					logroDesbloqueado = logros[i];
					break;
				}
			}
		}
		return logroDesbloqueado;
	}
Esempio n. 23
0
 // Use this for initialization
 void Awake()
 {
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
         colorControl = GetComponent <ColorControl>();
     }
     else
     {
         estadoJuego.ImageHudItemActual = ImageHudItemActual;
         Destroy(gameObject);
     }
 }
Esempio n. 24
0
        /// <summary>
        /// Inicia un nuevo juego.
        /// </summary>
        public void IniciarJuego()
        {
            double pos = GenerarValor() * (int)JuegoAhorcadoConstantes.TotalPalabras;

            m_actual = (Palabra)m_diccionario[(int)pos];

            m_intentosDisponibles = (int)JuegoAhorcadoConstantes.MaximoIntentos;

            // Vector de letras jugadas:
            m_jugadas = new ArrayList();

            // Actualizaci[on del estado del juego:
            m_estado = EstadoJuego.Jugando;
        }
Esempio n. 25
0
 void Awake()
 {
     rutaArchivo = Application.persistentDataPath + "/datos.dat";
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
         Debug.Log("soyelprimero");
     }
     else if (estadoJuego != this)
     {
         Destroy(gameObject);
         Debug.Log("yaexistia");
     }
 }
Esempio n. 26
0
 void Awake()
 {
     directorioArchivo = Application.persistentDataPath + "/datosJuego.dat";
     //Impide que se destruya EstadoObjto al cambiar de escena
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
         objetos_guardados = Utilidad.crearDiccionarioPuntuacion();
     }
     else if (estadoJuego != this)
     {
         Destroy(gameObject);
     }
 }
Esempio n. 27
0
 void Awake()
 {
     //Para saber donde guardar
     rutaArchivo = Application.persistentDataPath + "/datos.dat";
     //es nulo si es la primera vez que este script se esta ejecutando
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
     }
     else if (estadoJuego != this)
     {
         Destroy(gameObject);
     }
 }
Esempio n. 28
0
    void FinalizarCarrera()
    {
        EstAct = EstadoJuego.Finalizado;

        TiempoDeJuego = 0;

        if (Player1.Dinero > Player2.Dinero)
        {
            //lado que gano
            if (PlayerInfo1.LadoAct == Visualization.Lado.Der)
            {
                GameData.LadoGanadaor = GameData.Lados.Der;
            }
            else
            {
                GameData.LadoGanadaor = GameData.Lados.Izq;
            }

            //puntajes
            GameData.PtsGanador  = Player1.Dinero;
            GameData.PtsPerdedor = Player2.Dinero;
        }
        else
        {
            //lado que gano
            if (PlayerInfo2.LadoAct == Visualization.Lado.Der)
            {
                GameData.LadoGanadaor = GameData.Lados.Der;
            }
            else
            {
                GameData.LadoGanadaor = GameData.Lados.Izq;
            }

            //puntajes
            GameData.PtsGanador  = Player2.Dinero;
            GameData.PtsPerdedor = Player1.Dinero;
        }

        Player1.GetComponent <Break>().Frenar();
        Player1.ContrDesc.FinDelJuego();

        if (GameOptionsManager.instance.gameMode == GameOptionsManager.GameMode.LocalMultiplayer)
        {
            Player2.GetComponent <Break>().Frenar();
            Player2.ContrDesc.FinDelJuego();
        }
    }
Esempio n. 29
0
        void actualizar()
        {   //Invoke lleva de parametro una función
            while (true)
            {
                Dispatcher.Invoke(
                    () => //Se creo una función nueva dentro de otra. La => es para indicar que es otra función
                {
                    var tiempoActuali = stopwatch.Elapsed;
                    var deltaTime     = tiempoActuali - tiempoAnterior;

                    if (estadoActual == EstadoJuego.GamePlay)
                    {
                        lblScore.Text = (stopwatch.Elapsed.TotalMinutes.ToString());
                        //moverjugador
                        //Se agrega al parametro utilizado
                        moverjugador(deltaTime);
                        movimientoEnemigos(deltaTime);
                        //Intersecciones :(
                        foreach (Enemigos enemigos in enemigos)
                        {
                            double xNave     = Canvas.GetLeft(imgNave);
                            double yNave     = Canvas.GetTop(imgNave);
                            double xEnemigos = Canvas.GetLeft(enemigos.Imagen);
                            double yEnemigos = Canvas.GetTop(enemigos.Imagen);
                            if (xEnemigos + enemigos.Imagen.Width >= xNave && xEnemigos <= xNave + imgNave.Width && yEnemigos + enemigos.Imagen.Height >= yNave && yEnemigos <= yNave + imgNave.Height)
                            {
                                //puntos = puntos - 1;

                                //if (puntos == 0) {
                                estadoActual = EstadoJuego.GameOver;
                                canvasGamePlay.Visibility = Visibility.Collapsed;
                                canvasGameOver.Visibility = Visibility.Visible;
                                //}
                            }

                            if (stopwatch.Elapsed.TotalMinutes >= 0.61)
                            {
                                estadoActual = EstadoJuego.GameWon;
                                canvasGamePlay.Visibility = Visibility.Collapsed;
                                canvasWinner.Visibility   = Visibility.Visible;
                            }
                        }
                    }
                    tiempoAnterior = tiempoActuali;
                }
                    );
            }
        }
 void Awake()
 {
     rutaArchivo = Application.persistentDataPath + "/datos.dat";
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
         //Remove line before
         PlayGamesPlatform.DebugLogEnabled = true;
         PlayGamesPlatform.Activate();
     }
     else if (estadoJuego != this)
     {
         Destroy(gameObject);
     }
 }
Esempio n. 31
0
 void Awake()
 {
     rutaArchivo           = Application.persistentDataPath + "/datos.dat";
     rutaArchivoAvisoLeido = Application.persistentDataPath + "/leido.dat";
     //	Debug.Log (rutaArchivoAvisoLeido);
     if (estadoJuego == null)
     {
         estadoJuego = this;
         DontDestroyOnLoad(gameObject);
         PlayGamesPlatform.Activate();
         PlayGamesPlatform.DebugLogEnabled = false;             //OJO desactivar al finalizar
     }
     else if (estadoJuego != this)
     {
         Destroy(gameObject);
     }
 }
Esempio n. 32
0
    void Awake()
    {
        nombreArchivo = Application.persistentDataPath + "/datos.dat";
        Debug.Log(Application.persistentDataPath);
        if (estadoJuego == null)
        {
            estadoJuego = this;
            DontDestroyOnLoad(gameObject);

            //  PlayGamesPlatform.DebugLogEnabled = true;
            //  PlayGamesPlatform.Activate();
        }
        else if (estadoJuego != this)
        {
            Destroy(gameObject);
        }
    }
Esempio n. 33
0
    void FinalizarCarrera()
    {
        EstAct = EstadoJuego.Finalizado;

        TiempoDeJuego = 0;

        if (Player1.Dinero > Player2.Dinero)
        {
            //lado que gano
            if (PlayerInfo1.LadoAct == Visualizacion.Lado.Der)
            {
                DatosPartida.LadoGanadaor = DatosPartida.Lados.Der;
            }
            else
            {
                DatosPartida.LadoGanadaor = DatosPartida.Lados.Izq;
            }

            //puntajes
            DatosPartida.PtsGanador  = Player1.Dinero;
            DatosPartida.PtsPerdedor = Player2.Dinero;
        }
        else
        {
            //lado que gano
            if (PlayerInfo2.LadoAct == Visualizacion.Lado.Der)
            {
                DatosPartida.LadoGanadaor = DatosPartida.Lados.Der;
            }
            else
            {
                DatosPartida.LadoGanadaor = DatosPartida.Lados.Izq;
            }

            //puntajes
            DatosPartida.PtsGanador  = Player2.Dinero;
            DatosPartida.PtsPerdedor = Player1.Dinero;
        }

        Player1.GetComponent <Frenado>().Frenar();
        Player2.GetComponent <Frenado>().Frenar();

        Player1.ContrDesc.FinDelJuego();
        Player2.ContrDesc.FinDelJuego();
    }
Esempio n. 34
0
 void setEstado(EstadoJuego nuevoEstado)
 {
     estado = nuevoEstado;
 }
 // Use this for initialization
 void Start()
 {
     estadoJuego = ControladorDelJuego.ObtenerComponente<EstadoJuego>("ControladorDelJuego");
 }
Esempio n. 36
0
File: Jugador.cs Progetto: Sp4iK/2D
    void Start()
    {
        // Fijamos el estado del juego
        estadoJuego = EstadoJuego.Jugando;

        // Obtenemos el componente Rigidbody2D
        rigidbodyPollo = GetComponent<Rigidbody2D>();
        // Obtenemos el componente Animator
        animatorPollo = GetComponent<Animator>();
        // Obtenemos el AudioSource
        audioSourcePollo = GetComponent<AudioSource>();
        // Obtenemos el Transform del pollo
        transformPollo = GetComponent<Transform>();
    }
Esempio n. 37
0
	public ArrayList logrosDesbloqueados(EstadoJuego e) {
        /// <summary>
        /// Inicializa una instancia de la clase JuegoAhorcado.
        /// </summary>
        public JuegoAhorcado()
        {
            m_diccionario = new Palabra[(int)JuegoAhorcadoConstantes.TotalPalabras];

            m_diccionario[0] = new Palabra("algoritmo");
            m_diccionario[1] = new Palabra("contenedora");
            m_diccionario[2] = new Palabra("avance");
            m_diccionario[3] = new Palabra("ciclo");
            m_diccionario[4] = new Palabra("indice");
            m_diccionario[5] = new Palabra("instrucciones");
            m_diccionario[6] = new Palabra("arreglo");
            m_diccionario[7] = new Palabra("vector");
            m_diccionario[8] = new Palabra("inicio");
            m_diccionario[9] = new Palabra("cuerpo");
            m_diccionario[10] = new Palabra("recorrido");
            m_diccionario[11] = new Palabra("patron");

            m_intentosDisponibles = (int)JuegoAhorcadoConstantes.MaximoIntentos;
            m_estado = EstadoJuego.NoIniciado;
        }
        /// <summary>
        /// Inicia un nuevo juego.
        /// </summary>
        public void IniciarJuego()
        {
            double pos = GenerarValor() * (int)JuegoAhorcadoConstantes.TotalPalabras;

            m_actual = (Palabra)m_diccionario[(int)pos];

            m_intentosDisponibles = (int)JuegoAhorcadoConstantes.MaximoIntentos;

            // Vector de letras jugadas: 
            m_jugadas = new ArrayList();

            // Actualizaci[on del estado del juego: 
            m_estado = EstadoJuego.Jugando;
        }
        /// <summary>
        /// Juega una letra específica.
        /// </summary>
        /// <param name="letra">Letra a jugar.</param>
        /// <returns><em>true</em> si la letra pertenece a la palbra; <em>false</em> en caso contrario.</returns>
        public bool JugarLetra(Letra letra)
        {
            if (m_estado != EstadoJuego.Jugando)
            {
                return false;
            }

            m_jugadas.Add(letra);

            bool pertenece = m_actual.EstaLetra(letra);


            if (!pertenece)
            {
                --m_intentosDisponibles;

                if(m_intentosDisponibles == 0)
                {
                    m_estado = EstadoJuego.Ahorcado;
                }
            }
            else
            {
                if (m_actual.EstaCompleta(m_jugadas))
                {
                    m_estado = EstadoJuego.Ganador;
                }
            }

            return pertenece;
        }
Esempio n. 41
0
    void moverFicha(int fichaX, int fichaY, int destinoX, int destinoY)
    {
        Vector3 posicion;
        // HACK Caso especial para una ficha que tiene un nombre que colisiona
        if (destinoX == 11 && destinoY == 0)
        {
            posicion = GameObject.Find(destinoX.ToString() + "-" + destinoY.ToString()).GetComponent<MeshCollider>().transform.position;
        }
        else
        {
            posicion = GameObject.Find(destinoX.ToString() + destinoY.ToString()).GetComponent<MeshCollider>().transform.position;
        }
        // Verifico si es un movimiento valido
        if (validarMovimiento(fichaX, fichaY, destinoX, destinoY, true))
        {
            // Actualizar los valores de la matriz
            if (MenuController.screenValue == Constants.GAMEMP)
            {
                GetComponent<NetworkView>().RPC("setMatrix", RPCMode.All, fichaX, fichaY, destinoX, destinoY);
            }
            else if (MenuController.screenValue == Constants.GAMESP || MenuController.screenValue == Constants.GAMEMPOFFLINE)
            {
                setMatrix(fichaX, fichaY, destinoX, destinoY);
            }

            if (selected == ID_Pelota)
            {
                if (MenuController.screenValue == Constants.GAMEMP)
                {
                    GetComponent<NetworkView>().RPC("moverPelotaEnServidorYCliente", RPCMode.All, destinoX, destinoY, posicion);
                }
                else if (MenuController.screenValue == Constants.GAMESP || MenuController.screenValue == Constants.GAMEMPOFFLINE)
                {
                    moverPelotaEnServidorYCliente(destinoX, destinoY, posicion);
                }
            }
            else
            {
                // Mover la ficha
                GameObject.FindWithTag(selected).GetComponent<MatrixAttributes>().x = destinoX;
                GameObject.FindWithTag(selected).GetComponent<MatrixAttributes>().y = destinoY;
                GameObject.FindWithTag(selected).transform.position = posicion;
            }

            // Deseleccionar la ficha
            selectDeselectPiece(selected);

            // Actualizar la posicion de la pelota si se esta moviendo la pelota
            BoardCell pelota = obtenerPelotaAdyacente(board[destinoX, destinoY]);
            if (pelota != null && pelota.tieneInfluencia(turno, true))
            {
                estado = EstadoJuego.Pase;
                selectDeselectPiece(ID_Pelota);
            }
            else
            {
                estado = EstadoJuego.Juego;
                bool especial = board[destinoX, destinoY].ficha == TipoFicha.Pelota &&
                                board[destinoX, destinoY].especial &&
                                board[destinoX, destinoY].equipo != turno;

                if (especial && !jugadaEspecial)
                {
                    jugadaEspecial = true;
                    jugadasAI = null;
                    jugadaAI = -1;
                    pases -= 1;
                }
                else
                {
                    if (MenuController.screenValue == Constants.GAMEMP)
                    {
                        GetComponent<NetworkView>().RPC("cambiarTurno", RPCMode.All);
                    }
                    else if (MenuController.screenValue == Constants.GAMESP || MenuController.screenValue == Constants.GAMEMPOFFLINE)
                    {
                        cambiarTurno();
                    }
                }
            }
        }
    }
 // Use this for initialization
 void Start()
 {
     rotar = GetComponent<Rotar>();
     estadoJuego = ControladorDelJuego.ObtenerComponente<EstadoJuego>("ControladorDelJuego");
 }
Esempio n. 43
0
 // Use this for initialization
 void Start()
 {
     estadoJuego = GetComponent<EstadoJuego>();
 }