/// <summary>
/// 解绑条件
/// </summary>
/// <param name="condtion"></param>
public void UnBindCondition(ITransitionCondition condtion)
{
if (condtion == null)
{
throw new Exception("Func is" + condtion);
}
conditions -= condtion.IsMetCondition;
}
public override bool AddFinishCondition(ITransitionCondition condition)
{
if (condition == null || this.finishConditions.Contains(condition))
{
return(false);
}
this.finishConditions.Add(condition);
return(true);
}
// PRAGMA MARK - ISerializationCallbackReceiver Implementation
public void OnAfterDeserialize()
{
this._conditions = new List <ITransitionCondition>();
foreach (string serializedCondition in this._serializedConditions)
{
ITransitionCondition condition = JsonSerialization.DeserializeGeneric <ITransitionCondition>(serializedCondition);
if (condition != null)
{
this._conditions.Add(condition);
}
}
}
private void AddTransitionCondition(object tupleAsObject)
{
Tuple <NodeTransition, Type> data = tupleAsObject as Tuple <NodeTransition, Type>;
NodeTransition nodeTransition = data.Item1;
Type type = data.Item2;
ITransitionCondition transitionCondition = Activator.CreateInstance(type) as ITransitionCondition;
if (transitionCondition == null)
{
Debug.LogError("AddTransitionCondition - Failed to cast created type as ITransitionCondition!");
return;
}
nodeTransition.transition.AddTransitionCondition(transitionCondition);
this.SetTargetDirty();
}
public static string Serialize(ITransitionCondition condition)
{
if (condition == null)
{
Debug.LogError("TransitionConditionSerializer - Serialize was passed in null condition!");
return("");
}
Type type = condition.GetType();
MethodInfo genericMethod = typeof(TransitionConditionSerializer).GetMethod("SerializeCondition", BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo method = genericMethod.MakeGenericMethod(type);
string serializedCondition = (string)method.Invoke(null, new object[] { condition });
var serializedConditionWrapper = new SerializedClassWrapper(type, serializedCondition);
return(JsonUtility.ToJson(serializedConditionWrapper, prettyPrint: true));
}
public void BoolTransitionCondition_MatchesOtherTests_AfterSerializingAndDeserializing(string key, bool targetValue, bool expectedEntered)
{
Graph graph = new Graph();
Node nodeA = graph.MakeNode();
Node nodeB = graph.MakeNode();
Transition transition = new Transition(waitForManualExit: false);
BoolTransitionCondition condition = new BoolTransitionCondition(key, targetValue);
// NEW CODE
string serialized = TransitionConditionSerializer.Serialize(condition);
ITransitionCondition deserialized = TransitionConditionSerializer.Deserialize(serialized);
transition.AddTransitionCondition(deserialized);
// END NEW CODE
NodeTransition nodeTransition = new NodeTransition {
targets = new NodeId[] { nodeB.Id }, transition = transition
};
graph.AddOutgoingTransitionForNode(nodeA, nodeTransition);
IGraphContext stubContext = Substitute.For <IGraphContext>();
stubContext.HasBoolParameterKey(Arg.Is("Key")).Returns(true);
stubContext.GetBool(Arg.Is("Key")).Returns(true);
IGraphContextFactory stubFactory = Substitute.For <IGraphContextFactory>();
stubFactory.MakeContext().Returns(stubContext);
GraphContextFactoryLocator.Provide(stubFactory);
bool entered = false;
nodeB.OnEnter += () => { entered = true; };
graph.Start();
Assert.AreEqual(expectedEntered, entered);
}
public Transition <TState, TTransition, TSignal> FinishWhen(
ITransitionCondition condition)
{
AddFinishCondition(condition);
return(this);
}
public Transition <TState, TTransition, TSignal> StartWhen(
ITransitionCondition condition)
{
AddStartCondition(condition);
return(this);
}
public OrthogonalTransition <TState, TTransition, TSignal> FinishWhen(
ITransitionCondition condition)
{
this.Transition.StartWhen(condition);
return(this);
}
public void AddTransitionCondition(ITransitionCondition condition)
{
this._conditions.Add(condition);
}
public abstract bool AddFinishCondition(ITransitionCondition condition);
public abstract bool AddStartCondition(ITransitionCondition condition);
