Основы скриптинга в Roblox: Создаем первый код на Luau

Знакомство с Roblox Studio: интерфейс, окно Output и создание первого скрипта

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

В этом курсе мы будем изучать язык Luau. Это версия языка Lua, специально адаптированная и улучшенная инженерами Roblox. Он быстрый, легкий в освоении и прощает многие ошибки новичкам, что делает его идеальным для старта в программировании.

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

Подготовка рабочего пространства

Прежде чем писать код, нужно разобраться, где мы будем это делать. Интерфейс Roblox Studio может показаться перегруженным кнопками и окнами, но для скриптинга нам понадобятся всего несколько ключевых элементов.

Окно Explorer (Обозреватель)

Это, пожалуй, самое важное окно для разработчика. Оно отображает иерархическую структуру вашей игры. Всё в Roblox — это объекты (Instance), и все они живут здесь.

Представьте Explorer как файловую систему вашего компьютера, где есть папки и файлы. В Roblox есть главные сервисы (папки верхнего уровня), такие как:

• Workspace: здесь находится всё, что физически существует в игровом мире (детали, ландшафт, персонажи).
• Players: сервис, содержащий информацию о подключенных игроках.
• Lighting: настройки освещения.
• ServerScriptService: специальное место для хранения серверных скриптов. Именно здесь мы будем работать чаще всего в начале курса.

Если вы не видите окно Explorer, перейдите во вкладку View (Вид) в верхней панели инструментов и нажмите на кнопку Explorer.

Окно Properties (Свойства)

Это окно обычно находится под Explorer. Оно показывает настройки выделенного объекта. Например, если вы выберете деталь (Part) в Workspace, в окне Properties вы увидите её цвет (Color), прозрачность (Transparency), позицию (Position) и размер (Size).

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

Главный инструмент программиста: Окно Output

Многие новички игнорируют это окно, и это их главная ошибка. Окно Output (Вывод) — это консоль, через которую игра общается с вами.

Зачем нужно окно Output:

1. Отладка (Debugging): Здесь появляются сообщения об ошибках. Если вы напишете код неправильно, Roblox напишет здесь красный текст, объясняющий, что пошло не так и в какой строке.
2. Логирование: Вы можете отправлять сюда свои собственные сообщения, чтобы проверить, работает ли определенная часть кода.

Как открыть Output

1. Перейдите во вкладку View (Вид) в верхней части экрана.
2. Найдите иконку Output (обычно рядом с Explorer и Properties).
3. Нажмите на неё. В нижней части экрана появится окно консоли.

Никогда не закрывайте окно Output во время программирования. Это ваши «глаза», позволяющие видеть, что происходит внутри «мозга» игры.

Создание первого скрипта

В Roblox существует три основных типа скриптов:

1. Script (Серверный скрипт): Выполняется на сервере. Управляет игровой логикой, сохранением данных, взаимодействием между игроками. Его видят все.
2. LocalScript (Локальный скрипт): Выполняется на компьютере игрока (клиенте). Отвечает за интерфейс (GUI), нажатия клавиш и визуальные эффекты, касающиеся только одного игрока.
3. ModuleScript (Модульный скрипт): Библиотека кода, которую могут использовать другие скрипты.

Мы начнем с обычного Script.

Шаг 1: Создание объекта Script

Лучшее место для хранения серверной логики — это сервис ServerScriptService. Скрипты, помещенные сюда, защищены и гарантированно запускаются при старте сервера.

1. В окне Explorer найдите папку ServerScriptService.
2. Наведите на неё курсор и нажмите на значок + (плюс), который появится справа от названия.
3. В появившемся меню поиска начните вводить слово Script.
4. Выберите объект Script (иконка выглядит как свиток с кодом).

