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

[Revert] Reverts Ninja (#15516)

Browse Source 
* Revert "[Antag] add space ninja as midround antag (#14069)"

This reverts commit c1cda0dbf8.

* Revert "[Fix] move ninja objectives into NinjaRole (#15490)"

This reverts commit 251f429fb3.
This commit is contained in:
keronshb
2023-04-19 03:43:09 -04:00
committed by GitHub
parent 6161f7d5f3
commit ac87effca0
81 changed files with 20 additions and 2742 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
Content.Server/Ninja/Systems/NinjaGlovesSystem.cs
View File

@@ -1,92 +0,0 @@
using Content.Server.Communications;
using Content.Server.DoAfter;
using Content.Server.Ninja.Systems;
using Content.Server.Power.Components;
using Content.Shared.DoAfter;
using Content.Shared.Interaction.Events;
using Content.Shared.Ninja.Components;
using Content.Shared.Ninja.Systems;
using Content.Shared.Popups;
using Content.Shared.Research.Components;
namespace Content.Server.Ninja.Systems;
public sealed class NinjaGlovesSystem : SharedNinjaGlovesSystem
{
[Dependency] private readonly new NinjaSystem _ninja = default!;
protected override void OnDrain(EntityUid uid, NinjaDrainComponent comp, InteractionAttemptEvent args)
{
if (!GloveCheck(uid, args, out var gloves, out var user, out var target)
|| !HasComp<PowerNetworkBatteryComponent>(target))
return;
// nicer for spam-clicking to not open apc ui, and when draining starts, so cancel the ui action
args.Cancel();
var doAfterArgs = new DoAfterArgs(user, comp.DrainTime, new DrainDoAfterEvent(), target: target, used: uid, eventTarget: uid)
{
BreakOnUserMove = true,
MovementThreshold = 0.5f,
CancelDuplicate = false
};
_doAfter.TryStartDoAfter(doAfterArgs);
}
protected override 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(uid, 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);
}
protected override void OnTerror(EntityUid uid, NinjaTerrorComponent comp, InteractionAttemptEvent args)
{
if (!GloveCheck(uid, args, out var gloves, out var user, out var target)
|| !_ninja.GetNinjaRole(user, out var role)
|| !HasComp<CommunicationsConsoleComponent>(target))
return;
// can only do it once
if (role.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();
}
protected override void OnTerrorDoAfter(EntityUid uid, NinjaTerrorComponent comp, TerrorDoAfterEvent args)
{
if (args.Cancelled || args.Handled)
return;
_ninja.CallInThreat(args.User);
}
}

148
Content.Server/Ninja/Systems/NinjaSuitSystem.cs
View File

@@ -1,148 +0,0 @@
using Content.Server.Emp;
using Content.Server.Popups;
using Content.Server.Power.Components;
using Content.Server.PowerCell;
using Content.Shared.Actions;
using Content.Shared.Examine;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Ninja.Components;
using Content.Shared.Ninja.Systems;
using Content.Shared.Popups;
using Robust.Shared.Containers;
namespace Content.Server.Ninja.Systems;
public sealed class NinjaSuitSystem : SharedNinjaSuitSystem
{
[Dependency] private readonly EmpSystem _emp = default!;
[Dependency] private readonly SharedHandsSystem _hands = default!;
[Dependency] private readonly new NinjaSystem _ninja = default!;
[Dependency] private readonly PopupSystem _popups = default!;
[Dependency] private readonly PowerCellSystem _powerCell = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
base.Initialize();
// TODO: maybe have suit activation stuff
SubscribeLocalEvent<NinjaSuitComponent, ContainerIsInsertingAttemptEvent>(OnSuitInsertAttempt);
SubscribeLocalEvent<NinjaSuitComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<NinjaSuitComponent, TogglePhaseCloakEvent>(OnTogglePhaseCloak);
SubscribeLocalEvent<NinjaSuitComponent, CreateSoapEvent>(OnCreateSoap);
SubscribeLocalEvent<NinjaSuitComponent, RecallKatanaEvent>(OnRecallKatana);
SubscribeLocalEvent<NinjaSuitComponent, NinjaEmpEvent>(OnEmp);
}
protected override void NinjaEquippedSuit(EntityUid uid, NinjaSuitComponent comp, EntityUid user, NinjaComponent ninja)
{
base.NinjaEquippedSuit(uid, comp, user, ninja);
_ninja.SetSuitPowerAlert(user);
}
// TODO: if/when battery is in shared, put this there too
private void OnSuitInsertAttempt(EntityUid uid, NinjaSuitComponent comp, ContainerIsInsertingAttemptEvent args)
{
// no power cell for some reason??? allow it
if (!_powerCell.TryGetBatteryFromSlot(uid, out var battery))
return;
// can only upgrade power cell, not swap to recharge instantly otherwise ninja could just swap batteries with flashlights in maints for easy power
if (!TryComp<BatteryComponent>(args.EntityUid, out var inserting) || inserting.MaxCharge <= battery.MaxCharge)
{
args.Cancel();
}
}
private void OnExamined(EntityUid uid, NinjaSuitComponent comp, ExaminedEvent args)
{
// TODO: make this also return the uid of the battery
if (_powerCell.TryGetBatteryFromSlot(uid, out var battery))
RaiseLocalEvent(battery.Owner, args);
}
protected override void UserUnequippedSuit(EntityUid uid, NinjaSuitComponent comp, EntityUid user)
{
base.UserUnequippedSuit(uid, comp, user);
// remove power indicator
_ninja.SetSuitPowerAlert(user);
}
private void OnTogglePhaseCloak(EntityUid uid, NinjaSuitComponent comp, TogglePhaseCloakEvent args)
{
args.Handled = true;
var user = args.Performer;
// need 1 second of charge to turn on stealth
var chargeNeeded = SuitWattage(comp);
if (!comp.Cloaked && (!_ninja.GetNinjaBattery(user, out var battery) || battery.CurrentCharge < chargeNeeded || _useDelay.ActiveDelay(uid)))
{
_popups.PopupEntity(Loc.GetString("ninja-no-power"), user, user);
return;
}
comp.Cloaked = !comp.Cloaked;
SetCloaked(args.Performer, comp.Cloaked);
RaiseNetworkEvent(new SetCloakedMessage()
{
User = user,
Cloaked = comp.Cloaked
});
}
private void OnCreateSoap(EntityUid uid, NinjaSuitComponent comp, CreateSoapEvent args)
{
args.Handled = true;
var user = args.Performer;
if (!_ninja.TryUseCharge(user, comp.SoapCharge) || _useDelay.ActiveDelay(uid))
{
_popups.PopupEntity(Loc.GetString("ninja-no-power"), user, user);
return;
}
// try to put soap in hand, otherwise it goes on the ground
var soap = Spawn(comp.SoapPrototype, Transform(user).Coordinates);
_hands.TryPickupAnyHand(user, soap);
}
private void OnRecallKatana(EntityUid uid, NinjaSuitComponent comp, RecallKatanaEvent args)
{
args.Handled = true;
var user = args.Performer;
if (!TryComp<NinjaComponent>(user, out var ninja) || ninja.Katana == null)
return;
// 1% charge per tile
var katana = ninja.Katana.Value;
var coords = _transform.GetWorldPosition(katana);
var distance = (_transform.GetWorldPosition(user) - coords).Length;
var chargeNeeded = (float) distance * 3.6f;
if (!_ninja.TryUseCharge(user, chargeNeeded) || _useDelay.ActiveDelay(uid))
{
_popups.PopupEntity(Loc.GetString("ninja-no-power"), user, user);
return;
}
// TODO: teleporting into belt slot
var message = _hands.TryPickupAnyHand(user, katana)
? "ninja-katana-recalled"
: "ninja-hands-full";
_popups.PopupEntity(Loc.GetString(message), user, user);
}
private void OnEmp(EntityUid uid, NinjaSuitComponent comp, NinjaEmpEvent args)
{
args.Handled = true;
var user = args.Performer;
if (!_ninja.TryUseCharge(user, comp.EmpCharge) || _useDelay.ActiveDelay(uid))
{
_popups.PopupEntity(Loc.GetString("ninja-no-power"), user, user);
return;
}
// I don't think this affects the suit battery, but if it ever does in the future add a blacklist for it
var coords = Transform(user).MapPosition;
_emp.EmpPulse(coords, comp.EmpRange, comp.EmpConsumption);
}
}

