bcirpggithubmirror/Phase2/Godot_Toolset/Luke/addons/dialogic/Other/DialogicClass.gd

extends Node

## Exposed and safe to use methods for Dialogic
## See documentation under 'https://github.com/coppolaemilio/dialogic' or in the editor:

## ### /!\ ###
## Do not use methods from other classes as it could break the plugin's integrity
## ### /!\ ###

## Trying to follow this documentation convention: https://github.com/godotengine/godot/pull/41095
class_name Dialogic


## Refactor the start function for 2.0 there should be a cleaner way to do it :)

## Starts the dialog for the given timeline and returns a Dialog node.
## You must then add it manually to the scene to display the dialog.
##
## Example:
## var new_dialog = Dialogic.start('Your Timeline Name Here')
## add_child(new_dialog)
##
## This is similar to using the editor:
## you can drag and drop the scene located at /addons/dialogic/Dialog.tscn 
## and set the current timeline via the inspector.
##
## @param timeline				The timeline to load. You can provide the timeline name or the filename.
##								If you leave it empty, it will try to load from current data
##								In that case, you should do  Dialogic.load() or Dialogic.import() before.
## @param default_timeline		If timeline == '' and no valid data was found, this will be loaded.
## @param dialog_scene_path		If you made a custom Dialog scene or moved it from its default path, you can specify its new path here.
## @param use_canvas_instead	Create the Dialog inside a canvas layer to make it show up regardless of the camera 2D/3D situation.
## @returns						A Dialog node to be added into the scene tree.
static func start(timeline: String = '', default_timeline: String ='', dialog_scene_path: String="res://addons/dialogic/Nodes/DialogNode.tscn", use_canvas_instead=true):
	var dialog_scene = load(dialog_scene_path)
	var dialog_node = null
	var canvas_dialog_node = null
	var returned_dialog_node = null
	
	if use_canvas_instead:
		var canvas_dialog_script = load("res://addons/dialogic/Nodes/canvas_dialog_node.gd")
		canvas_dialog_node = canvas_dialog_script.new()
		canvas_dialog_node.set_dialog_node_scene(dialog_scene)
		dialog_node = canvas_dialog_node.dialog_node
	else:
		dialog_node = dialog_scene.instance()
	
	returned_dialog_node = dialog_node if not canvas_dialog_node else canvas_dialog_node
	
	## 1. Case: A slot has been loaded OR data has been imported
	if timeline == '':
		if (Engine.get_main_loop().has_meta('last_dialog_state') 
			and not Engine.get_main_loop().get_meta('last_dialog_state').empty()
			and not Engine.get_main_loop().get_meta('last_dialog_state').get('timeline', '').empty()):
		
			dialog_node.resume_state_from_info(Engine.get_main_loop().get_meta('last_dialog_state'))
			return returned_dialog_node
		
		## The loaded data isn't complete
		elif (Engine.get_main_loop().has_meta('current_timeline')
			and not Engine.get_main_loop().get_meta('current_timeline').empty()):
				timeline = Engine.get_main_loop().get_meta('current_timeline')
		
		## Else load the default timeline
		else:
			timeline = default_timeline
	
	## 2. Case: A specific timeline should be started
	
	# check if it's a file name
	if timeline.ends_with('.json'):
		for t in DialogicUtil.get_timeline_list():
			if t['file'] == timeline:
				dialog_node.timeline = t['file']
				dialog_node.timeline_name = timeline
				return returned_dialog_node
		# No file found. Show error
		dialog_node.dialog_script = {
			"events":[
				{"event_id":'dialogic_001',
				"character":"",
				"portrait":"",
				"text":"[Dialogic Error] Loading dialog [color=red]" + timeline + "[/color]. It seems like the timeline doesn't exists. Maybe the name is wrong?"
			}]
		}
		return returned_dialog_node
	
	# else get the file from the name
	var timeline_file = _get_timeline_file_from_name(timeline)
	if timeline_file:
		dialog_node.timeline = timeline_file
		dialog_node.timeline_name = timeline
		return returned_dialog_node
	
	# Just in case everything else fails.
	return returned_dialog_node

# Loads the given timeline into the active DialogNode
# This means it's state (theme, characters, background, music) is preserved.
#
# @param timeline				the name of the timeline to load
static func change_timeline(timeline: String) -> void:
	# Set Timeline
	set_current_timeline(timeline)
	
	# If there is a dialog node
	if has_current_dialog_node():
		var dialog_node = Engine.get_main_loop().get_meta('latest_dialogic_node')
		
		# Get file name
		var timeline_file = _get_timeline_file_from_name(timeline)
		
		dialog_node.change_timeline(timeline_file)
	else:
		print("[D] Tried to change timeline, but no DialogNode exists!")

