Пример #1
0
        public void TestMobileUpdateOld()
        {
            var m = new Mobile(0x1);

            m.DefaultMobileInit();

            var data = new MobileUpdate(m, false).Compile();

            Span <byte> expectedData = stackalloc byte[19];
            var         pos          = 0;

            var hue = m.SolidHueOverride >= 0 ? m.SolidHueOverride : m.Hue;

            expectedData.Write(ref pos, (byte)0x20); // Packet ID
            expectedData.Write(ref pos, m.Serial);
            expectedData.Write(ref pos, (ushort)m.Body);
#if NO_LOCAL_INIT
            expectedData.Write(ref pos, (byte)0); // Unknown
#else
            pos++;
#endif
            expectedData.Write(ref pos, (ushort)hue);
            expectedData.Write(ref pos, (byte)m.GetPacketFlags(false));
            expectedData.Write(ref pos, (ushort)m.X);
            expectedData.Write(ref pos, (ushort)m.Y);
#if NO_LOCAL_INIT
            expectedData.Write(ref pos, (ushort)2); // Unknown
#else
            pos += 2;
#endif
            expectedData.Write(ref pos, (byte)m.Direction);
            expectedData.Write(ref pos, (byte)m.Z);

            AssertThat.Equal(data, expectedData);
        }
Пример #2
0
        public static GenericPacket MobileMoving(Mobile m, int noto)
        {
            var p = GenericPacket.Instantiate(0x77, 17);

            var loc = m.Location;

            var hue = m.Hue;

            if (m.SolidHueOverride >= 0)
            {
                hue = m.SolidHueOverride;
            }

            p.Stream.Write((int)m.Serial);
            p.Stream.Write((short)((int)m.Body));
            p.Stream.Write((short)loc.X);
            p.Stream.Write((short)loc.Y);
            p.Stream.Write((sbyte)loc.Z);
            p.Stream.Write((byte)m.Direction);
            p.Stream.Write((short)hue);
            p.Stream.Write((byte)m.GetPacketFlags());
            p.Stream.Write((byte)noto);

            return(p);
        }
        public MobileIncoming(Mobile beholder, Mobile beheld) : base(120)
        {
            int  num3;
            Item item1;
            byte num4;
            int  num5;
            bool flag1;

            this.m_Beheld = beheld;
            ++MobileIncoming.m_Version;
            ArrayList list1 = beheld.Items;
            int       num1  = list1.Count;

            base.EnsureCapacity((23 + (num1 * 9)));
            int num2 = beheld.Hue;

            if (beheld.SolidHueOverride >= 0)
            {
                num2 = beheld.SolidHueOverride;
            }
            this.m_Stream.Write(Serial.op_Implicit(beheld.Serial));
            this.m_Stream.Write(((short)Body.op_Implicit(beheld.Body)));
            this.m_Stream.Write(((short)beheld.X));
            this.m_Stream.Write(((short)beheld.Y));
            this.m_Stream.Write(((sbyte)beheld.Z));
            this.m_Stream.Write(((byte)beheld.Direction));
            this.m_Stream.Write(((short)num2));
            this.m_Stream.Write(((byte)beheld.GetPacketFlags()));
            this.m_Stream.Write(((byte)Notoriety.Compute(beholder, beheld)));
            for (num3 = 0; (num3 < num1); ++num3)
            {
                item1 = ((Item)list1[num3]);
                num4  = ((byte)item1.Layer);
                if ((!item1.Deleted && beholder.CanSee(item1)) && (MobileIncoming.m_DupedLayers[num4] != MobileIncoming.m_Version))
                {
                    MobileIncoming.m_DupedLayers[num4] = MobileIncoming.m_Version;
                    num2 = item1.Hue;
                    if (beheld.SolidHueOverride >= 0)
                    {
                        num2 = beheld.SolidHueOverride;
                    }
                    num5  = (item1.ItemID & 16383);
                    flag1 = (num2 != 0);
                    if (flag1)
                    {
                        num5 |= 32768;
                    }
                    this.m_Stream.Write(Serial.op_Implicit(item1.Serial));
                    this.m_Stream.Write(((short)num5));
                    this.m_Stream.Write(num4);
                    if (flag1)
                    {
                        this.m_Stream.Write(((short)num2));
                    }
                }
            }
            this.m_Stream.Write(0);
        }
Пример #4
0
 // Methods
 public UnkD3(Mobile beholder, Mobile beheld) : base(211)
 {
     base.EnsureCapacity(256);
     this.m_Stream.Write(Serial.op_Implicit(beheld.Serial));
     this.m_Stream.Write(((short)Body.op_Implicit(beheld.Body)));
     this.m_Stream.Write(((short)beheld.X));
     this.m_Stream.Write(((short)beheld.Y));
     this.m_Stream.Write(((sbyte)beheld.Z));
     this.m_Stream.Write(((byte)beheld.Direction));
     this.m_Stream.Write(((ushort)beheld.Hue));
     this.m_Stream.Write(((byte)beheld.GetPacketFlags()));
     this.m_Stream.Write(((byte)Notoriety.Compute(beholder, beheld)));
     this.m_Stream.Write(((short)0));
     this.m_Stream.Write(((short)0));
     this.m_Stream.Write(((short)0));
     this.m_Stream.Write(0);
 }
Пример #5
0
        public static void CreateMobileMoving(Span <byte> buffer, Mobile m, int noto, bool stygianAbyss)
        {
            var loc = m.Location;
            var hue = m.SolidHueOverride >= 0 ? m.SolidHueOverride : m.Hue;

            var writer = new SpanWriter(buffer);

            writer.Write((byte)0x77); // Packet ID
            writer.Write(m.Serial);
            writer.Write((short)m.Body);
            writer.Write((short)loc.m_X);
            writer.Write((short)loc.m_Y);
            writer.Write((sbyte)loc.m_Z);
            writer.Write((byte)m.Direction);
            writer.Write((short)hue);
            writer.Write((byte)m.GetPacketFlags(stygianAbyss));
            writer.Write((byte)noto);
        }
Пример #6
0
        // Methods
        public MobileUpdate(Mobile m) : base(32, 19)
        {
            int num1 = m.Hue;

            if (m.SolidHueOverride >= 0)
            {
                num1 = m.SolidHueOverride;
            }
            this.m_Stream.Write(Serial.op_Implicit(m.Serial));
            this.m_Stream.Write(((short)Body.op_Implicit(m.Body)));
            this.m_Stream.Write(((byte)0));
            this.m_Stream.Write(((short)num1));
            this.m_Stream.Write(((byte)m.GetPacketFlags()));
            this.m_Stream.Write(((short)m.X));
            this.m_Stream.Write(((short)m.Y));
            this.m_Stream.Write(((short)0));
            this.m_Stream.Write(((byte)m.Direction));
            this.m_Stream.Write(((sbyte)m.Z));
        }
