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

Merge branch 'master' into 2020-04-28-tool-component

Browse Source
This commit is contained in:
zumorica
2020-05-11 12:24:43 +02:00
parent 2c4354c95a 63b0df5ba2
commit 6ae5e36a18
114 changed files with 3532 additions and 531 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
Content.Client/GameObjects/Components/Gravity/GravityGeneratorBoundUserInterface.cs Normal file
View File

@@ -0,0 +1,104 @@
using System;
using Content.Shared.GameObjects.Components.Gravity;
using Robust.Client.GameObjects.Components.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.CustomControls;
using Robust.Shared.GameObjects.Components.UserInterface;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Maths;
namespace Content.Client.GameObjects.Components.Gravity
{
public class GravityGeneratorBoundUserInterface: BoundUserInterface
{
private GravityGeneratorWindow _window;
public bool IsOn;
public GravityGeneratorBoundUserInterface(ClientUserInterfaceComponent owner, object uiKey) : base (owner, uiKey)
{
SendMessage(new SharedGravityGeneratorComponent.GeneratorStatusRequestMessage());
}
protected override void Open()
{
base.Open();
IsOn = false;
_window = new GravityGeneratorWindow(this);
_window.Switch.OnPressed += (args) =>
{
SendMessage(new SharedGravityGeneratorComponent.SwitchGeneratorMessage(!IsOn));
SendMessage(new SharedGravityGeneratorComponent.GeneratorStatusRequestMessage());
};
_window.OpenCentered();
}
protected override void UpdateState(BoundUserInterfaceState state)
{
base.UpdateState(state);
var castState = (SharedGravityGeneratorComponent.GeneratorState) state;
IsOn = castState.On;
_window.UpdateButton();
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing) return;
_window?.Dispose();
}
}
public class GravityGeneratorWindow : SS14Window
{
public Label Status;
public Button Switch;
public GravityGeneratorBoundUserInterface Owner;
public GravityGeneratorWindow(GravityGeneratorBoundUserInterface gravityGeneratorInterface = null)
{
IoCManager.InjectDependencies(this);
Owner = gravityGeneratorInterface;
Title = Loc.GetString("Gravity Generator Control");
var vBox = new VBoxContainer
{
CustomMinimumSize = new Vector2(250, 100)
};
Status = new Label
{
Text = Loc.GetString("Current Status: " + (Owner.IsOn ? "On" : "Off")),
FontColorOverride = Owner.IsOn ? Color.ForestGreen : Color.Red
};
Switch = new Button
{
Text = Loc.GetString(Owner.IsOn ? "Turn Off" : "Turn On"),
TextAlign = Label.AlignMode.Center,
CustomMinimumSize = new Vector2(150, 60)
};
vBox.AddChild(Status);
vBox.AddChild(Switch);
Contents.AddChild(vBox);
}
public void UpdateButton()
{
Status.Text = Loc.GetString("Current Status: " + (Owner.IsOn ? "On" : "Off"));
Status.FontColorOverride = Owner.IsOn ? Color.ForestGreen : Color.Red;
Switch.Text = Loc.GetString(Owner.IsOn ? "Turn Off" : "Turn On");
}
}
}

4
Content.Client/GameObjects/Components/HUD/Inventory/HumanInventoryInterfaceController.cs
View File

