Anti-Tag/Nick/Part Nick/Word/Char [ATUALIZADO]

#include a_samp

#define DATABASE            "Block.db"

#define MAX_ITENS           100

static
    bool:CaseSensitive  =   true;

static
    DB:Database,
    DBResult:Resultado;

static
    AntiTag[MAX_ITENS][10],
    AntiNick[MAX_ITENS][MAX_PLAYER_NAME],
    AntiParteNick[MAX_ITENS][MAX_PLAYER_NAME],
    AntiPalavra[MAX_ITENS][20],
    AntiChar[MAX_ITENS][2];

static
    bool:AntiTagId[MAX_ITENS],
    bool:AntiParteNickId[MAX_ITENS],
    bool:AntiNickId[MAX_ITENS],
    bool:AntiPalavraId[MAX_ITENS],
    bool:AntiCharId[MAX_ITENS];

static
    String[128];

public OnGameModeInit()
{
    Database = db_open(DATABASE);

    db_query(Database, "CREATE TABLE IF NOT EXISTS `Anti-TAG` (`ID` INTEGER PRIMARY KEY, `TAG` TEXT)");
    db_query(Database, "CREATE TABLE IF NOT EXISTS `Anti-Nick` (`ID` INTEGER PRIMARY KEY, `NICK` TEXT)");
    db_query(Database, "CREATE TABLE IF NOT EXISTS `Anti-ParteNick` (`ID` INTEGER PRIMARY KEY, `PARTE NICK` TEXT)");
    db_query(Database, "CREATE TABLE IF NOT EXISTS `Anti-Palavra` (`ID` INTEGER PRIMARY KEY, `PALAVRA` TEXT)");
    db_query(Database, "CREATE TABLE IF NOT EXISTS `Anti-Char` (`ID` INTEGER PRIMARY KEY, `CARACTERE` TEXT)");

    new
        Rows,
        GetData[10],
        Id;

    Resultado = db_query(Database, "SELECT * FROM `Anti-TAG`");
    Rows = db_num_rows(Resultado);
    if(Rows)
    {
        print("\n\n-----------TAGs-Proibidas-----------");

        for(new x = 0; x < Rows; ++ x)
        {
            if(Rows > MAX_ITENS)
            {
                printf("Não foi possível carregar todas as TAGs, pois o número de linhas foi excedido: %d/%d", Rows, MAX_ITENS);
                break;
            }

            db_get_field_assoc(Resultado, "ID", GetData, sizeof GetData);
            Id = strval(GetData);
            AntiTagId[Id] = true;

            db_get_field_assoc(Resultado, "TAG", AntiTag[Id], sizeof AntiTag);

            printf("ID: %d | TAG: %s", Id, AntiTag[Id]);

            db_next_row(Resultado);
        }

        printf("\n%d TAGs proibidas foram carregadas com sucesso\n", Rows);
    }
    db_free_result(Resultado);

    Resultado = db_query(Database, "SELECT * FROM `Anti-Nick`");
    Rows = db_num_rows(Resultado);
    if(Rows)
    {
        print("\n-----------Nicks-Proibidos-----------");

        for(new x = 0; x < Rows; ++ x)
        {
            if(Rows > MAX_ITENS)
            {
                printf("Não foi possível carregar todas os Nicks, pois o número de linhas foi excedido: %d/%d", Rows, MAX_ITENS);
                break;
            }

            db_get_field_assoc(Resultado, "ID", GetData, sizeof GetData);
            Id = strval(GetData);
            AntiNickId[Id] = true;

            db_get_field_assoc(Resultado, "NICK", AntiNick[Id], sizeof AntiNick);

            printf("ID: %d | Nick: %s", Id, AntiNick[Id]);

            db_next_row(Resultado);
        }

        printf("\n%d Nicks proibidos foram carregados com sucesso\n", Rows);
    }
    db_free_result(Resultado);

    Resultado = db_query(Database, "SELECT * FROM `Anti-ParteNick`");
    Rows = db_num_rows(Resultado);
    if(Rows)
    {
        print("\n-----------Parte-Nick-Proibidos-----------");

        for(new x = 0; x < Rows; ++ x)
        {
            if(Rows > MAX_ITENS)
            {
                printf("Não foi possível carregar todas as Partes de Nick, pois o número de linhas foi excedido: %d/%d", Rows, MAX_ITENS);
                break;
            }

            db_get_field_assoc(Resultado, "ID", GetData, sizeof GetData);
            Id = strval(GetData);
            AntiParteNickId[Id] = true;

            db_get_field_assoc(Resultado, "PARTE NICK", AntiParteNick[Id], sizeof AntiParteNick);

            printf("ID: %d | Parte Nick: %s", Id, AntiParteNick[Id]);

            db_next_row(Resultado);
        }

        printf("\n%d Partes de Nick proibidos foram carregados com sucesso\n", Rows);
    }
    db_free_result(Resultado);

    Resultado = db_query(Database, "SELECT * FROM `Anti-Palavra`");
    Rows = db_num_rows(Resultado);
    if(Rows)
    {
        print("\n-----------Palavras-Proibidas-----------");

        for(new x = 0; x < Rows; ++ x)
        {
            if(Rows > MAX_ITENS)
            {
                printf("Não foi possível carregar todas as Palavras, pois o número de linhas foi excedido: %d/%d", Rows, MAX_ITENS);
                break;
            }

            db_get_field_assoc(Resultado, "ID", GetData, sizeof GetData);
            Id = strval(GetData);
            AntiPalavraId[Id] = true;

            db_get_field_assoc(Resultado, "PALAVRA", AntiPalavra[Id], sizeof AntiPalavra);

            printf("ID: %d | Palavra: %s", Id, AntiPalavra[Id]);

            db_next_row(Resultado);
        }

        printf("\n%d Palavras proibidas foram carregadas com sucesso\n", Rows);
    }
    db_free_result(Resultado);

    Resultado = db_query(Database, "SELECT * FROM `Anti-Char`");
    Rows = db_num_rows(Resultado);
    if(Rows)
    {
        print("\n-----------Caracteres-Proibidos-----------");

        for(new x = 0; x < Rows; ++ x)
        {
            if(Rows > MAX_ITENS)
            {
                printf("Não foi possível carregar todos os Caracteres, pois o número de linhas foi excedido: %d/%d", Rows, MAX_ITENS);
                break;
            }

            db_get_field_assoc(Resultado, "ID", GetData, sizeof GetData);
            Id = strval(GetData);
            AntiCharId[Id] = true;

            db_get_field_assoc(Resultado, "CARACTERE", AntiChar[Id], sizeof AntiChar);

            printf("ID: %d | Caractere: %c", Id, AntiChar[Id]);

            db_next_row(Resultado);
        }

        printf("\n%d Caracteres proibidos foram carregados com sucesso\n", Rows);
    }
    db_free_result(Resultado);

    #if defined F_OnGameModeInit
        return F_OnGameModeInit();
    #else
        return true;
    #endif
}
#if defined _ALS_OnGameModeInit
    #undef OnGameModeInit
