Есть одна задача, которую программисты терпеть не могут — но именно она отличает хорошего инженера от посредственного: как они документируют свой проект? Несколько лет назад я отвечал за запуск финтех-проекта. Мы выбрали стратегию быстрого старта, поэтому масштабируемость не стала для нас приоритетом. Главной целью было проверить гипотезу — и мы двигались вперёд, разрабатывая API, архитектуру и системы — с упором на простоту, не особенно задумываясь о будущем.

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

Во время работы я наткнулся на подход, который мне очень понравился: ADR — Architectural Decision Record, или «протокол архитектурных решений».

По сути, это документ, в котором фиксируются все изменения, внесённые в архитектуру: само решение, его влияние и полученные уроки.

Проще говоря, это как личный дневник — только для всей команды.

Почему это важно?

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

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

Будущие разработчики скажут вам спасибо. Подумайте о человеке, который через пять лет будет разбираться в вашем коде. Если вы не оставили объяснений, он, скорее всего, будет мучиться, пытаясь понять, зачем было сделано то или иное изменение. А теперь представьте другого разработчика в другой компании, который находит ADR-документ с чётким объяснением принятого решения. Он, без сомнения, будет вам благодарен.

Синьор-фронтендер из ВК Маргарита Лукина, автор телеграм-канала «Фронтенд кухня»:

Ценность ADR я впервые осознала в 2019 году. В команду, где работала, активно набирали новых ребят, и приблизительно раз в неделю кто-нибудь из новых разработчиков спрашивал "а почему это сделано так, а не иначе?" Приходилось постоянно давать ответы на одни и те же вопросы, и тогда-то я и поняла, насколько будет удобно записывать ответы где-нибудь в документацию в confluence и просто кидать ссылку новичкам.

В 2019 году я еще не знала сам термин ADR и говорила "документация". С термином я познакомилась совсем недавно — этим летом, на курсе по архитектуре монолитных приложений. Тогда я поняла, насколько эффективно можно использовать ADR для ускорения разработки и уменьшения TTM. Дело в том, что начиная разрабатывать новый проект, разработчик первое время (от месяца до полугода! всё зависит от размера проекта) погружается в проект — разбирается, как всё устроено, чтобы вносить изменения соответственно архитектуре. В этот период разработчик, по сути, составляет собственные adr — обычно в виде мыслеобразов в своей голове :) Если записать основные решения, разработчик сможет намного быстрее погрузиться в проект.

Как писать ADR?

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

Вдохновившее меня соглашение можно найти на GitHub . Вы также можете ознакомиться с процессом ADR на Amazon.

Вот пример шаблона, который вы можете использовать.

Такой тип документа может находиться прямо в репозитории проекта, в Confluence или, например, в JIRA.

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

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

Синьор-фронтендер из ВК Маргарита Лукина, автор телеграм-канала «Фронтенд кухня»:

Многие руководители хотят видеть на своём проекте разработчиков, которые "сразу, без раскачки" начнут перформить. Совсем избежать периода погружения невозможно, но можно ускорить его в десятки раз за счёт ADR

Несмотря на то, что пока нет подтверждений использования PromptLock в реальных атаках, эксперты считают находку важным предупреждением: злоумышленники уже научились внедрять ИИ в инструменты для автоматизированных кибератак.

Что умеет PromptLock

По данным ESET, PromptLock:

• написан на языке Golang, с версиями для Windows и Linux;
• использует ИИ-модель gpt-oss-20b через локальный API Ollama;
• генерирует вредоносные Lua-скрипты на лету, которые сканируют файловую систему, выбирают цели для атаки, шифруют и похищают данные;
• потенциально способен уничтожать данные, но эта функция пока не реализована.

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

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

Зачем в вирусе нужен ИИ

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

Именно такие примеры показывают, как ИИ может автоматизировать все этапы атаки — от разведки до кражи данных. Подобные инструменты меняют масштаб и скорость атак

Почему это тревожный сигнал

Хотя PromptLock пока выглядит как прототип или доказательство концепции, его появление сигнализирует об одном: инструменты на базе ИИ становятся доступными не только бизнесу, но и киберпреступникам.

Теперь для создания продвинутого вредоносного ПО не обязательно быть опытным программистом — достаточно задать правильный промпт. Сама угроза особенно актуальна в контексте:

• распространения локальных моделей и open-source решений;
• снижения технического порога входа для атакующих;
• роста интереса APT-групп к ИИ-автоматизации атак.

Что делать

Эксперты рекомендуют:

• пересмотреть защиту ИТ-инфраструктуры от динамически генерируемых скриптов;
• уделить внимание аномалиям в поведении программ, а не только сигнатурам;
• следить за новыми классами угроз с участием ИИ.

