AlliedModders - Function to check if translation exists

Version 1

The function checks if the folder exists, if the file exists and if the phrase contains the needed format indexes.

PHP Code:


		
			
stock bool TranslationExists(char[] phrase, char[] file)
{
    char cfgFile[PLATFORM_MAX_PATH];
    char dirName[PLATFORM_MAX_PATH];
    
    BuildPath(Path_SM, dirName, PLATFORM_MAX_PATH, "translations");
    BuildPath(Path_SM, cfgFile, PLATFORM_MAX_PATH, "translations/%s.txt", file);
    
    if (!DirExists(dirName) || !FileExists(cfgFile))
    {
        return false;
    }
    
    Handle kv = CreateKeyValues("Phrases");
    FileToKeyValues(kv, cfgFile);
    
    if (KvJumpToKey(kv, phrase))
    {
        char bufferformat[255];
        KvGetString(kv, "#format", bufferformat, sizeof(bufferformat), "");
        
        bool contains[16];
        bool passed = false;
        if (!StrEqual(bufferformat, ""))
        {
            for (int i = 1; i < sizeof(contains); i++)
            {
                char buffer[4];
                Format(buffer, sizeof(buffer), "{%d:", i);
                if (StrContains(bufferformat, buffer) != -1)
                {
                    passed = true;
                    contains[i] = true;
                }
                else
                {
                    contains[i] = false;
                }
            }
        }
        
        char bufferphrase[255];
        KvGetString(kv, langname, bufferphrase, sizeof(bufferphrase), "");
        
        if (StrEqual(bufferphrase, ""))
        {
            return false;
        }
        
        if (passed)
        {
            for (int i = 1; i < sizeof(contains); i++)
            {
                if (contains[i])
                {
                    char buffer[4];
                    Format(buffer, sizeof(buffer), "{%d}", i);
                    if (StrContains(bufferphrase, buffer) == -1)
                    {
                        return false;
                    }
                }
            }
        }
    }
    else
    {
        return false;
    }
    CloseHandle(kv);
    
    return true;
}

Call it like this:

PHP Code:


		
			
if (TranslationExists("Changing map", "common.phrases"))
{
    PrintToChat(client, "%t", "Changing map", map)
}
else
{
    PrintToChat(client, "Changing map to %s...", map)
}

Version 2

The function checks if the folder exists, if the file exists and if the phrase contains the needed format indexes.
It's coded using SMC Parser, which will prevent any bugs related with multi-line comments in the file.

PHP Code:


		
			
char parsephrase[255];
bool parsephrasefound;
bool parsecontainstrue;
bool parsepassed;
bool parseemptysection;
bool parsephrasesection;
bool parsecontains[16];

stock bool TranslationExists(char[] phrase, const char[] file)
{ 
    char cfgFile[PLATFORM_MAX_PATH];
    char dirName[PLATFORM_MAX_PATH];
    
    BuildPath(Path_SM, dirName, PLATFORM_MAX_PATH, "translations");
    BuildPath(Path_SM, cfgFile, PLATFORM_MAX_PATH, "translations/%s.txt", file);
    
    if (!DirExists(dirName) || !FileExists(cfgFile) || !ParseFile(cfgFile, phrase))
    {
        return false;
    }
    
    return true;
}

stock bool ParseFile(const char[] parsefile, const char[] phrase)
{
    Handle hParser = SMC_CreateParser();
    
    Format(parsephrase, sizeof(parsephrase), phrase);
    parsephrasefound = false;
    parsecontainstrue = false;
    parsepassed = true;
    parseemptysection = false;
    parsephrasesection = true;
    
    for (int i = 1; i < sizeof(parsecontains); i++)
    {
        parsecontains[i] = false;
    }
    
    SMC_SetReaders(hParser, NewSection, KeyValue, EndSection);
    SMC_SetParseEnd(hParser, ParseEnd);
    
    SMCError result = SMC_ParseFile(hParser, parsefile);
    CloseHandle(hParser);
    
    return (result == SMCError_Okay && parsepassed);
}

stock SMCResult NewSection(Handle parser, const char[] name, bool quotes)
{
    if (parsephrasesection)
    {
        if (!StrEqual(name, "Phrases"))
        {
            return SMCParse_HaltFail;
        }
        else
        {
            parsephrasesection = false;
        }
    }
    
    if (parseemptysection)
    {
        return SMCParse_HaltFail;
    }
    
    if (StrEqual(name, parsephrase))
    {
        parseemptysection = true;
        parsephrasefound = true;
    }
    
    return SMCParse_Continue;
}

