Блог Mopsicus – про разработку, игры и личный опыт

Починил RSS

mail@mopsicus.ru (Igor Lopatin) — Mon, 02 Mar 2026 12:35:00 +0300

Починил все RSS ленты на сайте. Оказалось, что там были неправильные пути для всех картинок 🥲 Теперь можно смело подписываться, кто пользуется RSS читалками. Ссылка в подвале, справа.

Восстановление аккаунта разработчика Google

mail@mopsicus.ru (Igor Lopatin) — Fri, 27 Feb 2026 14:10:00 +0300

Удалось восстановить и подтвердить свой древний аккаунт разработчика в Google Play. Несколько дней переписки и апелляций, составление «правильных» писем в саппорт с помощью ChatGPT и — аккаунт разлочен и подтверждён 😅

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

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

Лучшие практики Sprite Atlas в Unity

mail@mopsicus.ru (Igor Lopatin) — Wed, 25 Feb 2026 13:00:00 +0300

UniText — рендеринг текста для Unity

mail@mopsicus.ru (Igor Lopatin) — Thu, 19 Feb 2026 11:45:00 +0300

Вчера увидел в Unity паблике про свежий текстовый движок для Unity, корректно отображающий все системы письма. В основе тот же движок формирования текста который используется в Chrome, Firefox, Adobe InDesign и Android.

Пишут что быстрее, легче, сильнее чем TMP 😅 Но самое главное что я для себя отметил: полная поддержка эмоджи с использованием системных шрифтов! То есть, не нужно тащить в билд атласы с эмоджи. Да и вообще, сами атласы шрифтов для UniText вроде как тоже легче.

UniText — полная поддержка Unicode 17.0, системные emoji, 150+ языков, zero-allocation архитектура, шейпинг HarfBuzz.

Есть отличная дока, открытый код, в общем — выглядит всё очень интересно, пока.

Потенциальные трудности миграции с TMP

много сторонних ассетов основано на TMP
какие-то редакторские скрипты надо переписывать
атласы шрифтов переделывать, эффекты, материалы
UI рефакторить

Если UI не сложный, наверное проще переехать. Было бы неплохо если сделают какой-нибудь конвертер TMP → UniText, для более легкой миграции.

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

Сделал быстрый тест — сбилдил для андроид — работает жеж 🔥 Буду ковырять дальше, возможно есть подводные камни.

Znak — 2D движок для игр

mail@mopsicus.ru (Igor Lopatin) — Fri, 06 Feb 2026 10:45:00 +0300

Кто интересуется Unity и ECS наверняка слышали про товарища Leopotam и его разработки. С ним мы периодически общаемся ещё со времён самого первого ECS 😅 Так вот, он разрабатывает не только новые версии своей ECS, но и свой 2D движок Znak.

Это простой 2D движок, сначала был написан на Golang, потом портирован на Nimlang, компилируется за секунды в какие-то килобайты, которые даже считать смешно. Есть уже игра в разработке — Танчики.

Рендер на OpenGL 3.3/WebGL2/GLFW 3.4
Бандлы
SDF-шрифты
Пользовательский ввод
Шейдеры, материалы, текстуры, атласы
HTTP, WebSockets
Камеры
Звуки
Покадровая анимация и т.д.

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

Использование C# 14 в Unity

mail@mopsicus.ru (Igor Lopatin) — Fri, 30 Jan 2026 15:38:00 +0300

It’s Possible To Use C# 14 In Unity! — так называется свежий видос на одном ютуб канале. Несмотря на то что Unity официально не поддерживает C# 14 «из коробки», есть способы включить новые фичи 14 версии. Ссылки для патчинга прилагаются в описании. Так-так-так…

В самом видео говорится, что многое из списка скорее всего не будет работать, но это уже совсем другая история 😶‍🌫️

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

Extension Members — можно расширять типы не только методами, но и свойствами, индексаторами и операторами.

public static class EnumerableExtensions {
    extension<T>(IEnumerable<T> source) {
        public bool IsEmpty => !source.Any();
        public T this[int index] => source.Skip(index).First();
    }
}

Null-conditional присваивание (?.=) — позволяет записывать значения только если объект не null, без if-проверок.

player?.Health = 100;
player?.Score += 10;

Использование nameof с необобщёнными типами.

Debug.Log(nameof(List<>)); // "List"

Использование Span и ReadOnlySpan.

Span<byte> data = someArray;

Лямбды с модификаторами — можно использовать модификаторы вроде ref, out прямо в лямбдах без указания типа.

TryParse<int> parse = (text, out result) => int.TryParse(text, out result);

Ну и field в свойствах, наверно самое полезное, как по мне — можно обращаться к скрытому полю свойства прямо внутри тела аксессоров

// раньше
public int Health { get; set; }

private int _health;

public int Health {
    get => _health;
    set => _health = Mathf.Clamp(value, 0, 100);
}

//по новому
public int Health {
    get;
    set => field = Mathf.Clamp(value, 0, 100);
}

Но помните, Unity официально не поддерживает самые свежие версии C#, так что — на свой страх и риск 😅

Год ИИ

mail@mopsicus.ru (Igor Lopatin) — Sat, 24 Jan 2026 19:28:00 +0300

Год активного использования нейросетей, агентов, ИИ, etc!
Будут различные прототипы того, что долго откладывал в стол 😅

Как получить размеры TMP

mail@mopsicus.ru (Igor Lopatin) — Fri, 23 Jan 2026 15:40:00 +0300

Во всех наших играх есть список друзей и чаты между ними. Уже много лет для его реализации я использую UIS, свой же скрипт для бесконечных списков. И когда надо посчитать высоту элемента чата (облачко, speech balloon), это делалось с помощью старой функции подсчета слов, переносов строк и т.п. И в общем-то, работает это до сих пор нормально.

Но сейчас при создании новой игры, я нашёл более правильное решение этой задачи. Оказывается 😅 у TMP есть специальный метод который позволяет получить размеры компонента до! установки туда текста:

var size = _message.GetPreferredValues(text);

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

var size = _message.GetPreferredValues(text, MAX_ITEM_WIDTH, Mathf.Infinity);

Так что в новой игре чатики будут красивее 😁

Все исходники UIS доступны на Github

MCP для Unity

