/// <summary>
/// The base interruption handler
/// </summary>
protected void BaseInterruptionHandler()
{
float moveX = -20f;
float moveY = 70f;
double time = 500d;
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.HurtName, true);
Vector2 pos = User.Position + new Vector2(moveX, -moveY);
CurSequenceAction = new MoveToSeqAction(pos, time / 2d);
break;
case 1:
CurSequenceAction = new WaitForAnimationSeqAction(AnimationGlobals.HurtName);
break;
case 2:
CurSequenceAction = new MoveAmountSeqAction(new Vector2(0f, moveY), time);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceMainBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.DuplighostBattleAnimations.HeadbuttName);
CurSequenceAction = new MoveToSeqAction(User, new Vector2(EntitiesAffected[0].Position.X, EntitiesAffected[0].Position.Y + YHeight), MoveDur);
break;
case 1:
AttemptDamage(Action.DamageProperties.Damage, EntitiesAffected[0], Action.DamageProperties, false);
Vector2 pos = BattleManagerUtils.GetPositionInFront(EntitiesAffected[0], User.EntityType == Enumerations.EntityTypes.Player);
CurSequenceAction = new MoveToSeqAction(User, pos, MoveDur / 2d, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
break;
case 2:
User.AnimManager.PlayAnimation(AnimationGlobals.IdleName);
CurSequenceAction = new WaitSeqAction(WaitDur / 5d);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
SegmentTexUI = new UICroppedTexture2D(SegmentTex);
SegmentTexUI.Origin = new Vector2(.5f, .5f);
User.BManager.battleUIManager.AddUIElement(SegmentTexUI);
//Start it out being underneath, where the segment would be
SegmentTexUI.Position = Camera.Instance.SpriteToUIPos(User.Position + new Vector2(0f, SegmentTex.SourceRect.Value.Height * SegmentBehavior.CurSegmentCount));
//Remove a segment
SegmentBehavior.HandleSegmentRemoved(1);
//Move the segment above the user's head
CurSequenceAction = new MoveToSeqAction(SegmentTexUI, Camera.Instance.SpriteToUIPos(User.GetDrawnPosAbove(new Vector2(0f, -SegmentTex.SourceRect.Value.Height))),
UpMoveTime, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.CubicInOut);
break;
case 1:
//Wait a little bit
CurSequenceAction = new WaitSeqAction(WaitTime);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
//NOTE: Mario moves up a bit when he's in the front, I haven't confirmed how it works in the back yet
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
CurSequenceAction = new MoveToSeqAction(User.BattlePosition, WalkDuration);
break;
case 1:
//NOTE: Show all Crystal Stars coming from the map with VFX and such
User.AnimManager.PlayAnimation(AnimationGlobals.MarioBattleAnimations.MapLiftName);
CurSequenceAction = new WaitSeqAction(WaitTime);
break;
case 2:
User.AnimManager.PlayAnimation(User.GetIdleAnim());
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceEndBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
CurSequenceAction = new MoveToSeqAction(User, User.BattlePosition, WalkDuration);
break;
case 1:
User.AnimManager.PlayAnimation(User.GetIdleAnim());
//Remove the item when finished
//For Players, remove the item from the inventory
if (User.EntityType == Enumerations.EntityTypes.Player)
{
Inventory.Instance.RemoveItem(itemAction.ItemUsed);
}
//It has to be an Enemy, so remove its held item
else
{
BattleEnemy enemy = (BattleEnemy)User;
enemy.SetHeldCollectible(null);
}
EndSequence();
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
Vector2 frontPos = BattleManager.Instance.GetPositionInFront(BattleManager.Instance.GetFrontmostBattleEntity(CurTarget.EntityType, null), User.EntityType != EntityTypes.Enemy);
frontPos.Y = User.Position.Y;
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
CurSequenceAction = new MoveToSeqAction(frontPos, WalkDuration);
break;
case 1:
User.AnimManager.PlayAnimation(AnimationGlobals.JumpStartName);
CurSequenceAction = new WaitForAnimationSeqAction(AnimationGlobals.JumpStartName);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
//NOTE: Mario moves up a tiny bit when he's in the front, I haven't confirmed how it works in the back yet
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
CurSequenceAction = new MoveToSeqAction(User.BattlePosition, WalkDuration);
break;
case 1:
User.AnimManager.PlayAnimation(AnimationGlobals.PlayerBattleAnimations.StarSpecialName);
CurSequenceAction = new WaitSeqAction(WaitTime);
break;
case 2:
User.AnimManager.PlayAnimation(AnimationGlobals.PlayerBattleAnimations.StarWishName);
//NOTE: Show Star Spirit appearing and VFX and such
CurSequenceAction = new WaitSeqAction(WaitTime);
break;
case 3:
User.AnimManager.PlayAnimation(User.GetIdleAnim());
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceMainBranch()
{
switch (SequenceStep)
{
case 0:
//Always play the standard Idle animation here, since the entity is waiting
User.AnimManager.PlayAnimation(AnimationGlobals.IdleName);
//Make the used entity fly towards the target
EntityUsed.TintColor = PrevUsedTintColor;
CurSequenceAction = new MoveToSeqAction(EntityUsed, BattleManagerUtils.GetPositionInFront(EntitiesAffected[0], false), WalkDur / 2d);
break;
case 1:
//When hitting, it should eventually fly off after recoiling if a rock, or if it's like a bomb then explode
//There will need to be some type of collision behavior we can define
//For now just make it invisible
EntityUsed.TintColor = Color.Transparent;
//Attempt to deal damage
AttemptDamage(BaseDamage, EntitiesAffected[0], Action.DamageProperties, false);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceMissBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
//When Watt misses Electro Dash, she goes in a downwards arc to around where the next enemy slot would be
Vector2 destPos = BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], EntitiesAffected[0].EntityType == Enumerations.EntityTypes.Player);
Vector2 curDest = User.Position + new Vector2(UtilityGlobals.DifferenceDivided(destPos.X, User.Position.X, 2f), MissHeight);
CurSequenceAction = new MoveToSeqAction(curDest, MissMoveDur, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadOut);
break;
case 1:
destPos = BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], EntitiesAffected[0].EntityType == Enumerations.EntityTypes.Player);
curDest = User.Position + new Vector2(UtilityGlobals.DifferenceDivided(destPos.X, User.Position.X, 2f), -MissHeight);
CurSequenceAction = new MoveToSeqAction(curDest, MissMoveDur, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
break;
case 2:
User.AnimManager.PlayAnimation(AnimationGlobals.IdleName);
CurSequenceAction = new WaitSeqAction(MissWaitDur);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceEndBranch()
{
switch (SequenceStep)
{
case 0:
//End the action command's input if it's currently going on
if (CommandEnabled == true && actionCommand.AcceptingInput == true)
{
actionCommand.EndInput();
}
//The entity goes back to its battle position
User.AnimManager.PlayAnimation(User.GetIdleAnim());
CurSequenceAction = new MoveToSeqAction(User.BattlePosition, MoveTime);
break;
case 1:
EndSequence();
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
//Go in front of the entity
//bool approachFromLeft = User.BattlePosition.X < EntityUsed.BattlePosition.X;
Vector2 position = BattleManagerUtils.GetPositionInFront(EntityUsed, false);
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
CurSequenceAction = new MoveToSeqAction(User, position, WalkDur);
break;
case 1:
User.AnimManager.PlayAnimation(AnimationGlobals.GulpitBattleAnimations.SpitRockName);
//Show the used entity going inside its mouth; make invisible for now
EntityUsed.TintColor = Color.Transparent;
EntityUsed.Layer = User.Layer + .0001f;
AddSideSeqAction(new MoveToSeqAction(EntityUsed, User.Position + new Vector2(-18, -3), User.AnimManager.GetCurrentAnim <Animation>().CurFrame.Duration));
CurSequenceAction = new WaitForAnimationSeqAction(User, AnimationGlobals.GulpitBattleAnimations.SpitRockName);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceSuccessBranch()
{
switch (SequenceStep)
{
case 0:
CurSequenceAction = new MoveToSeqAction(new Vector2(EntitiesAffected[0].BattlePosition.X, User.Position.Y), 200d);
break;
case 1:
InteractionResult[] result = AttemptDamage(Action.DamageProperties.Damage, EntitiesAffected[0], Action.DamageProperties, false);
if (result[0] != null && result[0].WasVictimHit == true)
{
ShowCommandRankVFX(HighestCommandRank, EntitiesAffected[0].Position);
}
CurSequenceAction = new WaitSeqAction(0d);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
/// <summary>
/// The interruption that occurs when jumping on a Spiked entity
/// </summary>
protected void SpikedEntityInterruption()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.SpikedTipHurtName, true);
Vector2 pos = BattleManager.Instance.GetPositionInFront(CurTarget) + new Vector2(-50, -JumpHeight);
CurSequenceAction = new MoveToSeqAction(pos, WalkDuration / 4d);
break;
case 1:
CurSequenceAction = new WaitForAnimationSeqAction(AnimationGlobals.SpikedTipHurtName);
break;
case 2:
CurSequenceAction = new MoveAmountSeqAction(new Vector2(0f, JumpHeight), JumpDuration / 2f);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
Vector2 frontPos = BattleManagerUtils.GetPositionInFront(User.BManager.GetFrontmostBattleEntity(CurTarget.EntityType, null), User.EntityType != EntityTypes.Enemy);
frontPos.Y = User.Position.Y;
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
CurSequenceAction = new MoveToSeqAction(User, frontPos, WalkDuration);
break;
case 1:
User.AnimManager.PlayAnimation(AnimationGlobals.JumpStartName);
CurSequenceAction = new WaitForAnimationSeqAction(User, AnimationGlobals.JumpStartName);
ChangeSequenceBranch(SequenceBranch.Main);
//Store the jump distance
XDiffOverTwo = UtilityGlobals.DifferenceDivided(CurTarget.Position.X, User.Position.X, 2f);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceSuccessBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.GetAnimation(AnimationGlobals.ShelledBattleAnimations.ShellSpinName)?.SetSpeed(3f);
CurSequenceAction = new MoveToSeqAction(BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], User.EntityType != Enumerations.EntityTypes.Enemy), SpinMoveDuration);
break;
case 1:
InteractionResult[] interactions = AttemptDamage(BaseDamage * DamageMod, EntitiesAffected[0], Action.DamageProperties, false);
if (interactions[0] != null && interactions[0].WasVictimHit == true && interactions[0].WasAttackerHit == false)
{
ShowCommandRankVFX(HighestCommandRank, EntitiesAffected[0].Position);
}
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceMainBranch()
{
switch (SequenceStep)
{
case 0:
Vector2 posTo = User.Position + new Vector2(XDiffOverTwo, -JumpHeight);
User.AnimManager.PlayAnimation(AnimationGlobals.JumpRisingName);
CurSequenceAction = new MoveToSeqAction(posTo, JumpDuration, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadOut);
SoundManager.Instance.PlaySound(SoundManager.Sound.MarioJump);
break;
case 1:
Vector2 posTo2 = User.Position + new Vector2(XDiffOverTwo, JumpHeight);
User.AnimManager.PlayAnimation(AnimationGlobals.JumpFallingName);
StartActionCommandInput(SentRank);
CurSequenceAction = new MoveToSeqAction(posTo2, JumpDuration, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
CurSequenceAction = new MoveToSeqAction(BattleManager.Instance.GetPartner(), BattleManager.Instance.GetMario().BattlePosition, 300d);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
/// <summary>
/// The interruption that occurs when jumping on a Spiked entity
/// </summary>
protected void SpikedEntityInterruption()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.SpikedTipHurtName, true);
Vector2 offset = new Vector2(-50, -JumpHeight);
if (User.EntityType != EntityTypes.Player)
{
offset.X = -offset.X;
}
Vector2 pos = BattleManager.Instance.GetPositionInFront(CurTarget, User.EntityType != EntityTypes.Player) + offset;
CurSequenceAction = new MoveToSeqAction(pos, WalkDuration / 4d);
break;
case 1:
CurSequenceAction = new WaitForAnimationSeqAction(AnimationGlobals.SpikedTipHurtName);
break;
case 2:
CurSequenceAction = new MoveAmountSeqAction(new Vector2(0f, User.BattlePosition.Y - User.Position.Y), JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
break;
case 3:
//Do the same bounce as the end sequence, except keep playing the same animation
Vector2 endPos = BattleManager.Instance.GetPositionInFront(CurTarget, User.EntityType == EntityTypes.Player);
Vector2 moveAmt = new Vector2(UtilityGlobals.DifferenceDivided(endPos.X, User.Position.X, 2f), -(JumpHeight / 2f));
CurSequenceAction = new MoveAmountSeqAction(moveAmt, JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadOut);
break;
case 4:
endPos = BattleManager.Instance.GetPositionInFront(CurTarget, User.EntityType == EntityTypes.Player);
moveAmt = new Vector2(UtilityGlobals.DifferenceDivided(endPos.X, User.Position.X, 2f), (JumpHeight / 2f));
CurSequenceAction = new MoveAmountSeqAction(moveAmt, JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
ChangeSequenceBranch(SequenceBranch.End);
SequenceStep = 1;
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceMainBranch()
{
switch (SequenceStep)
{
case 0:
StartActionCommandInput();
CurSequenceAction = new MoveToSeqAction(BattleManager.Instance.GetPositionInFront(EntitiesAffected[0]), WalkDuration);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
CurSequenceAction = new MoveToSeqAction(BattleManager.Instance.GetPositionInFront(CurTarget), WalkDuration);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
//Move to the entity
CurSequenceAction = new MoveToSeqAction(BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], EntitiesAffected[0].EntityType != Enumerations.EntityTypes.Player), WalkDur);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.WingedBattleAnimations.FlyingName);
CurSequenceAction = new MoveToSeqAction(new Vector2(BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], User.EntityType != Enumerations.EntityTypes.Enemy).X, User.BattlePosition.Y), 700d);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceMainBranch()
{
switch (SequenceStep)
{
case 0:
//Make the user move back to its battle position
CurSequenceAction = new MoveToSeqAction(User.BattlePosition, MoveTime);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceFailedBranch()
{
switch (SequenceStep)
{
case 0:
//The user goes back to its battle position when failing and ends the sequence
CurSequenceAction = new MoveToSeqAction(User, EntityUsing.BattlePosition, MoveTime);
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceSuccessBranch()
{
switch (SequenceStep)
{
case 0:
//Move down
//NOTE: Move the ally as well - this needs to be added in
CurSequenceAction = new MoveToSeqAction(EntityUsing.Position + new Vector2(0f, 25f), MoveTime);
break;
case 1:
//Make them invisible
//NOTE: We need to change this to scale down the characters to almost 0, as that is how it works in the actual game
EntityUsing.TintColor = Color.White * 0f;
AllyAffected.TintColor = Color.White * 0f;
//Add evasion so attacks against these entities always miss
EntityUsing.AddEvasionMod(0d);
AllyAffected.AddEvasionMod(0d);
//NOTE: Add Invincibility to prevent both from taking damage from Status Effects
//This doesn't seem ideal, but it's the only way we can do this right now
EntityUsing.EntityProperties.AddAdditionalProperty(Enumerations.AdditionalProperty.Invincible, true);
AllyAffected.EntityProperties.AddAdditionalProperty(Enumerations.AdditionalProperty.Invincible, true);
CurSequenceAction = new WaitSeqAction(0d);
break;
case 2:
//Set up the entities for the second phase of the move
EntityUsing.TurnStartEvent -= OnUserTurnStart;
EntityUsing.TurnStartEvent += OnUserTurnStart;
//Skip the ally's turns until the user comes back up
AllyAffected.TurnStartEvent -= AllyAffectedTurnStartHandler;
AllyAffected.TurnStartEvent += AllyAffectedTurnStartHandler;
//Go to the end of the sequence
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
//Move to the entity
CurSequenceAction = new MoveToSeqAction(User, BattleManagerUtils.GetPositionInFront(EntitiesAffected[0], EntitiesAffected[0].EntityType != Enumerations.EntityTypes.Player), WalkDur);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceSuccessBranch()
{
switch (SequenceStep)
{
case 0:
//Move down
//NOTE: Move the ally as well - this needs to be added in
CurSequenceAction = new MoveToSeqAction(User, EntityUsing.Position + new Vector2(0f, 25f), MoveTime);
break;
case 1:
//Scale down the characters to almost 0; that is how it works in the actual game
EntityUsing.Scale *= ScaleVal;
AllyAffected.Scale *= ScaleVal;
//Add evasion so attacks against these entities always miss
EntityUsing.AddEvasionMod(0d);
AllyAffected.AddEvasionMod(0d);
//Add Effects suppression to the Poison, Burn, and Frozen Status Effects
EntityUsing.EntityProperties.SuppressStatuses(Enumerations.StatusSuppressionTypes.Effects, Enumerations.StatusTypes.Poison, Enumerations.StatusTypes.Burn, Enumerations.StatusTypes.Frozen);
AllyAffected.EntityProperties.SuppressStatuses(Enumerations.StatusSuppressionTypes.Effects, Enumerations.StatusTypes.Poison, Enumerations.StatusTypes.Burn, Enumerations.StatusTypes.Frozen);
CurSequenceAction = new WaitSeqAction(0d);
break;
case 2:
//Set up the entities for the second phase of the move
EntityUsing.TurnStartEvent -= OnUserTurnStart;
EntityUsing.TurnStartEvent += OnUserTurnStart;
//Skip the ally's turns until the user comes back up
AllyAffected.TurnStartEvent -= AllyAffectedTurnStartHandler;
AllyAffected.TurnStartEvent += AllyAffectedTurnStartHandler;
//Go to the end of the sequence
ChangeSequenceBranch(SequenceBranch.End);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
Vector2 pos = BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], User.EntityType == Enumerations.EntityTypes.Player);
CurSequenceAction = new MoveToSeqAction(pos, MoveDur);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceStartBranch()
{
switch (SequenceStep)
{
case 0:
User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
Vector2 pos = BattleManagerUtils.GetPositionInFront(User.BManager.FrontPlayer, User.EntityType != Enumerations.EntityTypes.Player);
CurSequenceAction = new MoveToSeqAction(User, pos, WalkDuration / 4f);
ChangeSequenceBranch(SequenceBranch.Main);
break;
default:
PrintInvalidSequence();
break;
}
}
protected override void SequenceMainBranch()
{
switch (SequenceStep)
{
case 0:
StartActionCommandInput();
Vector2 pos = BattleManagerUtils.GetPositionInFront(EntitiesAffected[0], User.EntityType != Enumerations.EntityTypes.Enemy);
pos.Y = User.Position.Y;
CurSequenceAction = new MoveToSeqAction(User, pos, WalkDuration);
break;
default:
PrintInvalidSequence();
break;
}
}