Pässe

Pässe ermöglichen es dir, von Nutzern eine einmalige Robux-Gebühr zu verlangen, um besondere Privilegien in deinem Spiel zu nutzen, wie z. B. den Zugang zu einem eingeschränkten Bereich, einen In-Game-Avatar-Gegenstand oder einen dauerhaften Power-Up.

Erstelle einen Pass

Um einen Pass zu erstellen:

1. Gehe zu Erstellungen und wähle ein Spiel aus.
2. Gehe zu Monetarisierung ⟩ Pässe.
3. Klicke auf Pass erstellen.
4. Lade ein Bild hoch, das als Passsymbol angezeigt wird. Stelle sicher, dass das Bild 512x512 Pixel nicht überschreitet, keine wichtigen Details außerhalb seiner runden Grenzen enthält und im Format .jpg, .png oder .bmp vorliegt.
5. Gib einen Namen und eine Beschreibung für den Pass ein.
6. Wähle eine Kategorie für den Pass aus. Die Kategorie wird verwendet, um Gegenstände in deinem In-Game-Shop zu organisieren.
7. Klicke auf Pass erstellen.

Erhalte die Pass-ID

Um Skripting zu verwenden, benötigst du eine Pass-ID. Um die Pass-ID zu erhalten:

1. Gehe zu Monetarisierung ⟩ Pässe.

2. Bewege den Mauszeiger über die Miniaturansicht eines Passes, klicke auf die ⋯-Schaltfläche und wähle Asset-ID kopieren aus dem Kontextmenü.

   

Verkaufe einen Pass

Du kannst Pässe auf zwei Arten verkaufen:

• Innerhalb deines Spiels
• Außerhalb deines Spiels

Innerhalb deines Spiels

Um einen Pass innerhalb eines Spiels umzusetzen und zu verkaufen, rufe die Funktionen MarketplaceService auf.

Verwende GetProductInfo(), um Informationen über einen Pass abzurufen, wie Name und Preis, und um diesen Pass dann den Nutzern anzuzeigen. Du kannst den Pass beispielsweise im Marktplatz deines Spiels verkaufen. Für Pässe muss der zweite Parameter Enum.InfoType.GamePass sein.

local MarketplaceService = game:GetService("MarketplaceService")

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

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


if success and productInfo then
	-- Überprüfe, ob das Produkt zum Verkauf steht
	if productInfo.IsForSale then
	-- Produktinformationen anzeigen
	-- Ersetze die Print-Anweisungen durch UI-Code, um den Pass anzuzeigen
  	print("Passname: " .. productInfo.Name)
  	print("Preis in Robux: " .. productInfo.PriceInRobux)
  	print("Beschreibung: " .. productInfo.Description)
	else
		print("Dieses Produkt steht nicht zum Verkauf")
	end
end

Verwende PromptGamePassPurchase(), um den Kauf eines Passes anzufordern, wenn der Nutzer den Pass noch nicht in seinem Inventar hat. Du kannst diese Funktion aufrufen, wenn ein Nutzer Aktionen ausführt, wie das Drücken eines Buttons oder das Sprechen mit einem NPC-Händler.

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

-- Ersetze die Platzhalter-ID durch deine Pass-ID
local passID = 0000000

-- Kaufaufforderung für den Pass
local function promptPurchase()
	local player = Players.LocalPlayer
	local hasPass = false

	local success, message = pcall(function()
		hasPass = MarketplaceService:UserOwnsGamePassAsync(player.UserId, passID)
	end)

	if not success then
		warn("Fehler beim Überprüfen, ob der Spieler den Pass hat: " .. tostring(message))
		return
	end

	if hasPass then
		-- Zeige eine Nachricht an, die dem Nutzer mitteilt, dass er den Pass bereits besitzt
	else
		-- Kaufaufforderung für den Pass
		MarketplaceService:PromptGamePassPurchase(player, passID)
	end
end

Verwende PromptGamePassPurchaseFinished, um eine abgeschlossene Kaufaufforderung zu bearbeiten und dem Nutzer die mit dem Pass verbundenen Privilegien zuzuweisen.

Platziere das Skript in ServerScriptService, damit der Server die Passprivilegien des Nutzers verwaltet.

local MarketplaceService = game:GetService("MarketplaceService")

-- Ersetze die Platzhalter-ID durch deine Pass-ID
local passID = 0000000  -- Ändere dies zu deiner Pass-ID

