Tutoriaali · Pelijärjestelmät

Miten tehdä inventaario Roblox Studiossa

Inventaario vaikuttaa käyttöliittymätehtävältä, mutta sen, voiko sen murtaa ja katoaako siitä esineitä, ratkaisee paikka, jossa esineet säilytetään. Tässä oppaassa jokaisen pelaajan esineet ovat taulukossa palvelimella, jokainen pelaaja saa kopion ja piirtää sen ruudukoksi, varustaa Toolin ja käyttää kulutustavaroita palvelimen tarkistamien pyyntöjen kautta, ja kaikki tallennetaan data storeen.

Päivitetty 20. marraskuuta 202613 min lukuaikaKirjoittaja:

Lyhyesti

Säilytä jokaisen pelaajan esineet taulukossa palvelimella, ModuleScriptissä ServerScriptServicessä, ja vain tämä koodi saa lisätä, poistaa ja pinota niitä. Kuvaile esineet kerran ModuleScriptissä ReplicatedStoragessa (id, nimi, pinon enimmäiskoko). Jokaisen muutoksen jälkeen palvelin lähettää tälle pelaajalle RemoteEventin, jossa on kopio hänen inventaariostaan, ja LocalScript piirtää sen ruudukoksi ScrollingFramen ja UIGridLayoutin avulla.

  • Asiakas ei koskaan lisää esineitä. Se voi vain pyytää, esimerkiksi "varusta miekkani", ja palvelin tarkistaa, että pelaajalla on se, ennen kuin tekee mitään.
  • Esineitä ilmestyy vain hallitsemasi palvelinkoodin kautta: poiminnat, palvelimella tarkistetut kauppaostokset, palkinnot.
  • Tallenna esineiden id:t ja määrät, älä Tooleja, DataStoreServicellä, kun pelaaja poistuu, kun palvelin sammuu ja muutaman minuutin välein. Älä koskaan tallenna pelaajaa, jonka tiedot eivät latautuneet.
Tällä sivulla
  1. Miten se toimii
  2. Miksi esineet palvelimella
  3. 1. Explorerin valmistelu
  4. 2. Esineluettelo
  5. 3. Inventaario palvelimella
  6. 4. Lataus ja tallennus
  7. 5. Esineiden poiminta
  8. 6. Varustaminen ja käyttö
  9. 7. UI-ruudukko
  10. Testaus
  11. Common errors
  12. RoCodella
  13. Usein kysytyt kysymykset
  14. Lähteet ja lisälukemista

Miten inventaario toimii

HavainnollistusPaina B, vie osoitin esineen päälle lukeaksesi kuvauksen ja klikkaa Swordia ottaaksesi sen käteen.

Järjestelmä koostuu kuudesta pienestä osasta, joilla jokaisella on yksi tehtävä. Kaikki esineitä koskevat säännöt ovat yhdessä palvelinmoduulissa, joten kun jokin hajoaa, etsittävää on täsmälleen yhdessä paikassa.

Järjestelmän osat ja missä ne toimivat
OsaTyyppi ja paikkaTehtävä
ItemCatalogModuleScript ReplicatedStoragessaMitä kukin esine on: nimi, kuvaus, pinon enimmäiskoko ja voiko sen varustaa tai käyttää. Sitä lukevat palvelin ja kaikki asiakkaat.
InventoryServiceModuleScript ServerScriptServicessäSäilyttää kaikkien pelaajien slotit. Ainoa koodi, joka lisää, poistaa ja pinoaa esineitä.
InventoryDataScript ServerScriptServicessäLataa pelaajan esineet liittymisen yhteydessä ja tallentaa ne.
InventoryActionsScript ServerScriptServicessäTarkistaa ja suorittaa varustus- ja käyttöpyynnöt.
ItemPickupScript Partin sisälläAntaa esineen sille, joka poimi sen.
InventoryClientLocalScript StarterPlayerScriptsissäPiirtää ruudukon ja lähettää pyynnöt. Ei itse muuta mitään.

Tieto kulkee yhteen suuntaan. Palvelin muuttaa inventaariota ja lähettää sitten tälle pelaajalle InventoryUpdated-viestin koko inventaariolla, ja asiakas piirtää sen uudelleen. Kun pelaaja klikkaa slottia, asiakas lähettää EquipItem- tai UseItem-pyynnön esineen id:llä; palvelin tarkistaa pyynnön, tekee muutoksen, ja uusi kopio saapuu samaa reittiä. Koko inventaarion lähettäminen on yksinkertaisempaa kuin muutosten lähettäminen, ja muutamalle kymmenelle slotille viesti pysyy pienenä.

Miksi asiakas ei koskaan lisää esineitä

