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(); }