-- Bearbeite eine abgeschlossene Aufforderung und den Kauf
local function onPromptPurchaseFinished(player, purchasedPassID, purchaseSuccess)
	if purchaseSuccess and purchasedPassID == passID then
		print(player.Name .. " hat den Pass mit ID " .. passID .. " gekauft")
		-- Weisen Sie dem Benutzer die Fähigkeit oder den Bonus zu, der mit dem Pass verbunden ist
	end
end

-- Verbinde PromptGamePassPurchaseFinished-Events mit der Funktion
MarketplaceService.PromptGamePassPurchaseFinished:Connect(onPromptPurchaseFinished)

Außerhalb deines Spiels

Um einen Pass im Shop-Tab der Detailseite des Spiels zu verkaufen:

1. Gehe zu Monetarisierung ⟩ Pässe.
2. Bewege den Mauszeiger über den Pass und klicke auf das ⋯-Menü.
3. Wähle den Pass aus, den du verkaufen möchtest.
4. Wähle Verkäufe.
5. Aktiviere den Schalter Artikel zum Verkauf.
6. Gib im Feld Preis in Robux den Betrag an Robux ein, den du den Nutzern für den Pass berechnen möchtest. Der Preis, den du angibst, beeinflusst, wie viel Robux du pro Verkauf verdienst. Der Mindestpreis beträgt 1 Robux und der Höchstpreis 1 Milliarde Robux.
7. Klicke auf Änderungen speichern. Der Pass wird im Shop-Tab der Detailseite des Spiels angezeigt.

Weisen Sie Passprivilegien zu

Du musst die Passprivilegien manuell den Nutzern zuweisen, die deine Pässe kaufen. Um dies zu tun, verwende PlayerAdded, wenn ein Nutzer deinem Spiel beitritt, um zu überprüfen, ob er den Pass bereits besitzt und um ihm die Passprivilegien zuzuweisen.

Platziere das Skript in ServerScriptService, damit der Server die Passprivilegien der Nutzer verwaltet.

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

-- Ersetze die Platzhalter-ID durch deine Pass-ID
local passID = 0000000

local function onPlayerAdded(player)
	local hasPass = false

	-- Überprüfe, ob der Nutzer den Pass bereits besitzt
	local success, message = pcall(function()
		hasPass = MarketplaceService:UserOwnsGamePassAsync(player.UserId, passID)
	end)

	if not success then
		-- Gib eine Warnung aus und verlasse die Funktion
		warn("Fehler beim Überprüfen, ob der Spieler den Pass hat: " .. tostring(message))
		return
	end

	if hasPass then
		-- Weisen Sie dem Nutzer die Fähigkeit oder den Bonus zu, der mit dem Pass verbunden ist
		print(player.Name .. " besitzt den Pass mit ID " .. passID)
	end
end

-- Verbinde PlayerAdded-Events mit der Funktion
Players.PlayerAdded:Connect(onPlayerAdded)

Personalisieren Sie Ihren In-Game-Shop

Du kannst Produktintelligenz-APIs verwenden, um Pässe für Nutzer zu sortieren und zu empfehlen. Die Personalisierung deines In-Game-Shops hilft, den relevantesten Gegenstand für jeden Nutzer anzuzeigen, was das Engagement und die Einnahmen steigert. Indem du Pässe auf die Benutzerpräferenzen zuschneidest, kannst du deren Auffindbarkeit verbessern, die Konversionsraten erhöhen und neue Monetarisierungsmöglichkeiten erschließen.

Pässe zum Verkauf bewerten

RankProductsAsync nimmt eine Liste von Produkt-IDs entgegen und liefert eine personalisierte, geordnete Liste dieser Produkte zurück. Du kannst diese Methode verwenden, um deinen Nutzern personalisierte Produktempfehlungen in deinem In-Game-Shop zu bieten.

local MarketplaceService = game:GetService("MarketplaceService")

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

-- Optional: Umfasse den Aufruf in einer asynchronen Aufgabe, damit, falls die Anfrage langsam ist,
-- die UI / das Spiel nicht einfriert
task.spawn(function()
    -- Verwende ein pcall, um Fehler sanft zu behandeln
    local success, result = pcall(function()
        return MarketplaceService:RankProductsAsync(productIdentifiers)
    end)

    if not success then
        -- Wenn es fehlgeschlagen ist, ist 'result' die Fehlermeldung.
        warn("Produkte konnten nicht eingeordnet werden:", result)
    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 zum Hinzufügen von productInfo in den Shop
    end
end)

