Functions
s32	add_item (s32 itemID)
	Add `itemID` to player inventory and return inventory slot in which it was placed.

s32	remove_item (s32 itemID)
	Remove first instance of `itemID` found in player inventory.

b32	has_item (s32 itemID)
	Check whether player has `itemID` in their inventory.

s32	find_item (s32 itemID)
	Search player inventory for `itemID` and return first matching array index.

s32	count_item (s32 itemID)
	Search player inventory for `itemID` and count the number matches.

b32	is_badge_equipped (s32 itemID)

s32	get_consumables_count (void)

s32	get_consumables_empty (void)

s32	store_item (s32 itemID)
	Add `itemID` to player storage and return slot in which it was placed.

s32	get_stored_count (void)

s32	get_stored_empty (void)

s32	recover_hp (s32 amt)
	Recover player HP.

s32	recover_fp (s32 amt)
	Recover player FP.

Function Documentation

◆ add_item()

s32 add_item ( s32 itemID )

Add itemID to player inventory and return inventory slot in which it was placed.

Returns: the index of the new item in the player's inventory, or -1 if there was no room

Definition at line 146 of file inventory.c.

                         {
    s32 idx;
 
    // handle key items
    if (item_is_key(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.keyItems); idx++) {
            if (gPlayerData.keyItems[idx] == ITEM_NONE) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.keyItems)) {
            return -1;
        }
 
        gPlayerData.keyItems[idx] = itemID;
        return idx;
    }
 
    // handle badges
    if (item_is_badge(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.badges); idx++) {
            if (gPlayerData.badges[idx] == ITEM_NONE) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.badges)) {
            return -1;
        }
 
        gPlayerData.badges[idx] = itemID;
        return idx;
    }
 
    // handle consumables
    sort_consumables();
 
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.invItems); idx++) {
        if (gPlayerData.invItems[idx] == ITEM_NONE) {
            break;
        }
    }
 
    if (idx == ARRAY_COUNT(gPlayerData.invItems)) {
        return -1;
    }
 
    gPlayerData.invItems[idx] = itemID;
    return idx;
}

Referenced by update_item_entity_pickup().

◆ remove_item()

s32 remove_item ( s32 itemID )

Remove first instance of itemID found in player inventory.

Returns: the index of the removed item in the player's inventory, or -1 none was found

Definition at line 198 of file inventory.c.

                            {
    s32 idx;
 
    // handle key items
    if (item_is_key(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.keyItems); idx++) {
            if (gPlayerData.keyItems[idx] == itemID) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.keyItems)) {
            return -1;
        }
 
        gPlayerData.keyItems[idx] = ITEM_NONE;
        return idx;
    }
 
    // handle badges
    if (item_is_badge(itemID)) {
        // unequip
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.equippedBadges); idx++) {
            if (gPlayerData.equippedBadges[idx] == itemID) {
                gPlayerData.equippedBadges[idx] = ITEM_NONE;
            }
        }
 
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.badges); idx++) {
            if (gPlayerData.badges[idx] == itemID) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.badges)) {
            return -1;
        }
 
        gPlayerData.badges[idx] = ITEM_NONE;
        return idx;
    }
 
    // handle consumables
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.invItems); idx++) {
        if (gPlayerData.invItems[idx] == itemID) {
            break;
        }
    }
 
    if (idx == ARRAY_COUNT(gPlayerData.invItems)) {
        return -1;
    }
 
    gPlayerData.invItems[idx] = ITEM_NONE;
    sort_consumables();
    return idx;
}

◆ has_item()

b32 has_item ( s32 itemID )

Check whether player has itemID in their inventory.

Returns: boolean 'does player have item?'

Definition at line 337 of file inventory.c.

                         {
    s32 idx;
 
    // handle key items
    if (item_is_key(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.keyItems); idx++) {
            if (gPlayerData.keyItems[idx] == itemID) {
                return TRUE;
            }
        }
        return FALSE;
    }
 
    // handle badges
    if (item_is_badge(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.badges); idx++) {
            if (gPlayerData.badges[idx] == itemID) {
                return TRUE;
            }
        }
        return FALSE;
    }
 
    // handle consumables
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.invItems); idx++) {
        if (gPlayerData.invItems[idx] == itemID) {
            return TRUE;
        }
    }
    return FALSE;
}

◆ find_item()

s32 find_item ( s32 itemID )

Search player inventory for itemID and return first matching array index.

Returns: the index of the given item in the player's inventory, or -1 if not found

