Prodotti per sviluppatori

Un prodotto per sviluppatori è un articolo o una capacità che un utente può acquistare più di una volta, come valuta di gioco, munizioni o pozioni.

Crea un prodotto per sviluppatori

Per creare un prodotto per sviluppatori:

1. Vai a Creazioni e seleziona un gioco.
2. Vai su Monetizzazione ⟩ Prodotti per sviluppatori.
3. Fai clic su Crea prodotto per sviluppatori.
4. Carica un'immagine da visualizzare come icona del prodotto. Assicurati che l'immagine non superi i 512x512 pixel, non contenga dettagli importanti al di fuori dei suoi confini circolari e sia nel formato .jpg, .png o .bmp.
5. Inserisci un nome e una descrizione per il prodotto.
6. Seleziona una categoria per il prodotto. La categoria viene utilizzata per organizzare gli articoli nel tuo negozio di gioco.
7. Imposta il prezzo del prodotto in Robux. Il prezzo minimo è 1 Robux e il prezzo massimo è 1 miliardo di Robux.
8. Fai clic su Salva modifiche.

Ottieni l'ID del prodotto per sviluppatori

Per utilizzare la programmazione, hai bisogno di un ID del prodotto per sviluppatori. Per ottenere l'ID del prodotto:

1. Vai su Monetizzazione ⟩ Prodotti per sviluppatori.

2. Passa il mouse sopra la miniatura di un prodotto, fai clic sul pulsante ⋯ e seleziona Copia ID risorsa dal menu contestuale.

   

Vendi un prodotto per sviluppatori

Prima di vendere prodotti per sviluppatori, assicurati di elaborare correttamente le ricevute di vendita e di concedere agli utenti i prodotti acquistati. Per farlo, devi:

• Utilizzare l'API ProcessReceipt per controllare le ricevute di acquisto. ProcessReceipt legge automaticamente e riconosce che un utente ha acquistato un prodotto al di fuori del gioco.
• Validare ciascuna ricevuta per User ID, Developer Product ID e lo stato della ricevuta.
• Se la ricevuta ha uno stato di Aperta, concedi all'utente i prodotti per sviluppatori che ha acquistato.
• Rispondere all'API ProcessReceipt con un messaggio che riconosca la ricevuta e che convalidi che i prodotti acquistati siano stati concessi.

Puoi vendere prodotti per sviluppatori in due modi:

• All'interno del tuo gioco
• Al di fuori del tuo gioco

All'interno del tuo gioco

Per implementare e vendere un prodotto per sviluppatori all'interno di un gioco, chiama le funzioni di MarketplaceService.

Utilizza GetProductInfo per recuperare informazioni su un prodotto per sviluppatori, come nome e prezzo, e quindi visualizzare quel prodotto agli utenti. Puoi vendere il prodotto all'interno del mercato del tuo gioco, ad esempio. Per i prodotti per sviluppatori, il secondo parametro deve essere Enum.InfoType.Product.

local MarketplaceService = game:GetService("MarketplaceService")

-- Sostituisci l'ID segnaposto con il tuo ID prodotto per sviluppatori
local productId = 000000

local success, productInfo = pcall(function()
	return MarketplaceService:GetProductInfo(productId, Enum.InfoType.Product)
end)

if success and productInfo then
	-- Visualizza le informazioni sul prodotto
	-- Sostituisci le istruzioni print con codice UI per visualizzare il prodotto
  print("Nome del prodotto per sviluppatori: " .. productInfo.Name)
  print("Prezzo in Robux: " .. productInfo.PriceInRobux)
  print("Descrizione: " .. productInfo.Description)
end

Utilizza GetDeveloperProductsAsync per recuperare tutti i prodotti per sviluppatori associati al tuo gioco. Questa funzione restituisce un oggetto Pages che puoi ispezionare e filtrare per costruire cose come un negozio di gioco o un'interfaccia utente per l'elenco dei prodotti.

local MarketplaceService = game:GetService("MarketplaceService")

