private static void OnThrustTorqueReceived(MySyncGrid sync, ref ThrustAndTorqueMsg msg, MyNetworkClient sender)
        {
            sender.ClientFrameId = msg.ClientFrameId;

            //if (false)
            {
                sync.Entity.GridSystems.ThrustSystem.ControlThrust = msg.Thrust;
                sync.Entity.GridSystems.GyroSystem.ControlTorque = msg.Torque;
            }
        }

        private static void OnColorBlocksRequest(MySyncGrid sync, ref ColorBlocksMsg msg, MyNetworkClient sender)
        {
            var handler = sync.BlocksColored;
            if (handler != null) handler(msg.Min, msg.Max, ColorExtensions.UnpackHSVFromUint(msg.HSV), msg.PlaySound);

            if (Sync.IsServer)
            {
                // Broadcast to clients, use result collection
                Sync.Layer.SendMessageToAll(ref msg);
            }
        }

        private static void OnBonesReceived(MySyncGrid sync, ref BonesMsg msg, MyNetworkClient sender)
        {
            sync.Entity.Skeleton.DeserializePart(msg.MinBone, msg.MaxBone, sync.Entity.GridSize, msg.Bones);

            Vector3I minCube = Vector3I.Zero;
            Vector3I maxCube = Vector3I.Zero;

            // To hit incident cubes
            Vector3I min = msg.MinBone;// -Vector3I.One;
            Vector3I max = msg.MaxBone;// +Vector3I.One;

            sync.Entity.Skeleton.Wrap(ref minCube, ref min);
            sync.Entity.Skeleton.Wrap(ref maxCube, ref max);

            minCube -= Vector3I.One;
            maxCube += Vector3I.One;

            Vector3I pos;
            for (pos.X = minCube.X; pos.X <= maxCube.X; pos.X++)
            {
                for (pos.Y = minCube.Y; pos.Y <= maxCube.Y; pos.Y++)
                {
                    for (pos.Z = minCube.Z; pos.Z <= maxCube.Z; pos.Z++)
                    {
                        sync.Entity.SetCubeDirty(pos);
                    }
                }
            }
        }

        private static void OnBuildBlocksAreaSuccess(MySyncGrid sync, ref BuildBlocksAreaSuccessMsg successMsg, MyNetworkClient sender)
        {
            Debug.Assert(sync.BlocksBuiltAreaSuccess != null, "Handler should not be null, build messages will be ignored!");

            var handler = sync.BlocksBuiltAreaSuccess;
            if (handler != null) handler(ref successMsg.Area, successMsg.EntityIdSeed, successMsg.FailList, successMsg.OwnerId);
        }

        private static void OnRazeBlocksAreaSuccess(MySyncGrid sync, ref RazeBlocksAreaSuccessMsg successMsg, MyNetworkClient sender)
        {
            Debug.Assert(sync.BlocksRazeAreaSuccess != null, "Handler should not be null, Raze messages will be ignored!");

            var handler = sync.BlocksRazeAreaSuccess;
            if (handler != null) handler(ref successMsg.Pos, ref successMsg.Size, successMsg.FailList);
        }

        private static void OnRemoveSplit(MySyncGrid grid, ref RemoveSplitMsg msg, MyNetworkClient sender)
        {
            MyCubeGrid m_grid;
            if (MyEntities.TryGetEntityById(msg.GridEntityId, out m_grid))
            {
                m_tmpBlockListReceive.Clear();
                foreach (var position in msg.RemovedBlocks)
                {
                    var block = m_grid.GetCubeBlock(position);
                    Debug.Assert(block != null, "Block was null when trying to remove a grid split. Desync?");
                    if (block == null)
                    {
                        MySandboxGame.Log.WriteLine("Block was null when trying to remove a grid split. Desync?");
                        continue;
                    }

                    m_tmpBlockListReceive.Add(block);
                }

                MyCubeGrid.RemoveSplit(m_grid, m_tmpBlockListReceive, 0, m_tmpBlockListReceive.Count, sync: false);
                m_tmpBlockListReceive.Clear();
            }
        }

        private static void OnBuildBlockRequest(MySyncGrid sync, ref BuildBlockMsg msg, MyNetworkClient sender)
        {
            MyCubeGrid.MyBlockLocation? builtBlock = null;

            MyEntity builder = null;
            MyEntities.TryGetEntityById(msg.BuilderEntityId, out builder);

            var buildHandler = sync.BlockBuilt;
            if (buildHandler != null) buildHandler(ColorExtensions.UnpackHSVFromUint(msg.ColorMaskHsv), msg.Location, msg.BlockObjectBuilder, ref builtBlock, builder);
            
            if (Sync.IsServer)
            {
                Sync.Layer.SendMessageToAll(ref msg);
            }
            
            var afterHandler = sync.AfterBlockBuilt;
            if (afterHandler != null && builtBlock != null) afterHandler(builtBlock.Value);
        }

 private static void OnModifyGroupSuccess(MySyncGrid sync, ref ModifyBlockGroupMsg msg, MyNetworkClient sender)
 {
     if (msg.Blocks == null || msg.Blocks.Count() == 0)
         foreach (var group in sync.Entity.BlockGroups)
         {
             if (group.Name.ToString().Equals(msg.Name))
             {
                 sync.Entity.RemoveGroup(group);
                 break;
             }
         }
     else
     {
         MyBlockGroup group = new MyBlockGroup(sync.Entity);
         group.Name.Clear().Append(msg.Name);
         foreach (var blockId in msg.Blocks)
         {
             MyTerminalBlock block = null;
             if (MyEntities.TryGetEntityById(blockId, out block))
                 group.Blocks.Add(block);
         }
         sync.Entity.AddGroup(group);
     }
 }

        private static void OnConvertedToShipRequest(MySyncGrid sync, ref ConvertToShipMsg msg, MyNetworkClient sender)
        {
            if (!sync.Entity.IsStatic)
            {
                Debug.Assert(false, "Grid was not static!");
                return;
            }

            if (Sync.IsServer)
                Sync.Layer.SendMessageToAllAndSelf(ref msg, MyTransportMessageEnum.Success);
        }

        private static void OnStockpileFillRequest(MySyncGrid sync, ref StockpileFillRequestMsg msg, MyNetworkClient sender)
        {
            var block = sync.Entity.GetCubeBlock(msg.BlockPosition);
            Debug.Assert(block != null, "Could not find block whose stockpile fill was requested");
            if (block == null) return;

            MyEntity ownerEntity = null;
            if (!MyEntities.TryGetEntityById(msg.OwnerEntityId, out ownerEntity))
            {
                Debug.Assert(false, "Stockpile fill inventory owner entity was null");
                return;
            }

            var owner = (ownerEntity as IMyInventoryOwner);
            Debug.Assert(owner != null, "Stockpile fill inventory owner was not an inventory owner");

            var inventory = owner.GetInventory(msg.InventoryIndex);
            Debug.Assert(inventory != null, "Stockpile fill inventory owner did not have the given inventory");

            block.MoveItemsToConstructionStockpile(inventory);
        }

        private static void OnSetToConstructionRequest(MySyncGrid sync, ref SetToConstructionRequestMsg msg, MyNetworkClient sender)
        {
            var block = sync.Entity.GetCubeBlock(msg.BlockPosition);
            Debug.Assert(block != null, "Could not find block to set to construction site");
            if (block == null) return;

            block.SetToConstructionSite();

            MyEntity ownerEntity = null;
            if (!MyEntities.TryGetEntityById(msg.OwnerEntityId, out ownerEntity))
            {
                Debug.Assert(false, "Set to construction site inventory owner entity was null");
                return;
            }

            var owner = (ownerEntity as IMyInventoryOwner);
            Debug.Assert(owner != null, "Set to construction site inventory owner was not an inventory owner");

            var inventory = owner.GetInventory(msg.InventoryIndex);
            Debug.Assert(inventory != null, "Set to construction site inventory owner did not have the given inventory");

            block.MoveItemsToConstructionStockpile(inventory);
            block.IncreaseMountLevel(MyWelder.WELDER_AMOUNT_PER_SECOND * MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS, msg.RequestingPlayer);
        }

 private static void OnStockpileChanged(MySyncGrid sync, ref StockpileChangedMsg msg, MyNetworkClient sender)
 {
     if (sync.BlockStockpileChanged != null)
         sync.BlockStockpileChanged(msg.BlockPosition, msg.SubBlockId, msg.Changes);
 }

 private static void OnIntegrityChanged(MySyncGrid sync, ref IntegrityChangedMsg msg, MyNetworkClient sender)
 {
     if (sync.BlockIntegrityChanged != null)
         sync.BlockIntegrityChanged(msg.BlockPosition, msg.SubBlockId, msg.BuildIntegrity, msg.Integrity, msg.IntegrityChangeType, msg.ToolOwner);
 }

 private static void OnThrustReceived(MySyncGrid sync, ref ThrustMsg msg, MyNetworkClient sender)
 {
     sync.Entity.GridSystems.ThrustSystem.ControlThrust = msg.Thrust;
 }

 private static void OnChangeDisplayName(MySyncGrid grid, ref ChangeDisplayNameMsg msg, MyNetworkClient sender)
 {
     MyCubeGrid m_grid;
     if (MyEntities.TryGetEntityById(msg.GridEntityId, out m_grid))
         m_grid.DisplayName = msg.DisplayName;
 }

        private static void OnConvertedToShipSuccess(MySyncGrid sync, ref ConvertToShipMsg msg, MyNetworkClient sender)
        {
            if (!sync.Entity.IsStatic)
            {
                Debug.Assert(false, "Grid was not static!");
                return;
            }

            sync.Entity.ConvertToDynamic();
        }

        private static void OnCreateSplits(MySyncGrid syncGrid, ref CreateSplitsMsg msg, MyNetworkClient sender)
        {
            m_tmpBlockListReceive.Clear();

            var grid = syncGrid.Entity;
            foreach (var b in msg.SplitBlocks)
            {
                var block = grid.GetCubeBlock(b);
                m_tmpBlockListReceive.Add(block); // Add even null, we cannot break the order
            }
            MyCubeGrid.CreateSplits(grid, m_tmpBlockListReceive, msg.Groups, false);

            m_tmpBlockListReceive.Clear();
        }

 private static void OnMergeGridSuccess(MySyncGrid sync, ref MergeMsg msg, MyNetworkClient sender)
 {
     MyCubeGrid grid = null;
     if (MyEntities.TryGetEntityById<MyCubeGrid>(msg.OtherEntityId, out grid))
     {
         Vector3I gridOffset = msg.GridOffset;
         MatrixI transform = new MatrixI(msg.GridOffset, msg.GridForward, msg.GridUp);
         sync.Entity.MergeGridInternal(grid, ref transform);
     }
 }

 private static void OnChangeDestructibleBlocks(MySyncGrid syncObject, ref ChangeDestructibleBlocksMsg msg, MyNetworkClient sender)
 {
     syncObject.Entity.DestructibleBlocks = msg.DestructionEnabled;
 }

 private static void OnChangeOwnerRequest(MySyncGrid sync, ref ChangeOwnershipMsg msg, MyNetworkClient sender)
 {
     MyCubeBlock block = null;
     if (MyEntities.TryGetEntityById<MyCubeBlock>(msg.BlockId, out block))
     {
         if (Sync.IsServer && ((MyFakes.ENABLE_BATTLE_SYSTEM && MySession.Static.Battle && block.IDModule == null) || (block.IDModule.Owner == 0) || block.IDModule.Owner == msg.RequestingPlayer || (msg.Owner == 0)))
         {
             OnChangeOwner(sync, ref msg, sender);
             Sync.Layer.SendMessageToAll(ref msg, MyTransportMessageEnum.Success);
         }
         else
         {
             System.Diagnostics.Debug.Fail("Invalid ownership change request!");
         }
     }
 }