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

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

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

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

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

Продукции (наряду с сетевыми моделями) являются наиболее популярными средствами представления знаний в информационных системах. В общем виде под продукцией понимают выражение вида A ® B. Обычное прочтение продукции выглядит так: ЕСЛИ А, ТО B. Импликация может истолковываться в обычном логическом смысле, как знак логического следования B из истинного А. Возможны и другие интерпретации продукции, например, А описывает некоторое условие, необходимое, чтобы можно было совершить действие B.

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

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

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

Сильные стороны систем продукций:

- модульность;

- единообразие структуры (основные компоненты продукционной системы могут применяться для построения интеллектуальных систем с различной проблемной ориентацией);

- естественность (вывод заключения в продукционной системе во многом аналогичен процессу рассуждения эксперта);

- гибкость родовидовой иерархии понятий, которая поддерживается только как связь между правилами (изменение правила ведет за собой изменение в иерархии);

- простота создания и понимания отдельных правил;

- простота пополнения и модификации;

- простота механизма логического вывода.

Слабые стороны систем продукций:

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

- сложно представить родовидовую иерархию понятий;

- неясность взаимных отношений правил;

- сложность оценки целостного образа знаний;

- отличие от человеческой структуры знаний;

- отсутствие гибкости в логическом выводе.

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

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

3.3 Анализ и выбор среды разработки игрового приложения виртуальной модели

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

3.3.1 Corona SDK

Corona SDK -- средство кроссплатформенной разработки для Android/iOS от Ansca Mobile (основатели компании в прошлом работали в Adobe над Flash Lite) [19]. Corona SDK предназначен прежде всего для разработки игр, но нем можно писать и бизнес-приложения -- для этого в движке есть набор UI-компонентов со сменными стилями. Главным преимуществом движка является значительное увеличение скорости разработки для опытных программистов, а также снижение технического барьера для новичков в мобильном gamedev'е.

Плюсы Corona SDK:

- разработка на простом и элегантном динамическом языке -- Lua

- симулятор позволяет видеть сделанные изменения моментально

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

- компактный и интуитивный API

- качественная документация от разработчиков движка

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

- стабильность и скорость движка

- быстрое исправление ошибок разработчиками -- у многих это самое слабое звено (например, с Titanium Mobile мои баг-репорты висели в баг-трекере месяцами, с Сorona -- от пары дней, до пары недель)

Минусы Corona SDK:

- лицензия $200-350/год (все вышеперечисленные средства бесплатны)

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

- критичный к быстродействию код все равно придется писать на Lua, если нет соответвующей функции в API движка, или искать обходные пути (они, как правило, есть)

- некоторые различия в функционале версий для Android и iOS (например, платежи внутри приложения поддерживаются пока только на iOS)

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

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

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

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

3.3.2 Unreal Engine

Unreal Engine -- игровой движок, разрабатываемый и поддерживаемый компанией Epic Games.

Написанный на языке C++, движок позволяет создавать игры для большинства операционных систем и платформ: Microsoft Windows, Linux, Mac OS и Mac OS X; консолей Xbox, Xbox 360, Xbox One, PlayStation 2, PlayStation 3, PlayStation 4, PSP, PS Vita, Wii, Dreamcast, GameCube и др., а также на различных портативных устройствах, например, устройствах Apple (iPad, iPhone), управляемых системой iOS и прочих. (Впервые работа с iOS была представлена в 2009 году, в 2010 году продемонстрирована работа движка на устройстве с системой webOS).

Для упрощения портирования движок использует модульную систему зависимых компонентов; поддерживает различные системы рендеринга (Direct3D, OpenGL, Pixomatic; в ранних версиях: Glide, S3, PowerVR), воспроизведения звука (EAX, OpenAL, DirectSound3D; ранее: A3D), средства голосового воспроизведения текста, распознавание речи), модули для работы с сетью и поддержки различных устройств ввода.

На данный момет функционально UE, блаодаря Blueprints (визуальное программирование), мощному редактору материалов и ИИ впереди своих конкурентов. У других движков нет возможности использовать удобное визуальное программирование, сильно сокращающее затраты времени. Новые параметры постоянно добавляются, коммьюнити создаёт собственные блюпринты, которые невозбранно можно использовать. А если этого мало, то С++ в помощь, с его помощью можно сделать всё, что угодно. Есть модуль для добавления Шарпа, что облечгает переходит Unity-разработчиков.

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

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

3.3.3 Game Maker

