/// <summary>
 ///     *
 /// </summary>
 public override void read_scalefactor(Bitstream stream, Header header)
 {
     if (allocation != 0)
         scalefactor = ScaleFactors[stream.GetBitsFromBuffer(6)];
     if (channel2_allocation != 0)
         channel2_scalefactor = ScaleFactors[stream.GetBitsFromBuffer(6)];
 }
        public float UnpackFloat(PropertyInfo info, Bitstream stream) {
            var flags = info.Flags;

            if (flags.HasFlag(PropertyInfo.MultiFlag.Coord)) {
                return UnpackFloatCoord(stream);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.CoordMp)) {
                return UnpackFloatCoordMp(stream, FloatType.None);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.CoordMpLowPrecision)) {
                return UnpackFloatCoordMp(stream, FloatType.LowPrecision);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.CoordMpIntegral)) {
                return UnpackFloatCoordMp(stream, FloatType.Integral);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.NoScale)) {
                return UnpackFloatNoScale(stream);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.Normal)) {
                return UnpackFloatNormal(stream);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.CellCoord)) {
                return UnpackFloatCellCoord(info, stream, FloatType.None);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.CellCoordLowPrecision)) {
                return UnpackFloatCellCoord(info, stream, FloatType.LowPrecision);
            } else if (flags.HasFlag(PropertyInfo.MultiFlag.CellCoordIntegral)) {
                return UnpackFloatCellCoord(info, stream, FloatType.Integral);
            } else {
                uint dividend = stream.ReadBits(info.NumBits);
                uint divisor = (uint) (1 << info.NumBits) - 1;

                float f = ((float) dividend) / divisor;
                float range = info.HighValue - info.LowValue;

                return f * range + info.LowValue;
            }
        }
Exemple #3
0
        public void Update(Bitstream stream, uint baseline, bool updateBaseline, uint updated, bool isDelta) {
            uint id = UInt32.MaxValue;
            uint found = 0;

            while (found < updated) {
                var flags = ReadHeader(ref id, stream);

                if (flags.HasFlag(UpdateFlag.EnterPvs)) {
                    ReadEnterPvs(id, baseline, updateBaseline, stream);
                } else if (flags.HasFlag(UpdateFlag.LeavePvs)) {
                    if (flags.HasFlag(UpdateFlag.Delete)) {
                        Delete(id);
                    }
                } else {
                    ReadUpdate(id, stream);
                }

                ++found;
            }

            if (isDelta) {
                while (stream.ReadBool()) {
                    id = stream.ReadBits(11);
                    Delete(id);
                }
            }
        }
Exemple #4
0
        private UpdateFlag ReadHeader(ref uint id, Bitstream stream) {
            uint value = stream.ReadBits(6);

            if ((value & 0x30) > 0) {
                uint a = (value >> 4) & 3;
                uint b = (uint) ((a == 3) ? 16 : 0);

                value = (stream.ReadBits((byte) (4 * a + b)) << 4) | (value & 0xF);
            }

            id = unchecked(id + value + 1);

            var flags = UpdateFlag.None;

            if (!stream.ReadBool()) {
                if (stream.ReadBool()) {
                    flags |= UpdateFlag.EnterPvs;
                }
            } else {
                flags |= UpdateFlag.LeavePvs;

                if (stream.ReadBool()) {
                    flags |= UpdateFlag.Delete;
                }
            }

            return flags;
        }
        private float UnpackFloatCoord(Bitstream stream) {
            bool hasInteger = stream.ReadBool();
            bool hasFraction = stream.ReadBool();

            if (hasInteger || hasFraction) {
                bool sign = stream.ReadBool();

                uint integer = 0;
                if (hasInteger) {
                    integer = stream.ReadBits(COORD_INTEGER_BITS) + 1;
                }

                uint fraction = 0;
                if (hasFraction) {
                    fraction = stream.ReadBits(COORD_FRACTIONAL_BITS);
                }

                float f = (float) (integer + fraction * COORD_RESOLUTION);

                if (sign) {
                    f *= -1;
                }

                return f;
            } else {
                return 0;
            }
        }
        private string ReadKeyIfIncluded(Bitstream stream, List<string> keyHistory) {
            bool has_key = stream.ReadBool();

            if (!has_key) {
                return null;
            } 

            bool is_substring = stream.ReadBool();

            string key;

            if (!is_substring) {
                key = stream.ReadString();
            } else {
                int fromIndex = (int) stream.ReadBits(5);
                int fromLength = (int) stream.ReadBits(5);
                key = keyHistory[fromIndex].Substring(0, fromLength);

                key += stream.ReadString();
            }

            Preconditions.CheckArgument(key.Length <= MAX_KEY_SIZE);

            if (keyHistory.Count == KEY_HISTORY_SIZE) {
                keyHistory.RemoveAt(0);
            }

            keyHistory.Add(key);

            return key;
        }
        /// <summary>
        ///     *
        /// </summary>
        public override void ReadScaleFactor(Bitstream stream, Header header)
        {
            if (allocation != 0)
            {
                base.ReadScaleFactor(stream, header);
                switch (channel2_scfsi)
                {
                    case 0:
                        channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 1:
                        channel2_scalefactor1 = channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 2:
                        channel2_scalefactor1 =
                            channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 3:
                        channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;
                }
            }
        }
        /// <summary>
        ///     *
        /// </summary>
        public override void ReadScaleFactor(Bitstream stream, Header header)
        {
            base.ReadScaleFactor(stream, header);
            if (channel2_allocation != 0)
            {
                switch (channel2_scfsi)
                {
                    case 0:
                        channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 1:
                        channel2_scalefactor1 = channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 2:
                        channel2_scalefactor1 =
                            channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 3:
                        channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;
                }
                prepare_sample_reading(header, channel2_allocation, 1, channel2_factor, channel2_codelength,
                    channel2_c, channel2_d);
            }
        }
