-- Получение ID карты для арены
-- Функция циклически перебирает доступные карты арены (3 варианта)
-- и создает новый экземпляр карты для матча
function GetArenaMapID()
    -- Увеличиваем счетчик номеров карт
    ArenaMapNum = ArenaMapNum + 1

    -- Сбрасываем счетчик при достижении максимального значения
    if ArenaMapNum >= 1000 then
        ArenaMapNum = 1
    end

    -- Создаем новый экземпляр карты арены
    map.CreateInstance(ArenaMap[ArenaMapNum % 3].ArenaMapID, ArenaMapNum)

    -- Возвращаем ID карты и номер экземпляра
    return ArenaMap[ArenaMapNum % 3].ArenaMapID, ArenaMapNum
end

-- Рандомизация игроков для равномерного распределения по командам
-- Функция перемешивает игроков случайным образом для баланса команд
function PlayerRandom_Arena(RoleID1, RoleID2, RoleID3, RoleID4, RoleID5, RoleID6)
    -- Создаем массив индексов игроков
    local table_Role = {1, 2, 3, 4, 5, 6}
    local table_Role1 = {}

    -- Алгоритм случайного перемешивания Фишера-Йетса
    for i = 1, 6 do
        local index = math.random(7 - i)
        table_Role1[i] = table_Role[index]
        table.remove(table_Role, index)
    end

    -- Создаем массив ID игроков в исходном порядке
    local iRole = {}  -- Массив ID игроков
    iRole[1] = RoleID1
    iRole[2] = RoleID2
    iRole[3] = RoleID3
    iRole[4] = RoleID4
    iRole[5] = RoleID5
    iRole[6] = RoleID6

    -- Возвращаем игроков в перемешанном порядке
    return iRole[table_Role1[1]], iRole[table_Role1[2]], iRole[table_Role1[3]], iRole[table_Role1[4]], iRole[table_Role1[5]], iRole[table_Role1[6]]
end