Tekisi mieli lisätä esine suoraan LocalScriptissä, joka näyttää sen: pelaaja klikkasi, slotti täyttyi. Tämä hajoaa kahdella tavalla.

  • Kukaan muu ei näe sitä. LocalScriptin muutos on olemassa vain tämän pelaajan laitteella. Palvelin ei saa tietää siitä, joten sitä ei tallenneta, eikä yksikään palvelinskripti voi käyttää sitä.
  • Kuka tahansa voi väärentää sen. Jos korjaat tämän remotella, kuten AddItem(itemId, amount), huijari voi kutsua tätä tapahtumaa itse, millä tahansa argumenteilla ja niin monta kertaa kuin haluaa. Robloxin turvallisuusoppaassa sanotaan, että palvelimen on tarkistettava kaikki, mitä asiakas lähettää, ennen kuin se käyttää sitä.

Siksi tässä oppaassa asiakas voi vain pyytää tekemään jotain esineillä, jotka pelaajalla jo on: "varusta tämä" ja "käytä tätä". Jokaisessa pyynnössä on yksi esineen id eikä määriä, ja palvelimella se käy läpi yhden tarkistuksen: se on merkkijono, esine on olemassa, pelaajalla on vähintään yksi, eikä pelaaja lähetä yli neljää pyyntöä sekunnissa. Sitten palvelin etsii Toolin itse luettelosta. Se ei koskaan ota asiakkaalta vastaan Toolia, polkua tai instanssia, mistä sama opas varoittaa.

Esineet päätyvät inventaarioon vain palvelinkoodin kautta: poiminta, jonka palvelin tarkisti, ostos, josta palvelin veloitti rahat (sen rakentaa kauppaopas), tehtäväpalkinto tai pudotus. Remoteista yleisesti, myös muunlaisten argumenttien tarkistamisesta, kerrotaan RemoteEvent-oppaassa.

Vaihe 1: valmistele Explorer

Luo nämä objektit käsin. Seuraavien vaiheiden skriptit etsivät niitä nimellä, joten kirjoita jokainen nimi täsmälleen kuten tässä.

  1. Lisää ReplicatedStorageen Folder nimeltä InventoryRemotes. Lisää sen sisään kolme RemoteEventiä nimeltä InventoryUpdated, EquipItem ja UseItem.
  2. Lisää ServerStorageen Folder nimeltä ItemTools. Lisää sen sisään Tool nimeltä Sword ja Toolin sisään Part nimeltä Handle (1 x 4 x 1 studia käy hyvin). Tarkista, että Handlen Anchored-rasti on poistettu: Roblox varoittaa, että hahmo jää jumiin paikalleen, jos se pitää työkalua, jossa on ankkuroituja partteja. Myös jo olemassa oleva Tool käy, jos sen nimi vastaa vaiheen 2 luetteloa.
  3. Lisää skriptit sitä mukaa kuin etenet vaiheissa. Puu näyttää, mihin kukin niistä menee.
Explorer, kun opas on käyty läpi
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

Vaihe 2: kuvaile esineet luettelossa

Luettelo kuvailee kerran jokaisen esineen, joka voi olla olemassa. Inventaariot säilyttävät sen jälkeen vain esineen id:n ja määrän. Näin tallennukset pysyvät pieninä, ja myöhemmin voit nimetä esineen uudelleen tai kirjoittaa sen kuvauksen uusiksi koskematta kenenkään tallennettuihin tietoihin.

Lisää ModuleScript ReplicatedStorageen, nimeä se ItemCatalog ja korvaa sen sisältö tällä:

ModuleScript kohteessa ReplicatedStorage nimeltä ItemCatalog
-- Kaikki esineet, joita pelissä voi olla. Tätä luetteloa lukevat palvelin ja kaikki
-- asiakkaat; vain palvelin päättää, kenellä on mitäkin.
export type Item = {
	id: string, -- täytyy vastata alla olevaa avainta
	name: string,
	description: string,
	maxStack: number, -- kuinka monta tätä esinettä mahtuu yhteen slottiin
	icon: string?, -- valinnainen kuva: "rbxassetid://" plus kuvasi ID
	toolName: string?, -- Tool kansiossa ServerStorage.ItemTools: esineen voi varustaa
	heal: number?, -- kuinka paljon terveyttä palauttaa: esine on kulutustavara
}

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 = {}

-- Palauttaa esineen tällä id:llä tai nil, jos sellaista esinettä ei ole
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Valinnaiset kentät ratkaisevat, mitä esine tekee. toolName tekee siitä varustettavan, heal tekee siitä käytettävän, ja esine ilman kumpaakaan kenttää, kuten puu, pysyy inventaariossa, kunnes muu palvelinkoodi poistaa sen (askartelu, myynti).

