Raycast в Roblox Studio — это метод, который позволяет выявить объекты в игровом мире, используя луч (ray). Луч излучается из определенной точки и направляется в заданном направлении, проверяя столкновение с объектами, которые находятся на его пути. Этот процесс часто используется для реализации различных механик, таких как стрельба, взаимодействие с объектами, проверки расстояния или определения того, попадает ли объект в линию видимости.

Основные моменты:

1. Происхождение: Луч начинается в заданной точке в пространстве, которая может быть позиционирована вручную или определена программно.
2. Направление: Луч имеет направление, обычно заданное векторами, которые могут определять движение вперед, назад, вверх и т. д.
3. Длина: Луч может иметь определенную длину, которая ограничивает его радиус действия.
4. Коллизия: Raycast проверяет столкновение с объектами, которые находятся в пути луча. Это может включать как игровые объекты, так и элементы, установленные в мире (например, стены или другие преграды).

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

а теперь к скриптингу

сейчас посмотрим как задать луч:

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

origin - это откуда собственно исходит луч

direction - это направление,цель в которую движется луч

RayCastParams - это определенные характеристики луча туда можно записать какие предметы игнорить и прочие модификации

также кто то кто не знаком с другими языками программирования спросит почему Raycast это метод а не функция и почему Workspace это обьект

Обьект это структура данных которая вмещает себя сразу и функции и переменные и многое другое и функции внутри обьекта являются методами это является частью одной из главных концепий с которой вы много столкнетесь

ООП- обьектно ориентированное программирование и это подход к программированию где данные и функции обьединяются в обьекты

мы не будем особо давать этому большее определение просто если когда нибудь в какой нибудь беседе кто то скажет что в Lua нету ООП то смело сможете заткнуть невежество

теперь вернемся к лучам

теперь сделаем два парта

а теперь зададим origin

origin - это откуда собственно исходит луч

в общем мы указали стартовую позицию луча origin

дальше осталось указать направления луча

дальше вопрос к вам

что нужно вот здесь в переменной direction?

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

после того как написали и посмотрите дальше ответ скорее всего вас удивит!

90% процентов кто читает подумали что в direction надо записать part2.Position

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

Почему это неверно?

В методе Raycast() второй аргумент — это вектор направления луча, который указывает, в какую сторону и на какое расстояние должен двигаться луч от начальной точки (origin). part2.Position — это просто координаты целевой точки, а не вектор, который определяет путь луча.

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

Как правильно указать направление?

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

local part1 = workspace.Part1
local part2 = workspace.Part2

— Параметры для Raycast
local origin = part1.Position
local direction = part2.Position - part1.Position — Здесь мы вычисляем разницу между точками
local ray = workspace:Raycast(origin, direction)

Вектор, вычисленный как разница между part2.Position и part1.Position:

определяет точное направление луча. Это означает, что луч будет двигаться от точки part1.Position в направлении part2.Position.

Например, если part1.Position = (2, 3, 4) и part2.Position = (8, 6, 4), то разница между этими точками будет:

Таким образом, луч будет двигаться на 6 единиц по оси X и на 3 единицы по оси Y.

Заключение

Необходимо помнить: передача координат целевой точки (например, part2.Position) в качестве вектора направления — это ошибка. Это не задает направление луча, а просто указывает координаты точки в пространстве. Для корректной работы луча необходимо вычислить разницу между начальной и конечной точкой, которая и будет вектором направления луча.

также стоит помнить что

### Оси в 3D-пространстве:
1. X — это горизонтальная ось, которая идет влево и вправо.
- Положительное значение (X > 0): движение вправо.
- Отрицательное значение (X < 0): движение влево.

2Y — это вертикальная ось, которая идет вверх и вниз.
- Положительное значение (Y > 0): движение вверх.
- Отрицательное значение (Y < 0): движение вниз.

3. Z — это ось глубины, которая идет вперед и назад.
- Положительное значение (Z > 0): движение вперед (к экрану).
- Отрицательное значение (Z < 0): движение назад (от экрана).

### Пример:
Вектор, например, `Vector3.new(10, 5, -3)`:
-X = 10— движение вправо на 10 единиц.
- Y = 5 — движение вверх на 5 единиц.
- Z = -3 — движение назад (от камеры) на 3 единицы.

Таким образом:
- X — это влево/вправ.
-Y — это вверх/вниз.
- Z — это вперед/назад.

теперь настало время погооврить о 3 параметре э

теперь осталось поговорить о 3 параметре это raycastparams собственно это параметры нашего луча

теперь обьявляем вот такую вот переменную

собственно она и будет олицетворять набор параметров и характеристик для данного луча

начнем с основного

мы обьявляем таблицу которая содержит элементы которые будут фильтроваться по определенному признаку

таблица это просто список каких либо обьектов или элементов просто линейный набор данных который можно представить как полку на которой лежат ящики

теперь собственно укажем тип фильтра

собственно Exclude это обьекты которые луч будет игнорировать

Когда говорят, что **"луч будет игнорировать"** какой-либо объект, это означает, что объект не будет участвовать в процессе столкновения или взаимодействия с лучом. В результате луч не остановится или не взаимодействует с этим объектом, а продолжит двигаться в своем направлении.

### Как это работает в Roblox:

1. **Raycast** — это механизм, который позволяет проверять, сталкивается ли луч с объектами в игровом мире. Когда луч сталкивается с объектом, он может вернуться с результатом, содержащим информацию о пересечении, такую как:
- Имя объекта, с которым произошло пересечение.
- Позиция пересечения.
- Точка на объекте, с которой луч взаимодействует.

2. **Игнорировать объект** — это значит, что если объект находится в **списке исключений** (например, через `FilterDescendantsInstances` и `RaycastParams`), то луч **не будет учитывать** этот объект при поиске пересечений. То есть, если луч встретит объект, который был добавлен в список игнорируемых, он его проигнорирует и продолжит движение, не прерываясь.

### Пример:

Если у нас есть несколько объектов (например, `part1`, `part2`, и `part3`) и мы хотим, чтобы луч **игнорировал `part2`**, это может быть сделано с использованием `RaycastParams` с параметром **`FilterType`**:

```lua
local part1 = workspace.Part1
local part2 = workspace.Part2
local part3 = workspace.Part3

-- Настроим параметры для Raycast
local raycastParams = RaycastParams.new()

-- Указываем объекты, которые нужно игнорировать (в данном случае part2)
raycastParams.FilterDescendantsInstances = {part3}
raycastParams.FilterType = Enum.RaycastFilterType.Exclude -- Исключаем часть из пересечения лучом

-- Выполняем Raycast
local origin = part1.Position
local direction = part2.Position - part1.Position
local rayResult = workspace:Raycast(origin, direction, raycastParams)

if rayResult then
print("Луч пересек объект: " .. rayResult.Instance.Name)
else
print("Луч не пересек ни одного объекта")
end
```

### В этом примере:
- **Луч** будет двигаться от `part1` к `part2`.
- **`part3`** будет **игнорироваться** лучом, благодаря установке фильтрации с `FilterType = Enum.RaycastFilterType.Exclude`.
- Это значит, что даже если луч пересекает `part3`, он не "заметит" его и не остановится. Луч продолжит движение и, возможно, пересечет другие объекты.

### Что происходит при игнорировании:
- **Игнорирование** объекта приводит к тому, что луч не будет "замечать" этот объект, и:
- Луч не остановится при его пересечении.
- Результат **Raycast** не будет включать информацию о пересечении с этим объектом.
- Луч будет двигаться дальше, как если бы этого объекта не существовало на его пути.

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

Если использовать **`Enum.RaycastFilterType.Whitelist`** (включить объекты, или "Whitelist"), то луч будет **взаимодействовать только с теми объектами, которые находятся в списке `FilterDescendantsInstances`**.

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

### Пример с **Whitelist** (включение объектов):

```lua
local part1 = workspace.Part1
local part2 = workspace.Part2
local part3 = workspace.Part3

-- Настроим параметры для Raycast
local raycastParams = RaycastParams.new()

-- Указываем объекты, с которыми луч будет взаимодействовать (в данном случае part1 и part2)
raycastParams.FilterDescendantsInstances = {part1, part2}
raycastParams.FilterType = Enum.RaycastFilterType.Whitelist -- Включаем объекты из списка

-- Выполняем Raycast
local origin = part1.Position
local direction = part3.Position - part1.Position
local rayResult = workspace:Raycast(origin, direction, raycastParams)

if rayResult then
print("Луч пересек объект: " .. rayResult.Instance.Name)
else
print("Луч не пересек ни одного объекта")
end
```

### В этом примере:
- **Луч** будет двигаться от `part1` в направлении `part3`.
- **`part1` и `part2`** находятся в **Whitelist**, это значит, что луч будет взаимодействовать **только с этими частями**.
- Если луч столкнется с `part3` или любыми другими объектами, которые не входят в белый список, он **будет их игнорировать** и продолжит движение.
- **`part1` и `part2`** — это те объекты, с которыми луч будет "взаимодействовать" (пересекаться).

### Что происходит при использовании **Whitelist**:
1. Луч **взаимодействует только с теми объектами, которые находятся в списке** `FilterDescendantsInstances`.
2. Все другие объекты, которые **не находятся в этом списке**, **игнорируются** и не будут приниматься во внимание при расчетах столкновений.
3. **Raycast** возвращает результат только если луч пересекает объекты из белого списка. Если луч пересекает что-то, что не входит в этот список, результат не будет найден (возвращается `nil`).

### Важные моменты:
- **Whitelist** полезен, когда нужно работать с определенными объектами (например, только с игроками, определенными частями или каким-то конкретным набором объектов).
- Все объекты, не входящие в этот список, будут проигнорированы.

также вы увидите еще последние две надписи WhiteList и BlackList

поясню что WhiteList и Include это одно и тоже как и BlackList и Exclude просто в одном из обновлений добавили новые функции и использования старых теперь не рекомендуется но их по прежнемум можно использовать

давайте укажем include

также если что part3 это кирпич по середине

видите луч игнорируют все парты кроме 3 так как мы добавили фильтр игнорировать все предметы кроме тех что в таблице а в таблице у нас парт3

давайте теперь наоборот

давайте теперь наоборот теперь он будет игнорировать все предметы которые в таблице

теперь он в сообщение игнорирует part3

Зачем это нужно?

1. Оптимизация производительности

Использование include и exclude позволяет уменьшить количество объектов, с которыми raycast будет взаимодействовать. Это важно, так как проверка на пересечения с большим количеством объектов может негативно сказаться на производительности игры. Ограничивая выбор объектов, вы можете сделать raycast более эффективным.

2. Точность взаимодействий

Часто в играх есть объекты, которые не должны реагировать на raycast. Например, вы можете не хотеть, чтобы луч взаимодействовал с декоративными объектами или определенными частями игрового мира, такими как стены или пол. Используя exclude, вы можете избежать неожиданных взаимодействий.

3. Создание уникального игрового опыта

В некоторых случаях вам может понадобиться, чтобы raycast реагировал только на определенные объекты. Например, в игре вы можете создать систему, где игроки могут стрелять по врагам, но не должны зацеплять свои собственные объекты или союзников. В этом случае вы можете использовать include для указания, что луч должен взаимодействовать только с вражескими объектами.

Примеры использования

1. Стрельба из оружия:
Если в вашей игре есть оружие, которое стреляет, вы можете использовать raycast для определения, попал ли игрок в противника. Вы можете использовать include, чтобы указать, что луч должен взаимодействовать только с объектами, имеющими тег "Враг". В то же время, используя exclude, вы можете игнорировать объекты с тегом "Игрок", чтобы предотвратить случайные попадания в союзников.