Пример #7
0
        // Methods
        public MobileMoving(Mobile m, int noto) : base(119, 17)
        {
            Point3D pointd1 = m.Location;
            int     num1    = m.Hue;

            if (m.SolidHueOverride >= 0)
            {
                num1 = m.SolidHueOverride;
            }
            this.m_Stream.Write(Serial.op_Implicit(m.Serial));
            this.m_Stream.Write(((short)Body.op_Implicit(m.Body)));
            this.m_Stream.Write(((short)pointd1.m_X));
            this.m_Stream.Write(((short)pointd1.m_Y));
            this.m_Stream.Write(((sbyte)pointd1.m_Z));
            this.m_Stream.Write(((byte)m.Direction));
            this.m_Stream.Write(((short)num1));
            this.m_Stream.Write(((byte)m.GetPacketFlags()));
            this.m_Stream.Write(((byte)noto));
        }
Пример #8
0
        public MobileUpdate(Mobile m, bool stygianAbyss) : base(0x20, 19)
        {
            var hue = m.Hue;

            if (m.SolidHueOverride >= 0)
            {
                hue = m.SolidHueOverride;
            }

            Stream.Write(m.Serial);
            Stream.Write((short)m.Body);
            Stream.Write((byte)0);
            Stream.Write((short)hue);
            Stream.Write((byte)m.GetPacketFlags(stygianAbyss));
            Stream.Write((short)m.X);
            Stream.Write((short)m.Y);
            Stream.Write((short)0);
            Stream.Write((byte)m.Direction);
            Stream.Write((sbyte)m.Z);
        }
Пример #9
0
        public MobileMoving(Mobile m, int noto, bool stygianAbyss) : base(0x77, 17)
        {
            var loc = m.Location;

            var hue = m.Hue;

            if (m.SolidHueOverride >= 0)
            {
                hue = m.SolidHueOverride;
            }

            Stream.Write(m.Serial);
            Stream.Write((short)m.Body);
            Stream.Write((short)loc.X);
            Stream.Write((short)loc.Y);
            Stream.Write((sbyte)loc.Z);
            Stream.Write((byte)m.Direction);
            Stream.Write((short)hue);
            Stream.Write((byte)m.GetPacketFlags(stygianAbyss));
            Stream.Write((byte)noto);
        }
Пример #10
0
        public static GenericPacket MobileMoving( Mobile m, int noto )
        {
            GenericPacket p = GenericPacket.Instantiate( 0x77, 17 );

            Point3D loc = m.Location;

            int hue = m.Hue;

            if ( m.SolidHueOverride >= 0 )
                hue = m.SolidHueOverride;

            p.Stream.Write( (int) m.Serial );
            p.Stream.Write( (short) ( (int) m.Body ) );
            p.Stream.Write( (short) loc.X );
            p.Stream.Write( (short) loc.Y );
            p.Stream.Write( (sbyte) loc.Z );
            p.Stream.Write( (byte) m.Direction );
            p.Stream.Write( (short) hue );
            p.Stream.Write( (byte) m.GetPacketFlags() );
            p.Stream.Write( (byte) noto );

            return p;
        }
Пример #11
0
        public void TestMobileMovingOld()
        {
            var m = new Mobile(0x1);

            m.DefaultMobileInit();

            var noto = 10;

            var data = new MobileMoving(m, noto, false).Compile();

            Span <byte> expectedData = stackalloc byte[17];
            var         pos          = 0;

            expectedData.Write(ref pos, (byte)0x77); // Packet ID
            expectedData.Write(ref pos, m.Serial);
            expectedData.Write(ref pos, (ushort)m.Body);
            expectedData.Write(ref pos, m.Location);
            expectedData.Write(ref pos, (byte)m.Direction);
            expectedData.Write(ref pos, (ushort)m.Hue);
            expectedData.Write(ref pos, (byte)m.GetPacketFlags(false));
            expectedData.Write(ref pos, (byte)noto);

            AssertThat.Equal(data, expectedData);
        }
