竞技场快速挑战

GameClient/Assets/Game/HotUpdate/Data/ArenaDataManager.cs

@@ -12,7 +12,7 @@ namespace GFGGame
         public int Rank = 10000;//本赛季段位内排名
         public int HighestGrade = 1;//本赛季最高段位
         public int HighestRank = 10000; //本赛最高季段位内排名
-        public Dictionary<int, FightRoleData> DressupDic = new Dictionary<int, FightRoleData>();//我的搭配列表
+        public List<FightRoleData> DressupList = new List<FightRoleData>();//我的搭配列表
         public List<ArenaTargetData> Targets = new List<ArenaTargetData>();//对手
         public ArenaTargetData SelfData = new ArenaTargetData();//自己的排行榜信息
         public List<ArenaTargetData> rankDatas = new List<ArenaTargetData>();//排行榜数据
@@ -24,7 +24,7 @@ namespace GFGGame
 
         public void Clear()
         {
-            DressupDic.Clear();
+            DressupList.Clear();
             Targets.Clear();
         }
 

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

@@ -183,7 +183,7 @@ namespace GFGGame
             robotData.cardId = fightCfg.targetCardId;
             robotData.cardScore = fightCfg.targetCardScore;
             robotData.skillLvs = new List<int>(fightCfg.targetSkillLvsArr);
-            robotData.targetPareScorList = new List<int>(fightCfg.targetPartsScoreArr);
+            robotData.itemScoreList = new List<int>(fightCfg.targetPartsScoreArr);
             return robotData;
         }
 
@@ -225,5 +225,78 @@ namespace GFGGame
             }
             return clickType;
         }
+
+        public void GetQuickFightResult(FightRoleData myRoleData, int targetType, FightRoleData targetRoleData, FightRobotData targetRobotData, out int _score, out int _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);
+
+            if (targetType == ArenaFightTargetType.PLAYER)
+            {
+                targetCardId = targetRoleData.cardId;
+                targetSkillLvs = targetRoleData.skillLvs;
+                targetMainScore = ScoreSystemData.Instance.GetMainScore(targetRoleData);
+                targetRoundTime = ScoreSystemData.Instance.GetRoundTime(targetRoleData.cardId, targetRoleData.skillLvs);
+            }
+            else
+            {
+                targetCardId = targetRobotData.cardId;
+                targetSkillLvs = targetRobotData.skillLvs;
+                targetMainScore = ScoreSystemData.Instance.GetRobotMainScore(targetRobotData);
+                targetRoundTime = ScoreSystemData.Instance.GetRoundTime(targetRobotData.cardId, targetRobotData.skillLvs);
+            }
+
+            int partId = 0;
+            int currentTime = BeginTime.PART_ALL_FIGHT_BEGIN;
+            GetSkillScore(currentTime, partId, mainScore, cardId, skillLvs, roundTime, ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore);
+            GetSkillScore(currentTime, partId, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime, ref score);
+
+            for (int i = 0; i < FightScoreCfgArray.Instance.dataArray.Length; i++)
+            {
+                partId++;
+
+                currentTime = BeginTime.PART_FIGHT_BEGIN;
+                GetSkillScore(currentTime, partId, mainScore, cardId, skillLvs, roundTime, ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore);
+                GetSkillScore(currentTime, partId, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime, ref score);
+                score += ScoreSystemData.Instance.GetPartScore(myRoleData, partId, ClickType.PREFACT_CLICK, 0);
+                if (targetType == ArenaFightTargetType.PLAYER)
+                {
+                    targetScore += ScoreSystemData.Instance.GetPartScore(targetRoleData, partId, ClickType.PREFACT_CLICK, 0);
+                }
+                else
+                {
+                    targetScore += ScoreSystemData.Instance.GetRobotPartScore(targetRobotData, partId, ClickType.PREFACT_CLICK, 0);
+                }
+                currentTime = BeginTime.PART_PREFACT_CLICK;
+                GetSkillScore(currentTime, partId, mainScore, cardId, skillLvs, roundTime, ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore);
+                GetSkillScore(currentTime, partId, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime, ref score);
+                currentTime = BeginTime.PART_FIGHT_END;
+                GetSkillScore(currentTime, partId, mainScore, cardId, skillLvs, roundTime, ref score, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore);
+                GetSkillScore(currentTime, partId, targetMainScore, targetCardId, targetSkillLvs, targetRoundTime, ref targetScore, mainScore, cardId, skillLvs, roundTime, ref score);
+            }
+            score += ScoreSystemData.Instance.GetAllCircleAddScore(mainScore);
+            targetScore += ScoreSystemData.Instance.GetAllCircleAddScore(targetMainScore);
+            _score = Mathf.CeilToInt((float)score);
+            _targetScore = Mathf.CeilToInt((float)targetScore);
+        }
+
+        private void GetSkillScore(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.GetPartItemSkillScore(vaildSkills, mainScore, targetMainScore, out int skillScore, out int targetSkillScore, out Dictionary<int, int> skillScoreDic);
+            score += skillScore;
+            targetMainScore += targetSkillScore;
+
+        }
     }
 }

