-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

local old = playerGui:FindFirstChild("P_WordBot")
if old then
    local stop = old:FindFirstChild("Stop")
    if stop and stop:IsA("BindableEvent") then
        stop:Fire()
    else
        old:Destroy()
    end
end

local gui = Instance.new("ScreenGui")
gui.Name = "P_WordBot"
gui.ResetOnSpawn = false
gui.Parent = playerGui

local stopEvent = Instance.new("BindableEvent")
stopEvent.Name = "Stop"
stopEvent.Parent = gui

local running = true
local enabled = false
local connections = {}
local used = {}
local lastWord
local submitted = false
local previousFocus = false
local feedbackConnection
local generation = 0

local words = {
    ["А"] = {
        "арбуз", "автобус", "аптека", "апельсин", "автор",
        "алмаз", "арка", "альбом", "акула", "аппарат",
        "автомобиль", "аквариум", "астронавт", "архитектура",
        "администрация", "астрономия"
    },
    ["Б"] = {
        "банан", "барабан", "белка", "береза", "билет",
        "бутылка", "башня", "бабочка", "берег", "бензин",
        "библиотека", "благодарность", "безопасность",
        "благополучие", "белоснежка"
    },
    ["В"] = {
        "вагон", "варенье", "ведро", "велосипед", "вишня",
        "волк", "вода", "воробей", "ветер", "весна",
        "вертолет", "водопад", "волшебник", "впечатление",
        "воображение", "взаимопонимание"
    },
    ["Г"] = {
        "газета", "галстук", "гараж", "гитара", "глобус",
        "город", "гора", "груша", "гриб", "голубь",
        "гостиница", "государство", "головоломка",
        "география", "грамматика"
    },
    ["Д"] = {
        "дерево", "диван", "дождь", "дорога", "дракон",
        "дверь", "дом", "доска", "долина", "деревня",
        "директор", "двигатель", "драгоценность",
        "достопримечательность", "доброжелательность"
    },
    ["Е"] = {
        "еда", "елка", "ель", "ежевика", "енот", "единица",
        "естество", "ежедневник", "единорог", "единство"
    },
    ["Ё"] = {"ёж", "ёлка", "ёрш", "ёжик", "ёмкость"},
    ["Ж"] = {
        "жаба", "жираф", "журнал", "живот", "жук",
        "жемчуг", "житель", "желание", "железо",
        "животное", "живописец", "журналистика"
    },
    ["З"] = {
        "забор", "завод", "заяц", "зебра", "зеркало",
        "зима", "зонт", "звезда", "земля", "здание",
        "знакомство", "здоровье", "землетрясение",
        "закономерность", "замечательность"
    },
    ["И"] = {
        "игра", "игрушка", "изба", "индюк", "инструмент",
        "история", "ирис", "иголка", "изображение",
        "искусство", "изобретение", "исследование",
        "информация", "инфраструктура"
    },
    ["Й"] = {"йогурт", "йод", "йога", "йорк"},
    ["К"] = {
        "карандаш", "картина", "книга", "корабль", "корова",
        "кот", "камень", "колесо", "кровать", "кукла",
        "календарь", "компьютер", "космонавт", "коллекция",
        "космический", "кораблестроение"
    },
    ["Л"] = {
        "лампа", "лестница", "лимон", "лиса", "лодка",
        "лопата", "луна", "лес", "лошадь", "линейка",
        "ландшафт", "ласточка", "любопытство",
        "лаборатория", "литература"
    },
    ["М"] = {
        "машина", "магазин", "малина", "медведь", "молоко",
        "мост", "мяч", "море", "монета", "морковь",
        "мороженое", "мультфильм", "механизм",
        "метеорология", "машиностроение"
    },
    ["Н"] = {
        "небо", "неделя", "нитка", "ножницы", "носок",
        "нора", "ноутбук", "ночь", "народ", "наука",
        "насекомое", "настроение", "наблюдение",
        "необходимость", "непредсказуемость"
    },
    ["О"] = {
        "облако", "обезьяна", "овощ", "одеяло", "озеро",
        "окно", "остров", "огурец", "орех", "осень",
        "образование", "оборудование", "обстоятельство",
        "окружающий", "ответственность"
    },
    ["П"] = {
        "пальто", "пароход", "петух", "письмо", "планета",
        "поезд", "поле", "птица", "подарок", "помидор",
        "путешествие", "путешественник", "приключение",
        "преподаватель", "предприниматель",
        "преобразование", "промышленность"
    },
    ["Р"] = {
        "ракета", "радуга", "река", "рисунок", "робот",
        "ромашка", "рыба", "ручка", "роза", "рюкзак",
        "рассказ", "растение", "расписание",
        "радиопередача", "развлечение", "реконструкция"
    },
    ["С"] = {
        "самолет", "сахар", "собака", "солнце", "стакан",
        "стол", "сумка", "сыр", "снег", "скворец",
        "строительство", "сокровище", "спутник",
        "сотрудничество", "самостоятельность",
        "сельскохозяйственный"
    },
    ["Т"] = {
        "тарелка", "телефон", "тигр", "трава", "трактор",
        "трамвай", "туча", "торт", "тетрадь", "театр",
        "технология", "термометр", "транспорт",
        "телевидение", "трудолюбие"
    },
    ["У"] = {
        "улица", "улитка", "утка", "утро", "учебник",
        "урок", "уголь", "улыбка", "учитель",
        "устройство", "управление", "университет",
        "удивление", "усовершенствование"
    },
    ["Ф"] = {
        "фабрика", "флаг", "фонарь", "фонтан", "фото",
        "фрукт", "футбол", "фигура", "ферма",
        "фотография", "фантазия", "фестиваль",
        "футболист", "фундамент"
    },
    ["Х"] = {
        "хлеб", "холодильник", "хомяк", "хвост", "халат",
        "художник", "хоккей", "хижина", "характер",
        "хозяйство", "храбрость", "художественный"
    },
    ["Ц"] = {
        "цветок", "цирк", "цифра", "цыпленок", "цепь",
        "царь", "цена", "цемент", "цитата",
        "цивилизация", "целеустремленность"
    },
    ["Ч"] = {
        "чайник", "часы", "чемодан", "черепаха", "человек",
        "чашка", "чудо", "чистота", "червяк",
        "чемпион", "человечество", "чрезвычайный"
    },
    ["Ш"] = {
        "шапка", "шарик", "школа", "шоколад", "шарф",
        "шина", "шкаф", "шахматы", "шоссе",
        "школьник", "шестеренка", "шоколадница"
    },
    ["Щ"] = {
        "щенок", "щетка", "щука", "щит", "щавель",
        "щепка", "щедрость", "щелчок"
    },
    ["Ъ"] = {},
    ["Ы"] = {},
    ["Ь"] = {},
    ["Э"] = {
        "экран", "экскаватор", "электричество", "этаж",
        "эхо", "экзамен", "экспедиция", "эксперимент",
        "электростанция", "электроприбор", "энциклопедия"
    },
    ["Ю"] = {
        "юбка", "юг", "юла", "юноша", "юмор",
        "юрист", "юность", "ювелир"
    },
    ["Я"] = {
        "яблоко", "ягода", "язык", "якорь", "ящик",
        "яйцо", "январь", "ястреб", "ярмарка",
        "явление", "ядерный"
    }
}

