using System.Linq;
using Content.Client.Administration.Managers;
using Content.Client.Administration.Systems;
+using Content.Client.UserInterface;
using Content.Shared.Administration;
using Content.Shared.IdentityManagement;
using Robust.Client.GameObjects;
namespace Content.Client.ContextMenu.UI
{
- public sealed partial class EntityMenuElement : ContextMenuElement
+ public sealed partial class EntityMenuElement : ContextMenuElement, IEntityControl
{
[Dependency] private readonly IClientAdminManager _adminManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
Text = GetEntityDescription(entity.Value);
}
}
+
+ EntityUid? IEntityControl.UiEntity => Entity;
}
}
-using System;
-using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using Content.Client.Clickable;
-using Content.Client.ContextMenu.UI;
+using Content.Client.UserInterface;
+using Content.Shared.Input;
using Robust.Client.ComponentTrees;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.Player;
using Robust.Client.State;
using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.CustomControls;
-using Robust.Shared.Containers;
+using Robust.Shared.Console;
using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
using Robust.Shared.Map;
+using Robust.Shared.Players;
using Robust.Shared.Timing;
namespace Content.Client.Gameplay
[Dependency] protected readonly IUserInterfaceManager UserInterfaceManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
[Dependency] private readonly IViewVariablesManager _vvm = default!;
+ [Dependency] private readonly IConsoleHost _conHost = default!;
private ClickableEntityComparer _comparer = default!;
- private (ViewVariablesPath? path, string[] segments) ResolveVVHoverObject(string path)
+ private (ViewVariablesPath? path, string[] segments) ResolveVvHoverObject(string path)
{
- // VVs the currently hovered entity. For a nifty vv keybinding you can use:
- //
- // /bind v command "vv /c/enthover"
- // /svbind
- //
- // Though you probably want to include a modifier like alt, as otherwise this would open VV even when typing
- // a message into chat containing the letter v.
-
var segments = path.Split('/');
+ var uid = RecursivelyFindUiEntity(UserInterfaceManager.CurrentlyHovered);
+ var netUid = _entityManager.GetNetEntity(uid);
+ return (netUid != null ? new ViewVariablesInstancePath(netUid) : null, segments);
+ }
- EntityUid? uid = null;
- if (UserInterfaceManager.CurrentlyHovered is IViewportControl vp && _inputManager.MouseScreenPosition.IsValid)
- uid = GetClickedEntity(vp.PixelToMap(_inputManager.MouseScreenPosition.Position));
- else if (UserInterfaceManager.CurrentlyHovered is EntityMenuElement element)
- uid = element.Entity;
+ private EntityUid? RecursivelyFindUiEntity(Control? control)
+ {
+ if (control == null)
+ return null;
- return (uid != null ? new ViewVariablesInstancePath(uid) : null, segments);
+ switch (control)
+ {
+ case IViewportControl vp:
+ if (_inputManager.MouseScreenPosition.IsValid)
+ return GetClickedEntity(vp.PixelToMap(_inputManager.MouseScreenPosition.Position));
+ return null;
+ case SpriteView sprite:
+ return sprite.Entity;
+ case IEntityControl ui:
+ return ui.UiEntity;
+ }
+
+ return RecursivelyFindUiEntity(control.Parent);
}
private IEnumerable<string>? ListVVHoverPaths(string[] segments)
protected override void Startup()
{
- _vvm.RegisterDomain("enthover", ResolveVVHoverObject, ListVVHoverPaths);
+ _vvm.RegisterDomain("enthover", ResolveVvHoverObject, ListVVHoverPaths);
_inputManager.KeyBindStateChanged += OnKeyBindStateChanged;
_comparer = new ClickableEntityComparer();
+ CommandBinds.Builder
+ .Bind(ContentKeyFunctions.InspectEntity, new PointerInputCmdHandler(HandleInspect, outsidePrediction: true))
+ .Register<GameplayStateBase>();
}
protected override void Shutdown()
{
_vvm.UnregisterDomain("enthover");
_inputManager.KeyBindStateChanged -= OnKeyBindStateChanged;
+ CommandBinds.Unregister<GameplayStateBase>();
+ }
+
+ private bool HandleInspect(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+ {
+ _conHost.ExecuteCommand($"vv /c/enthover");
+ return true;
}
public EntityUid? GetClickedEntity(MapCoordinates coordinates)
common.AddFunction(ContentKeyFunctions.ZoomOut);
common.AddFunction(ContentKeyFunctions.ZoomIn);
common.AddFunction(ContentKeyFunctions.ResetZoom);
+ common.AddFunction(ContentKeyFunctions.InspectEntity);
// Not in engine, because engine cannot check for sanbox/admin status before starting placement.
common.AddFunction(ContentKeyFunctions.EditorCopyObject);
AddButton(EngineKeyFunctions.ShowDebugConsole);
AddButton(EngineKeyFunctions.ShowDebugMonitors);
AddButton(EngineKeyFunctions.HideUI);
+ AddButton(ContentKeyFunctions.InspectEntity);
foreach (var control in _keyControls.Values)
{
}
}
-public sealed class ListContainerButton : ContainerButton
+public sealed class ListContainerButton : ContainerButton, IEntityControl
{
public readonly ListData Data;
// public PanelContainer Background;
// PanelOverride = new StyleBoxFlat {BackgroundColor = new Color(55, 55, 68)}
// });
}
+
+ public EntityUid? UiEntity => (Data as EntityListData)?.Uid;
}
#region Data
namespace Content.Client.UserInterface.Controls
{
[Virtual]
- public abstract class SlotControl : Control
+ public abstract class SlotControl : Control, IEntityControl
{
public static int DefaultButtonSize = 64;
public TextureButton StorageButton { get; }
public CooldownGraphic CooldownDisplay { get; }
- public EntityUid? Entity => SpriteView.Sprite?.Owner;
+ public EntityUid? Entity => SpriteView.Entity;
private bool _slotNameSet;
ButtonRect.Texture = Theme.ResolveTextureOrNull(_buttonTexturePath)?.Texture;
HighlightRect.Texture = Theme.ResolveTextureOrNull(_highlightTexturePath)?.Texture;
}
+
+ EntityUid? IEntityControl.UiEntity => Entity;
}
}
--- /dev/null
+namespace Content.Client.UserInterface;
+
+/// <summary>
+/// Simple interface that indicates that the given control is associated with some entity.
+/// This is primarily intended to be used with VV, so that you can easily open the VV window to examine an entity.
+/// </summary>
+public interface IEntityControl
+{
+ EntityUid? UiEntity { get; }
+}
namespace Content.Client.UserInterface.Systems.Actions.Controls;
-public sealed class ActionButton : Control
+public sealed class ActionButton : Control, IEntityControl
{
private IEntityManager? _entities;
private void UpdateItemIcon()
{
if (!Actions.TryGetActionData(ActionId, out var action) ||
- action is not { EntityIcon: { } entity } ||
+ action is not {EntityIcon: { } entity} ||
!Entities.HasComponent<SpriteComponent>(entity))
{
_bigItemSpriteView.Visible = false;
public void Depress(GUIBoundKeyEventArgs args, bool depress)
{
// action can still be toggled if it's allowed to stay selected
- if (!Actions.TryGetActionData(ActionId, out var action) || action is not { Enabled: true })
+ if (!Actions.TryGetActionData(ActionId, out var action) || action is not {Enabled: true})
return;
if (_depressed && !depress)
SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassNormal);
}
+
+ EntityUid? IEntityControl.UiEntity => ActionId;
}
public static readonly BoundKeyFunction Vote9 = "Vote9";
public static readonly BoundKeyFunction EditorCopyObject = "EditorCopyObject";
public static readonly BoundKeyFunction EditorFlipObject = "EditorFlipObject";
+ public static readonly BoundKeyFunction InspectEntity = "InspectEntity";
}
}
ui-options-function-open-abilities-menu = Open action menu
ui-options-function-show-debug-console = Open Console
ui-options-function-show-debug-monitors = Show Debug Monitors
+ui-options-function-inspect-entity = Inspect Entity
ui-options-function-hide-ui = Hide UI
ui-options-function-hotbar1 = Hotbar slot 1
- function: ShowDebugConsole
type: State
key: Tilde
+- function: InspectEntity
+ type: State
+ key: v
+ mod1: Alt
- function: MouseMiddle
type: State
key: MouseMiddle
projects / space-station-14.git / commitdiff