Cbug Detection

O Cbug Detection é um include flexível para San Andreas Multiplayer (SA-MP) projetado para detectar o exploit C-Bug, uma técnica que permite aos jogadores atirar mais rápido do que o previsto ao explorar mecânicas do jogo. Este include oferece aos desenvolvedores de servidores uma ferramenta confiável para identificar o uso de C-Bug, possibilitando integração com sistemas como anti-cheat, monitoramento de comportamento ou regras personalizadas de jogabilidade.

No contexto do SA-MP, o C-Bug é uma prática que envolve ações rápidas, como agachar ou trocar de arma, após disparar certas armas, reduzindo o tempo de recarga e conferindo vantagem injusta em combates. Este include detecta essas ações de forma precisa, sendo útil em servidores Roleplay (RP), Team Deathmatch (TDM), Deathmatch (DM), minigames ou qualquer cenário que exija controle rigoroso das mecânicas de jogo. Sua versatilidade permite usos além do anti-cheat, como análise de jogabilidade ou criação de mecânicas únicas.

Note

O Cbug Detection não se limita a bloquear C-Bug; ele pode ser integrado em sistemas de monitoramento, eventos específicos ou minigames com regras customizadas. Em resumo, são os desenvolvedores que decidem qual ação deve ocorrer quando um player for detectado usando C-Bug, permitindo uma ampla flexibilidade na aplicação da detecção conforme o contexto do servidor.

Idiomas

Deutsch: README
English: README
Español: README
Français: README
Italiano: README
Polski: README
Русский: README
Svenska: README
Türkçe: README

Índice

Cbug Detection

Funcionalidades

Detecção Abrangente de C-Bug: Identifica as seguintes variantes:
- Clássico
- Rollbug
- Quick C-switch
- Jumpbug
- Run Bug
- Slide C-Bug
- Disparos rápidos
Controle por Jogador: Ativa ou desativa a detecção individualmente para cada jogador.
Ajuste por Ping: Adapta os tempos de detecção com base no ping do jogador, minimizando falsos positivos.
Proteção contra Falsos Positivos: Valida estado do jogador, arma, munição e animações para garantir precisão.
Configurações Personalizáveis: Define parâmetros de detecção via constantes (defines), embora os valores padrão sejam otimizados.
Callback Extensível: O callback CbugDetection_OnDetected permite integração com sistemas personalizados.
Leve e Otimizado: Usa apenas OnPlayerKeyStateChange e OnPlayerWeaponShot, com impacto mínimo no desempenho.

Como Funciona

O include monitora ações dos jogadores por meio dos callbacks OnPlayerKeyStateChange e OnPlayerWeaponShot, utilizando um sistema de pontuação de suspeita (cbug_d_suspicion_score) para identificar padrões de C-Bug. Quando a pontuação ultrapassa um limite configurável (CBUG_D_SUSPICION_THRESHOLD), o callback CbugDetection_OnDetected é acionado.

Important

O sistema é projetado para ser robusto, com validações rigorosas que minimizam falsos positivos, embora casos raros possam ocorrer, conforme detalhado na seção de limitações.

Lógica de Detecção

Pontuação de Suspeita:
- Ações suspeitas (e.g., agachar, trocar arma, disparos rápidos) incrementam cbug_d_suspicion_score com pesos específicos.
- Exemplo: Agachar após disparar adiciona 4.0 pontos; disparos rápidos adicionam 3.0 pontos.
- A pontuação decai com o tempo (CBUG_D_SUSPICION_DECAY = 0.5 por segundo) para evitar acumulação de ações não relacionadas.
Janelas de Tempo:
- Ações são consideradas suspeitas se ocorrerem logo após um disparo (CBUG_D_SEQUENCE_INTERVAL = 1500ms).
- Disparos rápidos são detectados se ocorrerem dentro de CBUG_D_SHOT_INTERVAL = 200ms.
Validações:
- Monitora apenas armas específicas (CBUG_D_VALID_WEAPONS: Desert Eagle, Shotgun, SPAS-12, Rifle, Sniper).
- A detecção é desativada se:
  - O jogador não está a pé (PLAYER_STATE_ONFOOT).
  - O jogador está correndo ou pulando (verificado por animações).
  - Não há munição (GetPlayerAmmo(playerid) <= 0).
  - A detecção está desativada para o jogador (cbug_d_player_status).

