341 lines
13 KiB
C#
341 lines
13 KiB
C#
using System.Linq;
|
|
using Content.Shared.Examine;
|
|
using Content.Shared.Humanoid;
|
|
using Content.Shared.Humanoid.Markings;
|
|
using Content.Shared.Humanoid.Prototypes;
|
|
using Content.Shared.IdentityManagement;
|
|
using Content.Shared.Preferences;
|
|
using Content.Shared.Verbs;
|
|
using Robust.Shared.GameObjects.Components.Localization;
|
|
using Robust.Shared.Prototypes;
|
|
|
|
namespace Content.Server.Humanoid;
|
|
|
|
public sealed partial class HumanoidAppearanceSystem : SharedHumanoidAppearanceSystem
|
|
{
|
|
[Dependency] private readonly MarkingManager _markingManager = default!;
|
|
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
SubscribeLocalEvent<HumanoidAppearanceComponent, ComponentInit>(OnInit);
|
|
SubscribeLocalEvent<HumanoidAppearanceComponent, HumanoidMarkingModifierMarkingSetMessage>(OnMarkingsSet);
|
|
SubscribeLocalEvent<HumanoidAppearanceComponent, HumanoidMarkingModifierBaseLayersSetMessage>(OnBaseLayersSet);
|
|
SubscribeLocalEvent<HumanoidAppearanceComponent, GetVerbsEvent<Verb>>(OnVerbsRequest);
|
|
SubscribeLocalEvent<HumanoidAppearanceComponent, ExaminedEvent>(OnExamined);
|
|
}
|
|
|
|
private void OnInit(EntityUid uid, HumanoidAppearanceComponent humanoid, ComponentInit args)
|
|
{
|
|
if (string.IsNullOrEmpty(humanoid.Species))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(humanoid.Initial)
|
|
|| !_prototypeManager.TryIndex(humanoid.Initial, out HumanoidProfilePrototype? startingSet))
|
|
{
|
|
LoadProfile(uid, HumanoidCharacterProfile.DefaultWithSpecies(humanoid.Species), humanoid);
|
|
return;
|
|
}
|
|
|
|
// Do this first, because profiles currently do not support custom base layers
|
|
foreach (var (layer, info) in startingSet.CustomBaseLayers)
|
|
{
|
|
humanoid.CustomBaseLayers.Add(layer, info);
|
|
}
|
|
|
|
LoadProfile(uid, startingSet.Profile, humanoid);
|
|
}
|
|
|
|
private void OnExamined(EntityUid uid, HumanoidAppearanceComponent component, ExaminedEvent args)
|
|
{
|
|
var identity = Identity.Entity(component.Owner, EntityManager);
|
|
var species = GetSpeciesRepresentation(component.Species).ToLower();
|
|
var age = GetAgeRepresentation(component.Species, component.Age);
|
|
|
|
args.PushText(Loc.GetString("humanoid-appearance-component-examine", ("user", identity), ("age", age), ("species", species)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads a humanoid character profile directly onto this humanoid mob.
|
|
/// </summary>
|
|
/// <param name="uid">The mob's entity UID.</param>
|
|
/// <param name="profile">The character profile to load.</param>
|
|
/// <param name="humanoid">Humanoid component of the entity</param>
|
|
public void LoadProfile(EntityUid uid, HumanoidCharacterProfile profile, HumanoidAppearanceComponent? humanoid = null)
|
|
{
|
|
if (!Resolve(uid, ref humanoid))
|
|
{
|
|
return;
|
|
}
|
|
|
|
SetSpecies(uid, profile.Species, false, humanoid);
|
|
humanoid.Sex = profile.Sex;
|
|
humanoid.EyeColor = profile.Appearance.EyeColor;
|
|
|
|
SetSkinColor(uid, profile.Appearance.SkinColor, false);
|
|
|
|
humanoid.MarkingSet.Clear();
|
|
|
|
// Hair/facial hair - this may eventually be deprecated.
|
|
|
|
AddMarking(uid, profile.Appearance.HairStyleId, profile.Appearance.HairColor, false);
|
|
AddMarking(uid, profile.Appearance.FacialHairStyleId, profile.Appearance.FacialHairColor, false);
|
|
|
|
foreach (var marking in profile.Appearance.Markings)
|
|
{
|
|
AddMarking(uid, marking.MarkingId, marking.MarkingColors, false);
|
|
}
|
|
|
|
EnsureDefaultMarkings(uid, humanoid);
|
|
|
|
humanoid.Gender = profile.Gender;
|
|
if (TryComp<GrammarComponent>(uid, out var grammar))
|
|
{
|
|
grammar.Gender = profile.Gender;
|
|
}
|
|
|
|
humanoid.Age = profile.Age;
|
|
|
|
Dirty(humanoid);
|
|
}
|
|
|
|
// this was done enough times that it only made sense to do it here
|
|
|
|
/// <summary>
|
|
/// Clones a humanoid's appearance to a target mob, provided they both have humanoid components.
|
|
/// </summary>
|
|
/// <param name="source">Source entity to fetch the original appearance from.</param>
|
|
/// <param name="target">Target entity to apply the source entity's appearance to.</param>
|
|
/// <param name="sourceHumanoid">Source entity's humanoid component.</param>
|
|
/// <param name="targetHumanoid">Target entity's humanoid component.</param>
|
|
public void CloneAppearance(EntityUid source, EntityUid target, HumanoidAppearanceComponent? sourceHumanoid = null,
|
|
HumanoidAppearanceComponent? targetHumanoid = null)
|
|
{
|
|
if (!Resolve(source, ref sourceHumanoid) || !Resolve(target, ref targetHumanoid))
|
|
{
|
|
return;
|
|
}
|
|
|
|
targetHumanoid.Species = sourceHumanoid.Species;
|
|
targetHumanoid.SkinColor = sourceHumanoid.SkinColor;
|
|
targetHumanoid.Sex = sourceHumanoid.Sex;
|
|
targetHumanoid.CustomBaseLayers = new(sourceHumanoid.CustomBaseLayers);
|
|
targetHumanoid.MarkingSet = new(sourceHumanoid.MarkingSet);
|
|
|
|
targetHumanoid.Gender = sourceHumanoid.Gender;
|
|
if (TryComp<GrammarComponent>(target, out var grammar))
|
|
{
|
|
grammar.Gender = sourceHumanoid.Gender;
|
|
}
|
|
|
|
Dirty(targetHumanoid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a marking to this humanoid.
|
|
/// </summary>
|
|
/// <param name="uid">Humanoid mob's UID</param>
|
|
/// <param name="marking">Marking ID to use</param>
|
|
/// <param name="color">Color to apply to all marking layers of this marking</param>
|
|
/// <param name="sync">Whether to immediately sync this marking or not</param>
|
|
/// <param name="forced">If this marking was forced (ignores marking points)</param>
|
|
/// <param name="humanoid">Humanoid component of the entity</param>
|
|
public void AddMarking(EntityUid uid, string marking, Color? color = null, bool sync = true, bool forced = false, HumanoidAppearanceComponent? humanoid = null)
|
|
{
|
|
if (!Resolve(uid, ref humanoid)
|
|
|| !_markingManager.Markings.TryGetValue(marking, out var prototype))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var markingObject = prototype.AsMarking();
|
|
markingObject.Forced = forced;
|
|
if (color != null)
|
|
{
|
|
for (var i = 0; i < prototype.Sprites.Count; i++)
|
|
{
|
|
markingObject.SetColor(i, color.Value);
|
|
}
|
|
}
|
|
|
|
humanoid.MarkingSet.AddBack(prototype.MarkingCategory, markingObject);
|
|
|
|
if (sync)
|
|
Dirty(humanoid);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="uid">Humanoid mob's UID</param>
|
|
/// <param name="marking">Marking ID to use</param>
|
|
/// <param name="colors">Colors to apply against this marking's set of sprites.</param>
|
|
/// <param name="sync">Whether to immediately sync this marking or not</param>
|
|
/// <param name="forced">If this marking was forced (ignores marking points)</param>
|
|
/// <param name="humanoid">Humanoid component of the entity</param>
|
|
public void AddMarking(EntityUid uid, string marking, IReadOnlyList<Color> colors, bool sync = true, bool forced = false, HumanoidAppearanceComponent? humanoid = null)
|
|
{
|
|
if (!Resolve(uid, ref humanoid)
|
|
|| !_markingManager.Markings.TryGetValue(marking, out var prototype))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var markingObject = new Marking(marking, colors);
|
|
markingObject.Forced = forced;
|
|
humanoid.MarkingSet.AddBack(prototype.MarkingCategory, markingObject);
|
|
|
|
if (sync)
|
|
Dirty(humanoid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes a marking from a humanoid by ID.
|
|
/// </summary>
|
|
/// <param name="uid">Humanoid mob's UID</param>
|
|
/// <param name="marking">The marking to try and remove.</param>
|
|
/// <param name="sync">Whether to immediately sync this to the humanoid</param>
|
|
/// <param name="humanoid">Humanoid component of the entity</param>
|
|
public void RemoveMarking(EntityUid uid, string marking, bool sync = true, HumanoidAppearanceComponent? humanoid = null)
|
|
{
|
|
if (!Resolve(uid, ref humanoid)
|
|
|| !_markingManager.Markings.TryGetValue(marking, out var prototype))
|
|
{
|
|
return;
|
|
}
|
|
|
|
humanoid.MarkingSet.Remove(prototype.MarkingCategory, marking);
|
|
|
|
if (sync)
|
|
Dirty(humanoid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes a marking from a humanoid by category and index.
|
|
/// </summary>
|
|
/// <param name="uid">Humanoid mob's UID</param>
|
|
/// <param name="category">Category of the marking</param>
|
|
/// <param name="index">Index of the marking</param>
|
|
/// <param name="humanoid">Humanoid component of the entity</param>
|
|
public void RemoveMarking(EntityUid uid, MarkingCategories category, int index, HumanoidAppearanceComponent? humanoid = null)
|
|
{
|
|
if (index < 0
|
|
|| !Resolve(uid, ref humanoid)
|
|
|| !humanoid.MarkingSet.TryGetCategory(category, out var markings)
|
|
|| index >= markings.Count)
|
|
{
|
|
return;
|
|
}
|
|
|
|
humanoid.MarkingSet.Remove(category, index);
|
|
Dirty(humanoid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the marking ID of the humanoid in a category at an index in the category's list.
|
|
/// </summary>
|
|
/// <param name="uid">Humanoid mob's UID</param>
|
|
/// <param name="category">Category of the marking</param>
|
|
/// <param name="index">Index of the marking</param>
|
|
/// <param name="markingId">The marking ID to use</param>
|
|
/// <param name="humanoid">Humanoid component of the entity</param>
|
|
public void SetMarkingId(EntityUid uid, MarkingCategories category, int index, string markingId, HumanoidAppearanceComponent? humanoid = null)
|
|
{
|
|
if (index < 0
|
|
|| !_markingManager.MarkingsByCategory(category).TryGetValue(markingId, out var markingPrototype)
|
|
|| !Resolve(uid, ref humanoid)
|
|
|| !humanoid.MarkingSet.TryGetCategory(category, out var markings)
|
|
|| index >= markings.Count)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var marking = markingPrototype.AsMarking();
|
|
for (var i = 0; i < marking.MarkingColors.Count && i < markings[index].MarkingColors.Count; i++)
|
|
{
|
|
marking.SetColor(i, markings[index].MarkingColors[i]);
|
|
}
|
|
|
|
humanoid.MarkingSet.Replace(category, index, marking);
|
|
Dirty(humanoid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the marking colors of the humanoid in a category at an index in the category's list.
|
|
/// </summary>
|
|
/// <param name="uid">Humanoid mob's UID</param>
|
|
/// <param name="category">Category of the marking</param>
|
|
/// <param name="index">Index of the marking</param>
|
|
/// <param name="colors">The marking colors to use</param>
|
|
/// <param name="humanoid">Humanoid component of the entity</param>
|
|
public void SetMarkingColor(EntityUid uid, MarkingCategories category, int index, List<Color> colors,
|
|
HumanoidAppearanceComponent? humanoid = null)
|
|
{
|
|
if (index < 0
|
|
|| !Resolve(uid, ref humanoid)
|
|
|| !humanoid.MarkingSet.TryGetCategory(category, out var markings)
|
|
|| index >= markings.Count)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (var i = 0; i < markings[index].MarkingColors.Count && i < colors.Count; i++)
|
|
{
|
|
markings[index].SetColor(i, colors[i]);
|
|
}
|
|
|
|
Dirty(humanoid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Takes ID of the species prototype, returns UI-friendly name of the species.
|
|
/// </summary>
|
|
public string GetSpeciesRepresentation(string speciesId)
|
|
{
|
|
if (_prototypeManager.TryIndex<SpeciesPrototype>(speciesId, out var species))
|
|
{
|
|
return Loc.GetString(species.Name);
|
|
}
|
|
else
|
|
{
|
|
return Loc.GetString("humanoid-appearance-component-unknown-species");
|
|
}
|
|
}
|
|
|
|
public string GetAgeRepresentation(string species, int age)
|
|
{
|
|
_prototypeManager.TryIndex<SpeciesPrototype>(species, out var speciesPrototype);
|
|
|
|
if (speciesPrototype == null)
|
|
{
|
|
Logger.Error("Tried to get age representation of species that couldn't be indexed: " + species);
|
|
return Loc.GetString("identity-age-young");
|
|
}
|
|
|
|
if (age < speciesPrototype.YoungAge)
|
|
{
|
|
return Loc.GetString("identity-age-young");
|
|
}
|
|
|
|
if (age < speciesPrototype.OldAge)
|
|
{
|
|
return Loc.GetString("identity-age-middle-aged");
|
|
}
|
|
|
|
return Loc.GetString("identity-age-old");
|
|
}
|
|
|
|
private void EnsureDefaultMarkings(EntityUid uid, HumanoidAppearanceComponent? humanoid)
|
|
{
|
|
if (!Resolve(uid, ref humanoid))
|
|
{
|
|
return;
|
|
}
|
|
|
|
humanoid.MarkingSet.EnsureDefault(humanoid.SkinColor, _markingManager);
|
|
}
|
|
}
|