Zeige deine besten Pässe an

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

Wenn keine Empfehlungen ermittelt werden können, gibt RecommendTopProductsAsync 0 Artikel zurück. Alle Pässe, die der Nutzer bereits besitzt, werden ebenfalls nicht zurückgegeben.

In seltenen Fällen können Anrufe an das Bewertungsmodell langsam sein. Um zu verhindern, dass Nutzer zu lange warten, empfehlen wir die Verwendung von task.spawn, um den Aufruf von RecommendTopProducts nicht-blockierend zu machen.

local MarketplaceService = game:GetService("MarketplaceService")

-- Erstelle ein Array von Produkttypen, die enthalten sein sollen. In diesem Fall sowohl Spielpässe als auch Entwicklerprodukte
local productTypes = {Enum.InfoType.GamePass, Enum.InfoType.Product}

-- Optional: Umfasse den Aufruf in einer asynchronen Aufgabe, damit, falls die Anfrage langsam ist,
-- die UI / das Spiel nicht einfriert
task.spawn(function()
    -- Verwende ein pcall, um Fehler sanft zu behandeln
    local success, result = pcall(function()
        return MarketplaceService:RecommendTopProductsAsync(productTypes)
    end)

    if not success then
        -- Wenn es fehlgeschlagen ist, ist 'result' die Fehlermeldung.
        warn("Produkte konnten nicht eingeordnet werden:", result)
    end

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

Bewirb einen Pass

Um mehr Nutzern zu helfen, dein Spiel zu entdecken, kannst du dich dafür entscheiden, dass deine Pässe auf der Roblox Kaufen Robux Seite vorgestellt werden. Die Entscheidung, deine Pässe zu bewerben, kann dazu beitragen, die Zeit und die Robux, die Nutzer in deinem Spiel verbringen, zu erhöhen. Es gibt keine Begrenzung für die Anzahl der Pässe, die du bewerben kannst.

Nutzern werden Pässe angezeigt, die relevant für ihre Spielhistorie und ihr Engagement auf der Plattform sind. Ihnen werden keine Pässe angezeigt, die sie bereits besitzen.

Wenn Nutzer ein berechtigtes Robux-Paket kaufen, erhalten sie den beworbenen Pass und werden aufgefordert, ihren Pass zu beanspruchen, indem sie deinem Spiel beitreten.

Um dich für die Bewerbung eines deiner Pässe zu entscheiden:

1. Gehe zu Monetarisierung ⟩ Pässe.
2. Wähle den Pass aus, den du bewerben möchtest.
3. Wähle Bewerbungen.
4. Aktiviere Dieses Element in den Bonuspool einbeziehen.
5. Klicke auf Änderungen speichern. Der Pass wird relevanten Nutzern auf der Kaufen Robux-Seite angezeigt.

Der beworbene Pass:

• Kann nicht verkauft oder verkauft werden. Wenn sie verkauft werden, muss ihr Robux-Wert größer als 49 Robux und kleiner als 801 Robux sein.
• Muss ein Thumbnail enthalten.
• Darf keine bezahlten zufälligen Gegenstände gewähren.
• Muss den Gemeinschaftsstandards entsprechen.

Pass-Analysen

Verwende Pass-Analysen, um den Erfolg einzelner Pässe zu analysieren, Trends zu identifizieren und potenzielle zukünftige Einnahmen vorherzusagen.

Mit Analysen kannst du:

• Deine besten Pässe über einen ausgewählten Zeitraum anzeigen.
• Bis zu acht umsatzstärkste Artikel in einem Zeitreihendiagramm anzeigen, um den Gesamtumsatz und den Nettoumsatz zu analysieren.
• Dein Katalog überwachen und Artikel nach Verkaufszahlen und Nettoumsatz sortieren.
• Überprüfen, wie viele Pässe von Nutzern durch Werbung auf der Kaufen Robux-Seite erlangt wurden.
• Überprüfen, wie viele Nutzer deinem Spiel beigetreten sind, nachdem sie den Pass über die Kaufen Robux-Seite erworben haben.

Um auf Pass-Analysen zuzugreifen:

1. Gehe zu Erstellungen und wähle ein Spiel aus.
2. Gehe zu Monetarisierung ⟩ Pässe.
3. Wähle den Analysen-Tab aus.