/// <summary>
/// This function will receive a Universe and a StarDefaultSettings object and create Stars from the data
/// provided
/// </summary>
/// <param name="universe"></param>
/// <param name="starDefaultSettings"></param>
/// <param name="starData"></param>
/// <param name="nameGeneration"></param>
/// <returns>
/// A newly modified Universe
/// </returns>
public Universe AddStars(Universe universe, StarDefaultSettings starDefaultSettings, StarData starData,
NameGeneration nameGeneration)
{
// Check if the Stars have been initialized prior
universe.Stars ??= new List <Star>();
// Set the number of stars to create. The default is 1d10+20
var starLen = starData.Stars.Count;
var starCount = starDefaultSettings.StarCount < 0
? Rand.Next(0, 10) + 20
: starDefaultSettings.StarCount;
var sCount = 0;
while (sCount < starCount)
{
var star = new Star();
// Generate the unique ID for the Star
IdGen.GenerateId(star);
// Set Grid Location of the Star
var zone = universe.Zones[Rand.Next(0, universe.Zones.Count)];
if (zone.StarId == null)
{
zone.StarId = star.Id;
}
else
{
continue;
}
// If that ID exists roll a new one
if (universe.Stars.Exists(a => a.Id == star.Id))
{
continue;
}
// Pick a random Name for the Star
star.Name = Rand.Next(0, 4) == 2
? nameGeneration.GenerateName()
: starData.Stars[Rand.Next(0, starLen - 1)];
// If that Name exists roll a new one
if (universe.Stars.Exists(a => a.Name == star.Name))
{
continue;
}
// Set the type of Star
star.StarType = starData.StarTypes[Rand.Next(0, 8) + Rand.Next(0, 8) + Rand.Next(0, 8)];
// Add the Star to the Universe
universe.Stars.Add(star);
sCount++;
}
return(universe);
}
public City(HexRef xref, CityDisplay display)
{
name = NameGeneration.RandomCityName();
//color = Random.ColorHSV(0,1,1,1,0.99f,0.99f);
this.hexRef = xref;
this.cityDispaly = display;
this.cityDispaly.Name = name;
//this.display.SetColor(color);
}
private static IList <EntryPointOperation> GenerateEntryPointOperations(QsCompilation compilation)
{
var globals = compilation.Namespaces.GlobalCallableResolutions();
return(compilation.EntryPoints.Select(ep => new EntryPointOperation()
{
Name = NameGeneration.InteropFriendlyWrapperName(ep),
Parameters = GetParams(globals[ep]),
}).ToList());
}
private static void DelayValidateSchemaNamesChanged(ModelElement element)
{
if (!element.IsDeleted)
{
Schema schema = (Schema)element;
// Disable customization tracking during name generation, and
// reset customizations on completion.
SchemaCustomization customization = SchemaCustomization.SetCustomization(schema, null);
NameGeneration.GenerateAllNames(schema, customization);
SchemaCustomization.SetCustomization(schema, new SchemaCustomization(schema));
}
}
/// <summary>
/// This function receives a Universe and a PlanetDefaultSettings to create planets based on
/// specified information
/// </summary>
/// <param name="universe"></param>
/// <param name="planetDefaultSettings"></param>
/// <param name="worldInfo"></param>
/// <param name="starData"></param>
/// <param name="societyData"></param>
/// <param name="nameGeneration"></param>
/// <returns>
/// The newly updated Universe
/// </returns>
public Universe AddPlanets(Universe universe, PlanetDefaultSettings planetDefaultSettings, WorldInfo worldInfo,
StarData starData, SocietyData societyData, NameGeneration nameGeneration)
{
// Get the number of Planet Names from starData
var planLen = starData.Planets.Count;
// Iterate through each star and
foreach (Star star in universe.Stars)
{
// Set the random number of Planets that will be created for a given Star
var pMax = planetDefaultSettings.PlanetRange == null || planetDefaultSettings.PlanetRange.Length == 0 ||
planetDefaultSettings.PlanetRange[0] == 0 ||
planetDefaultSettings.PlanetRange[1] == 0
? Rand.Next(1, 3) // Default Planet count is up-to 3
: Rand.Next(planetDefaultSettings.PlanetRange[0],
planetDefaultSettings.PlanetRange[1] + 1);
var pCount = 0;
while (pCount < pMax)
{
var planet = new Planet
{
Society = new Society(), Ruler = new Ruler(), Ruled = new Ruled(), Flavor = new Flavor()
};
// Generate the ID for the Planet
IdGen.GenerateId(planet);
// If that ID exists somewhere then re-roll it
if (universe.Planets.Exists(a => a.Id == planet.Id))
{
continue;
}
// Pick a random name out of the list of Planets
planet.Name = Rand.Next(0, 4) == 2
? nameGeneration.GenerateName()
: starData.Planets[Rand.Next(0, planLen)];
// No planets can share a name
if (universe.Planets.Exists(a => a.Name == planet.Name))
{
continue;
}
// Set the Planet information from either a randomized value or specified information
planet.StarId = star.Id;
universe.Zones.Single(a => a.StarId == star.Id).Planets.Add(planet.Id);
planet.FirstWorldTag = worldInfo.WorldTags[Rand.Next(0, 100)].Type;
planet.SecondWorldTag = worldInfo.WorldTags[Rand.Next(0, 100)].Type;
planet.Atmosphere = worldInfo.Atmospheres[Rand.Next(0, 6) + Rand.Next(0, 6)].Type;
planet.Temperature = worldInfo.Temperatures[Rand.Next(0, 6) + Rand.Next(0, 6)].Type;
planet.Biosphere = worldInfo.Biospheres[Rand.Next(0, 6) + Rand.Next(0, 6)].Type;
planet.Population = worldInfo.Populations[Rand.Next(0, 6) + Rand.Next(0, 6)].Type;
planet.TechLevel = worldInfo.TechLevels[Rand.Next(0, 6) + Rand.Next(0, 6)].Type;
if (societyData != null)
{
// Set the Planet's society information
planet.Society.PriorCulture = societyData.Societies.PriorCultures[Rand.Next(0, 6)];
planet.Society.OtherSociety = societyData.Societies.OtherSocieties[Rand.Next(0, 8)];
planet.Society.MainRemnant = societyData.Societies.MainRemnants[Rand.Next(0, 10)];
planet.Society.SocietyAge = societyData.Societies.SocietyAges[Rand.Next(0, 4)];
planet.Society.ImportantResource = societyData.Societies.ImportantResources[Rand.Next(0, 12)];
planet.Society.FoundingReason = societyData.Societies.FoundingReasons[Rand.Next(0, 20)];
// Set the Planet's Ruler
planet.Ruler.GeneralSecurity = societyData.Rulers.GeneralSecurities[Rand.Next(0, 6)];
planet.Ruler.LegitimacySource = societyData.Rulers.LegitimacySources[Rand.Next(0, 8)];
planet.Ruler.MainRulerConflict = societyData.Rulers.MainRulerConflicts[Rand.Next(0, 10)];
planet.Ruler.RuleCompletion = societyData.Rulers.RuleCompletions[Rand.Next(0, 4)];
planet.Ruler.RuleForm = societyData.Rulers.RuleForms[Rand.Next(0, 12)];
planet.Ruler.MainPopConflict = societyData.Rulers.MainPopConflicts[Rand.Next(0, 20)];
// Set the Planet's Ruled
planet.Ruled.Contentment = societyData.Ruled.Contentments[Rand.Next(0, 6)];
planet.Ruled.LastMajorThreat = societyData.Ruled.LastMajorThreats[Rand.Next(0, 8)];
planet.Ruled.Power = societyData.Ruled.Powers[Rand.Next(0, 10)];
planet.Ruled.Uniformity = societyData.Ruled.Uniformities[Rand.Next(0, 4)];
planet.Ruled.MainConflict = societyData.Ruled.MainConflicts[Rand.Next(0, 12)];
planet.Ruled.Trends = societyData.Ruled.Trends[Rand.Next(0, 20)];
// Set the Planet's Flavor
planet.Flavor.BasicFlavor = societyData.Flavors.BasicFlavors[Rand.Next(0, 12)];
planet.Flavor.OutsiderTreatment = societyData.Flavors.OutsiderTreatments[Rand.Next(0, 6)];
planet.Flavor.PrimaryVirtue = societyData.Flavors.PrimaryVirtues[Rand.Next(0, 8)];
planet.Flavor.PrimaryVice = societyData.Flavors.PrimaryVices[Rand.Next(0, 10)];
planet.Flavor.XenophiliaDegree = societyData.Flavors.XenophiliaDegrees[Rand.Next(0, 4)];
planet.Flavor.PossiblePatron = societyData.Flavors.PossiblePatrons[Rand.Next(0, 12)];
planet.Flavor.Customs = societyData.Flavors.Customs[Rand.Next(0, 20)];
}
// Set primary world
if (pCount == 0)
{
planet.IsPrimary = true;
}
else
{
// Non-primary world information
planet.Origin = worldInfo.OwOrigins[Rand.Next(0, 8)];
planet.Relationship = worldInfo.OwRelationships[Rand.Next(0, 8)];
planet.Contact = worldInfo.OwContacts[Rand.Next(0, 8)];
planet.IsPrimary = false;
}
// Add the Planet to the current Universe
universe.Planets.Add(planet);
pCount++;
}
}
return(universe);
}
