Entwicklerprodukte

Ein Entwicklerprodukt ist ein Gegenstand oder eine Fähigkeit, die ein Benutzer mehr als einmal kaufen kann, wie z. B. In-Game-Währung, Munition oder Tränke.

Erstellen eines Entwicklerprodukts

Um ein Entwicklerprodukt zu erstellen:

1. Gehe zu Kreationen und wähle ein Spiel aus.
2. Gehe zu Monetarisierung ⟩ Entwicklerprodukte.
3. Klicke auf Entwicklerprodukt erstellen.
4. Lade ein Bild hoch, das als Produktikone angezeigt werden soll. Vergewissern Sie sich, dass das Bild 512x512 Pixel nicht überschreitet, keine wichtigen Details außerhalb seiner kreisförmigen Grenzen enthält und im Format .jpg, .png oder .bmp vorliegt.
5. Gib einen Namen und eine Beschreibung für das Produkt ein.
6. Wähle eine Kategorie für das Produkt aus. Die Kategorie dient dazu, Gegenstände in deinem In-Game-Shop zu organisieren.
7. Setze den Produktpreis in Robux. Der Mindestpreis beträgt 1 Robux, der Höchstpreis 1 Milliarde Robux.
8. Klicke auf Änderungen speichern.

Erhalte die Entwicklerprodukt-ID

Um zu skripten, benötigst du eine Entwicklerprodukt-ID. Um die Produkt-ID zu erhalten:

1. Gehe zu Monetarisierung ⟩ Entwicklerprodukte.

2. Fahre mit der Maus über das Thumbnail eines Produkts, klicke auf die ⋯-Schaltfläche und wähle Asset-ID kopieren aus dem Kontextmenü.

   

Verkaufe ein Entwicklerprodukt

Bevor du Entwicklerprodukte verkaufst, stelle sicher, dass du Verkaufsbelege ordnungsgemäß verarbeitest und den Benutzern ihre gekauften Produkte bereitstellst. Dazu musst du:

• Die ProcessReceipt API verwenden, um Kaufbelege zu überprüfen. ProcessReceipt liest und erkennt automatisch, dass ein Benutzer ein Produkt außerhalb des Spiels gekauft hat.
• Jeden Beleg auf Benutzer-ID, Developer Product ID und den Status des Belegs validieren.
• Wenn der Beleg den Status Offen hat, gewähre dem Benutzer die Entwicklergegenstände, die er gekauft hat.
• Antworte der ProcessReceipt API mit einer Nachricht, die den Beleg anerkennt und bestätigt, dass die gekauften Gegenstände gewährt wurden.

Du kannst Entwicklerprodukte auf zwei Arten verkaufen:

• In deinem Spiel
• Außerhalb deines Spiels

In deinem Spiel

Um ein Entwicklerprodukt innerhalb eines Spiels zu implementieren und zu verkaufen, rufe die Funktionen MarketplaceService auf.

Verwende GetProductInfo, um Informationen über ein Entwicklerprodukt abzurufen, wie z. B. Name und Preis, und um dieses Produkt dann den Benutzern anzuzeigen. Du kannst das Produkt beispielsweise im Marktplatz deines Spiels verkaufen. 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 Druckanweisungen durch UI-Code, um das Produkt anzuzeigen
    print("Entwicklerproduktname: " .. productInfo.Name)
    print("Preis in Robux: " .. productInfo.PriceInRobux)
    print("Beschreibung: " .. productInfo.Description)
end

Verwende GetDeveloperProductsAsync, um alle Entwicklerprodukte abzurufen, die mit deinem Spiel verknüpft sind. Diese Funktion gibt ein Pages-Objekt zurück, das du untersuchen und filtern kannst, um Dinge wie einen In-Game-Shop oder eine Produktlisten-GUI zu erstellen.

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

Verwende PromptProductPurchase, um den Kauf von Produkten innerhalb deines Spiels anzuregen. Du kannst diese Funktion aufrufen, wenn ein Benutzer Aktionen wie das Drücken eines Buttons oder das Sprechen mit einem NPC-Händler ausführt.

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("Kaufaufforderung erfolgreich angezeigt")
		end
end

Du kannst auch Funktionen innerhalb eines LocalScript kombinieren. Zum Beispiel kannst du ein UI-Element wie einen Button oder einen NPC-Händler erstellen, dann GetProductInfo() verwenden, um ein vorhandenes Entwicklerprodukt mit diesem Element zu verbinden, zu prüfen, ob das Produkt zum Verkauf steht, und PromptProductPurchase() aufzurufen, um eine Aufforderung zum Kauf jedes Mal anzuzeigen, wenn 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

	-- Ruft Produktinformationen ab, 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 steht
		if productInfo.IsForSale then
			print("Dieses Produkt steht zum Verkauf")
			-- Fordert den Produktkauf an
			MarketplaceService:PromptProductPurchase(player, productId)
		else
			-- Benachrichtigt, dass das Produkt nicht zum Verkauf steht
			print("Dieses Produkt ist derzeit nicht zum Verkauf.")
		end
	else
		print("Fehler beim Abrufen der Produktinformationen: " .. tostring(productInfo))
	end
