Solid Principles C # - Принцип единой ответственности

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

Что мы хотим построить?

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

Создайте прочную основу своих приложений, которая действительно может масштабироваться с вашими желаниями и желаниями. Чтобы добраться туда, мы начнем с S моей Unity - серии S.O.L.I.D.:

GitHub-Link: каждый принцип SOLID находится в отдельной ветке, не стесняйтесь клонировать и разветвлять :)

Теория принципа единственной ответственности

S означает принцип единой ответственности.

Что именно это означает?

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

Эта функция делает ровно одно. Примите аргумент, который выводится на консоль Unity. Ни больше ни меньше. Это идеальный фрагмент кода. Если вы хотите изменить функциональность, не трогайте эту функцию; напишите новый!

Единство и пример без принципа единой ответственности

Представьте, что у нас есть класс, который выполняет следующие действия каждый раз, когда нажимается клавиша «F» на клавиатуре:

1. Проверьте, не нажата ли кнопка клавиатуры
2. Перекрасить спрайт игрового объекта
3. Сохраните новый цвет в переменной
4. Распечатайте новый цвет в консоли

В Unity это будет:

• Внутри проекта Unity:
• с основной камерой
• с игровым объектом и прикрепленным скриптом «ChangeColorPropagateColor.cs»

Вот код «ChangeColorPropagateColor.cs»:

Как видите, этот скрипт выполняет 4 функции в Update ():

1. Проверяет ввод с клавиатуры
2. Делает случайный цвет и прикрепляет его к игровому объекту.
3. Сохраняет цвет в переменную
4. Выводит новую цветовую переменную на консоль Unity

Это не очень удобный или даже масштабируемый код. Что, если мы захотим перекрасить несколько объектов, если нажмем «F»? Что, если мы хотим распечатать несколько операторов или изменить кнопку, связанную с действием изменения цвета? Здесь мы могли бы переписать всю функцию или ввести глобальные переменные, и, если варианты использования станут более сложными, мы обязательно создадим спагетти-код.

Вместо этого мы должны рассмотреть два следующих правила:

1. Разделить вещи на части
2. Сделайте так, чтобы вещи использовались как общие, а не как конкретные

Так как же нам добиться разделения?

1. Проверка ввода - ›CheckInput.cs
2. Сделайте случайный цвет - ›ColorHandler.cs
3. Сохранение цвета - ›ColorChanger.cs
4. Распечатайте новый цвет - ›Logger.cs

Единство и пример принципа единой ответственности

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

ColorHandler.cs

Возвращает вызывающей стороне метода GenRandColor случайный цвет при каждом вызове.

Logger.cs

Принимая параметр объекта, мы можем передать все в эту функцию (потому что в C # все наследуется от корневого типа «объект», ключевого слова Polymorphism) и может быть выведено на консоль.

Вы можете вызвать Debug. Log-Statement каждый раз, когда вы хотите распечатать отчет, но в случае, если вы хотите, чтобы регистрировались только цвета. Вы можете создать новую функцию и называть ее «PrintColorToConsole» всякий раз, когда цвет должен быть распечатан; вы вызываете эту функцию.
Вы обязаны распечатать оператор. Поэтому, если что-то должно измениться, измените это в этом случае вместо множества отдельных операторов, называемых «PrintToConsole», которые распространяются по всем файлам кода.

CheckInput.cs

Этот скрипт будет проверять только то, была ли нажата свободная назначаемая клавиша InvokingKey (настраивается в редакторе Unity, см. Рисунок CheckInput - сценарий со свободной назначаемой клавишей »ниже). Если это так, то будет вызвано событие keyPressed, и каждый слушатель получит сообщение.

ColorChanger.cs

У этого скрипта одна обязанность: изменить цвет игрового объекта, к которому прикреплен этот скрипт. Поэтому он должен вызвать ColorHandler-Script, чтобы получить случайный цвет. Он также должен вызвать частную функцию ApplyColor, которая меняет спрайт игрового объекта на новый случайный цвет. Наконец, вызываем регистратор, чтобы распечатать новый цвет в консоли.

Соединение всего SOLID Script вместе

Это иерархия всей сцены:

• Основная камера (по умолчанию)
• ChangeColor A (CheckInput.cs, ColorChanger.cs)

Скрипты CheckInput.cs и ColorChanger.cs должны быть прикреплены к одному и тому же игровому объекту:

Присоедините новый EventListener к событию «KeyPressed ()», нажав на значок плюса ниже, перетащите игровой объект «ChangeColor A» со сцены в поле ссылки. Затем выберите в раскрывающемся списке функцию ColorChanger.ChangeColor в качестве прослушивателя события KeyPressed-Unity.

Вот спрайт для монеты

Благодаря модификатору static для ColorHandler-Class и Logger-Class мы можем вызывать их без создания экземпляров или присоединения к любому игровому объекту. Нам не нужны игровые объекты для их функциональности. Это просто базовые сценарии C #, не унаследованные от MonoBehaviour.

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

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

Вариации создаются легко и быстро

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

Единственное, что нужно изменить, - это вызывающий ключ для каждого элемента (демонстрируется на игровом объекте ChangeColor B):

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

Вывод

Итак, поехали. Знать, как писать код в соответствии с принципом единой ответственности в Unity. Обязательно задайте себе один вопрос:

Делает ли этот сценарий / класс / метод что-то одно и хорошо ли работает этот сценарий / класс / метод?

Если ответ да: ваш код в порядке!

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

Мой вывод о серии SOLID

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

Спасибо, что прочитали серию Принципов SOLID в Unity. Мне было очень весело создавать эти уроки, и, надеюсь, вам тоже понравилось! Эффект обучения достигается лучше всего, если вы увлекаетесь изученными темами! Пожалуйста, создайте свою собственную игру в Unity, руководствуясь этими твердыми принципами, и дайте мне знать об этом.

Разрабатывать игры с помощью Unity - значит знать, как работает C #.

Я прошел несколько курсов по C # для начинающих и продвинутых, не стесняйтесь взять образец в моей Академии Arnoldcode.com.

Увидимся в следующей серии.

GitHub-Link: каждый принцип SOLID находится в отдельной ветке, не стесняйтесь клонировать и разветвлять :)