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

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

namespace GFGGame
{
    public class ClickType
    {
        public const int MISS_CLICK = 0;
        public const int GOOD_CLICK = 1;
        public const int PERFECT_CLICK = 2;
    }

    public class SkillBeginTime
    {
        public const int ROUND_1 = 1; //作用第一回合
        public const int ROUND_2 = 2; //作用第二回合
        public const int ROUND_3 = 3; //作用第三回合
        public const int ROUND_4 = 4; //作用第四回合
        public const int ROUND_5 = 5; //作用第五回合
        public const int ROUND_6 = 6; //作用第六回合
        public const int FIGHT_BEGIN = 7; //对战开始
        public const int PERFECT_CLICK = 8; //每次完美点击
        public const int ERVERY_ROUND_BEGIN = 9; //每回合开始
        public const int ERVERY_ROUND_END = 10; //每回合结束
        public const int ALL_PERFECT_START = 11; //登封造极开始(所有点击完美才会出现登峰造极)
    }


    public class ScoreSystemData : SingletonBase<ScoreSystemData>
    {
        /// <summary>
        /// 将穿戴部件分组
        /// </summary>
        public void SetEquipScoresWithPartId(FightData roleData)
        {
            roleData.partScoreListDic.Clear();
            roleData.partListDic.Clear();
            List<FightScoreCfg> typeCfgs = CommonDataManager.Tables.TblFightScoreCfg.DataList;
            for (int j = 0; j < typeCfgs.Count; j++)
            {
                FightScoreCfg cfg = typeCfgs[j];
                if (roleData.partScoreListDic.ContainsKey(cfg.Id) == false)
                {
                    roleData.partScoreListDic.Add(cfg.Id, new List<float>());
                }

                if (roleData.partListDic.ContainsKey(cfg.Id) == false)
                {
                    roleData.partListDic.Add(cfg.Id, new List<int>());
                }
            }

            for (int i = 0; i < roleData.itemList.Count; i++)
            {
                for (int j = 0; j < typeCfgs.Count; j++)
                {
                    FightScoreCfg cfg = typeCfgs[j];
                    bool isCheckFinish = false;

                    for (int k = 0; k < cfg.SubTypes.Count; k++)
                    {
                        ItemCfg itemCfg = CommonDataManager.Tables.TblItemCfg.GetOrDefault(roleData.itemList[i]);
                        if (itemCfg != null && itemCfg.SubType == cfg.SubTypes[k])
                        {
                            roleData.partListDic[cfg.Id].Add(roleData.itemList[i]);
                            roleData.partScoreListDic[cfg.Id].Add(roleData.itemScoreList[i]);
                            isCheckFinish = true;
                            break;
                        }
                    }

                    if (isCheckFinish) break;
                }
            }
        }

        /// <summary>
        /// 返回总主属性分
        /// </summary>
        /// <returns></returns>
        public double GetMainScore(FightData roleData)
        {
            //（部件属性分数+标签分数+人物基础分+雅集技能分+词牌属性分数）*4

            // int partScore = 0;
            // double tagScore = 0;
            // int tagCount = 0;
            double baseScore = 0;

            for (int i = 0; i < CommonDataManager.Tables.TblFightScoreCfg.DataList.Count; i++)
            {
                baseScore += GetroundBaseScore(roleData, i + 1);
            }


            return (baseScore + roleData.baseScore + roleData.leagueSkillScore + roleData.cardScore) *
                   ConstScoreSystem.MAIN_SCORE;
        }

        public double GetRobotMainScore(FightData robotData)
        {
            //（部件属性分数+标签分数+人物基础分+词牌属性分数）*4

            double partScore = 0;

            for (int i = 0; i < CommonDataManager.Tables.TblFightScoreCfg.DataList.Count; i++)
            {
                partScore += GetRobotRoundBaseScore(robotData, i + 1);
            }

            return (partScore + robotData.baseScore + robotData.leagueSkillScore + robotData.cardScore) *
                   ConstScoreSystem.MAIN_SCORE;
        }