Lisätäksesi esineen lisää merkintä, jonka avain ja id ovat samat. Id:t erottelevat isot ja pienet kirjaimet ja juuri ne tallennetaan, joten älä koskaan muuta id:tä, kun esine on jo pelaajilla: muuta sen name-kenttää.

Vaihe 3: säilytä inventaariot palvelimella

Tämä ModuleScript omistaa jokaisen pelaajan inventaarion. Jokainen inventaario on luettelo sloteista, joissa kussakin on esineen id ja määrä, sekä 20 slotin kapasiteetti. Muut palvelinskriptit kutsuvat sen funktioita, eikä kukaan muu muokkaa taulukkoa.

Lisää ModuleScript ServerScriptServiceen ja nimeä se InventoryService:

ModuleScript kohteessa ServerScriptService nimeltä InventoryService
-- Ainoa koodi, joka muuttaa inventaarioita. Se on ServerScriptServicessä,
-- jossa asiakkaat eivät voi nähdä eivätkä ajaa sitä.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict-tila ei näe, mitä require palauttaa WaitForChildin kautta, joten
-- kuvataan se osa moduulista, jota tämä skripti käyttää
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 -- slotteja pelaajaa kohden
local STARTER_ITEMS: { Slot } = { -- millä täysin uusi pelaaja aloittaa
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

local inventories: { [Player]: Inventory } = {}

local InventoryService = {}

-- Lähettää omistajalle kopion hänen inventaariostaan. Kutsutaan jokaisen muutoksen jälkeen.
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

-- Pinoamissäännöt: ensin täytetään vajaat pinot, sitten aloitetaan uudet pinot
-- tyhjiin slotteihin. Palauttaa, kuinka monta lisättiin, mikä voi olla vähemmän kuin pyydettiin.
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

-- Kuinka paljon esinettä vielä mahtuu: tila sen pinoissa plus tyhjät slotit
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

-- Lisää enintään amount kappaletta esinettä. Palauttaa, kuinka monta lisättiin (0, jos
-- esinettä ei ole, inventaario on täynnä tai ei ole vielä latautunut).
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

-- Poistaa täsmälleen amount kappaletta esinettä viimeisistä pinoista alkaen.
-- Jos pelaajalla on vähemmän, ei poista mitään ja palauttaa 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
	-- Kuljetaan lopusta, jotta table.remove ei ohita slotteja
	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

-- Kutsutaan, kun pelaajan tallennetut tiedot ovat latautuneet. saved on se, minkä
-- data store palautti: nil uudelle pelaajalle. Jokainen merkintä käy uudelleen läpi
-- pinoamissäännöt, joten poistetut esineet ja vanhat pinokoot eivät riko mitään.
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

-- Yksinkertainen kopio tallennusta varten tai nil, jos pelaajan tiedot eivät koskaan latautuneet
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

type-rivit ja ::-tyyppimuunnos require-kutsun jälkeen ovat vain Luaun tyyppitarkistinta varten, joka ei näe, mitä WaitForChild-kutsulla löydetty moduuli palauttaa. Pelin aikana ne eivät muuta mitään. Muut tämän oppaan skriptit tekevät samoin.

Miten pinoamissäännöt toimivat yllä olevan luettelon kanssa, jossa omenat pinoutuvat 10:een asti:

  • Jos lisäät 15 omenaa pelaajalle, jolla on 7 omenan pino, tämä pino täyttyy 10:een, ja sitten alkaa uusi 5 omenan pino.
  • Kun slotit loppuvat, add lisää sen, mikä mahtui, ja palauttaa tämän luvun. Kutsu ensin spaceFor, kun tarvitset kaikki tai ei mitään, kuten vaiheen 5 poiminta tekee.
  • remove toimii periaatteella kaikki tai ei mitään. Jos pyydät 3 omenaa pelaajalta, jolla on niitä 2, mitään ei poisteta ja paluuarvo on false, joten tarkista tulos ennen kuin annat mitään vastineeksi.
  • Sloteissa ei ole aukkoja: kun slotti tyhjenee, muut siirtyvät ylöspäin. Näin luettelo on helpompi lähettää ja tallentaa. Sloteista, jotka pitävät paikkansa, kerrotaan lopun kysymyksissä.
Mitä muut palvelinskriptit voivat kutsua
FunktioPalauttaaMihin
add(player, itemId, amount)Kuinka monta lisättiinPoiminnat, palkinnot, ostokset
remove(player, itemId, amount)true, jos kaikki poistettiinKäyttö, myynti, askartelu
count(player, itemId)Summa kaikista pinoistaTarkista, mitä pelaajalla on
spaceFor(player, itemId)Kuinka paljon vielä mahtuuTarkistus ennen lisäystä periaatteella kaikki tai ei mitään
getEquipped, setEquippedVarustetun esineen id tai nilVarustaminen, vaiheessa 6
load, serialize, unloadTallennusvalmis kopio (serialize)Lataus ja tallennus, vaiheessa 4

Vaihe 4: lataa ja tallenna jokainen inventaario

Inventaariot ovat palvelimen muistissa, joten ne katoavat, kun pelaaja poistuu. Tämä skripti lataa pelaajan slotit data storesta, kun hän liittyy, ja kirjoittaa ne takaisin, kun hän poistuu, kun palvelin sammuu ja kolmen minuutin välein palvelimen kaatumisen varalta. Se tallentaa vain esineiden id:t ja määrät: data storet eivät osaa säilyttää Instanceja, kuten Tooleja.

Lisää Script ServerScriptServiceen ja nimeä se InventoryData:

Script kohteessa ServerScriptService nimeltä 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

-- Vain pelaajat, joiden tiedot latautuivat, tallennetaan. Epäonnistuneen latauksen jälkeen
-- ei saa tallentaa, muuten tyhjä inventaario korvaa oikean.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

local function keyFor(player: Player): string
	return "User_" .. player.UserId
end

-- Yksi epäonnistunut pyyntö ei saa maksaa kenellekään esineitä, joten yritetään useita kertoja.
-- GetDataStore on myös pcallin sisällä, joten Studion istunto ilman pääsyä data
-- storeihin saa varoituksen eikä pysäytä tätä skriptiä.
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 -- pelaaja poistui, kun latasimme
	end
	if ok then
		InventoryService.load(player, saved) -- saved on nil uudelle pelaajalle
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Tarkoittaa yleensä, että Studion API services -käyttö on pois päältä. Pelataan
		-- aloitusesineillä, jotta voi testata, mutta niitä ei koskaan tallenneta.
		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 -- tiedot eivät koskaan latautuneet, turvallisesti tallennettavaa ei ole
	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)