Exemple #9
0
        public override void Deserialize(Bitstream msg)
        {
            var count = msg.ReadUInt16();
            count = (ushort)Math.Max((int)count, 0);
            count = (ushort)Math.Min((int)count, 100);
            State = new List<PlayerStateData>(count);

            if (count > 0)
            {
                ushort objType = msg.ReadByte();
                PlayerId = msg.ReadVariableUInt32();
                if (_ownerType == null)
                {
                    _ownerType = ObjectMapper.LookupType(objType);
                    _lookupItem = DataLookupTable.Get(_ownerType.GetTypeInfo());

                }
            }

            NetworkObject pState = PlayerId > 0 ? ObjectMapper.GetCurrentPlayerState(PlayerId) : null;
            for (int i = 0; i < count; ++i)
            {
                NetworkObject data = Activator.CreateInstance(_ownerType) as NetworkObject;
                DataObjectPacket.ReadNetObject(_lookupItem, msg, data, pState);
                pState = data;
                State.Add(data as PlayerStateData);
            }

            if (State.Count > 0 && PlayerId > 0)
                ObjectMapper.SetCurrentPlayerState(PlayerId, State.Last());
        }
 /// <summary>
 ///     *
 /// </summary>
 public override bool read_sampledata(Bitstream stream)
 {
     bool returnvalue = base.read_sampledata(stream);
     if (channel2_allocation != 0)
     {
         channel2_sample = stream.GetBitsFromBuffer(channel2_samplelength);
     }
     return (returnvalue);
 }
Exemple #11
0
 public override void Serialize(Bitstream msg)
 {
     msg.Write(Name);
     msg.WriteVariableUInt32(EntityId);
     msg.Write(Parameters.Count);
     foreach (var p in Parameters)
     {
         WriteParam(p, msg);
     }
 }
Exemple #12
0
 public virtual void Create(Bitstream stream0, Header header0, SynthesisFilter filtera, SynthesisFilter filterb,
     ABuffer buffer0, int whichCh0)
 {
     stream = stream0;
     header = header0;
     filter1 = filtera;
     filter2 = filterb;
     buffer = buffer0;
     which_channels = whichCh0;
 }
 /// <summary>
 ///     *
 /// </summary>
 public override void ReadBitAllocation(Bitstream stream, Header header, Crc16 crc)
 {
     int length = get_allocationlength(header);
     allocation = stream.GetBitsFromBuffer(length);
     channel2_allocation = stream.GetBitsFromBuffer(length);
     if (crc != null)
     {
         crc.add_bits(allocation, length);
         crc.add_bits(channel2_allocation, length);
     }
 }
Exemple #14
0
        public static uint Compute32(Bitstream stream)
        {
            uint crc = 0xFFFFFFFF;

            while (!stream.Eof)
            {
                byte index = (byte)(((crc) & 0xFF) ^ stream.ReadByte(true));
                crc = (uint)((crc >> 8) ^ table[index]);
            }
            return ~crc;
        }
Exemple #15
0
        public Nullable<Message> Receive(Bitstream stream) {
            bool hasData = stream.ReadBool();

            if (!hasData) {
                return null;
            }

            if (stream.ReadBool()) {
                return ReadChunk(stream);
            } else {
                return ReadSingle(stream);
            }
        }
 /// <summary>
 ///     *
 /// </summary>
 public override void read_scalefactor_selection(Bitstream stream, Crc16 crc)
 {
     if (allocation != 0)
     {
         scfsi = stream.GetBitsFromBuffer(2);
         channel2_scfsi = stream.GetBitsFromBuffer(2);
         if (crc != null)
         {
             crc.add_bits(scfsi, 2);
             crc.add_bits(channel2_scfsi, 2);
         }
     }
 }
Exemple #17
0
        public override void Deserialize(Bitstream msg)
        {
            Name = msg.ReadString();
            EntityId = msg.ReadVariableUInt32();
            int count = msg.ReadInt32();
            Parameters = new List<object>(count);
            for(int i=0; i < count; ++i)
            {
                var p = ReadParam(msg);
                Parameters.Add(p);
            }

            RPCManager._Call(Name, EntityId, Parameters);
        }
Exemple #18
0
        public override void Deserialize(Bitstream msg)
        {
            SnapId = msg.ReadUInt32();
            BaselineId = msg.ReadUInt32();

            ushort count = msg.ReadByte();
            Dictionary<int, NetworkObject> state = new Dictionary<int, NetworkObject>();
            int addDeltaCount = 0;
            for (int i=0; i < count; ++i)
            {
                ushort objTypeId = msg.ReadByte();
                var entId = msg.ReadVariableUInt32();

                NetworkObject obj = ObjectMapper.Lookup(entId, objTypeId, true);
                if (obj == null)
                {
                    obj = ObjectMapper.Create(entId, objTypeId);
                }

                NetworkObject realObj = ObjectMapper.Lookup(entId, objTypeId, false);
                var realHash = 0;
                if (realObj != null)
                    realHash = realObj.GetHashCode();

                NetworkObject baseline = null;
                var usebaseLine = msg.ReadBool();
                uint bOffset = 0;
                if (usebaseLine)
                {
                    byte offset = msg.ReadByte();
                    var objBaselineId = BaselineId - (uint)offset;
                    bOffset = objBaselineId;

                    baseline = ObjectMapper.GetBaseline(objBaselineId, realHash);
                }

                var ownerType = obj.GetType().GetTypeInfo();
                var dItem = DataLookupTable.Get(ownerType);
                ReadNetObject(dItem, msg, obj, baseline);
                ObjectMapper.AddDeltaState(realHash, SnapId, obj);

                if (BaselineId != 0 && realHash != 0)
                    addDeltaCount++;
            }

            if (addDeltaCount == count)
                ObjectMapper.LastSimId = BaselineId;
        }
