Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Merge branch 'master' into buckle-locker-fix-1262

Browse Source
This commit is contained in:
DrSmugleaf
2020-07-07 00:20:07 +02:00
parent abfe86be81 c78ce3e27a
commit b850ac2437
267 changed files with 3520 additions and 1075 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Content.Client/ClientPreferencesManager.cs
View File

@@ -26,6 +26,7 @@ namespace Content.Client
{
_netManager.RegisterNetMessage<MsgPreferencesAndSettings>(nameof(MsgPreferencesAndSettings),
HandlePreferencesAndSettings);
_netManager.RegisterNetMessage<MsgUpdateCharacter>(nameof(MsgUpdateCharacter));
}
public void SelectCharacter(ICharacterProfile profile)

5
Content.Client/EntryPoint.cs
View File

@@ -125,7 +125,10 @@ namespace Content.Client
/// </summary>
public static void DetachPlayerFromEntity(EntityDetachedEventArgs eventArgs)
{
eventArgs.OldEntity.RemoveComponent<CharacterInterface>();
if (!eventArgs.OldEntity.Deleted)
{
eventArgs.OldEntity.RemoveComponent<CharacterInterface>();
}
}
public override void PostInit()

1
Content.Client/EscapeMenuOwner.cs
View File

@@ -6,6 +6,7 @@ using Robust.Client.Interfaces.Placement;
using Robust.Client.Interfaces.ResourceManagement;
using Robust.Client.Interfaces.State;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.Interfaces.Configuration;
using Robust.Shared.Interfaces.Map;
using Robust.Shared.IoC;

4
Content.Client/GameObjects/Components/Items/ItemComponent.cs
View File

@@ -1,4 +1,6 @@
using Content.Shared.GameObjects;
using Content.Client.GameObjects.Components.Storage;
using Content.Client.Interfaces.GameObjects.Components.Interaction;
using Content.Shared.GameObjects;
using Content.Shared.GameObjects.Components.Items;
using Robust.Client.Graphics;
using Robust.Client.Interfaces.ResourceManagement;

19
Content.Client/GameObjects/Components/Mobs/BuckleComponent.cs
View File

@@ -1,16 +1,19 @@
using Content.Shared.GameObjects.Components.Mobs;
using Content.Client.GameObjects.Components.Strap;
using Content.Client.Interfaces.GameObjects.Components.Interaction;
using Content.Shared.GameObjects.Components.Mobs;
using Robust.Client.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.Maths;
namespace Content.Client.GameObjects.Components.Mobs
{
[RegisterComponent]
public class BuckleComponent : SharedBuckleComponent
public class BuckleComponent : SharedBuckleComponent, IClientDraggable
{
private bool _buckled;
private int? _originalDrawDepth;
protected override bool Buckled => _buckled;
public override void HandleComponentState(ComponentState curState, ComponentState nextState)
{
if (!(curState is BuckleComponentState buckle))
@@ -39,6 +42,14 @@ namespace Content.Client.GameObjects.Components.Mobs
}
}
protected override bool Buckled => _buckled;
bool IClientDraggable.ClientCanDropOn(CanDropEventArgs eventArgs)
{
return eventArgs.Target.HasComponent<StrapComponent>();
}
bool IClientDraggable.ClientCanDrag(CanDragEventArgs eventArgs)
{
return true;
}
}
}

2
Content.Client/GameObjects/Components/Mobs/BuckleVisualizer2D.cs
View File

@@ -17,7 +17,7 @@ namespace Content.Client.GameObjects.Components.Mobs
return;
}
if (!component.TryGetData<int>(SharedStrapComponent.StrapVisuals.RotationAngle, out var angle))
if (!component.TryGetData<int>(StrapVisuals.RotationAngle, out var angle))
{
return;
}

139
Content.Client/GameObjects/Components/Mobs/ClientOverlayEffectsComponent.cs
View File

