public void Initialize(int currentWave, EnemyMetadata config, GameObject targetGameObject)
{
targetGameOjbects = new List <GameObject>();
targetGameOjbects.Add(targetGameObject);
maxHitPoint = config.hp;
AttackDamage = config.attack;
AttackRange = config.attackRange;
//type = config.enemyType;
AttackCoolDownSeconds = 1.0f / config.attackFrequency;
MoveSpeed = config.moveSpeed;
SearchRange = config.searchRange;
lootIds = config.lootIds;
enemyState = EEnemyState.IDLE;
enemyAttackState = EEnemyAttackState.IDLE;
currentHitPoint = maxHitPoint;
attackCoolDownStartTime = 0.0f;
hpBarBehaviour = GetComponentInChildren <HpBarBehaviour>();
if (hpBarBehaviour == null)
{
Debug.LogError("Enemy missing HP bar component");
}
animator = GetComponent <Animator>();
SetStateToIdle();
// ANIMATION_IS_DEAD should only be set to false at the beginning
animator.SetBool(ANIMATION_IS_DEAD, false);
}
/**
* Called when the game resumes
*/
public override void OnGameResumed()
{
// Restores state
state = previousState;
moveComponent.enabled = true;
}
IEnumerator CallInvestigate(float _delayBeforeAction)
{
yield return(new WaitForSeconds(_delayBeforeAction));
targetChargingPoint = investigatingComponent.InvestigatedTargetHealthSetter.gameObject.transform.position;
currentState = EEnemyState.Charging;
}
void Attack()
{
m_AudioSource.clip = m_AttackSound;
m_AudioSource.Play();
m_eState = EEnemyState.eAttacking;
m_Animator.SetTrigger("Attack");
}
private void MoveTowardsTarget()
{
if (!CanMoveTowardsTarget())
{
return;
}
float step = MoveSpeed * Time.deltaTime;
Vector3 targetPos = GetCurrentMovingTargetPosition();
transform.position = Vector3.MoveTowards(transform.position, targetPos, step);
transform.LookAt(targetPos);
enemyState = EEnemyState.MOVING;
animator.SetBool(ANIMATION_IS_IDLE, false);
//temp
if (TryReachTarget())
{
currentHitPoint = 0;
Die(false);
MapManager.Instance.ReduceCurrentHP(1);
}
}
void ChangeState(EEnemyState newState)
{
if (newState == EEnemyState.OUT_OF_VIEW)
{
// nothing to do
}
else if (newState == EEnemyState.MOVE_IN_VIEW)
{
startPos = transform.position;
targetPos = transform.position + inViewOffset;
}
else if (newState == EEnemyState.IN_VIEW)
{
// calculate if we should attack or not
willAttack = Random.Range(0, 10) > chanceToAttackOutOf10;
attackCooldown = Random.Range(MinAttackWaitTime, MaxAttackWaitTime);
}
else if (newState == EEnemyState.ATTACKING)
{
// nothing to do
attackCooldown = Random.Range(MinAttackWaitTime, MaxAttackWaitTime);
}
else if (newState == EEnemyState.MOVE_OUT_VIEW)
{
startPos = transform.position;
targetPos = transform.position - inViewOffset;
}
state = newState;
}
/**
* Called when the game is paused
*/
public override void OnGamePaused()
{
previousState = state;
state = EEnemyState.EnemyPaused;
// Disables components
moveComponent.enabled = false;
}
/**
* TODO
*/
private IEnumerator WaitForMove()
{
yield return(new WaitForSeconds(delayBeforeAttack));
moveComponent.endPoint = playerBufferedPositon;
animator.SetBool("Rush", true);
Piment_Charge();
Piment_Prep_Stop();
rotation = false;
state = EEnemyState.EnableMoveComponent;
}
public Enemy(Point pos)
{
image = Game1.enemy;
position = pos;
state = (Game1.rand.Next(1, 2) / 2 == 1) ? EEnemyState.wait : EEnemyState.walk;
if (state == EEnemyState.wait)
{
nextMove = waitBetweenMoves + 2;
}
}
IEnumerator CallBite(float _delayBeforeAction)
{
yield return(new WaitForSeconds(_delayBeforeAction));
if (dmgComponent.DealDamage(myBiteDamage))
{
currentState = EEnemyState.Cooldown_B;
}
else
{
currentState = EEnemyState.Investigation;
}
}
IEnumerator CallCooldownBite(float _delayBeforeAction)
{
yield return(new WaitForSeconds(_delayBeforeAction));
if (dmgComponent.playerHealthSetter)
{
currentState = EEnemyState.Bite;
}
else
{
currentState = EEnemyState.Investigation;
}
}
/**
* Called at start
*/
void Start()
{
SpriteToHide = GetComponentsInChildren <SpriteRenderer>();
GetComponent <SpriteRenderer>().enabled = false;
foreach (SpriteRenderer sprite in SpriteToHide)
{
sprite.enabled = false;
}
StartCoroutine("HidePop");
collider = GetComponent <CircleCollider2D>();
collider.enabled = false;
StartCoroutine("SafePop");
music = GameObject.Find("MusicPlayer");
GameObject player = GameObject.FindWithTag("Player");
sphereController = player.transform.GetComponentInChildren <PlayerSphereController>();
animator = GetComponent <Animator>();
trail = GetComponent <TrailRenderer>();
if (MusicManager.WebGLBuildSupport)
{
MusicManager.PostEvent("Ennemy_Pop");
}
else
{
#if !UNITY_WEBGL
AkSoundEngine.PostEvent("Ennemy_Pop", music);
#endif
}
tomateCounter = 0;
moveComponent = GetComponent <MoveElliptic>();
PopparticleSystem = GetComponentsInChildren <ParticleSystem>()[0];
PopparticleSystem.GetComponent <Renderer>().sortingLayerName = "UI";
//PopparticleSystem.GetComponent<Renderer>(). .material.color = new Color(0.82f, 0.18f, 0.18f);
if (moveComponent != null)
{
moveComponent.enabled = false;
state = EEnemyState.WaitForMove;
StartCoroutine(WaitForMove());
}
else
{
state = EEnemyState.DoUntilDeath;
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (m_eState == EEnemyState.eSlowing)
{
return;
}
if (other.gameObject.tag == "Oil")
{
Debug.Log("OIL!!!");
AddBuff(EEnemyBuff.eSlow, 0.0f, 10.0f);
m_eState = EEnemyState.eSlowing;
Invoke("StopSlowing", 15.0f);
}
}
public override void OnEntityCollisionEnterWithArena()
{
if (handle)
{
handle.OnEnemyDeath(bufferIndex);
Debug.Log("PimentHandle");
}
state = EEnemyState.WaitForMove;
moveComponent.enabled = false;
animator.SetBool("Collision", true);
this.gameObject.GetComponent <Rigidbody2D>().constraints = RigidbodyConstraints2D.FreezeAll;
trail.enabled = false;
}
/**
* Called at start
*/
void Start()
{
sprite = this.GetComponent <SpriteRenderer>();
sprite.enabled = false;
StartCoroutine("HidePop");
collider = GetComponent <PolygonCollider2D>();
collider.enabled = false;
StartCoroutine("SafePop");
music = GameObject.Find("MusicPlayer");
if (MusicManager.WebGLBuildSupport)
{
MusicManager.PostEvent("Ennemy_Pop");
}
else
{
#if !UNITY_WEBGL
AkSoundEngine.PostEvent("Ennemy_Pop", music);
#endif
}
animator = this.GetComponent <Animator>();
trail = GetComponent <TrailRenderer>();
entityBufferedPosition = transform.position;
playerBufferedPositon = GameObject.FindGameObjectWithTag("Player").transform.position;
moveComponent = GetComponent <MoveLinear>();
moveComponent.startPoint = entityBufferedPosition;
moveComponent.endPoint = playerBufferedPositon;
moveComponent.enabled = false;
state = EEnemyState.WaitForMove;
StartCoroutine(WaitForMove());
Piment_Prep_Play();
particleSystem = GetComponentInChildren <ParticleSystem>();
particleSystem.GetComponent <Renderer>().sortingLayerName = "UI";
PopparticleSystem = GetComponentsInChildren <ParticleSystem>()[1];
PopparticleSystem.GetComponent <Renderer>().sortingLayerName = "UI";
PopparticleSystem.GetComponent <Renderer>().material.color = new Color(0.82f, 0.18f, 0.18f);
PopparticleSystem.Play();
}
IEnumerator CallCharging(float _delayBeforeAction, Vector2 _targetPoint)
{
this.transform.position = _targetPoint - offsetFromTargetPlayerPosition;
// make player charge in certain direction according to the received point
yield return(new WaitForSeconds(_delayBeforeAction));
if (dmgComponent.playerHealthSetter)
{
currentState = EEnemyState.Bite;
}
else
{
currentState = EEnemyState.Investigation;
}
}
// Update is called once per frame
void Update()
{
if (!m_bActivate)
{
return;
}
ResetBuff();
m_Animator.SetFloat("Speed", m_oMoveRB2D.velocity.magnitude);
if (m_eState == EEnemyState.eAttacking)
{
AttackDetect();
}
if (m_eState == EEnemyState.eAttacking || m_eState == EEnemyState.eDie || m_eState == EEnemyState.eReadyToAttack)
{
return;
}
Vector2 dir = (transform.position - m_oPlayer.transform.position).normalized;
Vector2 moveVelocity = Vector2.zero;
if (Vector2.Distance(transform.position, m_oPlayer.transform.position) > m_fStopDistance)
{
moveVelocity = new Vector2(Vector2.Dot(transform.right, dir), Vector2.Dot(transform.up, dir)) * -1;
CancelInvoke();
}
else
{
m_eState = EEnemyState.eReadyToAttack;
Invoke("Attack", m_fAttackDelay);
}
m_oMoveRB2D.AddForce(Vector2.SmoothDamp(m_Velocity, moveVelocity, ref m_CurrentVelocity, m_fSmoothValue, m_fSpeed) * m_fMoveForce);
if (m_oMoveRB2D.velocity.x != 0)
{
if (m_oMoveRB2D.velocity.x < 0.0f)
{
m_SpriteRenderer.flipX = true;
}
else
{
m_SpriteRenderer.flipX = false;
}
}
}
public void setState(EEnemyState state, object param1 = null)
{
if (currentState == state)
{
return;
}
switch (state)
{
case EEnemyState.Idle: StartCoroutine("idle"); break;
case EEnemyState.Attack: StartCoroutine("attack"); break;
case EEnemyState.Move: StartCoroutine("move"); break;
}
currentState = state;
}
private bool TryAttackBuilding()
{
if (!CanAttckCurrentTarget())
{
animator.SetBool(ANIMATION_IS_IDLE, true);
return(false);
}
attackingTarget.TakeDamage(AttackDamage);
attackCoolDownStartTime = Time.time;
animator.SetBool(ANIMATION_IS_ATTACKING, true);
enemyAttackState = EEnemyAttackState.COOLING_DOWN;
enemyState = EEnemyState.ATTACKING;
transform.LookAt(attackingTarget.transform);
return(true);
}
public void ChangeState(EEnemyState newState)
{
if (_state == EEnemyState.STATE_DYING)
{
return;
}
switch (newState)
{
case EEnemyState.STATE_IDLE:
sprite.Play("default");
sprite.SpeedScale = rng.Next(75, 100) / 100f * 0.5f;
break;
case EEnemyState.STATE_MOVING:
sprite.Play("default");
if (_state == EEnemyState.STATE_ALERTED)
{
sprite.SpeedScale = rng.Next(75, 100) / 100f * 0.5f;
}
break;
case EEnemyState.STATE_STUNNED:
sprite.Play("default");
break;
case EEnemyState.STATE_ALERTED:
sprite.Play("default");
sprite.SpeedScale = 2;
break;
case EEnemyState.STATE_DYING:
sprite.Stop();
break;
default:
sprite.Play("default");
break;
}
_state = newState;
}
void ExecuteState(EEnemyState _enemyState)
{
switch (_enemyState)
{
case EEnemyState.NONE:
break;
case EEnemyState.Idle:
//myAnimator.SetTrigger(ANIMATION_IDLE);
break;
case EEnemyState.Investigation:
//myAnimator.SetTrigger(ANIMATION_INVESTIGATE);
StartCoroutine(CallInvestigate(investigationTimeLength));
break;
case EEnemyState.Charging:
//myAnimator.SetTrigger(ANIMATION_CHARGE);
StartCoroutine(CallCharging(constantChargingTime, targetChargingPoint));
break;
case EEnemyState.Bite:
//myAnimator.SetTrigger(ANIMATION_BITE);
StartCoroutine(CallBite(biteTimeLength));
break;
case EEnemyState.Cooldown_B:
//myAnimator.SetTrigger(ANIMATION_COOLDOWN_BITE);
StartCoroutine(CallCooldownBite(cooldownBiteTimeLength));
break;
case EEnemyState.MAX:
break;
default:
break;
}
}
public void Restart()
{
State = EEnemyState.Hide;
ShareTimer = 0;
gameObject.SetActive(true);
}
//===============================================
// Animator Funtions
private void setAnimState(EEnemyState NewState)
{
state.State = NewState;
animator.SetInteger("State", (int)state.State);
}
private void SetStateToIdle()
{
enemyState = EEnemyState.IDLE;
enemyAttackState = EEnemyAttackState.IDLE;
SetIdelAnimationState();
}
void Update () {
if(SceneManager.Instance.SceneComp_Battle.BattleState != EBattleState.BattleOn)
gameObject.SetActive(false);
ShareTimer += Time.deltaTime;
if(State == EEnemyState.Hide)
{
if(ShareTimer > HIDE_TIME)
{
int id = Random.Range(0, SceneManager.Instance.CurSceneComp.BuildingCompList.Count - 1);
BuildingComp buildingComp = SceneManager.Instance.CurSceneComp.BuildingCompList[id];
if(buildingComp)
{
transform.position = buildingComp.transform.position + Vector3.up * 1;
State = EEnemyState.HideToShow;
ShareTimer = 0;
CurSlot = buildingComp.Data.SlotID;
//animation["HideToShow"].normalizedSpeed = TO_SHOW_TIME;
//animation.Play("HideToShow");
}
}
}
else if(State == EEnemyState.HideToShow)
{
if(ShareTimer > TO_SHOW_TIME)
{
State = EEnemyState.Show;
ShareTimer = 0;
GameObject prefab = Resources.Load<GameObject>("Effects/fireBallBase");
GameObject effect = Instantiate(prefab) as GameObject;
effect.AddComponent<MoveToCamera>();
effect.transform.parent = SceneManager.Instance.EffectRootComp.transform;
effect.transform.position = transform.position;
}
else
{
renderer.material.color = new Color(1,1,1, ShareTimer / TO_SHOW_TIME);
}
}
else if(State == EEnemyState.Show)
{
if(ShareTimer > SHOW_TIME)
{
State = EEnemyState.ShowToHide;
ShareTimer = 0;
//animation["HideToShow"].normalizedSpeed = TO_HIDE_TIME;
//animation.Play("ShowToHide");
}
}
else if(State == EEnemyState.ShowToHide)
{
if(ShareTimer > TO_HIDE_TIME)
{
State = EEnemyState.Hide;
ShareTimer = 0;
}
else
{
renderer.material.color = new Color(1,1,1, 1-ShareTimer / TO_SHOW_TIME);
}
}
}
// Update is called once per frame
void Update () {
if(!GameManager.Instance.IsFighting)
gameObject.SetActive(false);
ShareTimer += Time.deltaTime;
if(State == EEnemyState.Hide)
{
if(ShareTimer > HIDE_TIME)
{
int id = Random.Range(0, GameManager.Instance.VillageComp.BuildingGroupComp.BuildingCompList.Count - 1);
BuildingComp buildingComp = GameManager.Instance.VillageComp.BuildingGroupComp.BuildingCompList[id];
if(buildingComp)
{
transform.position = buildingComp.transform.position + Vector3.up * 2;
State = EEnemyState.HideToShow;
ShareTimer = 0;
CurSlot = buildingComp.Data.SlotID;
//animation["HideToShow"].normalizedSpeed = TO_SHOW_TIME;
//animation.Play("HideToShow");
}
}
}
else if(State == EEnemyState.HideToShow)
{
if(ShareTimer > TO_SHOW_TIME)
{
State = EEnemyState.Show;
ShareTimer = 0;
}
else
{
renderer.material.color = new Color(1,1,1, ShareTimer / TO_SHOW_TIME);
}
}
else if(State == EEnemyState.Show)
{
if(ShareTimer > SHOW_TIME)
{
State = EEnemyState.ShowToHide;
ShareTimer = 0;
//animation["HideToShow"].normalizedSpeed = TO_HIDE_TIME;
//animation.Play("ShowToHide");
}
}
else if(State == EEnemyState.ShowToHide)
{
if(ShareTimer > TO_HIDE_TIME)
{
State = EEnemyState.Hide;
ShareTimer = 0;
}
else
{
renderer.material.color = new Color(1,1,1, 1-ShareTimer / TO_SHOW_TIME);
}
}
}
void StopSlowing()
{
m_eState = EEnemyState.eNormal;
}
/**
* TODO
*/
private IEnumerator WaitForMove()
{
yield return(new WaitForSeconds(delayBeforeAttack));
state = EEnemyState.EnableMoveComponent;
}
public override void Update(GameTime time)
{
List <Player> players;
switch (state)
{
case EEnemyState.walk:
if ((float)time.TotalGameTime.TotalSeconds >= nextMove)
{
players = Map.instance.CheckPlayer(position);
if (players.Count > 0)
{
target = Map.instance.CheckPlayer(position)[0];
}
else
{
target = null;
}
if (target != null)
{
state = EEnemyState.attack;
return;
}
Move();
movesCount--;
if (movesCount <= 0)
{
state = EEnemyState.wait;
nextWalk = (float)time.TotalGameTime.TotalSeconds + waitBetweenWalks;
movesCount = Game1.rand.Next(4, 9);
}
nextMove = (float)time.TotalGameTime.TotalSeconds + waitBetweenMoves;
players = Map.instance.CheckPlayer(position);
if (players.Count > 0)
{
target = Map.instance.CheckPlayer(position)[0];
}
else
{
target = null;
}
if (target != null)
{
state = EEnemyState.attack;
}
}
break;
case EEnemyState.wait:
if ((float)time.TotalGameTime.TotalSeconds >= nextWalk)
{
state = EEnemyState.walk;
}
break;
case EEnemyState.attack:
players = Map.instance.CheckPlayer(position);
if (players.Count > 0)
{
target = Map.instance.CheckPlayer(position)[0];
}
else
{
target = null;
}
if (target == null)
{
state = EEnemyState.walk;
}
if ((float)time.TotalGameTime.TotalSeconds >= nextAttack)
{
if (target != null)
{
target.TakeDamage();
nextAttack = (float)time.TotalGameTime.TotalSeconds + waitBetweenAttack;
}
}
break;
default:
break;
}
}
public void Restart()
{
State = EEnemyState.Hide;
ShareTimer = 0;
gameObject.SetActive(true);
}
// Update is called once per frame
void Update()
{
if (!GameManager.Instance.IsFighting)
{
gameObject.SetActive(false);
}
ShareTimer += Time.deltaTime;
if (State == EEnemyState.Hide)
{
if (ShareTimer > HIDE_TIME)
{
int id = Random.Range(0, GameManager.Instance.VillageComp.BuildingGroupComp.BuildingCompList.Count - 1);
BuildingComp buildingComp = GameManager.Instance.VillageComp.BuildingGroupComp.BuildingCompList[id];
if (buildingComp)
{
transform.position = buildingComp.transform.position + Vector3.up * 2;
State = EEnemyState.HideToShow;
ShareTimer = 0;
CurSlot = buildingComp.Data.SlotID;
//animation["HideToShow"].normalizedSpeed = TO_SHOW_TIME;
//animation.Play("HideToShow");
}
}
}
else if (State == EEnemyState.HideToShow)
{
if (ShareTimer > TO_SHOW_TIME)
{
State = EEnemyState.Show;
ShareTimer = 0;
}
else
{
renderer.material.color = new Color(1, 1, 1, ShareTimer / TO_SHOW_TIME);
}
}
else if (State == EEnemyState.Show)
{
if (ShareTimer > SHOW_TIME)
{
State = EEnemyState.ShowToHide;
ShareTimer = 0;
//animation["HideToShow"].normalizedSpeed = TO_HIDE_TIME;
//animation.Play("ShowToHide");
}
}
else if (State == EEnemyState.ShowToHide)
{
if (ShareTimer > TO_HIDE_TIME)
{
State = EEnemyState.Hide;
ShareTimer = 0;
}
else
{
renderer.material.color = new Color(1, 1, 1, 1 - ShareTimer / TO_SHOW_TIME);
}
}
}
void ChangeEnemyState(EEnemyState enemyState)
{
this.enemyState = enemyState;
}
/**
* TODO
*/
private void EnableMoveComponent()
{
moveComponent.enabled = true;
state = EEnemyState.DoUntilDeath;
}
