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

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

namespace GFGGame
{
    public class FightDataManager : SingletonBase<FightDataManager>
    {
        //public byte[] FightRoleRes { get; set; }
        //public Texture2D RoleTextuex { get; set; }

        //角色基础分+部件基础分
        // private int _score;
        // public int score
        // {
        //     get
        //     {
        //         return _score;
        //     }
        //     set
        //     {
        //         _score = value;
        //         EventAgent.DispatchEvent(ConstMessage.DRESS_UP_SCORE_CHANGED, _score);
        //     }
        // }

        public void Clear()
        {
            maxFightSpeed = 3;
            _fightSpeed = 1;
            _autoPlay = false;
            _storyDialogSpeed = 1;
            _totalScore = 0;
            _targetTotalScore = 0;
        }

        public int GetScore(FightData roleData)
        {
            float score = 0;

            for (int i = 0; i < roleData.itemList.Count; i++)
            {
                score += ItemDataManager.GetArenaScore(roleData.itemList[i], roleData.scoreType, roleData.tags);
            }

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

                score = score * (1 + addition);
            }

            return (int)Math.Ceiling(score);
        }

        //最终得分
        private int _totalScore;

        public int totalScore
        {
            get { return _totalScore; }
            set { _totalScore = value; }
        }

        //战斗对象最终得分
        private int _targetTotalScore;

        public int npcTotalScore
        {
            get { return _targetTotalScore; }
            set { _targetTotalScore = value; }
        }

        private bool _autoPlay = false;

        public bool autoPlay
        {
            get { return _autoPlay; }
            set
            {
                _autoPlay = value;
                if (!_autoPlay) fightSpeed = 1;
                StorageSProxy.ReqSetClientValue(ConstStorageId.STORAGE_AUTO_PLAY, _autoPlay == true ? 1 : 0)
                    .Coroutine();
            }
        }

        public int maxFightSpeed = 3;
        private int _fightSpeed = 1;

        public int fightSpeed
        {
            get { return _fightSpeed; }
            set
            {
                _fightSpeed = value;
                StorageSProxy.ReqSetClientValue(ConstStorageId.STORAGE_FIGHT_AUTO_PLAY_SPEED, _fightSpeed).Coroutine();
            }
        }

        private int _storyDialogSpeed = 1;

        public int dialogSpeed
        {
            get { return _storyDialogSpeed; }
            set
            {
                _storyDialogSpeed = value;
                StorageSProxy.ReqSetClientValue(ConstStorageId.STORAGE_DIALOG_AUTO_PLAY_SPEED, _storyDialogSpeed)
                    .Coroutine();
            }
        }


        //根据位置原点和随机范围获取评分位置
        public void GetCirclePos(Vector2 pos, int range, out float x, out float y)
        {
            int numX = UnityEngine.Random.Range(0, 2);
            int signX = numX % 2 == 0 ? 1 : -1;
            float rangeX = UnityEngine.Random.Range(0, range);
            x = pos.x + signX * (rangeX);

            int numY = UnityEngine.Random.Range(0, 2);
            int signY = numY % 2 == 0 ? 1 : -1;
            float rangeY = UnityEngine.Random.Range(0, range);
            y = pos.y + signY * (rangeY);
        }


        //public Texture2D GetPrintscreenNTexture(Camera camera)
        //{

        //    RenderTexture rt = new RenderTexture(UnityEngine.Screen.width, UnityEngine.Screen.height, 0);//渲染一张1920*1080的图
        //    camera.targetTexture = rt;//传到主摄像机上
        //    camera.Render();//渲染
        //    RenderTexture.active = rt;
        //    Texture2D screenShot = new Texture2D(UnityEngine.Screen.width, UnityEngine.Screen.height, TextureFormat.ARGB32, false);
        //    screenShot.ReadPixels(new Rect(0, 0, UnityEngine.Screen.width, UnityEngine.Screen.height), 0, 0);//读像素
        //    screenShot.Apply();
        //    camera.targetTexture = null;
        //    RenderTexture.active = null;
        //    UnityEngine.Object.Destroy(rt);
        //    return screenShot;

        //}

