public void MessageCreateStringTable()
        {
            bitBuffer.ReadString(); // table name

            UInt32 maxEntries = bitBuffer.ReadUnsignedBits(16);
            UInt32 nEntries   = bitBuffer.ReadUnsignedBits(Common.LogBase2((Int32)maxEntries) + 1);

            UInt32 nBits = bitBuffer.ReadUnsignedBits(20);

            if (bitBuffer.ReadBoolean()) // userdata bit
            {
                bitBuffer.SeekBits(12);  // "user data size"
                bitBuffer.SeekBits(4);   // "user data bits"
            }

            bitBuffer.SeekBits((Int32)nBits);

            if (demo.NetworkProtocol >= 15)
            {
                bitBuffer.SeekBits(1);
            }
        }
Exemple #2
0
        private Int32 ParseInt(BitBuffer bitBuffer, Entry e)
        {
            Boolean negative = bitBuffer.ReadBoolean();

            return((Int32)bitBuffer.ReadUnsignedBits((Int32)e.nBits - 1) / (Int32)e.Divisor * (negative ? -1 : 1));
        }
Exemple #3
0
        private Object ParseEntry(BitBuffer bitBuffer, Entry e)
        {
            Boolean signed = ((e.Flags & EntryFlags.Signed) != 0);

            if ((e.Flags & EntryFlags.Byte) != 0)
            {
                if (signed)
                {
                    return((SByte)ParseInt(bitBuffer, e));
                }
                else
                {
                    return((Byte)ParseUnsignedInt(bitBuffer, e));
                }
            }

            if ((e.Flags & EntryFlags.Short) != 0)
            {
                if (signed)
                {
                    return((Int16)ParseInt(bitBuffer, e));
                }
                else
                {
                    return((UInt16)ParseUnsignedInt(bitBuffer, e));
                }
            }

            if ((e.Flags & EntryFlags.Integer) != 0)
            {
                if (signed)
                {
                    return((Int32)ParseInt(bitBuffer, e));
                }
                else
                {
                    return((UInt32)ParseUnsignedInt(bitBuffer, e));
                }
            }

            if ((e.Flags & EntryFlags.Float) != 0 || (e.Flags & EntryFlags.TimeWindow8) != 0 || (e.Flags & EntryFlags.TimeWindowBig) != 0)
            {
                Boolean negative   = false;
                Int32   bitsToRead = (Int32)e.nBits;

                if (signed)
                {
                    negative = bitBuffer.ReadBoolean();
                    bitsToRead--;
                }

                return((Single)bitBuffer.ReadUnsignedBits(bitsToRead) / e.Divisor * (negative ? -1.0f : 1.0f));
            }

            if ((e.Flags & EntryFlags.Angle) != 0)
            {
                return((Single)(bitBuffer.ReadUnsignedBits((Int32)e.nBits) * (360.0f / (Single)(1 << (Int32)e.nBits))));
            }

            if ((e.Flags & EntryFlags.String) != 0)
            {
                return(bitBuffer.ReadString());
            }

            throw new ApplicationException(String.Format("Unknown delta entry type {0}.", e.Flags));
        }
 private Int32 ParseInt(BitBuffer bitBuffer, Entry e)
 {
     Boolean negative = bitBuffer.ReadBoolean();
     return (Int32)bitBuffer.ReadUnsignedBits((Int32)e.nBits - 1) / (Int32)e.Divisor * (negative ? -1 : 1);
 }
        private Object ParseEntry(BitBuffer bitBuffer, Entry e)
        {
            Boolean signed = ((e.Flags & EntryFlags.Signed) != 0);

            if ((e.Flags & EntryFlags.Byte) != 0)
            {
                if (signed)
                {
                    return (SByte)ParseInt(bitBuffer, e);
                }
                else
                {
                    return (Byte)ParseUnsignedInt(bitBuffer, e);
                }
            }

            if ((e.Flags & EntryFlags.Short) != 0)
            {
                if (signed)
                {
                    return (Int16)ParseInt(bitBuffer, e);
                }
                else
                {
                    return (UInt16)ParseUnsignedInt(bitBuffer, e);
                }
            }

            if ((e.Flags & EntryFlags.Integer) != 0)
            {
                if (signed)
                {
                    return (Int32)ParseInt(bitBuffer, e);
                }
                else
                {
                    return (UInt32)ParseUnsignedInt(bitBuffer, e);
                }
            }

            if ((e.Flags & EntryFlags.Float) != 0 || (e.Flags & EntryFlags.TimeWindow8) != 0 || (e.Flags & EntryFlags.TimeWindowBig) != 0)
            {
                Boolean negative = false;
                Int32 bitsToRead = (Int32)e.nBits;

                if (signed)
                {
                    negative = bitBuffer.ReadBoolean();
                    bitsToRead--;
                }

                return (Single)bitBuffer.ReadUnsignedBits(bitsToRead) / e.Divisor * (negative ? -1.0f : 1.0f);
            }

            if ((e.Flags & EntryFlags.Angle) != 0)
            {
                return (Single)(bitBuffer.ReadUnsignedBits((Int32)e.nBits) * (360.0f / (Single)(1 << (Int32)e.nBits)));
            }

            if ((e.Flags & EntryFlags.String) != 0)
            {
                return bitBuffer.ReadString();
            }

            throw new ApplicationException(String.Format("Unknown delta entry type {0}.", e.Flags));
        }
        public void MessageEvent()
        {
            if (demo.NetworkProtocol <= 43)
            {
                bitBuffer.Endian = BitBuffer.EndianType.Big;
            }

            UInt32 nEvents = bitBuffer.ReadUnsignedBits(5);

            for (Int32 i = 0; i < nEvents; i++)
            {
                bitBuffer.SeekBits(10); // event index

                Boolean packetIndexBit = bitBuffer.ReadBoolean();

                if (packetIndexBit)
                {
                    bitBuffer.SeekBits(11); // packet index

                    Boolean deltaBit = bitBuffer.ReadBoolean();

                    if (deltaBit)
                    {
                        GetDeltaStructure("event_t").ReadDelta(bitBuffer, null);
                    }
                }

                Boolean fireTimeBit = bitBuffer.ReadBoolean();

                if (fireTimeBit)
                {
                    bitBuffer.SeekBits(16); // fire time
                }
            }

            bitBuffer.SkipRemainingBits();
            bitBuffer.Endian = BitBuffer.EndianType.Little;
        }