суббота, 29 июня 2019 г.

FungusLua. LuaScript

Компонент LuaScript обеспечивает простой способ запуска сценариев Lua вашей сцене. Вы можете создать объект LuaScript через (Tools > Fungus > Create > LuaScript).

LuaScript

Компонент ExecuteHandler

Когда вы создадите объект LuaScript, вы увидите, что он содержит компонент с именем «ExecuteHandler». Этот компонент позволяет указать параметры, когда должен выполняться скрипт Lua. По умолчанию он запускает сценарий Lua при запуске сцены, но вы можете изменить на выполнение после задержки, при каждом обновлении, при срабатывании триггера и т. д.

Если вы хотите выполнить LuaScript из пользовательского сценария C#, установите для параметра «On Event» значение «Nothing» и вместо этого вызовите метод LuaScript.OnExecute () напрямую. Вы также можете вызвать метод OnExecute () из события пользовательского интерфейса, например, событие пользовательского интерфейса кнопки «On Click».

Lua скрипт и файлы

Вы можете ввести код Lua, который хотите выполнить, прямо в текстовое поле «Lua Script». Вы также можете поместить код Lua в текстовый файл в своем проекте и использовать свойство Lua File для его выполнения.

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

Lua модули и require()

Система модулей Lua позволяет создавать повторно используемые пакеты кода Lua и включать их в ваши сценарии Lua. Этот урок объясняет, как писать модули Lua. Файлы модулей в FungusLua нужно поместить в специальную структуру папок, чтобы функция Lua require () могла их найти.

Чтобы использовать модуль Lua:

Создайте папку Resources / Lua в своем проекте. Капитализация здесь важна. Папка может быть создана внутри существующей папки в вашем проекте.
Создайте файл mymodule.txt в папке Resources / Lua и добавьте в него свой скрипт Lua. (Переименуйте mymodule.txt в любое, что вы хотите).
Теперь вы можете использовать функцию Lua require для загрузки модуля для использования в любом скрипте Lua, например


local mymodule = require("mymodule")

-- Call a function in the module

mymodule.myfunction()

Сообщения об ошибках

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

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

Все ошибки скрипта Lua генерируют сообщение об ошибке в журнале Unity, отображаемое красным.

Например, если вы попытаетесь запустить этот неверный код в объекте LuaScript:

not valid lua

Это будет генерировать сообщение об ошибке в журнале, как это

LuaScript.LuaScript:(1,0-3): unexpected symbol near 'not'
1: not valid lua

Первая часть 'LuaScript.LuaScript' дает вам информацию о том, откуда запускается скрипт Lua.
Следующая часть в скобках «(1,0-3)» сообщает номер строки и диапазон символов, в которых находится ошибка.
Последняя часть строки дает вам описание типа ошибки.
Следующая строка содержит список исходного кода Lua. Используйте указанную выше информацию о белье, чтобы найти строку, вызывающую проблему.

Одна из наиболее распространенных ошибок - попытка доступа к переменной, которая не существует. В этом примере сообщения об ошибке мы пытались получить доступ к полю 'name' в переменной v, которая еще не была определена.

LuaScript.LuaScript: (1,7-9): попытка индексировать нулевое значение

1: печать (v.name)

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

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

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

Настройка LuaEnvironment

По умолчанию компонент LuaScript будет использовать первый LuaEnvironment, который он найдет в сцене для выполнения, или создаст его, если его не будет. Если вы хотите использовать определенное LuaEnvironment, установите его в свойстве Lua Environment. Это хороший способ сохранить изолированные друг от друга наборы сценариев Lua друг от друга.

Опция RunAsCoroutine

Эта опция запускает скрипт Lua как сопрограмму Lua, которая полезна для написания асинхронного кода с помощью функции coroutine.yield () в Lua. Если вам не нужно выполнять свой Lua-скрипт асинхронно, отмена выбора этой опции позволит избежать накладных расходов при запуске в качестве сопрограммы. Рекомендуется только для опытных пользователей!

пятница, 28 июня 2019 г.

FungusLua. LuaBindings

Компонент LuaBindings позволяет отображать игровые объекты и компоненты в ваших сценах на переменные Lua, которые вы затем можете использовать в скриптах Lua. Вы можете связать с любым компонентом, включая стандартные компоненты Unity, компоненты из Unity Asset Store и ваши собственные пользовательские сценарии.

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

LuaBinding

Добавление LuaBindings

Чтобы настроить LuaBindings в вашей сцене:

Создать объект LuaBindings (Tools > Fungus > Create > LuaBindings)
Перетащите объект Unity, к которому вы хотите получить доступ, в поле «Object» в списке «Object Bindings».
Поле Key заполняется автоматически на основе имени объекта. Это будет имя переменной, которую вы используете для доступа к связанному объекту из скрипта Lua. Вы можете изменить этот ключ на любую строку, которую вы предпочитаете.
Если связанный объект является GameObject, вы можете дополнительно выбрать компонент внутри него для привязки.

Использование глобальной таблицы

Привязки, указанные в компоненте LuaBindings, автоматически регистрируются как глобальные переменные во всех LuaEnvironments сцены при запуске.

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

Например, если ваша привязка называется «camera» и вы установили имя таблицы как «myobjects», вы получите доступ к объекту камеры, например:


myobjects.camera

Обратите внимание, что по умолчанию компонент LuaBindings регистрирует свои привязки со всеми LuaEnvironments в сцене. Если вы не хотите использовать это поведение, отмените выбор параметра «All Environments» и выберите конкретную среду Lua, которую вы хотите использовать.

Поиск информации об участнике

Раскрывающийся список Member Info позволяет быстро искать свойства и методы для любого связанного объекта. Когда вы выбираете Member, его описание отображается вместе со скриптом Lua, необходимым для доступа к нему. При связывании со стандартными объектами Unity вы также можете проверить документы API, чтобы узнать больше о поддерживаемых методах и свойствах.

Опция Register Types

Чтобы получить доступ к типу C# из Lua, этот тип должен быть зарегистрирован в MoonSharp. Если выбран параметр Register Types, LuaBindings автоматически зарегистрирует типы связанных объектов и все открытые свойства и методы, которые использует этот тип. связанных объектов и все открытые свойства и методы, используемые этим типом.