Game Maker -- один из самых известных конструкторов игр. Написан на Delphi. Доступен для ОС Windows, 7-я версия программы также существовала в версии для Mac. Ведущий разработчик -- Марк Овермарс.

Система рассчитана в основном на создание двухмерных (2D) игр любых жанров. Также подойдёт для создания различных презентаций и т. п. Начиная с 6-й версии появилась ограниченная возможность работать с 3D.

Может быть рекомендован для изучения программирования. Будучи профессором Утрехтского университета, Марк Овермарс начал разрабатывать Game Maker как учебное пособие для своих студентов.

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

Язык программирования, GML, дает гораздо больше гибкости и контроля, чем стандартные действия, которые доступны через Drag'n'Drop интерфейс. Есть много различных мест, где можно использовать этот язык для создания и управления в вашей игре. Сам язык имеет синтаксис от js, php, pascal. Собственно можно писать как на одном из этих языков, что не может не радовать.

Плюсы:

- кроссплатформенность;

- гибкая ценовая категория и невысокие цены;

- собственный язык программирования Game Maker Language (GML);

- интеграция со Steam;

- поддержка множества интернет-площадок «из коробки» (Developer Services Portal);

- поддержка Шейдеров

- интеграция с Facebook

- поддержка работы с сетью (TCP/IP и Bluetooth)

Минусы:

- плохо оптимизирован для больших игр (эту проблему может решить YoYo Compiler);

- разработчики перестали развивать режим 3D вообще;

Так же имеется удобные и функциональные редакторы игровых ресурсов. Стоит отметить сохранившеюся частичную совместимость со старыми проектами Game Maker.

3.3.4 Construct 2

Construct 2 позволяет каждому желающему создавать 2D-игры любой сложности и любого жанра, даже не имея навыков программирования. Игры, сделанные на нём, легко портируются на все основные платформы -- PC, Mac, Linux, браузеры с поддержкой HTML5, Android, iOS, Windows Phone, Blackberry 10, Amazon Appstore, Chrome Web Store, Facebook и пр. Поддержка iOS и Android осуществляется благодаря технологиям CocoonJS от Ludei, directCanvas от appMobi и Intel XDK, которые используют аппаратное ускорение для увеличения производительности HTML5 игр в 5-10 раз [20].

Интерфейс программы интуитивно понятен и прост в освоении, благодаря визуальному WYSIWYG-редактору от человека не требуется знаний программирования и опыта в разработке игр, в ней может разобраться даже ребёнок. Логика игр в Construct 2 создается с помощью системы событий (англ. events) и связанных с ними действий (англ. actions).

Для овладения Construct 2 требуется лишь базовый опыт работы с ПК и немного усилий. Вдобавок, постоянные обновления делают использование программы достаточно безопасным.

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

На рисунке 3.1 представлен основной интерфейс программы.

Рисунок 3.1 - Основной интерфейс «Construct 2»

По большому счёту, Construct 2 является улучшенной версией программы Construct Classic, имеет больше возможностей, а также умеет портировать игры на огромное количество мобильных платформ и не только. Движок был создан в 2007 году и за 10 лет сильно изменился.

Да, Construct 2 является условно-бесплатным конструктором игр, однако, полная версия программы со всеми возможностями обойдётся вам всего в $119. Хотя, если вы хотите ознакомиться с основными функциями и особенностями конструктора, вам хватит бесплатной версии.

Интерфейс программы максимально прост. Присутствует два основных окна: «layout» и «event sheet». «Layout»- это ваш уровень. Здесь вы можете расставить предметы, врагов. «Event sheet»- это лист событий, всё, что будет происходить на данном уровне. Хочется заметить, что каждый «layout» закреплён к определённому «event sheet», что на практике очень удобно.

В программе также используется продукционное программирование. Присутствует «Condition»- условие и «Action»- действие, которое произойдёт, если будет выполнено условие.

Вы сможете добавить к вашим игровым объектам много поведений (Behaviors). Например, если вы делаете 2D платформер, вам не нужно прописывать код для вашего персонажа, про добавьте ему поведение «Platform». У него автоматически появится гравитация, он сможет прыгать и бегать на установленные вами клавиши.

Плюсы:

- доступен каждому;

- прост в использовании;

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

- постоянные обновления;

- быстрое тестирование проектов;

- кроссплатформенность.

Минусов за время работы замечено не было.

4. РАЗРАБОТКА АЛГОРИТМОВ ПОСТРОЕНИЯ ВИРТУАЛЬНОЙ МОДЕЛИ ПРЕДМЕТНОЙ ОБЛАСТИ

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

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

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

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

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

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