mail@mopsicus.ru (Igor Lopatin) — Mon, 19 Jan 2026 11:34:00 +0300

Наткнулся тут на MCP for Unity. Это «мост» между редактором Unity и внешними AI-ассистентами/IDE через MCP (Model Context Protocol). В общем, позволяет выполнять действия напрямую в Unity через команды на естественном языке, так же как мы вайбкодим в чатике 😁

Зачем

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

Что может

Поставил. Подключил к своему Copilot. Интересная штука оказалась. В дополнение к Claude теперь можно какие-то вещи делегировать туда и оно будет работать в редакторе:

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

Немного потестировал в своих обычных кейсах, например: скопируй префаб Х из папки Y, удали в нём компонент Z и добавь компонент J, переименуй. В общем, то что обычно руками делал. Ну работает конечно, но не быстро 😅 Ещё написано что можно делать свои расширения, вот это уже интересно. И есть возможность выполнять несколько команд в одном вызове, это должно ускорить процесс…

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

Маркетинг в эпоху нейросетей

mail@mopsicus.ru (Igor Lopatin) — Tue, 13 Jan 2026 10:15:00 +0300

Вчера прочитал пост, что сейчас делать MVP по большому счёту уже не нужно и даже «вредно». С приходом нейросетей больше нет проблемы быстро что-то сделать: несложный сервис, приложение или клон можно наколдовать за короткое время.

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

В контексте игр это работает точно так же. Сделать несложную игру стало ещё проще, игр выпускается очень много, если не заниматься маркетингом — про неё просто никто не узнает. Вот читаю канал Кирилла Орешкина и примерно видно как работает этот процесс: есть трейлер, есть страница в Стим, нагоняется трафик, проверяются различные метрики, вишлисты и прочее. В этот момент игры ещё вообще может не быть 😁 Так и живём…

Выводы:

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

Античит для Unity на минималках

mail@mopsicus.ru (Igor Lopatin) — Sat, 31 Jan 2026 16:35:00 +0300

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

Главное что можно сразу сказать:

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

Основная задача: отсечь 80–90% «случайных» читеров, сохранить честность различных лидерборд и рейтингов, не тратить месяцы разработки.

Античит — это не про «сделать чит невозможным». Это про сделать чит дорогим, нестабильным и бессмысленным.

Какие есть самые распространённые читы с которыми может (скорее всего) столкнуться разработчик игр:

Memory hack (скорость, здоровье, урон)
Подмена логики (patched APK/modded build)
Спидхак (Time.timeScale, SpeedHack)
Подмена сохранений
Боты/автокликеры
Подмена сетевых пакетов (если есть онлайн)

Главное правило: клиенту нельзя доверять!

Примерно 90% игр (не ААА, а инди) ломаются с каким-нибудь Cheat Engine, если разработчик не озадачился минимальной защитой, как локальной так и серверной.

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

Защита без сервера

Определение спидхака

float realDelta = Time.unscaledDeltaTime;
float gameDelta = Time.deltaTime;

if (gameDelta / realDelta > 1.5f) {
    Flag();
}

Ловим TimeScale и системные спидхаки, просто и работает.

Защита значений

private int _gold;
private int _goldKey;

public int Gold {
    get => _gold ^ _goldKey;
    set {
        _goldKey = Random.Range(int.MinValue, int.MaxValue);
        _gold = value ^ _goldKey;
    }
}

Не совсем защита, а скорее усложнение при поиске точных значений в памяти.

Контроль максимума

if (damage > maxDamage * 1.2f) {
    Flag();
}

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

Важно: не банить сразу, а накапливать «флаги». Любой античит может ошибаться. Об этом ниже.

Защита в онлайн-играх

Авторитарный сервер — наверное самый распространённый вариант — является единственным источником истины, он обрабатывает все механики, движения и взаимодействия, чтобы исключить читерство.

Клиент не обрабатывает логику (например, перемещение или попадание) и не может подделать эти данные. Он получает готовое состояние «мира» и/или его изменение. Сервер же обрабатывает данные от всех клиентов, синхронизируя их.

Сервер может отслеживать подозрительные действия:

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

Главное: не банить сразу, не показывать сообщение «ты читер» 😅

Система флагов и банов

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

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

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

Идеально: читер не знает за что его поймали и что его вообще поймали.

Если банить сразу:

читер узнает точный триггер
он чинит за 10 минут
выкладывает «рабочую версию»

Если «копить флаги»:

он не понимает, что именно сработало
не знает, когда его «спалили»
не может воспроизвести условие

Лучший античит — тот, который не даёт обратной связи. Джейсон Стейтем

Когда есть накопленные флаги, ты можешь:

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

И самое важное: читер продолжает играть и не создаёт новый аккаунт!

Простая система флагов

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

enum CheatFlag {
    SpeedHack,
    TimeHack,
    InvalidDamage,
    Teleport,
    RateLimit
}

Dictionary<CheatFlag, int> flags = new();

void AddFlag(CheatFlag flag) {
    flags.TryAdd(flag, 0);
    flags[flag]++;
    int total = flags.Values.Sum();
    if (total > 10) {
        SoftBan();
    }
}

Кроме того, подобная система даст аналитику:

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

В общем, античит — это наблюдение, накопление и изоляция.

Платные и бесплатные ассеты

Anti-Cheat Toolkit

Универсальный античит, один из самых популярных ассетов для Unity, который предлагает:

защиту переменных в памяти
обфускацию PlayerPrefs
обнаружение speedhack и Time hack
инжекционный хук-детектор
обнаружение wallhack и прочие механизмы
есть GUI для инспектора и примеры кода

Anti Cheat Free v2025

защита типов переменных (int, float, Vector3 и др.)
защита сохранений
защита от манипуляция со временем
обнаружение изменения памяти
бесплатеный, подходит для простых проектов/экспериментов

GUARD – Multiplayer Anti Cheat

античит для сетевых игр
обнаружение читов в многопользовательской среде
подходит, если игра использует свой сетевой код (не только Unity Netcode), есть поддержка Mirror
обнаруживает Melon, BepInEx, DLL инъекции, патчинг инструкций, дебагеры, виртуальные машины

Easy Anti Cheat Tools

обнаружение манипуляций с памятью
спидхаков
инъекции ассемблерного кода
манипуляций с PlayerPrefs
расширенное использование PlayerPrefs
защищённые типы данных
простые в использовании хеширование и криптография