-- Kun palvelin sammuu, tallennetaan kaikki, jotka ovat vielä täällä, ja odotetaan jokaista
-- käynnissä olevaa tallennusta, myös PlayerRemovingin käynnistämiä
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Tallennetaan kaikki muutaman minuutin välein, jotta palvelimen kaatuminen maksaa minuutteja eikä koko istuntoa
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Mitä skripti tekee ja miksi:

  • Lataus oletusarvoilla. Uudella pelaajalla ei ole tallennettua arvoa, joten GetAsync palauttaa nil, ja hän saa aloitusesineet. Tallennetut slotit käyvät uudelleen läpi pinoamissäännöt, joten luettelosta poistettu esine tai pienennetty pinon enimmäiskoko ei riko latausta. Kaikki, mikä ei enää mahdu tai jonka id:tä ei enää ole luettelossa, hylätään, ja seuraava tallennus tekee tästä lopullista, joten pidä luettelossa jokainen id, joka pelaajilla voi olla.
  • Ei koskaan tallennusta epäonnistuneen latauksen jälkeen. Vain canSave-taulukon pelaajat kirjoitetaan. Julkaistulla palvelimella pelaajaa, jonka tiedot eivät latautuneet kolmenkaan yrityksen jälkeen, pyydetään liittymään uudelleen. Studiossa hän saa sen sijaan aloitusesineet, joita ei tallenneta, muutaman sekunnin myöhemmin uusintayritysten takia. Näin käy, kunnes paikka on julkaistu ja API-käyttö on päällä.
  • Tallennus poistuttaessa ja sammutettaessa. BindToClose tallentaa kaikki, jotka ovat vielä palvelimella, ja odottaa jo käynnissä olevia tallennuksia. Roblox antaa sidotuille funktioille enintään 30 sekuntia.
  • Rajojen sisällä pysyminen. Yksi kirjoitus pelaajaa kohden kolmen minuutin välein ja yksi poistuttaessa on paljon vähemmän kuin palvelimen oletusbudjetti, 60 kirjoitusta minuutissa plus 40 jokaista pelaajaa kohden (dokumentaation mukaan 30. syyskuuta 2026). Avainmalli User_ on Robloxin suosituksista, ja käyttäjä-ID:n antaminen SetAsync-kutsulle liittää tiedot tähän pelaajaan, mitä Roblox suosittelee painokkaasti tietojen poistopyyntöjen käsittelyä varten.

Pienelle pelille tämä on luotettava pohja. Istuntolukitus, joka estää nopeasti palvelinta vaihtanutta pelaajaa lataamasta tietoja ennen kuin vanha palvelin on tallentanut ne, sekä se, milloin käyttää UpdateAsync-kutsua SetAsync-kutsun sijaan, käsitellään DataStore-tutoriaalissa.

