Программирование на движке unity. Что такое спрайт? Именования различных аспектов одного и того же

24. Используйте расширения, чтобы сделать синтаксис более удобным. Например:

public static class CSTransform
{
public static void SetX(this Transform transform, float x)
{
Vector3 newPosition =
new Vector3(x, transform.position.y, transform.position.z);

Transform.position = newPosition;
}
...
}

25. Используйте безопасную альтернативу GetComponent. Иногда внедрение зависимостей компонентов (через RequiredComponent ), может быть болезненным. Например, это затрудняет изменение компонентов в инспекторе (даже, если они имеют тот же базовый тип). В качестве альтернативы, может быть использовано, следующее расширение GameObject , для вывода ошибки, если компонент не найден.

public static T GetSafeComponent(this GameObject obj) where T: MonoBehaviour
{
T component = obj.GetComponent();

If(component == null)
{
Debug.LogError("Expected to find component of type "
+ typeof(T) + " but found none", obj);
}

Return component;
}

Идиомы

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

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

Примеры групп идиом:

• Сопрограммы vs конечного автомата.
• Вложенные префабы vs связанные префабы vs «Бог»-префабы.
• Стратегии разделения данных.
• Способы использования спрайтов для состояний в 2D-игр.
• Структура префаба.
• Стратегии спауна (spawning).
• Способы поиска объектов: по типу vs по имени vs по тегу vs по слою vs ссылке.
• Способы группировки объектов: по типу vs по имени vs по тегу vs по слою vs массиву или ссылкам.
• Поиск групп объектов vs self-registration.
• Контроль порядка выполнения (использовать установленный порядок исполнения Unity vs логику yield vs Awake/Start и Update/Late Update vs ручные методы vs в любом порядке).
• Выделение объектов / позиции / целей с помощью мыши в игре: менеджер выделения vs локальный self-management.
• Хранение данных между изменениями сцены: через PlayerPrefs, или объекты, которые не уничтожаются при загрузке новой сцены.
• Способы комбинирования (смешивания, добавления и наслаивание) анимации.

(*vs — против)

Время

27. Держите свой собственный класс времени, чтобы сделать паузу легче. Оберните Time.DeltaTime и Time.TimeSinceLevelLoad для учета пауз и временной шкалы. Использование его требует дисциплины, но облегчит работу с разными таймерами (например, анимация интерфейса и игровая анимация).

Спаун объектов

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

Дизайн классов

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

public class Singleton : MonoBehaviour where T: MonoBehaviour
{
protected static T instance;

/**
Returns the instance of this singleton.
*/
public static T Instance
{
get
{
if(instance == null)
{
instance = (T) FindObjectOfType(typeof(T));

If (instance == null)
{
Debug.LogError("An instance of " + typeof(T) +
" is needed in the scene, but there is none.");
}
}

Return instance;
}
}
}

Синглтоны полезны, для различных менеджеров, таких как ParticleManager , или AudioManager , или GUIManager .

• Избегайте использования синглтонов для уникальных экземпляров префабов, которые не менеджеры (например, экземпляр Игрока). Не соблюдение этого принципа, усложняет иерархию наследований, и делает некоторые изменения сложнее. Вместо этого, держите ссылки на такие экземпляры в вашем GameManager (или другом подходящем «Бог»-классе;-)).
• Определите статические свойства и методы для публичных переменных и методов, которые часто используются за пределами класса. Это позволит вам писать GameManager.Player вместо GameManager.Instance.player .

30. Для компонентов, никогда не делайте переменные общедоступными, если они не должны изменяться через инспектор. Иначе, ее может «покрутить» дизайнер, не зная, что переменная делает. В редких случаях, это неизбежно. В таком случае, используйте два, или даже четыре подчеркивания в качестве префикса, в имени переменной, чтобы отпугнуть «крутильщиков»:

public float __aVariable;

31. Отделяйте интерфейс от логики игры. Это, по сути паттерн MVC.

Каждый контроллер ввода, должен лишь давать команды соответствующим компонентам, чтобы дать им знать, что контроллер был вызван. Например, в логике контроллера, можно решать, какие команды давать, основываясь на состоянии игрока. Но это плохо (например, это приведет к дублированию логики, если добавлено несколько контроллеров). Вместо этого, объект Игрока должен быть уведомлен о намерениях двигаться вперед, а затем на основе текущего состояния (замедлен или оглушен, например) установить скорость и обновить направление игрока. Контроллеры должны делать только то, что относится к их собственному состоянию (контроллер не меняет состояние, когда игрок изменяет состояние, поэтому контроллер вообще не должен знать о состоянии игрока). Другим примером является смена оружия игроком. Правильный способ сделать это в Player , с помощью метода SwitchWeapon(Weapon newWeapon) , который можно вызвать из GUI. GUI не должен манипулировать трансформациями, родителями и т.д..

Любой компонент интерфейса, должен только поддерживать данные, и выполнять обработку, связанную с его собственным состоянием. Например, отображение карты, на основе расчетов движения игрока. Тем не менее, это данные состояния игры, и не принадлежат к GUI. GUI должен лишь отображать данные состояния игры, хранить их нужно в другом месте. Картографические данные должны быть сохранены в другом месте (в GameManager , например).

Объекты геймплея не должны знать практически ничего о GUI. Единственным исключением является режим паузы, которая может контролироваться глобально посредством Time.timeScale (что не является хорошей идеей). Геймплейные объекты должны знать, если игра приостановлена. И это всё. Поэтому, не должно быть ссылок, на GUI-компоненты из объектов геймплея.

