public Structure(string name, Vector3 location, Random random, Module module) : base(name, location, random)
{
base.type = PointOfInterestType.Structure;
_module = module;
_event = EventDB.GetByName(name);
}
public void StartDialogue(DialogueEvent d)
{
m_Animator.SetBool("isVisible", true);
StopAllCoroutines();
StartCoroutine(RunDialogue(d, 0));
}
public void SetUiForEvent(DialogueEvent ev)
{
if (ev.GetType() == typeof(PhraseEvent))
{
glue.ShowPhraseUi((PhraseEvent)ev);
}
else if (ev.GetType() == typeof(DialogueChoiceEvent))
{
glue.ShowChoiceUi((DialogueChoiceEvent)ev);
}
else if (ev.GetType() == typeof(BackgroundChangeEvent))
{
var bev = (BackgroundChangeEvent)getEventById(currentId);
currentId = bev.nextEventId;
glue.ChangeBackground(bev);
SetUiForEvent(getEventById(currentId));
}
else if (ev.GetType() == typeof(FinalDialogueEvent))
{
glue.ShowEndingUi((FinalDialogueEvent)ev);
}
else if (ev.GetType() == typeof(ChooseGenderEvent))
{
glue.ShowGenderUi();
}
else if (ev.GetType() == typeof(PlayerPhraseEvent))
{
glue.ShowPlayerUi((PlayerPhraseEvent)ev);
}
else
{
Debug.LogError("Unhandled event type " + ev.GetType());
}
}
void OnDialogueEvent(DialogueEvent e)
{
if (!e.ongoing)
{
StartCoroutine(TransitionAfterFirstBerth(e.firstEncounter));
}
}
/**
* Handles events brought up by EventNodes triggers
*/
public void HandleEvent(DialogueEventsEnum dialogueEventsEnum, DialogueEvent dialogueEvent)
{
if (isActive)
{
GameManager.HandleDialogueEvent(dialogueEventsEnum, dialogueEvent);
}
}
private void HandleDialogue(Dialogue dialogue)
{
displayManager.UpdateSprint(false);
DialogueEvent dialogueEvent = dialogue.dialogueEvent;
float zoomOverride = dialogue.zoomOverride;
switch (dialogueEvent)
{
case DialogueEvent.ZoomToPlayer:
cinematicManager.CinematicType = CinematicType.TurnipAndPlayer;
cameraManager.ZoomOverride = zoomOverride;
break;
case DialogueEvent.ZoomToTurnip:
cinematicManager.CinematicType = CinematicType.Turnip;
cameraManager.ZoomOverride = zoomOverride;
break;
case DialogueEvent.ShowLantern:
cinematicManager.CinematicType = CinematicType.TurnipAndLantern;
cameraManager.ZoomOverride = zoomOverride;
displayManager.UpdateSprint(true);
break;
case DialogueEvent.ShowPowerUp:
cinematicManager.CinematicType = CinematicType.Turnip;
cameraManager.ZoomOverride = zoomOverride;
break;
}
}
/// <summary>
/// Opens the dialuge UI
/// </summary>
public void OpenDialogueManagerUI(DialogueEvent dialogueEvent)
{
dialogueTextContainer.gameObject.SetActive(true);
this.enabled = true;
this.currentlyAssignedDialogueEvent = dialogueEvent;
DrawNextDialogueNode(dialogueEvent.ResetDialogueEvent());
}
private void HandleChangeBackgroundEvent(DialogueEvent ev)
{
string[] parameters = ev.parameters;
if (parameters.Length <= 0)
{
Debug.LogWarning("ChangeBackground event need at least one integer argument\n" +
"ChangeBackground(int index); ChangeBackground(int index, float fadeDuration);");
}
else if (parameters.Length == 1)
{
//ChangeBackground(int backgroundIndex)
if (parameters.Length == 1 && isInteger(parameters[0]))
{
ChangeBackground(Int32.Parse(ev.parameters[0]));
}
else
{
Debug.LogWarning("Invalid Parameters/ ChangeBackground(int index)");
}
}
else
{
if (isInteger(parameters[0]) && isFloat(parameters[1]))
{
ChangeBackground(Int32.Parse(parameters[0]), float.Parse(parameters[1]));
}
else
{
Debug.LogWarning("Invalid Parameter / ChangeBackground(int index, float fadeTime)");
}
}
}
// NOTE: SPEECHLINE VARIABLES ARE {{ }}, THIS CLASS SHOULD INJECT THE CORRECT VARIABLE FOR THE SITUATION
public void ExecuteEventWithVars(string filename, Dictionary <string, string> vars) // vars should be: variable name, variable value
{
// fetch the dialogue information
DialogueText dialogueText = new DialogueText();
dialogueText.ReadRawLinesFromFile(filename);
// inject {{vars}} in order
foreach (KeyValuePair <string, string> entry in vars)
{
// search each line for the variable and inject as needed
foreach (List <SpeechLine> lines in dialogueText.lines)
{
foreach (SpeechLine line in lines)
{
if (line.lineText.Contains("{{" + entry.Key + "}}"))
{
Debug.Log("Injecting var " + entry.Key + " into " + filename + "...");
line.lineText = line.lineText.Replace("{{" + entry.Key + "}}", entry.Value);
}
}
}
}
// execute event
DialogueEvent.ExecuteEvent(dialogueText);
}
protected override IEnumerator RevealCharacters(TMP_Text textComponent)
{
textComponent.ForceMeshUpdate();
TMP_TextInfo textInfo = textComponent.textInfo;
int totalVisibleCharacters = textInfo.characterCount; // Get # of Visible Character in text object
int visibleCount = 0;
textComponent.maxVisibleCharacters = visibleCount;
yield return(new WaitForSeconds(_delayDuration));
while (!DialogueManager.Instance._isEnd)
{
if (_isTextChanged)
{
totalVisibleCharacters = textInfo.characterCount; // Update visible character count.
_isTextChanged = false;
}
/// 다음 페이지 경우 관련 변수 초기화
if (_isNextPage)
{
yield return(new WaitForSeconds(_duration));
_isNextPage = false;
visibleCount = 0;
yield return(new WaitForSeconds(_delayDuration));
}
/// 사운드 처리
if (0 < visibleCount && visibleCount < textComponent.text.Length)
{
char ch = textComponent.text[visibleCount - 1];
PlaySound(ch);
}
/// 한 글자씩 밝혀짐
textComponent.maxVisibleCharacters = visibleCount; // How many characters should TextMeshPro display?
yield return(new WaitForSeconds(_typingDelay));
visibleCount += 1;
/// 다음 페이지를 기다림
if (visibleCount > textComponent.text.Length)
{
yield return(StartCoroutine(WaitUntilInput()));
yield return(new WaitForSeconds(0.2f));
}
}
/// 대화 끝
DialogueEvent.Trigger(_id, null, 0, "", DialogueStatus.End);
_battleDialogueController._isEnd = true;
yield break;
}
public void DisplayDialogueEvent(DialogueEvent dialogueEvent)
{
content.text = dialogueEvent.prompt;
// maybe randomize order of choices?
leftChoice.text = dialogueEvent.choiceA.content;
rightChoice.text = dialogueEvent.choiceB.content;
}
public void NextDialogue()
{
_isEnd = false;
if (DialogueManager.Instance._isEnd)
{
DialogueEvent.Trigger(_id, _textPages, 0, _typingSound, DialogueStatus.Start);
}
}
void CreateListener(DialogueEvent dialogueEvent)
{
var listener = new DialogueEventListener
{
DialogueEvent = dialogueEvent
};
system.listeners.Add(listener);
}
void Awake()
{
if (diagEvent == null)
{
diagEvent = new DialogueEvent();
}
diagEvent.AddListener(ChangeDialogueState);
}
public void ExecuteEvent(string filename)
{
Debug.Log("Executing dialogue event: " + filename);
// fetch the dialogue information
DialogueText dialogueText = new DialogueText();
dialogueText.ReadRawLinesFromFile(filename);
DialogueEvent.ExecuteEvent(dialogueText);
}
// Update is called once per frame
private void SetText(DialogueEvent evt)
{
dialogueText.text = evt.dialoguetext;
if (!isPlaying) {
dialogueText.color = originalColor;
StartFade();
animationController.Play("DialogueBox");
isPlaying = true;
}
}
void Awake()
{
foreach (MonoBehaviour script in gameObject.GetComponents <MonoBehaviour>())
{
DialogueEvent s = script as DialogueEvent;
if (s != null)
{
events.Add(s);
}
}
}
public static DialogueEvent Prepare(
DialogueNode source,
bool started
)
{
var e = new DialogueEvent();
e.Source = source;
e.Started = started;
return(e);
}
// Update is called once per frame
private void SetText(DialogueEvent evt)
{
dialogueText.text = evt.dialoguetext;
if (!isPlaying)
{
dialogueText.color = originalColor;
StartFade();
animationController.Play("DialogueBox");
isPlaying = true;
}
}
private void CheckEvent()
{
if (Physics2D.OverlapCircle(transform.position, 0.1f, eventLayer) != null)
{
Collider2D[] collider = new Collider2D[20];
Physics2D.OverlapCircleNonAlloc(transform.position, 0.1f, collider, eventLayer);
DialogueEvent dialogueEvent = collider [0].GetComponent <DialogueEvent>();
dialogueEvent.Deactivate();
onDialogue(dialogueEvent.dialogue);
onEvent = true;
}
}
public void notifyDialogueEvent(DialogueEvent eventType)
{
// NOTE: IDialogueTrigger listener method implementation.
switch (eventType)
{
case DialogueEvent.End:
isActive = false;
break;
default:
break;
}
}
/// <summary>
/// Update the next dialogue line.
/// </summary>
public void DequeueDialogue()
{
if (isCurrentlyTyping)
{
if (isBuffering)
{
return;
}
CompleteText();
StopAllCoroutines();
isCurrentlyTyping = false;
return;
}
// Set the current Dialogue Line.
dialogueLineIndex++;
// Check for events to be fired.
if (hasDialogueEvents)
{
DialogueEvent dialogueEvent = dialogue as DialogueEvent;
foreach (DialogueEvent.Event a_event in dialogueEvent.dialogueEvents)
{
if (a_event.eventLine == dialogueLineIndex)
{
a_event.myEvent?.Invoke();
}
}
}
// Close dialogue box when reaching the end.
if (dialogueInfo.Count == 0)
{
if (isDialogueOption)
{
OptionsLogic();
}
else
{
CloseDialogue();
}
return;
}
DialogueBase.Info info = dialogueInfo.Dequeue();
completeText = info.text;
dialogueText.text = "";
StartCoroutine(TypeText(info));
}
public void TriggerEventForAction(DialogueEvent action)
{
switch (action)
{
case DialogueEvent.StartQuest:
Debug.Log("Start Quest");
TriggerQuestIfAny();
break;
case DialogueEvent.CompleteQuest:
CompleteQuestIfAny();
break;
}
}
public void ExecuteEventDialogue(DialogueEvent dialogueEvent,
CurrentStatistics currentStats,
EventFinishCallback eventFinishCallback)
{
isExecutingEvent = true;
isMakingChoice = false;
this.diaEvent = dialogueEvent;
this.currentStats = currentStats;
this.eventFinishCallback = eventFinishCallback;
randomDistrictIndex = -1;
lineIndex = 0;
ExecuteDialogueLine();
gameObject.GetComponent <Button>().interactable = true;
}
public void loadDiag(DialogueEvent diagEvent)
{
textMesh.text = diagEvent.diags[diagIndex];
portraits[diagEvent.portraits[diagIndex]].SetActive(true);
changeDiag = false;
mode = 1;
currDiag = diagEvent;
diagIndex = 0;
Debug.Log("Activating");
active = true;
textPanel.SetActive(true);
}
public Dialogue[] GetDialogues()
{
DialogueEvent t_DialogueEvent = new DialogueEvent();
t_DialogueEvent.dialogues = DatabaseManager.instance.GetDialogue((int)dialogueEvent.line.x, (int)dialogueEvent.line.y);
for (int i = 0; i < dialogueEvent.dialogues.Length; i++)
{
t_DialogueEvent.dialogues[i].tf_target = dialogueEvent.dialogues[i].tf_target;
t_DialogueEvent.dialogues[i].camType = dialogueEvent.dialogues[i].camType;
}
dialogueEvent.dialogues = t_DialogueEvent.dialogues;
return(dialogueEvent.dialogues);
}
IEnumerator DialogueSequence(DialogueEvent e)
{
if (FindObjectOfType <Stan>())
{
FindObjectOfType <Stan>().SayWithText(e.text, e.audio);
float realDuration = (e.audio == null) ? e.duration : e.audio.length;
yield return(new WaitForSeconds(realDuration));
FindObjectOfType <Stan>().ClearDialogueText();
}
else
{
Debug.LogError("WHERE'S STAN?!");
}
}
public void DisplayDialogueEvent(DialogueEvent dialogue)
{
for (int i = 0; i < _options.childCount; i++)
{
Destroy(_options.GetChild(i).gameObject);
}
//create options
for (int i = 0; i < dialogue.options.Count; i++)
{
CreateDialogueOption(dialogue.options[i], i);
}
LogManager.getInstance.AddEntry("[Event Received]: '" + dialogue.name + "'", 15f, EntryType.Dialogue);
_header.text = CommandManager.ProcessFlags(dialogue.name);
_body.text = CommandManager.ProcessFlags(dialogue.body);
float height = 0;
//header
height += 5 + 15 + 5;
//art
height += 150 + 5;
//body
float bodyHeight = _body.preferredHeight;
RectTransform bt = (RectTransform)_body.transform.parent;
bt.sizeDelta = new Vector2(bt.sizeDelta.x, bodyHeight);
height += bodyHeight + 5;
//options
int optionsHeight = 25 * (dialogue.options.Count) + 5 * (dialogue.options.Count - 1);
RectTransform ot = (RectTransform)_options;
ot.sizeDelta = new Vector2(ot.sizeDelta.x, optionsHeight);
height += optionsHeight + 5;
RectTransform rt = (RectTransform)_window.transform;
rt.sizeDelta = new Vector2(rt.sizeDelta.x, height);
_window.gameObject.SetActive(true);
}
void DrawEventAssignmentForm()
{
GUILayout.BeginVertical(GetBoxStyle());
GUILayout.Label("Add new DialogueEvent Listener");
assingingGameEvent = (DialogueEvent)EditorGUILayout.ObjectField(
assingingGameEvent, typeof(DialogueEvent), false);
if (GUILayout.Button("Add"))
{
if (assingingGameEvent != null)
{
CreateListener(assingingGameEvent);
assingingGameEvent = null;
}
}
GUILayout.EndVertical();
}
private void HandleChangeVolumeBGMEvent(DialogueEvent ev)
{
if (ev.parameters.Length <= 0)
{
Debug.LogWarning("ChangeVolumeBGM need at least one float argument");
}
else
{
if (isFloat(ev.parameters[0]))
{
ChangeVolumeBGM(float.Parse(ev.parameters[0]));
}
else
{
Debug.LogWarning("Invalid argument/ ChangeVolumeBGM(float volume) - range: 0-1");
}
}
}
private void HandleMoveCharacterEvent(DialogueEvent ev)
{
var parameters = ev.parameters;
if (parameters.Length < 2 || String.IsNullOrWhiteSpace(parameters[0]))
{
Debug.LogWarning("HandleMoveCharacterEvent needs at least two arguments HandleMoveCharacterEvent(string name, float posX)");
return;
}
GameObject character;
if (!characterDictionary.TryGetValue(parameters[0], out character))
{
Debug.LogWarning("This character name doesn't exist");
return;
}
var characterReactTransform = character.GetComponent <RectTransform>();
float posX = characterReactTransform.localPosition.x;
float posY = characterReactTransform.localPosition.y;
if (!isFloat(parameters[1]))
{
Debug.LogWarning("Invalid second argument - float posX/ HandleMoveCharacterEvent(string name, float posX)");
}
else
{
posX = float.Parse(parameters[1]);
}
if (parameters.Length >= 3)
{
if (!isFloat(parameters[2]))
{
Debug.LogWarning("Invalid second argument - float posX/ HandleMoveCharacterEvent(string name, float posX, float posY)");
}
else
{
posY = float.Parse(parameters[2]);
}
}
Image imageComponent = character.GetComponent <Image>();
ChangeCharacter(imageComponent, imageComponent.sprite, posX, posY, characterReactTransform.localScale.x, characterReactTransform.localScale.y);
}
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);
}
}