FungusLua. LuaEnvironment

Компонент LuaEnvironment управляет всеми переменными, функциями, выполнением кода и т. д., для одного контекста Lua и предоставляет удобные функции для загрузки и запуска сценариев Lua. Для запуска кода Lua в сцене должен быть хотя бы один компонент LuaEnvironment.

Вы можете создать его через (Tools > Fungus > Create > LuaEnvironment). Обычно вам не нужно явно создавать LuaEnvironment, потому что FungusLua создаст его автоматически, когда его нет в сцене при запуске.

LuaEnvironment

Несколько Сред

Вы можете использовать несколько LuaEnvironments в своей сцене для «песочницы» переменных, функций и выполнения кода независимых наборов сценариев Lua. Если вы сделаете это, обязательно укажите соответствующую LuaEnvironment при использовании компонентов LuaScript, команд ExecuteLua и т. Д., Иначе они просто будут использовать первый, который они найдут в сцене.

VS Code Debugger

VS Code - это бесплатная среда разработки с открытым исходным кодом от Microsoft, которую вы можете использовать для написания кода проектов Unity. FungusLua автоматически запускает сервер отладки VS Code в режиме воспроизведения в редакторе Unity. Обратитесь к Документации MoonSharp, чтобы узнать, как настроить VS Code для отладки сценариев Lua. Обратите внимание, что игра должна быть запущена в редакторе Unity, прежде чем вы сможете подключить к ней отладчик VS Code.

Опция «Remote Debugger» активирует встроенный инструмент удаленного отладчика MoonSharp. Приложение остановит выполнение в первой строке кода Lua и откроет окно отладчика MoonSharp в вашем браузере. См. Документацию MoonSharp для получения дополнительной информации об использовании этого отладчика.

LuaUtils

Когда вы создаете объект LuaEnvironment с помощью (Tools > Fungus > Create > LuaEnvironment), созданный игровой объект имеет еще один компонент, называемый LuaUtils, который добавляет много полезных функций в базовую настройку LuaEnvironment. Смотрите раздел Lua Utils для получения дополнительной информации.

FungusLua. Создать Меню

Самый простой способ добавить сценарии Lua в вашу сцену - через меню Tools > Fungus > Create. Это позволяет быстро создать один из префабов Lua, который поставляется с FungusLua. Префабы FungusLua начинаются с Lua.

Вы также можете получить доступ к этим префабам из Fungus / Thirdparty / FungusLua / Resources / Prefabs.

% Fungus Создать Меню

Lua Prefab

Этот префаб обеспечивает полную настройку Lua, включая компоненты LuaEnvironment, LuaUtils, LuaBindings и LuaScript в одном игровом объекте.

Это идеально, если вы хотите быстро настроить один скрипт с несколькими привязками. Если вы изучаете FungusLua, используйте объект Lua, пока не освоитесь с работой всех этих компонентов.

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

Файл Lua

Эта опция создает файл Lua в выбранной вами папке. В Unity файлы Lua используют расширение .txt, поэтому они правильно работают со свойствами TextAsset и могут быть открыты в редакторе кода.

Когда вы создаете файл Lua, добавьте в него свой скрипт Lua в текстовом редакторе, а затем выберите файл в свойстве файла Lua компонента LuaScript или команду Execute Lua(Выполнить Lua), чтобы выполнить его. Вы также можете использовать систему модулей Lua и функцию require () для включения кода Lua из других файлов.

Префаб Lua Environment

Этот префаб предоставляет компонент LuaEnvironment для выполнения сценария Lua и компонент LuaUtils, который предоставляет полезные утилиты для работы с Lua, Unity и Fungus.

FungusLua автоматически создаст LuaEnvironment по умолчанию, если ни один не существует при запуске сцены, поэтому вам действительно нужно создать Lua Environment в вашей сцене только тогда, когда вы хотите настроить параметры среды по умолчанию (например, добавить файл таблицы строк или зарегистрировать дополнительные типы c#) ,

Префаб Lua Bindings

Этот префаб содержит компонент LuaBindings, который можно использовать для привязки объектов в вашей сцене / проекте к переменным Lua, чтобы к ним можно было получить доступ из сценария Lua. Вы можете иметь несколько привязок Lua в сцене или дополнительно загружать в сцену, которая содержит привязки Lua для объектов в этой сцене. При запуске все загруженные привязки Lua регистрируют свои привязки с каждой средой Lua в сцене (если не включена опция All Environments).

Если вы хотите создать префаб с использованием привязок Lua, все связанные объекты должны быть дочерними по отношению к префабу Lua Bindings в Иерархии, чтобы Unity могла правильно поддерживать ссылки на объекты. Это ограничение Unity.

Префаб Lua Script

Этот префаб содержит компонент Lua Script, который вы можете использовать для запуска сценария Lua, либо набранный в окне Инспектора, либо загруженный через текстовый файл. Он также содержит компонент Execute Handler, который поддерживает выполнение сценария Lua при возникновении события Unity (например, запуск, обновление, запуск по триггеру и т. д.)

Префаб Lua Store

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

FungusLua. О Fungus Lua

FungusLua - это простой способ встроить сценарии Lua в ваш проект Unity. Lua - это простой в освоении язык сценариев, так что это отличный способ дать художникам, писателям и дизайнерам возможность использовать больше возможностей Unity.

По своей сути FungusLua позволяет вам контролировать любой объект Unity из скрипта Lua. Он имеет полезные утилиты для использования Блок-Схем и диалогов Fungus, сохранения переменных между загрузками сцены, локализацией и работы с инструментами тестирования Unity.

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

FungusLua входит в состав ассетов Fungus, доступных в Unity Asset Store.

Совместимость Платформы

FungusLua должен работать на большинстве платформ, поддерживаемых Unity. Здесь перечислены все известные проблемы совместимости платформы, пожалуйста, сообщите нам, если вы найдете больше.

Windows Store (.NET scripting backend): Fungus и FungusLua компилируются нормально, но выдают ошибки времени выполнения при выполнении сценариев Lua. Scripting backend IL2CPP компилируется и работает нормально.

Учебное Видео

В этом видео показано, как использовать многие функции, доступные в FungusLua. Это скорее демонстрация, чем пошаговое руководство, но, надеюсь, между этим видео, документами и форумами у вас будет достаточно, чтобы все это понять :)

