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)];
}
}
