Как прикрепить объект к другому unity
Перейти к содержимому

Как прикрепить объект к другому unity

  • автор:

Important Classes — GameObject

Unity’s GameObject class is used to represent anything which can exist in a Scene.

This page relates to scripting with Unity’s GameObject class. To learn about using GameObjects in the Scene and Hierarchy in the Unity Editor, see the GameObjects section of the user manual. For an exhaustive reference of every member of the GameObject class, see the GameObject script reference.

GameObjects are the building blocks for scenes in Unity, and act as a container for functional components which determine how the GameObject looks, and what the GameObject does.

In scripting, the GameObject class provides a collection of methods which allow you to work with them in your code, including finding, making connections and sending messages between GameObjects, as well as adding or removing components attached to the GameObject, and setting values relating to their status within the scene.

Scene Status properties

There are a number of properties you can modify via script which relate to the GameObject’s status in the scene. These typically correspond to the controls visible near the top of the inspector when you have a GameObject selected in the Editor.

They don’t relate to any particular component, and are visible in the inspector of a GameObject at the top, above the list of components.

A typical GameObject viewed in the Inspector. In this case, a directional light. The Scene status properties are outlined in red.A typical GameObject viewed in the Inspector. In this case, a directional light. The Scene status properties are outlined in red.

All GameObjects share a set of controls at the top of the inspector relating to the GameObject’s status within the scene, and these can be controlled via the GameObject’s scripting API.

If you want a quick list of all the available API for the GameObject class, see the GameObject Script Reference.

Active Status

The Active status of a GameObjectThe Active status of a GameObject

GameObjects are active by default, but can be deactivated, which turns off all components attached to the GameObject. This generally means it will become invisible, and not receive any of the normal callbacks or events such as Update or FixedUpdate .

The GameObject’s active status is represented by the checkbox to the left of the GameObject’s name. You can control this using GameObject.SetActive .

You can also read the current active state using GameObject.activeSelf , and whether or not the GameObject is actually active in the scene using GameObject.activeInHierarchy . The latter of these two is necessary because whether a GameObject is actually active is determined by its own active state, plus the active state of all of its parents. If any of its parents are not active, then it will not be active despite its own active setting.

Static Status

The Static status of a GameObjectThe Static status of a GameObject

Some of Unity’s systems, such as Global Illumination, Occlusion, Batching, Navigation, and Reflection Probes, rely on the static status of a GameObject. You can control which of Unity’s systems consider the GameObject to be static by using GameObjectUtility.SetStaticEditorFlags . Read more about Static GameObjects here.

Tags and Layers

The Static status of a GameObjectThe Static status of a GameObject

Tags provide a way of marking and identifying types of GameObject in your scene and Layers provide a similar but distinct way of including or excluding groups of GameObjects from certain built-in actions, such as rendering or physics collisions.

For more information about how to use Tags and Layers in the editor, see the main user manual pages for Tags and Layers.

You can modify tag and layer values via script using the GameObject.tag and GameObject.layer properties. You can also check a GameObject’s tag efficiently by using the CompareTag method, which includes validation of whether the tag exists, and does not cause any memory allocation.

Adding and Removing components

You can add or remove components at runtime, which can be useful for procedurally creating GameObjects, or modifying how a GameObject behaves. Note, you can also enable or disable script components, and some types of built-in component, via script without destroying them.

The best way to add a component at runtime is to use AddComponent<Type> , specifying the type of component within angle brackets as shown. To remove a component, you must use Object.Destroy method on the component itself.

Accessing components

The simplest case is where a script on a GameObject needs to access another Component attached to the same GameObject (remember, other scripts attached to a GameObject are also Components themselves). To do this, the first step is to get a reference to the Component instance you want to work with. This is done with the GetComponent method. Typically, you want to assign the Component object to a variable, which is done in using the following code. In this example the script is getting a reference to a Rigidbody component on the same GameObject:

Как только у вас есть ссылка на экземпляр компонента, вы можете устанавливать значения его свойств, тех же, которые вы можете изменить в окне Inspector:

You can also call methods on the Component reference, for example:

Note: you can have multiple custom scripts attached to the same GameObject. If you need to access one script from another, you can use GetComponent as usual and just use the name of the script class (or the filename) to specify the Component type you want.

