Roblox · Мини-игры

Шашки

Шашки 8 × 8 по русским правилам в простом виде: ходы вперёд по диагонали, бить обязательно (можно и назад), серия взятий одной шашкой, дамка на последней линии. Клик по своей шашке — подсветка ходов, клик по зелёной клетке — ход. Играть вдвоём или с ботом.

Структура

Синим — что нужно создать.

Workspace
└─ Checkers (Model)
   ├─ Board (Part) — стол
   ├─ Cells (Folder)
   │  └─ Cell_1_1…Cell_8_8 (Part) — у тёмных — ClickDetector
   ├─ Pieces (Folder) — шашки создаёт скрипт
   ├─ Sign (Part) — табло → SignGui → Text
   ├─ BotButton (Part) — ClickDetector
   └─ CheckersServer (Script)

Шаги

  1. Клетки — 64 детали «Cell_строка_столбец». Строка 1 — ближняя к белым. Ходят только по тёмным клеткам, поэтому ClickDetector — только у них.
  2. Доска в памяти — таблица board[строка][столбец]: пусто или {side = "White"/"Black", king = true/false}. Шашки на столе скрипт перерисовывает после каждого хода (Render) — так проще, чем двигать детали.
  3. У каждой шашки свой ClickDetector: клик по ней работает как клик по клетке под ней.
  4. MovesFrom: простая шашка ходит на 1 клетку вперёд, дамка — на 1 в любую сторону (в простой версии дамка не «летает»). Бить можно в любую сторону: чужая шашка рядом, за ней пусто.
  5. AllMoves: если у стороны есть хоть одно взятие — разрешены только взятия (бить обязательно). После взятия та же шашка бьёт дальше (chain), ход не переходит.
  6. Дошла до последней линии — дамка (выше и светится). Ходить некуда или шашек нет — проигрыш.
  7. Бот делает случайный разрешённый ход — бить он обязан, так что ошибки соперника не пропустит. Сделать умнее — выбирай ход, после которого твою шашку нельзя взять.

Скрипты

CheckersServer

Где: Workspace → Checkers · Script
Зачем: Правила, ходы, взятия, дамки, бот.

-- игроки
local Players = game:GetService("Players")
-- модель игры
local model = script.Parent
-- табло
local label = model:WaitForChild("Sign"):WaitForChild("SignGui"):WaitForChild("Text")
-- кнопка «Бот»
local botButton = model:WaitForChild("BotButton"):WaitForChild("ClickDetector")
-- вместо игрока может играть бот
local BOT = "Бот"
-- нет ходов минуту — игра сбрасывается
local IDLE = 60
-- players.White и players.Black: игрок или BOT
local players = {}
-- клетки Cell_строка_столбец
local cellsFolder = model:WaitForChild("Cells")
-- шашки — их рисует скрипт
local pieces = model:WaitForChild("Pieces")
-- для табло
local NAMES = {White = "белые", Black = "чёрные"}
-- цвета шашек
local PIECE = {White = Color3.fromRGB(240, 240, 230), Black = Color3.fromRGB(40, 40, 40)}
-- тёмная клетка
local DARK = Color3.fromRGB(110, 70, 40)
-- выбранная шашка
local SELECT = Color3.fromRGB(240, 200, 60)
-- куда можно сходить
local TARGET = Color3.fromRGB(90, 200, 110)
-- четыре диагонали
local DIRS = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}}
-- доска, чей ход, выбранная шашка, серия взятий, конец, время
local board, turn, selected, chain, over, lastMove = {}, "White", nil, nil, false, 0

-- клетка по строке и столбцу
local function Cell(r, c) return cellsFolder:FindFirstChild("Cell_" .. r .. "_" .. c) end
-- на доске?
local function Inside(r, c) return r >= 1 and r <= 8 and c >= 1 and c <= 8 end
-- противник
local function Enemy(side) return side == "White" and "Black" or "White" end
-- имя игрока за сторону
local function Name(side)
    -- игрок или BOT
    local p = players[side]
    -- имя
    return p == BOT and BOT or (p and p.DisplayName or "?")
-- конец функции
end

-- ходы одной шашки: простые и взятия
local function MovesFrom(r, c)
    -- шашка
    local piece = board[r][c]
    -- списки
    local moves, captures = {}, {}
    -- каждая диагональ
    for _, d in ipairs(DIRS) do
        -- соседняя клетка
        local nr, nc = r + d[1], c + d[2]
        -- вперёд для этого цвета
        local forward = (piece.side == "White" and d[1] == 1) or (piece.side == "Black" and d[1] == -1)
        -- на доске
        if Inside(nr, nc) then
            -- что там
            local other = board[nr][nc]
            -- пусто: простая шашка — только вперёд, дамка — куда угодно
            if not other and (forward or piece.king) then
                -- простой ход
                table.insert(moves, {nr, nc})
            -- чужая шашка, а за ней пусто
            elseif other and other.side ~= piece.side and Inside(nr + d[1], nc + d[2]) and not board[nr + d[1]][nc + d[2]] then
                -- взятие: куда встать и кого снять (бить можно и назад)
                table.insert(captures, {nr + d[1], nc + d[2], nr, nc})
            -- конец проверки
            end
        -- конец проверки
        end
    -- конец перебора
    end
    -- отдаём
    return moves, captures
