Показаны сообщения с ярлыком Unity. Показать все сообщения
Показаны сообщения с ярлыком Unity. Показать все сообщения

четверг, 4 июля 2019 г.

Руководство HORROR FPS KIT. Менеджер Конфигурации

Это простой Serialization Manager, который используется для Сериализации и Десериализации основных настроек игры (управление, графика, настройки игры).
  • Все конфигурационные файлы хранятся внутри проекта или внутри экспортированной игры в папке Data.


  • Вы можете просматривать или редактировать настройки конфигурации в сцене ExampleSerialization


  • Также примеры сценариев для сериализации находятся в папке Scripts.


вторник, 2 июля 2019 г.

Руководство HORROR FPS KIT. Установка Сцены Игры

  1. Откройте новую пустую сцену.
  2. Перейдите в Tools -> HFPS KIT -> Setup -> Game и выберите (FirstPerson или Body)

  3. Проверьте, есть ли в вашей сцене объект PLAYER и GAMEMANAGER.


  4. Переместите PLAYER на пол.
  5. Мы рекомендуем запустить HFPS из главного меню и позволить ему создавать необходимые файлы.


Руководство HORROR FPS KIT. Установка Главного Меню

  1. Откройте новую пустую сцену.
  2. Перейдите в  Tools - > HFPS KIT -> Setup -> MainMenu

     

  3. Теперь проверьте, есть ли у вас объект MENUMANAGER в вашей сцене.


Руководство HORROR FPS KIT. Установка Проекта

Мы настоятельно рекомендуем импортировать ассеты в пустой проект!

1. Импортируйте ассет в пустой проект (все настройки проекта будут перезаписаны!)






2. Переместите папку Data в папку Assets вашего проекта или запустите игру.


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

Руководство HORROR FPS KIT. О HORROR FPS KIT


О HORROR FPS KIT

    HORROR FPS KIT является усовершенствованным и простым в использовании шаблоном игр ужаса(horror), со многими функциями, важными для создания Вашей собственного ужасника, включая функции геймплея, замеченные в играх ужаса AAA последнего десятилетия. Он содержит много готовых к использованию ассетов, просто перетащите их на сцену.

FungusLua. Unity Test Tools

Если вы используете Unity Test Tools, FungusLua - это мощный и быстрый способ создания интеграционных тестов с использованием сценариев Lua.

Пример

  1. Создайте новый тест на сцене.
  2. Добавьте объект Lua (Tools > Fungus > Create > Lua) в качестве дочернего объекта тестового объекта.
  3. В компоненте LuaScript используйте функцию check(), чтобы утверждать, какие условия вам нужны для теста. В конце вызовите pass().
Пример тестового скрипта:

-- Проверьте условие и выведите причину, если оно не удалось
check( myvar < 40, «моя переменная слишком большая»)
-- Просто проверьте состояние
check( myvar > 20 )
-- Тест успешно завершится
pass()
Если какая-либо из проверок не пройдена, то проверка сразу завершается неудачей.

Lua Функции 


-- Проверяет, выполняется ли условие
-- Lua имеет встроенную функцию assert, поэтому мы вызвали эту проверку, чтобы избежать конфликтов.
check(c, reason)
-- Пройдите интеграционный тест
pass()
-- провалить интеграционный тест
-- причина: необязательная строка, объясняющая, почему тест не пройден.
fail(reason)

FungusLua. String Table

Локализация Текста


Компонент LuaUtils обеспечивает поддержку простой локализации текста.
  1. Определите ваши языковые строки в файле JSON и сохраните его в папке ресурсов проекта.
  2. Добавьте компонент LuaEnvironment в вашу сцену - например, Tools > Fungus > Create > LuaEnvironment
  3. В компоненте LuaUtils установите свойство String Table для ссылки на ваш файл JSON.
  4. Используйте синтаксис {$VarName} для подстановки локализованной строки везде, где поддерживается подстановка строк. например в сценарии Lua:

say("{$hello_world}")

Вы можете использовать синтаксис {$VarName} везде, где поддерживается подстановка переменных. Это включает:
  • Команда Say
  • Команда Menu
  • Команда Set Text
  • Команда Write
  • Команда Conversation
  • Character object - имя персонажа
  • Команда Debug Log
  • Команда Load Variable - сохранить ключ
  • Команда Save Variable - сохранить ключ
  • Команда Delete Save Key

Вы также можете расширить систему подстановки Fungus с помощью собственных компонентов. Реализуйте интерфейс StringSubstituter.ISubstitutionHandler в подклассе Monobehavior, а затем верните измененную строку из SubstituteStrings().

Формат JSON

{
    "hello_world" : {
        "en" : "Hello world!",
        "fr" : "Bonjour le monde!",
        "de" : "Hallo Welt!"
    },
    "goodbye_world" : {
        "en" : "Goodbye world!",
        "fr" : "Au revoir monde!",
        "de" : "Auf Wiedersehen Welt!"
    }
}


Это пример формата JSON для таблицы строк. Чтобы использовать эту локализованную строку, вы должны использовать тег {$hello_world}.

Функции Lua


Эти функции Lua доступны для работы с таблицей строк.

-- Установить активный язык для таблицы строк
setlanguage(languagecode)
-- получить именованную строку из таблицы строк
getstring(key)
-- Подставляет переменные и строки локализации в кусок текста
--[[ например, v = 10, «Значение вспомогательного элемента равно [$ v]» => «Значение дополнительного элемента равно 10» ]]
sub(text)

FungusLua. LuaStore

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

Компонент Lua Store


Компонент Lua Store позволяет легко обойти это при использовании сценариев Lua. Общая глобальная таблица с именем «store» связывается в каждой Lua Environment при запуске сцены. Эта глобальная таблица сохраняется между загрузками сцены, что означает, что вы можете установить переменную хранилища в одной сцене, загрузить другую сцену, а затем получить доступ к той же переменной хранилища, и она все равно сохранит значение, которое вы установили ранее.
Пример
  1. Добавьте LuaStore к первой сцене в вашей игре (Инструменты> Грибок> Создать> LuaStore).
  2. Установите переменные в store  Lua, например
store.name = "John"

     Загрузите другую сцену, например используя команду Load Scene в Fungus
     Получить ту же переменную из магазина, например, 


print(store.name) -- prints "John"

FungusLua. PlayerPrefs


Система Unity PlayerPrefs хранит и обращается к предпочтениям игрока между игровыми сессиями.

Пример PlayerPrefs


Вот пример использования PlayerPrefs из Lua.

-- Сохранение значения в настройках
playerprefs.SetInt("SaveName", 1)
playerprefs.Save()
-- Использование значения из настроек
local v = playerprefs.GetInt("SaveName")
print(v) -- Will print out 1

FungusPrefs


Класс FungusPrefs - это оболочка вокруг PlayerPrefs, которая добавляет поддержку слотов сохранения.

По сути, если вы хотите хранить простые значения, используйте PlayerPrefs. Если вы хотите сохранить значения, используя несколько профилей игроков, вы должны использовать FungusPrefs. Переменная в слоте - это целое число [0 ..], а ключ - это строка.

