public Spawn(params FiniteTimeAction[] actions)
{
FiniteTimeAction prev = actions [0];
FiniteTimeAction next = null;
if (actions.Length == 1)
{
next = new ExtraAction();
}
else
{
// We create a nested set of SpawnActions out of all of the actions
for (int i = 1; i < actions.Length - 1; i++)
{
prev = new Spawn(prev, actions [i]);
}
next = actions [actions.Length - 1];
}
// Can't call base(duration) because we need to determine max duration
// Instead call base's init method here
if (prev != null && next != null)
{
Duration = Math.Max(prev.Duration, next.Duration);
InitSpawn(prev, next);
}
}
public FiniteTimeActionState(FiniteTimeAction action, Node target)
: base(action, target)
{
Duration = action.Duration;
Elapsed = 0.0f;
firstTick = true;
}
public FiniteTimeActionState (FiniteTimeAction action, Node target)
: base (action, target)
{
Duration = action.Duration;
Elapsed = 0.0f;
firstTick = true;
}
void InitSequence (FiniteTimeAction actionOne, FiniteTimeAction actionTwo)
{
Debug.Assert (actionOne != null);
Debug.Assert (actionTwo != null);
Actions [0] = actionOne;
Actions [1] = actionTwo;
}
void InitSequence(FiniteTimeAction actionOne, FiniteTimeAction actionTwo)
{
Debug.Assert(actionOne != null);
Debug.Assert(actionTwo != null);
Actions [0] = actionOne;
Actions [1] = actionTwo;
}
public override FiniteTimeAction Reverse()
{
FiniteTimeAction[] rev = new FiniteTimeAction[Actions.Length];
for (int i = 0; i < Actions.Length; i++)
{
rev [i] = Actions [i].Reverse();
}
return(new Parallel(rev));
}
public override FiniteTimeAction Reverse ()
{
FiniteTimeAction[] rev = new FiniteTimeAction[Actions.Length];
for (int i = 0; i < Actions.Length; i++)
{
rev [i] = Actions [i].Reverse ();
}
return new Parallel (rev);
}
/// <summary>
/// Runs an Action that can be awaited.
/// </summary>
/// <param name="action">A FiniteTimeAction.</param>
public Task<ActionState> RunActionsAsync(FiniteTimeAction action)
{
var tcs = new TaskCompletionSource<ActionState>();
ActionState state = null;
var completion = new CallFunc(() => tcs.TrySetResult(state));
var asyncAction = new Sequence(action, completion);
state = Application.Current.ActionManager.AddAction(asyncAction, this);
return tcs.Task;
}
public Repeat(FiniteTimeAction action, uint times) : base(action.Duration * times)
{
Times = times;
InnerAction = action;
ActionInstant = action is ActionInstant;
//an instant action needs to be executed one time less in the update method since it uses startWithTarget to execute the action
if (ActionInstant)
{
Times -= 1;
}
Total = 0;
}
public Repeat (FiniteTimeAction action, uint times) : base (action.Duration * times)
{
Times = times;
InnerAction = action;
ActionInstant = action is ActionInstant;
//an instant action needs to be executed one time less in the update method since it uses startWithTarget to execute the action
if (ActionInstant)
{
Times -= 1;
}
Total = 0;
}
/// <summary>
/// Runs a sequence of Actions so that it can be awaited.
/// </summary>
/// <param name="actions">An array of FiniteTimeAction objects.</param>
public Task<ActionState> RunActionsAsync(params FiniteTimeAction[] actions)
{
if (actions.Length == 0)
return Task.FromResult<ActionState>(null);
var tcs = new TaskCompletionSource<ActionState>();
var numActions = actions.Length;
var asyncActions = new FiniteTimeAction[actions.Length + 1];
Array.Copy(actions, asyncActions, numActions);
ActionState state = null;
asyncActions[numActions] = new CallFunc(() => tcs.TrySetResult(state));
var asyncAction = asyncActions.Length > 1 ? new Sequence(asyncActions) : asyncActions[0];
state = Application.Current.ActionManager.AddAction(asyncAction, this);
return tcs.Task;
}
private void InitSpawn (FiniteTimeAction action1, FiniteTimeAction action2)
{
Debug.Assert (action1 != null);
Debug.Assert (action2 != null);
float d1 = action1.Duration;
float d2 = action2.Duration;
ActionOne = action1;
ActionTwo = action2;
if (d1 > d2)
{
ActionTwo = new Sequence (action2, new DelayTime (d1 - d2));
}
else if (d1 < d2)
{
ActionOne = new Sequence (action1, new DelayTime (d2 - d1));
}
}
private void InitSpawn(FiniteTimeAction action1, FiniteTimeAction action2)
{
Debug.Assert(action1 != null);
Debug.Assert(action2 != null);
float d1 = action1.Duration;
float d2 = action2.Duration;
ActionOne = action1;
ActionTwo = action2;
if (d1 > d2)
{
ActionTwo = new Sequence(action2, new DelayTime(d1 - d2));
}
else if (d1 < d2)
{
ActionOne = new Sequence(action1, new DelayTime(d2 - d1));
}
}
void InitFromArray(FiniteTimeAction[] actions, FiniteTimeAction other)
{
var prev = actions[0];
// Can't call base(duration) because we need to calculate duration here
float combinedDuration = 0.0f;
foreach (FiniteTimeAction action in actions)
{
combinedDuration += action.Duration;
}
Duration = combinedDuration;
if (actions.Length == 1)
{
InitSequence(prev, other ?? new ExtraAction());
}
else
{
// Basically what we are doing here is creating a whole bunch of
// nested Sequences from the actions.
int count = other != null ? actions.Length : actions.Length - 1;
for (int i = 1; i < count; i++)
{
prev = new Sequence(prev, actions[i]);
}
if (other != null)
{
InitSequence(prev, other);
}
else
{
InitSequence(prev, actions[actions.Length - 1]);
}
}
}
public EaseElasticOut (FiniteTimeAction action) : base (action, 0.3f)
{
}
public RepeatForever(FiniteTimeAction action)
{
Debug.Assert(action != null);
InnerAction = action;
}
public EaseRateAction(FiniteTimeAction action, float rate) : base(action)
{
Rate = rate;
}
public EaseElastic(FiniteTimeAction action, float period) : base(action)
{
Period = period;
}
public EaseInOut(FiniteTimeAction action, float rate) : base(action, rate)
{
}
public TargetedAction(Node target, FiniteTimeAction action) : base(action.Duration)
{
ForcedTarget = target;
Action = action;
}
public ActionEase(FiniteTimeAction action) : base (action.Duration)
{
InnerAction = action;
}
public Sequence(FiniteTimeAction action1, FiniteTimeAction action2) : base(action1.Duration + action2.Duration)
{
InitSequence(action1, action2);
}
public Sequence(FiniteTimeAction[] actions, FiniteTimeAction other)
{
InitFromArray(actions, other);
}
public EaseElasticInOut(FiniteTimeAction action, float period) : base(action, period)
{
}
public EaseSineOut(FiniteTimeAction action) : base(action)
{
}
public EaseElastic (FiniteTimeAction action) : this (action, 0.3f)
{
}
public EaseElastic (FiniteTimeAction action, float period) : base (action)
{
Period = period;
}
public ReverseTime(FiniteTimeAction action) : base(action.Duration)
{
Other = action;
}
public EaseBackOut (FiniteTimeAction action) : base (action)
{
}
public EaseBounceIn (FiniteTimeAction action) : base (action)
{
}
public EaseCustom(FiniteTimeAction action, Func <float, float> easeFunc) : base(action)
{
EaseFunc = easeFunc;
}
public EaseElasticOut(FiniteTimeAction action) : base(action, 0.3f)
{
}
public Speed (FiniteTimeAction action, float speedValue)
{
InnerAction = action;
SpeedValue = speedValue;
}
public Speed(FiniteTimeAction action, float speedValue)
{
InnerAction = action;
SpeedValue = speedValue;
}
protected Spawn(FiniteTimeAction action1, FiniteTimeAction action2)
: base(Math.Max(action1.Duration, action2.Duration))
{
InitSpawn(action1, action2);
}
public Sequence (FiniteTimeAction action1, FiniteTimeAction action2) : base (action1.Duration + action2.Duration)
{
Actions = new FiniteTimeAction[2];
InitSequence (action1, action2);
}
protected Spawn (FiniteTimeAction action1, FiniteTimeAction action2)
: base (Math.Max (action1.Duration, action2.Duration))
{
InitSpawn (action1, action2);
}
public EaseBackOut(FiniteTimeAction action) : base(action)
{
}
public EaseElastic(FiniteTimeAction action) : this(action, 0.3f)
{
}
public RepeatForever (FiniteTimeAction action)
{
Debug.Assert (action != null);
InnerAction = action;
}
public Sequence(FiniteTimeAction action1, FiniteTimeAction action2) : base(action1.Duration + action2.Duration)
{
Actions = new FiniteTimeAction[2];
InitSequence(action1, action2);
}
public EaseSineInOut (FiniteTimeAction action) : base (action)
{
}
public EaseExponentialOut(FiniteTimeAction action) : base(action)
{
}
public ActionEase(FiniteTimeAction action) : base(action.Duration)
{
InnerAction = action;
}
public EaseElasticOut (FiniteTimeAction action, float period) : base (action, period)
{
}
public EaseCustom (FiniteTimeAction action, Func<float, float> easeFunc) : base (action)
{
EaseFunc = easeFunc;
}
public RepeatForever(params FiniteTimeAction[] actions)
{
Debug.Assert(actions != null);
InnerAction = new Sequence(actions);
}
public TargetedAction (Node target, FiniteTimeAction action) : base (action.Duration)
{
ForcedTarget = target;
Action = action;
}
public EaseOut (FiniteTimeAction action, float rate) : base (action, rate)
{
}
public EaseExponentialInOut (FiniteTimeAction action) : base(action)
{
}
public EaseRateAction (FiniteTimeAction action, float rate) : base (action)
{
Rate = rate;
}
public ReverseTime (FiniteTimeAction action) : base (action.Duration)
{
Other = action;
}
public EaseBounceIn(FiniteTimeAction action) : base(action)
{
}
public RepeatForever (params FiniteTimeAction[] actions)
{
Debug.Assert (actions != null);
InnerAction = new Sequence (actions);
}
