private static Profile ConvertProfiles(HumanoidCharacterProfile humanoid, int slot)
{
var appearance = (HumanoidCharacterAppearance)humanoid.CharacterAppearance;
var entity = new Profile
{
CharacterName = humanoid.Name,
Age = humanoid.Age,
Sex = humanoid.Sex.ToString(),
HairName = appearance.HairStyleName,
HairColor = appearance.HairColor.ToHex(),
FacialHairName = appearance.FacialHairStyleName,
FacialHairColor = appearance.FacialHairColor.ToHex(),
EyeColor = appearance.EyeColor.ToHex(),
SkinColor = appearance.SkinColor.ToHex(),
Slot = slot,
PreferenceUnavailable = (DbPreferenceUnavailableMode)humanoid.PreferenceUnavailable
};
entity.Jobs.AddRange(
humanoid.JobPriorities
.Where(j => j.Value != JobPriority.Never)
.Select(j => new Job {
JobName = j.Key, Priority = (DbJobPriority)j.Value
})
);
entity.Antags.AddRange(
humanoid.AntagPreferences
.Select(a => new Antag {
AntagName = a
})
);
return(entity);
}
public ChangedHumanoidAppearanceEvent(HumanoidCharacterProfile profile)
{
Appearance = profile.Appearance;
Sex = profile.Sex;
Gender = profile.Gender;
Species = profile.Species;
}
private async void HandleUpdateCharacterMessage(MsgUpdateCharacter message)
{
var slot = message.Slot;
var profile = message.Profile;
var userId = message.MsgChannel.UserId;
if (!_cachedPlayerPrefs.TryGetValue(userId, out var prefsData) || !prefsData.PrefsLoaded.IsCompleted)
{
Logger.WarningS("prefs", $"User {userId} tried to modify preferences before they loaded.");
return;
}
if (slot < 0 || slot >= MaxCharacterSlots)
{
return;
}
var curPrefs = prefsData.Prefs !;
var arr = new ICharacterProfile[MaxCharacterSlots];
curPrefs.Characters.ToList().CopyTo(arr, 0);
arr[slot] = HumanoidCharacterProfile.EnsureValid((HumanoidCharacterProfile)profile, _protos);
prefsData.Prefs = new PlayerPreferences(arr, slot);
if (ShouldStorePrefs(message.MsgChannel.AuthType))
{
await _db.SaveCharacterSlotAsync(message.MsgChannel.UserId, message.Profile, message.Slot);
}
}
private void RandomizeEverything()
{
Profile = HumanoidCharacterProfile.Random();
UpdateSexControls();
UpdateAgeEdit();
UpdateNameEdit();
UpdateHairPickers();
}
public static Dictionary <NetUserId, HumanoidCharacterProfile> AddJob(
this Dictionary <NetUserId, HumanoidCharacterProfile> inp, string jobId, JobPriority prio = JobPriority.Medium,
int amount = 1)
{
for (var i = 0; i < amount; i++)
{
inp.Add(new NetUserId(Guid.NewGuid()), HumanoidCharacterProfile.Random().WithJobPriority(jobId, prio));
}
return(inp);
}
private async Task <PlayerPreferences> GetOrCreatePreferencesAsync(NetUserId userId)
{
var prefs = await _db.GetPlayerPreferencesAsync(userId);
if (prefs is null)
{
return(await _db.InitPrefsAsync(userId, HumanoidCharacterProfile.Default()));
}
return(prefs);
}
private void RandomizeEverything()
{
Profile = HumanoidCharacterProfile.Random();
UpdateSexControls();
UpdateGenderControls();
UpdateClothingControls();
UpdateAgeEdit();
UpdateNameEdit();
UpdateHairPickers();
UpdateEyePickers();
_skinColor.Value = _random.Next(0, 100);
}
/// <summary>
/// Retrieves preferences for the given username from storage.
/// Creates and saves default preferences if they are not found, then returns them.
/// </summary>
public PlayerPreferences GetPreferences(string username)
{
var prefs = GetFromSql(username);
if (prefs is null)
{
_preferencesDb.SaveSelectedCharacterIndex(username, 0);
_preferencesDb.SaveCharacterSlot(username, HumanoidCharacterProfile.Default(), 0);
prefs = GetFromSql(username);
}
return(prefs);
}
private void OnMapInit(EntityUid uid, RandomHumanoidAppearanceComponent component, MapInitEvent args)
{
if (TryComp <HumanoidAppearanceComponent>(uid, out var appearance))
{
var profile = HumanoidCharacterProfile.Random();
_humanoidAppearance.UpdateFromProfile(uid, profile, appearance);
if (component.RandomizeName)
{
var meta = MetaData(uid);
meta.EntityName = profile.Name;
}
}
}
/// <summary>
/// Retrieves preferences for the given username from storage.
/// Creates and saves default preferences if they are not found, then returns them.
/// </summary>
public async Task <PlayerPreferences> GetPreferencesAsync(string username)
{
var prefs = await GetFromSql(username);
if (prefs is null)
{
await _preferencesDb.SaveSelectedCharacterIndexAsync(username, 0);
await _preferencesDb.SaveCharacterSlotAsync(username, HumanoidCharacterProfile.Default(), 0);
prefs = await GetFromSql(username);
}
return(prefs);
}
private static Profile ConvertProfiles(HumanoidCharacterProfile humanoid, int slot)
{
var appearance = (HumanoidCharacterAppearance)humanoid.CharacterAppearance;
List <string> markingStrings = new();
foreach (var marking in appearance.Markings)
{
markingStrings.Add(marking.ToString());
}
var markings = JsonSerializer.SerializeToDocument(markingStrings);
var entity = new Profile
{
CharacterName = humanoid.Name,
FlavorText = humanoid.FlavorText,
Species = humanoid.Species,
Age = humanoid.Age,
Sex = humanoid.Sex.ToString(),
Gender = humanoid.Gender.ToString(),
HairName = appearance.HairStyleId,
HairColor = appearance.HairColor.ToHex(),
FacialHairName = appearance.FacialHairStyleId,
FacialHairColor = appearance.FacialHairColor.ToHex(),
EyeColor = appearance.EyeColor.ToHex(),
SkinColor = appearance.SkinColor.ToHex(),
Clothing = humanoid.Clothing.ToString(),
Backpack = humanoid.Backpack.ToString(),
Markings = markings,
Slot = slot,
PreferenceUnavailable = (DbPreferenceUnavailableMode)humanoid.PreferenceUnavailable
};
entity.Jobs.AddRange(
humanoid.JobPriorities
.Where(j => j.Value != JobPriority.Never)
.Select(j => new Job {
JobName = j.Key, Priority = (DbJobPriority)j.Value
})
);
entity.Antags.AddRange(
humanoid.AntagPreferences
.Select(a => new Antag {
AntagName = a
})
);
return(entity);
}
public async Task TestDeleteCharacter()
{
var db = GetDb();
var username = new NetUserId(new Guid("640bd619-fc8d-4fe2-bf3c-4a5fb17d6ddd"));
await db.InitPrefsAsync(username, HumanoidCharacterProfile.Default());
await db.SaveCharacterSlotAsync(username, CharlieCharlieson(), 1);
await db.SaveSelectedCharacterIndexAsync(username, 1);
await db.SaveCharacterSlotAsync(username, null, 1);
var prefs = await db.GetPlayerPreferencesAsync(username);
Assert.That(!prefs.Characters.Any(p => p.Key != 0));
}
public CharacterSetupGui(
IEntityManager entityManager,
IResourceCache resourceCache,
IClientPreferencesManager preferencesManager,
IPrototypeManager prototypeManager,
IConfigurationManager configurationManager)
{
RobustXamlLoader.Load(this);
_entityManager = entityManager;
_prototypeManager = prototypeManager;
_preferencesManager = preferencesManager;
_configurationManager = configurationManager;
var panelTex = resourceCache.GetTexture("/Textures/Interface/Nano/button.svg.96dpi.png");
var back = new StyleBoxTexture
{
Texture = panelTex,
Modulate = new Color(37, 37, 42)
};
back.SetPatchMargin(StyleBox.Margin.All, 10);
BackgroundPanel.PanelOverride = back;
_createNewCharacterButton = new Button
{
Text = Loc.GetString("character-setup-gui-create-new-character-button"),
};
_createNewCharacterButton.OnPressed += args =>
{
preferencesManager.CreateCharacter(HumanoidCharacterProfile.Random());
UpdateUI();
args.Event.Handle();
};
_humanoidProfileEditor = new HumanoidProfileEditor(preferencesManager, prototypeManager, entityManager, configurationManager);
_humanoidProfileEditor.OnProfileChanged += ProfileChanged;
CharEditor.AddChild(_humanoidProfileEditor);
UpdateUI();
RulesButton.OnPressed += _ => new RulesAndInfoWindow().Open();
preferencesManager.OnServerDataLoaded += UpdateUI;
}
public async Task TestDeleteCharacter()
{
var db = GetDb();
var username = new NetUserId(new Guid("640bd619-fc8d-4fe2-bf3c-4a5fb17d6ddd"));
IoCManager.Resolve <ISerializationManager>().Initialize();
IoCManager.Resolve <IPrototypeManager>().LoadFromStream(new StringReader(Prototypes));
await db.InitPrefsAsync(username, HumanoidCharacterProfile.Default());
await db.SaveCharacterSlotAsync(username, CharlieCharlieson(), 1);
await db.SaveSelectedCharacterIndexAsync(username, 1);
await db.SaveCharacterSlotAsync(username, null, 1);
var prefs = await db.GetPlayerPreferencesAsync(username);
Assert.That(!prefs.Characters.Any(p => p.Key != 0));
}
private string PickBestAvailableJob(HumanoidCharacterProfile profile)
{
var available = GetAvailablePositions();
bool TryPick(JobPriority priority, out string jobId)
{
var filtered = profile.JobPriorities
.Where(p => p.Value == priority)
.Select(p => p.Key)
.ToList();
while (filtered.Count != 0)
{
jobId = _robustRandom.Pick(filtered);
if (available.GetValueOrDefault(jobId, 0) > 0)
{
return(true);
}
filtered.Remove(jobId);
}
jobId = default;
return(false);
}
if (TryPick(JobPriority.High, out var picked))
{
return(picked);
}
if (TryPick(JobPriority.Medium, out picked))
{
return(picked);
}
if (TryPick(JobPriority.Low, out picked))
{
return(picked);
}
return(OverflowJob);
}
public async void OnClientConnected(IPlayerSession session)
{
if (!ShouldStorePrefs(session.ConnectedClient.AuthType))
{
// Don't store data for guests.
var prefsData = new PlayerPrefData
{
PrefsLoaded = Task.CompletedTask,
Prefs = new PlayerPreferences(
new[] { new KeyValuePair <int, ICharacterProfile>(0, HumanoidCharacterProfile.Default()) },
0)
};
_cachedPlayerPrefs[session.UserId] = prefsData;
}
else
{
var prefsData = new PlayerPrefData();
var loadTask = LoadPrefs();
prefsData.PrefsLoaded = loadTask;
_cachedPlayerPrefs[session.UserId] = prefsData;
await loadTask;
async Task LoadPrefs()
{
var prefs = await GetOrCreatePreferencesAsync(session.UserId);
prefsData.Prefs = prefs;
var msg = _netManager.CreateNetMessage <MsgPreferencesAndSettings>();
msg.Preferences = prefs;
msg.Settings = new GameSettings
{
MaxCharacterSlots = MaxCharacterSlots
};
_netManager.ServerSendMessage(msg, session.ConnectedClient);
}
}
}
private async void HandleUpdateCharacterMessage(MsgUpdateCharacter message)
{
var slot = message.Slot;
var profile = message.Profile;
var userId = message.MsgChannel.UserId;
if (profile == null)
{
Logger.WarningS("prefs",
$"User {userId} sent a {nameof(MsgUpdateCharacter)} with a null profile in slot {slot}.");
return;
}
if (!_cachedPlayerPrefs.TryGetValue(userId, out var prefsData) || !prefsData.PrefsLoaded.IsCompleted)
{
Logger.WarningS("prefs", $"User {userId} tried to modify preferences before they loaded.");
return;
}
if (slot < 0 || slot >= MaxCharacterSlots)
{
return;
}
var curPrefs = prefsData.Prefs !;
var profiles = new Dictionary <int, ICharacterProfile>(curPrefs.Characters)
{
[slot] = HumanoidCharacterProfile.EnsureValid((HumanoidCharacterProfile)profile, _protos)
};
prefsData.Prefs = new PlayerPreferences(profiles, slot);
if (ShouldStorePrefs(message.MsgChannel.AuthType))
{
await _db.SaveCharacterSlotAsync(message.MsgChannel.UserId, message.Profile, message.Slot);
}
}
public HumanoidProfileEditor(IClientPreferencesManager preferencesManager, IPrototypeManager prototypeManager)
{
_random = IoCManager.Resolve <IRobustRandom>();
_preferencesManager = preferencesManager;
var margin = new MarginContainer
{
MarginTopOverride = 10,
MarginBottomOverride = 10,
MarginLeftOverride = 10,
MarginRightOverride = 10
};
AddChild(margin);
var vBox = new VBoxContainer();
margin.AddChild(vBox);
var middleContainer = new HBoxContainer
{
SeparationOverride = 10
};
vBox.AddChild(middleContainer);
var leftColumn = new VBoxContainer();
middleContainer.AddChild(leftColumn);
#region Randomize
{
var panel = HighlightedContainer();
var randomizeEverythingButton = new Button
{
Text = Loc.GetString("Randomize everything")
};
randomizeEverythingButton.OnPressed += args => { RandomizeEverything(); };
panel.AddChild(randomizeEverythingButton);
leftColumn.AddChild(panel);
}
#endregion Randomize
#region Name
{
var panel = HighlightedContainer();
var hBox = new HBoxContainer
{
SizeFlagsVertical = SizeFlags.FillExpand
};
var nameLabel = new Label {
Text = Loc.GetString("Name:")
};
_nameEdit = new LineEdit
{
CustomMinimumSize = (270, 0),
SizeFlagsVertical = SizeFlags.ShrinkCenter
};
_nameEdit.OnTextChanged += args => { SetName(args.Text); };
var nameRandomButton = new Button
{
Text = Loc.GetString("Randomize"),
};
nameRandomButton.OnPressed += args => RandomizeName();
hBox.AddChild(nameLabel);
hBox.AddChild(_nameEdit);
hBox.AddChild(nameRandomButton);
panel.AddChild(hBox);
leftColumn.AddChild(panel);
}
#endregion Name
var tabContainer = new TabContainer {
SizeFlagsVertical = SizeFlags.FillExpand
};
vBox.AddChild(tabContainer);
#region Appearance
{
var appearanceVBox = new VBoxContainer();
tabContainer.AddChild(appearanceVBox);
tabContainer.SetTabTitle(0, Loc.GetString("Appearance"));
var sexAndAgeRow = new HBoxContainer
{
SeparationOverride = 10
};
appearanceVBox.AddChild(sexAndAgeRow);
#region Sex
{
var panel = HighlightedContainer();
var hBox = new HBoxContainer();
var sexLabel = new Label {
Text = Loc.GetString("Sex:")
};
var sexButtonGroup = new ButtonGroup();
_sexMaleButton = new Button
{
Text = Loc.GetString("Male"),
Group = sexButtonGroup
};
_sexMaleButton.OnPressed += args => { SetSex(Sex.Male); };
_sexFemaleButton = new Button
{
Text = Loc.GetString("Female"),
Group = sexButtonGroup
};
_sexFemaleButton.OnPressed += args => { SetSex(Sex.Female); };
hBox.AddChild(sexLabel);
hBox.AddChild(_sexMaleButton);
hBox.AddChild(_sexFemaleButton);
panel.AddChild(hBox);
sexAndAgeRow.AddChild(panel);
}
#endregion Sex
#region Age
{
var panel = HighlightedContainer();
var hBox = new HBoxContainer();
var ageLabel = new Label {
Text = Loc.GetString("Age:")
};
_ageEdit = new LineEdit {
CustomMinimumSize = (40, 0)
};
_ageEdit.OnTextChanged += args =>
{
if (!int.TryParse(args.Text, out var newAge))
{
return;
}
SetAge(newAge);
};
hBox.AddChild(ageLabel);
hBox.AddChild(_ageEdit);
panel.AddChild(hBox);
sexAndAgeRow.AddChild(panel);
}
#endregion Age
#region Hair
{
var panel = HighlightedContainer();
panel.SizeFlagsHorizontal = SizeFlags.None;
var hairHBox = new HBoxContainer();
_hairPicker = new HairStylePicker();
_hairPicker.Populate();
_hairPicker.OnHairStylePicked += newStyle =>
{
if (Profile is null)
{
return;
}
Profile = Profile.WithCharacterAppearance(
Profile.Appearance.WithHairStyleName(newStyle));
IsDirty = true;
};
_hairPicker.OnHairColorPicked += newColor =>
{
if (Profile is null)
{
return;
}
Profile = Profile.WithCharacterAppearance(
Profile.Appearance.WithHairColor(newColor));
IsDirty = true;
};
_facialHairPicker = new FacialHairStylePicker();
_facialHairPicker.Populate();
_facialHairPicker.OnHairStylePicked += newStyle =>
{
if (Profile is null)
{
return;
}
Profile = Profile.WithCharacterAppearance(
Profile.Appearance.WithFacialHairStyleName(newStyle));
IsDirty = true;
};
_facialHairPicker.OnHairColorPicked += newColor =>
{
if (Profile is null)
{
return;
}
Profile = Profile.WithCharacterAppearance(
Profile.Appearance.WithFacialHairColor(newColor));
IsDirty = true;
};
hairHBox.AddChild(_hairPicker);
hairHBox.AddChild(_facialHairPicker);
panel.AddChild(hairHBox);
appearanceVBox.AddChild(panel);
}
#endregion Hair
}
#endregion
#region Jobs
{
var jobList = new VBoxContainer();
var jobVBox = new VBoxContainer
{
Children =
{
(_preferenceUnavailableButton = new OptionButton()),
new ScrollContainer
{
SizeFlagsVertical = SizeFlags.FillExpand,
Children =
{
jobList
}
}
}
};
tabContainer.AddChild(jobVBox);
tabContainer.SetTabTitle(1, Loc.GetString("Jobs"));
_preferenceUnavailableButton.AddItem(
Loc.GetString("Stay in lobby if preference unavailable."),
(int)PreferenceUnavailableMode.StayInLobby);
_preferenceUnavailableButton.AddItem(
Loc.GetString("Be an {0} if preference unavailable.",
Loc.GetString(SharedGameTicker.OverflowJobName)),
(int)PreferenceUnavailableMode.SpawnAsOverflow);
_preferenceUnavailableButton.OnItemSelected += args =>
{
_preferenceUnavailableButton.SelectId(args.Id);
Profile = Profile.WithPreferenceUnavailable((PreferenceUnavailableMode)args.Id);
IsDirty = true;
};
_jobPriorities = new List <JobPrioritySelector>();
foreach (var job in prototypeManager.EnumeratePrototypes <JobPrototype>().OrderBy(j => j.Name))
{
var selector = new JobPrioritySelector(job);
jobList.AddChild(selector);
_jobPriorities.Add(selector);
selector.PriorityChanged += priority =>
{
Profile = Profile.WithJobPriority(job.ID, priority);
IsDirty = true;
if (priority == JobPriority.High)
{
// Lower any other high priorities to medium.
foreach (var jobSelector in _jobPriorities)
{
if (jobSelector != selector && jobSelector.Priority == JobPriority.High)
{
jobSelector.Priority = JobPriority.Medium;
Profile = Profile.WithJobPriority(jobSelector.Job.ID, JobPriority.Medium);
}
}
}
};
}
}
#endregion
#region Antags
{
var antagList = new VBoxContainer();
var antagVBox = new VBoxContainer
{
Children =
{
new ScrollContainer
{
SizeFlagsVertical = SizeFlags.FillExpand,
Children =
{
antagList
}
}
}
};
tabContainer.AddChild(antagVBox);
tabContainer.SetTabTitle(2, Loc.GetString("Antags"));
_antagPreferences = new List <AntagPreferenceSelector>();
foreach (var antag in prototypeManager.EnumeratePrototypes <AntagPrototype>().OrderBy(a => a.Name))
{
if (!antag.SetPreference)
{
continue;
}
var selector = new AntagPreferenceSelector(antag);
antagList.AddChild(selector);
_antagPreferences.Add(selector);
selector.PreferenceChanged += preference =>
{
Profile = Profile.WithAntagPreference(antag.ID, preference);
IsDirty = true;
};
}
}
#endregion
var rightColumn = new VBoxContainer();
middleContainer.AddChild(rightColumn);
#region Import/Export
{
var panelContainer = HighlightedContainer();
var hBox = new HBoxContainer();
var importButton = new Button
{
Text = Loc.GetString("Import"),
Disabled = true,
ToolTip = "Not yet implemented!"
};
var exportButton = new Button
{
Text = Loc.GetString("Export"),
Disabled = true,
ToolTip = "Not yet implemented!"
};
hBox.AddChild(importButton);
hBox.AddChild(exportButton);
panelContainer.AddChild(hBox);
rightColumn.AddChild(panelContainer);
}
#endregion Import/Export
#region Save
{
var panel = HighlightedContainer();
_saveButton = new Button
{
Text = Loc.GetString("Save"),
SizeFlagsHorizontal = SizeFlags.ShrinkCenter
};
_saveButton.OnPressed += args => { Save(); };
panel.AddChild(_saveButton);
rightColumn.AddChild(panel);
}
#endregion Save
if (preferencesManager.ServerDataLoaded)
{
LoadServerData();
}
preferencesManager.OnServerDataLoaded += LoadServerData;
IsDirty = false;
}
private void SetName(string newName)
{
Profile = Profile?.WithName(newName);
IsDirty = true;
}
private void SetSex(Sex newSex)
{
Profile = Profile?.WithSex(newSex);
IsDirty = true;
}
private void SetAge(int newAge)
{
Profile = Profile?.WithAge(newAge);
IsDirty = true;
}
private void LoadServerData()
{
Profile = (HumanoidCharacterProfile)_preferencesManager.Preferences.SelectedCharacter;
CharacterSlot = _preferencesManager.Preferences.SelectedCharacterIndex;
UpdateControls();
}
public async Task CreateDeleteCreateTest()
{
var serverOptions = new ServerContentIntegrationOption
{
CVarOverrides =
{
[CCVars.GameDummyTicker.Name] = "false",
[CCVars.GameLobbyEnabled.Name] = "true",
[CVars.NetPVS.Name] = "false"
}
};
var(client, server) = await StartConnectedServerClientPair(serverOptions : serverOptions);
var clientNetManager = client.ResolveDependency <IClientNetManager>();
var clientStateManager = client.ResolveDependency <IStateManager>();
var clientPrefManager = client.ResolveDependency <IClientPreferencesManager>();
var serverConfig = server.ResolveDependency <IConfigurationManager>();
var serverTicker = server.ResolveDependency <IEntitySystemManager>().GetEntitySystem <GameTicker>();
var serverPrefManager = server.ResolveDependency <IServerPreferencesManager>();
await server.WaitIdleAsync();
await client.WaitIdleAsync();
await server.WaitAssertion(() =>
{
serverConfig.SetCVar(CCVars.GameDummyTicker, false);
serverConfig.SetCVar(CCVars.GameLobbyEnabled, true);
serverTicker.RestartRound();
Assert.That(serverTicker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
});
// Need to run them in sync to receive the messages.
await RunTicksSync(client, server, 1);
await WaitUntil(client, () => clientStateManager.CurrentState is LobbyState, 600);
Assert.NotNull(clientNetManager.ServerChannel);
var clientNetId = clientNetManager.ServerChannel.UserId;
HumanoidCharacterProfile profile = null;
await client.WaitAssertion(() =>
{
clientPrefManager.SelectCharacter(0);
var clientCharacters = clientPrefManager.Preferences?.Characters;
Assert.That(clientCharacters, Is.Not.Null);
Assert.That(clientCharacters.Count, Is.EqualTo(1));
Assert.That(clientStateManager.CurrentState, Is.TypeOf <LobbyState>());
profile = HumanoidCharacterProfile.Random();
clientPrefManager.CreateCharacter(profile);
clientCharacters = clientPrefManager.Preferences?.Characters;
Assert.That(clientCharacters, Is.Not.Null);
Assert.That(clientCharacters.Count, Is.EqualTo(2));
Assert.That(clientCharacters[1].MemberwiseEquals(profile));
});
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
Assert.That(serverCharacters.Count, Is.EqualTo(2));
Assert.That(serverCharacters[1].MemberwiseEquals(profile));
});
await client.WaitAssertion(() =>
{
clientPrefManager.DeleteCharacter(1);
var clientCharacters = clientPrefManager.Preferences?.Characters.Count;
Assert.That(clientCharacters, Is.EqualTo(1));
});
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 1, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters.Count;
Assert.That(serverCharacters, Is.EqualTo(1));
});
await client.WaitIdleAsync();
await client.WaitAssertion(() =>
{
profile = HumanoidCharacterProfile.Random();
clientPrefManager.CreateCharacter(profile);
var clientCharacters = clientPrefManager.Preferences?.Characters;
Assert.That(clientCharacters, Is.Not.Null);
Assert.That(clientCharacters.Count, Is.EqualTo(2));
Assert.That(clientCharacters[1].MemberwiseEquals(profile));
});
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
Assert.That(serverCharacters.Count, Is.EqualTo(2));
Assert.That(serverCharacters[1].MemberwiseEquals(profile));
});
}
public void EquipStartingGear(IEntity entity, StartingGearPrototype startingGear, HumanoidCharacterProfile profile)
{
}
public ClonerDNAEntry(Mind.Mind m, HumanoidCharacterProfile hcp)
{
Mind = m;
Profile = hcp;
}
public async Task CreateDeleteCreateTest()
{
var(client, server) = await StartConnectedServerClientPair();
var clientNetManager = client.ResolveDependency <IClientNetManager>();
var clientStateManager = client.ResolveDependency <IStateManager>();
var clientPrefManager = client.ResolveDependency <IClientPreferencesManager>();
var serverConfig = server.ResolveDependency <IConfigurationManager>();
var serverTicker = server.ResolveDependency <IGameTicker>();
var serverPrefManager = server.ResolveDependency <IServerPreferencesManager>();
await server.WaitIdleAsync();
await client.WaitIdleAsync();
await server.WaitAssertion(() =>
{
serverConfig.SetCVar(CCVars.GameLobbyEnabled, true);
serverTicker.RestartRound();
});
Assert.That(serverTicker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
await WaitUntil(client, () => clientStateManager.CurrentState is LobbyState, maxTicks : 60);
Assert.NotNull(clientNetManager.ServerChannel);
var clientNetId = clientNetManager.ServerChannel.UserId;
HumanoidCharacterProfile profile = null;
await client.WaitAssertion(() =>
{
clientPrefManager.SelectCharacter(0);
var clientCharacters = clientPrefManager.Preferences.Characters;
Assert.That(clientCharacters.Count, Is.EqualTo(1));
Assert.That(clientStateManager.CurrentState, Is.TypeOf <LobbyState>());
profile = HumanoidCharacterProfile.Random();
clientPrefManager.CreateCharacter(profile);
clientCharacters = clientPrefManager.Preferences.Characters;
Assert.That(clientCharacters.Count, Is.EqualTo(2));
Assert.That(clientCharacters[1].MemberwiseEquals(profile));
});
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
Assert.That(serverCharacters.Count, Is.EqualTo(2));
Assert.That(serverCharacters[1].MemberwiseEquals(profile));
});
await client.WaitAssertion(() =>
{
clientPrefManager.DeleteCharacter(1);
var clientCharacters = clientPrefManager.Preferences.Characters.Count;
Assert.That(clientCharacters, Is.EqualTo(1));
});
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 1, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters.Count;
Assert.That(serverCharacters, Is.EqualTo(1));
});
await client.WaitIdleAsync();
await client.WaitAssertion(() =>
{
profile = HumanoidCharacterProfile.Random();
clientPrefManager.CreateCharacter(profile);
var clientCharacters = clientPrefManager.Preferences.Characters;
Assert.That(clientCharacters.Count, Is.EqualTo(2));
Assert.That(clientCharacters[1].MemberwiseEquals(profile));
});
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
Assert.That(serverCharacters.Count, Is.EqualTo(2));
Assert.That(serverCharacters[1].MemberwiseEquals(profile));
});
}
private void NameChanged(string newName)
{
Profile = Profile?.WithName(newName);
IsDirty = true;
}
public async Task CreateDeleteCreateTest()
{
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { InLobby = true });
var server = pairTracker.Pair.Server;
var client = pairTracker.Pair.Client;
var clientNetManager = client.ResolveDependency <IClientNetManager>();
var clientStateManager = client.ResolveDependency <IStateManager>();
var clientPrefManager = client.ResolveDependency <IClientPreferencesManager>();
var serverPrefManager = server.ResolveDependency <IServerPreferencesManager>();
// Need to run them in sync to receive the messages.
await PoolManager.RunTicksSync(pairTracker.Pair, 1);
await PoolManager.WaitUntil(client, () => clientStateManager.CurrentState is LobbyState, 600);
Assert.NotNull(clientNetManager.ServerChannel);
var clientNetId = clientNetManager.ServerChannel.UserId;
HumanoidCharacterProfile profile = null;
await client.WaitAssertion(() =>
{
clientPrefManager.SelectCharacter(0);
var clientCharacters = clientPrefManager.Preferences?.Characters;
Assert.That(clientCharacters, Is.Not.Null);
Assert.That(clientCharacters.Count, Is.EqualTo(1));
Assert.That(clientStateManager.CurrentState, Is.TypeOf <LobbyState>());
profile = HumanoidCharacterProfile.Random();
clientPrefManager.CreateCharacter(profile);
clientCharacters = clientPrefManager.Preferences?.Characters;
Assert.That(clientCharacters, Is.Not.Null);
Assert.That(clientCharacters.Count, Is.EqualTo(2));
Assert.That(clientCharacters[1].MemberwiseEquals(profile));
});
await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
Assert.That(serverCharacters.Count, Is.EqualTo(2));
Assert.That(serverCharacters[1].MemberwiseEquals(profile));
});
await client.WaitAssertion(() =>
{
clientPrefManager.DeleteCharacter(1);
var clientCharacters = clientPrefManager.Preferences?.Characters.Count;
Assert.That(clientCharacters, Is.EqualTo(1));
});
await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 1, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters.Count;
Assert.That(serverCharacters, Is.EqualTo(1));
});
await client.WaitIdleAsync();
await client.WaitAssertion(() =>
{
profile = HumanoidCharacterProfile.Random();
clientPrefManager.CreateCharacter(profile);
var clientCharacters = clientPrefManager.Preferences?.Characters;
Assert.That(clientCharacters, Is.Not.Null);
Assert.That(clientCharacters.Count, Is.EqualTo(2));
Assert.That(clientCharacters[1].MemberwiseEquals(profile));
});
await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks : 60);
await server.WaitAssertion(() =>
{
var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
Assert.That(serverCharacters.Count, Is.EqualTo(2));
Assert.That(serverCharacters[1].MemberwiseEquals(profile));
});
await pairTracker.CleanReturnAsync();
}
