missiongameplay.c

Go to the documentation of this file.

class MissionGameplay extends MissionBase
{
 int m_LifeState;
 bool m_Initialized;
 
 protected UIManager m_UIManager;
 
 Widget m_HudRootWidget;
 ImageWidget m_MicrophoneIcon;
 
 ref InventoryMenu m_InventoryMenu;
 ref Chat m_Chat;
 ref ActionMenu m_ActionMenu;
 ref IngameHud m_Hud;
 ref HudDebug m_HudDebug;
 ref LogoutMenu m_Logout;
 ref DebugMonitor m_DebugMonitor;
 
 protected ref ScriptInvoker m_OnConnectivityChanged;
 
 protected ref GameplayEffectWidgets m_EffectWidgets;
 
 ref Timer m_ChatChannelHideTimer;
 ref WidgetFadeTimer m_ChatChannelFadeTimer;
 ref WidgetFadeTimer m_MicFadeTimer;
 
 Widget m_ChatChannelArea;
 TextWidget m_ChatChannelText;
 NoteMenu m_Note;
 
 protected ref Timer m_ToggleHudTimer;
 protected const int HOLD_LIMIT_TIME = 300; //ms
 protected int m_ActionDownTime;
 protected int m_ActionUpTime;
 protected bool m_InitOnce;
 protected bool m_ControlDisabled; //DEPRECATED; disabled mode stored below
 protected int m_ControlDisabledMode;
 protected ref array<string> m_ActiveInputExcludeGroups; //exclude groups defined in 'specific.xml' file
 protected ref array<int> m_ActiveInputRestrictions; //additional scripted restrictions
 protected bool m_ProcessInputExcludes;
 protected bool m_QuickbarHold;
 protected bool m_PlayerRespawning;
 protected int m_RespawnModeClient; //for client-side usage
 protected bool m_PauseQueued;
 
 // von control info
 protected bool m_VoNActive;
 protected Widget m_VoiceLevels;
 protected ref map<int,ImageWidget> m_VoiceLevelsWidgets;
 protected ref map<int,ref WidgetFadeTimer> m_VoiceLevelTimers;
 
 void MissionGameplay()
 {
 DestroyAllMenus();
 m_Initialized = false;
 m_EffectWidgets = new GameplayEffectWidgets;
 m_HudRootWidget = null;
 m_Chat = new Chat;
 m_ActionMenu = new ActionMenu;
 m_LifeState = -1;
 m_Hud = new IngameHud;
 m_VoNActive = false;
 m_PauseQueued = false;
 m_ChatChannelFadeTimer = new WidgetFadeTimer;
 m_MicFadeTimer = new WidgetFadeTimer;
 m_ChatChannelHideTimer = new Timer(CALL_CATEGORY_GUI);
 m_ToggleHudTimer = new Timer(CALL_CATEGORY_GUI);
 
 m_ActiveRefresherLocations = new array<vector>;
 SyncEvents.RegisterEvents();
 }
 
 void ~MissionGameplay()
 {
 DestroyInventory();
 #ifndef NO_GUI
 if (g_Game.GetUIManager() && g_Game.GetUIManager().ScreenFadeVisible())
 {
 g_Game.GetUIManager().ScreenFadeOut(0);
 }
 Continue();
 #endif
 }
 
 InventoryMenu GetInventory()
 {
 return m_InventoryMenu;
 }
 
 override void OnInit()
 {
 super.OnInit();
 
 if ( m_Initialized )
 {
 return;
 }
 
 #ifdef DIAG_DEVELOPER
 if (!GetGame().IsMultiplayer())//to make it work in single during development
 {
 CfgGameplayHandler.LoadData();
 UndergroundAreaLoader.SpawnAllTriggerCarriers();
 }
 #endif
 
 PPEffects.Init(); //DEPRECATED, left in for legacy purposes only
 MapMarkerTypes.Init();
 
 m_UIManager = GetGame().GetUIManager();
 
 m_Initialized = true;
 
 // init hud ui
 if ( !m_HudRootWidget )
 {
 m_HudRootWidget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/day_z_hud.layout");
 
 m_HudRootWidget.Show(false);
 
 m_Chat.Init(m_HudRootWidget.FindAnyWidget("ChatFrameWidget"));
 
 m_ActionMenu.Init( m_HudRootWidget.FindAnyWidget("ActionsPanel"), TextWidget.Cast( m_HudRootWidget.FindAnyWidget("DefaultActionWidget") ) );
 
 m_Hud.Init( m_HudRootWidget.FindAnyWidget("HudPanel") );
 
 // von enabled icon
 m_MicrophoneIcon = ImageWidget.Cast( m_HudRootWidget.FindAnyWidget("mic") );
 m_MicrophoneIcon.Show(false);
 
 // von voice level
 m_VoiceLevels = m_HudRootWidget.FindAnyWidget("VoiceLevelsPanel");
 m_VoiceLevelsWidgets = new map<int, ImageWidget>; // [key] voice level
 m_VoiceLevelTimers = new map<int,ref WidgetFadeTimer>; // [key] voice level
 
 if ( m_VoiceLevels )
 {
 m_VoiceLevelsWidgets.Set(VoiceLevelWhisper, ImageWidget.Cast( m_VoiceLevels.FindAnyWidget("Whisper") ));
 m_VoiceLevelsWidgets.Set(VoiceLevelTalk, ImageWidget.Cast( m_VoiceLevels.FindAnyWidget("Talk") ));
 m_VoiceLevelsWidgets.Set(VoiceLevelShout, ImageWidget.Cast( m_VoiceLevels.FindAnyWidget("Shout") ));
 
 m_VoiceLevelTimers.Set(VoiceLevelWhisper, new WidgetFadeTimer);
 m_VoiceLevelTimers.Set(VoiceLevelTalk, new WidgetFadeTimer);
 m_VoiceLevelTimers.Set(VoiceLevelShout, new WidgetFadeTimer);
 }
 
 HideVoiceLevelWidgets();
 
 // chat channel
 m_ChatChannelArea = m_HudRootWidget.FindAnyWidget("ChatChannelPanel");
 m_ChatChannelText = TextWidget.Cast( m_HudRootWidget.FindAnyWidget("ChatChannelText") );
 }
 
 // init hud ui
 #ifdef DEVELOPER 
 m_HudDebug = new HudDebug;
 
 if ( !m_HudDebug.IsInitialized() )
 {
 m_HudDebug.Init( GetGame().GetWorkspace().CreateWidgets("gui/layouts/debug/day_z_hud_debug.layout") ); 
 PluginConfigDebugProfile.GetInstance().SetLogsEnabled(LogManager.IsLogsEnable());
 } 
 #endif
 }
 