FungusLua без Fungus

FungusLua может быть легко использован сам по себе, если вам не нужны остальные функции Fungus.

В окне проекта переместите папку Fungus / Thirdparty / FungusLua в корень проекта.
Удалите папки Fungus и FungusExamples.
Добавьте FUNGUSLUA_STANDALONE в Scripting Define Symbols Edit > Project Settings > Player.

В меню Tools > Fungus теперь отображаются только параметры для создания объектов FungusLua. Очевидно, вы больше не сможете использовать такие функции Fungus, как say (), menu () и т.д., но вы все равно можете использовать LuaEnvironment, LuaBindings, LuaScript для добавления сценариев Lua в свою игру.

О Lua

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

О MoonSharp

MoonSharp - это реализация скриптового языка Lua с открытым исходным кодом, полностью написанная на C#.

FungusLua - это, по сути, набор компонентов-оболочек, созданных поверх MoonSharp, которые упрощают использование сценариев Lua непосредственно в редакторе Unity. MoonSharp действительно выполняет всю тяжелую работу и является совершенно потрясающим проектом :)

Уроки MoonSharp и форум MoonSharp - это отличные ресурсы для изучения работы MoonSharp, особенно для более продвинутого использования.

Руководство по Fungus. Часто Задаваемые Вопросы

Что такое Fungus ?

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

Кто делает Fungus?

Fungus разработан небольшой независимой игровой компанией Snozbot. Крис Греган является основным разработчиком Fungus.

Где мне взять Fungus?

Fungus доступен в Unity Asset Store и в разделе выпусков репозитория Fungus github.

Действительно ли Fungus свободен для использования?

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

Могу ли я продавать приложения, которые я делаю с помощью Fungus?

Да. Мы не берем плату за лицензию.

Какие платформы поддерживает Fungus?

Fungus работает на любой платформе, поддерживаемой игровым движком Unity. Смотрите здесь список поддерживаемых платформ.

Нужно ли быть программистом, чтобы использовать Fungus ?

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

Полезен ли Fungus программистам?

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

Где я могу узнать больше о Fungus?

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

Я сделал что-то классное в Fungus. Хотите увидеть?

Вероятнее всего! Пожалуйста, напишите gofungus и / или опубликуйте статью в разделе анонсов(Announcements) нашего форума.

Как я могу загрузить свою игру Fungus, чтобы ее могли увидеть другие?

После создания сборки вы можете воспользоваться услугой хостинга, такой как itch.io, gamejolt.com или newgrounds.com.

Как я могу сообщить об ошибке или предложить новые функции для Fungus?

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

Как долго мне придется ждать исправления ошибки?

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

Могу ли я получить в свои руки бета-версии Fungus?

Самая последняя версия всегда доступна в нашем репозитории github.

Как я могу внести свой вклад в Fungus?

Есть много способов помочь сообществу Fungus расти!

Ответить на вопросы и опубликовать советы на форуме
Внесите код либо через запрос Github, либо отправьте фрагменты кода на форумах.
Улучшите документацию, отредактировав папку Docs на github и отправив запрос на извлечение.
Сообщите нам на форуме, если вы сделали игру с Fungus, чтобы мы могли добавить ее на сайт.
Если вы напишите статью, пост в блоге, подкаст и т. д. о Fungus, отправьте ее, и мы добавим ее в раздел «Учебники сообщества».

Планируете ли вы интегрировать Fungus в другие игровые движки?

Не сейчас. Мы поддерживаем Unity в обозримом будущем.

четверг, 27 июня 2019 г.

Руководство по Fungus. Глоссарий

A

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

Assets: файлы на компьютере / устройстве, которые используются в игре. Файлы Assets включают в себя аудиоклипы, видеоклипы, 2D-изображения, 3D-модели и текстовые файлы, содержащие код компьютерной программы.

Audio tag: один из тегов, специально позволяющих управлять аудио из Story Text команды Say.

Существует четыре тега, связанных со звуком:

{audio=AudioObjectName} Воспроизвести аудио один раз
{audioloop=AudioObjectName} Зацикленное воспроизведение аудио
{audiopause=AudioObjectName} Пауза аудио
{audiostop=AudioObjectName} Остановить аудио

Для получения дополнительной информации см.: Audio Tags recipe

Audiosource: Специальный компонент объектов Unity, который может ссылаться на определенный файл аудиоклипа и управлять его воспроизведением / приостановкой / 3d-эффектами и т. д.

B

Block: Fungus Блок это последовательность Команд, которые были созданы внутри Блок-Схемы Fungus.

Block connection: Когда Команды в одном Блоке вызывают выполнение команд в другом Блоке.

Boolean variable: Переменная True/False.

Branching block: Блок, который не является Event Block, и вызывает выполнение 2 или более других Блоков.

Примечание: Branching Blocks отображаются в виде оранжевого шестиугольника в окне Блок-Схемы.

Branching narrative: Когда выбор пользователя (например, с помощью Menu Command for example) изменит то, какие Narrative Commands выполняются и отображаются для пользователя.

Build platform: целевое устройство, для которого будет создано игровое приложение Unity.

Build settings: настройки сборки включают целевую платформу, разрешение экрана, устройства ввода, сцены, которые необходимо включить, и т. д.

C

