[Free] JB Challenges First [New Version v2,1]

/* 21/12/2024 Latest Version of JB Challenges
    v2.2 - Fixed HUD and chat handling, improved code stability
*/

#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <hamsandwich>

#define ADMIN_FLAG ADMIN_KICK
#define MAX_PLAYERS 32
#define CHALLENGE_TIMEOUT 30.0
#define CHECK_INTERVAL 10.0
#define TASK_GUESS_TIMER 987456

new bool:g_GameActive = false;
new g_CountdownTime;
new g_Answer[32];
new bool:g_WinnerFound = false;
new g_GameType;
new g_NoResponseCount = 0;
new bool:g_CountdownActive = false;
new Float:g_StartTime;
new Float:g_TimeElapsed;

// Guess game variables
new g_PlayerGuesses[MAX_PLAYERS + 1];
new g_BestGuessPlayer;
new g_GuessCount = 0;

enum _:GameTypes {
    GAME_FIRSTWRITE = 1,
    GAME_GUESS,
    GAME_MATH
}

public plugin_init() {
    register_plugin("JB Challenges", "2.1", "CheezPuff (Ariel)");

    register_concmd("say /first", "CmdStartGame", ADMIN_FLAG);
    register_concmd("say /random", "CmdStartGame", ADMIN_FLAG);
    register_concmd("say /fw", "CmdStartGame", ADMIN_FLAG);
    register_concmd("say /stopfw", "CmdStopGame", ADMIN_FLAG);
    register_concmd("say /stopfirst", "CmdStopGame", ADMIN_FLAG);

    register_clcmd("say", "HandleSay");
    register_clcmd("say_team", "HandleSay");

    set_task(CHECK_INTERVAL, "CheckTerroristCount", .flags="b");
}

public plugin_precache() {
    precache_sound("fvox/1.wav");
    precache_sound("fvox/2.wav");
    precache_sound("fvox/3.wav");
    precache_sound("fvox/4.wav");
    precache_sound("fvox/5.wav");
}

public CheckTerroristCount(taskid) {
    if (g_GameActive)
        return;

    new tCount = get_team_count(CS_TEAM_T);
    if (tCount >= 9) {
        StartGameCountdown();
    }
}

public CmdStartGame(id, level, cid) {
    if (!cmd_access(id, level, cid, 1))
        return PLUGIN_HANDLED;

    if (g_GameActive) {
        client_print_color(id, print_team_default, "^4[JB]^1 A challenge is already in progress!");
        return PLUGIN_HANDLED;
    }

    new tCount = get_team_count(CS_TEAM_T);
    if (tCount < 2) {
        client_print_color(id, print_team_default, "^4[JB]^1 Need at least 2 terrorists to start a challenge!");
        return PLUGIN_HANDLED;
    }

    StartGameCountdown();
    return PLUGIN_HANDLED;
}

public CmdStopGame(id, level, cid) {
    if (!cmd_access(id, level, cid, 1))
        return PLUGIN_HANDLED;

    if (!g_GameActive && !g_CountdownActive) {
        client_print_color(id, print_team_default, "^4[JB]^1 No challenge is currently running!");
        return PLUGIN_HANDLED;
    }

    // Clear HUD messages explicitly before resetting game state
    set_hudmessage(0, 0, 0, -1.0, 0.35, 0, 0.1, 0.1, 0.0, 0.0);
    show_hudmessage(0, "");

    ResetGameState();
    client_print_color(0, print_team_default, "^4[JB]^1 An admin has stopped the current challenge.");
    return PLUGIN_HANDLED;
}

stock get_team_count(CsTeams:team) {
    new players[MAX_PLAYERS], num;
    get_players(players, num, "ae", team == CS_TEAM_T ? "TERRORIST" : "CT");
    return num;
}

public StartGameCountdown() {
    // Clear any existing HUD messages first
    ClearAllHudMessages();

    ResetGameState();
    g_GameActive = true;
    g_CountdownActive = true;
    g_CountdownTime = 5;

    // Select random game type with equal probability
    new randomValue = random_num(1, 3);
    switch(randomValue) {
        case 1: g_GameType = GAME_FIRSTWRITE;
        case 2: g_GameType = GAME_GUESS;
        case 3: g_GameType = GAME_MATH;
    }

    new gameTypeName[32];
    GetGameTypeName(g_GameType, gameTypeName, charsmax(gameTypeName));

    set_hudmessage(0, 255, 255, -1.0, 0.35, 0, 6.0, 12.0, 0.1, 0.1);
    show_hudmessage(0, "%s will start in 5 seconds", gameTypeName);

    client_print_color(0, print_team_default, "^4[JB]^1 %s will start in 5 seconds", gameTypeName);

    set_task(1.0, "CountdownTimer");
}

