Пример #1
0
        private bool VerificarPoner(Assets.Casilla[,] casillas, int x, int z)
        {
            if (Limites.Comprobar(x, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z, 2, Escenario.instancia.tamañoEscenarioZ) == true)
            {
                if (casillas[x, z] != null)
                {
                    if (casillas[x, z].posicion.y > 1f)
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
Пример #2
0
        private int VerificarRampa1Rotacion270(int x, int z, float altura, Assets.Casilla[,] casillas)
        {
            if (Limites.Comprobar(z - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
            {
                if (casillas[x, z - 1] != null)
                {
                    if (Escenario.instancia.CalcularIDFinal(casillas[x, z - 1].id) < 5 && casillas[x, z - 1].idDebug != 99)
                    {
                        Assets.Isla isla = casillas[x, z - 1].isla;

                        Assets.Casilla rampa = new Assets.Casilla(5, 270, new Vector3(x, altura, z));
                        rampa.isla    = isla;
                        rampa.idDebug = 99;
                        Escenario.instancia.PonerCasilla(rampa);

                        return(1);
                    }
                }
            }

            return(0);
        }
Пример #3
0
        private int VerificarEsquina2Rotacion180(int x, int z, float altura, Assets.Casilla[,] casillas)
        {
            if (Limites.Comprobar(x + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z + 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
            {
                if (casillas[x + 1, z + 1] != null && ComprobarCosta(casillas[x + 1, z]) == 1 && ComprobarCosta(casillas[x, z + 1]) == 1)
                {
                    if (Escenario.instancia.CalcularIDFinal(casillas[x + 1, z + 1].id) < 5 && casillas[x + 1, z + 1].idDebug != 99)
                    {
                        Assets.Isla isla = casillas[x + 1, z + 1].isla;

                        Assets.Casilla esquina = new Assets.Casilla(6, 180, new Vector3(x, altura, z));
                        esquina.isla    = isla;
                        esquina.idDebug = 99;
                        Escenario.instancia.PonerCasilla(esquina);

                        return(1);
                    }
                }
            }

            return(0);
        }
Пример #4
0
        //-------------------------------------

        private void VerificarHuecos(int x, int z, float altura, Assets.Casilla[,] casillas)
        {
            if (Limites.Comprobar(z + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
            {
                if (ComprobarCosta(casillas[x, z + 1]) == 2 && ComprobarCosta(casillas[x, z - 1]) == 2)
                {
                    Assets.Isla isla = casillas[x, z + 1].isla;

                    Assets.Casilla plano = new Assets.Casilla(0, 0, new Vector3(x, altura + 0.5f, z));
                    plano.isla = isla;
                    Escenario.instancia.PonerCasilla(plano);
                }
            }

            if (Limites.Comprobar(x + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(x - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
            {
                if (ComprobarCosta(casillas[x + 1, z]) == 2 && ComprobarCosta(casillas[x - 1, z]) == 2)
                {
                    Assets.Isla isla = casillas[x + 1, z].isla;

                    Assets.Casilla plano = new Assets.Casilla(0, 0, new Vector3(x, altura + 0.5f, z));
                    plano.isla = isla;
                    Escenario.instancia.PonerCasilla(plano);
                }
            }

            if (Limites.Comprobar(x + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(x - 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z + 1, 2, Escenario.instancia.tamañoEscenarioZ) == true && Limites.Comprobar(z - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
            {
                if (ComprobarCosta(casillas[x + 1, z]) == 2 && ComprobarCosta(casillas[x, z + 1]) == 2 && ComprobarCosta(casillas[x - 1, z - 1]) == 2)
                {
                    Assets.Isla isla = casillas[x + 1, z].isla;

                    Assets.Casilla plano = new Assets.Casilla(0, 0, new Vector3(x, altura + 0.5f, z));
                    plano.isla = isla;
                    Escenario.instancia.PonerCasilla(plano);
                }
            }
        }
Пример #5
0
        public void GenerarCasillas(Assets.Casilla[,] casillas, Assets.Isla[] islas, int limitesMapa)
        {
            LimpiarDatos(islas);

            foreach (Assets.Isla isla in islas)
            {
                List <Vector3> listado = new List <Vector3>();

                int montañasGenerar    = (int)isla.extensionMaxima.x / 10 * (int)isla.extensionMaxima.y / 10;
                int intentosGeneracion = montañasGenerar;

                int i = 1;
                while (i <= intentosGeneracion)
                {
                    float alturaCasilla = (int)Random.Range(3, isla.alturaMaxima);

                    int posicionX = (int)Random.Range((int)isla.coordenadasMinimas.x + limitesMapa, (int)isla.coordenadasMinimas.x + (int)isla.extensionMaxima.x - limitesMapa);
                    int posicionZ = (int)Random.Range((int)isla.coordenadasMinimas.y + limitesMapa, (int)isla.coordenadasMinimas.y + (int)isla.extensionMaxima.y - limitesMapa);

                    bool añadir = true;

                    foreach (Assets.Casilla casilla in casillas)
                    {
                        if (casilla != null)
                        {
                            if (Enumerable.Range((int)(casilla.posicion.x - alturaCasilla), (int)(casilla.posicion.x + alturaCasilla)).Contains(posicionX))
                            {
                                if (Enumerable.Range((int)(casilla.posicion.z - alturaCasilla), (int)(casilla.posicion.z + alturaCasilla)).Contains(posicionZ))
                                {
                                    añadir = false;

                                    if (intentosGeneracion >= 0)
                                    {
                                        intentosGeneracion -= 1;
                                        i -= 1;
                                    }
                                }
                            }
                        }
                    }

                    if (Limites.Comprobar(posicionX, 2, Escenario.instancia.tamañoEscenarioX) == false || Limites.Comprobar(posicionZ, 2, Escenario.instancia.tamañoEscenarioZ) == false)
                    {
                        añadir = false;
                    }

                    if (añadir == true)
                    {
                        listado.Add(new Vector3(posicionX, alturaCasilla, posicionZ));

                        int desplazamiento = 0;
                        while (alturaCasilla >= 1)
                        {
                            int planos = (int)Random.Range(0, 4 + desplazamiento);

                            if (desplazamiento > 0)
                            {
                                int j = 0;
                                while (j <= planos)
                                {
                                    int x = 0;
                                    int z = 0;

                                    int azar = (int)Random.Range(0, 12);

                                    if (azar == 1)
                                    {
                                        x = 1 + (int)(desplazamiento * 2);
                                        z = 1 + (int)(desplazamiento * 2);
                                    }
                                    else if (azar == 2)
                                    {
                                        x = 1 + (int)(desplazamiento * 2);
                                        z = -1 - (int)(desplazamiento * 2);
                                    }
                                    else if (azar == 3)
                                    {
                                        x = -1 - (int)(desplazamiento * 2);
                                        z = 1 + (int)(desplazamiento * 2);
                                    }
                                    else if (azar == 4)
                                    {
                                        x = -1 - (int)(desplazamiento * 2);
                                        z = -1 - (int)(desplazamiento * 2);
                                    }
                                    else if (azar == 5 || azar == 6)
                                    {
                                        x = 2 + (int)(desplazamiento * 2);
                                        z = Random.Range(-desplazamiento, desplazamiento);
                                    }
                                    else if (azar == 7 || azar == 8)
                                    {
                                        x = -2 - (int)(desplazamiento * 2);
                                        z = Random.Range(-desplazamiento, desplazamiento);
                                    }
                                    else if (azar == 9 || azar == 10)
                                    {
                                        x = Random.Range(-desplazamiento, desplazamiento);
                                        z = 2 + (int)(desplazamiento * 2);
                                    }
                                    else if (azar == 11 || azar == 12)
                                    {
                                        x = Random.Range(-desplazamiento, desplazamiento);
                                        z = -2 - (int)(desplazamiento * 2);
                                    }

                                    if (azar > 0)
                                    {
                                        if (alturaCasilla == 1.5f || alturaCasilla == 2f)
                                        {
                                            for (int origenX = posicionX + x - 1; origenX < posicionX + x + 2; origenX++)
                                            {
                                                for (int origenZ = posicionZ + z - 1; origenZ < posicionZ + z + 2; origenZ++)
                                                {
                                                    if (Limites.Comprobar(origenX, 2, (int)isla.extensionMaxima.x) == true && Limites.Comprobar(origenZ, 2, (int)isla.extensionMaxima.y) == true)
                                                    {
                                                        if (casillas[origenX, origenZ] == null)
                                                        {
                                                            listado.Add(new Vector3(origenX, alturaCasilla, origenZ));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        else if (alturaCasilla == 1f)
                                        {
                                            for (int origenX = posicionX + x - 2; origenX < posicionX + x + 3; origenX++)
                                            {
                                                for (int origenZ = posicionZ + z - 2; origenZ < posicionZ + z + 3; origenZ++)
                                                {
                                                    if (Limites.Comprobar(origenX, 2, (int)isla.extensionMaxima.x) == true && Limites.Comprobar(origenZ, 2, (int)isla.extensionMaxima.y) == true)
                                                    {
                                                        if (casillas[origenX, origenZ] == null)
                                                        {
                                                            listado.Add(new Vector3(origenX, alturaCasilla, origenZ));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if (Limites.Comprobar(posicionX + x, 2, (int)isla.extensionMaxima.x) == true && Limites.Comprobar(posicionZ + z, 2, (int)isla.extensionMaxima.y) == true)
                                            {
                                                listado.Add(new Vector3(posicionX + x, alturaCasilla, posicionZ + z));
                                            }
                                        }
                                    }

                                    j += 1;
                                }
                            }

                            alturaCasilla  -= 0.5f;
                            desplazamiento += 1;
                        }
                    }

                    i += 1;
                }

                CopiarDatos(listado, isla.id);
            }
        }
Пример #6
0
        //------------------------------------------------------------------------------------------------------------------------------------

        public void PonerCasilla(Assets.Casilla casilla)
        {
            Assets.Casilla[] casillasFinal;
            int id      = casilla.id;
            int idDebug = casilla.idDebug;

            if (coloresGeneracion == false)
            {
                if (idDebug != 99)
                {
                    idDebug = id;
                }

                if (id != casillasDebug.Length - 1 && idDebug != 99)
                {
                    id = CalcularIDFinal(id);
                }

                if (casilla.isla != null)
                {
                    casillasFinal = casilla.isla.casillas;
                }
                else
                {
                    casillasFinal = casillasDebug;
                }
            }
            else
            {
                if (idDebug == 99)
                {
                    if (casilla.isla != null)
                    {
                        casillasFinal = casilla.isla.casillas;
                    }
                    else
                    {
                        casillasFinal = casillasDebug;
                    }
                }
                else
                {
                    casillasFinal = casillasDebug;
                    idDebug       = id;
                }
            }

            int x = (int)casilla.posicion.x;
            int z = (int)casilla.posicion.z;

            if (Limites.Comprobar(x, 3, tamañoEscenarioX) == true && Limites.Comprobar(z, 3, tamañoEscenarioZ) == true)
            {
                if (casillas[x, z] == null)
                {
                    Vector3 posicionFinal = casilla.posicion;

                    if (casillasEscala != 0.5f)
                    {
                        posicionFinal.x = (posicionFinal.x + posicionFinal.x * (casillasEscala * 1.5f)) - (tamañoEscenarioX / (casillasEscala + 0.5f));
                        posicionFinal.y = posicionFinal.y + posicionFinal.y * (casillasEscala * 1.5f);
                        posicionFinal.z = (posicionFinal.z + posicionFinal.z * (casillasEscala * 1.5f)) - (tamañoEscenarioZ / (casillasEscala + 0.5f));
                    }

                    GameObject casilla2 = Instantiate(casillasFinal[id].prefab, posicionFinal, Quaternion.identity);
                    casilla2.gameObject.transform.Rotate(Vector3.up, casilla.rotacion, Space.World);
                    casilla2.gameObject.transform.localScale = new Vector3(casillasEscala, casillasEscala, casillasEscala);

                    Coordenadas coordenadas = casilla2.gameObject.AddComponent <Coordenadas>();
                    coordenadas.x = x;
                    coordenadas.z = z;

                    Assets.Casilla casilla3 = new Assets.Casilla(id, casilla.rotacion, casilla.posicion);
                    casilla3.id      = id;
                    casilla3.idDebug = idDebug;
                    casilla3.prefab  = casilla2;
                    casilla3.prefab.gameObject.layer = LayerMask.NameToLayer("Terreno");
                    casilla3.isla                = casilla.isla;
                    casilla3.recursoPuesto       = false;
                    casilla3.recursoPosible      = casillasFinal[id].recursoPosible;
                    casilla3.recursoPosicion     = casillasFinal[id].recursoPosicion;
                    casilla3.construccionPosible = casillasFinal[id].construccionPosible;
                    casilla3.posicionesSuelo     = casillasFinal[id].posicionesSuelo;
                    casilla3.posicionesParedes   = casillasFinal[id].posicionesParedes;

                    casillas[x, z] = casilla3;
                }
            }
        }
Пример #7
0
        //------------------------------------------------------------------------------------------------------------------------------------

        private void GenerarNivel(float altura)
        {
            foreach (Assets.Isla isla in islas)
            {
                Partida.PartidaIsla isla2 = Vectores.instancia.LeerDatos(isla.id);

                foreach (Partida.PartidaCasilla casilla in isla2.casillas)
                {
                    Vector3 casilla2 = casilla.coordenadas.ObtenerVector3();

                    if (altura == casilla2.y)
                    {
                        if (Limites.Comprobar((int)casilla2.x, 3, tamañoEscenarioX) == true && Limites.Comprobar((int)casilla2.z, 3, tamañoEscenarioZ) == true)
                        {
                            if (casillas[(int)casilla2.x, (int)casilla2.z] == null)
                            {
                                Assets.Casilla casilla3 = new Assets.Casilla(0, 0, casilla2)
                                {
                                    isla = isla
                                };

                                PonerCasilla(casilla3);
                            }
                        }
                    }
                }
            }

            foreach (Assets.Casilla subcasilla in casillas)
            {
                if (subcasilla != null)
                {
                    int x = (int)subcasilla.posicion.x;
                    int z = (int)subcasilla.posicion.z;

                    float y = subcasilla.posicion.y;
                    y = y - 0.5f;

                    if (y < 0.0f)
                    {
                        y = 0.0f;
                    }

                    if ((y > 0) && (altura == subcasilla.posicion.y) && Limites.Comprobar(x, 2, tamañoEscenarioX) == true && Limites.Comprobar(z, 2, tamañoEscenarioZ) == true)
                    {
                        if (casillas[x - 1, z - 1] == null)
                        {
                            Colores.instancia.Casilla_Xmenos1_Zmenos1(x, y, z);
                        }

                        if (casillas[x - 1, z + 1] == null)
                        {
                            Colores.instancia.Casilla_Xmenos1_Zmas1(x, y, z);
                        }

                        if (casillas[x + 1, z - 1] == null)
                        {
                            Colores.instancia.Casilla_Xmas1_Zmenos1(x, y, z);
                        }

                        if (casillas[x + 1, z + 1] == null)
                        {
                            Colores.instancia.Casilla_Xmas1_Zmas1(x, y, z);
                        }

                        if (casillas[x, z - 1] == null)
                        {
                            Colores.instancia.Casilla_X0_Zmenos1(x, y, z);
                        }

                        if (casillas[x - 1, z] == null)
                        {
                            Colores.instancia.Casilla_Xmenos1_Z0(x, y, z);
                        }

                        if (casillas[x, z + 1] == null)
                        {
                            Colores.instancia.Casilla_X0_Zmas1(x, y, z);
                        }

                        if (casillas[x + 1, z] == null)
                        {
                            Colores.instancia.Casilla_Xmas1_Z0(x, y, z);
                        }
                    }
                }
            }
        }