Как изменить спрайт объекта unity

Смена спрайта из скрипта

Вернуться в Почемучка

Кто сейчас на конференции

Сейчас этот форум просматривают: Google [Bot], Yandex [Bot] и гости: 34



Although it’s a simple thing to do, changing a Sprite at runtime in Unity is a question that’s asked surprisingly often.

This may simply be because each developer’s specific needs are different, so it’s not always clear which method is the best or is the most efficient.

However, if you’ve ever tried to load all of the Sprites from a Sprite Sheet into an array from a script, or if you’ve tried to load a Sprite by its filename, what appears to be a simple task can quickly become confusing.

Especially for a beginner, like me.

But don’t worry…

There are several different uses and multiple methods available for changing sprites at runtime. So I’ve done a little digging and will be exploring each of them, along with their benefits and drawbacks, so that you can more confidently choose which one to use.

Here’s what you’ll learn in this post:

• How to change a single Sprite from script
• How to load Sprite from a Sprite Sheet into a Sprite Array (2 methods)
• How to load Sprites by filename (using the Resources folder)
• How to load Sprites by file path (using Addressable Assets)
• 3 Examples for changing a Sprite from a Sprite Array

Let’s start with the basics…

To change a Sprite from a script in Unity, create a reference variable to hold the new Sprite. Then set the Sprite property of the Sprite Renderer Component on the Game Object you wish to change to match the new, replacement Sprite.

In scripting, it looks like this:

public SpriteRenderer spriteRenderer;
public Sprite newSprite;
void ChangeSprite()
    {
        spriteRenderer.sprite = newSprite; 
    }

In the inspector select the new Sprite that you want to use by dragging it into the field or by using the circle select button.

Make sure to also set the Sprite Renderer reference in the Inspector, otherwise you’ll get an error.

Alternatively, if the script is on the same Game Object, you can easily get it by using Get Component in Start.

void Start()
    {
        spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
    }

Then, when you want to change the Sprite, just call the Change Sprite function.

Like in this example if the Left Mouse Button is clicked:

void Update()
    {
        if(Input.GetMouseButtonDown(0))
        {
            ChangeSprite(newSprite);
        }
    }

The example will easily change a Sprite Renderer’s existing sprite to use a different one instead. But what if you want to change to one of a number of different Sprites?

What if you have multiple Sprites, such as Slices stored in a Sprite Sheet, and you want to switch to one of them, or all of them in order, or a random Sprite, all from a script?

How to change a Sprite from a Sprite Sheet in Unity

Changing a Sprite to another image from a Sprite Sheet can be done using a similar method as changing a single Sprite.

What’s different is that, in this case, the method of loading the Sprites is different, as you’ll be storing multiple Sprites in an array and retrieving the one that you want with an index.

Creating a Sprite array is simple, just add brackets to the Sprite variable to declare it as an array.

Like this:

public Sprite[] spriteArray;

Next we need to add the Sprites to the array.

There are two main ways of doing this. We’ll start with the simplest method first, which is the manual method.

Method #1. The Manual Method

This method works in much the same way as changing a single Sprite, by manually dragging the Sprites to your array in the Inspector.

It helps to lock the inspector window when doing this, as it’s very easy to accidentally switch to the import settings of the file you’re trying to drag across.

Once the Sprites are loaded into the array you’ll be able to retrieve them using their index, like this:

void ChangeSprite() 
    { 
        spriteRenderer.sprite = spriteArray[0]; 
    }

Simply pass in the array element number in the square brackets that corresponds with the Sprite you wish to switch to.

To check which Sprite is assigned to which element, click the array dropdown in the Inspector.

When to use the manual method

The Manual Method is the simplest way to switch between multiple Sprites and is ideal if you are able to assign the sprites you’re going to use manually in the Inspector. For example, when using a Prefab.

But, what if you want to access Sprites entirely from scripting, without getting a reference to them first?

Well, as it turns out, there is a way to access Sprites from a script by their filename automatically.

Method #2. The Automatic Method

The Automatic Method allows you to access individual Sprites, or even a set of Sprites from a Sprite Sheet, without needing to get a reference to them in the Inspector.

