C# StreamHandler.WriteByte方法代码示例

        public override void Save(StreamHandler writer)
        {
            writer.WriteByte((byte)ContainerSlot);
            writer.WriteByte((byte)Slot);
            writer.WriteByte(CastId);
            writer.WriteUInt32(SpellId);
            writer.WriteGuid(ItemGuid);
            writer.WriteUInt32(GlyphSlot);
            writer.WriteByte(UnkFlags);

            TargetData.Write(writer);
        }

        public override void Save(StreamHandler writer)
        {
            writer.WriteUInt32((uint)Roles);

            writer.WriteUInt16(0);

            writer.WriteByte((byte)Dungeons.Length);
            foreach (var entry in Dungeons)
                writer.WriteUInt32(entry.Entry);

            writer.WriteByte(3);
            writer.WriteUInt16(0);
            writer.WriteByte(0);

            writer.WriteCString(Comment);
        }

 public override void Save(StreamHandler writer)
 {
     writer.WriteGuid(Entity);
     writer.WriteUInt32(Model);
     writer.WriteByte((byte)Race);
     writer.WriteByte((byte)Gender);
     writer.WriteByte((byte)Class);
     writer.WriteByte(Skin);
     writer.WriteByte(Face);
     writer.WriteByte(Hair);
     writer.WriteByte(HairColor);
     writer.WriteByte(FaceFeatures);
     writer.WriteGuid(Guild);
     writer.WriteUInt32(Head);
     writer.WriteUInt32(Shoulders);
     writer.WriteUInt32(Body);
     writer.WriteUInt32(Chest);
     writer.WriteUInt32(Waist);
     writer.WriteUInt32(Legs);
     writer.WriteUInt32(Feet);
     writer.WriteUInt32(Wrists);
     writer.WriteUInt32(Hands);
     writer.WriteUInt32(Back);
     writer.WriteUInt32(Tabard);
 }

 protected void WriteByteSeq(StreamHandler writer, byte b)
 {
     writer.FlushUnalignedBits();
     if (b != 0)
         writer.WriteByte((byte)(b ^ 1));
 }

        public override void Save(StreamHandler Writer)
        {
            Writer.WritePackedGuid(Caster);
            Writer.WritePackedGuid(CastInvoker);
            Writer.WriteByte(CastId);
            Writer.WriteUInt32(SpellId);
            Writer.WriteUInt32((uint)Flags);
            Writer.WriteUInt32(Unk43);
            Writer.WriteUInt32(Unk43_2);

            TargetData.Write(Writer);

            if ((Flags & CastFlags.PredictedPower) != 0)
                Writer.WriteUInt32(PredictedPower);

            if ((Flags & CastFlags.RuneStates) != 0)
            {
                Writer.WriteByte((byte)RunesBefore);
                Writer.WriteByte((byte)RunesAfter);
                for (int i = 0; i < RuneCooldowns.Length; ++i)
                    Writer.WriteByte((byte)RuneCooldowns[i]);
            }

            if ((Flags & CastFlags.Ammo) != 0)
            {
                Writer.WriteUInt32(ProjectileDisplayId);
                Writer.WriteUInt32((uint)ProjectileInventoryType);
            }

            if ((Flags & CastFlags.Unk0x04000000) != 0)
            {
                Writer.WriteUInt32(Unk0x04000000_UInt32_1);
                Writer.WriteUInt32(Unk0x04000000_UInt32_2);
            }
        }

 public void Write(StreamHandler Writer)
 {
     Writer.WriteGuid(TargetGuid);
     Writer.WriteByte((byte)MissCondition);
     if (MissCondition == CastMissReason.Reflect)
         Writer.WriteByte(ReflectResult);
 }

        /// <summary>
        /// Saves the current ChatMessage to a stream using a StreamHandler.
        /// </summary>
        /// <param name="Writer">
        /// Instance of StreamHandler used to save the current ChatMessage to a stream.
        /// </param>
        public override void Save(StreamHandler Writer)
        {
            Writer.WriteByte((byte)m_type);
            Writer.WriteUInt32((uint)m_language);
            Writer.WriteGuid(m_senderGUID);
            Writer.WriteUInt32(m_unknownUInt32);

            switch (m_type)
            {
                case ChatMessageType.MonsterSay:
                case ChatMessageType.MonsterParty:
                case ChatMessageType.MonsterYell:
                case ChatMessageType.MonsterWhisper:
                case ChatMessageType.MonsterEmote:
                case ChatMessageType.RaidBossEmote:
                case ChatMessageType.RaidBossWhisper:
                case ChatMessageType.BattleNet:
                    Writer.WriteChatString(m_senderName ?? "<sender>");
                    Writer.WriteGuid(m_targetGUID);
                    if (!m_targetGUID.IsEmpty
                        && !m_targetGUID.IsPlayer
                        && !m_targetGUID.IsPet)
                    {
                        Writer.WriteChatString(m_targetName ?? "<target>");
                    }
                    if (m_language == Language.Addon)
                        Writer.WriteCString(m_addonPrefix ?? "<prefix>");
                    Writer.WriteChatString(m_text ?? "<text>");
                    Writer.WriteByte((byte)m_flags);
                    if (m_type == ChatMessageType.RaidBossEmote || m_type == ChatMessageType.RaidBossWhisper)
                    {
                        Writer.WriteSingle(m_displayTime);
                        Writer.WriteBoolean(m_suspendEvent);
                    }
                    break;
                case ChatMessageType.BGSystemNeutral:
                case ChatMessageType.BGSystemAlliance:
                case ChatMessageType.BGSystemHorde:
                    Writer.WriteGuid(m_targetGUID);
                    if (!m_targetGUID.IsEmpty
                        && !m_targetGUID.IsPlayer)
                    {
                        Writer.WriteChatString(m_targetName);
                    }
                    if (m_language == Language.Addon)
                        Writer.WriteCString(m_addonPrefix ?? "<prefix>");
                    Writer.WriteChatString(m_text ?? "<text>");
                    Writer.WriteByte((byte)m_flags);
                    break;
                case ChatMessageType.Achievement:
                case ChatMessageType.GuildAchievement:
                    Writer.WriteGuid(m_targetGUID);
                    if (m_language == Language.Addon)
                        Writer.WriteCString(m_addonPrefix ?? "<prefix>");
                    Writer.WriteChatString(m_text ?? "<text>");
                    Writer.WriteByte((byte)m_flags);
                    Writer.WriteUInt32(m_achievementId);
                    break;
                case ChatMessageType.WhisperForeign:
                    Writer.WriteChatString(m_senderName ?? "<sender>");
                    Writer.WriteGuid(m_targetGUID);
                    if (m_language == Language.Addon)
                        Writer.WriteCString(m_addonPrefix ?? "<prefix>");
                    Writer.WriteChatString(m_text ?? "<text>");
                    Writer.WriteByte((byte)m_flags);
                    break;
                default:
                    if (GameMasterMessage)
                        Writer.WriteChatString(m_senderName ?? "<sender>");
                    if (m_type == ChatMessageType.Channel)
                        Writer.WriteCString(m_channel ?? "<channel>");
                    Writer.WriteGuid(m_targetGUID);
                    if (m_language == Language.Addon)
                        Writer.WriteCString(m_addonPrefix ?? "<prefix>");
                    Writer.WriteChatString(m_text ?? "<text>");
                    Writer.WriteByte((byte)m_flags);
                    break;
            }
        }

        private void WriteValues(StreamHandler Writer, UpdateFields values, ObjectTypeId type)
        {
            uint nValueUpdates = UpdateFields.GetCount(type, values.Last().Key);
            byte nBlocks = (byte)((nValueUpdates + 31) / 32);
            BitArray mask = new BitArray(nBlocks * 32);

            foreach (int key in values.Keys)
                mask[key] = true;

            // Write block count
            Writer.WriteByte(nBlocks);

            // Write all blocks
            int index = 0;
            for (byte i = 0; i < nBlocks; ++i)
            {
                uint block = 0;
                uint bit = 1;

                for (int j = 0; j < 32; ++j)
                {
                    if (mask[index])
                        block |= bit;

                    ++index;
                    bit <<= 1;
                }

                Writer.WriteUInt32(block);
            }

            // Write all values
            foreach (uint value in values.Values)
                Writer.WriteUInt32(value);
        }

        public override void Save(StreamHandler Writer)
        {
            Writer.WriteUInt16((ushort)this.Map);

            EnsureRead();

            long nUpdatesPos = Writer.BaseStream.Position;
            uint nUpdates = 0;
            Writer.WriteUInt32(nUpdates);

            if (this.DestroyedObjects.Count > 0)
            {
                ++nUpdates;
                Writer.WriteByte((byte)UpdateTypes.DestroyObjects);

                Writer.WriteInt32(this.DestroyedObjects.Count);
                foreach (WowGuid guid in this.DestroyedObjects)
                    Writer.WritePackedGuid(guid);
            }

            foreach (var pair in this.ValuesUpdates)
            {
                ++nUpdates;
                Writer.WriteByte((byte)UpdateTypes.UpdateValues);

                Writer.WritePackedGuid(pair.Key);
                WriteValues(Writer, pair.Value, WowObject.GetTypeId(pair.Key.Type));
            }

            foreach (var pair in this.CreatedObjects)
            {
                ++nUpdates;
                var type = UpdateTypes.CreateObjects;

                var obj = pair.Value;

                if (obj.MovementData.HavePosition)
                {
                    if (obj.TypeId == ObjectTypeId.DynamicObject
                        || obj.TypeId == ObjectTypeId.Corpse
                        || obj.TypeId == ObjectTypeId.Player)
                    {
                        type = UpdateTypes.CreateObjects2;
                    }

                    if (obj.TypeId == ObjectTypeId.GameObject && obj is WowGameObject)
                    {
                        switch ((obj as WowGameObject).GameObjectType)
                        {
                            case GameObjectTypes.Trap:
                            case GameObjectTypes.DuelArbiter:
                            case GameObjectTypes.FlagStand:
                            case GameObjectTypes.FlagDrop:
                                type = UpdateTypes.CreateObjects2;
                                break;
                        }
                    }
                }

                var guid = obj.Guid;

                Writer.WriteByte((byte)type);
                Writer.WritePackedGuid(guid);
                Writer.WriteByte((byte)obj.TypeId);
                obj.MovementData.Save(Writer);
                WriteValues(Writer, obj.GetValues(), obj.TypeId);
            }

            long pos = Writer.BaseStream.Position;
            Writer.BaseStream.Position = nUpdatesPos;
            Writer.WriteUInt32(nUpdates);
            Writer.BaseStream.Position = pos;
        }

        public sealed override void Save(StreamHandler writer)
        {
            var seq_b = ByteSequence;
            var seq_m = MaskSequence;
            var b_xor = ByteXorValue;

            int size = seq_m.Count(x => x >= 0);
            if (size != seq_m.Length && this.IsMaskSequenceSwapped)
                throw new InvalidOperationException("Cannot have elements in swapped MaskSequence.");
            CheckSequences(seq_b, seq_m);

            if (this.IsMaskSequenceSwapped)
            {
                var seq_m_copy = new int[seq_m.Length];
                for (int i = 0; i < seq_m.Length; )
                {
                    var t = i;
                    for (int j = t + 8 - 1; j >= t; --j, ++i)
                        seq_m_copy[j] = seq_m[i];
                }
                seq_m = seq_m_copy;
            }

            byte[] data = new byte[size];
            PackedSave(data);

            var mask = new BitArray(size);

            for (int i = 0; i < size; ++i)
            {
                var el = seq_m[i];
                if (el < 0)
                    ElementWrite(writer, el);
                else
                    writer.UnalignedWriteBit(data[el] != 0);
            }

            writer.FlushUnalignedBits();

            for (int i = 0; i < seq_b.Length; ++i)
            {
                var el = seq_b[i];

                if (el < 0)
                    ElementWrite(writer, el);
                else if (data[el] != 0)
                    writer.WriteByte((byte)(data[el] ^ b_xor));
            }
        }

        public void Save(StreamHandler writer)
        {
            writer
                .WriteByte(this.Slot)
                .WriteUInt32(this.Spell);

            if (this.Spell != 0)
            {
                writer
                    .WriteUInt16((ushort)this.Flags)
                    .WriteByte(this.Level)
                    .WriteByte(this.Charges);

                if ((Flags & AuraFlags.NotCaster) == 0)
                    writer.WritePackedGuid(this.Caster);

                if ((Flags & AuraFlags.Duration) != 0)
                {
                    writer.WriteUInt32(this.MaxDuration);
                    writer.WriteUInt32(this.LeftDuration);
                }

                if ((Flags & AuraFlags.BasePoints) != 0)
                {
                    for (int i = 0; i < MaxEffects; ++i)
                    {
                        if ((Flags & (AuraFlags)(1 << i)) != 0)
                            writer.WriteInt32(BasePoints[i]);
                    }
                }
            }
        }