示例#1
0
        // 필수 init 처리
        protected void SetEssentialInit(Vector3Int pos, List <Buff> buff, int hp, int damage, float attack_delay, string name)
        {
            // 버프 적용
            for (int i = 0; i < buff.Count; i++)
            {
                Buff buffCopy = buff[i].Copy();
                buffCopy.Init(this);
                buffList.Add(buffCopy);
            }

            // 상태 초기화
            currentState = PlayerUnitState.Init;

            // 값 초기화
            MaxHP              = hp;
            HP                 = hp;
            Damage             = damage;
            AttackDelay        = attack_delay;
            AdditionalDamage   = 0;
            DamageMultiplier   = 1;
            unitName           = name;
            CurrentAttackDelay = 0;

            // 유닛 위치 초기화
            this.gameObject.transform.position = pos + new Vector3(0, 0, -0.4f);
            UnitPosition = pos;

            // 업데이트 추가
            GameManager.Instance.AddUpdate(this);

            GameManager.Instance.MessageSystem.Publish(PlayerUnitSummonEvent.Create(pos, this));
        }
示例#2
0
    GameObject DetectEnemyUnit()
    {
        if (b_DetectEnemy == false && go_TargetedEnemy == null)
        {
            List <Transform> nearbyEnemy = new List <Transform>();
            foreach (Transform T_enemyChild in T_Enemy)
            {
                if ((T_enemyChild.position - gameObject.GetComponent <Transform>().position).sqrMagnitude <= GetRange() * GetRange())
                {
                    //DO something
                    nearbyEnemy.Add(T_enemyChild);
                    //gameObject.GetComponent<Renderer>().material.color = Color.green;
                    //Debug.Log("Detected");
                }
            }
            foreach (Transform T_enemyBuilding in T_ENemyBase)
            {
                if ((T_enemyBuilding.position - gameObject.GetComponent <Transform>().position).sqrMagnitude <= GetRange() * GetRange())
                {
                    nearbyEnemy.Add(T_enemyBuilding);
                }
            }


            int i_Enemy = 0;
            while (i_Enemy < nearbyEnemy.Count)
            {
                if (i_Enemy > 0)
                {
                    if ((gameObject.transform.position - nearbyEnemy[i_Enemy].position).sqrMagnitude < (gameObject.transform.position - go_TempEnemyHolder.transform.position).sqrMagnitude)
                    {
                        go_TempEnemyHolder = nearbyEnemy[i_Enemy].gameObject;
                    }
                    if (i_Enemy == nearbyEnemy.Count - 1)
                    {
                        PUS = PlayerUnitState.PUS_ATTACK;
                        go_TargetedEnemy = go_TempEnemyHolder;
                        listOfEnemy.Add(go_TargetedEnemy.transform);
                        b_DetectEnemy = true;
                    }
                }
                else
                {
                    go_TempEnemyHolder = nearbyEnemy[i_Enemy].gameObject;
                    if (i_Enemy == nearbyEnemy.Count - 1)
                    {
                        PUS = PlayerUnitState.PUS_ATTACK;
                        go_TargetedEnemy = go_TempEnemyHolder;
                        listOfEnemy.Add(go_TargetedEnemy.transform);
                        b_DetectEnemy = true;
                    }
                }
                i_Enemy++;
            }
        }

        return(go_TargetedEnemy);
    }
示例#3
0
 public void StopAllActions()
 {
     PUS = PlayerUnitState.PUS_GUARD;
     _animator.ResetTrigger("b_IsAttacking");
     _animator.ResetTrigger("b_IsMoving");
     _animator.ResetTrigger("b_isHarvesting");
     b_Moving            = false;
     b_TargetedEnemy     = false;
     _navmeshAgent.speed = 0f;
 }
示例#4
0
        public override void UpdateFrame(float dt)
        {
            switch (currentState)
            {
            case PlayerUnitState.Init:
                if (CheckRangeTileTarget() == true)
                {
                    currentState = PlayerUnitState.Attack;
                }
                else
                {
                    currentState = PlayerUnitState.Idle;
                }
                break;

            case PlayerUnitState.Idle:
                if (CurrentAttackDelay <= AttackDelay)
                {
                    CurrentAttackDelay += dt;
                }
                break;

            case PlayerUnitState.Attack:
                if (CurrentAttackDelay > AttackDelay)
                {
                    ResetBlinkCount();
                    CurrentAttackDelay = 0;
                    Attack();
                }
                else
                {
                    UnitAnimator.SetBool("attack", false);
                    CurrentAttackDelay += dt;
                }
                break;

            case PlayerUnitState.Dead:
                StartCoroutine("Dead");
                break;

            default:
                break;
            }
        }