@@ -1,18 +1,21 @@
using System.Collections.Generic;
using Content.Client.Graphics.Overlays;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Content.Shared.GameObjects.Components.Mobs;
using Content.Shared.Interfaces;
using Robust.Client.GameObjects;
using Robust.Client.Graphics.Overlays;
using Robust.Client.Interfaces.Graphics.Overlays;
using Robust.Client.Player;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Interfaces.Network;
using Robust.Shared.Interfaces.Reflection;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Players;
using Robust.Shared.Utility;
using Robust.Shared.ViewVariables;
namespace Content.Client.GameObjects
namespace Content.Client.GameObjects.Components.Mobs
{
/// <summary>
/// A character UI component which shows the current damage state of the mob (living/dead)
@@ -21,48 +24,33 @@ namespace Content.Client.GameObjects
[ComponentReference(typeof(SharedOverlayEffectsComponent))]
public sealed class ClientOverlayEffectsComponent : SharedOverlayEffectsComponent//, ICharacterUI
{
/// <summary>
/// An enum representing the current state being applied to the user
/// </summary>
private ScreenEffects _currentEffect = ScreenEffects.None;
private readonly List<OverlayContainer> _currentEffects = new List<OverlayContainer>();
[ViewVariables(VVAccess.ReadOnly)]
public List<OverlayContainer> ActiveOverlays
{
get => _currentEffects;
set => SetEffects(value);
}
#pragma warning disable 649
// Required dependencies
[Dependency] private readonly IOverlayManager _overlayManager;
[Dependency] private readonly IPlayerManager _playerManager;
[Dependency] private readonly IReflectionManager _reflectionManager;
#pragma warning restore 649
/// <summary>
/// Holds the screen effects that can be applied mapped ot their relevant overlay
/// </summary>
private Dictionary<ScreenEffects, Overlay> _effectsDictionary;
/// <summary>
/// Allows calculating if we need to act due to this component being controlled by the current mob
/// </summary>
private bool CurrentlyControlled => _playerManager.LocalPlayer.ControlledEntity == Owner;
public override void OnAdd()
{
base.OnAdd();
_effectsDictionary = new Dictionary<ScreenEffects, Overlay>()
{
{ ScreenEffects.CircleMask, new CircleMaskOverlay() },
{ ScreenEffects.GradientCircleMask, new GradientCircleMask() }
};
}
public override void HandleMessage(ComponentMessage message, IComponent component)
{
switch (message)
{
case PlayerAttachedMsg _:
SetOverlay(_currentEffect);
SetEffects(ActiveOverlays);
break;
case PlayerDetachedMsg _:
RemoveOverlay();
ActiveOverlays = new List<OverlayContainer>();
break;
}
}
@@ -70,42 +58,77 @@ namespace Content.Client.GameObjects
public override void HandleComponentState(ComponentState curState, ComponentState nextState)
{
base.HandleComponentState(curState, nextState);
if (!(curState is OverlayEffectComponentState state) || _currentEffect == state.ScreenEffect) return;
SetOverlay(state.ScreenEffect);
}
private void SetOverlay(ScreenEffects effect)
{
RemoveOverlay();
_currentEffect = effect;
ApplyOverlay();
}
private void RemoveOverlay()
{
if (CurrentlyControlled && _currentEffect != ScreenEffects.None)
if (!(curState is OverlayEffectComponentState state) || ActiveOverlays.Equals(state.Overlays))
{
var appliedEffect = _effectsDictionary[_currentEffect];
_overlayManager.RemoveOverlay(appliedEffect.ID);
return;
}
_currentEffect = ScreenEffects.None;
ActiveOverlays = state.Overlays;
}
private void ApplyOverlay()
private void SetEffects(List<OverlayContainer> newOverlays)
{
if (CurrentlyControlled && _currentEffect != ScreenEffects.None)
foreach (var container in ActiveOverlays.ShallowClone())
{
var overlay = _effectsDictionary[_currentEffect];
if (_overlayManager.HasOverlay(overlay.ID))
if (!newOverlays.Contains(container))
{
return;
RemoveOverlay(container);
}
_overlayManager.AddOverlay(overlay);
Logger.InfoS("overlay", $"Changed overlay to {overlay}");
}
foreach (var container in newOverlays)
{
if (!ActiveOverlays.Contains(container))
{
AddOverlay(container);
}
}
}
private void RemoveOverlay(OverlayContainer container)
{
ActiveOverlays.Remove(container);
_overlayManager.RemoveOverlay(container.ID);
}
private void AddOverlay(OverlayContainer container)
{
ActiveOverlays.Add(container);
if (TryCreateOverlay(container, out var overlay))
{
_overlayManager.AddOverlay(overlay);
}
else
{
Logger.ErrorS("overlay", $"Could not add overlay {container.ID}");
}
}
private bool TryCreateOverlay(OverlayContainer container, out Overlay overlay)
{
var overlayTypes = _reflectionManager.GetAllChildren<Overlay>();
var foundType = overlayTypes.FirstOrDefault(t => t.Name == container.ID);
if (foundType != null)
{
overlay = Activator.CreateInstance(foundType) as Overlay;
var configurable = foundType
.GetInterfaces()
.FirstOrDefault(type =>
type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IConfigurable<>)
&& type.GenericTypeArguments.First() == container.GetType());
if (configurable != null)
{
var method = overlay?.GetType().GetMethod("Configure");
method?.Invoke(overlay, new []{ container });
}
return true;
}
overlay = default;
return false;
}
}
}

11
Content.Client/GameObjects/Components/PlaceableSurfaceComponent.cs Normal file
View File

@@ -0,0 +1,11 @@
using Content.Shared.GameObjects.Components;
using Robust.Shared.GameObjects;
namespace Content.Client.GameObjects.Components
{
[RegisterComponent]
public class PlaceableSurfaceComponent : SharedPlaceableSurfaceComponent
{
}
}

15
Content.Client/GameObjects/Components/Storage/ClientStorageComponent.cs
View File

@@ -2,6 +2,7 @@
using System.Collections.Generic;
using Content.Shared.GameObjects.Components.Storage;
using Content.Client.Interfaces.GameObjects;
using Content.Client.Interfaces.GameObjects.Components.Interaction;
using Robust.Client.Graphics.Drawing;
using Robust.Client.Interfaces.GameObjects.Components;
using Robust.Client.UserInterface;
@@ -21,7 +22,7 @@ namespace Content.Client.GameObjects.Components.Storage
/// Client version of item storage containers, contains a UI which displays stored entities and their size
/// </summary>
[RegisterComponent]
public class ClientStorageComponent : SharedStorageComponent
public class ClientStorageComponent : SharedStorageComponent, IClientDraggable
{
private Dictionary<EntityUid, int> StoredEntities { get; set; } = new Dictionary<EntityUid, int>();
private int StorageSizeUsed;
@@ -316,5 +317,17 @@ namespace Content.Client.GameObjects.Components.Storage
AddChild(hBoxContainer);
}
}
public bool ClientCanDropOn(CanDropEventArgs eventArgs)
{
//can only drop on placeable surfaces to empty out contents
return eventArgs.Target.HasComponent<PlaceableSurfaceComponent>();
}
public bool ClientCanDrag(CanDragEventArgs eventArgs)
{
//always draggable, at least for now
return true;
}
}
}