-- Определение значений и распределение игроков по командам арены
-- Функция инициализирует данные матча и распределяет игроков по командам
function DefineValue_Arena(InstanceID, RoomID, RoleID1, RoleID2, RoleID3, RoleID4, RoleID5, RoleID6)
    -- Получаем текущее время для фиксации времени открытия арены
    local Hour = tonumber(os.date("%H"))
    local Min = tonumber(os.date("%M"))
    local Second = tonumber(os.date("%S"))

    -- Создание структуры данных арены: комната, время открытия, статус битвы, количество игроков в командах, массив ID игроков
    Arena[InstanceID] = {
        Room = RoomID,                                    -- ID комнаты
        OpenTime = Hour * 10000 + Min * 100 + Second,     -- Время открытия в формате HHMMSS
        Battle = 0,                                       -- Статус битвы (0 - ожидание, 1 - активна)
        RedNum = 0,                                       -- Количество игроков в красной команде
        BlueNum = 0,                                      -- Количество игроков в синей команде
        Player = {RoleID1, RoleID2, RoleID3, RoleID4, RoleID5, RoleID6}  -- Массив ID всех игроков
    }

    -- Массив ID игроков для обработки
    local RoleID = {}
    RoleID[1] = RoleID1
    RoleID[2] = RoleID2
    RoleID[3] = RoleID3
    RoleID[4] = RoleID4
    RoleID[5] = RoleID5
    RoleID[6] = RoleID6

    -- Переменные для подсчета суммарных рейтингов команд
    local TotalPoint_Red = 0
    local TotalPoint_Blue = 0

    -- Распределяем игроков по командам и инициализируем их данные
    for i = 1, 6 do
        local MapID, Instance_ID = role.GetRoleMapID(RoleID[i])
        if i <= 3 then
            -- Красная команда (первые 3 игрока)
            if ArenaPlayer[RoleID[i]] == nil then
                ArenaPlayer[RoleID[i]] = {Now = 0, Info = {}}
            end
            ArenaPlayer[RoleID[i]].Now = InstanceID

            -- Создание профиля игрока: команда, убийства, рейтинг, очки противника, получаемые очки, победа, победы в арене, общее количество участий
            ArenaPlayer[RoleID[i]].Info[InstanceID] = {
                Side = "red",                                    -- Команда игрока
                Kill = 0,                                        -- Количество убийств
                RankPoint = role.GetRoleAttValue(MapID, Instance_ID, RoleID[i], 79),  -- Текущий рейтинг
                EnemyPoint = 0,                                  -- Суммарный рейтинг противника
                GetRankPoint = 0,                                -- Получаемые очки рейтинга
                Win = 0,                                         -- Флаг победы (0 - нет, 1 - да)
                WinTimes = role.GetRoleScriptData(RoleID[i], 1, RoleDataType["WinTimes_Arena"]),  -- Общее количество побед
                TotleTimes = role.GetRoleScriptData(RoleID[i], 1, RoleDataType["TotleTimes_Arena"])   -- Общее количество участий
            }
            TotalPoint_Red = TotalPoint_Red + ArenaPlayer[RoleID[i]].Info[InstanceID].RankPoint
        else
            -- Синяя команда (остальные 3 игрока)
            if ArenaPlayer[RoleID[i]] == nil then
                ArenaPlayer[RoleID[i]] = {Now = 0, Info = {}}
            end
            ArenaPlayer[RoleID[i]].Now = InstanceID

            ArenaPlayer[RoleID[i]].Info[InstanceID] = {
                Side = "blue",                                   -- Команда игрока
                Kill = 0,                                        -- Количество убийств
                RankPoint = role.GetRoleAttValue(MapID, Instance_ID, RoleID[i], 79),  -- Текущий рейтинг
                EnemyPoint = 0,                                  -- Суммарный рейтинг противника
                GetRankPoint = 0,                                -- Получаемые очки рейтинга
                Win = 0,                                         -- Флаг победы (0 - нет, 1 - да)
                WinTimes = role.GetRoleScriptData(RoleID[i], 1, RoleDataType["WinTimes_Arena"]),  -- Общее количество побед
                TotleTimes = role.GetRoleScriptData(RoleID[i], 1, RoleDataType["TotleTimes_Arena"])   -- Общее количество участий
            }
            TotalPoint_Blue = TotalPoint_Blue + ArenaPlayer[RoleID[i]].Info[InstanceID].RankPoint
        end
    end

    -- Устанавливаем суммарный рейтинг противника для каждой команды
    for i = 1, 6 do
        if i <= 3 then
            -- Для красной команды противник - синяя
            ArenaPlayer[RoleID[i]].Info[InstanceID].EnemyPoint = TotalPoint_Blue
        else
            -- Для синей команды противник - красная
            ArenaPlayer[RoleID[i]].Info[InstanceID].EnemyPoint = TotalPoint_Red
        end
    end
end

-- Очистка данных арены после завершения
-- Функция удаляет все данные матча и очищает информацию об игроках
function RemoveValue_Arena(InstanceID)
    -- Проверяем существование данных арены
    if Arena[InstanceID] ~= nil then
        -- Очищаем данные для каждого игрока матча
        for i = 1, 6 do
            local playerID = Arena[InstanceID].Player[i]
            if ArenaPlayer[playerID] ~= nil then
                -- Удаляем информацию о конкретном матче
                if ArenaPlayer[playerID].Info[InstanceID] ~= nil then
                    ArenaPlayer[playerID].Info[InstanceID] = nil
                end

                -- Сбрасываем текущий InstanceID игрока
                ArenaPlayer[playerID].Now = 0

                -- Если у игрока нет активных матчей, удаляем его из ArenaPlayer
                local hasActiveMatches = false
                for k, v in pairs(ArenaPlayer[playerID].Info) do
                    if k ~= nil then
                        hasActiveMatches = true
                        break
                    end
                end

                if not hasActiveMatches then
                    ArenaPlayer[playerID] = nil
                end
            end
        end

        -- Удаляем данные самого матча
        Arena[InstanceID] = nil
    end
end

-- Получение текущего InstanceID арены для игрока
function GetNowArenaInstanceID(RoleID)
    -- Проверяем корректность входных параметров
    if RoleID == nil then
        return 0
    end

    local InstanceID_Now = 0
    if ArenaPlayer[RoleID] ~= nil and ArenaPlayer[RoleID].Now ~= nil then
        InstanceID_Now = ArenaPlayer[RoleID].Now
    end
    return InstanceID_Now
end