-- конец функции
end

-- все ходы стороны: {откуда r, c, куда r, c, снять r, c}
local function AllMoves(side)
    -- списки
    local moves, captures = {}, {}
    -- каждая строка
    for r = 1, 8 do
        -- каждый столбец
        for c = 1, 8 do
            -- шашка
            local piece = board[r][c]
            -- своя; в серии взятий — только та, что бьёт
            if piece and piece.side == side and (not chain or (chain[1] == r and chain[2] == c)) then
                -- её ходы
                local m, cap = MovesFrom(r, c)
                -- простые
                for _, x in ipairs(m) do table.insert(moves, {r, c, x[1], x[2]}) end
                -- взятия
                for _, x in ipairs(cap) do table.insert(captures, {r, c, x[1], x[2], x[3], x[4]}) end
            -- конец проверки
            end
        -- конец перебора
        end
    -- конец перебора
    end
    -- бить обязательно — если можно, только взятия
    if #captures > 0 then return captures, true end
    -- серия кончилась
    if chain then return {}, false end
    -- простые ходы
    return moves, false
-- конец функции
end

-- объявляем заранее: на клик по шашке отвечает та же функция
local OnClick
-- нарисовать доску, шашки и табло
local function Render()
    -- старые шашки убираем
    pieces:ClearAllChildren()
    -- каждая строка
    for r = 1, 8 do
        -- каждый столбец
        for c = 1, 8 do
            -- клетка
            local cell = Cell(r, c)
            -- тёмные клетки — обычный цвет
            if (r + c) % 2 == 0 then cell.Color = DARK end
            -- шашка
            local piece = board[r][c]
            -- есть
            if piece then
                -- новая деталь
                local part = Instance.new("Part")
                -- цилиндр
                part.Shape = Enum.PartType.Cylinder
                -- дамка выше
                part.Size = Vector3.new(piece.king and 1.2 or 0.6, 3.2, 3.2)
                -- лежит на клетке
                part.CFrame = CFrame.new(cell.Position + Vector3.new(0, cell.Size.Y / 2 + part.Size.X / 2, 0)) * CFrame.Angles(0, 0, math.rad(90))
                -- цвет
                part.Color = PIECE[piece.side]
                -- дамка светится
                part.Material = piece.king and Enum.Material.Neon or Enum.Material.SmoothPlastic
                -- не падает
                part.Anchored = true
                -- клик по шашке — как клик по её клетке
                local click = Instance.new("ClickDetector")
                -- дотянуться через всю доску
                click.MaxActivationDistance = 60
                -- та же функция
                click.MouseClick:Connect(function(player) OnClick(player, r, c) end)
                -- в шашку
                click.Parent = part
                -- на доску
                part.Parent = pieces
            -- конец проверки
            end
        -- конец перебора
        end
    -- конец перебора
    end
    -- шашка выбрана
    if selected then
        -- подсвечиваем её
        Cell(selected[1], selected[2]).Color = SELECT
        -- все ходы
        for _, m in ipairs((AllMoves(turn))) do
            -- ходы этой шашки — зелёным
            if m[1] == selected[1] and m[2] == selected[2] then Cell(m[3], m[4]).Color = TARGET end
        -- конец перебора
        end
    -- конец проверки
    end
    -- итог уже на табло
    if over then return end
    -- никого нет
    if not players.White then label.Text = "Кликни по шашке — играешь за белых"
    -- один игрок
    elseif not players.Black then label.Text = "Ждём второго игрока или нажми «Бот»"
    -- чей ход
    else label.Text = "Ходят " .. NAMES[turn] .. ": " .. Name(turn) end
-- конец функции
end

-- новая игра
local function Reset()
    -- всё сначала
    board, players, turn, selected, chain, over = {}, {}, "White", nil, nil, false
    -- каждая строка
    for r = 1, 8 do
        -- пустая
        board[r] = {}
        -- каждый столбец
        for c = 1, 8 do
            -- белые — на тёмных клетках трёх ближних рядов
            if (r + c) % 2 == 0 and r <= 3 then board[r][c] = {side = "White", king = false} end
            -- чёрные — трёх дальних
            if (r + c) % 2 == 0 and r >= 6 then board[r][c] = {side = "Black", king = false} end
        -- конец перебора
        end
    -- конец перебора
    end
    -- рисуем
    Render()
-- конец функции
end