Vaihe 5: anna esineitä maailmasta

Poiminta on yksinkertaisin tapa, jolla esineet päätyvät inventaarioon: part, jossa on ProximityPrompt ja joka lisää esineen, kun pelaaja käyttää sitä. Skripti kuuntelee sen Triggered-tapahtumaa palvelimella, joten esine lisätään paikassa, johon asiakas ei voi puuttua.

  1. Lisää Part Workspaceen, nimeä se Apple ja väritä punaiseksi. Ota Anchored käyttöön ja poista CanCollide käytöstä, jotta kukaan ei törmää siihen, kun se on näkymätön. Kehote näyttää partin nimen.
  2. Kun part on valittuna, vieritä Properties-ikkuna kohtaan Attributes ja paina +. Lisää ItemId tyypillä string ja paina Save, ja aseta sitten arvoksi apple. Lisää samoin Amount tyyppiä number arvolla 1.
  3. Lisää partin sisään Script, nimeä se ItemPickup ja liitä tämä koodi:
Script kohteessa Apple-part Workspacessa nimeltä ItemPickup
-- Laita tämä Script Partin sisään ja anna Partille kaksi attribuuttia:
-- ItemId (merkkijono, esimerkiksi apple) ja Amount (luku, esimerkiksi 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 -- joku muu poimi sen juuri
	end
	-- Tarkistetaan etäisyys palvelimella eikä luoteta pyyntöön
	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 -- tila ei riitä: jätetään esine paikalleen
	end
	InventoryService.add(player, itemId, amount)

	prompt.Enabled = false
	part.Transparency = 1
	task.wait(RESPAWN_SECONDS)
	part.Transparency = visibleTransparency
	prompt.Enabled = true
end)

Kopioi part sijoittaaksesi lisää esineitä. Muuta attribuutteja antaaksesi puuta, toisen miekan tai omenapinon.

Roblox tarkistaa etäisyyden Triggered-tapahtumalle, mutta sen turvallisuusopas käskee silti tarkistamaan kehotteet palvelimella: huijari voi laukaista kehotteen tapahtumia, vaikka Enabled olisi false, ja voi vetää ankkuroimattoman partin hahmonsa luo. Siksi skripti tarkistaa itse Enabled-arvon ja etäisyyden, ja siksi part on ankkuroitu.

Mikä tahansa muu palvelinskripti antaa esineitä samalla tavalla. Ostoksen, tehtävän tai tapon jälkeen ota InventoryService käyttöön require-kutsulla kuten yllä olevat skriptit ja kutsu InventoryService.add(player, "wood", 5). Tarkista ensin spaceFor, kun esinettä ei saa menettää. Yksi lähde voi olla myös NPC: NPC-dialogioppaassa vastaus käynnistää toiminnon palvelimella, ja tämä toiminto voi samalla tavalla kutsua InventoryService.add.

Vaihe 6: Toolin varustaminen ja esineiden käyttö

Kaksi RemoteEventiä kuljettaa ainoat pyynnöt, jotka asiakas voi tehdä. EquipItem laittaa kopion esineen Toolista ServerStoragesta pelaajan Backpackiin (hotbar näytön alareunassa) ja hänen käteensä, ja toinen pyyntö poistaa sen. UseItem poistaa yhden kappaleen käytettävää esinettä ja soveltaa sen vaikutuksen, tässä parantamisen.

Lisää Script ServerScriptServiceen ja nimeä se InventoryActions:

Script kohteessa ServerScriptService nimeltä 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 } = {}

-- Jokainen pyyntö alkaa tästä. Asiakas voi lähettää mitä tahansa milloin tahansa, joten
-- tarkistetaan tyyppi, että esine on olemassa, että se on pelaajalla, ja tiheys.
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

-- Tuhoaa tämän esineen Toolin, missä tahansa kopio onkin: hotbar, käsi tai 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) -- yksi varustettu työkalu kerrallaan

	local tool = template:Clone()
	tool.CanBeDropped = false -- pudotetun kopion voisi poimia joku muu
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Toinen kopio StarterGearissa kopioidaan takaisin Backpackiin uudelleensyntymän jälkeen
	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) -- suoraan käteen
	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) -- varustetun esineen klikkaaminen uudelleen poistaa sen
	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 -- kuollut tai jo täydessä terveydessä: ei tuhlata esinettä
	end
	-- Ensin otetaan esine ja parannetaan vain, jos se onnistui
	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)