-- Расчет очков за победу в арене
-- Формула: (средний рейтинг противника - рейтинг игрока) / 30 + 10, минимум 3 очка
function Win_Point_Arena(InstanceID, RoleID)
    -- Получаем MapID для текущего игрока
    local MapID, _ = role.GetRoleMapID(RoleID)
    if MapID == nil then
        return 0  -- Если игрок не найден, возвращаем 0
    end

    -- Проверяем и добавляем квестовый предмет, если нужно
    local a = role.GetRoleItemNum(RoleID, 6600884)
    if role.IsRoleHaveQuest(MapID, InstanceID, RoleID, 30011) == true and a == 0 then
        role.QuestAddRoleItem(MapID, InstanceID, RoleID, 30011, 6600884, 1, -1, 420)
    end

    -- Проверяем существование данных игрока в матче
    if ArenaPlayer[RoleID] ~= nil and ArenaPlayer[RoleID].Info[InstanceID] ~= nil then
        -- Расчет очков: (EnemyPoint/3 - RankPoint) / 30 + 10
        local enemyAvgRating = ArenaPlayer[RoleID].Info[InstanceID].EnemyPoint / 3
        local playerRating = ArenaPlayer[RoleID].Info[InstanceID].RankPoint
        local k = math.floor((enemyAvgRating - playerRating) / 30) + 10

        -- Минимум 3 очка за победу
        if k >= 3 then
            return k
        else
            return 3
        end
    else
        return 0
    end
end

-- Расчет штрафа за поражение в арене
-- Штраф зависит от рейтинга игрока: чем выше рейтинг, тем больше штраф
function Lose_Point_Arena(InstanceID, RoleID)
    -- Проверяем существование данных игрока в матче
    if ArenaPlayer[RoleID] ~= nil and ArenaPlayer[RoleID].Info[InstanceID] ~= nil then
        local rankPoint = ArenaPlayer[RoleID].Info[InstanceID].RankPoint

        -- Градация штрафа по рейтингу
        if rankPoint <= 50 then
            return 0        -- Новички не теряют очки
        elseif rankPoint <= 100 then
            return 3        -- Маленький штраф для низкого рейтинга
        elseif rankPoint <= 150 then
            return 5        -- Средний штраф
        elseif rankPoint <= 250 then
            return 8        -- Большой штраф
        elseif rankPoint > 250 then
            -- Прогрессивный штраф для высоких рейтингов: каждые 100 очков добавляют 3 штрафа
            return math.floor((rankPoint - 250) / 100) * 3 + 8
        else
            return 0
        end
    else
        return 0
    end
end

