Lua в Roblox: От новичка до создателя игр

Основы скриптинга: переменные, типы данных и работа с консолью

Добро пожаловать на курс «Lua в Roblox: От новичка до создателя игр»! Если вы читаете эту статью, значит, вы решили перейти черту, отделяющую обычного игрока от творца. Roblox — это не просто набор игр, это огромная физическая песочница, которая оживает благодаря языку программирования Lua.

В этой первой статье мы не будем строить сложные системы сохранения данных или создавать искусственный интеллект для зомби. Мы начнем с фундамента. Представьте, что вы учитесь говорить на новом языке. Сначала нужно выучить алфавит и простые слова, прежде чем писать поэмы. Сегодня мы научимся «говорить» с компьютером.

Что такое скрипт и где он живет?

В Roblox Studio все, что происходит в игре (от открытия двери до начисления очков), управляется скриптами. Скрипт — это текстовый файл с инструкциями для компьютера.

Чтобы создать свой первый скрипт:

1. Откройте Roblox Studio и создайте новый проект (Baseplate).
2. В окне Explorer (Обозреватель) справа найдите папку ServerScriptService.
3. Наведите на нее курсор, нажмите на + и выберите Script.

Почему именно ServerScriptService? Это безопасное место для скриптов, которые управляют логикой игры на сервере. Игроки не могут видеть или изменять код, который находится здесь.

Ваша первая команда: Hello World

Когда вы откроете созданный скрипт, вы, скорее всего, увидите там строчку:

print("Hello world!")

Это традиция программистов всего мира. Команда print() — это ваш лучший друг. Она не влияет на игровой процесс, не двигает блоки и не убивает персонажей. Всё, что она делает — выводит текст в Консоль (Output).

Чтобы увидеть результат:

1. Убедитесь, что у вас открыто окно Output. Если нет, зайдите во вкладку View сверху и нажмите Output.
2. Нажмите кнопку Play (или F5).

Внизу экрана появится текст: Hello world!.

Зачем нам консоль?

Консоль — это диагностический инструмент. Если ваш код не работает, консоль покажет ошибку красным текстом. Если вы хотите проверить, чему равно здоровье игрока в данный момент, вы можете вывести его в консоль.

Переменные: Коробочки для данных

Представьте, что вы переезжаете. Чтобы не носить вещи в руках, вы складываете их в коробки. На каждой коробке вы пишете маркером, что внутри: «Книги», «Посуда», «Одежда».

В программировании переменная — это и есть такая коробка. У нее есть имя (надпись маркером) и содержимое (значение).

В Lua переменная создается с помощью ключевого слова local. Давайте создадим переменную, которая хранит имя нашего игрока:

local playerName = "RobloxMaster"
print(playerName)

Разберем эту строку по косточкам:

• local — мы говорим компьютеру: «Создай новую локальную переменную».
• playerName — это имя нашей коробки. Мы можем назвать её как угодно (почти), но лучше давать понятные имена.
• = — это не знак равенства из математики! В программировании это оператор присваивания. Мы кладем значение справа в коробку слева.
• "RobloxMaster" — это то, что мы положили в коробку.

Теперь, когда мы пишем print(playerName), компьютер заглядывает в коробку с надписью playerName, достает оттуда текст и печатает его.

Правила именования переменных

• Имя не может начинаться с цифры (1stPlayer — ошибка, player1 — можно).
• Имя не может содержать пробелы (my score — ошибка, myScore — можно).
• Lua чувствителен к регистру: Score и score — это две разные переменные.

Типы данных: Что можно положить в коробку?

В коробку можно положить книгу, но нельзя положить воду (без бутылки). В Lua тоже есть разные типы «вещей», которые мы храним в переменных. Рассмотрим основные.

1. Числа (Number)

Это любые числа: целые, дробные, положительные или отрицательные.

local health = 100
local speed = 16.5
local temperature = -5

С числами можно производить математические операции. Допустим, мы хотим рассчитать урон. Формула может выглядеть так:

$$Damage = BaseAttack \times Multiplier$$

Где $Damage$ — итоговый урон, $BaseAttack$ — базовая сила атаки, а $Multiplier$ — множитель критического удара.

В коде это выглядит так:

local baseAttack = 10
local multiplier = 2
local damage = baseAttack * multiplier
print(damage) -- Выведет 20

2. Строки (String)

