C# UserNote.Call方法代码示例

        /// <summary>
        /// 领取奖励
        /// </summary>
        /// <param name="note"></param>
        public static void BossAward(UserNote note)
        {
            string fid = note.Player.Family.Value.GetStringOrDefault("FamilyID");
            if (string.IsNullOrEmpty(fid))
            {
                note.Call(FamilyCommand.BossAwardR, false, TipManager.GetMessage(FamilyReturn.NoAddFamily));
                return;
            }

            string bid = note.GetString(0);
            var p = GameConfigAccess.Instance.FindOneById(bid);
            if (p == null)
            {
                return;
            }

            string gid = note.GetString(1); //FamilyBossAccess.Instance.ViewAward(fid + bid, note.Player.ID);
            if (string.IsNullOrEmpty(gid))
            {
                return;
            }

            string[] tt = gid.Split('$');
            int number = 1;
            if (tt.Length != 2 || (!int.TryParse(tt[1], out number)))
            {
                number = 1;
            }
            string goodsid = tt[0];

            //TODO:检查包袱
            Dictionary<string, Variant> goods = new Dictionary<string, Variant>();
            Variant tmp = new Variant();
            tmp.Add("Number1", number);
            goods.Add(goodsid, tmp);
            if (BurdenManager.GetBurdenSpace(note.Player.B0.Value.GetValue<IList>("C")) == null)
            {
                note.Call(FamilyCommand.BossAwardR, false, TipManager.GetMessage(ActivityReturn.SignAward4));
                return;
            }

            //if (BurdenManager.IsFullBurden(note.Player.B0, goods))
            //{
            //    note.Call(FamilyCommand.BossAwardR, false, TipManager.GetMessage(ActivityReturn.SignAward4));
            //    return;
            //}

            if (FamilyBossAccess.Instance.GetAward(fid + bid, note.Player.ID, gid))
            {
                //发放物品
                note.Player.AddGoods(goods, GoodsSource.FamilyBoss);
                note.Call(FamilyCommand.BossAwardR, true, gid);
            }
            else
            {
                //已领取..
                note.Call(FamilyCommand.BossAwardR, false, TipManager.GetMessage(FamilyReturn.CannotBossAward));
            }
        }

        /// <summary>
        /// 添加好友
        /// </summary>
        /// <param name="note"></param>
        public static void AddFriends(UserNote note)
        {
            string name = note.GetString(0);
            if (note.Player.Name == name)
            {
                return;
            }
            PlayerEx social = note.Player.Social;
            if (social == null)
            {
                note.Call(SocialCommand.AddFriendsR, false, TipManager.GetMessage(SocialReturn.UserInfoError));
                return;
            }

            PlayerBusiness player = PlayersProxy.FindPlayerByName(name);
            if (player == null)
            {
                note.Call(SocialCommand.AddFriendsR, false, TipManager.GetMessage(SocialReturn.UserInfoError));
                return;
            }

            if (social.Value != null)
            {
                if (SocialBusiness.IsLet(social, player.ID, new List<string> { "Friends" }))
                {
                    note.Call(SocialCommand.AddFriendsR, false, TipManager.GetMessage(SocialReturn.Friends));
                    return;
                }

                if (SocialBusiness.IsLet(social, player.ID, new List<string> { "Enemy" }))
                {
                    note.Call(SocialCommand.AddFriendsR, false, TipManager.GetMessage(SocialReturn.Master));
                    return;
                }
            }

            Variant v = new Variant();
            v.Add("PlayerID", player.ID);
            v.Add("Created", DateTime.UtcNow);
            IList list = social.Value.GetValue<IList>("Friends");
            int num = 0;
            if (list == null)
            {
                social.Value["Friends"] = new List<Variant>() { v };
                num = 1;
            }
            else
            {
                list.Add(v);
                num = list.Count;
            }
            social.Save();

            note.Call(SocialCommand.AddFriendsR, true, new PlayerSimple(player, 3));

            //添加好友
            note.Player.FinishNote(FinishCommand.Friends, num);
        }

        /// <summary>
        /// 申请交易
        /// </summary>
        /// <param name="note"></param>
        public static void DealApply(UserNote note)
        {
            string playerid = note.GetString(0);

            if (note.Player.Value.ContainsKey("Deal"))
            {
                note.Call(DealCommand.DealApplyR, false, TipManager.GetMessage(DealReturn.DealOther));
                return;
            }
            PlayerBusiness OnlineBusiness = PlayersProxy.FindPlayerByID(playerid);
            if (OnlineBusiness == null || (!OnlineBusiness.Online))
            {
                note.Call(DealCommand.DealApplyR, false, TipManager.GetMessage(DealReturn.NoLine));
                return;
            }

            if (OnlineBusiness.AState == ActionState.Fight)
            {
                note.Call(DealCommand.DealApplyR, false, TipManager.GetMessage(DealReturn.Fighting));
                return;
            }

            if (OnlineBusiness.Value.ContainsKey("Deal"))
            {
                Variant dy = OnlineBusiness.Value.GetVariantOrDefault("Deal");
                if (dy.GetIntOrDefault("Status") >= 0)
                {
                    note.Call(DealCommand.DealApplyR, false, TipManager.GetMessage(DealReturn.DealOther));
                    return;
                }
            }

            Variant d0 = new Variant();
            d0.Add("Status", 0);
            d0.Add("PlayerID", playerid);//被邀请者
            d0.Add("Goods", null);
            if (!note.Player.Value.ContainsKey("Deal"))
                note.Player.Value.Add("Deal", d0);

            Variant d1 = new Variant();
            d1.Add("Status", 0);
            d1.Add("PlayerID", note.PlayerID);//邀请者
            d1.Add("Goods", null);
            if (!OnlineBusiness.Value.ContainsKey("Deal"))
                OnlineBusiness.Value.Add("Deal", d1);

            OnlineBusiness.Call(DealCommand.DealApplyR, true, note.PlayerID);
            note.Call(DealCommand.DealApplyR, true, note.PlayerID);
        }

 void Execute(UserNote note)
 {
     //表示角色正在战斗中，客户端提交信息不进行处理
     if (note.Player.AState == ActionState.Fight)
     {
         Variant msg = GoodsAccess.Instance.LiaoTianList(TipManager.GetMessage(DealReturn.SelfFighting));
         note.Call(ClientCommand.SendMsgToAllPlayerR, string.Empty, msg);
         return;
     }
     switch (note.Name)
     {
         case DealCommand.DealApply:
             DealBusiness.DealApply(note);
             break;
         case DealCommand.DealApplyBack:
             DealBusiness.DealApplyBack(note);
             break;
         case DealCommand.LockDeal:
             DealBusiness.LockDeal(note);
             break;
         case DealCommand.EnterDeal:
             DealBusiness.EnterDeal(note);
             break;
         case DealCommand.ExitDeal:
         case ClientCommand.UserDisconnected:
             DealBusiness.ExitDeal(note);
             break;
     }
 }

        /// <summary>
        /// 取得星阵星力值
        /// </summary>
        /// <param name="note"></param>
        public static void GetStarTroops(UserNote note)
        {
            string soleid = note.PlayerID + "GetStarTroops";

            if (!m_dic.TryAdd(soleid, soleid))
                return;
            try
            {
                PlayerEx star = note.Player.Star;
                Variant v = star.Value;
                int sp = StarTroopsSettle(star);
                if (sp <= 0)
                {
                    note.Call(StarCommand.GetStarTroopsR, false, TipManager.GetMessage(StarReturn.GetStarTroops2));
                    return;
                }
                int powerMax = PartAccess.Instance.PowerMax();

                int addPower = 0;
                if (note.Player.StarPower + sp > powerMax)
                {
                    addPower = powerMax - note.Player.StarPower;
                }
                else
                {
                    addPower = sp;
                }
                v["StarPower"] = 0;
                //重新计算时间
                v["StarTime"] = DateTime.UtcNow;

                if (addPower > 0)
                {
                    note.Player.AddStarPower(addPower, FinanceType.GetStarTroops);
                }

                star.Save();
                note.Call(ClientCommand.UpdateActorR, new PlayerExDetail(star));
                note.Call(StarCommand.GetStarTroopsR, true, TipManager.GetMessage(StarReturn.GetStarTroops3));
            }
            finally
            {
                m_dic.TryRemove(soleid, out soleid);
            }
        }

        /// <summary>
        /// 得到宠物列表
        /// </summary>
        /// <param name="note"></param>
        public void GetPetsList(UserNote note)
        {
            //表示没有家园不
            //if (note.Player.SceneID != SceneHome.DefaultID)
            //    return;
            //玩家ID
            string id = note.GetString(0);
            if (note.PlayerID == id)
            {
                note.Call(PetsCommand.GetPetsListR, PetAccess.Instance.GetPetList(note.Player.B2));
                return;
            }

            PlayerBusiness pb = PlayersProxy.FindPlayerByID(id);
            if (pb == null)
                return;
            note.Call(PetsCommand.GetPetsListR, PetAccess.Instance.GetPetList(pb.B2));
        }

        /// <summary>
        /// 回复交易
        /// </summary>
        /// <param name="note"></param>
        public static void DealApplyBack(UserNote note)
        {
            IList o = note[0] as IList;
            bool IsSame = false;

            PlayerBusiness OnlineBusiness = PlayersProxy.FindPlayerByID(o[1].ToString());
            if (OnlineBusiness == null || (!OnlineBusiness.Online))
            {
                note.Call(DealCommand.DealApplyBackR, false, TipManager.GetMessage(DealReturn.NoLine));
                return;
            }

            if (!OnlineBusiness.Value.ContainsKey("Deal"))
            {
                note.Call(DealCommand.DealApplyBackR, false, TipManager.GetMessage(DealReturn.BackMsgError));
                return;
            }
            Variant v0 = note.Player.Value.GetVariantOrDefault("Deal");
            Variant v1 = OnlineBusiness.Value.GetVariantOrDefault("Deal");

            if (!bool.TryParse(o[0].ToString(), out IsSame))
            {
                if (OnlineBusiness.Value.ContainsKey("Deal"))
                    OnlineBusiness.Value.Remove("Deal");
                OnlineBusiness.Call(DealCommand.DealApplyBackR, false, TipManager.GetMessage(DealReturn.NoDeal));

                //note.Call(DealCommand.DealApplyBackR, false, TipAccess.GetMessage(DealReturn.NoDeal));
                return;
            }

            if (!note.Player.Value.ContainsKey("Deal"))
            {
                if (OnlineBusiness.Value.ContainsKey("Deal"))
                    OnlineBusiness.Value.Remove("Deal");
                OnlineBusiness.Call(DealCommand.DealApplyBackR, false, TipManager.GetMessage(DealReturn.NoDeal));
                //note.Call(DealCommand.DealApplyBackR, false, TipAccess.GetMessage(DealReturn.NoDeal));
                return;
            }

            if (!IsSame)
            {
                if (OnlineBusiness.Value.ContainsKey("Deal"))
                    OnlineBusiness.Value.Remove("Deal");
                OnlineBusiness.Call(DealCommand.DealApplyBackR, false, TipManager.GetMessage(DealReturn.NoDeal));

                if (note.Player.Value.ContainsKey("Deal"))
                    note.Player.Value.Remove("Deal");
                //note.Call(DealCommand.DealApplyBackR, false, TipAccess.GetMessage(DealReturn.NoDeal));
                return;
            }

            v0["Status"] = 1;
            v1["Status"] = 1;
            OnlineBusiness.Call(DealCommand.DealApplyBackR, true, DealReturn.AgreeDeal);
            note.Call(DealCommand.DealApplyBackR, true, DealReturn.AgreeDeal);
        }

 /// <summary>
 /// 使用者等级限制
 /// </summary>
 /// <param name="note"></param>
 /// <param name="limit"></param>
 /// <returns></returns>
 private static bool CheckLevel(UserNote note, Variant limit)
 {
     int needLev = limit.GetIntOrDefault("LevelRequire");
     if (needLev > note.Player.Level)
     {
         note.Call(ArenaCommand.ArenaGoodsR, false, TipManager.GetMessage(GoodsReturn.NoLevel));
         return false;
     }
     return true;
 }

 /// <summary>
 /// 宠物奖励
 /// </summary>
 public static void TaskAward112009(UserNote note, Dictionary<string, int> pets)
 {
     foreach (string ps in pets.Keys)
     {
         for (int i = 0; i < pets[ps]; i++)
         {
             PetAccess.Instance.CreatePet(note.Player.B3, ps, 0, 1);
         }
     }
     note.Call(ClientCommand.UpdateActorR, new PlayerExDetail(note.Player.B3));
 }

        /// <summary>
        /// 邮件删除
        /// </summary>
        /// <param name="note"></param>
        public static void DelEmail(UserNote note)
        {
            IList id = note[0] as IList;

            if (id.Count > 0)
            {

                if (EmailAccess.Instance.RemoveEmail(id, note.PlayerID))
                {
                    note.Call(EmailCommand.DelEmailR, true);
                }
                else
                {
                    note.Call(EmailCommand.DelEmailR, false, TipManager.GetMessage(EmailReturn.EmailFuJian));
                }
            }
            else
            {
                note.Call(EmailCommand.DelEmailR, false, TipManager.GetMessage(EmailReturn.DataError));
            }
        }

 /// <summary>
 /// 骑乘或召回坐骑
 /// </summary>
 /// <param name="note"></param>
 public static void InOutMounts(UserNote note)
 {
     Mounts m = note.Player.Mounts;
     if (m == null)
     {
         note.Call(MountsCommand.InOutMountsR, false, TipManager.GetMessage(MountsReturn.Mounts2));
         return;
     }
     m.Status = m.Status == 0 ? 1 : 0;
     if (m.Save())
     {
         PetAccess.PetReset(note.Player.Pet, note.Player.Skill, false, m);
         note.Call(PetsCommand.UpdatePetR, true, note.Player.Pet);
         note.Player.MountsUpdate(m, new List<string>() { "Status" });
         note.Player.MountsInfo();
         note.Call(MountsCommand.InOutMountsR, true, "");
     }
     else
     {
         //操作失败
         note.Call(MountsCommand.InOutMountsR, false,TipManager.GetMessage(MountsReturn.Mounts1));
     }
 }

 /// <summary>
 /// 获取所有技能信息
 /// </summary>
 /// <param name="note"></param>
 private void GetSkills(UserNote note)
 {
     object[] ids = note[0] as object[];
     if (ids == null || ids.Length == 0)
     {
         var skills = GameConfigAccess.Instance.Find(MainType.Skill, string.Empty);
         note.Call(SkillCommand.GetSkillsR, true, skills.Select(x => new SkillSimple(x)));
     }
     else
     {
         var skill = GameConfigAccess.Instance.FindByIDList(ids);
         note.Call(SkillCommand.GetSkillsR, true, skill.Select(x => new SkillSimple(x)));
     }
 }

        /// <summary>
        /// 添加仇人
        /// </summary>
        /// <param name="note"></param>
        public static void AddEnemy(UserNote note)
        {
            string name = note.GetString(0);

            PlayerEx Social = note.Player.Social;
            if (Social == null)
            {
                note.Call(SocialCommand.AddEnemyR, false, TipManager.GetMessage(SocialReturn.UserInfoError));
                return;
            }
            PlayerBusiness player = PlayersProxy.FindPlayerByName(name);
            if (player == null)
            {
                note.Call(SocialCommand.AddEnemyR, false, TipManager.GetMessage(SocialReturn.UserInfoError));
                return;
            }
            if (SocialBusiness.IsLet(Social, player.ID, new List<string> { "Enemy" }))
            {
                note.Call(SocialCommand.AddEnemyR, false, TipManager.GetMessage(SocialReturn.Enemy));
                return;
            }
            if (SocialBusiness.IsLet(Social, player.ID, new List<string> {  "Friends" }))
            {
                note.Call(SocialCommand.AddEnemyR, false, TipManager.GetMessage(SocialReturn.Friends));
                return;
            }
            if (SocialBusiness.IsLet(Social, player.ID, new List<string> {  "Apprentice" }))
            {
                note.Call(SocialCommand.AddEnemyR, false, TipManager.GetMessage(SocialReturn.Apprentice));
                return;
            }
            if (SocialBusiness.IsLet(Social, player.ID, new List<string> {  "Master" }))
            {
                note.Call(SocialCommand.AddEnemyR, false, TipManager.GetMessage(SocialReturn.Master));
                return;
            }

            IList Enemy = Social.Value.GetValue<IList>("Enemy");
            Variant v = new Variant();
            v.Add("PlayerID", player.ID);
            v.Add("Created", DateTime.UtcNow);
            if (Enemy == null)
            {
                Social.Value["Enemy"] = new List<Variant> { v };
            }
            else
            {
                Enemy.Add(v);
            }
            Social.Save();
            note.Call(SocialCommand.AddEnemyR, true, new PlayerSimple(player, 3));
        }

        /// <summary>
        /// 学习技能
        /// </summary>
        /// <param name="note"></param>
        private void StudySkill(UserNote note)
        {
            string skillID = note.GetString(0);

            GameConfig c = GameConfigAccess.Instance.FindOneById(skillID);
            if (c == null) return;

            PlayerEx skill = note.Player.Skill;
            int oldLev = skill.Value.GetIntOrDefault(skillID);
            if (oldLev == 0) //第一次学习检查职业限制
            {
                //RoleLimit:职业限制 无限制"";  狂战士"1"; 魔弓手"2"; 神祭师"3"
                string roleID = c.UI.GetStringOrDefault("RoleLimit");
                if (roleID == "1" || roleID == "2" || roleID == "3")
                {
                    if (note.Player.RoleID != roleID)
                    {
                        note.Call(SkillCommand.StudySkillR, false, TipManager.GetMessage(SkillReturn.StudySkill1), oldLev);
                        return;
                    }
                }
            }

            //已达最大等级检查
            int maxLev = c.UI.GetIntOrDefault("Level");
            Variant studyLimit = c.UI.GetVariantOrDefault(oldLev.ToString());
            if (studyLimit == null || oldLev >= maxLev)
            {
                note.Call(SkillCommand.StudySkillR, false, TipManager.GetMessage(SkillReturn.StudySkill3), oldLev);
                return;
            }

            //学习所需角色等级检查
            int studyLev = studyLimit.GetIntOrDefault("StudyLev");
            if (studyLev > note.Player.Level)
            {
                note.Call(SkillCommand.StudySkillR, false, string.Format(TipManager.GetMessage(SkillReturn.StudySkill4), studyLev), oldLev);
                return;
            }

            //前置技能检查
            string preSkill = studyLimit.GetStringOrDefault("PreSkill");
            if (!string.IsNullOrEmpty(preSkill))
            {
                int preLev = studyLimit.GetIntOrDefault("PreLev");
                if (preLev > 0)
                {
                    GameConfig preConfig = GameConfigAccess.Instance.FindOneById(preSkill);
                    if (preConfig != null)
                    {
                        int check = skill.Value.GetIntOrDefault(preSkill);
                        if (preLev > check)
                        {
                            note.Call(SkillCommand.StudySkillR, false,
                                string.Format(TipManager.GetMessage(SkillReturn.StudySkill5), preConfig.Name, preLev), oldLev);
                            return;
                        }
                    }
                }
            }

            //学习消耗技能书检查
            string book = c.UI.GetStringOrDefault("Book");
            if (!string.IsNullOrEmpty(book))
            {
                if (BurdenManager.GoodsCount(note.Player.Value["B0"] as PlayerEx, book) == 0)
                {
                    note.Call(SkillCommand.StudySkillR, false, TipManager.GetMessage(SkillReturn.StudySkill2), oldLev);
                    return;
                }
            }

            //积分消耗检查
            int studyCost = studyLimit.GetIntOrDefault("StudyCost");
            if (note.Player.Score < studyCost || (!note.Player.AddScore(-studyCost, FinanceType.SkillStudy)))
            {
                note.Call(SkillCommand.StudySkillR, false, string.Format(TipManager.GetMessage(SkillReturn.StudySkill6), studyCost), oldLev);
                return;
            }

            skill.Value[skillID] = oldLev + 1;
            skill.Save();
            note.Call(SkillCommand.StudySkillR, true, skillID, oldLev + 1);
            //扣除技能书,每一级都要消耗一本
            if (!string.IsNullOrEmpty(book))
            {
                PlayerEx b0 = note.Player.Value.GetValueOrDefault<PlayerEx>("B0");
                BurdenManager.Remove(b0, book);
                Variant v = new Variant(1);
                v["B0"] = b0;
                note.Call(BurdenCommand.BurdenListR, v);
            }
            note.Player.RefeshSkill();
        }

        private void MosaicNeed(UserNote note)
        {
            string goodsid = note.GetString(0);
            Goods g = GoodsAccess.Instance.GetGoodsByID(goodsid, note.PlayerID);
            if (g == null)
            {
                note.Call(MosaicCommand.MosaicNeedR, false, TipManager.GetMessage(MosaicReturn.MosaicEquipNo));
                return;
            }

            if (g.Value.GetIntOrDefault("IsChange") == 0)
            {
                note.Call(ExchangeCommand.ExchangNeedR, false, TipManager.GetMessage(MosaicReturn.MosaicNoChange));
                return;
            }

            Variant BaoShiInfo = g.Value.GetVariantOrDefault("BaoShiInfo");

            bool IsLet = true;
            foreach (string d in BaoShiInfo.Keys)
            {
                if (BaoShiInfo[d].ToString() != "-1")
                {
                    IsLet = false;
                    break;
                }
            }

            if (IsLet)
            {
                note.Call(MosaicCommand.MosaicNeedR, false, TipManager.GetMessage(MosaicReturn.MosaicNoLet));
                return;
            }

            List<GameConfig> mosaic = GameConfigAccess.Instance.Find("Mosaic");
            GameConfig gc = null;
            foreach (GameConfig gcg in mosaic)
            {
                if (gcg.Value.GetStringOrDefault("Type") == g.Value.GetStringOrDefault("GoodsType"))
                {
                    gc = gcg;
                    break;
                }
            }

            if (gc == null)
            {
                note.Call(MosaicCommand.MosaicNeedR, false, TipManager.GetMessage(MosaicReturn.MosaicNoLet));
                return;
            }

            string UpID = gc.Value.GetStringOrDefault("UpID");

            int UpCount = 0;

            PlayerEx b = note.Player.B0;
            foreach (Variant con in b.Value.GetValueOrDefault<IList>("C"))
            {
                if (con.GetStringOrDefault("G") == UpID)
                    UpCount += con.GetIntOrDefault("A");
            }
            //可以镶嵌的宝石
            IList MosaicNeed = gc.Value.GetValue<IList>("MosaicNeed");

            List<string> bs = new List<string>();
            foreach (string key in MosaicNeed)
            {
                GameConfig tmp = GameConfigAccess.Instance.FindOneById(key);
                if (tmp == null)
                    continue;
                if (g.Value.GetIntOrDefault("Level") >= tmp.Value.GetIntOrDefault("Level"))
                {
                    bs.Add(tmp.ID);
                }
            }

            if (bs.Count == 0)
            {
                note.Call(MosaicCommand.MosaicNeedR, false, TipManager.GetMessage(MosaicReturn.MosaicNoLet));
                return;
            }
            Variant v = new Variant();
            v.Add("BaoShiInfo", bs);
            v.Add("UpID", UpID);
            v.Add("UpCount", UpCount);
            note.Call(MosaicCommand.MosaicNeedR, true, v);
        }