protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var materialBuilder = builder as MyObjectBuilder_TransparentMaterialDefinition;
MyDebug.AssertDebug(materialBuilder != null, "Initializing transparent material definition using wrong object builder.");
Texture = materialBuilder.Texture;
TextureType = materialBuilder.TextureType;
CanBeAffectedByLights = materialBuilder.CanBeAffectedByOtherLights;
AlphaMistingEnable = materialBuilder.AlphaMistingEnable;
IgnoreDepth = materialBuilder.IgnoreDepth;
NeedSort = materialBuilder.NeedSort;
UseAtlas = materialBuilder.UseAtlas;
AlphaMistingStart = materialBuilder.AlphaMistingStart;
AlphaMistingEnd = materialBuilder.AlphaMistingEnd;
SoftParticleDistanceScale = materialBuilder.SoftParticleDistanceScale;
Emissivity = materialBuilder.Emissivity;
AlphaSaturation = materialBuilder.AlphaSaturation;
Reflection = materialBuilder.Reflection;
Reflectivity = materialBuilder.Reflectivity;
Color = materialBuilder.Color;
AlphaCutout = materialBuilder.AlphaCutout;
TargetSize = materialBuilder.TargetSize;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_OreDetectorDefinition;
ResourceSinkGroup = MyStringHash.GetOrCompute(ob.ResourceSinkGroup);
MaximumRange = ob.MaximumRange;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var objectBuilder = builder as MyObjectBuilder_EntityStatDefinition;
MinValue = objectBuilder.MinValue;
MaxValue = objectBuilder.MaxValue;
DefaultValue = objectBuilder.DefaultValue;
EnabledInCreative = objectBuilder.EnabledInCreative;
Name = objectBuilder.Name;
if (float.IsNaN(DefaultValue)) DefaultValue = MaxValue;
GuiDef = new GuiDefinition();
if (objectBuilder.GuiDef != null)
{
GuiDef.HeightMultiplier = objectBuilder.GuiDef.HeightMultiplier;
GuiDef.Priority = objectBuilder.GuiDef.Priority;
GuiDef.Color = objectBuilder.GuiDef.Color;
GuiDef.CriticalRatio = objectBuilder.GuiDef.CriticalRatio;
GuiDef.DisplayCriticalDivider = objectBuilder.GuiDef.DisplayCriticalDivider;
GuiDef.CriticalColorFrom = objectBuilder.GuiDef.CriticalColorFrom;
GuiDef.CriticalColorTo = objectBuilder.GuiDef.CriticalColorTo;
}
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = (MyObjectBuilder_MissileLauncherDefinition)builder;
ProjectileMissile = ob.ProjectileMissile;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_VoxelHandDefinition;
MyDebug.AssertDebug(ob != null);
}
protected override void Init(MyObjectBuilder_DefinitionBase ob)
{
base.Init(ob);
var builder = ob as MyObjectBuilder_VoxelMaterialDefinition;
MyDebug.AssertDebug(builder != null);
MaterialTypeName = builder.MaterialTypeName;
MinedOre = builder.MinedOre;
MinedOreRatio = builder.MinedOreRatio;
CanBeHarvested = builder.CanBeHarvested;
IsRare = builder.IsRare;
SpawnsInAsteroids = builder.SpawnsInAsteroids;
SpawnsFromMeteorites = builder.SpawnsFromMeteorites;
DamageRatio = builder.DamageRatio;
DiffuseXZ = builder.DiffuseXZ;
DiffuseY = builder.DiffuseY;
NormalXZ = builder.NormalXZ;
NormalY = builder.NormalY;
SpecularPower = builder.SpecularPower;
SpecularShininess = builder.SpecularShininess;
MinVersion = builder.MinVersion;
if (!string.IsNullOrEmpty(builder.ParticleEffect))
{
ParticleEffect = (MyParticleEffectsIDEnum)Enum.Parse(typeof(MyParticleEffectsIDEnum), builder.ParticleEffect);
}
else
{
ParticleEffect = MyParticleEffectsIDEnum.None;
}
DamageThreshold = (int) (builder.DamageThreashold*255);
DamagedMaterial = MyStringHash.GetOrCompute(builder.DamagedMaterial);
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_AudioEffectDefinition;
Effect.EffectId = Id.SubtypeId;
foreach( var soundsEffects in ob.Sounds)
{
var soundsEffects2 = new List<MyAudioEffect.SoundEffect>();
foreach(var effect in soundsEffects.SoundEffects)
{
var seff = new MyAudioEffect.SoundEffect();
MyCurveDefinition def;
if(!MyDefinitionManager.Static.TryGetDefinition<MyCurveDefinition>(new MyDefinitionId(typeof (MyObjectBuilder_CurveDefinition), effect.VolumeCurve), out def))
{
seff.VolumeCurve = null;
}
else
seff.VolumeCurve = def.Curve;
seff.Duration = effect.Duration;
seff.Filter = effect.Filter;
seff.Frequency = (float)(2 * Math.Sin(3.14 * effect.Frequency / 44100));
seff.OneOverQ = 1 / effect.Q;
seff.StopAfter = effect.StopAfter;
soundsEffects2.Add(seff);
}
Effect.SoundsEffects.Add(soundsEffects2);
}
if (ob.OutputSound == 0)
Effect.ResultEmitterIdx = Effect.SoundsEffects.Count - 1;
else
Effect.ResultEmitterIdx = ob.OutputSound - 1;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_EnvironmentItemDefinition;
MyDebug.AssertDebug(ob != null);
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyDebug.AssertDebug(builder is MyObjectBuilder_ProductionBlockDefinition);
var obDefinition = builder as MyObjectBuilder_ProductionBlockDefinition;
this.InventoryMaxVolume = obDefinition.InventoryMaxVolume;
this.InventorySize = obDefinition.InventorySize;
ResourceSinkGroup = MyStringHash.GetOrCompute(obDefinition.ResourceSinkGroup);
this.StandbyPowerConsumption = obDefinition.StandbyPowerConsumption;
this.OperationalPowerConsumption = obDefinition.OperationalPowerConsumption;
System.Diagnostics.Debug.Assert(obDefinition.BlueprintClasses != null, "Production block has no blueprint classes specified");
if (obDefinition.BlueprintClasses == null)
InitializeLegacyBlueprintClasses(obDefinition);
BlueprintClasses = new List<MyBlueprintClassDefinition>();
for (int i = 0; i < obDefinition.BlueprintClasses.Length; ++i)
{
var className = obDefinition.BlueprintClasses[i];
var classDef = MyDefinitionManager.Static.GetBlueprintClass(className);
System.Diagnostics.Debug.Assert(classDef != null, "Production block references non-existent blueprint class");
if (classDef == null) continue;
BlueprintClasses.Add(classDef);
}
}
public void InitLazy(MyObjectBuilder_DefinitionBase baseBuilder)
{
var builder = baseBuilder as MyObjectBuilder_PrefabDefinition;
Debug.Assert(builder.CubeGrid != null || builder.CubeGrids != null, "No cube grids defined in prefab " + PrefabPath);
if (builder.CubeGrid == null && builder.CubeGrids == null) return;
// Backwards compatiblity
if (builder.CubeGrid != null)
m_cubeGrids = new MyObjectBuilder_CubeGrid[1] { builder.CubeGrid };
else
m_cubeGrids = builder.CubeGrids;
m_boundingSphere = new BoundingSphere(Vector3.Zero, float.MinValue);
m_boundingBox = BoundingBox.CreateInvalid();
foreach (var grid in m_cubeGrids)
{
BoundingBox localBB = grid.CalculateBoundingBox();
Matrix gridTransform = grid.PositionAndOrientation.HasValue ? (Matrix)grid.PositionAndOrientation.Value.GetMatrix() : Matrix.Identity;
m_boundingBox.Include(localBB.Transform(gridTransform));
}
m_boundingSphere = BoundingSphere.CreateFromBoundingBox(m_boundingBox);
foreach (var gridBuilder in m_cubeGrids)
{
gridBuilder.CreatePhysics = true;
gridBuilder.XMirroxPlane = null;
gridBuilder.YMirroxPlane = null;
gridBuilder.ZMirroxPlane = null;
}
Initialized = true;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_PhysicalItemDefinition;
MyDebug.AssertDebug(ob != null);
this.Size = ob.Size;
this.Mass = ob.Mass;
this.Model = ob.Model;
this.Models = ob.Models;
this.Volume = ob.Volume.HasValue? ob.Volume.Value / 1000f : ob.Size.Volume;
if (string.IsNullOrEmpty(ob.IconSymbol))
this.IconSymbol = null;
else
this.IconSymbol = MyStringId.GetOrCompute(ob.IconSymbol);
PhysicalMaterial = MyStringHash.GetOrCompute(ob.PhysicalMaterial);
VoxelMaterial = MyStringHash.GetOrCompute(ob.VoxelMaterial);
CanSpawnFromScreen = ob.CanSpawnFromScreen;
RotateOnSpawnX = ob.RotateOnSpawnX;
RotateOnSpawnY = ob.RotateOnSpawnY;
RotateOnSpawnZ = ob.RotateOnSpawnZ;
Health = ob.Health;
if (ob.DestroyedPieceId.HasValue)
{
DestroyedPieceId = ob.DestroyedPieceId.Value;
}
DestroyedPieces = ob.DestroyedPieces;
if (ob.ExtraInventoryTooltipLine != null)
ExtraInventoryTooltipLine = new StringBuilder().Append(Environment.NewLine).Append(ob.ExtraInventoryTooltipLine);
else
ExtraInventoryTooltipLine = new StringBuilder();
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
m_postprocessBuilder = builder as MyObjectBuilder_ComponentGroupDefinition;
MyDebug.AssertDebug(m_postprocessBuilder != null);
}
protected override void Init(MyObjectBuilder_DefinitionBase baseBuilder)
{
base.Init(baseBuilder);
var builder = baseBuilder as MyObjectBuilder_PrefabDefinition;
PrefabPath = builder.PrefabPath;
Initialized = false;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_ToolItemDefinition;
MyDebug.AssertDebug(ob != null);
if (ob.VoxelMinings != null && ob.VoxelMinings.Length > 0)
{
VoxelMinings = new MyVoxelMiningDefinition[ob.VoxelMinings.Length];
for (int i = 0; i < ob.VoxelMinings.Length; ++i)
{
VoxelMinings[i].MinedOre = ob.VoxelMinings[i].MinedOre;
VoxelMinings[i].HitCount = ob.VoxelMinings[i].HitCount;
VoxelMinings[i].PhysicalItemId = ob.VoxelMinings[i].PhysicalItemId;
VoxelMinings[i].RemovedRadius = ob.VoxelMinings[i].RemovedRadius;
VoxelMinings[i].OnlyApplyMaterial = ob.VoxelMinings[i].OnlyApplyMaterial;
}
}
CopyActions(ob.PrimaryActions, PrimaryActions);
CopyActions(ob.SecondaryActions, SecondaryActions);
HitDistance = ob.HitDistance;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyObjectBuilder_ContainerTypeDefinition definition = builder as MyObjectBuilder_ContainerTypeDefinition;
CountMin = definition.CountMin;
CountMax = definition.CountMax;
ItemsCumulativeFrequency = 0.0f;
int i = 0;
Items = new ContainerTypeItem[definition.Items.Length];
m_itemSelection = new bool[definition.Items.Length];
foreach (var itemBuilder in definition.Items)
{
ContainerTypeItem item = new ContainerTypeItem();
item.AmountMax = MyFixedPoint.DeserializeStringSafe(itemBuilder.AmountMax);
item.AmountMin = MyFixedPoint.DeserializeStringSafe(itemBuilder.AmountMin);
item.Frequency = Math.Max(itemBuilder.Frequency, 0.0f);
item.DefinitionId = itemBuilder.Id;
ItemsCumulativeFrequency += item.Frequency;
Items[i] = item;
m_itemSelection[i] = false;
++i;
}
m_tempCumulativeFreq = ItemsCumulativeFrequency;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
// Backward compatibility with definitions of events that have MyObjectBuilder_GlobalEventDefinition as the TypeId
if (builder.Id.TypeId == typeof(MyObjectBuilder_GlobalEventDefinition))
{
builder.Id = new VRage.ObjectBuilders.SerializableDefinitionId(typeof(MyObjectBuilder_GlobalEventBase), builder.Id.SubtypeName);
}
base.Init(builder);
var eventBuilder = builder as MyObjectBuilder_GlobalEventDefinition;
// This ensures that either both min and max activation time are specified or neither of them is
if (eventBuilder.MinActivationTimeMs.HasValue && !eventBuilder.MaxActivationTimeMs.HasValue)
{
eventBuilder.MaxActivationTimeMs = eventBuilder.MinActivationTimeMs;
}
if (eventBuilder.MaxActivationTimeMs.HasValue && !eventBuilder.MinActivationTimeMs.HasValue)
{
eventBuilder.MinActivationTimeMs = eventBuilder.MaxActivationTimeMs;
}
Debug.Assert(eventBuilder.FirstActivationTimeMs.HasValue || eventBuilder.MinActivationTimeMs.HasValue, "Global event definition has to have either the FirstActivationTime or [Min/Max]ActivationTime specified");
if (eventBuilder.MinActivationTimeMs.HasValue)
MinActivationTime = TimeSpan.FromTicks(eventBuilder.MinActivationTimeMs.Value * TimeSpan.TicksPerMillisecond);
if (eventBuilder.MaxActivationTimeMs.HasValue)
MaxActivationTime = TimeSpan.FromTicks(eventBuilder.MaxActivationTimeMs.Value * TimeSpan.TicksPerMillisecond);
if (eventBuilder.FirstActivationTimeMs.HasValue)
FirstActivationTime = TimeSpan.FromTicks(eventBuilder.FirstActivationTimeMs.Value * TimeSpan.TicksPerMillisecond);
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_CraftingComponentBasicDefinition;
ActionSound = ob.ActionSound;
CraftingSpeedMultiplier = ob.CraftingSpeedMultiplier;
if (ob.AvailableBlueprintClasses != null && ob.AvailableBlueprintClasses != String.Empty)
{
AvailableBlueprintClasses = ob.AvailableBlueprintClasses.Split(' ').ToList();
// TODO: REMOVE WHEN DURABILITY CAN BE ENABLED BYT DEFAULT..
if (!MyFakes.ENABLE_DURABILITY_COMPONENT)
{
if (AvailableBlueprintClasses.Contains("ToolsRepair"))
AvailableBlueprintClasses.Remove("ToolsRepair");
}
}
else
{
System.Diagnostics.Debug.Fail(String.Format("Problem initializing crafting block component definition {0}, it is missing available blueprint classes!", Id.ToString()));
}
}
protected override void Init(MyObjectBuilder_DefinitionBase ob)
{
base.Init(ob);
MyObjectBuilder_BlueprintDefinition builder = (MyObjectBuilder_BlueprintDefinition)ob;
Prerequisites = new Item[builder.Prerequisites.Length];
for (int i = 0; i < Prerequisites.Length; ++i)
{
Prerequisites[i] = Item.FromObjectBuilder(builder.Prerequisites[i]);
}
if (builder.Result != null)
{
Results = new Item[1];
Results[0] = Item.FromObjectBuilder(builder.Result);
}
else
{
Results = new Item[builder.Results.Length];
for (int i = 0; i < Results.Length; ++i)
{
Results[i] = Item.FromObjectBuilder(builder.Results[i]);
}
}
BaseProductionTimeInSeconds = builder.BaseProductionTimeInSeconds;
PostprocessNeeded = true;
ProgressBarSoundCue = builder.ProgressBarSoundCue;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = (MyObjectBuilder_ReflectorBlockDefinition)builder;
ReflectorTexture = ob.ReflectorTexture;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_HandDrillDefinition;
MyDebug.AssertDebug(ob != null);
HarvestRatioMultiplier = ob.HarvestRatioMultiplier;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_AiCommandBehaviorDefinition;
BehaviorTreeName = ob.BehaviorTreeName;
CommandEffect = ob.CommandEffect;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyDebug.AssertDebug(builder is MyObjectBuilder_AssemblerDefinition);
var obRefineryDef = builder as MyObjectBuilder_AssemblerDefinition;
m_assemblySpeed = obRefineryDef.AssemblySpeed;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_PlanetPrefabDefinition;
this.PlanetBuilder = ob.PlanetBuilder;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_RespawnShipDefinition;
Cooldown = ob.CooldownSeconds;
Prefab = MyDefinitionManager.Static.GetPrefabDefinition(ob.Prefab);
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var cbuilder = builder as MyObjectBuilder_ShipControllerDefinition;
EnableFirstPerson = cbuilder.EnableFirstPerson;
EnableShipControl = cbuilder.EnableShipControl;
EnableBuilderCockpit = cbuilder.EnableBuilderCockpit;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = (MyObjectBuilder_ClipboardDefinition)builder;
PastingSettings = ob.PastingSettings;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var upgradeDef = builder as MyObjectBuilder_UpgradeModuleDefinition;
Upgrades = upgradeDef.Upgrades;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var warheadBuilder = (MyObjectBuilder_WarheadDefinition)builder;
ExplosionRadius = warheadBuilder.ExplosionRadius;
WarheadExplosionDamage = warheadBuilder.WarheadExplosionDamage;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var cargoBuilder = builder as MyObjectBuilder_CargoContainerDefinition;
MyDebug.AssertDebug(cargoBuilder != null);
InventorySize = cargoBuilder.InventorySize;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var objectBuilder = builder as MyObjectBuilder_GasProperties;
EnergyDensity = objectBuilder.EnergyDensity;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var obMass = builder as MyObjectBuilder_VirtualMassDefinition;
MyDebug.AssertDebug(obMass != null, "Initializing virtual mass definition using wrong object builder.");
RequiredPowerInput = obMass.RequiredPowerInput;
VirtualMass = obMass.VirtualMass;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var soundBlockBuilder = (MyObjectBuilder_SoundBlockDefinition)builder;
Debug.Assert(soundBlockBuilder != null);
ResourceSinkGroup = MyStringHash.GetOrCompute(soundBlockBuilder.ResourceSinkGroup);
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var antennaBuilder = (MyObjectBuilder_RadioAntennaDefinition)builder;
Debug.Assert(antennaBuilder != null);
ResourceSinkGroup = MyStringHash.GetOrCompute(antennaBuilder.ResourceSinkGroup);
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = (MyObjectBuilder_DemoComponentDefinition)builder;
Float = ob.Float;
Int = ob.Int;
String = ob.String;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var obRemote = builder as MyObjectBuilder_RemoteControlDefinition;
MyDebug.AssertDebug(obRemote != null, "Initializing remote control using wrong definition");
ResourceSinkGroup = MyStringHash.GetOrCompute(obRemote.ResourceSinkGroup);
RequiredPowerInput = obRemote.RequiredPowerInput;
}
// init from object builder
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_AnimationControllerDefinition;
Debug.Assert(ob != null);
Layers = ob.Layers;
StateMachines = ob.StateMachines;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyDebug.AssertDebug(builder is MyObjectBuilder_RefineryDefinition);
var obRefineryDef = builder as MyObjectBuilder_RefineryDefinition;
this.RefineSpeed = obRefineryDef.RefineSpeed;
this.MaterialEfficiency = obRefineryDef.MaterialEfficiency;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyObjectBuilder_HandDrillDefinition definition = builder as MyObjectBuilder_HandDrillDefinition;
this.HarvestRatioMultiplier = definition.HarvestRatioMultiplier;
Vector3D particleOffset = definition.ParticleOffset;
this.ParticleOffset = definition.ParticleOffset;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var obMass = builder as MyObjectBuilder_SpaceBallDefinition;
MyDebug.AssertDebug(obMass != null, "Initializing sphere mass definition using wrong object builder.");
MaxVirtualMass = obMass.MaxVirtualMass;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyObjectBuilder_ShipDrillDefinition definition = builder as MyObjectBuilder_ShipDrillDefinition;
this.ResourceSinkGroup = MyStringHash.GetOrCompute(definition.ResourceSinkGroup);
this.CutOutOffset = definition.CutOutOffset;
this.CutOutRadius = definition.CutOutRadius;
this.ParticleOffset = definition.ParticleOffset;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var solarPanelBuilder = builder as MyObjectBuilder_SolarPanelDefinition;
PanelOrientation = solarPanelBuilder.PanelOrientation;
IsTwoSided = solarPanelBuilder.TwoSidedPanel;
PanelOffset = solarPanelBuilder.PanelOffset;
}
protected override void Init(MyObjectBuilder_DefinitionBase baseBuilder)
{
base.Init(baseBuilder);
var builder = baseBuilder as MyObjectBuilder_SpawnGroupDefinition;
Frequency = builder.Frequency;
if (Frequency == 0.0f)
{
MySandboxGame.Log.WriteLine("Spawn group initialization: spawn group has zero frequency");
return;
}
SpawnRadius = 0.0f;
BoundingSphere sphere = new BoundingSphere(Vector3.Zero, float.MinValue);
Prefabs.Clear();
foreach (var prefab in builder.Prefabs)
{
SpawnGroupPrefab spawnPrefab = new SpawnGroupPrefab();
spawnPrefab.Position = prefab.Position;
spawnPrefab.SubtypeId = prefab.SubtypeId;
spawnPrefab.BeaconText = prefab.BeaconText;
spawnPrefab.Speed = prefab.Speed;
spawnPrefab.ResetOwnership = prefab.ResetOwnership;
spawnPrefab.PlaceToGridOrigin = prefab.PlaceToGridOrigin;
var prefabDef = MyDefinitionManager.Static.GetPrefabDefinition(spawnPrefab.SubtypeId);
if (prefabDef == null)
{
System.Diagnostics.Debug.Assert(false, "Spawn group initialization: Could not get prefab " + spawnPrefab.SubtypeId);
MySandboxGame.Log.WriteLine("Spawn group initialization: Could not get prefab " + spawnPrefab.SubtypeId);
return;
}
Prefabs.Add(spawnPrefab);
}
Voxels.Clear();
if (builder.Voxels != null)
{
foreach (var prefab in builder.Voxels)
{
SpawnGroupVoxel spawnPrefab = new SpawnGroupVoxel();
spawnPrefab.Offset = prefab.Offset;
spawnPrefab.StorageName = prefab.StorageName;
Voxels.Add(spawnPrefab);
}
}
SpawnRadius = sphere.Radius + 5.0f; // Add 5m just to be sure
IsEncounter = builder.IsEncounter;
IsPirate = builder.IsPirate;
ReactorsOn = builder.ReactorsOn;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_ScenarioDefinition;
AsteroidClustersEnabled = ob.AsteroidClusters.Enabled;
AsteroidClustersOffset = ob.AsteroidClusters.Offset;
CentralClusterEnabled = ob.AsteroidClusters.CentralCluster;
CreativeDefaultToolbar = ob.CreativeDefaultToolbar;
SurvivalDefaultToolbar = ob.SurvivalDefaultToolbar;
MainCharacterModel = MyStringId.GetOrCompute(ob.MainCharacterModel);
GameDate = new DateTime(ob.GameDate);
SunDirection = ob.SunDirection;
if (ob.PossibleStartingStates != null && ob.PossibleStartingStates.Length > 0)
{
PossiblePlayerStarts = new MyWorldGeneratorStartingStateBase[ob.PossibleStartingStates.Length];
for (int i = 0; i < ob.PossibleStartingStates.Length; ++i)
{
PossiblePlayerStarts[i] = MyWorldGenerator.StartingStateFactory.CreateInstance(ob.PossibleStartingStates[i]);
}
}
if (ob.WorldGeneratorOperations != null && ob.WorldGeneratorOperations.Length > 0)
{
WorldGeneratorOperations = new MyWorldGeneratorOperationBase[ob.WorldGeneratorOperations.Length];
for (int i = 0; i < ob.WorldGeneratorOperations.Length; ++i)
{
WorldGeneratorOperations[i] = MyWorldGenerator.OperationFactory.CreateInstance(ob.WorldGeneratorOperations[i]);
}
}
if (ob.CreativeModeWeapons != null && ob.CreativeModeWeapons.Length > 0)
{
CreativeModeWeapons = new MyStringId[ob.CreativeModeWeapons.Length];
for (int i = 0; i < ob.CreativeModeWeapons.Length; ++i)
{
CreativeModeWeapons[i] = MyStringId.GetOrCompute(ob.CreativeModeWeapons[i]);
}
}
if (ob.SurvivalModeWeapons != null && ob.SurvivalModeWeapons.Length > 0)
{
SurvivalModeWeapons = new MyStringId[ob.SurvivalModeWeapons.Length];
for (int i = 0; i < ob.SurvivalModeWeapons.Length; ++i)
{
SurvivalModeWeapons[i] = MyStringId.GetOrCompute(ob.SurvivalModeWeapons[i]);
}
}
WorldBoundaries.Min = ob.WorldBoundaries.Min;
WorldBoundaries.Max = ob.WorldBoundaries.Max;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_ScriptedGroupDefinition;
Category = MyStringHash.GetOrCompute(ob.Category);
Script = MyStringHash.GetOrCompute(ob.Script);
m_scriptedObjects = new HashSet <MyDefinitionId>();
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var landingGearBuilder = builder as MyObjectBuilder_LandingGearDefinition;
MyDebug.AssertDebug(landingGearBuilder != null);
LockSound = landingGearBuilder.LockSound;
UnlockSound = landingGearBuilder.UnlockSound;
FailedAttachSound = landingGearBuilder.FailedAttachSound;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var modelDefinition = builder as MyObjectBuilder_ModelComponentDefinition;
Size = modelDefinition.Size;
Mass = modelDefinition.Mass;
Model = modelDefinition.Model;
Volume = modelDefinition.Volume.HasValue ? modelDefinition.Volume.Value / 1000f : modelDefinition.Size.Volume;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var cbuilder = builder as MyObjectBuilder_ShipControllerDefinition;
EnableFirstPerson = cbuilder.EnableFirstPerson;
EnableShipControl = cbuilder.EnableShipControl;
EnableBuilderCockpit = cbuilder.EnableBuilderCockpit;
GetInSound = cbuilder.GetInSound;
GetOutSound = cbuilder.GetOutSound;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var landingGearBuilder = builder as MyObjectBuilder_MedicalRoomDefinition;
MyDebug.AssertDebug(landingGearBuilder != null);
ResourceSinkGroup = landingGearBuilder.ResourceSinkGroup;
IdleSound = landingGearBuilder.IdleSound;
ProgressSound = landingGearBuilder.ProgressSound;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var doorBuilder = builder as MyObjectBuilder_DoorDefinition;
MyDebug.AssertDebug(doorBuilder != null);
MaxOpen = doorBuilder.MaxOpen;
OpenSound = doorBuilder.OpenSound;
CloseSound = doorBuilder.CloseSound;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyObjectBuilder_AdvancedDoorDefinition definition = builder as MyObjectBuilder_AdvancedDoorDefinition;
this.ResourceSinkGroup = MyStringHash.GetOrCompute(definition.ResourceSinkGroup);
this.PowerConsumptionIdle = definition.PowerConsumptionIdle;
this.PowerConsumptionMoving = definition.PowerConsumptionMoving;
this.Subparts = definition.Subparts;
this.OpeningSequence = definition.OpeningSequence;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyObjectBuilder_DoorDefinition definition = builder as MyObjectBuilder_DoorDefinition;
this.ResourceSinkGroup = definition.ResourceSinkGroup;
this.MaxOpen = definition.MaxOpen;
this.OpenSound = definition.OpenSound;
this.CloseSound = definition.CloseSound;
this.OpeningSpeed = definition.OpeningSpeed;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_DebrisDefinition;
MyDebug.AssertDebug(ob != null);
this.Model = ob.Model;
this.Type = ob.Type;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyObjectBuilder_PowerProducerDefinition definition = builder as MyObjectBuilder_PowerProducerDefinition;
if (definition != null)
{
this.ResourceSourceGroup = MyStringHash.GetOrCompute(definition.ResourceSourceGroup);
this.MaxPowerOutput = definition.MaxPowerOutput;
}
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_ComponentDefinition;
MyDebug.AssertDebug(ob != null);
this.MaxIntegrity = ob.MaxIntegrity;
this.DropProbability = ob.DropProbability;
DeconstructionEfficiency = ob.DeconstructionEfficiency;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = (MyObjectBuilder_TextPanelDefinition)builder;
ResourceSinkGroup = MyStringHash.GetOrCompute(ob.ResourceSinkGroup);
RequiredPowerInput = ob.RequiredPowerInput;
TextureResolution = ob.TextureResolution;
TextureAspectRadio = ob.TextureAspectRadio;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_WeaponItemDefinition;
MyDebug.AssertDebug(ob != null);
this.WeaponDefinitionId = new MyDefinitionId(ob.WeaponDefinitionId.Type, ob.WeaponDefinitionId.Subtype);
this.ShowAmmoCount = ob.ShowAmmoCount;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var mergeBuilder = builder as MyObjectBuilder_MergeBlockDefinition;
MyDebug.AssertDebug(mergeBuilder != null, "Initializing thrust definition using wrong object builder.");
Strength = mergeBuilder.Strength;
//DeformationRatio = mergeBuilder.DeformationRatio;
DeformationRatio = 0.5f;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
MyObjectBuilder_CryoChamberDefinition definition = builder as MyObjectBuilder_CryoChamberDefinition;
this.OverlayTexture = definition.OverlayTexture;
this.ResourceSinkGroup = definition.ResourceSinkGroup;
this.IdlePowerConsumption = definition.IdlePowerConsumption;
this.OutsideSound = new MySoundPair(definition.OutsideSound, true);
this.InsideSound = new MySoundPair(definition.InsideSound, true);
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var cbuilder = builder as MyObjectBuilder_ShipDrillDefinition;
Debug.Assert(cbuilder != null);
ResourceSinkGroup = MyStringHash.GetOrCompute(cbuilder.ResourceSinkGroup);
SensorRadius = cbuilder.SensorRadius;
SensorOffset = cbuilder.SensorOffset;
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var obGenerator = builder as MyObjectBuilder_GravityGeneratorDefinition;
MyDebug.AssertDebug(obGenerator != null, "Initializing definition using wrong object builder.");
RequiredPowerInput = obGenerator.RequiredPowerInput;
MinFieldSize = obGenerator.MinFieldSize;
MaxFieldSize = obGenerator.MaxFieldSize;
}