        /// <summary>
        /// 获取标签总分数
        /// </summary>
        /// <param name="itemList">服装列表</param>
        /// <param name="tags">标签</param>
        /// <returns></returns>
        public int GetTagsScore(List<int> itemList, List<string> tags)
        {
            int score = 0;
            for (int i = 0; i < itemList.Count; i++)
            {
                score += ItemDataManager.GetItemTagScore(itemList[i], tags);
            }

            return score;
        }


        public void SetItemScoreList(FightData _roleData)
        {
            _roleData.itemScoreList.Clear();
            _roleData.itemScoreDic.Clear();
            for (int i = 0; i < _roleData.itemList.Count; i++)
            {
                int score = ItemDataManager.GetArenaScore(_roleData.itemList[i], _roleData.scoreType);
                _roleData.itemScoreList.Add(score);
                _roleData.itemScoreDic[_roleData.itemList[i]] = score;
            }
        }

        public float GetDressListAllScore(List<int> itemList, int scoreType)
        {
            float itemSum = 0;
            for (int i = 0; i < itemList.Count; i++)
            {
                itemSum += ItemDataManager.GetArenaScore(itemList[i], scoreType);
            }

            return itemSum;
        }

        /// <summary>
        /// 0失败1优秀2完美
        /// </summary>
        /// <param name="scale"></param>
        /// <returns></returns>
        public int GetClickType(float scale)
        {
            // float scaleX = _ui.m_comClick.m_comResult.m_imgCircle.scale.x;
            int clickType = ClickType.MISS_CLICK;
            if (FightDataManager.Instance.autoPlay == true)
            {
                return ClickType.PERFECT_CLICK;
            }

            if (scale <= 0.55f && scale > 0.45f)
            {
                clickType = ClickType.PERFECT_CLICK;
            }
            else if (scale <= 0.05f)
            {
                clickType = ClickType.MISS_CLICK;
            }
            else
            {
                clickType = ClickType.GOOD_CLICK;
            }

            return clickType;
        }

        /// <summary>
        /// 词牌列表按竞技战力排序
        /// </summary>
        /// <param name="arrayList"></param>
        /// <returns></returns>
        public List<CardData> SortCardList(List<CardData> cardList, double itemSum, int scoreType)
        {
            int baseScore = CommonDataManager.Tables.TblRoleLevelCfg.GetOrDefault(RoleDataManager.lvl).BaseScore;
            int leagueSkillScore = LeagueDataManager.Instance.GetAllSkillScore(scoreType);
            cardList.Sort((CardData a, CardData b) =>
            {
                List<int> skillLvsA = SkillDataManager.Instance.GetCardSkillLvs(a.id);
                List<int> skillLvsB = SkillDataManager.Instance.GetCardSkillLvs(b.id);
                //start===============================
                //double addA = a.scores[scoreType] * ConstScoreSystem.PERFECT_SCORE * ConstScoreSystem.CLICK_SCORE / ConstScoreSystem.PART_SCORE * 6d;
                //double addB = b.scores[scoreType] * ConstScoreSystem.PERFECT_SCORE * ConstScoreSystem.CLICK_SCORE / ConstScoreSystem.PART_SCORE * 6d;
                //因为这里只是排序，不需要计算完整分数
                //end=================================
                double addA = a.scores[scoreType];
                double addB = b.scores[scoreType];
                double scoreA = GetSkillFightScore(itemSum, baseScore, leagueSkillScore, a.id, a.scores[scoreType],
                    skillLvsA) + addA;
                double scoreB = GetSkillFightScore(itemSum, baseScore, leagueSkillScore, b.id, b.scores[scoreType],
                    skillLvsB) + addB;
                if (scoreA < scoreB)
                {
                    return 1;
                }
                else if (scoreA > scoreB)
                {
                    return -1;
                }

                return string.Compare(a.itemCfg.Res, b.itemCfg.Res);
            });
            return cardList;
        }

