Example #1
0
        static Arcade()
        {
            CMOptions = new ArcadeOptions();

            Games = new BinaryDataStore <Type, IGame>(VitaNexCore.SavesDirectory + "/Arcade", "Games")
            {
                Async         = true,
                OnSerialize   = SerializeGames,
                OnDeserialize = DeserializeGames
            };

            Profiles = new BinaryDataStore <Mobile, ArcadeProfile>(VitaNexCore.SavesDirectory + "/Arcade", "Profiles")
            {
                Async         = true,
                OnSerialize   = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };

            GameTypes = typeof(IGame).GetConstructableChildren();

            foreach (var t in GameTypes)
            {
                var g = CreateGame(t);

                if (g != null)
                {
                    Games[t] = g;
                }
            }
        }
Example #2
0
        static AutoPvP()
        {
            CMOptions = new AutoPvPOptions();

            Scenarios   = new PvPScenario[0];
            BattleTypes = typeof(PvPBattle).GetConstructableChildren();

            SeasonSchedule = new Schedule(CMOptions.ModuleName + " Seasons", false, DefaultSeasonSchedule);

            Seasons = new BinaryDataStore <int, PvPSeason>(VitaNexCore.SavesDirectory + "/AutoPvP", "Seasons")
            {
                OnSerialize   = SerializeSeasons,
                OnDeserialize = DeserializeSeasons
            };

            Battles = new BinaryDirectoryDataStore <PvPSerial, PvPBattle>(
                VitaNexCore.SavesDirectory + "/AutoPvP", "Battles", "pvp")
            {
                OnSerialize   = SerializeBattle,
                OnDeserialize = DeserializeBattle
            };

            Profiles = new BinaryDataStore <PlayerMobile, PvPProfile>(VitaNexCore.SavesDirectory + "/AutoPvP", "Profiles")
            {
                Async         = true,
                OnSerialize   = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };
        }
Example #3
0
		static AutoPvP()
		{
			CMOptions = new AutoPvPOptions();

			Scenarios = new PvPScenario[0];
			BattleTypes = typeof(PvPBattle).GetConstructableChildren();

			SeasonSchedule = new Schedule(CMOptions.ModuleName + " Seasons", false, DefaultSeasonSchedule);

			Seasons = new BinaryDataStore<int, PvPSeason>(VitaNexCore.SavesDirectory + "/AutoPvP", "Seasons")
			{
				OnSerialize = SerializeSeasons,
				OnDeserialize = DeserializeSeasons
			};

			Battles = new BinaryDirectoryDataStore<PvPSerial, PvPBattle>(
				VitaNexCore.SavesDirectory + "/AutoPvP", "Battles", "pvp")
			{
				OnSerialize = SerializeBattle,
				OnDeserialize = DeserializeBattle
			};

			Profiles = new BinaryDataStore<PlayerMobile, PvPProfile>(VitaNexCore.SavesDirectory + "/AutoPvP", "Profiles")
			{
				Async = true,
				OnSerialize = SerializeProfiles,
				OnDeserialize = DeserializeProfiles
			};
		}
        static CustomTitles()
        {
            Rarities = ((TitleRarity)0).GetValues <TitleRarity>();

            TitleRegistry = new BinaryDataStore <TitleObjectSerial, Title>(VitaNexCore.SavesDirectory + "/CustomTitles",
                                                                           "Titles")
            {
                Async         = true,
                OnSerialize   = SerializeTitleRegistry,
                OnDeserialize = DeserializeTitleRegistry
            };

            HueRegistry = new BinaryDataStore <TitleObjectSerial, TitleHue>(
                VitaNexCore.SavesDirectory + "/CustomTitles", "Hues")
            {
                Async         = true,
                OnSerialize   = SerializeHueRegistry,
                OnDeserialize = DeserializeHueRegistry
            };

            Profiles = new BinaryDataStore <PlayerMobile, TitleProfile>(VitaNexCore.SavesDirectory + "/CustomTitles",
                                                                        "Profiles")
            {
                Async         = true,
                OnSerialize   = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };
        }
        static CustomTitles()
        {
            Rarities = ((TitleRarity) 0).GetValues<TitleRarity>();

            TitleRegistry = new BinaryDataStore<TitleObjectSerial, Title>(VitaNexCore.SavesDirectory + "/CustomTitles",
                "Titles")
            {
                Async = true,
                OnSerialize = SerializeTitleRegistry,
                OnDeserialize = DeserializeTitleRegistry
            };

            HueRegistry = new BinaryDataStore<TitleObjectSerial, TitleHue>(
                VitaNexCore.SavesDirectory + "/CustomTitles", "Hues")
            {
                Async = true,
                OnSerialize = SerializeHueRegistry,
                OnDeserialize = DeserializeHueRegistry
            };

            Profiles = new BinaryDataStore<PlayerMobile, TitleProfile>(VitaNexCore.SavesDirectory + "/CustomTitles",
                "Profiles")
            {
                Async = true,
                OnSerialize = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };
        }