Третье правило -- дискретность. Алгоритм строится из отдельных шагов (действий, операций, команд). Точнее -- из множества шагов.

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

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

4.1 Алгоритм динамической настройки сложности

Алгоритм динамической настройки сложности позволяет подбирать задание на каждой сцене по силам студенту. Его структура приведена на рисунке 4.1.

Рисунок 4.1 - Алгоритм подстройки сложности

Алгоритм динамической настройки сложности состоит из следующих шагов:

1) загружаются и проверяется наличие переменной Complex (сложность);

2) делаем проверку SceneNumber (номера уровня) и увеличиваем значение Complex на 1 (чтобы решить вопрос со сложностью 1 уровня);

3) далее сверяем SceneNumber и Complex между собой:

а) если если Complex < SceneNumber, то выбираем лёгкий уровень;

б) если если Complex = SceneNumber, то выбираем нормальный уровень;

б) если если Complex > SceneNumber, то выбираем сложный уровень;

4) загружаем уровень необходимой сложности;

5) проверяем, насколько легко игрок проходит уровень, замеряя кол-во попыток (потраченного времени) на уровень;

6) сохраняем значение фактической сложности в переменную Complex данного уровня;

4.2 Алгоритм реакции окружения виртуальной среды на успешность прохождения игры пользователем

Алгоритм реакции окружения виртуальной среды на успешность прохождения игры пользователем приведён на рисунке 4.2.



Рисунок 4.2 - Алгоритм реакции окружения виртуальной среды на успешность прохождения игры пользователем

Алгоритм реакции окружения виртуальной среды на успешность прохождения игры пользователем состоит из следующих шагов

1) загружаются и проверяется наличие переменной Success (успешность прохождения игры);

2) далее сверяем Success и MainSuccess между собой:

а) если Success < MainSuccess, то выбираем «плохую» обстановку уровня;

б) если Success = MainSuccess, то выбираем «нормальную» обстановку уровня;

б) если Success > MainSuccess, то выбираем «красивую» или «хорошую» обстановку уровня;

3) загружаем уровень необходимого качества;

4) проверяем, насколько успешно игрок проходит уровень, замеряя кол-во попыток (потраченного времени) на уровень;

5) сохраняем значение фактической успешности в переменную Success;

5. РАЗРАБОТКА МОДЕЛЕЙ БАЗ ДАННЫХ ВИРТУАЛЬНОЙ ПРЕДМЕТНОЙ ОБЛАСТИ

Система баз данных - это компьютеризированная система хранения записей, т.е. компьютеризированная система, основное назначение которой - хранить информацию, предоставляя пользователям средства её извлечения и модификации [21]. СУБД должна предоставлять доступ к данным любым пользователям, включая и тех, которые практически не имеют и (или) не хотят иметь представления о физическом размещении в памяти данных и их описаний.

Естественно, что проект базы данных надо начинать с анализа предметной области и выявления требований к ней отдельных пользователей (сотрудников организации, для которых создается база данных). Подробнее этот процесс будет рассмотрен ниже, а здесь отметим, что проектирование обычно поручается человеку (группе лиц) - администратору базы данных (АБД). Им может быть, как специально выделенный сотрудник организации, так и будущий пользователь базы данных, достаточно хорошо знакомый с машинной обработкой данных. Объединяя частные представления о содержимом базы данных, полученные в результате опроса пользователей, и свои представления о данных, которые могут потребоваться в будущих приложениях, АБД сначала создает обобщенное неформальное описание создаваемой базы данных. Это описание, выполненное с использованием естественного языка, математических формул, таблиц, графиков и других средств, понятных всем людям, работающих над проектированием базы данных, называют инфологической моделью данных [22].

Инфологическая модель должна быть отображена в компьютеро-ориентированную даталогическую модель, "понятную" СУБД. В процессе развития теории и практического использования баз данных, а также средств вычислительной техники создавались СУБД, поддерживающие различные даталогические модели

Сначала стали использовать иерархические даталогические модели. Простота организации, наличие заранее заданных связей между сущностями, сходство с физическими моделями данных позволяли добиваться приемлемой производительности иерархических СУБД на медленных ЭВМ с весьма ограниченными объемами памяти. Но, если данные не имели древовидной структуры, то возникала масса сложностей при построении иерархической модели и желании добиться нужной производительности.

