internal void Action(ActionType type, float attackStrength, SimpleCallbackDelegate attackOverCallback)
{
if (type == ActionType.Defence)
{
Defence(attackStrength, attackOverCallback);
return;
}
SquadUnitController unit = currentSquad.GetUnitByType(GetUnitTypeByActionType(type));
if (unit == null)
{
Utils.Logger.GetInstance().Message("Failed to fine unit with type Close");
return;
}
if (unit.Actionable != null)
{
if (unit.Statistic != null && !unit.Statistic.IsDied)
{
unit.Actionable.DoAction(attackStrength, currentSquad, enemySquad, attackOverCallback);
}
else
{
attackOverCallback();
}
}
}
public void DoAnimation(Vector3 target, SimpleCallbackDelegate OnDealDamage, SimpleCallbackDelegate OnAnimationOver)
{
isRunning = true;
onOver = OnAnimationOver;
onDealDamage = OnDealDamage;
animator.SetTrigger("Prepare");
}
private void OnAttackOver()
{
returnMovingComponent.MoveTo(startPosition, true, () =>
{
isRunning = false;
onOver();
onOver = null;
});
}
public void TakeDamage(ActionType type, float attackStrength, SimpleCallbackDelegate attackOverCallback)
{
takeDamageCallback = attackOverCallback;
animator.SetTrigger("takeDamage");
Health -= attackStrength;
if (Health <= 0.0f)
{
OnHealthOverEvent(this);
}
}
public void DoAnimation(Vector3 target, SimpleCallbackDelegate OnDealDamage, SimpleCallbackDelegate OnAnimationOver)
{
startPosition = transform.position;
isRunning = true;
onOver = OnAnimationOver;
attackMovingComponent.MoveTo(target + attackPositionOffset, true, () =>
{
OnDealDamage();
animator.SetTrigger("Attack");
});
}
private void Defence(float strength, SimpleCallbackDelegate onOverCallback)
{
SquadUnitController[] units = currentSquad.GetAllUnits();
if (units == null)
{
return;
}
foreach (SquadUnitController unit in units)
{
unit.Protectable.ReceiveProtection(strength);
}
StartCoroutine(WaitAndRun(1.0f, onOverCallback));
}
public override void Action(ActionType type, float attackStrength, SimpleCallbackDelegate attackOverCallback)
{
switch (type)
{
case ActionType.Heal:
case ActionType.Defence:
(is1PlayersTurn ? player1 : player2).Heal(attackStrength, () => { attackOverCallback(); });
break;
case ActionType.Close:
case ActionType.Distance:
case ActionType.Mass:
(is1PlayersTurn ? player2 : player1).TakeDamage(type, attackStrength, () => { attackOverCallback(); });
break;
}
}
public void MoveTo(Vector3 position, bool interpolate = false, SimpleCallbackDelegate onMovingEndCallback = null)
{
if (interpolate)
{
startPosition = useLocalPosition ? Trans.localPosition : Trans.position;
onMovingEnd = onMovingEndCallback;
Destination = position;
if (state == MovingState.Idle)
{
state = MovingState.Moving;
}
}
else
{
if (useLocalPosition)
{
Trans.localPosition = position;
}
else
{
Trans.position = position;
}
}
}
public abstract void Action(ActionType type, float attackStrength, SimpleCallbackDelegate attackOverCallback);
private IEnumerator WaitAndRun(float waittime, SimpleCallbackDelegate action)
{
yield return(new WaitForSeconds(waittime));
action();
}
private IEnumerator WaitAndCall(float waitTime, SimpleCallbackDelegate callback)
{
yield return(new WaitForSeconds(waitTime));
callback();
}
public void Heal(float strength, SimpleCallbackDelegate attackOverCallback)
{
Health += strength;
StartCoroutine(WaitAndCall(1.0f, attackOverCallback));
}
public abstract void DoAction(float strength, SquadContainer teammates, SquadContainer enemies, SimpleCallbackDelegate onOverCallback);
public override void DoAction(float strength, SquadContainer teammates, SquadContainer enemies, SimpleCallbackDelegate onOverCallback)
{
if (teammates == null)
{
Utils.Logger.GetInstance().Error("teammates is null");
onOverCallback();
return;
}
SquadUnitController[] teammatesArray = teammates.GetAllUnits();
if (teammatesArray == null || teammatesArray.Length <= 0)
{
Utils.Logger.GetInstance().Message("failed to get teammates");
onOverCallback();
return;
}
AttackAnimation.DoAnimation(teammatesArray[0].transform.parent.position, () =>
{
foreach (SquadUnitController teammate in teammatesArray)
{
if (teammate.Healable != null)
{
teammate.Healable.ReceiveHeal(strength);
}
}
}, () =>
{
onOverCallback();
});
}
public void SetHostCallbacks(Action <Action> wakeUp, Action flush)
{
_wakeUp = () => wakeUp(PerformUpdates);
_executeInServoThread = wakeUp;
_flush = new SimpleCallbackDelegate(flush);
}
public override void DoAction(float strength, SquadContainer teammates, SquadContainer enemies, SimpleCallbackDelegate onOverCallback)
{
if (enemies == null)
{
Utils.Logger.GetInstance().Error("enemies is null");
onOverCallback();
return;
}
SquadUnitController[] distancelineEnemies = enemies.GetDistanceLineUnits();
if (distancelineEnemies == null || distancelineEnemies.Length <= 0)
{
Utils.Logger.GetInstance().Message("failed to get distanceline enemies");
onOverCallback();
return;
}
SquadUnitController enemy = distancelineEnemies[Randomizer.Range(0, distancelineEnemies.Length)];
if (enemy == null || enemy.Damagable == null)
{
onOverCallback();
return;
}
AttackAnimation.DoAnimation(enemy.transform.position, () =>
{
enemy.Damagable.ReceiveDamage(strength);
}, () =>
{
onOverCallback();
});
}
public override void Action(ActionType type, float attackStrength, SimpleCallbackDelegate attackOverCallback)
{
(isLeftsTurn ? leftSquad : rightSquad).Action(type, attackStrength, attackOverCallback);
}
public override void DoAction(float strength, SquadContainer teammates, SquadContainer enemies, SimpleCallbackDelegate onOverCallback)
{
if (enemies == null)
{
Utils.Logger.GetInstance().Error("enemies is null");
onOverCallback();
return;
}
SquadUnitController[] units = enemies.GetAllUnits();
if (units == null || units.Length <= 0)
{
Utils.Logger.GetInstance().Error("Failed to get enemy units");
onOverCallback();
return;
}
AttackAnimation.DoAnimation(units[0].transform.parent.position, () =>
{
foreach (SquadUnitController unit in units)
{
if (unit.Damagable != null)
{
unit.Damagable.ReceiveDamage(strength);
}
}
}, () =>
{
onOverCallback();
});
}
public void SetLoadEndedCallback(Action callback)
{
_loadEnded = new SimpleCallbackDelegate(callback);
}
