Roblox-Inventararchitektur: Raster-Slots, Gewichtsbudgets & Server-Authorität

Das Inventarmanagement bildet das Fundament für RPGs und Survival-Spiele auf Roblox. Schlechte Architektur führt zu Duplikations-Exploits, desynchronisierten Leisten und frustrierender mobiler Bedienung.

Mit zustandsbasierten Server-Validierungen, zusammengesetzten Datenstrukturen und sitzungsgesperrten DataStores können Entwickler ein skalierbares, manipulationssicheres System für Tausende von Spielern erschaffen.

1. Inventarmodelle: Raster vs. Feste Slots vs. Gewichtsbudgets

Auswahl des richtigen Modells für deinen Game-Loop:

• Feste Slot-Architektur: Klassisches Hotbar-Modell mit festem Array (z. B. 20 Slots). O(1)-Zugriffe, einfache Serialisierung.
• Räumliches Tetris-Raster: Gegenstände belegen mehrere Zellen (z. B. 2x5). Erfordert 2D-Bitmaskenprüfung.
• Gewichts- & Überlastungsgrenzen: Gegenstände besitzen Masse. Überschreitungen führen zu Bewegungsverlangsamung.

2. Server-Authorität & Optimistische Client-UI

Reaktionsschnelles Drag-and-Drop ohne Sicherheitslücken:

• Optimistische UI-Vorhersage: Das Icon bewegt sich lokal sofort, ohne auf die Serverantwort zu warten.
• Server-Validierung: Überprüfung von Besitz, Grenzen, Gewicht und Cooldown vor Bestätigung.
• Reconciliation & Rollback: Bei Ablehnung erfolgt eine visuelle Rückkehr auf die ursprüngliche Position.

3. Datenstrukturen & Stapel-Serialisierung

Effiziente Trennung statischer und dynamischer Attribute in Luau:

• Basis-Vorlage vs. Instanz: Statische Daten liegen in ReplicatedStorage, dynamische Werte (UUID, Haltbarkeit) beim Spieler.
• Stapel-Zusammenführung: Berechnung des freien Platzes und atomare Mengenübertragung.
• Speicher-Optimierung: Leere Slots werden vor dem Speichern gefiltert, um die 4MB-Grenze einzuhalten.

-- Server-autoritativer Inventar-Manager
local InventoryManager = {}
InventoryManager.__index = InventoryManager
local ItemDatabase = require(game.ReplicatedStorage.ItemDatabase)

function InventoryManager.new(player, maxSlots, maxWeight)
    local self = setmetatable({}, InventoryManager)
    self.Player = player
    self.MaxSlots = maxSlots or 30
    self.MaxWeight = maxWeight or 100
    self.Slots = table.create(self.MaxSlots, false)
    self.CurrentWeight = 0
    self.IsLocked = false
    return self
end

function InventoryManager:AddItem(itemId, amount)
    if self.IsLocked then return false, "INVENTORY_LOCKED" end
    local itemData = ItemDatabase[itemId]
    if not itemData then return false, "INVALID_ITEM" end
    local addedWeight = itemData.Weight * amount
    if self.CurrentWeight + addedWeight > self.MaxWeight then
        return false, "OVER_ENCUMBERED"
    end
    for slotIndex = 1, self.MaxSlots do
        local slot = self.Slots[slotIndex]
        if slot and slot.Id == itemId and slot.Count < itemData.MaxStack then
            local space = itemData.MaxStack - slot.Count
            local toAdd = math.min(space, amount)
            slot.Count = slot.Count + toAdd
            amount = amount - toAdd
            self.CurrentWeight = self.CurrentWeight + (itemData.Weight * toAdd)
            if amount <= 0 then return true end
        end
    end
    for slotIndex = 1, self.MaxSlots do
        if not self.Slots[slotIndex] then
            self.Slots[slotIndex] = {
                UUID = game:GetService("HttpService"):GenerateGUID(false),
                Id = itemId,
                Count = amount,
                Durability = itemData.MaxDurability
            }
            self.CurrentWeight = self.CurrentWeight + (itemData.Weight * amount)
            return true
        end
    end
    return false, "INVENTORY_FULL"
end

return InventoryManager

4. Duplikationsschutz & Transaktionssperren

Absicherung gegen Server-Abstürze und Handels-Exploits:

• MemoryStore Session Locking: Temporäre verteilte Sperre bei Item-Transfers gegen Double-Spend-Angriffe.
• Atomare Handelsabschlüsse: Synchroner Tausch im selben Server-Frame oder vollständiger Rollback bei Verbindungsabbruch.
• Anfrage-Ratenbegrenzung: Cooldowns von mindestens 100ms verhindern Packet-Flooding.

5. Mobile Touch-Bedienung & Barrierefreiheit

Optimale Steuerung auf Smartphones und Tablets:

• Mindestens 44px Touch-Ziele: Dynamische UIScale-Anpassung für präzise Fingerbedienung.
• Kontextmenüs per Gedrückthalten: Ersatz für Rechtsklick auf Touchscreens durch Radialmenüs.
• Haptisches Feedback: Nutzung von HapticService für spürbare Bestätigungen.

Frequently Asked Questions