Attack() public method

public Attack ( ) : void
return void
Esempio n. 1
0
 void UtilityThiefActions()
 {
     if (EnemySpawner.instance.UtilityStatesInTheScene.Count == 0)
     {
         return;
     }
     enemyCombat.Attack();
 }
    void Update()
    {
        float distance = Vector3.Distance(target.position, transform.position);

        if (distance <= lookRadius)
        {
            agent.SetDestination(target.position);

            FaceTarget();
        }

        if (distance <= agent.stoppingDistance)
        {
            //Attack the target
            CharacterStats targetStats = target.GetComponent <CharacterStats>();

            //canAttack = true;

            //if (targetStats != null)
            //{
            if (agent.velocity.sqrMagnitude <= 0f)
            {
                combat.Attack(targetStats);
            }
            //}

            FaceTarget();
        }
        else
        {
            //canAttack = false;
        }
    }
Esempio n. 3
0
    void Update()
    {
        if (combat.IsAggrovated)
        {
            if (Vector3.Distance(transform.position, player.transform.position) > combat.RangeToAttack)
            {
                destinationPosition = player.transform.position;
            }
            else
            {
                destinationPosition = transform.position;

                //TODO: Move timeToNextAttack to EnemyCombat script so that EnemyMovement does not care about it.
                if (Time.time >= timeToNextAttack)
                {
                    timeToNextAttack = Time.time + combat.NextAttackTimer;
                    combat.Attack();
                }
            }
        }
        else
        {
            if (Time.time >= timeToWander)
            {
                timeToWander = Time.time + Random.Range(5, 11);
                Wander();
            }
        }

        transform.LookAt(destinationPosition);
        transform.position = Vector3.MoveTowards(transform.position, destinationPosition, MovementSpeed * Time.deltaTime);
    }
Esempio n. 4
0
    // Update is called once per frame
    void Update()
    {
        float distance    = Vector3.Distance(transform.position, player.transform.position);
        bool  isRunning   = false;
        bool  isAttacking = false;

        if (distance <= lookRadius)
        {
            if (!scream)
            {
                mort_scream.source.Play();
                scream = true;
            }
            agent.SetDestination(player.transform.position);
            if (distance <= attackRadius)
            {
                isAttacking = true;
                animator.SetBool("isRunning", isRunning);
                animator.SetBool("isAttacking", isAttacking);
                enemyCombat.Attack(this, player);
            }
            else
            {
                isRunning = true;
                animator.SetBool("isRunning", isRunning);
                animator.SetBool("isAttacking", isAttacking);
            }
        }
        else
        {
            scream = false;
        }
        if (isRunning && !isAttacking)
        {
            if (!mort_run.source.isPlaying)
            {
                mort_run.source.Play();
            }
        }
        else if (isAttacking)
        {
            // if (mort_grrr.source.isPlaying)
            // {
            //     mort_grrr.source.Play();
            // }

            // if (mort_run.source.isPlaying)
            // {
            //     mort_run.source.Stop();
            // }
            Debug.Log(Time.time);
            if (!mort_attaque.source.isPlaying && Time.time >= waitAttack)
            {
                mort_attaque.source.Play();

                waitAttack = Time.time + 1f / waitNextAttack;
            }
        }
    }
Esempio n. 5
0
    private void Update()
    {
        switch (state)
        {
        default:
        case State.Roaming:
            enemyPathfindingMovement.StartFollow(roamPosition);

            float reachedPositionDistance = 1f;
            if (Vector3.Distance(transform.position, roamPosition) < reachedPositionDistance)
            {
                roamPosition = GetRoamingPosition();
            }

            FindTarget();
            break;

        case State.ChaseTarget:
            enemyPathfindingMovement.StartFollow(PlayerController.instance.GetPosition().position);

            if (Vector3.Distance(transform.position, PlayerController.instance.GetPosition().position) < attackRange)
            {
                //прекращаем передвижение
                enemyPathfindingMovement.CanMove = false;
                if (Time.time > nextAttackTime)
                {
                    //Атакуем цель
                    enemyCombat.Attack();
                    //state = State.AttackingTarget;
                    nextAttackTime = Time.time + attackSpeed;
                }
            }
            float stopChaseDistance = 21f;
            if (Vector3.Distance(transform.position, PlayerController.instance.GetPosition().position) > stopChaseDistance)
            {
                //слишком далеко, прекращаем преследование
                state = State.GoingBackToStart;
            }
            break;

        case State.AttackingTarget:
            break;

        case State.GoingBackToStart:
            enemyPathfindingMovement.StartFollow(startingPosition);

            reachedPositionDistance = 10f;
            if (Vector3.Distance(transform.position, startingPosition) < reachedPositionDistance)
            {
                //возвращаемся на стартовую точку
                state = State.Roaming;
            }
            break;
        }
    }
    // Update is called once per frame
    void Update()
    {
        float distance    = Vector3.Distance(transform.position, player.transform.position);
        bool  isRunning   = false;
        bool  isAttacking = false;

        if (distance <= lookRadius)
        {
            if (!scream)
            {
                zombie_scream.source.Play();
                scream = true;
            }
            agent.SetDestination(player.transform.position);
            if (distance <= attackRadius)
            {
                isAttacking = true;
                animator.SetBool("isRunning", isRunning);
                animator.SetBool("isAttacking", isAttacking);
                enemyCombat.Attack(this, player);
            }
            else
            {
                isRunning = true;
                animator.SetBool("isRunning", isRunning);
                animator.SetBool("isAttacking", isAttacking);
            }
        }
        else
        {
            scream = false;
        }
        if (!isRunning && !isAttacking)
        {
            //Debug.Log(ennemy);
        }
        else if (isRunning && !isAttacking)
        {
            if (!zombie_run.source.isPlaying)
            {
                zombie_run.source.Play();
            }
        }
        else if (isAttacking)
        {
            if (!zombie_attaque.source.isPlaying)
            {
                zombie_attaque.source.Play();
            }

            //zombie_attaque
        }
    }
