private static void SendRemoveSystemObjectServer(Guid objectId, ulong callbackId, ulong clientId)
{
MyPluginLog.Log("Server: Removing object " + objectId.ToString() + " from system");
MySystemObject o = Static.StarSystem.GetObjectById(objectId);
if (o != null && o.DisplayName != Static.StarSystem.CenterObject.DisplayName)
{
if (o.Type == MySystemObjectType.ASTEROIDS)
{
var asteroids = o as MySystemAsteroids;
if (MyAsteroidObjectsManager.Static.AsteroidObjectProviders.ContainsKey(asteroids.AsteroidTypeName))
{
bool removed = MyAsteroidObjectsManager.Static.AsteroidObjectProviders[asteroids.AsteroidTypeName].RemoveInstance(asteroids);
if (removed)
{
MyGPSManager.Static.RemovePersistentGps(objectId);
PluginEventHandler.Static.RaiseStaticEvent(SendSimpleActionCallbackClient, Static.StarSystem.RemoveObject(objectId), callbackId, clientId);
return;
}
}
}
else
{
MyGPSManager.Static.RemovePersistentGps(objectId);
PluginEventHandler.Static.RaiseStaticEvent(SendSimpleActionCallbackClient, Static.StarSystem.RemoveObject(objectId), callbackId, clientId);
return;
}
}
PluginEventHandler.Static.RaiseStaticEvent(SendSimpleActionCallbackClient, false, callbackId, clientId);
}
/// <summary>
/// Loads data used by the procedural generator
/// </summary>
public override void LoadData()
{
if (!MySettingsSession.Static.IsEnabled())
{
return;
}
MyPluginLog.Log("Loading Procedural Generator Component");
Static = this;
m_procDensity = MySession.Static.Settings.ProceduralDensity;
m_seed = MySession.Static.Settings.ProceduralSeed;
if (MySettingsSession.Static.Settings.GeneratorSettings.AsteroidGenerator == ObjectBuilders.AsteroidGenerationMethod.PLUGIN)
{
MySession.Static.Settings.ProceduralDensity = 0f;
}
m_isEnabled = true;
//Add default impl of registering of standard generator components
RegisterModule(new MyProceduralPlanetModule(m_seed));
RegisterModule(new MyProceduralAsteroidsModule(m_seed));
MyPluginLog.Log("Loading Procedural Generator Component completed");
}
/// <summary>
/// Tries to apply the harmony patches to fix more complicated bugs.
/// Will only actually patch, if 0harmony.dll is found AND patching is enabled in the global settings.
/// </summary>
private void TryEnablePatches()
{
if (settings.Settings.EnablePatching)
{
try
{
MyPluginLog.Log("Patching...");
Patch();
MyPluginLog.Log("Patches applied");
}
catch (FileNotFoundException)
{
MyPluginLog.Log("0harmony.dll not found, skipping patching.", LogLevel.WARNING);
}
catch (Exception e)
{
MyPluginLog.Log("Something went wrong while patching: ", LogLevel.ERROR);
MyPluginLog.Log(e.StackTrace, LogLevel.ERROR);
}
}
else
{
MyPluginLog.Log("Patching is disabled, skipping patches.");
}
}
/// <summary>
/// Retreives the data for the vanilla asteroid generator to
/// correctly generate asteroids.
/// </summary>
/// <returns>The asteroid generator definition</returns>
private MyAsteroidGeneratorDefinition GetData()
{
MyAsteroidGeneratorDefinition myAsteroidGeneratorDefinition = null;
int voxelGeneratorVersion = MySession.Static.Settings.VoxelGeneratorVersion;
foreach (MyAsteroidGeneratorDefinition value in MyDefinitionManager.Static.GetAsteroidGeneratorDefinitions().Values)
{
if (value.Version == voxelGeneratorVersion)
{
myAsteroidGeneratorDefinition = value;
break;
}
}
if (myAsteroidGeneratorDefinition == null)
{
MyPluginLog.Log("Generator of version " + voxelGeneratorVersion + "not found!");
{
foreach (MyAsteroidGeneratorDefinition value2 in MyDefinitionManager.Static.GetAsteroidGeneratorDefinitions().Values)
{
if (myAsteroidGeneratorDefinition == null || (value2.Version > voxelGeneratorVersion && (myAsteroidGeneratorDefinition.Version < voxelGeneratorVersion || value2.Version < myAsteroidGeneratorDefinition.Version)))
{
myAsteroidGeneratorDefinition = value2;
}
}
return(myAsteroidGeneratorDefinition);
}
}
return(myAsteroidGeneratorDefinition);
}
/// <summary>
/// Checks all planets of the star system, and whether they are still existent as objects
/// in the world. Just to clear up deleted objects from the system at world loading
/// </summary>
private void CheckIntegrityOfSystem()
{
foreach (var obj in StarSystem.GetAllObjects())
{
if (obj is MySystemPlanet)
{
if (!MyEntities.EntityExists((obj as MySystemPlanet).EntityId) && (obj as MySystemPlanet).Generated)
{
MyPluginLog.Debug("Planet " + obj.Id + " does not exist anymore, deleting it", LogLevel.WARNING);
StarSystem.RemoveObject(obj.Id);
MyGPSManager.Static.RemovePersistentGps(obj.Id);
}
}
else if (obj is MySystemAsteroids)
{
var instance = obj as MySystemAsteroids;
if (MyAsteroidObjectsManager.Static.AsteroidObjectProviders.ContainsKey(instance.AsteroidTypeName))
{
var data = MyAsteroidObjectsManager.Static.AsteroidObjectProviders[instance.AsteroidTypeName].GetInstanceData(instance);
if (data == null)
{
MyPluginLog.Debug("Asteroid instance " + obj.Id + " has no data attached, deleting it", LogLevel.WARNING);
MyAsteroidObjectsManager.Static.AsteroidObjectProviders[instance.AsteroidTypeName].RemoveInstance(instance);
MyGPSManager.Static.RemovePersistentGps(obj.Id);
}
}
}
}
}
/// <summary>
/// Loads the savefile of the plugin settings of the world and stores it
/// int the Settings member variable
/// </summary>
public override void LoadData()
{
MyPluginLog.Log("Loading Session settings data");
Static = this;
if (MyFileUtils.FileExistsInWorldStorage(FILE_NAME))
{
Settings = MyFileUtils.ReadXmlFileFromWorld <MyObjectBuilder_WorldSettings>(FILE_NAME);
MyPluginLog.Log("Session settings read from file");
}
else
{
MyPluginLog.Log("Session settings do not exist, creating new ones.");
if (MySettings.Static == null)
{
var s = new MySettings();
s.LoadSettings();
}
if (MySettings.Static.SessionSettings != null)
{
Settings = MySettings.Static.SessionSettings;
}
else
{
Settings = new MyObjectBuilder_WorldSettings();
}
MySettings.Static.SessionSettings = null;
}
MyPluginLog.Log("Loading Session settings data completed");
}
private static void SendAddSystemObjectServer(MySystemObject obj, Guid parentId, ulong callbackId, ulong clientId)
{
MyPluginLog.Log("Server: Add object " + obj.DisplayName + " to system");
if (obj != null)
{
if (!Static.StarSystem.ObjectExists(obj.Id))
{
var parent = Static.StarSystem.GetObjectById(parentId);
if (parent != null)
{
parent.ChildObjects.Add(obj);
obj.ParentId = parentId;
PluginEventHandler.Static.RaiseStaticEvent(SendSimpleActionCallbackClient, true, callbackId, clientId);
}
else
{
Static.StarSystem.CenterObject.ChildObjects.Add(obj);
obj.ParentId = Static.StarSystem.CenterObject.Id;
PluginEventHandler.Static.RaiseStaticEvent(SendSimpleActionCallbackClient, true, callbackId, clientId);
}
Static.AddAllPersistentGps();
return;
}
}
PluginEventHandler.Static.RaiseStaticEvent(SendSimpleActionCallbackClient, false, callbackId, clientId);
}
/// <summary>
/// Saves the gpss to the file
/// </summary>
public override void SaveData()
{
if (!MySettingsSession.Static.IsEnabled())
{
return;
}
MyPluginLog.Log("Saving GPS manager data");
MyObjectBuilder_WorldGpsData ob = new MyObjectBuilder_WorldGpsData();
foreach (var entry in m_globalGpss)
{
PersistentGpsData item = new PersistentGpsData();
item.Name = entry.Value.Name;
item.Color = entry.Value.Color;
item.Position = entry.Value.Position;
item.PlayerIds = entry.Value.Players;
item.Id = entry.Key;
item.Hidden = entry.Value.Hidden;
ob.PersistentGpss.Add(item);
}
MyFileUtils.WriteXmlFileToWorld(ob, FILENAME);
MyPluginLog.Log("Saving GPS manager data completed");
}
/// <summary>
/// Generates a random amount of moons for a planet
/// </summary>
/// <param name="parentPlanet"></param>
/// <returns></returns>
private MySystemPlanetMoon[] GeneratePlanetMoons(MySystemPlanet parentPlanet)
{
MyPluginLog.Log("Generating moons for planet " + parentPlanet.DisplayName);
var settings = MySettingsSession.Static.Settings.GeneratorSettings;
uint maxMoons = (uint)Math.Ceiling(parentPlanet.Diameter / 120000 * 2);
maxMoons = (uint)Math.Min(maxMoons, settings.PlanetSettings.MinMaxMoons.Max);
uint numMoons = (uint)MyRandom.Instance.Next(settings.PlanetSettings.MinMaxMoons.Min, (int)maxMoons + 1);
numMoons = Math.Min(numMoons, 25);
if (settings.SystemGenerator == SystemGenerationMethod.UNIQUE)
{
numMoons = Math.Min(numMoons, (uint)m_moons.Count);
}
MySystemPlanetMoon[] moons = new MySystemPlanetMoon[numMoons];
for (int i = 0; i < numMoons; i++)
{
MyPluginLog.Log("Generating moon " + i);
double distance = parentPlanet.Diameter * (i + 1) + parentPlanet.Diameter * MyRandom.Instance.GetRandomFloat(1f, 1.5f);
double diameter;
var definition = FindPlanetDefinitionForSize(parentPlanet.Diameter * 0.75f, out diameter, true);
if (definition == null)
{
return(moons);
}
Vector3D position;
int tries2 = 0;
do
{
double angle = MyRandom.Instance.GetRandomFloat(0, (float)Math.PI * 2f);
position = new Vector3D(distance * Math.Sin(angle), distance * Math.Cos(angle), distance * Math.Sin(MyRandom.Instance.GetRandomFloat((float)-Math.PI / 2, (float)Math.PI / 2)));
position = Vector3D.Add(position, parentPlanet.CenterPosition);
} while (IsMoonPositionObstructed(position, diameter, parentPlanet, moons) && ++tries2 < MAX_DEF_FIND_ROUNDS);
MySystemPlanetMoon moon = new MySystemPlanetMoon();
moon.CenterPosition = position;
moon.Diameter = diameter;
moon.DisplayName = GetMoonName(i, definition.Id.SubtypeId.String, parentPlanet.DisplayName);
moon.SubtypeId = definition.Id.SubtypeId.String;
moon.ParentId = parentPlanet.Id;
moons[i] = moon;
}
MyPluginLog.Log("Generating moons for planet " + parentPlanet.DisplayName + " completed");
return(moons);
}
protected override MyProceduralCell GenerateCellSeeds(Vector3I cellId)
{
if (m_loadedCells.ContainsKey(cellId))
{
return(null);
}
var settings = MySettingsSession.Static.Settings.GeneratorSettings;
if (settings.AsteroidGenerator == AsteroidGenerationMethod.VANILLA)
{
return(null);
}
MyProceduralCell cell = new MyProceduralCell(cellId, CELL_SIZE);
int cellSeed = CalculateCellSeed(cellId);
int index = 0;
double subCellSize = OBJECT_SIZE_MAX * 1f / settings.AsteroidDensity;
int subcells = (int)(CELL_SIZE / subCellSize);
using (MyRandom.Instance.PushSeed(cellSeed))
{
Vector3I subcellId = Vector3I.Zero;
Vector3I max = new Vector3I(subcells - 1);
for (var it = new Vector3I_RangeIterator(ref Vector3I.Zero, ref max); it.IsValid(); it.GetNext(out subcellId))
{
Vector3D position = new Vector3D(MyRandom.Instance.NextDouble(), MyRandom.Instance.NextDouble(), MyRandom.Instance.NextDouble());
position += (Vector3D)subcellId;
position *= subCellSize;
position += ((Vector3D)cellId) * CELL_SIZE;
if (!MyEntities.IsInsideWorld(position) || (settings.WorldSize >= 0 && position.Length() > settings.WorldSize))
{
continue;
}
var ring = GetAsteroidObjectAt(position);
if (ring == null)
{
continue;
}
var cellObjectSeed = new MyObjectSeed(cell, position, MyRandom.Instance.Next(ring.AsteroidSize.Min, ring.AsteroidSize.Max));
cellObjectSeed.Params.Type = VRage.Game.MyObjectSeedType.Asteroid;
cellObjectSeed.Params.Seed = MyRandom.Instance.Next();
cellObjectSeed.Params.Index = index++;
cellObjectSeed.Params.GeneratorSeed = m_definition.UseGeneratorSeed ? MyRandom.Instance.Next() : 0;
cell.AddObject(cellObjectSeed);
MyPluginLog.Debug("Adding seed");
}
}
return(cell);
}
/// <summary>
/// Builds the spawn menu
/// </summary>
private void BuildSpawnMenu()
{
MyPluginLog.Debug("Create Spawn Menu");
var topCombo = GetCombo();
Vector2 start = topCombo.Position + new Vector2(0, MARGIN_VERT * 2 + GetCombo().Size.Y);
Vector2 end = start + new Vector2(topCombo.Size.X, 0.8f - MARGIN_VERT);
MyGuiControlParentTableLayout table = new MyGuiControlParentTableLayout(1, false, Vector2.Zero);
table.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP;
m_spawnTypeCombo = new MyGuiControlCombobox();
m_spawnTypeCombo.AddItem(0L, "Planet");
m_spawnTypeCombo.AddItem(1L, "Asteroid object");
m_spawnTypeCombo.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP;
m_spawnTypeCombo.SelectItemByKey(m_spawnType);
m_spawnTypeCombo.ItemSelected += OnSpawnTypeChange;
m_spawnTypeCombo.Size = new Vector2(m_usableWidth * 0.9f, m_spawnTypeCombo.Size.Y);
m_spawnTypeCombo.SetToolTip(MyPluginTexts.TOOLTIPS.ADMIN_SPAWN_TYPE);
table.AddTableRow(m_spawnTypeCombo);
table.AddTableSeparator();
switch (m_spawnType)
{
case 0L:
CreatePlanetSpawnMenu(table);
break;
case 1L:
CreateAsteroidSpawnMenu(table);
break;
}
table.AddTableSeparator();
table.ApplyRows();
MyGuiControlScrollablePanel scrollPane = new MyGuiControlScrollablePanel(table);
scrollPane.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_TOP;
scrollPane.ScrollbarVEnabled = true;
scrollPane.Size = end - start;
scrollPane.Size = new Vector2(0.315f, scrollPane.Size.Y);
scrollPane.Position = new Vector2(0, start.Y);
Controls.Add(scrollPane);
MyGuiControlSeparatorList sep = new MyGuiControlSeparatorList();
sep.AddHorizontal(new Vector2(scrollPane.Position.X - scrollPane.Size.X / 2, scrollPane.Position.Y + scrollPane.Size.Y), m_usableWidth);
Controls.Add(sep);
MyPluginLog.Debug("Added spawn menu");
}
/// <summary>
/// Verifies a double and sets it to def, if it is outside of the min max bounds.
/// </summary>
/// <param name="min">Minimum value</param>
/// <param name="max">Maximum value</param>
/// <param name="def">Default value</param>
/// <param name="name">Name of the variable</param>
/// <param name="value">Reference to the value to check</param>
public static void VerifyDouble(double min, double max, double def, string name, ref double value)
{
if (value < min || value > max)
{
value = def;
MyPluginLog.Log("Config value " + name + " of was invalid and will be set to default.", LogLevel.WARNING);
}
}
/// <summary>
/// Saves the system objects to a file, if the plugin is enabled.
/// </summary>
public override void SaveData()
{
if (MySettingsSession.Static.IsEnabled())
{
MyPluginLog.Log("Saving system data");
MyFileUtils.WriteXmlFileToWorld(StarSystem, STORAGE_FILE);
}
}
private static void SendGetStarSystemClient(MyObjectBuilder_SystemData starSystem, ulong callbackId)
{
MyPluginLog.Debug("Client: Received star system");
if (Static.m_getSystemCallbacks.ContainsKey(callbackId))
{
Static.m_getSystemCallbacks[callbackId](starSystem);
Static.m_getSystemCallbacks.Remove(callbackId);
}
}
/// <summary>
/// Registers a new module for this instance of the procedural generator
/// </summary>
/// <param name="module"></param>
public void RegisterModule(MyAbstractProceduralObjectModul module)
{
MyPluginLog.Log("Registering new Procedural generation module " + module.GetType());
if (!m_objectModules.Contains(module))
{
m_objectModules.Add(module);
}
}
private static void SendSimpleActionCallbackClient(bool success, ulong callbackId)
{
MyPluginLog.Log("Client: Getting simple callback with success=" + success + " from server");
if (Static.m_simpleActionsCallbacks.ContainsKey(callbackId))
{
Static.m_simpleActionsCallbacks[callbackId](success);
Static.m_simpleActionsCallbacks.Remove(callbackId);
}
}
/// <summary>
/// Generates a ring for the given planet
/// </summary>
/// <param name="parentPlanet">Planet the ring is based on</param>
/// <returns>The ring for the planet</returns>
private MySystemAsteroids GenrateRing(MySystemPlanet parentPlanet)
{
MyPluginLog.Log("Generating ring for planet " + parentPlanet.DisplayName);
var provider = MyAsteroidObjectsManager.Static.AsteroidObjectProviders[MyAsteroidRingProvider.TYPE_NAME];
var ring = provider.GenerateInstance(0, parentPlanet, 0);
return(ring);
}
/// <summary>
/// Verifies a float and sets it to def, if it is outside of the min max bounds.
/// </summary>
/// <param name="min">Minimum value</param>
/// <param name="max">Maximum value</param>
/// <param name="def">Default value</param>
/// <param name="name">Name of the variable</param>
/// <param name="value">Reference to the value to check</param>
public static void VerifyFloat(float min, float max, float def, string name, ref float value)
{
if (value < min || value > max)
{
value = def;
MyPluginLog.Log("Config value " + name + " of was invalid and will be set to default.", LogLevel.WARNING);
}
}
/// <summary>
/// Unloads used data.
/// </summary>
protected override void UnloadData()
{
MyPluginLog.Log("Unloading Procedural Generator Component");
m_trackedEntities.Clear();
m_cellModules.Clear();
m_objectModules.Clear();
MyPluginLog.Log("Unloading Procedural Generator Component completed");
}
private static void SendGetObjectClient(bool success, MySystemObject obj, ulong callbackId)
{
MyPluginLog.Log("Client: Received get object message from server with success " + success);
if (Static.m_getActionCallbacks.ContainsKey(callbackId))
{
Static.m_getActionCallbacks[callbackId](success, obj);
Static.m_getActionCallbacks.Remove(callbackId);
}
}
protected override void UnloadData()
{
MyPluginLog.Log("Asteroid object manager unloading data");
base.UnloadData();
AsteroidObjectProviders.Clear();
Static = null;
MyPluginLog.Log("Asteroid object manager unloading data completed");
}
public override void LoadData()
{
base.LoadData();
MyPluginLog.Log("Asteroid object manager loading data");
Static = this;
AsteroidObjectProviders = new Dictionary <string, MyAbstractAsteroidObjectProvider>();
LoadAllAsteroidTypes();
MyPluginLog.Log("Asteroid object manager loading data completed");
}
/// <summary>
/// Loads the global configuration file if it exists, otherwise creates a new one.
/// </summary>
public void LoadSettings()
{
MyPluginLog.Log("Loading the global config file");
if (MyFileUtils.FileExistsInGlobalStorage(FILENAME))
{
try
{
using (var reader = MyFileUtils.ReadFileInGlobalStorage(FILENAME))
{
MyPluginLog.Log("Reading global config file");
MyObjectBuilder_GlobalSettings saveFile = MyFileUtils.SerializeFromXml <MyObjectBuilder_GlobalSettings>(reader.ReadToEnd());
if (saveFile != null)
{
MyPluginLog.Log("Serialized global config file");
Settings = saveFile;
}
}
}
catch (Exception e)
{
MyPluginLog.Log("Couldnt load Plugin config file.", LogLevel.ERROR);
MyPluginLog.Log(e.Message + "\n" + e.StackTrace, LogLevel.ERROR);
MyFileUtils.DeleteFileInGlobalStorage(FILENAME);
Settings = new MyObjectBuilder_GlobalSettings();
Settings.MoonDefinitions.Add("Moon");
Settings.MoonDefinitions.Add("Titan");
Settings.MoonDefinitions.Add("Europa");
Settings.MoonDefinitions.Add("Triton");
Settings.BlacklistedPlanetDefinitions.Add("EarthLikeTutorial");
Settings.BlacklistedPlanetDefinitions.Add("MarsTutorial");
Settings.BlacklistedPlanetDefinitions.Add("MoonTutorial");
Settings.BlacklistedPlanetDefinitions.Add("SystemTestMap");
Settings.BlacklistedPlanetDefinitions.Add("EarthLikeModExample");
}
}
else
{
MyPluginLog.Log("Config does not exist, creating default one");
Settings = new MyObjectBuilder_GlobalSettings();
Settings.MoonDefinitions.Add("Moon");
Settings.MoonDefinitions.Add("Titan");
Settings.MoonDefinitions.Add("Europa");
Settings.MoonDefinitions.Add("Triton");
Settings.BlacklistedPlanetDefinitions.Add("EarthLikeTutorial");
Settings.BlacklistedPlanetDefinitions.Add("MarsTutorial");
Settings.BlacklistedPlanetDefinitions.Add("MoonTutorial");
Settings.BlacklistedPlanetDefinitions.Add("SystemTestMap");
Settings.BlacklistedPlanetDefinitions.Add("EarthLikeModExample");
}
Settings.Verify();
MyPluginLog.Log("Config loaded");
}
/// <summary>
/// Finds a fit planet definition for a planet with a diameter less than maxDiameter.
/// If none can be found, a random one will be returned.
/// </summary>
/// <param name="maxDiameter">Max diameter of the planet in meters</param>
/// <param name="diameter">The diameter of the planet for the returned definition</param>
/// <param name="isMoon">If it should use moon definitions</param>
/// <returns>A definition of a planet that tries to be smaller than maxDiameter</returns>
private MyPlanetGeneratorDefinition FindPlanetDefinitionForSize(double maxDiameter, out double diameter, bool isMoon = false)
{
var settings = MySettingsSession.Static.Settings.GeneratorSettings;
var planets = isMoon ? m_uniqueMoons : m_uniquePlanets;
var mandatory = isMoon ? m_mandatoryMoons : m_mandatoryPlanets;
MyPlanetGeneratorDefinition def;
int tries = 0;
if (planets == null || planets.Count <= 0)
{
if (isMoon)
{
m_uniqueMoons = new List <MyPlanetGeneratorDefinition>(m_moons);
planets = m_uniqueMoons;
}
else
{
m_uniquePlanets = new List <MyPlanetGeneratorDefinition>(m_planets);
planets = m_uniquePlanets;
}
}
if (planets.Count <= 0)
{
MyPluginLog.Log("Cant find planet definition", LogLevel.WARNING);
diameter = 0;
return(null);
}
if (settings.SystemGenerator >= SystemGenerationMethod.MANDATORY_FIRST && mandatory.Count > 0)
{
planets = mandatory;
}
do
{
def = planets[MyRandom.Instance.Next(0, planets.Count)];
diameter = CalculatePlanetDiameter(def);
} while (diameter > maxDiameter && ++tries < MAX_DEF_FIND_ROUNDS);
if (settings.SystemGenerator == SystemGenerationMethod.MANDATORY_FIRST)
{
mandatory.Remove(def);
}
if (settings.SystemGenerator == SystemGenerationMethod.UNIQUE)
{
planets.Remove(def);
}
return(def);
}
/// <summary>
/// Generates a planet for the star system.
/// </summary>
/// <param name="planetIndex">Index of the planet in the system</param>
/// <param name="maxDiameter">The largest diameter the planet should have</param>
/// <param name="orbitDistance">The distance the planet is away from Vector3D.Zero</param>
/// <returns>A new MySystemPlanet</returns>
private MySystemPlanet GeneratePlanet(int planetIndex, double maxDiameter, long orbitDistance)
{
MyPluginLog.Log("Generating new planet");
var settings = MySettingsSession.Static.Settings.GeneratorSettings.PlanetSettings;
var def = FindPlanetDefinitionForSize(maxDiameter);
if (def == null)
{
MyPluginLog.Log("Could not load a planet definition for this planet.", LogLevel.WARNING);
return(null);
}
var diameter = CalculatePlanetDiameter(def);
var angle = MyRandom.Instance.GetRandomFloat(0, (float)(2 * Math.PI));
var elevation = MyRandom.Instance.GetRandomFloat((float)Math.PI / 180 * -5, (float)Math.PI / 180 * 5);
Vector3D pos = new Vector3D(orbitDistance * Math.Sin(angle), orbitDistance * Math.Cos(angle), orbitDistance * Math.Sin(elevation));
string name = GetPlanetName(planetIndex, def.Id.SubtypeId.String);
MySystemPlanet planet = new MySystemPlanet()
{
CenterPosition = pos,
Diameter = diameter,
DisplayName = name,
Generated = false,
SubtypeId = def.Id.SubtypeId.String,
};
if (MyRandom.Instance.NextFloat() < settings.BaseRingProbability * def.SurfaceGravity)
{
planet.ChildObjects.Add(GenrateRing(planet));
}
if (MyRandom.Instance.NextFloat() < settings.BaseMoonProbability * def.SurfaceGravity)
{
foreach (var moon in GeneratePlanetMoons(planet))
{
if (moon == null)
{
continue;
}
planet.ChildObjects.Add(moon);
}
}
MyPluginLog.Log("Planet generated");
return(planet);
}
/// <summary>
/// This method adds the MyEntity to the MyEntityTrackerComponent as a
/// tracked Entity.
/// </summary>
/// <param name="thisEntity">The Entiy this method executes on</param>
public static void EntityTracking(this MyEntity thisEntity)
{
MyPluginLog.Debug("Try Track Entity" + thisEntity.Name);
if (thisEntity is MyVoxelBase)
{
return;
}
if (MyEntityTrackerComponent.Static != null)
{
MyPluginLog.Debug("Track Entity");
MyEntityTrackerComponent.Static.TrackEntity(thisEntity);
}
}
/// <summary>
/// Saves the global configuration file
/// </summary>
public void SaveSettings()
{
MyFileUtils.DeleteFileInGlobalStorage(FILENAME);
string xml = MyFileUtils.SerializeToXml(Settings);
MyPluginLog.Log("Saving global SEWorldGenPlugin config file: " + xml);
using (var writer = MyFileUtils.WriteFileInGlobalStorage(FILENAME))
{
writer.Write(xml);
writer.Close();
}
}
/// <summary>
/// Loads necessary data for this class and initializes the fields
/// </summary>
public override void LoadData()
{
MyPluginLog.Log("Entity tracker loading data");
base.LoadData();
Static = this;
m_entityTrackers = new List <IMyEntityTracker>();
m_trackedEntities = new List <MyEntity>();
m_newTrackedEntities = new List <MyEntity>();
m_toUntrackEntities = new List <MyEntity>();
MyPluginLog.Log("Entity tracker loading data completed");
}
/// <summary>
/// Registers all types with the EventOwnerAttribute.
/// </summary>
public void RegisterAll()
{
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var type in assembly.GetTypes())
{
if (type.GetCustomAttributes(typeof(EventOwnerAttribute), true).Length > 0)
{
MyPluginLog.Log("Registering type " + type.Name + " in PluginEventHandler.");
Register(type);
}
}
}
}
/// <summary>
/// Unloads the used data of this session component.
/// </summary>
protected override void UnloadData()
{
MyPluginLog.Log("Unloading Session settings data");
if (Sync.IsServer)
{
MyFileUtils.WriteXmlFileToWorld(Settings, FILE_NAME);
}
Settings = null;
MySettings.Static.SessionSettings = null;
MyPluginLog.Log("Unloading Session settings data completed");
}
