В этом руководстве я объясню, как создать гибкую систему инвентаря-сетки для вашей игры, которая будет похожа на те, что есть в Deus Ex, S.T.A.L.K.E.R. и Pathologic 2. Вы сможете с нуля написать эту систему пошагово, либо, если у вас уже есть игра, внедрить ее в свой код. Я постарался написать это руководство максимально подробно, так что в нем будут затронуты некоторые принципы работы самого движка, но даже если вы используете не GameMaker, а другой движок, статья все равно может быть вам полезна.
Перед началом
Для старта понадобится объект игрока и какой-нибудь другой объект, пусть это будет сундук (oChest). У обоих объектов будет инвентарь.
Также подготовим несколько спрайтов на тест для визуализации предметов инвентаря. В этом руководстве размер одной ячейки в сетке равен 32 на 32 пикселя, поэтому и спрайты предметов размером 1 на 1 клетку будут иметь размер 32x32, предметов 1x2 - 32x64 и т.д.. spItemError нужен на случай ошибки загрузки предмета.
spApple - 32x32
spItemError - 32x32
spMysteriousPackage - 64x64
spWaterBottle - 32x64
Еще нужна комната, где мы будем тестировать систему инвентаря, я назову ее rTest. В ней нужно расставить экземпляры объектов игрока и сундука.
Инициализация глобальных переменных для работы с инвентарем
Нам понадобятся некоторые глобальные переменные для работы системы инвентаря. Безопасной практикой объявления глобальных переменных считается их объявление сразу после запуска игры. Есть несколько хороших способов объявить глобальные переменные:
в отдельной «стартовой» комнате, в коде создания комнаты (Room Creation Code)
в отдельном объекте‑менеджере, размещенном в самой первой комнате и самым первым в списке очереди создания экземпляров объектов
в отдельном скрипте, который в свою очередь может быть вызван как в Room Creation Code, так и в событии Create объекта‑менеджера
Я рекомендую объединить первые два пункта: создать отдельную комнату (rInit), которая будет самой первой при запуске, и разместить туда объект-менеджер (oGameManager), но только без использования Room Creation Code. oGameManager должен быть Persistent-объектом, то есть он не должен уничтожаться при смене комнат, а должен существовать с момента создания и до закрытия игры.
О том, почему я советую именно такой способ, я напишу отдельную статью. Когда она будет опубликована, здесь появится ссылка на нее.
Сейчас это единственный экземпляр в комнате, но в дальнейшем при добавлении других объектов он должен быть первым в списке очереди инициализации.
В событии Create напишем следующее:
global.ItemDB = ds_map_create();
room_goto(rTest);global.ItemDB - это список всех предметов, существующих в игре, представленный в виде структуры данных ds_map, которая хранит пары ключ-значение. В нашем случае ключ - это идентификатор предмета (id), а значение - структура, описывающая его (struct). При работе с инвентарем мы будем обращаться к предметам, хранящимся в global.ItemDB, через их идентификатор (ключ), и получать структуру, описывающую эти предметы (значение)
room_goto(index) перебрасывает нас в нужную комнату
Факт смены комнаты не помешает созданию следующих в очереди экземпляров (тех, что вы, возможно, позже разместите ниже oGameManager в меню, которое выделено на скриншоте), потому что функция room_goto(index) не сразу меняет комнату, а только по завершению всех событий текущего кадра игры. Например, сразу после oGameManager у меня стоит Persistent-объект oInputHandler, который управляет обработкой нажатий клавиш, и он успешно успевает создаться (событие Create) перед сменой комнаты.
ini-файл
Создадим ini-файл, в котором будут описаны предметы, которые мы будем загружать в память при запуске игры. Структура ini-файла такая:
[раздел]
ключ1=значение
ключ2=значение
ключ3=значение
...
В нашем случае каждый раздел - идентификатор отдельного предмета, ключи - характеристики предмета (имя, описание, тип и т.д.), а значения - это, неожиданно, значения характеристик. Для теста я использую такой ini-файл, в котором описаны 3 разных предмета.
Каждый предмет здесь представлен в виде структуры из 7 полей:
Name — имя предмета (не то же самое, что и id)
Type — тип предмета (снаряжение, еда, оружие и т. д.)
Width, Height — размеры предмета в ячейкахMaxStack — максимальное количество предметов в одном стаке
Sprite — название спрайта (который вы создали в самом GameMaker — spApple, spWaterBottle и т. д.) предмета
Description — описание предмета
Разумеется, вы можете убрать часть полей или добавить новые.
Этот ini-файл нужно добавить по следующему пути: название_проекта\datafiles. После этого он появится в разделе Included Files.
Скрипт scInventoryGlobalDatabase
Создаем скрипт scInventoryGlobalDatabase, он будет предназначен для работы с самой базой данных предметов. В нем объявим функцию loadItemDefinitions, которая будет инициализировать global.ItemDB, считывая данные о предметах из ini-файла. Она будет выглядеть так:
function loadItemDefinitions()
{
ini_open("items.ini");
var i = 0;
while (ini_section_exists(i))
{
global.ItemDB[? i] =
{
Name: ini_read_string(i, "Name", "nameerror"),
Type: ini_read_string(i, "Type", "typeerror"),
Width: ini_read_real(i, "Width", 1),
Height: ini_read_real(i, "Height", 1),
MaxStack: ini_read_real(i, "MaxStack", 1),
Sprite: asset_get_index(ini_read_string(i, "Sprite", "spItemError")),
Description: ini_read_string(i, "Description", "descrerror")
};
++i;
}
ini_close();
}Функция ini_open(fname) принимает в качестве аргумента строку, хранящую имя ini-файла с его расширением, она открывает файл для прочтения и редактирования.
Далее мы запускаем цикл, который заканчивается тогда, когда все предметы прочитаны. Чтобы цикл успешно прошелся по каждому предмету, они должны иметь идентификаторы со значением от i до N, где N - количество ваших предметов. Главное, чтобы на этом промежутке не было пропусков.
Выражение global.ItemDB[? i] означает, что мы обращаемся к элементу этого списка с ключом i (предмету с идентификатором i). Выражение global.ItemDB[i] в данном случае привело бы к ошибке при компиляции, потому что компилятор думал бы, что вы пытаетесь обратиться не к структуре данных map, а к обычному массиву.
Иными словами, конструкция [? i] - это акцессор (accessor), который нужен для быстрого доступа к определенному элементу, но для разных структур данных есть свои акцессоры. Например, для ds_grid, которую мы чуть позже будем использовать, акцессор выглядит так: [# i, j].
Создаем структуру для ключей каждого элемента global.ItemDB, состоящую из 7 полей, которые описывают предмет. В соответствии с типом считываемых данных используем либо ini_read_string (для строк), либо ini_read_real (для чисел). Обе функции принимают 3 аргумента. Первый - раздел в ini-файле (тот, что обернут в квадратные скобки), второй - ключ, значение которого нам нужно прочитать, третий - значение, которое будет возвращено функцией в случае неудачного прочтения, например, если указанного раздела или ключа в файле не существует.
В конце мы закрываем файл функцией ini_close().
Добавим в этот же скрипт следующую функцию:
function getItemFromGlobalDatabase(_itemID)
{
if (ds_map_exists(global.ItemDB, _itemID))
return global.ItemDB[? _itemID];
return undefined;
}Эта функция будет принимать идентификатор предмета и возвращать его структуру. Если мы передаем несуществующий идентификатор, функция вернет undefined.
В событии Create объекта oGameManager перед строкой room_goto(rTest); добавим следующую строчку:
loadItemDefinitions();Она запустит функцию, которая проинициализирует global.ItemDB.
На этом работа с парсингом ini-файла и инициализации global.ItemDB закончена. Следующим этапом будет создание самого инвентаря.
Общие принципы работы инвентаря
Инвентарями мы сможем наделять как объект игрока, так и другие объекты (сундук, мусорное ведро на улице, другой NPC и т.д.)
Так как инвентарь, который мы создаем, будет сетчатым, мы воспользуемся встроенной в GameMaker структурой данных ds_grid, которая, по сути, является двумерным массивом с некоторыми улучшениями для упрощения работы. Наш инвентарь и будет являться контейнером ds_grid, просто мы напишем дополнительные функции для работы с ним
Предметы, размещаемые в сетке, могут иметь разные размеры (1x1, 1x2, 2x2 и т.д.), нам нужно это учитывать при добавлении, перемещении и удалении этих предметов. В структуре предмета есть поля, отвечающие за его размер (Width и Height)
В одной и той же ячейке может находиться несколько предметов одного типа, но не более, чем значение поля MaxStack структуры предмета
Учитывая все перечисленное, составим примерное описание того, как будет выглядеть хранение предметов в инвентаре:
Левая верхняя (основная) ячейка предмета в инвентаре - структура, содержащая поля itemID и quantity. Обращаясь к какому-либо предмету в инвентаре, мы будем обращаться именно к основной ячейке этого предмета, тем самым получать его идентификатор и количество таких предметов в этой ячейке, а так как мы знаем идентификатор, то можем и узнать всю информацию об этом предмете через функцию getItemFromGlobalDatabase(_itemID)
Все остальные ячейки предмета инвентаря, кроме основной - структуры со значениями refX и refY, которые являются координатами основной ячейки. Через побочные ячейки мы сможем находить основную
Если ячейка в сетке инвентаря ничем не занята, она будет принимать значение noone
Скрипт scInventoryGrid
В этом скрипте будут все функции для работы с сеткой инвентаря. На каждую функцию я оставил подробные комментарии.
Создаем сетку инвентаря
//создание инвентаря размерами _width на _height
//возвращает созданную сетку инвентаря
function inventoryCreate(_width, _height)
{
var grid = ds_grid_create(_width, _height);
ds_grid_clear(grid, noone); //инициализируем все ячейки значением 'noone' (пусто)
return grid;
}Уничтожаем сетку инвентаря
//уничтожение инвентаря
//возвращает true в случае успешного удаления и false, если указанный инвентарь не существует
function inventoryDestroy(_inventoryGrid)
{
//структуры, хранившиеся в сетке, будут удалены автоматически
if (ds_exists(_inventoryGrid, ds_type_grid))
{
ds_grid_destroy(_inventoryGrid); //просто уничтожаем саму сетку
return true;
}
else
{
return false;
}
}Получаем размеры предмета в клетках (ячейках). Здесь мы используем функцию getItemFromGlobalDatabase(_itemID), чтобы найти предмет по его id
//получаем размеры предмета в клетках (ячейках)
//возвращает структуру, описывающую размеры предмета или undefined, если указанного предмета не существует
function inventoryGetItemDimensions(_itemID)
{
var itemData = getItemFromGlobalDatabase(_itemID); //ищем предмет в ItemDB
if (itemData != undefined) //нашли предмет в ItemDB
{
return
{
w : itemData.Width,
h : itemData.Height
};
}
else //не нашли (предмета нет)
{
return undefined;
}
}Функция, проверяющая возможность размещения предмета по указанным координатам. Аргументы cellX и cellY - координаты основной ячейки. Мы проверяем все ячейки, которые будет занимать предмет, отталкиваясь от координат основной. Таким образом, если мы, например, размещаем предмет размером 2x2 в ячейке (3;4), то функция вернет true только в том случае, если ячейки (3;4), (4;4), (3;5) и (4;5) будут свободны
//можем ли разместить предмет _itemID в инвентаре _inventoryGrid в ячейке с координатами (_cellX;_cellY)
//возвращает true, если можем разместить предмет в указанном месте и false, если нет
function inventoryCanPlace(_inventoryGrid, _itemID, _quantity, _cellX, _cellY)
{
//находим размеры предмета в ячейках
var dims = inventoryGetItemDimensions(_itemID);
if (dims == undefined)
return false;
var itemW = dims.w;
var itemH = dims.h;
//размеры сетки в клетках
var gridW = ds_grid_width(_inventoryGrid);
var gridH = ds_grid_height(_inventoryGrid);
//проверка выхода за границы сетки
if (_cellX < 0 || _cellY < 0 || _cellX + itemW > gridW || _cellY + itemH > gridH)
return false;
//проверка, не заняты ли ячейки
for (var x_ = _cellX; x_ < _cellX + itemW; ++x_)
for (var y_ = _cellY; y_ < _cellY + itemH; ++y_)
if (_inventoryGrid[# x_, y_] != noone) //если ячейка занята
return false; //место занято
return true; //место свободно
}Функция, добавляющая предмет в инвентарь при условии, что все ячейки, необходимые для добавления, свободны. Здесь нет проверки, является ли добавляемый предмет таким же, что и находящийся в ячейке, поскольку логика стакования будет позже прописана в другом месте. Также здесь нет проверки, является ли значение _quantity больше, чем максимально возможное количество предметов такого типа в одной ячейке - на случай, если в качестве исключения вам захочется добавить больше предметов в одну позицию, чем это может сделать игрок
//добавляем в инвентарь _inventoryGrid предмет _itemID в количестве _quantity единиц в ячейку (_cellX;_cellY)
//возвращает true при успешном добавлении и false, если предмет нельзя разместить
function inventoryAddItemTo(_inventoryGrid, _itemID, _quantity, _cellX, _cellY)
{
//если не можем разместить предмет в указанной позиции
if (!inventoryCanPlace(_inventoryGrid, _itemID, _quantity, _cellX, _cellY))
return false; //не удалось разместить предмет (размеры или коллизия с другими предметами)
//получаем размеры предмета
//не проверяем случай dims == undefined, потому что в inventoryCanPlace уже была проверка
var dims = inventoryGetItemDimensions(_itemID);
//создаем структуру для хранения данных предмета
var itemToBePlaced =
{
itemID : _itemID,
quantity : _quantity
};
//помещаем предмет в основную ячейку
_inventoryGrid[# _cellX, _cellY] = itemToBePlaced;
//помечаем остальные ячейки так, чтобы они ссылались на основную ячейку
for (var x_ = _cellX; x_ < _cellX + dims.w; ++x_)
{
for (var y_ = _cellY; y_ < _cellY + dims.h; ++y_)
{
if (x_ == _cellX && y_ == _cellY)
continue; //пропускаем левую верхнюю (основную) ячейку
_inventoryGrid[# x_, y_] =
{
refX: _cellX,
refY: _cellY
};
}
}
return true; //предмет успешно добавлен
}Находим координаты основной ячейки через побочную. Если передаем в качестве аргументов координаты основной ячейки, возвращаем ее же
//находим основную ячейку предмета по указанным координатам
//возвращает:
//undefined, если вышли за пределы сетки;
//noone, если ячейка пустая;
//структуру, содержащую координаты основной ячейки, если по указанным координатам есть предмет
function inventoryGetMainItemCell(_inventoryGrid, _cellX, _cellY)
{
//находим размеры сетки в ячейках
var gridW = ds_grid_width(_inventoryGrid);
var gridH = ds_grid_height(_inventoryGrid);
//проверяем, не вышли ли мы за пределы сетки
if (_cellX < 0 || _cellY < 0 || _cellX >= gridW || _cellY >= gridH)
return undefined;
//смотрим содержимое ячейки
var cell = _inventoryGrid[# _cellX, _cellY];
//проверяем, есть ли что-то в ячейке
if (cell == noone)
return noone; //ячейка пуста
var mainX_, mainY_;
//проверяем, является ли содержимое ячейки ссылкой на основную ячейку (структурой с ключами "refX" и "refY")
if (variable_struct_exists(cell, "refX") && variable_struct_exists(cell, "refY"))
{
//находим координаты основной ячейки через побочную ячейку
mainX_ = cell.refX;
mainY_ = cell.refY;
}
else
{
//содержимое - и есть основная ячейка
mainX_ = _cellX;
mainY_ = _cellY;
}
return
{
mainX: mainX_,
mainY: mainY_
}
}Функция, возвращающая структуру предмета из global.ItemDB через основную ячейку предмета. Для нахождения основной ячейки используем предыдущую функцию
//получаем предмет из инвентаря _inventoryGrid в ячейке (_cellX;_cellY)
//возвращает:
//undefined, если вышли за пределы сетки;
//noone, если ячейка пустая;
//основную ячейку предмета (структуру, содержащую поля itemID и quantity), если по указанным координатам есть предмет
function inventoryGetItemAtCell(_inventoryGrid, _cellX, _cellY)
{
//ищем основную ячейку этого предмета
var mainItemCellCoords = inventoryGetMainItemCell(_inventoryGrid, _cellX, _cellY);
//если нажали на пустую ячейку или вышли за пределы сетки
if (mainItemCellCoords == noone || mainItemCellCoords == undefined)
return mainItemCellCoords;
//нашли основную ячейку
var mainX = mainItemCellCoords.mainX;
var mainY = mainItemCellCoords.mainY;
var item = _inventoryGrid[# mainX, mainY]; //находим сам предмет
return item; //возвращаем предмет
}Функция, принимающая координаты ячейки и удаляющая предмет в этой ячейке через основную. Для этого также используем функцию inventoryGetMainItemCell(_inventoryGrid, cellX, cellY). Здесь мы проходимся по всем ячейкам этого предмета и присваиваем им noone, что в дальнейшем будет сигнализировать о том, что ячейки пустые
//убираем из инвентаря _inventoryGrid предмет в ячейке (_cellX;_cellY)
//возвращает:
//false, если передали координаты пустой ячейки или вышли за пределы сетки;
//основную ячейку удаленного предмета, если предмет успешно удален
function inventoryRemoveItemAt(_inventoryGrid, _cellX, _cellY)
{
//ищем основную ячейку этого предмета
var mainItemCellCoords = inventoryGetMainItemCell(_inventoryGrid, _cellX, _cellY);
//если нажали на пустую ячейку или вышли за пределы сетки
if (mainItemCellCoords == noone || mainItemCellCoords == undefined)
return false;
//нашли основную ячейку
var mainX = mainItemCellCoords.mainX;
var mainY = mainItemCellCoords.mainY;
var item = _inventoryGrid[# mainX, mainY]; //находим сам предмет
var dims = inventoryGetItemDimensions(item.itemID); //получаем размеры предмета для очистки всех ячеек
//очищаем все ячейки, занятые этим предметом (ставим noone)
for (var x_ = mainX; x_ < mainX + dims.w; ++x_)
for (var y_ = mainY; y_ < mainY + dims.h; ++y_)
_inventoryGrid[# x_, y_] = noone;
return item; //возвращаем данные удаленного предмета
}Наш инвентарь будет отображаться как элемент интерфейса в виде сетки в левом верхнем (или любом другом) углу, поэтому нам понадобится функция, переводящая экранные координаты (в пикселях) в координаты сетки (в ячейках), чтобы мышью управлять инвентарем: при наведении мыши на инвентарь мы будем получить координаты той ячейки, над которой она «висит». Самой обработки движений и нажатий мыши здесь еще нет, ее логика будет прописана в другом месте. Функция принимает в качестве аргументов сам инвентарь, координаты точки в пикселях, координаты начала инвентаря и размер ячейки. Так как функция учитывает расположение сетки инвентаря, саму сетку мы сможем размещать как угодно (об отрисовке сетки позже), и нам не нужно будет менять или дополнять код в этой функции
//переводим экранные координаты (в пикселях) в координаты сетки (в ячейках)
//возвращает:
//undefined, если рассматриваемые координаты за пределами области сетки инвентаря;
//структуру, хранящую координаты ячейки, которым соответствуют экранные координаты, если координаты точки расположены внутри сетки
function inventoryScreenToGridCoords(_inventoryGrid, _screenX, _screenY, _gridStartX, _gridStartY, _cellSize)
{
//находим размеры сетки инвентаря (в ячейках)
var gridW = ds_grid_width(_inventoryGrid);
var gridH = ds_grid_height(_inventoryGrid);
//находим размеры сетки инвентаря (в пикселях)
var totalW = gridW * _cellSize;
var totalH = gridH * _cellSize;
//если рассматриваемые координаты за пределами области сетки инвентаря
if (_screenX < _gridStartX || _screenX >= _gridStartX + totalW ||
_screenY < _gridStartY || _screenY >= _gridStartY + totalH)
return undefined;
//вычисляем координаты в ячейках
var cellX_ = floor((_screenX - _gridStartX) / _cellSize);
var cellY_ = floor((_screenY - _gridStartY) / _cellSize);
return { x_ : cellX_, y_ : cellY_ };
}Создание инвентарей и добавление предметов в них
Теперь мы можем добавлять инвентари объектам. В событии Create любого объекта, который вы хотите наделить инвентарем, пишите следующую строчку:
inventory = inventoryCreate(_width, _height);где width и height - ширина и высота сетки соответственно.
И обязательно в событии Clean Up необходимо добавить эту строку:
inventoryDestroy(inventory);Без этой строки при уничтожении экземпляра объекта сетка продолжит существовать, а так как переменная, ссылающаяся на нее (inventory), будет удалена вместе с экземпляром объекта, получить доступ к этой сетке вы больше не сможете, и это приведет к утечке памяти.
Для добавления предметов в инвентарь, необходимо использовать функцию inventoryAddItemTo(_inventoryGrid, itemID, quantity, cellX, cellY).
Для инвентаря объекта игрока я добавлю в событии Create следующие строки:
inventory = inventoryCreate(7, 5);
inventoryAddItemTo(inventory, 0, 3, 0, 0);
inventoryAddItemTo(inventory, 1, 1, 3, 3);
inventoryAddItemTo(inventory, 2, 1, 3, 0);
inventoryAddItemTo(inventory, 1, 2, 4, 4);
inventoryAddItemTo(inventory, 1, 3, 5, 4);
Также создадим инвентарь для сундука и добавим туда несколько предметов:
inventory = inventoryCreate(5, 5);
inventoryAddItemTo(inventory, 0, 3, 1, 2);
inventoryAddItemTo(inventory, 1, 2, 0, 0);
Менеджер инвентаря
Теперь нам необходим объект, который будет отвечать за отрисовку интерфейса и обработку пользовательских нажатий относительно инвентаря. Назовем этот объект oInventoryManager. Создание такого менеджера поможет отделить код для вышеперечисленного функционала от всей остальной игры, что позволит при необходимости с легкостью его отредактировать или деактивировать без путаницы и последствий. Этот менеджер будет обрабатывать как инвентарь игрока в одиночку, так и два инвентаря одновременно, например, для лутинга сундука (или торговли/бартера между игроком и NPC — при соответствующей доработке этой системы).
Создаем oInventoryManager. НЕ делаем его Persistent: он будет существовать только когда мы открываем инвентарь, а в момент закрытия он будет удаляться. В событии Create напишем такой код:
//ссылки на инвентари
invPlayer = noone;
invOther = noone;
//инвентарь и ячейка, над которыми "висит" курсор
hoverInv = noone;
hoverCell = undefined;
//размер ячейки
cellSize = 32;
//позиции для отрисовки инвентарей на экране (левые верхние точки инвентарей)
playerInvX = 50;
playerInvY = 50;
otherInvX = 500;
otherInvY = 50;
//ДЛЯ ПЕРЕТАСКИВАНИЯ
//перетаскиваемый предмет
draggedItem = noone;
isDragging = function()
{
if (draggedItem != noone)
return true;
return false;
}
//исходный инвентарь перетаскиваемого предмета
draggedItemOriginalInv = noone;
//исходная позиция перетаскиваемого предмета
draggedItemOriginalX = 0;
draggedItemOriginalY = 0;Здесь уже есть комментарии, объясняющие, что эти переменные и функция делают.
Теперь в событии Destroy напишем следующее:
//если закрыли инвентарь в момент перетаскивания, перетаскиваемый предмет возвращаем в то же место, откуда взяли его
if (isDragging())
{
var inv = draggedItemOriginalInv;
var itemID = draggedItem.itemID;
var quantity = draggedItem.quantity;
var targetX = draggedItemOriginalX;
var targetY = draggedItemOriginalY;
inventoryAddItemTo(inv, itemID, quantity, targetX, targetY);
}Без этих строк при закрытии инвентаря предмет будет просто исчезать.
Теперь нам понадобятся функции, которые будут отвечать за создание/уничтожение oInventoryManager. Эти функции мы не будем писать в самом oInventoryManager, потому что в таком случае мы не сможем вызвать функцию создания этого объекта (его же еще не существует), так что создадим скрипт scInventoryManager и напишем там следующее:
function inventoryManagerCreateSingle()
{
//если менеджер уже есть, закрываем его
if (instance_exists(oInventoryManager))
return;
//создаем менеджер
instance_create_layer(0, 0, "UI", oInventoryManager); //слой UI
//если менеджер создан, он обязательно должен обрабатывать как минимум инвентарь игрока
oInventoryManager.invPlayer = oPlayer.inventory;
}
function inventoryManagerCreateDouble(_invOther = noone)
{
if (instance_exists(oInventoryManager))
return;
var invOther = noone;
//если инвентарь, с которым будем взаимодействовать, передан как аргумент, то менеджер обрабатывает его
if (_invOther != noone)
{
invOther = _invOther;
}
//иначе ищем ближайший сундук. если можем дотянуться до него (InteractionDistance), то менеджер обрабатывает его
else
{
var chest = instance_nearest(oPlayer.x, oPlayer.y, oChest);
if (chest != noone && point_distance(oPlayer.x, oPlayer.y, chest.x, chest.y) < InteractionDistance)
invOther = chest.inventory; //инвентарь сундука, с которым взаимодействуем
}
//если invOther так и остался noone, то и не создаем менеджер
if (invOther == noone)
return;
instance_create_layer(0, 0, "UI", oInventoryManager); //слой UI
oInventoryManager.invPlayer = oPlayer.inventory;
oInventoryManager.invOther = invOther;
}
function inventoryManagerDestroy()
{
if (instance_exists(oInventoryManager))
instance_destroy(oInventoryManager);
}Здесь описаны три функции:
inventoryManagerCreateSingle() создает менеджер инвентаря, инициализируя переменную invPlayer инвентарем игрока и оставляя переменную invOther равной noone, что будет означать, что второго инвентаря, с которым мы бы взаимодействовали, нет - то есть игрок просто открывает свой инвентарь
Функция inventoryManagerCreateDouble(_invOther = noone) служит для создания менеджера инвентаря с присвоением invOther какого-нибудь другого инвентаря, с которым бы взаимодействовал игрок. Здесь, если мы передаем в качестве аргумента какой-то конкретный инвентарь, то менеджер будет создаваться с ним, а если нет, то игра проверит наличие сундука в комнате и найдет ближайший
Обратите внимание, что в этой функции фигурирует константа InteractionDistance - я ее объявил в событии Create объекта oGameManager следующим образом:
#macro InteractionDistance 100Это максимальная дистанция от объекта игрока до объекта, с которым он пытается взаимодействовать. Так вот, если ближайший к игроку сундук находится на расстоянии меньше, чем максимально возможное, то этот сундук и является тем, который будет обрабатываться oInventoryManager.
Третья функция просто удаляет oInventoryManager при условии, что он существует
Условия, при которых будут вызываться эти функции, могут быть разными:
Вы добавили игроку в инвентарь квестовый предмет и сразу хотите это продемонстрировать, открыв его — вызываете inventoryManagerCreateSingle()
Игрок нажал на «Бартер» в диалоге с NPC — вызываете inventoryManagerCreateDouble(_invOther), где _invOther — его инвентарь
Вы, управляя игроком, подошли к сундуку и нажали на E — вызываете inventoryManagerCreateDouble() (без аргумента)
Вы, управляя игроком, нажали на I — вызываете inventoryManagerCreateSingle()
Давайте реализуем функционал последних двух способов.
Обработку нажатий клавиш я советую осуществлять в событии Step отдельного объекта - oInputHandler. Создайте его, разместите в rInit (инициализирующей комнате) и сделайте Persistent.
Добавьте в Create такие строки:
btnInventory = "I";
btnInteract = "E";Это будут кнопки, отвечающие за открытие инвентаря. В событии Step напишите:
//ИНВЕНТАРЬ
//только игрок
if (keyboard_check_pressed(ord(btnInventory)))
inventoryManagerCreateSingle();
//игрок + сундук
if (keyboard_check_pressed(ord(btnInteract)))
inventoryManagerCreateDouble();
//выход из инвентаря
if (keyboard_check_pressed(vk_escape))
inventoryManagerDestroy();Теперь при нажатии на I или E менеджер инвентаря будет создаваться, а при нажатии на Escape - уничтожаться. Чтобы открыть сундук, нужно подойти к нему на достаточное расстояние.
Подробнее об oInputHandler я напишу отдельную статью. Когда она будет опубликована, здесь появится ссылка на нее.
Визуальное отображение и обработка нажатий инвентаря
Начнем с кода для отрисовки сетки инвентаря, но сперва нужно создать какой-нибудь шрифт. Если у вас еще ни одного шрифта в проекте нет, можете создать обычный Arial.
В событии Draw GUI добавьте draw_set_font(font);, где font - название вашего шрифта. В данном случае это fArial.
Далее создадим функцию для отрисовки самой сетки инвентаря и предметов, находящихся в ней. Разместим объявление этой функции в событии Create, в самом конце:
//Ф-Я ДЛЯ ОТРИСОВКИ УКАЗАННОГО ИНВЕНТАРЯ
drawInventoryGrid = function(_inventoryGrid, _startX, _startY)
{
var gridW = ds_grid_width(_inventoryGrid);
var gridH = ds_grid_height(_inventoryGrid);
//рисуем фон сетки
for (var x_ = 0; x_ < gridW; ++x_)
{
for (var y_ = 0; y_ < gridH; ++y_)
{
var drawX = _startX + x_ * cellSize;
var drawY = _startY + y_ * cellSize;
draw_set_color(c_black);
draw_rectangle(drawX, drawY, drawX + cellSize, drawY + cellSize, false);
draw_set_color(c_dkgray);
draw_rectangle(drawX, drawY, drawX + cellSize, drawY + cellSize, true);
}
}
//отрисовка всех предметов в сетке
for (var x_ = 0; x_ < gridW; ++x_)
{
for (var y_ = 0; y_ < gridH; ++y_)
{
var cellContent = _inventoryGrid[# x_, y_];
//рисуем, только если это структура с ключом "itemID"
if (is_struct(cellContent) && variable_struct_exists(cellContent, "itemID"))
{
var item = cellContent;
var itemID = item.itemID;
var quantity = item.quantity;
var itemData = getItemFromGlobalDatabase(itemID);
var sprite = itemData.Sprite;
var itemWidth = itemData.Width;
var itemHeight = itemData.Height;
var drawX = _startX + x_ * cellSize;
var drawY = _startY + y_ * cellSize;
var drawW = itemWidth * cellSize;
var drawH = itemHeight * cellSize;
//рисуем спрайт
draw_set_alpha(1);
if (sprite_exists(sprite))
draw_sprite(sprite, 0, drawX, drawY);
else
draw_sprite(spItemError, 0, drawX, drawY);
//рисуем количество
if (itemData.MaxStack > 1 && quantity > 1)
{
draw_set_color(c_white);
draw_set_halign(fa_right);
draw_set_valign(fa_bottom);
draw_text_color(drawX + drawW + 1, drawY + drawH + 1, string(quantity), c_black, c_black, c_black, c_black, 1); //тень
draw_text(drawX + drawW, drawY + drawH, string(quantity));
}
}
}
}
};Функция в качестве аргументов принимает инвентарь, который нужно отрисовать, и левый верхний угол этого инвентаря. Эту функцию мы будем вызывать каждый кадр игры в Draw GUI для инвентаря игрока и при необходимости для инвентаря, с которым взаимодействует игрок. Давайте разберем этот код по частям:
Сначала мы рисуем саму сетку, по ячейкам. Функция draw_rectangle(drawX, drawY, drawX + cellSize, drawY + cellSize, false); рисует черную ячейку, а draw_rectangle(drawX, drawY, drawX + cellSize, drawY + cellSize, true); рисует обводку для этой ячейки.
Затем отрисовываем предметы. Для этого проходимся по всему ds_grid и ищем элементы, являющиеся структурами и содержащие поле itemID — это левые верхние углы предметов. Элементы, являющиеся ссылками на основную ячейку и пустыми ячейками, разумеется, пропускаем. Так как мы начинаем отрисовку с левого верхнего угла предмета, то и точка привязки спрайта должна находиться в левом верхнем углу. Убедитесь, что для каждого спрайта вы выбрали точку привязки Top Left (Origin = 0×0).
После отрисовки содержимого ячейки отрисовываем количество предметов в ней. Количество будет находиться в правом нижнем углу предмета.
Теперь применим эту функцию в Draw GUI, а также добавим надписи сверху, чтобы понимать, где инвентарь игрока, а где другой:
draw_set_font(fArial);
//ОТРИСОВЫВАЕМ ИНВЕНТАРИ: ИГРОКА И ДРУГОЙ, ЕСЛИ ОН ЕСТЬ
//отрисовка для инвентаря игрока
if (invPlayer != noone)
{
drawInventoryGrid(invPlayer, playerInvX, playerInvY);
//пишем название инвентаря сверху от сетки
draw_set_color(c_white);
draw_set_halign(fa_left);
draw_set_valign(fa_bottom);
draw_text(playerInvX, playerInvY - 5, "Player");
}
//отрисовка для другого инвентаря (если он есть)
if (invOther != noone)
{
drawInventoryGrid(invOther, otherInvX, otherInvY);
//пишем название инвентаря сверху от сетки
draw_set_color(c_white);
draw_set_halign(fa_left);
draw_set_valign(fa_bottom);
draw_text(otherInvX, otherInvY - 5, "Other");
}Теперь попробуем запустить игру. При открытии сундука видим такой результат:
Сейчас с этими инвентарями мы ничего не можем сделать, поэтому напишем код для перетаскивания предметов.
В событии Step все того же oInventoryManager напишем такие строки:
//если игрок подвинулся, то он выходит из инвентаря
if (oPlayer.dx != 0)
instance_destroy(self);
//получаем координаты мыши в GUI
var mouseX = device_mouse_x_to_gui(0);
var mouseY = device_mouse_y_to_gui(0);
//определяем, над какой сеткой и ячейкой висит курсор
hoverInv = noone;
hoverCell = undefined;
//проверяем инвентарь игрока
if (invPlayer != noone)
{
hoverCell = inventoryScreenToGridCoords(invPlayer, mouseX, mouseY, playerInvX, playerInvY, cellSize);
if (hoverCell != undefined)
hoverInv = invPlayer;
}
//если не над инвентарем игрока, то проверяем другой (если он есть)
if (hoverInv == noone && invOther != noone)
{
hoverCell = inventoryScreenToGridCoords(invOther, mouseX, mouseY, otherInvX, otherInvY, cellSize);
if (hoverCell != undefined)
hoverInv = invOther;
}
//если курсор не висит над каким-либо инвентарем, останавливаем выполнение события
if (hoverInv == noone)
return;В начале события стоит проверка, двигается ли объект игрока. Если да, то закрываем инвентарь. В моем случае движение игрока определяется переменной dx: если она не равна 0, то игрок находится в движении. У вас эта проверка может происходить по‑другому или ее вообще может не быть.
Затем смотрим на расположение курсора и проверяем, заходит ли он на какой‑нибудь из инвентарей. Если да, сразу ищем ячейку, над которой «висит» курсор, используя ранее написанную функцию для перевода экранных координат в координаты инвентаря.
Если курсор за пределами сеток инвентаря, дальнейшее выполнение события не имеет смысла, поэтому останавливаем его.
Теперь напишем саму логику перетаскивания. Оно будет осуществляться с помощью нажатий левой кнопки мыши:
//ЛОГИКА ПЕРЕТАСКИВАНИЯ
//начало перетаскивания (нажатие левой кнопки мыши по предмету)
if (mouse_check_button_pressed(mb_left) && !isDragging())
{
//координаты ячейки, куда нажали
var cellX = hoverCell.x_;
var cellY = hoverCell.y_;
var item = inventoryGetItemAtCell(hoverInv, cellX, cellY);
if (item == noone || item == undefined) //останавливаем событие, если предмета в этой ячейке нет
return;
item = inventoryRemoveItemAt(hoverInv, cellX, cellY); //убираем предмет из сетки
if (item == false) //останавливаем событие, если не удалось удалить предмет
return;
//запоминаем перетаскиваемый предмет, инвентарь, откуда он был взят и его исходную позицию
draggedItem = item;
draggedItemOriginalInv = hoverInv;
draggedItemOriginalX = cellX;
draggedItemOriginalY = cellY;
}
//конец перетаскивания (нажатие лкм при наличии перетаскиваемого предмета)
else if (mouse_check_button_pressed(mb_left) && isDragging())
{
//координаты ячейки, над которой курсор
var cellX = hoverCell.x_;
var cellY = hoverCell.y_;
//смотрим содержимое этой ячейки
var targetCell = inventoryGetItemAtCell(hoverInv, cellX, cellY);
//если вышли за пределы сеток инвентарей, игнорируем нажатие
if (targetCell == undefined)
return;
//ВАРИАНТ 1: в ячейке есть такой же предмет, стакуем их
if (targetCell != noone)
{
var targetItem = targetCell;
//если этот предмет тот же самый, что и тот, что в данный момент перетаскивается
if (targetItem.itemID == draggedItem.itemID)
{
var itemData = getItemFromGlobalDatabase(draggedItem.itemID);
var maxStack = itemData.MaxStack;
//если есть место в стаке
if (targetItem.quantity < maxStack)
{
var spaceAvailable = maxStack - targetItem.quantity; //вычисляем доступное место
var amountToMove = min(draggedItem.quantity, spaceAvailable); //сколько положим в стопку
//добавляем к стопке в инвентаре
targetItem.quantity += amountToMove;
//уменьшаем у перетаскиваемой стопки
draggedItem.quantity -= amountToMove;
//если мы перенесли все, завершаем перетаскивание (иначе перетаскивание продолжается с остатком)
if (draggedItem.quantity == 0)
draggedItem = noone;
}
}
}
//ВАРИАНТ 2: в ячейке нет предмета
else
{
//пробуем разместить предмет
var isPlaced = inventoryAddItemTo(hoverInv, draggedItem.itemID, draggedItem.quantity, hoverCell.x_, hoverCell.y_);
//при успешном размещении обнуляем переменную
if (isPlaced)
draggedItem = noone;
}
}Теперь добавим в Draw GUI код для отрисовки перетаскиваемого предмета, сразу после кода для отрисовки сеток:
//ОТРИСОВКА ПЕРЕТАСКИВАЕМОГО ПРЕДМЕТА
//рисуем проекцию перетаскиваемого предмета
//(белые квадраты будут сигнализировать о возможности расположить предмет)
if (isDragging() && hoverInv != noone)
{
var itemID = draggedItem.itemID;
var quantity = draggedItem.quantity;
if (inventoryCanPlace(hoverInv, itemID, quantity, hoverCell.x_, hoverCell.y_))
{
var itemData = getItemFromGlobalDatabase(itemID);
var invX, invY;
if (hoverInv == invPlayer)
{
invX = playerInvX;
invY = playerInvY;
}
else
{
invX = otherInvX;
invY = otherInvY;
}
for (var i = hoverCell.x_; i < hoverCell.x_ + itemData.Width; ++i)
{
for (var j = hoverCell.y_; j < hoverCell.y_ + itemData.Height; ++j)
{
var drawX = invX + i * cellSize;
var drawY = invY + j * cellSize;
draw_set_alpha(0.5);
draw_set_color(c_white);
draw_rectangle(drawX, drawY, drawX + cellSize - 1, drawY + cellSize - 1, false);
}
}
}
}
//отрисовка перетаскиваемого предмета
if (isDragging())
{
var itemID = draggedItem.itemID;
var quantity = draggedItem.quantity;
var itemData = getItemFromGlobalDatabase(itemID);
var drawX = device_mouse_x_to_gui(0);
var drawY = device_mouse_y_to_gui(0);
//рисуем спрайт
draw_set_alpha(0.5);
draw_set_halign(fa_left);
draw_set_valign(fa_top);
draw_sprite(itemData.Sprite, 0, drawX, drawY);
//рисуем кол-во, если больше одного предмета
if (itemData.MaxStack > 1 && quantity > 1)
{
var textX = drawX + itemData.Width*cellSize;
var textY = drawY + itemData.Height*cellSize;
draw_set_alpha(1);
draw_set_halign(fa_right);
draw_set_valign(fa_bottom);
draw_set_color(c_white);
draw_text_color(textX + 1, textY + 1, string(quantity), c_black, c_black, c_black, c_black, 1); //тень
draw_text(textX, textY, string(quantity));
}
}
draw_set_halign(fa_left);
draw_set_valign(fa_top);
draw_set_color(c_white);
draw_set_alpha(1);Сначала рисуем проекцию перетаскиваемого предмета. Это белые полупрозрачные квадраты, которые рисуются в том месте, где расположится предмет при нажатии на ЛКМ.
Затем отрисовываем перетаскиваемый предмет. Он будет полупрозрачным и перемещаться вместе с курсором.
Итог
Что дальше?
Вот идеи для доработки этой системы:
Добавить возможность выбирать, сколько предметов перетаскивать (сейчас можно только перетаскивать весь стак)
Добавить функцию для добавления предмета в свободное пространство инвентаря без указания конкретных координат. Она может понадобиться, например, для получения квестовых предметов
Для идеи, описанной выше, добавить обработку ситуации, когда для предмета не хватает места, например, выбросить его на землю
Добавить функцию для удаления предмета из инвентаря не по координатам, а по его ID
Добавить контекстное меню для взаимодействия с предметами (яблоко — съесть, коробку — вскрыть, броню — экипировать и т. д.)
Возможно, я напишу продолжение этой статьи, где объясню, как реализовать эти идеи.
Скачать исходники проекта можно здесь, он скомпилирован на версии v2024.13.1.193 (Steam).
Спасибо за внимание! Если есть вопросы - пишите в комментариях, на все отвечу.
