Пример #1
0
    /*
     * private void mapGeneration()
     * {
     *  int cantHabitaciones = NumPisos * NumHabitaciones;
     *
     *  int idRoom;
     *  if (room == null)
     *      print("Room es null");
     *
     *  int espaciosRestantes;
     *  Vector3 posicionActual = new Vector3(0, 0, 0);
     *
     *  idRoom = 0;
     *  for (int pisoActual = 0; pisoActual < NumPisos; pisoActual++)
     *  {
     *      posicionActual.x = 0;
     *
     *      espaciosRestantes = NumHabitaciones * 2;
     *      estructuraPisos auxPiso = new estructuraPisos(); //Creo el piso auxiliar donde guardar los datos en la estructura de pisos
     *      auxPiso.habitaciones = new List<estructuraHabitacion>();
     *      auxPiso.escaleraEn = -1;
     *
     *      int habActual = 0;
     *
     *      while (espaciosRestantes > 0)
     *      { // Mientras que sigan habiendo espacios / Pequenya 1 - Mediana 2 . Grande 4
     *
     *          int coordenadasActuales = (NumHabitaciones * 2 - espaciosRestantes);
     *
     *          float tHab = RoomController.T_HAB;
     *
     *          if (puedoConstruir(pisoActual, coordenadasActuales))
     *          {
     *
     *              //print ("En el piso "+pisoActual+" hay " + espaciosRestantes + " espacios restantes");
     *              estructuraHabitacion auxHab = new estructuraHabitacion();
     *              if (pisoActual == 0 && espaciosRestantes == cantHabitaciones * 2)
     *              {
     *                  auxHab.coordenadas = new Vector2(0, pisoActual);
     *              }
     *              else
     *                  auxHab.coordenadas = new Vector2(coordenadasActuales, pisoActual);
     *
     *              auxHab.conectaCon = new List<estructuraHabitacion>();
     *              GameObject habitacion = Instantiate(room, new Vector3(posicionActual.x, posicionActual.y, posicionActual.z), Quaternion.identity);
     *              if (habActual < 10)
     *                  habitacion.transform.name = "Habitacion: " + pisoActual + "0" + habActual;
     *              else
     *                  habitacion.transform.name = "Habitacion: " + pisoActual + "" + habActual;
     *
     *              habitacion.GetComponent<RoomController>().ladderReceived = -1;
     *              habitacion.GetComponent<RoomController>().id = idRoom;
     *              habitacion.GetComponent<RoomController>().piso = pisoActual;
     *              habitacion.transform.Rotate(new Vector3(0, 180, 0));
     *
     *              auxHab.id = idRoom;
     *              auxHab.habitacion = habitacion;
     *
     *              int contRandom = 0;
     *
     *              if (espaciosRestantes > 3)
     *                  contRandom = 3;
     *              else if (espaciosRestantes > 1)
     *                  contRandom = 2;
     *              else if (espaciosRestantes == 1)
     *                  contRandom = 1;
     *
     *
     *
     *              bool listo = false;
     *              while (!listo)
     *              {
     *
     *                  switch (Random.Range(1, (contRandom + 1)))
     *                  {
     *                      case 2:
     *                          if (puedoConstruir(pisoActual, coordenadasActuales) && puedoConstruir(pisoActual, coordenadasActuales + 1))
     *                          {
     *                              habitacion.GetComponent<RoomController>().tamanyo = RoomController.roomSize.medium;
     *                              posicionActual.x = posicionActual.x + tHab;
     *                              espaciosRestantes = espaciosRestantes - 2;
     *                              auxHab.tam = 2;
     *                              listo = true;
     *                          }
     *                          break;
     *                      case 3:
     *                          if (puedoConstruir(pisoActual, coordenadasActuales) && puedoConstruir(pisoActual, coordenadasActuales + 1) && puedoConstruir(pisoActual, coordenadasActuales + 2) && puedoConstruir(pisoActual, coordenadasActuales + 3))
     *                          {
     *                              habitacion.GetComponent<RoomController>().tamanyo = RoomController.roomSize.large;
     *                              posicionActual.x = posicionActual.x + tHab * 2f;
     *                              espaciosRestantes = espaciosRestantes - 4;
     *                              auxHab.tam = 4;
     *                              listo = true;
     *                          }
     *                          break;
     *                      default:
     *                          if (puedoConstruir(pisoActual, coordenadasActuales))
     *                          {
     *                              habitacion.GetComponent<RoomController>().tamanyo = RoomController.roomSize.small;
     *                              espaciosRestantes--;
     *                              posicionActual.x = posicionActual.x + tHab / 2f;
     *                              auxHab.tam = 1;
     *                              listo = true;
     *                          }
     *                          break;
     *                  }
     *
     *              }
     *              if (pisoActual != NumPisos - 1)
     *              {
     *                  habitacion.GetComponent<RoomController>().tall = Random.Range(0, 3) == 1 ? true : false;
     *
     *                  if (espaciosRestantes == 0 && areAllTall(pisoActual, false))
     *                      habitacion.GetComponent<RoomController>().tall = true;
     *                  else if (espaciosRestantes == 0 && areAllTall(pisoActual, true))
     *                      habitacion.GetComponent<RoomController>().tall = false;
     *              }
     *              else
     *                  habitacion.GetComponent<RoomController>().tall = false;
     *
     *              auxHab.tall = habitacion.GetComponent<RoomController>().tall;
     *
     *              if (pisoActual != 0)
     *              {
     *                  if (listaPisos[pisoActual - 1].escaleraEn >= auxHab.coordenadas.x && listaPisos[pisoActual - 1].escaleraEn < auxHab.coordenadas.x + auxHab.tam)
     *                  {
     *                      habitacion.GetComponent<RoomController>().ladderReceived = listaPisos[pisoActual - 1].escaleraEn - (int)auxHab.coordenadas.x;
     *                      //print ("La habitacion "+habitacion.GetComponent<RoomController> ().name+" recibe la escalera en "+habitacion.GetComponent<RoomController> ().ladderReceived+" posicion");
     *                  }
     *
     *              }
     *
     *              if (pisoActual < NumPisos - 1 && habitacion.GetComponent<RoomController>().ladderReceived == -1)
     *              {
     *                  if (pisoActual == 0)
     *                  {
     *                      if (auxPiso.escaleraEn == -1 && espaciosRestantes == 0)
     *                      {
     *                          habitacion.GetComponent<RoomController>().tall = false;
     *                          habitacion.GetComponent<RoomController>().ladderPosition = Random.Range(1, auxHab.tam);
     *                          //print ("Coordenadas escalera piso "+ pisoActual +": " + (auxHab.coordenadas.x + habitacion.GetComponent<RoomController> ().ladderPosition - 1));
     *                          auxPiso.escaleraEn = (int)(auxHab.coordenadas.x + habitacion.GetComponent<RoomController>().ladderPosition - 1);
     *                      }
     *
     *                      auxHab.tall = habitacion.GetComponent<RoomController>().tall;
     *
     *                      if (auxPiso.escaleraEn == -1 && !auxHab.tall)
     *                      {
     *                          if (Random.Range(0, 3) == 1)
     *                          {
     *                              habitacion.GetComponent<RoomController>().ladderPosition = Random.Range(1, auxHab.tam);
     *                              //print ("Coordenadas escalera piso "+ pisoActual +": " + (auxHab.coordenadas.x + habitacion.GetComponent<RoomController> ().ladderPosition - 1));
     *                              auxPiso.escaleraEn = (int)(auxHab.coordenadas.x + habitacion.GetComponent<RoomController>().ladderPosition - 1);
     *                          }
     *                      }
     *                  }
     *                  else
     *                  {
     *                      if (listaPisos[pisoActual - 1].escaleraEn >= auxHab.coordenadas.x && listaPisos[pisoActual - 1].escaleraEn < auxHab.coordenadas.x + auxHab.tam)
     *                      {
     *
     *                      }
     *                      else
     *                      {
     *                          if (auxPiso.escaleraEn == -1 && espaciosRestantes == 0)
     *                          {
     *                              habitacion.GetComponent<RoomController>().tall = false;
     *                              habitacion.GetComponent<RoomController>().ladderPosition = Random.Range(1, auxHab.tam);
     *                              //print ("Coordenadas escalera piso "+ pisoActual +": " + (auxHab.coordenadas.x + habitacion.GetComponent<RoomController> ().ladderPosition - 1));
     *                              auxPiso.escaleraEn = (int)(auxHab.coordenadas.x + habitacion.GetComponent<RoomController>().ladderPosition - 1);
     *                          }
     *
     *                          auxHab.tall = habitacion.GetComponent<RoomController>().tall;
     *
     *                          if (auxPiso.escaleraEn == -1 && !auxHab.tall)
     *                          {
     *                              if (Random.Range(0, 3) == 1)
     *                              {
     *                                  habitacion.GetComponent<RoomController>().ladderPosition = Random.Range(1, auxHab.tam);
     *                                  //print ("Coordenadas escalera piso "+ pisoActual +": " + (auxHab.coordenadas.x + habitacion.GetComponent<RoomController> ().ladderPosition - 1));
     *                                  auxPiso.escaleraEn = (int)(auxHab.coordenadas.x + habitacion.GetComponent<RoomController>().ladderPosition - 1);
     *                              }
     *                          }
     *                      }
     *                  }
     *              }
     *
     *              habitacion.GetComponent<RoomController>().tipoHabitacion = RoomController.tipo.HabitacionPrincipal;
     *
     *              if (idRoom == 0 && pisoActual == 0)
     *                  habitacion.GetComponent<RoomController>().playerSpawn = true;
     *              else
     *                  habitacion.GetComponent<RoomController>().playerSpawn = false;
     *
     *              //rellenarPeredes (habitacion, habActual, coordenadasActuales);
     *
     *              if (pisoActual == NumPisos - 1)
     *                  habitacion.GetComponent<RoomController>().hasTecho = true;
     *              else
     *                  habitacion.GetComponent<RoomController>().hasTecho = false;
     *
     *              if (pisoActual == NumPisos - 2 && auxHab.tall)
     *                  habitacion.GetComponent<RoomController>().hasTecho = true;
     *
     *              habitacion.GetComponent<RoomController>().estilo = estilo;
     *
     *
     *              //print ("He hecho "+cont + "iteraciones");
     *
     *              //print ("--- Soy la habitacion "+idRoom+" con dificultad -> "+aux+" ---");
     *
     *              habitacion.GetComponent<RoomController>().dificultad = dificultadParaHabitacion();
     *              habitacion.GetComponent<RoomController>().mapGenController = this.gameObject;
     *              habitacion.transform.SetParent(this.transform);
     *              roomList.Add(habitacion);
     *              cantHabitacionesTotal++;
     *              idRoom++;
     *              habActual++;
     *
     *              auxPiso.habitaciones.Add(auxHab);
     *
     *
     *          }
     *          else
     *          {
     *
     *              int restante = ((int)listaPisos[pisoActual - 1].habitaciones[getIndexHabitacionPorCoordenada(pisoActual - 1, coordenadasActuales)].coordenadas.x + listaPisos[pisoActual - 1].habitaciones[getIndexHabitacionPorCoordenada(pisoActual - 1, coordenadasActuales)].tam) - coordenadasActuales;
     *              posicionActual.x = posicionActual.x + (tHab / 2f * restante);
     *              //print ("Estoy en (" + pisoActual + "," + coordenadasActuales + ") y me sobra " + restante);
     *              espaciosRestantes = espaciosRestantes - restante;
     *
     *          }
     *      }
     *      //66.3f
     *      posicionActual.y = 66.5f * (pisoActual + 1);
     *
     *      if (auxPiso.escaleraEn == -1 && pisoActual != NumPisos - 1)
     *          print("PROBLEMAS EN EL PISO " + pisoActual);
     *
     *      listaPisos.Add(auxPiso);
     *  }
     * }*/

    private bool areAllTall(estructuraPisos piso, bool tall)
    {
        if (piso.habitaciones.Count > 0)
        {
            int cont = 0;
            for (int i = 0; i < piso.habitaciones.Count; i++)
            {
                if (tall == piso.habitaciones[i].tall)
                {
                    cont++;
                }
            }

            if (cont == piso.habitaciones.Count)
            {
                return(true);
            }
        }
        return(false);
    }
