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

using System;
using System.Collections.Generic;
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()
        {
            LeagueSkillCountCfg[] skillCountCfgs = LeagueSkillCountCfgArray.Instance.dataArray;
            for (int i = 0; i < skillCountCfgs.Length; i++)
            {
                if (GetSkillProgressByType(skillCountCfgs[i].type) < 100) return skillCountCfgs[i].type - 1;
            }
            return skillCountCfgs[skillCountCfgs.Length - 1].type;
        }

        //根据技能类型获取该类型进度
        public double GetSkillProgressByType(int skillType)
        {
            LeagueSkillCountCfg skillCountCfg = LeagueSkillCountCfgArray.Instance.GetCfg(skillType);
            // if (skillCountCfg.type - CurType < 0) return 100;
            // if (skillCountCfg.type - CurType > 0) return 0;

            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 < LeagueWelfareCfgArray.Instance.dataArray.Length; i++)
            {
                LeagueWelfareCfg welfareCfg = LeagueWelfareCfgArray.Instance.dataArray[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.LeagueWelfareSuperWeek) > 0;
                        isGet = GameGlobal.myNumericComponent.GetAsInt(NumericType.LeagueWelfareSuperWeek) == 1;
                        break;
                    case LeagueWelfareType.SuperDay:
                        isBuy = GetNumeriValue(LeagueNumericType.LeagueWelfareSuperLeftTimes) > 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 < LeagueWelfareCfgArray.Instance.dataArray.Length; i++)
            {
                LeagueWelfareCfg welfareCfg = LeagueWelfareCfgArray.Instance.dataArray[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.LeagueWelfareWeek);
                        endTime = GetNumeriValue(LeagueNumericType.LeagueWelfareWeekLeftTimes);
                        break;
                    case LeagueWelfareType.SuperWeek:
                        buyCount = (int)GetNumeriValue(LeagueNumericType.LeagueWelfareSuperWeek);
                        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 = TeapartyRoleCfgArray.Instance.GetCfgsByid(TeaPartyId);
            string[] tags = teapartyRoleCfg[ChooseTeaPartId - 1].tagArr;

            for (int i = 0; i < roleData.itemList.Count; i++)
            {
                int itemId = roleData.itemList[i];
                ItemCfg itemCfg = ItemCfgArray.Instance.GetCfg(itemId);
                if (itemCfg == null)
                {
                    ET.Log.Error("物品：" + itemId + "不存在");
                    return matchedValue;
                }
                for (int t = 0; t < itemCfg.tagsArr.Length; t++)
                {
                    for (int j = 0; j < tags.Length; j++)
                    {
                        if (itemCfg.tagsArr[t][0] == 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 = TeapartyRewardRoleCfgArray.Instance.dataArray;
            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.Length; 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 = TeapartyRewardLeagueCfgArray.Instance.GetCfgsByid(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 = TeapartyRewardRoleCfgArray.Instance.dataArray;
            var teapartyRewardLeagueCfgs = TeapartyRewardLeagueCfgArray.Instance.GetCfgsByid(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 "";
        }
    }
}