В общем, по идее, если вы удалите все классы GUI, игра должна компилироваться.

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

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

• сохранение состояния игры
• отладку состояния игры

Один из способов сделать это, определение класса SaveData для каждого класса игровой логики:

PlayerSaveData
{
public float health; //public for serialisation, not exposed in inspector
}

Player
{
//... bookkeeping variables (переменные промежуточных данных)

//Don’t expose state in inspector. State is not tweakable.
private PlayerSaveData playerSaveData;
}

33. Отделяйте конфигурацию специализаций.

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

• Определите шаблонный класс для каждого класса игровой логики. Для экземпляра врага, мы определим класс EnemyTemplate . Где будут храниться, все отличительные характеристики.
• В классе игровой логики, определите переменную типа нашего шаблона.
• Сделайте префаб врага, и два шаблонных префаба WeakEnemyTemplate и StrongEnemyTemplate .
• При загрузке и порождении объектов, задайте переменной шаблона нужный шаблон.

Этот метод может стать довольно сложным (а иногда, излишне сложным, так что будьте осторожны!).

Например, лучше будет использование полиморфизма обобщения, мы можем определить класс, так:

public class BaseTemplate
{
...
}

Public class ActorTemplate: BaseTemplate
{
...
}

Public class Entity where EntityTemplateType: BaseTemplate
{
EntityTemplateType template;
...
}

Public class Actor: Entity
{
...
}

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

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

public void SelectWeapon(int index)
{
currentWeaponIndex = index;
Player.SwitchWeapon(weapons);
}

Public void Shoot()
{
Fire(bullets);
FireParticles(particles);
}

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

public class Weapon
{
public GameObject prefab;
public ParticleSystem particles;
public Bullet bullet;
}

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

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

public void FireAttack()
{
/// behaviour
Fire(bullets);
}

Public void IceAttack()
{
/// behaviour
Fire(bullets);
}

Public void WindAttack()
{
/// behaviour
Fire(bullets);
}

Перечисления могут сделать ваш код лучше …

public void WindAttack()
{
/// behaviour
Fire(bullets);
}

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

public class Bullets
{
public Bullet FireBullet;
public Bullet IceBullet;
public Bullet WindBullet;
}

Здесь предполагается, что нет других данных для огня, льда и воздуха.

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

• Определите отдельные классы для групп переменных. Сделайте их публичными и сериализуемыми.
• В основном классе, определите публичные переменные каждого типа, как указанно ранее.
• Не инициализируйте эти переменные в Awake или Start ; так как они сериализуемые, Unity позаботится об этом.
• Вы можете указать значения по умолчанию, до присвоения значений в определении.

Это сгруппирует переменные в инспекторе в блоки, и облегчит управление ими.

public class MovementProperties //Not a MonoBehaviour!
{
public float movementSpeed;
public float turnSpeed = 1; //default provided
}

Public class HealthProperties //Not a MonoBehaviour!
{
public float maxHealth;
public float regenerationRate;
}

Public class Player: MonoBehaviour
{
public MovementProperties movementProeprties;
public HealthPorperties healthProeprties;
}

Текст

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

39. Если вы планируете локализовать отдельно все строки в одном месте. Есть много способов сделать это. Один из способов заключается в определении класса Text , с публичным полем для каждой строки, и заданным значением по умолчанию на английском, например. Другой языковой подкласс, повторно инициализирует поля языковым эквивалентом.

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

Тестирование и отладка

42. Реализуйте свой собственный FPS-счетчика. Да. Никто не знает, что на самом деле измеряет FPS-счетчик Unity, но это не скорость кадров. Реализуйте собственный, так чтобы FPS соответствовал интуиции и визуальному контролю.

43. Реализуйте сочетаний клавиш, для снятия снимков экрана. Многие ошибки являются визуальными, и гораздо проще, сообщить о них, когда можно сделать скриншот. Идеальная система должна содержать счетчик в PlayerPrefs, чтобы последовательные скриншоты не перезаписывались. Скриншоты должны быть сохранены за пределами папки проекта, чтобы избежать случайного коммита в репозиторий.

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

45. Реализуйте опции отладки для упрощения тестирования. Некоторые примеры:

• Разблокировать все предметы (айтемы).
• Отключить врагов.
• Отключить GUI.
• Сделать игрока непобедимым.
• Отключить весь геймплей.

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

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

47. Держите сцену со всеми элементами геймплея. Например, сцена со всеми врагами, все объекты, с которыми можно взаимодействовать, и т.д. Это делает легкой проверку функциональности, без необходимости играть слишком долго.

48. Определите константы для отладки сочетания клавиш, и держите их в одном месте. Клавиши отладки не нормально (не удобно) обрабатываются в едином месте, как и остальные части игрового ввода. Чтобы избежать конфликтов между сочетаниями клавиш, определите константы в одном месте. Альтернативой является, обрабатывать все клавиши в одном месте, независимо от того, является функция отладочной, или нет. (Недостатком является то, что этому классу могут понадобиться дополнительные ссылки на объекты).

Документация

49. Документируйте ваши настойки. Большинство документации должно быть в коде, но некоторые вещи должны быть задокументированы вне кода. Документация, повышает эффективность (если она актуальная).

Документируйте следующее:

• Использование слоя (для коллизий, Culling, и Raycasting — по сути то, что должно быть на слое).
• Использование тэгов.
• Глубина GUI для слоев (что должно отображаться, поверх чего).
• Настройка сцены.
• Идиома предпочтений.
• Структуры префабов
• Слои анимации.

Стандарт именования и структура папок

50. Следуйте документированному соглашению об именовании и структурах папок. Следование ему облегчает поиск вещей, и понимание, что это за вещь.

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

Общие принципы именования.

• Называйте вещи своими именами. Птица должна называться Bird .
• Выбирайте имена, легко произносимые и запоминающиеся. Если вы делаете игру о Майя, не называйте свой уровень QuetzalcoatisReturn .
• Будьте последовательными. Выбрав имя, придерживайтесь его.
• Используйте стиль PascalCase, например: ComplicatedVerySpecificObject . Не используйте пробелы, подчеркивания или дефисы, с одним исключением (см. «Именования различных аспектов одного и того же»).
• Не используйте номера версий, или слова для обозначения стадии прогресса (WIP, финал).
• Не используйте аббревиатуры: DVamp@W должно быть DarkVampire@Walk .
• Используйте терминологию из дизайн документации: если в документе анимация смерти называется Die, то надо использовать имя DarkVampire@Die , а не DarkVampire@Death .
• Держите наиболее специфический дескриптор слева: DarkVampire , вместо VampireDark ; PauseButton , вместо ButtonPaused . Легче, например, найти кнопку паузы в инспекторе, когда не все кнопки, начинаются со слова «Button». [Многие люди предпочитают делать наоборот, потому что, это делает группировки, визуально более очевидными. Имена существуют не для группировок, для этого есть папки. Имена для различения объектов, одного и того же типа, и они должны помогать делать это быстро.]
• Некоторые имена образуют последовательность. Используйте номера в этих названиях, например, PathNode0 , PathNode1 . Всегда начинайте с 0, а не 1.
• Не используйте цифры для вещей, которые не образуют последовательность. Например, Bird0 , Bird1 , Bird2 , должно быть Flamingo , Eagle , Swallow .
• Ставьте префикс временным объектам в виде двойного подчеркивания __Player_Backup .

Именования различных аспектов одного и того же

Используйте подчеркивание между основным именем, и тем, что описывает «Аспект». Например:

• Состояние GUI-кнопок: EnterButton_Active, EnterButton_Inactive.
• Текстуры: DarkVampire_Diffuse, DarkVampire_Normalmap.
• Скайбоксы: JungleSky_Top, JungleSky_North.
• LOD-группы: DarkVampire_LOD0, DarkVampire_LOD1.

Не используйте, это соглашение просто, для различия типов предметов, например, Rock_Small , Rock_Large , должно быть SmallRock , LargeRock .

Структура

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

Структура папок:

Materials
GUI
Effects
Meshes
Actors
DarkVampire
LightVampire
...
Structures
Buildings
...
Props
Plants
...
...
Plugins
Prefabs
Actors
Items
...
Resources
Actors
Items
...
Scenes
GUI
Levels
TestScenes
Scripts
Textures
GUI
Effects
...

Структура сцены:

Cameras
Dynamic Objects
Gameplay
Actors
Items
...
GUI
HUD
PauseMenu
...
Management
Lights
World
Ground
Props
Structure
...

Структура папки скриптов:

ThirdParty
...
MyGenericScripts
Debug
Extensions
Framework
Graphics
IO
Math
...
MyGameScripts
Debug
Gameplay
Actors
Items
...
Framework
Graphics
GUI
...

Как переопределить отрисовку инспектора.

1. Определите базовый класс для всех ваших редакторов:

BaseEditor : Editor
where T: MonoBehaviour
{
override public void OnInspectorGUI()
{
T data = (T) target;

GUIContent label = new GUIContent();
label.text = "Properties"; //

DrawDefaultInspectors(label, data);

If(GUI.changed)
{
EditorUtility.SetDirty(target);
}
}
}

2. Используйте рефлексию и рекурсию, чтобы составить компоненты:

public static void DrawDefaultInspectors(GUIContent label, T target)
where T: new()
{
EditorGUILayout.Separator();
Type type = typeof(T);
FieldInfo fields = type.GetFields();
EditorGUI.indentLevel++;

Foreach(FieldInfo field in fields)
{
if(field.IsPublic)
{
if(field.FieldType == typeof(int))
{
field.SetValue(target, EditorGUILayout.IntField(
MakeLabel(field), (int) field.GetValue(target)));
}
else if(field.FieldType == typeof(float))
{
field.SetValue(target, EditorGUILayout.FloatField(
MakeLabel(field), (float) field.GetValue(target)));
}

///etc. for other primitive types

Else if(field.FieldType.IsClass)
{
Type parmTypes = new Type{ field.FieldType};

String methodName = "DrawDefaultInspectors";

MethodInfo drawMethod =
typeof(CSEditorGUILayout).GetMethod(methodName);

If(drawMethod == null)
{
Debug.LogError("No method found: " + methodName);
}

Bool foldOut = true;

DrawMethod.MakeGenericMethod(parmTypes).Invoke(null,
new object
{
MakeLabel(field),
field.GetValue(target)
});
}
else
{
Debug.LogError(
"DrawDefaultInspectors does not support fields of type " +
field.FieldType);
}
}
}

EditorGUI.indentLevel--;
}

Описанный выше метод использует вспомогательный метод:

private static GUIContent MakeLabel(FieldInfo field)
{
GUIContent guiContent = new GUIContent();
guiContent.text = field.Name.SplitCamelCase();
object descriptions =
field.GetCustomAttributes(typeof(DescriptionAttribute), true);

If(descriptions.Length > 0)
{
//just use the first one.
guiContent.tooltip =
(descriptions as DescriptionAttribute).Description;
}

Return guiContent;
}

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

3. Определите новые пользовательские редакторы.

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

public class MyClassEditor: BaseEditor
{}

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

Перевод Максим Саликов .

Разработчик детского мобильного паззла Fold the Adventure Алексей Галкин написал для ЦП колонку о том, на что следует обратить внимание при разработке мобильной игры на платформе Unity: как выбрать правильные ассеты из Asset Store, в каком сервисе хранить данные о прогрессе пользователей и где взять звуки для игры.

В закладки

Начало

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

Эта история о том, как наша небольшая инди-команда создавала игру Fold the Adventure («Сложи приключение») на основе оригинальной идеи. Поскольку игра выпущена, мы можем перевести дух и окинуть взглядом три месяца, потраченные на разработку. Несмотря на наличие многолетнего опыта в игровой индустрии, создание Fold the Adventure заставило нас изрядно попотеть ввиду непредсказуемых поворотов событий и весьма ограниченных ресурсов. Добро пожаловать в наше приключение!

Выбор движка: Unity

Сказать по правде, движок нам выбирать не пришлось. Мы сразу взяли Unity и не пожалели об этом. Нашей первостепенной задачей было создание сравнительно небольшой игры и запуск её на максимальном количестве платформ. При этом хотелось избежать возни с программированием на Objective C и Java. С Unity нам это удалось. И хотя всё было не так просто и гладко, как предполагалось, движком мы остались довольны.

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

• Необходимо с самого начала потратить время на изучение базовой архитектуры Unity, включая игровые объекты, скриптуемые объекты, сцены, префабы, ассеты, методы-события и порядок их вызова, сопрограммы, измерение времени, обработку ввода, сериализацию. Unity может показаться лёгким в использовании движком, но без понимания его основ можно провести бесконечные часы за отладкой и рефакторингом.
• С самого начала сформулируйте правила структуризации, а также именования ассетов и игровых объектов. Даже небольшая игра имеет тенденцию превращаться в хаос без должной организации. Существует много статей, посвящённых данному вопросу. Можно также ориентироваться на проекты, публикуемые разработчиками в Unity Assets Store.
• Программируйте как можно меньше. Вместо этого активно используйте WYSIWYG (What You See Is What You Get - свойство прикладных программ, в которых содержание отображается в процессе редактирования и выглядит максимально близко похожим на конечную продукцию - ред.) возможности редактора Unity. Благодаря лёгкой расширяемости, редактор Unity позволяет превратить разрабатываемую игру в удобный конструктор, которым смогут пользоваться даже те, кто не умеет программировать. А это существенно упрощает и ускоряет создание игрового контента.
• Избегайте использования привычных практик, которые плохо сочетаются с идеологией Unity. Какой бы заманчивой не была возможность размещения всех объектов игры в рамках одной сцены или сохранение параметров игровой механики в XML-файлах, подобный подход существенно осложнит жизнь на более поздних этапах разработки.
• Будьте аккуратны и внимательны при использовании систем управления версиями. Unity имеет тенденцию непредсказуемо менять файлы. Например, внесение изменений в префаб влечёт за собой модификацию всех файлов сцен, в которых он используется, но только после их последующего сохранения. Всегда используйте force text в качестве режима сериализации ассетов и внимательно следите за файлами, которые заливаете на сервер, чтобы не уничтожить результат работы коллег.
• Тестируйте игру на максимально возможном количестве платформ. При этом не забывайте, что настройки можно определить для каждой из платформ в отдельности. Без подобного тестирования, вы, как и мы, можете столкнуться с тем, что ваша игра ведёт себя по-разному в web player-е под Windows и OS X.

Ассеты: создавать или покупать

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

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

Первым и самым очевидным ответом для нас, как для Unity разработчиков, был Unity Assets Store . Какой бы заманчивой ни казалась эта возможность, она влечёт за собой и ряд сложностей:

• Ассеты в Unity Assets Store доступны всем без исключения. Однако никто не хочет, чтобы их игра была похожа на другие. По крайней мере, мы этого очень не хотели.
• Практически невозможно купить один пак ассетов, который бы удовлетворил все нужды проекта, и возникает проблема стилистической совместимости. Для Fold the Adventure мы купили несколько паков, из которых использовали меньше половины.
• Несмотря на то, что общее количество ассетов в Unity Assets Store довольно велико, найти среди них что-то подходящее для конкретных нужд бывает весьма непросто. При этом качество зачастую оставляет желать лучшего. Мы потратили часы на поиски, при этом не всегда имея возможность оценить качество пака без его покупки.

Вторым вариантом был аутсорсинг ассетов. Безусловно, этот путь отнимает больше времени и денег, чем просто покупка чего-то из Unity Assets Store. Однако, при удачном раскладе, получаемые ассеты уникальны и более качественны.

Существовала также возможность покупки ассетов из источников помимо Unity Assets Store. Однако здесь возникала проблема совместимости с Unity, и мы решили воздержаться от таких экспериментов.

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

Вот несколько простых правил, к которым мы пришли в ходе поиска и покупки ассетов в Unity Assets Store