-- Добавление игрока в команду арены
-- Функция управляет формированием команд в зависимости от цвета игрока
function LetPlayerJoinTeam(MapID, InstanceID, RoleID)
    -- Проверяем входные параметры
    if MapID == nil or InstanceID == nil or RoleID == nil then
        return
    end

    -- Удаляем игрока из старой команды, если он в ней состоял
    local TeamID_Old = role.IsRoleHaveTeam(MapID, InstanceID, RoleID)
    if TeamID_Old ~= nil and TeamID_Old ~= 4294967295 then
        role.LetRoleLeaveTeam(TeamID_Old, RoleID)
    end

    -- Проверяем существование данных арены
    if Arena[InstanceID] ~= nil then
        if ArenaPlayer[RoleID] ~= nil and ArenaPlayer[RoleID].Info[InstanceID] ~= nil then
            local playerSide = ArenaPlayer[RoleID].Info[InstanceID].Side

            if playerSide == "red" then
                -- Обработка для красной команды
                role.SetForceInArena(MapID, InstanceID, RoleID, 1)  -- Устанавливаем силу арены (1 - красная)

                if Arena[InstanceID].RedNum == 0 then
                    -- Первый игрок в команде
                    Arena[InstanceID].RedNum = Arena[InstanceID].RedNum + 1
                elseif Arena[InstanceID].RedNum == 1 then
                    -- Второй игрок - создаем команду
                    Arena[InstanceID].RedNum = Arena[InstanceID].RedNum + 1
                    local RoleID2 = 0

                    -- Ищем первого доступного союзника
                    for i = 1, 3 do
                        local Map_ID, Instance_ID = role.GetRoleMapID(Arena[InstanceID].Player[i])
                        if Arena[InstanceID].Player[i] ~= RoleID and Map_ID == MapID and InstanceID == Instance_ID then
                            RoleID2 = Arena[InstanceID].Player[i]
                            break
                        end
                    end

                    -- Создаем новую команду
                    if RoleID2 ~= 0 then
                        role.CreatANewTeam(RoleID, RoleID2)
                    end
                elseif Arena[InstanceID].RedNum == 2 then
                    -- Третий игрок - присоединяемся к существующей команде
                    Arena[InstanceID].RedNum = Arena[InstanceID].RedNum + 1
                    local RoleID2 = 0

                    -- Ищем любого союзника в команде
                    for i = 1, 3 do
                        if Arena[InstanceID].Player[i] ~= RoleID then
                            RoleID2 = Arena[InstanceID].Player[i]
                            break
                        end
                    end

                    -- Присоединяемся к команде союзника
                    if RoleID2 ~= 0 then
                        local TeamID = role.IsRoleHaveTeam(MapID, InstanceID, RoleID2)
                        if TeamID ~= nil and TeamID ~= 4294967295 then
                            role.LetRoleJoinTeam(TeamID, RoleID)
                        end
                    end
                end
            else
                -- Обработка для синей команды (аналогично красной)
                role.SetForceInArena(MapID, InstanceID, RoleID, 0)  -- Устанавливаем силу арены (0 - синяя)

                if Arena[InstanceID].BlueNum == 0 then
                    -- Первый игрок в команде
                    Arena[InstanceID].BlueNum = Arena[InstanceID].BlueNum + 1
                elseif Arena[InstanceID].BlueNum == 1 then
                    -- Второй игрок - создаем команду
                    Arena[InstanceID].BlueNum = Arena[InstanceID].BlueNum + 1
                    local RoleID2 = 0

                    -- Ищем первого доступного союзника
                    for i = 4, 6 do
                        local Map_ID, Instance_ID = role.GetRoleMapID(Arena[InstanceID].Player[i])
                        if Arena[InstanceID].Player[i] ~= RoleID and Map_ID == MapID and InstanceID == Instance_ID then
                            RoleID2 = Arena[InstanceID].Player[i]
                            break
                        end
                    end

                    -- Создаем новую команду
                    if RoleID2 ~= 0 then
                        role.CreatANewTeam(RoleID, RoleID2)
                    end
                elseif Arena[InstanceID].BlueNum == 2 then
                    -- Третий игрок - присоединяемся к существующей команде
                    Arena[InstanceID].BlueNum = Arena[InstanceID].BlueNum + 1
                    local RoleID2 = 0

                    -- Ищем любого союзника в команде
                    for i = 4, 6 do
                        if Arena[InstanceID].Player[i] ~= RoleID then
                            RoleID2 = Arena[InstanceID].Player[i]
                            break
                        end
                    end

                    -- Присоединяемся к команде союзника
                    if RoleID2 ~= 0 then
                        local TeamID = role.IsRoleHaveTeam(MapID, InstanceID, RoleID2)
                        if TeamID ~= nil and TeamID ~= 4294967295 then
                            role.LetRoleJoinTeam(TeamID, RoleID)
                        end
                    end
                end
            end
        end
    end
end

