Entwicklerprodukte

Ein Entwicklerprodukt ist ein Artikel oder eine Fähigkeit, die ein Benutzer mehr als einmal kaufen kann, wie z. B. Währung in der Erfahrung, Munition oder Tränke.

Erstelle ein Entwicklerprodukt

Um ein Entwicklerprodukt zu erstellen:

1. Gehe zu Kreationen und wähle ein Erlebnis aus.
2. Gehe zu Monetarisierung > Entwicklerprodukte .
3. Klicken Sie auf Erstellen eines Entwicklerprodukts .
4. Lade ein Bild hoch, um es als Symbolanzuzeigen.Stellen Sie sicher, dass das Bild nicht mehr als 512x512 Pixel beträgt, keine wichtigen Details außerhalb seiner runden Grenzen enthält und im .jpg , .png oder .bmp -Format ist.
5. Geben Sie einen Namen und eine Beschreibung für das Produkt ein.
6. Stelle den Produktpreis in Robux fest. Der Mindestpreis beträgt 1 Robux, und der maximale Preis beträgt 1 Milliarde Robux.
7. Klicken Sie auf Entwicklerprodukt erstellen .

Holen Sie sich die Entwicklerprodukt-ID

Um Scriptingzu verwenden, benötigen Sie eine Entwicklerprodukt-ID. Um die Produkt-ID zu erhalten:

1. Gehe zu Monetarisierung > Entwicklerprodukte .

2. Bewegen Sie den Mauszeiger über die Miniaturansicht eines Produkts, klicken Sie auf die Schaltfläche ⋯ und wählen Sie Kopiere Asset-ID aus dem Kontextmenü.

   

Verkaufe ein Entwicklerprodukt

Bevor du Entwicklerprodukte verkaufst, stelle sicher, dass du Rechnungen richtig verarbeitest und Benutzern ihre gekauften Produkte gewährst.Um dies zu tun, musst du:

• Verwende die ProcessReceipt, um Rechnungen für den Kauf zu überprüfen.ProcessReceipt liest und bestätigt automatisch, dass ein Benutzer ein Produkt außerhalb der Erlebnisgekauft hat.
• Überprüfe jede Rechnung für User ID, Developer Product ID und den Status.
• Wenn die Rechnung einen Status von Offen hat, gewähre dem Benutzer die Entwicklerartikel, die er gekauft hat.
• Reagiere auf die ProcessReceipt API mit einer Nachricht, die die Erhaltbestätigung akzeptiert und bestätigt, dass die gekauften Artikel gewährt wurden.

Du kannst Entwicklerprodukte auf zwei Arten verkaufen:

• Innerhalb deiner Erfahrung
• Außerhalb deiner Erfahrung

Innerhalb deiner Erlebnis

Um ein Entwicklerprodukt innerhalb einer Erlebniszu implementieren und zu verkaufen, rufe MarketplaceService Funktionen auf.

Verwende GetProductInfo, um Informationen über ein Entwicklerprodukt wie Name und Preis abzurufen, und zeige dann dieses Produkt den Benutzern an.Du kannst das Produkt zum Beispiel auf dem Marktplatz deiner Erlebnisverkaufen.Für Entwicklerprodukte muss der zweite Parameter Enum.InfoType.Product sein.

local MarketplaceService = game:GetService("MarketplaceService")

-- Ersetze die Platzhalter-ID durch deine Entwicklerprodukt-ID
local productId = 000000

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

if success and productInfo then
	-- Produktinformationen anzeigen
	-- Ersetze die Druckausdrücke durch UI-Code, um das Produkt anzuzeigen
  print("Developer Product Name: " .. productInfo.Name)
  print("Price in Robux: " .. productInfo.PriceInRobux)
  print("Description: " .. productInfo.Description)
end

Verwende GetDeveloperProductsAsync, um alle Entwicklerprodukte wiederzugeben, die mit deiner Erfahrung verbunden sind.Diese Funktion gibt ein Pages Objekt zurück, das Sie inspizieren und filtern können, um Dinge wie einen Erlebnisladen oder eine grafische Benutzeroberflächezu bauen.

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
			-- Ersetze die Druckausgabe durch UI-Code, um das Produkt anzuzeigen
			print(field .. ": " .. value)
	end
end

