Esempio n. 1
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 0 ); // version

            writer.WriteItemList( m_DecoItems );
        }
Esempio n. 2
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int)4 ); // version

            writer.Write( m_ConfinedRoaming );
            writer.Write( m_Idol );
            writer.Write( m_HasBeenAdvanced );
            writer.Write( m_SpawnArea );

            writer.Write( m_RandomizeType );

            //			writer.Write( m_SpawnRange );
            writer.Write( m_Kills );

            writer.Write( (bool)m_Active );
            writer.Write( (int)m_Type );
            writer.WriteMobileList( m_Creatures, true );
            writer.WriteItemList( m_RedSkulls, true );
            writer.WriteItemList( m_WhiteSkulls, true );
            writer.Write( m_Platform );
            writer.Write( m_Altar );
            writer.Write( m_ExpireDelay );
            writer.WriteDeltaTime( m_ExpireTime );
            writer.Write( m_Champion );
            writer.Write( m_RestartDelay );

            writer.Write( m_RestartTimer != null );

            if( m_RestartTimer != null )
                writer.WriteDeltaTime( m_RestartTime );
        }
Esempio n. 3
0
		public override void Serialize( GenericWriter writer ) 
		{ 
			base.Serialize( writer ); 

			writer.Write( (int) 1 ); 

			writer.Write(m_spell); // version 1

			writer.Write(m_Owner); // version 0
			writer.Write(m_SleepingBodyName);
			writer.Write(m_Blessed);

			writer.WriteItemList( m_EquipItems, true );
		} 
Esempio n. 4
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 14 ); // version

			writer.Write( (Point3D) m_RelativeBanLocation );

			writer.WriteItemList( m_VendorRentalContracts, true );
			writer.WriteMobileList( m_InternalizedVendors, true );

			writer.WriteEncodedInt( m_RelocatedEntities.Count );
			foreach ( RelocatedEntity relEntity in m_RelocatedEntities )
			{
				writer.Write( (Point3D) relEntity.RelativeLocation );

				if ( ( relEntity.Entity is Item && ((Item)relEntity.Entity).Deleted ) || ( relEntity.Entity is Mobile && ((Mobile)relEntity.Entity).Deleted ) )
					writer.Write( (int) Serial.MinusOne );
				else
					writer.Write( (int) relEntity.Entity.Serial );
			}

			writer.WriteEncodedInt( m_VendorInventories.Count );
			for ( int i = 0; i < m_VendorInventories.Count; i++ )
			{
				VendorInventory inventory = (VendorInventory) m_VendorInventories[i];
				inventory.Serialize( writer );
			}

			writer.Write( (DateTime) m_LastRefreshed );
			writer.Write( (bool) m_RestrictDecay );

			writer.Write( (int) m_Visits );

			writer.Write( (int) m_Price );

			writer.WriteMobileList( m_Access );

			writer.Write( m_BuiltOn );
			writer.Write( m_LastTraded );

			writer.WriteItemList( m_Addons, true );

			writer.Write( m_Secures.Count );

			for ( int i = 0; i < m_Secures.Count; ++i )
				((SecureInfo)m_Secures[i]).Serialize( writer );

			writer.Write( m_Public );

			//writer.Write( BanLocation );

			writer.Write( m_Owner );

			// Version 5 no longer serializes region coords
			/*writer.Write( (int)m_Region.Coords.Count );
			foreach( Rectangle2D rect in m_Region.Coords )
			{
				writer.Write( rect );
			}*/

			writer.WriteMobileList( m_CoOwners, true );
			writer.WriteMobileList( m_Friends, true );
			writer.WriteMobileList( m_Bans, true );

			writer.Write( m_Sign );
			writer.Write( m_Trash );

			writer.WriteItemList( m_Doors, true );
			writer.WriteItemList( m_LockDowns, true );
			//writer.WriteItemList( m_Secures, true );

			writer.Write( (int) m_MaxLockDowns );
			writer.Write( (int) m_MaxSecures );

			// Items in locked down containers that aren't locked down themselves must decay!
			for ( int i = 0; i < m_LockDowns.Count; ++i )
			{
				Item item = (Item)m_LockDowns[i];

				if ( item is Container && !(item is BaseBoard) )
				{
					Container cont = (Container)item;
					List<Item> children = cont.Items;

					for ( int j = 0; j < children.Count; ++j )
					{
						Item child = children[j];

						if ( child.Decays && !child.IsLockedDown && !child.IsSecure && (child.LastMoved + child.DecayTime) <= DateTime.Now )
							Timer.DelayCall( TimeSpan.Zero, new TimerCallback( child.Delete ) );
					}
				}
			}
		}