        /// <summary>
        /// 回合评分
        /// </summary>
        /// <param name="roundId">部件id</param>
        /// <param name="clickType">点击状态0：miss，1：优秀，2：完美</param>
        /// <param name="mainScore">总主属性</param>
        /// <param name="type">评分部位</param>
        /// <param name="showCard">是否展示词牌效果</param>
        /// <returns></returns>
        public int GetRoundScore(FightData roleData, int roundId, int clickType, double skillScore = 0)
        {
            //部件评分=部件基础分*部件系数
            //词牌评分=总属性*技能配表百分比
            double partBaseScore = GetroundBaseScore(roleData, roundId);

            double partScore = partBaseScore * ConstScoreSystem.PART_SCORE;

            int roleScore = roleData.baseScore;
            long leagueSkillScore = roleData.leagueSkillScore;
            int cardScore = roleData.cardScore;

            double clickCoefficient = GetRoundItemClickScore(clickType);
            //start------------------------------------------------------
            //本段注释为上个版本的计算公式，留做备份参考
            //点击评分=（部件基础分+（人物基础分+雅集技能分+词牌属性分数）*点击系数）*2.22   (防止点击优秀却因为未穿衣服结果是0分)
            //double clickScore = (partBaseScore + (roleScore + leagueSkillScore + cardScore) * clickCoefficient) * ConstScoreSystem.CLICK_SCORE;
            //end--------------------------------------------------------
            //改为 点击评分 =（部件基础分+人物基础分）*点击系数
            double clickScore = (partBaseScore + roleScore) * clickCoefficient;
            int score = (int)Math.Ceiling(partScore + clickScore);
            return Math.Max(0, score);
        }

        /// <summary>
        /// 根据搭配学院获得服装分类基础分加成
        /// CollectPartDataManager.partIndex: 1.连衣裙或者上衣、下装及内搭 2.发型 3.外套4.袜子 5.鞋子6.饰品7.手持物
        /// </summary>
        public float CollegeAddition(int roundId)
        {
            int additionNum = 1;

            switch (roundId)
            {
                case 1:
                    additionNum += CollectPartDataManager.Instance.CollectPartDataDic[2][2] / 10000;
                    break;
                case 2:
                    break;
                case 3:
                    additionNum += CollectPartDataManager.Instance.CollectPartDataDic[6][2] / 10000;
                    break;
                case 4:
                    additionNum += CollectPartDataManager.Instance.CollectPartDataDic[7][2] / 10000;
                    break;
                case 5:
                    additionNum += CollectPartDataManager.Instance.CollectPartDataDic[4][2] / 10000 +
                                   CollectPartDataManager.Instance.CollectPartDataDic[5][2] / 10000;
                    break;
                case 6:
                    additionNum += CollectPartDataManager.Instance.CollectPartDataDic[1][2] / 10000 +
                                   CollectPartDataManager.Instance.CollectPartDataDic[3][2] / 10000;
                    break;
            }

            return additionNum;
        }

        public int GetRobotRoundScore(FightData robotData, int roundId, int clickType, double skillScore)
        {
            //部件评分=部件基础分*部件系数
            //词牌评分=总属性*技能配表百分比
            double partBaseScore = GetRobotRoundBaseScore(robotData, roundId);

            double partScore = partBaseScore * ConstScoreSystem.PART_SCORE;

            int roleScore = robotData.baseScore;
            long leagueSkillScore = robotData.leagueSkillScore;
            int cardScore = robotData.cardScore;

            double clickCoefficient = GetRoundItemClickScore(clickType);
            //start------------------------------------------------------
            //本段注释为上个版本的计算公式，留做备份参考
            //点击评分=（部件基础分+（人物基础分+词牌属性分数）*点击系数）*2.22   (防止点击优秀却因为未穿衣服结果是0分)
            //double clickScore = (partBaseScore + (cardScore + leagueSkillScore + roleScore) * clickCoefficient) * ConstScoreSystem.CLICK_SCORE;
            //end--------------------------------------------------------
            //改为 点击评分 =（部件基础分+人物基础分）*点击系数
            double clickScore = (partBaseScore + roleScore) * clickCoefficient;
            int score = (int)Math.Ceiling(partScore + clickScore + skillScore);
            return Math.Max(0, score);
        }