Сетевые модели также создавались для мало ресурсных ЭВМ. Это достаточно сложные структуры, состоящие из "наборов" - поименованных двухуровневых деревьев. "Наборы" соединяются с помощью "записей-связок", образуя цепочки и т.д. При разработке сетевых моделей было выдумано множество "маленьких хитростей", позволяющих увеличить производительность СУБД, но существенно усложнивших последние. Прикладной программист должен знать массу терминов, изучить несколько внутренних языков СУБД, детально представлять логическую структуру базы данных для осуществления навигации среди различных экземпляров, наборов, записей и т.п. Один из разработчиков операционной системы UNIX сказал "Сетевая база - это самый верный способ потерять данные".

Сложность практического использования иерархических и сетевых СУБД заставляла искать иные способы представления данных. В конце 60-х годов появились СУБД на основе инвертированных файлов, отличающиеся простотой организации и наличием весьма удобных языков манипулирования данными. Однако такие СУБД обладают рядом ограничений на количество файлов для хранения данных, количество связей между ними, длину записи и количество ее полей. Сегодня наиболее распространены реляционные модели.

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

Рисунок 5.1 - структурная схема виртуальной модели предметной области

6. РАЗРАБОТКА И РЕАЛИЗАЦИЯ ПРОГРАММНЫХ МОДУЛЕЙ

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

6.1 Описание программных модулей на языке JavaScript

Описание некоторых программных модулей на языке JavaScript (vJavaScript):

1) модуль внутриигровых событий (описание взаимодействий игрока с игровыми объектами):

const OFFLINE_DATA_FILE = "offline.js";

const CACHE_NAME_PREFIX = "c2offline";

const BROADCASTCHANNEL_NAME = "offline";

const CONSOLE_PREFIX = "[SW] ";

// Create a BroadcastChannel if supported.

const broadcastChannel = (typeof BroadcastChannel === "undefined" ? null: new BroadcastChannel(BROADCASTCHANNEL_NAME));

//////////////////////////////////////

// Utility methods

function PostBroadcastMessage(o)

{

if (!broadcastChannel)

return; // not supported

// Impose artificial (and arbitrary!) delay of 3 seconds to make sure client is listening by the time the message is sent.

// Note we could remove the delay on some messages, but then we create a race condition where sometimes messages can arrive

// in the wrong order (e.g. "update ready" arrives before "started downloading update"). So to keep the consistent ordering,

// delay all messages by the same amount.

setTimeout(() => broadcastChannel.postMessage(o), 3000);

};

function Broadcast(type)

{

PostBroadcastMessage({

"type": type

});

};

function BroadcastDownloadingUpdate(version)

{

PostBroadcastMessage({

"type": "downloading-update",

"version": version

});

}

function BroadcastUpdateReady(version)

{

PostBroadcastMessage({

"type": "update-ready",

"version": version

});

}

function GetCacheBaseName()

{

// Include the scope to avoid name collisions with any other SWs on the same origin.

// e.g. "c2offline-https://example.com/foo/" (won't collide with anything under bar/)

return CACHE_NAME_PREFIX + "-" + self.registration.scope;

};

function GetCacheVersionName(version)

{

// Append the version number to the cache name.

// e.g. "c2offline-https://example.com/foo/-v2"

return GetCacheBaseName() + "-v" + version;

};

// Return caches.keys() filtered down to just caches we're interested in (with the right base name).

// This filters out caches from unrelated scopes.

function GetAvailableCacheNames()

{

return caches.keys()

.then(cacheNames =>

{

const cacheBaseName = GetCacheBaseName();

return cacheNames.filter(n => n.startsWith(cacheBaseName));

});

};

// Identify if an update is pending, which is the case when we have 2 or more available caches.

// One must be an update that is waiting, since the next navigate that does an upgrade will

// delete all the old caches leaving just one currently-in-use cache.

function IsUpdatePending()

{

return GetAvailableCacheNames()

.then(availableCacheNames => availableCacheNames.length >= 2);

};

// Automatically deduce the main page URL (e.g. index.html or main.aspx) from the available browser windows.

// This prevents having to hard-code an index page in the file list, implicitly caching it like AppCache did.

function GetMainPageUrl()

{

return clients.matchAll({

includeUncontrolled: true,

type: "window"

})

.then(clients =>

{

for (let c of clients)

{

// Parse off the scope from the full client URL, e.g. https://example.com/index.html -> index.html

let url = c.url;

if (url.startsWith(self.registration.scope))

url = url.substring(self.registration.scope.length);

if (url && url!== "/") //./ is also implicitly cached so don't bother returning that

{

// If the URL is solely a search string, prefix it with / to ensure it caches correctly.

// e.g. https://example.com/?foo=bar needs to cache as /?foo=bar, not just ?foo=bar.

if (url.startsWith("?"))

url = "/" + url;

return url;

}

}

return ""; // no main page URL could be identified

});

};

