Esempio n. 1
0
        //进入战场
        public void EnterBattleField(BattleField battleField, GridUnit bornGrid)
        {
            if (battleField != null && bornGrid != null)
            {
                this.battleField = battleField;

                //设置敌方队伍
                enemyTeam = battleField.GetBattleTeam(this, false);

                //重置属性
                battleUnitAttribute.RandomAttributes();
                battleUnitAttribute.Reset();
                //重置bbsys
                battleBehaviourSystem.ResetSystem();

                EnterGrid(bornGrid);

                BattleUnitAction battleUnitAction = BattleUnitAction.Create(this);
                battleUnitAction.enterBattleFieldAction                         = BattleUnitEnterBattleFieldAction.Get();
                battleUnitAction.enterBattleFieldAction.bornGrid                = bornGrid;
                battleUnitAction.enterBattleFieldAction.attribute               = new BattleUnitSyncAttribute();
                battleUnitAction.enterBattleFieldAction.attribute.hpChanged     = 0;
                battleUnitAction.enterBattleFieldAction.attribute.currentHP     = battleUnitAttribute.hp;
                battleUnitAction.enterBattleFieldAction.attribute.energyChanged = 0;
                battleUnitAction.enterBattleFieldAction.attribute.currentEnergy = 0;

                //创建进入战场的消息
                battleField.AppendBattleAction(battleUnitAction);

                //初始化战斗行为系统
                battleBehaviourSystem.Init(this, battleField);
            }
        }
Esempio n. 2
0
        //自动搓招
        private void AutoUseSkill(BattleUnitAction battleUnitAction)
        {
            //计算每个技能对目标单位的使用得分
            BattleCalculator.Instance.AutoReleaseAnalysisor.Ananlysis(this, targetBattleUnit, battleUnitAttribute.battleSkills);
            //获取得分最高的技能
            BattleSkillAutoReleaseAnalysisItem analysisResult = BattleCalculator.Instance.AutoReleaseAnalysisor.GetResult();

            if (analysisResult != null)
            {
                //使用技能
                switch (analysisResult.battleSkill.targetType)
                {
                case BattleSkillTargetType.BattleUnit:
                    UseSkill(battleUnitAction, analysisResult.battleSkill, targetBattleUnit);
                    break;

                case BattleSkillTargetType.GridUnit:
                    UseSkill(battleUnitAction, analysisResult.battleSkill, null, analysisResult.targetGridUnit);
                    break;

                case BattleSkillTargetType.Self:
                    UseSkill(battleUnitAction, analysisResult.battleSkill);
                    break;

                default:
                    break;
                }
            }
            //重置分析器
            BattleCalculator.Instance.AutoReleaseAnalysisor.Reset();
        }
Esempio n. 3
0
        //自动搓招
        private void AutoUseSkill(BattleUnitAction battleUnitAction, BattleBehaviourSystem.BattleDecision decision)
        {
            if (decision == null)
            {
                return;
            }

            if (decision.battleSkill != null)
            {
                //使用技能
                switch (decision.battleSkill.targetType)
                {
                case BattleSkillTargetType.BattleUnit:
                    UseSkill(battleUnitAction, decision.battleSkill, decision.skillTargetBattleUnit);
                    break;

                case BattleSkillTargetType.GridUnit:
                    UseSkill(battleUnitAction, decision.battleSkill, null, decision.skillTargetGrid);
                    break;

                case BattleSkillTargetType.Self:
                    UseSkill(battleUnitAction, decision.battleSkill);
                    break;

                default:
                    break;
                }
            }
        }