public CountdownTimer() {
    static Float:lastMessageTime;
    new Float:currentTime = get_gametime();

    if ((currentTime - lastMessageTime) < 0.8) {
        set_task(0.2, "CountdownTimer");
        return;
    }

    if (g_CountdownTime > 0) {
        // Show countdown with game type in cyan
        set_hudmessage(0, 255, 255, -1.0, 0.35, 0, 0.8, 0.8, 0.1, 0.1);

        new gameTypeName[32];
        GetGameTypeName(g_GameType, gameTypeName, charsmax(gameTypeName));
        show_hudmessage(0, "%s will start in %d seconds", gameTypeName, g_CountdownTime);

        // Play countdown sound
        new sound[32];
        formatex(sound, charsmax(sound), "fvox/%d.wav", g_CountdownTime);
        emit_sound(0, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM);

        lastMessageTime = currentTime;
        g_CountdownTime--;
        set_task(1.0, "CountdownTimer");
    } else {
        g_CountdownActive = false;
        StartSelectedGame();
    }
}

public StartSelectedGame() {
    // Store start time for calculating elapsed time
    g_StartTime = get_gametime();

    switch(g_GameType) {
        case GAME_FIRSTWRITE: {
            new chars[] = "23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ";
            new output[8];
            for (new i = 0; i < 6; i++) {
                output[i] = chars[random_num(0, strlen(chars) - 1)];
            }
            output[6] = 0;
            copy(g_Answer, charsmax(g_Answer), output);

            set_hudmessage(0, 255, 255, -1.0, 0.35, 0, CHALLENGE_TIMEOUT, CHALLENGE_TIMEOUT);
            show_hudmessage(0, "First to write: %s", output);
            client_print_color(0, print_team_default, "^4[JB]^1 First to write: ^4%s^1", output);
        }

        case GAME_GUESS: {
            new num = random_num(1, 150);
            num_to_str(num, g_Answer, charsmax(g_Answer));

            // Start timer task for guess game
            g_TimeElapsed = CHALLENGE_TIMEOUT;
            set_task(1.0, "UpdateGuessTimer", TASK_GUESS_TIMER);

            UpdateGuessTimer();
        }

        case GAME_MATH: {
            new num1 = random_num(1, 50);
            new num2 = random_num(1, 50);
            new operation = random_num(1, 2);
            new result;

            if (operation == 1) {
                result = num1 + num2;
                num_to_str(result, g_Answer, charsmax(g_Answer));
                set_hudmessage(0, 255, 255, -1.0, 0.35, 0, CHALLENGE_TIMEOUT, CHALLENGE_TIMEOUT);
                show_hudmessage(0, "Math Question: %d + %d = ?", num1, num2);
                client_print_color(0, print_team_default, "^4[JB]^1 Math Question: %d + %d = ?", num1, num2);
            } else {
                result = num1 - num2;
                num_to_str(result, g_Answer, charsmax(g_Answer));
                set_hudmessage(0, 255, 255, -1.0, 0.35, 0, CHALLENGE_TIMEOUT, CHALLENGE_TIMEOUT);
                show_hudmessage(0, "Math Question: %d - %d = ?", num1, num2);
                client_print_color(0, print_team_default, "^4[JB]^1 Math Question: ^4%d ^1- ^4%d^1 = ?", num1, num2);
            }
        }
    }

    set_task(CHALLENGE_TIMEOUT, "EndGameNoWinner");
}

