public override void HandleInput(bool receivedFocusInThisUpdate)
{
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.LANDING_GEAR))
{
CloseScreenNow();
}
var humanPlayer = MySession.Static.LocalHumanPlayer;
if (humanPlayer != null &&
(MyInput.Static.IsNewLeftMousePressed() || MyControllerHelper.IsControl(Sandbox.Engine.Utils.MySpaceBindingCreator.CX_GUI, MyControlsGUI.ACCEPT, MyControlStateType.NEW_PRESSED)))
{
for (int i = 0; i < m_colorPaletteControlsList.Count; i++)
{
if (m_colorPaletteControlsList[i].IsMouseOver)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
humanPlayer.SelectedBuildColorSlot = i;
m_highlightControlPanel.Position = new Vector2(((x + defColCol) / 1600f) + (humanPlayer.SelectedBuildColorSlot % 7) * 0.03f, (y + defColLine) / 1200f + (humanPlayer.SelectedBuildColorSlot / 7) * 0.03f);
UpdateSliders(humanPlayer.SelectedBuildColor);
}
}
}
base.HandleInput(receivedFocusInThisUpdate);
}
public override void HandleInput()
{
base.HandleInput();
if (!(MyScreenManager.GetScreenWithFocus() is MyGuiScreenGamePlay))
{
return;
}
if (MyControllerHelper.IsControl(MySpaceBindingCreator.CX_CHARACTER, MyControlsSpace.PRIMARY_TOOL_ACTION))
{
if (MySession.ControlledEntity != null && BotToSpawn != null)
{
TrySpawnBot();
}
if (MySession.ControlledEntity != null && CommandDefinition != null)
{
UseCommand();
}
if (MySession.ControlledEntity != null && AreaMarkerDefinition != null)
{
PlaceAreaMarker();
}
}
}
public override void HandleInput()
{
ProfilerShort.Begin("MyToolbarComponent.HandleInput");
try
{
var context = MySession.ControlledEntity != null ? MySession.ControlledEntity.ControlContext : MyStringId.NullOrEmpty;
var focusedScreen = MyScreenManager.GetScreenWithFocus();
if ((focusedScreen == MyGuiScreenGamePlay.Static ||
focusedScreen is MyGuiScreenCubeBuilder ||
focusedScreen is MyGuiScreenToolbarConfigBase) &&
CurrentToolbar != null)
{
// if (!(focusedScreen is MyGuiScreenCubeBuilder) || !(focusedScreen.FocusedControl is MyGuiControlTextbox))
{
for (int i = 0; i < m_slotControls.Length; i++)
{
if (MyControllerHelper.IsControl(context, m_slotControls[i], MyControlStateType.NEW_PRESSED))
{
if (!MyInput.Static.IsAnyShiftKeyPressed())
{
CurrentToolbar.ActivateItemAtSlot(i);
}
else if (i < CurrentToolbar.PageCount)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
CurrentToolbar.SwitchToPage(i);
}
}
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_UP, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
CurrentToolbar.PageUp();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_DOWN, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
CurrentToolbar.PageDown();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_NEXT_ITEM, MyControlStateType.NEW_PRESSED))
{
CurrentToolbar.SelectNextSlot();
}
else if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_PREV_ITEM, MyControlStateType.NEW_PRESSED))
{
CurrentToolbar.SelectPreviousSlot();
}
}
}
finally
{
ProfilerShort.End();
}
base.HandleInput();
}
public virtual void HandleInput(bool receivedFocusInThisUpdate)
{
// Dont allow any input when the screen is not in OPENED state
if (!IsLoaded || State != MyGuiScreenState.OPENED)
{
return;
}
// Here we can make some one-time initialization hidden in update
bool isThisFirstHandleInput = !m_firstUpdateServed;
if (m_firstUpdateServed == false && FocusedControl == null) //m_keyboardControlIndex could be set from constructor
{
FocusedControl = GetFirstFocusableControl();
// Never again call this update-initialization (except if RecreateControls() is called, which resets this)
m_firstUpdateServed = true;
}
if (!HandleControlsInput(receivedFocusInThisUpdate))
{
bool handled = false;
// If input wasn't completely handled or captured by some control, only then we can handle screen's input
if ((MyInput.Static.IsKeyPress(MyKeys.LeftShift) && MyInput.Static.IsNewKeyPressed(MyKeys.Tab)) ||
MyInput.Static.IsNewKeyPressed(MyKeys.Up) ||
(MyInput.Static.IsNewKeyPressed(MyKeys.Left) && !(FocusedControl is MyGuiControlSlider)) ||
(MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_UP) && m_defaultJoystickDpadUse))
{
handled = HandleKeyboardActiveIndex(false);
}
else if (MyInput.Static.IsNewKeyPressed(MyKeys.Tab) ||
MyInput.Static.IsNewKeyPressed(MyKeys.Down) ||
(MyInput.Static.IsNewKeyPressed(MyKeys.Right) && !(FocusedControl is MyGuiControlSlider)) ||
(MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_DOWN) && m_defaultJoystickDpadUse))
{
handled = HandleKeyboardActiveIndex(true);
}
else if ((m_closeOnEsc == true) && ((MyInput.Static.IsNewKeyPressed(MyKeys.Escape) || MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MAIN_MENU)) ||
(m_defaultJoystickCancelUse && MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.CANCEL))))
{
Canceling();
}
if (!handled)
{
HandleUnhandledInput(receivedFocusInThisUpdate);
}
else if (m_defaultJoystickDpadUse && FocusedControl != null)
{
if (MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_UP) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_DOWN))
{
var coords = MyGuiManager.GetScreenCoordinateFromNormalizedCoordinate(FocusedControl.GetPositionAbsoluteCenter());
MyInput.Static.SetMousePosition((int)coords.X, (int)coords.Y);
}
}
}
}
private bool HandleMouseScrollInput(MyStringId context)
{
bool ctrl = MyInput.Static.IsAnyCtrlKeyPressed();
if ((ctrl && MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue()) ||
MyControllerHelper.IsControl(context, MyControlsSpace.MOVE_FURTHER, MyControlStateType.PRESSED))
{
bool handled = false;
if (m_clipboard.IsActive)
{
m_clipboard.MoveEntityFurther();
handled = true;
}
if (m_floatingObjectClipboard.IsActive)
{
m_floatingObjectClipboard.MoveEntityFurther();
handled = true;
}
if (m_voxelClipboard.IsActive)
{
m_voxelClipboard.MoveEntityFurther();
handled = true;
}
return(handled);
}
else if ((ctrl && MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue()) ||
MyControllerHelper.IsControl(context, MyControlsSpace.MOVE_CLOSER, MyControlStateType.PRESSED))
{
bool handled = false;
if (m_clipboard.IsActive)
{
m_clipboard.MoveEntityCloser();
handled = true;
}
if (m_floatingObjectClipboard.IsActive)
{
m_floatingObjectClipboard.MoveEntityCloser();
handled = true;
}
if (m_voxelClipboard.IsActive)
{
m_voxelClipboard.MoveEntityCloser();
handled = true;
}
return(handled);
}
return(false);
}
public override void HandleInput(bool receivedFocusInThisUpdate)
{
base.HandleInput(receivedFocusInThisUpdate);
if (!receivedFocusInThisUpdate && MyGuiScreenGamePlay.Static != null && MyControllerHelper.IsControl(MySpaceBindingCreator.CX_GUI, MyControlsGUI.MAIN_MENU))
{
CloseScreen();
}
if (MyControllerHelper.IsControl(MySpaceBindingCreator.CX_GUI, MyControlsGUI.BUTTON_X))
{
ShowCurrentNews();
}
}
public override void HandleInput()
{
base.HandleInput();
if ((MyScreenManager.GetScreenWithFocus() is MyGuiScreenGamePlay) && MyControllerHelper.IsControl(MySpaceBindingCreator.CX_CHARACTER, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED, false))
{
if ((MySession.Static.ControlledEntity != null) && (this.BotToSpawn != null))
{
this.TrySpawnBot();
}
if ((MySession.Static.ControlledEntity != null) && (this.CommandDefinition != null))
{
this.UseCommand();
}
}
}
public override void HandleInput()
{
if ((this.m_isActive && (MyScreenManager.GetScreenWithFocus() is MyGuiScreenGamePlay)) && ((MyInput.Static.ENABLE_DEVELOPER_KEYS || !MySession.Static.SurvivalMode) || MySession.Static.IsUserAdmin(Sync.MyId)))
{
base.HandleInput();
if (MyControllerHelper.IsControl(MySpaceBindingCreator.CX_CHARACTER, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED, false))
{
this.m_startTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
}
if (MyControllerHelper.IsControl(MySpaceBindingCreator.CX_CHARACTER, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_RELEASED, false))
{
MyObjectBuilder_CubeGrid[] gridPrefab = MyPrefabManager.Static.GetGridPrefab(this.CurrentDefinition.PrefabToThrow);
Vector3D zero = Vector3D.Zero;
Vector3D forward = Vector3D.Zero;
if (USE_SPECTATOR_FOR_THROW)
{
zero = MySpectator.Static.Position;
forward = MySpectator.Static.Orientation.Forward;
}
else if ((MySession.Static.GetCameraControllerEnum() != MyCameraControllerEnum.ThirdPersonSpectator) && (MySession.Static.GetCameraControllerEnum() != MyCameraControllerEnum.Entity))
{
zero = MySector.MainCamera.Position;
forward = MySector.MainCamera.WorldMatrix.Forward;
}
else
{
if (MySession.Static.ControlledEntity == null)
{
return;
}
zero = MySession.Static.ControlledEntity.GetHeadMatrix(true, true, false, false).Translation;
forward = MySession.Static.ControlledEntity.GetHeadMatrix(true, true, false, false).Forward;
}
Vector3D vectord3 = zero + forward;
Vector3D vectord4 = (forward * MathHelper.Clamp(((((float)(MySandboxGame.TotalGamePlayTimeInMilliseconds - this.m_startTime)) / 1000f) / this.CurrentDefinition.PushTime) * this.CurrentDefinition.MaxSpeed, this.CurrentDefinition.MinSpeed, this.CurrentDefinition.MaxSpeed)) + MySession.Static.ControlledEntity.Entity.Physics.LinearVelocity;
float num2 = 0f;
if (this.CurrentDefinition.Mass != null)
{
num2 = MyDestructionHelper.MassToHavok(this.CurrentDefinition.Mass.Value);
}
gridPrefab[0].EntityId = MyEntityIdentifier.AllocateId(MyEntityIdentifier.ID_OBJECT_TYPE.ENTITY, MyEntityIdentifier.ID_ALLOCATION_METHOD.RANDOM);
EndpointId targetEndpoint = new EndpointId();
Vector3D? position = null;
MyMultiplayer.RaiseStaticEvent <MyObjectBuilder_CubeGrid, Vector3D, Vector3D, float, MyCueId>(s => new Action <MyObjectBuilder_CubeGrid, Vector3D, Vector3D, float, MyCueId>(MySessionComponentThrower.OnThrowMessageSuccess), gridPrefab[0], vectord3, vectord4, num2, this.CurrentDefinition.ThrowSound, targetEndpoint, position);
this.m_startTime = 0;
}
}
}
private bool HandleLeftMouseButton(MyStringId context)
{
if (MyInput.Static.IsNewLeftMousePressed() || MyControllerHelper.IsControl(context, MyControlsSpace.COPY_PASTE_ACTION))
{
bool handled = false;
if (m_clipboard.IsActive)
{
if (m_clipboard.PasteGrid())
{
UpdatePasteNotification(MyCommonTexts.CubeBuilderPasteNotification);
handled = true;
}
}
if (m_floatingObjectClipboard.IsActive)
{
if (m_floatingObjectClipboard.PasteFloatingObject())
{
UpdatePasteNotification(MyCommonTexts.CubeBuilderPasteNotification);
handled = true;
}
}
if (m_voxelClipboard.IsActive)
{
if (m_voxelClipboard.PasteVoxelMap())
{
UpdatePasteNotification(MyCommonTexts.CubeBuilderPasteNotification);
handled = true;
}
}
if (handled)
{
this.Deactivate();
return(true);
}
}
return(false);
}
public override MyGuiControlBase HandleInput()
{
var captureInput = base.HandleInput();
if (captureInput != null)
{
return(captureInput);
}
bool isControl = MyInput.Static.IsNewLeftMouseReleased() || MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.ACCEPT, MyControlStateType.NEW_RELEASED);
if (Enabled && IsMouseOver && isControl ||
HasFocus && MyInput.Static.IsNewKeyPressed(MyKeys.Enter))
{
Value = !Value;
captureInput = this;
MyGuiSoundManager.PlaySound(GuiSounds.MouseClick);
}
return(captureInput);
}
public override void HandleInput(bool receivedFocusInThisUpdate)
{
if (MyInput.Static.IsNewKeyPressed(MyKeys.Up) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_UP, MyControlStateType.NEW_PRESSED))
{
UpdateSelectedItem(true);
UpdateScroll();
}
else if (MyInput.Static.IsNewKeyPressed(MyKeys.Down) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_DOWN, MyControlStateType.NEW_PRESSED))
{
UpdateSelectedItem(false);
UpdateScroll();
}
else if (MyInput.Static.IsNewKeyPressed(MyKeys.Escape) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.CANCEL, MyControlStateType.NEW_PRESSED) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsSpace.CONTROL_MENU, MyControlStateType.NEW_PRESSED))
{
Canceling();
}
if (m_selectedItem != -1)
{
if (MyInput.Static.IsNewKeyPressed(MyKeys.Right) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_RIGHT, MyControlStateType.NEW_PRESSED))
{
m_items[m_selectedItem].UpdateItem(ItemUpdateType.Next);
}
else if (MyInput.Static.IsNewKeyPressed(MyKeys.Left) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.MOVE_LEFT, MyControlStateType.NEW_PRESSED))
{
m_items[m_selectedItem].UpdateItem(ItemUpdateType.Previous);
}
else if (MyInput.Static.IsNewKeyPressed(MyKeys.Enter) ||
MyControllerHelper.IsControl(MyControllerHelper.CX_GUI, MyControlsGUI.ACCEPT, MyControlStateType.NEW_PRESSED))
{
m_items[m_selectedItem].UpdateItem(ItemUpdateType.Activate);
}
}
}
public override void HandleInput(bool receivedFocusInThisUpdate)
{
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.HELP_SCREEN) || MyControllerHelper.IsControl(MySpaceBindingCreator.CX_GUI, MyControlsGUI.BUTTON_Y))
{
if (MyInput.Static.IsAnyShiftKeyPressed() && MyPerGameSettings.GUI.PerformanceWarningScreen != null)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.PerformanceWarningScreen));
}
else
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.HelpScreen));
}
}
if (MyControllerHelper.IsControl(MyControllerHelper.CX_BASE, MyControlsSpace.WARNING_SCREEN) && MyPerGameSettings.GUI.PerformanceWarningScreen != null)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.PerformanceWarningScreen));
}
base.HandleInput(receivedFocusInThisUpdate);
}
public bool HandleGameInput()
{
m_rotationHintRotating = false;
var context = (m_activated && MySession.Static.ControlledEntity is MyCharacter) ? MySession.Static.ControlledEntity.ControlContext : MyStringId.NullOrEmpty;
// When spectator active, building is instant
if (MySession.Static.IsCopyPastingEnabled || MySession.Static.CreativeMode || (SpectatorIsBuilding && MyFinalBuildConstants.IS_OFFICIAL == false))
{
if (MySession.Static.IsCopyPastingEnabled && !(MySession.Static.ControlledEntity is MyShipController))
{
if (this.HandleCopyInput())
{
return(true);
}
if (this.HandleCutInput())
{
return(true);
}
if (this.HandlePasteInput())
{
return(true);
}
if (HandleMouseScrollInput(context))
{
return(true);
}
}
if (this.HandleEscape())
{
return(true);
}
if (this.HandleLeftMouseButton(context))
{
return(true);
}
}
if (this.HandleBlueprintInput())
{
return(true);
}
if (m_clipboard != null && m_clipboard.IsActive && (MyControllerHelper.IsControl(context, MyControlsSpace.FREE_ROTATION) ||
MyControllerHelper.IsControl(context, MyControlsSpace.SWITCH_BUILDING_MODE)))
{
m_clipboard.EnableStationRotation = !m_clipboard.EnableStationRotation;
m_floatingObjectClipboard.EnableStationRotation = !m_floatingObjectClipboard.EnableStationRotation;
//if (m_clipboard.EnableStationRotation)
// ShowStationRotationNotification();
//else
// HideStationRotationNotification();
}
if (HandleRotationInput(context))
{
return(true);
}
return(false);
}
public override void HandleInput()
{
ProfilerShort.Begin("MyToolbarComponent.HandleInput");
try
{
var context = MySession.Static.ControlledEntity != null ? MySession.Static.ControlledEntity.ControlContext : MyStringId.NullOrEmpty;
var focusedScreen = MyScreenManager.GetScreenWithFocus();
if ((focusedScreen == MyGuiScreenGamePlay.Static ||
IsToolbarControlShown) &&
CurrentToolbar != null && !MyGuiScreenGamePlay.DisableInput)
{
{
for (int i = 0; i < m_slotControls.Length; i++)
{
if (MyControllerHelper.IsControl(context, m_slotControls[i], MyControlStateType.NEW_PRESSED))
{
if (!MyInput.Static.IsAnyCtrlKeyPressed())
{
if ((focusedScreen is MyGuiScreenScriptingTools || focusedScreen == MyGuiScreenGamePlay.Static ||
(focusedScreen is MyGuiScreenCubeBuilder || focusedScreen is MyGuiScreenToolbarConfigBase) && ((MyGuiScreenToolbarConfigBase)focusedScreen).AllowToolbarKeys()) &&
CurrentToolbar != null)
{
CurrentToolbar.ActivateItemAtSlot(i);
}
}
else if (i < CurrentToolbar.PageCount)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
CurrentToolbar.SwitchToPage(i);
}
}
}
}
if ((focusedScreen == MyGuiScreenGamePlay.Static ||
(focusedScreen is MyGuiScreenCubeBuilder || focusedScreen is MyGuiScreenToolbarConfigBase) && ((MyGuiScreenToolbarConfigBase)focusedScreen).AllowToolbarKeys()) &&
CurrentToolbar != null)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_NEXT_ITEM, MyControlStateType.NEW_PRESSED))
{
CurrentToolbar.SelectNextSlot();
}
else if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_PREV_ITEM, MyControlStateType.NEW_PRESSED))
{
CurrentToolbar.SelectPreviousSlot();
}
if (MySpectator.Static.SpectatorCameraMovement != MySpectatorCameraMovementEnum.ConstantDelta)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_UP, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
CurrentToolbar.PageUp();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.TOOLBAR_DOWN, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
CurrentToolbar.PageDown();
}
}
}
}
}
finally
{
ProfilerShort.End();
}
base.HandleInput();
}
public override void HandleInput()
{
if (!m_isActive)
{
return;
}
if (!(MyScreenManager.GetScreenWithFocus() is MyGuiScreenGamePlay))
{
return;
}
if (!
(VRage.Input.MyInput.Static.ENABLE_DEVELOPER_KEYS || !MySession.Static.SurvivalMode || (MyMultiplayer.Static != null && MyMultiplayer.Static.IsAdmin(MySession.Static.LocalHumanPlayer.Id.SteamId)))
)
{
return;
}
base.HandleInput();
if (MyControllerHelper.IsControl(MySpaceBindingCreator.CX_CHARACTER, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED))
{
m_startTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
}
if (MyControllerHelper.IsControl(MySpaceBindingCreator.CX_CHARACTER, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_RELEASED))
{
var gridBuilders = MyPrefabManager.Static.GetGridPrefab(CurrentDefinition.PrefabToThrow);
Vector3D cameraPos = Vector3D.Zero;
Vector3D cameraDir = Vector3D.Zero;
if (USE_SPECTATOR_FOR_THROW)
{
cameraPos = MySpectator.Static.Position;
cameraDir = MySpectator.Static.Orientation.Forward;
}
else
{
if (MySession.Static.GetCameraControllerEnum() == MyCameraControllerEnum.ThirdPersonSpectator || MySession.Static.GetCameraControllerEnum() == MyCameraControllerEnum.Entity)
{
if (MySession.Static.ControlledEntity == null)
{
return;
}
cameraPos = MySession.Static.ControlledEntity.GetHeadMatrix(true, true).Translation;
cameraDir = MySession.Static.ControlledEntity.GetHeadMatrix(true, true).Forward;
}
else
{
cameraPos = MySector.MainCamera.Position;
cameraDir = MySector.MainCamera.WorldMatrix.Forward;
}
}
var position = cameraPos + cameraDir;
float deltaSeconds = (MySandboxGame.TotalGamePlayTimeInMilliseconds - m_startTime) / 1000.0f;
float velocity = deltaSeconds / CurrentDefinition.PushTime * CurrentDefinition.MaxSpeed;
velocity = MathHelper.Clamp(velocity, CurrentDefinition.MinSpeed, CurrentDefinition.MaxSpeed);
var linearVelocity = cameraDir * velocity + MySession.Static.ControlledEntity.Entity.Physics.LinearVelocity;
float mass = 0;
if (CurrentDefinition.Mass.HasValue)
{
mass = Sandbox.Engine.Physics.MyDestructionHelper.MassToHavok(CurrentDefinition.Mass.Value);
}
gridBuilders[0].EntityId = MyEntityIdentifier.AllocateId();
MyMultiplayer.RaiseStaticEvent(s => MySessionComponentThrower.OnThrowMessageSuccess, gridBuilders[0], position, linearVelocity, mass, CurrentDefinition.ThrowSound);
m_startTime = 0;
}
}
// This method is called every update (but only if application has focus)
public override void HandleUnhandledInput(bool receivedFocusInThisUpdate)
{
if (MyInput.Static.ENABLE_DEVELOPER_KEYS || (MySession.Static != null && MySession.Static.Settings.EnableSpectator) || (MyMultiplayer.Static != null && MySession.LocalHumanPlayer != null && MyMultiplayer.Static.IsAdmin(MySession.LocalHumanPlayer.Id.SteamId)))
{
//Set camera to player
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SPECTATOR_NONE))
{
if (MySession.ControlledEntity != null)
{ //we already are controlling this object
if (MyFinalBuildConstants.IS_OFFICIAL)
{
SetCameraController();
}
else
{
var cameraController = MySession.GetCameraControllerEnum();
if (cameraController != MyCameraControllerEnum.Entity && cameraController != MyCameraControllerEnum.ThirdPersonSpectator)
{
SetCameraController();
}
else
{
var entities = MyEntities.GetEntities().ToList();
int lastKnownIndex = entities.IndexOf(MySession.ControlledEntity.Entity);
var entitiesList = new List <MyEntity>();
if (lastKnownIndex + 1 < entities.Count)
{
entitiesList.AddRange(entities.GetRange(lastKnownIndex + 1, entities.Count - lastKnownIndex - 1));
}
if (lastKnownIndex != -1)
{
entitiesList.AddRange(entities.GetRange(0, lastKnownIndex + 1));
}
MyCharacter newControlledObject = null;
for (int i = 0; i < entitiesList.Count; i++)
{
var character = entitiesList[i] as MyCharacter;
if (character != null && !character.IsDead)
{
newControlledObject = character;
break;
}
}
if (MySession.LocalHumanPlayer != null && newControlledObject != null)
{
MySession.LocalHumanPlayer.Controller.TakeControl(newControlledObject);
}
}
// We could have activated the cube builder in spectator, so deactivate it now
if (MyCubeBuilder.Static.IsActivated && !(MySession.ControlledEntity is MyCharacter))
{
MyCubeBuilder.Static.Deactivate();
}
}
}
}
//Set camera to following third person
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SPECTATOR_DELTA))
{
if (MySession.ControlledEntity != null)
{
MySession.SetCameraController(MyCameraControllerEnum.SpectatorDelta);
}
}
//Set camera to spectator
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SPECTATOR_FREE))
{
if (!MyFakes.ENABLE_BATTLE_SYSTEM || !MySession.Static.Battle || Sync.IsServer)
{
if (MySession.GetCameraControllerEnum() != MyCameraControllerEnum.Spectator)
{
MySession.SetCameraController(MyCameraControllerEnum.Spectator);
}
else if (MyInput.Static.IsAnyShiftKeyPressed())
{
MyFakes.ENABLE_DEVELOPER_SPECTATOR_CONTROLS = !MyFakes.ENABLE_DEVELOPER_SPECTATOR_CONTROLS;
}
if (MyInput.Static.IsAnyCtrlKeyPressed() && MySession.ControlledEntity != null)
{
MySpectator.Static.Position = (Vector3D)MySession.ControlledEntity.Entity.PositionComp.GetPosition() + MySpectator.Static.ThirdPersonCameraDelta;
MySpectator.Static.Target = (Vector3D)MySession.ControlledEntity.Entity.PositionComp.GetPosition();
}
}
}
//Set camera to static spectator, non movable
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SPECTATOR_STATIC))
{
if (MySession.ControlledEntity != null)
{
MySession.SetCameraController(MyCameraControllerEnum.SpectatorFixed);
if (MyInput.Static.IsAnyCtrlKeyPressed())
{
MySpectator.Static.Position = (Vector3D)MySession.ControlledEntity.Entity.PositionComp.GetPosition() + MySpectator.Static.ThirdPersonCameraDelta;
MySpectator.Static.Target = (Vector3D)MySession.ControlledEntity.Entity.PositionComp.GetPosition();
}
}
}
//Open console
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.CONSOLE) && MyInput.Static.IsAnyAltKeyPressed())
{
MyGuiScreenConsole.Show();
}
}
if (MyDefinitionErrors.ShouldShowModErrors)
{
MyDefinitionErrors.ShouldShowModErrors = false;
MyGuiSandbox.ShowModErrors();
}
// Switch view - cockpit on/off, third person
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.CAMERA_MODE) && CanSwitchCamera)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
SwitchCamera();
}
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.HELP_SCREEN))
{
if (MyInput.Static.IsAnyCtrlKeyPressed())
{
switch (MySandboxGame.Config.DebugComponentsInfo)
{
case MyDebugComponent.MyDebugComponentInfoState.NoInfo:
MySandboxGame.Config.DebugComponentsInfo = MyDebugComponent.MyDebugComponentInfoState.EnabledInfo;
break;
case MyDebugComponent.MyDebugComponentInfoState.EnabledInfo:
MySandboxGame.Config.DebugComponentsInfo = MyDebugComponent.MyDebugComponentInfoState.FullInfo;
break;
case MyDebugComponent.MyDebugComponentInfoState.FullInfo:
MySandboxGame.Config.DebugComponentsInfo = MyDebugComponent.MyDebugComponentInfoState.NoInfo;
break;
}
MySandboxGame.Config.Save();
}
else
if (MyGuiScreenGamePlay.ActiveGameplayScreen == null)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyGuiSandbox.AddScreen(MyGuiScreenGamePlay.ActiveGameplayScreen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.HelpScreen));
}
}
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.TOGGLE_HUD))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
MyHud.MinimalHud = !MyHud.MinimalHud;
}
if (MyPerGameSettings.SimplePlayerNames && MyInput.Static.IsNewGameControlPressed(MyControlsSpace.BROADCASTING))
{
MyHud.LocationMarkers.Visible = !MyHud.LocationMarkers.Visible;
}
var controlledObject = MySession.ControlledEntity;
var currentCameraController = MySession.Static.CameraController;
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.MISSION_SETTINGS) && MyGuiScreenGamePlay.ActiveGameplayScreen == null &&
MyPerGameSettings.Game == Sandbox.Game.GameEnum.SE_GAME &&
MyFakes.ENABLE_MISSION_TRIGGERS &&
MySession.Static.Settings.ScenarioEditMode)
{
MyGuiSandbox.AddScreen(new Sandbox.Game.Screens.MyGuiScreenMissionTriggers());
}
MyStringId context = controlledObject != null ? controlledObject.ControlContext : MySpaceBindingCreator.CX_BASE;
bool handledByUseObject = false;
if (MySession.ControlledEntity is VRage.Game.Entity.UseObject.IMyUseObject)
{
handledByUseObject = (MySession.ControlledEntity as VRage.Game.Entity.UseObject.IMyUseObject).HandleInput();
}
if (controlledObject != null && !handledByUseObject)
{
if (!MySandboxGame.IsPaused)
{
if (context == MySpaceBindingCreator.CX_BUILD_MODE || context == MySpaceBindingCreator.CX_CHARACTER || context == MySpaceBindingCreator.CX_SPACESHIP)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED))
{
if (MyToolbarComponent.CurrentToolbar.ShouldActivateSlot)
{
MyToolbarComponent.CurrentToolbar.ActivateStagedSelectedItem();
}
else
{
controlledObject.BeginShoot(MyShootActionEnum.PrimaryAction);
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_RELEASED))
{
controlledObject.EndShoot(MyShootActionEnum.PrimaryAction);
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.SECONDARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED))
{
controlledObject.BeginShoot(MyShootActionEnum.SecondaryAction);
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.SECONDARY_TOOL_ACTION, MyControlStateType.NEW_RELEASED))
{
controlledObject.EndShoot(MyShootActionEnum.SecondaryAction);
}
}
if (context == MySpaceBindingCreator.CX_CHARACTER || context == MySpaceBindingCreator.CX_SPACESHIP)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.USE, MyControlStateType.NEW_PRESSED))
{
// Key press
if (currentCameraController != null)
{
if (!currentCameraController.HandleUse())
{
controlledObject.Use();
}
}
else
{
controlledObject.Use();
}
}
else if (MyControllerHelper.IsControl(context, MyControlsSpace.USE, MyControlStateType.PRESSED))
{
// Key not pressed this frame, holding from previous
controlledObject.UseContinues();
}
else if (MyControllerHelper.IsControl(context, MyControlsSpace.USE, MyControlStateType.NEW_RELEASED))
{
controlledObject.UseFinished();
}
//Temp fix until spectators are implemented as entities
//Prevents controlled object from getting input while spectator mode is enabled
if (!(MySession.Static.CameraController is MySpectatorCameraController && MySpectatorCameraController.Static.SpectatorCameraMovement == MySpectatorCameraMovementEnum.UserControlled))
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.CROUCH, MyControlStateType.NEW_PRESSED))
{
controlledObject.Crouch();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.CROUCH, MyControlStateType.PRESSED))
{
controlledObject.Down();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.SPRINT, MyControlStateType.PRESSED))
{
controlledObject.Sprint();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.JUMP, MyControlStateType.NEW_PRESSED))
{
controlledObject.Jump();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.JUMP, MyControlStateType.PRESSED))
{
controlledObject.Up();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.SWITCH_WALK, MyControlStateType.NEW_PRESSED))
{
controlledObject.SwitchWalk();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.BROADCASTING, MyControlStateType.NEW_PRESSED))
{
controlledObject.SwitchBroadcasting();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.HELMET, MyControlStateType.NEW_PRESSED))
{
controlledObject.SwitchHelmet();
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.DAMPING, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
controlledObject.SwitchDamping();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.THRUSTS, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
controlledObject.SwitchThrusts();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.HEADLIGHTS, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
controlledObject.SwitchLights();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.TOGGLE_REACTORS, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
controlledObject.SwitchReactors();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.LANDING_GEAR, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
controlledObject.SwitchLeadingGears();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.SUICIDE, MyControlStateType.NEW_PRESSED))
{
controlledObject.Die();
}
if ((controlledObject as MyCockpit) != null && MyControllerHelper.IsControl(context, MyControlsSpace.CUBE_COLOR_CHANGE, MyControlStateType.NEW_PRESSED))
{
(controlledObject as MyCockpit).SwitchWeaponMode();
}
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.TERMINAL, MyControlStateType.NEW_PRESSED) && MyGuiScreenGamePlay.ActiveGameplayScreen == null)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
controlledObject.ShowTerminal();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.INVENTORY, MyControlStateType.NEW_PRESSED) && MyGuiScreenGamePlay.ActiveGameplayScreen == null)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
controlledObject.ShowInventory();
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.CONTROL_MENU, MyControlStateType.NEW_PRESSED) && MyGuiScreenGamePlay.ActiveGameplayScreen == null)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
m_controlMenu.OpenControlMenu(controlledObject);
}
if (!MyCompilationSymbols.RenderProfiling && MyControllerHelper.IsControl(context, MyControlsSpace.CHAT_SCREEN, MyControlStateType.NEW_PRESSED))
{
if (MyGuiScreenChat.Static == null)
{
Vector2 chatPos = new Vector2(0.01f, 0.84f);
chatPos = MyGuiScreenHudBase.ConvertHudToNormalizedGuiPosition(ref chatPos);
MyGuiScreenChat chatScreen = new MyGuiScreenChat(chatPos);
MyGuiSandbox.AddScreen(chatScreen);
}
}
if (MyPerGameSettings.VoiceChatEnabled)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.VOICE_CHAT, MyControlStateType.NEW_PRESSED))
{
MyVoiceChatSessionComponent.Static.StartRecording();
}
//else if (MyControllerHelper.IsControl(context, MyControlsSpace.VOICE_CHAT, MyControlStateType.NEW_RELEASED))
// TODO: If other key was pressed during VOIP, NEW_RELEASED will return false even if this key was pressed, is this correct? We don't store key states?
else if (MyVoiceChatSessionComponent.Static.IsRecording && !MyControllerHelper.IsControl(context, MyControlsSpace.VOICE_CHAT, MyControlStateType.PRESSED))
{
MyVoiceChatSessionComponent.Static.StopRecording();
}
}
}
MoveAndRotatePlayerOrCamera();
// Quick save or quick load.
if (MyInput.Static.IsNewKeyPressed(MyKeys.F5))
{
if (!MySession.Static.IsScenario)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
var currentSession = MySession.Static.CurrentPath;
if (MyInput.Static.IsAnyShiftKeyPressed())
{
if (MySession.Static.ClientCanSave || Sync.IsServer)
{
if (!MyAsyncSaving.InProgress)
{
var messageBox = MyGuiSandbox.CreateMessageBox(
buttonType : MyMessageBoxButtonsType.YES_NO,
messageText : MyTexts.Get(MySpaceTexts.MessageBoxTextAreYouSureYouWantToQuickSave),
messageCaption : MyTexts.Get(MySpaceTexts.MessageBoxCaptionPleaseConfirm),
callback : delegate(MyGuiScreenMessageBox.ResultEnum callbackReturn)
{
if (callbackReturn == MyGuiScreenMessageBox.ResultEnum.YES)
{
MyAsyncSaving.Start(() => MySector.ResetEyeAdaptation = true); //black screen after save
}
});
messageBox.SkipTransition = true;
messageBox.CloseBeforeCallback = true;
MyGuiSandbox.AddScreen(messageBox);
}
}
else
{
MyHud.Notifications.Add(MyNotificationSingletons.ClientCannotSave);
}
}
else if (Sync.IsServer)
{
ShowLoadMessageBox(currentSession);
}
else
{
// Is multiplayer client, reconnect
ShowReconnectMessageBox();
}
}
}
// Launch main menu
if (MyInput.Static.IsNewKeyPressed(MyKeys.Escape) ||
MyControllerHelper.IsControl(context, MyControlsGUI.MAIN_MENU, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
//Allow changing video options from game in DX version
MyGuiScreenMainMenu.AddMainMenu();
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.F3))
{
if (Sync.MultiplayerActive)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyGuiSandbox.AddScreen(new MyGuiScreenPlayers());
}
else
{
MyHud.Notifications.Add(MyNotificationSingletons.MultiplayerDisabled);
}
}
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.BUILD_SCREEN) && MyGuiScreenGamePlay.ActiveGameplayScreen == null)
{
if (MyGuiScreenCubeBuilder.Static == null && (MySession.ControlledEntity is MyShipController || MySession.ControlledEntity is MyCharacter))
{
int offset = 0;
if (MyInput.Static.IsAnyShiftKeyPressed())
{
offset += 6;
}
if (MyInput.Static.IsAnyCtrlKeyPressed())
{
offset += 12;
}
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyGuiSandbox.AddScreen(
MyGuiScreenGamePlay.ActiveGameplayScreen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ToolbarConfigScreen,
offset,
MySession.ControlledEntity as MyShipController)
);
}
}
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.PAUSE_GAME))
{
MySandboxGame.UserPauseToggle();
}
if (MySession.Static != null)
{
if (MyInput.Static.IsNewKeyPressed(MyKeys.F10))
{
if (MyPerGameSettings.GUI.VoxelMapEditingScreen != null && MySession.Static.CreativeMode && MyInput.Static.IsAnyShiftKeyPressed())
{ // Shift+F10
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.VoxelMapEditingScreen));
}
else
{ // F10
if (MyFakes.ENABLE_BATTLE_SYSTEM && MySession.Static.Battle)
{
if (MyPerGameSettings.GUI.BattleBlueprintScreen != null)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.BattleBlueprintScreen));
}
else
{
Debug.Fail("No battle blueprint screen");
}
}
else
{
MyGuiSandbox.AddScreen(new MyGuiBlueprintScreen(MyCubeBuilder.Static.Clipboard));
}
}
}
}
// F11, mod debug
if (MyInput.Static.IsNewKeyPressed(MyKeys.F11) && !MyInput.Static.IsAnyShiftKeyPressed() && !MyInput.Static.IsAnyCtrlKeyPressed())
{
MyDX9Gui.SwitchModDebugScreen();
}
}
private bool HandleRotationInput(MyStringId context)
{
int frameDt = MySandboxGame.TotalGamePlayTimeInMilliseconds - m_lastInputHandleTime;
m_lastInputHandleTime += frameDt;
if (m_activated)
{
for (int i = 0; i < 6; ++i)
{
bool standardRotation = MyControllerHelper.IsControl(context, m_rotationControls[i], MyControlStateType.PRESSED);
if (standardRotation)
{
bool newStandardPress = MyControllerHelper.IsControl(context, m_rotationControls[i], MyControlStateType.NEW_PRESSED);
bool newPress = newStandardPress;
int axis = -1;
int direction = m_rotationDirections[i];
//if (MyFakes.ENABLE_STANDARD_AXES_ROTATION)
//{
// axis = GetStandardRotationAxisAndDirection(i, ref direction);
//}
if (MyFakes.ENABLE_STANDARD_AXES_ROTATION)
{
int[] axes = new int[] { 1, 1, 0, 0, 2, 2 };
if (m_rotationHints.RotationUpAxis != axes[i])
{
return(true);
//axis = m_rotationHints.RotationUpAxis;
//direction *= m_rotationHints.RotationUpDirection;
}
}
//else
//{
if (i < 2)
{
axis = m_rotationHints.RotationUpAxis;
direction *= m_rotationHints.RotationUpDirection;
}
if (i >= 2 && i < 4)
{
axis = m_rotationHints.RotationRightAxis;
direction *= m_rotationHints.RotationRightDirection;
}
if (i >= 4)
{
axis = m_rotationHints.RotationForwardAxis;
direction *= m_rotationHints.RotationForwardDirection;
}
// }
if (axis != -1)
{
m_rotationHintRotating |= !newPress;
RotateAxis(axis, direction, newPress, frameDt);
return(true);
}
}
}
}
return(false);
}