public void InitializeOrbits(int count)
{
Orbits.Clear();
for (int i = 0; i < count; i++)
{
Orbits.Add(new Orbit(2f * (Random.value > 0.5f ? 1f : -1f), 5 * (i + 1)));
}
}
protected void IntialiseOrbits()
{
for (int i = 0; i < Constants.MAX_ORBITS; i++)
{
var orbit = new Orbit();
Orbits.Add(orbit);
}
}
/// <summary>
/// Gets the Body's realative position based on it's orbit and current time.
/// Returns (0,0,0) if the body is not orbiting another body.
/// </summary>
/// <param name="days"></param>
public Vector3d GetPosition(double days)
{
if (Orbits == null)
{
return(new Vector3d());
}
return(Orbits.getPosition(days));
}
//Asing position to electrons, equidistant, set layer, return position
Vector3 segment_switch(int i, Orbits o)
{
Vector3 origin = gameObject.transform.position;
float r_scale = 0.5f;
Vector3 first = Vector3.right / r_scale;
Vector3 director = Vector3.right;
Orbits orbit = electron_holder[i].GetComponent <Orbits>();
/************************* LEVEL K ***************************/
switch (i)
{
case 0:
orbit.layer = 1;
return((first) + (origin));
break;
case 1:
orbit.layer = 1;
return(-(first) + (origin));
break;
default:
break;
}
/************************* LEVEL L ***************************/
if (i > 1 && i < 10)
{
int level_l = electron_num - 2;
if (level_l >= 8)
{
level_l = 8;
}
float arc = 360 / level_l;
i = i - 1;
if (arc * i == 360)
{
arc = 0;
}
var rot = Quaternion.AngleAxis(arc * i, Vector3.up);
director = rot * first * 2 + origin;
orbit.layer = 2;
/************************* LEVEL M ***************************/
}
else
{
int level_m = electron_num - 10;
float arc = 360 / level_m;
i = i - 9;
var rot = Quaternion.AngleAxis(arc * i, Vector3.up);
director = rot * first * 3 + origin;
orbit.layer = 3;
}
return(director);
}
/// <summary>
/// Start
/// </summary>
void Start()
{
Random.seed = GetInstanceID();
timer = new Timer(minDriftTime, maxDriftTime);
orbits = GameObject.Find("Main Camera").GetComponent <Orbits>();
origin = transform.position;
trace = GetComponent <ParticleSystem>();
Drift();
}
public void BuildSystem(double ComLumAddFromPrim)
{
HZone = -2;
var buildOrbit = !(Orbits.Count > 0);
for (int i = 0; i < Constants.MAX_ORBITS; i++)
{
var orbit = new Orbit();
if (!buildOrbit)
{
orbit = Orbits[i];
}
orbit.OrbitRange(i);
orbit.SetOrbitType(Luminosity, ComLumAddFromPrim);
if (orbit.OrbitalType == Orbit.OrbitType.HABITABLE)
{
HZone = i;
}
else if (orbit.OrbitalType == Orbit.OrbitType.OUTER && HZone == -2)
{
HZone = i - 1;
}
if (buildOrbit)
{
Orbits.Add(orbit);
}
}
if (HZone == -2)
{
HZone = 10;
}
PlaceEmptyOrbits();
PlaceCapturedPlanets();
PlaceGasGiants();
PlacePlanetoidBelts();
foreach (var orbit in Orbits)
{
if (orbit.Number > NumOrbits)
{
if (orbit.Occupied != Orbit.OccupiedBy.CAPTURED)
{
orbit.OrbitalType = Orbit.OrbitType.UNAVAILABLE;
}
}
}
}
private static int ChooseOrbitCount(Random random, StellarClass stellarClass)
{
Orbits orbits = WeightedChoices.Choose <Orbits>(random, StarHelper.OrbitCountWeights);
int num1 = Math.Max(0, (int)orbits);
int val2 = num1;
if ((Orbits)val2 != orbits)
{
throw new NotImplementedException(string.Format("Orbits.{0} not handled for Stars", (object)orbits));
}
switch (stellarClass.Size)
{
case StellarSize.Ia:
case StellarSize.Ib:
case StellarSize.II:
StarSystem.Trace("Special Rule: If Star Size I or II THEN # of orbits = # of orbits + 4");
val2 += 4;
break;
case StellarSize.III:
StarSystem.Trace("Special Rule: If Star Size III THEN # of orbits = # of orbits + 2");
val2 += 2;
break;
}
switch (stellarClass.Type)
{
case StellarType.K:
StarSystem.Trace("Special Rule: If Star Type K THEN # of orbits = # of orbits - 1");
--val2;
break;
case StellarType.M:
StarSystem.Trace("Special Rule: If Star Type M THEN # of orbits = # of orbits - 2");
val2 -= 2;
break;
}
int num2 = Math.Max(0, val2);
StarSystem.Trace("Final orbit count: {0}\n", (object)num2);
if (num2 == 0 && num1 > 0)
{
return(1);
}
return(num2);
}
private SolarSystemData()
{
this.SolarSystemObjects = new SolarSystemObjects();
this.SolarSystemObjects.Add(new Mercury());
this.SolarSystemObjects.Add(new Venus());
this.SolarSystemObjects.Add(new Earth());
this.SolarSystemObjects.Add(new Mars());
this.SolarSystemObjects.Add(new Jupiter());
this.SolarSystemObjects.Add(new Saturn());
this.SolarSystemObjects.Add(new Uranus());
this.SolarSystemObjects.Add(new Neptune());
this.SolarSystemObjects.Add(new Pluto());
this.SolarSystemObjects.Add(new Sun());
this.SolarSystemObjects.Add(new Moon());
this.SolarSystemObjects.Add(new EarthShadow());
this.location = LocationST.GetInstance();
this.Orbits = new Orbits(orbitNames);
this.copyOrb = new Orbits(orbitNames);
}
public void Stage6()
{
// introduce shooting - pick up a ball, force the dash, shoot the target - no orbits this time
if (Orbits == Standard)
{
foreach (Orbit orbit in Orbits)
{
orbit.Remove();
}
}
Orbits = Empty;
Orbits.Add(new Orbit(.8f, .38f, .05f));
text = "And finally:\nShoot to kill\nyour opponents";
point = new PointF(W / 2, W / 4);
Head player = HEADS[key_player];
player.act = Activities.DEFAULT;
player.pos = new IPoint(W * .7d, W * .19d);
player.v = speed * IVector.Left;
bot.act = Activities.DEFAULT;
bot.pos = new IPoint(W * 1 / 4, W / 4);
bot.v = IVector.Up;
bot.INVINCIBLE = true;
lock (Orb.OrbLock) for (int i = 1; i < 12; i++)
{
new Orb(true).pos = new IPoint(W * 1 / 4, W / 2 * i / 13);
}
bot1.INACTIVE = false;
bot1.color = Color.Green;
bot1.DisplayKey = "×";
bot1.pos = new IPoint(.8d * W, .215d * W);
bot1.act = Activities.ORBITING;
bot1.orbitCenter = new IPoint(W * .8f, W * .19f);
new Orb(true).pos = new IPoint(W * .1f, W * .19f);
}
// Let's get funky with the particles
void spawner()
{
//Electrons
for (int i = 0; i < electron_holder.Count; i++)
{
electron_holder[i].SetActive(true);
Orbits orbit = electron_holder[i].GetComponent <Orbits>();
orbit.nucleo = gameObject;
electron_holder[i].transform.parent = gameObject.transform;
electron_holder[i].transform.position = segment_switch(i, orbit);
}
//Nucleus
for (int i = 0; i < neutron_num; i++)
{
nuclear_init(i);
}
if (neutron_num == 0 && proton_num != 0)
{
nuclear_init(0);
}
}
public static IEnumerable <Kerberos.Sots.Data.StarMapFramework.Orbit> ChooseOrbitContents(
Random random)
{
Orbits orbits = WeightedChoices.Choose <Orbits>(random.NextDouble(), GasGiantHelper.OrbitCountWeights);
int count = StarSystemHelper.GetOrbitCount(orbits);
if (count >= 0)
{
for (int orbitNumber = 1; orbitNumber <= count; ++orbitNumber)
{
OrbitContents chosenContents = WeightedChoices.Choose <OrbitContents>(random.NextDouble(), GasGiantHelper.OrbitContentWeights);
Kerberos.Sots.Data.StarMapFramework.Orbit orbiter = StarSystemHelper.CreateOrbiterParams(chosenContents);
orbiter.OrbitNumber = orbitNumber;
yield return(orbiter);
}
}
else if (orbits == Orbits.Ring)
{
int ringOrbitNumber = 1;
Kerberos.Sots.Data.StarMapFramework.Orbit orbiter = StarSystemHelper.CreateOrbiterParams(OrbitContents.PlanetaryRing);
orbiter.OrbitNumber = ringOrbitNumber;
yield return(orbiter);
}
}
/// <summary>
/// Start
/// </summary>
void Start()
{
Random.seed = GetInstanceID();
timer = new Timer(minDriftTime, maxDriftTime);
orbits = GameObject.Find("Main Camera").GetComponent<Orbits>();
origin = transform.position;
trace = GetComponent<ParticleSystem>();
Drift();
}
public static int GetOrbitCount(Orbits orbits)
{
return(Math.Max(0, (int)orbits));
}