-- Удаляет все сохраненные значения для всех слотов.
prefs.DeleteAll()
-- Удаляет ключ и его значение из этого слота сохранения.
prefs.DeleteKey(slot, key)
--
[[ Возвращает значение с плавающей запятой, связанное с этим ключом в этом слоте сохранения, если оно существует.]]
prefs.GetFloat (slot, key, defaultValue)
--[[ Возвращает значение int, связанное с этим ключом в этом слоте сохранения, если оно существует.
]] 
prefs.GetInt (slot, key, defaultValue)
--[[ Возвращает строковое значение, связанное с этим ключом в этом слоте сохранения, если оно существует.
]] 
prefs.GetString (slot, key, defaultValue)
- Возвращает true, если ключ существует в этом слоте для сохранения.
prefs.HasKey(slot, key)
- Записывает все измененные настройки на диск.
prefs.Save()
--[[ Устанавливает значение предпочтения, определяемого ключом для этого слота сохранения.]]
prefs.SetFloat(slot, key, value)
--[[ Устанавливает значение предпочтения, определяемого ключом для этого слота сохранения.]]
prefs.SetInt(slot, key, value)
- Устанавливает значение предпочтения, определяемого ключом для этого слота сохранения.
prefs.SetString(slot, key, value)
--[[ Возвращает комбинированный ключ, используемый для идентификации ключа в слоте сохранения.]]
prefs.GetSlotKey(slot, key)

FungusLua. Команда ExecuteLua

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

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

Родительская Flowchart будет связана с глобальной переменной Lua до выполнения сценария Lua. По умолчанию имя привязки - «Flowchart», но вы можете изменить его на любое, используя свойство Lua Binding Name родительской потоковой диаграммы.

Вы также можете сохранить возвращаемое значение из сценария Lua в переменной Flowchart.

Оценка выражений


Команда Fungus If может сравнивать только 2 переменные одновременно. Для более сложных выражений, включающих несколько переменных или математические функции, вы можете использовать Lua для оценки выражения и сохранения результата в переменной Flowchart .
  1. Добавьте объект Блок-Схемы (Tools > Fungus > Create > Flowchart). Добавьте некоторые переменные в Блок-Схему.
  2. Добавить объект LuaBindings (Tools > Fungus > Create > LuaBindings)
  3. Добавьте привязку к игровому объекту Flowchart  и выберите компонент Flowchart .
  4. На Блок-Схеме добавьте команду ExecuteLua в блок для оценки сложного выражения. Сохраните возвращаемое значение в переменной логической Блок-Схемы.
  5. Добавьте команду If, которая проверяет значение логической переменной.

В команде Execute Lua вы можете использовать функцию getvar(), чтобы получить любые переменные Блок-Схемы, которые будут использоваться в выражении. Примечание: getvar() возвращает ссылку на объект переменной Fungus. Чтобы получить доступ к значению этой переменной, используйте свойство .value.

Пример кода


Вот пример сценария Lua, который оценивает сложное выражение, включающее 3 целочисленных переменных, определенных на связанной Блок-Схеме.

local v1 = getvar(flowchart, "Var1")
local v2 = getvar(flowchart, "Var2")
local v3 = getvar(flowchart, "Var3")
return (v1.value == v2.value or v3.value == 5)


Не забудьте использовать .value для доступа к значению, хранящемуся в объекте переменной, а не сам объект переменной!

FungusLua. Контроль Fungus

Модуль Fungus предоставляет несколько функций для работы со стандартными повествовательными функциями и Блок-Схемами Fungus.

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

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

Пример Повествования


В этом примере скрипт Lua демонстрирует некоторые функции диалога Say и Menu. Чтобы попробовать их, добавьте объект Lua на сцену (Tools > Fungus > Create > Lua) и скопируйте этот скрипт в текстовое поле Lua Script. Вам также может понадобиться добавить объект EventSystem в сцену (GameObject> UI> Event System), чтобы кнопки меню реагировали на ввод пользователя. 

-- Показать текст в SayDialog
say("Hi there")
say "This syntax also works for say commands"
-- Показать список опций в MenuDialog
-- (Обратите внимание на фигурные скобки здесь!)
local choice = choose{ "Go left", "Go right" }
if choice == 1 then
    say("You chose left")
elseif choice == 2 then
    say("You chose right")
end


 Примечание. Синтаксис фигурных скобок означает, что список опций передается в качестве параметра таблицы в функцию Choose(). Это ярлык для написания этого:
local choice = choose( {"Go left", "Go right"} )

функции Say Dialog