@@ -114,13 +114,13 @@ namespace Content.Client.GameObjects
}
}
protected override void HandleInventoryKeybind(BaseButton.ButtonEventArgs args, Slots slot)
protected override void HandleInventoryKeybind(GUIBoundKeyEventArgs args, Slots slot)
{
if (!_inventoryButtons.TryGetValue(slot, out var buttons))
return;
if (!Owner.TryGetSlot(slot, out var item))
return;
if (_itemSlotManager.OnButtonPressed(args.Event, item))
if (_itemSlotManager.OnButtonPressed(args, item))
return;
base.HandleInventoryKeybind(args, slot);

23
Content.Client/GameObjects/Components/HUD/Inventory/InventoryInterfaceController.cs
View File

@@ -2,8 +2,9 @@
using Content.Client.UserInterface;
using Content.Shared.GameObjects.Components.Inventory;
using Content.Shared.Input;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.CustomControls;
using Robust.Shared.Input;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
@@ -62,39 +63,35 @@ namespace Content.Client.GameObjects
{
}
protected virtual void HandleInventoryKeybind(BaseButton.ButtonEventArgs args, EquipmentSlotDefines.Slots slot)
protected virtual void HandleInventoryKeybind(GUIBoundKeyEventArgs args, EquipmentSlotDefines.Slots slot)
{
if (args.Event.CanFocus)
if (args.Function == EngineKeyFunctions.UIClick)
{
UseItemOnInventory(args, slot);
UseItemOnInventory(slot);
}
}
protected void AddToInventory(BaseButton.ButtonEventArgs args, EquipmentSlotDefines.Slots slot)
protected void AddToInventory(GUIBoundKeyEventArgs args, EquipmentSlotDefines.Slots slot)
{
if (!args.Event.CanFocus)
if (args.Function != EngineKeyFunctions.UIClick)
{
return;
}
args.Button.Pressed = false;
Owner.SendEquipMessage(slot);
}
protected void UseItemOnInventory(BaseButton.ButtonEventArgs args, EquipmentSlotDefines.Slots slot)
protected void UseItemOnInventory(EquipmentSlotDefines.Slots slot)
{
args.Button.Pressed = false;
Owner.SendUseMessage(slot);
}
protected void OpenStorage(BaseButton.ButtonEventArgs args, EquipmentSlotDefines.Slots slot)
protected void OpenStorage(GUIBoundKeyEventArgs args, EquipmentSlotDefines.Slots slot)
{
if (!args.Event.CanFocus && args.Event.Function != ContentKeyFunctions.ActivateItemInWorld)
if (args.Function != EngineKeyFunctions.UIClick && args.Function != ContentKeyFunctions.ActivateItemInWorld)
{
return;
}
args.Button.Pressed = false;
Owner.SendOpenStorageUIMessage(slot);
}

119
Content.Client/GameObjects/Components/Kitchen/MicrowaveBoundUserInterface.cs Normal file
View File

@@ -0,0 +1,119 @@
using Robust.Client.GameObjects.Components.UserInterface;
using Content.Shared.Kitchen;
using Robust.Shared.GameObjects.Components.UserInterface;
using Robust.Shared.IoC;
using Robust.Shared.Prototypes;
using Content.Shared.Chemistry;
using Robust.Shared.GameObjects;
using System.Collections.Generic;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Client.GameObjects;
using Robust.Client.UserInterface.Controls;
namespace Content.Client.GameObjects.Components.Kitchen
{
public class MicrowaveBoundUserInterface : BoundUserInterface
{
#pragma warning disable 649
[Dependency] private readonly IEntityManager _entityManager;
[Dependency] private readonly IPrototypeManager _prototypeManager;
#pragma warning restore 649
private MicrowaveMenu _menu;
private Dictionary<int, EntityUid> _solids = new Dictionary<int, EntityUid>();
private Dictionary<int, Solution.ReagentQuantity> _reagents =new Dictionary<int, Solution.ReagentQuantity>();
public MicrowaveBoundUserInterface(ClientUserInterfaceComponent owner, object uiKey) : base(owner,uiKey)
{
}
protected override void Open()
{
base.Open();
_menu = new MicrowaveMenu(this);
_menu.OpenCentered();
_menu.OnClose += Close;
_menu.StartButton.OnPressed += args => SendMessage(new SharedMicrowaveComponent.MicrowaveStartCookMessage());
_menu.EjectButton.OnPressed += args => SendMessage(new SharedMicrowaveComponent.MicrowaveEjectMessage());
_menu.IngredientsList.OnItemSelected += args =>
{
SendMessage(new SharedMicrowaveComponent.MicrowaveEjectSolidIndexedMessage(_solids[args.ItemIndex]));
};
_menu.IngredientsListReagents.OnItemSelected += args =>
{
SendMessage(
new SharedMicrowaveComponent.MicrowaveVaporizeReagentIndexedMessage(_reagents[args.ItemIndex]));
};
_menu.OnCookTimeSelected += args =>
{
var actualButton = args.Button as Button;
var newTime = (uint) int.Parse(actualButton.Text);
_menu.VisualCookTime = newTime;
SendMessage(new SharedMicrowaveComponent.MicrowaveSelectCookTimeMessage(newTime));
};
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing)
{
return;
}
_solids?.Clear();
_menu?.Dispose();
}
protected override void UpdateState(BoundUserInterfaceState state)
{
base.UpdateState(state);
if (!(state is MicrowaveUpdateUserInterfaceState cstate))
{
return;
}
RefreshContentsDisplay(cstate.ReagentsReagents, cstate.ContainedSolids);
}
private void RefreshContentsDisplay(IReadOnlyList<Solution.ReagentQuantity> reagents, List<EntityUid> solids)
{
_reagents.Clear();
_menu.IngredientsListReagents.Clear();
foreach (var reagent in reagents)
{
_prototypeManager.TryIndex(reagent.ReagentId, out ReagentPrototype proto);
var reagentAdded = _menu.IngredientsListReagents.AddItem($"{reagent.Quantity} {proto.Name}");
var reagentIndex = _menu.IngredientsListReagents.IndexOf(reagentAdded);
_reagents.Add(reagentIndex, reagent);
}
_solids.Clear();
_menu.IngredientsList.Clear();
foreach (var entityID in solids)
{
var entity = _entityManager.GetEntity(entityID);
if (entity.TryGetComponent(out IconComponent icon))
{
var solidItem = _menu.IngredientsList.AddItem(entity.Name, icon.Icon.Default);
var solidIndex = _menu.IngredientsList.IndexOf(solidItem);
_solids.Add(solidIndex, entityID);
}
}
}
}
}

