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. Gehen Sie zu Erstellungen und wählen Sie ein Spiel aus.
2. Gehen Sie zu Monetarisierung ⟩ Entwicklerprodukte.
3. Klicken Sie auf Entwicklerprodukt erstellen.
4. Laden Sie ein Bild hoch, das als Produkt-Icon angezeigt wird. Stellen Sie sicher, dass das Bild nicht größer als 512x512 Pixel ist, keine wichtigen Details außerhalb seiner kreisförmigen Grenzen enthält und im Format .jpg, .png oder .bmp vorliegt.
5. Geben Sie einen Namen und eine Beschreibung für das Produkt ein.
6. Wählen Sie eine Kategorie für das Produkt aus. Die Kategorie wird verwendet, um Gegenstände in Ihrem In-Game-Shop zu organisieren.
7. Setzen Sie den Produktpreis in Robux. Der Mindestpreis beträgt 1 Robux, der Höchstpreis 1 Milliarde Robux.
8. Klicken Sie auf Änderungen speichern.

Holen Sie sich die Entwicklerprodukt-ID

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

1. Gehen Sie zu Monetarisierung ⟩ Entwicklerprodukte.

2. Fahren Sie mit der Maus über das Thumbnail eines Produkts, klicken Sie auf die ⋯-Schaltfläche und wählen Sie Asset-ID kopieren aus dem Kontextmenü.

   

Verkaufen eines Entwicklerprodukts

Bevor Sie Entwicklerprodukte verkaufen, stellen Sie sicher, dass Sie Verkaufsbelege ordnungsgemäß verarbeiten und den Benutzern ihre gekauften Produkte gewähren. Dazu müssen Sie:

• Verwenden Sie die ProcessReceipt API, um Kaufbelege zu überprüfen. ProcessReceipt liest automatisch und bestätigt, dass ein Benutzer ein Produkt außerhalb des Spiels gekauft hat.
• Validieren Sie jeden Beleg auf Benutzer-ID, Entwicklerprodukt-ID und den Belegstatus.
• Wenn der Beleg den Status Offen hat, gewähren Sie dem Benutzer die Entwicklergegenstände, die er gekauft hat.
• Antworten Sie auf die ProcessReceipt API mit einer Nachricht, die den Beleg anerkennt und bestätigt, dass die gekauften Gegenstände gewährt wurden.

Sie können Entwicklerprodukte auf zwei Arten verkaufen:

• Innerhalb Ihres Spiels
• Außerhalb Ihres Spiels

Innerhalb Ihres Spiels

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

Verwenden Sie GetProductInfo, um Informationen über ein Entwicklerprodukt abzurufen, wie Name und Preis, und um dieses Produkt den Benutzern anzuzeigen. Sie können das Produkt beispielsweise im Marktplatz Ihres Spiels verkaufen. Für Entwicklerprodukte muss der zweite Parameter Enum.InfoType.Product sein.

local MarketplaceService = game:GetService("MarketplaceService")

-- Ersetzen Sie die Platzhalter-ID durch Ihre 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
	-- Ersetzen Sie die Druckanweisungen durch UI-Code, um das Produkt anzuzeigen
  print("Name des Entwicklerprodukts: " .. productInfo.Name)
  print("Preis in Robux: " .. productInfo.PriceInRobux)
  print("Beschreibung: " .. productInfo.Description)
end

Verwenden Sie GetDeveloperProductsAsync, um alle Entwicklerprodukte abzurufen, die mit Ihrem Spiel verbunden sind. Diese Funktion gibt ein Pages-Objekt zurück, das Sie inspizieren und filtern können, um Dinge wie einen In-Game-Shop oder eine Produktliste-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
			-- Ersetzen Sie die Druckanweisung durch UI-Code, um das Produkt anzuzeigen
			print(field .. ": " .. value)
	end
end

Verwenden Sie PromptProductPurchase, um Produktkäufe innerhalb Ihres Spiels anzufordern. Sie können diese Funktion aufrufen, wenn ein Benutzer Aktionen wie das Drücken eines Buttons oder das Sprechen mit einem Verkäufer-NPC ausführt.

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

-- Ersetzen Sie die Platzhalter-ID durch Ihre 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

Sie können auch Funktionen innerhalb eines LocalScript kombinieren. Zum Beispiel können Sie ein UI-Element wie einen Button oder einen Verkäufer-NPC erstellen, dann GetProductInfo() verwenden, um ein vorhandenes Entwicklerprodukt mit diesem Element zu verbinden, zu überprüfen, ob das Produkt zum Verkauf steht, und PromptProductPurchase() verwenden, um eine Kaufaufforderung anzuzeigen, wann immer der Benutzer darauf klickt.

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

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

-- Ersetzen Sie die Platzhalter-ID durch Ihre 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 ist 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 Ihres Spiels

Um Käufe von Entwicklerprodukten außerhalb Ihres Spiels zu ermöglichen, müssen Sie mit der ProcessReceipt API arbeiten. Nachdem ein Benutzer einen Kauf im Store-Tab Ihrer Spiel-Detailseite getätigt hat, müssen Sie ProcessReceipt verwenden, um seinen Kauf zu bestätigen und ihm seine Gegenstände zu gewähren, sobald er Ihr Spiel betritt.

Externe Verkäufe aktivieren

Roblox zeigt Ihre Aufgelisteten Entwicklerprodukte und Spielpässe außerhalb Ihres Spiels an, einschließlich auf der Roblox-Startseite, in Suchergebnissen und auf der Seite nach dem Kauf, nachdem ein Spieler Robux gekauft hat. Ein Spieler kann Ihr Produkt kaufen und dann Ihrem Spiel beitreten, wobei es bereits gewährt wurde.

Um ein Entwicklerprodukt für externe Verkäufe bereitzustellen:

1. Gehen Sie im Creator Hub zu Monetarisierung ⟩ Shop.
2. Markieren Sie das Entwicklerprodukt als Aufgelistet.
3. Bestätigen Sie, dass Sie ProcessReceipt korrekt für das Produkt implementiert haben.

Spielpässe erfordern keine ProcessReceipt-Korrektur, müssen jedoch ebenfalls Aufgelistet sein, um außerhalb Ihres Spiels angezeigt zu werden. Wir empfehlen, jedem Entwicklerprodukt ein benutzerdefiniertes Icon hinzuzufügen, damit die Spieler es auf externen Oberflächen erkennen können; wenn Sie kein Icon hinzufügen, zeigt Roblox ein Standardicon an.

Für weitere Informationen zur ProcessReceipt-API und deren Implementierung siehe die Seite ProcessReceipt.

Beheben eines markierten Entwicklerprodukts

Wenn Roblox ein Problem mit einer Ihrer Aufgelisteten Entwicklerprodukte in Bezug auf ProcessReceipt feststellt, erscheint ein Banner in Creator Hub ⟩ Monetarisierung ⟩ Shop, das zu einem Bericht über die betroffenen Produkte verlinkt. Wenn keines Ihrer Entwicklerprodukte eine Korrektur benötigt, erscheint kein Banner oder Bericht.

Um ein markiertes Entwicklerprodukt zu beheben:

1. Öffnen Sie den Bericht aus dem Banner. Der Bericht listet jedes Aufgelistete Entwicklerprodukt auf, das eine ProcessReceipt-Korrektur benötigt, zusammen mit seinem Produktnamen und seiner Produkt-ID.
2. Öffnen Sie Ihr Spiel in Roblox Studio und beheben Sie die ProcessReceipt-Implementierung für das markierte Produkt.
3. Veröffentlichen Sie Ihr Spiel.
4. Wählen Sie im Bericht die behobenen Produkte aus und klicken Sie auf Als behoben markieren.

Behobene Produkte verlassen den Bericht und sind wieder berechtigt, außerhalb Ihres Spiels angezeigt zu werden.

Einschränkungen

• Um außerhalb Ihres Spiels verkauft zu werden, muss ein Entwicklerprodukt Aufgelistet sein und die ProcessReceipt korrekt implementiert haben.
• Unaufgelistete Entwicklerprodukte erscheinen niemals im Shop oder außerhalb Ihres Spiels.
• Der Verkauf eines Entwicklerprodukts außerhalb Ihres Spiels ändert nicht Ihre standardmäßigen Einnahmen oder Kaufabwicklungen.

Häufig gestellte Fragen

Verarbeiten eines Entwicklerproduktkaufs

Nachdem ein Benutzer ein Entwicklerprodukt gekauft hat, müssen Sie die Transaktion verarbeiten und aufzeichnen. Dazu verwenden Sie ein Script innerhalb von ServerScriptService, das die Funktion ProcessReceipt verwendet.

Für weitere Informationen zur ProcessReceipt-API und deren 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
		-- Zeigt einen erfolgreichen Kauf an
		return true
	end
end

-- Beispiel: Produkt-ID 456456 gewährt 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
		-- 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("Fehler beim Verarbeiten des Belegs:", 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 dem Spiel beitritt
	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

Sie können Produktintelligenz-APIs verwenden, um Entwicklerprodukte zu sortieren und Benutzern zu empfehlen. Die Personalisierung Ihres In-Game-Shops hilft, die relevantesten Artikel für jeden Benutzer anzuzeigen, was Engagement und Einnahmen steigert. Durch die Anpassung von Entwicklerprodukten an die Benutzerpräferenzen können Sie deren Entdeckung verbessern, die Konversionsraten erhöhen und neue Monetarisierungsmöglichkeiten erschließen.

Entwicklprodukte zum Verkauf einstufen

RankProductsAsync nimmt eine Liste von Produkt-IDs entgegen und gibt eine personalisierte, geordnete Liste dieser Produkte zurück. Sie können diese Methode verwenden, um Ihren Benutzern personalisierte Artikelempfehlungen in Ihrem In-Game-Shop zu bieten.

local MarketplaceService = game:GetService("MarketplaceService")

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

-- Machen Sie 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

-- Laden Sie die zurückgegebenen Artikel in den Shop
for i, rankedItem in ipairs(rankedProducts) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logik zum Hinzufügen von Produkten in den Shop
end

Zeigen Sie Ihre besten Entwicklerprodukte an

RecommendTopProductsAsync nimmt ein Array von InfoType-Werten entgegen und gibt bis zu 50 Artikel zurück, mit denen ein Benutzer am wahrscheinlichsten interagiert und die er kauft. Sie können diese Methode verwenden, um einen Abschnitt "Top Picks" in Ihrem In-Game-Shop zu erstellen.

Wenn keine Empfehlungen ermittelt 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 Benutzer warten müssen, empfehlen wir, task.spawn zu verwenden, um den Aufruf an RecommendTopProducts nicht blockierend zu machen.

local MarketplaceService = game:GetService("MarketplaceService")

-- Erstellen Sie ein Array von Produkttypen, die Sie in die Empfehlungen aufnehmen möchten -- Dieses Beispiel umfasst sowohl Pässe als auch Entwicklerprodukte
local productTypes = {Enum.InfoType.GamePass, Enum.InfoType.Product}

-- Machen Sie 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

-- Laden Sie die zurückgegebenen Artikel in den Shop
-- Stellen Sie sicher, dass Sie alle nicht berechtigten Artikel aus topRankedItems herausfiltern, wie z.B. Entwicklerprodukte, die der Benutzer nicht mehr kaufen kann
for i, rankedItem in ipairs(topRankedItems) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logik zum Hinzufügen von Produkten in den Shop
end

Analytik für Entwicklerprodukte

Verwenden Sie die Analytik für Entwicklerprodukte, um den Erfolg einzelner Produkte zu analysieren, Trends zu identifizieren und potenzielle zukünftige Einnahmen vorherzusagen.

Mit Analytik können Sie:

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

Um auf die Analytik für Entwicklerprodukte zuzugreifen:

1. Gehen Sie zu Erstellungen und wählen Sie ein Spiel aus.
2. Gehen Sie zu Monetarisierung ⟩ Entwicklerprodukte.
3. Wählen Sie die Registerkarte Analytik aus.