public static Spawn Create(List <FiniteTimeAction> arrayOfActions)
{
Spawn ret = null;
do
{
int count = arrayOfActions.Count;
UnityEngine.Debug.Assert(count > 0);
FiniteTimeAction prev = arrayOfActions[0];
if (count > 1)
{
for (int i = 1; i < arrayOfActions.Count; ++i)
{
prev = createWithTwoActions(prev, arrayOfActions[i]);
}
}
else
{
// If only one action is added to Spawn, make up a Spawn by adding a simplest finite time action.
prev = createWithTwoActions(prev, ExtraAction.Create());
}
ret = (Spawn)prev;
}while (false);
return(ret);
}
static public SequenceAction Create(List <FiniteTimeAction> actionList)
{
SequenceAction ret = null;
do
{
int count = actionList.Count;
if (count == 0)
{
break;
}
FiniteTimeAction prev = actionList[0];
if (count > 1)
{
for (int i = 1; i < count; ++i)
{
prev = CreateWithTwoActions(prev, actionList[i]);
}
}
else
{
// If only one action is added to Sequence, make up a Sequence by adding a simplest finite time action.
prev = CreateWithTwoActions(prev, ExtraAction.Create());
}
ret = (SequenceAction)prev;
}while (false);
return(ret);
}
bool initWithTwoActions(FiniteTimeAction action1, FiniteTimeAction action2)
{
UnityEngine.Debug.Assert(action1 != null, "");
UnityEngine.Debug.Assert(action2 != null, "");
bool ret = false;
float d1 = action1.Duration;
float d2 = action2.Duration;
if (base.InitWithDuration(Mathf.Max(d1, d2)))
{
One = action1;
Two = action2;
if (d1 > d2)
{
Two = SequenceAction.CreateWithTwoActions(action2, DelayTime.Create(d1 - d2));
}
else if (d1 < d2)
{
One = SequenceAction.CreateWithTwoActions(action1, DelayTime.Create(d2 - d1));
}
ret = true;
}
return(ret);
}
static Spawn createWithTwoActions(FiniteTimeAction action1, FiniteTimeAction action2)
{
Spawn spawn = new Spawn();
spawn.initWithTwoActions(action1, action2);
return(spawn);
}
public bool InitWithTwoActions(FiniteTimeAction action1, FiniteTimeAction action2)
{
if (action1 == null || action2 == null)
{
Debug.LogError("Sequence::initWithTwoActions error: action is null!!");
return(false);
}
bool ret = false;
var d1 = action1.Duration;
var d2 = action2.Duration;
if (base.InitWithDuration(Math.Max(d1, d2)))
{
one = action1;
two = action2;
if (d1 > d2)
{
two = Sequence.CreateWithTwoActions(action2, DelayTime.Create(d1 - d2));
}
else if (d1 < d2)
{
one = Sequence.CreateWithTwoActions(action1, DelayTime.Create(d2 - d1));
}
ret = true;
}
return(ret);
}
public static Spawn CreateWithTwoActions(FiniteTimeAction actionOne, FiniteTimeAction actionTwo)
{
Spawn spawn = new Spawn();
if (spawn != null && spawn.InitWithTwoActions(actionOne, actionTwo))
{
return(spawn);
}
return(null);
}
public static Repeat Create(FiniteTimeAction action, uint times)
{
Repeat repeat = new Repeat();
if (repeat != null && repeat.InitWithAction(action, times))
{
return(repeat);
}
return(null);
}
public static Sequence CreateWithTwoActions(FiniteTimeAction actionOne, FiniteTimeAction actionTwo)
{
Sequence sequence = new Sequence();
if (sequence != null && sequence.InitWithTwoActions(actionOne, actionTwo))
{
return(sequence);
}
return(null);
}
//deprecated
public void FlipFinal(float delay = 0f, bool withAnimation = true)
{
/*
#region NEW_ADD
* int sceneIndex = UnityEngine.SceneManagement.SceneManager.GetActiveScene ().buildIndex;
* if (sceneIndex != (int)EScene.SCENE_Demo) {
* return;
* }
#endregion
*/
Vector3 oldPos = transform.position;
if (withAnimation)
{
_flipActionList.Clear();
FiniteTimeAction delayTime = null;
if (delay > 0f)
{
delayTime = DelayTime.Create(delay);
}
//上移
FiniteTimeAction mby = MoveBy.Create(0.2f, Vector3.up * 10f);
//翻过来
FiniteTimeAction mbt1 = RotateBy.Create(0.2f, Vector3.forward, 180f, Space.Self);
//下移到原来的地方
FiniteTimeAction mbt2 = MoveTo.Create(0.2f, oldPos);
FiniteTimeAction mbt3 = MoveTo.Create(0.2f, Vector3.up * 5f);
FiniteTimeAction mbt4 = RotateTo.Create(0.2f, Vector3.zero);
FiniteTimeAction mbt5 = InvokeAction.Create(delegate(GameObject target, object userdata) {
//TableController.Instance.SetCurrentPlayedTile (this);
});
if (delayTime != null)
{
_flipActionList.Add(delayTime);
}
_flipActionList.Add(mby);
_flipActionList.Add(mbt1);
_flipActionList.Add(mbt2);
_flipActionList.Add(mbt3);
_flipActionList.Add(mbt4);
_flipActionList.Add(mbt5);
ActionManager.Instance.RunAction(gameObject, _flipActionList);
}
else
{
//transform.Rotate (Vector3.forward, 180f, Space.Self);
transform.rotation = Quaternion.identity;
transform.position = Vector3.up * 5f;
//TableController.Instance.SetCurrentPlayedTile (this);
}
}
public Spawn InitSpawn()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
_action = new Spawn(GetFiniteActionSet());
return((Spawn)_action);
}
return(null);
}
public ReverseTime InitReverseTime()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
_action = new ReverseTime(GetFiniteActionSet()[0]);
return((ReverseTime)_action);
}
return(null);
}
public EaseSineOut InitSineOut()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
_action = new EaseSineOut(GetFiniteActionSet()[0]);
return((EaseSineOut)_action);
}
return(null);
}
public Repeat InitRepeat()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
_action = new Repeat(GetFiniteActionSet()[0], NumberOfTimes);
return((Repeat)_action);
}
return(null);
}
public RepeatForever InitRepeatForever()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
_action = new RepeatForever(GetFiniteActionSet()[0]);
return((RepeatForever)_action);
}
return(null);
}
/// <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>();
var asyncAction = new Sequence(action, new TaskSource(tcs))
{
CancelAction = s => tcs.TrySetCanceled()
};
Application.Current.ActionManager.AddAction(asyncAction, this);
return(tcs.Task);
}
public EaseIn InitEaseIn()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
_action = new EaseIn(GetFiniteActionSet()[0], Rate);
return((EaseIn)_action);
}
return(null);
}
public EaseElasticOut InitEaseElasticOut()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
_action = new EaseElasticOut(GetFiniteActionSet()[0], Period);
return((EaseElasticOut)_action);
}
return(null);
}
public Parallel InitParallel()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
var actionSet = GetFiniteActionSet();
_action = new Parallel(actionSet);
return((Parallel)_action);
}
return(null);
}
public Sequence InitSequence()
{
if (GetFiniteActionSet().Length > 0)
{
CreateFiniteActionsFromSet();
var actionSet = GetFiniteActionSet();
_action = new Sequence(actionSet);
return((Sequence)_action);
}
return(null);
}
/// <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 bool InitWithAction(FiniteTimeAction action, uint times)
{
if (action != null && base.InitWithDuration(action.Duration * times))
{
this.times = times;
this.innerAction = action;
actionInstant = action is ActionInstance;
total = 0;
return(true);
}
return(false);
}
public void Insert(Vector3 dstPosition, bool isLocal = false)
{
_insertActionList.Clear();
FiniteTimeAction mby = MoveBy.Create(0.1f, Vector3.up * MahjongTile.Thickness, isLocal);
FiniteTimeAction mbt1 = MoveTo.Create(0.2f, dstPosition + Vector3.up * MahjongTile.Thickness, isLocal);
FiniteTimeAction mbt2 = MoveTo.Create(0.1f, dstPosition, isLocal);
_insertActionList.Add(mby);
_insertActionList.Add(mbt1);
_insertActionList.Add(mbt2);
ActionManager.Instance.RunAction(gameObject, _insertActionList);
}
public bool InitWithTwoActions(FiniteTimeAction actionOne, FiniteTimeAction actionTwo)
{
if (actionOne == null || actionTwo == null)
{
Debug.LogError("Sequence::initWithTwoActions error: action is null!!");
return(false);
}
float d = actionOne.Duration + actionTwo.Duration;
base.InitWithDuration(d);
actions[0] = actionOne;
actions[1] = actionTwo;
return(true);
}
static public SequenceAction CreateWithTwoActions(FiniteTimeAction action1, FiniteTimeAction action2)
{
SequenceAction obj = new SequenceAction();
obj.InitWithDuration(0.0f);
UnityEngine.Debug.Assert(action1 != null);
UnityEngine.Debug.Assert(action2 != null);
obj.Duration = action1.Duration + action2.Duration;
obj.mActions[0] = action1;
obj.mActions[1] = action2;
return(obj);
}
/// <summary>
/// Runs an Action that can be awaited.
/// </summary>
/// <param name="action">A FiniteTimeAction.</param>
public Task <ActionState> RunActionsAsync(FiniteTimeAction action)
{
if (!EnsureAppIsActive())
{
return(Task.FromResult <ActionState>(null));
}
var tcs = new TaskCompletionSource <ActionState>();
var asyncAction = new Sequence(action, new TaskSource(tcs))
{
CancelAction = s => tcs.TrySetCanceled()
};
Application.Current.ActionManager.AddAction(asyncAction, this);
return(tcs.Task);
}
public static Spawn Create(FiniteTimeAction action1, params FiniteTimeAction[] args)
{
FiniteTimeAction now;
FiniteTimeAction prev = action1;
bool bOneAction = true;
for (int i = 0; i < args.Length; i++)
{
now = args[i];
prev = CreateWithTwoActions(prev, now);
bOneAction = false;
}
if (bOneAction)
{
prev = CreateWithTwoActions(prev, ExtraAction.Create());
}
return(prev as Spawn);
}
void Flash(Node node, bool enable, FiniteTimeAction flash, FiniteTimeAction stopFlash)
{
//validate
if (!IsRunning)
{
return;
}
if (enable)
{
node.RunActions(flash);
}
else
{
node.RemoveAction(flash);
node.RunActions(stopFlash);
}
}
protected override void OnUpdate(float timeStep)
{
var input = Input;
const float duration = 1f; //2s
FiniteTimeAction action = null;
if (input.GetKeyPress(Key.W))
{
action = new MoveBy(duration, new Vector3(0, 0, 5));
}
if (input.GetKeyPress(Key.S))
{
action = new MoveBy(duration, new Vector3(0, 0, -5));
}
if (input.GetKeyPress(Key.E))
{
action = new FadeIn(duration);
}
if (input.GetKeyPress(Key.Q))
{
action = new FadeOut(duration);
}
if (input.GetKeyPress(Key.R))
{
action = new EaseElasticInOut(new ScaleBy(duration, 1.3f));
}
if (input.GetKeyPress(Key.G))
{
action = new TintTo(duration, NextRandom(1), NextRandom(1), NextRandom(1));
}
if (action != null)
{
//can be awaited
boxNode.RunActionsAsync(action);
}
base.OnUpdate(timeStep);
}
//deprecated
public void Flip(float delay = 0f, bool withAnimation = true)
{
/*
#region NEW_ADD
* int sceneIndex = UnityEngine.SceneManagement.SceneManager.GetActiveScene ().buildIndex;
* if (sceneIndex != (int)EScene.SCENE_Demo) {
* return;
* }
#endregion
*/
Vector3 oldPos = transform.position;
if (withAnimation)
{
_flipActionList.Clear();
FiniteTimeAction delayTime = null;
if (delay > 0f)
{
delayTime = DelayTime.Create(delay);
}
//上移
FiniteTimeAction mby = MoveBy.Create(0.2f, Vector3.up * 10f);
//翻过来
FiniteTimeAction mbt1 = RotateBy.Create(0.2f, Vector3.forward, 180f, Space.Self);
//下移到原来的地方
FiniteTimeAction mbt2 = MoveTo.Create(0.2f, oldPos);
if (delayTime != null)
{
_flipActionList.Add(delayTime);
}
_flipActionList.Add(mby);
_flipActionList.Add(mbt1);
_flipActionList.Add(mbt2);
ActionManager.Instance.RunAction(gameObject, _flipActionList);
}
else
{
transform.Rotate(Vector3.forward, 180f, Space.Self);
}
}
/// <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);
}