local success, developerProducts = pcall(function()
	return MarketplaceService:GetDeveloperProductsAsync()
end)

if success and developerProducts then
	local firstPage = developerProducts:GetCurrentPage()
	for _, developerProduct in firstPage do
			-- Sostituisci l'istruzione print con codice UI per visualizzare il prodotto
			print(field .. ": " .. value)
	end
end

Utilizza PromptProductPurchase per richiedere acquisti di prodotti all'interno del tuo gioco. Puoi chiamare questa funzione quando un utente esegue azioni come premere un pulsante o parlare con un NPC venditore.

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")
local player = Players.LocalPlayer

-- Sostituisci l'ID segnaposto con il tuo ID prodotto per sviluppatori
local productId = 000000

local function promptProductPurchase()
    local success, errorMessage = pcall(function()
      MarketplaceService:PromptProductPurchase(player, productId)
    end)

    if success then
      print("Richiesta di acquisto mostrata con successo")
		end
end

Puoi anche combinare le funzioni all'interno di un LocalScript. Ad esempio, puoi creare un elemento UI come un pulsante o un NPC venditore, quindi utilizzare GetProductInfo() per collegare un prodotto per sviluppatori esistente a quell'elemento, controllare se il prodotto è in vendita e utilizzare PromptProductPurchase() per richiedere un acquisto ogni volta che l'utente fa clic su di esso.

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local button = script.Parent

-- Sostituisci l'ID segnaposto con il tuo ID prodotto per sviluppatori
local productId = 000000

	-- Ottiene informazioni sul prodotto quando l'utente fa clic sul pulsante UI
button.MouseButton1Click:Connect(function()
	local success, productInfo = pcall(function()
		return MarketplaceService:GetProductInfo(productId, Enum.InfoType.Product)
	end)

	if success and productInfo then
		-- Controlla se il prodotto è in vendita
		if productInfo.IsForSale then
			print("Questo è in vendita")
			-- Richiesta di acquisto del prodotto
			MarketplaceService:PromptProductPurchase(player, productId)
		else
			-- Notifica che il prodotto non è in vendita
			print("Questo prodotto non è attualmente in vendita.")
		end
	else
		print("Errore nel recupero delle informazioni sul prodotto: " .. tostring(productInfo))
	end
end)

Al di fuori del tuo gioco

Per abilitare gli acquisti di prodotti per sviluppatori al di fuori del tuo gioco, devi lavorare con l'API ProcessReceipt. Dopo che un utente ha effettuato un acquisto nella scheda Negozio della pagina dei dettagli del tuo gioco, devi utilizzare ProcessReceipt per confermare il loro acquisto e concedere loro i prodotti una volta che entreranno nel tuo gioco.

Modalità di test

La funzionalità di modalità di test ti aiuta a convalidare il tuo flusso di acquisto simulando un acquisto di prodotto per sviluppatori al di fuori del tuo gioco. Dovresti utilizzare la modalità di test per assicurarti di avere implementato ProcessReceipt correttamente prima di abilitare le vendite esterne di prodotti per sviluppatori.

I prodotti per sviluppatori che metti in vendita in modalità di test possono essere visualizzati solo da te e dai membri del tuo gruppo. Non sono visibili agli utenti.

Per testare la tua implementazione:

1. Nella Creator Hub, vai su Monetizzazione ⟩ Prodotti per sviluppatori.
2. Fai clic sul menu ⋮ e seleziona Impostazioni di acquisto esterno.
3. Nella pagina Impostazioni di acquisto esterno, fai clic su Abilita modalità test.
4. Una volta attiva la modalità di test, torna alla pagina Prodotti per sviluppatori e seleziona un prodotto da testare.
5. Nella pagina Impostazioni di base, seleziona la casella Consenti acquisti esterni e salva le modifiche.
6. Vai alla scheda Negozio della pagina dei dettagli del gioco e acquista il prodotto che hai reso disponibile per la vendita.
7. Entra nel gioco e conferma di aver ricevuto il prodotto acquistato. Lo stato della ricevuta dell'API ProcessReceipt dovrebbe aggiornarsi a Chiuso.

