Embed Size (px)
Citation preview
2
АННОТАЦИЯ
Работа посвящена разработке алгоритмов и программного обеспечения
для формирования пользовательского интерфейса на удалённом устройстве в
условиях кроссплатформенного взаимодействия программ.
В работе кратко рассмотрены существующие реализации решений
подобных задач, представленные программными продуктами Visual Terminal,
TeamViewer, RemoteMouse.
Для достижения поставленной цели проанализированы различные
средства разработки для мобильных устройств. Исследованы библиотеки
сетевого программирования для операционных систем Windows и Unix.
Исследованы основные принципы создания приложений на основе Unreal
Engine 4 и его сетевые возможности. Описано создание клиентских и
серверных приложений с использованием различных библиотек. Также
изложена технология создания масштабируемого интерфейса с помощью языка
QML.
В результате было разработано клиент-серверное игровое приложение
«Монополия», которое реализует разработанные алгоритмы. Серверное
приложение разработано на основе технологии Unreal Engine 4. Универсальное
клиентское приложение разработано с помощью языка C++. Интерфейс для
клиента описан с помощью языка QML.
Разработанное клиентское приложение может использоваться для работы
с любым серверным приложением, работающем в рамках разработанных
алгоритмов.
Объем работы составляет 66 страниц. Работа включает в себя 27
рисунков, 3 таблицы. Использовано 11 литературных источников.
3
ОГЛАВЛЕНИЕ
ОСНОВНЫЕ ПОНЯТИЯ И ОПРЕДЕЛЕНИЯ ......................................................... 5
ВВЕДЕНИЕ .................................................................................................................. 7
1. Обзор существующих решений ............................................................................. 9
1.1. Тонкие клиенты .................................................................................................. 9
1.1.1. Веб-браузер как тонкий клиент ................................................................. 9
1.1.2. Обзор Visual Terminal ............................................................................... 10
1.2. Программы удаленного доступа .................................................................... 12
1.2.1. Обзор TeamViewer .................................................................................... 12
1.2.2. Обзор Remote Mouse ................................................................................. 14
2. Алгоритмы обеспечивающие динамическое формирование интерфейса ...... 15
2.1. Алгоритм взаимодействия клиента и сервера .............................................. 15
2.2. Алгоритм работы функции передачи файлов на стороне сервера ............. 16
2.3. Алгоритм работы функции приема файлов на стороне клиента ................ 18
3. Обзор и выбор средств для разработки программной системы, реализующей
разработанные алгоритмы ........................................................................................ 20
3.1. Сетевые возможности Unreal Engine 4 .......................................................... 20
3.1.1. Репликация данных в стандартной сетевой подсистеме
Unreal Engine 4 ........................................................................................................... 20
3.1.2. Описание класса FSocket .......................................................................... 24
3.1.3. Использование стандартных библиотек ................................................. 26
3.1.4. Выводы ....................................................................................................... 29
3.2. Обзор инструментов для разработкисетевых мобильных приложений .... 30
3.2.1. AndroidStudio ............................................................................................. 30
3.2.1.1. Разработка интерфейса ....................................................................... 31
4
3.2.1.2. Разработка сетевой части ................................................................... 33
3.2.2. Unreal Engine 4 .......................................................................................... 34
3.2.2.1. Разработка сетевой части ................................................................... 35
3.2.2.2. Разработка интерфейса ....................................................................... 36
3.2.3. Qt Creator .................................................................................................... 38
3.2.4. Выводы ....................................................................................................... 41
4. Разработка программной системы, реализующей разработанные алгоритмы 42
4.1. Разработка серверной подсистемы ................................................................ 43
4.1.1. Разработка визуальной части ................................................................... 43
4.1.1.1. Создание необходимых трехмерных моделей ................................. 43
4.1.1.2. Разработка интерфейса и функций обеспечивающих обновление
состояния игрового поля .......................................................................................... 47
4.1.2. Разработка логики ..................................................................................... 51
4.1.3. Разработка сетевой части ......................................................................... 57
4.2. Разработка клиентской подсистемы .............................................................. 59
4.2.1. Разработка сетевой части ......................................................................... 59
4.2.2. Разработка масштабируемого интерфейса ............................................. 61
4.3. Выводы .............................................................................................................. 63
ЗАКЛЮЧЕНИЕ ......................................................................................................... 64
БИБЛИОГРАФИЧЕСКИЙ СПИСОК ..................................................................... 65
ПРИЛОЖЕНИЯ ......................................................................................................... 67
5
ОСНОВНЫЕ ПОНЯТИЯ И ОПРЕДЕЛЕНИЯ
Клиент – объект, запрашивающий информацию по сети. Как правило, это
персональный компьютер или рабочая станция, запрашивающая информацию у
сервера.
Кроссплатформенное (межплатформенное) программное обеспечение
— программное обеспечение, работающее более чем на одной аппаратной
платформе и/или операционной системе.
Материал – под этим термином будем понимать, совокупность
текстурных объектов (текстур), которые задают диффузный цвет и физические
свойства реализуемого реального материала, а также совокупность вершинной
и пиксельной программы, которые обеспечивают сборку информации из
текстур согласно заданному алгоритму.
Паттерн - повторимая архитектурная конструкция, представляющая
собой решение проблемы проектирования в рамках некоторого часто
возникающего контекста.
Пиксель – наименьший логический элемент двумерного цифрового
изображения в растровой графике, или элемент матрицы дисплеев,
формирующих изображение.
Прикладной программный интерфейс (Application Programming
Interface, API) – набор готовых классов, функций и констант, предоставляемых
приложением (библиотекой, сервисом) для использования во внешних
программных продуктах.
Репликация – процесс, под которым понимается копирование данных с
одного источника на другой (или несколько других) и наоборот.
Сервер – компьютер,хранящий информацию, с которой работают
сетевые клиенты.
Система контроля версий (СКВ) — это система, регистрирующая
изменения в одном или нескольких файлах с тем, чтобы в дальнейшем была
возможность вернуться к определённым старым версиям этих файлов.
6
Сокет (Socket) - название программного интерфейса для обеспечения
обмена данными между процессами. Процессы при таком обмене могут
исполняться как на одной ЭВМ, так и на различных ЭВМ, связанных между
собой сетью. Сокет — абстрактный объект, представляющий конечную точку
соединения.
Тайлинг (tiling) - вид наложения текстур на объект, когда не видно швов
(стыков) то есть бесшовный, по типу поклейки обоев с рисунком.
Текстура (texture)– объект, который состоит из набора двумерных
массивов пикселей, а также ассоциированных настроек, которые могут
использоваться для задания режимов отображения в процессе визуализации.
Чертеж (Blueprint) – основной объект логики в UnrealEngine 4. По своей
сути — это сборка из компонентов, которая образует сложный объект игрового
мира. Редактировать такую сборку можно через Редактор Чертежей
(BlueprintEditor). Поведением сборки возможно управлять через С++ класс и
редактор графов. Вместе они дополняют друг друга.
DIP (device-independentpixel) – единица измерения размеров элементов
пользовательского интерфейса, зависящая от DPI. Обычно используется, чтобы
обеспечить одинаковый фактический размер элементов на дисплеях с разной
плотностью пикселей.
DPI (dotsperinch)–количество пикселей на дюйм.Применяется для
указания разрешающей способности при вводе или выводе информации с/на
плоский носитель. Измеряется числом точек, приходящихся на линейный дюйм
поверхности.
RPC (RemoteProcedureCall) – удаленныйвызовпроцедур. класс
технологий, позволяющих компьютерным программам вызывать функции или
процедуры в другом адресном пространстве (как правило, на удалённых
компьютерах).
7
ВВЕДЕНИЕ
В связи с тем, что рынок информационных услуг постоянно расширяется,
производители программного обеспечения выпускают все более
интеллектуальные, а значит, и объемные программные комплексы. Росла
сложность вычислений – росли требования к компьютерам, на которых эти
вычисления выполнялись. Чтобы снизить стоимость оборудования была
разработана архитектура клиент-сервер. На сервере выполнялись вычисления, а
доступ к результатам осуществлялся при помощи сетевого соединения с
клиентского приложения.
В связи с появлением мобильных устройств под управлением
полноценных операционных систем клиентские приложения стали появляться и
на них. Это так называемые «толстые» и «тонкие» клиенты. Так же можно
выделить такие решения как программы удаленного доступа.
В «толстом» клиенте реализована вся логика по обработке данных, а
сервер выступает лишь в роли хранилища данных. С этим связаны и главные
недостатки такого типа решений. Для каждого серверного приложения
необходима установка и настройка соответствующего приложения на клиенте.
Необходимость обновления. Большие затраты на разработку клиента для
нескольких платформ.
В качестве «тонкого» клиента обычно выступает веб-браузер. Главным
минусом здесь является то, что различные браузеры могут по-разному
формировать одну и ту же страницу с интерфейсом. Особенно это касается
относительно старых решений. Скорее всего, решение двух-трехлетней
давности, запущенное в современном веб-браузере, будет отображаться не так,
как это задумал разработчик.
Минусом программ удаленного доступа является неудобство их
использования на различных платформах, в частности на мобильных
устройствах. Адекватно управлять целым компьютерным рабочим столом с
экрана мобильного телефона не представляется возможным.
8
В связи с существованием описанных выше недостатков у существующих
решений, была сформулирована следующая цель: разработать алгоритмы и
реализующее их программное обеспечение для формирования
пользовательского интерфейса на удалённом устройстве в условиях
кроссплатформенного взаимодействия программ.
Для достижения поставленной цели необходимо декомпозировать её на
следующие задачи:
1) разработка алгоритма взаимодействия клиента и сервера, а также
алгоритмов их функционирования;
2) исследование сетевых возможностей UnrealEngine 4;
3) обзор и выбор средств кроссплатформенной или мобильной
разработки;
4) разработка клиент-серверной программной системы, реализующей
возможность динамического формирования интерфейса на удаленном
устройстве.
Для исследований был выбран Unreal Engine 4, как одна из самых быстро
развивающихся и мощных трёхмерных систем визуализации с открытым
исходным кодом.
9
1. Обзор существующих решений
1.1. Тонкие клиенты
1.1.1. Веб-браузер как тонкий клиент
В статье [1] есть подробное описание веб-браузера как тонкого клиента
на примере системы документооборота в САПР. В данном подразделе описание
ограничится принципами работы, преимуществами и недостатками веб-
браузера, как тонкого клиента.
На сегодняшний день, чаще всего в качестве тонкого клиента
используется именно веб-браузер. Он универсален, не требует дополнительних
настроек, работа в нем привычна и удобна большинству пользователей.
Работает он следующим образом:
запрос с клиентской подсистемы отправляется на сервер;
сервер принимает и обрабатывает запрос;
сервер отправляет результат на клиент;
клиент формирует интерфейс в соответствии с принятыми
данными.
Однако, существуют у браузера и недостатки. Различные браузеры могут
отображать содержимое страниц по-разному. Веб-технологии меняются
достаточно часто и старые страницы в новых браузерах либо будут
отображаться неверно, либо не будут отображаться вовсе. Кроме того
функционал клиента ограничивается возможностями HTML и JavaScript.
Существуют различные технологии (например, ActiveX), которые позволяют
расширить этот функционал. Но их использование приводит к «утолщению»
клиента. На клиент передается целое приложение, которое затем на нем и
выполняется. Также использование таких технологий подразумевает установку
дополнительного ПО и настройку браузера (смягчение политики безопасности
и т.д.).
10
1.1.2. Обзор Visual Terminal
Программа Aurora 3 Visual Terminal предназначена для мониторинга
состояния системы визуализации Aurora 3, управления объектами и погодой,
запуска тестов, геометрического сведения проекционной системы.
Система визуализации Aurora 3 представляет из себя сервер, который
принимает пакеты с командами из внешних источников, плюс N клиентов (в
зависимости от конфигурации), которые принимают пакеты от сервера и
производят визуализацию. Через тонкий клиент пользовательского интерфейса
Visual Terminal возможно управление системой визуализации Aurora 3 с
удалённого компьютера.
Запуск к Aurora 3 осуществляется с помощью настройки профиля по
умолчанию. Пользователь может выбрать профиль по умолчанию, нажав
кнопку «Default».
Профиль представляет собой набор из следующих параметров:
• Config name - название выбранного профиля.
• Server Name - имя компьютера (локального или удаленного), где
находится визуальный сервер Aurora 3. Может быть опущен, если заполняется
поле IP.
• IP - IP-адрес визуального сервера Aurora 3. Должен быть указан, в
случае, если удаленный компьютер имеет несколько сетевых карт. Для
компьютеров с одним сетевым интерфейсом поле может быть опущено, если
заполняется поле Имя сервера.
• Executable file - имя исполняемого файла, используемого для запуска
визуальной системы.
• Process name - имя процесса, связанного с Aurora 3 на сервере.
Необходимо указывать для корректного завершения работы системы
визуализации.
• Path - путь к Aurora 3 на сервере;
• Error state - сообщение об ошибке из программы "clientlauncher".
11
Рис. 1.1. Окно редактирования профиля.
Кнопка Connect инициирует подключение к существующему экземпляру
Aurora 3, в соответствии с параметрами, которые перечислены выше. При
отсутствии запущенной копии Aurora 3, программа попросит запустить его.
На вкладке «Testing tab» находится список тестов для системы
визуализации Aurora 3. Для того чтобы запустить тест. Нужно просто выбрать
его из этого списка.
Вкладка «Weather controls» предоставляет полный контроль над всеми
погодными эффектами в Aurora 3.
Вкладка «Warp editor» используется для сведения системы из нескольких
проекторов.
12
1.2. Программы удаленного доступа
1.2.1. Обзор TeamViewer
В начале работы с программой TeamViewer, пользователю присваивается
уникальный идентификатор. С помощью этого идентификатора и пароля можно
подключиться к удаленному компьютеру, на котором также установлено это
приложение, и управлять им.
Пароль может устанавливаться программой автоматически либо
устанавливаться самим пользователем.
Передача данных от сервера к клиенту осуществляется в зашифрованном
виде. Для этого используется передача данных с ключом AES (256 бит) и
безопасное соединение HTTPS.
При работе с приложением доступно несколько режимов: удаленный
контроль, отображение рабочего стола, режим работы с файлами, режим
организации сети с удаленным компьютером.
Рис. 1.2. TeamViewer. Рабочий стол на экране мобильного телефона.
Для того чтобы уменьшить время общения клиента и сервера,
приложение дополнительно сжимает данные.
Также между двумя пользователями, которые используют это
приложение, можно организовать двустороннюю голосовую связь или
видеоконференцию.
13
Кроме этого, в приложении есть возможность общаться с помощью
встроенного чата. В программе присутствует инструмент Whiteboard -
виртуальная доска для рисования. С помощью этого инструмента можно
нарисовать собеседнику какую-нибудь блок-схему или сделать поясняющий
набросок.
Минусом данной реализации является неудобство управления целым
рабочим столом с экрана мобильного устройства.
14
1.2.2. Обзор Remote Mouse
RemoteMouse это приложение, которое позволяет удаленно управлять
компьютером с помощью планшета или смартфона.
Как и с аналогичными приложениями, для полноценной работы с
RemoteMouse, необходимо установить полноценную версию программы на
компьютер. При этом компьютер и Android-устройство должны находиться в
одной сети Wi-Fi.
Основная функция приложения заключается в имитации мыши.
Управление осуществляется простыми жестами. Одно нажатие на экране
отвечает за клик левой клавишей мыши, а касание двумя пальцами за клик
правой клавиши. Двойное нажатие позволит перетащить окно.
В приложении есть функция ввода текста с помощью клавиатуры или
голоса, пульт управления презентациями, горизонтальная клавиатура,
контроллер для медиа плееров.
Пожалуй, главной особенностью RemoteMouse является удобный
интерфейс. Во всем остальном приложение уступает своим конкурентам. Здесь
нет функции просмотра экрана компьютера.
Рис. 1.3. Интерфейс программы RemoteMouse.
15
2. Алгоритмы обеспечивающие динамическое формирование
интерфейса
2.1. Алгоритм взаимодействия клиента и сервера
В рамках данной работы решается задача динамического формирования
интерфейса на удаленном устройстве. Клиент представляет собой
универсальное приложение. Все данные об интерфейсе хранятся на сервере и
отправляются наклиент в момент подключения. Это позволяет использовать
одно клиентское приложение для работы с любыми серверными
приложениями, так же как и веб-браузер.
Рис. 2.1. Блок-схема взаимодействия клиента и сервера.
16
2.2. Алгоритм работы функции передачи файлов на стороне
сервера
1) Отправить наклиент количество файлов, которые будут переданы.
Установить _n количество файлов . Установить любой размер буфера b .
2) Принять сообщение-подтверждение с клиента. Если сообщение
сигнализирует об ошибке, то перейти на пункт 10.
3) Отправить имя файла на клиент.
4) Принять сообщение-подтверждение с клиента. Если сообщение
сигнализирует об ошибке, то перейти на пункт 10.
5) Открыть файл.
6) Считать блок данных размером b из файла. Отправить этот блок на
клиент. Если размер блока равен b , повторить пункт 6.
7) Закрыть файл.
8) Принять сообщение-подтверждение с клиента. Если сообщение
сигнализирует об ошибке, то перейти на пункт 10.
9) Установить 1n n . Если 0n , перейти на пункт 3.
10) Завершить отправку файлов.
17
Рис. 2.2. Блок-схема функции отправки файлов на сервере.
18
2.3. Алгоритм работы функции приема файлов на стороне
клиента
1) Создать директорию для сохранения файлов с сервера. Если
директория существует, пропустить пункт.
2) Прием количества файлов, которые будут приняты. Установить
_n количество файлов . Установить любой размер буфера b .
3) Отправить сообщение-подтверждение на сервер. В случае ошибки
отправить сообщение об ошибке и перейти на пункт 11.
4) Принять имя файла.
5) Отправить сообщение-подтверждение на сервер. В случае ошибки
отправить сообщение об ошибке и перейти на пункт 11.
6) Создать файл с именем, полученного из 4 пункта.
7) Принять блок данных с сервера. Записать этот блок в файл. Если
размер блока равен b , повторить пункт 7.
8) Закрыть файл.
9) Отправить сообщение-подтверждение на сервер. В случае ошибки
отправить сообщение об ошибке и перейти на пункт 11.
10) Установить 1n n . Если 0n , перейти на пункт 4.
11) Завершить прием файлов.
19
Рис. 2.3. Блок-схема функции приема файлов на клиенте.
20
3. Обзор и выбор средств для разработки программной системы,
реализующей разработанные алгоритмы
3.1. Сетевые возможности Unreal Engine 4
3.1.1. Репликация данных в стандартной сетевой подсистеме
Unreal Engine 4
Сетевой моделью в Unreal Engine 4 (UE4) является модель клиент-сервер.
Выбор количества клиентов в редакторе происходит на панели управления.
Основной составляющей сетевой технологии в UE4 является репликация
объектов. При установленном флажке Replicates в свойствах объекта, он будет
постоянно реплицироваться с сервера на все клиенты, то есть будет
происходить постоянная синхронизация.
Рис. 3.1. Репликация объектов
Для разделения логики на серверную и клиентскую используется
функция SwitchHasAuthority.
21
Рис. 3.2. Разделение логики в blueprint-редакторе.
Для каждой переменной в UnrealEngine 4 можно выбрать режим
репликации.
Рис. 3.3. Режимы репликации для переменных.
22
Таблица 3.1
Режимы репликации для переменных
Режим
репликации Описание
None Режим по умолчанию. Значение переменной не передаётся
по сети клиентам.
Replicated Значение переменной пересылается с сервера на клиенты.
На клиенте оно обновляется автоматически.
RepNotify Режим повторяет Replicated, но в дополнение создается
функция OnRep_, которая будет вызываться на сервере и
клиентах при изменении значения реплицируемой
переменной.
Для каждой функции в UnrealEngine 4 также можно выбрать режим
репликации.
Рис. 3.4. Режимы репликации для функций.
23
Таблица 3.2
Режимы репликации для функций
Режим репликации Описание
NotReplicated Выполняется там же, откуда вызывается.
Multicast Если функция вызывается на сервере, она будет
выполнена на сервере и на всех клиентах. Если
функция вызывается на клиенте, она будет
выполнена только на нем.
RunonServer Откуда бы функция не вызывалась, выполняться она
будет на сервере.
RunonOwningClient Если функция вызывается на сервере, она будет
выполнятся на клиенте, которому принадлежит
целевой объект. Если функция вызывается на
клиенте, то и выполняться она будет на том же
клиенте.
Не смотря на то, что стандартная сетевая подсистема UE4 предоставляет
весь основной функционал для репликации данных, для использования в
данной работе она не подходит. Во-первых, при её использовании
предполагается, что и сервер, и клиент должны быть разработаны на основе
Unreal Engine 4. Во-вторых, стандартная сетевая подсистема полностью скрыта
для пользователя, т.е. отсутствует возможность производить какие-либо
изменения в ней. Это слишком большое ограничение. В-третьих,
предполагается, что разработанное приложение может быть запущено как в
режиме сервера, так и в режиме клиента. Следовательно, ни о какой
универсальности клиентского приложения речи не идет.
24
3.1.2. Описание класса FSocket
Для реализации собственной сетевой логики, в UnrealEngine 4
предусмотрен класс FSocket.
Класс FSocket – встроенный в Unreal Engine 4 класс для работы с
сокетами. Ниже приведено описание основных методов данного класса[2].
Таблица 3.3
Возвращаемое
значение Метод Описание
FSocket *... Accept
(
constFString&InSocketDescription
)
Принимаетсоединение. В
случае неудачи возвращает
NULL
bool Bind
(
constFInternetAddr&Addr
)
Связывает сокет с IP-адресом
bool Close() Закрывает сокет
bool Connect
(
constFInternetAddr&Addr
)
Подключает сокет к узлу,
имеющему заданный адрес
bool Listen
(
int32 MaxBacklog
)
Переводит сокет в состояние
прослушивания сети для
входящих соединений
25
Продолжение таблицы 3.3
bool Recv
(
uint8* Data,
int32 BufferSize,
int32&BytesRead,
ESocketReceiveFlags::TypeFlags
)
Считывает блок данных из
подключенного сокета
bool Send
(
const uint8* Data,
int32 Count,
int32&BytesSent
)
Отправляет блок данных на
подключенный сокет
bool HasPendingConnection
(
bool&bHasPendingConnection
)
Проверяет очередь запросов
на подключение к
серверу.Возвращает trueв
случае, если очередь не
пуста, иначе false.
bool HasPendingData
(
uint32&PendingDataSize
)
Проверяет очередь входящих
сообщений. Возвращает trueв
случае, если очередь не
пуста, иначе false.
26
3.1.3. Использование стандартных библиотек
В Unreal Engine 4 есть возможность подключить и стандартные
библиотеки. В том числе и сетевую библиотеку Winsock.
Однако чтобы избежать проблем с типами данных, подключать
заголовочный файл winsock.hнужно следующим образом:
Код:
Далее производится описание этой библиотеки на примере разработки
простого серверного приложения в среде разработки Visual Studio 2015.
Для начала необходимо подключить заголовочный файл: winsock.h или
winsock2.h. Также нужно подключить библиотеку: Wsock32.lib или Ws2_32.lib.
Сделать это можно либо в настройках проекта (рис.3.5), либо с помощью
строки в коде программы:
Код:
Рис. 3.5. Настройки проекта в VisualStudio.
#include "AllowWindowsPlatformTypes.h" #include <winsock2.h> #include "HideWindowsPlatformTypes.h"
#pragma comment(lib, "ws2_32.lib")
27
Далее, в коде программы для инициализации Winsockнеобходимо вызвать
функцию WSAStartup.
Код:
С помощью макроса MAKEWORD указывается версия Winsock. В
результате успешного выполнения данного кода, переменная wsa будет
содержать информацию о только что проинициализированной версии Winsock
API.
Следующим шагом является создание сокета. Сделать это можно при
помощи функции socket.
Код:
Первый аргумент задает используемый для взаимодействия набор
протоколов, для стека протоколов TCP/IP он должен иметь значение AF_INET.
Второй аргумент задает режим взаимодействия: SOCK_STREAM - с
установлением соединения, SOCK_DGRAM - без установления соединения.
Третий аргумент задает конкретный протокол транспортного уровня. Если этот
аргумент задан равным 0, то будет использован протокол по умолчанию (TCP
для SOCK_STREAM и UDP для SOCK_DGRAM)[3].
После создания сокета нужно связать его с конкретным портом с
помощью функции bind.
WSADATA wsa; //… if(WSAStartup(MAKEWORD(2, 2), &wsa) != 0) { printf("Failed. Error code: %d", WSAGetLastError()); return 1; }
SOCKET s; if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { printf("Could not create socket : %d", WSAGetLastError()); }
28
Код:
С помощью функции listen нужно перевести сервер в режим «прослушки»
сети.
Код:
Первым аргументом указывается сокет, через который сервер будет
ожидать запросы от клиентов. Вторым – максимальная длина очереди на
установление соединения[3].
Для приема запросов от клиентов используется функция accept.
Код:
Первый аргумент задает сокет, через который программа-сервер
получила запрос на соединение. Второй аргумент должен указывать на область
памяти, размер которой позволял бы разместить в ней структуру данных,
содержащую адрес сокета программы-клиента, сделавшей запрос на
соединение. Третий - должен указывать на область памяти в виде целого числа,
задающего размер (в байтах) области памяти, указываемой вторым
аргументом[3].
Для обмена данными используются либо стандартные вызовы readи write,
либо sendи recv.
Для закрытия сокета используется функция closesocket.
structsockaddr_in server; server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = htons(8000); if (bind(s, (structsockaddr *)&server, sizeof(server)) == SOCKET_ERROR) { printf("Bind failed with error code : %d", WSAGetLastError()); }
listen(s, 3);
SOCKET new_socket; structsockaddr_in client; int c; c = sizeof(structsockaddr_in); new_socket = accept(s, (structsockaddr *)&client, &c); if (new_socket == INVALID_SOCKET) { printf("accept failed with error code : %d", WSAGetLastError()); }
29
3.1.4. Выводы
Встроенная сетевая подсистема UnrealEngine 4, как показано в пункте
3.1.1, не подходит для данной работы.
Библиотека Winsock не является платформонезависимой. Для
обеспечения кроссплатформенности её необходимо использовать в
совокупности с библиотекой sys/socket.h для операционных систем семейства
Unix. Однако, при использовании их при разработке приложений на основе
UnrealEngine 4 придется проводить многочисленные преобразования типов, не
всегда тривиальные.
Класс FSocket, встроенный в UnrealEngine 4, является
кроссплатформенным решением.
Поэтому для реализации сетевой части на стороне сервера был выбран
класс FSocket.
Разработанное в пункте 3.1.3 приложение будет использоваться в
дальнейшем для тестирования клиентских приложений.
30
3.2. Обзор инструментов для разработкисетевых мобильных
приложений
Одной из задач данной работы является клиентского приложения для
мобильной операционной системы Android. Поэтому в данном разделе будут
рассмотрены такие инструменты как Android Studio, Unreal Engine 4 и Qt. Обзор
будет производиться на примерах разработки клиентских приложений.
3.2.1. AndroidStudio
AndroidStudio – официальная среда разработки для платформы Android.
Разработка ведется на языке Java[4].
После установки и настройки AndroidStudio можно начать разработку. В
главном окне нужно выбрать пункт Start a new Android Studio project. Далее
следует задать имя проекта и домен компании. Домен нужен для формирования
имени пакета согласно стандартам языка Java. Любая программа на данном
языке содержит один или несколько классов. Они в свою очередь организованы
в так называемые пакеты. А имя пакета по соглашению начинается с
перевернутого домена компании. Также необходимо выбрать папку для
хранения проекта, устройство, для которого будет вестись разработка
(смартфон, планшет, «умные» часы и т.д.) и версию операционной системы. В
конце необходимо выбрать шаблон проекта и название главного класса.
После всех подготовительных действий начнется сборка проекта
системой автоматической сборки Gradle.
В проекте есть три основные папки. В папке manifestнаходится файл
конфигурации приложения. В папке javaхранятся пакеты, а в них файлы с
описанием классов приложения. В папке res хранятся различные ресурсы,
используемые в приложении. Это изображения, звуки, xml-файлы для разметки
интерфейса и т.д.
31
3.2.1.1. Разработка интерфейса
Код:
Приведенный выше код формирует следующий интерфейс (рис. 3.6).
Рис. 3.6. Интерфейс приложения.
<?xml version="1.0" encoding="utf-8"?> <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <EditText android:id="@+id/EditText01" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Enter the text" > </EditText> <Button android:id="@+id/myButton" android:layout_width="wrap_content" android:layout_height="wrap_content" android:onClick="onClick" android:text="Send" > </Button> </LinearLayout>
32
Здесь стоит отметить тег <LinearLayout>. В Androidсуществует четыре типа
разметки.
1) FrameLayout – самый простой тип разметки. Может содержать
только один дочерний элемент.
2) LinearLayout – может содержать больше одного дочернего
элемента. Каждый новый элемент помещается за предыдущим.
3) TableLayout – создает разметку в виде таблицы.
4) RelativeLayout – расположение элементов полностью описывает
разработчик.
33
3.2.1.2. Разработка сетевой части
Для начала нужно объявить объект типа Socket, задать IP – адрес сервера и
порт к которому будет происходить подключение.
Код:
Затем в методе, который вызывается при загрузке приложения необходимо
сформировать адрес сервера и создать соответствующий сокет.
Код:
А в методе, который вызывается по нажатию кнопки Send, нужно написать
следующее:
Код:
private Socket socket; private static final int SERVERPORT = 8000; private static final String SERVER_IP = "192.168.1.101";
InetAddressserverAddr = InetAddress.getByName(SERVER_IP); socket = new Socket(serverAddr, SERVERPORT);
//находим текстовое поле, текст из которого нужно отправить на сервер EditText et = (EditText) findViewById(R.id.EditText01);
//получаем текст из этого поля String str = et.getText().toString();
//создаем объект типа PrintWriter, связанный с созданным сокетом PrintWriter out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
//отправляем сообщение out.println(str);
34
3.2.2. Unreal Engine 4
Приложения в Unreal Editor пишутся на языке С++. Для того чтобы
реализовать функционал клиентского приложения, необходимо подключить
следующие заголовочные файлы:
Код:
Также, нужно отредактировать файл сборки .Build.cs. Этот файл, наряду с
файлом заголовка (.h) и С++ файлом, в обязательном порядке должен быть в
каждом модуле. Файл сборки находится в корневом каталоге модуля. Он
определяет информацию, которая используется в UnrealBuildTool для того,
чтобы скомпилировать модуль.
Код:
UnrealBuildTool – это специальный инструмент, который управляет
процессом сборки исходного кода в UnrealEngine 4. Он входит в состав
UnrealBuildSystem[2].
UnrealBuildSystem, помимо UnrealBuildTool, включает в себя
UnrealHeaderTool (инструмент синтаксического анализа и генерации кода)[2].
Компиляция происходит в два этапа:
1) Вызывается UnrealHeaderToolдля разбора заголовков С++ для
метаданных, связанных с Unreal-классом и генерирует специальный код для
реализации различных UObject-функций.
2) Стандартный компилятор C++ вызывается для компиляции
результата, полученного на предыдущем шаге.
#include "Runtime/Networking/Public/Networking.h" #include "Runtime/Networking/Public/Common/TcpSocketBuilder.h" #include "Runtime/Networking/Public/Interfaces/IPv4/IPv4Endpoint.h" #include "Runtime/Networking/Public/Interfaces/IPv4/IPv4Address.h" #include "Runtime/Sockets/Public/SocketSubsystem.h"
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Sockets", "Networking" });
35
3.2.2.1. Разработка сетевой части
Код:
Приведенный выше код позволяет устройству подключиться к порту 8000
сервера с IP-адресом 192.168.1.101.
Отправка сообщения выполняется при помощи следующего кода:
Код:
FSocket Socket = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_Stream, TEXT("default"), false); FString address = TEXT("192.168.1.101"); int32 port = 8000; FIPv4Address ip; FIPv4Address::Parse(address, ip); TSharedRef<FInternetAddr>addr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr(); addr->SetIp(ip.GetValue()); addr->SetPort(port); bool connected = Socket->Connect(*addr);
TCHAR *mesChar = mes.GetCharArray().GetData(); int32 size = FCString::Strlen(mesChar); int32 sent = 0; bool successful = Socket->Send((uint8*)TCHAR_TO_UTF8(mesChar), size, sent);
36
3.2.2.2. Разработка интерфейса
В данном приложении реализованы две кнопки из интерфейса
приложения «Монополия»: бросок кубиков и переход хода. При нажатии на
кнопку, на сервер отправляется сообщение: «1» - при нажатии на кнопку
«Бросок кубиков» и «2» - при нажатии на кнопку «Переход хода». Сервер
обрабатывает данные сообщения и вызывает на своей стороне
соответствующие функции.
Для реализации интерфейса в Unreal Engine 4 нужно создать Blueprint–
виджет. В редакторе нужно создать две кнопки (Button) (рис.3.7) и указать
функции, которые будут вызваны при нажатии на них (рис.3.8).
Рис. 3.7. Интерфейс приложения на основе UnrealEngine 4.
37
Рис. 3.8. Вызов функций из blueprint-редактора.
Функция SendMes (рис.2) определена в С++ классе. В теле этой функции
находится код, отправляющий сообщение на сервер (см. выше).
38
3.2.3. Qt Creator
Для работы с сокетами здесь используется заголовочный файл
sys/socket.h. Методы в нем полностью идентичны с методами библиотеки
WinSock, о которой говорилось выше.
Кроме рассмотренных выше методов стоит упомянуть о функции connect.
Она используется для обращения программы-клиента к серверу с запросом на
установление логического соединения.
Код:
Аргумент s задает дескриптор socket'а, через который программа
обращается к серверу с запросом на соединение. Socket должен быть
предварительно создан системным вызовом socket и обеспечен адресом с
помощью системного вызова bind.
Аргумент serverуказывает на структуру данных, содержащую адрес,
приписанный socket'у программы-сервера, к которой делается запрос на
соединение. Для сетей TCP/IP такой структурой является sockaddr_in.
Последний аргумент задает размер (в байтах) структуры данных,
указываемой аргументом server.
Для того, чтобы запрос на соединение был успешным, необходимо, по
крайней мере, чтобы программа-сервер выполнила к этому моменту системный
вызов listen для socket'а с указанным адресом.
На данный момент, задачей является разработка QML-приложения,
аналогичного уже разработанному приложению в UnrealEditor.
Для начала нужно описать интерфейс. Пример с кодом на языке QML
приведен в графическом приложении.
connect(s , (structsockaddr *)&server , sizeof(server));
39
Рис. 3.9. Интерфейс, описанный qml-файлами.
Теперь необходимо реализовать связь С++ и QML.
Для того чтобы увидеть на экране, то что описано в QML-файле, нужно в
конструкторе класса MainWindow (нужные файлы создаются автоматически,
при создании проекта QTWidgets с помощью QtCreator) добавить следующий
код:
Код:
//создаемобъектQDeclarativeView ui = new QDeclarativeView; //устанавливаем main.qmlв качестве источника ui->setSource(QUrl("qrc:/main.qml")); setCentralWidget(ui); ui->setResizeMode(QDeclarativeView::SizeRootObjectToView); //Находим корневой элемент Root = ui->rootObject(); //Соединяем C++ и QML, делая видимым функции С++ через элемент window ui->rootContext()->setContextProperty("window", this);
40
В деструкторе необходимо удалить созданный объект ui:
Код:
По нажатию кнопок, на сервер должны отправляться сообщения.
Содержание сообщений то же, что и в предыдущем случае.
Пример реализации функции, вызывающейся при нажатии на кнопку
«Бросок кубиков»:
Код:
Функция объявляется в классе MainWindow. Для того, чтобы эту
функцию можно было вызвать из QML-файла, перед объявлением этой
функции нужно прописать макрос Q_INVOKABLE[5].
Код:
Последнее, что осталось сделать – добавить в описание кнопки в файле
main.qml строку:
Код:
deleteui;
voidMainWindow::throwCubes() { char *mes = "1"; send(s , mes , strlen(mes) , 0); }
Q_INVOKABLE void throwCubes(); Q_INVOKABLE void changePlayer();
onClicked: window.throwCubes()
41
3.2.4. Выводы
В данном разделе были описаны инструменты, позволяющие
разрабатывать приложения для мобильных устройств. Это Android Studio,
Unreal Engine 4 и Qt Creator. С помощью каждого из них были разработаны
клиентские приложения.
Основными критериями выбора среды разработки для реализации
клиентского приложения является возможность реализовать динамическое
обновление интерфейса и кроссплатформенность самого приложения.
Этим требованиям отвечает вариант, описанный в пункте 3.2.3.
42
4. Разработка программной системы, реализующей
разработанные алгоритмы
В качестве примера программной системы, обеспечивающей
динамическое формирование интерфейса на удаленном устройстве, было
разработано игровое приложение «Монополия». На стороне сервера -
полноценное приложение, в котором реализована вся игровая логика. Сетевая
часть принимает сообщения от клиентов, обрабатывает их, и в зависимости от
сообщения, выполняет то или иное действие (игровые действия, отправка
файлов интерфейса, оправка данных наклиент для обновления его состояния).
Текущее состояние игрового поля отображается на экране.
На стороне клиента – приложение, разработанное на языке С++ и QML.
Выполняет прием QML-файлов и формирует интерфейс на их основе,
отправляет команды на сервер и обновляет интерфейс в соответствие с
данными, принятыми с сервера.
43
4.1. Разработка серверной подсистемы
Разработка серверной подсистемы была разбита на три части: разработка
визуальной части (создание необходимых трехмерных моделей, создание
материалов, разработка пользовательского интерфейса), разработка игровой
логики на языке С++ и разработка сетевой составляющей.
4.1.1. Разработка визуальной части
4.1.1.1. Создание необходимых трехмерных моделей
Для начала в пакете 3DSMaxнужно создать трехмерные модели объектов,
которые будут использоваться в игре (игровое поле, фишки игроков, фишки
домов и отелей, колоды карточек). К этим моделям необходимо применить
соответствующие материалы.
Для игрового поля материал удобно создать средствами пакета 3DSMax.
Поле представляет собой простой параллелепипед. К нему применяется
модификатор UnwrapUVдля того, чтобы получить его развертку. На основе
этой развертки создается текстура поля, в свойствах материала полученную
текстуру необходимо выбрать в качестве Diffuse (рис. 4.2).
Рис. 4.1. Модель поля в 3DS Max
44
Рис. 4.2. 3DSMaxMaterialEditor.
Материалы для остальных объектов будут созданы с использованием
непосредственно UnrealEngine 4.
Все созданные модели нужно импортировать в UnrealEngine 4.
Для того чтобы фишки игроков можно было отличить, нужно применить
к ним разные цвета. Для этого нужно создать динамический материал с
векторным параметром, который будет меняться в зависимости от номера
игрока. Предварительно были изучены видео – курсы категории “Materials”[6].
За основу был взят стандартный материал стали и добавлен векторный
параметр, отвечающий за цвет (рис 4.3).
45
Рис. 4.3. UE4 MaterialEditor. Динамический материал.
Созданный выше материал будет применен также и для моделей
недвижимости.
При создании материала для модели колоды карт стоит отметить одну
особенность. У колоды во время игры меняется высота. Поэтому у нее должно
соответствующим образом меняться отображение боковой текстуры. При этом
должно быть видно целое количество карт. Это проблема была решена
следующим образом. Была получена развертка колоды карт (развертка
параллелепипеда со скругленными краями), на развертке нижняя и верхняя
часть колоды нужно закрасить белым, а боковые части – черным. Затем, с
помощью функции Lerp, вместо белого цвета подкладывается текстура
«рубашки» карты, а вместо черного – текстура боковой поверхности. Для того
чтобы боковая текстура вела себя так как нужно, необходимо в настройках
самой текстуры в свойстве TilingMode выставить Wrap, затем в материал
добавить скалярный параметр, который нужно умножить на параметр
VTilingтекстуры. Осталось только в функции обновления игрового поля
46
сделать так, чтобы этот скалярный параметр изменялся пропорционально
высоте колоды.
Рис. 4.4. UEMaterialEditor. Материал для колоды.
Рис. 4.5. Демонстрация тайлинга текстуры.
47
4.1.1.2. Разработка интерфейса и функций обеспечивающих обновление
состояния игрового поля
В редакторе UnrealEngine 4 (UnrealEditor) необходимо создать blueprint–
класс Desk, который будет полностью описывать игровое поле, и виджеты,
отвечающие за прорисовку пользовательского интерфейса и главного меню. В
классе Desk с помощью blueprint - редактора будут разработаны функции
начальной инициализации, обновления игрового поля и обновления
пользовательского интерфейса.
Начальная инициализация подразумевает добавление на сцену колод
карточек и фишек игроков (количество игроков выбирается в главном меню),
присвоение им нужных материалов, а также подготовка необходимых данных
для игры, таких как координаты центров всех клеток на поле и т.д.
Функция обновления поля на вход принимает массив с номерами позиций
игроков и два числа (количество карт в колодах). Соответственно, функция
проходит циклом по массиву и расставляет фишки игроков на предварительно
рассчитанные позиции.
Рис. 4.6. Blueprint- редактор. Функция обновления игрового поля.
48
Функция обновления пользовательского интерфейса принимает на вход
целочисленный параметр – количество денег у игрока, булев параметр – статус
банкротства, целочисленный параметр – количество дней, которые осталось
провести в тюрьме, массив целых – номера карт, принадлежащих игроку. Все
эти параметры отображаются непосредственно на экране (рис. 4.7). При
разработке интерфейса помогли материалы категории UMG UI
DesignerVideos[6].
Рис. 4.7. Редактор виджетов. Пользовательский интерфейс.
Чтобы связать аргументы функции с тем, что мы видим на экране,
используются так называемые Bind’ы – специальные функции.
49
Рис. 4.8. Общий вид.
Далее нужно создать дочерний виджет – окно покупки недвижимости. Он
будет становиться видимым при нажатии на любую из карт в пользовательском
интерфейсе. Для этого нужно создать соответствующие методы. Также нужно
разработать методы покупки и продажи домов и отелей. При нажатии на
соответствующие кнопки, модели домов или отелей должны либо добавляться
на сцену, либо уничтожаться. Механизм назначения цветов используется тот
же, что и при инициализации фишек игроков. Позиции рассчитываются на
основе номера нажатой карты, уже известных координат центров клеток и
количества уже построенных домов. Для последнего случая создан отдельный
массив, где индекс элемента – это номер клетки, а значение элемента –
количество построенных домов. Для того чтобы постройки можно было
удалить, необходимо сохранять ссылки на эти объекты в отдельных массивах.
Для реализации функций покупки/продажи клеток можно добавить над
каждой клеткой дополнительную геометрию – плоскость. Теперь нужно создать
динамический материал. Нужно добавить в него две текстуры («куплено» и
«заложено»), параметр, который будет отвечать за отображение одной их них (0
50
– куплено, 1 – заложено), параметр, отвечающий за прозрачность (0 –
непрозрачно, отображается одна из двух текстур, 1 – прозрачно, то есть не
куплено) и векторный параметр, отвечающий за цвет игрока. При нажатии
одной из кнопок (купить, продать, заложить), устанавливается нужная
комбинация параметров. Механизм применения цвета уже не раз использовался
в данном проекте.
Рис. 4.9. Отображение построек и меток.
В каждой игре должно быть меню. Его можно создать на основе виджета.
Нужно добавить на него кнопки выбора количества игроков и выхода из игры.
Также необходимо создать нужные методы, которые будут записывать
количество игроков в переменную и передавать её в уже разработанный класс
Desk для последующей инициализации. При нажатии на одну из кнопок с
количеством игроков, виджет меню становится невидимым, запускается
инициализация и становится видимым виджет пользовательского интерфейса.
При нажатии кнопки выхода запускается стандартный метод выхода из проекта
51
4.1.2. Разработка логики
Логика игры была реализована на языке программирования высокого
уровня C++. В рамках данной задачи были описаны следующие классы:
Monopoly, MonopolyDestroyer, Player, Card, PropertyCard, ActionCard и Group.
Класс Monopoly в сочетании с классом MonopolyDestroyer представляет
собой улучшенную версию классической реализации паттерна
программирования Singleton[7], в котором хранятся неизменяемые на
протяжении всей игры данные в единственном экземпляре:
1) Указатель на текущего игрока: Player* currentPlayer.
2) Номер текущего игрока: intcurrentPlayerNum.
3) Методы задания текущего игрока и его номера:
setCurrentPlayer(Player* player), voidsetCurrentPlayerNum(intplayerNum).
4) Методы получения текущего игрока и его номера: Player*
getCurrentPlayer(),intgetCurrentPlayerNum().
5) Массивы аргументов, индексы текущих аргументов и вектора
указателей на функции-члены класса Player, необходимые для обработки полей
«Шанс» и «Общественная казна»: vector<pToFunc>vecComChest,
vector<pToFunc>vecChance, int comChestIndex,int chanceIndex, int
chanceArgument[16], int comChestArgument[16].
6) Методы получения индексов и указателей на функции полей
«Шанс» и «Общественная казна»: pToFuncgetVecComChest(int),
intgetChanceArgument(int), pToFuncgetVecChance(int),
intgetComChestArgument(int), intgetChanceIndex(),intgetComChestIndex().
7) Метод печати сообщений, упрощающий перенос логики игры на
технологию Unreal Engine: voidprint(string).
Объект данного класса создаётся при первом обращении к методу
getInstance(), доступ к нему также осуществляется с помощью этой функции с
указателем области видимости: Monopoly::getInstance().
52
Класс Player представляет собой класс игрока, содержащий необходимые
данные и методы для доступа к ним и их изменения. Количество объектов
данного класса соответствует количеству игроков.
1) Позиция игрока: int Position.
2) Флаг банкротства: bool bankrupt.
3) Количество денег: int money.
4) Количество карт вокзалов и коммунальных услуг: intnumOfOS,
intnumOfUtilities.
5) Количество оставшихся ходов в тюрьме: intjailed.
6) Флаг наличия карты освобождения из тюрьмы: boolhasJailFree.
7) Вектор купленных карт: vector<Card*>cards.
8) Методы изменения количества денег, карт вокзалов и
коммунальных услуг и позиции: voidchangeMoney(int),
voidchangeNumOfOS(int), voidchangePosition(int), voidchangeNumOfUtilities(int).
9) Методы добавления и удаления карт: voidaddCard(Card*),
voiddelCard(Card*).
10) Метод перемещения по полю: voidmove(int).
11) Методы получения количества денег, карт вокзалов и
коммунальных услуг и позиции: voidgetMoney(int), voidgetNumOfOS(int),
voidgetPosition(int), voidgetNumOfUtilities(int).
12) Методы проверки банкротства и нахождения в тюрьме:
boolisJailed(), boolisBankrupt().
13) Методы проверки наличия улиц и карты освобождения из тюрьмы:
boolhasStreets(), boolhasJailFree().
14) Метод отправки в тюрьму: voidtoJail().
15) Метод предложения продажи карты: boolsuggestCard(int, int, int).
16) Метод добавления карты освобождения из тюрьмы:
voidaddJailFree().
17) Метод проверки на банкротство: voidcheckBalance().
53
Абстрактный класс Card содержит методы и переменные, общие для
различных типов карт. От этого класса наследуются классы ActionCard и
PropertyCard.Количество объектов данного класса равно количеству игровых
полей.
1) Индекс карт: int index.
2) Тип карты TypeCard type.
3) Виртуальная функция действия, перегружаемая в наследуемых
классах virtualvoidAction(Player*).
4) Методы задания индекса и типа: voidsetIndex(int),
voidsetType(TypeCard).
5) Методы получения индекса и типа: TypeCardgetType(), intgetIndex().
Класс PropertyCard является классом-наследником типа public класса
Card. Описывает карты, которые игроки могут покупать и продавать, в связи с
чем обладает определенным набором функций.
1) Стоимость карты: intCardPrice.
2) Стоимость домов: inthousePrice.
3) Количество домов: inthouseCount.
4) Указатель на обладателя картой: Player* owner.
5) Массив налога в зависимости от количества построенных домов:
intrent.
6) Флаг залога: bool laid.
7) Указатель на группу, к которой относится карта: Group* cardGroup.
8) Методпокупкикарты void buyPropertyCard(Player*).
9) Методы задания стоимостей домов, налога, группы, самих карт:
void setHousePrice(int), void set Rent(int, int), void setGroup(Group*), void
setPrice(int).
10) Методы получения стоимости карты, владельца, группы:
intgetCardPrice(), Player* getOwner(), Group* getGroup().
11) Метод залога: void lay().
12) Метод проверки заложенности: boolisLaid().
54
13) Метод выкупа: void reBuy().
14) Перегрузка виртуальной функции: voidAction(Player*).
15) Метод постройки домов: voidbuildHouse().
16) Методпродажикарты void sell(Player*, int).
Класс ActionCard также является наследником типа public класса Card,
определяет поведение карт типа «Шанс», «Общественная казна», угловые поля.
Это поведение описано в перегруженной виртуальной функции абстрактного
класса CardvoidAction(Player*).
Класс Group необходим для группировки улиц, исходя из чего, даётся
возможность постройки домов и отелей.
1) Векторкарт vector<Card*> cards.
2) Метод добавления карт в группу voidAddCard(Card*).
3) Метод проверки укомплектованности группы владельцем
boolcheckAbility()).
На основе описанных классов была построена программная логика игры в
соответствии с правилами.
Далее описывается процесс подключения логики к приложению на
основе UnrealEngine 4.
Для этого нужно средствами мастера классов UnrealEngine 4 создать С++
класс, дочерний от класса GameMode. Такие классы редактируются в
VisualStudio. После создания класса, мастер генерирует нужные файлы и
заготовку класса.
Код:
Взаимодействие игры с логикой заключается в вызове С++ функций из
blueprint– классов, а также вызов blueprint– функций из С++ логики. Исходя из
UCLASS() class MONOPOLY_N_API AMyGameMode : public AGameMode { GENERATED_BODY() };
55
этого, нужно разработать такой класс, который станет неким связующим
звеном между двумя частями проекта.
В первом случае необходимо использовать макрос UFUNCTION( ).
Код:
Во втором примере, функция throwCube( ), определенная в С++ коде,
может быть вызвана из blueprint– класса. Опция BlueprintCallable указывает
возможность обработки данного метода в виртуальной машине blueprint'ов. Для
того, чтобы контекстное меню (вызываемое правой кнопкой мыши) работало
должным образом, каждый метод, вызов которого разрешен редактором,
должен содержать имя категории (Category = “Logic”). Изображение ниже
показывает, как именно категории отображаются в контекстном меню.
Рис. 4.11. Отображение С++ функций в blueprint-редакторе.
Во втором случае было решено поступить следующим образом:
использовать опцию BlueprintImplementableEvent, которая позволяет объявить
UFUNCTION(BlueprintCallable, Category = "Logic")
voidthrowCube(int32 &curPos, int32 &curPlayer, bool&dooble, bool&IsBuyEnable);
56
функцию в С++ классе, а определить её уже в blueprint– редакторе класса,
созданного на основе данного С++ класса.
Код:
Рис. 4.12. Определение функции, объявленной в С++ классе.
Ещё один полезный макрос: UPROPERTY( ).
Код:
В этом примере свойство класса curPlayerNumможно редактировать в
blueprint– редакторе.
В процессе работы над подключением логики широко использовалась
официальная документация[2] и статьи [8][9][10].
UFUNCTION(BlueprintImplementableEvent)
void UpdateField(constTArray<int32>&pos, int32 NumberOfChances, int32 NumberOfChests);
UPROPERTY(EditAnywhere, BlueprintReadWrite)
int32curPlayerNum;
57
4.1.3. Разработка сетевой части
Сетевая часть приложения «Монополия» будет реализована в отдельном
классе.
В Unreal Editor нужно создать новый С++ класс. Он будет
редактироваться в среде разработки VisualStudio. Затем, на его основе нужно
создать blueprint-класс. В итоге получен класс, который можно редактировать
как в blueprint-редакторе, так и в VisualStudio (все изменения С++ класса
автоматически применяются и для blueprint-класса, созданного на его основе).
Далее приведено описание методов разрабатываемого класса.
ListenerSock и ConnectionSock – указатели на сокеты сервера и клиента
соответственно.
StartReceiver– функция, в которой инициализируется ListenerSockи
запускается функция ConnectionListener. В качестве аргументов функция
принимает имя сокета, IP-адрес и порт. Возвращает falseв случае неудачи и
trueв обратном случае.
CreateConnectionListener – функция, которая собственно и производит
инициализацию ListenerSock. Вызывается внутри тела функции StartReceiver. В
аргументы те же, что и у StartReceiver, плюс размер буфера приемника.
Возвращает указатель на FSocket.
ConnectionListener – функция, которая отслеживает запросы на
установление соединения с сервером. В случае запроса на соединение
инициализируется ConnectionSock. В случае установления соединения
вызывается функция SocketListener.
SocketListener – функция, которая отслеживает входящие от клиента
сообщения. В случае имеющихся в потоке данных, они считываются в массив
типа uint8. После этого вызывается функция StringFromBinaryArray.
StringFromBinaryArray – принимает на вход массив типа uint8 и
преобразует его в объект типа FString. Это нужно для дальнейшей работы с
текстом.
58
FormatIP4ToNumber– преобразует IP-адрес строкового типа в массив типа
int32.
ServerSimple – инициализирует переменные IP-адреса и порта. Запускает
функцию StartReceiver. Функция вызывается в blueprint-редакторе из функции
инициализации.
BP_ThrowCubes и BP_ChangePlayer – функции, объявленные в С++
классе, а определенные в blueprint-редакторе. Вызывают разработанные
функции броска кубиков и смены игрока.
CheckMessage – обработчик сообщений. Вызывает необходимые функции
в зависимости от принятого сообщения.
SendResourceFile – функция, выполняющая отправку файла на
подключенный клиент. Принимает на вход название файла и путь к нему.
Выполняет отправку имени файла, а затем в цикле считывает блоки данных из
файла и отправляет их на клиент.
59
4.2. Разработка клиентской подсистемы
4.2.1. Разработка сетевой части
За основу клиентского приложения будет взято приложение,
разработанное в пункте 3.2.3.
Туда необходимо добавить функцию приема файлов, которые будут
описывать интерфейс, и функцию, которая будет менять текущий интерфейс
приложения на интерфейс, описанный в принятых файлах.
На начальном экране присутствует только одна кнопка. При нажатии на
нее выполняется отправка сообщения на сервер. Оно интерпретируется как
запрос на загрузку qml-файлов для формирования интерфейса. Сервер
запускает функцию, отправляющую необходимые файлы на клиент.
В свою очередь, клиент запускает функцию, которая выполняет прием
этих файлов.
Инициализация переменных для директорий, в которые будут
сохраняться ресурсные файлы:
Код:
Переменная path содержит название директории, в которой установлено
приложение.
Далее, эти директории создаются (в случае, если их нет).
Код:
maindir = "/my_app_folder"; dir = "/my_app_folder/ui_folder"; QString path = QDir().currentPath(); maindir = path + maindir; dir = path + dir;
if(!QDir(maindir).exists()) QDir().mkdir(maindir); if(!QDir(dir).exists()) QDir().mkdir(dir);
60
После этого, с помощью функции recv, клиент принимает от сервера
сообщение. Оно показывает количество файлов, которые сервер собирается
передать.
Затем в цикле происходит прием названия файла, переход в нужную
директорию и прием самого файла. Сразу же после приема строки файла, она
записывается в файл на клиенте.
Код:
После приема и сохранения файлов, они устанавливаются в качестве
источника для интерфейса приложения. Код идентичен коду, используемому в
конструкторе класса (см. п. 3.2.3.).
Код:
//прием одного файла //преобразование QString ->char* chartmp[BUF_SIZE]; QByteArraytempDir; tempDir = dir.toUtf8(); char *dir_ch=tempDir.data(); //смена директории chdir(dir_ch); //открытиефайла FILE *file = fopen(fname, "wb"); if (file == NULL) { return false; } intfrom_len = 0; //читаемстроку while ((from_len = recv(s, tmp, BUF_SIZE,0))>0) { //записьстроки fwrite(tmp, sizeof(char), from_len, file); if(from_len<BUF_SIZE) break; } fclose(file);
QDeclarativeView *view; view = new QDeclarativeView; QString temp = maindir + "/first.qml"; view->setSource(QUrl::fromLocalFile(temp)); setCentralWidget(view); view->setResizeMode(QDeclarativeView::SizeRootObjectToView); Root = view->rootObject(); view->rootContext()->setContextProperty("window", this); view->show();
61
4.2.2. Разработка масштабируемого интерфейса
При разработке интерфейса клиентского приложения, главной задачей
было создать такой интерфейс, который был бы читаем на любом экране, от
экрана компьютера до дисплея смартфона.
Обычно размеры элементов интерфейса задаются в пикселях. Однако при
одинаковом разрешении на экранах с различной диагональю получится
совершенно разный результат. Например, по кнопке, которая на компьютерном
мониторе имеет нормальный размер, на дисплее смартфона попасть будет
очень сложно.
В Android Studio для задания размеров элементов интерфейса можно
использовать так называемый density-independent pixel (dip). Это независимый
от плотности пиксель, который позволяет разрабатывать интерфейс
приложения, не задумываясь о том, сколько пикселей по ширине и высоте
нужно задавать для различных устройств.
В Qt такая возможность отсутствует. Однако можно разработать
отдельный объект с функцией, которая будет принимать dip и переводить их в
обычные пиксели.
Компания Google рекомендует использовать следующую формулу для
перевода dip в количество пикселей:
160
dpipx dp ,
где px - количество пикселей, dp - количество независимых от плотности
пикселей, dpi - количество пикселей на дюйм.
В Qt у объекта Screen есть функция pixelDensity, которая возвращает
количество пикселей на миллиметр. Чтобы получить количество пикселей на
дюйм, нужно умножить эту величину на 25.4. Количество независимых от
плотности пикселей – параметр функции. Рассмотренная выше формула
применима для дисплеев мобильных устройств (малая диагональ, относительно
большое разрешение). В случае отображения интерфейса на компьютерном
экране, производить перерасчет из dip в пиксели не требуется.
62
Пример реализации:
Код:
Для того чтобы размер шрифта на элементах интерфейса зависел от их
размера, можно использовать следующий код:
Код:
Рис. 4.13. Интерфейс клиентского приложения.
import QtQuick 2.0 import QtQuick.Window 2.0 Item { property int dpi: Screen.pixelDensity * 25.4 function dp(x){ if(dpi < 120) { return x; // Для обычного монитора компьютера } else { return x*(dpi/160); } } }
font.pixelSize: Math.round(height/2.2)
63
4.3. Выводы
В данном разделе был описан процесс разработки клиент-серверного
приложения «Монополия». В результате было разработано полноценное
серверное приложение «Монополия» на основе технологии Unreal Engine 4 и
универсальное клиентское приложение, написанное на языке С++ с
использованием технологии Qt. Интерфейс описан с помощью языка QML.
Оба приложения являются кроссплатформенными.
Клиентское приложение имеет возможность работать с любыми
серверными приложениями, реализующими необходимый алгоритм. Также
отсутствуют недостатки, присущие веб-браузерам (см. п. 1.1.1).
64
ЗАКЛЮЧЕНИЕ
В результате проделанной работы были исследованы основные
особенности создания приложений на основе Unreal Engine 4 и его сетевые
возможности. Исследованы библиотеки сетевого программирования. Также
исследованы средства разработки для мобильных устройств. В результате
проделанной работы было создано следующее программное обеспечение:
1) Консольная программа-сервер. Осуществляет прием сообщений и
вывод их в терминал. Осуществляет отправку файлов на клиент.
2) Программа-клиент для операционной системы Android. Разработана
с помощью AndroidStudio. Выполняет отправку введенного сообщения.
3) Кроссплатформенная программа-клиент на основе UnrealEngine 4.
Оправляет различные сообщения на сервер, в зависимости от нажатой кнопки.
4) Приложение «Монополия» с серверной частью на основе
UnrealEngine 4. Принимает сообщения от клиентов, обрабатывает их, и в
зависимости от сообщения, выполняет то или иное действие (игровые действия,
отправка файлов).
5) Кроссплатформенная программа-клиент. Разработана на языке С++
и QML. Выполняет прием файлов, динамически формирует интерфейс на
основе принятых файлов.
Данной работе был посвящен доклад на XVIII молодежной
международной научно-технической конференции «Наукоемкие и
интеллектуальные системы 2016»[11].
Разработанный в ходе работы проект был показан на благотворительном
фестивале будущего и развития «Импульс», который состоялся 23 апреля 2016
года.
65
БИБЛИОГРАФИЧЕСКИЙ СПИСОК
1. Гимейн Л.А., Козменко С.М. Документооборот и электронные архивы.
Насколько «тонок» клиент? [Электронный ресурс]: статья.- CADmaster
№5(35) 2006 (дополнительный). Режим доступа:
http://www.cadmaster.ru/magazin/articles/cm_35_tdms.html#hcq=eI12sKp
(дата обращения 31.05.16).
2. UnrealEngine 4 Documentation [Электронный ресурс] //
UnrealEngineTechnology: сайт. Режим доступа:
https://docs.unrealengine.com (дата обращения 14.12.15).
3. Федорук, В.Г. Сетевое программирование в ОС UNIX. [Электронный
ресурс] // Учебно-методические материалы к курсу «Разработка
программных систем» для бакалавров. Режим доступа:
http://fedoruk.comcor.ru/Dev_bach/netprg1.html (дата обращения 14.12.15).
4. AndroidDevelopers [Электронный ресурс]// сайт. Режим доступа:
http://developer.android.com/index.html (дата обращения 14.12.15).
5. QtDocumentation [Электронный ресурс]// Qt: сайт. Режим доступа:
http://doc.qt.io/ (дата обращения 14.12.15).
6. Unreal Engine Community Wiki [Электронный ресурс] // Unreal Engine
Technology: сайт. Режим доступа: https://wiki.unrealengine.com/Main_Page
(дата обращения 14.12.15).
7. Паттерны проектирования [Электронный ресурс] // CPP-
REFERENCE:сайт. Режим доступа: http://cpp-reference.ru/patterns/ (дата
обращения 14.12.15).
8. (Перевод) Введение в разработку C++ в UE4 [Электронный ресурс]
//Хабрахабр: интернет-портал. Режим доступа:
http://habrahabr.ru/post/254931/ (дата обращения 14.12.15).
9. (Перевод) Введение в разработку C++ в UE4 Часть 2[Электронный
ресурс] // Хабрахабр: интернет-портал. Режим доступа:
http://habrahabr.ru/post/257827/ (дата обращения 14.12.15).
66
10. UnrealEngine 4 для развития своих способностей[Электронный ресурс] //
Хабрахабр: интернет-портал. Режим доступа:
http://habrahabr.ru/post/249965/ (дата обращения 14.12.15).
11. Сериков, И.С. Сетевая репликация данных в кроссплатформенном ПО
для формирования интерфейса на удаленном устройстве [Текст] / 18-ая
Молодежная международная научно-техническая конференция
"Наукоемкие технологии и интеллектуальные системы 2016". - г. Москва,
МГТУ им. Н. Э. Баумана. 20 апреля 2016 г. – С. 111-114.
67
ПРИЛОЖЕНИЯ
