public ThingPlaneta(Galaxia galaxia, Vector2 centro, float diametro)
: base(galaxia, new Vector2(diametro, diametro), centro, 0)
{
SetMovible(false);
SetVida(1000000);
SetColorEnMapa(Color.DarkSalmon);
}
public bool HayCondicionesOptimasDeTemperatura(Galaxia galaxia)
{
//Obtiene la obicacion de los 3 planetas y el sol
var ubicacionBetasoide = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Betasoide);
var ubicacionFerengi = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Ferengi);
var ubicacionVulcano = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Vulcano);
var ubicacionSol = ubicacionPlanetaService.ObtenerCoordenadasSol();
//Verifica si los 3 planetas estan alineados.
if (EstanLosCuerposAlineados(ubicacionBetasoide, ubicacionFerengi, ubicacionVulcano))
{
//Si estan los planetas alineados verifico que no esten alineados al sol.
return(!EstanLosCuerposAlineados(ubicacionBetasoide, ubicacionFerengi, ubicacionSol));
}
else
{
return(false);
}
}
public ThingResto(Galaxia galaxia, Vector2 center)
: base(galaxia, new Vector2(rnd.Next(3000, 5000) / 1000.0f, rnd.Next(3000, 5000) / 1000.0f), center, (float)rnd.Next(0, 360))
{
SetSolido(false);
SetActivo(true);
vida = rnd.Next(1000, 3000) / 1000.0f;
velocidad = (float)rnd.Next(500, 2000);
}
public ThingAgujeroDeGusano(Galaxia galaxia, Vector2 centro, float diametro)
: base(galaxia, new Vector2(diametro, diametro), centro, 0)
{
SetMovible(false);
SetMaxVida(1000000);
SetVida(1000000);
SetColorEnMapa(Color.Blue);
}
private void InicializarGalaxia(bool demo)
{
Universes.Generadores.Generador[] generadores = Universes.Generadores.Generador.GeneradoresDisponibles();
Universes.Generadores.Generador generadorAUsar = null;
if (!demo)
{
enDemo = false;
guiMapa.DrawEnabled = true;
string nombreGenerador = Properties.Settings.Default.GeneradorAUsar.Trim();
foreach (Universes.Generadores.Generador generador in generadores)
{
if (generador.Nombre().Equals(nombreGenerador, StringComparison.InvariantCultureIgnoreCase))
{
generadorAUsar = generador;
break;
}
}
if (generadorAUsar == null)
{
generadorAUsar = generadores[0];
}
galaxia = Galaxia.Crear(generadorAUsar);
naveJugador = new ThingNaveJugador(galaxia, new Vector2(100.0f, 100.0f), galaxia.PosicionInicialJugador, 0.0f, galaxia.FaccionJugador);
thingASeguir = naveJugador;
if (guiAvisoDemo != null)
{
guiEngine.Root.RemoveChildWindow(guiAvisoDemo);
guiAvisoDemo = null;
}
}
else
{
enDemo = true;
guiMapa.DrawEnabled = true;
generadorAUsar = new Universes.Generadores.GeneradorDemo();
galaxia = Galaxia.Crear(generadorAUsar);
naveJugador = null;
thingASeguir = null;
if (guiAvisoDemo == null)
{
guiAvisoDemo = new EspacioInfinitoDotNet.GUI.Controls.GUIStatic(new Size(GraphicEngine.Instance.Size.Width, 40));
guiAvisoDemo.Text = "JUEGO EN MODO DEMO - PRESIONE ESCAPE Y SELECCIONE NUEVO JUEGO PARA JUGAR";
guiAvisoDemo.TextColor = Color.Red;
guiAvisoDemo.AutoFit = false;
guiAvisoDemo.CenterHorizontally = true;
guiAvisoDemo.CenterVertically = true;
guiEngine.Root.AddChildWindow(guiAvisoDemo, new Point(0, 100));
}
}
}
public ThingNaveJugador(Galaxia galaxia, Vector2 size, Vector2 center, float rotation, Faccion faccion)
: base(galaxia, size, center, rotation, faccion)
{
SetActivo(true);
Nombre = "Jugador";
SetMaxVida(10000);
SetVida(10000);
SetColorEnMapa(System.Drawing.Color.White);
}
public ThingEstrella(Galaxia galaxia, Vector2 centro, float diametro)
: base(galaxia, new Vector2(diametro, diametro), centro, 0)
{
SetMovible(false);
SetVida(100);
SetColorEnMapa(Color.Red);
recursos = new RecursoRenovable[1];
recursos[0] = new RecursoRenovableEnThing(this, Recurso.RecursoHelio, 1000, diametro * 5.0f, 50, 1000);
}
public PeriodoDeLluvia EsPeriodoDeLluvia(Galaxia galaxia)
{
if (EstaSolDentroTrianguloFormadoPorPlanetas(galaxia))
{
return(ObtenerPerimetroTriangulo(galaxia));
}
else
{
return(PeriodoDeLluvia.SinPeriodoDeLluvia());
}
}
protected Thing(Galaxia galaxia, Vector2 size, Vector2 position, float rotation)
{
this.centro = position;
this.tamanio = size;
this.rotacion = rotation;
this.galaxia = galaxia;
boundingCircle = new BoundingCircle(centro, (float)Math.Sqrt(((tamanio.X / 2.0f) * (tamanio.X / 2.0f) + (tamanio.Y / 2.0f) * (tamanio.Y / 2.0f))));
galaxia.AgregarThing(this);
}
/// <summary>
/// Verifica si es un periodo de sequia en la Galaxia
/// </summary>
/// <param name="galaxia">Galaxia a verificar</param>
/// <returns>Es Periodo de sequia o no</returns>
public bool EsPeriodoDeSequia(Galaxia galaxia)
{
//Obtiene la obicacion de los 3 planetas y el sol
var ubicacionBetasoide = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Betasoide);
var ubicacionFerengi = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Ferengi);
var ubicacionVulcano = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Vulcano);
var ubicacionSol = ubicacionPlanetaService.ObtenerCoordenadasSol();
//Verifica si los 3 planetas estan alineados. Luego verifica si 2 de ellos estan alineados respecto al sol.
return(EstanLosCuerposAlineados(ubicacionBetasoide, ubicacionFerengi, ubicacionVulcano) && EstanLosCuerposAlineados(ubicacionBetasoide, ubicacionFerengi, ubicacionSol));
}
public override void Procesar(float fDeltaSegundos)
{
Thing[] thingsAfectados = Galaxia.GetThingsEnRadio(Centro, radioAccion);
foreach (Thing thing in thingsAfectados)
{
if (thing.Movible)
{
Vector2 distancia = thing.Centro - this.Centro;
float velocidad = -velocidadAtraccion * (radioAccion - distancia.Length) / radioAccion;
thing.MoverA(distancia.Normalized() * velocidad * fDeltaSegundos, true, true);
}
}
}
/// <summary>
/// Obtiene el perimetro del triangulo formado por los planetas
/// </summary>
/// <param name="galaxia"></param>
/// <returns></returns>
private PeriodoDeLluvia ObtenerPerimetroTriangulo(Galaxia galaxia)
{
//Obtiene la obicacion de los 3 planetas
var ubicacionBetasoide = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Betasoide);
var ubicacionFerengi = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Ferengi);
var ubicacionVulcano = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Vulcano);
var distanciaBetasoideFerengi = DistanciaEntreDosPuntos(ubicacionBetasoide, ubicacionFerengi);
var distanciaFerengiVulcano = DistanciaEntreDosPuntos(ubicacionFerengi, ubicacionVulcano);
var distanciaBetasoideVulcano = DistanciaEntreDosPuntos(ubicacionBetasoide, ubicacionVulcano);
return(new PeriodoDeLluvia
{
EsPeriodoDeLluvia = true,
PerimetroTriangulo = distanciaBetasoideFerengi + distanciaFerengiVulcano + distanciaBetasoideVulcano
});
}
public override void OnImpacto(Thing thing)
{
if (thing.Eliminado)
{
return;
}
if (agujeroDestino != null)
{
Vector2 vectorEntrada = (thing.Centro - this.Centro).Normalized();
Vector2 posicionFinal = agujeroDestino.Centro - vectorEntrada * (agujeroDestino.Tamanio.X / 2.0f * 1.1f + thing.Tamanio.Length / 2.0f);
if (Galaxia.ColisionaConThing(thing, posicionFinal, thing.Tamanio * 1.5f, thing.RotacionEnGrados) == null)
{
Galaxia.ActualizarCentroThing(thing, posicionFinal);
}
}
}
public override void Procesar(float fDeltaSegundos)
{
Rotar(velocidadRotacion * fDeltaSegundos, false, false);
Thing[] thingsAfectados = Galaxia.GetThingsEnRadio(Centro, radioAccion);
foreach (Thing thing in thingsAfectados)
{
if (thing.Movible)
{
Vector2 distancia = thing.Centro - this.Centro;
float velocidad = -velocidadAtraccion * (radioAccion - distancia.Length) / radioAccion;
thing.MoverA(distancia.Normalized() * velocidad * fDeltaSegundos, true, true);
float anguloDistancia = distancia.AngleInDegress + 180.0f;
float anguloThing = thing.RotacionEnGrados;
anguloDistancia = anguloDistancia % 360.0f;
if (anguloDistancia < 0)
{
anguloDistancia += 360.0f;
}
float separacionRotacion = anguloDistancia - anguloThing;
if (separacionRotacion < 0)
{
separacionRotacion += 360.0f;
}
if (separacionRotacion > 180.0f)
{
separacionRotacion = -(separacionRotacion - 180.0f);
}
float velocidadRotacionAngulo = (radioAccion - distancia.Length) / radioAccion;
separacionRotacion *= velocidadRotacionAngulo * fDeltaSegundos;
thing.Rotar(separacionRotacion, true, true);
}
}
}
public override void OnImpacto(Thing thing)
{
if (thing.Eliminado)
{
return;
}
Random rnd = new Random((int)DateTime.Now.Ticks);
if (rnd.Next(0, 2) == 1)
{
if (thing is ThingDaniable)
{
((ThingDaniable)thing).ProcesarDanio(this, 1000.0f);
}
}
else
{
while (true)
{
SectorID sectorIDDestino = new SectorID(
rnd.Next(-Galaxia.TamanioEnSectores.Width / 2, Galaxia.TamanioEnSectores.Width / 2),
rnd.Next(-Galaxia.TamanioEnSectores.Height / 2, Galaxia.TamanioEnSectores.Height / 2));
Sector sectorDestino = Galaxia.GetSector(sectorIDDestino);
Vector2 posicionEnSector = new Vector2(
rnd.Next(-Sector.TamanioSector / 2, -Sector.TamanioSector / 2),
rnd.Next(-Sector.TamanioSector / 2, -Sector.TamanioSector / 2));
Vector2 posicionFinal = sectorDestino.Centro + posicionEnSector;
if (Galaxia.ColisionaConThing(thing, posicionFinal, thing.Tamanio, thing.RotacionEnGrados) == null)
{
Galaxia.ActualizarCentroThing(thing, posicionFinal);
break;
}
}
}
}
public override void Procesar(float fDeltaSegundos)
{
duracionTranscurrida += fDeltaSegundos;
if (duracionTranscurrida > duracionSegundos)
{
Eliminar();
}
else
{
//Daño los nuevos objetos con los que impacto, para lo cual calculo el nuevo radio y solo
//daño a quellos objetos que se encuentren a una distancia mayor a la del radio viejo, de esta
//forma no daño 2 veces al mismo objeto! Al menos que se mueva delante de la onda expansiva, en cuyo
//caso esta bien que lo dañe.
//Tambien mantengo un vector de los things que fueron afectados, asi me aseguro de afectarlos al menos una vez,
//ya que existe la posibilidad de que el thing se mueva de forma tal que no lo afecte segun el chequeo anterior.
float nuevoRadioActual = radioInicial + (radioMaximo - radioInicial) * duracionTranscurrida / duracionSegundos;
Thing[] thingsImpactados = Galaxia.GetThingsEnRadio(Centro, nuevoRadioActual);
foreach (Thing thingImpactado in thingsImpactados)
{
if (thingImpactado is ThingDaniable)
{
float distancia = (thingImpactado.Centro - Centro).Length;
if (distancia > radioActual || !thingsAfectados.Contains(thingImpactado))
{
((ThingDaniable)thingImpactado).ProcesarDanio(this, danio);
thingsAfectados.Add(thingImpactado);
}
}
}
radioActual = nuevoRadioActual;
SetTamanio(new Vector2(radioActual * 2, radioActual * 2));
}
}
private CondicionClimatica EvalucionCondicionClimatica(Galaxia galaxia)
{
var condicionClimatica = new CondicionClimatica();
//Verifica si es periodo de sequia.
if (EsPeriodoDeSequia(galaxia))
{
condicionClimatica.EsPeriodoDeSequia = true;
Debug.WriteLine("PERIODO DE SEQUIA!!");
}
else
{
//Verifica si hay condiciones optimas de temperatura y presion.
if (HayCondicionesOptimasDeTemperatura(galaxia))
{
condicionClimatica.HayCondicionesOptimasDeTemperatura = true;
Debug.WriteLine("CONDICIONES OPTIMAS DE TEMPERATURA");
}
else
{
//Verifica si es periodo de lluvia.
var periodoDeLluvia = EsPeriodoDeLluvia(galaxia);
if (periodoDeLluvia.EsPeriodoDeLluvia)
{
condicionClimatica.EsPeriodoDeLluvia = true;
condicionClimatica.PerimetroTriangulo = periodoDeLluvia.PerimetroTriangulo;
Debug.WriteLine($"PERIODO DE LLUVIA!! - PERIMETRO --> {periodoDeLluvia.PerimetroTriangulo}");
}
}
}
return(condicionClimatica);
}
/// <summary>
/// Verifica que el sol esté dentro del triangulo formado por los planetas
/// http://www.dma.fi.upm.es/personal/mabellanas/tfcs/kirkpatrick/Aplicacion/algoritmos.htm
/// </summary>
/// <param name="galaxia">Galaxia a verificar</param>
/// <returns></returns>
private bool EstaSolDentroTrianguloFormadoPorPlanetas(Galaxia galaxia)
{
//Obtiene la obicacion de los 3 planetas y el sol
var ubicacionBetasoide = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Betasoide);
//Debug.WriteLine($"Distancia al sol --> {galaxia.Betasoide.DistanciaAlSol} - Posicion en grados --> {galaxia.Betasoide.PosicionEnGrados}");
//Debug.WriteLine($"Betasoide ({ubicacionBetasoide.X}, {ubicacionBetasoide.Y})");
var ubicacionFerengi = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Ferengi);
//Debug.WriteLine($"Distancia al sol --> {galaxia.Ferengi.DistanciaAlSol} - Posicion en grados --> {galaxia.Ferengi.PosicionEnGrados}");
//Debug.WriteLine($"Ferengi ({ubicacionFerengi.X}, {ubicacionFerengi.Y})");
var ubicacionVulcano = ubicacionPlanetaService.ObtenerCoordenadas(galaxia.Vulcano);
//Debug.WriteLine($"Distancia al sol --> {galaxia.Vulcano.DistanciaAlSol} - Posicion en grados --> {galaxia.Vulcano.PosicionEnGrados}");
//Debug.WriteLine($"Vulcano ({ubicacionVulcano.X}, {ubicacionVulcano.Y})");
var ubicacionSol = ubicacionPlanetaService.ObtenerCoordenadasSol();
var orientacion1 = ObtenerOrientacionTriangulo(ubicacionBetasoide, ubicacionFerengi, ubicacionVulcano);
var orientacion2 = ObtenerOrientacionTriangulo(ubicacionBetasoide, ubicacionFerengi, ubicacionSol);
var orientacion3 = ObtenerOrientacionTriangulo(ubicacionFerengi, ubicacionVulcano, ubicacionSol);
var orientacion4 = ObtenerOrientacionTriangulo(ubicacionVulcano, ubicacionBetasoide, ubicacionSol);
return(orientacion1 == orientacion2 && orientacion1 == orientacion3 && orientacion1 == orientacion4);
}
public override void Inicializar(Galaxia galaxia)
{
this.galaxia = galaxia;
bmpUniverso = InicializarBitmap();
}
public ThingOndaExpansiva(Galaxia galaxia, Vector2 center)
: base(galaxia, new Vector2(1, 1), center, 0)
{
SetSolido(false);
SetActivo(true);
}
public ThingNave(Galaxia galaxia, Vector2 size, Vector2 center, float rotation, Faccion faccion)
: base(galaxia, size, center, rotation)
{
this.faccion = faccion;
}
public ThingEstacionEspacial(Galaxia galaxia, Vector2 centro, Vector2 tamanio)
: base(galaxia, tamanio, centro, 0)
{
SetMovible(false);
SetVida(1000000);
}
public override void Inicializar(Galaxia galaxia)
{
this.galaxia = galaxia;
}
protected ThingRedondo(Galaxia galaxia, Vector2 size, Vector2 position, float rotation)
: base(galaxia, size, position, rotation)
{
}
public ThingLaser(Galaxia galaxia, Vector2 center, float rotation, Thing duenio)
: base(galaxia, new Vector2(40.0f, 8.0f), center, rotation)
{
SetActivo(true);
this.duenio = duenio;
}
public PeriodoDeLluvia EsPeriodoDeLluvia(Galaxia galaxia)
{
throw new NotImplementedException();
}
public PrediccionClimaService(IUbicacionPlanetaService ubicacionPlanetaService, IRepositoryWrapper repositoryWrapper)
{
this.ubicacionPlanetaService = ubicacionPlanetaService;
this.repositoryWrapper = repositoryWrapper;
this.galaxia = new GalaxiaFactory().CrearGalaxia();
}
public bool EsPeriodoDeSequia(Galaxia galaxia)
{
throw new NotImplementedException();
}
public bool HayCondicionesOptimasDeTemperatura(Galaxia galaxia)
{
throw new NotImplementedException();
}
public override void Draw(GUIGraphicEngine guiGraphicEngine)
{
Thing thingASeguir = Game.GameEngine.Instance.ThingASeguir;
if (thingASeguir == null)
{
return;
}
Galaxia galaxia = thingASeguir.Galaxia;
//Calculo la posición del mapa en la pantalla
Vector2 inicioSuperiorIzquierdo = new Vector2(PrvGetAbsolutePosition().X, PrvGetAbsolutePosition().Y);
Vector2 finInferiorDerecho = new Vector2(PrvGetAbsolutePosition().X + Size.Width, PrvGetAbsolutePosition().Y + Size.Height);
//Calculo la cantidad óptima de sectores de igual tamaño (cuadrados) a dibujar
int radioSectoresADibujarEnMapaX = Properties.Settings.Default.RadioSectoresCercanosADibujarEnMapa;
int radioSectoresADibujarEnMapaY = Properties.Settings.Default.RadioSectoresCercanosADibujarEnMapa;
Vector2 tamanioSectorEnMapa = new Vector2(
(finInferiorDerecho.X - inicioSuperiorIzquierdo.X) / (radioSectoresADibujarEnMapaX * 2 + 1),
(finInferiorDerecho.Y - inicioSuperiorIzquierdo.Y) / (radioSectoresADibujarEnMapaY * 2 + 1));
float tamanioSectorAUsar;
if (tamanioSectorEnMapa.X > tamanioSectorEnMapa.Y)
{
tamanioSectorAUsar = tamanioSectorEnMapa.X;
}
else
{
tamanioSectorAUsar = tamanioSectorEnMapa.Y;
}
tamanioSectorEnMapa.X = tamanioSectorAUsar;
tamanioSectorEnMapa.Y = tamanioSectorAUsar;
radioSectoresADibujarEnMapaX = (int)Math.Ceiling((finInferiorDerecho.X - inicioSuperiorIzquierdo.X) / tamanioSectorEnMapa.X / 2 - 1);
radioSectoresADibujarEnMapaY = (int)Math.Ceiling((finInferiorDerecho.Y - inicioSuperiorIzquierdo.Y) / tamanioSectorEnMapa.Y / 2 - 1);
SectorID sectorIDCentro = galaxia.GetSectorEnPosicion(thingASeguir.Centro).SectorID;
Gl.glBegin(Gl.GL_QUADS);
//Dibujo un fondo negro
GraphicEngine.Instance.SetColor(Color.FromArgb(200, Color.Black));
Gl.glVertex3f(inicioSuperiorIzquierdo.X, inicioSuperiorIzquierdo.Y, GraphicEngine.zValue);
Gl.glVertex3f(inicioSuperiorIzquierdo.X, finInferiorDerecho.Y, GraphicEngine.zValue);
Gl.glVertex3f(finInferiorDerecho.X, finInferiorDerecho.Y, GraphicEngine.zValue);
Gl.glVertex3f(finInferiorDerecho.X, inicioSuperiorIzquierdo.Y, GraphicEngine.zValue);
Gl.glEnd();
//Dibujo el borde del mapa
Gl.glBegin(Gl.GL_LINE_LOOP);
GraphicEngine.Instance.SetColor(Color.FromArgb(100, Color.LightBlue));
Gl.glVertex3f(inicioSuperiorIzquierdo.X, inicioSuperiorIzquierdo.Y, GraphicEngine.zValue);
Gl.glVertex3f(inicioSuperiorIzquierdo.X, finInferiorDerecho.Y, GraphicEngine.zValue);
Gl.glVertex3f(finInferiorDerecho.X, finInferiorDerecho.Y, GraphicEngine.zValue);
Gl.glVertex3f(finInferiorDerecho.X, inicioSuperiorIzquierdo.Y, GraphicEngine.zValue);
Gl.glEnd();
//Dibujo las lineas de los sectores y su contenido
//Calculo el offset dentro del mapa debido al desplazamiento del jugador en el sector
Vector2 offset = new Vector2(
(thingASeguir.Centro.X - galaxia.GetSector(sectorIDCentro).Centro.X) / Sector.TamanioSector * tamanioSectorEnMapa.X,
(thingASeguir.Centro.Y - galaxia.GetSector(sectorIDCentro).Centro.Y) / Sector.TamanioSector * tamanioSectorEnMapa.Y);
//Dibujo un sector menos y un sector mas en cada uno de los ejes (X,Y) para compensar los casos en los que
//el offset es distinto a cero, en cuyo caso se deberian ver parcialmente algunos otros sectores
Vector2 from = new Vector2(
inicioSuperiorIzquierdo.X - offset.X - tamanioSectorEnMapa.X,
finInferiorDerecho.Y + offset.Y + tamanioSectorEnMapa.Y);
Gl.glBegin(Gl.GL_LINES);
for (int x = sectorIDCentro.X - radioSectoresADibujarEnMapaX - 1; x <= sectorIDCentro.X + radioSectoresADibujarEnMapaX + 1; x++)
{
from.Y = finInferiorDerecho.Y + offset.Y + tamanioSectorEnMapa.Y;
GraphicEngine.Instance.SetColor(Color.FromArgb(100, Color.LightBlue));
//Linea vertical que abarca todos los sectores
if (Properties.Settings.Default.DibujarLineasMapa)
{
Gl.glVertex3f(from.X, inicioSuperiorIzquierdo.Y, GraphicEngine.zValue);
Gl.glVertex3f(from.X, finInferiorDerecho.Y, GraphicEngine.zValue);
}
Vector2 to = new Vector2(from.X + tamanioSectorEnMapa.X, from.Y - tamanioSectorEnMapa.Y);
for (int y = sectorIDCentro.Y - radioSectoresADibujarEnMapaY - 1; y <= sectorIDCentro.Y + radioSectoresADibujarEnMapaY + 1; y++)
{
Sector sector = galaxia.GetSector(new SectorID(x, y));
bool cambiarFondo = false;
Color nuevoColorFondo = Color.Black;
if (sector.TieneNebulosa)
{
//Relleno el sector de un color distinto si tiene nebulosa
cambiarFondo = true;
nuevoColorFondo = Color.FromArgb(50, Color.DarkViolet);
}
if (thingASeguir is ThingNave)
{
ThingNave thingNave = (ThingNave)thingASeguir;
if (sector.Faccion != null &&
sector.Faccion.GetRelacion(thingNave.Faccion) == Faccion.RelacionConOtraFaccionEnum.Agresiva)
{
cambiarFondo = true;
nuevoColorFondo = Color.FromArgb(50, Color.Red);
}
}
if (cambiarFondo)
{
Gl.glEnd();
Gl.glBegin(Gl.GL_QUADS);
GraphicEngine.Instance.SetColor(nuevoColorFondo);
Gl.glVertex3f(from.X, from.Y, GraphicEngine.zValue);
Gl.glVertex3f(from.X, to.Y, GraphicEngine.zValue);
Gl.glVertex3f(to.X, to.Y, GraphicEngine.zValue);
Gl.glVertex3f(to.X, from.Y, GraphicEngine.zValue);
Gl.glEnd();
Gl.glBegin(Gl.GL_LINES);
}
//Dibujo las naves que haya en el sector
if (sector.ThingsCount > 0)
{
Gl.glEnd();
}
foreach (Thing thing in sector.Things)
{
//Dibujo todos los elementos en el mapa, excepto la nave del jugador
//que la dibujo al final para que queda arriba de todo
if (!(thing is ThingNaveJugador))
{
DibujarThing(guiGraphicEngine, thing, sector, from, to, tamanioSectorAUsar);
}
}
if (sector.ThingsCount > 0)
{
Gl.glBegin(Gl.GL_LINES);
}
GraphicEngine.Instance.SetColor(Color.FromArgb(100, Color.LightBlue));
//Linea horizontal que abarca solo este sector
if (Properties.Settings.Default.DibujarLineasMapa)
{
Gl.glVertex3f(from.X, to.Y, GraphicEngine.zValue);
Gl.glVertex3f(to.X, to.Y, GraphicEngine.zValue);
}
from.Y -= tamanioSectorEnMapa.Y;
to.Y -= tamanioSectorEnMapa.Y;
}
from.X += tamanioSectorEnMapa.X;
}
Gl.glEnd();
//Dibujo la nave del jugador en el centro del mapa, lo cual siempre va a ser correcto
//porque el mapa esta centrado en el jugador
//DibujarThing(guiGraphicEngine, naveJugador, galaxia.GetSectorEnPosicion(naveJugador.Centro), from, to, tamanioSectorAUsar);
Vector2 centroMapa = new Vector2(
(inicioSuperiorIzquierdo.X + finInferiorDerecho.X) / 2,
(inicioSuperiorIzquierdo.Y + finInferiorDerecho.Y) / 2);
centroMapa.X -= PrvGetAbsolutePosition().X;
centroMapa.Y -= PrvGetAbsolutePosition().Y;
thingASeguir.DibujarEnMapa(centroMapa, tamanioSectorAUsar / 3, guiGraphicEngine);
}