Чтобы использовать пользовательский SayDialog:
  1. Добавить SayDialog на сцену (Tools > Fungus > Create > SayDialog)
  2. Выберите объект Lua в окне Иерархии и найдите компонент LuaBindings.
  3. Добавьте привязку(binding) к игровому объекту SayDialog и выберите компонент SayDialog. Нотабене Убедитесь, что вы выбрали правильный компонент!
  4. В сценарии Lua теперь вы можете активировать этот SayDialog с помощью функции setsaydialog(), передав ключ привязки SayDialog.

Чтобы изменить поведение функции say(), например, чтобы не ждать ввода, когда это сделано, сделайте это:

sayoptions.waitforinput = false

Вы можете связать объекты Character похожим образом и установить говорящего персонажа с помощью функции setcharacter().
Это список доступных функций для управления SayDialogs.
-- Опции для настройки поведения Say Dialog
sayoptions.clearprevious = true | false
sayoptions.waitforinput = true | false
sayoptions.fadewhendone = true | false
sayoptions.stopvoiceover = true | false
-- Установите активный saydialog для использования с функцией say
-- saydialog: привязка к компоненту SayDialog
setsaydialog (saydialog)
-- Получает активное диалоговое окно произнесения или создает его, если его нет
getsaydialog()
-- Установите активный персонаж в Say Dialog
-- персонаж: A Fungus.Character компонентимя спрайта в списке портретов персонажаThe name of a sprite in the character's portrait list
setcharacter(character, portrait)
-- Написать текст в активном Say Dialog
-- text: строка для записи в Say Dialog
-- voice: закадровый аудиоклип для воспроизведения
say(text, voiceclip)

Функции Menu Dialog

Вы настраиваете собственные MenuDialogs таким же образом, как SayDialogs, используя функцию setmenudialog () для установки активного MenuDialog.

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

Вы можете установить параметр, который будет отображаться, но недоступен для выбора, добавив к нему ~ character.
local choice = choose { "Option 1", "Option 2", "~Option 3" }
if choice == 1 then
    say "Chose option 1"
elseif choice == 2 then
    say "Chose option 2"
end
-- Option 3 is displayed but can't be selected
say "End options"

Полезным шаблоном является использование select () вместе с оператором goa Lua и метками. Это может быть удобно для выравнивания вложенных пунктов меню. Оператор goto не поддерживает переход в область действия локальной переменной, но это легко обойти, объявив локальную переменную во внешней области видимости. Вы также можете использовать глобальную переменную (не используя ключевое слово local).

local choice = 0
choice = choose { "Option A", "Option B" }
if choice == 1 then goto optionA end
if choice == 2 then goto optionB end
::optionA::
say "Chose option A"
goto endoptions
::optionB::
choice = choose { "Option C", "Option D" }
if choice == 1 then goto optionC end
if choice == 2 then goto optionD end
goto endoptions
::optionC::
say "Chose option C"
goto endoptions
::optionD::
say "Chose option D"
goto endoptions
::endoptions::
say "End options"


Функции menu () и menutimer () предоставляют альтернативный способ использования MenuDialog. Эти функции немедленно возвращаются, и функция обратного вызова вызывается, когда игрок выбирает опцию в меню.

Это список доступных функций MenuDialog.

-- Установите активный menudialog для использования с функцией menu setmenudialog(menudialog)
-- Получает диалоговое окно menu dialog, или создает его, если его еще нет
getmenudialog()
-- Показать список параметров меню и ждет, пока пользователь выберет один..
-- Когда параметр начинается ~ character он будет отображается, но не доступен 

-- Возвращает индекс выбранной опции.
-- Возвращает 0, если список опций пуст. Индексы массива Lua начинаются с 1, 