Definition at line 258 of file inventory.c.

                          {
    s32 idx;
 
    // handle key items
    if (item_is_key(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.keyItems); idx++) {
            if (gPlayerData.keyItems[idx] == itemID) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.keyItems)) {
            return -1;
        }
        return idx;
    }
 
    // handle badges
    if (item_is_badge(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.badges); idx++) {
            if (gPlayerData.badges[idx] == itemID) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.badges)) {
            return -1;
        }
        return idx;
    }
 
    // handle consumables
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.invItems); idx++) {
        if (gPlayerData.invItems[idx] == itemID) {
            break;
        }
    }
 
    if (idx == ARRAY_COUNT(gPlayerData.invItems)) {
        return -1;
    }
    return idx;
}

◆ count_item()

s32 count_item ( s32 itemID )

Search player inventory for itemID and count the number matches.

Returns: the number of items matching itemID

Definition at line 304 of file inventory.c.

                           {
    s32 idx;
    s32 sum = 0;
 
    // handle key items
    if (item_is_key(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.keyItems); idx++) {
            if (gPlayerData.keyItems[idx] == itemID) {
                sum++;
            }
        }
        return sum;
    }
 
    // handle badges
    if (item_is_badge(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.badges); idx++) {
            if (gPlayerData.badges[idx] == itemID) {
                sum++;
            }
        }
        return sum;
    }
 
    // handle consumables
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.invItems); idx++) {
        if (gPlayerData.invItems[idx] == itemID) {
            sum++;
        }
    }
    return sum;
}

◆ is_badge_equipped()

b32 is_badge_equipped ( s32 itemID )

Returns: whether the player has itemID as an equipped badge

Definition at line 387 of file inventory.c.

                                  {
    s32 idx;
 
    if (!item_is_badge(itemID)) {
        return FALSE;
    }
 
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.equippedBadges); idx++) {
        if (gPlayerData.equippedBadges[idx] == itemID) {
            return TRUE;
        }
    }
 
    return FALSE;
}

◆ get_consumables_count()

s32 get_consumables_count ( void )

Returns: the number of consumables in player inventory

Definition at line 423 of file inventory.c.

                                {
    s32 idx;
    s32 sum = 0;
 
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.invItems); idx++) {
        if (gPlayerData.invItems[idx] != ITEM_NONE) {
            sum++;
        }
    }
 
    return sum;
}

Referenced by get_consumables_empty().

◆ get_consumables_empty()

s32 get_consumables_empty ( void )

Returns: the available room for consumables in player inventory

Definition at line 436 of file inventory.c.

                                {
    return ARRAY_COUNT(gPlayerData.invItems) - get_consumables_count();
}

◆ store_item()

s32 store_item ( s32 itemID )

Add itemID to player storage and return slot in which it was placed.

Returns: the index of the new item in player storage, or -1 if there was no room

Definition at line 369 of file inventory.c.

                           {
    s32 idx;
 
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.storedItems); idx++) {
        if (gPlayerData.storedItems[idx] == ITEM_NONE) {
            break;
        }
    }
 
    if (idx == ARRAY_COUNT(gPlayerData.storedItems)) {
        return -1;
    } else {
        gPlayerData.storedItems[idx] = itemID;
    }
 
    return idx;
}

◆ get_stored_count()

s32 get_stored_count ( void )

Returns: the number of consumables in player storage

Definition at line 440 of file inventory.c.

                           {
    s32 idx;
    s32 sum = 0;
 
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.storedItems); idx++) {
        if (gPlayerData.storedItems[idx] != ITEM_NONE) {
            sum++;
        }
    }
 
    return sum;
}

Referenced by get_stored_empty().

◆ get_stored_empty()

s32 get_stored_empty ( void )

Returns: the available room in player storage

Definition at line 453 of file inventory.c.

                           {
    return ARRAY_COUNT(gPlayerData.storedItems) - get_stored_count();
}

◆ recover_hp()

s32 recover_hp ( s32 amt )

Recover player HP.

Parameters

amt	the amount to recover, -1 for full, -2 for full and increase max by 1 (unused)

Returns: the new HP value, after recovery has been applied

Definition at line 2175 of file inventory.c.

                        {
    if (amt == -2) {
        gPlayerData.curMaxHP++;
        gPlayerData.curHP = gPlayerData.curMaxHP;
    } else if (amt == -1) {
        gPlayerData.curHP = gPlayerData.curMaxHP;
    } else {
        if (amt > 0) {
            gPlayerData.curHP += amt;
        }
        if (gPlayerData.curMaxHP < gPlayerData.curHP) {
            gPlayerData.curHP = gPlayerData.curMaxHP;
        }
    }
    return gPlayerData.curHP;
}

Referenced by entity_HeartBlockContent__anim_heal().

◆ recover_fp()

s32 recover_fp ( s32 amt )

Recover player FP.