Exemple #19
0
 /// <summary>
 ///     *
 /// </summary>
 public override void read_allocation(Bitstream stream, Header header, Crc16 crc)
 {
     if ((allocation = stream.GetBitsFromBuffer(4)) == 15)
     {
     }
     //	 cerr << "WARNING: stream contains an illegal allocation!\n";
     // MPEG-stream is corrupted!
     if (crc != null)
         crc.add_bits(allocation, 4);
     if (allocation != 0)
     {
         samplelength = allocation + 1;
         factor = TableFactor[allocation];
         offset = TableOffset[allocation];
     }
 }
Exemple #20
0
        private Nullable<Message> ReadChunk(Bitstream stream) {
            uint offset = stream.ReadBits(18);
            uint count = stream.ReadBits(3);

            log.DebugFormat("chunk start = {0} end = {1}", offset, count);

            if (offset == 0) {
                Preconditions.CheckArgument(!Receiving);
                ReadChunkHeader(stream);
            } else {
                Preconditions.CheckArgument(Receiving);
            }

            uint byteOffset = offset * Connection.BYTES_PER_CHUNK;

            uint byteCount;
            if (offset + count < header.ChunkCount) {
                byteCount = count * Connection.BYTES_PER_CHUNK;
            } else {
                byteCount = header.ByteLength - byteOffset;
            }

            stream.Read(dataIn, (int)byteOffset, (int)byteCount);

            for (uint i = offset;
                    i < offset + count;
                    ++i) {
                if (!dataReceived[i]) {
                    dataReceived[i] = true;
                    ++countReceived;
                }
            }

            if (countReceived == header.ChunkCount) {
                log.Debug("chunk complete");
                Receiving = false;
                return new Message {
                    IsCompressed = header.IsCompressed,
                    DecompressedLength = header.DecompressedLength,

                    Data = dataIn,
                };
            } else {
                log.DebugFormat("chunk has {0}/{1}", countReceived, header.ChunkCount);
                return null;
            }
        }
Exemple #21
0
        private static void WriteParam(object o, Bitstream msg)
        {
            var t = o.GetType();
            var dsitem = new DataSerializationProperty(null, t);

            msg.Write(t.FullName);
            switch (dsitem.Type)
            {
                case DataTypes.BOOL:
                    msg.Write((bool)o);
                    break;
                case DataTypes.UBYTE:
                    msg.Write((byte)o);
                    break;
                case DataTypes.UINT:
                    msg.WriteVariableUInt32((uint)o);
                    break;
                case DataTypes.BYTE:
                    msg.Write((sbyte)o);
                    break;
                case DataTypes.INT:
                    msg.WriteVariableInt32((int)o);
                    break;
                case DataTypes.ULONG:
                    msg.Write((ulong)o);
                    break;
                case DataTypes.LONG:
                    msg.Write((long)o);
                    break;
                case DataTypes.FLOAT:
                    msg.Write((float)o);
                    break;
                case DataTypes.DOUBLE:
                    msg.Write((double)o);
                    break;
                case DataTypes.STRING:
                    msg.Write((string)o);
                    break;
                case DataTypes.VECTOR2:
                    msg.Write((Vector2)o);
                    break;
                default:
                    throw new ArgumentException("Invalid RPC paramter type.");
            }
        }
        public uint UnpackInt(PropertyInfo info, Bitstream stream) {
            var flags = info.Flags;

            if (flags.HasFlag(PropertyInfo.MultiFlag.EncodedAgainstTickcount)) {
                if (flags.HasFlag(PropertyInfo.MultiFlag.Unsigned)) {
                    return stream.ReadVarUInt();
                } else {
                    uint value = stream.ReadVarUInt();
                    return unchecked((uint) ((-(value & 1)) ^ (value >> 1)));
                }
            } else {
                byte numBits = info.NumBits;

                uint isUnsigned = Convert.ToUInt32(flags.HasFlag(PropertyInfo.MultiFlag.Unsigned));
                uint signer = (0x80000000 >> (32 - numBits)) & unchecked((uint) (isUnsigned - 1));

                uint value = stream.ReadBits(numBits) ^ signer;
                return value - signer;
            }
        }
 /// <summary>
 ///     *
 /// </summary>
 public override void read_allocation(Bitstream stream, Header header, Crc16 crc)
 {
     allocation = stream.GetBitsFromBuffer(4);
     channel2_allocation = stream.GetBitsFromBuffer(4);
     if (crc != null)
     {
         crc.add_bits(allocation, 4);
         crc.add_bits(channel2_allocation, 4);
     }
     if (allocation != 0)
     {
         samplelength = allocation + 1;
         factor = TableFactor[allocation];
         offset = TableOffset[allocation];
     }
     if (channel2_allocation != 0)
     {
         channel2_samplelength = channel2_allocation + 1;
         channel2_factor = TableFactor[channel2_allocation];
         channel2_offset = TableOffset[channel2_allocation];
     }
 }
