Inventory System Design

Implement a grid-based inventory similar to Escape from Tarkov, with support for all specified
features. Most items (weapons, tools, etc.) can be handled uniformly as “inventory items,” except for the
listed exceptions. Specifically, we treat all items as slot-based objects (equipable like weapons),
except that certain consumables/grenades (M18 Smoke Grenade – green/white, Ammo Boxes, F-1,
RGD-5, Zarya stun grenades) can stack or behave differently as consumable items. For example, non-
stackable items (unique weapons) have a max-stack size of 1, whereas grenades and ammo can stack
(with a count label) 1 .

• Item Categories: All non-exception items are treated as inventory “weapons” (one per slot). The
exceptions (grenades, ammo boxes listed above) are treated as stackable consumables in the
grid. In practice, give each item a MaxStack attribute (1 for non-stackables) and, on pickup, if
stackable and same type exists, increase its count; otherwise place in a new slot 1 .

• Rotation: Support rotating items (90°) during drag, toggled with the R key. This matches
Tarkov’s behavior (pressing R rotates an item’s orientation in the grid). Implement this by
swapping the item’s width/height grid size on R-press while dragging, and re-checking grid fit.

• Functional Demo: The demo should showcase item stacking (multiple ammo/grenades in one
slot with a count label), item inspection (e.g. right-click or button to view details or 3D preview),
and drop-on-death (when a player dies, all inventory items are removed from the character and
remain in the world or are otherwise handled).

Drag-and-Drop and Interaction

The inventory GUI should allow mouse dragging of items, with real-time feedback:

• Dragging: When the user clicks and drags an item frame, detach it from the grid (reparent it to a
top-level UI layer or ScreenGui) and follow the mouse cursor. Hook
[Link] (mouse movement) to update the item’s Position , and
on InputEnded (mouse release) drop it into the nearest slot 2 3 . A common approach is to
compute the cursor offset (delta) from the original position and tween the UI element to follow
the cursor 2 .