Пример #12
0
        public void TestMobileIncoming(
            ProtocolChanges protocolChanges, int hairItemId, int hairHue, int facialHairItemId, int facialHairHue
            )
        {
            var beholder = new Mobile(0x1)
            {
                Name = "Random Mobile 1"
            };

            beholder.DefaultMobileInit();

            var beheld = new Mobile(0x2)
            {
                Name = "Random Mobile 2"
            };

            beheld.DefaultMobileInit();
            beheld.AddItem(
                new Item((Serial)0x1000)
            {
                Layer = Layer.OneHanded
            }
                );

            // Test Dupe
            beheld.AddItem(
                new Item((Serial)0x1001)
            {
                Layer = Layer.OneHanded
            }
                );

            beheld.HairItemID       = hairItemId;
            beheld.HairHue          = hairHue;
            beheld.FacialHairItemID = facialHairItemId;
            beheld.FacialHairHue    = facialHairHue;

            var ns = new NetState(null)
            {
                ProtocolChanges = protocolChanges
            };

            var data = new MobileIncoming(ns, beholder, beheld).Compile();

            var sa         = ns.StygianAbyss;
            var newPacket  = ns.NewMobileIncoming;
            var itemIdMask = newPacket ? 0xFFFF : 0x7FFF;

            Span <bool> layers = stackalloc bool[256];

#if NO_LOCAL_INIT
            layers.Clear();
#endif

            var items = beheld.Items;
            var count = items.Count;

            if (beheld.HairItemID > 0)
            {
                count++;
            }

            if (beheld.FacialHairItemID > 0)
            {
                count++;
            }

            var length = 23 + count * 9; // Max Size

            Span <byte> expectedData = stackalloc byte[length];
            var         pos          = 0;

            expectedData.Write(ref pos, (byte)0x78);
            pos += 2; // Length

            var isSolidHue = beheld.SolidHueOverride >= 0;

            expectedData.Write(ref pos, beheld.Serial);
            expectedData.Write(ref pos, (ushort)beheld.Body);
            expectedData.Write(ref pos, (ushort)beheld.X);
            expectedData.Write(ref pos, (ushort)beheld.Y);
            expectedData.Write(ref pos, (byte)beheld.Z);
            expectedData.Write(ref pos, (byte)beheld.Direction);
            expectedData.Write(ref pos, (ushort)(isSolidHue ? beheld.SolidHueOverride : beheld.Hue));
            expectedData.Write(ref pos, (byte)beheld.GetPacketFlags(sa));
            expectedData.Write(ref pos, (byte)Notoriety.Compute(beholder, beheld));

            byte layer;

            for (var i = 0; i < items.Count; i++)
            {
                var item = items[i];

                layer = (byte)item.Layer;

                if (!item.Deleted && !layers[layer] && beholder.CanSee(item))
                {
                    layers[layer] = true;

                    expectedData.Write(ref pos, item.Serial);

                    var hue      = isSolidHue ? beheld.SolidHueOverride : item.Hue;
                    var itemID   = item.ItemID & itemIdMask;
                    var writeHue = newPacket || hue != 0;

                    if (!newPacket)
                    {
                        itemID |= 0x8000;
                    }

                    expectedData.Write(ref pos, (ushort)itemID);
                    expectedData.Write(ref pos, layer);
                    if (writeHue)
                    {
                        expectedData.Write(ref pos, (ushort)hue);
                    }
                }
            }

            layer = (byte)Layer.Hair;
            var itemId = beheld.HairItemID;

            if (itemId > 0 && !layers[layer])
            {
                expectedData.Write(ref pos, HairInfo.FakeSerial(beheld));
                var hue = isSolidHue ? beheld.SolidHueOverride : beheld.HairHue;
                itemId &= itemIdMask;
                var writeHue = newPacket || hue != 0;

                if (!newPacket)
                {
                    itemId |= 0x8000;
                }

                expectedData.Write(ref pos, (ushort)itemId);
                expectedData.Write(ref pos, layer);
                if (writeHue)
                {
                    expectedData.Write(ref pos, (ushort)hue);
                }
            }

            layer  = (byte)Layer.FacialHair;
            itemId = beheld.FacialHairItemID;

            if (itemId > 0 && !layers[layer])
            {
                expectedData.Write(ref pos, FacialHairInfo.FakeSerial(beheld));
                var hue = isSolidHue ? beheld.SolidHueOverride : beheld.FacialHairHue;
                itemId &= itemIdMask;
                var writeHue = newPacket || hue != 0;

                if (!newPacket)
                {
                    itemId |= 0x8000;
                }

                expectedData.Write(ref pos, (ushort)itemId);
                expectedData.Write(ref pos, layer);
                if (writeHue)
                {
                    expectedData.Write(ref pos, (ushort)hue);
                }
            }

#if NO_LOCAL_INIT
            expectedData.Write(ref pos, 0); // Zero serial, terminate list
#else
            pos += 4;
#endif

            expectedData.Slice(1, 2).Write((ushort)pos); // Length
            expectedData = expectedData.Slice(0, pos);

            AssertThat.Equal(data, expectedData);
        }
Пример #13
0
		public MobileMoving( Mobile m, int noto, Mobile receiver ) : base( 0x77, 17 )
		{
			Point3D loc = m.Location;

			//int hue = m.Hue;
            int hue = receiver.GetHue(m);   // Scriptiz : hallucinations

			if ( m.SolidHueOverride >= 0 )
				hue = m.SolidHueOverride;

			m_Stream.Write( (int) m.Serial );
			//m_Stream.Write( (short) m.Body );
            m_Stream.Write((short)receiver.GetBody(m)); // Scriptiz : hallucinations
			m_Stream.Write( (short) loc.m_X );
			m_Stream.Write( (short) loc.m_Y );
			m_Stream.Write( (sbyte) loc.m_Z );
			m_Stream.Write( (byte) m.Direction );
			m_Stream.Write( (short) hue );
			m_Stream.Write( (byte) m.GetPacketFlags() );
			m_Stream.Write( (byte) noto );
		}
Пример #14
0
        public MobileUpdate( Mobile m )
            : base(0x20, 19)
        {
            int hue = m.Hue;

            if ( m.SolidHueOverride >= 0 )
                hue = m.SolidHueOverride;

            m_Stream.Write( (int) m.Serial );
            m_Stream.Write( (short) m.Body );
            m_Stream.Write( (byte) 0 );
            m_Stream.Write( (short) hue );
            m_Stream.Write( (byte) m.GetPacketFlags() );
            m_Stream.Write( (short) m.X );
            m_Stream.Write( (short) m.Y );
            m_Stream.Write( (short) 0 );
            m_Stream.Write( (byte) m.Direction );
            m_Stream.Write( (sbyte) m.Z );
        }
Пример #15
0
        public MobileIncoming( Mobile beholder, Mobile beheld )
            : base(0x78)
        {
            m_Beheld = beheld;
            ++m_Version;

            ArrayList eq = beheld.Items;
            int count = eq.Count;

            this.EnsureCapacity( 23 + (count * 9) );

            int hue = beheld.Hue;

            if ( beheld.SolidHueOverride >= 0 )
                hue = beheld.SolidHueOverride;

            m_Stream.Write( (int) beheld.Serial );
            m_Stream.Write( (short) beheld.Body );
            m_Stream.Write( (short) beheld.X );
            m_Stream.Write( (short) beheld.Y );
            m_Stream.Write( (sbyte) beheld.Z );
            m_Stream.Write( (byte) beheld.Direction );
            m_Stream.Write( (short) hue );
            m_Stream.Write( (byte) beheld.GetPacketFlags() );
            m_Stream.Write( (byte) Notoriety.Compute( beholder, beheld ) );

            for ( int i = 0; i < count; ++i )
            {
                Item item = (Item)eq[i];

                byte layer = (byte) item.Layer;

                if ( !item.Deleted && beholder.CanSee( item ) && m_DupedLayers[layer] != m_Version )
                {
                    m_DupedLayers[layer] = m_Version;

                    hue = item.Hue;

                    if ( beheld.SolidHueOverride >= 0 )
                        hue = beheld.SolidHueOverride;

                    int itemID = item.ItemID & 0x3FFF;
                    bool writeHue = ( hue != 0 );

                    if ( writeHue )
                        itemID |= 0x8000;

                    m_Stream.Write( (int) item.Serial );
                    m_Stream.Write( (short) itemID );
                    m_Stream.Write( (byte) layer );

                    if ( writeHue )
                        m_Stream.Write( (short) hue );
                }
            }

            m_Stream.Write( (int) 0 ); // terminate
        }