If you attempt to retrieve a Component type that hasn’t actually been added to the GameObject then GetComponent will return null; you will get a null reference error at runtime if you try to change any values on a null object.

Accessing components on other GameObjects

Although they sometimes operate in isolation, it is common for scripts to keep track of other GameObjects, or more commonly, components on other GameObjects. For example, in a cooking game, a chef might need to know the position of the stove. Unity provides a number of different ways to retrieve other objects, each appropriate to certain situations.

Linking to GameObjects with variables in the inspector

Самый простой способ найти нужный игровой объект — добавить в скрипт переменную типа GameObject с уровнем доступа public:

This variable will be visible in the Inspector, as a GameObject field.

You can now drag an object from the scene or Hierarchy panel onto this variable to assign it.

Dragging a Prefab from the Project window into a GameObject field in the Inspector windowDragging a Prefab from the Project window into a GameObject field in the Inspector window

The GetComponent function and Component access variables are available for this object as with any other, so you can use code like the following:

Additionally, if you declare a public variable of a Component type in your script, you can drag any GameObject that has that Component attached onto it. This accesses the Component directly rather than the GameObject itself.

Соединение объектов через переменные наиболее полезно, когда вы имеете дело с отдельными объектами, имеющими постоянную связь. Вы можете использовать массив для хранения связи с несколькими объектами одного типа, но связи все равно должны быть заданы в редакторе Unity, а не во время выполнения. Часто удобно находить объекты во время выполнения, и Unity предоставляет два основных способа сделать это, описанных ниже.

Finding child GameObjects

Sometimes, a game Scene makes use of a number of GameObjects of the same type, such as collectibles, waypoints and obstacles. These may need to be tracked by a particular script that supervises or reacts to them (for example, all waypoints might need to be available to a pathfinding script). Using variables to link these GameObjects is a possibility but it makes the design process tedious if each new waypoint has to be dragged to a variable on a script. Likewise, if a waypoint is deleted, then it is a nuisance to have to remove the variable reference to the missing GameObject. In cases like this, it is often better to manage a set of GameObjects by making them all children of one parent GameObject. The child GameObjects can be retrieved using the parent’s Transform component (because all GameObjects implicitly have a Transform):

You can also locate a specific child object by name using the Transform.Find method: transform.Find(«Frying Pan»);

This can be useful when a GameObject has a child GameObject that can be added and removed during gameplay. A tool or utensil that can be picked up and put down during gameplay is a good example of this.

Sending and Broadcasting messages

While editing your project you can set up references between GameObjects in the Inspector. However, sometimes it is impossible to set up these in advance (for example, finding the nearest item to a character in your game, or making references to GameObjects that were instantiated after the Scene loaded). In these cases, you can find references and send messages between GameObjects at runtime.

BroadcastMessage allows you to send out a call to a named method, without being specific about where that method should be implemented. You can use it to call a named method on every MonoBehaviour on a particular GameObject or any of its children. You can optionally choose to enforce that there must be at least one receiver (or an error is generated).

SendMessage is a little more specific, and only sends the call to a named method on the GameObject itself, and not its children.

SendMessageUpwards is similar, but sends out the call to a named method on the GameObject and all its parents.

Finding GameObjects by Name or Tag

It is always possible to locate GameObjects anywhere in the Scene hierarchy as long as you have some information to identify them. Individual objects can be retrieved by name using the GameObject.Find function:

An object or a collection of objects can also be located by their tag using the GameObject.FindWithTag and GameObject.FindGameObjectsWithTag methods.

For example, in a cooking game with one chef character, and multiple stoves in the kitchen (each tagged “Stove”):

Creating and Destroying GameObjects

You can create and destroy GameObjects while your project is running. In Unity, a GameObject can be created using the Instantiate method which makes a new copy of an existing object.

For a full description and examples of how to instantiate GameObjects, see Instantiating Prefabs at Runtime.

There is also a Destroy method that will destroy an object after the frame update has finished or optionally after a short time delay:

Note that the Destroy function can destroy individual components without affecting the GameObject itself. A common mistake is to write this, assuming it will destroy the GameObject the script it’s attached to…

