///////////////////////
// CLASS FUNCTIONS
///////////////////////
public void PreProcess() {
// Generate samples
graph = new FlowNode[vertices.Length];
for( int i = 0; i < graph.Length; i++ ){
graph[i] = new FlowNode();
graph[i].water = 0.0f;
graph[i].worldposition = target.TransformPoint( vertices[i] );
graph[i].additionalheight = Mathf.Max( 0.0f, 0.0f - graph[i].worldposition.y );
}
// Add vertex links to graph nodes
for( int i = 0; i < triangles.Length; i+=3 ){
int t0= triangles[i];
int t1= triangles[i+1];
int t2= triangles[i+2];
graph[t0].vertexlinks_list.Add(t1);
graph[t0].vertexlinks_list.Add(t2);
graph[t1].vertexlinks_list.Add(t0);
graph[t1].vertexlinks_list.Add(t2);
graph[t2].vertexlinks_list.Add(t0);
graph[t2].vertexlinks_list.Add(t1);
graph[t0].linkedTriangles++;
graph[t1].linkedTriangles++;
graph[t2].linkedTriangles++;
}
// Remove doubles in nodes
for( int i = 0; i < vertices.Length; i++ ){
ArrayList links = new ArrayList();
ArrayList nodelinks = graph[i].vertexlinks_list;
for( int j = 0; j < nodelinks.Count; j++ ) {
if (!HasLink(links, (int)nodelinks[j])) links.Add(nodelinks[j]);
}
// Transfer node links from list to array
graph[i].vertexlinks = new int[links.Count];
for( int j = 0; j < graph[i].vertexlinks.Length; j++ ) {
graph[i].vertexlinks[j] = (int)links[j];
}
// Clear node list
graph[i].vertexlinks_list.Clear();
}
// Find edges
for( int i = 0; i < graph.Length; i++ ) {
if( graph[i].vertexlinks.Length > graph[i].linkedTriangles ) graph[i].isEdge = true;
}
}
public FlowNode Clone(){
FlowNode clone = new FlowNode();
clone.vertexlinks = this.vertexlinks;
clone.water = this.water;
clone.flowdirection = this.flowdirection;
clone.worldposition = this.worldposition;
clone.additionalheight = this.additionalheight;
clone.isEdge = this.isEdge;
clone.vertexlinks_list = this.vertexlinks_list;
clone.linkedTriangles = this.linkedTriangles;
return clone;
}
public void ProcessEvent(FlowNode.EFlowEvent _event, UInt16 id)
{
Logging./*CryConsole.*/LogAlways("Process Event; Mono style.");
switch (_event)
{
case EFlowEvent.Activate:
{/*
if (IsPortActive(nodeInfo, (int)EInputPorts.EIP_Start))
{
ActivateOutput(nodeInfo, (int)EOutputPorts.EOP_Started);
}*/
}
break;
}
}
/// <summary>
/// Sets the source flow node of this sequence flow.
/// </summary>
/// <param name="source"> the source of this sequence flow </param>
/// <returns> the builder object </returns>
public virtual B from(FlowNode source)
{
element.Source = source;
source.Outgoing.Add(element);
return(myself);
}
protected override ISet <VariableAlias> Transfer(FlowNode node, ISet <VariableAlias> data)
{
return(_TransferRegular(node, data, false));
}
public static List <VariableInfo> DrawVariables(Rect position, IEnumerable <VariableInfo> variables, Dictionary <string, VariableInfo> ovrrideInputs, List <VariableInfo> inputs)
{
if (inputs != null)
{
for (int i = 0; i < inputs.Count; i++)
{
var input = inputs[i];
var variable = variables.Where(o => o.Name == input.Name).FirstOrDefault();
if (variable == null || variable.Type != input.Type)
{
inputs.RemoveAt(i);
i--;
GUI.changed = true;
}
}
}
Rect rowRect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
GUIStyle labelStyle = new GUIStyle("label");
// labelStyle.fontStyle = FontStyle.Bold;
int inputCount = variables.Where(o => o.IsIn).Count();
// if (inputCount > 0)
{
rowRect.x = position.x;
rowRect.width = position.width;
rowRect.xMin += GUI.depth * GUIDepthScope.Pixels;
//rowRect = EditorGUI.PrefixLabel(rowRect, new GUIContent("Input"), labelStyle);
GUI.Label(GUIExtensions.Width(ref rowRect, EditorGUIUtility.labelWidth), new GUIContent("Input"), labelStyle);
rowRect.y += rowRect.height;
using (new GUIDepthScope())
{
variables.Where(o => o.IsIn).OrderBy(o => o.Name).Where((variable, index) =>
{
VariableInfo inVar = null;
if (inputs != null)
{
inVar = inputs.Where(o => o.Name == variable.Name).FirstOrDefault();
}
if (inVar != null && inVar.Type != variable.Type)
{
inputs.Remove(inVar);
inVar = null;
GUI.changed = true;
}
rowRect.x = position.x;
rowRect.width = position.width;
rowRect.xMin += GUI.depth * GUIDepthScope.Pixels;
if (inVar == null)
{
GUI.color = Color.gray;
}
else
{
GUI.color = Color.white;
}
GUI.Label(GUIExtensions.Width(ref rowRect, variableLabelWidth), new GUIContent(variable.Name));
GUI.color = Color.white;
var tmpRect = GUIExtensions.Width(ref rowRect, rowRect.width - variableCheckWidth);
if (inVar != null)
{
object newValue2;
newValue2 = SerializableValuePropertyDrawer.ValueField(tmpRect, inVar.DefaultValue, inVar.Type);
if (!object.Equals(newValue2, inVar.DefaultValue))
{
inVar.DefaultValue = newValue2;
GUI.changed = true;
}
}
else
{
GUI.enabled = false;
object value = variable.DefaultValue;
if (ovrrideInputs.ContainsKey(variable.Name))
{
value = ovrrideInputs[variable.Name].DefaultValue;
}
SerializableValuePropertyDrawer.ValueField(tmpRect, value, variable.Type);
GUI.enabled = true;
}
rowRect.xMin += 5f;
if (EditorGUI.Toggle(rowRect, inVar != null))
{
if (inVar == null)
{
inVar = new VariableInfo(variable.Name, variable.Type, variable.DefaultValue);
if (inputs == null)
{
inputs = new List <VariableInfo>();
}
inputs.Add(inVar);
GUI.changed = true;
}
}
else
{
if (inVar != null)
{
inputs.Remove(inVar);
GUI.changed = true;
}
}
rowRect.y = rowRect.yMax;
return(false);
}).Count();
}
}
int outputCount = variables.Where(o => o.IsOut).Count();
// if (outputCount > 0)
{
rowRect.x = position.x;
rowRect.width = position.width;
rowRect.xMin += GUI.depth * GUIDepthScope.Pixels;
//rowRect = EditorGUI.PrefixLabel(rowRect, new GUIContent("Output"), labelStyle);
GUI.Label(GUIExtensions.Width(ref rowRect, EditorGUIUtility.labelWidth), new GUIContent("Output"), labelStyle);
rowRect.y += rowRect.height;
using (new GUIDepthScope())
{
variables.Where(o => o.IsOut).OrderBy(o => o.Name).Where((variable, index) =>
{
rowRect.x = position.x;
rowRect.width = position.width;
rowRect.xMin += GUI.depth * GUIDepthScope.Pixels;
GUI.Label(GUIExtensions.Width(ref rowRect, variableLabelWidth), new GUIContent(variable.Name));
GUI.Label(rowRect, new GUIContent(FlowNode.GetDisplayValueTypeName(variable.Type), variable.Type.FullName));
rowRect.y += rowRect.height;
return(false);
}).Count();
}
}
return(inputs);
}
virtual protected void OnRegisterExtraPorts(FlowNode node)
{
}
public void Set(FlowNode next)
{
nodes.Add(next);
first = next;
second = null;
}
// The logic is similar to UpdateCloneReferences.
// the difference is in this function, we need to set reference by Property.
void UpdateCloneReferenceByModelItem(FlowNode currentFlowElement,
Dictionary <FlowNode, ModelItem> modelItems, Dictionary <FlowNode, FlowNode> clonedFlowElements)
{
if (typeof(FlowStep).IsAssignableFrom(currentFlowElement.GetType()))
{
FlowStep currentFlowStep = (FlowStep)currentFlowElement;
FlowStep clonedFlowStep = (FlowStep)clonedFlowElements[currentFlowElement];
ModelItem modelItem = modelItems[clonedFlowStep];
FlowNode nextFlowElement = currentFlowStep.Next;
if (nextFlowElement != null && clonedFlowElements.ContainsKey(nextFlowElement))
{
modelItem.Properties["Next"].SetValue(clonedFlowElements[nextFlowElement]);
}
else
{
modelItem.Properties["Next"].SetValue(null);
}
}
else if (typeof(FlowDecision).IsAssignableFrom(currentFlowElement.GetType()))
{
if (!modelItems.ContainsKey(currentFlowElement))
{
Fx.Assert("Should not happen.");
}
FlowDecision currentFlowDecision = (FlowDecision)currentFlowElement;
FlowDecision clonedFlowDecision = (FlowDecision)clonedFlowElements[currentFlowElement];
Fx.Assert(currentFlowDecision == clonedFlowDecision, "should not happen");
ModelItem modelItem = modelItems[currentFlowElement];
Fx.Assert(modelItem != null, "should not happen");
FlowNode trueElement = currentFlowDecision.True;
FlowNode falseElement = currentFlowDecision.False;
if (trueElement != null && clonedFlowElements.ContainsKey(trueElement))
{
modelItem.Properties["True"].SetValue(clonedFlowElements[trueElement]);
}
else
{
modelItem.Properties["True"].SetValue(null);
}
if (falseElement != null && clonedFlowElements.ContainsKey(falseElement))
{
modelItem.Properties["False"].SetValue(clonedFlowElements[falseElement]);
}
else
{
modelItem.Properties["False"].SetValue(null);
}
}
else if (GenericFlowSwitchHelper.IsGenericFlowSwitch(currentFlowElement.GetType()))
{
GenericFlowSwitchHelper.ReferenceCopy(currentFlowElement.GetType().GetGenericArguments()[0],
currentFlowElement,
modelItems,
clonedFlowElements);
}
else
{
Debug.Fail("Unknown FlowNode");
}
}
public void OnFlowNodeSignal(FlowNode node, PropertyInfo signal)
{
_nodesToRun.Add(new KeyValuePair <FlowNode, PropertyInfo>(node, signal));
}
public override Null Visit(WhileStmt node)
{
// Create an flow node for the back edge
FlowNode end = next.Get();
FlowNode loop = new FlowNode();
// Calculate flow for the body block
next.Set(loop);
node.block.Accept(this);
FlowNode body = next.Get();
// Calculate flow for the test expression
next.Set(body, end);
node.test.Accept(this);
// Link the back edge to before the test expression
loop.next.Add(next.Get());
return null;
}
/// <summary>
///
/// </summary>
/// <param name="activityBehavior"></param>
/// <param name="flowNode"></param>
protected internal virtual void ExecuteActivityBehavior(IActivityBehavior activityBehavior, FlowNode flowNode)
{
log.LogDebug($"Executing activityBehavior {activityBehavior.GetType()} on activity '{flowNode.Id}' with execution {execution.Id}");
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
if (processEngineConfiguration != null && processEngineConfiguration.EventDispatcher.Enabled)
{
processEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityEvent(ActivitiEventType.ACTIVITY_STARTED, flowNode.Id, flowNode.Name, execution.Id, execution.ProcessInstanceId, execution.ProcessDefinitionId, flowNode));
}
try
{
activityBehavior.Execute(execution);
}
catch (Exception e)
{
throw new Exception($"{e.Message}", e);
}
}
public abstract void RegisterPorts(FlowNode node, ReflectedFieldNodeWrapper.AccessMode accessMode);
/// <summary>
///
/// </summary>
/// <param name="flowNode"></param>
protected internal virtual void ExecuteAsynchronous(FlowNode flowNode)
{
IJobEntity job = commandContext.JobManager.CreateAsyncJob(execution, flowNode.Exclusive);
commandContext.JobManager.ScheduleAsyncJob(job);
}
/// <summary>
/// Creates an expression equality which makes use of flow information and aliases.
/// </summary>
/// <param name="aNode">The control flow graph node where the first expression is located.</param>
/// <param name="bNode">The control flow graph node where the second expression is located.</param>
/// <param name="aliases">The aliases collected within the control flow graph.</param>
public ExpressionEquality(FlowNode aNode, FlowNode bNode, AliasAnalysis aliases)
{
_aNode = aNode;
_bNode = bNode;
_aliases = aliases;
}
void NodeProcessEvent(FlowNode.EFlowEvent flowEvent, UInt16 nodeId)
{
Trace.TraceInformation("Process event on node of type {0}", nodeId);
object[] args = new object[2];
args[0] = flowEvent;
args[1] = nodeId;
InvokeNodeFunc(nodeId, "ProcessEvent", args);
}
/// <summary>
/// Gets the alias information of a variable at the exit of the given node.
/// </summary>
/// <param name="variableName">The name of the variable to get the alias information of.</param>
/// <param name="node">The node where to get the alias information of.</param>
/// <returns>The alias information.</returns>
public IEnumerable <VariableAlias> GetAliasesOfVariableAfter(string variableName, FlowNode node)
{
return(_GetAliases(Exit[node], variableName));
}
public void OnFlowNodeSignal(FlowNode node, PropertyInfo signal)
{
_addIn.OnFlowNodeSignal(node, signal);
}
public Result(FlowNode node, Knowledge knowledge)
{
this.node = node;
this.knowledge = knowledge;
}
/// <summary>
///
/// </summary>
/// <param name="flowNode"></param>
protected internal virtual void LeaveFlowNode(FlowNode flowNode)
{
log.LogDebug($"Leaving flow node {flowNode.GetType()} with id '{flowNode.Id}' by following it's {flowNode.OutgoingFlows.Count} outgoing sequenceflow");
// Get default sequence flow (if set)
string defaultSequenceFlowId = null;
if (flowNode is Activity)
{
defaultSequenceFlowId = ((Activity)flowNode).DefaultFlow;
}
else if (flowNode is Gateway)
{
defaultSequenceFlowId = ((Gateway)flowNode).DefaultFlow;
}
// Determine which sequence flows can be used for leaving
IList <SequenceFlow> outgoingSequenceFlows = new List <SequenceFlow>();
foreach (SequenceFlow sequenceFlow in flowNode.OutgoingFlows)
{
string skipExpressionString = sequenceFlow.SkipExpression;
if (!SkipExpressionUtil.IsSkipExpressionEnabled(execution, skipExpressionString))
{
if (!evaluateConditions || (evaluateConditions && ConditionUtil.HasTrueCondition(sequenceFlow, execution) && (defaultSequenceFlowId is null || !defaultSequenceFlowId.Equals(sequenceFlow.Id))))
{
outgoingSequenceFlows.Add(sequenceFlow);
}
}
else if (flowNode.OutgoingFlows.Count == 1 || SkipExpressionUtil.ShouldSkipFlowElement(commandContext, execution, skipExpressionString))
{
// The 'skip' for a sequence flow means that we skip the condition, not the sequence flow.
outgoingSequenceFlows.Add(sequenceFlow);
}
}
// Check if there is a default sequence flow
if (outgoingSequenceFlows.Count == 0 && evaluateConditions)
{ // The elements that set this to false also have no support for default sequence flow
if (!(defaultSequenceFlowId is null))
{
foreach (SequenceFlow sequenceFlow in flowNode.OutgoingFlows)
{
if (defaultSequenceFlowId.Equals(sequenceFlow.Id))
{
outgoingSequenceFlows.Add(sequenceFlow);
break;
}
}
}
}
// No outgoing found. Ending the execution
if (outgoingSequenceFlows.Count == 0)
{
if (flowNode.OutgoingFlows == null || flowNode.OutgoingFlows.Count == 0)
{
log.LogDebug($"No outgoing sequence flow found for flow node '{flowNode.Id}'.");
Context.Agenda.PlanEndExecutionOperation(execution);
}
else
{
throw new ActivitiException("No outgoing sequence flow of element '" + flowNode.Id + "' could be selected for continuing the process");
}
}
else
{
// Leave, and reuse the incoming sequence flow, make executions for all the others (if applicable)
IExecutionEntityManager executionEntityManager = commandContext.ExecutionEntityManager;
IList <IExecutionEntity> outgoingExecutions = new List <IExecutionEntity>(flowNode.OutgoingFlows.Count);
SequenceFlow sequenceFlow = outgoingSequenceFlows[0];
// Reuse existing one
execution.CurrentFlowElement = sequenceFlow;
execution.IsActive = true;
outgoingExecutions.Add(execution);
// Executions for all the other one
if (outgoingSequenceFlows.Count > 1)
{
for (int i = 1; i < outgoingSequenceFlows.Count; i++)
{
IExecutionEntity parent = !(execution.ParentId is null) ? execution.Parent : execution;
IExecutionEntity outgoingExecutionEntity = commandContext.ExecutionEntityManager.CreateChildExecution(parent);
SequenceFlow outgoingSequenceFlow = outgoingSequenceFlows[i];
outgoingExecutionEntity.CurrentFlowElement = outgoingSequenceFlow;
executionEntityManager.Insert(outgoingExecutionEntity);
outgoingExecutions.Add(outgoingExecutionEntity);
}
}
// Leave (only done when all executions have been made, since some queries depend on this)
foreach (IExecutionEntity outgoingExecution in outgoingExecutions)
{
Context.Agenda.PlanContinueProcessOperation(outgoingExecution);
}
}
}
public void Clear()
{
first = second = null;
}
/// <summary>
/// Creates a new available expression with the given binary expression.
/// </summary>
/// <param name="expression">The binary expression represented by this instance.</param>
public AvailableExpression(FlowNode node, BinaryExpression expression) : this(node, (Expression)expression)
{
}
public AssignNode(Symbol symbol, IsNull isNull, FlowNode next)
: base(next)
{
this.symbol = symbol;
this.isNull = isNull;
}
/// <summary>
/// Creates a new available expression with the given invocation expression.
/// </summary>
/// <param name="expression">The invocation expression represented by this instance.</param>
public AvailableExpression(FlowNode node, InvocationExpression expression) : this(node, (Expression)expression)
{
}
/// <summary>
///
/// </summary>
/// <param name="flowNode"></param>
/// <returns></returns>
protected internal virtual bool IsExtraScopeNeeded(FlowNode flowNode)
{
return(flowNode.SubProcess is object);
}
public Node Create(Program parentProgram)
{
FlowNode node = (Activator.CreateInstance(FlowNodeType) as FlowNode).SetSource(Identifier, 0).SetPosition(new VectorPosition(0, 0)).SetProgram(parentProgram) as FlowNode;
return(node);
}
///-------------------------------------------------------------------------
abstract protected void OnRegisterPorts(FlowNode node);
sealed protected override void OnRegisterDerivedPorts(FlowNode node)
{
node.AddFlowInput("In", (f) => { Begin(Invoke(), f); });
}
// TODO: Consider splitting into multiple methods to increase readability
public GeneratedGraphs Translate()
{
this.builder = new FlowGraphBuilder(this.flowGraphId);
this.ingoingEdges = this.ComputeIngoingEdges(this.BuildGraph);
this.expressionTranslator = new ExpressionTranslator(this);
this.buildToFlowVariablesMap = new OrdinalOverlay <BuildVariableId, BuildVariable, FlowVariable>();
this.buildToFlowNodesMap = new OrdinalOverlay <BuildNodeId, BuildNode, FlowNodeMappedInfo>();
var nodeQueue = new Queue <BuildNode>();
var edgeQueue = new Queue <EdgeInfo>();
var visitedNodes = new OrdinalOverlay <BuildNodeId, BuildNode, bool>();
var buildParameters = this.BuildGraph.Variables
.Where(v => v.Origin == VariableOrigin.Parameter || v.Origin == VariableOrigin.This);
var flowParameters = new List <FlowVariable>();
foreach (var parameter in buildParameters)
{
flowParameters.Add(this.TranslateVariable(parameter));
}
var flowEnterNode = this.builder.AddEnterNode(flowParameters);
this.buildToFlowNodesMap[this.BuildGraph.EnterNode] = flowEnterNode;
visitedNodes[this.BuildGraph.EnterNode] = true;
Contract.Assert(this.BuildGraph.EnterNode.OutgoingEdges.Count == 1);
var firstNonEnterNode = this.BuildGraph.EnterNode.OutgoingEdges.Single().To;
nodeQueue.Enqueue(firstNonEnterNode);
visitedNodes[firstNonEnterNode] = true;
while (nodeQueue.Count > 0)
{
var buildNode = nodeQueue.Dequeue();
Contract.Assert(visitedNodes[buildNode]);
Contract.Assert(this.buildToFlowNodesMap[buildNode].FlowNode == null);
BuildNode firstBuildNode, lastBuildNode;
var flowNode = this.TryTranslateBorderNode(buildNode);
if (flowNode != null)
{
firstBuildNode = buildNode;
lastBuildNode = buildNode;
this.buildToFlowNodesMap[buildNode] = flowNode;
}
else
{
this.ProcessInnerNodesSequence(buildNode, out firstBuildNode, out lastBuildNode, out var operations);
flowNode = this.builder.AddInnerNode(operations, lastBuildNode.Flags); // TODO: Handle flag merging when there are flag types that need it
this.MapAssignmentsToFlowNode(firstBuildNode, lastBuildNode, flowNode);
}
// TODO: Try to get rid of the empty nodes (empty blocks etc.)
Contract.Assert(flowNode != null);
foreach (var edge in lastBuildNode.OutgoingEdges)
{
if (!visitedNodes[edge.To])
{
nodeQueue.Enqueue(edge.To);
visitedNodes[edge.To] = true;
}
}
foreach (var edgeInfo in this.ingoingEdges[firstBuildNode])
{
var flowFromNode = this.buildToFlowNodesMap[edgeInfo.From].FlowNode;
if (flowFromNode == null)
{
edgeQueue.Enqueue(edgeInfo);
}
else
{
this.TranslateEdge(edgeInfo.Edge, edgeInfo.From, flowFromNode, flowNode);
}
}
}
while (edgeQueue.Count > 0)
{
var edgeInfo = edgeQueue.Dequeue();
FlowNode flowFrom = this.buildToFlowNodesMap[edgeInfo.From];
FlowNode flowTo = this.buildToFlowNodesMap[edgeInfo.Edge.To];
Contract.Assert(flowFrom != null);
Contract.Assert(flowTo != null);
this.TranslateEdge(edgeInfo.Edge, edgeInfo.From, flowFrom, flowTo);
}
this.FlowGraph = this.builder.FreezeAndReleaseGraph();
this.FinishDisplayGraph();
return(new GeneratedGraphs(this.FlowGraph, this.DisplayGraph));
}
public void Initialize(FlowNode node)
{
this.m_FlowNode = node;
}
/// <summary>
/// Sets the target flow node of this sequence flow.
/// </summary>
/// <param name="target"> the target of this sequence flow </param>
/// <returns> the builder object </returns>
public virtual B to(FlowNode target)
{
element.Target = target;
target.Incoming.Add(element);
return(myself);
}
/// <summary>
/// 创建人工节点
/// </summary>
/// <param name="setting"></param>
/// <param name="displayName"></param>
/// <param name="actioner"></param>
/// <param name="humanResultTo"></param>
/// <param name="nexts"></param>
/// <returns></returns>
public static FlowStep CreateHuman(ActivitySetting setting
, string displayName
, Expression<Func<ActivityContext, string[]>> actioner
, Variable<string> humanResultTo
, IDictionary<string, FlowNode> nexts
, FlowNode defaultFlowNode)
{
return null;
//return CreateHuman(setting
// , displayName
// , new Taobao.Activities.Expressions.LambdaValue<string[]>(actioner)
// , humanResultTo
// , nexts
// , defaultFlowNode);
}
/// <summary>
/// Gets the alias information of a variable at the entry of the given node.
/// </summary>
/// <param name="variableName">The name of the variable to get the alias information of.</param>
/// <param name="node">The node where to get the alias information of.</param>
/// <returns>The alias information.</returns>
public IEnumerable <VariableAlias> GetAliasesOfVariableBefore(string variableName, FlowNode node)
{
return(_GetAliases(Entry[node], variableName));
}
/// <summary>
/// 创建人工节点
/// </summary>
/// <param name="setting"></param>
/// <param name="displayName"></param>
/// <param name="actioner"></param>
/// <param name="humanResultTo"></param>
/// <param name="nexts"></param>
/// <param name="defaultFlowNode"></param>
/// <returns></returns>
public static FlowStep CreateHuman(ActivitySetting setting
, string displayName
, IActionersHelper actioner//Activity<string[]> actioner
, Variable<string> humanResultTo
, IDictionary<string, FlowNode> nexts
, FlowNode defaultFlowNode)
{
var human = CreateHuman(setting, displayName, actioner, humanResultTo);
var step = new FlowStep();
step.Action = human;
if (nexts == null && defaultFlowNode == null) return step;
//设置finish cases
//HACK:在进入switch之前就已经计算出任务结果
var flowSwitch = new FlowSwitch<string>(o => humanResultTo.Get(o));
if (defaultFlowNode != null)
flowSwitch.Default = defaultFlowNode;
if (nexts != null)
nexts.ToList().ForEach(o => flowSwitch.Cases.Add(o.Key, o.Value));
step.Next = flowSwitch;
return step;
}
private void Visit(FlowNode node, Knowledge knowledge)
{
// Memoize the results so we don't do more work than necessary. This is
// also required to handle loops without hanging.
Result result = new Result(node, knowledge);
if (results.Contains(result)) {
return;
}
results.Add(result);
// Add to the knowledge flowing through this path, but stop if flow stops
knowledge = knowledge.Clone();
if (!node.Update(knowledge)) {
return;
}
// Merge that knowledge into the total knowledge for this node
if (node.knowledge != null) {
node.knowledge.UnionWith(knowledge);
} else {
node.knowledge = knowledge.Clone();
}
// Propagate flow to next links
foreach (FlowNode next in node.next) {
Visit(next, knowledge);
}
}
/// <summary>
/// 创建并行节点
/// </summary>
/// <param name="setting"></param>
/// <param name="displayName"></param>
/// <param name="completionScript"></param>
/// <param name="next"></param>
/// <param name="branchs"></param>
/// <returns></returns>
public static FlowStep CreateParallel(ActivitySetting setting
, string displayName
, string completionScript
, FlowNode next
, params Custom[] branchs)
{
return new FlowStep() { Action = CreateCustomParallel(setting, displayName, completionScript, branchs), Next = next };
}
public AliasNode(Symbol leftSymbol, Symbol rightSymbol, FlowNode next)
: base(next)
{
this.leftSymbol = leftSymbol;
this.rightSymbol = rightSymbol;
}
/// <summary>
/// 创建SubProcess子流程节点
/// </summary>
/// <param name="setting"></param>
/// <param name="displayName"></param>
/// <param name="serverScript">节点执行内容脚本</param>
/// <param name="finishRule">节点完成规则</param>
/// <param name="serverScriptResultTo">执行内容的结果输出到指定变量</param>
/// <param name="serverResultTo">节点执行结果输出到变量</param>
/// <param name="nexts"></param>
/// <param name="defaultFlowNode"></param>
/// <returns></returns>
public static FlowStep CreateSubProcess(ActivitySetting setting
, string displayName
, IDictionary<string, string> finishRule
, Variable<string> resultTo
, IDictionary<string, FlowNode> nexts
, FlowNode defaultFlowNode)
{
var server = CreateSubProcess(setting, displayName, finishRule, resultTo);
var step = new FlowStep();
step.Action = server;
if (nexts == null && defaultFlowNode == null) return step;
//设置finish cases
var flowSwitch = new FlowSwitch<string>(o => resultTo.Get(o));
if (defaultFlowNode != null)
flowSwitch.Default = defaultFlowNode;
if (nexts != null)
nexts.ToList().ForEach(o => flowSwitch.Cases.Add(o.Key, o.Value));
step.Next = flowSwitch;
return step;
}
public override Null Visit(FuncDef node)
{
// Make a new end node to start off the flow
FlowNode root = new FlowNode();
nodeMap.Add(node, root);
next.Set(root);
node.block.Accept(this);
for (int i = node.argDefs.Count - 1; i >= 0; i--) {
node.argDefs[i].Accept(this);
}
roots.Add(next.Get());
return null;
}
private bool _IsExpectedTransfer(FlowNode node, string sourceMethod, string targetMethod, bool transferTo, bool transferBack)
{
return(node is FlowTransfer transfer &&
transfer.TransfersTo == transferTo && transfer.TransfersBack == transferBack &&
transfer.SourceMethod.Equals(sourceMethod) && transfer.TargetMethod.Equals(targetMethod));
}
public FlowNode Get()
{
// Merge multiple next flow nodes to make sure there is only one next flow node
if (second != null) {
first = new FlowNode(first, second);
second = null;
nodes.Add(first);
}
return first;
}
private bool _IsExpectedBoundary(FlowNode node, string methodName, FlowKind kind)
{
return(node is FlowBoundary boundary &&
boundary.MethodName.Equals(methodName) && boundary.Kind == kind);
}
public void Set(FlowNode trueNode, FlowNode falseNode)
{
nodes.Add(trueNode);
nodes.Add(falseNode);
first = trueNode;
second = falseNode;
}
private static bool BFS(Dictionary<uint, Dictionary<uint, FlowEdge>> neighbours, uint source, uint sink, out FlowNode path)
{
path = null;
Queue<FlowNode> open = new Queue<FlowNode>();
open.Enqueue(new FlowNode(source, null, int.MaxValue));
HashSet<uint> done = new HashSet<uint>();
done.Add(source);
FlowNode node;
while (open.Count > 0)
{
node = open.Dequeue();
foreach (uint i in neighbours[node.Node].Keys)
{
if (done.Contains(i) || neighbours[node.Node][i].Residual == 0)
continue;
if (i == sink)
{
path = new FlowNode(i, node, Math.Min(neighbours[node.Node][i].Residual, node.Capacity));
return true;
}
open.Enqueue(new FlowNode(i, node, Math.Min(neighbours[node.Node][i].Residual, node.Capacity)));
done.Add(i);
}
}
return false;
}
public BlockerNode(FlowNode next)
: base(next)
{
}
public void FlowUpdate (){
FlowNode[] buffer = new FlowNode[graph.Length];
for( int i = 0; i < graph.Length; i++ ) {
buffer[i] = ((FlowNode)graph[i]).Clone();
}
int k= 0;
while( k < graphnodespercycle ){
k++;
graph_cycle++;
if( graph_cycle == graph.Length ) graph_cycle = 0;
int i=0;
i = graph_cycle;
FlowNode node= graph[i] as FlowNode;
float node_h = node.worldposition.y + node.additionalheight + node.water;
ArrayList nlink_flow_node = new ArrayList();
ArrayList nlink_flow_water= new ArrayList();
float total_waterflow= 0.0f;
float fluid_flow_magnitude= 0.0f;
// run loops if this node contains water
if( node.water > 0.0f ) {
// Get nodes that water flows to plus height differences
for( int j = 0; j < node.vertexlinks.Length; j++ ) {
FlowNode n = buffer[node.vertexlinks[j]] as FlowNode;
float node_link_h = n.worldposition.y + n.additionalheight + n.water;
if( node_h > node_link_h ) {
float node_diff = node_h - node_link_h;
nlink_flow_node.Add(n);
nlink_flow_water.Add(node_diff);
total_waterflow += node_diff;
node_diff = Mathf.Min(node_diff, node.water);
if( node_diff > fluid_flow_magnitude ) fluid_flow_magnitude = node_diff;
}
}
// Subtract water from center node
buffer[i].water -= fluid_flow_magnitude * fluidViscosity;
// Flow off edge
if( node.isEdge && node.water > 0 ) buffer[i].water = 0;
// Calculate water distribution between node links
if( total_waterflow > 0.0f ){
for( int j = 0; j < nlink_flow_node.Count; j++ ) {
FlowNode n = nlink_flow_node[j] as FlowNode;
float nw = (float)nlink_flow_water[j];
n.water += (nw / total_waterflow) * fluid_flow_magnitude * fluidViscosity;
}
}
}
}
for (int i = 0; i < graph.Length; i++) {
FlowNode node = (FlowNode)buffer[i];
Vector3 flowdirection = Vector3.zero;
for (int j = 0; j < node.vertexlinks.Length; j++) {
FlowNode linkedNode = (FlowNode)buffer[node.vertexlinks[j]];
float heightDifference = ((node.water + node.additionalheight + node.worldposition.y) - (linkedNode.water + linkedNode.additionalheight + linkedNode.worldposition.y));
if (heightDifference > 0) {
flowdirection += Vector3.Normalize(new Vector3(linkedNode.worldposition.x - node.worldposition.x, 0, linkedNode.worldposition.z - node.worldposition.z)) * heightDifference;
}
}
node.flowdirection = flowdirection;
}
graph = buffer;
}
private IFlowSwitchLink DeleteLinkImpl(Connector link, bool isMoveOrAutoSplit = false,
HashSet <ModelItem> referenceUpdatedModelItems = null)
{
IFlowSwitchLink caseKey = null;
ModelItem linkModelItem = FlowchartDesigner.GetLinkModelItem(link);
if (referenceUpdatedModelItems != null &&
referenceUpdatedModelItems.Contains(linkModelItem))
{
return(caseKey);
}
ConnectionPoint srcConnectionPoint = FreeFormPanel.GetSourceConnectionPoint(link);
ConnectionPoint destConnectionPoint = FreeFormPanel.GetDestinationConnectionPoint(link);
if (typeof(FlowStep).IsAssignableFrom(linkModelItem.ItemType))
{
linkModelItem.Properties["Next"].SetValue(null);
}
else if (typeof(FlowDecision).IsAssignableFrom(linkModelItem.ItemType))
{
//Determine if it is True or False branch.
if (srcConnectionPoint.Equals(FlowchartDesigner.GetTrueConnectionPoint(srcConnectionPoint.ParentDesigner)))
{
//True branch
linkModelItem.Properties["True"].SetValue(null);
}
else
{
linkModelItem.Properties["False"].SetValue(null);
}
}
else if (typeof(IFlowSwitchLink).IsAssignableFrom(linkModelItem.ItemType))
{
IFlowSwitchLink flowSwitchLink = (IFlowSwitchLink)linkModelItem.GetCurrentValue();
caseKey = flowSwitchLink;
//Transitioning from the fakeModelItem world to the real ModelItem world.
FlowNode fs = flowSwitchLink.ParentFlowSwitch;
ModelItem realFlowSwitchMI = (this.ModelItem as IModelTreeItem).ModelTreeManager.WrapAsModelItem(fs);
if (referenceUpdatedModelItems != null &&
referenceUpdatedModelItems.Contains(realFlowSwitchMI))
{
return(caseKey);
}
if (flowSwitchLink.IsDefaultCase)
{
realFlowSwitchMI.Properties["Default"].SetValue(null);
if (!isMoveOrAutoSplit)
{
realFlowSwitchMI.Properties[FlowSwitchLabelFeature.DefaultCaseDisplayNamePropertyName].SetValue(FlowSwitchLabelFeature.DefaultCaseDisplayNameDefaultValue);
}
}
else
{
GenericFlowSwitchHelper.RemoveCase(realFlowSwitchMI.Properties["Cases"], flowSwitchLink.CaseObject);
}
}
else // StartNode
{
this.ModelItem.Properties["StartNode"].SetValue(null);
}
this.StoreConnectorViewState(linkModelItem, null, srcConnectionPoint, true);
return(caseKey);
}
sealed protected override void OnRegisterPorts(FlowNode node)
{
var o = node.AddFlowOutput(" ");
node.AddFlowInput(" ", (Flow f) => { Invoke(); o.Call(f); });
}
public FlowNode(uint node, FlowNode parent, uint capacity)
{
this.Node = node;
this.Parent = parent;
this.Capacity = capacity;
}
public abstract void RegisterPorts(FlowNode node);
//since we want to check the condition per frame, this is implementing this way instead of a parameter
protected override void OnRegisterExtraPorts(FlowNode node)
{
condition = node.AddValueInput <bool>("Condition");
}
//public virtual void Push(ItemDefinition value)
//{
// if (value == null)
// throw new ArgumentNullException(nameof(value));
// this.itemDefinitions.Add(value.Id, value);
// this.elements.Add(value.Id, value);
// Queue<Action<object>> queue = null;
// if(this.requestQueues.TryGetValue(value.Id, out queue))
// {
// while(queue.Count > 0)
// {
// var action = queue.Dequeue();
// action(value);
// }
// this.requestQueues.Remove(value.Id);
// }
//}
//public virtual void Push(Message value)
//{
// if (value == null)
// throw new ArgumentNullException(nameof(value));
// this.messages.Add(value.Id, value);
// this.elements.Add(value.Id, value);
// Queue<Action<object>> queue = null;
// if (this.requestQueues.TryGetValue(value.Id, out queue))
// {
// while (queue.Count > 0)
// {
// var action = queue.Dequeue();
// action(value);
// }
// this.requestQueues.Remove(value.Id);
// }
//}
public virtual void AddFlowNode(FlowNode flowNode)
{
this.flowNodes.Add(flowNode);
}