Mitä kukin pyyntö saa tehdä
PyyntöAsiakas lähettääPalvelin tarkistaa ennen toimintaa
EquipItemEsineen idSe on merkkijono, esine on olemassa, pelaajalla on se, pyyntöjä tulee enintään neljä sekunnissa, esineellä on toolName, ja sen niminen Tool on kansiossa ServerStorage.ItemTools
UseItemEsineen idSamat tyypin, omistuksen ja tiheyden tarkistukset, esineellä on heal-arvo, hahmo on elossa ja haavoittunut, ja yksi esine poistetaan ennen kuin terveyttä lisätään

Kolme yksityiskohtaa estää Toolia monistumasta tai katoamasta. Kopion CanBeDropped on false, koska pudotettu Tool putoaa Workspaceen, josta toinen pelaaja voi ottaa sen, vaikka alkuperäinen jää inventaarioon. Jokaisella kopiolla on attribuutti InventoryItem, joten riisuttaessa jokainen kopio löydetään ja tuhotaan, missä tahansa se onkin. Ja jos pelaajalla on StarterGear-säiliö, siihen laitetaan toinen kopio. Roblox kopioi StarterGearin Backpackiin aina hahmon syntyessä, joten varustettu miekka palaa uudelleensyntymän jälkeen.

Vain yksi Tool on varustettuna kerrallaan, eikä varustusta tallenneta, joten pelaaja aloittaa uudelleen liityttyään tyhjällä hotbarilla. Jos lisäät myöhemmin myynnin tai pudottamisen, riisu esine ennen kuin sen viimeinen kopio poistuu inventaariosta.

Paikkamiekasta voi tehdä miekan, joka oikeasti taistelee: kokoa Tool miekkaoppaan mukaan, jätä sen nimeksi Sword ja laita se kansioon ItemTools paikkamiekan tilalle. Tuon oppaan palvelinskripti tarkistaa jokaisen iskun riippumatta siitä, miten pelaaja sai miekan.

Vaihe 7: piirrä inventaarion ruudukko

LocalScript kokoaa koko ikkunan koodissa, joten mitään ei tarvitse asetella käsin. ScrollingFrame sisältää slotit, sen sisällä oleva UIGridLayout asettelee ne riveihin, ja AutomaticCanvasSize kasvattaa vieritettävää aluetta rivien lisääntyessä.

Avaa Explorerissa StarterPlayer, lisää LocalScript kansioon StarterPlayerScripts ja nimeä se InventoryClient:

LocalScript kohteessa StarterPlayerScripts nimeltä 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. Kootaan ikkuna kerran. ResetOnSpawn = false säilyttää sen uudelleensyntymien yli.
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 kasvattaa sitä solujen mukaan
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. Yksi solu slottia kohden. Tämä vain piirtää sen, mitä palvelin lähetti; itse
-- inventaariota ei koskaan muuteta täältä.
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 -- tyhjä slotti
	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()
		-- Pyydetään, ei käsketä: palvelin tarkistaa pyynnön ja lähettää tuloksen
		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

-- Palvelin lähettää tämän latauksen jälkeen ja jokaisen muutoksen jälkeen
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Avataan ja suljetaan painikkeella tai B-näppäimellä
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)

LocalScript StarterPlayerScriptsissä käynnistyy kerran istuntoa kohden, ja ResetOnSpawn = false säilyttää ScreenGuin hahmon syntyessä uudelleen, joten ruudukko näyttää edelleen viimeisimmän palvelimen lähettämän kopion.

Asiakas piirtää solun jokaista slottia kohden, myös tyhjiä, joten 20 slotin inventaario näyttää aina 20 slotilta. Jokainen päivitys tuhoaa vanhat solut ja rakentaa uudet; se on yksinkertaista ja sopii muutamalle kymmenelle slotille. Jos palvelin lähettää InventoryUpdated-viestin ennen kuin tämä skripti on kytkeytynyt siihen, Roblox laittaa viestin jonoon ja toimittaa sen heti, kun käsittelijä kytkeytyy, joten ensimmäinen inventaario ei katoa.

Haluatko piirtää ikkunan Studiossa? Kokoa ScreenGui, jossa on yksi pohjaslotti, ja tee siitä Clone funktiossa makeCell. Kuvakkeita varten anna luettelon esineelle icon, jossa on lataamasi kuva, niin sen solu näyttää kuvan nimen sijaan.