 UIManager GetUIManager()
 {
 return m_UIManager;
 }
 
 override void OnMissionStart()
 {
 g_Game.SetConnecting(false);
 
#ifndef FEATURE_CURSOR
 GetUIManager().ShowUICursor(false);
#endif
 
 g_Game.SetMissionState( DayZGame.MISSION_STATE_GAME );
 
 }
 
 void InitInventory()
 {
 if ( !m_InventoryMenu )
 {
 m_InventoryMenu = InventoryMenu.Cast( GetUIManager().CreateScriptedMenu(MENU_INVENTORY, null) );
 }
 }
 
 void TickScheduler(float timeslice)
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 
 if( player )
 player.OnScheduledTick(timeslice);
 }
 
 void SendMuteListToServer( map<string, bool> mute_list )
 {
 if( mute_list && mute_list.Count() > 0 )
 {
 ScriptRPC rpc = new ScriptRPC();
 rpc.Write(mute_list);
 rpc.Send(null, ERPCs.RPC_USER_SYNC_PERMISSIONS, true, null);
 }
 }
 
 override void UpdateInputDevicesAvailability()
 {
 super.UpdateInputDevicesAvailability();
 
 g_Game.GetInput().UpdateConnectedInputDeviceList();
 g_Game.UpdateInputDeviceDisconnectWarning();
 }
 
 override void OnMissionFinish()
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 
 //Print("OnMissionFinish");
 GetUIManager().HideDialog();
 DestroyAllMenus();
 
 m_Chat.Destroy();
 delete m_HudRootWidget;
 
 if (m_DebugMonitor)
 m_DebugMonitor.Hide();
#ifndef FEATURE_CURSOR
 g_Game.GetUIManager().ShowUICursor(false);
#endif
 PPEManagerStatic.GetPPEManager().StopAllEffects(PPERequesterCategory.ALL);
 EnableAllInputs();
 g_Game.SetMissionState( DayZGame.MISSION_STATE_FINNISH );
 }
 
 override void OnUpdate(float timeslice)
 { 
#ifdef DIAG_DEVELOPER
 UpdateInputDeviceDiag();
#endif
 
#ifdef FEATURE_CURSOR
 if (GetTimeStamp() == 0)
 {
 if (!g_Game.IsAppActive() || IsCLIParam("launchPaused"))
 {
 m_PauseQueued = true;
 }
 else
 {
 GetUIManager().ShowUICursor(false);
 }
 }
#endif
 
 if (m_PauseQueued && !IsPaused())
 {
 Pause();
 }
 
 Man player = GetGame().GetPlayer();
 PlayerBase playerPB = PlayerBase.Cast(player);
 TickScheduler(timeslice);
 UpdateDummyScheduler();//for external entities
 UIScriptedMenu menu = m_UIManager.GetMenu();
 InventoryMenu inventory = InventoryMenu.Cast( m_UIManager.FindMenu(MENU_INVENTORY) );
 NoteMenu note_menu = NoteMenu.Cast( m_UIManager.FindMenu(MENU_NOTE) );
 GesturesMenu gestures_menu = GesturesMenu.Cast(m_UIManager.FindMenu(MENU_GESTURES));
 RadialQuickbarMenu quickbar_menu = RadialQuickbarMenu.Cast(m_UIManager.FindMenu(MENU_RADIAL_QUICKBAR));
 InspectMenuNew inspect = InspectMenuNew.Cast( m_UIManager.FindMenu(MENU_INSPECT) );
 Input input = GetGame().GetInput();
 ActionBase runningAction;
 bool manualInputUnlockProcessed = false;
 
 if ( playerPB )
 {
 #ifdef DIAG_DEVELOPER
 if ( DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM) )
 {
 DbgUI.Begin("Hologram Debug", 5, 5);
 }
 #endif
 
 if ( playerPB.GetHologramLocal() )
 {
 playerPB.GetHologramLocal().UpdateHologram( timeslice );
 }
 #ifdef DIAG_DEVELOPER
 else if ( DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM) )
 { 
 DbgUI.Text("No active Hologram");
 }
 
 if ( DiagMenu.GetBool(DiagMenuIDs.MISC_HOLOGRAM) )
 { 
 DbgUI.End();
 }
 #endif
 
 runningAction = playerPB.GetActionManager().GetRunningAction();
 }
 