Example #6
0
		static WebStats()
		{
			CMOptions = new WebStatsOptions();

			EventSink.ServerStarted += () => _Started = true;

			Clients = new List<WebStatsClient>();
			Snapshot = new Dictionary<IPAddress, List<NetState>>();

			Stats = new BinaryDataStore<string, WebStatsEntry>(VitaNexCore.SavesDirectory + "/WebStats", "Stats")
			{
				OnSerialize = SerializeStats,
				OnDeserialize = DeserializeStats
			};

			TimeSpan uptime = DateTime.UtcNow - Clock.ServerStart;

			Stats.Add("uptime", new WebStatsEntry(uptime, false));
			Stats.Add("uptime_peak", new WebStatsEntry(uptime, true));

			Stats.Add("online", new WebStatsEntry(0, false));
			Stats.Add("online_max", new WebStatsEntry(0, false));
			Stats.Add("online_peak", new WebStatsEntry(0, true));

			Stats.Add("unique", new WebStatsEntry(0, false));
			Stats.Add("unique_max", new WebStatsEntry(0, false));
			Stats.Add("unique_peak", new WebStatsEntry(0, true));

			Stats.Add("items", new WebStatsEntry(0, false));
			Stats.Add("items_max", new WebStatsEntry(0, false));
			Stats.Add("items_peak", new WebStatsEntry(0, true));

			Stats.Add("mobiles", new WebStatsEntry(0, false));
			Stats.Add("mobiles_max", new WebStatsEntry(0, false));
			Stats.Add("mobiles_peak", new WebStatsEntry(0, true));

			Stats.Add("guilds", new WebStatsEntry(0, false));
			Stats.Add("guilds_max", new WebStatsEntry(0, false));
			Stats.Add("guilds_peak", new WebStatsEntry(0, true));

			OnConnected += HandleConnection;

			_ActivityTimer = PollTimer.FromSeconds(
				60.0,
				() =>
				{
					if (!_Listening || Listener == null || Listener.Server == null || !Listener.Server.IsBound)
					{
						_Listening = false;
						ListenAsync();
					}

					Clients.RemoveRange(c => !c.Connected);
				},
				() => CMOptions.ModuleEnabled && Clients.Count > 0);
		}
Example #7
0
        static WebStats()
        {
            CMOptions = new WebStatsOptions();

            EventSink.ServerStarted += () => _Started = true;

            Clients  = new List <WebStatsClient>();
            Snapshot = new Dictionary <IPAddress, List <NetState> >();

            Stats = new BinaryDataStore <string, WebStatsEntry>(VitaNexCore.SavesDirectory + "/WebStats", "Stats")
            {
                OnSerialize   = SerializeStats,
                OnDeserialize = DeserializeStats
            };

            TimeSpan uptime = DateTime.UtcNow - Clock.ServerStart;

            Stats.Add("uptime", new WebStatsEntry(uptime, false));
            Stats.Add("uptime_peak", new WebStatsEntry(uptime, true));

            Stats.Add("online", new WebStatsEntry(0, false));
            Stats.Add("online_max", new WebStatsEntry(0, false));
            Stats.Add("online_peak", new WebStatsEntry(0, true));

            Stats.Add("unique", new WebStatsEntry(0, false));
            Stats.Add("unique_max", new WebStatsEntry(0, false));
            Stats.Add("unique_peak", new WebStatsEntry(0, true));

            Stats.Add("items", new WebStatsEntry(0, false));
            Stats.Add("items_max", new WebStatsEntry(0, false));
            Stats.Add("items_peak", new WebStatsEntry(0, true));

            Stats.Add("mobiles", new WebStatsEntry(0, false));
            Stats.Add("mobiles_max", new WebStatsEntry(0, false));
            Stats.Add("mobiles_peak", new WebStatsEntry(0, true));

            Stats.Add("guilds", new WebStatsEntry(0, false));
            Stats.Add("guilds_max", new WebStatsEntry(0, false));
            Stats.Add("guilds_peak", new WebStatsEntry(0, true));

            OnConnected += HandleConnection;

            _ActivityTimer = PollTimer.FromSeconds(
                60.0,
                () =>
            {
                if (!_Listening || Listener == null || Listener.Server == null || !Listener.Server.IsBound)
                {
                    _Listening = false;
                    ListenAsync();
                }

                Clients.RemoveRange(c => !c.Connected);
            },
                () => CMOptions.ModuleEnabled && Clients.Count > 0);
        }
