Как составить игру лабиринте

Как создавать уникальные лабиринты

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

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

▍ Небольшое лирическое предисловие

Предыстория: почему же так получилось, и как же я дошёл до того, что буду описывать далее. Когда-то давно, во времена старших классов в школе, я разрабатывал модификацию на движке Source, которая, увы, релиза своего не увидела (но возможно у меня хватит желания и смелости продолжить всё уже на UE). Но дала небольшой опыт в игровой индустрии, а также тему для дипломных работ и научных статей.

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

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

▍ Задача генерации лабиринта

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

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

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

▍ Первый (и неинтересный) вариант генерации лабиринта

Первые шаги в построении нового алгоритма были довольно примитивными. Для начала, исходя из материалов данного сайта, был выбран базовый алгоритм построения лабиринта — алгоритм Уилсона. Он довольно прост в реализации и понимании, но главное — довольно быстрый, не имеет тенденций делать похожие лабиринты, а также гибок в настройке. То есть даже если ограничить область лабиринта не прямоугольным полем, а в виде буквы «Г», то алгоритм прекрасно сработает.

Как работает алгоритм Уилсона наглядно:

Именно такое свойство было базой для первого варианта алгоритма. Прямоугольное поле для лабиринта разделяется на три области: среднюю (1), внутреннюю (2) и внешнюю (3). В каждой из них генерируется лабиринт алгоритмом Уилсона (в средней части со своими особенностями) отдельно. А после этого достаточно сделать два и более прохода между внешней и средней областью. Картинка ниже наглядно показывает весь процесс.

Та генерация, которая «неинтересная»:

Формально мы получаем лабиринт с двумя и более проходами, а количество проходов зависит только от того, сколько точек доступа мы сделаем между средней и внешней областью. Более того, даже по длинам путей всё получалось более-менее прилично. Но всё же, есть существенные недостатки. Например, очевидно то, что все пути обязательно будут проходить через центральную его часть, или же то, что вход и выход из лабиринта обязаны быть на крайних точках, причём в противоположных сторонах. Вдобавок, алгоритм не рассчитан на построение маленьких лабиринтов, то есть сгенерировать мини-лабиринт 10×10 «толстых» клеток у нас не получится. В конце концов, слабо контролируется число пересечений путей, а также визуально выделяются длинные стенки между внешней и средней областью.

Если интересно что такое тонкие и толстые клетки:

Несмотря на не самый красивый результат, алгоритм всё же есть в наличии. Теперь было бы неплохо прикрутить к нему поиск получаемых путей. И здесь тоже встал вопрос эффективного их нахождения. Ведь если почитать про все алгоритмы нахождения путей в лабиринте, то ни один из них не даёт гарантий в нахождении абсолютно всех путей. Какие-то рассчитаны только на один, какие-то могут пропустить «пару-тройку». Поэтому и здесь пришлось разрабатывать новое.

По итогу за основу был взят самый обыкновенный муравьиный алгоритм, но с некоторыми изменениями в «концепции». Один за другим, муравьи ищут новые пути. Один муравей равен одному возможному пути. «Возможному» означает, что по достижении выхода путь текущего муравья будет сравниваться с уже имеющимся на предмет повторения. Каждый муравей рассматривает до четырёх возможных направлений (все 4 могут быть, например, в точке старта).

Куда может ходить муравей:

Следующее и основное изменение заключается в использовании феромонов. Во-первых, они будут использоваться только на развилках. Во-вторых, было убрано испарение феромонов. В-третьих, сам расчёт феромонов, представляющий из себя вероятность выбрать то или иное направление, преследует цель увеличения вероятности для нового муравья выбирать менее популярный путь, дабы быстрее находить новые вариации прохождения. В дополнение к этому, тупиковые ветки автоматически обнуляли вероятность такового направления, а также был проработан случай зацикливания муравья на своём же пути. Далее был проведён эксперимент с целью найти оптимальное количество муравьёв для любого варианта лабиринта. Как уже было упомянуто, зависит оно от числа тех вырезов, которые мы сделали в конце алгоритма. Конечно, оптимальные цифры не самые приятные, муравьёв требуется немало, но зато это гарантированное нахождение всех путей (ну почти, при 8 вырезах уже есть небольшой шанс потерять пару путей, поэтому было рекомендовано использовать цифры 2, 4 и 6).

Много цифр! Результаты эксперимента (к первому столбцу прибавляем 2):

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

Итого, первая часть закончена, решение получено, пусть оно громоздкое и неказистое.

▍ Второй вариант генерации лабиринта

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

И идея для него родилась непосредственно из алгоритма поиска путей: а что если использовать именно алгоритм на базе муравьиного? Более того, следом за этой мыслью пришла другая — а может строить лабиринт наоборот? Сначала пути, а потом тупиковые ветви. Во-первых, это избавит от дальнейшего поиска путей, а во-вторых, можно вносить коррективы в лабиринт по мере его генерации. Более подробную информацию о подходе, выведенных формулах и тестировании можно прочитать в моей статье, которая, (возможно) к сожалению, только на английском языке. Здесь же я хочу рассказать на более простом и понятном языке основные моменты, без разбора громоздких формул (а финальная вероятностная формула получилась довольно большой).

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

