Программирование на языке LUA. Книги lua


Lua учебник для начинающих lua manual for beginners

Доброго времени суток!Как и обещал начинаю создавать некоторое подобие учебнику по луа.

Как это будет выглядеть? Конечно не в виде справки, лишь при изучении какой-то сложной функции будет цитироваться русскоязычная справка по луа с сайта 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 runningHello 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 — переменная типа booleanvar = 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      elseifend       false     for       function  ifin        local     nil       not       orrepeat    return    then      true      until     while

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

s — stringi — integerb — booleanh — handlet — tablemt — 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

luagu.ru

Основы декларативного программирования на Lua / Хабр

Луа (Lua) — мощный, быстрый, лёгкий, расширяемый и встраиваемый скриптовый язык программирования. Луа удобно использовать для написания бизнес-логики приложений.

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

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

Пример

В качестве наивного примера возьмём код создания диалогового окна с текстовым сообщением и кнопкой в императивном стиле:function build_message_box(gui_builder)<br/>   local my_dialog = gui_builder:dialog()<br/>   my_dialog:set_title("Message Box")<br/>  <br/>   local my_label = gui_builder:label()<br/>   my_label:set_font_size(20)<br/>   my_label:set_text("Hello, world!")<br/>   my_dialog:add(my_label)<br/>  <br/>   local my_button = gui_builder:button()<br/>   my_button:set_title("OK")<br/>   my_dialog:add(my_button)<br/>  <br/>   return my_dialog<br/>end В декларативном стиле этот код мог бы выглядеть так:build_message_box = gui:dialog "Message Box"<br/>{<br/>   gui:label "Hello, world!" { font_size = 20 };<br/>   gui:button "OK" { };<br/>} Гораздо нагляднее. Но как сделать, чтобы это работало?

Основы

Чтобы разобраться в чём дело, нужно знать о некоторых особенностях языка Луа. Я поверхностно расскажу о самых важных для понимания данной статьи. Более подробную информацию можно получить по ссылкам ниже.
Динамическая типизация
Важно помнить, что Луа — язык с динамической типизацией. Это значит, что тип в языке связан не с переменной, а с её значением. Одна и та же переменная может принимать значения разных типов:a = "the meaning of life" --> была строка,<br/> a = 42                    --> стало число
Таблицы
Таблицы (table) — основное средство композиции данных в Луа. Таблица — это и record и array и dictionary и set и object.

Для программирования на Луа очень важно хорошо знать этот тип данных. Я кратко остановлюсь лишь на самых важных для понимания деталях.

Создаются таблицы при помощи «конструктора таблиц» (table constructor) — пары фигурных скобок.

Создадим пустую таблицу t:

t = { } Запишем в таблицу t строку «one» по ключу 1 и число 1 по ключу «one»:t[1] = "one"<br/> t["one"] = 1 Содержимое таблицы можно указать при её создании:t = { [1] = "one", ["one"] = 1 } Таблица в Луа может содержать ключи и значения всех типов (кроме nil). Но чаще всего в качестве ключей используются целые положительные числа (array) или строки (record / dictionary). Для работы с этими типами ключей язык предоставляет особые средства. Я остановлюсь только на синтаксисе.

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

Следующие две формы записи эквивалентны:

t = { [1] = "one", [2] = "two", [3] = "three" }<br/> t = { "one", "two", "three" }Во-вторых: При использовании строковых литералов в качестве ключей можно опускать кавычки и квадратные скобки, если литерал удовлетворяет ограничениям, налагаемым на луашные идентификаторы.

При создании таблицы следующие две формы записи эквивалентны:

t = { ["one"] = 1 }<br/> t = { one = 1 } Аналогично для индексации при записи…t["one"] = 1<br/> t.one = 1 … И при чтении:print(t["one"])<br/>print(t.one)
Функции
Функции в Луа — значения первого класса. Это значит, что функцию можно использовать во всех случаях, что и, например, строку: присваивать переменной, хранить в таблице в качестве ключа или значения, передавать в качестве аргумента или возвращаемого значения другой функции.

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

function make_multiplier(coeff)<br/>   return function(value)<br/>     return value * coeff<br/>   end<br/>end<br/>  <br/>local x5 = make_multiplier(5)<br/>print(x5(10)) --> 50 Важно помнить, что «объявление функции» в Луа — на самом деле синтаксический сахар, скрывающий создание значения типа «функция» и присвоение его переменной.

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

С сахаром:

function mul(lhs, rhs) return lhs * rhs end Без сахара:mul = function(lhs, rhs) return lhs * rhs end
Вызов функции без круглых скобок
В Луа можно не ставить круглые скобки при вызове функции с единственным аргументом, если этот аргумент — строковый литерал или конструктор таблицы. Это очень удобно при написании кода в декларативном стиле.

Строковый литерал:

my_name_is = function(name)<br/>   print("Use the force,", name)<br/>end<br/>  <br/> my_name_is "Luke" --> Use the force, Luke Без сахара:my_name_is("Luke") Конструктор таблицы:shopping_list = function(items)<br/>   print("Shopping list:")<br/>   for name, qty in pairs(items) do<br/>     print("*", qty, "x", name)<br/>   end<br/>end<br/>  <br/> shopping_list<br/>{<br/>   milk = 2;<br/>   bread = 1;<br/>   apples = 10;<br/>}<br/>  <br/>--> Shopping list:<br/>--> * 2 x milk<br/>--> * 1 x bread<br/>--> * 10 x apples Без сахара:shopping_list(<br/>       {<br/>         milk = 2;<br/>         bread = 1;<br/>         apples = 10;<br/>       }<br/>   )
Цепочки вызовов
Как я уже упоминал, функция в Луа может вернуть другую функцию (или даже саму себя). Возвращённую функцию можно вызвать сразу же:function chain_print(...)<br/>   print(...)<br/>   return chain_print<br/>end<br/>  <br/> chain_print (1) ("alpha") (2) ("beta") (3) ("gamma")<br/>--> 1<br/>--> alpha<br/>--> 2<br/>--> beta<br/>--> 3<br/>--> gamma В примере выше можно опустить скобки вокруг строковых литералов:chain_print (1) "alpha" (2) "beta" (3) "gamma" Для наглядности приведу эквивалентный код без «выкрутасов»:do<br/>   local tmp1 = chain_print(1)<br/>   local tmp2 = tmp1("alpha")<br/>   local tmp3 = tmp2(2)<br/>   local tmp4 = tmp3("beta")<br/>   local tmp5 = tmp4(3)<br/>   tmp5("gamma")<br/>end
Методы
Объекты в Луа — чаще всего реализуются при помощи таблиц.

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

Луа предоставляет специальный синтаксический сахар для объявления и вызова методов — двоеточие. Двоеточие скрывает первый аргумент метода — self, сам объект.

Следующие три формы записи эквивалентны. Создаётся глобальная переменная myobj, в которую записывается таблица-объект с единственным методом foo.

С двоеточием:

myobj = { a_ = 5 }<br/>  <br/>function myobj:foo(b)<br/>   print(self.a_ + b)<br/>end<br/>  <br/> myobj:foo(37) --> 42 Без двоеточия:myobj = { a_ = 5 }<br/>  <br/>function myobj.foo(self, b)<br/>   print(self.a_ + b)<br/>end<br/>  <br/> myobj.foo(myobj, 37) --> 42 Совсем без сахара:myobj = { ["a_"] = 5 }<br/>  <br/> myobj["foo"] = function(self, b)<br/>   print(self["a_"] + b)<br/>end<br/>  <br/> myobj["foo"](myobj, 37) --> 42Примечание: Как можно заметить, при вызове метода без использования двоеточия, myobj упоминается два раза. Следующие два примера, очевидно, не эквивалентны в случае, когда get_myobj() выполняется с побочными эффектами.

С двоеточием:

get_myobj():foo(37) Без двоеточия:get_myobj().foo(get_myobj(), 37) Чтобы код был эквивалентен варианту с двоеточием, нужна временная переменная:do <br/>   local tmp = get_myobj()<br/>   tmp.foo(tmp, 37) <br/>end При вызове методов через двоеточие также можно опускать круглые скобки, если методу передаётся единственный явный аргумент — строковый литерал или конструктор таблицы:foo:bar ""<br/> foo:baz { }

Реализация

Теперь мы знаем почти всё, что нужно для того, чтобы наш декларативный код заработал. Напомню как он выглядит:build_message_box = gui:dialog "Message Box"<br/>{<br/>   gui:label "Hello, world!" { font_size = 20 };<br/>   gui:button "OK" { };<br/>}
Что же там написано?
Приведу эквивалентную реализацию без декларативных «выкрутасов»:do<br/>   local tmp_1 = gui:label("Hello, world!")<br/>   local label = tmp_1({ font_size = 20 })<br/>  <br/>   local tmp_2 = gui:button("OK")<br/>   local button = tmp_2({ })<br/>  <br/>   local tmp_3 = gui:dialog("Message Box")<br/>   build_message_box = tmp_3({ label, button })<br/> end
Интерфейс объекта gui
Как мы видим, всю работу выполняет объект gui — «конструктор» нашей функции build_message_box(). Теперь уже видны очертания его интерфейса.

Опишем их в псевдокоде:

gui:label(title : string) => function(parameters : table) : [gui_element] gui:button(text : string) => function(parameters : table) : [gui_element] gui:dialog(title : string) => function(element_list : table) : function
Декларативный метод
В интерфейсе объекта gui чётко виден шаблон — метод, принимающий часть аргументов и возвращающий функцию, принимающую остальные аргументы и возвращающую окончательный результат.

Для простоты, будем считать, что мы надстраиваем декларативную модель поверх существующего API gui_builder, упомянутого в императивном примере в начале статьи. Напомню код примера:

function build_message_box(gui_builder)<br/>   local my_dialog = gui_builder:dialog()<br/>   my_dialog:set_title("Message Box")<br/>  <br/>   local my_label = gui_builder:label()<br/>   my_label:set_font_size(20)<br/>   my_label:set_text("Hello, world!")<br/>   my_dialog:add(my_label)<br/>  <br/>   local my_button = gui_builder:button()<br/>   my_button:set_title("OK")<br/>   my_dialog:add(my_button)<br/>  <br/>   return my_dialog<br/>end Попробуем представить себе, как мог бы выглядеть метод gui:dialog():function gui:dialog(title)<br/>   return function(element_list)<br/>  <br/>     -- Наша build_message_box():<br/>     return function(gui_builder) <br/>       local my_dialog = gui_builder:dialog()<br/>       my_dialog:set_title(title)<br/>  <br/>       for i = 1, #element_list do<br/>         my_dialog:add(<br/>             element_list[i](gui_builder)<br/>           )<br/>       end<br/>  <br/>       return my_dialog      <br/>     end<br/>  <br/>   end<br/>end Ситуация с [gui_element] прояснилась. Это — функция-конструктор, создающая соответствующий элемент диалога.

Функция build_message_box() создаёт диалог, вызывает функции-конструкторы для дочерних элементов, после чего добавляет эти элементы к диалогу. Функции-конструкторы для элементов диалога явно очень похожи по устройству на build_message_box(). Генерирующие их методы объекта gui тоже будут похожи.

Напрашивается как минимум такое обобщение:

function declarative_method(method)<br/>   return function(self, name)<br/>     return function(data)<br/>       return method(self, name, data)<br/>     end<br/>   end<br/>end Теперь gui:dialog() можно записать нагляднее:gui.dialog = declarative_method(function(self, title, element_list)<br/>   return function(gui_builder) <br/>     local my_dialog = gui_builder:dialog()<br/>     my_dialog:set_title(title)<br/>  <br/>     for i = 1, #element_list do<br/>       my_dialog:add(<br/>           element_list[i](gui_builder)<br/>         )<br/>     end<br/>  <br/>     return my_dialog      <br/>   end<br/>end) Реализация методов gui:label() и gui:button() стала очевидна:gui.label = declarative_method(function(self, text, parameters)<br/>   return function(gui_builder) <br/>     local my_label = gui_builder:label()<br/>  <br/>     my_label:set_text(text)<br/>     if parameters.font_size then<br/>       my_label:set_font_size(parameters.font_size)<br/>     end<br/>  <br/>     return my_label<br/>   end<br/>end)<br/>  <br/> gui.button = declarative_method(function(self, title, parameters)<br/>   return function(gui_builder) <br/>     local my_button = gui_builder:button()<br/>  <br/>     my_button:set_title(title)<br/>     -- Так сложилось, что у нашей кнопки нет параметров.<br/>  <br/>     return my_button<br/>   end<br/>end)

Что же у нас получилось?

Проблема улучшения читаемости нашего наивного императивного примера успешно решена.

В результате нашей работы мы, фактически, реализовали с помощью Луа собственный предметно-ориентированный декларативный язык описания «игрушечного» пользовательского интерфейса (DSL).

Благодаря особенностям Луа реализация получилась дешёвой и достаточно гибкой и мощной.

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

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

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

Полностью работающий пример можно посмотреть здесь.

Дополнительное чтение

habr.com

Lua для всей семьи. Урок 1: установка и первые программы - Программирование - Статьи по созданию игр

В этой серии уроков, которую я задумал, будет обсуждаться язык программирования Lua. Я постараюсь сделать изложение как можно более доступным для начинающих, и именно на них буду ориентироваться. То есть, опытные Lua-кодеры, скорее всего, не почерпнут отсюда ничего нового (уверен, тут они найдут только простор для придирок и замечаний, которые, собственно, с их стороны даже приветствуется), но если у вас за плечами нет богатого опыта программирования, то, думаю, кое-что вы вынесете.

Вся серия не будет подчиняться какой-то системе. Уроки будут последовательно вводить ряд конструкций языка, чтобы уже к третьему или четвёртому уроку вы уже могли писать свои программы. Моя цель - подтолкнуть вас к самостоятельному изучению языка, помочь ощутить его, а не разъяснить от А до Я - если хотите освоить язык полностью, читайте справочное руководство (которое, хоть и скверно, переведено на русский язык: http://www.lua.ru/doc/). Чем раньше вы перейдёте от уроков "для чайников" в Сети к изучению справочника, тем лучше.

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

Lua - популярный, несложный для освоения встраиваемый интерпретируемый динамически типизированный язык программирования общего назначения. Нет, вам необязательно понимать и половины слов, сказанных в предыдущем предложении - главное знайте, что он популярный и несложный. Кстати, простотой, а также маленьким размером дистрибутива (около 150 килобайт), он и заслужил свою популярность. Скрипты на Lua поддерживаются большим количеством приложений, в том числе играми. World of Warcraft и S.T.A.L.K.E.R. используют язык Lua. Мой любимый игровой движок, LÖVE, позволит вам с помощью Lua с лёгкостью создавать разнообразные игры. Как видите, Lua открывает вам немалые горизонты!

Прежде чем мы начнём, вам следует обустроить среду для программирования: то есть, найти программу, которая принимала бы написанный вами код на Lua и исполняла его: интерпретатор. Тут есть три варианта:

1. Скачать официальный дистрибутив Lua с одного из сайтов, поставляющих их.

С официального сайта Lua можно скачать только исходные коды интерпретатора. Однако поизучав http://lua.org/download.html в разделе Binaries, вы можете обнаружить ссылки на сайты с исполняемыми файлами для Windows. Один из них: http://joedf.users.sourceforge.net/luabuilds/. Загрузите оттуда один из архивов (совпадающий с вашей платформой: 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 и напишите в него:

Код

-- main.lua -- print("Hello world!")

После чего запустите в командной строке (не забудьте переместиться в директорию с main.lua с помощью команды cd):

Код

> C:\lua\lua.exe main.lua

В ответ интерпретатор Lua выдаст:

В принципе, этого следовало ожидать. В программе мы вызвали функцию print. Функция print принимает произвольное число параметров и последовательно выводит их на экран. В данном примере мы передали ей строку (цепочку символов) "Hello world!". С таким же успехом можно передать в качестве параметра:

Код

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 отмечаются комментарии: подсказки для программиста, которые игнорируются интерпретатором, и предназначенные для того, чтобы в коде было легче разобраться. Можете попробовать написать в программе:

Код

-- print("nothing")

Интерпретатор подумает, что это комментарий, и не станет выполнять инструкцию.

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

Код

print "Just one string"

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

Код

print 2 -- не сработает, 2 - не строка. print 2*2 + 6 -- тем более не сработает

str = "string!!" -- присвоили переменной str значение "string!!"   -- о переменных читайте ниже print str -- тоже не сработает.

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

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

Код

<имя_переменной> = <выражение>

Например:

Код

star = 8 -- Теперь в переменной star хранится число 8 wars = "owl" -- В переменной wars - строка "owl" jedi = 42/2 -- В переменной jedi - число 21 luke = star*jedi -- В переменной luke - число 168 (да, 21 умножить на 8)

Значения переменных и выражений с ними также можно вывести на экран:

Код

print(star, wars, jedi, jedi-star+luke) -- Выведет: -- 8 owl 21 181

Только не пытайтесь сложить переменные star и wars - попытавшись прибавить 8 к "owl", вы ничего хорошего не добьётесь!

Как вы должны были заметить, имя у переменной может быть практически любым: главное, чтобы оно не начиналось с цифры. Серьёзно, вы даже можете объявить переменную с названием print, и тогда функция print перестанет работать, потому что имя print станет ссылаться на вновь объявленную переменную. Но есть группа слов, которые запрещено использовать в качестве названий переменных - это ключевые слова языка, с которыми мы пока не познакомились, но на которые точно стоит посмотреть:

Код

  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. Надеюсь, я вас не запутал.

Попробуйте, например, запустить такую программу:

Код

-- main.lua -- foo = "bar" print(foo, baz) -- Выведет: -- bar nil

Таким образом, у переменной baz, которой нет, но считается, будто она есть, значение nil, и функция print понимает это и выводит его на экран в виде строки "nil". В Lua есть хороший метод проверки существования переменной: если значение переменной не равняется nil, то она по крайней мере объявлена. С другой стороны, можно явно объявить переменную, равную nil:

Так можно делать, и, хотя это на первый взгляд и кажется глупым, так иногда делают. В последующих уроках вы узнаете, кто и зачем, и наверняка начнёте делать так же. Иногда, конечно же. Будьте осторожны с nil'ом: напечатать nil можно, но совершать с ним арифметические операции нельзя! То есть, если print(nil) сойдёт вам с рук, то конструкция вроде 99+nil вызовет ошибку, даже если вам бы хотелось, чтобы 99+nil равнялось 99. Поверьте, я тоже огорчился, когда узнал.

Резюме: 1. Мы узнали про функцию print, что она умеет и как правильно вызывать её без скобок. 2. Узнали, как объявлять переменные, как вычислять выражения (правда, совсем немножко), какие могут быть имена у переменных. 3. Узнали про nil, прониклись его мистической загадочностью и обрели уверенность в том, что в будущем многое будем связано с ним.

Для пытливых и желающих укрепить свои познания предлагаю простые упражнения, которые можно не выполнять, если вы чувствуете себя и без того достаточно компетентным: 1. Напишите программу, которая выводит припев вашей любимой песни. 2. Попробуйте вывести значения следующий выражений. Попытайтесь понять, почему некоторые из них работают, а некоторые - нет. Посмотрите, какие ошибки вызывают несработавшие выражения.

Код

2 + "string"; 6 + "14"; "box" - "vox"; 1 * "11b" "148" * "1e6";

3. Напишите программу, которая обменивает две переменные значениями. То есть: Сделайте так, чтобы a стала равна 8086, а b - 6502. Для этого создайте третью переменную и совершите нехитрые перестановки. Убедитесь, что задача решена правильно, вызвав print(a,b) до обмена и print(a,b) после.

gcup.ru

Роберту Иерузалимски — «Программирование на языке LUA» PDF

ВВЕДЕНИЕКогда Вальдемар, Луис и я начали разработку Lúa в 1993 году, мы с трудом могли себе представить, что Lúa так распространится. Начавшись как домашний язык для двух специфичных проектов, сейчас Lúa широко используется во всех областях, которые могут получить выигрыш от простого, расширяемого, переносимого и эффективного скриптового языка, таких как встроенные системы, мобильные уст­ройства и, конечно, игры. Мы разработали Lúa с самого начала для интегрирования с про­граммным обеспечением, написанным на C/C++ и других распро­страненных языках. Эта интеграция несет с собой много преимуществ. Lúa – это крошечный и простой язык, частично из-за того, что он не пытается делать то, в чем уже хорош С, например быстродействие, низкоуровневые операции и взаимодействие с программами третьих сторон. Для этих задач Lúa полагается на С. Lúa предлагает то, для чего С недостаточно хорош: достаточная удаленность от аппаратно­го обеспечения, динамические структуры, отсутствие избыточности и легкость тестирования и отладки. Для этих целей Lúa располагает безопасным окружением, автоматическим управлением памятью и хорошими возможностями для работы со строками и другими типами данных с изменяемым размером.Часть силы Lúa идет от его библиотек. И это не случайно. В конце концов, одной из главных сил Lúa является расширяемость. Многие особенности языка вносят в это свой вклад. Динамическая типиза­ция предоставляет большую степень полиморфизма. Автоматическое управление памятью упрощает интерфейсы, поскольку нет необхо­димости решать, ктоотвечает за выделение и освобождение памяти или как обрабатывать переполнения. Функции высших порядков и анонимные функции позволяют высокую степень параметризации, делая функции более универсальными.В большей степени, чем расширяемым языком, Lúa является «склеи­вающим» (glue) языком. Lúa поддерживает компонентный подход к разработке программного обеспечения, когда мы создаем приложение, склеивая вместе существующие высокоуровневые компоненты. Эти компоненты написаны на компилируемом языке со статической типизацией, таком как C/C++; Lúa является «клеем», который мы ис­пользуем для компоновки и соединения этих компонентов. Обычно компоненты (или объекты) представляют более конкретные низко­уровневые сущности (такие как виджеты и структуры данных), ко­торые почти не меняются во время разработки программы и которые занимают основную часть времени выполнения итоговой программы.Lúa придает итоговую форму приложению, которая, скорее всего, сильно меняется во время жизни данного программного продукта. Однако, в отличие от других «склеивающих» технологий, Lúa явля­ется полноценным языком программирования. Поэтому мы можем использовать Lúa не только для «склеивания» компонентов, но и для адаптации и настройки этих компонентов, а также для создания пол­ностью новых компонентов.К

scanlibs.com

Учебник по LUA - Мои статьи - Каталог статей

Вступление Этот учебник научит вас, как использовать Lua . Он написан для людей, которые не встречилались раньше с программированием совсем, и поэтому в нем не будут использованы сложные слова, которые есть в других учебниках. Лучше будет, если вы уже будете знать как работать с ini-кодом, прежде чем приступите к изучению программирования.

Содержание:

1.0 - Начало -> 1.1 Создание Lua файла -> 1.2 Прикрепление скрипта к объекту

2.0 - Основы Lua -> 2.1 Комментарии -> 2.2 Типы данных -> 2.3 Переменные -> 2.4 Операторы -> 2.5 Таблицы -> 2.6 Оператор "For"

3.0 - Lua stuff -> 3.1 Этапы скрипта -> 3.2 Функции -> 3.3 Указатели

4.0 - Функции и свойства в Вики

5.0 - Пример скрипта -> 5.1 Мина

________________________

----- 1.0 - Начало ----- ________________________ Lua позволяет объектам делать то, что они обычно не были бы в состоянии сделать или создать особенные эффекты.

- 1.1 Создание Lua файла-

Принцип работы скриптов Lua состоит в том, что скрипты присоединены к объектам, созданным с помощью ini. Чтобы сделать файл Lua в простом блокноте в Windows, просто создайте новый текстовый файл, перейдити в меню "Файл", "Сохранить Как...", измените "Тип файла:" на "Все файлы" , и измените ".txt" в имени файла на ".lua". Если нет никакого расширения, просто добавьте ".lua" в конце имени файла. Потом нажмите "Сохранить". Вы создали файл Lua.

Совет от переводчика: Используйте Notepad++ вместо стандартного блокнота, так как в нем показывается весь синтаксис Lua, и вообще в нем легче работать.

- 1.2 Прикрепление скрипта к объекту -

Чтобы прикрепить Lua скрипт к объекту, созданному в ini файле, просто поместите "ScriptPath = <путь к файлу Lua>" в блоке кода объекта с соответствующим табулированием.

________________________

----- 2.0 - Основы программирования Lua ----- ________________________

--- 2.1 Комментарии ---

Комментарии в скрипте Lua - строки текста, которые не читаются игрой/программой, и в основном используются, чтобы аннотировать скрипт. Чтобы аннотировать, сделайте 2 дефиса, и что-нибудь после них на той же самой строке - комментарий.

Code

-- Это коменнтарий

--- 2.2 Типы данных ---

Типы данных - типы данных, которые используются для переменных и свойств. В CC есть 5 основных типов данных: числа, текст, boolean (логическая переменная), вектор, и ноль (nil). Первые 2 - понятно из названия то это. boolean - логическая переменная, т.е. её значения это истина (true) или ложь (false). Вектор в CC - координаты (X, Y). Числовые данные используются, печатая только числа. Текст используется при наличии пары кавычек ("") с текстом между ними. Вектор используется, следуя за словом "Vector " 2 числами разделенными запятой в двух круглых скобках. Ноль - обозначается как "nil" (чтобы не быть перепутанным с числом ноль).

Code

--Числа 1234

--Текст "text"

--Логическая переменная true false

--Векторы Vector(1,1) Vector(5,2) Vector(-7,6)

--Ноль (ничто) nil

--- 2.3 Переменные ---

Переменные - это то в Lua, чему Вы можете дать значение. Они используются для того, чтобы хранить информацию, чтобы Вы могли снова вызвать это позже. Переменная состоит из своего имени, одного знака "=", и значения.

Code

X = 5

Чтобы изменить переменную, просто напечатайте ту же самую переменную снова с новым значением:

Code

X = 2

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

Code

A = 5 X = A

В результате X будет равен 5.

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

Локальные переменные - переменные, у которых могут быть множественные копии, каждая из них привязана к объекту со скриптом, который создал их. Чтобы создать локальную переменную, напечатайте "local" перед именем переменной, разделив их пробелом. Установка значения локальной переменной равного значению другой локальной переменной работает подобным способом как и у глобальных переменных.

Code

local varA = 5 local varB = varA

Это действие сделало переменную "varB" равной 5. Заметьте, что слово "local" не использовалось, когда мы выбирали переменную "varA".

Другое полезное свойство переменных - то, что Вы можете использовать переменные, чтобы установить определенное свойство в объект, и хранить объект в переменной. Храня объект в переменной, с ним легче взаимодействовать и легче вызывать указателем. Чтобы использовать переменные, для изменения свойства объекта, Вы нуждаетесь в переменной, которая является определенным указателем на объект (мы разберем это позже), сопровождающаяся точкой, названием свойства, знаком "=", и значением.

Code

thing.GetsHitByMOs = false

"thing" это указатель на объект, "GetsHitByMOs" это свойство объекта в ini, и "false" это значение.

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

Code

self.GetsHitByMOs = false

--- 2.4 Операторы ---

Принцип работы Lua (и программирования вообще), это проверка операторов, чтобы увидеть, являются ли их значение истинным (true) и делающим что-либо если это так (или если не так). Давайте посмотрим на код ниже.

Code

if X == 1 then <содержимое> end

Этот код проверяет, если переменная "X" равна "1", то совершает "содержимое" ("<содержимое>" не фактическое действие, только указатель места заполнения для других команд, до которых мы доберемся позже), если оператор будет истиной. Обратите внимание на "end" внизу блока кода, который говорит, что "<содержимое>", часть этого оператора, закончено. Если Вы не напечатаете "end" после оператора (конец оператора после <содержимого> тоже), то Вы получите ошибку. Также заметьте, что есть 2 знака "=" в "строке "if". "==" нужно для того, чтобы проверить равенство, и "=" для того, чтобы установить значение переменной/свойства. Символы условий:

Code

-- равно ==

-- неравно ~=

-- меньше <

-- больше >

-- меньше или равно <=

-- больше или равно >=

Внутри операторов "if", могут находится операторы "else". Эти операторы проверяют, выполняется ли условие оператора "if", и если оно не истинно (не выполняется), то тогда совершаются действия в их содержимом.

Code

if X == 1 then <содержимое> else <содержимое> end

Условие "Elseif" похоже на второй "if" оператор и работает также:

Code

if X == 1 then <содержимое> elseif X == 2 then <содержимое> end

В операторе могут быть много условий "elseif", но только одно "else".

--- 2.5 Таблицы ---

Списки (также называемые как таблицы и массивы) похожи на переменные, у которых могут быть множество значений. Чтобы создать список, напечатайте название списка сопровождаемое знаком "=" и парой скобок {}.

Code

thelist = {}

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

Code

thelist[1] = 1234 thelist[2] = 37065

Числовой символ с именем списка перед этим, говорит число элементов в списке.

Code

numbercheck = #thelist

Тот же самый список как в вышеупомянутых примерах, имеет значение переменной "numbercheck" равное 2.

Чтобы очистить все значения списка, напечатайте имя списка, знак "=" и пустую пару скобок. Чтобы очистить только одно значение, установите это значение в ноль.

Code

-- Очистка всего списка thelist = {}

-- Очистка одного значения thelist[1] = nil

Списки могут быть глобальными и локальными, как переменные.

Code

thelist = {} local thesecondlist = {}

--- 2.6 Оператор For ---

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

for <переменная> = <начальное число>, <число как много раз совершать действия> do

Пример использования оператора "for".

Code

for i = 1, 5 do <содержимое> end

Давайте рассмотрим каждую часть подробно:

for - Стартовое ключевое слово

i = 1 - "i" - временная переменная, которая используется оператором "for", для сохранения, сколько раз он совершил действия (включая 1). "i" может быть изменен на любое имя как переменная. "1" это начальное значение для отсчета.

5 - Кол-во повторений "<содержимого>".

Чтобы прервать оператор "for", включите "break" в оператор "if", который проверяет значение оператора "for" для соблюдения условия.

Code

for i = 1, 5 do if i == 3 then break end end

________________________

----- 3.0 - Cortex Command Lua stuff ----- ________________________

--- 3.1 Этапы скрипта ---

Этапы скрипта - это части скрипта, которые выполняются только, когда объект был создан, когда он существует, или когда уничтожен. Этапы скрипта тоже требуют "end" как и операторы условий.

Code

-- <Содержимое> в промежутке между "function Create(self)" и "end" будет работать, только когда объект будет создан. (происходит только один раз) function Create(self) <Содержимое> end

-- <Содержимое> в промежутке между "function Update(self) и "end" будет работать, только когда этот объект существует. function Update(self) <Содержимое> end

-- <Содержимое> в промежутке между "function Destroy(self) и "end" будет работать, только когда этот объект уничтожается. (происходит только один раз) function Destroy(self) <Содержимое> end

--- 3.2 Функции ---

Функции - часть Lua, которые уже встроены в игру и взаимодействуют с содержимым в Cortex Command. Формат функции - название группы функции, двоеточие, имя функции, и её параметры (нужные данные для этого, чтобы это работало) разделяются запятыми в круглой скобке. Большинство названий групп функции Cortex Command могут быть заменены указателем чем-нибудь на то, с чем они смогут взаимодействовать. Пример функции ниже:

Code

anactor:AddImpulseForce(Vector(0,-10),Vector(0,0))

Информация о функции из Википедии Cortex Command Lua:

Code

AddImpulseForce Adds impulse force (or instant momentum) to this MovableObject for the next time Update() is called.

Arguments:

- An Vector with the impulse force vector that will directly be added to this MovableObject's momentum next Update(). In kg * m/s. - A Vector with the offset, in METERS, of where the impulse is being applied relative to the center of this MovableObject.

Return value:

None.

"anactor" - указатель на актора, "AddImpulseForce" - название функции, и содержимое круглой скобки - данные, необходимые для работы функции. В блоке информации о функции, "Return value", - это то, что выводит функция, когда она выполняется. Большинство функций в Cortex Command может быть найдено в wiki, так что убедитесь проверив это.

--- 3.3 Указатели ---

Хорошо, мы наконец добрались до указателей! В Cortex Command указатели - переменные, которые "хранят" объект в себе. Или Вы можете представить это, как гигантскую стрелку, указывающую на объект. независимо от того, что свойства Вы устанавливаете на указатель или используете функцию на нем, это произведет эффект на тот объект, на который он "казывает.

Есть несколько способов создать указатели. Обычно используют специальный оператор "for", который проверяет все объекты определенного типа и является оператором, который проверяет, является ли объект тем, который вам нужен. Кусок кода скрипта ниже присоединен к объекту, который ищет актора, с именем "Dummy" и затем устанавливает на него указатель, названный "local pointer".

Code

function Update(self)

for actor in MovableMan.Actors do if actor.PresetName == "Dummy" then local pointer = actor break end end

end

Что делает вышеупомянутый кусок - проверяет всех акторов в игре, пока он не находит агента с "PresetName" как "Dummy". Тогда это устанавливает указатель на этого актора как "local pointer" и останавливает оператор "for" с "break". Термин "актор" является указателем на актора, и передан "local pointer" для более простой справочной информации.

Здесь 2 других строки "for", которые получают указатели на устройствах и частицах.

Code

-- Указатель устройств for item in MovableMan.Items do end

Code

-- Указатель частиц for particle in MovableMan.Particles do end

________________________

----- 4.0 - Функции и свойства в Cortex Command Wiki ----- ________________________

Это - ссылка на раздел Cortex Command wiki, который содержит документацию для многих функций и свойств. http://wiki.datarealms.com/wiki/index.php/LuaDocs/Index

________________________

----- 5.0 - Пример скрипта ----- ________________________

--- 5.1 Mine --- Этот скрипт для простой мины, которая взрывается, когда акторы находятся в пределах определенного расстояния объекта со скриптом.

Code

-- Пока объект существует function Update(self)

-- Проверка всех акторов for actor in MovableMan.Actors do

-- Использует функцию и свойство вектора, чтобы сохранить расстояние между актором и объект со скриптом в переменной. local distcheck = SceneMan:shortestDistance(self.Pos,actor.Pos,true).Magnitude

-- Оператор, проверяющий, если проверяемое расстояние (переменная "local distcheck") меньше чем 10. Если так, совершите действие... if distcheck < 30 then

-- GibThis() - это функция, которая делает целенаправленную разрушение объекта. self:GibThis()

-- Остановка оператора break

-- Конец оператора "if". end

-- Конец оператора "for". end

-- Конец "function Update(self)". end

mikro-team.clan.su

Язык программирования Lua. Учебник для начинающ..

Язык программирования Lua. Учебник для начинающ..

Имя файла: Yazyk_programmirovania_Lua_Uchebnik_dlya_nachinayusch.pdfРазмер: 473.96 Kb.Формат: pdf

Пожалуйста, введите цифры на картинке: С этим файлом связано 46 файл(ов). Khaos_i_kosmos_Sinergetika_evolyutsii.pdf Большие биологические часы (введение в интеграл...doc OS_RTEMS_Rukovodstvo_polzovatelya.pdf Старение. Хаос.Фракталы.doc Julia_Language_Documentation.pdf korotko_o_yazyke_prgrammirovania_julia.pdf Процессы регуляции и старение организма.doc julia_tutorial.pdf Magnitnye_polya_v_kosmose.pdf Integratsia_3D_prilozheniy.pdf Balbaert_-_Getting_Started_with_Julia_Programming.pdf В. В. Фролькис В чем сущность старения.doc Retsepty_dlya_CryEngine_3.pdf Joshi_-_Julia_for_Data_Science.pdf Апоптоз.doc CryEngine_3_Razrabotka_igr_dlya_nachinayuschikh.pdf Mastering_Julia.pdf Том Вуджек. Тренировка ума.doc Руководство по Lua.doc Satori.pdf Analiz_dvizhenia_mayatika_fuko.pdf Vlianie_vraschenia_zemli_na_dvizhenie_tel.pdf 100_velikikh_korablekrusheniy.pdf Legendy_voenno-morskogo_flota.pdf Programmirovanie_v_Lua_3-e_izd.pdf Yazyk_programmirovania_Lua_Uchebnik_dlya_nachinayusch.pdf Jung_K__Brown_A_-_Pogrammirovanie_v_Lua_dlya_n.pdf

biologo.ru

Lua за 60 минут « Santa Simplicita

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

Lua? Что это?

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

Зачем?

Lua может вам пригодится:

* если вы геймер (плагины для World of Warcraft и множества других игр)* если вы пишете игры (очень часто в играх движок пишут на C/C++, а AI — на Lua)* если вы системный программист (на Lua можно писать плагины для nmap, wireshark, nginx и других утилит)* если вы embedded-разработчик (Lua очень быстрый, компактный и требует очень мало ресурсов)

Что надо для того, чтобы читать дальше?

1. Научитесь программировать. Хотя бы немного. Не важно на каком языке.2. Установите Lua. Для этого либо скачайте здесь версию 5.2 (http://www.lua.org/download.html), либо ищите ее в репозиториях. Версия 5.1 тоже пойдет, но знайте, что она очень старая.

Все примеры из статьи запускайте в терминале командой наподобие «lua file.lua».

Первые впечатления

Lua — язык с динамической типизацией (переменные получают типы «на лету» в зависимости от присвоенных значений). Писать на нем можно как в императивном, так и в объектно-ориентированном или функциональном стиле (даже если вы не знаете как это — ничего страшного, продолжайте читать). Вот Hello world на Lua:

-- my first lua app: hello.lua print "hello world"; print("goodbye world")

Что уже можно сказать о языке:

* однострочные комментарии начинаются с двух дефисов "--"* скобки и точки-с-запятыми можно не писать

Операторы языка

Набор условных операторов и циклов довольно типичен:

-- условные операторы (ветки else может не быть) if a == 0 then print("a is zero") els

zserge.wordpress.com