Exemple #24
0
        public override void Serialize(Bitstream msg)
        {
            var count = State.Count;
            msg.Write((ushort)State.Count);
            if (count > 0 && _ownerType == null)
            {
                _ownerType = State[0].GetType();
                _lookupItem = DataLookupTable.Get(_ownerType.GetTypeInfo());
            }
            if (count > 0)
            {
                ushort objTypeId = ObjectMapper.LookupType(_ownerType);
                msg.Write((byte)objTypeId);
                msg.WriteVariableUInt32(PlayerId);
            }

            PlayerStateData pState = PreviousState;
            foreach (var o in State)
            {
                DataObjectPacket.WriteNetObject(_lookupItem, msg, o, pState);
                pState = o;
            }
        }
Exemple #25
0
        private void ReadChunkHeader(Bitstream stream) {
            header = new ChunkedHeader();

            header.IsFile = stream.ReadBool();
            if (header.IsFile) {
                uint filenameLength = stream.ReadUInt32();
                byte[] filename = new byte[filenameLength + 1]; // semantically wrong. should be
                                                                // 0x104
                stream.Read(filename, 0, (int)filenameLength); // and then read to end of string
                filename[filenameLength] = 0; // whatever 
                header.Filename = Encoding.UTF8.GetString(filename);
                log.ErrorFormat("read filename: \"{0}\" ({1})", filenameLength, header.Filename);
                throw new NotImplementedException();
            }

            header.IsCompressed = stream.ReadBool();
            if (header.IsCompressed) {
                header.DecompressedLength = stream.ReadBits(26);
                log.DebugFormat(
                    "chunkheader compressed: decompressed len {0}", 
                    header.DecompressedLength);
            }

            header.ByteLength = stream.ReadBits(26);
            header.ChunkCount = 
                (header.ByteLength + Connection.BYTES_PER_CHUNK - 1) /
                Connection.BYTES_PER_CHUNK;
            log.DebugFormat(
                "chunkheader len {0} expecting {1} chunks", 
                header.ByteLength, header.ChunkCount);

            Receiving = true;
            dataIn = new byte[header.ByteLength];
            dataReceived = new bool[header.ChunkCount];
            countReceived = 0;
        }
Exemple #26
0
 public abstract void ReadScaleFactor(Bitstream stream, Header header);
Exemple #27
0
 public abstract void ReadBitAllocation(Bitstream stream, Header header, Crc16 crc);
Exemple #28
0
 /// <summary>
 ///     *
 /// </summary>
 public override bool read_sampledata(Bitstream stream)
 {
     return(base.read_sampledata(stream));
 }
Exemple #29
0
 /// <summary>
 ///     *
 /// </summary>
 public override void read_allocation(Bitstream stream, Header header, Crc16 crc)
 {
     base.read_allocation(stream, header, crc);
 }
Exemple #30
0
        private void ProcessPacket(byte[] bytes, int length)
        {
            using (var stream = Bitstream.CreateWith(bytes, length))
            {
                var seq = stream.ReadUInt32();
                var ack = stream.ReadUInt32();

                var flags    = stream.ReadByte();
                var checksum = stream.ReadUInt16();

                var at       = stream.Position;
                var computed = CrcUtils.Compute16(stream);
                stream.Position = at;

                if (checksum != computed)
                {
                    return;
                }

                var reliableState = stream.ReadByte();

                if (seq < sequenceIn)
                {
                    // We no longer care.
                    return;
                }

                for (byte i = 0; i < subchannels.Length; ++i)
                {
                    var channel = subchannels[i];
                    var mask    = 1 << i;

                    if ((reliableStateOut & mask) == (reliableState & mask))
                    {
                        if (channel.Blocked)
                        {
                            channel.Clear();
                        }
                    }
                    else
                    {
                        if (channel.Blocked && channel.SentIn < ack)
                        {
                            reliableStateOut = Flip(reliableStateOut, i);
                            channel.Requeue();
                        }
                    }
                }

                if ((flags & (uint)PacketFlags.IsReliable) != 0)
                {
                    var bit = stream.ReadBits(3);
                    reliableStateIn = Flip(reliableStateIn, bit);

                    for (var i = 0; i < streams.Length; ++i)
                    {
                        var message = streams[i].Receive(stream);

                        if (message.HasValue)
                        {
                            ProcessMessage(message.Value);
                        }
                    }
                }

                while (stream.HasByte())
                {
                    HandleMessage(stream);
                }

                if (!stream.Eof)
                {
                    var remain      = (byte)stream.Remain;
                    var expect      = (1 << remain) - 1;
                    var expectedTru = stream.ReadBits(remain) == expect; // if false then probably something wrong
                }

                lastAckRecv = ack;
                sequenceIn  = seq;
            }
        }
        private float UnpackFloatNoScale(Bitstream stream)
        {
            var data = stream.ReadManyBits(32);

            return(BitConverter.ToSingle(data, 0));
        }
 /// <summary>
 ///     *
 /// </summary>
 public override bool read_sampledata(Bitstream stream)
 {
     return base.read_sampledata(stream);
 }
Exemple #33
0
 /// <summary>
 ///     *
 /// </summary>
 public override void ReadBitAllocation(Bitstream stream, Header header, Crc16 crc)
 {
     base.ReadBitAllocation(stream, header, crc);
 }