Unity Game Shield

защита памяти
сканер инъекций
защищённые сохранения игры
капча с вознаграждением
защита от таймхаков
детектор спидхаков
защищённые сетевые запросы
система отчётов о читерстве
детектор телепортации
детектор воллхаков

SafeValues

скрывает переменные в памяти
шифрует и расширяет PlayerPrefs
обнаруживает спидхаки

Тяжёлая артиллерия

DexGuard (Guardsquare)

продвинутая обфускация DEX
защита от реверс-инжиниринга
анти-debug/анти-emulator
anti-tampering (подпись, целостность)
runtime checks
string/class encryption
защита JNI/native кода

В контексте Unity:

работает поверх IL2CPP
защищает Java-слой, bootstrap, плагины
сильно усложняет modded APK
часто используется в F2P с реальной экономикой

DexProtector (Licel)

anti-tampering
anti-debug / anti-hook
anti-emulator
string & class encryption
контроль целостности
защита native библиотек

В контексте Unity:

часто используется как альтернатива DexGuard
подходит для игр среднего масштаба
хорошо режет repack + LuckyPatcher

Arxan GuardIT (Digital.ai)

одна из самых жёстких систем защиты
используется в крупных играх и корпорациях
runtime-mutation
self-defending code
анти-hook, анти-dump, анти-debug
серверные проверки целостности

В контексте Unity:

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

Appdome

защита без изменения исходного кода
cloud-pipeline
anti-tampering
anti-debug
обнаружение root/jailbreak

В контексте Unity:

подходит, если нет доступа к исходникам Android-части
часто берут издатели

Virbox/Themida/VMProtect

применяются для PC-версий
защищают exe/native IL2CPP
часто конфликтуют с античитами
могут вызывать срабатывания у антивирусов

Бан — это крайняя мера и он оправдан, когда:

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

Банить сразу — значит терять игроков быстрее, чем читеров 🥲 Надеюсь ваши игры будут такие популярные и успешные, что вам хватит на любую защиту 🤑 Потому что в таком случае она вам 100% понадобится.

Настройка VS Code для Unity

mail@mopsicus.ru (Igor Lopatin) — Mon, 22 Dec 2025 20:05:00 +0300

Скоро уже будет лет 10 как я увяз в Unity и C#… Начинал наверно как и многие с MonoDevelop 🥴 Потом появился Sublime Text, которым я пользовался пару лет, классный и быстрый редактор, у меня даже была такая же заметка про его настройку. Но он был поменян на VS Code, который тогда начал активно развиваться и поддерживаться. Собственно, до сих пор им и продолжаю пользоваться.

Далее, почему я считаю VS Code хорошим выбором для разработки на Unity и C#, также список плагинов и настроек которые использую и рекомендую.

Почему VS Code, плюсы

лёгкий и быстрый
бесплатный и кроссплатформенный
гибкая кастомизация
отлично подходит для многопроектной работы
хорошо дружит с Git

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

Минусы

более слабая интеграция с Unity
слабый рефакторинг по сравнению с Rider
слабее отладка
нет встроенной навигации по Unity API

Тут минусы только в контексте работы с Unity. Некоторые из них выходят как ни странно из «плюсов», например, слабая интеграция с Unity и хуже рефакторинг — это «плата» за быстроту, бесплатность и возможность в одном редакторе работать и с C#, и c TypeScript, Node.js и с прочими языками и фреймворками. Редактор не заточен под один язык или платформу, как Xcode например.

Расширения

C# Dev Kit — ну это база, как говорится, официальное расширение от Microsoft, лучше OmniSharp: нормальный intellisense, поддержка C# 8–12, встроенный Roslyn анализатор, быстрая индексация
Unity Tools — подсветка методов монобехов, ссылки на Unity доки, лучше навигация по Unity API
Error Lens — отображение ошибок и варнингов прямо в строках (спёрто у Rider 😬)
GitLens — навигация по истории, blame, ревью и прочие git радости
EditorConfig for VS Code — настройка форматирования через стандартизированный формат
Todo Tree — быстрый поиск и отображение TODO-шек
Unity — официальное расширение Unity для VS Code: API, debugger, подсказки, навигация
Monokai Pro — тема оформления
eppz! — ещё тема оформления

Ниже мой файл конфигурации .editorconfig который вместе с расширением EditorConfig for VS Code показывает ошибки, варнинги в именовании полей, переменных и методов, а также форматирует код в соответствии с указанными правилами.

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

# Dotnet code style settings:
[*.cs]
indent_style = space
indent_size = 4
insert_final_newline = true
charset = utf-8

# Sort using and Import directives with System.* appearing first
csharp_using_directive_placement = outside_namespace:silent
dotnet_sort_system_directives_first = true
dotnet_separate_import_directive_groups = false

# Avoid "this." and "Me." if not necessary
dotnet_style_qualification_for_field = false:refactoring
dotnet_style_qualification_for_property = false:refactoring
dotnet_style_qualification_for_method = false:refactoring
dotnet_style_qualification_for_event = false:refactoring

# Use language keywords instead of framework type names for type references
dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
dotnet_style_predefined_type_for_member_access = true:suggestion

# Suggest more modern language features when available
dotnet_style_object_initializer = true:suggestion
dotnet_style_collection_initializer = true:suggestion
dotnet_style_coalesce_expression = true:suggestion
dotnet_style_null_propagation = true:suggestion
dotnet_style_explicit_tuple_names = true:suggestion

# Whitespace options
dotnet_style_allow_multiple_blank_lines_experimental = false

# IDE0055: Fix formatting
dotnet_diagnostic.IDE0055.severity = warning

# Newline settings
csharp_new_line_before_open_brace = false
csharp_new_line_before_else = false
csharp_new_line_before_catch = false
csharp_new_line_before_finally = false
csharp_new_line_before_members_in_object_initializers = false
csharp_new_line_before_members_in_anonymous_types = false
csharp_new_line_between_query_expression_clauses = false
csharp_new_line_between_members = true

# Indentation preferences
csharp_indent_block_contents = true
csharp_indent_braces = false
csharp_indent_case_contents = true
csharp_indent_case_contents_when_block = true
csharp_indent_switch_labels = true
csharp_indent_labels = flush_left