end)

Außerhalb deines Spiels

Um den Kauf von Entwicklerprodukten außerhalb deines Spiels zu ermöglichen, musst du mit der ProcessReceipt API arbeiten. Nachdem ein Benutzer einen Kauf im Store-Tab deiner Spiel-Detailseite getätigt hat, musst du ProcessReceipt verwenden, um ihren Kauf zu bestätigen und ihnen ihre Gegenstände zu gewähren, sobald sie dein Spiel betreten.

Testmodus

Die Testmodus-Funktion hilft dir, deinen Kaufablauf zu validieren, indem sie einen Kauf eines Entwicklerprodukts außerhalb deines Spiels simuliert. Du solltest den Testmodus verwenden, um sicherzustellen, dass du ProcessReceipt korrekt implementiert hast, bevor du externe Verkäufer von Entwicklerprodukten aktivierst.

Die Entwicklerprodukte, die du im Testmodus zum Verkauf anbietest, 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. Gehe zum Creator Hub und dann zu Monetarisierung ⟩ Entwicklerprodukte.
2. Klicke im ⋮-Menü auf Einstellungen für externe Käufe.
3. Klicke auf der Seite Einstellungen für externe Käufe auf Testmodus aktivieren.
4. Sobald der Testmodus aktiv ist, kehre zur Seite Entwicklerprodukte zurück und wähle ein Produkt zum Testen aus.
5. Wähle auf der Seite Grundlegende Einstellungen die Checkbox Externe Käufe erlauben aus und speichere deine Änderungen.
6. Gehe zum Store-Tab der Spiel-Detailseite und kaufe das Produkt, das du zum Verkauf verfügbar gemacht hast.
7. Betritt das Spiel und bestätige, dass du das Produkt erhalten hast, das du gekauft hast. Der Belegstatus der ProcessReceipt API sollte auf Geschlossen aktualisiert werden.

Nachdem du deine Implementierung getestet hast, verifiziert Roblox, dass der Test erfolgreich abgeschlossen wurde, und ermöglicht dir, die Funktion zum Verkauf von Entwicklerprodukten außerhalb deiner Spiele vollständig zu aktivieren.

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

Aktiviere externe Verkäufe

Um externe Verkäufe zu aktivieren:

1. Gehe zur Seite Einstellungen für externe Käufe.
2. Schalte Externe Käufe ein.
3. Kehre zur Seite Entwicklerprodukte zurück und wähle die Produkte aus, die du außerhalb deines Spiels verkaufen möchtest.
4. Wähle auf der Seite Grundlegende Einstellungen die Checkbox Externe Käufe erlauben aus und speichere deine Änderungen.
5. Bestätige, dass die Produkte jetzt im Store-Tab der Spiel-Detailseite zum Kauf angeboten werden.

Um den externen Verkauf eines Entwicklerprodukts zu deaktivieren, wähle das Produkt auf der Seite Entwicklerprodukte aus und entferne das Häkchen bei Externe Käufe erlauben.

Einschränkungen

• Gegenstände, die im Testmodus zum Verkauf stehen, kosten tatsächliche Robux. Wir empfehlen, kostengünstige Entwicklerprodukte zu testen.
• Gegenstände, die im Testmodus zum Verkauf stehen, können nur von dir oder von Mitgliedern deiner Gruppe gesehen werden.
• Damit deine Entwicklerprodukte extern verkauft werden können, müssen sie ein Thumbnail haben.
• Du solltest Folgendes nicht außerhalb deines Spiels verkaufen:

  • Bezahlte zufällige Gegenstände
  • Gegenstände, die auf bestimmte Mengen, Zeiten, Orte oder Benutzereinstellungen und Rollen beschränkt sind

Verarbeite den Kauf eines Entwicklerprodukts

Nachdem ein Benutzer ein Entwicklerprodukt gekauft hat, musst du die Transaktion bearbeiten und aufzeichnen. Dazu verwendest du ein Script innerhalb von ServerScriptService, das die Funktion ProcessReceipt verwendet.

Für weitere Informationen über die ProcessReceipt API und ihre Implementierung 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
		-- Markiert einen erfolgreichen Kauf
		return true
	end
end

-- Beispiel: Produkt-ID 456456 belohnt den Benutzer mit 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
		-- Ruft die Handlerfunktion ab, die mit der Entwicklerprodukt-ID verknüpft ist, und versucht, sie auszuführen
		local handler = productFunctions[productId]
		local success, result = pcall(handler, receiptInfo, player)
		if success then
			-- Der Benutzer hat seine Gegenstände erhalten
			-- Gibt "PurchaseGranted" zurück, um die Transaktion zu bestätigen
			return Enum.ProductPurchaseDecision.PurchaseGranted
		else
			warn("Beleg konnte nicht verarbeitet werden:", receiptInfo, result)
		end
	end

	-- Die Gegenstände des Benutzers konnten nicht gewährt werden
	-- Gibt "NotProcessedYet" zurück und versucht es beim nächsten Mal, wenn der Benutzer das Spiel betritt, erneut
	return Enum.ProductPurchaseDecision.NotProcessedYet
