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

Re-organize all projects (#4166)

Browse Source
This commit is contained in:
DrSmugleaf
2021-06-09 22:19:39 +02:00
committed by GitHub
parent 9f50e4061b
commit ff1a2d97ea
1773 changed files with 5258 additions and 5508 deletions
Download Patch File Download Diff File Expand all files Collapse all files

366
Content.Server/AME/Components/AMEControllerComponent.cs Normal file
View File

@@ -0,0 +1,366 @@
#nullable enable
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Hands.Components;
using Content.Server.Items;
using Content.Server.NodeContainer;
using Content.Server.Power.Components;
using Content.Server.UserInterface;
using Content.Shared.ActionBlocker;
using Content.Shared.AME;
using Content.Shared.Interaction;
using Content.Shared.Notification;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.Localization;
using Robust.Shared.Player;
using Robust.Shared.ViewVariables;
namespace Content.Server.AME.Components
{
[RegisterComponent]
[ComponentReference(typeof(IActivate))]
[ComponentReference(typeof(IInteractUsing))]
public class AMEControllerComponent : SharedAMEControllerComponent, IActivate, IInteractUsing
{
[ViewVariables] private BoundUserInterface? UserInterface => Owner.GetUIOrNull(AMEControllerUiKey.Key);
[ViewVariables] private bool _injecting;
[ViewVariables] public int InjectionAmount;
private AppearanceComponent? _appearance;
private PowerSupplierComponent? _powerSupplier;
private bool Powered => !Owner.TryGetComponent(out PowerReceiverComponent? receiver) || receiver.Powered;
[ViewVariables]
private int _stability = 100;
private ContainerSlot _jarSlot = default!;
[ViewVariables] private bool HasJar => _jarSlot.ContainedEntity != null;
public override void Initialize()
{
base.Initialize();
if (UserInterface != null)
{
UserInterface.OnReceiveMessage += OnUiReceiveMessage;
}
Owner.TryGetComponent(out _appearance);
Owner.TryGetComponent(out _powerSupplier);
_injecting = false;
InjectionAmount = 2;
_jarSlot = ContainerHelpers.EnsureContainer<ContainerSlot>(Owner, $"{Name}-fuelJarContainer");
}
public override void HandleMessage(ComponentMessage message, IComponent? component)
{
base.HandleMessage(message, component);
switch (message)
{
case PowerChangedMessage powerChanged:
OnPowerChanged(powerChanged);
break;
}
}
internal void OnUpdate(float frameTime)
{
if(!_injecting)
{
return;
}
var group = GetAMENodeGroup();
if (group == null)
{
return;
}
var jar = _jarSlot.ContainedEntity;
if(jar is null)
return;
jar.TryGetComponent<AMEFuelContainerComponent>(out var fuelJar);
if(fuelJar != null && _powerSupplier != null)
{
var availableInject = fuelJar.FuelAmount >= InjectionAmount ? InjectionAmount : fuelJar.FuelAmount;
_powerSupplier.SupplyRate = group.InjectFuel(availableInject, out var overloading);
fuelJar.FuelAmount -= availableInject;
InjectSound(overloading);
UpdateUserInterface();
}
_stability = group.GetTotalStability();
UpdateDisplay(_stability);
if(_stability <= 0) { group.ExplodeCores(); }
}
/// <summary>
/// Called when you click the owner entity with an empty hand. Opens the UI client-side if possible.
/// </summary>
/// <param name="args">Data relevant to the event such as the actor which triggered it.</param>
void IActivate.Activate(ActivateEventArgs args)
{
if (!args.User.TryGetComponent(out ActorComponent? actor))
{
return;
}
if (!args.User.TryGetComponent(out IHandsComponent? hands))
{
Owner.PopupMessage(args.User, Loc.GetString("You have no hands."));
return;
}
var activeHandEntity = hands.GetActiveHand?.Owner;
if (activeHandEntity == null)
{
UserInterface?.Open(actor.PlayerSession);
}
}
private void OnPowerChanged(PowerChangedMessage e)
{
UpdateUserInterface();
}
private AMEControllerBoundUserInterfaceState GetUserInterfaceState()
{
var jar = _jarSlot.ContainedEntity;
if (jar == null)
{
return new AMEControllerBoundUserInterfaceState(Powered, IsMasterController(), false, HasJar, 0, InjectionAmount, GetCoreCount());
}
var jarcomponent = jar.GetComponent<AMEFuelContainerComponent>();
return new AMEControllerBoundUserInterfaceState(Powered, IsMasterController(), _injecting, HasJar, jarcomponent.FuelAmount, InjectionAmount, GetCoreCount());
}
/// <summary>
/// Checks whether the player entity is able to use the controller.
/// </summary>
/// <param name="playerEntity">The player entity.</param>
/// <returns>Returns true if the entity can use the controller, and false if it cannot.</returns>
private bool PlayerCanUseController(IEntity playerEntity, bool needsPower = true)
{
//Need player entity to check if they are still able to use the dispenser
if (playerEntity == null)
return false;
//Check if player can interact in their current state
if (!ActionBlockerSystem.CanInteract(playerEntity) || !ActionBlockerSystem.CanUse(playerEntity))
return false;
//Check if device is powered
if (needsPower && !Powered)
return false;
return true;
}
private void UpdateUserInterface()
{
var state = GetUserInterfaceState();
UserInterface?.SetState(state);
}
/// <summary>
/// Handles ui messages from the client. For things such as button presses
/// which interact with the world and require server action.
/// </summary>
/// <param name="obj">A user interface message from the client.</param>
private void OnUiReceiveMessage(ServerBoundUserInterfaceMessage obj)
{
if (obj.Session.AttachedEntity == null)
{
return;
}
var msg = (UiButtonPressedMessage) obj.Message;
var needsPower = msg.Button switch
{
UiButton.Eject => false,
_ => true,
};
if (!PlayerCanUseController(obj.Session.AttachedEntity, needsPower))
return;
switch (msg.Button)
{
case UiButton.Eject:
TryEject(obj.Session.AttachedEntity);
break;
case UiButton.ToggleInjection:
ToggleInjection();
break;
case UiButton.IncreaseFuel:
InjectionAmount += 2;
break;
case UiButton.DecreaseFuel:
InjectionAmount = InjectionAmount > 0 ? InjectionAmount -= 2 : 0;
break;
case UiButton.RefreshParts:
RefreshParts();
break;
}
GetAMENodeGroup()?.UpdateCoreVisuals(InjectionAmount, _injecting);
UpdateUserInterface();
ClickSound();
}
private void TryEject(IEntity user)
{
if (!HasJar || _injecting)
return;
var jar = _jarSlot.ContainedEntity;
if(jar is null)
return;
_jarSlot.Remove(jar);
UpdateUserInterface();
if (!user.TryGetComponent<HandsComponent>(out var hands) || !jar.TryGetComponent<ItemComponent>(out var item))
return;
if (hands.CanPutInHand(item))
hands.PutInHand(item);
}
private void ToggleInjection()
{
if (!_injecting)
{
_appearance?.SetData(AMEControllerVisuals.DisplayState, "on");
}
else
{
_appearance?.SetData(AMEControllerVisuals.DisplayState, "off");
if (_powerSupplier != null)
{
_powerSupplier.SupplyRate = 0;
}
}
_injecting = !_injecting;
UpdateUserInterface();
}
private void UpdateDisplay(int stability)
{
if(_appearance == null) { return; }
_appearance.TryGetData<string>(AMEControllerVisuals.DisplayState, out var state);
var newState = "on";
if (stability < 50) { newState = "critical"; }
if (stability < 10) { newState = "fuck"; }
if (state != newState)
{
_appearance?.SetData(AMEControllerVisuals.DisplayState, newState);
}
}
private void RefreshParts()
{
GetAMENodeGroup()?.RefreshAMENodes(this);
UpdateUserInterface();
}
private AMENodeGroup? GetAMENodeGroup()
{
Owner.TryGetComponent(out NodeContainerComponent? nodeContainer);
var engineNodeGroup = nodeContainer?.Nodes.Values
.Select(node => node.NodeGroup)
.OfType<AMENodeGroup>()
.FirstOrDefault();
return engineNodeGroup;
}
private bool IsMasterController()
{
if(GetAMENodeGroup()?.MasterController == this)
{
return true;
}
return false;
}
private int GetCoreCount()
{
var coreCount = 0;
var group = GetAMENodeGroup();
if (group != null)
{
coreCount = group.CoreCount;
}
return coreCount;
}
private void ClickSound()
{
SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Machines/machine_switch.ogg", Owner, AudioParams.Default.WithVolume(-2f));
}
private void InjectSound(bool overloading)
{
SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Effects/bang.ogg", Owner, AudioParams.Default.WithVolume(overloading ? 10f : 0f));
}
async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs args)
{
if (!args.User.TryGetComponent(out IHandsComponent? hands))
{
Owner.PopupMessage(args.User, Loc.GetString("You have no hands."));
return true;
}
if (hands.GetActiveHand == null)
{
Owner.PopupMessage(args.User, Loc.GetString("You have nothing on your hand."));
return false;
}
var activeHandEntity = hands.GetActiveHand.Owner;
if (activeHandEntity.TryGetComponent<AMEFuelContainerComponent>(out var fuelContainer))
{
if (HasJar)
{
Owner.PopupMessage(args.User, Loc.GetString("The controller already has a jar loaded."));
}
else
{
_jarSlot.Insert(activeHandEntity);
Owner.PopupMessage(args.User, Loc.GetString("You insert the jar into the fuel slot."));
UpdateUserInterface();
}
}
else
{
Owner.PopupMessage(args.User, Loc.GetString("You can't put that in the controller..."));
}
return true;
}
}
}

