Код: Выделить всё

addons/amxmodx/plugins/

Код: Выделить всё

amx_sql_host    "localhost"
amx_sql_user    "root"
amx_sql_pass    "password"
amx_sql_db      "database"
amx_sql_type    "mysql"

Код: Выделить всё

CREATE TABLE IF NOT EXISTS `connection_stats` (
    `id` INT AUTO_INCREMENT PRIMARY KEY,
    `daily_connections` INT DEFAULT 0,
    `weekly_connections` INT DEFAULT 0,
    `monthly_connections` INT DEFAULT 0,
    `last_reset_day` INT,
    `last_reset_week` INT,
    `last_reset_month` INT,
    `update_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Код: Выделить всё

addons/amxmodx/configs/connection_stats.ini

Код: Выделить всё

#include <amxmodx>
#include <amxmisc>
#include <sqlx>

#define PLUGIN "Connection Statistics"
#define VERSION "2.1"
#define AUTHOR "Legolas"

// Цвет в RGB (желтый)
#define TEXT_COLOR_R 255
#define TEXT_COLOR_G 255
#define TEXT_COLOR_B 0

// Позиция текста (x, y)
#define TEXT_POS_X -1.0
#define TEXT_POS_Y 0.83

// Максимальное количество подключений с одного SteamID за минуту
#define MAX_CONNECTIONS_PER_MINUTE 5

#if !defined isdigit
#define isdigit(%1) ( (%1) >= '0' && (%1) <= '9' )
#endif

// Переменные для хранения статистики
new g_DailyConnections = 0
new g_WeeklyConnections = 0
new g_MonthlyConnections = 0

// Время последнего сброса (формат YYYYMMDD)
new g_LastResetDay
new g_LastResetWeek
new g_LastResetMonth

// Хранилище уникальных SteamID
new Trie:g_DailySteamIDs
new Trie:g_WeeklySteamIDs
new Trie:g_MonthlySteamIDs

// Для защиты от флуда
new Trie:g_RecentConnections
new Array:g_ConnectionTimes

// SQL соединение
new Handle:g_SqlTuple
new g_SqlConnected = 0
new g_SqlTable[32] = "connection_stats"
new Handle:g_SqlConnection

// Параметры SQL подключения
new g_SqlHost[64] = "localhost"
new g_SqlUser[32] = "root"
new g_SqlPass[32] = "password"
new g_SqlDb[32] = "database"
new g_SqlType[10] = "mysql"

public plugin_init() {
    register_plugin(PLUGIN, VERSION, AUTHOR)
    
    register_concmd("amx_reset_stats", "cmd_reset_stats", ADMIN_BAN, "Сбросить статистику подключений")
    
    // Инициализация хранилищ
    g_DailySteamIDs = TrieCreate()
    g_WeeklySteamIDs = TrieCreate()
    g_MonthlySteamIDs = TrieCreate()
    g_RecentConnections = TrieCreate()
    g_ConnectionTimes = ArrayCreate(1)
    
    if(g_DailySteamIDs == Invalid_Trie || g_WeeklySteamIDs == Invalid_Trie || 
       g_MonthlySteamIDs == Invalid_Trie || g_RecentConnections == Invalid_Trie || 
       g_ConnectionTimes == Invalid_Array) {
        set_fail_state("Не удалось создать хранилище данных")
        return
    }
    
    // Подключение к базе данных
    init_sql_connection()
    
    // Загрузка статистики
    set_task(3.0, "delayed_load")
    
    // Периодические задачи
    set_task(1.0, "update_hud_text", _, _, _, "b")
    set_task(300.0, "save_stats", _, _, _, "b")
    set_task(60.0, "clear_old_connections", _, _, _, "b")
    set_task(3600.0, "check_reset", _, _, _, "b")
}

public delayed_load() {
    load_stats()
    check_reset()
}

init_sql_connection() {
    load_sql_config()
    
    new error[256], error_code
    g_SqlTuple = SQL_MakeDbTuple(g_SqlHost, g_SqlUser, g_SqlPass, g_SqlDb)
    
    if(g_SqlTuple == Empty_Handle) {
        log_amx("Ошибка создания SQL кортежа")
        g_SqlConnected = 0
    } else {
        new Handle:connectHandle = SQL_Connect(g_SqlTuple, error_code, error, charsmax(error))
        if(connectHandle == Empty_Handle) {
            log_amx("Ошибка подключения к SQL: %s (код %d)", error, error_code)
            g_SqlConnected = 0
            SQL_FreeHandle(g_SqlTuple)
            g_SqlTuple = Empty_Handle
        } else {
            g_SqlConnected = 1
            g_SqlConnection = connectHandle
            
            // Проверка/создание таблицы
            new query[1024]
            formatex(query, charsmax(query), "CREATE TABLE IF NOT EXISTS `%s` ( \
                `id` INT AUTO_INCREMENT PRIMARY KEY, \
                `daily_connections` INT DEFAULT 0, \
                `weekly_connections` INT DEFAULT 0, \
                `monthly_connections` INT DEFAULT 0, \
                `last_reset_day` INT, \
                `last_reset_week` INT, \
                `last_reset_month` INT, \
                `update_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP \
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8", g_SqlTable)
            
            new Handle:queryHandle = SQL_PrepareQuery(connectHandle, query)
            if(!queryHandle || !SQL_Execute(queryHandle)) {
                if(queryHandle) {
                    SQL_QueryError(queryHandle, error, charsmax(error))
                    log_amx("Ошибка создания таблицы: %s", error)
                    SQL_FreeHandle(queryHandle)
                }
                g_SqlConnected = 0
            } else {
                SQL_FreeHandle(queryHandle)
                log_amx("Таблица %s успешно создана/проверена", g_SqlTable)
                
                // Создаем таблицы для SteamID, если их нет
                if(g_SqlConnected) {
                    create_steamid_tables()
                }
            }
        }
    }
}