end

-- Setzt den Callback
-- Dies kann nur einmal von einem serverseitigen Skript durchgeführt werden
MarketplaceService.ProcessReceipt = processReceipt

Personalisieren Sie Ihren In-Game-Shop

Du kannst Produktintelligenz-APIs verwenden, um Entwicklerprodukte zu sortieren und Benutzern zu empfehlen. Die Personalisierung deines In-Game-Shops hilft, die relevantesten Gegenstände für jeden Benutzer zu finden, was das Engagement und den Umsatz steigert. Durch die Anpassung von Entwicklerprodukten an die Benutzerpräferenzen kannst du ihre Auffindbarkeit verbessern, die Konversionsraten erhöhen und neue Monetarisierungsmöglichkeiten erschließen.

Bewerte Entwicklerprodukte zum Verkauf

RankProductsAsync nimmt eine Liste von Produkt-IDs entgegen und gibt eine personalisierte, geordnete Liste dieser Produkte zurück. Du kannst diese Methode verwenden, um deinen Benutzern personalisierte Artikelempfehlungen in deinem In-Game-Shop bereitzustellen.

local MarketplaceService = game:GetService("MarketplaceService")

-- Erstelle ein Array von Produkten, die du einstufen möchtest
local productIdentifiers = {
    {InfoType = Enum.InfoType.GamePass, Id = 123},
    {InfoType = Enum.InfoType.Product, Id = 456},
    {InfoType = Enum.InfoType.Product, Id = 789}
}

-- Mach einen geschützten Aufruf, um Fehler zu behandeln
local success, rankedProducts = pcall(function()
    return MarketplaceService:RankProductsAsync(productIdentifiers)
end)

if not success then
    error("Fehler beim Einstufen der Produkte")
end

-- Lade die zurückgegebenen Artikel in den Shop
for i, rankedItem in ipairs(rankedProducts) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logik, um Produkte in den Shop hinzuzufügen
end

Zeige deine besten Entwicklerprodukte an

RecommendTopProductsAsync nimmt ein Array von InfoType-Werten und gibt bis zu 50 Artikel zurück, mit denen ein Benutzer mit hoher Wahrscheinlichkeit interagieren und die er kaufen wird. Du kannst diese Methode verwenden, um einen "Top Picks"-Bereich in deinem In-Game-Shop zu erstellen.

Wenn keine Empfehlungen bestimmt werden können, gibt RecommendTopProductsAsync 0 Artikel zurück.

In seltenen Fällen können Aufrufe an das Ranking-Modell langsam sein. Um zu verhindern, dass es für Benutzer später hinzugefügt wird, empfehlen wir, task.spawn zu verwenden, um den Aufruf an RecommendTopProducts nicht blockierend zu gestalten.

local MarketplaceService = game:GetService("MarketplaceService")

-- Erstelle ein Array von Produkttypen, die du in die Empfehlungen einbeziehen möchtest -- Dieses Beispiel umfasst sowohl Pässe als auch Entwicklerprodukte
local productTypes = {Enum.InfoType.GamePass, Enum.InfoType.Product}

-- Mach einen geschützten Aufruf, um Fehler zu behandeln
local success, topRankedItems = pcall(function()
    return MarketplaceService:RecommendTopProductsAsync(productTypes)
end)

if not success then
    error("Fehler beim Einstufen der Produkte")
end

-- Lade die zurückgegebenen Artikel in den Shop
-- Stelle sicher, dass du alle nicht berechtigten Artikel aus topRankedItems herausfilterst, zum Beispiel Entwicklerprodukte, die der Benutzer nicht mehr kaufen kann
for i, rankedItem in ipairs(topRankedItems) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logik, um Produkte in den Shop hinzuzufügen
end

Entwicklerprodukte-Analyse

Verwende die Entwicklerprodukte-Analyse, um den Erfolg einzelner Produkte zu analysieren, Trends zu identifizieren und potenzielle zukünftige Einnahmen zu prognostizieren.

Mit Analysen kannst du:

• Deine besten Entwicklerprodukte über einen ausgewählten Zeitraum anzeigen.
• Bis zu acht meistverkaufte Artikel in einem Zeitreihendiagramm anzeigen, um die Gesamverkäufe und den Nettoumsatz zu analysieren.
• Deinen Katalog überwachen und Artikel nach Verkäufen und Nettoumsatz sortieren.

Um auf die Entwicklerprodukte-Analyse zuzugreifen:

1. Gehe zu Kreationen und wähle ein Spiel aus.
2. Gehe zu Monetarisierung ⟩ Entwicklerprodukte.
3. Wähle die Registerkarte Analyse.