示例#5
0
        public sealed override bool OnEvent(IEvent e)
        {
            if (e.GetType() == typeof(TileEnterEvent))
            {
                TileEnterEvent enterEvent = e as TileEnterEvent;
                if (currentState == PlayerUnitState.Idle)
                {
                    foreach (var rangeTilePos in rangeTile)
                    {
                        if (rangeTilePos == enterEvent.EnterTilePos)
                        {
                            currentState = PlayerUnitState.Attack;
                            Target       = (MonsterUnit)enterEvent.EnterUnit;
                            return(true);
                        }
                    }
                }
            }
            else if (e.GetType() == typeof(DamageEvent))
            {
                DamageEvent DamageEvent = e as DamageEvent;
                if (DamageEvent.Target == (Unit)this)
                {
                    DamageEvent newDamageEvent = DamageEvent.Create(DamageEvent.Publisher, DamageEvent.Target, DamageEvent.Damage);

                    if (HP > newDamageEvent.Damage)
                    {
                        HP -= newDamageEvent.Damage;
                    }
                    else
                    {
                        HP           = 0;
                        currentState = PlayerUnitState.Dead;
                    }
                }
            }
            else if (e.GetType() == typeof(BattleStageEndEvent))
            {
                Dispose(true);
            }
            return(false);
        }
示例#6
0
    // Use this for initialization
    void Start()
    {
        _navmeshAgent = gameObject.GetComponent <NavMeshAgent>();
        _animator     = gameObject.GetComponent <Animator>();
        //getpath = GameObject.FindGameObjectWithTag("MoveParent").GetComponent<WaypointConnector>().getCreatePath();

        //debugLog = GameObject.FindGameObjectWithTag("DebugPurpose").transform.GetChild(0).gameObject;
        //WC = GameObject.FindGameObjectWithTag("MoveParent").GetComponent<WaypointConnector>();

        go_CommandMenu = GameObject.FindGameObjectWithTag("Canvas").transform.GetChild(0).gameObject;
        go_CommandMenu.SetActive(false);

        i_resourceWOOD  = 0;
        i_resourceSTONE = 0;
        T_Enemy         = GameObject.FindGameObjectWithTag("EnemyList").transform;
        T_ENemyBase     = GameObject.FindGameObjectWithTag("EnemyBuildingList").transform;
        PUS             = PlayerUnitState.PUS_GUARD;
        //rb_Body = gameObject.GetComponent<Rigidbody>();
        b_Selected          = false;
        b_Moving            = false;
        b_DetectEnemy       = false;
        b_TargetedEnemy     = false;
        b_CollidedWithEnemy = false;

        if (PUN == PlayerUnitType.PUN_WORKER)
        {
            b_StartHarvest     = false;
            b_HoldingResource  = false;
            b_buildBuilding    = false;
            b_isHarvesting     = false;
            f_HarvestingTime   = 0;
            b_isStoneHarvested = false;
            b_isWoodHarvested  = false;
            b_toHarvestStone   = false;
            b_toHarvestTree    = false;
        }

        f_OriginSpeed    = _navmeshAgent.speed;//f_speed;
        go_TargetedEnemy = null;
    }
示例#7
0
    private void MoveToTargetPos()
    {
        _navmeshAgent.SetDestination(v3_targetPos);
        _animator.SetTrigger("b_IsMoving");
        //Vector3 dir = gameObject.transform.position - _navmeshAgent.nextPosition;
        Vector3 dir    = _navmeshAgent.velocity + gameObject.transform.position;
        Vector3 lookAt = new Vector3(dir.x, gameObject.transform.position.y, dir.z);

        gameObject.transform.LookAt(lookAt);
        if ((gameObject.transform.position - v3_targetPos).sqrMagnitude < 0.05f * 0.05f)
        {
            if (b_buildBuilding)
            {
                ConstructBuilding(v3_targetPos);
                b_buildBuilding = false;
            }

            PUS      = PlayerUnitState.PUS_GUARD;
            b_Moving = false;
            _animator.ResetTrigger("b_IsMoving");
            _navmeshAgent.isStopped = true;
        }
    }
示例#8
0
 public void SetUnitState(PlayerUnitState pus)
 {
     PUS = pus;
 }