        /// <summary>
        /// 回合基础评分
        /// </summary>
        /// <param name="roundId">评分部位</param>
        /// <returns></returns>
        public double GetroundBaseScore(FightData roleData, int roundId)
        {
            double partScore = 0;
            double tagScore = 0;
            int tagCount = 0;
            if (!roleData.partListDic.ContainsKey(roundId) || roleData.partListDic[roundId].Count == 0)
                return partScore;

            List<int> partList = roleData.partListDic[roundId];
            for (int i = 0; i < partList.Count; i++)
            {
                partScore += roleData.partScoreListDic[roundId][i];
                tagScore += ItemDataManager.GetItemTagScore(partList[i], roleData.tags);
                // if (ItemDataManager.CheckItemTagsRight(partList[i], roleData.tags)) tagCount++;
            }

            if (InstanceZonesDataManager.FightScene == ConstInstanceZonesType.Arena ||
                InstanceZonesDataManager.FightScene == ConstInstanceZonesType.FieldWork)
            {
                tagCount = ArenaDataManager.Instance.GetTagsCount(roleData.itemList, roleData.tags);
                tagCount = Math.Min(CommonDataManager.Tables.TblArenaTagCfg.DataList.Count, tagCount);
                float addition = 0;
                if (tagCount > 0)
                {
                    addition = CommonDataManager.Tables.TblArenaTagCfg.GetOrDefault(tagCount).Addition / 10000f;
                }

                return (partScore + tagScore) * (1 + addition);
            }
            else
            {
                return partScore + tagScore;
            }
        }

        /// <summary>
        /// 部件基础分之和
        /// </summary>
        /// <param name="roleData"></param>
        /// <returns></returns>
        public double GetAllRoundBaseScore(FightData roleData)
        {
            double baseScore = 0;

            for (int i = 0; i < CommonDataManager.Tables.TblFightScoreCfg.DataList.Count; i++)
            {
                baseScore += GetroundBaseScore(roleData, i + 1);
            }

            return baseScore;
        }

        private double GetRobotRoundBaseScore(FightData robotData, int roundId)
        {
            double partBaseScore = robotData.itemScoreList[roundId - 1];
            if (InstanceZonesDataManager.FightScene == ConstInstanceZonesType.Arena ||
                InstanceZonesDataManager.FightScene == ConstInstanceZonesType.FieldWork)
            {
                partBaseScore = partBaseScore * (1 + robotData.tagAddition / 10000f);
            }

            return partBaseScore;
        }


        private double GetRoundItemClickScore(int clickType)
        {
            //点击评分=（部件基础分+（人物基础分+词牌属性分数）*点击系数）*2.22
            double clickCoefficient = 0;
            switch (clickType)
            {
                case ClickType.MISS_CLICK:
                    clickCoefficient = ConstScoreSystem.MISS_SCORE;
                    break;
                case ClickType.GOOD_CLICK:
                    clickCoefficient = ConstScoreSystem.GREAT_SCORE;
                    break;
                case ClickType.PERFECT_CLICK:
                    clickCoefficient = ConstScoreSystem.PERFECT_SCORE;
                    break;
            }

            return clickCoefficient;
        }

        /// <summary>
        /// 获取词牌技能持续回合数
        /// </summary>
        /// <returns></returns>
        public List<int> GetRoundTime(int cardId, List<int> skillLvs)
        {
            List<int> roundTimes = new List<int>();


            List<PassivitySkillCfg> targetSkillCfgs =
                CommonDataManager.Tables.TblPassivitySkillCfg.DataList.Where(a => a.CardId == cardId).ToList();
            for (int i = 0; i < targetSkillCfgs.Count; i++)
            {
                if (skillLvs.Count <= i) continue;
                int skillLv = skillLvs[i];
                PassivitySkillLvlCfg skillLvlCfg =
                    CommonDataManager.Tables.TblPassivitySkillLvlCfg.Get(skillLv, targetSkillCfgs[i].SkillId);
                if (skillLvlCfg.BeginTime == SkillBeginTime.FIGHT_BEGIN &&
                    UnityEngine.Random.Range(0, 10000) < skillLvlCfg.Probability)
                {
                    roundTimes.Add(skillLvlCfg.RoundTime);
                }
                else
                {
                    roundTimes.Add(0);
                }
            }

            return roundTimes;
        }