Все ждали, что вот-вот начнётся киберпанк: наши аватары будут тусоваться в 3D, ходить по виртуальным улицам и работать в офисе на Марсе. Но метавселенная не случилась и вместо этого мы получили пустые миры, лаги и виртуальную морскую болезнь. Чтобы попасть в эту «новую реальность», нужен мощный комп, дорогущий VR-шлем и вестибулярка космонавта. Массовому пользователю это не по карману и не по душе. Даже если вы добрались до метавечеринки — вас ждала примитивная мультяшная графика.

Метавселенная — красивый технологический концепт, но без реального запроса со стороны людей. Одни видели в ней VR и AR, другие — NFT и блокчейн, третьи — некий 3D-интернет. И стало непонятно: что это вообще было и зачем?

Метавселенная обещала стать новым поколением соцсетей, что именно там будет жить наше будущее общение и работа. Весь хайп смыл новый тренд: волна генеративного ИИ. Meta* (признана в России экстремистской организацией и запрещена) и другие техногиганты свернули свои эксперименты и переключились на нейросети.

У бизнеса с метавселенными тоже не сложилось: ни чёткой модели монетизации, ни реальных кейсов. Продажа виртуальной недвижимости в Decentraland, мерч для аватаров, баннеры в виртуальных тусовках — всё больше напоминает Web3-версию The Sims, чем серьёзную платформу с реальной экономикой. Так что будущее в 3D отложили до лучших времён.

Игровые платформы вроде Minecraft, Roblox, Fortnite — это по сути и есть настоящие метавселенные, которые давно живут своей жизнью. Среднестатистический пользователь от виртуальных тусовок отказывается: ему проще зайти в Discord или залипнуть в обычный стрим на Twitch, чем надевать шлем ради планёрки в Horizon Worlds.

Я могу просто посмотреть стрим и получить лучший опыт. Надевать шлем не имеет смысла — никакой пользы

Громкие обещания про «полное погружение» и «эффект присутствия» на практике разбивались о суровую реальность — кривую техническую реализацию. Сейчас платформы выглядят заброшенными: пустые сцены, аватары без ног и скучные шаблонные взаимодействия. Ещё одна проблема — отсутствие единого мира. Все платформы живут по отдельности, между ними нет порталов и возможности перемещаться. К тому же, в виртуальности были серьёзные проблемы с безопасностью — например, случаи домогательств.

Есть надежда, что метавселенная вернётся — когда технологии и контекст будут готовы. Когда VR-шлемы станут лёгкими, дешевыми и удобными, появятся реальные сценарии, а не просто презентации для инвесторов. Тогда, может быть, мы ещё туда заглянем. А пока — rest in pixels, Metaverse.

NFT-мания

Пока одни тусовались в метавселенной и зарабатывали миллионы на продаже пикселей, другие гуглили, что такое OpenSea и почему JPEG стоит как однушка в Москве. Сейчас NFT называют либо финансовым пузырём, либо зачатками новой цифровой инфраструктуры.

Пандемия и локдаун дали интернету второе дыхание. Люди заскучали и начали скупать цифровое искусство, как раньше собирали марки, карточки или скины в играх. В 2021 году NFT стали мейнстримом: CryptoPunks, Bored Ape, Beeple — эти имена знали все. К цифровой лихорадке подключились бренды: Adidas, Nike и даже McDonald’s начали продавать цифровой мерч в метавселенных. Пиксельные обезьяны разлетались, как будто золото будущего: в январе 2022 NFT-маркетплейс OpenSea побил все рекорды, ведь месячный объём торгов составил около $5 млрд. Владение NFT стало признаком цифрового престижа. Люди устанавливали токены себе на аватарки в Twitter, потому что это был цифровой Rolex: если у тебя был токен — ты в теме. А если нет — шёл читать гайды на Tproger.

Но уже к лету того же года рынок начал сдуваться. В июне 2022 объем OpenSea упал до ~$700 млн, а в октябре 2023 он составлял лишь $91 млн. Минус 98% от пиковых значений. Что же пошло не так?

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

Зачем мне вообще покупать этот NFT вместо настоящего произведения искусства?

Тысячи NFT-проектов выходили каждый день, рынок быстро перенасытился, и в итоге NFT-платформы утонули в спаме и мошенничестве. Один из самых распространённых трюков — wash trading: пользователь продаёт токен сам себе, чтобы искусственно раздуть спрос. Исследования показывают, что по итогам 2022 года более половины объёма торгов NFT на Ethereum приходилось на липовые сделки. Кто-то считает, что NFT со временем обесценились. Но возможно, что они с самого начала были пустышками.

Ещё один удар по доверию — кражи и хаос с плагиатом. Работы художников массово превращали в NFT без их ведома: копировали, заливали и продавали, как своё. Никто не спрашивал разрешения у авторов, и уж точно не предлагал процент с продаж. NFT также критиковали за углеродный след и загрязнение окружающей среды.

