meat_madness_redux/godot/addons/dialogic/Nodes/DialogNode.gd

1582 lines
56 KiB
GDScript3
Raw Normal View History

2022-11-27 13:31:09 -07:00
tool
extends Control
## -----------------------------------------------------------------------------
## VARIABLES
## -----------------------------------------------------------------------------
## The timeline to load when starting the scene
var timeline: String
var timeline_name: String
### MODE
var preview: bool = false
var noSkipMode: bool = false
var autoPlayMode: bool = false
var autoWaitTime : float = 2.0
enum state {
IDLE, # When nothing is happening
READY, # When Dialogic already displayed the text on the screen
TYPING, # While the editor is typing text
WAITING, # Waiting a timer or something to finish
WAITING_INPUT, # Waiting for player to answer a question
ANIMATING # While performing a dialog animation
}
var _state : int = state.IDLE
var do_fade_in := true
var dialog_faded_in_already = false
# true if the glossary popup is visible: # TODO rename
var definition_visible: bool = false
# used to reset the mouse mode after questions:
var last_mouse_mode = null
# this is for switching back after a custom character theme was loaded
var current_default_theme = null
### SETTINGS
var settings: ConfigFile
var custom_events = {}
var record_history: bool = false
### DATA
var definitions = {}
# Parsing results
var questions #for keeping track of the questions answered
var anchors = {} # for listing the indexes of the anchors
### CURRENT STATE
var current_timeline: String = ''
var dialog_script: Dictionary = {}
var current_event: Dictionary
var dialog_index: int = 0
var is_last_text: bool
var current_background = ""
# Theme and Audio
var current_theme: ConfigFile
var current_theme_file_name = null
var history_theme: ConfigFile
var audio_data = {}
# References
var button_container = null
## -----------------------------------------------------------------------------
## SCENES
## -----------------------------------------------------------------------------
onready var ChoiceButton = load("res://addons/dialogic/Nodes/ChoiceButton.tscn")
onready var Portrait = load("res://addons/dialogic/Nodes/Portrait.tscn")
onready var Background = load("res://addons/dialogic/Nodes/Background.tscn")
onready var HistoryTimeline = $History
## -----------------------------------------------------------------------------
## SIGNALS
## -----------------------------------------------------------------------------
# Event end/start
signal event_start(type, event)
signal event_end(type)
# Text Signals
signal text_complete(text_data)
# Timeline end/start
signal timeline_start(timeline_name)
signal timeline_end(timeline_name)
# Custom user signal
signal dialogic_signal(value)
# Utility
signal letter_displayed(lastLetter)
## -----------------------------------------------------------------------------
## SCRIPT
## -----------------------------------------------------------------------------
func _ready():
# Set this dialog as the latest (used for saving)
Engine.get_main_loop().set_meta('latest_dialogic_node', self)
# Loading the config files
load_config_files()
#update_custom_events()
$CustomEvents.update()
# Checking if the dialog should read the code from a external file
if not timeline.empty():
set_current_dialog(timeline)
elif dialog_script.keys().size() == 0:
dialog_script = {
"events":[
{'event_id':'dialogic_001',
"character":"","portrait":"",
"text":"[Dialogic Error] No timeline specified."}]
}
# Load the dialog directly from GDscript
else:
load_dialog()
# Connecting resize signal
get_viewport().connect("size_changed", self, "resize_main")
resize_main()
if !DialogicResources.get_settings_value('dialog', 'stop_mouse', true):
mouse_filter = Control.MOUSE_FILTER_IGNORE
# Connecting some other timers
$OptionsDelayedInput.connect("timeout", self, '_on_OptionsDelayedInput_timeout')
# Setting everything up for the node to be default
$DefinitionInfo.visible = false
$TextBubble.connect("text_completed", self, "_on_text_completed")
$TextBubble.connect("letter_written", self, "_on_letter_written")
$TextBubble.connect("signal_request", self, "_on_signal_request")
$TextBubble.text_label.connect('meta_hover_started', self, '_on_RichTextLabel_meta_hover_started')
$TextBubble.text_label.connect('meta_hover_ended', self, '_on_RichTextLabel_meta_hover_ended')
$TouchScreenButton.action = Dialogic.get_action_button()
if Engine.is_editor_hint():
if preview:
get_parent().connect("resized", self, "resize_main")
_init_dialog()
$DefinitionInfo.in_theme_editor = true
else:
if do_fade_in: _hide_dialog()
_init_dialog()
# loads the definitions, themes and settings
func load_config_files():
# defintiions
if not Engine.is_editor_hint():
definitions = Dialogic._get_definitions()
else:
definitions = DialogicResources.get_default_definitions()
# settings
settings = DialogicResources.get_settings_config()
# theme
var theme_file = 'res://addons/dialogic/Editor/ThemeEditor/default-theme.cfg'
theme_file = settings.get_value('theme', 'default', 'default-theme.cfg')
current_default_theme = theme_file
current_theme = load_theme(theme_file)
# history
if settings.has_section('history'):
record_history = settings.get_value('history', 'enable_history_logging', false)
if settings.has_section_key('history', 'history_theme'):
theme_file = settings.get_value('history', 'history_theme')
history_theme = load_theme(theme_file)
HistoryTimeline.load_theme(history_theme)
if settings.has_section_key('history', 'enable_history_logging'):
if settings.get_value('history', 'enable_history_logging'):
HistoryTimeline.initalize_history()
## -----------------------------------------------------------------------------
## CUSTOM EVENTS
## -----------------------------------------------------------------------------
## not used anymore. use $CustomEvents.update()
func update_custom_events() -> void:
custom_events = {}
var path : String = DialogicResources.get_working_directories()["CUSTOM_EVENTS_DIR"]
var dir = Directory.new()
if dir.open(path) == OK:
dir.list_dir_begin()
var file_name = dir.get_next()
# goes through all the folders in the custom events folder
while file_name != "":
# if it found a folder
if dir.current_is_dir() and not file_name in ['.', '..']:
# look through that folder
#print("Found custom event folder: " + file_name)
var event = load(path.plus_file(file_name).plus_file('EventBlock.tscn')).instance()
if event:
custom_events[event.event_data['event_id']] = {
'event_script' :path.plus_file(file_name).plus_file('event_'+event.event_data['event_id']+'.gd'),
'event_name' : event.event_name,
}
event.queue_free()
else:
print("[D] An error occurred when trying to access a custom event.")
else:
pass # files in the directory are ignored
file_name = dir.get_next()
else:
print("[D] An error occurred when trying to access the custom event folder.")
## -----------------------------------------------------------------------------
## VISUALS
## -----------------------------------------------------------------------------
# This function makes sure that the dialog is displayed at the correct
# size and position in the screen.
func resize_main():
var reference = rect_size
if not Engine.is_editor_hint():
set_global_position(Vector2(0,0))
reference = get_viewport().get_visible_rect().size
# Update box position
var anchor = current_theme.get_value('box', 'anchor', 9)
# TODO: remove backups in 2.0
var margin_bottom = current_theme.get_value('box', 'box_margin_bottom', current_theme.get_value('box', 'box_margin_v', 40) * -1)
var margin_top = current_theme.get_value('box', 'box_margin_top', current_theme.get_value('box', 'box_margin_v', 40))
var margin_left = current_theme.get_value('box', 'box_margin_left', current_theme.get_value('box', 'box_margin_h', 40))
var margin_right = current_theme.get_value('box', 'box_margin_right', current_theme.get_value('box', 'box_margin_h', 40) * -1)
# first the y position
if anchor in [0,1,2]: # TOP
$TextBubble.rect_position.y = margin_top
elif anchor in [4,5,6]: # CENTER
$TextBubble.rect_position.y = (reference.y/2)-($TextBubble.rect_size.y/2)
else:
$TextBubble.rect_position.y = (reference.y) - ($TextBubble.rect_size.y) + margin_bottom
# now x position
if anchor in [0,4,8]: # LEFT
$TextBubble.rect_position.x = margin_left
elif anchor in [1,5,9]: # CENTER
$TextBubble.rect_position.x = (reference.x / 2) - ($TextBubble.rect_size.x / 2)
else:
$TextBubble.rect_position.x = reference.x - ($TextBubble.rect_size.x) + margin_right
# Update TextBubble background size
var pos_x = 0
if current_theme.get_value('background', 'full_width', false):
if preview:
pos_x = get_parent().rect_global_position.x
$TextBubble/TextureRect.rect_global_position.x = pos_x
$TextBubble/ColorRect.rect_global_position.x = pos_x
$TextBubble/TextureRect.rect_size.x = reference.x
$TextBubble/ColorRect.rect_size.x = reference.x
else:
$TextBubble/TextureRect.rect_global_position.x = $TextBubble.rect_global_position.x
$TextBubble/ColorRect.rect_global_position.x = $TextBubble.rect_global_position.x
$TextBubble/TextureRect.rect_size.x = $TextBubble.rect_size.x
$TextBubble/ColorRect.rect_size.x = $TextBubble.rect_size.x
# Button positioning
var button_anchor = current_theme.get_value('buttons', 'anchor', 5)
var anchor_vertical = 1
var anchor_horizontal = 1
# OMG WHY IS TIHS NOT A MATCH I CAN'T BELIEVE YOU, WHY YOU DOING THIS TO ME
if button_anchor == 0:
anchor_vertical = 0
anchor_horizontal = 0
elif button_anchor == 1:
anchor_vertical = 0
elif button_anchor == 2:
anchor_vertical = 0
anchor_horizontal = 2
# Number skip because of the separator
elif button_anchor == 4:
anchor_horizontal = 0
elif button_anchor == 6:
anchor_horizontal = 2
# Number skip because of the separator
elif button_anchor == 8:
anchor_vertical = 2
anchor_horizontal = 0
elif button_anchor == 9:
anchor_vertical = 2
elif button_anchor == 10:
anchor_vertical = 2
anchor_horizontal = 2
var theme_choice_offset = current_theme.get_value('buttons', 'offset', Vector2(0,0))
var position_offset = Vector2(0,0)
if anchor_horizontal == 0:
position_offset.x = (reference.x / 2) * -1
elif anchor_horizontal == 1:
position_offset.x = 0
elif anchor_horizontal == 2:
position_offset.x = (reference.x / 2)
if anchor_vertical == 0:
position_offset.y -= (reference.y / 2)
elif anchor_vertical == 1:
position_offset.y += 0
elif anchor_vertical == 2:
position_offset.y += (reference.y / 2)
$Options.rect_global_position = Vector2(0,0) + theme_choice_offset + position_offset
$Options.rect_size = reference
if settings.get_value('input', 'clicking_dialog_action', true):
$TouchScreenButton.shape.extents = reference
# Background positioning
var background = get_node_or_null('Background')
if background != null:
background.rect_size = reference
var portraits = get_node_or_null('Portraits')
if portraits != null:
portraits.rect_position.x = reference.x / 2
portraits.rect_position.y = reference.y
# calls resize_main
func deferred_resize(current_size, result, anchor):
$TextBubble.rect_size = result
if current_size != $TextBubble.rect_size or current_theme.get_value('box', 'anchor', 9) != anchor:
resize_main()
# loads the given theme file
func load_theme(filename):
var current_theme_anchor = -1
if current_theme:
current_theme_anchor = current_theme.get_value('box', 'anchor', 9)
var load_theme = DialogicResources.get_theme_config(filename)
if not load_theme:
return current_theme
var theme = load_theme
current_theme_file_name = filename
# Box size
call_deferred('deferred_resize', $TextBubble.rect_size, theme.get_value('box', 'size', Vector2(910, 167)), current_theme_anchor)
$TextBubble.load_theme(theme)
HistoryTimeline.change_theme(theme)
$DefinitionInfo.load_theme(theme)
if theme.get_value('buttons', 'layout', 0) == 0:
button_container = VBoxContainer.new()
else:
button_container = HBoxContainer.new()
button_container.name = 'ButtonContainer'
button_container.alignment = 1
for n in $Options.get_children():
n.queue_free()
$Options.add_child(button_container)
load_audio(theme)
if theme.get_value('box', 'portraits_behind_dialog_box', true):
move_child($Portraits, 0)
else:
move_child($Portraits, 1)
return theme
## -----------------------------------------------------------------------------
## AUDIO
## -----------------------------------------------------------------------------
func load_audio(theme):
# Audio
var default_audio_file = "res://addons/dialogic/Example Assets/Sound Effects/Beep.wav"
var default_audio_data = {
'enable': false,
'path': default_audio_file,
'volume': 0.0,
'volume_rand_range': 0.0,
'pitch': 1.0,
'pitch_rand_range': 0.0,
'allow_interrupt': true,
'audio_bus': AudioServer.get_bus_name(0)
}
for audio_node in $FX/Audio.get_children():
var name = audio_node.name.to_lower()
audio_data[name] = theme.get_value('audio', name, default_audio_data)
var file_system = Directory.new()
if file_system.dir_exists(audio_data[name].path):
audio_node.load_samples_from_folder(audio_data[name].path)
elif file_system.file_exists(audio_data[name].path) or file_system.file_exists(audio_data[name].path + '.import'):
audio_node.samples = [load(audio_data[name].path)]
audio_node.set_volume_db(audio_data[name].volume)
audio_node.random_volume_range = audio_data[name].volume_rand_range
audio_node.set_pitch_scale(audio_data[name].pitch)
audio_node.random_pitch_range = audio_data[name].pitch_rand_range
audio_node.set_bus(audio_data[name].audio_bus)
func play_audio(name):
var node = $FX/Audio.get_node(name.capitalize())
name = name.to_lower()
if audio_data[name].enable:
if audio_data[name].allow_interrupt or not node.is_playing():
node.play()
## -----------------------------------------------------------------------------
## LOADING/PARSING DIALOG
## -----------------------------------------------------------------------------
# load a timeline file and start parsing
func set_current_dialog(dialog_path: String):
current_timeline = dialog_path
dialog_script = DialogicResources.get_timeline_json(dialog_path)
return load_dialog()
# starts all necessary parsing
func load_dialog():
# All this parse events should be happening in the same loop ideally
# But until performance is not an issue I will probably stay lazy
# And keep adding different functions for each parsing operation.
if settings.get_value('dialog', 'auto_color_names', true):
dialog_script = DialogicParser.parse_characters(dialog_script)
dialog_script = DialogicParser.parse_text_lines(dialog_script, preview)
dialog_script = DialogicParser.parse_branches(self, dialog_script)
DialogicParser.parse_anchors(self)
return dialog_script
## -----------------------------------------------------------------------------
## MAIN GAME-LOGIC
## -----------------------------------------------------------------------------
# checks if NextIndicator and ChoiceButtons should be visible
func _process(delta):
# Showing or hiding the ▼ next indicator
$TextBubble/NextIndicatorContainer/NextIndicator.visible = is_state(state.READY)
# Showing or hiding the container where the option buttons show up in questions
$Options.visible = is_state(state.WAITING_INPUT)
# Hide if no input is required
if current_event.has('text'):
if '[nw]' in current_event['text'] or '[nw=' in current_event['text'] or noSkipMode or autoPlayMode:
$TextBubble/NextIndicatorContainer/NextIndicator.visible = false
# Hide if "Don't Close After Last Event" is checked and event is last text
if current_theme and current_theme.get_value('settings', 'dont_close_after_last_event', false) and is_last_text:
$TextBubble/NextIndicatorContainer/NextIndicator.visible = false
# Hide if fading in
if is_state(state.ANIMATING):
$TextBubble/NextIndicatorContainer/NextIndicator.visible = false
# checks for the "input_next" action
func _input(event: InputEvent) -> void:
if not Engine.is_editor_hint() and event.is_action_pressed(Dialogic.get_action_button()) and autoPlayMode:
autoPlayMode = false
return
if not Engine.is_editor_hint() and event.is_action_pressed(Dialogic.get_action_button()) and (!noSkipMode and !autoPlayMode):
if HistoryTimeline.block_dialog_advance:
return
if is_state(state.WAITING):
if not current_event:
return
var timer = current_event.get('waiting_timer_skippable')
if timer:
timer.time_left = 0
else:
if is_state(state.TYPING):
# Skip to end if key is pressed during the text animation
$TextBubble.skip()
# Cut the voice
$FX/CharacterVoice.stop_voice()
else:
if current_event.has('options') and !is_state(state.WAITING_INPUT):
pass
elif is_state(state.WAITING_INPUT) or is_state(state.ANIMATING):
pass
elif $TextBubble/NextIndicatorContainer/NextIndicator.is_visible():
$FX/CharacterVoice.stop_voice() # stop the current voice as well
play_audio("passing")
_load_next_event()
else:
next_event(false)
if settings.has_section_key('dialog', 'propagate_input'):
var propagate_input: bool = settings.get_value('dialog', 'propagate_input')
if not propagate_input and not is_state(state.WAITING_INPUT):
get_tree().set_input_as_handled()
func next_event(discreetly: bool):
$FX/CharacterVoice.stop_voice() # stop the current voice as well
if !discreetly:
play_audio("passing")
_load_next_event()
# when the text finished showing
# plays audio, adds buttons, handles [nw]
func _on_text_completed():
emit_signal('text_complete', current_event)
play_audio('waiting')
# Add the choice buttons for questions
if current_event.has('options'):
# Already showed the text, ready to show the option buttons
set_state(state.WAITING_INPUT)
var waiting_until_options_enabled = float(settings.get_value('input', 'delay_after_options', 0.1))
$OptionsDelayedInput.start(waiting_until_options_enabled)
for o in current_event['options']:
if _should_add_choice_button(o):
add_choice_button(o)
# Auto focus
$DialogicTimer.start(0.1); yield($DialogicTimer, "timeout")
if settings.get_value('input', 'autofocus_choices', false):
button_container.get_child(0).grab_focus()
if current_event.has('text'):
# Already showed the text, ready to show the ▼ next indicator button
set_state(state.READY)
# [p] needs more work
# Setting the timer for how long to wait in the [nw] events
if '[nw]' in current_event['text'] or '[nw=' in current_event['text'] or noSkipMode or autoPlayMode:
var waiting_time = 2
var current_index = dialog_index
if '[nw=' in current_event['text']: # Regex stuff
var regex = RegEx.new()
regex.compile("\\[nw=(.+?)\\](.*?)")
var result = regex.search(current_event['text'])
var wait_settings = result.get_string()
#Kva-hack. if the waiting time is set to 'v'
#It will fetch waiting time from CharacterVoice.
waiting_time = wait_settings.split('=')[1]
if(waiting_time.begins_with('v')):
waiting_time = $"FX/CharacterVoice".remaining_time()
else:
waiting_time = float(waiting_time)
#print("Waiting time: " + String(waiting_time))
#Remove these comments once replaced with proper code.
# - KvaGram
#original line
#waiting_time = float(wait_settings.split('=')[1])
elif noSkipMode or autoPlayMode:
waiting_time = autoWaitTime
if current_event.has('voice_data'):
waiting_time = $"FX/CharacterVoice".remaining_time()
else:
waiting_time = float(waiting_time)
$DialogicTimer.start(waiting_time); yield($DialogicTimer, "timeout")
if dialog_index == current_index:
_load_next_event()
# When text reaches a [signal] command
# emits the dialogic signal with the argument
func _on_signal_request(name):
emit_signal("dialogic_signal", name)
# emits timeline_start and handles autosaving
func on_timeline_start():
if not Engine.is_editor_hint():
if settings.get_value('saving', 'autosave', true):
# save to the default slot
Dialogic.save('', true)
# TODO remove event_start in 2.0
emit_signal("event_start", "timeline", timeline_name)
emit_signal("timeline_start", timeline_name)
# emits timeline_end and handles autosaving
func on_timeline_end():
if not Engine.is_editor_hint():
if settings.get_value('saving', 'autosave', true):
# save to the default slot
Dialogic.save('', true)
# TODO remove event_end in 2.0
emit_signal("event_end", "timeline")
emit_signal("timeline_end", timeline_name)
# does checks and calls the above functions
func _emit_timeline_signals():
if dialog_script.has('events'):
if dialog_index == 0:
on_timeline_start()
elif _is_dialog_finished():
on_timeline_end()
# resets dialog_index and starts first event
func _init_dialog():
dialog_index = 0
_load_event()
# jumps to the event at the given index
func _load_event_at_index(index: int):
dialog_index = index
_load_event()
# loads the next event
func _load_next_event():
dialog_index += 1
_load_event()
# returns true if dialog_index is outside of the events indexes
func _is_dialog_finished():
return dialog_index >= dialog_script['events'].size()
# calls the event_handler
func _load_event():
# Updates whether the event is the last text box
if dialog_index + 1 >= dialog_script['events'].size():
is_last_text = true
else:
# Get next event
var next_event = dialog_script['events'][dialog_index + 1]
# If next event is Text Event, is_last_text is false
if next_event['event_id'] == "dialogic_001":
is_last_text = false
# Else, if next event is End Branch, set is_last_text to whether the next after exceeds the size of events.
elif 'end_branch_of' in next_event:
is_last_text = dialog_index + 2 >= dialog_script['events'].size()
# Else, if next event is Choice (and current event is not a Question)
elif 'choice' in next_event and not 'options' in dialog_script['events'][dialog_index]:
# Get Question
var index_in_questions = next_event['question_idx']
var question = questions[index_in_questions]
var index_in_events = dialog_script['events'].rfind(question, dialog_index)
var end_index = question['end_idx']
is_last_text = end_index + 1 >= dialog_script['events'].size()
_emit_timeline_signals()
_hide_definition_popup()
if dialog_script.has('events'):
if not _is_dialog_finished():
# CHECK IF NECESSARY!
var func_state = event_handler(dialog_script['events'][dialog_index])
#if (func_state is GDScriptFunctionState):
# print(func_state)
# yield(func_state, "completed")
elif not Engine.is_editor_hint():
# If setting 'Don't Close After Last Event' is not checked, free it.
if not current_theme.get_value('settings', 'dont_close_after_last_event', false):
queue_free()
# Handling an event and updating the available nodes accordingly.
func event_handler(event: Dictionary):
$TextBubble.reset()
clear_options()
current_event = event
if record_history:
HistoryTimeline.add_history_row_event(current_event)
match event['event_id']:
# MAIN EVENTS
# Text Event
'dialogic_001':
emit_signal("event_start", "text", event)
if fade_in_dialog():
yield(get_node('fade_in_tween_show_time'), 'tween_completed')
set_state(state.TYPING)
if event.has('character'):
var character_data = DialogicUtil.get_character(event['character'])
grab_portrait_focus(character_data, event)
if character_data.get('data', {}).get('theme', '') and current_theme_file_name != character_data.get('data', {}).get('theme', ''):
current_theme = load_theme(character_data.get('data', {}).get('theme', ''))
elif !character_data.get('data', {}).get('theme', '') and current_default_theme and current_theme_file_name != current_default_theme:
current_theme = load_theme(current_default_theme)
update_name(character_data)
#voice
handle_voice(event)
update_text(event['text'])
# Character event
'dialogic_002':
## PLEASE UPDATE THIS! BUT HOW?
emit_signal("event_start", "action", event)
set_state(state.WAITING)
if event['character'] == '':# No character found on the event. Skip.
_load_next_event()
else:
var character_data = DialogicUtil.get_character(event['character'])
# JOIN MODE -------------------------------------------
if event.get('type', 0) == 0 and not portrait_exists(character_data):
# CREATE NEW PORTRAIT
var p = Portrait.instance()
# SET DATA
if current_theme.get_value('settings', 'single_portrait_mode', false):
p.single_portrait_mode = true
p.character_data = character_data
p.dim_time = current_theme.get_value('animation', 'dim_time', 0.5)
var char_portrait = get_portrait_name(event)
p.init(char_portrait)
p.set_mirror(event.get('mirror_portrait', false))
# ADD IT TO THE SCENE
$Portraits.add_child(p)
p.move_to_position(get_character_position(event['position']))
event = insert_animation_data(event, 'join', 'fade_in_up.gd')
p.animate(event.get('animation', '[No Animation]'), event.get('animation_length', 1))
p.current_state['character'] = event['character']
p.current_state['position'] = event['position']
# z_index
$Portraits.move_child(p, get_portrait_z_index_point(event.get('z_index', 0)))
p.z_index = event.get('z_index', 0)
if event.get('animation_wait', false):
yield(p, 'animation_finished')
# LEAVE MODE -------------------------------------------
elif event.get('type', 0) == 1:
if event['character'] == '[All]':
event = insert_animation_data(event, 'leave', 'fade_out_down.gd')
characters_leave_all(event.get('animation', '[No Animation]'), event.get('animation_length', -1))
if event.get('animation_wait', false):
$DialogicTimer.start(event.get('animation_duration', 1))
yield($DialogicTimer, "timeout")
else:
for p in $Portraits.get_children():
if is_instance_valid(p) and p.character_data['file'] == event['character']:
event = insert_animation_data(event, 'leave', 'fade_out_down.gd')
p.animate(event.get('animation', 'instant_out.gd'), event.get('animation_length', 1), 1, true)
if event.get('animation_wait', false):
yield(p, 'animation_finished')
# UPDATE MODE -------------------------------------------
else:
if portrait_exists(character_data):
for portrait in $Portraits.get_children():
if portrait.character_data.get('file', true) == character_data.get('file', false):
# UPDATE PORTRAIT
var portrait_name = get_portrait_name(event)
if portrait_name != portrait.current_state['portrait']:
portrait.set_portrait(portrait_name)
# recalculate the position of the portrait with an instant animation
portrait.move_to_position(get_character_position(portrait.current_state['position']))
# UPDATE POSITION
if event.get('change_position', false):
if event['position'] != portrait.current_state['position']:
portrait.move_to_position(get_character_position(event['position']))
portrait.current_state['position'] = event['position']
if event.get('change_mirror_portrait', false):
portrait.set_mirror(event.get('mirror_portrait', false))
if event.get('change_z_index', false):
$Portraits.move_child(portrait, get_portrait_z_index_point(event.get('z_index', 0)))
portrait.z_index = event.get('z_index', 0)
portrait.animate(event.get('animation', '[No Animation]'), event.get('animation_length', 1), event.get('animation_repeat', 1))
if event.get('animation_wait', false) and event.get('animation', '[No Animation]') != "[No Animation]":
yield(portrait, 'animation_finished')
set_state(state.READY)
_load_next_event()
# LOGIC EVENTS
# Question event
'dialogic_010':
emit_signal("event_start", "question", event)
if fade_in_dialog():
yield(get_node('fade_in_tween_show_time'), 'tween_completed')
set_state(state.TYPING)
if event.has('name'):
update_name(event['name'])
elif event.has('character'):
var character_data = DialogicUtil.get_character(event['character'])
grab_portrait_focus(character_data, event)
if character_data.get('data', {}).get('theme', '') and current_theme_file_name != character_data.get('data', {}).get('theme', ''):
current_theme = load_theme(character_data.get('data', {}).get('theme', ''))
elif !character_data.get('data', {}).get('theme', '') and current_default_theme and current_theme_file_name != current_default_theme:
current_theme = load_theme(current_default_theme)
update_name(character_data)
#voice
handle_voice(event)
update_text(event['question'])
# Choice event
'dialogic_011':
emit_signal("event_start", "choice", event)
for q in questions:
if q['question_idx'] == event['question_idx']:
if q['answered']:
# If the option is for an answered question, skip to the end of it.
_load_event_at_index(q['end_idx'])
# Condition event
'dialogic_012':
# Treating this conditional as an option on a regular question event
var def_value = null
var current_question = questions[event['question_idx']]
for d in definitions['variables']:
if d['id'] == event['definition']:
def_value = d['value']
var condition_met = def_value != null and DialogicUtil.compare_definitions(def_value, event['value'], event['condition']);
current_question['answered'] = !condition_met
if !condition_met:
# condition not met, skipping branch
_load_event_at_index(current_question['end_idx'])
else:
# condition met, entering branch
_load_next_event()
# End Branch event
'dialogic_013':
emit_signal("event_start", "endbranch", event)
_load_next_event()
# Set Value event
'dialogic_014':
emit_signal("event_start", "set_value", event)
var operation = '='
if 'operation' in event and not event['operation'].empty():
operation = event["operation"]
var value = event['set_value']
if event.get('set_random', false):
value = str(randi()%int(event.get("random_upper_limit", 100)-event.get('random_lower_limit', 0))+event.get('random_lower_limit', 0))
Dialogic.set_variable_from_id(event['definition'], value, operation)
_load_next_event()
# Anchor event
'dialogic_015':
emit_signal("event_start", "anchor", event)
_load_next_event()
# GoTo event
'dialogic_016':
emit_signal("event_start", "goto", event)
dialog_index = anchors[event.get('anchor_id')]
_load_next_event()
# TIMELINE EVENTS
# Change Timeline event
'dialogic_020':
if !event['change_timeline'].empty():
change_timeline(event['change_timeline'])
# Change Backround event
'dialogic_021':
emit_signal("event_start", "background", event)
var fade_time = event.get('fade_duration', 1)
var value = event.get('background', '')
var background = get_node_or_null('Background')
current_background = event['background']
if background != null:
background.name = "BackgroundFadingOut"
if !value:
background.fade_out(fade_time)
else:
background.remove_with_delay(fade_time)
background = null
if value != '':
background = Background.instance()
add_child(background)
if (event['background'].ends_with('.tscn')):
var bg_scene = load(event['background'])
bg_scene = bg_scene.instance()
background.modulate = Color(1,1,1,0)
background.add_child(bg_scene)
background.fade_in(fade_time)
else:
background.texture = load(value)
background.fade_in(fade_time)
call_deferred('resize_main') # Executing the resize main to update the background size
_load_next_event()
# Close Dialog event
'dialogic_022':
emit_signal("event_start", "close_dialog", event)
set_state(state.ANIMATING)
var transition_duration = event.get('transition_duration', 1.0)
# fade out characters
insert_animation_data(event, 'leave', 'fade_out_down')
characters_leave_all(event['animation'], event['animation_length'])
# fade out background
var background = get_node_or_null('Background')
if background != null:
background.name = 'BackgroundFadingOut'
background.fade_out(transition_duration)
if transition_duration != 0:
var tween = Tween.new()
add_child(tween)
tween.interpolate_property($TextBubble, "modulate",
$TextBubble.modulate, Color('#00ffffff'), transition_duration,
Tween.TRANS_LINEAR, Tween.EASE_IN_OUT)
tween.start()
yield(tween, "tween_all_completed")
on_timeline_end()
queue_free()
# Wait seconds event
'dialogic_023':
emit_signal("event_start", "wait", event)
if event.get('hide_dialogbox', true):
$TextBubble.visible = false
set_state(state.WAITING)
var timer = get_tree().create_timer(event['wait_seconds'])
if event.get('waiting_skippable', false):
event['waiting_timer_skippable'] = timer
yield(timer, "timeout")
event.erase('waiting_timer_skippable')
set_state(state.IDLE)
$TextBubble.visible = true
emit_signal("event_end", "wait")
_load_next_event()
# Set Theme event
'dialogic_024':
emit_signal("event_start", "set_theme", event)
if event['set_theme'] != '':
current_theme = load_theme(event['set_theme'])
current_default_theme = event['set_theme']
resize_main()
_load_next_event()
# Set Glossary event
'dialogic_025':
emit_signal("event_start", "set_glossary", event)
if event['glossary_id']:
Dialogic.set_glossary_from_id(event['glossary_id'], event['title'], event['text'],event['extra'])
_load_next_event()
# Save event
'dialogic_026':
emit_signal('event_start', 'save', event)
var custom_slot :String = event.get('custom_slot', '').strip_edges()
if event.get('use_default_slot', true) or custom_slot == '':
Dialogic.save()
else:
if custom_slot.begins_with("[") and custom_slot.ends_with("]"):
custom_slot = custom_slot.trim_prefix("[").trim_suffix("]")
var saved = false
for definition in definitions['variables']:
if definition['name'] == custom_slot:
Dialogic.save(definition['value'])
saved = true
if not saved:
print("[D] Tried to access value definition '"+custom_slot+"' for saving, but it didn't exist.")
else:
Dialogic.save(custom_slot)
_load_next_event()
# AUDIO EVENTS
# Audio event
'dialogic_030':
emit_signal("event_start", "audio", event)
if event['audio'] == 'play' and 'file' in event.keys() and not event['file'].empty():
var audio = get_node_or_null('AudioEvent')
if audio == null:
audio = AudioStreamPlayer.new()
audio.name = 'AudioEvent'
add_child(audio)
if event.has('audio_bus'):
if AudioServer.get_bus_index(event['audio_bus']) >= 0:
audio.bus = event['audio_bus']
if event.has('volume'):
audio.volume_db = event['volume']
audio.stream = load(event['file'])
audio.play()
else:
var audio = get_node_or_null('AudioEvent')
if audio != null:
audio.stop()
audio.queue_free()
_load_next_event()
# Background Music event
'dialogic_031':
emit_signal("event_start", "background-music", event)
if event['background-music'] == 'play' and 'file' in event.keys() and not event['file'].empty():
$FX/BackgroundMusic.crossfade_to(event['file'], event.get('audio_bus', 'Master'), event.get('volume', 0), event.get('fade_length', 1))
else:
$FX/BackgroundMusic.fade_out(event.get('fade_length', 1))
_load_next_event()
# GODOT EVENTS
# Emit signal event
'dialogic_040':
emit_signal("dialogic_signal", event['emit_signal'])
_load_next_event()
# Change Scene event
'dialogic_041':
if event.has('scene'):
get_tree().change_scene(event['scene'])
elif event.has('change_scene'):
get_tree().change_scene(event['change_scene'])
# Call Node event
'dialogic_042':
emit_signal("event_start", "call_node", event)
$TextBubble.visible = false
set_state(state.WAITING)
var target = get_node_or_null(event['call_node']['target_node_path'])
if not target:
target = get_tree().root.get_node_or_null(event['call_node']['target_node_path'])
var method_name = event['call_node']['method_name']
var args = event['call_node']['arguments']
if (not args is Array):
args = []
if is_instance_valid(target):
if target.has_method(method_name):
var func_result = target.callv(method_name, args)
if (func_result is GDScriptFunctionState):
yield(func_result, "completed")
set_state(state.IDLE)
$TextBubble.visible = true
_load_next_event()
'dialogic_050':
noSkipMode = event['block_input']
autoWaitTime = event['wait_time']
_load_next_event()
_:
if event['event_id'] in $CustomEvents.handlers.keys():
# get the handler node
var handler = $CustomEvents.handlers[event['event_id']]
handler.handle_event(event, self)
else:
visible = false
func change_timeline(timeline):
dialog_script = set_current_dialog(timeline)
_init_dialog()
## -----------------------------------------------------------------------------
## TEXTBOX-FUNCTIONALITY
## -----------------------------------------------------------------------------
# updates the Name Label
func update_name(character) -> void:
if character.has('name'):
var parsed_name = character['name']
if character['data'].get('display_name_bool', false):
if character['display_name'] != '':
parsed_name = character['display_name']
parsed_name = DialogicParser.parse_definitions(self, parsed_name, true, false)
$TextBubble.update_name(parsed_name, character.get('color', Color.white), current_theme.get_value('name', 'auto_color', true))
else:
$TextBubble.update_name('')
# shows the given text in the Text Bubble
# handles the simple translation feature
func update_text(text: String) -> String:
if settings.get_value('dialog', 'translations', false):
text = tr(text)
var final_text = DialogicParser.parse_definitions(self, DialogicParser.parse_alignment(self, text))
final_text = final_text.replace('[br]', '\n')
$TextBubble.update_text(final_text)
return final_text
# plays a sound
func _on_letter_written(lastLetter):
if lastLetter != ' ':
play_audio('typing')
emit_signal('letter_displayed', lastLetter)
## -----------------------------------------------------------------------------
## CHOICE/OPTION BUTTONS
## -----------------------------------------------------------------------------
# called when a choice is selected
# hides choices, sets question as answered and jumps to the appropriate event
func answer_question(i, event_idx, question_idx):
play_audio("selecting")
clear_options()
# set flags and continue dialog
questions[question_idx]['answered'] = true
_load_event_at_index(event_idx + 1)
if record_history:
HistoryTimeline.add_answer_to_question(str(i.text))
# Revert to last mouse mode when selection is done
if last_mouse_mode != null:
Input.set_mouse_mode(last_mouse_mode)
last_mouse_mode = null
# deletest the choice buttons
func clear_options():
# Clearing out the options after one was selected.
for option in button_container.get_children():
option.queue_free()
# adds a button for the given choice
func add_choice_button(option: Dictionary) -> Button:
var button = get_classic_choice_button(option['label'])
button_container.set('custom_constants/separation', current_theme.get_value('buttons', 'gap', 20))
button_container.add_child(button)
var hotkey
var buttonCount = button_container.get_child_count()
var hotkeyOption = settings.get_value('input', str('choice_hotkey_', buttonCount), '')
# If there is a hotkey, use that key
if hotkeyOption != '' and hotkeyOption != '[None]':
hotkey = InputEventAction.new()
hotkey.action = hotkeyOption
# otherwise default hotkeys are 1-9 for the first 10 buttons
elif buttonCount < 10 and settings.get_value('input', 'enable_default_shortcut', false):
hotkey = InputEventKey.new()
hotkey.scancode = OS.find_scancode_from_string(str(button_container.get_child_count()))
else:
hotkey = InputEventKey.new()
if hotkeyOption != '[None]' or settings.get_value('input', 'enable_default_shortcut', false) == true:
var shortcut = ShortCut.new()
shortcut.set_shortcut(hotkey)
button.set_shortcut(shortcut)
button.shortcut_in_tooltip = false
# Selecting the first button added
if settings.get_value('input', 'autofocus_choices', false):
if button_container.get_child_count() == 1:
button.grab_focus()
else:
button.focus_mode = FOCUS_NONE
# Adding audio when focused or hovered
button.connect('focus_entered', self, '_on_option_hovered', [button])
button.connect('mouse_entered', self, '_on_option_focused')
button.set_meta('event_idx', option['event_idx'])
button.set_meta('question_idx', option['question_idx'])
if Input.get_mouse_mode() != Input.MOUSE_MODE_VISIBLE:
last_mouse_mode = Input.get_mouse_mode()
Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) # Make sure the cursor is visible for the options selection
return button
# checks the condition of the given option
func _should_add_choice_button(option: Dictionary):
if not option['definition'].empty():
var def_value = null
for d in definitions['variables']:
if d['id'] == option['definition']:
def_value = d['value']
return def_value != null and DialogicUtil.compare_definitions(def_value, option['value'], option['condition']);
else:
return true
# instances a custom choice
func get_custom_choice_button(label: String):
var theme = current_theme
var custom_path = current_theme.get_value('buttons', 'custom_path', "")
var CustomChoiceButton = load(custom_path)
var button = CustomChoiceButton.instance()
button.text = label
return button
# instances a normal dialogic button
func get_classic_choice_button(label: String):
var theme = current_theme
var button : Button = ChoiceButton.instance()
button.text = label
button.set_meta('input_next', Dialogic.get_action_button())
# Removing the blue selected border
button.set('custom_styles/focus', StyleBoxEmpty.new())
# Text
button.set('custom_fonts/font', DialogicUtil.path_fixer_load(theme.get_value('text', 'font', "res://addons/dialogic/Example Assets/Fonts/DefaultFont.tres")))
if theme.get_value('buttons', 'fixed', false):
var size = theme.get_value('buttons', 'fixed_size', Vector2(130,40))
button.rect_min_size = size
button.rect_size = size
button_container.set('custom_constants/separation', theme.get_value('buttons', 'gap', 20))
# Different styles
var default_background = 'res://addons/dialogic/Example Assets/backgrounds/background-2.png'
var default_style = [
false, # 0 $TextColor/CheckBox
Color.white, # 1 $TextColor/ColorPickerButton
false, # 2 $FlatBackground/CheckBox
Color.black, # 3 $FlatBackground/ColorPickerButton
true, # 4 $BackgroundTexture/CheckBox
default_background, # 5 $BackgroundTexture/Button
false, # 6 $TextureModulation/CheckBox
Color.white, # 7 $TextureModulation/ColorPickerButton
]
# Default hover style
var hover_style = [true, Color( 0.698039, 0.698039, 0.698039, 1 ), false, Color.black, true, default_background, false, Color.white]
var style_normal = theme.get_value('buttons', 'normal', default_style)
var style_hover = theme.get_value('buttons', 'hover', hover_style)
var style_focus = theme.get_value('buttons', 'focus', hover_style)
var style_pressed = theme.get_value('buttons', 'pressed', default_style)
var style_disabled = theme.get_value('buttons', 'disabled', default_style)
# Text color
var default_color = Color(theme.get_value('text', 'color', '#ffffff'))
button.set('custom_colors/font_color', default_color)
button.set('custom_colors/font_color_hover', default_color.lightened(0.2))
button.set('custom_colors/font_color_focus', default_color.lightened(0.2))
button.set('custom_colors/font_color_pressed', default_color.darkened(0.2))
button.set('custom_colors/font_color_disabled', default_color.darkened(0.8))
if style_normal[0]:
button.set('custom_colors/font_color', style_normal[1])
if style_hover[0]:
button.set('custom_colors/font_color_hover', style_hover[1])
if style_focus[0]:
button.set('custom_colors/font_color_focus', style_focus[1])
if style_pressed[0]:
button.set('custom_colors/font_color_pressed', style_pressed[1])
if style_disabled[0]:
button.set('custom_colors/font_color_disabled', style_disabled[1])
# Style normal
button_style_setter('normal', style_normal, button, theme)
button_style_setter('hover', style_hover, button, theme)
button_style_setter('focus', style_focus, button, theme)
button_style_setter('pressed', style_pressed, button, theme)
button_style_setter('disabled', style_disabled, button, theme)
return button
# adds parts of a style to the given button
func button_style_setter(section, data, button, theme):
var style_box = StyleBoxTexture.new()
if data[2]:
# I'm using a white texture to do the flat style because otherwise the padding doesn't work.
style_box.set('texture', DialogicUtil.path_fixer_load("res://addons/dialogic/Images/Plugin/white-texture.png"))
style_box.set('modulate_color', data[3])
else:
if data[4]:
style_box.set('texture', DialogicUtil.path_fixer_load(data[5]))
if data[6]:
style_box.set('modulate_color', data[7])
# Padding
var padding = theme.get_value('buttons', 'padding', Vector2(5,5))
style_box.set('margin_left', padding.x)
style_box.set('margin_right', padding.x)
style_box.set('margin_top', padding.y)
style_box.set('margin_bottom', padding.y)
button.set('custom_styles/' + section, style_box)
# focuses button on hover
func _on_option_hovered(button):
button.grab_focus()
# plays the sound
func _on_option_focused():
play_audio("hovering")
# connects the signals after a short delay to make accidental clicking less likely
func _on_OptionsDelayedInput_timeout():
for button in button_container.get_children():
if button.is_connected("pressed", self, "answer_question") == false:
button.connect("pressed", self, "answer_question", [button, button.get_meta('event_idx'), button.get_meta('question_idx')])
## -----------------------------------------------------------------------------
## VOICE LINE FEATURE
## -----------------------------------------------------------------------------
# plays the voice line of the event
func handle_voice(event):
var settings_file = DialogicResources.get_settings_config()
if not settings_file.get_value('dialog', 'text_event_audio_enable', false):
return
# In game only
if Engine.is_editor_hint():
return
if event.has('voice_data'):
var voice_data = event['voice_data']
if voice_data.has('0'):
$FX/CharacterVoice.play_voice(voice_data['0'])
return
$FX/CharacterVoice.stop_voice()
## -----------------------------------------------------------------------------
## PORTRAITS
## -----------------------------------------------------------------------------
# defocuses all characters except the given one
func grab_portrait_focus(character_data, event: Dictionary = {}) -> bool:
var exists = false
for portrait in $Portraits.get_children():
# check if it's the same character
if portrait.character_data.get("file", "something") == character_data.get("file", "none"):
exists = true
portrait.focus()
if event.has('portrait'):
portrait.set_portrait(get_portrait_name(event))
if settings.get_value('dialog', 'recenter_portrait', true):
portrait.move_to_position(portrait.direction)
else:
portrait.focusout(Color(current_theme.get_value('animation', 'dim_color', '#ff808080')))
return exists
# returns true if the a portrait for that character already exists
func portrait_exists(character_data) -> bool:
var exists = false
for portrait in $Portraits.get_children():
if portrait.character_data.get('file', true) == character_data.get('file', false):
exists = true
return exists
# converts PORTRAIT-WEIRDNESS to a word
func get_character_position(positions) -> String:
if positions['0']:
return 'left'
if positions['1']:
return 'center_left'
if positions['2']:
return 'center'
if positions['3']:
return 'center_right'
if positions['4']:
return 'right'
return 'left'
# returns the portrait name or the definition value (id definition is enabled)
func get_portrait_name(event_data):
var char_portrait = event_data['portrait']
if char_portrait == '':
char_portrait = "(Don't change)"
if char_portrait == '[Definition]' and event_data.has('port_defn'):
var portrait_definition = event_data['port_defn']
if portrait_definition != '':
for d in Dialogic._get_definitions()['variables']:
if d['id'] == portrait_definition:
char_portrait = d['value']
break
return char_portrait
func insert_animation_data(event_data, type = 'join', default = 'fade_in_up'):
var animation = event_data.get('animation', '[Default]')
var length = event_data.get('animation_length', 0.5)
if animation == '[Default]':
animation = DialogicResources.get_settings_value('animations', 'default_'+type+'_animation', default)
length = DialogicResources.get_settings_value('animations', 'default_'+type+'_animation_length', 0.5)
event_data['animation'] = animation
event_data['animation_length'] = length
return event_data
# moves out all portraits
func characters_leave_all(animation, time):
var portraits = get_node_or_null('Portraits')
if portraits != null:
for p in portraits.get_children():
p.animate(animation, time, 1, true)
# returns where to move the portrait, so the fake-z-index looks good
func get_portrait_z_index_point(z_index):
for i in range($Portraits.get_child_count()):
if $Portraits.get_child(i).z_index >= z_index:
return i
return $Portraits.get_child_count()
## -----------------------------------------------------------------------------
## GLOSSARY POPUP
## -----------------------------------------------------------------------------
# cheks the 'show_glossary' setting
func _should_show_glossary():
if current_theme != null:
return current_theme.get_value('definitions', 'show_glossary', true)
return true
# shows the glossary popup
func _on_RichTextLabel_meta_hover_started(meta):
var correct_type = false
for d in definitions['glossary']:
if d['id'] == meta:
$DefinitionInfo.load_preview({
'title': d['title'],
'body': DialogicParser.parse_definitions(self, d['text'], true, false), # inserts variables but not other glossary items!
'extra': d['extra'],
})
correct_type = true
if correct_type:
definition_visible = true
$DefinitionInfo.visible = definition_visible
# Adding a timer to avoid a graphical glitch
$DefinitionInfo/Timer.stop()
# hides the glossary popup
func _on_RichTextLabel_meta_hover_ended(meta):
# Adding a timer to avoid a graphical glitch
$DefinitionInfo/Timer.start(0.1)
# hides the glossary popup
func _hide_definition_popup():
definition_visible = false
$DefinitionInfo.visible = definition_visible
# (actually) hides the glossary popup
func _on_Definition_Timer_timeout():
# Adding a timer to avoid a graphical glitch
definition_visible = false
$DefinitionInfo.visible = definition_visible
## -----------------------------------------------------------------------------
## DIALOG FADING
## -----------------------------------------------------------------------------
# Since Dialogic has some placeholder text in case something goes wrong
# This will reset the text, reset any modulation it might have, and
# set the variables that handle the fade in to the start position
func _hide_dialog():
$TextBubble.clear() # Clearing the text
$TextBubble.modulate = Color(1,1,1,0)
dialog_faded_in_already = false
# start a fade in animation
func fade_in_dialog(time = 0.5):
visible = true
time = current_theme.get_value('animation', 'show_time', 0.5)
var has_tween = false
if Engine.is_editor_hint() == false:
if dialog_faded_in_already == false and do_fade_in:
var tween = Tween.new()
add_child(tween)
# The tween created ('fade_in_tween_show_time') is also reference for the $TextBubble
# node to know if it should start showing up the letters of the dialog or not.
tween.name = 'fade_in_tween_show_time'
$TextBubble.modulate.a = 0
tween.interpolate_property($TextBubble, "modulate",
$TextBubble.modulate, Color(1,1,1,1), time,
Tween.TRANS_LINEAR, Tween.EASE_IN_OUT)
tween.start()
tween.connect("tween_completed", self, "finished_fade_in_dialog", [tween])
has_tween = true
if has_tween:
set_state(state.ANIMATING)
dialog_faded_in_already = true
return true
return false
# at the end of fade animation, reset flags
func finished_fade_in_dialog(object, key, node):
node.queue_free()
if !current_event.has('options'):
set_state(state.IDLE)
dialog_faded_in_already = true
## -----------------------------------------------------------------------------
## LOADING AND SAVING
## -----------------------------------------------------------------------------
# returns all important data in a dictionary to be saved
func get_current_state_info():
var state = {}
# visible characters:
state["portraits"] = []
for portrait in $Portraits.get_children():
state['portraits'].append(portrait.current_state)
state['portraits'][-1]['z_index'] = portrait.z_index
# background music:
state['background_music'] = $FX/BackgroundMusic.get_current_info()
# current_timeline and event
state["timeline"] = current_timeline
state['event_idx'] = dialog_index
# current background
state['background'] = current_background
return state
# loads all important data from a dictionary
func resume_state_from_info(state_info):
# wait until the dialog node was added to the tree
do_fade_in = false
yield(self, "ready")
#print(state_info)
# load the characters
for saved_portrait in state_info['portraits']:
var event = saved_portrait
# this code is ALL copied from the event_handler. So I should probably outsource it to a function...
var character_data = DialogicUtil.get_character(event['character'])
if portrait_exists(character_data):
for portrait in $Portraits.get_children():
if portrait.character_data == character_data:
portrait.move_to_position(get_character_position(event['position']))
portrait.set_mirror(event.get('mirror', false))
else:
var p = Portrait.instance()
var char_portrait = event['portrait']
if char_portrait == '':
char_portrait = 'Default'
if char_portrait == '[Definition]' and event.has('port_defn'):
var portrait_definition = event['port_defn']
if portrait_definition != '':
for d in DialogicResources.get_default_definitions()['variables']:
if d['id'] == portrait_definition:
char_portrait = d['value']
break
if current_theme.get_value('settings', 'single_portrait_mode', false):
p.single_portrait_mode = true
p.dim_time = current_theme.get_value('animation', 'dim_time', 0.5)
p.character_data = character_data
p.init(char_portrait)
p.set_mirror(event.get('mirror', false))
$Portraits.add_child(p)
$Portraits.move_child(p, get_portrait_z_index_point(saved_portrait.get('z_index', 0)))
p.move_to_position(get_character_position(event['position']))
# this info is only used to save the state later
p.current_state['character'] = event['character']
p.current_state['position'] = event['position']
# load the background music
if state_info['background_music'] != null:
$FX/BackgroundMusic.crossfade_to(state_info['background_music']['file'], state_info['background_music']['audio_bus'], state_info['background_music']['volume'], 1)
# load the background image
if state_info['background']:
current_background = state_info['background']
var background = Background.instance()
call_deferred('resize_main') # Executing the resize main to update the background size
add_child(background)
if (current_background.ends_with('.tscn')):
var bg_scene = load(current_background)
if (bg_scene):
bg_scene = bg_scene.instance()
background.add_child(bg_scene)
elif (current_background != ''):
background.texture = load(current_background)
# load the timeline and event
set_current_dialog(state_info['timeline'])
# mark all previous question events as "answered"
for event_index in range(0, state_info['event_idx']):
if dialog_script['events'][event_index]['event_id'] == 'dialogic_010':
dialog_script['events'][event_index]['answered'] = true
_load_event_at_index(state_info['event_idx'])
## -----------------------------------------------------------------------------
## Finite State Machine
## -----------------------------------------------------------------------------
# At the moment both functions are helpers only, but the goal of making them
# as functions and not a simple `_state = whatever` is to also perform certain
# actions when changing from state to state. If needed in the future, we can
# also emit signals and stuff like that without having to go back to every
# state change in the code.
func set_state(new_state):
var state_string = [ "IDLE", "READY", "TYPING", "WAITING", "WAITING_INPUT", "ANIMATING", ]
#print(state_string[new_state])
_state = new_state
return _state
func is_state(check_state):
if _state == check_state:
return true
return false