public void SetTransitionPropertyAsymType(TransitionProperty property, TransitionType asymType, params float[] plist)
{
Transition transition = transitions[(int)property];
if (transition != null)
{
transition.type = asymType;
switch (asymType)
{
case TransitionType.ASYMETRIC_INFLECTED:
transition.SetAsymInflectedData((int)plist[0], (int)plist[1], (int)plist[2], (int)plist[3],
plist[4], plist[5], plist[6], plist[7]);
break;
case TransitionType.ASYMETRIC_NORMALISED:
transition.SetAsymNormalisedData((int)plist[0], (int)plist[1], plist[2]);
break;
case TransitionType.SYMMETRIC_INFLECTED:
transition.SetSymmInflectedData((int)plist[0], (int)plist[1], plist[2]);
break;
default:
break;
}
}
}
public void SetStartAndDestRotationEulerAngles(GameObject go, Vector3 startEulerAngles, Vector3 destEulerAngles)
{
TransitionProperty property = TransitionProperty.RotationEulerAngles;
Transition transition = transitions[(int)TransitionProperty.RotationEulerAngles];
TransitionParams td = go.GetComponent <TransitionParams>();
td.startRotationEulerAngles = startEulerAngles;
td.destRotationEulerAngles = destEulerAngles;
bool containsKey = propTransDict.ContainsKey(property);
if (startEulerAngles == destEulerAngles)
{
if (containsKey)
{
propTransDict.Remove(property);
}
}
else
{
if (!containsKey && transition != null)
{
propTransDict.Add(property, transition);
}
}
}
public void SetTransitionPropertyType(TransitionProperty property, TransitionType type, int power)
{
Transition transition = transitions[(int)property];
if (transition != null)
{
transition.type = type;
transition.power = power;
}
}
public void AddPropertyToDictionary(TransitionProperty property)
{
bool containsKey = propTransDict.ContainsKey(property);
if (!containsKey)
{
Transition transition = transitions[(int)property];
propTransDict.Add(property, transition);
}
}
public Transition(TransitionProperty type, bool addTransitionParams, params GameObject[] gObjects)
{
this.property = type;
gameObjects = new GameObject[gObjects.Length];
for (int i = 0; i < gObjects.Length; i++)
{
gameObjects[i] = gObjects[i];
}
if (addTransitionParams)
{
for (int i = 0; i < gObjects.Length; i++)
{
gameObjects[i].AddComponent <TransitionParams>();
}
}
}
public void SetStartAndDestProperty(GameObject go, TransitionProperty property, float start, float dest)
{
if (property == TransitionProperty.Position ||
property == TransitionProperty.RotationEulerAngles)
{
return;
}
Transition transition = null;
TransitionParams tp = go.GetComponent <TransitionParams>();
switch (property)
{
case TransitionProperty.Scale:
transition = transitions[(int)TransitionProperty.Scale];
tp.startScale = start;
tp.destScale = dest;
tp.gameObject.transform.localScale = new Vector3(start, start, 1.0f);
break;
case TransitionProperty.Alpha:
transition = transitions[(int)TransitionProperty.Alpha];
tp.startAlpha = start;
tp.destAlpha = dest;
Utils.SetSpriteAlpha(tp.gameObject, start);
break;
default:
break;
}
bool containsKey = propTransDict.ContainsKey(property);
if (start == dest)
{
if (containsKey && transition.gameObjects.Length == 1)
{
propTransDict.Remove(property);
}
}
else
{
if (!containsKey && transition != null)
{
propTransDict.Add(property, transition);
}
}
}
/// <summary>
/// Compute the transitive closure (i.e. the list of states) which can be reached from the
/// start state by following transitions with the given property.
/// </summary>
/// <param name="startState">The state at which to start the computation.</param>
/// <param name="includeStartState">Whether or not the start state is included in the result.</param>
/// <param name="prop">The property a transition must fulfill to be followed further.</param>
/// <returns>A list of state IDs</returns>
private List <int> ComputeStateClosure(int startState,
bool includeStartState,
TransitionProperty prop)
{
List <int> result = new List <int>();
List <int> statesToCheck = new List <int>();
statesToCheck.Add(startState);
while (statesToCheck.Count > 0)
{
int p;
int s = statesToCheck[0];
statesToCheck.RemoveAt(0);
p = result.BinarySearch(s);
System.Diagnostics.Debug.Assert(p < 0);
if (s != _StartState || includeStartState)
{
result.Insert(~p, s);
}
foreach (FSTTransition t in _States[s].Transitions)
{
if (prop(t))
{
int targetState = t.Target;
// targetState is reachable through a transition which fulfills the property - add
// to list of states to visit
if (result.BinarySearch(targetState) < 0 && ((p = statesToCheck.BinarySearch(targetState)) < 0))
{
statesToCheck.Insert(~p, targetState);
}
}
}
}
return(result);
}
get => (TransitionType)GetValue(TransitionProperty); set => SetValue(TransitionProperty, value);
set => SetValue(TransitionProperty, value);
