716 lines
26 KiB
C#
716 lines
26 KiB
C#
using System.Numerics;
|
|
using AcDream.App.UI;
|
|
using AcDream.App.UI.Layout;
|
|
using AcDream.Runtime;
|
|
using AcDream.Runtime.Session;
|
|
|
|
namespace AcDream.App.Tests.UI.Layout;
|
|
|
|
public sealed class CharacterManagementUiControllerTests
|
|
{
|
|
[Fact]
|
|
public void AuthoredChildContract_PreservesRuntimeOrderGreyTailHighlightAndButtonMatrix()
|
|
{
|
|
using var environment = new EnvironmentHarness();
|
|
CharacterManagementUiController controller = environment.Controller;
|
|
|
|
Assert.True(controller.Root.Visible);
|
|
Assert.Equal(
|
|
CharacterManagementUiController.RootElementId,
|
|
controller.Root.DatElementId);
|
|
Assert.IsType<UiTemplateListBox>(environment.Screen.FindElement(
|
|
CharacterManagementUiController.ListElementId));
|
|
UiButton create = environment.Button(
|
|
CharacterManagementUiController.CreateElementId);
|
|
UiButton enter = environment.Button(
|
|
CharacterManagementUiController.EnterElementId);
|
|
UiButton delete = environment.Button(
|
|
CharacterManagementUiController.DeleteElementId);
|
|
UiButton restore = environment.Button(
|
|
CharacterManagementUiController.RestoreElementId);
|
|
|
|
Assert.True(create.Visible);
|
|
Assert.False(create.Enabled);
|
|
Assert.Null(create.OnClick);
|
|
Assert.True(enter.Enabled);
|
|
Assert.True(delete.Visible);
|
|
Assert.True(delete.Enabled);
|
|
Assert.False(restore.Visible);
|
|
Assert.False(restore.Enabled);
|
|
|
|
// Runtime owns wcscmp sorting and the stable grey-to-tail partition.
|
|
// "Aaron (pending)" would sort first if App incorrectly re-sorted it;
|
|
// the controller must preserve this exact borrowed display order.
|
|
Assert.Equal(
|
|
["Alpha", "Zulu", "Aaron (pending)"],
|
|
controller.Rows.Select(static row => row.Label!).ToArray());
|
|
Assert.True(controller.Rows[0].Selected);
|
|
Assert.False(controller.Rows[1].Selected);
|
|
Assert.Equal(Vector4.One, controller.Rows[0].LabelColor);
|
|
Assert.Equal(new Vector4(1f, 0f, 0f, 1f), controller.Rows[2].LabelColor);
|
|
Assert.DoesNotContain(
|
|
Descendants(controller.Root),
|
|
static element => element is UiViewport);
|
|
|
|
controller.Rows[2].OnClick!();
|
|
|
|
Assert.Equal(1, environment.Runtime.HighlightCalls);
|
|
Assert.Equal(0x50000003u,
|
|
environment.Runtime.View.Snapshot.HighlightedCharacterId);
|
|
Assert.True(controller.Rows[2].Selected);
|
|
Assert.False(enter.Enabled);
|
|
Assert.False(delete.Visible);
|
|
Assert.False(delete.Enabled);
|
|
Assert.True(restore.Visible);
|
|
Assert.True(restore.Enabled);
|
|
}
|
|
|
|
[Fact]
|
|
public void DeleteConfirmation_IsCaseInsensitive_ThenWaitsThroughAckUntilFreshRoster()
|
|
{
|
|
using var environment = new EnvironmentHarness();
|
|
CharacterManagementUiController controller = environment.Controller;
|
|
UiButton delete = environment.Button(
|
|
CharacterManagementUiController.DeleteElementId);
|
|
|
|
// A wrong typed response closes the modal and cancels Runtime's exact
|
|
// pending-delete owner without sending the wire request.
|
|
delete.OnClick!();
|
|
ImportedLayout wrong = environment.LastDialog(
|
|
RetailDialogType.ConfirmationTextInput);
|
|
Assert.Contains("Alpha", Message(wrong));
|
|
Assert.Contains("Type DELETE", Message(wrong));
|
|
Input(wrong).SetText("not delete");
|
|
DialogButton(
|
|
wrong,
|
|
RetailConfirmationTextInputDialogView.AcceptButtonId).OnClick!();
|
|
Assert.Equal(1, environment.Runtime.CancelCalls);
|
|
Assert.Equal(0, environment.Runtime.ConfirmDeleteCalls);
|
|
Assert.Equal(0u, controller.DeleteDialogContext);
|
|
Assert.False(environment.Dialogs.IsOpen);
|
|
|
|
// Retail compares the localized response case-insensitively.
|
|
delete.OnClick!();
|
|
ImportedLayout accepted = environment.LastDialog(
|
|
RetailDialogType.ConfirmationTextInput);
|
|
Input(accepted).SetText("delete");
|
|
DialogButton(
|
|
accepted,
|
|
RetailConfirmationTextInputDialogView.AcceptButtonId).OnClick!();
|
|
|
|
Assert.Equal(1, environment.Runtime.ConfirmDeleteCalls);
|
|
Assert.Equal(
|
|
RuntimeCharacterSelectionOperation.DeleteRequested,
|
|
environment.Runtime.View.Snapshot.Operation);
|
|
uint waitContext = controller.OperationWaitContext;
|
|
Assert.NotEqual(0u, waitContext);
|
|
Assert.Equal(
|
|
RetailDialogType.Wait,
|
|
environment.DialogLayouts[^1].Type);
|
|
Assert.Equal("Please Wait", Message(environment.DialogLayouts[^1].Layout));
|
|
|
|
// Opcode-only ack does not close the wait. Neither does silence.
|
|
environment.Runtime.SetOperation(
|
|
RuntimeCharacterSelectionOperation.DeleteAcknowledged);
|
|
controller.Tick();
|
|
controller.Tick();
|
|
Assert.Equal(waitContext, controller.OperationWaitContext);
|
|
|
|
// Retail closes via the fresh CharacterList rebuild that follows ack.
|
|
environment.Runtime.ReplaceRoster(
|
|
[
|
|
new RuntimeCharacterSelectionEntry(1, 0x50000002u, "Zulu", 0u),
|
|
new RuntimeCharacterSelectionEntry(2, 0x50000003u, "Aaron (pending)", 1u),
|
|
],
|
|
highlightedCharacterId: 0x50000002u);
|
|
controller.Tick();
|
|
|
|
Assert.Equal(0u, controller.OperationWaitContext);
|
|
Assert.False(environment.Dialogs.IsOpen);
|
|
Assert.Equal(
|
|
["Zulu", "Aaron (pending)"],
|
|
controller.Rows.Select(static row => row.Label!).ToArray());
|
|
}
|
|
|
|
[Fact]
|
|
public void AuthoredRowDoubleActivation_EntersTheHighlightedCharacter()
|
|
{
|
|
using var environment = new EnvironmentHarness();
|
|
CharacterManagementUiController controller = environment.Controller;
|
|
UiButton row = controller.Rows[1];
|
|
|
|
Assert.True(row.OnEvent(new UiEvent(
|
|
row.EventId,
|
|
row,
|
|
UiEventType.Click)));
|
|
Assert.True(row.OnEvent(new UiEvent(
|
|
row.EventId,
|
|
row,
|
|
UiEventType.DoubleClick)));
|
|
|
|
Assert.Equal(1, environment.Runtime.HighlightCalls);
|
|
Assert.Equal(0x50000002u,
|
|
environment.Runtime.View.Snapshot.HighlightedCharacterId);
|
|
Assert.Equal(1, environment.Runtime.EnterCalls);
|
|
Assert.Equal(
|
|
RuntimeCharacterSelectionLifecycle.EnteringWorld,
|
|
environment.Runtime.View.Snapshot.Lifecycle);
|
|
Assert.NotEqual(0u, controller.EnterWaitContext);
|
|
}
|
|
|
|
[Fact]
|
|
public void RestoreSilenceExpires_EnterTransitions_AndErrorUsesMessageDialog()
|
|
{
|
|
using var environment = new EnvironmentHarness();
|
|
CharacterManagementUiController controller = environment.Controller;
|
|
|
|
controller.Rows[2].OnClick!();
|
|
environment.Button(CharacterManagementUiController.RestoreElementId).OnClick!();
|
|
uint restoreWait = controller.OperationWaitContext;
|
|
Assert.NotEqual(0u, restoreWait);
|
|
Assert.Equal(
|
|
RuntimeCharacterSelectionOperation.RestoreRequested,
|
|
environment.Runtime.View.Snapshot.Operation);
|
|
|
|
// ACE may send no restore response. Runtime's correlation expiry is
|
|
// represented by Operation=None; the presentation never owns a timer.
|
|
controller.Tick();
|
|
Assert.Equal(restoreWait, controller.OperationWaitContext);
|
|
environment.Runtime.SetOperation(RuntimeCharacterSelectionOperation.None);
|
|
controller.Tick();
|
|
Assert.Equal(0u, controller.OperationWaitContext);
|
|
Assert.False(environment.Dialogs.IsOpen);
|
|
|
|
controller.Rows[0].OnClick!();
|
|
environment.Button(CharacterManagementUiController.EnterElementId).OnClick!();
|
|
Assert.Equal(1, environment.Runtime.EnterCalls);
|
|
Assert.Equal(
|
|
RuntimeCharacterSelectionLifecycle.EnteringWorld,
|
|
environment.Runtime.View.Snapshot.Lifecycle);
|
|
Assert.NotEqual(0u, controller.EnterWaitContext);
|
|
Assert.Equal("Entering World", Message(
|
|
environment.LastDialog(RetailDialogType.Wait)));
|
|
|
|
environment.Runtime.SetError("That character is unavailable.");
|
|
controller.Tick();
|
|
Assert.Equal(0u, controller.EnterWaitContext);
|
|
Assert.NotEqual(0u, controller.ErrorDialogContext);
|
|
ImportedLayout error = environment.LastDialog(RetailDialogType.Message);
|
|
Assert.Equal("That character is unavailable.", Message(error));
|
|
DialogButton(error, RetailMessageDialogView.OkButtonId).OnClick!();
|
|
Assert.Equal(1, environment.Runtime.CancelCalls);
|
|
Assert.Null(environment.Runtime.View.Snapshot.Error);
|
|
Assert.False(environment.Dialogs.IsOpen);
|
|
|
|
// CharacterError.NumErrors is ignored by Runtime without a revision;
|
|
// an unchanged, error-free projection must not manufacture a dialog.
|
|
int createdBeforeSentinel = environment.DialogLayouts.Count;
|
|
controller.Tick();
|
|
Assert.Equal(createdBeforeSentinel, environment.DialogLayouts.Count);
|
|
|
|
environment.Button(CharacterManagementUiController.EnterElementId).OnClick!();
|
|
Assert.NotEqual(0u, controller.EnterWaitContext);
|
|
environment.Runtime.SetLifecycle(
|
|
RuntimeCharacterSelectionLifecycle.InWorld);
|
|
controller.Tick();
|
|
Assert.False(controller.Root.Visible);
|
|
Assert.Equal(0u, controller.EnterWaitContext);
|
|
Assert.False(environment.Dialogs.IsOpen);
|
|
}
|
|
|
|
[Fact]
|
|
public void MissingOrDisposedBorrowedView_ClosesDialogsFlushesRowsAndDisposesSafely()
|
|
{
|
|
using var environment = new EnvironmentHarness();
|
|
CharacterManagementUiController controller = environment.Controller;
|
|
environment.Button(CharacterManagementUiController.DeleteElementId).OnClick!();
|
|
Assert.NotEqual(0u, controller.DeleteDialogContext);
|
|
|
|
environment.Runtime.ProvideView = false;
|
|
controller.Tick();
|
|
|
|
Assert.False(controller.Root.Visible);
|
|
Assert.Empty(controller.Rows);
|
|
Assert.False(environment.Dialogs.IsOpen);
|
|
Assert.Equal(0, environment.Runtime.CancelCalls);
|
|
|
|
controller.Dispose();
|
|
Assert.Null(controller.Root.Parent);
|
|
Assert.Null(environment.Button(
|
|
CharacterManagementUiController.EnterElementId).OnClick);
|
|
controller.Tick();
|
|
}
|
|
|
|
[Fact]
|
|
public void SessionReset_ClosesOwnedContextsWithoutReentrantCancel()
|
|
{
|
|
using var environment = new EnvironmentHarness();
|
|
CharacterManagementUiController controller = environment.Controller;
|
|
environment.Button(CharacterManagementUiController.DeleteElementId).OnClick!();
|
|
Assert.NotEqual(0u, controller.DeleteDialogContext);
|
|
|
|
controller.ResetSession();
|
|
|
|
Assert.False(controller.Root.Visible);
|
|
Assert.Empty(controller.Rows);
|
|
Assert.False(environment.Dialogs.IsOpen);
|
|
Assert.Equal(0, environment.Runtime.CancelCalls);
|
|
}
|
|
|
|
[Fact]
|
|
public void PreviewViewport_IsRejectedBeforeTheAuthoredScreenIsMounted()
|
|
{
|
|
var host = new UiRoot { Width = 800f, Height = 600f };
|
|
ImportedLayout screen = BuildScreen(includePreview: true);
|
|
using var dialogs = new RetailDialogFactory(
|
|
host,
|
|
RetailDialogFactoryTests.BuildDialogLayout);
|
|
var runtime = new FakeRuntime();
|
|
|
|
CharacterManagementUiController? controller =
|
|
CharacterManagementUiController.Bind(
|
|
host,
|
|
screen,
|
|
static (_, _) => BuildRow(),
|
|
dialogs,
|
|
runtime.Bindings,
|
|
TestStrings());
|
|
|
|
Assert.Null(controller);
|
|
Assert.Empty(host.Children);
|
|
}
|
|
|
|
[Fact]
|
|
public void TransientTemplateMiss_DoesNotConsumeTheRuntimeRevision()
|
|
{
|
|
var host = new UiRoot { Width = 800f, Height = 600f };
|
|
ImportedLayout screen = BuildScreen();
|
|
using var dialogs = new RetailDialogFactory(
|
|
host,
|
|
RetailDialogFactoryTests.BuildDialogLayout);
|
|
var runtime = new FakeRuntime();
|
|
int resolveCalls = 0;
|
|
using CharacterManagementUiController controller =
|
|
Assert.IsType<CharacterManagementUiController>(
|
|
CharacterManagementUiController.Bind(
|
|
host,
|
|
screen,
|
|
(_, _) => ++resolveCalls == 1 ? null : BuildRow(),
|
|
dialogs,
|
|
runtime.Bindings,
|
|
TestStrings()));
|
|
|
|
Assert.Empty(controller.Rows);
|
|
controller.Tick();
|
|
|
|
Assert.Equal(3, controller.Rows.Count);
|
|
Assert.True(resolveCalls >= 4);
|
|
}
|
|
|
|
private static CharacterManagementUiController.DialogStrings TestStrings() =>
|
|
new(
|
|
name => $"WARNING! {name}\nType DELETE in the box below.",
|
|
"DELETE",
|
|
"Please Wait",
|
|
"Entering World");
|
|
|
|
private static ImportedLayout BuildScreen(bool includePreview = false)
|
|
{
|
|
var root = new ElementInfo
|
|
{
|
|
Id = CharacterManagementUiController.RootElementId,
|
|
Type = 3u,
|
|
Width = 800f,
|
|
Height = 600f,
|
|
};
|
|
var list = new ElementInfo
|
|
{
|
|
Id = CharacterManagementUiController.ListElementId,
|
|
Type = 5u,
|
|
X = 42f,
|
|
Y = 212f,
|
|
Width = 160f,
|
|
Height = 320f,
|
|
};
|
|
list.TemplateList.Add(new UiTemplateListEntry(
|
|
0x21000004u,
|
|
0x100003A5u));
|
|
root.Children.Add(list);
|
|
root.Children.Add(ButtonInfo(
|
|
CharacterManagementUiController.CreateElementId));
|
|
root.Children.Add(ButtonInfo(
|
|
CharacterManagementUiController.EnterElementId));
|
|
root.Children.Add(ButtonInfo(
|
|
CharacterManagementUiController.DeleteElementId));
|
|
root.Children.Add(ButtonInfo(
|
|
CharacterManagementUiController.RestoreElementId));
|
|
if (includePreview)
|
|
{
|
|
root.Children.Add(new ElementInfo
|
|
{
|
|
Id = 0xDEADBEEFu,
|
|
Type = 0xDu,
|
|
Width = 100f,
|
|
Height = 100f,
|
|
});
|
|
}
|
|
return LayoutImporter.Build(root, _ => (0u, 0, 0), null);
|
|
}
|
|
|
|
private static ElementInfo ButtonInfo(uint id) => new()
|
|
{
|
|
Id = id,
|
|
Type = 1u,
|
|
Width = 100f,
|
|
Height = 30f,
|
|
};
|
|
|
|
private static UiElement BuildRow() => LayoutImporter.Build(
|
|
new ElementInfo
|
|
{
|
|
Id = 0x100003A5u,
|
|
Type = 1u,
|
|
Width = 160f,
|
|
Height = 16f,
|
|
},
|
|
_ => (0u, 0, 0),
|
|
null).Root;
|
|
|
|
private static IEnumerable<UiElement> Descendants(UiElement root)
|
|
{
|
|
yield return root;
|
|
foreach (UiElement child in root.Children)
|
|
foreach (UiElement descendant in Descendants(child))
|
|
yield return descendant;
|
|
}
|
|
|
|
private static UiButton DialogButton(ImportedLayout layout, uint id) =>
|
|
Assert.IsType<UiButton>(layout.FindElement(id));
|
|
|
|
private static UiField Input(ImportedLayout layout) =>
|
|
Assert.IsType<UiField>(layout.FindElement(
|
|
RetailConfirmationTextInputDialogView.InputElementId));
|
|
|
|
private static string Message(ImportedLayout layout) => string.Join(
|
|
" ",
|
|
Assert.IsType<UiText>(layout.FindElement(0x3Eu))
|
|
.LinesProvider()
|
|
.Select(static line => line.Text));
|
|
|
|
private sealed class EnvironmentHarness : IDisposable
|
|
{
|
|
public EnvironmentHarness()
|
|
{
|
|
Host = new UiRoot { Width = 800f, Height = 600f };
|
|
Screen = BuildScreen();
|
|
Runtime = new FakeRuntime();
|
|
Dialogs = new RetailDialogFactory(Host, type =>
|
|
{
|
|
ImportedLayout layout =
|
|
RetailDialogFactoryTests.BuildDialogLayout(type);
|
|
DialogLayouts.Add((type, layout));
|
|
return layout;
|
|
});
|
|
Controller = Assert.IsType<CharacterManagementUiController>(
|
|
CharacterManagementUiController.Bind(
|
|
Host,
|
|
Screen,
|
|
static (_, _) => BuildRow(),
|
|
Dialogs,
|
|
Runtime.Bindings,
|
|
TestStrings()));
|
|
}
|
|
|
|
public UiRoot Host { get; }
|
|
public ImportedLayout Screen { get; }
|
|
public FakeRuntime Runtime { get; }
|
|
public RetailDialogFactory Dialogs { get; }
|
|
public List<(RetailDialogType Type, ImportedLayout Layout)> DialogLayouts { get; } = [];
|
|
public CharacterManagementUiController Controller { get; }
|
|
|
|
public UiButton Button(uint id) =>
|
|
Assert.IsType<UiButton>(Screen.FindElement(id));
|
|
|
|
public ImportedLayout LastDialog(RetailDialogType type) =>
|
|
DialogLayouts.Last(entry => entry.Type == type).Layout;
|
|
|
|
public void Dispose()
|
|
{
|
|
Controller.Dispose();
|
|
Dialogs.Dispose();
|
|
}
|
|
}
|
|
|
|
private sealed class FakeRuntime
|
|
{
|
|
private static readonly RuntimeGenerationToken Generation = new(7u);
|
|
|
|
public FakeRuntime()
|
|
{
|
|
View.Entries =
|
|
[
|
|
new RuntimeCharacterSelectionEntry(0, 0x50000001u, "Alpha", 0u),
|
|
new RuntimeCharacterSelectionEntry(1, 0x50000002u, "Zulu", 0u),
|
|
new RuntimeCharacterSelectionEntry(2, 0x50000003u, "Aaron (pending)", 1u),
|
|
];
|
|
View.Snapshot = Snapshot(
|
|
RuntimeCharacterSelectionLifecycle.AwaitingSelection,
|
|
revision: 1,
|
|
highlightedCharacterId: 0x50000001u,
|
|
buttons: ButtonsFor(0x50000001u));
|
|
Bindings = new CharacterSelectionRuntimeBindings(
|
|
() => ProvideView ? View : null,
|
|
Highlight,
|
|
Enter,
|
|
RequestDelete,
|
|
ConfirmDelete,
|
|
Restore,
|
|
Cancel);
|
|
}
|
|
|
|
public FakeView View { get; } = new();
|
|
public CharacterSelectionRuntimeBindings Bindings { get; }
|
|
public bool ProvideView { get; set; } = true;
|
|
public int HighlightCalls { get; private set; }
|
|
public int EnterCalls { get; private set; }
|
|
public int ConfirmDeleteCalls { get; private set; }
|
|
public int CancelCalls { get; private set; }
|
|
|
|
public void SetOperation(RuntimeCharacterSelectionOperation operation)
|
|
{
|
|
RuntimeCharacterSelectionButtons buttons = operation is
|
|
RuntimeCharacterSelectionOperation.DeleteRequested
|
|
or RuntimeCharacterSelectionOperation.DeleteAcknowledged
|
|
? RuntimeCharacterSelectionButtons.None
|
|
: ButtonsFor(View.Snapshot.HighlightedCharacterId);
|
|
Update(snapshot => snapshot with
|
|
{
|
|
Operation = operation,
|
|
Buttons = buttons,
|
|
});
|
|
}
|
|
|
|
public void ReplaceRoster(
|
|
RuntimeCharacterSelectionEntry[] entries,
|
|
uint highlightedCharacterId)
|
|
{
|
|
View.Entries = entries;
|
|
Update(snapshot => snapshot with
|
|
{
|
|
RosterCount = entries.Length,
|
|
HighlightedCharacterId = highlightedCharacterId,
|
|
HighlightedDisplayIndex = Array.FindIndex(
|
|
entries,
|
|
entry => entry.CharacterId == highlightedCharacterId),
|
|
PendingDeleteCharacterId = 0u,
|
|
Operation = RuntimeCharacterSelectionOperation.None,
|
|
Buttons = ButtonsFor(highlightedCharacterId),
|
|
});
|
|
}
|
|
|
|
public void SetLifecycle(RuntimeCharacterSelectionLifecycle lifecycle) =>
|
|
Update(snapshot => snapshot with { Lifecycle = lifecycle });
|
|
|
|
public void SetError(string message) => Update(snapshot => snapshot with
|
|
{
|
|
Lifecycle = RuntimeCharacterSelectionLifecycle.AwaitingSelection,
|
|
Error = new RuntimeCharacterSelectionError(
|
|
1u,
|
|
AcDream.Core.Net.Messages.CharacterError.Code.Logon,
|
|
message),
|
|
PendingDeleteCharacterId = 0u,
|
|
Operation = RuntimeCharacterSelectionOperation.None,
|
|
});
|
|
|
|
private RuntimeCommandResult Highlight(uint characterId)
|
|
{
|
|
HighlightCalls++;
|
|
int index = Array.FindIndex(
|
|
View.Entries,
|
|
entry => entry.CharacterId == characterId);
|
|
if (index < 0)
|
|
return Result(RuntimeCommandStatus.Rejected);
|
|
Update(snapshot => snapshot with
|
|
{
|
|
HighlightedCharacterId = characterId,
|
|
HighlightedDisplayIndex = index,
|
|
Buttons = ButtonsFor(characterId),
|
|
});
|
|
return Result(RuntimeCommandStatus.Accepted, characterId);
|
|
}
|
|
|
|
private RuntimeCommandResult Enter()
|
|
{
|
|
EnterCalls++;
|
|
Update(snapshot => snapshot with
|
|
{
|
|
Lifecycle = RuntimeCharacterSelectionLifecycle.EnteringWorld,
|
|
Error = null,
|
|
});
|
|
return Result(
|
|
RuntimeCommandStatus.Accepted,
|
|
View.Snapshot.HighlightedCharacterId);
|
|
}
|
|
|
|
private RuntimeCommandResult RequestDelete()
|
|
{
|
|
uint id = View.Snapshot.HighlightedCharacterId;
|
|
Update(snapshot => snapshot with
|
|
{
|
|
PendingDeleteCharacterId = id,
|
|
Error = null,
|
|
});
|
|
return Result(RuntimeCommandStatus.Accepted, id);
|
|
}
|
|
|
|
private RuntimeCommandResult ConfirmDelete()
|
|
{
|
|
ConfirmDeleteCalls++;
|
|
uint id = View.Snapshot.HighlightedCharacterId;
|
|
Update(snapshot => snapshot with
|
|
{
|
|
PendingDeleteCharacterId = 0u,
|
|
Operation = RuntimeCharacterSelectionOperation.DeleteRequested,
|
|
Buttons = RuntimeCharacterSelectionButtons.None,
|
|
});
|
|
return Result(RuntimeCommandStatus.Accepted, id);
|
|
}
|
|
|
|
private RuntimeCommandResult Restore()
|
|
{
|
|
uint id = View.Snapshot.HighlightedCharacterId;
|
|
Update(snapshot => snapshot with
|
|
{
|
|
LastRestoreRequestedCharacterId = id,
|
|
Operation = RuntimeCharacterSelectionOperation.RestoreRequested,
|
|
Buttons = new RuntimeCharacterSelectionButtons(
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true),
|
|
});
|
|
return Result(RuntimeCommandStatus.Accepted, id);
|
|
}
|
|
|
|
private RuntimeCommandResult Cancel()
|
|
{
|
|
CancelCalls++;
|
|
Update(snapshot => snapshot with
|
|
{
|
|
PendingDeleteCharacterId = 0u,
|
|
Error = null,
|
|
Buttons = ButtonsFor(snapshot.HighlightedCharacterId),
|
|
});
|
|
return Result(RuntimeCommandStatus.Accepted);
|
|
}
|
|
|
|
private RuntimeCharacterSelectionButtons ButtonsFor(uint characterId)
|
|
{
|
|
RuntimeCharacterSelectionEntry? selected = View.Entries
|
|
.Cast<RuntimeCharacterSelectionEntry?>()
|
|
.FirstOrDefault(entry => entry?.CharacterId == characterId);
|
|
if (selected is null)
|
|
return RuntimeCharacterSelectionButtons.None;
|
|
if (selected.Value.IsPendingDelete)
|
|
{
|
|
return new RuntimeCharacterSelectionButtons(
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
true);
|
|
}
|
|
return new RuntimeCharacterSelectionButtons(
|
|
true,
|
|
true,
|
|
false,
|
|
true,
|
|
false);
|
|
}
|
|
|
|
private void Update(
|
|
Func<RuntimeCharacterSelectionSnapshot,
|
|
RuntimeCharacterSelectionSnapshot> update)
|
|
{
|
|
RuntimeCharacterSelectionSnapshot current = View.Snapshot;
|
|
RuntimeCharacterSelectionSnapshot next = update(current);
|
|
View.Snapshot = next with { Revision = current.Revision + 1 };
|
|
}
|
|
|
|
private RuntimeCharacterSelectionSnapshot Snapshot(
|
|
RuntimeCharacterSelectionLifecycle lifecycle,
|
|
long revision,
|
|
uint highlightedCharacterId,
|
|
RuntimeCharacterSelectionButtons buttons) => new(
|
|
Generation,
|
|
lifecycle,
|
|
revision,
|
|
"account",
|
|
SlotCount: 5,
|
|
RosterCount: View.Entries.Length,
|
|
highlightedCharacterId,
|
|
HighlightedDisplayIndex: Array.FindIndex(
|
|
View.Entries,
|
|
entry => entry.CharacterId == highlightedCharacterId),
|
|
PendingDeleteCharacterId: 0u,
|
|
LastRestoreRequestedCharacterId: 0u,
|
|
Operation: RuntimeCharacterSelectionOperation.None,
|
|
Error: null,
|
|
buttons);
|
|
|
|
private static RuntimeCommandResult Result(
|
|
RuntimeCommandStatus status,
|
|
uint objectId = 0u) => new(status, Generation, objectId);
|
|
}
|
|
|
|
private sealed class FakeView : IRuntimeCharacterSelectionView
|
|
{
|
|
public RuntimeCharacterSelectionEntry[] Entries { get; set; } = [];
|
|
public RuntimeCharacterSelectionSnapshot Snapshot { get; set; }
|
|
|
|
public bool TryGetAt(
|
|
int displayIndex,
|
|
out RuntimeCharacterSelectionEntry character)
|
|
{
|
|
if ((uint)displayIndex >= (uint)Entries.Length)
|
|
{
|
|
character = default;
|
|
return false;
|
|
}
|
|
character = Entries[displayIndex];
|
|
return true;
|
|
}
|
|
|
|
public bool TryGet(
|
|
uint characterId,
|
|
out RuntimeCharacterSelectionEntry character)
|
|
{
|
|
int index = Array.FindIndex(
|
|
Entries,
|
|
entry => entry.CharacterId == characterId);
|
|
if (index < 0)
|
|
{
|
|
character = default;
|
|
return false;
|
|
}
|
|
character = Entries[index];
|
|
return true;
|
|
}
|
|
|
|
public void Visit(IRuntimeCharacterSelectionVisitor visitor)
|
|
{
|
|
foreach (RuntimeCharacterSelectionEntry character in Entries)
|
|
visitor.Visit(in character);
|
|
}
|
|
|
|
public IDisposable Subscribe(IRuntimeCharacterSelectionObserver observer) =>
|
|
NoopDisposable.Instance;
|
|
}
|
|
|
|
private sealed class NoopDisposable : IDisposable
|
|
{
|
|
public static NoopDisposable Instance { get; } = new();
|
|
public void Dispose() { }
|
|
}
|
|
}
|