Preços regionais

Com Preço Gerenciado, você pode oferecer preços específicos para a região de seus itens e construir uma economia global mais inclusiva e acessível. Depois de determinar um preço global padrão para um item, o Roblox utiliza uma variedade de sinais, como o poder de compra da região, taxas de câmbio e o comportamento de gastos local, para definir o preço mais apropriado para aquele item, região por região.

Você pode escolher quais dos seus itens deseja precificar regionalmente. Quando você ativa o Preço Gerenciado para um item em seu jogo, o Roblox ajusta automaticamente o preço desse item para os usuários com base em sua localização econômica.

A localização econômica nem sempre é a mesma que a localização da conta. Para determinar a localização econômica de um usuário, o Roblox observa sinais, incluindo uso de VPN, histórico de cobrança e histórico da conta. Se a localização econômica não puder ser determinada, os usuários veem o preço global padrão para o item em vez disso.

Para evitar a arbitragem de preços quando os usuários presenteiam ou trocam itens com preços gerenciados diferentes, você pode gerenciar transferências no jogo com a API GetUsersPriceLevelsAsync.

Ativar preços regionais

Para passes

Os preços regionais estão ativados por padrão para todos os novos e existentes passes através do Preço Gerenciado.

Para desativar o preço gerenciado de um passe:

1. Vá para Criações e selecione um jogo.
2. Vá para Monetização ⟩ Passes.
3. Selecione um ou mais passes existentes.
4. Clique em Desativar Preço Gerenciado.
5. OPCIONAL

   Para visualizar preços gerenciados por país ou região, selecione um passe e vá para sua página de Vendas. A lista Principais Países/Regiões é atualizada para mostrar os preços ajustados com base no preço padrão do passe. Para visualizar preços de todos os países e regiões, clique em Ver todos os países.

Para produtos de desenvolvedor

Para ativar o preço gerenciado para um produto de desenvolvedor:

1. Verifique se seus produtos de desenvolvedor têm preços dinamicamente scriptados.
2. Implemente o método GetUsersPriceLevelsAsync para regular transferências de itens com base nos níveis de preço dos usuários.
3. Vá para Criações e selecione um jogo.
4. Vá para Monetização ⟩ Produtos de Desenvolvedor.
5. Selecione um ou mais produtos existentes ou crie um novo produto.
6. Clique em Ativar Preço Gerenciado.
7. OPCIONAL

   Para visualizar Preço Gerenciado por país ou região, selecione um produto e vá para sua página de Configurações Básicas. A lista Principais Países/Regiões é atualizada para mostrar os preços ajustados com base no preço padrão do produto. Para visualizar Preço Gerenciado para todos os países e regiões, clique em Ver todos os países.

Para assinaturas

O preço gerenciado é ativado por padrão para assinaturas com preço em Robux e não pode ser desativado. Para mais informações, veja Criar assinaturas.

O preço gerenciado não está disponível para assinaturas com preço em moeda local.

Para itens de Avatar

Para ativar o Preço Gerenciado para um item de Avatar, veja Preços na página Publicar no Marketplace.

Verificar preços dinâmicos

Quando você ativa o Preço Gerenciado, o preço do item se ajusta para usuários em diferentes regiões, seja para venda dentro ou fora do seu jogo. No entanto, se você codificou rigidamente o preço na interface de usuário do seu jogo, esse número não é atualizado, pois não é dinâmico ou acessível pelo Roblox. Como resultado, os usuários são cobrados pelo preço correspondente à sua região, mas a interface de usuário ainda mostra o valor codificado.

A ferramenta de verificação de preço dinâmico atualiza todos os itens à venda dentro do seu jogo com um preço fictício em Robux ou uma localização econômica fictícia para ajudar você a identificar quais preços estão codificados na interface de usuário do seu jogo e quais são dinamicamente scriptados com MarketplaceService e chamados de um script de cliente. Depois de identificar os passes codificados, você pode atualizá-los para usar as funções MarketplaceService.

Para usar a ferramenta de verificação de preço dinâmico:

1. Vá para Monetização.

   • Para passes, vá para Passes.
   • Para produtos de desenvolvedor, vá para Produtos de Desenvolvedor.
2. Clique em … e selecione Verificação de Preço Dinâmico.
3. Em Adicionar contas de teste, insira até cinco usuários do Roblox para verificar preços codificados.
4. Selecione um tipo de teste.

   • Preço fixo atualiza todos os preços dinamicamente scriptados com um determinado valor fictício em Robux.
   • Localização fixa atualiza todos os preços dinamicamente scriptados com um preço específico para uma localização econômica fictícia.