#ifdef PLATFORM_CONSOLE
 //'Special behaviour' for colliding VON distance input actions [CONSOLE ONLY]
 if (GetUApi().GetInputByID(UAVoiceModifierHelper).LocalValue() && !menu)
 {
 GetUApi().GetInputByID(UAUIQuickbarRadialOpen).Lock();
 GetUApi().GetInputByID(UAZoomInToggle).Lock();
 GetUApi().GetInputByID(UAPersonView).Lock();
 GetUApi().GetInputByID(UALeanLeft).Lock();
 GetUApi().GetInputByID(UALeanRight).Lock();
 }
 else if (GetUApi().GetInputByID(UAVoiceModifierHelper).LocalRelease()) //unlocks on release, if already excluded, all the other inputs should be locked/unlocked in the exclude (if defined properly!)
 {
 GetUApi().GetInputByID(UAUIQuickbarRadialOpen).Unlock();
 GetUApi().GetInputByID(UAZoomInToggle).Unlock();
 GetUApi().GetInputByID(UAPersonView).Unlock();
 GetUApi().GetInputByID(UALeanLeft).Unlock();
 GetUApi().GetInputByID(UALeanRight).Unlock();
 
 manualInputUnlockProcessed = true;
 }
 
 //Radial quickbar
 if (GetUApi().GetInputByID(UAUIQuickbarRadialOpen).LocalPress() && playerPB)
 {
 //open quickbar menu
 if ( playerPB.IsAlive() && !playerPB.IsRaised() && !playerPB.IsUnconscious() && !playerPB.GetCommand_Vehicle() ) //player hands not raised, player is not in prone and player is not interacting with vehicle
 {
 if ( !GetUIManager().IsMenuOpen( MENU_RADIAL_QUICKBAR ) )
 {
 RadialQuickbarMenu.OpenMenu();
 m_Hud.ShowHudUI( false );
 } 
 }
 }
 
 bool b1 = RadialQuickbarMenu.GetItemToAssign() != null;
 //close quickbar menu from world
 if (GetUIManager().IsMenuOpen( MENU_RADIAL_QUICKBAR ) && (!RadialQuickbarMenu.GetMenuInstance().GetParentMenu() || RadialQuickbarMenu.GetMenuInstance().GetParentMenu() != inventory) && (GetUApi().GetInputByID(UAUIQuickbarRadialOpen).LocalRelease() || !GetUApi().GetInputByID(UAUIQuickbarRadialOpen).LocalValue()))
 {
 RadialQuickbarMenu.CloseMenu();
 m_Hud.ShowHudUI( true );
 }
 
 //Radial Quickbar from inventory
 if ((RadialQuickbarMenu.instance && RadialQuickbarMenu.GetMenuInstance().GetParentMenu() && RadialQuickbarMenu.GetMenuInstance().GetParentMenu() == inventory) && GetUApi().GetInputByID(UAUIQuickbarRadialInventoryOpen).LocalRelease())
 {
 //close radial quickbar menu
 if (GetGame().GetUIManager().IsMenuOpen(MENU_RADIAL_QUICKBAR))
 {
 RadialQuickbarMenu.CloseMenu();
 RadialQuickbarMenu.SetItemToAssign( NULL );
 AddActiveInputExcludes({"inventory"});
 AddActiveInputRestriction(EInputRestrictors.INVENTORY);
 }
 }
 
 if (playerPB)
 {
 //Special behaviour for leaning [CONSOLE ONLY]
 if (playerPB.IsRaised() || playerPB.IsInRasedProne())
 {
 GetUApi().GetInputByID(UALeanLeftGamepad).Unlock();
 GetUApi().GetInputByID(UALeanRightGamepad).Unlock();
 
 manualInputUnlockProcessed = true;
 }
 else if (!GetUApi().GetInputByID(UALeanLeftGamepad).IsLocked() || !GetUApi().GetInputByID(UALeanRightGamepad).IsLocked())
 {
 GetUApi().GetInputByID(UALeanLeftGamepad).Lock();
 GetUApi().GetInputByID(UALeanRightGamepad).Lock();
 }
 
 //Special behaviour for freelook & zeroing [CONSOLE ONLY]
 if (playerPB.IsRaised())
 {
 GetUApi().GetInputByID(UALookAround).Lock(); //disable freelook
 GetUApi().GetInputByID(UALookAroundToggle).Lock(); //disable freelook
 
 GetUApi().GetInputByID(UAZeroingUp).Unlock(); //enable zeroing
 GetUApi().GetInputByID(UAZeroingDown).Unlock();
 
 manualInputUnlockProcessed = true;
 }
 else if (GetUApi().GetInputByID(UALookAround).IsLocked() || GetUApi().GetInputByID(UALookAroundToggle).IsLocked())
 {
 GetUApi().GetInputByID(UALookAround).Unlock(); //enable freelook
 GetUApi().GetInputByID(UALookAroundToggle).Unlock(); //enable freelook
 
 GetUApi().GetInputByID(UAZeroingUp).Lock(); //disable zeroing
 GetUApi().GetInputByID(UAZeroingDown).Lock();
 
 manualInputUnlockProcessed = true;
 }
 }
