Подключение внешних библиотек в VisualD

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

  1. Создаём проект с помощью dub init dsfml_test (здесь dsfml_test — это имя нашего проекта)
    1. create
  2. Путём редактирования файла dub.json, добавляем в него необходимые зависимости
    2. json
  3. Генерируем проект для Visual Studio с помощью dub generate vstudio
    3. generate project
  4. Открываем получившийся проект в Visual Studio
    4. open soluton
  5. Открываем свойства проекта
    5. project properties
  6. Указываем путь к директории, в которой находятся нужные lib-файлы
    6. libs path

Собственно, это всё, что нужно сделать. Далее можно подключать необходимые модули и собирать проект. В моём случае это

import dsfml.graphics, dsfml.window, dsfml.system;

Скелетная анимация спрайтов с использованием Spine

Author: Mark Alexander
Перевод: Dmi7ry
Оригинал здесь

Version: GameMaker: Studio 1.3+

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

GameMaker: Studio теперь поддерживает этот тип анимации спрайтов — можно импортировать файлы, созданные с помощью программы Spine, которая является фантастическим инструментом для создания скелетной анимации (вы можете узнать больше о Spine здесь ). Обратите внимание, что Spine — это очень мощная программа с огромными возможностями и для того, чтобы объяснить, как это всё работает, одной короткой статьи совершенно не достаточно! Однако, мы дадим краткий обзор некоторых ключевых моментов, которые связаны с реализацией скелетной анимации в Gamemaker: Studio.

ПРИМЕЧАНИЕ: Spine имеет trial-версию, которая доступна для скачивания здесь: http://esotericsoftware.com/spine-download 

Обзор Spine

Spine позволяет создать «скелет», а затем менять его позу для создания анимации. Скелет состоит из «костей», которые могут быть соединены и перемещены относительно друг друга в установленный период времени, а на окончательную анимацию может быть натянута «шкурка» (то есть текстура) для финальной анимации. Для добавления в ваш проект GameMaker: Studio, эта анимация может быть экспортирована или в виде стрипа растрового спрайта, или в виде Spine JSON файла.

Spine_MainScreen

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

Например, вы можете иметь один спрайт и создать несколько анимаций для него (например, набор анимаций из ходьбы, бега и прыжков). Можно создать несколько скинов для вашей анимации, так что один скелет может быть использован для разных персонажей (с теми же движениями, конечно), и вы также можете присоединять к своим спрайтам «вложения», чтобы в дальнейшем менять их внешний вид. Также все эти вещи доступны для использования в GameMaker: Studio при импорте JSON спрайтов.

ПРИМЕЧАНИЕ: вы можете найти дополнительную документацию о том, как использовать Spine, здесь: http://esotericsoftware.com/spine-documentation/

Основы

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

Также вам нужно обратить внимание на то, где находится центр вашей анимации (то есть её основа, корень, root). Центр анимации — это точка, относительно которой Spine анимация будет закреплена в мировом пространстве. При импорте вашего спрайта в GameMaker: Studio, она будет переведена как координаты центра спрайта (orign), которые нельзя редактировать в этом типе спрайта. Большинство ваших расчетов для движущихся частей скелета также будут зависеть от этой точки.

 Spine_Root

При создании анимации, вы устанавливаете позу, а затем создаёте ключевой кадр из неё. После этого вы перемещаетесь по таймлайну для анимации и создаёте ещё один ключевой кадр. После выполнения этого, Spine будет интерполировать данные кости между ключевыми кадрами, чтобы получить плавную анимацию, которую затем можно назвать и сохранить. Вы можете создать несколько наборов анимаций для одного спрайта, и дать каждой из них отдельное название. Затем это название может быть использовано в GameMaker: Studio для установки позы скелетной анимации вашего импортированного спрайта.

Также к вашим Spine спрайтам можно прикрепить «слоты» — это точки, где вы можете отображать отдельное изображение, который не имеет костей. Оно будет перемещаться вместе с родительской костью, что позволит вам добавить вашим анимациям несколько под-изображений, для крепления в пределах одного спрайта. Эти прикрепляемые слоты также должны быть названы в соответствии с изображениями, которые они содержат, так как эти имена будут использоваться в GameMaker: Studio для изменения изображения слота во время игры.

Импорт спрайта Spine