        /// <summary>
        /// 获取技能战力
        /// </summary>
        /// <param name="itemScoreSum"></param>
        /// <param name="baseScore"></param>
        /// <param name="cardId"></param>
        /// <param name="cardScore"></param>
        /// <param name="skillLvs"></param>
        /// <returns></returns>
        public long GetSkillFightScore(double itemScoreSum, int baseScore, long leagueSkillScore, int cardId,
            int cardScore, List<int> skillLvs)
        {
            float skillScore = 0;
            if (skillLvs.Count == 0) return (long)skillScore;
            float skillBaseScore = (long)itemScoreSum + cardScore + baseScore + leagueSkillScore;
            List<PassivitySkillCfg> skillCfgs = CommonDataManager.Tables.TblPassivitySkillCfg.DataList
                .Where(a => a.CardId == cardId).ToList();

            //容错处理，防止两个长度不一致
            var count = Mathf.Min(skillLvs.Count, skillCfgs.Count);
            for (int j = 0; j < count; j++)
            {
                PassivitySkillLvlCfg skillLvlCfg =
                    CommonDataManager.Tables.TblPassivitySkillLvlCfg.Get(skillLvs[j], skillCfgs[j].SkillId);
                if (skillLvlCfg == null) continue;
                skillScore += skillBaseScore * ((float)skillLvlCfg.FightPowerParam / 10000f);
            }

            // ET.Log.Debug("cardId:" + cardId);
            // ET.Log.Debug("skillScore:" + skillScore);
            return (long)Math.Ceiling(skillScore);
            ;
        }

        /// <summary>
        /// 获取快速挑战结果
        /// </summary>
        /// <param name="myRoleData"></param>
        /// <param name="targetType"></param>
        /// <param name="targetRoleData"></param>
        /// <param name="targetRobotData"></param>
        /// <param name="_score"></param>
        /// <param name="_targetScore"></param>
        public void GetQuickFightResult(int roundIndex, FightData myRoleData, FightData targetRoleData, out long _score,
            out long _targetScore)
        {
            double score = 0;
            double targetScore = 0;

            int cardId = myRoleData.cardId;
            double mainScore = ScoreSystemData.Instance.GetMainScore(myRoleData);
            List<int> skillLvs = myRoleData.skillLvs;

            int targetCardId;
            double targetMainScore;
            List<int> targetSkillLvs;
            List<int> targetRoundTime;
            List<int> roundTime = ScoreSystemData.Instance.GetRoundTime(myRoleData.cardId, myRoleData.skillLvs);

            targetCardId = targetRoleData.cardId;
            targetSkillLvs = targetRoleData.skillLvs;
            targetRoundTime = ScoreSystemData.Instance.GetRoundTime(targetRoleData.cardId, targetRoleData.skillLvs);

            if (targetRoleData.type == FightTargetType.PLAYER)
            {
                targetMainScore = ScoreSystemData.Instance.GetMainScore(targetRoleData);
            }
            else
            {
                targetMainScore = ScoreSystemData.Instance.GetRobotMainScore(targetRoleData);
            }

            if (InstanceZonesDataManager.FightScene == ConstInstanceZonesType.Arena ||
                InstanceZonesDataManager.FightScene == ConstInstanceZonesType.FieldWork)
            {
                ArenaDataManager.Instance.roundTime = roundTime;
                ArenaDataManager.Instance.targetRoundTime = targetRoundTime;
                if (!ArenaDataManager.Instance.vaildSkills.ContainsKey(roundIndex))
                    ArenaDataManager.Instance.vaildSkills[roundIndex] =
                        new Dictionary<int, Dictionary<int, List<PassivitySkillLvlCfg>>>();
                if (!ArenaDataManager.Instance.targetVaildSkills.ContainsKey(roundIndex))
                    ArenaDataManager.Instance.targetVaildSkills[roundIndex] =
                        new Dictionary<int, Dictionary<int, List<PassivitySkillLvlCfg>>>();
            }

            int roundId = 0;
            int currentTime = SkillBeginTime.FIGHT_BEGIN;
            GetSkillScore(FightRoleType.MINE, roundIndex, currentTime, roundId, mainScore, cardId, skillLvs, roundTime,
                ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore);
            GetSkillScore(FightRoleType.TAEGET, roundIndex, currentTime, roundId, targetMainScore, targetCardId,
                targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime, ref score);
            for (int i = 0; i < CommonDataManager.Tables.TblFightScoreCfg.DataList.Count; i++)
            {
                roundId++;
                currentTime = SkillBeginTime.ERVERY_ROUND_BEGIN;
                GetSkillScore(FightRoleType.MINE, roundIndex, currentTime, roundId, mainScore, cardId, skillLvs,
                    roundTime, ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime,
                    ref targetScore);
                GetSkillScore(FightRoleType.TAEGET, roundIndex, currentTime, roundId, targetMainScore, targetCardId,
                    targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime,
                    ref score);
                score += ScoreSystemData.Instance.GetRoundScore(myRoleData, roundId, ClickType.PERFECT_CLICK, 0);
                if (targetRoleData.type == FightTargetType.PLAYER)
                {
                    targetScore +=
                        ScoreSystemData.Instance.GetRoundScore(targetRoleData, roundId, ClickType.PERFECT_CLICK, 0);
                }
                else
                {
                    targetScore +=
                        ScoreSystemData.Instance.GetRobotRoundScore(targetRoleData, roundId, ClickType.PERFECT_CLICK,
                            0);
                }

                currentTime = SkillBeginTime.PERFECT_CLICK;
                GetSkillScore(FightRoleType.MINE, roundIndex, currentTime, roundId, mainScore, cardId, skillLvs,
                    roundTime, ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime,
                    ref targetScore);
                GetSkillScore(FightRoleType.TAEGET, roundIndex, currentTime, roundId, targetMainScore, targetCardId,
                    targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime,
                    ref score);
                currentTime = SkillBeginTime.ERVERY_ROUND_END;
                GetSkillScore(FightRoleType.MINE, roundIndex, currentTime, roundId, mainScore, cardId, skillLvs,
                    roundTime, ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime,
                    ref targetScore);
                GetSkillScore(FightRoleType.TAEGET, roundIndex, currentTime, roundId, targetMainScore, targetCardId,
                    targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime,
                    ref score);
                // Debug.Log(" targetScore444:" + targetScore);
            }

            roundId++;
            currentTime = SkillBeginTime.ALL_PERFECT_START;
            GetSkillScore(FightRoleType.MINE, roundIndex, currentTime, roundId, mainScore, cardId, skillLvs, roundTime,
                ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore);
            GetSkillScore(FightRoleType.TAEGET, roundIndex, currentTime, roundId, targetMainScore, targetCardId,
                targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime, ref score);
            score += ScoreSystemData.Instance.GetAllCircleAddScore(myRoleData);
            targetScore += ScoreSystemData.Instance.GetAllCircleAddScore(targetRoleData);
            Debug.Log(" targetScore666:" + targetScore);
            _score = Mathf.CeilToInt((float)score);
            _targetScore = Mathf.CeilToInt((float)targetScore);
        }