Пример #16
0
        public WorldItemHS(Mobile mob, PacketWriter stream)
            : base(0xF3, 26, stream)
        {
            stream.Write((short)0x1);

            stream.Write((byte)0x01);
            stream.Write((int)mob.Serial);
            stream.Write((ushort)mob.BodyValue);
            stream.Write((byte)0);

            int amount = 1;
            stream.Write((short)amount);
            stream.Write((short)amount);

            Point3D loc = mob.Location;
            int x = loc.m_X & 0x7FFF;
            int y = loc.m_Y & 0x3FFF;
            stream.Write((short)x);
            stream.Write((short)y);
            stream.Write((sbyte)loc.m_Z);

            stream.Write((byte)mob.LightLevel);
            stream.Write((short)mob.Hue);
            stream.Write((byte)mob.GetPacketFlags());

            stream.Write((short)0x00); // ??
        }
Пример #17
0
		public MobileIncoming( Mobile beholder, Mobile beheld ) : base( 0x78 )
		{
			m_Beheld = beheld;
			++m_Version;

			List<Item> eq = beheld.Items;
			int count = eq.Count;

			if( beheld.HairItemID > 0 )
				count++;
			if( beheld.FacialHairItemID > 0 )
				count++;
            #region GeNova: KR Support
            bool face = false;
            if (beholder.NetState != null && (beholder.NetState.IsKRClient || beholder.NetState.IsSAClient) && beheld.FaceItemID > 0)
                face = true;
            if (face)
            {
                count++;
            }
            #endregion KR Face

			this.EnsureCapacity( 23 + (count * 9) );

			int hue = beheld.Hue;

			if ( beheld.SolidHueOverride >= 0 )
				hue = beheld.SolidHueOverride;

			m_Stream.Write( (int) beheld.Serial );
			m_Stream.Write( (short) beheld.Body );
			m_Stream.Write( (short) beheld.X );
			m_Stream.Write( (short) beheld.Y );
			m_Stream.Write( (sbyte) beheld.Z );
			m_Stream.Write( (byte) beheld.Direction );
			m_Stream.Write( (short) hue );
			m_Stream.Write( (byte) beheld.GetPacketFlags() );
			m_Stream.Write( (byte) Notoriety.Compute( beholder, beheld ) );

			for ( int i = 0; i < eq.Count; ++i )
			{
				Item item = eq[i];

				byte layer = (byte) item.Layer;

				if ( !item.Deleted && beholder.CanSee( item ) && m_DupedLayers[layer] != m_Version )
				{
					m_DupedLayers[layer] = m_Version;

					hue = item.Hue;

					if ( beheld.SolidHueOverride >= 0 )
						hue = beheld.SolidHueOverride;

					#region SA
					int itemID = item.ItemID & 0x7FFF;
					#endregion
					bool writeHue = ( hue != 0 );

					if ( writeHue )
						itemID |= 0x8000;

					m_Stream.Write( (int) item.Serial );
					m_Stream.Write( (short) itemID );
					m_Stream.Write( (byte) layer );

					if ( writeHue )
						m_Stream.Write( (short) hue );
				}
			}

			if( beheld.HairItemID > 0 )
			{
				if( m_DupedLayers[(int)Layer.Hair] != m_Version )
				{
					m_DupedLayers[(int)Layer.Hair] = m_Version;
					hue = beheld.HairHue;

					if( beheld.SolidHueOverride >= 0 )
						hue = beheld.SolidHueOverride;

					int itemID = beheld.HairItemID & 0x7FFF;

					bool writeHue = (hue != 0);

					if( writeHue )
						itemID |= 0x8000;

					m_Stream.Write( (int)HairInfo.FakeSerial( beheld ) );
					m_Stream.Write( (short)itemID );
					m_Stream.Write( (byte)Layer.Hair );

					if( writeHue )
						m_Stream.Write( (short)hue );
				}
			}

			if( beheld.FacialHairItemID > 0 )
			{
				if( m_DupedLayers[(int)Layer.FacialHair] != m_Version )
				{
					m_DupedLayers[(int)Layer.FacialHair] = m_Version;
					hue = beheld.FacialHairHue;

					if( beheld.SolidHueOverride >= 0 )
						hue = beheld.SolidHueOverride;

					#region SA
					int itemID = beheld.FacialHairItemID & 0x7FFF;
					#endregion

					bool writeHue = (hue != 0);

					if( writeHue )
						itemID |= 0x8000;

					m_Stream.Write( (int)FacialHairInfo.FakeSerial( beheld ) );
					m_Stream.Write( (short)itemID );
					m_Stream.Write( (byte)Layer.FacialHair );

					if( writeHue )
						m_Stream.Write( (short)hue );
				}
			}
            #region KR Face
            if (face)
            {
                if (m_DupedLayers[15] != m_Version)
                {
                    m_DupedLayers[15] = m_Version;
                    hue = beheld.Hue;
                    if (beheld.SolidHueOverride >= 0)
                        hue = beheld.SolidHueOverride;

                    int itemID2 = beheld.FaceItemID & 0x7FFF;
                    itemID2 |= 0x8000;

                    m_Stream.Write((int)FaceInfo.FakeSerial(beheld));
                    m_Stream.Write((short)itemID2);
                    m_Stream.Write((byte)15);
                    m_Stream.Write((short)hue);
                }
            }
            #endregion KR Face 
			m_Stream.Write( (int) 0 ); // terminate
		}