#else
    #define _ALS_OnGameModeInit
#endif
#define OnGameModeInit F_OnGameModeInit
#if defined F_OnGameModeInit
    forward F_OnGameModeInit();
#endif
public OnGameModeExit()
{
    db_close(Database);
    #if defined F_OnGameModeExit
        return F_OnGameModeExit();
    #else
        return true;
    #endif
}
#if defined _ALS_OnGameModeExit
    #undef OnGameModeExit
#else
    #define _ALS_OnGameModeExit
#endif
#define OnGameModeExit F_OnGameModeExit
#if defined F_OnGameModeExit
    forward OnGameModeExit();
#endif
//------------------------------------------
stock AddForbiddenTag(const Tag[])
{
    if(ForbiddenTagExists(Tag)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiTagId[i] == true) continue;

        AntiTagId[i] = true;

        format(String, sizeof String, "INSERT INTO `Anti-TAG` (`ID`, `TAG`) VALUES ('%d', '%s')", i, Tag);
        db_query(Database, String);

        strcat((AntiTag[i][0] = '\0', AntiTag[i]), Tag);

        return true;
    }
    return false;
}
stock AddForbiddenNick(const Nick[])
{
    if(ForbiddenNickExists(Nick)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiNickId[i] == true) continue;

        AntiNickId[i] = true;

        format(String, sizeof String, "INSERT INTO `Anti-Nick` (`ID`, `NICK`) VALUES ('%d', '%s')", i, Nick);
        db_query(Database, String);

        strcat((AntiNick[i][0] = '\0', AntiNick[i]), Nick);

        return true;
    }
    return false;
}
stock AddForbiddenPartNick(const PartNick[])
{
    if(ForbiddenPartNickExists(PartNick)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiParteNickId[i] == true) continue;

        AntiParteNickId[i] = true;

        format(String, sizeof String, "INSERT INTO `Anti-ParteNick` (`ID`, `PARTE NICK`) VALUES ('%d', '%s')", i, PartNick);
        db_query(Database, String);

        strcat((AntiParteNick[i][0] = '\0', AntiParteNick[i]), PartNick);

        return true;
    }
    return false;
}
stock AddForbiddenWord(const Word[])
{
    if(ForbiddenWordExists(Word)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiPalavraId[i] == true) continue;

        AntiPalavraId[i] = true;

        format(String, sizeof String, "INSERT INTO `Anti-Palavra` (`ID`, `PALAVRA`) VALUES ('%d', '%s')", i, Word);
        db_query(Database, String);

        strcat((AntiPalavra[i][0] = '\0', AntiPalavra[i]), Word);

        return true;
    }
    return false;
}
stock AddForbiddenChar(const Char[])
{
    if(ForbiddenCharExists(Char)) return false;
    if(strlen(Char) > 1) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiCharId[i] == true) continue;

        AntiCharId[i] = true;

        format(String, sizeof String, "INSERT INTO `Anti-Char` (`ID`, `CARACTERE`) VALUES ('%d', '%s')", i, Char);
        db_query(Database, String);

        strcat((AntiChar[i][0] = '\0', AntiChar[i]), Char);

        return true;
    }
    return false;
}
//------------------------------------------
stock RemoveForbiddenTag(const Tag[])
{
    if(!ForbiddenTagExists(Tag)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiTagId[i] == false) continue;

        if(strcmp(Tag, AntiTag[i], CaseSensitive) == 0)
        {
            format(String, sizeof String, "DELETE FROM `Anti-TAG` WHERE `TAG` = '%s'", Tag);
            db_query(Database, String);

            AntiTagId[i] = false;
            AntiTag[i][0] = '\0';

            return true;
        }
    }
    return false;
}
stock RemoveForbiddenNick(const Nick[])
{
    if(!ForbiddenNickExists(Nick)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiNickId[i] == false) continue;

        if(strcmp(Nick, AntiNick[i], CaseSensitive) == 0)
        {
            format(String, sizeof String, "DELETE FROM `Anti-Nick` WHERE `NICK` = '%s'", Nick);
            db_query(Database, String);

            AntiNickId[i] = false;
            AntiNick[i][0] = '\0';

            return true;
        }
    }
    return false;
}
stock RemoveForbiddenPartNick(const PartNick[])
{
    if(!ForbiddenPartNickExists(PartNick)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiParteNickId[i] == false) continue;

        if(strcmp(PartNick, AntiParteNick[i], CaseSensitive) == 0)
        {
            format(String, sizeof String, "DELETE FROM `Anti-ParteNick` WHERE `PARTE NICK` = '%s'", PartNick);
            db_query(Database, String);

            AntiParteNickId[i] = false;
            AntiParteNick[i][0] = '\0';

            return true;
        }
    }
    return false;
}
stock RemoveForbiddenWord(const Word[])
{
    if(!ForbiddenWordExists(Word)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiPalavraId[i] == false) continue;

        if(strcmp(Word, AntiPalavra[i], CaseSensitive) == 0)
        {
            format(String, sizeof String, "DELETE FROM `Anti-Palavra` WHERE `PALAVRA` = '%s'", Word);
            db_query(Database, String);

            AntiPalavraId[i] = false;
            AntiPalavra[i][0] = '\0';

            return true;
        }
    }
    return false;
}
stock RemoveForbiddenChar(const Char[])
{
    if(!ForbiddenCharExists(Char)) return false;

    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiCharId[i] == false) continue;

        if(strcmp(Char, AntiChar[i], CaseSensitive) == 0)
        {
            format(String, sizeof String, "DELETE FROM `Anti-Char` WHERE `CARACTERE` = '%c'", Char);
            db_query(Database, String);

            AntiCharId[i] = false;
            AntiChar[i][0] = '\0';

            return true;
        }
    }
    return false;
}
//------------------------------------------
stock ForbiddenTagExists(const Tag[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiTagId[i] == false) continue;

        if(strcmp(Tag, AntiTag[i], CaseSensitive) == 0) return true;
    }
    return false;
}
stock ForbiddenNickExists(const Nick[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiNickId[i] == false) continue;

        if(strcmp(Nick, AntiNick[i], CaseSensitive) == 0) return true;
    }
    return false;
}
stock ForbiddenPartNickExists(const PartNick[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiParteNickId[i] == false) continue;

        if(strcmp(PartNick, AntiParteNick[i], CaseSensitive) == 0) return true;
    }
    return false;
}
stock ForbiddenWordExists(const Word[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiPalavraId[i] == false) continue;

        if(strcmp(Word, AntiPalavra[i], CaseSensitive) == 0) return true;
    }
    return false;
}
stock ForbiddenCharExists(const Char[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiCharId[i] == false) continue;

        if(strcmp(Char, AntiChar[i], CaseSensitive) == 0) return true;
    }
    return false;
}
//------------------------------------------
forward bool:IsForbiddenTag(const Tag[]);
stock bool:IsForbiddenTag(const Tag[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiTagId[i] == false) continue;

        if(strfind(Tag, AntiTag[i], CaseSensitive) == 0) return true;
    }
    return false;
}
forward bool:IsForbiddenNick(const Nick[]);
stock bool:IsForbiddenNick(const Nick[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiNickId[i] == false) continue;

        if(strcmp(Nick, AntiNick[i], CaseSensitive) == 0) return true;
    }
    return false;
}
forward bool:IsForbiddenPartNick(const PartNick[]);
stock bool:IsForbiddenPartNick(const PartNick[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiParteNickId[i] == false) continue;

        if(strfind(PartNick, AntiParteNick[i], CaseSensitive) == 0) return true;
    }
    return false;
}
forward bool:IsForbiddenWord(const Word[]);
stock bool:IsForbiddenWord(const Word[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiPalavraId[i] == false) continue;

        if(strfind(Word, AntiPalavra[i], CaseSensitive) == 0) return true;
    }
    return false;
}
forward bool:IsForbiddenChar(const Str[]);
stock bool:IsForbiddenChar(const Str[])
{
    for(new i = 0; i < MAX_ITENS; ++ i)
    {
        if(AntiCharId[i] == false) continue;

        if(strfind(Str, AntiChar[i], CaseSensitive) != -1) return true;
    }
    return false;
}