С таким подходом у нас появляются дополнительные возможности. Мы можем в любой момент отследить количество пройденных клеток, то есть строить пути определённой длины (или близкой к некоторому числу). Число данное мы можем либо вводить, что не совсем корректно, так как пользователь не может без дополнительных расчётов понимать каким оно может быть и каким быть не должно. Либо же автоматически высчитывать эту длину исходя из размеров лабиринта. Добавим к вычисленному значению некоторую дельту, допустим, длина пути минус 2 клетки. И теперь мы знаем сразу и количество пройденных клеток, и необходимую длину пути, что даст нам возможность влиять на его дальнейшее построение.

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

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

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

▍ Про то, как сделать уникальный тип лабиринтов

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

1. Пути нашего лабиринта были достаточно «извилистыми».
2. У лабиринта было как можно меньше пересечений.
3. Не было нечестного короткого пути.
4. Построенные пути максимально эффективно использовали поле лабиринта.

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

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

Пример:

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

Почему без пересечений нельзя:

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

Про читерство (осуждаем):

Последний пункт тоже проиллюстрируем. Необходимо стараться использовать всю данную площадь. Объясняя на примерах — только в правом нижнем варианте максимально эффективно используется поле лабиринта.

Про эффективность поля:

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

▍ Чем подход интересен и какие у него подводные камни

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

Примеры изъянов:

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

Метод, использованный мною, оказался достаточно эффективным по получаемым результатам, но, к сожалению, не самый эффективный по времени работы. Были введены колонии. То есть, после получения первого пути, для дальнейших итераций алгоритма генерировалось некоторое количество вариантов путей, после чего из всех выбирался один наилучший. Экспериментально было выявлено, что 20 вариантов достаточно, чтобы один из них был наилучшим. В качестве критериев оценки — наши «правила правильного лабиринта», переведенные в цифры. Количество смен направлений и пересечений считать не надо даже. А вот эффективное использование поля — это, так сказать, поле для размышлений. Я остановился на следующем варианте: Для каждого i-го пути из колонии возможных новых путей считаем сумму расстояний j-й клетки этого пути и j-й клетки остальных уже построенных путей. Остатки более длинного пути можно просто не трогать. Пожалуй, здесь было бы понятнее объяснить процесс формулой:

где

— множество уже построенных путей,

— минимум из длин i-го пути колонии и t-го пути из уже построенных,

— j-я клетка i-го пути из колонии,

— j-я клетка t-го пути из множества

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

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

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

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

▍ Выводы

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

Для более подробного ознакомления со всей разработкой есть три моих статьи:

К слову о программе. Я долго размышлял, стоит ли её показать, очень не хотелось, потому что до релиза ей далеко, у неё много багов, недоработок, хотя с генерацией небольших лабиринтов она справляется хорошо (лично у меня после разных проверок нашлись странные моменты, которые раньше работали, а сейчас почему-то нет, возможно, из-за Win11). Но я всё же выложу её здесь и буду стараться потихоньку исправлять баги и дорабатывать её.

Если же скачивать и пробовать чужую кривую прогу не хочется, то есть короткий ролик, демонстрирующий основные функции программы: генерация лабиринта с разными характеристиками, рисование лабиринта на поле «своими руками» и прохождение 2D/3D лабиринта.

Видео-демонстрация:

Приступаем
к работе.

Запускаем
программу Kodu Game Lab, в
открывшимся окне выбираем вкладку «NEW WORLD».

Рис. 3 – Создание пустого мира

После
нажатия на «NEW WORLD»
открылась рабочая плоскость. В нижней части находится панель взаимодействия с
миром.

Рис. 4 – Рабочая плоскость

Нижняя
панель имеет следующие компоненты:

·        
Главное меню

·        
Играть

·        
Перемещает камеру

·        
Объект

·        
Путь

·        
Кисть для земли

·        
Вверх/вниз

·        
Сглаживание

·        
Неровности

·        
Вода

·        
Удалить

·        
Изменяет параметры мира

Создание компьютерной игры «Лабиринт» состоит из
нескольких пунктов:

1.     
Создание лабиринта;

2.     
Создание «Байкеров»;

3.     
Программирование «Байкеров»;

4.     
Тестирование игры.

Так как, по умолчанию при создании игры рабочая
плоскость имеет зеленый цвет, мы ее изменим. Для этого в панели инструментов
выберем «Кисть».

Кисть – для
земли. Рисует, добавляет или удаляет землю.

Рис. 5 – Кисть для земли

В левой части над «Кистью», располагаются
четыре квадрата, нажав на которые появляется возможность выбрать цвет рабочей
плоскости, на которой мы работаем.

Рис. 6 – Выбор цвета рабочей области

Наводим
мышку с мерцающим квадратом на рабочую плоскость и нажимаем один раз.