Esempio n. 5
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			writer.Write((int)1); // version

			writer.Write(m_Cost);
			writer.Write(m_AmountCollected);

			writer.Write(m_Active);
			if (m_Owner != null && m_Owner.Deleted)
				m_Owner = null;
			writer.Write(m_Owner);
			writer.Write(m_Decays);
			writer.Write(m_DecayTime);
			writer.Write((int)m_AccessLevel);
			if (m_RuneBooks != null && m_RuneBooks.Count > 0)
			{
				writer.Write(true);
				writer.WriteItemList(m_RuneBooks);
			}
			else
				writer.Write(false);
			writer.Write(m_DecayRunning);
			if (m_DecayRunning)
				writer.Write(this.m_DecayEnd - DateTime.Now);

			if (m_Active && m_RuneBooks != null && m_RuneBooks.Count > 0)
			{
				Runebook runebook = m_RuneBooks[0] as Runebook;
				if (runebook.Hue != Hue)
					Hue = runebook.Hue == 1121 ? 58 : runebook.Hue;
			}
		}
Esempio n. 6
0
        public virtual void Serialize( GenericWriter writer )
        {
            writer.Write( 7 ); // version

            SaveFlag flags = SaveFlag.None;

            int x = m_Location.m_X, y = m_Location.m_Y, z = m_Location.m_Z;

            if ( x != 0 || y != 0 || z != 0 )
            {
                if ( x >= short.MinValue && x <= short.MaxValue && y >= short.MinValue && y <= short.MaxValue && z >= sbyte.MinValue && z <= sbyte.MaxValue )
                {
                    if ( x != 0 || y != 0 )
                    {
                        if ( x >= byte.MinValue && x <= byte.MaxValue && y >= byte.MinValue && y <= byte.MaxValue )
                            flags |= SaveFlag.LocationByteXY;
                        else
                            flags |= SaveFlag.LocationShortXY;
                    }

                    if ( z != 0 )
                        flags |= SaveFlag.LocationSByteZ;
                }
                else
                {
                    flags |= SaveFlag.LocationFull;
                }
            }

            if ( m_Direction != Direction.North ) flags |= SaveFlag.Direction;
            if ( m_Bounce != null ) flags |= SaveFlag.Bounce;
            if ( m_LootType != LootType.Regular ) flags |= SaveFlag.LootType;
            if ( m_ItemID != 0 ) flags |= SaveFlag.ItemID;
            if ( m_Hue != 0 ) flags |= SaveFlag.Hue;
            if ( m_Amount != 1 ) flags |= SaveFlag.Amount;
            if ( m_Layer != Layer.Invalid ) flags |= SaveFlag.Layer;
            if ( m_Name != null ) flags |= SaveFlag.Name;
            if ( m_Parent != null ) flags |= SaveFlag.Parent;
            if ( m_Items != null && m_Items.Count > 0 ) flags |= SaveFlag.Items;
            if ( m_Map != Map.Internal ) flags |= SaveFlag.Map;
            //if ( m_InsuredFor != null && !m_InsuredFor.Deleted ) flags |= SaveFlag.InsuredFor;
            if ( m_BlessedFor != null && !m_BlessedFor.Deleted ) flags |= SaveFlag.BlessedFor;
            if ( m_HeldBy != null && !m_HeldBy.Deleted ) flags |= SaveFlag.HeldBy;
            if ( m_SavedFlags != 0 ) flags |= SaveFlag.SavedFlags;

            if ( m_Weight == 0.0 )
            {
                flags |= SaveFlag.WeightIs0;
            }
            else if ( m_Weight != 1.0 )
            {
                if ( m_Weight == (int)m_Weight )
                    flags |= SaveFlag.IntWeight;
                else
                    flags |= SaveFlag.WeightNot1or0;
            }

            ImplFlag implFlags = ( m_Flags & (ImplFlag.Visible | ImplFlag.Movable | ImplFlag.Stackable | ImplFlag.Insured | ImplFlag.PayedInsurance) );

            if ( implFlags != (ImplFlag.Visible | ImplFlag.Movable) )
                flags |= SaveFlag.ImplFlags;

            writer.Write( (int) flags );

            /* begin last moved time optimization */
            long ticks = m_LastMovedTime.Ticks;
            long now = Core.Now.Ticks;

            TimeSpan d;

            try{ d = new TimeSpan( ticks-now ); }
            catch{ if ( ticks < now ) d = TimeSpan.MaxValue; else d = TimeSpan.MaxValue; }

            double minutes = -d.TotalMinutes;

            if ( minutes < int.MinValue )
                minutes = int.MinValue;
            else if ( minutes > int.MaxValue )
                minutes = int.MaxValue;

            writer.WriteEncodedInt( (int) minutes );
            /* end */

            if ( GetSaveFlag( flags, SaveFlag.Direction ) )
                writer.Write( (byte) m_Direction );

            if ( GetSaveFlag( flags, SaveFlag.Bounce ) )
                BounceInfo.Serialize( m_Bounce, writer );

            if ( GetSaveFlag( flags, SaveFlag.LootType ) )
                writer.Write( (byte) m_LootType );

            if ( GetSaveFlag( flags, SaveFlag.LocationFull ) )
            {
                writer.WriteEncodedInt( x );
                writer.WriteEncodedInt( y );
                writer.WriteEncodedInt( z );
            }
            else
            {
                if ( GetSaveFlag( flags, SaveFlag.LocationByteXY ) )
                {
                    writer.Write( (byte) x );
                    writer.Write( (byte) y );
                }
                else if ( GetSaveFlag( flags, SaveFlag.LocationShortXY ) )
                {
                    writer.Write( (short) x );
                    writer.Write( (short) y );
                }

                if ( GetSaveFlag( flags, SaveFlag.LocationSByteZ ) )
                    writer.Write( (sbyte) z );
            }

            if ( GetSaveFlag( flags, SaveFlag.ItemID ) )
                writer.WriteEncodedInt( (int) m_ItemID );

            if ( GetSaveFlag( flags, SaveFlag.Hue ) )
                writer.WriteEncodedInt( (int) m_Hue );

            if ( GetSaveFlag( flags, SaveFlag.Amount ) )
                writer.WriteEncodedInt( (int) m_Amount );

            if ( GetSaveFlag( flags, SaveFlag.Layer ) )
                writer.Write( (byte) m_Layer );

            if ( GetSaveFlag( flags, SaveFlag.Name ) )
                writer.Write( (string) m_Name );

            if ( GetSaveFlag( flags, SaveFlag.Parent ) )
            {
                if ( m_Parent is Mobile && !((Mobile)m_Parent).Deleted )
                    writer.Write( ((Mobile)m_Parent).Serial );
                else if ( m_Parent is Item && !((Item)m_Parent).Deleted )
                    writer.Write( ((Item)m_Parent).Serial );
                else
                    writer.Write( (int) Serial.MinusOne );
            }

            if ( GetSaveFlag( flags, SaveFlag.Items ) )
                writer.WriteItemList( m_Items, false );

            if ( GetSaveFlag( flags, SaveFlag.IntWeight ) )
                writer.WriteEncodedInt( (int) m_Weight );
            else if ( GetSaveFlag( flags, SaveFlag.WeightNot1or0 ) )
                writer.Write( (double) m_Weight );

            if ( GetSaveFlag( flags, SaveFlag.Map ) )
                writer.Write( (Map) m_Map );

            if ( GetSaveFlag( flags, SaveFlag.ImplFlags ) )
                writer.WriteEncodedInt( (int) implFlags );

            if ( GetSaveFlag( flags, SaveFlag.InsuredFor ) )
                writer.Write( (Mobile)null );

            if ( GetSaveFlag( flags, SaveFlag.BlessedFor ) )
                writer.Write( m_BlessedFor );

            if ( GetSaveFlag( flags, SaveFlag.HeldBy ) )
                writer.Write( m_HeldBy );

            if ( GetSaveFlag( flags, SaveFlag.SavedFlags ) )
                writer.WriteEncodedInt( m_SavedFlags );
        }