Esempio n. 7
0
    // Update is called once per frame
    void Update()
    {
        float distance = Vector3.Distance(target.position, transform.position);

        if (distance <= lookRadius)
        {
            CharacterStats targetStats = target.GetComponent <CharacterStats>();
            if (targetStats != null)
            {
                combat.Attack(targetStats);
            }

            FaceTarget();
        }
    }
Esempio n. 8
0
 // Update is called once per frame
 void FixedUpdate()
 {
     if (util.playerFound() && util.distToPlayer < util.attackRange)
     {
         combat.Attack();
     }
     else if (util.playerFound() || util.inCombat)
     {
         util.inCombat = true;
         combat.Chase();
     }
     else
     {
         pacing.Pace();
     }
 }
Esempio n. 9
0
 // Update is called once per frame
 void Update()
 {
     if (aiPath.desiredVelocity.x >= 0.01f)//moving to the right
     {
         animator.SetBool("moveRight", true);
         animator.SetBool("moveLeft", false);
         //Debug.Log("Right");
     }
     else if (aiPath.desiredVelocity.x <= -0.01f)//moving to the left
     {
         animator.SetBool("moveRight", false);
         animator.SetBool("moveLeft", true);
         //Debug.Log("Left");
     }
     //animator.SetTrigger("Attack"); //Quando a tartaruga tiver uma animação de ataque (se tiver)
     enemyCombat.Attack();
 }
    void Update()
    {
        if (playerGuy.IsDead)
        {
            return;
        }

        if (!combat.enabled)
        {
            return;
        }

        agent.SetDestination(player.position);

        if ((player.position - transform.position).magnitude < agent.stoppingDistance)
        {
            FaceTarget();
            combat.Attack();
        }
    }
Esempio n. 11
0
    // Update is called once per frame
    private void Update()
    {
        PlayAnim();

        // Distance to the target
        float playerDistance = Vector3.Distance(target.position, transform.position);

        // If inside the lookRadius
        if (playerDistance <= lookRadius)
        {
            agent.SetDestination(target.position); // Move towards target
            isIdle      = false;
            isWalking   = true;
            isAttacking = false;
            isDead      = false;

            // If within attacking distance
            if (playerDistance <= agent.stoppingDistance + 2f)
            {
                CharacterStats targetStats = target.GetComponent <CharacterStats>();

                if (targetStats != null)
                {
                    combat.Attack(targetStats); // Attack the target
                    isIdle      = false;
                    isWalking   = false;
                    isAttacking = true;
                    isDead      = false;

                    // If enemy is dead
                    if (enemyStats.ZeroHealth)
                    {
                        gameObject.GetComponent <NavMeshAgent>().isStopped = true;
                        isDead      = true;
                        isIdle      = false;
                        isWalking   = false;
                        isAttacking = false;
                    }
                }

                FaceTarget(); // Face the target
            }
        }

        else
        {
            agent.SetDestination(moveSpots[randomSpot].position); // Move towards target
            isIdle      = false;
            isWalking   = true;
            isAttacking = false;
            isDead      = false;

            // Distance to the moveSpot
            float patrolDistance = Vector3.Distance(moveSpots[randomSpot].position, transform.position);

            // If distance is between enemy and destination is smaller or equal to destination, the enemy has reached its destination
            if (patrolDistance <= agent.stoppingDistance)
            {
                // Move to new position
                if (waitTime <= 0)
                {
                    randomSpot = Random.Range(0, moveSpots.Length);
                    waitTime   = startWaitTime;
                }

                // Wait X amount of seconds before moving again
                else
                {
                    waitTime   -= Time.deltaTime;
                    isIdle      = true;
                    isWalking   = false;
                    isAttacking = false;
                    isDead      = false;
                }
            }
        }
    }