SCR_AddonTools.c

Go to the documentation of this file.

[Obsolete("Use SCR_ParamEnumArray")]
class ParamEnumAddons : array<ref ParamEnum>
{
    //------------------------------------------------------------------------------------------------
    [Obsolete("Use SCR_ParamEnumArray.FromAddons instead")]
    private static ParamEnumArray FromEnum(int titleFormat = 2, int hideCoreModules = 0)
    {
        return SCR_ParamEnumArray.FromAddons(titleFormat, hideCoreModules);
    }
}
 
// TODO: rename to SCR_AddonTools?
class SCR_AddonTool
{
    protected static const ref array<string> LOADED_ADDON_IDS = {}; // static values get reset every time addons are loaded/unloaded
    protected static const ref array<string> LOADED_ADDON_GUIDS = {};
 
    protected static const ref array<string> CORE_ADDONS = { "core", "ArmaReforger" };
 
    //------------------------------------------------------------------------------------------------
    static array<string> GetResourceAddons(ResourceName prefab, bool ignoreCoreAddons = false)
    {
        array<string> addonNames = {};
 
        if (prefab.IsEmpty())
            return addonNames;
 
        Resource prefabResource = BaseContainerTools.LoadContainer(prefab);
        if (!prefabResource)
            return addonNames;
 
        BaseResourceObject configContainer;
        configContainer = prefabResource.GetResource();
        if (!configContainer)
            return addonNames;
 
        BaseContainer configBase = configContainer.ToBaseContainer();
        if (!configBase)
            return addonNames;
 
        configBase.GetSourceAddons(addonNames);
 
        if (ignoreCoreAddons && !addonNames.IsEmpty())
        {
            foreach (string item : CORE_ADDONS)
            {
                addonNames.RemoveItem(item);
            }
        }
 
        return addonNames;
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetResourceLastAddon(ResourceName prefab)
    {
        array<string> addonNames = GetResourceAddons(prefab);
        if (addonNames.IsEmpty())
            return string.Empty;
 
        return addonNames[addonNames.Count() - 1];
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetAddonID(int index)
    {
        LoadAddons();
 
        if (!LOADED_ADDON_IDS.IsIndexValid(index))
            return string.Empty;
 
        return LOADED_ADDON_IDS[index];
    }
 
    //------------------------------------------------------------------------------------------------
    // \param[in] ignoreCoreAddons
    static array<string> GetAllAddonIDs(/* bool ignoreCoreAddons = false */)
    {
        LoadAddons();
 
        return SCR_ArrayHelperT<string>.GetCopy(LOADED_ADDON_IDS);
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetAddonFileSystem(int addonIndex)
    {
        LoadAddons();
 
        if (!LOADED_ADDON_IDS.IsIndexValid(addonIndex))
            return string.Empty;
 
        return ToFileSystem(LOADED_ADDON_IDS[addonIndex]);
    }
 
    //------------------------------------------------------------------------------------------------
    // \param[in] ignoreCoreAddons
    static array<string> GetAllAddonFileSystems(/* bool ignoreCoreAddons = false */)
    {
        LoadAddons();
 
        array<string> result = {};
 
        foreach (string addonID : LOADED_ADDON_IDS)
        {
            result.Insert(ToFileSystem(addonID));
        }
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool IsVanillaAddon(int addonIndex)
    {
        if (!LOADED_ADDON_GUIDS.IsIndexValid(addonIndex))
            return false;
 
        return GameProject.IsVanillaAddon(LOADED_ADDON_GUIDS[addonIndex]);
    }
 
    //------------------------------------------------------------------------------------------------
    static bool IsVanillaAddon(string addonID)
    {
        int addonIndex = LOADED_ADDON_IDS.Find(addonID);
        if (addonIndex < 0)
            return false;
 
        return GameProject.IsVanillaAddon(LOADED_ADDON_GUIDS[addonIndex]);
    }
 
    //------------------------------------------------------------------------------------------------
    static string StripFileSystem(string fileSystemPath)
    {
        int length = fileSystemPath.Length();
        if (fileSystemPath.IsEmpty())
            return fileSystemPath;
 
        if (!fileSystemPath.StartsWith("$"))
            return fileSystemPath;
 
        int colonIndex /* ha, ha */ = fileSystemPath.IndexOf(":");
        if (colonIndex < 0)
            return fileSystemPath;
 
        ++colonIndex;
        if (colonIndex == length)
            return string.Empty;
 
        return fileSystemPath.Substring(colonIndex, length - colonIndex);
    }
 
    //------------------------------------------------------------------------------------------------
    static string ToFileSystem(string addonID)
    {
        addonID.TrimInPlace();
        if (!addonID) // !.IsEmpty()
            return string.Empty;
 
        return string.Format("$%1:", addonID);
    }
 
    //------------------------------------------------------------------------------------------------
    protected static void LoadAddons()
    {
        if (!LOADED_ADDON_IDS.IsEmpty())
            return;
 
        array<string> guids = {};
        GameProject.GetLoadedAddons(guids);
 
        LOADED_ADDON_GUIDS.Copy(guids);
        foreach (string addonGUID : LOADED_ADDON_GUIDS)
        {
            LOADED_ADDON_IDS.Insert(GameProject.GetAddonID(addonGUID));
        }
    }
 
#ifdef WORKBENCH
    //------------------------------------------------------------------------------------------------
    static bool GetAddonAbsolutePath(int addonId, string relativeDirPath, out string result, bool mustExist = true)
    {
        return Workbench.GetAbsolutePath(ToFileSystem(GetAddonID(addonId)) + relativeDirPath, result, mustExist);
    }
 
    //------------------------------------------------------------------------------------------------
    static bool GetAddonAbsolutePath(int addonId, ResourceName directory, out string result, bool mustExist = true)
    {
        return Workbench.GetAbsolutePath(ToFileSystem(GetAddonID(addonId)) + directory.GetPath(), result, mustExist);
    }
#endif
}