Example #1
0
 public void load(PacketInputStream ps)
 {
     tableid = ps.loadInt();
     pid     = ps.loadInt();
     nick    = ps.loadString();
     seat    = ps.loadByte();
 }
Example #2
0
 public void load(PacketInputStream ps)
 {
     seq     = ps.loadInt();
     gameid  = ps.loadInt();
     address = ps.loadString();
     status  = Enums.makeFilteredJoinResponseStatus(ps.loadUnsignedByte());
 }
Example #3
0
 public void load(PacketInputStream ps)
 {
     inviter    = ps.loadInt();
     screenname = ps.loadString();
     tableid    = ps.loadInt();
     seat       = ps.loadByte();
 }
 public void load(PacketInputStream ps)
 {
     type     = Enums.makeLobbyType(ps.loadUnsignedByte());
     gameid   = ps.loadInt();
     address  = ps.loadString();
     objectid = ps.loadInt();
 }
Example #5
0
 public void load(PacketInputStream ps)
 {
     tableid = ps.loadInt();
     seat    = ps.loadByte();
     status  = Enums.makeJoinResponseStatus(ps.loadUnsignedByte());
     code    = ps.loadInt();
 }
        public void load(PacketInputStream ps)
        {
            tableid = ps.loadInt();
            int inviteesCount = ps.loadInt();

            invitees = new int[inviteesCount];
            ps.loadIntArray(invitees);
        }
Example #7
0
 public void load(PacketInputStream ps)
 {
     tableid  = ps.loadInt();
     seat     = ps.loadByte();
     mttid    = ps.loadInt();
     snapshot = new TableSnapshotPacket();
     snapshot.load(ps);
 }
 public void load(PacketInputStream ps)
 {
     pid       = ps.loadInt();
     channelid = ps.loadInt();
     targetid  = ps.loadInt();
     nick      = ps.loadString();
     message   = ps.loadString();
 }
Example #9
0
        public void load(PacketInputStream ps)
        {
            type    = ps.loadInt();
            level   = ps.loadInt();
            message = ps.loadString();
            int pidsCount = ps.loadInt();

            pids = new int[pidsCount];
            ps.loadIntArray(pids);
        }
        public void load(PacketInputStream ps)
        {
            seq = ps.loadInt();
            int servicedataCount = ps.loadInt();

            servicedata = new byte[servicedataCount];
            if (servicedataCount > 0)
            {
                ps.loadByteArray(servicedata);
            }
        }
Example #11
0
        public void load(PacketInputStream ps)
        {
            mttid = ps.loadInt();
            pid   = ps.loadInt();
            int mttdataCount = ps.loadInt();

            mttdata = new byte[mttdataCount];
            if (mttdataCount > 0)
            {
                ps.loadByteArray(mttdata);
            }
        }
Example #12
0
        public void load(PacketInputStream ps)
        {
            tableid = ps.loadInt();
            pid     = ps.loadInt();
            int gamedataCount = ps.loadInt();

            gamedata = new byte[gamedataCount];
            if (gamedataCount > 0)
            {
                ps.loadByteArray(gamedata);
            }
        }
Example #13
0
        public void load(PacketInputStream ps)
        {
            pid    = ps.loadInt();
            nick   = ps.loadString();
            status = Enums.makeResponseStatus(ps.loadUnsignedByte());
            int dataCount = ps.loadInt();

            data = new byte[dataCount];
            if (dataCount > 0)
            {
                ps.loadByteArray(data);
            }
        }
        public void load(PacketInputStream ps)
        {
            mttid = ps.loadInt();
            int parametersCount = ps.loadInt();

            parameters = new List <Param>(parametersCount);
            for (int i = 0; i != parametersCount; ++i)
            {
                Param _tmp = new Param();
                _tmp.load(ps);
                parameters.Add(_tmp);
            }
        }
Example #15
0
        public void load(PacketInputStream ps)
        {
            user       = ps.loadString();
            password   = ps.loadString();
            operatorid = ps.loadInt();
            int credentialsCount = ps.loadInt();

            credentials = new byte[credentialsCount];
            if (credentialsCount > 0)
            {
                ps.loadByteArray(credentials);
            }
        }
Example #16
0
        public void load(PacketInputStream ps)
        {
            pid  = ps.loadInt();
            nick = ps.loadString();
            int detailsCount = ps.loadInt();

            details = new List <Param>(detailsCount);
            for (int i = 0; i != detailsCount; ++i)
            {
                Param _tmp = new Param();
                _tmp.load(ps);
                details.Add(_tmp);
            }
        }
Example #17
0
        public void load(PacketInputStream ps)
        {
            id      = ps.loadInt();
            tableid = ps.loadInt();
            int stampsCount = ps.loadInt();

            stamps = new List <ProbeStamp>(stampsCount);
            for (int i = 0; i != stampsCount; ++i)
            {
                ProbeStamp _tmp = new ProbeStamp();
                _tmp.load(ps);
                stamps.Add(_tmp);
            }
        }
        public void load(PacketInputStream ps)
        {
            tableid = ps.loadInt();
            status  = Enums.makeResponseStatus(ps.loadUnsignedByte());
            int seatsCount = ps.loadInt();

            seats = new List <SeatInfoPacket>(seatsCount);
            for (int i = 0; i != seatsCount; ++i)
            {
                SeatInfoPacket _tmp = new SeatInfoPacket();
                _tmp.load(ps);
                seats.Add(_tmp);
            }
        }
