Введение
Это руководство предназначено для тех, у кого ограниченный опыт работы с LUA. Мы рассмотрим основы того, как оформлять код, строительные блоки для Вас, чтобы создавать более сложный код и предоставим некоторые примеры. Руководство написано так, чтобы сразу применять его на практике. Поэтому Вам следует открыть Tabletop Simulator и Ваш редактор LUA, чтобы следовать дальше.
Это первое руководство в этой серии. Второй – это Изучение Lua Подробнее. Третий представляет собой набор полезных функций под названием Learning Lua Functions.
Перед первым нажатием клавиши
Во-первых, я бы настоятельно рекомендовал установить Atom, если вы собираетесь делать скрипты в Tabletop Simulator. Он знает, какие функции можно использовать и будет импортировать/экспортировать код в/из TTS.
Затем Вы должны добавить в закладках . Вы будете часто ссылаться на этот сайт, как только начнете писать свои скрипты. Здесь Вы найдете специальные функции в Tabletop Simulator и как они работают. Вы чаще всего будете использовать страницы API и Object, по крайней мере, на моем опыте.
Подготовка
Когда Вы сохраняете свои скрипты в Tabletop, он будет использовать Ваше последнее сохранение, а затем загрузит в него скрипты. Поэтому для любого скрипта, который Вы намереваетесь написать, Вам нужно будет сделать следующее:
Повторно нажимайте его, потому что, конечно, вы это сделаете.
EXTRA CREDIT:
Когда вы создаете таблицы, есть несколько способов сделать это . Способ, используемый здесь, заключался в том, чтобы обеспечить визуальную ясность. Однако такой способ создания параметров кнопки, как этот, занимает не мало места, если у Вас будет много кнопок. Я предпочитаю создавать свои таблицы таким образом, чтобы экономить место, но не выходить за правых край. Используя наш пример, я бы создал таблицу параметров следующим образом:
button_parameters = { click_function="buttonClicked", function_owner=nil, label="Press Me", position={0,0.8,0}, rotation={0,0,0}, width=500, height=500, font_size=100 }
EXTRA CREDIT: Это идеальный момент для начала игры с разными вещами, которые вы можете делать с объектами. Перейдите на страницу «Объект» в Knowledge Base и попробуйте материал. Двигайте объекты, заставляйте их переключаться на позиции, менять их цвета, что бы вы ни думали.EXTRA CREDIT: Кроме того, при каждом нажатии кнопки функция click_function запускается с двумя параметрами. Первая - это ссылка на объект, в частности ссылка на объект, к которому привязана кнопка. Второй - это цвет (например, "Blue" - синий) в строчном формате цвета игрока, который нажал на кнопку.
5) Логические утверждение
Сравнение переменных
Еще раз удалите все скрипты внутри функции buttonClicked().
Мы собираемся создать новую переменную, а затем изменить ее. Новая переменная будет булевского типа. Булевские значения могут быть только true, false. Булевские значения всегда записываются маленькими буквами. Во-первых, мы создадим нашу переменную под нашим идентификатором GUID объектов и шашки.
trueOrFalse = true
Затем, в buttonClicked, мы установим некоторую логику, чтобы проверить, истинно ли значение trueOrFalse. Если оно истинно, то будет печатать, что это Истина, и переключит его на Ложь. Если кнопка снова нажата, будет печатать, что это Ложь, и переключит значение на Истина.
if trueOrFalse then print("trueOrFalse was true.") --trueOrFalse была истина. trueOrFalse = false else print("trueOrFalse was false.") --trueOrFalse была ложна. trueOrFalse = true end
Мы могли бы также написать это так "if trueOrFalse == true then", но это необязательно. Помните, что оператору IF нужно передать булевское значение. И так как trueOrFalse уже является одним из таких, мы можем отпустить "== true".
Цикл - это секция кода, которая могут запускаться несколько раз. Это один из более сложных элементов, которые Вы будете использовать в LUA. Они часто идут со таблицами, позволяя запускать код для каждой записи в таблице.
Это ещё один тип – ipairs. Pairs нужны для таблиц без числовых ключей, а ipairs нужны для таблицы с последовательными числовыми ключами (массивы). ipairs идет по порядку, когда pairs может идти в любом порядке.
Как это будет выглядеть? Конечно не в виде справки, лишь при изучении какой-то сложной функции будет цитироваться русскоязычная справка по луа с сайта Lua.ru, материал я постараюсь преподнести в форме задача — ее решение, начиная с простого и продвигаясь дальше. Не думаю что за платформу для изучения стоит брать какой-либо хаб, так что мы будем использовать пакет LuaAIO (all in one), с помощью которого мы будем проверять код на луа. Скачать пакет можно , там же лежит справка по пакету, она полностью на английском языке и как-то странно собрана что просто не работает, рабочую версию подготовил alex82 , за что ему огромное спасибо, вот . В этой справке есть мануал по луа, первая редакция книги Programming in Lua в электронном виде и справка по библиотекам, включенным в набор LuaAIO.
Итак, скачали, распаковали, теперь запускаем файл lua.exe, открылось окно редактора, написанного на луа с применением библиотек из пакета луааио, в это углубляться не будем, скажу лишь что файл что мы запустили — среда исполнения кода, сам код находится в файле с таким же именем, но с расширением.lua, в нашем случае это lua.lua.
Начем конечно же с банального примера вывода в консоль «Hello world!», на луа это весьма простой код:
print ("Hello world!" )
Теперь разберемся с тем как посмотреть результат работы скрипта, для начала нам надо его сохранить, для этого выбираем File -> Save или нажимаем Ctrl+S, выбираем имя файла, указывать можно любое, к примеру, example1.lua. Следующим шагом будет запуск нашей программы, тот редактор в котором мы работаем позволяет делать это прямо в нем, так что выбираем в верхнем меню Debug -> Run или нажимаем просто F5, видим появившееся внизу окно, в котором отобразился следующий текст:
> Program example1.lua is running
Hello world!
Вот он, результат работы! Теперь останавливаем скрипт выбрав Debug -> Stop или нажав F6, к тексту дописалось
> Program example1.lua is stopped
что означает что скрипт остановлен (теперь можно свернуть до самого низа это окно, оно вылезет само при следующем запуске). А вот сейчас уже разберем сам скрипт на запчасти, узнав что в нем означает каждый символ. Сразу скажу что углубляться в фишки и разнообразные уловки написания скриптов я не буду, поэтому код идет в стандартном (в моем понимании) виде и содержит обычне конструкции. И еще одно небольшое отступление, если вы не владеете логикой, не можете составить план работы и продумать исполнение самого скрипта, то лучше и не браться, а уж если взялись — стараться разобраться самому что да как, а не доставать не очень добрых дядек программистов, они очень сильно начинают нервничать когда пытаются вам на пальцах объяснить что надо сделать и почему именно так, а вы в это время ничего не понимаете или просто «тупите». Если все-таки упрямость играет в вас и вы еще не закрыли этот текст, тогда продолжим. Продолжим с еще одного важного как мне кажется отступления, заключается оно в том, что здешний материал — мое видение, в том числе и русского языка, а не только луа. Любые замечания по этому тексту будут учитываться, но постарайтесь не вступать в спор из-за какой-либо не нравящейся вам запятой или конструкции в коде. Я не мастер луа, но кое-что умею, об этом и постараюсь рассказать.
И снова продолжим (обожаю такие отступления, они заставляют и тебя и собесеников держать нить разговора))), начнем с того как выглядит вызов функции в луа. Функция — некий набор инструкций, выполняющийся по вызову. В функцию так же могут передаваться аргументы (параметры), хотя это и не обязательно, переданные аргумент можно использовать исключительно внутри функции (об областях видимости переменных расскажу позднее). Допустим, что у нас есть некая функция SomeFunction, вот пример ее вызова без аргуменов:
SomeFunction()
и с аргументами one и two, они разделяются запятыми:
SomeFunction(one, two)
Теперь о нашем коде, надеюсь теперь видно что у нас имеется вызов функции print, имеющей один аргумент, которым является «Hello world!». Функция print — стандартная (базовая) функция, предоставленная луа, она выводит данные в стандартное окно вывода, эта функция может принимать любое число аргументов любого типа, выводя их друг за другом в преобразованном в строку виде.
А сейчас настало время поговорить о типах переменных, это один из значимых моментов в программирвании на луа. В этом языке существуют следующие типы данных (этот и некоторый далее материал заимствован с сайта ilovelua.narod.ru):
nil — ничего, обозначает отсутствие какого либо значения
boolean — булевская переменная, принимает значения true либо false
number — числовой тип
string — строковый тип
function — функция
userdata — специальный тип данных, позволяющий хранить в Lua данные из С (фактически это указатель void*)
thread — сопрограмма Lua (позволяет организовать превдо-многопоточность)
table — таблица — ассоциативный массив (набор пар ключ-значение), причем в качестве и ключа и значения может выступать любой тип данных
Lua — язык с динамической типизацией, то есть тип переменной устанавливается не заранее, как, например, в С, а в момент присвоения переменной значения. Примеры:
var = true
— var — переменная типа boolean
var = 1
— теперь var число
var = "string"
— теперь var строка
var = function
(a, b)
return
a + b end
— а теперь var функция, которая принимает два параметра и возвращает их сумму
var = coroutine.create
(var)
— а теперь var сопрограмма
var = {
}
— а тепеь var таблица
var = nil
— а теперь… теперь var отсутствует, перменаая уничтожена
Два символа — означают начало однострочного комментария, в котором может записываться что угодно.
А теперь после этой маленькой справки ответьте мне к какому типу относится «Hello world!»? Правильно, это строка, если вы думаете иначе — читаем все заново. Вот и весь разбор полетов, вышло что в нашем простом скрипте имеется один вызов стандартной функции луа что выводит в консоль любые переданные ей параметры, преобразовывая их в строку, мы передаем фукнции один аргумент, являющийся строкой «Hello world!», которую мы и видим в консоли после запуска скрипта.
Мой вам совет: если не понятен смысл речевых конструкций лучше не пропускать этот момент и постараться понять что написано в этой простенькой справке, иначе можно упустить важные моменты и в самом простом моменте в скрипте сесть в лужу.
Немного порадовавшись переходим к как мне кажется важной справке, следует принять её как должное. В луа мы можем объявлять переменные, которые могут являться любым из типов луа, но так же есть зарезервированные имена переменных, ими пользоваться нельзя, это приведет к нарушению работы вашего скрипта! Вот полное перечисление:
and
break
do
else
elseif
end
false
for
function
if
in
local
nil
not
or
repeat
return
then
true
until
while
Так называть переменные нельзя т.к. эти слова используются в конструкциях языка луа. Давайте договоримся дальше что писать названия переменных мы будем в соответствии с венгерской нотацией, то есть называть переменные в соответствии с их типом, начиная переменную с маленькой буквы, обозначающей тип переменной, а уже дальше писать само имя нашей переменной:
s — string
i — integer
b — boolean
h — handle
t — table
mt — metatable
Примеры: sData, iShareSize, bConnected, hFile, tTable, mtTable. Примечанице: здесь под handle подразумевается тип userdata.
Теперь справка по спец. символам в строках луа, вот цитата из лексических соглашений:
Литеральные строки должны быть заключены в одинарные или двойные кавычки и могут содержать следующие С-подобные escape-поледовательности: ‘\a’ («звонок»), ‘\b’ («забой»), ‘\f’ («перевод страницы»), ‘\n’ («перевод на новую строку»), ‘\r’ («возврат каретки»), ‘\t’ («горизонтальная табуляция»), ‘\v’ («вертикальная табуляция»), ‘\\\»‘ («двойная кавычка»), and’\» (апостроф [«одинарная кавычка»]). Кроме того, обратный слеш ставится перед концом строки в редакторе, когда для удобства набора длинные непрерывные строки записываются в несколько строк. Символ в строке также может быть представлен своим кодом с помощью escape-последовательности \ddd, где ddd- последовательность из не более чем трех цифр. (Заметим, что если после символа, записанного с помощью своего кода, должна идти цифра, то код символа в escape-последовательности должен содержать ровно три цифры). Строки в Lua могут содержать любые 8-битные значения, включая ноль, который записывается как ‘\0’.
Что реально полезно:
\t — табуляция, применяется для более красивого вывода информации
\\ — так экранируется сам слеш чтобы вывести его как \, в ином случае будет ошибка
\n — перенос строки
\r — возврат каретки
\» — двойная кавычка
\’ — одинарная кавычка
Для переноса строки на разных операционных системах используется разное сочетание символов переноса строки и возврата каретки:
\r\n — windows
\n — *nix
\r — macOS
Пока все, думаю это вам еще надо обдумать, правда на практике все намного понятнее, попробуйте сами сделать выводы через функцию print() и поиграть с типами, кстати, функция type() возвращает тип переданной ей переменной, написав print(type(«»)) мы получим string
В этой серии уроков, которую я задумал, будет обсуждаться язык программирования Lua. Я постараюсь сделать изложение как можно более доступным для начинающих, и именно на них буду ориентироваться. То есть, опытные Lua-кодеры, скорее всего, не почерпнут отсюда ничего нового (уверен, тут они найдут только простор для придирок и замечаний, которые, собственно, с их стороны даже приветствуется), но если у вас за плечами нет богатого опыта программирования, то, думаю, кое-что вы вынесете.Вся серия не будет подчиняться какой-то системе. Уроки будут последовательно вводить ряд конструкций языка, чтобы уже к третьему или четвёртому уроку вы уже могли писать свои программы. Моя цель - подтолкнуть вас к самостоятельному изучению языка, помочь ощутить его, а не разъяснить от А до Я - если хотите освоить язык полностью, читайте справочное руководство (которое, хоть и скверно, переведено на русский язык: http://www.lua.ru/doc/). Чем раньше вы перейдёте от уроков "для чайников" в Сети к изучению справочника, тем лучше.
Если что-то непонятно - обязательно задайте вопрос в комментариях, и я и другие участники постараемся вам помочь.
Lua - популярный, несложный для освоения встраиваемый интерпретируемый динамически типизированный язык программирования общего назначения. Нет, вам необязательно понимать и половины слов, сказанных в предыдущем предложении - главное знайте, что он популярный и несложный. Кстати, простотой, а также маленьким размером дистрибутива (около 150 килобайт), он и заслужил свою популярность. Скрипты на Lua поддерживаются большим количеством приложений, в том числе играми. World of Warcraft и S.T.A.L.K.E.R. используют язык Lua. Мой любимый игровой движок, позволит вам с помощью Lua с лёгкостью создавать разнообразные игры. Как видите, Lua открывает вам немалые горизонты!
Прежде чем мы начнём, вам следует обустроить среду для программирования: то есть, найти программу, которая принимала бы написанный вами код на Lua и исполняла его: интерпретатор. Тут есть три варианта:
1. Скачать официальный дистрибутив Lua с одного из сайтов, поставляющих их.
С официального сайта Lua можно скачать только исходные коды интерпретатора. Однако поизучав http://lua.org/download.html в разделе Binaries, вы можете обнаружить ссылки на сайты с исполняемыми файлами для Windows. Один из них: . Загрузите оттуда один из архивов (совпадающий с вашей платформой: Win32 или Win64) и распакуйте его куда-нибудь, желательно в каталог с коротким путём: вроде C:\lua. Отныне я буду полагать, что вы пользуетесь Windows, и ваш интерпретатор лежит именно там.
Пользователям операционных систем на базе Linux в этом смысле проще: им достаточно воспользоваться пакетным менеджером и установить Lua из репозиториев. В Debian и Ubuntu это делается командой apt-get install lua, а в Fedora, Red Hat и производных дистрибутивах - yum install lua. Однако не доверяйте мне слепо и обратитесь к справочнику вашей операционной системы, чтобы узнать, как именно это делается у вас.
2. Использовать онлайн-интерпретатор.
Находится по адресу http://www.lua.org/demo.html . На первых порах его может хватить, однако в дальнейшем, когда мы коснёмся модулей, вы будете вынуждены использовать оффлайн-версию. Пользоваться онлайн-интерпретатором очень просто: введите в окошко с текстом вашу программу и нажмите кнопку Run. Программа будет исполнена, в окошке Output покажется вывод вашей программы, а также отчёты об ошибках, если таковые были вами допущены.
3. Использовать IDE.
Например ZeroBrane Studio: http://studio.zerobrane.com/ . Есть и другие - поищите в Интернете.
В ходу сейчас две несколько различающиеся версии Lua: 5.1 и 5.2. Я буду ориентироваться на самую последнюю версию - версию 5.2, но обязательно укажу на важные различия между ей и 5.1, так как последняя тоже достаточно распространена. Кстати, Lua 5.1 исполняет код в полтора раза быстрее, чем Lua 5.2, чтобы вы знали.
=== Урок №1 ===
Итак, начнём. Создайте в изолированной от посторонних файлов папке файл main.lua и напишите в него:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
print("Hello world!")
После чего запустите в командной строке (не забудьте переместиться в директорию с main.lua с помощью команды cd):
200?"200px":""+(this.scrollHeight+5)+"px");">
> C:\lua\lua.exe main.lua
В ответ интерпретатор Lua выдаст:
200?"200px":""+(this.scrollHeight+5)+"px");">
Hello world!
В принципе, этого следовало ожидать. В программе мы вызвали функцию print. Функция print принимает произвольное число параметров и последовательно выводит их на экран. В данном примере мы передали ей строку (цепочку символов) "Hello world!". С таким же успехом можно передать в качестве параметра:
200?"200px":""+(this.scrollHeight+5)+"px");">
print(8) -- какое-нибудь десятичное число
-- выведет: 8
Print(0xDEADBEEF) -- шестнадцатиричное число
-- выведет: 3735928559
Print("0xDEADBEEF") -- а это строка, не число! Видете кавычки?
-- выведет: 0xDEADBEEF
Print(1.35e-4) -- число с плавающей запятой (дробное число)
-- Выведет 0.000135. 1.35e-4 следует понимать как "1.35, умноженное
-- на десять в минус четвёртой степени", если кто не знает.
Print((198*99)-3*500 + 14/88) -- выражение
-- Выведет значение выражения: 18102.159090909. Неплохая альтернатива
-- настольному калькулятору!
Print(198/7, "fertilizer", 2^9) -- несколько параметров произвольного
-- типа. Будут выведены значения каждого из них, разделённые знаками
-- табуляции:
-- 28.285714285714 fertilizer 512
-- Обратите внимание, что кавычки вокруг fertilizer не выводятся!
Print(1,35) -- два числа, а не десятичная дробь 1,35!
-- Запятая используется для разделения параметров.
-- Выведет:
-- 1 35
Знак "--" - не просто имитация знака тире, которая вставлена для красоты. Знаком "--" в Lua отмечаются комментарии: подсказки для программиста, которые игнорируются интерпретатором, и предназначенные для того, чтобы в коде было легче разобраться. Можете попробовать написать в программе:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- print("nothing")
Интерпретатор подумает, что это комментарий, и не станет выполнять инструкцию.
Хозяйке на заметку: если вы хотите напечатать только одну строку, можно написать вызов print так, без скобок:
200?"200px":""+(this.scrollHeight+5)+"px");">
print "Just one string"
Удобство, безусловно, сомнительное: просто имейте ввиду, что так можно. Вместе с тем, такие вызовы недопустимы:
200?"200px":""+(this.scrollHeight+5)+"px");">
print 2 -- не сработает, 2 - не строка.
print 2*2 + 6 -- тем более не сработает
Str = "string!!" -- присвоили переменной str значение "string!!"
-- о переменных читайте ниже
print str -- тоже не сработает.
В каждом из вышеперечисленных случаев программа просто откажется работать. Таким образом, в "бесскобочном" вызове за названием функции может стоять лишь строковый литерал (то есть, последовательность символов, заключённая в кавычки), и больше ничего. В будущем я расскажу об этой особенности чуть подробнее, но сейчас с вас хватит и этого.
В любом хорошем языке программирования возможно объявлять переменные: маленькие контейнеры, которые могут содержать какие-нибудь данные. В Lua это делается таким образом:
200?"200px":""+(this.scrollHeight+5)+"px");">
<имя_переменной> = <выражение>
Например:
200?"200px":""+(this.scrollHeight+5)+"px");">
star = 8 -- Теперь в переменной star хранится число 8
wars = "owl" -- В переменной wars - строка "owl"
jedi = 42/2 -- В переменной jedi - число 21
luke = star*jedi -- В переменной luke - число 168 (да, 21 умножить на 8)
Значения переменных и выражений с ними также можно вывести на экран:
200?"200px":""+(this.scrollHeight+5)+"px");">
print(star, wars, jedi, jedi-star+luke)
-- Выведет:
-- 8 owl 21 181
Только не пытайтесь сложить переменные star и wars - попытавшись прибавить 8 к "owl", вы ничего хорошего не добьётесь!
Как вы должны были заметить, имя у переменной может быть практически любым: главное, чтобы оно не начиналось с цифры. Серьёзно, вы даже можете объявить переменную с названием print, и тогда функция print перестанет работать, потому что имя print станет ссылаться на вновь объявленную переменную. Но есть группа слов, которые запрещено использовать в качестве названий переменных - это ключевые слова языка, с которыми мы пока не познакомились, но на которые точно стоит посмотреть:
200?"200px":""+(this.scrollHeight+5)+"px");">
and break do else elseif end
false for function goto if in
local nil not or repeat return
then true until while
Создав переменную с одним из этих названий, вы вызовете ошибку в программе, и работать она точно не будет. Обратите внимание: в Lua 5.1 ключевого слова goto нет, и переменную так назвать можно, но вы лучше так не делайте.
Также учтите, что имена переменных чувствительны к регистру. Это означает, что foo, fOo, fOO и FOO - четыре разные переменные, так что если вы написали имя какой-то переменной строчными буквами, а позднее написали его прописными, то, скорее всего, программа не будет работать корректно.
А теперь один важный момент: что будет если вы, случайно или преднамеренно, обратитесь к несуществующей переменной? В большинстве других языков это вызовет ошибку, но в Lua такая ситуация допустима. Она трактуется так, как будто несуществующая переменная на самом деле существует, но её значение равно nil . nil - запомните это слово! - особый тип значения в Lua, который означает "ничто". Не нуль и не пустую строку (строку вида "" - попробуйте её вывести на экран), а просто ничто. Сравните это с такой моделью: есть два человека, у одного из них есть банковский счёт, но на нём нет денег, а у другого банковского счёта нет вообще. В терминах Lua будет считаться, что на счету у первого - 0 долларов, а на счету у второго - nil . И даже не долларов, а просто nil . Надеюсь, я вас не запутал.
Попробуйте, например, запустить такую программу:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
foo = "bar"
print(foo, baz)
-- Выведет:
-- bar nil
Таким образом, у переменной baz, которой нет, но считается, будто она есть, значение nil, и функция print понимает это и выводит его на экран в виде строки "nil". В Lua есть хороший метод проверки существования переменной: если значение переменной не равняется nil, то она по крайней мере объявлена. С другой стороны, можно явно объявить переменную, равную nil:
200?"200px":""+(this.scrollHeight+5)+"px");">
cool_var = nil
Так можно делать, и, хотя это на первый взгляд и кажется глупым, так иногда делают. В последующих уроках вы узнаете, кто и зачем, и наверняка начнёте делать так же. Иногда, конечно же.
Будьте осторожны с nil"ом: напечатать nil можно, но совершать с ним арифметические операции нельзя! То есть, если print(nil) сойдёт вам с рук, то конструкция вроде 99+nil вызовет ошибку, даже если вам бы хотелось, чтобы 99+nil равнялось 99. Поверьте, я тоже огорчился, когда узнал.
Резюме:
1. Мы узнали про функцию print, что она умеет и как правильно вызывать её без скобок.
2. Узнали, как объявлять переменные, как вычислять выражения (правда, совсем немножко), какие могут быть имена у переменных.
3. Узнали про nil, прониклись его мистической загадочностью и обрели уверенность в том, что в будущем многое будем связано с ним.
Для пытливых и желающих укрепить свои познания предлагаю простые упражнения,
которые можно не выполнять, если вы чувствуете себя и без того достаточно компетентным:
1. Напишите программу, которая выводит припев вашей любимой песни.
2. Попробуйте вывести значения следующий выражений. Попытайтесь понять, почему некоторые из них работают, а некоторые - нет. Посмотрите, какие ошибки вызывают несработавшие выражения.
200?"200px":""+(this.scrollHeight+5)+"px");">
2 + "string";
6 + "14";
"box" - "vox";
1 * "11b"
"148" * "1e6";
200?"200px":""+(this.scrollHeight+5)+"px");">
a = 6502
b = 8086
Lua (от португальского «луна») - интерпретируемый язык программирования, разработанный Computer Graphics Technology Group of Pontifical Catholic University of Rio de Janeiro in Brazil. является свободно распространяемым, с открытыми исходными текстами на языке Си. По своим возможностям и реализации он ближе всего к JavaScript, но , с моей точки зрения, более гибок и имеет более широкие возможности. Несмотря на то, что Lua не имеет таких понятий, как “класс” или “объект”, на его базе вполне возможно построение ООП-программ на базе метатаблиц, которые также позволяют реализовать, например, перегрузку операций.
В этом уроке я хочу дать вам немного самых общих сведений об этом языке, а в следующих уроках покажу вам на практике как можно применять язык Lua для решения задач программирования игр.
Как я сказал выше, Луа был разработан одним из подразделений Католического университета Рио-де-Жанейро. Произошло это аж в далёком 1993 году. Но с того момента активно развивался и периодически выходили новые версии Lua – он становился удобнее, быстрее, функциональнее. В данный момент стабильной версией Lua является 5.1, однако уже доступна alpha-версия 5.2.
В Lua насчитывается восемь основных типов данных:
Lua это язык с динамическим определением типов данных. Любая переменная в Lua может содержать значения любого типа из вышеперечисленных. Все значения в Lua могут храниться в переменных, использоваться в качестве аргументов при вызове функций и возвращаться в виде результата исполнения функции.
Таблицы являются наиболее важным типом данных в Lua – именно таблицы являются основой для хранения и использования пользовательских типов данных: структуры, массивы, списки, множества и т.д. реализуются в Lua именно через таблицы. Таблица в Луа представляет собой набор пар [Ключ, Значение], где в качестве ключа может быть значение любого типа, кроме nil.
Как и многие интерпретируемые языки программирования, реализация Lua имеет отдельный компилятор исходного в исполняемый байт-код и виртуальную машину для исполнения сгенерированного байт-кода. В случае Lua байт-код представляет из себя не машинные команды, а команды “виртуального процессора Lua” с несколькими регистрами, что повышает эффективность исполнения. В виртуальной машине Lua используется так же и принцип сборки мусора (аналогично Java или.NET), который позволяет программисту не заботиться о выделении/удалении памяти – этим занимается сам интерпретатор.
Для критичных задач, имеется компилятор Lua: , который позволяет получить более быстрый код.
Lua, за долгие годы его существования и развития, завоевал сердца многих разработчиков ПО и в наше время он используется в самых разнообразных областях программирования: в скриптинге компьютерных игр (Crysis, Far Cry, Diablo 3, S.T.A.L.K.E.R.), на серверах MMO-игр (World of Warcraft, Аллоды Онлайн), в пакетах графики (например, в Adobe Photoshop Lightroom), в игровых движках и конструкторах игр (INSTEAD), для программирования GUI некоторых приложений (тот же самый Photoshop Lightroom) и во многих других задачах.
Вообще, документации, как и примеров использования, в сети достаточно много. Потому я не буду особо углубляться в эту тему. Скажу лишь, что могу посоветовать вам почитать
Lua - язык программирования, создателями которого являются Роберту Иерузалимски, Валдемар Селиш и Луис Энрике ди Фигейреду. С трудом верится, что такой популярный язык могли создать не где-нибудь в Кремниевой Долине или MIT, а в солнечной Бразилии. В стране, которая, казалось бы, находится довольно далеко от центров сосредоточения IT. Тем не менее, в одном из подразделений Католического университета Рио-де-Жанейро смогли создать настолько гибкий и мощный язык, что сейчас он находит широкое применение во многих областях.
Всё началось с разработки вспомогательного языка для нефтяной компании PETROBRAS. Инженерам-нефтяникам требовался графический фронтэнд для обработки данных по симуляции определенных процессов. При этом оборудование могло быть самым разным - и PC DOS, и UNIX, Macintosh, поэтому многие уже существующие языки (Perl, например) просто не подходили, так как работали только на одной из этих систем. На этом этапе был разработан язык под названием DEL (data entry language). Со временем, возможностей этого языка стало не хватать, поэтому был разработан новый язык, названный SOL (simple object language). И, наконец, в 1993 году разработчики поняли, что их можно объединить в один полноценный язык программирования, которые был назван Lua (по-португальски Sol это солнце, а Lua - луна). Кстати, в 1996 году Роберту Иерузалимски и другие авторы языка решили рассказать о своей работе миру и отправили статью про Lua в журнал “Software: Practice & Experience”. Позже про Lua напечатали в журнале “Dr.Dobb’s”, из которого о нем узнал один из главных разработчиков адвенчурных игр в LucasArts. Решив использовать Lua вместо их собственного скриптового языка, он был поражен его простотой и эффективностью. В результате этого большая часть разрабатываемой в тот момент игры была переписана на Lua, что способствовало росту его популярности.
Больше всего идеология Lua схожа с JavaScript. Например, у них обоих прототипная модель для реализации ООП. Однако, Lua гораздо более гибкий и мощный язык. В Lua используются виртуальная машина и сборщик мусора, что делает её более похожей на Java, однако это не мешает ей сохранять свою простоту и элегантность.
В основе языка Lua лежат таблицы, реализуемые при помощи ассоциативных массивов. Таблица здесь означает набор данных, где каждому из уникальных ключей соответствует своё значение.При помощи таблиц в Lua можно представить практически любые данные - обычные массивы, множества, таблицы символов и.т.д. В полях таблицы также могут быть описаны и функции. Проще говоря, если Вы захотите, чтобы в Вашей любимой и игре появился некий персонаж или предмет, то вам достаточно будет знать его имя, чтобы внести в таблицу, функцию, чтобы создать этот объект и ввести координаты игрового мира, в которых он должен появиться.
Стоит упомянуть такжи и о метатаблицах - таблицы, которые позволяют изменять поведение других таблиц. Например, определить, допустимо ли в некоторой ситуации сложение нечисловых значений. Или определить для некоторого события запуск “сборки мусора” (очистки памяти).
Хотя Lua используется и в промышленных приложениях,но самую большую популярность этот язык приобрел в геймдеве. Так как разработчикам бывает трудно вносить изменения в движок игры, а геймдизайнерам постоянно приходится вносить изменения в работу уровней или персонажей, то здесь Lua бывает просто незаменим. На нем очень легко в описать взаимодействие между игроками, запрограммировать NPC (крестьян в скайриме) или поведение боссов при помощи скриптов, которые потом можно быстро изменить, не влияя на движок.
Самой известной игрой, в которой применяется Lua, сейчас, конечно, стала World of Warcraft. Интерфейс WoW (меню, чат и.т.д) написаны на нем. Ещё Lua использовали в таких играх, как Crysis, King’s of Bounty, Warhammer, Аллоды онлайн, CS, Сталкер, Ведьмак, Sim City, Far Cry, Civilization V и.т.д.
Ещё на Lua часто пишутся плагины для nmap, wireshark, nginx или боты для Telegram. А ещё Википедия планирует использовать Lua для встраивания в MediaWiki (можете попробовать в английской версии).
Lua также используется в обсерваториях, занимающихся исследованиями в области астрофизики и крупных университетах по всему миру (например, в Берлинском Техническом Университете). Также Lua стал чем-то вроде национального языка программирования у себя на родине и используется многими местными компаниями и исследовательскими центрами в самых разных сферах деятельности.
Lua достаточно прост в изучении. По нему много ресурсов и видеоуроков в сети. К тому же, тут очень помогает геймификация. Если в вашей любимой игре можно создавать моды на Lua, то попробуйте поэкспериментировать с игровым миром в процессе обучения. Это позволит освоить программировании весело и без лишних усилий.
К плюсам Lua относятся:
Из минусов:
Lua отлично работает настолько, насколько вообще может скриптовый язык. Но чаще всего его применяют совместно с другими языками, хотя он вполне выполнять некоторые задачи самостоятельно. Поэтому, вам нужно будет знать хотя бы ещё один, например,C или С++. Однако, несомненно, знание Lua будет вам большим плюсом при трудоустройстве на должность разработчика игр.
LuaJIt - JIT-компилятор для Lua. Используется для задач, в которых критично время выполнения. Работает примерно в шесть раз быстрее стандартного интерпретатора.
Love2D - популярный фреймворк, предназначенный для разработки 2D игр на Lua.
Corona SDK - фреймворк для создания приложений под iOS и Android на Lua. С 2015 года появилась бесплатная версия.