Ajuste por Ping:

A função CbugDetection_GetPingAdjtThresh ajusta os tempos com base no ping:

static stock Float:CbugDetection_GetPingAdjtThresh(playerid, cbug_d_base_threshold)
    return float(cbug_d_base_threshold) + (float(GetPlayerPing(playerid)) * CBUG_D_PING_MULTIPLIER);

Isso garante justiça para jogadores com maior latência (e.g., 200-300ms).

Cooldown:
- Um intervalo (CBUG_D_COOLDOWN_TIME = 1500ms) evita detecções repetidas para a mesma sequência.

Eventos Monitorados

OnPlayerKeyStateChange:

Rastreia teclas pressionadas (agachar, correr, esquerda/direita) e trocas de arma.
Detecta padrões como agachar ou rolar após disparar.

Exemplo:

if ((newkeys & KEY_CROUCH) && !(oldkeys & KEY_CROUCH)) {
    cbug_d_score_increment = 4.0;
    // Verificações adicionais para Rollbug, Quick C-switch, etc.
}

OnPlayerWeaponShot:

Monitora disparos e sequências rápidas.
Atualiza a pontuação para disparos consecutivos rápidos.

Exemplo:

if (cbug_d_time_since_last_shot <= cbug_d_adjusted_shot_threshold) {
    cbug_d_suspicion_score[playerid] += 3.0;
    cbug_d_shot_count[playerid]++;
    cbug_d_last_action_time[playerid] = cbug_d_current_time;
}

OnPlayerConnect:
- Inicializa o estado de detecção do jogador como desativado e reseta variáveis:
```
cbug_d_player_status[playerid] = false;
CbugDetection_ResetVariables(playerid);
```

Configurações (Defines)

Os defines controlam o comportamento da detecção. Os valores padrão são otimizados e recomendados:

Define	Valor Padrão	Descrição
`CBUG_D_SUSPICION_THRESHOLD`	10.0	Pontuação necessária para detecção. Valores maiores reduzem sensibilidade.
`CBUG_D_SUSPICION_DECAY`	0.5	Decaimento da pontuação por segundo.
`CBUG_D_SEQUENCE_INTERVAL`	1500	Janela (ms) para ações após disparo serem consideradas suspeitas.
`CBUG_D_SHOT_INTERVAL`	200	Janela (ms) para detectar disparos rápidos consecutivos.
`CBUG_D_COOLDOWN_TIME`	1500	Cooldown (ms) entre detecções para evitar repetições.
`CBUG_D_PING_MULTIPLIER`	0.01	Multiplicador para ajuste de ping nos tempos.
`CBUG_D_WEAPON_BUFFER_TIME`	500	Buffer (ms) para detecção de troca de arma após disparo.
`CBUG_D_SCORE_RESET_TIME`	2000	Tempo (ms) após última ação para resetar pontuação.
`CBUG_D_VALID_WEAPONS`	{24, 25, 27, 33, 34}	Armas monitoradas (Desert Eagle, Shotgun, SPAS-12, Rifle, Sniper).

Warning

Não é recomendado alterar os valores dos defines, pois os padrões foram cuidadosamente calibrados para balancear precisão e desempenho.

Estrutura do Código

O include é organizado em seções distintas, cada uma com uma função específica:

Cabeçalho:
- Define o include guard (_cbug_detection_included) e verifica a inclusão de a_samp ou open.mp.
Configurações (Defines):
- Define constantes para parâmetros de detecção (e.g., CBUG_D_SUSPICION_THRESHOLD).
- Usa #if defined para evitar conflitos de redefinição.

Variáveis Globais:

Armazena estados dos jogadores:

static bool:cbug_d_player_status[MAX_PLAYERS]; // Estado por jogador
static Float:cbug_d_suspicion_score[MAX_PLAYERS]; // Pontuação de suspeita
static cbug_d_last_fire_time[MAX_PLAYERS]; // Último disparo
// ... outras variáveis para rastreamento

Funções Utilitárias (Static Stock):

Funções internas para lógica de detecção:
- CbugDetection_GetPingAdjtThresh: Ajusta tempos por ping.
- CbugDetection_IsCbugWeapon: Verifica armas monitoradas.
- CbugDetection_IsJumping: Detecta animações de pulo.
- CbugDetection_IsRunning: Detecta animações de corrida.
- CbugDetection_ResetVariables: Reseta variáveis do jogador.

Exemplo:

static stock bool:CbugDetection_ResetVariables(playerid)
{
    if (cbug_d_suspicion_score[playerid] != 0.0)
        cbug_d_suspicion_score[playerid] = 0.0;

    if (cbug_d_last_fire_time[playerid] != 0)
        cbug_d_last_fire_time[playerid] = 0;

    if (cbug_d_last_roll_time[playerid] != 0)
        cbug_d_last_roll_time[playerid] = 0;

    // ... outras variáveis a ser resetadas...

    return true;
}

Funções Públicas (Stock):

Funções para controle do sistema:
- CbugDetection_Player: Ativa ou desativa a detecção para um jogador específico.
- CbugDetection_IsActive: Verifica se a detecção está ativa para um jogador.

Exemplo:

stock bool:CbugDetection_Player(playerid, bool:cbug_d_enable) {
    if (!IsPlayerConnected(playerid))
        return false;

    if (cbug_d_enable) {
        if (cbug_d_player_status[playerid])
            return false;

        cbug_d_player_status[playerid] = true;

        return true;
    }
    else {
        if (!cbug_d_player_status[playerid])
            return false;

        cbug_d_player_status[playerid] = false;
        CbugDetection_ResetVariables(playerid);

        return true;
    }
}

Callbacks:
- Implementa a lógica em OnPlayerKeyStateChange, OnPlayerWeaponShot, OnPlayerConnect, e OnPlayerDisconnect.
- Fornece CbugDetection_OnDetected para personalização.
- Exemplo:
```
forward CbugDetection_OnDetected(playerid);
```

Hooks ALS:

Integra callbacks padrão do SA-MP para compatibilidade:

#if defined _ALS_OnPlayerConnect
    #undef OnPlayerConnect
#else
    #define _ALS_OnPlayerConnect
#endif
#define OnPlayerConnect CBUG_D_OnPlayerConnect

// ... outros ALS a serem definidos...

Instalação e Configuração

Instalação

Baixe o Include:
- Coloque o arquivo cbug-detection.inc no diretório pawno/include.
Inclua no Gamemode:
- Adicione ao início do gamemode:
```
#include <a_samp>
#include <cbug-detection>
```

Warning

Certifique-se de incluir a_samp ou open.mp antes do cbug-detection.inc, ou o compilador reportará erros.

Compile o Gamemode:
- Use o compilador Pawn para compilar o gamemode, verificando a ausência de erros.

Configuração

Defina o Callback:

Implemente CbugDetection_OnDetected no gamemode para lidar com detecções:

public CbugDetection_OnDetected(playerid) {
    new string[100];

    format(string, sizeof(string), "Jogador %d detectado usando C-Bug!", playerid);
    SendClientMessageToAll(-1, string);

    return 1;
}

Como Utilizar

O include oferece controle individual para detecção de C-Bug por jogador. Abaixo, exemplos práticos de uso:

Ativação por Jogador

