private void WriteWhole(int bitsToSend, StreamClientData clientData, byte packetId, ref VRage.Library.Collections.BitStream stream)
        {
            StreamPartInfo info = new StreamPartInfo();

            info.StartIndex = 0;
            info.NumBits    = bitsToSend;
            info.Position   = 0;

            clientData.SendPackets[packetId] = info;
            clientData.RemainingBits         = 0;

            clientData.Dirty     = false;
            clientData.ForceSend = false;
            stream.WriteInt16(1);
            stream.WriteInt16(0);
            stream.WriteInt32(bitsToSend);

            unsafe
            {
                fixed(byte *dataPtr = clientData.ObjectData)
                {
                    stream.WriteMemory(dataPtr, bitsToSend);
                }
            }
        }
        private void WriteIncompletePacket(StreamClientData clientData, byte packetId, ref VRage.Library.Collections.BitStream stream)
        {
            if (clientData.ObjectData == null)
            {
                clientData.FailedIncompletePackets.Clear();
                return;
            }

            StreamPartInfo failedPart = clientData.FailedIncompletePackets[0];

            clientData.FailedIncompletePackets.Remove(failedPart);
            clientData.SendPackets[packetId] = failedPart;

            stream.WriteInt32(clientData.UncompressedSize);
            stream.WriteInt16(clientData.NumParts);
            stream.WriteInt16(failedPart.Position);
            stream.WriteInt32(failedPart.NumBits);

            unsafe
            {
                fixed(byte *dataPtr = &clientData.ObjectData[failedPart.StartIndex])
                {
                    stream.WriteMemory(dataPtr, failedPart.NumBits);
                }
            }
        }
        private void WritePart(ref int bitsToSend, StreamClientData clientData, byte packetId, ref VRage.Library.Collections.BitStream stream)
        {
            bitsToSend = Math.Min(m_streamSize, clientData.RemainingBits);
            StreamPartInfo info = new StreamPartInfo();

            info.StartIndex = clientData.LastPosition;
            info.NumBits    = bitsToSend;

            clientData.LastPosition          = info.StartIndex + MyLibraryUtils.GetDivisionCeil(m_streamSize, 8);
            clientData.SendPackets[packetId] = info;
            clientData.RemainingBits         = Math.Max(0, clientData.RemainingBits - m_streamSize);

            stream.WriteInt16(clientData.NumParts);
            stream.WriteInt16(clientData.CurrentPart);
            info.Position = clientData.CurrentPart;

            clientData.CurrentPart++;

            stream.WriteInt32(bitsToSend);

            unsafe
            {
                fixed(byte *dataPtr = &clientData.ObjectData[info.StartIndex])
                {
                    stream.WriteMemory(dataPtr, bitsToSend);
                }
            }
        }
        private bool ReadPart(ref VRage.Library.Collections.BitStream stream)
        {
            m_numPartsToRecive = stream.ReadInt16();
            short currentPacket  = stream.ReadInt16();
            int   bitsToRecieve  = stream.ReadInt32();
            int   bytesToRecieve = MyLibraryUtils.GetDivisionCeil(bitsToRecieve, 8);

            int numBitsInStream = stream.BitLength - stream.BitPosition;

            if (numBitsInStream < bitsToRecieve)
            {
                Debug.Fail("trying to read more than there is in stream. Why ?");
                MyLog.Default.WriteLine("trying to read more than there is in stream. Total num parts : " + m_numPartsToRecive.ToString() + " current part : " + currentPacket.ToString() + " bits to read : " + bitsToRecieve.ToString() + " bits in stream : " + numBitsInStream.ToString() + " replicable : " + Instance.ToString());
                //what now ?
                return(false);
            }

            if (m_recivedParts == null)
            {
                m_recivedParts = new SortedList <StreamPartInfo, byte[]>();
            }


            m_recievedBytes += bytesToRecieve;
            byte[] partData = new byte[bytesToRecieve];

            unsafe
            {
                fixed(byte *dataPtr = partData)
                {
                    stream.ReadMemory(dataPtr, bitsToRecieve);
                }
            }

            StreamPartInfo info = new StreamPartInfo();

            info.NumBits         = bitsToRecieve;
            info.StartIndex      = currentPacket;
            m_recivedParts[info] = partData;

            return(true);
        }