-- Показ информации о противниках в арене
-- Condition: 1 - показать всех противников с их состоянием, 2 - показать живых, 3 - показать мертвых
function ShowEnemyInformation(MapID, InstanceID, RoleID, Condition)
    -- Проверяем входные параметры
    if MapID == nil or InstanceID == nil or RoleID == nil or Condition == nil then
        return
    end

    -- Проверяем существование данных арены и игрока
    if Arena[InstanceID] ~= nil then
        if ArenaPlayer[RoleID] ~= nil and ArenaPlayer[RoleID].Info[InstanceID] ~= nil then
            local EnemyID = {}

            -- Определяем противников в зависимости от команды игрока
            if ArenaPlayer[RoleID].Info[InstanceID].Side == "red" then
                -- Красная команда - противники синие (игроки 4, 5, 6)
                EnemyID[1] = Arena[InstanceID].Player[4]
                EnemyID[2] = Arena[InstanceID].Player[5]
                EnemyID[3] = Arena[InstanceID].Player[6]
            else
                -- Синяя команда - противники красные (игроки 1, 2, 3)
                EnemyID[1] = Arena[InstanceID].Player[1]
                EnemyID[2] = Arena[InstanceID].Player[2]
                EnemyID[3] = Arena[InstanceID].Player[3]
            end

            if Condition == 1 then
                -- Показать всех противников с их состоянием
                local EState = {}  -- 1 - оффлайн, 2 - мертв, 3 - жив
                for i = 1, 3 do
                    local Emap, EInstance = role.GetRoleMapID(EnemyID[i])
                    if (Emap == nil or Emap ~= MapID) or (EInstance == nil or EInstance ~= InstanceID) then
                        EState[i] = 1  -- Игрок оффлайн/не в арене
                    elseif unit.IsDead(MapID, InstanceID, EnemyID[i]) then
                        EState[i] = 2  -- Игрок мертв
                    else
                        EState[i] = 3  -- Игрок жив
                        -- Показываем имя живого противника
                        role.ShowAlivePeopleNameInArena(EnemyID[i], RoleID, 3)
                    end
                    -- Отправляем статус противника игроку
                    role.ShowAlivePeopleNameInArena(RoleID, EnemyID[i], EState[i])
                end
            elseif Condition == 2 then
                -- Показать только живых противников
                for i = 1, 3 do
                    local Emap, EInstance = role.GetRoleMapID(EnemyID[i])
                    if (Emap == nil or Emap ~= MapID) or (EInstance == nil or EInstance ~= InstanceID) then
                        -- Игрок не в арене - пропускаем
                    elseif not unit.IsDead(MapID, InstanceID, EnemyID[i]) then
                        -- Игрок жив - показываем его
                        role.ShowAlivePeopleNameInArena(EnemyID[i], RoleID, 2)
                    end
                end
            elseif Condition == 3 then
                -- Показать только мертвых противников
                for i = 1, 3 do
                    local Emap, EInstance = role.GetRoleMapID(EnemyID[i])
                    if (Emap == nil or Emap ~= MapID) or (EInstance == nil or EInstance ~= InstanceID) then
                        -- Игрок не в арене - пропускаем
                    elseif unit.IsDead(MapID, InstanceID, EnemyID[i]) then
                        -- Игрок мертв - показываем его
                        role.ShowAlivePeopleNameInArena(EnemyID[i], RoleID, 1)
                    end
                end
            end
        end
    end
end

-- Показ времени до окончания арены
-- Длительность матча: 11 минут (660 секунд)
function ShowArenaTime(MapID, InstanceID, RoleID)
    -- Проверяем входные параметры
    if MapID == nil or InstanceID == nil or RoleID == nil then
        return
    end

    -- Проверяем существование данных арены
    if Arena[InstanceID] == nil then
        return
    end

    local leftSec = 660  -- Общее время матча в секундах

    -- Получаем текущее время
    local Min = tonumber(os.date("%M"))
    local Second = tonumber(os.date("%S"))

    -- Получаем время открытия арены
    local Min_open = math.floor((Arena[InstanceID].OpenTime % 10000) / 100)
    local Second_open = Arena[InstanceID].OpenTime % 100

    -- Расчет оставшегося времени
    if Second == Second_open and Min == Min_open then
        leftSec = 660  -- Точное совпадение времени - полное время
    elseif Second <= Second_open then
        -- Текущая секунда меньше секунды открытия - учитываем перенос минуты
        leftSec = 660 - (Second + 60 - Second_open)
    else
        -- Обычный расчет разницы
        leftSec = 660 - (Second - Second_open)
    end

    -- Корректировка времени с учетом минут
    if Min ~= Min_open then
        local minDiff = Min - Min_open
        if minDiff < 0 then
            minDiff = minDiff + 60  -- Учитываем переход через час
        end
        leftSec = leftSec - (minDiff * 60)
    end

    -- Ограничиваем минимальное время
    if leftSec < 0 then
        leftSec = 0
    end

    -- Отправка сообщения с оставшимся временем
    local MsgID = msg.BeginMsgEvent()
    msg.AddMsgEvent(MsgID, 16, 28)  -- Тип сообщения: время арены
    msg.AddMsgEvent(MsgID, 16, leftSec)  -- Оставшееся время в секундах
    msg.DispatchRoleMsgEvent(RoleID, MsgID)
end