NFT как спекулятивный пузырь — фактически умер. Большинство коллекций потеряли всякий торговый смысл: объёмы упали, активные игроки исчезли, а токены превратились в мёртвые цифровые артефакты. Лихорадочные инвестиции, основанные на спекуляциях, просто сдулись.

Но сама концепция уникального цифрового актива живёт дальше. Токен как технология адаптируется и трансформируется. В играх NFT уже показали себя как востребованный юзкейс: игроки могут владеть, торговать и прокачивать виртуальные предметы. Эксперты считают, что инфраструктура останется, и на её базе появятся проекты с реальной практической ценностью. А NFT превратится в элемент цифровой инфраструктуры — как инструмент доступа и сертификат владения. Цифровой «паспорт», который фиксирует принадлежность к сообществам, открывает возможности для участия в клубах и эксклюзивных событиях.

3D‑телевизоры: история провала объёмного кино у вас дома

В начале 2010-х 3D-ТВ казались мегатрендом после хита «Аватар». Однако к 2016 году большинство крупных производителей отказались от выпуска моделей с поддержкой 3D. Многие пользователи так и не получили качественный опыт из-за технических ограничений и ранней стадии развития.

Я знаю, почему 3D-телевизоры провалились: производители поспешили поймать волну кинотеатрального бумa, сделав технологию с тяжёлыми и требующими подзарядки очками. В то же время на горизонте появились большие плоские телевизоры без очков, которые выглядели гораздо лучше и удобнее для пользователей.

Что пошло не так? Во-первых, сами 3D-очки. Их нужно было заряжать, носить поверх своих, а сидеть при этом строго под определённым углом, иначе магия пропадала. Многие отмечают, что это было неудобно — очки были дорогими, тяжелыми, а некоторые зрители уставали уже на середине фильма: жаловались на напряжение в глазах, дискомфорт и головные боли. Технология, которая должна была удивлять, в итоге просто раздражала.

Контента почти не было, и пользователи, купив дорогой телевизор, сталкивались с вопросом: а что, собственно, смотреть? 3D-телевизоры были дороже своих 2D-аналогов, и с развитием 4K, HDR и OLED-технологий потребители начали отдавать предпочтение лучшему качеству изображения без 3D. Зачем платить за условную «глубину», если можно просто получить красивую живую картинку из коробки.

Несмотря на провал 3D-ТВ в их классическом виде, эксперты не ставят на них технологии крест. Как пишет WIRED, новый виток связан с автостереоскопическими дисплеями: они используют трекинг взгляда, линзы и AI, чтобы создавать объёмное изображение прямо на экране — без всяких аксессуаров.

Google Glass: будущее было на носу

Google Glass подавали как прорыв — интерфейс будущего прямо у вас перед глазами. Но вместо футуризма — странная дужка с экранчиком сбоку. Стоила как хороший ноутбук, делала как плохой смартфон. Пользователи получали уведомления на уровне браслета и фото из 2005 года. Памяти почти нет, батарея умирает быстрее, чем вы успеете сказать «Окей, Google».

Соучредитель Google Сергей Брин позже признал, что не понимал, как устроены поставки и насколько сложно произвести такие очки массово и недорого. И это многое объясняет: в Google Glass вложили идею, но не довели её до жизнеспособного устройства.

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

Некоторые считают, что Google Glass просто опередили своё время. Прототип показали ещё в 2013 году на Google I/O, а уже к 2015-му производство свернули. На практике очки оказались недостаточно удобными, многие обозреватели говорили, что они нелепо выглядят, а способов их применения никто так и не придумал. При цене в $1500 очки превратились в атрибут избранных гиков, а не в массовый гаджет.

По оценкам аналитиков, всего было продано не более 250 тыс. таких устройств, причем на старте Google отдала лишь 10 000 очков ограниченному кругу «избранных». Попасть к покупателю было сложно — очки продавали только по рекомендациям действующих владельцев. Функционально устройство не впечатляло: маленький прозрачный дисплей с разрешением 640×360, слабая 5-Мп камера, мало памяти и скромные 2–3 часа работы от батареи не соответствовали ожиданиям пользователей.

После провала на массовом рынке Google сменила стратегию на бизнес‑фокус. С 2014 года разрабатывалась корпоративная версия Glass Enterprise Edition, адаптированная для промышленных задач. Однако эти бизнес-успехи не спасли проект на массовом рынке, и Google окончательно закрыла проект в 2023 году.

На фоне фиаско Google Glass, современные игроки делают выводы — и действуют иначе. Ray-Ban Meta* (признана в России экстремистской организацией и запрещена) не обещают революцию — они интегрируют ИИ и камеру в повседневную форму очков. Не «будущее на лице», а стильный способ снять сторис и получить подсказки от ИИ. Apple Vision Pro, напротив, сознательно уходит в премиум и не обещает быть массовым — только для профессионалов, с чётким сценарием: дополнительный дисплей, работа с контентом и Facetime. А Android XR (например, от Samsung) с амбицией создать экосистему, куда подключаются другие производители.