При экспорте спрайта со скелетной анимацией из Spine как JSON, вы на самом деле создадите три отдельных файла. Основной JSON, который содержит все данные костей и анимации, файл атласа, который содержит данные о том, как упакованы текстуры и файл PNG, который содержит непосредственно текстурный атлас. GameMaker: Studio требуются все три файла для создания вашего Spine спрайта, поэтому при импорте они все должны быть в той же папке.

Spine_Import

Добавление таких спрайтов в GameMaker: Studio практически идентично добавлению обычных растровых изображений: нужно создать новый спрайт, и вызвать обычный диалог загрузки спрайта. Перед тем, как выбрать место, в которое вы сохранили ваши spine-спрайты, нужно убедиться, что тип файла в нижней части выбран *.json и далее просто выбрать спрайт, который вы хотите импортировать.

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

ПРИМЕЧАНИЕ: В связи со сложностью скелетных анимаций, полученное изображение, показанное в редакторе спрайта, не предназначено для точного представления анимации, а всего лишь даёт вам простой образ, представляющий анимацию, для визуализации в редакторе комнаты.

Использование спрайтов Spine в GameMaker

После загрузки спрайта в GameMaker: Studio, вы можете использовать его так же, как и любой другой спрайт. Вы можете назначить его объекту, или установить его для экземпляра в коде, и они также будут реагировать на большинство переменных экземпляра спрайта: во время игры их можно масштабировать, вращать, смешивать с цветом и задавать прозрачность. Также их можно рисовать с помощью расширенных функций draw_sprite (за исключением draw_sprite_pos и draw_sprite_part), как и любой другой спрайт.

Spine_GMSprites

И всё же основной смысл в использовании Spine — это создание спрайта со скелетной анимацией с несколькими позами и скинами, что достаточно сильно отличается от обычного растрового спрайта. Для этого GameMaker: Studio имеет множество новых функций skeleton_*, а также новое событие «Animation Update» (обновление анимации) событие для поддержки такого типа спрайтов. Далее в этой статье будут рассмотрены эти функции и описано, что они делают, но вы можете найти более полное объяснение каждой из них в документации.

Анимации

skeleton_animation_get()

skeleton_animation_set(name)

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

skeleton_animation_get_ext(track)

skeleton_animation_set_ext(name, track)

Это похоже на предыдущие функции, но немного сложнее. Spine позволяет вам задать костную анимацию для части скелета, а затем создать отдельные наборы анимации для этих частей и проигрывать их вместе. Каждая анимация присвоена треку, и при этом track0 всегда является основой, анимацией по умолчанию. Таким образом, вы можете иметь, например, фигуру с присвоенной ей анимацией «ходьба» и эта анимация влияет только на ноги. Далее вы можете иметь различные другие анимации (где перемещаются, например, только руки, или голова, или верхняя часть туловища и т.д.) и назначить одну из них на трек 1, используя эти функции. И GameMaker: Studio будет играть обе эти анимации вместе.

skeleton_animation_mix

Эта маленькая функция, возможно, одна из наиболее важных, когда дело касается окончательного внешнего вида вашего импортированного спрайта. Вы можете изменить анимацию в любое время с помощью упомянутой выше функции skeleton_animation_set(), но при этом image_index будет сброшен в 0, что может сделать «скачок» при переходе, так как одна поза меняется на другую. Для растровых спрайтов это вполне ожидаемо и может быть даже желательным, но со скелетной анимацией спрайтов это выглядит странно и багнуто. Однако это можно исправить это с помощью функции skeleton_animation_mix(), которая будет интерполировать данные наборов анимаций, чтобы они плавно перетекали друг в друга естественным образом.Например, вы можете установить смешивание вашей анимации «бег» в анимацию «прыжок», затем установить следующее смешивание — теперь анимацию «прыжок» в анимацию «бег» — и теперь ваш спрайт будет плавно анимироваться между двумя этими наборами естественным образом.

Скины

skeleton_skin_get()

skeleton_skin_set(skinname)

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

Spine_TexturePacker

Прикрепления

skeleton_attachment_get()

skeleton_attachment_set(slotname, imagename)

skeleton_attachment_create(imagename, sprite, ind, xo, yo, xs, ys, rot);

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

Отображение

skeleton_collision_draw_set(flag)

draw_skeleton_collision(sprite, animname, image_index, x, y, xscale, yscale, rot, colour)

draw_skeleton(sprite, animname, skinname, image_index, x, y, xscale, yscale, rot, colour, alpha)

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

Spine_Masks

Заключение