Instead, by using this method, you will be able to load Sprites into a Scene with their filename from the Resources folder, a special folder that Unity will automatically load assets from (even if they’re not referenced in the Scene).

Normally, this is not how Unity works, as assets are usually identified by assigning references to them (as is the case in the Manual Method). As a result, using this method comes with a few words of caution (more on that later) but, if it works for you and your project, and you understand what you’re doing, here’s how to do it.

1. First, create a new folder inside of your Assets folder called Resources. This can be placed anywhere in your Assets directory.
2. Next place the Sprites into the Resources folder.
3. Lastly, from a script, load the Sprite with Resources.Load<Type>(“filename”) passing in a String for the filename (without its extension).

Instead of manually adding the Sprites to the array, we can now, instead, load all of the Sprites associated with a Sprite Sheet by using Load All.

Like this:

void Start()
    {
        spriteArray = Resources.LoadAll<Sprite>("BirdHeroSprite");
    }

In the example above I’ve loaded every file of the type Sprite found in the BirdHeroSprite Texture, which is essentially a directory from which all the Slices are loaded.

While extremely useful, the Resources folder should be used with caution.

Reasons you shouldn’t use the Resources folder

Despite offering a useful option for loading assets, using the Resources folder is, generally, not recommended, as it’s not good practice.

But why?

The main reasons you should avoid using the Resources folder in Unity include:

• Increased memory usage and a bigger application size: as everything inside the Resources folder is packaged and loaded, whether you need it or not.
• Assets are more difficult to manage: as using filename paths can make it more likely that a connection will be broken if a file name or string is changed.
• Longer loading and startup time: as, if you’re using a large number of assets, the operation to load them all takes exponentially longer as more and more is added to the Resources folder. In extreme cases (think thousands of assets) this can add multiple seconds to the startup time of applications to load assets that are not initially required (source).

So, while more experienced developers will no doubt understand the risks of using this special folder, and will be able to work around issues like these easily, it’s worth knowing that the general advice is not to use the Resources folder wherever possible.

So… wait, hang on…

If the Resources folder isn’t recommended, then why does it exist? And what’s the right way to use it?

When it’s OK to use the Resources folder

According to Unity, there are a couple of use cases for which the Resources folder is particularly useful:

• Prototyping – Where performance is less important than being able to rapidly create ideas. In this case, the flexibility of the Resources folder can be extremely helpful and outweighs the performance hit.
• Minor Uses – Using relatively few assets, that are not memory intensive, and are unlikely to change between platforms is much less likely to cause you significant issues.

Generally speaking, if your game is small or performance is not (yet) critical to your project, then using the Resources folder isn’t necessarily a problem. For more information on what Unity considers to be best practice when using the Resources folder, see this tutorial.

So what can you do if you want to load a Sprite by its filename, without using the Resources folder?

Well, what if I told you that there is an option that leverages the flexibility of the Resources folder but without the potential drawbacks.

How to load a Sprite from a script by filename (using Addressable Assets)

This method requires a little extra work to set up, but it allows you to load assets into a Scene with a filename and without the drawbacks of the Resources folder.

What are Addressable Assets in Unity?

[su_quote]The Addressable Asset system provides an easy way to load assets by “address”. It handles asset management overhead by simplifying content pack creation and deployment. The Addressable Asset system uses asynchronous loading to support loading from any location with any collection of dependencies. Whether you use direct references, traditional asset bundles, or Resource folders for asset management, Addressable Assets provide a simpler way to make your game more dynamic.[/su_quote]

Unity3d.com – Source

How to change a Sprite from a Sprite Sheet in scripting using Addressable Assets in Unity:

1. Select Window > Package Manager and install the Addressable Assets package from the Package Manager (this requires Unity 2018.3 or later).
   
2. Next select Window > Asset Management > Addressables > Groups to open the Addressables Groups Window.
   
3. Click the button labelled Create Addressable Settings, this will create a default Addressable Group.
   
4. In the Project Folder, select the Texture containing the Sprites you want to use and, in the Inspector, check the Addressable checkbox. This will reveal the asset’s Addressable Path, which you’ll need for the script.
   
5. The file should now have been added to the default Addressable Group.
   

The asset is now Addressable and can be accessed from a script without a reference.

Using Addressable Assets after using the Resources folder

