void Update()
{
if (dragonController != null)
{
if (dragonController.gameObject.activeSelf)
{
if (dragonController.StateAction == EDragonStateAction.MOVE)
{
for (int i = 0; i < listBabyDragon.Count; i++)
{
BabyDragonController babyDragonController = listBabyDragon[i].GetComponent <BabyDragonController>();
if (babyDragonController.StateAction != EDragonStateAction.MOVE)
{
try
{
Vector3 handleException = dragonController.stateMove.listPosition[PlayConfig.BabyDragonIndexForListStart
- PlayConfig.BabyDragonIndexForListDistance * babyDragonController.index]; // for test exception
babyDragonController.stateAttack.target = null;
babyDragonController.StateAction = EDragonStateAction.MOVE;
}
catch
{
}
}
}
}
}
}
}
public void attackDragonBaby()
{
if (target == null)
{
return;
}
BabyDragonController babyController = target.GetComponent <BabyDragonController>();
if (babyController != null)
{
int dmg = PlayManager.Instance.pushDamagePhysics(controller.attribute.ATK.Min,
controller.attribute.ATK.Max,
babyController.attribute.DEF);
babyController.attribute.HP.Current -= dmg;
if (babyController.attribute.HP.Current < 0)
{
babyController.attribute.HP.Current = 0;
}
float valueTo = babyController.attribute.HP.Current / (float)babyController.attribute.HP.Max;
babyController.updateTextHP();
EffectSupportor.Instance.runSliderValue(babyController.sliderHP, valueTo, EffectSupportor.TimeValueRunHP);
}
}
void attackBabyDragon(BabyDragonController babyDragon)
{
babyDragon.babyAttack.listEnemy.Add(this.transform.parent.gameObject);
babyDragon.babyAttack.chooseEnemyToAttack();
attack(babyDragon.gameObject);
}
void attackBabyDragon(BabyDragonController babyDragon)
{
babyDragon.babyAttack.listEnemy.Add(this.transform.parent.gameObject);
babyDragon.babyAttack.chooseEnemyToAttack();
attack(babyDragon.gameObject);
}
void OnTriggerEnter(Collider other)
{
if (other.tag == TagHashIDs.ColliderForEnemyATK)
{
if (controller.attribute.HP.Current <= 0)
{
return;
}
if (other.transform.parent.GetComponent <DragonController>() != null)
{
DragonController dragonController = other.transform.parent.GetComponent <DragonController>();
if (dragonController.StateOffense == EDragonStateOffense.NONE &&
dragonController.attribute.HP.Current > 0 &&
!dragonController.dragonAttack.listEnemy.Contains(this.transform.parent.gameObject) &&
!listDragon.Contains(other.transform.parent.gameObject))
{
//attackPlayerDragon(dragonController);
listDragon.Add(other.transform.parent.gameObject);
}
if (controller.StateAction == EEnemyStateAction.MOVE && controller.stateAttack.target == null &&
dragonController.StateAction != EDragonStateAction.ATTACK &&
dragonController.StateAction != EDragonStateAction.MOVE)
{
chooseDragonToAttack();
}
}
else
{
BabyDragonController babyController = other.transform.parent.GetComponent <BabyDragonController>();
if (babyController.attribute.HP.Current > 0 &&
!babyController.babyAttack.listEnemy.Contains(this.transform.parent.gameObject) &&
!listDragon.Contains(other.transform.parent.gameObject))
{
//attackPlayerDragon(dragonController);
listDragon.Add(other.transform.parent.gameObject);
}
if (controller.StateAction == EEnemyStateAction.MOVE && controller.stateAttack.target == null &&
babyController.StateAction != EDragonStateAction.ATTACK &&
babyController.StateAction != EDragonStateAction.MOVE)
{
chooseDragonToAttack();
}
}
}
}
public void chooseDragonToAttack()
{
if (controller.stateAttack.target == null && listDragon.Count > 0)
{
bool hasTarget = false;
for (int i = 0; i < listDragon.Count; i++)
{
if (listDragon[i] == null)
{
break;
}
if (listDragon[i].activeSelf)
{
if (listDragon[i].GetComponent <DragonController>() != null)
{
DragonController dragon = listDragon[i].GetComponent <DragonController>();
if (dragon.StateAction == EDragonStateAction.IDLE)
{
attackPlayerDragon(dragon);
break;
}
}
else
{
BabyDragonController baby = listDragon[i].GetComponent <BabyDragonController>();
if (baby.StateAction == EDragonStateAction.IDLE)
{
attackBabyDragon(baby);
break;
}
}
}
}
if (hasTarget)
{
controller.stateAttack.target = null;
controller.stateMove.State = EEnemyMovement.MOVE_ON_PATHS;
controller.StateAction = EEnemyStateAction.MOVE;
}
}
else
{
controller.stateAttack.target = null;
controller.stateMove.State = EEnemyMovement.MOVE_ON_PATHS;
controller.StateAction = EEnemyStateAction.MOVE;
}
}
void Start()
{
controller = transform.parent.GetComponent<BabyDragonController>();
listEnemy = new System.Collections.Generic.List<GameObject>();
}
void OnEnable()
{
animationFrames = GetComponent<AnimationFrames>();
controller = transform.parent.GetComponent<BabyDragonController>();
}
public override void Execute(EnemyController obj)
{
if (!obj.isEnable)
{
return;
}
if (target == null)
{
controller.stateMove.State = EEnemyMovement.MOVE_ON_PATHS;
controller.StateAction = EEnemyStateAction.MOVE;
return;
}
else
{
if (target.GetComponent <DragonController>() != null)
{
DragonController dragonController = target.GetComponent <DragonController>();
if (dragonController.attribute.HP.Current <= 0)
{
dragonController.StateAction = EDragonStateAction.DIE;
dragonController.StateOffense = EDragonStateOffense.NONE;
controller.StateAction = EEnemyStateAction.MOVE;
target = null;
return;
}
}
else
{
BabyDragonController babyController = target.GetComponent <BabyDragonController>();
if (babyController.attribute.HP.Current <= 0)
{
babyController.StateAction = EDragonStateAction.DIE;
controller.enemyAttack.listDragon.Remove(target);
target = null;
controller.enemyAttack.chooseDragonToAttack();
return;
}
}
}
if (target.transform.position.x >= controller.transform.position.x && direction == EDragonStateDirection.LEFT)
{
direction = EDragonStateDirection.RIGHT;
if (preDirection != direction)
{
setDirection();
}
}
else if (target.transform.position.x < controller.transform.position.x && direction == EDragonStateDirection.RIGHT)
{
direction = EDragonStateDirection.LEFT;
if (preDirection != direction)
{
setDirection();
}
}
if (preTargetPosition != target.transform.position)
{
if (target.transform.position.x < controller.transform.position.x)
{
controller.stateMove.Direction = EDragonStateDirection.RIGHT;
}
else
{
controller.stateMove.Direction = EDragonStateDirection.LEFT;
}
controller.stateMove.State = EEnemyMovement.MOVE_TO_DRAGON;
controller.StateAction = EEnemyStateAction.MOVE;
}
}
void Start()
{
controller = transform.parent.GetComponent <BabyDragonController>();
listEnemy = new System.Collections.Generic.List <GameObject>();
}
void OnEnable()
{
animationFrames = GetComponent <AnimationFrames>();
controller = transform.parent.GetComponent <BabyDragonController>();
}
void initBabyDragon()
{
GameObject babyDragon = Instantiate(Resources.Load <GameObject>("Prefab/Dragon/Baby/Baby Dragon")) as GameObject;
babyDragon.transform.parent = PlayManager.Instance.Temp.Dragon.transform;
BabyDragonController babyController = babyDragon.GetComponent <BabyDragonController>();
babyController.index = countBaby;
#region Scale base on parent scale
babyDragon.transform.localScale = new Vector3(0.5f, 0.5f, 1);
BoxCollider boxCollider = babyDragon.GetComponent <BoxCollider>();
boxCollider.size = new Vector2(boxCollider.size.x / 2, boxCollider.size.y / 2);
//foreach (Transform child in babyDragon.transform)
//{
// if(child.name.Equals("Collider For Enemy ATK"))
// {
// SphereCollider collider = child.GetComponent<SphereCollider>();
// collider.radius = collider.radius * 0.5f;
// }
// if(child.name.Equals("ATK Range"))
// {
// SphereCollider collider = child.GetComponent<SphereCollider>();
// collider.radius = collider.radius * 0.5f;
// }
//}
#endregion
if (dragonController.StateDirection == EDragonStateDirection.LEFT)
{
babyDragon.transform.position = new Vector3(PlayerDragon.transform.position.x + 0.25f, PlayerDragon.transform.position.y,
PlayerDragon.transform.position.z);
babyController.StateDirection = EDragonStateDirection.LEFT;
}
else
{
babyDragon.transform.position = new Vector3(PlayerDragon.transform.position.x - 0.25f, PlayerDragon.transform.position.y,
PlayerDragon.transform.position.z);
babyController.StateDirection = EDragonStateDirection.RIGHT;
}
if (babyController.StateDirection == EDragonStateDirection.LEFT)
{
Vector3 scale = babyDragon.transform.GetChild(0).localScale;
babyDragon.transform.GetChild(0).localScale = new Vector3(-1 * scale.x, scale.y, scale.z);
}
else
{
Vector3 scale = babyDragon.transform.GetChild(0).localScale;
babyDragon.transform.GetChild(0).localScale = new Vector3(Mathf.Abs(scale.x), scale.y, scale.z);
}
//Stretch HP
babyDragon.transform.GetChild(1).GetComponent <UIStretch>().container = GameObject.FindWithTag("Root");
babyController.dragonParent = dragonController;
listBabyDragon.Add(babyDragon);
countBaby = listBabyDragon.Count;
}