Исходя из написанного выше, вы можете понять, что скелетная анимация — это невероятно мощный инструмент. Это позволяет получить естественные анимации с минимальными усилиями, и (спасибо функции смешивания) эти анимации плавно перетекают друг в друга, чтобы пользователи получали только положительный опыт в ваших играх. Функции скинов и фиксации, доступные в GameMaker: Studio также означают, что вы можете упростить создание нескольких спрайтов из одного источника, и также позволяют игроку настроить их прямо во время выполнения игры. Очевидно, что это система не применима ко всем играм, но если вы проверите веб-сайт Spine и демо, вы увидите, что это на удивление универсально и определённо стоит времени и усилий, необходимые на создание спрайта и его импорта в GameMaker: Studio.

Аксессоры к структурам данных и массивам в GameMaker: Studio

Перевод: Dmi7ry
Оригинал: James Foreman

Последнее обновление (начиная с версии 1.2.1261]) GameMaker: Studio добавляет интересный дополнительный функционал для некоторых структур данных и обычным массивам, называемый «аксессоры» (Accessors, методы доступа). Эти аксессоры являются простыми логическими выражениями, которые позволяют вам добавлять или изменять значения в этих структурах и записываются таким образом, будто вы работаете с массивами, с тем отличием, что используется специальный идентификационный символ перед первым аргументом, который говорит GameMaker: Studio, что вы работаете со структурой данных (заранее созданной), либо напрямую с исходным массивом.

Вы можете добавлять, заменять и получать значения и ключи для следующих типов структур данных: ds_maps, ds_lists и ds_grids, каждый из которых имеет свой собственный символ для доступа, изменения или установки значения, как показано ниже. Для массивов этот функционал даёт вам прямой доступ к исходному массиву, передаваемому в скрипт, взамен стандартного поведения, когда передаётся копия массива, которое обычно и ожидается (это объясняется в конце статьи).

