public CombatProcessContainer()
 {
     AttackList = new CacheList<CombatEmbattle>();
     DefenseList = new CacheList<CombatEmbattle>();
     ProcessList = new CacheList<CombatProcess>();
     SelfAbilityEffectList = new CacheList<SelfAbilityEffect>();
 }

 public UserDailyRestrain()
     : base(AccessLevel.ReadWrite)
 {
     UserExtend = new DailyUserExtend();
     FunPlot = new CacheList<FunPlot>();
     PlainPlotList = new CacheList<FunPlot>();
 }

 /// <summary>
 /// 每日限制次数
 /// </summary>
 /// <returns></returns>
 public static int GetVipUseNum(int vipLv, RestrainType restrainType)
 {
     int rType = (int)restrainType;
     int baseNum = 0;
     int MaxNum = 0;
     int vipNum = 0;
     DailyRestrainSet restrainSet = new ShareCacheStruct<DailyRestrainSet>().FindKey(restrainType);
     if (restrainSet != null)
     {
         baseNum = restrainSet.MaxNum;
     }
     VipLvInfo lvInfo = new ConfigCacheSet<VipLvInfo>().FindKey(vipLv);
     var restrainArray = new CacheList<DailyRestrain>();
     if (lvInfo != null)
     {
         restrainArray = lvInfo.DailyRestrain;
     }
     foreach (DailyRestrain daily in restrainArray)
     {
         if (daily.ID == rType)
         {
             vipNum = daily.Num;
         }
     }
     MaxNum = MathUtils.Addition(baseNum, vipNum, int.MaxValue);
     return MaxNum;
 }

 public GeneralInfo()
     : base(AccessLevel.ReadOnly)
 {
     ShowFilter = new CacheList<ShowFilterInfo>(0, true);
     RecruitFilter = new CacheList<RecruitFilter>(0, true);
     Mature = new CacheList<GeneralProperty>(0, true);
 }

 public UserGuild()
     : base(AccessLevel.ReadWrite)
 {
     GuildBossInfo = new GuildBossInfo();
     AbilityInfo = new CacheList<GuildAbility>();
     GuildExercise = new GuildExercise();
 }

 public FestivalInfo()
     : base(AccessLevel.ReadWrite)
 {
     Reward = new CacheList<PrizeInfo>();
     TimePriod = new TimePriod();
     TaskConfig = new CacheList<TaskConfigInfo>();
     FestivalExtend = new FestivalExtend();
 }

 public static string GetGeneralQuality(CacheList<RecruitInfo> _generalQuality)
 {
     string genquality = string.Empty;
     foreach (var quality in _generalQuality)
     {
         genquality += quality.Quality.ToInt() + ",";
     }
     return genquality.TrimEnd(',');
 }

 public StoryTaskInfo()
     : base(AccessLevel.ReadOnly)
 {
     ReleaseDialogue = new CacheList<DialogueInfo>(0, true);
     TakedDialogue = new CacheList<DialogueInfo>(0, true);
     DeliveryDialogue = new CacheList<DialogueInfo>(0, true);
     PreTaskID = new int[0];
     Reward = new CacheList<PrizeInfo>(0, true);
 }

 public DailyUserExtend():base(false)
 {
     KalpaPlot = new CacheList<FunPlot>();
     LastKalpaPlot = new CacheList<FunPlot>();
     MorePlot = new CacheList<FunPlot>();
     HeroPlot = new List<HeroPlot>();
     WaterNum = new List<DailyRestrain>();
     //待确认，事件绑定
 }

        public static int festId = 1012; //��ֵ����ID

        public GameUser()
            : base(AccessLevel.ReadWrite)
        {
            UserExtend = new GameUserExtend();
            GrayCrystalList = new CacheList<GrayCrystal>();
            SportsCombatQueue = new CacheQueue<SportsCombat>();
            PropertyInfo = new CacheList<GuildAbility>();
            HeritageList = new CacheList<GeneralHeritage>();
            SweepPool = new SweepPoolInfo();
            OpenFun = new List<UserFunction>();
        }

 /// <summary>
 /// </summary>
 public UserPlotPackage(String UserID)
     : this()
 {
     this._UserID = UserID;
     PlotPackage = new CacheList<UserPlotInfo>
                       {
                           new UserPlotInfo(){PlotID = 1222, BossChallengeCount = 5},
                           new UserPlotInfo(){PlotID = 1223, BossChallengeCount = 5},
                           new UserPlotInfo(){PlotID = 1224, BossChallengeCount = 5}
                       };
 }

 public MapReduceQuery(Node n, CacheList cl): base(n) {
   _cl = cl;
   _mut = new Mutable<MRQState>(new MRQState());
   //Add the default query handlers:
   AddQueryMatcher("regex", delegate(object pattern) {
                              return new RegexMatcher((string)pattern);
                            });
   AddQueryMatcher("exact", delegate(object pattern) { return new ExactMatcher(pattern); });
   AddHitCombiner("concat", delegate(object arg) { return ConcatCombiner.Instance; });
   AddHitCombiner("maxcount", delegate(object arg) { return new MaxCountCombiner((int)arg); });
 }

 public static Caches GetCaches()
 {
     Cache _cache = HttpRuntime.Cache;
     IDictionaryEnumerator cacheEnum = _cache.GetEnumerator();
     CacheList cl = new CacheList();
     cl = new CacheList();
     while (cacheEnum.MoveNext())
     {
         cl.Add(new CacheInfo(cacheEnum.Key.ToString(), cacheEnum.Value.GetType().ToString()));
     }
     Caches rs = new Caches();
     rs.CacheList = new CacheList();
     cl.SortBy(CacheInfo.Columns.Key, true);
     rs.CacheList.AddRange(cl);
     rs.Total = cl.Count;
     return rs;
 }

		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public void Awake() {
			var sett = new InputSettings();
			sett.InputTransform = gameObject.transform;
			sett.CameraTransform = HeadsetCameraTransform;
			sett.CursorSize = CursorSize;
			sett.UseMouseForTesting = UseMouseForTesting;
			sett.MousePositionMultiplier = MousePositionMultiplier;
			
			if ( HeadsetCameraTransform == null ) {
				IsFailure = true;
				throw new Exception("The "+typeof(HovercursorLookInput)+" component "+
					"requires the 'Headset Camera Transform' to be set.");
			}

			vCursor = new InputCursor(CursorType.Look, sett);
			vPlaneStates = new CacheList<PlaneState>();
		}

 /// <summary>
 /// 新增装备合成log
 /// </summary>
 /// <param name="userID"></param>
 /// <param name="opType"></param>
 /// <param name="itemID"></param>
 /// <param name="num"></param>
 /// <param name="synthesisInfo1"></param>
 /// <param name="synthesisInfo2"></param>
 /// <param name="useGold"></param>
 /// <param name="beforeLv"></param>
 /// <param name="afterLv"></param>
 public static void AppenItemSynthesisLog(string userID, short opType, int itemID, int num, CacheList<SynthesisInfo> synthesisInfo1, SynthesisInfo synthesisInfo2, int useGold, short beforeLv, short afterLv)
 {
     UserItemSynthesisLog log = new UserItemSynthesisLog
       {
           ID = Guid.NewGuid().ToString(),
           UserID = userID,
           OpType = opType,
           ItemID = itemID,
           OpNum = num,
           DemandMaterial = synthesisInfo1,
           SurplusMaterial = synthesisInfo2,
           UseGold = useGold,
           BeforeLv = beforeLv,
           AfterLv = afterLv,
           CreateDate = DateTime.Now
       };
     var sender = DataSyncManager.GetDataSender();
     sender.Send(log);
 }

        /// <summary>
        /// 玩家命运水晶log
        /// </summary>
        /// <param name="userID"></param>
        /// <param name="opType"></param>
        /// <param name="sumNum"></param>
        /// <param name="opNum"></param>
        /// <param name="useGold"></param>
        /// <param name="surplusGold"></param>
        /// <param name="totalGold"></param>
        public static void AppenCtystalLog(string userID, short opType, int crystalID, int coinNum, int useGold, CacheList<SynthesisInfo> synthesisInfo, short crystalLv, int exp)
        {
            UserCrystalLog log = new UserCrystalLog()
            {
                ID = Guid.NewGuid().ToString(),
                UserID = userID,
                OpType = opType,
                CrystalID = crystalID,
                CoinNum = coinNum,
                UseGold = useGold,
                SynthesisCrystal = synthesisInfo,
                CrystalLv = crystalLv,
                Experience = exp,
                CreateDate = DateTime.Now
            };

            var sender = DataSyncManager.GetDataSender();
            sender.Send(log);
        }

 public static void GuildFightCombatUserList()
 {
     _fightUserList = new CacheList<FightUser>();
     var fightList = new ShareCacheStruct<ServerFight>().FindAll(m => m.FastID == info.FastID);
     foreach (ServerFight fight in fightList)
     {
         if (string.IsNullOrEmpty(fight.CombatMember))
         {
             continue;
         }
         string[] strList = fight.CombatMember.Split(',');
         foreach (string s in strList)
         {
             if (string.IsNullOrEmpty(s))
             {
                 continue;
             }
             var FightStatusUser = _fightUserList.Find(m => !m.IsRemove && m.UserId == s);
             if (FightStatusUser != null)
             {
                 continue;
             }
             FightUser fightUser = new FightUser();
             fightUser.GuildID = fight.GuildID;
             fightUser.UserId = s;
             GameUser user = UserCacheGlobal.CheckLoadUser(s);
             if (user != null)
             {
                 fightUser.UserName = user.NickName;
                 user.UserStatus = UserStatus.FightCombat;
             }
             fightUser.WinCount = 0;
             fightUser.CityID = fight.CityID;
             fightUser.ObtainNum = 0;
             fightUser.InspirePercent = 0;
             fightUser.IsRemove = false;
             fightUser.IsNotEnough = false;
             _fightUserList.Add(fightUser);
         }
     }
 }

        static void Main(string[] args)
        {
            try
            {
                var dict = new CacheList<int>();
                dict.Add(1);
                string js = dict.ToJson();
                var temp = js.ParseJson<CacheList<int>>();
                if(temp == null)
                {

                }
                GameServerListManager.Initialize();
                var server = new GameProxy();
                Console.WriteLine("Press Enter to exit...");
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                TraceLog.WriteError("Main error:{0}", ex);
            }
        }

 /// <summary>
 /// 获取奖励
 /// </summary>
 /// <param name="List"></param>
 /// <returns></returns>
 public static CacheList<PrizeInfo> GetPrizeInfo(CacheList<PrizeInfo> List)
 {
     if (List[0].Reward == 1)
     {
         return new CacheList<PrizeInfo> { List[RandomUtils.GetRandom(0, List.Count)] };
     }
     else if (List[0].Reward == 2)
     {
         CacheList<PrizeInfo> prizeInfosArray = List;
         double[] probability = new double[prizeInfosArray.Count];
         for (int i = 0; i < prizeInfosArray.Count; i++)
         {
             probability[i] = (double)prizeInfosArray[i].Probability;
         }
         int index2 = RandomUtils.GetHitIndex(probability);
         return new CacheList<PrizeInfo> { prizeInfosArray[index2] };
     }
     else if (List[0].Reward == 3)
     {
         return List;
     }
     return new CacheList<PrizeInfo>();
 }

        public override bool TakeAction()
        {
            var package = UserCrystalPackage.Get(Uid);
            if (ops == 1)
            {
                UserCrystalInfo userCryStal1 = package.CrystalPackage.Find(m => m.UserCrystalID.Equals(userCrystalID1));
                UserCrystalInfo userCryStal2 = package.CrystalPackage.Find(m => m.UserCrystalID.Equals(userCrystalID2));
                // UserCrystal userCryStal1 = UserCrystal.FindKey(userCrystalID1);
                //UserCrystal userCryStal2 = UserCrystal.FindKey(userCrystalID2);
                if (userCryStal1 == null || userCryStal2 == null)
                {
                    ErrorCode = LanguageManager.GetLang().ErrorCode;
                    ErrorInfo = LanguageManager.GetLang().St1308_CrystalNotEnough;
                    return false;
                }
                if (userCryStal1.CrystalLv > 9)
                {
                    ErrorCode = LanguageManager.GetLang().ErrorCode;
                    ErrorInfo = LanguageManager.GetLang().St1308_CrystalLvFull;
                    return false;
                }

                CrystalInfo crystalInfo1 = new ShareCacheStruct<CrystalInfo>().FindKey(userCryStal1.CrystalID);
                CrystalInfo crystalInfo2 = new ShareCacheStruct<CrystalInfo>().FindKey(userCryStal2.CrystalID);
                int cryExprience1 = 0;
                int cryExprience2 = 0;
                if (crystalInfo1 != null && crystalInfo2 != null)
                {
                    cryExprience1 = crystalInfo1.Experience;
                    cryExprience2 = crystalInfo2.Experience;

                    if (crystalInfo1.CrystalQuality == crystalInfo2.CrystalQuality)
                    {
                        if (userCryStal1.CurrExprience >= userCryStal2.CurrExprience)
                        {
                            UpdateCrystal(userCrystalID1, userCrystalID2, cryExprience2);
                        }
                        else
                        {
                            UpdateCrystal(userCrystalID2, userCrystalID1, cryExprience1);
                        }
                    }
                    else if (crystalInfo1.CrystalQuality > crystalInfo2.CrystalQuality)
                    {
                        UpdateCrystal(userCrystalID1, userCrystalID2, cryExprience2);
                    }
                    else
                    {
                        UpdateCrystal(userCrystalID2, userCrystalID1, cryExprience1);
                    }

                }
            }
            else if (ops == 2)
            {
                CacheList<SynthesisInfo> SynList = new CacheList<SynthesisInfo>();
                int experience = 0;
                var userCrystalArray = package.CrystalPackage.FindAll(m => m.IsSale == 2 && m.GeneralID.Equals(0));
                if (userCrystalArray.Count == 0)
                {
                    ErrorCode = LanguageManager.GetLang().ErrorCode;
                    ErrorInfo = LanguageManager.GetLang().St1308_CrystalNotEnough;
                    return false;
                }
                userCrystalArray.QuickSort((x, y) =>
                {
                    int result = 0;
                    if (x == null && y == null) return 0;
                    if (x != null && y == null) return 1;
                    if (x == null) return -1;
                    result = (int)new ShareCacheStruct<CrystalInfo>().FindKey(y.CrystalID).CrystalQuality.CompareTo(
                        new ShareCacheStruct<CrystalInfo>().FindKey(x.CrystalID).CrystalQuality);
                    if (result == 0)
                    {
                        result = y.CurrExprience.CompareTo(x.CurrExprience);
                    }
                    return result;
                });

                UserCrystalInfo userCrystal1 =
                    package.CrystalPackage.Find(m => m.UserCrystalID == userCrystalArray[0].UserCrystalID);
                int maxExprience = 0;
                if (userCrystal1 == null)
                {
                    ErrorCode = LanguageManager.GetLang().ErrorCode;
                    ErrorInfo = LanguageManager.GetLang().St1308_CrystalNotEnough;
                    return false;
                }
                short upLv = 10;
                CrystalLvInfo crystalLvInfo = new ShareCacheStruct<CrystalLvInfo>().FindKey(userCrystal1.CrystalID, upLv);
                maxExprience = crystalLvInfo == null ? 0 : crystalLvInfo.UpExperience;


                foreach (UserCrystalInfo crystal in userCrystalArray)
                {
                    CrystalInfo crystalInfo = new ShareCacheStruct<CrystalInfo>().FindKey(crystal.CrystalID);
                    if (crystalInfo != null)
                    {
                        experience = crystalInfo.Experience;
                    }
//.........这里部分代码省略.........