void ShrinkVMap()
{
Vector3I min, max;
m_selectedVoxel.GetFilledStorageBounds(out min, out max);
MyVoxelMapStorageDefinition def = null;
if (m_selectedVoxel.AsteroidName != null)
{
MyDefinitionManager.Static.TryGetVoxelMapStorageDefinition(m_selectedVoxel.AsteroidName, out def);
}
var origSize = m_selectedVoxel.Size;
var tightSize = max - min + 1;
var storage = new MyOctreeStorage(null, tightSize);
var offset = (storage.Size - tightSize) / 2 + 1;
MyStorageData data = new MyStorageData();
data.Resize(tightSize);
m_selectedVoxel.Storage.ReadRange(data, MyStorageDataTypeFlags.ContentAndMaterial, 0, min, max);
min = offset;
max = offset + tightSize - 1;
storage.WriteRange(data, MyStorageDataTypeFlags.ContentAndMaterial, ref min, ref max);
var newMap = MyWorldGenerator.AddVoxelMap(m_selectedVoxel.StorageName, storage, m_selectedVoxel.WorldMatrix);
m_selectedVoxel.Close();
newMap.Save = true;
if (def == null)
{
ShowAlert("Voxel map {0} does not have a definition, the shrunk voxel map will be saved with the world instead.", m_selectedVoxel.StorageName);
}
else
{
byte[] cVmapData;
newMap.Storage.Save(out cVmapData);
using (var ostream = MyFileSystem.OpenWrite(Path.Combine(MyFileSystem.ContentPath, def.StorageFile), FileMode.Open))
{
ostream.Write(cVmapData, 0, cVmapData.Length);
}
var notification = new MyHudNotification(MyStringId.GetOrCompute("Voxel prefab {0} updated succesfuly (size changed from {1} to {2})."), 4000);
notification.SetTextFormatArguments(def.Id.SubtypeName, origSize, storage.Size);
MyHud.Notifications.Add(notification);
}
}
private void StartNewSandbox()
{
MyLog.Default.WriteLine("StartNewSandbox - Start");
GetSettingsFromControls();
if (!MySteamWorkshop.CheckLocalModsAllowed(m_mods, m_settings.OnlineMode == MyOnlineModeEnum.OFFLINE))
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption: MyTexts.Get(MySpaceTexts.MessageBoxCaptionError),
messageText: MyTexts.Get(MySpaceTexts.DialogTextLocalModsDisabledInMultiplayer),
buttonType: MyMessageBoxButtonsType.OK));
MyLog.Default.WriteLine("LoadSession() - End");
return;
}
MySteamWorkshop.DownloadModsAsync(m_mods, delegate(bool success)
{
if (success || (m_settings.OnlineMode == MyOnlineModeEnum.OFFLINE) && MySteamWorkshop.CanRunOffline(m_mods))
{
MyScreenManager.RemoveAllScreensExcept(null);
if (AsteroidAmount < 0)
{
MyWorldGenerator.SetProceduralSettings(AsteroidAmount, m_settings);
m_asteroidAmount = 0;
}
MyAnalyticsHelper.SetEntry(MyGameEntryEnum.Custom);
MyGuiScreenGamePlay.StartLoading(delegate
{
MySession.Start(
m_nameTextbox.Text,
GetDescription(),
GetPassword(),
m_settings,
m_mods,
new MyWorldGenerator.Args()
{
AsteroidAmount = this.AsteroidAmount,
Scenario = (m_scenarioTypesGroup.SelectedButton as MyGuiControlScenarioButton).Scenario
}
);
});
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption: MyTexts.Get(MySpaceTexts.MessageBoxCaptionError),
messageText: MyTexts.Get(MySpaceTexts.DialogTextDownloadModsFailed),
buttonType: MyMessageBoxButtonsType.OK));
}
MyLog.Default.WriteLine("StartNewSandbox - End");
});
}
private static MyObjectBuilder_SessionSettings CreateBasicQuickStartSettings()
{
var settings = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_SessionSettings>();
settings.GameMode = MyGameModeEnum.Creative;
settings.EnableToolShake = true;
settings.VoxelGeneratorVersion = MyVoxelConstants.VOXEL_GENERATOR_VERSION;
settings.EnableOxygen = true;
MyWorldGenerator.SetProceduralSettings(-1, settings);
return(settings);
}
public override void GenerateObjects(List <MyObjectSeed> objectsList)
{
ProfilerShort.Begin("GenerateObjects");
foreach (var objectSeed in objectsList)
{
if (objectSeed.Generated)
{
continue;
}
objectSeed.Generated = true;
using (MyRandom.Instance.PushSeed(GetObjectIdSeed(objectSeed)))
{
ProfilerShort.Begin("Planet");
var bbox = objectSeed.BoundingVolume;
MyGamePruningStructure.GetAllVoxelMapsInBox(ref bbox, m_tmpVoxelMapsList);
String storageName = string.Format("Planet_{0}_{1}_{2}_{3}_{4}", objectSeed.CellId.X, objectSeed.CellId.Y, objectSeed.CellId.Z, objectSeed.Index, objectSeed.Seed);
bool exists = false;
foreach (var voxelMap in m_tmpVoxelMapsList)
{
if (voxelMap.StorageName == storageName)
{
exists = true;
break;
}
}
m_tmpVoxelMapsList.Clear();
if (!exists)
{
var planet = MyWorldGenerator.AddPlanet(storageName, objectSeed.BoundingVolume.Center - VRageMath.MathHelper.GetNearestBiggerPowerOfTwo(objectSeed.Size) / 2, objectSeed.Seed, objectSeed.Size, GetPlanetEntityId(objectSeed));
if (planet == null)
{
continue;
}
planet.Save = false;
RangeChangedDelegate OnStorageRangeChanged = null;
OnStorageRangeChanged = delegate(Vector3I minVoxelChanged, Vector3I maxVoxelChanged, MyStorageDataTypeFlags changedData)
{
planet.Save = true;
planet.Storage.RangeChanged -= OnStorageRangeChanged;
};
planet.Storage.RangeChanged += OnStorageRangeChanged;
}
ProfilerShort.End();
}
}
ProfilerShort.End();
}
static void SpawnPlanet_Server(string planetName, float size, int seed, Vector3D pos)
{
var storageNameBase = planetName + "-" + seed + "d" + size;
var storageName = MakeStorageName(storageNameBase);
MyWorldGenerator.AddPlanet(storageNameBase, planetName, planetName, pos, seed, size, MyRandom.Instance.NextLong(), userCreated: true);
if (MySession.Static.RequiresDX < 11)
{
MySession.Static.RequiresDX = 11;
}
}
private void SpawnPlanet(int seed, float size, Vector3D?pos = null)
{
var storageNameBase = "Planet" + "-" + seed + "d" + size;
var storageName = MakeStorageName(storageNameBase);
if (pos.HasValue == false)
{
pos = MySession.LocalHumanPlayer.GetPosition();
}
MyWorldGenerator.AddPlanet(storageNameBase, MySession.LocalHumanPlayer.GetPosition(), seed, size, MyRandom.Instance.NextLong(), false);
}
public override void GenerateObjects()
{
var system = MyStarSystemGenerator.Static.StarSystem;
if (system == null || system.CenterObject == null)
{
return;
}
var objs = system.GetAllObjects();
foreach (var obj in objs)
{
if (obj == null)
{
continue;
}
if (obj.Type != MySystemObjectType.PLANET && obj.Type != MySystemObjectType.MOON)
{
continue;
}
MySystemPlanet planet = obj as MySystemPlanet;
if (planet.Generated)
{
continue;
}
var definition = MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(planet.SubtypeId));
if (definition == null)
{
continue;
}
long id = MyRandom.Instance.NextLong();
string name = GetPlanetStorageName(planet);
MyPlanet generatedPlanet = MyWorldGenerator.AddPlanet(name, planet.DisplayName, planet.SubtypeId, planet.CenterPosition - GetPlanetOffset(definition, planet.Diameter), m_seed, (float)planet.Diameter, true, id, false, true);
if (generatedPlanet != null)
{
generatedPlanet.DisplayNameText = planet.DisplayName;
generatedPlanet.AsteroidName = planet.DisplayName;
planet.Generated = true;
planet.EntityId = generatedPlanet.EntityId;
}
}
}
private static MyObjectBuilder_SessionSettings CreateBasicQuickStartSettings()
{
var settings = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_SessionSettings>();
settings.GameMode = MyGameModeEnum.Creative;
settings.EnableStationVoxelSupport = MyPerGameSettings.Game == GameEnum.SE_GAME;
settings.EnableToolShake = true;
settings.EnablePlanets = (MyPerGameSettings.Game == GameEnum.SE_GAME) && MyFakes.ENABLE_PLANETS;
settings.EnableSunRotation = MyPerGameSettings.Game == GameEnum.SE_GAME;
settings.VoxelGeneratorVersion = MyVoxelConstants.VOXEL_GENERATOR_VERSION;
settings.EnableOxygen = true;
MyWorldGenerator.SetProceduralSettings(-1, settings);
return(settings);
}
private void AddVoxelMap(int item, string prefabName, MatrixD matrix, string name, long entityId, Dictionary <byte, byte> modifiers = null)
{
var fileName = MyWorldGenerator.GetVoxelPrefabPath(prefabName);
var storage = MyStorageBase.LoadFromFile(fileName, modifiers);
if (storage == null)
{
return;
}
var voxelMap = MyWorldGenerator.AddVoxelMap(name, storage, matrix, entityId, true);
RegisterVoxelMap(item, voxelMap);
}
IMyVoxelMap IMyVoxelMaps.CreateVoxelMapFromStorageName(string storageName, string prefabVoxelMapName, Vector3D position)
{
var filePath = MyWorldGenerator.GetVoxelPrefabPath(prefabVoxelMapName);
var storage = MyStorageBase.LoadFromFile(filePath);
if (storage == null)
{
return(null);
}
storage.DataProvider = MyCompositeShapeProvider.CreateAsteroidShape(0,
storage.Size.AbsMax() * MyVoxelConstants.VOXEL_SIZE_IN_METRES,
MySession.Static.Settings.VoxelGeneratorVersion);
return(MyWorldGenerator.AddVoxelMap(storageName, storage, position));
}
static void SpawnPlanet_Server(string planetName, float size, int seed, Vector3D pos)
{
if (MySession.Static.CreativeMode || MyEventContext.Current.IsLocallyInvoked || MySession.Static.HasPlayerCreativeRights(MyEventContext.Current.Sender.Value))
{
var storageNameBase = planetName + "-" + seed + "d" + size;
var storageName = MakeStorageName(storageNameBase);
MyWorldGenerator.AddPlanet(storageNameBase, planetName, planetName, pos, seed, size, MyRandom.Instance.NextLong(), userCreated: true);
if (MySession.Static.RequiresDX < 11)
{
MySession.Static.RequiresDX = 11;
}
}
}
public override void GenerateObjects(List <MyObjectSeed> objectsList)
{
ProfilerShort.Begin("GenerateObjects");
foreach (var objectSeed in objectsList)
{
if (objectSeed.Generated)
{
continue;
}
objectSeed.Generated = true;
using (MyRandom.Instance.PushSeed(GetObjectIdSeed(objectSeed)))
{
switch (objectSeed.Type)
{
case MyObjectSeedType.Asteroid:
ProfilerShort.Begin("Asteroid");
var bbox = objectSeed.BoundingVolume;
MyGamePruningStructure.GetAllVoxelMapsInBox(ref bbox, m_tmpVoxelMapsList);
String storageName = string.Format("Asteroid_{0}_{1}_{2}_{3}_{4}", objectSeed.CellId.X, objectSeed.CellId.Y, objectSeed.CellId.Z, objectSeed.Index, objectSeed.Seed);
bool exists = false;
foreach (var voxelMap in m_tmpVoxelMapsList)
{
if (voxelMap.StorageName == storageName)
{
exists = true;
break;
}
}
if (!exists)
{
var provider = MyCompositeShapeProvider.CreateAsteroidShape(objectSeed.Seed, objectSeed.Size, MySession.Static.Settings.VoxelGeneratorVersion);
MyStorageBase storage = new MyOctreeStorage(provider, GetAsteroidVoxelSize(objectSeed.Size));
var voxelMap = MyWorldGenerator.AddVoxelMap(storageName, storage, objectSeed.BoundingVolume.Center - VRageMath.MathHelper.GetNearestBiggerPowerOfTwo(objectSeed.Size) / 2, GetAsteroidEntityId(objectSeed));
if (voxelMap != null)
{
voxelMap.Save = false;
RangeChangedDelegate OnStorageRangeChanged = null;
OnStorageRangeChanged = delegate(Vector3I minVoxelChanged, Vector3I maxVoxelChanged, MyStorageDataTypeFlags changedData)
{
voxelMap.Save = true;
storage.RangeChanged -= OnStorageRangeChanged;
};
storage.RangeChanged += OnStorageRangeChanged;
}
}
m_tmpVoxelMapsList.Clear();
ProfilerShort.End();
break;
case MyObjectSeedType.EncounterAlone:
case MyObjectSeedType.EncounterSingle:
case MyObjectSeedType.EncounterMulti:
ProfilerShort.Begin("Encounter");
MyEncounterGenerator.PlaceEncounterToWorld(objectSeed.BoundingVolume, objectSeed.Seed, objectSeed.Type);
ProfilerShort.End();
break;
default:
throw new InvalidBranchException();
break;
}
}
}
ProfilerShort.End();
}
public override void GenerateObjects(List <MyObjectSeed> objects, HashSet <MyObjectSeedParams> existingObjectSeeds)
{
List <MyVoxelBase> tmp_voxelMaps = new List <MyVoxelBase>();
foreach (var obj in objects)
{
if (obj.Params.Generated)
{
continue;
}
obj.Params.Generated = true;
using (MyRandom.Instance.PushSeed(GetObjectIdSeed(obj)))
{
if (obj.Params.Type != MyObjectSeedType.Asteroid)
{
continue;
}
var bounds = obj.BoundingVolume;
MyGamePruningStructure.GetAllVoxelMapsInBox(ref bounds, tmp_voxelMaps);
string storageName = string.Format("Asteroid_{0}_{1}_{2}_{3}_{4}", obj.CellId.X, obj.CellId.Y, obj.CellId.Z, obj.Params.Index, obj.Params.Seed);
bool exists = false;
foreach (var voxelMap in tmp_voxelMaps)
{
if (voxelMap.StorageName == storageName)
{
if (!existingObjectSeeds.Contains(obj.Params))
{
existingObjectSeeds.Add(obj.Params);
}
exists = true;
break;
}
}
if (!exists)
{
var storage = CreateAsteroidStorage(GetAsteroidVoxelSize(obj.Size), obj.Params.Seed, obj.Size, m_data.UseGeneratorSeed ? obj.Params.GeneratorSeed : 0, 3);
Vector3D pos = obj.BoundingVolume.Center - MathHelper.GetNearestBiggerPowerOfTwo(obj.Size) / 2;
MyVoxelMap voxelMap;
voxelMap = MyWorldGenerator.AddVoxelMap(storageName, storage, pos, GetAsteroidEntityId(storageName));
if (voxelMap == null)
{
continue;
}
voxelMap.Save = true;
m_NotSavedMaps.Add(voxelMap);
MyVoxelBase.StorageChanged OnStorageRangeChanged = null;
OnStorageRangeChanged = delegate(MyVoxelBase voxel, Vector3I minVoxelChanged, Vector3I maxVoxelChanged, MyStorageDataTypeFlags changedData)
{
voxelMap.Save = true;
m_NotSavedMaps.Remove(voxelMap);
voxelMap.RangeChanged -= OnStorageRangeChanged;
};
voxelMap.RangeChanged += OnStorageRangeChanged;
}
tmp_voxelMaps.Clear();
}
}
}
public static bool PlaceEncounterToWorld(BoundingBoxD boundingVolume, int seed, MyObjectSeedType seedType)
{
if (MySession.Static.Settings.EnableEncounters == false)
{
return(false);
}
boundingVolume.Max.X = Math.Round(boundingVolume.Max.X, 2);
boundingVolume.Max.Y = Math.Round(boundingVolume.Max.Y, 2);
boundingVolume.Max.Z = Math.Round(boundingVolume.Max.Z, 2);
boundingVolume.Min.X = Math.Round(boundingVolume.Min.X, 2);
boundingVolume.Min.Y = Math.Round(boundingVolume.Min.Y, 2);
boundingVolume.Min.Z = Math.Round(boundingVolume.Min.Z, 2);
Vector3D placePosition = boundingVolume.Center;
m_random.SetSeed(seed);
if (m_spawnGroups.Count == 0)
{
m_spawnGroupsNoVoxels.Clear();
var allSpawnGroups = MyDefinitionManager.Static.GetSpawnGroupDefinitions();
foreach (var spawnGroup in allSpawnGroups)
{
if (spawnGroup.IsEncounter)
{
m_spawnGroups.Add(spawnGroup);
if (spawnGroup.Voxels.Count == 0)
{
m_spawnGroupsNoVoxels.Add(spawnGroup);
}
}
}
}
if (m_spawnGroups.Count > 0)
{
m_randomEncounters.Clear();
m_placePositions.Clear();
m_encountersId.Clear();
int numEncoutersToPlace = seedType == MyObjectSeedType.EncounterMulti ? 2 : 1;
List <MySpawnGroupDefinition> currentSpawnGroup = seedType == MyObjectSeedType.EncounterMulti ? m_spawnGroupsNoVoxels : m_spawnGroups;
for (int i = 0; i < numEncoutersToPlace; ++i)
{
MyEncounterId encounterPosition = new MyEncounterId(boundingVolume, seed, i);
if (true == m_savedEncounters.Contains(encounterPosition))
{
continue;
}
m_randomEncounters.Add(PickRandomEncounter(currentSpawnGroup));
Vector3D newPosition = placePosition + (i == 0 ? -1 : 1) * GetEncounterBoundingBox(currentSpawnGroup[m_randomEncounters[m_randomEncounters.Count - 1]]).HalfExtents;
Vector3D savedPosition = Vector3D.Zero;
if (true == m_movedOnlyEncounters.Dictionary.TryGetValue(encounterPosition, out savedPosition))
{
newPosition = savedPosition;
}
encounterPosition.PlacePosition = newPosition;
m_encountersId.Add(encounterPosition);
m_placePositions.Add(newPosition);
}
//first place voxels becaose voxel needs to be created even on client and if grids were created first
//entity ids woudn't match
for (int i = 0; i < m_randomEncounters.Count; ++i)
{
foreach (var selectedVoxel in currentSpawnGroup[m_randomEncounters[i]].Voxels)
{
var filePath = MyWorldGenerator.GetVoxelPrefabPath(selectedVoxel.StorageName);
var storage = MyStorageBase.LoadFromFile(filePath);
storage.DataProvider = MyCompositeShapeProvider.CreateAsteroidShape(0, 1.0f, MySession.Static.Settings.VoxelGeneratorVersion);
IMyEntity voxel = MyWorldGenerator.AddVoxelMap(String.Format("Asteroid_{0}_{1}_{2}", m_entityToEncounterConversion.Count, seed, m_random.Next()), storage, m_placePositions[i] + selectedVoxel.Offset);
voxel.Save = false;
voxel.OnPhysicsChanged += OnCreatedEntityChanged;
m_entityToEncounterConversion[voxel] = m_encountersId[i];
}
}
if (Sync.IsServer == true)
{
for (int i = 0; i < m_randomEncounters.Count; ++i)
{
SpawnEncouter(m_encountersId[i], m_placePositions[i], currentSpawnGroup, m_randomEncounters[i]);
}
}
}
return(true);
}
// Backward compatibility method only used when the procedurally generated asteroids were not working
private static void AddPregeneratedAsteroid(string name, float scale)
{
Vector3 position = m_compatStaticAsteroids[name] * scale;
MyWorldGenerator.AddAsteroidPrefab("Pregen\\" + name, position, name);
}
public void GeneratePlanets()
{
foreach (var obj in SystemGenerator.Static.m_objects)
{
if (obj == null)
{
continue;
}
if (obj.Type != SystemObjectType.PLANET)
{
continue;
}
MyPlanetItem planet = (MyPlanetItem)obj;
if (planet.Generated)
{
continue;
}
MyPlanetGeneratorDefinition definition = GetDefinition(planet.DefName);
if (definition == null)
{
continue;
}
long id = MyRandom.Instance.NextLong();
string name = (planet.DisplayName + " - " + definition.Id.SubtypeId).Replace(" ", "_");
if (planet.CenterPosition.Equals(Vector3D.Zero))
{
planet.CenterPosition = planet.OffsetPosition;
}
MyPlanet generatedPlanet = MyWorldGenerator.AddPlanet(name, planet.DisplayName, planet.DefName, planet.CenterPosition - GetPlanetOffset(definition, planet.Size), m_seed, planet.Size, true, id, false, true);
if (generatedPlanet == null)
{
continue;
}
planet.CenterPosition = generatedPlanet.PositionComp.GetPosition();
generatedPlanet.DisplayNameText = planet.DisplayName;
generatedPlanet.AsteroidName = planet.DisplayName;
if (planet.PlanetRing != null)
{
planet.PlanetRing.Center = planet.CenterPosition;
}
List <Vector3D> spawnedMoons = new List <Vector3D>();
for (int i = 0; i < planet.PlanetMoons.Length; i++)
{
MyPlanetMoonItem moon = planet.PlanetMoons[i];
if (moon == null)
{
continue;
}
MyPlanetGeneratorDefinition moonDef = GetDefinition(moon.DefName);
if (moonDef == null)
{
continue;
}
var position = new Vector3D(0, 0, 0);
long mId = MyRandom.Instance.NextLong();
string storageNameMoon = ("Moon " + moon.DisplayName + " - " + moonDef.Id.SubtypeId).Replace(" ", "_");
var threshold = 0;
do
{
double angle = MyRandom.Instance.GetRandomFloat(0, (float)Math.PI * 2f);
position = new Vector3D(moon.Distance * Math.Sin(angle), moon.Distance * Math.Cos(angle), moon.Distance * Math.Sin(MyRandom.Instance.GetRandomFloat((float)-Math.PI / 2, (float)Math.PI / 2)));
position = Vector3D.Add(planet.CenterPosition, position);
threshold++;
} while (ObstructedPlace(position, spawnedMoons, planet.Size, planet.PlanetRing) && threshold < 10000);
MyPlanet spawnedMoon = MyWorldGenerator.AddPlanet(storageNameMoon, moon.DisplayName, moon.DefName, position, m_seed, moon.Size, true, mId, false, true);
spawnedMoons.Add(spawnedMoon.PositionComp.GetPosition());
if (SettingsSession.Static.Settings.GeneratorSettings.PlanetSettings.ShowMoonGPS)
{
GlobalGpsManager.Static.AddGps(moon.DisplayName, Color.Aqua, spawnedMoon.PositionComp.GetPosition());
}
}
planet.Generated = true;
if (SettingsSession.Static.Settings.GeneratorSettings.PlanetSettings.ShowPlanetGPS)
{
GlobalGpsManager.Static.AddGps(planet.DisplayName, Color.Aqua, generatedPlanet.PositionComp.GetPosition());
}
}
}
public override void GenerateLoadedCellObjects()
{
List <MyObjectSeed> seeds = new List <MyObjectSeed>();
foreach (var cell in m_loadedCells.Values)
{
cell.GetAll(seeds, false);
}
List <MyVoxelBase> tmp_voxelMaps = new List <MyVoxelBase>();
foreach (var seed in seeds)
{
if (seed.Params.Generated)
{
continue;
}
if (seed.Params.Type != VRage.Game.MyObjectSeedType.Asteroid)
{
continue;
}
seed.Params.Generated = true;
using (MyRandom.Instance.PushSeed(GetObjectIdSeed(seed)))
{
tmp_voxelMaps.Clear();
var bounds = seed.BoundingVolume;
MyGamePruningStructure.GetAllVoxelMapsInBox(ref bounds, tmp_voxelMaps);
string storageName = string.Format("Asteroid_{0}_{1}_{2}_{3}_{4}", seed.CellId.X, seed.CellId.Y, seed.CellId.Z, seed.Params.Index, seed.Params.Seed);
bool exists = false;
foreach (var tmp in tmp_voxelMaps)
{
if (tmp.StorageName == storageName)
{
if (!m_existingObjectSeeds.Contains(seed))
{
m_existingObjectSeeds.Add(seed);
}
exists = true;
if (tmp_voxelMaps.Contains(tmp))
{
tmp.Save = true;
}
break;
}
}
if (exists)
{
continue;
}
var storage = CreateAsteroidStorage(GetAsteroidVoxelSize(seed.Size), seed.Params.Seed, seed.Size, m_definition.UseGeneratorSeed ? seed.Params.GeneratorSeed : 0);
Vector3D pos = seed.BoundingVolume.Center - MathHelper.GetNearestBiggerPowerOfTwo(seed.Size) / 2;
MyVoxelMap voxelMap;
voxelMap = MyWorldGenerator.AddVoxelMap(storageName, storage, pos, GetAsteroidEntityId(storageName));
if (voxelMap == null)
{
continue;
}
MyVoxelBase.StorageChanged del = null;
del = delegate(MyVoxelBase voxel, Vector3I minVoxelChanged, Vector3I maxVoxelChanged, MyStorageDataTypeFlags changedData)
{
voxel.Save = true;
m_tmpAsteroids.Remove(voxel);
voxel.RangeChanged -= del;
};
voxelMap.RangeChanged += del;
voxelMap.IsSeedOpen = true;
seed.UserData = voxelMap;
m_tmpAsteroids.Add(voxelMap);
}
}
}
public override void GenerateObjects(List <MyObjectSeed> objectsList, HashSet <MyObjectSeedParams> existingObjectsSeeds)
{
ProfilerShort.Begin("GenerateObjects");
foreach (var objectSeed in objectsList)
{
if (objectSeed.Params.Generated || existingObjectsSeeds.Contains(objectSeed.Params))
{
continue;
}
objectSeed.Params.Generated = true;
using (MyRandom.Instance.PushSeed(GetObjectIdSeed(objectSeed)))
{
switch (objectSeed.Params.Type)
{
case MyObjectSeedType.Asteroid:
ProfilerShort.Begin("Asteroid");
var bbox = objectSeed.BoundingVolume;
MyGamePruningStructure.GetAllVoxelMapsInBox(ref bbox, m_tmpVoxelMapsList);
String storageName = string.Format("Asteroid_{0}_{1}_{2}_{3}_{4}", objectSeed.CellId.X, objectSeed.CellId.Y, objectSeed.CellId.Z, objectSeed.Params.Index, objectSeed.Params.Seed);
bool exists = false;
foreach (var voxelMap in m_tmpVoxelMapsList)
{
if (voxelMap.StorageName == storageName)
{
existingObjectsSeeds.Add(objectSeed.Params);
exists = true;
break;
}
}
if (!exists)
{
var provider = MyCompositeShapeProvider.CreateAsteroidShape(objectSeed.Params.Seed, objectSeed.Size, MySession.Static.Settings.VoxelGeneratorVersion);
MyStorageBase storage = new MyOctreeStorage(provider, GetAsteroidVoxelSize(objectSeed.Size));
var voxelMap = MyWorldGenerator.AddVoxelMap(storageName, storage, objectSeed.BoundingVolume.Center - VRageMath.MathHelper.GetNearestBiggerPowerOfTwo(objectSeed.Size) / 2, GetAsteroidEntityId(storageName));
if (voxelMap != null)
{
voxelMap.Save = false;
MyVoxelBase.StorageChanged OnStorageRangeChanged = null;
OnStorageRangeChanged = delegate(MyVoxelBase voxel, Vector3I minVoxelChanged, Vector3I maxVoxelChanged, MyStorageDataTypeFlags changedData)
{
voxelMap.Save = true;
voxelMap.RangeChanged -= OnStorageRangeChanged;
};
voxelMap.RangeChanged += OnStorageRangeChanged;
}
}
m_tmpVoxelMapsList.Clear();
ProfilerShort.End();
break;
case MyObjectSeedType.EncounterAlone:
case MyObjectSeedType.EncounterSingle:
case MyObjectSeedType.EncounterMulti:
ProfilerShort.Begin("Encounter");
bool doSpawn = true;
foreach (var start in MySession.Static.Scenario.PossiblePlayerStarts)
{
Vector3D?startPos = start.GetStartingLocation();
if (!startPos.HasValue)
{
startPos = Vector3D.Zero;
}
if ((startPos.Value - objectSeed.BoundingVolume.Center).LengthSquared() < (15000 * 15000))
{
doSpawn = false;
}
}
if (doSpawn)
{
MyEncounterGenerator.PlaceEncounterToWorld(objectSeed.BoundingVolume, objectSeed.Params.Seed, objectSeed.Params.Type);
}
ProfilerShort.End();
break;
default:
throw new InvalidBranchException();
break;
}
}
}
ProfilerShort.End();
}