GameClient/Assets/Game/HotUpdate/Data/ItemDataManager.cs

@@ -249,5 +249,21 @@ namespace GFGGame
             }
             return score;
         }
+        /// <summary>
+        /// 检测一件服装是否包含要求的标签
+        /// </summary>
+        /// <returns></returns>
+        public static bool CheckItemTagsRight(int itemId, string[] tags)
+        {
+            ItemCfg itemCfg = ItemCfgArray.Instance.GetCfg(itemId);
+            for (int i = 0; i < itemCfg.tagsArr.Length; i++)
+            {
+                for (int j = 0; j < tags.Length; j++)
+                {
+                    if (itemCfg.tagsArr[i][0] == tags[j]) return true;
+                }
+            }
+            return false;
+        }
     }
 }

GameClient/Assets/Game/HotUpdate/Data/ScoreFightQuickManager.cs

@@ -1,7 +0,0 @@
-namespace GFGGame
-{
-    public class ScoreFightQuickManager : SingletonBase<ScoreFightQuickManager>
-    {
-
-    }
-}

GameClient/Assets/Game/HotUpdate/Data/ScoreFightQuickManager.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 47c41f14c9a5a964b95d501f7e09586e
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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

@@ -82,27 +82,28 @@ namespace GFGGame
         {
             //（部件属性分数+标签分数+人物基础分+卡牌属性分数）*4
 
-            int partScore = 0;
-            double tagScore = 0;
+            // int partScore = 0;
+            // double tagScore = 0;
+            // int tagCount = 0;
+            double baseScore = 0;
 
-            for (int i = 0; i < roleData.itemList.Count; i++)
+            for (int i = 0; i < FightScoreCfgArray.Instance.dataArray.Length; i++)
             {
-                partScore += ItemDataManager.GetItemAdditionScore(roleData.itemList[i], roleData.scoreType);
-                tagScore = ItemDataManager.GetItemTagScore(roleData.itemList[i], roleData.tags);
+                baseScore += GetPartBaseScore(roleData, i + 1);
             }
 
-            return (partScore + tagScore + roleData.baseScore + roleData.cardScore) * ConstScoreSystem.MAIN_SCORE;
+            return (baseScore + roleData.baseScore + roleData.cardScore) * ConstScoreSystem.MAIN_SCORE;
         }
 
         public double GetRobotMainScore(FightRobotData robotData)
         {
             //（部件属性分数+标签分数+人物基础分+卡牌属性分数）*4
 
-            int partScore = 0;
+            double partScore = 0;
 
             for (int i = 0; i < FightScoreCfgArray.Instance.dataArray.Length; i++)
             {
-                partScore += robotData.targetPareScorList[i];
+                partScore += GetRobotPartBaseScore(robotData, i);
             }
 
             return (partScore + robotData.baseScore + robotData.cardScore) * ConstScoreSystem.MAIN_SCORE;
@@ -124,7 +125,7 @@ namespace GFGGame
             //部件评分=部件基础分*部件系数
             //点击评分=（部件基础分+（人物基础分+卡牌属性分数）*点击系数）*2.22   (新点击公式，防止点击优秀却因为未穿衣服结果是0分)
             //卡牌评分=总属性*技能配表百分比
-            double partBaseScore = GetPartBaseScore(roleData.pardListDic[partId], roleData.pardScoreListDic[partId]);
+            double partBaseScore = GetPartBaseScore(roleData, partId);
 
             double partScore = partBaseScore * ConstScoreSystem.PART_SCORE;
 
@@ -143,7 +144,7 @@ namespace GFGGame
             //部件评分=部件基础分*部件系数
             //点击评分=（部件基础分+（人物基础分+卡牌属性分数）*点击系数）*2.22   (新点击公式，防止点击优秀却因为未穿衣服结果是0分)
             //卡牌评分=总属性*技能配表百分比
-            double partBaseScore = robotData.targetPareScorList[partId - 1];
+            double partBaseScore = GetRobotPartBaseScore(robotData, partId);
 
             double partScore = partBaseScore * ConstScoreSystem.PART_SCORE;
 
@@ -162,18 +163,39 @@ namespace GFGGame
         /// </summary>
         /// <param name="partId">评分部位</param>
         /// <returns></returns>
-        private double GetPartBaseScore(List<int> partList, List<int> partScoreList)
+        private double GetPartBaseScore(FightRoleData roleData, int partId)
         {
             double partScore = 0;
             double tagScore = 0;
-            if (partScoreList == null || partScoreList.Count == 0) return partScore;
+            int tagCount = 0;
+            if (!roleData.pardListDic.ContainsKey(partId) || roleData.pardListDic[partId].Count == 0) return partScore;
 
-            for (int i = 0; i < partScoreList.Count; i++)
+            List<int> partList = roleData.pardListDic[partId];
+            for (int i = 0; i < partList.Count; i++)
+            {
+                partScore += roleData.pardScoreListDic[partId][i];
+                tagScore += ItemDataManager.GetItemTagScore(partList[i], roleData.tags);
+                if (ItemDataManager.CheckItemTagsRight(partList[i], roleData.tags)) tagCount++;
+            }
+            if (InstanceZonesDataManager.FightScene == ConstInstanceZonesType.Arena)
+            {
+                tagCount = Math.Min(ArenaTagCfgArray.Instance.dataArray.Length, tagCount);
+                double addition = ArenaTagCfgArray.Instance.GetCfg(tagCount).addition / 10000;
+                return (partScore + tagScore) * (1 + addition);
+            }
+            else
+            {
+                return partScore + tagScore;
+            }
+        }
+        private double GetRobotPartBaseScore(FightRobotData robotData, int partId)
+        {
+            double partBaseScore = robotData.itemScoreList[partId - 1];
+            if (InstanceZonesDataManager.FightScene == ConstInstanceZonesType.Arena)
             {
-                partScore += partScoreList[i];
-                tagScore += ItemDataManager.GetItemTagScore(partList[i], InstanceZonesDataManager.currentFightTags);
+                partBaseScore = partBaseScore * (1 + robotData.tagAddition);
             }
-            return partScore + tagScore;
+            return partBaseScore;
         }
 
 
@@ -392,5 +414,91 @@ namespace GFGGame
             return null;
         }
 