-- объявляем заранее — DoMove и BotMove вызывают друг друга
local BotMove
-- сделать ход {откуда, куда, кого снять}
local function DoMove(m)
    -- шашка
    local piece = board[m[1]][m[2]]
    -- уходит
    board[m[1]][m[2]] = nil
    -- встаёт
    board[m[3]][m[4]] = piece
    -- взятая шашка снимается
    if m[5] then board[m[5]][m[6]] = nil end
    -- дошла до края — дамка
    if (piece.side == "White" and m[3] == 8) or (piece.side == "Black" and m[3] == 1) then piece.king = true end
    -- время хода
    lastMove = os.clock()
    -- выбор сброшен
    selected, chain = nil, nil
    -- было взятие
    if m[5] then
        -- та же шашка может бить дальше
        chain = {m[3], m[4]}
        -- есть ещё взятие?
        local _, more = AllMoves(turn)
        -- есть — бьёт дальше, ход не переходит
        if more then selected = chain else chain = nil end
    -- конец проверки
    end
    -- ход противника
    if not chain then turn = Enemy(turn) end
    -- ходить некуда (или шашек нет) — проиграл
    if #(AllMoves(turn)) == 0 then
        -- стоп
        over = true
        -- показать доску
        Render()
        -- победитель
        local winner = Enemy(turn)
        -- итог
        label.Text = "Победили " .. NAMES[winner] .. ": " .. Name(winner) .. "!"
        -- новая игра
        task.delay(6, Reset)
        -- дальше не ходим
        return
    -- конец проверки
    end
    -- рисуем
    Render()
    -- ход бота
    if players[turn] == BOT then task.delay(0.8, BotMove) end
-- конец функции
end
-- ход бота: случайный разрешённый (бить обязан)
function BotMove()
    -- уже не его ход
    if over or players[turn] ~= BOT then return end
    -- разрешённые ходы
    local moves = AllMoves(turn)
    -- любой
    if #moves > 0 then DoMove(moves[math.random(1, #moves)]) end
-- конец функции
end

-- клик по клетке или шашке
function OnClick(player, r, c)
    -- игра окончена
    if over then return end
    -- первый кликнувший играет первым цветом
    if not players.White then players.White = player
    -- второй — вторым
    elseif not players.Black and players.White ~= player then players.Black = player end
    -- кто-то действует
    lastMove = os.clock()
    -- не твой ход
    if players[turn] ~= player then Render() return end
    -- что на клетке
    local piece = board[r][c]
    -- своя шашка (в серии взятий менять нельзя)
    if piece and piece.side == turn and not chain then
        -- выбираем
        selected = {r, c}
        -- подсветка
        Render()
        -- ждём второй клик
        return
    -- конец проверки
    end
    -- сначала выбери шашку
    if not selected then return end
    -- разрешённые ходы
    for _, m in ipairs((AllMoves(turn))) do
        -- этот ход разрешён
        if m[1] == selected[1] and m[2] == selected[2] and m[3] == r and m[4] == c then
            -- ходим
            DoMove(m)
            -- готово
            return
        -- конец проверки
        end
    -- конец перебора
    end
-- конец функции
end
-- каждая строка
for r = 1, 8 do
    -- каждый столбец
    for c = 1, 8 do
        -- клик есть только у тёмных клеток
        local click = Cell(r, c):FindFirstChild("ClickDetector")
        -- подключаем
        if click then click.MouseClick:Connect(function(player) OnClick(player, r, c) end) end
    -- конец перебора
    end
-- конец перебора
end

-- нажали «Бот»
botButton.MouseClick:Connect(function(player)
    -- игра закончена или второй игрок уже есть
    if over or players.Black then return end
    -- первым будет тот, кто нажал
    if not players.White then players.White = player end
    -- против бота
    if players.White == player then players.Black = BOT end
    -- игра началась
    lastMove = os.clock()
    -- табло
    Render()
    -- если сейчас ход бота — пусть ходит
    if players[turn] == BOT then task.delay(0.7, BotMove) end
-- конец функции
end)
-- игрок вышел
Players.PlayerRemoving:Connect(function(player)
    -- это участник
    if players.White == player or players.Black == player then
        -- игра окончена
        over = true
        -- табло
        label.Text = "Игрок вышел"
        -- новая игра
        task.delay(2, Reset)
    -- конец проверки
    end
-- конец функции
end)

-- первая игра
Reset()
-- следим за брошенными играми
while true do
    -- раз в 5 секунд
    task.wait(5)
    -- кто-то сел и ушёл
    if not over and players.White and os.clock() - lastMove > IDLE then
        -- табло
        label.Text = "Никто не ходит — новая игра"
        -- стоп
        over = true
        -- сброс
        task.delay(2, Reset)
    -- конец проверки
    end
-- конец цикла
end

Проверка

Запусти Play (или Run) и убедись:

Собрать шашки одной командой