Testaa inventaario

  1. Paina Play. Avaa inventaario vasemmalla olevalla painikkeella tai näppäimellä B: uudella pelaajalla on Sword ja 3 Apple, ja laskuri näyttää 2 / 20 slots. Niin kauan kuin Studio ei voi käyttää data storeja, esineet ilmestyvät muutaman sekunnin kuluttua Outputin latausvaroitusten jälkeen, eikä niitä tallenneta.
  2. Klikkaa Swordia. Miekka ilmestyy käteesi ja hotbariin, ja sen slotti saa violetin kehyksen. Klikkaa uudelleen poistaaksesi sen.
  3. Mene Apple-partin luo ja käytä sen kehotetta. Omenapino kasvaa 4:ään, ja part katoaa 15 sekunniksi.
  4. Testataksesi parantamista vähennä ensin terveyttä. Vaihda Client/Server tilaan Server, valitse hahmosi Humanoid Explorerissa, aseta Health arvoon 50, vaihda takaisin tilaan Client ja klikkaa Applea.
  5. Kun Studion API services -käyttö on päällä, pysäytä peli ja käynnistä uudelleen. Poimittu omena on tallessa. Jos lataus tai tallennus epäonnistui, Output kertoo sen.

Testataksesi usealla pelaajalla valitse testiasetuksista Server & Clients 2 asiakkaalla. Jokainen pelaaja näkee vain oman inventaarionsa, ja toisen kädessä olevan miekan näkevät molemmat.

Yleiset virheet ja ratkaisut

Useimmat ongelmat näkyvät Output-ikkunassa varoituksena tai punaisena virherivinä. Lue ensimmäinen: seuraavat virheet johtuvat usein siitä.

Infinite yield possible WaitForChild-kutsussa

Skripti odottaa objektia, jota ei ole juuri tällä nimellä. Vertaa Exploreriasi vaiheen 1 puuhun: InventoryRemotes kolmella RemoteEventillä ReplicatedStoragessa, ItemTools ServerStoragessa ja kaksi moduulia. Nimet erottelevat isot ja pienet kirjaimet. Skriptivirheiden opas käsittelee tätä varoitusta tarkemmin.

Ruudukko aukeaa mutta pysyy tyhjänä

Asiakas piirtää vain sen, mitä palvelin lähettää. Etsi Outputista varoituksia Inventory load failed ja tarkista, että InventoryData on Script eikä LocalScript, ServerScriptServicessä, ja sen vieressä on ModuleScript InventoryService. Jos Output näyttää virheen Remote event invocation, kukaan ei kuuntele InventoryUpdated-tapahtumaa asiakkaalla: etsi aiempi virhe InventoryClient-skriptistä.

Esineet nollautuvat joka kerta, kun pelaan Studiossa

Jos Output kirjoittaa Inventory not loaded: playing with starter items that will not be saved, paikkaa ei ole julkaistu tai Studion API services -käyttö on pois päältä. Ota se käyttöön vaiheen 4 ohjeen mukaan pelisi testikopiossa.

Miekan klikkaaminen ei tee mitään

Etsi Outputista Cannot equip sword: kansion ServerStorage.ItemTools Toolin nimen on oltava täsmälleen sama kuin luettelon toolName. Lisäksi Tool tarvitsee partin nimeltä Handle, jotta sitä voi pitää kädessä, ellet ole asettanut sen RequiresHandle-arvoa falseksi.

Poimintakehote ilmestyy, mutta mitään ei lisätä

ItemId-attribuutin on vastattava luettelon id:tä täsmälleen, myös kirjainkoon osalta: apple, ei Apple. Mitään ei lisätä, kun pelaajan inventaario latautuu vielä tai kun koko määrälle ei ole tilaa.

Tallennus hajoaa sen jälkeen, kun muutin tallennettavia tietoja

Data storet hyväksyvät yksinkertaista dataa: merkkijonoja, lukuja, totuusarvoja ja niistä koostuvia taulukoita. Toolin, Partin tai minkä tahansa muun Instancen tallennus kaatuu, tai arvo tallentuu nilinä. Tallenna esineen id ja määrä ja palauta kaikki muu luettelosta, kuten serialize tekee.

Tee se RoCodella

Jos sinun on helpompi kuvailla järjestelmä kuin koota se käsin, RoCode voi koota sen paikkaan, joka sinulla on auki. Se on tekoälyagentti Roblox Studioon: kuvailet ominaisuuden verkkochatissa, ja sen Studio-lisäosa luo skriptit ja objektit Exploreriisi sen sijaan, että antaisi liitettävää koodia.

Sinä kirjoitat

Lisää 20 slotin inventaario, jossa esineet pinoutuvat, UI-ruudukko, joka aukeaa B:llä, ServerStoragessa oleva miekka, jonka pelaajat voivat varustaa, omenat, jotka parantavat, ja tallennus DataStoreServicellä.