Главные фейлы: почему хайп умер быстрее, чем мы успели надеть шлемы

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

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

IT-канал Awesome подробно рассказал об интересных особенностях Lua.

В видео рассказывают:

1. Что из себя представляет Lua.
2. Как выглядит базовый синтаксис языка.
3. Таблица — единственная структура данных, которая прекрасно обходится в одиночку.
4. Типов данных в Lua всего 8.
5. Как выглядит поток управления в Lua.
6. Стандартные библиотеки и API позволяют работать с другими языками, например с С.

Ниже — транскрибация ролика.

Если вы взглянете на диаграммы, показывающие самый быстрорастущий язык программирования в проектах с открытым исходным кодом, вас ждет большой сюрприз. Во-вторых, внимательно изучив Rust, вы обнаружите крошечный язык под названием Lua. Так в чем же дело? Почему Lua вдруг стал таким популярным и, что более важно, есть ли польза в его изучении? Давайте потратим несколько минут на исследование основных функций Lua и преимуществ, и к концу <...> вы увидите, что благодаря своей простоте и популярности Lua может стать ценным дополнением к вашему набору навыков.

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

Как выглядит программирование на Lua

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

Итак, Lua эффективен и легковесен, поскольку он опирается всего на 22 зарезервированных ключевых слова и 8 базовых типов. Еще более интересным, однако, является его подход к структурам данных. Здесь нет классов, структур, интерфейсов или трейтов. Нет массивов, списков или хэш-карт.

Единственным механизмом структурирования данных, доступным в Lua, является таблица. На первый взгляд это может показаться странным, но через секунду вы увидите, что эта базовая структура достаточно универсальна и мощна, чтобы удовлетворить все ваши потребности. Благодаря своей легковесности и низкому барьеру входа, Lua также можно легко встраивать в другие хост-клиенты, начиная от популярных игр, таких как Roblox, и заканчивая современными IDE, такими как NeoVim. Итак, давайте перейдем к самой интересной части и рассмотрим некоторый код.

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

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

В Lua функции являются значениями первого класса (first-class values), поэтому мы можем легко присоединять методы к нашему пользовательскому объекту. Язык довольно гибкий, и функция user.hello также может быть определена непосредственно в таблице.

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

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

Наконец, мы убедимся, что длина имени больше нуля, используя другой интересный оператор, и вызовем user.hello, если проверка пройдет успешно. Мы можем запустить этот код в терминале, вызвав команду lua, за которой следует имя файла:

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

Типы данных в Lua

В Lua существует восемь типов:

Строка, число, логическое значение, nil, не представляющий значения, таблицу, функцию, потоки и пользовательские данные. Все это довольно понятно само собой, за исключением, может быть, последних двух. Мы подробно обсудим их через секунду, но пока помните, что, несмотря на кажущуюся простоту, в Lua вы можете обрабатывать рабочие нагрузки с помощью «совместной многопоточности», а также вы можете хранить данные C и работать с ними с помощью пользовательских типов данных.

Lua — это язык с динамической типизацией, что означает, что переменные не имеют типов, а имеют только значения. В языке нет определений типов, и все значения имеют свой собственный тип.

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

Поток управления Lua

Далее давайте кратко рассмотрим поток управления Lua. Здесь все немного более подробно, но, тем не менее, просто. У вас есть доступ к вашим обычным операторам if-then-else, циклам while, а также к циклам repeat until, которые выполнят ваш код хотя бы один раз. Оператор for может быть числовым или общим, чтобы вы могли выполнять итерацию по значениям таблицы.

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

Однако имейте в виду, что мы говорим о языке 30-летней давности, и тенденции тогда были немного другими.

Таблица в Lua

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

а затем просто добавить поля, используя один из этих подходов:

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

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

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

Метатаблицы в Lua

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

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

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

Стандартные библиотеки Lua

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

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

Lua и С

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

В С-файле давайте убедимся, что у нас есть доступ к Lua API, а затем определим структуру Point. Функция new_point() позволяет нам создать экземпляр point, проверив данные, полученные из стека, и убедившись, что зарегистрировано новое значение пользовательских данных. Наконец, мы зарегистрируем функцию new_point() с помощью Lua, скомпилируем наш C-код, и мы должны быть готовы к работе.

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

Экосистема Lua

Наконец, давайте оценим экосистему Lua, чтобы понять, достаточно ли сторонней поддержки и необходимых библиотек, которые мы можем использовать, чтобы не изобретать велосипед заново. Lua предлагает простую модульную систему для упаковки кода и легкого обмена им, особенно благодаря менеджеру пакетов Luarox. Существуют различные успешные библиотеки, начиная от хорошо зарекомендовавших себя веб-фреймворков, таких как Lapis, и заканчивая серверами веб-приложений, такими как OpenResty. Сообщество также живо и вовлечено, и вы увидите различные эксперименты, такие как перенос языка шаблонов JSX на Lua или Moonscript, динамический язык сценариев, который компилируется в Lua.

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