# Immediately plays the next event.
#
# @param discreetly				determines whether the Passing Audio will be played in the process
static func next_event(discreetly: bool = false):
	
	# If there is a dialog node
	if has_current_dialog_node():
		var dialog_node = Engine.get_main_loop().get_meta('latest_dialogic_node')
		
		dialog_node.next_event(discreetly)


################################################################################
## 						Test to see if a timeline exists
################################################################################

## Check to see if a timeline with a given name/path exists. Useful for verifying
## before calling a timeline, or for automated tests to make sure timeline calls 
## are valid. Returns a boolean of true if the timeline exists, and false if it 
## does not. 
static func timeline_exists(timeline: String):
	var timeline_file = _get_timeline_file_from_name(timeline)
	if timeline_file:
		return true
	else:
		return false


################################################################################
## 						BUILT-IN SAVING/LOADING
################################################################################

## Loads the given slot
static func load(slot_name: String = ''):
	_load_from_slot(slot_name)
	Engine.get_main_loop().set_meta('current_save_slot', slot_name)


## Saves the current definitions and the latest added dialog nodes state info.
## 
## @param slot_name		The name of the save slot. To load this save you have to specify the same
##						If the slot folder doesn't exist it will be created. 
static func save(slot_name: String = '', is_autosave = false) -> void:
	# check if to save (if this is a autosave)
	if is_autosave and not get_autosave():
		return
	
	# gather the info
	var current_dialog_info = {}
	if has_current_dialog_node():
		current_dialog_info = Engine.get_main_loop().get_meta('latest_dialogic_node').get_current_state_info()
	
	var game_state = {}
	if Engine.get_main_loop().has_meta('game_state'):
		game_state = Engine.get_main_loop().get_meta('game_state')
	
	var save_data = {
		'game_state': game_state,
		'dialog_state': current_dialog_info
		}
	
	# save the information
	_save_state_and_definitions(slot_name, save_data)


## Returns an array with the names of all available slots.
static func get_slot_names() -> Array:
	return DialogicResources.get_saves_folders()


## Will permanently erase the data in the given save_slot.
## 
## @param slot_name		The name of the slot folder.
static func erase_slot(slot_name: String) -> void:
	DialogicResources.remove_save_folder(slot_name)


## Whether a save can be performed
##
## @returns				True if a save can be performed; otherwise False
static func has_current_dialog_node() -> bool:
	return Engine.get_main_loop().has_meta('latest_dialogic_node') and is_instance_valid(Engine.get_main_loop().get_meta('latest_dialogic_node'))


## Resets the state and definitions of the given save slot
##
## By default this will also LOAD that reseted save
static func reset_saves(slot_name: String = '', reload:= true) -> void:
	DialogicResources.reset_save(slot_name)
	if reload: _load_from_slot(slot_name)


## Returns the currently loaded save slot
static func get_current_slot():
	if Engine.get_main_loop().has_meta('current_save_slot'):
		return Engine.get_main_loop().get_meta('current_save_slot')
	else:
		return ''

## +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
## 						EXPORT / IMPORT
## +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

# this returns a dictionary with the DEFINITIONS, the GAME STATE and the DIALOG STATE
static func export(dialog_node = null) -> Dictionary:
	# gather the data
	var current_dialog_info = {}
	if dialog_node == null and has_current_dialog_node():
		dialog_node = Engine.get_main_loop().get_meta('latest_dialogic_node')
	if dialog_node:
		current_dialog_info = dialog_node.get_current_state_info()
	
	# return it
	return {
		'definitions': _get_definitions(),
		'state': Engine.get_main_loop().get_meta('game_state'),
		'dialog_state': current_dialog_info
	}


# this loads a dictionary with GAME STATE, DEFINITIONS and DIALOG_STATE 
static func import(data: Dictionary) -> void:
	## Tell the future we want to use the imported data
	Engine.get_main_loop().set_meta('current_save_lot', '/')
	
	# load the data
	Engine.get_main_loop().set_meta('definitions', data['definitions'])
	Engine.get_main_loop().set_meta('game_state', data['state'])
	Engine.get_main_loop().set_meta('last_dialog_state', data.get('dialog_state', null))
	set_current_timeline(get_saved_state_general_key('timeline'))