-- options: массив строк параметров. например { "Option 1", "Option 2" }
choose(options)
-- Список параметров меню и ждет, пользователь не выберет один, или истечет таймер.
-- Когда параметр начинается с ~ character он будет отображаться, но не будет доступен для выбора.
-- Возвращает индекс выбранной опции или значение по умолчанию, если таймер истекает.
-- Возвращает 0, если список опций пуст. Примечание: индексы массива Lua начинаются с 1, а не с 0).
-- options: массив строк параметров. например { "Option 1", "Option 2" }
-- duration: время игрок должен выбрать опцию.
-- defaultoption:  опция index для возврата, если таймер истекает.
choosetimer(options, duration, defaultoption)
-- Показать кнопку меню
-- text: текст для отображения на кнопке
-- callback: функция для вызова, когда выбрана эта опция
-- interactive (optional): если false, опция отображается как отключенное
menu(text, callback, interactive)
-- Отображение таймера, в течение которого игрок должен выбрать опцию.
-- duration: продолжительность отображения таймера.
-- callback: функция для вызова, если таймер истекает до выбора опции 

menutimer (duration, callback)
-- Очистить все отображаемые в данный момент пункты меню
clearmenu()

Функции  Portrait


Состояния портретов можно контролировать с помощью stage.

Сначала добавьте своих персонажей и сцену в список LuaBindings.

Затем в сценарии lua используйте команды stage, show, showPortrait и hide, чтобы управлять портретами на сцене.

-- Показать персонажа на этой стадии позиции
stage.show (character, "left")
-- показать персонажа с определенным портретом и переместить его
-- от одного этапа к другому.
stage.show(character, "happy", "offscreen right", "right")
-- показать конкретный портрет
stage.showPortrait(character, "amused")

-- скрыть персонажа
stage.hide(character)
-- Скрыть персонажа, исчезающего в позиции
stage.hide(character, "offscreen left")


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

stage.show{character=character, fromPosition="left", toPosition="right"}
stage.show{character=character, portrait="angry", facing="left"}
stage.hide{character=character}

Функция Conversation


Функция conversation() позволяет вам выполнять длительный обмен диалогами с помощью одного вызова функции. Многострочный синтаксис Lua [[ ]] здесь удобен. Поскольку функция dialog() принимает единственный строковый параметр, вы можете опустить обычные скобки функции.

conversation [[
john: Hello!
sherlock: Greetings.
]]


Смотрите документы для Conversation system.

Функции  Flowchart


Мы добавили специальные функции для say() и menu(), потому что они распространены в играх Fungus. Чтобы выполнить любые другие команды в Fungus от Lua, вы должны сделать это вместе с Блок-Схемой и Блоком, например так:
  1. Добавьте Блок-Схему и Блок (например, «MyBlock») в сцене.
  2. Добавьте команды Fungus, которые вы хотите выполнить из Lua, в Блоке. (например, Play Sound)
  3. Добавить объект Lua на сцену (Tools > Fungus > Create > Lua)
  4. В компоненте LuaBindings добавьте привязку к игровому объекту Блок-Схемы и выберите компонент Блок-Схемы.
  5. В компоненте LuaScript используйте функцию runblock() для выполнения Блока, передавая связанную Блок-Схему и имя Блока в качестве параметров.

runblock(flowchart, "MyBlock")

Вы также можете получить доступ к любой переменной Flowchart из Lua через функцию getvar().

-- Предположим, что переменная Flowchart связана с компонентом Flowchart в LuaBindings
-- MyVar - это строковая переменная, определенная в Flowchart
local myvar = getvar(flowchart, "MyVar")
print(myvar.value)
myvar.value = "New value for string"


Это список доступных функций для управления Блок-Схемами(Flowcharts).

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

v = getvar(flowchart, "FloatVar")
-- v.value = 10 - устанавливает значение переменной равным 10
-- f = v.value - f теперь содержит 10
-- flowchart: Fungus Flowchart, содержащая блок для запуска.
-- varname: имя переменной, которую нужно получить.
getvar (
flowchart, varname)
-- запускает указанный блок в
flowchart
-- flowchart: Fungus Flowchart, содержащая блок для запуска.
-- blockname: имя блока для запуска.
--commandindex: индекс команды, с которой нужно начать выполнение
-- nowait: если false, будет приносить, пока блок не завершит выполнение. Если --true, то будет продолжено немедленно
runblock (блок-схема, имя блока, commandindex, nowait)

