En bref
Garde les objets de chaque joueur dans une table sur le serveur, dans un ModuleScript dans ServerScriptService qui est le seul code autorisé à ajouter, retirer ou empiler des objets. Liste tes objets une seule fois dans un ModuleScript dans ReplicatedStorage (id, nom, taille de pile maximale). Après chaque changement, le serveur déclenche un RemoteEvent vers ce joueur avec une copie de son inventaire, et un LocalScript le dessine sous forme de grille avec un ScrollingFrame et un UIGridLayout.
- Le client n'ajoute jamais d'objets. Il peut seulement demander, par exemple "équipe mon épée", et le serveur vérifie que le joueur en possède une avant d'agir.
- Les objets n'arrivent que par du code serveur que tu contrôles : des objets à ramasser, des achats en boutique vérifiés par le serveur, des récompenses.
- Sauvegarde les id et les quantités des objets, pas les Tools, avec DataStoreService quand les joueurs partent, quand le serveur s'arrête et toutes les quelques minutes. Ne sauvegarde jamais un joueur dont les données n'ont pas pu charger.
Sur cette page
Comment s'organise l'inventaire
Le système est fait de six petites pièces, chacune avec un seul rôle. Toutes les règles sur les objets vivent dans un seul module côté serveur, donc quand quelque chose ne va pas, il y a exactement un endroit où chercher.
| Pièce | Type et emplacement | Rôle |
|---|---|---|
ItemCatalog | ModuleScript dans ReplicatedStorage | Ce qu'est chaque objet : nom, description, taille de pile maximale, et s'il peut être équipé ou utilisé. Le serveur et chaque client le lisent. |
InventoryService | ModuleScript dans ServerScriptService | Garde les emplacements de chaque joueur. Le seul code qui ajoute, retire et empile des objets. |
InventoryData | Script dans ServerScriptService | Charge les objets d'un joueur quand il rejoint et les sauvegarde. |
InventoryActions | Script dans ServerScriptService | Vérifie et exécute les requêtes pour équiper et utiliser. |
ItemPickup | Script dans une Part | Donne un objet à celui qui le ramasse. |
InventoryClient | LocalScript dans StarterPlayerScripts | Dessine la grille et envoie les requêtes. Il ne change rien lui-même. |
Les données vont dans un seul sens. Le serveur modifie un inventaire, puis déclenche InventoryUpdated vers ce joueur avec tout l'inventaire, et le client redessine à partir de ça. Quand le joueur clique sur un emplacement, le client déclenche EquipItem ou UseItem avec l'id de l'objet ; le serveur vérifie la requête, fait le changement, et la nouvelle copie arrive par le même chemin. Envoyer tout l'inventaire est plus simple qu'envoyer les changements, et pour quelques dizaines d'emplacements le message reste petit.
Pourquoi le client n'ajoute jamais d'objets
C'est tentant d'ajouter un objet dans le LocalScript qui l'affiche : le joueur clique, l'emplacement se remplit. Ça casse de deux façons.
- Personne d'autre ne le voit. Un changement fait dans un LocalScript n'existe que sur l'appareil de ce joueur. Le serveur n'en entend jamais parler, donc il n'est pas sauvegardé et aucun script serveur ne peut l'utiliser.
- N'importe qui peut le truquer. Si tu règles ça avec un RemoteEvent comme
AddItem(itemId, amount), un exploiteur peut déclencher cet événement lui-même, avec n'importe quels arguments, aussi souvent qu'il veut. Le guide de sécurité de Roblox dit que le serveur doit valider tout ce qu'un client envoie avant de l'utiliser.
Donc dans ce guide, le client peut seulement faire des requêtes sur des objets que le joueur possède déjà : "équipe ça" et "utilise ça". Chaque requête porte un seul id d'objet et aucune quantité, et passe une vérification sur le serveur : est-ce un string, est-ce un vrai objet, le joueur en possède-t-il au moins un, et le joueur envoie-t-il au plus quatre requêtes par seconde ? Le serveur cherche ensuite le Tool lui-même dans le catalogue. Il n'accepte jamais un Tool, un chemin ou une instance venant du client, ce contre quoi le même guide met en garde.
Les objets n'entrent que par du code serveur : un objet à ramasser que le serveur a vérifié, un achat que le serveur a fait payer (le guide de la boutique en construit un), une récompense de quête ou un butin. Pour le modèle RemoteEvent en général, avec la validation d'autres types d'arguments, lis le guide des RemoteEvents.
Étape 1 : préparer l'Explorer
Crée ces objets à la main. Les scripts des étapes suivantes les trouvent par leur nom, donc écris chaque nom exactement comme ici.
- Dans ReplicatedStorage, insère un Folder nommé
InventoryRemotes. Dedans, insère trois RemoteEvents nommésInventoryUpdated,EquipItemetUseItem. - Dans ServerStorage, insère un Folder nommé
ItemTools. Dedans, insère un Tool nomméSword, et dans le Tool une Part nomméeHandle(1 sur 4 sur 1 studs suffit). Vérifie que la case Anchored du Handle est décochée : Roblox prévient que les personnages restent bloqués sur place quand ils tiennent un tool avec des parts ancrées. Un Tool que tu as déjà marche aussi, tant que son nom correspond au catalogue de l'étape 2. - Ajoute les scripts au fur et à mesure des étapes. L'arbre montre où va chacun d'eux.
ReplicatedStorage
ItemCatalog ModuleScript new
InventoryRemotes Folder new
InventoryUpdated RemoteEvent new
EquipItem RemoteEvent new
UseItem RemoteEvent new
ServerScriptService
InventoryService ModuleScript new
InventoryData Script new
InventoryActions Script new
ServerStorage
ItemTools Folder new
Sword Tool new
Handle Part new
StarterPlayer
StarterPlayerScripts
InventoryClient LocalScript new
Workspace
Apple Part new
ItemPickup Script new
Étape 2 : lister tes objets dans un catalogue
Le catalogue décrit une seule fois chaque objet qui peut exister. Les inventaires ne stockent ensuite que l'id d'un objet et une quantité. Ça garde les sauvegardes petites, et tu peux renommer un objet ou réécrire sa description plus tard sans toucher aux données sauvegardées de personne.
Insère un ModuleScript dans ReplicatedStorage, nomme-le ItemCatalog et remplace son contenu par ceci :
-- Chaque objet qui peut exister dans le jeu. Le serveur et chaque client lisent cette
-- liste ; seul le serveur décide qui possède quoi.
export type Item = {
id: string, -- doit correspondre à la clé ci-dessous
name: string,
description: string,
maxStack: number, -- le maximum de cet objet qui tient dans un emplacement
icon: string?, -- image facultative, écrite "rbxassetid://" suivi de l'ID de ton image
toolName: string?, -- un Tool dans ServerStorage.ItemTools : l'objet peut être équipé
heal: number?, -- vie rendue à l'utilisation : l'objet est un consommable
}
local items: { [string]: Item } = {
sword = {
id = "sword",
name = "Sword",
description = "Equip it to put it in your hand.",
maxStack = 1,
toolName = "Sword",
},
apple = {
id = "apple",
name = "Apple",
description = "Use it to restore 25 health.",
maxStack = 10,
heal = 25,
},
wood = {
id = "wood",
name = "Wood",
description = "A building material.",
maxStack = 50,
},
}
local ItemCatalog = {}
-- Renvoie l'objet avec cet id, ou nil si cet objet n'existe pas
function ItemCatalog.get(id: string): Item?
return items[id]
end
return ItemCatalog
Les champs facultatifs décident de ce que fait un objet. toolName le rend équipable, heal le rend utilisable, et un objet qui n'a ni l'un ni l'autre, comme le bois, reste dans l'inventaire jusqu'à ce qu'un autre code serveur (artisanat, vente) le retire.
Pour ajouter un objet, ajoute une entrée dont la clé et l'id sont identiques. Les id tiennent compte des majuscules et ce sont eux qui sont sauvegardés, donc ne change jamais un id une fois que des joueurs possèdent l'objet : change plutôt son name.
Étape 3 : garder les inventaires sur le serveur
Ce ModuleScript possède l'inventaire de chaque joueur. Chaque inventaire est une liste d'emplacements, chaque emplacement un id d'objet et une quantité, plus une capacité de 20 emplacements. Les autres scripts serveur appellent ses fonctions, et rien d'autre ne modifie la table.
Insère un ModuleScript dans ServerScriptService et nomme-le InventoryService :
-- Le seul code qui modifie les inventaires. Il est dans ServerScriptService,
-- où les clients ne peuvent ni le voir ni le lancer.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Le mode strict ne peut pas suivre un require à travers WaitForChild, donc on décrit
-- la partie du module que ce script utilise
type Item = { id: string, maxStack: number }
type Catalog = { get: (id: string) -> Item? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent
export type Slot = { id: string, count: number }
type Inventory = { slots: { Slot }, capacity: number, equipped: string? }
local CAPACITY = 20 -- emplacements par joueur
local STARTER_ITEMS: { Slot } = { -- ce avec quoi un tout nouveau joueur commence
{ id = "sword", count = 1 },
{ id = "apple", count = 3 },
}
local inventories: { [Player]: Inventory } = {}
local InventoryService = {}
-- Envoie à son propriétaire une copie de son inventaire. Tourne après chaque changement.
local function sync(player: Player)
local inventory = inventories[player]
if inventory then
inventoryUpdated:FireClient(player, {
capacity = inventory.capacity,
slots = inventory.slots,
equipped = inventory.equipped,
})
end
end
-- Règles d'empilement : compléter les piles pas pleines, puis commencer de nouvelles piles dans
-- les emplacements vides. Renvoie combien ont été ajoutés, ce qui peut être moins que demandé.
local function addToInventory(inventory: Inventory, item: Item, amount: number): number
local remaining = amount
for _, slot in inventory.slots do
if remaining == 0 then
break
end
if slot.id == item.id and slot.count < item.maxStack then
local moved = math.min(item.maxStack - slot.count, remaining)
slot.count += moved
remaining -= moved
end
end
while remaining > 0 and #inventory.slots < inventory.capacity do
local moved = math.min(item.maxStack, remaining)
table.insert(inventory.slots, { id = item.id, count = moved })
remaining -= moved
end
return amount - remaining
end
function InventoryService.count(player: Player, itemId: string): number
local inventory = inventories[player]
local total = 0
if inventory then
for _, slot in inventory.slots do
if slot.id == itemId then
total += slot.count
end
end
end
return total
end
-- Combien d'exemplaires d'un objet tiennent encore : la place dans ses piles plus les emplacements vides
function InventoryService.spaceFor(player: Player, itemId: string): number
local inventory = inventories[player]
local item = ItemCatalog.get(itemId)
if not inventory or not item then
return 0
end
local space = (inventory.capacity - #inventory.slots) * item.maxStack
for _, slot in inventory.slots do
if slot.id == itemId then
space += item.maxStack - slot.count
end
end
return space
end
-- Ajoute jusqu'à `amount` exemplaires d'un objet. Renvoie combien ont été ajoutés (0 si
-- l'objet n'existe pas, si l'inventaire est plein ou pas encore chargé).
function InventoryService.add(player: Player, itemId: string, amount: number): number
local inventory = inventories[player]
local item = ItemCatalog.get(itemId)
local wanted = math.floor(amount)
if not inventory or not item or wanted < 1 then
return 0
end
local added = addToInventory(inventory, item, wanted)
if added > 0 then
sync(player)
end
return added
end
-- Retire exactement `amount` exemplaires d'un objet, en prenant d'abord dans les dernières piles.
-- Si le joueur en a moins, ne retire rien et renvoie false.
function InventoryService.remove(player: Player, itemId: string, amount: number): boolean
local inventory = inventories[player]
local wanted = math.floor(amount)
if not inventory or wanted < 1 or InventoryService.count(player, itemId) < wanted then
return false
end
local remaining = wanted
-- Parcourir à l'envers pour que table.remove ne saute jamais un emplacement
for index = #inventory.slots, 1, -1 do
local slot = inventory.slots[index]
if slot.id == itemId then
local taken = math.min(slot.count, remaining)
slot.count -= taken
remaining -= taken
if slot.count == 0 then
table.remove(inventory.slots, index)
end
if remaining == 0 then
break
end
end
end
sync(player)
return true
end
function InventoryService.getEquipped(player: Player): string?
local inventory = inventories[player]
return if inventory then inventory.equipped else nil
end
function InventoryService.setEquipped(player: Player, itemId: string?)
local inventory = inventories[player]
if inventory then
inventory.equipped = itemId
sync(player)
end
end
-- Appelée une fois les données sauvegardées d'un joueur chargées. `saved` est ce que le data
-- store a renvoyé : nil pour un nouveau joueur. Chaque entrée repasse par les
-- règles d'empilement, donc les objets retirés et les anciennes tailles de pile ne cassent rien.
function InventoryService.load(player: Player, saved: any)
local inventory: Inventory = { slots = {}, capacity = CAPACITY }
local entries: { Slot } = STARTER_ITEMS
if type(saved) == "table" and type(saved.slots) == "table" then
entries = {}
for _, entry in saved.slots do
if type(entry) == "table" and type(entry.id) == "string" and type(entry.count) == "number" then
table.insert(entries, { id = entry.id, count = math.floor(entry.count) })
end
end
end
for _, entry in entries do
local item = ItemCatalog.get(entry.id)
if item and entry.count > 0 then
addToInventory(inventory, item, entry.count)
end
end
inventories[player] = inventory
sync(player)
end
-- Une simple copie à sauvegarder, ou nil si les données de ce joueur n'ont jamais chargé
function InventoryService.serialize(player: Player): { version: number, slots: { Slot } }?
local inventory = inventories[player]
if not inventory then
return nil
end
local slots: { Slot } = {}
for index, slot in inventory.slots do
slots[index] = { id = slot.id, count = slot.count }
end
return { version = 1, slots = slots }
end
function InventoryService.unload(player: Player)
inventories[player] = nil
end
return InventoryService
Les lignes type et le cast :: après require servent seulement au vérificateur de types de Luau, qui ne peut pas voir ce que renvoie un module trouvé avec WaitForChild. Elles ne changent rien quand le jeu tourne. Les autres scripts de ce guide font pareil.
Voici comment les règles d'empilement s'appliquent avec le catalogue ci-dessus, où les pommes s'empilent jusqu'à 10 :
- Ajouter 15 pommes à un joueur qui a une pile de 7 remplit cette pile jusqu'à 10, puis commence une nouvelle pile de 5.
- Quand il n'y a plus d'emplacements,
addajoute ce qui tient et renvoie ce nombre. Appelle d'abordspaceForquand ça doit être tout ou rien, comme le fait l'objet à ramasser de l'étape 5. removefonctionne en tout ou rien. Demander 3 pommes à un joueur qui en a 2 n'en retire aucune et renvoiefalse, donc vérifie le résultat avant de donner quoi que ce soit en échange.- Les emplacements n'ont pas de trous : quand l'un se vide, les autres remontent. Ça garde la liste simple à envoyer et à sauvegarder. Les questions à la fin parlent des emplacements qui gardent leur position.
| Fonction | Renvoie | À utiliser pour |
|---|---|---|
add(player, itemId, amount) | Combien ont été ajoutés | Objets à ramasser, récompenses, achats |
remove(player, itemId, amount) | true si tout a été retiré | Utiliser, vendre, fabriquer |
count(player, itemId) | Le total sur toutes les piles | Vérifier ce qu'un joueur possède |
spaceFor(player, itemId) | Combien tiendraient encore | Vérifier avant un ajout en tout ou rien |
getEquipped, setEquipped | L'id de l'objet équipé, ou nil | Équiper, à l'étape 6 |
load, serialize, unload | Une copie prête à sauvegarder (serialize) | Charger et sauvegarder, à l'étape 4 |
Étape 4 : charger et sauvegarder chaque inventaire
Les inventaires vivent dans la mémoire du serveur, donc ils disparaissent quand le joueur part. Ce script charge les emplacements d'un joueur depuis un data store quand il rejoint et les réécrit quand il part, quand le serveur s'arrête, et toutes les trois minutes au cas où le serveur planterait. Il ne sauvegarde que les id et les quantités : les data stores ne peuvent pas stocker d'Instances comme des Tools.
Insère un Script dans ServerScriptService et nomme-le InventoryData :
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")
local ServerScriptService = game:GetService("ServerScriptService")
type InventoryApi = {
load: (player: Player, saved: any) -> (),
serialize: (player: Player) -> any,
unload: (player: Player) -> (),
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi
local STORE_NAME = "PlayerInventory_v1"
local LOAD_ATTEMPTS = 3
local AUTOSAVE_SECONDS = 180
-- Seuls les joueurs dont les données ont chargé sont sauvegardés. Un chargement raté ne doit
-- jamais être suivi d'une sauvegarde, sinon l'inventaire vide remplace le vrai.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0
local function keyFor(player: Player): string
return "User_" .. player.UserId
end
-- Une requête ratée ne doit faire perdre ses objets à personne, donc on réessaie quelques fois.
-- GetDataStore est aussi dans le pcall, pour qu'une session Studio qui ne peut pas
-- joindre les data stores reçoive un avertissement au lieu d'arrêter ce script.
local function loadSaved(player: Player): (boolean, any)
for attempt = 1, LOAD_ATTEMPTS do
local ok, result = pcall(function()
return DataStoreService:GetDataStore(STORE_NAME):GetAsync(keyFor(player))
end)
if ok then
return true, result
end
warn(`Inventory load failed for {player.Name} (attempt {attempt}): {result}`)
if attempt < LOAD_ATTEMPTS then
task.wait(attempt * 2)
end
end
return false, nil
end
local function onPlayerAdded(player: Player)
local ok, saved = loadSaved(player)
if player.Parent ~= Players then
return -- il est parti pendant le chargement
end
if ok then
InventoryService.load(player, saved) -- saved vaut nil pour un nouveau joueur
canSave[player] = true
elseif RunService:IsStudio() then
-- Veut souvent dire que l'accès de Studio aux services API est désactivé. Jouer avec les
-- objets de départ pour pouvoir tester, mais ne jamais les sauvegarder.
warn("Inventory not loaded: playing with starter items that will not be saved")
InventoryService.load(player, nil)
else
player:Kick("Your inventory could not be loaded. Please rejoin in a minute.")
end
end
local function save(player: Player)
if not canSave[player] then
return -- ses données n'ont jamais chargé, donc rien ne peut être écrit sans risque
end
local data = InventoryService.serialize(player)
if not data then
return
end
activeSaves += 1
local ok, err = pcall(function()
DataStoreService:GetDataStore(STORE_NAME):SetAsync(keyFor(player), data, { player.UserId })
end)
activeSaves -= 1
if not ok then
warn(`Inventory save failed for {player.Name}: {err}`)
end
end
Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
task.spawn(onPlayerAdded, player)
end
Players.PlayerRemoving:Connect(function(player: Player)
save(player)
canSave[player] = nil
InventoryService.unload(player)
end)
-- Quand le serveur s'arrête, sauvegarder tous ceux encore là, puis attendre chaque
-- sauvegarde en cours, y compris celles lancées par PlayerRemoving
game:BindToClose(function()
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
while activeSaves > 0 do
task.wait()
end
end)
-- Sauvegarder tout le monde toutes les quelques minutes, pour qu'un crash coûte des minutes, pas une session
while true do
task.wait(AUTOSAVE_SECONDS)
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
end
Ce que fait le script, et pourquoi :
- Charger avec des valeurs par défaut. Un nouveau joueur n'a aucune valeur sauvegardée, donc
GetAsyncrenvoie nil et il reçoit les objets de départ. Les emplacements sauvegardés repassent par les règles d'empilement, donc un objet que tu as retiré du catalogue ou une taille de pile plus petite ne peut pas casser un chargement. Tout ce qui ne tient plus, ou dont l'id n'est plus dans le catalogue, est abandonné, et la sauvegarde suivante rend ça définitif, donc garde dans le catalogue chaque id que des joueurs peuvent posséder. - Ne jamais sauvegarder après un chargement raté. Seuls les joueurs dans
canSavesont écrits. Sur un serveur en ligne, un joueur dont les données ne chargent toujours pas après trois essais est invité à revenir. Dans Studio, il reçoit à la place des objets de départ non sauvegardés, quelques secondes plus tard à cause des nouveaux essais, et c'est ce que tu vois tant que le jeu n'est pas publié avec l'accès aux API activé. - Sauvegarder au départ et à l'arrêt.
BindToClosesauvegarde tous ceux encore sur le serveur et attend les sauvegardes déjà en cours. Roblox donne jusqu'à 30 secondes aux fonctions liées. - Rester dans les limites. Une écriture par joueur toutes les trois minutes, plus une quand il part, c'est très en dessous du budget par défaut par serveur de 60 écritures par minute plus 40 par joueur (selon la documentation au 30 septembre 2026). Le modèle de clé
User_suit les bonnes pratiques de Roblox, et passer l'ID utilisateur àSetAsyncrelie les données à ce joueur, ce que Roblox recommande fortement pour traiter les demandes de suppression de données.
C'est une base solide pour un petit jeu. Le verrouillage de session, qui empêche un joueur qui change vite de serveur de charger ses données avant que l'ancien serveur les ait sauvegardées, et quand utiliser UpdateAsync au lieu de SetAsync, sont expliqués dans le tutoriel DataStore.
Étape 5 : donner des objets depuis le monde
Un objet à ramasser est la façon la plus simple de faire entrer des objets dans un inventaire : une part avec un ProximityPrompt qui ajoute un objet quand un joueur l'utilise. Le script écoute son événement Triggered sur le serveur, donc l'objet est ajouté là où le client ne peut pas intervenir.
- Ajoute une Part dans Workspace, nomme-la
Appleet colore-la en rouge. Coche Anchored et décoche CanCollide, pour que personne ne la heurte pendant qu'elle est invisible. Le prompt affiche le nom de la part. - Avec la part sélectionnée, descends jusqu'à la section Attributes de la fenêtre Properties et clique sur +. Ajoute
ItemIdavec le type string et clique sur Save, puis règle sa valeur surapple. AjouteAmountde la même façon en number réglé sur1. - Insère un Script dans la part, nomme-le
ItemPickupet colle ce code :
-- Mets ce Script dans une Part et donne à la Part deux attributs :
-- ItemId (un string, comme apple) et Amount (un number, comme 1).
local ServerScriptService = game:GetService("ServerScriptService")
type InventoryApi = {
add: (player: Player, itemId: string, amount: number) -> number,
spaceFor: (player: Player, itemId: string) -> number,
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi
local part = script.Parent :: BasePart
local RESPAWN_SECONDS = 15
local itemId = part:GetAttribute("ItemId")
local amount = part:GetAttribute("Amount")
if typeof(itemId) ~= "string" or typeof(amount) ~= "number" or amount < 1 then
error(`{part:GetFullName()} needs an ItemId (string) and an Amount (number, 1 or more) attribute`)
end
local prompt = Instance.new("ProximityPrompt")
prompt.ActionText = "Pick up"
prompt.ObjectText = part.Name
prompt.Parent = part
local visibleTransparency = part.Transparency
prompt.Triggered:Connect(function(player: Player)
if not prompt.Enabled then
return -- quelqu'un d'autre l'a ramassé il y a un instant
end
-- Vérifier la distance sur le serveur au lieu de faire confiance à la requête
local character = player.Character
if not character then
return
end
local distance = (character:GetPivot().Position - part.Position).Magnitude
if distance > prompt.MaxActivationDistance + 5 then
return
end
if InventoryService.spaceFor(player, itemId) < amount then
return -- pas assez de place : laisser l'objet là où il est
end
InventoryService.add(player, itemId, amount)
prompt.Enabled = false
part.Transparency = 1
task.wait(RESPAWN_SECONDS)
part.Transparency = visibleTransparency
prompt.Enabled = true
end)
Copie la part pour placer d'autres objets à ramasser. Change les attributs pour distribuer du bois, une autre épée ou une pile de pommes.
Roblox vérifie la distance pour Triggered, mais son guide de sécurité te dit quand même de valider les prompts sur le serveur : un exploiteur peut déclencher les événements d'un prompt même quand Enabled vaut false, et peut tirer une part non ancrée à côté de son personnage. C'est pour ça que le script vérifie Enabled et la distance lui-même, et que la part est ancrée.
N'importe quel autre script serveur donne des objets de la même façon. Après un achat, une quête ou un kill, fais un require de InventoryService comme les scripts ci-dessus et appelle InventoryService.add(player, "wood", 5). Vérifie d'abord spaceFor chaque fois que l'objet ne doit pas être perdu. Un PNJ peut être une autre source : dans le guide du dialogue de PNJ, une réponse lance une action sur le serveur, et cette action peut appeler InventoryService.add de la même façon.
Étape 6 : équiper des Tools et utiliser des objets
Deux RemoteEvents portent les seules requêtes qu'un client peut faire. EquipItem met une copie du Tool de l'objet depuis ServerStorage dans le Backpack du joueur (la barre d'objets en bas de l'écran) et dans sa main, et redemander la retire. UseItem retire un exemplaire d'un objet utilisable et applique son effet, ici un soin.
Insère un Script dans ServerScriptService et nomme-le InventoryActions :
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
local ServerStorage = game:GetService("ServerStorage")
type Item = { id: string, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type InventoryApi = {
count: (player: Player, itemId: string) -> number,
remove: (player: Player, itemId: string, amount: number) -> boolean,
getEquipped: (player: Player) -> string?,
setEquipped: (player: Player, itemId: string?) -> (),
}
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent
local itemTools = ServerStorage:WaitForChild("ItemTools")
local COOLDOWN_SECONDS = 0.25
local lastRequest: { [Player]: number } = {}
-- Chaque requête commence ici. Un client peut envoyer n'importe quoi à tout moment, donc vérifier
-- le type, que l'objet existe, que le joueur en possède un, et la fréquence.
local function ownedItem(player: Player, itemId: unknown): Item?
if typeof(itemId) ~= "string" then
return nil
end
local now = os.clock()
if now - (lastRequest[player] or 0) < COOLDOWN_SECONDS then
return nil
end
lastRequest[player] = now
local item = ItemCatalog.get(itemId)
if not item or InventoryService.count(player, itemId) < 1 then
return nil
end
return item
end
-- Détruit le Tool de cet objet partout où il y a une copie : barre d'objets, main ou StarterGear
local function destroyTools(container: Instance?, itemId: string)
if not container then
return
end
for _, child in container:GetChildren() do
if child:IsA("Tool") and child:GetAttribute("InventoryItem") == itemId then
child:Destroy()
end
end
end
local function unequip(player: Player)
local equippedId = InventoryService.getEquipped(player)
if equippedId then
destroyTools(player:FindFirstChildOfClass("Backpack"), equippedId)
destroyTools(player.Character, equippedId)
destroyTools(player:FindFirstChildOfClass("StarterGear"), equippedId)
InventoryService.setEquipped(player, nil)
end
end
local function equip(player: Player, item: Item, toolName: string)
local template = itemTools:FindFirstChild(toolName)
local backpack = player:FindFirstChildOfClass("Backpack")
if not template or not template:IsA("Tool") or not backpack then
warn(`Cannot equip {item.id}: no Tool named {toolName} in ServerStorage.ItemTools`)
return
end
unequip(player) -- un seul tool équipé à la fois
local tool = template:Clone()
tool.CanBeDropped = false -- une copie lâchée pourrait être ramassée par quelqu'un d'autre
tool:SetAttribute("InventoryItem", item.id)
tool.Parent = backpack
-- Une deuxième copie dans StarterGear est recopiée dans le Backpack après une réapparition
local starterGear = player:FindFirstChildOfClass("StarterGear")
if starterGear then
local gearCopy = tool:Clone()
gearCopy.Parent = starterGear
end
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if humanoid and humanoid.Health > 0 then
humanoid:EquipTool(tool) -- le mettre directement dans sa main
end
InventoryService.setEquipped(player, item.id)
end
equipItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
local item = ownedItem(player, itemId)
if not item or not item.toolName then
return
end
if InventoryService.getEquipped(player) == item.id then
unequip(player) -- recliquer sur l'objet équipé le range
else
equip(player, item, item.toolName)
end
end)
useItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
local item = ownedItem(player, itemId)
if not item or not item.heal then
return
end
local heal = item.heal
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 or humanoid.Health >= humanoid.MaxHealth then
return -- mort ou déjà à fond de vie : ne pas gaspiller l'objet
end
-- Prendre l'objet d'abord, et ne soigner que si ça a marché
if InventoryService.remove(player, item.id, 1) then
humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + heal)
end
end)
Players.PlayerRemoving:Connect(function(player: Player)
lastRequest[player] = nil
end)
| Requête | Le client envoie | Le serveur vérifie avant d'agir |
|---|---|---|
EquipItem | Un id d'objet | C'est un string, l'objet existe, le joueur en possède un, les requêtes n'arrivent pas plus vite que quatre par seconde, l'objet a un toolName, et un Tool de ce nom est dans ServerStorage.ItemTools |
UseItem | Un id d'objet | Les mêmes vérifications de type, de possession et de fréquence, l'objet a une valeur heal, le personnage est en vie et blessé, et un objet a été retiré avant de rendre de la vie |
Trois détails empêchent un Tool d'être dupliqué ou perdu. La copie a CanBeDropped réglé sur false, parce qu'un Tool lâché atterrit dans Workspace, où un autre joueur pourrait le prendre pendant que l'original reste dans l'inventaire. Chaque copie porte un attribut InventoryItem, pour que le déséquipement puisse trouver et détruire chaque copie où qu'elle soit. Et quand le joueur a un conteneur StarterGear, une deuxième copie y va. Roblox copie StarterGear dans le Backpack à chaque apparition du personnage, donc une épée équipée revient après une réapparition.
Un seul Tool est équipé à la fois, et ce qui est équipé n'est pas sauvegardé, donc un joueur qui revient commence avec une barre d'objets vide. Si tu ajoutes plus tard la vente ou le lâcher d'objets, déséquipe un objet avant que sa dernière copie quitte l'inventaire.
L'épée provisoire peut devenir une épée qui se bat vraiment : construis le Tool du guide de l'épée, garde son nom Sword et mets-le dans ItemTools à la place de l'épée provisoire. Le script serveur de ce guide vérifie alors chaque coup, quelle que soit la façon dont le joueur a eu l'épée.
Étape 7 : dessiner la grille de l'inventaire
Le LocalScript construit toute la fenêtre en code, donc il n'y a pas d'interface à placer à la main. Un ScrollingFrame contient les emplacements, un UIGridLayout dedans les range en lignes, et AutomaticCanvasSize agrandit la zone de défilement quand des lignes s'ajoutent.
Dans l'Explorer, ouvre StarterPlayer, insère un LocalScript dans StarterPlayerScripts et nomme-le InventoryClient :
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")
type Item = { name: string, description: string, icon: string?, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type Slot = { id: string, count: number }
type Snapshot = { capacity: number, slots: { Slot }, equipped: string? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent
local player = Players.LocalPlayer
local TOGGLE_KEY = Enum.KeyCode.B
local COLOURS = {
panel = Color3.fromRGB(24, 20, 36),
slot = Color3.fromRGB(44, 38, 64),
empty = Color3.fromRGB(34, 30, 48),
equipped = Color3.fromRGB(124, 77, 255),
text = Color3.fromRGB(240, 238, 245),
muted = Color3.fromRGB(170, 165, 185),
}
local function addCorner(parent: GuiObject, radius: number)
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, radius)
corner.Parent = parent
end
local function makeLabel(parent: GuiObject, text: string, textSize: number): TextLabel
local label = Instance.new("TextLabel")
label.BackgroundTransparency = 1
label.Font = Enum.Font.BuilderSansBold
label.TextColor3 = COLOURS.text
label.TextSize = textSize
label.Text = text
label.Parent = parent
return label
end
-- 1. Construire la fenêtre une fois. ResetOnSpawn = false la garde après les réapparitions.
local gui = Instance.new("ScreenGui")
gui.Name = "InventoryGui"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")
local openButton = Instance.new("TextButton")
openButton.AnchorPoint = Vector2.new(0, 0.5)
openButton.Position = UDim2.new(0, 16, 0.5, 0)
openButton.Size = UDim2.fromOffset(140, 40)
openButton.BackgroundColor3 = COLOURS.panel
openButton.Font = Enum.Font.BuilderSansBold
openButton.TextColor3 = COLOURS.text
openButton.TextSize = 18
openButton.Text = "Inventory (B)"
addCorner(openButton, 8)
openButton.Parent = gui
local panel = Instance.new("Frame")
panel.AnchorPoint = Vector2.new(0.5, 0.5)
panel.Position = UDim2.fromScale(0.5, 0.5)
panel.Size = UDim2.fromScale(0.9, 0.8)
panel.BackgroundColor3 = COLOURS.panel
panel.Visible = false
addCorner(panel, 12)
panel.Parent = gui
local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(440, 400)
sizeLimit.Parent = panel
local title = makeLabel(panel, "Inventory", 22)
title.Position = UDim2.fromOffset(16, 8)
title.Size = UDim2.new(1, -32, 0, 32)
title.TextXAlignment = Enum.TextXAlignment.Left
local slotCount = makeLabel(panel, "", 16)
slotCount.Position = UDim2.fromOffset(16, 8)
slotCount.Size = UDim2.new(1, -32, 0, 32)
slotCount.TextColor3 = COLOURS.muted
slotCount.TextXAlignment = Enum.TextXAlignment.Right
local grid = Instance.new("ScrollingFrame")
grid.Position = UDim2.fromOffset(12, 48)
grid.Size = UDim2.new(1, -24, 1, -100)
grid.BackgroundTransparency = 1
grid.BorderSizePixel = 0
grid.CanvasSize = UDim2.new() -- AutomaticCanvasSize l'agrandit pour contenir les cases
grid.AutomaticCanvasSize = Enum.AutomaticSize.Y
grid.ScrollingDirection = Enum.ScrollingDirection.Y
grid.ScrollBarThickness = 6
grid.Parent = panel
local layout = Instance.new("UIGridLayout")
layout.CellSize = UDim2.fromOffset(72, 72)
layout.CellPadding = UDim2.fromOffset(8, 8)
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = grid
local info = makeLabel(panel, "Click an item to equip or use it.", 16)
info.AnchorPoint = Vector2.new(0, 1)
info.Position = UDim2.new(0, 16, 1, -8)
info.Size = UDim2.new(1, -32, 0, 40)
info.Font = Enum.Font.BuilderSans
info.TextColor3 = COLOURS.muted
info.TextWrapped = true
info.TextXAlignment = Enum.TextXAlignment.Left
-- 2. Une case par emplacement. Ça dessine seulement ce que le serveur a envoyé ; ça ne
-- modifie jamais l'inventaire.
local function makeCell(index: number, slot: Slot?, equippedId: string?)
local cell = Instance.new("TextButton")
cell.LayoutOrder = index
cell.Text = ""
cell.AutoButtonColor = slot ~= nil
cell.BackgroundColor3 = if slot then COLOURS.slot else COLOURS.empty
addCorner(cell, 8)
cell.Parent = grid
if not slot then
return -- un emplacement vide
end
local itemId = slot.id
local item = ItemCatalog.get(itemId)
local name = if item then item.name else itemId
if item and item.icon then
local image = Instance.new("ImageLabel")
image.BackgroundTransparency = 1
image.Size = UDim2.fromScale(1, 1)
image.Image = item.icon
image.Parent = cell
else
local nameLabel = makeLabel(cell, name, 14)
nameLabel.Size = UDim2.fromScale(1, 1)
nameLabel.TextWrapped = true
end
if slot.count > 1 then
local countLabel = makeLabel(cell, `x{slot.count}`, 14)
countLabel.AnchorPoint = Vector2.new(1, 1)
countLabel.Position = UDim2.new(1, -6, 1, -4)
countLabel.Size = UDim2.fromOffset(40, 16)
countLabel.TextXAlignment = Enum.TextXAlignment.Right
end
if itemId == equippedId then
local outline = Instance.new("UIStroke")
outline.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
outline.Color = COLOURS.equipped
outline.Thickness = 3
outline.Parent = cell
end
cell.MouseEnter:Connect(function()
info.Text = if item then `{item.name}: {item.description}` else name
end)
cell.Activated:Connect(function()
-- Demander, jamais imposer : le serveur vérifie la requête et renvoie le résultat
if item and item.toolName then
equipItem:FireServer(itemId)
elseif item and item.heal then
useItem:FireServer(itemId)
end
end)
end
local function render(snapshot: Snapshot)
for _, child in grid:GetChildren() do
if child:IsA("GuiButton") then
child:Destroy()
end
end
for index = 1, snapshot.capacity do
makeCell(index, snapshot.slots[index], snapshot.equipped)
end
slotCount.Text = `{#snapshot.slots} / {snapshot.capacity} slots`
end
-- Le serveur l'envoie après le chargement et après chaque changement
inventoryUpdated.OnClientEvent:Connect(render)
-- 3. Ouvrir et fermer avec le bouton ou la touche B
local function toggle()
panel.Visible = not panel.Visible
end
openButton.Activated:Connect(toggle)
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessedEvent: boolean)
if not gameProcessedEvent and input.KeyCode == TOGGLE_KEY then
toggle()
end
end)
Un LocalScript dans StarterPlayerScripts tourne une fois par session, et ResetOnSpawn = false garde la ScreenGui quand le personnage réapparaît, donc la grille affiche toujours la dernière copie envoyée par le serveur.
Le client dessine une case pour chaque emplacement, vides compris, donc un inventaire de 20 emplacements ressemble toujours à 20 emplacements. Chaque mise à jour détruit les anciennes cases et en construit de nouvelles, ce qui est simple et suffit pour quelques dizaines d'emplacements. Si le serveur déclenche InventoryUpdated avant que ce script s'y soit connecté, Roblox met le message en file d'attente et le livre dès que le gestionnaire se connecte, donc le premier inventaire n'est pas perdu.
Tu préfères dessiner la fenêtre dans Studio ? Construis une ScreenGui avec un emplacement modèle et fais-en un Clone dans makeCell. Pour les icônes, règle l'icon d'un objet dans le catalogue sur une image que tu as importée, et sa case affiche l'image au lieu du nom.
Tester l'inventaire
- Appuie sur Play. Ouvre l'inventaire avec le bouton à gauche ou B : un nouveau joueur a une Sword et 3 Apples, et le compteur affiche 2 / 20 slots. Tant que Studio ne peut pas joindre les data stores, les objets mettent quelques secondes à apparaître, après des avertissements de chargement dans Output, et ne sont pas sauvegardés.
- Clique sur la Sword. Elle apparaît dans ta main et dans la barre d'objets, et son emplacement est entouré de violet. Clique encore dessus pour la ranger.
- Va jusqu'à la part Apple et utilise son prompt. La pile de pommes monte à 4, et la part disparaît pendant 15 secondes.
- Pour essayer le soin, baisse d'abord ta vie. Passe le bouton Client/Server sur Server, sélectionne le
Humanoidde ton personnage dans l'Explorer, règle Health sur 50, repasse sur Client et clique sur une Apple. - Avec l'accès de Studio aux services API activé, arrête et relance le jeu. La pomme que tu as ramassée est toujours là. Si un chargement ou une sauvegarde a échoué, Output le dit.
Pour le voir avec plus d'un joueur, choisis Server & Clients dans les options de test avec 2 clients. Chaque joueur ne voit que son propre inventaire, mais les deux peuvent voir une épée dans la main de l'autre.
Problèmes courants
La plupart des problèmes apparaissent dans la fenêtre Output sous forme d'avertissement ou de ligne d'erreur rouge. Lis la première : les erreurs suivantes en sont souvent la conséquence.
Infinite yield possible sur un appel à WaitForChild
Un script attend un objet qui n'existe pas sous ce nom exact. Compare ton Explorer avec l'arbre de l'étape 1 : InventoryRemotes avec ses trois RemoteEvents dans ReplicatedStorage, ItemTools dans ServerStorage, et les deux modules. Les noms tiennent compte des majuscules. Le guide des erreurs de script explique cet avertissement plus en détail.
La grille s'ouvre mais reste vide
Le client ne dessine que ce que le serveur envoie. Cherche dans Output des avertissements Inventory load failed, et vérifie que InventoryData est un Script, pas un LocalScript, dans ServerScriptService, avec le ModuleScript InventoryService à côté. Si Output affiche une erreur Remote event invocation, rien sur le client n'écoute InventoryUpdated : cherche une erreur plus ancienne venant de InventoryClient.
Les objets se réinitialisent à chaque fois que je joue dans Studio
Si Output affiche Inventory not loaded: playing with starter items that will not be saved, le jeu n'est pas publié ou l'accès de Studio aux services API est désactivé. Active-le comme expliqué à l'étape 4, dans une copie de test de ton jeu.
Cliquer sur l'épée ne fait rien
Cherche Cannot equip sword dans Output : le Tool dans ServerStorage.ItemTools doit avoir exactement le même nom que toolName dans le catalogue. Un Tool a aussi besoin d'une part nommée Handle pour être tenu, sauf si tu règles son RequiresHandle sur false.
Le prompt de l'objet à ramasser s'affiche, mais rien n'est ajouté
L'attribut ItemId doit correspondre exactement à un id du catalogue, majuscules comprises : apple, pas Apple. Rien n'est ajouté tant que l'inventaire du joueur charge encore, ou quand il n'y a pas assez de place pour toute la quantité.
La sauvegarde échoue depuis que j'ai changé ce qui est sauvegardé
Les data stores acceptent des données simples : strings, numbers, booleans et des tables de ces types. Sauvegarder un Tool, une Part ou n'importe quelle autre Instance échoue, ou la valeur est stockée comme nil. Sauvegarde l'id et la quantité de l'objet, et reconstruis tout le reste depuis le catalogue, comme le fait serialize.
Le faire avec RoCode
Si tu préfères décrire le système plutôt que le câbler à la main, RoCode peut le construire dans le jeu que tu as ouvert. C'est un agent IA pour Roblox Studio : tu décris la fonction dans un chat web, et son plugin pour Studio crée les scripts et les objets dans ton Explorer au lieu de te donner du code à coller.
Ajoute un inventaire de 20 emplacements qui empile les objets, une grille qui s'ouvre avec B, une épée dans ServerStorage que les joueurs peuvent équiper, des pommes qui soignent, et une sauvegarde avec DataStoreService.
- Peut parcourir ton jeu quand une étape le demande, avec Search Game et Search Scripts, pour s'appuyer sur les objets, les remotes ou le code de sauvegarde que tu as déjà au lieu d'ajouter un deuxième système
- Crée les dossiers et les RemoteEvents avec Create Instance, et les ModuleScripts, les Scripts et le LocalScript avec Create Script
- Peut préparer la fenêtre avec Build UI, qui a une mise en page d'inventaire avec des emplacements provisoires ; le code qui remplit les emplacements depuis le serveur est écrit dans des scripts séparés
- Vérifie la compilation de chaque script dans Studio avec Check Script, qui repère les erreurs de compilation et quelques schémas risqués mais ne vérifie pas les types, ne fait pas de lint et ne lance pas ton code
Chaque lot de changements est un point d'annulation dans Studio. RoCode ne peut pas activer l'accès de Studio aux services API, donc tu le fais toi-même. Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.15 ou plus récent son personnage de test peut appuyer sur des touches et équiper des objets, mais il ne vérifie que ce qu'il a choisi de tester, donc teste la sauvegarde toi-même. Un inventaire repose sur d'autres systèmes comme la sauvegarde et les tools, et un créateur de jeux IA qui construit dans ton propre jeu Studio les ajoute un prompt à la fois. Comment RoCode se connecte à Studio.
Questions fréquentes
Faut-il utiliser le Backpack de Roblox au lieu d'un inventaire personnalisé ?
Le Backpack est l'inventaire intégré de Roblox : chaque Tool dedans s'affiche comme un bouton dans la barre d'objets. Si tous les objets de ton jeu sont des Tools et que tu n'as besoin ni de piles, ni de quantités, ni de limite d'emplacements, il peut suffire, même s'il faut quand même sauvegarder quels Tools chaque joueur possède. Un inventaire personnalisé sert aux objets qui ne sont pas des Tools, comme les matériaux et les consommables. Ce guide utilise les deux : l'inventaire stocke tout, et le Backpack contient le Tool équipé.
Peut-on cacher la barre d'objets par défaut ?
Oui. Depuis un LocalScript, appelle StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Avec la barre cachée, les joueurs ont besoin d'un autre moyen de tenir et de ranger un Tool équipé, par exemple un bouton qui demande au serveur d'appeler Humanoid:EquipTool ou Humanoid:UnequipTools.
Comment faire pour que les emplacements gardent leur position pour le glisser-déposer ?
Stocke une liste de longueur fixe avec une entrée par emplacement, et marque les emplacements vides avec une valeur comme un id vide plutôt que nil, parce que Roblox déconseille les valeurs nil dans les tables envoyées par un RemoteEvent. Ajoute ensuite un RemoteEvent MoveItem qui envoie deux numéros d'emplacement, et fais vérifier au serveur que les deux sont des nombres entiers entre 1 et la capacité avant de les échanger.
Quelle taille peut atteindre un inventaire sauvegardé ?
Une valeur de data store peut faire jusqu'à 4 194 304 caractères une fois sérialisée (selon la documentation au 30 septembre 2026). Une liste d'id et de quantités en utilise une toute petite partie. Ce qui fait grossir une sauvegarde, c'est du texte par objet, comme des noms personnalisés ou de longues descriptions sauvegardés pour chaque objet.
Comment acheter ou vendre des objets contre des pièces ?
Fais tout sur le serveur. Pour vendre, appelle InventoryService.remove et ne paie que s'il a renvoyé true. Pour acheter, vérifie le prix et spaceFor, retire les pièces, puis appelle add. Le guide de la boutique construit la partie achat.
Sources et lectures
- Roblox Creator Docs : Remote events and callbacks (en anglais). FireClient, OnServerEvent, les limites des arguments et la mise en file d'attente des messages non livrés
- Roblox Creator Docs : Securing the client-server boundary (en anglais). valider ce que les remotes reçoivent, les vérifications des ProximityPrompts et la manipulation des data stores
- Roblox Creator Docs : Data stores (en anglais). GetAsync, SetAsync et l'activation de l'accès depuis Studio
- Roblox Creator Docs : Best practices for data stores (en anglais). une clé par joueur, les modèles de clé et les sauvegardes régulières
- Roblox Creator Docs : Data store error codes and limits (en anglais). les limites de requêtes par serveur et la taille maximale d'une valeur
- Roblox Creator Docs : In-game tools (en anglais). les Handles, l'ancrage, le Backpack et StarterGear
- Roblox Creator Docs : Grid and table layouts (en anglais). la taille des cases, l'espacement et l'ordre de tri de UIGridLayout
Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.