item toggling giga rework + full ninja refactor (#28039)

* item toggle refactoring and some new systems

* add ToggleClothing component/system

* unhardcode magboots gravity logic

* make magboots and speedboots use ItemToggle and stuff

* remove now useless clothing components

* update client/server magboots systems

* add note to use ItemToggledEvent in ToggleActionEvent doc

* refactor PowerCellDraw to use ItemToggle for ui open/close control

* add TryUseCharges, refactor charges system

* update magboot trigger code

* make borg use ItemToggle, network SelectedModule instead of now removed Activated

* add AccessToggle for borg

* the giga ninja refactor

* update ninja yml

* update ItemToggle usage for some stuff

* fix activatableui requires power

* random fixing

* yaml fixing

* nuke ItemToggleDisarmMalus

* make defib use ItemToggle

* make things that use power not turn on if missing use charge

* pro

* fix sound prediction

* bruh

* proximity detector use ItemToggle

* oop

* big idiot syndrome

* fix ninja spawn rule and make it generic

* fix ninja spawn rule yml

* move loading profiles into AntagLoadProfileRule

* more ninja refactor

* ninja yml fixes

* the dreaded copy paste ops

* remove useless NinjaRuleComponent and ue AntagSelection for greeting

* fix invisibility

* move IsCompleted to SharedObjectivesSystem

* ability fixes

* oop fix powercell instantly draining itself

* sentient speedboots gaming

* make reflect use ItemToggle

* fix other test

* loadprofilerule moved into its own pr

* remove conflict with dragon refactor

* remove all GenericAntag code from ninja

* )

* probably

* remove old enabled

* great language bravo vince

* GREAT LANGUAGE

* who made this language

* because it stinks

* reparent blood-red magboots to magboots probbbly works

* most of the review stuff

* hasGrav doesnt mean what i thought it did

* make health analyzer use itemtoggle, not fail test

* fix mag/speed boots being wacky

* UNTROLL

* add ItemToggle to the random health analyzers

* a

* remove unused obsolete borg func

* untrolling

* :trollface:

* fix test

* fix

* g

* untroll

---------

Co-authored-by: deltanedas <@deltanedas:kde.org>
This commit is contained in:
deltanedas
2024-07-11 05:55:56 +00:00
committed by GitHub
parent e45f55e36d
commit 02636386b5
121 changed files with 1629 additions and 2014 deletions

View File