Example #8
0
        static EquipmentSets()
        {
            CMOptions = new EquipmentSetsOptions();

            Sets = new BinaryDataStore <Type, EquipmentSet>(VitaNexCore.SavesDirectory + "/EquipSets", "Sets")
            {
                OnSerialize   = SaveSets,
                OnDeserialize = LoadSets
            };
        }
		static PlayerNames()
		{
			CSOptions = new PlayerNamesOptions();

			Registry = new BinaryDataStore<string, List<PlayerMobile>>(VitaNexCore.SavesDirectory + "/PlayerNames", "Registry")
			{
				OnSerialize = Serialize,
				OnDeserialize = Deserialize
			};
		}
Example #10
0
        static PlayerNames()
        {
            CSOptions = new PlayerNamesOptions();

            Registry = new BinaryDataStore <string, List <PlayerMobile> >(VitaNexCore.SavesDirectory + "/PlayerNames", "Registry")
            {
                OnSerialize   = Serialize,
                OnDeserialize = Deserialize
            };
        }
Example #11
0
		static EquipmentSets()
		{
			CMOptions = new EquipmentSetsOptions();

			Sets = new BinaryDataStore<Type, EquipmentSet>(VitaNexCore.SavesDirectory + "/EquipSets", "Sets")
			{
				OnSerialize = SaveSets,
				OnDeserialize = LoadSets
			};
		}
Example #12
0
        static DonationsTracker()
        {
            CSOptions = new DonationsTrackerOptions();

            DonationProfiles = new BinaryDataStore <String, DonationProfile>(
                VitaNexCore.SavesDirectory + "/DonationsTracker", "DonationProfiles")
            {
                Async         = true,
                OnSerialize   = SerializeDonationProfiles,
                OnDeserialize = DeserializeDonationProfiles
            };
        }
		static PvPTemplates()
		{
			CSOptions = new PvPTemplatesOptions();

			Templates = new BinaryDataStore<PlayerMobile, TemplateProfile>(
				VitaNexCore.SavesDirectory + "/Templates", "PvPTemplates")
			{
				Async = true,
				OnSerialize = SerializeTemplates,
				OnDeserialize = DeserializeTemplates
			};
		}
        static PvPTemplates()
        {
            CSOptions = new PvPTemplatesOptions();

            Templates = new BinaryDataStore <PlayerMobile, TemplateProfile>(
                VitaNexCore.SavesDirectory + "/Templates", "PvPTemplates")
            {
                Async         = true,
                OnSerialize   = SerializeTemplates,
                OnDeserialize = DeserializeTemplates
            };
        }
        static DonationsTracker()
        {
            CSOptions = new DonationsTrackerOptions();

            DonationProfiles = new BinaryDataStore<String, DonationProfile>(
                VitaNexCore.SavesDirectory + "/DonationsTracker", "DonationProfiles")
            {
                Async = true,
                OnSerialize = SerializeDonationProfiles,
                OnDeserialize = DeserializeDonationProfiles
            };
        }
