public override void HandleButtonPress(ButtonPressedMessage message)
{
if (message.ButtonType == Net.ButtonType.Right)
{
this.RightButtonPressed(message);
}
}
// Messages from Messenger are events. async void is fine in this case.
Task ButtonPressedMessageHandler(ButtonPressedMessage message)
{
return(Task.Run(async() =>
{
WriteLine($"Handling button pressed message ({message.Action.ToString()}, {message.Code.ToString()})");
if (_activeDevice.Device?.Id == message.DeviceId)
{
if (_activeDevice.Device.OtherConnections > 0)
{
string info = TranslationSource.Instance["UserAction.ButtonDisabled.ToManyOtherConnections"];
var deviceName = _activeDevice.Device.Name;
var otherConnections = _activeDevice.Device.OtherConnections;
var hotkey = await _hotkeyManager.GetHotkeyForAction(message.Action);
var localizedAction = TranslationSource.Instance[$"Enum.UserAction.{message.Action.ToString()}"].ToLowerInvariant();
info = string.Format(info, deviceName, otherConnections, hotkey, localizedAction);
var msgOptions = new NotificationOptions {
CloseTimeout = NotificationOptions.LongTimeout
};
await _metaMessenger.Publish(new ShowInfoNotificationMessage(info, options: msgOptions, notificationId: _activeDevice.Device.Mac));
}
else if (!_activeDevice.Device.IsLoadingStorage)
{
await HandleButtonActionAsync(message.DeviceId, message.Action, message.Code);
}
}
else
{
string warn = string.Format(TranslationSource.Instance["UserAction.DeviceIsNotActive"], message.DeviceId);
await _metaMessenger.Publish(new ShowWarningNotificationMessage(warn, notificationId: _activeDevice.Device?.Mac));
WriteLine(warn, LogErrorSeverity.Warning);
}
}));
}
private void Update()
{
// input test
if (enableKeyboard)
{
controller.SetActionState(eControllerActions.Jump, Input.GetKeyDown(KeyCode.Space));
controller.SetActionState(eControllerActions.Left, Input.GetKey(KeyCode.Q));
controller.SetActionState(eControllerActions.Right, Input.GetKey(KeyCode.D));
controller.SetActionState(eControllerActions.Down, Input.GetKey(KeyCode.S));
controller.SetActionState(eControllerActions.Up, Input.GetKey(KeyCode.Z));
if (Input.GetKeyDown(KeyCode.A))
{
Interact();
}
if (Input.GetKeyDown(KeyCode.T))
{
heldElement.Throw();
heldElement = null;
}
}
if (singleAction || continousAction)
{
if (continousAction)
{
continousActionActive = true;
}
ButtonPressedMessage m = new ButtonPressedMessage();
m.ButtonId = InputTest;
ReceiveMessage(m);
if (singleAction)
{
singleAction = false;
ButtonPressedMessage m2 = new ButtonPressedMessage();
m2.ButtonId = InputTest;
ReceiveMessage(m2);
}
}
if (!continousAction && continousActionActive)
{
ButtonReleasedMessage m = new ButtonReleasedMessage();
m.ButtonId = InputTest;
ReceiveMessage(m);
}
// end test
if (nearestInteraction == null)
{
RemoveInteraction(null);
}
PlayerController ctl = GetComponent <PlayerController>();
if (ctl.CanClimb && !CarrySomething)
{
ShowIndicator(false);
}
else
{
HideIndicator(false);
}
UpdateNearestInteraction();
}
public void ReceiveMessage(Message mess)
{
if (mess is ButtonPressedMessage)
{
ButtonPressedMessage m = (ButtonPressedMessage)mess;
switch (m.ButtonId)
{
case Buttons.B:
controller.SetActionState(eControllerActions.Jump, true);
break;
case Buttons.A:
Interact();
break;
case Buttons.Joystick:
controller.SetActionState(eControllerActions.Left, false);
controller.SetActionState(eControllerActions.Right, false);
controller.SetActionState(eControllerActions.Down, false);
controller.SetActionState(eControllerActions.Up, false);
controller.SetActionState(TranslateJoystickInput(m.Extra1, m.Extra2), true);
break;
case Buttons.DPadLeft:
controller.SetActionState(eControllerActions.Left, true);
break;
case Buttons.DPadRight:
controller.SetActionState(eControllerActions.Right, true);
break;
case Buttons.DPadDown:
controller.SetActionState(eControllerActions.Down, true);
break;
case Buttons.DPadUp:
controller.SetActionState(eControllerActions.Up, true);
break;
}
}
else if (mess is ButtonReleasedMessage)
{
ButtonReleasedMessage m = (ButtonReleasedMessage)mess;
switch (m.ButtonId)
{
case Buttons.DPadLeft:
case Buttons.DPadRight:
case Buttons.DPadDown:
case Buttons.DPadUp:
case Buttons.Joystick:
controller.SetActionState(eControllerActions.Left, false);
controller.SetActionState(eControllerActions.Right, false);
controller.SetActionState(eControllerActions.Down, false);
controller.SetActionState(eControllerActions.Up, false);
break;
case Buttons.B:
controller.SetActionState(eControllerActions.Jump, false);
break;
case Buttons.A:
break;
}
}
else if (mess is ItemThrowMessage)
{
if (heldElement != null)
{
heldElement.Throw();
heldElement = null;
Socket.SendMessage(new UpdateItemMessage(0, "", ""));
}
}
}
public abstract void RightButtonPressed(ButtonPressedMessage message);
public abstract void LeftButtonPressed(ButtonPressedMessage message);
public abstract void BackButtonPressed(ButtonPressedMessage message);
public abstract void HandleButtonPress(ButtonPressedMessage message);
void ProcessFrame(Frame frame)
{
if (frame.GetEvents().Count > 0)
{
foreach (var ev in frame.GetEvents())
{
switch (ev.GetEventType())
{
case Net.EventType.Pinch:
var pinch = SWIGHelper.CastTo <Pinch>(ev, false);
if (pinch != null)
{
PinchMessage pinchMessage = new PinchMessage(pinch);
MessageBus.MessageBus.Instance.SendMessage(pinchMessage);
}
break;
case Net.EventType.HandSupine:
var supine = SWIGHelper.CastTo <HandSupine>(ev, false);
if (supine != null)
{
HandSupineMessage pinchMessage = new HandSupineMessage(supine);
MessageBus.MessageBus.Instance.SendMessage(pinchMessage);
}
break;
case Net.EventType.EfficioStarted:
var started = SWIGHelper.CastTo <EfficioStarted>(ev, false);
if (started != null)
{
EfficioStartedMessage startedMessage = new EfficioStartedMessage(started);
MessageBus.MessageBus.Instance.SendMessage(startedMessage);
}
break;
case Net.EventType.ButtonPressed:
{
var buttonPressed = SWIGHelper.CastTo <ButtonPressed>(ev, false);
if (buttonPressed != null)
{
ButtonPressedMessage buttonPressedMessage = new ButtonPressedMessage(buttonPressed);
MessageBus.MessageBus.Instance.SendMessage(buttonPressedMessage);
}
break;
}
case Net.EventType.SensorConnected:
{
var sensorConnected = SWIGHelper.CastTo <Connected>(ev, false);
if (sensorConnected != null)
{
SensorConnectedMesssage sensorConnectedMesssage = new SensorConnectedMesssage(sensorConnected);
MessageBus.MessageBus.Instance.SendMessage(sensorConnectedMesssage);
}
break;
}
case Net.EventType.SensorFaulted:
{
var sensorFaulted = SWIGHelper.CastTo <Faulted>(ev, false);
if (sensorFaulted != null)
{
SensorFaultedMesssage sensorFaultedMesssage = new SensorFaultedMesssage(sensorFaulted);
MessageBus.MessageBus.Instance.SendMessage(sensorFaultedMesssage);
}
break;
}
case Net.EventType.SensorDisconnected:
{
var sensorDisconnected = SWIGHelper.CastTo <Disconnected>(ev, false);
if (sensorDisconnected != null)
{
SensorDisconnectedMesssage sensorDisconnectedMesssage = new SensorDisconnectedMesssage(sensorDisconnected);
MessageBus.MessageBus.Instance.SendMessage(sensorDisconnectedMesssage);
}
break;
}
default:
break;
}
}
}
}