// Hack to fetch optionally bypassing HTTP cache until fetch cache options are supported in Chrome (crbug.com/453190)

function fetchWithBypass(request, bypassCache)

{

if (typeof request === "string")

request = new Request(request);

if (bypassCache)

{

// bypass enabled: add a random search parameter to avoid getting a stale HTTP cache result

const url = new URL(request.url);

url.search += Math.floor(Math.random() * 1000000);

return fetch(url, {

headers: request.headers,

mode: request.mode,

credentials: request.credentials,

redirect: request.redirect,

cache: "no-store"

});

}

else

{

// bypass disabled: perform normal fetch which is allowed to return from HTTP cache

return fetch(request);

}

};

// Effectively a cache.addAll() that only creates the cache on all requests being successful (as a weak attempt at making it atomic)

// and can optionally cache-bypass with fetchWithBypass in every request

function CreateCacheFromFileList(cacheName, fileList, bypassCache)

{

// Kick off all requests and wait for them all to complete

return Promise.all(fileList.map(url => fetchWithBypass(url, bypassCache)))

.then(responses =>

{

// Check if any request failed. If so don't move on to opening the cache.

// This makes sure we only open a cache if all requests succeeded.

let allOk = true;

for (let response of responses)

{

if (!response.ok)

{

allOk = false;

console.error(CONSOLE_PREFIX + "Error fetching '" + originalUrl + "' (" + response.status + " " + response.statusText + ")");

}

}

if (!allOk)

throw new Error("not all resources were fetched successfully");

// Can now assume all responses are OK. Open a cache and write all responses there.

// TODO: ideally we can do this transactionally to ensure a complete cache is written as one atomic operation.

// This needs either new transactional features in the spec, or at the very least a way to rename a cache

// (so we can write to a temporary name that won't be returned by GetAvailableCacheNames() and then rename it when ready).

return caches.open(cacheName)

.then(cache =>

{

return Promise.all(responses.map(

(response, i) => cache.put(fileList[i], response)

));

})

.catch(err =>

{

// Not sure why cache.put() would fail (maybe if storage quota exceeded?) but in case it does,

// clean up the cache to try to avoid leaving behind an incomplete cache.

console.error(CONSOLE_PREFIX + "Error writing cache entries: ", err);

caches.delete(cacheName);

throw err;

});

});

};

function UpdateCheck(isFirst)

{

// Always bypass cache when requesting offline.js to make sure we find out about new versions.

return fetchWithBypass(OFFLINE_DATA_FILE, true)

.then(r => r.json())

.then(data =>

{

const version = data.version;

let fileList = data.fileList;

const currentCacheName = GetCacheVersionName(version);

return caches.has(currentCacheName)

.then(cacheExists =>

{

// Don't recache if there is already a cache that exists for this version. Assume it is complete.

if (cacheExists)

{

// Log whether we are up-to-date or pending an update.

return IsUpdatePending()

.then(isUpdatePending =>

{

if (isUpdatePending)

{

console.log(CONSOLE_PREFIX + "Update pending");

Broadcast("update-pending");

}

else

{

console.log(CONSOLE_PREFIX + "Up to date");

Broadcast("up-to-date");

}

});

}

// Implicitly add the main page URL to the file list, e.g. "index.html", so we don't have to assume a specific name.

return GetMainPageUrl()

.then(mainPageUrl =>

{

// Prepend the main page URL to the file list if we found one and it is not already in the list.

// Also make sure we request the base / which should serve the main page.

fileList.unshift("./");

if (mainPageUrl && fileList.indexOf(mainPageUrl) === -1)

fileList.unshift(mainPageUrl);

console.log(CONSOLE_PREFIX + "Caching " + fileList.length + " files for offline use");

if (isFirst)

Broadcast("downloading");

else

BroadcastDownloadingUpdate(version);

// Note we don't bypass the cache on the first update check. This is because SW installation and the following

// update check caching will race with the normal page load requests. For any normal loading fetches that have already

// completed or are in-flight, it is pointless and wasteful to cache-bust the request for offline caching, since that

// forces a second network request to be issued when a response from the browser HTTP cache would be fine.

return CreateCacheFromFileList(currentCacheName, fileList,!isFirst)

.then(IsUpdatePending)

.then(isUpdatePending =>

{

if (isUpdatePending)

{

console.log(CONSOLE_PREFIX + "All resources saved, update ready");

BroadcastUpdateReady(version);

}

else

{

console.log(CONSOLE_PREFIX + "All resources saved, offline support ready");

Broadcast("offline-ready");

}

});

});

});

})

.catch(err =>

{

// Update check fetches fail when we're offline, but in case there's any other kind of problem with it, log a warning.

console.warn(CONSOLE_PREFIX + "Update check failed: ", err);

});

};