5. Clique em Ativar. Após alguns minutos, entre no seu jogo para identificar os preços codificados.

Para desativar a ferramenta de verificação de preço dinâmico, vá até a página Verificação de Preço Dinâmico e clique em Desativar.

Para mais informações sobre preços codificados versus preços dinamicamente scriptados, consulte Verificar preços dinâmicos na página de Otimização de Preços. Para mais informações sobre vendas de passes e produtos de desenvolvedor com funções MarketplaceService, consulte Vender um passe dentro do seu jogo e Vender um produto de desenvolvedor dentro do seu jogo.

Exibir preços regionais em seu jogo

Com o Preço Gerenciado, o preço que um usuário vê pode variar com base em sua localização. Se você exibir preços em uma interface de usuário personalizada no jogo, como um TextLabel, você pode recuperar informações sobre o produto em tempo de execução para garantir que o preço exibido corresponda ao preço mostrado na solicitação de compra.

Para exibir o preço regional para um único produto de desenvolvedor ou passe, use GetProductInfoAsync.

Para exibir o preço regional para todos os produtos de desenvolvedor, use GetDeveloperProductsAsync.

Proteger suas trocas e presentes

O preço gerenciado pode afetar transferências no jogo, como trocas e presentes. Devido a diferenças de preços entre regiões, a arbitragem de preços (explorar discrepâncias de preços entre os mesmos produtos para gerar lucro) pode ocorrer. Para gerenciar o potencial de arbitragem de preços, você pode usar a API GetUsersPriceLevelsAsync, que permite que você determine os níveis de preços relativos dos usuários para que você possa implementar a lógica para regular transferências de itens com base nesses níveis.

GetUsersPriceLevelsAsync fornece um valor numérico entre 1 e 1000 que indica o nível de preço de um usuário. Este valor foi projetado para representar a porcentagem do preço total que se espera que um usuário pague. O nível de preço 1000 representa o preço global total, enquanto níveis de preço mais baixos indicam que o usuário normalmente paga um preço mais baixo devido à sua localização econômica.

Uma diferença de nível de preço mais baixa significa que há uma menor diferença de preço entre o preço global total e o preço gerenciado do usuário. Uma diferença de nível de preço mais alta significa que há uma maior diferença de preço entre os dois. Por exemplo:

• O Usuário A tem o nível de preço 1000, que representa o preço global total. Este usuário paga 100% do preço base por um item.
• O Usuário B tem o nível de preço 500, que representa 50% do preço global total. Este usuário paga 50% do preço base por um item.
• Uma vez que você saiba o nível de preço de cada usuário, você pode optar por aprovar ou bloquear presentes ou trocas entre o Usuário A e o Usuário B com base em sua diferença de nível de preço de 500.

Implementar GetUsersPriceLevelsAsync

Para obter os níveis de preço dos usuários envolvidos em uma transferência de item, chame a função GetUsersPriceLevelsAsync no MarketplaceService. Esta função recebe um array de IDs de usuário como argumento e retorna um array de objetos PriceLevelInfo com os seguintes campos:

type PriceLevelInfo = {
    UserId: number,
    PriceLevel: number
}

Após implementar a função, use os níveis de preço retornados para escolher se deseja permitir que uma transferência de item ocorra. Por exemplo, você pode permitir que usuários com um nível de preço mais alto presenteiem itens para usuários com um nível de preço mais baixo, mas apenas permitir trocas entre usuários que têm o mesmo nível de preço. Consulte os exemplos disponíveis para mais informações.

Para mais informações sobre a API GetUsersPriceLevelsAsync, consulte MarketplaceService.

Exemplos

Exemplos de como você pode usar GetUsersPriceLevelsAsync com preços regionais.

Exemplo 1: Verificar os níveis de preço para uma lista de usuários

Este exemplo mostra como recuperar os níveis de preço para uma lista de usuários, o que pode ajudar você a escolher se deseja permitir que uma transferência de item ocorra.

-- Obter o MarketplaceService
local MarketplaceService = game:GetService("MarketplaceService")

-- Definir uma função para recuperar níveis de preço para uma lista de usuários e criar uma tabela de pesquisa de UserId para PriceLevel
local function getPriceLevelsLookup(userIds)
    local success, result = pcall(function()
        return MarketplaceService:GetUsersPriceLevelsAsync(userIds)
    end)

    if success then
        -- Mapear cada PriceLevelInfo para uma tabela de pesquisa UserId -> PriceLevel
        local lookup = {}
        for _, userData in ipairs(result) do
            lookup[userData.UserId] = userData.PriceLevel
        end
        return lookup
    else
        warn("Erro ao obter níveis de preço:", result)
        return nil
    end
