/* This is the AI Brain, it knows its state and its behaviour tree and chooses an action depending on it */
//private readonly Subject<CharacterAction> onActionSelectedObservable = new Subject<CharacterAction>();
//public IObservable<CharacterAction> OnActionSelectedObservable { get { return onActionSelectedObservable; } }
public AIActionSelector(EnemyActor actor)
{
this.actor = actor;
this.state = AIState.Default;
this.patrouille = actor.GetComponent <PatrouilleBehaviour>();
}
private EnemyActor Create(ActorSpawnSettings spawn)
{
// get random direction,
float angle = Random.Range(0.0f, Mathf.PI * 2);
Vector3 dir = new Vector3(Mathf.Sin(angle), 0.0f, Mathf.Cos(angle));
// If its a flying enemy get random y direction aswell,
if (spawn.aiValues.MovementType == MovementType.Air)
{
dir.y = Random.Range(0.5f, 1);
dir.Normalize();
}
// multiply by the random distance
Vector3 pos = dir * spawn.Distance;
pos.x = Mathf.Clamp(pos.x, -_arenaDimensions.x, _arenaDimensions.x);
pos.z = Mathf.Clamp(pos.z, -_arenaDimensions.z, _arenaDimensions.z);
pos.y = Mathf.Clamp(pos.y, 0, _arenaDimensions.y);
// Instantiate
EnemyActor newEnemy = Instantiate(spawn.Prefab, pos, Quaternion.identity);
AIEntity ai = newEnemy.gameObject.AddComponent <AIEntity>();
spawn.aiValues.Init(_playerTransform);
ai.Actor = spawn;
return(newEnemy);
}
public void SetBase(EnemyBase enemyBase, RarityType rarity, int level, EnemyActor actor)
{
BaseEnemyData = enemyBase;
Name = enemyBase.idName;
Level = level;
CurrentActor = actor;
OnHitData.SourceActor = actor;
BaseHealth = (float)(Helpers.GetEnemyHealthScaling(level) * enemyBase.healthScaling);
MaximumHealth = (int)BaseHealth;
CurrentHealth = MaximumHealth;
movementSpeed = enemyBase.movementSpeed;
minAttackDamage = (int)(enemyBase.attackDamageMinMultiplier * Helpers.GetEnemyDamageScaling(level));
maxAttackDamage = (int)(enemyBase.attackDamageMaxMultiplier * Helpers.GetEnemyDamageScaling(level));
foreach (ElementType element in Enum.GetValues(typeof(ElementType)))
{
ElementData[element] = enemyBase.resistances[(int)element];
}
CurrentShieldDelay = 0f;
foreach (AbilityScalingBonusProperty bonusProp in enemyBase.leveledBonusProperties)
{
AddStatBonus(bonusProp.bonusType, bonusProp.restriction, bonusProp.modifyType, bonusProp.initialValue + bonusProp.growthValue * level);
}
}
void Start()
{
if (_actor == null)
{
_actor = GetComponentInParent <EnemyActor>();
}
}
public AttackPrepareAction(EnemyActor owner, GameObject target, float waitTime)
{
this.owner = owner;
this.targetPosition = target.transform.position;
this.target = target;
time = 0f;
this.waitTime = waitTime;
owner.animator.SetTrigger("Attack");
isOver = false;
}
public MeleeAttackAction(EnemyActor owner, Vector3 targetPosition, float speed, float targetTime)
{
owner.animator.SetTrigger("Attack");
this.owner = owner;
this.speed = speed;
time = 0f;
this.targetTime = targetTime;
isOver = false;
attackDir = (Vector2)(targetPosition - owner.transform.position).normalized;
}
//TODO private bool listen = false; // listens to player steps
void Awake()
{
mesh = new Mesh();
mesh.MarkDynamic();
enemyActor = GetComponent <EnemyActor>();
movementController = GetComponent <MovementController>();
movementController.OnTileEnterAsObservable.Subscribe(RecalculateVisibleArea);
}
void Awake()
{
// Setting up the references.
player = GameObject.FindGameObjectWithTag("Player");
playerHealth = player.GetComponent <PlayerHealth>();
playerActor = player.GetComponent <PlayerActor>();
enemy = this.gameObject;
enemyActor = enemy.GetComponent <EnemyActor>();
//enemyHealth = GetComponent<EnemyHealth>();
//anim = GetComponent <Animator> ();
musicControl = player.GetComponent <CombatMusicControl>();
}
public BackstepAction(EnemyActor owner, Vector2 direction, float speed)
{
this.owner = owner;
this.direction = direction;
this.speed = speed;
isOver = false;
if (owner.heighter.velocity == 0)
{
owner.heighter.SetVelocity(speed);
}
}
public void AddNewEnemyActor(EnemyActor enemy)
{
if (_enemies.Contains(enemy))
{
return;
}
if (_debugObject)
{
Debug.Log("New Enemy Added: " + enemy.name);
}
_enemies.Add(enemy);
}
public void RemoveEnemyActor(EnemyActor enemy)
{
if (!_enemies.Contains(enemy))
{
return;
}
_enemies.Remove(enemy);
if (_debugObject)
{
Debug.Log("Enemy Removed: " + enemy.name + "\n New Count: " + ActiveEnemiesCount);
}
}
public EnemyActor ClosesTo(Vector3 position, float minimum = 0f)
{
EnemyActor closest = null;
float min = minimum == 0f ? float.PositiveInfinity : minimum;
for (int i = 0; i < _enemies.Count; i++)
{
float d = Vector3.Distance(position, _enemies[i].transform.position);
if (d < min)
{
min = d;
closest = _enemies[i];
}
}
return(closest);
}
private void CreateEnemyActor(float distance, float angle, Vector3 lookAtTarget, float lifetime, float speed)
{
EnemyActor actor = Instantiate <EnemyActor>(EnemyActorPrefab);
if (actor != null)
{
actor.transform.localPosition = new Vector3(
distance * Mathf.Cos(angle * Mathf.PI / 180.0f),
0,
distance * Mathf.Sin(angle * Mathf.PI / 180.0f));
//actor.transform.localEulerAngles = angle;
//actor.transform.rotation = Quaternion.EulerAngles(0, -angle, 0);
actor.transform.LookAt(lookAtTarget);
actor.Lifetime = lifetime;
actor.Speed = speed;
}
}
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
hero = animator.GetComponent <HeroActor> ();
hero.body.velocity = Vector2.zero;
hero.attackCollider.GetComponent <HeroAttackColliderBehavior>().SetAttackCollider(false);
frame = 0;
GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");
foreach (GameObject enemyObject in enemies)
{
if ((enemyObject.transform.position - hero.transform.position).sqrMagnitude <= Mathf.Pow(0.44f, 2))
{
EnemyActor enemy = enemyObject.GetComponent <EnemyActor>();
enemy.stateManager.EventAttack(hero.gameObject);
}
}
}
private void SpawnEnemy(EnemyWaveItem enemyWaveItem, Dictionary <BonusType, StatBonus> bonuses, RarityType rarity)
{
EnemyBase enemyBase = ResourceManager.Instance.GetEnemyBase(enemyWaveItem.enemyName);
Spawner spawner = SpawnerList[enemyWaveItem.spawnerIndex];
EnemyActor enemy = EnemyPool.GetEnemy(spawner.transform);
enemy.ParentSpawner = spawner;
Vector3 positionOffset = new Vector3(Random.Range(-0.4f, 0.4f), Random.Range(-0.4f, 0.4f), 0);
//Vector3 positionOffset = new Vector3(-0.5f, -0.5f, 0);
enemy.positionOffset = positionOffset;
enemy.rotatedOffset = positionOffset;
if (enemyBase.isBoss || enemyWaveItem.isBossOverride)
{
enemy.isBoss = true;
}
else
{
enemy.isBoss = false;
}
Sprite enemySprite = ResourceManager.Instance.GetEnemySprite(enemyBase.idName);
if (enemySprite != null)
{
enemy.GetComponent <SpriteRenderer>().sprite = enemySprite;
}
else
{
Debug.Log("Could not find sprite: " + enemyBase.idName);
}
enemy.SetBase(enemyBase, rarity, stageInfo.monsterLevel + survivalLoopCount);
//Set bonuses from wave
enemy.Data.SetMobBonuses(bonuses);
enemy.Init(enemyWaveItem.goalIndex);
currentEnemyList.Add(enemy);
enemiesSpawned++;
}
private void OnSceneGUI()
{
#if UNITY_EDITOR
selectedCheckerInfo = target as EnemyBodyShootWithCrouchChecker;
if (null == selectedCheckerInfo)
{
return;
}
if (null == selectedCheckerInfo.actor)
{
selectedCheckerInfo.actor = selectedCheckerInfo.GetComponentInParent <Actor>();
selectedCheckerInfo.eActor = EnemyActor.GetEnemyActor <Actor> (selectedCheckerInfo.actor);
}
EnemyViewRenderer.DrawRecognizableRect(selectedCheckerInfo.eActor.GetEnemyOutsideInfo());
EnemyViewRenderer.DrawViewableRect(selectedCheckerInfo.eActor.GetEnemyOutsideInfo());
DrawShootableRect(selectedCheckerInfo);
#endif
}
public void Spawn(float power)
{
if (_spawns.Length <= 0)
{
return;
}
// 1 + power = increased stats
List <ActorSpawnSettings> possible = new List <ActorSpawnSettings>();
bool shouldRollIfSameType = Random.value <= _sameTypeRerollChance;
for (int i = 0; i < _spawns.Length; i++)
{
if (_spawns[i].PowerLevelGate <= power + 1)
{
possible.Add(_spawns[i]);
}
}
ActorSpawnSettings newSpawn = possible[Random.Range(0, possible.Count)];
// if (_lastSpawned != null &&
// newSpawn.Type == _lastSpawned.Type && newSpawn.Attack == _lastSpawned.Attack)
// {
// if (Random.value < _sameTypeRerollChance)
// {
// ActorSpawnSettings first = newSpawn;
// while(newSpawn == first)
// newSpawn = _spawns[Random.Range(0, _spawns.Length)];
// }
// }
EnemyActor spawned = Create(newSpawn);
spawned.SetPower(power);
_lastSpawned = newSpawn;
}
private void OnMouseDownHandler()
{
LayerMask mask = LayerMask.GetMask("Hero", "Enemy");
Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction, 50, mask);
if (EventSystem.current.IsPointerOverGameObject(pointerId))
{
return;
}
if (hit.collider != null)
{
if (hit.collider.gameObject.layer == 13)
{
HeroActor hero = hit.collider.gameObject.GetComponent <HeroActor>();
if (hero != null)
{
OnTargetSelect(hero);
}
}
else if (hit.collider.gameObject.layer == 12)
{
EnemyActor enemy = hit.collider.gameObject.GetComponent <EnemyActor>();
if (enemy != null)
{
OnTargetSelect(enemy);
}
}
//return;
}
else
{
OnTargetSelect(null);
}
if (!EventSystem.current.IsPointerOverGameObject(pointerId))
{
isDragging = true;
}
}
public void SpawnBoss(float power)
{
if (_bosses == null || _bosses.Length == 0)
{
return;
}
EnemyActor spawned = Create(_bosses[_nextBossIndex]);
spawned.SetPower(power);
if (_bossHealthReference != null && _bossMaxHealthReference != null)
{
spawned.SetHealthReference(_bossHealthReference, _bossMaxHealthReference);
bossSpawnEvent?.Invoke();
}
if (_nextBossIndex + 1 < _bosses.Length)
{
_nextBossIndex++;
}
}
/// <summary>
/// If collided with player, all enemies.Agro = true.
/// If collided with enemy, added to m_actors
/// </summary>
/// <param name="other">
/// A Collider. The Collider that has entered the room
/// </param>
private void OnTriggerEnter(Collider other)
{
// check if player
Robbo robbo = other.GetComponent <Robbo>();
if (robbo)
{
foreach (EnemyActor e in m_actors)
{
e.Agro = true;
}
return;
}
// check if enemy
EnemyActor enemy = other.GetComponent <EnemyActor>();
if (enemy && !m_actors.Exists(e => e == enemy))
{
enemy.Room = this;
m_actors.Add(enemy);
}
}
private void OnCollisionEnter(Collision Collision)
{
string tag = Collision.gameObject.tag;
if (Collision.gameObject.layer == 11 || Collision.gameObject.GetComponent <EnemyActor>())
{
EnemyActor enemy = Collision.gameObject.GetComponent <EnemyActor>();
enemy.TakeDamage(m_damage);
Debug.Log("attacked enemy");
GameObject temp = Instantiate(m_blood, enemy.transform.position, Quaternion.identity);
Destroy(temp, 1);
Debug.Log(Collision.gameObject.name);
GetComponent <Rigidbody>().Sleep();
GetComponent <Rigidbody>().collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
GetComponent <Rigidbody>().isKinematic = true;
activated = false;
}
else
{
Debug.Log("attck failed");
}
}
public void CreateEnemy(string _name)
{
EnemyActor _actor = (EnemyActor)Resources.Load(pathHeadOfPrefabs + _name);
}
public WalkAction(EnemyActor owner, TargetType type)
{
this.owner = owner;
this.type = type;
}
public override void Actioned(EnemyActor actor, Action action)
{
}
void Awake()
{
owner = transform.root.GetComponent <EnemyActor>();
}
public abstract void Actioned(EnemyActor actor, Action action);
public EnemyStateManager(EnemyActor owner)
{
this.owner = owner;
}
void Start() {
if (_actor == null) { _actor = GetComponentInParent<EnemyActor>(); }
}
public BirdSwordManStateManager(EnemyActor owner) : base(owner)
{
currentAction = new WaitAction();
}
