public void ClickedButton(DialogueOption dialogueOption)
{
dialogueText.text = dialogueOption.dialogueText;
playerParty.inventory.ChangeAmmoAmount(Inventory.AmmoTypes.rifle, dialogueOption.ammoReward);
foreach (Button button in buttons)
{
print(button);
Destroy(button.gameObject);
}
buttons.Clear();
if (dialogueOption.dialogueOptions.Count != 0)
{
foreach (DialogueOption i in dialogueOption.dialogueOptions)
{
AddDialogueOption(i);
}
}
else
{
Time.timeScale = 1;
gameObject.SetActive(false);
if(dialogueOption.startCombat)
{
AIParty encounteredParty;
encounteredParty = encounteredObject.GetComponent<AIParty>();
if(encounteredParty)
{
gameManager.EnterCombatMap(playerParty, encounteredParty);
}
}
}
}
public void StartLine(string dialogueLineName)
{
DialogueOption option = null;
dialogueTable.TryGetValue(dialogueLineName, out option);
StartLine(option);
}
public new IModable copyDeep()
{
DialogueOption result = (DialogueOption)base.copyDeep <DialogueOption>();
result.Say = Modable.copyDeep(Say);
result.TargetStage = Modable.copyDeep(TargetStage);
return(result);
}
public void optionExecute(DialogueOption option)
{
option.execute();
textShow(option.Say);
stageShow(option.TargetStage);
}
/// <summary>
/// Constructor which lets you provide a dialogue option and relationship to automatically bind to.
/// </summary>
/// <param name="option">
/// The dialogue option which, when triggered by a visitor, will apply the batch.
/// </param>
/// <param name="relationship">The relationship that will be modified.</param>
/// <param name="applyMultiple">
/// Whether the batch may be applied more than once for the same dialogue option.
/// </param>
public RelationshipChange(DialogueOption option, Relationship relationship, bool applyMultiple = false)
{
rel = relationship;
opt = option;
applymulti = applyMultiple;
chooseevent = new EventHandler <EventArgs>(opt_OptionChosen);
opt.OptionChosen += chooseevent;
}
public override void OnInspectorGUI()
{
DialogueOption _target = (DialogueOption)target;
PropertiesGUI(_target);
base.DrawSharedElements(_target);
UnityVersionHandler.CustomSetDirty(_target);
}
public void AddDialogueOption(DialogueOption dialogueOption)
{
Button dialogueButton = Instantiate<Button>(buttonPrefab);
buttons.Add(dialogueButton);
dialogueButton.transform.Translate(0, -40 * buttons.IndexOf(dialogueButton), 0);
dialogueButton.transform.SetParent(gameObject.transform, false);
dialogueButton.GetComponentInChildren<Text>().text = dialogueOption.buttonText;
dialogueButton.onClick.AddListener(delegate { ClickedButton(dialogueOption); });
}
public static void ShowDialogueOpition(DialogueOption options)
{
if (!Choosing)
{
Choosing = true;
Instance.currentOptions = options;
Instance.ShowOptions();
}
}
void Awake()
{
dialogueOption = DialogueOption.Instance();
displayManager = DisplayManager.Instance();
keyBinds = GameObject.FindObjectOfType <KeyBinds>();
yesEvent = new UnityAction(TestAccept);
noEvent = new UnityAction(TestDecline);
}
public void Select(DialogueOption option)
{
ScoreManager.Instance.Add(option.ResultPoints);
DialogueManager.Instance.SetFlag(option.Flag);
DialogueManager.Instance.StartDialogue(option.ResultDialogue);
ContinueButton.interactable = true;
FadeOut();
}
private DialogueOption createDialogueOption(string text, string id, string nextDialogueId)
{
DialogueOption dialogueOption = new DialogueOption();
dialogueOption.id = id;
dialogueOption.text = text;
dialogueOption.nextDialogId = nextDialogueId;
return(dialogueOption);
}
/// <summary>
/// instantiates gameplay option (buttons) for possible next plot points
/// </summary>
/// <param name="info">information needed for gameplay option instantiation</param>
private void InstantiateDecision(DialogueOption info)
{
if (player.StatsCheckOut(info.strRequirement, info.dexRequirement,
info.intRequirement, info.fthRequirement, info.lckRequirement) &&
!info.IsBlocked(pathPlayerTook))
{
Instantiate(decisionPrefab, decisionsPanel.transform).
Init(info.description, info.nextSituationID, info.startBattle);
}
}
private void Save_DialogueNode_Click(object sender, RoutedEventArgs e)
{
string dialogueText = "";
DialogueOption[] options = new DialogueOption[3];
string path = FilePath.Text;
int nodeID = selectedItem.selectedDialogueNode.NodeID;
if (CheckBox_Option1.IsChecked.Value)
{
options[0].DisplayOnce = DisplayOnce1.IsChecked.Value;
int destNode = returnParentNode1.IsChecked.Value ? nodeID : -1;
options[0].DestinationNodeID = destNode;
int minCharisma = MinCharisma1.Text != null ? 0 : int.Parse(MinCharisma1.Text);
options[0].Text = Option1_Text.Text;
}
if (CheckBox_Option2.IsChecked.Value)
{
options[1].DisplayOnce = DisplayOnce2.IsChecked.Value;
int destNode = returnParentNode2.IsChecked.Value ? nodeID : -1;
options[1].DestinationNodeID = destNode;
int minCharisma = MinCharisma2.Text != null ? 0 : int.Parse(MinCharisma2.Text);
options[1].Text = Option2_Text.Text;
}
if (CheckBox_Option3.IsChecked.Value)
{
options[2].DisplayOnce = DisplayOnce3.IsChecked.Value;
int destNode = returnParentNode3.IsChecked.Value ? nodeID : -1;
options[2].DestinationNodeID = destNode;
int minCharisma = MinCharisma3.Text != null ? 0 : int.Parse(MinCharisma3.Text);
options[2].Text = Option3_Text.Text;
}
// I set string to empty if no value set to be able to handle then later
//if (CheckBox_Option1.IsChecked.Value)
// options.Add(Option1_Text.Text);
//else
// options.Add("");
//if (CheckBox_Option2.IsChecked.Value)
// options.Add(Option2_Text.Text);
//else
// options.Add("");
//if (CheckBox_Option3.IsChecked.Value)
// options.Add(Option3_Text.Text);
//else
// options.Add("");
if (DialogueText.Text != null)
{
dialogueText = DialogueText.Text;
}
dialogue = Dialogue.UpdateDialogueNode(dialogue, nodeID, dialogueText, options, path);
UpdateNodeTree();
}
public void Setup(DialogueOption optionOne, DialogueOption optionTwo, Action <int> onClick)
{
m_ButtonOne.onClick.RemoveAllListeners();
m_ButtonTwo.onClick.RemoveAllListeners();
m_OptionOne.text = optionOne.Text;
m_OptionTwo.text = optionTwo.Text;
m_ButtonOne.onClick.AddListener(() => onClick(optionOne.NewState));
m_ButtonTwo.onClick.AddListener(() => onClick(optionTwo.NewState));
}
public Task ContinueDialogue(DialogueOption option, IMediator mediator)
{
_game.ContinueDialogue(option);
if (!_game.DialogueTreeActive)
{
_eventQueue.Enqueue(new PlayerActionCompleted(false));
}
return(_eventQueue.FlushAsync(mediator));
}
public void AddAnswer(DialogueOption answer)
{
if (answer.modifier == 0)
{
answersNegative.Add(answer);
}
else
{
answersPositive.Add(answer);
}
}
public override void OnInspectorGUI()
{
DialogueOption _target = (DialogueOption)target;
PropertiesGUI(_target);
base.DrawSharedElements(_target);
if (GUI.changed)
{
EditorUtility.SetDirty(_target);
}
}
public static DialogueOption Instance()
{
if (!instance)
{
instance = FindObjectOfType(typeof(DialogueOption)) as DialogueOption;
//if (!instance)
// Debug.Log("There need to be at least one active DialogueOption script on a GameObject in your scene.");
//return;
}
return(instance);
}
public void AddDialogueOption(DialogueOption dop)
{
GameObject newOption = Instantiate(FindObjectOfType <TextboxManager> ().DialogueOptionPrefab, transform.Find("Options"));
newOption.GetComponent <DialogueOption> ().SelectionText = dop.SelectionText;
newOption.GetComponent <DialogueOption> ().OnSelect = dop.OnSelect;
newOption.GetComponent <DialogueOption> ().MasterBox = this;
newOption.GetComponent <DialogueOption> ().remainderText = dop.remainderText;
newOption.GetComponentInChildren <TextMeshProUGUI> ().text = TextboxManager.TrimSpecialSequences(dop.SelectionText);
EventSystem.current.SetSelectedGameObject(newOption);
Debug.Log("added DialogueOption: " + dop.SelectionText);
}
public void SetUpOptions(DialogueOption optionsElement)
{
float optionsSpace = Mathf.Max(0, (150 * (optionsElement.Options.Length - 1) - 30) / 2);
Debug.Log(optionButtons.Length);
for (int i = 0; i < optionsElement.Options.Length; i++)
{
optionButtons[i].gameObject.GetComponent <RectTransform>().localPosition = new Vector3(optionsSpace - (150 * i), 0, 0);
optionButtons[i].gameObject.GetComponentsInChildren <Text> ().First().text = optionsElement.Options [i];
optionButtons [i].gameObject.SetActive(true);
}
}
// DESTROY //
public void DestroyDialogueTree()
{
if (dialogueTreeObject != null)
{
Destroy(dialogueTreeObject);
currentDialogueOption = null;
dialogueTreeObject = null;
GameManager.dialogueTreeBoxActive = false;
EventsHandler.Invoke_cb_inputStateChanged();
}
}
public override void OnInspectorGUI()
{
DialogueOption _target = (DialogueOption)target;
// Draw all GUI elements that buttons and triggers share
DrawSharedElements();
if (GUI.changed)
{
EditorUtility.SetDirty(_target);
}
}
public void OptionPicked(DialogueOptionPanel optionPanel)
{
if (choiceOptionPicked == null)
{
DialogueOption dialogueOption = optionPanel.dialogueOption;
answerBox.text = dialogueOption.answer;
TopicScore score = topicScores[dialogueOption.topic];
score.total++;
score.currentScore += dialogueOption.modifier;
printScore();
choiceOptionPicked = optionPanel;
}
}
private void deleteOption(DialogueOption dialogueOption)
{
if (!selectedOptions.ContainsKey(dialogueOption.topic))
{
return;
}
selectedOptions[dialogueOption.topic].Remove(dialogueOption);
if (selectedOptions[dialogueOption.topic].Count == 0)
{
selectedOptions.Remove(dialogueOption.topic);
}
}
// Use this for initialization
void Start()
{
progressText = GetComponent <ProgressTextFiled> ();
autoScroll = GetComponent <AutoScrollDown> ();
pM = GetComponent <PanelManager> ();
dialogueO = GetComponent <DialogueOption> ();
timer = Time.time + waitingTime;
once = true;
once2 = true;
once3 = true;
once4 = true;
}
public void UpdateButton(bool active, DialogueOption option = null)
{
this.option = option;
button.interactable = active;
if (option != null)
{
text.text = option.displayText;
}
else
{
text.text = "";
}
}
public static void PropertiesGUI(DialogueOption _target)
{
CustomGUILayout.BeginVertical();
EditorGUILayout.LabelField("Dialogue Option properties", EditorStyles.boldLabel);
_target.source = (ActionListSource)CustomGUILayout.EnumPopup("Actions source:", _target.source, "", "Where the Actions are stored");
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = (ActionListAsset)CustomGUILayout.ObjectField <ActionListAsset> ("ActionList asset:", _target.assetFile, false, "", "The ActionList asset that stores the Actions");
_target.syncParamValues = CustomGUILayout.Toggle("Sync parameter values?", _target.syncParamValues, "", "If True, the ActionList asset's parameter values will be shared amongst all linked ActionLists");
}
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = CustomGUILayout.Toggle("Is skippable?", _target.isSkippable, "", "If True, the Actions will be skipped when the user presses the 'EndCutscene' Input button");
}
_target.tagID = ShowTagUI(_target.actions.ToArray(), _target.tagID);
if (_target.source == ActionListSource.InScene)
{
_target.useParameters = CustomGUILayout.Toggle("Use parameters?", _target.useParameters, "", "If True, ActionParameters can be used to override values within the Action objects");
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && !_target.syncParamValues && _target.assetFile.useParameters)
{
_target.useParameters = CustomGUILayout.Toggle("Set local parameter values?", _target.useParameters, "", "If True, parameter values set here will be assigned locally, and not on the ActionList asset");
}
CustomGUILayout.EndVertical();
if (_target.useParameters)
{
if (_target.source == ActionListSource.InScene)
{
EditorGUILayout.Space();
CustomGUILayout.BeginVertical();
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ShowParametersGUI(_target, null, _target.parameters);
CustomGUILayout.EndVertical();
}
else if (!_target.syncParamValues && _target.source == ActionListSource.AssetFile && _target.assetFile != null && _target.assetFile.useParameters)
{
bool isAsset = UnityVersionHandler.IsPrefabFile(_target.gameObject);
EditorGUILayout.Space();
CustomGUILayout.BeginVertical();
EditorGUILayout.LabelField("Local parameter values", EditorStyles.boldLabel);
ShowLocalParametersGUI(_target.parameters, _target.assetFile.GetParameters(), isAsset);
CustomGUILayout.EndVertical();
}
}
}
public static void PropertiesGUI(DialogueOption _target)
{
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Dialogue Option properties", EditorStyles.boldLabel);
_target.source = (ActionListSource)EditorGUILayout.EnumPopup("Actions source:", _target.source);
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = ActionListAssetMenu.AssetGUI("ActionList asset:", _target.assetFile);
_target.syncParamValues = EditorGUILayout.Toggle("Sync parameter values?", _target.syncParamValues);
}
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = EditorGUILayout.Toggle("Is skippable?", _target.isSkippable);
}
_target.tagID = ShowTagUI(_target.actions.ToArray(), _target.tagID);
if (_target.source == ActionListSource.InScene)
{
_target.useParameters = EditorGUILayout.Toggle("Use parameters?", _target.useParameters);
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && !_target.syncParamValues && _target.assetFile.useParameters)
{
_target.useParameters = EditorGUILayout.Toggle("Set local parameter values?", _target.useParameters);
}
EditorGUILayout.EndVertical();
if (_target.useParameters)
{
if (_target.source == ActionListSource.InScene)
{
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ShowParametersGUI(_target, null, _target.parameters);
EditorGUILayout.EndVertical();
}
else if (!_target.syncParamValues && _target.source == ActionListSource.AssetFile && _target.assetFile != null && _target.assetFile.useParameters)
{
bool isAsset = (PrefabUtility.GetPrefabType(_target) == PrefabType.Prefab) ? true : false;
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Local parameter values", EditorStyles.boldLabel);
ShowLocalParametersGUI(_target.parameters, _target.assetFile.parameters, isAsset);
EditorGUILayout.EndVertical();
}
}
}
public void BrowseDialogueOptions(Direction myDirection)
{
if (GameManager.instance.inputState != InputState.DialogueBox)
{
return;
}
if (dialogueTreeObject == null)
{
return;
}
int i = currentDialogueTree.currentConversation.optionList.IndexOf(currentDialogueOption);
switch (myDirection)
{
case Direction.down:
if (i < currentDialogueTree.currentConversation.optionList.Count - 1)
{
currentDialogueOption = currentDialogueTree.currentConversation.optionList [i + 1];
}
if (i == currentDialogueTree.currentConversation.optionList.Count - 1)
{
currentDialogueOption = currentDialogueTree.currentConversation.optionList [0];
}
break;
case Direction.up:
if (i > 0)
{
currentDialogueOption = currentDialogueTree.currentConversation.optionList [i - 1];
}
if (i == 0)
{
currentDialogueOption = currentDialogueTree.currentConversation.optionList [currentDialogueTree.currentConversation.optionList.Count - 1];
}
break;
}
}
void AcceptButtonInput(DialogueOption option, int optionNumber)
{
if (currentDialogueNode.GetPort($"dialogueOptions {optionNumber}").Connection != null)
{
currentDialogueNode = (DialogueNode)currentDialogueNode.GetPort($"dialogueOptions {optionNumber}").Connection.node;
ClearButtons();
DisplayNextSentence();
}
else
{
ClearButtons();
EndDialogue();
}
}
private void SetOptionBtn(GameObject btn, DialogueOption opt)
{
string optText = SetOptionText(opt);
if (optText.Length == 0)
{
return;
}
btn.SetActive(true);
btn.GetComponentInChildren <Text>().text = optText;
btn.GetComponent <Button>().onClick.AddListener(delegate
{
if (opt.Pro.Length > 0)
{
string[] proIds = opt.Pro.Split(',');
foreach (InfoPro pro in feedbackData.pros)
{
if (Array.IndexOf(proIds, pro.id) > -1 && !PlayerData.pros.Contains(pro))
{
PlayerData.pros.Add(pro);
}
}
}
if (opt.Con.Length > 0)
{
string[] conIds = opt.Con.Split(',');
foreach (InfoCon con in feedbackData.cons)
{
if (Array.IndexOf(conIds, con.id) > -1 && !PlayerData.cons.Contains(con))
{
PlayerData.cons.Add(con);
}
}
}
if (isCoroutineRunning)
{
StopCoroutine(displayTextCoroutine);
}
SetSelectedOption(opt.DestNodeID);
if (opt.DestNodeID == -1)
{
SceneManager.LoadScene("Feedback");
}
btn.GetComponent <Button>().onClick.RemoveAllListeners();
});
}
public string toJsonString()
{
DialogueOption[] dialogueArray = new DialogueOption[dialogueOptionMap.Count];
int count = 0;
foreach (DialogueOption dialogueOption in dialogueOptionMap.Values)
{
dialogueArray[count++] = dialogueOption;
}
SerializableArrayWrapper <DialogueOption> wrapper = new SerializableArrayWrapper <DialogueOption>();
wrapper.items = dialogueArray;
return(JsonUtility.ToJson(wrapper));
}
public static void PropertiesGUI(DialogueOption _target)
{
EditorGUILayout.BeginVertical ("Button");
EditorGUILayout.LabelField ("Dialogue Option properties", EditorStyles.boldLabel);
_target.source = (ActionListSource) EditorGUILayout.EnumPopup ("Actions source:", _target.source);
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = ActionListAssetMenu.AssetGUI ("ActionList asset:", _target.assetFile);
}
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = EditorGUILayout.Toggle ("Is skippable?", _target.isSkippable);
}
EditorGUILayout.EndVertical ();
}
public ButtonDialog (int[] idArray)
{
label = "";
icon = null;
isOn = true;
isLocked = false;
conversationAction = ConversationAction.ReturnToConversation;
assetFile = null;
newConversation = null;
dialogueOption = null;
lineID = -1;
ID = 1;
isEditing = false;
// Update id based on array
foreach (int _id in idArray)
{
if (ID == _id)
{
ID ++;
}
}
}
public void MapBlob(string blob)
{
var parsed = JSON.Parse(blob);
var threads = parsed["TextThreads"].AsArray;
TextThreads = new List<TextThread>();
foreach(var thread in threads.Childs)
{
TextThread newThread = new TextThread();
newThread.IsDefaultThread = thread["IsDefaultThread"].AsBool;
newThread.Name = thread["Name"];
var sequenceState = thread["SequenceState"].AsObject;
SequenceRange newState = new SequenceRange();
newState.Name = sequenceState["Name"];
newState.MinCounter = sequenceState["MinCounter"].AsInt;
newState.MaxCounter = sequenceState["MaxCounter"].AsInt;
newThread.SequenceRange = newState;
newThread.TextContent = new List<TextContent>();
var content = thread["TextContent"].AsArray;
foreach(var contentItem in content.Childs)
{
TextContent newTextContent = new TextContent();
newTextContent.Speaker = contentItem["Speaker"];
newTextContent.Dialogue = contentItem["Dialogue"];
newTextContent.DialogueEvents = new List<DialogueEvent>();
// Map Dialogue Options...
newTextContent.Options = new List<DialogueOption>();
var dialogueOptions = contentItem["Options"];
foreach(var dialogueOption in dialogueOptions.Childs)
{
DialogueOption newOption = new DialogueOption();
newOption.Text = dialogueOption["Text"];
newOption.TargetID = dialogueOption["TargetID"].AsInt;
newTextContent.Options.Add(newOption);
}
// Map Dialogue Events...
var dialogueEvents = contentItem["DialogueEvents"].AsArray;
foreach(var dialogueEvent in dialogueEvents.Childs)
{
DialogueEvent newDialogueEvent = new DialogueEvent();
newDialogueEvent.MessageName = dialogueEvent["MessageName"];
newDialogueEvent.Args = new List<string>();
var eventArgs = dialogueEvent["Args"].AsArray;
foreach(var eventArg in eventArgs.Childs)
{
newDialogueEvent.Args.Add(eventArg);
}
newTextContent.DialogueEvents.Add(newDialogueEvent);
}
newThread.TextContent.Add(newTextContent);
}
TextThreads.Add(newThread);
}
}
private void SetOptionButton(GameObject button, DialogueOption dialogueOption)
{
bool mostrar = true;
for(int i = 0; i < dialogueOption.DevuelveNumeroGrupos(); i++)
{
int IDGrupo = dialogueOption.DevuelveIDGrupo(i); //Miramos si la opción está asignada a algún grupo
Grupo grupo = Manager.instance.DevolverGrupoActivo(IDGrupo);
if (grupo != null)
{
List<DialogueOptionGrupoVariables> variables = dialogueOption.DevuelveVariables(i);
for(int j = 0; i < variables.Count; j++)
{
//Si la variable de la opcion es mayor que la actual del grupo, no se muestra la opción
if(variables[j].valor > grupo.variables[variables[j].numVariable])
{
mostrar = false;
}
}
}
//El grupo no está activo
else
{
mostrar = false;
}
}
if(mostrar)
{
//Creamos un objeto inventario
Inventario inventario;
//Buscamos el inventario en la colaobjetos
ColaObjeto inventarioCola = Manager.instance.GetColaObjetos(Manager.rutaInventario + "Inventario.xml");
//Se ha encontrado en la cola de objetos
if(inventarioCola != null)
{
ObjetoSerializable objetoSerializable = inventarioCola.GetObjeto();
inventario = objetoSerializable as Inventario;
}
//No se ha encontrado en la cola de objetos
else
{
//Cargamos el inventario si existe, sino lo creamos
if(System.IO.File.Exists(Manager.rutaInventario + "Inventario.xml"))
{
inventario = Inventario.LoadInventario(Manager.rutaInventario + "Inventario.xml");
}
else
{
inventario = new Inventario();
}
}
for(int i = 0; i < dialogueOption.DevuelveNumeroObjetos(); i++)
{
int IDObjeto = dialogueOption.DevuelveIDObjeto(i);
bool enPosesion = dialogueOption.DevuelveObjetoPosesion(i);
bool existe = inventario.ObjetoInventarioExiste(IDObjeto);
//Mostramos la opción solo si coincide el parámetro
if(enPosesion != existe)
{
mostrar = false;
}
}
}
if(mostrar)
{
button.SetActive(true);
button.GetComponentInChildren<Text>().text = dialogueOption.DevuelveTexto(); //Texto del botón
button.GetComponent<Button>().onClick.RemoveAllListeners();
button.GetComponent<Button>().onClick.AddListener(delegate { SetSelectedOption(dialogueOption.DevuelveDestinationNodeID()); }); //Listener del botón
}
}
public void AddDialogueOption()
{
DialogueOption option = new DialogueOption();
dialogueOptions.Add(option);
}
