/// <summary>
/// Construtor.
/// </summary>
/// <param name="console">Define as cores padrão no console.</param>
/// <param name="translate">Manipula traduções de texto.</param>
/// <param name="loaderAssembly">Carregador de assembly em disco para a memória.</param>
/// <param name="multipleInput">Gerencia múltiplos IInput.</param>
/// <param name="multipleOutput">Gerencia múltiplos IOutput.</param>
/// <param name="multipleModule">Gerencia múltiplos IModule.</param>
public Engine(
IConsole console,
ITranslate translate,
ILoaderAssembly loaderAssembly,
IMultipleInput multipleInput,
IMultipleOutput multipleOutput,
IMultipleModule multipleModule)
{
_console = console;
_translate = translate;
_loaderAssembly = loaderAssembly;
_multipleInput = multipleInput;
_multipleOutput = multipleOutput;
_multipleModule = multipleModule;
}
public virtual Node NextNode()
{
IOutput sOutputNode = this as IOutput;
if (sOutputNode != null)
{
return(CheckNextNodePort(sOutputNode.OutputPort));
}
IMultipleOutput mOutputNode = this as IMultipleOutput;
if (mOutputNode != null)
{
return(mOutputNode.NextNode());
}
return(null);
}
public void OnBeforeSerialize()
{
if (_endNode == null && End != null && End.Node != null)
{
_endNode = End.Node;
}
if (_startNode == null && Start != null && Start.Node != null)
{
_startNode = Start.Node;
}
if (_startNode == null)
{
//Debug.Log("Null shit node");
return;
}
if (Start == null)
{
//Debug.Log("Null output port?");
return;
}
IMultipleOutput mOutput = _startNode.PortHandler.multipleOutputNode;
if (mOutput != null)
{
//OutputPort[] outputs = mOutput.GetOutputs().ToArray();
//_contingencyPlan = Array.IndexOf(outputs, Start);
//List<OutputPort> outputs = mOutput.GetOutputs().ToList();
//_contingencyPlan = outputs.IndexOf(Start);
List <int> outputs = ElementsOf(mOutput.GetOutputs(), outputPort => outputPort.ID).ToList();
_contingencyPlan = outputs.IndexOf(Start.ID);
//if (_contingencyPlan != -1)
//Debug.Log(mOutput + " " + _contingencyPlan);
//else Debug.LogError("WHY!?");
}
}
public static void FixNodeOutput(OutputPort output, int contingencyPlan)
{
Node node = output.Node;
if (node == null)
{
Debug.LogWarning("Null node on attempt to fix output port.");
return;
}
if (node.PortHandler.outputNode != null)
{
node.PortHandler.outputNode.OutputPort = output;
}
else if (node.PortHandler.multipleOutputNode != null)
{
IMultipleOutput mOutput = node.PortHandler.multipleOutputNode;
OutputPort[] outputs = mOutput.GetOutputs().ToArray();
if (contingencyPlan >= 0 && contingencyPlan < outputs.Length)
{
mOutput.ReplacePort(outputs[contingencyPlan], output);
}
}
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="multipleOutput">Gerencia múltiplas instâncias da mesma interface: IOutput</param>
/// <param name="multipleInput">Gerencia múltiplas instâncias da mesma interface: IInput</param>
public Interaction(IMultipleOutput multipleOutput, IMultipleInput multipleInput)
{
_multipleOutput = multipleOutput;
_multipleInput = multipleInput;
}
private void CheckHoveringAndSelection()
{
if (_isLayoutEvent)
{
return;
}
ResetHover();
bool isDraggingGrid = _currentActivity == Activity.DraggingGrid;
Rect selectionRect = _selectionRect;
Vector2 mousePosition = _mousePosition;
List <Object> boxSelected = new List <Object>();
//TODO Investigate reverse recognition not working!?
//Never mind it works, it's just my architecture works bottom-top,
//instead of top-bottom-or-stop
//Why? Cause hovering
//TODO Investigate alternatives for conversion
for (int i = 0; i < Graph.NodeCount; i++)
{
Node node = Graph.GetNode(i);
NodeEditor nodeEditor = NodeEditor.GetEditor(node);
Vector2 size;
if (_nodeSizes.TryGetValue(node, out size))
{
Rect nodeRect = new Rect(node.Position, size);
nodeRect = GridToWindowRect(nodeRect);
if (nodeRect.Contains(mousePosition))
{
_hoveredNode = node;
}
if (isDraggingGrid && nodeRect.Overlaps(selectionRect))
{
boxSelected.Add(node);
}
}
//Check hovering over ports
var inputNode = node as IInput;
if (inputNode != null)
{
InputPort input = inputNode.InputPort;
Rect inputRect = nodeEditor.GetPortRect(input);
//inputRect.position += node.Position;
inputRect = GridToWindowRect(inputRect);
if (inputRect.Contains(mousePosition))
{
HoveredPort = input;
}
}
IOutput sOutputNode = node as IOutput;
if (sOutputNode != null)
{
OutputPort output = sOutputNode.OutputPort;
Rect outputRect = nodeEditor.GetPortRect(output);
//outputRect.position += node.Position;
outputRect = GridToWindowRect(outputRect);
if (outputRect.Contains(mousePosition))
{
HoveredPort = output;
}
}
IMultipleOutput mOutputNode = node as IMultipleOutput;
if (mOutputNode != null)
{
var outputs = mOutputNode.GetOutputs();
foreach (OutputPort output in outputs)
{
Rect outputRect = nodeEditor.GetPortRect(output);
//outputRect.position += node.Position;
outputRect = GridToWindowRect(outputRect);
if (outputRect.Contains(mousePosition))
{
HoveredPort = output;
}
}
}
}
for (int i = 0; i < Graph.ConnectionCount; i++)
{
Connection connection = Graph.GetConnection(i);
if (connection == null)
{
Debug.Log("Null connection at index " + i);
OnNull(Graph);
continue;
}
Vector2 start = NodeEditor.FindPortRect(connection.Start).center;
Vector2 end = NodeEditor.FindPortRect(connection.End).center;
start = GridToWindowPosition(start);
end = GridToWindowPosition(end);
//if (OtherUtilities.PointOverlapBezier(mousePosition, start, end, NodePreferences.CONNECTION_WIDTH))
if (LineSegment.WideLineSegmentPointCheck(mousePosition, start, end, NodePreferences.CONNECTION_WIDTH * 2 / Zoom))
{
_hoveredConnection = connection;
}
//DONE: Add range percentage overlap check, as just overlapping might be too annoying.
if (isDraggingGrid && LineSegment.LineRectOverlapPercentageCheck(selectionRect, start, end) > 0.3f)
{
boxSelected.Add(connection);
}
Rect[] modifierRects;
if (!_connectionModifierRects.TryGetValue(connection, out modifierRects))
{
continue;
}
for (int j = 0; j < connection.InstructionCount; j++)
{
Instruction mod = connection.GetInstruction(j);
Rect rect = GridToWindowRect(modifierRects[j]);
if (rect.Contains(mousePosition))
{
_hoveredInstruction = mod;
}
if (isDraggingGrid && rect.Overlaps(selectionRect))
{
boxSelected.Add(mod);
}
}
}
//return;
if (isDraggingGrid)
{
if (_cachedEvent.control || _cachedEvent.shift)
{
boxSelected.AddRange(_cachedSelectedObjects);
}
Selection.objects = boxSelected.ToArray();
}
else
{
_selectionRect = Rect.zero;
}
}
public PortHandler(Node node)
{
inputNode = node as IInput;
outputNode = node as IOutput;
multipleOutputNode = node as IMultipleOutput;
}