22
Content.Client/GameObjects/Components/Strap/StrapComponent.cs Normal file
View File

@@ -0,0 +1,22 @@
#nullable enable
using Content.Shared.GameObjects.Components.Strap;
using Robust.Shared.GameObjects;
namespace Content.Client.GameObjects.Components.Strap
{
[RegisterComponent]
public class StrapComponent : SharedStrapComponent
{
public override StrapPosition Position { get; protected set; }
public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
{
if (!(curState is StrapComponentState strap))
{
return;
}
Position = strap.Position;
}
}
}

397
Content.Client/GameObjects/EntitySystems/DragDropSystem.cs Normal file
View File

@@ -0,0 +1,397 @@
using System.Collections.Generic;
using Content.Client.Interfaces.GameObjects.Components.Interaction;
using Content.Client.State;
using Content.Shared.GameObjects;
using Content.Shared.GameObjects.EntitySystemMessages;
using Content.Shared.GameObjects.EntitySystems;
using JetBrains.Annotations;
using Robust.Client.GameObjects;
using Robust.Client.GameObjects.EntitySystems;
using Robust.Client.Graphics.Shaders;
using Robust.Client.Interfaces.Graphics.ClientEye;
using Robust.Client.Interfaces.Input;
using Robust.Client.Interfaces.State;
using Robust.Shared.GameObjects.Systems;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Interfaces.Map;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Maths;
using Robust.Shared.Prototypes;
namespace Content.Client.GameObjects.EntitySystems
{
/// <summary>
/// Handles clientside drag and drop logic
/// </summary>
[UsedImplicitly]
public class DragDropSystem : EntitySystem
{
// drag will be triggered when mouse leaves this deadzone around the click position.
private const float DragDeadzone = 2f;
// how often to recheck possible targets (prevents calling expensive
// check logic each update)
private const float TargetRecheckInterval = 0.25f;
// if a drag ends up being cancelled and it has been under this
// amount of time since the mousedown, we will "replay" the original
// mousedown event so it can be treated like a regular click
private const float MaxMouseDownTimeForReplayingClick = 0.85f;
private const string ShaderDropTargetInRange = "SelectionOutlineInrange";
private const string ShaderDropTargetOutOfRange = "SelectionOutline";
#pragma warning disable 649
[Dependency] private readonly IStateManager _stateManager;
[Dependency] private readonly IEntityManager _entityManager;
[Dependency] private readonly IInputManager _inputManager;
[Dependency] private readonly IEyeManager _eyeManager;
[Dependency] private readonly IPrototypeManager _prototypeManager;
[Dependency] private readonly IMapManager _mapManager;
#pragma warning restore 649
// entity performing the drag action
private IEntity _dragger;
private IEntity _draggedEntity;
private IClientDraggable _draggable;
private IEntity _dragShadow;
private DragState _state;
// time since mouse down over the dragged entity
private float _mouseDownTime;
// screen pos where the mouse down began
private Vector2 _mouseDownScreenPos;
// how much time since last recheck of all possible targets
private float _targetRecheckTime;
// reserved initial mousedown event so we can replay it if no drag ends up being performed
private PointerInputCmdHandler.PointerInputCmdArgs? _savedMouseDown;
// whether we are currently replaying the original mouse down, so we
// can ignore any events sent to this system
private bool _isReplaying;
private ShaderInstance _dropTargetInRangeShader;
private ShaderInstance _dropTargetOutOfRangeShader;
private SharedInteractionSystem _interactionSystem;
private InputSystem _inputSystem;
private List<SpriteComponent> highlightedSprites = new List<SpriteComponent>();
private enum DragState
{
NotDragging,
// not dragging yet, waiting to see
// if they hold for long enough
MouseDown,
// currently dragging something
Dragging,
}
public override void Initialize()
{
_state = DragState.NotDragging;
_dropTargetInRangeShader = _prototypeManager.Index<ShaderPrototype>(ShaderDropTargetInRange).Instance();
_dropTargetOutOfRangeShader = _prototypeManager.Index<ShaderPrototype>(ShaderDropTargetOutOfRange).Instance();
_interactionSystem = EntitySystem.Get<SharedInteractionSystem>();
_inputSystem = EntitySystem.Get<InputSystem>();
// needs to fire on mouseup and mousedown so we can detect a drag / drop
CommandBinds.Builder
.Bind(EngineKeyFunctions.Use, new PointerInputCmdHandler(OnUse, false))
.Register<DragDropSystem>();
}
public override void Shutdown()
{
CancelDrag(false, null);
CommandBinds.Unregister<DragDropSystem>();
base.Shutdown();
}
private bool OnUse(in PointerInputCmdHandler.PointerInputCmdArgs args)
{
// not currently predicted
if (_inputSystem.Predicted) return false;
// currently replaying a saved click, don't handle this because
// we already decided this click doesn't represent an actual drag attempt
if (_isReplaying) return false;
if (args.State == BoundKeyState.Down)
{
return OnUseMouseDown(args);
}
else if (args.State == BoundKeyState.Up)
{
return OnUseMouseUp(args);
}
return false;
}
private bool OnUseMouseDown(in PointerInputCmdHandler.PointerInputCmdArgs args)
{
var dragger = args.Session.AttachedEntity;
// cancel any current dragging if there is one (shouldn't be because they would've had to have lifted
// the mouse, canceling the drag, but just being cautious)
CancelDrag(false, null);
// possibly initiating a drag
// check if the clicked entity is draggable
if (_entityManager.TryGetEntity(args.EntityUid, out var entity))
{
// check if the entity is reachable
if (_interactionSystem.InRangeUnobstructed(dragger.Transform.MapPosition,
entity.Transform.MapPosition, ignoredEnt: dragger) == false)
{
{
return false;
}
}
foreach (var draggable in entity.GetAllComponents<IClientDraggable>())
{
var dragEventArgs = new CanDragEventArgs(args.Session.AttachedEntity, entity);
if (draggable.ClientCanDrag(dragEventArgs))
{
// wait to initiate a drag
_dragger = dragger;
_draggedEntity = entity;
_draggable = draggable;
_mouseDownTime = 0;
_state = DragState.MouseDown;
_mouseDownScreenPos = _inputManager.MouseScreenPosition;
// don't want anything else to process the click,
// but we will save the event so we can "re-play" it if this drag does
// not turn into an actual drag so the click can be handled normally
_savedMouseDown = args;
return true;
}
}
}
return false;
}
private bool OnUseMouseUp(in PointerInputCmdHandler.PointerInputCmdArgs args)
{
if (_state == DragState.MouseDown)
{
// quick mouseup, definitely treat it as a normal click by
// replaying the original
CancelDrag(true, args.OriginalMessage);
return false;
}
if (_state != DragState.Dragging) return false;
// remaining CancelDrag calls will not replay the click because
// by this time we've determined the input was actually a drag attempt
// tell the server we are dropping if we are over a valid drop target in range.
// We don't use args.EntityUid here because drag interactions generally should
// work even if there's something "on top" of the drop target
if (_interactionSystem.InRangeUnobstructed(_dragger.Transform.MapPosition,
args.Coordinates.ToMap(_mapManager), ignoredEnt: _dragger) == false)
{
{
CancelDrag(false, null);
return false;
}
}
var entities = GameScreenBase.GetEntitiesUnderPosition(_stateManager, args.Coordinates);
foreach (var entity in entities)
{
// check if it's able to be dropped on by current dragged entity
if (_draggable.ClientCanDropOn(new CanDropEventArgs(_dragger, _draggedEntity, entity)))
{
// tell the server about the drop attempt
RaiseNetworkEvent(new DragDropMessage(args.Coordinates, _draggedEntity.Uid,
entity.Uid));
CancelDrag(false, null);
return true;
}
}
CancelDrag(false, null);
return false;
}
private void StartDragging()
{
// this is checked elsewhere but adding this as a failsafe
if (_draggedEntity == null || _draggedEntity.Deleted)
{
Logger.Error("Programming error. Cannot initiate drag, no dragged entity or entity" +
" was deleted.");
return;
}
if (_draggedEntity.TryGetComponent<SpriteComponent>(out var draggedSprite))
{
_state = DragState.Dragging;
// pop up drag shadow under mouse
var mousePos = _eyeManager.ScreenToMap(_inputManager.MouseScreenPosition);
_dragShadow = _entityManager.SpawnEntity("dragshadow", mousePos);
var dragSprite = _dragShadow.GetComponent<SpriteComponent>();
dragSprite.CopyFrom(draggedSprite);
dragSprite.RenderOrder = EntityManager.CurrentTick.Value;
dragSprite.Color = dragSprite.Color.WithAlpha(0.7f);
// keep it on top of everything
dragSprite.DrawDepth = (int) DrawDepth.Overlays;
HighlightTargets();
}
else
{
Logger.Warning("Unable to display drag shadow for {0} because it" +
" has no sprite component.", _draggedEntity.Name);
}
}
private void HighlightTargets()
{
if (_state != DragState.Dragging || _draggedEntity == null ||
_draggedEntity.Deleted || _dragShadow == null || _dragShadow.Deleted)
{
Logger.Warning("Programming error. Can't highlight drag and drop targets, not currently " +
"dragging anything or dragged entity / shadow was deleted.");
return;
}
// highlights the possible targets which are visible
// and able to be dropped on by the current dragged entity
// remove current highlights
RemoveHighlights();
// find possible targets on screen even if not reachable
// TODO: Duplicated in SpriteSystem
var pvsBounds = _eyeManager.GetWorldViewport().Enlarged(5);
var pvsEntities = EntityManager.GetEntitiesIntersecting(_eyeManager.CurrentMap, pvsBounds, true);
foreach (var pvsEntity in pvsEntities)
{
if (pvsEntity.TryGetComponent<SpriteComponent>(out var inRangeSprite))
{
// can't highlight if there's no sprite or it's not visible
if (inRangeSprite.Visible == false) continue;
// check if it's able to be dropped on by current dragged entity
if (_draggable.ClientCanDropOn(new CanDropEventArgs(_dragger, _draggedEntity, pvsEntity)))
{
// highlight depending on whether its in or out of range
var inRange = _interactionSystem.InRangeUnobstructed(_dragger.Transform.MapPosition,
pvsEntity.Transform.MapPosition, ignoredEnt: _dragger);
inRangeSprite.PostShader = inRange ? _dropTargetInRangeShader : _dropTargetOutOfRangeShader;
inRangeSprite.RenderOrder = EntityManager.CurrentTick.Value;
highlightedSprites.Add(inRangeSprite);
}
}
}
}
private void RemoveHighlights()
{
foreach (var highlightedSprite in highlightedSprites)
{
highlightedSprite.PostShader = null;
highlightedSprite.RenderOrder = 0;
}
highlightedSprites.Clear();
}
/// <summary>
/// Cancels the drag, firing our saved drag event if instructed to do so and
/// we are within the threshold for replaying the click
/// (essentially reverting the drag attempt and allowing the original click
/// to proceed as if no drag was performed)
/// </summary>
/// <param name="cause">if fireSavedCmd is true, this should be passed with the value of
/// the pointer cmd that caused the drag to be cancelled</param>
private void CancelDrag(bool fireSavedCmd, FullInputCmdMessage cause)
{
RemoveHighlights();
if (_dragShadow != null)
{
_entityManager.DeleteEntity(_dragShadow);
}
_dragShadow = null;
_draggedEntity = null;
_draggable = null;
_dragger = null;
_state = DragState.NotDragging;
_mouseDownTime = 0;
if (fireSavedCmd && _savedMouseDown.HasValue && _mouseDownTime < MaxMouseDownTimeForReplayingClick)
{
var savedValue = _savedMouseDown.Value;
_isReplaying = true;
// adjust the timing info based on the current tick so it appears as if it happened now
var replayMsg = savedValue.OriginalMessage;
var adjustedInputMsg = new FullInputCmdMessage(cause.Tick, cause.SubTick, replayMsg.InputFunctionId, replayMsg.State, replayMsg.Coordinates, replayMsg.ScreenCoordinates, replayMsg.Uid);
_inputSystem.HandleInputCommand(savedValue.Session, EngineKeyFunctions.Use,
adjustedInputMsg, true);
_isReplaying = false;
}
_savedMouseDown = null;
}
public override void Update(float frameTime)
{
base.Update(frameTime);
if (_state == DragState.MouseDown)
{
var screenPos = _inputManager.MouseScreenPosition;
if (_draggedEntity == null || _draggedEntity.Deleted)
{
// something happened to the clicked entity or we moved the mouse off the target so
// we shouldn't replay the original click
CancelDrag(false, null);
return;
}
else if ((_mouseDownScreenPos - screenPos).Length > DragDeadzone)
{
// initiate actual drag
StartDragging();
_mouseDownTime = 0;
}
}
else if (_state == DragState.Dragging)
{
if (_draggedEntity == null || _draggedEntity.Deleted)
{
CancelDrag(false, null);
return;
}
// still in range of the thing we are dragging?
if (_interactionSystem.InRangeUnobstructed(_dragger.Transform.MapPosition,
_draggedEntity.Transform.MapPosition, ignoredEnt: _dragger) == false)
{
CancelDrag(false, null);
return;
}
// keep dragged entity under mouse
var mousePos = _eyeManager.ScreenToMap(_inputManager.MouseScreenPosition);
// TODO: would use MapPosition instead if it had a setter, but it has no setter.
// is that intentional, or should we add a setter for Transform.MapPosition?
_dragShadow.Transform.WorldPosition = mousePos.Position;
_targetRecheckTime += frameTime;
if (_targetRecheckTime > TargetRecheckInterval)
{
HighlightTargets();
_targetRecheckTime = 0;
}
}
}
}
}