local lowerToUpper = {}
local upperLetters = {}
local upper = "А Б В Г Д Е Ё Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я"
local lower = "а б в г д е ё ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я"

for letter in upper:gmatch("%S+") do
    table.insert(upperLetters, letter)
end

local index = 0
for letter in lower:gmatch("%S+") do
    index += 1
    lowerToUpper[letter] = upperLetters[index]
end

local function connect(signal, callback)
    local connection = signal:Connect(callback)
    table.insert(connections, connection)
    return connection
end

local function make(className, parent, properties)
    local object = Instance.new(className)
    for key, value in pairs(properties) do
        object[key] = value
    end
    object.Parent = parent
    return object
end

local function button(parent, text, position, size)
    return make("TextButton", parent, {
        Position = position,
        Size = size,
        BackgroundColor3 = Color3.fromRGB(38, 38, 38),
        BorderSizePixel = 0,
        Text = text,
        TextColor3 = Color3.fromRGB(235, 235, 235),
        Font = Enum.Font.Gotham,
        TextSize = 14,
        TextWrapped = true
    })
end

local main = make("Frame", gui, {
    Position = UDim2.fromOffset(12, 75),
    Size = UDim2.fromOffset(300, 252),
    BackgroundColor3 = Color3.fromRGB(18, 18, 18),
    BorderSizePixel = 0,
    Active = true
})

