public ProcessState GetNext(Command command)
{
StateTransition transition = new StateTransition(CurrentState, command);
ProcessState nextState;
if (!transitions.TryGetValue(transition, out nextState))
{
//Halt process throwing execption
//throw new Exception("Invalid transition: " + CurrentState + " -> " + command);
Console.WriteLine("Invalid transition: " + CurrentState + " -> " + command);
}
else
{
switch (nextState)
{
case ProcessState.Inactive:
Console.WriteLine("Do stuff for " + nextState);
break;
case ProcessState.Active:
Console.WriteLine("Do stuff for " + nextState);
break;
case ProcessState.Paused:
Console.WriteLine("Do stuff for " + nextState);
break;
case ProcessState.Terminated:
Console.WriteLine("Do stuff for " + nextState);
break;
default:
break;
}
}
return nextState;
}
public FiniteAutomaton(int initialState, int statesNumber, int eventsNumber)
{
InitialState = initialState;
StatesNumber = statesNumber;
EventsNumber = eventsNumber;
Transitions = new StateTransition[statesNumber, eventsNumber];
}
public override void SetTransitions()
{
StateTransition cancellingBackMenu = new StateTransition(TransitionID.Previous, StateID.SelectUnit);
AddTransition(cancellingBackMenu);
StateTransition endingTurn = new StateTransition(TransitionID.Next, StateID.ChangeTurns);
AddTransition(endingTurn);
}
public void TestStateTransitionEquals()
{
var s1 = new StateTransition<SystemState, SystemStateEvent>(SystemState.WaitingForEvaluator,
SystemStateEvent.AllContextsAreReady);
var s2 = new StateTransition<SystemState, SystemStateEvent>(SystemState.WaitingForEvaluator,
SystemStateEvent.AllContextsAreReady);
Assert.True(s1.Equals(s2), "The two transitions should be equal");
}
public EnemyEntityState GetNext(EnemyCommand command)
{
StateTransition transition = new StateTransition(CurrentState, command);
EnemyEntityState nextState;
if (!transitions.TryGetValue(transition, out nextState))
throw new Exception("Invalid transition: " + CurrentState + " -> " + command);
return nextState;
}
public ProcessState GetNext(Command command)
{
StateTransition transition = new StateTransition(CurrentState, command);
ProcessState nextState;
if (!transitions.TryGetValue(transition, out nextState))
{
throw new Exception("Invalid transition: " + CurrentState + " -> " + command);
}
return nextState;
}
/// <summary>
/// Based on the event and current state to determine the next state
/// </summary>
/// <param name="systemEvent"></param>
/// <returns></returns>
internal SystemState GetNext(SystemStateEvent systemEvent)
{
var transition = new StateTransition<SystemState, SystemStateEvent>(_currentState, systemEvent);
SystemState nextState;
if (!Transitions.TryGetValue(transition, out nextState))
{
throw new SystemStateTransitionException(_currentState, systemEvent);
}
return nextState;
}
/// <summary>
/// Initialise the fade transition, specifying how long the fade should last, in ms.
/// </summary>
/// <param name="transition">The transition this fade is part of.</param>
/// <param name="manager">The window this fade is to be drawn on.</param>
/// <param name="lengthMS">The length of time, in ms, the fade should last.</param>
public FeatureFrameTransition(StateTransition transition, FrameOverlayManager manager, IFeatureTransition transitionEffect)
: base(transition, manager)
{
mTransition = transitionEffect;
mTransition.Start = From;
mTransition.Finish = To;
mTransition.Finished += new Action(transitionEffect_Finished);
AddFeature(mTransition);
}
public void AddTransition(S init, S end, Callback c)
{
StateTransition <S> tr = new StateTransition <S>(init, end);
if (mTransitions.ContainsKey(tr))
{
return;
}
mTransitions.Add(tr, c);
}
public void AddTransition(S initial_state, S end_state, StateHandler call)
{
StateTransition <S> temp_transition = new StateTransition <S>(initial_state, end_state);
if (TransitionTable.ContainsKey(temp_transition))
{
return;
}
TransitionTable.Add(temp_transition, call);
}
public void Tick()
{
// Transition to a new State if any of our current State's transition conditions are met
StateTransition transition = CheckForTransition();
if (transition != null)
{
SetState(transition.To);
}
_currentState.Tick();
}
public void DefineTransition(
TState fromState,
TState toState,
Func <TEvent, bool> condition,
Action <TEvent> action
)
{
var t = new StateTransition(fromState, toState, condition, action);
_transitions.Add(t);
}
public override bool Equals(object obj)
{
bool result = false;
StateTransition newObj = obj as StateTransition;
if (newObj != null && _currentState == newObj._currentState && _transition == newObj._transition)
{
result = true;
}
return(result);
}
public ProcessState GetNext(Command command)
{
StateTransition transition = new StateTransition(CurrentState, command);
ProcessState nextState;
if (!transitions.TryGetValue(transition, out nextState))
{
return(nextState);
}
return(nextState);
}
public ProcessState GetNext(Command command)
{
StateTransition transition = new StateTransition(CurrentState, command);
ProcessState nextState;
if (!transitions.TryGetValue(transition, out nextState))
{
throw new Exception("Invalid transition: " + CurrentState + " -> " + command);
}
return(nextState);
}
public State GetNext(Event currentEvent)
{
StateTransition transition = new StateTransition(CurrentState, currentEvent);
State nextState;
if (!m_transitions.TryGetValue(transition, out nextState))
{
throw new Exception("Invalid transition: " + CurrentState + " -> " + currentEvent);
}
return(nextState);
}
//Return a list of values associated with the action values from each model for the given state
public List <double[]> modelActionValues(StateTransition <stateType, actionType> StaTran,
Dictionary <int, ActionValue <stateType, actionType> > models)
{
List <double[]> returnValues = null;
foreach (int key in models.Keys)
{
returnValues.Add(models[key].value(StaTran.oldState, models[key].availableActions));
}
return(returnValues);
}
public void Tick()
{
StateTransition transition = CheckForTransition();
if (transition != null)
{
SetState(transition.To);
}
CurrentState.Tick();
}
public void AddTransition(IState from, IState to, Func <bool> condition)
{
if (_stateTransitions.ContainsKey(from) == false)
{
_stateTransitions[from] = new List <StateTransition>();
}
StateTransition stateTransition = new StateTransition(from, to, condition);
_stateTransitions[from].Add(stateTransition);
}
public void GetPossibleTransitionsFromState2and5returns4Transitions()
{
GameState fromState = new GameState(2, 5);
int bucket1Max = 3;
int bucket2Max = 5;
IList <StateTransition> actual = StateTransition.GetPossibleTransitions(fromState, bucket1Max, bucket2Max);
//dump 1, dump 2, fill 1, tranfer 2 to 1
Assert.AreEqual(actual.Count, 4);
}
public void GetPossibleTransitionsFromState0and0returns2Transitions()
{
GameState fromState = new GameState(0, 0);
int bucket1Max = 3;
int bucket2Max = 5;
IList <StateTransition> actual = StateTransition.GetPossibleTransitions(fromState, bucket1Max, bucket2Max);
//fill 1, fill 2
Assert.AreEqual(actual.Count, 2);
}
protected TState GetNext(TState state)
{
StateTransition transition = new StateTransition(CurrentState, state);
TState nextState;
if (!transitions.TryGetValue(transition, out nextState))
{
throw new System.Exception($"Invalid transition: {CurrentState} -> {state}");
}
return(nextState);
}
/// <summary>
///
/// </summary>
/// <param name="transition"></param>
/// <param name="window"></param>
/// <exception cref="InvalidArgumentException">Thrown if there is no window state for the To or From state.</exception>
public FrameTransition(StateTransition transition, FrameOverlayManager manager)
: base(manager.Name)
{
mManager = manager;
mTransition = transition;
mFrom = transition.From[manager.Name];
mTo = transition.To[manager.Name];
Finished += trans => mSelected = false;
}
/// <summary>
///
/// </summary>
/// <param name="transition"></param>
/// <param name="window"></param>
/// <exception cref="InvalidArgumentException">Thrown if there is no window state for the To or From state.</exception>
public FrameTransition(StateTransition transition, FrameOverlayManager manager)
: base(manager.Name)
{
mManager = manager;
mTransition = transition;
mFrom = transition.From[manager.Name];
mTo = transition.To[manager.Name];
Finished += trans => mSelected = false;
}
private IEnumerator ChangeToNewStateRoutine(StateMapping newState, StateTransition transtiion)
{
_destinationState = newState;
if (_currentState != null)
{
if (_currentState.hasExitRoutine)
{
_exitRoutine = _currentState.ExitRoutine();
if (_exitRoutine != null && transtiion != StateTransition.Overwrite)
{
yield return(_engine.StartCoroutine(_exitRoutine));
}
_exitRoutine = null;
}
else
{
_currentState.ExitCall();
}
_currentState.Finally();
}
_lastState = _currentState;
_currentState = _destinationState;
if (_currentState != null)
{
if (_currentState.hasEnterRoutine)
{
_enterRoutine = _currentState.EnterRoutine();
if (_enterRoutine != null)
{
yield return(_engine.StartCoroutine(_enterRoutine));
}
_enterRoutine = null;
}
else
{
_currentState.EnterCall();
}
if (Changed != null)
{
Changed(_currentState.State);
}
}
_isInTransition = false;
}
//Transistions between step
public ProcessState GetNext(Command command)
{
StateTransition transition = new StateTransition(CurrentState, command);
ProcessState nextState;
if (!transitions.TryGetValue(transition, out nextState)) // Handles the case where the transition to the next step is invalid in which case throws and exceptions to get the values from the next step.
{
throw new Exception("Invalid transition: " + CurrentState + " -> " + command);
}
return(nextState);
}
public StrategySettings(StrategySettings other)
{
AllowedTransitions = other.AllowedTransitions;
Run = other.Run;
Reset = other.Reset;
PreferredSpeed = other.PreferredSpeed;
PreferredManeuverSecondDistance = other.PreferredManeuverSecondDistance;
PartialUpdate = other.PartialUpdate;
VersionNumber = other.VersionNumber;
CustomTransitionQueue = new List <StateTransition>(other.CustomTransitionQueue);
}
public void GetHashCode_ReturnsExpectedInt()
{
// Arrange
var stateTransition = new StateTransition(new State(OrderStatus.Initialized), new Trigger(OrderEvent.Accepted));
// Act
var result = stateTransition.GetHashCode();
// Assert
Assert.Equal(typeof(int), result.GetType());
}
public void ToString_ReturnsExpectedString()
{
// Arrange
var stateTransition = new StateTransition(new State(OrderStatus.Initialized), new Trigger(OrderEvent.Accepted));
// Act
var result = stateTransition.ToString();
// Assert
Assert.Equal("StateTransition: Initialized -> Accepted", result);
}
/// <summary>
///
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
public Status GetNext(SendCommand command)
{
var transition = new StateTransition(CurrentState, command);
Status nextState;
if (!_transitions.TryGetValue(transition, out nextState))
{
throw new CommunicationStateException("Incorrect State");
}
return(nextState);
}
public void TestTransitionConstructor()
{
var firstState = new State();
var secondState = new State();
var testTransition = new StateTransition(firstState, secondState, "TransitionTrigger");
Assert.NotNull(testTransition);
Assert.True(testTransition.SourceState == firstState);
Assert.True(testTransition.TargetState == secondState);
Assert.True(testTransition.TransitionTrigger == "TransitionTrigger");
}
protected override void ReadInternal(Reader reader)
{
transitions = new StateTransition[length];
for (int i = 0; i < transitions.Length; i++)
{
transitions[i] = new StateTransition();
transitions[i].targetState = new Reference <State>(reader, true);
transitions[i].stateToGo = new Reference <State>(reader, true);
transitions[i].linkingType = reader.ReadUInt16();
}
}
public void ToString_ReturnsExpectedString()
{
// Arrange
var stateTransition = new StateTransition <OrderState>(OrderState.Initialized, Trigger.Event(typeof(OrderAccepted)));
// Act
var result = stateTransition.ToString();
// Assert
Assert.Equal("StateTransition(Initialized -> OrderAccepted)", result);
}
public MyRegistrationState GetNext(RegisterCommands command)
{
StateTransition transition = new StateTransition(CurrentState, command);
MyRegistrationState nextState;
if (!transitions.TryGetValue(transition, out nextState))
{
throw new Exception("Invalid transition: " + CurrentState + " -> " + command);
}
return(nextState);
}
private void GenerateStructure()
{
foreach (State toState in sm.States)
{
string stateName = toState.Name;
if (stateName == FromState)
{
continue;
}
MetaObject mo = StateMachineManager.GetState(ClassName, stateName);
HtmlTableRow tr = new HtmlTableRow();
tr.Style.Add(HtmlTextWriterStyle.Height, "25px");
HtmlTableCell td1 = new HtmlTableCell();
HtmlTableCell td2 = new HtmlTableCell();
td1.NoWrap = true;
CheckBox cb = new CheckBox();
cb.ID = String.Format("chk{0}", stateName);
TextBox txt = new TextBox();
txt.ID = String.Format("txt{0}", stateName);
txt.Width = Unit.Percentage(100);
if (!IsPostBack)
{
cb.Text = CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString());
StateTransition st = sm.FindTransition(FromState, stateName);
if (st != null)
{
cb.Checked = true;
txt.Text = st.Name;
}
else
{
txt.Text = mo.Properties["FriendlyName"].Value.ToString();
txt.Style.Add(HtmlTextWriterStyle.Display, "none");
}
}
td1.Controls.Add(cb);
td2.Controls.Add(txt);
tr.Cells.Add(td1);
tr.Cells.Add(td2);
tblMain.Rows.Add(tr);
cb.Attributes.Add("onclick", String.Format("ShowHide('{0}', '{1}')", cb.ClientID, txt.ClientID));
}
}
public void AddTransition(SimpleState toState)
{
if (_transitions.ContainsKey(toState))
{
StateTransition transition = _transitions[toState];
}
else
{
_transitions.Add(toState, new StateTransition(this, toState));
}
}
public void TestTransitionEquals()
{
var firstState = new State();
var secondState = new State();
var testTransition1 = new StateTransition(firstState, secondState, "TransitionTrigger");
var testTransition2 = new StateTransition(firstState, secondState, "TransitionTrigger");
var testTransition3 = new StateTransition(secondState, firstState, "TransitionTrigger");
Assert.True(testTransition1.Equals(testTransition2));
Assert.True(!testTransition1.Equals(testTransition3));
}
public override SceneBase GetNext(SceneCommand command)
{
StateTransition transition = new StateTransition(Current, command);
SceneBase nextState;
if (!transitions.TryGetValue(transition, out nextState))
{
throw new System.Exception("Invalid transition: " + Current + " -> " + command);
}
return(nextState);
}
public static void addStateTransition(CompanionSettings settings, string stateName, string transitionName, FFXICompanion.Settings.Button button, Settings.Key key)
{
StateTransition stateTransition = new StateTransition();
stateTransition.stateName = stateName;
stateTransition.transitionName = transitionName;
stateTransition.key = key;
ControllerButton controllerButton = new ControllerButton(button, Settings.Action.PRESSED);
stateTransition.transitionButtons.Add(controllerButton);
settings.stateTransitions.Add(stateTransition);
}
void Start()
{
target = GameController.instance.player;
characterData = this.GetComponent<CharacterData>();
animator = this.GetComponent<Animator>();
attack = new Attack(this);
idle = new Idle(this);
toIdle = new StateTransition(this, idle);
toAttack= new StateTransition(this, attack);
currentState = idle;
}
public void FromState()
{
var machine = new FiniteStateMachine<UpdateState, string>();
var transition = new StateTransition<UpdateState, string>
{
FromState = UpdateState.Ready,
ToState = UpdateState.DownloadingUpdate,
InputValidator = s => s.Equals("Start")
};
machine.Transitions.Add( transition );
Assert.AreEqual(UpdateState.Ready, machine.CurrentState);
var transitions = machine.Transitions.FromState(machine.CurrentState);
Assert.AreEqual(1, transitions.Count());
Assert.AreEqual(transition, transitions.First());
}
public IWindowTransition Create(StateTransition transition, FrameOverlayManager manager)
{
return new OpacityFadeWindowTransition(transition, manager, mLengthMS, !mFadeOut);
}
public void IsValid_throws_InvalidOperationException_if_InputValidator_is_null()
{
var transition = new StateTransition<string, string>();
transition.IsValid("test");
}
public static void SwitchState(Type state, StateTransition startTransition, StateTransition endTransition)
{
Core.SwitchState(state, startTransition, endTransition);
}
private void TransitState(StateTransition stateTransition)
{
TimerBar.localScale = Vector3.one;
if (Type == CellType.Interactive)
{
CurrentInteractiveCellStateID = stateTransition.TransitionToID;
}
else
{
DoorCellState = stateTransition.TransitionToDoorState;
}
UpdateCellType();
}
public void SwitchState(Type state, StateTransition startTransition, StateTransition endTransition)
{
this.CurrentState = null;
this.CurrentState = (State)Activator.CreateInstance(state);
}
/// <summary>
/// Start the transition transition one state to another.
/// </summary>
/// <param name="transition">The transition to begin.</param>
public void BeginTransition(StateTransition transition)
{
if (Transitioning)
throw new InvalidOperationException("Unable to start transition transition " + transition.From.Name
+ " to " + transition.To.Name + ". There is already a transition in progress.");
lock (this) {
mCurrentState = null;
mCurrentTransition = transition;
transition.Finished += mTransitionCompleteListener;
}
if (TransitionStarting != null)
TransitionStarting(transition);
transition.Begin();
}
/// <summary>
/// Called by ITransitionCommand's when the transitional condition is met, triggers state change
/// </summary>
public void OnTransition(ITransitionCommand transition)
{
StateTransition st = new StateTransition(CurrentState,transition);
ChangeState(StateTransitions[st]);
}
public IWindowTransition Create(StateTransition transition, FrameOverlayManager manager)
{
return new FeatureFrameTransition(transition, manager, mFactory.Create(mLengthMS));
}
/// <summary>
/// Add a new transition to another state.
/// </summary>
/// <param name="stateTransition">The new transition to add.</param>
public void AddTransition(StateTransition stateTransition)
{
if (stateTransition.From != this)
throw new ArgumentException("Error. " + stateTransition.Name + " does not start at " + Name + " so cannot be added as a transition from it.");
//TODO - this is a hack and will break things. Need to decide on how to handle multiple triggers.
//What happens if new transition needs to be drawn?
if (mTransitions.ContainsKey(stateTransition.To.Name)) {
mTransitions[stateTransition.To.Name].AddTriggers(stateTransition.Triggers);
} else {
mTransitions.Add(stateTransition.To.Name, stateTransition);
if (stateTransition is IFeature)
AddFeature(stateTransition as IFeature);
}
}
/// <summary>
/// Binds the transition buttons.
/// </summary>
/// <param name="nextTransitions">The next transitions.</param>
/// <param name="prevTransitions">The prev transitions.</param>
private void BindTransitions(StateTransition[] nextTransitions, StateTransition[] prevTransitions)
{
if (TransitionList.Items.Count > 0)
TransitionList.Items.Clear();
ListItem li;
for (int i = 0; i < prevTransitions.Length; i++)
{
li = new ListItem(CHelper.GetResFileString(prevTransitions[i].Name), prevTransitions[i].Uid.ToString());
TransitionList.Items.Add(li);
}
for (int i = 0; i < nextTransitions.Length; i++)
{
li = new ListItem(CHelper.GetResFileString(nextTransitions[i].Name), nextTransitions[i].Uid.ToString());
TransitionList.Items.Add(li);
if (i == 0)
li.Selected = true;
}
if (TransitionList.Items.Count > 0 && TransitionList.SelectedItem == null)
TransitionList.Items[0].Selected = true;
}
/// <summary>
/// Initialise the fade transition, specifying how long the fade should last, in ms.
/// </summary>
/// <param name="transition">The transition this fade is part of.</param>
/// <param name="manager">The window this fade is to be drawn on.</param>
/// <param name="lengthMS">The length of time, in ms, the fade should last.</param>
public OpacityFadeWindowTransition(StateTransition transition, FrameOverlayManager manager, double lengthMS, bool fadeIn)
: base(transition, manager)
{
mLengthMS = lengthMS;
mFadeIn = fadeIn;
mTickListener = new Action(Coordinator_Tick);
Finished += new Action<IWindowTransition>(OpacityFadeWindowTransition_Finished);
#if DEBUG
StatisticsCollection.AddStatistics(mStatistics, transition.Name + " " + manager.Name);
#endif
}
public override void SetTransitions()
{
StateTransition cancellingUnitAction = new StateTransition(TransitionID.Previous, StateID.SelectUnitAction);
AddTransition(cancellingUnitAction);
StateTransition executingUnitAction = new StateTransition(TransitionID.Next, StateID.ExecuteUnitAction);
AddTransition(executingUnitAction);
}
/// <summary>
/// Map the transitiom from 'fromState' to 'toState'.
/// </summary>
/// <returns>
/// false if there is a transition from 'fromState' matching 'transition', else true;
/// </returns>
bool MapTransition(FiniteState fromState, ITransitionCommand transition,FiniteState toState,bool cache)
{
StateTransition st = new StateTransition(fromState,transition);
if(StateTransitions.ContainsKey(st)){
return false;
}
AddState(fromState,cache);
AddState(toState,cache);
StateTransitions.Add(st,toState);
TransitionMap[fromState].Add(transition);
if(cache){
StateTransitionState sts = new StateTransitionState();//ScriptableObject.CreateInstance<StateTransitionState>() as StateTransitionState;
sts.StartState = fromState;
sts.EndState = toState;
sts.Transition = transition;
StateCache.Add(sts);
}
return true;
}
private void transition_Finished(StateTransition transition)
{
if (TransitionFinished != null)
TransitionFinished(transition);
lock (this) {
transition.Finished -= mTransitionCompleteListener;
CurrentState = transition.To;
mCurrentTransition = null;
}
}
/// <summary>
/// Called by 'awake()' to rebuild dictionaries, which Unity doesn't serialize
/// </summary>
void RebuildStateTransitionMap()
{
TransitionMap.Clear();
StateTransitions.Clear();
StartState = null;
CurrentState = null;
//Debug.Log("Rebuilding transition map");
//Unity serialization doesn't work w/ Generic.Dictionary, rebuild from state list
foreach(StateTransitionState sts in StateCache){
AddState(sts.StartState,false);
AddState(sts.EndState,false);
if(sts.StartState!=null && sts.Transition!=null) {
StateTransition st = new StateTransition(sts.StartState,sts.Transition);
StateTransitions.Add(st,sts.EndState);
TransitionMap[sts.StartState].Add(sts.Transition);
if(sts.StartState.Start == true){
SetStart(sts.StartState,false);
}
}
if(sts.Valid()){
//Debug.Log("Rebuilding transition from " + sts.StartState.StateName + " to " + sts.EndState.StateName);
} else if(sts.StartState!=null && sts.EndState==null){
//Debug.Log("Rebuilding start state w/ no end state <" + sts.StartState.StateName + ">");
} else if(sts.StartState==null && sts.EndState!=null){
//Debug.Log("Rebuilding end state w/ no start state <" + sts.EndState.StateName + ">");
} else if(sts.StartState==null && sts.EndState==null && sts.Transition==null){
//Debug.Log("Warning, disconnected transition <" + sts.Transition.Name + ">");
}
}
//StateTransition st1 = new StateTransition(StateCache[0].StartState,StateCache[0].Transition);
//StateTransition st2 = new StateTransition(StartState,StateCache[0].Transition);
//Debug.Log("Comparison Hash. " + st1.GetHashCode() + "==" + st2.GetHashCode());
//Debug.Log("Comparison Equl. " + (st1 == st2).ToString());
}
/// <summary>
/// Add a new transition from 1 state to another
/// </summary>
/// <returns>
public ITransitionCommand AddTransition(FiniteState fromState, ITransitionCommand component, FiniteState toState)
{
component.enabled = false;
component.FSM = this;
StateTransition st = new StateTransition(fromState,component);
//Debug.Log("Adding new transition type " + component.GetType() + " from state " + fromState.StateName + " to state " + toState.StateName);
if(!MapTransition(fromState,component,toState)){
Destroy(component); //always delete duplicate transition components
//Debug.Log("fromState " + fromState.StateName + " already contains a transition type " + component.GetType().ToString());
return null;
}
return component;
}
public override void SetTransitions()
{
StateTransition selectingUnit = new StateTransition(TransitionID.Previous, StateID.SelectUnit);
AddTransition(selectingUnit);
StateTransition changingTurns = new StateTransition(TransitionID.Next, StateID.ChangeTurns);
AddTransition(changingTurns);
}
private bool CheckStateTransition(StateTransition stateTransition)
{
for (int i = 0; i < stateTransition.Conditions.Count; i++)
{
if (stateTransition.Conditions[i].Cell.CurrentInteractiveCellStateID !=
stateTransition.Conditions[i].CellStateID)
{
return false;
}
}
return true;
}
public override void SetTransitions()
{
StateTransition deselectingUnit = new StateTransition(TransitionID.Previous, StateID.SelectUnit);
AddTransition(deselectingUnit);
StateTransition confirmingUnitMove = new StateTransition(TransitionID.Next, StateID.SelectUnitAction);
AddTransition(confirmingUnitMove);
}