+        /// <summary>
+        /// 获取竞技场玩家战力
+        /// </summary>
+        /// <returns></returns>
+        public int GetArenaRoleFightScore(List<FightRoleData> roleDatas)
+        {
+            //竞技场战力=搭配战力+卓越点击战力+卡牌战力
+            //搭配战力=第1套搭配所有部件主属性和+第2套搭配所有部件主属性和+第3套搭配所有部件主属性和
+            //卓越点击战力=卓越点击评分和/2.33
+            //技能战力=（第1套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能1当前等级对应的战力系数+（第1套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能2当前等级对应的战力系数+（第1套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能3当前等级对应的战力系数+（第2套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能1当前等级对应的战力系数+（第2套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能2当前等级对应的战力系数+（第2套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能3当前等级对应的战力系数+（第3套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能1当前等级对应的战力系数+（第3套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能2当前等级对应的战力系数+（第3套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能3当前等级对应的战力系数
+            double fightScore = 0;
+            for (int i = 0; i < roleDatas.Count; i++)
+            {
+                double itemSum = GetItemScoreSum(roleDatas[i].itemScoreList);
+                double clickScore = GetPerfectClickScore(roleDatas[i]) / ConstScoreSystem.PART_SCORE;
+                double skillScore = 0;
+                double skillBaseScore = itemSum + roleDatas[i].cardScore + roleDatas[i].baseScore;
+                List<PassivitySkillCfg> skillCfgs = PassivitySkillCfgArray.Instance.GetCfgsBycardId(roleDatas[i].cardId);
+                for (int j = 0; j < skillCfgs.Count; j++)
+                {
+                    PassivitySkillLvlCfg skillLvlCfg = PassivitySkillLvlCfgArray.Instance.GetCfgByskilllvlAndskillId(roleDatas[i].skillLvs[j], skillCfgs[i].skillId);
+                    if (skillLvlCfg == null) continue;
+                    skillScore += skillBaseScore * skillLvlCfg.fightPowerParam / 10000;
+                }
+                fightScore = itemSum + clickScore + skillScore;
+            }
+            return (int)Math.Ceiling(fightScore);
+        }
+        /// <summary>
+        /// 获取竞技场机器人战力
+        /// </summary>
+        /// <returns></returns>
+        public int GetArenaRobotFightScore(List<FightRobotData> robotDatas)
+        {
+            double fightScore = 0;
+            for (int i = 0; i < robotDatas.Count; i++)
+            {
+                double itemSum = GetItemScoreSum(robotDatas[i].itemScoreList);
+                double clickScore = GetRobotPerfectClickScore(robotDatas[i]) / ConstScoreSystem.PART_SCORE;
+                double skillScore = 0;
+                double skillBaseScore = itemSum + robotDatas[i].cardScore + robotDatas[i].baseScore;
+                List<PassivitySkillCfg> skillCfgs = PassivitySkillCfgArray.Instance.GetCfgsBycardId(robotDatas[i].cardId);
+                for (int j = 0; j < skillCfgs.Count; j++)
+                {
+                    PassivitySkillLvlCfg skillLvlCfg = PassivitySkillLvlCfgArray.Instance.GetCfgByskilllvlAndskillId(robotDatas[i].skillLvs[j], skillCfgs[i].skillId);
+                    if (skillLvlCfg == null) continue;
+                    skillScore += skillBaseScore * skillLvlCfg.fightPowerParam / 10000;
+                }
+                fightScore = itemSum + clickScore + skillScore;
+            }
+            return (int)Math.Ceiling(fightScore);
+        }
+        /// <summary>
+        /// 所有部件主属性和
+        /// </summary>
+        /// <returns></returns>
+        private double GetItemScoreSum(List<int> itemScoreList)
+        {
+            double scoreSum = 0;
+            for (int i = 0; i < itemScoreList.Count; i++)
+            {
+                scoreSum += itemScoreList[i];
+            }
+            return scoreSum;
+
+        }
+        private double GetPerfectClickScore(FightRoleData roleData)
+        {
+            double clickScore = 0;
+            foreach (int key in roleData.pardScoreListDic.Keys)
+            {
+                clickScore += GetPartScore(roleData, key, ClickType.PREFACT_CLICK, 0);
+            }
+            return clickScore;
+        }
+        private double GetRobotPerfectClickScore(FightRobotData robotData)
+        {
+            double clickScore = 0;
+            FightScoreCfg[] scoreCfg = FightScoreCfgArray.Instance.dataArray;
+            for (int i = 0; i < scoreCfg.Length; i++)
+            {
+                clickScore += GetRobotPartScore(robotData, i + 1, ClickType.PREFACT_CLICK, 0);
+            }
+            return clickScore;
+        }
+
     }
 }