-- Показ финального экрана результатов арены
-- Формирует и отображает итоговую статистику матча для всех игроков
function ShowArenaFinalFrame(MapID, InstanceID)
    -- Проверяем входные параметры
    if MapID == nil or InstanceID == nil then
        return
    end

    -- Проверяем существование данных арены
    if Arena[InstanceID] == nil then
        return
    end

    -- Инициализация массива результатов для всех 6 игроков
    -- Структура: [ID игрока, рейтинг, получаемые очки, убийства, процент побед, результат]
    -- Результат: 1 - победа, 2 - поражение, 3 - ничья (победившая команда), 4 - ничья (ничья)
    local acount = {}
    acount[1] = {-1, -1, -1, -1, -1, -1}
    acount[2] = {-1, -1, -1, -1, -1, -1}
    acount[3] = {-1, -1, -1, -1, -1, -1}
    acount[4] = {-1, -1, -1, -1, -1, -1}
    acount[5] = {-1, -1, -1, -1, -1, -1}
    acount[6] = {-1, -1, -1, -1, -1, -1}

    -- Заполняем ID игроков в массиве результатов
    for i = 1, 6 do
        acount[i][1] = Arena[InstanceID].Player[i]
    end

    -- Определение результатов матча на основе количества живых игроков в командах
    if Arena[InstanceID].RedNum == 0 or Arena[InstanceID].RedNum < Arena[InstanceID].BlueNum then
        -- Красная команда проиграла или все мертвы
        acount[1][6] = 2  -- Красные: поражение
        acount[2][6] = 2
        acount[3][6] = 2

        if Arena[InstanceID].BlueNum >= 3 then
            -- Синие победили с полноценной командой
            acount[4][6] = 3  -- Синие: победа
            acount[5][6] = 3
            acount[6][6] = 3
        else
            -- Синие победили, но неполной командой (техническая победа)
            acount[4][6] = 1  -- Синие: победа (техническая)
            acount[5][6] = 1
            acount[6][6] = 1
        end

        -- Отмечаем победителей
        ArenaPlayer[acount[4][1]].Info[InstanceID].Win = 1
        ArenaPlayer[acount[5][1]].Info[InstanceID].Win = 1
        ArenaPlayer[acount[6][1]].Info[InstanceID].Win = 1

    elseif Arena[InstanceID].BlueNum == 0 or Arena[InstanceID].BlueNum < Arena[InstanceID].RedNum then
        -- Синяя команда проиграла или все мертвы
        acount[4][6] = 2  -- Синие: поражение
        acount[5][6] = 2
        acount[6][6] = 2

        if Arena[InstanceID].RedNum >= 3 then
            -- Красные победили с полноценной командой
            acount[1][6] = 3  -- Красные: победа
            acount[2][6] = 3
            acount[3][6] = 3
        else
            -- Красные победили, но неполной командой (техническая победа)
            acount[1][6] = 1  -- Красные: победа (техническая)
            acount[2][6] = 1
            acount[3][6] = 1
        end

        -- Отмечаем победителей
        ArenaPlayer[acount[1][1]].Info[InstanceID].Win = 1
        ArenaPlayer[acount[2][1]].Info[InstanceID].Win = 1
        ArenaPlayer[acount[3][1]].Info[InstanceID].Win = 1

    elseif Arena[InstanceID].BlueNum == Arena[InstanceID].RedNum then
        -- Ничья - равное количество живых игроков в командах
        acount[1][6] = 4  -- Все: ничья
        acount[2][6] = 4
        acount[3][6] = 4
        acount[4][6] = 4
        acount[5][6] = 4
        acount[6][6] = 4
    end

    -- Заполнение статистики для каждого игрока
    for i = 1, 6 do
        -- Заполняем текущий рейтинг и количество убийств
        acount[i][2] = ArenaPlayer[acount[i][1]].Info[InstanceID].RankPoint
        acount[i][4] = ArenaPlayer[acount[i][1]].Info[InstanceID].Kill

        -- Проверяем, находится ли игрок онлайн в арене
        local Map_ID, Instance_ID = role.GetRoleMapID(acount[i][1])
        if (Map_ID == nil or Instance_ID == nil) or (Map_ID ~= MapID or Instance_ID ~= InstanceID) then
            acount[i][6] = 2  -- Игрок оффлайн - результат поражения
        end

        -- Расчет получаемых очков рейтинга
        if acount[i][6] == 2 then
            -- Поражение - теряем очки
            acount[i][3] = -Lose_Point_Arena(InstanceID, acount[i][1])
        elseif acount[i][6] ~= 4 then
            -- Победа - получаем очки и сообщение
            acount[i][3] = Win_Point_Arena(InstanceID, acount[i][1])
            local MsgID = msg.BeginMsgEvent()
            msg.AddMsgEvent(MsgID, 101, 206283)  -- Сообщение о победе в арене
            msg.DispatchRoleMsgEvent(acount[i][1], MsgID)  -- Отправка сообщения победителю
        else
            -- Ничья - получаем 1 очко
            acount[i][3] = 1
        end

        -- Расчет процента побед
        if acount[i][6] == 1 or acount[i][6] == 3 then
            -- Победа - учитываем текущую победу в статистике
            acount[i][5] = math.floor((ArenaPlayer[acount[i][1]].Info[InstanceID].WinTimes + 1) * 10000 / (ArenaPlayer[acount[i][1]].Info[InstanceID].TotleTimes + 1))
        else
            -- Поражение или ничья - не учитываем текущую победу
            acount[i][5] = math.floor((ArenaPlayer[acount[i][1]].Info[InstanceID].WinTimes) * 10000 / (ArenaPlayer[acount[i][1]].Info[InstanceID].TotleTimes + 1))
        end

        -- Применение изменений рейтинга только для игроков, которые онлайн
        if Map_ID ~= nil and Instance_ID ~= nil and Map_ID == MapID and Instance_ID == InstanceID then
            role.ModRoleAttValue(MapID, InstanceID, acount[i][1], 79, acount[i][3])
        end
    end

    -- Отображение финального экрана для каждого онлайн игрока
    for q = 1, 6 do
        local Map_ID, Instance_ID = role.GetRoleMapID(acount[q][1])
        -- Проверяем, что игрок онлайн и находится в арене
        if Map_ID ~= nil and Instance_ID ~= nil and Map_ID == MapID and Instance_ID == InstanceID and role.IsRoleOnLine(MapID, InstanceID, acount[q][1]) == 1 then
            -- Вызов функции обновления статистики игрока в арене
            SetScript_Arena(acount[q][1], acount[q][6])

            -- Добавление баффа окончания арены
            unit.AddBuff(MapID, InstanceID, acount[q][1], 6936201, acount[q][1])

            -- Подготовка данных для финального экрана
            -- Создаем копию массива результатов
            local acount_1 = {}
            for i = 1, 6 do
                acount_1[i] = {}
                for j = 1, 6 do
                    acount_1[i][j] = acount[i][j]
                end
            end

            -- Перемещаем данные текущего игрока на первую позицию для отображения
            local temp = {}
            for i = 1, 6 do
                temp[i] = acount_1[1][i]
                acount_1[1][i] = acount_1[q][i]
                acount_1[q][i] = temp[i]
            end

            -- Формирование строки данных для клиентского интерфейса
            local char = nil
            for i = 1, 6 do
                for j = 1, 5 do  -- Первые 5 полей каждого игрока
                    if i == 1 and j == 1 then
                        char = tostring(acount_1[1][1])  -- ID первого игрока
                    else
                        char = char .. "," .. tostring(acount_1[i][j])
                    end
                end
            end
            char = char .. "," .. tostring(acount_1[1][6])  -- Результат первого игрока

            -- Добавляем количество матчей сегодня
            local TimesToday = role.GetRoleScriptData(acount_1[1][1], 1, RoleDataType["TimesToday_Arena"])
            if TimesToday > 6 then
                TimesToday = 6  -- Ограничение максимального количества матчей в день
            end
            char = char .. "," .. tostring(TimesToday)

            -- Отправка финального экрана игроку
            role.ShowArenaEndFrame(acount_1[1][1], char)
        end
    end
