public void DecreaseMountLevel(float unmountAmount, MyConstructionStockpile outputStockpile = null, bool useDefaultDeconstructEfficiency = false) { float ratio = this.BuildIntegrity / this.Integrity; this.UnmountInternal(unmountAmount, outputStockpile, false, useDefaultDeconstructEfficiency); this.UpdateBuildIntegrityDown(ratio); }
public void GetMissingComponents(Dictionary <string, int> addToDictionary, MyConstructionStockpile availableItems = null) { Dictionary <string, int> dictionary; string str2; int topGroupIndex = this.m_topGroupIndex; MyCubeBlockDefinition.Component component = this.m_blockDefinition.Components[topGroupIndex]; int num2 = this.m_topComponentIndex + 1; if (this.IsFullyDismounted) { num2--; } if (num2 < component.Count) { string subtypeName = component.Definition.Id.SubtypeName; if (!addToDictionary.ContainsKey(subtypeName)) { addToDictionary[subtypeName] = component.Count - num2; } else { dictionary = addToDictionary; str2 = subtypeName; dictionary[str2] += component.Count - num2; } } topGroupIndex++; while (topGroupIndex < this.m_blockDefinition.Components.Length) { component = this.m_blockDefinition.Components[topGroupIndex]; string subtypeName = component.Definition.Id.SubtypeName; if (!addToDictionary.ContainsKey(subtypeName)) { addToDictionary[subtypeName] = component.Count; } else { dictionary = addToDictionary; str2 = subtypeName; dictionary[str2] += component.Count; } topGroupIndex++; } if (availableItems != null) { for (topGroupIndex = 0; topGroupIndex < addToDictionary.Keys.Count; topGroupIndex++) { string subtypeName = addToDictionary.Keys.ElementAt <string>(topGroupIndex); dictionary = addToDictionary; str2 = subtypeName; dictionary[str2] -= availableItems.GetItemAmount(new MyDefinitionId(typeof(MyObjectBuilder_Component), subtypeName), MyItemFlags.None); if (addToDictionary[subtypeName] <= 0) { addToDictionary.Remove(subtypeName); topGroupIndex--; } } } }
public bool CanContinueBuild(MyInventory inventory, MyConstructionStockpile stockpile) { if (IsFullIntegrity) { return(false); } float topIntegrity = GetTopComponentIntegrity(); if (topIntegrity < m_blockDefinition.Components[m_topGroupIndex].Definition.MaxIntegrity) { return(true); } int nextCompoGroup = m_topGroupIndex; if (m_topComponentIndex == m_blockDefinition.Components[nextCompoGroup].Count - 1) { nextCompoGroup++; } var componentDefinition = m_blockDefinition.Components[nextCompoGroup].Definition; if (stockpile != null && stockpile.GetItemAmount(componentDefinition.Id) > 0) { return(true); } if (inventory != null && inventory.GetItemAmount(componentDefinition.Id) > 0) { return(true); } return(false); }
public void ApplyDamage(float damage, MyConstructionStockpile outputStockpile = null) { this.UnmountInternal(damage, outputStockpile, true, false); float ratio = this.BuildIntegrity / this.Integrity; this.UpdateBuildIntegrityDown(ratio); }
/// <summary> /// Applies damage to the component stack. The method works almost the same as dismounting, it just leaves the /// build level at the original value and also the parts that are put into the outputStockpile are damaged. /// </summary> public void ApplyDamage(float damage, MyConstructionStockpile outputStockpile = null) { Debug.Assert(!IsDestroyed, "Applying damage to an already destroyed stack. Block should have been removed."); bool oldWorkingState = IsFunctional; UnmountInternal(damage, outputStockpile, true); CheckFunctionalState(oldWorkingState); }
private void UnmountInternal(float unmountAmount, MyConstructionStockpile outputStockpile = null, bool damageItems = false, bool useDefaultDeconstructEfficiency = false) { float topComponentIntegrity = this.GetTopComponentIntegrity(); int topGroupIndex = this.m_topGroupIndex; int topComponentIndex = this.m_topComponentIndex; MyObjectBuilder_PhysicalObject physicalObject = null; MyObjectBuilder_Ore scrapBuilder = MyFloatingObject.ScrapBuilder; while ((unmountAmount * this.GetDeconstructionEfficiency(topGroupIndex, damageItems | useDefaultDeconstructEfficiency)) >= topComponentIntegrity) { this.Integrity -= topComponentIntegrity; unmountAmount -= topComponentIntegrity; if ((outputStockpile != null) && MySession.Static.SurvivalMode) { bool flag = damageItems && MyFakes.ENABLE_DAMAGED_COMPONENTS; if (!damageItems || (flag && (MyRandom.Instance.NextFloat() <= this.m_blockDefinition.Components[topGroupIndex].Definition.DropProbability))) { physicalObject = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject((SerializableDefinitionId)this.m_blockDefinition.Components[topGroupIndex].DeconstructItem.Id); if (flag) { physicalObject.Flags |= MyItemFlags.Damaged; } if ((this.Integrity > 0f) || this.m_yieldLastComponent) { outputStockpile.AddItems(1, physicalObject); } } MyComponentDefinition definition = this.m_blockDefinition.Components[topGroupIndex].Definition; if (((MyFakes.ENABLE_SCRAP & damageItems) && (MyRandom.Instance.NextFloat() < definition.DropProbability)) && ((this.Integrity > 0f) || this.m_yieldLastComponent)) { outputStockpile.AddItems((int)(0.8f * definition.Mass), scrapBuilder); } } topComponentIndex--; if (topComponentIndex < 0) { topGroupIndex--; if (topGroupIndex < 0) { this.SetTopIndex(0, 0); this.Integrity = 0f; return; } topComponentIndex = this.m_blockDefinition.Components[topGroupIndex].Count - 1; } topComponentIntegrity = this.m_blockDefinition.Components[topGroupIndex].Definition.MaxIntegrity; this.SetTopIndex(topGroupIndex, topComponentIndex); } this.Integrity -= unmountAmount * this.GetDeconstructionEfficiency(topGroupIndex, damageItems | useDefaultDeconstructEfficiency); topComponentIntegrity -= unmountAmount * this.GetDeconstructionEfficiency(topGroupIndex, damageItems | useDefaultDeconstructEfficiency); if (topComponentIntegrity < 1.525902E-05f) { this.Integrity += 1.525902E-05f - topComponentIntegrity; topComponentIntegrity = 1.525902E-05f; } }
/// <summary> /// Applies damage to the component stack. The method works almost the same as dismounting, it just leaves the /// build level at the original value and also the parts that are put into the outputStockpile are damaged. /// </summary> public void ApplyDamage(float damage, MyConstructionStockpile outputStockpile = null) { Debug.Assert(!IsDestroyed, "Applying damage to an already destroyed stack. Block should have been removed."); UnmountInternal(damage, outputStockpile, true); float buildIntegrityRatio = BuildIntegrity / Integrity; // Save the original build integrity ratio // Following function calls CheckFunctionalState itself UpdateBuildIntegrityDown(buildIntegrityRatio); }
/// <summary> /// Dismounts component stack, dismounted items are put into output stockpile /// </summary> public void DecreaseMountLevel(float unmountAmount, MyConstructionStockpile outputStockpile = null) { Debug.Assert(!IsFullyDismounted, "Dismounting a fully dismounted block. Either it was not razed or it was not created correctly."); float buildIntegrityRatio = BuildIntegrity / Integrity; // Save the original build integrity ratio UnmountInternal(unmountAmount, outputStockpile); // Following function calls CheckFunctionalState itself UpdateBuildIntegrityDown(buildIntegrityRatio); }
public void GetMissingComponents(Dictionary <string, int> addToDictionary, MyConstructionStockpile availableItems = null) { int index = m_topGroupIndex; var component = m_blockDefinition.Components[index]; int mountCount = m_topComponentIndex + 1; if (IsFullyDismounted) { mountCount--; } if (mountCount < component.Count) { string subTypeId = component.Definition.Id.SubtypeName; if (addToDictionary.ContainsKey(subTypeId)) { addToDictionary[subTypeId] += component.Count - mountCount; } else { addToDictionary[subTypeId] = component.Count - mountCount; } } index++; for (; index < m_blockDefinition.Components.Length; index++) { component = m_blockDefinition.Components[index]; string subTypeId = component.Definition.Id.SubtypeName; if (addToDictionary.ContainsKey(subTypeId)) { addToDictionary[subTypeId] += component.Count; } else { addToDictionary[subTypeId] = component.Count; } } if (availableItems != null) { for (index = 0; index < addToDictionary.Keys.Count; index++) { string key = addToDictionary.Keys.ElementAt(index); addToDictionary[key] -= availableItems.GetItemAmount(new MyDefinitionId(typeof(MyObjectBuilder_Component), key)); if (addToDictionary[key] <= 0) { addToDictionary.Remove(key); index--; } } } }
private bool CheckOrMountFirstComponent(MyConstructionStockpile stockpile = null) { if (this.Integrity <= 7.629511E-06f) { MyComponentDefinition definition = this.m_blockDefinition.Components[0].Definition; if ((stockpile != null) && !stockpile.RemoveItems(1, definition.Id, MyItemFlags.None)) { return(false); } this.Integrity = 1.525902E-05f; this.UpdateBuildIntegrityUp(); } return(true); }
private bool CheckOrMountFirstComponent(MyConstructionStockpile stockpile = null) { if (Integrity > MOUNT_THRESHOLD / 2) { return(true); } var firstComponent = m_blockDefinition.Components[0].Definition; if (stockpile == null || stockpile.RemoveItems(1, firstComponent.Id)) { Integrity = MOUNT_THRESHOLD; UpdateBuildIntegrityUp(); return(true); } return(false); }
private void IncreaseMountLevelInternal(float mountAmount, MyConstructionStockpile stockpile = null) { if (this.CheckOrMountFirstComponent(stockpile)) { float topComponentIntegrity = this.GetTopComponentIntegrity(); float maxIntegrity = this.m_blockDefinition.Components[this.m_topGroupIndex].Definition.MaxIntegrity; int topGroupIndex = this.m_topGroupIndex; int topComponentIndex = this.m_topComponentIndex; while (mountAmount > 0f) { float num5 = maxIntegrity - topComponentIntegrity; if (mountAmount < num5) { this.Integrity += mountAmount; this.UpdateBuildIntegrityUp(); return; } this.Integrity += num5 + 1.525902E-05f; mountAmount -= num5 + 1.525902E-05f; if ((topComponentIndex + 1) >= this.m_blockDefinition.Components[this.m_topGroupIndex].Count) { topGroupIndex++; topComponentIndex = 0; } if (topGroupIndex == this.m_blockDefinition.Components.Length) { this.Integrity = this.MaxIntegrity; this.UpdateBuildIntegrityUp(); return; } MyComponentDefinition definition = this.m_blockDefinition.Components[topGroupIndex].Definition; if ((stockpile != null) && !stockpile.RemoveItems(1, definition.Id, MyItemFlags.None)) { this.Integrity -= 1.525902E-05f; this.UpdateBuildIntegrityUp(); return; } this.UpdateBuildIntegrityUp(); this.SetTopIndex(topGroupIndex, topComponentIndex); topComponentIntegrity = 1.525902E-05f; maxIntegrity = this.m_blockDefinition.Components[topGroupIndex].Definition.MaxIntegrity; } } }
public bool CanContinueBuild(MyInventoryBase inventory, MyConstructionStockpile stockpile) { if (this.IsFullIntegrity) { return(false); } if (this.GetTopComponentIntegrity() >= this.m_blockDefinition.Components[this.m_topGroupIndex].Definition.MaxIntegrity) { int topGroupIndex = this.m_topGroupIndex; if (this.m_topComponentIndex == (this.m_blockDefinition.Components[topGroupIndex].Count - 1)) { topGroupIndex++; } MyComponentDefinition definition = this.m_blockDefinition.Components[topGroupIndex].Definition; if ((stockpile == null) || (stockpile.GetItemAmount(definition.Id, MyItemFlags.None) <= 0)) { return((inventory != null) && (MyCubeBuilder.BuildComponent.GetItemAmountCombined(inventory, definition.Id) > 0)); } } return(true); }
public void IncreaseMountLevel(float mountAmount, MyConstructionStockpile stockpile = null) { bool isFunctional = this.IsFunctional; this.IncreaseMountLevelInternal(mountAmount, stockpile); }
private bool CheckOrMountFirstComponent(MyConstructionStockpile stockpile = null) { if (Integrity > MOUNT_THRESHOLD / 2) { return true; } var firstComponent = m_blockDefinition.Components[0].Definition; if (stockpile == null || stockpile.RemoveItems(1, firstComponent.Id)) { Integrity = MOUNT_THRESHOLD; UpdateBuildIntegrityUp(); return true; } return false; }
public void GetMissingComponents(Dictionary<string, int> addToDictionary, MyConstructionStockpile availableItems = null) { int index = m_topGroupIndex; var component = m_blockDefinition.Components[index]; int mountCount = m_topComponentIndex + 1; if (IsFullyDismounted) mountCount--; if (mountCount < component.Count) { string subTypeId = component.Definition.Id.SubtypeName; if (addToDictionary.ContainsKey(subTypeId)) addToDictionary[subTypeId] += component.Count - mountCount; else addToDictionary[subTypeId] = component.Count - mountCount; } index++; for (; index < m_blockDefinition.Components.Length; index++) { component = m_blockDefinition.Components[index]; string subTypeId = component.Definition.Id.SubtypeName; if (addToDictionary.ContainsKey(subTypeId)) addToDictionary[subTypeId] += component.Count; else addToDictionary[subTypeId] = component.Count; } if (availableItems != null) for (index = 0; index < addToDictionary.Keys.Count; index++ ) { string key = addToDictionary.Keys.ElementAt(index); addToDictionary[key] -= availableItems.GetItemAmount(new MyDefinitionId(typeof(MyObjectBuilder_Component), key)); if (addToDictionary[key] <= 0) { addToDictionary.Remove(key); index--; } } }
private void UnmountInternal(float unmountAmount, MyConstructionStockpile outputStockpile = null, bool damageItems = false) { // We don't have to update functional state in this function, because it is done in the caller functions. // If you start using this function anywhere else, don't forget to update functional state yourself! float topIntegrity = GetTopComponentIntegrity(); int groupIndex = (int)m_topGroupIndex; int compIndex = (int)m_topComponentIndex; // Continue removing components, until the to be removed component's health is larger than unmountAmount MyObjectBuilder_Component componentBuilder = null; var scrapBuilder = MyFloatingObject.ScrapBuilder; while (unmountAmount * GetDeconstructionEfficiency(groupIndex, damageItems) >= topIntegrity) { Integrity -= topIntegrity; unmountAmount -= topIntegrity; // In creative mode, the outputInventory should normally be null. // However, if we load the game from the realistic mode, it would not be necessarilly null. if (outputStockpile != null && MySession.Static.SurvivalMode) { bool doDamage = damageItems && MyFakes.ENABLE_DAMAGED_COMPONENTS; if (!damageItems || (doDamage && MyRandom.Instance.NextFloat() <= m_blockDefinition.Components[groupIndex].Definition.DropProbability)) { componentBuilder = MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Component>(); componentBuilder.SubtypeName = m_blockDefinition.Components[groupIndex].Definition.Id.SubtypeName; if (doDamage) { componentBuilder.Flags |= MyItemFlags.Damaged; } if (!outputStockpile.AddItems(1, componentBuilder)) { // TODO: Throw the items into space (although this branch should probably not happen) } } MyComponentDefinition destroyedComponentDefinition = m_blockDefinition.Components[groupIndex].Definition; if (MyFakes.ENABLE_SCRAP && damageItems && (MyRandom.Instance.NextFloat() < destroyedComponentDefinition.DropProbability)) { outputStockpile.AddItems((int)(0.8f * destroyedComponentDefinition.Mass), scrapBuilder); } } compIndex--; if (compIndex < 0) { groupIndex--; if (groupIndex < 0) { SetTopIndex(0, 0); Integrity = 0.0f; return; } else { compIndex = m_blockDefinition.Components[groupIndex].Count - 1; } } topIntegrity = m_blockDefinition.Components[groupIndex].Definition.MaxIntegrity; SetTopIndex(groupIndex, compIndex); } // Damage the remaining component Integrity -= unmountAmount * GetDeconstructionEfficiency(groupIndex, damageItems); topIntegrity -= unmountAmount * GetDeconstructionEfficiency(groupIndex, damageItems); if (topIntegrity < MOUNT_THRESHOLD) { Integrity += MOUNT_THRESHOLD - topIntegrity; topIntegrity = MOUNT_THRESHOLD; } Debug.Assert(Integrity >= MOUNT_THRESHOLD, "Integrity inconsistent after a dismount of component stack"); }
/// <summary> /// Dismounts component stack, dismounted items are put into output stockpile /// </summary> public void DecreaseMountLevel(float unmountAmount, MyConstructionStockpile outputStockpile = null) { Debug.Assert(!IsFullyDismounted, "Dismounting a fully dismounted block. Either it was not razed or it was not created correctly."); float buildIntegrityRatio = BuildIntegrity / Integrity; // Save the original build integrity ratio UnmountInternal(unmountAmount, outputStockpile); // Following function calls CheckFunctionalState itself UpdateBuildIntegrityDown(buildIntegrityRatio); }
private void IncreaseMountLevelInternal(float mountAmount, MyConstructionStockpile stockpile = null) { Debug.Assert(BuildIntegrity >= Integrity, "Integrity of component stack is larger than build integrity"); if (!CheckOrMountFirstComponent(stockpile)) { return; } float topIntegrity = GetTopComponentIntegrity(); float maxCompIntegrity = m_blockDefinition.Components[m_topGroupIndex].Definition.MaxIntegrity; int groupIndex = (int)m_topGroupIndex; int compIndex = (int)m_topComponentIndex; while (mountAmount > 0) { float toBuild = maxCompIntegrity - topIntegrity; if (mountAmount < toBuild) { Integrity += mountAmount; UpdateBuildIntegrityUp(); break; } Integrity += toBuild + MOUNT_THRESHOLD; mountAmount -= toBuild + MOUNT_THRESHOLD; ++compIndex; if (compIndex >= m_blockDefinition.Components[m_topGroupIndex].Count) { ++groupIndex; compIndex = 0; } // Fully built if (groupIndex == m_blockDefinition.Components.Length) { Integrity = MaxIntegrity; UpdateBuildIntegrityUp(); break; } // We don't have the next item var nextComponent = m_blockDefinition.Components[groupIndex].Definition; if (stockpile != null && !stockpile.RemoveItems(1, nextComponent.Id)) { Integrity -= MOUNT_THRESHOLD; UpdateBuildIntegrityUp(); break; } else { UpdateBuildIntegrityUp(); } SetTopIndex(groupIndex, compIndex); topIntegrity = MOUNT_THRESHOLD; maxCompIntegrity = m_blockDefinition.Components[groupIndex].Definition.MaxIntegrity; } return; }
public void IncreaseMountLevel(float mountAmount, MyConstructionStockpile stockpile = null) { bool oldWorkingState = IsFunctional; IncreaseMountLevelInternal(mountAmount, stockpile); }
/// <summary> /// Applies damage to the component stack. The method works almost the same as dismounting, it just leaves the /// build level at the original value and also the parts that are put into the outputStockpile are damaged. /// </summary> public void ApplyDamage(float damage, MyConstructionStockpile outputStockpile = null) { Debug.Assert(!IsDestroyed, "Applying damage to an already destroyed stack. Block should have been removed."); UnmountInternal(damage, outputStockpile, true); float buildIntegrityRatio = BuildIntegrity / Integrity; // Save the original build integrity ratio // Following function calls CheckFunctionalState itself UpdateBuildIntegrityDown(buildIntegrityRatio); }
public void IncreaseMountLevel(float mountAmount, MyConstructionStockpile stockpile = null) { bool oldWorkingState = IsFunctional; IncreaseMountLevelInternal(mountAmount, stockpile); }
public bool CanContinueBuild(MyInventory inventory, MyConstructionStockpile stockpile) { if (IsFullIntegrity) return false; float topIntegrity = GetTopComponentIntegrity(); if (topIntegrity < m_blockDefinition.Components[m_topGroupIndex].Definition.MaxIntegrity) return true; int nextCompoGroup = m_topGroupIndex; if (m_topComponentIndex == m_blockDefinition.Components[nextCompoGroup].Count - 1) { nextCompoGroup++; } var componentDefinition = m_blockDefinition.Components[nextCompoGroup].Definition; if (stockpile != null && stockpile.GetItemAmount(componentDefinition.Id) > 0) { return true; } if (inventory != null && inventory.GetItemAmount(componentDefinition.Id) > 0) { return true; } return false; }
private void UnmountInternal(float unmountAmount, MyConstructionStockpile outputStockpile = null, bool damageItems = false) { // We don't have to update functional state in this function, because it is done in the caller functions. // If you start using this function anywhere else, don't forget to update functional state yourself! float topIntegrity = GetTopComponentIntegrity(); int groupIndex = (int)m_topGroupIndex; int compIndex = (int)m_topComponentIndex; // Continue removing components, until the to be removed component's health is larger than unmountAmount MyObjectBuilder_Component componentBuilder = null; var scrapBuilder = MyFloatingObject.ScrapBuilder; while (unmountAmount * GetDeconstructionEfficiency(groupIndex, damageItems) >= topIntegrity) { Integrity -= topIntegrity; unmountAmount -= topIntegrity; // In creative mode, the outputInventory should normally be null. // However, if we load the game from the realistic mode, it would not be necessarilly null. if (outputStockpile != null && MySession.Static.SurvivalMode) { bool doDamage = damageItems && MyFakes.ENABLE_DAMAGED_COMPONENTS; if (!damageItems || (doDamage && MyRandom.Instance.NextFloat() <= m_blockDefinition.Components[groupIndex].Definition.DropProbability)) { componentBuilder = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Component>(); componentBuilder.SubtypeName = m_blockDefinition.Components[groupIndex].Definition.Id.SubtypeName; if (doDamage) { componentBuilder.Flags |= MyItemFlags.Damaged; } if (!outputStockpile.AddItems(1, componentBuilder)) { // TODO: Throw the items into space (although this branch should probably not happen) } } MyComponentDefinition destroyedComponentDefinition = m_blockDefinition.Components[groupIndex].Definition; if (MyFakes.ENABLE_SCRAP && damageItems && (MyRandom.Instance.NextFloat() < destroyedComponentDefinition.DropProbability)) { outputStockpile.AddItems((int)(0.8f * destroyedComponentDefinition.Mass), scrapBuilder); } } compIndex--; if (compIndex < 0) { groupIndex--; if (groupIndex < 0) { SetTopIndex(0, 0); Integrity = 0.0f; return; } else { compIndex = m_blockDefinition.Components[groupIndex].Count - 1; } } topIntegrity = m_blockDefinition.Components[groupIndex].Definition.MaxIntegrity; SetTopIndex(groupIndex, compIndex); } // Damage the remaining component Integrity -= unmountAmount * GetDeconstructionEfficiency(groupIndex, damageItems); topIntegrity -= unmountAmount * GetDeconstructionEfficiency(groupIndex, damageItems); if (topIntegrity < MOUNT_THRESHOLD) { Integrity += MOUNT_THRESHOLD - topIntegrity; topIntegrity = MOUNT_THRESHOLD; } Debug.Assert(Integrity >= MOUNT_THRESHOLD, "Integrity inconsistent after a dismount of component stack"); }
private void IncreaseMountLevelInternal(float mountAmount, MyConstructionStockpile stockpile = null) { Debug.Assert(BuildIntegrity >= Integrity, "Integrity of component stack is larger than build integrity"); if (!CheckOrMountFirstComponent(stockpile)) { return; } float topIntegrity = GetTopComponentIntegrity(); float maxCompIntegrity = m_blockDefinition.Components[m_topGroupIndex].Definition.MaxIntegrity; int groupIndex = (int)m_topGroupIndex; int compIndex = (int)m_topComponentIndex; while (mountAmount > 0) { float toBuild = maxCompIntegrity - topIntegrity; if (mountAmount < toBuild) { Integrity += mountAmount; UpdateBuildIntegrityUp(); break; } Integrity += toBuild + MOUNT_THRESHOLD; mountAmount -= toBuild + MOUNT_THRESHOLD; ++compIndex; if (compIndex >= m_blockDefinition.Components[m_topGroupIndex].Count) { ++groupIndex; compIndex = 0; } // Fully built if (groupIndex == m_blockDefinition.Components.Length) { Integrity = MaxIntegrity; UpdateBuildIntegrityUp(); break; } // We don't have the next item var nextComponent = m_blockDefinition.Components[groupIndex].Definition; if (stockpile != null && !stockpile.RemoveItems(1, nextComponent.Id)) { Integrity -= MOUNT_THRESHOLD; UpdateBuildIntegrityUp(); break; } else { UpdateBuildIntegrityUp(); } SetTopIndex(groupIndex, compIndex); topIntegrity = MOUNT_THRESHOLD; maxCompIntegrity = m_blockDefinition.Components[groupIndex].Definition.MaxIntegrity; } return; }
/// <summary> /// Applies damage to the component stack. The method works almost the same as dismounting, it just leaves the /// build level at the original value and also the parts that are put into the outputStockpile are damaged. /// </summary> public void ApplyDamage(float damage, MyConstructionStockpile outputStockpile = null) { Debug.Assert(!IsDestroyed, "Applying damage to an already destroyed stack. Block should have been removed."); UnmountInternal(damage, outputStockpile, true); }