Esempio n. 7
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int)30 ); // version
			// Version 30
			writer.Write( m_AllowNPCTriggering );

			// Version 29
			if( m_SpawnObjects != null )
			{
				writer.Write( m_SpawnObjects.Count );
				for( int i = 0; i < m_SpawnObjects.Count; ++i )
				{
					// Write the spawns per tick value
					writer.Write( ((SpawnObject)m_SpawnObjects[i]).SpawnsPerTick );
				}
			}
			else
			{
				// empty spawner
				writer.Write( (int)0 );
			}

			// Version 28
			if( m_SpawnObjects != null )
			{
				for( int i = 0; i < m_SpawnObjects.Count; ++i )
				{
					// Write the pack range value
					writer.Write( ((SpawnObject)m_SpawnObjects[i]).PackRange );
				}
			}


			// Version 27
			if( m_SpawnObjects != null )
			{
				for( int i = 0; i < m_SpawnObjects.Count; ++i )
				{
					// Write the disable spawn flag
					writer.Write( ((SpawnObject)m_SpawnObjects[i]).Disabled );
				}
			}

			// Version 26
			writer.Write( m_SpawnOnTrigger );
			writer.Write( m_FirstModified );
			writer.Write( m_LastModified );

			// Version 25
			// eliminated the textentrybook serialization (they autodelete on deser now)

			// Version 24
			if( m_SpawnObjects != null )
			{
				for( int i = 0; i < m_SpawnObjects.Count; ++i )
				{
					SpawnObject so = (SpawnObject)m_SpawnObjects[i];
					// Write the restrict kills flag
					writer.Write( so.RestrictKillsToSubgroup );
					// Write the clear on advance flag
					writer.Write( so.ClearOnAdvance );
					// Write the mindelay
					writer.Write( so.MinDelay );
					// Write the maxdelay
					writer.Write( so.MaxDelay );
					// write the next spawn time for the subgrop
					writer.WriteDeltaTime( so.NextSpawn );

				}
			}

			if( m_ShowBoundsItems != null && m_ShowBoundsItems.Count > 0 )
			{
				writer.Write( true );
				writer.WriteItemList( m_ShowBoundsItems );
			}
			else
			{
				// empty showbounds item list
				writer.Write( false );
			}

			// Version 23
			writer.Write( IsInactivated );
			writer.Write( m_SmartSpawning );
			// Version 22
			writer.Write( m_SkillTrigger );
			writer.Write( (int)m_skill_that_triggered );
			writer.Write( m_FreeRun );
			writer.Write( m_mob_who_triggered );
			// Version 21
			writer.Write( m_DespawnTime );
			// Version 20
			if( m_SpawnObjects != null )
			{
				for( int i = 0; i < m_SpawnObjects.Count; ++i )
				{
					// Write the requiresurface flag
					writer.Write( ((SpawnObject)m_SpawnObjects[i]).RequireSurface );
				}
			}
			// Version 19
			writer.Write( m_ConfigFile );
			writer.Write( m_OnHold );
			writer.Write( m_HoldSequence );
			writer.Write( m_FirstModifiedBy );
			writer.Write( m_LastModifiedBy );
			// compute the number of tags to save
			int tagcount = 0;
			for( int i = 0; i < m_KeywordTagList.Count; i++ )
			{
				// only save WAIT type keywords or other keywords that have the save flag set
				if( (((BaseXmlSpawner.KeywordTag)(m_KeywordTagList[i])).Flags & BaseXmlSpawner.KeywordFlags.Serialize) != 0 )
					tagcount++;
			}
			writer.Write( tagcount );
			// and write them out
			for( int i = 0; i < m_KeywordTagList.Count; i++ )
			{
				if( (((BaseXmlSpawner.KeywordTag)(m_KeywordTagList[i])).Flags & BaseXmlSpawner.KeywordFlags.Serialize) != 0 )
				{
					((BaseXmlSpawner.KeywordTag)(m_KeywordTagList[i])).Serialize( writer );
				}
			}
			// Version 18
			writer.Write( m_AllowGhostTriggering );
			// Version 17
			// removed in version 25
			//writer.Write( m_TextEntryBook);
			// Version 16
			writer.Write( m_SequentialSpawning );
			// write out the remaining time until sequential reset
			writer.Write( NextSeqReset );
			// Write the spawn object list
			if( m_SpawnObjects != null )
			{
				for( int i = 0; i < m_SpawnObjects.Count; ++i )
				{
					SpawnObject so = (SpawnObject)m_SpawnObjects[i];
					// Write the subgroup and sequential reset time
					writer.Write( so.SubGroup );
					writer.Write( so.SequentialResetTime );
					writer.Write( so.SequentialResetTo );
					writer.Write( so.KillsNeeded );
				}
			}
			writer.Write( m_RegionName );	// 2004.02.08 :: Omega Red


			// Version 15
			writer.Write( m_ExternalTriggering );
			writer.Write( m_ExternalTrigger );

			// Version 14
			writer.Write( m_NoItemTriggerName );

			// Version 13
			writer.Write( m_GumpState );

			// Version 12
			int todtype = (int)m_TODMode;
			writer.Write( todtype );

			// Version 11
			writer.Write( m_KillReset );
			writer.Write( m_skipped );
			writer.Write( m_spawncheck );

			// Version 10
			writer.Write( m_SetPropertyItem );

			// Version 9
			writer.Write( m_TriggerProbability );

			// Version 8
			writer.Write( m_MobPropertyName );
			writer.Write( m_MobTriggerName );
			writer.Write( m_PlayerPropertyName );

			// Version 7
			writer.Write( m_SpeechTrigger );

			// Version 6
			writer.Write( m_ItemTriggerName );

			// Version 5
			writer.Write( m_ProximityTriggerMessage );
			writer.Write( m_ObjectPropertyItem );
			writer.Write( m_ObjectPropertyName );
			writer.Write( m_killcount );

			// Version 4
			writer.Write( m_ProximityRange );
			writer.Write( m_ProximityTriggerSound );
			writer.Write( m_proximityActivated );
			writer.Write( m_durActivated );
			writer.Write( m_refractActivated );
			writer.Write( m_StackAmount );
			writer.Write( m_TODStart );
			writer.Write( m_TODEnd );
			writer.Write( m_MinRefractory );
			writer.Write( m_MaxRefractory );
			if( m_refractActivated )
				writer.Write( m_RefractEnd - DateTime.Now );
			if( m_durActivated )
				writer.Write( m_DurEnd - DateTime.Now );
			// Version 3
			writer.Write( m_ShowContainerStatic );
			// Version 2
			writer.Write( m_Duration );

			// Version 1
			writer.Write( m_UniqueId );
			writer.Write( m_HomeRangeIsRelative );

			// Version 0
			writer.Write( m_Name );
			writer.Write( m_X );
			writer.Write( m_Y );
			writer.Write( m_Width );
			writer.Write( m_Height );
			writer.Write( m_WayPoint );
			writer.Write( m_Group );
			writer.Write( m_MinDelay );
			writer.Write( m_MaxDelay );
			writer.Write( m_Count );
			writer.Write( m_Team );
			writer.Write( m_HomeRange );
			writer.Write( m_Running );

			if( m_Running )
				writer.Write( m_End - DateTime.Now );

			// Write the spawn object list
			int nso = 0;
			if( m_SpawnObjects != null ) nso = m_SpawnObjects.Count;
			writer.Write( nso );
			for( int i = 0; i < nso; ++i )
			{
				SpawnObject so = (SpawnObject)m_SpawnObjects[i];

				// Write the type and maximum count
				writer.Write( (string)so.TypeName );
				writer.Write( (int)so.ActualMaxCount );

				// Write the spawned object information
				writer.Write( so.SpawnedObjects.Count );
				for( int x = 0; x < so.SpawnedObjects.Count; ++x )
				{
					object o = so.SpawnedObjects[x];

					if( o is Item )
						writer.Write( (Item)o );
					else if( o is Mobile )
						writer.Write( (Mobile)o );
					else
					{

						// if this is a keyword tag then add some more info
						if( o is BaseXmlSpawner.KeywordTag )
						{
							writer.Write( -1 * ((BaseXmlSpawner.KeywordTag)o).Serial - 2 );
						}
						else
						{
							writer.Write( Serial.MinusOne );
						}
					}
				}
			}
		}
