public override void execute(AbstractEnemyAI enemyAI)
{
if (GameManager.player == null)
{
Executing = false;
return;
}
entity.StopMoving();
entity.lookPos = GameManager.player.transform.position;
if (entity.currentWeapon.attacking)
{
return;
}
if (entity.currentWeapon.CanSecondaryAttack())
{
entity.SecondaryAttack();
}
else
{
entity.Attack();
}
if (!enemyAI.CanAttackTarget())
{
entity.lookingAt = false;
Executing = false;
}
}
public void beginSummon(SummonerAttackState _summoner, AbstractEnemyAI _enemyToSummon)
{
enemyToSummon = _enemyToSummon;
summoner = _summoner;
animator = GetComponent <Animator>();
animator.SetTrigger("BeginSummon");
}
public override void execute(AbstractEnemyAI enemyAI)
{
if (enemyAI.reachedEndOfPath || enemyAI.canSeePlayer)
{
Executing = false;
}
enemyAI.AstarMoveToTarget();
}
void OnTriggerEnter(Collider coll)
{
IAggroable aggroable = coll.GetComponentInParent <IAggroable>();
AbstractEnemyAI ai = aggroable as AbstractEnemyAI;
if (aggroable != null)
{
Assert.IsNotNull(ai);
AbstractEnemyAI.AIState newState = new AbstractEnemyAI.SeekingAggroAIState(ai, this);
aggroable.pushNewState(newState);
}
}
public override void execute(AbstractEnemyAI enemyAI)
{
entity.StopMoving();
if (enemySpawned && spawnCount <= numEnemiesToSpawn)
{
var summon = Instantiate(summoningController, enemyAI.GetCurrentRoom().GetRandomPointInRoom(2, 2), Quaternion.identity);
entity.lookPos = summon.transform.position;
summon.beginSummon(this, enemyPrefab);
enemySpawned = false;
}
}
public override void execute(AbstractEnemyAI enemyAI)
{
if (Executing && !conditionsMet(enemyAI))
{
Executing = false;
}
enemyAI.AstarMoveToTarget();
if (enemyAI.reachedEndOfPath)
{
enemyAI.targetPosition = currentRoom.GetRandomPointInRoom(0, 0);
}
}
public override bool conditionsMet(AbstractEnemyAI enemyAI)
{
if (enemyAI.currentState.Name == "Patrol" && !enemyAI.canSeePlayer)
{
if (!enemyAI.reachedEndOfPath)
{
return(true);
}
}
else if (enemyAI.currentState.Name == "Idle" && !enemyAI.canSeePlayer)
{
IdleState idleState = (IdleState)enemyAI.currentState;
if (idleState.timeIdle > patrolInterval)
{
return(true);
}
}
return(false);
}
public override void execute(AbstractEnemyAI enemyAI)
{
// If can see player update path to player and move towards.
if (enemyAI.canSeePlayer && !enemyAI.CanAttackTarget())
{
if (GameManager.player == null)
{
return;
}
enemyAI.targetPosition = GameManager.player.transform.position;
enemyAI.AstarMoveToTarget();
}
// If reached end of path and cannot see player stop executing ChaseState.
else
{
enemyAI.targetPosition = transform.position;
Executing = false;
}
}
public override void execute(AbstractEnemyAI enemyAI)
{
// If dashing check if we have travelled the dash distance and stop.
if (Vector2.Distance(startPos, transform.position) >= DashDistance && dashing && Executing)
{
OnFinishDash();
}
// If already dashing dont dash again
if (dashing || chargingDash)
{
return;
}
if (caster == null)
{
return;
}
lastCastTime = Time.time;
// Target wasnt set
if (target == Vector2.zero)
{
Debug.Log("[" + caster.name + "] " + "DashAbility target was not set");
}
UpdateDirection();
// Disable friction and movement
caster.canMove = false;
caster.applyFriction = false;
caster.ResetVelocity();
caster.AddVelocity(direction, DashSpeed);
dashing = true;
}
public SeekingAggroAIState(AbstractEnemyAI stateMachine, Aggro target)
: base(stateMachine)
{
stateMachine.navigation.SeekQueen();
this.target = target;
}
public override bool conditionsMet(AbstractEnemyAI enemyAI)
{
return(canCast() && enemyAI.canSeePlayer);
}
public IdleState(AbstractEnemyAI stateMachine) : base(stateMachine)
{
stateMachine.navigation.ClearSeeking();
}
public abstract void execute(AbstractEnemyAI enemyAI);
public abstract bool conditionsMet(AbstractEnemyAI enemyAI);
protected virtual void Awake()
{
enemyAI = GetComponent <AbstractEnemyAI>();
entity = GetComponent <AbstractEnemy>();
}
public override void execute(AbstractEnemyAI enemyAI)
{
timeIdle += Time.deltaTime;
entity.StopMoving();
}
public AtomicAIState(AbstractEnemyAI stateMachine) : base(stateMachine)
{
}
public void summonEnemy()
{
enemySummoned = Instantiate(enemyToSummon, GameManager.dungeonGenerator.Enemies.transform);
enemySummoned.transform.position = this.transform.position;
enemySummoned.enabled = false;
}
public override void execute(AbstractEnemyAI enemyAI)
{
throw new System.NotImplementedException();
}
public SeekingPlayerAIState(AbstractEnemyAI stateMachine)
: base(stateMachine)
{
stateMachine.navigation.SeekPlayer();
aggroLossTime = Time.time + stateMachine.aiParameters.aggroTime;
}
public override bool conditionsMet(AbstractEnemyAI enemyAI)
{
// Dont idle if we can see player
return(!enemyAI.canSeePlayer);
}
public override bool conditionsMet(AbstractEnemyAI enemyAI)
{
return(enemyAI.canSeePlayer && !enemyAI.CanAttackTarget());
}
public AIState(AbstractEnemyAI stateMachine)
{
this.stateMachine = stateMachine;
}
public override void execute(AbstractEnemyAI enemyAI)
{
enemyAI.Attack();
Executing = false;
}
public SeekingQueenAIState(AbstractEnemyAI stateMachine)
: base(stateMachine)
{
stateMachine.navigation.SeekQueen();
}
public override bool conditionsMet(AbstractEnemyAI enemyAI)
{
throw new System.NotImplementedException();
}
public override bool conditionsMet(AbstractEnemyAI enemyAI)
{
target = GameManager.player == null ? transform.position : GameManager.player.transform.position;
return(canCast() && TargetInRange() && enemyAI.canSeePlayer);
}