Esempio n. 4
0
        //自动
        private HeroActionState AutoAction(BattleUnitAction battleUnitAction)
        {
            BattleBehaviourSystem.BattleDecision decision = battleBehaviourSystem.Think();

            if (decision == null)
            {
                battleUnitAction.warningAction            = BattleUnitWarningAction.Get();
                battleUnitAction.warningAction.logWarning = "No target:" + ID;
                return(HeroActionState.Normal);
            }

            //判断是否切换目标
            if (decision.targetBattleUnit != null && !decision.targetBattleUnit.Equals(targetBattleUnit))
            {
                battleUnitAction.changeTargetAction = BattleUnitChangeTargetAction.Get();
                battleUnitAction.changeTargetAction.lastTargetUnit = targetBattleUnit;
                battleUnitAction.changeTargetAction.newTargetUnit  = decision.targetBattleUnit;
                targetBattleUnit = decision.targetBattleUnit;
            }

            //需要移动
            if (decision.movePath != null && decision.movePath.Length > 0)
            {
                MoveToTargetGrid(battleUnitAction, targetBattleUnit, decision.movePath[decision.movePath.Length - 1], decision.movePath);
            }

            //自动搓招儿
            AutoUseSkill(battleUnitAction, decision);

            return(HeroActionState.Normal);
        }
Esempio n. 5
0
        //进入战场
        public void EnterBattleField(BattleField battleField, GridUnit bornGrid, List <BattleAction> heroActions)
        {
            if (battleField != null && bornGrid != null)
            {
                this.battleField = battleField;

                //设置敌方队伍
                enemyTeam = battleField.GetBattleTeam(this, false);

                //重置仇恨记录器
                hatredRecorder.Reset(this, enemyTeam);

                EnterGrid(bornGrid);

                if (heroActions != null)
                {
                    BattleUnitAction battleUnitAction = BattleUnitAction.Get(this);
                    battleUnitAction.enterBattleFieldAction                         = BattleUnitEnterBattleFieldAction.Get();
                    battleUnitAction.enterBattleFieldAction.bornGrid                = bornGrid;
                    battleUnitAction.enterBattleFieldAction.attribute               = new BattleUnitSyncAttribute();
                    battleUnitAction.enterBattleFieldAction.attribute.hpChanged     = 0;
                    battleUnitAction.enterBattleFieldAction.attribute.currentHP     = battleUnitAttribute.hp;
                    battleUnitAction.enterBattleFieldAction.attribute.energyChanged = 0;
                    battleUnitAction.enterBattleFieldAction.attribute.currentEnergy = 0;
                    heroActions.Add(battleUnitAction);
                }
            }
        }
Esempio n. 6
0
        //自动
        private HeroActionState AutoAction(BattleUnitAction battleUnitAction)
        {
            //自动选择目标
            AutoSelectTarget(battleUnitAction);

            //找不到目标单位,这个就很奇怪了...
            if (targetBattleUnit == null && battleUnitAction != null)
            {
                battleUnitAction.warningAction            = BattleUnitWarningAction.Get();
                battleUnitAction.warningAction.logWarning = "No target:" + battleUnitID;
                return(HeroActionState.Warn);
            }

            //需要移动
            if (battleUnitAction != null && toTargetPath.Count > 0)
            {
                MoveToTargetGrid(battleUnitAction, targetBattleUnit, toTargetPath[toTargetPath.Count - 1], toTargetPath.ToArray());
            }

            //自动搓招儿
            AutoUseSkill(battleUnitAction);

            //战斗结束判断
            if (battleField.CheckBattleEnd())
            {
                return(HeroActionState.BattleEnd);
            }
            else
            {
                return(HeroActionState.Normal);
            }
        }
Esempio n. 7
0
        //手动选择移动目标
        private void ManualMoveTo(GridUnit grid, GridUnit[] path)
        {
            //添加一个行动
            BattleUnitAction battleUnitAction = BattleUnitAction.Create(manualOperatingBattleUnitRenderer.battleUnit);

            //为行动添加移动数据
            manualOperatingBattleUnitRenderer.battleUnit.MoveToTargetGrid(battleUnitAction, null, grid, path);
            fieldRenderer.battleField.AppendBattleAction(battleUnitAction);
            fieldRenderer.PlayBattle(AfterManualMove);
        }
Esempio n. 8
0
        //手动操作
        private HeroActionState ManualAction(BattleUnitAction battleUnitAction)
        {
            //重置手动操作状态
            manualActionState |= ManualActionState.Move;
            manualActionState |= ManualActionState.Skill;

            //创建一个手动操作的行动用于显示
            if (battleUnitAction != null)
            {
                battleUnitAction.manualAction = LiteSingleton <BattleUnitManualAction> .Instance;
            }

            return(HeroActionState.WaitForPlayerChoose);
        }
