XiuXianProject/GameClient/Assets/Game/HotUpdate/Data/LeagueDataManager.cs

using System;
using System.Collections.Generic;
using cfg.GfgCfg;
using ET;

namespace GFGGame
{
    public class LastQuestionResult
    {
        public static int SomeBodyRight = 1; //1:有人答对题目
        public static int NobodyRight = 2; // 2:无人答对
        public static int Ending = 3; // 3:答题结束
    }

    public class LeagueJoinType
    {
        public static int Join = 1; //1:已经加入军团
        public static int UnJoin = 2; //1:未加入军团
    }

    public class LeagueDataManager : SingletonBase<LeagueDataManager>
    {
        public int Type = 2; // 1:已经加入军团 2:未加入军团

        public int MaxFinishType
        {
            get { return GetSkillCurType(); }
        }

        public int CurLayer
        {
            get { return Math.Max(GameGlobal.myNumericComponent.GetAsInt(NumericType.LeagueSkillMaxLayer), 1); }
        }

        public LeagueData LeagueData; //联盟信息

        public int HallLevel
        {
            get { return (int)GetNumeriValue(LeagueNumericType.HallLevel); }
        }

        public int HotelLevel
        {
            get { return (int)GetNumeriValue(LeagueNumericType.HotelLevel); }
        }

        public int StoreLevel
        {
            get { return (int)GetNumeriValue(LeagueNumericType.StoreLevel); }
        }

        public Dictionary<int, long> LeagueNumber = new Dictionary<int, long>(); //联盟数值,LeagueNumericType
        public Dictionary<long, LeagueListData> ListDatas = new Dictionary<long, LeagueListData>(); //联盟列表
        public Dictionary<long, OtherRoleInfoData> ListApplyDatas = new Dictionary<long, OtherRoleInfoData>(); //联盟申请列表
        public List<LeagueLogData> ListLogDatas = new List<LeagueLogData>(); //日志数据
        public LeagueLastAnswerRoleData LastAnswerRoleData = new LeagueLastAnswerRoleData(); //上题回答数据
        public Dictionary<long, int> ListAnsweringDatas = new Dictionary<long, int>(); //当前答题玩家数据，roleId，答题数量。

        public Dictionary<int, List<LeagueAnswerData>> ListAnswerRankDatas =
            new Dictionary<int, List<LeagueAnswerData>>(); //答题排行榜数据,int:type//0:周排行 1:上周排行

        public int TeaPartyId = 0; //茶会期数 --未开启则期数为0
        public int TeaPartyStatus = 0; // 0未开启 1集结中 2已集结
        public RoleTeapartyInfoProto RoleTeapartyInfo = new RoleTeapartyInfoProto(); // 玩家本期茶话会参与信息
        public List<RoleContainerProto> RoleContainerList = new List<RoleContainerProto>(); // 茶会每个扮演角色坑位信息
        public long TeaPartyCloseTime = 0; // 茶话会结束时间
        public int ChooseTeaPartId = 0; // 选择的茶话会类型

        public void Clear()
        {
            Type = LeagueJoinType.UnJoin;
            ListDatas.Clear();
            LeagueData = null;
            ListApplyDatas.Clear();
            ListLogDatas.Clear();
            ListAnsweringDatas.Clear();
            LeagueNumber.Clear();
        }

        public void SetNumeric(int type, long value)
        {
            if (LeagueNumber.ContainsKey(type))
                LeagueNumber[type] = value;
            else
                LeagueNumber.Add(type, value);
        }

        public long GetNumeriValue(int type)
        {
            if (LeagueNumber.TryGetValue(type, out long value))
            {
                return value;
            }

            return 0;
        }


        public string GetMemberTitle(int pos)
        {
            string title = "";
            switch (pos)
            {
                case LeaguePos.Owner:
                    title = "社长";
                    break;
                case LeaguePos.SubOwner:
                    title = "副社长";
                    break;
                case LeaguePos.Flower:
                    title = "社花";
                    break;
                case LeaguePos.Member:
                    title = "成员";
                    break;
            }

            return title;
        }

        public int GetMyPos()
        {
            if (LeagueDataManager.Instance.LeagueData == null)
            {
                return LeaguePos.Member;
            }

            if (LeagueDataManager.Instance.LeagueData.LeagueMemberDatas.TryGetValue(RoleDataManager.roleId,
                    out LeagueMemberData memberData))
            {
                return memberData.Pos;
            }

            return LeaguePos.Member;
        }