end

-- Обновление статистики игрока после арены
-- value: 0 - оффлайн, 1 - победа, 2 - поражение, 3 - победа (техническая), 4 - ничья
function SetScript_Arena(RoleID, value)
    -- Проверяем входные параметры
    if RoleID == nil or value == nil then
        return
    end

    -- Получаем сохраненную дату последнего матча и текущую дату
    local Date = role.GetRoleScriptData(RoleID, 1, RoleDataType["Date_Arena"])
    local CurTime = tonumber(os.date("%j"))  -- День года (1-366)

    -- Сброс ежедневной статистики при смене дня
    if Date ~= CurTime then
        role.SetRoleScriptData(RoleID, 1, RoleDataType["Date_Arena"], CurTime)
        role.SetRoleScriptData(RoleID, 1, RoleDataType["TimesToday_Arena"], 0)
    end

    -- Обновление статистики в зависимости от результата
    if value == 1 or value == 3 then
        -- Победа или техническая победа
        local TotleTimes_Arena = role.GetRoleScriptData(RoleID, 1, RoleDataType["TotleTimes_Arena"])
        role.SetRoleScriptData(RoleID, 1, RoleDataType["TotleTimes_Arena"], TotleTimes_Arena + 1)

        local WinTimes_Arena = role.GetRoleScriptData(RoleID, 1, RoleDataType["WinTimes_Arena"])
        role.SetRoleScriptData(RoleID, 1, RoleDataType["WinTimes_Arena"], WinTimes_Arena + 1)

        local TimesToday = role.GetRoleScriptData(RoleID, 1, RoleDataType["TimesToday_Arena"])
        TimesToday = TimesToday + 1
        role.SetRoleScriptData(RoleID, 1, RoleDataType["TimesToday_Arena"], TimesToday)

    elseif value == 0 or value == 2 or value == 4 then
        -- Оффлайн, поражение или ничья
        local TotleTimes_Arena = role.GetRoleScriptData(RoleID, 1, RoleDataType["TotleTimes_Arena"])
        role.SetRoleScriptData(RoleID, 1, RoleDataType["TotleTimes_Arena"], TotleTimes_Arena + 1)

        local TimesToday = role.GetRoleScriptData(RoleID, 1, RoleDataType["TimesToday_Arena"])
        TimesToday = TimesToday + 1
        role.SetRoleScriptData(RoleID, 1, RoleDataType["TimesToday_Arena"], TimesToday)
    end