…whereas, because “this” represents the script, and not the GameObject, it will actually just destroy the script component that calls it, leaving the GameObject behind, with the script component removed.


The GameObject class offers script-based alternatives to the options available in Unity’s GameObject menu that allows you to create primitive objects.

To create instances of Unity’s built-in primitives, use GameObject.CreatePrimitive, which instantiates a primitive of the type that you specify. The available primitive types are Sphere, Capsule, Cylinder, Cube, Plane and Quad.

The Primitive shapes available in Unitys GameObject menuThe Primitive shapes available in Unity’s GameObject menu

Как сделать привязку двух объектов через скрипт в Unity?

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

P.S В Unity совсем новичок, заранее спасибо!

Все оказалось в разы проще, чем я думал:

Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.3.11.43304

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Name already in use

Unity3d-Handbook / general.md

  • Go to file T
  • Go to line L
  • Copy path
  • Copy permalink
  • Open with Desktop
  • View raw
  • Copy raw contents Copy raw contents

Copy raw contents

Copy raw contents

Базовый класс для всех объектов в Unity.

Базовый класс для всего что содержит в себе любой игровой объект(GameObject)

Порядок наследования: Component -> Object

Базовый класс для всех объектов на сценах Unity.

Порядок наследования: GameObject -> Object

Базовый класс, от которого наследуются все скрипты.

Порядок наследования: MonoBehavior -> Behavior -> Component -> Object

Класс MonoBehavior имеет ряд функций «сообщений», которые вызываются при определенных условиях. Пример функций: Start(), Update()


Флажок выключающий MonoBehavior в любом скрипте предотвращает выполнение функций:
Start(), Awake(), Update(), FixedUpdate(), OnGUI()

Наследование в C#

Синтаксис наследование: public class ChildClass : ParentClass

Полиморфизм в С#

  • Во время выполнения объекты производного класса могут обрабатываться как объекты базового класса
  • Базовые классы могут определять и реализовывать виртуальные методы, а производные классы — переопределять их:

Внутри производного класса можно получить доступ к методам базового через base Пример:

Интерфейсы могут включить в класс поведение из нескольких источников.

Интерфейс содержит только сигнатуры методов, свойств, событий или индексаторов.

Отладка в Unity

Самый простой способ отладки, использовать класс Debug, который выводит сообщения в консоли редактора:

Переопределение метода ToString()

Визуальная отладка осуществляется с помощью класса Gizmo и метода MonoBehavior.OnDrawGizmos()

Регистрация ошибок в текстовый файл

Профайлер Unity помогает вам оптимизировать вашу игру. Он сообщает вам о том, как много времени тратится в различных областях вашей игры.

Функция получающая компонент объекта по его типу.

Функция получает несколько компонентов по типу

Функции Find и FindWithTag

Поиск объектов в сцене. Первый ищет по имени объекта, второй по тегу. Второй способ быстрее!

Функция сравнения тегов CompareTag

Функция сравнения двух объектов GetInstanceID

Расстояние между двумя объектами

Поиск объектов определенного типа

Не использовать в Update()

Проверка препятствий между объектами

Присоединение одного объекта к другому с помощью Transform

Работа с кадрами в Unity

Для работы с кадрами имеются три основных вида событий в любом классе MonoBehavior.

  • Update()
  • FixecUpdate()
  • LateUpdate()

Вызывается один раз для каждого кадра в каждом активном компоненте каждого активного объекта. Update соответствует понятию кадра в Unity. Используется для событий ввода: клавиатура, мышь. Очередность обработки Update не определена. Нельзя утверждать, что Update Х будет вызван раньше чем Update Y и наоборот.

Не привязано к кадрам. Может вызываться несколько раз в кадре. Вызывается регулярно и нормированно, через фиксированные интервалы времени. Используется для эмуляции физических характеристик объектов(св-ва компонента RigidBody)

Вызывается в каждом кадре как и Update, но только после событий Update и FixedUpdate. Используется для изменения положения камеры, т.к. положение объекта уже было изменено в Update

Вызывается один раз в первом кадре, где игровой объект становится активным.

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

