public static IEnumerator MeleeAttackCoroutineAndInvokeAction(EnemyUnitController self)
{
self.SM.InitilizeAttackCoroutine(meleeAttackCoroutineAndInvokeAction(self));
yield return(self.SM.StartCoroutine(self.SM.AttackCoroutine));
yield break;
}
public static Vector2 FindPositionNextToUnit(PlayerUnitController pc, EnemyUnitController ec)
{
Vector2 TargetSpriteExtent = ec.SR.sprite.bounds.extents;
Vector2 SelfSpriteExtent = pc.SR.sprite.bounds.extents;
SelfSpriteExtent.x *= pc.transform.localScale.x;
SelfSpriteExtent.y *= pc.transform.localScale.y;
TargetSpriteExtent.x *= ec.transform.localScale.x;
TargetSpriteExtent.y *= ec.transform.localScale.y;
Vector2 TargetGOPos = ec.transform.position;
Vector2 SelfPos = pc.transform.position;
string LoR = (FindIfTargetIsLeftOrRightOfSelf(pc, ec));
Vector2 pos = SelfPos;
if (LoR == "left")
{
pos.x = (TargetGOPos.x - TargetSpriteExtent.x - 0.1f - SelfSpriteExtent.x);
pos.y = (TargetGOPos.y - TargetSpriteExtent.y + SelfSpriteExtent.y);
}
else if (LoR == "right")
{
pos.x = (TargetGOPos.x + TargetSpriteExtent.x + 0.1f + SelfSpriteExtent.x);
pos.y = (TargetGOPos.y - TargetSpriteExtent.y + SelfSpriteExtent.y);
}
else
{
Debug.Log("Couldn't find if object is left or right.. Default to self transform.position...");
pos = pc.transform.position;
}
return(pos);
}
public static bool StandardIsTargetable(EnemyUnitController ec)
{
if (ec.CurrentStateLegacy != ec.States.Death)
{
return(true);
}
return(false);
}
public static bool StandardEnterDirectBattleCondition(ObjectStateLegacy us, EnemyUnitController ec, NormalUnitStates states)
{
if (us == states.Default || us == states.PostBattle)
{
return(true);
}
return(false);
}
public override void OnTargetEnteredRange(EnemyUnitController ec)
{
if (CanEnterNewBattle())
{
dataLegacy.EnemyTarget = ec;
dataLegacy.EffectableTarget = GameObjectPool.Instance.ActiveEffectables.Pool[ec.name];
SM.SetState(States.PreBattle);
}
}
public static void StandardOnTargetDeathCheck(WeaponController self)
{
EnemyUnitController ec = self.EnemyTargetBank.FindSingleTargetNearestToEndOfSpline();
if (ec != null)
{
self.Data.EnemyTarget = ec;
self.OnAttackInitiate();
}
}
public void SetEnemyTargetToNull(string unitName, string callerName)
{
if (EnemyTarget != null)
{
if (EnemyTarget.name == unitName)
{
EnemyTarget = null;
}
}
}
public static string FindIfTargetIsLeftOrRightOfSelf(PlayerUnitController pc, EnemyUnitController ec)
{
if (pc.transform.position.x < ec.transform.position.x)
{
return("left");
}
else
{
return("right");
}
}
public void RemoveFromTargetsString(String name, string callerName)
{
clearNullsFromList();
try {
targets.Remove(name);
CurrentLowestProximityTarget = FindSingleTargetNearestToEndOfSpline();
}
catch (Exception e) {
Debug.LogWarning(e.Message);
}
}
public static bool CheckIfEnemyIsInBattleWithOtherUnit(EnemyUnitController ec)
{
if (ec.SM.currentStateLegacy == ec.States.PreBattle || ec.SM.currentStateLegacy == ec.States.InDirectBattle)
{
return(true);
}
else
{
return(false);
}
}
public PoolObjectQueue <EnemyUnitController> GetUnitQueue(EnemyUnitController prefab)
{
if (EnemyUnitObjectPoolQueue.ContainsKey(prefab.name))
{
return(EnemyUnitObjectPoolQueue[prefab.name]);
}
else
{
CreateNewObjectQueue <EnemyUnitController>(EnemyUnitObjectPoolQueue, prefab);
return(EnemyUnitObjectPoolQueue[prefab.name]);
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.CompareTag("Enemy"))
{
if (GameObjectPool.Instance.ActiveUnitPool.Pool.ContainsKey(other.name))
{
tempEc = GameObjectPool.Instance.ActiveUnitPool.Pool[other.name] as EnemyUnitController;
AddObjectToTargets(tempEc);
targetEnteredRange?.Invoke(tempEc);
}
}
}
public static IEnumerator TestAttack(WeaponController self, EnemyUnitController ec)
{
while (self.Target != null)
{
while (ec?.IsTargetable() ?? false)
{
Debug.DrawLine(self.ProjectileExitPoint, ec.transform.position);
yield return(new WaitForFixedUpdate());
}
yield return(new WaitForFixedUpdate());
}
}
public static IEnumerator RotateTowardsEnemyTargetUnit(Transform self, EnemyUnitController target, float rotationSpeed)
{
Transform targetTransform = target.transform;
while (target?.IsTargetable() ?? false)
{
Vector2 vecToTarget = targetTransform.position - self.position;
float angleToTarget = Mathf.Atan2(vecToTarget.y, vecToTarget.x) * Mathf.Rad2Deg;
Quaternion q = Quaternion.AngleAxis(angleToTarget, Vector3.forward);
self.rotation = Quaternion.Slerp(self.rotation, q, StaticObjects.DeltaGameTime * rotationSpeed);
yield return(new WaitForFixedUpdate());
}
}
public static IEnumerator TellEnemyToPrepareFor1on1battleWithMe(EnemyUnitController ec, PlayerUnitController pc)
{
if (ec.CurrentStateLegacy == ec.States.Default)
{
ec.dataLegacy.PlayerTarget = pc;
if (GameObjectPool.Instance.ActiveEffectables.Pool.ContainsKey(pc.name))
{
ec.dataLegacy.EffectableTarget = GameObjectPool.Instance.ActiveEffectables.Pool[pc.name];
ec.SM.SetState(ec.States.PreBattle);
}
}
yield break;
}
/// <summary>
/// Build the unit given in class attribute
/// </summary>
public void build()
{
UnitProperties properties = toBuild.GetComponent <UnitProperties> ();
BuildingProperties factoryProperties = buildFactory.GetComponent <BuildingProperties> ();
toBuild.SetActive(true);
GameObject newUnit = Instantiate(toBuild, GameObject.Find("EnemyUnits").transform) as GameObject;
newUnit.transform.position = new Vector3(buildFactory.transform.position.x - 5, 1.4f, buildFactory.transform.position.z);
newUnit.transform.name = toBuild.name;
EnemyUnitController euc = newUnit.AddComponent <EnemyUnitController> ();
euc.baseBuilding = playerBaseBuilding;
}
static IEnumerator meleeAttackCoroutineAndInvokeAction(EnemyUnitController self)
{
float maxCounter = 1.0f;
while (self.Target?.IsTargetable() ?? false)
{
if (maxCounter >= 1.0f)
{
self.OnAttack();
maxCounter = 0.0f;
}
maxCounter += ((StaticObjects.DeltaGameTime / 10.0F));
yield return(new WaitForFixedUpdate());
}
yield break;
}
public EnemyUnitController FindSingleTargetNearestToEndOfSpline()
{
clearNullsFromList();
EnemyUnitController ec = null;
float p = 999999.0f;
foreach (var item in targets)
{
float tp = item.Value.Proximity;
if (tp < p)
{
p = tp;
ec = item.Value;
}
}
CurrentLowestProximtyTargetName = ec?.name ?? "NULL";
return(ec);
}
public void AddObjectToTargets(EnemyUnitController ec)
{
clearNullsFromList();
if (ec.CompareTag("Enemy"))
{
if (ec.IsTargetable())
{
try {
targets.Add(ec.name, ec);
// Debug.LogWarning(ec.name);
CurrentLowestProximityTarget = FindSingleTargetNearestToEndOfSpline();
}
catch (Exception e) {
Debug.LogWarning(e.Message);
}
}
}
}
// public static IEnumerator TellEnemyToPrepareFor1on1battleWithMe(EnemyUnitController ec, PlayerUnitController pc) {
// if (ec.CurrentState == ec.States.Default) {
// ec.Data.PlayerTarget = pc;
// ec.SM.SetState(ec.States.PreBattle);
// }
// yield break;
// }
public static IEnumerator StandardPostBattleCheck(EnemyUnitController self)
{
PlayerUnitController pc = self.dataLegacy.GetFirstPlayerUnitControllerFromList();
if (pc != null)
{
yield return(self.StartCoroutine(TellPlayerUnitToInitiateForDirectBattleWithMe(self.dataLegacy.GetFirstPlayerUnitControllerFromList())));
self.Target = pc;
self.dataLegacy.EffectableTarget = GameObjectPool.Instance.ActiveEffectables.Pool[pc.name];
self.SM.SetState(self.States.PreBattle);
}
else
{
self.SM.SetState(self.States.Default);
}
yield break;
}
//attacking ships pattern
void Attack()
{
attackForce.transform.parent = null;
EnemyUnitController enemy = (EnemyUnitController)attackForce.GetComponent(typeof(EnemyUnitController));
//EnemyUnitController enemy = attackForce.GetComponent<EnemyUnitController>();
if (randomMove == 0)
{
enemy.Move();
}
else if (randomMove == 1)
{
enemy.FollowMove();
Debug.Log("FollowMove");
}
else
{
enemy.SpinMove();
}
}
// Update is called once per frame
void Update()
{
activeUnit = turnOrder[turnCounter];
if (activeUnit.tag.Equals("Player Unit"))
{
actionButton1.GetComponentInChildren <Text>().text = activeUnit.GetComponent <UnitController>().actionSet.actions[2].action.actionName;
actionButton2.GetComponentInChildren <Text>().text = activeUnit.GetComponent <UnitController>().actionSet.actions[3].action.actionName;
}
if (switchTurn)
{
cursor.GetComponent <CursorController>().position = activeUnit.GetComponent <UnitController>().position;
switchTurn = false;
if (!activeUnit.activeSelf)
{
endCurrentTurn();
switchTurn = true;
}
}
if ((activeUnit != null) && "Enemy Unit".Equals(activeUnit.tag))
{
EnemyUnitController enemy = activeUnit.GetComponent <EnemyUnitController>();
if (!enemy.isActing)
{
enemy.possiblePaths = getPossibleMovement(enemy.position, enemy.maxMovement, enemy.maxJump);
activeUnit.GetComponent <EnemyUnitController>().takeTurn();
}
}
if (selectedObject != null && !displayingActionTargets)
{
GridPosition gp = selectedObject.GetComponent <PlayerUnitController>().position;
if (activeAction is Move)
{
possibleTargets.Clear();
List <List <GridPosition> > possibleMoves = getPossibleMovement(gp, selectedObject.GetComponent <PlayerUnitController>().maxMovement, selectedObject.GetComponent <PlayerUnitController>().maxJump);
foreach (List <GridPosition> path in possibleMoves)
{
possibleTargets.Add(path[path.Count - 1]);
}
selectedObject.GetComponent <PlayerUnitController>().possiblePaths = possibleMoves;
InstantiateTargetsDisplay(possibleTargets);
displayingActionTargets = true;
}
else
{
possibleTargets = getPossibleActionTargets(gp, activeAction);
InstantiateTargetsDisplay(possibleTargets);
displayingActionTargets = true;
}
}
else if (selectedObject == null)
{
if (displayingActionTargets)
{
destroyTargetsDisplay();
displayingActionTargets = false;
}
}
if (checkForPlayerLoss())
{
playerLoses();
}
if (checkForRoundOver())
{
endRound();
}
actionObjects.Clear();
foreach (Transform child in actionObjectsContainer.transform)
{
actionObjects.Add(child.gameObject);
}
}
public static void AttackPlayerUnit(EnemyUnitController self)
{
self.dataLegacy.EffectableTarget?.ApplyDamage(self.dataLegacy.DamageRange.RandomDamage());
//self.Target?.LifeManager.DamageToUnit(UnityEngine.Random.Range(self.Data.DamageRange.min,self.Data.DamageRange.max), self.Data.damageType);
}
public static PlayerUnitController GetRandomPlayerUnitFromList(EnemyUnitController ec)
{
return(ec.dataLegacy.GetFirstPlayerUnitControllerFromList());
}