43
Content.Server/AME/Components/AMEFuelContainerComponent.cs Normal file
View File

@@ -0,0 +1,43 @@
#nullable enable
using Robust.Shared.GameObjects;
using Robust.Shared.ViewVariables;
namespace Content.Server.AME.Components
{
[RegisterComponent]
public class AMEFuelContainerComponent : Component
{
public override string Name => "AMEFuelContainer";
private int _fuelAmount;
private int _maxFuelAmount;
/// <summary>
/// The amount of fuel in the jar.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public int FuelAmount
{
get => _fuelAmount;
set => _fuelAmount = value;
}
/// <summary>
/// The maximum fuel capacity of the jar.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public int MaxFuelAmount
{
get => _maxFuelAmount;
set => _maxFuelAmount = value;
}
public override void Initialize()
{
base.Initialize();
_maxFuelAmount = 1000;
_fuelAmount = 1000;
}
}
}

60
Content.Server/AME/Components/AMEPartComponent.cs Normal file
View File

@@ -0,0 +1,60 @@
#nullable enable
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Hands.Components;
using Content.Server.Tools.Components;
using Content.Shared.Interaction;
using Content.Shared.Notification;
using Content.Shared.Tool;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Map;
using Robust.Shared.Player;
namespace Content.Server.AME.Components
{
[RegisterComponent]
[ComponentReference(typeof(IInteractUsing))]
public class AMEPartComponent : Component, IInteractUsing
{
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IServerEntityManager _serverEntityManager = default!;
public override string Name => "AMEPart";
private string _unwrap = "/Audio/Effects/unwrap.ogg";
async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs args)
{
if (!args.User.TryGetComponent<IHandsComponent>(out var hands))
{
Owner.PopupMessage(args.User, Loc.GetString("You have no hands."));
return true;
}
if (!args.Using.TryGetComponent<ToolComponent>(out var multitool) || multitool.Qualities != ToolQuality.Multitool)
return true;
if (!_mapManager.TryGetGrid(args.ClickLocation.GetGridId(_serverEntityManager), out var mapGrid))
return false; // No AME in space.
var snapPos = mapGrid.TileIndicesFor(args.ClickLocation);
if (mapGrid.GetAnchoredEntities(snapPos).Any(sc => _serverEntityManager.ComponentManager.HasComponent<AMEShieldComponent>(sc)))
{
Owner.PopupMessage(args.User, Loc.GetString("Shielding is already there!"));
return true;
}
var ent = _serverEntityManager.SpawnEntity("AMEShielding", mapGrid.GridTileToLocal(snapPos));
ent.Transform.LocalRotation = Owner.Transform.LocalRotation;
SoundSystem.Play(Filter.Pvs(Owner), _unwrap, Owner);
Owner.Delete();
return true;
}
}
}

