Prodotti per sviluppatori

Un prodotto sviluppatore è un oggetto o un'abilità che un utente può acquistare più di una volta, come valuta in-experience, Monetao pozioni.

Crea un prodotto per sviluppatori

Per creare un prodotto sviluppatore:

1. Vai a Creazioni e seleziona un'esperienza.
2. Vai a Monetizzazione > Prodotti per sviluppatori .
3. Fai clic su Crea un prodotto per sviluppatori .
4. Carica un'immagine da mostrare come Iconadel prodotto.Assicurati che l'immagine non superi i 512x512 pixel, non includa 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. Imposta il prezzo del prodotto in Robux. Il prezzo minimo è 1 Robux e il prezzo massimo è 1 miliardo di Robux.
7. Fai clic su Crea prodotto sviluppatore .

Ottieni l'ID prodotto sviluppatore

Per utilizzare scripting, è necessario un ID prodotto sviluppatore. Per ottenere l'ID del prodotto:

1. Vai a Monetizzazione > Prodotti per sviluppatori .

2. Passa il mouse su una miniatura di 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 loro prodotti acquistati.Per farlo, devi:

• Usa l'API ProcessReceipt per controllare le ricevute di acquisto.ProcessReceipt Legge e riconosce automaticamente che un utente ha acquistato un prodotto al di fuori dell'esperienza.
• Valida ogni ricevuta per User ID , Developer Product ID e lo Statodel ricevente.
• Se la ricevuta ha uno stato di Aperto , concedi all'utente gli oggetti sviluppatore che ha acquistato.
• Rispondi all'API ProcessReceipt con un messaggio che riconosce la ricezione e convalida che gli oggetti acquistati sono stati concessi.

Puoi vendere prodotti per sviluppatori in due modi:

• All'interno della tua esperienza
• Al di fuori della tua esperienza

All'interno della tua esperienza

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

Usa 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 della tua esperienza, ad esempio.Per i prodotti per sviluppatori, il secondo parametro deve essere Enum.InfoType.Product .

local MarketplaceService = game:GetService("MarketplaceService")

-- Sostituisci l'ID del segnaposto con l'ID del prodotto sviluppatore
local productId = 000000

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

if success and productInfo then
	-- Mostra le informazioni sul prodotto
	-- Sostituisci le dichiarazioni di stampa con codice UI per visualizzare il prodotto
  print("Developer Product Name: " .. productInfo.Name)
  print("Price in Robux: " .. productInfo.PriceInRobux)
  print("Description: " .. productInfo.Description)
end

Usa GetDeveloperProductsAsync per recuperare tutti i prodotti per sviluppatori associati alla tua esperienza.Questa funzione restituisce un oggetto Pages che puoi ispezionare e filtrare per costruire cose come un negozio in-experience o una lista di prodotti GUI or Intefaccia grafica utente.

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 la dichiarazione di stampa con il codice UI per visualizzare il prodotto
			print(field .. ": " .. value)
	end
end

Usa PromptProductPurchase per richiedere l'acquisto di prodotti all'interno della tua esperienza.Puoi chiamare questa funzione quando un utente esegue azioni come premere un pulsante o parlare con un venditore NPC.

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

-- Sostituisci l'ID del segnaposto con l'ID del prodotto sviluppatore
local productId = 000000

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

    if success then
      print("Purchase prompt shown successfully")
		end
end

Puoi anche combinare funzioni all'interno di un LocalScript .Ad esempio, puoi creare un elemento UI come un pulsante o un NPC venditore, quindi usa GetProductInfo() per connettere un prodotto sviluppatore esistente a quell'elemento, controlla se il prodotto è In Venditae usa PromptProductPurchase() per richiedere un acquisto ogni volta che l'utente lo clicca.

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

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

-- Sostituisci l'ID del segnaposto con l'ID del prodotto sviluppatore
local productId = 000000

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

	if success and productInfo then
		-- Verifica se il prodotto è In Vendita
		if productInfo.IsForSale then
			print("This is for sale")
			-- Richiede l'Acquistadel prodotto
			MarketplaceService:PromptProductPurchase(player, productId)
		else
			-- Avvisa il prodotto non è In Vendita
			print("This product is not currently for sale.")
		end
	else
		print("Error retrieving product info: " .. tostring(productInfo))
	end
end)

Al di fuori della tua esperienza

Per abilitare gli acquisti di prodotti per sviluppatori al di fuori della tua esperienza, devi lavorare con l'API ProcessReceipt.Dopo che un utente effettua un acquisto nella scheda Negozio delle sue dettagli dell'esperienza, devi usare ProcessReceipt per confermare il loro acquisto e concedere loro i loro oggetti una volta che entrano nella tua esperienza.