Что такое интернет вещей, и из чего он состоит

Интернет вещей — система, которая объединяет с помощью проводных и беспроводных сетей (Wi-Fi, Bluetooth и т. д.) разные устройства, подключённые к интернету.

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

Архитектуру IoT обычно разделяют на несколько уровней:

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

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

Какие языки программирования востребованы в IoT

Каждый год компания Eclipse Foundation организует опрос IoT-разработчиков из разных стран и публикует исследование о трендах интернета вещей. В нём есть блок про языки программирования.

По итогам 2022 года:

• в топ-3 языков для программирования микроконтроллеров и встраиваемых устройств вошли C, C++ и Python;
• самыми популярными языками для создания программного обеспечения облачной инфраструктуры стали Java, C, C++, Python и JavaScript;
• Java, Python, JavaScript и C заняли первые места в топе языков для программирования шлюзов и пограничных узлов.

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

Java

Самый популярный язык программирования в сфере IoT. Причина проста — один раз написав код на Java, вы можете быть уверены, что он будет стабильно работать на любом другом устройстве (от смартфона до одноплатного микрокомпьютера).

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

Не стоит забывать и о том, что Java — объектно-ориентированный язык, поэтому на нём можно создавать код для облачной инфраструктуры и пограничных узлов. Для Java создано большое количество библиотек и инструментов безопасности, он отличается высокой скоростью работы.

При всех плюсах неудивительно, что на Java написан бэкенд нашего приложения для поддержания микроклимата «Цельсиум» и платформы MTS IoT HUB.

Python

Благодаря простому синтаксису и быстроте написания кода Python всё чаще используется в сфере IoT. Так как это интерпретируемый язык, он хорошо совместим с такими парадигмами, как объектно-ориентированное, структурное и функциональное программирование.

Кроме того, под Python создано множество библиотек для решения различных задач, например для машинного обучения и работы с данными. А для программирования микроконтроллеров есть специальный пакет MicroPython, который запускает Python непосредственно на «железе».

C

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

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

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

C++

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

Благодаря возможности создавать абстракции C++ отлично подходит для приложений Linux и программирования встраиваемых устройств.

Мы остановились на С++ для фронтенда приложения NB-IoT-тревожной кнопки Smart Click.

JavaScript

JavaScript — универсальный язык программирования, который можно использовать не только для создания фронтенда сайтов и веб-приложений.

Благодаря программной платформе Node.js, расширяющей возможности JavaScript, он также подходит для программирования датчиков, серверов и шлюзов.

Языки программирования для узких задач в сфере IoT

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

LUA

Довольно редкий язык программирования, который тем не менее часто используется в сфере IoT.

LUA — гибкий скриптовый язык, подходящий для создания приложений, ориентированных на портативность, экономию энергии и работу с большими объёмами данных. У него также есть фреймворк Node.lua, аналогичный Node.js.

Swift

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

Go

Golang, или Go, позволяет писать оптимизированный код, подходящий для устройств с низким энергопотреблением и небольшой памятью, поэтому набирает популярность в IoT.

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

Выводы

Нет сомнений, что IoT будет развиваться дальше, охватывая всё больше сфер нашей жизни.

✔ Если вы уже программируете на Python, Java, C или C++, поищите вакансии в компаниях, разрабатывающих устройства для интернета вещей.

✔ Если только планируете делать первые шаги в программировании, советуем освоить Python для решения большинства задач IoT или C/C++ для работы с «железом».

Мы собрали серию видеоуроков, которые познакомят детей с разработкой игр в Роблокс Студио и программированием на Lua. Короткие пошаговые уроки рассчитаны на начинающих разработчиков и будут полезны детям и подросткам: сначала мы изучим интерфейс программы и основы языка Lua, а затем создадим игры разных жанров. Попробуйте покопаться в Роблокс и сделать свои первые игры с помощью этого плейлиста.

Урок 0. Скачивание и установка Roblox Studio

Для начала давайте установим Roblox и Roblox Studio на компьютер. Подробная инструкция в видео.

Урок 1. Создание первой карты в Роблокс Студио

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

Урок 2. Основы Lua, первые шаги в создании игры

В этом уроке мы разберём, как создать скрипт на языке Lua. А также рассмотрим особенности этого языка, попробуем сделать небольшую программу. Кроме того, мы научимся делать спавн героя и создадим мини-игру в жанре шутера (стрелялки).

Урок 3. Создание уровней, циклы

Мы продолжим изучать язык программирования Lua и писать скрипты, познакомимся с понятием циклов. А также подробно разберём тему добавления уровней в игру, попробуем создать проект наподобие популярного LineRunner.