GameClient/Assets/Game/HotUpdate/Data/VO/ArenaData.cs

@@ -8,20 +8,27 @@ namespace GFGGame
         public int RankInGrade;//本赛季段位内排名
         public int Type; //类型，由FightTargetType定义
         public OtherRoleInfoData RoleInfo; //玩家数据
-        public List<FightRoleData> RoleDressupList = new List<FightRoleData>();//搭配列表
-        public List<FightRobotData> RobotDressupList = new List<FightRobotData>();//机器人搭配列表
+        public List<FightRoleData> RoleDressupList = new List<FightRoleData>();//搭配列表，与RobotDressupList只能存在一个，取决于Type
+        public List<FightRobotData> RobotDressupList = new List<FightRobotData>();//机器人搭配列表，与RoleDressupList只能存在一个，取决于Type
 
     }
 
     public class ArenaHistoryData//竞技场历史记录
     {
         public bool isWin = false;//是否胜利
+        public bool IsChallenge = false;//是否发起挑战
         public long FightTime;//战斗时间
-        public int Type;//类型，由FightTargetType定义
-        public OtherRoleInfoData RoleInfo; //玩家数据
+        public int Type;//类型，由ArenaFightTargetType定义
+        public OtherRoleInfoData RoleInfo; //对方玩家数据
         public List<FightRoleData> RoleDressupList = new List<FightRoleData>();//搭配列表
         public List<FightRobotData> RobotDressupList = new List<FightRobotData>();//机器人搭配列表
-        public long ChallengePlayerId;//挑战者玩家id 比较小是否与自己的id相同来判断是否发起挑战, 机器人发起挑战这里是0
+        public int GradeChangeType = 0;//是否晋级 ArenaGradeChangeType
+        public int SelfFightScore = 0;//自己战斗分数
+        public int OtherFightScore = 0;//对手战斗分数
+        public int Grade = 1;//战斗后段位
+        public int Rank = 1;//战斗后排行
+        public int SelfFightPower = 0;//自己战斗力
+        public int TargetFightPower = 0;//对手战斗力
 
     }
 }

