public void MultiTarget()
{
ParallelAction parallel = new ParallelAction();
parallel.name = "SkillCast";
string vfx = "Thunder";
AnimeAction action1 = CreateCastAction("target1", vfx, enemyAnimator, 1000);
parallel.AddAction(action1);
AnimeAction action2 = CreateCastAction("target2", vfx, enemyAnimator2, 777);
parallel.AddAction(action2);
AnimatorAction animeAction = new AnimatorAction();
animeAction.name = "character";
animeAction.animator = charAnimator;
animeAction.triggerState = "Cast";
animeAction.onHitAction = parallel;
actionManager.RunAction(animeAction);
}
public void VFXUsingPrefab()
{
AnimeAction action = BattleVFXAction.CreateWithPrefab(vfxPrefab, "Fire", enemy2);
//action
action.Start();
}
public void Init(GameCharacter _actorCharacter, AnimeAction _subAttackAction)
{
// mIsDone = false;
// Debug.Log("BattleVFXAction: Init called");
// mVFXObject = _vfxObj;
// mVFXName = vfxName;
actorCharacter = _actorCharacter;
subAttackAction = _subAttackAction;
actorCharacter.SetAnimeEventCallback((string eventName) => {
//Debug.Log("BattleVFXAction: animeEvent. name=" + eventName);
if (eventName == "attack")
{
//HitTarget();
StartSubAttackAction();
}
});
actorCharacter.SetAnimeEndCallback(() => {
//if(onAttackAction == null || onA
MarkAsDone();
});
}
protected override void OnUpdate()
{
if (mActiveAction != null)
{
mActiveAction.Update(mDeltaTime);
if (mActiveAction.IsDone() == false)
{
return; // wait for next update
}
else
{
mActiveAction = null;
}
}
// -- activeAction is null or activeAction is done
// if no more pending
if (HasPendingAction() == false)
{
MarkAsDone();
}
else
{
PopPendingAction();
}
}
public void TargetAttack()
{
AnimeAction targetHit = CreateHitDamageAction(hero);
AnimeAction actorAttack = CreateAttackAction(enemy, hero, 0, true, targetHit);
actionManager.RunAction(actorAttack);
}
public void OneOnOne()
{
Debug.Log("###### TEST 1 ######");
SequenceAction demoFight = new SequenceAction();
Model actor, target;
// Right-0 attack Left-0
actor = rightTeam[0]; target = leftTeam[0];
AnimeAction p1Attack = CreateAttackAction(actor, target, 0,
true, CreateHitDamageAction(target));
// Left-0 attack Right-1
actor = leftTeam[0]; target = rightTeam[0];
AnimeAction p2Attack = CreateAttackAction(actor, target, 0,
true, CreateHitDamageAction(target, effectPrefab[1]));
demoFight.AddAction(p2Attack);
demoFight.AddAction(p1Attack);
actionManager.RunAction(demoFight);
}
public static CharAttackAction Create(GameCharacter _actor, AnimeAction _subAttackAction)
{
CharAttackAction action = new CharAttackAction();
action.Init(_actor, _subAttackAction);
return(action);
}
public void Schedule(float delay, AnimeAction action)
{
ScheduleItem scheduleItem = new ScheduleItem();
scheduleItem.delay = delay;
scheduleItem.action = action;
mScheduleList.Add(scheduleItem);
}
public void PlayerAttack()
{
// SubAction
AnimeAction subAction = BattleVFXAction.CreateWithPrefab(vfxPrefab, "Fire", enemy2);
AnimeAction attackAction = CharAttackAction.Create(player, subAction);
attackAction.Start();
}
public void AttackToPosition()
{
UpdateLog("Attack to a position");
AnimeAction onHitAction = GetOnHitAction();
ModelAttackAction action = ModelAttackAction.CreateAttackToPos(
GetActor(), attackStyle, isMoving, targetPosition, onHitAction);
AnimeActionManager.Instance.StartAction(action);
}
public void TestProject()
{
Model actor, target;
actor = rightTeam[0];
target = leftTeam[0];
AnimeAction action = CreateProjectileAction(actor, target, projectilePrefab[0], effectPrefab[0]);
actionManager.RunAction(action);
}
public void StartAction(AnimeAction action)
{
if (action == null)
{
return;
}
action.SetManager(this);
action.Start();
mActionList.Add(action);
}
public void KillAModel()
{
UpdateLog("Kill to a model");
AnimeAction onHitAction = ModelDieAction.Create(GetTarget());
ModelAttackAction action = ModelAttackAction.CreateAttackToModel(
GetActor(), attackStyle, isMoving, GetTarget(), onHitAction);
AnimeActionManager.Instance.StartAction(action);
}
public void StartAction(AnimeAction action)
{
if (mManager != null)
{
Debug.Log("ERROR: AnimeAction: queue action=" + action.name);
mManager.QueueNewAction(action);
}
else
{
Debug.Log("ERROR: AnimeActionManager: manager is null");
}
}
// [Test]
// public void Die()
// {
// Debug.Log("###### TEST 2 ######");
// }
#region Action
public AttackAction CreateAttackAction(BattleModel actor, BattleModel target,
short style, bool isMoving, AnimeAction onHitAction)
{
AttackAction attackAction = new AttackAction();
attackAction.actor = actor;
attackAction.style = style;
attackAction.isMoving = isMoving;
attackAction.targetPostion = target.GetHitPosition() + new Vector3(0, 0, -5);
attackAction.onHitAction = onHitAction;
return(attackAction);
}
public void QueueNewAction(AnimeAction action)
{
if (action == null)
{
return;
}
Debug.Log("INFO: ActionManager: " + action.name + " is queued");
// action.SetManager(this);
// action.Start();
mNewActionQueue.Add(action); // update loop will run it
}
public void Range2()
{
// Projectile Action
SequenceAction sequence = new SequenceAction();
AnimeAction projectileAction = CreateProjectileAction(hero.GetLaunchPosition(), target.transform.position);
sequence.AddAction(projectileAction);
sequence.AddAction(CreateTargetHitDamageAction());
//
AttackAction attackAction = CreateActorAttackAction(1, false, sequence);
actionManager.RunAction(attackAction);
}
public void MeleeEffect()
{
SequenceAction sequence = new SequenceAction();
bool isMoving = true;
foreach (GameObject effect in effectPrefab)
{
AnimeAction action = CreateEffectAttack(rightTeam[1], leftTeam[0], isMoving, effect);
sequence.AddAction(action);
}
AnimeActionManager.Instance.RunAction(sequence);
}
public ModelAttackAction CreateAttackAction(Model actor, Model target,
short style, bool isMoving, AnimeAction onHitAction)
{
ModelAttackAction attackAction = new ModelAttackAction();
attackAction.actor = actor;
attackAction.style = style;
attackAction.isMoving = isMoving;
attackAction.postionType = ModelAttackAction.PositionType.UseModel;
attackAction.targetModel = target;
attackAction.onHitAction = onHitAction;
return(attackAction);
}
protected void PopPendingAction()
{
if (mPendingList.Count == 0)
{
return; // Prevent out-of-bound problem!
}
mActiveAction = mPendingList[0];
mPendingList.RemoveAt(0);
if (mActiveAction != null)
{
mActiveAction.Start();
}
}
public void SingleTarget()
{
AnimeAction targetAction = CreateCastAction("fire", "Fire", enemyAnimator, 1000);
AnimatorAction animeAction = new AnimatorAction();
animeAction.name = "character";
animeAction.animator = charAnimator;
animeAction.triggerState = "Cast";
animeAction.onHitAction = targetAction;
//AnimeAction action =
actionManager.RunAction(animeAction);
}
public void AttackFromTeam(SequenceAction sequence, BattleModel[] attackTeam, BattleModel[] targetTeam)
{
for (int i = 0; i < attackTeam.Length; i++)
{
BattleModel actor = attackTeam[i];
BattleModel target = targetTeam[i];
short style = (short)Random.Range(0, 2);
AnimeAction attackAttack = CreateAttackAction(actor, target, style,
true, CreateHitDamageAction(target, slashEffect[0]));
sequence.AddAction(attackAttack);
//for(BattleModel actor in attackTeam) {
}
}
public void FightDemo1()
{
SequenceAction demoFight = new SequenceAction();
AnimeAction p1Attack = CreateAttackAction(enemy, hero, 0,
true, CreateHitDamageAction(hero));
demoFight.AddAction(p1Attack);
AnimeAction p2Attack = CreateAttackAction(hero, enemy, 0,
true, CreateHitDamageAction(enemy, slashEffect));
demoFight.AddAction(p2Attack);
actionManager.RunAction(demoFight);
}
public void AttackFromTeam(SequenceAction sequence, Model[] attackTeam, Model[] targetTeam)
{
for (int i = 0; i < attackTeam.Length; i++)
{
Model actor = attackTeam[i];
Model target = targetTeam[i];
short style = (short)Random.Range(0, 2);
effectIndex++;
int effectIdx = effectIndex % 2;
AnimeAction attackAttack = CreateAttackAction(actor, target, style,
true, CreateHitDamageAction(target, effectPrefab[effectIdx]));
sequence.AddAction(attackAttack);
//for(Model actor in attackTeam) {
}
}
// Note:
// https://answers.unity.com/questions/1039227/play-an-animation-of-animator-once-only.html
public void ChangeAnimeAction(AnimeAction action)
{
if (action == AnimeAction.Idle)
{
mAnimator.SetTrigger("Idle");
}
else if (action == AnimeAction.Attack)
{
mAnimator.SetTrigger("Attack");
}
else if (action == AnimeAction.CastMagic)
{
mAnimator.SetTrigger("Cast");
}
else if (action == AnimeAction.Hit)
{
mAnimator.SetTrigger("Hit");
}
//mAnimator.
}
private void InitilizeActions()
{
InLockAction += (act) => {
SetWalkable (false);
inAction = act;
};
OutLockAction += (act) => {
SetWalkable (true);
inAction = AnimeAction.None;
};
stateMachines = animator.GetBehaviours<UnityChanLocoSD> ().ToList();
SetWalkable (true);
}
public void RunAction(AnimeAction action)
{
Reset();
StartAction(action);
}
private void StartLockedAction(AnimeAction act, LockHandler onCompleted, bool isForceStop = false)
{
if (isForceStop) {
ForceStop ();
}
// anime
InLockAction(act);
stateMachines.ForEach (m => m.OnExit = (hash) => {
OutLockAction(act);
onCompleted(act);
});
animator.SetAnimeAction ((int)act);
}
public bool Is(AnimeAction act)
{
return InAction == act;
}
public void DamageText()
{
AnimeAction action = CreateHitValueAction(leftPlayer);
actionManager.StartAction(action);
}
public void Hit()
{
AnimeAction action = CreateHitAction(leftPlayer);
actionManager.StartAction(action);
}
public void SlashVFX()
{
AnimeAction action = CreateEffectAction(leftPlayer, slashEffect[0]);
actionManager.StartAction(action);
}
protected void AddSubAction(AnimeAction action)
{
action.SetManager(mManager);
action.Start();
mSubActionList.Add(action);
}