create_steamid_tables() {
    new error[256]
    
    // Таблица для ежедневных SteamID
    new query[512]
    formatex(query, charsmax(query), "CREATE TABLE IF NOT EXISTS `daily_steamids` ( \
        `steamid` VARCHAR(32) PRIMARY KEY, \
        `last_day` INT \
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8")
    
    new Handle:queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    if(!SQL_Execute(queryHandle)) {
        SQL_QueryError(queryHandle, error, charsmax(error))
        log_amx("Ошибка создания таблицы daily_steamids: %s", error)
    }
    SQL_FreeHandle(queryHandle)
    
    // Таблица для еженедельных SteamID
    formatex(query, charsmax(query), "CREATE TABLE IF NOT EXISTS `weekly_steamids` ( \
        `steamid` VARCHAR(32) PRIMARY KEY \
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8")
    
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    if(!SQL_Execute(queryHandle)) {
        SQL_QueryError(queryHandle, error, charsmax(error))
        log_amx("Ошибка создания таблицы weekly_steamids: %s", error)
    }
    SQL_FreeHandle(queryHandle)
    
    // Таблица для ежемесячных SteamID
    formatex(query, charsmax(query), "CREATE TABLE IF NOT EXISTS `monthly_steamids` ( \
        `steamid` VARCHAR(32) PRIMARY KEY \
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8")
    
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    if(!SQL_Execute(queryHandle)) {
        SQL_QueryError(queryHandle, error, charsmax(error))
        log_amx("Ошибка создания таблицы monthly_steamids: %s", error)
    }
    SQL_FreeHandle(queryHandle)
}