# Whitespace options
csharp_style_allow_embedded_statements_on_same_line_experimental = false
csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false
csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = false
csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = false
csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = false

# # Prefer "var" everywhere
csharp_style_var_for_built_in_types = true:suggestion
csharp_style_var_when_type_is_apparent = true:suggestion
csharp_style_var_elsewhere = true:suggestion

# Prefer method-like constructs to have a block body
csharp_style_expression_bodied_methods = false:none
csharp_style_expression_bodied_constructors = false:none
csharp_style_expression_bodied_operators = false:none

csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:suggestion

# Prefer property-like constructs to have an expression-body
csharp_style_expression_bodied_properties = true:none
csharp_style_expression_bodied_indexers = true:none
csharp_style_expression_bodied_accessors = true:none

# Suggest more modern language features when available
csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
csharp_style_inlined_variable_declaration = true:suggestion
csharp_style_throw_expression = true:suggestion
csharp_style_conditional_delegate_call = true:suggestion
csharp_style_prefer_extended_property_pattern = true:suggestion

# Space preferences
csharp_space_after_cast = false
csharp_space_after_colon_in_inheritance_clause = true
csharp_space_after_comma = true
csharp_space_after_dot = false
csharp_space_after_keywords_in_control_flow_statements = true
csharp_space_after_semicolon_in_for_statement = true
csharp_space_around_binary_operators = before_and_after
csharp_space_around_declaration_statements = do_not_ignore
csharp_space_before_colon_in_inheritance_clause = true
csharp_space_before_comma = false
csharp_space_before_dot = false
csharp_space_before_open_square_brackets = false
csharp_space_before_semicolon_in_for_statement = false
csharp_space_between_empty_square_brackets = false
csharp_space_between_method_call_empty_parameter_list_parentheses = false
csharp_space_between_method_call_name_and_opening_parenthesis = false
csharp_space_between_method_call_parameter_list_parentheses = false
csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
csharp_space_between_method_declaration_name_and_open_parenthesis = false
csharp_space_between_method_declaration_parameter_list_parentheses = false
csharp_space_between_parentheses = false
csharp_space_between_square_brackets = false

# Blank lines
csharp_blank_lines_around_region = 0
csharp_blank_lines_inside_region = 0
csharp_keep_blank_lines_in_declarations = 1
csharp_remove_blank_lines_near_braces_in_declarations = true
csharp_blank_lines_between_using_groups = 1
csharp_blank_lines_after_using_list = 1
csharp_blank_lines_around_namespace = 1
csharp_blank_lines_inside_namespace = 0
csharp_blank_lines_after_file_scoped_namespace_directive = 1
csharp_blank_lines_around_type = 1
csharp_blank_lines_around_single_line_type = 1
csharp_blank_lines_inside_type = 0
csharp_blank_lines_around_field = 1
csharp_blank_lines_around_single_line_field = 1
csharp_blank_lines_around_property = 1
csharp_blank_lines_around_single_line_property = 1
csharp_blank_lines_around_auto_property = 1
csharp_blank_lines_around_single_line_auto_property = 1
csharp_blank_lines_around_accessor = 1
csharp_blank_lines_around_single_line_accessor = 1
csharp_blank_lines_around_invocable = 1
csharp_blank_lines_around_single_line_invocable = 1
csharp_keep_blank_lines_in_code = 0
csharp_remove_blank_lines_near_braces_in_code = false
csharp_blank_lines_around_local_method = 1
csharp_blank_lines_around_single_line_local_method = 0
csharp_blank_lines_before_control_transfer_statements = 0
csharp_blank_lines_after_control_transfer_statements = 0
csharp_blank_lines_before_block_statements = 0
csharp_blank_lines_after_block_statements = 0
csharp_blank_lines_around_block_case_section = 0
csharp_blank_lines_around_multiline_case_section = 0
csharp_blank_lines_before_case = 0
csharp_blank_lines_after_case = 0

# Access modifiers
dotnet_style_require_accessibility_modifiers = omit_if_default:warning

# Blocks are allowed
csharp_prefer_braces = true
csharp_preserve_single_line_blocks = true
csharp_preserve_single_line_statements = true

dotnet_diagnostic.IDE0001.severity = silent
dotnet_diagnostic.IDE0002.severity = warning

# Using directive is unnecessary.
dotnet_diagnostic.IDE0005.severity = warning

# invalid switch.
dotnet_diagnostic.IDE0010.severity = silent

# add braces.
dotnet_diagnostic.IDE0011.severity = warning

# IDE0040: Add accessibility modifiers
dotnet_diagnostic.IDE0040.severity = suggestion

# IDE0060: Remove unused parameter
dotnet_diagnostic.IDE0060.severity = warning

# IDE0052: Remove unread private member
dotnet_diagnostic.IDE0052.severity = warning

# IDE0059: Unnecessary assignment to a value
dotnet_diagnostic.IDE0059.severity = warning

# CA1012: Abstract types should not have public constructors
dotnet_diagnostic.CA1012.severity = warning

# CA1822: Make member static
dotnet_diagnostic.CA1822.severity = warning

dotnet_diagnostic.IDE0051.severity = warning

dotnet_diagnostic.IDE0160.severity = warning
dotnet_diagnostic.IDE0161.severity = warning

# Prefer "var" everywhere
dotnet_diagnostic.IDE0007.severity = warning
csharp_style_var_for_built_in_types = true:warning
csharp_style_var_when_type_is_apparent = true:warning
csharp_style_var_elsewhere = true:warning

# csharp_style_allow_embedded_statements_on_same_line_experimental
dotnet_diagnostic.IDE2001.severity = silent

# csharp_style_allow_blank_lines_between_consecutive_braces_experimental
dotnet_diagnostic.IDE2002.severity = warning

# csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental
dotnet_diagnostic.IDE2004.severity = warning

# csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental
dotnet_diagnostic.IDE2005.severity = warning

# csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental
dotnet_diagnostic.IDE2006.severity = warning

# CS4014 Because this call is not awaited, execution of the current method continues before the call is completed
dotnet_diagnostic.CS4014.severity = silent

# csharp_style_implicit_object_creation_when_type_is_apparent
dotnet_diagnostic.IDE0090.severity = silent

# IDE0035: Remove unreachable code
dotnet_diagnostic.IDE0035.severity = warning