local header = make("TextLabel", main, {
    Size = UDim2.new(1, -84, 0, 38),
    BackgroundColor3 = Color3.fromRGB(28, 28, 28),
    BorderSizePixel = 0,
    Text = "  WORDS | БОТ",
    TextColor3 = Color3.fromRGB(235, 235, 235),
    Font = Enum.Font.GothamBold,
    TextSize = 14,
    TextXAlignment = Enum.TextXAlignment.Left,
    Active = true
})

local minimize = button(
    main, "—", UDim2.new(1, -84, 0, 0), UDim2.fromOffset(42, 38)
)
local close = button(
    main, "X", UDim2.new(1, -42, 0, 0), UDim2.fromOffset(42, 38)
)
local onButton = button(
    main, "ВКЛ", UDim2.fromOffset(12, 48), UDim2.fromOffset(132, 38)
)
local offButton = button(
    main, "ВЫКЛ", UDim2.fromOffset(156, 48), UDim2.fromOffset(132, 38)
)
local resetButton = button(
    main, "Сбросить слова", UDim2.fromOffset(12, 92), UDim2.new(1, -24, 0, 38)
)

local status = make("TextLabel", main, {
    Position = UDim2.fromOffset(12, 138),
    Size = UDim2.new(1, -24, 0, 102),
    BackgroundTransparency = 1,
    Text = "Включи бота и дождись своего хода.\nF6 — вкл/выкл | RightShift — свернуть",
    TextColor3 = Color3.fromRGB(175, 175, 175),
    Font = Enum.Font.Gotham,
    TextSize = 12,
    TextWrapped = true
})

local reopen = button(
    gui, "WORDS", UDim2.fromOffset(12, 75), UDim2.fromOffset(76, 40)
)
reopen.Visible = false

local function setVisible(value)
    main.Visible = value
    reopen.Visible = not value
end

local function updateButtons()
    onButton.BackgroundColor3 = enabled
        and Color3.fromRGB(65, 65, 65)
        or Color3.fromRGB(38, 38, 38)

    offButton.BackgroundColor3 = not enabled
        and Color3.fromRGB(65, 65, 65)
        or Color3.fromRGB(38, 38, 38)
end

local function getParts()
    local ui = playerGui:FindFirstChild("WordGameUI")
    local canvas = ui and ui:FindFirstChild("Canvas")
    local match = canvas and canvas:FindFirstChild("Match")
    if not match then return end

    local box = match:FindFirstChild("TypingCapture")
    local tiles = match:FindFirstChild("WordTiles")
    local first = tiles and tiles:FindFirstChild("Letter1")
    local glyph = first and first:FindFirstChild("Glyph")
    local feedback = match:FindFirstChild("Feedback")

    if box and box:IsA("TextBox")
        and glyph and glyph:IsA("TextLabel") then
        return box, glyph, feedback
    end
end

local function getLetter(glyph)
    local text = glyph.Text:match("^%s*(.-)%s*$")
    return lowerToUpper[text] or text
end

local function nextWord(letter)
    local list = words[letter]
    if not list then return nil end

    for _, word in ipairs(list) do
        if not used[word] then
            return word
        end
    end
    return nil
end

local function hasEnterAPI()
    return type(keypress) == "function"
        and type(keyrelease) == "function"
end

local function attempt()
    if not running or not enabled then return end

    local box, glyph = getParts()
    if not box or UserInputService:GetFocusedTextBox() ~= box then
        status.Text = "Жду твоего хода и фокуса поля."
        return
    end

    if not hasEnterAPI() then
        enabled = false
        generation += 1
        updateButtons()
        status.Text = "Executor не поддерживает keypress/keyrelease."
        return
    end

    local letter = getLetter(glyph)
    local word = nextWord(letter)

    if not word then
        submitted = true
        status.Text = "Нет слов на «" .. tostring(letter)
            .. "».\nВ новом раунде нажми «Сбросить слова»."
        return
    end

    local secondByte = utf8.offset(word, 2)
    if not secondByte then
        submitted = true
        status.Text = "Ошибка слова в словаре."
        return
    end

    -- Игра уже поставила первую букву.
    box.Text = word:sub(secondByte)

    used[word] = true
    lastWord = word
    submitted = true
    status.Text = "Пробую: " .. word .. "\nОжидаю ответ игры."

    local pressed = pcall(keypress, 0x0D)
    task.wait(0.05)
    local released = pcall(keyrelease, 0x0D)

    if not pressed or not released then
        enabled = false
        generation += 1
        updateButtons()
        status.Text = "Не удалось нажать или отпустить Enter."
    end
