public void Init(MyCubeBlock myBlock, ConveyorLinePosition a, ConveyorLinePosition b, MyObjectBuilder_ConveyorLine.LineType type, MyObjectBuilder_ConveyorLine.LineConductivity conductivity = MyObjectBuilder_ConveyorLine.LineConductivity.FULL)
        {
            CubeBlock = myBlock;
            ConnectingPosition1 = a;
            ConnectingPosition2 = b;

            // Neighbour grid position of one of the connecting positions is inside this block
            var linePosition = (myBlock as IMyConveyorSegmentBlock).ConveyorSegment.ConnectingPosition1.NeighbourGridPosition;

            ConveyorLine = myBlock.CubeGrid.GridSystems.ConveyorSystem.GetDeserializingLine(linePosition);
            if (ConveyorLine == null)
            {
                ConveyorLine = new MyConveyorLine();
                if (IsCorner)
                    ConveyorLine.Init(a, b, myBlock.CubeGrid, type, conductivity, CalculateCornerPosition());
                else
                    ConveyorLine.Init(a, b, myBlock.CubeGrid, type, conductivity, (Vector3I?)null);
            }
            else
            {
                Debug.Assert(ConveyorLine.Type == type, "Conveyor line type mismatch on segment deserialization");
            }

            myBlock.SlimBlock.ComponentStack.IsFunctionalChanged += CubeBlock_IsFunctionalChanged;
        }

        public MyUpgradableBlockComponent(MyCubeBlock parent)
        {
            Debug.Assert(parent != null);

            ConnectionPositions = new HashSet<ConveyorLinePosition>();
            Refresh(parent);
        }

 private static bool RemoveGenerated(HkdBreakableBody b, MyCubeBlock block)
 {
     if (MyFakes.REMOVE_GENERATED_BLOCK_FRACTURES && ContainsGenerated(block))
     {
         if (b.BreakableShape.IsCompound())
         {
             b.BreakableShape.GetChildren(m_tmpInfos);
             for (int i = 0; i < m_tmpInfos.Count; i++)
             {
                 if (DontCreateFracture(m_tmpInfos[i].Shape))
                 {
                     m_tmpInfos.RemoveAt(i);
                     i--;
                 }
             }
             if (m_tmpInfos.Count == 0)
             {
                 return true;
             }
             m_tmpInfos.Clear();
         }
         else if (DontCreateFracture(b.BreakableShape))
         {
             return true;
         }
     }
     return false;
 }

 public void Refresh(MyCubeBlock parent)
 {
     ConnectionPositions.Clear();
     var positions = MyMultilineConveyorEndpoint.GetLinePositions(parent, "detector_upgrade");
     foreach (var position in positions)
     {
         ConnectionPositions.Add(MyMultilineConveyorEndpoint.PositionToGridCoords(position, parent));
     }
 }

        public MyGuiScreenCubeBuilder(int scrollOffset = 0, MyCubeBlock owner = null)
            : base(scrollOffset, owner)
        {
            MySandboxGame.Log.WriteLine("MyGuiScreenCubeBuilder.ctor START");

            Static = this;

            m_scrollOffset = scrollOffset / 6.5f;
            m_size = new Vector2(1, 1);
            m_canShareInput = true;
            m_drawEvenWithoutFocus = true;
            EnabledBackgroundFade = true;
            m_screenOwner = owner;
            RecreateControls(true);

            MySandboxGame.Log.WriteLine("MyGuiScreenCubeBuilder.ctor END");
        }

        public static MyFracturedPiece CreateFracturePiece(HkdBreakableBody b, ref MatrixD worldMatrix, List<MyDefinitionId> originalBlocks, MyCubeBlock block = null, bool sync = true)        
        {
            System.Diagnostics.Debug.Assert(Sync.IsServer, "Only on server");

            if (block != null)
            {
                if (RemoveGenerated(b, block))
                {
                    return null;
                }
            }

            ProfilerShort.Begin("CreateFracturePiece");
            var fracturedPiece = MyFracturedPiecesManager.Static.GetPieceFromPool(0);
            fracturedPiece.InitFromBreakableBody(b, worldMatrix, block);
            fracturedPiece.NeedsUpdate |= Common.MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
            //fracturedPiece.Physics.RigidBody.ContactPointCallbackDelay = 0;
            //fracturedPiece.Physics.RigidBody.ContactPointCallbackEnabled = true;
            ProfilerShort.End();

            ProfilerShort.Begin("MyEntities.Add");
            MyEntities.Add(fracturedPiece);
            ProfilerShort.End();

            if (block == null)
            {
                fracturedPiece.OriginalBlocks.Clear();
                fracturedPiece.OriginalBlocks.AddRange(originalBlocks);

                MyPhysicalModelDefinition def;
                if(MyDefinitionManager.Static.TryGetDefinition<MyPhysicalModelDefinition>(originalBlocks[0], out def))
                    fracturedPiece.Physics.MaterialType = def.PhysicalMaterial.Id.SubtypeId;
            }

            if (sync)
                MySyncDestructions.CreateFracturePiece((Sandbox.Common.ObjectBuilders.MyObjectBuilder_FracturedPiece)fracturedPiece.GetObjectBuilder());

            return fracturedPiece;
        }

        public static MyFracturedPiece CreateFracturePiece(HkdBreakableBody b, ref MatrixD worldMatrix, List<MyDefinitionId> originalBlocks, MyCubeBlock block = null, bool sync = true)
        {
            System.Diagnostics.Debug.Assert(Sync.IsServer, "Only on server");

            if (IsBodyWithoutGeneratedFracturedPieces(b, block))
                return null;

            ProfilerShort.Begin("CreateFracturePiece");
            var fracturedPiece = MyFracturedPiecesManager.Static.GetPieceFromPool(0);
            fracturedPiece.InitFromBreakableBody(b, worldMatrix, block);
            fracturedPiece.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
            //fracturedPiece.Physics.RigidBody.ContactPointCallbackDelay = 0;
            //fracturedPiece.Physics.RigidBody.ContactPointCallbackEnabled = true;
            ProfilerShort.End();

            if (originalBlocks != null && originalBlocks.Count != 0)
            {
                fracturedPiece.OriginalBlocks.Clear();
                fracturedPiece.OriginalBlocks.AddRange(originalBlocks);

                MyPhysicalModelDefinition def;
                if (MyDefinitionManager.Static.TryGetDefinition<MyPhysicalModelDefinition>(originalBlocks[0], out def))
                    fracturedPiece.Physics.MaterialType = def.PhysicalMaterial.Id.SubtypeId;
            }

            // Check valid shapes from block definitions.
            if (MyFakes.ENABLE_FRACTURE_PIECE_SHAPE_CHECK)
                fracturedPiece.DebugCheckValidShapes();

            ProfilerShort.Begin("MyEntities.Add");
            MyEntities.RaiseEntityCreated(fracturedPiece);
            MyEntities.Add(fracturedPiece);
            ProfilerShort.End();

            return fracturedPiece;
        }

 public MyUseObjectWardrobe(IMyEntity owner, string dummyName, MyModelDummy dummyData, uint key)
     : base(owner, dummyData)
 {
     Block = owner as MyCubeBlock;
     LocalMatrix = dummyData.Matrix;
 }

 public override void OnAddedToContainer()
 {
     base.OnAddedToContainer();
     m_cubeBlock = Container.Entity as MyCubeBlock;
 }

        private void ConveyorSystem_BlockRemoved(MyCubeBlock obj)
        {
            m_interactedGridOwners.Remove(obj);
            if (m_leftShowsGrid) LeftTypeGroup_SelectedChanged(m_leftTypeGroup);
            if (m_rightShowsGrid) RightTypeGroup_SelectedChanged(m_rightTypeGroup);

            if (m_dragAndDropInfo != null)
            {
                ClearDisabledControls();
                DisableInvalidWhileDragging();
            }
        }

        void MyBatteryBlock_IsWorkingChanged(MyCubeBlock obj)
        {
            UpdateMaxOutputAndEmissivity();
			ResourceSink.Update();
        }

        public void Add(MyCubeBlock block)
        {
            bool added = m_inventoryBlocks.Add(block);
            System.Diagnostics.Debug.Assert(added, "Double add");

            var handler = BlockAdded;
            if (handler != null) handler(block);
        }

 void MyUpgradeModule_IsWorkingChanged(MyCubeBlock obj)
 {
     RefreshEffects();
     UpdateEmissivity();
 }

        /// <summary>
        /// Returns true if the block (or any block in compound) does not generate generate fractured pieces.
        /// </summary>
        private static bool ContainsBlockWithoutGeneratedFracturedPieces(MyCubeBlock block)
        {
            if (!block.BlockDefinition.CreateFracturedPieces)
                return true;

            if (block is MyCompoundCubeBlock)
            {
                foreach (var b in (block as MyCompoundCubeBlock).GetBlocks())
                    if (!b.BlockDefinition.CreateFracturedPieces)
                        return true;
            }

            if (block is MyFracturedBlock)
            {
                foreach (var def in (block as MyFracturedBlock).OriginalBlocks)
                    if (!MyDefinitionManager.Static.GetCubeBlockDefinition(def).CreateFracturedPieces)
                        return true;
            }
            return false;
        }

        private static bool ContainsGenerated(MyCubeBlock block)
        {
            if (block.BlockDefinition.IsGeneratedBlock)
                return true;

            if (block is MyCompoundCubeBlock)
            {
                foreach (var b in (block as MyCompoundCubeBlock).GetBlocks())
                    if (b.BlockDefinition.IsGeneratedBlock)
                        return true;
            }

            if (block is MyFracturedBlock)
            {
                foreach (var def in (block as MyFracturedBlock).OriginalBlocks)
                    if (MyDefinitionManager.Static.GetCubeBlockDefinition(def).IsGeneratedBlock)
                        return true;
            }
            return false;
        }

 public override void OnAddedToContainer(MyComponentContainer container)
 {
     base.OnAddedToContainer(container);
     m_cubeBlock = Entity as MyCubeBlock;
 }

 private void MyJumpDrive_IsWorkingChanged(MyCubeBlock obj)
 {
     CheckForAbort();
 }

 void MyAirVent_IsWorkingChanged(MyCubeBlock obj)
 {
     SourceComp.Enabled = IsWorking;
     UpdateEmissivity();
 }

 private void MySpaceBall_IsWorkingChanged(MyCubeBlock obj)
 {
     UpdateRadios(IsWorking);
 }

        public void Remove(MyCubeBlock block)
        {
            bool removed = m_inventoryBlocks.Remove(block);
            System.Diagnostics.Debug.Assert(removed, "Double remove or removing something not added");

            var handler = BlockRemoved;
            if (handler != null) handler(block);
        }