Модуль похоти киборга

Content.Client/Lobby/LobbyUIController.cs

@@ -565,6 +565,21 @@ public EntityUid LoadProfileEntity(HumanoidCharacterProfile? humanoid, JobProtot
         {
             // Special type like borg or AI, do not spawn a human just spawn the entity.
             dummyEnt = EntityManager.SpawnEntity(previewEntity, MapCoordinates.Nullspace);
+
+            // Lust-start
+            // У синтов тоже могут быть лоадауты, брух
+            if (humanoid != null && job != null && jobClothes)
+            {
+                GiveDummyJobClothes(dummyEnt, humanoid, job);
+
+                if (_prototypeManager.HasIndex<RoleLoadoutPrototype>(LoadoutSystem.GetJobPrototype(job.ID)))
+                {
+                    var loadout = humanoid.GetLoadoutOrDefault(LoadoutSystem.GetJobPrototype(job.ID), _playerManager.LocalSession, humanoid.Species, EntityManager, _prototypeManager, sponsorPrototypes);
+                    GiveDummyLoadout(dummyEnt, loadout, jobClothes);
+                }
+            }
+            // Lust-end
+
             return dummyEnt;
         }
         else if (humanoid is not null)

Content.Server/Station/Systems/StationSpawningSystem.cs

@@ -27,6 +27,8 @@
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
 using Content.Sunrise.Interfaces.Shared;
+using Content.Shared.Clothing.Components;
+using Content.Server._Lust.Silicons.Borgs;
 
 namespace Content.Server.Station.Systems;
 
@@ -145,6 +147,14 @@ public EntityUid SpawnPlayerMob(
             // Make sure custom names get handled, what is gameticker control flow whoopy.
             if (loadout != null)
             {
+                // Lust-start
+                EquipRoleLoadout(jobEntity, loadout, roleProto!);
+                if (prototype.StartingGear is not null)
+                {
+                    var startingGear = _prototypeManager.Index<StartingGearPrototype>(prototype.StartingGear);
+                    EquipStartingGear(jobEntity, startingGear, raiseEvent: false);
+                }
+                // Lust-end
                 EquipRoleName(jobEntity, loadout, roleProto!);
             }
 

Content.Server/_Lust/Borgs/BorgModuleInnateComponent.cs

@@ -0,0 +1,44 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._Lust.Silicons.Borgs;
+
+/// <summary>
+/// Компонент, позволяющий давать боргам действия (экшены) и компоненты через модуль
+/// </summary>
+[RegisterComponent]
+public sealed partial class BorgModuleInnateComponent : Component
+{
+    /// <summary>
+    /// Предметы, которые активируются прямо в руке
+    /// </summary>
+    [DataField]
+    public List<EntProtoId?> UseItems = new();
+
+    /// <summary>
+    /// Предметы, с помощью которых можно взаимодействовать с сущностями
+    /// </summary>
+    [DataField]
+    public List<EntProtoId?> InteractionItems = new();
+
+    /// <summary>
+    /// Компоненты, которые будут добавлены боргу при установке модуля
+    /// Будут удалены после его изъятия!
+    /// </summary>
+    [DataField]
+    public ComponentRegistry InnateComponents = new();
+
+    /// <summary>
+    /// Айди добавленных предметов этим модулем
+    /// Данный список нужен сугубо для корректной очистки
+    /// </summary>
+    [ViewVariables, Access(typeof(BorgModuleInnateSystem))]
+    public List<EntityUid> InnateItems = new();
+
+    /// <summary>
+    /// Экшены для борга, созданные данным модулем
+    /// Данный список нужен сугубо для корректной очистки
+    /// </summary>
+    [ViewVariables, Access(typeof(BorgModuleInnateSystem))]
+    public List<EntityUid> Actions = new();
+}

Content.Server/_Lust/Borgs/BorgModuleInnateSystem.cs

@@ -0,0 +1,214 @@
+using Content.Shared._Lust.Silicons.Borgs;
+using Content.Shared.Actions;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Silicons.Borgs.Components;
+using Content.Shared.UserInterface;
+using Robust.Shared.Containers;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Server._Lust.Silicons.Borgs;
+
+/// <summary>
+/// Система выдачи встраиваемых предметов и компонентов через модуль.
+/// </summary>
+public sealed class BorgModuleInnateSystem : EntitySystem
+{
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
+    [Dependency] private readonly ActionContainerSystem _actionContainer = default!;
+    [Dependency] private readonly SharedContainerSystem _containers = default!;
+    [Dependency] private readonly MetaDataSystem _metadata = default!;
+    [Dependency] private readonly SharedInteractionSystem _interactions = default!;
+
+    // Название контейнера-хранилища встроенных предметов
+    private const string InnateItemsContainerId = "module_innate_items";
+
+    // Прототипы действий над предметами
+    private static readonly EntProtoId InnateUseItemAction = "ModuleInnateUseItemAction";
+    private static readonly EntProtoId InnateInteractionItemAction = "ModuleInnateInteractionItemAction";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<BorgModuleInnateComponent, BorgModuleInstalledEvent>(OnInstalled);
+        SubscribeLocalEvent<BorgModuleInnateComponent, BorgModuleUninstalledEvent>(OnUninstalled);
+
+        SubscribeLocalEvent<BorgModuleInnateComponent, ModuleInnateUseItem>(OnInnateUseItem);
+        SubscribeLocalEvent<BorgModuleInnateComponent, ModuleInnateInteractionItem>(OnInnateInteractionItem);
+    }
+
+    /// <summary>
+    /// Добавляет нужные компоненты и предметы при "установке" модуля
+    /// </summary>
+    private void OnInstalled(Entity<BorgModuleInnateComponent> module, ref BorgModuleInstalledEvent args)
+    {
+        var containerManager = EnsureComp<ContainerManagerComponent>(args.ChassisEnt);
+        _containers.EnsureContainer<Container>(args.ChassisEnt, InnateItemsContainerId, containerManager);
+
+        EntityManager.AddComponents(args.ChassisEnt, module.Comp.InnateComponents);
+
+        if (!_containers.TryGetContainer(args.ChassisEnt, InnateItemsContainerId, out var container))
+            return;
+
+        AddItems(args.ChassisEnt, module, container);
+    }
+
+    /// <summary>
+    /// Удаляет нужные компоненты и предметы при "удалении" модуля
+    /// </summary>
+    private void OnUninstalled(Entity<BorgModuleInnateComponent> module, ref BorgModuleUninstalledEvent args)
+    {
+        foreach (var action in module.Comp.Actions)
+        {
+            _actions.RemoveAction(args.ChassisEnt, action);
+            QueueDel(action);
+        }
+        foreach (var item in module.Comp.InnateItems)
+            QueueDel(item);
+
+        module.Comp.Actions.Clear();
+        module.Comp.InnateItems.Clear();
+
+        EntityManager.RemoveComponents(args.ChassisEnt, module.Comp.InnateComponents);
+    }
+
+    /// <summary>
+    /// Добавляет предметы в контейнер, а также создаёт экшены их активации в модуле для тела киборга
+    /// </summary>
+    private void AddItems(EntityUid chassis, Entity<BorgModuleInnateComponent> module, BaseContainer container)
+    {
+        foreach (var itemProto in module.Comp.UseItems)
+        {
+            if (itemProto is null)
+                continue;
+
+            AddUseItem(itemProto.Value, chassis, module, container);
+        }
+
+        foreach (var itemProto in module.Comp.InteractionItems)
+        {
+            if (itemProto is null)
+                continue;
+
+            AddInteractionItem(itemProto.Value, chassis, module, container);
+        }
+    }
+
+    /// <summary>
+    /// Добавляет предмет, который активируется в руке, вместе с экшеном для его активации
+    /// </summary>
+    private void AddUseItem(
+        EntProtoId itemProto,
+        EntityUid chassis,
+        Entity<BorgModuleInnateComponent> module,
+        BaseContainer container
+    )
+    {
+        var item = CreateInnateItem(itemProto, module, container);
+        var ev = new ModuleInnateUseItem(item);
+        var action = CreateAction(item, ev, InnateUseItemAction);
+        AssignAction(chassis, module, action);
+    }
+
+    /// <summary>
+    /// Добавляет предмет, который активируется выбором цели, вместе с экшеном для его активации
+    /// </summary>
+    private void AddInteractionItem(
+        EntProtoId itemProto,
+        EntityUid chassis,
+        Entity<BorgModuleInnateComponent> module,
+        BaseContainer container
+    )
+    {
+        var item = CreateInnateItem(itemProto, module, container);
+        var ev = new ModuleInnateInteractionItem(item);
+        var action = CreateAction(item, ev, InnateInteractionItemAction);
+        AssignAction(chassis, module, action);
+    }
+
+    /// <summary>
+    /// Создает предмет для использования через экшены согласно прототипу в заданном контейнере
+    /// </summary>
+    /// <returns>Сущность предмета</returns>
+    private EntityUid CreateInnateItem(
+        EntProtoId itemProto,
+        Entity<BorgModuleInnateComponent> module,
+        BaseContainer container
+    )
+    {
+        var item = Spawn(itemProto);
+        module.Comp.InnateItems.Add(item);
+
+        // Модифицируем компач юай, чтобы борг наверняка мог его использовать
+        if (TryComp<ActivatableUIComponent>(item, out var activatableUIComponent))
+        {
+            activatableUIComponent.RequiresComplex = false;
+            activatableUIComponent.InHandsOnly = false;
+            activatableUIComponent.RequireActiveHand = false;
+            Dirty(item, activatableUIComponent);
+        }
+
+        // Сохраняем его в контейнере предметов модуля
+        _containers.Insert(item, container);
+
+        return item;
+    }
+
+    /// <summary>
+    /// Согласно прототипу и событию создает экшен для активации данной сущности-предмета
+    /// </summary>
+    /// <returns>Сущность экшена</returns>
+    private EntityUid CreateAction(EntityUid item, BaseActionEvent assignedEvent, EntProtoId actionProto)
+    {
+        var actionEnt = Spawn(actionProto);
+        // Подгружаем спрайт для экшена из прото предмета
+        _actions.SetIcon(actionEnt, new SpriteSpecifier.EntityPrototype(MetaData(item).EntityPrototype!.ID));
+        // Заготовка события для экшена
+        _actions.SetEvent(actionEnt, assignedEvent);
+
+        // Даем экшену название и описание предмета
+        _metadata.SetEntityName(actionEnt, MetaData(item).EntityName);
+        _metadata.SetEntityDescription(actionEnt, MetaData(item).EntityDescription);
+        return actionEnt;
+    }
+
+    /// <summary>
+    /// Добавляет экшен в шасси и сохраняет его в контейнере модуля
+    /// </summary>
+    private void AssignAction(EntityUid chassis, Entity<BorgModuleInnateComponent> module, EntityUid action)
+    {
+        // Добавляем экшн в список экшенов и в список компача
+        _actionContainer.AddAction(module.Owner, action);
+        _actions.AddAction(chassis, action, module.Owner);
+        module.Comp.Actions.Add(action);
+    }
+
+    /// <summary>
+    /// Обработчик события использования предмета как будто он в руке
+    /// </summary>
+    private void OnInnateUseItem(Entity<BorgModuleInnateComponent> ent, ref ModuleInnateUseItem args)
+    {
+        var ev = new UseInHandEvent(args.Performer);
+        RaiseLocalEvent(args.Item, ev);
+        args.Handled = true;
+    }
+
+    /// <summary>
+    /// Обработчик события использования предмета на заданной цели
+    /// </summary>
+    private void OnInnateInteractionItem(Entity<BorgModuleInnateComponent> ent, ref ModuleInnateInteractionItem args)
+    {
+        _interactions.InteractUsing(
+            args.Performer,
+            args.Item,
+            args.Target,
+            Transform(args.Target).Coordinates,
+            false,
+            false,
+            false
+        );
+        args.Handled = true;
+    }
+}

Content.Server/_Sunrise/InteractionsPanel/InteractionsPanel.Interactions.cs

@@ -43,6 +43,7 @@ private void InitializeInteractions()
 
         SubscribeLocalEvent<InteractionsComponent, GetVerbsEvent<AlternativeVerb>>(AddInteractionsVerb);
         SubscribeLocalEvent<InteractionsComponent, ComponentInit>(OnInteractionsComponentInit);
+        SubscribeLocalEvent<InteractionsComponent, ComponentRemove>(OnInteractionsComponentRemove);
 
         SubscribeLocalEvent<InteractionsComponent, ClothingDidEquippedEvent>(ClothingDidEquipped);
         SubscribeLocalEvent<InteractionsComponent, ClothingDidUnequippedEvent>(ClothingDidUnequipped);
@@ -174,6 +175,11 @@ private void OnInteractionsComponentInit(EntityUid uid, InteractionsComponent co
         _ui.SetUi(uid, InteractionWindowUiKey.Key, interfaceData);
     }
 
+    private void OnInteractionsComponentRemove(Entity<InteractionsComponent> ent, ref ComponentRemove args)
+    {
+        _ui.CloseUi(ent.Owner, InteractionWindowUiKey.Key);
+    }
+
     private void OnInteractionMessageReceived(Entity<InteractionsComponent> ent, ref InteractionMessage args)
     {
         var target = ent.Comp.CurrentTarget;
@@ -579,6 +585,9 @@ private void AddInteractionsVerb(Entity<InteractionsComponent> ent, ref GetVerbs
         if (!TryComp<UserInterfaceComponent>(args.User, out var interfaceComponent))
             return;
 
+        if (!HasComp<InteractionsComponent>(args.User))
+            return;
+
         if (_mobState.IsIncapacitated(args.Target) || _mobState.IsIncapacitated(args.User))
             return;
 

Content.Shared/Preferences/Loadouts/LoadoutPrototype.cs

@@ -50,6 +50,10 @@ public sealed partial class LoadoutPrototype : IPrototype, IEquipmentLoadout
     [DataField]
     public Dictionary<string, List<EntProtoId>> Storage { get; set; } = new();
 
+    /// <inheritdoc />
+    [DataField]
+    public Dictionary<string, List<EntProtoId>> Container { get; set; } = new();
+
     // Sunrise-Sponsors-Start
     [DataField]
     public bool SponsorOnly;

Content.Shared/Roles/StartingGearPrototype.cs

@@ -33,6 +33,11 @@ public sealed partial class StartingGearPrototype : IPrototype, IInheritingProto
     [DataField]
     [AlwaysPushInheritance]
     public Dictionary<string, List<EntProtoId>> Storage { get; set; } = new();
+
+    /// <inheritdoc />
+    [DataField]
+    [AlwaysPushInheritance]
+    public Dictionary<string, List<EntProtoId>> Container { get; set; } = new();
 }
 
 /// <summary>
@@ -55,6 +60,12 @@ public interface IEquipmentLoadout
     /// </summary>
     public Dictionary<string, List<EntProtoId>> Storage { get; set; }
 
+    /// <summary>
+    /// Inserts entities into the specified container.
+    /// </summary>
+    public Dictionary<string, List<EntProtoId>> Container { get; set; }
+
+
     /// <summary>
     /// Gets the entity prototype ID of a slot in this starting gear.
     /// </summary>