Урок 4. Создание первого уровня игры Obby

В этом видео мы познакомимся с понятиями условия и функции в программировании. В процессе создадим игру в жанре Obby — проект с полосой препятствий. И добавим в нее несколько уровней.

Урок 5. Создание диалогов в Роблокс

На этом занятии займёмся построением диалогов. Чтобы их осуществить, нам нужно добавить несколько второстепенных персонажей в наш «платформер».

Урок 6. Компоненты GUI в Roblox Studio

Простыми словами, GUI — это вспомогательные компоненты, благодаря которым мы можем делать интерфейс. В этом видеоуроке мы создадим игровое меню с помощью GUI.

Урок 7. Создание 3D-игры Capture the Flag

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

Урок 8. Продолжаем создавать игру Capture the Flag

Улучшим и доделаем нашу игру.

Урок 9. Повторение материала

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

На этом уроки по Roblox Studio и программированию Lua для начинающих завершены, теперь вы умеете делать все самое основное!

Язык программирования Lua появился в 1993 году. По своей структуре он является компактным языком программирования, который можно встраивать практически в любое приложение — от World of Warcraft до веб-сервера Nginx. Ну и конечно же, в Redis, о котором далее и пойдёт речь.

Благодаря Lua в Redis возможно встраивать собственные скриптовые расширения для базы данных. Вызов скриптов выглядит следующим образом:

Далее сам Lua-скрипт:

Что более важно, вы можете запускать скрипты в качестве “умных транзакций”. Это позволяет обрабатывать ошибки в рантайме, не останавливая приложение. Безусловно, то, насколько “умными” будут эти транзакции, зависит целиком и полностью от вас.

Ключи и аргументы

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

В конце EVAL мы видим ноль — это количество ключей, переданных скрипту. Но если вместо ноля написать 2 foo bar fizz buzzthen, первые два элемента foo и bar будут переданы в качестве ключей, а fizz и buzz — в качестве аргументов.

Ключи доступны Lua-скрипту в таблице KEYS. Таблица в Lua — это ассоциативный массив, который также используется в качестве массива из одного элемента. Если помимо ключей используются аргументы, они будут доступны в таблице ARGV, например:

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

Никакой магии в KEYS, это просто строка, так что нам по-прежнему нужно получить их значение.

Что касается вызова Redis из Lua, можно использовать функцию redis.call(). Например:

Прим. автора Если в процессе объединения вы получаете ошибку “attempt to concatenate a boolean value” (попытка объединения значений булевого типа), скорее всего name:first не было присвоено какое-либо значение.

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

Однако помимо EVAL есть и другой способ передать скрипт на сервер. Например, используя аргументы команды redis-cli. Попробуем написать чуть более сложный скрипт:

Сохраним его как longhello.lua и выполним в командной строке:

Итак, мы запускаем redis-cli, добавляем параметры -h, -p и -a для связи с базой данных. Затем идёт --eval, позволяющий указать имя файла, в виде которого скрипт отправится на сервер. Также нашему скрипту понадобятся ключи и аргументы. В данном случае ключами являются указанные до первой запятой параметры команды.

Сложные скрипты

Следующий случай наглядно демонстрирует, как Lua решает одну небольшую проблему. Допустим, разные пользователи или разработчики увеличивают счётчики в большой структуре данных. Например, region:one увеличивает count:emea, count:usa, count:atlantic, в то время как region:two затрагивает лишь count:usa. Эти счётчики могут быть добавлены позже, но вдруг вам важно убедиться, что добавятся они все разом? Самое время вспомнить про “умные транзакции”.

Добавим все наши регионы в список:

Создадим локальную переменную:

Начнём с переменной-счётчика — он будет считать все операции по увеличению наших округов.

Теперь запросим у Redis все значения списка, относящиеся к первому ключу.

Здесь мы запустили цикл, в котором функция ipairs() просмотрит каждую задействованную Lua-таблицу и передаст из неё ключ.

С каждым вызовом мы увеличиваем указанный ключ, а заодно и наш счётчик.

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

В таблице будут содержаться следующие значения:

Значения для region.two:

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

Кэширование скриптов

Для того чтобы не загружать скрипт каждый раз перед выполнением, можно использовать команду SCRIPT LOAD для загрузки скрипта в кэш. Рассмотрим пример использования из командной строки:

Здесь $(cat broadcast.lua) превращает наш скрипт в аргумент. А шестнадцатеричное число ниже — SHA1-подпись нашего скрипта. Её можно использовать для его последующего вызова командой EVALSHA:

Также есть команды для проверки наличия скрипта на сервере и его удаления – SCRIPT EXISTS и SCRIPT FLUSH соответственно.

Не всё так просто