#endif
 
 if (manualInputUnlockProcessed)
 {
 RefreshExcludes();
 }
 
 //Gestures
 if ( GetUApi().GetInputByID(UAUIGesturesOpen).LocalPress() && playerPB)
 {
 //open gestures menu
 if ( !playerPB.IsRaised() && (playerPB.GetActionManager().ActionPossibilityCheck(playerPB.m_MovementState.m_CommandTypeId) || playerPB.IsEmotePlaying()) && !playerPB.GetCommand_Vehicle() )
 {
 if ( !GetUIManager().IsMenuOpen( MENU_GESTURES ) )
 {
 GesturesMenu.OpenMenu();
 m_Hud.ShowHudUI( false );
 }
 }
 }
 
 if ( GetUApi().GetInputByID(UAUIGesturesOpen).LocalRelease() || GetUApi().GetInputByID(UAUIGesturesOpen).LocalValue() == 0 )
 {
 //close gestures menu
 if ( GetUIManager().IsMenuOpen( MENU_GESTURES ) )
 {
 GesturesMenu.CloseMenu();
 m_Hud.ShowHudUI( true );
 }
 }
 
 if (player && m_LifeState == EPlayerStates.ALIVE && !player.IsUnconscious() )
 {
 // enables HUD on spawn
 if (m_HudRootWidget)
 {
 m_HudRootWidget.Show(true);
 }
 
 #ifndef NO_GUI
 // fade out black screen
 
 if ( GetUIManager().ScreenFadeVisible() )
 {
 GetUIManager().ScreenFadeOut(0.5);
 }
 
 #endif
 
 if (GetUApi().GetInputByID(UAGear).LocalPress())
 {
 if (!inventory && playerPB.CanManipulateInventory() && IsMapUnfoldActionRunning(runningAction))
 {
 ShowInventory();
 menu = m_InventoryMenu;
 }
 else if (menu == inventory)
 {
 HideInventory();
 }
 }
 
 if (GetUApi().GetInputByID(UAUIMenu).LocalPress() && menu && inventory && menu == inventory)
 {
 HideInventory();
 }
 
 #ifndef PLATFORM_CONSOLE
 if (GetUApi().GetInputByID(UAChat).LocalPress() && input.IsEnabledMouseAndKeyboardEvenOnServer())
 {
 ChatInputMenu chat = ChatInputMenu.Cast( m_UIManager.FindMenu(MENU_CHAT) ); 
 if ( menu == NULL )
 {
 ShowChat();
 }
 }
 #endif
 
 // voice level updated
 VONManager.GetInstance().HandleInput(input);
 
 if (GetUApi().GetInputByID(UAUIQuickbarToggle).LocalHold())
 {
 if (!m_QuickbarHold)
 {
 m_QuickbarHold = true;
 m_Hud.ShowHudPlayer(m_Hud.IsHideHudPlayer());
 }
 }
 
 if (GetUApi().GetInputByID(UAUIQuickbarToggle).LocalRelease())
 {
 if (!m_QuickbarHold)
 {
 m_Hud.ShowQuickbarPlayer(m_Hud.IsHideQuickbarPlayer());
 }
 m_QuickbarHold = false;
 }
 
 if (GetUApi().GetInputByID(UAZeroingUp).LocalPress() || GetUApi().GetInputByID(UAZeroingDown).LocalPress() || GetUApi().GetInputByID(UAToggleWeapons).LocalPress())
 {
 m_Hud.ZeroingKeyPress();
 }
 
 if (menu == NULL)
 {
 m_ActionMenu.Refresh();
 
 if (GetUApi().GetInputByID(UANextActionCategory).LocalPress())
 {
 m_ActionMenu.NextActionCategory();
 }
 else if (GetUApi().GetInputByID(UAPrevActionCategory).LocalPress())
 {
 m_ActionMenu.PrevActionCategory();
 } 
 else if (GetUApi().GetInputByID(UANextAction).LocalPress())
 {
 m_ActionMenu.NextAction();
 }
 else if (GetUApi().GetInputByID(UAPrevAction).LocalPress())
 {
 m_ActionMenu.PrevAction();
 }
 }
 else
 {
 m_ActionMenu.Hide();
 }
 
 //hologram rotation
 if (menu == NULL && playerPB.IsPlacingLocal() && playerPB.GetHologramLocal().GetParentEntity().PlacementCanBeRotated())
 {
 if (GetUApi().GetInputByID(UANextAction).LocalRelease())
 {
 playerPB.GetHologramLocal().SubtractProjectionRotation(15);
 }
 
 if (GetUApi().GetInputByID(UAPrevAction).LocalRelease())
 {
 playerPB.GetHologramLocal().AddProjectionRotation(15);
 }
 }
 
 if (CfgGameplayHandler.GetMapIgnoreMapOwnership() && !CfgGameplayHandler.GetUse3DMap())
 {
 if (GetUApi().GetInputByID(UAMapToggle).LocalPress() && !m_UIManager.GetMenu())
 {
 if (IsMapUnfoldActionRunning(runningAction))
 {
 HandleMapToggleByKeyboardShortcut(player);
 }
 }
 }
 }
 
 // life state check
 if (player)
 {
 int life_state = player.GetPlayerState();
 
 // life state changed
 if (m_LifeState != life_state)
 {
 m_LifeState = life_state;
 
 if (m_LifeState != EPlayerStates.ALIVE && !player.IsUnconscious())
 {
 CloseAllMenus();
 }
 }
 }
 
 if (menu && !menu.UseKeyboard() && menu.UseMouse())
 {
 int i;
 for (i = 0; i < 5; i++)
 {
 input.DisableKey(i | INPUT_DEVICE_MOUSE);
 input.DisableKey(i | INPUT_ACTION_TYPE_DOWN_EVENT | INPUT_DEVICE_MOUSE);
 input.DisableKey(i | INPUT_ACTION_TYPE_DOUBLETAP | INPUT_DEVICE_MOUSE);
 }
 
 for (i = 0; i < 6; i++)
 {
 input.DisableKey(i | INPUT_DEVICE_MOUSE_AXIS);
 }
 }
 
 if (!m_UIManager.IsDialogVisible())
 {
 if (menu)
 {
 if (menu == inspect)
 {
 if (GetUApi().GetInputByID(UAGear).LocalPress())
 {
 if (ItemManager.GetInstance().GetSelectedItem() == NULL)
 {
 HideInventory();
 }
 }
 else if (GetUApi().GetInputByID(UAUIBack).LocalPress())
 {
 if (ItemManager.GetInstance().GetSelectedItem() == NULL)
 {
 HideInventory();
 }
 }
 }
 else if (menu == note_menu && (!IsInputExcludeActive("inventory") || !IsInputRestrictionActive(EInputRestrictors.INVENTORY)))
 {
 AddActiveInputExcludes({"inventory"});
 AddActiveInputRestriction(EInputRestrictors.INVENTORY);
 }
 else if (menu == gestures_menu && !gestures_menu.IsMenuClosing() && !IsInputExcludeActive("radialmenu"))
 {
 AddActiveInputExcludes({"radialmenu"});
 GetUApi().GetInputByID(UAUIGesturesOpen).Unlock();
 }
 else if (menu == quickbar_menu && !quickbar_menu.IsMenuClosing() && !IsInputExcludeActive("radialmenu"))
 {
 AddActiveInputExcludes({"radialmenu"});
 GetUApi().GetInputByID(UAUIQuickbarRadialOpen).Unlock();
 }
 else if (IsPaused())
 {
 InGameMenuXbox menu_xb = InGameMenuXbox.Cast(GetGame().GetUIManager().GetMenu());
 if (!g_Game.GetUIManager().ScreenFadeVisible() && (!menu_xb || !menu_xb.IsOnlineOpen()))
 {
 if (GetUApi().GetInputByID(UAUIMenu).LocalPress())
 {
 Continue();
 }
 else if (GetUApi().GetInputByID(UAUIBack).LocalPress())
 {
 Continue();
 }
 }
 else if (GetUApi().GetInputByID(UAUIBack).LocalPress())
 {
 if (menu_xb && menu_xb.IsOnlineOpen())
 {
 menu_xb.CloseOnline();
 }
 }
 }
 }
 else if (GetUApi().GetInputByID(UAUIMenu).LocalPress())
 {
 if (IsMapUnfoldActionRunning(runningAction))
 {
 Pause();
 }
 }
 }
 
 UpdateDebugMonitor();
 
 SEffectManager.Event_OnFrameUpdate(timeslice);
 
 if (!GetGame().IsMultiplayer())
 m_WorldData.UpdateBaseEnvTemperature( timeslice );
 
#ifdef DIAG_DEVELOPER
 DisplayHairDebug();