# IDE0130: Namespace does not match folder structure
dotnet_diagnostic.IDE0130.severity = silent

# IDE0071: Simplify interpolation
dotnet_diagnostic.IDE0071.severity = suggestion
dotnet_style_prefer_simplified_interpolation = true

# IDE0041: Use is null check
# Unity objects don't support null checking so best to use ReferenceEquals(value, null)
dotnet_diagnostic.IDE0041.severity = error
dotnet_style_prefer_is_null_check_over_reference_equality_method = false

# .NET Unnecessary code rules
[*.{cs,csx,cake,vb,vbx}]
dotnet_code_quality_unused_parameters = all:warning
dotnet_remove_unnecessary_suppression_exclusions = none:warning

# Constants are UPPERCASE
dotnet_naming_rule.constants_should_be_upper_case.severity = error
dotnet_naming_rule.constants_should_be_upper_case.symbols = constants
dotnet_naming_rule.constants_should_be_upper_case.style = constant_style
dotnet_naming_symbols.constants.applicable_kinds = field, local
dotnet_naming_symbols.constants.required_modifiers = const
dotnet_naming_style.constant_style.capitalization = all_upper

# Private should starts underscore
dotnet_naming_rule.private_members_with_underscore.symbols = private_fields
dotnet_naming_rule.private_members_with_underscore.style = prefix_underscore
dotnet_naming_rule.private_members_with_underscore.severity = error
dotnet_naming_symbols.private_fields.applicable_kinds = field
dotnet_naming_symbols.private_fields.applicable_accessibilities = private
dotnet_naming_style.prefix_underscore.capitalization = camel_case
dotnet_naming_style.prefix_underscore.required_prefix = _

# Public fields should be PascalCase
dotnet_naming_rule.public_fields_should_be_pascalcase.symbols = public_fields
dotnet_naming_rule.public_fields_should_be_pascalcase.style = pascalcase_style
dotnet_naming_rule.public_fields_should_be_pascalcase.severity = error
dotnet_naming_symbols.public_fields.applicable_kinds = field
dotnet_naming_symbols.public_fields.applicable_accessibilities = public
dotnet_naming_symbols.public_fields.required_modifiers = 
dotnet_naming_style.pascalcase_style.capitalization = pascal_case

# Interfaces should begin with I
dotnet_naming_rule.interface_should_begin_with_i.symbols = interface
dotnet_naming_rule.interface_should_begin_with_i.style = begins_with_i
dotnet_naming_rule.interface_should_begin_with_i.severity = error
dotnet_naming_symbols.interface.applicable_kinds = interface
dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal
dotnet_naming_style.begins_with_i.required_prefix = I
dotnet_naming_style.begins_with_i.capitalization = pascal_case

# Locals and parameters are camelCase
dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters
dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style
dotnet_naming_rule.locals_should_be_camel_case.severity = warning
dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local
dotnet_naming_symbols.locals_and_parameters.applicable_accessibilities = *
dotnet_naming_style.camel_case_style.capitalization = camel_case

# Types should be PascalCase
dotnet_naming_rule.types_should_be_pascal_case.symbols = types
dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
dotnet_naming_rule.types_should_be_pascal_case.severity = error
dotnet_naming_symbols.types.applicable_kinds = namespace, class, struct, interface, enum, property, method, event, delegate, local_function
dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal
dotnet_naming_style.pascal_case.capitalization = pascal_case

Шрифт FiraCode

Использую данный шрифт уже давно. Это хороший бесплатный моноширинный шрифт с лигатурами (которые почему-то не всем не нравятся 🤷‍♂️). Для отображения лигатур надо включить их в настройках VS Code:

{
  "editor.fontFamily": "Fira Code", // или FiraCode-Retina
  "editor.fontLigatures": true
}

Inlay Hints

Inlay Hints — это подсказки прямо в коде, которые редактор показывает внутри строки, но которые не являются частью кода. Некоторые не включают их из-за «визуального шума», но я к ним давно привык и всегда использую.

{
  "editor.inlayHints.fontFamily": "FiraCode",
  "csharp.inlayHints.enableInlayHintsForImplicitObjectCreation": true,
  "csharp.inlayHints.enableInlayHintsForImplicitVariableTypes": true,
  "csharp.inlayHints.enableInlayHintsForLambdaParameterTypes": true,
  "csharp.inlayHints.enableInlayHintsForTypes": true,
  "dotnet.inlayHints.enableInlayHintsForIndexerParameters": true,
  "dotnet.inlayHints.enableInlayHintsForLiteralParameters": true,
  "dotnet.inlayHints.enableInlayHintsForObjectCreationParameters": true,
  "dotnet.inlayHints.enableInlayHintsForOtherParameters": true,
  "dotnet.inlayHints.enableInlayHintsForParameters": true,
  "dotnet.inlayHints.suppressInlayHintsForParametersThatDifferOnlyBySuffix": true,
  "dotnet.inlayHints.suppressInlayHintsForParametersThatMatchArgumentName": true,
  "dotnet.inlayHints.suppressInlayHintsForParametersThatMatchMethodIntent": true
}

Плагин для Unity

Для завершения интеграции с Unity редактором необходимо установить пакет Visual Studio Editor. Обычно он сразу включён после установки редактора, вместе с плагином для Rider.

Вот такая сборка. Не забываем обновлять расширения. Ждём CoreCLR 😅

Генерация 3D моделей

mail@mopsicus.ru (Igor Lopatin) — Wed, 05 Nov 2025 10:15:00 +0300

Собирал для студентов список сервисов для генерации 3D моделей по описанию и из 2D в 3D, решил что можно и поделиться, наверняка будет полезно. Мои фавориты пока это Meshy и Hitem3D.

Периодически буду возвращаться к этому списку, потому что такие вещи сейчас часто появляются, буду чекать ссылки, удалять мёртвые, добавлять новые. Последнее обновление: 05.11.2025.

Менеджер событий для Unity

mail@mopsicus.ru (Igor Lopatin) — Fri, 05 Sep 2025 13:34:00 +0300

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

Менеджер событий или шина данных — паттерн проектирования pub-sub (публикация-подписка), который служит посредником между компонентами системы, позволяя им взаимодействовать, не зная друг друга напрямую.

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

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

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