Пример #18
0
        public MobileIncomingSA(Mobile beholder, Mobile beheld) : base(0x78)
        {
            var m_Version     = ++m_VersionTL.Value;
            var m_DupedLayers = m_DupedLayersTL.Value;

            var eq    = beheld.Items;
            var count = eq.Count;

            if (beheld.HairItemID > 0)
            {
                count++;
            }
            if (beheld.FacialHairItemID > 0)
            {
                count++;
            }

            EnsureCapacity(23 + count * 9);

            var hue = beheld.Hue;

            if (beheld.SolidHueOverride >= 0)
            {
                hue = beheld.SolidHueOverride;
            }

            Stream.Write(beheld.Serial);
            Stream.Write((short)beheld.Body);
            Stream.Write((short)beheld.X);
            Stream.Write((short)beheld.Y);
            Stream.Write((sbyte)beheld.Z);
            Stream.Write((byte)beheld.Direction);
            Stream.Write((short)hue);
            Stream.Write((byte)beheld.GetPacketFlags());
            Stream.Write((byte)Notoriety.Compute(beholder, beheld));

            for (var i = 0; i < eq.Count; ++i)
            {
                var item = eq[i];

                var layer = (byte)item.Layer;

                if (!item.Deleted && beholder.CanSee(item) && m_DupedLayers[layer] != m_Version)
                {
                    m_DupedLayers[layer] = m_Version;

                    hue = item.Hue;

                    if (beheld.SolidHueOverride >= 0)
                    {
                        hue = beheld.SolidHueOverride;
                    }

                    var itemID   = item.ItemID & 0x7FFF;
                    var writeHue = hue != 0;

                    if (writeHue)
                    {
                        itemID |= 0x8000;
                    }

                    Stream.Write(item.Serial);
                    Stream.Write((ushort)itemID);
                    Stream.Write(layer);

                    if (writeHue)
                    {
                        Stream.Write((short)hue);
                    }
                }
            }

            if (beheld.HairItemID > 0)
            {
                if (m_DupedLayers[(int)Layer.Hair] != m_Version)
                {
                    m_DupedLayers[(int)Layer.Hair] = m_Version;
                    hue = beheld.HairHue;

                    if (beheld.SolidHueOverride >= 0)
                    {
                        hue = beheld.SolidHueOverride;
                    }

                    var itemID = beheld.HairItemID & 0x7FFF;

                    var writeHue = hue != 0;

                    if (writeHue)
                    {
                        itemID |= 0x8000;
                    }

                    Stream.Write(HairInfo.FakeSerial(beheld));
                    Stream.Write((ushort)itemID);
                    Stream.Write((byte)Layer.Hair);

                    if (writeHue)
                    {
                        Stream.Write((short)hue);
                    }
                }
            }

            if (beheld.FacialHairItemID > 0)
            {
                if (m_DupedLayers[(int)Layer.FacialHair] != m_Version)
                {
                    m_DupedLayers[(int)Layer.FacialHair] = m_Version;
                    hue = beheld.FacialHairHue;

                    if (beheld.SolidHueOverride >= 0)
                    {
                        hue = beheld.SolidHueOverride;
                    }

                    var itemID = beheld.FacialHairItemID & 0x7FFF;

                    var writeHue = hue != 0;

                    if (writeHue)
                    {
                        itemID |= 0x8000;
                    }

                    Stream.Write(FacialHairInfo.FakeSerial(beheld));
                    Stream.Write((ushort)itemID);
                    Stream.Write((byte)Layer.FacialHair);

                    if (writeHue)
                    {
                        Stream.Write((short)hue);
                    }
                }
            }

            Stream.Write(0); // terminate
        }
Пример #19
0
        public ContainerMultiList(Mobile beholder, BaseSmoothMulti smoothMulti)
            : base(0xF7)
        {
            if (smoothMulti != null && smoothMulti.ContainedObjects != null)
            {
                //Safety check : avoiding client stack overflow
                smoothMulti.ContainedObjects.Remove(smoothMulti);

                EnsureCapacity(3 + 2 + (smoothMulti.ContainedObjects.Count + 1) * 26);

                m_Stream.Write((short)0);                 // count placeholder

                int count = 0;

                if (beholder.CanSee(smoothMulti))
                {
                    //Display the smoothMulti
                    m_Stream.Write((byte)0xF3);
                    m_Stream.Write((short)0x1);

                    m_Stream.Write((byte)0x02);
                    m_Stream.Write((int)smoothMulti.Serial);
                    m_Stream.Write((ushort)(smoothMulti.ItemID & 0x7FFF));
                    m_Stream.Write((byte)0);

                    m_Stream.Write((short)smoothMulti.Amount);
                    m_Stream.Write((short)smoothMulti.Amount);

                    m_Stream.Write((short)(smoothMulti.X & 0x7FFF));
                    m_Stream.Write((short)(smoothMulti.Y & 0x3FFF));
                    m_Stream.Write((sbyte)smoothMulti.Z);

                    m_Stream.Write((byte)smoothMulti.Light);
                    m_Stream.Write((short)smoothMulti.Hue);
                    m_Stream.Write((byte)smoothMulti.GetPacketFlags());

                    m_Stream.Write((short)0x00);
                    ++count;

                    //Display smoothMulti components
                    smoothMulti.ContainedObjects.ForEachObject(
                        item =>
                    {
                        if (beholder.CanSee(item))
                        {
                            // Embedded WorldItemHS packets
                            m_Stream.Write((byte)0xF3);
                            m_Stream.Write((short)0x1);

                            Item i = (Item)item;

                            m_Stream.Write((byte)0x00);
                            m_Stream.Write((int)i.Serial);
                            m_Stream.Write((ushort)(i.ItemID & 0xFFFF));
                            m_Stream.Write((byte)0);

                            m_Stream.Write((short)i.Amount);
                            m_Stream.Write((short)i.Amount);

                            m_Stream.Write((short)(i.X & 0x7FFF));
                            m_Stream.Write((short)(i.Y & 0x3FFF));
                            m_Stream.Write((sbyte)i.Z);

                            m_Stream.Write((byte)i.Light);
                            m_Stream.Write((short)i.Hue);
                            m_Stream.Write((byte)i.GetPacketFlags());

                            m_Stream.Write((short)0x00);
                            ++count;
                        }
                    },
                        mob =>
                    {
                        if (beholder.CanSee(mob))
                        {
                            // Embedded WorldItemHS packets
                            m_Stream.Write((byte)0xF3);
                            m_Stream.Write((short)0x1);

                            Mobile m = (Mobile)mob;

                            m_Stream.Write((byte)0x01);
                            m_Stream.Write((int)m.Serial);
                            m_Stream.Write((short)m.Body);
                            m_Stream.Write((byte)0);

                            m_Stream.Write((short)1);
                            m_Stream.Write((short)1);

                            m_Stream.Write((short)(m.X & 0x7FFF));
                            m_Stream.Write((short)(m.Y & 0x3FFF));
                            m_Stream.Write((sbyte)m.Z);

                            m_Stream.Write((byte)m.Direction);
                            m_Stream.Write((short)m.Hue);
                            m_Stream.Write((byte)m.GetPacketFlags());

                            m_Stream.Write((short)0x00);
                            ++count;
                        }
                    });

                    m_Stream.Seek(3, System.IO.SeekOrigin.Begin);
                    m_Stream.Write((short)count);
                }
            }
        }
Пример #20
0
		private static void Write(PacketWriter m_Stream, Mobile m, int noto) {
			Point3D loc = m.Location;

			int hue = m.Hue;

			if ( m.SolidHueOverride >= 0 )
				hue = m.SolidHueOverride;

			m_Stream.Write( (int) m.Serial );
			m_Stream.Write( (short) m.Body );
			m_Stream.Write( (short) loc.m_X );
			m_Stream.Write( (short) loc.m_Y );
			m_Stream.Write( (sbyte) loc.m_Z );
			m_Stream.Write( (byte) m.Direction );
			m_Stream.Write( (short) hue );
			m_Stream.Write( (byte) m.GetPacketFlags() );
			m_Stream.Write( (byte) noto );//Notoriety.Compute( beholder, beheld ) );
		}
