private void OnCreateClicked(MyGuiControlButton sender)
{
//MyGuiSandbox.AddScreen(new MyGuiScreenCreateOrEditFaction(ref m_userFaction));
var screen = (MyGuiScreenCreateOrEditFaction)MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.CreateFactionScreen);
screen.Init(ref m_userFaction);
MyGuiSandbox.AddScreen(screen);
}
public override void Activate()
{
MyScreenManager.CloseScreen(typeof(MyGuiScreenControlMenu));
MyGuiSandbox.AddScreen
(
MyGuiScreenGamePlay.ActiveGameplayScreen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ToolbarConfigScreen, 0, m_entity as MyShipController)
);
}
static MyTimerBlock()
{
m_openedToolbars = new List <MyToolbar>();
var silent = new MyTerminalControlCheckbox <MyTimerBlock>("Silent", MySpaceTexts.BlockPropertyTitle_Silent, MySpaceTexts.ToolTipTimerBlock_Silent);
silent.Getter = (x) => x.Silent;
silent.Setter = (x, v) => x.Silent = v;
silent.EnableAction();
MyTerminalControlFactory.AddControl(silent);
var slider = new MyTerminalControlSlider <MyTimerBlock>("TriggerDelay", MySpaceTexts.TerminalControlPanel_TimerDelay, MySpaceTexts.TerminalControlPanel_TimerDelay);
slider.SetLogLimits(1, 60 * 60);
slider.DefaultValue = 10;
slider.Enabled = (x) => !x.IsCountingDown;
slider.Getter = (x) => x.TriggerDelay;
slider.Setter = (x, v) => x.m_timerSync.Value = ((int)(Math.Round(v, 1) * 1000));
slider.Writer = (x, sb) => MyValueFormatter.AppendTimeExact(Math.Max(x.m_countdownMsStart, 1000) / 1000, sb);
slider.EnableActions();
MyTerminalControlFactory.AddControl(slider);
var toolbarButton = new MyTerminalControlButton <MyTimerBlock>("OpenToolbar", MySpaceTexts.BlockPropertyTitle_TimerToolbarOpen, MySpaceTexts.BlockPropertyTitle_TimerToolbarOpen,
delegate(MyTimerBlock self)
{
m_openedToolbars.Add(self.Toolbar);
if (MyGuiScreenCubeBuilder.Static == null)
{
m_shouldSetOtherToolbars = true;
MyToolbarComponent.CurrentToolbar = self.Toolbar;
MyGuiScreenBase screen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ToolbarConfigScreen, 0, self);
MyToolbarComponent.AutoUpdate = false;
screen.Closed += (source) =>
{
MyToolbarComponent.AutoUpdate = true;
m_openedToolbars.Clear();
};
MyGuiSandbox.AddScreen(screen);
}
});
MyTerminalControlFactory.AddControl(toolbarButton);
var triggerButton = new MyTerminalControlButton <MyTimerBlock>("TriggerNow", MySpaceTexts.BlockPropertyTitle_TimerTrigger, MySpaceTexts.BlockPropertyTitle_TimerTrigger, (x) => x.OnTrigger());
triggerButton.EnableAction();
MyTerminalControlFactory.AddControl(triggerButton);
var startButton = new MyTerminalControlButton <MyTimerBlock>("Start", MySpaceTexts.BlockPropertyTitle_TimerStart, MySpaceTexts.BlockPropertyTitle_TimerStart, (x) => x.StartBtn());
startButton.EnableAction();
MyTerminalControlFactory.AddControl(startButton);
var stopButton = new MyTerminalControlButton <MyTimerBlock>("Stop", MySpaceTexts.BlockPropertyTitle_TimerStop, MySpaceTexts.BlockPropertyTitle_TimerStop, (x) => x.StopBtn());
stopButton.EnableAction();
MyTerminalControlFactory.AddControl(stopButton);
}
public override void HandleInput(bool receivedFocusInThisUpdate)
{
base.HandleInput(receivedFocusInThisUpdate);
if (MyInput.Static.IsNewKeyPressed(MyKeys.Escape))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.MainMenu));
}
}
public static void StartLoading(Action loadingAction)
{
var newGameplayScreen = new MyGuiScreenGamePlay();
newGameplayScreen.OnLoadingAction += loadingAction;
var loadScreen = new MyGuiScreenLoading(newGameplayScreen, MyGuiScreenGamePlay.Static);
loadScreen.OnScreenLoadingFinished += delegate
{
MyModAPIHelper.OnSessionLoaded();
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.HUDScreen));
};
MyGuiSandbox.AddScreen(loadScreen);
}
protected override void CreateTerminalControls()
{
if (MyTerminalControlFactory.AreControlsCreated <MyButtonPanel>())
{
return;
}
base.CreateTerminalControls();
var checkAccess = new MyTerminalControlCheckbox <MyButtonPanel>("AnyoneCanUse", MySpaceTexts.BlockPropertyText_AnyoneCanUse, MySpaceTexts.BlockPropertyDescription_AnyoneCanUse);
checkAccess.Getter = (x) => x.AnyoneCanUse;
checkAccess.Setter = (x, v) => x.AnyoneCanUse = v;
checkAccess.EnableAction();
MyTerminalControlFactory.AddControl(checkAccess);
var toolbarButton = new MyTerminalControlButton <MyButtonPanel>("Open Toolbar", MySpaceTexts.BlockPropertyTitle_SensorToolbarOpen, MySpaceTexts.BlockPropertyDescription_SensorToolbarOpen,
delegate(MyButtonPanel self)
{
m_openedToolbars.Add(self.Toolbar);
if (MyGuiScreenCubeBuilder.Static == null)
{
m_shouldSetOtherToolbars = true;
MyToolbarComponent.CurrentToolbar = self.Toolbar;
MyGuiScreenBase screen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ToolbarConfigScreen, 0, self);
MyToolbarComponent.AutoUpdate = false;
screen.Closed += (source) =>
{
MyToolbarComponent.AutoUpdate = true;
m_openedToolbars.Clear();
};
MyGuiSandbox.AddScreen(screen);
}
});
MyTerminalControlFactory.AddControl(toolbarButton);
var buttonsList = new MyTerminalControlListbox <MyButtonPanel>("ButtonText", MySpaceTexts.BlockPropertyText_ButtonList, MySpaceTexts.Blank);
buttonsList.ListContent = (x, list1, list2) => x.FillListContent(list1, list2);
buttonsList.ItemSelected = (x, y) => x.SelectButtonToName(y);
MyTerminalControlFactory.AddControl(buttonsList);
var customButtonName = new MyTerminalControlTextbox <MyButtonPanel>("ButtonName", MySpaceTexts.BlockPropertyText_ButtonName, MySpaceTexts.Blank);
customButtonName.Getter = (x) => x.GetButtonName();
customButtonName.Setter = (x, v) => x.SetCustomButtonName(v);
customButtonName.SupportsMultipleBlocks = false;
MyTerminalControlFactory.AddControl(customButtonName);
}
public static void StartLoading(Action loadingAction, string customLoadingBackground = null, string customLoadingtext = null)
{
MyAnalyticsHelper.LoadingStarted();
var newGameplayScreen = new MyGuiScreenGamePlay();
newGameplayScreen.OnLoadingAction += loadingAction;
var loadScreen = new MyGuiScreenLoading(newGameplayScreen, MyGuiScreenGamePlay.Static, customLoadingBackground, customLoadingtext);
loadScreen.OnScreenLoadingFinished += delegate
{
MyModAPIHelper.OnSessionLoaded();
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.HUDScreen));
};
MyGuiSandbox.AddScreen(loadScreen);
}
public override void HandleInput(bool receivedFocusInThisUpdate)
{
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.HELP_SCREEN))
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.HelpScreen));
}
base.HandleInput(receivedFocusInThisUpdate);
if (MyInput.Static.ENABLE_DEVELOPER_KEYS)
{
if (MyInput.Static.IsNewKeyPressed(MyKeys.Multiply) && MyInput.Static.IsAnyShiftKeyPressed())
{
GC.Collect();
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.M))
{
RecreateControls(false);
}
}
/*
* if (MyGuiScreenGamePlay.Static == null || MyGuiScreenGamePlay.Static.GetGameType() == MyGuiScreenGamePlayType.MAIN_MENU)
* {
* if (input.IsNewKeyPress(Keys.Escape))
* {
* MyAudio.Static.AddCue2D(MySoundCuesEnum.HudMouseClick);
* OnExitToWindowsClick(null);
* }
* }
*/
//if (input.IsNewKeyPress(Keys.Enter))
//{
// MyGuiSandbox.AddScreen(new MyGuiScreenLoading(Vector2.Zero, null, null, null, new MyGuiScreenGamePlay(Vector2.Zero, null, null, null, false), MyGuiScreenGamePlay.Static));
// CloseScreen();
//}
//if (input.IsNewKeyPress(Keys.Escape))
//{
// CloseScreen();
//}
//if (input.IsNewKeyPress(VRageMath.Input.Keys.P))
//{
// MySandboxGame.Static.UnloadContent();
//}
}
protected override void CreateTerminalControls()
{
if (MyTerminalControlFactory.AreControlsCreated <MyAirVent>())
{
return;
}
base.CreateTerminalControls();
var isDepressurizing = new MyTerminalControlOnOffSwitch <MyAirVent>("Depressurize", MySpaceTexts.BlockPropertyTitle_Depressurize, MySpaceTexts.BlockPropertyDescription_Depressurize);
isDepressurizing.Getter = (x) => x.IsDepressurizing;
isDepressurizing.Setter = (x, v) => { x.IsDepressurizing = v; x.UpdateEmissivity(); };
isDepressurizing.EnableToggleAction();
isDepressurizing.EnableOnOffActions();
MyTerminalControlFactory.AddControl(isDepressurizing);
var toolbarButton = new MyTerminalControlButton <MyAirVent>("Open Toolbar", MySpaceTexts.BlockPropertyTitle_SensorToolbarOpen, MySpaceTexts.BlockPropertyDescription_SensorToolbarOpen,
delegate(MyAirVent self)
{
if (self.m_onFullAction != null)
{
self.m_actionToolbar.SetItemAtIndex(0, self.m_onFullAction);
}
if (self.m_onEmptyAction != null)
{
self.m_actionToolbar.SetItemAtIndex(1, self.m_onEmptyAction);
}
self.m_actionToolbar.ItemChanged += self.Toolbar_ItemChanged;
if (MyGuiScreenCubeBuilder.Static == null)
{
MyToolbarComponent.CurrentToolbar = self.m_actionToolbar;
MyGuiScreenBase screen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ToolbarConfigScreen, 0, self);
MyToolbarComponent.AutoUpdate = false;
screen.Closed += (source) =>
{
MyToolbarComponent.AutoUpdate = true;
self.m_actionToolbar.ItemChanged -= self.Toolbar_ItemChanged;
self.m_actionToolbar.Clear();
};
MyGuiSandbox.AddScreen(screen);
}
});
toolbarButton.SupportsMultipleBlocks = false;
MyTerminalControlFactory.AddControl(toolbarButton);
}
public static void OnJoinBattle(MyGuiScreenProgress progress, Result joinResult, LobbyEnterInfo enterInfo, MyMultiplayerBase multiplayer)
{
MyLog.Default.WriteLine(String.Format("Battle lobby join response: {0}, enter state: {1}", joinResult.ToString(), enterInfo.EnterState));
bool battleCanBeJoined = multiplayer != null && multiplayer.BattleCanBeJoined;
if (joinResult == Result.OK && enterInfo.EnterState == LobbyEnterResponseEnum.Success && battleCanBeJoined && multiplayer.GetOwner() != MySteam.UserId)
{
// Create session with empty world
Debug.Assert(MySession.Static == null);
MySession.CreateWithEmptyWorld(multiplayer);
MySession.Static.Settings.Battle = true;
progress.CloseScreen();
MyLog.Default.WriteLine("Battle lobby joined");
if (MyPerGameSettings.GUI.BattleLobbyClientScreen != null)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.BattleLobbyClientScreen));
}
else
{
Debug.Fail("No battle lobby client screen");
}
}
else
{
string status = "ServerHasLeft";
if (joinResult != Result.OK)
{
status = joinResult.ToString();
}
else if (enterInfo.EnterState != LobbyEnterResponseEnum.Success)
{
status = enterInfo.EnterState.ToString();
}
else if (!battleCanBeJoined)
{
status = "Started battle cannot be joined";
}
OnJoinBattleFailed(progress, multiplayer, status);
}
}
private void OnClickNewGame(MyGuiControlButton sender)
{
if (MySandboxGame.Config.EnableNewNewGameScreen)
{
RunWithTutorialCheck(delegate
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenSimpleNewGame>(Array.Empty <object>()));
});
return;
}
RunWithTutorialCheck(delegate
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenNewGame>(new object[3] {
true, true, true
}));
});
}
public override void RecreateControls(bool constructor)
{
base.RecreateControls(constructor);
_elementGroup = new MyGuiControlElementGroup();
_elementGroup.HighlightChanged += ElementGroupHighlightChanged;
AddCaption(MyCommonTexts.ScreenCaptionOptions, null, null);
var value = new Vector2(0f, -m_size.Value.Y / 2f + 0.146f);
var num = 0;
var myGuiControlButton = new MyGuiControlButton(value + num ++ *MyGuiConstants.MENU_BUTTONS_POSITION_DELTA, MyGuiControlButtonStyleEnum.Default, null, null, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER, null, MyTexts.Get(MyCommonTexts.ScreenOptionsButtonGame), 0.8f, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER, MyGuiControlHighlightType.WHEN_ACTIVE, delegate(MyGuiControlButton sender)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <TorchSettingsScreen>());
}, GuiSounds.MouseClick, 1f, null);
Controls.Add(myGuiControlButton);
_elementGroup.Add(myGuiControlButton);
CloseButtonEnabled = true;
}
public static void OnJoinScenario(MyGuiScreenProgress progress, Result joinResult, LobbyEnterInfo enterInfo, MyMultiplayerBase multiplayer)
{
MyLog.Default.WriteLine(String.Format("Lobby join response: {0}, enter state: {1}", joinResult.ToString(), enterInfo.EnterState));
if (joinResult == Result.OK && enterInfo.EnterState == LobbyEnterResponseEnum.Success && multiplayer.GetOwner() != Sync.MyId)
{
// Create session with empty world
if (MySession.Static != null)
{
MySession.Static.Unload();
MySession.Static = null;
}
MySession.CreateWithEmptyWorld(multiplayer);
progress.CloseScreen();
MyScreenManager.CloseAllScreensNowExcept(null);
MyLog.Default.WriteLine("Scenario lobby joined");
if (MyPerGameSettings.GUI.ScenarioLobbyClientScreen != null)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ScenarioLobbyClientScreen));
}
else
{
Debug.Fail("No scenario lobby client screen");
}
}
else
{
string status = "ServerHasLeft";
if (joinResult != Result.OK)
{
status = joinResult.ToString();
}
else if (enterInfo.EnterState != LobbyEnterResponseEnum.Success)
{
status = enterInfo.EnterState.ToString();
}
OnJoinBattleFailed(progress, multiplayer, status);
}
}
void OnEditClick(MyGuiControlButton sender)
{
var row = m_sessionsTable.SelectedRow;
if (row == null)
{
return;
}
var save = FindSave(row);
if (save != null)
{
ulong dummySizeInBytes;
var checkpoint = MyLocalCache.LoadCheckpoint(save.Item1, out dummySizeInBytes);
MySession.FixIncorrectSettings(checkpoint.Settings);
var worldSettingsScreen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.EditWorldSettingsScreen, checkpoint, save.Item1);
MyGuiSandbox.AddScreen(worldSettingsScreen);
worldSettingsScreen.Closed += (source) => { m_state = StateEnum.ListNeedsReload; };
}
}
public override void Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
switch (actionEnum)
{
case UseActionEnum.Manipulate:
if (!m_buttonPanel.IsWorking)
{
return;
}
if (!m_buttonPanel.AnyoneCanUse && !m_buttonPanel.HasLocalPlayerAccess())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
return;
}
m_buttonPanel.Toolbar.UpdateItem(m_index);
m_buttonPanel.Toolbar.ActivateItemAtIndex(m_index);
m_buttonPanel.PressButton(m_index);
break;
case UseActionEnum.OpenTerminal:
if (!m_buttonPanel.HasLocalPlayerAccess())
{
return;
}
MyToolbarComponent.CurrentToolbar = m_buttonPanel.Toolbar;
MyGuiScreenBase screen = MyGuiScreenCubeBuilder.Static;
if (screen == null)
{
screen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ToolbarConfigScreen, 0, m_buttonPanel);
}
MyToolbarComponent.AutoUpdate = false;
screen.Closed += (source) => MyToolbarComponent.AutoUpdate = true;
MyGuiSandbox.AddScreen(screen);
break;
default:
break;
}
}
public override void HandleInput(bool receivedFocusInThisUpdate)
{
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.HELP_SCREEN))
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.HelpScreen));
}
base.HandleInput(receivedFocusInThisUpdate);
if (MyInput.Static.ENABLE_DEVELOPER_KEYS)
{
if (MyInput.Static.IsNewKeyPressed(MyKeys.Multiply) && MyInput.Static.IsAnyShiftKeyPressed())
{
GC.Collect();
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.M))
{
RecreateControls(false);
}
}
}
void OnEditClick(MyGuiControlButton sender)
{
var row = m_saveBrowser.SelectedRow;
if (row == null)
{
return;
}
var save = m_saveBrowser.GetSave(row);
if (save != null)
{
ulong dummySizeInBytes;
var checkpoint = MyLocalCache.LoadCheckpoint(save.Item1, out dummySizeInBytes);
MySession.FixIncorrectSettings(checkpoint.Settings);
var worldSettingsScreen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.EditWorldSettingsScreen, checkpoint, save.Item1);
worldSettingsScreen.Closed += source => m_saveBrowser.ForceRefresh();
MyGuiSandbox.AddScreen(worldSettingsScreen);
}
}
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 void OnBattleClick(MyGuiControlButton sender)
{
if (MySteam.IsOnline)
{
if (MyFakes.ENABLE_TUTORIAL_PROMPT && MySandboxGame.Config.NeedShowBattleTutorialQuestion)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(buttonType : MyMessageBoxButtonsType.YES_NO,
messageText : MyTexts.Get(MySpaceTexts.MessageBoxTextTutorialQuestion),
messageCaption : MyTexts.Get(MyCommonTexts.MessageBoxCaptionVideoTutorial),
callback : delegate(MyGuiScreenMessageBox.ResultEnum val)
{
if (val == MyGuiScreenMessageBox.ResultEnum.YES)
{
MyGuiSandbox.OpenUrlWithFallback(MySteamConstants.URL_GUIDE_BATTLE, "Steam Guide");
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.BattleScreen));
}
}));
MySandboxGame.Config.NeedShowBattleTutorialQuestion = false;
MySandboxGame.Config.Save();
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.BattleScreen));
}
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
buttonType: MyMessageBoxButtonsType.OK,
messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionError),
messageText: MyTexts.Get(MyCommonTexts.SteamIsOfflinePleaseRestart)
));
}
}
private void OnClickInventory(MyGuiControlButton obj)
{
if (MyGameService.IsActive)
{
if (MyGameService.Service.GetInstallStatus(out var _))
{
if (MySession.Static == null)
{
MyGuiScreenLoadInventory inventory = MyGuiSandbox.CreateScreen <MyGuiScreenLoadInventory>(Array.Empty <object>());
MyGuiScreenLoading screen = new MyGuiScreenLoading(inventory, null);
MyGuiScreenLoadInventory myGuiScreenLoadInventory = inventory;
myGuiScreenLoadInventory.OnLoadingAction = (Action)Delegate.Combine(myGuiScreenLoadInventory.OnLoadingAction, (Action) delegate
{
MySessionLoader.LoadInventoryScene();
MySandboxGame.IsUpdateReady = true;
inventory.Initialize(inGame: false, null);
});
MyGuiSandbox.AddScreen(screen);
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenLoadInventory>(new object[2] {
false, null
}));
}
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(MyMessageBoxStyleEnum.Error, MyMessageBoxButtonsType.OK, messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionInfo), messageText: MyTexts.Get(MyCommonTexts.InventoryScreen_InstallInProgress)));
}
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(MyMessageBoxStyleEnum.Error, MyMessageBoxButtonsType.OK, messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionError), messageText: MyTexts.Get(MyCommonTexts.SteamIsOfflinePleaseRestart)));
}
}
public void OnTutorialClick(MyGuiControlButton sender)
{
MyAnalyticsHelper.ReportTutorialScreen("TutorialsButtonClicked");
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.TutorialScreen));
}
public void OnScenarioGameClick(MyGuiControlButton sender)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ScenarioScreen));
}
public void OnCustomGameClick(MyGuiControlButton sender)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.CustomWorldScreen));
}
private void OnClickHelp(MyGuiControlButton sender)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenHelpSpace>());
}
private void OnClickOptions(MyGuiControlButton sender)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenOptionsSpace>());
}
private void OnClickPlayers(MyGuiControlButton obj)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenPlayers>());
}
private void OnClickNewGame(MyGuiControlButton sender)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenNewGame>());
}
private void OnCustomGameClicked(MyGuiControlButton myGuiControlButton)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen <MyGuiScreenWorldSettings>());
}
static MySensorBlock()
{
m_openedToolbars = new List <MyToolbar>();
var toolbarButton = new MyTerminalControlButton <MySensorBlock>("Open Toolbar", MySpaceTexts.BlockPropertyTitle_SensorToolbarOpen, MySpaceTexts.BlockPropertyDescription_SensorToolbarOpen,
delegate(MySensorBlock self)
{
m_openedToolbars.Add(self.Toolbar);
if (MyGuiScreenCubeBuilder.Static == null)
{
m_shouldSetOtherToolbars = true;
MyToolbarComponent.CurrentToolbar = self.Toolbar;
MyGuiScreenBase screen = MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.ToolbarConfigScreen, 0, self);
MyToolbarComponent.AutoUpdate = false;
screen.Closed += (source) =>
{
MyToolbarComponent.AutoUpdate = true;
m_openedToolbars.Clear();
};
MyGuiSandbox.AddScreen(screen);
}
});
MyTerminalControlFactory.AddControl(toolbarButton);
var fieldWidthMin = new MyTerminalControlSlider <MySensorBlock>("Left", MySpaceTexts.BlockPropertyTitle_SensorFieldWidthMin, MySpaceTexts.BlockPropertyDescription_SensorFieldLeft);
fieldWidthMin.SetLimits(block => 1, block => block.MaxRange);
fieldWidthMin.DefaultValue = 5;
fieldWidthMin.Getter = (x) => - x.m_fieldMin.X;
fieldWidthMin.Setter = (x, v) =>
{
var fieldMin = x.FieldMin;
fieldMin.X = -v;
x.FieldMin = fieldMin;
(x.SyncObject as MySyncSensorBlock).SendChangeSensorMinRequest(ref fieldMin);
};
fieldWidthMin.Writer = (x, result) => result.AppendInt32((int)-x.m_fieldMin.X).Append(" m");
fieldWidthMin.EnableActions();
MyTerminalControlFactory.AddControl(fieldWidthMin);
var fieldWidthMax = new MyTerminalControlSlider <MySensorBlock>("Right", MySpaceTexts.BlockPropertyTitle_SensorFieldWidthMax, MySpaceTexts.BlockPropertyDescription_SensorFieldRight);
fieldWidthMax.SetLimits(block => 1, block => block.MaxRange);
fieldWidthMax.DefaultValue = 5;
fieldWidthMax.Getter = (x) => x.m_fieldMax.X;
fieldWidthMax.Setter = (x, v) =>
{
var fieldMax = x.FieldMax;
fieldMax.X = v;
x.FieldMax = fieldMax;
(x.SyncObject as MySyncSensorBlock).SendChangeSensorMaxRequest(ref fieldMax);
};
fieldWidthMax.Writer = (x, result) => result.AppendInt32((int)x.m_fieldMax.X).Append(" m");
fieldWidthMax.EnableActions();
MyTerminalControlFactory.AddControl(fieldWidthMax);
var fieldHeightMin = new MyTerminalControlSlider <MySensorBlock>("Bottom", MySpaceTexts.BlockPropertyTitle_SensorFieldHeightMin, MySpaceTexts.BlockPropertyDescription_SensorFieldBottom);
fieldHeightMin.SetLimits(block => 1, block => block.MaxRange);
fieldHeightMin.DefaultValue = 5;
fieldHeightMin.Getter = (x) => - x.m_fieldMin.Y;
fieldHeightMin.Setter = (x, v) =>
{
var fieldMin = x.FieldMin;
fieldMin.Y = -v;
x.FieldMin = fieldMin;
(x.SyncObject as MySyncSensorBlock).SendChangeSensorMinRequest(ref fieldMin);
};
fieldHeightMin.Writer = (x, result) => result.AppendInt32((int)-x.m_fieldMin.Y).Append(" m");
fieldHeightMin.EnableActions();
MyTerminalControlFactory.AddControl(fieldHeightMin);
var fieldHeightMax = new MyTerminalControlSlider <MySensorBlock>("Top", MySpaceTexts.BlockPropertyTitle_SensorFieldHeightMax, MySpaceTexts.BlockPropertyDescription_SensorFieldTop);
fieldHeightMax.SetLimits(block => 1, block => block.MaxRange);
fieldHeightMax.DefaultValue = 5;
fieldHeightMax.Getter = (x) => x.m_fieldMax.Y;
fieldHeightMax.Setter = (x, v) =>
{
var fieldMax = x.FieldMax;
fieldMax.Y = v;
x.FieldMax = fieldMax;
(x.SyncObject as MySyncSensorBlock).SendChangeSensorMaxRequest(ref fieldMax);
};
fieldHeightMax.Writer = (x, result) => result.AppendInt32((int)x.m_fieldMax.Y).Append(" m");
fieldHeightMax.EnableActions();
MyTerminalControlFactory.AddControl(fieldHeightMax);
var fieldDepthMax = new MyTerminalControlSlider <MySensorBlock>("Back", MySpaceTexts.BlockPropertyTitle_SensorFieldDepthMax, MySpaceTexts.BlockPropertyDescription_SensorFieldBack);
fieldDepthMax.SetLimits(block => 1, block => block.MaxRange);
fieldDepthMax.DefaultValue = 5;
fieldDepthMax.Getter = (x) => x.m_fieldMax.Z;
fieldDepthMax.Setter = (x, v) =>
{
var fieldMax = x.FieldMax;
fieldMax.Z = v;
x.FieldMax = fieldMax;
(x.SyncObject as MySyncSensorBlock).SendChangeSensorMaxRequest(ref fieldMax);
};
fieldDepthMax.Writer = (x, result) => result.AppendInt32((int)x.m_fieldMax.Z).Append(" m");
fieldDepthMax.EnableActions();
MyTerminalControlFactory.AddControl(fieldDepthMax);
var fieldDepthMin = new MyTerminalControlSlider <MySensorBlock>("Front", MySpaceTexts.BlockPropertyTitle_SensorFieldDepthMin, MySpaceTexts.BlockPropertyDescription_SensorFieldFront);
fieldDepthMin.SetLimits(block => 1, block => block.MaxRange);
fieldDepthMin.DefaultValue = 5;
fieldDepthMin.Getter = (x) => - x.m_fieldMin.Z;
fieldDepthMin.Setter = (x, v) =>
{
var fieldMin = x.FieldMin;
fieldMin.Z = -v;
x.FieldMin = fieldMin;
(x.SyncObject as MySyncSensorBlock).SendChangeSensorMinRequest(ref fieldMin);
};
fieldDepthMin.Writer = (x, result) => result.AppendInt32((int)-x.m_fieldMin.Z).Append(" m");
fieldDepthMin.EnableActions();
MyTerminalControlFactory.AddControl(fieldDepthMin);
var separatorFilters = new MyTerminalControlSeparator <MySensorBlock>();
MyTerminalControlFactory.AddControl(separatorFilters);
var detectPlayProximitySoundSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Audible Proximity Alert", MySpaceTexts.BlockPropertyTitle_SensorPlaySound, MySpaceTexts.BlockPropertyTitle_SensorPlaySound);
detectPlayProximitySoundSwitch.Getter = (x) => x.PlayProximitySound;
detectPlayProximitySoundSwitch.Setter = (x, v) =>
{
x.PlayProximitySound = v;
(x.SyncObject as MySyncSensorBlock).SendChangeSensorPlaySoundRequest(x.PlayProximitySound);
};
MyTerminalControlFactory.AddControl(detectPlayProximitySoundSwitch);
var detectPlayersSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Players", MySpaceTexts.BlockPropertyTitle_SensorDetectPlayers, MySpaceTexts.BlockPropertyTitle_SensorDetectPlayers);
detectPlayersSwitch.Getter = (x) => x.DetectPlayers;
detectPlayersSwitch.Setter = (x, v) =>
{
x.DetectPlayers = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectPlayersSwitch.EnableToggleAction(MyTerminalActionIcons.CHARACTER_TOGGLE);
detectPlayersSwitch.EnableOnOffActions(MyTerminalActionIcons.CHARACTER_ON, MyTerminalActionIcons.CHARACTER_OFF);
MyTerminalControlFactory.AddControl(detectPlayersSwitch);
var detectFloatingObjectsSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Floating Objects", MySpaceTexts.BlockPropertyTitle_SensorDetectFloatingObjects, MySpaceTexts.BlockPropertyTitle_SensorDetectFloatingObjects);
detectFloatingObjectsSwitch.Getter = (x) => x.DetectFloatingObjects;
detectFloatingObjectsSwitch.Setter = (x, v) =>
{
x.DetectFloatingObjects = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectFloatingObjectsSwitch.EnableToggleAction(MyTerminalActionIcons.MOVING_OBJECT_TOGGLE);
detectFloatingObjectsSwitch.EnableOnOffActions(MyTerminalActionIcons.MOVING_OBJECT_ON, MyTerminalActionIcons.MOVING_OBJECT_OFF);
MyTerminalControlFactory.AddControl(detectFloatingObjectsSwitch);
var detectSmallShipsSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Small Ships", MySpaceTexts.BlockPropertyTitle_SensorDetectSmallShips, MySpaceTexts.BlockPropertyTitle_SensorDetectSmallShips);
detectSmallShipsSwitch.Getter = (x) => x.DetectSmallShips;
detectSmallShipsSwitch.Setter = (x, v) =>
{
x.DetectSmallShips = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectSmallShipsSwitch.EnableToggleAction(MyTerminalActionIcons.SMALLSHIP_TOGGLE);
detectSmallShipsSwitch.EnableOnOffActions(MyTerminalActionIcons.SMALLSHIP_ON, MyTerminalActionIcons.SMALLSHIP_OFF);
MyTerminalControlFactory.AddControl(detectSmallShipsSwitch);
var detectLargeShipsSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Large Ships", MySpaceTexts.BlockPropertyTitle_SensorDetectLargeShips, MySpaceTexts.BlockPropertyTitle_SensorDetectLargeShips);
detectLargeShipsSwitch.Getter = (x) => x.DetectLargeShips;
detectLargeShipsSwitch.Setter = (x, v) =>
{
x.DetectLargeShips = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectLargeShipsSwitch.EnableToggleAction(MyTerminalActionIcons.LARGESHIP_TOGGLE);
detectLargeShipsSwitch.EnableOnOffActions(MyTerminalActionIcons.LARGESHIP_ON, MyTerminalActionIcons.LARGESHIP_OFF);
MyTerminalControlFactory.AddControl(detectLargeShipsSwitch);
var detectStationsSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Stations", MySpaceTexts.BlockPropertyTitle_SensorDetectStations, MySpaceTexts.BlockPropertyTitle_SensorDetectStations);
detectStationsSwitch.Getter = (x) => x.DetectStations;
detectStationsSwitch.Setter = (x, v) =>
{
x.DetectStations = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectStationsSwitch.EnableToggleAction(MyTerminalActionIcons.STATION_TOGGLE);
detectStationsSwitch.EnableOnOffActions(MyTerminalActionIcons.STATION_ON, MyTerminalActionIcons.STATION_OFF);
MyTerminalControlFactory.AddControl(detectStationsSwitch);
var detectAsteroidsSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Asteroids", MySpaceTexts.BlockPropertyTitle_SensorDetectAsteroids, MySpaceTexts.BlockPropertyTitle_SensorDetectAsteroids);
detectAsteroidsSwitch.Getter = (x) => x.DetectAsteroids;
detectAsteroidsSwitch.Setter = (x, v) =>
{
x.DetectAsteroids = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectAsteroidsSwitch.EnableToggleAction();
detectAsteroidsSwitch.EnableOnOffActions();
MyTerminalControlFactory.AddControl(detectAsteroidsSwitch);
var separatorFactionFilters = new MyTerminalControlSeparator <MySensorBlock>();
MyTerminalControlFactory.AddControl(separatorFactionFilters);
var detectOwnerSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Owner", MySpaceTexts.BlockPropertyTitle_SensorDetectOwner, MySpaceTexts.BlockPropertyTitle_SensorDetectOwner);
detectOwnerSwitch.Getter = (x) => x.DetectOwner;
detectOwnerSwitch.Setter = (x, v) =>
{
x.DetectOwner = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectOwnerSwitch.EnableToggleAction();
detectOwnerSwitch.EnableOnOffActions();
MyTerminalControlFactory.AddControl(detectOwnerSwitch);
var detectFriendlySwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Friendly", MySpaceTexts.BlockPropertyTitle_SensorDetectFriendly, MySpaceTexts.BlockPropertyTitle_SensorDetectFriendly);
detectFriendlySwitch.Getter = (x) => x.DetectFriendly;
detectFriendlySwitch.Setter = (x, v) =>
{
x.DetectFriendly = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectFriendlySwitch.EnableToggleAction();
detectFriendlySwitch.EnableOnOffActions();
MyTerminalControlFactory.AddControl(detectFriendlySwitch);
var detectNeutralSwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Neutral", MySpaceTexts.BlockPropertyTitle_SensorDetectNeutral, MySpaceTexts.BlockPropertyTitle_SensorDetectNeutral);
detectNeutralSwitch.Getter = (x) => x.DetectNeutral;
detectNeutralSwitch.Setter = (x, v) =>
{
x.DetectNeutral = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectNeutralSwitch.EnableToggleAction();
detectNeutralSwitch.EnableOnOffActions();
MyTerminalControlFactory.AddControl(detectNeutralSwitch);
var detectEnemySwitch = new MyTerminalControlOnOffSwitch <MySensorBlock>("Detect Enemy", MySpaceTexts.BlockPropertyTitle_SensorDetectEnemy, MySpaceTexts.BlockPropertyTitle_SensorDetectEnemy);
detectEnemySwitch.Getter = (x) => x.DetectEnemy;
detectEnemySwitch.Setter = (x, v) =>
{
x.DetectEnemy = v;
(x.SyncObject as MySyncSensorBlock).SendFiltersChangedRequest(x.Filters);
};
detectEnemySwitch.EnableToggleAction();
detectEnemySwitch.EnableOnOffActions();
MyTerminalControlFactory.AddControl(detectEnemySwitch);
}
private void OnClickHelp(MyGuiControlButton sender)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.HelpScreen));
}
