C# Plasma.hsStream类代码示例

 public static void WriteRGBA(hsStream s, Color c)
 {
     s.WriteFloat(Convert.ToSingle(c.R) / 255.0f);
     s.WriteFloat(Convert.ToSingle(c.G) / 255.0f);
     s.WriteFloat(Convert.ToSingle(c.B) / 255.0f);
     s.WriteFloat(Convert.ToSingle(c.A) / 255.0f);
 }

        public override void Read(hsStream s, hsResMgr mgr)
        {
            base.Read(s, mgr);

            fSecsRunning = s.ReadDouble();
            fSession = (SessionTypes)s.ReadByte();
        }

 public static void WriteRGBA8(hsStream s, Color c)
 {
     s.WriteByte(c.R);
     s.WriteByte(c.G);
     s.WriteByte(c.B);
     s.WriteByte(c.A);
 }

        public override void Write(hsStream s, hsResMgr mgr)
        {
            base.Write(s, mgr);

            s.WriteDouble(fSecsRunning);
            s.WriteByte((byte)fSession);
        }

        /// <summary>
        /// Reads in a NetCliConnect message from the stream
        /// </summary>
        /// <param name="s">Stream to read the message from</param>
        /// <returns>Connection YData (an array of 64 bytes) or NULL if the message is malformed</returns>
        protected byte[] IReadNetCliConnect(hsStream s)
        {
            byte[] y_data = null;
            try {
                if (s.ReadByte() != plNetCore.kNetCliConnect) return null;
                int size = (int)s.ReadByte() - 2;
                y_data = s.ReadBytes(size);
            } catch (Exception e) {
            #if DEBUG
                throw e;
            #else
                return null;
            #endif
            }

            // Truncate the YData if it's too large
            if (y_data.Length > 64) {
                byte[] old = y_data;
                y_data = new byte[64];
                Buffer.BlockCopy(old, 0, y_data, 0, 64);
            }

            // The client sends us the YData in Little Endian, but
            // BigNum wants Big Endian (because OpenSSL). Let's fix that.
            Array.Reverse(y_data);

            return y_data;
        }

        public override void Write(hsStream s, hsResMgr mgr)
        {
            base.Write(s, mgr);

            s.WriteInt((int)fCommand);
            s.WriteStdString(fString);
        }

 public void Read(hsStream s)
 {
     fX = s.ReadFloat();
     fY = s.ReadFloat();
     fZ = s.ReadFloat();
     fW = s.ReadFloat();
 }

        public override void Read(hsStream s, hsResMgr mgr)
        {
            base.Read(s, mgr);

            fCommand = (Cmd)s.ReadInt();
            fString = s.ReadStdString();
        }

        public override void Read(hsStream s, hsResMgr mgr)
        {
            base.Read(s, mgr);

            fSynchFlags = (Flags)s.ReadInt();
            if (s.Version.IsPlasma21)
                fSynchFlags &= (Flags)~0x8;

            if (s.Version.IsPlasma21 && (((int)fSynchFlags & 0x06) != 0) ||
               (s.Version.IsPlasma20 && ExcludeStates)) {
                short count = s.ReadShort();
                for (short i = 0; i < count; i++)
                    fExcludeStates.Add((States)Enum.Parse(typeof(States), s.ReadStdString()));
            }

            //Plasma 2.1+ ends here...
            if (s.Version.IsPlasma21) {
                fSynchFlags = 0; // Synch Flags are pretty useless in Plasma21
                return;
            } else if (s.Version.IsPlasma20) {
                if (VolatileStates) {
                    short count = s.ReadShort();
                    for (short i = 0; i < count; i++)
                        fVolatileStates.Add((States)Enum.Parse(typeof(States), s.ReadStdString()));
                }
            }
        }

        /// <summary>
        /// Reads a key reference from the stream
        /// </summary>
        /// <param name="s">Stream containing a key reference</param>
        /// <returns>The key referenced in the stream or null (if null reference)</returns>
        public plKey ReadKey(hsStream s)
        {
            if (!s.Version.IsPlasma21)
                if (!s.ReadBool()) return null;

            return ReadUoid(s);
        }

 public void Write(hsStream s)
 {
     s.WriteFloat(fX);
     s.WriteFloat(fY);
     s.WriteFloat(fZ);
     s.WriteFloat(fW);
 }

 /// <summary>
 /// Reads an arbitrary Creatable from the current position in the stream
 /// </summary>
 /// <param name="s">Stream to read from</param>
 /// <returns></returns>
 public plCreatable ReadCreatable(hsStream s)
 {
     plCreatable pCre = plFactory.Create(plManagedType.Read(s));
     if (pCre != null)
         pCre.Read(s, this);
     return pCre;
 }

 public override void Write(hsStream s, hsResMgr mgr)
 {
     if (s.Version.IsMystOnline)
         mgr.WriteKey(s, fpKey);
     else
         mgr.WriteUoid(s, fpKey);
 }

 public override void Write(hsStream s)
 {
     s.WriteUInt(fTransID);
     pnHelpers.WriteString(s, fAccount, 64);
     s.WriteBytes(fHash);
     s.WriteUInt(fSrvChg);
     s.WriteUInt(fCliChg);
 }

        public override void Write(hsStream s, hsResMgr mgr)
        {
            base.Write(s, mgr);

            s.WriteBool(fDeliveryTime.HasValue);
            if (fDeliveryTime.HasValue)
                plUnifiedTime.Write(s, fDeliveryTime.Value);
        }