        /// <summary>
        /// 获取有效技能配置，过滤掉：被对方失效的、不符合作用时机、未满足触发概率的技能
        /// </summary>
        /// <returns></returns>
        public List<PassivitySkillLvlCfg> GetValidSkills(int currentTime, int roundId, int cardId, List<int> skillLvs,
            int targetCardId, List<int> targetSkillLvs, List<int> roundTimes, List<int> targetRoundTimes)
        {
            List<PassivitySkillLvlCfg> skillCfgs = new List<PassivitySkillLvlCfg>();

            List<PassivitySkillCfg> targetSkillCfgs =
                CommonDataManager.Tables.TblPassivitySkillCfg.DataList.Where(a => a.CardId == targetCardId).ToList();

            //找到敌方对我的减益技能
            List<int> nullifySkillIndex = new List<int>();
            if (targetSkillCfgs != null)
            {
                for (int i = 0; i < targetSkillCfgs.Count; i++)
                {
                    if (targetSkillLvs.Count <= i) continue;
                    PassivitySkillLvlCfg targetSkillLvlCfg =
                        CommonDataManager.Tables.TblPassivitySkillLvlCfg.Get(targetSkillLvs[i],
                            targetSkillCfgs[i].SkillId);
                    if (CheckIsRightTime(targetSkillLvlCfg, currentTime, roundId))
                    {
                        bool isProbability = targetSkillLvlCfg.NullifySkillIndex > 0 &&
                                             UnityEngine.Random.Range(0, 10000) < targetSkillLvlCfg.Probability;
                        if (targetSkillLvlCfg.BeginTime == SkillBeginTime.FIGHT_BEGIN && targetRoundTimes.Count > i &&
                            roundId < targetRoundTimes[i]) isProbability = true;
                        if (isProbability) nullifySkillIndex.Add(targetSkillLvlCfg.NullifySkillIndex);
                    }
                }
            }

            List<PassivitySkillCfg> mySkillCfgs =
                CommonDataManager.Tables.TblPassivitySkillCfg.DataList.Where(a => a.CardId == cardId).ToList();

            for (int i = 0; i < mySkillCfgs.Count; i++)
            {
                if (skillLvs.Count <= i) continue;
                PassivitySkillLvlCfg mySkillLvlCfg =
                    CommonDataManager.Tables.TblPassivitySkillLvlCfg.Get(skillLvs[i], mySkillCfgs[i].SkillId);

                if (nullifySkillIndex.IndexOf(i + 1) >= 0) continue; //技能被对手失效

                if (CheckIsRightTime(mySkillLvlCfg, currentTime, roundId))
                {
                    bool isProbability = UnityEngine.Random.Range(0, 10000) < mySkillLvlCfg.Probability;
                    if ((mySkillLvlCfg.BeginTime == currentTime || roundId == mySkillLvlCfg.BeginTime) &&
                        roundTimes != null /*&& roundId < roundTimes[i]*/)
                        isProbability = true;
                    else
                        isProbability = false;

                    if (isProbability) skillCfgs.Add(mySkillLvlCfg);
                }
            }

            return skillCfgs;
        }

