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
Miten inventaario toimii
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.
| Osa | Tyyppi ja paikka | Tehtävä |
|---|---|---|
ItemCatalog | ModuleScript ReplicatedStoragessa | Mitä kukin esine on: nimi, kuvaus, pinon enimmäiskoko ja voiko sen varustaa tai käyttää. Sitä lukevat palvelin ja kaikki asiakkaat. |
InventoryService | ModuleScript ServerScriptServicessä | Säilyttää kaikkien pelaajien slotit. Ainoa koodi, joka lisää, poistaa ja pinoaa esineitä. |
InventoryData | Script ServerScriptServicessä | Lataa pelaajan esineet liittymisen yhteydessä ja tallentaa ne. |
InventoryActions | Script ServerScriptServicessä | Tarkistaa ja suorittaa varustus- ja käyttöpyynnöt. |
ItemPickup | Script Partin sisällä | Antaa esineen sille, joka poimi sen. |
InventoryClient | LocalScript 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ä.
- Lisää ReplicatedStorageen Folder nimeltä
InventoryRemotes. Lisää sen sisään kolme RemoteEventiä nimeltäInventoryUpdated,EquipItemjaUseItem. - Lisää ServerStorageen Folder nimeltä
ItemTools. Lisää sen sisään Tool nimeltäSwordja 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. - Lisää skriptit sitä mukaa kuin etenet vaiheissa. Puu näyttää, mihin kukin niistä menee.
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ä:
-- 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:
-- 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,
addlisää sen, mikä mahtui, ja palauttaa tämän luvun. Kutsu ensinspaceFor, kun tarvitset kaikki tai ei mitään, kuten vaiheen 5 poiminta tekee. removetoimii periaatteella kaikki tai ei mitään. Jos pyydät 3 omenaa pelaajalta, jolla on niitä 2, mitään ei poisteta ja paluuarvo onfalse, 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ä.
| Funktio | Palauttaa | Mihin |
|---|---|---|
add(player, itemId, amount) | Kuinka monta lisättiin | Poiminnat, palkinnot, ostokset |
remove(player, itemId, amount) | true, jos kaikki poistettiin | Käyttö, myynti, askartelu |
count(player, itemId) | Summa kaikista pinoista | Tarkista, mitä pelaajalla on |
spaceFor(player, itemId) | Kuinka paljon vielä mahtuu | Tarkistus ennen lisäystä periaatteella kaikki tai ei mitään |
getEquipped, setEquipped | Varustetun esineen id tai nil | Varustaminen, vaiheessa 6 |
load, serialize, unload | Tallennusvalmis 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:
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
GetAsyncpalauttaa 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.
BindToClosetallentaa 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 antaminenSetAsync-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.
- Lisää Part Workspaceen, nimeä se
Appleja 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. - Kun part on valittuna, vieritä Properties-ikkuna kohtaan Attributes ja paina +. Lisää
ItemIdtyypillä string ja paina Save, ja aseta sitten arvoksiapple. Lisää samoinAmounttyyppiä number arvolla1. - Lisää partin sisään Script, nimeä se
ItemPickupja liitä tämä koodi:
-- 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:
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)
| Pyyntö | Asiakas lähettää | Palvelin tarkistaa ennen toimintaa |
|---|---|---|
EquipItem | Esineen id | Se 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 |
UseItem | Esineen id | Samat 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:
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
- 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.
- Klikkaa Swordia. Miekka ilmestyy käteesi ja hotbariin, ja sen slotti saa violetin kehyksen. Klikkaa uudelleen poistaaksesi sen.
- Mene Apple-partin luo ja käytä sen kehotetta. Omenapino kasvaa 4:ään, ja part katoaa 15 sekunniksi.
- Testataksesi parantamista vähennä ensin terveyttä. Vaihda Client/Server tilaan Server, valitse hahmosi
HumanoidExplorerissa, aseta Health arvoon 50, vaihda takaisin tilaan Client ja klikkaa Applea. - 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.
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ä.
- 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
- Roblox Creator Docs: Remote events and callbacks (englanniksi). FireClient, OnServerEvent, argumenttien rajoitukset ja miten viestit ilman vastaanottajaa laitetaan jonoon
- Roblox Creator Docs: Securing the client-server boundary (englanniksi). remotejen syötteiden tarkistus, ProximityPromptin tarkistukset ja datan väärentäminen data storessa
- Roblox Creator Docs: Data stores (englanniksi). GetAsync, SetAsync ja käytön salliminen Studiosta
- Roblox Creator Docs: Best practices for data stores (englanniksi). yksi avain pelaajaa kohden, avainmallit ja säännölliset tallennukset
- Roblox Creator Docs: Data store error codes and limits (englanniksi). palvelimen pyyntörajat ja yhden arvon kokoraja
- Roblox Creator Docs: In-game tools (englanniksi). Handle, ankkurointi, Backpack ja StarterGear
- Roblox Creator Docs: Grid and table layouts (englanniksi). UIGridLayoutin solukoko, välit ja lajittelujärjestys
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.