public ExponentialNotation GetIntensityAtDistance(Vector3 orbitingObjectPosition)
{
//todo convert Vector3 into real distance
ExponentialNotation actualDistance = ConvertVector3ToAU(orbitingObjectPosition);
return(IntensityCalculator.IntensityAtDistance(this.IntenstityAtSurface, this.Radius, actualDistance));
}
private static ExponentialNotation ConvertUp(ExponentialNotation distanceToConvert, SIUnit desiredMeasurementUnit)
{
ExponentialNotation convertedDistance = distanceToConvert;
while (convertedDistance.MeasurementUnits < desiredMeasurementUnit)
{
switch (convertedDistance.MeasurementUnits)
{
case SIUnit.AstronomicalUnits:
convertedDistance = convertedDistance / LightYear_To_AstronomicalUnitsRatio;
convertedDistance.MeasurementUnits = SIUnit.Lightyears;
break;
case SIUnit.Kilometers:
convertedDistance = convertedDistance / AstronomicalUnit_To_KilometersRatio;
convertedDistance.MeasurementUnits = SIUnit.AstronomicalUnits;
break;
case SIUnit.Meters:
convertedDistance = convertedDistance / Kilometers_To_MetersRatio;
convertedDistance.MeasurementUnits = SIUnit.Kilometers;
break;
default:
return(convertedDistance);
}
}
return(convertedDistance);
}
public static ExponentialNotation operator *(ExponentialNotation exponentialValue1, ExponentialNotation exponentialValue2)
{
var temp = new ExponentialNotation
(
value: exponentialValue1.value * exponentialValue2.value,
exponent: exponentialValue1.exponent + exponentialValue2.exponent,
unit: exponentialValue1.MeasurementUnits
);
temp.RecalculateExponents();
return(temp);
}
public static ExponentialNotation operator /(ExponentialNotation exponentialValue, float floatValue)
{
var temp = new ExponentialNotation
(
value: exponentialValue.value / floatValue,
exponent: exponentialValue.exponent,
unit: exponentialValue.MeasurementUnits
);
temp.RecalculateExponents();
return(temp);
}
private void CreateNewStellarObject(ExponentialNotation mass, ExponentialNotation radius,
string name, Vector3 startingPosition)
{
GameObject newInstance = GameObject.Instantiate(stellarObject_BasePrefab, startingPosition, Quaternion.identity);
newInstance.name = name;
StellarObject newStellarObject = newInstance.GetComponentInChildren <StellarObject>();
newStellarObject.Initialize(mass, radius);
stellarObjects.Add(newInstance);
}
public static ExponentialNotation Convert(ExponentialNotation massToConvert, SIUnit unitToConvertTo)
{
ExponentialNotation convertedMass = massToConvert;
if (massToConvert.MeasurementUnits > unitToConvertTo)
{
convertedMass = ConvertDown(massToConvert, unitToConvertTo);
}
else if (massToConvert.MeasurementUnits < unitToConvertTo)
{
convertedMass = ConvertUp(massToConvert, unitToConvertTo);
}
return(convertedMass);
}
public static ExponentialNotation Convert(ExponentialNotation distanceToConvert, SIUnit unitToConvertTo)
{
ExponentialNotation convertedDistance = distanceToConvert;
if (distanceToConvert.MeasurementUnits > unitToConvertTo)
{
convertedDistance = ConvertDown(distanceToConvert, unitToConvertTo);
}
else if (distanceToConvert.MeasurementUnits < unitToConvertTo)
{
convertedDistance = ConvertUp(distanceToConvert, unitToConvertTo);
}
return(convertedDistance);
}
public void Initialize(ExponentialNotation mass, ExponentialNotation radius)
{
this.Mass = mass;
this.Radius = radius;
this.IntenstityAtSurface = IntensityCalculator.IntensityAtSurface(this.Mass, this.Radius);
ExponentialNotation radiusAsAU = DistanceConverter.Convert(this.Radius, SIUnit.AstronomicalUnits);
float scaledValue = radiusAsAU.GetNormalizedValue();
this.gameObject.transform.localScale = new Vector3(
x: scaledValue,
y: scaledValue,
z: scaledValue
);
}
/// <summary>
/// n = distanceFromSource / radiusOfSource
/// I / (n^2) = Intensity at DistanceFromSource
/// </summary>
/// <param name="surfaceIntensity"></param>
/// <param name="radiusOfSourceObject"></param>
/// <param name="distanceAwayFromSource"></param>
/// <returns></returns>
public static ExponentialNotation IntensityAtDistance(ExponentialNotation surfaceIntensity, ExponentialNotation radiusOfSourceObject, ExponentialNotation distanceAwayFromSource)
{
ExponentialNotation intensityAtDistance = null;
//Convert distances to meters
//Calculate n: distanceFromSource / radiusOfSource
ExponentialNotation multipleOfRadius = distanceAwayFromSource / radiusOfSourceObject;
multipleOfRadius = (multipleOfRadius * multipleOfRadius);
multipleOfRadius = DistanceConverter.Convert(multipleOfRadius, SIUnit.Meters);
//Divide Surface Intensity by n^2
intensityAtDistance = surfaceIntensity / multipleOfRadius;
intensityAtDistance.MeasurementUnits = SIUnit.MetersCubed_PerSecondsSquared_PerKilograms;
//I / (n^2)
return(intensityAtDistance);
}
private static ExponentialNotation ConvertUp(ExponentialNotation massToConvert, SIUnit desiredMeasurementUnit)
{
ExponentialNotation convertedMass = massToConvert;
while (convertedMass.MeasurementUnits < desiredMeasurementUnit)
{
switch (convertedMass.MeasurementUnits)
{
case SIUnit.Kilograms:
convertedMass = convertedMass / SolarMass_To_KilogramsRatio;
convertedMass.MeasurementUnits = SIUnit.SolarMasses;
break;
default:
return(convertedMass);
}
}
return(convertedMass);
}
/// <summary>
/// Calculate the Intensity of Gravity at the Surface of the object
/// I = (G*M)/(r^2)
/// </summary>
/// <param name="massOfObject">The mass of the object</param>
/// <param name="radiusOfObject">The radius of the object</param>
/// <returns></returns>
public static ExponentialNotation IntensityAtSurface(ExponentialNotation massOfObject, ExponentialNotation radiusOfObject)
{
ExponentialNotation intensity = null;
//Calculate the numerator: Graviational Constant * Mass (in kg)
ExponentialNotation massOfObjectInKilograms = MassConverter.Convert(massOfObject, SIUnit.Kilograms);
intensity = GravitationalConstantOfTheUniverse * massOfObjectInKilograms;
//Square the radius
ExponentialNotation radiusOfObjectInMeters = DistanceConverter.Convert(radiusOfObject, SIUnit.Meters);
radiusOfObjectInMeters = radiusOfObjectInMeters * radiusOfObjectInMeters;
//Divide the numerator by the radius squared
intensity = intensity / radiusOfObjectInMeters;
intensity.MeasurementUnits = SIUnit.MetersCubed_PerSecondsSquared_PerKilograms;
//I = (G*M)/(r^2)
return(intensity);
}
// Use this for initialization
void Start()
{
this.Mass = null;
this.Radius = null;
this.IntenstityAtSurface = null;
}