stock SMCResult KeyValue(Handle parser, const char[] key, const char[] value, bool key_quotes, bool value_quotes)
{
    if (parsephrasefound)
    {
        if (!parsecontainstrue)
        {
            if (StrEqual(key, "#format"))
            {
                for (int i = 1; i < sizeof(parsecontains); i++)
                {
                    char buffer[4];
                    Format(buffer, sizeof(buffer), "{%d:", i);
                    if (StrContains(value, buffer) != -1)
                    {
                        parsecontainstrue = true;
                        parsecontains[i] = true;
                    }
                    else
                    {
                        parsecontains[i] = false;
                    }
                }
            }
            else if (StrEqual(key, "en"))
            {
                if (StrEqual(value, ""))
                {
                    return SMCParse_HaltFail;
                }
                parseemptysection = false;
                return SMCParse_Halt;
            }
        }
        else
        {
            if (StrEqual(key, "en"))
            {
                for (int i = 1; i < sizeof(parsecontains); i++)
                {
                    if (parsecontains[i])
                    {
                        char buffer[4];
                        Format(buffer, sizeof(buffer), "{%d}", i);
                        if (StrContains(value, buffer) == -1)
                        {
                            return SMCParse_HaltFail;
                        }
                    }
                }
                parseemptysection = false;
                return SMCParse_Halt;
            }
        }
    }
    
    return SMCParse_Continue;
}

stock SMCResult EndSection(Handle parser){}

stock void ParseEnd(Handle parser, bool halted, bool failed)
{
    if (failed || parseemptysection || parsephrasesection)
    {
        parsepassed = false;
    }
}

Call it like this:

PHP Code:


		
			
if (TranslationExists("Changing map", "common.phrases"))
{
    PrintToChat(client, "%t", "Changing map", map);
}
else
{
    PrintToChat(client, "Changing map to %s...", map);
}

The code will cache the valid translations in an array. Then it will simply check if that translation is available in the array in the client language, server language or English.
It's coded using SMC Parser, which will prevent any bugs related with multi-line comments in the file.

PHP Code:


		
			
Handle langs = INVALID_HANDLE;
Handle transid = INVALID_HANDLE;
Handle translang = INVALID_HANDLE;

char transidbuffer[64];
bool parsefirstsection;
bool getlangs;
bool parsecontains[16];

public void OnPluginStart()
{
    langs = CreateArray(16);
    transid = CreateArray(64);
    translang = CreateArray(16);
    
    LoadTranslations("common.phrases");
    LoadTranslationsEx("common.phrases");
}

stock bool TranslationExists(int client, const char[] phrase)
{
    int langservernum = GetServerLanguage();
    int langnum;
    if (client == 0)
    {
        langnum = GetServerLanguage();
    }
    else
    {
        langnum = GetClientLanguage(client);
    }
    
    char langservercode[16];
    char langcode[16];
    GetLanguageInfo(langservernum, langservercode, sizeof(langservercode));
    GetLanguageInfo(langnum, langcode, sizeof(langcode));
    
    for (int i = 0; i < GetArraySize(transid); i++)
    {
        char buffer1[64];
        GetArrayString(transid, i, buffer1, sizeof(buffer1));
        
        if (StrEqual(phrase, buffer1))
        {
            char buffer2[64];
            GetArrayString(translang, i, buffer2, sizeof(buffer2));
            
            if (StrEqual(langcode, buffer2) || StrEqual("en", buffer2) || StrEqual(langservercode, buffer2))
            {
                return true;
            }
        }
    }
    
    return false;
}