66
Content.Server/AME/Components/AMEShieldComponent.cs Normal file
View File

@@ -0,0 +1,66 @@
#nullable enable
using System;
using Content.Shared.AME;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.ViewVariables;
namespace Content.Server.AME.Components
{
[RegisterComponent]
public class AMEShieldComponent : SharedAMEShieldComponent
{
private bool _isCore = false;
[ViewVariables]
public int CoreIntegrity = 100;
private AppearanceComponent? _appearance;
private PointLightComponent? _pointLight;
public override void Initialize()
{
base.Initialize();
Owner.TryGetComponent(out _appearance);
Owner.TryGetComponent(out _pointLight);
}
public void SetCore()
{
if(_isCore) { return; }
_isCore = true;
_appearance?.SetData(AMEShieldVisuals.Core, "isCore");
}
public void UnsetCore()
{
_isCore = false;
_appearance?.SetData(AMEShieldVisuals.Core, "isNotCore");
}
public void UpdateCoreVisuals(int injectionStrength, bool injecting)
{
if (!injecting)
{
_appearance?.SetData(AMEShieldVisuals.CoreState, "off");
if (_pointLight != null) { _pointLight.Enabled = false; }
return;
}
if (_pointLight != null)
{
_pointLight.Radius = Math.Clamp(injectionStrength, 1, 12);
_pointLight.Enabled = true;
}
if (injectionStrength > 2)
{
_appearance?.SetData(AMEShieldVisuals.CoreState, "strong");
return;
}
_appearance?.SetData(AMEShieldVisuals.CoreState, "weak");
}
}
}