示例#1
0
        public override Sector CrearSector(SectorID sectorID)
        {
            Sector sector = new Sector(galaxia, sectorID, null);

            galaxia.AgregarSector(sector);

            if (sectorID.X == 4 && sectorID.Y == 3)
            {
                ThingAgujeroDeGusano ta1 = new ThingAgujeroDeGusano(galaxia, sector.Centro +
                                                                    new Vector2(0, Sector.TamanioSector / 2 - 1 - 300), 300);
                ThingAgujeroDeGusano ta2 = new ThingAgujeroDeGusano(galaxia, galaxia.GetSector(new SectorID(4, 5)).Centro +
                                                                    new Vector2(0, -Sector.TamanioSector / 2 + 1 - 300), 300);

                ta1.AgujeroDestino = ta2;
                ta2.AgujeroDestino = ta1;
            }
            else if (sectorID.X == 4 && sectorID.Y == 4)
            {
                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(Sector.TamanioSector / 2 - 1, Sector.TamanioSector / 2 - 1), 300);

                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(-Sector.TamanioSector / 2 + 1, -Sector.TamanioSector / 2 + 1), 300);

                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(Sector.TamanioSector / 2 - 1, -Sector.TamanioSector / 2 + 1), 300);

                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(-Sector.TamanioSector / 2 + 1, Sector.TamanioSector / 2 - 1), 300);

                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(-Sector.TamanioSector / 2 + 1, 0), 300);

                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(+Sector.TamanioSector / 2 - 1, 0), 300);

                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(0, -Sector.TamanioSector / 2 + 1), 300);

                new ThingPlaneta(galaxia, sector.Centro +
                                 new Vector2(0, +Sector.TamanioSector / 2 - 1), 300);
            }

            return(sector);
        }