        public string GetMyLeagueName()
        {
            if (LeagueDataManager.Instance.LeagueData == null)
            {
                return "";
            }

            return LeagueDataManager.Instance.LeagueData.Name;
        }

        // //判断一个玩家是否是会长副会长
        // public bool CheckPlayerIsLeader()
        // {

        // }
        /// <summary>
        /// 根据祈福类型获取祈福次数
        /// </summary>
        /// <returns></returns>
        public int GetPrayTimesByType(int prayType)
        {
            int curCount = 0;
            switch (prayType)
            {
                case LeaguePrayType.First:
                    curCount = RoleDataManager.LeagueType1PrayTimes;
                    break;
                case LeaguePrayType.Second:
                    curCount = RoleDataManager.LeagueType2PrayTimes;
                    break;
                case LeaguePrayType.Third:
                    curCount = RoleDataManager.LeagueType3PrayTimes;
                    break;
            }

            return curCount;
        }

        public OtherRoleInfoData GetMemberRoleInfo(long roleId)
        {
            LeagueData.LeagueMemberDatas.TryGetValue(roleId, out LeagueMemberData value);
            if (value == null) return null;
            return value.RoleInfo;
        }

        //输入属性类型，获取联盟技能该属性加成总值
        public int GetAllSkillScore(int scoreType)
        {
            int score = 0;
            foreach (int key in SkillDataManager.Instance.LeagueSkillScoreDatas.Keys)
            {
                score += SkillDataManager.Instance.LeagueSkillScoreDatas[key][scoreType];
            }

            return score;
        }

        //输入联盟技能类型和属性类型，获取指定技能类型该属性加成值
        public int GetSkillScoreByType(int skillType, int scoreType)
        {
            int score = 0;
            if (!SkillDataManager.Instance.LeagueSkillScoreDatas.ContainsKey(skillType)) return score;
            if (!SkillDataManager.Instance.LeagueSkillScoreDatas[skillType].ContainsKey(scoreType)) return score;
            return SkillDataManager.Instance.LeagueSkillScoreDatas[skillType][scoreType];
        }

        //检测一个技能是否激活
        public bool CheckIsSkillActive(int skillType, int skillId)
        {
            if (!SkillDataManager.Instance.LeagueSkillDatas.ContainsKey(skillType)) return false;
            return SkillDataManager.Instance.LeagueSkillDatas[skillType].IndexOf(skillId) >= 0;
        }

        private int GetSkillCurType()
        {
            List<LeagueSkillCountCfg> skillCountCfgs = CommonDataManager.Tables.TblLeagueSkillCountCfg.DataList;

            for (int i = 0; i < skillCountCfgs.Count; i++)
            {
                if (GetSkillProgressByType(skillCountCfgs[i].Type) < 100) return skillCountCfgs[i].Type - 1;
            }

            return skillCountCfgs[skillCountCfgs.Count - 1].Type;
        }

        //根据技能类型获取该类型进度
        public double GetSkillProgressByType(int skillType)
        {
            LeagueSkillCountCfg skillCountCfg = CommonDataManager.Tables.TblLeagueSkillCountCfg.GetOrDefault(skillType);
            float count = !SkillDataManager.Instance.LeagueSkillDatas.ContainsKey(skillType)
                ? 0
                : SkillDataManager.Instance.LeagueSkillDatas[skillType].Count;
            float maxCount = skillCountCfg.SkillCount;

            return Math.Round(count / maxCount * 100, 2);
            ;
        }