self.addEventListener('install', event =>

{

// On install kick off an update check to cache files on first use.

// If it fails we can still complete the install event and leave the SW running, we'll just

// retry on the next navigate.

event.waitUntil(

UpdateCheck(true) // first update

.catch(() => null)

);

});

self.addEventListener('fetch', event =>

{

const isNavigateRequest = (event.request.mode === "navigate");

let responsePromise = GetAvailableCacheNames()

.then(availableCacheNames =>

{

// No caches available: go to network

if (!availableCacheNames.length)

return fetch(event.request);

// Resolve with the cache name to use.

return Promise.resolve().then(() =>

{

// Prefer the oldest cache available. This avoids mixed-version responses by ensuring that if a new cache

// is created and filled due to an update check while the page is running, we keep returning resources

// from the original (oldest) cache only.

if (availableCacheNames.length === 1 ||!isNavigateRequest)

return availableCacheNames[0];

// We are making a navigate request with more than one cache available. Check if we can expire any old ones.

return clients.matchAll().then(clients =>

{

// If there are other clients open, don't expire anything yet. We don't want to delete any caches they

// might be using, which could cause mixed-version responses.

// TODO: verify client count is as expected in navigate requests.

// TODO: find a way to upgrade on reloading the only client. Chrome seems to think there are 2 clients in that case.

if (clients.length > 1)

return availableCacheNames[0];

// Identify newest cache to use. Delete all the others.

let latestCacheName = availableCacheNames[availableCacheNames.length - 1];

console.log(CONSOLE_PREFIX + "Updating to new version");

return Promise.all(availableCacheNames.slice(0, -1)

.map(c => caches.delete(c)))

.then(() => latestCacheName);

});

}).then(useCacheName =>

{

return caches.open(useCacheName)

.then(c => c.match(event.request))

.then(response => response || fetch(event.request));

});

});

if (isNavigateRequest)

{

// allow the main request to complete, then check for updates

event.waitUntil(responsePromise

.then(() => UpdateCheck(false))); // not first check

}

event.respondWith(responsePromise);

});

2) модуль запуска программы в режиме оффлайн (без доступа к интернету):

(function() {

class OfflineClient

{

constructor()

{

// Create a BroadcastChannel, if supported.

this._broadcastChannel = (typeof BroadcastChannel === "undefined" ? null: new BroadcastChannel("offline"));

// Queue of messages received before a message callback is set.

this._queuedMessages = [];

// The message callback.

this._onMessageCallback = null;

// If BroadcastChannel is supported, listen for messages.

if (this._broadcastChannel)

this._broadcastChannel.onmessage = (e => this._OnBroadcastChannelMessage(e));

}

_OnBroadcastChannelMessage(e)

{

// Have a message callback set: just forward the call.

if (this._onMessageCallback)

{

this._onMessageCallback(e);

return;

}

// Otherwise the app hasn't loaded far enough to set a message callback.

// Buffer the incoming messages to replay when the app sets a callback.

this._queuedMessages.push(e);

}

SetMessageCallback(f)

{

this._onMessageCallback = f;

// Replay any queued messages through the handler, then clear the queue.

for (let e of this._queuedMessages)

this._onMessageCallback(e);

this._queuedMessages.length = 0;

}

};

// Create the offline client ASAP so we receive and start queueing any messages the SW broadcasts.

window.OfflineClientInfo = new OfflineClient();

}());

3) движковый модуль описания переменных:

var cr = {};

cr.plugins_ = {};

cr.behaviors = {};

if (typeof Object.getPrototypeOf!== "function")

{

if (typeof "test".__proto__ === "object")

{

Object.getPrototypeOf = function(object) {

return object.__proto__;

};

}

else

{

Object.getPrototypeOf = function(object) {

return object.constructor.prototype;

};

}

}