[VISUALIZATION: Крупный план окна Explorer. Курсор мыши нажимает на плюс рядом с ServerScriptService. В выпадающем меню выделен пункт

Основы синтаксиса Luau: переменные, типы данных и вывод информации в консоль

В предыдущей статье мы подготовили наше рабочее место: изучили интерфейс Roblox Studio, узнали, где живут скрипты, и открыли окно Output. Теперь пришло время наполнить эти скрипты смыслом. Мы начинаем погружение в синтаксис языка Luau.

Синтаксис — это набор правил, по которым строится язык программирования. Как в русском языке есть правила пунктуации и орфографии, так и в Luau есть строгие законы написания кода. Если вы их нарушите, скрипт просто не запустится, а в консоли появится красная ошибка.

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

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

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

Компьютер полностью игнорирует комментарии при выполнении скрипта. В Luau комментарии создаются с помощью двух дефисов --.

-- Это однострочный комментарий. Игра его не видит.
print("А эту строку игра выполнит!") -- Комментарий может быть и в конце строки

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

--[[
Это многострочный комментарий.
Здесь можно писать целые поэмы,
и скрипт их проигнорирует.
]]

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

Переменные: Контейнеры для данных

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

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

Создание переменной

В Luau для создания (объявления) переменной используется ключевое слово local. Оно говорит компьютеру: «Создай локальную переменную здесь и сейчас».

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

local имяПеременной = значение

Разберем на примере:

local myName = "Alex"
local playerHealth = 100
local isAlive = true

Что здесь произошло:

1. Мы создали коробку с именем myName и положили туда текст "Alex".
2. Мы создали коробку playerHealth и положили туда число 100.
3. Мы создали коробку isAlive и положили туда логическое значение true (истина).

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

Вы не можете называть переменные как угодно. Есть правила:

• Только латиница: Используйте английские буквы, цифры и нижнее подчеркивание _.
• Не начинать с цифры: 1stPlayer — ошибка, player1 — правильно.
• Без пробелов: my score — ошибка, myScore — правильно.
• Регистр важен: score, Score и SCORE — это три разные переменные.

В сообществе Roblox принято использовать стиль camelCase (верблюжий регистр). Первое слово пишется с маленькой буквы, а каждое следующее — с большой. Например: walkingSpeed, maxAmmoCount, partColor.

Зачем нужно слово local?

Вы можете увидеть старые уроки, где пишут просто score = 10 без local. В Luau так делать не рекомендуется. Переменная без local становится глобальной для всего скрипта, что замедляет работу кода и может вызвать ошибки, если вы случайно используете одно и то же имя в разных местах. Всегда используйте local.

Типы данных

В наши «коробки» можно класть разные вещи. В Luau есть несколько основных типов данных, с которыми вы будете работать 90% времени.

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

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

local emptyBox -- Значение равно nil

2. Number (Число)

В отличие от некоторых других языков, в Luau нет разделения на целые числа (integers) и дробные (floats). Всё это — просто тип number.

local age = 15
local speed = 16.5
local temperature = -5

С числами можно производить математические операции:

local a = 10
local b = 5

local sum = a + b       -- Сложение (15)
local diff = a - b      -- Вычитание (5)
local mult = a * b      -- Умножение (50)
local div = a / b       -- Деление (2)
local power = a ^ 2     -- Возведение в степень (100)

3. String (Строка)

Строка — это текст. Строки всегда должны быть обернуты в кавычки. Можно использовать двойные " или одинарные ' кавычки.

local greeting = "Привет, Роблокс!"
local name = 'Игрок'

Важно: Если вы напишете текст без кавычек, Luau подумает, что это имя переменной, и выдаст ошибку, если такой переменной нет.

Конкатенация (Склеивание строк)

В математике мы используем плюс + для сложения чисел. Но для склеивания строк в Luau используется оператор две точки ...

local firstName = "Roblox"
local lastName = "Developer"

-- Результат будет "Roblox Developer"
local fullName = firstName .. " " .. lastName

4. Boolean (Логический тип)

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

• true (Истина / Да / Включено)
• false (Ложь / Нет / Выключено)

local isDoorOpen = false
local canJump = true

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

Вывод информации: print()

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

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

local apples = 5
local pears = 3

print("У нас есть яблоки:")
print(apples)

print("Всего фруктов:")
print(apples + pears)

Функция print() умеет принимать несколько аргументов, разделенных запятой. Это удобно для форматирования вывода:

local score = 1500
print("Текущий счет игрока:", score)
-- В Output будет: Текущий счет игрока: 1500

Динамическая типизация

Luau — язык с динамической типизацией. Это значит, что одна и та же переменная может сначала хранить число, а потом — строку. Тип переменной определяется тем, что в ней лежит прямо сейчас.

local myVar = 10      -- Сейчас это число
print(myVar)

myVar = "Теперь текст" -- Теперь это строка
print(myVar)

Хотя это возможно, старайтесь не злоупотреблять этим. Если переменная называется playerScore, не стоит класть в неё текст "Много", так как это запутает вас в будущем.

Чтобы узнать, какой тип данных хранится в переменной прямо сейчас, можно использовать команду type():

local data = 50
print(type(data)) -- Выведет "number"

data = true
print(type(data)) -- Выведет "boolean"

Практическое задание

Давайте соберем всё вместе и напишем скрипт, который рассчитывает характеристики персонажа.

1. Создайте новый Script в ServerScriptService.
2. Удалите print("Hello world!").
3. Напишите следующий код:

-- Характеристики героя
local heroName = "Рыцарь"
local baseDamage = 10
local weaponBonus = 5
local levelMultiplier = 2

-- Вычисление итогового урона
-- Сначала складываем базу и бонус, потом умножаем на уровень
local totalDamage = (baseDamage + weaponBonus) * levelMultiplier

-- Вывод информации
print("Статистика героя:", heroName)
print("Базовый урон:", baseDamage)
print("Бонус оружия:", weaponBonus)
print("Итоговая сила удара:", totalDamage)

4. Нажмите Play (или Run) и посмотрите в окно Output.

Если вы всё сделали правильно, вы увидите расчет силы вашего рыцаря. Попробуйте изменить значения переменных baseDamage или levelMultiplier и запустите снова, чтобы увидеть, как меняется результат.

Заключение

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

• Как создавать «коробки» для данных с помощью local.
• Чем число отличается от строки и булева значения.
• Как склеивать строки и проводить математические операции.
• Как использовать print() для проверки своих расчетов.

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

Взаимодействие с игровым миром: обращение к объектам и изменение их свойств через код

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

В этой статье мы перейдем к самой захватывающей части скриптинга — взаимодействию с 3D-миром. Мы научимся писать код, который находит объекты на карте (например, детали, источники света или партиклы) и меняет их свойства в реальном времени. Представьте мост, который становится прозрачным, когда на него наступают, или лампу, меняющую цвет каждую секунду. Всё это делается через изменение свойств объектов.

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

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

Родители и Потомки (Parents and Children)

В Roblox существуют два ключевых понятия, описывающих отношения между объектами:

1. Parent (Родитель) — это объект, внутри которого находится наш объект. У каждого объекта может быть только один родитель.
2. Children (Потомки/Дети) — это объекты, которые находятся внутри нашего объекта. У одного родителя может быть сколько угодно детей.

Посмотрите на окно Explorer. Если Part находится внутри Workspace, то:

• Workspace — это Parent для Part.
• Part — это Child для Workspace.

Адресация: Как найти объект через код

Самый главный объект в игре, корень всего дерева, называется game. Чтобы обратиться к любой детали, мы должны проложить к ней «путь», начиная от game, перечисляя имена всех объектов через точку .. Это называется Dot Notation (Точечная нотация).

Представьте, что у вас в Workspace лежит деталь с именем SuperPart.

Путь к ней будет выглядеть так: game.Workspace.SuperPart

Давайте разберем этот путь:

1. game — начало пути, вся игра.
2. .Workspace — мы заходим в сервис Workspace, где лежит физический мир.
3. .SuperPart — мы находим внутри Workspace конкретную деталь.

Пример в коде

Допустим, мы хотим изменить прозрачность этой детали. Мы можем сохранить ссылку на объект в переменную, чтобы не писать длинный путь каждый раз.

-- Создаем переменную, которая ссылается на нашу деталь
local myPart = game.Workspace.SuperPart

-- Теперь myPart - это пульт управления этой деталью
print(myPart.Name) -- Выведет "SuperPart"

Важно: Имена в скрипте должны точь-в-точь совпадать с именами в окне Explorer. superPart, Superpart и SuperPart — это три разных имени для Luau. Если вы ошибетесь в одной букве, скрипт выдаст ошибку, так как не сможет найти объект.

Изменение свойств (Properties)

Когда мы «схватили» объект и положили ссылку на него в переменную, мы получаем доступ к его свойствам. Вспомните окно Properties: там есть Transparency, Color, Anchored, CanCollide и многое другое. В коде мы обращаемся к ним так же — через точку.

Формула изменения свойства: Объект.Свойство = НовоеЗначение

1. Прозрачность (Transparency)

Свойство Transparency принимает число от 0 до 1.

• 0 — полностью видимый.
• 1 — полностью невидимый.
• 0.5 — полупрозрачный (как стекло).

local wall = game.Workspace.Wall

-- Делаем стену полупрозрачной
wall.Transparency = 0.5

2. Закрепление (Anchored)

Свойство Anchored определяет, падает ли деталь под действием гравитации. Это тип данных boolean (истина/ложь).

local fallingBlock = game.Workspace.Block

-- Отключаем гравитацию, блок зависнет в воздухе
fallingBlock.Anchored = true

-- Включаем физику, блок упадет
fallingBlock.Anchored = false

3. Цвет (Color и BrickColor)

С цветом всё немного сложнее. В Roblox есть два способа задать цвет:

Способ А: BrickColor Это палитра готовых цветов Roblox (те самые названия вроде "Bright red" или "Really blue").

local part = game.Workspace.Part

-- Создаем новый BrickColor по названию
part.BrickColor = BrickColor.new("Bright red")

Способ Б: Color3 Это более профессиональный способ, позволяющий смешивать Красный (Red), Зеленый (Green) и Синий (Blue) каналы. Значения каналов могут быть от 0 до 1 (или от 0 до 255, если использовать специальный конструктор).

local part = game.Workspace.Part

-- Color3.fromRGB принимает значения от 0 до 255
-- (255, 0, 0) — это чистый красный
part.Color = Color3.fromRGB(255, 0, 0)

Обратите внимание: свойство называется Color, но значение мы создаем через Color3. Если вы используете BrickColor, то и свойство называется BrickColor.

Относительная адресация: script.Parent

Писать полные пути вроде game.Workspace.PartName не всегда удобно. Что, если вы переименуете деталь? Вам придется переписывать код. Что, если вы скопируете деталь? Скрипт внутри копии всё равно будет искать оригинальную деталь по имени.

Чтобы решить эту проблему, используют относительную адресацию.

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

script — это ссылка на сам файл скрипта, который выполняется прямо сейчас. .Parent — это обращение к его родителю.

Пример:

1. Создайте деталь в Workspace.
2. Внутри детали создайте Script.
3. Напишите код:

local myPart = script.Parent -- Скрипт находит своего родителя (деталь)

myPart.Transparency = 1 -- Деталь становится невидимой

Такой скрипт можно копировать и вставлять в любые другие детали, и он всегда будет работать с той деталью, внутри которой лежит.

Время и ожидание: task.wait()

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

Чтобы увидеть изменения, нам часто нужно просить скрипт «подождать». Для этого используется команда task.wait(секунды).

Давайте напишем скрипт «Светофор». Создайте деталь, положите в неё скрипт и напишите:

local light = script.Parent

-- Ждем 3 секунды после старта игры
task.wait(3)

-- Включаем красный свет
light.Color = Color3.fromRGB(255, 0, 0)
print("Красный свет!")

-- Ждем еще 2 секунды
task.wait(2)

-- Включаем зеленый свет
light.Color = Color3.fromRGB(0, 255, 0)
print("Зеленый свет!")

Когда вы нажмете Play, вы увидите, как деталь меняет цвет с задержкой.

Типы данных свойств

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

Свойство	Тип данных	Пример значения
Transparency	number	0.5
Name	string	"MyPart"
Anchored	boolean	true
CanCollide	boolean	false
Color	Color3	Color3.fromRGB(255, 255, 255)
Position	Vector3	Vector3.new(0, 10, 0)
Size	Vector3	Vector3.new(4, 1, 2)

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

Практическое задание: Исчезающая платформа

Давайте создадим классическую ловушку из платформеров: платформу, которая исчезает через несколько секунд.

1. Создайте деталь (Part) в Workspace.
2. Убедитесь, что она закреплена (Anchored = true), чтобы она не упала сразу.
3. Добавьте внутрь детали Script.
4. Напишите код:

local platform = script.Parent

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

-- Делаем платформу полупрозрачной (предупреждение)
platform.Transparency = 0.5
platform.BrickColor = BrickColor.new("Really red")

-- Ждем еще 1 секунду
task.wait(1)

-- Платформа исчезает и сквозь нее можно упасть
platform.Transparency = 1
platform.CanCollide = false -- Отключаем столкновения

print("Платформа исчезла!")

Запустите игру и встаньте на платформу. Через 5 секунд она покраснеет, а еще через секунду вы провалитесь сквозь неё.

Заключение

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

• Как устроена иерархия объектов (Parent/Children).
• Как находить объекты через game.Workspace.
• Как использовать script.Parent для универсальных скриптов.
• Как менять свойства: цвет, прозрачность и физику.
• Как использовать task.wait() для создания пауз.

Теперь ваш мир не статичен. Но пока что наши скрипты выполняются один раз и заканчиваются. А что, если мы хотим, чтобы платформа исчезала и появлялась снова и снова? Или чтобы дверь открывалась только тогда, когда к ней подходит игрок? Для этого нам понадобятся Циклы и Функции, о которых мы поговорим в следующих статьях.

Логика и действия: введение в функции и обработку событий Touched

Добро пожаловать обратно в курс «Основы скриптинга в Roblox»! В прошлых статьях мы научились менять свойства объектов: красить детали, делать их прозрачными и даже заставлять их исчезать. Но у наших скриптов была одна большая проблема: они были линейными и «одноразовыми». Код запускался, выполнял инструкции сверху вниз и заканчивался.

Представьте, если бы выключатель света в вашей комнате работал только один раз: вы нажали его, свет включился, и больше выключатель не работает. Это неудобно. В играх нам нужно, чтобы код реагировал на действия игрока снова и снова. Дверь должна открываться каждый раз, когда к ней подходят. Лава должна убивать игрока в любой момент касания.

Сегодня мы сделаем огромный шаг вперед. Мы превратим наши скрипты из простых списков инструкций в умные механизмы, реагирующие на окружающий мир. Мы изучим Функции (способы упаковки кода) и События (сигналы, запускающие этот код).

Функции: Рецепты действий

До этого момента мы писали код просто в теле скрипта. Но что, если нам нужно выполнить одно и то же действие пять раз в разные моменты времени? Копировать и вставлять код — плохая практика. Это делает скрипт огромным и сложным для исправления.

В программировании для этого существуют функции.

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

Создание функции

В Luau функция создается с помощью ключевых слов local function, за которыми следует имя функции, скобки () и завершающее слово end.

-- Объявление функции (создание рецепта)
local function changeColor()
	print("Меняем цвет детали!")
	game.Workspace.Part.BrickColor = BrickColor.new("Bright green")
end

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

Вызов функции

Чтобы код внутри функции сработал, функцию нужно вызвать (Call). Это делается написанием имени функции со скобками.

-- 1. Создаем рецепт
local function changeColor()
	print("Меняем цвет детали!")
	game.Workspace.Part.BrickColor = BrickColor.new("Bright green")
end

-- 2. Готовим по рецепту (вызываем функцию)
changeColor()

-- Можно вызвать её снова через паузу
task.wait(2)
changeColor()

Теперь, когда скрипт дойдет до строчки changeColor(), он «прыгнет» внутрь функции, выполнит весь код между function и end, а затем вернется обратно.

События: Триггеры игрового мира

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

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

Событие — это специальный сигнал, который объект подает, когда с ним что-то случается. У каждого объекта в Roblox есть свой набор событий.

• У детали (Part) есть событие Touched (Коснулись).
• У кнопки на экране есть событие MouseButton1Click (Клик мышкой).
• У игрока есть событие Died (Умер).

Связь события и функции

Чтобы заставить событие запускать нашу функцию, мы используем команду :Connect(). Это как подключить провода: мы соединяем «дверной звонок» (Событие) с «динамиком» (Функция).

Формула выглядит так: Объект.Событие:Connect(ИмяФункции)

Обратите внимание: когда мы пишем имя функции внутри Connect, мы не ставим скобки (). Мы передаем саму функцию, а не результат её работы.

Событие Touched: Основа взаимодействия

Самое популярное событие для новичков — это Touched. Оно срабатывает каждый раз, когда один физический объект касается другого. Именно на этом событии строятся ловушки, чекпоинты, двери и магазины.

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

1. Создайте деталь в Workspace и назовите её MagicPart.
2. Добавьте внутрь неё Script.
3. Напишите следующий код:

local part = script.Parent

-- 1. Создаем функцию
local function onTouch()
	print("Кто-то коснулся детали!")
	part.Color = Color3.new(math.random(), math.random(), math.random())
end

-- 2. Подключаем функцию к событию Touched
part.Touched:Connect(onTouch)

Запустите игру и побегайте персонажем по этой детали. Каждый раз, когда ваша нога или туловище касается детали, она будет менять цвет. В окне Output вы увидите поток сообщений «Кто-то коснулся детали!».

Интересный факт: Событие Touched очень чувствительное. Когда ваш персонаж стоит на детали, событие может срабатывать десятки раз в секунду, потому что физический движок постоянно регистрирует микро-столкновения стоп персонажа с поверхностью.

Параметры функции и аргумент hit

В примере выше мы знали, что кто-то коснулся детали, но не знали кто именно. Может, это был игрок? А может, на деталь упал мяч или обломок стены?

Функции могут принимать входящую информацию. Это называется параметры (или аргументы). Представьте, что в нашем рецепте пирога есть пустые места, куда можно вписать начинку: «яблоко» или «вишня».

Когда срабатывает событие Touched, Roblox автоматически передает в подключенную функцию информацию о том, какая именно деталь коснулась нашей детали.

Давайте обновим наш код, чтобы увидеть это:

local part = script.Parent

-- Добавляем параметр hit внутри скобок
local function onTouch(hit)
	print("Касание произошло с:", hit.Name)
	part.Transparency = 0.5
end

part.Touched:Connect(onTouch)

Переменная hit (вы можете назвать её как угодно, например otherPart, но hit — это стандарт) теперь содержит ссылку на объект, который врезался в нашу деталь.

Если на деталь наступит игрок, hit будет равен LeftFoot (Левая стопа) или RightFoot (Правая стопа).

Создание Kill Brick (Убивающей детали)

Теперь у нас есть все знания, чтобы создать классику Roblox — красный блок, который убивает игрока. Это называется «Kill Brick» или «Лава».

Для этого нам нужно понять структуру персонажа в Roblox. Персонаж — это Model (Модель), внутри которой лежат:

1. Детали тела (Head, Torso, LeftLeg и т.д.).
2. Особый объект Humanoid.

Humanoid — это объект, который отвечает за здоровье (Health), скорость ходьбы и имя над головой. Если сделать Health равным 0, персонаж развалится на части и возродится.

Логика убийства

Когда срабатывает Touched, мы получаем hit (например, Левую Ногу).

1. Нам нужно найти родителя этой ноги (hit.Parent), чтобы получить Модель персонажа.
2. Внутри этой Модели мы должны поискать объект Humanoid.
3. Если Humanoid найден, значит, это живое существо, и мы можем его убить.

Для поиска объекта используется метод :FindFirstChild("Имя"). Он лучше, чем просто точка, потому что если объекта нет, скрипт не сломается, а просто вернет nil (пустоту).

Итоговый код Kill Brick

Создайте новую деталь, покрасьте её в ярко-красный цвет и добавьте скрипт:

local trap = script.Parent

local function killPlayer(hit)
	-- 1. Ищем родителя детали, которая коснулась ловушки
	local character = hit.Parent

	-- 2. Пробуем найти внутри родителя объект Humanoid
	local humanoid = character:FindFirstChild("Humanoid")

	-- 3. Проверяем: если humanoid существует (не nil), то...
	if humanoid then
		humanoid.Health = 0 -- Обнуляем здоровье
		print(character.Name .. " погиб в лаве!")
	end
end

trap.Touched:Connect(killPlayer)

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

• local character = hit.Parent: Если hit — это нога, то character — это сам персонаж.
• `local humanoid = character:FindFirstChild(

Практикум: создание скрипта для смертельного блока (Kill Brick) или изменения цвета

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

В этой статье мы не будем учить новые сложные концепции языка. Вместо этого мы сосредоточимся на создании двух классических игровых элементов, которые есть почти в каждом «Обби» (полосе препятствий): Смертельный блок (Kill Brick) и Волшебная плита, меняющая цвет.

Мы разберем каждую строчку кода, научимся избегать популярных ошибок новичков и узнаем о важном приеме программирования — «Дебаунсе» (Debounce).

Проект 1: Волшебная плита (Color Changing Part)

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

Подготовка сцены

1. Откройте Roblox Studio.
2. Создайте новую деталь (Part) в окне просмотра.
3. Измените её размер, чтобы на ней было удобно стоять (например, $4, 1, 4$).
4. Убедитесь, что свойство Anchored включено (галочка стоит), иначе деталь улетит, если вы её пнете.
5. Переименуйте деталь в ColorPart.
6. Добавьте внутрь детали новый Script.

Написание кода

В предыдущем уроке мы уже касались смены цвета. Теперь давайте сделаем это правильно, используя Color3 и генератор случайных чисел.

Введите следующий код в ваш скрипт:

local part = script.Parent

-- Функция для смены цвета
local function changeColor(hit)
	-- Создаем случайный цвет
	-- math.random() выдает дробное число от 0 до 1
	local randomColor = Color3.new(math.random(), math.random(), math.random())

	-- Применяем цвет к детали
	part.Color = randomColor
	print("Цвет изменен!")
end

-- Подключаем событие
part.Touched:Connect(changeColor)

Проблема частого срабатывания

Если вы запустите этот код и встанете на платформу, вы заметите странность: цвет меняется с бешеной скоростью, создавая эффект стробоскопа. В окне Output появятся сотни сообщений «Цвет изменен!» за пару секунд.

Почему это происходит? Событие Touched срабатывает при каждом физическом контакте. Когда персонаж стоит на блоке, его стопы немного двигаются (анимация дыхания, микро-движения физики), и каждое такое движение регистрируется как новое касание.

Чтобы это исправить, нам нужен Debounce (Задержка или «Антидребезг»).

Важная концепция: Debounce

Debounce — это способ заставить скрипт «остыть» перед следующим выполнением. Представьте турникет в метро: после того как один человек прошел, створки закрываются, и турникет блокируется на пару секунд, прежде чем пропустить следующего.

В коде это реализуется через логическую переменную (boolean), которая служит «замком».

Улучшенный код с задержкой

Давайте перепишем наш скрипт, добавив проверку активности.

local part = script.Parent

-- Переменная-замок.
-- false означает, что скрипт "свободен" и готов работать.
local isProcessing = false

local function changeColor(hit)
	-- 1. Проверяем замок. Если скрипт УЖЕ занят, мы выходим.
	if isProcessing == true then
		return -- Команда return немедленно прерывает выполнение функции
	end

	-- 2. Закрываем замок. Теперь другие касания будут игнорироваться.
	isProcessing = true

	-- 3. Выполняем полезное действие
	local randomColor = Color3.new(math.random(), math.random(), math.random())
	part.Color = randomColor
	print("Цвет изменен с задержкой!")

	-- 4. Ждем некоторое время (например, 1 секунду)
	task.wait(1)

	-- 5. Открываем замок. Скрипт снова готов к работе.
	isProcessing = false
end

part.Touched:Connect(changeColor)

Теперь, если вы встанете на платформу, цвет будет меняться ровно один раз в секунду, независимо от того, сколько раз физический движок зарегистрировал касание. Этот паттерн (шаблон) кода вы будете использовать постоянно: для оружия, дверей, кнопок и способностей.

Проект 2: Смертельный блок (Kill Brick)

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

Подготовка

1. Создайте новую деталь.
2. Покрасьте её в ярко-красный цвет (Bright red).
3. В свойствах поставьте материал Neon, чтобы она светилась как лава.
4. Назовите её KillPart.
5. Добавьте Script.

Поиск гуманоида

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

У неживых предметов нет здоровья. Если мы попытаемся отнять здоровье у камня, скрипт выдаст ошибку и сломается. Поэтому нам нужно проверить наличие объекта Humanoid.

Humanoid — это специальный объект внутри модели персонажа, который хранит такие свойства, как:

• Health (Здоровье)
• MaxHealth (Максимальное здоровье)
• WalkSpeed (Скорость ходьбы)
• JumpPower (Сила прыжка)

Код убийцы

local trap = script.Parent

local function kill(hit)
	-- hit — это та часть, которая коснулась ловушки (например, Левая Нога)

	-- Ищем родителя этой части (Модель Персонажа)
	local character = hit.Parent

	-- Пытаемся найти внутри модели объект с именем "Humanoid"
	local humanoid = character:FindFirstChild("Humanoid")

	-- Проверяем, нашелся ли он
	if humanoid then
		-- Если humanoid существует (не nil), значит это живое существо
		humanoid.Health = 0
	end
end

trap.Touched:Connect(kill)

Разбор метода :FindFirstChild()

Почему мы написали `character:FindFirstChild(