void Start() { enemySettings = GOD.Instance.Settings.enemy; if(enemySettings == null) Debug.Log("settings in " + gameObject.name + " is null"); state = EnemyStates.NEUTRAL; //init spawn direction switch (Random.Range(0 , 5)) { case 0: direction = new Vector3(1,0,0); break; case 1: direction = new Vector3(0,0,1); break; case 2: direction = new Vector3(0,0,-1); break; case 3: direction = new Vector3(-1,0,0); break; default: break; } }
protected virtual void Attack() { if (!InRankAttack(rankAttack)) { actualState = EnemyStates.movenment; //enemyMovement.MoveToTarget(targetPlayer.transform.position, targetPlayer); enemyMovement.ResumeMovenment(); } }
protected virtual void Movement() { if (isAttacker && targetPlayer.GetComponent<PlayerStatsEnemy>().Alive && InRankAttack(rankAttacker)) { actualState = EnemyStates.movenmentToAttack; //enemyMovement.StopMovenment(); enemyMovement.MoveToTarget(targetPlayer.transform.position, targetPlayer); } }
private void Start() { movement = GetComponent <NPCMovement>(); combat = GetComponent <EnemyCombat>(); ai = GetComponent <NPCAI>(); // spawnPoint = transform.position; spawnPoint = transform.localPosition; curState = EnemyStates.Wandering; }
// Start is called before the first frame update void Start() { sprayed = false; coverObjects = GameObject.FindGameObjectsWithTag("Cover"); agent = GetComponent <NavMeshAgent>(); currentPatrolTarget = patrolPositions[Random.Range(0, patrolPositions.Length)]; player = GameObject.FindGameObjectWithTag("Player"); waitTimer = Random.Range(3, 5); state = EnemyStates.Patrol; myAnim = bMan.GetComponent <Animator>(); }
private void OnCollisionEnter(Collision other) { if (other.gameObject.CompareTag("Player") && isChasing == true) { enemy = EnemyStates.Flee; } if (other.gameObject.CompareTag("Player") && isChasing == false) { enemy = EnemyStates.Chase; } }
private void OnTriggerEnter(Collider other) { EnemyStates eStates = other.transform.GetComponentInParent <EnemyStates>(); if (eStates == null) { return; } eStates.DoDamage(states.currentAction); }
void enableWaitForAttack(bool enabled) { currentState = EnemyStates.WaitForAttack; StopMoving(); if ((target.x > transform.position.x && facing == FacingDirection.West) || (target.x < transform.position.x && facing == FacingDirection.East)) { ChangeFacing(); } StartCoroutine(attackCycle(firstAttackChance)); }
// Start is called before the first frame update public virtual void Start() { state = EnemyStates.PATROL; cController = GetComponent <CharacterController>(); agent = GetComponent <NavMeshAgent>(); player = GameObject.FindGameObjectWithTag("Player"); anim = GetComponent <Animator>(); anim.SetBool("PlayerDetected", false); locked = false; wpStop = StartCoroutine(WaitOnWP()); }
protected void CheckAttack() { if (Vector2.Distance(transform.position, castle.transform.position) <= attackRange) { currentState = EnemyStates.Attacking; } else { currentState = EnemyStates.Walking; } }
private void Search() { indicatorColor.material.color = Color.yellow; transform.position = Vector3.MoveTowards(transform.position, targetPos, Time.deltaTime * moveSpeed); transform.rotation = Quaternion.RotateTowards(transform.rotation, targetRot, Time.deltaTime * lookSpeed); if (timedOut()) { state = EnemyStates.Patrolling; targetHome(); } }
protected override void Awake() { base.Awake(); if (world == null) { world = FindObjectOfType <World>(); } player = FindObjectOfType <Player>(); currentState = EnemyStates.Searching; }
protected virtual IEnumerator Attack() { transform.LookAt(friendlyAI.transform); friendlyAI.GetComponent <IDamageable>().TakeDamage(attackPower); currentState = EnemyStates.Idle; yield return(new WaitForSeconds(timeBetweenAttacks)); if (friendlyAI.GetComponent <FriendlyAI>().GetCurrentState() == FriendlyAIStates.Attacking) { StartCoroutine("Attack"); } }
/// <summary> /// Call this to make the enemy take knockback /// </summary> /// <param name="time">Duration IN SECONDS of the knockback</param> /// <param name="speed">Initial velocity of the knockback</param> public virtual void RecieveKnockback(float time, Vector2 speed) { canMove = false; knockbackTime = time; entity.Displacement = speed * knockbackModifier; //reset knockback modifer knockbackModifier = 1f; inKnockback = true; ResetCombatStates(); //Debug.Log("Switching Enemy states 11"); enemyState = EnemyStates.Knockback; }
void Update() { other = Physics.OverlapSphere(this.transform.position, 1.5f); //viewangle = 120 //find target vector target.position - transform.position //check if the angle of the z axis and the target vector is lower than the viewangle /2 //add the object to the list OnSightObjects.Clear(); for (int i = 0; i < other.Length; i++) { Transform tmp = other[i].transform; Vector3 DistToAi = tmp.position - transform.position; if (Vector3.Angle(DistToAi, transform.forward) < viewangle / 2) { if (other[i].gameObject.tag == "Player") { //Raycast to target Debug.Log("Chasing Player"); OnSightObjects.Add(other[i].gameObject); states = EnemyStates.Chase; } else { states = EnemyStates.Idle; } } } // foreach(Collider c in other) // { // if(c.gameObject.tag == "Player") // { // states=EnemyStates.Chase; // }else // { // states = EnemyStates.Idle; // } // } //When to change to Idle //When to change to Chase //if (Vector3.Distance(navMeshAgent.transform.position, FollowTarget.transform.position) < 3) //{ // states = EnemyStates.Chase; //}else if(Vector3.Distance(navMeshAgent.transform.position, FollowTarget.transform.position) > 3) //{ // states = EnemyStates.Idle; //} AIStates(states); }
private void Wander() { if (ai.CanSeeTarget(targetMask)) { target = ai.GetCurrentTarget(); curState = EnemyStates.Engaging; } else { movement.MoveTowards(spawnPoint); } }
private void OnTriggerStay(Collider other) { if (other != null) { if (other.gameObject.CompareTag("Distraction") && other.transform.parent.gameObject.GetComponent <ObjectMover>().GetAudible()) { contact = true; soundSource = other.gameObject.transform; enemyState = EnemyStates.DISTRACTED; } } }
private void FixedUpdate() { if (gameController.state != GameController.States.battle) { navMeshAgent.isStopped = true; return; } switch (enemyState) { case EnemyStates.idle: if (mySpawner == null) { enemyState = EnemyStates.ai; } else if (mySpawner.isOpened) { enemyState = EnemyStates.run; mySpawner.isOpened = false; } break; case EnemyStates.run: myTransform.Translate(Vector3.forward * speed * Time.fixedDeltaTime); runDistance += speed * Time.fixedDeltaTime; if (runDistance >= 2.0f) { enemyState = EnemyStates.ai; } break; case EnemyStates.ai: if (navMeshAgent.isStopped) { navMeshAgent.isStopped = false; } if (!banzai) { navMeshAgent.SetDestination(player.position); } else { navMeshAgent.SetDestination(radar.transform.position); } break; } }
// Start is called before the first frame update void Start() { enemyCurrentState = EnemyStates.idle; deathAnim = this.GetComponent <Animator>(); enemySprite = this.gameObject.GetComponent <Sprite>(); if (this.gameObject.name == "Enemy_Steady") { this.gameObject.GetComponent <Follow>().enabled = false; } }
protected virtual void OnTriggerExit(Collider c) { //check if player is outside our radius (optional) if (c.tag == "Ball") { //change state back to wandering enemyState = EnemyStates.Wandering; curSpeed = 0.0f; //clear enemy target target = null; } }
/// <summary> /// Unflags inEncounter and tells the enemy to return to its starting position /// </summary> public void EndEncounter() { //No longer in an encounter inEncounter = false; //Fix abnormal states ResetCombatStates(); //Set move target to the return position this.moveTarget = startingPosition; //Set state to returning to said position //Debug.Log("Switching Enemy states 12"); this.enemyState = EnemyStates.ReturningFromEncounter; }
void Move() { Vector3 direction = destination - transform.position; transform.rotation = Quaternion.LookRotation(direction); transform.position = Vector3.MoveTowards(transform.position, destination, speed); if (transform.position == destination) { currentState = EnemyStates.Idle; } }
void Attack() { if (attackbool == false) { InvokeRepeating("TakeDamage", 0.0f, 1.0f); attackbool = true; } if (attackDetector.Length > 0) { states = EnemyStates.IDIE; } }
private void MoveOnSpawn() { if (Time.time > timer) { // Change state and end invincibility period enemyState = EnemyStates.Shooting; canTakeDamage = true; } // Move in the "forward" direction of the sprite transform.Translate(Vector2.down * speed * Time.deltaTime); }
public void Attacking() { Quaternion tarRotation = Quaternion.LookRotation(PlayerReference.transform.position - this.transform.position); this.transform.rotation = Quaternion.Slerp(transform.rotation, tarRotation, rotationSpeed * Time.deltaTime); if ((lastSpawnTime > SpawnTime)) { this.GetComponent <FireBoltSpawner>().SpawnTheObject(this.gameObject); lastSpawnTime = 0f; this.enemyState = EnemyStates.Chase; } }
private void MoveOnSpawn() { // If the invincibility should end, change state and begin "AI" if (Time.time > timer) { enemyState = EnemyStates.Targetting; canTakeDamage = true; } // Move in the "forward" direction of the sprite transform.Translate(Vector2.down * speed * Time.deltaTime); }
private void ShootProjectiles() { // Spawn a bullet in each spawn zone attached to the enemy for (int i = 0; i < projectileSpawns.Length; i++) { Instantiate(projectile, projectileSpawns[i].transform.position, projectileSpawns[i].transform.rotation, spinner.transform); } // Set up timer for next shot and change state timer = Time.time + shootDelay; enemyState = EnemyStates.Spinning; }
private void Start() { if (isGuard) { enemyState = EnemyStates.GUARD; } else { enemyState = EnemyStates.PATROL; GetNewWayPoint(); } }
// Start is called before the first frame update void Start() { pointOfInterest = transform.position; defaultLocation = transform.position; currentState = EnemyStates.Passive; sensors = GetComponent <FieldOfView>(); lineOfSightMeshRenderer = transform.Find("LineOfSightMesh").GetComponent <Renderer>(); // lineOfSightMeshRenderer.material.shader = Shader.Find("Lightweight Render Pipeline/Simple Lit"); }
private void Awake() { Move = GetComponent <EnemyMove>(); Look = GetComponent <EnemyLook>(); Patrol = GetComponent <EnemyPatrol>(); Chase = GetComponent <EnemyChase>(); agent = GetComponent <NavMeshAgent>(); state = EnemyStates.Idle; lastState = EnemyStates.Idle; }
bool CheckForBackstab(Action slot) { if (!slot.canBackstab) { return(false); } EnemyStates backstabTarget = null; Vector3 origin = transform.position; origin.y += 1; Vector3 rayDir = transform.forward; RaycastHit hit; if (Physics.Raycast(origin, rayDir, out hit, 3, ignoreLayers)) { backstabTarget = hit.transform.GetComponentInParent <EnemyStates>(); } if (backstabTarget == null) { return(false); } Vector3 dir = transform.position - backstabTarget.transform.position; dir.Normalize(); dir.y = 0; float angle = Vector3.Angle(backstabTarget.transform.forward, dir); if (angle > 150) { Vector3 targetPos = dir * backstabOffset; targetPos += backstabTarget.transform.position; transform.position = targetPos; backstabTarget.transform.rotation = transform.rotation; backstabTarget.IsGettingBackstabbed(slot, inventoryManager.GetCurrentWeapon(slot.mirror)); onEmpty = false; canAttack = false; canMove = false; inAction = true; anim.SetBool(StaticStrings.mirror, slot.mirror); anim.CrossFade(StaticStrings.parry_attack, 0.2f); lockonTarget = null; return(true); } return(false); }
public virtual void Attack() { if (health >= 5) { this.FindClosestPlayer(); damage = Random.Range(damageMin, damageMax); Debug.Log("Damaging for " + damage + " damage"); } else { this.currentState = EnemyStates.Defend; } }
private void OnTriggerEnter2D(Collider2D collision) { if (collision.CompareTag("Villager") && currentState != EnemyStates.Escaping && currentState != EnemyStates.Engaged) { EnemyController.successes++; collision.gameObject.SetActive(false); currentState = EnemyStates.Escaping; } else if (collision.CompareTag("Guard")) { currentState = EnemyStates.Engaged; } }
void Attack() { if (!hasSpawned) { Vector3 toPlayer; toPlayer = _player.transform.position - transform.position; toPlayer = toPlayer.normalized; GameObject pyro = (GameObject)Instantiate(pyroBall, transform.position + toPlayer, transform.rotation); pyro.transform.parent = transform; hasSpawned = true; } else state = EnemyStates.Idle; }
void OnCollisionEnter(Collision collision) { if(collision.gameObject.layer == LayerMask.NameToLayer("wall")){ ChangeDirection(collision); state = (EnemyStates)Random.Range(0,4); ChangeColor(state); } if(collision.gameObject.tag == GlobalNames.TAG_PLAYER){ state = (EnemyStates)Random.Range(0,4); ChangeColor(state); Debug.Log("player hit"); } }
void Idle() { if(Vector3.Distance(_player.transform.position, transform.position) < aggroRange) { RaycastHit hit; if(Physics.Raycast(transform.position, (_player.transform.position - transform.position), out hit, float.PositiveInfinity, visionMask)) { if(hit.collider.tag == "Player") { state = EnemyStates.Attack; } } } return; }
private void onState(EnemyStates m_state) { if (debug) { Debug.Log("Handling state" + m_state); } switch (m_state) { case EnemyStates.Idle: handleIdle(); break; case EnemyStates.Patrol: handlePatrol(); break; case EnemyStates.Chasing: handleChasing(); break; } }
void ChangeColor(EnemyStates state) { switch (state) { case EnemyStates.NEUTRAL: gameObject.renderer.material.color = Color.blue; break; case EnemyStates.PISSED: gameObject.renderer.material.color = Color.yellow; break; case EnemyStates.ANGRY: gameObject.renderer.material.color = Color.red; break; case EnemyStates.DEAD: gameObject.renderer.material.color = Color.green; break; default: break; } }
private void onStateEnter(EnemyStates m_state) { if (debug) { Debug.Log("Entering state" + m_state); } switch (m_state) { case EnemyStates.Idle: handleIdleEntered (); break; case EnemyStates.Chasing: handleChasingEntered(); break; case EnemyStates.Patrol: handlePatrolEntered(); break; } }
public void ChangeState(EnemyStates state) { if (_currentState == state) { // Already in state return; } //Log.Trace("Enemy Changing state from {0} to {1}", _currentState, state); _currentState = state; if (_stateHandler != null) { _stateHandler.Dispose(); _stateHandler = null; } _stateHandler = _stateFactory.Create(state); _stateHandler.Initialize(); }
public IEnemyState Create(EnemyStates state) { switch (state) { case EnemyStates.Idle: { return _container.Instantiate<EnemyStateIdle>(); } case EnemyStates.RunAway: { return _container.Instantiate<EnemyStateRunAway>(); } case EnemyStates.Attack: { return _container.Instantiate<EnemyStateAttack>(); } case EnemyStates.Follow: { return _container.Instantiate<EnemyStateFollow>(); } } throw Assert.CreateException(); }
public void setDead() { currentHealth = 0; // Sets the health to 0. capsuleCollider.enabled = false; sphereCollider.enabled = false; leftHandAttack1.enabled = false; score.pointsCounter += points; anim.SetTrigger("Die"); // Plays the die animation. state = EnemyStates.DEAD; // Calls the DEAD state. }
void ChangeState(EnemyStates state) { m_state = state; }
public void setDamaged(int damage) { temp = tempDamage; currentHealth -= damage; // Applies the damage recieved if (currentHealth <= 0) setDead(); // Calls the setDead function if the enemy has died else state = EnemyStates.DAMAGED; // If the enemy is still alive, calls the DAMAGED state }
public void setStunned() { // TODO: implement the animation Debug.Log("Enemy stunned :("); temp = tempStunned; state = EnemyStates.STUNNED; }
public void AttackPlayer() { enemyState = EnemyStates.Moving; }
public void setStunAttack() { anim.SetTrigger("isStunning"); leftHandAttack1.enabled = false; // Deactivates the leftHandAttack1 collider, since it keeps activated if the enemy doesn't go to the activeState. This can happen if the player is always in range to stun. stunCooldown = stunCooldownIni; state = EnemyStates.STUNATTACK; }
public void setIdle() { capsuleCollider.enabled = true; // Activates the capsuleCollider. It keeps activated by default. sphereCollider.enabled = true; // Activates the sphereCollider. It keeps activated by default. leftHandAttack1.enabled = false; // Deactivates the leftHandAttack coollider. It keeps deactivated by default. state = EnemyStates.IDLE; }
IEnumerator ResumeAutoWalkAfterTime(float time) { yield return (new WaitForSeconds (time)); EnemyState = EnemyStates.MOVE_FORWARD; StopWalking = false; JumpFromBeginningToEnd = false; }
IEnumerator Damaged(float damage, AttackEffect[] attackEffects) { var previousState = enemyState; enemyState = EnemyStates.Damaged; animateEnemy.Damage(); attackDelayStartTime = Time.time; health -= damage; if (attackEffects.Length > 0){ yield return this.StartSafeCoroutine(WaitForAttackEffects(attackEffects)); } yield return new WaitForSeconds(damageDuration); if (health > 0){ animateEnemy.Inactive(); enemyState = previousState; } }
// Sets public void setAwake() { currentHealth = maxHealth; player = GameObject.FindGameObjectWithTag("Player"); // Finds the gameobject with the tag "Player". playerManager = player.GetComponent<PlayerManagerBackup>(); // Gets the script PlayerManager of the player. pointsText = GameObject.FindGameObjectWithTag("Score"); score = pointsText.GetComponent<PointCounter>(); nav = GetComponent<NavMeshAgent>(); // Gets the NavMeshAgent component. playerInRange = false; // Initalize the playerInRange bool to false. playerAttacked = false; // Initialize the playerAttacked bool to false. onStunTimer = onStunTimerIni; // Initialize the onStunTimer. stunCooldown = stunCooldownIni; // Initialize the stunCooldown. stunOffset = stunOffsetIni; // Initialize the stunOffset. //enemyAudio = GetComponent<AudioSource>(); // Gets the AudioSource component from the enemy. //rigidBody = GetComponent<Rigidbody>(); // Gets the rigidbody component from the enemy. //capsuleCollider = GetComponent<CapsuleCollider>(); //sphereCollider = GetComponent<SphereCollider>(); //leftHandAttack1 = GetComponentInChildren<SphereCollider>(); // Gets the SphereCollider of the leftHandAttack1 children. anim = GetComponent<Animator>(); // Gets the animator component from the enemy. state = EnemyStates.AWAKE; // Goes to the AWAKE state. }
void Start() { player = GameObject.Find("PlayerCharacter").GetComponent<PlayerController>(); enemyState = EnemyStates.Idle; animateEnemy = GetComponentInChildren<AnimateEnemy>(); behaviourCoroutine = this.StartSafeCoroutine(Primer()); }
public void HaltMovement() { EnemyState = EnemyStates.Hunting; }
void Update() { inDestinationRange = InRangeOfDestinationPosition(); inAttackRange = InRangeForAttack(); if (enemyState != EnemyStates.Dead){ var pos = transform.localPosition; if (health <= 0 && enemyState != EnemyStates.Dead){ enemyState = EnemyStates.Dead; CancelBehaviourCoroutine(); this.StartSafeCoroutine(Dead()); } if (enemyState == EnemyStates.Moving){ // Check if close enough if (InRangeOfDestinationPosition() && InRangeForAttack()){ CancelBehaviourCoroutine(); enemyState = EnemyStates.Attacking; } else{ if (!moving){ CancelBehaviourCoroutine(); moving = true; behaviourCoroutine = this.StartSafeCoroutine(Move()); } // Move towards destination if (destinationPosition.y <= pos.y + .01f){ pos.y -= vMoveSpeed; } else if (destinationPosition.y > pos.y - .01f){ pos.y += vMoveSpeed; } if (Mathf.Abs(pos.y - destinationPosition.y) < .03){ pos.y = destinationPosition.y; } if (destinationPosition.x <= pos.x){ pos.x -= hMoveSpeed; } else if (destinationPosition.x > pos.x){ pos.x += hMoveSpeed; } } } else if (enemyState == EnemyStates.Attacking){ if (InRangeForAttack()){ if (!punching){ CancelBehaviourCoroutine(); punching = true; behaviourCoroutine = this.StartSafeCoroutine(Punch()); } } else{ enemyState = EnemyStates.Moving; } } else if (enemyState == EnemyStates.Damaged){ return; } else if (enemyState == EnemyStates.Idle){ if (!InRangeOfDestinationPosition()){ pos = Vector3.MoveTowards(transform.position, destinationPosition, .025f); } else{ if (!idle){ CancelBehaviourCoroutine(); idle = true; behaviourCoroutine = this.StartSafeCoroutine(Idle()); } } } else if (enemyState == EnemyStates.Dead){ } if (enemyState != EnemyStates.Dead){ transform.rotation = player.transform.position.x < transform.position.x ? Quaternion.Euler(new Vector3(0, 180, 0)) : Quaternion.Euler(Vector3.zero); } transform.localPosition = Vector3.Lerp(transform.localPosition, pos, Time.deltaTime * generalMoveSpeed); } }
void nextState(Vector3 towardsTarget) { const float RET_ERR = 1.0f; // Rango de error para la vuelta a otro estado. // Control principal de las transiciones entre estados. float angleTmp = Vector3.Angle (transform.forward, towardsTarget.normalized); switch (actualState) { case EnemyStates.IDLE: if (towardsTarget.magnitude < SOUND_RANGE) { // Si escuchamos al jugador pasar al estado de busqueda. actualState = EnemyStates.LOOKING_TARGET; } break; case EnemyStates.LOOKING_TARGET: if (towardsTarget.magnitude > SOUND_RANGE + RET_ERR) { // Si el jugador se sale del rango de escucha, pasar al estado // inactivo actualState = EnemyStates.IDLE; timeForIdle = IDLE_TIME; } else if ((towardsTarget.magnitude < ATTACK_RANGE) && (angleTmp < VISION_ANGLE)) { // Si el jugador está a distancia de tiro y dentro del rango de // vision, pasar al estado disparo. actualState = EnemyStates.SHOOT_TARGET; } break; case EnemyStates.PURSUIT_TRAGET: if ((timeTargetLost <= 0) || (angleTmp > VISION_ANGLE + RET_ERR)) { // Si se ha perdido de vista al jugador un cierto tiempo y éste // se encuentra fuera del rango de visión, pasar al estado de // búsqueda. actualState = EnemyStates.LOOKING_TARGET; } else if (towardsTarget.magnitude < ATTACK_RANGE) { // Si el jugador se encuentra dentro del rango de ataque, pasar // al estado de disparo. actualState = EnemyStates.SHOOT_TARGET; } break; case EnemyStates.SHOOT_TARGET: if ((timeTargetLost <= 0) || (angleTmp > VISION_ANGLE + RET_ERR)) { actualState = EnemyStates.LOOKING_TARGET; } else if (towardsTarget.magnitude > ATTACK_RANGE + RET_ERR) { // Si el jugador se sale del rango de ataque pasar al estado // persecución. actualState = EnemyStates.PURSUIT_TRAGET; } break; } }
public void setActive() { leftHandAttack1.enabled = false; anim.SetBool("Attack", false); // Sets the Attack bool for the attack animation to false. onStunTimer = onStunTimerIni; stunOffset = stunOffsetIni; state = EnemyStates.ACTIVE; // Goes to the ACTIVE state. }
IEnumerator AutoJumpUpAfterTime(float time) { yield return (new WaitForSeconds (time)); if (Grounded && !Jump && !JumpInProgress) { GetComponent<Rigidbody2D>().velocity = new Vector2(0,0); StopWalking = true; // Change direction after jump? if(Random.Range (0, 3) == 1){ ChangeDirection(); } // It looks better when enemy looks around before jump Flip (); yield return (new WaitForSeconds (0.3f)); Flip (); yield return (new WaitForSeconds (0.3f)); Flip (); yield return (new WaitForSeconds (0.3f)); Jump = true; EnemyState = EnemyStates.JUMP_UP; yield return (new WaitForSeconds (0.3f)); Flip (); } IsInCoRoutineAutoJumpUp = false; }
public void setAttack() { AttackAction(attackMelee, tempAttackMelee); // Calls the AttackAction function, and give it the damage fo the attack, and the time that longs. anim.SetBool("Attack", true); // Sets the Attack bool for the attack animation to true. anim.SetBool("Run", false); // Sets the Run bool for the run animation to true. state = EnemyStates.ATTACK; // Goes to the ATTACK state. }
public void DoEnemyStatePointAction(bool jump_up, bool jump_forward, bool move_forward, bool move_directionChange) { if (Grounded && !Jump && !JumpInProgress && !JumpFromBeginningToEnd) { List<EnemyStates> EnemyStateList = new List<EnemyStates> (); if (jump_up) { EnemyStateList.Add(EnemyStates.JUMP_UP); } if (jump_forward) { if(PlayerFollowing){ InitPlayerTransform(); if(target != null){ if (target.position.y > (transform.position.y - range)) { // Player is above EnemyStateList.Add(EnemyStates.JUMP_FORWARD); } else { // Player is down EnemyStateList.Add(EnemyStates.MOVE_FORWARD); } } else { EnemyStateList.Add(EnemyStates.MOVE_FORWARD); } } else { EnemyStateList.Add(EnemyStates.JUMP_FORWARD); } } if (move_forward) { if(PlayerFollowing){ InitPlayerTransform(); if(target != null){ if (target.position.y > (transform.position.y + range)) { // Player is above EnemyStateList.Add(EnemyStates.JUMP_FORWARD); } else { // Player is down EnemyStateList.Add(EnemyStates.MOVE_FORWARD); } } else { EnemyStateList.Add(EnemyStates.MOVE_FORWARD); } } else { EnemyStateList.Add(EnemyStates.MOVE_FORWARD); } } if(move_directionChange){ EnemyStateList.Add(EnemyStates.MOVE_CHANGEDIRECTION); ChangeDirection(); } if (EnemyStateList.Count == 0) { EnemyStateList.Add(EnemyStates.JUMP_FORWARD); EnemyStateList.Add(EnemyStates.MOVE_FORWARD); } EnemyState = EnemyStateList[Random.Range (0, EnemyStateList.Count)]; } }
public void GoIdle() { enemyState = EnemyStates.Idle; behaviourCoroutine = this.StartSafeCoroutine(Idle()); }