Asteroids & Refactoring

We have proper belts that hug the Grid, reactive properties for planet instance data, and more!
This commit is contained in:
Reinier Vens 2020-12-01 00:16:11 +00:00
commit 1f90d3639a
42 changed files with 614 additions and 597 deletions

View file

@ -4,6 +4,7 @@ using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using MessagePack;
using UniRx;
using Unity.Mathematics;
using static Unity.Mathematics.math;
using Random = Unity.Mathematics.Random;
@ -11,13 +12,42 @@ using Random = Unity.Mathematics.Random;
public class ZoneGenerator
{
public static ZonePack GenerateZone(
GameContext context,
ZoneGenerationSettings settings,
Dictionary<string,GalaxyMapLayerData> mapLayers,
IEnumerable<SimpleCommodityData> resources,
string name,
float2 position)
{
var random = new Random(Convert.ToUInt32(abs(name.GetHashCode())));
var radius = settings.ZoneRadius.Evaluate(random.NextFloat() * mapLayers["Radius"].Evaluate(position, settings.ShapeSettings));
var mass = settings.ZoneMass.Evaluate(random.NextFloat() * mapLayers["Mass"].Evaluate(position, settings.ShapeSettings));
return GenerateZone(settings, mapLayers, resources, name, position, mass, radius, random);
}
public static ZonePack GenerateZone(
ZoneGenerationSettings settings,
Dictionary<string,GalaxyMapLayerData> mapLayers,
IEnumerable<SimpleCommodityData> resources,
float mass,
float radius)
{
var name = Guid.NewGuid().ToString().Substring(0, 8);
var position = float2(0f);
var random = new Random(Convert.ToUInt32(abs(name.GetHashCode())));
return GenerateZone(settings, mapLayers, resources, name, position, mass, radius, random);
}
private static ZonePack GenerateZone(
ZoneGenerationSettings settings,
Dictionary<string,GalaxyMapLayerData> mapLayers,
IEnumerable<SimpleCommodityData> resources,
string name,
float2 position,
IEnumerable<GalaxyMapLayerData> mapLayers,
IEnumerable<SimpleCommodityData> resources,
float mass = 0,
float radius = 0)
float mass,
float radius,
Random random)
{
var zone = new ZoneData
{
@ -30,33 +60,12 @@ public class ZoneGenerator
Data = zone
};
var zoneRadius = radius != 0 ? radius : context.Random.NextPowerDistribution(
context.GlobalData.MinimumZoneRadius,
context.GlobalData.MaximumZoneRadius,
context.GlobalData.ZoneRadiusExponent,
1 / lerp(
context.GlobalData.ResourceDensityMinimum,
context.GlobalData.ResourceDensityMaximum,
mapLayers
.First(m => m.Name == "Radius")
.Evaluate(zone.Position, context.GlobalData)));
zone.Radius = zoneRadius;
var zoneMass = mass != 0 ? mass : context.Random.NextPowerDistribution(
context.GlobalData.MinimumZoneMass,
context.GlobalData.MaximumZoneMass,
context.GlobalData.ZoneMassExponent,
1 / lerp(
context.GlobalData.ResourceDensityMinimum,
context.GlobalData.ResourceDensityMaximum,
mapLayers
.First(m => m.Name == "Mass")
.Evaluate(zone.Position, context.GlobalData)));
zone.Mass = zoneMass;
zone.Radius = radius;
zone.Mass = mass;
//Debug.Log($"Generating zone at position {zone.Position} with radius {zoneRadius} and mass {zoneMass}");
var planets = GenerateEntities(context, zone, zoneMass, zoneRadius);
var planets = GenerateEntities(settings, ref random, zone);
// Create collections to map between zone generator output and database entries
var orbitMap = new Dictionary<GeneratorPlanet, OrbitData>();
@ -67,8 +76,8 @@ public class ZoneGenerator
{
var data = new OrbitData
{
Distance = planet.Distance,
Period = planet.Period,
Distance = new ReactiveProperty<float>(planet.Distance),
//Period = planet.Period,
Phase = planet.Phase
};
orbitMap[planet] = data;
@ -83,21 +92,22 @@ public class ZoneGenerator
: Guid.Empty;
// Cache resource densities
var resourceMaps = mapLayers.ToDictionary(m => m.ID, m => m.Evaluate(zone.Position, context.GlobalData));
var resourceMaps = mapLayers.Values
.ToDictionary(m => m.ID, m => m.Evaluate(zone.Position, settings.ShapeSettings));
pack.Planets = planets.Where(p=>!p.Empty).Select(planet =>
{
Dictionary<Guid, float> planetResources = new Dictionary<Guid, float>();
BodyType bodyType = planet.Belt ? BodyType.Asteroid :
planet.Mass > context.GlobalData.SunMass ? BodyType.Sun :
planet.Mass > context.GlobalData.GasGiantMass ? BodyType.GasGiant :
planet.Mass > context.GlobalData.PlanetMass ? BodyType.Planet : BodyType.Planetoid;
planet.Mass > settings.SunMass ? BodyType.Sun :
planet.Mass > settings.GasGiantMass ? BodyType.GasGiant :
planet.Mass > settings.PlanetMass ? BodyType.Planet : BodyType.Planetoid;
foreach (var r in resources)
{
if ((bodyType & r.ResourceBodyType) != 0)
{
float quantity = ResourceValue(r, context, r.ResourceDensity.Aggregate(1f, (m, rdm) => m * resourceMaps[rdm]));
float quantity = ResourceValue(ref random, settings, r, r.ResourceDensity.Aggregate(1f, (m, rdm) => m * resourceMaps[rdm]));
if (r.Floor < quantity) planetResources.Add(r.ID, quantity);
}
}
@ -129,21 +139,21 @@ public class ZoneGenerator
if (planetData is AsteroidBeltData beltData)
{
beltData.Asteroids =
Enumerable.Range(0, (int) (pow(planetData.Mass.Value, context.GlobalData.BeltMassExponent) / context.GlobalData.BeltMassRatio * orbitMap[planet].Distance))
Enumerable.Range(0, (int) (settings.AsteroidCount.Evaluate(beltData.Mass.Value * orbitMap[planet].Distance.Value)))
.Select(_ => new Asteroid
{
Distance = context.Random.NextFloat(orbitMap[planet].Distance * .5f, orbitMap[planet].Distance * 1.5f),
Phase = context.Random.NextFloat(),
Size = pow(context.Random.NextFloat(), context.GlobalData.AsteroidSizeExponent) *
(context.GlobalData.AsteroidSizeMax - context.GlobalData.AsteroidSizeMin) +
context.GlobalData.AsteroidSizeMin,
RotationSpeed = context.Random.NextFloat() * context.GlobalData.AsteroidRotationSpeed
}).ToArray();
Distance = random.NextFloat(orbitMap[planet].Distance.Value * .5f, orbitMap[planet].Distance.Value * 1.5f),
Phase = random.NextFloat(),
Size = random.NextFloat(),
RotationSpeed = settings.AsteroidRotationSpeed.Evaluate(random.NextFloat())
})
//.OrderByDescending(a=>a.Size)
.ToArray();
}
else if (planetData is GasGiantData gas)
{
var times = Enumerable.Range(0, 5).Select(i => (float) i / 4).ToArray();
gas.Colors.Value = times.Select(time => float4(context.Random.NextFloat3(),time)).ToArray();
gas.Colors.Value = times.Select(time => float4(random.NextFloat3(),time)).ToArray();
gas.AlbedoRotationSpeed.Value = -3;
gas.FirstOffsetRotationSpeed.Value = 5;
gas.FirstOffsetDomainRotationSpeed.Value = 0;
@ -151,7 +161,7 @@ public class ZoneGenerator
gas.SecondOffsetDomainRotationSpeed.Value = -25;
if (planetData is SunData sun)
{
sun.FogTintColor.Value = sun.LightColor.Value = context.Random.NextFloat3();
sun.FogTintColor.Value = sun.LightColor.Value = random.NextFloat3();
gas.FirstOffsetDomainRotationSpeed.Value = 5;
}
}
@ -161,36 +171,34 @@ public class ZoneGenerator
return pack;
}
static float ResourceValue(SimpleCommodityData resource, GameContext context, float density)
static float ResourceValue(ref Random random, ZoneGenerationSettings settings, SimpleCommodityData resource, float density)
{
return context.Random.NextPowerDistribution(resource.Minimum, resource.Maximum, resource.Exponent,
1 / lerp(context.GlobalData.ResourceDensityMinimum, context.GlobalData.ResourceDensityMaximum, density));
return random.NextPowerDistribution(resource.Minimum, resource.Maximum, resource.Exponent,
1 / lerp(settings.ResourceDensityMinimum, settings.ResourceDensityMaximum, density));
}
public static GeneratorPlanet[] GenerateEntities(GameContext context, ZoneData data, float mass, float radius)
public static GeneratorPlanet[] GenerateEntities(ZoneGenerationSettings settings, ref Random random, ZoneData zone)
{
var random = new Random();
random.InitState(unchecked((uint)data.Name.GetHashCode()));
var root = new GeneratorPlanet
{
Context = context,
Mass = mass,
ChildDistanceMaximum = radius * .75f,
ChildDistanceMinimum = context.GlobalData.PlanetRadius(mass)
Settings = settings,
Mass = zone.Mass,
ChildDistanceMaximum = zone.Radius * .75f,
ChildDistanceMinimum = settings.PlanetSafetyRadius.Evaluate(zone.Mass)
};
// There is some chance of generating a rosette or binary system
// Probabilities which are fixed for the entire galaxy are in GlobalData, contained in the GameContext
var rosette = random.NextFloat() < context.GlobalData.RosetteProbability;
var rosette = random.NextFloat() < settings.RosetteProbability;
if (rosette)
{
// Create a rosette with a number of vertices between 2 and 9 inclusive
root.ExpandRosette((int)(random.NextFloat(1, 5) + random.NextFloat(1, 5)));
root.ExpandRosette(ref random, (int)(random.NextFloat(1, 5) + random.NextFloat(1, 5)));
// Create a small number of less massive "captured" planets orbiting past the rosette
root.ExpandSolar(
ref random,
count: (int)(random.NextFloat(1, 3) * random.NextFloat(1, 2)),
massMulMin: .6f,
massMulMax: .8f,
@ -200,11 +208,12 @@ public class ZoneGenerator
massFraction: .1f);
var averageChildMass = root.Children.Sum(p => p.Mass) / root.Children.Count;
foreach(var p in root.Children.Where(c=>c.Mass>context.GlobalData.GasGiantMass))
foreach(var p in root.Children.Where(c=>c.Mass>settings.GasGiantMass))
{
var m = p.Mass / averageChildMass;
// Give each child in the rosette its own mini solar system
p.ExpandSolar(
ref random,
count: (int) (random.NextFloat(1, 3 * m) + random.NextFloat(1, 3 * m)),
massMulMin: 0.75f,
massMulMax: 2.5f,
@ -219,6 +228,7 @@ public class ZoneGenerator
{
// Create a regular old boring solar system
root.ExpandSolar(
ref random,
count: random.NextInt(5, 15),
massMulMin: 0.5f,
massMulMax: 2.0f,
@ -229,43 +239,65 @@ public class ZoneGenerator
);
}
// Get all children that are above the satellite creation mass floor and not rosette members
var satelliteCandidates = rosette
? root.AllPlanets().Where(p => p != root && p.Parent != root && p.Mass > context.GlobalData.SatelliteCreationMassFloor)
: root.AllPlanets().Where(p => p != root && p.Mass > context.GlobalData.SatelliteCreationMassFloor);
var alreadyExpanded = new List<GeneratorPlanet>();
var binaries = new List<GeneratorPlanet>();
foreach (var planet in satelliteCandidates)
for(int i=0; i<settings.SatellitePasses; i++)
{
// There's a chance of generating satellites for each qualified planet
if (random.NextFloat() < context.GlobalData.SatelliteCreationProbability)
// Get all children that are above the satellite creation mass floor and not rosette members
var satelliteCandidates = rosette
? root.AllPlanets().Where(p =>
p != root &&
p.Parent != root &&
p.Mass > settings.SatelliteCreationMassFloor &&
!alreadyExpanded.Contains(p))
: root.AllPlanets().Where(p =>
p != root &&
p.Mass > settings.SatelliteCreationMassFloor &&
!alreadyExpanded.Contains(p));
foreach (var planet in satelliteCandidates)
{
// Sometimes the satellite is so massive that it forms a binary system (like Earth!)
if (random.NextFloat() < context.GlobalData.BinaryCreationProbability)
// There's a chance of generating satellites for each qualified planet
if (random.NextFloat() < settings.SatelliteCreationProbability)
{
planet.ExpandRosette(2);
binaries.AddRange(planet.Children);
// Sometimes the satellite is so massive that it forms a binary system (like Earth!)
if (random.NextFloat() < settings.BinaryCreationProbability)
{
planet.ExpandRosette(ref random, 2);
binaries.AddRange(planet.Children);
}
// Otherwise, terrestrial planets get a couple satellites while gas giants get many
else
{
planet.ExpandSolar(
ref random,
count: planet.Mass < settings.GasGiantMass ? random.NextInt(1, 3) : random.NextInt(2, 6),
massMulMin: .75f,
massMulMax: 1.5f,
distMulMin: 1.05f,
distMulMax: 1.25f,
jupiterJump: 1,
massFraction: .15f); // Planetary satellites are not nearly as massive as planets themselves
}
alreadyExpanded.Add(planet);
}
// Otherwise, terrestrial planets get a couple satellites while gas giants get many
else planet.ExpandSolar(
count: planet.Mass < context.GlobalData.GasGiantMass ? random.NextInt(1,3) : random.NextInt(4,10),
massMulMin: .75f,
massMulMax: 1.5f,
distMulMin: 1.05f,
distMulMax: 1.25f,
jupiterJump: 1,
massFraction: .15f); // Planetary satellites are not nearly as massive as planets themselves
}
}
// Get all children that are below the belt creation mass floor and not rosette members, also exclude binaries
var beltCandidates = rosette
? root.AllPlanets().Where(p => p != root && p.Parent != root && p.Mass < context.GlobalData.BeltMassCeiling && !binaries.Contains(p))
: root.AllPlanets().Where(p => p != root && p.Mass < context.GlobalData.BeltMassCeiling && !binaries.Contains(p));
? root.AllPlanets().Where(p => p != root && p.Parent != root && p.Mass < settings.BeltMassCeiling && !binaries.Contains(p))
: root.AllPlanets().Where(p => p != root && p.Mass < settings.BeltMassCeiling && !binaries.Contains(p));
foreach(var planet in beltCandidates.Reverse())
if (random.NextFloat() < context.GlobalData.BeltProbability && !planet.Parent.Children.Any(p=>p.Belt))
if (random.NextFloat() < settings.BeltProbability && !planet.Parent.Children.Any(p=>p.Belt))
planet.Belt = true;
var totalMass = root.AllPlanets().Sum(p => p.Mass);
var rootMass = root.Mass;
foreach (var planet in root.AllPlanets())
planet.Mass = (planet.Mass / totalMass) * rootMass;
return root.AllPlanets().ToArray();
}
}
@ -275,11 +307,11 @@ public class ZoneGenerator
// Because they were objects we observed to move in the sky instead of remaining fixed like the stars
public class GeneratorPlanet
{
public GameContext Context;
public ZoneGenerationSettings Settings;
public float Distance;
public float Phase;
public float Mass;
public float Period;
//public float Period;
public float ChildDistanceMinimum;
public float ChildDistanceMaximum;
public bool Empty = false;
@ -295,7 +327,7 @@ public class GeneratorPlanet
// Create children that fill a single orbit, equally spaced
// https://en.wikipedia.org/wiki/Klemperer_rosette
public void ExpandRosette(int vertices)
public void ExpandRosette(ref Random random, int vertices)
{
//Debug.Log("Expanding Rosette");
@ -306,7 +338,7 @@ public class GeneratorPlanet
var sharedMass = Mass / vertices * 2;
// Proportion of the masses of sequential pairs is random, but only for even vertex counts
var proportion = vertices % 2 == 0 ? Context.Random.NextFloat(.5f,.95f) : .5f;
var proportion = vertices % 2 == 0 ? random.NextFloat(.5f,.95f) : .5f;
// Place children at a fixed distance in the center of the range
var dist = (ChildDistanceMinimum + ChildDistanceMaximum) / 2;
@ -318,22 +350,22 @@ public class GeneratorPlanet
var p1 = OrbitData.Evaluate(1.0f / vertices) * dist;
// Maximum child distance is half the distance to the neighbor minus the neighbor's radius
var p0ChildDist = (distance(p0, p1) * proportion - Context.GlobalData.PlanetRadius(sharedMass * (1 - proportion))) * .75f;
var p1ChildDist = (distance(p0, p1) * (1 - proportion) - Context.GlobalData.PlanetRadius(sharedMass * proportion)) * .75f;
var p0ChildDist = (distance(p0, p1) * proportion - Settings.PlanetSafetyRadius.Evaluate(sharedMass * (1 - proportion))) * .75f;
var p1ChildDist = (distance(p0, p1) * (1 - proportion) - Settings.PlanetSafetyRadius.Evaluate(sharedMass * proportion)) * .75f;
for (int i = 0; i < vertices; i++)
{
var child = new GeneratorPlanet
{
Context = Context,
Settings = Settings,
Parent = this,
Mass = sharedMass * (i % 2 == 0 ? proportion : 1 - proportion), // Masses alternate
Distance = dist,
Phase = (float) i / vertices,
ChildDistanceMaximum = (i % 2 == 0 ? p0ChildDist : p1ChildDist)
};
child.ChildDistanceMinimum = Context.GlobalData.PlanetRadius(child.Mass) * 2;
child.Period = Context.GlobalData.OrbitalPeriod(child.Distance);
child.ChildDistanceMinimum = Settings.PlanetSafetyRadius.Evaluate(child.Mass) * 2;
//child.Period = Settings..Evaluate(child.Distance);
Children.Add(child);
}
@ -341,7 +373,7 @@ public class GeneratorPlanet
}
// Create children that mimic the distribution of planetary masses in the solar system
public void ExpandSolar(int count, float massMulMin, float massMulMax, float distMulMin, float distMulMax, float jupiterJump, float massFraction)
public void ExpandSolar(ref Random random, int count, float massMulMin, float massMulMax, float distMulMin, float distMulMax, float jupiterJump, float massFraction)
{
//Debug.Log("Expanding Solar");
// Expansion is impossible when child space is full
@ -360,13 +392,13 @@ public class GeneratorPlanet
// jupiterJump is an additional mass multiplier applied after half of the planets
for (var i = 1; i < count; i++)
{
massTotal += masses[i] = masses[i - 1] * Context.Random.NextFloat(massMulMin, massMulMax) * (count/2==i ? jupiterJump : 1);
distances[i] = distances[i - 1] * Context.Random.NextFloat(distMulMin, distMulMax);
massTotal += masses[i] = masses[i - 1] * random.NextFloat(massMulMin, massMulMax) * (count/2==i ? jupiterJump : 1);
distances[i] = distances[i - 1] * random.NextFloat(distMulMin, distMulMax);
}
// Add some randomness to child masses
for (var i = 0; i < masses.Length; i++)
masses[i] *= Context.Random.NextFloat(.1f, 1f);
masses[i] *= random.NextFloat(.1f, 1f);
// Normalize the masses of the children
for (var i = 0; i < count; i++)
@ -378,24 +410,24 @@ public class GeneratorPlanet
var oldDistances = (float[]) distances.Clone();
for (var i = 0; i < count; i++)
distances[i] = lerp(ChildDistanceMinimum, ChildDistanceMaximum,
(oldDistances[i] - oldDistances[0]) / (oldDistances[count - 1] - oldDistances[0])) + Context.GlobalData.PlanetRadius(masses[i]);
(oldDistances[i] - oldDistances[0]) / (oldDistances[count - 1] - oldDistances[0])) + Settings.PlanetSafetyRadius.Evaluate(masses[i]);
}
for (var i = 0; i < count; i++)
{
// Only instantiate children above the mass floor
if (masses[i] > Context.GlobalData.MassFloor)
if (masses[i] > Settings.MassFloor)
{
var child = new GeneratorPlanet
{
Context = Context,
Settings = Settings,
Parent = this,
Mass = masses[i],
Distance = distances[i],
Phase = Context.Random.NextFloat()
Phase = random.NextFloat()
};
child.Period = Context.GlobalData.OrbitalPeriod(child.Distance);
child.ChildDistanceMinimum = Context.GlobalData.PlanetRadius(child.Mass) * 2;
//child.Period = Context.GlobalData.OrbitalPeriod(child.Distance);
child.ChildDistanceMinimum = Settings.PlanetSafetyRadius.Evaluate(child.Mass) * 2;
// Maximum child distance of child is the smallest distance to either of its neighbors
child.ChildDistanceMaximum = min(i == 0 ? child.Distance - ChildDistanceMinimum : child.Distance - distances[i - 1],
i < count - 1 ? distances[i + 1] - child.Distance : float.PositiveInfinity);