Example #1
1
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(0);

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

            int version = writer.SetVersion(0);

            switch (version)
            {
                case 0:
                {
                    writer.WriteMobile(Owner);
                    writer.Write(OverallScore);

                    writer.Write(SpecificPortalScores.Count);

                    if (SpecificPortalScores.Count > 0)
                    {
                        foreach (KeyValuePair<PortalSerial, int> kvp in SpecificPortalScores)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }
                }
                    break;
            }
        }
Example #3
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(1);

            UID.Serialize(writer);

            switch (version)
            {
                case 1:
                {
                    writer.Write(Plat);
                    goto case 0;
                }
                case 0:
                {
                    writer.Write(InvaderTitles);
                    writer.Write(TimeLimit);
                    writer.Write(SpawnAmount);
                    writer.Write(KillAmount);

                    writer.Write(Creatures.Count);

                    if (Creatures.Count > 0)
                    {
                        foreach (Type creature in Creatures)
                        {
                            writer.WriteType(creature);
                        }
                    }
                }
                    break;
            }
        }
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(0);

            UID.Serialize(writer);

            switch (version)
            {
                case 0:
                {
                    writer.Write(Email);
                    writer.Write(TotalDonations);

                    writer.Write(DonationEntries.Count);

                    if (DonationEntries.Count > 0)
                    {
                        foreach (DonationEntry entry in DonationEntries)
                        {
                            entry.Serialize(writer);
                        }
                    }

                }
                    break;
            }
        }
Example #5
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(3);

			switch (version)
			{
                case 3:
                    {
                        writer.Write(SupressWorldFirsts);
                    }
                    goto case 2;
                case 2:
                    {
                       writer.Write(StaffWorldFirsts);
                    }
                    goto case 1;
				case 1:
					{
						writer.Write(MySQLEnabled);
						MySQLInfo.Serialize(writer);
					}
					goto case 0;
				case 0:
					writer.Write(UseCategories);
					break;
			}
		}
Example #6
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

            int version = writer.SetVersion(0);

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

			int version = writer.SetVersion(0);

            writer.Write(_Owner);
            writer.Write(_Contribution);

		}
Example #8
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			writer.SetVersion(0);

			writer.Write(InformChampSpawnRegionMobs);
			writer.Write(PowerScrollsToGive);
			writer.Write(PowerScrollMinimumDistance);
			writer.Write(PowerScrollRequireAlive);
		}
		private static void SerializeCams(GenericWriter writer)
		{
			int version = writer.SetVersion(0);

			switch (version)
			{
				case 0:
					{
					}
					break;
			}
		}
Example #10
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

            int version = writer.SetVersion(0);

            switch (version)
            {
                case 0:
                    break;
            }
		}
Example #11
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(0);

			switch (version)
			{
				case 0:
					writer.Write(DefaultTitleHue);
					break;
			}
		}
Example #12
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(0);

			switch (version)
			{
				case 0:
					writer.Write(VisitedMoonglow);
					break;
			}
		}
        private static bool SerializeDonationProfiles(GenericWriter writer)
        {
            writer.SetVersion(0);

            writer.WriteBlockDictionary(
                DonationProfiles,
                (pm, p) =>
                {
                    writer.Write(pm);

                    p.Serialize(writer);
                });

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

            int version = writer.SetVersion(0);

            switch (version)
            {
                case 0:
                {
                    writer.Write((int) Alignment);
                }
                    break;
            }
        }
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(0);

            switch (version)
            {
                case 0:
                {
                    writer.Write(Location);
                    writer.Write(Map);
                }
                    break;
            }
        }
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(0);

			switch (version)
			{
				case 0:
					{
						writer.WriteType(Spell);
						writer.Write(ChangeSpellReset);
					}
					break;
			}
		}
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(0);

			switch (version)
			{
                case 0:
                    {
                        writer.Write(LastKillerCheck);
                        writer.Write(IsPlayer);
                        writer.Write(IsCreature);
                    }
					break;
			}
		}
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(0);

			switch (version)
			{
                case 0:
                    {
                        writer.WriteType(Battle);
                        writer.Write(BattleChildren);
                        writer.Write(ChangeBattleReset);
                    }
					break;
			}
		}
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(1);

            switch (version)
            {
                case 1:
                    {
                        writer.Write(IsEthic);
                    }
                    goto case 0;
                case 0:
                    {}
                    break;
            }
		}
Example #20
0
        private static bool SerializePortals(GenericWriter writer)
        {
            writer.SetVersion(0);

            writer.WriteBlockDictionary(
                PortalList,
                (key, val) => writer.WriteType(
                    val,
                    t =>
                    {
                        if (t != null)
                        {
                            val.Serialize(writer);
                        }
                    }));

            return true;
        }