Exemple #34
0
        private void ReadUpdate(uint id, Bitstream stream)
        {
            var entity = state.Slots[id].Entity;

            ReadAndUnpackFields(entity, stream);
        }
        public void UnpackArray(uint tick, List <Property> elements, PropertyInfo info, Bitstream stream)
        {
            var countBits = MiscMath.Log2(info.NumElements + 1);
            var count     = stream.ReadBits(countBits);

            if (elements.Count > count)
            {
                elements.RemoveRange(0, elements.Count - (int)count);
            }
            else
            {
                while (elements.Count < count)
                {
                    elements.Add(Property.For(info.ArrayProp));
                }
            }

            foreach (var element in elements)
            {
                element.Update(tick, this, stream);
            }
        }
Exemple #36
0
        /// <summary>
        ///     Connect to the game server. Will use existing lobby on default.
        /// </summary>
        /// <param name="lobb"></param>
        public void Connect(CSODOTALobby lobb = null)
        {
            if (_connectDetails != null)
            {
                Disconnect();
            }

            lobb = lobb ?? DotaGc.Lobby;
            if (lobb == null)
            {
                Log("No lobby so not connecting.");
                return;
            }

            _connectLobby = lobb;
            if (_appOwnershipTicket == null)
            {
                Log("Waiting for ownership ticket...");
                _waitingForAuthTicket = true;
                FetchAppTicket();
                return;
            }

            _authTicket = AuthTicket.CreateAuthTicket(_gameConnectTokens.Dequeue(), publicIP);

            var ver = new CMsgAuthTicket
            {
                gameid       = (uint)DotaGc.GameID,
                h_steam_pipe = 327684,
                ticket       = _authTicket
            };

            using (var stream = Bitstream.CreateWith(_authTicket))
                ver.ticket_crc = CrcUtils.Compute32(stream);

            _connectDetails = new DOTAConnectDetails
            {
                AuthTicket       = _authTicket,
                ServerAuthTicket = AuthTicket.CreateServerTicket(DotaGc.SteamClient.SteamID, _authTicket, _appOwnershipTicket),
                ConnectInfo      = lobb.connect,
                ConnectID        = _connectAttempt++,
                AuthTicketCRC    = ver.ticket_crc,
                Name             = DotaGc.SteamClient.GetHandler <SteamFriends>().GetPersonaName(),
                PassKey          = lobb.pass_key,
                SteamId          = DotaGc.SteamClient.SteamID.ConvertToUInt64()
            };

            var msg = new ClientMsgProtobuf <CMsgClientAuthList>(EMsg.ClientAuthList)
            {
                Body =
                {
                    tokens_left      = (uint)_gameConnectTokens.Count,
                    app_ids          = { (uint)DotaGc.GameID },
                    tickets          = { ver },
                    message_sequence = 2 // Second in sequence.
                }
            };

            DotaGc.SteamClient.Send(msg);
            Log("Sent crc ticket auth list, hash: " + ver.ticket_crc + ".");
        }
Exemple #37
0
 /// <summary>
 ///     *
 /// </summary>
 public override bool ReadSampleData(Bitstream stream)
 {
     return(base.ReadSampleData(stream));
 }
Exemple #38
0
 public abstract bool ReadSampleData(Bitstream stream);