(function(){

cr.logexport = function (msg)

{

if (window.console && window.console.log)

window.console.log(msg);

};

cr.logerror = function (msg)

{

if (window.console && window.console.error)

window.console.error(msg);

};

cr.seal = function(x)

{

return x;

};

cr.freeze = function(x)

{

return x;

};

cr.is_undefined = function (x)

{

return typeof x === "undefined";

};

cr.is_number = function (x)

{

return typeof x === "number";

};

cr.is_string = function (x)

{

return typeof x === "string";

};

cr.isPOT = function (x)

{

return x > 0 && ((x - 1) & x) === 0;

};

cr.nextHighestPowerOfTwo = function(x) {

--x;

for (var i = 1; i < 32; i <<= 1) {

x = x | x >> i;

}

return x + 1;

}

cr.abs = function (x)

{

return (x < 0 ? -x: x);

};

cr.max = function (a, b)

{

return (a > b ? a: b);

};

cr.min = function (a, b)

{

return (a < b ? a: b);

};

cr.PI = Math.PI;

cr.round = function (x)

{

return (x + 0.5) | 0;

};

cr.floor = function (x)

{

if (x >= 0)

return x | 0;

else

return (x | 0) - 1; // correctly round down when negative

};

cr.ceil = function (x)

{

var f = x | 0;

return (f === x ? f: f + 1);

};

function Vector2(x, y)

{

this.x = x;

this.y = y;

cr.seal(this);

};

Vector2.prototype.offset = function (px, py)

{

this.x += px;

this.y += py;

return this;

};

Vector2.prototype.mul = function (px, py)

{

this.x *= px;

this.y *= py;

return this;

};

cr.vector2 = Vector2;

cr.segments_intersect = function(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y)

{

var max_ax, min_ax, max_ay, min_ay, max_bx, min_bx, max_by, min_by;

if (a1x < a2x)

{

min_ax = a1x;

max_ax = a2x;

}

else

{

min_ax = a2x;

max_ax = a1x;

}

if (b1x < b2x)

{

min_bx = b1x;

max_bx = b2x;

}

else

{

min_bx = b2x;

max_bx = b1x;

}

if (max_ax < min_bx || min_ax > max_bx)

return false;

if (a1y < a2y)

{

min_ay = a1y;

max_ay = a2y;

}

else

{

min_ay = a2y;

max_ay = a1y;

}

if (b1y < b2y)

{

min_by = b1y;

max_by = b2y;

}

else

{

min_by = b2y;

max_by = b1y;

}

if (max_ay < min_by || min_ay > max_by)

return false;

var dpx = b1x - a1x + b2x - a2x;

var dpy = b1y - a1y + b2y - a2y;

var qax = a2x - a1x;

var qay = a2y - a1y;

var qbx = b2x - b1x;

var qby = b2y - b1y;

var d = cr.abs(qay * qbx - qby * qax);

var la = qbx * dpy - qby * dpx;

if (cr.abs(la) > d)

return false;

var lb = qax * dpy - qay * dpx;

return cr.abs(lb) <= d;

};

function Rect(left, top, right, bottom)

{

this.set(left, top, right, bottom);

cr.seal(this);

};

Rect.prototype.set = function (left, top, right, bottom)

{

this.left = left;

this.top = top;

this.right = right;

this.bottom = bottom;

};

Rect.prototype.copy = function (r)

{

this.left = r.left;

this.top = r.top;

this.right = r.right;

this.bottom = r.bottom;

};

Rect.prototype.width = function ()

{

return this.right - this.left;

};

Rect.prototype.height = function ()

{

return this.bottom - this.top;

};

Rect.prototype.offset = function (px, py)

{

this.left += px;

this.top += py;

this.right += px;

this.bottom += py;

return this;

};

Rect.prototype.normalize = function ()

{

var temp = 0;

if (this.left > this.right)

{

temp = this.left;

this.left = this.right;

this.right = temp;

}

if (this.top > this.bottom)

{

temp = this.top;

this.top = this.bottom;

this.bottom = temp;

}

};

Rect.prototype.intersects_rect = function (rc)

{

return!(rc.right < this.left || rc.bottom < this.top || rc.left > this.right || rc.top > this.bottom);

};

Rect.prototype.intersects_rect_off = function (rc, ox, oy)

{

return!(rc.right + ox < this.left || rc.bottom + oy < this.top || rc.left + ox > this.right || rc.top + oy > this.bottom);

};

Rect.prototype.contains_pt = function (x, y)

{

return (x >= this.left && x <= this.right) && (y >= this.top && y <= this.bottom);

};

Rect.prototype.equals = function (r)

{

return this.left === r.left && this.top === r.top && this.right === r.right && this.bottom === r.bottom;

};

cr.rect = Rect;

function Quad()

{

this.tlx = 0;

this.tly = 0;

this.trx = 0;

this.try_ = 0; // is a keyword otherwise!

this.brx = 0;

this.bry = 0;

this.blx = 0;

this.bly = 0;

cr.seal(this);

};

Quad.prototype.set_from_rect = function (rc)

{

this.tlx = rc.left;

this.tly = rc.top;

this.trx = rc.right;

this.try_ = rc.top;

this.brx = rc.right;

this.bry = rc.bottom;

this.blx = rc.left;

this.bly = rc.bottom;

};

Quad.prototype.set_from_rotated_rect = function (rc, a)

{

if (a === 0)

{

this.set_from_rect(rc);

}

Quad.prototype.offset = function (px, py)

{

this.tlx += px;

this.tly += py;

this.trx += px;

this.try_ += py;

this.brx += px;

this.bry += py;

this.blx += px;

this.bly += py;

return this;

};

var minresult = 0;

var maxresult = 0;

function minmax4(a, b, c, d)

{

if (a < b)

{

if (c < d)

{

if (a < c)

minresult = a;

else

minresult = c;

if (b > d)

maxresult = b;

else

maxresult = d;

}

else

{

if (a < d)

minresult = a;

else

minresult = d;

if (b > c)

maxresult = b;

else

maxresult = c;

}

}

else

{

if (c < d)

{

if (b < c)

minresult = b;

else

minresult = c;

if (a > d)

maxresult = a;

else

maxresult = d;

}

else

{

if (b < d)

minresult = b;

else

minresult = d;

if (a > c)

maxresult = a;

else

maxresult = c;

}

}

};

Quad.prototype.bounding_box = function (rc)

{

minmax4(this.tlx, this.trx, this.brx, this.blx);

rc.left = minresult;

rc.right = maxresult;

minmax4(this.tly, this.try_, this.bry, this.bly);

rc.top = minresult;

rc.bottom = maxresult;

6.2 Отладка и экспериментальное тестирование модулей

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

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

В тестировании программного обеспечения изучаются внутренние элементы программы и связи между ними. Объектом тестирования является внутреннее поведение программы.

При проверке формируются тестовые варианты, в которых:

- гарантируется проверка всех независимых маршрутов программы;

- выполнение всех циклов в пределах их границ и диапазонов;

- проход ветви имеет значение True или False для всех логических решений;

- анализируется правильность внутренней структуры данных.

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

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

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

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

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

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

Таблица 8.1 - Результаты тестирования

Номер тестировщика	Характеристики компьютера	Оценка программы
	ОС	Процессор	Видеокарта	ОЗУ (ГБ)	графика	быстродействие
1	2	3	4	5	6	7
1	Windows XP	Intel core 2dou 1,5 ГГц	NVidia GeForce 5200 128 МБ	1	6	7
2	Windows 7	Intel i5 2.9 ГГц	NVidia GeForce 410М 512 МБ	3	9	10
3	Windows Vista	AMD 3.2 ГГц	NVidia GeForce 520М 512 МБ	4	8	9

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

ЗАКЛЮЧЕНИЕ

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

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

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

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

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

СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

1 Лопатина, Т.М. Так ли безопасны компьютерные игры? /Т.М. Лопатина //Высшее образование сегодня. 2006. - №9. - С. 34-37.

2 Википедия: свободная энциклопедия [Электронный ресурс]. - Режим доступа: https://ru.wikipedia.org/wiki/Представление_знаний

3 Анализ данных и процессов: учеб. пособие для вузов / А. А. Барсегян, М. С. Куприянов, И. И. Холод [и др.]. - СПб.: БХВ-Петербург, 2009. - 512 с.

4 Rule-Based Expert Systems: The MYCIN Experiments of the Stanford Heuristic Programming Project

5 Википедия: свободная энциклопедия [Электронный ресурс]. - Режим доступа: https://ru.wikipedia.org/wiki/Индустрия_компьютерных_игр

6 SUPERDATA: аналитическая компания [Электронный ресурс]. - Режим доступа: https://www.superdataresearch.com

7 Википедия: свободная энциклопедия [Электронный ресурс]. - Режим доступа: https://ru.wikipedia.org/wiki/Игры_для_социальных_сетей

8 Grand Theft Auto V - Rockstar Games [Электронный ресурс]. - Режим доступа: www.rockstargames.com/v/order

9 Википедия: свободная энциклопедия [Электронный ресурс]. - Режим доступа: https://ru.wikipedia.org/wiki/Классификация_компьютерных_игр

10 Карева, Г.В. Компьютерные игры как средство развития гностических способностей студентов в ВУЗе / Г.В. Карева // Вестник Брянского государственного технического университета. - 2008. - №4. - С.149-155.