Пример #21
0
        public MobileIncoming(Mobile beholder, Mobile beheld)
            : base(0x78)
        {
            m_Beheld = beheld;

#if Framework_4_0
			int m_Version = ++(m_VersionTL.Value);
			int[] m_DupedLayers = m_DupedLayersTL.Value;
#else
            ++m_Version;
#endif

            List<Item> eq = beheld.Items;
            int count = eq.Count;

            if (beheld.HairItemID > 0)
                count++;
            if (beheld.FacialHairItemID > 0)
                count++;

            this.EnsureCapacity(23 + (count * 9));

            int hue = beheld.Hue;

            if (beheld.SolidHueOverride >= 0)
                hue = beheld.SolidHueOverride;

            m_Stream.Write((int)beheld.Serial);
            m_Stream.Write((short)beheld.Body);
            m_Stream.Write((short)beheld.X);
            m_Stream.Write((short)beheld.Y);
            m_Stream.Write((sbyte)beheld.Z);
            m_Stream.Write((byte)beheld.Direction);
            m_Stream.Write((short)hue);
            m_Stream.Write((byte)beheld.GetPacketFlags());
            m_Stream.Write((byte)Notoriety.Compute(beholder, beheld));

            for (int i = 0; i < eq.Count; ++i)
            {
                Item item = eq[i];

                byte layer = (byte)item.Layer;

                if (!item.Deleted && beholder.CanSee(item) && m_DupedLayers[layer] != m_Version)
                {
                    m_DupedLayers[layer] = m_Version;

                    hue = item.Hue;

                    if (beheld.SolidHueOverride >= 0)
                        hue = beheld.SolidHueOverride;

                    int itemID = item.ItemID & 0xFFFF;

                    m_Stream.Write((int)item.Serial);
                    m_Stream.Write((ushort)itemID);
                    m_Stream.Write((byte)layer);

                    m_Stream.Write((short)hue);
                }
            }

            if (beheld.HairItemID > 0)
            {
                if (m_DupedLayers[(int)Layer.Hair] != m_Version)
                {
                    m_DupedLayers[(int)Layer.Hair] = m_Version;
                    hue = beheld.HairHue;

                    if (beheld.SolidHueOverride >= 0)
                        hue = beheld.SolidHueOverride;

                    int itemID = beheld.HairItemID & 0xFFFF;

                    m_Stream.Write((int)HairInfo.FakeSerial(beheld));
                    m_Stream.Write((ushort)itemID);
                    m_Stream.Write((byte)Layer.Hair);

                    m_Stream.Write((short)hue);
                }
            }

            if (beheld.FacialHairItemID > 0)
            {
                if (m_DupedLayers[(int)Layer.FacialHair] != m_Version)
                {
                    m_DupedLayers[(int)Layer.FacialHair] = m_Version;
                    hue = beheld.FacialHairHue;

                    if (beheld.SolidHueOverride >= 0)
                        hue = beheld.SolidHueOverride;

                    int itemID = beheld.FacialHairItemID & 0xFFFF;

                    m_Stream.Write((int)FacialHairInfo.FakeSerial(beheld));
                    m_Stream.Write((ushort)itemID);
                    m_Stream.Write((byte)Layer.FacialHair);

                    m_Stream.Write((short)hue);
                }
            }

            m_Stream.Write((int)0); // terminate
        }
Пример #22
0
        public MobileDirectionToOthersOnly (Mobile m, int noto, Direction direction)
            : base(0x77, 17)
        {
            Point3D loc = m.Location;

            int hue = m.Hue;

            if (m.SolidHueOverride >= 0)
                hue = m.SolidHueOverride;

            m_Stream.Write((int)m.Serial);
            m_Stream.Write((short)m.Body);
            m_Stream.Write((short)loc.m_X);
            m_Stream.Write((short)loc.m_Y);
            m_Stream.Write((sbyte)loc.m_Z);
            m_Stream.Write((byte)direction);
            m_Stream.Write((short)hue);
            m_Stream.Write((byte)m.GetPacketFlags());
            m_Stream.Write((byte)noto);
        }
Пример #23
0
		public MobileIncoming(Mobile beholder, Mobile beheld)
			: base(0x78)
		{
			m_Beheld = beheld;
			++m_Version;

			//List<Item> eq = beheld.Items;
			//SMD: back-porting new runuo2.0 code to use our stuff (which still uses arraylists)
			ArrayList temparraylist = beheld.Items;
			List<Item> eq = new List<Item>();
			try
			{
				for (int i = 0; i < temparraylist.Count; i++)
				{
					Item a = temparraylist[i] as Item;
					if (a != null)
					{
						eq.Add(a);
					}
				}
			}
			catch (Exception ex) { EventSink.InvokeLogException(new LogExceptionEventArgs(ex)); }
			//SMD: done back-port

			int count = eq.Count;

			if (beheld.HairItemID > 0)
				count++;
			if (beheld.FacialHairItemID > 0)
				count++;

			this.EnsureCapacity(23 + (count * 9));

			int hue = beheld.Hue;

			if (beheld.SolidHueOverride >= 0)
				hue = beheld.SolidHueOverride;

			m_Stream.Write((int)beheld.Serial);
			m_Stream.Write((short)beheld.Body);
			m_Stream.Write((short)beheld.X);
			m_Stream.Write((short)beheld.Y);
			m_Stream.Write((sbyte)beheld.Z);
			m_Stream.Write((byte)beheld.Direction);
			m_Stream.Write((short)hue);
			m_Stream.Write((byte)beheld.GetPacketFlags());
			m_Stream.Write((byte)Notoriety.Compute(beholder, beheld));

			for (int i = 0; i < eq.Count; ++i)
			{
				Item item = eq[i];

				byte layer = (byte)item.Layer;

				if (!item.Deleted && beholder.CanSee(item) && m_DupedLayers[layer] != m_Version)
				{
					m_DupedLayers[layer] = m_Version;

					hue = item.Hue;

					if (beheld.SolidHueOverride >= 0)
						hue = beheld.SolidHueOverride;

					int itemID = item.ItemID & 0x3FFF;
					bool writeHue = (hue != 0);

					if (writeHue)
						itemID |= 0x8000;

					m_Stream.Write((int)item.Serial);
					m_Stream.Write((short)itemID);
					m_Stream.Write((byte)layer);

					if (writeHue)
						m_Stream.Write((short)hue);
				}
			}

			if (beheld.HairItemID > 0)
			{
				if (m_DupedLayers[(int)Layer.Hair] != m_Version)
				{
					m_DupedLayers[(int)Layer.Hair] = m_Version;
					hue = beheld.HairHue;

					if (beheld.SolidHueOverride >= 0)
						hue = beheld.SolidHueOverride;

					int itemID = beheld.HairItemID & 0x3FFF;

					bool writeHue = (hue != 0);

					if (writeHue)
						itemID |= 0x8000;

					//SMD: new runuo2.0 stuff - fake it
					//m_Stream.Write( (int)HairInfo.FakeSerial( beheld ) );
					m_Stream.Write((int)(0x7FFFFFFF - 0x400 - (beheld.Serial * 4)));


					m_Stream.Write((short)itemID);
					m_Stream.Write((byte)Layer.Hair);

					if (writeHue)
						m_Stream.Write((short)hue);
				}
			}

			if (beheld.FacialHairItemID > 0)
			{
				if (m_DupedLayers[(int)Layer.FacialHair] != m_Version)
				{
					m_DupedLayers[(int)Layer.FacialHair] = m_Version;
					hue = beheld.FacialHairHue;

					if (beheld.SolidHueOverride >= 0)
						hue = beheld.SolidHueOverride;

					int itemID = beheld.FacialHairItemID & 0x3FFF;

					bool writeHue = (hue != 0);

					if (writeHue)
						itemID |= 0x8000;

					//SMD: new runuo2.0 stuff - fake it
					//m_Stream.Write( (int)FacialHairInfo.FakeSerial( beheld ) );
					m_Stream.Write((int)(0x7FFFFFFF - 0x400 - 1 - (beheld.Serial * 4)));

					m_Stream.Write((short)itemID);
					m_Stream.Write((byte)Layer.FacialHair);

					if (writeHue)
						m_Stream.Write((short)hue);
				}
			}

			m_Stream.Write((int)0); // terminate
		}