GameClient/Assets/Game/HotUpdate/Data/VO/FightData.cs

@@ -30,8 +30,9 @@ namespace GFGGame
         public int cardId;
         public int cardScore;
         public string[] tags = { };////本次战斗要求的标签
+        public int tagAddition = 0;//标签加成万分比
         public List<int> skillLvs = new List<int>();
-        public List<int> targetPareScorList = new List<int>();
+        public List<int> itemScoreList = new List<int>();
         public int showSuitId;//机器人服装，仅展示用
     }
 }

GameClient/Assets/Game/HotUpdate/ServerProxy/ArenaSproxy.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using ET;
 
@@ -49,7 +50,7 @@ namespace GFGGame
                         roleData.cardId = response.DressupList[i].CardId;
                         roleData.itemList = response.DressupList[i].EquipIds;
 
-                        ArenaDataManager.Instance.DressupDic[response.ThemeList[i]] = roleData;
+                        ArenaDataManager.Instance.DressupList.Add(roleData);
                     }
 
                     for (int i = 0; i < response.targets.Count; i++)
@@ -78,19 +79,19 @@ namespace GFGGame
         }
 
         //更换搭配
-        public static async ETTask ReqChangeArenaDressup(int theme, FightRoleData roleData)
+        public static async ETTask ReqChangeArenaDressup(int index, FightRoleData roleData)
         {
             ArenaDressupProto dressupInfo = new ArenaDressupProto();
             dressupInfo.CardId = roleData.cardId;
             dressupInfo.EquipIds = roleData.itemList;
 
             S2C_ChangeArenaDressup response = null;
-            response = (S2C_ChangeArenaDressup)await MessageHelper.SendToServer(new C2S_ChangeArenaDressup() { Theme = theme, DressupInfo = dressupInfo });
+            response = (S2C_ChangeArenaDressup)await MessageHelper.SendToServer(new C2S_ChangeArenaDressup() { Index = index, DressupInfo = dressupInfo });
             if (response != null)
             {
                 if (response.Error == ErrorCode.ERR_Success)
                 {
-                    ArenaDataManager.Instance.DressupDic[theme] = roleData;
+                    ArenaDataManager.Instance.DressupList[index] = roleData;
                 }
             }
         }