После довольно небольшого промежутка времени (по умолчанию — 5 секунд) Lua-скрипты начнут выдавать ошибки в ответ на запросы — в таком случае возможно только “убить” скрипт командой KILL SCRIPT либо выключить сервер командой SHUTDOWN NOSAVE. С другой стороны, 5 секунд — очень щедрое ограничение, ведь ваши скрипты должны выполняться буквально в течение миллисекунд. И на это есть очень веская причина: во время выполнения ваших скриптов все остальные процессы приостанавливаются.

Заключение

Итак, в этой статье мы рассмотрели примеры написания простых и сложных Lua-скриптов, их вызов из Redis, а также запись и хранение на сервере.

Новая атака

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

Интерфейс WoW и его дополнения написаны на скриптовом языке Lua. Обе части вышеуказанного равенства являются рабочими функциями WoW Lua API. Исполнение этой строчки кода меняет поведение интерфейса.

Что делает эта команда?

• /run  — это команда воспринимать следующий текст как скрипт Lua;
• RemoveExtraSpaces — встроенная функция, удаляющая лишние пробелы;
• RunScript — функция, исполняющая код Lua code (аналогично /run)

Почему это опасно?

Функция RemoveExtraSpaces применяется к каждому полученному в чате сообщению. Вышеуказанная команда заменяет эту функцию на функцию RunScript, что называется перехватом. После этого все сообщения в чате воспринимаются как код Lua и исполняются.

Этим было доказано существование уязвимости. Таким образом, этот способ чем-то похож на использование троянов.

Подробнее об этой уязвимости читайте здесь.

• с управлением сцен;
• с таймерами;
• с перемещением героев;
• со встроенным физическим движком.

Также мы узнаем, как использовать модули для эмуляции классов на языке программирования Lua. Прилагаем полный список всех статей в этой серии:

1. Настройка проекта.
2. Реализация геймплея. Часть 1
3. Реализация геймплея. Часть 2
4. Заключение

Создание проекта

Откройте Corona Simulator, нажмите New Project и сконфигурируйте проект так, как показано на изображении ниже. Не забудьте выбрать папку для сохранения проекта и нажмите OK. После этого создастся указанная вами папка, которая будет содержать ряд иконок и три особенно важных файла: main.lua, config.lua и build.settings. Мы поговорим о каждом из них чуть позже.

Настройка сборки

Файл build.settings, как несложно догадаться, отвечает за настройки сборки проекта. Откройте этот файл и удалите его содержимое, вместо которого напишите следующее:

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

Настройка приложения

Файл config.lua отвечает за настройки самого приложения. Откройте этот файл, также удалите его содержимое, вместо которого напишите следующее:

Здесь все просто: мы устанавливаем размер рабочего пространства и задаем частоту кадров. Все подробности в официальной документации.

Примечание переводчика Стоит отдельно рассказать про третью строчку, в которой устанавливается масштаб. Параметр scale может принимать различные значения ("letterbox", "zoomEven", "adaptive" и т.д.). Автор статьи использует "letterbox", и это означает, что если размер экрана отличается от установленного нами, то изображение наше будет масштабироваться до тех пор, пока оно целиком входит в экран. Иными словами, если окно будет размером 800×1024, то слева и справа от изображения будут черные полосы. Проще увидеть, чем прочитать:

Точка входа

Файл main.lua является точкой входа в приложение. Мы будем использовать этот файл для того, чтобы установить несколько параметров по умолчанию и загрузить первый экран при помощи библиотеки Composer.

Если вы не знакомы с Composer, то мы вам настоятельно рекомендуем прочитать официальную документацию по библиотеке по этой ссылке. Если говорить о ней вкратце, то Composer — встроенный в Corona инструмент для управления сценами.

Вышеупомянутая библиотека достаточно новая, она заменяет уже устаревшую StoryBoard.

Статус бар

В игре статус бар не особо-то и нужен, а потому мы уберем его. Для этого следует в файле main.lua прописать следующий код:

Точка привязки

Когда мы указываем координаты для некоторого объекта, мы должны учитывать точку привязки, в качестве которой удобнее всего использовать центральную точку. Для этого добавьте в main.lua:

Значения параметров anchorX и anchorY лежит в диапазоне от 0 до 1. Отсчет начинается слева и сверху. Например, если вы хотите указать в качестве точки привязки левый верхний угол, то выставьте оба значения в нули.

Зерно генерации

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

Хорошим параметром для зерна генерации может послужить функция os.time, которая будет различной при каждом запуске приложения. Для определения этого параметра напишите следующий код:

«Нет» глобальным переменным

При использовании Corona и, в частности, языка программирования Lua (да и не только Lua) используют глобальные переменные для того, чтобы расширить область их видимости. Чтобы объявить глобальную переменную в Lua, достаточно убрать ключевое слово local перед ее именем.

Например, в следующем блоке кода объявляются две переменные, первая из которых локальная (она видна только в той функции, в которой объявлена), а вторая — глобальная (она видна в любом месте файла после объявления).