Два важных правила в работе с кадрами

  1. Важно рационально относиться к Update и любым другим регулярным вызываемым событиям, связанным с кадрами. Они должны содержать только самый необходимый код. Серьезно уменьшить нагрузку на функции Update поможет событийное программирование.
  2. Движение должно основываться на времени. То есть нужно писать код для реализации движений и изменений так, чтобы вне зависимости от частоты кадров они выглядели одинаково у всех игроков.Для этого используется переменная Time.deltaTime
    transform.localPosition += transform.forward * Speed * Time.deltaTime;

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

Чтобы перенести объект из сцены в сцену, необходимо его сохранять. Одним из способов сохранения является функция DontDestroyOnLoad: DontDestroyOnLoad(gameObject);
При этом также будут сохраняться все дочерние объекты и любые ресурсы которые использует сохраняемый объект. Также может возникнуть проблема дублирования объектов, т.к. данная функция переносит копию объекта.

Синглтоны и статические переменные

Синглтоны это классы у которых может существовать только один экземпляр. Такие классы используются в Unity для переноса данных из сцены в сцену. Пример реализации синглтона GameManager:

Событийное программирование в Unity

Используется для значительного увеличения производительности, заместо постоянного использования функции Update

Два варианта реализации логики врага

  1. Через функцию Update :
  1. Событийная реализация логики врага :

Система управления событиями EventManager

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

  1. EventListener: «получатель событий» применимо к любому объекту, который должен получать уведомления о событии, даже если это событие связано с ним самим. Всякий раз, когда объект ожидает, что ему сообщат о событии, он становится получателем.
  2. EventPoster: объект, который обнаруживает, что произошло событие, после чего он должен уведомить всех получателей, или разместить объявление о событии. Требуется, чтобы объект инициировал события на глобальном уровне.
  3. EventManager: синглтон, который сохраняется при переходе между уровнями и доступен глобально. Связывает получателей с отправителями. Принимает уведомления о событиях, и сразу же передает их нужным получателям в форме события.

Должен быть зарегистрирован в EventManager в качестве получателя одного или более конкретных событий. Необходимо создать интерфейс, из которого мы будем обращаться ко всем объектам получателей.
Интерфейс в C# является подходящим кандидатом для создания объектов получателей.
С помощью интерфейса Listener, от которого будут произведены все объекты, каждый объект получает возможность стать получателем события.
Простой интерфейс Listener :

С помощью интерфейса IListener мы можем сделать получателем любой объект, используя только наследование класса, то есть любой объект может объявить себя получателем и получать события:

EventManager(класс диспетчер синглтон)

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

Для получения уведомлений о событии (любом событии) получатель должен зарегистрироваться в экземпляре синглтона EventManager. Обычно это делается при первой же возможности, например в функции Start. Не используйте для этого функцию Awake, потому что она зарезервирована для внутренней инициализации объектов, а не для операций, которые выходят за пределы текущего объекта, для смены состояний и настройки других объектов. Регистрация получателя событий:

После регистрации получателей одного или более событий объекты могут затем уведомить синглтон EventManager об обнаруженном событии:

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

Директивы #region и #endregion для свертывания кода

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

Альтернативный способ, основанный на делегировании

Можно прочитать в книге Алон Торн — Искусство создания сценариев в Unity стр. 155

События класса MonoBehavior

Класс содержит широкий спектр событий, которые вызываются автоматически при определенных условиях. Эти функции, или события, начинаются с префикса On и включают например такие события, как:

  • OnGUI
  • OnMouseEnter
  • OnMouseDown
  • OnParticleCollision

OnMouseEnter, OnMouseDown и OnMouseExit регистрируют события не только для мыши, но и для сеносорной панели. Вызов этих событий определяется коллайдером объекта, события вызываются при нахождении курсора мыши в пределах его объекта. Ни одно из событий мыши не срабатывает для объектов, не имеющих коллайдера.

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

  • Важно!OnApplicationQuit не вызывается на устройствах, работающих под управлением iOS, т.к. приложения часто не закрываются, а приостанавливаются, позволяя позже возобновить работу с того же места.

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

