protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case SharedLatheComponent.LatheProducingRecipeMessage msg:
if (!_prototypeManager.TryIndex(msg.ID, out LatheRecipePrototype recipe))
{
break;
}
_queueMenu?.SetInfo(recipe);
break;
case SharedLatheComponent.LatheStoppedProducingRecipeMessage _:
_queueMenu?.ClearInfo();
break;
case SharedLatheComponent.LatheFullQueueMessage msg:
_queuedRecipes.Clear();
foreach (var id in msg.Recipes)
{
if (!_prototypeManager.TryIndex(id, out LatheRecipePrototype recipePrototype))
{
break;
}
_queuedRecipes.Enqueue(recipePrototype);
}
_queueMenu?.PopulateList();
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
if (_window == null)
{
return;
}
switch (message)
{
case AirAlarmSetAddressMessage addrMsg:
_window.SetAddress(addrMsg.Address);
break;
case AirAlarmUpdateDeviceDataMessage deviceMsg:
_window.UpdateDeviceData(deviceMsg.Address, deviceMsg.Data);
break;
case AirAlarmUpdateAlarmModeMessage alarmMsg:
_window.UpdateModeSelector(alarmMsg.Mode);
break;
case AirAlarmUpdateAlarmThresholdMessage thresholdMsg:
_window.UpdateThreshold(ref thresholdMsg);
break;
case AirAlarmUpdateAirDataMessage airDataMsg:
_window.UpdateGasData(ref airDataMsg.AirData);
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
if (message is SpaceVillainArcadeDataUpdateMessage msg)
{
_menu?.UpdateInfo(msg);
}
}
private void UserInterfaceOnOnReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case LatheQueueRecipeMessage msg:
_prototypeManager.TryIndex(msg.ID, out LatheRecipePrototype recipe);
if (recipe != null)
{
for (var i = 0; i < msg.Quantity; i++)
{
Queue.Enqueue(recipe);
_userInterface.SendMessage(new LatheFullQueueMessage(GetIDQueue()));
}
}
break;
case LatheSyncRequestMessage msg:
if (!Owner.TryGetComponent(out MaterialStorageComponent storage))
{
return;
}
_userInterface.SendMessage(new LatheFullQueueMessage(GetIDQueue()));
if (_producingRecipe != null)
{
_userInterface.SendMessage(new LatheProducingRecipeMessage(_producingRecipe.ID));
}
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
base.ReceiveMessage(message);
if (message is ValidationUpdateMessage msg)
{
Validation = new Regex(msg.ValidationString, RegexOptions.Compiled);
}
}
private void UserInterfaceOnOnReceiveMessage(BoundUserInterfaceMessage obj)
{
if (obj is ApcToggleMainBreakerMessage)
{
_provider.MainBreaker = !_provider.MainBreaker;
_uiDirty = true;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case MagicMirrorInitialDataMessage initialData:
_window?.SetInitialData(initialData);
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case SharedVendingMachineComponent.VendingMachineInventoryMessage msg:
_menu.Populate(msg.Inventory);
break;
}
}
/// <summary>
/// Sends a message to a specific session.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="session">The session to send the message to.</param>
/// <exception cref="ArgumentNullException">Thrown if either argument is null.</exception>
/// <exception cref="ArgumentException">Thrown if the session does not have this UI open.</exception>
public void SendMessage(BoundUserInterfaceMessage message, IPlayerSession session)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
AssertContains(session);
Owner.SendToSession(session, message, UiKey);
}
/// <summary>
/// Sends a message to ALL sessions that currently have the UI open.
/// </summary>
/// <param name="message">The message to send.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="message"/> is null.</exception>
public void SendMessage(BoundUserInterfaceMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
foreach (var session in _subscribedSessions)
{
Owner.SendToSession(session, message, UiKey);
}
}
private void UserInterfaceOnOnReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case VendingMachineEjectMessage msg:
TryEject(msg.ID);
break;
case InventorySyncRequestMessage msg:
_userInterface.SendMessage(new VendingMachineInventoryMessage(Inventory));
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case BlockGameMessages.BlockGameVisualUpdateMessage updateMessage:
switch (updateMessage.GameVisualType)
{
case BlockGameMessages.BlockGameVisualType.GameField:
_menu?.UpdateBlocks(updateMessage.Blocks);
break;
case BlockGameMessages.BlockGameVisualType.HoldBlock:
_menu?.UpdateHeldBlock(updateMessage.Blocks);
break;
case BlockGameMessages.BlockGameVisualType.NextBlock:
_menu?.UpdateNextBlock(updateMessage.Blocks);
break;
}
break;
case BlockGameMessages.BlockGameScoreUpdateMessage scoreUpdate:
_menu?.UpdatePoints(scoreUpdate.Points);
break;
case BlockGameMessages.BlockGameUserStatusMessage userMessage:
_menu?.SetUsability(userMessage.IsPlayer);
break;
case BlockGameMessages.BlockGameSetScreenMessage statusMessage:
if (statusMessage.isStarted)
{
_menu?.SetStarted();
}
_menu?.SetScreen(statusMessage.Screen);
if (statusMessage is BlockGameMessages.BlockGameGameOverScreenMessage gameOverScreenMessage)
{
_menu?.SetGameoverInfo(gameOverScreenMessage.FinalScore, gameOverScreenMessage.LocalPlacement, gameOverScreenMessage.GlobalPlacement);
}
break;
case BlockGameMessages.BlockGameHighScoreUpdateMessage highScoreUpdateMessage:
_menu?.UpdateHighscores(highScoreUpdateMessage.LocalHighscores,
highScoreUpdateMessage.GlobalHighscores);
break;
case BlockGameMessages.BlockGameLevelUpdateMessage levelUpdateMessage:
_menu?.UpdateLevel(levelUpdateMessage.Level);
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
if (_window == null)
{
return;
}
if (message is not ForensicScannerUserMessage cast)
{
return;
}
_window.Populate(cast);
}
internal void InternalReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case UpdateBoundStateMessage updateBoundStateMessage:
State = updateBoundStateMessage.State;
UpdateState(State);
break;
default:
ReceiveMessage(message);
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
if (_window == null)
{
return;
}
if (message is not HealthAnalyzerScannedUserMessage cast)
{
return;
}
_window.Populate(cast);
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
case RequestBodyPartSurgeryUIMessage msg:
HandleBodyPartRequest(msg);
break;
case RequestMechanismSurgeryUIMessage msg:
HandleMechanismRequest(msg);
break;
case RequestBodyPartSlotSurgeryUIMessage msg:
HandleBodyPartSlotRequest(msg);
break;
}
}
internal void ReceiveMessage(BoundUserInterfaceMessage wrappedMessage, IPlayerSession session)
{
if (!_subscribedSessions.Contains(session))
{
Logger.DebugS("go.comp.ui", "Got message from session not subscribed to us.");
return;
}
switch (wrappedMessage)
{
case CloseBoundInterfaceMessage _:
_subscribedSessions.Remove(session);
break;
default:
OnReceiveMessage?.Invoke(wrappedMessage);
break;
}
}
internal void ReceiveMessage(BoundUserInterfaceMessage wrappedMessage, IPlayerSession session)
{
if (!_subscribedSessions.Contains(session))
{
Logger.DebugS("go.comp.ui", "Got message from session not subscribed to us.");
return;
}
switch (wrappedMessage)
{
case CloseBoundInterfaceMessage msg:
var closeMsg = new ServerBoundUserInterfaceMessage(msg, session);
_subscribedSessions.Remove(session);
OnClosed?.Invoke(closeMsg);
break;
case BoundUserInterfaceMessage msg:
var serverMsg = new ServerBoundUserInterfaceMessage(msg, session);
OnReceiveMessage?.Invoke(serverMsg);
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
base.ReceiveMessage(message);
switch (message)
{
case SharedReagentGrinderComponent.ReagentGrinderWorkStartedMessage workStarted:
_menu.GrindButton.Disabled = true;
_menu.GrindButton.Modulate = workStarted.GrinderProgram == SharedReagentGrinderComponent.GrinderProgram.Grind ? Color.Green : Color.White;
_menu.JuiceButton.Disabled = true;
_menu.JuiceButton.Modulate = workStarted.GrinderProgram == SharedReagentGrinderComponent.GrinderProgram.Juice ? Color.Green : Color.White;
_menu.BeakerContentBox.EjectButton.Disabled = true;
_menu.ChamberContentBox.EjectButton.Disabled = true;
break;
case SharedReagentGrinderComponent.ReagentGrinderWorkCompleteMessage doneMessage:
_menu.GrindButton.Disabled = false;
_menu.JuiceButton.Disabled = false;
_menu.GrindButton.Modulate = Color.White;
_menu.JuiceButton.Modulate = Color.White;
_menu.BeakerContentBox.EjectButton.Disabled = false;
_menu.ChamberContentBox.EjectButton.Disabled = false;
break;
}
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
switch (message)
{
}
}
internal void SendToSession(IPlayerSession session, BoundUserInterfaceMessage message, object uiKey)
{
SendNetworkMessage(new BoundInterfaceMessageWrapMessage(message, uiKey), session.ConnectedClient);
}
public ServerBoundUserInterfaceMessage(BoundUserInterfaceMessage message, IPlayerSession session)
{
Message = message;
Session = session;
}
protected override void ReceiveMessage(BoundUserInterfaceMessage message)
{
base.ReceiveMessage(message);
_menu?.HandleMessage(message);
}
public BoundInterfaceMessageWrapMessage(BoundUserInterfaceMessage message, object uiKey)
{
Directed = true;
Message = message;
UiKey = uiKey;
}
public new void SendMessage(BoundUserInterfaceMessage msg)
{
base.SendMessage(msg);
}
/// <summary>
/// Sends a message to the server-side UI.
/// </summary>
protected void SendMessage(BoundUserInterfaceMessage message)
{
Owner.SendMessage(message, UiKey);
}
/// <summary>
/// Invoked when the server sends an arbitrary message.
/// </summary>
protected virtual void ReceiveMessage(BoundUserInterfaceMessage message)
{
}
internal void SendMessage(BoundUserInterfaceMessage message, object uiKey)
{
SendNetworkMessage(new BoundInterfaceMessageWrapMessage(message, uiKey));
}