Exemple #39
0
        /// <summary>
        ///     *
        /// </summary>
        public override void ReadScaleFactor(Bitstream stream, Header header)
        {
            if (allocation != 0)
            {
                switch (scfsi)
                {
                    case 0:
                        scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 1:
                        scalefactor1 = scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 2:
                        scalefactor1 = scalefactor2 = scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;

                    case 3:
                        scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        scalefactor2 = scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)];
                        break;
                }
                prepare_sample_reading(header, allocation, 0, factor, codelength, c, d);
            }
        }
    // Read the next word from the bitstream "wvbits" and return the value. This
    // function can be used for hybrid or lossless streams, but since an
    // optimized version is available for lossless this function would normally
    // be used for hybrid only. If a hybrid lossless stream is being read then
    // the "correction" offset is written at the specified pointer. A return value
    // of WORD_EOF indicates that the end of the bitstream was reached (all 1s) or
    // some other error occurred.

    internal static int get_words(long nsamples, long flags, words_data w, Bitstream bs, int[] buffer, int bufferStartPos)
    {
        entropy_data[] c = w.c;
        int            csamples;
        int            buffer_counter = bufferStartPos;
        int            entidx         = 1;

        if ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) == 0)
        // if not mono
        {
            nsamples *= 2;
        }
        else
        {
            // it is mono
            entidx = 0;
        }

        for (csamples = 0; csamples < nsamples; ++csamples)
        {
            long ones_count, low, high, mid;

            if ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) == 0)
            // if not mono
            {
                if (entidx == 1)
                {
                    entidx = 0;
                }
                else
                {
                    entidx = 1;
                }
            }

            if ((w.c[0].median[0] & ~1) == 0 && w.holding_zero == 0 && w.holding_one == 0 && (w.c[1].median[0] & ~1) == 0)
            {
                long mask;
                int  cbits;

                if (w.zeros_acc > 0)
                {
                    --w.zeros_acc;

                    if (w.zeros_acc > 0)
                    {
                        c[entidx].slow_level  -= ((c[entidx].slow_level + SLO) >> SLS);
                        buffer[buffer_counter] = 0;
                        buffer_counter++;
                        continue;
                    }
                }
                else
                {
                    cbits = 0;
                    bs    = BitsUtils.getbit(bs);

                    while (cbits < 33 && bs.bitval > 0)
                    {
                        cbits++;
                        bs = BitsUtils.getbit(bs);
                    }

                    if (cbits == 33)
                    {
                        break;
                    }

                    if (cbits < 2)
                    {
                        w.zeros_acc = cbits;
                    }
                    else
                    {
                        --cbits;

                        for (mask = 1, w.zeros_acc = 0; cbits > 0; mask <<= 1)
                        {
                            bs = BitsUtils.getbit(bs);

                            if (bs.bitval > 0)
                            {
                                w.zeros_acc |= mask;
                            }
                            cbits--;
                        }

                        w.zeros_acc |= mask;
                    }

                    if (w.zeros_acc > 0)
                    {
                        c[entidx].slow_level -= ((c[entidx].slow_level + SLO) >> SLS);
                        w.c[0].median[0]      = 0;
                        w.c[0].median[1]      = 0;
                        w.c[0].median[2]      = 0;
                        w.c[1].median[0]      = 0;
                        w.c[1].median[1]      = 0;
                        w.c[1].median[2]      = 0;

                        buffer[buffer_counter] = 0;
                        buffer_counter++;
                        continue;
                    }
                }
            }

            if (w.holding_zero > 0)
            {
                ones_count = w.holding_zero = 0;
            }
            else
            {
                int next8;
                int uns_buf;

                if (bs.bc < 8)
                {
                    bs.ptr++;
                    bs.buf_index++;

                    if (bs.ptr == bs.end)
                    {
                        bs = BitsUtils.bs_read(bs);
                    }

                    uns_buf = (int)(bs.buf[bs.buf_index] & 0xff);

                    bs.sr = bs.sr | (uns_buf << bs.bc);                     // values in buffer must be unsigned

                    next8 = (int)(bs.sr & 0xff);

                    bs.bc += 8;
                }
                else
                {
                    next8 = (int)(bs.sr & 0xff);
                }

                if (next8 == 0xff)
                {
                    bs.bc  -= 8;
                    bs.sr >>= 8;

                    ones_count = 8;
                    bs         = BitsUtils.getbit(bs);

                    while (ones_count < (LIMIT_ONES + 1) && bs.bitval > 0)
                    {
                        ones_count++;
                        bs = BitsUtils.getbit(bs);
                    }

                    if (ones_count == (LIMIT_ONES + 1))
                    {
                        break;
                    }

                    if (ones_count == LIMIT_ONES)
                    {
                        int mask;
                        int cbits;

                        cbits = 0;
                        bs    = BitsUtils.getbit(bs);

                        while (cbits < 33 && bs.bitval > 0)
                        {
                            cbits++;
                            bs = BitsUtils.getbit(bs);
                        }

                        if (cbits == 33)
                        {
                            break;
                        }

                        if (cbits < 2)
                        {
                            ones_count = cbits;
                        }
                        else
                        {
                            for (mask = 1, ones_count = 0; --cbits > 0; mask <<= 1)
                            {
                                bs = BitsUtils.getbit(bs);

                                if (bs.bitval > 0)
                                {
                                    ones_count |= mask;
                                }
                            }
                            ones_count |= mask;
                        }

                        ones_count += LIMIT_ONES;
                    }
                }
                else
                {
                    bs.bc = (int)(bs.bc - ((ones_count = ones_count_table[next8]) + 1));
                    bs.sr = bs.sr >> (int)(ones_count + 1);                      // needs to be unsigned
                }

                if (w.holding_one > 0)
                {
                    w.holding_one = ones_count & 1;
                    ones_count    = (ones_count >> 1) + 1;
                }
                else
                {
                    w.holding_one = ones_count & 1;
                    ones_count  >>= 1;
                }

                w.holding_zero = (int)(~w.holding_one & 1);
            }

            if ((flags & Defines.HYBRID_FLAG) > 0 && ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) > 0 || (csamples & 1) == 0))
            {
                w = update_error_limit(w, flags);
            }

            if (ones_count == 0)
            {
                low  = 0;
                high = (((c[entidx].median[0]) >> 4) + 1) - 1;

                // for c# I replace the division by DIV0 with >> 7
                c[entidx].median[0] -= (((c[entidx].median[0] + (DIV0 - 2)) >> 7) * 2);
            }
            else
            {
                low = (((c[entidx].median[0]) >> 4) + 1);

                // for c# I replace the division by DIV0 with >> 7
                c[entidx].median[0] += ((c[entidx].median[0] + DIV0) >> 7) * 5;

                if (ones_count == 1)
                {
                    high = low + (((c[entidx].median[1]) >> 4) + 1) - 1;
                    // for c# I replace the division by DIV1 with >> 6
                    c[entidx].median[1] -= ((c[entidx].median[1] + (DIV1 - 2)) >> 6) * 2;
                }
                else
                {
                    low += (((c[entidx].median[1]) >> 4) + 1);
                    // for c# I replace the division by DIV1 with >> 6
                    c[entidx].median[1] += ((c[entidx].median[1] + DIV1) >> 6) * 5;

                    if (ones_count == 2)
                    {
                        high = low + (((c[entidx].median[2]) >> 4) + 1) - 1;
                        // for c# I replace the division by DIV2 with >> 5
                        c[entidx].median[2] -= ((c[entidx].median[2] + (DIV2 - 2)) >> 5) * 2;
                    }
                    else
                    {
                        low += (ones_count - 2) * (((c[entidx].median[2]) >> 4) + 1);
                        high = low + (((c[entidx].median[2]) >> 4) + 1) - 1;
                        // for c# I replace the division by DIV2 with >> 5
                        c[entidx].median[2] += ((c[entidx].median[2] + DIV2) >> 5) * 5;
                    }
                }
            }

            mid = (high + low + 1) >> 1;

            if (c[entidx].error_limit == 0)
            {
                mid = read_code(bs, high - low);

                mid = mid + low;
            }
            else
            {
                while (high - low > c[entidx].error_limit)
                {
                    bs = BitsUtils.getbit(bs);

                    if (bs.bitval > 0)
                    {
                        mid = (high + (low = mid) + 1) >> 1;
                    }
                    else
                    {
                        mid = ((high = mid - 1) + low + 1) >> 1;
                    }
                }
            }

            bs = BitsUtils.getbit(bs);

            if (bs.bitval > 0)
            {
                buffer[buffer_counter] = (int)~mid;
            }
            else
            {
                buffer[buffer_counter] = (int)mid;
            }

            buffer_counter++;

            if ((flags & Defines.HYBRID_BITRATE) > 0)
            {
                c[entidx].slow_level = c[entidx].slow_level - ((c[entidx].slow_level + SLO) >> SLS) + mylog2(mid);
            }
        }

        w.c = c;

        if ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) != 0)
        {
            return(csamples);
        }
        else
        {
            return(csamples / 2);
        }
    }