        private bool CheckIsRightTime(PassivitySkillLvlCfg skillLvlCfg, int currentTime, int roundId)
        {
            if (skillLvlCfg.BeginTime == SkillBeginTime.FIGHT_BEGIN && currentTime == SkillBeginTime.ERVERY_ROUND_BEGIN
                || skillLvlCfg.BeginTime == SkillBeginTime.PERFECT_CLICK && currentTime == SkillBeginTime.PERFECT_CLICK
                || skillLvlCfg.BeginTime == SkillBeginTime.ERVERY_ROUND_BEGIN &&
                currentTime == SkillBeginTime.ERVERY_ROUND_BEGIN
                || skillLvlCfg.BeginTime == SkillBeginTime.ERVERY_ROUND_END &&
                currentTime == SkillBeginTime.ERVERY_ROUND_END
                || skillLvlCfg.BeginTime == SkillBeginTime.ALL_PERFECT_START &&
                currentTime == SkillBeginTime.ALL_PERFECT_START
                || skillLvlCfg.BeginTime == SkillBeginTime.FIGHT_BEGIN && currentTime == SkillBeginTime.FIGHT_BEGIN
                || skillLvlCfg.BeginTime <= SkillBeginTime.ROUND_6 &&
                currentTime == SkillBeginTime.ERVERY_ROUND_BEGIN && roundId == skillLvlCfg.BeginTime)
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// 本轮技能分数
        /// </summary>
        /// <param name="validSkills">有效技能列表</param>
        /// <param name="mainScore">总主属性</param>
        /// <returns></returns>
        public void GetRoundItemSkillScore(List<PassivitySkillLvlCfg> validSkills, double mainScore,
            double targetMainScore, out int skillScore, out int targetScore, out Dictionary<int, int> skillsToShowDic)
        {
            double _skillScore = 0;
            double _targetSkillScore = 0;
            skillsToShowDic = new Dictionary<int, int>();
            for (int i = 0; i < validSkills.Count; i++)
            {
                if (validSkills[i].Target == 1 && mainScore > 0) //作用自身
                {
                    double score = mainScore * validSkills[i].Ratio / 10000;
                    _skillScore += score;
                    skillsToShowDic.Add(validSkills[i].SkillId, (int)Math.Ceiling(score));
                }
                else if (validSkills[i].Target == 2 && targetMainScore > 0) //作用对方
                {
                    double score = mainScore * validSkills[i].Ratio / 10000;
                    _targetSkillScore += score;
                    skillsToShowDic.Add(validSkills[i].SkillId, (int)Math.Ceiling(score));
                }
            }

            skillScore = (int)Math.Ceiling(_skillScore);
            targetScore = (int)Math.Ceiling(_targetSkillScore);
        }

        /// <summary>
        /// 是否展示词牌效果
        /// </summary>
        /// <param name="cardId">词牌id</param>
        /// <param name="validSkills">被触发的有效技能列表</param>
        /// <returns></returns>
        public bool IsShowCard(int cardId, List<PassivitySkillLvlCfg> validSkills)
        {
            if (cardId <= 0) return false; //未选卡
            if (validSkills.Count == 0) return false; //本轮没有技能被触发不显示词牌
            List<PassivitySkillCfg> skillCfgs = CommonDataManager.Tables.TblPassivitySkillCfg.DataList
                .Where(a => a.CardId == cardId).ToList();

            for (int i = 0; i < skillCfgs.Count; i++)
            {
                if (skillCfgs[i].MainSkill == 1)
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 登峰造极额外加分
        /// </summary>
        /// <param name="mainScore"></param>
        /// <returns></returns>
        public int GetAllCircleAddScore(FightData fightData)
        {
            //登峰造极评分 = （部件基础分之和 + 人物基础分）*卓越点击系数 * 3
            double allPartsBaseScore = GetAllRoundBaseScore(fightData);
            return (int)Math.Ceiling((allPartsBaseScore + (double)fightData.baseScore) *
                                     ConstScoreSystem.PERFECT_SCORE * ConstScoreSystem.ALL_CIRCLE_SCORE);
        }


        /// <summary>
        /// 根据词牌Id获取 战斗选卡 界面显示配置
        /// </summary>
        /// <param name="cardId"></param>
        /// <returns></returns>
        public PassivitySkillCfg GetShowSkillCfg(int cardId)
        {
            List<PassivitySkillCfg> skillCfgs = CommonDataManager.Tables.TblPassivitySkillCfg.DataList
                .Where(a => a.CardId == cardId).ToList();

            if (skillCfgs.Count <= 0)
            {
                Debug.LogWarning(cardId + " 这张卡片没有配置技能");
                return null;
            }

            for (int i = 0; i < skillCfgs.Count; i++)
            {
                if (skillCfgs[i].ShowSkill == 1)
                {
                    // int skillLv = SkillDataManager.Instance.GetSkillLv(cardId, skillCfgs[i].skillId);
                    return skillCfgs[i];
                }
            }

            return null;
        }


        /// <summary>
        /// 根据词牌Id获取评分主技能显示配置
        /// </summary>
        /// <param name="cardId"></param>
        /// <returns></returns>
        public PassivitySkillCfg GetMainSkillCfg(int cardId)
        {
            // Dictionary<int, List<PassivitySkillCfg>> cfgs = SkillDataManager.Instance.dicPassivitySkill[cardId];
            List<PassivitySkillCfg> skillCfgs = CommonDataManager.Tables.TblPassivitySkillCfg.DataList
                .Where(a => a.CardId == cardId).ToList();
            
            if (skillCfgs.Count <= 0)
            {
                Debug.LogWarning(cardId + " 这张卡片没有配置技能");
                return null;
            }

            // foreach (int key in cfgs.Keys)
            // {
            for (int i = 0; i < skillCfgs.Count; i++)
            {
                if (skillCfgs[i].MainSkill == 1)
                {
                    // int skillLV = SkillDataManager.Instance.GetSkillLv(cardId, skillCfgs[i].skillId);
                    // PassivitySkillLvlCfgArray skillLvCfg = PassivitySkillLvlCfgArray.Instance.GetCfg(skillLV, skillCfgs[i].skillId);
                    // return cfgs[key][skillLV - 1];
                    return skillCfgs[i];
                }
            }

            return null;
        }
    }
}