@@ -1,11 +1,14 @@
using Content.Shared.Actions;
using Content.Shared.Clothing;
using Content.Shared.Clothing.Components;
using Content.Shared.Clothing.EntitySystems;
using Content.Shared.Inventory.Events;
using Content.Shared.Item.ItemToggle;
using Content.Shared.Item.ItemToggle.Components;
using Content.Shared.Ninja.Components;
using Content.Shared.Popups;
using Content.Shared.Timing;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Shared.Ninja.Systems;
@@ -14,137 +17,158 @@ namespace Content.Shared.Ninja.Systems;
/// </summary>
public abstract class SharedNinjaSuitSystem : EntitySystem
{
[Dependency] protected readonly IGameTiming GameTiming = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedNinjaGlovesSystem _gloves = default!;
[Dependency] private readonly SharedSpaceNinjaSystem _ninja = default!;
[Dependency] private readonly ActionContainerSystem _actionContainer = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly ItemToggleSystem _toggle = default!;
[Dependency] protected readonly SharedPopupSystem Popup = default!;
[Dependency] protected readonly StealthClothingSystem StealthClothing = default!;
[Dependency] private readonly SharedSpaceNinjaSystem _ninja = default!;
[Dependency] private readonly UseDelaySystem _useDelay = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<NinjaSuitComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<NinjaSuitComponent, GotEquippedEvent>(OnEquipped);
SubscribeLocalEvent<NinjaSuitComponent, ClothingGotEquippedEvent>(OnEquipped);
SubscribeLocalEvent<NinjaSuitComponent, GetItemActionsEvent>(OnGetItemActions);
SubscribeLocalEvent<NinjaSuitComponent, AddStealthActionEvent>(OnAddStealthAction);
SubscribeLocalEvent<NinjaSuitComponent, ToggleClothingCheckEvent>(OnCloakCheck);
SubscribeLocalEvent<NinjaSuitComponent, CheckItemCreatorEvent>(OnStarCheck);
SubscribeLocalEvent<NinjaSuitComponent, CreateItemAttemptEvent>(OnCreateStarAttempt);
SubscribeLocalEvent<NinjaSuitComponent, ItemToggleActivateAttemptEvent>(OnActivateAttempt);
SubscribeLocalEvent<NinjaSuitComponent, GotUnequippedEvent>(OnUnequipped);
}
private void OnMapInit(EntityUid uid, NinjaSuitComponent component, MapInitEvent args)
private void OnEquipped(Entity<NinjaSuitComponent> ent, ref ClothingGotEquippedEvent args)
{
_actionContainer.EnsureAction(uid, ref component.RecallKatanaActionEntity, component.RecallKatanaAction);
_actionContainer.EnsureAction(uid, ref component.CreateThrowingStarActionEntity, component.CreateThrowingStarAction);
_actionContainer.EnsureAction(uid, ref component.EmpActionEntity, component.EmpAction);
Dirty(uid, component);
var user = args.Wearer;
if (_ninja.NinjaQuery.TryComp(user, out var ninja))
NinjaEquipped(ent, (user, ninja));
}
/// <summary>
/// Call the shared and serverside code for when a ninja equips the suit.
/// </summary>
private void OnEquipped(EntityUid uid, NinjaSuitComponent comp, GotEquippedEvent args)
protected virtual void NinjaEquipped(Entity<NinjaSuitComponent> ent, Entity<SpaceNinjaComponent> user)
{
var user = args.Equipee;
if (!TryComp<SpaceNinjaComponent>(user, out var ninja))
return;
// mark the user as wearing this suit, used when being attacked among other things
_ninja.AssignSuit(user, ent);
}
NinjaEquippedSuit(uid, comp, user, ninja);
private void OnMapInit(Entity<NinjaSuitComponent> ent, ref MapInitEvent args)
{
var (uid, comp) = ent;
_actionContainer.EnsureAction(uid, ref comp.RecallKatanaActionEntity, comp.RecallKatanaAction);
_actionContainer.EnsureAction(uid, ref comp.EmpActionEntity, comp.EmpAction);
Dirty(uid, comp);
}
/// <summary>
/// Add all the actions when a suit is equipped by a ninja.
/// </summary>
private void OnGetItemActions(EntityUid uid, NinjaSuitComponent comp, GetItemActionsEvent args)
private void OnGetItemActions(Entity<NinjaSuitComponent> ent, ref GetItemActionsEvent args)
{
if (!HasComp<SpaceNinjaComponent>(args.User))
if (!_ninja.IsNinja(args.User))
return;
var comp = ent.Comp;
args.AddAction(ref comp.RecallKatanaActionEntity, comp.RecallKatanaAction);
args.AddAction(ref comp.CreateThrowingStarActionEntity, comp.CreateThrowingStarAction);
args.AddAction(ref comp.EmpActionEntity, comp.EmpAction);
}
/// <summary>
/// Only add stealth clothing's toggle action when equipped by a ninja.
/// Only add toggle cloak action when equipped by a ninja.
/// </summary>
private void OnAddStealthAction(EntityUid uid, NinjaSuitComponent comp, AddStealthActionEvent args)
private void OnCloakCheck(Entity<NinjaSuitComponent> ent, ref ToggleClothingCheckEvent args)
{
if (!HasComp<SpaceNinjaComponent>(args.User))
args.Cancel();
if (!_ninja.IsNinja(args.User))
args.Cancelled = true;
}
private void OnStarCheck(Entity<NinjaSuitComponent> ent, ref CheckItemCreatorEvent args)
{
if (!_ninja.IsNinja(args.User))
args.Cancelled = true;
}
private void OnCreateStarAttempt(Entity<NinjaSuitComponent> ent, ref CreateItemAttemptEvent args)
{
if (CheckDisabled(ent, args.User))
args.Cancelled = true;
}
/// <summary>
/// Call the shared and serverside code for when anyone unequips a suit.
/// </summary>
private void OnUnequipped(EntityUid uid, NinjaSuitComponent comp, GotUnequippedEvent args)
private void OnUnequipped(Entity<NinjaSuitComponent> ent, ref 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, SpaceNinjaComponent ninja)
{
// mark the user as wearing this suit, used when being attacked among other things
_ninja.AssignSuit(user, uid, ninja);
// initialize phase cloak, but keep it off
StealthClothing.SetEnabled(uid, user, false);
var user = args.Equipee;
if (_ninja.NinjaQuery.TryComp(user, out var ninja))
UserUnequippedSuit(ent, (user, ninja));
}
/// <summary>
/// Force uncloaks the user and disables suit abilities.
/// </summary>
public void RevealNinja(EntityUid uid, EntityUid user, bool disable = true, NinjaSuitComponent? comp = null, StealthClothingComponent? stealthClothing = null)
public void RevealNinja(Entity<NinjaSuitComponent?> ent, EntityUid user, bool disable = true)
{
if (!Resolve(uid, ref comp, ref stealthClothing))
if (!Resolve(ent, ref ent.Comp))
return;
if (!StealthClothing.SetEnabled(uid, user, false, stealthClothing))
return;
if (!disable)
var uid = ent.Owner;
var comp = ent.Comp;
if (_toggle.TryDeactivate(uid, user) || !disable)
return;
// previously cloaked, disable abilities for a short time
_audio.PlayPredicted(comp.RevealSound, uid, user);
Popup.PopupClient(Loc.GetString("ninja-revealed"), user, user, PopupType.MediumCaution);
comp.DisableCooldown = GameTiming.CurTime + comp.DisableTime;
_useDelay.TryResetDelay(uid, id: comp.DisableDelayId);
}
// TODO: modify PowerCellDrain
/// <summary>
/// Returns the power used by a suit
/// </summary>
public float SuitWattage(EntityUid uid, NinjaSuitComponent? suit = null)
private void OnActivateAttempt(Entity<NinjaSuitComponent> ent, ref ItemToggleActivateAttemptEvent args)
{
if (!Resolve(uid, ref suit))
return 0f;
if (!_ninja.IsNinja(args.User))
{
args.Cancelled = true;
return;
}
float wattage = suit.PassiveWattage;
if (TryComp<StealthClothingComponent>(uid, out var stealthClothing) && stealthClothing.Enabled)
wattage += suit.CloakWattage;
return wattage;
if (IsDisabled((ent, ent.Comp, null)))
{
args.Cancelled = true;
args.Popup = Loc.GetString("ninja-suit-cooldown");
}
}
/// <summary>
/// Returns true if the suit is currently disabled
/// </summary>
public bool IsDisabled(Entity<NinjaSuitComponent?, UseDelayComponent?> ent)
{
if (!Resolve(ent, ref ent.Comp1, ref ent.Comp2))
return false;
return _useDelay.IsDelayed((ent, ent.Comp2), ent.Comp1.DisableDelayId);
}
protected bool CheckDisabled(Entity<NinjaSuitComponent> ent, EntityUid user)
{
if (IsDisabled((ent, ent.Comp, null)))
{
Popup.PopupEntity(Loc.GetString("ninja-suit-cooldown"), user, user, PopupType.Medium);
return true;
}
return false;
}
/// <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)
protected virtual void UserUnequippedSuit(Entity<NinjaSuitComponent> ent, Entity<SpaceNinjaComponent> user)
{
if (!TryComp<SpaceNinjaComponent>(user, out var ninja))
return;
// mark the user as not wearing a suit
_ninja.AssignSuit(user, null, ninja);
_ninja.AssignSuit(user, null);
// disable glove abilities
if (ninja.Gloves != null && TryComp<NinjaGlovesComponent>(ninja.Gloves.Value, out var gloves))
_gloves.DisableGloves(ninja.Gloves.Value, gloves);
if (user.Comp.Gloves is {} uid)
_toggle.TryDeactivate(uid, user: user);
}
}