364
Content.Server/Ninja/Systems/NinjaSystem.cs
View File

@@ -1,364 +0,0 @@
using Content.Server.Administration.Commands;
using Content.Server.Body.Systems;
using Content.Server.Chat.Managers;
using Content.Server.Chat.Systems;
using Content.Server.Doors.Systems;
using Content.Server.GameTicking;
using Content.Server.GameTicking.Rules;
using Content.Server.GameTicking.Rules.Configurations;
using Content.Server.Ghost.Roles.Events;
using Content.Server.Mind.Components;
using Content.Server.Ninja;
using Content.Server.Ninja.Components;
using Content.Server.Objectives;
using Content.Server.Popups;
using Content.Server.Power.Components;
using Content.Server.PowerCell;
using Content.Server.Warps;
using Content.Shared.Alert;
using Content.Shared.Doors.Components;
using Content.Shared.Implants;
using Content.Shared.Implants.Components;
using Content.Shared.Ninja.Components;
using Content.Shared.Ninja.Systems;
using Content.Shared.Roles;
using Content.Shared.Popups;
using Content.Shared.PowerCell.Components;
using Content.Shared.Rounding;
using Robust.Shared.Audio;
using Robust.Shared.GameObjects;
using Robust.Shared.Physics.Components;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
namespace Content.Server.Ninja.Systems;
public sealed class NinjaSystem : SharedNinjaSystem
{
[Dependency] private readonly AlertsSystem _alerts = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly ChatSystem _chat = default!;
[Dependency] private readonly IChatManager _chatMan = default!;
[Dependency] private readonly GameTicker _gameTicker = default!;
[Dependency] private readonly SharedSubdermalImplantSystem _implants = default!;
[Dependency] private readonly InternalsSystem _internals = default!;
[Dependency] private readonly IPrototypeManager _proto = default!;
[Dependency] private readonly PopupSystem _popups = default!;
[Dependency] private readonly PowerCellSystem _powerCell = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly TraitorRuleSystem _traitorRule = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<NinjaComponent, ComponentStartup>(OnNinjaStartup);
SubscribeLocalEvent<NinjaComponent, GhostRoleSpawnerUsedEvent>(OnNinjaSpawned);
SubscribeLocalEvent<NinjaComponent, MindAddedMessage>(OnNinjaMindAdded);
SubscribeLocalEvent<DoorComponent, DoorEmaggedEvent>(OnDoorEmagged);
}
public override void Update(float frameTime)
{
var query = EntityQueryEnumerator<NinjaComponent>();
while (query.MoveNext(out var uid, out var ninja))
{
UpdateNinja(uid, ninja, frameTime);
}
}
/// <summary>
/// Turns the player into a space ninja
/// </summary>
public void MakeNinja(Mind.Mind mind)
{
if (mind.OwnedEntity == null)
return;
// prevent double ninja'ing
var user = mind.OwnedEntity.Value;
if (HasComp<NinjaComponent>(user))
return;
AddComp<NinjaComponent>(user);
SetOutfitCommand.SetOutfit(user, "SpaceNinjaGear", EntityManager);
GreetNinja(mind);
}
/// <summary>
/// Download the given set of nodes, returning how many new nodes were downloaded.'
/// </summary>
public int Download(EntityUid uid, List<string> ids)
{
if (!GetNinjaRole(uid, out var role))
return 0;
var oldCount = role.DownloadedNodes.Count;
role.DownloadedNodes.UnionWith(ids);
var newCount = role.DownloadedNodes.Count;
return newCount - oldCount;
}
/// <summary>
/// Gets a ninja's role using the player's mind
/// </summary>
public static bool GetNinjaRole(Mind.Mind? mind, [NotNullWhen(true)] out NinjaRole? role)
{
if (mind == null)
{
role = null;
return false;
}
role = (NinjaRole?) mind.AllRoles
.Where(r => r is NinjaRole)
.FirstOrDefault();
return role != null;
}
/// <summary>
/// Gets a ninja's role using the player's entity id
/// </summary>
public bool GetNinjaRole(EntityUid uid, [NotNullWhen(true)] out NinjaRole? role)
{
role = null;
if (!TryComp<MindComponent>(uid, out var mind))
return false;
return GetNinjaRole(mind.Mind, out role);
}
/// <summary>
/// Returns the space ninja spawn gamerule's config
/// </summary>
public NinjaRuleConfiguration RuleConfig()
{
return (NinjaRuleConfiguration) _proto.Index<GameRulePrototype>("SpaceNinjaSpawn").Configuration;
}
/// <summary>
/// Update the alert for the ninja's suit power indicator.
/// </summary>
public void SetSuitPowerAlert(EntityUid uid, NinjaComponent? comp = null)
{
if (!Resolve(uid, ref comp, false) || comp.Deleted || comp.Suit == null)
{
_alerts.ClearAlert(uid, AlertType.SuitPower);
return;
}
if (GetNinjaBattery(uid, out var battery))
{
var severity = ContentHelpers.RoundToLevels(MathF.Max(0f, battery.CurrentCharge), battery.MaxCharge, 7);
_alerts.ShowAlert(uid, AlertType.SuitPower, (short) severity);
}
else
{
_alerts.ClearAlert(uid, AlertType.SuitPower);
}
}
/// <summary>
/// Set the station grid on an entity, either ninja spawner or the ninja itself.
/// Used to tell a ghost that takes ninja role where the station is.
/// </summary>
public void SetNinjaStationGrid(EntityUid uid, EntityUid grid)
{
var station = EnsureComp<NinjaStationGridComponent>(uid);
station.Grid = grid;
}
/// <summary>
/// Get the battery component in a ninja's suit, if it's worn.
/// </summary>
public bool GetNinjaBattery(EntityUid user, [NotNullWhen(true)] out BatteryComponent? battery)
{
if (TryComp<NinjaComponent>(user, out var ninja)
&& ninja.Suit != null
&& _powerCell.TryGetBatteryFromSlot(ninja.Suit.Value, out battery))
{
return true;
}
battery = null;
return false;
}
public override bool TryUseCharge(EntityUid user, float charge)
{
return GetNinjaBattery(user, out var battery) && battery.TryUseCharge(charge);
}
/// <summary>
/// Completes the objective, makes announcement and adds rule of a random threat.
/// </summary>
public void CallInThreat(EntityUid uid)
{
var config = RuleConfig();
if (config.Threats.Count == 0 || !GetNinjaRole(uid, out var role) || role.CalledInThreat)
return;
role.CalledInThreat = true;
var threat = _random.Pick(config.Threats);
if (_proto.TryIndex<GameRulePrototype>(threat.Rule, out var rule))
{
_gameTicker.AddGameRule(rule);
_chat.DispatchGlobalAnnouncement(Loc.GetString(threat.Announcement), playSound: false, colorOverride: Color.Red);
}
else
{
Logger.Error($"Threat gamerule does not exist: {threat.Rule}");
}
}
public override void TryDrainPower(EntityUid user, NinjaDrainComponent drain, EntityUid target)
{
if (!GetNinjaBattery(user, out var suitBattery))
// took suit off or something, ignore draining
return;
if (!TryComp<BatteryComponent>(target, out var battery) || !TryComp<PowerNetworkBatteryComponent>(target, out var pnb))
return;
if (suitBattery.IsFullyCharged)
{
_popups.PopupEntity(Loc.GetString("ninja-drain-full"), user, user, PopupType.Medium);
return;
}
if (MathHelper.CloseToPercent(battery.CurrentCharge, 0))
{
_popups.PopupEntity(Loc.GetString("ninja-drain-empty", ("battery", target)), user, user, PopupType.Medium);
return;
}
var available = battery.CurrentCharge;
var required = suitBattery.MaxCharge - suitBattery.CurrentCharge;
// higher tier storages can charge more
var maxDrained = pnb.MaxSupply * drain.DrainTime;
var input = Math.Min(Math.Min(available, required / drain.DrainEfficiency), maxDrained);
if (battery.TryUseCharge(input))
{
var output = input * drain.DrainEfficiency;
suitBattery.CurrentCharge += output;
_popups.PopupEntity(Loc.GetString("ninja-drain-success", ("battery", target)), user, user);
// TODO: spark effects
_audio.PlayPvs(drain.SparkSound, target);
}
}
private void OnNinjaStartup(EntityUid uid, NinjaComponent comp, ComponentStartup args)
{
var config = RuleConfig();
// start with internals on, only when spawned by event. antag control ninja won't do this due to component add order.
_internals.ToggleInternals(uid, uid, true);
// inject starting implants
var coords = Transform(uid).Coordinates;
foreach (var id in config.Implants)
{
var implant = Spawn(id, coords);
if (!TryComp<SubdermalImplantComponent>(implant, out var implantComp))
return;
_implants.ForceImplant(uid, implant, implantComp);
}
}
private void OnNinjaSpawned(EntityUid uid, NinjaComponent comp, GhostRoleSpawnerUsedEvent args)
{
// inherit spawner's station grid
if (TryComp<NinjaStationGridComponent>(args.Spawner, out var station))
SetNinjaStationGrid(uid, station.Grid);
}
private void OnNinjaMindAdded(EntityUid uid, NinjaComponent comp, MindAddedMessage args)
{
Logger.ErrorS("ninja_testing", "AMONG US 2 RELASED");
if (TryComp<MindComponent>(uid, out var mind) && mind.Mind != null)
GreetNinja(mind.Mind);
}
private void GreetNinja(Mind.Mind mind)
{
Logger.ErrorS("ninja_testing", "GREETING");
if (!mind.TryGetSession(out var session))
return;
var config = RuleConfig();
var role = new NinjaRole(mind, _proto.Index<AntagPrototype>("SpaceNinja"));
mind.AddRole(role);
_traitorRule.Traitors.Add(role);
foreach (var objective in config.Objectives)
{
AddObjective(mind, objective);
}
Logger.ErrorS("ninja_testing", "added role");
// choose spider charge detonation point
// currently based on warp points, something better could be done (but would likely require mapping work)
var warps = new List<EntityUid>();
var query = EntityQueryEnumerator<WarpPointComponent>();
while (query.MoveNext(out var warpUid, out var warp))
{
// won't be asked to detonate the nuke disk or singularity
if (warp.Location != null && !HasComp<PhysicsComponent>(warpUid))
warps.Add(warpUid);
}
if (warps.Count > 0)
role.SpiderChargeTarget = _random.Pick(warps);
_audio.PlayGlobal(config.GreetingSound, Filter.Empty().AddPlayer(session), false, AudioParams.Default);
_chatMan.DispatchServerMessage(session, Loc.GetString("ninja-role-greeting"));
if (TryComp<NinjaStationGridComponent>(mind.OwnedEntity, out var station))
{
var gridPos = _transform.GetWorldPosition(station.Grid);
var ninjaPos = _transform.GetWorldPosition(mind.OwnedEntity.Value);
var vector = gridPos - ninjaPos;
var direction = vector.GetDir();
var position = $"({(int) gridPos.X}, {(int) gridPos.Y})";
var msg = Loc.GetString("ninja-role-greeting-direction", ("direction", direction), ("position", position));
_chatMan.DispatchServerMessage(session, msg);
}
}
private void OnDoorEmagged(EntityUid uid, DoorComponent door, ref DoorEmaggedEvent args)
{
// make sure it's a ninja doorjacking it
if (GetNinjaRole(args.UserUid, out var role))
role.DoorsJacked++;
}
private void UpdateNinja(EntityUid uid, NinjaComponent ninja, float frameTime)
{
if (ninja.Suit == null || !TryComp<NinjaSuitComponent>(ninja.Suit, out var suit))
return;
float wattage = _suit.SuitWattage(suit);
SetSuitPowerAlert(uid, ninja);
if (!TryUseCharge(uid, wattage * frameTime))
{
// ran out of power, reveal ninja
_suit.RevealNinja(ninja.Suit.Value, suit, uid);
}
}
private void AddObjective(Mind.Mind mind, string name)
{
if (_proto.TryIndex<ObjectivePrototype>(name, out var objective))
mind.TryAddObjective(objective);
else
Logger.Error($"Ninja has unknown objective prototype: {name}");
}
}