Esempio n. 8
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize (writer);

            writer.Write( (int)0 );
            writer.WriteItemList( m_Links );
            writer.Write( m_Charges );
        }
Esempio n. 9
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 0 ); // version

            writer.Write( (int)m_KeyValue );
            writer.Write( (int) m_Visits );
            writer.Write( (int) m_Price );

            writer.Write( m_BuiltOn );
            writer.Write( m_LastTraded );

            writer.Write( m_Public );

            writer.Write( BanLocation );

            writer.Write( m_Owner );

            writer.Write( m_Sign );
            writer.Write( m_Trash );

            writer.WriteItemList( m_Doors, true );
            writer.WriteItemList( m_Addons, true );

            if ( m_Sign != null && !m_Sign.Deleted && m_Sign.HouseDecayDate < DateTime.Now )
                Timer.DelayCall( TimeSpan.FromSeconds( Utility.Random( 60 ) + 60 ), new TimerCallback( m_Sign.CheckDecay ) );
        }
Esempio n. 10
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.WriteEncodedInt( 0 ); // version

            writer.WriteItemList<Key>( m_Keys );
        }
Esempio n. 11
0
		public override void Serialize( GenericWriter writer )
		{
            base.Serialize(writer);
            writer.Write(1); // Version
            writer.WriteItemList(m_market, true);
            writer.WriteMobileList(m_marketmob, true);
		}