206
Content.Client/GameObjects/Components/Kitchen/MicrowaveMenu.cs Normal file
View File

@@ -0,0 +1,206 @@
using System;
using Robust.Client.Graphics.Drawing;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.CustomControls;
using Robust.Shared.Localization;
using Robust.Shared.Maths;
namespace Content.Client.GameObjects.Components.Kitchen
{
public class MicrowaveMenu : SS14Window
{
protected override Vector2? CustomSize => (512, 256);
private MicrowaveBoundUserInterface Owner { get; set; }
public event Action<BaseButton.ButtonEventArgs> OnCookTimeSelected;
public uint VisualCookTime = 1;
public Button StartButton { get;}
public Button EjectButton { get;}
public PanelContainer TimerFacePlate { get; }
public ButtonGroup CookTimeButtonGroup { get; }
private VBoxContainer CookTimeButtonVbox { get; }
public ItemList IngredientsList { get;}
public ItemList IngredientsListReagents { get; }
private Label _cookTimeInfoLabel { get; }
public MicrowaveMenu(MicrowaveBoundUserInterface owner = null)
{
Owner = owner;
Title = Loc.GetString("Microwave");
var hSplit = new HBoxContainer
{
SizeFlagsHorizontal = SizeFlags.Fill,
SizeFlagsVertical = SizeFlags.Fill
};
IngredientsListReagents = new ItemList
{
SizeFlagsVertical = SizeFlags.FillExpand,
SizeFlagsHorizontal = SizeFlags.FillExpand,
SelectMode = ItemList.ItemListSelectMode.Button,
SizeFlagsStretchRatio = 2,
CustomMinimumSize = (100,128)
};
IngredientsList = new ItemList
{
SizeFlagsVertical = SizeFlags.FillExpand,
SizeFlagsHorizontal = SizeFlags.FillExpand,
SelectMode = ItemList.ItemListSelectMode.Button,
SizeFlagsStretchRatio = 2,
CustomMinimumSize = (100,128)
};
hSplit.AddChild(IngredientsListReagents);
//Padding between the lists.
hSplit.AddChild(new Control
{
CustomMinimumSize = (0,5),
});
hSplit.AddChild(IngredientsList);
var vSplit = new VBoxContainer
{
SizeFlagsVertical = SizeFlags.FillExpand,
SizeFlagsHorizontal = SizeFlags.FillExpand,
};
hSplit.AddChild(vSplit);
var buttonGridContainer = new VBoxContainer
{
Align = BoxContainer.AlignMode.Center,
SizeFlagsStretchRatio = 3
};
StartButton = new Button
{
Text = Loc.GetString("Start"),
TextAlign = Label.AlignMode.Center,
};
EjectButton = new Button
{
Text = Loc.GetString("Eject All Contents"),
ToolTip = Loc.GetString("This vaporizes all reagents, but ejects any solids."),
TextAlign = Label.AlignMode.Center,
};
buttonGridContainer.AddChild(StartButton);
buttonGridContainer.AddChild(EjectButton);
vSplit.AddChild(buttonGridContainer);
//Padding
vSplit.AddChild(new Control
{
CustomMinimumSize = (0, 15),
SizeFlagsVertical = SizeFlags.Fill,
});
CookTimeButtonGroup = new ButtonGroup();
CookTimeButtonVbox = new VBoxContainer
{
SizeFlagsVertical = SizeFlags.FillExpand,
Align = BoxContainer.AlignMode.Center,
};
var index = 0;
for (var i = 0; i <= 12; i++)
{
var newButton = new Button
{
Text = (index <= 0 ? 1 : index).ToString(),
TextAlign = Label.AlignMode.Center,
Group = CookTimeButtonGroup,
};
CookTimeButtonVbox.AddChild(newButton);
newButton.OnPressed += args =>
{
OnCookTimeSelected?.Invoke(args);
_cookTimeInfoLabel.Text = $"{Loc.GetString("COOK TIME")}: {VisualCookTime}";
};
index+=5;
}
var cookTimeOneSecondButton = (Button)CookTimeButtonVbox.GetChild(0);
cookTimeOneSecondButton.Pressed = true;
_cookTimeInfoLabel = new Label
{
Text = Loc.GetString($"COOK TIME: {VisualCookTime}"),
Align = Label.AlignMode.Center,
Modulate = Color.White,
SizeFlagsVertical = SizeFlags.ShrinkCenter
};
var innerTimerPanel = new PanelContainer
{
SizeFlagsVertical = SizeFlags.FillExpand,
ModulateSelfOverride = Color.Red,
CustomMinimumSize = (100, 128),
PanelOverride = new StyleBoxFlat {BackgroundColor = Color.Black.WithAlpha(0.5f)},
Children =
{
new VBoxContainer
{
Children =
{
new PanelContainer
{
PanelOverride = new StyleBoxFlat(){BackgroundColor = Color.Gray.WithAlpha(0.2f)},
Children =
{
_cookTimeInfoLabel
}
},
new ScrollContainer()
{
SizeFlagsVertical = SizeFlags.FillExpand,
Children =
{
CookTimeButtonVbox,
}
},
}
}
}
};
TimerFacePlate = new PanelContainer()
{
SizeFlagsVertical = SizeFlags.FillExpand,
SizeFlagsHorizontal = SizeFlags.FillExpand,
Children =
{
innerTimerPanel
},
};
vSplit.AddChild(TimerFacePlate);
Contents.AddChild(hSplit);
}
}
}

