Команда для отправки цели для станции (#21)

* Команда для отправки цели для станции

* Правки

(cherry picked from commit 93a79c4952e3a75c32ff5cc4d07df4018a9bf7db)

Content.Server/_White/_Engi/StationGoalCommand/StationGoalCommand.cs

@@ -0,0 +1,66 @@
+using System.Linq;
+using Content.Server.Administration;
+using Content.Server.Commands;
+using Content.Shared.Administration;
+using Robust.Shared.Console;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._White._Engi.StationGoal
+{
+    [AdminCommand(AdminFlags.Fun)]
+    public sealed class StationGoalCommand : IConsoleCommand
+    {
+        [Dependency] private readonly IEntityManager _entManager = default!;
+
+        public string Command => "sendstationgoal";
+        public string Description => Loc.GetString("send-station-goal-command-description");
+        public string Help => Loc.GetString("send-station-goal-command-help-text", ("command", Command));
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            if (args.Length != 2)
+            {
+                shell.WriteError(Loc.GetString("shell-wrong-arguments-number"));
+                return;
+            }
+
+            if (!NetEntity.TryParse(args[0], out var euidNet) || !_entManager.TryGetEntity(euidNet, out var euid))
+            {
+                shell.WriteError($"Failed to parse euid '{args[0]}'.");
+                return;
+            }
+
+            var protoId = args[1];
+            var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
+            if (!prototypeManager.TryIndex<StationGoalPrototype>(protoId, out var proto))
+            {
+                shell.WriteError($"No station goal found with ID {protoId}!");
+                return;
+            }
+
+            var stationGoalPaper = IoCManager.Resolve<IEntityManager>().System<StationGoalPaperSystem>();
+            if (!stationGoalPaper.SendStationGoal(euid, protoId))
+            {
+                shell.WriteError("Station goal was not sent");
+                return;
+            }
+        }
+
+        public CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+        {
+            switch (args.Length)
+            {
+                case 1:
+                    var stations = ContentCompletionHelper.StationIds(_entManager);
+                    return CompletionResult.FromHintOptions(stations, "[StationId]");
+                case 2:
+                    var options = IoCManager.Resolve<IPrototypeManager>()
+                        .EnumeratePrototypes<StationGoalPrototype>()
+                        .Select(p => new CompletionOption(p.ID));
+
+                    return CompletionResult.FromHintOptions(options, Loc.GetString("send-station-goal-command-arg-id"));
+            }
+            return CompletionResult.Empty;
+        }
+    }
+}

Content.Server/_White/_Engi/StationGoalCommand/StationGoalComponent.cs

@@ -0,0 +1,15 @@
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._White._Engi.StationGoal
+{
+    /// <summary>
+    /// WD ENGI EXCLUSIVE.
+    /// If attached to a station prototype, will send the station a random goal from the list.
+    /// </summary>
+    [RegisterComponent]
+    public sealed partial class StationGoalComponent : Component
+    {
+        [DataField]
+        public List<ProtoId<StationGoalPrototype>> Goals = new();
+    }
+}

Content.Server/_White/_Engi/StationGoalCommand/StationGoalPaperComponent.cs

@@ -0,0 +1,11 @@
+namespace Content.Server._White._Engi.StationGoal
+{
+    /// <summary>
+    /// WD ENGI EXCLUSIVE.
+    /// Paper with a written station goal in it.
+    /// </summary>
+    [RegisterComponent]
+    public sealed partial class StationGoalPaperComponent : Component
+    {
+    }
+}

Content.Server/_White/_Engi/StationGoalCommand/StationGoalPaperSystem.cs

