Kurz gesagt
Halte die Items jedes Spielers in einer Tabelle auf dem Server, in einem ModuleScript in ServerScriptService, das als einziger Code Items hinzufügen, entfernen oder stapeln darf. Liste deine Items einmal in einem ModuleScript in ReplicatedStorage auf (ID, Name, maximale Stapelgröße). Nach jeder Änderung feuert der Server ein RemoteEvent an diesen Spieler mit einer Kopie seines Inventars, und ein LocalScript zeichnet es als Grid mit einem ScrollingFrame und einem UIGridLayout.
- Der Client fügt nie Items hinzu. Er kann nur fragen, zum Beispiel "rüste mein Schwert aus", und der Server prüft, ob der Spieler eins besitzt, bevor er handelt.
- Items kommen nur über Server-Code, den du kontrollierst: Pickups, Shop-Käufe, die der Server geprüft hat, Belohnungen.
- Speichere Item-IDs und Anzahlen, keine Tools, mit DataStoreService, wenn Spieler gehen, wenn der Server herunterfährt und alle paar Minuten. Speichere nie einen Spieler, dessen Daten nicht geladen werden konnten.
Auf dieser Seite
Wie das Inventar zusammenhängt
Das System besteht aus sechs kleinen Teilen mit je einer Aufgabe. Jede Regel über Items steht in einem einzigen Modul auf dem Server, also gibt es genau eine Stelle, an der du suchen musst, wenn etwas schiefgeht.
| Teil | Typ und Ort | Aufgabe |
|---|---|---|
ItemCatalog | ModuleScript in ReplicatedStorage | Was jedes Item ist: Name, Beschreibung, maximale Stapelgröße und ob es sich ausrüsten oder benutzen lässt. Der Server und jeder Client lesen es. |
InventoryService | ModuleScript in ServerScriptService | Hält die Slots jedes Spielers. Der einzige Code, der Items hinzufügt, entfernt und stapelt. |
InventoryData | Script in ServerScriptService | Lädt die Items eines Spielers, wenn er beitritt, und speichert sie. |
InventoryActions | Script in ServerScriptService | Prüft Anfragen zum Ausrüsten und Benutzen und führt sie aus. |
ItemPickup | Script in einem Part | Gibt jedem, der das Pickup einsammelt, ein Item. |
InventoryClient | LocalScript in StarterPlayerScripts | Zeichnet das Grid und schickt Anfragen. Es ändert selbst nichts. |
Die Daten fließen in eine Richtung. Der Server ändert ein Inventar, feuert dann InventoryUpdated mit dem ganzen Inventar an diesen Spieler, und der Client zeichnet es daraus neu. Klickt der Spieler auf einen Slot, feuert der Client EquipItem oder UseItem mit der ID des Items; der Server prüft die Anfrage, macht die Änderung, und die neue Kopie kommt auf demselben Weg an. Das ganze Inventar zu schicken ist einfacher, als Änderungen zu schicken, und bei ein paar Dutzend Slots bleibt die Nachricht klein.
Warum der Client nie Items hinzufügt
Es ist verlockend, ein Item in dem LocalScript hinzuzufügen, das es anzeigt: Der Spieler klickt, der Slot füllt sich. Das geht auf zwei Arten schief.
- Niemand sonst sieht es. Eine Änderung in einem LocalScript existiert nur auf dem Gerät dieses Spielers. Der Server erfährt nie davon, also wird sie nicht gespeichert und kein Server-Skript kann sie nutzen.
- Jeder kann es fälschen. Wenn du das mit einem RemoteEvent wie
AddItem(itemId, amount)löst, kann ein Exploiter dieses Event selbst feuern, mit beliebigen Argumenten, so oft er will. Der Security-Guide von Roblox sagt, dass der Server alles prüfen muss, was ein Client schickt, bevor er es benutzt.
Darum kann der Client in diesem Guide nur Anfragen zu Items stellen, die der Spieler schon besitzt: "rüste das aus" und "benutz das". Jede Anfrage enthält eine Item-ID und keine Anzahl und muss auf dem Server eine Prüfung bestehen: Ist es ein string, ist es ein echtes Item, besitzt der Spieler mindestens eins, und schickt der Spieler höchstens vier Anfragen pro Sekunde? Danach sucht der Server das Tool selbst aus dem Katalog heraus. Er nimmt vom Client nie ein Tool, einen Pfad oder eine Instanz an, wovor derselbe Guide warnt.
Items kommen nur über Server-Code hinein: ein Pickup, das der Server geprüft hat, ein Kauf, den der Server abgerechnet hat (der Shop-GUI-Guide baut einen), eine Quest-Belohnung oder ein Drop. Für das RemoteEvent-Muster allgemein, mit Prüfungen für andere Arten von Argumenten, lies den RemoteEvents-Guide.
Schritt 1: Den Explorer einrichten
Leg diese Objekte von Hand an. Die Skripte in den späteren Schritten finden sie über den Namen, also schreib jeden Namen genau so wie hier.
- Füge in ReplicatedStorage einen Folder namens
InventoryRemotesein. Füge darin drei RemoteEvents namensInventoryUpdated,EquipItemundUseItemein. - Füge in ServerStorage einen Folder namens
ItemToolsein. Füge darin ein Tool namensSwordein, und in das Tool einen Part namensHandle(1 mal 4 mal 1 Studs reicht). Achte darauf, dass beim Handle Anchored aus ist: Roblox warnt, dass Charaktere feststecken, wenn sie ein Tool mit verankerten Parts halten. Ein Tool, das du schon hast, geht auch, solange sein Name zum Katalog in Schritt 2 passt. - Füge die Skripte hinzu, wenn du beim jeweiligen Schritt bist. Der Baum zeigt, wohin jedes gehört.
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
Schritt 2: Deine Items in einem Katalog auflisten
Der Katalog beschreibt jedes Item, das es geben kann, genau einmal. Inventare speichern dann nur die ID eines Items und eine Anzahl. Das hält Speicherstände klein, und du kannst ein Item später umbenennen oder seine Beschreibung neu schreiben, ohne die gespeicherten Daten von irgendwem anzufassen.
Füge ein ModuleScript in ReplicatedStorage ein, nenn es ItemCatalog und ersetz seinen Inhalt durch das hier:
-- Jedes Item, das es im Spiel geben kann. Der Server und jeder Client lesen diese
-- Liste; nur der Server entscheidet, wem was gehört.
export type Item = {
id: string, -- muss zum Schlüssel unten passen
name: string,
description: string,
maxStack: number, -- wie viele von diesem Item höchstens in einen Slot passen
icon: string?, -- optionales Bild, geschrieben als "rbxassetid://" plus die ID deines Bildes
toolName: string?, -- ein Tool in ServerStorage.ItemTools: Das Item lässt sich ausrüsten
heal: number?, -- Leben, das beim Benutzen zurückkommt: Das Item ist ein Verbrauchsgegenstand
}
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 = {}
-- Gibt das Item mit dieser ID zurück, oder nil, wenn es kein solches Item gibt
function ItemCatalog.get(id: string): Item?
return items[id]
end
return ItemCatalog
Die optionalen Felder legen fest, was ein Item macht. toolName macht es ausrüstbar, heal macht es benutzbar, und ein Item ohne beides, wie Holz, bleibt im Inventar, bis anderer Server-Code (Crafting, Verkaufen) es entfernt.
Um ein Item hinzuzufügen, füge einen Eintrag hinzu, bei dem Schlüssel und id übereinstimmen. IDs unterscheiden Groß- und Kleinschreibung und werden gespeichert, also ändere eine ID nie, sobald Spieler das Item besitzen: Ändere stattdessen den name.
Schritt 3: Inventare auf dem Server halten
Dieses ModuleScript besitzt das Inventar jedes Spielers. Jedes Inventar ist eine Liste von Slots, jeder Slot eine Item-ID und eine Anzahl, dazu eine Kapazität von 20 Slots. Andere Server-Skripte rufen seine Funktionen auf, und sonst bearbeitet nichts die Tabelle.
Füge ein ModuleScript in ServerScriptService ein und nenn es InventoryService:
-- Der einzige Code, der Inventare ändert. Er liegt in ServerScriptService,
-- wo Clients ihn weder sehen noch ausführen können.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Der Strict-Modus kann einem require über WaitForChild nicht folgen, also geben wir
-- den Teil des Moduls an, den dieses Skript benutzt
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 -- Slots pro Spieler
local STARTER_ITEMS: { Slot } = { -- womit ein ganz neuer Spieler startet
{ id = "sword", count = 1 },
{ id = "apple", count = 3 },
}
local inventories: { [Player]: Inventory } = {}
local InventoryService = {}
-- Schickt dem Besitzer eine Kopie seines Inventars. Läuft nach jeder Änderung.
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
-- Stapelregeln: Erst nicht volle Stapel auffüllen, dann neue Stapel in
-- leeren Slots anfangen. Gibt zurück, wie viele dazukamen, das kann weniger als verlangt sein.
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
-- Wie viele von einem Item noch passen: Platz in seinen Stapeln plus leere Slots
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
-- Fügt bis zu `amount` Stück eines Items hinzu. Gibt zurück, wie viele dazukamen (0, wenn
-- das Item nicht existiert, das Inventar voll ist oder noch nicht geladen hat).
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
-- Entfernt genau `amount` Stück eines Items, zuerst aus den letzten Stapeln.
-- Hat der Spieler weniger, wird nichts entfernt und false zurückgegeben.
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
-- Rückwärts laufen, damit table.remove nie einen Slot überspringt
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
-- Wird aufgerufen, sobald die gespeicherten Daten eines Spielers geladen sind. `saved` ist, was der Data
-- Store zurückgegeben hat: nil bei einem neuen Spieler. Jeder Eintrag läuft wieder durch die
-- Stapelregeln, also können entfernte Items und alte Stapelgrößen nichts kaputt machen.
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
-- Eine einfache Kopie zum Speichern, oder nil, wenn die Daten dieses Spielers nie geladen haben
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
Die type-Zeilen und der ::-Cast nach require helfen nur dem Type-Checker von Luau, der nicht sehen kann, was ein über WaitForChild gefundenes Modul zurückgibt. Beim Spielen ändern sie nichts. Die anderen Skripte in diesem Guide machen es genauso.
So wirken die Stapelregeln mit dem Katalog oben, in dem Äpfel bis 10 stapeln:
- Fügst du einem Spieler mit einem Stapel von 7 Äpfeln 15 Äpfel hinzu, wird dieser Stapel auf 10 aufgefüllt und dann ein neuer Stapel mit 5 angefangen.
- Wenn die Slots ausgehen, fügt
addhinzu, was passt, und gibt diese Zahl zurück. Ruf vorherspaceForauf, wenn es alles oder nichts sein muss, wie beim Pickup in Schritt 5. removeist alles oder nichts. Verlangst du 3 Äpfel von einem Spieler, der 2 hat, wird keiner entfernt undfalsezurückgegeben, also prüf das Ergebnis, bevor du im Tausch etwas hergibst.- Slots haben keine Lücken: Wird einer leer, rücken die anderen auf. So bleibt die Liste einfach zu schicken und zu speichern. Die Fragen am Ende behandeln Slots, die ihre Position behalten.
| Funktion | Gibt zurück | Wofür |
|---|---|---|
add(player, itemId, amount) | Wie viele hinzugefügt wurden | Pickups, Belohnungen, Käufe |
remove(player, itemId, amount) | true, wenn alle entfernt wurden | Benutzen, Verkaufen, Crafting |
count(player, itemId) | Die Summe über alle Stapel | Prüfen, was ein Spieler hat |
spaceFor(player, itemId) | Wie viele noch passen würden | Prüfen vor einem Hinzufügen nach dem Prinzip alles oder nichts |
getEquipped, setEquipped | Die ID des ausgerüsteten Items, oder nil | Ausrüsten, in Schritt 6 |
load, serialize, unload | Eine Kopie zum Speichern (serialize) | Laden und Speichern, in Schritt 4 |
Schritt 4: Jedes Inventar laden und speichern
Inventare liegen im Speicher des Servers, also sind sie weg, wenn der Spieler geht. Dieses Skript lädt die Slots eines Spielers aus einem Data Store, wenn er beitritt, und schreibt sie zurück, wenn er geht, wenn der Server herunterfährt und alle drei Minuten, falls der Server abstürzt. Es speichert nur Item-IDs und Anzahlen: Data Stores können keine Instanzen wie Tools speichern.
Füge ein Script in ServerScriptService ein und nenn es 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
-- Gespeichert werden nur Spieler, deren gespeicherte Daten geladen haben. Auf ein fehlgeschlagenes Laden darf
-- nie ein Speichern folgen, sonst ersetzt das leere Inventar das echte.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0
local function keyFor(player: Player): string
return "User_" .. player.UserId
end
-- Eine fehlgeschlagene Anfrage soll niemanden seine Items kosten, also ein paar Mal neu versuchen.
-- GetDataStore steht auch im pcall, damit eine Studio-Sitzung, die keine
-- Data Stores erreicht, eine Warnung bekommt, statt dieses Skript anzuhalten.
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 -- sie sind gegangen, während wir geladen haben
end
if ok then
InventoryService.load(player, saved) -- saved ist nil bei einem neuen Spieler
canSave[player] = true
elseif RunService:IsStudio() then
-- Heißt meistens, dass der Studio-Zugriff auf API-Dienste aus ist. Mit den
-- Start-Items spielen, damit du testen kannst, sie aber nie speichern.
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 -- ihre Daten haben nie geladen, also gibt es nichts, was sicher geschrieben werden kann
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)
-- Wenn der Server herunterfährt, alle noch Anwesenden speichern, dann auf jedes
-- laufende Speichern warten, auch auf die, die PlayerRemoving gestartet hat
game:BindToClose(function()
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
while activeSaves > 0 do
task.wait()
end
end)
-- Alle paar Minuten alle speichern, damit ein Server-Absturz Minuten kostet, keine ganze Sitzung
while true do
task.wait(AUTOSAVE_SECONDS)
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
end
Was das Skript macht, und warum:
- Mit Standardwerten laden. Ein neuer Spieler hat keinen gespeicherten Wert, also gibt
GetAsyncnil zurück und er bekommt die Start-Items. Gespeicherte Slots laufen wieder durch die Stapelregeln, also kann ein Item, das du aus dem Katalog entfernt hast, oder eine kleinere maximale Stapelgröße das Laden nicht kaputt machen. Alles, was nicht mehr passt oder dessen ID nicht mehr im Katalog steht, fällt weg, und das nächste Speichern macht das dauerhaft, also behalte jede ID, die Spieler besitzen könnten, im Katalog. - Nach einem fehlgeschlagenen Laden nie speichern. Geschrieben werden nur Spieler in
canSave. In einem Live-Server wird ein Spieler, dessen Daten nach drei Versuchen immer noch nicht laden, gebeten, neu beizutreten. In Studio bekommt er stattdessen nicht gespeicherte Start-Items, wegen der Wiederholungen ein paar Sekunden später. Das siehst du, bis das Spiel mit eingeschaltetem API-Zugriff veröffentlicht ist. - Beim Verlassen und beim Herunterfahren speichern.
BindToClosespeichert jeden, der noch im Server ist, und wartet auf Speichervorgänge, die schon laufen. Roblox gibt gebundenen Funktionen bis zu 30 Sekunden. - Innerhalb der Limits bleiben. Ein Schreibvorgang pro Spieler alle drei Minuten, plus einer beim Verlassen, liegt weit unter dem Standardbudget pro Server von 60 Schreibvorgängen pro Minute plus 40 für jeden Spieler (Stand der Dokumentation: 30. September 2026). Das Schlüsselmuster
User_folgt den Best Practices von Roblox, und die Benutzer-ID anSetAsynczu übergeben verknüpft die Daten mit diesem Spieler, was Roblox für Anfragen zum Löschen von Daten dringend empfiehlt.
Für ein kleines Spiel ist das eine solide Grundlage. Session Locking, das verhindert, dass ein Spieler, der schnell den Server wechselt, Daten lädt, bevor der alte Server sie gespeichert hat, und wann du UpdateAsync statt SetAsync nimmst, behandelt das DataStore-Tutorial.
Schritt 5: Items aus der Welt vergeben
Ein Pickup ist der einfachste Weg, wie Items in ein Inventar kommen: ein Part mit einem ProximityPrompt, das ein Item hinzufügt, wenn ein Spieler es benutzt. Das Skript hört auf dem Server auf sein Event Triggered, also wird das Item dort hinzugefügt, wo der Client nicht eingreifen kann.
- Füge einen Part in Workspace ein, nenn ihn
Appleund färb ihn rot. Schalte Anchored ein und CanCollide aus, damit niemand dagegenstößt, während er unsichtbar ist. Der Prompt zeigt den Namen des Parts. - Scroll bei ausgewähltem Part im Properties-Fenster zum Bereich Attributes und klick auf +. Füge
ItemIdmit dem Typ string hinzu, klick auf Save und setz den Wert aufapple. FügeAmountgenauso als number mit dem Wert1hinzu. - Füge ein Script in den Part ein, nenn es
ItemPickupund füge diesen Code ein:
-- Leg dieses Script in einen Part und gib dem Part zwei Attribute:
-- ItemId (ein string, zum Beispiel apple) und Amount (eine number, zum Beispiel 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 -- jemand anderes hat es gerade eben eingesammelt
end
-- Die Entfernung auf dem Server prüfen, statt der Anfrage zu vertrauen
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 -- nicht genug Platz: das Pickup liegen lassen
end
InventoryService.add(player, itemId, amount)
prompt.Enabled = false
part.Transparency = 1
task.wait(RESPAWN_SECONDS)
part.Transparency = visibleTransparency
prompt.Enabled = true
end)
Kopier den Part, um mehr Pickups zu platzieren. Ändere die Attribute, um Holz, ein weiteres Schwert oder einen Stapel Äpfel zu verteilen.
Roblox prüft bei Triggered die Entfernung, aber sein Security-Guide sagt trotzdem, dass du Prompts auf dem Server prüfen sollst: Ein Exploiter kann die Events eines Prompts feuern, auch wenn Enabled false ist, und kann einen nicht verankerten Part zu seinem Charakter ziehen. Darum prüft das Skript Enabled und die Entfernung selbst, und darum ist der Part verankert.
Jedes andere Server-Skript vergibt Items auf dieselbe Art. Nach einem Kauf, einer Quest oder einem Kill: require InventoryService wie die Skripte oben und ruf InventoryService.add(player, "wood", 5) auf. Prüf vorher spaceFor, wenn das Item nicht verloren gehen darf. Ein NPC kann eine weitere Quelle sein: Im NPC-Dialog-Guide führt eine Antwort eine Aktion auf dem Server aus, und diese Aktion kann InventoryService.add auf dieselbe Art aufrufen.
Schritt 6: Tools ausrüsten und Items benutzen
Zwei RemoteEvents tragen die einzigen Anfragen, die ein Client stellen kann. EquipItem legt eine Kopie des Tools des Items aus ServerStorage in den Backpack des Spielers (die Hotbar unten am Bildschirm) und in seine Hand, und eine erneute Anfrage nimmt es wieder weg. UseItem entfernt eins von einem benutzbaren Item und wendet seine Wirkung an, hier Heilen.
Füge ein Script in ServerScriptService ein und nenn es 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 } = {}
-- Jede Anfrage beginnt hier. Ein Client kann jederzeit alles schicken, also prüfen:
-- den Typ, dass das Item existiert, dass der Spieler eins besitzt, und die Rate.
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
-- Zerstört das Tool dieses Items überall, wo eine Kopie ist: Hotbar, Hand oder 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) -- immer nur ein ausgerüstetes Tool
local tool = template:Clone()
tool.CanBeDropped = false -- eine fallen gelassene Kopie könnte jemand anderes aufheben
tool:SetAttribute("InventoryItem", item.id)
tool.Parent = backpack
-- Eine zweite Kopie in StarterGear wird nach einem Respawn zurück in den Backpack kopiert
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) -- direkt in die Hand geben
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) -- ein erneuter Klick auf das ausgerüstete Item nimmt es wieder weg
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 -- tot oder schon volles Leben: das Item nicht verschwenden
end
-- Zuerst das Item nehmen und nur heilen, wenn das geklappt hat
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)
| Anfrage | Der Client schickt | Der Server prüft, bevor er handelt |
|---|---|---|
EquipItem | Eine Item-ID | Es ist ein string, das Item existiert, der Spieler besitzt eins, Anfragen kommen nicht schneller als vier pro Sekunde, das Item hat einen toolName, und ein Tool mit diesem Namen liegt in ServerStorage.ItemTools |
UseItem | Eine Item-ID | Dieselben Prüfungen von Typ, Besitz und Rate, das Item hat einen heal-Wert, der Charakter lebt und ist verletzt, und ein Item wurde entfernt, bevor es Leben gibt |
Drei Details verhindern, dass ein Tool verdoppelt wird oder verloren geht. Bei der Kopie ist CanBeDropped auf false gesetzt, weil ein fallen gelassenes Tool in Workspace landet, wo ein anderer Spieler es nehmen könnte, während das Original im Inventar bleibt. Jede Kopie trägt ein Attribut InventoryItem, damit das Ablegen jede Kopie finden und zerstören kann, egal wo sie ist. Und wenn der Spieler einen Container StarterGear hat, kommt eine zweite Kopie dort hinein. Roblox kopiert StarterGear jedes Mal in den Backpack, wenn der Charakter spawnt, also kommt ein ausgerüstetes Schwert nach einem Respawn zurück.
Es ist immer nur ein Tool ausgerüstet, und was ausgerüstet ist, wird nicht gespeichert, also startet ein Spieler nach dem Wiederbeitreten mit leerer Hotbar. Wenn du später Verkaufen oder Fallenlassen hinzufügst, leg ein Item ab, bevor seine letzte Kopie das Inventar verlässt.
Aus dem Platzhalter-Sword kann eins werden, das wirklich kämpft: Bau das Tool aus dem Schwert-Guide, behalt den Namen Sword und leg es statt des Platzhalters in ItemTools. Das Server-Skript aus diesem Guide prüft dann jeden Schlag, egal wie der Spieler an das Schwert gekommen ist.
Schritt 7: Das Inventar-Grid zeichnen
Das LocalScript baut das ganze Fenster im Code, also musst du keine UI von Hand anordnen. Ein ScrollingFrame hält die Slots, ein UIGridLayout darin ordnet sie in Reihen an, und AutomaticCanvasSize vergrößert den Scrollbereich, wenn Reihen dazukommen.
Öffne im Explorer StarterPlayer, füge ein LocalScript in StarterPlayerScripts ein und nenn es 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. Das Fenster einmal bauen. ResetOnSpawn = false behält es über Respawns hinweg.
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 vergrößert es passend zu den Zellen
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. Eine Zelle pro Slot. Das zeichnet nur, was der Server geschickt hat; es ändert
-- das Inventar nie selbst.
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 -- ein leerer Slot
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()
-- Fragen, nie bestimmen: Der Server prüft die Anfrage und schickt das Ergebnis zurück
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
-- Der Server feuert das nach dem Laden und nach jeder Änderung
inventoryUpdated.OnClientEvent:Connect(render)
-- 3. Mit dem Button oder der Taste B öffnen und schließen
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)
Ein LocalScript in StarterPlayerScripts läuft einmal pro Sitzung, und ResetOnSpawn = false behält die ScreenGui, wenn der Charakter respawnt, also zeigt das Grid weiter die letzte Kopie, die der Server geschickt hat.
Der Client zeichnet eine Zelle für jeden Slot, leere eingeschlossen, also sieht ein Inventar mit 20 Slots immer nach 20 Slots aus. Jedes Update zerstört die alten Zellen und baut neue, das ist einfach und reicht für ein paar Dutzend Slots. Feuert der Server InventoryUpdated, bevor dieses Skript sich damit verbunden hat, stellt Roblox die Nachricht in eine Warteschlange und liefert sie, sobald der Handler verbunden ist, also geht das erste Inventar nicht verloren.
Willst du das Fenster lieber in Studio gestalten? Bau eine ScreenGui mit einem Vorlage-Slot und Clone ihn in makeCell. Für Icons setz das icon eines Items im Katalog auf ein Bild, das du hochgeladen hast, und seine Zelle zeigt das Bild statt des Namens.
Das Inventar testen
- Drück auf Play. Öffne das Inventar mit dem Button links oder B: Ein neuer Spieler hat ein Sword und 3 Apples, und der Zähler zeigt 2 / 20 slots. Solange Studio keine Data Stores erreicht, erscheinen die Items erst nach ein paar Sekunden, nach Lade-Warnungen im Output, und werden nicht gespeichert.
- Klick auf das Sword. Es erscheint in deiner Hand und in der Hotbar, und sein Slot bekommt eine lila Umrandung. Klick noch einmal, um es wegzustecken.
- Geh zum Part Apple und benutz seinen Prompt. Der Apfelstapel steigt auf 4, und der Part verschwindet für 15 Sekunden.
- Um das Heilen zu testen, senk zuerst dein Leben. Stell den Schalter Client/Server auf Server, wähl im Explorer den
Humanoiddeines Charakters aus, setz Health auf 50, schalte zurück auf Client und klick auf einen Apple. - Mit eingeschaltetem Studio-Zugriff auf API-Dienste: Stopp und spiel noch einmal. Der Apfel, den du eingesammelt hast, ist noch da. Wenn ein Laden oder Speichern fehlgeschlagen ist, steht das im Output.
Um es mit mehr als einem Spieler zu sehen, wähl bei den Testoptionen Server & Clients mit 2 Clients. Jeder Spieler sieht nur sein eigenes Inventar, während beide ein Schwert in der Hand des anderen sehen können.
Häufige Fehler und Lösungen
Die meisten Probleme zeigen sich im Output-Fenster als Warnung oder rote Fehlerzeile. Lies die erste: Spätere Fehler sind oft eine Folge davon.
Infinite yield possible bei einem Aufruf von WaitForChild
Ein Skript wartet auf ein Objekt, das es unter genau diesem Namen nicht gibt. Vergleich deinen Explorer mit dem Baum in Schritt 1: InventoryRemotes mit seinen drei RemoteEvents in ReplicatedStorage, ItemTools in ServerStorage und die beiden Module. Namen unterscheiden Groß- und Kleinschreibung. Der Guide zu Skript-Fehlern erklärt diese Warnung genauer.
Das Grid öffnet sich, bleibt aber leer
Der Client zeichnet nur, was der Server schickt. Schau im Output nach Warnungen Inventory load failed und prüf, dass InventoryData ein Script ist, kein LocalScript, in ServerScriptService, mit dem ModuleScript InventoryService daneben. Zeigt der Output einen Fehler Remote event invocation, hört auf dem Client nichts auf InventoryUpdated: Such nach einem früheren Fehler von InventoryClient.
Die Items werden jedes Mal zurückgesetzt, wenn ich in Studio spiele
Wenn der Output Inventory not loaded: playing with starter items that will not be saved meldet, ist das Spiel nicht veröffentlicht oder der Studio-Zugriff auf API-Dienste ist aus. Schalte ihn wie in Schritt 4 beschrieben ein, in einer Testkopie deines Spiels.
Ein Klick auf das Schwert macht nichts
Such im Output nach Cannot equip sword: Das Tool in ServerStorage.ItemTools muss genau so heißen wie toolName im Katalog. Ein Tool braucht außerdem einen Part namens Handle, damit man es halten kann, außer du setzt sein RequiresHandle auf false.
Der Pickup-Prompt erscheint, aber nichts wird hinzugefügt
Das Attribut ItemId muss genau zu einer Katalog-ID passen, auch in der Groß- und Kleinschreibung: apple, nicht Apple. Nichts wird hinzugefügt, solange das Inventar des Spielers noch lädt oder wenn nicht genug Platz für die ganze Menge ist.
Das Speichern schlägt fehl, nachdem ich geändert habe, was gespeichert wird
Data Stores nehmen einfache Daten an: strings, numbers, booleans und Tabellen daraus. Ein Tool, einen Part oder eine andere Instanz zu speichern schlägt fehl, oder der Wert wird als nil gespeichert. Speichere die Item-ID und die Anzahl und bau alles andere aus dem Katalog neu auf, wie serialize es macht.
Mit RoCode bauen
Wenn du das System lieber beschreibst, statt es von Hand zu verdrahten, kann RoCode es in dem Spiel bauen, das du offen hast. RoCode ist ein KI-Agent für Roblox Studio: Du beschreibst die Funktion in einem Webchat, und sein Studio-Plugin erstellt die Skripte und Objekte in deinem Explorer, statt dir Code zum Einfügen zu geben. Prompts kannst du auf Deutsch schreiben.
Füge ein Inventar mit 20 Slots hinzu, das Items stapelt, ein Grid-UI, das sich mit B öffnet, ein Schwert aus ServerStorage, das Spieler ausrüsten können, Äpfel, die heilen, und Speichern mit DataStoreService.
- Kann dein Spiel durchsuchen, wenn ein Schritt es braucht, mit Search Game und Search Scripts, und so auf Items, Remotes oder Speichercode aufbauen, die du schon hast, statt ein zweites System hinzuzufügen
- Erstellt die Ordner und RemoteEvents mit Create Instance, und die ModuleScripts, Scripts und das LocalScript mit Create Script
- Kann das Fenster mit Build UI vorbereiten, das ein Inventar-Layout mit Platzhalter-Slots hat; der Code, der die Slots vom Server aus füllt, wird als eigene Skripte geschrieben
- Prüft jedes Skript in Studio mit Check Script auf Kompilierfehler, was Kompilierfehler und ein paar riskante Muster findet, aber deinen Code weder auf Typen prüft noch lintet oder ausführt
Jede Änderungsrunde ist ein Undo-Punkt in Studio. RoCode kann den Studio-Zugriff auf API-Dienste nicht einschalten, das machst du selbst. Mit Plugin 3.9 oder neuer kann es einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.15 oder neuer kann sein Test-Charakter Tasten drücken und Items ausrüsten, aber es prüft nur, was es selbst zum Testen ausgewählt hat, also teste das Speichern selbst. Ein Inventar baut auf anderen Systemen wie Speichern und Tools auf, und ein KI-Spielemacher, der in deinem eigenen Studio-Place baut, fügt sie Prompt für Prompt hinzu. Wie sich RoCode mit Studio verbindet.
Häufige Fragen
Soll ich statt eines eigenen Inventars den Backpack von Roblox benutzen?
Der Backpack ist das eingebaute Inventar von Roblox: Jedes Tool darin erscheint als Button in der Hotbar. Wenn jedes Item in deinem Spiel ein Tool ist und du keine Stapel, Anzahlen oder Slot-Grenze brauchst, kann er reichen, auch wenn du trotzdem speichern musst, welche Tools jeder Spieler besitzt. Ein eigenes Inventar ist für Items, die keine Tools sind, wie Materialien und Verbrauchsgegenstände. Dieser Guide nutzt beides: Das Inventar speichert alles, und der Backpack hält das Tool, das gerade ausgerüstet ist.
Kann ich die Standard-Hotbar ausblenden?
Ja. Ruf in einem LocalScript StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) auf. Bei ausgeblendeter Hotbar brauchen Spieler einen anderen Weg, ein ausgerüstetes Tool zu halten und wegzustecken, zum Beispiel einen Button, der den Server bittet, Humanoid:EquipTool oder Humanoid:UnequipTools aufzurufen.
Wie behalten Slots ihre Position für Drag and Drop?
Speichere eine Liste fester Länge mit einem Eintrag pro Slot und markiere leere Slots mit einem Wert wie einer leeren ID statt nil, weil Roblox von nil-Werten in Tabellen abrät, die über ein RemoteEvent geschickt werden. Füge dann ein RemoteEvent MoveItem hinzu, das zwei Slot-Nummern schickt, und lass den Server prüfen, dass beide ganze Zahlen zwischen 1 und der Kapazität sind, bevor er sie tauscht.
Wie groß kann ein gespeichertes Inventar werden?
Ein Wert in einem Data Store kann nach dem Serialisieren bis zu 4.194.304 Zeichen lang sein (Stand der Dokumentation: 30. September 2026). Eine Liste aus IDs und Anzahlen braucht davon nur einen winzigen Teil. Text pro Item, wie eigene Namen oder lange Beschreibungen, die für jedes Item gespeichert werden, lässt einen Speicherstand wachsen.
Wie kaufe oder verkaufe ich Items für Coins?
Mach alles auf dem Server. Zum Verkaufen ruf InventoryService.remove auf und zahl nur aus, wenn es true zurückgegeben hat. Zum Kaufen prüf den Preis und spaceFor, zieh die Coins ab und ruf dann add auf. Der Shop-GUI-Guide baut die Kaufseite.
Quellen und weiterführende Links
- Roblox Creator Docs: Remote events and callbacks (auf Englisch). FireClient, OnServerEvent, Grenzen für Argumente und wie nicht zugestellte Nachrichten in eine Warteschlange kommen
- Roblox Creator Docs: Securing the client-server boundary (auf Englisch). Remote-Eingaben prüfen, Prüfungen für ProximityPrompts und Manipulation von Data Stores
- Roblox Creator Docs: Data stores (auf Englisch). GetAsync, SetAsync und Studio-Zugriff einschalten
- Roblox Creator Docs: Best practices for data stores (auf Englisch). ein Schlüssel pro Spieler, Schlüsselmuster und regelmäßiges Speichern
- Roblox Creator Docs: Data store error codes and limits (auf Englisch). Anfragelimits pro Server und die Größengrenze für einen Wert
- Roblox Creator Docs: In-game tools (auf Englisch). Handles, Verankern, der Backpack und StarterGear
- Roblox Creator Docs: Grid and table layouts (auf Englisch). Zellgröße, Abstand und Sortierreihenfolge von UIGridLayout
So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 14. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.