end

-- Exemplo usando IDs fictícios
local user1Id = 123456789
local user2Id = 987654321

-- Chamar a função e armazenar o resultado
local priceLevels = getPriceLevelsLookup({user1Id, user2Id})
-- Se bem-sucedido, imprimir o nível de cada usuário
if priceLevels then
    print("Nível de preço para o Usuário 1:", priceLevels[user1Id])
    print("Nível de preço para o Usuário 2:", priceLevels[user2Id])
else
    print("Falha ao recuperar níveis de preço.")
end

Exemplo 2: Comparar o nível de preço do remetente com o nível de preço do destinatário

Este exemplo mostra uma implementação de exemplo de como verificar o nível de preço de um remetente em comparação ao nível de preço do destinatário. Isso pode ajudar você a gerenciar presentes de usuários em regiões de preços mais altos para usuários em regiões de preços mais baixos.

-- Obter o MarketplaceService
local MarketplaceService = game:GetService("MarketplaceService")

-- Definir uma função para recuperar níveis de preço para uma lista de usuários e criar uma tabela de pesquisa de UserId para PriceLevel
local function getPriceLevelsLookup(userIds)
    local success, result = pcall(function()
        return MarketplaceService:GetUsersPriceLevelsAsync(userIds)
    end)

    if success then
        -- Mapear cada PriceLevelInfo para uma tabela de pesquisa UserId -> PriceLevel
        local lookup = {}
        for _, userData in ipairs(result) do
            lookup[userData.UserId] = userData.PriceLevel
        end
        return lookup
    else
        warn("Erro ao obter níveis de preço:", result)
        return nil
    end
end

-- Definir uma função que verifica se o remetente tem um nível de preço maior ou igual ao do destinatário
-- Os parâmetros são o Player que está enviando o item e o Player que está recebendo o item
-- A função retorna true se o nível de preço do remetente for maior ou igual ao nível de preço do destinatário
function isSenderPriceLevelHigherOrEqualforGifting(sender, recipient)
	local priceLevelsLookup = getPriceLevelsLookup({ sender.UserId, recipient.UserId })

	if not priceLevelsLookup then
		error("MarketplaceService:GetUsersPriceLevelsAsync falhou. Não foi possível recuperar os níveis de preço dos usuários.")
	end

	local senderPriceLevel = priceLevelsLookup[sender.UserId]
	local recipientPriceLevel = priceLevelsLookup[recipient.UserId]

	return senderPriceLevel >= recipientPriceLevel
end

Exemplo 3: Verificar se dois usuários têm o mesmo nível de preço

Este exemplo mostra uma implementação de exemplo de como verificar se dois usuários têm o mesmo nível de preço. Isso pode ajudar você a gerenciar trocas e garantir uma troca justa entre usuários de diferentes regiões.

-- Obter o MarketplaceService
local MarketplaceService = game:GetService("MarketplaceService")

-- Definir uma função para recuperar níveis de preço para uma lista de usuários e criar uma tabela de pesquisa de UserId para PriceLevel
local function getPriceLevelsLookup(userIds)
    local success, result = pcall(function()
        return MarketplaceService:GetUsersPriceLevelsAsync(userIds)
    end)

    if success then
        -- Mapear cada PriceLevelInfo para uma tabela de pesquisa UserId -> PriceLevel
        local lookup = {}
        for _, userData in ipairs(result) do
            lookup[userData.UserId] = userData.PriceLevel
        end
        return lookup
    else
        warn("Erro ao obter níveis de preço:", result)
        return nil
    end
end

-- Definir uma função que verifica se dois usuários têm o mesmo nível de preço
-- Os parâmetros são os dois usuários cujos níveis de preço você deseja comparar
-- A função retorna true se ambos os usuários tiverem o mesmo nível de preço
function haveSamePriceLevelForTrading(userA, userB)
	local priceLevelsLookup = getPriceLevelsLookup({ userA.UserId, userB.UserId })

	if not priceLevelsLookup then
		error("MarketplaceService:GetUsersPriceLevelsAsync falhou. Não foi possível recuperar os níveis de preço dos usuários.")
	end

	local userAPriceLevel = priceLevelsLookup[userA.UserId]
	local userBPriceLevel = priceLevelsLookup[userB.UserId]

	return userAPriceLevel == userBPriceLevel
end