Csharp (C#): язык программирования, разработанный Microsoft, похожий на Java. C# - один из языков программирования, который можно использовать для написания скриптов для управления играми Unity.

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

Clickable Sprite: 2D-изображение на экране, в котором был код для выполнения каких-либо действий при щелчке мышью или при выборе трекпадом.

Coding / Scripting: Написание строк компьютерного кода для управления выполнением компьютерной программы, такой как игра Unity (в отличие от использования визуального языка, такого как Fungus Блок-Схемы).

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

Command category: Fungus команды сгруппированы в зависимости от того, к какому действию они будут приводить.

Command property panel: если Блок выбран на Блок-Схеме Fungus в верхней части окна Инспектора будут отображаться свойства и список команд для этого блока. Когда выбрана одна из команд, ее свойства отображаются в нижней половине окна Инспектора.

Condition: условия - это тесты, которые являются "TRUE" или "FALSE" в определенный момент времени. Различные команды могут быть определены для выполнения в зависимости от значения проверки условия в Fungus Блоке.

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

Custom strings: Помимо автоматически сгенерированных строк для каждого Say, Menu, Command и т. д., Вы также можете добавить свои собственные строки в файл локализации, используя любой желаемый идентификатор строки. Чтобы использовать эти пользовательские строки, вы используете подстановку переменных.
Например, если у вас есть пользовательская строка с именем «PlayerName», вы можете поместить {$PlayerName} в любой текст Say, чтобы заменить правильное локализованное значение из файла локализации.

D

Draggable Sprite: 2D-изображение на экране, в котором был код для выполнения каких-либо действий при нажатии и перетаскивании мышью или трекпадом.

DragTarget Sprite: 2D-изображение, определенное для выполнения некоторых действий, если перетаскиваемый спрайт перетаскивается и отпускается поверх него.

E

Editor: приложение, позволяющее редактировать игровые ресурсы. Unity Editor имеет несколько окон для просмотра / редактирования свойств файлов, содержимого сцены, диалоговых окон пользовательского интерфейса, настроек камеры и т. д.

Event Handler: Блок Fungus Block или «метод», кодирования в Unity, который будет выполняться при наступлении определенного «события». Например, когда нажата клавиша «ПРОБЕЛ», игра должна реагировать на то, что пользователь выполнил заклинание, выстрелил из пистолета или что-то еще.

Event block: Любой Блок выполнение которого инициируется Событие(Event), таким как Game Started или Key Preses.

Note: Event Blocks отображаются в виде закругленных синих прямоугольников в окне Блок-Схемы.

Excel: прикладная программа для работы с электронными таблицами от Microsoft, часть пакета MS Office.

см. веб-сайт Microsoft: приложение Microsoft Excel

Execution: запуск команд или операторов в компьютерном скрипте / программе. Заставить компьютер сделать что-нибудь.

F

Float variable: Переменная, которая хранит десятичные числа, такие как 5.5, -0.11 и т. д.

Flowchart: Блок-Схема Fungus Flowchart содержит набор Блоков, каждый из которых содержит команды, которые должны быть выполнены.

Flow control: Общий термин, обозначающий, как компьютер решает, что делать дальше. Таким образом, он решает, какой оператор Команды Fungus или код Unity выполнить следующим. Типичные команды потока включают выбор решений, таких как циклы или условия IF и т. д.

Flowchart item id: Уникальный номер, который создается для каждого Блока Блок-Схемы. Этот идентификатор используется для сериализации (сохранения и загрузки) и обычно не виден разработчику..

Flowchart Localization id: специальное уникальное имя, используемое для привязки данных локализации языка каждого игрового проекта Fungus.

Flowchart Message: Сообщение - это, по сути, фрагмент текста, но тот, который играет роль «триггерного события», запускает выполнение Блоков

Сообщения могут быть отправлены (с помощью команды Flow | Send Message) либо на текущую Блок-Схему, либо на ВСЕ Блок-Схемы. Одно из событий, которое можно определить для начала выполнения Блока, - это если конкретное сообщение было получено Блок-Схемой.

Flowchart Window: специальное окно, доступное в Editor Unity для редактирования и работы с Блок-Схемами грибов и их Блоками.

I

Integer variable: Переменная, которая хранит целые числа, такие как 100, 2, 0, -2 и т. д.

L

Landscape orientation: Ориентация изображения или экрана компьютера, ширина которого превышает высоту.

Language Column: при первом экспорте файла локализации .csv (Comma-Separated-Variable) он имеет 3 столбца (Key, Description, Standard). Если вы хотите добавить новый язык в файл, вы добавляете новый столбец для этого языка. Вы можете использовать любое имя столбца, которое вам нравится, хотя обычно используется двухбуквенный код языка (FR, ES, DE и т. д.).

Команда Set Language cсодержит название столбца для языка, который вы хотите использовать в Fungus.

Libre Office: бесплатная альтернатива Microsoft Office с открытым исходным кодом.

Узнайте больше и загрузите с: LibreOffice.org

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

Logging: Команда Scripting | Debug Log позволяет записывать ('logging') сообщения в окно консоли во время работы сцены. Журналы обеспечивают запись того, что произошло во время запуска игры, полезно для проверки того, что произошло, было тем, что было задумано, или для отладки (поиска, где находятся ошибки).

M

Mecanim Animation: файл Unity, представляющий анимационный клип или позу. Аниматоры управляют изменениями или микшированием между одним анимационным клипом и другим.

Mecanim Animator: контроллер диаграммы состояний Unity, который управляет анимированными объектами gameObjects - решая, когда и как быстро объекты должны «смешаться» в другое состояние или анимацию.

Menu Dialog: элементы пользовательского интерфейса (фон / линии / текст), которые определяют визуальный стиль представления текста команд меню пользователю.

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

O

Order in layer: если несколько объектов были назначены одному и тому же Unity Sorting Layer, то числовое значение свойства Order в Layer определяет их визуальный порядок сортировки (что отображается перед чем).

P

Parallax Sprite: использование 2D-спрайтов, движущихся с разными скоростями, для создания впечатления о 3D-движении (когда спрайты для объектов, которые должны находиться дальше от пользователя, движутся медленнее, чем объекты, расположенные ближе к игровому объекту.

Platform build: Относится к устройству и типу приложения, которое будет создавать редактор Unity. Примерами являются автономные приложения для Windows, Mac OS, телефона iOS, телефона Android, X-BOX и т. д.

Portrait: Команда Fungus Portrait используется для отображения в игре одного из портретных изображений персонажей на Stage. Можно выбрать конкретное изображение, и оно может быть сделано для перемещения вкл / выкл сцены.

Portrait orientation: ориентация изображения или экрана компьютера, где высота больше ширины.

Procedural Sound: метод создания звуков с использованием компьютерных алгоритмов.

Private / Public variables: Закрытая переменная как переменная, к которой могут обращаться только команды Cmmands в блоках этой Блок-Схемы. Публичная переменная - это переменная, к которой могут обращаться команды в Блоках других Блок-Схем, а также в своей собственной.

S

Save profile: Save Profile в основном представляет собой строку, к которой добавляется ключ, используемый для сохранения и загрузки переменных в PlayerPrefs. Это позволяет создавать отдельные профили сохранения с разными именами. Например, данные сохранения игрока 1 могут использовать Save Profile 'Chris', в то время как данные игрока 2 будут использовать Save Profile 'Matt', и их данные можно сохранять / загружать независимо.

Типичный рабочий процесс будет:

Выберите подходящее значение для Save Profile (например, "player1")
Установите Save Profile.
Сохранить Переменную(Переменные).

Say Dialog: Элементы Пользовательского Интерфейса(UI) (фон / линии / текст), которые определяют визуальный стиль представления Story Text из комад Say.

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

Scenes: Сцены Unity подобны главам в книге, или «экранам» в игре, или «уровням» в игре. Они позволяют разбить логику компьютерной игры на компоненты. «GameObjects» в сцене определяет, какие программные компоненты будут созданы при запуске Scene (другие могут быть созданы или удалены после запуска Scene).

Screen aspect ratio: Отношение ширины изображения или экрана к его высоте. Типичные соотношения включают 4: 3 и 16:10.
Screen resolution: Количество пикселей в ширину и высоту, поддерживаемых окном или устройством.

Sorting layer: 2D-объекты Unity назначаются на "Sorting Layer". Это позволяет назначать изображения / текст таким слоям, как фон, передний план, средний план, пользовательский интерфейс (поверх всего) и т. д.

Spine: Spine - сторонняя система 2D-анимации от EsotericSoftware.com.

Spine Animation: анимационный клип, основанный на 2D-системе Spine, которым можно управлять с помощью команд Fungus (после установки дополнительных пакетов Unity Spine и Fungus Spine).

Sprites: 2D-изображения, которые могут быть скрыты / раскрыты. Sprite можно перемещать с помощью команд Fungus или кода Unity. Спрайты также могут быть определены как «перетаскиваемые» пользовательскими указателями мыши или жестами касания мобильного устройства.

Stage: игровой объект Fungus на сцене, используемый для определения положения и начальных перемещений изображений Character Portrait, управляемых командами Portrait.

Standard block: Блок Fungus выполнение которого не инициируется каким-либо событием(event) (таким образом, это не Event Block), и который не вызывает выполнение 2 или более других Блоков (таким образом, это не Branching Block).

Note: Стандартные блоки отображаются в виде желтых прямоугольников в окне Блок-Схемы.

Standard Text: При экспорте файла локализации имеется поле Standard Text. Он заполняется текстом, который был введен в текстовые поля Say, Menu, и т. д. в редакторе Unity. При обычном использовании это поле находится в файле локализации для справки, поэтому локализаторы знают, какой текст необходимо перевести. Например, если проект составлен с использованием английского языка, то текст в Командах Say, Menu и т. д. Будет на английском языке, а в экспортированном файле локализации этот текст будет отображаться в полях Standard Text fields.

Обратите внимание, что если вы используете команду Set Language с пустой строкой языка, то значения в поле Standard Text будут использоваться при запуске Fungus.

Story Text Tags: Специальные инструкции, которые могут быть встроены в команды Story Text в Say Примерами являются теги, которые запускают / останавливают воспроизведение звука или отправляют сообщение.

String ID: Это автоматически генерируемый идентификационный код, который хранится в первом столбце файла локализации. Эти идентификаторы генерируются автоматически при экспорте строк с использованием объекта Localization.

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

String variable: Переменная, в которой хранятся текстовые символы, такие как имя игрока или цвет зелья, которое они несут.

T

Tag: Специальные символы, которые могут быть вставлены в команды Fungus Say для управления другими аспектами сцены, такими как воспроизведение звука, дрожание камеры или отправка сообщения, заставляющее запускать другие блоки.

U

Unity: Игровой движок и IDE (интерактивная среда разработки) - с программным редактором кода и средствами редактирования аудио / графики. Возможность создавать приложения для развертывания на Windows, Mac, Linus, iOS, Android, XBox и т. д.

Unity UI: Создание визуальных интерфейсов для компьютерных программ, развертываемых Unity.

Usfxr: Система для генерации звуковых эффектов из математических параметров.

Встроенный в Fungus и основанный на проекте с открытым исходным кодом по адресу: Usfxr на GitHub

V

Variable: Именованная ячейка памяти, из которой можно позднее извлечь значения.

Variable default value: значение «по умолчанию» относится к значению, автоматически присваиваемому переменной, если не указано конкретное значение. В разделе Variables в нижней части окна Блок-схемы, а также в определении имен и типов данных переменных, вы также можете установить здесь значения по умолчанию.

Variables Panel: в самом нижнем разделе окна Блок-Схемы можно определить переменные (например, Score, playerName, carryingGreenKey и т. д.) для использования в командах Fungus.

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

Variable substitution: Это относится к использованию тега в Story Text of команды Say, в результате чего содержимое переменной будет вставлено в эту часть текста для команды Say

{$VarName} Substitute variable

View, Move, Rotate, Scale & Rectangle tools: основные инструменты, предлагаемые в редакторе Unity для изменения основных свойств 2D и 3D объектов

View: Fungus gameObject, который помогает обеспечить хороший визуальный опыт независимо от соотношения сторон устройства и используется для перемещения камеры и управления с помощью Fungus Commands.

Voice over: файл аудиоклипа, содержащий записанный звук, соответствующий тексту, отображаемому на экране.

W

Webplayer: опция сборки в Unity, которая создает приложение, которое может воспроизводить веб-страницы, на которых установлен подключаемый модуль Unity Web Player. Необходимость использования плагина и опции веб-плеера заменяется средством сборки WebGL Unity.

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

понедельник, 24 июня 2019 г.

Руководство по Fungus. Стандартное Кодирование

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

Этот документ посвящен решениям, которые мы приняли для проекта Fungus. Для получения общих советов по кодированию в Unity попробуйте 50 советов и рекомендаций для Unity.

Макет кода

Это типичное расположение класса в Fungus:

using UnityEngine;
namespace Fungus
{
    /// <summary>
    /// Description of the component.
    /// </summary>
    public class MyComponent : MonoBehaviour
    {
        [Tooltip("Tooltip comment displayed in the editor.")]
        [SerializeField] protected float myProperty = 10f;
        protected virtual void MyMethod()
        {
            if (myProperty > 5f)
            {
                Debug.Log("A message");
            }
        }
        #region Public members
        /// <summary>
        /// Documentation comment for public property.
        /// </summary>
        public virtual float MyProperty { get; set; }
        /// <summary>
        /// Aspect ratio of the secondary view rectangle. e.g. a 2:1 aspect ratio = 2/1 = 2.0.
        /// </summary>
        public virtual void DoSomething()
        {
        }
        #endregion
    }
}

Что следует отметить:

Все использующиеся объявления размещаются в вверху файла скрипта.
Удалите все неиспользуемые объявления (можно легко определить их с помощью статического анализа кода - см. Ниже).
Код времени выполнения идет в пространстве имен Fungus.
Код редактора помещается в пространство имен Fungus.EditorUtils.
Все открытые классы, структуры, перечисления и члены класса должны быть задокументированы с использованием комментариев xml.
Вы можете задокументировать частных и защищенных членов, если хотите, но ВСЕ Публичные члены(Public members) должны иметь хотя бы краткий комментарий.
Описания параметров и возврата являются необязательными, добавьте их, если считаете, что параметры требуют нетривиального объяснения.
Сериализированные поля НИКОГДА не должны быть открытыми. Используйте свойство общедоступного метода доступа для доступа к полю, если требуется внешний доступ.
Все сериализованные поля должны иметь атрибут Tooltip. Это удваивается как код документации для поля.
Все методы должны быть объявлены виртуальными и использовать защищенные, а не частные. Это позволяет легко наследовать и расширять (за счет некоторой производительности).
Все общедоступные члены класса (включая общедоступные статические типы и типы делегатов) должны быть помещены в область 'Public members' для легкого доступа.
Скобки переходят на новую строку и используют пробелы исключительно вместо вкладок.

Лучшие Практики Кодирования

Это некоторые общие рекомендации при написании кода для Fungus. Если это идет вразрез с обычной рекомендуемой практикой кодирования (например, Assert), то это из-за проблемы в Unity, заключающейся в том, чтобы делать это «правильным образом»..

Используйте статический анализатор кода в MonoDevelop. http://tinyurl.com/h7xqpwg
Используйте стиль комментария c# xml. https://msdn.microsoft.com/en-us/library/b2s063f7.aspx
Объявите все публичные перечисления в области имен, а не внутри класса. (Согласованность, облегчение разделения перечислений между классами).
Используйте var вместо объявления типов переменных, когда это возможно. (Более читабельно).
Используйте вместо foreach, когда это возможно. (Избегает выделения проблем с итераторами и GC).
Используйте string.Format или StringBuilder вместо объединения строк. (Избегает распределения и проблем с GC).
Не используйте LINQ. (Избегает распределения и проблем GC.)
Не используйте Assert. (Мы поддерживаем до Unity 5.0, до появления Assert).
Используйте Mathf.Approximately при сравнении переменных с плавающей точкой с константами.
Обрабатывайте предупреждения компилятора как ошибки. Должны быть нулевые предупреждения при сборке или во время выполнения при нормальной работе.
Добавить глобальные константы в FungusConstants.cs

Обратная совместимость

Мы стремимся поддерживать обратную совместимость с каждым новым выпуском (в разумных пределах).

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

Содействие

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

Fork и clone Fungus repo.
Убедитесь, что тесты пройдены локально (см. Readme проекта для инструкций).
Сделай свое изменение. Добавьте тесты для вашего изменения. Сделайте тесты проходить локально.
Нажмите на fork и отправьте запрос на извлечение.

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

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

воскресенье, 23 июня 2019 г.

Руководство по Fungus. Советы по Кодированию

Это коллекция быстрых советов по написанию сценариев Fungus из кода.

Выполнение Блоков

Сначала вам нужно получить ссылку на ваш объект Блок-Схемы. Добавьте общедоступное свойство потоковой диаграммы к вашему компоненту и установите для него ссылку на вашу Блок-Схему в окне Инспектор.


using UnityEngine;

using Fungus;

class MyComponent : public MonoBehaviour

{
    
    public Flowchart flowchart;

}

Чтобы выполнить именованный Блок в Блок-Схеме:

flowchart.ExecuteBlock ( "BlockName");

Чтобы начать выполнение с определенного индекса команды:

flowchart.ExecuteBlock ("BlockName", 3);

Чтобы узнать, есть ли у блок-схемы какие-либо исполняемые блоки:


flowchart.ExecuteBlock("BlockName");

{
    // Сделай что-нибудь
}

Сигналы Блока

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


using Fungus;
public MyComponent : MonoBehaviour
{
    void OnEnable() 
    {
        // Register as listener for Block events
        BlockSignals.OnBlockStart += OnBlockStart;
    }
    void OnDisable()
    {
        // Unregister as listener for Block events
        BlockSignals.OnBlockStart -= OnBlockStart;
    }
    void OnBlockStart(Block block)
    {
        Debug.Log("Block started " + block.BlockName);
    }

}

Сигналы Writer

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

using Fungus;
public MyComponent : MonoBehaviour
{

    void OnEnable() 
    {
        // Register as listener for Writer state change events
        WriterSignals.OnWriterState += OnWriterState;
    }
    void OnDisable()
    {
        // Unregister as listener for Writer state change events
        WriterSignals.OnWriterState -= OnWriterState;
    }
    void OnWriterState(Writer writer, WriterState writerState)
    {
        if (writerState == WriterState.Start)
        {
            Debug.Log("Writing started");
        }
    }
}

Руководство по Fungus. Сохранение и Загрузка

Вступление

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

Fungus Save System предоставляет простой способ сохранить и загрузить состояние выполнения Блок-Схем в вашей игре.
Из этого туториала Вы узнаете, как быстро добавить функцию сохранения в играх Fungus.
Система сохранения работает, сохраняя серию очков(Save Points) сохранения по ходу игры, чтобы создать Историю Сохранения(Save History).Базовый Save Menu UI позволяющий игроку Сохранять(Save), Загружать(Load), Перезагружать(Restart), Перематывать Назад(Rewind ) и Перематывать Вперед(Fast Forward) через Историю Сохранения(Save History).

Точка сохранения создается путем выполнения команды Save Point в Блок-Схеме. Когда точка сохранения загружается позже, выполнение возобновляется сразу после этой команды Save Point. Система сохранения наблюдает за восстановлением состояния переменных Блок-Схемы в каждой точке сохранения, и вы также можете получать уведомления, когда конкретная точка сохранения загружается через обработчик события Save Point Loaded.
Если вы используете старые команды для сохранения отдельных переменных (Set Save Profile, Save Variable, Load Variable), они все еще работают, но отдельно от новой системы сохранения.

Пример Сцены «Сохранить игру»

Чтобы увидеть, как работает система сохранения, откройте пример сцены FungusExamples/Savegame/SaveGame.unity
Нажмите Play в Unity и пролистайте рассказ. Меню Save Menu можно открыть в любое время, щелкнув значок маленькой шестерни в правом верхнем углу. Попробуйте сохранить, загрузить, перемотать, перемотать вперед и перезапустить в разных точках во время прохождения истории. Также попробуйте сохранить игру в середине истории и остановить игру. Нажмите Play еще раз и обратите внимание, что игра возобновляется с того места, где вы остановились.
The Save Menu также поддерживает режим автосохранения, при котором игра сохраняется на диск в каждой точке сохранения. Вы можете включить это, выбрав объект Save Menu и выбрав свойство Auto Save. Кнопки Save и Load отключены при использовании Auto Save.
Ниже приведены ключевые элементы, которые используются для реализации сохранения в этом примере сцены..

Save Menu UI

Объект Save Menu oможно увидеть в корне окна иерархии. Этот объект управляет меню пользовательского интерфейса, которое игрок использует для взаимодействия с системой сохранения. Save Menu - это одноэлементный объект, который сохраняется при загрузке сцены, поэтому вам нужно добавить его только один раз в первой сцене вашей игры.
Чтобы добавить Save Menu выберите Tools > Fungus > Create > Save Menu.

Создание Точек Сохранения

Точки Сохранения создаются путем выполнения команд Save Point в Блок-Схеме.
Чтобы увидеть это в примере сцены, убедитесь, что окно Блок-Схемы отображается (через Tools > Fungus > Flowchart Window), затем выберите объект Блок-Схемы в окне Иерархии и выберите каждый из Блоков в Блок-Схеме. Первая команда в каждом блоке - это команда Save Point (добавляется через Flow > Save Point).
Когда каждая команда Save Point command выполняется, она добавляет новую Save Point в Save History. При загрузке ранее сохраненной игры выполнение возобновляется сразу после команды Save Point которая создала эту Save Point.
В примере сцены выберите Блок ‘Start’ Block в окне Блок-Схемы и выберите команду Save Point в верхней части списка команд. Обратите внимание, что свойство Is Start Point property включено и это единственная команда Save Point в Блок-Схеме для которой включена эта опция. В сцене должна быть только одна Start Point на сцене.
Когда вы запускаете новую игру, Fungus ищет команду Save Point command с включенным свойством Is Start Point и выполняет ее. При загрузке ранее сохраненной игры, Fungus начинает выполнение с соответствующей команды Save Point и игнорирует start point.
Это означает, что если ваша игра поддерживает сохранение, то у вас всегда должна быть ровно одна команда Save Point со включенным свойством Is Start Point в каждой сцене.
Нотабене Обработчик событий Game Started будет запускаться как для новых, так и для загруженных игр, что, как правило, не то, что вам нужно, поэтому избегайте его использования в играх, которые поддерживают сохранение.

Обработка событий Save Point Loaded

Вам часто нужно проделать дополнительную работу, когда сохраненная игра загружается, чтобы убедиться, что сцена находится в правильном состоянии. Например. Возможно, камеру нужно переместить в соответствующее место или на определенную музыкальную дорожку, сыгранную в данный момент в игре. Простой способ сделать это - через обработчик события Save Point Loaded.
IВ примере сцены выберите Блок ‘Play Music 1’ в окне Блок-Схемы, и убедитесь, что в нем есть обработчик события Save Point Loaded. Этот Блок будет выполнен, когда загрузится любая из Save Points из Save Point Keys списка загрузок. В этом случае мы просто играем правильное музыкальное произведение для этой части игры, но вы можете выполнить любую настройку, необходимую здесь.
The Save Point Loaded event handler will also fire when a matching Save Point command executes (if the Fire Event property is enabled). This allows you to place all the scene setup commands into a single shared Block which will be called when a Save Point command is first reached or when loading a previously saved game at that Save Point.

Сохранение Переменных Блок-Схемы

Каждая Save Point может хранить состояние переменных Блок-Схемы в этот момент времени. Вы используете объект Save Data чтобы система сохранения знала, какие Блок-Схемы должны быть включены в нее. Обратите внимание, что в настоящее время сохраняются переменные типа Boolean, Integer, Float и String.
В примере сцены объект Save Data можно увидеть в корне окна Иерархии. Свойство Блок-Схем содержит список объектов Блок-Схемы, которые необходимо сохранить в этой сцене.
Чтобы добавить объект Save Data на сцену, выберите Tools > Fungus > Create > Save Data. Вы можете добавить в список столько Блок-Схем, сколько захотите, но убедитесь, что у каждого из них есть уникальное имя (например, Flowchart1, Flowchart2, и т. д.), Иначе загрузка не будет работать правильно.
Если вы заинтересованы в расширении системы сохранения для поддержки сохранения других типов данных (помимо переменных потоковой диаграммы), вы можете изменить или создать подкласс компонента SaveData для достижения этой цели.

Пользовательский Интерфейс Save Menu

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

Свойства Save Menu

Существует 4 основных свойства, которые вы можете настроить в Save Menu.

Save Data Key: строковый ключ, используемый для сохранения данных игры в Player Prefs. Если в одном проекте Unity определено несколько игр, используйте уникальный ключ для каждой из них.
Load On Start: Автоматически загружать ранее сохраненную игру при запуске.
Auto Save: Автоматическое сохранение игры на диск при каждом сохранении. Когда эта опция включена, кнопки Save и Load отключены.
Restart Deletes Save: удалить данные сохранения с диска, когда игрок перезапустит игру. Это полезно при тестировании вашей игры, чтобы убедиться, что вы начинаете с пустого состояния сохранения.

Нотабене Если ваша игра использует несколько сцен (например, с помощью команды Load Scene), обязательно добавьте всю сцену в список Scenes in Build list в Build Settings.

Кнопка Save

При нажатии кнопки Save текущая Save History сериализуется в текст JSON и записывается в постоянное хранилище с помощью класса PlayerPrefs.

Кнопка Load

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

Загрузите сцену, сохраненную в Save Point (даже если это текущая загруженная сцена).
Восстановить переменные Блок-Схемы в сохраненные значения
Вызвать Save Point Loaded и запустить выполнение Блок-Схемы после соответствующей команды Save Point.

Кнопки перемотки Назад и Вперед(Rewind Fast Forwar)

Кнопки Rewind иFast Forward позволяют перемещаться назад и вперед между Save Points в Save History.
Каждый ход просто загружает Save Point сохраненную в определенной точке в Save History. амо по себе это не меняет Save History и ничего не записывает в постоянное хранилище. Однако, если вы вернетесь к более ранней точке сохранения и начнете воспроизведение снова, в следующий раз, когда будет выполнена команда Save Point это приведет к тому, что все Save Points находящиеся дальше по времени, будут удалены навсегда.

Кнопка Restart

Кнопка Restart button очищает Save History и загружает начальную сцену. Начальная сцена - это сцена, которая была активной при первоначальной инициализации Save Menu.

Запуск Игры

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

Каждая сцена в вашей игре должна иметь ровно одну команду Save Point со включенным свойством Is Start Point. Если в вашей игре несколько сцен, убедитесь, что для каждой из них определена начальная Save Point и что это первая команда, выполненная на сцене.
Избегайте использования обработчика событий Game Started. Это будет работать правильно только при первом запуске игры, а не после загрузки сохраненной игры. После загрузки сохраненной игры вы хотите, чтобы выполнение началось с Save Point, а не с начала Блок-Схемы.
Используйте обработчик события Save Point Loaded когда вы хотите выполнить Блок, когда загружены определенные точки сохранения. Эти обработчики событий вызываются до возобновления выполнения с помощью команды Save Points так что это дает вам возможность выполнить настройку до возобновления игрового процесса.

Терминология

Save Point

Save Point - это снимок состояния игры в определенный момент времени. Каждая Save Point записывает текущую сцену, текущую точку выполнения Блок-Схемы (т.е. в команде Save Point)и текущие значения переменных Блок-Схемы. В настоящее время сохраняются только переменные типа Boolean, Integer, Float и String.

Команда Save Point

Команда Save Point используется в Блок-Схеме для создания Save Point в этой точке выполнения. Каждая отдельная команда Save Point должна иметь уникальный Save Point Key. Параметр Resume On Load позволяет возобновить выполнение с этой точки после загрузки Save Point.

Save Point Key

Save Point Key - это уникальный строковый идентификатор для одной Save Point. По умолчанию имя родительского Блока используется для Save Point Key, но при необходимости вы также можете использовать пользовательский Ключ(Key) (например, несколько команд Save Point в одном Блоке).
Нотабене Каждый ключ должен быть уникальным для каждой сцены, иначе загрузка не будет работать правильно!

Save History

Save History содержит список ранее записанных Save Points, сохраненных в хронологическом порядке. При выполнении команды Save Point создается новая Save Pointкоторая добавляется в Save History.
Чтобы визуализировать Save Historyво время выполнения, разверните объект Save Menu в окне Иерархии, выберите Save Menu > Panel > Debug View и включите игровой объект. Сводная информация о Save Points в Save History будет отображаться в текстовом окне.

Руководство по Fungus. Система Вариаций Текста

Система для выбора подраздела большей строки. Позволяет происходить простым изменениям в одном и том же Блоке текста вместо необходимости создавать несколько команд. Система изменения текста основана на Ink. Variable Text. Классы Fungus Writer и Menu в настоящее время используют эту систему, так как команды Say, Menu и Conversation могут использовать ее. Действия Fungus Lua, в результате которых Lua передает строки в Fungus Writer или Menu, тоже будут работать.

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

[] отметьте границы секции переменной
| разделить элементы переменной

Поведение по умолчанию - показывать один элемент за другим и удерживать последний элемент. Таким образом, [1|2|3] покажет 1 при первом разборе, 2 - второй и каждый последующий раз - 3.
Допускаются пустые секции, например [a||c],на втором показе будет 0 символов..
Поддерживает вложенные разделы, которые оцениваются, только если выбран их родительский элемент.
Это поведение можно изменить с помощью определенных символов в начале [], например [&a|b|c];

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

Пример

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


Приветствую и рад нашей встрече, незнакомец. Чем я могу вам помочь?

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

С возвращением, друг. Чем я могу вам помочь?

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

[Приветствую и рад нашей встрече, незнакомец|С возвращением, друг]. Чем я могу вам помочь?

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

Доброе утро.
Добрый день.
Как дела?
Ой ой.
Как вы?
Давай сделаем это.

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

Для более полного и подробного примера см. Пример сцены в FungusExamples\VariationText\TextVariation.unity

Будущая Работа

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

суббота, 29 июня 2019 г.