#endif
 if (m_ProcessInputExcludes)
 {
 PerformRefreshExcludes();
 m_ProcessInputExcludes = false;
 }
 
 super.OnUpdate( timeslice );
 }
 
 override void OnKeyPress(int key)
 {
 super.OnKeyPress(key);
 m_Hud.KeyPress(key);
 }
 
 override void OnKeyRelease(int key)
 {
 super.OnKeyRelease(key);
 }
 
 override void OnEvent(EventType eventTypeId, Param params)
 {
 super.OnEvent(eventTypeId, params);
 InventoryMenu menu;
 Man player = GetGame().GetPlayer();
 
 switch (eventTypeId)
 {
 case ChatMessageEventTypeID:
 ChatMessageEventParams chat_params = ChatMessageEventParams.Cast( params ); 
 if (m_LifeState == EPlayerStates.ALIVE)
 {
 m_Chat.Add(chat_params);
 }
 break;
 
 case ChatChannelEventTypeID:
 ChatChannelEventParams cc_params = ChatChannelEventParams.Cast( params );
 ChatInputMenu chatMenu = ChatInputMenu.Cast( GetUIManager().FindMenu(MENU_CHAT_INPUT) );
 if (chatMenu)
 {
 chatMenu.UpdateChannel();
 }
 else
 {
 m_ChatChannelText.SetText(ChatInputMenu.GetChannelName(cc_params.param1));
 m_ChatChannelFadeTimer.FadeIn(m_ChatChannelArea, 0.5, true);
 m_ChatChannelHideTimer.Run(2, m_ChatChannelFadeTimer, "FadeOut", new Param3<Widget, float, bool>(m_ChatChannelArea, 0.5, true));
 }
 break;
 
 case WindowsResizeEventTypeID:
 DestroyAllMenus();
 m_Hud.OnResizeScreen();
 
 break;
 
 case SetFreeCameraEventTypeID:
 SetFreeCameraEventParams set_free_camera_event_params = SetFreeCameraEventParams.Cast( params );
 PluginDeveloper plugin_developer = PluginDeveloper.Cast( GetPlugin(PluginDeveloper) );
 plugin_developer.OnSetFreeCameraEvent( PlayerBase.Cast( player ), set_free_camera_event_params.param1 );
 break;
 }
 }
 
 override void OnItemUsed(InventoryItem item, Man owner)
 {
 if (item && GetUIManager().GetMenu() == NULL)
 {
 if (item.IsInherited(ItemBook))
 {
 BookMenu bookMenu = BookMenu.Cast( GetUIManager().EnterScriptedMenu(MENU_BOOK, NULL) );
 if (bookMenu)
 {
 bookMenu.ReadBook(item);
 }
 }
 }
 }
 
#ifdef DEVELOPER
 override void SetInputSuppression(bool state)
 {
 m_SuppressNextFrame = state;
 }
 
 override bool GetInputSuppression()
 {
 return m_SuppressNextFrame;
 }