67
Content.Client/GameObjects/Components/Kitchen/MicrowaveVisualizer.cs Normal file
View File

@@ -0,0 +1,67 @@
using Content.Client.GameObjects.Components.Sound;
using Content.Shared.GameObjects.Components.Power;
using Content.Shared.GameObjects.Components.Sound;
using Content.Shared.Kitchen;
using Robust.Client.GameObjects;
using Robust.Client.Interfaces.GameObjects.Components;
using Robust.Shared.Audio;
using Robust.Shared.Log;
namespace Content.Client.GameObjects.Components.Kitchen
{
public sealed class MicrowaveVisualizer : AppearanceVisualizer
{
private SoundComponent _soundComponent;
private const string MicrowaveSoundLoop = "/Audio/machines/microwave_loop.ogg";
public override void OnChangeData(AppearanceComponent component)
{
base.OnChangeData(component);
var sprite = component.Owner.GetComponent<ISpriteComponent>();
_soundComponent ??= component.Owner.GetComponent<SoundComponent>();
if (!component.TryGetData(PowerDeviceVisuals.VisualState, out MicrowaveVisualState state))
{
state = MicrowaveVisualState.Idle;
}
switch (state)
{
case MicrowaveVisualState.Idle:
sprite.LayerSetState(MicrowaveVisualizerLayers.Base, "mw");
sprite.LayerSetState(MicrowaveVisualizerLayers.BaseUnlit, "mw_unlit");
_soundComponent.StopAllSounds();
break;
case MicrowaveVisualState.Cooking:
sprite.LayerSetState(MicrowaveVisualizerLayers.Base, "mw");
sprite.LayerSetState(MicrowaveVisualizerLayers.BaseUnlit, "mw_running_unlit");
var audioParams = AudioParams.Default;
audioParams.Loop = true;
var schedSound = new ScheduledSound();
schedSound.Filename = MicrowaveSoundLoop;
schedSound.AudioParams = audioParams;
_soundComponent.AddScheduledSound(schedSound);
break;
default:
Logger.Debug($"Something terrible happened in {this}");
break;
}
var glowingPartsVisible = !(component.TryGetData(PowerDeviceVisuals.Powered, out bool powered) && !powered);
sprite.LayerSetVisible(MicrowaveVisualizerLayers.BaseUnlit, glowingPartsVisible);
}
private enum MicrowaveVisualizerLayers
{
Base,
BaseUnlit
}
}
}

30
Content.Client/GameObjects/Components/Sound/SoundComponent.cs
View File