## +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
## 						DEFINITIONS
## +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

# clears all variables
static func clear_all_variables():
	for d in _get_definitions()['variables']:
		d['value'] = ""

# sets the value of the value definition with the given name
static func set_variable(name: String, value):
	var exists = false
	
	if '/' in name:
		var variable_id = _get_variable_from_file_name(name)
		if variable_id != '':
			for d in _get_definitions()['variables']:
				if d['id'] == variable_id:
					d['value'] = str(value)
					exists = true
	else:		
		for d in _get_definitions()['variables']:
			if d['name'] == name:
				d['value'] = str(value)
				exists = true
	if exists == false:
		# TODO it would be great to automatically generate that missing variable here so they don't
		# have to create it from the editor. 
		print("[Dialogic] Warning! the variable [" + name + "] doesn't exists. Create it from the Dialogic editor.")
	return value

# returns the value of the value definition with the given name
static func get_variable(name: String, default = null):
	if '/' in name:
		var variable_id = _get_variable_from_file_name(name)
		for d in _get_definitions()['variables']:
			if d['id'] == variable_id:
				return d['value']
		print("[Dialogic] Warning! the variable [" + name + "] doesn't exists.")
		return default
	else:
		for d in _get_definitions()['variables']:
			if d['name'] == name:
				return d['value']
		print("[Dialogic] Warning! the variable [" + name + "] doesn't exists.")
		return default


## +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
## 						GAME STATE
## +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# the game state is a global dictionary that can be used to store custom data
# these functions should be renamed in 2.0! These names are outdated.

# this sets a value in the GAME STATE dictionary
static func get_saved_state_general_key(key: String, default = '') -> String:
	if not Engine.get_main_loop().has_meta('game_state'):
		return default
	if key in Engine.get_main_loop().get_meta('game_state').keys():
		return Engine.get_main_loop().get_meta('game_state')[key]
	else:
		return default


# this gets a value from the GAME STATE dictionary
static func set_saved_state_general_key(key: String, value) -> void:
	if not Engine.get_main_loop().has_meta('game_state'):
		Engine.get_main_loop().set_meta('game_state', {})
	Engine.get_main_loop().get_meta('game_state')[key] = str(value)
	save('', true)


################################################################################
## 					HISTORY
################################################################################

# Used to toggle the history timeline display. Only useful if you do not wish to
# use the provided buttons
static func toggle_history():
	if has_current_dialog_node():
		var dialog_node = Engine.get_main_loop().get_meta('latest_dialogic_node')
		dialog_node.HistoryTimeline._on_toggle_history()
	else:
		print('[D] Tried to toggle history, but no dialog node exists.')


################################################################################
## 					COULD BE USED
################################################################################
# these are old things, that have little use.

static func get_autosave() -> bool:
	if Engine.get_main_loop().has_meta('autoload'):
		return Engine.get_main_loop().get_meta('autoload')
	return true


static func set_autosave(autoload):
	Engine.get_main_loop().set_meta('autoload', autoload)


static func set_current_timeline(timeline):
	Engine.get_main_loop().set_meta('current_timeline', timeline)
	return timeline


static func get_current_timeline():
	var timeline
	timeline = Engine.get_main_loop().get_meta('current_timeline')
	if timeline == null:
		timeline = ''
	return timeline


# Returns a string with the action button set on the project settings
static func get_action_button():
	return DialogicResources.get_settings_value('input', 'default_action_key', 'dialogic_default_action')

################################################################################
## 					NOT TO BE USED FROM OUTSIDE
################################################################################
## this loads the saves definitions and returns the saves state_info ditionary
static func _load_from_slot(slot_name: String = '') -> Dictionary:
	Engine.get_main_loop().set_meta('definitions', DialogicResources.get_saved_definitions(slot_name))
	
	var state_info = DialogicResources.get_saved_state_info(slot_name)
	Engine.get_main_loop().set_meta('last_dialog_state', state_info.get('dialog_state', null))
	Engine.get_main_loop().set_meta('game_state', state_info.get('game_state', null))
	
	return state_info.get('dialog_state', {})


## this saves the current definitions and the given state info into the save folder @save_name
static func _save_state_and_definitions(save_name: String, state_info: Dictionary) -> void:
	DialogicResources.save_definitions(save_name, _get_definitions())
	DialogicResources.save_state_info(save_name, state_info)



static func _get_definitions() -> Dictionary:
	var definitions
	if Engine.get_main_loop().has_meta('definitions'):
		definitions = Engine.get_main_loop().get_meta('definitions')
	else:
		definitions = DialogicResources.get_default_definitions()
		Engine.get_main_loop().set_meta('definitions', definitions)
	return definitions