OnApplicationPause является неоднозначным событием, потому что понятие паузеы в Unity четко не определено. При вызове данного метода все действия и события в игре полностью приостанавливаются. В этом состоянии нет течения времени, и ничто не может двигаться. Это событие будет вызываться, только если сброшен флаг Run In Background во вкладке Player Settings в группе Resolution.

  • В iOS событие OnApplicationPause будет вызываться всякий раз, когда приложение сворачивается или переносится на задний план.

Более верно не полагаться на событие OnApplicationPause при реализации собственной паузы. Лучше использовать переменную Time.timeScale или создать более полноценную систему, которая сможет сама выбирать, какие элементы приостанавливать.

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

Самым простым способом определения видимости или невидимости объекта являются два события:

  1. OnBecameVisible
  2. OnBecameInvisible Оба автоматически вызываются для любого объекта с компонентом отображения, таким как MeshRenderer или SkinnedMeshRenderer.
  • Видимость здесь означает, что объект попал в поле зрения камеры, но он может быть перекрыт другими объектами, находящимися ближе к камере.
  • Событие относится ко всем камерам, а не к конкретной. Тобишь срабатывает на любой камере.
  • Обе функции отслеживают также видимость камеры сцены.

Видимость для конкретной камеры

Для определения видимости для конкретной камеры используется событие OnWillRenderObject. Это событие вызывается регулярно, один раз в каждом кадре для каждой камеры, для которой виден объект. Проверка заслонения другими объектами не применяется. С помощью свойства Camera.current можно получить ссылку на камеру, для которой объект в настояее время виден.

Визуализации изображений в 2D играх

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

  • Для отображения 1 игровой еденицы в 1 пиксель значение в поле Size во вкладке Camera должно быть равно половине вертикального разрешения дисплея.
    То есть, если игра будет запущена в окне с разрешением 1024х768, поле Size должно содержать значение 364, потому что 768 / 2 = 364.

Если пользователь имеет возможность изменять размер окна игры или разрешение, необходимо обновить размер камеры программно:

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

Вывод изображения с камеры и постобработка

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

Важные классы — GameObject

Класс Unity GameObject используется для представления всего, что может существовать в Сцене Сцена содержит окружение и меню вашей игры. Думайте о каждом уникальном файле сцены как об уникальном уровне. В каждой сцене вы размещаете свое окружение, препятствия и декорации, по сути проектируя и создавая свою игру по частям. Подробнее
См. в Словарь

Эта страница относится к скриптам с классом GameObject Unity. Чтобы узнать об использовании игровых объектов в сцене и иерархии в редакторе Unity, см. раздел GameObjects руководства пользователя. Исчерпывающую информацию о каждом члене класса GameObject см. в справочнике по сценариям GameObject.

GameObjects — это стандартные блоки для сцен в Unity, которые служат контейнером для функциональных компонентов, определяющих, как выглядит GameObject и что делает GameObject.

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

Свойства статуса сцены

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

Они не относятся к какому-либо конкретному компоненту и отображаются в инспекторе GameObject вверху над списком компонентов.

Типичный GameObject, просматриваемый в Инспекторе. В данном случае направленный свет. Свойства состояния сцены обведены красным.Типичный GameObject, просматриваемый в Инспекторе. В данном случае направленный свет. Свойства состояния сцены обведены красным.

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

Если вам нужен краткий список всех доступных API для класса GameObject, см. Справочник по скриптам GameObject.

Активный статус

Активный статус GameObjectАктивный статус GameObject

Игровые объекты активны по умолчанию, но их можно деактивировать, что приведет к отключению всех компонентов, прикрепленных к игровым объектам. Обычно это означает, что он станет невидимым и не будет получать какие-либо обычные обратные вызовы или события, такие как Update или FixedUpdate .

Статус игрового объекта активен представлен флажком слева от имени игрового объекта. Вы можете управлять этим с помощью GameObject.SetActive .

Вы также можете прочитать текущее активное состояние с помощью GameObject.activeSelf , а также не GameObject действительно активен в сцене с использованием GameObject.activeInHierarchy . Последнее из этих двух необходимо, потому что действительно ли GameObject активен, определяется его собственным активным состоянием плюс активным состоянием всех его родителей. Если какой-либо из его родителей неактивен, он не будет активен, несмотря на его собственную активную настройку.

Статический статус