Пример #24
0
        public MobileIncoming( Mobile beholder, Mobile beheld )
            : base(0x78)
        {
            m_Beheld = beheld;
            ++m_Version;

            List<Item> eq = beheld.Items;
            int count = eq.Count;

            if( beheld.HairItemID > 0 )
                count++;
            if( beheld.FacialHairItemID > 0 )
                count++;

            this.EnsureCapacity( 23 + (count * 9) );

            int hue = beheld.Hue;

            if ( beheld.SolidHueOverride >= 0 )
                hue = beheld.SolidHueOverride;

            m_Stream.Write( (int) beheld.Serial );
            m_Stream.Write( (short) beheld.Body );
            m_Stream.Write( (short) beheld.X );
            m_Stream.Write( (short) beheld.Y );
            m_Stream.Write( (sbyte) beheld.Z );
            m_Stream.Write( (byte) beheld.Direction );
            m_Stream.Write( (short) hue );
            m_Stream.Write( (byte) beheld.GetPacketFlags() );
            m_Stream.Write( (byte) Notoriety.Compute( beholder, beheld ) );

            NetState ns = beholder.RawNetState;
            bool useHueFlag = ( ns == null || !ns.NewMobileIncoming );

            for ( int i = 0; i < eq.Count; ++i )
            {
                Item item = eq[i];

                byte layer = (byte) item.Layer;

                if ( !item.Deleted && beholder.CanSee( item ) && m_DupedLayers[layer] != m_Version )
                {
                    m_DupedLayers[layer] = m_Version;

                    hue = item.Hue;

                    if ( beheld.SolidHueOverride >= 0 )
                        hue = beheld.SolidHueOverride;

                    int itemID = item.ItemID & 0xFFFF;

                    if ( useHueFlag )
                    {
                        itemID &= 0x7FFF;

                        if ( hue != 0 )
                            itemID |= 0x8000;
                    }

                    m_Stream.Write( (int) item.Serial );
                    m_Stream.Write( (ushort) itemID );
                    m_Stream.Write( (byte) layer );

                    if ( !useHueFlag || hue != 0 )
                        m_Stream.Write( (short) hue );
                }
            }

            if( beheld.HairItemID > 0 )
            {
                if( m_DupedLayers[(int)Layer.Hair] != m_Version )
                {
                    m_DupedLayers[(int)Layer.Hair] = m_Version;
                    hue = beheld.HairHue;

                    if( beheld.SolidHueOverride >= 0 )
                        hue = beheld.SolidHueOverride;

                    int itemID = beheld.HairItemID & 0xFFFF;

                    if ( useHueFlag )
                    {
                        itemID &= 0x7FFF;

                        if ( hue != 0 )
                            itemID |= 0x8000;
                    }

                    m_Stream.Write( (int)HairInfo.FakeSerial( beheld ) );
                    m_Stream.Write( (ushort)itemID );
                    m_Stream.Write( (byte)Layer.Hair );

                    if ( !useHueFlag || hue != 0 )
                        m_Stream.Write( (short)hue );
                }
            }

            if( beheld.FacialHairItemID > 0 )
            {
                if( m_DupedLayers[(int)Layer.FacialHair] != m_Version )
                {
                    m_DupedLayers[(int)Layer.FacialHair] = m_Version;
                    hue = beheld.FacialHairHue;

                    if( beheld.SolidHueOverride >= 0 )
                        hue = beheld.SolidHueOverride;

                    int itemID = beheld.FacialHairItemID & 0xFFFF;

                    if ( useHueFlag )
                    {
                        itemID &= 0x7FFF;

                        if ( hue != 0 )
                            itemID |= 0x8000;
                    }

                    m_Stream.Write( (int)FacialHairInfo.FakeSerial( beheld ) );
                    m_Stream.Write( (ushort)itemID );
                    m_Stream.Write( (byte)Layer.FacialHair );

                    if ( !useHueFlag || hue != 0 )
                        m_Stream.Write( (short)hue );
                }
            }

            m_Stream.Write( (int) 0 ); // terminate
        }
Пример #25
0
		public MobileMoving(Mobile m, int noto)
			: base(0x77, 17)
		{
			Point3D loc = m.Location;

			int hue = m.Hue;

			if (m.SolidHueOverride >= 0)
			{
				hue = m.SolidHueOverride;
			}

			m_Stream.Write(m.Serial);
			m_Stream.Write((short)m.Body);
			m_Stream.Write((short)loc.m_X);
			m_Stream.Write((short)loc.m_Y);
			m_Stream.Write((sbyte)loc.m_Z);
			m_Stream.Write((byte)m.Direction);
			m_Stream.Write((short)hue);
			m_Stream.Write((byte)m.GetPacketFlags());
			m_Stream.Write((byte)noto);
		}