If you were already using the Resources folder, you may have noticed the Resources directory, and its files, in the Groups Window alongside the Addressable Group. If so, dragging those assets to the Addressable Group will automatically mark them Addressable and move them into a new folder for you (as they can’t stay in Resources for this to work).

How to fix the Invalid Key Exception Error when using Addressable Assets

Depending on your version of Unity, the path that is assigned to the asset may continue to match the string that was being used for the Resources folder value (e.g. BirdHeroSprite, without a folder path or a file extension).

However, if you’re getting an Invalid Key Exception error be sure to check that the Addressable Path (displayed next to the asset’s Addressable Checkbox) matches the value you’re using in the script.

How to access Addressable Sprite Assets from a Script

Now that the Sprites are addressable it’s possible to load them from a script, without a reference. Here’s how to do it:

First, add the following two namespaces to the top of the script. These are required for the Addressable features and loading operations to work properly.

using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

You can add them below the existing namespace declarations, using UnityEngine etc.

Next we need to load the Sprites from the Sprite Sheet, just as we did when using the Resources folder.

This happens in two steps:

1. First, load the Sprites using an asynchronous operation.
2. When that operation is completed, assign the result to the Sprite Array.

In scripting it looks like this:

public SpriteRenderer spriteRenderer;
public Sprite[] spriteArray;
void Start()
{
    AsyncOperationHandle<Sprite[]> spriteHandle = Addressables.LoadAssetAsync<Sprite[]>("Assets/BirdHeroSprite.png");
    spriteHandle.Completed += LoadSpritesWhenReady;
}
void LoadSpritesWhenReady(AsyncOperationHandle<Sprite[]> handleToCheck)
{ 
    if(handleToCheck.Status == AsyncOperationStatus.Succeeded)
    {
        spriteArray = handleToCheck.Result;
    }
}

Instead of setting the contents of the array directly, what’s happening here is we’re starting a loading operation and creating a reference to it (the AsyncOperationHandle). Then when the loading is finished, we’re assigning the result to the Array, using the Handle reference to look up what was loaded.

Doing it in this way allows time for the assets to load.

Registering the function LoadSpritesWhenReady to the spriteHandle.Completed event means that, as soon as the assets are finished loading, the function will be called and the Sprites will be assigned to the Array.

While this part of the method could be done in several ways (inside a Coroutine for example), using an action like this avoids having to repeatedly check in Update, which would inefficient, especially since we know it’s only going to happen once.

Although using Addressable Assets requires more work than simply dropping the Sprites into the Resources folder, it’s more efficient, and it’s a much more up to date solution when compared to using the Resources folder.

A comprehensive guide of the Addressable Asset system is beyond the scope of this article but you can view the full Unity documentation here.

Now that you’ve loaded the Sprites into the Array, it’s time to put them to good use.

How to change a Sprite from an array (3 examples)

Once the Sprites are assigned to the array, you can change the Sprite Renderer’s Sprite property using the same function as in the first example. Simply pass in the name of the array and the index of the Sprite.

For example, to switch to the first Sprite in the array would look like this in scripting:

public SpriteRenderer spriteRenderer;
public Sprite[] spriteArray;
void ChangeSprite()
{
    spriteRenderer.sprite = spriteArray[0]; 
}

Or, if you want to switch to a random Sprite simply pass in a random number between zero and the length of the array. Like this:

public SpriteRenderer spriteRenderer;
public Sprite[] spriteArray;
void ChangeSprite()
{
    spriteRenderer.sprite = spriteArray[ Random.Range(0, spriteArray.Length)]; 
}

Lastly, if you want to cycle through each sprite of the array, create an Integer variable to store the last Sprite index. Then increment it every time you change the Sprite:

public SpriteRenderer spriteRenderer;
public Sprite[] spriteArray;
public int currentSprite;
void ChangeSprite()
{
    spriteRenderer.sprite = spriteArray[currentSprite];
    currentSprite++;
    if(currentSprite >= spriteArray.Length)
    {
        currentSprite = 0;
    }
}

You’ll notice in the example above that I’ve added an If Statement. This is to check if the index number has reached the end of the array. This is important as trying to retrieve a Sprite outside of the array’s range will result in an error.

