bool Calcular(ISateliteData data)
{
var elementos = conversor.Convertir(data.Posicion, data.Velocidad);
data.Inclinacion = elementos.Inclination;
return true;
}
Vector CalcularOrientacionOrbital(ISateliteData data)
{
Vector forward = data.Velocidad.Clone();
forward.Normalize();
return forward;
}
private void OrientacionATierra(ISateliteData data)
{
data.Actitud = ActitudRotacion.Maniobrando;
Vector orientacion = CalcularOrientacionATierra(data);
maniobra = factory.CreateManiobra(ActitudRotacion.EnfocadoATierra, data, orientacion);
}
Vector CalcularOrientacionATierra(ISateliteData data)
{
Vector forward = data.Posicion.Clone();
forward.Normalize();
forward *= -1;
return forward;
}
public IManiobraRotacion CreateManiobra(ActitudRotacion siguienteActitud, ISateliteData sateliteData, Vector orientacionSolicitada)
{
return container.Resolve<IManiobraRotacion>(
new NamedParameter("siguienteActitud", siguienteActitud),
new NamedParameter("sateliteData", sateliteData),
new NamedParameter("orientacionSolicitada", orientacionSolicitada)
);
}
public void CalcularImpulso(ISateliteData data)
{
if (data.ImpulsoSolicitado >= 0)
{
CambioDeImpulso(data, data.ImpulsoSolicitado);
}
variacionImpulso?.Invoke();
}
Vector CalcularFuerzaGravitatoria(ISateliteData data)
{
double gravitationModulus = CalcularAtraccionTerrestre(constantes.SatellitMass, data.Posicion.Magnitude);
Vector gravitationForce = data.Posicion.Clone();
gravitationForce.Normalize();
gravitationForce = gravitationForce * gravitationModulus * -1;
return gravitationForce;
}
public void CalcularNuevaPosicion(ISateliteData data)
{
Vector fuerzaGravitatoria = CalcularFuerzaGravitatoria(data);
Vector aceleracionGravitatoria = fuerzaGravitatoria / constantes.SatellitMass;
data.Velocidad += aceleracionGravitatoria * constantes.FixedDeltaTime;
Vector desplazamiento = data.Velocidad * constantes.FixedDeltaTime;
data.Posicion += desplazamiento;
}
void Frenar(ISateliteData data, float frenadoSolicitado)
{
var variacion = constantes.VariacionMaximaDelImpulso * constantes.FixedDeltaTime;
data.Impulso -= variacion;
if (data.Impulso <= frenadoSolicitado)
{
data.Impulso = frenadoSolicitado;
variacionImpulso = null;
}
}
void Acelerar(ISateliteData data, float aceleracionSolicitada)
{
var variacion = constantes.VariacionMaximaDelImpulso * constantes.FixedDeltaTime;
data.Impulso += variacion;
if (data.Impulso >= aceleracionSolicitada)
{
data.Impulso = aceleracionSolicitada;
variacionImpulso = null;
}
}
public override void Ejecutar(ISateliteData data)
{
if (data.AlturaDeReferencia < data.Altura)
{
PasoFinalizado = true;
}
else
{
data.AlturaDeReferencia = data.Altura;
this.SegundosAEsperar = 30;
}
}
public ManiobraRotacion(Constantes constantes, IVectorTools vectorTools, ActitudRotacion siguienteActitud, ISateliteData sateliteData, Vector orientacionSolicitada)
{
this.constantes = constantes;
this.vectorTools = vectorTools;
SiguienteActitud = siguienteActitud;
orientacionInicial = sateliteData.Orientacion;
orientacionFinal = orientacionSolicitada;
float anguloEnGrados = vectorTools.AngleTo(orientacionInicial, orientacionFinal);
tiempoParaFinalizarEnSegundos = anguloEnGrados / velocidadAngularEnGradosPorSegundo;
}
private void GestionarCambioDeRotacion(ISateliteData data)
{
if (data.ActitudSolicitada != data.Actitud)
{
switch (data.ActitudSolicitada)
{
case ActitudRotacion.CaidaLibre: RotacionLibre(data); break;
case ActitudRotacion.EnfocadoATierra: OrientacionATierra(data); break;
case ActitudRotacion.Orbital: OrientacionOrbital(data); break;
}
}
data.ActitudSolicitada = ActitudRotacion.Ninguna;
}
bool ComprobarSiLaOrbitaSubeOBaja(ISateliteData data)
{
if (data.AlturaDeReferencia > data.Altura)
{
data.OrbitaSubiendo = false;
return true;
}
if (data.AlturaDeReferencia < data.Altura)
{
data.OrbitaSubiendo = true;
return true;
}
SolicitarEspera(5);
return false;
}
bool CalcularValoresDelImpulso(ISateliteData data)
{
double radioPeriapsis = data.Periapsis + constantes.EarthRadius;
double radioApoapsis = data.Apoapsis + constantes.EarthRadius;
double compartido = Math.Sqrt(constantes.Mu * 2);
double momentoAngularActual = compartido * Math.Sqrt((radioApoapsis * radioPeriapsis) / (radioApoapsis + radioPeriapsis));
double momentoAngularDeseado = compartido * Math.Sqrt((radioApoapsis * radioApoapsis) / (radioApoapsis + radioApoapsis));
double velocidadActualenApoapsis = momentoAngularActual / radioApoapsis;
double velocidadDeseadaEnApoapsis = momentoAngularDeseado / radioApoapsis;
nuevaVelocidad = (float)velocidadDeseadaEnApoapsis;
impulsoNecesario = (float)(velocidadDeseadaEnApoapsis - velocidadActualenApoapsis);
duracionDelImpulsoEnSegundos = impulsoNecesario / constantes.ImpulsoMaximo;
if (duracionDelImpulsoEnSegundos > 5) duracionDelImpulsoEnSegundos = 5;
return true;
}
public void CambioDeImpulso(ISateliteData data, float cambioDeImpulsoPedido)
{
data.ImpulsoSolicitado = -1;
if (cambioDeImpulsoPedido > constantes.ImpulsoMaximo)
cambioDeImpulsoPedido = constantes.ImpulsoMaximo;
else if (cambioDeImpulsoPedido < 0)
cambioDeImpulsoPedido = 0;
if (cambioDeImpulsoPedido > data.Impulso)
{
variacionImpulso = () => Acelerar(data, cambioDeImpulsoPedido);
}
if (cambioDeImpulsoPedido < data.Impulso)
{
variacionImpulso = () => Frenar(data, cambioDeImpulsoPedido);
}
}
public void CalcularNuevaRotacion(ISateliteData data)
{
if (data.ActitudSolicitada != ActitudRotacion.Ninguna)
{
GestionarCambioDeRotacion(data);
}
if ((maniobra != null) && (maniobra.ManiobraCompletada))
{
data.Actitud = maniobra.SiguienteActitud;
maniobra = null;
}
switch (data.Actitud)
{
case ActitudRotacion.CaidaLibre: break;
case ActitudRotacion.Maniobrando: data.Orientacion = maniobra.CalcularNuevaOrientacion(); break;
case ActitudRotacion.EnfocadoATierra: data.Orientacion = CalcularOrientacionATierra(data); break;
case ActitudRotacion.Orbital: data.Orientacion = CalcularOrientacionOrbital(data); break;
default: throw new ArgumentException("Actitud no implementada en CalculadorRotacion2");
}
}
public void Actua(ISateliteData data)
{
while (pasosAEjecutar[0].PasoFinalizado)
{
bool informarDelCambioDePaso = !(pasosAEjecutar[0] is PasoEsperar);
pasosAEjecutar.RemoveAt(0);
if (pasosAEjecutar.Count == 0)
{
DecisionFinalizada = true;
return;
}
if (informarDelCambioDePaso)
Log.Paso(pasosAEjecutar[0].LogData);
}
pasosAEjecutar[0].Ejecutar(data);
var segundosAEsperar = pasosAEjecutar[0].SegundosAEsperar;
if (segundosAEsperar > 0)
{
pasosAEjecutar.Insert(0, new PasoEsperar(constantes, segundosAEsperar));
pasosAEjecutar[0].SegundosAEsperar = 0;
}
}
public override void Ejecutar(ISateliteData data)
{
data.ActitudSolicitada = ActitudRotacion.EnfocadoATierra;
PasoFinalizado = true;
}
public override void Ejecutar(ISateliteData data)
{
if (Accion(data))
PasoFinalizado = true;
}
private bool CambiarVelocidad(ISateliteData data)
{
data.Velocidad.Normalize();
data.Velocidad *= nuevaVelocidad;
return true;
}
public override bool DebeActuar(ISateliteData data)
{
return (data.Periapsis > 0)
&& (data.Apoapsis > 0)
&& (Math.Abs(data.Apoapsis - data.Periapsis) > margenDeCircularización);
}
public override void Inicializar(ISateliteData data)
{
base.Inicializar(data);
impulsoNecesario = -1;
}
public override bool DebeActuar(ISateliteData data)
{
return data.Actitud != ActitudRotacion.Orbital;
}
//bool EsperarMomentoDeIgnicion(float deltaTime)
//{
// float tiempoYaGastado = Time.time - marcaDeTiempo;
// float tiempoAntesDeApoapsisParaIgnicion = duracionDelImpulsoEnSegundos / 2;
// float tiempoAEsperar = duracionDeMediaOrbita - tiempoYaGastado - tiempoAntesDeApoapsisParaIgnicion;
// SolicitarEspera(tiempoAEsperar);
// return true;
//}
//bool EncenderMotor(float deltaTime)
//{
// Data.ImpulsoSolicitado = Config.ImpulsoMaximo;
// return true;
//}
//bool EsperarDuracionDelImpulso(float deltaTime)
//{
// SolicitarEspera(duracionDelImpulsoEnSegundos);
// return true;
//}
//bool ApagarMotor(float deltaTime)
//{
// Data.ImpulsoSolicitado = 0;
// return true;
//}
bool ResetearValoresOrbitales(ISateliteData data)
{
data.InvalidateOrbitalValues();
return true;
}
private void RotacionLibre(ISateliteData data)
{
data.Actitud = ActitudRotacion.CaidaLibre;
}
private void OrientacionOrbital(ISateliteData data)
{
data.Actitud = ActitudRotacion.Maniobrando;
Vector orientacion = CalcularOrientacionOrbital(data);
maniobra = factory.CreateManiobra(ActitudRotacion.Orbital, data, orientacion);
}
public override bool DebeActuar(ISateliteData data)
{
return (((data.Periapsis < 0) || (data.Apoapsis < 0)) && (data.OrbitaSubiendo == null));
}
public override void Inicializar(ISateliteData data)
{
base.Inicializar(data);
data.AlturaDeReferencia = -1;
}
public override bool DebeActuar(ISateliteData data)
{
return ((data.Periapsis < 0) && (data.OrbitaSubiendo == false));
}