示例#9
0
    void AttackEnemyUnit()
    {
        if (go_TargetedEnemy != null)
        {
            if (b_DetectEnemy || b_TargetedEnemy)
            {
                listOfEnemy.Clear();
                b_Moving         = false;
                b_AttackingEnemy = true;
                Vector3 enemyLoc   = new Vector3(go_TargetedEnemy.transform.position.x, gameObject.transform.position.y, go_TargetedEnemy.transform.position.z);
                Vector3 difference = go_TargetedEnemy.transform.position - gameObject.transform.position;
                gameObject.transform.LookAt(enemyLoc);
                if (PUN == PlayerUnitType.PUN_MELEE || PUN == PlayerUnitType.PUN_TANK)
                {
                    //_navmeshAgent.stoppingDistance = 0.05f;
                    if (go_TargetedEnemy.tag == "Enemy")
                    {
                        if (difference.sqrMagnitude > 0.08f * 0.08f)
                        {
                            _navmeshAgent.stoppingDistance = 0.04f;
                            _animator.SetTrigger("b_IsMoving");
                            //gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, go_TargetedEnemy.transform.position, GetSpeed() * Time.deltaTime);
                            _navmeshAgent.SetDestination(go_TargetedEnemy.transform.position);
                            f_fireCooldown = 0;
                        }
                        else
                        {
                            _animator.ResetTrigger("b_IsMoving");

                            if ((f_fireCooldown += Time.deltaTime) >= 1 / f_fireRate)
                            {
                                _animator.SetTrigger("b_IsAttacking");
                                f_fireCooldown = 0;
                                go_TargetedEnemy.gameObject.GetComponent <EnemyBehaviour>().f_health -= GetAttack();
                            }
                        }
                    }
                    else
                    {
                        if (difference.sqrMagnitude > 0.1f * 0.1f)
                        {
                            _navmeshAgent.stoppingDistance = 0.1f;

                            _animator.SetTrigger("b_IsMoving");
                            //gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, go_TargetedEnemy.transform.position, GetSpeed() * Time.deltaTime);
                            _navmeshAgent.SetDestination(go_TargetedEnemy.transform.position);
                            f_fireCooldown = 0;
                        }
                        else
                        {
                            _animator.ResetTrigger("b_IsMoving");
                            _navmeshAgent.ResetPath();

                            if ((f_fireCooldown += Time.deltaTime) >= 1 / f_fireRate)
                            {
                                _animator.SetTrigger("b_IsAttacking");
                                f_fireCooldown = 0;
                                if (go_TargetedEnemy.name != "Base")
                                {
                                    go_TargetedEnemy.gameObject.GetComponent <BuildingInfo>().f_health -= GetAttack();
                                }
                                else
                                {
                                    go_TargetedEnemy.gameObject.GetComponent <TownHallBehaviour>().f_health -= GetAttack();
                                }
                            }
                        }
                    }
                }
                else if (PUN == PlayerUnitType.PUN_RANGE)
                {
                    if ((f_fireCooldown += Time.deltaTime) >= 1 / f_fireRate)
                    {
                        _animator.SetTrigger("b_IsAttacking");
                        f_fireCooldown = 0;
                        FireBullet(difference.normalized);
                    }
                }
            }
        }


        //if ((go_TargetedEnemy.tag == "Enemy" && go_TargetedEnemy.GetComponent<EnemyBehaviour>().f_health <= 0) ||
        //    (go_TargetedEnemy.tag == "SelectableBuilding" && go_TargetedEnemy.GetComponent<BuildingInfo>().f_health <= 0) ||
        //   (go_TargetedEnemy.name == "Base" && go_TargetedEnemy.GetComponent<TownHallBehaviour>().f_health <= 0))
        if (go_TargetedEnemy == null)
        {
            //listOfEnemy.Remove(go_TargetedEnemy.transform);
            listOfEnemy.Clear();
            b_DetectEnemy       = false;
            b_AttackingEnemy    = false;
            b_TargetedEnemy     = false;
            b_CollidedWithEnemy = false;
            //b_Moving = true;
            _animator.ResetTrigger("b_IsAttacking");
            _animator.ResetTrigger("b_IsMoving");
            _navmeshAgent.speed = f_OriginSpeed;
            f_speed             = f_OriginSpeed;
            PUS = PlayerUnitState.PUS_GUARD;
        }
        else if ((go_TargetedEnemy.transform.position - gameObject.GetComponent <Transform>().position).sqrMagnitude > GetRange() * GetRange())
        {
            //listOfEnemy.Remove(go_TargetedEnemy.transform);
            b_DetectEnemy       = false;
            b_AttackingEnemy    = false;
            go_TargetedEnemy    = null;
            b_CollidedWithEnemy = false;
            _animator.ResetTrigger("b_IsAttacking");
            _animator.ResetTrigger("b_IsMoving");
            //b_Moving = true;
            _navmeshAgent.speed = f_OriginSpeed;
            f_speed             = f_OriginSpeed;
            PUS = PlayerUnitState.PUS_GUARD;
        }
    }
