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();
        //GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).Remove(this.UpdateDebugMonitor);
    #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 DEVELOPER
        if (!GetGame().IsMultiplayer())//to make it work in single during development
        {
            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);
        GetUIManager().ShowUICursor(false);
        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();
        g_Game.GetUIManager().ShowUICursor(false);
        PPEManagerStatic.GetPPEManager().StopAllEffects(PPERequesterCategory.ALL);
        EnableAllInputs();
        g_Game.SetMissionState( DayZGame.MISSION_STATE_FINNISH );
    }
    
    override void OnUpdate(float timeslice)
    {
        super.OnUpdate(timeslice);
        
#ifdef DIAG_DEVELOPER
        UpdateInputDeviceDiag();
#endif
        
        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;
        
        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();
            
            RefreshExcludes();
        }
        
        //Radial quickbar
        if (GetUApi().GetInputByID(UAUIQuickbarRadialOpen).LocalPress())
        {
            //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();
            }
            else
            {
                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();
            }
            else
            {
                GetUApi().GetInputByID(UALookAround).Unlock();  //enable freelook
                GetUApi().GetInputByID(UALookAroundToggle).Unlock();    //enable freelook
                
                GetUApi().GetInputByID(UAZeroingUp).Lock();     //disable zeroing
                GetUApi().GetInputByID(UAZeroingDown).Lock();
            }
        }
#endif
        //Gestures
        if ( GetUApi().GetInputByID(UAUIGesturesOpen).LocalPress() )
        {
            //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)
                {
                    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();
        }
            
        RefreshExcludes();
        // supress control for next frame
        GetUApi().SupressNextFrame(bForceSupress);
    }
    
    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;
        }
 
        if ( g_Game.IsClient() && g_Game.GetGameState() != DayZGameState.IN_GAME )
        {
            return;
        }
        
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        if ( player && !player.IsPlayerLoaded() || IsPlayerRespawning() )
        {
            return;
        }
        
        m_PauseQueued = true;
        
        CloseAllMenus();
        
        // open ingame menu
        GetUIManager().EnterScriptedMenu( MENU_INGAME, GetGame().GetUIManager().GetMenu() );
        AddActiveInputExcludes({"menu"});
        AddActiveInputRestriction(EInputRestrictors.INVENTORY);
    }
    
    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;
        }
        
        m_PauseQueued = false;
        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();
        }
    }
    
    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"});
            }
            else
            {
                GetGame().GetMission().AddActiveInputExcludes({"loopedactions"});
            }
 
            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;
    }
}