@@ -207,7 +208,32 @@ namespace GFGGame
         public static ArenaHistoryData GetArenaHistoryData(ArenaHistoryProto arenaHistory)
         {
             ArenaHistoryData arenaTarget = new ArenaHistoryData();
+            arenaTarget.isWin = arenaHistory.IsWin;
+            arenaTarget.IsChallenge = arenaHistory.IsChallenge;
+            arenaTarget.FightTime = arenaHistory.FightTime;
+            arenaTarget.Type = arenaHistory.Type;
+            arenaTarget.RoleInfo = DataChangeUtil.Instance.GetOtherRoleInfoData(arenaHistory.RoleInfo);
 
+            for (int i = 0; i < ArenaDataManager.Instance.ThemeList.Count; i++)
+            {
+                if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
+                {
+                    FightRoleData roleData = GetFightRoleData(arenaHistory.PlayerDressupList[i], arenaTarget.RoleInfo, i);
+                    arenaTarget.RoleDressupList.Add(roleData);
+                }
+                else if (arenaTarget.Type == ArenaFightTargetType.ROBOT)
+                {
+                    FightRobotData robotData = GetFightRobotData(arenaHistory.RobotDressupInfo, i);
+                    arenaTarget.RobotDressupList.Add(robotData);
+                }
+            }
+            arenaTarget.GradeChangeType = arenaHistory.GradeChangeType;
+            arenaTarget.SelfFightScore = arenaHistory.SelfFightScore;
+            arenaTarget.OtherFightScore = arenaHistory.OtherFightScore;
+            arenaTarget.Grade = arenaHistory.Grade;
+            arenaTarget.Rank = arenaHistory.Rank;
+            arenaTarget.SelfFightPower = arenaHistory.SelfFightPower;
+            arenaTarget.TargetFightPower = arenaHistory.TargetFightPower;
             return arenaTarget;
         }
 
@@ -226,35 +252,50 @@ namespace GFGGame
             {
                 if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
                 {
-                    FightRoleData roleData = new FightRoleData();
-                    roleData.name = arenaTarget.RoleInfo.roleName;
-                    roleData.headId = arenaTarget.RoleInfo.roleHead;
-                    roleData.headBorderId = arenaTarget.RoleInfo.roleHeadBorder;
-                    roleData.baseScore = RoleLevelCfgArray.Instance.GetCfg(arenaTargetProto.RoleInfo.RoleLvl).baseScore;
-                    roleData.cardId = arenaTargetProto.PlayerDressupList[j].CardId;
-                    roleData.itemList = arenaTargetProto.PlayerDressupList[j].EquipIds;
-                    if (j == 0) roleData.tags = new string[1] { ArenaDataManager.Instance.Tag };
-
+                    FightRoleData roleData = GetFightRoleData(arenaTargetProto.PlayerDressupList[j], arenaTarget.RoleInfo, j);
                     arenaTarget.RoleDressupList.Add(roleData);
                 }
                 else if (arenaTarget.Type == ArenaFightTargetType.ROBOT)
                 {
-                    ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(arenaTargetProto.RobotDressupInfo.RobotId);
-                    FightRobotData robotData = new FightRobotData();
-                    robotData.name = robotCfg.gradeName;
-                    robotData.res = robotCfg.targetRes;
-                    robotData.targetPareScorList = new List<int>(robotCfg.partsScoreArr);
-                    robotData.baseScore = robotCfg.baseScore;
-                    robotData.cardId = robotCfg.cardIdsArr[j];
-                    robotData.cardScore = robotCfg.cardScore * arenaTargetProto.RobotDressupInfo.Random;
-                    robotData.skillLvs.Add(robotCfg.skillLvs);
-                    robotData.showSuitId = robotCfg.suitIdsArr[j];
-                    if (j == 0) robotData.tags = new string[1] { ArenaDataManager.Instance.Tag };
-
+                    FightRobotData robotData = GetFightRobotData(arenaTargetProto.RobotDressupInfo, j);
                     arenaTarget.RobotDressupList.Add(robotData);
                 }
             }
             return arenaTarget;
         }