Example #21
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(1);

			switch (version)
			{
				case 1:
				case 0:
					{
						writer.Write((int)Skill);
                        writer.Write(SkillAmount);
						writer.Write(Children);
						writer.Write(ChangeSkillReset);
					}
					break;
			}
		}
Example #22
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(0);

            UID.Serialize(writer);

            switch (version)
            {
                case 0:
                {
                    writer.Write(Character);
                    writer.Write(AmountDonated);
                    writer.Write(CoinsGiven);
                    writer.Write(Date);
                }
                    break;
            }
        }
Example #23
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(0);

            UID.Serialize(writer);

            switch (version)
            {
                case 0:
                {
                    writer.Write((int)EventType);
                    writer.Write(EventName);
                    writer.Write(TimeAwarded);
                    writer.Write(PointsGained);
                }
                    break;
            }
        }
Example #24
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(1);

            switch (version)
            {
                case 1:
                {
                    writer.Write(MaxZombiesQuadrant1);
                    writer.Write(MaxZombiesQuadrant2);
                    writer.Write(MaxZombiesQuadrant3);
                    writer.Write(MaxZombiesQuadrant4);
                }
                    goto case 0;
                case 0:
                    writer.Write(MeleeMod);
                    break;
            }
        }
Example #25
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(1);

            switch (version)
            {
                case 1:
                {
                    writer.Write(ArcherMod);
                    writer.Write(BardMod);
                    writer.Write(TamerMod);
                    writer.Write(SummonMod);
                }
                    goto case 0;
                case 0:
                    break;
            }

        }
Example #26
0
        public override void Serialize(GenericWriter writer)
        {
            int version = writer.SetVersion(0);

            switch (version)
            {
                case 0:
                {
                    writer.Write(_level);
                    writer.Write(Name);
                    writer.Write((int) MetaSkillType);
                    writer.Write(ChanceToActivate);
                    writer.Write(CoolDown);
                    writer.Write(AbilityMultiplier);
                    writer.Write(Experience);
                    writer.Write(NextLevelExperience);
                    writer.Write(MaxLevel);
                }
                    break;
            }
        }
Example #27
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            writer.SetVersion(0);
        }
Example #28
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            var version = writer.SetVersion(2);

            switch (version)
            {
            case 3:
                writer.Write(AllowNoOwner);
                goto case 2;

            case 2:
            case 1:
                writer.Write(Silent);
                goto case 0;

            case 0:
            {
                writer.Write(Usage);
                writer.Write(Token);
                writer.Write(AllowCombat);
                writer.Write(AllowDeadUser);
                writer.Write(Consumable);
                writer.Write(ClearHands);
                writer.Write(DismountUser);
                writer.Write(EffectID);
                writer.Write(EffectHue);
                writer.Write(EffectSpeed);

                if (version < 2)
                {
                    writer.Write((short)EffectRender);
                    writer.Write((byte)TargetFlags);
                }
                else
                {
                    writer.WriteFlag(EffectRender);
                    writer.WriteFlag(TargetFlags);
                }

                writer.Write(ThrowSound);
                writer.Write(ImpactSound);
                writer.Write(ThrowRange);
                writer.Write(ThrowRecovery);
                writer.Write(ThrownLast);

                if (version < 2)
                {
                    writer.Write((short)RequiredSkill);
                }
                else
                {
                    writer.WriteFlag(RequiredSkill);
                }

                writer.Write(RequiredSkillValue);
            }
            break;
            }
        }
Example #29
0
        private void SerializeSnapshot(GenericWriter writer)
        {
            writer.SetVersion(0);

            Snapshot.Serialize(writer);
        }
Example #30
0
		public override void Serialize(GenericWriter writer)
		{
			base.Serialize(writer);

			int version = writer.SetVersion(1);

			switch (version)
			{
				case 1:
					{
						writer.Write(Region);
						writer.Write(Map);

						writer.Write(RegionChangeReset);
						writer.Write(MapChangeReset);
					}
					goto case 0;
				case 0:
					break;
			}
		}
Example #31
0
 public virtual void Serialize(GenericWriter writer)
 {
     writer.SetVersion(0);
 }
