using Content.Shared.Cloning;
+using Content.Shared.Whitelist;
using Robust.Shared.Prototypes;
namespace Content.Server.GameTicking.Rules.Components;
/// </summary>
[DataField]
public EntProtoId GibProto = "MobParadoxTimed";
+
+ /// <summary>
+ /// Mind entity of the original player.
+ /// Gets assigned when cloning.
+ /// </summary>
+ [DataField]
+ public EntityUid? Original;
+
+ /// <summary>
+ /// Whitelist for Objectives to be copied to the clone.
+ /// </summary>
+ [DataField]
+ public EntityWhitelist? ObjectiveWhitelist;
+
+ /// <summary>
+ /// Blacklist for Objectives to be copied to the clone.
+ /// </summary>
+ [DataField]
+ public EntityWhitelist? ObjectiveBlacklist;
}
public sealed class ParadoxCloneRuleSystem : GameRuleSystem<ParadoxCloneRuleComponent>
{
[Dependency] private readonly SharedTransformSystem _transform = default!;
- [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly SharedMindSystem _mind = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly CloningSystem _cloning = default!;
base.Initialize();
SubscribeLocalEvent<ParadoxCloneRuleComponent, AntagSelectEntityEvent>(OnAntagSelectEntity);
+ SubscribeLocalEvent<ParadoxCloneRuleComponent, AfterAntagEntitySelectedEvent>(AfterAntagEntitySelected);
}
protected override void Started(EntityUid uid, ParadoxCloneRuleComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
if (args.Session?.AttachedEntity is not { } spawner)
return;
- if (!_prototypeManager.TryIndex(ent.Comp.Settings, out var settings))
- {
- Log.Error($"Used invalid cloning settings {ent.Comp.Settings} for ParadoxCloneRule");
- return;
- }
-
// get possible targets
var allHumans = _mind.GetAliveHumans();
var playerToClone = _random.Pick(allHumans);
var bodyToClone = playerToClone.Comp.OwnedEntity;
- if (bodyToClone == null || !_cloning.TryCloning(bodyToClone.Value, _transform.GetMapCoordinates(spawner), settings, out var clone))
+ if (bodyToClone == null || !_cloning.TryCloning(bodyToClone.Value, _transform.GetMapCoordinates(spawner), ent.Comp.Settings, out var clone))
{
Log.Error($"Unable to make a paradox clone of entity {ToPrettyString(bodyToClone)}");
return;
gibComp.PreventGibbingObjectives = new() { "ParadoxCloneKillObjective" }; // don't gib them if they killed the original.
args.Entity = clone;
+ ent.Comp.Original = playerToClone.Owner;
+ }
+
+ private void AfterAntagEntitySelected(Entity<ParadoxCloneRuleComponent> ent, ref AfterAntagEntitySelectedEvent args)
+ {
+ if (ent.Comp.Original == null)
+ return;
+
+ if (!_mind.TryGetMind(args.EntityUid, out var cloneMindId, out var cloneMindComp))
+ return;
+
+ _mind.CopyObjectives(ent.Comp.Original.Value, (cloneMindId, cloneMindComp), ent.Comp.ObjectiveWhitelist, ent.Comp.ObjectiveBlacklist);
}
}
using Content.Shared.Mobs.Systems;
using Content.Shared.Objectives.Systems;
using Content.Shared.Players;
+using Content.Shared.Whitelist;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Player;
[Dependency] private readonly SharedObjectivesSystem _objectives = default!;
[Dependency] private readonly SharedPlayerSystem _player = default!;
[Dependency] private readonly MetaDataSystem _metadata = default!;
+ [Dependency] private readonly EntityWhitelistSystem _whitelist = default!;
[ViewVariables]
protected readonly Dictionary<NetUserId, EntityUid> UserMinds = new();
var title = Name(objective);
_adminLogger.Add(LogType.Mind, LogImpact.Low, $"Objective {objective} ({title}) removed from the mind of {MindOwnerLoggingString(mind)}");
mind.Objectives.Remove(objective);
+
+ // garbage collection - only delete the objective entity if no mind uses it anymore
+ // This comes up for stuff like paradox clones where the objectives share the same entity
+ var mindQuery = new AllEntityQueryEnumerator<MindComponent>();
+ while (mindQuery.MoveNext(out _, out var queryComp))
+ {
+ if (queryComp.Objectives.Contains(objective))
+ return true;
+ }
+
Del(objective);
return true;
}
return false;
}
+ /// <summary>
+ /// Copies objectives from one mind to another, so that they are shared between two players.
+ /// </summary>
+ /// <remarks>
+ /// Only copies the reference to the objective entity, not the entity itself.
+ /// This relies on the fact that objectives are never changed after spawning them.
+ /// If someone ever changes that, they will have to address this.
+ /// </remarks>
+ /// <param name="source"> mind entity of the player to copy from </param>
+ /// <param name="target"> mind entity of the player to copy to </param>
+ /// <param name="except"> whitelist for objectives that should be copied </param>
+ /// <param name="except"> blacklist for objectives that should not be copied </param>
+ public void CopyObjectives(Entity<MindComponent?> source, Entity<MindComponent?> target, EntityWhitelist? whitelist = null, EntityWhitelist? blacklist = null)
+ {
+ if (!Resolve(source, ref source.Comp) || !Resolve(target, ref target.Comp))
+ return;
+
+ foreach (var objective in source.Comp.Objectives)
+ {
+ if (target.Comp.Objectives.Contains(objective))
+ continue; // target already has this objective
+
+ if (_whitelist.CheckBoth(objective, blacklist, whitelist))
+ AddObjective(target, target.Comp, objective);
+ }
+ }
+
/// <summary>
/// Tries to find an objective that has the same prototype as the argument.
/// </summary>
- Clumsy
- MindShield
- MimePowers
+ - SpaceNinja
# accents
- Accentless
- BackwardsAccent
reoccurrenceDelay: 20
minimumPlayers: 15
- type: ParadoxCloneRule
+ objectiveBlacklist:
+ tags:
+ - ParadoxCloneObjectiveBlacklist
- type: AntagObjectives
objectives:
- ParadoxCloneKillObjective
roles:
mindRoles:
- ParadoxCloneRole
+ - type: Tag
+ tags:
+ - ParadoxCloneObjectiveBlacklist # don't copy the objectives from other clones
- type: entity
parent: [BaseParadoxCloneObjective, BaseLivingObjective]
- type: Tag
id: Packet
+- type: Tag
+ id: ParadoxCloneObjectiveBlacklist # objective entities with this tag don't get copied to paradox clones
+
- type: Tag
id: Paper
projects / space-station-14.git / commitdiff