+
+        private static FightRoleData GetFightRoleData(ArenaDressupProto dressupProto, OtherRoleInfoData roleInfoData, int index)
+        {
+            FightRoleData roleData = new FightRoleData();
+            roleData.name = roleInfoData.roleName;
+            roleData.headId = roleInfoData.roleHead;
+            roleData.headBorderId = roleInfoData.roleHeadBorder;
+            roleData.baseScore = RoleLevelCfgArray.Instance.GetCfg(roleInfoData.roleLv).baseScore;
+            roleData.cardId = dressupProto.CardId;
+            roleData.itemList = dressupProto.EquipIds;
+            if (index == 0) roleData.tags = new string[1] { ArenaDataManager.Instance.Tag };
+
+            return roleData;
+        }
+        private static FightRobotData GetFightRobotData(ArenaRobotProto robotProto, int index)
+        {
+            ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(robotProto.RobotId);
+            FightRobotData robotData = new FightRobotData();
+            robotData.name = robotCfg.gradeName;
+            robotData.res = robotCfg.targetRes;
+            robotData.itemScoreList = new List<int>(robotCfg.partsScoreArr);
+            robotData.baseScore = robotCfg.baseScore;
+            robotData.cardId = robotProto.CardIdList[index];
+            double cardScore = (double)robotCfg.cardScore * (double)robotProto.Random / 10000 * 100;
+            robotData.cardScore = (int)Math.Ceiling(cardScore);
+            robotData.skillLvs.Add(robotCfg.skillLvs);
+            robotData.showSuitId = robotProto.SuitList[index];
+            if (index == 0)//只有第一个主题才计算标签
+            {
+                robotData.tags = new string[1] { ArenaDataManager.Instance.Tag };
+                robotData.tagAddition = robotCfg.tagAddition;
+            }
+            return robotData;
+        }
     }
 }

GameClient/Assets/Game/HotUpdate/Views/MainStory/StoryFightSingleScoreView.cs

@@ -134,9 +134,11 @@ namespace GFGGame
             _score = 0;
             _skillScore = 0;//技能附加分
             _mainScore = ScoreSystemData.Instance.GetMainScore(roleData);
-
-            _ui.m_comAllPerfect.target.onTouchBegin.Add(OnComAllCircleClickBegin);
-            _ui.m_comAllPerfect.target.onTouchEnd.Add(AllCircleScoreEnd);
+            if (!FightDataManager.Instance.autoPlay)
+            {
+                _ui.m_comAllPerfect.target.onTouchBegin.Add(OnComAllCircleClickBegin);
+                _ui.m_comAllPerfect.target.onTouchEnd.Add(AllCircleScoreEnd);
+            }
             Timers.inst.Add(0.5f, 1, SkillScoreStart);//评分结束
         }
 
@@ -360,7 +362,7 @@ namespace GFGGame
             _ui.m_comAllPerfect.target.onTouchEnd.Remove(AllCircleScoreEnd);
 
             int allCircleScore = 0;
-            if (_time >= ConstScoreSystem.LONG_PRESS_TIME / FightDataManager.Instance.fightSpeed)
+            if (_time >= ConstScoreSystem.LONG_PRESS_TIME / FightDataManager.Instance.fightSpeed || FightDataManager.Instance.autoPlay)
             {
                 allCircleScore = ScoreSystemData.Instance.GetAllCircleAddScore(_mainScore);
             }

GameClient/Assets/Game/HotUpdate/Views/MainStory/StoryFightTargetScoreView.cs

@@ -153,8 +153,11 @@ namespace GFGGame
             _partId = 1;
             _score = 0;
             _targetScore = 0;
-            _ui.m_comAllPerfect.target.onTouchBegin.Add(OnComAllCircleClickBegin);
-            _ui.m_comAllPerfect.target.onTouchEnd.Add(AllCircleScoreEnd);
+            if (!_isAutoPlay)
+            {
+                _ui.m_comAllPerfect.target.onTouchBegin.Add(OnComAllCircleClickBegin);
+                _ui.m_comAllPerfect.target.onTouchEnd.Add(AllCircleScoreEnd);
+            }
 
             CheckPartAllFightBegin();
         }
@@ -453,6 +456,8 @@ namespace GFGGame
             _partId++;
             if (_partId > FightScoreCfgArray.Instance.dataArray.Length)
             {
+                _targetScore += ScoreSystemData.Instance.GetAllCircleAddScore(_targetMainScore);
+
                 if (_prefectCount > 0)
                 {
                     _ui.m_comAllPerfect.target.visible = true;
@@ -516,7 +521,7 @@ namespace GFGGame
             _ui.m_comAllPerfect.target.onTouchEnd.Remove(AllCircleScoreEnd);
 
             int allCircleScore = 0;
-            if (_time >= ConstScoreSystem.LONG_PRESS_TIME / FightDataManager.Instance.fightSpeed)
+            if (_time >= ConstScoreSystem.LONG_PRESS_TIME / FightDataManager.Instance.fightSpeed || _isAutoPlay)
             {
                 allCircleScore = ScoreSystemData.Instance.GetAllCircleAddScore(_mainScore);
             }