Example #32
0
        public virtual void Serialize(GenericWriter writer)
        {
            int version = writer.SetVersion(7);

            if (version > 5)
            {
                writer.WriteBlock(
                    () =>
                {
                    if (version > 6)
                    {
                        Serial.Serialize(writer);
                    }
                    else
                    {
                        writer.WriteType(
                            Serial,
                            t =>
                        {
                            if (t != null)
                            {
                                Serial.Serialize(writer);
                            }
                        });
                    }
                });
            }

            switch (version)
            {
            case 7:
            case 6:
            case 5:
                writer.Write(Hidden);
                goto case 4;

            case 4:
                writer.Write(FloorItemDelete);
                goto case 3;

            case 3:
            case 2:
                writer.Write(Gate);
                goto case 1;

            case 1:
            {
                writer.Write(Category);
                writer.Write(Ranked);
                writer.Write(InviteWhileRunning);
            }
                goto case 0;

            case 0:
            {
                if (version < 6)
                {
                    writer.WriteBlock(
                        () => writer.WriteType(
                            Serial,
                            t =>
                        {
                            if (t != null)
                            {
                                Serial.Serialize(writer);
                            }
                        }));
                }

                writer.Write(DebugMode);
                writer.WriteFlag(State);
                writer.Write(Name);
                writer.Write(Description);
                writer.Write(AutoAssign);
                writer.Write(UseTeamColors);
                writer.Write(IgnoreCapacity);
                writer.Write(SubCommandPrefix);
                writer.Write(QueueAllowed);
                writer.Write(SpectateAllowed);
                writer.Write(KillPoints);
                writer.Write(PointsBase);
                writer.Write(PointsRankFactor);
                writer.Write(IdleKick);
                writer.Write(IdleThreshold);
                writer.WriteFlag(LastState);
                writer.Write(LastStateChange);
                writer.Write(LightLevel);
                writer.Write(LogoutDelay);
                writer.WriteItemList(Doors, true);

                writer.WriteBlock(
                    () => writer.WriteType(
                        Options,
                        t =>
                    {
                        if (t != null)
                        {
                            Options.Serialize(writer);
                        }
                    }));

                writer.WriteBlock(
                    () => writer.WriteType(
                        Schedule,
                        t =>
                    {
                        if (t != null)
                        {
                            Schedule.Serialize(writer);
                        }
                    }));

                writer.WriteBlock(
                    () => writer.WriteType(
                        BattleRegion,
                        t =>
                    {
                        if (t != null)
                        {
                            BattleRegion.Serialize(writer);
                        }
                    }));

                writer.WriteBlock(
                    () => writer.WriteType(
                        SpectateRegion,
                        t =>
                    {
                        if (t != null)
                        {
                            SpectateRegion.Serialize(writer);
                        }
                    }));

                writer.WriteBlockList(
                    Teams,
                    team => writer.WriteType(
                        team,
                        t =>
                    {
                        if (t != null)
                        {
                            team.Serialize(writer);
                        }
                    }));
            }
            break;
            }
        }
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(2);

            switch (version)
            {
                case 2:
                    {
                        writer.Write(Tier1Cap);
                        writer.Write(Tier2Cap);
                        writer.Write(Tier3Cap);
                        writer.Write(Tier4Cap);
                        writer.Write(Tier5Cap);
                        writer.Write(Tier6Cap);
                        writer.Write(Tier7Cap);
                        writer.Write(Tier8Cap);
                        writer.Write(Tier9Cap);
                        writer.Write(Tier10Cap);
                    }
                    goto case 1;
                case 1:
                {
                    writer.Write(DragonBossDamage);
                }
                    goto case 0;
                case 0:
                {
                    writer.WriteMobile(Owner);
                    writer.Write(OverallScore);
                    writer.Write(SpendablePoints);
                    writer.Write(Kills);
                    writer.Write(Deaths);
                    writer.Write(ZombieAvatar);
                    writer.Write(Active);
                    writer.Write(ZombieSavePoint);

                    writer.Write(ZombieKills.Count);

                    if (ZombieKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in ZombieKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }

                    writer.Write(DaemonKills.Count);

                    if (DaemonKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in DaemonKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }

                    writer.Write(FeyKills.Count);

                    if (FeyKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in FeyKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }

                    writer.Write(GoreFiendKills.Count);

                    if (GoreFiendKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in GoreFiendKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }

                    writer.Write(TentacleKills.Count);

                    if (TentacleKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in TentacleKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }

                    writer.Write(TreefellowKills.Count);

                    if (TreefellowKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in TreefellowKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }

                    writer.Write(VitriolKills.Count);

                    if (VitriolKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in VitriolKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }

                    writer.Write(SpiderKills.Count);

                    if (SpiderKills.Count > 0)
                    {
                        foreach (KeyValuePair<ZombieInstanceSerial, int> kvp in SpiderKills)
                        {
                            kvp.Key.Serialize(writer);
                            writer.Write(kvp.Value);
                        }
                    }
                }
                    break;
            }
        }