63
Content.Server/Ninja/Systems/SpiderChargeSystem.cs
View File

@@ -1,63 +0,0 @@
using Content.Server.Explosion.EntitySystems;
using Content.Server.Sticky.Events;
using Content.Server.Popups;
using Content.Shared.Interaction;
using Content.Shared.Ninja.Components;
using Robust.Shared.GameObjects;
namespace Content.Server.Ninja.Systems;
public sealed class SpiderChargeSystem : EntitySystem
{
[Dependency] private readonly NinjaSystem _ninja = default!;
[Dependency] private readonly PopupSystem _popups = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<SpiderChargeComponent, BeforeRangedInteractEvent>(BeforePlant);
SubscribeLocalEvent<SpiderChargeComponent, EntityStuckEvent>(OnStuck);
SubscribeLocalEvent<SpiderChargeComponent, TriggerEvent>(OnExplode);
}
private void BeforePlant(EntityUid uid, SpiderChargeComponent comp, BeforeRangedInteractEvent args)
{
var user = args.User;
if (!_ninja.GetNinjaRole(user, out var role))
{
_popups.PopupEntity(Loc.GetString("spider-charge-not-ninja"), user, user);
args.Handled = true;
return;
}
// allow planting anywhere if there is no target, which should never happen
if (role.SpiderChargeTarget == null)
return;
// assumes warp point still exists
var target = Transform(role.SpiderChargeTarget.Value).MapPosition;
var coords = args.ClickLocation.ToMap(EntityManager, _transform);
if (!coords.InRange(target, comp.Range))
{
_popups.PopupEntity(Loc.GetString("spider-charge-too-far"), user, user);
args.Handled = true;
}
}
private void OnStuck(EntityUid uid, SpiderChargeComponent comp, EntityStuckEvent args)
{
comp.Planter = args.User;
}
private void OnExplode(EntityUid uid, SpiderChargeComponent comp, TriggerEvent args)
{
if (comp.Planter == null || !_ninja.GetNinjaRole(comp.Planter.Value, out var role))
return;
// assumes the target was destroyed, that the charge wasn't moved somehow
role.SpiderChargeDetonated = true;
}
}