Esempio n. 12
0
 public override void Serialize(GenericWriter writer)
 {
     base.Serialize(writer);
     writer.Write(verSion); // version
     switch (verSion)
     {
         case 1:
             writer.WriteItemList(locs);
             break;
     }
 }
Esempio n. 13
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 2 ); // version

            writer.WriteMobileList( m_Guardians, true );
            writer.Write( (bool) m_Temporary );

            writer.Write( m_Owner );

            writer.Write( (int) m_Level );
            writer.WriteDeltaTime( m_DeleteTime );
            writer.WriteItemList( m_Lifted, true );
        }
Esempio n. 14
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 0 ); // version
			writer.WriteItemList(PetHolders, true);
			writer.Write( exit );
		}
Esempio n. 15
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( 12 );

			// Version 12

			writer.Write( c_Free );

			// Version 11

			writer.Write( (int)c_Murderers );

			// Version 10

			writer.Write( c_LeaveItems );

			// Version 9
			writer.Write( c_RentToOwn );
			writer.Write( c_OriginalRentTime );
			writer.Write( c_RTOPayments );

			// Version 7
			writer.WriteItemList( c_PreviewItems, true );

			// Version 6
			writer.Write( c_ItemsPrice );
			writer.Write( c_KeepItems );

			// Version 5
			writer.Write( c_DecoreItemInfos.Count );
			foreach( DecoreItemInfo info in c_DecoreItemInfos )
				info.Save( writer );

			writer.Write( c_Relock );

			// Version 4
			writer.Write( c_RecurRent );
			writer.Write( c_RentByTime );
			writer.Write( c_RentTime );
			writer.Write( c_DemolishTime );
			writer.Write( c_YoungOnly );
			writer.Write( c_MinTotalSkill );
			writer.Write( c_MaxTotalSkill );

			// Version 3
			writer.Write( c_MinZ );
			writer.Write( c_MaxZ );

			// Version 2
			writer.Write( c_House );

			// Version 1
			writer.Write( c_Price );
			writer.Write( c_Locks );
			writer.Write( c_Secures );
			writer.Write( c_BanLoc );
			writer.Write( c_SignLoc );
			writer.Write( c_Skill );
			writer.Write( c_SkillReq );
			writer.Write( c_Blocks.Count );
			foreach( Rectangle2D rect in c_Blocks )
				writer.Write( rect );
		}
