552 lines
19 KiB
GDScript
552 lines
19 KiB
GDScript
class_name CardBoard extends PanelContainer
|
|
|
|
enum {NAVIGATE, ASSIGN, DRAG}
|
|
enum Error {
|
|
OK,
|
|
OUT_OF_BOUNDS,
|
|
ILLEGAL_STATE,
|
|
MISSING
|
|
}
|
|
|
|
var focus_stickies:bool = true:
|
|
set(stickies):
|
|
if stickies and sticky_note_container.get_child_count() == 0: return
|
|
|
|
# this messes things up if called unneeded.
|
|
if focus_stickies != stickies:
|
|
focus_stickies = stickies
|
|
|
|
if not current_context == ASSIGN:
|
|
if stickies:
|
|
current_sticky_note_id = current_sticky_note_id
|
|
else:
|
|
current_dropzone_id = current_dropzone_id
|
|
|
|
var has_stage = false:
|
|
set(focus):
|
|
if focus:
|
|
has_stage = true
|
|
get_tree().call_group("interactables", "collapse")
|
|
current_dropzone_id = 0
|
|
current_sticky_note_id = 0
|
|
focus_stickies = true
|
|
else:
|
|
has_stage = false
|
|
if is_node_ready():
|
|
if focus:
|
|
process_mode = Node.PROCESS_MODE_INHERIT
|
|
else:
|
|
process_mode = Node.PROCESS_MODE_DISABLED
|
|
for sticky in dropzone.get_children():
|
|
if sticky is StickyNote:
|
|
sticky.is_dragged = false
|
|
visible = has_stage
|
|
|
|
@onready var dropzone = $HBoxContainer/dropzone
|
|
var dropzone_size: Vector2
|
|
@export var dropzone_padding:int = 100
|
|
@onready var sticky_note_container = $HBoxContainer/ScrollContainer/VBoxContainer
|
|
@onready var current_context:int = NAVIGATE:
|
|
set(context):
|
|
if current_context == ASSIGN and !context == ASSIGN:
|
|
sticky_note_container.get_child(current_sticky_note_id).clear_if_empty()
|
|
#match context:
|
|
# NAVIGATE:
|
|
# _return_sticky_notes_to_panels()
|
|
# DRAG:
|
|
# pass
|
|
# ASSIGN:
|
|
# pass
|
|
current_context = context
|
|
@onready var instructions = $instructions_panel/HBoxContainer/cards_remaining
|
|
@onready var timer: Timer = $Timer
|
|
|
|
var mementos_collected: int = 0:
|
|
set(mementos):
|
|
mementos_collected = mementos
|
|
match mementos:
|
|
1:
|
|
instructions.text = "There are three Mementos left to find."
|
|
2:
|
|
instructions.text = "You have collected half of the mementos."
|
|
3:
|
|
instructions.text = "Find the last Memento to complete the Board."
|
|
4:
|
|
instructions.text = "Combine cards to order your thoughts."
|
|
|
|
@onready var currently_active_node: Area2D = null:
|
|
set(new_node):
|
|
# this makes sure no accidental context switches can happen while a card is being dragged.
|
|
if not (current_context == DRAG):
|
|
if not currently_active_node == null:
|
|
currently_active_node.highlighted = false
|
|
currently_active_node = new_node
|
|
if not currently_active_node == null:
|
|
currently_active_node.highlighted = true
|
|
|
|
@onready var current_dropzone_id: int = 0:
|
|
set(new_id):
|
|
if new_id > dropzone.get_child_count() - 1: current_dropzone_id = 0
|
|
elif new_id < 0: current_dropzone_id = dropzone.get_child_count() - 1
|
|
else: current_dropzone_id = new_id
|
|
if current_context == ASSIGN and not focus_stickies:
|
|
while not dropzone.get_child(current_dropzone_id) is Card: current_dropzone_id = (current_dropzone_id + 1) % dropzone.get_child_count()
|
|
dropzone.get_child(current_dropzone_id).preview_sticky_note(currently_active_node)
|
|
|
|
elif not focus_stickies:
|
|
currently_active_node = dropzone.get_child(current_dropzone_id)
|
|
|
|
@onready var current_sticky_note_id: int = 0:
|
|
set(new_id):
|
|
if sticky_note_container.get_child_count() <= 1: return
|
|
elif new_id > sticky_note_container.get_child_count() - 1: current_sticky_note_id = 0
|
|
elif new_id < 0: current_sticky_note_id = sticky_note_container.get_child_count() - 1
|
|
else: current_sticky_note_id = new_id
|
|
if current_context == ASSIGN:
|
|
_return_sticky_notes_to_panels()
|
|
currently_active_node.preview_sticky_note(sticky_note_container.get_child(current_sticky_note_id).attached_sticky_note)
|
|
else:
|
|
if sticky_note_container.get_child(current_sticky_note_id).get_child_count() == 1:
|
|
currently_active_node = sticky_note_container.get_child(current_sticky_note_id).get_child(0)
|
|
else:
|
|
for i in range(sticky_note_container.get_child_count() - 1):
|
|
if sticky_note_container.get_child(i).get_child_count() == 1:
|
|
currently_active_node = sticky_note_container.get_child(i).get_child(0)
|
|
|
|
var last_save_dict: Dictionary
|
|
var text_recovery: Dictionary
|
|
|
|
signal board_completed
|
|
|
|
# Called when the node enters the scene tree for the first time.
|
|
func _ready():
|
|
var size_reference = StickyNotePanel.new()
|
|
|
|
dropzone_size = get_viewport_rect().size - Vector2(dropzone_padding + size_reference.minimum_size.x, dropzone_padding)
|
|
|
|
if get_parent() == get_tree().root:
|
|
populate_board(["void", 'joy', "wet", "effort"])
|
|
populate_board(["jui_jutsu", 'hit', "girly", "vent"])
|
|
populate_board(["comic_heroes", 'teasing', "agent_q", "good_intended"])
|
|
populate_board(["out_of_world", 'confusion', "outer_conflict", "unique"])
|
|
mementos_collected = 2
|
|
|
|
has_stage = has_stage
|
|
|
|
get_viewport().gui_focus_changed.connect(reclaim_lost_focus)
|
|
|
|
#FIXME properly implement board recovery
|
|
#timer.timeout.connect(validate_board)
|
|
#timer.start()
|
|
|
|
#await get_tree().process_frame
|
|
#last_save_dict = get_save_dict()
|
|
|
|
|
|
func reclaim_lost_focus():
|
|
if has_stage:
|
|
grab_focus()
|
|
|
|
#func _process(delta):
|
|
# # drops dragged area when Mouse is no longer pressed.
|
|
# if has_stage and !Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT) and current_context == DRAGGING:
|
|
# currently_active_node.is_dragged = false
|
|
|
|
# Will be used later to spawn Cards and Post-Its and remember them in the dictionary
|
|
func populate_board(card_names: Array[StringName]):
|
|
mementos_collected += 1
|
|
|
|
var all_new:Dictionary = HardCards.get_cards_by_name_array(card_names)
|
|
|
|
# spawning the cards and adding them to the dictionary
|
|
for new_card in all_new["cards"]:
|
|
add_card(new_card, false)
|
|
for new_sticky_note in all_new["sticky_notes"]: # spawning a sticky note
|
|
add_sticky_note(new_sticky_note, false)
|
|
|
|
#currently_active_node = area_dict["dropzone_content"][0] # set first Card as currently selected node by default
|
|
currently_active_node = dropzone.get_child(0)
|
|
|
|
func add_card(card: Card, reparent:bool = true):
|
|
if reparent:
|
|
card.reparent(self)
|
|
else:
|
|
add_child(card)
|
|
card.position = Vector2(randi_range(dropzone_padding, dropzone_size.x), randi_range(dropzone_padding, dropzone_size.y))
|
|
insert_area(dropzone, card)
|
|
card.set_owner(self)
|
|
card.is_dragable = true
|
|
|
|
func add_sticky_note(sticky: StickyNote, reparent:bool = true):
|
|
var new_panel = StickyNotePanel.new()
|
|
sticky_note_container.add_child(new_panel, true, Node.INTERNAL_MODE_DISABLED)
|
|
#WARNING this for some reason would break the tweens
|
|
new_panel.set_owner(self)
|
|
sticky.current_handle = self
|
|
new_panel.attatch_sticky_note(sticky, self, false, reparent)
|
|
|
|
# Checks if a Node is currently inside the dropzone
|
|
func is_in_dropzone(to_check: Node) -> bool:
|
|
return dropzone.get_rect().has_point(to_check.global_position)
|
|
|
|
# Called by notes when a mouse event needs handling
|
|
func handle_mouse_button(input: InputEventMouseButton, to_handle = currently_active_node):
|
|
|
|
# Makes sure that only the same area is dragged.
|
|
# Otherwise overlapping areas are dragged at the same time.
|
|
if current_context == DRAG and to_handle != currently_active_node:
|
|
return
|
|
|
|
if input.button_index == MOUSE_BUTTON_MASK_LEFT and input.pressed:
|
|
currently_active_node = to_handle
|
|
to_handle.is_dragged = true
|
|
if to_handle is StickyNote:
|
|
if not to_handle.on_board:
|
|
to_handle.reparent(dropzone)
|
|
to_handle.on_board = true
|
|
to_handle.attached_to = self
|
|
current_context = DRAG
|
|
|
|
# when Drag stops ...
|
|
if input.button_index == MOUSE_BUTTON_MASK_LEFT and not input.pressed:
|
|
to_handle.is_dragged = false
|
|
if to_handle is StickyNote:
|
|
if is_in_dropzone(to_handle):
|
|
if to_handle.has_overlapping_areas():
|
|
for area in to_handle.get_overlapping_areas():
|
|
if area is Card:
|
|
focus_stickies = false
|
|
if area.has_sticky_note_attached():
|
|
to_handle = area.exchange_sticky_note_with(to_handle)
|
|
to_handle.reparent(dropzone)
|
|
to_handle.on_board = true
|
|
# FIXME: this caused an error when all stickies were attatched ...
|
|
sticky_note_container.get_child(current_sticky_note_id).attached_sticky_note = to_handle
|
|
to_handle.attached_to = sticky_note_container.get_child(current_sticky_note_id)
|
|
to_handle.reset_drag()
|
|
current_context = NAVIGATE
|
|
_return_sticky_notes_to_panels()
|
|
return
|
|
else:
|
|
area.attach_sticky_note(to_handle)
|
|
to_handle.z_index = 0
|
|
if sticky_note_container.get_child_count() > 0:
|
|
sticky_note_container.get_child(current_sticky_note_id).clear_if_empty()
|
|
current_context = NAVIGATE
|
|
if is_board_complete(): board_completed.emit()
|
|
return
|
|
else:
|
|
var i: int = 0
|
|
for panel: StickyNotePanel in sticky_note_container.get_children():
|
|
i += 1
|
|
if panel.is_gapped or i == sticky_note_container.get_child_count():
|
|
panel.collapse_gap()
|
|
var new_panel = StickyNotePanel.new()
|
|
sticky_note_container.add_child(new_panel)
|
|
sticky_note_container.move_child(new_panel, i)
|
|
new_panel.attatch_sticky_note(to_handle, self)
|
|
new_panel.owner = self
|
|
panel.clear_if_empty()
|
|
_return_sticky_notes_to_panels()
|
|
current_context = NAVIGATE
|
|
return
|
|
|
|
## Dropping Cards and Sticky Notes not causing a return condition above.
|
|
if not (to_handle is StickyNote and to_handle.is_sticky_note_attached()):
|
|
if to_handle.get_parent() is Card:
|
|
insert_area(to_handle.get_parent().remove_sticky_note(), to_handle)
|
|
else:
|
|
insert_area(dropzone, to_handle)
|
|
current_context = NAVIGATE
|
|
focus_stickies = false
|
|
current_dropzone_id = dropzone.get_children().find(to_handle)
|
|
if to_handle is StickyNote:
|
|
to_handle.rotation = to_handle.base_rotation
|
|
to_handle.scale = to_handle.base_scale
|
|
|
|
if input.is_action_pressed("mouse_right") and current_context == DRAG:
|
|
to_handle.reset_drag()
|
|
|
|
|
|
func _return_sticky_notes_to_panels():
|
|
for panel:StickyNotePanel in sticky_note_container.get_children():
|
|
panel.reclaim_sticky_note()
|
|
|
|
for node in dropzone.get_children():
|
|
if node is StickyNote:
|
|
node.is_dragable = true
|
|
|
|
func is_board_complete() -> bool:
|
|
if mementos_collected == 4:
|
|
for card in dropzone.get_children():
|
|
if card is Card:
|
|
if not card.has_sticky_note_attached():
|
|
return false
|
|
return true
|
|
return false
|
|
|
|
func is_board_lore() -> bool:
|
|
for card in dropzone.get_children():
|
|
if card is Card:
|
|
if card.has_sticky_note_attached():
|
|
if not card.current_sticky_note.sticky_id.contains(card.card_id): return false
|
|
return true
|
|
|
|
# Mark area that was hovered over as currently selected
|
|
func handle_hover(to_handle: Area2D):
|
|
if Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT): return
|
|
currently_active_node = to_handle
|
|
|
|
if is_in_dropzone(to_handle) or to_handle is Card:
|
|
if not (to_handle is StickyNote and !to_handle.on_board):
|
|
current_dropzone_id = dropzone.get_children().find(to_handle)
|
|
focus_stickies = false
|
|
else:
|
|
current_sticky_note_id = sticky_note_container.get_children().find(to_handle.attached_to)
|
|
focus_stickies = true
|
|
|
|
# Adds a child at the correct child indext in an area
|
|
func insert_area(parent: Control, node: Area2D):
|
|
var children:Array = parent.get_children()
|
|
var i = 0
|
|
|
|
if not node in parent.get_children():
|
|
node.reparent(parent)
|
|
if node is StickyNote:
|
|
node.on_board = true
|
|
node.owner = self
|
|
|
|
if children.size() > 0:
|
|
children.erase(node)
|
|
while children[i].global_position.y < node.global_position.y and i+1 < children.size():
|
|
i+=1
|
|
parent.move_child(node, i)
|
|
|
|
if node is StickyNote:
|
|
node.attached_to = self
|
|
node.is_dragable = true
|
|
|
|
# Takes the inputs for control inputs
|
|
func _input(event):
|
|
|
|
# Return, if the input is a mouse event (mouse events are handled separately)
|
|
if not has_stage or not is_instance_valid(currently_active_node): return
|
|
|
|
if event.is_action_pressed("ui_cancel"):
|
|
State.leave_stage(self)
|
|
get_viewport().set_input_as_handled()
|
|
|
|
if event is InputEventMouse:
|
|
# makes sure to pass release events so notes do not get attached to the mouse while the cursor leaves the area.
|
|
if event is InputEventMouseButton and current_context == DRAG:
|
|
if event.button_index == MOUSE_BUTTON_LEFT and not event.pressed:
|
|
handle_mouse_button(event)
|
|
get_viewport().set_input_as_handled()
|
|
else:
|
|
return
|
|
|
|
if current_context != DRAG:
|
|
if event.is_action_pressed("ui_up"):
|
|
if focus_stickies:
|
|
current_sticky_note_id -= 1
|
|
else:
|
|
current_dropzone_id -= 1
|
|
get_viewport().set_input_as_handled()
|
|
|
|
elif event.is_action_pressed("ui_down"): # down to select an element beneath
|
|
if focus_stickies:
|
|
current_sticky_note_id += 1
|
|
else:
|
|
current_dropzone_id += 1
|
|
get_viewport().set_input_as_handled()
|
|
|
|
elif event.is_action_pressed("ui_right"): # left to switch context to the left
|
|
if not focus_stickies:
|
|
if current_context == NAVIGATE:
|
|
focus_stickies = true
|
|
elif current_context == ASSIGN:
|
|
current_context = NAVIGATE
|
|
get_viewport().set_input_as_handled()
|
|
|
|
elif event.is_action_pressed("ui_left"): # right to switch context to the right
|
|
if focus_stickies:
|
|
if current_context == NAVIGATE:
|
|
focus_stickies = false
|
|
elif current_context == ASSIGN:
|
|
current_context = NAVIGATE
|
|
get_viewport().set_input_as_handled()
|
|
|
|
elif event.is_action_pressed("ui_accept"): # select the selected note it
|
|
if dropzone.get_child(current_dropzone_id) is Card:
|
|
var card:Card = dropzone.get_child(current_dropzone_id)
|
|
if current_context == ASSIGN: # to assign it to a card
|
|
if card.has_sticky_note_attached():
|
|
currently_active_node = card.exchange_sticky_note_with(currently_active_node)
|
|
current_dropzone_id = find_first_free_card()
|
|
else:
|
|
card.attach_sticky_note(sticky_note_container.get_child(current_sticky_note_id).attached_sticky_note)
|
|
current_context = NAVIGATE
|
|
current_sticky_note_id += 1
|
|
current_dropzone_id = find_first_free_card()
|
|
if is_board_complete(): emit_signal("board_completed")
|
|
else:
|
|
if !focus_stickies and card.has_sticky_note_attached():
|
|
currently_active_node = card.remove_sticky_note()
|
|
add_sticky_note(currently_active_node)
|
|
current_dropzone_id = -1
|
|
else: current_dropzone_id = find_first_free_card()
|
|
|
|
current_context = ASSIGN
|
|
focus_stickies = !focus_stickies
|
|
if focus_stickies:
|
|
current_sticky_note_id = current_sticky_note_id
|
|
else:
|
|
current_dropzone_id = current_dropzone_id
|
|
elif dropzone.get_child(current_dropzone_id) is StickyNote:
|
|
if currently_active_node is StickyNote:
|
|
currently_active_node = dropzone.get_child(current_dropzone_id)
|
|
focus_stickies = false
|
|
current_context = ASSIGN
|
|
current_dropzone_id += 1
|
|
currently_active_node.is_dragable = false
|
|
currently_active_node.z_index = 1
|
|
get_viewport().set_input_as_handled()
|
|
|
|
# move the note it so it floats next to the card where it should be attached
|
|
func _select_card_for_assigning(sticky_note: Area2D, card: Area2D):
|
|
sticky_note.tween_transform_to(card.get_child(3).global_position)
|
|
|
|
func on_scene_skipped(i: int):
|
|
mementos_collected += i
|
|
|
|
func claim_focus():
|
|
State.pass_stage_to(self)
|
|
|
|
func find_first_free_card() -> int:
|
|
for i in range(dropzone.get_child_count()):
|
|
# start searching at the current location, use modulo to avoid getting out of array bounds
|
|
if !dropzone.get_child((i+current_dropzone_id)%dropzone.get_child_count()).has_sticky_note_attached():
|
|
return (i+current_dropzone_id)%dropzone.get_child_count()
|
|
return -1
|
|
|
|
func on_sticky_panel_cleared():
|
|
if current_sticky_note_id == sticky_note_container.get_child_count() - 1:
|
|
current_sticky_note_id -= 1
|
|
|
|
func get_save_dict() -> Dictionary:
|
|
var cards: Dictionary = {}
|
|
var stickies: Dictionary = {}
|
|
|
|
for child in dropzone.get_children():
|
|
if child is Card:
|
|
# Save position of Card.
|
|
cards[child.name] = child.transform.origin
|
|
|
|
if child.has_sticky_note_attached():
|
|
# Saves Card Name as position of it's children.
|
|
stickies[child.get_attached_sticky_note().name] = child.name
|
|
|
|
elif child is StickyNote:
|
|
# Save position of StickyNote.
|
|
cards[child.name] = child.transform.origin
|
|
|
|
for child in sticky_note_container.get_children():
|
|
if child is StickyNotePanel:
|
|
# Saves all collected Stickies that are not on board.
|
|
stickies[child.attached_sticky_note.name] = -1
|
|
return {
|
|
"cards": cards,
|
|
"stickies": stickies
|
|
}
|
|
|
|
|
|
func initialise_from_save(savegame: SaveGame):
|
|
last_save_dict = savegame.board_state.duplicate()
|
|
if savegame.board_state == {}: return
|
|
rebuild_from_savedict(savegame.board_state)
|
|
|
|
func rebuild_from_savedict(board_state:Dictionary):
|
|
var cards: Dictionary = board_state["cards"]
|
|
var stickies: Dictionary = board_state["stickies"]
|
|
|
|
var card_pile = HardCards.get_cards_by_name_array(cards.keys() + (stickies.keys()))
|
|
|
|
for card:Card in card_pile["cards"]:
|
|
add_card(card)
|
|
card.transform.origin = cards[card.name] # Replacing position reference with card reference! Needed in next loop.
|
|
cards[card.name] = card
|
|
text_recovery[card.name] = card.text
|
|
for sticky:StickyNote in card_pile["sticky_notes"]:
|
|
text_recovery[sticky.name] = sticky.text
|
|
if stickies[sticky.name] == -1:
|
|
add_sticky_note(sticky)
|
|
elif stickies[sticky.name] is String:
|
|
cards[stickies[sticky.name]].attach_sticky_note(sticky)
|
|
else:
|
|
insert_area(dropzone, sticky)
|
|
sticky.transform.origin = stickies[sticky.name]
|
|
|
|
func validate_board():
|
|
return
|
|
if current_context == NAVIGATE:
|
|
|
|
var needs_rebuild = false
|
|
for node in dropzone.get_children():
|
|
if node is Card:
|
|
match validate_card(node):
|
|
Error.OUT_OF_BOUNDS:
|
|
node.position = last_save_dict[node.name]
|
|
Error.ILLEGAL_STATE:
|
|
needs_rebuild = true
|
|
if node is StickyNote:
|
|
match validate_sticky(node):
|
|
Error.OUT_OF_BOUNDS:
|
|
node.position = last_save_dict[node.name]
|
|
Error.ILLEGAL_STATE:
|
|
needs_rebuild = true
|
|
for panel:StickyNotePanel in sticky_note_container.get_children():
|
|
if panel.attached_sticky_note != null:
|
|
match validate_sticky(panel.attached_sticky_note):
|
|
Error.OUT_OF_BOUNDS:
|
|
panel.attached_sticky_note.position = panel.ancor_position
|
|
Error.ILLEGAL_STATE:
|
|
needs_rebuild = true
|
|
|
|
# FIXME: currently, illegal temporary state exists a lot and needs to be rectified before this can be trusted.
|
|
if needs_rebuild and false:
|
|
|
|
for child in dropzone.get_children(): child.free()
|
|
for child in sticky_note_container.get_children(): child.free()
|
|
|
|
rebuild_from_savedict(last_save_dict)
|
|
|
|
current_dropzone_id = 0
|
|
current_sticky_note_id = 0
|
|
focus_stickies = false
|
|
current_context = NAVIGATE
|
|
else:
|
|
last_save_dict = get_save_dict()
|
|
|
|
func validate_sticky(note: StickyNote) -> CardBoard.Error:
|
|
if not get_viewport_rect().has_point(note.get_global_transform().origin):
|
|
return Error.OUT_OF_BOUNDS
|
|
if note.attached_to is StickyNotePanel:
|
|
if note.position != note.attached_to.ancor_position:
|
|
return Error.OUT_OF_BOUNDS
|
|
if (note.on_board and not is_in_dropzone(note)):
|
|
return Error.ILLEGAL_STATE
|
|
if not ((note.attached_to == self and dropzone.get_children().has(note)) or note.attached_to == note.get_parent()) or note.shift_tween != null:
|
|
return Error.ILLEGAL_STATE
|
|
|
|
return Error.OK
|
|
|
|
func validate_card(card: Card) -> CardBoard.Error:
|
|
if not is_in_dropzone(card):
|
|
return Error.OUT_OF_BOUNDS
|
|
if card.get_attached_sticky_note() != card.current_sticky_note:
|
|
#push_error("Card %s claims to have %s as current sticky note but has %s attached." % [card.name, card.current_sticky_note, card.get_attached_sticky_note()])
|
|
return Error.ILLEGAL_STATE
|
|
if not card.owner == self:
|
|
return Error.ILLEGAL_STATE
|
|
return CardBoard.Error.OK
|