Modalità di test

La funzione Modalità di test ti aiuta a validare il flusso di acquisto inserendo un prodotto per sviluppatori all'interno della tua esperienza.Dovresti usare la modalità di test per assicurarti di aver implementato correttamente ProcessReceipt prima di abilitare le vendite di prodotti sviluppatori esterni.

I prodotti per gli sviluppatori che metti in vendita in modalità test possono essere visti solo da te e da membri del tuo Gruppo. Non sono visibili agli utenti.

Per testare la tua implementazione:

1. Nel Creator Hub , vai a Monetizzazione > Prodotti per sviluppatori .
2. Fai clic sul menu ⋮ e seleziona Impostazioni acquisto esterno .
3. Nella pagina Impostazioni acquisto esterno , clicca Abilita modalità test .
4. Una volta attivo il modo di test, torna alla pagina Prodotti per sviluppatori e seleziona un prodotto da testare.
5. Nella pagina Impostazioni di base , seleziona il riquadro Consenti acquisti esterni e salva le tue modifiche.
6. Vai alla scheda Negozio della pagina dettagli dell'esperienza e acquista il prodotto che hai reso disponibile In Vendita.
7. Entra nell'esperienza e conferma di aver ricevuto il prodotto che hai acquistato.Lo stato della ricevuta dell'ProcessReceipt deve essere aggiornato 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 funzione per vendere prodotti per sviluppatori al di fuori delle tue esperienze.

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

Abilita le vendite esterne

Per abilitare le vendite esterne:

1. Vai alla pagina Impostazioni acquisto esterno .
2. Attiva Acquisti esterni .
3. Torna alla pagina Prodotti per sviluppatori e seleziona i prodotti che vuoi vendere al di fuori della tua esperienza.
4. Nella pagina Impostazioni di base , seleziona il riquadro Consenti acquisti esterni e salva le tue modifiche.
5. Conferma che i prodotti sono ora disponibili per l'acquisto nella scheda Negozio della pagina dettagli dell'esperienza.

Per disabilitare la vendita esterna di un prodotto sviluppatore, seleziona il prodotto sulla pagina Prodotti per sviluppatori e annulla la casella di controllo Consenti acquisti esterni .

Limitazioni

• Gli oggetti in vendita in modalità test costano Robux effettivi. Consigliamo di testare prodotti sviluppatori a basso costo.
• Gli oggetti in vendita in modalità test possono essere visti solo da te o da membri del tuo Gruppo.
• Per essere venduti esternamente, i prodotti del tuo sviluppatore devono avere una Miniatura.
• Non dovresti vendere quanto segue al di fuori della tua esperienza:

  • Oggetti casuali pagati
  • Oggetti che sono limitati a quantità specifiche, tempo, Postoo ruoli di utente

Gestisci l'acquisto di un prodotto per Acquista

Dopo che un utente acquista un prodotto per sviluppatori, devi gestire e registrare la transazione.Per farlo, usa un Script all'interno di ServerScriptService utilizzando la funzione ProcessReceipt.

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

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

local productFunctions = {}

-- Esempio: l'ID prodotto 123123 riporta l'utente alla 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 Acquistariuscito
		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 handler associata all'ID prodotto sviluppatore e tenta di eseguirlo
		local handler = productFunctions[productId]
		local success, result = pcall(handler, receiptInfo, player)
		if success then
			-- L'utente ha ricevuto i suoi oggetti
			-- Restituisce "PurchaseGranted" per confermare la transazione
			return Enum.ProductPurchaseDecision.PurchaseGranted
		else
			warn("Failed to process receipt:", receiptInfo, result)
		end
	end

	-- Gli oggetti dell'utente non potrebbero essere assegnati
	-- Restituisce "NonProcessedYet" e riprova la prossima volta che l'utente si unisce all'esperienza
	return Enum.ProductPurchaseDecision.NotProcessedYet
end

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

Analisi del prodotto sviluppatore

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

Con l'analisi, puoi:

• Visualizza i tuoi prodotti per sviluppatori principali in un periodo di tempo selezionato.
• Mostra fino a otto articoli più venduti su un grafico di serie temporale per analizzare le vendite complessive e le entrate nette.
• Monitora il tuo catalogo e ordina gli elementi per vendite e ricavi netti.

Per accedere all'analisi dei prodotti degli sviluppatori:

1. Vai a Creazioni e seleziona un'esperienza.
2. Vai a Monetizzazione > Prodotti per sviluppatori .
3. Seleziona la scheda Analitica .