FungusLua. Модуль Fungus Lua

Модуль Fungus Lua предоставляет удобные функции для работы с Lua, Unity и Fungus. Он находится в FungusLua/Resources/Lua/Fungus.txt и загружается автоматически при использовании компонента Lua Script.

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

Осмотр объектов Lua


Вы можете использовать встроенную функцию Lua print (), чтобы получить базовое описание любого объекта, напечатанного на консоли. Если вы хотите получить более подробное описание объекта, используйте inspect ().

-- Prints a short description of object v
print(v)
-- Prints a summary of object v in a human readable format.
inspect(v)

Запуск сопрограмм Unity


При привязке к компоненту C# с использованием Lua Bindings вы можете получить доступ к любому public методу в классе. Если метод возвращает IEnumerator, то этот метод может быть выполнен как  Unity coroutine, которая является мощным способом запуска асинхронного кода.

Функция runwait () позволяет вам вызывать метод сопрограммы C# из Lua, который может завершить свою работу несколькими кадрами, а затем продолжить работу с остальной частью кода Lua после завершения выполнения метода C#. Так работает, например, функция say ().

Это список доступных функций для ожидания и работы с сопрограммами.

-- Waits for a number of seconds, then continue execution of Lua script
wait(duration)
-- Waits until the Lua function provided returns true, or the timeout expires.
-- Returns true if the function succeeded, or false if the timeout expired
waitfor(fn, timeoutduration)
-- Run a C# coroutine and continue execution of Lua script
run(co)
-- Run a C# coroutine, wait until it completes, then continue execution of Lua script
runwait(co)

Globals vs Table mode


Модуль Fungus может использоваться в трех режимах, управляемых опцией Fungus Module в компоненте LuaUtils.
  1. Use Global Variables: все функции модуля отображаются на глобальные функции. Это обеспечивает удобный доступ, но при этом существует риск того, что вы можете случайно объявить переменную с тем же именем, что и у функции модуля Fungus.
  2. Use Fungus Variable: все функции модуля доступны через глобальную таблицу, называемую «fungus». Это дает определенную степень безопасности пространства имен за счет большего набора текста.
  3. No Fungus Module: модуль «Fungus» не будет зарегистрирован. Используется, если вы не хотите использовать модуль Fungus.

Опции 1 и 2 функционально эквивалентны, это просто вопрос личных предпочтений, которые вы хотите использовать.

-- sub is a function in the %Fungus module, mapped to a global variable
-- Use Global Variables
sub('a string')
-- Use Fungus Variable
fungus.sub('a string')

FungusLua. LuaUtils

LuaUtils - это компонент, который расширяет среду Lua некоторыми часто используемыми функциями.

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

Пример


Вот пример того, что вы можете сделать:
local go = luautils.Find("MyObject") -- Find a game object by name luautils.Destroy(go) -- Destroy it

 Функции GameObject


Это список функций GameObject, представленных в luautils.