        //获取联盟礼包领取数据
        public List<LeagueGiftGetData> GetGiftGetDatas()
        {
            List<LeagueGiftGetData> getDatas = new List<LeagueGiftGetData>();

            for (int i = 0; i < CommonDataManager.Tables.TblLeagueWelfareCfg.DataList.Count; i++)
            {
                LeagueWelfareCfg welfareCfg = CommonDataManager.Tables.TblLeagueWelfareCfg.DataList[i];

                bool isBuy = false;
                bool isGet = false;
                switch (welfareCfg.Type)
                {
                    case LeagueWelfareType.Day: //普通日福利
                        isBuy = GetNumeriValue(LeagueNumericType.LeagueWelfareDay) > 0;
                        isGet = GameGlobal.myNumericComponent.GetAsInt(NumericType.LeagueWelfareDay) == 1;
                        break;
                    case LeagueWelfareType.Week: //普通周福利
                        isBuy = GetNumeriValue(LeagueNumericType.LeagueWelfareWeekLeftTimes) > 0;
                        isGet = GameGlobal.myNumericComponent.GetAsInt(NumericType.LeagueWelfareWeek) == 1;
                        break;
                    case LeagueWelfareType.SuperWeek: //超级周福利
                        isBuy = GetNumeriValue(LeagueNumericType.LeagueWelfareSuperLeftTimes) > 0;
                        isGet = GameGlobal.myNumericComponent.GetAsInt(NumericType.LeagueWelfareSuperWeek) == 1;
                        break;
                    case LeagueWelfareType.SuperDay: //超级日福利
                        isBuy = GetNumeriValue(LeagueNumericType.LeagueWelfareSuperDay) > 0;
                        isGet = GameGlobal.myNumericComponent.GetAsInt(NumericType.LeagueWelfareSuperDay) == 1;
                        break;
                }

                // ET.Log.Debug("isBuy:" + isBuy);
                if (isBuy)
                {
                    LeagueGiftGetData giftGetData = new LeagueGiftGetData();
                    giftGetData.Type = welfareCfg.Type;
                    giftGetData.IsGet = isGet;
                    giftGetData.GiftCfg = welfareCfg;
                    getDatas.Add(giftGetData);
                }
            }

            return getDatas;
        }

        public List<LeagueGiftBuyData> GetGiftBuyDatas()
        {
            List<LeagueGiftBuyData> giftBuyDatas = new List<LeagueGiftBuyData>();

            for (int i = 0; i < CommonDataManager.Tables.TblLeagueWelfareCfg.DataList.Count; i++)
            {
                LeagueWelfareCfg welfareCfg = CommonDataManager.Tables.TblLeagueWelfareCfg.DataList[i];
                int buyCount = 0;
                long endTime = 0;
                switch (welfareCfg.Type)
                {
                    case LeagueWelfareType.Day:
                        buyCount = (int)GetNumeriValue(LeagueNumericType.LeagueWelfareDay);
                        break;
                    case LeagueWelfareType.Week:
                        buyCount = (int)GetNumeriValue(LeagueNumericType.LeagueWelfareWeekLeftTimes) > 0 ? 1 : 0;
                        endTime = GetNumeriValue(LeagueNumericType.LeagueWelfareWeekLeftTimes);
                        break;
                    case LeagueWelfareType.SuperWeek:
                        buyCount = (int)GetNumeriValue(LeagueNumericType.LeagueWelfareSuperLeftTimes) > 0 ? 1 : 0;
                        endTime = GetNumeriValue(LeagueNumericType.LeagueWelfareSuperLeftTimes);
                        break;
                    case LeagueWelfareType.SuperDay:
                        buyCount = (int)GetNumeriValue(LeagueNumericType.LeagueWelfareSuperDay);
                        break;
                }

                LeagueGiftBuyData giftBuyData = new LeagueGiftBuyData();
                giftBuyData.Type = welfareCfg.Type;
                giftBuyData.BuyCount = buyCount;
                giftBuyData.EndTime = endTime;
                giftBuyData.GiftCfg = welfareCfg;
                giftBuyDatas.Add(giftBuyData);
            }

            return giftBuyDatas;
        }


        //茶话会匹配度计算
        public int GetTeaPartyMatchedValue(FightData roleData)
        {
            int matchedValue = 0;

            var teapartyRoleCfg = CommonDataManager.Tables.TblTeapartyRoleCfg.GetGroup1ById(TeaPartyId);

            List<string> tags = teapartyRoleCfg[ChooseTeaPartId - 1].Tag;

            for (int i = 0; i < roleData.itemList.Count; i++)
            {
                int itemId = roleData.itemList[i];
                ItemCfg itemCfg = CommonDataManager.Tables.TblItemCfg.GetOrDefault(itemId);
                if (itemCfg == null)
                {
                    ET.Log.Error("物品：" + itemId + "不存在");
                    return matchedValue;
                }

                for (int t = 0; t < itemCfg.Tags.Count; t++)
                {
                    for (int j = 0; j < tags.Count; j++)
                    {
                        if (itemCfg.Tags[t].Name == tags[j])
                        {
                            matchedValue += 1;
                        }
                    }
                }
            }

            return matchedValue;
        }

        //茶话会个人奖励是否可以领取

        public bool CheckTeaPartyPersonRewardCanGet(int targetScore)
        {
            return CheckTeaPartyPersonRewardStatu(targetScore) == ConstBonusStatus.CAN_GET &&
                   LeagueDataManager.Instance.TeaPartyStatus == LeagueTeaPartyStatus.YesGo;
        }