2
Content.Client/GameObjects/EntitySystems/MoverSystem.cs
View File

@@ -46,7 +46,7 @@ namespace Content.Client.GameObjects.EntitySystems
protected override void SetController(PhysicsComponent physics)
{
((PhysicsComponent)physics).SetController<MoverController>();
physics.SetController<MoverController>();
}
}
}

5
Content.Client/Graphics/Overlays/CircleMaskOverlay.cs
View File

@@ -1,4 +1,5 @@
using Robust.Client.Graphics.Drawing;
using Content.Shared.GameObjects.Components.Mobs;
using Robust.Client.Graphics.Drawing;
using Robust.Client.Graphics.Overlays;
using Robust.Client.Graphics.Shaders;
using Robust.Client.Interfaces.Graphics.ClientEye;
@@ -17,7 +18,7 @@ namespace Content.Client.Graphics.Overlays
public override OverlaySpace Space => OverlaySpace.WorldSpace;
public CircleMaskOverlay() : base(nameof(CircleMaskOverlay))
public CircleMaskOverlay() : base(nameof(OverlayType.CircleMaskOverlay))
{
IoCManager.InjectDependencies(this);
Shader = _prototypeManager.Index<ShaderPrototype>("CircleMask").Instance();

73
Content.Client/Graphics/Overlays/FlashOverlay.cs Normal file
View File

@@ -0,0 +1,73 @@
using System.Net.Mime;
using Content.Shared.GameObjects.Components.Mobs;
using Content.Shared.Interfaces;
using Robust.Client.Graphics;
using Robust.Client.Graphics.Drawing;
using Robust.Client.Graphics.Overlays;
using Robust.Client.Graphics.Shaders;
using Robust.Client.Interfaces.Graphics;
using Robust.Client.Interfaces.Graphics.ClientEye;
using Robust.Shared.Interfaces.Timing;
using Robust.Shared.IoC;
using Robust.Shared.Maths;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using Color = Robust.Shared.Maths.Color;
namespace Content.Client.Graphics.Overlays
{
public class FlashOverlay : Overlay, IConfigurable<TimedOverlayContainer>
{
#pragma warning disable 649
[Dependency] private readonly IPrototypeManager _prototypeManager;
[Dependency] private readonly IClyde _displayManager;
[Dependency] private readonly IGameTiming _gameTiming;
#pragma warning restore 649
public override OverlaySpace Space => OverlaySpace.ScreenSpace;
private double _startTime;
private int lastsFor = 5000;
private Texture _screenshotTexture;
public FlashOverlay() : base(nameof(OverlayType.FlashOverlay))
{
IoCManager.InjectDependencies(this);
Shader = _prototypeManager.Index<ShaderPrototype>("FlashedEffect").Instance().Duplicate();
_startTime = _gameTiming.CurTime.TotalMilliseconds;
_displayManager.Screenshot(ScreenshotType.BeforeUI, image =>
{
var rgba32Image = image.CloneAs<Rgba32>(Configuration.Default);
_screenshotTexture = _displayManager.LoadTextureFromImage(rgba32Image);
});
}
protected override void Draw(DrawingHandleBase handle)
{
var percentComplete = (float) ((_gameTiming.CurTime.TotalMilliseconds - _startTime) / lastsFor);
Shader?.SetParameter("percentComplete", percentComplete);
var screenSpaceHandle = handle as DrawingHandleScreen;
var screenSize = UIBox2.FromDimensions((0, 0), _displayManager.ScreenSize);
if (_screenshotTexture != null)
{
screenSpaceHandle?.DrawTextureRect(_screenshotTexture, screenSize);
}
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
_screenshotTexture = null;
}
public void Configure(TimedOverlayContainer parameters)
{
lastsFor = parameters.Length;
}
}
}

7
Content.Client/Graphics/Overlays/GradientCircleMask.cs
View File

@@ -1,4 +1,5 @@
using Robust.Client.Graphics.Drawing;
using Content.Shared.GameObjects.Components.Mobs;
using Robust.Client.Graphics.Drawing;
using Robust.Client.Graphics.Overlays;
using Robust.Client.Graphics.Shaders;
using Robust.Client.Interfaces.Graphics.ClientEye;
@@ -8,7 +9,7 @@ using Robust.Shared.Prototypes;
namespace Content.Client.Graphics.Overlays
{
public class GradientCircleMask : Overlay
public class GradientCircleMaskOverlay : Overlay
{
#pragma warning disable 649
[Dependency] private readonly IPrototypeManager _prototypeManager;
@@ -16,7 +17,7 @@ namespace Content.Client.Graphics.Overlays
#pragma warning restore 649
public override OverlaySpace Space => OverlaySpace.WorldSpace;
public GradientCircleMask() : base(nameof(GradientCircleMask))
public GradientCircleMaskOverlay() : base(nameof(OverlayType.GradientCircleMaskOverlay))
{
IoCManager.InjectDependencies(this);
Shader = _prototypeManager.Index<ShaderPrototype>("GradientCircleMask").Instance();

2
Content.Client/IgnoredComponents.cs
View File

@@ -25,7 +25,6 @@
"ItemTeleporter",
"Portal",
"EntityStorage",
"PlaceableSurface",
"Wirecutter",
"Screwdriver",
"Multitool",
@@ -116,7 +115,6 @@
"Utensil",
"UnarmedCombat",
"TimedSpawner",
"Strap",
"NodeContainer",
"PowerSupplier",
"PowerConsumer",

1
Content.Client/Input/ContentContexts.cs
View File

@@ -13,6 +13,7 @@ namespace Content.Client.Input
{
var common = contexts.GetContext("common");
common.AddFunction(ContentKeyFunctions.FocusChat);
common.AddFunction(ContentKeyFunctions.FocusOOC);
common.AddFunction(ContentKeyFunctions.ExamineEntity);
common.AddFunction(ContentKeyFunctions.OpenTutorial);
common.AddFunction(ContentKeyFunctions.TakeScreenshot);

59
Content.Client/Interfaces/GameObjects/Components/Interaction/IClientDraggable.cs Normal file
View File

@@ -0,0 +1,59 @@
using System;
using Robust.Shared.Interfaces.GameObjects;
namespace Content.Client.Interfaces.GameObjects.Components.Interaction
{
/// <summary>
/// This interface allows a local client to initiate dragging of the component's entity by mouse, for drag and
/// drop interactions. The actual logic of what happens on drop
/// is handled by IDragDrop
/// </summary>
public interface IClientDraggable
{
/// <summary>
/// Invoked on entities visible to the user to check if this component's entity
/// can be dropped on the indicated target entity. No need to check range / reachability in here.
/// </summary>
/// <returns>true iff target is a valid target to be dropped on by this
/// component's entity. Returning true will cause the target entity to be highlighted as a potential
/// target and allow dropping when in range.</returns>
bool ClientCanDropOn(CanDropEventArgs eventArgs);
/// <summary>
/// Invoked clientside when user is attempting to initiate a drag with this component's entity
/// in range. Return true if the drag should be initiated. It's fine to
/// return true even if there wouldn't be any valid targets - just return true
/// if this entity is in a "draggable" state.
/// </summary>
/// <param name="eventArgs"></param>
/// <returns>true iff drag should be initiated</returns>
bool ClientCanDrag(CanDragEventArgs eventArgs);
}
public class CanDropEventArgs : EventArgs
{
public CanDropEventArgs(IEntity user, IEntity dragged, IEntity target)
{
User = user;
Dragged = dragged;
Target = target;
}
public IEntity User { get; }
public IEntity Dragged { get; }
public IEntity Target { get; }
}
public class CanDragEventArgs : EventArgs
{
public CanDragEventArgs(IEntity user, IEntity dragged)
{
User = user;
Dragged = dragged;
}
public IEntity User { get; }
public IEntity Dragged { get; }
}
}

4
Content.Client/Sandbox/SandboxManager.cs
View File

@@ -8,6 +8,7 @@ using Robust.Client.Interfaces.ResourceManagement;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.CustomControls;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.Interfaces.Map;
using Robust.Shared.Interfaces.Network;
using Robust.Shared.IoC;
@@ -36,7 +37,7 @@ namespace Content.Client.Sandbox
private SandboxWindow _window;
private EntitySpawnWindow _spawnWindow;
private TileSpawnWindow _tilesSpawnWindow;
private bool _sandboxWindowToggled = false;
private bool _sandboxWindowToggled;
public void Initialize()
{
@@ -114,6 +115,7 @@ namespace Content.Client.Sandbox
{
_window = null;
_gameHud.SandboxButtonDown = false;
_sandboxWindowToggled = false;
}
private void OnRespawnButtonOnOnPressed(BaseButton.ButtonEventArgs args)

1
Content.Client/ScreenshotHook.cs
View File

@@ -5,6 +5,7 @@ using Content.Shared.Input;
using Robust.Client.Interfaces.Graphics;
using Robust.Client.Interfaces.Input;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.Interfaces.Resources;
using Robust.Shared.IoC;
using Robust.Shared.Log;

20
Content.Client/State/GameScreen.cs
View File

@@ -1,13 +1,19 @@
using System.Collections.Generic;
using System.Collections.Immutable;
using Content.Client.Chat;
using Content.Client.Interfaces.Chat;
using Content.Client.UserInterface;
using Content.Shared.Input;
using Robust.Client.Interfaces.Input;
using Robust.Client.Interfaces.State;
using Robust.Client.Interfaces.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Map;
using Robust.Shared.ViewVariables;
namespace Content.Client.State
@@ -41,6 +47,9 @@ namespace Content.Client.State
_inputManager.SetInputCommand(ContentKeyFunctions.FocusChat,
InputCmdHandler.FromDelegate(s => FocusChat(_gameChat)));
_inputManager.SetInputCommand(ContentKeyFunctions.FocusOOC,
InputCmdHandler.FromDelegate(s => FocusOOC(_gameChat)));
}
public override void Shutdown()
@@ -61,5 +70,16 @@ namespace Content.Client.State
chat.Input.IgnoreNext = true;
chat.Input.GrabKeyboardFocus();
}
internal static void FocusOOC(ChatBox chat)
{
if (chat == null || chat.UserInterfaceManager.KeyboardFocused != null)
{
return;
}
chat.Input.IgnoreNext = true;
chat.Input.GrabKeyboardFocus();
chat.Input.InsertAtCursor("[");
}
}
}

24
Content.Client/State/GameScreenBase.cs
View File

@@ -1,7 +1,7 @@
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Content.Client.GameObjects.Components;
using Content.Shared.GameObjects;
using Content.Shared.GameObjects.EntitySystems;
using Robust.Client.GameObjects.EntitySystems;
using Robust.Client.Interfaces.GameObjects;
@@ -9,6 +9,7 @@ using Robust.Client.Interfaces.GameObjects.Components;
using Robust.Client.Interfaces.Graphics.ClientEye;
using Robust.Client.Interfaces.Input;
using Robust.Client.Interfaces.UserInterface;
using Robust.Client.Interfaces.State;
using Robust.Client.Player;
using Robust.Shared.GameObjects;
using Robust.Shared.Input;
@@ -71,7 +72,7 @@ namespace Content.Client.State
.InRangeUnobstructed(playerPos, entityPos,
predicate: entity =>
entity == _playerManager.LocalPlayer.ControlledEntity || entity == entityToClick,
insideBlockerValid: true);
ignoreInsideBlocker: true);
}
InteractionOutlineComponent outline;
@@ -146,6 +147,25 @@ namespace Content.Client.State
return foundEntities.Select(a => a.clicked).ToList();
}
/// <summary>
/// Gets all entities intersecting the given position.
///
/// Static alternative to GetEntitiesUnderPosition to cut out
/// some of the boilerplate needed to get state manager and check the current state.
/// </summary>
/// <param name="stateManager">state manager to use to get the current game screen</param>
/// <param name="coordinates">coordinates to check</param>
/// <returns>the entities under the position, empty list if none found</returns>
public static IList<IEntity> GetEntitiesUnderPosition(IStateManager stateManager, GridCoordinates coordinates)
{
if (stateManager.CurrentState is GameScreenBase gameScreenBase)
{
return gameScreenBase.GetEntitiesUnderPosition(coordinates);
}
return ImmutableList<IEntity>.Empty;
}
internal class ClickableEntityComparer : IComparer<(IEntity clicked, int depth, uint renderOrder)>
{
public int Compare((IEntity clicked, int depth, uint renderOrder) x,

1
Content.Client/State/LobbyState.cs
View File

@@ -12,6 +12,7 @@ using Robust.Client.Interfaces.UserInterface;
using Robust.Client.Player;
using Robust.Client.UserInterface.Controls;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;

1
Content.Client/UserInterface/GameHud.cs
View File

@@ -9,6 +9,7 @@ using Robust.Client.Interfaces.ResourceManagement;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Maths;

97
Content.Client/UserInterface/HumanoidProfileEditor.cs
View File

@@ -1,4 +1,4 @@
using System;
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Client.GameObjects.Components;
@@ -6,6 +6,7 @@ using Content.Client.Interfaces;
using Content.Client.Utility;
using Content.Shared;
using Content.Shared.Jobs;
using Content.Shared.Antags;
using Content.Shared.Preferences;
using Robust.Client.Graphics.Drawing;
using Robust.Client.UserInterface;
@@ -42,6 +43,7 @@ namespace Content.Client.UserInterface
private readonly FacialHairStylePicker _facialHairPicker;
private readonly List<JobPrioritySelector> _jobPriorities;
private readonly OptionButton _preferenceUnavailableButton;
private readonly List<AntagPreferenceSelector> _antagPreferences;
private bool _isDirty;
public int CharacterSlot;
@@ -320,6 +322,52 @@ namespace Content.Client.UserInterface
#endregion
#region Antags
{
var antagList = new VBoxContainer();
var antagVBox = new VBoxContainer
{
Children =
{
new ScrollContainer
{
SizeFlagsVertical = SizeFlags.FillExpand,
Children =
{
antagList
}
}
}
};
tabContainer.AddChild(antagVBox);
tabContainer.SetTabTitle(2, Loc.GetString("Antags"));
_antagPreferences = new List<AntagPreferenceSelector>();
foreach (var antag in prototypeManager.EnumeratePrototypes<AntagPrototype>().OrderBy(a => a.Name))
{
if(!antag.SetPreference)
{
continue;
}
var selector = new AntagPreferenceSelector(antag);
antagList.AddChild(selector);
_antagPreferences.Add(selector);
selector.PreferenceChanged += preference =>
{
Profile = Profile.WithAntagPreference(antag.ID, preference);
IsDirty = true;
};
}
}
#endregion
var rightColumn = new VBoxContainer();
middleContainer.AddChild(rightColumn);
@@ -466,6 +514,7 @@ namespace Content.Client.UserInterface
UpdateHairPickers();
UpdateSaveButton();
UpdateJobPriorities();
UpdateAntagPreferences();
_preferenceUnavailableButton.SelectId((int) Profile.PreferenceUnavailable);
}
@@ -533,5 +582,51 @@ namespace Content.Client.UserInterface
});
}
}
private void UpdateAntagPreferences()
{
foreach (var preferenceSelector in _antagPreferences)
{
var antagId = preferenceSelector.Antag.ID;
var preference = Profile.AntagPreferences.Contains(antagId);
preferenceSelector.Preference = preference;
}
}
private class AntagPreferenceSelector : Control
{
public AntagPrototype Antag { get; }
private readonly CheckBox _checkBox;
public bool Preference
{
get => _checkBox.Pressed;
set => _checkBox.Pressed = value;
}
public event Action<bool> PreferenceChanged;
public AntagPreferenceSelector(AntagPrototype antag)
{
Antag = antag;
_checkBox = new CheckBox {Text = $"{antag.Name}"};
_checkBox.OnToggled += OnCheckBoxToggled;
AddChild(new HBoxContainer
{
Children =
{
_checkBox
}
});
}
private void OnCheckBoxToggled(BaseButton.ButtonToggledEventArgs args)
{
PreferenceChanged?.Invoke(Preference);
}
}
}
}

4
Content.Client/UserInterface/TutorialWindow.cs
View File

@@ -75,6 +75,7 @@ Open inventory: [color=#a4885c]{7}[/color]
Open character window: [color=#a4885c]{8}[/color]
Open crafting window: [color=#a4885c]{9}[/color]
Focus chat: [color=#a4885c]{10}[/color]
Focus OOC: [color=#a4885c]{26}[/color]
Use hand/object in hand: [color=#a4885c]{22}[/color]
Do wide attack: [color=#a4885c]{23}[/color]
Use targeted entity: [color=#a4885c]{11}[/color]
@@ -110,7 +111,8 @@ Toggle sandbox window: [color=#a4885c]{21}[/color]",
Key(Use),
Key(WideAttack),
Key(SmartEquipBackpack),
Key(SmartEquipBelt)));
Key(SmartEquipBelt),
Key(FocusOOC)));
//Gameplay
VBox.AddChild(new Label { FontOverride = headerFont, Text = "\nGameplay" });