CatStation/Content.Server/Cloning/CloningSystem.Subscriptions.cs

using Content.Shared.Body.Components;
using Content.Server.Atmos.EntitySystems;
using Content.Shared.Atmos.Components;
using Content.Shared.Body.Systems;
using Content.Shared.Cloning.Events;
using Content.Shared.Clothing.Components;
using Content.Shared.Clothing.EntitySystems;
using Content.Shared.Damage.Components;
using Content.Shared.Damage.Systems;
using Content.Shared.FixedPoint;
using Content.Shared.Forensics.Components;
using Content.Shared.Forensics.Systems;
using Content.Shared.Inventory;
using Content.Shared.Labels.Components;
using Content.Shared.Labels.EntitySystems;
using Content.Shared.Movement.Components;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Pulling.Systems;
using Content.Shared.Movement.Systems;
using Content.Shared.Nutrition.Components;
using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Paper;
using Content.Shared.Speech.Components;
using Content.Shared.Speech.EntitySystems;
using Content.Shared.Stacks;
using Content.Shared.Storage;
using Content.Shared.Store;
using Content.Shared.Store.Components;
using Robust.Shared.Prototypes;

namespace Content.Server.Cloning;

/// <summary>
/// The part of item cloning responsible for copying over important components.
/// </summary>
/// <remarks>
/// These are all not part of their corresponding systems because we don't want systems every system to depend on a CloningSystem namespace import, which is still heavily coupled to med code.
/// TODO: Create a more generic "CopyEntity" method/event (probably in RT) that doesn't have this problem and then move all these subscriptions.
/// </remarks>
public sealed partial class CloningSystem
{
    [Dependency] private SharedStackSystem _stack = default!;
    [Dependency] private LabelSystem _label = default!;
    [Dependency] private PaperSystem _paper = default!;
    [Dependency] private VocalSystem _vocal = default!;
    [Dependency] private MovementSpeedModifierSystem _movementSpeedModifier = default!;
    [Dependency] private SharedChameleonClothingSystem _chameleonClothing = default!;
    [Dependency] private PullingSystem _pulling = default!;
    [Dependency] private BloodstreamSystem _bloodstream = default!;
    [Dependency] private SharedCreamPieSystem _creampie = default!;
    [Dependency] private ForensicsSystem _forensics = default!;
    [Dependency] private FlammableSystem _flammable = default!;
    [Dependency] private DamageableSystem _damageable = default!;

    public override void Initialize()
    {
        base.Initialize();

        // These are used for <see cref="CopyItem"/>.
        // Anything not copied over here gets reverted to the values the item had in its prototype.
        // This method of copying items is of course not perfect as we cannot clone every single component, which would be pretty much impossible with our ECS.
        // We only consider the most important components so the paradox clone gets similar equipment.
        // This method of using subscriptions was chosen to make it easy for forks to add their own custom components that need to be copied.
        SubscribeLocalEvent<StackComponent, CloningItemEvent>(OnCloneItemStack);
        SubscribeLocalEvent<LabelComponent, CloningItemEvent>(OnCloneItemLabel);
        SubscribeLocalEvent<PaperComponent, CloningItemEvent>(OnCloneItemPaper);
        SubscribeLocalEvent<ForensicsComponent, CloningItemEvent>(OnCloneItemForensics);
        SubscribeLocalEvent<StoreComponent, CloningItemEvent>(OnCloneItemStore);
        SubscribeLocalEvent<ChameleonClothingComponent, CloningItemEvent>(OnCloneItemChameleon);

        // These are for cloning components that cannot be cloned using CopyComp.
        // Put them into CloningSettingsPrototype.EventComponents to have them be applied to the clone.
        SubscribeLocalEvent<VocalComponent, CloningEvent>(OnCloneVocal);
        SubscribeLocalEvent<StorageComponent, CloningEvent>(OnCloneStorage);
        SubscribeLocalEvent<InventoryComponent, CloningEvent>(OnCloneInventory);
        SubscribeLocalEvent<MovementSpeedModifierComponent, CloningEvent>(OnCloneMovementSpeedModifier);
        SubscribeLocalEvent<PullerComponent, CloningEvent>(OnClonePuller);
        SubscribeLocalEvent<BloodstreamComponent, CloningEvent>(OnCloneBloodstream);
        SubscribeLocalEvent<CreamPiedComponent, CloningEvent>(OnCloneCreamPied);
        SubscribeLocalEvent<FlammableComponent, CloningEvent>(OnCloneFlammable);
        SubscribeLocalEvent<DamageableComponent, CloningEvent>(OnCloneDamageable);
    }

    private void OnCloneItemStack(Entity<StackComponent> ent, ref CloningItemEvent args)
    {
        // if the clone is a stack as well, adjust the count of the copy
        if (TryComp<StackComponent>(args.CloneUid, out var cloneStackComp))
            _stack.SetCount((args.CloneUid, cloneStackComp), ent.Comp.Count);
    }

    private void OnCloneItemLabel(Entity<LabelComponent> ent, ref CloningItemEvent args)
    {
        // copy the label
        _label.Label(args.CloneUid, ent.Comp.CurrentLabel);
    }

    private void OnCloneItemPaper(Entity<PaperComponent> ent, ref CloningItemEvent args)
    {
        // copy the text and any stamps
        if (TryComp<PaperComponent>(args.CloneUid, out var clonePaperComp))
        {
            _paper.SetContent((args.CloneUid, clonePaperComp), ent.Comp.Content);
            _paper.CopyStamps(ent.AsNullable(), (args.CloneUid, clonePaperComp));
        }
    }

    private void OnCloneItemForensics(Entity<ForensicsComponent> ent, ref CloningItemEvent args)
    {
        // copy any forensics to the cloned item
        _forensics.CopyForensicsFrom(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneItemStore(Entity<StoreComponent> ent, ref CloningItemEvent args)
    {
        // copy the current amount of currency in the store
        // at the moment this takes care of uplink implants and the portable nukie uplinks
        // turning a copied pda into an uplink will need some refactoring first
        if (TryComp<StoreComponent>(args.CloneUid, out var cloneStoreComp))
        {
            cloneStoreComp.Balance = new Dictionary<ProtoId<CurrencyPrototype>, FixedPoint2>(ent.Comp.Balance);
        }
    }

    private void OnCloneItemChameleon(Entity<ChameleonClothingComponent> ent, ref CloningItemEvent args)
    {
        // copy the prototype the original is mimicing
        _chameleonClothing.SetSelectedPrototype(args.CloneUid, ent.Comp.Default);
    }

    private void OnCloneVocal(Entity<VocalComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _vocal.CopyComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneStorage(Entity<StorageComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _storage.CopyComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneInventory(Entity<InventoryComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _inventory.CopyComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneMovementSpeedModifier(Entity<MovementSpeedModifierComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _movementSpeedModifier.CopyComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnClonePuller(Entity<PullerComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _pulling.CopyPullerComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneBloodstream(Entity<BloodstreamComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _bloodstream.CopyComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneCreamPied(Entity<CreamPiedComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _creampie.CopyComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneFlammable(Entity<FlammableComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _flammable.CopyComponent(ent.AsNullable(), args.CloneUid);
    }

    private void OnCloneDamageable(Entity<DamageableComponent> ent, ref CloningEvent args)
    {
        if (!args.Settings.EventComponents.Contains(Factory.GetRegistration(ent.Comp.GetType()).Name))
            return;

        _damageable.CopyComponent(ent.AsNullable(), args.CloneUid);
    }
}