RoCode tekee
  • Voi käydä paikkasi läpi, kun vaihe sitä tarvitsee, Search Gamella ja Search Scriptsillä nojatakseen jo olemassa oleviin esineisiin, remoteihin tai tallennuskoodiin eikä lisätäkseen toista järjestelmää
  • Luo kansiot ja RemoteEventit Create Instancella sekä ModuleScriptit, Scriptit ja LocalScriptit Create Scriptillä
  • Voi koota ikkunan pohjan Build UI:lla, jossa on inventaarion asettelu paikkaslotteineen; koodi, joka täyttää slotit palvelimelta, kirjoitetaan erillisinä skripteinä
  • Tarkistaa jokaisen skriptin kääntymisen Studiossa Check Scriptillä, joka löytää käännösvirheet ja muutaman riskialttiin kuvion, mutta ei tarkista tyyppejä, ei linttaa eikä aja koodiasi

Jokainen muutoserä on kumouspiste Studiossa. RoCode ei voi ottaa käyttöön Studion API services -käyttöä, se on sinun tehtäväsi. Lisäosalla 3.9 tai uudemmalla se voi ajaa lyhyen pelitestin ja lukea virheet, ja lisäosalla 3.9.15 tai uudemmalla sen testihahmo voi painaa näppäimiä ja varustaa esineitä, mutta se tarkistaa vain sen, minkä se itse päätti testata, joten testaa tallennus pelitestillä itse. Inventaario rakentuu muiden järjestelmien, kuten tallennuksen ja työkalujen, päälle, ja tekoälypelintekijä, joka rakentaa omaan paikkaasi Studiossa, lisää ne yksi kehote kerrallaan. Miten RoCode yhdistyy Studioon.

Usein kysytyt kysymykset

Käytänkö Robloxin Backpackia oman inventaarion sijaan?

Backpack on Robloxin sisäänrakennettu inventaario: jokainen sen Tool näkyy painikkeena hotbarissa. Jos kaikki pelisi esineet ovat Tooleja etkä tarvitse pinoja, määriä ja slottirajaa, se voi riittää, vaikka sinun pitää silti tallentaa, mitkä Toolit kullakin pelaajalla on. Oma inventaario tarvitaan esineille, jotka eivät ole Tooleja, kuten materiaaleille ja kulutustavaroille. Tässä oppaassa käytetään molempia: inventaario säilyttää kaiken, ja Backpack pitää varustetun Toolin.

Miten piilotan Robloxin oletushotbarin?

Kutsu LocalScriptistä StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Kun hotbar on piilotettu, pelaajat tarvitsevat toisen tavan ottaa käteen ja poistaa varustettu Tool, esimerkiksi painikkeen, joka pyytää palvelinta kutsumaan Humanoid:EquipTool tai Humanoid:UnequipTools.

Miten saan slotit pitämään paikkansa drag and dropia varten?

Säilytä kiinteän pituinen luettelo, jossa on yksi merkintä slottia kohden, ja merkitse tyhjät slotit arvolla, kuten tyhjällä id:llä, ei nilillä, koska Roblox ei suosittele lähettämään nil-arvoja sisältäviä taulukoita RemoteEventin kautta. Lisää sitten RemoteEvent MoveItem, joka lähettää kaksi slotin numeroa, ja anna palvelimen tarkistaa, että molemmat ovat kokonaislukuja väliltä 1 ja kapasiteetti, ennen kuin se vaihtaa niiden paikat.

Kuinka suuri tallennettu inventaario voi olla?

Yksi data storen arvo voi olla enintään 4 194 304 merkkiä sarjallistamisen jälkeen (dokumentaation mukaan 30. syyskuuta 2026). Luettelo id:istä ja määristä vie tästä pienen murto-osan. Tallennuksen kokoa kasvattaa esinekohtainen teksti, kuten omat nimet tai pitkät kuvaukset, jotka tallennetaan jokaiselle esineelle.

Miten esineitä ostetaan ja myydään kolikoilla?

Tee kaikki palvelimella. Myydessä kutsu InventoryService.remove ja maksa vain, jos se palautti true. Ostaessa tarkista hinta ja spaceFor, ota kolikot ja kutsu sitten add. Kauppaopas rakentaa ostopuolen.

Lähteet ja lisälukemista

Miten koodi tarkistettiin: jokainen tämän sivun skripti läpäisee Luaun tiukan tyyppitarkistuksen Roblox API:n määrittelyillä (luau-lsp, 20. marraskuuta 2026). Tyyppitarkistus löytää virheet API-nimissä ja väärät tyypit, mutta ei pelilogiikan virheitä, joten testaa kaikki Studiossa ennen julkaisua.

Kokeile RoCodea omassa pelissäsi.

Ilmaisia krediittejä joka päivä, ei korttia. Asenna lisäosa, kuvaile ominaisuus ja katso, mitä Studioon ilmestyi.