public static bool EmptyExpansionExists(Expansion expansion)
 {
     if (expansion is NonTerminal)
         return ((NonTerminal) expansion).Production.IsEmptyPossible;
     else if (expansion is Action)
         return true;
     else if (expansion is RegularExpression)
         return false;
     else if (expansion is OneOrMore)
         return EmptyExpansionExists(((OneOrMore) expansion).Expansion);
     else if (expansion is ZeroOrMore || expansion is ZeroOrOne)
         return true;
     else if (expansion is Lookahead)
         return true;
     else if (expansion is Choice) {
         foreach (var choice in ((Choice) expansion).Choices) {
             if (EmptyExpansionExists(choice))
                 return true;
         }
         return false;
     } else if (expansion is Sequence) {
         foreach (var unit in ((Sequence) expansion).Units) {
             if (!EmptyExpansionExists(unit))
                 return false;
         }
         return true;
     } else if (expansion is TryBlock)
         return EmptyExpansionExists(((TryBlock) expansion).Expansion);
     else
         return false; // This should be dead code.
 }

        private void EnsureLoaded()
        {
            using (new ReaderLock(_lock))
            {
                if (_loaded) return;

                using (new WriterLock(_lock))
                {
                    if (_loaded) return;

                    if (null == _cache)
                        _cache = new List<Expansion>();

                    Connection.ExecuteSql(new Query(EXPANSION_SELECT), delegate(SqlDataReader reader)
                    {
                        while (reader.Read())
                        {
                            if (null != _cache.Find(c => reader[0].ToString() == c.Name))
                                return;

                            var newExpansion = new Expansion()
                            {
                                Name = reader[0].ToString()
                            };

                            _cache.Add(newExpansion);
                        }
                    });

                    _loaded = true;
                }
            }
        }

		public static void RegisterMap(
			int mapIndex, int mapID, int fileIndex, int width, int height, Season season, Expansion ex, string name, MapRules rules)
		{
			var newMap = new Map(mapID, mapIndex, fileIndex, width, height, season.GetID(), ex, name, rules);

			Map.Maps[mapIndex] = newMap;
			Map.AllMaps.Add(newMap);
		}

		public HarvestVein(Expansion reqExpansion, double veinChance, double chanceToFallback, HarvestResource primaryResource, HarvestResource fallbackResource )
		{
			ReqExpansion = reqExpansion;
			VeinChance = veinChance;
			ChanceToFallback = chanceToFallback;
			PrimaryResource = primaryResource;
			FallbackResource = fallbackResource;
		}

		public RewardEntry( RewardCategory category, int name, Type itemType, params object[] args )
		{
			m_Category = category;
			m_ItemType = itemType;
			m_RequiredExpansion = Expansion.None;
			m_Name = name;
			m_Args = args;
			category.Entries.Add( this );
		}

		public HarvestResource( Expansion reqExpansion, double reqSkill, double minSkill, double maxSkill, object message, params Type[] types )
		{
			ReqExpansion = reqExpansion;
			ReqSkill = reqSkill;
			MinSkill = minSkill;
			MaxSkill = maxSkill;
			Types = types;
			SuccessMessage = message;
		}

		protected override void OnExpansionChanged(Expansion old)
		{
			base.OnExpansionChanged(old);

			if (EraML)
			{
				Stackable = true;
			}
		}

		private static Item MakeNewbie(Item item, Expansion e)
		{
			if (e < Expansion.AOS)
			{
				item.LootType = LootType.Newbied;
			}

			return item;
		}

 public static void LoadExpansion(string name, Expansion expansion)
 {
     expansions.Add(name, expansion);
     foreach (var card in expansion.CardSet)
     {
         card.Id = cardSet.Count;
         cardSet.Add(card);
     }
 }

		public BonusHarvestResource(Expansion reqExpansion, double reqSkill, double chance, TextDefinition message, Type type)
		{
			ReqExpansion = reqExpansion;
			ReqSkill = reqSkill;

			Chance = chance;
			Type = type;
			SuccessMessage = message;
		}

		protected override void OnExpansionChanged(Expansion old)
		{
			base.OnExpansionChanged(old);

			if (0.3 > Utility.RandomDouble())
			{
				PackItem(Loot.RandomPossibleReagent(Expansion));
			}
		}

		protected override void OnExpansionChanged(Expansion old)
		{
			base.OnExpansionChanged(old);

			if (Expansion == Expansion.T2A)
			{
				ReplaceWith(new Silver(Amount));
			}
		}

		public BankBox(Mobile owner, Expansion e)
			: base(0xE7C)
		{
			Owner = owner;
			Expansion = e;

			Movable = false;
			Layer = Layer.Bank;
		}

		protected override void OnExpansionChanged(Expansion old)
		{
			base.OnExpansionChanged(old);

			if (EraML)
			{
				Charges = Utility.RandomMinMax(1, 109);
			}
		}

        public static async Task SetPlayerExpansion(string username, Expansion exp)
        {

            if (_tcm.Online)
                await GetClient().SendMessage(TCCommand.SetPlayerExpansion.BuildCommand(username, ((int)exp).ToString()));
            else
                await _tcm.AuthDatabase.ChangeAccountExpansion(username, exp);


        }

        /// <summary>
        /// Modify an account
        /// </summary>
        /// <param name="id">The id of the account</param>
        /// <param name="username">The new username for the account</param>
        /// <param name="password">The new password for the account</param>
        /// <param name="email">The new email for the account</param>
        /// <param name="lvl">The new GM level for the account</param>
        /// <param name="exp">The new expansion for the account</param>
        /// <returns>An awaitable Task object</returns>
        public async Task EditAccount(int id, string username, string password, string email, GMLevel lvl, Expansion exp)
        {

            await ExecuteNonQuery("UPDATE `account` SET [email protected], [email protected], [email protected], [email protected] WHERE [email protected]",
                new MySqlParameter("@username", username), new MySqlParameter("@hash", String.Format("{0}:{1}", username.ToUpper(), password.ToUpper()).ToSHA1()),
                new MySqlParameter("@expansion", (int)exp), new MySqlParameter("@email", email), new MySqlParameter("@id", id));

            await ExecuteNonQuery("UPDATE `account_access` SET [email protected] WHERE id = @id", new MySqlParameter("@gmlevel", (int)lvl), new MySqlParameter("@id", id));

        }

		protected override void OnExpansionChanged(Expansion old)
		{
			base.OnExpansionChanged(old);

			if (m_Chest == null || m_Filled)
			{
				return;
			}

			TreasureMapChest.Fill(m_Chest, 2, Expansion);
			m_Filled = true;
		}

 public static void reInit()
 {
     ostr = null;
     gensymindex = 0;
     indentamt = 0;
     cc2LA = false;
     phase2list = new List<Lookahead>();
     phase3list = new List<Phase3Data>();
     phase3table = new Dictionary<Expansion, Phase3Data>();
     firstSet = null;
     xsp_declared = false;
     cc3_expansion = null;
 }

 private Account(int id, string username, string reg_mail, string email, DateTime joindate, string last_ip, int failed_logins, DateTime last_login, bool online, Expansion expansion, bool locked)
 {
     this.id = id;
     this.username = username;
     this.reg_mail = reg_mail;
     this.email = email;
     this.joindate = joindate;
     this.last_ip = last_ip;
     this.failed_logins = failed_logins;
     this.last_login = last_login;
     this.online = online;
     this.expansion = expansion;
     this.locked = locked;
 }

		protected override void OnExpansionChanged(Expansion old)
		{
			base.OnExpansionChanged(old);

			if (EraSE)
			{
				SetHits(140);
				ControlSlots = 2;
			}
			else
			{
				SetHits(500);
				ControlSlots = 1;
			}
		}