Example #16
0
        static EventScores()
        {
            CSOptions = new EventScoresOptions();

            PlayerProfiles = new BinaryDataStore <PlayerMobile, PlayerEventScoreProfile>(
                VitaNexCore.SavesDirectory + "/EventScores", "PlayerProfiles")
            {
                Async         = true,
                OnSerialize   = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
        static EventScores()
        {
            CSOptions = new EventScoresOptions();

            PlayerProfiles = new BinaryDataStore<PlayerMobile, PlayerEventScoreProfile>(
                VitaNexCore.SavesDirectory + "/EventScores", "PlayerProfiles")
            {
                Async = true,
                OnSerialize = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
Example #18
0
		static Notify()
		{
			CSOptions = new CoreServiceOptions(typeof(Notify));

			GumpTypes = typeof(NotifyGump).GetConstructableChildren(t => !t.IsEqualOrChildOf<WorldNotifyGump>());
			WorldGumpSubTypes = typeof(WorldNotifyGump).GetConstructableChildren(t => t.IsNested);

			Settings = new BinaryDataStore<Type, NotifySettings>(VitaNexCore.SavesDirectory + "/Notify", "Settings") {
				OnSerialize = Serialize,
				OnDeserialize = Deserialize
			};
		}
		static PlayerScores()
		{
			CSOptions = new PlayerScoresOptions();

			Registry = new BinaryDataStore<IEntity, Dictionary<Mobile, double>>(
				VitaNexCore.SavesDirectory + "/PlayerScores", "Scores")
			{
				Async = true,
				OnSerialize = SerializeScores,
				OnDeserialize = DeserializePlayerScores
			};
		}
        static PlayerScores()
        {
            CSOptions = new PlayerScoresOptions();

            Registry = new BinaryDataStore <IEntity, Dictionary <Mobile, double> >(
                VitaNexCore.SavesDirectory + "/PlayerScores", "Scores")
            {
                Async         = true,
                OnSerialize   = SerializeScores,
                OnDeserialize = DeserializePlayerScores
            };
        }
Example #21
0
        static Notify()
        {
            CSOptions = new CoreServiceOptions(typeof(Notify));

            GumpTypes         = typeof(NotifyGump).GetConstructableChildren(t => !t.IsEqualOrChildOf <WorldNotifyGump>());
            WorldGumpSubTypes = typeof(WorldNotifyGump).GetConstructableChildren(t => t.IsNested);

            Settings = new BinaryDataStore <Type, NotifySettings>(VitaNexCore.SavesDirectory + "/Notify", "Settings")
            {
                OnSerialize   = Serialize,
                OnDeserialize = Deserialize
            };
        }
Example #22
0
        static DeceitBraziers()
        {
            CMOptions = new CoreModuleOptions(typeof(DeceitBraziers));

            Locations = new List <MapPoint>();
            Spawns    = new List <Type>();

            Registry = new BinaryDataStore <DeceitBrazier, MapPoint>(VitaNexCore.SavesDirectory + "/DeceitBraziers/", "Braziers")
            {
                Async         = true,
                OnSerialize   = Serialize,
                OnDeserialize = Deserialize
            };
        }
		static DeceitBraziers()
		{
			Locations = new List<MapPoint>();
			Spawns = new List<Type>();

			CMOptions = new CoreModuleOptions(typeof(DeceitBraziers));

			Registry = new BinaryDataStore<DeceitBrazier, MapPoint>(VitaNexCore.SavesDirectory + "/DeceitBraziers/", "Braziers")
			{
				Async = true,
				OnSerialize = Serialize,
				OnDeserialize = Deserialize
			};
		}
Example #24
0
		static Toolbars()
		{
			EntryTypes = typeof(ToolbarEntry).GetConstructableChildren();

			CMOptions = new ToolbarsOptions();

			Profiles = new BinaryDataStore<PlayerMobile, ToolbarState>(VitaNexCore.SavesDirectory + "/Toolbars", "States")
			{
				Async = true,
				OnSerialize = Serialize,
				OnDeserialize = Deserialize
			};

			DefaultEntries = new ToolbarState(null, CMOptions.DefaultWidth, CMOptions.DefaultHeight);
		}
Example #25
0
        static Toolbars()
        {
            EntryTypes = typeof(ToolbarEntry).GetConstructableChildren();

            CMOptions = new ToolbarsOptions();

            Profiles = new BinaryDataStore <PlayerMobile, ToolbarState>(VitaNexCore.SavesDirectory + "/Toolbars", "States")
            {
                Async         = true,
                OnSerialize   = Serialize,
                OnDeserialize = Deserialize
            };

            DefaultEntries = new ToolbarState(null, CMOptions.DefaultWidth, CMOptions.DefaultHeight);
        }
Example #26
0
        static Notify()
        {
            CSOptions = new CoreServiceOptions(typeof(Notify));

            GumpTypes = typeof(NotifyGump).GetChildren(t => !t.IsNested);

            NestedTypes = new Dictionary <Type, Type[]>();

            Settings = new BinaryDataStore <Type, NotifySettings>(VitaNexCore.SavesDirectory + "/Notify", "Settings")
            {
                Async         = true,
                OnSerialize   = Serialize,
                OnDeserialize = Deserialize
            };
        }
Example #27
0
		static Notify()
		{
			CSOptions = new CoreServiceOptions(typeof(Notify));
			
			GumpTypes = typeof(NotifyGump).GetChildren(t => !t.IsNested);

			NestedTypes = new Dictionary<Type, Type[]>();

			Settings = new BinaryDataStore<Type, NotifySettings>(VitaNexCore.SavesDirectory + "/Notify", "Settings")
			{
				Async = true,
				OnSerialize = Serialize,
				OnDeserialize = Deserialize
			};
		}
Example #28
0
        static Instances()
        {
            _BounceRestore = new Dictionary <PlayerMobile, MapPoint>(0x100);
            _ItemRestore   = new Dictionary <Item, IEntity>(0x1000);

            CSOptions = new InstanceMapsOptions();

            IndexFile = IOUtility.EnsureFile(VitaNexCore.SavesDirectory + "/InstanceMaps/Maps.idx");

            RestoreFile = IOUtility.EnsureFile(VitaNexCore.CacheDirectory + "/InstanceMaps/Restore.bin");
            RestoreFile.SetHidden(true);

            Lockouts = new BinaryDataStore <PlayerMobile, LockoutState>(VitaNexCore.SavesDirectory + "/InstanceMaps", "Lockouts")
            {
                Async         = true,
                OnSerialize   = SerializeLockouts,
                OnDeserialize = DeserializeLockouts
            };

            Maps = new BinaryDirectoryDataStore <InstanceMapSerial, InstanceMap>(VitaNexCore.SavesDirectory + "/InstanceMaps", "Maps", "bin")
            {
                Async         = true,
                OnSerialize   = SerializeMap,
                OnDeserialize = DeserializeMap
            };

            Dungeons = new BinaryDirectoryDataStore <DungeonSerial, Dungeon>(VitaNexCore.SavesDirectory + "/InstanceMaps", "Dungeons", "bin")
            {
                Async         = true,
                OnSerialize   = SerializeDungeon,
                OnDeserialize = DeserializeDungeon
            };

            DungeonTypes = typeof(Dungeon).GetConstructableChildren();

            var instances = DungeonTypes
                            .Select(t => t.CreateInstanceSafe <Dungeon>())
                            .Where(d => d != null && d.ID != DungeonID.None && d.GroupMax > 0)
                            .Where(d => d.MapParent != null && !(d.MapParent is InstanceMap))
                            .ToList();

            DungeonInfo = instances.Select(d => new DungeonInfo(d)).ToArray();

            instances.ForEach(d => d.Delete());
            instances.Free(true);

            DefragmentTimer = PollTimer.FromMinutes(10.0, Defragment, () => !_Defragmenting, false);
        }
Example #29
0
        static TimeBoosts()
        {
            Minutes = new TimeBoostMinutes[] { 1, 3, 5, 15, 30 };
            Hours   = new TimeBoostHours[] { 1, 3, 6, 12 };

            Times = new[] { Minutes.CastToArray <ITimeBoost>(), Hours.CastToArray <ITimeBoost>() };

            AllTimes = Times.SelectMany(t => t).OrderBy(b => b.Value).ToArray();

            Profiles = new BinaryDataStore <IAccount, TimeBoostProfile>(VitaNexCore.SavesDirectory + "/TimeBoosts", "Profiles")
            {
                Async         = true,
                OnSerialize   = Serialize,
                OnDeserialize = Deserialize
            };
        }
Example #30
0
		static TimeBoosts()
		{
			Minutes = new TimeBoostMinutes[] {1, 3, 5, 15, 30};
			Hours = new TimeBoostHours[] {1, 3, 6, 12};

			Times = new[] {Minutes.CastToArray<ITimeBoost>(), Hours.CastToArray<ITimeBoost>()};

			AllTimes = Times.SelectMany(t => t).OrderBy(b => b.Value).ToArray();

			Profiles = new BinaryDataStore<IAccount, TimeBoostProfile>(VitaNexCore.SavesDirectory + "/TimeBoosts", "Profiles")
			{
				Async = true,
				OnSerialize = Serialize,
				OnDeserialize = Deserialize
			};
		}
Example #31
0
        static SpellCastBars()
        {
            CMOptions = new CastBarsOptions();

            _CastBarQueue = new Queue <PlayerMobile>();

            _InternalTimer = PollTimer.CreateInstance(TimeSpan.FromSeconds(0.1), PollCastBarQueue, _CastBarQueue.Any);

            Instances = new Dictionary <PlayerMobile, SpellCastBar>();

            States = new BinaryDataStore <PlayerMobile, CastBarState>(VitaNexCore.SavesDirectory + "/SpellCastBars", "States")
            {
                Async         = true,
                OnSerialize   = Serialize,
                OnDeserialize = Deserialize
            };
        }
Example #32
0
		static Voting()
		{
			SiteTypes = typeof(IVoteSite).GetConstructableChildren();

			CMOptions = new VotingOptions();

			VoteSites = new BinaryDataStore<int, IVoteSite>(VitaNexCore.SavesDirectory + "/Voting", "Sites") {
				OnSerialize = SerializeVoteSites,
				OnDeserialize = DeserializeVoteSites
			};

			Profiles = new BinaryDataStore<PlayerMobile, VoteProfile>(VitaNexCore.SavesDirectory + "/Voting", "Profiles")
			{
				Async = true,
				OnSerialize = SerializeProfiles,
				OnDeserialize = DeserializeProfiles
			};
		}
Example #33
0
        static WebStats()
        {
            CMOptions = new WebStatsOptions();

            Snapshot = new Dictionary <IPAddress, List <Mobile> >();

            Stats = new BinaryDataStore <string, WebStatsEntry>(VitaNexCore.SavesDirectory + "/WebStats", "Stats")
            {
                Async         = true,
                OnSerialize   = SerializeStats,
                OnDeserialize = DeserializeStats
            };

            _Json = new Dictionary <string, object>();

            var uptime = VitaNexCore.UpTime;

            Stats["uptime"]      = new WebStatsEntry(uptime, false);
            Stats["uptime_peak"] = new WebStatsEntry(uptime, true);

            Stats["online"]      = new WebStatsEntry(0, false);
            Stats["online_max"]  = new WebStatsEntry(0, false);
            Stats["online_peak"] = new WebStatsEntry(0, true);

            Stats["unique"]      = new WebStatsEntry(0, false);
            Stats["unique_max"]  = new WebStatsEntry(0, false);
            Stats["unique_peak"] = new WebStatsEntry(0, true);

            Stats["items"]      = new WebStatsEntry(0, false);
            Stats["items_max"]  = new WebStatsEntry(0, false);
            Stats["items_peak"] = new WebStatsEntry(0, true);

            Stats["mobiles"]      = new WebStatsEntry(0, false);
            Stats["mobiles_max"]  = new WebStatsEntry(0, false);
            Stats["mobiles_peak"] = new WebStatsEntry(0, true);

            Stats["guilds"]      = new WebStatsEntry(0, false);
            Stats["guilds_max"]  = new WebStatsEntry(0, false);
            Stats["guilds_peak"] = new WebStatsEntry(0, true);

            Stats["memory"]      = new WebStatsEntry(0L, false);
            Stats["memory_max"]  = new WebStatsEntry(0L, false);
            Stats["memory_peak"] = new WebStatsEntry(0L, true);
        }
Example #34
0
        static TrashCollection()
        {
            HandlerTypes = typeof(BaseTrashHandler).GetConstructableChildren();

            CMOptions = new TrashCollectionOptions();

            Handlers = new BinaryDataStore <string, BaseTrashHandler>(VitaNexCore.SavesDirectory + "/TrashCollection", "Handlers")
            {
                OnSerialize   = SerializeHandlers,
                OnDeserialize = DeserializeHandlers
            };

            Profiles = new BinaryDataStore <Mobile, TrashProfile>(VitaNexCore.SavesDirectory + "/TrashCollection", "Profiles")
            {
                Async         = true,
                OnSerialize   = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };
        }
Example #35
0
		static TrashCollection()
		{
			HandlerTypes = typeof(BaseTrashHandler).GetConstructableChildren();

			CMOptions = new TrashCollectionOptions();

			Handlers = new BinaryDataStore<string, BaseTrashHandler>(VitaNexCore.SavesDirectory + "/TrashCollection", "Handlers")
			{
				OnSerialize = SerializeHandlers,
				OnDeserialize = DeserializeHandlers
			};

			Profiles = new BinaryDataStore<Mobile, TrashProfile>(VitaNexCore.SavesDirectory + "/TrashCollection", "Profiles")
			{
				Async = true,
				OnSerialize = SerializeProfiles,
				OnDeserialize = DeserializeProfiles
			};
		}
Example #36
0
        static Voting()
        {
            SiteTypes = typeof(IVoteSite).GetConstructableChildren();

            CMOptions = new VotingOptions();

            VoteSites = new BinaryDataStore <int, IVoteSite>(VitaNexCore.SavesDirectory + "/Voting", "Sites")
            {
                OnSerialize   = SerializeVoteSites,
                OnDeserialize = DeserializeVoteSites
            };

            Profiles = new BinaryDataStore <PlayerMobile, VoteProfile>(VitaNexCore.SavesDirectory + "/Voting", "Profiles")
            {
                Async         = true,
                OnSerialize   = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };
        }
        static EventInvasions()
        {
            CSOptions = new EventInvasionsOptions();

            Invasions = new BinaryDataStore<InvasionSerial, Invasion>(
                VitaNexCore.SavesDirectory + "/EventInvasions", "Invasions")
            {
                Async = true,
                OnSerialize = SerializeInvasions,
                OnDeserialize = DeserializeInvasions
            };

            PlayerProfiles = new BinaryDataStore<PlayerMobile, PlayerInvasionProfile>(
                VitaNexCore.SavesDirectory + "/EventInvasions", "PlayerProfiles")
            {
                Async = true,
                OnSerialize = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
Example #38
0
        static Conquests()
        {
            ConquestTypes             = typeof(Conquest).GetConstructableChildren();
            ConquestCompleteGumpTypes = typeof(ConquestCompletedGump).GetConstructableChildren();

            ConquestRegistry = new BinaryDataStore <ConquestSerial, Conquest>(
                VitaNexCore.SavesDirectory + "Conquests", "Conquests")
            {
                OnSerialize   = SerializeConquestRegistry,
                OnDeserialize = DeserializeConquestRegistry
            };

            Profiles = new BinaryDataStore <PlayerMobile, ConquestProfile>(VitaNexCore.SavesDirectory + "Conquests",
                                                                           "Profiles")
            {
                Async         = true,
                OnSerialize   = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };
        }
Example #39
0
        static Conquests()
        {
            ConquestTypes = typeof(Conquest).GetConstructableChildren();
            ConquestCompleteGumpTypes = typeof(ConquestCompletedGump).GetConstructableChildren();

            ConquestRegistry = new BinaryDataStore<ConquestSerial, Conquest>(
                VitaNexCore.SavesDirectory + "Conquests", "Conquests")
            {
                OnSerialize = SerializeConquestRegistry,
                OnDeserialize = DeserializeConquestRegistry
            };

            Profiles = new BinaryDataStore<PlayerMobile, ConquestProfile>(VitaNexCore.SavesDirectory + "Conquests",
                "Profiles")
            {
                Async = true,
                OnSerialize = SerializeProfiles,
                OnDeserialize = DeserializeProfiles
            };
        }
Example #40
0
        static ZombieEvent()
        {
            CSOptions = new ZombieEventOptions();

            ZombieEvents = new BinaryDataStore <ZombieInstanceSerial, ZombieInstance>(
                VitaNexCore.SavesDirectory + "/Zombies", "ZombieInstances")
            {
                Async         = true,
                OnSerialize   = SerializeZombieEvent,
                OnDeserialize = DeserializeZombieEvent
            };

            PlayerProfiles = new BinaryDataStore <PlayerMobile, PlayerZombieProfile>(
                VitaNexCore.SavesDirectory + "/Zombies", "PlayerProfiles")
            {
                Async         = true,
                OnSerialize   = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
        static ZombieEvent()
        {
            CSOptions = new ZombieEventOptions();

            ZombieEvents = new BinaryDataStore<ZombieInstanceSerial, ZombieInstance>(
                VitaNexCore.SavesDirectory + "/Zombies", "ZombieInstances")
            {
                Async = true,
                OnSerialize = SerializeZombieEvent,
                OnDeserialize = DeserializeZombieEvent
            };

            PlayerProfiles = new BinaryDataStore<PlayerMobile, PlayerZombieProfile>(
                VitaNexCore.SavesDirectory + "/Zombies", "PlayerProfiles")
            {
                Async = true,
                OnSerialize = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
Example #42
0
        static Portals()
        {
            CSOptions = new PortalsOptions();

            PortalList = new BinaryDataStore <PortalSerial, Portal>(
                VitaNexCore.SavesDirectory + "/Portals", "PortalsList")
            {
                Async         = true,
                OnSerialize   = SerializePortals,
                OnDeserialize = DeserializePortals
            };

            PlayerProfiles = new BinaryDataStore <PlayerMobile, PlayerPortalProfile>(
                VitaNexCore.SavesDirectory + "/Portals", "PlayerProfiles")
            {
                Async         = true,
                OnSerialize   = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
Example #43
0
        static EventInvasions()
        {
            CSOptions = new EventInvasionsOptions();

            Invasions = new BinaryDataStore <InvasionSerial, Invasion>(
                VitaNexCore.SavesDirectory + "/EventInvasions", "Invasions")
            {
                Async         = true,
                OnSerialize   = SerializeInvasions,
                OnDeserialize = DeserializeInvasions
            };

            PlayerProfiles = new BinaryDataStore <PlayerMobile, PlayerInvasionProfile>(
                VitaNexCore.SavesDirectory + "/EventInvasions", "PlayerProfiles")
            {
                Async         = true,
                OnSerialize   = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
Example #44
0
        static Portals()
        {
            CSOptions = new PortalsOptions();

            PortalList = new BinaryDataStore<PortalSerial, Portal>(
                VitaNexCore.SavesDirectory + "/Portals", "PortalsList")
            {
                Async = true,
                OnSerialize = SerializePortals,
                OnDeserialize = DeserializePortals
            };

            PlayerProfiles = new BinaryDataStore<PlayerMobile, PlayerPortalProfile>(
                VitaNexCore.SavesDirectory + "/Portals", "PlayerProfiles")
            {
                Async = true,
                OnSerialize = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };
        }
Example #45
0
        static CentralGump()
        {
            CSOptions = new CentralGumpOptions();

            PlayerProfiles = new BinaryDataStore <PlayerMobile, CentralGumpProfile>(
                VitaNexCore.SavesDirectory + "/CentralGump", "PlayerProfiles")
            {
                Async         = true,
                OnSerialize   = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };

            Adventurers = new List <PlayerMobile>();

            Messages = new XmlDataStore <string, Message>(
                VitaNexCore.SavesDirectory + "/CentralGump", "NewsMessages")
            {
                OnSerialize   = SerializeMessages,
                OnDeserialize = DeserializeMessages
            };
        }
Example #46
0
        static AutoDonate()
        {
            CMOptions = new DonationOptions();

            Transactions = new BinaryDataStore <string, DonationTransaction>(
                VitaNexCore.SavesDirectory + "/AutoDonate",
                "Transactions")
            {
                OnSerialize   = SerializeTransactions,
                OnDeserialize = DeserializeTransactions
            };

            Profiles = new BinaryDirectoryDataStore <IAccount, DonationProfile>(
                VitaNexCore.SavesDirectory + "/AutoDonate",
                "Profiles",
                "pro")
            {
                OnSerialize   = SerializeProfile,
                OnDeserialize = DeserializeProfile
            };
        }
Example #47
0
		static AutoDonate()
		{
			CMOptions = new DonationOptions();

			Transactions = new BinaryDataStore<string, DonationTransaction>(
				VitaNexCore.SavesDirectory + "/AutoDonate",
				"Transactions")
			{
				OnSerialize = SerializeTransactions,
				OnDeserialize = DeserializeTransactions
			};

			Profiles = new BinaryDirectoryDataStore<IAccount, DonationProfile>(
				VitaNexCore.SavesDirectory + "/AutoDonate",
				"Profiles",
				"pro")
			{
				OnSerialize = SerializeProfiles,
				OnDeserialize = DeserializeProfiles
			};
		}
        static CentralGump()
        {
            CSOptions = new CentralGumpOptions();

            PlayerProfiles = new BinaryDataStore<PlayerMobile, CentralGumpProfile>(
                VitaNexCore.SavesDirectory + "/CentralGump", "PlayerProfiles")
            {
                Async = true,
                OnSerialize = SerializePlayerProfiles,
                OnDeserialize = DeserializePlayerProfiles
            };

            Adventurers = new List<PlayerMobile>();

            Messages = new XmlDataStore<string, Message>(
                VitaNexCore.SavesDirectory + "/CentralGump", "NewsMessages")
            {
                OnSerialize = SerializeMessages,
                OnDeserialize = DeserializeMessages
            };
        }