static void testItemMassActions (void)
{
ResetInventoryList();
const objDef_t* od = INVSH_GetItemByIDSilent("assault");
CU_ASSERT_PTR_NOT_NULL_FATAL(od);
const invDef_t* container = INVSH_GetInventoryDefinitionByID("right");
CU_ASSERT_PTR_NOT_NULL_FATAL(container);
Inventory inv;
bool addedItem = testAddSingle(&inv, od, container);
CU_ASSERT(addedItem == true);
/* second try should fail as the right container is a single container */
addedItem = testAddSingle(&inv, od, container);
CU_ASSERT(addedItem == false);
container = INVSH_GetInventoryDefinitionByID("left");
CU_ASSERT_PTR_NOT_NULL_FATAL(container);
od = INVSH_GetItemByIDSilent("fraggrenade");
CU_ASSERT_PTR_NOT_NULL_FATAL(od);
addedItem = testAddSingle(&inv, od, container);
CU_ASSERT(addedItem == true);
container = INVSH_GetInventoryDefinitionByID("equip");
CU_ASSERT_PTR_NOT_NULL_FATAL(container);
for (int i = 0; i < csi.numODs; i++) {
od = INVSH_GetItemByIDX(i);
/* every item should be placable on the ground container and there should really be enough space */
addedItem = testAddSingle(&inv, od, container);
CU_ASSERT(addedItem == true);
addedItem = testAddSingle(&inv, od, container);
CU_ASSERT(addedItem == true);
addedItem = testAddSingle(&inv, od, container);
CU_ASSERT(addedItem == true);
for (int j = 0; j < od->numAmmos; j++) {
addedItem = testAddSingle(&inv, od->ammos[j], container);
CU_ASSERT(addedItem == true);
addedItem = testAddSingle(&inv, od->ammos[j], container);
CU_ASSERT(addedItem == true);
addedItem = testAddSingle(&inv, od->ammos[j], container);
CU_ASSERT(addedItem == true);
addedItem = testAddSingle(&inv, od->ammos[j], container);
CU_ASSERT(addedItem == true);
addedItem = testAddSingle(&inv, od->ammos[j], container);
CU_ASSERT(addedItem == true);
addedItem = testAddSingle(&inv, od->ammos[j], container);
CU_ASSERT(addedItem == true);
}
}
}
/**
* @brief For things like craft_ufo_scout that are no real items this function will
* increase the collected counter by one
* @note Mission trigger function
* @sa CP_MissionTriggerFunctions
* @sa CP_ExecuteMissionTrigger
*/
static void CP_AddItemAsCollected_f (void)
{
int baseID;
const char* id;
base_t *base;
const objDef_t *item;
if (Cmd_Argc() < 2) {
Com_Printf("Usage: %s <item>\n", Cmd_Argv(0));
return;
}
id = Cmd_Argv(1);
baseID = atoi(Cmd_Argv(2));
base = B_GetBaseByIDX(baseID);
if (base == NULL)
return;
/* i = item index */
item = INVSH_GetItemByIDSilent(id);
if (item) {
technology_t *tech = RS_GetTechForItem(item);
base->storage.numItems[item->idx]++;
Com_DPrintf(DEBUG_CLIENT, "add item: '%s'\n", item->id);
RS_MarkCollected(tech);
}
}
/**
* @brief Draw an item node
*/
void uiItemNode::draw (uiNode_t* node)
{
const objDef_t* od;
const char* ref = UI_GetReferenceString(node, EXTRADATA(node).model);
vec2_t pos;
if (Q_strnull(ref))
return;
UI_GetNodeAbsPos(node, pos);
R_CleanupDepthBuffer(pos[0], pos[1], node->box.size[0], node->box.size[1]);
od = INVSH_GetItemByIDSilent(ref);
if (od) {
Item item(od, nullptr, 1); /* 1 so it's not reddish; fake item anyway */
const char* model = GAME_GetModelForItem(item.def(), nullptr);
if (EXTRADATA(node).containerLike || Q_strnull(model)) {
const vec4_t color = {1, 1, 1, 1};
vec3_t itemNodePos;
/* We position the model of the item ourself (in the middle of the item
* node). See the "-1, -1" parameter of UI_DrawItem. */
UI_GetNodeAbsPos(node, itemNodePos);
itemNodePos[0] += node->box.size[0] / 2.0;
itemNodePos[1] += node->box.size[1] / 2.0;
itemNodePos[2] = 0;
/** @todo we should not use DrawItem but draw the image with render function (remove dependency with container) */
UI_DrawItem(node, itemNodePos, &item, -1, -1, EXTRADATA(node).scale, color);
} else {
UI_DrawModelNode(node, model);
}
} else {
GAME_DisplayItemInfo(node, ref);
}
}
static void testItemAdd (void)
{
inventory_t inv;
const objDef_t *od;
item_t item;
const invDef_t *container;
ResetInventoryList();
OBJZERO(inv);
od = INVSH_GetItemByIDSilent("assault");
CU_ASSERT_PTR_NOT_NULL(od);
container = INVSH_GetInventoryDefinitionByID("right");
CU_ASSERT_PTR_NOT_NULL(container);
item.t = od;
item.m = NULL;
item.a = 0;
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == false);
CU_ASSERT_PTR_NOT_NULL(i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1));
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == true);
}
static void testItemToHeadgear (void)
{
inventory_t inv;
const objDef_t *od;
const invDef_t *container;
item_t item;
ResetInventoryList();
OBJZERO(inv);
od = INVSH_GetItemByIDSilent("irgoggles");
CU_ASSERT_PTR_NOT_NULL_FATAL(od);
container = INVSH_GetInventoryDefinitionByID("headgear");
CU_ASSERT_PTR_NOT_NULL_FATAL(container);
item.t = od;
item.m = NULL;
item.a = 0;
CU_ASSERT_FALSE(INVSH_ExistsInInventory(&inv, container, &item));
CU_ASSERT_PTR_NOT_NULL(i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1));
CU_ASSERT_TRUE(INVSH_ExistsInInventory(&inv, container, &item));
CU_ASSERT_PTR_NULL(i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1));
}
static void testItemMove (void)
{
Inventory inv;
const objDef_t* od;
const invDef_t* container, *containerTo;
Item* addedItem;
ResetInventoryList();
od = INVSH_GetItemByIDSilent("assault");
CU_ASSERT_PTR_NOT_NULL(od);
container = INVSH_GetInventoryDefinitionByID("right");
CU_ASSERT_PTR_NOT_NULL(container);
Item item(od);
CU_ASSERT(inv.containsItem(container->id, &item) == false);
addedItem = i.addToInventory(&inv, &item, container, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(inv.containsItem(container->id, &item) == true);
containerTo = INVSH_GetInventoryDefinitionByID("backpack");
CU_ASSERT_PTR_NOT_NULL(containerTo);
CU_ASSERT_EQUAL(IA_MOVE, i.moveInInventory(&inv, container, addedItem, containerTo, NONE, NONE, nullptr, nullptr));
CU_ASSERT(inv.containsItem(container->id, &item) == false);
CU_ASSERT(inv.containsItem(containerTo->id, &item) == true);
}
static void testItemDel (void)
{
Inventory inv;
const objDef_t* od;
const invDef_t* container;
Item* addedItem;
ResetInventoryList();
od = INVSH_GetItemByIDSilent("assault");
CU_ASSERT_PTR_NOT_NULL(od);
container = INVSH_GetInventoryDefinitionByID("right");
CU_ASSERT_PTR_NOT_NULL(container);
Item item(od);
CU_ASSERT(inv.containsItem(container->id, &item) == false);
addedItem = i.addToInventory(&inv, &item, container, NONE, NONE, 1);
CU_ASSERT(inv.containsItem(container->id, &item) == true);
CU_ASSERT(i.removeFromInventory(&inv, container, addedItem));
CU_ASSERT(inv.containsItem(container->id, &item) == false);
}
/**
* @brief Checks If a technology/UFOpaedia-entry will be displayed in the UFOpaedia (-list).
* @note This does not check for different display modes (only pre-research text, what statistics, etc...). The
* content is mostly checked in @c UP_Article
* @return true if the tech gets displayed at all, otherwise false.
* @sa UP_Article
*/
static bool UP_TechGetsDisplayed (const technology_t* tech)
{
const objDef_t* item;
assert(tech);
/* virtual items are hidden */
item = INVSH_GetItemByIDSilent(tech->provides);
if (item && item->isVirtual)
return false;
/* Is already researched OR has collected items OR (researchable AND have description)
* AND not a logical block AND not redirected */
return (RS_IsResearched_ptr(tech) || RS_Collected_(tech)
|| (tech->statusResearchable && tech->preDescription.numDescriptions > 0))
&& tech->type != RS_LOGIC && !tech->redirect;
}
/**
* @brief Show item description in bdef menu
* @note it handles items in both slots and storage
*/
static void BDEF_SelectItem_f (void)
{
aircraftSlot_t* slot;
installation_t* installation = INS_GetCurrentSelectedInstallation();
base_t* base = B_GetCurrentSelectedBase();
aircraftItemType_t bdefType;
int slotIDX;
int itemIDX;
if (cgi->Cmd_Argc() < 4) {
Com_Printf("Usage: %s <type> <slotIDX> <itemIDX>\n", cgi->Cmd_Argv(0));
return;
}
bdefType = BDEF_GetItemTypeFromID(cgi->Cmd_Argv(1));
slotIDX = atoi(cgi->Cmd_Argv(2));
itemIDX = atoi(cgi->Cmd_Argv(3));
if (bdefType == MAX_ACITEMS) {
Com_Printf("BDEF_AddItem_f: Invalid defence type.\n");
return;
}
if (slotIDX >= 0) {
const objDef_t* item;
slot = (installation) ? BDEF_GetInstallationSlotByIDX(installation, bdefType, slotIDX) : BDEF_GetBaseSlotByIDX(base, bdefType, slotIDX);
item = (slot) ? ( (slot->nextItem) ? slot->nextItem : slot->item ) : nullptr;
UP_AircraftItemDescription(item);
} else if (itemIDX >= 0) {
technology_t** list;
technology_t* itemTech = nullptr;
int i = 0;
slot = (installation) ? BDEF_GetInstallationSlotByIDX(installation, bdefType, 0) : BDEF_GetBaseSlotByIDX(base, bdefType, 0);
list = AII_GetCraftitemTechsByType(bdefType);
while (*list && i <= itemIDX) {
if (AIM_SelectableCraftItem(slot, *list)) {
itemTech = *list;
i++;
break;
}
list++;
}
UP_AircraftItemDescription((itemTech) ? INVSH_GetItemByIDSilent(itemTech->provides) : nullptr);
} else {
Com_Printf("BDEF_AddItem_f: Invalid item-space.\n");
}
}
/**
* @brief Adds a new item to an existing or new floor container edict at the given grid location
* @param pos The grid location to spawn the item on the floor
* @param itemID The item to spawn
*/
bool G_AddItemToFloor (const pos3_t pos, const char *itemID)
{
edict_t *floor;
item_t item = {NONE_AMMO, NULL, NULL, 0, 0};
const objDef_t *od = INVSH_GetItemByIDSilent(itemID);
if (!od) {
gi.DPrintf("Could not find item '%s'\n", itemID);
return false;
}
/* Also sets FLOOR(ent) to correct value. */
floor = G_GetFloorItemsFromPos(pos);
/* nothing on the ground yet? */
if (!floor)
floor = G_SpawnFloor(pos);
item.item = od;
return game.i.TryAddToInventory(&game.i, &floor->chr.i, &item, INVDEF(gi.csi->idFloor));
}
static void testItemMove (void)
{
inventory_t inv;
const objDef_t *od;
item_t item;
const invDef_t *container, *containerTo;
invList_t *addedItem;
ResetInventoryList();
OBJZERO(inv);
OBJZERO(item);
od = INVSH_GetItemByIDSilent("assault");
CU_ASSERT_PTR_NOT_NULL(od);
container = INVSH_GetInventoryDefinitionByID("right");
CU_ASSERT_PTR_NOT_NULL(container);
item.t = od;
item.m = NULL;
item.a = 0;
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == false);
addedItem = i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == true);
containerTo = INVSH_GetInventoryDefinitionByID("backpack");
CU_ASSERT_PTR_NOT_NULL(containerTo);
CU_ASSERT_EQUAL(IA_MOVE, i.MoveInInventory(&i, &inv, container, addedItem, containerTo, NONE, NONE, NULL, NULL));
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == false);
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerTo, &item) == true);
}
static void testItemToHeadgear (void)
{
Inventory inv;
const objDef_t* od;
const invDef_t* container;
ResetInventoryList();
od = INVSH_GetItemByIDSilent("irgoggles");
CU_ASSERT_PTR_NOT_NULL_FATAL(od);
container = INVSH_GetInventoryDefinitionByID("headgear");
CU_ASSERT_PTR_NOT_NULL_FATAL(container);
Item item(od);
CU_ASSERT_FALSE(inv.containsItem(container->id, &item));
CU_ASSERT_PTR_NOT_NULL(i.addToInventory(&inv, &item, container, NONE, NONE, 1));
CU_ASSERT_TRUE(inv.containsItem(container->id, &item));
CU_ASSERT_PTR_NULL(i.addToInventory(&inv, &item, container, NONE, NONE, 1));
}
/**
* @brief Parses one "components" entry in a .ufo file and writes it into the next free entry in xxxxxxxx (components_t).
* @param[in] name The unique id of a components_t array entry.
* @param[in] text the whole following text after the "components" definition.
* @sa CP_ParseScriptFirst
*/
static void CP_ParseComponents (const char *name, const char **text)
{
components_t *comp;
const char *errhead = "CP_ParseComponents: unexpected end of file.";
const char *token;
/* get body */
token = Com_Parse(text);
if (!*text || *token != '{') {
Com_Printf("CP_ParseComponents: \"%s\" components def without body ignored.\n", name);
return;
}
if (ccs.numComponents >= MAX_ASSEMBLIES) {
Com_Printf("CP_ParseComponents: too many technology entries. limit is %i.\n", MAX_ASSEMBLIES);
return;
}
/* New components-entry (next free entry in global comp-list) */
comp = &ccs.components[ccs.numComponents];
ccs.numComponents++;
OBJZERO(*comp);
/* set standard values */
Q_strncpyz(comp->assemblyId, name, sizeof(comp->assemblyId));
comp->assemblyItem = INVSH_GetItemByIDSilent(comp->assemblyId);
if (comp->assemblyItem)
Com_DPrintf(DEBUG_CLIENT, "CP_ParseComponents: linked item: %s with components: %s\n", name, comp->assemblyId);
do {
/* get the name type */
token = Com_EParse(text, errhead, name);
if (!*text)
break;
if (*token == '}')
break;
/* get values */
if (Q_streq(token, "item")) {
/* Defines what items need to be collected for this item to be researchable. */
if (comp->numItemtypes < MAX_COMP) {
/* Parse item name */
token = Com_Parse(text);
comp->items[comp->numItemtypes] = INVSH_GetItemByID(token); /* item id -> item pointer */
/* Parse number of items. */
token = Com_Parse(text);
comp->itemAmount[comp->numItemtypes] = atoi(token);
token = Com_Parse(text);
/* If itemcount needs to be scaled */
if (token[0] == '%')
comp->itemAmount2[comp->numItemtypes] = COMP_ITEMCOUNT_SCALED;
else
comp->itemAmount2[comp->numItemtypes] = atoi(token);
/** @todo Set item links to NONE if needed */
/* comp->item_idx[comp->numItemtypes] = xxx */
comp->numItemtypes++;
} else {
Com_Printf("CP_ParseComponents: \"%s\" Too many 'items' defined. Limit is %i - ignored.\n", name, MAX_COMP);
}
} else if (Q_streq(token, "time")) {
/* Defines how long disassembly lasts. */
token = Com_Parse(text);
comp->time = atoi(token);
} else {
Com_Printf("CP_ParseComponents: Error in \"%s\" - unknown token: \"%s\".\n", name, token);
}
} while (*text);
}
/**
* @brief Update the item description according to the tech and the slot selected
*/
static void AIM_UpdateItemDescription (bool fromList, bool fromSlot)
{
int status;
aircraft_t *aircraft;
aircraftSlot_t *slot;
base_t *base = B_GetCurrentSelectedBase();
assert(base);
aircraft = base->aircraftCurrent;
assert(aircraft);
slot = AII_SelectAircraftSlot(aircraft, airequipID);
/* update mini ufopedia */
/** @todo we should clone the text, and not using the ufopedia text */
if (fromList)
UP_AircraftItemDescription(INVSH_GetItemByIDSilent(aimSelectedTechnology ? aimSelectedTechnology->provides : NULL));
else if (fromSlot) {
if (airequipID == AC_ITEM_AMMO)
UP_AircraftItemDescription(slot->ammo);
else
UP_AircraftItemDescription(slot->item);
}
/* update status */
status = AIM_CheckTechnologyIntoSlot(slot, aimSelectedTechnology);
switch (status) {
case AIM_LOADING_NOSLOTSELECTED:
Cvar_Set("mn_aircraft_item_warning", _("No slot selected."));
break;
case AIM_LOADING_NOTECHNOLOGYSELECTED:
Cvar_Set("mn_aircraft_item_warning", _("No item selected."));
break;
case AIM_LOADING_ALIENTECH:
Cvar_Set("mn_aircraft_item_warning", _("You can't equip an alien technology."));
break;
case AIM_LOADING_TECHNOLOGYNOTRESEARCHED:
Cvar_Set("mn_aircraft_item_warning", _("Technology requested is not yet completed."));
break;
case AIM_LOADING_TOOHEAVY:
Cvar_Set("mn_aircraft_item_warning", _("This item is too heavy for the selected slot."));
break;
case AIM_LOADING_NOWEAPON:
Cvar_Set("mn_aircraft_item_warning", _("Equip a weapon first."));
break;
case AIM_LOADING_NOTUSABLEWITHWEAPON:
Cvar_Set("mn_aircraft_item_warning", _("Ammo not usable with current weapon."));
break;
case AIM_LOADING_UNKNOWNPROBLEM:
Cvar_Set("mn_aircraft_item_warning", _("Unknown problem."));
break;
case AIM_LOADING_OK:
Cvar_Set("mn_aircraft_item_warning", _("Ok"));
break;
}
if (*Cvar_GetString("mn_item") == '\0') {
cgi->UI_ExecuteConfunc("airequip_no_item");
} else {
if (fromSlot) {
cgi->UI_ExecuteConfunc("airequip_installed_item");
} else {
if (status == AIM_LOADING_OK)
cgi->UI_ExecuteConfunc("airequip_installable_item");
else
cgi->UI_ExecuteConfunc("airequip_noinstallable_item");
}
}
}
static void testItemReload (void)
{
inventory_t inv;
const objDef_t *od, *ad;
item_t item, ammo, ammoFrom;
const invDef_t *container, *containerFrom;
invList_t *addedItem;
ResetInventoryList();
OBJZERO(inv);
od = INVSH_GetItemByIDSilent("rpg");
CU_ASSERT_PTR_NOT_NULL(od);
container = INVSH_GetInventoryDefinitionByID("right");
CU_ASSERT_PTR_NOT_NULL(container);
item.t = od;
item.m = NULL;
item.a = 0;
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == false);
addedItem = i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == true);
ad = INVSH_GetItemByIDSilent("rpg_ammo");
CU_ASSERT_PTR_NOT_NULL(ad);
ammo.t = ad;
ammo.m = NULL;
ammo.a = 0;
containerFrom = INVSH_GetInventoryDefinitionByID("backpack");
CU_ASSERT_PTR_NOT_NULL(containerFrom);
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerFrom, &ammo) == false);
addedItem = i.AddToInventory(&i, &inv, &ammo, containerFrom, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerFrom, &ammo) == true);
CU_ASSERT_EQUAL(IA_RELOAD, i.MoveInInventory(&i, &inv, containerFrom, addedItem, container, NONE, NONE, NULL, NULL));
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerFrom, &ammo) == false);
item.m = ad;
item.a = 1;
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == true);
ad = INVSH_GetItemByIDSilent("rpg_incendiary_ammo");
CU_ASSERT_PTR_NOT_NULL(ad);
ammoFrom.t = ad;
ammoFrom.m = NULL;
ammoFrom.a = 0;
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerFrom, &ammoFrom) == false);
addedItem = i.AddToInventory(&i, &inv, &ammoFrom, containerFrom, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerFrom, &ammoFrom) == true);
CU_ASSERT_EQUAL(IA_RELOAD_SWAP, i.MoveInInventory(&i, &inv, containerFrom, addedItem, container, NONE, NONE, NULL, NULL));
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerFrom, &ammoFrom) == false);
CU_ASSERT(INVSH_ExistsInInventory(&inv, containerFrom, &ammo) == true);
item.m = ad;
CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == true);
}
static void testItemReload (void)
{
Inventory inv;
const objDef_t* od, *ad;
const invDef_t* container, *containerFrom;
Item* addedItem;
ResetInventoryList();
od = INVSH_GetItemByIDSilent("rpg");
CU_ASSERT_PTR_NOT_NULL(od);
container = INVSH_GetInventoryDefinitionByID("right");
CU_ASSERT_PTR_NOT_NULL(container);
Item item(od);
CU_ASSERT(inv.containsItem(container->id, &item) == false);
addedItem = i.addToInventory(&inv, &item, container, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(inv.containsItem(container->id, &item) == true);
ad = INVSH_GetItemByIDSilent("rpg_ammo");
CU_ASSERT_PTR_NOT_NULL(ad);
Item ammo(ad);
containerFrom = INVSH_GetInventoryDefinitionByID("backpack");
CU_ASSERT_PTR_NOT_NULL(containerFrom);
CU_ASSERT(inv.containsItem(containerFrom->id, &ammo) == false);
addedItem = i.addToInventory(&inv, &ammo, containerFrom, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(inv.containsItem(containerFrom->id, &ammo) == true);
CU_ASSERT_EQUAL(IA_RELOAD, i.moveInInventory(&inv, containerFrom, addedItem, container, NONE, NONE, nullptr, nullptr));
CU_ASSERT(inv.containsItem(containerFrom->id, &ammo) == false);
item.setAmmoDef(ad);
item.setAmmoLeft(1);
CU_ASSERT(inv.containsItem(container->id, &item) == true);
ad = INVSH_GetItemByIDSilent("rpg_incendiary_ammo");
CU_ASSERT_PTR_NOT_NULL(ad);
Item ammoFrom(ad);
CU_ASSERT(inv.containsItem(containerFrom->id, &ammoFrom) == false);
addedItem = i.addToInventory(&inv, &ammoFrom, containerFrom, NONE, NONE, 1);
CU_ASSERT_PTR_NOT_NULL(addedItem);
CU_ASSERT(inv.containsItem(containerFrom->id, &ammoFrom) == true);
CU_ASSERT_EQUAL(IA_RELOAD_SWAP, i.moveInInventory(&inv, containerFrom, addedItem, container, NONE, NONE, nullptr, nullptr));
CU_ASSERT(inv.containsItem(containerFrom->id, &ammoFrom) == false);
CU_ASSERT(inv.containsItem(containerFrom->id, &ammo) == true);
item.setAmmoDef(ad);
CU_ASSERT(inv.containsItem(container->id, &item) == true);
}