2. Проверка линии видимости:
Вы можете использовать raycast, чтобы проверить, видит ли игрок определенный объект. Используя exclude, вы можете игнорировать объекты, которые блокируют линию видимости, например, стены или другие преграды.

3. Система квестов:
В играх с квестами вы можете использовать raycast для определения, взаимодействует ли игрок с объектом квеста. С помощью include вы можете указать, что луч должен реагировать только на объекты с тегом "Квест".

теперь поговорим про вывод состояние луча и работы с обьектом которого он коснулся

если rayResult равен true тогда

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

в данном случае мы выводим его имя

а во втором принте мы выводим позицию луча

Зачем используется tostring()?

В данном случае, tostring() используется для преобразования значения rayResult.Position в строку. Это важно по нескольким причинам:

1. Тип данных:
• rayResult.Position является вектором (объектом типа Vector3), который представляет координаты в 3D пространстве. Когда вы пытаетесь конкатенировать (..) этот вектор с строкой, Lua требует, чтобы оба элемента были строками.
• Если вы попытаетесь просто использовать rayResult.Position без tostring(), возникнет ошибка, так как вы не можете объединить строку и объект типа Vector3 напрямую.
2. Форматирование вывода:
• Используя tostring(), вы можете получить строковое представление вектора, которое будет выглядеть как Vector3(1, 2, 3) (где 1, 2 и 3 — это значения по осям X, Y и Z соответственно). Это делает вывод более понятным и удобным для чтения.
3. конкатенирование значит сложение или соеденение двух строк

в данном случае чтобы вектор не является строкой следовательно мы не можем выполнить конкатенацию следовательно мы вызываем функцию tostring() для превращения вектора в строку а потом в следующее очередь их уже сконкатенировать

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

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

но сначала мы с вами сделаем кнопку + меню выбора оружия

в папке StarterGui мы добавляем screengui

Screengui -

В Roblox Studio ScreenGui (сокращение от "Screen Graphical User Interface") — это элемент интерфейса, который отображает графические элементы на экране игрока. ScreenGui используется для создания различных интерфейсов, таких как кнопки, текстовые поля, шкалы здоровья, карты и другие визуальные элементы, которые игроки видят во время игры.

Основные характеристики ScreenGui

1. Расположение на экране: ScreenGui всегда отображается поверх игры и фиксируется к экрану игрока. Это означает, что элементы внутри ScreenGui не будут изменять своё положение относительно экрана, даже если камера или игрок будут двигаться.
2. Родительский объект для GUI-элементов: Внутри ScreenGui можно добавлять различные элементы интерфейса, такие как:Все эти элементы должны быть вложены в ScreenGui для того, чтобы быть видимыми на экране.
• TextLabel: Текстовые метки.
• TextButton: Кнопки с текстом.
• ImageLabel: Изображения.
• Frame: Прямоугольные области, используемые для группировки других элементов.
• И другие GUI-объекты.
3. Область отображения: ScreenGui всегда отображается в пределах области экрана игрока. Это означает, что он "привязан" к экрану и не будет изменяться в зависимости от игрового мира. Например, элементы интерфейса, такие как панели управления, инвентари, карты и другие элементы HUD (Head-Up Display), всегда остаются на экране, независимо от позиции игрока в игровом мире.

Выбираем TextButton

Дизайн кнопки вы можете выбрать сами в Properties для тех кто не знает как я покажу как сделать такую же кнопку или как настроить ее внешний вид

для тех у кого также как у меня нету Properties

Мы заходим во View и выбираем properties

делаю черный цвет нашего бэкграунда

дальше меняю цвет текста

и увеличиваем размер текста в пункте TextScale

Также еще в нашу папку Screengui добавляем обьект с именем Frame

(я также если что поменял имя нашего Textbutton на MenuButton для удобства)

Также добавляем внутрь нашего ScreenGui cкрипт

Только поправку не Script а Localscript щас обьясню почему

В Roblox Studio существуют два основных типа скриптов для работы с Lua-кодом: Script и LocalScript. Они отличаются главным образом тем, где и как они выполняются, а также какие функции и данные им доступны. Вот основные различия:

1. Script (Скрипт)

• Место выполнения: Скрипты выполняются на стороне сервера. Это означает, что код внутри Script запускается и работает на сервере Roblox.
• Область видимости: Скрипты имеют доступ к серверным функциям и объектам. Они могут изменять состояние игры, доступное для всех игроков.
• Примеры использования:
• Управление серверной логикой игры (например, изменение состояния игры, управление спавном объектов).
• Взаимодействие с DataStore для хранения и загрузки данных игроков.
• Создание и управление общедоступными объектами (например, расположение деталей, управление монстрами).

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

• Место выполнения: Локальные скрипты выполняются на стороне клиента, то есть непосредственно на устройстве игрока.
• Область видимости: Локальные скрипты имеют доступ к объектам и функциям, которые доступны только клиенту, например, графический интерфейс пользователя (GUI) или управление камерой.
• Примеры использования:
• Управление интерфейсом пользователя (например, отображение HUD или диалогов).
• Управление камерой, анимацией или другими визуальными эффектами, которые специфичны для каждого игрока.
• Обработка ввода пользователя (например, нажатия клавиш, движения мыши).

3. Особенности взаимодействия

• LocalScript не может напрямую изменять объекты на сервере, для этого ему нужно использовать RemoteEvent или RemoteFunction для отправки запроса на сервер, чтобы серверный Script мог выполнить необходимую работу.
• Script не может напрямую взаимодействовать с клиентскими объектами, такими как интерфейс пользователя, и тоже должен использовать удаленные вызовы для взаимодействия с клиентом.

4. Где они могут быть размещены:

• Script можно размещать в ServerScriptService, Workspace и других местах, которые доступны серверу.
• LocalScript должен быть размещен в объектах, которые доступны клиенту, таких как StarterPlayerScripts, StarterCharacterScripts, StarterGui и некоторых других.