Exemple #41
0
        private void ReceivePacket(byte[] bytes, int length)
        {
            ++receivedTotal;

            using (var stream = Bitstream.CreateWith(bytes, length))
            {
                var type = stream.ReadUInt32();

                if (type == COMPRESSED_PACKET)
                {
                    var method = stream.ReadUInt32();

                    var compressed = new byte[length - 8];
                    stream.Read(compressed, 0, compressed.Length);

                    var decompressed = Lzss.Decompress(compressed);
                    ProcessPacket(decompressed, decompressed.Length);
                }
                else if (type == SPLIT_PACKET)
                {
                    var request = stream.ReadUInt32();
                    var total   = stream.ReadByte();
                    var index   = stream.ReadByte();
                    var size    = stream.ReadUInt16();

                    SplitPacket split;
                    if (!splitPackets.ContainsKey(request))
                    {
                        split = new SplitPacket
                        {
                            Request  = request,
                            Total    = total,
                            Received = 0,
                            Data     = new byte[total][],
                            Present  = new bool[total]
                        };
                        splitPackets[request] = split;
                    }
                    else
                    {
                        split = splitPackets[request];
                    }

                    var buffer = new byte[Math.Min(size, (stream.Remain + 7) / 8)];
                    stream.Read(buffer, 0, buffer.Length);
                    split.Data[index] = buffer;

                    if (!split.Present[index])
                    {
                        ++split.Received;
                        split.Present[index] = true;
                    }

                    if (split.Received == split.Total)
                    {
                        var full = split.Data.SelectMany(b => b).ToArray();
                        ReceivePacket(full, full.Length);
                        splitPackets.Remove(request);
                    }
                }
                else if (type == OOB_PACKET)
                {
                    var data = new byte[stream.Length - 4];
                    stream.Read(data, 0, data.Length);

                    receivedOutOfBand.Enqueue(data);
                }
                else
                {
                    ProcessPacket(bytes, length);
                }
            }
        }
 private float UnpackFloatCoordMp(Bitstream stream, FloatType type)
 {
     throw new NotImplementedException();
 }
Exemple #43
0
 public abstract bool read_sampledata(Bitstream stream);
 /// <summary>
 ///     *
 /// </summary>
 public override void read_allocation(Bitstream stream, Header header, Crc16 crc)
 {
     base.read_allocation(stream, header, crc);
 }