Ссылки

Основы скриптинга Unity

Исходники 2D платформера

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

Разница между 2D и 3D

Unity поддерживает разработку 2D-игр, и для удобства процесса разработки перед созданием нового проекта он может быть определен как 2D.

Переключение режима разработки в уже созданном проекте осуществляется через меню Edit – ProjectSettings–Editor–DefaultBehaviorMode–Mode.

В 2D-режиме Unity вносит некоторые изменения в настройки редактора:

• Окно сцены по умолчанию включено в 2D-режиме (если необходимо, данная настройка легко переключается обратно в 3D-режим с помощью переключателя в верхней части окна сцены). Эта настройка независима от остальных настроек 2D-режима и может быть изменена в любое время.
• Свойство «Projection» камеры по умолчанию установлено в «Orthographic», а «Size» равно.
• При импорте новых изображении их Texture Type по умолчанию установлен в «Sprite (2DuGUI)».

Компоненты 2D-объектов

Рассмотрим некоторые компоненты и события 2D-объектов и их отличия от компонентов и событий,использующихся для 3D-объектов.

Компоненты

BoxCollider2D –это прямоугольный коллайдер, используемый при работе с 2D физикой.

2D коллайдер/триггер обрабатывает события (сталкивание, пересечение и т.д.) независимо от того, где он располагается по координате Z. Все свойства коллайдера точно такие же, как и у BoxCollider, за исключением одного. Переключатель Used By Effector отвечает за то, используется ли данный коллайдер прикрепленным компонентом – Effector 2D (данные компонент бывает разного типа: точка, область, платформа и т.д.).

• Material – физический материал, который определяет свойства столкновений, такие как трение и отскок.
• IsTrigger – является ли коллайдер триггером?
• Used by Effector – используется ли данный коллайдер прикрепленным компонентом – Effector.
• Auto Tiling – установите этот флажок, если компонент Sprite Renderer установлен в режим Tile. Это позволит автоматически, обновлять форму коллайдера, которая будет корректироваться по форме спрайта.
• Offset – локальное смещение геометрии коллайдера.
• Size – ширина и высота прямоугольника в единицах локального пространства.
• Edge Radius – смягчает грани, делая коллайдер более круглым, по умолчанию значение равно
• Info – общая информация о состоянии коллайдера.

Визуальное отображение пустых объектов с 2D- и 3D-коллайдерами при включении 3D-режима в окне сцены:

Rigidbody2D – компонент помещает объект под контроль физического движка. В целом компонент похож на Rigidbody, но объект может двигаться только в плоскость XY, а вращаться только перпендикулярно этой плоскости.

Отличительные свойства:

• UseAutoMass – рассчитать массу автоматически,исходя из коллайдера;
• GravityScale – как гравитация воздействует на объект;
• Sleeping Mode – режим, когда объект выключается из физической симуляции (в целях оптимизации).
• Never Sleep – всегда активен (необходимо стараться избегать данного режима);
• Start Awake – активен при запуске (режим включен по умолчанию);
• Start Asleep – не активен при запуске, но может быть разбужен (столкновением или через скрипт).

Спрайты

Настройки спрайта (Import Settings)

После импорта изображения в проект в 2D-режиме разработки его настройки по умолчанию выглядят следующим образом:

• В верхней части находится иконка – превью спрайта (также превью находится в нижней части инспектора), отображается название файла, кнопка Open, которая открывает изображение в программе просмотра изображений, установленной в системе по умолчанию.
• Texture Type – устанавливает базовые параметры в зависимости от предназначения текстуры(изображения).
• Sprite Mode – устанавливает, в каком режиме спрайт будет извлекаться из изображения, как один спрайт (Single) или как несколько раздельных спрайтов (Multiple). Второй режим может использоваться для импорта спрайтов как кадров анимации, а также как несколько спрайтов, относящихся к одному объекту. Третий режим Polygon позволяет настраивать форму, размер и pivot point для вашего спрайта.
• PackingTag – имя атласа, в который данное изображение должно быть запаковано.
• Pixels Per Unit – количество пикселей в изображении спрайта, которые соответствуют одному юниту (внутренняя единица измерения в Unity).

Компонент Sprite Renderer