Esempio n. 16
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 0 ); // version

            writer.WriteItemList( m_Items, true );
            writer.WriteMobileList( m_Mobiles, true );
            writer.WriteDeltaTime( m_DecayTime );
        }
Esempio n. 17
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 0 ); // version

            writer.WriteItemList( m_Levers, true );
            writer.WriteItemList( m_Statues, true );
            writer.WriteItemList( m_Pads, true );

            writer.Write( m_Box );
        }
		public void Serialize( GenericWriter writer )
		{
			writer.WriteEncodedInt( 0 ); // version

			writer.Write( (Mobile) m_Owner );
			writer.Write( (string) m_VendorName );
			writer.Write( (string) m_ShopName );

			writer.WriteItemList( m_Items, true );
			writer.Write( (int) m_Gold );

			writer.WriteDeltaTime( m_ExpireTime );
		}
Esempio n. 19
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 1 ); // version
			writer.WriteItemList( m_Lifted, true );
			writer.Write( (int) m_IOBAlignment );
		}
Esempio n. 20
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 1 ); // version

			writer.Write( m_Owner );

			writer.Write( (int) m_Level );
			writer.WriteDeltaTime( m_DeleteTime );
			writer.WriteItemList( m_Lifted, true );
		}
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );
            writer.Write( (int) 0 ); // version

            writer.Write ( m_Active );

            writer.WriteItemList( m_AllSpawn );
            writer.WriteItemList( m_DungeonsSpawn );
            writer.WriteItemList( m_LostLandsSpawn );
            writer.WriteItemList( m_IlshenarSpawn );
            writer.WriteItemList( m_TokunoSpawn );

            writer.Write( m_RandomizeDelay );

            writer.Write( m_ActiveAltars );
        }
