dcb61efb5a
Move character options and movement skills into the Runtime-owned character graph, expose borrowed inventory, character, and social views, and route retained UI state commands through generation-gated typed Runtime contracts. Preserve the existing synchronous wire path while deleting the App-owned option and skill mirrors and extending normalized parity checkpoints. Co-authored-by: Codex <codex@openai.com>
689 lines
24 KiB
C#
689 lines
24 KiB
C#
using AcDream.App.Combat;
|
|
using AcDream.App.Input;
|
|
using AcDream.App.Interaction;
|
|
using AcDream.App.Net;
|
|
using AcDream.Core.Selection;
|
|
using AcDream.Core.Items;
|
|
using AcDream.Runtime;
|
|
using AcDream.Runtime.Session;
|
|
using AcDream.UI.Abstractions;
|
|
using AcDream.UI.Abstractions.Input;
|
|
|
|
namespace AcDream.App.Runtime;
|
|
|
|
/// <summary>
|
|
/// Generation-gated synchronous command projection onto the same current
|
|
/// owners used by graphical input. It introduces no queue or frame boundary.
|
|
/// </summary>
|
|
internal sealed class CurrentGameRuntimeCommandAdapter
|
|
: IRuntimeSessionCommands,
|
|
IRuntimeSelectionCommands,
|
|
IRuntimeCombatCommands,
|
|
IRuntimeMovementCommands,
|
|
IRuntimeChatCommands,
|
|
IRuntimePortalCommands,
|
|
IRuntimeInventoryStateCommands,
|
|
IRuntimeSpellbookCommands,
|
|
IRuntimeCharacterCommands,
|
|
IRuntimeSocialCommands
|
|
{
|
|
private readonly LiveSessionController _session;
|
|
private readonly LiveSessionHost _sessionHost;
|
|
private readonly ICommandBus _commands;
|
|
private readonly CurrentGameRuntimeViewAdapter _view;
|
|
private readonly SelectionState _selectionState;
|
|
private readonly SelectionInteractionController _selection;
|
|
private readonly GameplayInputFrameController _gameplayInput;
|
|
private readonly ILiveCombatModeCommand _combat;
|
|
private readonly ICurrentGameRuntimeEventSink _events;
|
|
|
|
public CurrentGameRuntimeCommandAdapter(
|
|
LiveSessionController session,
|
|
LiveSessionHost sessionHost,
|
|
ICommandBus commands,
|
|
CurrentGameRuntimeViewAdapter view,
|
|
SelectionState selectionState,
|
|
SelectionInteractionController selection,
|
|
GameplayInputFrameController gameplayInput,
|
|
ILiveCombatModeCommand combat,
|
|
ICurrentGameRuntimeEventSink events)
|
|
{
|
|
_session = session ?? throw new ArgumentNullException(nameof(session));
|
|
_sessionHost = sessionHost ?? throw new ArgumentNullException(nameof(sessionHost));
|
|
_commands = commands ?? throw new ArgumentNullException(nameof(commands));
|
|
_view = view ?? throw new ArgumentNullException(nameof(view));
|
|
_selectionState = selectionState
|
|
?? throw new ArgumentNullException(nameof(selectionState));
|
|
_selection = selection ?? throw new ArgumentNullException(nameof(selection));
|
|
_gameplayInput = gameplayInput
|
|
?? throw new ArgumentNullException(nameof(gameplayInput));
|
|
_combat = combat ?? throw new ArgumentNullException(nameof(combat));
|
|
_events = events ?? throw new ArgumentNullException(nameof(events));
|
|
}
|
|
|
|
public RuntimeSessionStartResult Start(
|
|
RuntimeGenerationToken expectedGeneration)
|
|
{
|
|
RuntimeLifecycleState previous = _view.Lifecycle.State;
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: false);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return RejectedStart(gate);
|
|
|
|
RuntimeSessionStartResult result =
|
|
_sessionHost.Start(expectedGeneration);
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Session,
|
|
operation: 0,
|
|
ToCommandStatus(result.Status),
|
|
result.CharacterId,
|
|
result.CharacterName);
|
|
_events.EmitLifecycle(previous);
|
|
return result;
|
|
}
|
|
|
|
public RuntimeSessionStartResult Reconnect(
|
|
RuntimeGenerationToken expectedGeneration)
|
|
{
|
|
RuntimeLifecycleState previous = _view.Lifecycle.State;
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: false);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return RejectedStart(gate);
|
|
|
|
RuntimeSessionStartResult result =
|
|
_sessionHost.Reconnect(expectedGeneration);
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Session,
|
|
operation: 1,
|
|
ToCommandStatus(result.Status),
|
|
result.CharacterId,
|
|
result.CharacterName);
|
|
_events.EmitLifecycle(previous);
|
|
return result;
|
|
}
|
|
|
|
public RuntimeTeardownAcknowledgement Stop(
|
|
RuntimeGenerationToken expectedGeneration)
|
|
{
|
|
RuntimeLifecycleState previous = _view.Lifecycle.State;
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: false);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
{
|
|
return new RuntimeTeardownAcknowledgement(
|
|
expectedGeneration,
|
|
_view.Generation,
|
|
gate,
|
|
RuntimeTeardownStage.None);
|
|
}
|
|
|
|
RuntimeTeardownAcknowledgement acknowledgement =
|
|
_sessionHost.Stop(expectedGeneration);
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Session,
|
|
operation: 2,
|
|
acknowledgement.Status,
|
|
text: acknowledgement.Error?.GetType().Name ?? string.Empty);
|
|
_events.EmitLifecycle(previous);
|
|
return acknowledgement;
|
|
}
|
|
|
|
public RuntimeCommandResult Execute(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
RuntimeSelectionCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
|
|
InputAction action = command switch
|
|
{
|
|
RuntimeSelectionCommand.SelectClosestHostile =>
|
|
InputAction.SelectionClosestMonster,
|
|
RuntimeSelectionCommand.SelectPrevious =>
|
|
InputAction.SelectionPreviousSelection,
|
|
RuntimeSelectionCommand.ExamineSelected =>
|
|
InputAction.SelectionExamine,
|
|
RuntimeSelectionCommand.UseSelected =>
|
|
InputAction.UseSelected,
|
|
RuntimeSelectionCommand.PickUpSelected =>
|
|
InputAction.SelectionPickUp,
|
|
_ => InputAction.None,
|
|
};
|
|
RuntimeCommandStatus status = action != InputAction.None
|
|
&& _selection.HandleInputAction(action)
|
|
? RuntimeCommandStatus.Accepted
|
|
: RuntimeCommandStatus.Unsupported;
|
|
uint selected = _selectionState.SelectedObjectId ?? 0u;
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Selection,
|
|
(int)command,
|
|
status,
|
|
selected);
|
|
return Result(status, selected);
|
|
}
|
|
|
|
public RuntimeCommandResult Execute(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
RuntimeCombatCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
|
|
RuntimeCommandStatus status;
|
|
if (command == RuntimeCombatCommand.ToggleMode)
|
|
{
|
|
_combat.Toggle();
|
|
status = RuntimeCommandStatus.Accepted;
|
|
}
|
|
else
|
|
{
|
|
status = RuntimeCommandStatus.Unsupported;
|
|
}
|
|
|
|
_events.EmitCommand(RuntimeCommandDomain.Combat, (int)command, status);
|
|
return Result(status);
|
|
}
|
|
|
|
public RuntimeCommandResult Execute(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
RuntimeMovementCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
|
|
InputAction action = command switch
|
|
{
|
|
RuntimeMovementCommand.ToggleRunLock => InputAction.MovementRunLock,
|
|
RuntimeMovementCommand.Stop => InputAction.MovementStop,
|
|
_ => InputAction.None,
|
|
};
|
|
RuntimeCommandStatus status;
|
|
if (action == InputAction.None)
|
|
{
|
|
status = RuntimeCommandStatus.Unsupported;
|
|
}
|
|
else
|
|
{
|
|
_gameplayInput.HandlePressedMovementAction(action);
|
|
status = RuntimeCommandStatus.Accepted;
|
|
}
|
|
|
|
_events.EmitCommand(RuntimeCommandDomain.Movement, (int)command, status);
|
|
return Result(status);
|
|
}
|
|
|
|
public RuntimeCommandResult Execute(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
in RuntimeChatCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
|
|
if (!TryMap(command.Channel, out ChatChannelKind channel))
|
|
{
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Chat,
|
|
(int)command.Channel,
|
|
RuntimeCommandStatus.Unsupported);
|
|
return Result(RuntimeCommandStatus.Unsupported);
|
|
}
|
|
|
|
_commands.Publish(new SendChatCmd(
|
|
channel,
|
|
command.TargetName,
|
|
command.Text));
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Chat,
|
|
(int)command.Channel,
|
|
RuntimeCommandStatus.Accepted,
|
|
text: command.Text);
|
|
return Result(RuntimeCommandStatus.Accepted);
|
|
}
|
|
|
|
public RuntimeCommandResult Execute(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
RuntimePortalCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
|
|
ClientCommandId? commandId = command switch
|
|
{
|
|
RuntimePortalCommand.RecallLifestone =>
|
|
ClientCommandId.LifestoneRecall,
|
|
RuntimePortalCommand.RecallMarketplace =>
|
|
ClientCommandId.MarketplaceRecall,
|
|
RuntimePortalCommand.RecallHouse =>
|
|
ClientCommandId.HouseRecall,
|
|
RuntimePortalCommand.RecallMansion =>
|
|
ClientCommandId.MansionRecall,
|
|
_ => null,
|
|
};
|
|
if (commandId is null)
|
|
{
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Portal,
|
|
(int)command,
|
|
RuntimeCommandStatus.Unsupported);
|
|
return Result(RuntimeCommandStatus.Unsupported);
|
|
}
|
|
|
|
_commands.Publish(new ExecuteClientCommandCmd(
|
|
commandId.Value,
|
|
string.Empty));
|
|
_events.EmitCommand(
|
|
RuntimeCommandDomain.Portal,
|
|
(int)command,
|
|
RuntimeCommandStatus.Accepted);
|
|
return Result(RuntimeCommandStatus.Accepted);
|
|
}
|
|
|
|
public RuntimeCommandResult AddShortcut(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
in RuntimeShortcutCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
if (command.Index < 0
|
|
|| (command.ObjectId == 0u && command.SpellId == 0u))
|
|
{
|
|
return EmitResult(
|
|
RuntimeCommandDomain.InventoryState,
|
|
operation: 0,
|
|
RuntimeCommandStatus.Rejected,
|
|
command.ObjectId);
|
|
}
|
|
|
|
_commands.Publish(new AddShortcutRuntimeCmd(new ShortcutEntry(
|
|
command.Index,
|
|
command.ObjectId,
|
|
command.SpellId)));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.InventoryState,
|
|
operation: 0,
|
|
RuntimeCommandStatus.Accepted,
|
|
command.ObjectId);
|
|
}
|
|
|
|
public RuntimeCommandResult RemoveShortcut(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
int index)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
if (index < 0)
|
|
{
|
|
return EmitResult(
|
|
RuntimeCommandDomain.InventoryState,
|
|
operation: 1,
|
|
RuntimeCommandStatus.Rejected);
|
|
}
|
|
|
|
_commands.Publish(new RemoveShortcutRuntimeCmd((uint)index));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.InventoryState,
|
|
operation: 1,
|
|
RuntimeCommandStatus.Accepted);
|
|
}
|
|
|
|
public RuntimeCommandResult AddFavorite(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
int tabIndex,
|
|
int position,
|
|
uint spellId)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
if ((uint)tabIndex >= 8u
|
|
|| position < 0
|
|
|| spellId == 0u)
|
|
{
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 0,
|
|
RuntimeCommandStatus.Rejected,
|
|
spellId);
|
|
}
|
|
|
|
_commands.Publish(new AddFavoriteRuntimeCmd(
|
|
spellId,
|
|
position,
|
|
tabIndex));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 0,
|
|
RuntimeCommandStatus.Accepted,
|
|
spellId);
|
|
}
|
|
|
|
public RuntimeCommandResult RemoveFavorite(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
int tabIndex,
|
|
uint spellId)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
if ((uint)tabIndex >= 8u || spellId == 0u)
|
|
{
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 1,
|
|
RuntimeCommandStatus.Rejected,
|
|
spellId);
|
|
}
|
|
|
|
_commands.Publish(new RemoveFavoriteRuntimeCmd(spellId, tabIndex));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 1,
|
|
RuntimeCommandStatus.Accepted,
|
|
spellId);
|
|
}
|
|
|
|
public RuntimeCommandResult SetFilter(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
uint filters)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
_commands.Publish(new SetSpellbookFilterRuntimeCmd(filters));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 2,
|
|
RuntimeCommandStatus.Accepted);
|
|
}
|
|
|
|
public RuntimeCommandResult ForgetSpell(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
uint spellId)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
if (spellId == 0u)
|
|
{
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 3,
|
|
RuntimeCommandStatus.Rejected,
|
|
spellId);
|
|
}
|
|
|
|
_commands.Publish(new ForgetSpellRuntimeCmd(spellId));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 3,
|
|
RuntimeCommandStatus.Accepted,
|
|
spellId);
|
|
}
|
|
|
|
public RuntimeCommandResult SetDesiredComponent(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
uint componentId,
|
|
uint amount)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
if (componentId == 0u)
|
|
{
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 4,
|
|
RuntimeCommandStatus.Rejected,
|
|
componentId);
|
|
}
|
|
|
|
_commands.Publish(new SetDesiredComponentRuntimeCmd(
|
|
componentId,
|
|
amount));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 4,
|
|
RuntimeCommandStatus.Accepted,
|
|
componentId);
|
|
}
|
|
|
|
public RuntimeCommandResult ClearDesiredComponents(
|
|
RuntimeGenerationToken expectedGeneration)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
_commands.Publish(new ClearDesiredComponentsRuntimeCmd());
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Spellbook,
|
|
operation: 5,
|
|
RuntimeCommandStatus.Accepted);
|
|
}
|
|
|
|
public RuntimeCommandResult Advance(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
in RuntimeAdvancementCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
if (command.StatId == 0u
|
|
|| command.Cost == 0u)
|
|
{
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Character,
|
|
(int)command.Kind,
|
|
RuntimeCommandStatus.Rejected,
|
|
command.StatId);
|
|
}
|
|
|
|
switch (command.Kind)
|
|
{
|
|
case RuntimeAdvancementKind.Attribute:
|
|
_commands.Publish(new RaiseAttributeRuntimeCmd(
|
|
command.StatId,
|
|
command.Cost));
|
|
break;
|
|
case RuntimeAdvancementKind.Vital:
|
|
_commands.Publish(new RaiseVitalRuntimeCmd(
|
|
command.StatId,
|
|
command.Cost));
|
|
break;
|
|
case RuntimeAdvancementKind.Skill:
|
|
_commands.Publish(new RaiseSkillRuntimeCmd(
|
|
command.StatId,
|
|
command.Cost));
|
|
break;
|
|
case RuntimeAdvancementKind.TrainSkill
|
|
when command.Cost <= uint.MaxValue:
|
|
_commands.Publish(new TrainSkillRuntimeCmd(
|
|
command.StatId,
|
|
(uint)command.Cost));
|
|
break;
|
|
default:
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Character,
|
|
(int)command.Kind,
|
|
RuntimeCommandStatus.Rejected,
|
|
command.StatId);
|
|
}
|
|
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Character,
|
|
(int)command.Kind,
|
|
RuntimeCommandStatus.Accepted,
|
|
command.StatId);
|
|
}
|
|
|
|
public RuntimeCommandResult SetOptions1(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
uint options)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
_commands.Publish(new SetCharacterOptionsRuntimeCmd(options));
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Character,
|
|
operation: 4,
|
|
RuntimeCommandStatus.Accepted);
|
|
}
|
|
|
|
public RuntimeCommandResult Execute(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
in RuntimeFriendCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
RuntimeCommandStatus status = RuntimeCommandStatus.Accepted;
|
|
switch (command.Kind)
|
|
{
|
|
case RuntimeFriendCommandKind.Add
|
|
when !string.IsNullOrWhiteSpace(command.Name):
|
|
_commands.Publish(new AddFriendRuntimeCmd(command.Name));
|
|
break;
|
|
case RuntimeFriendCommandKind.Remove
|
|
when command.CharacterId != 0u:
|
|
_commands.Publish(new RemoveFriendRuntimeCmd(
|
|
command.CharacterId));
|
|
break;
|
|
case RuntimeFriendCommandKind.Clear:
|
|
_commands.Publish(new ClearFriendsRuntimeCmd());
|
|
break;
|
|
case RuntimeFriendCommandKind.RequestLegacyList:
|
|
_commands.Publish(new RequestLegacyFriendsRuntimeCmd());
|
|
break;
|
|
default:
|
|
status = RuntimeCommandStatus.Rejected;
|
|
break;
|
|
}
|
|
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Social,
|
|
(int)command.Kind,
|
|
status,
|
|
command.CharacterId,
|
|
command.Name);
|
|
}
|
|
|
|
public RuntimeCommandResult Execute(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
in RuntimeSquelchCommand command)
|
|
{
|
|
RuntimeCommandStatus gate = Validate(expectedGeneration, requireWorld: true);
|
|
if (gate != RuntimeCommandStatus.Accepted)
|
|
return Result(gate);
|
|
RuntimeCommandStatus status = RuntimeCommandStatus.Accepted;
|
|
switch (command.Scope)
|
|
{
|
|
case RuntimeSquelchScope.Character
|
|
when command.CharacterId != 0u
|
|
&& !string.IsNullOrWhiteSpace(command.Name):
|
|
_commands.Publish(new ModifyCharacterSquelchRuntimeCmd(
|
|
command.Add,
|
|
command.CharacterId,
|
|
command.Name,
|
|
command.MessageType));
|
|
break;
|
|
case RuntimeSquelchScope.Account
|
|
when !string.IsNullOrWhiteSpace(command.Name):
|
|
_commands.Publish(new ModifyAccountSquelchRuntimeCmd(
|
|
command.Add,
|
|
command.Name));
|
|
break;
|
|
case RuntimeSquelchScope.Global:
|
|
_commands.Publish(new ModifyGlobalSquelchRuntimeCmd(
|
|
command.Add,
|
|
command.MessageType));
|
|
break;
|
|
default:
|
|
status = RuntimeCommandStatus.Rejected;
|
|
break;
|
|
}
|
|
|
|
return EmitResult(
|
|
RuntimeCommandDomain.Social,
|
|
operation: 4 + (int)command.Scope,
|
|
status,
|
|
command.CharacterId,
|
|
command.Name);
|
|
}
|
|
|
|
private RuntimeCommandStatus Validate(
|
|
RuntimeGenerationToken expectedGeneration,
|
|
bool requireWorld)
|
|
{
|
|
if (!_view.IsActive)
|
|
return RuntimeCommandStatus.Inactive;
|
|
if (expectedGeneration != _view.Generation)
|
|
return RuntimeCommandStatus.StaleGeneration;
|
|
if (requireWorld && !_session.IsInWorld)
|
|
return RuntimeCommandStatus.Inactive;
|
|
return RuntimeCommandStatus.Accepted;
|
|
}
|
|
|
|
private RuntimeCommandResult Result(
|
|
RuntimeCommandStatus status,
|
|
uint objectId = 0u) =>
|
|
new(status, _view.Generation, objectId);
|
|
|
|
private RuntimeCommandResult EmitResult(
|
|
RuntimeCommandDomain domain,
|
|
int operation,
|
|
RuntimeCommandStatus status,
|
|
uint objectId = 0u,
|
|
string? text = null)
|
|
{
|
|
_events.EmitCommand(domain, operation, status, objectId, text);
|
|
return Result(status, objectId);
|
|
}
|
|
|
|
private RuntimeSessionStartResult RejectedStart(RuntimeCommandStatus status) =>
|
|
new(
|
|
status == RuntimeCommandStatus.StaleGeneration
|
|
? RuntimeSessionStartStatus.StaleGeneration
|
|
: RuntimeSessionStartStatus.Inactive,
|
|
_view.Generation);
|
|
|
|
private static RuntimeCommandStatus ToCommandStatus(
|
|
RuntimeSessionStartStatus status) =>
|
|
status switch
|
|
{
|
|
RuntimeSessionStartStatus.Failed => RuntimeCommandStatus.Rejected,
|
|
RuntimeSessionStartStatus.Inactive => RuntimeCommandStatus.Inactive,
|
|
RuntimeSessionStartStatus.StaleGeneration =>
|
|
RuntimeCommandStatus.StaleGeneration,
|
|
_ => RuntimeCommandStatus.Accepted,
|
|
};
|
|
|
|
private static bool TryMap(
|
|
RuntimeChatChannel channel,
|
|
out ChatChannelKind result)
|
|
{
|
|
result = channel switch
|
|
{
|
|
RuntimeChatChannel.Say => ChatChannelKind.Say,
|
|
RuntimeChatChannel.Tell => ChatChannelKind.Tell,
|
|
RuntimeChatChannel.Fellowship => ChatChannelKind.Fellowship,
|
|
RuntimeChatChannel.Allegiance => ChatChannelKind.Allegiance,
|
|
RuntimeChatChannel.Vassals => ChatChannelKind.Vassals,
|
|
RuntimeChatChannel.Patron => ChatChannelKind.Patron,
|
|
RuntimeChatChannel.Monarch => ChatChannelKind.Monarch,
|
|
RuntimeChatChannel.CoVassals => ChatChannelKind.CoVassals,
|
|
RuntimeChatChannel.General => ChatChannelKind.General,
|
|
RuntimeChatChannel.Trade => ChatChannelKind.Trade,
|
|
RuntimeChatChannel.LookingForGroup => ChatChannelKind.Lfg,
|
|
RuntimeChatChannel.Roleplay => ChatChannelKind.Roleplay,
|
|
RuntimeChatChannel.Society => ChatChannelKind.Society,
|
|
RuntimeChatChannel.Olthoi => ChatChannelKind.Olthoi,
|
|
_ => ChatChannelKind.Unknown,
|
|
};
|
|
return result != ChatChannelKind.Unknown;
|
|
}
|
|
}
|