Это текст. Строки всегда должны быть обернуты в кавычки (двойные " или одинарные ').

local message = "Добро пожаловать!"
local petName = 'Doge'

Если вы забудете кавычки, Lua подумает, что вы пытаетесь обратиться к переменной, а не написать текст, и выдаст ошибку.

Склеивание строк (Конкатенация): В Lua для соединения двух строк используется оператор две точки ...

local name = "Alex"
local greeting = "Привет, " .. name
print(greeting) -- Выведет: Привет, Alex

3. Булевы значения (Boolean)

Это самый простой тип данных. Он имеет всего два значения:

• true (истина, да, включено)
• false (ложь, нет, выключено)

Они используются для переключателей и проверок.

local isGameStarted = true
local isDoorOpen = false

4. Nil (Пустота)

Это специальный тип данных, который означает «ничего». Если переменная не имеет значения, она равна nil. Это как пустая коробка, в которой даже воздуха нет.

local emptyVariable = nil

Комментарии: Записки для себя

Иногда код становится сложным, и вы можете забыть, что делает та или иная строка. Для этого существуют комментарии. Это текст, который компьютер игнорирует, но который полезен программисту.

В Lua комментарий начинается с двух дефисов --.

local score = 0 -- Начальный счет игрока

-- Увеличиваем счет на 10 (компьютер пропустит эту строку)
score = score + 10

Практика: Создаем анкету персонажа

Давайте объединим все знания и напишем скрипт, который выводит информацию о нашем герое в консоль.

Удалите всё из вашего скрипта и напишите следующее:

-- Создаем переменные с данными героя
local heroName = "Рыцарь"
local level = 5
local isAlive = true
local weapon = "Меч"

-- Выводим приветствие
print("Имя героя: " .. heroName)
print("Уровень: " .. level)
print("Жив ли герой? " .. tostring(isAlive))

-- Рассчитываем здоровье по формуле
local baseHealth = 100
local healthBonus = level * 10
local maxHealth = baseHealth + healthBonus

print("Максимальное здоровье: " .. maxHealth)

Обратите внимание на функцию tostring(isAlive). Так как isAlive — это булево значение, а мы пытаемся склеить его со строкой, нам нужно явно превратить его в текст командой tostring.

Запустите игру (Play). В консоли вы должны увидеть:

Имя героя: Рыцарь
Уровень: 5
Жив ли герой? true
Максимальное здоровье: 150

Заключение

Поздравляю! Вы написали свой первый осмысленный код. Вы узнали, что:

• Переменные — это хранилища данных (local name = value).
• Типы данных бывают разными: числа, строки, булевы значения.
• Консоль помогает нам видеть, что происходит внутри скрипта.

В следующей статье мы научимся управлять потоком выполнения кода: заставим компьютер принимать решения с помощью условных операторов if и else. Готовьтесь, будет интересно!

Управляющие конструкции, циклы и создание собственных функций

Приветствую вас, будущие создатели миров! В прошлой лекции мы научились создавать «коробки» для данных — переменные. Мы узнали, как хранить числа, имена и состояния. Но пока наши скрипты похожи на список покупок: они просто хранят информацию и выводят её в консоль. Они не умеют думать.

Сегодня мы вдохнем в наш код жизнь. Мы научим компьютер принимать решения, выполнять рутинную работу за нас и объединять команды в удобные инструменты. Мы изучим три кита логики программирования: условные конструкции, циклы и функции.

Условные конструкции: Искусство принятия решений

В жизни мы постоянно принимаем решения по схеме «Если... то...».

• Если на улице дождь, то я беру зонт.
• Если у меня есть деньги, то я покупаю пиццу, иначе я ем бутерброд.

В Lua (и в Roblox) за это отвечает конструкция if (если).

Базовая конструкция if...then

Самый простой пример проверки условия:

local health = 0

if health == 0 then
    print("Игрок погиб!")
end

Обратите внимание на синтаксис:

1. if — начало проверки.
2. health == 0 — само условие.
3. then — слово «тогда». Код после него выполнится только если условие истинно.
4. end — конец блока проверки.

Операторы сравнения

Вы заметили, что мы использовали == вместо =. Это важно! В программировании:

• = — это присваивание (положить значение в коробку).
• == — это сравнение (проверить, равны ли значения).

Вот список основных операторов, которые вам понадобятся:

Оператор	Значение	Пример
==	Равно	5 == 5 (true)
~=	Не равно	5 ~= 3 (true)
>	Больше	10 > 5 (true)
<	Меньше	2 < 4 (true)
>=	Больше или равно	5 >= 5 (true)
<=	Меньше или равно	3 <= 4 (true)

Конструкция else и elseif

Что, если мы хотим сделать что-то, когда условие не выполнено? Для этого есть else (иначе).

local money = 5
local price = 10

if money >= price then
    print("Вы купили предмет!")
else
    print("Недостаточно средств.")
end

А если условий много? Например, проверка ранга игрока. Используем elseif (иначе если).

local rank = "Guest"

if rank == "Admin" then
    print("Привет, создатель!")
elseif rank == "VIP" then
    print("Добро пожаловать, VIP-игрок.")
else
    print("Привет, игрок.")
end

Компьютер проверяет условия сверху вниз. Как только он находит истину, он выполняет код и пропускает остальные проверки.

Циклы: Заставь компьютер работать за тебя

Представьте, что вам нужно создать 100 зомби. Писать 100 раз команду SpawnZombie() — это долго и глупо. Программисты ленивы, поэтому они придумали циклы.

Цикл — это конструкция, которая повторяет код определенное количество раз или пока выполняется условие.

Цикл while (Пока...)

Этот цикл работает до тех пор, пока условие истинно. В Roblox он часто используется для бесконечных действий (например, смена дня и ночи).

local timer = 10

while timer > 0 do
    print("Осталось: " .. timer)
    timer = timer - 1
    task.wait(1) -- Ждем 1 секунду
end

print("Время вышло!")

ВАЖНОЕ ПРАВИЛО: В бесконечных циклах while true do всегда добавляйте task.wait(). Если этого не сделать, скрипт попытается выполнить бесконечное количество операций за одну секунду, и Roblox Studio зависнет (крашнется).

Цикл for (Для...)

Этот цикл используется, когда мы точно знаем, сколько раз нужно повторить действие. Это называется «счетчик».

Синтаксис: for переменная = старт, финиш, шаг do

-- Считаем от 1 до 5
for i = 1, 5 do
    print("Круг номер: " .. i)
end

Здесь i — это переменная-счетчик. Сначала она равна 1, потом 2, и так до 5. Если шаг не указан, он равен 1.

Мы можем считать и в обратную сторону:

-- Обратный отсчет от 10 до 1 с шагом -1
for i = 10, 1, -1 do
    print(i)
end
print("Поехали!")

Функции: Ваши собственные заклинания

До этого момента мы писали код сплошным текстом. Но по мере роста игры скрипт может растянуться на тысячи строк. Чтобы не запутаться, код разбивают на функции.

Функция — это именованный блок кода, который можно вызывать в любой момент. Это как рецепт: вы один раз записываете, как печь пирог, а потом просто говорите повару: «Испеки пирог».

Создание простой функции

-- Объявляем функцию (учим компьютер)
local function sayHello()
    print("Привет!")
    print("Рады видеть тебя в Roblox.")
end

-- Вызываем функцию (используем)
sayHello()
sayHello() -- Можно вызывать сколько угодно раз

Параметры и аргументы

Функции становятся мощнее, когда мы передаем им данные. Переменные внутри скобок называются параметрами.

local function greetPlayer(name, level)
    print("Игрок " .. name .. " имеет уровень " .. level)
end

greetPlayer("Alex", 5)
greetPlayer("Noob123", 1)

Когда мы вызываем greetPlayer("Alex", 5), переменная name внутри функции становится равна "Alex", а level — 5.

Возврат значений (return)

Иногда нам нужно, чтобы функция не просто что-то напечатала, а посчитала и вернула результат, чтобы мы могли использовать его дальше.

Допустим, мы хотим рассчитать урон с учетом брони. Формула может выглядеть так:

$$FinalDamage = Damage \times (1 - \frac{Defense}{100})$$

Где $FinalDamage$ — итоговый урон, $Damage$ — базовый урон оружия, а $Defense$ — процент защиты брони (от 0 до 100).

Реализуем это в коде:

local function calculateDamage(damage, defense)
    local multiplier = 1 - (defense / 100)
    local finalDamage = damage * multiplier
    return finalDamage -- Возвращаем результат наружу
end

local myDamage = calculateDamage(50, 20) -- 50 урона, 20% защиты
print("Нанесенный урон: " .. myDamage) -- Выведет 40

Ключевое слово return останавливает функцию и «выбрасывает» значение туда, где функцию вызвали.

Практика: Система доступа к двери

Давайте объединим всё изученное. Представьте, что мы делаем дверь, которая открывается только для игроков с уровнем выше 10, но не для админов (потому что админы могут проходить сквозь стены).

local function checkAccess(level, isAdmin)
    print("Проверка доступа...")

    if isAdmin == true then
        print("Администратор: Доступ не требуется.")
        return true -- Админам всегда можно
    elseif level > 10 then
        print("Уровень " .. level .. ": Доступ разрешен!")
        return true
    else
        print("Уровень " .. level .. ": Доступ запрещен. Нужно больше 10.")
        return false
    end
end

-- Тестируем систему
local playerLevel = 5
local playerIsAdmin = false

local canEnter = checkAccess(playerLevel, playerIsAdmin)

if canEnter then
    print("Дверь открывается...")
else
    print("Дверь закрыта наглухо.")
end

Скопируйте этот код в Roblox Studio и поиграйте со значениями переменных playerLevel и playerIsAdmin. Посмотрите, как меняется результат в консоли.

Заключение

Сегодня вы сделали огромный шаг вперед. Вы научились:

1. Использовать условные операторы (if, else), чтобы скрипт принимал решения.
2. Применять циклы (while, for), чтобы автоматизировать повторения.
3. Писать собственные функции, чтобы структурировать код и делать его многоразовым.

Теперь вы знаете грамматику языка Lua. В следующей статье мы наконец-то начнем взаимодействовать с игровым миром: научимся менять цвет деталей, делать их прозрачными и двигать объекты с помощью скрипта. Мир Roblox начнет подчиняться вам по-настоящему!

Взаимодействие с игровым миром: события, физика и манипуляция объектами

Добро пожаловать обратно, создатели! В прошлых уроках мы освоили «грамматику» языка Lua: переменные, условия, циклы и функции. Теперь у нас есть инструменты, но пока мы применяли их в вакууме, выводя текст в консоль. Пришло время выйти в свет.

Roblox — это физический движок. Здесь предметы падают, сталкиваются, катятся и взрываются. В этой статье мы научимся управлять этим хаосом. Мы заставим детали менять цвет по нашему желанию, исчезать, перемещаться и реагировать на прикосновения игроков.

Иерархия: Дерево игры

Прежде чем управлять объектом, нужно понять, как до него «достучаться». Взгляните на окно Explorer (Обозреватель) в Roblox Studio. Вы видите структуру, напоминающую папки на компьютере. Это называется DataModel или иерархия «Родитель-Потомок» (Parent-Child).

Как обратиться к объекту?

Самый главный объект — это game. Это вся ваша игра. Внутри game есть служба Workspace — это видимый 3D-мир, где находятся все детали, ландшафт и персонажи.

Если вы создали деталь (Part) и назвали её SuperPart, путь к ней будет таким:

local myPart = game.Workspace.SuperPart

Относительный путь: script.Parent

Чаще всего мы кладем скрипт прямо внутрь детали, которой хотим управлять. В этом случае деталь является «Родителем» (Parent) для скрипта.

Это позволяет использовать универсальную команду:

local part = script.Parent

script.Parent означает «объект, внутри которого лежит этот скрипт». Если вы скопируете этот скрипт в другую деталь, он будет работать и с ней без изменения кода.

Свойства: Изменяем реальность

У каждого объекта в Roblox есть Свойства (Properties). Вы видите их в окне Properties, когда нажимаете на деталь: Color, Material, Transparency, Position и так далее. Скрипт может менять их мгновенно.

Допустим, у нас есть скрипт внутри детали. Давайте сделаем её полупрозрачной и призрачной.

local part = script.Parent

-- Делаем деталь полупрозрачной (0 - видно, 1 - невидимо)
part.Transparency = 0.5

-- Отключаем коллизию (сквозь деталь можно пройти)
part.CanCollide = false

-- Закрепляем деталь, чтобы она не падала
part.Anchored = true

Работа с цветом и векторами

Некоторые свойства сложнее, чем просто число или галочка. Например, цвет или позиция.

Цвет (Color3): Компьютер кодирует цвет смешиванием Красного (Red), Зеленого (Green) и Синего (Blue). В Roblox для этого используется специальный тип данных Color3.

-- Меняем цвет на ярко-красный
part.Color = Color3.fromRGB(255, 0, 0)

Позиция и Размер (Vector3): Мир Roblox трехмерен. Любая точка в пространстве описывается тремя координатами: $X$, $Y$ и $Z$. Для хранения этих координат используется тип данных Vector3.

Если мы хотим изменить размер детали или переместить её, мы должны создать новый вектор.

$$\vec{V} = (x, y, z)$$

Где $\vec{V}$ — это вектор (набор координат), $x$ — координата по ширине, $y$ — по высоте, $z$ — по глубине.

Пример изменения размера:

-- Устанавливаем размер 4 на 4 на 4 студа
part.Size = Vector3.new(4, 4, 4)

События: Реакция на действия

До сих пор наши скрипты выполнялись сразу после запуска игры. Но в играх действия происходят в ответ на что-то: игрок нажал кнопку, пуля попала в стену, персонаж коснулся монетки.

Для этого в Lua существуют События (Events) и Связи (Connections).

Самое популярное событие для физических объектов — Touched (Коснулся). Оно срабатывает, когда одна деталь физически соприкасается с другой.

Анатомия события

Чтобы использовать событие, нам нужно:

1. Создать функцию, которая выполнится при событии.
2. «Подключить» (Connect) эту функцию к событию.

Давайте создадим «Убивающую плиту» (Kill Brick) — классику всех обби (полос препятствий).

local trap = script.Parent

-- Эта функция запустится, когда кто-то коснется ловушки
local function onTouch(otherPart)
    -- otherPart — это та деталь, которая коснулась ловушки (например, Левая Нога)

    -- Ищем родителя этой детали (это должен быть персонаж)
    local character = otherPart.Parent

    -- Ищем внутри персонажа объект Humanoid (он отвечает за здоровье)
    local humanoid = character:FindFirstChild("Humanoid")

    -- Если Humanoid найден, значит это живое существо
    if humanoid then
        humanoid.Health = 0 -- Обнуляем здоровье
    end
end

-- Связываем событие Touched с нашей функцией
trap.Touched:Connect(onTouch)

Разберем, что здесь происходит:

• trap.Touched — это событие.
• :Connect(onTouch) — мы говорим: «Когда событие случится, запусти функцию onTouch».
• otherPart — это аргумент, который событие передает в функцию автоматически. Roblox сам сообщает нам, кто именно коснулся ловушки.

Практика: Исчезающий мост

Давайте создадим скрипт для моста, который исчезает через секунду после того, как на него наступили, и появляется снова через 3 секунды. Это отличный пример взаимодействия событий и свойств.

1. Создайте деталь, растяните её как мост.
2. Добавьте внутрь Script.
3. Вставьте следующий код:

local bridge = script.Parent
local isTouched = false -- Переменная-флаг, чтобы мост не мигал

local function vanish()
    if isTouched == false then
        isTouched = true -- Запоминаем, что процесс запущен

        -- Ждем секунду перед исчезновением (чтобы игрок успел пробежать)
        task.wait(0.5)

        -- Делаем мост прозрачным и проницаемым
        bridge.Transparency = 1
        bridge.CanCollide = false

        -- Ждем 3 секунды пока мост "перезаряжается"
        task.wait(3)

        -- Возвращаем мост обратно
        bridge.Transparency = 0
        bridge.CanCollide = true

        isTouched = false -- Разрешаем запускать процесс снова
    end
end

bridge.Touched:Connect(vanish)

Логика работы (Debounce)

Обратите внимание на переменную isTouched. Это называется Debounce (защита от дребезга). Событие Touched срабатывает десятки раз в секунду, пока вы стоите на детали (касается левая нога, правая нога, снова левая). Без этой проверки скрипт пытался бы запустить функцию исчезновения сотни раз одновременно, что вызвало бы ошибки или странное поведение.

Мы используем условие if isTouched == false, чтобы убедиться, что ловушка срабатывает только один раз за цикл.

Немного математики: Перемещение объектов

Иногда нам нужно не просто менять свойства, а двигать объекты плавно. Хотя для сложной физики используются TweenService или BodyMovers (о которых позже), полезно понимать, как работает сложение векторов.

Чтобы переместить объект, мы прибавляем к его текущей позиции вектор смещения.

$$\vec{P}_{new} = \vec{P}_{current} + \vec{D}$$

Где:

• $\vec{P}_{new}$ — новая позиция объекта (куда он попадет).
• $\vec{P}_{current}$ — текущая позиция объекта (где он сейчас).
• $\vec{D}$ — вектор направления и дистанции (насколько и куда сдвинуть).

Пример телепортации детали на 5 студов вверх:

local part = script.Parent
-- Vector3.new(0, 5, 0) означает: 0 по X, 5 по Y (вверх), 0 по Z
part.Position = part.Position + Vector3.new(0, 5, 0)

Заключение

Сегодня вы научились магии Roblox:

1. Обращаться к объектам через иерархию (game.Workspace, script.Parent).
2. Менять свойства объектов (Transparency, Color, CanCollide).
3. Использовать типы данных Vector3 и Color3.
4. Реагировать на физику с помощью события Touched.

Теперь вы можете создавать ловушки, двери, батуты и исчезающие платформы. Ваш мир перестал быть статичной картинкой и начал реагировать на игрока.

В следующей статье мы углубимся в работу с игроком: научимся создавать лидерборды (таблицы очков), сохранять прогресс и выдавать инструменты.

Клиент-серверная архитектура: LocalScripts, Scripts и RemoteEvents

Приветствую вас, архитекторы виртуальных миров! В прошлых уроках мы научились оживлять предметы, менять их цвета и заставлять исчезать. Но до сих пор мы упускали одну важнейшую деталь. Roblox — это многопользовательская платформа.

Вы когда-нибудь замечали в играх странные вещи? Например, вы открыли дверь, но ваш друг видит её закрытой и проходит сквозь неё, как призрак? Или вы нажали кнопку, а звук услышали только вы? Все эти загадки решаются пониманием одной темы: Клиент-серверная архитектура.

Сегодня мы переходим от простого скриптинга к настоящей разработке игр. Мы узнаем, как общаются компьютеры игроков с главным компьютером Roblox, и научимся передавать информацию между ними.

Два мира: Клиент и Сервер

Представьте себе огромный ресторан.

1. Сервер (Кухня): Это место, где готовится еда. Здесь работает шеф-повар. То, что происходит на кухне — это истина. Если шеф-повар решил, что стейк готов, значит, он готов. В Roblox Сервер — это мощный компьютер компании Roblox, который управляет игрой. Он хранит «настоящее» состояние мира: где находятся враги, сколько у кого очков и открыта ли дверь.
2. Клиент (Столик посетителя): Это ваш компьютер (или телефон). Вы сидите за столиком и видите меню. Вы можете посолить свой суп (изменить что-то у себя), но это не значит, что суп станет соленым во всем ресторане. В Roblox Клиент — это устройство игрока, которое показывает красивую картинку и принимает нажатия кнопок.

Почему это разделение важно?

Если бы каждый игрок управлял игрой со своего компьютера, начался бы хаос. Один игрок сказал бы: «Я убил босса!», а другой: «Нет, босс жив!». Сервер выступает в роли судьи. Его слово — закон.

Кроме того, это защита от читеров. Если бы игрок мог напрямую менять свои очки здоровья на сервере, игры стали бы бессмысленными. В современной архитектуре Roblox (которая называется FilteringEnabled) изменения, сделанные на Клиенте, не передаются на Сервер автоматически.

Виды скриптов: Кто где живет?

Чтобы управлять этими двумя мирами, в Roblox существуют два основных типа скриптов.

1. Script (Обычный серверный скрипт)

Это те скрипты, которые мы писали в предыдущих уроках. Они обозначаются иконкой свитка бумаги.

• Где выполняется: На Сервере.
• Что видит: Весь игровой мир.
• На кого влияет: На всех игроков сразу.
• Где обычно лежит: ServerScriptService, Workspace.

Если Script меняет цвет детали на красный, все игроки увидят, что деталь стала красной.

-- Пример серверного кода
-- Этот код сделает деталь красной для ВСЕХ
game.Workspace.Part.Color = Color3.fromRGB(255, 0, 0)

2. LocalScript (Локальный скрипт)

Обозначается иконкой свитка с человечком. Это личный скрипт игрока.

• Где выполняется: На компьютере игрока (Клиенте).
• Что видит: Только то, что загружено у этого игрока, плюс ввод с клавиатуры/мыши.
• На кого влияет: Только на этого игрока.
• Где обычно лежит: StarterPlayerScripts, StarterGui, StarterPack (инструменты).

Если LocalScript меняет цвет детали на синий, только этот игрок увидит её синей. Для остальных она останется прежней.

Важное правило: LocalScript не работает в Workspace или ServerScriptService. Он работает только в папках, принадлежащих игроку (например, внутри рюкзака или интерфейса).

Когда использовать LocalScript?

• Обработка нажатий клавиш (клавиатура, мышь).
• Создание интерфейса (GUI), кнопок на экране.
• Визуальные эффекты, которые нужны только одному игроку (например, размытие экрана при низком здоровье).
• Камера игрока.

RemoteEvents: Мост через пропасть

Итак, у нас есть проблема. Игрок нажимает кнопку «Купить меч» (это происходит в LocalScript, так как это интерфейс). Но меч должен появиться в руках, и его должны видеть все (это должен сделать Script на сервере).

Как LocalScript может попросить Script что-то сделать? Они ведь находятся на разных компьютерах!

Для этого существуют RemoteEvents (Удаленные события). Это как телефонная линия или почтовый голубь между Клиентом и Сервером.

Как это работает?

1. Мы создаем объект RemoteEvent в месте, доступном и клиенту, и серверу. Идеальное место — папка ReplicatedStorage.
2. Клиент «стреляет» событием (отправляет сигнал).
3. Сервер «слушает» это событие и выполняет код, когда сигнал получен.

Практика: Кнопка невидимости

Давайте создадим систему: игрок нажимает клавишу F, и его персонаж становится полупрозрачным для всех.

Шаг 1: Создание канала связи

1. В окне Explorer найдите папку ReplicatedStorage.
2. Создайте внутри неё RemoteEvent.
3. Переименуйте его в InvisibilityEvent.

Шаг 2: Клиентская часть (Отправка)

Создайте LocalScript в папке StarterPlayer -> StarterPlayerScripts. Назовите его InputHandler.

-- LocalScript
local UserInputService = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Находим наше событие
local invisibilityEvent = ReplicatedStorage:WaitForChild("InvisibilityEvent")

-- Функция, которая срабатывает при нажатии клавиш
local function onInputBegan(input, gameProcessed)
    if gameProcessed then return end -- Если мы печатаем в чат, игнорируем

    if input.KeyCode == Enum.KeyCode.F then
        print("Игрок нажал F, отправляем запрос на сервер...")
        -- ОТПРАВЛЯЕМ СИГНАЛ НА СЕРВЕР
        invisibilityEvent:FireServer()
    end
end

UserInputService.InputBegan:Connect(onInputBegan)

Обратите внимание на команду FireServer(). Она кричит серверу: «Эй, тут что-то случилось!».

Шаг 3: Серверная часть (Прием)

Создайте обычный Script в папке ServerScriptService. Назовите его AbilityManager.

-- Script (Server)
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Находим то же самое событие
local invisibilityEvent = ReplicatedStorage:WaitForChild("InvisibilityEvent")

-- Функция, которая выполнится на сервере
local function makeInvisible(player)
    -- ВАЖНО: Первый аргумент на сервере ВСЕГДА игрок, который отправил сигнал
    print("Сигнал получен от игрока: " .. player.Name)

    local character = player.Character
    if character then
        -- Перебираем все части тела и делаем их прозрачными
        for _, part in pairs(character:GetChildren()) do
            if part:IsA("BasePart") then
                part.Transparency = 0.5
            end
        end
    end
end

-- Подключаем функцию к событию
invisibilityEvent.OnServerEvent:Connect(makeInvisible)

Магия аргументов

Заметьте важную деталь. В LocalScript мы написали FireServer() (пустые скобки). А в Script мы принимаем makeInvisible(player). Откуда взялся player?

Roblox автоматически добавляет игрока, отправившего сигнал, как первый аргумент при получении на сервере. Это сделано для безопасности, чтобы вы всегда точно знали, кто именно запросил действие, и хакер не мог притвориться другим игроком.

Обратная связь: Сервер -> Клиент

Иногда серверу нужно сказать что-то конкретному клиенту. Например, «У тебя недостаточно денег».

Для этого используется метод FireClient(player).

1. Сервер: `RemoteEvent:FireClient(player,

Создание интерфейсов (GUI) и сохранение данных игрока через DataStore

Приветствую вас, будущие разработчики! Мы уже прошли долгий путь: научились писать скрипты, управлять физикой и даже наладили связь между клиентом и сервером. Но посмотрите на свой экран. Чего-то не хватает, верно?

В любой хорошей игре есть интерфейс (GUI). Полоска здоровья, счетчик монет, кнопка магазина — всё это помогает игроку понимать, что происходит. А еще, представьте разочарование игрока, который заработал миллион монет, вышел из игры, вернулся... а монет снова ноль. Чтобы этого не случилось, нам нужно научиться сохранять данные.

Сегодня мы объединим визуальную часть (GUI) и серверную память (DataStore), чтобы превратить ваш проект в полноценную игру.

GUI: Графический интерфейс пользователя

GUI (Graphical User Interface) в Roblox — это всё, что накладывается поверх 3D-мира на экран игрока. Это 2D-элементы: текст, картинки, кнопки.

Где живет интерфейс?

Все элементы интерфейса хранятся в специальной папке StarterGui. Когда игра начинается, всё содержимое этой папки копируется каждому игроку в его личную папку PlayerGui.

Чтобы создать свой первый интерфейс:

1. Наведите курсор на StarterGui в окне Explorer.
2. Нажмите + и выберите ScreenGui. Это «холст», на котором мы будем рисовать.
3. Внутри ScreenGui создайте TextLabel (Текстовая метка) или TextButton (Кнопка).

Позиционирование: Scale против Offset

Это самая частая ошибка новичков. Вы красиво расставили кнопки на своем большом мониторе, а ваш друг зашел с телефона, и у него кнопки улетели за край экрана. Почему?

В Roblox координаты интерфейса задаются типом данных UDim2. Он состоит из четырех чисел: {Scale X, Offset X}, {Scale Y, Offset Y}.

• Offset (Смещение): Размер в пикселях. Если вы поставите кнопку на 100 пикселей вправо, она всегда будет там, независимо от размера экрана.
• Scale (Масштаб): Процент от размера экрана (от 0 до 1). 0.5 — это ровно середина.

Формула расчета итоговой позиции в пикселях выглядит так:

$$P_{final} = S \times D_{screen} + O$$

Где:

• $P_{final}$ — итоговая позиция в пикселях.
• $S$ — значение Scale (например, 0.5 для 50%).
• $D_{screen}$ — размер экрана в этом измерении (ширина или высота).
• $O$ — значение Offset (добавочные пиксели).

Совет профессора: Всегда старайтесь использовать Scale для позиционирования и размера основных элементов, чтобы ваша игра выглядела хорошо и на компьютере, и на планшете.

Скриптинг интерфейса

Интерфейс — это клиентская часть. Поэтому для управления им мы используем LocalScript. Давайте сделаем так, чтобы текст на экране показывал имя игрока.

1. Создайте ScreenGui, внутри него TextLabel.
2. Внутри TextLabel создайте LocalScript.

local label = script.Parent
local player = game.Players.LocalPlayer

label.Text = "Привет, " .. player.Name .. "!"

Всё просто! Мы обратились к локальному игроку и изменили свойство Text.

DataStore: Как не потерять прогресс

Теперь перейдем к более сложной, но важной теме. DataStoreService — это служба Roblox, которая позволяет сохранять данные на серверах Roblox. Это как огромный облачный сейф.

Правила безопасности

1. Только сервер: DataStore работает только в обычных Script. LocalScript не имеет к нему доступа ради безопасности (иначе читеры могли бы нарисовать себе миллион монет).
2. Лимиты: Нельзя сохранять данные слишком часто. Roblox имеет ограничения на количество запросов.

Основные функции

Для работы нам понадобятся три метода:

• GetDataStore("Name") — открывает (или создает) хранилище с определенным именем.
• GetAsync(key) — читает данные из ячейки key.
• SetAsync(key, value) — записывает значение value в ячейку key.

Leaderstats: Стандартная статистика

В Roblox есть встроенная система отображения очков — leaderstats. Если создать в игроке папку с таким именем, Roblox автоматически покажет список игроков и их очки в углу экрана.

Давайте напишем полноценный скрипт, который создает статистику и сохраняет её.

Создайте Script в ServerScriptService и назовите его DataManager.

local DataStoreService = game:GetService("DataStoreService")
local myDataStore = DataStoreService:GetDataStore("PlayerMoneyData")

-- Функция, которая срабатывает при входе игрока
game.Players.PlayerAdded:Connect(function(player)
    -- 1. Создаем папку leaderstats
    local leaderstats = Instance.new("Folder")
    leaderstats.Name = "leaderstats"
    leaderstats.Parent = player

    -- 2. Создаем валюту (Money)
    local money = Instance.new("IntValue")
    money.Name = "Money"
    money.Parent = leaderstats

    -- 3. Загружаем данные
    local playerKey = "User_" .. player.UserId -- Уникальный ключ для каждого игрока

    local success, savedMoney = pcall(function()
        return myDataStore:GetAsync(playerKey)
    end)

    if success then
        if savedMoney then
            money.Value = savedMoney -- Если данные были, ставим их
            print("Данные загружены для " .. player.Name)
        else
            money.Value = 0 -- Если данных нет (новый игрок), ставим 0
            print("Новый игрок: " .. player.Name)
        end
    else
        warn("Ошибка загрузки данных!")
    end
end)

-- Функция сохранения при выходе
game.Players.PlayerRemoving:Connect(function(player)
    local playerKey = "User_" .. player.UserId
    local moneyValue = player.leaderstats.Money.Value

    local success, errorMessage = pcall(function()
        myDataStore:SetAsync(playerKey, moneyValue)
    end)

    if success then
        print("Данные сохранены для " .. player.Name)
    else
        warn("Не удалось сохранить данные: " .. errorMessage)
    end
end)

Что такое pcall?

Вы заметили странную конструкцию pcall? Это сокращение от Protected Call (Защищенный вызов).

Работа с интернетом ненадежна. Сервер может зависнуть, интернет может моргнуть. Если обычная функция выдаст ошибку, весь скрипт сломается. pcall позволяет «попробовать» выполнить код. Если произойдет ошибка, скрипт не упадет, а просто вернет false в переменную success.

Связываем GUI и Данные

Теперь у нас есть деньги на сервере (в leaderstats), и они сохраняются. Давайте выведем их на экран в красивую рамку, а не в стандартный список.

1. В StarterGui создайте ScreenGui -> TextLabel.
2. В TextLabel добавьте LocalScript.

local label = script.Parent
local player = game.Players.LocalPlayer

-- Ждем, пока загрузится статистика
local leaderstats = player:WaitForChild("leaderstats")
local money = leaderstats:WaitForChild("Money")

-- Функция обновления текста
local function updateMoney()
    label.Text = "Монеты: " .. money.Value
end

-- Обновляем сразу при запуске
updateMoney()

-- И подписываемся на изменение значения
money.Changed:Connect(updateMoney)

Теперь, как только сервер изменит количество денег (например, вы дадите игроку награду), текст на экране игрока обновится мгновенно.

Важное примечание о тестировании

DataStore часто не работает в Roblox Studio, если не включить специальную настройку. Чтобы протестировать сохранение:

1. Зайдите во вкладку Home -> Game Settings.
2. Перейдите в раздел Security.
3. Включите Enable Studio Access to API Services.

Без этой галочки ваши скрипты сохранения будут выдавать ошибку в режиме тестирования.

Заключение

Поздравляю! Вы создали фундамент настоящей игры. Теперь у вас есть:

• Интерфейс, который адаптируется под экраны.
• Система сохранения, которая помнит прогресс игрока.
• Связь между данными на сервере и картинкой на клиенте.

В следующей статье мы добавим в игру динамики: научимся работать со звуками и анимациями, чтобы сделать мир живым и насыщенным. Готовьте наушники!