internal CustomCommand Configure(int opCode, int sender, Stream lps, RTData data, int limit, IRTSessionInternal session, int packetSize)
        {
            ms = PooledObjects.MemoryStreamPool.Pop();
            this.packetSize    = packetSize;
            this.opCode        = opCode;
            this.sender        = sender;
            this.data          = data;
            this.session       = session;
            this.limit         = limit;
            this.limitedStream = null;

            if (lps != null)
            {
                limitedStream = PooledObjects.LimitedPositionStreamPool.Pop();

                for (int i = 0; i < limit; i++)
                {
                    byte read = (byte)lps.ReadByte();
                    ms.WriteByte(read);
                }
                ms.Position = 0;
                limitedStream.Wrap(ms, limit);
            }

            return(this);
        }
Пример #2
0
    public void OnPacket(string packet)
    {
        if (!ignoreEvent && m_OnPacket != null)
        {
            packet = DecodeFromUtf8(packet);

            JsonObject            o             = (JsonObject)SimpleJson2.SimpleJson2.DeserializeObject(packet);
            int                   opCode        = Convert.ToInt32(o ["opCode"]);
            int                   sender        = Convert.ToInt32(o ["sender"]);
            int                   limit         = Convert.ToInt32(o ["streamLength"]);
            int                   packetSize    = Convert.ToInt32(o ["packetSize"]);
            JsonObject            data          = (JsonObject)o ["data"];
            RTData                data2         = DeserializeData(data);
            JsonObject            stream        = (JsonObject)o ["stream"];
            LimitedPositionStream limitedStream = null;

            if (stream != null)
            {
                limitedStream = new LimitedPositionStream(Encoding.UTF8.GetBytes((string)((JsonObject)stream ["stream"]) ["buffer"]),
                                                          Convert.ToInt32(stream ["limit"]));
            }

            RTPacket packet2 = new RTPacket(opCode, sender, limitedStream, limit, data2, packetSize);

            m_OnPacket(packet2);
        }
    }
        internal static IRTCommand GetCommand(int opCode, int sender, int?sequence, Stream stream, IRTSessionInternal session, RTData data, int packetSize)
        {
            long limit = global::GameSparks.RT.Proto.ProtocolParser.ReadUInt32(stream);
            LimitedPositionStream lps = PooledObjects.LimitedPositionStreamPool.Pop();

            try{
                lps.Wrap(stream, limit);
                switch (opCode)
                {
                case OpCodes.LoginResult:
                    return(LoginResult.Deserialize(lps, LoginResult.pool.Pop()));

                case OpCodes.PingResult:
                    return(PingResult.Deserialize(lps, PingResult.pool.Pop()));

                case OpCodes.UDPConnectMessage:
                    return(UDPConnectMessage.Deserialize(lps, UDPConnectMessage.pool.Pop()));

                case OpCodes.PlayerConnectMessage:
                    return(PlayerConnectMessage.Deserialize(lps, PlayerConnectMessage.pool.Pop()));

                case OpCodes.PlayerDisconnectMessage:
                    return(PlayerDisconnectMessage.Deserialize(lps, PlayerDisconnectMessage.pool.Pop()));

                default:
                    if (session.ShouldExecute(sender, sequence))
                    {
                        return(CustomCommand.pool.Pop().Configure(opCode, sender, lps, data, (int)limit, session, packetSize));
                    }

                    return(null);
                }
            } finally {
                lps.SkipToEnd();
                PooledObjects.LimitedPositionStreamPool.Push(lps);
            }
        }