@@ -15,7 +15,7 @@ namespace Content.Client.GameObjects.Components.Sound
[RegisterComponent]
public class SoundComponent : SharedSoundComponent
{
private readonly List<ScheduledSound> _schedules = new List<ScheduledSound>();
private readonly Dictionary<ScheduledSound, IPlayingAudioStream> _audioStreams = new Dictionary<ScheduledSound, IPlayingAudioStream>();
private AudioSystem _audioSystem;
#pragma warning disable 649
[Dependency] private readonly IRobustRandom _random;
@@ -23,26 +23,27 @@ namespace Content.Client.GameObjects.Components.Sound
public override void StopAllSounds()
{
foreach (var schedule in _schedules)
foreach (var kvp in _audioStreams)
{
schedule.Play = false;
kvp.Key.Play = false;
kvp.Value.Stop();
}
_schedules.Clear();
_audioStreams.Clear();
}
public override void StopScheduledSound(string filename)
{
foreach (var schedule in _schedules.ToArray())
foreach (var kvp in _audioStreams)
{
if (schedule.Filename != filename) continue;
schedule.Play = false;
_schedules.Remove(schedule);
if (kvp.Key.Filename != filename) continue;
kvp.Key.Play = false;
kvp.Value.Stop();
_audioStreams.Remove(kvp.Key);
}
}
public override void AddScheduledSound(ScheduledSound schedule)
{
_schedules.Add(schedule);
Play(schedule);
}
@@ -54,16 +55,11 @@ namespace Content.Client.GameObjects.Components.Sound
{
if (!schedule.Play) return; // We make sure this hasn't changed.
if (_audioSystem == null) _audioSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<AudioSystem>();
_audioSystem.Play(schedule.Filename, Owner, schedule.AudioParams);
_audioStreams.Add(schedule,_audioSystem.Play(schedule.Filename, Owner, schedule.AudioParams));
if (schedule.Times == 0)
{
_schedules.Remove(schedule);
return;
}
if (schedule.Times == 0) return;
if (schedule.Times > 0)
schedule.Times--;
if (schedule.Times > 0) schedule.Times--;
Play(schedule);
});

117
Content.Client/GameObjects/EntitySystems/CombatModeSystem.cs
View File

