PluginManager.c

Go to the documentation of this file.

class PluginManager
{   
    private ref array<typename>                 m_PluginRegister;   // list of modules for creation
    private ref map<typename, ref PluginBase>   m_PluginsPtrs;      // plugin, plugin pointer
    
    //=================================
    // Constructor
    //=================================
    void PluginManager()
    {
        m_PluginRegister    = new array<typename>;
        m_PluginsPtrs       = new map<typename, ref PluginBase>;
    }
    
    //=================================
    // Destructor
    //=================================
    void ~PluginManager()
    {
        int i;
        PluginBase plugin;
        
        for ( i = 0; i < m_PluginsPtrs.Count(); ++i)
        {
            plugin = m_PluginsPtrs.GetElement(i);
            if ( plugin != NULL )
            {
                plugin.OnDestroy();
                delete plugin;
            }
        }
        
        GetGame().GetUpdateQueue(CALL_CATEGORY_GAMEPLAY).Remove(this.MainOnUpdate);
    }
    
    //=================================
    // Init
    //=================================
    void Init()
    {   
        //----------------------------------------------------------------------
        // Register modules
        //----------------------------------------------------------------------
        //              Module Class Name                               Client  Server
        //----------------------------------------------------------------------
        RegisterPlugin( "PluginHorticulture",                           true,   true );
        RegisterPlugin( "PluginRepairing",                              true,   true );
        RegisterPlugin( "PluginPlayerStatus",                           true,   true );
        RegisterPlugin( "PluginMessageManager",                         true,   true );
        RegisterPlugin( "PluginLifespan",                               true,   true );
        RegisterPlugin( "PluginVariables",                              true,   true );
        RegisterPlugin( "PluginObjectsInteractionManager",              false,  true );
        RegisterPlugin( "PluginRecipesManager",                         true,   true );
        RegisterPlugin( "PluginTransmissionAgents",                     true,   true );
        RegisterPlugin( "PluginAdditionalInfo",                         true,   true ); //TODO clean up after Gamescom
        RegisterPlugin( "PluginConfigEmotesProfile",                    true,   true );
        RegisterPlugin( "PluginPresenceNotifier",                       true,   false );
        RegisterPlugin( "PluginAdminLog",                               false,  true );
        
        // Developer + Diag
        RegisterPluginDiag( "PluginKeyBinding",                         true,   false );
        RegisterPluginDiag( "PluginDeveloper",                          true,   true );
        RegisterPluginDiag( "PluginDeveloperSync",                      true,   true );
        RegisterPluginDiag( "PluginDiagMenuClient",                     true,   false );
        RegisterPluginDiag( "PluginDiagMenuServer",                     false,  true );
        RegisterPluginDiag( "PluginPermanentCrossHair",                 true,   false );
        RegisterPluginDiag( "PluginRemotePlayerDebugClient",            true,   false );
        RegisterPluginDiag( "PluginRemotePlayerDebugServer",            false,  true );
        RegisterPluginDiag( "PluginUniversalTemperatureSourceClient",   true,   false );
        RegisterPluginDiag( "PluginUniversalTemperatureSourceServer",   false,  true );
        RegisterPluginDiag( "PluginDrawCheckerboard",                   true,   false );
        RegisterPluginDiag( "PluginItemDiagnostic",                     true,   true );
        RegisterPluginDiag( "PluginDayZCreatureAIDebug",                true,   true );
        
        // Only In Debug / Internal
        RegisterPluginDebug( "PluginConfigViewer",                      true,   true );
        RegisterPluginDebug( "PluginLocalEnscriptHistory",              true,   true );
        RegisterPluginDebug( "PluginLocalEnscriptHistoryServer",        true,   true );
        
        RegisterPluginDebug( "PluginSceneManager",                      true,   true );
        RegisterPluginDebug( "PluginConfigScene",                       true,   true );
        RegisterPluginDebug( "PluginMissionConfig",                     true,   true );
        RegisterPluginDebug( "PluginConfigEmotesProfile",               true,   true );
        RegisterPluginDebug( "PluginConfigDebugProfile",                true,   true );
        RegisterPluginDebug( "PluginConfigDebugProfileFixed",           true,   true );
        
        RegisterPluginDebug( "PluginDayzPlayerDebug",                   true,   true );
        RegisterPluginDebug( "PluginDayZInfectedDebug",                 true,   true );
        RegisterPluginDebug( "PluginDoorRuler",                         true,   false );
        RegisterPluginDebug( "PluginCharPlacement",                     true,   false );
        //RegisterPluginDebug( "PluginSoundDebug",                      false,  false );
        RegisterPluginDebug( "PluginCameraTools",                       true,   true );
        RegisterPluginDebug( "PluginNutritionDumper",                   true,   false );
        
        GetGame().GetUpdateQueue(CALL_CATEGORY_GAMEPLAY).Insert(MainOnUpdate);
    }
    