Сразу простой пример:

using Shardy.Signals;

/// <summary>
/// Demo interface
/// </summary>
public interface IDemo : ISubscriber {
    void OnSignalAction(int data);
}

/// <summary>
/// Demo class with sender/receiver
/// </summary>
public class Demo : MonoBehaviour, IDemo {

    /// <summary>
    /// Log tag
    /// </summary>
    public const string TAG = "DEMO";

    /// <summary>
    /// Destroy method name
    /// </summary>
    const string SEND_METHOD = "Send";

    /// <summary>
    /// Init and subscribe to signals
    /// </summary>
    void Awake() {
        Signals.Subscribe(this);
        InvokeRepeating(SEND_METHOD, 1f, 1f);
    }

    /// <summary>
    /// Unsubscribe from signals
    /// </summary>
    void OnDestroy() {
        Signals.Unsubscribe(this);
    }

    /// <summary>
    /// Sends demo signals
    /// Send int data -> current subscriber count
    /// </summary>
    void Send() {
        Signals.Send<IDemo>(a => a.OnSignalAction(Signals.GetSubscriberCount<IDemo>()));
    }

    /// <summary>
    /// Called when a signal is received
    /// </summary>
    public void OnSignalAction(int data) {
        Debug.Log(///
{{> rss-list key='layout' value='post' time='rss' limit=10}}
{{> rss-list key='layout' value='note' time='rss' limit=10}}
///quot;[{TAG}] action: {data}");
    }
}

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

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

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

Это хорошо работает с пунктом №2, т.е. когда одно действие должно вызвать реакцию в разных подсистемах. Как пример, событие PlayerKilled. Что может происходить в этом случае:

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

Отправив одно сообщение, каждая подсистема связанная с игроком и подписанная на это событие, примет его и выполнит.

Вот как это можно реализовать:

/// <summary>
/// Player interface
/// </summary>
public interface IPlayer : ISubscriber {
    void OnPlayerKilled(int level, int score);
    ...
}

/// <summary>
/// Player class on character object
/// </summary>
public class Player {

    /// <summary>
    /// Current player level
    /// </summary>
    int _level = 3;

    /// <summary>
    /// Current player score
    /// </summary>
    int _score = 120;

    /// <summary>
    /// Called when take damage
    /// </summary>
    public void OnDamage(int health) {
      if (health <= 0) {
        Signals.Send<IPlayer>(action => action.OnPlayerKilled(_level, _score));
      }
    }
}

/// <summary>
/// UI
/// </summary>
public class UI: IPlayer {

    /// <summary>
    /// Subscribe to signals
    /// </summary>
    void Awake() {
        Signals.Subscribe(this);
    }

    /// <summary>
    /// Called when a signal is received
    /// </summary>
    public void OnPlayerKilled(int level, int score) {
        TMP.SetText("Player killed on {0} level with {1} score", level, score);
    }
}

/// <summary>
/// Sounds
/// </summary>
public class SoundManager: IPlayer {

    /// <summary>
    /// Subscribe to signals
    /// </summary>
    void Awake() {
        Signals.Subscribe(this);
    }

    /// <summary>
    /// Called when a signal is received
    /// </summary>
    public void OnPlayerKilled(int level, int score) {
        Audio.Play(///
{{> rss-list key='layout' value='post' time='rss' limit=10}}
{{> rss-list key='layout' value='note' time='rss' limit=10}}
///quot;killed_sound_{level}");
    }
}

/// <summary>
/// Stats
/// </summary>
public class Stats: IPlayer {

    /// <summary>
    /// Subscribe to signals
    /// </summary>
    void Awake() {
        Signals.Subscribe(this);
    }