Данный компонент позволяет отображать спрайты и используется как в 2D, так и в3D-сценах.

Компонент имеет следующие свойства:

• Sprite – спрайт.
• Color – цвет.
• Flip – отражение спрайта по оси X или Y.
• Material – материал, стандартные шейдеры, которые используют для материала спрайта – Sprites/Default (не взаимодействует с освещением на сцене), Sprites/Diffuse (взаимодействует с освещением на сцене).
• Draw Mode – выберите параметр из списка Draw Mode, чтобы определить, как масштабируется спрайт при изменении его параметров.
• Simple – это значение по умолчанию. Изображение изменяется во всех направлениях,когда его размеры меняются.
• Sliced – применяйте это, если хотите нарезать спрайт на 9 частей, чтобы эти части можно было растягивать. В этом режиме углы остаются одинаковыми, верхняя и нижняя часть тянутся в собственную высоту, а центр тянется в ширину и высоту.
• Size – используйте это значение, чтобы изменить горизонтальный и вертикальный размер спрайта. Если вы хотите, чтобы slice работала корректно, вам нужно настроить это значение. Компонент Transform применяется только по умолчанию.
• Tiled – применяйте это если хотите нарезать спрайт на 9 частей, чтобы эти части можно было повторять. В этом режиме углы остаются одинаковыми, верхняя и нижняя часть тянутся в собственную высоту, а центр тянется в ширину и высоту.

Sprite Creator

С помощью этого инструмента можно создавать временные заменители спрайтов. Их можно использовать в проекте в процессе разработки, а затем, когда будет создана необходимая графика, заменить. Для создания таких спрайтов необходимо выбрать меню Assets – Create – Sprites, далее один из доступных типов спрайтов: Square, Triangle, Diamond, Hexagon, Circle, Polygon.

Через меню Assets – Create создаются не объекты, а ассеты, поэтому после создания спрайта в папке проекта появляется новый ассет, а на сцене ничего не изменяется. Далее необходимо добавить созданный спрайт на сцену.

Спрайты в окне проекта:

Спрайты на сцене:

При создании спрайта Polygon открывается Sprite Editor, где можно изменить форму спрайта и некоторые его параметры. Далее более подробно об этом редакторе.

Sprite Editor

Чаще всего спрайт – это одно изображение, но иногда спрайт содержит несколько элементов, которые каким-либо образом связаны друг с другом и объединены в одно изображение. Для работы с такими спрайтами в Unity есть специальный редактор.

Если для спрайта установлен режиме Sprite Mode – Single, часть функций редактора недоступна, и он выглядит следующим образом:

В режиме SpriteMode – Multiple:

SpritePacker

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

Необходимо указывать Packing Tag в настройках текстуры, чтобы включить упаковку спрайтов для данной текстуры.

По умолчанию упаковщик спрайтов отключён, но его работу можно настроить через настройки редактора Edit->Project Settings->Editor. Метод упаковывания спрайтов можно установить в состояние Enabled for Builds (упаковывание будет работать для сборок, но не в режиме Play) или в состояние Always Enabled (упаковывание будет работать и во время сборки и в режиме Play).

Указав для нескольких текстур (спрайтов) одинаковый Packing Tag, можно открыть Windows – SpritePacker, нажать кнопку Pack и посмотреть расположение текстур в атласе.

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

Инструменты в верхней части окна упаковщика спрайтов:

• Pack – инициализирует операцию упаковывания.
• Repack – переупаковка атласа (обновление).
• View Atlas – атлас, который необходимо отобразить в окне (если при максимальном размере текстуры в неё не помещаются все спрайты, атлас может быть разбит на множество страниц).
• Page – позволят выбрать страницу атласа, которую необходимо отобразить в окне.
• Меню, следующее за номером страницы – выбор правил упаковывания использующиеся для текущего атласа.

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

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

Понятие FPS

FPS – аббревиатура от Frames Per Second, что в переводе на русский означает количество кадров в секунду. Видео – это процесс смены статических кадров. Каждый кадр – это статическое изображение. Количество кадров в секунду – это скорость смены изображений.

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

Человеческий глаз способен воспринимать смену картинок, как видео при смене не менее 25-30 кадров в секунду.

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

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