• Чтобы избежать стилистических расхождений, желательно покупать ассеты одного типа у одного автора. Это не мешает купить модели у одной студии, а партиклы у другой, но при этом нужно следить за совместимостью стилей.
• Избегайте использования ассетов в том виде, в котором они были куплены. Достаточно внести небольшие изменения (например, немного перерисовать текстуры, реструкурировать партиклы) или использовать ассеты нестандартным образом.
• Если вы планируете выпуск игры на мобильных платформах, убедитесь, что покупаемые ассеты оптимизированы под них.

Музыка и звуки заслуживают отдельного внимания. Они редко создаются инди-командой самостоятельно (если у вас есть композитор, то вам либо очень повезло, либо вы уже не инди). К счастью, существует большое количество сервисов, поставляющих royalty-free музыку и звуки, включая Unity Assets Store. И это совсем недорого.

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

Где хранить данные: Parse

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

В поисках лучшего решения мы обнаружили Parse . Parse - это кросс-платформенный сервис BaaS (Backend as a Service - платформа типа «бэкенд как сервис», предоставляет облачную серверную инфраструктуру для всех типов приложений - ред.), который позволяет приложению сохранять данные в облаке, поддерживает авторизацию пользователей, серверные функции, push-оповещения и аналитику. Это не исчерпывающий список функциональности, но он даёт общее представление о том, что есть Parse.

Одной из причин, по которым мы выбрали Parsе, была его интеграция с Facebook (первая версия Fold the Adventure создавалась именно для Facebook). И, несмотря на то, что позднее фокус разработки был смещён на мобильные платформы, мы продолжили использовать Parse.

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

В Parse вы делаете всё через запросы. Для получения и изменения полей данных, создания отношения между таблицами, формирования выборки - для всего нужен запрос. На первый взгляд, количество запросов должно быть довольно большим, но, на деле, большую часть элементарных операций можно объединить в один запрос с помощью метода ParseObject.SaveAllAsync. Кроме того, Parse выбросит исключение, если предел запросов в секунду превышен. Но ничего не мешает вам подождать некоторое время и выполнить запрос повторно. И хотя игра в таком случае может показаться пользователю «подвисшей», эта проблема легко обходится с помощью внесения небольших изменений в пользовательский интерфейс и логику сохранения и чтения данных.

Единственное, для чего Parse не следует использовать, так это для создания игрового сервера. Даже если вы разрабатываете пошаговую игру, предназначение Parse в корне отлично. Существуют другие решения, которые существенно лучше подходят для этих целей.

Использование Parse в рамках Unity не сопряжено с особыми трудностями и хорошо документировано. По сути, вам необходимо скачать Parse SDK, настроить вашу игру на сервере Parse и в проекте Unity, а также немного попрограммировать. Один очевидный нюанс: вы не сможете использовать Parse, если устройство, на которое установлена ваша игра, не имеет доступа к интернету.

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

Стационарные платформы против мобильных: компромиссы

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

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

• Если вы планируете запуск на мобильных платформах и используете тени, то ограничьтесь режимом forward lighting. Несмотря на запекание освещения и сокращения числа объектов, отбрасывающих тени, мы не смогли добиться приемлемой производительности в режиме deferred lighting. Возможно, мы недостаточно старались, но форумы Unity, по большей части, солидарны с нами в этом вопросе.
• Минимизируйте количество draw call-ов. Большое количество полигонов в моделях не скажется так сильно на производительности, как дополнительные draw call-ы. Мы планировали большую оптимизацию, направленную на сокращение количества draw call-ов, чтобы лучше поддерживать старые модели мобильных устройств, но, к сожалению, не смогли сделать её в отведённые жёсткие сроки.
• Не злоупотребляйте текстурными выборками в шейдерах. Это может привести к существенному падению производительности. В нашей игре мы были вынуждены использовать несколько специальных шейдеров вместо одного универсального - именно по этой причине.

Помимо различий в производительности и аппаратных ограничений, существует ещё одно важное отличие между стационарными и мобильными платформами. И это отличие - режим ввода. Игра, созданная для управления с помощью клавиатуры и мыши, плохо переносится на мультитач и акселерометр. Мы убедились в этом на своём горьком опыте. Прежде всего, в Unity разделена обработка мыши и мультитача. А потому было необходимо создать систему, унифицирующую этот аспект. Для этих целей мы использовали систему ввода из состава NGUI , которая, после небольших доработок, показала себя весьма хорошо. Она также позволила нам решить проблему распределения ввода между пользовательским интерфейсом и игровым управлением, которая доставляла нам некоторые неприятности на тот момент.

Пользовательский интерфейс в целом потребовал ряда модификаций для корректной поддержки мобильных устройств. Например, вместо прокручивания колёсика мыши и удерживания кнопок пришлось ввести мультитач-жесты. Некоторые из модификаций можно было потенциально упросить с помощью готовых решений из Unity Assets Store. Но в нашем случае это был простой pinch, а потому мы решили написать его за час с нуля, вместо того, чтобы тратить дни на подключение и отладку системы, которая «делает всё и даже больше».

Наибольшее количество проблем вызвало внутриигровое управление. Мы начали с традиционного набора ASWD + мышь для управления персонажем и камерой, планируя использовать экранный джойстик на мобильных устройствах. Но всё получилось не совсем так, как мы ожидали: игра стала практически неуправляемой. Нам пришлось срочно менять внутриигровое управление, при этом внося изменения даже в игровую механику. Методом проб и ошибок мы остановились на point-n-click управлении, которое на мобильных устройствах воспринимается интуитивно.