    /// <summary>
    /// Called when a signal is received
    /// </summary>
    public void OnPlayerKilled(int level, int score) {
        DB.SendStat("killed", level, score);
    }
}

Тут конечно всё упрощено, но смысл думаю понятен:

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

Особенности реализации

Данная реализация поддерживает WeakReference, это означает что если получатель при отправке события уже удалён, то ошибки не будет.

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

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

Если бы этот пакет был не для использования в Unity, то этой проверки можно было бы избежать. А так есть нюанс, как в старом анекдоте…

В Unity уничтожение объекта не значит что GC его сразу убрал. UnityEngine.Object имеют кастомное поведение:

obj == null возвращает true, хотя в памяти объект ещё есть
ReferenceEquals(obj, null) вернёт false

Поэтому при работе с WeakReference в Unity проверка должна быть двойная:

/// <summary>
/// Check if object is alive, check custom null behavior
/// </summary>
bool IsAlive(object target) {
    if (target == null) {
        return false;
    }
    if (target is UnityEngine.Object obj && obj == null) {
        return false;
    }
    return true;
}

Когда не стоит использовать

когда связь «один к одному»
очень частые события Update, FixedUpdate и другие перегрузят систему, тут лучше прямые вызовы
есть критическая зависимость: лучше передать ссылку напрямую, а не надеятся, что «кто-то подпишется»

Иногда, попробовав такой метод коммуникации между объектами и системами, возникает соблазн слать события на всё подряд. Но это фатальная ошибка 😬 Если игра (проект) более-менее крупная, а не прототип, то нужен строгий контроль или использование других паттернов, например ECS.

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

Документации нет, всё поместилось в README файле. Добавил этот модуль как часть Shardy, но использовать его конечно можно и отдельно.

Все исходники доступны на Github

FSM для C#

mail@mopsicus.ru (Igor Lopatin) — Thu, 05 Dec 2024 12:18:00 +0300

В общем-то, на просторах Гитхаба можно найти 100 и 1 вариант FSM, но у моей реализация есть свои «особенности» 😅 Сначала, краткое описание для тех кто не в курсе:

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

И сразу тестовый пример из демки:

using Shardy.FSM;

/// <summary>
/// Test FSM
/// </summary>
void Test() {
    _fsm = FSM<State, Action>.Builder(State.Standing)
    .State(State.Standing)
    .OnEnter((data) => {
        Debug.Log("on enter standing");
    })
    .To(State.Sitting).On(Action.Down)
    .To(State.Jumping).On(Action.Space).If(s => _isConditionActive)
    .State(State.Sitting)
    .To(State.Lying).On(Action.Down)
    .To(State.Standing).On(Action.Up)
    .State(State.Lying)
    .To(State.Sitting).On(Action.Up)
    .State(State.Jumping)
    .Note("some help message here")
    .OnExit((data) => {
        Debug.Log("on exit jumping");
    })
    .To(State.Standing).On(Action.Down)
    .Build();

    _fsm.Trigger(Action.Down);
}

Для перехода на стейт надо активировать триггер(ы):

fsm.Trigger(Action.Down);
fsm.Trigger(Action.Down);

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

initial is standing
on exit standing
on enter sitting
on exit sitting
on enter lying

Ещё подсмотрел, как сгенерить описание для UML диаграммы и отрендерить её на сайте или на этом, по-моему у них один движок:

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

@startuml
skin rose
title TestFSM
left to right direction
agent Standing
agent Sitting
agent Lying
agent Jumping
note left of Jumping
some help message here
end note
Start --> Standing
Standing --> Sitting : Down
Standing ~~> Jumping : Space
Sitting --> Lying : Down
Sitting --> Standing : Up
Lying --> Sitting : Up
Jumping --> Standing : Down
@enduml

Ещё к каждому переходу можно добавлять условия, (на картинке выше их нет) об этом подробнее в документации.

Если у перехода между состояниями есть условие(я), то линия будет рисоваться пунктирной, а если нет триггера – то с крестиком на конце. Актуально когда состояний и переходов много, можно сгенерить диаграмму и посмотреть нет ли косяков.

Вертикальная форма записи это необязательное условие 😅

И тут возникает вопрос: зачем в разработке машина состояний?

Если совсем просто — это способ сказать объекту:

Сейчас ты в таком-то состоянии, и можешь делать только это. А потом — переключись в другое состояние и делай другое.

Примеры

Персонаж игрока

Состояния: стоит, идет, прыгает, атакует.

Когда игрок нажимает «прыжок», машина состояний переключается с «идёт» на «прыгает», и только тогда проигрывается анимация прыжка и отключается движение по земле.

Противник

Состояния: патрулирует → заметил игрока → следует → атакует.

Без машины состояний враг мог бы «пытаться делать всё сразу», а это приводит к багам и странному поведению.

Карточные игры

Состояния: ожидает, ходит, бьётся, берёт.

На каждом состоянии отображается разные элементы управления, UI, запускается таймер и прочее.

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

Все исходники доступны на Github

Бесплатные звуки и музыка для игр

mail@mopsicus.ru (Igor Lopatin) — Sat, 01 Apr 2023 15:06:00 +0300

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

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

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

Оптимизация игр на Unity

mail@mopsicus.ru (Igor Lopatin) — Wed, 13 Oct 2021 10:20:00 +0300

Не смотрите что статья от 2021 года, она даже старее 😁 На старой версии сайта она была одной из первых, начал я её в 2016 году. К слову, с тех пор многие советы до сих пор актуальны, поэтому я решил её оставить и в новой версии сайта.

Этот пост будет периодически дополняться и обновляться как и прежде, последнее обновление: 24.10.2025.

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

Ниже немного актуальных до сих пор рекомендаций и ссылки на статьи, они подойдут и для 2D и для 3D игр:

Кешируйте всё. Всё что используется больше 1-2 раз — лучше закешировать. Операции типа GameObject.Find(), GetComponent(), FindObjectOfType() достаточно ресурсозатратны, а если они вызываются где-нибудь в цикле или в Update(), то производительность наверняка упадёт.
В Unity есть стандартные пресеты настройки качества графики. Но так как мы говорим про оптимизацию для 2D и для мобильных устройств, то всё что выше Simple нет смысла ставить. Конечно, если у вас есть какие-то специфические моменты, частицы, и т.п., то с параметры можно поэкспериментировать найдя оптимальный баланс.
Регулируйте частоту кадров. Понижая фреймрейт на сценах или игровых меню, где ничего не двигается, можно значительно снизить CPU, а следовательно продлить жизнь батарее устройства.

QualitySettings.vSyncCount = 0;
Application.targetFrameRate = XX;

Если не отключить вертикальную синхронизацию, то изменение фреймрейта игнорируется!

Все используемые картинки нужно упаковывать в атласы. Можно использовать как встроенный инструмент, так и подготавливать атласы в какой-нибудь другой программе, например TexturePacker. Таким образом уменьшается количество вызовов отрисовок ваших спрайтов. Проверить как идёт отрисовка можно с помощью встроенного инструмента Frame Debugger.
Ещё про атласы. Если упаковываете в Unity, убедитесь что атлас влезает на одну страницу! Это видно в инспекторе. Иначе каждая страница по сути новая текстура.
Старайтесь по возможности делать меньше вызовов xxx.ToList() и xxx.ToArray() — они создают новые коллекции при каждом вызове. Лучше построить свой код так, чтобы был прямой доступ к массивам, спискам и использовать ранее созданные коллекции повторно.
Уделите внимание работе со строками, особенно если это частая операция. Используйте StringBuilder и специальный форматный метод TMP — tmp.SetText("Data: {0}", data), он не создаёт промежуточные строки.
Используйте пул объектов. GameObject.Instantiate() — очень дорогая операция! Если есть возможность не использовать её в процессе игры — не используйте. Для большого количества однотипных объектов надо использовать пул объектов (object pool). Один раз инициализировав определенное количество, например пуль, они будут использоваться снова и снова, вместо создания и уничтожения каждый раз. Урок по пулу объектов и куча готовых реализаций гуглится по запросу unity object pool github.
Используйте события. Во многих уроках и видео до сих пор используют метод Update(). Он вызывается каждый кадр, а FixedUpdate() по умолчанию вызывается 50 раз в секунду! Если у вас в этих методах лежит какой-то тяжелый код, то производительность приложения упадёт. В качестве альтернативы можно использовать: 1) событийный подход 2) корутины 3) централизованный Update 4) перейти на ECS

/// <summary>
/// Пример с событиями (event-driven)
/// </summary>
public class Player : MonoBehaviour {

    public Action OnDamaged;

    public void Damage(int value) {
        OnDamaged?.Invoke();
    }
}

/// <summary>
/// Интерфейс для вызова обновления
/// </summary>
public interface IUpdatable {
    void OnUpdate();
}

/// <summary>
/// Менеджер для централизованного Update
/// </summary>
public class Updater : MonoBehaviour {
    