Также обратите внимание, что символы, выбранные для обозначения метода доступа, были выбраны в соответствии с их мнемонической природой (например, # — это идентификатор для ds_grid), что делает их более лёгкими для опознавания и запоминания.

ds_list [| ]

Синтаксис для списков следующий:

list_index[| index]

После создания списка с помощью ds_list_create(), вы можете использовать индекс списка, который у вас сохранён в переменной, для обращения к нему. Значение index здесь указывает на позицию элемента в списке, который вы хотите добавить или установить. Например, следующий код создаёт список и добавляет 10 записей, каждая из которых будет содержать случайное число от 0 до 9:

ds = ds_list_create();

var index = 0;

repeat(10)
{
    ds[| index++] = irandom(9);
}

После создания вашего списка и заполнения его данными, чтобы получить значение из списка, нужно сделать что-нибудь типа этого:

value = ds[| 5];

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

ds​_map [? ]

Синтаксис для карт следующий:

map_index[? key]

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

ds = ds_map_create();

ds[? "Name"] = "Hamish";

ds[? "Company"] = "MacSeweeny Games";

ds[? "Game"] = "Catch The Haggis";

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

value = ds[? "Name"];

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

ds_grid [# ]

Синтаксис для сеток следующий:

grid_index[# xpos, ypos]

После создания вашей сетки с помощью ds_grid_create(), вы должны использовать индекс сетки, сохранённый в переменной, чтобы обращаться к ней. Значения «xpos» и «ypos» указывают на элемент сетки, который необходимо записать или прочитать. Например, следующий код создаёт сетку, очищает её нулём и после добавляет несколько записей в неё:

ds = ds_grid_create();

ds_grid_clear(ds, 0);

var gw = ds_grid_width(ds) - 1;

var gh = ds_grid_height(ds) - 1;

repeat(10)

{
    var xx = irandom(gw);

    var yy = irandom(gh);

    if ds[# xx, yy] == 0 ds[# xx, yy] = 1;
}

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

value = ds[# mouse_x div 16, mouse_y div 16];

Этот код получает значение из сетки, основываясь на координатах мыши (поделенных на размер «клетки» в комнате, чтобы получить корректную позицию).

Массивы.

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

//CREATE EVENT
a[9] = 0; //initialise a 10 value array

​
//CALL A SCRIPT WITH THE ARRAY
a = scr_Set_Array(a);

 
//SCRIPT
var temp_a = argument0;

temp_a[3] = 10;

return temp_a;

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

array[@ val]; //1D array

array[@ val, val]; //2D array

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

//CREATE EVENT
a[9] = 0; //initialise a 10 value array


//CALL A SCRIPT WITH THE ARRAY
a = scr_Set_Array(a);


//SCRIPT
var temp_a = argument0;

temp_a[@ 3] = 10;

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

Расширения для iOS и Android в GameMaker: Studio

Перевод статьи iOS & Android Extensions
Автор: James Foreman
Перевод: Dmi7ry

Буду благодарен сообщениям об опечатках и улучшениях перевода.

 

Обновление версии 1.3 вносит в GameMaker: Studio много новых и интересных функций: SWF-импорт, Push-уведомления, переработанную систему внутриигровых покупок. Тем не менее, возможно, что самой важной частью этого обновления является открытие системы расширений, что позволит использовать сторонние SDK и нативный код в Ваших играх.

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

Стоит отметить, что расширения для платформы iOS должны быть написаны с использованием Objective C++, в то время как расширения для Android должны писаться на Java. В данной статье предполагается, что если Вы пишете, либо используете нативные расширения, то у вас уже есть практические знания нативного языка для выбранной платформы.

 

Приступаем

Создание расширений в GameMaker: Studio просто и требует от вас клика правой кнопкой мыши на папке Extensions в дереве ресурсов и последующего клика на «Create Extension».

После этого появится окно Extension Package Properties (свойства пакета расширений), в котором, во вкладке General, Вам нужно заполнить поля «name» (имя), «author» (автор) и другие, для расширения, которое Вы создаёте. Сделав это, Вам нужно заполнить детали формы для выбранной платформы в соответствующей вкладке. Обратите внимание, что пакет расширений может содержать расширения для нескольких платформ. Поэтому, если у вас есть стороннее SDK с файлами для Android и iOS, Вы можете создать один пакет, который будет содержать и то и другое. Затем в своей конфигурации нужно установить, чтобы экспортировалось только то, что Вам нужно (подробнее об этом позже).

Каждый тип расширений требует, чтобы Вы указали ClassName (имя класса), идентифицирующий его, и Source Directory (исходная папка). Это исходная папка, так как расширения для платформ iOS и Android не требуют, чтобы Вы добавляли файлы непосредственно в GameMaker: Studio, как расширения JS или DLL (хотя для корректной работы они, в настоящее время, требуют файл-болванку, как описано далее в этой статье). Вместо этого, во вкладке Вы должны указать на Ваши папки со сторонними расширениями или пользовательскими файлами — тогда GameMaker: Studio скомпилирует требуемые файлы из них в Вашу игру.

Если Вы создаёте расширение iOS, есть некоторые дополнительные поля, которые, возможно, Вам потребуется заполнить: Mac Source Directory, необходимый для любых SDK, требующих symlinks, Linker Flags, так как некоторые фреймворки и сторонние SDK требуют добавление дополнительных флагов в компоновщик и, наконец, любые системные и сторонние фреймворки, которые Вам необходимы.

Если Вы работаете с Android, то есть только два поля, которые может понадобиться заполнить: разрешения, требуемые Вашему расширению (Permissions) и любые дополнительные записи для манифеста (Android Manifest XML). Необходимые Вам разрешения будут полностью зависеть от того, что использует расширение и Вам нужно смотреть документацию Google, либо документацию, поставляемую с выбранным SDK, чтобы найти те, которые Вам нужны. Что касается Android Manifest, здесь Вы добавляете любую дополнительную информацию к манифесту, которая может требоваться для Вашего расширения, которое будет внедрено (добавлено), когда Ваша игра будет собираться для тестирования или финального релиза.

 

Создание нативного расширения — Общие

Ниже приведены основные шаги создания iOS или Android расширения и вызов функции, использующей нативный код. В данном случае мы добавим в GameMaker: Studio одну новую функцию, которая будет использовать Objective C++ на iOS для вывода информации в консоль iPhone Configuration Utility на Вашем рабочем Mac, а на Android отправляет ту же самую информацию в ADB-консоль.

Основы

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

Создание расширения

Теперь нужно создать наше расширение. Для этого нужно кликнуть правой кнопкой мыши на папке Extensions в дереве ресурсов и выбрать «Create Extension», после чего откроется окно Extension Package Properties и здесь (для нашего простого примера) Вам нужно заполнить только общую информацию (General information), затем нажать «Okay» для продолжения.

Добавление файла-болванки.

Для JS, GML и DLL расширений, Вам требуется файл, содержащий необходимый код. Однако для iOS и Android этот файл не используется, но GameMaker: Studio по-прежнему требуется файл для «группировки» Ваших функций расширения и констант (это может измениться в будущих обновлениях). Поэтому Вам необходимо создать файл-болванку, который может иметь любой формат, кроме .js, .gex или .dll и добавить его (для нашего примера назовём его как-нибудь типа «extension.ext»).

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

 

Создание нативного расширения — iOS

Теперь, когда Вы подготовили свой файл для группировки функций и констант, которые Вы собираетесь использовать в Вашей тестовой игре, мы должны добавить файлы с исходным Objective C++ кодом, которые собирается использовать расширение. Для этого сделайте двойной щелчок по папке Extension Package и кликните по вкладке iOS, чтобы открыть свойства для этой платформы.

Для такого простого примера, Вам нет необходимости волноваться ни о каких других деталях, кроме исходного каталога (Source Directory) и имени класса (Class Name), поэтому просто установим их сейчас. Папка — место, куда мы собираемся сохранить необходимые исходные файлы, а имя класса может быть чем-нибудь простым, вроде «GenericExtension».

Теперь, в проводнике Windows, перейдите в каталог, который Вы выбрали для исходного кода Вашего расширения и создайте папку с именем «Source» (если назвать любым другим именем, кроме «Source«, то GameMaker: Studio просто не найдёт его). В этой новой папке Вы должны создать два файла для своего кода – .mm и .h файлы. Для этого примера мы назовем их GenericExt.mm и GenericExt.h. В файл GenericExt.h добавьте строку

@interface YourClassName :NSObject

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

-(void) genexttestdummy_Function1:(char *)arg1 Arg2:(double)arg2 Arg3:(char *)arg3;

Обратите внимание, что первый параметр следует непосредственно после двоеточия и ему не требуется имя, но последующие параметры должны быть с именем «ArgN«, за которым следует двоеточие, затем тип (либо double, либо char *) в скобках и, наконец, имя, которое будет использоваться в определении функции — arg2, arg3 и т.д.

После объявления членов своих функций, добавьте «@end», чтобы закрыть объявление интерфейса.

В .mm файле мы сначала подключим .h:

#import “GenericExt.h”

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

@implementation GenericExtClass

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

 

Создание нативного расширения — Android

С расширениями для Android все несколько проще… Мы действительно должны создать только исходный файл Java, который собирается использовать расширение и «указать» GameMaker: Studio на него. Для нашего простого примера, Вы не должны волноваться о деталях манифеста и разрешениях. Таким образом, в окне свойств Extension Package, на вкладке Android, просто задайте имя класса (типа «GenericExtension«) и укажите папку, в которой Вы собираетесь хранить свой Java файл для использования.

Теперь, в проводнике Windows перейдите в каталог, который Вы выбрали, чтобы найти исходные файлы Вашего расширения и создайте папку «Java» (и опять, если назвать любым другим именем, кроме «Java«, то GameMaker: Studio не сможет найти его).

В этой новой папке необходимо создать файл с Java-кодом. Для нашего примера просто создайте файл с именем «GenericExtension.java», не забывая включить следующую строку в верхней части Вашего кода Java:

package ${YYAndroidPackageName};

Теперь Вы можете создать свое определение класса, которое включает функцию, которую Вы хотите вызвать. В нашем примере Вы должны будете создать класс «GenericExtension» с функцией, названной genextestdummy_Function1, принимающей три параметра — String, double, string. Для простоты, в этом примере просто сделайте вывод параметров в ADB-консоль, чтобы проверить, что функция была вызвана правильно.

Создание GML-функции

Затем Вы должны добавить объявление функции к нашему расширению в GameMaker: Studio так, чтобы Ваш код мог вызвать Вашу новую Java-функцию. Чтобы сделать это, нажмите правой кнопкой мыши по файлу группы, который Вы добавили (файл-болванку), и выберите “Add Function”. Откроется новое окно, где Вы можете добавить свою функцию и присвоить ей параметры и свойства.

В соответствии с код, созданным ранее, Вы должны указать имя функции (Function Name) как «genextestdummy_Function1«, и Вы должны также определить внешнее имя, которое будет тем же самым. Теперь установите три параметра, которые принимает функция (string, double, string), и нажмите кнопку «Okay«, чтобы сохранить изменения.

Вызов функции нового расширения

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

genexttestdummy_Function1("Hello", 100, "World");

При тестировании игры на выбранном устройстве, нажатие и отпускание этой кнопки должно приводить к отображению переданных параметров в консоли Configuration Utility iPhone на Mac или в консоли ADB на Вашем PC.