Dopo aver testato la tua implementazione, Roblox verifica che il test sia stato completato con successo e ti consente di attivare completamente la funzionalità di vendita di prodotti per sviluppatori al di fuori dei tuoi giochi.

Per ulteriori informazioni sull'API ProcessReceipt e sulla sua implementazione, vedere la pagina ProcessReceipt.

Abilita le vendite esterne

Per abilitare le vendite esterne:

1. Vai alla pagina Impostazioni di acquisto esterno.
2. Attiva Acquisti esterni.
3. Torna alla pagina Prodotti per sviluppatori e seleziona i prodotti che desideri vendere al di fuori del tuo gioco.
4. Nella pagina Impostazioni di base, seleziona la casella Consenti acquisti esterni e salva le modifiche.
5. Conferma che i prodotti siano ora disponibili per l'acquisto nella scheda Negozio della pagina dei dettagli del gioco.

Per disabilitare la vendita esterna di un prodotto per sviluppatori, seleziona il prodotto nella pagina Prodotti per sviluppatori e deseleziona la casella Consenti acquisti esterni.

Limitazioni

• Gli articoli in vendita in modalità di test costano reali Robux. Ti consigliamo di testare prodotti per sviluppatori a basso costo.
• Gli articoli in vendita in modalità di test possono essere visualizzati solo da te o da membri del tuo gruppo.
• Per essere venduti esternamente, i tuoi prodotti per sviluppatori devono avere una miniatura.
• Non dovresti vendere al di fuori del tuo gioco:

  • Articoli casuali a pagamento
  • Articoli limitati a specifiche quantità, tempo, luogo o impostazioni e ruoli utente

Gestire un acquisto di prodotto per sviluppatori

Dopo che un utente ha acquistato un prodotto per sviluppatori, devi gestire e registrare la transazione. Per fare ciò, utilizza uno Script all'interno di ServerScriptService utilizzando la funzione ProcessReceipt.

Per ulteriori informazioni sull'API ProcessReceipt e sulla sua implementazione, vedere la pagina ProcessReceipt.

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local productFunctions = {}

-- Esempio: l'ID prodotto 123123 riporta l'utente a piena salute
productFunctions[123123] = function(receipt, player)
	local character = player.Character
	local humanoid = character and character:FindFirstChildWhichIsA("Humanoid")

	if humanoid then
		humanoid.Health = humanoid.MaxHealth
		-- Indica un acquisto riuscito
		return true
	end
end

-- Esempio: l'ID prodotto 456456 assegna 100 monete d'oro all'utente
productFunctions[456456] = function(receipt, player)
	local leaderstats = player:FindFirstChild("leaderstats")
	local gold = leaderstats and leaderstats:FindFirstChild("Gold")

	if gold then
		gold.Value += 100
		return true
	end
end

local function processReceipt(receiptInfo)
	local userId = receiptInfo.PlayerId
	local productId = receiptInfo.ProductId

	local player = Players:GetPlayerByUserId(userId)
	if player then
		-- Ottiene la funzione gestore associata all'ID prodotto per sviluppatori e tenta di eseguirla
		local handler = productFunctions[productId]
		local success, result = pcall(handler, receiptInfo, player)
		if success then
			-- L'utente ha ricevuto i suoi articoli
			-- Restituisce "PurchaseGranted" per confermare la transazione
			return Enum.ProductPurchaseDecision.PurchaseGranted
		else
			warn("Impossibile elaborare la ricevuta:", receiptInfo, result)
		end
	end

	-- Gli articoli dell'utente non possono essere assegnati
	-- Restituisce "NotProcessedYet" e tenta di nuovo la prossima volta che l'utente entra nel gioco
	return Enum.ProductPurchaseDecision.NotProcessedYet
end