public HandleSay(id) {
    if (!g_GameActive || g_WinnerFound || !is_user_connected(id) || g_CountdownActive)
        return PLUGIN_CONTINUE;

    if (cs_get_user_team(id) != CS_TEAM_T)
        return PLUGIN_CONTINUE;

    new said[32];
    read_args(said, charsmax(said));
    remove_quotes(said);
    trim(said);

    if (strlen(said) < 1)
        return PLUGIN_CONTINUE;

    switch(g_GameType) {
        case GAME_FIRSTWRITE: {
            if (equal(said, g_Answer, strlen(g_Answer))) {
                DeclareWinner(id, "First Write");
                return PLUGIN_HANDLED;
            }
        }

        case GAME_GUESS: {
            if (!is_str_num(said) || g_PlayerGuesses[id] != 0)
                return PLUGIN_CONTINUE;

            new guess = str_to_num(said);
            if (guess < 1 || guess > 150)
                return PLUGIN_CONTINUE;

            g_PlayerGuesses[id] = guess;
            g_GuessCount++;

            client_print_color(id, print_team_default, "^4[JB]^1 You guessed number: ^4%d^1!", guess);

            new answer = str_to_num(g_Answer);
            if (guess == answer) {
                DeclareWinner(id, "Number Guess - Perfect!");
                return PLUGIN_HANDLED;
            }

            new currentDiff = abs(guess - answer);
            if (g_BestGuessPlayer == 0 || currentDiff < abs(g_PlayerGuesses[g_BestGuessPlayer] - answer)) {
                g_BestGuessPlayer = id;
            }

            return PLUGIN_HANDLED;
        }

        case GAME_MATH: {
            if (str_to_num(said) == str_to_num(g_Answer)) {
                DeclareWinner(id, "Math");
                return PLUGIN_HANDLED;
            }
        }
    }

    return PLUGIN_CONTINUE;
}

public DeclareWinner(id, const gameType[]) {
    if (g_WinnerFound || !is_user_connected(id))
        return;

    g_WinnerFound = true;
    g_GameActive = false;
    g_NoResponseCount = 0;

    // Store elapsed time
    g_StartTime = get_gametime() - g_StartTime;

    cs_set_user_team(id, CS_TEAM_CT);
    ExecuteHamB(Ham_CS_RoundRespawn, id);

    new name[32];
    get_user_name(id, name, charsmax(name));
    client_print_color(0, print_team_default, "^4[JB]^3 %s ^1has won the^4 %s ^1and moved to CT! Answer was: %s",
    name, gameType, g_Answer);

    remove_task();
    set_task(5.0, "CheckTerroristCount");
}

public EndGameNoWinner() {
    if (!g_GameActive)
        return;

    if (g_GameType == GAME_GUESS && g_BestGuessPlayer && g_GuessCount > 0) {
        DeclareWinner(g_BestGuessPlayer, "Number Guess - Closest!");
        return;
    }

    g_GameActive = false;
    g_NoResponseCount++;

    client_print_color(0, print_team_default, "^4[JB]^1 Time's up! No one won the challenge.");

    if (g_NoResponseCount >= 2) {
        client_print_color(0, print_team_default, "^4[JB]^1 Starting a new challenge automatically...");
        g_NoResponseCount = 0;
        set_task(3.0, "StartGameCountdown");
    }

    set_task(5.0, "CheckTerroristCount");
}

stock ClearAllHudMessages() {
    // Multiple calls with different parameters to ensure clearing
    set_hudmessage(0, 0, 0, -1.0, 0.35, 0, 0.1, 0.1, 0.0, 0.0);
    show_hudmessage(0, "");

    set_hudmessage(0, 0, 0, -1.0, 0.35, 1, 0.1, 0.1, 0.0, 0.0);
    show_hudmessage(0, " ");

    // Small delay before allowing new messages
    set_task(0.2, "EnableHudMessages");
}

public EnableHudMessages() {
    // This function exists just to provide a delay
    return PLUGIN_CONTINUE;
}

public UpdateGuessTimer() {
    if (!g_GameActive || g_WinnerFound)
        return;

    g_TimeElapsed--;

    if (g_TimeElapsed <= 0) {
        remove_task();
        EndGameNoWinner();
        return;
    }

    set_hudmessage(0, 255, 255, -1.0, 0.35, 0, 9999.0, 1.0, 0.1, 0.1);
    show_hudmessage(0, "Guess the number between 1 and 150!^n^nTime remaining: %.0f seconds", g_TimeElapsed);

    // Ensure the task continues
    set_task(1.0, "UpdateGuessTimer", TASK_GUESS_TIMER);
}

public ResetGameState() {
    g_GameActive = false;
    g_WinnerFound = false;
    g_CountdownActive = false;
    g_NoResponseCount = 0;
    g_GuessCount = 0;
    g_BestGuessPlayer = 0;

    for (new i = 1; i <= MAX_PLAYERS; i++) {
        g_PlayerGuesses[i] = 0;
    }

    // Important: Clear all tasks first
    remove_task();

    // Clear HUD messages
    ClearAllHudMessages();
}

GetGameTypeName(type, output[], len) {
    switch(type) {
        case GAME_FIRSTWRITE: copy(output, len, "First Write Challenge");
        case GAME_GUESS: copy(output, len, "Number Guess Challenge");
        case GAME_MATH: copy(output, len, "Math Challenge");
        default: copy(output, len, "Unknown Challenge");
    }
}