the-lost-memory/project/addons/dialogic/Nodes/DialogNode.gd

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