C# BitStream.Read方法代码示例

        public ReplicaReturnResult Deserialize(BitStream inBitStream, uint timestamp, uint lastDeserializeTime, SystemAddress systemAddress)
        {
            if (lastDeserializeTime == 0)
                Console.Write("First call to Player::Deserialize\n");
            else
                Console.Write("Got Player::Deserialize\n");

            inBitStream.Read(out position);
            inBitStream.Read(out health);
            return ReplicaReturnResult.REPLICA_PROCESSING_DONE;
        }

        public static void clientRPC(RPCParameters rpcParameters)
        {
            BitStream b = new BitStream(rpcParameters, false);
            string name;

            if (!b.Read(out name))
            {
                Console.Write("Too-short bitstreams.\n");
                return;
            }

            Console.Write("In clientRPC:\n");
            Console.Write("Name is {0}\n", name);

            uint age;
            if (!b.ReadCompressed(out age))
            {
                return;
            }

            Console.Write("Age is {0}\n", age);
            Console.Out.Flush();

            bool wroteEmploymentStruct;
            if (!b.Read(out wroteEmploymentStruct))
            {
                return;
            }

            if (wroteEmploymentStruct)
            {
                Console.Write("We are employed.\n");

                EmploymentStruct employmentStruct;
                if (!b.Read(out employmentStruct.salary)) return;
                if (!b.Read(out employmentStruct.yearsEmployed)) return;

                Console.Write("Salary is {0}.  Years employed is {1}\n", employmentStruct.salary, employmentStruct.yearsEmployed);
            }
            else
                Console.Write("We are between jobs :)\n");

            quit = true;
        }

 public ReplicaReturnResult ReceiveScopeChange(BitStream inBitStream, SystemAddress systemAddress, uint timestamp)
 {
     bool inScope;
     inBitStream.Read(out inScope);
     if (inScope)
         Console.Write("Received message that scope is now true in Player\n");
     else
         Console.Write("Received message that scope is now false in Player\n");
     return ReplicaReturnResult.REPLICA_PROCESSING_DONE;
 }

 private static object Deserialize(BitStream stream, params object[] codecOptions)
 {
     byte[] numArray;
     int num;
     ContextMenuItemData[] contextMenuItemDataArray;
     int num1 = stream.Read<int>(codecOptions);
     if (num1 != 0)
     {
         contextMenuItemDataArray = new ContextMenuItemData[num1];
     }
     else
     {
         contextMenuItemDataArray = null;
     }
     ContextMenuItemData[] contextMenuItemDatum = contextMenuItemDataArray;
     for (int i = 0; i < num1; i++)
     {
         int num2 = stream.Read<int>(codecOptions);
         stream.ReadByteArray_MinimalCalls(out numArray, out num, codecOptions);
         contextMenuItemDatum[i] = new ContextMenuItemData(num2, num, numArray);
     }
     return new ContextMenuData(num1, contextMenuItemDatum);
 }

        public static string GetString(byte[] data)
        {
            int letters = data.Length * 8 / 5;
            string base32_string = "";
            BitStream b = new BitStream();
            b.Write(data, 0, data.Length);
            b.Seek(0, System.IO.SeekOrigin.Begin);
            if (b.Length == 0) return("");
            long output_length = b.Length;
            Console.WriteLine("bits in bitstream:" + b.Length);
            if (b.Length % 5 != 0)
            {
                Console.WriteLine("rest bits:" + (b.Length % 5));
                output_length += (5 - (b.Length % 5));
            }
            Console.WriteLine("bits in output buffer(+padding):" + output_length);
            byte[] output = new byte[output_length];
            output.Initialize();
            //output.Length
            int ret = b.Read(output, 0, (int)b.Length);//will crash with buffers over 4gb ,or something else
            //now we have an array of bits in output that will be converted to base32
            //5 bit to 1 byte + zero padding conversion
            //pad to correct length with zeros
            long pos = 0;
            while (pos < output.Length)
            {
                int value = 0;
                /*
                value += output[pos + 0] * 1;
                value += output[pos + 1] * 2;
                value += output[pos + 2] * 4;
                value += output[pos + 3] * 8;
                value += output[pos + 4] * 16;
                */

                value += output[pos + 0] * 16;
                value += output[pos + 1] * 8;
                value += output[pos + 2] * 4;
                value += output[pos + 3] * 2;
                value += output[pos + 4] * 1;

                base32_string += conversion_array[value];
                pos += 5;
            }
            Console.WriteLine("pos:"+pos);
            return (base32_string);
        }

        internal Sample(BitStream bitStream, byte bitsPerComponent, byte componentCount)
        {
            if (bitStream == null)
                throw new ArgumentNullException("bitStream");

            if (bitsPerComponent <= 0 || bitsPerComponent > 16)
                throw new ArgumentOutOfRangeException("bitsPerComponent");

            if (componentCount <= 0 || componentCount > 5)
                throw new ArgumentOutOfRangeException("componentCount");

            m_bitsPerComponent = bitsPerComponent;

            m_components = new short[componentCount];
            for (short i = 0; i < componentCount; ++i)
                m_components[i] = (short)bitStream.Read(bitsPerComponent);
        }

        internal void Deserialize(BitStream bs)
        {
            bool success;

            bool fieldExists;
            success = bs.Read(out fieldExists);
            Debug.Assert(success, "Failed to read synced class existance");

            if (fieldExists)
            {
                foreach (var mySyncedObject in m_syncedObjects)
                {
                    mySyncedObject.Deserialize(bs);
                }

                foreach (var mySynced in m_syncedVariables)
                {
                    mySynced.Deserialize(bs);
                }
            }
        }

 /// <summary>
 /// Convert a byte array
 /// </summary>
 /// <param name="original">Byte array</param>
 /// <returns>Base62 string</returns>
 public static string ToBase62( this byte[] original )
 {
     StringBuilder sb = new StringBuilder();
     BitStream stream = new BitStream( original );         // Set up the BitStream
     byte[] read = new byte[ 1 ];                          // Only read 6-bit at a time
     while( true )
     {
         read[ 0 ] = 0;
         int length = stream.Read( read, 0, 6 );           // Try to read 6 bits
         if( length == 6 )                                // Not reaching the end
         {
             if( (int)( read[ 0 ] >> 3 ) == 0x1f )            // First 5-bit is 11111
             {
                 sb.Append( Base62CodingSpace[ 61 ] );
                 stream.Seek( -1, SeekOrigin.Current );    // Leave the 6th bit to next group
             }
             else if( (int)( read[ 0 ] >> 3 ) == 0x1e )       // First 5-bit is 11110
             {
                 sb.Append( Base62CodingSpace[ 60 ] );
                 stream.Seek( -1, SeekOrigin.Current );
             }
             else                                        // Encode 6-bit
             {
                 sb.Append( Base62CodingSpace[ (int)( read[ 0 ] >> 2 ) ] );
             }
         }
         else if( length == 0 )                           // Reached the end completely
         {
             break;
         }
         else                                            // Reached the end with some bits left
         {
             // Padding 0s to make the last bits to 6 bit
             sb.Append( Base62CodingSpace[ (int)( read[ 0 ] >> (int)( 8 - length ) ) ] );
             break;
         }
     }
     return sb.ToString();
 }

        static void Main(string[] args)
        {
            char ch;
            bool isServer;
            RakPeerInterface serverRakPeer = RakNetworkFactory.GetRakPeerInterface();
            const int maxNumberOfClients = 2048;
            IList<Connection> clientConnections = new List<Connection>(maxNumberOfClients);
            const ushort portNum = 12345;
            int querySize = 1000;
            byte[] dummyData = new byte[querySize];
            Random r = new Random();
            r.NextBytes(dummyData);
            dummyData[0] = (byte)RakNetBindings.ID_USER_PACKET_ENUM;
            List<SystemAddress> incomingConnections = new List<SystemAddress>(maxNumberOfClients);
            Console.WriteLine("(S)erver or (C)lient?");
            ch = Console.ReadKey(true).KeyChar;
            if (ch == 's')
            {
                isServer = true;
                serverRakPeer.SetMaximumIncomingConnections(maxNumberOfClients);
                SocketDescriptor socketDescriptor = new SocketDescriptor(portNum, string.Empty);
                serverRakPeer.Startup(maxNumberOfClients, 0, new SocketDescriptor[] { socketDescriptor }, 1);
                Console.WriteLine("Server started");
            }
            else
            {
                isServer = false;
                Console.Write("Number of Clients: ");
                string numberOfClientsString = Console.ReadLine();
                int numberOfClients = Convert.ToInt32(numberOfClientsString);
                Console.Write("Query size: ");
                string querySizeString = Console.ReadLine();
                querySize = Convert.ToInt32(querySizeString);
                SocketDescriptor socketDescriptor = new SocketDescriptor();
                for (int i = 0; i < numberOfClients; ++i)
                {
                    RakPeerInterface clientRakPeer = RakNetworkFactory.GetRakPeerInterface();
                    clientRakPeer.Startup(1, 0, new SocketDescriptor[] { socketDescriptor }, 1);
                    clientConnections.Add(new Connection(clientRakPeer, false));
                }
                Console.WriteLine("Client started");
                Console.Write("Enter server IP: ");
                string serverIP = Console.ReadLine();
                Console.WriteLine("Connecting to server.");
                foreach (Connection clientConnection in clientConnections)
                {
                    clientConnection.RakPeer.Connect(serverIP, portNum, string.Empty, 0);
                }
            }
            //Console.WriteLine("(E)xit");
            uint lastLog = 0;
            while (true)
            {
                if (isServer)
                {
                    Packet p = serverRakPeer.Receive();
                    if (p != null)
                    {
                        BitStream inBitStream = new BitStream(p, false);
                        byte packetIdentifier;
                        inBitStream.Read(out packetIdentifier);
                        switch (packetIdentifier)
                        {
                            case RakNetBindings.ID_NEW_INCOMING_CONNECTION:
                                Console.WriteLine("ID_NEW_INCOMING_CONNECTION");
                                //incomingConnections.Add(p.systemAddress);
                                break;
                            case RakNetBindings.ID_USER_PACKET_ENUM:
                                serverRakPeer.Send(inBitStream, PacketPriority.HIGH_PRIORITY, PacketReliability.RELIABLE_ORDERED, 0, p.systemAddress, false);
                                break;
                        }
                        serverRakPeer.DeallocatePacket(p);
                    }

                    SystemAddress systemAddress = serverRakPeer.GetSystemAddressFromIndex(0);
                    //if (systemAddress.binaryAddress != RakNetBindings.UNASSIGNED_SYSTEM_ADDRESS.binaryAddress &&
                    //    systemAddress.port != RakNetBindings.UNASSIGNED_SYSTEM_ADDRESS.port)
                    if(!systemAddress.Equals(RakNetBindings.UNASSIGNED_SYSTEM_ADDRESS))
                    {
                        RakNetStatistics rss = serverRakPeer.GetStatistics(systemAddress);
                        if (RakNetBindings.GetTime() > lastLog + 4000)
                        {
                            Console.WriteLine("Packets sent:\t\t\t\t{0:D}", rss.packetsSent);
                            lastLog = RakNetBindings.GetTime();
                        }
                    }
                }
                else
                {
                    foreach(Connection clientConnection in clientConnections)
                    {
                        Packet p = clientConnection.RakPeer.Receive();
                        if (p != null)
                        {
                            BitStream inBitStream = new BitStream(p, false);
                            byte packetIdentifier;
                            inBitStream.Read(out packetIdentifier);
                            switch (packetIdentifier)
                            {
                                case RakNetBindings.ID_CONNECTION_REQUEST_ACCEPTED:
//.........这里部分代码省略.........

 private void HandlePacket(Packet packet)
 {
     logger.Debug("received Message:");
     BitStream inBitStream = new BitStream(packet, false);
     byte packetIdentifier;
     inBitStream.Read(out packetIdentifier);
     switch (packetIdentifier)
     {
         case RakNetBindings.ID_REMOTE_DISCONNECTION_NOTIFICATION:
             logger.Debug("Another client has disconnected.\n");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_REMOTE_CONNECTION_LOST:
             logger.Debug("Another client has lost the connection.\n");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_REMOTE_NEW_INCOMING_CONNECTION:
             logger.Debug("Another client has connected.\n");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_CONNECTION_REQUEST_ACCEPTED:
             logger.Debug("Our connection request has been accepted.");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_NEW_INCOMING_CONNECTION:
             logger.Debug("A connection is incoming.\n");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_NO_FREE_INCOMING_CONNECTIONS:
             logger.Debug("The server is full.\n");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_DISCONNECTION_NOTIFICATION:
             logger.Debug("A client has disconnected.\n");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_CONNECTION_LOST:
             logger.Debug("A client lost the connection.\n");
             CallRakNetEventHandler((RakNetMessageId)packetIdentifier);
             break;
         case RakNetBindings.ID_DATABASE_UNKNOWN_TABLE:
             logger.Debug("ID_DATABASE_UNKNOWN_TABLE\n");
             break;
         case RakNetBindings.ID_DATABASE_INCORRECT_PASSWORD:
             logger.Debug("ID_DATABASE_INCORRECT_PASSWORD\n");
             break;
         case RakNetBindings.ID_DATABASE_QUERY_REPLY:
             logger.Debug("ID_DATABASE_QUERY_REPLY\n");
             break;
         default:
             logger.Debug("Message with identifier {0} has arrived.", packetIdentifier);
             break;
     }
 }

        public void DeserializeDefault(BitStream bs)
        {
            bool success;

            bool isDefault;
            success = bs.Read(out isDefault);
            Debug.Assert(success, "Failed to read synced class defaultness");

            if (!isDefault)
            {
                foreach (var mySyncedObject in m_syncedClass)
                {
                    mySyncedObject.DeserializeDefault(bs);
                }

                foreach (var mySynced in m_syncedVariables)
                {
                    mySynced.DeserializeDefault(bs);
                }
            }
        }

        internal void DeserializeStateData(BitStream bs)
        {
            bool success;
            int count;

            success = bs.Read(out count);
            Debug.Assert(success, "Failed to read state count");

            for (int i = 0; i < count; i++)
            {
                ProcessReplication(bs);
            }
        }

        internal void ReplicationDestroy(BitStream bs)
        {
            bool success;

            long tmpLong;
            success = bs.Read(out tmpLong);
            Debug.Assert(success, "Failed to read entityID");
            ulong entityID = (ulong)tmpLong;

            m_stateData.Remove(entityID);

            var handle = OnEntityDestroyed;
            if (handle != null)
            {
                handle(entityID);
            }
        }

        internal void ProcessSync(BitStream bs)
        {
            long tmpLong;
            bool success = bs.Read(out tmpLong);
            Debug.Assert(success, "Failed to read entityID");
            ulong entityID = (ulong)tmpLong;

            MySyncedClass mySyncedObject = GetEntitySyncFields(entityID);
            if (mySyncedObject != null)
            {
                mySyncedObject.Deserialize(bs);
            }
        }

        public override bool ReadConnectRequest(BitStream stream, ref String errorString)
        {
            if (!base.ReadConnectRequest(stream, ref errorString))
                return false;

            var tInterface = Interface as TNLInterface;
            if (tInterface == null)
                return false;

            Int32 version;
            if (!stream.Read(out version) || version != tInterface.Version)
            {
                errorString = "Incorrect Version";
                return false;
            }

            if (!stream.Read(out _key))
            {
                errorString = "Unknown Key";
                return false;
            }

            if (!stream.Read(out _playerCOID))
            {
                errorString = "Unknown player ID";
                return false;
            }

            return true;
        }