end

local function bindFeedback(feedback)
    if feedbackConnection then
        feedbackConnection:Disconnect()
        feedbackConnection = nil
    end

    if not feedback or not feedback:IsA("TextLabel") then return end

    local function check()
        if not enabled or not submitted or not feedback.Visible then return end
        if not feedback.Text:find("не подходит", 1, true) then return end

        submitted = false
        local token = generation
        status.Text = "Отклонено: " .. tostring(lastWord) .. ". Пробую другое..."

        task.delay(0.35, function()
            if running and enabled and generation == token and not submitted then
                attempt()
            end
        end)
    end

    feedbackConnection = feedback:GetPropertyChangedSignal("Visible"):Connect(check)
    table.insert(connections, feedbackConnection)
end

local function turnOn()
    if enabled or not running then return end

    if not hasEnterAPI() then
        status.Text = "Executor не поддерживает keypress/keyrelease."
        return
    end

    generation += 1
    enabled = true
    submitted = false
    previousFocus = false
    updateButtons()
    status.Text = "ВКЛ. Жду твоего хода."
end

local function turnOff()
    generation += 1
    enabled = false
    submitted = false
    updateButtons()
    status.Text = "Бот выключен."
end

local function resetWords()
    -- Сбрасываем только память бота, не список игры.
    generation += 1
    table.clear(used)
    lastWord = nil

    -- Если бот остановился из-за отсутствия слов, он сможет
    -- сделать новую попытку даже во время текущего хода.
    local box = getParts()
    if enabled and box and UserInputService:GetFocusedTextBox() == box then
        submitted = false
        local token = generation
        status.Text = "Список сброшен. Пробую слово..."

        task.delay(0.15, function()
            if running and enabled and generation == token and not submitted then
                attempt()
            end
        end)
    else
        submitted = false
        status.Text = "Список слов сброшен. Жду следующий ход."
    end
end

connect(onButton.Activated, turnOn)
connect(offButton.Activated, turnOff)
connect(resetButton.Activated, resetWords)
connect(minimize.Activated, function()
    setVisible(false)
end)
connect(reopen.Activated, function()
    setVisible(true)
end)

connect(UserInputService.InputBegan, function(input)
    if UserInputService:GetFocusedTextBox() then return end

    if input.KeyCode == Enum.KeyCode.F6 then
        if enabled then
            turnOff()
        else
            turnOn()
        end
    elseif input.KeyCode == Enum.KeyCode.RightShift then
        setVisible(not main.Visible)
    end
end)

local dragInput
local dragStart
local startPosition

connect(header.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        dragInput = input
        dragStart = input.Position
        startPosition = main.Position
    end
end)

connect(UserInputService.InputChanged, function(input)
    if not dragInput then return end

    local mouseDrag =
        dragInput.UserInputType == Enum.UserInputType.MouseButton1
        and input.UserInputType == Enum.UserInputType.MouseMovement

    if mouseDrag or input == dragInput then
        local delta = input.Position - dragStart
        main.Position = UDim2.new(
            startPosition.X.Scale,
            startPosition.X.Offset + delta.X,
            startPosition.Y.Scale,
            startPosition.Y.Offset + delta.Y
        )
    end
end)

connect(UserInputService.InputEnded, function(input)
    if input == dragInput then
        dragInput = nil
    end
end)

local function stop()
    if not running then return end

    generation += 1
    enabled = false
    running = false

    if type(keyrelease) == "function" then
        pcall(keyrelease, 0x0D)
    end

    for _, connection in ipairs(connections) do
        connection:Disconnect()
    end

    gui:Destroy()
end

connect(close.Activated, stop)
connect(stopEvent.Event, stop)

updateButtons()

task.spawn(function()
    local boundFeedback

    while running do
        local box, _, feedback = getParts()

        if feedback ~= boundFeedback then
            boundFeedback = feedback
            bindFeedback(feedback)
        end

        if enabled then
            local focused = box ~= nil
                and UserInputService:GetFocusedTextBox() == box

            if focused and not previousFocus then
                submitted = false
                local token = generation
                task.wait(0.15)

                if running and enabled and generation == token and not submitted then
                    attempt()
                end
            elseif not focused and previousFocus then
                submitted = false
                status.Text = "Жду следующего хода."
            end

            previousFocus = focused
        else
            previousFocus = false
        end

        task.wait(0.1)
    end
end)