Таким образом, основное различие между Script и LocalScript в Roblox Studio заключается в том, где они выполняются (на сервере или на клиенте) и какие функции они могут использовать.

также LocalScript гораздо легче взломать поэтому все важные манипуляции и данные размещяем в script чтобы читеры не могли получить существенное превосходство

так а теперь к главному

в нашей переменной мы обращаемся к родителю нашего скрипта (родитель это папка а ребенок материал который расположен в папке в нашем же случае Frame является ребенком StarterGui

menuButton:

• Это переменная, которая ссылается на объект типа TextButton (кнопку), которую мы создали в ScreenGui. Эта кнопка отображается на экране игрока и может быть нажата игроком.
• у нас есть кнопка с именем MenuButton, переменная menuButton содержит ссылку на этот объект.

MouseButton1Click:

• Это событие, которое срабатывает, когда пользователь нажимает на кнопку с левой кнопкой мыши.
• В Roblox все GUI-элементы могут иметь события, которые запускаются при определённых действиях, таких как нажатие кнопки или перемещение мыши. В данном случае событие MouseButton1Click связано с левым щелчком мыши по кнопке.

Connect(OnOff):

• Метод Connect используется для подключения функции к событию. Когда событие происходит (в данном случае, когда пользователь нажимает на кнопку), вызывается подключенная функция.
• OnOff — это имя нашей функции, котораячс будет выполнена, когда событие MouseButton1Click сработает. Например, функция OnOff может управлять видимостью меню, показывая или скрывая его.

я немного поменял наш Frame

теперь я добавил 3 ImageButton это кнопка с картинкой я на каждой кнопке размещу картинку оружия которую получит персонаж при нажатии а также переименую каждую кнопку в названия оружия

name button

**Example**

AK-47 BUTTON

Теперь после того как я пронумеровал их, мы в Properties поставим саму картинку

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

про дизайн gui будет отдельная статья + в конце статьи будет ссылка на полезный плагин

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

после того как нашли наши модельки переносим их в ServerStorage (это наше хранилище где можно хранить предметы карты и прочее)

добавляем еще один скрипт

и теперь добавляем в ReplicatedStorage Remove event

Remote Event в Roblox Studio — это один из ключевых механизмов, позволяющих взаимодействовать между клиентом и сервером в игре. Давайте разберёмся, что это такое, зачем он нужен и как его использовать.

Что такое Remote Event?

Remote Event — это объект, который используется для передачи сообщений между клиентом (игроком) и сервером (серверной частью игры). В Roblox, игры работают по принципу клиент-серверной архитектуры, где клиент и сервер — это два разных "мира":

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

Из-за этой разделённости клиент и сервер не могут напрямую "видеть" или управлять друг другом, поэтому нужен способ передавать данные между ними. И вот тут на сцену выходит Remote Event.

Зачем нужен Remote Event?

1. Безопасность: Сервер управляет важной логикой игры, такой как проверка правил, обработка игровых данных, и так далее. Если бы клиент мог сам всё это контролировать, то игроки могли бы читерить, меняя данные у себя на устройстве. Поэтому клиент не может напрямую изменять важные данные на сервере — ему нужно отправлять запросы с помощью Remote Event, а сервер уже решает, что с этими данными делать.
2. Синхронизация: В игре могут быть действия, которые нужно синхронизировать между разными игроками. Например, если один игрок нажал кнопку, то у всех остальных игроков должно что-то произойти. Для этого клиент отправляет событие на сервер, а сервер уже рассылает это событие всем клиентам.

Как работает Remote Event?

Работа с Remote Event основана на двух основных методах:

1. FireServer — используется клиентом для отправки сообщения на сервер.
2. FireClient — используется сервером для отправки сообщения на конкретный клиент.
3. FireAllClients — используется сервером для отправки сообщения всем клиентам.

Пример использования Remote Event

Представим, что у вас в игре есть кнопка, которую игрок нажимает, и это должно привести к каким-то изменениям на сервере, например, выдаче очков.

1. На стороне клиента:
• Игрок нажимает кнопку.
• Скрипт на клиенте (местный скрипт) вызывает RemoteEvent:FireServer(), передавая какие-то данные на сервер, например, количество очков.
2. На стороне сервера:
• Сервер получает сообщение от клиента с помощью RemoteEvent.OnServerEvent:Connect(function(player, data) ... end).
• Обрабатывает это сообщение, например, добавляет очки игроку.
• Если нужно, сервер может отправить обратно информацию клиенту с помощью RemoteEvent:FireClient().

и сегодня мы как раз таки будем выдывать предмет нашему игру с помощью данной конструкции

так а теперь переходим к скрипту

напомню что надо localsript так как мы будем использовать клиент → серверную архитектуру мы будем обращаться из клиента (компьютера игрока) на серверную функцию мы с вами уже делали такой трюк в этой статье

https://teletype.in/@antichrist_squid/x4AvHZLlEeQ

Переменные

luaCopy codelocal ak47 = script.Parent:WaitForChild("AK-47 BUTTON")
local m12button = script.Parent:WaitForChild("m12 button")
local awpbutton = script.Parent:WaitForChild("AWP Button")

• ak47, m12button, awpbutton: Здесь создаются три переменные, которые будут ссылаться на кнопки которые мы с вами создали. Они используются для того, чтобы привязать к ним функционал. Каждая переменная ссылается на кнопку с соответствующим названием ("AK-47 BUTTON", "m12 button", "AWP Button"). Эти кнопки находятся в родительском объекте script.Parent, который указывает на родительский элемент скрипта (обычно это GUI объект).

Функция для выдачи оружия

luaCopy codelocal givingweapon = game.ReplicatedStorage.RemoteEvent

• givingweapon: Создаётся переменная givingweapon, которая ссылается на событие типа RemoteEvent, находящееся в ReplicatedStorage. Это событие будет использовано для отправки сигнала с клиента на сервер (что-то вроде межсессионного сообщения между клиентом и сервером).

Подключение кнопки к функции

luaCopy codeak47.MouseButton1Click:Connect(function(plr)
	givingweapon:FireServer(plr)
end)

• ak47.MouseButton1Click:Connect(function(plr) ... end): Эта строка кода говорит, что когда игрок нажимает на кнопку ak47, выполняется функция, переданная в Connect.
• givingweapon:FireServer(plr): Внутри функции вызывается метод FireServer, который отправляет сигнал на сервер с параметром plr (в данном случае, это, вероятно, ссылка на объект игрока).

Что это всё значит?

• Переменные ak47, m12button, и awpbutton: Эти переменные позволяют вам работать с конкретными кнопками на пользовательском интерфейсе (UI).
• Событие RemoteEvent (givingweapon): Оно используется для того, чтобы сигнализировать серверу о необходимости выдать игроку оружие. Это нужно, поскольку в Roblox действия, связанные с изменением данных игры, часто должны быть выполнены на сервере.
• Обработка нажатия кнопки: Когда игрок кликает по кнопке ak47, клиент отправляет запрос на сервер через givingweapon:FireServer(plr). Сервер, получив этот сигнал, может выполнить выдачу оружия.

грубо говоря при нажатии наш скрипт говорит серверу "Эй, босс, этому игроку нужен АК-47!" И сервер мгновенно достаёт оружие и вручает его

хорошо а теперь пришло время к реализации серверного скрипта

добавляем на сервер скрипт

Что такое ServerScriptService?

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

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

Почему важно использовать ServerScriptService?

1. Безопасность: Скрипты, размещенные в ServerScriptService, не видны и недоступны для игроков. Это важно, потому что игроки не могут их изменить или взломать. Например, если вы хотите сохранить логику выдачи наград или обработку покупок, лучше разместить этот код в ServerScriptService.
2. Организация: ServerScriptService помогает структурировать ваш проект. Вы можете хранить все серверные скрипты в одном месте, что упрощает их управление и редактирование.
3. Серверная логика: В ServerScriptService можно размещать скрипты, которые управляют тем, что происходит на сервере. Например, когда игрок собирает предмет, серверный скрипт может обрабатывать этот процесс, обеспечивая правильное взаимодействие между всеми игроками.

1. Подключение к удалённому событию (RemoteEvent)

local givingweapon = game.ReplicatedStorage.RemoteEvent

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

2. Обработка события на сервере

degivingweapon.OnServeшщEvent:Connect(function(plr)

• Этот код прослушивает событие OnServerEvent, которое срабатывает, когда клиент отправляет сигнал на сервер, используя RemoteEvent.
• Когда происходит это событие, вызывается функция, которая получает параметр plr (это игрок, который отправил запрос).

3. Клонирование и выдача оружия

game.ServerStorage["ak47"]:Clone().Parent = plr:WaitForChild("Backpack")
game.ServerStorage["ak47"]:Clone().Parent = plr:WaitForChild("StarterGear")

• game.ServerStorage["ak47"] — этот код обращается к объекту ak47, который хранится в ServerStorage.
• ServerStorage — это хранилище, в котором хранятся объекты, доступные только серверу. Игроки не могут получить к ним доступ напрямую.
• Clone() — эта команда создаёт копию объекта ak47.
• Parent = plr:WaitForChild("Backpack") — эта часть кода перемещает клонированный объект в рюкзак игрока (Backpack). Таким образом, оружие появляется у игрока и он может его использовать.
• Parent = plr:WaitForChild("StarterGear") — эта строка по вашему желанию она отвечает за то что даже после смерти нашего персонажа во время респпуана у него всероно останется

также в качестве практики реализуете красную кнопку при нажатии на которую у нас пропадает наша меню

теперь к основе

добавляете в это место скрипт и копируете туда наш код от капкана

теперь добавим несколько изменений

нашу основую функцию не меняем единственное что мы поменяем это условие ее вызова

тут нужно немного поменять:

для начала в функции stopBleeding убираем редактирование кирпича

теперь просто удаляем функцию onTouch она нам не нужна:

теперь пишем новую функцию onHealthChanged

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

local function onHealthChanged(health)
	-- Если здоровье уменьшилось и персонаж не кровоточит, запускаем кровотечение
	if health < humanoid.MaxHealth and not isBleeding then
		startBleeding(humanoid.Parent)
	end
end

1. Определение функции:
• local function onHealthChanged(health) — Эта строка объявляет локальную функцию с именем onHealthChanged. Функция принимает один параметр — health, который представляет текущее значение здоровья персонажа.
2. Проверка состояния:
• if health < humanoid.MaxHealth and not isBleeding then — Эта строка проверяет два условия:
• health < humanoid.MaxHealth — Проверяет, уменьшилось ли текущее здоровье (health) по сравнению с максимальным здоровьем (humanoid.MaxHealth). Это значит, что персонаж получил урон.
• not isBleeding — Проверяет, не кровоточит ли уже персонаж (isBleeding должно быть переменной, которая указывает, кровоточит ли персонаж в данный момент).
3. Запуск эффекта кровотечения:
• startBleeding(humanoid.Parent) — Если оба условия истинны (здоровье уменьшилось и персонаж не кровоточит), вызывается функция startBleeding, передавая ей родительский объект персонажа (humanoid.Parent). Эта функция отвечает за запуск эффекта кровотечения для персонажа.

Что делает этот код: Этот код следит за изменением здоровья персонажа. Когда здоровье персонажа уменьшается (то есть, когда он получает урон) и при этом он не кровоточит, код запускает функцию, которая инициирует эффект кровотечения.

теперь пишем следующую функцию которая будет отслеживать нашего игрока

1. Функция onCharacterAdded:
• Эта функция вызывается каждый раз, когда к игроку добавляется новый персонаж в игру (например, когда игрок респавнится).
• Функция получает параметр character, который представляет собой объект персонажа игрока.
• Внутри функции она пытается найти объект Humanoid в персонаже. Humanoid — это компонент, который управляет здоровьем, анимациями и другими аспектами персонажа.
• Если Humanoid найден (то есть, если он существует), функция подключает две обработки событий:
• HealthChanged: Событие, которое срабатывает каждый раз, когда изменяется здоровье персонажа. Для этого события подключается функция onHealthChanged, которая будет вызвана при изменении здоровья.
• Died: Событие, которое срабатывает, когда персонаж умирает. Для этого события подключается функция stopBleeding, которая остановит кровотечение (или выполнит другую соответствующую логику).
2. Подключение к событию CharacterAdded:
• player.CharacterAdded:Connect(onCharacterAdded) — эта строка подключает функцию onCharacterAdded к событию, которое срабатывает каждый раз, когда у игрока добавляется новый персонаж.
• Это означает, что каждый раз, когда персонаж игрока появляется или респавнится, функция onCharacterAdded будет вызвана, чтобы установить необходимые обработчики событий.
3. Проверка существующего персонажа:
• if player.Character then onCharacterAdded(player.Character) — это условие проверяет, существует ли персонаж игрока в момент выполнения скрипта. Если персонаж уже существует, функция onCharacterAdded вызывается сразу, чтобы установить обработчики событий, не дожидаясь следующего появления персонажа.

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

теперь можете тестировать все должно работать

я думаю уже после серии про Doors я выдвину пару улучшений который мы сможем добавить

(то куда летит пуля то место и отлетает) тоесть если мы целимя в руку то урон приходится в эту часть тела игрока и эта часть отлетает мы уже сделали с капканом похожее ну а теперь к практике

1 Реализуете кнопку закрывания меню выбора оружия(Легко)

2.Попробуйте сделать то что я написал выше(сложно)

достаточно предельно все просто пользуемся библеотечной функцией библеотеки math - random, тут просто если нам выпадает единица из функции тогда удаляем левую ногу если 2 то правую

если из фукнции выпадает число один то переменной legToRemove присваиваем значение переменной leftleg который в свою очередь ссылается уже на обьект класса Humanoid left leg

c двойкой все тоже самое

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

берем какой нибудь меш из тулбокса

в свойствах нашего Mesh копируем такой параметр как Meshid

добавляем вот такую вот новую строчку кода в код:

local mesh = Instance.new("SpecialMesh") mesh.MeshId = "rbxassetid://ВАШ_ID_МЕША" — Укажите ID меша капкана"rbxassetid://

mesh.Scale = Vector3.new(1, 1, 1) — Масштабирование меша, можно изменить под размер детали
mesh.Parent = part — Применяем меш к Part

Что тут происходит

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

local mesh = Instance.new("SpecialMesh")

• Что происходит?
• Этот код создает новый объект SpecialMesh, который представляет собой специальный 3D-меш, используемый для изменения формы и текстуры базовой части (Part).
• Instance.new — это функция, которая создает новый объект определенного типа. В данном случае это SpecialMesh.
• Зачем это нужно?
• Обычные части (Part) в Roblox имеют простую геометрическую форму (куб, шар и т.д.). Меш позволяет использовать более сложные 3D-модели, такие как капкан или другой объект.

Шаг 2: Присваивание MeshId

MeshId = "rbxassetid://ВАШ_ID_МЕША"

• Что происходит?
• Здесь MeshId устанавливается на конкретный идентификатор меша. Этот ID указывает Roblox, какой именно 3D-меш должен быть применен.
• ID меша можно найти в Roblox библиотеке, где хранятся различные модели. Он обычно выглядит как числовой код (например, "rbxassetid://1234567890").
• Зачем это нужно?
• Этот ID связывает созданный меш с конкретной моделью, например, моделью капкана, которая загружается и накладывается на вашу часть.

Шаг 3: Настройка масштаба

mesh.Scale = Vector3.new(1, 1, 1)

• Что происходит?
• Эта строка устанавливает размер меша, используя векторные координаты (X, Y, Z). В данном случае масштаб меша задан как 1, 1, 1, что означает его исходный размер.
• Зачем это нужно?
• Масштабирование меша позволяет сделать модель больше или меньше по трем осям (X, Y, Z). Например, если модель капкана слишком большая для части, вы можете уменьшить ее до нужных пропорций.

Шаг 5: Привязка меша к части

luaCopy codemesh.Parent = part

• Что происходит?
• Этот код привязывает созданный меш к объекту part, который должен уже существовать в игре.
• Зачем это нужно?
• Привязка меша к части (например, вашему кирпичу или капкану) позволяет изменить форму и текстуру этой части. Меш становится визуальной частью объекта, и игроки видят не обычный куб или сферу, а сложную 3D модель.

Итог:

Этот код создает 3D-модель (меш) капкана, текстурирует её, масштабирует до нужного размера и привязывает к вашему объекту в игре. Благодаря этому, вместо обычной базовой формы части (Part) вы получите более сложный и детализированный объект.

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

находим в тулбоксе модельку уже закрытого капкана и пихаем ее также как и прошлый меш внутрь нашего парта(*part)

теперь придумываем одну хитрость которая позволит нам в этом уроке миновать работу с анимациями

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

Что тут происходит

в нашей функции которая проверяет касался ли игрок нашего капкана(,брика,парта)

когда она активируется

мы делаем наш капкан невидимым

part.Transparency = 1 мы обратились к свойствам нашего кирпича с помощью переменной которая на него ссылается

local part = script.Parent

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

теперь в функции которая вызывается когда наш Гуманоид,(персонаж,игрок

мы делаем точно такие же действия только наоборот

наш второй капкан который закрытый делаем невидимым а второй снова видимым

Смотрим на результат

хорошо теперь в качестве практики

1.*Cделайте чтобы персонаж не мог выбраться из капкана(он был заморожен,застрял и тд)*

2.*Сделайте мину,бомбу, чтобы при взрыве у персонажа появлась кровь и тд*

3.*Придумайте свой вариант ловушки и свой вариант реализации*

На этом все можете свои решения,реализации,

скидывать в коментарии под уроком.

Заходим в Roblox studio и создаём Baseplate

Для начала мы просто создаём part кирпич

С этого начинаются почти все уроки)

Теперь как всегда добавляем скрипт в наш part

На первой строке мы присваиваем переменной part ссылку на объект (кирпич),к которому прикреплён этот скрипт.Это важно для отслеживания касания

На второй строке это переменная флаг

Представьте что переменная флаг это как переключатель который может находится в двух состояниях: "включено или "выключено". В компьютере как правило в операционной системе переменной флаг присваиваивают либо 1 "включено" либо 0. "выключено" в микроконтроллерах испозует первый вариант но мы с вами сегодня будем пользоваться true и false переменная будет показывать идёт ли кровотечение true или нет false

На 4 строке Это функция которая отвечает за запуск кровотечения у персонажа.В качестве аргумента она принимает 'character',что является ссылкой на объект персонажа

На 5 строке: Проверяется,не идёт ли уже кровотечение.Если нет,продолжаем выполнение функции

На 6 строке: Устанавливаем флаг 'isBleeding в 'true',указывая что персонажа начал кровоточить

Переходим уже к более интересному

С помощью функции Instance new мы создаём объект класса ParticleEmitter но вы наверняка спросите почему именно этот тип объекта, почему не Part не Mesh или какой нибудь WedgePart а я скажу

ParticleEmitter — это особый объект в Roblox, который используется для создания и управления системами частиц. Он значительно отличается от других объектов, которые можно создать с помощью Instance.new, благодаря своей специфической роли в создании динамических визуальных эффектов.

Чем ParticleEmitter отличается от других объектов?

1. Динамические эффекты:
• ParticleEmitter создается для генерации частиц, которые могут двигаться, изменять цвет, форму, размер, скорость и т. д. Это делает его идеальным для создания таких эффектов, как дым, огонь, искры, вода, кровь, магия и другие динамические визуальные эффекты.
• Другие объекты, такие как Part, Decal или Mesh, обычно статичны или малоизменяемы. Например, Part — это базовый строительный блок, представляющий собой 3D-объект, который обычно используется для создания физической геометрии, тогда как Decal используется для наложения изображений на поверхность Part.
2. Создание множества объектов за секунды:
• ParticleEmitter способен создавать сотни или даже тысячи частиц в секунду, что позволяет создавать эффекты с большим количеством мелких объектов (например, капли дождя или искры). Он оптимизирован для того, чтобы создавать и управлять большим количеством объектов одновременно.
• Если бы мы пытались создать аналогичный эффект с помощью множества отдельных Part объектов, это быстро бы стало неэффективным и привело к снижению производительности игры, так как Roblox плохо справляется с обработкой большого количества физических объектов.
3. Анимация и настройки:
• ParticleEmitter предоставляет множество настроек для анимации частиц, таких как скорость, вращение, жизненный цикл, размеры и цвета частиц. Это позволяет создать очень гибкие и разнообразные эффекты.
• В других объектах, таких как Part или Mesh, такие настройки гораздо более ограничены или отсутствуют. Например, вы можете изменить размер и цвет Part, но вам придется вручную программировать анимации, перемещение и изменение этих параметров, что намного сложнее и менее эффективно, чем использование системы частиц.
4. Эффективность и оптимизация:
• ParticleEmitter оптимизирован для работы с большими объемами данных, касающихся частиц, и для создания визуальных эффектов без чрезмерной нагрузки на систему. Он включает встроенные функции для автоматического удаления частиц по окончании их жизненного цикла.
• Другие объекты, такие как Part, могут увеличивать нагрузку на систему, если их использовать для моделирования большого количества движущихся объектов. Например, если бы вы создавали кровь с помощью отдельных Part, их пришлось бы удалять вручную или через систему Debris, что требует дополнительных вычислительных ресурсов.

Почему используем именно ParticleEmitter?

В контексте создания эффекта кровотечения, использование ParticleEmitter — это лучший выбор по нескольким причинам:

1. Реалистичные капли крови: ParticleEmitter позволяет легко создать эффект капель крови, падающих с персонажа. Эти капли могут двигаться под действием гравитации, изменять направление и исчезать через определенное время. Все эти параметры легко настраиваются с помощью свойств ParticleEmitter, таких как Lifetime, Speed, Rotation, Color и т. д.
2. Массовая генерация частиц: С помощью ParticleEmitter вы можете создавать множество частиц (капель крови) в секунду без значительной нагрузки на производительность игры. Это позволяет сделать эффект кровотечения более интенсивным и реалистичным, чем если бы вы вручную создавали Part объекты для каждой капли.
3. Автоматическое управление частицами: ParticleEmitter автоматически управляет созданием, анимацией и удалением частиц. Это упрощает код и освобождает вас от необходимости вручную отслеживать каждую каплю крови и удалять ее после окончания анимации.
4. Гибкость в настройке: Вы можете настроить частички крови так, чтобы они выглядели именно так, как вам нужно. Например, вы можете настроить их размер, скорость появления, время жизни, направление движения и другие параметры. Это дает вам больше контроля над визуальными эффектами.

Заключение:

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

На 9 строке теперь мы делаем Texture: Устанавливаем текстуру частиц крови, используя ID текстуры (в данном случае, это ID текстуры крови) я долго не искал просто взял первую возможную вы же можете добавить свою или использовать мою.Rate: Задает скорость появления частиц (5 частиц в секунду).Lifetime: Устанавливает диапазон времени жизни частиц (от 1 до 2 секунд).Speed: Устанавливает скорость частиц (в данном случае от 2 до 4).Rotation и RotSpeed: Настройки вращения частиц.Color: Устанавливаем цвет частиц в темно-красный цвет.Size: Задает размер частиц (0.5).

local humanoid = character:FindFirstChild("Humanoid"): Эта строка находит объект Humanoid внутри персонажа. Humanoid отвечает за управление жизнью, движением и другими важными аспектами персонажа.Поиск ноги: Код пытается найти часть тела персонажа, которая будет использоваться для привязки эмиттера частиц (например, "Left Leg", "LeftLowerLeg" или "LeftFoot").Присоединение эмиттера: Если нога найдена, bloodEmitter привязывается к этой части тела.

local function leaveBloodTrail(): Эта функция отвечает за создание пятен крови на земле. Она работает в цикле while, создавая новые пятна, пока флаг isBleeding равен true.Создание части (Part): Создается новый объект Part, который будет использоваться как пятно крови на земле.

• Размер: Задается размер пятна крови.
• Anchored: Делает часть неподвижной.
• CanCollide = false: Отключает возможность столкновения, чтобы другие объекты не сталкивались с пятном.
• Цвет: Задается цвет пятна в темно-красный.

Позиционирование части: Проверяется, есть ли у персонажа PrimaryPart. Если есть, пятно позиционируется под персонажем, создавая эффект, будто кровь капает на землю.

Добавление текстуры:

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

Как работает Decal:

• Размещение: Decal прикрепляется к части (Part) и отображается на одной из ее поверхностей. Вы можете выбрать, на какую именно поверхность будет нанесена наклейка, используя свойство Face (например, Enum.NormalId.Top для верхней поверхности).
• Текстура: Основное свойство Decal — это его текстура. Это изображение, которое будет отображаться на выбранной поверхности. Текстура указывается через URL или ID ресурса в Roblox. В вашем коде используется ID текстуры крови (rbxassetid://13346855).

Зачем нужна Decal:

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

Удаление части через некоторое время: Используется служба Debris, чтобы удалить пятно крови спустя 10 секунд, предотвращая захламление сцены.Уменьшение здоровья: Каждые полсекунды мы уменьшаем здоровья персонажа на 1 единицу чтобы создать эффект кровотечения и потерю крови.wait(0.5): Пауза перед созданием следующего пятна крови.

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

local function stopBleeding(): Эта функция останавливает кровотечение, устанавливая флаг isBleeding в false. Это предотвращает дальнейшее создание частиц и пятен крови.

local function onTouch(hit): Эта функция вызывается, когда что-то касается объекта (кирпича). Аргумент hit содержит объект, который касается кирпича.Определение персонажа: hit.Parent используется для определения персонажа, который коснулся кирпича.Поиск Humanoid: Если у персонажа есть объект Humanoid, это означает, что это персонаж игрока.Запуск кровотечения: Если Humanoid найден, вызывается функция startBleeding, и запускается процесс кровотечения.Подписка на событие смерти: Если персонаж умирает, срабатывает функция stopBleeding, которая останавливает кровотечение.

part.Touched:Connect(onTouch)

• part.Touched:Connect(onTouch): Подписка на событие Touched, которое вызывается при касании объекта part. Когда кто-то касается кирпича, вызывается функция onTouch.

Итог:

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

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

1. Работа с Instance.new

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

2. Создание и настройка ParticleEmitter

• Создание частиц: Мы использовали ParticleEmitter для создания эффекта частиц, который позволяет добавить динамическое и визуально привлекательное поведение, например, капли крови.
• Настройка свойств частиц: Мы научились настраивать параметры частиц, такие как Texture, Rate, Lifetime, Speed, Color, и Size, чтобы добиться нужного визуального эффекта. Это помогает сделать эффекты более реалистичными и подходящими для конкретной задачи.

3. Создание и управление следами крови

• Использование Part для создания следов: Мы научились создавать простые части (Part) для имитации следов крови на земле. Это включает в себя установку размеров, цвета и текстуры пятен.
• Добавление Decal для текстур: Мы использовали Decal, чтобы наложить текстуру на части, что делает следы более реалистичными и детализированными.

4. Работа с событиями касания

• Обработка события Touched: Мы научились использовать событие Touched для определения, когда персонаж касается объекта (например, кирпича), чтобы инициировать определенные действия, такие как создание эффекта крови.
• Определение персонажа: Мы проверяли, является ли объект, который коснулся кирпича, персонажем игрока, используя FindFirstChild("Humanoid").

5. Создание функций для управления эффектами

• Функция startBleeding: Мы создали функцию, которая запускает эффект кровотечения, создавая и настраивая частицы и следы крови.
• Функция stopBleeding: Мы также создали функцию для остановки кровотечения, что может быть полезно при излечении или смерти персонажа.

6. Оптимизация и управление ресурсами

• Использование Debris для удаления объектов: Мы узнали, как использовать службу Debris для автоматического удаления объектов (например, пятен крови) спустя определенное время, чтобы избежать перегрузки игры лишними объектами.
• Использование spawn: Мы использовали spawn для запуска функции создания следов крови в отдельном потоке, что позволяет избежать блокировки основного потока исполнения кода и улучшить производительность.

7. Понимание Humanoid и здоровья

• Работа с Humanoid: Мы научились взаимодействовать с компонентом Humanoid для проверки состояния персонажа и обработки событий, связанных со здоровьем персонажа.

Заключение

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

на следующих уроках мы улучшим нашу систему крови и сделаем полноценный bloodtide где при стрельбе в игрока он начнет кровоточить и тд и так бонус для тех кто дочитал до конца можно сделать эффект "отрубания" ноги local character = hit.Parent local humanoid = character:FindFirstChild("Humanoid") if humanoid then — Попробуем найти левую и правую ногу local leftLeg = character:FindFirstChild("Left Leg") or character:FindFirstChild("LeftLowerLeg") or character:FindFirstChild("LeftFoot") local rightLeg = character:FindFirstChild("Right Leg") or character:FindFirstChild("RightLowerLeg") or character:FindFirstChild("RightFoot") — Удаляем левую ногу, если она найдена if leftLeg then leftLeg:Destroy() end также при кровотечение у нашего персонажа пропадет нога и он станет "одноногим" всем пока.