-- Imposta il callback
-- Questo può essere fatto solo una volta da uno script server-side
MarketplaceService.ProcessReceipt = processReceipt

Personalizza il tuo negozio in-game

Puoi utilizzare le API di intelligenza dei prodotti per ordinare e raccomandare prodotti per sviluppatori agli utenti. Personalizzare il tuo negozio in-game aiuta a mettere in evidenza gli articoli più rilevanti per ciascun utente, aumentando l'engagement e i ricavi. Personalizzando i prodotti per sviluppatori in base alle preferenze degli utenti, puoi migliorare la loro scoperta, aumentare i tassi di conversione e sbloccare nuove opportunità di monetizzazione.

Classifica i prodotti per sviluppatori in vendita

RankProductsAsync prende un elenco di ID prodotto e restituisce un elenco ordinato personalizzato di quei prodotti. Puoi utilizzare questo metodo per fornire ai tuoi utenti raccomandazioni personalizzate sugli articoli nel tuo negozio in-game.

local MarketplaceService = game:GetService("MarketplaceService")

-- Crea un array di prodotti che desideri classificare
local productIdentifiers = {
    {InfoType = Enum.InfoType.GamePass, Id = 123},
    {InfoType = Enum.InfoType.Product, Id = 456},
    {InfoType = Enum.InfoType.Product, Id = 789}
}

-- Effettua una chiamata protetta per gestire gli errori
local success, rankedProducts = pcall(function()
    return MarketplaceService:RankProductsAsync(productIdentifiers)
end)

if not success then
    error("Impossibile classificare i prodotti")
end

-- Carica gli articoli restituiti nel negozio
for i, rankedItem in ipairs(rankedProducts) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logica per aggiungere prodotti nel negozio
end

Visualizza i tuoi migliori prodotti per sviluppatori

RecommendTopProductsAsync prende un array di valori InfoType e restituisce fino a 50 articoli con cui un utente è più probabilmente coinvolto e acquisterà. Puoi utilizzare questo metodo per creare una sezione "Top Picks" nel tuo negozio in-game.

Se non è possibile determinare raccomandazioni, RecommendTopProductsAsync restituisce 0 articoli.

In rari casi, le chiamate al modello di classificazione possono essere lente. Per aiutare a prevenire ritardi per gli utenti, ti consigliamo di utilizzare task.spawn per rendere la chiamata a RecommendTopProducts non bloccante.

local MarketplaceService = game:GetService("MarketplaceService")

-- Crea un array di tipi di prodotto che desideri includere nelle raccomandazioni -- Questo esempio include sia pass che prodotti per sviluppatori
local productTypes = {Enum.InfoType.GamePass, Enum.InfoType.Product}

-- Effettua una chiamata protetta per gestire gli errori
local success, topRankedItems = pcall(function()
    return MarketplaceService:RecommendTopProductsAsync(productTypes)
end)

if not success then
    error("Impossibile classificare i prodotti")
end

-- Carica gli articoli restituiti nel negozio
-- Assicurati di filtrare eventuali articoli non idonei da topRankedItems, come prodotti per sviluppatori che l'utente non può più acquistare
for i, rankedItem in ipairs(topRankedItems) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logica per aggiungere prodotti nel negozio
end

Analisi dei prodotti per sviluppatori

Utilizza l'analisi dei prodotti per sviluppatori per analizzare il successo di singoli prodotti, identificare tendenze e prevedere potenziali guadagni futuri.

Con l'analisi, puoi:

• Visualizzare i tuoi migliori prodotti per sviluppatori su un periodo di tempo selezionato.
• Mostrare fino a otto articoli più venduti su un grafico temporale per analizzare le vendite complessive e il reddito netto.
• Monitorare il tuo catalogo e ordinare gli articoli per vendite e reddito netto.

Per accedere all'analisi dei prodotti per sviluppatori:

1. Vai a Creazioni e seleziona un gioco.
2. Vai su Monetizzazione ⟩ Prodotti per sviluppatori.
3. Seleziona la scheda Analisi.