fb0b1705ec
* fix: педали теперь снова могут играть, если у них были выбраны фелиниды * fix: фикс спама от взаимодействия с цветками
1625 lines
56 KiB
C#
1625 lines
56 KiB
C#
using System.Linq;
|
|
using System.Numerics;
|
|
using Content.Client._White.Sponsors;
|
|
using Content.Client.Administration.Managers;
|
|
using Content.Client.Guidebook;
|
|
using Content.Client.Humanoid;
|
|
using Content.Client.Lobby.UI;
|
|
using Content.Client.Message;
|
|
using Content.Client.Players.PlayTimeTracking;
|
|
using Content.Client.Stylesheets;
|
|
using Content.Client.UserInterface.Controls;
|
|
using Content.Client.UserInterface.Systems.Guidebook;
|
|
using Content.Shared.Administration;
|
|
using Content.Shared.CCVar;
|
|
using Content.Shared.GameTicking;
|
|
using Content.Shared.Humanoid;
|
|
using Content.Shared.Humanoid.Markings;
|
|
using Content.Shared.Humanoid.Prototypes;
|
|
using Content.Shared.Preferences;
|
|
using Content.Shared.Roles;
|
|
using Content.Shared.StatusIcon;
|
|
using Content.Shared.Traits;
|
|
using Robust.Client.AutoGenerated;
|
|
using Robust.Client.Graphics;
|
|
using Robust.Client.UserInterface;
|
|
using Robust.Client.UserInterface.Controls;
|
|
using Robust.Client.UserInterface.CustomControls;
|
|
using Robust.Client.UserInterface.XAML;
|
|
using Robust.Client.Utility;
|
|
using Robust.Shared.Configuration;
|
|
using Robust.Shared.Enums;
|
|
using Robust.Shared.Map;
|
|
using Robust.Shared.Prototypes;
|
|
using Robust.Shared.Timing;
|
|
using Robust.Shared.Utility;
|
|
using static Robust.Client.UserInterface.Controls.BoxContainer;
|
|
using Direction = Robust.Shared.Maths.Direction;
|
|
|
|
namespace Content.Client.Preferences.UI
|
|
{
|
|
public sealed class HighlightedContainer : PanelContainer
|
|
{
|
|
public HighlightedContainer()
|
|
{
|
|
PanelOverride = new StyleBoxFlat
|
|
{
|
|
ContentMarginTopOverride = 10,
|
|
ContentMarginBottomOverride = 10,
|
|
ContentMarginLeftOverride = 10,
|
|
ContentMarginRightOverride = 10
|
|
};
|
|
}
|
|
}
|
|
|
|
[GenerateTypedNameReferences]
|
|
public sealed partial class HumanoidProfileEditor : Control
|
|
{
|
|
|
|
//WD-EDIT
|
|
private readonly SponsorsManager _sponsorsManager;
|
|
private readonly IClientAdminManager _adminManager;
|
|
//WD-EDIT
|
|
|
|
private readonly IClientPreferencesManager _preferencesManager;
|
|
private readonly IEntityManager _entMan;
|
|
private readonly IConfigurationManager _configurationManager;
|
|
private readonly MarkingManager _markingManager;
|
|
private readonly JobRequirementsManager _requirements;
|
|
|
|
private LineEdit _ageEdit => CAgeEdit;
|
|
private LineEdit _nameEdit => CNameEdit;
|
|
private TextEdit _flavorTextEdit = null!;
|
|
private LineEdit _nameClownEdit => CClownNameEdit;
|
|
private LineEdit _nameMimeEdit => CMimeNameEdit;
|
|
private LineEdit _nameBorgEdit => CBorgNameEdit;
|
|
private Button _nameRandomButton => CNameRandomize;
|
|
private Button _nameClownRandomButton => CClownNameRandomize;
|
|
private Button _nameMimeRandomButton => CMimeNameRandomize;
|
|
private Button _nameBorgRandomButton => CBorgNameRandomize;
|
|
private Button _randomizeEverythingButton => CRandomizeEverything;
|
|
private RichTextLabel _warningLabel => CWarningLabel;
|
|
private Button _saveButton => CSaveButton;
|
|
private OptionButton _sexButton => CSexButton;
|
|
private OptionButton _genderButton => CPronounsButton;
|
|
|
|
//WD-EDIT
|
|
private OptionButton _voiceButton => CVoiceButton;
|
|
private Button _voicePlayButton => CVoicePlayButton;
|
|
//WD-EDIT
|
|
|
|
private Slider _skinColor => CSkin;
|
|
private OptionButton _clothingButton => CClothingButton;
|
|
private OptionButton _backpackButton => CBackpackButton;
|
|
private OptionButton _spawnPriorityButton => CSpawnPriorityButton;
|
|
private SingleMarkingPicker _hairPicker => CHairStylePicker;
|
|
private SingleMarkingPicker _facialHairPicker => CFacialHairPicker;
|
|
private EyeColorPicker _eyesPicker => CEyeColorPicker;
|
|
|
|
private TabContainer _tabContainer => CTabContainer;
|
|
private BoxContainer _jobList => CJobList;
|
|
private BoxContainer _antagList => CAntagList;
|
|
private BoxContainer _traitsList => CTraitsList;
|
|
private readonly List<JobPrioritySelector> _jobPriorities;
|
|
private OptionButton _preferenceUnavailableButton => CPreferenceUnavailableButton;
|
|
private readonly Dictionary<string, BoxContainer> _jobCategories;
|
|
// Mildly hacky, as I don't trust prototype order to stay consistent and don't want the UI to break should a new one get added mid-edit. --moony
|
|
private readonly List<SpeciesPrototype> _speciesList;
|
|
private readonly List<AntagPreferenceSelector> _antagPreferences;
|
|
private readonly List<TraitPreferenceSelector> _traitPreferences;
|
|
private List<BodyTypePrototype> _bodyTypesList = new();
|
|
|
|
private SpriteView _previewSpriteView => CSpriteView;
|
|
private Button _previewRotateLeftButton => CSpriteRotateLeft;
|
|
private Button _previewRotateRightButton => CSpriteRotateRight;
|
|
private Direction _previewRotation = Direction.North;
|
|
private EntityUid? _previewDummy;
|
|
|
|
private BoxContainer _rgbSkinColorContainer => CRgbSkinColorContainer;
|
|
private ColorSelectorSliders _rgbSkinColorSelector;
|
|
|
|
private bool _isDirty;
|
|
private bool _needUpdatePreview;
|
|
public int CharacterSlot;
|
|
public HumanoidCharacterProfile? Profile;
|
|
private MarkingSet _markingSet = new(); // storing this here feels iffy but a few things need it this high up
|
|
|
|
public event Action<HumanoidCharacterProfile, int>? OnProfileChanged;
|
|
|
|
public HumanoidProfileEditor(IClientPreferencesManager preferencesManager, IPrototypeManager prototypeManager,
|
|
IEntityManager entityManager, IConfigurationManager configurationManager)
|
|
{
|
|
RobustXamlLoader.Load(this);
|
|
_sponsorsManager = IoCManager.Resolve<SponsorsManager>();
|
|
_adminManager = IoCManager.Resolve<IClientAdminManager>();
|
|
_prototypeManager = prototypeManager;
|
|
_entMan = entityManager;
|
|
_preferencesManager = preferencesManager;
|
|
_configurationManager = configurationManager;
|
|
_markingManager = IoCManager.Resolve<MarkingManager>();
|
|
|
|
SpeciesInfoButton.ToolTip = Loc.GetString("humanoid-profile-editor-guidebook-button-tooltip");
|
|
|
|
#region Left
|
|
|
|
#region Name
|
|
|
|
_nameEdit.OnTextChanged += args => { SetName(args.Text); };
|
|
_nameClownEdit.OnTextChanged += args => { SetClownName(args.Text); };
|
|
_nameMimeEdit.OnTextChanged += args => { SetMimeName(args.Text); };
|
|
_nameBorgEdit.OnTextChanged += args => { SetBorgName(args.Text); };
|
|
_nameRandomButton.OnPressed += args => RandomizeName();
|
|
_nameClownRandomButton.OnPressed += args => RandomizeClownName();
|
|
_nameMimeRandomButton.OnPressed += args => RandomizeMimeName();
|
|
_nameBorgRandomButton.OnPressed += args => RandomizeBorgName();
|
|
_randomizeEverythingButton.OnPressed += args => { RandomizeEverything(); };
|
|
_warningLabel.SetMarkup($"[color=red]{Loc.GetString("humanoid-profile-editor-naming-rules-warning")}[/color]");
|
|
|
|
#endregion Name
|
|
|
|
#region Appearance
|
|
|
|
_tabContainer.SetTabTitle(0, Loc.GetString("humanoid-profile-editor-appearance-tab"));
|
|
|
|
ShowClothes.OnPressed += ToggleClothes;
|
|
|
|
#region Sex
|
|
|
|
_sexButton.OnItemSelected += args =>
|
|
{
|
|
_sexButton.SelectId(args.Id);
|
|
SetSex((Sex) args.Id);
|
|
};
|
|
|
|
#endregion Sex
|
|
|
|
#region Body Type
|
|
|
|
CBodyTypesButton.OnItemSelected += OnBodyTypeSelected;
|
|
|
|
UpdateBodyTypes();
|
|
|
|
#endregion Body Type
|
|
|
|
#region Age
|
|
|
|
_ageEdit.OnTextChanged += args =>
|
|
{
|
|
if (!int.TryParse(args.Text, out var newAge))
|
|
return;
|
|
SetAge(newAge);
|
|
};
|
|
|
|
#endregion Age
|
|
|
|
#region Gender
|
|
|
|
_genderButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-male-text"), (int) Gender.Male);
|
|
_genderButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-female-text"), (int) Gender.Female);
|
|
_genderButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-epicene-text"), (int) Gender.Epicene);
|
|
_genderButton.AddItem(Loc.GetString("humanoid-profile-editor-pronouns-neuter-text"), (int) Gender.Neuter);
|
|
|
|
_genderButton.OnItemSelected += args =>
|
|
{
|
|
_genderButton.SelectId(args.Id);
|
|
SetGender((Gender) args.Id);
|
|
};
|
|
|
|
#endregion Gender
|
|
|
|
//TTS-Start
|
|
#region Voice
|
|
|
|
InitializeVoice();
|
|
|
|
#endregion
|
|
//TTS-End
|
|
|
|
#region Species
|
|
|
|
//WD EDIT
|
|
_speciesList = GetAllowedSpecies();
|
|
//WD EDIT END
|
|
|
|
for (var i = 0; i < _speciesList.Count; i++)
|
|
{
|
|
var specie = _speciesList[i]; // WD EDIT
|
|
var name = Loc.GetString(specie.Name);
|
|
|
|
CSpeciesButton.AddItem(name, i);
|
|
}
|
|
|
|
CSpeciesButton.OnItemSelected += args =>
|
|
{
|
|
CSpeciesButton.SelectId(args.Id);
|
|
SetSpecies(_speciesList[args.Id].ID);
|
|
UpdateHairPickers();
|
|
OnSkinColorOnValueChanged();
|
|
};
|
|
|
|
#endregion Species
|
|
|
|
#region Skin
|
|
|
|
|
|
_skinColor.OnValueChanged += _ =>
|
|
{
|
|
OnSkinColorOnValueChanged();
|
|
};
|
|
|
|
_rgbSkinColorContainer.AddChild(_rgbSkinColorSelector = new ColorSelectorSliders());
|
|
_rgbSkinColorSelector.OnColorChanged += _ =>
|
|
{
|
|
OnSkinColorOnValueChanged();
|
|
};
|
|
|
|
#endregion
|
|
|
|
#region Hair
|
|
|
|
_hairPicker.OnMarkingSelect += newStyle =>
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithHairStyleName(newStyle.id));
|
|
IsDirty = true;
|
|
};
|
|
|
|
_hairPicker.OnColorChanged += newColor =>
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithHairColor(newColor.marking.MarkingColors[0]));
|
|
UpdateCMarkingsHair();
|
|
IsDirty = true;
|
|
};
|
|
|
|
_facialHairPicker.OnMarkingSelect += newStyle =>
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithFacialHairStyleName(newStyle.id));
|
|
IsDirty = true;
|
|
};
|
|
|
|
_facialHairPicker.OnColorChanged += newColor =>
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithFacialHairColor(newColor.marking.MarkingColors[0]));
|
|
UpdateCMarkingsFacialHair();
|
|
IsDirty = true;
|
|
};
|
|
|
|
_hairPicker.OnSlotRemove += _ =>
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithHairStyleName(HairStyles.DefaultHairStyle)
|
|
);
|
|
UpdateHairPickers();
|
|
UpdateCMarkingsHair();
|
|
IsDirty = true;
|
|
};
|
|
|
|
_facialHairPicker.OnSlotRemove += _ =>
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithFacialHairStyleName(HairStyles.DefaultFacialHairStyle)
|
|
);
|
|
UpdateHairPickers();
|
|
UpdateCMarkingsFacialHair();
|
|
IsDirty = true;
|
|
};
|
|
|
|
_hairPicker.OnSlotAdd += delegate()
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
var hair = _markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.Hair, Profile.Species).Keys
|
|
.FirstOrDefault();
|
|
|
|
if (string.IsNullOrEmpty(hair))
|
|
return;
|
|
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithHairStyleName(hair)
|
|
);
|
|
|
|
UpdateHairPickers();
|
|
UpdateCMarkingsHair();
|
|
IsDirty = true;
|
|
};
|
|
|
|
_facialHairPicker.OnSlotAdd += delegate()
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
var hair = _markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.FacialHair, Profile.Species).Keys
|
|
.FirstOrDefault();
|
|
|
|
if (string.IsNullOrEmpty(hair))
|
|
return;
|
|
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithFacialHairStyleName(hair)
|
|
);
|
|
|
|
UpdateHairPickers();
|
|
UpdateCMarkingsFacialHair();
|
|
IsDirty = true;
|
|
};
|
|
|
|
#endregion Hair
|
|
|
|
#region Clothing
|
|
|
|
_clothingButton.AddItem(Loc.GetString("humanoid-profile-editor-preference-jumpsuit"), (int) ClothingPreference.Jumpsuit);
|
|
_clothingButton.AddItem(Loc.GetString("humanoid-profile-editor-preference-jumpskirt"), (int) ClothingPreference.Jumpskirt);
|
|
|
|
_clothingButton.OnItemSelected += args =>
|
|
{
|
|
_clothingButton.SelectId(args.Id);
|
|
SetClothing((ClothingPreference) args.Id);
|
|
};
|
|
|
|
#endregion Clothing
|
|
|
|
#region Backpack
|
|
|
|
_backpackButton.AddItem(Loc.GetString("humanoid-profile-editor-preference-backpack"), (int) BackpackPreference.Backpack);
|
|
_backpackButton.AddItem(Loc.GetString("humanoid-profile-editor-preference-satchel"), (int) BackpackPreference.Satchel);
|
|
_backpackButton.AddItem(Loc.GetString("humanoid-profile-editor-preference-duffelbag"), (int) BackpackPreference.Duffelbag);
|
|
|
|
_backpackButton.OnItemSelected += args =>
|
|
{
|
|
_backpackButton.SelectId(args.Id);
|
|
SetBackpack((BackpackPreference) args.Id);
|
|
};
|
|
|
|
#endregion Backpack
|
|
|
|
#region SpawnPriority
|
|
|
|
foreach (var value in Enum.GetValues<SpawnPriorityPreference>())
|
|
{
|
|
_spawnPriorityButton.AddItem(Loc.GetString($"humanoid-profile-editor-preference-spawn-priority-{value.ToString().ToLower()}"), (int) value);
|
|
}
|
|
|
|
_spawnPriorityButton.OnItemSelected += args =>
|
|
{
|
|
_spawnPriorityButton.SelectId(args.Id);
|
|
SetSpawnPriority((SpawnPriorityPreference) args.Id);
|
|
};
|
|
|
|
#endregion SpawnPriority
|
|
|
|
#region Eyes
|
|
|
|
_eyesPicker.OnEyeColorPicked += newColor =>
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
Profile = Profile.WithCharacterAppearance(
|
|
Profile.Appearance.WithEyeColor(newColor));
|
|
CMarkings.CurrentEyeColor = Profile.Appearance.EyeColor;
|
|
IsDirty = true;
|
|
};
|
|
|
|
#endregion Eyes
|
|
|
|
#endregion Appearance
|
|
|
|
#region Jobs
|
|
|
|
_tabContainer.SetTabTitle(1, Loc.GetString("humanoid-profile-editor-jobs-tab"));
|
|
|
|
_preferenceUnavailableButton.AddItem(
|
|
Loc.GetString("humanoid-profile-editor-preference-unavailable-stay-in-lobby-button"),
|
|
(int) PreferenceUnavailableMode.StayInLobby);
|
|
_preferenceUnavailableButton.AddItem(
|
|
Loc.GetString("humanoid-profile-editor-preference-unavailable-spawn-as-overflow-button",
|
|
("overflowJob", Loc.GetString(SharedGameTicker.FallbackOverflowJobName))),
|
|
(int) PreferenceUnavailableMode.SpawnAsOverflow);
|
|
|
|
_preferenceUnavailableButton.OnItemSelected += args =>
|
|
{
|
|
_preferenceUnavailableButton.SelectId(args.Id);
|
|
|
|
Profile = Profile?.WithPreferenceUnavailable((PreferenceUnavailableMode) args.Id);
|
|
IsDirty = true;
|
|
};
|
|
|
|
_jobPriorities = new List<JobPrioritySelector>();
|
|
_jobCategories = new Dictionary<string, BoxContainer>();
|
|
_requirements = IoCManager.Resolve<JobRequirementsManager>();
|
|
_requirements.Updated += UpdateRoleRequirements;
|
|
UpdateRoleRequirements();
|
|
|
|
#endregion Jobs
|
|
|
|
#region Antags
|
|
|
|
_tabContainer.SetTabTitle(2, Loc.GetString("humanoid-profile-editor-antags-tab"));
|
|
|
|
_antagPreferences = new List<AntagPreferenceSelector>();
|
|
|
|
foreach (var antag in prototypeManager.EnumeratePrototypes<AntagPrototype>().OrderBy(a => Loc.GetString(a.Name)))
|
|
{
|
|
if (!antag.SetPreference)
|
|
continue;
|
|
|
|
var selector = new AntagPreferenceSelector(antag);
|
|
_antagList.AddChild(selector);
|
|
_antagPreferences.Add(selector);
|
|
if (selector.Disabled)
|
|
{
|
|
Profile = Profile?.WithAntagPreference(antag.ID, false);
|
|
IsDirty = true;
|
|
}
|
|
|
|
selector.PreferenceChanged += preference =>
|
|
{
|
|
Profile = Profile?.WithAntagPreference(antag.ID, preference);
|
|
IsDirty = true;
|
|
};
|
|
}
|
|
|
|
#endregion Antags
|
|
|
|
#region Traits
|
|
|
|
var traits = prototypeManager.EnumeratePrototypes<TraitPrototype>().OrderBy(t => Loc.GetString(t.Name)).ToList();
|
|
_traitPreferences = new List<TraitPreferenceSelector>();
|
|
_tabContainer.SetTabTitle(3, Loc.GetString("humanoid-profile-editor-traits-tab"));
|
|
|
|
if (traits.Count > 0)
|
|
{
|
|
foreach (var trait in traits)
|
|
{
|
|
var selector = new TraitPreferenceSelector(trait);
|
|
_traitsList.AddChild(selector);
|
|
_traitPreferences.Add(selector);
|
|
|
|
selector.PreferenceChanged += preference =>
|
|
{
|
|
Profile = Profile?.WithTraitPreference(trait.ID, preference);
|
|
IsDirty = true;
|
|
};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_traitsList.AddChild(new Label
|
|
{
|
|
Text = "No traits available :(",
|
|
FontColorOverride = Color.Gray,
|
|
});
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Save
|
|
|
|
_saveButton.OnPressed += _ => { Save(); };
|
|
|
|
#endregion Save
|
|
|
|
#region Markings
|
|
_tabContainer.SetTabTitle(4, Loc.GetString("humanoid-profile-editor-markings-tab"));
|
|
|
|
CMarkings.OnMarkingAdded += OnMarkingChange;
|
|
CMarkings.OnMarkingRemoved += OnMarkingChange;
|
|
CMarkings.OnMarkingColorChange += OnMarkingChange;
|
|
CMarkings.OnMarkingRankChange += OnMarkingChange;
|
|
|
|
#endregion Markings
|
|
|
|
#region FlavorText
|
|
|
|
if (_configurationManager.GetCVar(CCVars.FlavorText))
|
|
{
|
|
var flavorText = new FlavorText.FlavorText();
|
|
_tabContainer.AddChild(flavorText);
|
|
_tabContainer.SetTabTitle(_tabContainer.ChildCount - 1, Loc.GetString("humanoid-profile-editor-flavortext-tab"));
|
|
_flavorTextEdit = flavorText.CFlavorTextInput;
|
|
|
|
flavorText.OnFlavorTextChanged += OnFlavorTextChange;
|
|
}
|
|
|
|
#endregion FlavorText
|
|
|
|
#region Dummy
|
|
|
|
_previewRotateLeftButton.OnPressed += _ =>
|
|
{
|
|
_previewRotation = _previewRotation.TurnCw();
|
|
_needUpdatePreview = true;
|
|
};
|
|
_previewRotateRightButton.OnPressed += _ =>
|
|
{
|
|
_previewRotation = _previewRotation.TurnCcw();
|
|
_needUpdatePreview = true;
|
|
};
|
|
|
|
var species = Profile?.Species ?? SharedHumanoidAppearanceSystem.DefaultSpecies;
|
|
var dollProto = _prototypeManager.Index<SpeciesPrototype>(species).DollPrototype;
|
|
|
|
if (_previewDummy != null)
|
|
_entMan.DeleteEntity(_previewDummy!.Value);
|
|
|
|
_previewDummy = _entMan.SpawnEntity(dollProto, MapCoordinates.Nullspace);
|
|
_previewSpriteView.SetEntity(_previewDummy);
|
|
#endregion Dummy
|
|
|
|
#endregion Left
|
|
|
|
if (preferencesManager.ServerDataLoaded)
|
|
{
|
|
LoadServerData();
|
|
}
|
|
|
|
preferencesManager.OnServerDataLoaded += LoadServerData;
|
|
|
|
SpeciesInfoButton.OnPressed += OnSpeciesInfoButtonPressed;
|
|
|
|
UpdateSpeciesGuidebookIcon();
|
|
|
|
IsDirty = false;
|
|
}
|
|
|
|
private void OnSpeciesInfoButtonPressed(BaseButton.ButtonEventArgs args)
|
|
{
|
|
var guidebookController = UserInterfaceManager.GetUIController<GuidebookUIController>();
|
|
var species = Profile?.Species ?? SharedHumanoidAppearanceSystem.DefaultSpecies;
|
|
var page = "Species";
|
|
if (_prototypeManager.HasIndex<GuideEntryPrototype>(species))
|
|
page = species;
|
|
|
|
if (_prototypeManager.TryIndex<GuideEntryPrototype>("Species", out var guideRoot))
|
|
{
|
|
var dict = new Dictionary<string, GuideEntry> { { "Species", guideRoot } };
|
|
//TODO: Don't close the guidebook if its already open, just go to the correct page
|
|
guidebookController.ToggleGuidebook(dict, includeChildren:true, selected: page);
|
|
}
|
|
}
|
|
|
|
private void ToggleClothes(BaseButton.ButtonEventArgs obj)
|
|
{
|
|
RebuildSpriteView();
|
|
}
|
|
|
|
private void UpdateRoleRequirements()
|
|
{
|
|
_jobList.DisposeAllChildren();
|
|
_jobPriorities.Clear();
|
|
_jobCategories.Clear();
|
|
var firstCategory = true;
|
|
|
|
var departments = _prototypeManager.EnumeratePrototypes<DepartmentPrototype>().ToArray();
|
|
Array.Sort(departments, DepartmentUIComparer.Instance);
|
|
|
|
foreach (var department in departments)
|
|
{
|
|
var departmentName = Loc.GetString($"department-{department.ID}");
|
|
|
|
if (!_jobCategories.TryGetValue(department.ID, out var category))
|
|
{
|
|
category = new BoxContainer
|
|
{
|
|
Orientation = LayoutOrientation.Vertical,
|
|
Name = department.ID,
|
|
ToolTip = Loc.GetString("humanoid-profile-editor-jobs-amount-in-department-tooltip",
|
|
("departmentName", departmentName))
|
|
};
|
|
|
|
if (firstCategory)
|
|
{
|
|
firstCategory = false;
|
|
}
|
|
else
|
|
{
|
|
category.AddChild(new Control
|
|
{
|
|
MinSize = new Vector2(0, 23),
|
|
});
|
|
}
|
|
|
|
category.AddChild(new PanelContainer
|
|
{
|
|
PanelOverride = new StyleBoxFlat {BackgroundColor = Color.FromHex("#232323")},
|
|
Children =
|
|
{
|
|
new Label
|
|
{
|
|
Text = Loc.GetString("humanoid-profile-editor-department-jobs-label",
|
|
("departmentName", departmentName)),
|
|
Margin = new Thickness(5f, 0, 0, 0)
|
|
}
|
|
}
|
|
});
|
|
|
|
_jobCategories[department.ID] = category;
|
|
_jobList.AddChild(category);
|
|
}
|
|
|
|
var jobs = department.Roles.Select(jobId => _prototypeManager.Index<JobPrototype>(jobId))
|
|
.Where(job => job.SetPreference)
|
|
.ToArray();
|
|
Array.Sort(jobs, JobUIComparer.Instance);
|
|
|
|
foreach (var job in jobs)
|
|
{
|
|
var selector = new JobPrioritySelector(job, _prototypeManager);
|
|
|
|
if (!_requirements.IsAllowed(job, out var reason))
|
|
{
|
|
selector.LockRequirements(reason);
|
|
}
|
|
|
|
category.AddChild(selector);
|
|
_jobPriorities.Add(selector);
|
|
|
|
selector.PriorityChanged += priority =>
|
|
{
|
|
Profile = Profile?.WithJobPriority(job.ID, priority);
|
|
IsDirty = true;
|
|
|
|
foreach (var jobSelector in _jobPriorities)
|
|
{
|
|
// Sync other selectors with the same job in case of multiple department jobs
|
|
if (jobSelector.Proto == selector.Proto)
|
|
{
|
|
jobSelector.Priority = priority;
|
|
}
|
|
else if (priority == JobPriority.High && jobSelector.Priority == JobPriority.High)
|
|
{
|
|
// Lower any other high priorities to medium.
|
|
jobSelector.Priority = JobPriority.Medium;
|
|
Profile = Profile?.WithJobPriority(jobSelector.Proto.ID, JobPriority.Medium);
|
|
}
|
|
}
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
if (Profile is not null)
|
|
{
|
|
UpdateJobPriorities();
|
|
}
|
|
}
|
|
|
|
private void OnFlavorTextChange(string content)
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
Profile = Profile.WithFlavorText(content);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void OnMarkingChange(MarkingSet markings)
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithMarkings(markings.GetForwardEnumerator().ToList()));
|
|
_needUpdatePreview = true;
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void OnMarkingColorChange(List<Marking> markings)
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithMarkings(markings));
|
|
IsDirty = true;
|
|
}
|
|
|
|
|
|
private void OnSkinColorOnValueChanged()
|
|
{
|
|
if (Profile is null) return;
|
|
|
|
var skin = _prototypeManager.Index<SpeciesPrototype>(Profile.Species).SkinColoration;
|
|
|
|
switch (skin)
|
|
{
|
|
case HumanoidSkinColor.HumanToned:
|
|
{
|
|
if (!_skinColor.Visible)
|
|
{
|
|
_skinColor.Visible = true;
|
|
_rgbSkinColorContainer.Visible = false;
|
|
}
|
|
|
|
var color = SkinColor.HumanSkinTone((int) _skinColor.Value);
|
|
|
|
CMarkings.CurrentSkinColor = color;
|
|
Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));//
|
|
break;
|
|
}
|
|
case HumanoidSkinColor.Hues:
|
|
{
|
|
if (!_rgbSkinColorContainer.Visible)
|
|
{
|
|
_skinColor.Visible = false;
|
|
_rgbSkinColorContainer.Visible = true;
|
|
}
|
|
|
|
CMarkings.CurrentSkinColor = _rgbSkinColorSelector.Color;
|
|
Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(_rgbSkinColorSelector.Color));
|
|
break;
|
|
}
|
|
case HumanoidSkinColor.TintedHues:
|
|
{
|
|
if (!_rgbSkinColorContainer.Visible)
|
|
{
|
|
_skinColor.Visible = false;
|
|
_rgbSkinColorContainer.Visible = true;
|
|
}
|
|
|
|
var color = SkinColor.TintedHues(_rgbSkinColorSelector.Color);
|
|
|
|
CMarkings.CurrentSkinColor = color;
|
|
Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));
|
|
break;
|
|
}
|
|
}
|
|
|
|
IsDirty = true;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
if (!disposing)
|
|
return;
|
|
|
|
if (_previewDummy != null)
|
|
_entMan.DeleteEntity(_previewDummy.Value);
|
|
|
|
_requirements.Updated -= UpdateRoleRequirements;
|
|
_preferencesManager.OnServerDataLoaded -= LoadServerData;
|
|
}
|
|
|
|
private void RebuildSpriteView()
|
|
{
|
|
var species = Profile?.Species ?? SharedHumanoidAppearanceSystem.DefaultSpecies;
|
|
var dollProto = _prototypeManager.Index<SpeciesPrototype>(species).DollPrototype;
|
|
|
|
if (_previewDummy != null)
|
|
_entMan.DeleteEntity(_previewDummy!.Value);
|
|
|
|
_previewDummy = _entMan.SpawnEntity(dollProto, MapCoordinates.Nullspace);
|
|
_previewSpriteView.SetEntity(_previewDummy);
|
|
_needUpdatePreview = true;
|
|
}
|
|
|
|
private void LoadServerData()
|
|
{
|
|
Profile = (HumanoidCharacterProfile) _preferencesManager.Preferences!.SelectedCharacter;
|
|
CharacterSlot = _preferencesManager.Preferences.SelectedCharacterIndex;
|
|
|
|
UpdateControls();
|
|
_needUpdatePreview = true;
|
|
}
|
|
|
|
private void SetAge(int newAge)
|
|
{
|
|
Profile = Profile?.WithAge(newAge);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetSex(Sex newSex)
|
|
{
|
|
Profile = Profile?.WithSex(newSex);
|
|
// for convenience, default to most common gender when new sex is selected
|
|
switch (newSex)
|
|
{
|
|
case Sex.Male:
|
|
Profile = Profile?.WithGender(Gender.Male);
|
|
break;
|
|
case Sex.Female:
|
|
Profile = Profile?.WithGender(Gender.Female);
|
|
break;
|
|
default:
|
|
Profile = Profile?.WithGender(Gender.Epicene);
|
|
break;
|
|
}
|
|
UpdateGenderControls();
|
|
CMarkings.SetSex(newSex);
|
|
UpdateTTSVoicesControls(); //WD-EDIT
|
|
IsDirty = true;
|
|
}
|
|
|
|
//WD-EDIT
|
|
private void SetVoice(string newVoice)
|
|
{
|
|
Profile = Profile?.WithVoice(newVoice);
|
|
IsDirty = true;
|
|
}
|
|
//WD-EDIT
|
|
|
|
private void SetGender(Gender newGender)
|
|
{
|
|
Profile = Profile?.WithGender(newGender);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetSpecies(string newSpecies)
|
|
{
|
|
Profile = Profile?.WithSpecies(newSpecies);
|
|
OnSkinColorOnValueChanged(); // Species may have special color prefs, make sure to update it.
|
|
CMarkings.SetSpecies(newSpecies); // Repopulate the markings tab as well.
|
|
UpdateSexControls(); // update sex for new species
|
|
RebuildSpriteView(); // they might have different inv so we need a new dummy
|
|
UpdateSpeciesGuidebookIcon();
|
|
UpdateBodyTypes();
|
|
IsDirty = true;
|
|
_needUpdatePreview = true;
|
|
}
|
|
|
|
private void SetName(string newName)
|
|
{
|
|
Profile = Profile?.WithName(newName);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetClownName(string newName)
|
|
{
|
|
Profile = Profile?.WithClownName(newName);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetMimeName(string newName)
|
|
{
|
|
Profile = Profile?.WithMimeName(newName);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetBorgName(string newName)
|
|
{
|
|
Profile = Profile?.WithBorgName(newName);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetClothing(ClothingPreference newClothing)
|
|
{
|
|
Profile = Profile?.WithClothingPreference(newClothing);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetBackpack(BackpackPreference newBackpack)
|
|
{
|
|
Profile = Profile?.WithBackpackPreference(newBackpack);
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void SetSpawnPriority(SpawnPriorityPreference newSpawnPriority)
|
|
{
|
|
Profile = Profile?.WithSpawnPriorityPreference(newSpawnPriority);
|
|
IsDirty = true;
|
|
}
|
|
|
|
public void Save()
|
|
{
|
|
IsDirty = false;
|
|
|
|
if (Profile != null)
|
|
{
|
|
_preferencesManager.UpdateCharacter(Profile, CharacterSlot);
|
|
OnProfileChanged?.Invoke(Profile, CharacterSlot);
|
|
_needUpdatePreview = true;
|
|
}
|
|
}
|
|
|
|
private void OnBodyTypeSelected(OptionButton.ItemSelectedEventArgs args)
|
|
{
|
|
args.Button.SelectId(args.Id);
|
|
SetBodyType(_bodyTypesList[args.Id].ID);
|
|
}
|
|
|
|
private void UpdateBodyTypes()
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
CBodyTypesButton.Clear();
|
|
var species = _prototypeManager.Index<SpeciesPrototype>(Profile.Species);
|
|
var sex = Profile.Sex;
|
|
_bodyTypesList = EntitySystem.Get<HumanoidAppearanceSystem>().GetValidBodyTypes(species, sex);
|
|
|
|
for (var i = 0; i < _bodyTypesList.Count; i++)
|
|
{
|
|
CBodyTypesButton.AddItem(Loc.GetString(_bodyTypesList[i].Name), i);
|
|
}
|
|
|
|
// If current body type is not valid.
|
|
if (!_bodyTypesList.Select(proto => proto.ID).Contains(Profile.BodyType.Id))
|
|
{
|
|
// Then replace it with a first valid body type.
|
|
SetBodyType(_bodyTypesList.First().ID);
|
|
}
|
|
|
|
CBodyTypesButton.Select(_bodyTypesList.FindIndex(x => x.ID == Profile.BodyType));
|
|
IsDirty = true;
|
|
}
|
|
|
|
private bool IsDirty
|
|
{
|
|
get => _isDirty;
|
|
set
|
|
{
|
|
_isDirty = value;
|
|
_needUpdatePreview = true;
|
|
UpdateSaveButton();
|
|
}
|
|
}
|
|
|
|
private void UpdateNamesEdit()
|
|
{
|
|
_nameEdit.Text = Profile?.Name ?? "";
|
|
_nameClownEdit.Text = Profile?.ClownName ?? "";
|
|
_nameMimeEdit.Text = Profile?.MimeName ?? "";
|
|
_nameBorgEdit.Text = Profile?.BorgName ?? "";
|
|
}
|
|
|
|
private void UpdateFlavorTextEdit()
|
|
{
|
|
if(_flavorTextEdit != null)
|
|
{
|
|
_flavorTextEdit.TextRope = new Rope.Leaf(Profile?.FlavorText ?? "");
|
|
}
|
|
}
|
|
|
|
private void UpdateAgeEdit()
|
|
{
|
|
_ageEdit.Text = Profile?.Age.ToString() ?? "";
|
|
}
|
|
|
|
private void UpdateSexControls()
|
|
{
|
|
if (Profile == null)
|
|
return;
|
|
|
|
_sexButton.Clear();
|
|
|
|
var sexes = new List<Sex>();
|
|
|
|
// add species sex options, default to just none if we are in bizzaro world and have no species
|
|
if (_prototypeManager.TryIndex<SpeciesPrototype>(Profile.Species, out var speciesProto))
|
|
{
|
|
foreach (var sex in speciesProto.Sexes)
|
|
{
|
|
sexes.Add(sex);
|
|
}
|
|
} else
|
|
{
|
|
sexes.Add(Sex.Unsexed);
|
|
}
|
|
|
|
// add button for each sex
|
|
foreach (var sex in sexes)
|
|
{
|
|
_sexButton.AddItem(Loc.GetString($"humanoid-profile-editor-sex-{sex.ToString().ToLower()}-text"), (int) sex);
|
|
}
|
|
|
|
if (sexes.Contains(Profile.Sex))
|
|
_sexButton.SelectId((int) Profile.Sex);
|
|
else
|
|
_sexButton.SelectId((int) sexes[0]);
|
|
}
|
|
|
|
private void UpdateSkinColor()
|
|
{
|
|
if (Profile == null)
|
|
return;
|
|
|
|
var skin = _prototypeManager.Index<SpeciesPrototype>(Profile.Species).SkinColoration;
|
|
|
|
switch (skin)
|
|
{
|
|
case HumanoidSkinColor.HumanToned:
|
|
{
|
|
if (!_skinColor.Visible)
|
|
{
|
|
_skinColor.Visible = true;
|
|
_rgbSkinColorContainer.Visible = false;
|
|
}
|
|
|
|
_skinColor.Value = SkinColor.HumanSkinToneFromColor(Profile.Appearance.SkinColor);
|
|
|
|
break;
|
|
}
|
|
case HumanoidSkinColor.Hues:
|
|
{
|
|
if (!_rgbSkinColorContainer.Visible)
|
|
{
|
|
_skinColor.Visible = false;
|
|
_rgbSkinColorContainer.Visible = true;
|
|
}
|
|
|
|
// set the RGB values to the direct values otherwise
|
|
_rgbSkinColorSelector.Color = Profile.Appearance.SkinColor;
|
|
break;
|
|
}
|
|
case HumanoidSkinColor.TintedHues:
|
|
{
|
|
if (!_rgbSkinColorContainer.Visible)
|
|
{
|
|
_skinColor.Visible = false;
|
|
_rgbSkinColorContainer.Visible = true;
|
|
}
|
|
|
|
// set the RGB values to the direct values otherwise
|
|
_rgbSkinColorSelector.Color = Profile.Appearance.SkinColor;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public void UpdateSpeciesGuidebookIcon()
|
|
{
|
|
SpeciesInfoButton.StyleClasses.Clear();
|
|
|
|
var species = Profile?.Species;
|
|
if (species is null)
|
|
return;
|
|
|
|
if (!_prototypeManager.TryIndex<SpeciesPrototype>(species, out var speciesProto))
|
|
return;
|
|
|
|
// Don't display the info button if no guide entry is found
|
|
if (!_prototypeManager.HasIndex<GuideEntryPrototype>(species))
|
|
return;
|
|
|
|
var style = speciesProto.GuideBookIcon;
|
|
SpeciesInfoButton.StyleClasses.Add(style);
|
|
}
|
|
|
|
private void UpdateMarkings()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CMarkings.SetData(Profile.Appearance.Markings, Profile.Species,
|
|
Profile.Sex, Profile.BodyType, Profile.Appearance.SkinColor, Profile.Appearance.EyeColor
|
|
);
|
|
}
|
|
|
|
private void UpdateSpecies()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!_speciesList.Exists(x => x.ID == Profile.Species))
|
|
{
|
|
CSpeciesButton.Select(0);
|
|
return;
|
|
}
|
|
|
|
CSpeciesButton.Select(_speciesList.FindIndex(x => x.ID == Profile.Species));
|
|
}
|
|
|
|
private void UpdateGenderControls()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_genderButton.SelectId((int) Profile.Gender);
|
|
}
|
|
|
|
private void UpdateClothingControls()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_clothingButton.SelectId((int) Profile.Clothing);
|
|
}
|
|
|
|
private void UpdateBackpackControls()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_backpackButton.SelectId((int) Profile.Backpack);
|
|
}
|
|
|
|
private void UpdateSpawnPriorityControls()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_spawnPriorityButton.SelectId((int) Profile.SpawnPriority);
|
|
}
|
|
|
|
private void UpdateHairPickers()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
var hairMarking = Profile.Appearance.HairStyleId switch
|
|
{
|
|
HairStyles.DefaultHairStyle => new List<Marking>(),
|
|
_ => new List<Marking> { new(Profile.Appearance.HairStyleId, new List<Color> { Profile.Appearance.HairColor }) },
|
|
};
|
|
|
|
var facialHairMarking = Profile.Appearance.FacialHairStyleId switch
|
|
{
|
|
HairStyles.DefaultFacialHairStyle => new List<Marking>(),
|
|
_ => new List<Marking> { new(Profile.Appearance.FacialHairStyleId, new List<Color> { Profile.Appearance.FacialHairColor }) },
|
|
};
|
|
|
|
_hairPicker.UpdateData(hairMarking, Profile.Species, 1);
|
|
_facialHairPicker.UpdateData(facialHairMarking, Profile.Species, 1);
|
|
}
|
|
|
|
private void UpdateCMarkingsHair()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// hair color
|
|
Color? hairColor = null;
|
|
if ( Profile.Appearance.HairStyleId != HairStyles.DefaultHairStyle &&
|
|
_markingManager.Markings.TryGetValue(Profile.Appearance.HairStyleId, out var hairProto)
|
|
)
|
|
{
|
|
if (_markingManager.CanBeApplied(Profile.Species, Profile.Sex, hairProto, _prototypeManager))
|
|
{
|
|
hairColor = _markingManager.MustMatchSkin(Profile.BodyType, HumanoidVisualLayers.Hair, out _, _prototypeManager)
|
|
? Profile.Appearance.SkinColor
|
|
: Profile.Appearance.HairColor;
|
|
}
|
|
}
|
|
if (hairColor != null)
|
|
{
|
|
CMarkings.HairMarking = new (Profile.Appearance.HairStyleId, new List<Color> { hairColor.Value });
|
|
}
|
|
else
|
|
{
|
|
CMarkings.HairMarking = null;
|
|
}
|
|
}
|
|
|
|
private void UpdateCMarkingsFacialHair()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// facial hair color
|
|
Color? facialHairColor = null;
|
|
if ( Profile.Appearance.FacialHairStyleId != HairStyles.DefaultFacialHairStyle &&
|
|
_markingManager.Markings.TryGetValue(Profile.Appearance.FacialHairStyleId, out var facialHairProto)
|
|
)
|
|
{
|
|
if (_markingManager.CanBeApplied(Profile.Species, Profile.Sex, facialHairProto, _prototypeManager))
|
|
{
|
|
if (_markingManager.MustMatchSkin(Profile.BodyType, HumanoidVisualLayers.Hair, out _, _prototypeManager))
|
|
{
|
|
facialHairColor = Profile.Appearance.SkinColor;
|
|
}
|
|
else
|
|
{
|
|
facialHairColor = Profile.Appearance.FacialHairColor;
|
|
}
|
|
}
|
|
}
|
|
if (facialHairColor != null)
|
|
{
|
|
CMarkings.FacialHairMarking = new (Profile.Appearance.FacialHairStyleId, new List<Color> { facialHairColor.Value });
|
|
}
|
|
else
|
|
{
|
|
CMarkings.FacialHairMarking = null;
|
|
}
|
|
}
|
|
|
|
private void UpdateEyePickers()
|
|
{
|
|
if (Profile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CMarkings.CurrentEyeColor = Profile.Appearance.EyeColor;
|
|
_eyesPicker.SetData(Profile.Appearance.EyeColor);
|
|
}
|
|
|
|
private void UpdateSaveButton()
|
|
{
|
|
_saveButton.Disabled = Profile is null || !IsDirty;
|
|
}
|
|
|
|
private void UpdatePreview()
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
var humanoid = _entMan.System<HumanoidAppearanceSystem>();
|
|
humanoid.LoadProfile(_previewDummy!.Value, Profile);
|
|
|
|
if (ShowClothes.Pressed)
|
|
LobbyCharacterPreviewPanel.GiveDummyJobClothes(_previewDummy!.Value, Profile);
|
|
|
|
_previewSpriteView.OverrideDirection = (Direction) ((int) _previewRotation % 4 * 2);
|
|
}
|
|
|
|
public void UpdateControls()
|
|
{
|
|
if (Profile is null)
|
|
return;
|
|
|
|
UpdateNamesEdit();
|
|
UpdateFlavorTextEdit();
|
|
UpdateSexControls();
|
|
UpdateGenderControls();
|
|
UpdateSkinColor();
|
|
UpdateSpecies();
|
|
UpdateClothingControls();
|
|
UpdateBackpackControls();
|
|
UpdateSpawnPriorityControls();
|
|
UpdateAgeEdit();
|
|
UpdateEyePickers();
|
|
UpdateSaveButton();
|
|
UpdateJobPriorities();
|
|
UpdateAntagPreferences();
|
|
UpdateTraitPreferences();
|
|
UpdateMarkings();
|
|
RebuildSpriteView();
|
|
UpdateHairPickers();
|
|
UpdateCMarkingsHair();
|
|
UpdateCMarkingsFacialHair();
|
|
|
|
//WD-EDIT
|
|
UpdateTTSVoicesControls();
|
|
UpdateBodyTypes();
|
|
//WD-EDIT
|
|
|
|
_preferenceUnavailableButton.SelectId((int) Profile.PreferenceUnavailable);
|
|
}
|
|
|
|
protected override void FrameUpdate(FrameEventArgs args)
|
|
{
|
|
base.FrameUpdate(args);
|
|
|
|
if (_needUpdatePreview)
|
|
{
|
|
UpdatePreview();
|
|
_needUpdatePreview = false;
|
|
}
|
|
}
|
|
|
|
//WD EDIT
|
|
private List<SpeciesPrototype> GetAllowedSpecies()
|
|
{
|
|
var allowedSpecies = new List<SpeciesPrototype>();
|
|
|
|
var rawSpecieList = _prototypeManager.EnumeratePrototypes<SpeciesPrototype>().Where(specie =>
|
|
{
|
|
switch (specie.RoundStart)
|
|
{
|
|
case true when specie.SponsorOnly || specie.ForAdmins:
|
|
return true;
|
|
case true:
|
|
allowedSpecies.Add(specie);
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}).ToList();
|
|
|
|
if (_sponsorsManager.TryGetInfo(out var sponsor))
|
|
{
|
|
foreach (var specie in rawSpecieList)
|
|
{
|
|
if (specie.SponsorOnly
|
|
&& sponsor.AllowedMarkings.Contains(specie.ID)
|
|
&& !allowedSpecies.Contains(specie))
|
|
{
|
|
allowedSpecies.Add(specie);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_adminManager.HasFlag(AdminFlags.AdminSpecies))
|
|
{
|
|
foreach (var specie in rawSpecieList)
|
|
{
|
|
if (specie.ForAdmins && !allowedSpecies.Contains(specie))
|
|
{
|
|
allowedSpecies.Add(specie);
|
|
}
|
|
}
|
|
}
|
|
|
|
return allowedSpecies;
|
|
}
|
|
|
|
private void SetBodyType(string newBodyType)
|
|
{
|
|
Profile = Profile?.WithBodyType(newBodyType);
|
|
IsDirty = true;
|
|
_needUpdatePreview = true;
|
|
}
|
|
|
|
//WD EDIT END
|
|
|
|
private void UpdateJobPriorities()
|
|
{
|
|
foreach (var prioritySelector in _jobPriorities)
|
|
{
|
|
var jobId = prioritySelector.Proto.ID;
|
|
|
|
var priority = Profile?.JobPriorities.GetValueOrDefault(jobId, JobPriority.Never) ?? JobPriority.Never;
|
|
|
|
prioritySelector.Priority = priority;
|
|
}
|
|
}
|
|
|
|
private abstract class RequirementsSelector<T> : Control
|
|
{
|
|
public T Proto { get; }
|
|
public bool Disabled => _lockStripe.Visible;
|
|
|
|
protected readonly RadioOptions<int> Options;
|
|
private StripeBack _lockStripe;
|
|
private Label _requirementsLabel;
|
|
|
|
protected RequirementsSelector(T proto)
|
|
{
|
|
Proto = proto;
|
|
|
|
Options = new RadioOptions<int>(RadioOptionsLayout.Horizontal)
|
|
{
|
|
FirstButtonStyle = StyleBase.ButtonOpenRight,
|
|
ButtonStyle = StyleBase.ButtonOpenBoth,
|
|
LastButtonStyle = StyleBase.ButtonOpenLeft
|
|
};
|
|
//Override default radio option button width
|
|
Options.GenerateItem = GenerateButton;
|
|
|
|
Options.OnItemSelected += args => Options.Select(args.Id);
|
|
|
|
_requirementsLabel = new Label
|
|
{
|
|
Text = Loc.GetString("role-timer-locked"),
|
|
Visible = true,
|
|
HorizontalAlignment = HAlignment.Center,
|
|
StyleClasses = {StyleBase.StyleClassLabelSubText},
|
|
};
|
|
|
|
_lockStripe = new StripeBack
|
|
{
|
|
Visible = false,
|
|
HorizontalExpand = true,
|
|
MouseFilter = MouseFilterMode.Stop,
|
|
Children =
|
|
{
|
|
_requirementsLabel
|
|
}
|
|
};
|
|
|
|
// Setup must be called after
|
|
}
|
|
|
|
/// <summary>
|
|
/// Actually adds the controls, must be called in the inheriting class' constructor.
|
|
/// </summary>
|
|
protected void Setup((string, int)[] items, string title, int titleSize, string? description, TextureRect? icon = null)
|
|
{
|
|
foreach (var (text, value) in items)
|
|
{
|
|
Options.AddItem(Loc.GetString(text), value);
|
|
}
|
|
|
|
var titleLabel = new Label
|
|
{
|
|
Margin = new Thickness(5f, 0, 5f, 0),
|
|
Text = title,
|
|
MinSize = new Vector2(titleSize, 0),
|
|
MouseFilter = MouseFilterMode.Stop,
|
|
ToolTip = description
|
|
};
|
|
|
|
var container = new BoxContainer
|
|
{
|
|
Orientation = LayoutOrientation.Horizontal,
|
|
};
|
|
|
|
if (icon != null)
|
|
container.AddChild(icon);
|
|
container.AddChild(titleLabel);
|
|
container.AddChild(Options);
|
|
container.AddChild(_lockStripe);
|
|
|
|
AddChild(container);
|
|
}
|
|
|
|
public void LockRequirements(FormattedMessage requirements)
|
|
{
|
|
var tooltip = new Tooltip();
|
|
tooltip.SetMessage(requirements);
|
|
_lockStripe.TooltipSupplier = _ => tooltip;
|
|
_lockStripe.Visible = true;
|
|
Options.Visible = false;
|
|
}
|
|
|
|
// TODO: Subscribe to roletimers event. I am too lazy to do this RN But I doubt most people will notice fn
|
|
public void UnlockRequirements()
|
|
{
|
|
_lockStripe.Visible = false;
|
|
Options.Visible = true;
|
|
}
|
|
|
|
private Button GenerateButton(string text, int value)
|
|
{
|
|
return new Button
|
|
{
|
|
Text = text,
|
|
MinWidth = 90
|
|
};
|
|
}
|
|
}
|
|
|
|
private sealed class JobPrioritySelector : RequirementsSelector<JobPrototype>
|
|
{
|
|
public JobPriority Priority
|
|
{
|
|
get => (JobPriority) Options.SelectedValue;
|
|
set => Options.SelectByValue((int) value);
|
|
}
|
|
|
|
public event Action<JobPriority>? PriorityChanged;
|
|
|
|
public JobPrioritySelector(JobPrototype proto, IPrototypeManager protoMan)
|
|
: base(proto)
|
|
{
|
|
Options.OnItemSelected += args => PriorityChanged?.Invoke(Priority);
|
|
|
|
var items = new[]
|
|
{
|
|
("humanoid-profile-editor-job-priority-high-button", (int) JobPriority.High),
|
|
("humanoid-profile-editor-job-priority-medium-button", (int) JobPriority.Medium),
|
|
("humanoid-profile-editor-job-priority-low-button", (int) JobPriority.Low),
|
|
("humanoid-profile-editor-job-priority-never-button", (int) JobPriority.Never),
|
|
};
|
|
|
|
var icon = new TextureRect
|
|
{
|
|
TextureScale = new Vector2(2, 2),
|
|
VerticalAlignment = VAlignment.Center
|
|
};
|
|
var jobIcon = protoMan.Index<StatusIconPrototype>(proto.Icon);
|
|
icon.Texture = jobIcon.Icon.Frame0();
|
|
|
|
Setup(items, proto.LocalizedName, 200, proto.LocalizedDescription, icon);
|
|
}
|
|
}
|
|
|
|
private void UpdateAntagPreferences()
|
|
{
|
|
foreach (var preferenceSelector in _antagPreferences)
|
|
{
|
|
var antagId = preferenceSelector.Proto.ID;
|
|
var preference = Profile?.AntagPreferences.Contains(antagId) ?? false;
|
|
preferenceSelector.Preference = preference;
|
|
}
|
|
}
|
|
|
|
private void UpdateTraitPreferences()
|
|
{
|
|
foreach (var preferenceSelector in _traitPreferences)
|
|
{
|
|
var traitId = preferenceSelector.Trait.ID;
|
|
var preference = Profile?.TraitPreferences.Contains(traitId) ?? false;
|
|
|
|
preferenceSelector.Preference = preference;
|
|
}
|
|
}
|
|
|
|
private sealed class AntagPreferenceSelector : RequirementsSelector<AntagPrototype>
|
|
{
|
|
// 0 is yes and 1 is no
|
|
public bool Preference
|
|
{
|
|
get => Options.SelectedValue == 0;
|
|
set => Options.Select((value && !Disabled) ? 0 : 1);
|
|
}
|
|
|
|
public event Action<bool>? PreferenceChanged;
|
|
|
|
public AntagPreferenceSelector(AntagPrototype proto)
|
|
: base(proto)
|
|
{
|
|
Options.OnItemSelected += args => PreferenceChanged?.Invoke(Preference);
|
|
|
|
var items = new[]
|
|
{
|
|
("humanoid-profile-editor-antag-preference-yes-button", 0),
|
|
("humanoid-profile-editor-antag-preference-no-button", 1)
|
|
};
|
|
var title = Loc.GetString(proto.Name);
|
|
var description = Loc.GetString(proto.Objective);
|
|
Setup(items, title, 250, description);
|
|
|
|
// immediately lock requirements if they arent met.
|
|
// another function checks Disabled after creating the selector so this has to be done now
|
|
var requirements = IoCManager.Resolve<JobRequirementsManager>();
|
|
if (proto.Requirements != null && !requirements.CheckRoleTime(proto.Requirements, out var reason))
|
|
{
|
|
LockRequirements(reason);
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class TraitPreferenceSelector : Control
|
|
{
|
|
public TraitPrototype Trait { get; }
|
|
private readonly CheckBox _checkBox;
|
|
|
|
public bool Preference
|
|
{
|
|
get => _checkBox.Pressed;
|
|
set => _checkBox.Pressed = value;
|
|
}
|
|
|
|
public event Action<bool>? PreferenceChanged;
|
|
|
|
public TraitPreferenceSelector(TraitPrototype trait)
|
|
{
|
|
Trait = trait;
|
|
|
|
_checkBox = new CheckBox {Text = Loc.GetString(trait.Name)};
|
|
_checkBox.OnToggled += OnCheckBoxToggled;
|
|
|
|
if (trait.Description is { } desc)
|
|
{
|
|
_checkBox.ToolTip = Loc.GetString(desc);
|
|
}
|
|
|
|
AddChild(new BoxContainer
|
|
{
|
|
Orientation = LayoutOrientation.Horizontal,
|
|
Children = { _checkBox },
|
|
});
|
|
}
|
|
|
|
private void OnCheckBoxToggled(BaseButton.ButtonToggledEventArgs args)
|
|
{
|
|
PreferenceChanged?.Invoke(Preference);
|
|
}
|
|
}
|
|
}
|
|
}
|