467 lines
22 KiB
C#
467 lines
22 KiB
C#
using AcDream.App.UI;
|
|
using AcDream.Core.Chat;
|
|
using AcDream.Core.Items;
|
|
using AcDream.Runtime.Gameplay;
|
|
using AcDream.Runtime.Session;
|
|
|
|
namespace AcDream.App.Net;
|
|
|
|
internal sealed record LiveSessionCommandBindings(
|
|
ClientCommandController.Bindings ClientCommands,
|
|
ChatLog Chat,
|
|
TurbineChatState TurbineChat,
|
|
Func<uint> PlayerGuid,
|
|
Action<string> SendTalk,
|
|
Action<string, string> SendTell,
|
|
Action<uint, string> SendChannel,
|
|
Action<uint, uint, uint, uint, string, uint> SendTurbineChat,
|
|
Action<ShortcutEntry> AddShortcut,
|
|
Action<uint> RemoveShortcut,
|
|
Action<uint, int, int> AddFavorite,
|
|
Action<uint, int> RemoveFavorite,
|
|
Action<uint> SetSpellbookFilter,
|
|
Action<uint> ForgetSpell,
|
|
Action<uint, uint> SetDesiredComponent,
|
|
Action ClearDesiredComponents,
|
|
Action<uint, ulong> RaiseAttribute,
|
|
Action<uint, ulong> RaiseVital,
|
|
Action<uint, ulong> RaiseSkill,
|
|
Action<uint, uint> TrainSkill,
|
|
Action<string> AddFriend,
|
|
Action<uint> RemoveFriend,
|
|
Action ClearFriends,
|
|
Action RequestLegacyFriends,
|
|
// Secure trade (2026-08-14) — the CM_Trade senders.
|
|
Action<uint> OpenTradeNegotiations,
|
|
Action CloseTradeNegotiations,
|
|
Action<uint> AddToTrade,
|
|
Action<uint, bool, bool> AcceptTrade,
|
|
Action DeclineTrade,
|
|
Action ResetTrade,
|
|
Action<bool, uint, string, uint> ModifyCharacterSquelch,
|
|
Action<bool, string> ModifyAccountSquelch,
|
|
Action<bool, uint> ModifyGlobalSquelch,
|
|
// Campaign CH slice CH3 (2026-08-09): the RuntimeCommunicationState.
|
|
// AddText chokepoint (local refusals — Turbine unavailable / not
|
|
// listening) and the RuntimeCharacterState owner (Hear*Chat options +
|
|
// IsOlthoiPlayer) the Turbine membership gate reads, plus the
|
|
// SetSingleCharacterOption (0x0005) sender that replaced the malformed,
|
|
// callerless full-blob SetCharacterOptions (0x01A1) path.
|
|
RuntimeCommunicationState Communication,
|
|
RuntimeCharacterState CharacterState,
|
|
Action<uint, bool> SendSingleCharacterOption,
|
|
// Campaign OP slice OP1 (2026-08-10): the real SetCharacterOptions
|
|
// (0x01A1) blob-flush verb — CH3's TODO, now resurrected per wire
|
|
// research §2.3-§2.7. No-ops when the batched module is clean, matching
|
|
// retail's CPlayerModule::SaveToServer(force: 0).
|
|
Action SaveCharacterOptions,
|
|
// Campaign FA slice FA2 (2026-08-12): fellowship + allegiance send
|
|
// wrappers, the App-bus twin of DirectGameRuntimeCommandAdapter's
|
|
// direct session.SendXxx calls.
|
|
Action<string, bool> SendFellowshipCreate,
|
|
Action<uint> SendFellowshipRecruit,
|
|
Action<uint> SendFellowshipDismiss,
|
|
Action<bool> SendFellowshipQuit,
|
|
Action<uint> SendFellowshipAssignNewLeader,
|
|
Action<bool> SendFellowshipChangeOpenness,
|
|
Action<bool> SendFellowshipUpdateRequest,
|
|
Action<uint> SendAllegianceSwear,
|
|
Action<uint> SendAllegianceBreak,
|
|
Action<uint> SendAllegianceKick,
|
|
Action<string> SendAllegianceInfoRequest,
|
|
Action<bool> SendAllegianceUpdateRequest,
|
|
Action<string>? Log = null);
|
|
|
|
internal readonly record struct AddShortcutRuntimeCmd(ShortcutEntry Entry);
|
|
internal readonly record struct RemoveShortcutRuntimeCmd(uint Index);
|
|
internal readonly record struct AddFavoriteRuntimeCmd(
|
|
uint SpellId,
|
|
int Position,
|
|
int TabIndex);
|
|
internal readonly record struct RemoveFavoriteRuntimeCmd(
|
|
uint SpellId,
|
|
int TabIndex);
|
|
internal readonly record struct SetSpellbookFilterRuntimeCmd(uint Filters);
|
|
internal readonly record struct ForgetSpellRuntimeCmd(uint SpellId);
|
|
internal readonly record struct SetDesiredComponentRuntimeCmd(
|
|
uint ComponentId,
|
|
uint Amount);
|
|
internal readonly record struct ClearDesiredComponentsRuntimeCmd;
|
|
internal readonly record struct RaiseAttributeRuntimeCmd(uint StatId, ulong Cost);
|
|
internal readonly record struct RaiseVitalRuntimeCmd(uint StatId, ulong Cost);
|
|
internal readonly record struct RaiseSkillRuntimeCmd(uint StatId, ulong Cost);
|
|
internal readonly record struct TrainSkillRuntimeCmd(uint StatId, uint Cost);
|
|
internal readonly record struct SetSingleCharacterOptionRuntimeCmd(
|
|
uint OptionId,
|
|
bool Value);
|
|
internal readonly record struct SaveCharacterOptionsRuntimeCmd;
|
|
internal readonly record struct AddFriendRuntimeCmd(string Name);
|
|
internal readonly record struct RemoveFriendRuntimeCmd(uint CharacterId);
|
|
|
|
// ── Secure trade (2026-08-14) ──────────────────────────────────────────────
|
|
internal readonly record struct OpenTradeNegotiationsRuntimeCmd(uint PartnerGuid);
|
|
internal readonly record struct CloseTradeNegotiationsRuntimeCmd;
|
|
internal readonly record struct AddToTradeRuntimeCmd(uint ItemGuid);
|
|
internal readonly record struct AcceptTradeRuntimeCmd(
|
|
uint PartnerGuid,
|
|
bool SelfAccepted,
|
|
bool PartnerAccepted);
|
|
internal readonly record struct DeclineTradeRuntimeCmd;
|
|
internal readonly record struct ResetTradeRuntimeCmd;
|
|
internal readonly record struct ClearFriendsRuntimeCmd;
|
|
internal readonly record struct RequestLegacyFriendsRuntimeCmd;
|
|
internal readonly record struct ModifyCharacterSquelchRuntimeCmd(
|
|
bool Add,
|
|
uint CharacterId,
|
|
string Name,
|
|
uint MessageType);
|
|
internal readonly record struct ModifyAccountSquelchRuntimeCmd(
|
|
bool Add,
|
|
string Name);
|
|
internal readonly record struct ModifyGlobalSquelchRuntimeCmd(
|
|
bool Add,
|
|
uint MessageType);
|
|
|
|
// ── Fellowship / Allegiance (Campaign FA slice FA2, 2026-08-12) ────────────
|
|
internal readonly record struct FellowshipCreateRuntimeCmd(
|
|
string FellowshipName,
|
|
bool ShareXp);
|
|
internal readonly record struct FellowshipRecruitRuntimeCmd(uint TargetGuid);
|
|
internal readonly record struct FellowshipDismissRuntimeCmd(uint TargetGuid);
|
|
internal readonly record struct FellowshipQuitRuntimeCmd(bool Disband);
|
|
internal readonly record struct FellowshipAssignNewLeaderRuntimeCmd(uint NewLeaderGuid);
|
|
internal readonly record struct FellowshipChangeOpennessRuntimeCmd(bool IsOpen);
|
|
internal readonly record struct FellowshipUpdateRequestRuntimeCmd(bool PanelOpen);
|
|
internal readonly record struct AllegianceSwearRuntimeCmd(uint PatronGuid);
|
|
internal readonly record struct AllegianceBreakRuntimeCmd(uint TargetGuid);
|
|
internal readonly record struct AllegianceKickRuntimeCmd(uint VassalGuid);
|
|
internal readonly record struct AllegianceInfoRequestRuntimeCmd(string PlayerName);
|
|
internal readonly record struct AllegianceUpdateRequestRuntimeCmd(bool On);
|
|
|
|
/// <summary>
|
|
/// Owns the command surface for one exact live-session generation. The router
|
|
/// itself is the published bus, so a retained reference becomes inert before
|
|
/// the displaced transport is disposed.
|
|
/// </summary>
|
|
internal sealed class LiveSessionCommandRouter : ILiveSessionCommandRouting
|
|
{
|
|
private readonly object _gate = new();
|
|
private LiveCommandBus? _commands;
|
|
private LiveChatCommandRoute? _chatCommands;
|
|
private ClientCommandController.Bindings? _clientCommands;
|
|
private int _state; // 0 = constructed, 1 = active, 2 = disposed
|
|
|
|
public LiveSessionCommandRouter(LiveSessionCommandBindings bindings)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(bindings);
|
|
ArgumentNullException.ThrowIfNull(bindings.ClientCommands);
|
|
ArgumentNullException.ThrowIfNull(bindings.Chat);
|
|
ArgumentNullException.ThrowIfNull(bindings.TurbineChat);
|
|
ArgumentNullException.ThrowIfNull(bindings.PlayerGuid);
|
|
ArgumentNullException.ThrowIfNull(bindings.SendTalk);
|
|
ArgumentNullException.ThrowIfNull(bindings.SendTell);
|
|
ArgumentNullException.ThrowIfNull(bindings.SendChannel);
|
|
ArgumentNullException.ThrowIfNull(bindings.SendTurbineChat);
|
|
ArgumentNullException.ThrowIfNull(bindings.Communication);
|
|
ArgumentNullException.ThrowIfNull(bindings.CharacterState);
|
|
|
|
_clientCommands = bindings.ClientCommands;
|
|
var commands = new LiveCommandBus();
|
|
var clientCommands = new ClientCommandController(
|
|
BuildGuardedClientCommands(bindings.ClientCommands));
|
|
_chatCommands = new LiveChatCommandRoute(new LiveChatCommandBindings(
|
|
clientCommands.Execute,
|
|
bindings.Communication,
|
|
bindings.Chat,
|
|
bindings.TurbineChat,
|
|
bindings.CharacterState,
|
|
bindings.PlayerGuid,
|
|
bindings.SendTalk,
|
|
bindings.SendTell,
|
|
bindings.SendChannel,
|
|
bindings.SendTurbineChat,
|
|
bindings.Log));
|
|
// Campaign CH slice CH4 (2026-08-09): the 22 unregistered
|
|
// ChannelSystem::GetChannelID fallback tags — bypasses
|
|
// ChatChannelKind/ChannelResolver entirely and sends the raw
|
|
// legacy ChatChannel (0x0147) broadcast directly.
|
|
commands.Register<AddShortcutRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.AddShortcut(command.Entry)));
|
|
commands.Register<RemoveShortcutRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.RemoveShortcut(command.Index)));
|
|
commands.Register<AddFavoriteRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.AddFavorite(
|
|
command.SpellId,
|
|
command.Position,
|
|
command.TabIndex)));
|
|
commands.Register<RemoveFavoriteRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.RemoveFavorite(
|
|
command.SpellId,
|
|
command.TabIndex)));
|
|
commands.Register<SetSpellbookFilterRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SetSpellbookFilter(command.Filters)));
|
|
commands.Register<ForgetSpellRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.ForgetSpell(command.SpellId)));
|
|
commands.Register<SetDesiredComponentRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.SetDesiredComponent(
|
|
command.ComponentId,
|
|
command.Amount)));
|
|
commands.Register<ClearDesiredComponentsRuntimeCmd>(
|
|
_ => SendIfActive(bindings.ClearDesiredComponents));
|
|
commands.Register<RaiseAttributeRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.RaiseAttribute(command.StatId, command.Cost)));
|
|
commands.Register<RaiseVitalRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.RaiseVital(command.StatId, command.Cost)));
|
|
commands.Register<RaiseSkillRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.RaiseSkill(command.StatId, command.Cost)));
|
|
commands.Register<TrainSkillRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.TrainSkill(command.StatId, command.Cost)));
|
|
commands.Register<SetSingleCharacterOptionRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendSingleCharacterOption(
|
|
command.OptionId,
|
|
command.Value)));
|
|
commands.Register<SaveCharacterOptionsRuntimeCmd>(
|
|
_ => SendIfActive(bindings.SaveCharacterOptions));
|
|
commands.Register<AddFriendRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.AddFriend(command.Name)));
|
|
commands.Register<OpenTradeNegotiationsRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.OpenTradeNegotiations(command.PartnerGuid)));
|
|
commands.Register<CloseTradeNegotiationsRuntimeCmd>(
|
|
_ => SendIfActive(bindings.CloseTradeNegotiations));
|
|
commands.Register<AddToTradeRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.AddToTrade(command.ItemGuid)));
|
|
commands.Register<AcceptTradeRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.AcceptTrade(
|
|
command.PartnerGuid,
|
|
command.SelfAccepted,
|
|
command.PartnerAccepted)));
|
|
commands.Register<DeclineTradeRuntimeCmd>(
|
|
_ => SendIfActive(bindings.DeclineTrade));
|
|
commands.Register<ResetTradeRuntimeCmd>(
|
|
_ => SendIfActive(bindings.ResetTrade));
|
|
commands.Register<RemoveFriendRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.RemoveFriend(command.CharacterId)));
|
|
commands.Register<ClearFriendsRuntimeCmd>(
|
|
_ => SendIfActive(bindings.ClearFriends));
|
|
commands.Register<RequestLegacyFriendsRuntimeCmd>(
|
|
_ => SendIfActive(bindings.RequestLegacyFriends));
|
|
commands.Register<ModifyCharacterSquelchRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.ModifyCharacterSquelch(
|
|
command.Add,
|
|
command.CharacterId,
|
|
command.Name,
|
|
command.MessageType)));
|
|
commands.Register<ModifyAccountSquelchRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.ModifyAccountSquelch(
|
|
command.Add,
|
|
command.Name)));
|
|
commands.Register<ModifyGlobalSquelchRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.ModifyGlobalSquelch(
|
|
command.Add,
|
|
command.MessageType)));
|
|
commands.Register<FellowshipCreateRuntimeCmd>(
|
|
command => SendIfActive(() => bindings.SendFellowshipCreate(
|
|
command.FellowshipName,
|
|
command.ShareXp)));
|
|
commands.Register<FellowshipRecruitRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendFellowshipRecruit(command.TargetGuid)));
|
|
commands.Register<FellowshipDismissRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendFellowshipDismiss(command.TargetGuid)));
|
|
commands.Register<FellowshipQuitRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendFellowshipQuit(command.Disband)));
|
|
commands.Register<FellowshipAssignNewLeaderRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendFellowshipAssignNewLeader(command.NewLeaderGuid)));
|
|
commands.Register<FellowshipChangeOpennessRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendFellowshipChangeOpenness(command.IsOpen)));
|
|
commands.Register<FellowshipUpdateRequestRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendFellowshipUpdateRequest(command.PanelOpen)));
|
|
commands.Register<AllegianceSwearRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendAllegianceSwear(command.PatronGuid)));
|
|
commands.Register<AllegianceBreakRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendAllegianceBreak(command.TargetGuid)));
|
|
commands.Register<AllegianceKickRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendAllegianceKick(command.VassalGuid)));
|
|
commands.Register<AllegianceInfoRequestRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendAllegianceInfoRequest(command.PlayerName)));
|
|
commands.Register<AllegianceUpdateRequestRuntimeCmd>(
|
|
command => SendIfActive(() =>
|
|
bindings.SendAllegianceUpdateRequest(command.On)));
|
|
_commands = commands;
|
|
}
|
|
|
|
public bool IsActive
|
|
{
|
|
get
|
|
{
|
|
lock (_gate)
|
|
return _state == 1;
|
|
}
|
|
}
|
|
|
|
public void Activate()
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (_state == 2)
|
|
throw new ObjectDisposedException(nameof(LiveSessionCommandRouter));
|
|
_chatCommands?.Activate();
|
|
_state = 1;
|
|
}
|
|
}
|
|
|
|
public void Publish<T>(T command) where T : notnull
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (_state == 1)
|
|
{
|
|
if (_chatCommands?.TryPublish(command) != true)
|
|
_commands?.Publish(command);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
LiveCommandBus? commands;
|
|
LiveChatCommandRoute? chatCommands;
|
|
lock (_gate)
|
|
{
|
|
_state = 2;
|
|
commands = _commands;
|
|
_commands = null;
|
|
chatCommands = _chatCommands;
|
|
_chatCommands = null;
|
|
_clientCommands = null;
|
|
}
|
|
|
|
chatCommands?.Dispose();
|
|
commands?.Clear();
|
|
}
|
|
|
|
private ClientCommandController.Bindings BuildGuardedClientCommands(
|
|
ClientCommandController.Bindings source) => new(
|
|
TeleportToLifestone: () => InvokeClient(static b => b.TeleportToLifestone()),
|
|
TeleportToMarketplace: () => InvokeClient(static b => b.TeleportToMarketplace()),
|
|
TeleportToPkArena: () => InvokeClient(static b => b.TeleportToPkArena()),
|
|
TeleportToPkLiteArena: () => InvokeClient(static b => b.TeleportToPkLiteArena()),
|
|
TeleportToHouse: () => InvokeClient(static b => b.TeleportToHouse()),
|
|
TeleportToMansion: () => InvokeClient(static b => b.TeleportToMansion()),
|
|
QueryAge: () => InvokeClient(static b => b.QueryAge()),
|
|
QueryBirth: () => InvokeClient(static b => b.QueryBirth()),
|
|
ToggleFrameRate: () => InvokeClient(static b => b.ToggleFrameRate()),
|
|
ToggleUiLock: () => InvokeClient(static b => b.ToggleUiLock()),
|
|
ShowSystemMessage: text => InvokeClient(b => b.ShowSystemMessage(text)),
|
|
ShowWeenieError: error => InvokeClient(b => b.ShowWeenieError(error)),
|
|
PlayerPublicWeenieBitfield: () =>
|
|
ReadClient(static b => b.PlayerPublicWeenieBitfield(), default(uint?)),
|
|
ClientVersion: () => ReadClient(static b => b.ClientVersion(), string.Empty),
|
|
CurrentPosition: () =>
|
|
ReadClient(static b => b.CurrentPosition(), default(AcDream.Core.Physics.Position?)),
|
|
LastOutsideCorpsePosition: () =>
|
|
ReadClient(static b => b.LastOutsideCorpsePosition(), default(AcDream.Core.Physics.Position?)),
|
|
ShowConfirmation: (text, callback) =>
|
|
InvokeClient(b => b.ShowConfirmation(text, callback)),
|
|
Suicide: () => InvokeClient(static b => b.Suicide()),
|
|
ClearChat: all => InvokeClient(b => b.ClearChat(all)),
|
|
SaveUi: name => InvokeClient(b => b.SaveUi(name)),
|
|
LoadUi: name => InvokeClient(b => b.LoadUi(name)),
|
|
SaveAutoUi: () => InvokeClient(static b => b.SaveAutoUi()),
|
|
LoadAutoUi: () => InvokeClient(static b => b.LoadAutoUi()),
|
|
IsAway: () => ReadClient(static b => b.IsAway(), false),
|
|
SetAway: away => InvokeClient(b => b.SetAway(away)),
|
|
SetAwayMessage: message => InvokeClient(b => b.SetAwayMessage(message)),
|
|
AcceptLootPermits: () => ReadClient(static b => b.AcceptLootPermits(), false),
|
|
SetAcceptLootPermits: accept => InvokeClient(b => b.SetAcceptLootPermits(accept)),
|
|
DisplayConsent: () => InvokeClient(static b => b.DisplayConsent()),
|
|
ClearConsent: () => InvokeClient(static b => b.ClearConsent()),
|
|
RemoveConsent: name => InvokeClient(b => b.RemoveConsent(name)),
|
|
SendEmote: text => InvokeClient(b => b.SendEmote(text)),
|
|
Friends: source.Friends,
|
|
AddFriend: name => InvokeClient(b => b.AddFriend(name)),
|
|
RemoveFriend: id => InvokeClient(b => b.RemoveFriend(id)),
|
|
ClearFriends: () => InvokeClient(static b => b.ClearFriends()),
|
|
RequestLegacyFriends: () => InvokeClient(static b => b.RequestLegacyFriends()),
|
|
Squelch: source.Squelch,
|
|
ModifyCharacterSquelch: (add, id, name, chatType) =>
|
|
InvokeClient(b => b.ModifyCharacterSquelch(add, id, name, chatType)),
|
|
ModifyAccountSquelch: (add, name) =>
|
|
InvokeClient(b => b.ModifyAccountSquelch(add, name)),
|
|
ModifyGlobalSquelch: (add, chatType) =>
|
|
InvokeClient(b => b.ModifyGlobalSquelch(add, chatType)),
|
|
LastTeller: () => ReadClient(static b => b.LastTeller(), default(string?)),
|
|
ClearDesiredComponents: () => InvokeClient(static b => b.ClearDesiredComponents()),
|
|
HasOpenVendor: () => ReadClient(static b => b.HasOpenVendor(), false),
|
|
FillComponentBuyList: (componentId, targetCount) =>
|
|
InvokeClient(b => b.FillComponentBuyList(componentId, targetCount)),
|
|
EnterPkLite: () => InvokeClient(static b => b.EnterPkLite()),
|
|
// Campaign CH slice CH4 (2026-08-09): command-registry completion.
|
|
IsUsingTurbineChat: () => ReadClient(static b => b.IsUsingTurbineChat(), false),
|
|
SetChatTitle: title => InvokeClient(b => b.SetChatTitle(title)),
|
|
SetSingleCharacterOption: (optionId, value) =>
|
|
InvokeClient(b => b.SetSingleCharacterOption(optionId, value)),
|
|
AddPlayerPermission: name => InvokeClient(b => b.AddPlayerPermission(name)),
|
|
RemovePlayerPermission: name => InvokeClient(b => b.RemovePlayerPermission(name)),
|
|
RequestAvailableHouses: houseType => InvokeClient(b => b.RequestAvailableHouses(houseType)),
|
|
RequestChannelIndex: () => InvokeClient(static b => b.RequestChannelIndex()),
|
|
RequestChannelList: channelId => InvokeClient(b => b.RequestChannelList(channelId)),
|
|
JoinGmChannel: channelId => InvokeClient(b => b.JoinGmChannel(channelId)),
|
|
LeaveGmChannel: channelId => InvokeClient(b => b.LeaveGmChannel(channelId)),
|
|
RecallAllegianceHometown: () => InvokeClient(static b => b.RecallAllegianceHometown()),
|
|
RequestAllegianceInfo: name => InvokeClient(b => b.RequestAllegianceInfo(name)),
|
|
AbandonHouse: () => InvokeClient(static b => b.AbandonHouse()));
|
|
|
|
private bool InvokeClient(Action<ClientCommandController.Bindings> invoke)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
ClientCommandController.Bindings? bindings = _clientCommands;
|
|
if (_state != 1 || bindings is null)
|
|
return false;
|
|
invoke(bindings);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private TResult ReadClient<TResult>(
|
|
Func<ClientCommandController.Bindings, TResult> read,
|
|
TResult fallback)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
ClientCommandController.Bindings? bindings = _clientCommands;
|
|
return _state == 1 && bindings is not null
|
|
? read(bindings)
|
|
: fallback;
|
|
}
|
|
}
|
|
|
|
private bool SendIfActive(Action send)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (_state != 1)
|
|
return false;
|
|
send();
|
|
return true;
|
|
}
|
|
}
|
|
}
|