void MakeNodeToOptionConnection(int idFrom, int idTo, NodeType targetType)
{
if (targetType == NodeType.Option)
{
DialogueNode node = CurrentNodes[idFrom];
List <int> optionsAttachedToNode = new List <int>(node.OptionsAttached);
if (!EditorInfo.NodesOptionsFoldouts.ContainsKey(node.NodeID))
{
EditorInfo.NodesOptionsFoldouts.Add(node.NodeID, new Dictionary <int, bool>());
}
if (!optionsAttachedToNode.Contains(idTo))
{
optionsAttachedToNode.Add(idTo);
node.OptionsAttached = optionsAttachedToNode.ToArray();
EditorInfo.NodesOptionsFoldouts[node.NodeID].Add(idTo, false);
}
}
else
{
if (targetType == NodeType.Node)
{
DialogueOption option = CurrentOptions[idFrom];
if (idTo != Dialogue.ExitDialogue)
{
option.SetNext(idTo, NodeType.Node);
}
else
{
option.SetNextNodeExit();
}
}
}
ClearAllConnectionsPending();
}
private void AddContinueButton(int indexer = 0)
{
int nxt = DialogueShown.CurrentNode.TargetID;
NodeType nxtType = DialogueShown.CurrentNode.TargetType;
DialogueOption continueOption = new DialogueOption();
continueOption.OptionText = "[Continue]";
continueOption.OptionID = int.MaxValue;
continueOption.SetNext(nxt, nxtType);
GameObject prefabCreated = Instantiate(OptionButtonPrefab, this.transform);
OptionButtonScript obs = prefabCreated.GetComponent <OptionButtonScript>();
obs.SetNumber(++indexer);
obs.SetText(continueOption.OptionText);
obs.SetOption(continueOption);
DialogueLog.Insert(indexer, prefabCreated);
AddSeparator(indexer + 1);
}
void UpdateCurves()
{
Event currentEvent = Event.current;
Rect cursorRect = new Rect(currentEvent.mousePosition, new Vector2(5, 5));
foreach (Rect win in EditorInfo.Windows)
{
if (win.Contains(currentEvent.mousePosition))
{
cursorRect = win;
}
}
bool repaint = false;
bool save = false;
#region Immediate Node connections creation
if (nodeToNodeToAttach.Count == 1)
{
int from = EditorInfo.NodesIndexes[nodeToNodeToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.ImmidiateNodeConnection);
repaint = true;
}
else
{
if (nodeToNodeToAttach.Count == 2)
{
MakeImmediateNodeConnection(
nodeToNodeToAttach[0],
nodeToNodeToAttach[1],
(nodeToNodeToAttach[1] == Dialogue.ExitDialogue)?
NodeType.Exit : NodeType.Node);
save = true;
}
}
#endregion
#region Node To Option Connections creation
if (nodeToOptionToAttach.Count == 1)
{
int from = EditorInfo.NodesIndexes[nodeToOptionToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.NodeToOptionConnection);
repaint = true;
}
else
{
if (nodeToOptionToAttach.Count == 2)
{
MakeNodeToOptionConnection(nodeToOptionToAttach[0], nodeToOptionToAttach[1], NodeType.Option);
save = true;
}
}
#endregion
#region Option To Node Connection creation
if (optionToNodeToAttach.Count == 1)
{
int from = EditorInfo.OptionsIndexes[optionToNodeToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.OptionToNodeConnection);
repaint = true;
}
else
{
if (optionToNodeToAttach.Count == 2)
{
MakeNodeToOptionConnection(optionToNodeToAttach[0], optionToNodeToAttach[1], NodeType.Node);
save = true;
}
}
#endregion
#region Conditions Connections
#region Immediate Node -> Condition
if (nodeToConditionToAttach.Count == 1)
{
int from = EditorInfo.NodesIndexes[nodeToConditionToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.ToConditionConnection);
repaint = true;
}
else
{
if (nodeToConditionToAttach.Count == 2)
{
MakeImmediateNodeConnection(
nodeToConditionToAttach[0],
nodeToConditionToAttach[1],
(nodeToConditionToAttach[1] == Dialogue.ExitDialogue)? NodeType.Exit : NodeType.Condition
);
save = true;
}
}
#region Option -> Condtion
if (optionToConditionToAttach.Count == 1)
{
int from = EditorInfo.OptionsIndexes[optionToConditionToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.ToConditionConnection);
repaint = true;
}
else
{
if (optionToConditionToAttach.Count == 2)
{
DialogueOption optionFrom = CurrentOptions[optionToConditionToAttach[0]];
optionFrom.SetNext(optionToConditionToAttach[1], NodeType.Condition);
optionToConditionToAttach.Clear();
optionToNodeToAttach.Clear();
}
}
#endregion
#endregion
#region Condition -> [Success] -> Condition
if (conditionSuccessToConditionToAttach.Count == 1)
{
int from = EditorInfo.ConditionsIndexes[conditionSuccessToConditionToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.FromSuccesConnection);
repaint = true;
}
else
{
if (conditionSuccessToConditionToAttach.Count == 2)
{
MakeConditionNodeConnection(
conditionSuccessToConditionToAttach[0],
conditionSuccessToConditionToAttach[1],
NodeType.Condition,
true
);
save = true;
}
}
#endregion
#region Condition -> [Success] -> Node
if (conditionSuccessToNodeToAttach.Count == 1)
{
int from = EditorInfo.ConditionsIndexes[conditionSuccessToNodeToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.FromSuccesConnection);
repaint = true;
}
else
{
if (conditionSuccessToNodeToAttach.Count == 2)
{
MakeConditionNodeConnection(
conditionSuccessToNodeToAttach[0],
conditionSuccessToNodeToAttach[1],
NodeType.Node,
true
);
save = true;
}
}
#endregion
#region Condition -> [Failure] -> Condition
if (conditionFailToConditionToAttach.Count == 1)
{
int from = EditorInfo.ConditionsIndexes[conditionFailToConditionToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.FromFailureConnection);
repaint = true;
}
else
{
if (conditionFailToConditionToAttach.Count == 2)
{
MakeConditionNodeConnection(
conditionFailToConditionToAttach[0],
conditionFailToConditionToAttach[1],
NodeType.Condition,
false
);
save = true;
}
}
#endregion
#region Condition -> [Failure] -> Node
if (conditionFailToNodeToAttach.Count == 1)
{
int from = EditorInfo.ConditionsIndexes[conditionFailToNodeToAttach[0]];
DrawNodeCurve(EditorInfo.Windows[from], cursorRect, Config.FromFailureConnection);
repaint = true;
}
else
{
if (conditionFailToNodeToAttach.Count == 2)
{
MakeConditionNodeConnection(
conditionFailToNodeToAttach[0],
conditionFailToNodeToAttach[1],
NodeType.Node,
false
);
save = true;
}
}
#endregion
#region Condition -> Entry Option
if (conditionToEntryOption.Count == 1)
{
int to = EditorInfo.ConditionsIndexes[conditionToEntryOption[0]];
DrawNodeCurve(cursorRect, EditorInfo.Windows[to], Config.EntryConditionConnection);
repaint = true;
}
else
{
if (conditionToEntryOption.Count == 2)
{
int to = conditionToEntryOption[0];
if (ValidateConditionChain(to))
{
MakeConditionNodeConnection(conditionToEntryOption[0], conditionToEntryOption[1], NodeType.Option, false);
save = true;
}
else
{
WriteDebug("WARNING! Attempted illegal connection!: Entry Conditions must lead to Exit or another Condition.");
conditionToEntryOption.Clear();
}
}
}
#endregion
#endregion
#region Drawing established connections TOFINISH
foreach (DialogueNode nodeFrom in CurrentNodes)
{
int from = EditorInfo.NodesIndexes[nodeFrom.NodeID];
if (nodeFrom.ImmediateNode)
{
int targID;
NodeType targType;
nodeFrom.GetTarget(out targID, out targType);
if (targID == Dialogue.ExitDialogue)
{
continue;
}
if (targType == NodeType.Node)
{
int to = EditorInfo.NodesIndexes[targID];
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[to], Config.ImmidiateNodeConnection);
}
if (targType == NodeType.Condition)
{
int to = EditorInfo.ConditionsIndexes[targID];
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[to], Config.ToConditionConnection);
}
}
else
{
foreach (int optInd in nodeFrom.OptionsAttached)
{
int to = EditorInfo.OptionsIndexes[optInd];
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[to], Config.NodeToOptionConnection);
}
}
}
foreach (DialogueOption optionFrom in CurrentOptions)
{
int from = EditorInfo.OptionsIndexes[optionFrom.OptionID];
if (optionFrom.EntryConditionSet)
{
int entryCondition = EditorInfo.ConditionsIndexes[optionFrom.EntryCondition.ConditionID];
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[entryCondition], Config.EntryConditionConnection);
}
int to = -1;
switch (optionFrom.NextType)
{
case NodeType.Node:
to = EditorInfo.NodesIndexes[optionFrom.NextID];
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[to], Config.OptionToNodeConnection);
break;
case NodeType.Condition:
to = EditorInfo.ConditionsIndexes[optionFrom.NextID];
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[to], Config.ToConditionConnection);
break;
}
}
foreach (ConditionNode conditionFrom in CurrentConditions)
{
int from = EditorInfo.ConditionsIndexes[conditionFrom.ConditionID];
int to = Dialogue.ExitDialogue;
switch (conditionFrom.SuccessTargetType)
{
case NodeType.Condition:
to = EditorInfo.ConditionsIndexes[conditionFrom.SuccessTarget];
break;
case NodeType.Node:
to = EditorInfo.NodesIndexes[conditionFrom.SuccessTarget];
break;
}
if (to != Dialogue.ExitDialogue)
{
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[to], Config.FromSuccesConnection);
}
to = Dialogue.ExitDialogue;
switch (conditionFrom.FailureTargetType)
{
case NodeType.Condition:
to = EditorInfo.ConditionsIndexes[conditionFrom.FailureTarget];
break;
case NodeType.Node:
to = EditorInfo.NodesIndexes[conditionFrom.FailureTarget];
break;
}
if (to != Dialogue.ExitDialogue)
{
DrawNodeCurve(EditorInfo.Windows[from], EditorInfo.Windows[to], Config.FromFailureConnection);
}
}
#endregion
if (repaint)
{
Repaint();
}
if (save)
{
SaveChanges("Update Curves");
}
}