• Snap to Grid: On drop, snap the item to the nearest grid cell. Compute the new grid
coordinates by rounding/clamping the cursor position to the inventory’s grid. For example,
divide the absolute pixel position by the cell size (using integer division or modulus) to get an
(x,y) slot index, then clamp into bounds 3 . As one helper note: “you can use the modulus (%) or
floor-division (//) operator to snap an object to a grid” 3 .

• Invalid Placement: Before finalizing the drop, detect collisions or invalid zones. That is, check
if the item’s proposed grid cells overlap any already-occupied cells or exceed the grid bounds. If
there is a collision (or the item would go out of the grid), revert the item to its original slot (or a
“held” state) and play a refusal animation. Collision detection can be done by maintaining a 2D

1
 array of occupied cells or by bounding-box checks against other items. In practice, calculate the
item’s grid footprint (accounting for rotation), then check if every covered cell is free.

• Hover and Highlight: Optionally highlight the slot under the cursor as the user drags, indicating
the intended drop location. Also, implement hover highlights on inventory items and slots: on
MouseEnter or via a custom loop, change the UI frame’s background or border to indicate
focus. The provided hover-text script uses an attribute HoverText on parts to show metadata.
Similarly, you can attach hover text to GUI elements (or world-model parts) to display item
names/stats when the cursor hovers within a short delay and within range.

Item Stacking, Inspection, and Drop-on-Death

• Stacking: If the player picks up another copy of a stackable item already in inventory, simply
increase the count on that slot instead of creating a new slot. Show the stack count as a small
number in a corner of the item icon. As noted on DevForum, stackable vs non-stackable can be
handled by storing an “Amount” or Count value in the slot 4 1 . If an item’s stack exceeds its
MaxStack , overflow into a new slot (splitting counts) 5 .

• Inspection: Provide a way (e.g. right-click or inspect button) to view item details or a larger
preview. This could open a popup GUI that shows the full item model or stats. This is similar to
how Escape from Tarkov allows inspecting weapon models in 3D. For example, clicking an item
could clone its 3D model into a ViewportFrame for visualization.

• Drop-on-Death: On player death, automatically drop all inventory items. This means clearing the
inventory data and optionally spawning the items in the world or transferring them to a loot
container. This is a common gameplay feature (e.g. Tarkov drops gear on death). Make sure any
equipped gear is also unequipped and dropped.

Grid Layout and Item Sizing

• Grid Structure: Use a grid (2D array) of cells for the inventory, where each cell can hold part of
an item. Display this as a UI (e.g. a UIGridLayout or custom grid of Frames). For visual clarity,
show grid lines or slots to guide placement.

• Item Sizes: Support multiple item sizes (width × height in grid cells). For example, a small pistol
might be 1×2 cells, a rifle 1×4, a backpack 4×3, etc. As one guideline suggests: assign sizes like
Tiny = 1 cell, Small = 2 cells, Normal = 4, Large = 8, Huge = 16 and mark the grid accordingly 6 .
When an item occupies multiple cells, mark all those cells as filled (or “grayed out”) when placed.
This avoids “inventory tetris” overlap.

• Snap Placement: When dragging, visibly snap the item to grid positions (show it moving
between grid cells). You can calculate the snapped position each frame (using mod/floor as
above) so the UI item icon lines up exactly with the grid cells under the cursor 3 .

• Invalid Cells: If the user tries to drop an item where it would overlap a filled cell or stick out,
prevent the drop (or snap it back). This ensures the grid logic is enforced.

2
Gear and Equipment Slots
• Gear Slots: Beyond the inventory grid, include dedicated gear slots for armor and accessories
(e.g. helmet, vest, backpack, pockets). In Tarkov-style systems, a backpack or vest is itself an item
that, when equipped, expands the player’s available grid size. Treat gear as equippable inventory
items: for example, the player’s Vest is a Tool with a name like "Vest_<Name>" found in
ReplicatedStorage . When a vest item is equipped, you could increase inventory capacity or
change item appearance. Similarly, a Helmet item (named "Helmet_<Name>" ) goes into a head
slot.

• Implementation: Store all gear items (vests, helmets, etc.) as tools/models in

ReplicatedStorage or a folder. Use GetDescendants() to search for tools whose name
starts with "Vest_" or "Helmet_" to identify them. When equipping, parent the gear’s
model to the character (so it appears on the player) and move the corresponding inventory slot
to the gear slot UI.

• Additional Slots: If desired, add slots for weapons (primary/secondary/pistol) and pockets.
These can be icons or anchor points on the character UI. Equip a weapon by moving it from
inventory to a weapon slot, and use Humanoid:EquipTool() to have the character hold it.

Visual Representation and Metadata

• Character Viewport: Show the equipped gear and perhaps a preview of held items on the
character model. You can use a ViewportFrame to display the character or individual gear 3D
models. Update this whenever the player equips/unequips items.

• Inventory View: The grid inventory GUI should be clearly labeled and possibly mimic Tarkov’s
look (dark panels, white outlines, item icons). Include labels for weight or size if needed.

• Hover Text / Metadata: Display item information on hover. For example, attach an attribute
HoverText to each item instance (or GUI element) containing its name and stats. Use a local
script (like the provided hover script) to show a TextLabel near the cursor after a short delay,
fading in by shrinking a cover frame【script】. This script checks
target:GetAttribute("HoverText") and only shows it if within a max distance (e.g. 7
studs)【script】. You can adapt this for GUI hover by using MouseEnter events.

• UI Details: Ensure hovered slots highlight (e.g. change border color) and the inventory shows
any stack counts or item icons clearly. Use UI strokes or backgrounds to differentiate empty vs
occupied slots.

Tarkov-Style Interface
Aim for a Tarkov-inspired aesthetic: a blocky, grid-based stash view with interactive item icons. For
example, the design should reflect how Escape from Tarkov makes the player “cram” items into a limited
2D grid 7 . Include features like:

• Visual Clarity: Show each item’s sprite clearly, with count labels and an outline. In Valkov’s
inventory, every item has a white border/icon 7 ; emulate that style.

3
 • Detailed Tooltips: As in Tarkov, items have detailed names and stats, so the hover/inspect
system should reveal full descriptions.
• Drag Feedback: Provide feedback (highlight grid cells, sound effect, or animation) when items
are moved or dropped.
• Backpack VFX: If a backpack is equipped, consider showing it on the character model for visual
confirmation.

By combining these elements—grid logic with cell-sizing 6 , drag-and-drop snapping 3 , hover

metadata, and stacking logic 1 —you’ll have a comprehensive, Tarkov-style inventory system. Each
feature (“rotate with R”, stacking, drop-on-death, gear slots, etc.) should integrate smoothly so the
player can manage their loadout intuitively.

Sources: Implementation techniques are drawn from community guides and game-design best
practices. For example, grid snapping can be done via modulus math 3 , and stackable items are
handled by a count field with max-size logic 1 . The overall grid/Tetris approach is inspired by Escape
from Tarkov’s inventory design 7 6 .

1 4 5 Stackeable and non-stackeable items on inventory system - Scripting Support - Developer

Forum | Roblox
[Link]

2 Dragging slots in UIGridLayout inventory - Scripting Support - Developer Forum | Roblox

[Link]

3 Help with Grid Inventory - Scripting Support - Developer Forum | Roblox

[Link]

6 Tile-based Inventory System - Game Design and Theory - [Link]

[Link]

7 Escape from Tarkov Menu UX Redesign - Blog - Hey I'm Markus

[Link]