Esempio n. 22
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 2 );

            writer.Write( (int) BodyMod );
            writer.WriteItemList( m_Items );
        }
Esempio n. 23
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			writer.Write((int)1); 

			writer.Write(m_Cost); // Version 1
			writer.Write(m_AmountCollected);

			writer.Write(m_Active); // Version 0
			writer.Write(m_Decays);
			writer.Write(m_DecayTime);
			if (m_RuneBooks != null && m_RuneBooks.Count > 0)
			{
				writer.Write(true);
				writer.WriteItemList(m_RuneBooks);
			}
			else
				writer.Write(false);
			if (m_Decays)
				writer.Write(m_TimeLeft);
		}
Esempio n. 24
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 2 ); // version

			#region Mondain's Legacy version 2
			writer.Write( (int) m_Resource );
			#endregion

			writer.WriteItemList<AddonComponent>( m_Components );
		}
Esempio n. 25
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 1 ); // version

            writer.WriteItemList<AddonComponent>( m_Components );
        }
Esempio n. 26
0
        public override void Serialize( GenericWriter writer )
        {
            base.Serialize( writer );

            writer.Write( (int) 1 ); // version

            writer.Write( m_RegionBounds );

            writer.WriteItemList( m_Traps, false );

            writer.WriteMobileList( m_Creatures, false );

            writer.Write( m_TypeName );
            writer.Write( m_Door );
            writer.Write( m_Addon );
            writer.Write( m_Sequence );

            writer.Write( (int) m_State );
        }
Esempio n. 27
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 1 ); // version

			writer.Write( m_RegionBounds );

			writer.WriteItemList<BaseTrap>( m_Traps, false );

			writer.Write( m_Creatures, false );

			writer.Write( m_TypeName );
			writer.WriteItem<BaseDoor>( m_Door );
			writer.WriteItem<BaseAddon>( m_Addon );
			writer.WriteItem<GauntletSpawner>( m_Sequence );

			writer.Write( (int) m_State );
		}
Esempio n. 28
0
		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.WriteEncodedInt( 0 ); // version

			writer.WriteEncodedInt( m_Charges );
			writer.WriteItemList<ReceiverCrystal>( m_Receivers );
		}
        public override void Serialize( GenericWriter writer )
        {
            writer.Write( (int) 5 ); // version

            writer.Write( m_Signpost );
            writer.Write( (int) m_SignpostGraphic );

            writer.Write( (int) m_Type );

            writer.Write( m_SignHanger );

            writer.Write( (int) m_LastRevision );
            writer.WriteItemList( m_Fixtures, true );

            CurrentState.Serialize( writer );
            DesignState.Serialize( writer );
            BackupState.Serialize( writer );

            base.Serialize( writer );
        }
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            m_Corpses.ConvertAll(new System.Converter<Corpse, Item>(CorpseToItem));
            writer.Write((int)0); // version

            writer.Write(m_Player);
            writer.WriteItemList(m_Corpses);
            writer.Write(m_LastValidCorpse);
        }