Но использование глобальных переменных, как правило, считается плохой практикой: могут возникнуть конфликты между двумя переменными с одним и тем же названием. Мы можем решить эту проблему с помощью модулей. Создайте новый Lua файл, назовите его gamedata.lua и добавьте в него следующий код:

Мы попросту создали таблицу и вернули ее. Для того, чтобы использовать этот код, мы воспользуемся методом require. Добавьте этот код в main.lua:

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

Всякий раз, когда мы хотим получить эти переменные, мы должны вызвать функцию require, чтобы загрузить gamedata.lua. Каждый раз, когда мы загружаем модуль при помощи вышеупомянутой функции, сам модуль помещается в таблицу package.loaded. При следующем запросе игровые данные не будут заново прогружаться, а попросту извлекутся из кэша.

Загружаем Composer

Прежде чем воспользоваться модулем Composer, его нужно «затребовать». Добавьте в main.lua следующий код:

Первая сцена

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

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

Запуск сцены

Итак, давайте создадим файл start.lua, в которой и опишем нашу первую сцену. Как уже говорилось выше, для того, чтобы управлять сценами, нам потребуется модуль Composer — самое время его подключить. Добавьте следующий код в start.lua:

Вызов метода newScene сделает start.lua частью иерархии сцен модуля Composer. Именно поэтому все то, что мы хотим увидеть в первой сцене, должно быть написано между этой строчкой и ключевым словом return.

Локальные переменные

Вот те переменные, которые нам потребуются в файле start.lua:

Важно помнить, что эти строчки будут вызваны лишь единожды. А дальше при вызове метода gotoScene эти переменные уже будут проинициализированы.

Есть несколько способов, как сделать так, чтобы переменные каждый раз переинициализировались. Мы будем использовать самый простой способ: удалим сцену из иерархии модуля Composer с помощью метода removeScene. В этом уроке мы будем использовать именно такой подход.

Мы также будем использовать два кастомных модуля: pulsatingText и starFieldGenerator. Создадим два новых файла в папке проекта с названиями pulsatingtext.lua и starfieldgenerator.lua.

События сцены

Если вы нашли время и прочитали документацию, ссылку на которую мы прилагали в начале статьи, то вы наверняка заметили шаблон, содержащий все возможные события модуля Composer. К каждому событию прилагается комментарий, в котором указывается, для чего оно используется. Нас интересуют следующие функции: scene:create, scene:show и scene:hide.

Шаг 1: scene:create

Добавьте этот отрывок кода в файл start.lua:

Этот метод вызывается, когда сцена еще не существует. Здесь вы должны проинициализировать все переменные и объекты и добавить их на сцену. Переменная group, являясь экземпляром класса GroupObject, указывает на саму сцену, и именно «на нее» добавляются все изображения и другие визуальные элементы.

Мы создаем кнопку startButton при помощи метода newImage объекта класса Display. Сама функция принимает в качестве аргументов путь к изображению и координаты будущей кнопки.

Шаг 2: scene:show

Этот метод имеет 2 фазы. Фаза will вызывается, когда сцена по-прежнему еще не на экране, но вот-вот будет. Фаза did вызывается, когда сцена уже появилась и видна пользователю. Именно во второй фазе мы и будем «оживлять» нашу игру: запустим таймеры, добавим слушателей, начнем проигрывать музыку и т.д.

В этом уроке фаза will нам не понадобится.

Мы объявляем локальную переменную phase, в которую и записываем текущую фазу выполнения метода. Так как позднее мы будем к этой сцене возвращаться, то проверим, есть ли предыдущая сцена, и если она есть — удаляем ее. Также мы добавляем слушателя для кнопки startButton (при ее нажатии вызовется метод startGame).

Шаг 3: scene:hide

Метод hide тоже имеет две фазы: will и did. По смыслу они такие же, как и в scene:show. Во время выполнения фазы will мы будем останавливать таймеры, удалять слушателей различных событий, останавливать музыку и т.д. Фаза did вызывается ровно один раз, когда сцена исчезает с экрана. В наших статьях она нам не понадобится.

Начало игры

Функция startGame вызывается тогда, когда игрок нажимает на кнопку startButton. В этом методе мы будем вызывать gotoScene и переходить к сцене gamelevel.

Игровая сцена

Создайте новый файл с именем gamelevel.lua и добавьте в него следующий код:

Все знакомо, не правда ли? Да, мы здесь попросту создаем новую сцену.

Слушатель сцен

Теперь нам следует добавить слушателя сцен для методов create, show, hide. Для этого напишем в start.lua:

Запуск

Если вы в данный момент запустите игру, то увидите черный экран с одной кнопкой — это сцена start. При нажатии на кнопку вы попадете на другой экран, который пока полностью пустой — это сцена gamelevel.

Вывод

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

Перевод статьи «Create a Space Invaders Game in Corona: Project Setup»