#endif
 
 override void PlayerControlEnable( bool bForceSupress )
 {
 super.PlayerControlEnable(bForceSupress);
 
 if (m_ControlDisabledMode != -1)
 {
 switch (m_ControlDisabledMode)
 {
 case INPUT_EXCLUDE_ALL:
 {
 RemoveActiveInputExcludes({"menu"},bForceSupress);
 break;
 }
 case INPUT_EXCLUDE_INVENTORY:
 {
 RemoveActiveInputExcludes({"inventory"},bForceSupress);
 RemoveActiveInputRestriction(EInputRestrictors.INVENTORY);
 break;
 }
 case INPUT_EXCLUDE_MAP:
 {
 RemoveActiveInputExcludes({"loopedactions"},bForceSupress);
 RemoveActiveInputRestriction(EInputRestrictors.MAP);
 break;
 }
 case INPUT_EXCLUDE_MOUSE_ALL:
 {
 RemoveActiveInputExcludes({"radialmenu"},bForceSupress);
 break;
 }
 case INPUT_EXCLUDE_MOUSE_RADIAL:
 {
 RemoveActiveInputExcludes({"radialmenu"},bForceSupress);
 break;
 }
 }
 
 m_ControlDisabledMode = -1;
 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if (player)
 {
 HumanInputController hic = player.GetInputController();
 hic.LimitsDisableSprint(false);
 }
 }
 }
 
 override void PlayerControlDisable(int mode)
 {
 super.PlayerControlDisable(mode);
 
 switch (mode)
 {
 case INPUT_EXCLUDE_ALL:
 {
 AddActiveInputExcludes({"menu"});
 break;
 }
 case INPUT_EXCLUDE_INVENTORY:
 {
 AddActiveInputExcludes({"inventory"});
 AddActiveInputRestriction(EInputRestrictors.INVENTORY);
 break;
 }
 case INPUT_EXCLUDE_MAP:
 {
 AddActiveInputExcludes({"loopedactions"});
 AddActiveInputRestriction(EInputRestrictors.MAP);
 break;
 }
 case INPUT_EXCLUDE_MOUSE_ALL:
 {
 AddActiveInputExcludes({"radialmenu"});
 break;
 }
 case INPUT_EXCLUDE_MOUSE_RADIAL:
 {
 AddActiveInputExcludes({"radialmenu"});
 break;
 }
 default:
 {
 Debug.Log("Unknown controls disable mode");
 return;
 }
 }
 
 m_ControlDisabledMode = mode;
 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if ( player )
 {
 ItemBase item = player.GetItemInHands();
 if (item && item.IsWeapon())
 player.RequestResetADSSync();
 }
 }
 
 override void RemoveActiveInputExcludes(array<string> excludes, bool bForceSupress = false)
 {
 super.RemoveActiveInputExcludes(excludes,bForceSupress);
 
 if (excludes.Count() != 0)
 {
 bool changed = false;
 
 if (m_ActiveInputExcludeGroups)
 {
 for (int i = 0; i < excludes.Count(); i++)
 {
 if (m_ActiveInputExcludeGroups.Find(excludes[i]) != -1)
 {
 m_ActiveInputExcludeGroups.RemoveItem(excludes[i]);
 changed = true;
 }
 }
 
 if (changed)
 {
 RefreshExcludes();
 }
 }
 
 // supress control for next frame
 GetUApi().SupressNextFrame(bForceSupress);
 }
 }
 
 override void RemoveActiveInputRestriction(int restrictor)
 {
 //unique behaviour outside regular excludes
 if (restrictor > -1)
 {
 switch (restrictor)
 {
 case EInputRestrictors.INVENTORY:
 {
 GetUApi().GetInputByID(UAWalkRunForced).ForceEnable(false); // force walk off!
 break;
 }
 case EInputRestrictors.MAP:
 {
 GetUApi().GetInputByID(UAWalkRunForced).ForceEnable(false); // force walk off!
 break;
 }
 }
 
 if (m_ActiveInputRestrictions && m_ActiveInputRestrictions.Find(restrictor) != -1)
 {
 m_ActiveInputRestrictions.RemoveItem(restrictor);
 }
 }
 }
 
 override void AddActiveInputExcludes(array<string> excludes)
 {
 super.AddActiveInputExcludes(excludes);
 
 if (excludes.Count() != 0)
 {
 bool changed = false;
 if (!m_ActiveInputExcludeGroups)
 {
 m_ActiveInputExcludeGroups = new array<string>;
 }
 
 for (int i = 0; i < excludes.Count(); i++)
 {
 if (m_ActiveInputExcludeGroups.Find(excludes[i]) == -1)
 {
 m_ActiveInputExcludeGroups.Insert(excludes[i]);
 changed = true;
 }
 }
 
 if (changed)
 {
 RefreshExcludes();
 #ifdef BULDOZER
 GetUApi().SupressNextFrame(true);
 #endif
 }
 }
 }
 
 override void AddActiveInputRestriction(int restrictor)
 {
 //unique behaviour outside regular excludes
 if (restrictor > -1)
 {
 switch (restrictor)
 {
 case EInputRestrictors.INVENTORY:
 {
 GetUApi().GetInputByID(UAWalkRunForced).ForceEnable(true); // force walk on!
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if ( player )
 {
 ItemBase item = player.GetItemInHands();
 if (item && item.IsWeapon())
 player.RequestResetADSSync();
 }
 break;
 }
 case EInputRestrictors.MAP:
 {
 GetUApi().GetInputByID(UAWalkRunForced).ForceEnable(true); // force walk on!
 break;
 }
 }
 
 if (!m_ActiveInputRestrictions)
 {
 m_ActiveInputRestrictions = new array<int>;
 }
 if (m_ActiveInputRestrictions.Find(restrictor) == -1)
 {
 m_ActiveInputRestrictions.Insert(restrictor);
 }
 }
 }
 
 override void RefreshExcludes()
 {
 m_ProcessInputExcludes = true;
 }
 
 protected void PerformRefreshExcludes()
 {
 if (m_ActiveInputExcludeGroups)
 {
 for (int i = 0; i < m_ActiveInputExcludeGroups.Count(); i++)
 {
 GetUApi().ActivateExclude(m_ActiveInputExcludeGroups[i]);
 }
 }
 
 GetUApi().UpdateControls();
 }
 
 override void EnableAllInputs(bool bForceSupress = false)
 {
 m_ControlDisabledMode = -1;
 
 if (m_ActiveInputRestrictions)
 {
 int count = m_ActiveInputRestrictions.Count();
 for (int i = 0; i < count; i++)
 {
 RemoveActiveInputRestriction(m_ActiveInputRestrictions[0]);
 }
 m_ActiveInputRestrictions.Clear(); //redundant?
 }
 if (m_ActiveInputExcludeGroups)
 {
 m_ActiveInputExcludeGroups.Clear();
 }
 
 GetUApi().UpdateControls(); //it is meant to happen instantly, does not wait for update to process
 GetUApi().SupressNextFrame(bForceSupress); // supress control for next frame
 }
 
 override bool IsControlDisabled()
 {
 bool active = false;
 if (m_ActiveInputExcludeGroups)
 {
 active |= m_ActiveInputExcludeGroups.Count() > 0;
 }
 if (m_ActiveInputRestrictions)
 {
 active |= m_ActiveInputRestrictions.Count() > 0;
 }
 active |= m_ControlDisabledMode >= INPUT_EXCLUDE_ALL; //legacy stuff, Justin case
 return active;
 }
 
 override bool IsInputExcludeActive(string exclude)
 {
 return m_ActiveInputExcludeGroups && m_ActiveInputExcludeGroups.Find(exclude) != -1;
 }
 
 override bool IsInputRestrictionActive(int restriction)
 {
 return m_ActiveInputRestrictions && m_ActiveInputRestrictions.Find(restriction) != -1;
 }
 
 override int GetControlDisabledMode()
 {
 return m_ControlDisabledMode;
 }
 
 void CloseAllMenus()
 {
 GetUIManager().CloseAll();
 }
 
 
 void DestroyAllMenus()
 {
 if( GetUIManager() )
 {
 GetUIManager().HideDialog();
 GetUIManager().CloseAll();
 }
 
 DestroyInventory();
 
 if( m_Chat )
 m_Chat.Clear();
 }
 
 void MoveHudForInventory( bool inv_open )
 {
 #ifdef PLATFORM_CONSOLE
 IngameHud hud = IngameHud.Cast( GetHud() );
 if( hud )
 {
 if( inv_open )
 {
 hud.GetHudPanelWidget().SetPos( 0, -0.055 );
 }
 else
 {
 hud.GetHudPanelWidget().SetPos( 0, 0 );
 }
 }
 #endif
 }
 
 override void ShowInventory()
 {
 UIScriptedMenu menu = GetUIManager().GetMenu();
 
 if ( !menu && GetGame().GetPlayer().GetHumanInventory().CanOpenInventory() && !GetGame().GetPlayer().IsInventorySoftLocked() )
 {
 if( !m_InventoryMenu )
 {
 InitInventory();
 }
 
 if( !GetUIManager().FindMenu( MENU_INVENTORY ) )
 {
 GetUIManager().ShowScriptedMenu(m_InventoryMenu, null);
 PlayerBase.Cast(GetGame().GetPlayer()).OnInventoryMenuOpen();
 }
 AddActiveInputExcludes({"inventory"});
 AddActiveInputRestriction(EInputRestrictors.INVENTORY);
 }
 }
 
 override void HideInventory()
 {
 if ( m_InventoryMenu )
 {
 GetUIManager().HideScriptedMenu(m_InventoryMenu);
 RemoveActiveInputExcludes({"inventory"},false);
 RemoveActiveInputRestriction(EInputRestrictors.INVENTORY);
 PlayerBase.Cast(GetGame().GetPlayer()).OnInventoryMenuClose();
 VicinityItemManager.GetInstance().ResetRefreshCounter();
 }
 }
 
 void DestroyInventory()
 {
 if ( m_InventoryMenu )
 {
 if (!m_InventoryMenu.GetParentMenu() && GetUIManager().GetMenu() != m_InventoryMenu)
 {
 m_InventoryMenu.SetParentMenu(GetUIManager().GetMenu()); //hack; guarantees the 'm_pCurrentMenu' will be set to whatever is on top currently
 }
 m_InventoryMenu.Close();
 m_InventoryMenu = NULL;
 }
 }
 
 override void ResetGUI()
 {
 DestroyInventory();
 InitInventory();
 }
 
 override void ShowChat()
 {
 m_ChatChannelHideTimer.Stop();
 m_ChatChannelFadeTimer.Stop();
 m_ChatChannelArea.Show(false);
 m_UIManager.EnterScriptedMenu(MENU_CHAT_INPUT, NULL);
 
 int level = GetGame().GetVoiceLevel();
 UpdateVoiceLevelWidgets(level);
 
 AddActiveInputExcludes({"menu"});
 }
 
 override void HideChat()
 {
 RemoveActiveInputExcludes({"menu"},true);
 }
 
 void ShowVehicleInfo()
 {
 if ( GetHud() )
 GetHud().ShowVehicleInfo();
 }
 
 void HideVehicleInfo()
 {
 if ( GetHud() )
 GetHud().HideVehicleInfo();
 }
 
 override Hud GetHud()
 {
 return m_Hud;
 }
 
 HudDebug GetHudDebug()
 {
 return m_HudDebug;
 }
 
 override void RefreshCrosshairVisibility()
 {
 if (GetHudDebug())
 GetHudDebug().RefreshCrosshairVisibility();
 }
 
 override void HideCrosshairVisibility()
 {
 if (GetHudDebug())
 GetHudDebug().HideCrosshairVisibility();
 }
 
 override bool IsPaused()
 {
 return GetGame().GetUIManager().IsMenuOpen(MENU_INGAME);
 }
 
 override void Pause()
 {
 if (IsPaused() || (GetGame().GetUIManager().GetMenu() && GetGame().GetUIManager().GetMenu().GetID() == MENU_INGAME))
 {
 return;
 }
 
 m_PauseQueued = true;
 
 if ( g_Game.IsClient() && g_Game.GetGameState() != DayZGameState.IN_GAME )
 {
 return;
 }
 
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 if ( player && !player.IsPlayerLoaded() || IsPlayerRespawning() )
 {
 return;
 }
 
 CloseAllMenus();
 
 // open ingame menu
 UIScriptedMenu menu = GetUIManager().EnterScriptedMenu( MENU_INGAME, GetGame().GetUIManager().GetMenu() );
 if (!menu || !menu.IsVisible())
 {
 return;
 }
 
 AddActiveInputExcludes({"menu"});
 AddActiveInputRestriction(EInputRestrictors.INVENTORY);
 
 m_PauseQueued = false;
 }
 
 override void Continue()
 {
 UIScriptedMenu menu = GetGame().GetUIManager().GetMenu();
 if (!menu)
 return;
 
 int menu_id = menu.GetID();
 if ( !IsPaused() || ( menu_id != MENU_INGAME && menu_id != MENU_LOGOUT && menu_id != MENU_RESPAWN_DIALOGUE ) || ( m_Logout && m_Logout.layoutRoot.IsVisible() ) )
 {
 return;
 }
 
 RemoveActiveInputExcludes({"menu"},true);
 RemoveActiveInputRestriction(EInputRestrictors.INVENTORY);
 GetUIManager().CloseMenu(MENU_INGAME);
 }
 
 override bool IsMissionGameplay()
 {
 return true;
 }
 
 override void AbortMission()
 {
 #ifdef BULDOZER
 GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(g_Game.RequestExit, IDC_MAIN_QUIT);
 #else
 GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(GetGame().AbortMission);
 #endif
 }
 
 override void CreateLogoutMenu(UIMenuPanel parent)
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 
 // do not show logout screen if player's dead
 if (!player || player.IsDamageDestroyed())
 {
 // exit the game immediately
 AbortMission();
 return;
 }
 
 if (parent)
 {
 m_Logout = LogoutMenu.Cast(parent.EnterScriptedMenu(MENU_LOGOUT));
 
 if (m_Logout)
 {
 m_Logout.SetLogoutTime();
 }
 } 
 }
 
 override void StartLogoutMenu(int time)
 {
 if (m_Logout)
 {
 if (time > 0)
 {
 // character will be deleted from server int "time" seconds
 m_Logout.SetTime(time);
 m_Logout.Show();
 
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(m_Logout.UpdateTime, 1000, true);
 }
 else
 {
 // no waiting time -> player is most likely dead
 m_Logout.Exit();
 }
 }
 }
 
 override void CreateDebugMonitor()
 {
 if (!m_DebugMonitor)
 {
 m_DebugMonitor = new DebugMonitor();
 m_DebugMonitor.Init();
 }
 else
 m_DebugMonitor.Show();
 
 }
 override void HideDebugMonitor()
 {
 if (m_DebugMonitor)
 {
 m_DebugMonitor.Hide();
 }
 }
 
 protected void HandleMapToggleByKeyboardShortcut(Man player)
 {
 UIManager um = GetGame().GetUIManager();
 if (um && !um.IsMenuOpen(MENU_MAP))
 {
 um.CloseAll();
 if (!CfgGameplayHandler.GetUse3DMap())
 {
 um.EnterScriptedMenu(MENU_MAP, null);
 GetGame().GetMission().AddActiveInputExcludes({"map"});
 GetGame().GetMission().AddActiveInputRestriction(EInputRestrictors.MAP);
 }
 }
 }
 
 protected bool IsMapUnfoldActionRunning(ActionBase pAction)
 {
 return !pAction || pAction.Type() != ActionUnfoldMap;
 }
 
 /*void ChangeBleedingIndicatorVisibility(bool visible)
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if (player)
 {
 BleedingSourcesManagerRemote manager = player.GetBleedingManagerRemote();
 if (manager && manager.GetBleedingSourcesCount() > 0)
 {
 manager.ChangeBleedingIndicatorVisibility(visible);
 }
 }
 }*/
 
 void UpdateDebugMonitor()
 {
 if (!m_DebugMonitor) return;
 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if (player)
 {
 DebugMonitorValues values = player.GetDebugMonitorValues();
 if (values)
 {
 m_DebugMonitor.SetHealth(values.GetHealth());
 m_DebugMonitor.SetBlood(values.GetBlood());
 m_DebugMonitor.SetLastDamage(values.GetLastDamage());
 m_DebugMonitor.SetPosition(MiscGameplayFunctions.TruncateVec(player.GetPosition(),1));
 }
 }
 }
 
 void SetActionDownTime( int time_down )
 {
 m_ActionDownTime = time_down;
 }
 
 void SetActionUpTime( int time_up )
 {
 m_ActionUpTime = time_up;
 }
 
 int LocalPressTime()
 {
 return m_ActionDownTime;
 }
 
 int LocalReleaseTime()
 {
 return m_ActionUpTime;
 }
 
 float GetHoldActionTime()
 {
 float hold_action_time = LocalReleaseTime() - LocalPressTime();
 return hold_action_time;
 }
 
 void DisplayHairDebug()
 {
#ifndef SERVER
 ShowHairDebugValues(DiagMenu.GetBool(DiagMenuIDs.MISC_HAIR_DISPLAY_DEBUG));
#endif
 }
 
 void ShowHairDebugValues(bool state)
 {
#ifdef DIAG_DEVELOPER
 if ( state )
 {
 PluginDiagMenuClient diagmenu = PluginDiagMenuClient.Cast(GetPlugin(PluginDiagMenuClient));
 
 int i = DiagMenu.GetValue(DiagMenuIDs.MISC_HAIR_LEVEL);
 bool bState = diagmenu.m_HairHidingStateMap.Get(i);
 string selectionState;
 if (!bState)
 selectionState = "Hidden";
 else
 selectionState = "Shown";
 string selectionName = diagmenu.m_HairSelectionArray.Get(i);
 
 DbgUI.BeginCleanupScope();
 DbgUI.Begin("Hair Debug", 50, 150);
 DbgUI.Text("Current Hair Selection:" + selectionName);
 DbgUI.Text("State: " + selectionState);
 
 DbgUI.End();
 DbgUI.EndCleanupScope();
 }
 else
 {
 DbgUI.BeginCleanupScope();
 DbgUI.Begin("Hair Debug", 50, 50);
 DbgUI.End();
 DbgUI.EndCleanupScope();
 }
#endif
 }
 
 override void UpdateVoiceLevelWidgets(int level)
 {
 for ( int n = 0; n < m_VoiceLevelsWidgets.Count(); n++ )
 {
 int voiceKey = m_VoiceLevelsWidgets.GetKey(n);
 ImageWidget voiceWidget = m_VoiceLevelsWidgets.Get(n);
 
 // stop fade timer since it will be refreshed
 WidgetFadeTimer timer = m_VoiceLevelTimers.Get(n); 
 timer.Stop();
 
 // show widgets according to the level
 if ( voiceKey <= level )
 {
 voiceWidget.SetAlpha(1.0); // reset from possible previous fade out 
 voiceWidget.Show(true);
 
 if ( !m_VoNActive && !GetUIManager().FindMenu(MENU_CHAT_INPUT) ) 
 timer.FadeOut(voiceWidget, 3.0); 
 }
 else
 voiceWidget.Show(false);
 }
 
 // fade out microphone icon when switching levels without von on
 if ( !m_VoNActive )
 {
 if ( !GetUIManager().FindMenu(MENU_CHAT_INPUT) )
 {
 m_MicrophoneIcon.SetAlpha(1.0); 
 m_MicrophoneIcon.Show(true);
 
 m_MicFadeTimer.FadeOut(m_MicrophoneIcon, 3.0);
 }
 }
 else
 {
 // stop mic icon fade timer when von is activated
 m_MicFadeTimer.Stop();
 }
 }
 
 override ImageWidget GetMicrophoneIcon() 
 {
 return m_MicrophoneIcon;
 }
 
 override WidgetFadeTimer GetMicWidgetFadeTimer()
 {
 return m_MicFadeTimer;
 }
 
 override map<int,ImageWidget> GetVoiceLevelWidgets()
 {
 return m_VoiceLevelsWidgets;
 }
 
 override map<int,ref WidgetFadeTimer> GetVoiceLevelTimers()
 {
 return m_VoiceLevelTimers;
 }
 
 override bool IsVoNActive()
 {
 return m_VoNActive;
 }
 
 override void SetVoNActive(bool active)
 {
 m_VoNActive = active;
 }
 
 override void HideVoiceLevelWidgets()
 {
 for ( int n = 0; n < m_VoiceLevelsWidgets.Count(); n++ )
 {
 ImageWidget voiceWidget = m_VoiceLevelsWidgets.Get( n );
 voiceWidget.Show(false);
 }
 }
 
 override UIScriptedMenu GetNoteMenu()
 {
 return m_Note;
 };
 
 override void SetNoteMenu(UIScriptedMenu menu)
 {
 m_Note = NoteMenu.Cast(menu);
 };
 
 override void OnPlayerRespawned(Man player)
 {
 #ifdef DIAG_DEVELOPER
 if (m_HudDebug)
 m_HudDebug.RefreshByLocalProfile();
 #endif
 
 PlayerBase playerBase = PlayerBase.Cast(player);
 if (playerBase)
 {
 GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(playerBase.ShowDeadScreen, false, 0);
 }
 
 GetGame().GetSoundScene().SetSoundVolume(g_Game.m_volume_sound,1);
 GetGame().GetSoundScene().SetSpeechExVolume(g_Game.m_volume_speechEX,1);
 GetGame().GetSoundScene().SetMusicVolume(g_Game.m_volume_music,1);
 GetGame().GetSoundScene().SetVOIPVolume(g_Game.m_volume_VOIP,1);
 GetGame().GetSoundScene().SetRadioVolume(g_Game.m_volume_radio,1);
 }
 
 override void SetPlayerRespawning(bool state)
 {
 m_PlayerRespawning = state;
 }
 
 override bool IsPlayerRespawning()
 {
 return m_PlayerRespawning;
 }
 
 override array<vector> GetActiveRefresherLocations()
 {
 return m_ActiveRefresherLocations;
 }
 
 override void SetRespawnModeClient(int mode)
 {
 m_RespawnModeClient = mode;
 }
 
 override int GetRespawnModeClient()
 {
 return m_RespawnModeClient;
 }
 
 override GameplayEffectWidgets GetEffectWidgets()
 {
 return m_EffectWidgets;
 }
 
 ScriptInvoker GetConnectivityInvoker()
 {
 if (!m_OnConnectivityChanged)
 {
 m_OnConnectivityChanged = new ScriptInvoker();
 }
 return m_OnConnectivityChanged;
 }
}