//Called from GenerateResources. Generates a random assortment of moons to orbit this planet
private void GenerateMoons()
{
//Initialize the new list of moons so that it's empty
this.moons = new List <GameObject>();
//Created a scalar that uses the massMoonCoorilation curve to skew the random value
Interpolator scalar = new Interpolator(this.massMoonCoorilation);
scalar.AddTime(Random.value);
//Uses the scalar, min number of moons, and max number of moons to find out how many this planet will have
int numMoons = Mathf.RoundToInt(scalar.GetProgress() * (this.moonNumberRanges.y - this.moonNumberRanges.x) - this.moonNumberRanges.x);
//Loop to generate each moon
for (int i = 0; i < numMoons; ++i)
{
//Created a new game object to store the instance of the created moon
GameObject newMoon = null;
//Finds the orbit distance of the new moon
float radius = this.GetMoonRadius();
//If the radius is invalid, we stop generating moons
if (radius <= 0)
{
break;
}
//Random value from 0 to 1
float rand = Random.value;
//Loop through each moon prefab probability to check against the random value
for (int m = 0; m < this.moonProbabilities.Count; ++m)
{
//If the current moon probability is higher than our rand, that prefab is created
if (this.moonProbabilities[m] >= rand)
{
newMoon = GameObject.Instantiate(this.moonTypes[m], this.transform.localPosition, this.transform.rotation) as GameObject;
break;
}
//If this is the last moon probability in the list, it's spawned by default
else if ((m + 1) >= this.moonProbabilities.Count)
{
newMoon = GameObject.Instantiate(this.moonTypes[m], this.transform.localPosition, this.transform.rotation) as GameObject;
}
}
//creates a random orbit time
//NOTE: The values used are for testing
float orbitTime = Random.Range(45, 300);
//Adds the moon to this planet's list and parents it at the local center
this.moons.Add(newMoon);
newMoon.transform.parent = this.displayObject.transform;
newMoon.transform.localPosition = new Vector3(0, 0, 0);
//Generates the moon's stats
newMoon.GetComponent <Moon>().GenerateStats(new Vector3(radius, 0, radius), orbitTime, this.spinClockwise);
}
}
//Function to be called as soon as this object is spawned
public virtual void GenerateStats(bool spinClockwise_ = true)
{
//Sets the direction of the revolution
this.spinClockwise = spinClockwise_;
//Temp float used to determine the revolution speed
float spinValue = 1;
if (!this.spinClockwise)
{
spinValue = -1;
}
//Makes this planet rotate with its spin
this.revolutionSpeed = Random.Range(this.revSpeedRange.x, this.revSpeedRange.y) * spinValue;
//Creating an interpolator and random value that is used as the baseline for our mass and radius
float rand = Random.value;
Interpolator scalar = new Interpolator(this.massDistribution);
scalar.AddTime(rand);
//Sets the Mass based on the scalar's distribution
this.mass = Mathf.Round((scalar.GetProgress() * (this.massRange.y - this.massRange.x) + this.massRange.x) * 100) / 100;
//Sets the mass based on the same random value as the mass
scalar.ease = this.massRadiusCoorilation;
this.radius = Mathf.Round((scalar.GetProgress() * (this.radiusRange.y - this.radiusRange.x) + this.radiusRange.x) * 100) / 100;
//Creates a new random value for the scalar to determine the spin
rand = Random.value;
scalar.ResetTime();
scalar.AddTime(rand);
this.revolutionSpeed = scalar.GetProgress() * (this.revSpeedRange.y - this.revSpeedRange.x) + this.revSpeedRange.x;
}
//Function called from GeneratePlanets. Returns a radius (float) to spawn a new planet at. Returns 0 if a valid radius isn't found.
private float GetPlanetRadius()
{
//The radius that is returned by the end of the function
float returnRadius = 0;
//Create a sine-in scalar that will weight more of the planets to spawn closer to the star
Interpolator scalar = new Interpolator(EaseType.SineIn);
//Counter to track the number of times we've attempted to generate a valid radius
int endlessCount = 0;
for (int i = 0; i < 1; ++i)
{
//Gives the scalar a random value between 0 and 1 to give us a percentage that's weighted closer to 0 (closer to the star)
scalar.ResetTime();
scalar.AddTime(Random.value);
//Calculates the radius of the planet using the min/max radii (hot and cold) and the scalar's weighted percentage
returnRadius = scalar.GetProgress() * (this.iceZoneRadius - this.hotZoneRadius) + this.hotZoneRadius;
//Loops through each planet to see if its orbit is within collision distance
for (int p = 0; p < this.planets.Count; ++p)
{
float check1 = Mathf.Abs(this.planets[p].GetComponent <Planet>().orbitDimensions.x - returnRadius);
//If we find a planet within collision distance of the new radius, the loop is reset to try again
if (check1 <= this.collisionDistance)
{
i = -1;
endlessCount += 1;
//If there have been 20 failed attempts to generate a new radius, the loop is broken and 0 is returned
if (endlessCount > 20)
{
i = 1;
return(0);
}
break;
}
}
}
return(returnRadius);
}
//Function called externally from InventoryButton.cs to make a character learn this skill
public void CharacterUseTome(Character charToLearn_)
{
//Int to hold the character's skill level that we'll improve
int currentSkillLevel = this.GetCurrentSkillLevel(charToLearn_);
//Int to hold what the new skill level will be
int improvedSkillLevel = currentSkillLevel;
//Looping through each progression curve
for (int c = 0; c < this.progressionCurves.Count; ++c)
{
SkillTomeProgression curve = this.progressionCurves[c];
//Checking to see if the player's current skill level is between the ranges for the curve
if (currentSkillLevel >= curve.skillRangeMin && currentSkillLevel <= curve.skillRangeMax)
{
//Switch statement to allocate points based on the curve type
switch (curve.progressionCurve)
{
case SkillTomeProgression.progressionCurves.Linear:
//Getting the percent that the player is between the curve range min/max
float percentL = (1f * (currentSkillLevel - curve.skillRangeMin)) /
(1f * (curve.skillRangeMax - curve.skillRangeMin));
//Finding the new value between the new skill min/max
float newSkillF = (curve.newSkillMax - curve.newSkillMin) * percentL;
improvedSkillLevel = curve.newSkillMin + Mathf.RoundToInt(newSkillF);
break;
case SkillTomeProgression.progressionCurves.SineIn:
//Getting the percent that the player is between the curve range min/max
float percentSI = (1f * (currentSkillLevel - curve.skillRangeMin)) /
(1f * (curve.skillRangeMax - curve.skillRangeMin));
//Creating a new interpolator to get the sine in interp using the percent SI
Interpolator siInterp = new Interpolator();
siInterp.ease = EaseType.SineIn;
siInterp.SetDuration(1);
siInterp.AddTime(percentSI);
//Finding the new value between the new skill min/max using the interpolated percent
float newSkillSI = (curve.newSkillMax - curve.newSkillMin) * siInterp.GetProgress();
improvedSkillLevel = curve.newSkillMin + Mathf.RoundToInt(newSkillSI);
break;
case SkillTomeProgression.progressionCurves.SineOut:
//Getting the percent that the player is between the curve range min/max
float percentSO = (1f * (currentSkillLevel - curve.skillRangeMin)) /
(1f * (curve.skillRangeMax - curve.skillRangeMin));
//Creating a new interpolator to get the sine in interp using the percent SO
Interpolator soInterp = new Interpolator();
soInterp.ease = EaseType.SineOut;
soInterp.SetDuration(1);
soInterp.AddTime(percentSO);
//Finding the new value between the new skill min/max using the interpolated percent
float newSkillSO = (curve.newSkillMax - curve.newSkillMin) * soInterp.GetProgress();
improvedSkillLevel = curve.newSkillMin + Mathf.RoundToInt(newSkillSO);
break;
case SkillTomeProgression.progressionCurves.UpToMax:
//Setting the skill level to the max
improvedSkillLevel = curve.newSkillMax;
break;
}
//Breaking the loop so we don't have to bother with the other curves
break;
}
}
//Setting the new character skill value
this.SetImprovedSkillLevel(charToLearn_, improvedSkillLevel - currentSkillLevel);
}
/* Function called from SolarSystem.cs (GenerateStar function)
* Override of the SolarBody parent class' GenerateStats function since stars will have their own unique stats*/
public override void GenerateStats(bool spinClockwise_ = true)
{
//Calls the GenerateStats base function to set the spin direction
base.GenerateStats(spinClockwise_);
//Generating a random value between 0 and 1 to use in our scalar
float rand = Random.value;
//The new scalar uses the curve designated with TemperatureDistribution and has a time length of 1
Interpolator scaler = new Interpolator(this.temperatureDistribution, 1);
scaler.AddTime(rand);
//Finds the surface temperature based on the temperature distribution
this.surfaceTemp = Mathf.RoundToInt((scaler.GetProgress() * (this.tempRange.y - this.tempRange.x) + this.tempRange.x) / 100) * 100;
/*Finds the luminosity based off the area, the temperature to the 4th power, and the Stefan-Bolzmann constant
* NOTE: the radius used is a float variable inherited from the SolarBody parent class that's generated in base.GenerateStats */
float area = (4 * Mathf.PI * (this.radius * this.radius));
float SBConstant = 5.670367f * Mathf.Pow(10f, -8);
float tempQuad = Mathf.Pow(this.surfaceTemp, 4);
this.luminosity = area * SBConstant * tempQuad;
//Determines the display object's color based on the temperature distribution. Uses the Mesh Renderer if there's no Sprite Renderer component
if (this.displayObject.GetComponent <SpriteRenderer>() != null)
{
this.displayObject.GetComponent <SpriteRenderer>().color = this.starColors.Evaluate(scaler.GetProgress());
}
else if (this.displayObject.GetComponent <MeshRenderer>() != null)
{
this.displayObject.GetComponent <MeshRenderer>().materials[0].color = this.starColors.Evaluate(scaler.GetProgress());
}
//If this star is at or below the smallest radius, it's game object is set to the smallest scale in the StarScaleRange
if (this.radius <= this.starRadiusRange.x)
{
this.displayObject.transform.localScale = new Vector3(this.starScaleRange.x, this.starScaleRange.x, this.starScaleRange.x);
}
//If it's between the smallest and middle radius, finds the scale to set it at based on the coorilation
else if (this.radius > this.starRadiusRange.x && this.radius <= this.starRadiusRange.y)
{
Interpolator scalar = new Interpolator(this.lowMidCoorilation);
float percent = (this.radius - this.starRadiusRange.x) / (this.starRadiusRange.y - this.starRadiusRange.x);
scalar.AddTime(percent);
float newScale = scalar.GetProgress() * (this.starScaleRange.y - this.starScaleRange.x) + this.starScaleRange.x;
this.displayObject.transform.localScale = new Vector3(newScale, newScale, newScale);
}
//If it's between the middle radius and the max radius, we find the scale to set it at based on the coorilation
else if (this.radius > this.starRadiusRange.y && this.radius <= this.starRadiusRange.z)
{
Interpolator scalar = new Interpolator(this.midMaxCoorilation);
float percent = (this.radius - this.starRadiusRange.y) / (this.starRadiusRange.z - this.starRadiusRange.y);
scalar.AddTime(percent);
float newScale = scalar.GetProgress() * (this.starScaleRange.z - this.starScaleRange.y) + this.starScaleRange.y;
this.displayObject.transform.localScale = new Vector3(newScale, newScale, newScale);
}
//Otherwise the radius is at or above the max radius, so it's set to the largest scale in the StarScaleRange
else
{
this.displayObject.transform.localScale = new Vector3(this.starScaleRange.z, this.starScaleRange.z, this.starScaleRange.z);
}
}