load_sql_config() {
    new configsDir[64], filePath[128]
    get_configsdir(configsDir, charsmax(configsDir))
    format(filePath, charsmax(filePath), "%s/sql.cfg", configsDir)
    
    if(!file_exists(filePath)) {
        log_amx("Файл конфигурации SQL не найден, используются значения по умолчанию")
        return
    }
    
    new file = fopen(filePath, "rt")
    if(!file) {
        log_amx("Не удалось открыть файл конфигурации SQL")
        return
    }
    
    new line[128], key[32], value[64]
    while(!feof(file)) {
        fgets(file, line, charsmax(line))
        trim(line)
        
        if(!line[0] || line[0] == ';' || (line[0] == '/' && line[1] == '/'))
            continue
            
        if(parse(line, key, charsmax(key), value, charsmax(value)) != 2)
            continue
            
        replace_all(value, charsmax(value), "^"", "")
        
        if(equal(key, "amx_sql_host")) copy(g_SqlHost, charsmax(g_SqlHost), value)
        else if(equal(key, "amx_sql_user")) copy(g_SqlUser, charsmax(g_SqlUser), value)
        else if(equal(key, "amx_sql_pass")) copy(g_SqlPass, charsmax(g_SqlPass), value)
        else if(equal(key, "amx_sql_db")) copy(g_SqlDb, charsmax(g_SqlDb), value)
        else if(equal(key, "amx_sql_type")) copy(g_SqlType, charsmax(g_SqlType), value)
    }
    
    fclose(file)
}

public client_authorized(id) {
    if(!is_user_bot(id) && !is_user_hltv(id)) {
        new steamid[32]
        get_user_authid(id, steamid, 31)
        
        if(!is_valid_steamid(steamid)) {
            log_amx("Неверный SteamID: %s", steamid)
            return
        }
        
        // Проверка на флуд
        if(!check_flood_protection(steamid)) {
            return
        }
        
        // Обновление статистики
        update_connection_stats(steamid)
        
        // Логирование для отладки
        server_print("Подключение: %s | День: %d (%s) | Неделя: %d | Месяц: %d", 
            steamid, g_DailyConnections, 
            TrieKeyExists(g_DailySteamIDs, steamid) ? "уже был" : "новый",
            g_WeeklyConnections, g_MonthlyConnections)
    }
}

bool:check_flood_protection(const steamid[]) {
    new current_time = get_systime()
    new connection_count = 0
    new Array:steamid_times
    
    if(TrieGetCell(g_RecentConnections, steamid, steamid_times)) {
        new size = ArraySize(steamid_times)
        for(new i = 0; i < size; i++) {
            if(current_time - ArrayGetCell(steamid_times, i) <= 60) {
                connection_count++
            }
        }
        
        if(connection_count >= MAX_CONNECTIONS_PER_MINUTE) {
            log_amx("Превышено максимальное количество подключений с SteamID %s (%d за минуту)", steamid, connection_count)
            return false
        }
    } else {
        steamid_times = ArrayCreate(1)
        TrieSetCell(g_RecentConnections, steamid, steamid_times)
    }
    
    ArrayPushCell(steamid_times, current_time)
    ArrayPushCell(g_ConnectionTimes, current_time)
    return true
}

update_connection_stats(const steamid[]) {
    // Получаем текущую дату в формате YYYYMMDD
    new date_str[16]
    get_time("%Y%m%d", date_str, charsmax(date_str))
    new today = str_to_num(date_str)
    
    // Дневная статистика
    if(!TrieKeyExists(g_DailySteamIDs, steamid)) {
        TrieSetCell(g_DailySteamIDs, steamid, today)
        g_DailyConnections++
    } else {
        new last_day
        TrieGetCell(g_DailySteamIDs, steamid, last_day)
        if(last_day != today) {
            TrieSetCell(g_DailySteamIDs, steamid, today)
            g_DailyConnections++
        }
    }
    
    // Недельная статистика
    if(!TrieKeyExists(g_WeeklySteamIDs, steamid)) {
        TrieSetCell(g_WeeklySteamIDs, steamid, 1)
        g_WeeklyConnections++
    }
    
    // Месячная статистика
    if(!TrieKeyExists(g_MonthlySteamIDs, steamid)) {
        TrieSetCell(g_MonthlySteamIDs, steamid, 1)
        g_MonthlyConnections++
    }
}

public check_reset() {
    new date_str[16], time_str[16]
    get_time("%Y%m%d", date_str, charsmax(date_str))
    get_time("%H%M", time_str, charsmax(time_str))
    
    new today = str_to_num(date_str)
    new current_time = str_to_num(time_str)
    
    // Сброс дневной статистики
    if(today != g_LastResetDay) {
        g_DailyConnections = 0
        g_LastResetDay = today
        TrieClear(g_DailySteamIDs)
        save_stats()
    }
    
    // Сброс недельной статистики (каждый понедельник в 00:00)
    if((current_time == 0) && (get_weekday() == 1) && (today != g_LastResetWeek)) {
        g_WeeklyConnections = 0
        g_LastResetWeek = today
        TrieClear(g_WeeklySteamIDs)
        save_stats()
    }
    
    // Сброс месячной статистики (первое число месяца в 00:00)
    new month_day = str_to_num(date_str[6]) // Получаем день месяца из строки YYYYMMDD
    if((month_day == 1) && (current_time == 0) && (today != g_LastResetMonth)) {
        g_MonthlyConnections = 0
        g_LastResetMonth = today
        TrieClear(g_MonthlySteamIDs)
        save_stats()
    }
}

get_weekday() {
    new time_str[16]
    get_time("%Y%m%d", time_str, charsmax(time_str))
    
    new year = str_to_num(time_str[0]) * 1000 + str_to_num(time_str[1]) * 100 + 
               str_to_num(time_str[2]) * 10 + str_to_num(time_str[3])
    new month = str_to_num(time_str[4]) * 10 + str_to_num(time_str[5])
    new day = str_to_num(time_str[6]) * 10 + str_to_num(time_str[7])
    
    if(month < 3) {
        month += 12
        year--
    }
    
    new c = year / 100
    year = year % 100
    new weekday = (day + ((month + 1) * 26)/10 + year + year/4 + c/4 - 2*c) % 7
    if(weekday < 0) weekday += 7
    
    return weekday
}

public update_hud_text() {
    static message[256]
    format(message, 255, "Игроков за:^nдень: %d | неделю: %d | месяц: %d", 
        g_DailyConnections, g_WeeklyConnections, g_MonthlyConnections)
    
    set_hudmessage(TEXT_COLOR_R, TEXT_COLOR_G, TEXT_COLOR_B, TEXT_POS_X, TEXT_POS_Y, 0, 6.0, 1.1, 0.0, 0.0, -1)
    show_hudmessage(0, message)
}

public load_stats() {
    if(g_SqlConnected) {
        new query[512], error[256], Handle:queryHandle
        
        // Загрузка основной статистики
        formatex(query, 511, "SELECT daily_connections, weekly_connections, monthly_connections, \
                last_reset_day, last_reset_week, last_reset_month \
                FROM %s ORDER BY update_time DESC LIMIT 1", g_SqlTable)
        
        queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
        
        if(SQL_Execute(queryHandle)) {
            if(SQL_NumResults(queryHandle) > 0) {
                g_DailyConnections = SQL_ReadResult(queryHandle, 0)
                g_WeeklyConnections = SQL_ReadResult(queryHandle, 1)
                g_MonthlyConnections = SQL_ReadResult(queryHandle, 2)
                g_LastResetDay = SQL_ReadResult(queryHandle, 3)
                g_LastResetWeek = SQL_ReadResult(queryHandle, 4)
                g_LastResetMonth = SQL_ReadResult(queryHandle, 5)
                
                log_amx("Статистика загружена: день=%d, неделя=%d, месяц=%d", 
                    g_DailyConnections, g_WeeklyConnections, g_MonthlyConnections)
            }
        } else {
            SQL_QueryError(queryHandle, error, 255)
            log_amx("Ошибка загрузки статистики: %s", error)
        }
        
        SQL_FreeHandle(queryHandle)
        
        // Загрузка SteamID
        load_steamids_from_db()
    } else {
        new file_path[256]
        get_configsdir(file_path, 255)
        format(file_path, 255, "%s/connection_stats.ini", file_path)
        
        if(file_exists(file_path)) {
            new data[128], key[32], value[32]
            new file = fopen(file_path, "rt")
            
            if(file) {
                while(!feof(file)) {
                    fgets(file, data, 127)
                    parse(data, key, 31, value, 31)
                    
                    if(equal(key, "DAILY")) g_DailyConnections = str_to_num(value)
                    else if(equal(key, "WEEKLY")) g_WeeklyConnections = str_to_num(value)
                    else if(equal(key, "MONTHLY")) g_MonthlyConnections = str_to_num(value)
                    else if(equal(key, "LAST_DAY")) g_LastResetDay = str_to_num(value)
                    else if(equal(key, "LAST_WEEK")) g_LastResetWeek = str_to_num(value)
                    else if(equal(key, "LAST_MONTH")) g_LastResetMonth = str_to_num(value)
                }
                fclose(file)
            }
        }
        
        // Загрузка SteamID из файлов
        load_steamids_from_files()
    }
}

load_steamids_from_db() {
    if(!g_SqlConnected) return
    
    new today = get_today_date()
    
    // Загрузка daily SteamID
    new query[512], Handle:queryHandle
    formatex(query, charsmax(query), "SELECT steamid, last_day FROM daily_steamids")
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    
    if(SQL_Execute(queryHandle)) {
        new steamid[32], last_day
        while(SQL_MoreResults(queryHandle)) {
            SQL_ReadResult(queryHandle, 0, steamid, charsmax(steamid))
            last_day = SQL_ReadResult(queryHandle, 1)
            
            // Добавляем только если дата совпадает с текущим днем
            if(last_day == today) {
                TrieSetCell(g_DailySteamIDs, steamid, last_day)
            }
            
            SQL_NextRow(queryHandle)
        }
    }
    SQL_FreeHandle(queryHandle)
    
    // Загрузка weekly SteamID
    formatex(query, charsmax(query), "SELECT steamid FROM weekly_steamids")
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    
    if(SQL_Execute(queryHandle)) {
        new steamid[32]
        while(SQL_MoreResults(queryHandle)) {
            SQL_ReadResult(queryHandle, 0, steamid, charsmax(steamid))
            TrieSetCell(g_WeeklySteamIDs, steamid, 1)
            SQL_NextRow(queryHandle)
        }
    }
    SQL_FreeHandle(queryHandle)
    
    // Загрузка monthly SteamID
    formatex(query, charsmax(query), "SELECT steamid FROM monthly_steamids")
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    
    if(SQL_Execute(queryHandle)) {
        new steamid[32]
        while(SQL_MoreResults(queryHandle)) {
            SQL_ReadResult(queryHandle, 0, steamid, charsmax(steamid))
            TrieSetCell(g_MonthlySteamIDs, steamid, 1)
            SQL_NextRow(queryHandle)
        }
    }
    SQL_FreeHandle(queryHandle)
}

load_steamids_from_files() {
    new today = get_today_date()
    new file_path[256]
    
    // Загрузка daily SteamID
    get_configsdir(file_path, 255)
    format(file_path, 255, "%s/daily_steamids.ini", file_path)
    
    if(file_exists(file_path)) {
        new file = fopen(file_path, "rt")
        if(file) {
            new line[64], steamid[32], last_day
            while(!feof(file)) {
                fgets(file, line, charsmax(line))
                trim(line)
                if(parse(line, steamid, charsmax(steamid), last_day) == 2) {
                    // Добавляем только если дата совпадает с текущим днем
                    if(last_day == today) {
                        TrieSetCell(g_DailySteamIDs, steamid, last_day)
                    }
                }
            }
            fclose(file)
        }
    }
    
    // Загрузка weekly SteamID
    get_configsdir(file_path, 255)
    format(file_path, 255, "%s/weekly_steamids.ini", file_path)
    
    if(file_exists(file_path)) {
        new file = fopen(file_path, "rt")
        if(file) {
            new line[64]
            while(!feof(file)) {
                fgets(file, line, charsmax(line))
                trim(line)
                if(line[0]) {
                    TrieSetCell(g_WeeklySteamIDs, line, 1)
                }
            }
            fclose(file)
        }
    }
    
    // Загрузка monthly SteamID
    get_configsdir(file_path, 255)
    format(file_path, 255, "%s/monthly_steamids.ini", file_path)
    
    if(file_exists(file_path)) {
        new file = fopen(file_path, "rt")
        if(file) {
            new line[64]
            while(!feof(file)) {
                fgets(file, line, charsmax(line))
                trim(line)
                if(line[0]) {
                    TrieSetCell(g_MonthlySteamIDs, line, 1)
                }
            }
            fclose(file)
        }
    }
}

get_today_date() {
    new date_str[16]
    get_time("%Y%m%d", date_str, charsmax(date_str))
    return str_to_num(date_str)
}

public save_stats() {
    if(g_SqlConnected) {
        new query[1024], error[256], Handle:queryHandle
        
        // Сохранение основной статистики
        formatex(query, 1023, "INSERT INTO %s (daily_connections, weekly_connections, \
                monthly_connections, last_reset_day, last_reset_week, last_reset_month) \
                VALUES (%d, %d, %d, %d, %d, %d) \
                ON DUPLICATE KEY UPDATE \
                daily_connections = VALUES(daily_connections), \
                weekly_connections = VALUES(weekly_connections), \
                monthly_connections = VALUES(monthly_connections), \
                last_reset_day = VALUES(last_reset_day), \
                last_reset_week = VALUES(last_reset_week), \
                last_reset_month = VALUES(last_reset_month)", 
                g_SqlTable,
                g_DailyConnections, g_WeeklyConnections, g_MonthlyConnections,
                g_LastResetDay, g_LastResetWeek, g_LastResetMonth)
        
        queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
        
        if(!SQL_Execute(queryHandle)) {
            SQL_QueryError(queryHandle, error, 255)
            log_amx("Ошибка сохранения статистики: %s", error)
        }
        
        SQL_FreeHandle(queryHandle)
        
        // Сохранение SteamID
        save_steamids_to_db()
    } else {
        new file_path[256]
        get_configsdir(file_path, 255)
        format(file_path, 255, "%s/connection_stats.ini", file_path)
        
        new file = fopen(file_path, "wt")
        if(file) {
            fprintf(file, "DAILY %d^n", g_DailyConnections)
            fprintf(file, "WEEKLY %d^n", g_WeeklyConnections)
            fprintf(file, "MONTHLY %d^n", g_MonthlyConnections)
            fprintf(file, "LAST_DAY %d^n", g_LastResetDay)
            fprintf(file, "LAST_WEEK %d^n", g_LastResetWeek)
            fprintf(file, "LAST_MONTH %d^n", g_LastResetMonth)
            fclose(file)
        }
        
        // Сохранение SteamID в файлы
        save_steamids_to_files()
    }
}

save_steamids_to_db() {
    if(!g_SqlConnected) return
    
    new Handle:queryHandle
    new query[512]
    
    // Очистка старых данных
    formatex(query, charsmax(query), "TRUNCATE TABLE daily_steamids")
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    SQL_Execute(queryHandle)
    SQL_FreeHandle(queryHandle)
    
    formatex(query, charsmax(query), "TRUNCATE TABLE weekly_steamids")
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    SQL_Execute(queryHandle)
    SQL_FreeHandle(queryHandle)
    
    formatex(query, charsmax(query), "TRUNCATE TABLE monthly_steamids")
    queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
    SQL_Execute(queryHandle)
    SQL_FreeHandle(queryHandle)
    
    // Сохранение daily SteamID
    new TrieIter:iter = TrieIterCreate(g_DailySteamIDs)
    new steamid[32], last_day
    
    while(!TrieIterEnded(iter)) {
        TrieIterGetKey(iter, steamid, charsmax(steamid))
        TrieIterGetCell(iter, last_day)
        
        formatex(query, charsmax(query), "INSERT INTO daily_steamids (steamid, last_day) VALUES ('%s', %d)", steamid, last_day)
        queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
        SQL_Execute(queryHandle)
        SQL_FreeHandle(queryHandle)
        
        TrieIterNext(iter)
    }
    TrieIterDestroy(iter)
    
    // Сохранение weekly SteamID
    iter = TrieIterCreate(g_WeeklySteamIDs)
    
    while(!TrieIterEnded(iter)) {
        TrieIterGetKey(iter, steamid, charsmax(steamid))
        
        formatex(query, charsmax(query), "INSERT INTO weekly_steamids (steamid) VALUES ('%s')", steamid)
        queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
        SQL_Execute(queryHandle)
        SQL_FreeHandle(queryHandle)
        
        TrieIterNext(iter)
    }
    TrieIterDestroy(iter)
    
    // Сохранение monthly SteamID
    iter = TrieIterCreate(g_MonthlySteamIDs)
    
    while(!TrieIterEnded(iter)) {
        TrieIterGetKey(iter, steamid, charsmax(steamid))
        
        formatex(query, charsmax(query), "INSERT INTO monthly_steamids (steamid) VALUES ('%s')", steamid)
        queryHandle = SQL_PrepareQuery(g_SqlConnection, query)
        SQL_Execute(queryHandle)
        SQL_FreeHandle(queryHandle)
        
        TrieIterNext(iter)
    }
    TrieIterDestroy(iter)
}

save_steamids_to_files() {
    new file_path[256]
    
    // Сохранение daily SteamID
    get_configsdir(file_path, 255)
    format(file_path, 255, "%s/daily_steamids.ini", file_path)
    
    new file = fopen(file_path, "wt")
    if(file) {
        new TrieIter:iter = TrieIterCreate(g_DailySteamIDs)
        new steamid[32], last_day
        
        while(!TrieIterEnded(iter)) {
            TrieIterGetKey(iter, steamid, charsmax(steamid))
            TrieIterGetCell(iter, last_day)
            fprintf(file, "%s %d^n", steamid, last_day)
            TrieIterNext(iter)
        }
        TrieIterDestroy(iter)
        fclose(file)
    }
    
    // Сохранение weekly SteamID
    get_configsdir(file_path, 255)
    format(file_path, 255, "%s/weekly_steamids.ini", file_path)
    
    file = fopen(file_path, "wt")
    if(file) {
        new TrieIter:iter = TrieIterCreate(g_WeeklySteamIDs)
        new steamid[32]
        
        while(!TrieIterEnded(iter)) {
            TrieIterGetKey(iter, steamid, charsmax(steamid))
            fprintf(file, "%s^n", steamid)
            TrieIterNext(iter)
        }
        TrieIterDestroy(iter)
        fclose(file)
    }
    
    // Сохранение monthly SteamID
    get_configsdir(file_path, 255)
    format(file_path, 255, "%s/monthly_steamids.ini", file_path)
    
    file = fopen(file_path, "wt")
    if(file) {
        new TrieIter:iter = TrieIterCreate(g_MonthlySteamIDs)
        new steamid[32]
        
        while(!TrieIterEnded(iter)) {
            TrieIterGetKey(iter, steamid, charsmax(steamid))
            fprintf(file, "%s^n", steamid)
            TrieIterNext(iter)
        }
        TrieIterDestroy(iter)
        fclose(file)
    }
}

public clear_old_connections() {
    new current_time = get_systime()
    new steamid[32], Array:steamid_times, Array:temp_times
    
    new TrieIter:iter = TrieIterCreate(g_RecentConnections)
    
    while(!TrieIterEnded(iter)) {
        TrieIterGetKey(iter, steamid, charsmax(steamid))
        TrieIterGetCell(iter, steamid_times)
        
        temp_times = ArrayCreate(1)
        new size = ArraySize(steamid_times)
        
        for(new i = 0; i < size; i++) {
            new time = ArrayGetCell(steamid_times, i)
            if(current_time - time <= 60) {
                ArrayPushCell(temp_times, time)
            }
        }
        
        if(ArraySize(temp_times) > 0) {
            ArrayDestroy(steamid_times)
            TrieSetCell(g_RecentConnections, steamid, temp_times)
        } else {
            ArrayDestroy(steamid_times)
            TrieDeleteKey(g_RecentConnections, steamid)
        }
        
        TrieIterNext(iter)
    }
    
    TrieIterDestroy(iter)
}

public cmd_reset_stats(id, level, cid) {
    if(!cmd_access(id, level, cid, 1)) {
        console_print(id, "У вас нет доступа к этой команде")
        return PLUGIN_HANDLED
    }
    
    new date_str[16]
    get_time("%Y%m%d", date_str, charsmax(date_str))
    new today = str_to_num(date_str)
    
    g_DailyConnections = 0
    g_WeeklyConnections = 0
    g_MonthlyConnections = 0
    
    g_LastResetDay = today
    g_LastResetWeek = today
    g_LastResetMonth = today
    
    TrieClear(g_DailySteamIDs)
    TrieClear(g_WeeklySteamIDs)
    TrieClear(g_MonthlySteamIDs)
    
    save_stats()
    
    console_print(id, "Статистика сброшена")
    client_print(0, print_chat, "Администратор сбросил статистику подключений")
    return PLUGIN_HANDLED
}

bool:is_valid_steamid(const steamid[]) {
    if(strlen(steamid) < 11) return false
    
    if(steamid[0] != 'S' || steamid[1] != 'T' || steamid[2] != 'E' || 
       steamid[3] != 'A' || steamid[4] != 'M' || steamid[5] != '_')
        return false
    
    new colon1 = -1, colon2 = -1
    for(new i = 6; steamid[i]; i++) {
        if(steamid[i] == ':') {
            if(colon1 == -1) colon1 = i
            else if(colon2 == -1) colon2 = i
            else return false
        }
    }
    
    if(colon1 == -1 || colon2 == -1) return false
    
    new part1[2]
    copy(part1, 1, steamid[6])
    if(!equal(part1, "0") && !equal(part1, "1")) return false
    
    new part2[16]
    copy(part2, charsmax(part2), steamid[colon1 + 1])
    part2[colon2 - colon1 - 1] = 0
    
    if(!equal(part2, "0") && !equal(part2, "1")) return false
    
    for(new i = colon2 + 1; steamid[i]; i++) {
        if(!isdigit(steamid[i])) return false
    }
    
    return true
}

public plugin_end() {
    save_stats()
    
    if(g_DailySteamIDs != Invalid_Trie) TrieDestroy(g_DailySteamIDs)
    if(g_WeeklySteamIDs != Invalid_Trie) TrieDestroy(g_WeeklySteamIDs)
    if(g_MonthlySteamIDs != Invalid_Trie) TrieDestroy(g_MonthlySteamIDs)
    
    if(g_RecentConnections != Invalid_Trie) {
        new Array:steamid_times
        new TrieIter:iter = TrieIterCreate(g_RecentConnections)
        
        while(!TrieIterEnded(iter)) {
            TrieIterGetCell(iter, steamid_times)
            if(steamid_times != Invalid_Array) ArrayDestroy(steamid_times)
            TrieIterNext(iter)
        }
        
        TrieIterDestroy(iter)
        TrieDestroy(g_RecentConnections)
    }
    
    if(g_ConnectionTimes != Invalid_Array) ArrayDestroy(g_ConnectionTimes)
    if(g_SqlConnection != Empty_Handle) SQL_FreeHandle(g_SqlConnection)
    if(g_SqlTuple != Empty_Handle) SQL_FreeHandle(g_SqlTuple)
}