Локализация: чем проще, тем лучше

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

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

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

Но минимизация локализуемого контента - это только начало. Следующий этап - подготовка самой игры к локализации. Плохая новость состоит в том, что Unity (на момент написания данной статьи) не имеет встроенных механизмов для этих целей. И хотя существует целый ряд специализированных решений в Unity Assets Store (например, l2 Localization), мы решили использовать систему локализации, идущую в составе NGUI.

Система локализации NGUI проста и понятна в использовании. Она построена на основе одного CSV-файла, содержащего колонку для каждого языка. Наличие такого файла очень удобно для отправки строк на перевод (для этого существует большое количество специализированных сервисов) и последующей вставки переведённой версии.

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

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

Let"s get it started

Предстартовая подготовка

При первом запуске перед вами предстанет окошко Project Wizard"а (у вас там будет пусто):

Для общего ознакомления можете открыть прилагавшийся в комплекте BootcampDemo, который в винде ложится, как ни странно, в «DocumentsAndSettings\AllUsers\Документы\Unity Projects\Bootcamp Demo».
Для продолжения же нашего обучения переходим на закладку Create New Project и отмечаем галочками наборы стандартных игровых объектов и скриптов, которые нам понадобятся. Понадобятся нам

• Character Controller
• Particles
• Physic materials
• Scripts
• Skyboxes
• Terrain Assets
• Tree Creator

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

Если коротко пройтись по подписям на картинке, то инспектор префабов и ресурсов - это то место где хранятся добавленные в проект модели, текстуры, звуки, и собственно префабы - сохранённые для дальнейшего повторного использования объекты. Т.е. мы создали объект противника с прикрепленной к нему моделью и скриптом, управляющим его поведением, и хотим чтобы на каждом уровне нам не приходилось создавать его заново, и чтобы все копии этого объекта изменялись не вручную, по-отдельности, а все скопом. В таком случае мы сохраняем его как префаб, и когда в следующий раз нам понадобится поставить врага, просто перетаскиваем префаб на сцену; а изменение префаба меняет и все его копии.

Иерархия объектов на сцене - это список всех объектов на текущем уровне, показывающий заодно отношения Parent-Child.

Инспектор объектов показывает компоненты и их свойства выделенного в данный момент объекта - модели, текстуры, префаба.

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

В главном окне редактирования мы пользуемся всеми прелестями драг"н"дропа для расставления объектов по уровням.

Для начала посмотрим, что у нас уже есть в дефолтной сцене. Негусто, правда? Объект с говорящим названием Main Camera, по нажатию на название которого в иерарахии мы увидим конус viewport"а и маленькое окошко с видом из камеры.

Сразу расскажу основные контролсы окна редактирования:

• средняя мыши - передвижение камеры вправо-влево (по внутренней плоскости xy)
• левый клик - понятное дело, выделение объекта (хотя тяжело бывает переключаться между Blender"ом и юнити:))
• правый клик - вращение «головой»
• F - центрирование на выделенном объекте
• перетаскивание объекта с зажатым ctrl - перетаскивание с шагом в 1 единицу координат

Земля обетованная

Опять-таки, не очень впечатляет. Для начала, сменим размер земной тверди через Terrain->Set Resolution. По умолчанию параметры Length и Width равны 2000, т.е. 2 км на 2 км. Для тестовых побегушек нам столько не надо, потому пишем в эти поля 500 и 500 - более чем достаточно.

Теперь назначим земле текстуру. Для этого выделяем террейн (в главном окне или в иерархии), и наблюдаем доступные свойства в инспекторе объектов. Там мы увидим инструменты для редактирования террейнов (стандартные - поднять\опустить, сгладить, и т.д.). Можете сразу начать рисовать нужный вам ландшафт, но в данный момент нас интересует кнопка с кисточкой Paint the terrain texture. А на закладке, которую она открывает, кнопка Edit textures, в меню которой жмём Add Texture:

Откроется окошко с параметрами будущей текстуры. Находим среди них один со значением «None (Texture 2d)» и кликаем на шарик с точкой справа от этих слов. Откроется выбиралка текстуры из уже добавленных в ресурсы проекта. К слову, чтобы добавить текстуру в проект, достаточно её просто скопировать в папку проекта - юнити все сам подхватит. Импорт всего остального происходит анналогично а удаление ресурса из проекта означает физическое удаление с диска.

Выбираем нужную текстуру, например Grass(Hill). Можно добавить ещё несколько текстур, например Cliff (Layered Rock), и, пользуясь кистью, выбираемой чуть выше, раскрасить по своему усмотрению. У меня после предыдущих манипуляций получилось вот так:

Если мы в данный момент нажмем на кнопку «Play» вверху экрана, то вы увидите, скорее всего, кусок нашей плохо освещённой земли на голубом фоне. Но так ведь неинтересно, поэтому прежде чем продолжить, нам надо добавить на сцену освещение, симулирующее солнечное, и заменить голубой фон небом. Свет добавляется через главное меню, GameObject->Create other->Directional light. Затем, следуя картинке, нажимаем кнопку которая меняет стрелки-хелперы вокруг выделенного объекта на оси вращения. Тягая за эти оси мы, как ни странно, вращаем осветительный прибор так, чтобы земля покрасивше подсвечивалась.

Чтобы вместо голубого полотна над головой было небо, надо указать текстуру скайбокса (skybox - «небесная коробка», куб, на который изнутри натянута текстура, как правило - панорамная фотография неба, сделанная таким образом, что изнутри кажется, будто ты окружен шаром с этой текстурой. Именно так в большинстве игр и рисуется небо). Для этого заходим в меню Edit->Render Settings, находим свойство «Skybox material» и, как мы это делали с текстурой земли, жмем на кружок с точкой справа от него. Нам покажут материалы, имеющиеся в проекте (чтобы не ходить в дебри терминологии, будем считать что материал это текстура и то, как она будет отображаться - будет она прозрачной, или будет блестеть, и т.д.). Выбирайте любой со словом skybox, например sunny2 skybox. Отлично, теперь наш полигон выглядит поживее.

Управление и камера

Вообще-то, в комплект Юнити входят два игровых объекта, дающих готовое, уже собранное решение для камеры и управления. Но я о них вам пока не скажу, чтобы был стимул собрать своими руками. :)

