First work on dialogic, resized guild, and started implementing portraits.

addons/dialogic/Modules/LayeredPortrait/layered_portrait.gd

@@ -0,0 +1,252 @@
+@tool
+## Layered portrait scene.
+##
+## The parent class has a character and portrait variable.
+extends DialogicPortrait
+
+## The term used for hiding a layer.
+const _HIDE_COMMAND := "hide"
+## The term used for showing a layer.
+const _SHOW_COMMAND := "show"
+## The term used for setting a layer to be the only visible layer.
+const _SET_COMMAND := "set"
+
+## A collection of all possible layer commands.
+const _OPERATORS = [_HIDE_COMMAND, _SHOW_COMMAND, _SET_COMMAND]
+
+static var _OPERATORS_EXPRESSION := "|".join(_OPERATORS)
+static var _REGEX_STRING := "(" + _OPERATORS_EXPRESSION + ") (\\S+)"
+static var _REGEX := RegEx.create_from_string(_REGEX_STRING)
+
+var _initialized := false
+
+var _is_coverage_rect_cached := false
+var _cached_coverage_rect := Rect2(0, 0, 0, 0)
+
+
+@export_group("Private")
+## Attempts to fix the offset based on the first child node
+@export var fix_offset := true
+
+## Overriding [class DialogicPortrait]'s method.
+##
+## Load anything related to the given character and portrait
+func _update_portrait(passed_character: DialogicCharacter, passed_portrait: String) -> void:
+	if not _initialized:
+		_apply_layer_adjustments()
+		_initialized = true
+
+	apply_character_and_portrait(passed_character, passed_portrait)
+
+
+## Modifies all layers to fit the portrait preview and appear correctly in
+## portrait containers.
+##
+## This method is not changing the scene itself and is intended for the
+## Dialogic editor preview and in-game rendering only.
+func _apply_layer_adjustments() -> void:
+	var coverage := _find_largest_coverage_rect()
+	var offset_fix := Vector2()
+	if fix_offset and get_child_count():
+		offset_fix = -get_child(0).position
+		if "centered" in get_child(0) and get_child(0).centered:
+			offset_fix += get_child(0).get_rect().size/2.0
+
+	for node: Node in get_children():
+		var node_position: Vector2 = node.position
+		node_position += offset_fix
+		node.position = _reposition_with_rect(coverage, node_position)
+
+
+## Returns a position based on [param rect]'s size where Dialogic expects the
+## scene part to be positioned at. [br]
+## If the node has an offset or extra position, pass it as [param node_offset].
+func _reposition_with_rect(rect: Rect2, node_offset := Vector2(0.0, 0.0)) -> Vector2:
+	return rect.size  * Vector2(-0.5, -1.0) + node_offset
+
+
+## Iterates over all children in [param start_node] and its children, looking
+## for [class Sprite2D] nodes with a texture (not `null`).
+## All found sprites are returned in an array, eventually returning all
+## sprites in the scene.
+func _find_sprites_recursively(start_node: Node) -> Array[Sprite2D]:
+	var sprites: Array[Sprite2D] = []
+
+	# Iterate through the children of the current node
+	for child: Node in start_node.get_children():
+
+		if child is Sprite2D:
+			var sprite := child as Sprite2D
+
+			if sprite.texture:
+				sprites.append(sprite)
+
+
+		var sub := _find_sprites_recursively(child)
+		sprites.append_array(sub)
+
+	return sprites
+
+
+## A command will apply an effect to the layered portrait.
+class LayerCommand:
+	# The different types of effects.
+	enum CommandType {
+		## Additively Show a specific layer.
+		SHOW_LAYER,
+		## Subtractively hide a specific layer.
+		HIDE_LAYER,
+		## Exclusively show a specific layer, hiding all other sibling layers.
+		## A sibling layer is a layer sharing the same parent node.
+		SET_LAYER,
+	}
+
+	var _path: String
+	var _type: CommandType
+
+	## Executes the effect of the layer based on the [enum CommandType].
+	func _execute(root: Node) -> void:
+		var target_node := root.get_node(_path)
+
+		if target_node == null:
+			printerr("Layered Portrait had no node matching the node path: '", _path, "'.")
+			return
+
+		if not target_node is Node2D and not target_node is Sprite2D:
+			printerr("Layered Portrait target path '", _path, "', is not a Sprite2D or Node2D type.")
+			return
+
+		match _type:
+			CommandType.SHOW_LAYER:
+				target_node.show()
+
+			CommandType.HIDE_LAYER:
+				target_node.hide()
+
+			CommandType.SET_LAYER:
+				var target_parent := target_node.get_parent()
+
+				for child: Node in target_parent.get_children():
+
+					if child is Sprite2D:
+						var sprite_child := child as Sprite2D
+						sprite_child.hide()
+
+				target_node.show()
+
+
+## Turns the input into a single [class LayerCommand] object.
+## Returns `null` if the input cannot be parsed into a [class LayerCommand].
+func _parse_layer_command(input: String) -> LayerCommand:
+	var regex_match: RegExMatch = _REGEX.search(input)
+
+	if regex_match == null:
+		print("[Dialogic] Layered Portrait had an invalid command: ", input)
+		return null
+
+	var _path: String = regex_match.get_string(2)
+	var operator: String = regex_match.get_string(1)
+
+	var command := LayerCommand.new()
+
+	match operator:
+		_SET_COMMAND:
+			command._type = LayerCommand.CommandType.SET_LAYER
+
+		_SHOW_COMMAND:
+			command._type = LayerCommand.CommandType.SHOW_LAYER
+
+		_HIDE_COMMAND:
+			command._type = LayerCommand.CommandType.HIDE_LAYER
+
+		_SET_COMMAND:
+			command._type = LayerCommand.CommandType.SET_LAYER
+
+	## We clean escape symbols and trim the spaces.
+	command._path = _path.replace("\\", "").strip_edges()
+
+	return command
+
+
+## Parses [param input] into an array of [class LayerCommand] objects.
+func _parse_input_to_layer_commands(input: String) -> Array[LayerCommand]:
+	var commands: Array[LayerCommand] = []
+	var command_parts := input.split(",")
+
+	for command_part: String in command_parts:
+
+		if command_part.is_empty():
+			continue
+
+		var _command := _parse_layer_command(command_part.strip_edges())
+
+		if not _command == null:
+			commands.append(_command)
+
+	return commands
+
+
+
+## Overriding [class DialogicPortrait]'s method.
+##
+## The extra data will be turned into layer commands and then be executed.
+func _set_extra_data(data: String) -> void:
+	var commands := _parse_input_to_layer_commands(data)
+
+	for _command: LayerCommand in commands:
+		_command._execute(self)
+
+
+## Overriding [class DialogicPortrait]'s method.
+##
+## Handling all layers horizontal flip state.
+func _set_mirror(is_mirrored: bool) -> void:
+	for child: Node in get_children():
+
+		if is_mirrored:
+			child.position.x = child.position.x * -1
+			child.scale.x = -child.scale.x
+
+
+## Scans all nodes in this scene and finds the largest rectangle that
+## covers encloses every sprite.
+func _find_largest_coverage_rect() -> Rect2:
+	if _is_coverage_rect_cached:
+		return _cached_coverage_rect
+
+	var coverage_rect := Rect2(0, 0, 0, 0)
+
+	for sprite: Sprite2D in _find_sprites_recursively(self):
+		var sprite_size := sprite.get_rect().size
+		var sprite_position: Vector2 = sprite.global_position-self.global_position
+
+		if sprite.centered:
+			sprite_position -= sprite_size/2
+
+		var sprite_width := sprite_size.x * sprite.scale.x
+		var sprite_height := sprite_size.y * sprite.scale.y
+
+		var texture_rect := Rect2(
+			sprite_position.x,
+			sprite_position.y,
+			sprite_width,
+			sprite_height
+		)
+		coverage_rect = coverage_rect.merge(texture_rect)
+
+	coverage_rect.position = _reposition_with_rect(coverage_rect)
+
+	_is_coverage_rect_cached = true
+	_cached_coverage_rect = coverage_rect
+
+	return coverage_rect
+
+
+## Overriding [class DialogicPortrait]'s method.
+##
+## Called by Dialogic when the portrait is needed to be shown.
+## For instance, in the Dialogic editor or in-game.
+func _get_covered_rect() -> Rect2:
+	var needed_rect := _find_largest_coverage_rect()
+
+	return needed_rect