Transferts de Robux

Les transferts de Robux permettent aux abonnés de Roblox Plus d'envoyer des Robux directement à d'autres utilisateurs.

Pour prendre en charge les transferts dans votre jeu, appelez PromptRobuxTransferAsync pour ouvrir l'invite de transfert et utilisez BindReceiptHandler pour traiter les reçus de transfert. Lorsqu'un abonné termine un transfert, votre jeu gagne 10% des Robux envoyés et le destinataire reçoit les 90% restants. Par exemple, un transfert de 100 Robux paie 90 Robux au destinataire et 10 Robux à votre jeu.

Les Robux que votre jeu gagne grâce aux transferts sont éligibles au programme DevEx. Roblox ne prend pas de frais sur ces transferts.

En tant que créateur, vous n'avez pas accès aux détails du transfert ni au contrôle de son exécution. Tous les transferts de Robux sont traités et gérés par la plateforme Roblox, et toutes les actions des expéditeurs et des destinataires passent par les mêmes contrôles de sécurité et d'éligibilité. Dans votre jeu, les transferts sont effectués via une interface utilisateur contrôlée par Roblox pour s'assurer qu'ils sont sûrs et conformes à la politique.

Inviter des transferts de Robux

Pour initier un transfert de Robux dans votre jeu :

1. Appelez PromptRobuxTransferAsync depuis un script côté serveur.
2. Passez les paramètres requis :

   • sender: Le joueur initiant le transfert.
   • receiverUserId: L'identifiant utilisateur du destinataire.
   • amount: Le montant de Robux à transférer.
3. Stockez le transferRequestId retourné qui identifie la demande de transfert et peut être utilisé pour enregistrer ou corréler le transfert avec des reçus plus tard.

L'exemple suivant initie un transfert de Robux entre deux utilisateurs :

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

-- Transfère des Robux lorsqu'un utilisateur déclenche un RemoteEvent
local transferEvent = game.ReplicatedStorage:WaitForChild("RequestTransfer")

transferEvent.OnServerEvent:Connect(function(sender, receiverUserId, amount)
	-- Valide les entrées
	if not sender or not sender:IsA("Player") then
		return
	end

	if typeof(receiverUserId) ~= "number" or receiverUserId <= 0 then
		warn("Identifiant de destinataire invalide")
		return
	end

	if typeof(amount) ~= "number" or amount <= 0 then
		warn("Montant invalide")
		return
	end

	local success, result = pcall(function()
		return MarketplaceService:PromptRobuxTransferAsync(sender, receiverUserId, amount)
	end)

	if success then
		print(`Transfert initié avec TransferRequestId: {result}`)
	else
		warn(`Transfert échoué: {result}`)
	end
end)

Gérer les reçus de transfert

Après un transfert réussi, Roblox génère des reçus pour l'expéditeur et le destinataire. Vous pouvez traiter ces reçus en utilisant BindReceiptHandler pour confirmer que le transfert a été complété avec succès.

Pour encourager les abonnés Plus à transférer des Robux dans votre jeu, vous pouvez offrir des articles ou d'autres avantages pour chaque transfert réussi. Si vous le faites, traitez le reçu avant d'accorder la récompense pour vous assurer qu'elle n'est donnée que pour les transferts complétés.

Pour traiter les reçus de transfert de Robux :

1. Utilisez BindReceiptHandler pour enregistrer un gestionnaire pour RobuxTransferSender, qui traite les reçus pour l'utilisateur qui a initié le transfert.
2. Enregistrez un second gestionnaire pour RobuxTransferReceiver, qui traite les reçus pour l'utilisateur qui a reçu les Robux.
3. Dans chaque gestionnaire, inspectez les informations du reçu, y compris PlayerId et TransferRequestId. Les deux types de reçus contiennent un TransferRequestId qui correspond au transferRequestId retourné par PromptRobuxTransferAsync.
4. Retournez une valeur Enum.ReceiptDecision depuis votre gestionnaire :

   • Retournez Processed après avoir fini de traiter le reçu. Cela marque le reçu comme complet et confirme que le transfert de Robux a réussi.
   • Retournez NotProcessedYet si le reçu ne peut pas encore être traité (par exemple, si l'utilisateur n'est plus sur le serveur). Cela garde le reçu non résolu pour qu'il puisse être livré plus tard (par exemple, lorsque l'utilisateur rejoint à nouveau le serveur).

L'exemple suivant enregistre des gestionnaires pour les reçus d'expéditeur et de destinataire :

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

-- Gère les reçus des expéditeurs (l'utilisateur qui a envoyé les Robux)
local senderConnection = MarketplaceService:BindReceiptHandler(
	Enum.ReceiptType.RobuxTransferSender,
	function(receiptInfo)
		local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
		if not player then
			-- L'utilisateur a quitté le serveur - le traitement du reçu est différé jusqu'à ce que l'utilisateur rejoigne à nouveau
			return Enum.ReceiptDecision.NotProcessedYet
		end

		print(`{player.Name} a envoyé des Robux (TransferRequestId: {receiptInfo.TransferRequestId})`)

		-- Vous pouvez accorder toute reconnaissance côté expéditeur ou mettre à jour l'interface utilisateur ici

		return Enum.ReceiptDecision.Processed
	end
)

-- Gère les reçus des destinataires (l'utilisateur qui a reçu les Robux)
local receiverConnection = MarketplaceService:BindReceiptHandler(
	Enum.ReceiptType.RobuxTransferReceiver,
	function(receiptInfo)
		local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
		if not player then
			return Enum.ReceiptDecision.NotProcessedYet
		end

		print(`{player.Name} a reçu des Robux (TransferRequestId: {receiptInfo.TransferRequestId})`)

		-- Vous pouvez accorder tout avantage côté destinataire ou mettre à jour l'interface utilisateur ici

		return Enum.ReceiptDecision.Processed
	end
)