@@ -0,0 +1,133 @@
+using Content.Server.Fax;
+using Content.Server.GameTicking.Events;
+using Content.Server.Station.Components;
+using Content.Server.Station.Systems;
+using Content.Shared.Fax.Components;
+using Content.Shared.Paper;
+using Robust.Server.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Content.Server.RandomMetadata;
+
+namespace Content.Server._White._Engi.StationGoal
+{
+    /// <summary>
+    /// WD ENGI EXCLUSIVE.
+    /// System to spawn paper with station goal.
+    /// </summary>
+    public sealed class StationGoalPaperSystem : EntitySystem
+    {
+        [Dependency] private readonly IPrototypeManager _proto = default!;
+        [Dependency] private readonly IRobustRandom _random = default!;
+        [Dependency] private readonly FaxSystem _fax = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly StationSystem _station = default!;
+        [Dependency] private readonly RandomMetadataSystem _randomMeta = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<RoundStartingEvent>(OnRoundStarting);
+        }
+
+        private void OnRoundStarting(RoundStartingEvent ev)
+        {
+            var playerCount = _playerManager.PlayerCount;
+
+            var query = EntityQueryEnumerator<StationGoalComponent>();
+            while (query.MoveNext(out var uid, out var station))
+            {
+                var tempGoals = new List<ProtoId<StationGoalPrototype>>(station.Goals);
+                StationGoalPrototype? selGoal = null;
+                while (tempGoals.Count > 0)
+                {
+                    var goalId = _random.Pick(tempGoals);
+                    var goalProto = _proto.Index(goalId);
+
+                    if (playerCount > goalProto.MaxPlayers ||
+                        playerCount < goalProto.MinPlayers)
+                    {
+                        tempGoals.Remove(goalId);
+                        continue;
+                    }
+
+                    selGoal = goalProto;
+                    break;
+                }
+
+                if (selGoal is null)
+                    return;
+
+                if (SendStationGoal(uid, selGoal))
+                {
+                    Log.Info($"Goal {selGoal.ID} has been sent to station {MetaData(uid).EntityName}");
+                }
+            }
+        }
+
+        public bool SendStationGoal(EntityUid? ent, ProtoId<StationGoalPrototype> goal)
+        {
+            return SendStationGoal(ent, _proto.Index(goal));
+        }
+
+        /// <summary>
+        /// WD ENGI EXCLUSIVE.
+        /// Send a station goal on selected station to all faxes which are authorized to receive it.
+        /// </summary>
+        /// <returns>True if at least one fax received paper</returns>
+        public bool SendStationGoal(EntityUid? ent, StationGoalPrototype goal)
+        {
+            if (ent is null)
+                return false;
+
+            if (!TryComp<StationDataComponent>(ent, out var stationData))
+                return false;
+
+            var today = DateTime.Today.ToString("dd.MM");
+            var namesList = new List<string>
+            {
+                "names_first_male",
+                "names_last_male"
+            };
+            var operatorName = _randomMeta.GetRandomFromSegments(namesList, " ");
+
+            var faxContent = Loc.GetString("engi-station-goal-form",
+            ("station", MetaData(ent.Value).EntityName),
+            ("date", today),
+            ("operator", operatorName),
+            ("text", Loc.GetString(goal.Text)));
+
+            var printout = new FaxPrintout(
+                faxContent,
+                Loc.GetString("engi-station-goal-fax-paper-name"),
+                null,
+                null,
+                "paper_stamp-centcom",
+                new List<StampDisplayInfo>
+                {
+                    new() { StampedName = Loc.GetString("stamp-component-stamped-name-centcom"), StampedColor = Color.FromHex("#006600") },
+                });
+
+            var wasSent = false;
+            var query = EntityQueryEnumerator<FaxMachineComponent>();
+            while (query.MoveNext(out var faxUid, out var fax))
+            {
+                if (!fax.ReceiveStationGoal)
+                    continue;
+
+                var largestGrid = _station.GetLargestGrid(stationData);
+                var grid = Transform(faxUid).GridUid;
+                if (grid is not null && largestGrid == grid.Value)
+                {
+                    _fax.Receive(faxUid, printout, null, fax);
+                    foreach (var spawnEnt in goal.Spawns)
+                    {
+                        SpawnAtPosition(spawnEnt, Transform(faxUid).Coordinates);
+                    }
+                    wasSent = true;
+                }
+            }
+            return wasSent;
+        }
+    }
+}

Content.Server/_White/_Engi/StationGoalCommand/StationGoalPrototype.cs

@@ -0,0 +1,29 @@
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._White._Engi.StationGoal
+{
+    /// <summary>
+    /// WD ENGI EXCLUSIVE.
+    /// </summary>
+    [Serializable, Prototype("stationGoal")]
+    public sealed class StationGoalPrototype : IPrototype
+    {
+        [IdDataField]
+        public string ID { get; } = default!;
+
+        [DataField]
+        public string Text { get; set; } = string.Empty;
+
+        [DataField]
+        public int? MinPlayers;
+
+        [DataField]
+        public int? MaxPlayers;
+
+        /// <summary>
+        /// Goal may require certain items to complete. These items will appear near the receving fax machine at the start of the round.
+        /// </summary>
+        [DataField]
+        public List<EntProtoId> Spawns = new();
+    }
+}