end

-- Получение награды из сундука арены
-- TargetTypeID: 5512004 - обычный сундук, 5512005 - премиум сундук
function ArenaBox_GetItem(MapID, InstanceID, TargetTypeID, RoleID)
    -- Проверяем, что все необходимые параметры переданы корректно
    if MapID == nil or InstanceID == nil or TargetTypeID == nil or RoleID == nil then
        return
    end

    -- Проверяем наличие квеста и добавляем квестовый предмет
    if role.IsRoleHaveQuest(MapID, InstanceID, RoleID, 30011) then
        role.QuestAddRoleItem(MapID, InstanceID, RoleID, 30012, 6600884, 1, -1, 420)
    end

    -- Проверяем наличие свободного места в инвентаре
    if role.GetBagFreeSize(RoleID) >= 1 then
        if TargetTypeID == 5512004 then
            -- Обычный сундук арены
            role.AddRoleItem(MapID, InstanceID, RoleID, 4600001, 1, -1, 8, 420)  -- 1 золотая монета

            -- Редкий шанс на дополнительную награду (1/250)
            if role.GetBagFreeSize(RoleID) >= 1 and math.random(250) == 57 then
                role.AddRoleItem(MapID, InstanceID, RoleID, 4631001, 1, -1, 8, 420)  -- Редкий предмет
            end

        elseif TargetTypeID == 5512005 then
            -- Премиум сундук арены
            local k = math.random(10)

            if k <= 5 then
                -- 50% шанс: 2 золотые монеты
                role.AddRoleItem(MapID, InstanceID, RoleID, 4600001, 2, -1, 8, 420)
            elseif k <= 8 then
                -- 30% шанс: 3 золотые монеты
                role.AddRoleItem(MapID, InstanceID, RoleID, 4600001, 3, -1, 8, 420)
            elseif k <= 9 then
                -- 10% шанс: особый предмет + 1 золотая монета
                role.AddRoleItem(MapID, InstanceID, RoleID, 4090015, 1, -1, 8, 420)  -- Особый предмет
                role.AddRoleItem(MapID, InstanceID, RoleID, 4600001, 1, -1, 8, 420)  -- 1 золотая монета
            else
                -- 10% шанс: редкая монета + 1 золотая монета
                role.AddRoleItem(MapID, InstanceID, RoleID, 4600002, 1, -1, 8, 420)  -- Редкая монета
                role.AddRoleItem(MapID, InstanceID, RoleID, 4600001, 1, -1, 8, 420)  -- 1 золотая монета
            end
        end
    end
end