# used by the DialogNode
static func set_glossary_from_id(id: String, title: String, text: String, extra:String) -> void:
	var target_def: Dictionary;
	for d in _get_definitions()['glossary']:
		if d['id'] == id:
			target_def = d;
	if target_def != null:
		if title and title != "[No Change]":
			target_def['title'] = title
		if text and text != "[No Change]":
			target_def['text'] = text
		if extra and extra != "[No Change]":
			target_def['extra'] = extra

# used by the DialogNode
static func set_variable_from_id(id: String, value: String, operation: String) -> void:
	var target_def: Dictionary;
	for d in _get_definitions()['variables']:
		if d['id'] == id:
			target_def = d;
	if target_def != null:
		var converted_set_value = value
		var converted_target_value = target_def['value']
		var is_number = converted_set_value.is_valid_float() and converted_target_value.is_valid_float()
		if is_number:
			converted_set_value = float(value)
			converted_target_value = float(target_def['value'])
		var result = target_def['value']
		# Do nothing for -, * and / operations on string
		match operation:
			'=':
				result = converted_set_value
			'+':
				result = converted_target_value + converted_set_value
			'-':
				if is_number:
					result = converted_target_value - converted_set_value
			'*':
				if is_number:
					result = converted_target_value * converted_set_value
			'/':
				if is_number:
					result = converted_target_value / converted_set_value
		target_def['value'] = str(result)

# tries to find the path of a given timeline 
static func _get_timeline_file_from_name(timeline_name_path: String) -> String:
	var timelines = DialogicUtil.get_full_resource_folder_structure()['folders']['Timelines']
	
	# Checks for slash in the name, and uses the folder search if there is 
	if '/' in timeline_name_path:
		#Add leading slash if its a path and it is missing, for paths that have subfolders but no leading slash 
		if(timeline_name_path.left(1) != '/'):
			timeline_name_path = "/" + timeline_name_path
		var parts = timeline_name_path.split('/', false)
	
		# First check if it's a timeline in the root folder
		if parts.size() == 1:
			for t in DialogicUtil.get_timeline_list():
				for f in timelines['files']:
					if t['file'] == f && t['name'] == parts[0]:
						return t['file']
		if parts.size() > 1:
			var current_data
			var current_depth = 0
			for p in parts:
				if current_depth == 0:
					# Starting the crawl
					if (timelines['folders'].has(p) ):
						current_data = timelines['folders'][p]
					else:
						return ''
				elif current_depth == parts.size() - 1:
					# The final destination
					for t in DialogicUtil.get_timeline_list():
						for f in current_data['files']:
							if t['file'] == f && t['name'] == p:
								return t['file']
							
				else:
					# Still going deeper
					if (current_data['folders'].size() > 0):
						if p in current_data['folders']:
							current_data = current_data['folders'][p]
						else:
							return ''
					else:
						return ''
				current_depth += 1
		return ''
	else:
		# Searching for any timeline that could match that name
		for t in DialogicUtil.get_timeline_list():
			if t['name'] == timeline_name_path:
				return t['file']
	return ''

static func _get_variable_from_file_name(variable_name_path: String) -> String:
	#First add the leading slash if it is missing so algorithm works properly
	if(variable_name_path.left(1) != '/'):
		variable_name_path = "/" + variable_name_path

	var definitions = DialogicUtil.get_full_resource_folder_structure()['folders']['Definitions']
	var parts = variable_name_path.split('/', false)
	
	# Check the root if it's a variable in the root folder 
	if parts.size() == 1:
		for t in _get_definitions()['variables']:
			for f in definitions['files']:
				if t['id'] == f && t['name'] == parts[0]:
					return t['id']
	if parts.size() > 1:
		var current_data
		var current_depth = 0
		
		for p in parts:
			if current_depth == 0:

				# Starting the crawl
				if (definitions['folders'].has(p)):
					current_data = definitions['folders'][p]
				else:
					return ''
			elif current_depth == parts.size() - 1:
				# The final destination
				for t in _get_definitions()['variables']:
					for f in current_data['files']:
						if t['id'] == f && t['name'] == p:
							return t['id']
							
			else:
				# Still going deeper
				if (current_data['folders'].size() > 0):
					if p in current_data['folders']:
						current_data = current_data['folders'][p]
					else:
						return ''
				else:
					return ''
			current_depth += 1
	return ''