        private void GetSkillScore(int roleType, int roundIndex, int currentTime, int partId, double mainScore,
            int cardId, List<int> skillLvs, List<int> roundTime, ref double score, double targetMainScore,
            int targetCardId, List<int> targetSkillLvs, List<int> targetRoundTime, ref double targetScore)
        {
            List<PassivitySkillLvlCfg> vaildSkills = ScoreSystemData.Instance.GetValidSkills(currentTime, partId,
                cardId, skillLvs, targetCardId, targetSkillLvs, roundTime, targetRoundTime);
            ScoreSystemData.Instance.GetRoundItemSkillScore(vaildSkills, mainScore, targetMainScore, out int skillScore,
                out int targetSkillScore, out Dictionary<int, int> skillScoreDic);

            score += skillScore;
            targetScore += targetSkillScore;

            if (InstanceZonesDataManager.FightScene == ConstInstanceZonesType.Arena ||
                InstanceZonesDataManager.FightScene == ConstInstanceZonesType.FieldWork)
            {
                ArenaDataManager dataManager = ArenaDataManager.Instance;
                if (roleType == FightRoleType.MINE)
                {
                    if (!dataManager.vaildSkills[roundIndex].ContainsKey(partId))
                        dataManager.vaildSkills[roundIndex][partId] = new Dictionary<int, List<PassivitySkillLvlCfg>>();
                    dataManager.vaildSkills[roundIndex][partId][currentTime] = vaildSkills;
                }
                else
                {
                    if (!dataManager.targetVaildSkills[roundIndex].ContainsKey(partId))
                        dataManager.targetVaildSkills[roundIndex][partId] =
                            new Dictionary<int, List<PassivitySkillLvlCfg>>();
                    dataManager.targetVaildSkills[roundIndex][partId][currentTime] = vaildSkills;
                }
            }
        }
    }
}