Для начала, создадим объект для игрока. Вернее, чтобы не плодить лишние скрипты, переименуем «Main Camera» в «player». Теперь, выделив камеру, в меню выберем Component->Physics->Character Controller. Character controller - это компонент, который обрабатывает положение объекта (вернее, персонажа) в пространстве: его движение, повороты, падения, прыжки и столкновения с другими объектами. Все это можно делать напрямую, без помощи этой обертки вокруг стандартных функций перемещения объектов и проверки коллизий, но тогда код реализации передвижения вырастает в разы, что плохо для первого знакомства с движком. А так, в общем-то, можно на первом уроке и не кодить:)

<Лирическое отступление>

Любой предмет, который мы видим на сцене - это экземпляр класса с говорящим названием GameObject. Он имеет некоторое количество т.н. компонентов - в свою очередь, являющихся экземплярами своих классов. Каждый компонент выполняет некую утилитарную функцию. Так, у каждого GameObject должен быть компонент Transform, который занимается тем, что хранит текущие координаты, угол разворота и размеры объекта в трехмерном пространстве. Ну и заодно содержит методы для выполнения действий над положением объекта в этом пространстве: пермещение, развороты и т.д., т.е. когда мы в редакторе тянем объект за стрелки-управляторы, мы меняем координаты его трансформа.

А вот например компонент RigidBody занимается тем, что обрабатывает физическое поведение объекта: всё, что мы видим, когда бочка от выстрела падает на бок и катится - результат работы RigidBody. Который, кстати, не сможет правильно работать, если не назначить объекту компонент типа Collider, который хранит в себе трехмерную модель, по которой определяются столкновения объекта. Эта модель не отображается, но именно она, а не та что мы видим на экране во время игры, проверяется на столкновения с окружающим миром.

Вокруг камеры мы теперь видим зелёные линии, образующие купсулу, по которой рассчитываются столкновения с игроком - его, так сказать, тело. Камера находится в середине этой капсулы, но нам же не нужны глаза на поясе (хотя ситуации бывают разные:)), поэтому надо передвинуть камеру в район предполагаемой головы персонажа. Но эта капсула - часть объекта с единым Transform, а потому подвинуть её отдельно от камеры не получится. К счастью, если в инспекторе объекта мы глянем на свойства, доступные для Character Controller, то увидим там свойство Center, с параметрами x, y, z. То есть мы можем сдвинуть центр капсулы относительно центра объекта. Ставим y = -0.8 и получаем нормальную высоту глаз.

Если мы теперь поставим нашего player"а над поверхностью земли и включим Play, наша камера всё ещё будет стоять на месте. Так происходит потому, что Character Controller лишь обрабатывает поступающие к нему управляющие команды, сама они инициативы не проявляет. Чтобы разъяснить ей, что делать, драг-н-дропнем на player"a скрипт, который лежит в инспекторе префабов в папке Standart Assets\Character Controllers\Sources\Scripts и зовётся «CharacterMotor». Его задача - используя методы Character Controller осуществлять основную рутину передвижения: реализовывать действие гравитации, прыжки, вычислять текущую скорость и направление движения. Запуск уровня теперь заставит камеру игрока падать на землю - уже что-то.

Но мы всё еще стоим на месте: ведь у нас нет скрипта, который перехватывал нажатия клавиш и сообщал о них в CharacterMotor. Этим занимается лежащий в той же папке скрипт FPSInputController. Кидаем его на игрока, запускаем и ура - кнопки W, S, A, D теперь позволяют ходить, а пробел - прыгать! Но ходим-то мы всё как-то в одну сторону, вправо-влево да приставным шагом. Чтобы вертеть головой и идти куда глаза глядят, понадобится ещё один скрипт, оттуда же: MouseLook. Кидаем, запускаем - и получаем полноценное управление.

Теперь можно поиграться с переменными. Character Cоntroller установил вместе с собой Character Motor - в его-то свойствах и хранятся такие параметры, как Gravity, Max Forward Speed, Jumping Base Height и всякие другие. Вот они, все плюсы Инспектора - все основные свойства классов всегда на виду, даже в код лезть не надо.

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

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

Выделив куб, нажмём Ctrl+D (дублирование объекта), и с зажатым Ctrl потянем куб вверх до тех пор, пока кубы не будут расположены один над другим. Теперь у нас два совершенно одинаковых куба ровно друг над другом. Повторим эту процедуру кубов до 15, и посмотрим на падение Вавилонской башни.

