public AnyState GenerateData(Dictionary <StateNodeUI, State> stateMap)
{
var anyState = new AnyState()
{
Name = Name
};
foreach (var filter in _filters)
{
anyState.StateFilters.Add(new AnyStateFilter {
State = filter.State == null ? null : stateMap[filter.State], Mode = filter.Mode
});
}
foreach (var element in outputContainer.Children())
{
if (!(element is Port port))
{
continue;
}
anyState.ExitTransitions.Add(null);
}
return(anyState);
}
private void Update()
{
if (isPaused || isDisabled)
{
return;
}
if (ActiveNode != null)
{
if (!ActiveNode.IsEntered)
{
ActiveNode.OnEnter();
}
else if (!ActiveNode.IsFinished)
{
ActiveNode.OnUpdate();
UpdateChanges(ActiveNode);
}
}
if (AnyState != null)
{
if (!AnyState.IsEntered)
{
AnyState.OnEnter();
}
else if (!AnyState.IsFinished)
{
AnyState.OnUpdate();
UpdateChanges(AnyState);
}
}
}
public void SetAIController()
{
enabled = (originalController != null && originalController.states.Count > 0);
if (enabled) {
triggers= new List<BaseTrigger>();
attributes= new List<BaseAttribute>();
controller=(AIController)ScriptableObject.Instantiate(originalController);
for(int i=0;i<controller.parameters.Count;i++)
{
controller.parameters[i]=(NamedParameter)ScriptableObject.Instantiate(controller.parameters[i]);
controller.parameters[i].OnChangeParameter = OnChangeParameter;
}
for(int i=0;i< controller.states.Count;i++)
{
controller.states[i]=(State)ScriptableObject.Instantiate(controller.states[i]);
controller.states[i].Initialize(this);
if(controller.states[i] is BaseTrigger){
triggers.Add(controller.states[i] as BaseTrigger);
}
if(controller.states[i] is OnAttributeChanged){
attributes.Add((controller.states[i] as OnAttributeChanged).attribute);
}
}
currentStateIndex= controller.states.FindIndex (state => state.isDefaultState == true);
anyState = (AnyState)controller.states.Find (state => state.GetType() == typeof(AnyState));
}
}
public static void CreateStateMachine()
{
FsmEditor.ShowWindow();
StateMachine stateMachine = AssetCreator.CreateAsset <StateMachine> (true);
if (stateMachine == null)
{
return;
}
stateMachine.color = (int)NodeColor.Blue;
stateMachine.Name = stateMachine.name;
FsmGameObject gameObject = ScriptableObject.CreateInstance <FsmGameObject> ();
gameObject.Name = "Owner";
gameObject.hideFlags = HideFlags.HideInHierarchy;
gameObject.IsHidden = true;
gameObject.IsShared = true;
stateMachine.Variables = ArrayUtility.Add <FsmVariable> (stateMachine.Variables, gameObject);
AssetDatabase.AddObjectToAsset(gameObject, stateMachine);
AssetDatabase.SaveAssets();
AnyState state = FsmEditorUtility.AddNode <AnyState> (FsmEditor.Center, stateMachine);
state.color = (int)NodeColor.Aqua;
state.Name = "Any State";
FsmEditor.SelectStateMachine(stateMachine);
}
private void Awake()
{
enabled = (originalController != null && originalController.states.Count > 0);
if (enabled)
{
triggers = new List <BaseTrigger>();
attributes = new List <BaseAttribute>();
controller = (AIController)ScriptableObject.Instantiate(originalController);
for (int i = 0; i < controller.parameters.Count; i++)
{
controller.parameters[i] = (NamedParameter)ScriptableObject.Instantiate(controller.parameters[i]);
}
for (int i = 0; i < controller.states.Count; i++)
{
controller.states[i] = (State)ScriptableObject.Instantiate(controller.states[i]);
controller.states[i].Initialize(this);
if (controller.states[i] is BaseTrigger)
{
triggers.Add(controller.states[i] as BaseTrigger);
}
if (controller.states[i] is OnAttributeChanged)
{
attributes.Add((controller.states[i] as OnAttributeChanged).attribute);
}
}
currentStateIndex = controller.states.FindIndex(state => state.isDefaultState == true);
anyState = (AnyState)controller.states.Find(state => state.GetType() == typeof(AnyState));
}
}
static void CreateAIController()
{
AIController controller = CreateAssetAtSelectionPath <AIController> ();
EntryState entryState = ScriptableObject.CreateInstance <EntryState> ();
entryState.position = new Vector2(0, 0);
entryState.name = "Entry";
AnyState anyState = ScriptableObject.CreateInstance <AnyState> ();
anyState.position = new Vector2(0, 200);
anyState.name = "Any";
controller.entryState = entryState;
controller.anyState = anyState;
#if SERIALIZER_DEBUG
Debug.Log("Controller [" + controller.name + "] created.");
#endif
AddNewNodeToController(controller, entryState, false);
AddNewNodeToController(controller, anyState, false);
Save();
}
public void LoadData(GraphView graphView, AnyState anyState, Dictionary <State, StateNodeUI> map)
{
anyState.StateFilters.ForEach(filter =>
{
_filters.Add(new AnyStateFilterItem {
State = filter.State == null ? null : map[filter.State], Mode = filter.Mode
});
});
_filterList.List.Refresh();
}
private void SelectStateMachine()
{
GUIContent content = new GUIContent(FsmEditor.Active != null?FsmEditor.Active.Name:"[None Selected]");
float width = EditorStyles.toolbarDropDown.CalcSize(content).x;
width = Mathf.Clamp(width, 100f, width);
if (GUILayout.Button(content, EditorStyles.toolbarDropDown, GUILayout.Width(width)))
{
GenericMenu toolsMenu = new GenericMenu();
if (FsmEditor.ActiveGameObject != null)
{
foreach (ICodeBehaviour behaviour in FsmEditor.ActiveGameObject.GetComponents <ICodeBehaviour>())
{
SelectStateMachineMenu(behaviour.stateMachine, ref toolsMenu);
}
}
else if (FsmEditor.Active != null)
{
SelectStateMachineMenu(FsmEditor.Active.Root, ref toolsMenu);
}
toolsMenu.AddItem(new GUIContent("[Create New]"), false, delegate() {
StateMachine stateMachine = AssetCreator.CreateAsset <StateMachine> (true);
if (stateMachine != null)
{
stateMachine.Name = stateMachine.name;
AnyState state = FsmEditorUtility.AddNode <AnyState> (FsmEditor.Center, stateMachine);
state.color = (int)NodeColor.Aqua;
state.Name = "Any State";
FsmGameObject gameObject = ScriptableObject.CreateInstance <FsmGameObject> ();
gameObject.Name = "Owner";
gameObject.hideFlags = HideFlags.HideInHierarchy;
gameObject.IsHidden = true;
gameObject.IsShared = true;
stateMachine.Variables = ArrayUtility.Add <FsmVariable> (stateMachine.Variables, gameObject);
AssetDatabase.AddObjectToAsset(gameObject, stateMachine);
AssetDatabase.SaveAssets();
FsmEditor.SelectStateMachine(stateMachine);
}
});
toolsMenu.ShowAsContext();
}
}
public void Execute()
{
var graph = stateMachine.GetStateMachineGraph();
//Create the rect of the state (for the graph)
var rect = new Rect(0, 0, 120, 60);
rect.x = this.position.x - rect.width / 2;
rect.y = this.position.y - rect.height / 2;
var anyState = new AnyState()
{
Rect = rect,
ID = graph.GetUniqueAnyStateName()
};
Undo.RecordObject(this.stateMachine, "Added anyState");
graph.TryAddNode(anyState);
}
private void SwitchNode(Node toNode)
{
if (toNode == null)
{
return;
}
if (ActiveNode != null)
{
ActiveNode.OnExit();
}
ActiveNode = toNode;
if (this.ActiveNode != null && this.ActiveNode.Parent != this.AnyState.Parent)
{
this.AnyState.OnExit();
this.AnyState = this.ActiveNode.Parent.GetAnyState();
this.AnyState.OnEnter();
}
switchToNode = null;
ActiveNode.OnEnter();
}
public void EnableStateMachine()
{
if (stateMachine == null)
{
enabled = false;
return;
}
if (!stateMachine.IsInitialized)
{
stateMachine = (StateMachine)FsmUtility.Copy(stateMachine);
stateMachine.Init(this);
}
if (!isPaused)
{
this.ActiveNode = stateMachine.GetStartNode();
this.AnyState = stateMachine.GetAnyState();
}
isPaused = false;
isDisabled = false;
enabled = true;
}
public static T AddNode <T>(Vector2 position, StateMachine parent)
{
if (parent == null)
{
Debug.LogWarning("Can't add node to parent state machine, because the parent state machine is null!");
return(default(T));
}
Node node = (Node)ScriptableObject.CreateInstance(typeof(T));
node.hideFlags = HideFlags.HideInHierarchy;
node.Name = FsmEditorUtility.GenerateUniqueNodeName <T> (parent.Root);
node.Parent = parent;
parent.Nodes = ArrayUtility.Add <Node> (parent.Nodes, node);
node.position = new Rect(position.x, position.y, FsmEditorStyles.StateWidth, FsmEditorStyles.StateHeight);
UpdateNodeColor(node);
if (EditorUtility.IsPersistent(parent))
{
AssetDatabase.AddObjectToAsset(node, parent);
}
if (node.GetType() == typeof(StateMachine))
{
node.position.width = FsmEditorStyles.StateMachineWidth;
node.position.height = FsmEditorStyles.StateMachineHeight;
AnyState state = FsmEditorUtility.AddNode <AnyState> (FsmEditor.Center, (StateMachine)node);
UpdateNodeColor(state);
state.Name = "Any State";
}
AssetDatabase.SaveAssets();
return((T)(object)node);
}
public static void Paste(Vector2 position, StateMachine stateMachine)
{
List <Node> copiedNodes = new List <Node> ();
Vector2 center = GetCenter(nodes);
for (int i = 0; i < nodes.Count; i++)
{
Node origNode = nodes[i];
List <FsmVariable> sharedVariables = new List <FsmVariable>();
GetSharedVariables(origNode, ref sharedVariables);
if (sharedVariables.Count > 0)
{
string variableNames = string.Empty;
sharedVariables.Select(x => x.Name).ToList().ForEach(y => variableNames = (variableNames + (string.IsNullOrEmpty(variableNames)?"":",") + y));
if (EditorUtility.DisplayDialog("Paste Variables", "Copied states have reference to shared variables, do you want to paste those variables? (" + variableNames + ")", "Yes", "No"))
{
for (int j = 0; j < sharedVariables.Count; j++)
{
FsmVariable variable = sharedVariables[j];
stateMachine.SetVariable(variable.Name, variable.GetValue());
}
}
}
Node mNode = (Node)FsmUtility.Copy(origNode);
mNode.Parent = stateMachine;
mNode.hideFlags = HideFlags.HideInHierarchy;
if (mNode.IsStartNode && stateMachine.GetStartNode() != null)
{
mNode.IsStartNode = false;
}
//mNode.Name = FsmEditorUtility.GenerateUniqueNodeName(mNode.GetType(),stateMachine);
stateMachine.Nodes = ArrayUtility.Add <Node> (stateMachine.Nodes, mNode);
mNode.position = new Rect(-(center.x - origNode.position.x) + position.x, -(center.y - origNode.position.y) + position.y, FsmEditorStyles.StateWidth, FsmEditorStyles.StateHeight);
if (mNode.GetType() == typeof(StateMachine))
{
mNode.position.width = FsmEditorStyles.StateMachineWidth;
mNode.position.height = FsmEditorStyles.StateMachineHeight;
}
FsmEditorUtility.UpdateNodeColor(mNode);
copiedNodes.Add(mNode);
}
for (int i = 0; i < copiedNodes.Count; i++)
{
Node mNode = copiedNodes [i];
if (mNode is AnyState)
{
bool mOverride = EditorUtility.DisplayDialog("Override AnyState", "AnyState can only exist once per state machine. Do you want to override it?", "Yes", "No");
AnyState anyState = stateMachine.Nodes.ToList().Find(x => x.GetType() == typeof(AnyState) && (mOverride && x != mNode || !mOverride && x == mNode)) as AnyState;
stateMachine.Nodes = ArrayUtility.Remove(stateMachine.Nodes, anyState);
FsmEditorUtility.DestroyImmediate(anyState);
FsmEditor.SelectedNodes.Clear();
}
}
for (int i = 0; i < copiedNodes.Count; i++)
{
Node mNode = copiedNodes[i];
foreach (Transition transition in mNode.Transitions)
{
Node toNode = copiedNodes.Find(x => x.Name == transition.ToNode.Name) ?? stateMachine.Nodes.ToList().Find(x => x.Name == transition.ToNode.Name);
if (toNode != null)
{
transition.ToNode = toNode;
}
else
{
FsmEditorUtility.DestroyImmediate(transition);
mNode.Transitions = ArrayUtility.Remove(mNode.Transitions, transition);
}
}
}
for (int i = 0; i < copiedNodes.Count; i++)
{
Node mNode = stateMachine.Nodes.ToList().Find(x => x.Name == copiedNodes[i].Name && x != copiedNodes[i]);
if (mNode != null)
{
copiedNodes[i].Name = FsmEditorUtility.GenerateUniqueNodeName(copiedNodes[i].GetType(), stateMachine);
}
}
FsmEditorUtility.ParentChilds(stateMachine);
nodes.Clear();
EditorUtility.SetDirty(stateMachine);
ErrorChecker.CheckForErrors();
}
public void LoadStateMachine(StateMachineNodeUI stateMachineUI)
{
CreateGraphView();
void SetNodePositionAndExpansion(Node node, NodeVisualInfo info)
{
node.SetPosition(new Rect(info.Position, Vector2.zero));
node.expanded = info.IsExpanded;
}
NodeUI = stateMachineUI;
var stateMachine = (StateMachineNode)stateMachineUI.StateMachineNodeAsset.Data;
var parameterMap = new Dictionary <Parameter, ParameterNodeUI>();
var valueProviderMap = new Dictionary <IValueProvider, StateMachineBaseNodeUI>();
foreach (var parameter in stateMachine.Parameters.Values)
{
var parameterNode = new ParameterNodeUI();
GraphView.AddNode(parameterNode);
SetNodePositionAndExpansion(parameterNode, stateMachineUI.StateMachineNodeAsset.ParameterMap[parameter.Id]);
parameterNode.LoadData(parameter);
parameterMap.Add(parameter, parameterNode);
valueProviderMap.Add(parameter.ValueProvider, parameterNode);
}
var stateToNodeMap = new Dictionary <State, StateNodeUI>();
var nodeToStateMap = new Dictionary <StateNodeUI, State>();
for (int i = 0; i < stateMachine.States.Count; i++)
{
string stateName = stateMachine.States.KeyAt(i);
State state = stateMachine.States.At(i);
var stateNode = new StateNodeUI();
stateNode.Name = stateName;
GraphView.AddNode(stateNode);
SetNodePositionAndExpansion(stateNode, stateMachineUI.StateMachineNodeAsset.StateMap[state.Id]);
stateToNodeMap.Add(state, stateNode);
nodeToStateMap.Add(stateNode, state);
valueProviderMap.Add(state.Time, stateNode);
valueProviderMap.Add(state.PreviousTime, stateNode);
valueProviderMap.Add(state.NormalizedTime, stateNode);
valueProviderMap.Add(state.PreviousNormalizedTime, stateNode);
}
var anyStateMap = new Dictionary <AnyState, AnyStateNodeUI>();
for (int i = 0; i < stateMachine.AnyStates.Items.Count; i++)
{
string anyStateName = stateMachine.AnyStates.Items.KeyAt(i);
AnyState anyState = stateMachine.AnyStates.Items.At(i);
//if (anyState == null) { continue; }
var anyStateNode = new AnyStateNodeUI();
anyStateNode.Name = anyStateName;
GraphView.AddNode(anyStateNode);
SetNodePositionAndExpansion(anyStateNode, stateMachineUI.StateMachineNodeAsset.AnyStateMap[anyState.Id]);
anyStateNode.LoadData(GraphView, anyState, stateToNodeMap);
anyStateMap.Add(anyState, anyStateNode);
foreach (var transition in anyState.ExitTransitions)
{
var transitionConnection = (TransitionConnectionUI)CreateConnection(anyStateNode, stateToNodeMap[transition.DestinationState], false);
LoadTransitionInfo(transitionConnection.Transitions[transitionConnection.Transitions.Count - 1], transition);
}
}
if (NodeUI.StateMachineNodeAsset.AnyStatePriorityManager != null)
{
var anyStatePriorityManagerNode = new AnyStatePriorityManagerNodeUI();
GraphView.AddNode(anyStatePriorityManagerNode);
SetNodePositionAndExpansion(anyStatePriorityManagerNode, stateMachineUI.StateMachineNodeAsset.AnyStatePriorityManager);
anyStatePriorityManagerNode.LoadData(GraphView, stateMachine.AnyStates.Items.Values, anyStateMap);
}
foreach (var state in stateMachine.States.Values)
{
foreach (var transition in state.ExitTransitions)
{
StateNodeUI stateNode = stateToNodeMap[(State)transition.SourceState];
var transitionConnection = (TransitionConnectionUI)CreateConnection(stateNode, stateToNodeMap[transition.DestinationState], false);
LoadTransitionInfo(transitionConnection.Transitions[transitionConnection.Transitions.Count - 1], transition);
}
}
void LoadTransitionInfo(TransitionInfo transitionInfo, Transition transition)
{
transitionInfo.DurationType = transition.DurationType;
transitionInfo.Duration = transition.Duration;
transitionInfo.OffsetType = transition.OffsetType;
transitionInfo.Offset = transition.Offset;
transitionInfo.InterruptionSource = transition.InterruptionSource;
transitionInfo.OrderedInterruption = transition.OrderedInterruption;
transitionInfo.InterruptableByAnyState = transition.InterruptableByAnyState;
transitionInfo.PlayAfterTransition = transition.PlayAfterTransition;
transition.Conditions.ForEach(condition =>
{
TransitionInfoCondition infoCondition = new TransitionInfoCondition();
transitionInfo.Conditions.Add(infoCondition);
if (condition.ValueProvider == null)
{
return;
}
StateMachineBaseNodeUI node = valueProviderMap[condition.ValueProvider];
if (node is StateNodeUI stateNode)
{
State state = nodeToStateMap[stateNode];
infoCondition.ProviderSourceType = ValueProviderSourceType.State;
infoCondition.State = stateNode;
infoCondition.StateValueProvider = condition.ValueProvider == state.PreviousTime ? StateValueProviders.PreviousTime
: condition.ValueProvider == state.Time ? StateValueProviders.Time
: condition.ValueProvider == state.NormalizedTime ? StateValueProviders.NormalizedTime
: StateValueProviders.PreviousNormalizedTime;
FloatConditionEvaluator floatEvaluator = (FloatConditionEvaluator)condition.Evaluator;
infoCondition.FloatComparison = floatEvaluator.Comparison;
infoCondition.FloatComparisonValue = floatEvaluator.ComparisonValue;
}
else
{
ParameterNodeUI parameterNode = (ParameterNodeUI)node;
infoCondition.ProviderSourceType = ValueProviderSourceType.Parameter;
infoCondition.Parameter = parameterNode;
switch (condition.Evaluator)
{
case BoolConditionEvaluator boolEvaluator:
infoCondition.BoolComparisonValue = boolEvaluator.ComparisonValue == Bool.True;
break;
case IntConditionEvaluator intEvaluator:
infoCondition.IntComparison = intEvaluator.Comparison;
infoCondition.IntComparisonValue = intEvaluator.ComparisonValue;
break;
case FloatConditionEvaluator floatEvaluator:
infoCondition.FloatComparison = floatEvaluator.Comparison;
infoCondition.FloatComparisonValue = floatEvaluator.ComparisonValue;
break;
}
}
});
}
EntryNodeUI entryStateNode = new EntryNodeUI();
GraphView.AddNode(entryStateNode);
GraphView.EntryNode = entryStateNode;
if (NodeUI.StateMachineNodeAsset.EntryState != null)
{
SetNodePositionAndExpansion(entryStateNode, NodeUI.StateMachineNodeAsset.EntryState);
}
entryStateNode.LoadData(GraphView, stateMachine.EntryState, stateToNodeMap);
}
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 AnyStateContextMenu(Context context, AnyState anyState)
{
this.context = context;
this.anyState = anyState;
}
