private DialogueNodeData SaveNodeData(DialogueNode _node)
{
DialogueNodeData dialogueNodeData = new DialogueNodeData
{
NodeGuid = _node.NodeGuid,
Position = _node.GetPosition().position,
TextType = _node.Texts,
Name = _node.Name,
AudioClips = _node.AudioClips,
DialogueFaceImageType = _node.FaceImageType,
Sprite = _node.FaceImage,
Background = _node.BackGround,
DialogueNodePorts = new List <DialogueNodePort>(_node.DialogueNodePorts)
};
foreach (DialogueNodePort nodePort in dialogueNodeData.DialogueNodePorts)
{
nodePort.OutputGuid = string.Empty;
nodePort.InputGuid = string.Empty;
foreach (Edge edge in edges)
{
if (edge.output == nodePort.MyPort)
{
nodePort.OutputGuid = (edge.output.node as BaseNode).NodeGuid;
nodePort.InputGuid = (edge.input.node as BaseNode).NodeGuid;
}
}
}
return(dialogueNodeData);
}
protected override void OnInit(Camera UICamera)
{
base.OnInit(UICamera);
LeftIcon = CacheTransform.Find("Content/LeftImage").GetComponent <Image>();
RightIcon = CacheTransform.Find("Content/RightImage").GetComponent <Image>();
LeftModel = CacheTransform.Find("Content/LeftModel");
RightModel = CacheTransform.Find("Content/RightModel");
ShowText = CacheTransform.Find("Content/ShowText").GetComponent <Text>();
TitleText = CacheTransform.Find("Content/TitleText").GetComponent <Text>();
for (int i = 0; i < 4; i++)
{
Answers[i] = CacheTransform.Find("Content/AnswerBtn" + (i + 1)).gameObject;
EventTriggerListener.Get(Answers[i].gameObject).SetEventHandle(EnumTouchEventType.OnClick, (a, b, c) =>
{
StopContentText();
string nextNode = NodeData.Answers[(int)(c[0])].Target;
if (nextNode == "end")
{
//关闭界面
Singleton <WindowManager> .GetInstance().CloseWindow(false, "Dialogue");
return;
}
NodeData = GetDialogue(nextNode);
Coroutine = SingletonMono <GameFrameWork> .GetInstance().StartCoroutine(ShowContentText());
}, i);
}
}
private void CreateNodes()
{
foreach (var nodeData in containerCache.baseNodesData)
{
switch (nodeData.nodeType)
{
case NodeType.StartNode:
var startNode = new BaseNode(nodeData.nodeType, targetGraphView, nodeData.position, nodeData.guid);
targetGraphView.AddElement(startNode);
break;
case NodeType.DialogueNode:
DialogueNodeData dialogueData = containerCache.dialogueNodesData.Find(x => x.guid == nodeData.guid);
var dialogueNode = new DialogueNode(targetGraphView, nodeData, dialogueData);
targetGraphView.AddElement(dialogueNode);
break;
case NodeType.ChoiceNode:
ChoiceNodeData choiceData = containerCache.choiceNodesData.Find(x => x.guid == nodeData.guid);
var nodePorts = containerCache.nodeLinks.Where(x => x.thisNodeGuid == nodeData.guid).ToList();
var choiceNode = new ChoiceNode(targetGraphView, nodeData, choiceData, nodePorts);
targetGraphView.AddElement(choiceNode);
break;
case NodeType.EndNode:
var endNode = new BaseNode(nodeData.nodeType, targetGraphView, nodeData.position, nodeData.guid);
targetGraphView.AddElement(endNode);
break;
}
}
}
private bool SaveNodes(string fileName, DialogueContainer dialogueContainerObject)
{
if (!Edges.Any())
{
return(false);
}
var connectedSockets = Edges.Where(x => x.input.node != null).ToArray();
for (var i = 0; i < connectedSockets.Count(); i++)
{
var outputNode = (connectedSockets[i].output.node as DialogueNode);
var inputNode = (connectedSockets[i].input.node as DialogueNode);
dialogueContainerObject.NodeLinks.Add(new NodeLinkData
{
BaseNodeGUID = outputNode.GUID,
PortName = connectedSockets[i].output.portName,
TargetNodeGUID = inputNode.GUID
});
}
foreach (var node in Nodes.Where(node => !node.EntyPoint))
{
DialogueNodeData data = new DialogueNodeData {
NodeGUID = node.GUID,
DialogueText = node.DialogueText,
mood = node.mood,
Position = node.GetPosition().position
};
dialogueContainerObject.DialogueNodeData.Add(data);
}
return(true);
}
public void Path2()
{
//moves onto next node
currentNode = activeDialogue.FindNode(activeDialogue.ReturnValidEdges(currentNode)[1].secondNodeID);
isNode = true;
NextDialogue();
}
// Saving dialogue node
private DialogueNodeData SaveNodeData(DialogueNode node)
{
DialogueNodeData dialogueNodeData = new DialogueNodeData
{
NodeGuid = node.NodeGuid,
Position = node.GetPosition().position,
TextLanguages = node.Texts,
Name = node.NameText,
AudioClips = node.AudioClips,
npcSprite = node.NpcFaceImage,
playerSprite = node.PlayerFaceImage,
DialogueNodePorts = new List <DialogueNodePort>(node.DialogueNodePorts)
};
foreach (DialogueNodePort nodePort in dialogueNodeData.DialogueNodePorts)
{
nodePort.OutputGuid = string.Empty;
nodePort.InputGuid = string.Empty;
foreach (Edge edge in edges)
{
if (edge.output == nodePort.MyPort)
{
// Converting DialogueNode output and input guids to BaseNode for unified loading and saving
nodePort.OutputGuid = (edge.output.node as BaseNode).NodeGuid;
nodePort.InputGuid = (edge.input.node as BaseNode).NodeGuid;
}
}
}
return(dialogueNodeData);
}
public void Load(DialogueNodeData data, bool isEntryPoint = false)
{
(GUID, DialogueText, EntryPoint) =
(data.Guid, data.DialogueText, isEntryPoint);
RefreshExpandedState();
RefreshPorts();
}
public static NodePresenter Create(Vector2 position)
{
var nodeView = new DialogueNodeView(LocalizationStrings.DialogueNode, position);
var connectionPointInPresenter = new ConnectionPointPresenter(new ConnectionPointView(nodeView, ConnectionPointType.In));
var connectionPointOutPresenter = new ConnectionPointPresenter(new ConnectionPointView(nodeView, ConnectionPointType.Out));
var nodeData = new DialogueNodeData();
var nodePresenter = new DialogueNodePresenter(nodeView, nodeData, connectionPointInPresenter, connectionPointOutPresenter);
return(nodePresenter);
}
public void StartDialogue()
{
EdgeData leadingEdge = activeDialogue.GraphEdges.Where(x => x.portName == "StartNodeEdge").First();
//set current node ID to the first nodeID
currentNode = activeDialogue.NodeData.Where(x => x.nodeID == leadingEdge.secondNodeID).First();
normalText.enabled = true;
normalText.text = currentNode.dialogueTxt;
//StartCoroutine(typeSentence(currentNode.dialogueTxt));
}
void ProceedToNarrative(string narrativeDataGUID)
{
DialogueNodeData nodeData = currPatient.dialogue.DialogueNodeData.Find(x => x.NodeGUID == narrativeDataGUID);
string text = nodeData.DialogueText;
List <NodeLinkData> choices = currPatient.dialogue.NodeLinks.Where(x => x.BaseNodeGUID == narrativeDataGUID).ToList();
PatientData.PatientMoodData mood = currPatient.GetMoodData(nodeData.mood);
if (mood.mood == PatientMood.ExitNotOK)
{
AudioManager.Instance.PlayMusic(loseAmbient, time: 0.5f);
}
else if (mood.mood == PatientMood.ExitOk)
{
AudioManager.Instance.MuteMusic(AudioManager.Instance.crossfadeTime);
winAmbientAS = AudioManager.Instance.Play(winAmbient, 0.4f, 1.0f, AudioManager.Instance.crossfadeTime);
LeanTween.delayedCall(winAmbient.length - AudioManager.Instance.crossfadeTime, AudioManager.Instance.ContinueMusicAfterMute);
}
dialogLog.AddToLog(DialogLogUI.LogEntryType.Patient, ProcessProperties(text), currPatient.name, mood.backColor, currPatient, mood, () => {
AudioManager.Instance.Play(patientWriteSound, 0.5f);
}, () => {
AudioManager.Instance.Play(buttonAppear, buttonAppearVolume);
foreach (var choice in choices)
{
string choiceText = ProcessProperties(choice.PortName);
dialogSelect.AddButton(choiceText, () => {
dialogSelect.Clear();
dialogLog.AddToLog(DialogLogUI.LogEntryType.Operator, choiceText, operatorName, minTimeToCallShow: 0.5f, onShowLog: () => {
switch (mood.mood)
{
case PatientMood.ExitOk:
case PatientMood.ExitNotOK:
EndPatient();
break;
case PatientMood.Normal:
case PatientMood.Angry:
default:
ProceedToNarrative(choice.TargetNodeGUID);
break;
}
});
});
}
if (mood.mood == PatientMood.ExitOk || mood.mood == PatientMood.ExitNotOK)
{
EndPatient();
}
});
}
protected override void OnAppear(int sequence, int openOrder, WindowContext context)
{
base.OnAppear(sequence, openOrder, context);
Content = context as DialogueContent;
// LeftIcon.sprite = Content.LeftIcon;
// RightIcon.sprite = Content.RightIcon;
// Content.LeftModel.transform.SetParent(LeftModel);
// Content.RightModel.transform.SetParent(RightModel);
LoadDialogueData(Content.FileName);
this.NodeData = GetDialogue(Content.StartNode);
Coroutine = SingletonMono <GameFrameWork> .GetInstance().StartCoroutine(ShowContentText());
}
public new DialogueNodeData CopyData(bool keepGuid = true)
{
var textList = dialogueTexts.Select(textObject => textObject.text).ToList();
var data = new DialogueNodeData
{
guid = keepGuid ? guid : Guid.NewGuid().ToString(),
speaker = characterDropdown.value.PropertyName,
dialogueTexts = textList,
};
return(data);
}
private void RunNode(DialogueNodeData _nodeData)
{
lastDialogueNodeData = currentDialogueNodeData;
currentDialogueNodeData = _nodeData;
dialogueController.SetText(_nodeData.Name, _nodeData.TextType.Find(text => text.LanguageType == LanguageController.Instance.Language).LanguageGenericType);
dialogueController.SetImage(_nodeData.Sprite);
MakeButtons(_nodeData.DialogueNodePorts);
audioSource.clip = _nodeData.AudioClips.Find(clip => clip.LanguageType == LanguageController.Instance.Language).LanguageGenericType;
audioSource.Play();
}
public int ReturnPotentialEdges(DialogueNodeData current)
{
List <EdgeData> edges = GraphEdges.Where(x => x.firstNodeID == current.nodeID).ToList();
List <DialogueNodeData> nodes = new List <DialogueNodeData>();
edges.ForEach(e => NodeData.Where(n => n.nodeID == e.secondNodeID).ToList().ForEach(n => nodes.Add(n)));
List <EdgeData> validEdges = new List <EdgeData>();
nodes.ForEach(n => edges.Where(e => e.secondNodeID == n.nodeID).ToList().ForEach(e => validEdges.Add(e)));
totalEdges = validEdges.Count();
return(totalEdges);
}
//method to retun all adjacent nodes
public List <EdgeData> ReturnValidEdges(DialogueNodeData current)
{
List <EdgeData> edges = GraphEdges.Where(x => x.firstNodeID == current.nodeID).ToList();
List <DialogueNodeData> nodes = new List <DialogueNodeData>();
edges.ForEach(e => NodeData.Where(n => n.nodeID == e.secondNodeID && RealParser.RP.inv.ContainsKey(Int32.Parse(n.dialogueKey))).ToList().ForEach(n => nodes.Add(n)));
List <EdgeData> validEdges = new List <EdgeData>();
nodes.ForEach(n => edges.Where(e => e.secondNodeID == n.nodeID).ToList().ForEach(e => validEdges.Add(e)));
return(validEdges);
}
public void answerDialogue(int answer)
{
if (dialogueState == DialogueState.OPEN)
{
string nextNode = dialogueNode.answers[answer].target;
if (nextNode == "END")
{
endDialogue();
return;
}
dialogueNode = dialogueController.getDialogue(nextNode);
drawDialogue();
}
}
private void RunNode(DialogueNodeData nodeData) // Running dialogue node
{
// If the current dialogue node is different than coming dialogue node
if (currentDialogueNodeData != nodeData)
{
lastDialogueNodeData = currentDialogueNodeData; // Last dialogue node is the current node
currentDialogueNodeData = nodeData; // Current dialogue node is the coming node
}
dialogueController.SetText(nodeData.Name, nodeData.TextLanguages.Find(text => text.LanguageType == LanguageController.Instance.Language).LanguageGenericType); // Setting NPC name text and its dialogue text
dialogueController.SetImage(nodeData.playerSprite, nodeData.npcSprite); // Setting NPC and Player images to show in dialogue UI
MakeButtons(nodeData.DialogueNodePorts); // Spawning dialogue buttons based on possible dialogue options in Dialogue Node
audioSource.clip = nodeData.AudioClips.Find(clip => clip.LanguageType == LanguageController.Instance.Language).LanguageGenericType; // Getting the right NPC audio clip to play
audioSource.Play(); // Playing found clip
}
private void DisplayDialogueNode(DialogueNodeData node)
{
speakerNameLabel.text = ProcessExposedProperties(node.speakerName);
dialogueLabel.text = ProcessExposedProperties(node.dialogueText);
ClearChoiceButtons();
if (node.responses.Count == 0)
{
Button endButton = Instantiate(choiceButtonPrefab, choicesContentAreaTransform);
endButton.GetComponentInChildren <TMP_Text>().text = closeConversationLabelText;
endButton.onClick.AddListener(() => dialoguePanel.gameObject.SetActive(false));
}
else
{
GenerateChoiceButtons(node);
}
}
public void OnPasteElementsOption(string a, string b)
{
if (nodeCopyCache.Count == 0)
{
return;
}
var graphContainer = GraphSaveUtility.GetInstance(targetGraphView).GetNodesContainer();
foreach (var node in nodeCopyCache)
{
var baseNode = (BaseNode)node;
var nodeData = baseNode.CopyData(false);
// Offset pasted node
nodeData.position.y += baseNode.GetPosition().height + nodePasteOffset;
switch (nodeData.nodeType)
{
case NodeType.DialogueNode:
var dialogueNodeOriginal = node as DialogueNode;
DialogueNodeData dialogueData = dialogueNodeOriginal.CopyData();
var dialogueNode = new DialogueNode(targetGraphView, nodeData, dialogueData);
targetGraphView.AddElement(dialogueNode);
break;
case NodeType.ChoiceNode:
var choiceNodeOriginal = node as ChoiceNode;
ChoiceNodeData choiceData = choiceNodeOriginal.CopyData();
var choicePorts = graphContainer.nodeLinks.ToList().Where(x => x.thisNodeGuid == nodeData.guid).ToList();
var choiceNode = new ChoiceNode(targetGraphView, nodeData, choiceData, choicePorts);
targetGraphView.AddElement(choiceNode);
break;
case NodeType.EndNode:
var endNode = new BaseNode(nodeData.nodeType, targetGraphView, nodeData.position, nodeData.guid);
targetGraphView.AddElement(endNode);
break;
}
}
}
public DialogueNode(DialogueGraphView _graphView, BaseNodeData baseData, DialogueNodeData dialogueData)
{
graphView = _graphView;
Initialize(baseData.nodeName, baseData.guid);
SetupPorts();
var propertyIndex = _graphView.exposedProperties.FindIndex(x => x.PropertyName == dialogueData.speaker);
SetupCharacterSelection(propertyIndex);
SetPosition(new Rect(baseData.position, defaultNodeSize));
RefreshExpandedState();
RefreshPorts();
foreach (var text in dialogueData.dialogueTexts)
{
AddTextField(text);
}
}
/// <summary>
/// Generates a new DialogueNode with pre-existing data.
/// </summary>
/// <param name="onClickRemovePort">An action delegate called when the remove port button is clicked.</param>
/// <param name="nodeData">The node data to populate the node with.</param>
public DialogueNode(Action <Node, Port> onClickRemovePort, DialogueNodeData nodeData) : base(onClickRemovePort)
{
type = NodeType.Dialogue;
// Associate stylesheet
styleSheets.Add(Resources.Load <StyleSheet>("Node"));
// Set the properties from the passed in data.
Guid = nodeData.guid;
DialogueText = nodeData.dialogueText;
SpeakerName = nodeData.speakerName;
for (int i = 0; i < nodeData.responses.Count; i++)
{
AddDialogueNodePorts(nodeData.responses[i], nodeData.conditionsToToggle[i]);
}
// Add node fields
BuildNodeControls();
UpdateTitle();
}
private void GenerateChoiceButtons(DialogueNodeData node)
{
List <NodeLinkData> nodeLinks = GetLinks(node.guid);
if (nodeLinks.Count != node.responses.Count)
{
Debug.LogError(
$"Dialogue Node {node.guid} has mismatched number of links and responses. Aborting conversation.");
dialoguePanel.gameObject.SetActive(false);
return;
}
for (var i = 0; i < node.responses.Count; i++)
{
NodeLinkData link = nodeLinks[i];
string currentResponse = node.responses[i];
DialogueCondition conditionToToggle = node.conditionsToToggle[i];
Button button = Instantiate(choiceButtonPrefab, choicesContentAreaTransform);
button.GetComponentInChildren <TMP_Text>().text = currentResponse;
button.onClick.AddListener(() => OnButtonClick(link, conditionToToggle));
}
}
protected override void OnClose(WindowContext context)
{
base.OnClose(context);
this.NodeData = null;
StopContentText();
}
public DialogueData()
{
nodes = new DialogueNodeData[1];
nodes[0] = new DialogueNodeData();
}
/// <summary>
/// Creates a new DialogueNode with given values.
/// </summary>
/// <param name="nodeData">The values to initialize the node with.</param>
/// <returns>A dialogue node initialized with the given values.</returns>
public DialogueNode CreateDialogueNode(DialogueNodeData nodeData)
{
return(new DialogueNode(OnClickRemoveOutputPort, nodeData));
}
public void startDialogue(string nodeName)
{
dialogueState = DialogueState.OPEN;
dialogueNode = dialogueController.getDialogue(nodeName);
drawDialogue();
}
private bool GraphDeconstruct(DialogueContainer input)
{
while (!string.IsNullOrEmpty(currentGUID) && !textboxWait)
{
//Dialogue Node
if (input.DialogueNodeData.Any(x => x.Guid == currentGUID))
{
DialogueNodeData node = input.DialogueNodeData.First(x => x.Guid == currentGUID);
textboxWait = true;
SayDialogue dialogueCutscene = ScriptableObject.CreateInstance <SayDialogue>();
if (!string.IsNullOrEmpty(node.TargetPlayer))
{
dialogueCutscene.speakerName = node.TargetPlayer;
}
else
{
dialogueCutscene.speakerName = speakerName;
}
dialogueCutscene.inputText = new TextAsset(node.DialogueText);
dialogueCutscene.currentLinks = input.NodeLinks.Where(x => x.BaseNodeGuid == currentGUID).ToList();
dialogueCutscene.deconstructerSource = this;
CutsceneController.addCutsceneEvent(dialogueCutscene, cutsceneSource, true, GameDataTracker.cutsceneModeOptions.Cutscene);
continue;
}
//Animation Trigger
if (input.AnimationTriggerNodeData.Any(x => x.Guid == currentGUID))
{
AnimationTriggerNodeData node = input.AnimationTriggerNodeData.First(x => x.Guid == currentGUID);
AnimationTriggerCutscene animationTriggerCutscene = ScriptableObject.CreateInstance <AnimationTriggerCutscene>();
animationTriggerCutscene.TriggerName = node.TriggerName;
animationTriggerCutscene.TargetName = node.TargetPlayer;
CutsceneController.addCutsceneEvent(animationTriggerCutscene, cutsceneSource, false, GameDataTracker.cutsceneModeOptions.Cutscene);
currentGUID = FindNextNode(input, currentGUID);
continue;
}
//Set Flag
if (input.SetFlagNodeData.Any(x => x.Guid == currentGUID))
{
SetFlagNodeData SetFlagNode = input.SetFlagNodeData.First(x => x.Guid == currentGUID);
string FlagName = SetFlagNode.FlagName;
string FlagTag = SetFlagNode.FlagTag;
if (GameDataTracker.stringFlags.ContainsKey(FlagName))
{
GameDataTracker.stringFlags[FlagName] = FlagTag;
}
else
{
GameDataTracker.stringFlags.Add(FlagName, FlagTag);
}
currentGUID = FindNextNode(input, currentGUID);
continue;
}
//Get Flag
if (input.GetFlagNodeData.Any(x => x.Guid == currentGUID))
{
GetFlagNodeData GetFlagNode = input.GetFlagNodeData.First(x => x.Guid == currentGUID);
string FlagName = GetFlagNode.FlagName;
if (GameDataTracker.stringFlags.ContainsKey(FlagName))
{
string FlagTag = GameDataTracker.stringFlags[FlagName];
if (input.NodeLinks.Any(x => x.PortName == FlagTag))
{
currentGUID = input.NodeLinks.First(x => x.PortName == FlagTag && x.BaseNodeGuid == currentGUID).TargetNodeGuid;
}
else
{
currentGUID = input.NodeLinks.First(x => x.PortName == "Other" && x.BaseNodeGuid == currentGUID).TargetNodeGuid;
}
}
else
{
currentGUID = input.NodeLinks.First(x => x.PortName == "Other" && x.BaseNodeGuid == currentGUID).TargetNodeGuid;
}
continue;
}
//Boolean Set Flag
if (input.BooleanSetFlagNodeData.Any(x => x.Guid == currentGUID))
{
BooleanSetFlagNodeData BooleanSetFlagNode = input.BooleanSetFlagNodeData.First(x => x.Guid == currentGUID);
string FlagName = BooleanSetFlagNode.FlagName;
bool FlagBool = BooleanSetFlagNode.FlagBool;
if (GameDataTracker.boolFlags.ContainsKey(FlagName))
{
GameDataTracker.boolFlags[FlagName] = FlagBool;
}
else
{
GameDataTracker.boolFlags.Add(FlagName, FlagBool);
}
currentGUID = FindNextNode(input, currentGUID);
continue;
}
//Boolean Get Flag
if (input.BooleanGetFlagNodeData.Any(x => x.Guid == currentGUID))
{
BooleanGetFlagNodeData BooleanGetFlagNode = input.BooleanGetFlagNodeData.First(x => x.Guid == currentGUID);
string FlagName = BooleanGetFlagNode.FlagName;
if (GameDataTracker.boolFlags.ContainsKey(FlagName))
{
bool FlagBool = GameDataTracker.boolFlags[FlagName];
if (FlagBool)
{
currentGUID = input.NodeLinks.First(x => x.PortName == "True" && x.BaseNodeGuid == currentGUID).TargetNodeGuid;
}
else
{
currentGUID = input.NodeLinks.First(x => x.PortName == "False" && x.BaseNodeGuid == currentGUID).TargetNodeGuid;
}
}
else
{
currentGUID = input.NodeLinks.First(x => x.PortName == "Other" && x.BaseNodeGuid == currentGUID).TargetNodeGuid;
}
continue;
}
//Move To Position
if (input.MoveToPosNodeData.Any(x => x.Guid == currentGUID))
{
MoveToPosNodeData MoveToPosNode = input.MoveToPosNodeData.First(x => x.Guid == currentGUID);
string TargetObject = MoveToPosNode.TargetObject;
string ReferenceObject = MoveToPosNode.ReferenceObject;
bool Wait = MoveToPosNode.Wait;
Vector3 Offset = MoveToPosNode.PosOffset;
MoveToPosition moveToPosition = ScriptableObject.CreateInstance <MoveToPosition>();
moveToPosition.PositionOffset = Offset;
moveToPosition.ReferenceObject = ReferenceObject;
moveToPosition.TargetObject = TargetObject;
moveToPosition.Wait = Wait;
CutsceneController.addCutsceneEvent(moveToPosition, cutsceneSource, true, GameDataTracker.cutsceneModeOptions.Cutscene);
currentGUID = FindNextNode(input, currentGUID);
continue;
}
}
if (!textboxWait && string.IsNullOrEmpty(currentGUID))
{
done = true;
return(true);
}
return(false);
}
/// <summary>
/// Checks Nodes validity and translates them in a saveable data (DialogueNodeData and NodeLinkData for the edges)
/// </summary>
private bool SaveNodes(DialogueContainer dialogueContainer)
{
var entryPoint = Edges.Find(x => x.output.node.title == "START");
if (entryPoint == null)
{
EditorUtility.DisplayDialog("Error", "Start Node must be connected before saving.", "OK");
if (_targetGraph.GetAutoSave())
{
_targetGraph.Close();
}
return(false);
}
if (!Edges.Any())//Is there any connection made ? If not, return, that way we do not save anything
{
return(false);
}
//We get only connections in the input ports, since the output ports will be stored in another nodes' input port
var connectedPorts = Edges.Where(x => x.input.node != null).OrderByDescending(x => ((DialogueNode)(x.output.node)).EntryPoint).ToArray();;
for (int i = 0; i < connectedPorts.Length; i++)
{
var outputNode = connectedPorts[i].output.node as DialogueNode;
var inputNode = connectedPorts[i].input.node as DialogueNode;
dialogueContainer.NodeLinks.Add(item: new NodeLinkData
{
BaseNodeGuid = outputNode.GUID,
PortName = connectedPorts[i].output.portName,
TargetNodeGuid = inputNode.GUID
});
}
foreach (var dialogueNode in Nodes.Where(node => !node.EntryPoint))
{
//If the condition is not null nor empty, and it is not a handled predicate, we say stop
if (!Core.PredicateHelper.IsWholePredicateValid(dialogueNode.condition))
{
string errorMessage = "Error, current condition for node '" + dialogueNode.name + "' isnt valid. Valid conditions are : ";
foreach (string type in Enum.GetNames(typeof(Core.PredicateHelper.predicateType)))
{
errorMessage += type + ", ";
}
errorMessage += "please chose one of them before saving, or set it up to nothing. You can also use boolean operators &&, ||, ! and brackets ().";
EditorUtility.DisplayDialog(title: "Condition not valid", message: errorMessage, ok: "OK");
return(false);
}
//We make sure that the node's data was created and updated
DialogueNodeData data = new DialogueNodeData()
{
DialogueText = dialogueNode.DialogueText,
GUID = dialogueNode.GUID,
Position = new Vector2(dialogueNode.GetPosition().x, dialogueNode.GetPosition().y),
OnEnterAction = dialogueNode.OnEnterAction,
OnExitAction = dialogueNode.OnExitAction,
condition = new Core.Condition(dialogueNode.condition, null)
};
//Then add it to the save container
dialogueContainer.dialogueNodeData.Add(item: data);
}
return(true);
}
public void NextDialogue()
{
//if node is end node, end dialogue
if (currentNode.dialogueTxt == "End")
{
EndDialogue();
}
//if has 2 edges
//activeDialogue.ReturnValidEdges(currentNode).Count >= 2
else if (activeDialogue.ReturnPotentialEdges(currentNode) >= 2)
{
//but only has one valid edge
if (activeDialogue.ReturnValidEdges(currentNode).Count == 1)
{
if (isNode)
{
//display node
thisIsNode();
}
else
{
normalText.enabled = false;
Option1.gameObject.SetActive(true);
Option2.gameObject.SetActive(true);
option1.text = activeDialogue.ReturnValidEdges(currentNode)[0].portName;
option2.text = "Option requires an item to unlock it.";
}
}
else if (activeDialogue.ReturnValidEdges(currentNode).Count >= 2)
{
if (isNode)
{
//display node
thisIsNode();
}
else
{
normalText.enabled = false;
Option1.gameObject.SetActive(true);
Option2.gameObject.SetActive(true);
option1.text = activeDialogue.ReturnValidEdges(currentNode)[0].portName;
option2.text = activeDialogue.ReturnValidEdges(currentNode)[1].portName;
}
}
}
//if has 1 edge
else if (activeDialogue.ReturnPotentialEdges(currentNode) == 1)
{
if (!isNode)
{
//display edge
normalText.enabled = true;
Option1.gameObject.SetActive(false);
Option2.gameObject.SetActive(false);
normalText.text = activeDialogue.ReturnValidEdges(currentNode)[0].portName;
currentNode = activeDialogue.FindNode(activeDialogue.ReturnValidEdges(currentNode)[0].secondNodeID);
isNode = true;
}
else if (isNode)
{
//display node
thisIsNode();
}
}
}
public DialogueNode(DialogueNodeData data)
: this(data.Id, data.Title, data.Content, data.DialogueResponses.Select(o => new DialogueResponse(o)).ToList())
{
}