-- Найти игровой объект по имени и вернуть его.
GameObject Find(string name)
-- Возвращает один активный тег с тегом GameObject. Возвращает ноль, если GameObject не был найден.
GameObject FindWithTag(string tag)
-- Возвращает список активных тегов с тегами GameObjects. Возвращает пустой массив, если GameObject не был найден.
GameObject[] FindGameObjectsWithTag(string tag)
-- Создайте копию GameObject.
-- Может быть использован для создания префабов.
GameObject Instantiate(GameObject go)
-- Уничтожает экземпляр GameObject.
Destroy(GameObject go)
-- Создает экземпляр именованного префаба
-- Префаб должен существовать в папке ресурсов в проекте.
GameObject Spawn(string resourceName

Регистрация типов C#


Наиболее важной функцией компонента LuaUtils является регистрация типов C #, чтобы к экземплярам этих типов можно было получить доступ из сценариев Lua.

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

Однако в некоторых случаях вам необходимо явно зарегистрировать тип. Самый простой способ сделать это - добавить имя типа в файлы JSON FungusTypes.txt или UnityTypes.txt, на которые ссылается компонент LuaUtils. Вы также можете создавать свои собственные файлы JSON для регистрации дополнительных типов. Обратите внимание, что типы, которые не содержатся в основной DLL-библиотеке приложения, должны будут использовать полное имя типа пространства имен в файле JSON.

Пример файла типа JSON


Пример файла типа JSON:

{ "registerTypes" : [ "Fungus.Block" ], "extensionTypes" : [ "Fungus.LuaExtensions" ] }

Регистрация типов напрямую


Если вам нужно зарегистрировать типы непосредственно из C # или выполнить более сложный тип регистрации, вы можете использовать класс MoonSharp UserData для этого. См. Документацию MoonSharp для списка поддерживаемых методов регистрации. Хорошее место для регистрации типов C # - метод Awake пользовательского компонента.

Другие утилиты


Имя привязки Описание
time Unity Time class. например 'time.deltaTime' возвращает delta time для этого кадра
playerprefsКласс Lua Preferences. Используется для сохранения данных на диск.
prefsКласс Fungus Prefs наша собственная оболочка вокруг PlayerPrefs, которая добавляет систему слотов.
factoryКласс PODTypeFactory для создания общих plain-old-data типов
luaenvironmentКомпонент LuaEnvironment, используемый для выполнения сценариев Lua
luautilsСсылка на сам компонент LuaUtils
testПоддержка Unity Test Tools (если установлен)
stringtableFungusLua локализации String Table

PODFactory

Из-за ограничений в C# / Mono, MoonSharp имеет ограниченную поддержку для работы с типами Plain-Old-Data (struct), такими как Vector3, Color и т. Д.

Наилучший подход здесь состоит в том, чтобы рассматривать свойства POD как неизменяемые объекты и никогда не пытаться изменять переменную POD, которая была получена из объекта C#. Вместо этого вы должны создать новый объект POD, заполнить его необходимыми значениями, а затем передать этот объект в вызовах кода C#. Класс LuaUtils PODFactory помогает сделать это для распространенных типов Unity.

суббота, 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:
  1. Создайте папку Resources / Lua в своем проекте. Капитализация здесь важна. Папка может быть создана внутри существующей папки в вашем проекте.
  2. Создайте файл mymodule.txt в папке Resources / Lua и добавьте в него свой скрипт Lua. (Переименуйте mymodule.txt в любое, что вы хотите).
  3. Теперь вы можете использовать функцию 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

  1. Первая часть 'LuaScript.LuaScript' дает вам информацию о том, откуда запускается скрипт Lua.
  2. Следующая часть в скобках «(1,0-3)» сообщает номер строки и диапазон символов, в которых находится ошибка.
  3. Последняя часть строки дает вам описание типа ошибки.
  4. Следующая строка содержит список исходного кода 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 в вашей сцене:
  1. Создать объект LuaBindings (Tools > Fungus > Create > LuaBindings)
  2. Перетащите объект Unity, к которому вы хотите получить доступ, в поле «Object» в списке «Object Bindings».
  3. Поле Key заполняется автоматически на основе имени объекта. Это будет имя переменной, которую вы используете для доступа к связанному объекту из скрипта Lua. Вы можете изменить этот ключ на любую строку, которую вы предпочитаете.
  4. Если связанный объект является 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.
  1. В окне проекта переместите папку Fungus / Thirdparty / FungusLua в корень проекта.
  2. Удалите папки Fungus и FungusExamples.
  3. Добавьте 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, особенно для более продвинутого использования.