@@ -25,8 +25,6 @@ namespace Content.Client.GameObjects.EntitySystems
[UsedImplicitly]
public sealed class CombatModeSystem : SharedCombatModeSystem
{
private const float AttackTimeThreshold = 0.15f;
#pragma warning disable 649
[Dependency] private readonly IGameHud _gameHud;
[Dependency] private readonly IPlayerManager _playerManager;
@@ -37,9 +35,6 @@ namespace Content.Client.GameObjects.EntitySystems
private InputSystem _inputSystem;
public bool UseOrAttackIsDown { get; private set; }
private float _timeHeld;
public override void Initialize()
{
base.Initialize();
@@ -48,10 +43,8 @@ namespace Content.Client.GameObjects.EntitySystems
_gameHud.OnTargetingZoneChanged = OnTargetingZoneChanged;
_inputSystem = EntitySystemManager.GetEntitySystem<InputSystem>();
_inputSystem.BindMap.BindFunction(ContentKeyFunctions.UseOrAttack, new InputHandler(this));
_inputSystem.BindMap.BindFunction(ContentKeyFunctions.ToggleCombatMode,
InputCmdHandler.FromDelegate(CombatModeToggled));
_overlayManager.AddOverlay(new CombatModeOverlay(this));
}
private void CombatModeToggled(ICommonSession session)
@@ -60,20 +53,10 @@ namespace Content.Client.GameObjects.EntitySystems
{
EntityManager.RaisePredictiveEvent(
new CombatModeSystemMessages.SetCombatModeActiveMessage(!IsInCombatMode()));
// Just in case.
UseOrAttackIsDown = false;
}
}
public override void Shutdown()
{
base.Shutdown();
_overlayManager.RemoveOverlay(nameof(CombatModeOverlay));
}
private bool IsInCombatMode()
public bool IsInCombatMode()
{
var entity = _playerManager.LocalPlayer.ControlledEntity;
if (entity == null || !entity.TryGetComponent(out CombatModeComponent combatMode))
@@ -92,104 +75,6 @@ namespace Content.Client.GameObjects.EntitySystems
private void OnCombatModeChanged(bool obj)
{
EntityManager.RaisePredictiveEvent(new CombatModeSystemMessages.SetCombatModeActiveMessage(obj));
// Just in case.
UseOrAttackIsDown = false;
}
private bool HandleInputMessage(ICommonSession session, InputCmdMessage message)
{
if (!(message is FullInputCmdMessage msg))
return false;
void SendMsg(BoundKeyFunction function, BoundKeyState state)
{
var functionId = _inputManager.NetworkBindMap.KeyFunctionID(function);
var sendMsg = new FullInputCmdMessage(msg.Tick, functionId, state,
msg.Coordinates, msg.ScreenCoordinates, msg.Uid);
_inputSystem.HandleInputCommand(session, function, sendMsg);
}
// If we are not in combat mode, relay it as a regular Use instead.
if (!IsInCombatMode())
{
SendMsg(EngineKeyFunctions.Use, msg.State);
return true;
}
if (msg.State == BoundKeyState.Down)
{
UseOrAttackIsDown = true;
_timeHeld = 0;
return true;
}
// Up.
if (UseOrAttackIsDown && _timeHeld >= AttackTimeThreshold)
{
// Attack.
SendMsg(ContentKeyFunctions.Attack, BoundKeyState.Down);
SendMsg(ContentKeyFunctions.Attack, BoundKeyState.Up);
}
else
{
// Use.
SendMsg(EngineKeyFunctions.Use, BoundKeyState.Down);
SendMsg(EngineKeyFunctions.Use, BoundKeyState.Up);
}
UseOrAttackIsDown = false;
return true;
}
public override void FrameUpdate(float frameTime)
{
if (UseOrAttackIsDown)
{
_timeHeld += frameTime;
}
}
// Custom input handler type so we get the ENTIRE InputCmdMessage.
private sealed class InputHandler : InputCmdHandler
{
private readonly CombatModeSystem _combatModeSystem;
public InputHandler(CombatModeSystem combatModeSystem)
{
_combatModeSystem = combatModeSystem;
}
public override bool HandleCmdMessage(ICommonSession session, InputCmdMessage message)
{
return _combatModeSystem.HandleInputMessage(session, message);
}
}
private sealed class CombatModeOverlay : Overlay
{
private readonly CombatModeSystem _system;
public CombatModeOverlay(CombatModeSystem system) : base(nameof(CombatModeOverlay))
{
_system = system;
}
protected override void Draw(DrawingHandleBase handle)
{
var screenHandle = (DrawingHandleScreen) handle;
var mousePos = IoCManager.Resolve<IInputManager>().MouseScreenPosition;
if (_system.UseOrAttackIsDown && _system._timeHeld > AttackTimeThreshold)
{
var tex = ResC.GetTexture($"/Textures/Objects/Tools/toolbox_r.png");
screenHandle.DrawTextureRect(tex, UIBox2.FromDimensions(mousePos, tex.Size * 2));
}
}
}
}
}

4
Content.Client/GameObjects/EntitySystems/RangedWeaponSystem.cs
View File

@@ -39,8 +39,8 @@ namespace Content.Client.GameObjects.EntitySystems
base.Update(frameTime);
var canFireSemi = _isFirstShot;
var state = _inputSystem.CmdStates.GetState(ContentKeyFunctions.Attack);
if (!_combatModeSystem.UseOrAttackIsDown && state != BoundKeyState.Down)
var state = _inputSystem.CmdStates.GetState(EngineKeyFunctions.Use);
if (!_combatModeSystem.IsInCombatMode() || state != BoundKeyState.Down)
{
_isFirstShot = true;
_blocked = false;

10
Content.Client/GameObjects/EntitySystems/VerbSystem.cs
View File

@@ -150,7 +150,10 @@ namespace Content.Client.GameObjects.EntitySystems
if (verb.RequireInteractionRange && !VerbUtility.InVerbUseRange(user, entity))
continue;
var disabled = verb.GetVisibility(user, component) != VerbVisibility.Visible;
if (VerbUtility.IsVerbInvisible(verb, user, component, out var vis))
continue;
var disabled = vis != VerbVisibility.Visible;
var category = verb.GetCategory(user, component);
@@ -166,7 +169,10 @@ namespace Content.Client.GameObjects.EntitySystems
if (globalVerb.RequireInteractionRange && !VerbUtility.InVerbUseRange(user, entity))
continue;
var disabled = globalVerb.GetVisibility(user, entity) != VerbVisibility.Visible;
if (VerbUtility.IsVerbInvisible(globalVerb, user, entity, out var vis))
continue;
var disabled = vis != VerbVisibility.Visible;
var category = globalVerb.GetCategory(user, entity);
if(!buttons.ContainsKey(category))