    //=================================
    // PluginsInit
    //=================================
    void PluginsInit()
    {
        int i = 0;
        int regCount = m_PluginRegister.Count();
        
        array<PluginBase> pluginPtrs = {};
        pluginPtrs.Reserve(regCount);
        
        foreach (typename pluginType : m_PluginRegister)
        {
            PluginBase moduleExist = GetPluginByType( pluginType );
            if ( moduleExist )
            {
                m_PluginsPtrs.Remove( pluginType );
            }
            
            PluginBase moduleNew = PluginBase.Cast(pluginType.Spawn());
            m_PluginsPtrs.Set(pluginType, moduleNew);
            pluginPtrs.Insert(moduleNew);
        }
        
        foreach (PluginBase plugin : pluginPtrs)
        {
            if ( plugin )
            {
                plugin.OnInit();
            }
        }
    }
    
    //=================================
    // MainOnUpdate
    //=================================
    void MainOnUpdate(float delta_time)
    {
        for ( int i = 0; i < m_PluginsPtrs.Count(); ++i)
        {
            PluginBase plugin = m_PluginsPtrs.GetElement(i);
            if ( plugin != NULL )
            {
                plugin.OnUpdate(delta_time);
            }
        }
    }
    
    //=================================
    // GetPluginByType
    //=================================
    PluginBase GetPluginByType( typename plugin_type )
    {
        if ( m_PluginsPtrs.Contains( plugin_type ) )
        {
            return m_PluginsPtrs.Get( plugin_type );
        }
        
        return null;
    }
    
    //=================================
    // RegisterPlugin
    //=================================
    protected void RegisterPlugin( string plugin_class_name, bool reg_on_client, bool reg_on_server, bool reg_on_release = true )
    {
        if ( !reg_on_client )
        {
            if ( GetGame().IsMultiplayer() && GetGame().IsClient() )
            {
                return;
            }
        }
        
        if ( !reg_on_server )
        {
            if ( GetGame().IsMultiplayer() )
            {
                if ( GetGame().IsServer() )
                {
                    return;
                }
            }
        }
        
        if ( !reg_on_release )
        {
            if ( !GetGame().IsDebug() )
            {
                return;
            }
        }
        
        m_PluginRegister.Insert( plugin_class_name.ToType() );
    }
    
    //=================================
    // RegisterPlugin
    //=================================
    protected void RegisterPluginDebug( string plugin_class_name, bool reg_on_client, bool reg_on_server )
    {
        RegisterPlugin(plugin_class_name, reg_on_client, reg_on_server, false);
    }
    //=================================
    // RegisterPlugin
    //=================================
    protected void RegisterPluginDiag( string plugin_class_name, bool reg_on_client, bool reg_on_server )
    {
        #ifdef DIAG_DEVELOPER
        RegisterPlugin(plugin_class_name, reg_on_client, reg_on_server, true);
        #else
        return;
        #endif      
    }
    
    //---------------------------------
    // UnregisterPlugin
    //---------------------------------
    protected bool UnregisterPlugin( string plugin_class_name )
    {
        typename plugin_type = plugin_class_name.ToType();
        
        if ( m_PluginRegister.Find( plugin_type ) != -1 )
        {
            m_PluginRegister.RemoveItem( plugin_type );
            return true;
        }
        
        return false;
    }
}
 
ref PluginManager g_Plugins;
 
PluginManager GetPluginManager()
{   
    /*
    if ( g_Plugins == NULL )
    {
        PluginManagerInit();
    }
    */
    
    return g_Plugins;
}
 
 
void PluginManagerInit()
{   
    if (g_Plugins == NULL)
    {
        g_Plugins = new PluginManager;
        g_Plugins.Init();
        g_Plugins.PluginsInit();
    }
}
 
void PluginManagerDelete()
{   
    if ( g_Plugins )
    {
        delete g_Plugins;
        g_Plugins = NULL;
    }
}
 
bool IsPluginManagerExists()
{
    if ( g_Plugins != null )
    {
        return true;
    }   
    
    return false;
}
 
PluginBase GetPlugin(typename plugin_type)
{
    PluginBase plugin = null;
    
    if ( IsPluginManagerExists() )
    {
        plugin = GetPluginManager().GetPluginByType(plugin_type);
    
        if ( plugin == null )
        {
            #ifdef DIAG_DEVELOPER
            if ( IsPluginManagerExists() )
            {
                PrintString("Module " + plugin_type.ToString() + " is not Registred in PluginManager.c!");
                DumpStack();
            }
            #endif
        }
    }
    
    return plugin;
}
 
bool IsModuleExist(typename plugin_type)
{
    if ( IsPluginManagerExists() )
    {
        return ( GetPlugin(plugin_type) != NULL );
    }
    
    return false;
}