Ative para um jogador específico, e.g., em um evento de combate:
```
CbugDetection_Player(playerid, true);
```

Desativação por Jogador

Desative para um jogador específico, e.g., para administradores:
```
CbugDetection_Player(playerid, false);
```

Verificação de Estado

Verifique se a detecção está ativa para um jogador:

if (CbugDetection_IsActive(playerid))
    SendClientMessage(playerid, -1, "Detecção está ativa para você.");

Integração com Anti-Cheat

Aplique punições em CbugDetection_OnDetected:

public CbugDetection_OnDetected(playerid) {
    new string[110], name[MAX_PLAYER_NAME];
    GetPlayerName(playerid, name, sizeof(name));

    format(string, sizeof(string), "Jogador %s (ID: %d) detectado usando C-Bug!", name, playerid);
    SendClientMessageToAll(-1, string);

    Kick(playerid);

    return 1;
}

Registro de Detecções

Registre detecções em um arquivo:

public CbugDetection_OnDetected(playerid) {
    new string[128], name[MAX_PLAYER_NAME], 
        File:log = fopen("cbug_detections.log", io_append);

    format(string, sizeof(string), "[%s] Jogador %s (ID: %d) detectado usando C-Bug\n", GetCurrentDateTime(), name, playerid);

    fwrite(log, string);
    fclose(log);

    return 1;
}

Exemplo em Minigame

Ative a detecção apenas para jogadores específicos em um minigame:

CMD:iniciarminigame(playerid, params[]) {
    CbugDetection_Player(playerid, true);
    SendClientMessage(playerid, -1, "Detecção de C-Bug ativada para você no minigame!");

    return 1;
}

CMD:finalizarminigame(playerid, params[]) {
    CbugDetection_Player(playerid, false);
    SendClientMessage(playerid, -1, "Detecção de C-Bug desativada para você!");

    return 1;
}

Tip

Use CbugDetection_IsActive para verificar o estado da detecção antes de executar ações condicionais, como alertas ou punições.

Aplicações Possíveis

O Cbug Detection é altamente versátil e pode ser usado em diversos contextos:

Servidores Roleplay (RP): Reforce regras contra C-Bug para combates realistas.
Servidores TDM/DM: Garanta equilíbrio em combates detectando C-Bug.
Monitoramento: Analise comportamento dos jogadores ou identifique infratores frequentes.
Minigames e Eventos: Controle C-Bug apenas em eventos específicos.
Mecânicas Personalizadas: Integre com sistemas de pontuação ou penalidades.

Note

A capacidade de preservar configurações individuais ao ativar ou desativar globalmente torna o include ideal para servidores com regras dinâmicas.

Personalização

Embora o include seja otimizado com configurações padrão, é possível ajustar os defines ou o callback CbugDetection_OnDetected.

Warning

Alterar os defines ou outras configurações não é recomendado, pois os valores padrão foram testados e balanceados para máxima eficácia. Modificações podem causar falsos positivos, detecções imprecisas ou até mesmo impedir o funcionamento adequado.

Ajuste de Defines

Servidores com Ping Alto:

#define CBUG_D_SEQUENCE_INTERVAL 2000
#define CBUG_D_SHOT_INTERVAL 300

Detecção Mais Rigorosa:
```
#define CBUG_D_SUSPICION_THRESHOLD 15.0
```

Armas Personalizadas:

#define CBUG_D_VALID_WEAPONS {24, 25, 27, 33, 34}

Personalização do Callback

Adicione lógica avançada:

public CbugDetection_OnDetected(playerid) {
    new string[128], name[MAX_PLAYER_NAME];
    static warnings[MAX_PLAYERS];

    GetPlayerName(playerid, name, sizeof(name));
    warnings[playerid]++;

    format(string, sizeof(string), "Aviso %d: Jogador %s (ID: %d) detectado usando C-Bug!", warnings[playerid], name, playerid);
    SendClientMessageToAll(-1, string);

    if (warnings[playerid] >= 3)
        BanEx(playerid, "Uso repetido de C-Bug");
    
    return 1;
}