Esempio n. 9
0
 //向目标格子移动
 public void MoveToTargetGrid(BattleUnitAction battleUnitAction, BattleUnit targetUnit, GridUnit targetGrid, GridUnit[] gridPath)
 {
     //是否需要记录过程
     if (battleUnitAction != null)
     {
         battleUnitAction.motionAction            = BattleUnitMotionAction.Get();
         battleUnitAction.motionAction.targetUnit = targetUnit;
         battleUnitAction.motionAction.fromGrid   = mapGrid;
         battleUnitAction.motionAction.gridPath   = gridPath;
         battleUnitAction.motionAction.moveRange  = battleUnitAttribute.mobility;
     }
     //进入格子,直接设置数据
     EnterGrid(targetGrid);
 }
Esempio n. 10
0
        //使用技能
        public void UseSkill(BattleUnitAction battleUnitAction, SO_BattleSkill battleSkill, BattleUnit targetBattleUnit = null, GridUnit targetGridUnit = null)
        {
            if (battleSkill == null)
            {
                UtilityHelper.LogError("Use skill error. Battle skill is none.");
                return;
            }
            BattleSkillEffectAnalysis analysis = BattleCalculator.Instance.AnalyseBattleSkillEffect(battleSkill, this, targetBattleUnit, targetGridUnit);

            if (analysis == null)
            {
                UtilityHelper.LogError("Use skill error. Analysis failed:" + battleSkill.skillName);
                return;
            }

            List <BattleUnitSkillResult> skillResults = new List <BattleUnitSkillResult>();

            //主要影响
            for (int i = 0; i < analysis.mainReceiver.Count; ++i)
            {
                skillResults.Add(BattleCalculator.Instance.CalcSingle(this, analysis.mainReceiver[i], battleSkill, true));
            }
            //次要影响
            for (int i = 0; i < analysis.minorReceiver.Count; ++i)
            {
                skillResults.Add(BattleCalculator.Instance.CalcSingle(this, analysis.minorReceiver[i], battleSkill, false));
            }

            //产生使用技能的动作
            if (battleUnitAction != null)
            {
                battleUnitAction.skillAction                  = BattleUnitSkillAction.Get();
                battleUnitAction.skillAction.battleSkill      = battleSkill;
                battleUnitAction.skillAction.skillResult      = skillResults.ToArray();
                battleUnitAction.skillAction.targetBattleUnit = targetBattleUnit;
                battleUnitAction.skillAction.targetGrid       = targetGridUnit;
                battleUnitAction.skillAction.selfAttribute    = BattleSkillCostEnergy(battleSkill);
            }

            //伤害产生效果,计算仇恨
            for (int i = 0; i < skillResults.Count; ++i)
            {
                skillResults[i].battleUnit.AcceptSkillResult(skillResults[i].syncAttribute, battleUnitAction);
                //产生仇恨
                if (battleSkill.damageType != BattleSkillDamageType.Heal && !skillResults[i].battleUnit.Equals(this))
                {
                    skillResults[i].battleUnit.hatredRecorder.RecoredHatred(this.battleUnitID, skillResults[i].syncAttribute.hpChanged < 0 ? -skillResults[i].syncAttribute.hpChanged : skillResults[i].syncAttribute.hpChanged);
                }
            }
        }
Esempio n. 11
0
        //被使用技能
        private void AcceptSkillResult(BattleUnitSyncAttribute sync, BattleUnitAction battleUnitAction)
        {
            if (sync != null)
            {
                battleUnitAttribute.hp = sync.currentHP;

                if (battleUnitAttribute.hp <= 0)
                {
                    //被击败了
                    //从格子中移除
                    LeaveGrid();
                }
            }
        }
Esempio n. 12
0
 private void RecoverEnergy(BattleUnitAction battleUnitAction)
 {
     //数值改变
     battleUnitAttribute.energy += EGameConstL.EnergyRecoverPerRound;
     battleUnitAttribute.energy  = battleUnitAttribute.energy > battleUnitAttribute.maxEnergy ? battleUnitAttribute.maxEnergy : battleUnitAttribute.energy;
     //创建一个Action
     if (battleUnitAction != null)
     {
         battleUnitAction.attributeUpdate                         = BattleUnitAttributeUpdate.Get();
         battleUnitAction.attributeUpdate.attribute               = new BattleUnitSyncAttribute();
         battleUnitAction.attributeUpdate.attribute.hpChanged     = 0;
         battleUnitAction.attributeUpdate.attribute.currentHP     = battleUnitAttribute.hp;
         battleUnitAction.attributeUpdate.attribute.energyChanged = EGameConstL.EnergyRecoverPerRound;
         battleUnitAction.attributeUpdate.attribute.currentEnergy = battleUnitAttribute.energy;
     }
 }
Esempio n. 13
0
        /// <summary>
        /// 战斗单位动作的顺序是,移动->攻击
        /// </summary>
        /// <param name="heroActions"></param>
        /// <returns></returns>
        public HeroActionState BattleAction(BattleUnitAction battleUnitAction)
        {
            //恢复能量
            RecoverEnergy(battleUnitAction);

            //手动
            if (battleUnitAttribute.manualOperation)
            {
                return(ManualAction(battleUnitAction));
            }
            //自动
            else
            {
                return(AutoAction(battleUnitAction));
            }
        }
Esempio n. 14
0
        //手动释放技能(对具体的目标)
        private void ManualSkill(BattleUnit targetBattleUnit)
        {
            if (targetBattleUnit == null)
            {
                return;
            }

            //添加一个行动
            BattleUnitAction battleUnitAction = BattleUnitAction.Create(manualOperatingBattleUnitRenderer.battleUnit);

            //为行动添加技能释放数据
            manualOperatingBattleUnitRenderer.battleUnit.UseSkill(battleUnitAction, usedManualReleaseAnalysisor.battleSkill, targetBattleUnit);
            fieldRenderer.battleField.AppendBattleAction(battleUnitAction);

            //行动结束
            ManualOperationComplete();
        }
Esempio n. 15
0
        //运行英雄动作
        public IEnumerator RunHeroAction(BattleUnitAction heroAction)
        {
            if (heroAction == null)
            {
                yield break;
            }

            //进入战场
            if (heroAction.enterBattleFieldAction != null)
            {
                yield return(PlayEnterBattleFieldAction(heroAction.enterBattleFieldAction));
            }
            //恢复能量
            if (heroAction.attributeUpdate != null)
            {
                yield return(PlayAttributeUpdateAction(heroAction.attributeUpdate));
            }
            //切换目标
            if (heroAction.changeTargetAction != null)
            {
                yield return(PlayChangeTargetAction(heroAction.changeTargetAction));
            }
            //移动
            if (heroAction.motionAction != null)
            {
                yield return(PlayMotionAction(heroAction.motionAction));
            }
            //使用技能
            if (heroAction.skillAction != null)
            {
                yield return(PlaySkillAction(heroAction.skillAction));
            }
            //手动操作
            if (heroAction.manualAction != null)
            {
                yield return(PlayManualAction(heroAction.manualAction));
            }
            //警告动作
            if (heroAction.warningAction != null)
            {
                UtilityHelper.LogWarning(heroAction.ToString());
                yield return(EGameConstL.WaitForTouchScreen);
            }
            yield return(null);
        }
Esempio n. 16
0
        //播放战场动作
        private IEnumerator PlayBattleByCoroutine(System.Action callback)
        {
            if (battleField == null ||
                battleField.msgAction.battleActions == null ||
                battleField.msgAction.battleActions.Count == 0)
            {
                UtilityHelper.LogError(string.Format("Play battle action failed. -> {0}", battleField.battleID));
                yield break;
            }

            UtilityHelper.Log("Play battle actions");

            //遍历所有战斗动作
            var msgAction = battleField.msgAction;

            while (battleField.currentIndex < msgAction.battleActions.Count)
            {
                if (msgAction.battleActions[battleField.currentIndex] == null)
                {
                    UtilityHelper.LogError(string.Format("Play action error. Action is none or type is none, index = {0}", battleField.currentIndex));
                    continue;
                }

                BattleUnitAction heroAction = null;
                //一个英雄动作
                if (msgAction.battleActions[battleField.currentIndex] is BattleUnitAction)
                {
                    heroAction = (BattleUnitAction)msgAction.battleActions[battleField.currentIndex];

                    //有对应的战斗单位,且这个战斗单位已经连接了战斗单位渲染器
                    if (heroAction.actionUnit != null && heroAction.actionUnit.battleUnitRenderer != null)
                    {
                        yield return(heroAction.actionUnit.battleUnitRenderer.RunHeroAction(heroAction));
                    }
                }
                ++battleField.currentIndex;
            }

            UtilityHelper.Log("Play Msg Action fin");

            if (callback != null)
            {
                callback();
            }
        }
Esempio n. 17
0
        //手动释放技能(对具体的地块)
        private void ManualSkill(GridUnit targetGrid)
        {
            if (targetGrid == null)
            {
                return;
            }

            //添加一个行动
            BattleUnitAction battleUnitAction = BattleUnitAction.Create(manualOperatingBattleUnitRenderer.battleUnit);

            manualOperatingBattleUnitRenderer.battleUnit.UseSkill(battleUnitAction, usedManualReleaseAnalysisor.battleSkill, null, targetGrid);
            fieldRenderer.battleField.AppendBattleAction(battleUnitAction);

            //取消范围高亮显示
            SetCircularRangeRenderStateActive(false, GridRenderType.SkillReleaseRange);
            SetCircularRangeRenderStateActive(false, GridRenderType.SkillEffectRange);

            //行动结束
            ManualOperationComplete();
        }
Esempio n. 18
0
        /// <summary>
        /// 战斗单位动作的顺序是,移动->攻击
        /// </summary>
        /// <param name="heroActions"></param>
        /// <returns></returns>
        public HeroActionState BattleAction()
        {
            BattleUnitAction battleUnitAction = BattleUnitAction.Create(this);

            battleField.AppendBattleAction(battleUnitAction);

            //恢复能量
            RecoverEnergy(battleUnitAction);
            //冷静
            battleBehaviourSystem.RageLevelCooldown();

            //手动
            if (battleUnitAttribute.manualOperation)
            {
                return(ManualAction(battleUnitAction));
            }
            //自动
            else
            {
                return(AutoAction(battleUnitAction));
            }
        }
Esempio n. 19
0
        //播放战场动作
        private IEnumerator PlayBattleByCoroutine(System.Action callback)
        {
            if (battleField == null ||
                battleField.battleActions == null ||
                battleField.battleActions.Count == 0)
            {
                UtilityHelper.LogError(string.Format("Play battle action failed. -> {0}", battleField.ID));
                yield break;
            }

            //遍历所有战斗动作
            while (currentActionIndex < battleField.battleActions.Count)
            {
                BattleUnitAction heroAction = null;
                //一个英雄动作
                if (battleField.battleActions[currentActionIndex] is BattleUnitAction)
                {
                    heroAction = (BattleUnitAction)battleField.battleActions[currentActionIndex];

                    //有对应的战斗单位,且这个战斗单位已经连接了战斗单位渲染器
                    if (heroAction.actionUnit != null && heroAction.actionUnit.battleUnitRenderer != null)
                    {
                        yield return(heroAction.actionUnit.battleUnitRenderer.RunHeroAction(heroAction));
                    }
#if UNITY_EDITOR
                    if (DebugHelper.Instance.playBattleByStep)
                    {
                        yield return(EGameConstL.WaitForTouchScreen);
                    }
#endif
                }
                ++currentActionIndex;
            }

            if (callback != null)
            {
                callback();
            }
        }
Esempio n. 20
0
        //开始战斗
        private void Fight()
        {
            battleState = BattleState.Fighting;

            UtilityHelper.Log(string.Format("<color=#ff0000> {0} battle fight. </color>", this.ToString()));

            BattleUnit actionUnit = null;

            do
            {
                //没有连接渲染器,则一步一更新
                //连接了渲染器,则一直更新直到结束
                actionUnit = actionQueue.Dequeue();

                if (actionUnit == null)
                {
                    battleState = BattleState.End;
                    break;
                }

                if (actionUnit.CanAction)
                {
                    BattleUnitAction battleUnitAction = BattleUnitAction.Get(actionUnit);

                    HeroActionState state = actionUnit.BattleAction(battleUnitAction);

                    switch (state)
                    {
                    case HeroActionState.BattleEnd:
                        battleState = BattleState.End;
                        break;

                    case HeroActionState.Error:
                        battleState = BattleState.Exception;
                        break;

                    case HeroActionState.Warn:
                        battleState = BattleState.Exception;
                        UtilityHelper.LogWarning(string.Format("Warning: battle action state warning -> {0}", actionUnit.ToString()));
                        break;

                    case HeroActionState.WaitForPlayerChoose:
                        battleState = BattleState.WaitForPlayer;
                        break;

                    default:
                        break;
                    }

                    //追加动作
                    AppendBattleAction(battleUnitAction);
                }

                //考虑是否在放回队列
                CalculateNextAction(actionUnit);

                ++actionCount;

                if (actionCount >= EGameConstL.BattleFieldMaxActions)
                {
                    battleState = BattleState.Exception;
                }
            } while (battleFieldRenderer == null &&
                     battleState != BattleState.End &&
                     battleState != BattleState.Exception);

            //连接了渲染器,一步一更新
            if (battleFieldRenderer != null)
            {
                Debug.Log("Play actions");

                if (battleState == BattleState.End || battleState == BattleState.Exception)
                {
                    battleFieldRenderer.PlayBattle(BattleEnd);
                }

                else if (battleState == BattleState.WaitForPlayer)
                {
                    battleFieldRenderer.PlayBattle(null);
                }

                else
                {
                    battleFieldRenderer.PlayBattle(Fight);
                }
            }
            else
            {
                //没有连接渲染器,自动战斗
                BattleEnd();
            }
        }
Esempio n. 21
0
        //开始战斗
        private void Fight()
        {
            battleState = BattleState.Fighting;

            BattleUnit actionUnit = null;

            do
            {
                //连接渲染器,则一步一更新
                //没有连接渲染器,则一直计算直到结束
                actionUnit = actionQueue.Dequeue();

                if (actionUnit == null)
                {
                    battleState = BattleState.End;
                    break;
                }

                if (actionUnit.CanAction)
                {
                    BattleUnitAction battleUnitAction = BattleUnitAction.Create(actionUnit);

                    HeroActionState state = actionUnit.BattleAction();

                    switch (state)
                    {
                    case HeroActionState.Normal:
                        battleState = BattleState.Fighting;
                        break;

                    case HeroActionState.WaitForPlayerChoose:
                        battleState = BattleState.WaitForPlayer;
                        break;

                    case HeroActionState.Error:
                        battleState = BattleState.Exception;
                        break;

                    case HeroActionState.Warn:
                        battleState = BattleState.Exception;
                        UtilityHelper.LogWarning(string.Format("Warning: battle action state warning -> {0}", actionUnit.ToString()));
                        break;

                    default:
                        break;
                    }
                }

                //考虑是否在放回队列
                CalculateNextAction(actionUnit);

                if (battleActions.Count > EGameConstL.BattleFieldMaxActions)
                {
                    UtilityHelper.LogError("Battle actions overflow max limit.");
                    battleState = BattleState.Exception;
                }
                else
                {
                    //只在这种情况下做战斗结束的判断
                    if (!actionUnit.CanAction ||
                        actionUnit.targetBattleUnit == null ||
                        !actionUnit.targetBattleUnit.CanAction)
                    {
                        CheckBattleEnd();
                    }
                }
            } while (battleFieldRenderer == null &&
                     battleState != BattleState.End &&
                     battleState != BattleState.Exception);

            //连接了渲染器,一步一表现
            if (battleFieldRenderer != null)
            {
                if (battleState == BattleState.WaitForPlayer)
                {
                    battleFieldRenderer.PlayBattle(null);
                }

                else
                {
                    battleFieldRenderer.PlayBattle(Run);
                }
            }
            else
            {
                Run();
            }
        }
Esempio n. 22
0
        //输出分析战报
        private void OutputBattleReport(string path)
        {
            StringBuilder strBuilder = new StringBuilder();

            if (!File.Exists(path))
            {
                strBuilder.AppendFormat("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}\n", "BattleID", "State", "SN", "AtkTeam", "FirstAction", "Attacker", "SufferTeam", "Sufferer", "SkillName", "SkillType", "Damage/HP");
            }

            foreach (var item in battleActions)
            {
                switch (item.actionType)
                {
                case MsgBattleActionType.None:
                case MsgBattleActionType.Warning:
                case MsgBattleActionType.BattleUnitAction:
                    BattleUnitAction battleUnitAction = item as BattleUnitAction;
                    if (battleUnitAction != null && battleUnitAction.skillAction != null)
                    {
                        foreach (var skillResult in battleUnitAction.skillAction.skillResult)
                        {
                            BattleTeam firstActionTeam = ((resetTimes & 1) == 0) ? teams[1] : teams[0];
                            strBuilder.AppendFormat("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}\n",
                                                    resetTimes,
                                                    "Action",
                                                    item.sn,
                                                    battleUnitAction.actionUnit.battleTeam,
                                                    firstActionTeam.Equals(battleUnitAction.actionUnit.battleTeam) ? 1 : 0,
                                                    battleUnitAction.actionUnit.battleUnitAttribute.battleUnitName,
                                                    skillResult.battleUnit.battleTeam,
                                                    skillResult.battleUnit.battleUnitAttribute.battleUnitName,
                                                    battleUnitAction.skillAction.battleSkill.skillName,
                                                    battleUnitAction.skillAction.battleSkill.damageType.ToString(),
                                                    skillResult.syncAttribute.hpChanged);

                            //统计击杀
                            if (skillResult.syncAttribute.currentHP <= 0)
                            {
                                strBuilder.AppendFormat("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}\n",
                                                        resetTimes,
                                                        "Kill",
                                                        item.sn,
                                                        battleUnitAction.actionUnit.battleTeam,
                                                        firstActionTeam.Equals(battleUnitAction.actionUnit.battleTeam) ? 1 : 0,
                                                        battleUnitAction.actionUnit.battleUnitAttribute.battleUnitName,
                                                        skillResult.battleUnit.battleTeam,
                                                        skillResult.battleUnit.battleUnitAttribute.battleUnitName,
                                                        battleUnitAction.skillAction.battleSkill.skillName,
                                                        battleUnitAction.skillAction.battleSkill.damageType.ToString(),
                                                        skillResult.syncAttribute.hpChanged);
                            }
                        }
                    }
                    break;

                case MsgBattleActionType.BattleStart:
                    break;

                case MsgBattleActionType.End:
                    break;

                default:
                    break;
                }
            }
            foreach (var team in teams)
            {
                foreach (var bu in team.battleUnits)
                {
                    BattleTeam firstActionTeam = ((resetTimes & 1) == 0) ? teams[1] : teams[0];
                    strBuilder.AppendFormat("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}\n",
                                            resetTimes,
                                            "End",
                                            string.Empty,
                                            bu.battleTeam,
                                            firstActionTeam.Equals(bu.battleTeam) ? 1 : 0,
                                            bu.battleUnitAttribute.battleUnitName,
                                            string.Empty,
                                            string.Empty,
                                            string.Empty,
                                            string.Empty,
                                            bu.battleUnitAttribute.hp);
                }
            }
            File.AppendAllText(path, strBuilder.ToString());
        }
Esempio n. 23
0
        //使用技能
        public void UseSkill(BattleUnitAction battleUnitAction, SO_BattleSkill battleSkill, BattleUnit targetBattleUnit = null, GridUnit targetGridUnit = null)
        {
            if (battleSkill == null)
            {
                UtilityHelper.LogError("Use skill error. Battle skill is none.");
                return;
            }
            BattleSkillEffectAnalysis analysis = BattleCalculator.Instance.AnalyseBattleSkillEffect(battleSkill, this, targetBattleUnit, targetGridUnit);

            if (analysis == null)
            {
                UtilityHelper.LogError("Use skill error. Analysis failed:" + battleSkill.skillName);
                return;
            }

            List <BattleUnitSkillResult> skillResults = new List <BattleUnitSkillResult>();

            //主要影响
            for (int i = 0; i < analysis.mainReceiver.Count; ++i)
            {
                skillResults.Add(BattleCalculator.Instance.CalcSingle(this, analysis.mainReceiver[i], battleSkill, true));
            }
            //次要影响
            for (int i = 0; i < analysis.minorReceiver.Count; ++i)
            {
                skillResults.Add(BattleCalculator.Instance.CalcSingle(this, analysis.minorReceiver[i], battleSkill, false));
            }

            //产生使用技能的动作
            if (battleUnitAction != null)
            {
                battleUnitAction.skillAction                  = BattleUnitSkillAction.Get();
                battleUnitAction.skillAction.battleSkill      = battleSkill;
                battleUnitAction.skillAction.skillResult      = skillResults.ToArray();
                battleUnitAction.skillAction.targetBattleUnit = targetBattleUnit;
                battleUnitAction.skillAction.targetGrid       = targetGridUnit;
                battleUnitAction.skillAction.selfAttribute    = BattleSkillCostEnergy(battleSkill);
            }

            //伤害产生效果,计算仇恨
            for (int i = 0; i < skillResults.Count; ++i)
            {
                //接收伤害,属性变更
                skillResults[i].battleUnit.AcceptSkillResult(skillResults[i].syncAttribute, battleUnitAction);

                //产生仇恨
                if (battleSkill.damageType != BattleSkillDamageType.Heal && !skillResults[i].battleUnit.Equals(this))
                {
                    //新仇记录
                    for (int j = 0; j < enemyTeam.battleUnits.Count; ++j)
                    {
                        if (!enemyTeam.battleUnits[j].CanAction)
                        {
                            continue;
                        }

                        //每个战斗单位都需要知道发生了什么
                        enemyTeam.battleUnits[j].battleBehaviourSystem.RecordSkillResult(this, skillResults[i]);
                    }
                }
            }
        }
Esempio n. 24
0
        //自动选择目标
        private void AutoSelectTarget(BattleUnitAction battleUnitAction)
        {
            int stopDistance = SkillStopDistance;
            //从仇恨列表中确定目标
            BattleUnit hatredUnit = null;

            //按照仇恨列表获取目标
            for (int i = 0; i < hatredRecorder.HatredCount; ++i)
            {
                hatredUnit = hatredRecorder.GetHatredByIdx(i, i == 0);
                if (!hatredUnit.CanAction)
                {
                    //已经排序过了,找到不能行动的单位,就表示没有单位可以行动了
                    hatredUnit = null;
                    break;
                }

                //判断这个单位是否可以到达
                bool catched = false;
                //如果这个单位就在身边
                if (mapGrid.Distance(hatredUnit.mapGrid) <= stopDistance)
                {
                    toTargetPath.Clear();
                    catched = true;
                }
                else
                {
                    catched = MapNavigator.Instance.Navigate(
                        battleField.battleMap,
                        mapGrid,
                        hatredUnit.mapGrid,
                        toTargetPath,
                        null,
                        battleUnitAttribute.mobility,
                        stopDistance
                        );
                }

                //寻路不可达
                if (!catched)
                {
                    hatredUnit = null;
                    continue;
                }
                //找到了
                else
                {
                    break;
                }
            }

            //没有目标
            if (hatredUnit == null)
            {
                targetBattleUnit = null;
                return;
            }

            //判断是否切换目标
            if (battleUnitAction != null && !hatredUnit.Equals(targetBattleUnit))
            {
                battleUnitAction.changeTargetAction = BattleUnitChangeTargetAction.Get();
                battleUnitAction.changeTargetAction.lastTargetUnit = targetBattleUnit;
                battleUnitAction.changeTargetAction.newTargetUnit  = hatredUnit;
                targetBattleUnit = hatredUnit;
            }
        }