Пример #2
0
    private estructuraPisos generateFloor(int piso)
    {
        estructuraPisos auxPiso = new estructuraPisos();

        auxPiso.habitaciones = new List <estructuraHabitacion>();
        auxPiso.escaleraEn   = -1;

        int espaciosRestantes = (int)espacioLibreEnPiso(piso);
        int idRoom            = 0;

        if (piso != 0)
        {
            idRoom = listaPisos[piso - 1].habitaciones[listaPisos[piso - 1].habitaciones.Count - 1].id + 1;
        }

        int HabActual, maxEspDisponible;

        while (espaciosRestantes > 0)
        {
            estructuraHabitacion auxHab = new estructuraHabitacion();
            HabActual        = (int)HabitacionMasGrandeDisponible(piso).x;
            maxEspDisponible = (int)HabitacionMasGrandeDisponible(piso).y;

            auxHab.id = idRoom;
            auxHab.estiloHabitacion = estilo;
            auxHab.tipoHabitacion   = RoomController.tipo.HabitacionPrincipal;
            int contRandom = 0;

            if (idRoom == 0)
            {
                auxHab.tipoHabitacion = RoomController.tipo.Entrada;
            }

            auxHab.coordenadas = new Vector2(piso, HabActual);
            auxHab.tall        = false;
            auxHab.conectaCon  = new List <estructuraHabitacion>();
            auxHab.hasTecho    = false;

            auxHab.listaLaterales = new RoomController.tiposParedes[4];
            for (int i = 0; i < 4; i++)
            {
                auxHab.listaLaterales[i] = RoomController.tiposParedes.nada;
            }

            if (maxEspDisponible > 3)
            {
                contRandom += 3;
            }
            else if (maxEspDisponible > 1)
            {
                contRandom += 2;
            }
            else if (maxEspDisponible == 1)
            {
                contRandom += 1;
            }

            int auxTam = Random.Range(1, (contRandom + 1));
            if (auxTam == 1 && auxHab.tipoHabitacion == RoomController.tipo.HabitacionPrincipal)
            {
                auxHab.tipoHabitacion = Random.Range(0, 5) == 0 ? RoomController.tipo.Banyo : RoomController.tipo.HabitacionPrincipal;
            }

            switch (auxHab.tipoHabitacion)
            {
            case RoomController.tipo.Entrada:
                if (maxEspDisponible > 1)
                {
                    auxTam = Random.Range(1, 3);
                }
                else
                {
                    auxTam = 1;
                }
                break;

            case RoomController.tipo.Banyo:
                auxTam = 1;
                break;
            }

            switch (auxTam)
            {
            case 2:
                espaciosRestantes = espaciosRestantes - 2;
                auxHab.tam        = 2;
                break;

            case 3:
                espaciosRestantes = espaciosRestantes - 4;
                auxHab.tam        = 4;
                break;

            default:
                espaciosRestantes--;
                auxHab.tam = 1;
                break;
            }

            if (piso < (NumPisos - 1))
            {
                auxHab.tall = Random.Range(0, 3) == 1 ? true : false;
            }

            if ((piso == NumPisos - 2 && auxHab.tall) || piso == (NumPisos - 1))
            {
                auxHab.hasTecho = true;
            }

            for (int i = HabActual; i < HabActual + auxHab.tam; i++)
            {
                matrizHabitaciones[piso, i] = auxHab.id;
                if (auxHab.tall)
                {
                    matrizHabitaciones[piso + 1, i] = auxHab.id;
                }
            }
            cantHabitacionesTotal++;
            auxPiso.habitaciones.Add(auxHab);
            idRoom++;
        }//Acabo de generar los pisos

        if (piso < (NumPisos - 1))
        {
            if (areAllTall(auxPiso, true) || areAllTall(auxPiso, false)) //Compruebo que no todos sean altos, ni todos sean bajos (al menos 1 de cada)
            {
                int habCambio = Random.Range(0, auxPiso.habitaciones.Count);
                estructuraHabitacion habTemp = auxPiso.habitaciones[habCambio];
                habTemp.tall = !habTemp.tall;
                if (piso == NumPisos - 2)
                {
                    if (habTemp.tall)
                    {
                        habTemp.hasTecho = true;
                    }
                    else
                    {
                        habTemp.hasTecho = false;
                    }
                }

                auxPiso.habitaciones[habCambio] = habTemp;

                for (int i = (int)habTemp.coordenadas.y; i < (int)habTemp.coordenadas.y + habTemp.tam; i++)
                {
                    matrizHabitaciones[piso, i] = habTemp.id;
                    if (habTemp.tall)
                    {
                        matrizHabitaciones[piso + 1, i] = habTemp.id;
                    }
                    else
                    {
                        matrizHabitaciones[piso + 1, i] = -1;
                    }
                }
            }
        }

        return(auxPiso);
    }