Testes e Validação

Para garantir o funcionamento correto, execute os seguintes testes:

Detecção de C-Bug:
- Teste todas as variantes listadas com armas monitoradas.
- Confirme que CbugDetection_OnDetected é acionado após 2-3 sequências.
Falsos Positivos:
- Execute ações como correr, pular ou atirar sem agachar.
- Verifique que não há detecções para ações não relacionadas ao C-Bug.
Controle por Jogador:
- Teste CbugDetection_Player para ativação/desativação por jogador.
- Confirme que a detecção só ocorre para jogadores com cbug_d_player_status ativo.
Verificação de Estado:
- Use CbugDetection_IsActive para confirmar o estado por jogador.
OnPlayerConnect:
- Verifique se novos jogadores iniciam com detecção desativada (cbug_d_player_status = false).
Ping Alto:
- Simule ping de 200-300ms e verifique a precisão da detecção.
Desempenho:
- Teste com 50+ jogadores para confirmar eficiência.

Tip

Teste em um ambiente controlado com poucos jogadores antes de implantar em servidores lotados.

Limitações e Considerações

Dependência de Callbacks:
- Depende de OnPlayerWeaponShot e OnPlayerKeyStateChange, que podem ser afetados por lag ou outros includes.
Ping Extremo:
- Latências muito altas (>500ms) podem exigir ajustes em CBUG_D_PING_MULTIPLIER.
Animações:
- A detecção de corrida/pulo usa índices de animação, que podem variar em clientes modificados.
Falsos Positivos:
- Apesar de robusto, falsos positivos podem ocorrer em casos raros, como ações legítimas em sequência rápida, o que é considerado normal.

Important

Falsos positivos são minimizados pelas validações, mas podem ocorrer em cenários atípicos. Monitore detecções para ajustar o uso, se necessário.

Licença

Este include está protegido sob a Licença Apache 2.0, que permite:

✔️ Uso comercial e privado
✔️ Modificação do código fonte
✔️ Distribuição do código
✔️ Concessão de patentes

Condições:

Manter o aviso de direitos autorais
Documentar alterações significativas
Incluir cópia da licença Apache 2.0

Para mais detalhes sobre a licença: http://www.apache.org/licenses/LICENSE-2.0

Name		Name	Last commit message	Last commit date
Latest commit History 7 Commits
src		src
translations		translations
LICENSE		LICENSE
README.md		README.md

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Repository files navigation

Cbug Detection

Idiomas

Índice

Funcionalidades

Como Funciona

Lógica de Detecção

Eventos Monitorados

Configurações (Defines)

Estrutura do Código

Instalação e Configuração

Instalação

Configuração

Como Utilizar

Ativação por Jogador

Desativação por Jogador

Verificação de Estado

Integração com Anti-Cheat

Registro de Detecções

Exemplo em Minigame

Aplicações Possíveis

Personalização

Ajuste de Defines

Personalização do Callback

Testes e Validação

Limitações e Considerações

Licença

Condições:

About

Uh oh!

Releases 1

Languages

License

ocalasans/cbug-detection

Folders and files

Latest commit

History

Repository files navigation

Cbug Detection

Idiomas

Índice

Funcionalidades

Como Funciona

Lógica de Detecção

Eventos Monitorados

Configurações (Defines)

Estrutura do Código

Instalação e Configuração

Instalação

Configuração

Como Utilizar

Ativação por Jogador

Desativação por Jogador

Verificação de Estado

Integração com Anti-Cheat

Registro de Detecções

Exemplo em Minigame

Aplicações Possíveis

Personalização

Ajuste de Defines

Personalização do Callback

Testes e Validação

Limitações e Considerações

Licença

Condições:

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 1

Languages