Статический статус GameObjectСтатический статус GameObject

Некоторые системы Unity, такие как Global Illumination группа методов, которые моделируют как прямое, так и непрямое освещение для обеспечения реалистичного освещения. полученные результаты. В Unity есть две системы глобального освещения, сочетающие прямое и непрямое освещение: запеченное глобальное освещение и глобальное освещение в реальном времени.
См. в Словарь , Окклюзия, Пакетная обработка, Навигация и Reflection Probes Компонент рендеринга, который захватывает сферическое изображение своего окружения во всех направлениях, подобно камере. Захваченное изображение затем сохраняется как кубическая карта, которую можно использовать для объектов с отражающими материалами. Подробнее
См. в Словарь , полагайтесь на статический статус GameObject. Вы можете указать, какие из систем Unity будут считать GameObject статическими, используя GameObjectUtility.SetStaticEditorFlags . Узнайте больше о статических игровых объектах здесь.

Теги и слои

Статический статус GameObjectСтатический статус GameObject

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

Дополнительную информацию об использовании тегов и слоев в редакторе см. на основных страницах руководства пользователя для тегов. Опорное слово, которое вы можете присвоить одному или нескольким игровым объектам, чтобы помочь вам идентифицировать игровые объекты для сценариев. Например, вы можете определить тег «Съедобный» для любого предмета, который игрок может съесть в вашей игре. Подробнее
См. в Словарь и Слои Слои в Unity можно использовать для выборочного включения или исключения групп игровых объектов из определенных процессов или вычислений. Это включает в себя рендеринг камеры, освещение, физические коллизии или пользовательские вычисления в вашем собственном коде. Подробнее
См. в Словарь .

Вы можете изменить значения тегов и слоев с помощью скрипта, используя GameObject.tag и GameObject.layer . Вы также можете эффективно проверить тег GameObject с помощью метода CompareTag , который включает проверку того, тег существует и не вызывает выделения памяти.

Добавление и удаление компонентов

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

Лучший способ добавить компонент во время выполнения — использовать AddComponent , указав тип компонента в угловых скобках, как показано. Чтобы удалить компонент, вы должны использовать метод Object.Destroy для самого компонента.

Доступ к компонентам

Самый простой случай — когда скрипту игрового объекта требуется доступ к другому компоненту, прикрепленному к тому же игровому объекту (помните, что другие скрипты, прикрепленные к игровому объекту, также сами являются компонентами). Для этого первым делом необходимо получить ссылку на экземпляр компонента, с которым вы хотите работать. Это делается с помощью метода GetComponent. Как правило, вы хотите присвоить объект Component переменной, что делается с помощью следующего кода. В этом примере скрипт получает ссылку на Rigidbody компонент, который позволяет моделируемой гравитации и другим силам воздействовать на GameObject. . Подробнее
См. в компоненте Словарь на том же GameObject:

Once you have a reference to a Component instance, you can set the values of its properties much as you would in the Inspector:

Вы также можете вызывать методы для ссылки на компонент, например:

Примечание: у вас может быть несколько пользовательских скриптов фрагмент кода, который позволяет создавать собственные компоненты, запускающие игровые события , изменяйте свойства компонента с течением времени и реагируйте на ввод данных пользователем любым удобным для вас способом. Подробнее
См. Словарь , прикрепленный к тому же GameObject. Если вам нужно получить доступ к одному скрипту из другого, вы можете использовать GetComponent как обычно и просто использовать имя класса скрипта (или имя файла), чтобы указать нужный тип компонента.

Если вы попытаетесь получить тип компонента, который на самом деле не был добавлен в GameObject, GetComponent вернет значение null; вы получите ошибку нулевой ссылки во время выполнения, если попытаетесь изменить какие-либо значения нулевого объекта.

Доступ к компонентам других игровых объектов

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

Связывание с игровыми объектами с помощью переменных в инспекторе

Самый простой способ найти связанный GameObject — добавить в скрипт общедоступную переменную GameObject:

Эта переменная будет видна в Инспекторе как поле GameObject.

Теперь вы можете перетащить объект со сцены или панели иерархии на эту переменную, чтобы назначить ее.

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

