void Condition(out ICondition cond)
{
cond = null; ICondition other = null;
SimpleCondition(out cond);
while (la.kind == 25 || la.kind == 26)
{
if (la.kind == 25)
{
Get();
SimpleCondition(out other);
cond = cond.Intersection(other);
}
else
{
Get();
SimpleCondition(out other);
cond = cond.Union(other);
}
}
cond.Freeze();
if (la.kind == 27)
{
Get();
ICondition rcond;
Condition(out rcond);
rcond.Freeze();
cond = new TransitionCondition(cond, rcond);
cond.Freeze();
}
}
private void AddTransitionCondition()
{
TransitionCondition condition = _section.TransitionConditions.Add();
TransitionConditionBuilder transitionConditionBuilder = new TransitionConditionBuilder(condition);
transitionConditionBuilder.ShowDialog();
}
private TransitionCondition GetTransitionCondition()
{
//Debug.Log("getting transition conditions :: ");
TransitionCondition ret = 0;
if (moveCondition.isGrounded)
{
ret |= TransitionCondition.GROUNDED;
//Debug.Log("getting transition conditions :: grounded");
}
else
{
ret |= TransitionCondition.AERIAL;
}
//ret |= (TransitionCondition)input.buttons;
if (this.CanJump() > 0)
{
ret |= TransitionCondition.CANJUMP;
}
//Debug.Log(ret);
return(ret);
}
/// <summary>
/// Creates a state transition rule, that allows a transition from one state (<paramref name="fromState"/>) to an other state (<paramref name="toState"/>)
/// when a specific <paramref name="condition"/> is fulfilled.
/// </summary>
/// <param name="fromState">Type of the origin state. Type must be a subclass of <see cref="WuProcessState"/>.</param>
/// <param name="toState">Type of the target state. Type must be a subclass of <see cref="WuProcessState"/>.</param>
/// <param name="condition">Condition which must be fulfilled, before the state transition is valid.</param>
public StateTransition(Type fromState, Type toState, TransitionCondition condition) : this(fromState, toState)
{
if (condition != null)
{
Condition = condition;
}
}
public MachineTransition(string from, string to, TransitionCondition condition, int interval = -1)
{
From = from;
To = to;
Condition = condition;
Interval = interval;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="nextState">The state to transition to when the condition satisfied</param>
/// <param name="condition">The callback used to determine when a transition should occur</param>
public StateLink(State nextState, TransitionCondition condition)
{
Assert.IsNotNull(nextState, "StateLink: nextState is null");
Assert.IsNotNull(condition, "StateLink: condition is null");
m_nextState = nextState;
m_condition = condition;
}
/// <summary>
/// [Draft] Initialized constructor
/// </summary>
/// <param name="item">Layout item.</param>
/// <param name="condition">Condition for the position values.</param>
/// <param name="left">Left position.</param>
/// <param name="top">Top position.</param>
/// <param name="right">Right position.</param>
/// <param name="bottom">Bottom position.</param>
public LayoutData(LayoutItem item, TransitionCondition condition, float left, float top, float right, float bottom)
{
Item = item;
ConditionForAnimation = condition;
Left = left;
Top = top;
Right = right;
Bottom = bottom;
}
/// <summary>
/// LayoutTransition constructor.
/// </summary>
/// <param name="condition">The animatable condition.</param>
/// <param name="animatableProperty">the property to animate.</param>
/// <param name="targetValue">target value of the property.</param>
/// <param name="animator">Components to define the animator.</param>
/// <since_tizen> 6 </since_tizen>
public LayoutTransition(TransitionCondition condition,
AnimatableProperties animatableProperty,
object targetValue,
TransitionComponents animator)
{
Condition = condition;
AnimatableProperty = animatableProperty;
Animator = animator;
TargetValue = targetValue;
}
public void RegisterTransition(string fromStateName, string toStateName, TransitionCondition condition)
{
IState fromState;
if( !(states.TryGetValue(fromStateName, out fromState) && states.ContainsKey(toStateName) ) )
return;
if(!transitions.ContainsKey(fromState))
transitions.Add(fromState, new List<StateTransition>());
transitions[fromState].Add(new StateTransition(toStateName, condition));
}
public TransitionCondition GetConditions()
{
int len = Conditions.Count;
TransitionCondition ret = 0;
for (int i = 0; i < len; i++)
{
ret |= Conditions[i];
}
return(ret);
}
/// <summary>
/// 添加状态切换条件，from 不指定时表示任意状态， to 不指定时表示堆栈中的上一次的状态
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="condition"></param>
public void AddTransition(string from, string to, TransitionCondition condition)
{
if (condition == null)
{
return;
}
Transition trans = new Transition();
trans.m_FromState = from;
trans.m_ToState = to;
trans.m_Condition = condition;
m_Transitions.Add(trans);
}
/// <summary>
/// Advance the machine to the next state(s).
/// </summary>
/// <seealso cref="StateMachine{S, A}.Step(A)"/>
/// <param name="letter">The letter used for transitioning.</param>
protected override void Step(A letter)
{
// Perform exit action(s)
foreach (S state in cursors)
{
try {
foreach (S nextState in deltaFunction.Evaluate(state, letter))
{
TransitionCondition condition = nextState.Equals(state) ? TransitionCondition.Self : TransitionCondition.NotSelf;
// Perform exit action(s)
foreach (ActionInfo actionInfo in stateActions.GetEnumerator(state, TransitionDirection.Exit, condition))
{
actionInfo.action.Invoke();
}
foreach (ActionInfo actionInfo in transitionActions.GetEnumerator(state, letter, TransitionDirection.Exit, condition))
{
actionInfo.action.Invoke();
}
// Perform enter action(s)
foreach (ActionInfo actionInfo in stateActions.GetEnumerator(nextState, TransitionDirection.Enter, condition))
{
actionInfo.action.Invoke();
}
foreach (ActionInfo actionInfo in transitionActions.GetEnumerator(nextState, letter, TransitionDirection.Enter, condition))
{
actionInfo.action.Invoke();
}
}
}
catch (UndefinedTransitionException) {
if (!retainCursorOnDeadTransitions)
{
// Perform exit action(s) on dead transitions
foreach (ActionInfo actionInfo in stateActions.GetEnumerator(state, TransitionDirection.Exit, TransitionCondition.NotSelf))
{
actionInfo.action.Invoke();
}
foreach (ActionInfo actionInfo in transitionActions.GetEnumerator(state, letter, TransitionDirection.Exit, TransitionCondition.NotSelf))
{
actionInfo.action.Invoke();
}
}
}
}
// Update the machine
base.Step(letter);
}
/// <summary>
/// Adds the given transition and condition to a transition list.
/// </summary>
/// <param name="targetTransitionList">The list to add the transition to.</param>
/// <param name="condition">Condition for the transition.</param>
/// <param name="transition">The transition to add.</param>
/// <param name="explicitlySet">True is set explicitly, false if inherited.</param>
static public void AddTransitionForCondition(
Dictionary <TransitionCondition, TransitionList> targetTransitionList,
TransitionCondition condition,
LayoutTransition transition,
bool explicitlySet)
{
bool replaced = false;
bool conditionNotInDictionary = false;
TransitionList transitionListMatchingCondition;
if (targetTransitionList.TryGetValue(condition, out transitionListMatchingCondition))
{
if (transitionListMatchingCondition != null)
{
for (var index = 0; index < transitionListMatchingCondition.Count; index++)
{
if (transitionListMatchingCondition[index].AnimatableProperty == transition.AnimatableProperty)
{
if (explicitlySet)
{
transitionListMatchingCondition[index] = transition;
replaced = true;
continue;
}
}
}
}
}
else
{
conditionNotInDictionary = true;
}
if (replaced == false)
{
if (transitionListMatchingCondition == null)
{
transitionListMatchingCondition = new TransitionList();
}
transitionListMatchingCondition.Add(transition);
// Update dictionary with new or replaced entry.
if (conditionNotInDictionary)
{
targetTransitionList.Add(condition, transitionListMatchingCondition); // new entry
}
else
{
targetTransitionList[condition] = transitionListMatchingCondition; // replaced
}
}
}
public void RegisterTransition(string fromStateName, string toStateName, TransitionCondition condition, TransitionType transition = TransitionType.ReplacePreviousState)
{
IState fromState;
if (!(states.TryGetValue(fromStateName, out fromState) && (transition == TransitionType.RemoveCurrentState || states.ContainsKey(toStateName))))
{
return;
}
if (!transitions.ContainsKey(fromState))
{
transitions.Add(fromState, new List <StateTransition>());
}
transitions[fromState].Add(new StateTransition(toStateName, condition, transition));
}
public void UpdateTest()
{
TransitionCondition condition = Substitute.For <TransitionCondition>();
stateMachine.AddTransition(Color.Red, Color.Blue, condition);
stateMachine.Update();
handler.Received().HandleState(Color.Red);
handler.DidNotReceiveWithAnyArgs().OnStateEnter(Color.Red);
handler.DidNotReceiveWithAnyArgs().OnStateExit(Color.Red);
condition.IsFulfilled.Returns(true);
stateMachine.Update();
handler.Received().HandleState(Color.Red);
handler.Received().OnStateExit(Color.Red);
handler.Received().OnStateEnter(Color.Blue);
}
/// <summary>
/// Set all children in a LayoutGroup to the supplied condition.
/// Children with Add or Remove conditions should not be changed.
/// </summary>
private void SetConditionsForAnimationOnLayoutGroup(TransitionCondition conditionToSet)
{
foreach (LayoutItem childLayout in _children)
{
switch (conditionToSet)
{
case TransitionCondition.ChangeOnAdd:
{
// If other children also being added (TransitionCondition.Add) then do not change their
// conditions, Continue to use their Add transitions.
if (childLayout.ConditionForAnimation.HasFlag(TransitionCondition.Add))
{
break; // Child being Added so don't update it's condition
}
else
{
// Set siblings for the child being added to use the ChangeOnAdd transition.
childLayout.ConditionForAnimation = TransitionCondition.ChangeOnAdd;
}
break;
}
case TransitionCondition.ChangeOnRemove:
{
if (childLayout.ConditionForAnimation.HasFlag(TransitionCondition.Remove))
{
break; // Child being Removed so don't update it's condition
}
else
{
childLayout.ConditionForAnimation = TransitionCondition.ChangeOnRemove;
}
break;
}
case TransitionCondition.LayoutChanged:
{
childLayout.ConditionForAnimation = TransitionCondition.LayoutChanged;
break;
}
}
}
}
protected override void GenerateMember(Attachment attachment, StreamWriter stream, string indent)
{
base.GenerateMember(attachment, stream, indent);
TransitionCondition transition = attachment as TransitionCondition;
if (transition == null)
{
return;
}
if (transition.Opl != null)
{
RightValueCsExporter.GenerateClassMember(transition.Opl, stream, indent, "opl");
}
if (transition.Opr2 != null)
{
RightValueCsExporter.GenerateClassMember(transition.Opr2, stream, indent, "opr2");
}
}
/// <summary>
/// Retreive the transition list for the given condition.
/// </summary>
/// <param name="sourceTransitionCollection">The source collection of transition lists to retrieve.</param>
/// <param name="condition">Condition for the transition.</param>
/// <param name="transitionsForCondition">transition list to return as out parameter.</param>
/// <returns>True if a transition list found for the given condition></returns>
static public bool GetTransitionsListForCondition(
Dictionary<TransitionCondition, TransitionList> sourceTransitionCollection,
TransitionCondition condition,
TransitionList transitionsForCondition )
{
TransitionCondition resolvedCondition = condition;
bool matched = false;
// LayoutChanged transitions overrides ChangeOnAdd and ChangeOnRemove as siblings will
// reposition to the new layout not to the insertion/removal of a sibling.
if ((condition & TransitionCondition.LayoutChanged) == TransitionCondition.LayoutChanged)
{
resolvedCondition = TransitionCondition.LayoutChanged;
}
if (sourceTransitionCollection.TryGetValue(resolvedCondition, out transitionsForCondition))
{
matched = true;
}
return matched;
}
public void InputtingExistentValidFile_SetsUpTransitionsCorrectly()
{
Story story = new Story();
SpeechNode speechNode = story.CreateNode("Node1");
SpeechNode destinationNode = story.CreateNode("Node2");
Transition transition = speechNode.CreateTransition(destinationNode);
IntentCondition condition = transition.CreateCondition <IntentCondition>();
condition.IntentName = "TestIntent";
string filePath = Path.Combine(Resources.TempDir, "Test.txt");
SaveStoryBinary(story, filePath);
FileAssert.FileExists(filePath);
Story loadedStory = Story.Load(filePath);
Assert.IsNotNull(loadedStory);
Assert.AreEqual(2, loadedStory.NodeCount);
SpeechNode loadedNode = loadedStory.GetNodeAt(0);
SpeechNode loadedDestinationNode = loadedStory.GetNodeAt(1);
Assert.IsNotNull(loadedNode);
Assert.IsNotNull(loadedDestinationNode);
Assert.AreEqual(1, loadedNode.TransitionCount);
Transition loadedTransition = loadedNode.GetTransitionAt(0);
Assert.AreSame(loadedNode, loadedTransition.Source);
Assert.AreSame(loadedDestinationNode, loadedTransition.Destination);
Assert.AreEqual(1, loadedTransition.ConditionCount);
TransitionCondition loadedCondition = loadedTransition.GetConditionAt(0);
Assert.IsInstanceOfType(loadedCondition, typeof(IntentCondition));
Assert.AreEqual("TestIntent", (loadedCondition as IntentCondition).IntentName);
Assert.AreSame(loadedTransition, loadedCondition.Transition);
}
protected override void GenerateConstructor(Attachment attachment, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(attachment, stream, indent, className);
TransitionCondition transition = attachment as TransitionCondition;
if (transition == null)
{
return;
}
stream.WriteLine("{0}\t\t\tthis.TargetStateId = {1};", indent, transition.TargetFSMNodeId);
if (transition.Opl != null)
{
RightValueCsExporter.GenerateClassConstructor(attachment, transition.Opl, stream, indent, "opl");
}
if (transition.Opr2 != null)
{
RightValueCsExporter.GenerateClassConstructor(attachment, transition.Opr2, stream, indent, "opr2");
}
}
public FSMTransition(FSMState _toState, TransitionCondition _condition)
{
toState = _toState;
condition = _condition;
}
/// <summary>
/// Registers an action to a state.
/// </summary>
/// <param name="state">The target state.</param>
/// <param name="action">The action to be invoked.</param>
/// <param name="direction">The directional constraint.</param>
/// <param name="condition">The conditional constraint.</param>
public void AddStateAction(S state, Action action, TransitionDirection direction = TransitionDirection.Enter, TransitionCondition condition = TransitionCondition.Always)
{
ActionInfo actionInfo = new ActionInfo(action);
stateActions.Add(state, actionInfo, direction, condition);
}
/// <summary>
/// Registers an action to a transition.
/// </summary>
/// <param name="state">The target state.</param>
/// <param name="letter">The target transitioning letter.</param>
/// <param name="action">The action to be invoked.</param>
/// <param name="direction">The directional constraint.</param>
/// <param name="condition">The conditional constraint.</param>
public void AddTransitionAction(S state, A letter, Action action, TransitionDirection direction = TransitionDirection.Exit, TransitionCondition condition = TransitionCondition.Always)
{
ActionInfo actionInfo = new ActionInfo(action);
transitionActions.Add(state, letter, actionInfo, direction, condition);
}
protected override void GenerateMethod(Behaviac.Design.Attachments.Attachment attachment, StreamWriter stream, string indent)
{
base.GenerateMethod(attachment, stream, indent);
TransitionCondition transition = attachment as TransitionCondition;
if (transition == null)
{
return;
}
stream.WriteLine("{0}\t\tprotected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = EBTStatus.BT_SUCCESS;", indent);
{
string typeName = Plugin.GetNativeTypeName(transition.Opl.ValueType);
typeName = typeName.Replace("::", ".");
RightValueCsExporter.GenerateCode(attachment, transition.Opl, stream, indent + "\t\t\t", typeName, "opl", "");
RightValueCsExporter.GenerateCode(attachment, transition.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "");
if (transition.Opl != null && transition.Opl.IsMethod)
{
RightValueCsExporter.PostGenerateCode(transition.Opl, stream, indent + "\t\t\t", typeName, "opl", "");
}
if (transition.Opr2 != null && transition.Opr2.IsMethod)
{
RightValueCsExporter.PostGenerateCode(transition.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "");
}
switch (transition.Operator)
{
case OperatorTypes.Equal:
stream.WriteLine("{0}\t\t\tbool op = (opl == opr2);", indent);
break;
case OperatorTypes.NotEqual:
stream.WriteLine("{0}\t\t\tbool op = (opl != opr2);", indent);
break;
case OperatorTypes.Greater:
stream.WriteLine("{0}\t\t\tbool op = (opl > opr2);", indent);
break;
case OperatorTypes.GreaterEqual:
stream.WriteLine("{0}\t\t\tbool op = (opl >= opr2);", indent);
break;
case OperatorTypes.Less:
stream.WriteLine("{0}\t\t\tbool op = (opl < opr2);", indent);
break;
case OperatorTypes.LessEqual:
stream.WriteLine("{0}\t\t\tbool op = (opl <= opr2);", indent);
break;
default:
stream.WriteLine("{0}\t\t\tbool op = false;", indent);
break;
}
}
stream.WriteLine("{0}\t\t\tif (!op)", indent);
stream.WriteLine("{0}\t\t\t\tresult = EBTStatus.BT_FAILURE;", indent);
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
//this transition algorithm feels very bad, rewrite and organize
private StateFrameData CheckTransitionState(bool timerIsDone, SpaxInput input, StateFrameData srcState)
{
int len = srcState._transitions.Count;
//gets current transition conditions
TransitionCondition curConditions = GetTransitionCondition();
//if the timer is done
if (timerIsDone)
{
curConditions |= TransitionCondition.ON_END;
}
for (int i = 0; i < len; i++)
{
StateFrameData potenState = srcState._transitions[i].Target;
TransitionCondition compare = srcState._transitions[i].GetConditions();
InputCodeFlags inputCond = srcState._transitions[i].inputConditions;
CancelCondition cancelCond = srcState._transitions[i].cancelCondition;
if ((compare & (TransitionCondition.FULL_METER | TransitionCondition.HALF_METER | TransitionCondition.QUART_METER)) == 0)
{
//if all the conditions are met
if ((compare & curConditions) == compare && (cancelCond & this.cancelCondition) == cancelCond)
{
//get the last input change
int fromInput = (int)inputRecorder.GetLatestCode();
//flip 6 and 4 direction, if needed
if (!moveCondition.facingRight)
{
fromInput = InputCode.FlipBackForth(fromInput);
}
bool initialCheck = ((inputCond & (InputCodeFlags)fromInput) == inputCond);
bool freePass = false;
if (!initialCheck && (inputCond & InputCodeFlags.CURRENTLY_HELD) > 0)
{
inputCond ^= InputCodeFlags.CURRENTLY_HELD;
int codeFromInput = (((int)input.direction & 510) << 2) | ((int)input.buttons << 11);
int inputCondSimple = ((int)inputCond >> 3) << 3;
if (!moveCondition.facingRight)
{
codeFromInput = InputCode.FlipBackForth(codeFromInput);
}
freePass = ((codeFromInput & inputCondSimple) == inputCondSimple);
}
//check it
if (inputCond == 0 || initialCheck || freePass)
{
//Debug.Log(compare);
return(AssignNewCurState(potenState));
}
}
}
}
//only really reached if state to transition to isn't found
if (((srcState.stateConditions & StateConditions.NO_PARENT_TRANS) == 0) && (srcState.parentState != null))
{
return(CheckTransitionState(timerIsDone, input, srcState.parentState));
}
return(null);
}
public void AddTransition(TState from, TState to, TransitionCondition condition)
{
transitions[from].Add((to, condition));
}
private void SaveStateMachine()
{
var stateMachine = new StateMachineNode();
NodeUI.StateMachineNodeAsset = new StateMachineNodeAsset {
Data = stateMachine
};
var parameterMap = new Dictionary <ParameterNodeUI, Parameter>();
var stateMap = new Dictionary <StateNodeUI, State>();
var anyStateMap = new Dictionary <AnyStateNodeUI, AnyState>();
var transitionMap = new Dictionary <TransitionInfo, Transition>();
Parameters.Items.Values.ForEach(p =>
{
var parameter = stateMachine.AddParameter(p.Name);
parameter.Type = (ValueProviderType)p.ParameterTypeField.value;
NodeUI.StateMachineNodeAsset.ParameterMap.Add(parameter.Id, new NodeVisualInfo(p.GetPosition().position, p.expanded));
switch (parameter.ValueProvider)
{
case BoolProvider boolProvider:
boolProvider.Value = p.BoolField.value;
break;
case IntProvider intProvider:
intProvider.Value = p.IntField.value;
break;
case FloatProvider floatProvider:
floatProvider.Value = p.FloatField.value;
break;
default:
break;
}
parameterMap.Add(p, parameter);
});
TransitionConnections.ForEach(transitionConnection =>
{
transitionConnection.Transitions.ForEach(transitionInfo =>
{
Transition transition = new Transition()
{
DurationType = transitionInfo.DurationType,
Duration = transitionInfo.Duration,
OffsetType = transitionInfo.OffsetType,
Offset = transitionInfo.Offset,
InterruptionSource = transitionInfo.InterruptionSource,
OrderedInterruption = transitionInfo.OrderedInterruption,
InterruptableByAnyState = transitionInfo.InterruptableByAnyState,
PlayAfterTransition = transitionInfo.PlayAfterTransition
};
stateMachine.Transitions.Add(transition);
transitionMap.Add(transitionInfo, transition);
});
});
States.Items.Values.ForEach(stateNode =>
{
var state = stateMachine.AddState(stateNode.Name);
stateNode.ExitConnections.ForEach(connection =>
{
((TransitionConnectionUI)connection).Transitions.ForEach(transitionInfo =>
{
Transition transition = transitionMap[transitionInfo];
transition.SourceState = state;
state.ExitTransitions.Add(transition);
});
});
stateNode.EntryConnections.ForEach(connection =>
{
if (!(connection is TransitionConnectionUI transitionConnection))
{
return;
}
transitionConnection.Transitions.ForEach(transitionInfo =>
{
Transition transition = transitionMap[transitionInfo];
transition.DestinationState = state;
state.EntryTransitions.Add(transition);
});
});
NodeUI.StateMachineNodeAsset.StateMap.Add(state.Id, new NodeVisualInfo(stateNode.GetPosition().position, stateNode.expanded));
stateMap.Add(stateNode, state);
});
HashSet <AnyStateNodeUI> alreadyAddedAnyStates = new HashSet <AnyStateNodeUI>();
if (GraphView.AnyStatePriorityManager == null)
{
NodeUI.StateMachineNodeAsset.AnyStatePriorityManager = null;
}
else
{
NodeUI.StateMachineNodeAsset.AnyStatePriorityManager = new NodeVisualInfo(GraphView.AnyStatePriorityManager.GetPosition().position, GraphView.AnyStatePriorityManager.expanded);
foreach (var anyStateNode in GraphView.AnyStatePriorityManager.AnyStates)
{
if (anyStateNode == null)
{
continue;
}
AnyState anyState = anyStateNode.GenerateData(stateMap);
anyStateNode.ExitConnections.ForEach(connection =>
{
((TransitionConnectionUI)connection).Transitions.ForEach(transitionInfo =>
{
Transition transition = transitionMap[transitionInfo];
transition.SourceState = anyState;
anyState.ExitTransitions.Add(transition);
});
});
stateMachine.AnyStates.AddItem(anyState);
NodeUI.StateMachineNodeAsset.AnyStateMap.Add(anyState.Id, new NodeVisualInfo(anyStateNode.GetPosition().position, anyStateNode.expanded));
alreadyAddedAnyStates.Add(anyStateNode);
anyStateMap.Add(anyStateNode, anyState);
}
}
AnyStates.Items.Values.ForEach(anyStateNode =>
{
if (alreadyAddedAnyStates.Contains(anyStateNode))
{
return;
}
AnyState anyState = anyStateNode.GenerateData(stateMap);
anyStateNode.ExitConnections.ForEach(connection =>
{
((TransitionConnectionUI)connection).Transitions.ForEach(transitionInfo =>
{
Transition transition = transitionMap[transitionInfo];
transition.SourceState = anyState;
anyState.ExitTransitions.Add(transition);
});
});
stateMachine.AnyStates.AddItem(anyState);
NodeUI.StateMachineNodeAsset.AnyStateMap.Add(anyState.Id, new NodeVisualInfo(anyStateNode.GetPosition().position, anyStateNode.expanded));
anyStateMap.Add(anyStateNode, anyState);
});
TransitionConnections.ForEach(transitionConnection =>
{
transitionConnection.Transitions.ForEach(transitionInfo =>
{
Transition transition = transitionMap[transitionInfo];
transition.Conditions.Capacity = transitionInfo.Conditions.Count;
transitionInfo.Conditions.ForEach(infoCondition =>
{
TransitionCondition condition = new TransitionCondition();
if (infoCondition.ProviderSourceType == ValueProviderSourceType.State)
{
if (infoCondition.State != null)
{
State state = stateMap[infoCondition.State];
switch (infoCondition.StateValueProvider)
{
case StateValueProviders.PreviousTime:
condition.SetValueProvider(state.PreviousTime);
break;
case StateValueProviders.Time:
condition.SetValueProvider(state.Time);
break;
case StateValueProviders.PreviousNormalizedTime:
condition.SetValueProvider(state.PreviousNormalizedTime);
break;
case StateValueProviders.NormalizedTime:
condition.SetValueProvider(state.NormalizedTime);
break;
}
FloatConditionEvaluator floatEvaluator = (FloatConditionEvaluator)condition.Evaluator;
floatEvaluator.Comparison = infoCondition.FloatComparison;
floatEvaluator.ComparisonValue = infoCondition.FloatComparisonValue;
}
}
else if (infoCondition.Parameter != null)
{
condition.SetValueProvider(parameterMap[infoCondition.Parameter].ValueProvider);
switch (condition.Evaluator)
{
case BoolConditionEvaluator boolEvaluator:
boolEvaluator.ComparisonValue = infoCondition.BoolComparisonValue ? Bool.True : Bool.False;
break;
case IntConditionEvaluator intEvaluator:
intEvaluator.Comparison = infoCondition.IntComparison;
intEvaluator.ComparisonValue = infoCondition.IntComparisonValue;
break;
case FloatConditionEvaluator floatEvaluator:
floatEvaluator.Comparison = infoCondition.FloatComparison;
floatEvaluator.ComparisonValue = infoCondition.FloatComparisonValue;
break;
default:
break;
}
}
transition.Conditions.Add(condition);
});
});
});
GraphView.EntryNode.GenerateData(stateMachine, stateMap);
NodeUI.StateMachineNodeAsset.EntryState = new NodeVisualInfo(GraphView.EntryNode.GetPosition().position, GraphView.EntryNode.expanded);
NodeUI.UpdateStatePorts();
}
public StateTransition(string desiredState, TransitionCondition condition)
{
this.desiredState = desiredState;
this.condition = condition;
}
protected override void GenerateMethod(Behaviac.Design.Attachments.Attachment attachment, StreamWriter stream, string indent)
{
base.GenerateMethod(attachment, stream, indent);
TransitionCondition transition = attachment as TransitionCondition;
if (transition == null)
{
return;
}
stream.WriteLine("{0}\t\tvirtual EBTStatus update_impl(Agent* pAgent, EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(pAgent);", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(childStatus);", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = BT_SUCCESS;", indent);
{
string typeName = Plugin.GetNativeTypeName(transition.Opl.ValueType);
RightValueCppExporter.GenerateCode(attachment, transition.Opl, stream, indent + "\t\t\t", typeName, "opl", "");
RightValueCppExporter.GenerateCode(attachment, transition.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "");
if (transition.Opl != null && transition.Opl.IsMethod)
{
RightValueCppExporter.PostGenerateCode(transition.Opl, stream, indent + "\t\t\t", typeName, "opl", "");
}
if (transition.Opr2 != null && transition.Opr2.IsMethod)
{
RightValueCppExporter.PostGenerateCode(transition.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "");
}
switch (transition.Operator)
{
case OperatorTypes.Equal:
stream.WriteLine("{0}\t\t\tbool op = Details::Equal(opl, opr2);", indent);
break;
case OperatorTypes.NotEqual:
stream.WriteLine("{0}\t\t\tbool op = !Details::Equal(opl, opr2);", indent);
break;
case OperatorTypes.Greater:
stream.WriteLine("{0}\t\t\tbool op = Details::Greater(opl, opr2);", indent);
break;
case OperatorTypes.GreaterEqual:
stream.WriteLine("{0}\t\t\tbool op = Details::GreaterEqual(opl, opr2);", indent);
break;
case OperatorTypes.Less:
stream.WriteLine("{0}\t\t\tbool op = Details::Less(opl, opr2);", indent);
break;
case OperatorTypes.LessEqual:
stream.WriteLine("{0}\t\t\tbool op = Details::LessEqual(opl, opr2);", indent);
break;
default:
stream.WriteLine("{0}\t\t\tbool op = false;", indent);
break;
}
}
stream.WriteLine("{0}\t\t\tif (!op)", indent);
stream.WriteLine("{0}\t\t\t\tresult = BT_FAILURE;", indent);
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
public void RegisterTransition(string fromStateName, string toStateName, TransitionCondition condition, TransitionType transition = TransitionType.ReplacePreviousState)
{
IState fromState;
if( !(states.TryGetValue(fromStateName, out fromState) && (transition == TransitionType.RemoveCurrentState || states.ContainsKey(toStateName)) ) )
return;
if(!transitions.ContainsKey(fromState))
transitions.Add(fromState, new List<StateTransition>());
transitions[fromState].Add(new StateTransition(toStateName, condition, transition));
}
public Entry(V value, TransitionDirection direction, TransitionCondition condition)
{
this.value = value;
this.direction = direction;
this.condition = condition;
}
public FSMTransition(FSMState _toState, TransitionCondition _condition)
{
toState = _toState;
condition = _condition;
}
public StateTransition(States source, States target, TransitionCondition condition)
{
this.source = source;
this.target = target;
this.Condition = condition;
}
/// <summary>
/// Sets up the main animation with the animators for each item (each layoutPositionData structure)
/// </summary>
private void AddAnimatorsToAnimation(LayoutData layoutPositionData)
{
LayoutTransition positionTransition = new LayoutTransition();
LayoutTransition sizeTransition = new LayoutTransition();
TransitionCondition conditionForAnimators = layoutPositionData.ConditionForAnimation;
// LayoutChanged transitions overrides ChangeOnAdd and ChangeOnRemove as siblings will
// reposition to the new layout not to the insertion/removal of a sibling.
if (layoutPositionData.ConditionForAnimation.HasFlag(TransitionCondition.LayoutChanged))
{
conditionForAnimators = TransitionCondition.LayoutChanged;
}
// Set up a default transitions, will be overwritten if inherited from parent or set explicitly.
TransitionComponents positionTransitionComponents = CreateDefaultTransitionComponent(0, 300);
TransitionComponents sizeTransitionComponents = CreateDefaultTransitionComponent(0, 300);
bool matchedCustomTransitions = false;
TransitionList transitionsForCurrentCondition = new TransitionList();
// Note, Transitions set on View rather than LayoutItem so if the Layout changes the transition persist.
// Check if item to animate has it's own Transitions for this condition.
// If a key exists then a List of at least 1 transition exists.
if (layoutPositionData.Item.Owner.LayoutTransitions.ContainsKey(conditionForAnimators))
{
// Child has transitions for the condition
matchedCustomTransitions = layoutPositionData.Item.Owner.LayoutTransitions.TryGetValue(conditionForAnimators, out transitionsForCurrentCondition);
}
if (!matchedCustomTransitions)
{
// Inherit parent transitions as none already set on View for the condition.
ILayoutParent layoutParent = layoutPositionData.Item.GetParent();
if (layoutParent != null)
{
// Item doesn't have it's own transitions for this condition so copy parents if
// has a parent with transitions.
LayoutGroup layoutGroup = layoutParent as LayoutGroup;
TransitionList parentTransitionList;
// Note TryGetValue returns null if key not matched.
if (layoutGroup != null && layoutGroup.Owner.LayoutTransitions.TryGetValue(conditionForAnimators, out parentTransitionList))
{
// Copy parent transitions to temporary TransitionList. List contains transitions for the current condition.
LayoutTransitionsHelper.CopyTransitions(parentTransitionList,
transitionsForCurrentCondition);
}
}
}
// Position/Size transitions can be displayed for a layout changing to another layout or an item being added or removed.
// There can only be one position transition and one size position, they will be replaced if set multiple times.
// transitionsForCurrentCondition represent all non position (custom) properties that should be animated.
// Search for Position property in the transitionsForCurrentCondition list of custom transitions,
// and only use the particular parts of the animator as custom transitions should not effect all parameters of Position.
// Typically Delay, Duration and Alphafunction can be custom.
FindAndReplaceAnimatorComponentsForProperty(transitionsForCurrentCondition,
AnimatableProperties.Position,
ref positionTransitionComponents);
// Size
FindAndReplaceAnimatorComponentsForProperty(transitionsForCurrentCondition,
AnimatableProperties.Size,
ref sizeTransitionComponents);
// Add animators to the core Animation,
SetupAnimationForCustomTransitions(transitionsForCurrentCondition, layoutPositionData.Item.Owner);
SetupAnimationForPosition(layoutPositionData, positionTransitionComponents);
SetupAnimationForSize(layoutPositionData, sizeTransitionComponents);
// Dispose components
positionTransitionComponents.Dispose();
sizeTransitionComponents.Dispose();
}
public void RegisterTransitionToPrevious(string stateName, TransitionCondition condition)
{
RegisterTransition(stateName, "previous", condition, TransitionType.RemoveCurrentState);
}