Verwende PromptProductPurchase, um Produktkäufe innerhalb deiner Erlebniszu veranlassen.Sie können diese Funktion aufrufen, wenn ein Benutzer Aktionen ausführt, wie zum Beispiel einen Knopf drücken oder mit einem Verkäufer-NPC sprechen.

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

-- Ersetze die Platzhalter-ID durch deine Entwicklerprodukt-ID
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

Du kannst auch Funktionen innerhalb eines LocalScript kombinieren.Zum Beispiel können Sie ein UI-Element wie eine Schaltfläche oder einen Hersteller-NPC erstellen, dann GetProductInfo() verwenden, um ein vorhandenes Entwicklerprodukt mit diesem Element zu verbinden, überprüfen, ob das Produkt zum Verkauf stehensteht, und PromptProductPurchase() verwenden, um den Kauf zu veranlassen, wann immer der Benutzer darauf klickt.

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

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

-- Ersetze die Platzhalter-ID durch deine Entwicklerprodukt-ID
local productId = 000000

	-- Holen Sie sich Produktinformationen, wenn der Benutzer auf die UI-Schaltfläche klickt
button.MouseButton1Click:Connect(function()
	local success, productInfo = pcall(function()
		return MarketplaceService:GetProductInfo(productId, Enum.InfoType.Product)
	end)

	if success and productInfo then
		-- Überprüft, ob das Produkt zum Verkauf stehensteht
		if productInfo.IsForSale then
			print("This is for sale")
			-- Fragen zur kaufen
			MarketplaceService:PromptProductPurchase(player, productId)
		else
			-- Benachrichtigt, dass das Produkt nicht zum Verkauf stehensteht
			print("This product is not currently for sale.")
		end
	else
		print("Error retrieving product info: " .. tostring(productInfo))
	end
end)

Außerhalb deiner Erlebnis

Um Entwicklerproduktkäufe außerhalb deiner Erlebniszu aktivieren, musst du mit der ProcessReceipt arbeiten.Nachdem ein Benutzer einen Kauf in der Laden-Registerkarte Ihrer Erfahrungsdetailsseite getätigt hat, müssen Sie verwenden, um seine Kaufbestätigung zu erteilen und ihm seine Artikel zu gewähren, sobald er Ihre Erlebnisbetritt.

Testmodus

Die Test-Modus -Funktion hilft dir, deinen Kaufprozess zu validieren, indem du ein Entwicklerprodukt außerhalb deiner Erlebniskaufst.Du solltest den Testmodus verwenden, um sicherzustellen, dass du ProcessReceipt korrekt implementiert hast, bevor du externe Entwicklerproduktverkäufe aktivierst.

Die Entwicklerprodukte, die du im Testmodus zum Verkauf stellst, können nur von dir und von Mitgliedern deiner Gruppe gesehen werden. Sie sind für Benutzer nicht sichtbar.

Um deine Implementierung zu testen:

1. Im Creator-Hub , gehe zu Monetarisierung > Entwicklerprodukte .
2. Klicken Sie auf das ⋮ -Menü und wählen Sie Externe Einkaufsoptionen .
3. Auf der Seite Externe Einkaufs-Einstellungen klicken Sie auf Testmodus aktivieren .
4. Sobald der Testmodus aktiv ist, kehre zur Entwicklerprodukte Seite zurück und wähle ein Produkt zum Testen aus.
5. Auf der Seite Grundeinstellungen wählen Sie die Externe Einkäufe zulassen -Checkbox aus und speichern Sie Ihre Änderungen.
6. Gehe auf die Laden -Registerkarte der Detailseite des Erlebnisses und kaufe das Produkt, das du zum Verkauf stehenbereitgestellt hast.
7. Geben Sie die Erfahrung ein und bestätigen Sie, dass Sie das Produkt erhalten haben, das Sie gekauft haben.Der Rechnungsstatus der ProcessReceipt API sollte auf Geschlossen aktualisiert werden.

Nachdem du deine Implementierung getestet hast, überprüft Roblox, dass der Test erfolgreich abgeschlossen wurde, und ermöglicht es dir, das Feature vollständig zu aktivieren, um Entwicklerprodukte außerhalb deiner Erlebnisse zu verkaufen.

Für weitere Informationen über die ProcessReceipt API und ihre Umsetzung, siehe die Seite ProcessReceipt.

Aktiviere externe Verkäufe

Um externe Verkäufe zu aktivieren:

1. Gehe auf die externen Einkaufs-Einstellungen Seite.
2. Schalte Externe Einkäufe ein.
3. Kehre zur Entwicklerprodukte Seite zurück und wähle die Produkte aus, die du außerhalb deiner Erlebnisverkaufen möchtest.
4. Auf der Seite Grundeinstellungen wählen Sie die Externe Einkäufe zulassen -Checkbox aus und speichern Sie Ihre Änderungen.
5. Bestätigen Sie, dass die Produkte jetzt im Laden -Tab der Detailseite der Erfahrung zum Kauf verfügbar sind.

Um den externen Verkauf eines Entwicklerprodukts zu deaktivieren, wählen Sie das Produkt auf der Entwicklerprodukte -Seite aus und löschen Sie die Externe Einkäufe zulassen -Checkbox.

Beschränkungen

• Artikel zum Verkauf im Testmodus kosten echte Robux. Wir empfehlen niedrige Kostenentwicklerprodukte zu testen.
• Artikel zum Verkauf im Testmodus können nur von dir oder von Mitgliedern deiner Gruppe gesehen werden.
• Um extern verkauft zu werden, müssen deine Entwicklerprodukte eine Miniaturansichthaben .
• Du solltest nicht das Folgende außerhalb deiner Erlebnisverkaufen:

  • Bezahlte zufällige Artikel
  • Artikel, die sich auf bestimmte Mengen, Zeit, Ort oder Benutereinstellungen und Rollen beschränken

Behandle den Kauf eines Entwicklerprodukts

Nachdem ein Benutzer ein Entwicklerprodukt gekauft hat, musst du die Transaktion bearbeiten und aufzeichnen.Um dies zu tun, verwende eine Script innerhalb von ServerScriptService mit der Funktion ProcessReceipt.

Für weitere Informationen über die ProcessReceipt API und ihre Umsetzung, siehe die Seite ProcessReceipt.

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

local productFunctions = {}

-- Beispiel: Produkt-ID 123123 bringt den Benutzer zurück zu voller Gesundheit
productFunctions[123123] = function(receipt, player)
	local character = player.Character
	local humanoid = character and character:FindFirstChildWhichIsA("Humanoid")

	if humanoid then
		humanoid.Health = humanoid.MaxHealth
		-- Weist auf einen erfolgreichen kaufenhin
		return true
	end
end

-- Beispiel: Produkt-ID 456456 verleiht dem Benutzer 100 Goldmünzen
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
		-- Holen Sie sich die Handlerfunktion, die mit der Produkt-ID des Entwicklers verbunden ist, und versuchen Sie, sie auszuführen
		local handler = productFunctions[productId]
		local success, result = pcall(handler, receiptInfo, player)
		if success then
			-- Der Benutzer hat seine Artikel erhalten
			-- Gibt "Kauf gewährt" zurück, um die Transaktion zu bestätigen
			return Enum.ProductPurchaseDecision.PurchaseGranted
		else
			warn("Failed to process receipt:", receiptInfo, result)
		end
	end

	-- Die Items des Benutzers konnten nicht verliehen werden
	-- Gibt "Noch nicht verarbeitet" zurück und versucht es beim nächsten Mal, wenn der Benutzer der Erlebnisbeitritt
	return Enum.ProductPurchaseDecision.NotProcessedYet
end

-- Setzt den Callback
-- Dies kann nur einmal von einem Skript, das. PL: die Skriptsdurchgeführt werden
MarketplaceService.ProcessReceipt = processReceipt

Entwicklerprodukt-Analysen

Verwende die Produktanalysen von Entwicklern, um den Erfolg einzelner Produkte zu analysieren, Trends zu identifizieren und potenzielle zukünftige Einnahmen vorherzusagen.

Mit Analysen kannst du:

• Sehen Sie sich Ihre besten Entwicklerprodukte über einen ausgewählten Zeitraum an.
• Zeige bis zu acht meistverkaufte Artikel auf einem Zeitreihendiagramm, um die Gesamtverkäufe und den Nettoerlös zu analysieren.
• Überwachen Sie Ihren Katalog und sortieren Sie Artikel nach Umsatz und Nettoeinnahmen.

Um auf die Analysefür Entwickler zuzugreifen:

1. Gehe zu Kreationen und wähle ein Erlebnis aus.
2. Gehe zu Monetarisierung > Entwicklerprodukte .
3. Wählen Sie die Analytics -Registerkarte.