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

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

Если нет, то:
1) установите что-нибудь для редактирования кода (КРОМЕ БЛОКНОТА, ЭТО ВРЕДНО ДЛЯ ПСИХОЛОГИЧЕСКОГО ЗДОРОВЬЯ), например Visual Studio Code;
2) сделайте копию любого левелпака, откройте любой файл из Pack/Styles или Pack/Scripts/Levels, меняйте там любые цифры и смотрите в игре что происходит после этого;
3) продолжайте экспериментировать пока не обретёте осознание того, что вы делайте. В крайнем случае, посмотрите документацию.[github.com]

Чтобы быстрее проверять изменения в игре после редактирования файлов включите Debug Mode в настройках и жмите F4 в меню выбора уровней.

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

Для максимальной простоты пусть вначале файл будет выглядеть как-то так:

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

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

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

Идём дальше.

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

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

Данные вы можете хранить как числовые, так и строковые:

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

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

Если что, в Lua с помощью -- обозначаются комментарии. Это позволяет писать рандомный дезинформирующий бред, который не будет влиять на работу программы. Т.е. весь текст в строке, идущий после --, никакого влияния на работу кода не оказывает.

Переменные нам будут нужны для двух вещей:
1) выполнение арифметических операций со значениями, хранящимися в переменных;
2) передача значений в нужные нам куски кода.

Первый пункт вроде как понятен:

Со вторым разберёмся позже.

---

Функции... что мы можем сказать про функции...
Функция - кусок программного кода, который можно многоразово использовать из других частей программы.
Если вы уже немного видели скрипты в этой игре, то догадывайтесь, что функции здесь это практически всё, кроме переменных и редких цифр.

Выглядят они примерно как-то так:

Смысл сего написания примерно таков: мы говорим, что хотим создать функцию с названием createSomeWalls без параметров () (ПРО ПАРАМЕТРЫ ПОТОМ). Это её заголовок.
Далее мы пишем какой-то код вызова стен и определяем окончание функции с помощью ключевого слова end.
То что происходит между заголовком функции и словом end является телом функции, т.е. списком действий, которая она выполняет.

При вызове этой функции мы сразу создадим три стены в трёх разных позициях. НАМ НЕ НАДО ПИСАТЬ ВЕЗДЕ ТРИ ВЫЗОВА СТЕНЫ ВМЕСТО ОДНОГО ВЫЗОВА ЭТОЙ ФУНКЦИИ.

Как мы можем это использовать:

Результат будет такой же, как и здесь:

Но это же не очень хорошо, верно?

То, что мы использовали ранее: w_wall(0, 40) и t_wait(60), ЭТО ТОЖЕ ФУНКЦИИ! только их создаём не мы, они уже есть в игре.

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

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

Для начала рассмотрим первую полезную нам игровую функцию с параметрами:
w_wall(side, thickness)
Мы уже использовали её ранее чтобы создавать стены. Теперь поговорим подробнее про то, что означают те магические числа, что мы писали в параметрах. Но для начала про сами параметры.

Параметр функции - значение, передаваемое из вызывающего кода внутрь функции.
Если хотите математическую аналогию, то парабола y(x) = x^2 в коде будет выглядеть примерно так:
Если вы не хотите математическую аналогию, то другой аналогии у меня для вас нет.

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

Пример использования данной функции будет выглядеть так:
То есть, мы передаём в функцию y числа 5, 15 и 25 как значение параметра x, а затем записываем её результат вычислений в переменные value1, value2, value3 после каждого вызова.

Данный код с функцией будет эквивалентен этому:

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

Возвращаемся к w_wall(side, thickness)
Эта функция имеет два параметра:
1) side - определяет позицию (side) появления стены;
2) thickness - задаёт толщину (высоту?) стены.
На всякий случай уточняю, что возвращаемого значения у этой функции нет (или по крайней мере не должно быть..................)

Когда мы в начале писали вот такую штуку:
то мы с помощью значений задавали параметры расположения и толщины стен.
Также, упомянутая здесь функция t_wait(duration) создаёт задержку, равную её единственному параметру.

Теперь мы будем задавать параметры с помощью переменных, но чтобы мне было легче объяснять возьмём другую игровую функцию: e_messageAddImportantSilent(message, duration)
Она выводит на экран сообщение без звука. Параметры:
1) message - само сообщение (строка текстовая);
2) duration - длительность нахождения сообщения на экране.

Мы можем её использовать так:
что вызовет сообщение при запуске уровня.

А можем так:

Или даже так:

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

Постановка проблемы: мы имеем пустой уровень с 6 сторонами. Мы хотим получить один паттерн с одной открытой стороной.


Что мы знаем про этот паттерн? Он состоит из 5 стен в шестиугольном уровне. Этого нам пока достаточно.

И вот мы уже получили что мы хотим.
Но что мы уже знаем? Мы должны использовать функции!


Уже лучше, но это не должно так работать. Переместим вызов функции паттерна из onLoad() в onStep() с некоторой задержкой, что позволит паттерну повторяться спустя время.

Работает, но вы можете быть недовольны, что паттерн появляется всегда одинаково. Исправим это.

math.random(param1, param2) - возвращает случайное значение в промежутке [param1, param2]

Теперь мы получили паттерн, появляющийся в случайном положении через промежутки времени. НО МОЖНО СДЕЛАТЬ ЛУЧШЕ

Что вы будете делать если нужно будет сделать паттерн не для шестиугольного уровня, а для 3-4-5-7-8 и так далее?
Будете создавать новые функции? Это необязательно.

Новая штука для изучения - циклы. Для создания паттернов в Lua мы используем цикл FOR - DO - END.

Выглядит он так:

Как это работает:
1) первая строчка состоит из сразу трёх магических цифр:
    1a) i = 0 (мы создаём переменную, равную 0, это счётчик);
    1b) 9 (значение для условия выхода из цикла, как только счётчик i превысит число 9, цикл завершится);
    1c) 1 (инкремент, значение на которое увеличивается счётчик после выполнения одной итерации).
2) тело цикла от заголовка до end (так же как и в функциях), то что будет выполняться в каждой итерации.

Чаще всего люди не пишут инкремент явно и оставляют запись в виде for i = 0, 9 do. Это тоже будет работать, поскольку по умолчанию инкремент равен единице.

Изменим наш код паттерна с помощью цикла:

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

Что надо сделать, чтобы получить нужное количество стен в зависимости от формы уровня? Использовать l_getSides() - возвращает текущее количество сторон уровня.

Почему -2?
• потому что условие <=, (i = 0, N do даст нам N + 1 итераций) для этого нам надо -1
• потому что нам нужна одна открытая сторона, это уже -2

Почему я инициализирую цикл с нуля (i = 0), а не единицы (i = 1)?
Потому что я привык в кодинге считать с нуля. Lua в этом плане язык особенный, потому что тут и цикл <=, и массивы индексируются с единицы, но в большинстве ЯП счёт идёт от нуля.
Вы можете писать [for i = 1, l_getSides() - 1 do], но меня это будет путать.

Паттерн работает? Работает. Универсальный для сторон? Вполне. Что ещё надо? Что-нибудь более осмысленное.

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

В качестве примера сделаем серию паттернов с "обратными" позициями.

Созданный ранее паттерн возьмём за основу и немного переделаем для лучшего контролирования переменных:
Изменения: начальную позицию (side) и толщину перенесли в параметры.

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

Если вы будете использовать серии паттернов, то уберите вызов задержки в onStep() функции, потому что за один вызов серии будет создаваться несколько паттернов, между которыми нужно будет создавать задержку уже внутри самой функции.

Теперь подробнее о том, что происходит:
1) мы получаем случайную позицию паттерна на любой из граней;
2) начинается цикл, идёт первая итерация: появляется паттерн в случайной позиции + вызывается задержка;
3) проверяется условие i <= timesDo, если оно true, то создаётся следующая стена, но уже с другой позицией: к предыдущей позиции добавляется половина числа граней на уровне (side + move), таким образом мы получаем "инвертированный" паттерн;
4) паттерны продолжают появляться и чередовать противоположные стороны до окончания цикла (+ move * i) и последующего завершения серии.

Отдельно про добавленные параметры:
1) thickness - толщина, как обычно. Впрочем, вы можете сделать глобальную переменную в главном файле, что-то вроде thickness = 40 и потом использовать её значение в самой функции без параметра;
2) timesDo - сколько раз вы хотите создавать паттернов за одну серию. Обычно определяется с помощью math.random(a, b). Помните, что условие <=, поэтому 0 создаст один паттерн;
3) delay - длительность задержки, как правильно выбирать задержу для каждого паттерна я понятия не имею.

С помощью небольшой замены можно сделать уже другой вид паттерна:
Что-то похожее на лево-право паттерн. % - остаток от деления, i % 2 будет давать +1 на нечётных значениях счётчика и +0 на чётных, что позволит чередовать соседние стороны на разных итерациях.


Как вы можете видеть смысловое отличие только в способе изменения позиции паттерна во время серии. Если хотите сделать что-нибудь ещё, то просто сделайте другой способ изменения для move, чтобы получить что-нибудь новое.
Например, умножьте move на два из leftRight паттерна и посмотрите что получится.
Просто замените move = i % 2 на move = i % 2 * 2

Что делать в случае, когда мы хотим создавать последовательности из разных видов паттернов?
Во-первых, нужны условия, синтаксис у них примерно такой:
• if then и end - обязательные части условия;
• elseif - (опционально) дополнительное условие если предыдущее условие не сработало;
• else - (опционально) действие если никакие условия не сработали.

• код после then выполняется только если предшествующая проверка условия равна true;
• условие для проверки создаётся с помощью логических операций ==, !=, >, >=, <, <=. Например, a == b - возвращает true если значения a и b одинаковые;
• выполняется код только первого условия с проверкой true, после него остальные игнорируются.

Условия нам нужны для создания функции выбора паттерна, которая будет вызывать нужную функцию паттерна в зависимости от значения ключа:
l_getDelayMult() - возвращает текущий множитель задержки уровня.

Теперь нам нужен список ключей паттернов, который мы хотим использовать:

Создаётся он в виде массива (переменная, хранящая несколько значений). Нумерация элементов идёт от 1, доступ через индекс keys[value]. Расположение элементов в массиве выглядит так:

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

Подобный код используется в подавляющем большинстве уровней, включая официальные. Объясняю, что здесь происходит:
1) вызывается паттерн через addPattern(keys[index]); поскольку index = 1, keys[index] = 1, то addPattern(key) вызовет inversedPatternSeries(...) через условие key == 1;
2) увеличивается индекс на единицу;
3) index = 2, keys[index] = 1, снова вызывается inversedPatternSeries(...) через условие key == 1;
...
N) #keys - количество элементов в массиве, в данном случае #keys = 5. Когда индекс становится больше чем количество элементов в массиве (index - 1 == #keys), то его значение становится снова 1 и последовательность повторяется заново.

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

Полный код для генерации последовательностей паттернов будет таким:

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

Пока хватит, на этом всё.
Надеюсь это кому-нибудь поможет, но на самом деле нет.

Я конечно сам так написал в качестве примера для руководства просто потому что почти все так делают (и так немного проще объяснять), но вы задумайтесь: зачем?
Зачем так делать?

Неправильно:

Правильно:

Докажите, что я неправ :)

Это мыло((((
Объясните мне, пожалуйста, в чём смысл сего произведения?

Расчёт задержки на основе толщины паттернов разделённой на скорость?
И что это даёт? Что при большей скорости задержка будет изменяться даже если ты не меняешь сам параметр задержки? Что при увеличении толщины паттерна в два раза настолько же будет увеличиваться пространство между паттернами, которое обычно должно быть в несколько раз больше чем их толщина?

Можете кидаться в меня камнями за мои уровни сколько угодно, но на такую функцию задержки я никогда не соглашусь.