public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { m_cameraDummy = Matrix.Identity; m_characterDummy = Matrix.Identity; base.Init(objectBuilder, cubeGrid); var chamberOb = objectBuilder as MyObjectBuilder_CryoChamber; if (chamberOb.SteamId != null && chamberOb.SerialId != null) { m_currentPlayerId = new MyPlayer.PlayerId(chamberOb.SteamId.Value, chamberOb.SerialId.Value); } else { m_currentPlayerId = null; } var overlayTexture = BlockDefinition.OverlayTexture; if (!string.IsNullOrEmpty(overlayTexture)) { m_overlayTextureName = overlayTexture; } var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( MyStringHash.GetOrCompute(BlockDefinition.ResourceSinkGroup), BlockDefinition.IdlePowerConsumption, this.CalculateRequiredPowerInput); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink = sinkComp; NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; }
protected override void Init(MyObjectBuilder_DefinitionBase builder) { base.Init(builder); var gasTankDefinition = builder as MyObjectBuilder_GasTankDefinition; MyDebug.AssertDebug(gasTankDefinition != null, "Initializing gas tank definition using wrong object builder."); Capacity = gasTankDefinition.Capacity; MyDefinitionId gasId; if (gasTankDefinition.StoredGasId.IsNull()) // Backward compatibility { gasId = new MyDefinitionId(typeof(MyObjectBuilder_GasProperties), "Oxygen"); } else { gasId = gasTankDefinition.StoredGasId; } StoredGasId = gasId; ResourceSourceGroup = MyStringHash.GetOrCompute(gasTankDefinition.ResourceSourceGroup); }
public override void Deserialize(MyObjectBuilder_ComponentBase objectBuilder) { MyObjectBuilder_CharacterStatComponent component = objectBuilder as MyObjectBuilder_CharacterStatComponent; using (List <MyStatLogic> .Enumerator enumerator = this.m_scripts.GetEnumerator()) { while (enumerator.MoveNext()) { enumerator.Current.Close(); } } this.m_scripts.Clear(); if (component != null) { if (component.Stats != null) { foreach (MyObjectBuilder_EntityStat stat in component.Stats) { MyEntityStatDefinition definition = null; if ((MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(stat.TypeId, stat.SubtypeId), out definition) && definition.Enabled) && ((definition.EnabledInCreative && MySession.Static.CreativeMode) || (definition.AvailableInSurvival && MySession.Static.SurvivalMode))) { this.AddStat(MyStringHash.GetOrCompute(definition.Name), stat, true); } } } if ((component.ScriptNames != null) && Sync.IsServer) { component.ScriptNames = component.ScriptNames.Distinct <string>().ToArray <string>(); foreach (string str in component.ScriptNames) { this.InitScript(str); } } } base.Deserialize(objectBuilder); }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { m_objectBuilder = objectBuilder; Entity.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME | MyEntityUpdateEnum.EACH_FRAME; MyResourceSinkInfo ElectricityResourceSinkInfo = new MyResourceSinkInfo { ResourceTypeId = ElectricityDefinitionsId, MaxRequiredInput = MaxElectricityConsumption, RequiredInputFunc = OnUpdateElectricityUsage }; MyResourceSinkComponent ResourceSink = new MyResourceSinkComponent(); ResourceSink.Init(MyStringHash.GetOrCompute("Factory"), ElectricityResourceSinkInfo); Entity.Components.Add <MyResourceSinkComponent>(ResourceSink); ResourceSink.Update(); m_resourceSink = ResourceSink; /* * // Because a Cargo Container does not produce anything, we need to create a new Resource Source for it and attach it to the block * MyResourceSourceComponent ResourceSource = new MyResourceSourceComponent(); * Entity.Components.Add<MyResourceSourceComponent>(ResourceSource); * * // We let it produce OxyHydrogen gas with a defined (changed by us later) maximum of 1200MW * MyResourceSourceInfo oxyHydrogenResourceSourceInfo = new MyResourceSourceInfo() {ResourceTypeId = ElectricityDefinitionsId, DefinedOutput = 0.0001f, IsInfiniteCapacity = true, ProductionToCapacityMultiplier = 60*60}; * ResourceSource.Init(MyStringHash.GetOrCompute("Battery"), oxyHydrogenResourceSourceInfo); * ResourceSource.SetMaxOutputByType(ElectricityDefinitionsId, 0.00005f); * ResourceSource.SetProductionEnabledByType(ElectricityDefinitionsId, true); * * m_resourceSource = ResourceSource; */ }
public override void ContactPointCallback(ref MyGridContactInfo value) { //return; var prop = value.Event.ContactProperties; prop.Friction = Friction; prop.Restitution = 0.5f; value.EnableParticles = false; value.RubberDeformation = true; string particle = null; if (value.CollidingEntity is MyVoxelBase && MyFakes.ENABLE_DRIVING_PARTICLES) { MyVoxelBase voxel = value.CollidingEntity as MyVoxelBase; Vector3D contactPosition = value.ContactPosition; var vmat = voxel.GetMaterialAt(ref contactPosition); if (vmat == null) { return; } MyStringHash material = MyStringHash.GetOrCompute(vmat.MaterialTypeName); particle = MyMaterialPropertiesHelper.Static.GetCollisionEffect(MyMaterialPropertiesHelper.CollisionType.Start, m_wheelStringHash, material); } else if (value.CollidingEntity is MyCubeGrid && MyFakes.ENABLE_DRIVING_PARTICLES) { MyCubeGrid grid = value.CollidingEntity as MyCubeGrid; MyStringHash material = grid.Physics.GetMaterialAt(value.ContactPosition); particle = MyMaterialPropertiesHelper.Static.GetCollisionEffect(MyMaterialPropertiesHelper.CollisionType.Start, m_wheelStringHash, material); } if (Render != null && particle != null) { Render.TrySpawnParticle((Vector3)value.ContactPosition, value.Event.ContactPoint.Normal, particle); } }
public virtual void Init(MyObjectBuilder_Base objectBuilder) { var builder = (MyObjectBuilder_EntityStat)objectBuilder; MyEntityStatDefinition definition; MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(builder.TypeId, builder.SubtypeId), out definition); Debug.Assert(definition != null); StatDefinition = definition; System.Diagnostics.Debug.Assert(!float.IsNaN(definition.MaxValue) && !float.IsNaN(definition.MinValue) && !float.IsNaN(definition.DefaultValue), "Invalid values in stat definition!"); m_maxValue = definition.MaxValue; m_minValue = definition.MinValue; m_currentValue = builder.Value * m_maxValue; m_defaultValue = definition.DefaultValue; m_lastSyncValue = m_currentValue; m_statId = MyStringHash.GetOrCompute(definition.Name); m_regenAmountMultiplier = builder.StatRegenAmountMultiplier; m_regenAmountMultiplierDuration = builder.StatRegenAmountMultiplierDuration; m_regenAmountMultiplierTimeStart = MySandboxGame.TotalGamePlayTimeInMilliseconds; m_regenAmountMultiplierTimeAlive = 0; m_regenAmountMultiplierActive = m_regenAmountMultiplierDuration > 0; ClearEffects(); if (builder.Effects != null) { foreach (var effectBuilder in builder.Effects) { AddEffect(effectBuilder); } } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.m_characterDummy = Matrix.Identity; base.Init(objectBuilder, cubeGrid); if (base.ResourceSink != null) { base.ResourceSink.SetMaxRequiredInputByType(MyResourceDistributorComponent.ElectricityId, this.BlockDefinition.IdlePowerConsumption); base.ResourceSink.SetRequiredInputFuncByType(MyResourceDistributorComponent.ElectricityId, new Func <float>(this.CalculateRequiredPowerInput)); base.ResourceSink.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); } else { MyResourceSinkComponent component = new MyResourceSinkComponent(1); component.Init(MyStringHash.GetOrCompute(this.BlockDefinition.ResourceSinkGroup), this.BlockDefinition.IdlePowerConsumption, new Func <float>(this.CalculateRequiredPowerInput)); component.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); base.ResourceSink = component; } MyObjectBuilder_CryoChamber chamber = objectBuilder as MyObjectBuilder_CryoChamber; if ((chamber.SteamId == null) || (chamber.SerialId == null)) { this.m_currentPlayerId = null; } else { this.m_currentPlayerId = new MyPlayer.PlayerId(chamber.SteamId.Value, chamber.SerialId.Value); } string overlayTexture = this.BlockDefinition.OverlayTexture; if (!string.IsNullOrEmpty(overlayTexture)) { this.m_overlayTextureName = overlayTexture; } base.HorizonIndicatorEnabled = false; base.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME; }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; base.Init(objectBuilder, cubeGrid); NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME; var ob = objectBuilder as MyObjectBuilder_CameraBlock; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( MyStringHash.GetOrCompute(BlockDefinition.ResourceSinkGroup), BlockDefinition.RequiredPowerInput, CalculateRequiredPowerInput); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; sinkComp.RequiredInputChanged += Receiver_RequiredInputChanged; sinkComp.Update(); ResourceSink = sinkComp; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; IsWorkingChanged += MyCameraBlock_IsWorkingChanged; IsInFirstPersonView = true; if (ob.IsActive) { m_requestActivateAfterLoad = true; ob.IsActive = false; } OnChangeFov(ob.Fov); UpdateText(); }
public void Consume(MyFixedPoint amount, MyConsumableItemDefinition definition) { if (definition == null) { return; } MyEntityStat stat; var regenEffect = new MyObjectBuilder_EntityStatRegenEffect(); regenEffect.Interval = 1.0f; regenEffect.MaxRegenRatio = 1.0f; regenEffect.MinRegenRatio = 0.0f; foreach (var statValue in definition.Stats) { if (Stats.TryGetValue(MyStringHash.GetOrCompute(statValue.Name), out stat)) { regenEffect.TickAmount = statValue.Value * (float)amount; regenEffect.Duration = statValue.Time; stat.AddEffect(regenEffect); } } }
protected override void Init(MyObjectBuilder_DefinitionBase builder) { base.Init(builder); MyObjectBuilder_ProductionBlockDefinition ob = builder as MyObjectBuilder_ProductionBlockDefinition; this.InventoryMaxVolume = ob.InventoryMaxVolume; this.InventorySize = ob.InventorySize; this.ResourceSinkGroup = MyStringHash.GetOrCompute(ob.ResourceSinkGroup); this.StandbyPowerConsumption = ob.StandbyPowerConsumption; this.OperationalPowerConsumption = ob.OperationalPowerConsumption; if (ob.BlueprintClasses == null) { this.InitializeLegacyBlueprintClasses(ob); } this.BlueprintClasses = new List <MyBlueprintClassDefinition>(); foreach (string str in ob.BlueprintClasses) { MyBlueprintClassDefinition blueprintClass = MyDefinitionManager.Static.GetBlueprintClass(str); if (blueprintClass != null) { this.BlueprintClasses.Add(blueprintClass); } } }
protected override void Init(MyObjectBuilder_DefinitionBase builder) { base.Init(builder); MyObjectBuilder_EnvironmentItemsDefinition definition = builder as MyObjectBuilder_EnvironmentItemsDefinition; this.m_itemDefinitions = new HashSet <MyStringHash>(MyStringHash.Comparer); this.m_definitionList = new List <MyStringHash>(); object[] customAttributes = builder.Id.TypeId.GetCustomAttributes(typeof(MyEnvironmentItemsAttribute), false); if (customAttributes.Length != 1) { this.m_itemDefinitionType = typeof(MyObjectBuilder_EnvironmentItemDefinition); } else { MyEnvironmentItemsAttribute attribute = customAttributes[0] as MyEnvironmentItemsAttribute; this.m_itemDefinitionType = attribute.ItemDefinitionType; } this.Channel = definition.Channel; this.MaxViewDistance = definition.MaxViewDistance; this.SectorSize = definition.SectorSize; this.ItemSize = definition.ItemSize; this.Material = MyStringHash.GetOrCompute(definition.PhysicalMaterial); this.Frequencies = new List <float>(); }
protected override void Init(MyObjectBuilder_DefinitionBase builder) { MyDefinitionId id; base.Init(builder); MyObjectBuilder_OxygenFarmDefinition definition = builder as MyObjectBuilder_OxygenFarmDefinition; this.ResourceSinkGroup = MyStringHash.GetOrCompute(definition.ResourceSinkGroup); this.ResourceSourceGroup = MyStringHash.GetOrCompute(definition.ResourceSourceGroup); this.PanelOrientation = definition.PanelOrientation; this.IsTwoSided = definition.TwoSidedPanel; this.PanelOffset = definition.PanelOffset; if (definition.ProducedGas.Id.IsNull()) { id = new MyDefinitionId(typeof(MyObjectBuilder_GasProperties), "Oxygen"); } else { id = definition.ProducedGas.Id; } this.ProducedGas = id; this.MaxGasOutput = definition.ProducedGas.MaxOutputPerSecond; this.OperationalPowerConsumption = definition.OperationalPowerConsumption; }
public override void LoadData() { base.LoadData(); var allDefs = MyDefinitionManager.Static.GetAllDefinitions().ToArray(); foreach (var tankDef in allDefs.OfType <MyGasTankDefinition>()) { var cubeSideLen = tankDef.CubeSize.GetSizeM(); var size = tankDef.Size * cubeSideLen; var surfaceArea = 2 * (size.X * size.Y + size.X * size.Z + size.Y * size.Z); //m^2 var tankWeightKg = surfaceArea * (tankDef.CubeSize == MyCubeSize.Large ? 9 : 4); //not sure this har is realistic tankDef.Capacity = tankDef.GetVolumeM3() * 1000; RescaleToHaveMass(tankDef, tankWeightKg); } // foreach(var oreDetector in allDefs.OfType<MyOreDetectorDefinition>()) // { // // ore detectors should be 10x longer // var diameter = oreDetector.GetDiameter(); // oreDetector.MaximumRange = diameter * 100; // } // no you can't have a cookie. foreach (var medbay in allDefs.OfType <MyMedicalRoomDefinition>()) { medbay.RespawnAllowed = false; } foreach (var wheelDef in allDefs.OfType <MyMotorSuspensionDefinition>()) { // wheels in this game should be way more powerful } foreach (var componenet in allDefs.OfType <MyPhysicalItemDefinition>()) { componenet.MinimalPricePerUnit = 0; } foreach (var batDef in allDefs.OfType <MyBatteryBlockDefinition>()) { // todo use the number of battery componenets to figure out batDef.RequiredPowerInput = batDef.MaxStoredPower * 6; // 6 is charge to full in 10mins which is pretty close to what we have rn batDef.MaxPowerOutput = batDef.MaxStoredPower * 40; // batts have a lot of power 80 continous is fairly common batDef.InitialStoredPowerRatio = 0.1f; } foreach (var thrusterDef in allDefs.OfType <MyThrustDefinition>()) { ThrusterData thruster = null; var diameter = thrusterDef.Size.Dot(ref Vector3I.Up) * thrusterDef.CubeSize.GetSizeM(); if (thrusterDef.ThrusterType == MyStringHash.GetOrCompute("Ion")) { // yeah ions don't really do much thrusterDef.ForceMagnitude *= 1e-6f; continue; } if (thrusterDef.ThrusterType == MyStringHash.GetOrCompute("Atmospheric")) { thruster = ThrusterData.DjiQuadcopter; thrusterDef.MinPlanetaryInfluence = 0.1f; // this is the best thing. } // normal thrusters start here if (thrusterDef.ThrusterType == MyStringHash.GetOrCompute("Hydrogen")) { thruster = ThrusterData.RS25; } // this is in N var scale = Math.Pow(diameter / thruster.Diameter, 2); var mass = scale * thruster.Mass; RescaleToHaveMass(thrusterDef, mass, true); var force = scale * thruster.MaxThrust; // force in newtons var maxIsp = Math.Max(thruster.IspSea, thruster.IspVac); var massFlowRate = force / (maxIsp * PhysicsData.G0); var fuel = thruster.Fuel; var power = massFlowRate / fuel.Mass * fuel.Energy / Mwh; thrusterDef.ForceMagnitude = (float)force; //TODO i am sure this unit should be Mw and powe is in Mw but for some reason game wants it in Mwh/s not thrusterDef.MinPowerConsumption = 0; thrusterDef.MaxPowerConsumption = (float)(power); /* * var twr = 0; * * var oiwer= mass* PhysicsData.G0* twr / (maxIsp * PhysicsData.G0) / fuel.Mass * fuel.Energy * var oiwer= mass* twr / (maxIsp) / fuel.Mass * fuel.Energy * */ //thrusterDef.FuelConverter.Efficiency = 1f; // assume //var fuelEnergyPerKg = // this is in //thruster.MaxPowerConsumption = 2790.0e-6f * } }
private void SetThrustMountPoints(string subtypeId, params MyObjectBuilder_CubeBlockDefinition.MountPoint[] addMPObjects) { MyCubeBlockDefinition def; if (MyDefinitionManager.Static.TryGetCubeBlockDefinition(new MyDefinitionId(typeof(MyObjectBuilder_Thrust), MyStringHash.GetOrCompute(subtypeId)), out def)) { // HACK since there's no way to edit the flame properly, this hides it and the mod draws its own MyThrustDefinition thrustDef = (MyThrustDefinition)def; thrustDef.FlameFullColor = Vector4.Zero; thrustDef.FlameIdleColor = Vector4.Zero; MyCubeBlockDefinition.MountPoint[] mp = def.MountPoints; def.MountPoints = new MyCubeBlockDefinition.MountPoint[mp.Length + addMPObjects.Length]; for (int i = 0; i < mp.Length; i++) { def.MountPoints[i] = mp[i]; } for (int i = 0; i < addMPObjects.Length; ++i) { MyObjectBuilder_CubeBlockDefinition.MountPoint mpObj = addMPObjects[i]; Vector3 start = new Vector3(Vector2.Min(mpObj.Start, mpObj.End) + 0.001f, 0.0004f); Vector3 end = new Vector3(Vector2.Max(mpObj.Start, mpObj.End) - 0.001f, -0.0004f); int side = (int)mpObj.Side; TransformMountPointPosition(ref start, side, def.Size, out start); TransformMountPointPosition(ref end, side, def.Size, out end); Vector3I forward = Vector3I.Forward; Vector3I.TransformNormal(ref forward, ref m_mountPointTransforms[side], out forward); def.MountPoints[mp.Length + i] = new MyCubeBlockDefinition.MountPoint() { Start = start, End = end, Normal = forward, ExclusionMask = mpObj.ExclusionMask, PropertiesMask = mpObj.PropertiesMask, Enabled = mpObj.Enabled, Default = mpObj.Default, }; } } }
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(); }
protected override void Init(MyObjectBuilder_DefinitionBase def) { base.Init(def); var ob = (MyObjectBuilder_EquiHarvestableComponentDefinition)def; _lootTableByTag.Clear(); _lootTableByItem.Clear(); if (ob.Entries == null) { return; } foreach (var k in ob.Entries) { if (string.IsNullOrWhiteSpace(k.From)) { MyDefinitionErrors.Add(Package, $"{Id} has an entry with no from state", LogSeverity.Warning); continue; } if (k.Harvesters == null || k.Harvesters.Length == 0) { MyDefinitionErrors.Add(Package, $"{Id} has an entry with no harvesters", LogSeverity.Warning); continue; } MyLootTableDefinition lootTable = null; if (k.LootTable.HasValue) { lootTable = MyDefinitionManager.Get <MyLootTableDefinition>(k.LootTable.Value); if (lootTable == null) { MyDefinitionErrors.Add(Package, $"{Id} has an entry from {k.From} referring to missing loot table {k.LootTable}", LogSeverity.Warning); continue; } } foreach (var item in k.Harvesters) { if (!item.IsValid()) { MyDefinitionErrors.Add(Package, $"{Id} has an entry with an invalid harvester", LogSeverity.Warning); } } var sourceState = MyStringHash.GetOrCompute(k.From); var destState = MyStringHash.GetOrCompute(k.To); var data = new Data(lootTable, destState, k.RequiresPermission, k.ActionHint ?? "Harvest", MyStringHash.GetOrCompute(k.ActionIcon ?? "Pickup_Item")); foreach (var item in k.Harvesters) { if (!item.IsValid()) { continue; } if (!string.IsNullOrWhiteSpace(item.Tag)) { _lootTableByTag[new TagKey(sourceState, MyStringHash.GetOrCompute(item.Tag))] = data; } else { _lootTableByItem[new DefinitionKey(sourceState, item)] = data; } } } }
protected override unsafe void Init(MyObjectBuilder_DefinitionBase builder) { base.Init(builder); MyObjectBuilder_PlanetGeneratorDefinition definition = builder as MyObjectBuilder_PlanetGeneratorDefinition; if ((definition.InheritFrom != null) && (definition.InheritFrom.Length > 0)) { this.InheritFrom(definition.InheritFrom); } if (definition.Environment != null) { this.EnvironmentId = new MyDefinitionId?(definition.Environment.Value); } else { this.m_pgob = definition; } if (definition.PlanetMaps != null) { this.PlanetMaps = definition.PlanetMaps.Value; } if (definition.HasAtmosphere != null) { this.HasAtmosphere = definition.HasAtmosphere.Value; } if (definition.CloudLayers != null) { this.CloudLayers = definition.CloudLayers; } if (definition.SoundRules != null) { this.SoundRules = new MyPlanetEnvironmentalSoundRule[definition.SoundRules.Length]; for (int i = 0; i < definition.SoundRules.Length; i++) { MyPlanetEnvironmentalSoundRule rule = new MyPlanetEnvironmentalSoundRule { Latitude = definition.SoundRules[i].Latitude, Height = definition.SoundRules[i].Height, SunAngleFromZenith = definition.SoundRules[i].SunAngleFromZenith, EnvironmentSound = MyStringHash.GetOrCompute(definition.SoundRules[i].EnvironmentSound) }; rule.Latitude.ConvertToSine(); rule.SunAngleFromZenith.ConvertToCosine(); this.SoundRules[i] = rule; } } if (definition.MusicCategories != null) { this.MusicCategories = definition.MusicCategories; } if (definition.HillParams != null) { this.HillParams = definition.HillParams.Value; } if (definition.Atmosphere != null) { this.Atmosphere = definition.Atmosphere; } if (definition.GravityFalloffPower != null) { this.GravityFalloffPower = definition.GravityFalloffPower.Value; } if (definition.HostileAtmosphereColorShift != null) { this.HostileAtmosphereColorShift = definition.HostileAtmosphereColorShift; } if (definition.MaterialsMaxDepth != null) { this.MaterialsMaxDepth = definition.MaterialsMaxDepth.Value; } if (definition.MaterialsMinDepth != null) { this.MaterialsMinDepth = definition.MaterialsMinDepth.Value; } if ((definition.CustomMaterialTable != null) && (definition.CustomMaterialTable.Length != 0)) { this.SurfaceMaterialTable = new MyPlanetMaterialDefinition[definition.CustomMaterialTable.Length]; for (int i = 0; i < this.SurfaceMaterialTable.Length; i++) { this.SurfaceMaterialTable[i] = definition.CustomMaterialTable[i].Clone() as MyPlanetMaterialDefinition; if ((this.SurfaceMaterialTable[i].Material == null) && !this.SurfaceMaterialTable[i].HasLayers) { MyLog.Default.WriteLine("Custom material does not contain any material ids."); } else if (this.SurfaceMaterialTable[i].HasLayers) { float depth = this.SurfaceMaterialTable[i].Layers[0].Depth; for (int j = 1; j < this.SurfaceMaterialTable[i].Layers.Length; j++) { float *singlePtr1 = (float *)ref this.SurfaceMaterialTable[i].Layers[j].Depth; singlePtr1[0] += depth; depth = this.SurfaceMaterialTable[i].Layers[j].Depth; } } } } if ((definition.DistortionTable != null) && (definition.DistortionTable.Length != 0)) { this.DistortionTable = definition.DistortionTable; } if (definition.DefaultSurfaceMaterial != null) { this.DefaultSurfaceMaterial = definition.DefaultSurfaceMaterial; } if (definition.DefaultSubSurfaceMaterial != null) { this.DefaultSubSurfaceMaterial = definition.DefaultSubSurfaceMaterial; } if (definition.SurfaceGravity != null) { this.SurfaceGravity = definition.SurfaceGravity.Value; } if (definition.AtmosphereSettings != null) { this.AtmosphereSettings = definition.AtmosphereSettings; } this.FolderName = (definition.FolderName != null) ? definition.FolderName : definition.Id.SubtypeName; if ((definition.ComplexMaterials != null) && (definition.ComplexMaterials.Length != 0)) { this.MaterialGroups = new MyPlanetMaterialGroup[definition.ComplexMaterials.Length]; int index = 0; while (index < definition.ComplexMaterials.Length) { this.MaterialGroups[index] = definition.ComplexMaterials[index].Clone() as MyPlanetMaterialGroup; MyPlanetMaterialGroup group = this.MaterialGroups[index]; MyPlanetMaterialPlacementRule[] materialRules = group.MaterialRules; List <int> indices = new List <int>(); int num6 = 0; while (true) { if (num6 >= materialRules.Length) { if (indices.Count > 0) { materialRules = materialRules.RemoveIndices <MyPlanetMaterialPlacementRule>(indices); } group.MaterialRules = materialRules; index++; break; } if ((materialRules[num6].Material == null) && ((materialRules[num6].Layers == null) || (materialRules[num6].Layers.Length == 0))) { MyLog.Default.WriteLine("Material rule does not contain any material ids."); indices.Add(num6); } else { if ((materialRules[num6].Layers != null) && (materialRules[num6].Layers.Length != 0)) { float depth = materialRules[num6].Layers[0].Depth; for (int i = 1; i < materialRules[num6].Layers.Length; i++) { float *singlePtr2 = (float *)ref materialRules[num6].Layers[i].Depth; singlePtr2[0] += depth; depth = materialRules[num6].Layers[i].Depth; } } materialRules[num6].Slope.ConvertToCosine(); materialRules[num6].Latitude.ConvertToSine(); materialRules[num6].Longitude.ConvertToCosineLongitude(); } num6++; } } } if (definition.OreMappings != null) { this.OreMappings = definition.OreMappings; } if (definition.MaterialBlending != null) { this.MaterialBlending = definition.MaterialBlending.Value; } if (definition.SurfaceDetail != null) { this.Detail = definition.SurfaceDetail; } if (definition.AnimalSpawnInfo != null) { this.AnimalSpawnInfo = definition.AnimalSpawnInfo; } if (definition.NightAnimalSpawnInfo != null) { this.NightAnimalSpawnInfo = definition.NightAnimalSpawnInfo; } if (definition.SectorDensity != null) { this.SectorDensity = definition.SectorDensity.Value; } MyObjectBuilder_PlanetMapProvider mapProvider = definition.MapProvider; if (definition.MapProvider == null) { MyObjectBuilder_PlanetMapProvider local1 = definition.MapProvider; MyObjectBuilder_PlanetTextureMapProvider provider1 = new MyObjectBuilder_PlanetTextureMapProvider(); provider1.Path = this.FolderName; mapProvider = provider1; } this.MapProvider = mapProvider; this.MesherPostprocessing = definition.MesherPostprocessing; if (this.MesherPostprocessing == null) { MyLog.Default.Warning("PERFORMANCE WARNING: Postprocessing voxel triangle decimation steps not defined for " + this, Array.Empty <object>()); } this.MinimumSurfaceLayerDepth = definition.MinimumSurfaceLayerDepth; }
// receiving messages private void LiveDebugging_ReceivedMessageHandler(MyExternalDebugStructures.CommonMsgHeader messageHeader, IntPtr messageData) { MyExternalDebugStructures.ACReloadInGameMsg msgReload; if (MyExternalDebugStructures.ReadMessageFromPtr(ref messageHeader, messageData, out msgReload)) { try { string acContentPath = msgReload.ACContentAddress; string acAddress = msgReload.ACAddress; string acName = msgReload.ACName; MyObjectBuilder_Definitions allDefinitions; // = null; // load animation controller definition from SBC file if (MyObjectBuilderSerializer.DeserializeXML(acAddress, out allDefinitions) && allDefinitions.Definitions != null && allDefinitions.Definitions.Length > 0) { var firstDef = allDefinitions.Definitions[0]; MyModContext context = new MyModContext(); context.Init("AnimationControllerDefinition", acAddress, acContentPath); MyAnimationControllerDefinition animationControllerDefinition = new MyAnimationControllerDefinition(); animationControllerDefinition.Init(firstDef, context); MyStringHash animSubtypeNameHash = MyStringHash.GetOrCompute(acName); // post process and update in def. manager MyAnimationControllerDefinition originalAnimationControllerDefinition = MyDefinitionManagerBase.Static.GetDefinition <MyAnimationControllerDefinition>( animSubtypeNameHash); var postprocessor = MyDefinitionManagerBase.GetPostProcessor(typeof(MyObjectBuilder_AnimationControllerDefinition)); if (postprocessor != null) { MyDefinitionPostprocessor.Bundle originalBundle = new MyDefinitionPostprocessor.Bundle { Context = MyModContext.BaseGame, Definitions = new Dictionary <MyStringHash, MyDefinitionBase> { { animSubtypeNameHash, originalAnimationControllerDefinition } }, Set = new MyDefinitionSet() }; originalBundle.Set.AddDefinition(originalAnimationControllerDefinition); MyDefinitionPostprocessor.Bundle overridingBundle = new MyDefinitionPostprocessor.Bundle { Context = context, Definitions = new Dictionary <MyStringHash, MyDefinitionBase> { { animSubtypeNameHash, animationControllerDefinition } }, Set = new MyDefinitionSet() }; overridingBundle.Set.AddDefinition(animationControllerDefinition); // postprocess -> override existing definition in memory postprocessor.AfterLoaded(ref overridingBundle); postprocessor.OverrideBy(ref originalBundle, ref overridingBundle); } // swap animation controller for each entity foreach (var component in m_skinnedEntityComponents) { if (component != null && component.SourceId.SubtypeName == acName) { component.Clear(); component.InitFromDefinition(originalAnimationControllerDefinition, forceReloadMwm: true); // reload from original def that was modified by postprocessor if (component.ReloadBonesNeeded != null) { component.ReloadBonesNeeded(); } } } } } catch (Exception e) { MyLog.Default.WriteLine(e); } } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.Init(objectBuilder, cubeGrid); var medicalRoomDefinition = BlockDefinition as MyMedicalRoomDefinition; MyStringHash resourceSinkGroup; if (medicalRoomDefinition != null) { m_idleSound = new MySoundPair(medicalRoomDefinition.IdleSound); m_progressSound = new MySoundPair(medicalRoomDefinition.ProgressSound); resourceSinkGroup = MyStringHash.GetOrCompute(medicalRoomDefinition.ResourceSinkGroup); } else { m_idleSound = new MySoundPair("BlockMedical"); m_progressSound = new MySoundPair("BlockMedicalProgress"); resourceSinkGroup = MyStringHash.GetOrCompute("Utility"); } m_rechargeSocket = new MyRechargeSocket(); NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME; SteamUserId = (objectBuilder as MyObjectBuilder_MedicalRoom).SteamUserId; if (SteamUserId != 0) //backward compatibility { MyPlayer controller = Sync.Players.GetPlayerById(new MyPlayer.PlayerId(SteamUserId)); if (controller != null) { IDModule.Owner = controller.Identity.IdentityId; IDModule.ShareMode = MyOwnershipShareModeEnum.Faction; } } SteamUserId = 0; m_takeSpawneeOwnership = (objectBuilder as MyObjectBuilder_MedicalRoom).TakeOwnership; m_setFactionToSpawnee = (objectBuilder as MyObjectBuilder_MedicalRoom).SetFaction; SyncObject = new SyncClass(this); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; InitializeConveyorEndpoint(); SinkComp = new MyResourceSinkComponent(); SinkComp.Init( resourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_MEDICAL_ROOM, () => (Enabled && IsFunctional) ? SinkComp.MaxRequiredInput : 0f); SinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; SinkComp.Update(); AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(SinkComp, this)); if (this.CubeGrid.CreatePhysics) { Components.Add <MyRespawnComponent>(new MyRespawnComponent()); } }
private void Grind() { var block = GetTargetBlock(); MyStringHash target = m_metal; if (block != null && (!(MySession.Static.IsScenario || MySession.Static.Settings.ScenarioEditMode) || block.CubeGrid.BlocksDestructionEnabled)) { float hackMultiplier = 1.0f; if (block.FatBlock != null && Owner != null && Owner.ControllerInfo.Controller != null && Owner.ControllerInfo.Controller.Player != null) { var relation = block.FatBlock.GetUserRelationToOwner(Owner.ControllerInfo.Controller.Player.Identity.IdentityId); if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies || relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Neutral) { hackMultiplier = MySession.Static.HackSpeedMultiplier; } } float damage = GrinderAmount; MyDamageInformation damageInfo = new MyDamageInformation(false, damage * hackMultiplier, MyDamageType.Grind, EntityId); if (block.UseDamageSystem) { MyDamageSystem.Static.RaiseBeforeDamageApplied(block, ref damageInfo); } block.DecreaseMountLevel(damageInfo.Amount, CharacterInventory); block.MoveItemsFromConstructionStockpile(CharacterInventory); if (block.UseDamageSystem) { MyDamageSystem.Static.RaiseAfterDamageApplied(block, damageInfo); } if (block.IsFullyDismounted) { if (block.UseDamageSystem) { MyDamageSystem.Static.RaiseDestroyed(block, damageInfo); } block.SpawnConstructionStockpile(); block.CubeGrid.RazeBlock(block.Min); } if (block.BlockDefinition.PhysicalMaterial.Id.SubtypeName.Length > 0) { target = block.BlockDefinition.PhysicalMaterial.Id.SubtypeId; } } var targetDestroyable = GetTargetDestroyable(); if (targetDestroyable != null) { //HACK to not grind yourself if (targetDestroyable is MyCharacter && (targetDestroyable as MyCharacter) == Owner) { return; } //damage tracking if (targetDestroyable is MyCharacter && MySession.Static.ControlledEntity == this.Owner && (targetDestroyable as MyCharacter).IsDead == false) { MySession.Static.TotalDamageDealt += 20; } targetDestroyable.DoDamage(20, MyDamageType.Grind, true, attackerId: Owner != null ? Owner.EntityId : 0); if (targetDestroyable is MyCharacter) { target = MyStringHash.GetOrCompute((targetDestroyable as MyCharacter).Definition.PhysicalMaterial); } } if (block != null || targetDestroyable != null) { m_actualSound = MyMaterialPropertiesHelper.Static.GetCollisionCue(MyMaterialPropertiesHelper.CollisionType.Start, m_source, target); } }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { m_defId = builder.GetId(); var def = MyDefinitionManager.Static.GetCubeBlockDefinition(m_defId) as MyShipDrillDefinition; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( def.ResourceSinkGroup, ComputeMaxRequiredPower(), ComputeRequiredPower); ResourceSink = sinkComp; m_drillBase = new MyDrillBase(this, MyDrillConstants.DRILL_SHIP_DUST_EFFECT, MyDrillConstants.DRILL_SHIP_DUST_STONES_EFFECT, MyDrillConstants.DRILL_SHIP_SPARKS_EFFECT, new MyDrillSensorSphere(def.SensorRadius, def.SensorOffset), new MyDrillCutOut(def.SensorOffset, def.SensorRadius), HEAD_SLOWDOWN_TIME_IN_SECONDS, -0.4f, 0.4f, 1 ); base.Init(builder, cubeGrid); m_blockLength = def.Size.Z; m_cubeSideLength = MyDefinitionManager.Static.GetCubeSize(def.CubeSize); float inventoryVolume = def.Size.X * def.Size.Y * def.Size.Z * m_cubeSideLength * m_cubeSideLength * m_cubeSideLength * 0.5f; Vector3 inventorySize = new Vector3(def.Size.X, def.Size.Y, def.Size.Z * 0.5f); if (this.GetInventory() == null) { MyInventory inventory = new MyInventory(inventoryVolume, inventorySize, MyInventoryFlags.CanSend); Components.Add <MyInventoryBase>(inventory); } Debug.Assert(this.GetInventory().Owner == this, "Ownership was not set!"); this.GetInventory().Constraint = new MyInventoryConstraint(MySpaceTexts.ToolTipItemFilter_AnyOre) .AddObjectBuilderType(typeof(MyObjectBuilder_Ore)); SlimBlock.UsesDeformation = false; SlimBlock.DeformationRatio = def.DeformationRatio; // 3x times harder for destruction by high speed m_drillBase.OutputInventory = this.GetInventory(); m_drillBase.IgnoredEntities.Add(this); m_drillBase.OnWorldPositionChanged(WorldMatrix); m_wantsToCollect = false; AddDebugRenderComponent(new MyDebugRenderCompomentDrawDrillBase(m_drillBase)); ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink.Update(); AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(ResourceSink, this)); var obDrill = (MyObjectBuilder_Drill)builder; this.GetInventory().Init(obDrill.Inventory); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; m_useConveyorSystem.Value = obDrill.UseConveyorSystem; UpdateDetailedInfo(); m_wantsToDrill = obDrill.Enabled; IsWorkingChanged += OnIsWorkingChanged; m_drillBase.m_drillMaterial = MyStringHash.GetOrCompute("ShipDrill"); m_drillBase.m_idleSoundLoop = new MySoundPair("ToolShipDrillIdle"); }
public void DamageProcess() { Settings.Data.LastExecCommandTime = DateTime.Now; LogTo("Damage wave incoming"); ReflectRevealAll(); List <MyCubeGrid> AllGrids = MyEntities.GetEntities().OfType <MyCubeGrid>().ToList <MyCubeGrid>(); LogTo("All grids count:" + AllGrids.Count()); var tblocks = new ConcurrentDictionary <Sandbox.Game.Entities.Cube.MySlimBlock, float>(); ParallelTasks.Parallel.ForEach(AllGrids, (cubegrid) => //cycles through all entities { try { if (cubegrid.MarkedForClose || cubegrid.Closed) { return; //if it is not a Physics grid, or no longer exists, skip to next } var blocks = new HashSet <Sandbox.Game.Entities.Cube.MySlimBlock>(); blocks = cubegrid.GetBlocks(); if (blocks.Count == 0) { return; } foreach (var rule in Settings.Data.BigRuleList) { // LogTo("TargetSubtypeId " + rule.TargetSubtypeId + " TargetTypeIdString " + rule.TargetTypeId.ToString()); if (rule.TargetTypeIdString != null && rule.TargetSubtypeId != null) { foreach (var blockk in blocks) { //LogTo("block = SubtypeId: " + blockk.BlockDefinition.Id.SubtypeId.String + " TypeId:" + blockk.BlockDefinition.Id.TypeId); if ((blockk.BlockDefinition.Id.TypeId.ToString() == rule.TargetTypeId.ToString()) && (blockk.BlockDefinition.Id.SubtypeId.String == rule.TargetSubtypeId)) { tblocks.AddOrUpdate(blockk, rule.Damage, (k, v) => v); } } } } } catch (Exception ex) { LogTo("ex= " + ex.ToString()); } }, ParallelTasks.WorkPriority.High, null, true); var toRemove = new HashSet <Sandbox.Game.Entities.Cube.MySlimBlock>(); foreach (var target in tblocks) //cycles through list of targeted blocks { LogTo("Found block for damage " + target.Key.BlockDefinition.DisplayNameText + "Integrity " + target.Key.Integrity + "/" + target.Key.MaxIntegrity + " " + target.Key.CurrentDamage + " BuildPercent: " + target.Key.BuildPercent() + "damage percent: " + target.Value); if (target.Key?.CubeGrid == null || target.Key.BuildPercent() <= (float)0.05 || target.Key.Closed()) //if the block doesnt exist or is below min build percentage { // LogTo("add block for delete: " + target.Key.FatBlock.DisplayName); toRemove.Add(target.Key); //mark block for removal, skips damage step continue; } target.Key.DoDamage((target.Key.MaxIntegrity / 100) * target.Value, MyStringHash.GetOrCompute("Degradation"), true, null, 0); //applies damage } foreach (Sandbox.Game.Entities.Cube.MySlimBlock block in toRemove) //removes blocks marked for removal { LogTo("Remove critical damaged block " + block.BlockDefinition.Id.SubtypeId.String); block.CubeGrid.RemoveBlock(block); } Settings.Save(Path.Combine(StoragePath, "DamageWave.cfg")); }
private MyCueId CheckDistanceSounds(MyCueId soundId) { if (soundId.IsNull == false) { if (m_lastSoundData != null && m_lastSoundData.DistantSounds != null && m_lastSoundData.DistantSounds.Count > 0) { float distanceToSoundSquered = Vector3.DistanceSquared(MySector.MainCamera.Position, this.SourcePosition); int bestSoundIndex = -1; m_usesDistanceSounds = true; m_secondaryEnabled = false; float dist, crossfadeDist; for (int i = 0; i < m_lastSoundData.DistantSounds.Count; i++) { dist = m_lastSoundData.DistantSounds[i].distance * m_lastSoundData.DistantSounds[i].distance; if (distanceToSoundSquered > dist) { bestSoundIndex = i; } else { crossfadeDist = m_lastSoundData.DistantSounds[i].distanceCrossfade >= 0f ? m_lastSoundData.DistantSounds[i].distanceCrossfade * m_lastSoundData.DistantSounds[i].distanceCrossfade : float.MaxValue; if (distanceToSoundSquered > crossfadeDist) { m_secondaryVolumeRatio = (distanceToSoundSquered - crossfadeDist) / (dist - crossfadeDist); m_secondaryEnabled = true; MySoundPair secondarySoundPair = new MySoundPair(m_lastSoundData.DistantSounds[i].sound); if (secondarySoundPair != MySoundPair.Empty) { m_secondaryCueEnum = SelectCue(secondarySoundPair); } else { m_secondaryCueEnum = new MyCueId(MyStringHash.GetOrCompute(m_lastSoundData.DistantSounds[bestSoundIndex].sound)); } } else { break; } } } if (bestSoundIndex >= 0) { MySoundPair soundPair = new MySoundPair(m_lastSoundData.DistantSounds[bestSoundIndex].sound); if (soundPair != MySoundPair.Empty) { m_soundPair = soundPair; soundId = SelectCue(m_soundPair); } else { soundId = new MyCueId(MyStringHash.GetOrCompute(m_lastSoundData.DistantSounds[bestSoundIndex].sound)); } } else { m_soundPair = m_closeSoundSoundPair; } } else { m_usesDistanceSounds = false; } } if (m_secondaryEnabled == false) { m_secondaryCueEnum = myEmptyCueId; } return(soundId); }
public void Init(long seed, string generator, double radius) { Debug.Assert(radius > 0, "The planet radius must be a strictly positive number!"); radius = Math.Max(radius, 1.0); var def = MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(generator)); if (def == null) { throw new Exception(String.Format("Cannot load planet generator definition for subtype '{0}'.", generator)); } Generator = def; m_data = new PlanetData() { Radius = radius, Seed = seed, Version = STORAGE_VERSION }; Init(); }
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 ReadFrom(ref MyOctreeStorage.ChunkHeader header, System.IO.Stream stream, ref bool isOldFormat) { m_data.Version = stream.ReadInt64(); m_data.Seed = stream.ReadInt64(); m_data.Radius = stream.ReadDouble(); string generator = stream.ReadString(); if (m_data.Version != STORAGE_VERSION) { isOldFormat = true; } var def = MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(generator)); if (def == null) { throw new Exception(String.Format("Cannot load planet generator definition for subtype '{0}'.", generator)); } Generator = def; Init(); }
// -------------------------------------------------------------------------------------------- /// <summary> /// Reload all mwm tracks while in-game. Mwms from cache are not used. /// </summary> public void ReloadMwmTracks() { foreach (var component in m_skinnedEntityComponents) { MyAnimationControllerDefinition animationControllerDefinition = MyDefinitionManagerBase.Static.GetDefinition <MyAnimationControllerDefinition>(MyStringHash.GetOrCompute(component.SourceId.SubtypeName)); if (animationControllerDefinition != null) { component.Clear(); component.InitFromDefinition(animationControllerDefinition, forceReloadMwm: true); // reload from original def that was modified by postprocessor if (component.ReloadBonesNeeded != null) { component.ReloadBonesNeeded(); } } } }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { var doorDefinition = BlockDefinition as MyDoorDefinition; MyStringHash resourceSinkGroup; if (doorDefinition != null) { MaxOpen = doorDefinition.MaxOpen; m_openSound = new MySoundPair(doorDefinition.OpenSound); m_closeSound = new MySoundPair(doorDefinition.CloseSound); resourceSinkGroup = MyStringHash.GetOrCompute(doorDefinition.ResourceSinkGroup); } else { MaxOpen = 1.2f; m_openSound = new MySoundPair("BlockDoorSmallOpen"); m_closeSound = new MySoundPair("BlockDoorSmallClose"); resourceSinkGroup = MyStringHash.GetOrCompute("Doors"); } var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( resourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_DOOR, () => (Enabled && IsFunctional) ? sinkComp.MaxRequiredInput : 0f); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink = sinkComp; base.Init(builder, cubeGrid); //m_subpartsSize = 0.5f * (0.5f * SlimBlock.CubeGrid.GridSize - 0.3f); var ob = (MyObjectBuilder_Door)builder; m_open.Value = ob.State; if (ob.Opening == -1) { m_currOpening = IsFunctional ? 0 : MaxOpen; m_open.Value = !IsFunctional; } else { m_currOpening = ob.Opening; } if (!Enabled || !ResourceSink.IsPowered) { UpdateSlidingDoorsPosition(true); } OnStateChange(); if (m_open) { // required when reinitializing a door after the armor beneath it is destroyed if (Open && (m_currOpening == MaxOpen)) { UpdateSlidingDoorsPosition(true); } } sinkComp.Update(); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; }
private void InheritFrom(string generator) { MyPlanetGeneratorDefinition definition = MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(generator)); if (definition == null) { MyDefinitionManager.Static.LoadingSet.m_planetGeneratorDefinitions.TryGetValue(new MyDefinitionId(typeof(MyObjectBuilder_PlanetGeneratorDefinition), generator), out definition); } if (definition == null) { MyLog.Default.WriteLine($"Could not find planet generator definition for '{generator}'."); } else { this.PlanetMaps = definition.PlanetMaps; this.HasAtmosphere = definition.HasAtmosphere; this.Atmosphere = definition.Atmosphere; this.CloudLayers = definition.CloudLayers; this.SoundRules = definition.SoundRules; this.MusicCategories = definition.MusicCategories; this.HillParams = definition.HillParams; this.MaterialsMaxDepth = definition.MaterialsMaxDepth; this.MaterialsMinDepth = definition.MaterialsMinDepth; this.GravityFalloffPower = definition.GravityFalloffPower; this.HostileAtmosphereColorShift = definition.HostileAtmosphereColorShift; this.SurfaceMaterialTable = definition.SurfaceMaterialTable; this.DistortionTable = definition.DistortionTable; this.DefaultSurfaceMaterial = definition.DefaultSurfaceMaterial; this.DefaultSubSurfaceMaterial = definition.DefaultSubSurfaceMaterial; this.MaterialGroups = definition.MaterialGroups; this.MaterialEnvironmentMappings = definition.MaterialEnvironmentMappings; this.SurfaceGravity = definition.SurfaceGravity; this.AtmosphereSettings = definition.AtmosphereSettings; this.FolderName = definition.FolderName; this.MaterialBlending = definition.MaterialBlending; this.OreMappings = definition.OreMappings; this.AnimalSpawnInfo = definition.AnimalSpawnInfo; this.NightAnimalSpawnInfo = definition.NightAnimalSpawnInfo; this.Detail = definition.Detail; this.SectorDensity = definition.SectorDensity; this.EnvironmentSectorType = definition.EnvironmentSectorType; this.MesherPostprocessing = definition.MesherPostprocessing; this.MinimumSurfaceLayerDepth = definition.MinimumSurfaceLayerDepth; } }
public static int GetHashFromType(Type type) { return(MyStringHash.GetOrCompute(type.FullName).GetHashCode()); }