示例#10
0
    // Update is called once per frame
    void Update()
    {
        //debugLog.GetComponent<Text>().text = "state" + PUS + "," + "/n" +
        //                                     "CurrentPos"+ v3_currentPos + "," + "/n" +
        //                                     "targetpos" + v3_targetPos + "," + "/n" +
        //                                     "navmesh" + _navMeshAgent.enabled +  "," + "/n" +
        //                                     "isMoving" + b_Moving + "," + "/n" +
        //                                     "selected" + b_Selected;
        if (b_Selected)
        {
            //Debug.Log(PUS);

            foreach (Transform child in gameObject.transform)
            {
                if (child.transform.tag == "SelectionIcon")
                {
                    child.gameObject.SetActive(true);
                }
            }
        }
        else
        {
            foreach (Transform child in gameObject.transform)
            {
                if (child.transform.tag == "SelectionIcon")
                {
                    child.gameObject.SetActive(false);
                }
            }
        }

        if (f_HealthPoint <= 0)
        {
            go_CommandMenu.SetActive(false);
            Destroy(gameObject);
        }
        if (b_StartHarvest)
        {
            PUS = PlayerUnitState.PUS_HARVEST;
        }
        else if (!b_StartHarvest)
        {
            _navmeshAgent.stoppingDistance = 0f;
            b_toHarvestStone = false;
            b_toHarvestTree  = false;
        }

        if (PUN == PlayerUnitType.PUN_WORKER)
        {
            if (b_Moving)
            {
                PUS = PlayerUnitState.PUS_MOVE;
            }
            else if (!b_Moving && !b_StartHarvest)
            {
                PUS = PlayerUnitState.PUS_GUARD;
            }
        }
        else
        {
            if (b_Moving || b_MovingToEnemy)
            {
                PUS = PlayerUnitState.PUS_MOVE;
            }
            else if (!b_Moving && !b_DetectEnemy && !b_TargetedEnemy)
            {
                PUS = PlayerUnitState.PUS_GUARD;
            }
            else if (b_TargetedEnemy)
            {
                PUS = PlayerUnitState.PUS_ATTACK;
            }
        }


        //if (PUN != PlayerUnitType.PUN_WORKER && !b_Moving)
        //{
        //    DetectEnemyUnit();
        //}

        if (b_isHarvesting)
        {
            _animator.ResetTrigger("b_IsMoving");
            _animator.SetTrigger("b_isHarvesting");
            f_HarvestingTime += Time.deltaTime;
            if (f_HarvestingTime >= 2)
            {
                b_HoldingResource = true;
                _animator.ResetTrigger("b_isHarvesting");
                _animator.SetTrigger("b_IsMoving");
                _navmeshAgent.speed = f_OriginSpeed;
                if (b_isStoneHarvested)
                {
                    i_resourceSTONE += go_Resource.GetComponent <StoneMineBehaviour>().CollectStone();
                }
                else if (b_isWoodHarvested)
                {
                    i_resourceWOOD += go_Resource.GetComponent <TreeBehaviour>().CollectWood();
                }

                f_HarvestingTime = 0;
                b_isHarvesting   = false;
            }
        }
        SnapToGround();
        //CheckWhetherStillOnGround();

        switch (PUS)
        {
        case PlayerUnitState.PUS_MOVE:
        {
            if (PUN == PlayerUnitType.PUN_WORKER)
            {
                b_StartHarvest = false;
            }
            //rb_Body.isKinematic = false;
            if (PUN != PlayerUnitType.PUN_WORKER && !b_AttackingEnemy)
            {
                DetectEnemyUnit();
            }

            if (b_Moving)
            {
                MoveToTargetPos();
            }
            else if (b_MovingToEnemy)
            {
                MoveToEnemyPos();
            }
            break;
        }

        case PlayerUnitState.PUS_ATTACK:
        {
            AttackEnemyUnit();
            break;
        }

        case PlayerUnitState.PUS_GUARD:
        {
            //this.GetComponent<NavMeshAgent>().enabled = false;
            //rb_Body.isKinematic = true;
            if (PUN != PlayerUnitType.PUN_WORKER && !b_AttackingEnemy)
            {
                DetectEnemyUnit();
            }
            break;
        }

        case PlayerUnitState.PUS_HARVEST:
        {
            if (PUN == PlayerUnitType.PUN_WORKER)
            {
                IgnoreCollision();
                //rb_Body.isKinematic = false;
                OnHarvestMode();
            }
            break;
        }
        }
    }