Exemple #45
0
        private void WriteUserCmd(UserCmd cmd, UserCmd last, Bitstream stream)
        {
            if (cmd.Command != last.Command + 1)
            {
                stream.WriteBool(true);
                stream.WriteUInt32(cmd.Command);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.Tick != last.Tick + 1)
            {
                stream.WriteBool(true);
                stream.WriteUInt32(cmd.Tick);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.ViewAngles.X != last.ViewAngles.X)
            {
                stream.WriteBool(true);
                stream.WriteFloat(cmd.ViewAngles.X);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.ViewAngles.X != last.ViewAngles.X)
            {
                stream.WriteBool(true);
                stream.WriteFloat(cmd.ViewAngles.X);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.ViewAngles.Z != last.ViewAngles.Z)
            {
                stream.WriteBool(true);
                stream.WriteFloat(cmd.ViewAngles.Z);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.ForwardMove != last.ForwardMove)
            {
                stream.WriteBool(true);
                stream.WriteFloat(cmd.ForwardMove);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.SideMove != last.SideMove)
            {
                stream.WriteBool(true);
                stream.WriteFloat(cmd.SideMove);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.UpMove != last.UpMove)
            {
                stream.WriteBool(true);
                stream.WriteFloat(cmd.UpMove);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.Buttons != last.Buttons)
            {
                stream.WriteBool(true);
                stream.WriteUInt32(cmd.Buttons);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.Impulse != last.Impulse)
            {
                stream.WriteBool(true);
                stream.WriteByte(cmd.Impulse);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.CrosshairTrace != last.CrosshairTrace)
            {
                stream.WriteBool(true);
                stream.WriteBitVec3Coord(cmd.CrosshairTrace);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.CursorUnitEntIndex != last.CursorUnitEntIndex)
            {
                stream.WriteBool(true);
                stream.WriteBits(cmd.CursorUnitEntIndex, 11);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.QueryEntIndex != last.QueryEntIndex)
            {
                stream.WriteBool(true);
                stream.WriteBits(cmd.QueryEntIndex, 11);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.CursorUnitEntIndex != last.CursorUnitEntIndex)
            {
                stream.WriteBool(true);
                stream.WriteBits(cmd.CursorUnitEntIndex, 11);

                if (cmd.QueryEntIndex != last.QueryEntIndex)
                {
                    stream.WriteBool(true);
                    stream.WriteBits(cmd.QueryEntIndex, 11);
                }
                else
                {
                    stream.WriteBool(false);
                }
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.MouseDx != last.MouseDx)
            {
                stream.WriteBool(true);
                stream.WriteUInt16(cmd.MouseDx);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.MouseDy != last.MouseDy)
            {
                stream.WriteBool(true);
                stream.WriteUInt16(cmd.MouseDy);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.Offset3c != last.Offset3c)
            {
                stream.WriteBool(true);
                stream.WriteUInt16(cmd.Offset3c);
            }
            else
            {
                stream.WriteBool(false);
            }

            // 0x44 to 0x74 inclusive
            if (cmd.OrderId != last.OrderId)
            {
                stream.WriteBool(true);
                stream.WriteInt16(cmd.OrderId);
                stream.WriteInt16((short)cmd.Order.Value.SelectedUnits.Length);

                foreach (var entity in cmd.Order.Value.SelectedUnits)
                {
                    stream.WriteBits(entity, 11);
                }

                stream.WriteInt16(cmd.Order.Value.OrderType);
                stream.WriteInt16(cmd.Order.Value.EntityIndex1);
                stream.WriteBitVec3Coord(cmd.Order.Value.PreparedOrderPoint);
                stream.WriteBits(cmd.Order.Value.BaseNpcHandle, 11);
                stream.WriteBool(cmd.Order.Value.QueueOrder);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.CameraX != last.CameraX || cmd.CameraY != last.CameraY)
            {
                stream.WriteBool(true);
                stream.WriteUInt16(cmd.CameraX);
                stream.WriteUInt16(cmd.CameraY);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.ClickBehavior != last.ClickBehavior)
            {
                stream.WriteBool(true);
                stream.WriteByte(cmd.ClickBehavior);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.SpectatorStatsSomething != last.SpectatorStatsSomething)
            {
                stream.WriteBool(true);
                stream.WriteByte(cmd.SpectatorStatsSomething);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.ShopModeSomething != last.ShopModeSomething)
            {
                stream.WriteBool(true);
                stream.WriteByte(cmd.ShopModeSomething);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.HudStatsDropdownCategoryIndex != last.HudStatsDropdownCategoryIndex)
            {
                stream.WriteBool(true);
                stream.WriteByte(cmd.HudStatsDropdownCategoryIndex);
            }
            else
            {
                stream.WriteBool(false);
            }

            if (cmd.HudStatsDropdownSortMethod != last.HudStatsDropdownSortMethod)
            {
                stream.WriteBool(true);
                stream.WriteByte(cmd.HudStatsDropdownSortMethod);
            }
            else
            {
                stream.WriteBool(false);
            }
        }
Exemple #46
0
 /// <summary>
 ///     *
 /// </summary>
 public virtual void read_scalefactor_selection(Bitstream stream, Crc16 crc)
 {
     if (allocation != 0)
     {
         scfsi = stream.GetBitsFromBuffer(2);
         if (crc != null)
             crc.add_bits(scfsi, 2);
     }
 }
Exemple #47
0
 public abstract void read_allocation(Bitstream stream, Header header, Crc16 crc);
Exemple #48
0
        /// <summary>
        ///     *
        /// </summary>
        public override bool ReadSampleData(Bitstream stream)
        {
            if (allocation != 0)
                if (groupingtable[0] != null)
                {
                    int samplecode = stream.GetBitsFromBuffer(codelength[0]);
                    // create requantized samples:
                    samplecode += samplecode << 1;
                    float[] target = samples;
                    float[] source = groupingtable[0];
                    /*
                    int tmp = 0;
                    int temp = 0;
                    target[tmp++] = source[samplecode + temp];
                    temp++;
                    target[tmp++] = source[samplecode + temp];
                    temp++;
                    target[tmp] = source[samplecode + temp];
                    */
                    //Bugfix:
                    int tmp = 0;
                    int temp = samplecode;

                    if (temp > source.Length - 3)
                        temp = source.Length - 3;

                    target[tmp] = source[temp];
                    temp++;
                    tmp++;
                    target[tmp] = source[temp];
                    temp++;
                    tmp++;
                    target[tmp] = source[temp];

                    // memcpy (samples, groupingtable + samplecode, 3 * sizeof (real));
                }
                else
                {
                    samples[0] = (float)((stream.GetBitsFromBuffer(codelength[0])) * factor[0] - 1.0);
                    samples[1] = (float)((stream.GetBitsFromBuffer(codelength[0])) * factor[0] - 1.0);
                    samples[2] = (float)((stream.GetBitsFromBuffer(codelength[0])) * factor[0] - 1.0);
                }

            samplenumber = 0;
            if (++groupnumber == 12)
                return true;
            return false;
        }
Exemple #49
0
 public abstract void read_scalefactor(Bitstream stream, Header header);