示例#2
0
        public override Sector CrearSector(SectorID sectorID)
        {
            Faccion faccion = null;

            if (sectorID.X > -TamanioEnSectores / 2 &&
                sectorID.X < TamanioEnSectores / 2 &&
                sectorID.Y > -TamanioEnSectores / 2 &&
                sectorID.Y < TamanioEnSectores / 2)
            {
                int x = sectorID.X + TamanioEnSectores / 2;
                int y = sectorID.Y + TamanioEnSectores / 2;

                Color color = bmpUniverso.GetPixel(x, y);

                faccion = facciones[color.R / 8];
            }

            Sector sector = new Sector(galaxia, sectorID, faccion);

            galaxia.AgregarSector(sector);

            bool puedeSerNebula  = true;
            bool puedeTenerNaves = false;

            if (rndCreacionSectores.Next(0, ProbabilidadAgujeroNegro) == 0)
            {
                //Agrego un agujero negro

                puedeSerNebula = false; //Los sectores con agujeros negros no deben contener nebulas

                float diametro          = rndCreacionSectores.Next(100, 500);
                float radioAlcance      = rndCreacionSectores.Next(1000, 3000);
                float velocidadRotacion = rndCreacionSectores.Next(90, 360);

                Vector2 posicion = sector.BuscarEspacioVacio(diametro / 2 + DistanciaMinimaEntreThingsEnSector);

                ThingAgujeroNegro t = new ThingAgujeroNegro(galaxia, posicion, diametro);

                t.RadioAccion       = radioAlcance;
                t.VelocidadRotacion = velocidadRotacion;
            }
            else if (rndCreacionSectores.Next(0, ProbabilidadEstrella) == 0)
            {
                //Agrego una estrella

                float diametro     = rndCreacionSectores.Next(100, 500);
                float radioAlcance = rndCreacionSectores.Next(1000, 3000);

                Vector2 posicion = sector.BuscarEspacioVacio(diametro / 2 + DistanciaMinimaEntreThingsEnSector);

                ThingEstrella t = new ThingEstrella(galaxia, posicion, diametro);

                t.RadioAccion = radioAlcance;
            }
            else if (rndCreacionSectores.Next(0, ProbabilidadPlaneta) == 0)
            {
                //Agrego un planeta, para lo cual primero determino si va a tener o no estacion espacial,
                //ya que de tenerla, tengo que buscar en el sector un espacio lo suficientemente grande como para
                //que entre el planeta y la estacion espacial en orbita
                puedeTenerNaves = true;

                float diametroPlaneta = rndCreacionSectores.Next(100, 500);

                Vector2 tamanioEstacionEspacial     = new Vector2(200, 200);
                bool    tieneEstacionEspacial       = (rndCreacionSectores.Next(0, ProbabilidadEstacionEspacialOrbitaPlaneta) == 0);
                float   radioOrbitaEstacionEspacial = diametroPlaneta / 2.0f + tamanioEstacionEspacial.X / 2.0f + (float)rndCreacionSectores.Next(100, 1000);

                Vector2 posicionPlaneta;

                if (tieneEstacionEspacial)
                {
                    posicionPlaneta = sector.BuscarEspacioVacio(diametroPlaneta / 2 + radioOrbitaEstacionEspacial + tamanioEstacionEspacial.X / 2 + DistanciaMinimaEntreThingsEnSector);
                }
                else
                {
                    posicionPlaneta = sector.BuscarEspacioVacio(diametroPlaneta / 2 + DistanciaMinimaEntreThingsEnSector);
                }

                ThingPlaneta planeta = new ThingPlaneta(galaxia, posicionPlaneta, diametroPlaneta);

                if (tieneEstacionEspacial)
                {
                    //Agrego una estación espacial en orbita!
                    float velocidadRotacionOrbita = (float)rndCreacionSectores.Next(100, 1000) / 100.0f;

                    Vector2 posicionEstacion = planeta.Centro + new Vector2(radioOrbitaEstacionEspacial, 0);

                    ThingEstacionEspacial estacionEspacial = new ThingEstacionEspacial(galaxia, posicionEstacion, tamanioEstacionEspacial);

                    estacionEspacial.EnOrbita                = true;
                    estacionEspacial.ThingCentroOrbita       = planeta;
                    estacionEspacial.RadioOrbita             = radioOrbitaEstacionEspacial;
                    estacionEspacial.VelocidadRotacionOrbita = velocidadRotacionOrbita;
                }
            }
            else if (rndCreacionSectores.Next(0, ProbabilidadEstacionEspacial) == 0)
            {
                //Agrego una estación espacial

                puedeTenerNaves = true;

                Vector2 posicion = sector.BuscarEspacioVacio(100 + DistanciaMinimaEntreThingsEnSector);

                ThingEstacionEspacial t = new ThingEstacionEspacial(galaxia, posicion, new Vector2(200, 200));
            }
            else if (rndCreacionSectores.Next(0, ProbabilidadAgujeroDeGusano) == 0)
            {
                //Agrego agujeros de gusano

                float diametro          = rndCreacionSectores.Next(100, 500);
                float velocidadRotacion = rndCreacionSectores.Next(90, 360);

                //Busco posiciones que sean 2 veces el diametro para que quede espacio alrededor
                //del agujero de salida para que se mueva el objeto que llegue
                Vector2 posicion = sector.BuscarEspacioVacio(diametro / 2 + DistanciaMinimaEntreThingsEnSector);

                ThingAgujeroDeGusano a1 = new ThingAgujeroDeGusano(galaxia, posicion, diametro);
                Sector sectorDestino;

                a1.VelocidadRotacion = velocidadRotacion;

                while (true)
                {
                    SectorID sectorIDDestino = new SectorID(
                        rndCreacionSectores.Next(-TamanioEnSectores / 2, TamanioEnSectores / 2),
                        rndCreacionSectores.Next(-TamanioEnSectores / 2, TamanioEnSectores / 2));

                    if (galaxia.SectorCargado(sectorIDDestino) == false)
                    {
                        sectorDestino = galaxia.GetSector(sectorIDDestino);
                        break;
                    }
                }

                posicion = sectorDestino.BuscarEspacioVacio(diametro / 2 + DistanciaMinimaEntreThingsEnSector);

                ThingAgujeroDeGusano a2 = new ThingAgujeroDeGusano(galaxia, posicion, diametro);

                a1.AgujeroDestino = a2;
                a2.AgujeroDestino = a1;
            }

            if (puedeSerNebula)
            {
                int probabilidadNebula = ProbabilidadNebula;

                //Si un sector tiene una nebula cerca, tiene mas probabilidad de ser nebula

                foreach (SectorID sIDCercano in sectorID.SectoresCercanos)
                {
                    if (galaxia.SectorCargado(sIDCercano) &&
                        galaxia.GetSector(sIDCercano).TieneNebulosa)
                    {
                        probabilidadNebula = ProbabilidadNebulaContinua;
                        break;
                    }
                }

                if (rndCreacionSectores.Next(0, probabilidadNebula) == 0)
                {
                    sector.CrearNebulosa();
                }
            }

            if (puedeTenerNaves && sector.Faccion != null)
            {
                int cantidadNaves = rndCreacionSectores.Next(0, 2);

                for (int i = 0; i < cantidadNaves; i++)
                {
                    Vector2 posicion = sector.BuscarEspacioVacio(300);

                    Things.NPC.ThingNaveNPC thingNaveNPC = new Things.NPC.ThingNaveNPC(galaxia, new Vector2(100, 100), posicion, 0, sector.Faccion);
                }
            }

            return(sector);
        }