private void OnOwnerChanged(IMyComponentInventory inventory, IMyInventoryOwner owner) { if (OwnerChanged != null) { OwnerChanged(inventory, owner); } }
private void OnContentsChanged(IMyComponentInventory inventory) { if (ContentsChanged != null) { ContentsChanged(inventory); } }
/// <summary> /// Moves items with the given flags from the construction inventory to the character. /// If the flags are None, all items are moved. /// </summary> public void MoveItemsFromConstructionStockpile(IMyComponentInventory toInventory, MyItemFlags flags = MyItemFlags.None) { if (m_stockpile == null) return; Debug.Assert(toInventory != null); if (toInventory == null) return; m_tmpItemList.Clear(); foreach (var item in m_stockpile.GetItems()) { if (flags == MyItemFlags.None || (item.Content.Flags & flags) != 0) m_tmpItemList.Add(item); } m_stockpile.ClearSyncList(); foreach (var item in m_tmpItemList) { var amount = (int)toInventory.ComputeAmountThatFits(item.Content.GetId()); amount = Math.Min(amount, item.Amount); toInventory.AddItems(amount, item.Content); m_stockpile.RemoveItems(amount, item.Content); } CubeGrid.SyncObject.SendStockpileChanged(this, m_stockpile.GetSyncList()); m_stockpile.ClearSyncList(); }
public void MoveItemsToConstructionStockpile(IMyComponentInventory fromInventory) { if (MySession.Static.CreativeMode || MySession.Static.SimpleSurvival) return; m_tmpComponents.Clear(); GetMissingComponents(m_tmpComponents); if (m_tmpComponents.Count() != 0) { EnsureConstructionStockpileExists(); m_stockpile.ClearSyncList(); foreach (var kv in m_tmpComponents) { var id = new MyDefinitionId(typeof(MyObjectBuilder_Component), kv.Key); int amountAvailable = (int)fromInventory.GetItemAmount(id); int moveAmount = Math.Min(kv.Value, amountAvailable); if (moveAmount > 0) { fromInventory.RemoveItemsOfType(moveAmount, id); m_stockpile.AddItems(moveAmount, new MyDefinitionId(typeof(MyObjectBuilder_Component), kv.Key)); } } CubeGrid.SyncObject.SendStockpileChanged(this, m_stockpile.GetSyncList()); m_stockpile.ClearSyncList(); } }
public void MoveFirstItemToConstructionStockpile(IMyComponentInventory fromInventory) { if (MySession.Static.CreativeMode) { return; } EnsureConstructionStockpileExists(); MyComponentStack.GroupInfo info = ComponentStack.GetGroupInfo(0); m_stockpile.ClearSyncList(); if ((int)fromInventory.GetItemAmount(info.Component.Id) >= 1) { //Other player cant move your inventory and you also when trying to cosntruct so its safe already after check above ^^ fromInventory.RemoveItemsOfType(1, info.Component.Id, MyItemFlags.None); //Debug.Assert(removed, "Item not found, but reported available few lines above"); m_stockpile.AddItems(1, info.Component.Id); } CubeGrid.SyncObject.SendStockpileChanged(this, m_stockpile.GetSyncList()); m_stockpile.ClearSyncList(); }
public static void SetBlockComponents(MyHudBlockInfo hudInfo, MySlimBlock block, IMyComponentInventory availableInventory = null) { hudInfo.Components.Clear(); for (int i = 0; i < block.ComponentStack.GroupCount; i++) { var groupInfo = block.ComponentStack.GetGroupInfo(i); var componentInfo = new MyHudBlockInfo.ComponentInfo(); componentInfo.DefinitionId = groupInfo.Component.Id; componentInfo.ComponentName = groupInfo.Component.DisplayNameText; componentInfo.Icon = groupInfo.Component.Icon; componentInfo.TotalCount = groupInfo.TotalCount; componentInfo.MountedCount = groupInfo.MountedCount; if (availableInventory != null) componentInfo.AvailableAmount = (int)availableInventory.GetItemAmount(groupInfo.Component.Id); hudInfo.Components.Add(componentInfo); } if (!block.StockpileEmpty) { // For each component foreach (var comp in block.BlockDefinition.Components) { // Get amount in stockpile int amount = block.GetConstructionStockpileItemAmount(comp.Definition.Id); for (int i = 0; amount > 0 && i < hudInfo.Components.Count; i++) { if (block.ComponentStack.GetGroupInfo(i).Component == comp.Definition) { if (block.ComponentStack.IsFullyDismounted) { return; } // Distribute amount in stockpile from bottom to top var info = hudInfo.Components[i]; int space = info.TotalCount - info.MountedCount; int movedItems = Math.Min(space, amount); info.StockpileCount = movedItems; amount -= movedItems; hudInfo.Components[i] = info; } } } } }
virtual public void RemoveInventory(IMyComponentInventory inventory) { foreach (var child in m_children) { if (child.Inventories.Contains(inventory)) { child.RemoveInventory(inventory); return; } } m_attachedInventories.Remove(inventory); }
public override bool PasteGrid(IMyComponentInventory buildInventory = null, bool deactivate = true) { if ((CopiedGrids.Count > 0) && !IsActive) { Activate(); return true; } if (!m_canBePlaced) { MyGuiAudio.PlaySound(MyGuiSounds.HudUnable); return false; } if (PreviewGrids.Count == 0) return false; bool result; bool placingOnDynamicGrid = RemoveBlock != null && !RemoveBlock.CubeGrid.IsStatic; if (MyCubeBuilder.Static.DynamicMode || placingOnDynamicGrid) { result = PasteGridsInDynamicMode(buildInventory, deactivate); } else { result = PasteGridsInStaticMode(buildInventory, deactivate); } return result; }
private bool PasteGridsInDynamicMode(IMyComponentInventory buildInventory, bool deactivate) { bool result; // Remember static grid flag and set it to dynamic List<bool> gridStaticFlags = new List<bool>(); foreach (var copiedGrid in CopiedGrids) { gridStaticFlags.Add(copiedGrid.IsStatic); copiedGrid.IsStatic = false; } result = PasteGridInternal(buildInventory: buildInventory, deactivate: deactivate); // Set static grid flag back for (int i = 0; i < CopiedGrids.Count; ++i) CopiedGrids[i].IsStatic = gridStaticFlags[i]; return result; }
protected bool PasteGridInternal(IMyComponentInventory buildInventory, bool deactivate, List<MyObjectBuilder_CubeGrid> pastedBuilders = null, List<MyCubeGrid> touchingGrids = null, UpdateAfterPasteCallback updateAfterPasteCallback = null) { if (m_copiedGrids.Count == 0) return false; if ((m_copiedGrids.Count > 0) && !IsActive) { Activate(); return true; } if (!CanBePlaced) { MyGuiAudio.PlaySound(MyGuiSounds.HudUnable); return false; } if (m_previewGrids.Count == 0) return false; bool missingBlockDefinitions = !CheckPastedBlocks(); if (missingBlockDefinitions) { AllowSwitchCameraMode = false; var messageBox = MyGuiSandbox.CreateMessageBox( buttonType: MyMessageBoxButtonsType.YES_NO, messageText: MyTexts.Get(MySpaceTexts.MessageBoxTextDoYouWantToPasteGridWithMissingBlocks), messageCaption: MyTexts.Get(MySpaceTexts.MessageBoxCaptionWarning), callback: (result) => { if (result == MyGuiScreenMessageBox.ResultEnum.YES) { PasteInternal(buildInventory, missingBlockDefinitions, deactivate, pastedBuilders, updateAfterPasteCallback: updateAfterPasteCallback); } AllowSwitchCameraMode = true; }); MyGuiSandbox.AddScreen(messageBox); return false; } return PasteInternal(buildInventory, missingBlockDefinitions, deactivate, pastedBuilders: pastedBuilders, touchingGrids: touchingGrids, updateAfterPasteCallback: updateAfterPasteCallback); }
public virtual bool PasteGrid(IMyComponentInventory buildInventory = null, bool deactivate = true) { return PasteGridInternal(buildInventory, deactivate); }
private bool PasteGridsInStaticMode(IMyComponentInventory buildInventory, bool deactivate) { MatrixD firstGridMatrix = GetFirstGridOrientationMatrix(); MatrixD inverseFirstGridMatrix = Matrix.Invert(firstGridMatrix); List<MatrixD> previewMatrices = new List<MatrixD>(); foreach (var previewGrid in PreviewGrids) previewMatrices.Add(previewGrid.WorldMatrix); { // First grid is forced static MyObjectBuilder_CubeGrid originalCopiedGrid = CopiedGrids[0]; MatrixD previewGridWorldMatrix = PreviewGrids[0].WorldMatrix; // Convert grid builder to static ConvertGridBuilderToStatic(originalCopiedGrid, previewGridWorldMatrix); PreviewGrids[0].WorldMatrix = MatrixD.CreateTranslation(previewGridWorldMatrix.Translation); } for (int i = 1; i < CopiedGrids.Count; ++i) { if (CopiedGrids[i].IsStatic) { MyObjectBuilder_CubeGrid originalCopiedGrid = CopiedGrids[i]; MatrixD previewGridWorldMatrix = PreviewGrids[i].WorldMatrix; // Convert grid builder to static ConvertGridBuilderToStatic(originalCopiedGrid, previewGridWorldMatrix); PreviewGrids[i].WorldMatrix = MatrixD.CreateTranslation(previewGridWorldMatrix.Translation); } } // All static grids has been reset to default rotation, builders will be set from paste. List<MyObjectBuilder_CubeGrid> pastedBuilders = new List<MyObjectBuilder_CubeGrid>(); bool result = PasteGridInternal(buildInventory: buildInventory, deactivate: true, pastedBuilders: pastedBuilders, touchingGrids: m_touchingGrids, updateAfterPasteCallback: delegate(List<MyObjectBuilder_CubeGrid> pastedBuildersInCallback) { UpdateAfterPaste(deactivate, pastedBuildersInCallback); }); if (result) { UpdateAfterPaste(deactivate, pastedBuilders); } return result; }
public override bool PasteGrid(IMyComponentInventory buildInventory = null, bool deactivate = true) { if ((CopiedGrids.Count > 0) && !IsActive) { Activate(); return true; } if (!m_canBePlaced) { MyGuiAudio.PlaySound(MyGuiSounds.HudUnable); return false; } if (PreviewGrids.Count == 0) return false; bool result; bool isSnappedOnGrid = (m_hitEntity is MyCubeGrid) && IsSnapped && SnapMode == MyGridPlacementSettings.SnapMode.Base6Directions; bool placingDynamicGrid = !CopiedGrids[0].IsStatic && !isSnappedOnGrid; bool placingOnDynamicGrid = (m_hitEntity is MyCubeGrid) && !((MyCubeGrid)m_hitEntity).IsStatic && !MyCubeBuilder.Static.DynamicMode; if (MyCubeBuilder.Static.DynamicMode) { result = PasteGridsInDynamicMode(buildInventory, deactivate); } else if (placingDynamicGrid || placingOnDynamicGrid) { result = PasteGridInternal(buildInventory: buildInventory, deactivate: deactivate); } else { result = PasteGridsInStaticMode(buildInventory, deactivate); } return result; }
public void MoveUnneededItemsFromConstructionStockpile(IMyComponentInventory toInventory) { if (m_stockpile == null) return; Debug.Assert(toInventory != null); if (toInventory == null) return; m_tmpItemList.Clear(); AcquireUnneededStockpileItems(m_tmpItemList); m_stockpile.ClearSyncList(); foreach (var item in m_tmpItemList) { var amount = (int)toInventory.ComputeAmountThatFits(item.Content.GetId()); amount = Math.Min(amount, item.Amount); toInventory.AddItems(amount, item.Content); m_stockpile.RemoveItems(amount, item.Content); } CubeGrid.SyncObject.SendStockpileChanged(this, m_stockpile.GetSyncList()); m_stockpile.ClearSyncList(); }
private bool PasteInternal(IMyComponentInventory buildInventory, bool missingDefinitions, bool deactivate, List<MyObjectBuilder_CubeGrid> pastedBuilders = null, List<MyCubeGrid> touchingGrids = null, UpdateAfterPasteCallback updateAfterPasteCallback = null) { MyGuiAudio.PlaySound(MyGuiSounds.HudPlaceBlock); MyEntities.RemapObjectBuilderCollection(m_copiedGrids); m_tmpPastedBuilders.Clear(); m_tmpPastedBuilders.Capacity = m_copiedGrids.Count; MyCubeGrid firstPastedGrid = null; bool forceDynamicGrid = IsForcedDynamic() && !m_gridChangeToDynamicDisabled; int i = 0; bool retVal = false; List<MyCubeGrid> pastedGrids = new List<MyCubeGrid>(); foreach (var gridBuilder in m_copiedGrids) { gridBuilder.CreatePhysics = true; gridBuilder.EnableSmallToLargeConnections = true; bool savedStaticFlag = gridBuilder.IsStatic; if (forceDynamicGrid) { gridBuilder.IsStatic = false; } var previousPos = gridBuilder.PositionAndOrientation; gridBuilder.PositionAndOrientation = new MyPositionAndOrientation(m_previewGrids[i].WorldMatrix); var pastedGrid = MyEntities.CreateFromObjectBuilder(gridBuilder) as MyCubeGrid; if (pastedGrid == null) { retVal = true; continue; } if (MySession.Static.EnableStationVoxelSupport && pastedGrid.IsStatic) { pastedGrid.TestDynamic = true; } //pastedGrid.PositionComp.SetPosition(MySector.MainCamera.Position); MyEntities.Add(pastedGrid); if (i == 0) firstPastedGrid = pastedGrid; if (missingDefinitions) pastedGrid.DetectDisconnectsAfterFrame(); //pastedGrid.PositionComp.SetWorldMatrix(m_previewGrids[i].WorldMatrix); i++; if (!pastedGrid.IsStatic && (!MyFakes.ENABLE_BATTLE_SYSTEM || !MySession.Static.Battle)) pastedGrid.Physics.LinearVelocity = m_objectVelocity; if (!pastedGrid.IsStatic && MySession.ControlledEntity != null && MySession.ControlledEntity.Entity.Physics != null && m_calculateVelocity && (!MyFakes.ENABLE_BATTLE_SYSTEM || !MySession.Static.Battle)) { pastedGrid.Physics.AngularVelocity = MySession.ControlledEntity.Entity.Physics.AngularVelocity; } pastedGrids.Add(pastedGrid); gridBuilder.IsStatic = savedStaticFlag; retVal = true; } //Because blocks fills SubBlocks in this method.. //TODO: Create LoadPhase2 MyEntities.UpdateOnceBeforeFrame(); foreach (var pastedGrid in pastedGrids) { var builder = pastedGrid.GetObjectBuilder(); m_tmpPastedBuilders.Add(builder); if (pastedBuilders != null) pastedBuilders.Add((MyObjectBuilder_CubeGrid)builder); } if (IsSnapped && SnapMode == MyGridPlacementSettings.SnapMode.Base6Directions && m_hitEntity is MyCubeGrid && firstPastedGrid != null && ((MyCubeGrid)m_hitEntity).GridSizeEnum == firstPastedGrid.GridSizeEnum) { var hitGrid = m_hitEntity as MyCubeGrid; MatrixI mergingTransform = hitGrid.CalculateMergeTransform(firstPastedGrid, hitGrid.WorldToGridInteger(firstPastedGrid.PositionComp.GetPosition())); MySyncCreate.RequestMergingCopyPaste(m_tmpPastedBuilders, m_hitEntity.EntityId, mergingTransform); } else if (touchingGrids != null && touchingGrids.Count > 0) { // Currently only first grid is supported for merging. MyCubeGrid touchingGrid = touchingGrids[0]; if (touchingGrid != null) { MatrixI mergingTransform = touchingGrid.CalculateMergeTransform(firstPastedGrid, touchingGrid.WorldToGridInteger(firstPastedGrid.PositionComp.GetPosition())); MySyncCreate.RequestMergingCopyPaste(m_tmpPastedBuilders, touchingGrid.EntityId, mergingTransform); } else { //MySyncCreate.RequestEntitiesCreate(m_tmpPastedBuilders); MySyncCreate.SendEntitiesCreated(m_tmpPastedBuilders); } } else { // CH:TODO: This would probably be safer if it was requested from the server as well MySyncCreate.SendEntitiesCreated(m_tmpPastedBuilders); } // CH:TODO: Use only items for grids that were really added to not screw with players if (buildInventory != null) { foreach (var item in m_buildComponents.TotalMaterials) { buildInventory.RemoveItemsOfType(item.Value, item.Key); } } if (deactivate) Deactivate(); if (retVal && updateAfterPasteCallback != null) { updateAfterPasteCallback(pastedBuilders); } return retVal; }
public void ClearConstructionStockpile(IMyComponentInventory outputInventory) { if (!StockpileEmpty) { if (outputInventory != null && outputInventory.Owner.InventoryOwnerType == MyInventoryOwnerTypeEnum.Character) { MoveItemsFromConstructionStockpile(outputInventory); } else { m_stockpile.ClearSyncList(); m_tmpItemList.Clear(); foreach (var item in m_stockpile.GetItems()) { m_tmpItemList.Add(item); } foreach (var item in m_tmpItemList) { RemoveFromConstructionStockpile(item); } CubeGrid.SyncObject.SendStockpileChanged(this, m_stockpile.GetSyncList()); m_stockpile.ClearSyncList(); } } ReleaseConstructionStockpile(); }
public void IncreaseMountLevel(float welderMountAmount, long welderOwnerPlayerId, IMyComponentInventory outputInventory = null, float maxAllowedBoneMovement = 0.0f, bool isHelping = false, MyOwnershipShareModeEnum sharing = MyOwnershipShareModeEnum.Faction) { welderMountAmount *= BlockDefinition.IntegrityPointsPerSec; MySession.Static.PositiveIntegrityTotal += welderMountAmount; if (MySession.Static.CreativeMode) { ClearConstructionStockpile(outputInventory); } else { if (outputInventory != null && outputInventory.Owner.InventoryOwnerType == MyInventoryOwnerTypeEnum.Character) { MoveItemsFromConstructionStockpile(outputInventory, MyItemFlags.Damaged); } } float oldPercentage = m_componentStack.BuildRatio; float oldDamage = CurrentDamage; if (!BlockDefinition.RatioEnoughForOwnership(BuildLevelRatio) && BlockDefinition.RatioEnoughForOwnership((BuildIntegrity + welderMountAmount) / BlockDefinition.MaxIntegrity)) { if (FatBlock != null && outputInventory != null && !isHelping) { FatBlock.OnIntegrityChanged(BuildIntegrity, Integrity, true, welderOwnerPlayerId, sharing); } } if (MyFakes.SHOW_DAMAGE_EFFECTS && FatBlock != null && !BlockDefinition.RationEnoughForDamageEffect((Integrity+welderMountAmount) / MaxIntegrity)) {//stop effect FatBlock.SetDamageEffect(false); } bool removeDecals = false; if (m_stockpile != null) { m_stockpile.ClearSyncList(); m_componentStack.IncreaseMountLevel(welderMountAmount, m_stockpile); CubeGrid.SyncObject.SendStockpileChanged(this, m_stockpile.GetSyncList()); m_stockpile.ClearSyncList(); } else { m_componentStack.IncreaseMountLevel(welderMountAmount, null); } if (m_componentStack.IsFullIntegrity) { ReleaseConstructionStockpile(); removeDecals = true; } MyCubeGrid.MyIntegrityChangeEnum integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.Damage; if (BlockDefinition.ModelChangeIsNeeded(oldPercentage, m_componentStack.BuildRatio) || BlockDefinition.ModelChangeIsNeeded(m_componentStack.BuildRatio, oldPercentage)) { removeDecals = true; if (FatBlock != null) { // this needs to be detected here because for cubes the following call to UpdateVisual() set FatBlock to null when the construction is complete if (m_componentStack.IsFunctional) { integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.ConstructionEnd; } } UpdateVisual(); if (FatBlock != null) { int buildProgressID = CalculateCurrentModelID(); if (buildProgressID == 0) { integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.ConstructionBegin; } else if (!m_componentStack.IsFunctional) { integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.ConstructionProcess; } } PlayConstructionSound(integrityChangeType); CreateConstructionSmokes(); if (CubeGrid.GridSystems.OxygenSystem != null) { CubeGrid.GridSystems.OxygenSystem.Pressurize(); } } if (HasDeformation) CubeGrid.SetBlockDirty(this); if (removeDecals) CubeGrid.RenderData.RemoveDecals(Position); CubeGrid.SyncObject.SendIntegrityChanged(this, integrityChangeType, 0); if (maxAllowedBoneMovement != 0.0f) FixBones(oldDamage, maxAllowedBoneMovement); }
private bool PasteGridsInStaticMode(IMyComponentInventory buildInventory, bool deactivate) { // Paste generates grid from builder and use matrix from preview List<MyObjectBuilder_CubeGrid> copiedGridsOrig = new List<MyObjectBuilder_CubeGrid>(); List<MatrixD> previewGridsWorldMatrices = new List<MatrixD>(); { // First grid is forced static MyObjectBuilder_CubeGrid originalCopiedGrid = CopiedGrids[0]; copiedGridsOrig.Add(originalCopiedGrid); MatrixD previewGridWorldMatrix = PreviewGrids[0].WorldMatrix; // Convert grid builder to static var gridBuilder = ConvertGridBuilderToStatic(originalCopiedGrid, previewGridWorldMatrix); // Set it to copied grids CopiedGrids[0] = gridBuilder; previewGridsWorldMatrices.Add(previewGridWorldMatrix); PreviewGrids[0].WorldMatrix = MatrixD.CreateTranslation(previewGridWorldMatrix.Translation); } for (int i = 1; i < CopiedGrids.Count; ++i) { MyObjectBuilder_CubeGrid originalCopiedGrid = CopiedGrids[i]; copiedGridsOrig.Add(originalCopiedGrid); MatrixD previewGridWorldMatrix = PreviewGrids[i].WorldMatrix; previewGridsWorldMatrices.Add(previewGridWorldMatrix); if (CopiedGrids[i].IsStatic) { // Convert grid builder to static var gridBuilder = ConvertGridBuilderToStatic(originalCopiedGrid, previewGridWorldMatrix); // Set it to copied grids CopiedGrids[i] = gridBuilder; PreviewGrids[i].WorldMatrix = MatrixD.CreateTranslation(previewGridWorldMatrix.Translation); } } Debug.Assert(CopiedGrids.Count == copiedGridsOrig.Count); Debug.Assert(CopiedGrids.Count == previewGridsWorldMatrices.Count); bool result = PasteGridInternal(buildInventory: buildInventory, deactivate: deactivate); // Set original grids back CopiedGrids.Clear(); CopiedGrids.AddList(copiedGridsOrig); for (int i = 0; i < PreviewGrids.Count; ++i) PreviewGrids[i].WorldMatrix = previewGridsWorldMatrices[i]; return result; }
public void DecreaseMountLevel(float grinderAmount, IMyComponentInventory outputInventory) { if (FatBlock != null) grinderAmount /= FatBlock.DisassembleRatio; else grinderAmount /= BlockDefinition.DisassembleRatio; grinderAmount = grinderAmount * BlockDefinition.IntegrityPointsPerSec; if (MySession.Static.CreativeMode) { ClearConstructionStockpile(outputInventory); } else { EnsureConstructionStockpileExists(); } float oldBuildRatio = m_componentStack.BuildRatio; float newBuildRatio = (BuildIntegrity - grinderAmount) / BlockDefinition.MaxIntegrity; if (BlockDefinition.RatioEnoughForOwnership(BuildLevelRatio) && !BlockDefinition.RatioEnoughForOwnership(newBuildRatio)) { if (FatBlock != null) { FatBlock.OnIntegrityChanged(BuildIntegrity, Integrity, false, MySession.LocalPlayerId); } } long toolOwner = 0; if (outputInventory != null && outputInventory.Owner != null) { var moduleOwner = outputInventory.Owner as IMyComponentOwner<MyIDModule>; if (moduleOwner == null && outputInventory.Owner is MyCharacter) { Debug.Assert((outputInventory.Owner as MyCharacter).ControllerInfo.Controller != null, "Controller was null on the character in DecreaseMountLevel!"); if ((outputInventory.Owner as MyCharacter).ControllerInfo.Controller == null) toolOwner = (outputInventory.Owner as MyCharacter).ControllerInfo.ControllingIdentityId; } else { MyIDModule module; if (moduleOwner.GetComponent(out module)) toolOwner = module.Owner; } } UpdateHackingIndicator(newBuildRatio, oldBuildRatio, toolOwner); if (m_stockpile != null) { m_stockpile.ClearSyncList(); m_componentStack.DecreaseMountLevel(grinderAmount, m_stockpile); CubeGrid.SyncObject.SendStockpileChanged(this, m_stockpile.GetSyncList()); m_stockpile.ClearSyncList(); } else { m_componentStack.DecreaseMountLevel(grinderAmount, null); } bool modelChangeNeeded = BlockDefinition.ModelChangeIsNeeded(m_componentStack.BuildRatio, oldBuildRatio); MyCubeGrid.MyIntegrityChangeEnum integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.Damage; if (modelChangeNeeded) { UpdateVisual(); if (FatBlock != null) { int buildProgressID = CalculateCurrentModelID(); if ((buildProgressID == -1) || (BuildLevelRatio == 0f)) { integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.ConstructionEnd; } else if (buildProgressID == BlockDefinition.BuildProgressModels.Length - 1) { integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.ConstructionBegin; } else { integrityChangeType = MyCubeGrid.MyIntegrityChangeEnum.ConstructionProcess; } } PlayConstructionSound(integrityChangeType, true); CreateConstructionSmokes(); } if (CubeGrid.GridSystems.OxygenSystem != null) { CubeGrid.GridSystems.OxygenSystem.Pressurize(); } CubeGrid.SyncObject.SendIntegrityChanged(this, integrityChangeType, toolOwner); }
private void inventory_OnContentsChanged(IMyComponentInventory obj) { RefreshInventoryContents(); if (InventoryContentsChanged != null) InventoryContentsChanged(this); }
virtual public void AddInventory(IMyComponentInventory inventory) { //TODO: Consider adding inventories to the children aggregates m_attachedInventories.Add(inventory); }