Example #19
0
        public void load(PacketInputStream ps)
        {
            screenname = ps.loadString();
            pid        = ps.loadInt();
            status     = Enums.makeResponseStatus(ps.loadUnsignedByte());
            code       = ps.loadInt();
            message    = ps.loadString();
            int credentialsCount = ps.loadInt();

            credentials = new byte[credentialsCount];
            if (credentialsCount > 0)
            {
                ps.loadByteArray(credentials);
            }
        }
Example #20
0
        public void load(PacketInputStream ps)
        {
            seq     = ps.loadInt();
            gameid  = ps.loadInt();
            address = ps.loadString();
            int parametersCount = ps.loadInt();

            parameters = new List <ParamFilter>(parametersCount);
            for (int i = 0; i != parametersCount; ++i)
            {
                ParamFilter _tmp = new ParamFilter();
                _tmp.load(ps);
                parameters.Add(_tmp);
            }
        }
Example #21
0
        public void load(PacketInputStream ps)
        {
            int tournamentsCount = ps.loadInt();

            tournaments = new int[tournamentsCount];
            ps.loadIntArray(tournaments);
        }
Example #22
0
 public void load(PacketInputStream ps)
 {
     tableid = ps.loadInt();
     seat    = ps.loadByte();
     status  = Enums.makePlayerStatus(ps.loadUnsignedByte());
     player  = new PlayerInfoPacket();
     player.load(ps);
 }
Example #23
0
        public void load(PacketInputStream ps)
        {
            mttid = ps.loadInt();
            int parametersCount = ps.loadInt();

            parameters = new List <Param>(parametersCount);
            for (int i = 0; i != parametersCount; ++i)
            {
                Param _tmp = new Param();
                _tmp.load(ps);
                parameters.Add(_tmp);
            }
            int removedParamsCount = ps.loadInt();

            removedParams = new string[removedParamsCount];
            ps.loadStringArray(removedParams);
        }
Example #24
0
        public void load(PacketInputStream ps)
        {
            tableid  = ps.loadInt();
            address  = ps.loadString();
            name     = ps.loadString();
            capacity = ps.loadShort();
            seated   = ps.loadShort();
            int parametersCount = ps.loadInt();

            parameters = new List <Param>(parametersCount);
            for (int i = 0; i != parametersCount; ++i)
            {
                Param _tmp = new Param();
                _tmp.load(ps);
                parameters.Add(_tmp);
            }
        }
        public void load(PacketInputStream ps)
        {
            seq    = ps.loadInt();
            gameid = ps.loadInt();
            seats  = ps.loadByte();
            int parametersCount = ps.loadInt();

            parameters = new List <Param>(parametersCount);
            for (int i = 0; i != parametersCount; ++i)
            {
                Param _tmp = new Param();
                _tmp.load(ps);
                parameters.Add(_tmp);
            }
            int inviteesCount = ps.loadInt();

            invitees = new int[inviteesCount];
            ps.loadIntArray(invitees);
        }
Example #26
0
        public void load(PacketInputStream ps)
        {
            func = ps.loadByte();
            int payloadCount = ps.loadInt();

            payload = new byte[payloadCount];
            if (payloadCount > 0)
            {
                ps.loadByteArray(payload);
            }
        }
Example #27
0
        public void load(PacketInputStream ps)
        {
            key  = ps.loadString();
            type = ps.loadByte();
            int valueCount = ps.loadInt();

            value = new byte[valueCount];
            if (valueCount > 0)
            {
                ps.loadByteArray(value);
            }
        }
Example #28
0
        public void load(PacketInputStream ps)
        {
            int updatesCount = ps.loadInt();

            updates = new List <TableUpdatePacket>(updatesCount);
            for (int i = 0; i != updatesCount; ++i)
            {
                TableUpdatePacket _tmp = new TableUpdatePacket();
                _tmp.load(ps);
                updates.Add(_tmp);
            }
        }
Example #29
0
        public void load(PacketInputStream ps)
        {
            int snapshotsCount = ps.loadInt();

            snapshots = new List <TournamentSnapshotPacket>(snapshotsCount);
            for (int i = 0; i != snapshotsCount; ++i)
            {
                TournamentSnapshotPacket _tmp = new TournamentSnapshotPacket();
                _tmp.load(ps);
                snapshots.Add(_tmp);
            }
        }
Example #30
0
    public static int readIntParam(List <Param> parameters, string key)
    {
        foreach (Param param in parameters)
        {
            if (param.key == key)
            {
                MemoryStream      memStream         = new MemoryStream(param.value);
                BinaryReader      reader            = new BinaryReader(memStream);
                PacketInputStream packetInputStream = new PacketInputStream(reader);

                if (param.type == (byte)Enums.ParameterType.INT)
                {
                    return(packetInputStream.loadInt());
                }
            }
        }
        return(-1);
    }