Example #34
0
        public virtual void Serialize(GenericWriter writer)
        {
            var version = writer.SetVersion(8);

            if (version > 4)
            {
                writer.WriteBlock(
                    w =>
                {
                    if (version > 5)
                    {
                        Serial.Serialize(w);
                    }
                    else
                    {
                        w.WriteType(Serial, t => Serial.Serialize(w));
                    }
                });
            }

            switch (version)
            {
            case 8:
            case 7:
            {
                writer.Write(RespawnRangeMin);
                writer.Write(RespawnRangeMax);
            }
                goto case 6;

            case 6:
            case 5:
            case 4:
            case 3:
                writer.Write(RespawnOnStart);
                goto case 2;

            case 2:
                writer.Write(KickOnDeath);
                goto case 1;

            case 1:
            {
                GateLocation.Serialize(writer);
                writer.Write(Gate);
            }
                goto case 0;

            case 0:
            {
                writer.Write(_Name);
                writer.Write(_MinCapacity);
                writer.Write(_MaxCapacity);
                writer.Write(_Color);
                writer.Write(_HomeBase);
                writer.Write(_SpawnPoint);

                writer.Write(RespawnOnDeath);
                writer.Write(RespawnDelay);

                if (version < 8)
                {
                    writer.WriteBlock(w => w.WriteType(Statistics));
                }
            }
            break;
            }
        }
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(2);

            switch (version)
            {
                case 2:
                    {
                        writer.Write(Events.Count);

                        if (Events.Count > 0)
                        {
                            foreach (EventObject eventobj in Events)
                            {
                                eventobj.Serialize(writer);
                            }
                        }
                    }
                    goto case 1;
                case 1:
                {
                    writer.Write(DisplayCharacter);
                    writer.Write(SpendablePoints);
                }
                    goto case 0;
                case 0:
                {
                    writer.Write(OverallScore);

                    writer.Write(Players.Count);

                    if (Players.Count > 0)
                    {
                        foreach (PlayerMobile player in Players)
                        {
                            writer.Write(player);
                        }
                    }

                    writer.Write(Invasions.Count);

                    if (Invasions.Count > 0)
                    {
                        foreach (KeyValuePair<string, int> score in Invasions)
                        {
                            writer.Write(score.Key);
                            writer.Write(score.Value);
                        }
                    }

                    writer.Write(Tournaments.Count);

                    if (Tournaments.Count > 0)
                    {
                        foreach (KeyValuePair<string, int> score in Tournaments)
                        {
                            writer.Write(score.Key);
                            writer.Write(score.Value);
                        }
                    }

                    writer.Write(Battles.Count);

                    if (Battles.Count > 0)
                    {
                        foreach (KeyValuePair<string, int> score in Battles)
                        {
                            writer.Write(score.Key);
                            writer.Write(score.Value);
                        }
                    }
                }
                    break;
            }
        }
Example #36
0
        public virtual void Serialize(GenericWriter writer)
        {
            writer.SetVersion(0);

            writer.WriteList(this, (w, o) => o.Serialize(w));
        }
        private static bool SerializeZombieEvent(GenericWriter writer)
        {
            writer.SetVersion(0);

            writer.WriteBlockDictionary(
                ZombieEvents,
                (key, val) => writer.WriteType(
                    val,
                    t =>
                    {
                        if (t != null)
                        {
                            val.Serialize(writer);
                        }
                    }));

            return true;
        }
Example #38
0
        public virtual void Serialize(GenericWriter writer)
        {
            int version = writer.SetVersion(6);

            if (version > 4)
            {
                writer.WriteBlock(
                    () =>
                {
                    if (version > 5)
                    {
                        Serial.Serialize(writer);
                    }
                    else
                    {
                        writer.WriteType(
                            Serial,
                            t =>
                        {
                            if (t != null)
                            {
                                Serial.Serialize(writer);
                            }
                        });
                    }
                });
            }

            switch (version)
            {
            case 6:
            case 5:
            case 4:
            case 3:
                writer.Write(RespawnOnStart);
                goto case 2;

            case 2:
                writer.Write(KickOnDeath);
                goto case 1;

            case 1:
            {
                GateLocation.Serialize(writer);
                writer.Write(Gate);
            }
                goto case 0;

            case 0:
            {
                writer.Write(Name);
                writer.Write(MinCapacity);
                writer.Write(MaxCapacity);
                writer.Write(Color);
                writer.Write(HomeBase);
                writer.Write(SpawnPoint);
                writer.Write(RespawnOnDeath);
                writer.Write(RespawnDelay);

                writer.WriteBlock(() => writer.WriteType(Statistics));
            }
            break;
            }
        }