        //茶话会个人奖励当前状态
        public int CheckTeaPartyPersonRewardStatu(int targetScore)
        {
            var teapartyRewardRoleCfg = CommonDataManager.Tables.TblTeapartyRewardRoleCfg.DataList;

            if (teapartyRewardRoleCfg == null)
                return 0;
            var roleTeapartyInfo = LeagueDataManager.Instance.RoleTeapartyInfo;
            if (roleTeapartyInfo == null || roleTeapartyInfo.PerAwardStatusVs == null ||
                roleTeapartyInfo.PerAwardStatusVs.Count <= 0)
                return 0;
            for (int i = 0; i < teapartyRewardRoleCfg.Count; i++)
            {
                if (teapartyRewardRoleCfg[i].TargetScore == targetScore)
                {
                    return roleTeapartyInfo.PerAwardStatusVs[i];
                }
            }

            return 0;
        }

        //茶话会雅集奖励是否可以领取

        public bool CheckTeaPartyLeagueRewardCanGet(int targetScore)
        {
            return CheckTeaPartyLeagueRewardStatu(targetScore) == ConstBonusStatus.CAN_GET;
        }

        //茶话会雅集奖励是否可以领取
        public int CheckTeaPartyLeagueRewardStatu(int targetScore)
        {
            var teapartyRewardLeagueCfgs =
                CommonDataManager.Tables.TblTeapartyRewardLeagueCfg.GetGroup1ById(LeagueDataManager.Instance
                    .TeaPartyId);

            if (teapartyRewardLeagueCfgs == null)
                return 0;
            var roleTeapartyInfo = LeagueDataManager.Instance.RoleTeapartyInfo;
            if (roleTeapartyInfo == null || roleTeapartyInfo.LeagueAwardStatusVs == null ||
                roleTeapartyInfo.LeagueAwardStatusVs.Count <= 0)
                return 0;
            for (int i = 0; i < teapartyRewardLeagueCfgs.Count; i++)
            {
                if (teapartyRewardLeagueCfgs[i].TargetScore == targetScore)
                {
                    return roleTeapartyInfo.LeagueAwardStatusVs[i];
                }
            }

            return 0;
        }

        //茶话会奖励是否可以领取
        public bool CheckTeaPartyRewardCanGet()
        {
            var roleTeapartyInfo = LeagueDataManager.Instance.RoleTeapartyInfo;
            if (roleTeapartyInfo == null)
                return false;

            //该活动暂未开启
            if (LeagueDataManager.Instance.TeaPartyStatus == LeagueTeaPartyStatus.YesGo &&
                roleTeapartyInfo.IsNoActDayEnterLeague)
                return false;
            //该玩法不可以重复参加哦
            if (roleTeapartyInfo.IsQuitTeaParty && roleTeapartyInfo.LastOpenCfgId != 0 &&
                roleTeapartyInfo.LastOpenCfgId == LeagueDataManager.Instance.TeaPartyId)
                return false;

            var teapartyRewardRoleCfg = CommonDataManager.Tables.TblTeapartyRewardRoleCfg.DataList;

            var teapartyRewardLeagueCfgs =
                CommonDataManager.Tables.TblTeapartyRewardLeagueCfg.GetGroup1ById(LeagueDataManager.Instance
                    .TeaPartyId);

            foreach (var cfg in teapartyRewardRoleCfg)
            {
                if (CheckTeaPartyPersonRewardCanGet(cfg.TargetScore))
                    return true;
            }

            foreach (var cfg in teapartyRewardLeagueCfgs)
            {
                if (CheckTeaPartyLeagueRewardCanGet(cfg.TargetScore))
                    return true;
            }

            return false;
        }

        //主界面雅集提示语判断
        public string CheckLeagueMainTips()
        {
            if (LeagueDataManager.Instance.GetNumeriValue(LeagueNumericType.LeagueQuestionStatus) ==
                LeagueQuestionStatus.Open ||
                LeagueDataManager.Instance.GetNumeriValue(LeagueNumericType.LeagueQuestionStatus) ==
                LeagueQuestionStatus.WaitNext)
                return "雅集夜宴进行中...";

            if (LeagueDataManager.Instance.Type == LeagueJoinType.Join &&
                LeagueDataManager.Instance.TeaPartyStatus == LeagueTeaPartyStatus.YesOpen &&
                !LeagueDataManager.Instance.RoleTeapartyInfo.Status)
                return "茶话会挑战中...";

            return "";
        }
    }
}