Функция GetComponent и переменные доступа к компоненту доступны для этого объекта, как и для любого другого, поэтому вы можете использовать следующий код:

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

public Transform playerTransform;

Связывание объектов вместе с переменными наиболее полезно, когда вы имеете дело с отдельными объектами, имеющими постоянные связи. Вы можете использовать переменную массива, чтобы связать несколько объектов одного типа, но соединения все равно должны выполняться в редакторе Unity, а не во время выполнения. Часто удобно находить объекты во время выполнения, и Unity предоставляет два основных способа сделать это, как описано ниже.

Поиск дочерних игровых объектов

Иногда игровая сцена использует несколько игровых объектов одного типа, таких как предметы коллекционирования, путевые точки и препятствия. Их может потребоваться отслеживать с помощью определенного сценария, который контролирует их или реагирует на них (например, может потребоваться, чтобы все путевые точки были доступны для сценария поиска пути). Использование переменных для связывания этих игровых объектов возможно, но это делает процесс проектирования утомительным, если каждую новую путевую точку нужно перетаскивать в переменную в сценарии. Точно так же, если путевая точка удалена, то удаление ссылки переменной на отсутствующий объект GameObject является неприятностью. В подобных случаях часто лучше управлять набором игровых объектов, сделав их дочерними элементами одного родительского игрового объекта. Дочерние игровые объекты можно получить с помощью родительского компонента Transform Компонент Transform определяет положение, вращение и масштаб каждого объекта в сцена. Каждый GameObject имеет Transform. Подробнее
См. в Словарь (поскольку все игровые объекты неявно имеют преобразование):

Вы также можете найти определенный дочерний объект по имени, используя метод Transform.Find: transform.Find («Сковорода»);

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

Отправка и трансляция сообщений

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

BroadcastMessage позволяет отправить вызов именованному методу, не уточняя о том, где этот метод должен быть реализован. Вы можете использовать его для вызова именованного метода для каждого MonoBehaviour в конкретном GameObject или любом из его дочерних элементов. При желании вы можете указать, что должен быть хотя бы один получатель (иначе будет сгенерирована ошибка).

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

SendMessageUpwards аналогичен, но отправляет вызов именованного метода в GameObject и все его родители.

Поиск игровых объектов по имени или тегу

Всегда можно найти игровые объекты в любом месте иерархии сцен, если у вас есть информация для их идентификации. Отдельные объекты можно получить по имени с помощью функции GameObject.Find:

GameObject player; void Start()

Объект или набор объектов также можно найти по их тегу с помощью GameObject.FindWithTag и GameObject.FindGameObjectsWithTag.

Например, в кулинарной игре с одним персонажем-поваром и несколькими плитами на кухне (каждая из которых помечена как «Плита»):

GameObject chef; GameObject[] stoves; void Start()

Создание и уничтожение игровых объектов

Вы можете создавать и уничтожать игровые объекты во время работы вашего проекта. В Unity GameObject можно создать с помощью метода Instantiate, который создает новую копию существующего объекта.

Полное описание и примеры создания экземпляров GameObject см. в разделе Создание экземпляров префабов во время выполнения.

Существует также метод Destroy, который уничтожит объект после завершения обновления кадра или, опционально, после небольшой задержки:

Обратите внимание, что функция Destroy может уничтожать отдельные компоненты, не затрагивая сам GameObject. Распространенной ошибкой является написание этого, предполагая, что это уничтожит GameObject скрипт, к которому он прикреплен…

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


Класс GameObject предлагает основанные на сценариях альтернативы параметрам, доступным в меню GameObject Unity, что позволяет создавать примитивные объекты.

Чтобы создать экземпляры встроенных примитивов Unity, используйте GameObject.CreatePrimitive, который создает экземпляр примитива того типа, который вы указываете. Доступные примитивные типы: Sphere, Capsule, Цилиндр, Куб, Плоскость и Quad Примитивный объект, напоминает плоскость, но его ребра имеют длину всего одну единицу, он использует только 4 вершины, а поверхность ориентирована в плоскости XY локального координатного пространства. Подробнее
См. в Словарь .

Примитивные формы, доступные в меню Unity GameObjectПримитивные формы, доступные в меню Unity GameObject

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *