예제 #1
0
파일: BattleHero.cs 프로젝트: TimonYoon/Dev
    void OnDrawGizmosSelected()
    {
        if (!showDebug)
        {
            return;
        }

        if (gameObject != UnityEditor.Selection.activeGameObject)
        {
            return;
        }

        if (!battleGroup)
        {
            return;
        }

        GUIStyle style = new GUIStyle();


        BattleHero enemy = nearestEnemy;

        Color color = Color.white;

        style.normal.textColor = color;

        UnityEditor.Handles.color = color;
        UnityEditor.Handles.Label(enemy.transform.position, enemy.GetDistanceFrom(this).ToString(), style);
    }
예제 #2
0
    protected bool IsInCastRange(BattleHero target)
    {
        if (!target)
        {
            return(false);
        }

        float distance = target.GetDistanceFrom(owner);

        if (distance >= skill.skillData.minDistance && distance <= skill.skillData.maxDistance)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
예제 #3
0
    /// <summary> 시전 가능 여부 체크 </summary>
    virtual public void CheckCastCondition()
    {
        if (!isInitialized || skillData == null || !owner)
        {
            canCastSkill = false;
            return;
        }

        ////현재 쿨타임 중이면 발동 불가
        //if (isCoolTime)
        //{
        //    canCastSkill = false;
        //    return;
        //}

        //if (castTargetCollector != null)
        //    castTarget = castTargetCollector.CollectTarget(this);

        castTarget = CollectCastTarget(this);


        if (castTarget && castTarget != owner)
        {
            float distance = castTarget.GetDistanceFrom(owner);
            if (distance > skillData.maxDistance || (skillData.minDistance > 0f && distance < skillData.minDistance))
            {
                canCastSkill = false;
                return;
            }

            if (!skillData.canCastToAir && castTarget.skeletonAnimation.transform.localPosition.y > 3f)
            {
                canCastSkill = false;
                return;
            }
        }

        canCastSkill = IsValidCondition(castTarget, skillData.castCondition);
    }
예제 #4
0
    public override BattleHero CollectTarget(SkillBase skill)
    {
        //이전 대상이 살아있는데, 검색 주기 전이면 새로 검색 안 함
        if ((lastTarget && !skill.skillData.canCastToDeadUnit && !lastTarget.isDie) &&
            Time.time < lastCollectTargetTime + refreshInterval)
        {
            return(lastTarget);
        }

        base.CollectTarget(skill);

        if (!owner.battleGroup)
        {
            return(null);
        }

        if (owner.team == BattleUnit.Team.none || enemyList == null || enemyList.Count == 0)
        {
            return(null);
        }

        farthestEnemy = null;
        float distance = -9999f;

        for (int i = 0; i < enemyList.Count; i++)
        {
            BattleHero enemy = enemyList[i];
            if (enemy == owner as BattleHero)
            {
                continue;
            }


            if (!skill.skillData.canCastToDeadUnit && enemy.isDie && enemy == owner)
            {
                continue;
            }

            if (!farthestEnemy)
            {
                distance = enemy.GetDistanceFrom(owner);
                if (distance >= skill.skillData.minDistance && distance <= skill.skillData.maxDistance)
                {
                    //공중 공격 불가 시 공중에 있는 애는 타겟으로 잡지 않음
                    if (skill.skillData.canCastToAir || (!skill.skillData.canCastToAir && enemy.skeletonAnimation.transform.localPosition.y < 3f))
                    {
                        farthestEnemy = enemy;
                        continue;
                    }
                }
            }
            else
            {
                distance = enemy.GetDistanceFrom(owner);
                if (farthestEnemy.GetDistanceFrom(owner) < distance && distance >= skill.skillData.minDistance && distance <= skill.skillData.maxDistance)
                {
                    //공중 공격 불가 시 공중에 있는 애는 타겟으로 잡지 않음
                    if (skill.skillData.canCastToAir || (!skill.skillData.canCastToAir && enemy.skeletonAnimation.transform.localPosition.y < 3f))
                    {
                        farthestEnemy = enemy;
                    }
                }
            }
        }

        lastTarget            = farthestEnemy;
        lastCollectTargetTime = Time.time;
        //lastDistanceFromTarget = distance;

        return(farthestEnemy);
    }
예제 #5
0
    public override BattleHero CollectTarget(SkillBase skill)
    {
        this.skill = skill;

        //이전 대상이 살아있는데, 검색 주기 전이면 새로 검색 안 함
        if (lastTarget && !skill.skillData.canCastToDeadUnit && lastTarget.isDie)
        {
        }
        else
        {
            if (Time.time < lastCollectTargetTime + refreshInterval)
            {
                return(lastTarget);
            }
        }


        base.CollectTarget(skill);

        if (!owner.battleGroup)
        {
            return(null);
        }

        if (owner.team == BattleUnit.Team.none || enemyList == null || enemyList.Count == 0)
        {
            return(null);
        }

        //도발한 적이 있으면 해당 적을 캐스팅 대상으로 지정
        if (owner.provokeEnemy && owner.provokeEnemy.gameObject.activeSelf)
        {
            if (skill.skillData.canCastToDeadUnit || (!skill.skillData.canCastToDeadUnit && !owner.provokeEnemy.isDie) ||
                skill.skillData.castToDeadUnit == owner.provokeEnemy.isDie)
            {
                return(owner.provokeEnemy);
            }
        }

        nearestEnemy = null;
        float distance = -9999f;

        //BattleHero frontMostEnemy = null;

        BattleUnit.Team team = owner.team;
        //Buff buff = owner.buffController.buffList.Find(x => x.id == "Buff_Succubus_Charm" && x.isActive);
        //if (buff != null)
        //{
        //    if (team != BattleUnit.Team.none)
        //        team = team == BattleUnit.Team.Blue ? BattleUnit.Team.Red : BattleUnit.Team.Blue;
        //    Debug.Log(" 매혹 걸림 캐스팅" + owner.team.ToString() + "->" + team.ToString());
        //}


        //거리 체크 안 해도 되는 조금 빠른 방식
        if (team == BattleUnit.Team.Red)
        {
            BattleHero enemy = owner.battleGroup.frontMostMonster;
            if (enemy == owner as BattleHero)
            {
                //Debug.Log("본인 타겟 " + owner.heroData.heroName);
            }
            else if (enemy && enemy.isFinishSpawned && skill.skillData.castToDeadUnit == enemy.isDie && enemy.transform.position.x > owner.transform.position.x)
            {
                if (skill.skillData.canCastToAir || enemy.skeletonAnimation.transform.localPosition.y < 3f)
                {
                    if (!enemy.isDie || (enemy.isDie && enemy.canResurrect))
                    //if(enemy.transform.position.x - owner.transform.position.x >= skill.skillData.minDistance
                    //    && enemy.transform.position.x - owner.transform.position.x <= skill.skillData.maxDistance)
                    {
                        lastTarget            = enemy;
                        lastCollectTargetTime = Time.time;
                        return(enemy);
                    }
                }
            }
        }
        else if (team == BattleUnit.Team.Blue)
        {
            BattleHero enemy = owner.battleGroup.frontMostHero;
            if (enemy == owner as BattleHero)
            {
                //Debug.Log("본인 타겟 " + owner.heroData.heroName);
            }
            else if (enemy && enemy.isFinishSpawned && skill.skillData.castToDeadUnit == enemy.isDie && enemy.transform.position.x < owner.transform.position.x)
            {
                if (skill.skillData.canCastToAir || enemy.skeletonAnimation.transform.localPosition.y < 3f)
                {
                    if (!enemy.isDie || (enemy.isDie && enemy.canResurrect))
                    //if (enemy.transform.position.x - owner.transform.position.x >= skill.skillData.minDistance
                    //       && enemy.transform.position.x - owner.transform.position.x <= skill.skillData.maxDistance)
                    {
                        lastTarget            = enemy;
                        lastCollectTargetTime = Time.time;
                        return(enemy);
                    }
                }
            }
        }


        for (int i = 0; i < enemyList.Count; i++)
        {
            BattleHero enemy = enemyList[i];

            if (!enemy.gameObject.activeSelf)
            {
                continue;
            }

            if (enemy == owner as BattleHero)
            {
                //Debug.Log("11본인 타겟 " + owner.heroData.heroName);
                continue;
            }

            if (!skill.skillData.canCastToDeadUnit && enemy.isDie)
            {
                continue;
            }

            if (skill.skillData.castToDeadUnit != enemy.isDie)
            {
                continue;
            }

            if (enemy.isDie && !enemy.canResurrect)
            {
                continue;
            }

            if (skill.skillData.canCastToAir || enemy.skeletonAnimation.transform.localPosition.y < 3f)
            {
                distance = enemy.GetDistanceFrom(owner);

                //if (distance < skill.skillData.minDistance || distance > skill.skillData.maxDistance)
                //    continue;

                if (!nearestEnemy)
                {
                    nearestEnemy = enemy;
                    continue;
                }
                else
                {
                    //이전 대상 보다 가까우면 교체
                    if (nearestEnemy.GetDistanceFrom(owner) > distance)
                    {
                        nearestEnemy = enemy;
                    }
                }
            }
        }



        lastTarget            = nearestEnemy;
        lastCollectTargetTime = Time.time;
        //lastDistanceFromTarget = distance;

        return(nearestEnemy);
    }