Основные методы класса MonoBehaviour

MonoBehaviour – класс, на базе которого (наследуются) по умолчанию создаются все скрипты в Unity. Скрипты создаются через контекстное меню в окне проекта, через меню Component на верхней панели инструментов, при помощи кнопки Add Component в окне инспектора (когда выделен какой-либо объект). Скрипт работает только тогда, когда он является компонентом объекта на сцене, причём некоторые функции (методы) скрипта могут срабатывать даже тогда, когда сам скрипт выключен(неактивен).

Для редактирования скрипта после его создания необходимо дважды нажать на него ЛКМ в окне инспектора или в окне проекта. Скрипт откроется в той среде разработки, которая указана в настройках Editor–>Preferences–>External Tools–>External Script Editor (обычно это Visual Studio или MonoDevelop). Там же можно сменить среду разработки.

Имя класса в скрипте должно совпадать с именем файла (это происходит автоматически, при создании файла). По умолчанию в скрипте создаются две функции (метода) – Start() и Update(), но существуют и другие функций, которые могут быть использованы как унаследованные от MonoBehaviour. Так же можно создавать свои функции.

По умолчанию скрипт выглядит следующим образом:

using System.Collections;

using UnityEngine;

public class MyFirstScript : MonoBehaviour
{
    private void Start()
    {
    }

    private void Update()
    {
    }
}

Awake()

Функция, которая вызывается один раз при запуске игры до функции Start(). Вызывается в случайном порядке среди объектов на сцене, для которых она реализована. Функция срабатывает даже тогда, когда скрипт не активен.

Start()

Функция, которая также вызывается один раз, но в тот момент, когда скрипт становится активным. Вызывается перед функций FixedUpdate(),Update()ит.д.

FixedUpdate()

Функция, которая выполняется каждый фиксированный отрезок времени. Можно настроить в Edit–>Project Settings–>Time – Fixed Time step. Используется для обработки физики (приложения силы, импульса к объект у и т.д.)

Update()

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

Для того, чтобы реализовать выполнения какой-либо действия с определенной частотой, например, раз в секунду,используют Time.deltaTime * 1.

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

LateUpdate()

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

Практика

Рассмотрим проект на примере 2D Platformer’a от UnityTech.

Давайте разберем, из чего состоит основа геймплея 2DPlatformer’a.

Самым важным объектом является игрок, поэтому с него мы и начнём.

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

Аниматор — позволит нам анимировать нашего героя.

Rigidbody позволит физически взаимодействовать с препятствиями, а чтобы мы не проваливались под пол и фиксировать столкновения с препятствиями, нам понадобится Box Collider2D.

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

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

Теперь можно расставлять объекты на сцене, просто перетаскивая их из окна Project. Буквально за несколько движений мы с вами уже сделали свой уровень с персонажем.

Главное, не забыть положить нашему персонажу объект groundCheck в иерархии, как дочерний, чтобы мы могли прыгать и указать всем балкам, что они лежать на слое Ground, не забывая о коллайдерах.

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

** Проект 1 (Используя готовый проект собрать свой игровой уровень)

• Скачать несколько бесплатных ассетов и собрать свой уровень.
• Заменить спрайт персонажа на свой.
• Собрать свою сцену на основе 2D-платформера, чтобы противники спаунились и их можно было убивать.

Проект 2 (Используя графику, анимации, звуки реализовать простейший раннер)

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

• Написатьмодифицировать скрипт контроллера (передвижение). Персонаж бежит сам. От игрока требуется только прыгать над противниками. В случае падения в воду и столкновения с противником – умирать.
• Персонаж находится в середине экрана. Камера следует за персонажем.
• В случае смерти игрок стартует сначала со стартовой точки.
• В случае успеха игрок переносится в стартовую точку.
• Реализовать спаунер (место от куда они появляются)противников. Противники должны передвигаться в пределах одной платформы.
• Размер игрового окна – 1366×768.
• Примеры похожих игр: BeatRush (ios, Android), GeometryDash (ios, Android, Steam) и другие. Поиграйте, изучите как работают игры такого типа.

Примерное изображение игрового уровня:

Дополнительные материалы

• Asset Workflow
• Mipmap
• 2D физика