Рис. 7 – Смена цвета рабочей плоскости

Далее мы выбираем новый цвет, тем
же способом, каким ранее изменили цвет рабочей плоскости. – Рис 8.

В панели задач, над «Кистью»
располагается с левой стороны выбор цвета для рабочей плоскости, а справа
выбор способа нанесения цвета на рабочую плоскость. – Рис 9.

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

Рис. 8 – Чертеж
Лабиринта

Рис. 9 –
Выбор элемента «Длинная прямая кисть» для черчения Лабиринта

Далее выбираем «Вверх/вниз – создает холмы и
долины». – Рис 10. Над элементом «Вверх/вниз» находятся четыре фигуры,
нажимаем на них и выбираем «Волшебная кисть» – Рис. 11. После, правой
кнопкой мыши нажимаем на нарисованный вторым цветом чертеж и держим, до
нужного нам увеличения стен.

Рис. 10 – Вверх/вниз

Рис. 11 – «Вверх/вниз» Волшебная кисть

Рис. 12 – Создание возвышения №1

Рис. 13 – Создание возвышения №2

Для создания новых объектов, на панели задач
воспользуемся элементом «Объект» – элемент с помощью которого
происходит создание и добавление различных персонажей и новых объектов.

Рис. 14 – Объект

Выбрав «Объект» нажимаем правой кнопкой мыши
на рабочей плоскости и выбираем «Добавить объект».

Рис. 15 – Добавление объекта «Байкер» №1

В
появившимся круглом меню, находим «Байкера».

Рис. 16 – Добавление объекта «Байкер» №2

Рис. 17 – Добавление объекта «Байкер» №3

После добавления и появления объекта «Байкер» на
плоскости, он имеет большой размер. – Рис 18.

Рис. 18 – Байкер

Для изменения размера Байкера, нажимаем на него
правой кнопкой мыши – «Изменить размер».

Рис. 19 – Изменение размера Байкера №1

В
появившийся шкале «Размера» уменьшаем наше значение до 0,2.

Рис. 20 –
Изменение размера Байкера №2

Динамическая пауза

https://www.youtube.com/watch?v=Wcr4ZB_4Iqo

Продолжаем нашу работу. Правой кнопкой мыши нажимаем
на нашего Байкера и выбираем «Программа».

Рис. 21 – Программа

В чем будет заключаться суть нашей игры:

У нас есть лабиринт в конце которого находится
яблоко. Мы играем за Красного Байкера (Доброго), которому нужно преодолеть лабиринт
и не столкнуться со «Злыми Байкерами» – докоснувшись до которых «Игра
закончена» и мы проиграли.

Если же нам удалось пройти лабиринт, увернуться и
уехать от всех «Злых Байкеров», а также найти и докоснуться до яблока, то
тогда мы победили.

Программа
для «Злых Байкеров».

Рис. 22 – Программа для «Злых Байкеров»

Программа
для «Доброго Байкера».

Рис. 23 – Программа для «Доброго Байкера»

Схема
расположения Байкеров:

«Злые
Байкеры» – красные кружки – 7 штук.

«Добрый
Байкер» – желтый кружок, представлена на Рис. 24.

Для того, чтобы в программа различала байкеров между
собой, Главного Байкера, за которого будем играть мы, сделаем красным цветом.
– Рис. 25.

Рис. 24 – Схема расположения Байкеров

Рис. 25 – Выбор цвета Главного байкера

Добавим в конец лабиринта «Яблоко» – которое и будет
символизировать победу в случае если главный байкер докоснется до него.

Правой кнопкой мыши на рабочей плоскости, где хотим,
чтобы появилось «Яблоко». Далее «Добавить объект», находим «Яблоко».

Рис. 26 – Создание Яблока

Если
«Злые Байкера» дотронутся до «Главного байкера» появится окно о поражении.

Рис. 27 – Game over

Если все же «Главный байкер» сумел добраться до
Яблока и коснуться его, появится окно, о победе.

Рис. 28 – Winner

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

Такая интерактивная игра может использоваться:

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

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

Рассмотрим порядок создания игры “Лабиринт”.

Идея игры взята из курса по робототехнике «Робокласс». Игровые персонажи — инфики: ВсеЗнайка, Самоделкин, Кибернетик. Графические объекты — элементы LEGO Mindstorms. Школьнику необходимо преодолеть лабиринт, отвечая на вопросы, которые ему задают инфики. В случае правильного ответа на все вопросы лабиринт будет пройден.

1. Разберем подробно этап создания игры в программе PowerPoint.

А. Формируем лабиринт с помощью каких-либо графических фигур и рисунков. Это может быть множество колес или иные объекты. Добавим фоновое изображение — шестерёнку.

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

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

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

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

Итак, все слайды готовы. Не забудьте похвалить школьника, успешно прошедшего лабиринт.

2. Публикуем созданную интерактивную игру с помощью программных продуктов iSpring. Теперь эту игру можно разместить в интернете или использовать на занятии в компьютерном классе.

Пример игры доступен здесь.

Did this article help you?