1300 lines
38 KiB
GDScript
1300 lines
38 KiB
GDScript
class_name GameUI
|
|
extends CanvasLayer
|
|
|
|
const CollectionLogType = preload("res://collection/collection_log.gd")
|
|
const FishBuyerProfileType = preload("res://economy/fish_buyer_profile.gd")
|
|
const FishSaleServiceType = preload("res://economy/fish_sale_service.gd")
|
|
const FishPoolType = preload("res://fish/fish_pool.gd")
|
|
const FishQualityType = preload("res://fish/fish_quality.gd")
|
|
const FishInventoryType = preload("res://inventory/fish_inventory.gd")
|
|
const FishingSpotType = preload("res://fishing/fishing_spot.gd")
|
|
const PlayerMenuType = preload("res://ui/player_menu.gd")
|
|
const PlayerType = preload("res://player/player.gd")
|
|
const PlayerWalletType = preload("res://economy/player_wallet.gd")
|
|
const ItemCatalogType = preload("res://items/item_catalog.gd")
|
|
const PlayerBagType = preload("res://inventory/player_bag.gd")
|
|
const PlayerHotbarType = preload("res://inventory/player_hotbar.gd")
|
|
const HotbarUIType = preload("res://ui/hotbar.gd")
|
|
const TitleScreenType = preload("res://ui/title_screen.gd")
|
|
const PauseMenuType = preload("res://ui/pause_menu.gd")
|
|
const NetworkSessionType = preload("res://network/network_session.gd")
|
|
const FishingShopType = preload("res://ui/fishing_shop.gd")
|
|
const SettingsPanelType = preload("res://ui/settings_panel.gd")
|
|
const PlayerFishingUpgradesType = preload(
|
|
"res://progression/player_fishing_upgrades.gd"
|
|
)
|
|
const ShopInteractionType = preload(
|
|
"res://world/fishing_shop_interaction.gd"
|
|
)
|
|
const PlayerItemEffectsType = preload(
|
|
"res://progression/player_item_effects.gd"
|
|
)
|
|
const PlayerCoolerCapacityType = preload(
|
|
"res://progression/player_cooler_capacity.gd"
|
|
)
|
|
const ChatUIType = preload("res://ui/chat_ui.gd")
|
|
const EmoteRadialMenuType = preload("res://ui/emote_radial_menu.gd")
|
|
const QuickRadialMenuType = preload("res://ui/quick_radial_menu.gd")
|
|
const ControllerVirtualCursorType = preload(
|
|
"res://ui/controller_virtual_cursor.gd"
|
|
)
|
|
const SurfaceDrawingToolbarType = preload(
|
|
"res://ui/surface_drawing_toolbar.gd"
|
|
)
|
|
const PlayerSettingsManagerType = preload(
|
|
"res://settings/player_settings_manager.gd"
|
|
)
|
|
const WorldTimeServiceType = preload("res://world/world_time_service.gd")
|
|
const WorldWeatherServiceType = preload(
|
|
"res://world/world_weather_service.gd"
|
|
)
|
|
const PlayerExperienceType = preload(
|
|
"res://progression/player_experience.gd"
|
|
)
|
|
const UIReferencePresentationType = preload(
|
|
"res://ui/ui_reference_presentation.gd"
|
|
)
|
|
|
|
signal pixelation_settings_visibility_changed(is_visible: bool)
|
|
signal crisp_reset_focus_requested
|
|
signal interactive_pointer_ui_changed(is_open: bool)
|
|
signal passive_pointer_ui_changed(is_enabled: bool)
|
|
signal player_menu_backdrop_visibility_changed(is_visible: bool)
|
|
signal shop_backdrop_visibility_changed(is_visible: bool)
|
|
|
|
const VIRTUAL_MOUSE_INPUT_OWNER: StringName = &"controller_virtual_mouse"
|
|
const VIRTUAL_MOUSE_TRIGGER_THRESHOLD: float = 0.55
|
|
const VIRTUAL_MOUSE_STICK_DEADZONE: float = 0.18
|
|
const VIRTUAL_MOUSE_SPEED: float = 720.0
|
|
|
|
@onready var _status_label: Label = %StatusLabel
|
|
@onready var _gameplay_transient_hud: Control = %GameplayTransientHUD
|
|
@onready var _experience_presentation: Control = %ExperiencePresentation
|
|
@onready var _catch_track: Control = %CatchTrack
|
|
@onready var _green_catch_progress: ProgressBar = %GreenCatchProgress
|
|
@onready var _red_chase_progress: ProgressBar = %RedChaseProgress
|
|
@onready var _barrier_markers: Control = %BarrierMarkers
|
|
@onready var _barrier_prompt_panel: PanelContainer = %BarrierPromptPanel
|
|
@onready var _barrier_prompt: Label = %BarrierPrompt
|
|
@onready var _barrier_health: Label = %BarrierHealth
|
|
@onready var _showcase_details: Label = %ShowcaseDetails
|
|
@onready var _fishing_panel: PanelContainer = %FishingPanel
|
|
@onready var _experience_panel: PanelContainer = %ExperienceProgressPanel
|
|
@onready var _experience_level_label: Label = %ExperienceLevelLabel
|
|
@onready var _experience_award_label: Label = %ExperienceAwardLabel
|
|
@onready var _experience_progress: ProgressBar = %ExperienceProgress
|
|
@onready var _experience_bubble: PanelContainer = %ExperienceBubble
|
|
@onready var _experience_bubble_label: Label = %ExperienceBubbleLabel
|
|
@onready var _canonical_stage: Control = %CanonicalStage
|
|
@onready var _ui_root: Control = %UIRoot
|
|
@onready var _player_menu: PlayerMenuType = %PlayerMenu
|
|
@onready var _screen_fade: ScreenFade = %ScreenFade
|
|
@onready var _title_screen: TitleScreenType = %TitleScreen
|
|
@onready var _pause_menu: PauseMenuType = %PauseMenu
|
|
@onready var _hotbar_ui: HotbarUIType = %Hotbar
|
|
@onready var _fishing_shop: FishingShopType = %FishingShop
|
|
@onready var _shop_prompt: PanelContainer = %ShopPrompt
|
|
@onready var _effect_status: Label = %EffectStatus
|
|
@onready var _chat_ui: ChatUIType = %ChatUI
|
|
@onready var _emote_radial_menu: EmoteRadialMenuType = %EmoteRadialMenu
|
|
@onready var _quick_radial_menu: QuickRadialMenuType = %QuickRadialMenu
|
|
@onready var _controller_virtual_cursor: ControllerVirtualCursorType = (
|
|
%ControllerVirtualCursor
|
|
)
|
|
@onready var _surface_drawing_toolbar: SurfaceDrawingToolbarType = (
|
|
%SurfaceDrawingToolbar
|
|
)
|
|
@onready var _title_settings_panel: SettingsPanelType = (
|
|
$UIRoot/TitleScreen/ResponsiveTitleStage/TitlePresentationScaleRoot/SettingsPanel
|
|
)
|
|
@onready var _pause_settings_panel: SettingsPanelType = (
|
|
$UIRoot/CanonicalStage/PauseMenu/ResponsivePauseStage/PausePresentationScaleRoot/SettingsCenter/SettingsPanel
|
|
)
|
|
|
|
var _showcase_active: bool = false
|
|
var _player: PlayerType
|
|
var _player_menu_open: bool = false
|
|
var _gameplay_ui_enabled: bool = false
|
|
var _fishing_spot: FishingSpotType
|
|
var _system_menu_open: bool = false
|
|
var _shop_open: bool = false
|
|
var _chat_input_open: bool = false
|
|
var _player_menu_hotbar_visible: bool = false
|
|
var _item_effects: PlayerItemEffectsType
|
|
var _main_shop_buyer: FishBuyerProfileType
|
|
var _shop_interaction: ShopInteractionType
|
|
var _surface_drawing: NetworkSurfaceDrawingService
|
|
var _experience: PlayerExperienceType
|
|
var _experience_award_queue: Array[Dictionary] = []
|
|
var _experience_animation_active: bool = false
|
|
var _experience_animation_generation: int = 0
|
|
var _experience_panel_rest_y: float = 18.0
|
|
var _emote_prior_camera_input_enabled: bool = true
|
|
var _quick_prior_camera_input_enabled: bool = true
|
|
var _virtual_mouse_active: bool = false
|
|
var _virtual_mouse_prior_camera_input_enabled: bool = true
|
|
var _virtual_mouse_prior_mouse_mode: Input.MouseMode = Input.MOUSE_MODE_VISIBLE
|
|
var _virtual_mouse_window_position: Vector2 = Vector2.ZERO
|
|
var _virtual_mouse_button_mask: int = 0
|
|
var _virtual_mouse_right_pressed: bool = false
|
|
var _injecting_virtual_mouse_event: bool = false
|
|
|
|
|
|
func _ready() -> void:
|
|
# Reward feedback must remain above full-screen canonical menus. Keeping the
|
|
# overlay as the final stage child makes that ownership explicit instead of
|
|
# relying on scene declaration order when another menu adds high-z children.
|
|
var presentation_parent: Node = _experience_presentation.get_parent()
|
|
if presentation_parent != null:
|
|
presentation_parent.move_child(
|
|
_experience_presentation,
|
|
presentation_parent.get_child_count() - 1,
|
|
)
|
|
_emote_radial_menu.emote_selected.connect(_on_emote_selected)
|
|
_quick_radial_menu.action_selected.connect(_on_quick_action_selected)
|
|
_chat_ui.text_entry_ownership_changed.connect(
|
|
_on_chat_text_entry_ownership_changed
|
|
)
|
|
_hotbar_ui.presentation_transition_finished.connect(
|
|
_on_hotbar_presentation_transition_finished
|
|
)
|
|
_title_settings_panel.panel_visibility_changed.connect(
|
|
_on_settings_visibility_changed
|
|
)
|
|
_pause_settings_panel.panel_visibility_changed.connect(
|
|
_on_settings_visibility_changed
|
|
)
|
|
_title_settings_panel.crisp_reset_focus_requested.connect(
|
|
crisp_reset_focus_requested.emit
|
|
)
|
|
_pause_settings_panel.crisp_reset_focus_requested.connect(
|
|
crisp_reset_focus_requested.emit
|
|
)
|
|
|
|
|
|
func setup(
|
|
player: PlayerType,
|
|
inventory: FishInventoryType,
|
|
collection_log: CollectionLogType,
|
|
experience: PlayerExperienceType,
|
|
wallet: PlayerWalletType,
|
|
sale_service: FishSaleServiceType,
|
|
default_buyer: FishBuyerProfileType,
|
|
catalog: FishPoolType,
|
|
fishing_spot: FishingSpotType,
|
|
bag: PlayerBagType,
|
|
hotbar: PlayerHotbarType,
|
|
item_catalog: ItemCatalogType,
|
|
main_shop_buyer: FishBuyerProfileType,
|
|
fishing_upgrades: PlayerFishingUpgradesType,
|
|
shop_interaction: ShopInteractionType,
|
|
item_effects: PlayerItemEffectsType,
|
|
cooler_capacity: PlayerCoolerCapacityType,
|
|
network_session: NetworkSessionType,
|
|
network_sale_service: NetworkSaleService,
|
|
network_shop_service: NetworkShopService,
|
|
network_chat_service: NetworkChatService,
|
|
network_profile: NetworkProfilePreferences,
|
|
spawn_service: PlayerSpawnService,
|
|
network_mail_service: NetworkMailService,
|
|
reservations: PlayerAssetReservationService,
|
|
network_profile_service: NetworkProfileService,
|
|
network_player_list: NetworkPlayerListService,
|
|
settings_manager: PlayerSettingsManagerType,
|
|
surface_drawing: NetworkSurfaceDrawingService,
|
|
art_unlocks: PlayerArtUnlocks,
|
|
world_time: WorldTimeServiceType,
|
|
world_weather: WorldWeatherServiceType,
|
|
player_jobs: PlayerJobService,
|
|
) -> void:
|
|
_player = player
|
|
_fishing_spot = fishing_spot
|
|
_item_effects = item_effects
|
|
_experience = experience
|
|
if (
|
|
_experience != null
|
|
and not _experience.experience_awarded.is_connected(
|
|
_on_experience_awarded
|
|
)
|
|
):
|
|
_experience.experience_awarded.connect(_on_experience_awarded)
|
|
_chat_ui.setup(
|
|
network_chat_service, network_session, spawn_service, player,
|
|
fishing_spot, settings_manager, world_time, world_weather
|
|
)
|
|
_title_settings_panel.setup_network_profile(
|
|
network_profile, network_session
|
|
)
|
|
_pause_settings_panel.setup_network_profile(
|
|
network_profile, network_session
|
|
)
|
|
fishing_spot.status_changed.connect(_on_fishing_status_changed)
|
|
fishing_spot.catch_display_changed.connect(_on_catch_display_changed)
|
|
fishing_spot.showcase_changed.connect(_on_showcase_changed)
|
|
fishing_spot.art_ui_toggle_requested.connect(_toggle_surface_drawing)
|
|
_player_menu.menu_visibility_changed.connect(
|
|
_on_player_menu_visibility_changed
|
|
)
|
|
_player_menu.menu_exit_started.connect(_on_player_menu_exit_started)
|
|
_player_menu.inventory_hotbar_context_changed.connect(
|
|
_on_inventory_hotbar_context_changed
|
|
)
|
|
_player_menu.shop_cooler_modal_changed.connect(
|
|
_on_shop_cooler_modal_changed
|
|
)
|
|
_player_menu.setup(
|
|
player,
|
|
inventory,
|
|
collection_log,
|
|
experience,
|
|
wallet,
|
|
sale_service,
|
|
default_buyer,
|
|
catalog,
|
|
fishing_spot,
|
|
bag,
|
|
hotbar,
|
|
item_catalog,
|
|
cooler_capacity,
|
|
network_session,
|
|
network_sale_service,
|
|
network_mail_service,
|
|
reservations,
|
|
network_profile_service,
|
|
network_player_list,
|
|
player_jobs,
|
|
world_time,
|
|
)
|
|
_hotbar_ui.setup(hotbar, bag, item_catalog, fishing_spot, inventory)
|
|
_fishing_shop.setup(
|
|
player,
|
|
wallet,
|
|
main_shop_buyer,
|
|
fishing_upgrades,
|
|
fishing_spot,
|
|
shop_interaction,
|
|
bag,
|
|
item_catalog,
|
|
cooler_capacity,
|
|
art_unlocks,
|
|
network_shop_service,
|
|
)
|
|
_fishing_shop.menu_visibility_changed.connect(_on_shop_visibility_changed)
|
|
_fishing_shop.sell_fish_requested.connect(_on_shop_sell_fish_requested)
|
|
_fishing_shop.shop_cooler_return_requested.connect(
|
|
_on_shop_cooler_return_requested
|
|
)
|
|
_fishing_shop.shop_cooler_confirmation_cancel_requested.connect(
|
|
_player_menu.cancel_shop_cooler_confirmation
|
|
)
|
|
_main_shop_buyer = main_shop_buyer
|
|
_shop_interaction = shop_interaction
|
|
_surface_drawing = surface_drawing
|
|
_surface_drawing_toolbar.setup(_surface_drawing, art_unlocks)
|
|
set_edge_docks(
|
|
settings_manager.current_settings.chat_dock_right,
|
|
settings_manager.current_settings.paint_dock_right,
|
|
)
|
|
|
|
|
|
func _input(event: InputEvent) -> void:
|
|
if (
|
|
_virtual_mouse_active
|
|
and _injecting_virtual_mouse_event
|
|
and event is InputEventMouseMotion
|
|
):
|
|
_update_virtual_cursor_position(
|
|
(event as InputEventMouseMotion).position
|
|
)
|
|
if _handle_virtual_mouse_input(event):
|
|
get_viewport().set_input_as_handled()
|
|
return
|
|
if (
|
|
_surface_drawing_toolbar != null
|
|
and _surface_drawing_toolbar.owns_pointer_event(event)
|
|
):
|
|
return
|
|
var drawing_can_open: bool = (
|
|
_gameplay_ui_enabled
|
|
and not _system_menu_open
|
|
and not _player_menu_open
|
|
and not _shop_open
|
|
and not _chat_input_open
|
|
and not _showcase_active
|
|
and _fishing_spot != null
|
|
and _fishing_spot.can_use_surface_drawing()
|
|
)
|
|
if (
|
|
_surface_drawing != null
|
|
and _surface_drawing.handle_input(event, drawing_can_open)
|
|
):
|
|
get_viewport().set_input_as_handled()
|
|
return
|
|
if _emote_radial_menu == null or _quick_radial_menu == null:
|
|
return
|
|
var can_open: bool = (
|
|
_gameplay_ui_enabled
|
|
and not _system_menu_open
|
|
and not _player_menu_open
|
|
and not _shop_open
|
|
and not _chat_input_open
|
|
and not _showcase_active
|
|
and not _virtual_mouse_active
|
|
)
|
|
var emote_was_open: bool = _emote_radial_menu.is_open()
|
|
if _emote_radial_menu.handle_input(
|
|
event,
|
|
can_open and not _quick_radial_menu.is_open(),
|
|
):
|
|
var emote_is_open: bool = _emote_radial_menu.is_open()
|
|
if emote_is_open != emote_was_open and _player != null:
|
|
if emote_is_open:
|
|
_emote_prior_camera_input_enabled = (
|
|
_player.is_camera_input_enabled()
|
|
)
|
|
_player.set_camera_input_enabled(false)
|
|
else:
|
|
_player.set_camera_input_enabled(
|
|
_emote_prior_camera_input_enabled
|
|
)
|
|
get_viewport().set_input_as_handled()
|
|
return
|
|
var quick_was_open: bool = _quick_radial_menu.is_open()
|
|
if _quick_radial_menu.handle_input(
|
|
event,
|
|
can_open and not _emote_radial_menu.is_open(),
|
|
):
|
|
var quick_is_open: bool = _quick_radial_menu.is_open()
|
|
if quick_is_open != quick_was_open and _player != null:
|
|
if quick_is_open:
|
|
_quick_prior_camera_input_enabled = (
|
|
_player.is_camera_input_enabled()
|
|
)
|
|
_player.set_camera_input_enabled(false)
|
|
else:
|
|
_player.set_camera_input_enabled(
|
|
_quick_prior_camera_input_enabled
|
|
)
|
|
get_viewport().set_input_as_handled()
|
|
|
|
|
|
func _on_emote_selected(emote_id: StringName) -> void:
|
|
if emote_id == &"sit" and _player != null:
|
|
_player.toggle_sitting()
|
|
|
|
|
|
func _on_quick_action_selected(action_id: StringName) -> void:
|
|
match action_id:
|
|
&"stuff":
|
|
_player_menu.open_section(PlayerMenuType.Section.COOLER)
|
|
&"logbook":
|
|
_player_menu.open_section(PlayerMenuType.Section.LOGBOOK)
|
|
&"fishnet":
|
|
_player_menu.open_section(PlayerMenuType.Section.NET)
|
|
&"mail":
|
|
_player_menu.open_section(PlayerMenuType.Section.MAIL)
|
|
&"profile":
|
|
_player_menu.open_section(PlayerMenuType.Section.PROFILE)
|
|
&"online":
|
|
_player_menu.open_section(PlayerMenuType.Section.PLAYERS)
|
|
&"paint":
|
|
_toggle_surface_drawing()
|
|
&"chat":
|
|
_chat_ui.open_chat()
|
|
|
|
|
|
func _handle_virtual_mouse_input(event: InputEvent) -> bool:
|
|
var motion_event: InputEventJoypadMotion = event as InputEventJoypadMotion
|
|
if motion_event != null:
|
|
if motion_event.axis == JOY_AXIS_TRIGGER_LEFT:
|
|
var was_active: bool = _virtual_mouse_active
|
|
if motion_event.axis_value >= VIRTUAL_MOUSE_TRIGGER_THRESHOLD:
|
|
if not _virtual_mouse_active and _can_start_virtual_mouse():
|
|
_begin_virtual_mouse()
|
|
elif _virtual_mouse_active:
|
|
_end_virtual_mouse()
|
|
return was_active or _virtual_mouse_active
|
|
if (
|
|
_virtual_mouse_active
|
|
and motion_event.axis == JOY_AXIS_TRIGGER_RIGHT
|
|
):
|
|
_set_virtual_mouse_button(
|
|
MOUSE_BUTTON_RIGHT,
|
|
motion_event.axis_value >= VIRTUAL_MOUSE_TRIGGER_THRESHOLD,
|
|
)
|
|
return true
|
|
var button_event: InputEventJoypadButton = event as InputEventJoypadButton
|
|
if (
|
|
button_event != null
|
|
and button_event.button_index == JOY_BUTTON_RIGHT_SHOULDER
|
|
and (
|
|
_virtual_mouse_active
|
|
or Input.get_joy_axis(0, JOY_AXIS_TRIGGER_LEFT)
|
|
>= VIRTUAL_MOUSE_TRIGGER_THRESHOLD
|
|
)
|
|
):
|
|
if not _virtual_mouse_active and _can_start_virtual_mouse():
|
|
_begin_virtual_mouse()
|
|
if _virtual_mouse_active:
|
|
_set_virtual_mouse_button(MOUSE_BUTTON_LEFT, button_event.pressed)
|
|
return true
|
|
return false
|
|
|
|
|
|
func _can_start_virtual_mouse() -> bool:
|
|
return (
|
|
_gameplay_ui_enabled
|
|
and not _showcase_active
|
|
and _player != null
|
|
and _fishing_spot != null
|
|
and _fishing_spot.can_use_surface_drawing()
|
|
and not _emote_radial_menu.is_open()
|
|
and not _quick_radial_menu.is_open()
|
|
)
|
|
|
|
|
|
func _begin_virtual_mouse() -> void:
|
|
if _virtual_mouse_active:
|
|
return
|
|
_virtual_mouse_active = true
|
|
_virtual_mouse_prior_camera_input_enabled = (
|
|
_player.is_camera_input_enabled()
|
|
)
|
|
_player.set_camera_input_enabled(false)
|
|
if _fishing_spot != null:
|
|
_fishing_spot.set_local_menu_input_suppressed(
|
|
VIRTUAL_MOUSE_INPUT_OWNER,
|
|
true,
|
|
)
|
|
_virtual_mouse_prior_mouse_mode = Input.mouse_mode
|
|
Input.mouse_mode = Input.MOUSE_MODE_HIDDEN
|
|
_virtual_mouse_button_mask = 0
|
|
_virtual_mouse_right_pressed = false
|
|
_virtual_mouse_window_position = Vector2(get_window().size) * 0.5
|
|
_controller_virtual_cursor.visible = true
|
|
_emit_virtual_mouse_motion(Vector2.ZERO)
|
|
|
|
|
|
func _end_virtual_mouse() -> void:
|
|
if not _virtual_mouse_active:
|
|
return
|
|
if (_virtual_mouse_button_mask & MOUSE_BUTTON_MASK_LEFT) != 0:
|
|
_set_virtual_mouse_button(MOUSE_BUTTON_LEFT, false)
|
|
if _virtual_mouse_right_pressed:
|
|
_set_virtual_mouse_button(MOUSE_BUTTON_RIGHT, false)
|
|
_virtual_mouse_active = false
|
|
_controller_virtual_cursor.visible = false
|
|
if _fishing_spot != null:
|
|
_fishing_spot.set_local_menu_input_suppressed(
|
|
VIRTUAL_MOUSE_INPUT_OWNER,
|
|
false,
|
|
)
|
|
if _player != null and is_instance_valid(_player):
|
|
_player.set_camera_input_enabled(
|
|
_virtual_mouse_prior_camera_input_enabled
|
|
)
|
|
Input.mouse_mode = _virtual_mouse_prior_mouse_mode
|
|
|
|
|
|
func _update_virtual_mouse(delta: float) -> void:
|
|
if not _virtual_mouse_active:
|
|
return
|
|
if (
|
|
Input.get_joy_axis(0, JOY_AXIS_TRIGGER_LEFT)
|
|
< VIRTUAL_MOUSE_TRIGGER_THRESHOLD
|
|
):
|
|
_end_virtual_mouse()
|
|
return
|
|
var stick: Vector2 = Vector2(
|
|
Input.get_joy_axis(0, JOY_AXIS_RIGHT_X),
|
|
Input.get_joy_axis(0, JOY_AXIS_RIGHT_Y),
|
|
)
|
|
var stick_length: float = stick.length()
|
|
if stick_length <= VIRTUAL_MOUSE_STICK_DEADZONE:
|
|
return
|
|
var adjusted_strength: float = (
|
|
(stick_length - VIRTUAL_MOUSE_STICK_DEADZONE)
|
|
/ (1.0 - VIRTUAL_MOUSE_STICK_DEADZONE)
|
|
)
|
|
var display_scale: float = UIReferencePresentationType.get_scale(
|
|
Vector2(get_window().size)
|
|
)
|
|
var relative_motion: Vector2 = (
|
|
stick.normalized()
|
|
* adjusted_strength
|
|
* VIRTUAL_MOUSE_SPEED
|
|
* display_scale
|
|
* delta
|
|
)
|
|
var window_size: Vector2 = Vector2(get_window().size)
|
|
_virtual_mouse_window_position = Vector2(
|
|
clampf(
|
|
_virtual_mouse_window_position.x + relative_motion.x,
|
|
0.0,
|
|
window_size.x,
|
|
),
|
|
clampf(
|
|
_virtual_mouse_window_position.y + relative_motion.y,
|
|
0.0,
|
|
window_size.y,
|
|
),
|
|
)
|
|
_emit_virtual_mouse_motion(relative_motion)
|
|
|
|
|
|
func _set_virtual_mouse_button(button: MouseButton, pressed: bool) -> void:
|
|
var mask: int = (
|
|
MOUSE_BUTTON_MASK_LEFT
|
|
if button == MOUSE_BUTTON_LEFT
|
|
else MOUSE_BUTTON_MASK_RIGHT
|
|
)
|
|
var already_pressed: bool = bool(_virtual_mouse_button_mask & mask)
|
|
if already_pressed == pressed:
|
|
return
|
|
if pressed:
|
|
_virtual_mouse_button_mask |= mask
|
|
else:
|
|
_virtual_mouse_button_mask &= ~mask
|
|
if button == MOUSE_BUTTON_RIGHT:
|
|
_virtual_mouse_right_pressed = pressed
|
|
var mouse_event := InputEventMouseButton.new()
|
|
mouse_event.position = _virtual_mouse_window_position
|
|
mouse_event.global_position = _virtual_mouse_window_position
|
|
mouse_event.button_index = button
|
|
mouse_event.button_mask = _virtual_mouse_button_mask
|
|
mouse_event.pressed = pressed
|
|
mouse_event.factor = 1.0
|
|
_parse_virtual_mouse_event(mouse_event)
|
|
|
|
|
|
func _emit_virtual_mouse_motion(relative_motion: Vector2) -> void:
|
|
var motion_event := InputEventMouseMotion.new()
|
|
motion_event.position = _virtual_mouse_window_position
|
|
motion_event.global_position = _virtual_mouse_window_position
|
|
motion_event.relative = relative_motion
|
|
motion_event.button_mask = _virtual_mouse_button_mask
|
|
_parse_virtual_mouse_event(motion_event)
|
|
|
|
|
|
func _parse_virtual_mouse_event(event: InputEventMouse) -> void:
|
|
_injecting_virtual_mouse_event = true
|
|
Input.parse_input_event(event)
|
|
_injecting_virtual_mouse_event = false
|
|
|
|
|
|
func _update_virtual_cursor_position(viewport_position: Vector2) -> void:
|
|
var root_transform: Transform2D = _ui_root.get_global_transform_with_canvas()
|
|
_controller_virtual_cursor.set_pointer_position(
|
|
root_transform.affine_inverse() * viewport_position
|
|
)
|
|
|
|
|
|
func _toggle_surface_drawing() -> void:
|
|
if _surface_drawing == null:
|
|
return
|
|
if _surface_drawing.is_active():
|
|
_surface_drawing.deactivate()
|
|
elif _surface_drawing.can_activate():
|
|
_surface_drawing.activate()
|
|
|
|
|
|
func setup_data_and_identity(
|
|
data_root: PlayerDataRoot,
|
|
identity_backups: IdentityBackupService,
|
|
player_identity: PlayerIdentityStore,
|
|
host_identity: HostIdentityStore,
|
|
network_session: NetworkSession,
|
|
interface_fonts: InterfaceFontController,
|
|
) -> void:
|
|
for panel: SettingsPanelType in [
|
|
_title_settings_panel, _pause_settings_panel
|
|
]:
|
|
panel.setup_data_and_identity(
|
|
data_root,
|
|
identity_backups,
|
|
player_identity,
|
|
host_identity,
|
|
network_session,
|
|
interface_fonts,
|
|
)
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
_update_virtual_mouse(delta)
|
|
_update_experience_bubble_position()
|
|
if _item_effects == null or not _gameplay_ui_enabled:
|
|
_effect_status.hide()
|
|
return
|
|
var parts: Array[String] = []
|
|
for item_id: StringName in [
|
|
PlayerItemEffectsType.COFFEE_ID,
|
|
PlayerItemEffectsType.ENERGY_DRINK_ID,
|
|
PlayerItemEffectsType.SNACK_ID,
|
|
PlayerItemEffectsType.FISH_FINDER_ID,
|
|
]:
|
|
var remaining: float = _item_effects.get_remaining(item_id)
|
|
if remaining <= 0.0:
|
|
continue
|
|
var label: String = {
|
|
PlayerItemEffectsType.COFFEE_ID: "coffee",
|
|
PlayerItemEffectsType.ENERGY_DRINK_ID: "energy",
|
|
PlayerItemEffectsType.SNACK_ID: "snack",
|
|
PlayerItemEffectsType.FISH_FINDER_ID: "finder",
|
|
}.get(item_id, "")
|
|
parts.append(
|
|
"%s %d:%02d"
|
|
% [label, floori(remaining / 60.0), int(remaining) % 60]
|
|
)
|
|
_effect_status.text = " ".join(parts)
|
|
_effect_status.visible = not parts.is_empty()
|
|
|
|
|
|
func close_player_menu() -> void:
|
|
_player_menu.close_menu()
|
|
|
|
|
|
func close_player_menu_for_water_recovery() -> void:
|
|
_player_menu.close_for_water_recovery()
|
|
|
|
|
|
func close_player_menu_for_game_menu() -> void:
|
|
_player_menu.close_for_game_menu()
|
|
|
|
|
|
func close_player_menu_for_session_end() -> void:
|
|
_player_menu.close_for_session_end()
|
|
|
|
|
|
func consume_player_menu_escape() -> bool:
|
|
return _player_menu.consume_escape()
|
|
|
|
|
|
func get_pause_menu() -> PauseMenuType:
|
|
return _pause_menu
|
|
|
|
|
|
func set_gameplay_ui_enabled(enabled: bool) -> void:
|
|
_gameplay_ui_enabled = enabled
|
|
_gameplay_transient_hud.visible = enabled and not _player_menu_open
|
|
_experience_presentation.visible = enabled
|
|
_refresh_chat_availability()
|
|
if not enabled:
|
|
_end_virtual_mouse()
|
|
if _emote_radial_menu != null and _emote_radial_menu.is_open():
|
|
_emote_radial_menu.close_menu()
|
|
if _player != null:
|
|
_player.set_camera_input_enabled(
|
|
_emote_prior_camera_input_enabled
|
|
)
|
|
if _quick_radial_menu != null and _quick_radial_menu.is_open():
|
|
_quick_radial_menu.close_menu()
|
|
if _player != null:
|
|
_player.set_camera_input_enabled(
|
|
_quick_prior_camera_input_enabled
|
|
)
|
|
if _surface_drawing != null:
|
|
_surface_drawing.deactivate()
|
|
close_player_menu_for_session_end()
|
|
_fishing_shop.close_for_session_end()
|
|
_fishing_panel.visible = false
|
|
_shop_prompt.hide()
|
|
_hotbar_ui.set_presentation_visible(false, false)
|
|
_hotbar_ui.set_gameplay_input_enabled(false)
|
|
else:
|
|
_refresh_hotbar_visibility()
|
|
_hotbar_ui.set_gameplay_input_enabled(true)
|
|
_refresh_fishing_panel_visibility()
|
|
call_deferred("_start_next_experience_animation")
|
|
|
|
|
|
func set_system_menu_open(is_open: bool) -> void:
|
|
_system_menu_open = is_open
|
|
if is_open and _surface_drawing != null:
|
|
_surface_drawing.deactivate()
|
|
_refresh_chat_availability()
|
|
_refresh_hotbar_visibility()
|
|
_hotbar_ui.set_gameplay_input_enabled(
|
|
_gameplay_ui_enabled
|
|
and not is_open
|
|
and not _player_menu_open
|
|
and not _shop_open
|
|
)
|
|
_hotbar_ui.set_drag_enabled(_player_menu_open and not is_open)
|
|
if is_open:
|
|
_hotbar_ui.set_drag_enabled(false)
|
|
_shop_prompt.hide()
|
|
_emit_interactive_pointer_ui_changed()
|
|
|
|
|
|
func get_fishing_shop() -> FishingShopType:
|
|
return _fishing_shop
|
|
|
|
|
|
func set_shop_prompt_visible(is_visible: bool) -> void:
|
|
_shop_prompt.visible = (
|
|
is_visible
|
|
and _gameplay_ui_enabled
|
|
and not _system_menu_open
|
|
and not _player_menu_open
|
|
and not _shop_open
|
|
)
|
|
|
|
|
|
func get_screen_fade() -> ScreenFade:
|
|
return _screen_fade
|
|
|
|
|
|
func get_title_screen() -> TitleScreenType:
|
|
return _title_screen
|
|
|
|
|
|
func set_effective_ui_pixel_size(pixel_size: int) -> void:
|
|
_title_settings_panel.set_effective_ui_pixel_size(pixel_size)
|
|
_pause_settings_panel.set_effective_ui_pixel_size(pixel_size)
|
|
|
|
|
|
func set_edge_docks(chat_dock_right: bool, paint_dock_right: bool) -> void:
|
|
_chat_ui.set_dock_right(chat_dock_right)
|
|
_surface_drawing_toolbar.set_dock_right(paint_dock_right)
|
|
|
|
|
|
func focus_open_settings_back_button() -> void:
|
|
if _title_settings_panel.visible:
|
|
_title_settings_panel.focus_back_button()
|
|
elif _pause_settings_panel.visible:
|
|
_pause_settings_panel.focus_back_button()
|
|
|
|
|
|
func refresh_open_settings_panel() -> void:
|
|
_title_settings_panel.refresh_open_panel()
|
|
_pause_settings_panel.refresh_open_panel()
|
|
|
|
|
|
func _on_settings_visibility_changed(_is_visible: bool) -> void:
|
|
pixelation_settings_visibility_changed.emit(
|
|
_title_settings_panel.visible or _pause_settings_panel.visible
|
|
)
|
|
|
|
|
|
func _on_fishing_status_changed(status: String) -> void:
|
|
if _showcase_active:
|
|
return
|
|
if _fishing_spot != null and _fishing_spot.is_fighting():
|
|
return
|
|
var normalized_status: String = status.strip_edges().to_lower()
|
|
if normalized_status in [
|
|
"fishing cancelled.",
|
|
"fishing cancelled",
|
|
"fishing failed.",
|
|
"fishing failed",
|
|
"fishing attempt ended.",
|
|
"fishing attempt ended",
|
|
]:
|
|
_set_fishing_status("")
|
|
return
|
|
_set_fishing_status(status)
|
|
|
|
|
|
func _set_fishing_status(text: String) -> void:
|
|
var normalized_text: String = text.strip_edges()
|
|
_status_label.text = normalized_text
|
|
_status_label.visible = not normalized_text.is_empty()
|
|
_refresh_fishing_panel_visibility()
|
|
|
|
|
|
func _refresh_fishing_panel_visibility() -> void:
|
|
var has_content: bool = (
|
|
not _status_label.text.strip_edges().is_empty()
|
|
or not _showcase_details.text.strip_edges().is_empty()
|
|
)
|
|
_fishing_panel.visible = (
|
|
_gameplay_ui_enabled
|
|
and has_content
|
|
)
|
|
|
|
|
|
func _on_catch_display_changed(
|
|
progress: float,
|
|
chase_progress: float,
|
|
barrier_positions: PackedFloat32Array,
|
|
barrier_health: PackedInt32Array,
|
|
_barrier_max_health: PackedInt32Array,
|
|
active_barrier_index: int,
|
|
visible: bool,
|
|
) -> void:
|
|
var encounter_visible: bool = (
|
|
visible
|
|
and _fishing_spot != null
|
|
and _fishing_spot.is_fighting()
|
|
)
|
|
_hotbar_ui.set_item_name_suppressed(encounter_visible)
|
|
_green_catch_progress.value = progress * 100.0
|
|
_red_chase_progress.value = maxf(chase_progress, 0.0) * 100.0
|
|
_catch_track.visible = encounter_visible
|
|
_barrier_prompt_panel.visible = false
|
|
_barrier_prompt.visible = false
|
|
_barrier_health.visible = false
|
|
if not encounter_visible:
|
|
_barrier_health.visible = false
|
|
_barrier_prompt.visible = false
|
|
_clear_barrier_markers()
|
|
_barrier_health.text = ""
|
|
_refresh_fishing_panel_visibility()
|
|
return
|
|
_status_label.text = ""
|
|
_status_label.visible = false
|
|
|
|
_update_barrier_markers(
|
|
barrier_positions,
|
|
barrier_health,
|
|
active_barrier_index
|
|
)
|
|
if (
|
|
active_barrier_index >= 0
|
|
and active_barrier_index < barrier_health.size()
|
|
):
|
|
_barrier_prompt_panel.visible = true
|
|
_barrier_prompt.visible = true
|
|
_barrier_health.visible = true
|
|
_barrier_health.text = "%d" % barrier_health[active_barrier_index]
|
|
else:
|
|
_barrier_prompt.visible = false
|
|
_barrier_health.visible = false
|
|
_barrier_health.text = ""
|
|
_refresh_fishing_panel_visibility()
|
|
|
|
|
|
func _update_barrier_markers(
|
|
positions: PackedFloat32Array,
|
|
health: PackedInt32Array,
|
|
active_index: int,
|
|
) -> void:
|
|
_clear_barrier_markers()
|
|
for barrier_index: int in range(positions.size()):
|
|
var marker := ColorRect.new()
|
|
var defeated: bool = (
|
|
barrier_index < health.size()
|
|
and health[barrier_index] <= 0
|
|
)
|
|
marker.color = (
|
|
UIPalette.DISABLED
|
|
if defeated
|
|
else UIPalette.PRIMARY
|
|
)
|
|
if barrier_index == active_index:
|
|
marker.color = UIPalette.TEXT
|
|
marker.set_anchors_preset(Control.PRESET_TOP_LEFT)
|
|
marker.anchor_left = positions[barrier_index]
|
|
marker.anchor_right = positions[barrier_index]
|
|
marker.offset_left = -2.0
|
|
marker.offset_right = 2.0
|
|
marker.offset_top = 0.0
|
|
marker.offset_bottom = 18.0
|
|
marker.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
_barrier_markers.add_child(marker)
|
|
|
|
|
|
func _clear_barrier_markers() -> void:
|
|
for marker: Node in _barrier_markers.get_children():
|
|
marker.queue_free()
|
|
|
|
|
|
func _on_showcase_changed(
|
|
fish_name: String,
|
|
rarity_name: String,
|
|
weight_lb: float,
|
|
quality: int,
|
|
visible: bool,
|
|
) -> void:
|
|
_showcase_active = visible
|
|
if not visible:
|
|
_showcase_details.text = ""
|
|
_showcase_details.visible = false
|
|
_set_fishing_status("")
|
|
call_deferred("_start_next_experience_animation")
|
|
return
|
|
_catch_track.visible = false
|
|
_barrier_prompt_panel.visible = false
|
|
_barrier_prompt.visible = false
|
|
_barrier_health.visible = false
|
|
_clear_barrier_markers()
|
|
_showcase_details.text = (
|
|
"%s • %.1f lb"
|
|
% [rarity_name.to_lower(), weight_lb]
|
|
)
|
|
_showcase_details.visible = true
|
|
_status_label.text = "You caught %s!" % (
|
|
FishQualityType.qualified_name_with_article(fish_name, quality)
|
|
)
|
|
_status_label.visible = true
|
|
_refresh_fishing_panel_visibility()
|
|
|
|
|
|
func _on_experience_awarded(
|
|
amount: int,
|
|
previous_total: int,
|
|
new_total: int,
|
|
previous_level: int,
|
|
new_level: int,
|
|
) -> void:
|
|
if amount <= 0:
|
|
return
|
|
_experience_award_queue.append({
|
|
"amount": amount,
|
|
"previous_total": previous_total,
|
|
"new_total": new_total,
|
|
"previous_level": previous_level,
|
|
"new_level": new_level,
|
|
})
|
|
_start_next_experience_animation()
|
|
|
|
|
|
func _start_next_experience_animation() -> void:
|
|
if (
|
|
_experience_animation_active
|
|
or _showcase_active
|
|
or _experience_award_queue.is_empty()
|
|
or not _gameplay_ui_enabled
|
|
):
|
|
return
|
|
var award: Dictionary = _experience_award_queue.pop_front()
|
|
_experience_animation_active = true
|
|
_experience_animation_generation += 1
|
|
var generation: int = _experience_animation_generation
|
|
_play_experience_animation(award, generation)
|
|
|
|
|
|
func _play_experience_animation(
|
|
award: Dictionary,
|
|
generation: int,
|
|
) -> void:
|
|
var amount: int = int(award.get("amount", 0))
|
|
var previous_total: int = int(award.get("previous_total", 0))
|
|
var new_total: int = int(award.get("new_total", previous_total))
|
|
_experience_award_label.text = "+%d xp" % amount
|
|
_experience_bubble_label.text = "+%d xp!" % amount
|
|
_update_experience_progress(previous_total)
|
|
_experience_panel.position.y = -_experience_panel.size.y - 8.0
|
|
_experience_panel.modulate.a = 0.0
|
|
_experience_panel.show()
|
|
_experience_bubble.modulate.a = 0.0
|
|
_experience_bubble.scale = Vector2(0.72, 0.72)
|
|
_experience_bubble.pivot_offset = _experience_bubble.size * 0.5
|
|
_experience_bubble.show()
|
|
|
|
var entry_tween: Tween = create_tween()
|
|
entry_tween.set_parallel(true)
|
|
entry_tween.tween_property(
|
|
_experience_panel,
|
|
"position:y",
|
|
_experience_panel_rest_y,
|
|
0.26,
|
|
).set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
|
|
entry_tween.tween_property(
|
|
_experience_panel,
|
|
"modulate:a",
|
|
1.0,
|
|
0.18,
|
|
)
|
|
entry_tween.tween_property(
|
|
_experience_bubble,
|
|
"modulate:a",
|
|
1.0,
|
|
0.15,
|
|
)
|
|
entry_tween.tween_property(
|
|
_experience_bubble,
|
|
"scale",
|
|
Vector2.ONE,
|
|
0.28,
|
|
).set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
|
|
await entry_tween.finished
|
|
if generation != _experience_animation_generation:
|
|
return
|
|
|
|
var fill_duration: float = clampf(
|
|
0.8 + float(amount) * 0.006,
|
|
0.9,
|
|
1.65,
|
|
)
|
|
var fill_tween: Tween = create_tween()
|
|
fill_tween.tween_method(
|
|
Callable(self, "_set_experience_animation_progress").bind(
|
|
previous_total,
|
|
new_total,
|
|
),
|
|
0.0,
|
|
1.0,
|
|
fill_duration,
|
|
).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_OUT)
|
|
await fill_tween.finished
|
|
if generation != _experience_animation_generation:
|
|
return
|
|
await get_tree().create_timer(0.75).timeout
|
|
if generation != _experience_animation_generation:
|
|
return
|
|
|
|
var exit_tween: Tween = create_tween()
|
|
exit_tween.set_parallel(true)
|
|
exit_tween.tween_property(
|
|
_experience_panel,
|
|
"modulate:a",
|
|
0.0,
|
|
0.24,
|
|
)
|
|
exit_tween.tween_property(
|
|
_experience_bubble,
|
|
"modulate:a",
|
|
0.0,
|
|
0.2,
|
|
)
|
|
exit_tween.tween_property(
|
|
_experience_bubble,
|
|
"scale",
|
|
Vector2(0.82, 0.82),
|
|
0.24,
|
|
).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
|
|
await exit_tween.finished
|
|
if generation != _experience_animation_generation:
|
|
return
|
|
_experience_panel.hide()
|
|
_experience_bubble.hide()
|
|
_experience_animation_active = false
|
|
call_deferred("_start_next_experience_animation")
|
|
|
|
|
|
func _set_experience_animation_progress(
|
|
progress: float,
|
|
previous_total: int,
|
|
new_total: int,
|
|
) -> void:
|
|
var displayed_total: int = roundi(lerpf(
|
|
float(previous_total),
|
|
float(new_total),
|
|
clampf(progress, 0.0, 1.0),
|
|
))
|
|
_update_experience_progress(displayed_total)
|
|
|
|
|
|
func _update_experience_progress(total_experience: int) -> void:
|
|
var level: int = PlayerExperienceType.level_for_total_experience(
|
|
total_experience
|
|
)
|
|
_experience_level_label.text = "level %d" % level
|
|
_experience_progress.value = (
|
|
PlayerExperienceType.progress_for_total_experience(total_experience)
|
|
* 100.0
|
|
)
|
|
|
|
|
|
func _update_experience_bubble_position() -> void:
|
|
if not _experience_animation_active or _player == null:
|
|
return
|
|
if _player_menu_open:
|
|
_experience_bubble.show()
|
|
_experience_bubble.position = Vector2(
|
|
(_canonical_stage.size.x - _experience_bubble.size.x) * 0.5,
|
|
_experience_panel_rest_y + _experience_panel.size.y + 10.0,
|
|
)
|
|
return
|
|
var camera: Camera3D = _player.get_gameplay_camera()
|
|
var anchor_position: Vector3 = _player.get_chat_anchor_position()
|
|
if camera == null or camera.is_position_behind(anchor_position):
|
|
_experience_bubble.hide()
|
|
return
|
|
_experience_bubble.show()
|
|
var window_size := Vector2(get_window().size)
|
|
var output_scale: float = UIReferencePresentationType.get_scale(
|
|
window_size
|
|
)
|
|
var stage_position: Vector2 = (
|
|
camera.unproject_position(anchor_position) / output_scale
|
|
- _canonical_stage.position
|
|
)
|
|
var desired: Vector2 = stage_position - Vector2(
|
|
_experience_bubble.size.x * 0.5,
|
|
_experience_bubble.size.y + 10.0,
|
|
)
|
|
_experience_bubble.position = Vector2(
|
|
clampf(
|
|
desired.x,
|
|
8.0,
|
|
_canonical_stage.size.x - _experience_bubble.size.x - 8.0,
|
|
),
|
|
clampf(
|
|
desired.y,
|
|
8.0,
|
|
_canonical_stage.size.y - _experience_bubble.size.y - 8.0,
|
|
),
|
|
)
|
|
|
|
|
|
func _on_player_menu_visibility_changed(is_open: bool) -> void:
|
|
_player_menu_open = is_open
|
|
if is_open and _surface_drawing != null:
|
|
_surface_drawing.deactivate()
|
|
_gameplay_transient_hud.visible = _gameplay_ui_enabled and not is_open
|
|
if is_open:
|
|
_hotbar_ui.set_drag_enabled(false)
|
|
_hotbar_ui.set_presentation_visible(false, false)
|
|
if _player_menu_hotbar_visible:
|
|
_hotbar_ui.set_player_menu_context(true)
|
|
_hotbar_ui.set_presentation_visible(
|
|
true,
|
|
true,
|
|
UIMotion.PLAYER_MENU_ENTER_DURATION,
|
|
)
|
|
player_menu_backdrop_visibility_changed.emit(true)
|
|
else:
|
|
_player_menu_hotbar_visible = false
|
|
_hotbar_ui.set_presentation_visible(false, false)
|
|
_hotbar_ui.set_player_menu_context(false)
|
|
_refresh_chat_availability()
|
|
_hotbar_ui.set_gameplay_input_enabled(
|
|
_gameplay_ui_enabled and not is_open
|
|
)
|
|
if not is_open:
|
|
_hotbar_ui.set_drag_enabled(false)
|
|
_refresh_hotbar_visibility()
|
|
_refresh_fishing_panel_visibility()
|
|
_emit_interactive_pointer_ui_changed()
|
|
if is_open:
|
|
_shop_prompt.hide()
|
|
else:
|
|
_refresh_fishing_panel_visibility()
|
|
|
|
|
|
func _on_player_menu_exit_started() -> void:
|
|
if not _player_menu_open:
|
|
return
|
|
_hotbar_ui.set_drag_enabled(false)
|
|
_hotbar_ui.set_presentation_visible(
|
|
false,
|
|
true,
|
|
UIMotion.PLAYER_MENU_EXIT_DURATION,
|
|
)
|
|
player_menu_backdrop_visibility_changed.emit(false)
|
|
|
|
|
|
func _on_shop_visibility_changed(is_open: bool) -> void:
|
|
_shop_open = is_open
|
|
if is_open and _surface_drawing != null:
|
|
_surface_drawing.deactivate()
|
|
shop_backdrop_visibility_changed.emit(is_open)
|
|
if not is_open and _player_menu.is_shop_cooler_mounted():
|
|
_player_menu.unmount_shop_cooler()
|
|
_refresh_chat_availability()
|
|
_refresh_hotbar_visibility()
|
|
_hotbar_ui.set_gameplay_input_enabled(
|
|
_gameplay_ui_enabled
|
|
and not is_open
|
|
and not _system_menu_open
|
|
and not _player_menu_open
|
|
)
|
|
if is_open:
|
|
_shop_prompt.hide()
|
|
_emit_interactive_pointer_ui_changed()
|
|
|
|
|
|
func _on_shop_sell_fish_requested() -> void:
|
|
if (
|
|
not _fishing_shop.visible
|
|
or _main_shop_buyer == null
|
|
or not _main_shop_buyer.is_valid()
|
|
or _shop_interaction == null
|
|
or not _shop_interaction.is_local_player_in_range()
|
|
or _fishing_spot == null
|
|
or not _fishing_spot.is_ready_for_shop_transaction()
|
|
):
|
|
return
|
|
if _player_menu.mount_shop_cooler(
|
|
_fishing_shop.get_shop_cooler_mount(),
|
|
_main_shop_buyer,
|
|
):
|
|
_fishing_shop.activate_shop_cooler_page()
|
|
|
|
|
|
func _on_shop_cooler_return_requested() -> void:
|
|
_player_menu.unmount_shop_cooler()
|
|
_fishing_shop.deactivate_shop_cooler_page()
|
|
|
|
|
|
func _on_shop_cooler_modal_changed(is_open: bool) -> void:
|
|
_fishing_shop.set_shop_cooler_modal_open(is_open)
|
|
|
|
|
|
func _on_inventory_hotbar_context_changed(show_hotbar: bool) -> void:
|
|
var context_changed: bool = _player_menu_hotbar_visible != show_hotbar
|
|
_player_menu_hotbar_visible = show_hotbar
|
|
if _player_menu_open and context_changed:
|
|
_hotbar_ui.set_drag_enabled(false)
|
|
if show_hotbar:
|
|
_hotbar_ui.set_presentation_visible(false, false)
|
|
_hotbar_ui.set_player_menu_context(true)
|
|
_hotbar_ui.set_presentation_visible(
|
|
true,
|
|
true,
|
|
UIMotion.PLAYER_MENU_INVENTORY_DURATION,
|
|
)
|
|
else:
|
|
_hotbar_ui.set_presentation_visible(
|
|
false,
|
|
true,
|
|
UIMotion.PLAYER_MENU_INVENTORY_DURATION,
|
|
)
|
|
elif _player_menu_open and show_hotbar:
|
|
_hotbar_ui.set_drag_enabled(true)
|
|
if not context_changed:
|
|
return
|
|
if not _player_menu_open:
|
|
_refresh_hotbar_visibility()
|
|
|
|
|
|
func _on_hotbar_presentation_transition_finished(
|
|
is_visible: bool,
|
|
) -> void:
|
|
_hotbar_ui.set_drag_enabled(
|
|
is_visible
|
|
and _player_menu_open
|
|
and _player_menu_hotbar_visible
|
|
and not _system_menu_open
|
|
)
|
|
|
|
|
|
func _refresh_hotbar_visibility() -> void:
|
|
_hotbar_ui.set_presentation_visible(
|
|
_gameplay_ui_enabled
|
|
and not _system_menu_open
|
|
and not _shop_open
|
|
and (
|
|
not _player_menu_open
|
|
or _player_menu_hotbar_visible
|
|
),
|
|
_player_menu_open,
|
|
)
|
|
|
|
|
|
func _emit_interactive_pointer_ui_changed() -> void:
|
|
interactive_pointer_ui_changed.emit(
|
|
_system_menu_open or _player_menu_open or _shop_open or _chat_input_open
|
|
)
|
|
|
|
|
|
func _on_chat_text_entry_ownership_changed(active: bool) -> void:
|
|
_chat_input_open = active
|
|
if active and _surface_drawing != null:
|
|
_surface_drawing.deactivate()
|
|
_emit_interactive_pointer_ui_changed()
|
|
|
|
|
|
func _refresh_chat_availability() -> void:
|
|
if _chat_ui == null:
|
|
return
|
|
var chat_available := (
|
|
_gameplay_ui_enabled
|
|
and not _system_menu_open
|
|
and not _player_menu_open
|
|
and not _shop_open
|
|
)
|
|
_chat_ui.set_available(chat_available)
|
|
passive_pointer_ui_changed.emit(chat_available)
|