Пример #26
0
        public MobileMoving( Mobile m, int noto/*Mobile beholder, Mobile beheld*/ )
            : base(0x77, 17)
        {
            Point3D loc = m.Location;

            int hue = m.Hue;

            if ( m.SolidHueOverride >= 0 )
                hue = m.SolidHueOverride;

            m_Stream.Write( (int) m.Serial );
            m_Stream.Write( (short) m.Body );
            m_Stream.Write( (short) loc.m_X );
            m_Stream.Write( (short) loc.m_Y );
            m_Stream.Write( (sbyte) loc.m_Z );
            m_Stream.Write( (byte) m.Direction );
            m_Stream.Write( (short) hue );
            m_Stream.Write( (byte) m.GetPacketFlags() );
            m_Stream.Write( (byte) noto );//Notoriety.Compute( beholder, beheld ) );
        }
Пример #27
0
		public MobileIncomingSA(Mobile beholder, Mobile beheld)
			: base(0x78)
		{
			m_Beheld = beheld;

			int m_Version = ++(m_VersionTL.Value);
			var m_DupedLayers = m_DupedLayersTL.Value;

			var eq = beheld.Items;
			int count = eq.Count;

			if (beheld.HairItemID > 0)
			{
				count++;
			}
			if (beheld.FacialHairItemID > 0)
			{
				count++;
			}

			EnsureCapacity(23 + (count * 9));

			int hue = beheld.Hue;

			if (beheld.SolidHueOverride >= 0)
			{
				hue = beheld.SolidHueOverride;
			}

			m_Stream.Write(beheld.Serial);
			m_Stream.Write((short)beheld.Body);
			m_Stream.Write((short)beheld.X);
			m_Stream.Write((short)beheld.Y);
			m_Stream.Write((sbyte)beheld.Z);
			m_Stream.Write((byte)beheld.Direction);
			m_Stream.Write((short)hue);
			m_Stream.Write((byte)beheld.GetPacketFlags());
			m_Stream.Write((byte)Notoriety.Compute(beholder, beheld));

			for (int i = 0; i < eq.Count; ++i)
			{
				Item item = eq[i];

				byte layer = (byte)item.Layer;

				if (!item.Deleted && beholder.CanSee(item) && m_DupedLayers[layer] != m_Version)
				{
					m_DupedLayers[layer] = m_Version;

					hue = item.Hue;

					if (beheld.SolidHueOverride >= 0)
					{
						hue = beheld.SolidHueOverride;
					}

					int itemID = item.ItemID & 0x7FFF;
					bool writeHue = (hue != 0);

					if (writeHue)
					{
						itemID |= 0x8000;
					}

					m_Stream.Write(item.Serial);
					m_Stream.Write((ushort)itemID);
					m_Stream.Write(layer);

					if (writeHue)
					{
						m_Stream.Write((short)hue);
					}
				}
			}

			if (beheld.HairItemID > 0)
			{
				if (m_DupedLayers[(int)Layer.Hair] != m_Version)
				{
					m_DupedLayers[(int)Layer.Hair] = m_Version;
					hue = beheld.HairHue;

					if (beheld.SolidHueOverride >= 0)
					{
						hue = beheld.SolidHueOverride;
					}

					int itemID = beheld.HairItemID & 0x7FFF;

					bool writeHue = (hue != 0);

					if (writeHue)
					{
						itemID |= 0x8000;
					}

					m_Stream.Write(HairInfo.FakeSerial(beheld));
					m_Stream.Write((ushort)itemID);
					m_Stream.Write((byte)Layer.Hair);

					if (writeHue)
					{
						m_Stream.Write((short)hue);
					}
				}
			}

			if (beheld.FacialHairItemID > 0)
			{
				if (m_DupedLayers[(int)Layer.FacialHair] != m_Version)
				{
					m_DupedLayers[(int)Layer.FacialHair] = m_Version;
					hue = beheld.FacialHairHue;

					if (beheld.SolidHueOverride >= 0)
					{
						hue = beheld.SolidHueOverride;
					}

					int itemID = beheld.FacialHairItemID & 0x7FFF;

					bool writeHue = (hue != 0);

					if (writeHue)
					{
						itemID |= 0x8000;
					}

					m_Stream.Write(FacialHairInfo.FakeSerial(beheld));
					m_Stream.Write((ushort)itemID);
					m_Stream.Write((byte)Layer.FacialHair);

					if (writeHue)
					{
						m_Stream.Write((short)hue);
					}
				}
			}

			m_Stream.Write(0); // terminate
		}
Пример #28
0
        public UnkD3( Mobile beholder, Mobile beheld )
            : base(0xD3)
        {
            this.EnsureCapacity( 256 );

            //int
            //short
            //short
            //short
            //byte
            //byte
            //short
            //byte
            //byte
            //short
            //short
            //short
            //while ( int != 0 )
            //{
            //short
            //byte
            //short
            //}

            m_Stream.Write( (int) beheld.Serial );
            m_Stream.Write( (short) beheld.Body );
            m_Stream.Write( (short) beheld.X );
            m_Stream.Write( (short) beheld.Y );
            m_Stream.Write( (sbyte) beheld.Z );
            m_Stream.Write( (byte) beheld.Direction );
            m_Stream.Write( (ushort) beheld.Hue );
            m_Stream.Write( (byte) beheld.GetPacketFlags() );
            m_Stream.Write( (byte) Notoriety.Compute( beholder, beheld ) );

            m_Stream.Write( (short) 0 );
            m_Stream.Write( (short) 0 );
            m_Stream.Write( (short) 0 );

            m_Stream.Write( (int) 0 );
        }
Пример #29
0
		public MobileUpdate( Mobile m ) : base( 0x20, 19 )
		{
			//int hue = m.Hue;
            int hue = m.GetHue(m);  // Scriptiz : hallucinations

			if ( m.SolidHueOverride >= 0 )
				hue = m.SolidHueOverride;

			m_Stream.Write( (int) m.Serial );
			//m_Stream.Write( (short) m.Body );
            m_Stream.Write((short)m.GetBody(m));    // Scriptiz : hallucinations
			m_Stream.Write( (byte) 0 );
			m_Stream.Write( (short) hue );
			m_Stream.Write( (byte) m.GetPacketFlags() );
			m_Stream.Write( (short) m.X );
			m_Stream.Write( (short) m.Y );
			m_Stream.Write( (short) 0 );
			m_Stream.Write( (byte) m.Direction );
			m_Stream.Write( (sbyte) m.Z );
		}