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

[Antag] add space ninja as midround antag (#14069)

Browse Source 
* start of space ninja midround antag

* suit has powercell, can be upgraded only (not replaced with equal or worse battery)

* add doorjacking to ninja gloves, power cell, doorjack objective (broken), tweaks

* 💀

* add basic suit power display that uses stamina rsi

* add draining apc/sub/smes - no wires yet

* add research downloading

* ninja starts implanted, move some stuff to yaml

* add Automated field to OnUseTimerTrigger

* implement spider charge and objective

* fix client crash when taking suit off, some refactor

* add survive condition and tweak locale

* add comms console icon for objective

* add calling in a threat - currently revenant and dragon

* combine all glove abilities

* locale

* spark sounds when draining, refactoring

* toggle is actually toggle now

* prevent crash if disabling stealth with outline

* add antag ctrl for ninja, hopefully show greentext

* fix greentext and some other things

* disabling gloves if taken off or suit taken off

* basic energy katana, change ninja loadout

* recallable katana, refactoring

* start of dash - not done yet

* katana dashing ability

* merge upstream + compiling, make AutomatedTimer its own component

* docs and stuff

* partial refactor of glove abilities, still need to move handling

* make dooremaggedevent by ref

* move bunch of stuff to shared - broken

* clean ninja antag verb

* doc

* mark rule config fields as required

* fix client crash

* wip systems refactor

* big refactor of systems

* fuck

* make TryDoElectrocution callable from shared

* finish refactoring?

* no guns

* start with internals on

* clean up glove abilities, add range check

* create soap, in place of ninja throwing stars

* add emp suit ability

* able to eat chefs stolen food in space

* stuff, tell client when un/cloaked but there is bug with gloves

* fix prediction breaking gloves on client

* ninja soap despawns after a minute

* ninja spawns outside the station now, with gps + station coords to navigate

* add cooldown to stun ability

* cant use glove abilities in combat mode

* require empty hand to use glove abilities

* use ghost role spawner

* Update Content.Server/Ninja/Systems/NinjaSuitSystem.cs

Co-authored-by: keronshb <54602815+keronshb@users.noreply.github.com>

* some review changes

* show powercell charge on examine

* new is needed

* address some reviews

* ninja starts with jetpack, i hope

* partial feedback

* uhh

* pro

* remove pirate from threats list

* use doafter refactor

* pro i gave skeleton jetpack

* some stuff

* use auto gen state

* mr handy

* use EntityQueryEnumerator

* cleanup

* spider charge target anti-troll

* mmmmmm

---------

Co-authored-by: deltanedas <deltanedas@laptop>
Co-authored-by: deltanedas <user@zenith>
Co-authored-by: deltanedas <@deltanedas:kde.org>
Co-authored-by: keronshb <54602815+keronshb@users.noreply.github.com>
This commit is contained in:
deltanedas
2023-04-17 07:33:27 +00:00
committed by GitHub
parent 0e6b273f1f
commit c1cda0dbf8
78 changed files with 2697 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
Content.Shared/Ninja/Components/EnergyKatanaComponent.cs Normal file
View File

@@ -0,0 +1,66 @@
using Content.Shared.Actions;
using Content.Shared.Actions.ActionTypes;
using Content.Shared.Ninja.Systems;
using Robust.Shared.Audio;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
using Robust.Shared.Serialization;
namespace Content.Shared.Ninja.Components;
/// <summary>
/// Component for a Space Ninja's katana, controls its dash sound.
/// Requires a ninja with a suit for abilities to work.
/// </summary>
// basically emag but without immune tag, TODO: make the charge thing its own component and have emag use it too
[Access(typeof(EnergyKatanaSystem))]
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
public sealed partial class EnergyKatanaComponent : Component
{
public EntityUid? Ninja = null;
/// <summary>
/// Sound played when using dash action.
/// </summary>
[DataField("blinkSound")]
public SoundSpecifier BlinkSound = new SoundPathSpecifier("/Audio/Magic/blink.ogg");
/// <summary>
/// Volume control for katana dash action.
/// </summary>
[DataField("blinkVolume")]
public float BlinkVolume = 5f;
/// <summary>
/// The maximum number of dash charges the katana can have
/// </summary>
[DataField("maxCharges"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public int MaxCharges = 3;
/// <summary>
/// The current number of dash charges on the katana
/// </summary>
[DataField("charges"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public int Charges = 3;
/// <summary>
/// Whether or not the katana automatically recharges over time.
/// </summary>
[DataField("autoRecharge"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public bool AutoRecharge = true;
/// <summary>
/// The time it takes to regain a single dash charge
/// </summary>
[DataField("rechargeDuration"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public TimeSpan RechargeDuration = TimeSpan.FromSeconds(20);
/// <summary>
/// The time when the next dash charge will be added
/// </summary>
[DataField("nextChargeTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public TimeSpan NextChargeTime = TimeSpan.MaxValue;
}
public sealed class KatanaDashEvent : WorldTargetActionEvent { }

69
Content.Shared/Ninja/Components/NinjaComponent.cs Normal file
View File

@@ -0,0 +1,69 @@
using Content.Shared.Ninja.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
namespace Content.Shared.Ninja.Components;
/// <summary>
/// Component placed on a mob to make it a space ninja, able to use suit and glove powers.
/// Contains ids of all ninja equipment.
/// </summary>
// TODO: Contains objective related stuff, might want to move it out somehow
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
[Access(typeof(SharedNinjaSystem))]
public sealed partial class NinjaComponent : Component
{
/// <summary>
/// Grid entity of the station the ninja was spawned around. Set if spawned naturally by the event.
/// </summary>
public EntityUid? StationGrid;
/// <summary>
/// Currently worn suit
/// </summary>
[ViewVariables]
public EntityUid? Suit = null;
/// <summary>
/// Currently worn gloves
/// </summary>
[ViewVariables]
public EntityUid? Gloves = null;
/// <summary>
/// Bound katana, set once picked up and never removed
/// </summary>
[ViewVariables]
public EntityUid? Katana = null;
/// <summary>
/// Number of doors that have been doorjacked, used for objective
/// </summary>
[ViewVariables, AutoNetworkedField]
public int DoorsJacked = 0;
/// <summary>
/// Research nodes that have been downloaded, used for objective
/// </summary>
// TODO: client doesn't need to know what nodes are downloaded, just how many
[ViewVariables, AutoNetworkedField]
public HashSet<string> DownloadedNodes = new();
/// <summary>
/// Warp point that the spider charge has to target
/// </summary>
[ViewVariables, AutoNetworkedField]
public EntityUid? SpiderChargeTarget = null;
/// <summary>
/// Whether the spider charge has been detonated on the target, used for objective
/// </summary>
[ViewVariables, AutoNetworkedField]
public bool SpiderChargeDetonated;
/// <summary>
/// Whether the comms console has been hacked, used for objective
/// </summary>
[ViewVariables, AutoNetworkedField]
public bool CalledInThreat;
}

151
Content.Shared/Ninja/Components/NinjaGlovesComponent.cs Normal file
View File

@@ -0,0 +1,151 @@
using Content.Shared.Actions;
using Content.Shared.Actions.ActionTypes;
using Content.Shared.DoAfter;
using Content.Shared.Ninja.Systems;
using Content.Shared.Tag;
using Content.Shared.Toggleable;
using Robust.Shared.Audio;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
using Robust.Shared.Utility;
using System.Threading;
namespace Content.Shared.Ninja.Components;
/// <summary>
/// Component for toggling glove powers.
/// Powers being enabled is controlled by GlovesEnabledComponent
/// </summary>
[Access(typeof(SharedNinjaGlovesSystem))]
[RegisterComponent, NetworkedComponent]
public sealed class NinjaGlovesComponent : Component
{
/// <summary>
/// Entity of the ninja using these gloves, usually means enabled
/// </summary>
[ViewVariables]
public EntityUid? User;
/// <summary>
/// The action for toggling ninja gloves abilities
/// </summary>
[DataField("toggleAction")]
public InstantAction ToggleAction = new()
{
DisplayName = "action-name-toggle-ninja-gloves",
Description = "action-desc-toggle-ninja-gloves",
Priority = -13,
Event = new ToggleActionEvent()
};
}
/// <summary>
/// Component for emagging doors on click, when gloves are enabled.
/// Only works on entities with DoorComponent.
/// </summary>
[RegisterComponent]
public sealed class NinjaDoorjackComponent : Component
{
/// <summary>
/// The tag that marks an entity as immune to doorjacking
/// </summary>
[DataField("emagImmuneTag", customTypeSerializer: typeof(PrototypeIdSerializer<TagPrototype>))]
public string EmagImmuneTag = "EmagImmune";
}
/// <summary>
/// Component for stunning mobs on click, when gloves are enabled.
/// Knocks them down for a bit and deals shock damage.
/// </summary>
[RegisterComponent]
public sealed class NinjaStunComponent : Component
{
/// <summary>
/// Joules required in the suit to stun someone. Defaults to 10 uses on a small battery.
/// </summary>
[DataField("stunCharge")]
public float StunCharge = 36.0f;
/// <summary>
/// Shock damage dealt when stunning someone
/// </summary>
[DataField("stunDamage")]
public int StunDamage = 5;
/// <summary>
/// Time that someone is stunned for, stacks if done multiple times.
/// </summary>
[DataField("stunTime")]
public TimeSpan StunTime = TimeSpan.FromSeconds(3);
}
/// <summary>
/// Component for draining power from APCs/substations/SMESes, when gloves are enabled.
/// </summary>
[RegisterComponent]
public sealed class NinjaDrainComponent : Component
{
/// <summary>
/// Conversion rate between joules in a device and joules added to suit.
/// Should be very low since powercells store nothing compared to even an APC.
/// </summary>
[DataField("drainEfficiency")]
public float DrainEfficiency = 0.001f;
/// <summary>
/// Time that the do after takes to drain charge from a battery, in seconds
/// </summary>
[DataField("drainTime")]
public float DrainTime = 1f;
[DataField("sparkSound")]
public SoundSpecifier SparkSound = new SoundCollectionSpecifier("sparks");
}
/// <summary>
/// Component for downloading research nodes from a R&D server, when gloves are enabled.
/// Requirement for greentext.
/// </summary>
[RegisterComponent]
public sealed class NinjaDownloadComponent : Component
{
/// <summary>
/// Time taken to download research from a server
/// </summary>
[DataField("downloadTime")]
public float DownloadTime = 20f;
}
/// <summary>
/// Component for hacking a communications console to call in a threat.
/// Called threat is rolled from the ninja gamerule config.
/// </summary>
[RegisterComponent]
public sealed class NinjaTerrorComponent : Component
{
/// <summary>
/// Time taken to hack the console
/// </summary>
[DataField("terrorTime")]
public float TerrorTime = 20f;
}
/// <summary>
/// DoAfter event for drain ability.
/// </summary>
[Serializable, NetSerializable]
public sealed class DrainDoAfterEvent : SimpleDoAfterEvent { }
/// <summary>
/// DoAfter event for research download ability.
/// </summary>
[Serializable, NetSerializable]
public sealed class DownloadDoAfterEvent : SimpleDoAfterEvent { }
/// <summary>
/// DoAfter event for comms console terror ability.
/// </summary>
[Serializable, NetSerializable]
public sealed class TerrorDoAfterEvent : SimpleDoAfterEvent { }

148
Content.Shared/Ninja/Components/NinjaSuitComponent.cs Normal file
View File

@@ -0,0 +1,148 @@
using Content.Shared.Actions;
using Content.Shared.Actions.ActionTypes;
using Content.Shared.Ninja.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
using Robust.Shared.Utility;
namespace Content.Shared.Ninja.Components;
// TODO: ResourcePath -> ResPath when thing gets merged
/// <summary>
/// Component for ninja suit abilities and power consumption.
/// As an implementation detail, dashing with katana is a suit action which isn't ideal.
/// </summary>
[Access(typeof(SharedNinjaSuitSystem))]
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
public sealed partial class NinjaSuitComponent : Component
{
[ViewVariables, AutoNetworkedField]
public bool Cloaked = false;
/// <summary>
/// The action for toggling suit phase cloak ability
/// </summary>
[DataField("togglePhaseCloakAction")]
public InstantAction TogglePhaseCloakAction = new()
{
UseDelay = TimeSpan.FromSeconds(5), // have to plan un/cloaking ahead of time
DisplayName = "action-name-toggle-phase-cloak",
Description = "action-desc-toggle-phase-cloak",
Priority = -9,
Event = new TogglePhaseCloakEvent()
};
/// <summary>
/// Battery charge used passively, in watts. Will last 1000 seconds on a small-capacity power cell.
/// </summary>
[DataField("passiveWattage")]
public float PassiveWattage = 0.36f;
/// <summary>
/// Battery charge used while cloaked, stacks with passive. Will last 200 seconds while cloaked on a small-capacity power cell.
/// </summary>
[DataField("cloakWattage")]
public float CloakWattage = 1.44f;
/// <summary>
/// The action for creating throwing soap, in place of ninja throwing stars since embedding doesn't exist.
/// </summary>
[DataField("createSoapAction")]
public InstantAction CreateSoapAction = new()
{
UseDelay = TimeSpan.FromSeconds(10),
Icon = new SpriteSpecifier.Rsi(new ResourcePath("Objects/Specific/Janitorial/soap.rsi"), "soap"),
ItemIconStyle = ItemActionIconStyle.NoItem,
DisplayName = "action-name-create-soap",
Description = "action-desc-create-soap",
Priority = -10,
Event = new CreateSoapEvent()
};
/// <summary>
/// Battery charge used to create a throwing soap. Can do it 25 times on a small-capacity power cell.
/// </summary>
[DataField("soapCharge")]
public float SoapCharge = 14.4f;
/// <summary>
/// Soap item to create with the action
/// </summary>
[DataField("soapPrototype", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>))]
public string SoapPrototype = "SoapNinja";
/// <summary>
/// The action for recalling a bound energy katana
/// </summary>
[DataField("recallkatanaAction")]
public InstantAction RecallKatanaAction = new()
{
UseDelay = TimeSpan.FromSeconds(1),
Icon = new SpriteSpecifier.Rsi(new ResourcePath("Objects/Weapons/Melee/energykatana.rsi"), "icon"),
ItemIconStyle = ItemActionIconStyle.NoItem,
DisplayName = "action-name-recall-katana",
Description = "action-desc-recall-katana",
Priority = -11,
Event = new RecallKatanaEvent()
};
/// <summary>
/// The action for dashing somewhere using katana
/// </summary>
[DataField("katanaDashAction")]
public WorldTargetAction KatanaDashAction = new()
{
Icon = new SpriteSpecifier.Rsi(new ResourcePath("Objects/Magic/magicactions.rsi"), "blink"),
ItemIconStyle = ItemActionIconStyle.NoItem,
DisplayName = "action-name-katana-dash",
Description = "action-desc-katana-dash",
Priority = -12,
Event = new KatanaDashEvent(),
// doing checks manually
CheckCanAccess = false,
Range = 0f
};
/// <summary>
/// The action for creating an EMP burst
/// </summary>
[DataField("empAction")]
public InstantAction EmpAction = new()
{
Icon = new SpriteSpecifier.Rsi(new ResourcePath("Objects/Weapons/Grenades/empgrenade.rsi"), "icon"),
ItemIconStyle = ItemActionIconStyle.BigAction,
DisplayName = "action-name-em-burst",
Description = "action-desc-em-burst",
Priority = -13,
Event = new NinjaEmpEvent()
};
/// <summary>
/// Battery charge used to create an EMP burst. Can do it 2 times on a small-capacity power cell.
/// </summary>
[DataField("empCharge")]
public float EmpCharge = 180f;
/// <summary>
/// Range of the EMP in tiles.
/// </summary>
[DataField("empRange")]
public float EmpRange = 6f;
/// <summary>
/// Power consumed from batteries by the EMP
/// </summary>
[DataField("empConsumption")]
public float EmpConsumption = 100000f;
}
public sealed class TogglePhaseCloakEvent : InstantActionEvent { }
public sealed class CreateSoapEvent : InstantActionEvent { }
public sealed class RecallKatanaEvent : InstantActionEvent { }
public sealed class NinjaEmpEvent : InstantActionEvent { }

17
Content.Shared/Ninja/Components/SpiderChargeComponent.cs Normal file
View File

@@ -0,0 +1,17 @@
namespace Content.Shared.Ninja.Components;
/// <summary>
/// Component for the Space Ninja's unique Spider Charge.
/// Only this component detonating can trigger the ninja's objective.
/// </summary>
[RegisterComponent]
public sealed class SpiderChargeComponent : Component
{
/// Range for planting within the target area
[DataField("range")]
public float Range = 10f;
/// The ninja that planted this charge
[ViewVariables]
public EntityUid? Planter = null;
}

147
Content.Shared/Ninja/Systems/EnergyKatanaSystem.cs Normal file
View File

@@ -0,0 +1,147 @@
using Content.Shared.Examine;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Inventory.Events;
using Content.Shared.Ninja.Components;
using Content.Shared.Physics;
using Content.Shared.Popups;
using Robust.Shared.Audio;
using Robust.Shared.GameObjects;
using Robust.Shared.Timing;
namespace Content.Shared.Ninja.Systems;
/// <summary>
/// System for katana dashing, recharging and what not.
/// </summary>
// TODO: move all recharging stuff into its own system and use for emag too
public sealed class EnergyKatanaSystem : EntitySystem
{
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedHandsSystem _hands = default!;
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
[Dependency] private readonly SharedNinjaSystem _ninja = default!;
[Dependency] private readonly SharedPopupSystem _popups = default!;
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<EnergyKatanaComponent, GotEquippedEvent>(OnEquipped);
SubscribeLocalEvent<EnergyKatanaComponent, ExaminedEvent>(OnExamine);
SubscribeLocalEvent<NinjaSuitComponent, KatanaDashEvent>(OnDash);
SubscribeLocalEvent<EnergyKatanaComponent, EntityUnpausedEvent>(OnUnpaused);
}
private void OnEquipped(EntityUid uid, EnergyKatanaComponent comp, GotEquippedEvent args)
{
// check if already bound
if (comp.Ninja != null)
return;
// check if ninja already has a katana bound
var user = args.Equipee;
if (!TryComp<NinjaComponent>(user, out var ninja) || ninja.Katana != null)
return;
// bind it
comp.Ninja = user;
_ninja.BindKatana(ninja, uid);
}
private void OnUnpaused(EntityUid uid, EnergyKatanaComponent component, ref EntityUnpausedEvent args)
{
component.NextChargeTime += args.PausedTime;
}
private void OnExamine(EntityUid uid, EnergyKatanaComponent component, ExaminedEvent args)
{
args.PushMarkup(Loc.GetString("emag-charges-remaining", ("charges", component.Charges)));
if (component.Charges == component.MaxCharges)
{
args.PushMarkup(Loc.GetString("emag-max-charges"));
return;
}
var timeRemaining = Math.Round((component.NextChargeTime - _timing.CurTime).TotalSeconds);
args.PushMarkup(Loc.GetString("emag-recharging", ("seconds", timeRemaining)));
}
// TODO: remove and use LimitedCharges+AutoRecharge
public override void Update(float frameTime)
{
base.Update(frameTime);
foreach (var comp in EntityQuery<EnergyKatanaComponent>())
{
if (!comp.AutoRecharge)
continue;
if (comp.Charges == comp.MaxCharges)
continue;
if (_timing.CurTime < comp.NextChargeTime)
continue;
ChangeCharge(comp.Owner, 1, true, comp);
}
}
public void OnDash(EntityUid suit, NinjaSuitComponent comp, KatanaDashEvent args)
{
var user = args.Performer;
args.Handled = true;
if (!TryComp<NinjaComponent>(user, out var ninja) || ninja.Katana == null)
return;
var uid = ninja.Katana.Value;
if (!TryComp<EnergyKatanaComponent>(uid, out var katana) || !_hands.IsHolding(user, uid, out var _))
{
_popups.PopupEntity(Loc.GetString("ninja-katana-not-held"), user, user);
return;
}
if (katana.Charges <= 0)
{
_popups.PopupEntity(Loc.GetString("emag-no-charges"), user, user);
return;
}
// TODO: check that target is not dense
var origin = Transform(user).MapPosition;
var target = args.Target.ToMap(EntityManager, _transform);
// prevent collision with the user duh
if (!_interaction.InRangeUnobstructed(origin, target, 0f, CollisionGroup.Opaque, uid => uid == user))
{
// can only dash if the destination is visible on screen
_popups.PopupEntity(Loc.GetString("ninja-katana-cant-see"), user, user);
return;
}
_transform.SetCoordinates(user, args.Target);
_transform.AttachToGridOrMap(user);
_audio.PlayPvs(katana.BlinkSound, user, AudioParams.Default.WithVolume(katana.BlinkVolume));
// TODO: show the funny green man thing
ChangeCharge(uid, -1, false, katana);
}
/// <summary>
/// Changes the charge on an energy katana.
/// </summary>
public bool ChangeCharge(EntityUid uid, int change, bool resetTimer, EnergyKatanaComponent? katana = null)
{
if (!Resolve(uid, ref katana))
return false;
if (katana.Charges + change < 0 || katana.Charges + change > katana.MaxCharges)
return false;
if (resetTimer || katana.Charges == katana.MaxCharges)
katana.NextChargeTime = _timing.CurTime + katana.RechargeDuration;
katana.Charges += change;
Dirty(katana);
return true;
}
}

314
Content.Shared/Ninja/Systems/NinjaGlovesSystem.cs Normal file
View File

@@ -0,0 +1,314 @@
using Content.Shared.Actions;
using Content.Shared.Administration.Logs;
using Content.Shared.CombatMode;
using Content.Shared.Damage.Components;
using Content.Shared.Database;
using Content.Shared.Doors.Components;
using Content.Shared.DoAfter;
using Content.Shared.Electrocution;
using Content.Shared.Emag.Systems;
using Content.Shared.Examine;
using Content.Shared.Hands.Components;
using Content.Shared.IdentityManagement;
using Content.Shared.Interaction;
using Content.Shared.Interaction.Components;
using Content.Shared.Interaction.Events;
using Content.Shared.Inventory.Events;
using Content.Shared.Ninja.Components;
using Content.Shared.Popups;
using Content.Shared.Research.Components;
using Content.Shared.Tag;
using Content.Shared.Timing;
using Content.Shared.Toggleable;
using Robust.Shared.Network;
using Robust.Shared.Timing;
using System.Diagnostics.CodeAnalysis;
namespace Content.Shared.Ninja.Systems;
public abstract class SharedNinjaGlovesSystem : EntitySystem
{
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
[Dependency] private readonly SharedCombatModeSystem _combatMode = default!;
[Dependency] protected readonly SharedDoAfterSystem _doAfter = default!;
[Dependency] private readonly SharedElectrocutionSystem _electrocution = default!;
[Dependency] private readonly EmagSystem _emag = default!;
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
[Dependency] private readonly INetManager _net = default!;
[Dependency] private readonly SharedNinjaSystem _ninja = default!;
[Dependency] private readonly SharedPopupSystem _popups = default!;
[Dependency] private readonly TagSystem _tags = default!;
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly UseDelaySystem _useDelay = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<NinjaGlovesComponent, GetItemActionsEvent>(OnGetItemActions);
SubscribeLocalEvent<NinjaGlovesComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<NinjaGlovesComponent, ToggleActionEvent>(OnToggleAction);
SubscribeLocalEvent<NinjaGlovesComponent, GotUnequippedEvent>(OnUnequipped);
SubscribeLocalEvent<NinjaDoorjackComponent, InteractionAttemptEvent>(OnDoorjack);
SubscribeLocalEvent<NinjaStunComponent, InteractionAttemptEvent>(OnStun);
SubscribeLocalEvent<NinjaDrainComponent, InteractionAttemptEvent>(OnDrain);
SubscribeLocalEvent<NinjaDrainComponent, DrainDoAfterEvent>(OnDrainDoAfter);
SubscribeLocalEvent<NinjaDownloadComponent, InteractionAttemptEvent>(OnDownload);
SubscribeLocalEvent<NinjaDownloadComponent, DownloadDoAfterEvent>(OnDownloadDoAfter);
SubscribeLocalEvent<NinjaTerrorComponent, InteractionAttemptEvent>(OnTerror);
SubscribeLocalEvent<NinjaTerrorComponent, TerrorDoAfterEvent>(OnTerrorDoAfter);
}
/// <summary>
/// Disable glove abilities and show the popup if they were enabled previously.
/// </summary>
public void DisableGloves(NinjaGlovesComponent comp, EntityUid user)
{
if (comp.User != null)
{
comp.User = null;
_popups.PopupEntity(Loc.GetString("ninja-gloves-off"), user, user);
}
}
private void OnGetItemActions(EntityUid uid, NinjaGlovesComponent comp, GetItemActionsEvent args)
{
args.Actions.Add(comp.ToggleAction);
}
private void OnToggleAction(EntityUid uid, NinjaGlovesComponent comp, ToggleActionEvent args)
{
// client prediction desyncs it hard
if (args.Handled || !_timing.IsFirstTimePredicted)
return;
args.Handled = true;
var user = args.Performer;
// need to wear suit to enable gloves
if (!TryComp<NinjaComponent>(user, out var ninja)
|| ninja.Suit == null
|| !HasComp<NinjaSuitComponent>(ninja.Suit.Value))
{
ClientPopup(Loc.GetString("ninja-gloves-not-wearing-suit"), user);
return;
}
var enabling = comp.User == null;
var message = Loc.GetString(enabling ? "ninja-gloves-on" : "ninja-gloves-off");
ClientPopup(message, user);
if (enabling)
{
comp.User = user;
_ninja.AssignGloves(ninja, uid);
// set up interaction relay for handling glove abilities, comp.User is used to see the actual user of the events
_interaction.SetRelay(user, uid, EnsureComp<InteractionRelayComponent>(user));
}
else
{
comp.User = null;
_ninja.AssignGloves(ninja, null);
RemComp<InteractionRelayComponent>(user);
}
}
private void OnExamined(EntityUid uid, NinjaGlovesComponent comp, ExaminedEvent args)
{
if (!args.IsInDetailsRange)
return;
args.PushText(Loc.GetString(comp.User != null ? "ninja-gloves-examine-on" : "ninja-gloves-examine-off"));
}
private void OnUnequipped(EntityUid uid, NinjaGlovesComponent comp, GotUnequippedEvent args)
{
comp.User = null;
if (TryComp<NinjaComponent>(args.Equipee, out var ninja))
_ninja.AssignGloves(ninja, null);
}
/// <summary>
/// Helper for glove ability handlers, checks gloves, range, combat mode and stuff.
/// </summary>
protected bool GloveCheck(EntityUid uid, InteractionAttemptEvent args, [NotNullWhen(true)] out NinjaGlovesComponent? gloves,
out EntityUid user, out EntityUid target)
{
if (args.Target != null && TryComp<NinjaGlovesComponent>(uid, out gloves)
&& gloves.User != null
&& !_combatMode.IsInCombatMode(gloves.User)
&& _timing.IsFirstTimePredicted
&& TryComp<HandsComponent>(gloves.User, out var hands)
&& hands.ActiveHandEntity == null)
{
user = gloves.User.Value;
target = args.Target.Value;
if (_interaction.InRangeUnobstructed(user, target))
return true;
}
gloves = null;
user = target = EntityUid.Invalid;
return false;
}
private void OnDoorjack(EntityUid uid, NinjaDoorjackComponent comp, InteractionAttemptEvent args)
{
if (!GloveCheck(uid, args, out var gloves, out var user, out var target))
return;
// only allowed to emag non-immune doors
if (!HasComp<DoorComponent>(target) || _tags.HasTag(target, comp.EmagImmuneTag))
return;
var handled = _emag.DoEmagEffect(user, target);
if (!handled)
return;
ClientPopup(Loc.GetString("ninja-doorjack-success", ("target", Identity.Entity(target, EntityManager))), user, PopupType.Medium);
_adminLogger.Add(LogType.Emag, LogImpact.High, $"{ToPrettyString(user):player} doorjacked {ToPrettyString(target):target}");
}
private void OnStun(EntityUid uid, NinjaStunComponent comp, InteractionAttemptEvent args)
{
if (!GloveCheck(uid, args, out var gloves, out var user, out var target))
return;
// short cooldown to prevent instant stunlocking
if (_useDelay.ActiveDelay(uid))
return;
// battery can't be predicted since it's serverside
if (user == target || _net.IsClient || !HasComp<StaminaComponent>(target))
return;
// take charge from battery
if (!_ninja.TryUseCharge(user, comp.StunCharge))
{
_popups.PopupEntity(Loc.GetString("ninja-no-power"), user, user);
return;
}
// not holding hands with target so insuls don't matter
_electrocution.TryDoElectrocution(target, uid, comp.StunDamage, comp.StunTime, false, ignoreInsulation: true);
_useDelay.BeginDelay(uid);
}
// can't predict PNBC existing so only done on server.
protected virtual void OnDrain(EntityUid uid, NinjaDrainComponent comp, InteractionAttemptEvent args) { }
private void OnDrainDoAfter(EntityUid uid, NinjaDrainComponent comp, DrainDoAfterEvent args)
{
if (args.Cancelled || args.Handled || args.Target == null)
return;
_ninja.TryDrainPower(args.User, comp, args.Target.Value);
}
private void OnDownload(EntityUid uid, NinjaDownloadComponent comp, InteractionAttemptEvent args)
{
if (!GloveCheck(uid, args, out var gloves, out var user, out var target))
return;
// can only hack the server, not a random console
if (!TryComp<TechnologyDatabaseComponent>(target, out var database) || HasComp<ResearchClientComponent>(target))
return;
// fail fast if theres no tech right now
if (database.TechnologyIds.Count == 0)
{
ClientPopup(Loc.GetString("ninja-download-fail"), user);
return;
}
var doAfterArgs = new DoAfterArgs(user, comp.DownloadTime, new DownloadDoAfterEvent(), target: target, used: uid, eventTarget: uid)
{
BreakOnDamage = true,
BreakOnUserMove = true,
MovementThreshold = 0.5f,
CancelDuplicate = false
};
_doAfter.TryStartDoAfter(doAfterArgs);
args.Cancel();
}
private void OnDownloadDoAfter(EntityUid uid, NinjaDownloadComponent comp, DownloadDoAfterEvent args)
{
if (args.Cancelled || args.Handled)
return;
var user = args.User;
var target = args.Target;
if (!TryComp<NinjaComponent>(user, out var ninja)
|| !TryComp<TechnologyDatabaseComponent>(target, out var database))
return;
var gained = _ninja.Download(ninja, database.TechnologyIds);
var str = gained == 0
? Loc.GetString("ninja-download-fail")
: Loc.GetString("ninja-download-success", ("count", gained), ("server", target));
_popups.PopupEntity(str, user, user, PopupType.Medium);
}
private void OnTerror(EntityUid uid, NinjaTerrorComponent comp, InteractionAttemptEvent args)
{
if (!GloveCheck(uid, args, out var gloves, out var user, out var target)
|| !TryComp<NinjaComponent>(user, out var ninja))
return;
if (!IsCommsConsole(target))
return;
// can only do it once
if (ninja.CalledInThreat)
{
_popups.PopupEntity(Loc.GetString("ninja-terror-already-called"), user, user);
return;
}
var doAfterArgs = new DoAfterArgs(user, comp.TerrorTime, new TerrorDoAfterEvent(), target: target, used: uid, eventTarget: uid)
{
BreakOnDamage = true,
BreakOnUserMove = true,
MovementThreshold = 0.5f,
CancelDuplicate = false
};
_doAfter.TryStartDoAfter(doAfterArgs);
// FIXME: doesnt work, don't show the console popup
args.Cancel();
}
//for some reason shared comms console component isn't a component, so this has to be done server-side
protected virtual bool IsCommsConsole(EntityUid uid)
{
return false;
}
private void OnTerrorDoAfter(EntityUid uid, NinjaTerrorComponent comp, TerrorDoAfterEvent args)
{
if (args.Cancelled || args.Handled)
return;
var user = args.User;
if (!TryComp<NinjaComponent>(user, out var ninja) || ninja.CalledInThreat)
return;
_ninja.CallInThreat(ninja);
}
private void ClientPopup(string msg, EntityUid user, PopupType type = PopupType.Small)
{
if (_net.IsClient)
_popups.PopupEntity(msg, user, user, type);
}
}

151
Content.Shared/Ninja/Systems/NinjaSuitSystem.cs Normal file
View File

@@ -0,0 +1,151 @@
using Content.Shared.Actions;
using Content.Shared.Inventory.Events;
using Content.Shared.Ninja.Components;
using Content.Shared.Stealth;
using Content.Shared.Stealth.Components;
using Content.Shared.Timing;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
namespace Content.Shared.Ninja.Systems;
public abstract class SharedNinjaSuitSystem : EntitySystem
{
[Dependency] private readonly SharedNinjaGlovesSystem _gloves = default!;
[Dependency] protected readonly SharedNinjaSystem _ninja = default!;
[Dependency] private readonly SharedStealthSystem _stealth = default!;
[Dependency] protected readonly UseDelaySystem _useDelay = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<NinjaSuitComponent, GotEquippedEvent>(OnEquipped);
SubscribeLocalEvent<NinjaSuitComponent, GetItemActionsEvent>(OnGetItemActions);
SubscribeLocalEvent<NinjaSuitComponent, GotUnequippedEvent>(OnUnequipped);
SubscribeNetworkEvent<SetCloakedMessage>(OnSetCloakedMessage);
}
private void OnEquipped(EntityUid uid, NinjaSuitComponent comp, GotEquippedEvent args)
{
var user = args.Equipee;
if (!TryComp<NinjaComponent>(user, out var ninja))
return;
NinjaEquippedSuit(uid, comp, user, ninja);
}
private void OnGetItemActions(EntityUid uid, NinjaSuitComponent comp, GetItemActionsEvent args)
{
args.Actions.Add(comp.TogglePhaseCloakAction);
args.Actions.Add(comp.RecallKatanaAction);
// TODO: ninja stars instead of soap, when embedding is a thing
// The cooldown should also be reduced from 10 to 1 or so
args.Actions.Add(comp.CreateSoapAction);
args.Actions.Add(comp.KatanaDashAction);
args.Actions.Add(comp.EmpAction);
}
private void OnUnequipped(EntityUid uid, NinjaSuitComponent comp, GotUnequippedEvent args)
{
UserUnequippedSuit(uid, comp, args.Equipee);
}
/// <summary>
/// Called when a suit is equipped by a space ninja.
/// In the future it might be changed to an explicit activation toggle/verb like gloves are.
/// </summary>
protected virtual void NinjaEquippedSuit(EntityUid uid, NinjaSuitComponent comp, EntityUid user, NinjaComponent ninja)
{
// mark the user as wearing this suit, used when being attacked among other things
_ninja.AssignSuit(ninja, uid);
// initialize phase cloak
EnsureComp<StealthComponent>(user);
SetCloaked(user, comp.Cloaked);
}
/// <summary>
/// Force uncloak the user, disables suit abilities if the bool is set.
/// </summary>
public void RevealNinja(EntityUid uid, NinjaSuitComponent comp, EntityUid user, bool disableAbilities = false)
{
if (comp.Cloaked)
{
comp.Cloaked = false;
SetCloaked(user, false);
// TODO: add the box open thing its funny
if (disableAbilities)
_useDelay.BeginDelay(uid);
}
}
/// <summary>
/// Returns the power used by a suit
/// </summary>
public float SuitWattage(NinjaSuitComponent suit)
{
float wattage = suit.PassiveWattage;
if (suit.Cloaked)
wattage += suit.CloakWattage;
return wattage;
}
/// <summary>
/// Sets the stealth effect for a ninja cloaking.
/// Does not update suit Cloaked field, has to be done yourself.
/// </summary>
protected void SetCloaked(EntityUid user, bool cloaked)
{
if (!TryComp<StealthComponent>(user, out var stealth) || stealth.Deleted)
return;
// slightly visible, but doesn't change when moving so it's ok
var visibility = cloaked ? stealth.MinVisibility + 0.25f : stealth.MaxVisibility;
_stealth.SetVisibility(user, visibility, stealth);
_stealth.SetEnabled(user, cloaked, stealth);
}
/// <summary>
/// Called when a suit is unequipped, not necessarily by a space ninja.
/// In the future it might be changed to also have explicit deactivation via toggle.
/// </summary>
protected virtual void UserUnequippedSuit(EntityUid uid, NinjaSuitComponent comp, EntityUid user)
{
// mark the user as not wearing a suit
if (TryComp<NinjaComponent>(user, out var ninja))
{
_ninja.AssignSuit(ninja, null);
// disable glove abilities
if (ninja.Gloves != null && TryComp<NinjaGlovesComponent>(ninja.Gloves.Value, out var gloves))
_gloves.DisableGloves(gloves, user);
}
// force uncloak the user
comp.Cloaked = false;
SetCloaked(user, false);
RemComp<StealthComponent>(user);
}
private void OnSetCloakedMessage(SetCloakedMessage msg)
{
if (TryComp<NinjaComponent>(msg.User, out var ninja) && TryComp<NinjaSuitComponent>(ninja.Suit, out var suit))
{
suit.Cloaked = msg.Cloaked;
SetCloaked(msg.User, msg.Cloaked);
}
}
}
/// <summary>
/// Calls SetCloaked on the client from the server, along with updating the suit Cloaked bool.
/// </summary>
[Serializable, NetSerializable]
public sealed class SetCloakedMessage : EntityEventArgs
{
public EntityUid User;
public bool Cloaked;
}

101
Content.Shared/Ninja/Systems/NinjaSystem.cs Normal file
View File

@@ -0,0 +1,101 @@
using Content.Shared.Ninja.Components;
using Content.Shared.Weapons.Melee.Events;
using Robust.Shared.GameStates;
using Robust.Shared.Network;
namespace Content.Shared.Ninja.Systems;
public abstract class SharedNinjaSystem : EntitySystem
{
[Dependency] protected readonly SharedNinjaSuitSystem _suit = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<NinjaComponent, AttackedEvent>(OnNinjaAttacked);
}
/// <summary>
/// Sets the station grid entity that the ninja was spawned near.
/// </summary>
public void SetStationGrid(NinjaComponent comp, EntityUid? grid)
{
comp.StationGrid = grid;
}
/// <summary>
/// Set the ninja's worn suit entity
/// </summary>
public void AssignSuit(NinjaComponent comp, EntityUid? suit)
{
comp.Suit = suit;
}
/// <summary>
/// Set the ninja's worn gloves entity
/// </summary>
public void AssignGloves(NinjaComponent comp, EntityUid? gloves)
{
comp.Gloves = gloves;
}
/// <summary>
/// Bind a katana entity to a ninja, letting it be recalled and dash.
/// </summary>
public void BindKatana(NinjaComponent comp, EntityUid? katana)
{
comp.Katana = katana;
}
// TODO: remove when objective stuff moved into objectives somehow
public void DetonateSpiderCharge(NinjaComponent comp)
{
comp.SpiderChargeDetonated = true;
}
/// <summary>
/// Marks the objective as complete.
/// On server, makes announcement and adds rule of random threat.
/// </summary>
public virtual void CallInThreat(NinjaComponent comp)
{
comp.CalledInThreat = true;
}
/// <summary>
/// Drain power from a target battery into the ninja's suit battery.
/// Serverside only.
/// </summary>
public virtual void TryDrainPower(EntityUid user, NinjaDrainComponent drain, EntityUid target)
{
}
/// <summary>
/// Download the given set of nodes, returning how many new nodes were downloaded.'
/// </summary>
public int Download(NinjaComponent ninja, List<string> ids)
{
var oldCount = ninja.DownloadedNodes.Count;
ninja.DownloadedNodes.UnionWith(ids);
var newCount = ninja.DownloadedNodes.Count;
return newCount - oldCount;
}
/// <summary>
/// Gets the user's battery and tries to use some charge from it, returning true if successful.
/// Serverside only.
/// </summary>
public virtual bool TryUseCharge(EntityUid user, float charge)
{
return false;
}
private void OnNinjaAttacked(EntityUid uid, NinjaComponent comp, AttackedEvent args)
{
if (comp.Suit != null && TryComp<NinjaSuitComponent>(comp.Suit, out var suit) && suit.Cloaked)
{
_suit.RevealNinja(comp.Suit.Value, suit, uid, true);
}
}
}