Далее, создаем новый куб, но не назначаем ему Rigidbody. Из него мы сделаем ровную поверхность для удобства стрельбы. Задаем ему Scale: 150, 20, 150; и располагаем где угодно - главное разместить на нем нашу башню и игрока. У меня получилось так:

Теперь создадим оружие и патроны. Патронами будет служить префаб, который мы создадим в инспекторе префабов нажав на кнопку «Create» вверху инспектора, и выбрав там собственно Prefab. Новый префаб создастся в той папке, что была открыта в тот момент в инспекторе. Он будет подсвечен серым, что символизирует отсутствие у него компонентов. В главном меню жмём GameObject->Create other->Sphere, находим в иерархии сцены эту Sphere, вешаем на неё Rigidbody. Но для пущей красоты зайдем в свойства этого Rigidbody, что мы только что повесили, и изменим парамтер Mass на 5.

После этого перетаскиваем сферу из списка в иерархии на созданный нами префаб. Префаб становится голубым, а вместе с ним синеет и имя сферы на сцене - это означает, что она является клоном префаба. Переименовываем префаб из дефолтного имени в, допустим, prefab_bullet. Для красоты. Пуля готова!

Следующим шагом будет создание оружия, вернее - скрипта, стреляющего по клику мыши этой самой сферой. Рядом с префабом создаем файл JavaScript"а: Create->JavaScript. Называем его, например, player (ну, чтобы не путаться). Даблкликом по нему откроется встроенный скрипторедактор, в котором мы заменяем содержимое файла вот этим (разбирать пока что не будем):

Public var bulletImpulse = 300;
public var shootSpeed = 1;
public var bullet: GameObject;

Public var lastShotTime: float;

Function Start() {
lastShotTime = 0;
}

Function Update () {

If (Input.GetKey(KeyCode.Mouse0)) {
if (Time.time>(lastShotTime + shootSpeed)) {
var bull_clone: GameObject;
bull_clone = Instantiate(bullet, transform.position, transform.rotation);
Physics.IgnoreCollision(bull_clone.collider, collider);
bull_clone.rigidbody.AddForce(transform.forward*bulletImpulse, ForceMode.Impulse);
lastShotTime = Time.time;

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

Если, конечно, НЛО не вмешалось в мои мысли и я не пропустил какой-то важный шаг.

Надеюсь, что я достаточно подробно осветил то, что надо было осветить, и не зацикливался на неважных мелочах. Пусть этот туториал и носит ознакомительный характер, хотелось бы верить, что он кому-то окажется реально полезен. Жду рациональной критики и пожеланий на следующий выпуск. Спасибо за внимание!

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

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

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

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

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

Уроки восьмой и выше фактически начинают рассматривать применение концепции написания скриптов в Unity.

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

Редактор Unity

Это иллюстрация проекта Bootcamp Demo в редакторе Unity. Вы должны быть знакомы с расположением окон в редакторе Unity из просмотра других доступных уроков. Те уроки, которые размещены здесь, не о расположении окон или навигации в редакторе. Данные уроки только о программировании в Unity с помощью скриптов (версия JavaScript для Unity).

Редактор скриптов

Это Unitron, редактор скриптов Unity для Mac, который я использую. Он будет выглядеть по-другому в Windows, но они оба служат одной и той же цели.

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

Что вы изучите

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

Ваша игра наполнена глупыми объектами

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

Это то самое место, где в дело вступают скрипты. «Но, но, но я не знаю как программировать» — скажете вы. Хорошо, на самом деле вы правы. Вы делаете это каждый день, просто вы не называете это программированием или написанием скриптов. Вы ведь живете каждый день бесцельно натыкаясь на вещи без каких-либо указаний? Вы, наверное, взаимодействуете вообще с другими людьми, или даже с домашними животными? Разговариваете? Пользуетесь туалетом или ванной-комнатой?

Шаг первый

Давайте притворимся:

Вообразите, что сидите на диване, разговаривая с другом.

Шаг второй

Потом звонит телефон. Вы говорите: «Извините, позвольте мне ответить на звонок».

Шаг третий

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

Теперь подумайте

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

Давайте разберем немного по пунктам:

Шаг первый

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

Шаг второй

Вами была запущена на выполнение другая функция — разговор по телефону. Следовательно сейчас вы выполняете скрипт «разговор по телефону» .

Шаг третий

Когда вы закончили с телефоном, вы возвратились к скрипту «разговор» со своим другом.

Примечание:

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

Скриптофобия

Теперь я спрашиваю вас, настолько ли трудным был процесс? Беспокоил ли он вас, потому что вы не верили в то, что сможете сделать все это? Заходили ли вы на форум, чтобы спросить о том, как вести разговор, а после разговаривали по телефону в середине всего этого?

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

У вас есть такие страхи, которые не дают вам написать несколько инструкций в последовательном ключе?

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

«Комплекс Бога»

Создатель миров.

У вас есть Unity, потому что вы хотели создать игру или что-нибудь интерактивное. Хорошо, вы чувствуете, что игра наполнена глупыми игровыми объектами и теперь вы должны «поиграть в Бога». Вы создали их, теперь вы должны обучить их всему, что им нужно знать для жизни в этом воображаемом мире. Та часть, где вы должны написать инструкции так, чтобы ваши игровые объекты могли быть умными, как и вы.

Станьте учителем

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

Надлежащее поведение

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

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