/// <summary>
        /// 选择目标方法:在攻击的时候,选择{什么范围中的敌人作为}攻击的目标
        /// </summary>
        /// <param name="skillData">技能对象</param>
        /// <param name="skillOwner">技能拥有者的transform</param>
        /// <returns>选中的目标</returns>
        public GameObject[] SelectTarget(SkillData skillData, SkillDeployer skillDeployer)
        {
            List <GameObject> list = new List <GameObject>();

            // 1 添加技能影响范围的目标
            list.AddRange(skillDeployer.enterTrigger.EnterObjs);
            if (list.Count <= 0)
            {
                Debug.LogError("圆形攻击目标为0");
                return(null);
            }
            Transform depTf = skillDeployer.transform;

            // 2 从所有攻击目标中 找出攻击范围中活着的敌人
            list = list.FindAll(go => Vector3.Distance(go.transform.position, depTf.position) < skillData.attackDistance && go.GetComponent <CharacterStatus>().chBase.HP > 0);
            if (null == list || list.Count <= 0)
            {
                return(null);
            }
            // 3 根据释放的技能,选择一个或多个敌人
            switch (skillData.attackType)
            {
            case SkillAttackType.Single:
                GameObject obj = ArrayHelper.Min(list.ToArray(), go => Vector3.Distance(go.transform.position, depTf.position));
                return(new GameObject[] { obj });

            case SkillAttackType.Group:
                return(list.ToArray());

            default:
                YellowEvents.SendEvent(YellowEventName.error, YellowErrorText.notSkillType);
                return(null);
            }
        }
Exemple #2
0
        private IEnumerator RepeatDamage(SkillDeployer deployer, SkillData skillData)
        {
            float attackTime = 0;

            do
            {
                // 1 对多个目标执行伤害
                if (skillData.attackTargets != null && skillData.attackTargets.Length > 0)
                {
                    for (int i = 0; i < skillData.attackTargets.Length; i++)
                    {
                        OnceDamage(skillData, skillData.attackTargets[i]);
                    }
                }
                // 2 等待一个伤害间隔
                yield return(new WaitForSeconds(skillData.damageInterval));

                attackTime = attackTime + skillData.damageInterval;
                // ! 那么 damageInterval 不能为0
                if (skillData.damageInterval <= 0)
                {
                    YellowEvents.SendEvent(YellowEventName.error, YellowErrorText.errorSkilldamageInterval + skillData.name);
                    skillData.damageInterval = 0.1f;
                }
                // 3 攻击完一次后,重新选取目标
                skillData.attackTargets = deployer.ResetTargets();
            } while (attackTime <= skillData.durationTime);
        }
Exemple #3
0
 public void TargerImpact(SkillDeployer deployer, SkillData skillData, GameObject goSelf)
 {
     if (skillData.Owner != null && skillData.Owner.gameObject != null)
     {
         baseDamage = skillData.Owner.GetComponent <CharacterStatus>().Damage;
     }
     deployer.StartCoroutine(RepeatDamage(deployer, skillData));
 }
Exemple #4
0
 private void OnceDamage(SkillDeployer deployer)
 {
     for (int i = 0; i < deployer.CurrentSkillData.attackTargets.Length; i++)
     {
         deployer.CurrentSkillData.attackTargets[i].GetComponent <CharacterStatus>().Damage(deployer.CurrentSkillData.owner.GetComponent <CharacterStatus>().baseATK *deployer.CurrentSkillData.atkRatio);
     }
     //单次伤害
     //遍历被攻击的目标 data.attackTargets,调用受伤方法。
     //
 }
        /// <summary>
        /// 影响自身方法
        /// </summary>
        /// <param name="deployer">技能释放器</param>
        /// <param name="skillData">技能数据对象</param>
        /// <param name="goSelf">自身或队友对象</param>
        ///
        //private PlayerStatus playerStatus;
        public void SelfImpact(SkillDeployer deployer, SkillData skillData, GameObject goSelf)
        {
            if (skillData.Owner == null)
            {
                return;
            }
            var chStatus = skillData.Owner.GetComponent <CharacterStatus>();

            chStatus.SP -= skillData.costSP;
        }
Exemple #6
0
 /// 影响目标的操作【方法】
 /// <param name="deployer">技能施放器</param>
 /// <param name="skillData">技能数据对象</param>
 /// <param name="goSelf">目标对象</param>
 public void TargetImpact(SkillDeployer deployer, SkillData skillData,
                          GameObject goTarget)
 {
     //获取技能拥有者的基础伤害
     if (skillData.Owner != null && skillData.Owner.gameObject != null)
     {
         baseDamage = skillData.Owner.
                      GetComponent <CharacterStatus>().Damage;
     }
     //执行伤害
     deployer.StartCoroutine(RepeatDamage(deployer, skillData));
 }
Exemple #7
0
        private IEnumerator RepeatDamage(SkillDeployer deployer)
        {
            float atkTime = 0;

            do
            {
                OnceDamage(deployer);
                yield return(new WaitForSeconds(deployer.CurrentSkillData.atkInterval - Time.deltaTime));

                atkTime += (deployer.CurrentSkillData.atkInterval - Time.deltaTime);
                deployer.CalculateTargets();
            } while (atkTime < deployer.CurrentSkillData.durationTime);
        }
Exemple #8
0
        /// <summary>
        /// 重复攻击
        /// </summary>
        /// <returns></returns>
        private IEnumerator RepeatAttack(SkillDeployer deployer)
        {
            float atkTime = 0;

            do
            {
                if (deployer.CurrentSkillData.attackTargets != null)
                {
                    Attack(deployer.CurrentSkillData);
                }
                yield return(new WaitForSeconds(deployer.CurrentSkillData.atkInterval));

                atkTime += deployer.CurrentSkillData.atkInterval;
                //再次计算攻击目标
                deployer.CalculateTargets();
            } while (atkTime < deployer.CurrentSkillData.durationTime);
        }
        //生成技能
        public void GenerateSkill(SkillData data)
        {
            //GameObject skillG0 =  Instantiate(data.skillPrefab,transform.position,transform.rotation);
            GameObject skillG0 = GameObjectPool.Instance.CreateObject(data.prefabName, data.skillPrefab, transform.position, transform.rotation);

            GameObjectPool.Instance.CollectObjectSeconds(skillG0, data.durationTime);
            //传递技能数据
            SkillDeployer deployer = skillG0.GetComponent <SkillDeployer>();

            //赋值初始化准备技能算法
            deployer.CurrentSkillData = data;
            //开始执行算法
            deployer.DeployerSkill();

            //Destroy(skillG0, data.durationTime);
            //开启冷却
            StartCoroutine(CoolTimeDown(data));
        }
Exemple #10
0
        //重复伤害
        private IEnumerator RepeatDamage(SkillDeployer deploy, SkillData skill)
        {
            float attackTime = 0;

            do
            {
                if (skill.attackTargets != null && skill.attackTargets.Length > 0)
                {
                    //对多个 目标执行伤害
                    for (int i = 0; i < skill.attackTargets.Length; i++)
                    {
                        OnceDamage(skill, skill.attackTargets[i]);//**
                    }
                }
                //间隔一个时间,再次执行伤害
                yield return(new WaitForSeconds(skill.damageInterval));

                attackTime += skill.damageInterval;//!! durationTime不是0,
                //damageInterval也不能为0
                //攻击一次之后,要重新选取目标
                skill.attackTargets = deploy.ResetTarget(); //先去实现施放器的 方法,再完成这里
            }while(attackTime < skill.durationTime);        //!!防止死循环
        }
Exemple #11
0
        //多次伤害
        private IEnumerator RepeatDamage(SkillDeployer deployer, SkillData skillData)
        {
            float attackTime = 0;

            do
            {
                if (skillData.attackTargets != null && skillData.attackTargets.Length != 0)
                {
                    //对目标执行伤害
                    for (int i = 0; i < skillData.attackTargets.Length; i++)
                    {
                        OnceDamage(skillData, skillData.attackTargets[i]);
                    }
                }

                yield return(new WaitForSeconds(skillData.damageInterval));

                attackTime += skillData.damageInterval;

                //攻击一次要重置目标
                skillData.attackTargets = deployer.ResetTargets();
            } while (attackTime < skillData.durationTime);  //防止死循环
        }
Exemple #12
0
 public void TargetImpact(SkillDeployer deployer, SkillData skillData, GameObject targetGo)
 {
     // 2 执行伤害
     deployer.StartCoroutine(RepeatDamage(deployer, skillData));
 }
Exemple #13
0
 public void Excute(SkillDeployer deployer)
 {
     deployer.StartCoroutine(RepeatDamage(deployer));
 }
Exemple #14
0
        public void DoImpact(SkillDeployer deployer)
        {
            var chState = deployer.CurrentSkillData.owner.GetComponent <CharacterStatus>();

            chState.SP -= deployer.CurrentSkillData.costSP;
        }
Exemple #15
0
 public void DoImpact(SkillDeployer deployer)
 {
     //攻击
     deployer.StartCoroutine(RepeatAttack(deployer));
 }
Exemple #16
0
 public void Excute(SkillDeployer deployer)
 {
     deployer.CurrentSkillData.owner.GetComponent <CharacterStatus>().SP -= deployer.CurrentSkillData.costSP;
 }