253 lines
7.2 KiB
GDScript
253 lines
7.2 KiB
GDScript
@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
|