    List<IUpdatable> updatables = new List<IUpdatable>();

    public void Register(IUpdatable item) => updatables.Add(item);

    void Update() {
        foreach (var item in updatables) {
            item.OnUpdate();
        }
    }
}

Уменьшайте размер текстур. Если не знаете как оптимизировать картинки при сохранении в редакторе, прогоните их через какой-нибудь онлайн оптимизатор. В некоторых случаях можно уменьшить размер на 20-40% от оригинала.
Ещё про текстуры. Если используйте спрайты вне атласов — старайтесь делать картинки (да и сами атласы тоже) размером кратным степени 2, т.е. 1024×1024, 2048×2048. Особенно актуально для WebGL билдов.
При возможности используйте одинаковые материалы. Если на объектах стоят разные материалы, они не будут батчится и будет больше вызовов отрисовки.
Старайтесь не использовать скрипты для автоматического расположения элементов UI: ContentSizeFitter, XXXLayoutGroup. Они удобные, но ресурсозатратные. Особенно если внутри большое количество элементов. Если количество и расположение элементов в процессе работы не будет меняться, можно отключить их в редакторе, после установки на нужные позиции.
Ещё про UI. Используйте разные канвасы (Canvas). При изменении почти любого параметра у любого объекта, весь канвас перерисовывается полностью! Поэтому при построении сложного UI имеет смысл статичные элементы располагать на отдельном канвасе. И конечно не изменять UI в Update, а только по событиям, когда действительно что-то поменялось.
Оптимизируйте прокручивающиеся списки. Родной ScrollView плохо справляется с большим количеством элементов. Используйте data-driven списки, например UIS 🙄 Также есть смысл заменить Mask на RectMask2D в списках, потому что обычная маска работает через шейдер с обрезкой по альфе с помощью дополнительного материала (больше DC), а прямоугольная маска работает только с прямоугольниками, отсеивает пиксели и вершины за пределами области, не трогая шейдеры и не создавая лишние материалы, соответственно меньше DC и нагрузки на GPU.

И списком статьи и видео по оптимизации:

Emoji в Unity

mail@mopsicus.ru (Igor Lopatin) — Sat, 11 Sep 2021 11:35:00 +0300

Как добавить поддержку эмоджи в Unity?

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

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

Подготовка

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

Есть ещё OpenMoji — бесплатный пак со всеми символами, в том числе с разными начертаниями: контурные, цветные, чёрно-белые.

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

Также понадобится программа — TexturePacker и расширение для Unity — TexturePacker Importer. С помощью этого набора подготовим все необходимые файлы для использования в редакторе Unity.

У программы много настроек: различные типы текстур, параметры оптимизации, варианты упаковки и прочее. В документации про всё это написано.

Дальше алгоритм такой:

Загружаем эмоджи в программу
Выставляем необходимые настройки: формат текстуры, размер атласа и т.п.
Экспортируем в формат Unity® - Texture2D sprite sheet – кнопка Publish sprite sheet.
После этого меняем формат на JSON (Array) и делаем экспорт еще раз.
Получили три файла: ХХХ.png, ХХХ.json и ХХХ.tpsheet.

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

Импорт в Unity

Теперь нужно из полученных файлов сделать TMP Sprite Asset — файл для TMP по которому он будет ориентироваться: какой файл показывать и с какими отступами.

Перетаскиваете полученные файлы в редактор и запускаете Window → TextMeshPro → Sprite Importer.

Выбираете в качестве источника данных ваш JSON файл и спрайт с эмоджи. Далее жмёте Create, Save по очереди и получаете TMP Sprite Asset.

Вот таких файлов может быть много. Вы разбиваете весь ваш пак с эмоджи на небольшие атласы 1024×1024 или 2048×2048, импортируете, создаёте спрайт ассеты для TMP.

Использование

Финальный этап. Как использовать полученные файлы и показывать эмоджи?

Если юникод эмоджи простой и не состоит из модификаторов (имя файла без дефиса), то всё будет работать даже если вы вставите эмоджи в инспекторе в поле ввода TMP. Эмоджи с модификаторами так использовать не получится, можете сами проверить. Поэтому придётся использовать скрипт который подставляет корректный спрайт.

Если вы не хотите каждый раз у текстового компонента TMP выставлять спрайт ассет, то можно в настройках указать какой файл брать по умолчанию. В проекте найти файл TMP Settings или отрыть через Project settings → TextMesh Pro → Settings и настроить блок Default Sprite Asset.

Тут указано, что в моём проекте есть папка Resources/Emojis в которой хранятся все сгенерированные выше спрайт ассеты и атласы, а также выбран какой ассет использовать по умолчанию.

К этому ассету в качестве «резервных» (fallback) подключены все остальные. Таким образом, если в «основном» ассете не будет нужного эмоджи, будет подгружен один из резервных и эмоджи отобразится в компоненте.

EmojiHelper

Для использования хелпера в коде, можно вызвать метод CheckAndParseEmoji у вашего TMP компонента или статический метод ParseEmojiSequence у хелпера:

/// Можно применять сразу к TMP компоненту
MyTMPText.CheckAndParseEmoji("string with emoji");

/// Или распарсить и использовать позднее в другом месте
var tmpString = EmojiHelper.ParseEmojiSequence("string with emoji");

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

EmojiHelper доступен на Github

Вроде всё. Теперь ваши приложения и игры на Unity могут быть более привлекательными 😊

Градиентный текст в Unity

mail@mopsicus.ru (Igor Lopatin) — Tue, 12 May 2020 15:48:00 +0300

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

Выглядит это так:

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

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

Исходник доступен на Github

TabsView для Unity

mail@mopsicus.ru (Igor Lopatin) — Wed, 19 Feb 2020 13:57:00 +0300

Раздел «Велосипедостроение» 😅

Когда-то давно понадобилось сделать в UI горизонтальную прокрутку табами в одном прототипе. В iOS есть такой стандартный элемент. В Android по-моему тоже. Для Unity как известно стандартные UI компоненты довольно скудны. Поэтому каждый придумывает себе, по мере надобности. Вот и получилось когда-то такое, супер простое решение.

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

Что умеет:

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

Даже видео осталось:

Для применения в проде конечно не подходит, но для изучения — вполне.

Все исходники доступны на Github.