af88788e4f
Refactored game loop to allow full local testing Added AI controller abstractions Added ability to save database to local copy for offline testing Tech Tab is now interactive, has properties panel
350 lines
No EOL
13 KiB
C#
350 lines
No EOL
13 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using MessagePack;
|
|
using Unity.Mathematics;
|
|
using static Unity.Mathematics.math;
|
|
using Random = Unity.Mathematics.Random;
|
|
|
|
public class ZoneGenerator
|
|
{
|
|
|
|
public static void GenerateZone(
|
|
GlobalData global,
|
|
ZoneData zone,
|
|
IEnumerable<GalaxyMapLayerData> mapLayers,
|
|
IEnumerable<SimpleCommodityData> resources,
|
|
out OrbitData[] orbitData,
|
|
out PlanetData[] planetsData)
|
|
{
|
|
var zoneRadius = lerp(global.MinimumZoneRadius,
|
|
global.MaximumZoneRadius,
|
|
mapLayers.First(m => m.Name == "Radius")
|
|
.Evaluate(zone.Position,
|
|
global));
|
|
zone.Radius = zoneRadius;
|
|
|
|
var zoneMass = lerp(global.MinimumZoneMass,
|
|
global.MaximumZoneMass,
|
|
mapLayers.First(m => m.Name == "Mass")
|
|
.Evaluate(zone.Position,
|
|
global));
|
|
|
|
//Debug.Log($"Generating zone at position {zone.Position} with radius {zoneRadius} and mass {zoneMass}");
|
|
|
|
var planets = GenerateEntities(global, zone, zoneMass, zoneRadius);
|
|
|
|
// Create collections to map between zone generator output and database entries
|
|
var orbitMap = new Dictionary<Planet, OrbitData>();
|
|
var orbitInverseMap = new Dictionary<OrbitData, Planet>();
|
|
|
|
// Create orbit database entries
|
|
orbitData = planets.Select(planet =>
|
|
{
|
|
var data = new OrbitData()
|
|
{
|
|
ID = Guid.NewGuid(),
|
|
Distance = planet.Distance,
|
|
Period = planet.Period,
|
|
Phase = planet.Phase,
|
|
Zone = zone.ID
|
|
};
|
|
orbitMap[planet] = data;
|
|
orbitInverseMap[data] = planet;
|
|
return data;
|
|
}).ToArray();
|
|
|
|
// Link OrbitData parents to database GUIDs
|
|
foreach (var data in orbitData)
|
|
data.Parent = orbitInverseMap[data].Parent != null
|
|
? orbitMap[orbitInverseMap[data].Parent].ID
|
|
: Guid.Empty;
|
|
|
|
// Cache resource densities
|
|
var resourceMaps = mapLayers.ToDictionary(m => m.ID, m => m.Evaluate(zone.Position, global));
|
|
|
|
var random = new Random((uint) (DateTime.Now.Ticks%uint.MaxValue));
|
|
|
|
planetsData = planets.Where(p=>!p.Empty).Select(planet =>
|
|
{
|
|
var planetData = new PlanetData
|
|
{
|
|
Mass = planet.Mass,
|
|
ID = Guid.NewGuid(),
|
|
Orbit = orbitMap[planet].ID,
|
|
Zone = zone.ID,
|
|
Belt = planet.Belt,
|
|
Resources = resources
|
|
// Filter resources where the body type matches the current planet
|
|
.Where(r =>
|
|
((planet.Belt ? BodyType.Asteroid :
|
|
planet.Mass > global.SunMass ? BodyType.Sun :
|
|
planet.Mass > global.GasGiantMass ? BodyType.GasGiant :
|
|
planet.Mass > global.PlanetMass ? BodyType.Planet : BodyType.Planetoid) & r.ResourceBodyType) != 0)
|
|
// NextUnbounded is our extension function containing resource placement formula
|
|
// Obtain bias variable by multiplying all resource maps together
|
|
.Select(r => new
|
|
{
|
|
resource = r,
|
|
quantity = random.NextUnbounded(
|
|
r.ResourceDensity.Aggregate(1f, (m, rdm) => m * resourceMaps[rdm]),
|
|
r.ResourceDensityBiasPower)
|
|
})
|
|
// Only include resources above a minimum quantity
|
|
.Where(r => r.resource.ResourceFloor < r.quantity)
|
|
.ToDictionary(r => r.resource.ID, r => r.quantity)
|
|
};
|
|
planetData.Name = planetData.ID.ToString().Substring(0, 8);
|
|
return planetData;
|
|
}).ToArray();
|
|
|
|
zone.Planets = planetsData.Select(pd => pd.ID).ToList();
|
|
zone.Orbits = orbitData.Select(od => od.ID).ToList();
|
|
}
|
|
|
|
public static Planet[] GenerateEntities(GlobalData global, ZoneData data, float mass, float radius)
|
|
{
|
|
var random = new Random();
|
|
random.InitState(unchecked((uint)data.Name.GetHashCode()));
|
|
|
|
var root = new Planet
|
|
{
|
|
Random = random,
|
|
Global = global,
|
|
Mass = mass,
|
|
ChildDistanceMaximum = radius * .75f,
|
|
ChildDistanceMinimum = global.PlanetRadius(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() < global.RosetteProbability;
|
|
|
|
if (rosette)
|
|
{
|
|
// Create a rosette with a number of vertices between 2 and 9 inclusive
|
|
root.ExpandRosette((int)(random.NextFloat(1, 3) * random.NextFloat(2, 3)));
|
|
|
|
// Create a small number of less massive "captured" planets orbiting past the rosette
|
|
root.ExpandSolar(
|
|
count: (int)(random.NextFloat(1, 3) * random.NextFloat(1, 2)),
|
|
massMulMin: .6f,
|
|
massMulMax: .8f,
|
|
distMulMin: 1.25f,
|
|
distMulMax: 1.75f,
|
|
jupiterJump: 1,
|
|
massFraction: .1f);
|
|
|
|
var averageChildMass = root.Children.Sum(p => p.Mass) / root.Children.Count;
|
|
foreach(var p in root.Children.Where(c=>c.Mass>global.GasGiantMass))
|
|
{
|
|
var m = p.Mass / averageChildMass;
|
|
// Give each child in the rosette its own mini solar system
|
|
p.ExpandSolar(
|
|
count: (int) (random.NextFloat() * random.NextFloat() * m * 5 + 1),
|
|
massMulMin: 0.75f,
|
|
massMulMax: 2.5f,
|
|
distMulMin: 1 + m * .25f,
|
|
distMulMax: 1.05f + m * .5f,
|
|
jupiterJump: random.NextFloat() * random.NextFloat() * 10 + 1,
|
|
massFraction: .5f
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Create a regular old boring solar system
|
|
root.ExpandSolar(
|
|
count: random.NextInt(5, 15),
|
|
massMulMin: 0.5f,
|
|
massMulMax: 2.0f,
|
|
distMulMin: 1.1f,
|
|
distMulMax: 1.25f,
|
|
jupiterJump: random.NextFloat() * random.NextFloat() * 10 + 1,
|
|
massFraction: .25f
|
|
);
|
|
}
|
|
|
|
// 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 > global.SatelliteCreationMassFloor)
|
|
: root.AllPlanets().Where(p => p != root && p.Mass > global.SatelliteCreationMassFloor);
|
|
|
|
var binaries = new List<Planet>();
|
|
foreach (var planet in satelliteCandidates)
|
|
{
|
|
// There's a chance of generating satellites for each qualified planet
|
|
if (random.NextFloat() < global.SatelliteCreationProbability)
|
|
{
|
|
// Sometimes the satellite is so massive that it forms a binary system (like Earth!)
|
|
if (random.NextFloat() < global.BinaryCreationProbability)
|
|
{
|
|
planet.ExpandRosette(2);
|
|
binaries.AddRange(planet.Children);
|
|
}
|
|
// Otherwise, terrestrial planets get a couple satellites while gas giants get many
|
|
else planet.ExpandSolar(
|
|
count: planet.Mass < global.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 < global.BeltMassCeiling && !binaries.Contains(p))
|
|
: root.AllPlanets().Where(p => p != root && p.Mass < global.BeltMassCeiling && !binaries.Contains(p));
|
|
foreach(var planet in beltCandidates.Reverse())
|
|
if (random.NextFloat() < global.BeltProbability && !planet.Parent.Children.Any(p=>p.Belt))
|
|
planet.Belt = true;
|
|
|
|
return root.AllPlanets().ToArray();
|
|
}
|
|
}
|
|
|
|
// All orbiting bodies are referred to here as "Planets"
|
|
// This goes back to the original etymology for the word planet, which is traveler,
|
|
// Because they were objects we observed to move in the sky instead of remaining fixed like the stars
|
|
public class Planet
|
|
{
|
|
public Random Random;
|
|
public GlobalData Global;
|
|
public float Distance;
|
|
public float Phase;
|
|
public float Mass;
|
|
public float Period;
|
|
public float ChildDistanceMinimum;
|
|
public float ChildDistanceMaximum;
|
|
public bool Empty = false;
|
|
public bool Belt = false;
|
|
public List<Planet> Children = new List<Planet>(); // Planets orbiting this one are referred to as children
|
|
public Planet Parent;
|
|
|
|
// Recursively gather all planets in the hierarchy
|
|
public IEnumerable<Planet> AllPlanets()
|
|
{
|
|
return new[]{this}.Concat(Children.SelectMany(c=>c.AllPlanets()));
|
|
}
|
|
|
|
// Create children that fill a single orbit, equally spaced
|
|
// https://en.wikipedia.org/wiki/Klemperer_rosette
|
|
public void ExpandRosette(int vertices)
|
|
{
|
|
//Debug.Log("Expanding Rosette");
|
|
|
|
// Rosette children replace the parent, parent orbital node is left empty
|
|
Empty = true;
|
|
|
|
// Masses in a rosette alternate, so every sequential pair has the same shared mass
|
|
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 ? Random.NextFloat(.5f,.95f) : .5f;
|
|
|
|
// Place children at a fixed distance in the center of the range
|
|
var dist = (ChildDistanceMinimum + ChildDistanceMaximum) / 2;
|
|
|
|
// Position of first child
|
|
var p0 = new float2(0, dist);
|
|
|
|
// Position of second child
|
|
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 - Global.PlanetRadius(sharedMass * (1 - proportion))) * .75f;
|
|
var p1ChildDist = (distance(p0, p1) * (1 - proportion) - Global.PlanetRadius(sharedMass * proportion)) * .75f;
|
|
|
|
for (int i = 0; i < vertices; i++)
|
|
{
|
|
var child = new Planet
|
|
{
|
|
Random = Random,
|
|
Global = Global,
|
|
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 = Global.PlanetRadius(child.Mass) * 2;
|
|
child.Period = pow(child.Distance, Global.OrbitPeriodExponent) * Global.OrbitPeriodMultiplier;
|
|
Children.Add(child);
|
|
}
|
|
|
|
ChildDistanceMinimum = dist + p0ChildDist;
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
//Debug.Log("Expanding Solar");
|
|
// Expansion is impossible when child space is full
|
|
if (count == 0 || ChildDistanceMaximum < ChildDistanceMinimum)
|
|
return;
|
|
|
|
var masses = new float[count];
|
|
var distances = new float[count];
|
|
|
|
// Accumulate total mass
|
|
// Initialize first mass and distance, actual number doesn't matter since total mass will be divided proportionally
|
|
float massTotal = distances[0] = masses[0] = 1;
|
|
|
|
// Masses and distances multiply from one planet to the next
|
|
// Mass typically increases exponentially as you go further out
|
|
// 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] * 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] *= Random.NextFloat(.1f, 1f);
|
|
|
|
// Normalize the masses of the children
|
|
for (var i = 0; i < count; i++)
|
|
masses[i] = masses[i] / massTotal * Mass * massFraction;
|
|
|
|
// Map child distances to range between minimum and maximum
|
|
if (count > 1)
|
|
{
|
|
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])) + Global.PlanetRadius(masses[i]);
|
|
}
|
|
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
// Only instantiate children above the mass floor
|
|
if (masses[i] > Global.MassFloor)
|
|
{
|
|
var child = new Planet
|
|
{
|
|
Random = Random,
|
|
Global = Global,
|
|
Parent = this,
|
|
Mass = masses[i],
|
|
Distance = distances[i],
|
|
Phase = Random.NextFloat()
|
|
};
|
|
child.Period = pow(child.Distance, Global.OrbitPeriodExponent) * Global.OrbitPeriodMultiplier;
|
|
child.ChildDistanceMinimum = Global.PlanetRadius(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);
|
|
if (float.IsNaN(child.Distance))
|
|
throw new NotFiniteNumberException($"Planet created with NaN distance, something went very wrong!");
|
|
if (child.ChildDistanceMaximum > child.ChildDistanceMinimum)
|
|
Children.Add(child);
|
|
}
|
|
}
|
|
}
|
|
} |