stock void LoadTranslationsEx(const char[] file)
{
    char cfgFile[PLATFORM_MAX_PATH];
    char dirName[PLATFORM_MAX_PATH];
    
    BuildPath(Path_SM, dirName, PLATFORM_MAX_PATH, "configs");
    BuildPath(Path_SM, cfgFile, PLATFORM_MAX_PATH, "configs/languages.cfg");
    
    if (DirExists(dirName) && FileExists(cfgFile))
    {
        Handle smc = SMC_CreateParser();
        
        parsefirstsection = true;
        getlangs = true;
        
        SMC_SetReaders(smc, NewSection, KeyValue, EndSection);
        SMC_ParseFile(smc, cfgFile);
        
        CloseHandle(smc);
    }
    
    for (int i = 0; i < GetArraySize(langs); i++)
    {
        char buffer[64];
        GetArrayString(langs, i, buffer, sizeof(buffer));
        
        if (StrEqual(buffer, "en", false))
        {
            BuildPath(Path_SM, dirName, PLATFORM_MAX_PATH, "translations");
            BuildPath(Path_SM, cfgFile, PLATFORM_MAX_PATH, "translations/%s.txt", file);
            
            if (DirExists(dirName) && FileExists(cfgFile))
            {
                Handle smc = SMC_CreateParser();
                
                parsefirstsection = true;
                
                SMC_SetReaders(smc, NewSection, KeyValue, EndSection);
                SMC_ParseFile(smc, cfgFile);
                
                CloseHandle(smc);
            }
        }
        else
        {
            BuildPath(Path_SM, dirName, PLATFORM_MAX_PATH, "translations/%s", buffer);
            BuildPath(Path_SM, cfgFile, PLATFORM_MAX_PATH, "translations/%s/%s.txt", buffer, file);
            
            if (DirExists(dirName) && FileExists(cfgFile))
            {
                Handle smc = SMC_CreateParser();
                
                parsefirstsection = true;
                
                SMC_SetReaders(smc, NewSection, KeyValue, EndSection);
                SMC_ParseFile(smc, cfgFile);
                
                CloseHandle(smc);
            }
        }
    }
}

stock SMCResult NewSection(Handle parser, const char[] name, bool quotes)
{
    for (int i = 1; i < sizeof(parsecontains); i++)
    {
        parsecontains[i] = false;
    }
    
    if (getlangs)
    {
        if (!StrEqual(name, "Languages"))
        {
            getlangs = false;
            return SMCParse_HaltFail;
        }
        else
        {
            return SMCParse_Continue;
        }
    }
    else
    {
        if (parsefirstsection)
        {
            if (!StrEqual(name, "Phrases"))
            {
                return SMCParse_HaltFail;
            }
            else
            {
                parsefirstsection = false;
                return SMCParse_Continue;
            }
        }
    }
    
    Format(transidbuffer, sizeof(transidbuffer), name);
    return SMCParse_Continue;
}

stock SMCResult KeyValue(Handle parser, const char[] key, const char[] value, bool key_quotes, bool value_quotes)
{
    if (getlangs)
    {
        for (int i = 0; i < GetArraySize(langs); i++)
        {
            char buffer[16];
            GetArrayString(langs, i, buffer, sizeof(buffer));
            if (StrEqual(key, buffer, false))
            {
                return SMCParse_Continue;
            }
        }
        
        PushArrayString(langs, key);
        return SMCParse_Continue;
    }
    else
    {
        if (StrEqual(key, "#format", false))
        {
            for (int i = 1; i < sizeof(parsecontains); i++)
            {
                char buffer[4];
                Format(buffer, sizeof(buffer), "{%d:", i);
                if (StrContains(value, buffer) != -1)
                {
                    parsecontains[i] = true;
                }
                else
                {
                    parsecontains[i] = false;
                }
            }
            return SMCParse_Continue;
        }
        else if (StrEqual(value, ""))
        {
            return SMCParse_Continue;
        }
        
        for (int i = 0; i < GetArraySize(transid); i++)
        {
            char buffer1[64];
            GetArrayString(transid, i, buffer1, sizeof(buffer1));
            if (StrEqual(transidbuffer, buffer1))
            {
                char buffer2[16];
                GetArrayString(translang, i, buffer2, sizeof(buffer2));
                if (StrEqual(key, buffer2, false))
                {
                    return SMCParse_Continue;
                }
            }
        }
        
        for (int i = 1; i < sizeof(parsecontains); i++)
        {
            if (parsecontains[i])
            {
                char buffer[4];
                Format(buffer, sizeof(buffer), "{%d}", i);
                if (StrContains(value, buffer) == -1)
                {
                    return SMCParse_Continue;
                }
            }
        }
        
        PushArrayString(transid, transidbuffer);
        PushArrayString(translang, key);
        
        return SMCParse_Continue;
    }
}

stock SMCResult EndSection(Handle parser)
{
    if (getlangs)
    {
        getlangs = false;
    }
}

Call it like this:

PHP Code:


		
			
if (TranslationExists(client, "Changing map"))
{
    PrintToChat(client, "%t", "Changing map", "de_dust2");
}
else
{
    PrintToChat(client, "Changing map to %s...", "de_dust2");
}