public static void AddPlanetPrefab(string prefabName, string name)
{
DictionaryValuesReader <MyDefinitionId, MyPlanetPrefabDefinition> planetDefinitions = MyDefinitionManager.Static.GetPlanetsPrefabsDefinitions();
foreach (var planetPrebabDefinition in planetDefinitions)
{
if (planetPrebabDefinition.Id.SubtypeName == prefabName)
{
var voxelMap = new MyPlanet();
var ob = planetPrebabDefinition.PlanetBuilder;
string storageName = MyFileSystem.ContentPath + "\\VoxelMaps\\" + ob.StorageName + MyVoxelConstants.FILE_EXTENSION;
voxelMap.EntityId = ob.EntityId;
MyPlanetInitArguments planetInitArguments;
planetInitArguments.StorageName = ob.StorageName;
planetInitArguments.Storage = MyStorageBase.LoadFromFile(storageName);
planetInitArguments.PositionMinCorner = ob.PositionAndOrientation.Value.Position;
planetInitArguments.AveragePlanetRadius = ob.Radius;
planetInitArguments.AtmosphereRadius = ob.AtmosphereRadius;
planetInitArguments.MaximumHillRadius = ob.MaximumHillRadius;
planetInitArguments.MinimumSurfaceRadius = ob.MinimumSurfaceRadius;
planetInitArguments.HasAtmosphere = ob.HasAtmosphere;
planetInitArguments.AtmosphereWavelengths = ob.AtmosphereWavelengths;
planetInitArguments.MaxOxygen = ob.MaximumOxygen;
planetInitArguments.GravityFalloff = ob.GravityFalloff;
planetInitArguments.MarkAreaEmpty = true;
voxelMap.Init(planetInitArguments);
MyEntities.Add(voxelMap);
}
}
}
public override void Init(MyObjectBuilder_EntityBase builder)
{
var ob = (MyObjectBuilder_VoxelMap)builder;
if (ob == null)
{
return;
}
m_storage = MyStorageBase.Load(ob.StorageName);
//By Gregory: Added for compatibility with old saves
if (m_storage == null)
{
return;
}
Init(builder, m_storage);
if (ob.ContentChanged.HasValue)
{
ContentChanged = ob.ContentChanged.Value;
}
else
{
ContentChanged = true;
}
}
/// <summary>
/// Gets the uncompressed, gzip-wrapped storage data for a given voxel map.
/// </summary>
/// <param name="storage"></param>
/// <param name="data"></param>
private static void SaveUncompressed(MyStorageBase storage, out byte[] data)
{
if (storage.CachedWrites)
{
storage.WritePending(true);
}
using (var ms = new MemoryStream(0x8000))
using (var gz = new GZipStream(ms, CompressionLevel.NoCompression))
using (var bf = new BufferedStream(gz, 0x8000))
{
string name;
int version;
if (storage is MyOctreeStorage)
{
name = "Octree";
version = 1;
}
else
{
throw new InvalidBranchException("Keen what are you DOING");
}
bf.WriteNoAlloc(name);
bf.Write7BitEncodedInt(version);
_saveInternal(storage, bf);
bf.Flush();
gz.Flush();
data = ms.ToArray();
}
}
public override void Init(MyObjectBuilder_EntityBase builder)
{
var ob = (MyObjectBuilder_VoxelMap)builder;
if (ob == null)
{
return;
}
m_storage = MyStorageBase.Load(ob.StorageName);
if (m_storage == null)
{
throw new Exception("Voxel storage not found: " + ob.StorageName);
}
Init(builder, m_storage);
if (ob.ContentChanged.HasValue)
{
ContentChanged = ob.ContentChanged.Value;
}
else
{
ContentChanged = true;
}
}
public override void Init(MyObjectBuilder_EntityBase builder)
{
ProfilerShort.Begin("base init");
SyncFlag = true;
base.Init(builder);
base.Init(null, null, null, null, null);
ProfilerShort.BeginNextBlock("Load file");
var ob = (MyObjectBuilder_VoxelMap)builder;
if (ob == null)
{
return;
}
if (ob.MutableStorage)
{
StorageName = ob.StorageName;
}
else
{
StorageName = string.Format("{0}-{1}", ob.StorageName, m_immutableStorageNameSalt++);
}
m_storage = MyStorageBase.Load(ob.StorageName);
m_storage.RangeChanged += storage_RangeChanged;
m_storageMax = m_storage.Size;
InitVoxelMap(ob.PositionAndOrientation.Value.Position, m_storage.Size);
ProfilerShort.End();
}
public static MyVoxelMap AddVoxelMap(string storageName, MyStorageBase storage, Vector3 positionMinCorner, long entityId = 0)
{
var voxelMap = new MyVoxelMap();
voxelMap.EntityId = entityId;
voxelMap.Init(storageName, storage, positionMinCorner);
MyEntities.Add(voxelMap);
return(voxelMap);
}
public static MyVoxelMap AddVoxelMap(string storageName, MyStorageBase storage, MatrixD worldMatrix, long entityId = 0)
{
var voxelMap = new MyVoxelMap();
voxelMap.EntityId = entityId;
voxelMap.Init(storageName, storage, worldMatrix);
MyEntities.Add(voxelMap);
MyEntities.RaiseEntityCreated(voxelMap);
return(voxelMap);
}
public static MyStorageBase LoadRandomizedVoxelMapPrefab(string prefabFilePath)
{
var storage = MyStorageBase.LoadFromFile(prefabFilePath);
storage.DataProvider = MyCompositeShapeProvider.CreateAsteroidShape(
MyUtils.GetRandomInt(int.MaxValue - 1) + 1,
storage.Size.AbsMax() * MyVoxelConstants.VOXEL_SIZE_IN_METRES,
MySession.Static.Settings.VoxelGeneratorVersion);
storage.Reset(MyStorageDataTypeFlags.Material);
return(storage);
}
public void Init(MyStorageBase storage, bool isStorageMutable)
{
Flags |= EntityFlags.NeedsUpdate10;
SyncFlag = true;
base.Init(null);
m_storage = new MyProxyStorage(isStorageMutable, storage);
InitVoxelMap(Vector3.Zero);
NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
public void Clear()
{
foreach (var entry in m_voxelMapsByEntityId)
{
entry.Value.Close();
}
MyStorageBase.ResetCache();
m_voxelMapsByEntityId.Clear();
m_renderComponentsByClipmapId.Clear();
}
internal bool TryGetStorage(string name, out MyStorageBase result)
{
MyStringId id;
if (MyStringId.TryGet(name, out id))
{
return(m_storageByName.TryGetValue(id, out result));
}
result = null;
return(false);
}
public override void Init(MyObjectBuilder_EntityBase builder)
{
if (MyFakes.ENABLE_PLANETS == false)
{
throw new PlanetsNotEnabledException();
}
ProfilerShort.Begin("base init");
SyncFlag = true;
base.Init(builder);
base.Init(null, null, null, null, null);
ProfilerShort.BeginNextBlock("Load file");
var ob = (MyObjectBuilder_Planet)builder;
if (ob == null)
{
return;
}
if (ob.MutableStorage)
{
StorageName = ob.StorageName;
}
else
{
StorageName = string.Format("{0}", ob.StorageName);
}
m_savedEnviromentSectors = ob.SavedEnviromentSectors;
m_planetInitValues.StorageName = StorageName;
m_planetInitValues.Storage = MyStorageBase.Load(ob.StorageName);
m_planetInitValues.PositionMinCorner = ob.PositionAndOrientation.Value.Position;
m_planetInitValues.AveragePlanetRadius = ob.Radius;
m_planetInitValues.AtmosphereRadius = ob.AtmosphereRadius;
m_planetInitValues.MaximumHillRadius = ob.MaximumHillRadius;
m_planetInitValues.MinimumSurfaceRadius = ob.MinimumSurfaceRadius;
m_planetInitValues.HasAtmosphere = ob.HasAtmosphere;
m_planetInitValues.AtmosphereWavelengths = ob.AtmosphereWavelengths;
m_planetInitValues.MaxOxygen = ob.MaximumOxygen;
m_planetInitValues.GravityFalloff = ob.GravityFalloff;
m_planetInitValues.MarkAreaEmpty = ob.MarkAreaEmpty;
Init(m_planetInitValues);
ProfilerShort.End();
}
protected override void OnLoad(BitStream stream, Action <MyVoxelBase> loadingDoneHandler)
{
MyVoxelBase map = null;
bool isFromPrefab = VRage.Serialization.MySerializer.CreateAndRead <bool>(stream);
bool rangeChanged = VRage.Serialization.MySerializer.CreateAndRead <bool>(stream);
byte[] data = null;
if (rangeChanged)
{
data = VRage.Serialization.MySerializer.CreateAndRead <byte[]>(stream);
}
if (isFromPrefab)
{
var builder = VRage.Serialization.MySerializer.CreateAndRead <MyObjectBuilder_EntityBase>(stream, MyObjectBuilderSerializer.Dynamic);
var voxelMap = new MyVoxelMap();
if (rangeChanged && data != null)
{
IMyStorage storage = MyStorageBase.Load(data);
MyEntity entity;
if (MyEntities.TryGetEntityById(builder.EntityId, out entity) && entity is MyVoxelMap)
{
voxelMap = (entity as MyVoxelMap);
voxelMap.Storage = storage;
}
else
{
voxelMap.Init(builder, storage);
MyEntities.Add(voxelMap);
}
}
else
{
voxelMap.Init(builder);
MyEntities.Add(voxelMap);
}
map = voxelMap;
}
else
{
long voxelMapId = VRage.Serialization.MySerializer.CreateAndRead <long>(stream);
MyEntity entity = null;
MyEntities.TryGetEntityById(voxelMapId, out entity);
map = entity as MyVoxelBase;
}
loadingDoneHandler(map);
}
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));
}
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);
}
public static MyVoxelMap AddVoxelMap(string storageName, MyStorageBase storage, Vector3D positionMinCorner, long entityId = 0)
{
var voxelMap = new MyVoxelMap();
if (entityId != 0)
{
voxelMap.EntityId = entityId;
}
voxelMap.Init(storageName, storage, positionMinCorner);
MyEntities.RaiseEntityCreated(voxelMap);
MyEntities.Add(voxelMap);
voxelMap.IsReadyForReplication = true;
return(voxelMap);
}
public static MyVoxelMap AddVoxelMap(string storageName, MyStorageBase storage, MatrixD worldMatrix, long entityId = 0, bool lazyPhysics = false)
{
ProfilerShort.Begin("AddVoxelMap");
var voxelMap = new MyVoxelMap();
if (entityId != 0)
{
voxelMap.EntityId = entityId;
}
voxelMap.DelayRigidBodyCreation = lazyPhysics;
voxelMap.Init(storageName, storage, worldMatrix);
MyEntities.Add(voxelMap);
MyEntities.RaiseEntityCreated(voxelMap);
ProfilerShort.End();
return(voxelMap);
}
//[TestMethod]
public void LoadOthe3r()
{
var filename = @"D:\Program Files (x86)\Steam\SteamApps\common\SpaceEngineers\Content\VoxelMaps\Arabian_Border_7.vx2";
var storage = MyStorageBase.LoadFromFile(filename);
//byte[] buffer;
//using (var ms = new FileStream(filename, FileMode.Open))
//{
// using (var reader = new BinaryReader(ms))
// {
// buffer = reader.ReadBytes((int)reader.BaseStream.Length);
// }
//}
//var storage = MyStorageBase.Load(buffer);
}
public static MyStorageBase CreateAsteroidStorage(string asteroid, int randomSeed)
{
MyVoxelMapStorageDefinition definition;
if (MyDefinitionManager.Static.TryGetVoxelMapStorageDefinition(asteroid, out definition))
{
if (definition.Context.IsBaseGame)
{
return(MyStorageBase.LoadFromFile(Path.Combine(MyFileSystem.ContentPath, definition.StorageFile)));
}
else
{
return(MyStorageBase.LoadFromFile(definition.StorageFile));
}
}
return(null);
}
public static void AddPlanetPrefab(string planetName, string definitionName, Vector3D position, bool addGPS)
{
DictionaryValuesReader <MyDefinitionId, MyPlanetPrefabDefinition> planetPrefabDefinitions = MyDefinitionManager.Static.GetPlanetsPrefabsDefinitions();
foreach (var planetPrefabDefinition in planetPrefabDefinitions)
{
if (planetPrefabDefinition.Id.SubtypeName == planetName)
{
MyPlanetGeneratorDefinition planetDefinition = MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(definitionName));
var planet = new MyPlanet();
var ob = planetPrefabDefinition.PlanetBuilder;
string storageName = MyFileSystem.ContentPath + "\\VoxelMaps\\" + ob.StorageName + MyVoxelConstants.FILE_EXTENSION;
planet.EntityId = ob.EntityId;
MyPlanetInitArguments planetInitArguments;
planetInitArguments.StorageName = ob.StorageName;
planetInitArguments.Storage = MyStorageBase.LoadFromFile(storageName);
planetInitArguments.PositionMinCorner = position;
planetInitArguments.Radius = ob.Radius;
planetInitArguments.AtmosphereRadius = ob.AtmosphereRadius;
planetInitArguments.MaxRadius = ob.MaximumHillRadius;
planetInitArguments.MinRadius = ob.MinimumSurfaceRadius;
planetInitArguments.HasAtmosphere = planetDefinition.HasAtmosphere;
planetInitArguments.AtmosphereWavelengths = ob.AtmosphereWavelengths;
planetInitArguments.GravityFalloff = planetDefinition.GravityFalloffPower;
planetInitArguments.MarkAreaEmpty = true;
planetInitArguments.AtmosphereSettings = ob.AtmosphereSettings.HasValue ? ob.AtmosphereSettings.Value : MyAtmosphereSettings.Defaults();
planetInitArguments.SurfaceGravity = planetDefinition.SurfaceGravity;
planetInitArguments.AddGps = addGPS;
planetInitArguments.SpherizeWithDistance = true;
planetInitArguments.Generator = planetDefinition;
planetInitArguments.UserCreated = false;
planetInitArguments.InitializeComponents = true;
planet.Init(planetInitArguments);
MyEntities.Add(planet);
MyEntities.RaiseEntityCreated(planet);
}
}
}
public static void RecreateAsteroidBeforePaste(float dragVectorLength)
{
var seed = m_lastAsteroidInfo.RandomSeed;
var radius = m_lastAsteroidInfo.ProceduralRadius;
var storageNameBase = "ProcAsteroid" + "-" + seed + "r" + radius;
var storageName = MyGuiScreenDebugSpawnMenu.MakeStorageName(storageNameBase);
MyStorageBase storage = null;
if (m_lastAsteroidInfo.IsProcedural)
{
storage = CreateProceduralAsteroidStorage(seed, radius);
}
else
{
storage = CreateAsteroidStorage(m_lastAsteroidInfo.Asteroid, seed);
}
var builder = CreateAsteroidObjectBuilder(storageName);
MyClipboardComponent.Static.ActivateVoxelClipboard(builder, storage, MySector.MainCamera.ForwardVector, dragVectorLength);
}
public override void Init(MyObjectBuilder_EntityBase builder)
{
var ob = (MyObjectBuilder_VoxelMap)builder;
if (ob == null)
{
return;
}
m_storage = MyStorageBase.Load(ob.StorageName);
Init(builder, m_storage);
if (ob.ContentChanged.HasValue)
{
ContentChanged = ob.ContentChanged.Value;
}
else
{
ob.ContentChanged = true;
}
}
private void ResavePrefabs(MyGuiControlButton sender)
{
var fileList = MyFileSystem.GetFiles(
MyFileSystem.ContentPath,
//Path.Combine(MyFileSystem.ContentPath, "VoxelMaps"),
"*" + MyVoxelConstants.FILE_EXTENSION,
SearchOption.AllDirectories).ToArray();
for (int i = 0; i < fileList.Length; ++i)
{
var file = fileList[i];
Debug.WriteLine(string.Format("Resaving [{0}/{1}] '{2}'", i + 1, fileList.Length, file));
var storage = MyStorageBase.LoadFromFile(file);
byte[] savedData;
storage.Save(out savedData);
using (var stream = MyFileSystem.OpenWrite(file, System.IO.FileMode.Open))
{
stream.Write(savedData, 0, savedData.Length);
}
}
Debug.WriteLine("Saving prefabs finished.");
}
public override void Init(MyObjectBuilder_EntityBase builder, Sandbox.Engine.Voxels.IMyStorage storage)
{
ProfilerShort.Begin("MyPlanet::Init()");
if (MyFakes.ENABLE_PLANETS == false)
{
throw new PlanetsNotEnabledException();
}
ProfilerShort.Begin("MyVoxelBase Init");
SyncFlag = true;
base.Init(builder);
ProfilerShort.BeginNextBlock("Load Saved Data");
var ob = (MyObjectBuilder_Planet)builder;
if (ob == null)
{
return;
}
MyLog.Default.WriteLine("Planet init info - MutableStorage:" + ob.MutableStorage + " StorageName:" + ob.StorageName + " storage?:" + (storage != null).ToString());
if (ob.MutableStorage)
{
StorageName = ob.StorageName;
}
else
{
StorageName = string.Format("{0}", ob.StorageName);
}
m_planetInitValues.StorageName = StorageName;
m_planetInitValues.PositionMinCorner = ob.PositionAndOrientation.Value.Position;
m_planetInitValues.HasAtmosphere = ob.HasAtmosphere;
m_planetInitValues.AtmosphereRadius = ob.AtmosphereRadius;
m_planetInitValues.AtmosphereWavelengths = ob.AtmosphereWavelengths;
m_planetInitValues.GravityFalloff = ob.GravityFalloff;
m_planetInitValues.MarkAreaEmpty = ob.MarkAreaEmpty;
m_planetInitValues.SurfaceGravity = ob.SurfaceGravity;
m_planetInitValues.AddGps = ob.ShowGPS;
m_planetInitValues.SpherizeWithDistance = ob.SpherizeWithDistance;
m_planetInitValues.Generator = ob.PlanetGenerator == ""
? null
: MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(
MyStringHash.GetOrCompute(ob.PlanetGenerator));
if (m_planetInitValues.Generator == null)
{
string message = string.Format("No definition found for planet generator {0}.", ob.PlanetGenerator);
MyLog.Default.WriteLine(message);
throw new MyIncompatibleDataException(message);
}
m_planetInitValues.AtmosphereSettings = m_planetInitValues.Generator.AtmosphereSettings.HasValue
? m_planetInitValues.Generator.AtmosphereSettings.Value
: MyAtmosphereSettings.Defaults();
m_planetInitValues.UserCreated = false;
ProfilerShort.BeginNextBlock("Load Storage");
if (storage != null)
{
m_planetInitValues.Storage = storage;
}
else
{
m_planetInitValues.Storage = MyStorageBase.Load(ob.StorageName);
if (m_planetInitValues.Storage == null)
{
string message = string.Format("No storage loaded for planet {0}.", ob.StorageName);
MyLog.Default.WriteLine(message);
throw new MyIncompatibleDataException(message);
}
}
m_planetInitValues.InitializeComponents = false;
ProfilerShort.BeginNextBlock("Init Internal");
// MZ: if any crashes are related to MP planet init in the future, i added logging of MyPlanetInitArguments and other sanity checks.
// we are currently having crashes without this additional info and it is likely that even after my hotfixes it is going to crash again
// ...but we can check the logs and know the setup of the player :)
MyLog.Default.Log(MyLogSeverity.Info, "Planet generator name: {0}", ob.PlanetGenerator ?? "<null>");
// Initialize!
Init(m_planetInitValues);
ProfilerShort.End();
ProfilerShort.End();
}
public void Add(MyStorageBase storage)
{
StorageData sdata = new StorageData(storage);
m_storagesWithCache.Add(sdata);
}
public void Remove(MyStorageBase storage)
{
// this works because magic
m_storagesWithCache.Remove(new StorageData(storage));
}
public override void Init(MyObjectBuilder_EntityBase builder, Sandbox.Engine.Voxels.IMyStorage storage)
{
ProfilerShort.Begin("MyPlanet::Init()");
if (MyFakes.ENABLE_PLANETS == false)
{
throw new PlanetsNotEnabledException();
}
ProfilerShort.Begin("MyVoxelBase Init");
SyncFlag = true;
base.Init(builder);
ProfilerShort.BeginNextBlock("Load Saved Data");
var ob = (MyObjectBuilder_Planet)builder;
if (ob == null)
{
return;
}
if (ob.MutableStorage)
{
StorageName = ob.StorageName;
}
else
{
StorageName = string.Format("{0}", ob.StorageName);
}
m_planetInitValues.StorageName = StorageName;
m_planetInitValues.PositionMinCorner = ob.PositionAndOrientation.Value.Position;
m_planetInitValues.HasAtmosphere = ob.HasAtmosphere;
m_planetInitValues.AtmosphereRadius = ob.AtmosphereRadius;
m_planetInitValues.AtmosphereWavelengths = ob.AtmosphereWavelengths;
m_planetInitValues.GravityFalloff = ob.GravityFalloff;
m_planetInitValues.MarkAreaEmpty = ob.MarkAreaEmpty;
m_planetInitValues.SurfaceGravity = ob.SurfaceGravity;
m_planetInitValues.AddGps = ob.ShowGPS;
m_planetInitValues.SpherizeWithDistance = ob.SpherizeWithDistance;
m_planetInitValues.Generator = ob.PlanetGenerator == "" ? null : MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(ob.PlanetGenerator));
if (m_planetInitValues.Generator == null)
{
string message = string.Format("No definition found for planet generator {0}.", ob.PlanetGenerator);
MyLog.Default.WriteLine(message);
throw new Exception(message);
}
m_planetInitValues.AtmosphereSettings = m_planetInitValues.Generator.AtmosphereSettings.HasValue ? m_planetInitValues.Generator.AtmosphereSettings.Value : MyAtmosphereSettings.Defaults();
m_planetInitValues.UserCreated = false;
ProfilerShort.BeginNextBlock("Load Storage");
if (storage != null)
{
m_planetInitValues.Storage = storage;
}
else
{
m_planetInitValues.Storage = MyStorageBase.Load(ob.StorageName);
}
ProfilerShort.BeginNextBlock("Init Internal");
Init(m_planetInitValues);
ProfilerShort.End();
ProfilerShort.End();
}
public StorageData(MyStorageBase storage)
{
Storage = storage;
}
IMyStorage IMyVoxelMaps.CreateStorage(byte[] data)
{
return(MyStorageBase.Load(data));
}
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);
}
