Player

O AccountAge é uma propriedade Player que descreve quanto tempo atrás a conta de um jogador foi registrada em dias.É definido usando a função Player:SetAccountAge(), que não pode ser acessada por scripts.

Essa propriedade é útil para mostrar condicionalmente o conteúdo de novos jogadores do Roblox, como tutoriais.

local Players = game:GetService("Players")

local MAX_AGE_NEW_PLAYER = 7 -- uma semana
local MIN_AGE_VETERAN = 365 -- um ano

-- Essa função marca uma parte com texto usando um BillboardGui
local function mark(part, text)
	local bbgui = Instance.new("BillboardGui")
	bbgui.AlwaysOnTop = true
	bbgui.StudsOffsetWorldSpace = Vector3.new(0, 2, 0)
	bbgui.Size = UDim2.new(0, 200, 0, 50)
	local textLabel = Instance.new("TextLabel")
	textLabel.Size = UDim2.new(1, 0, 1, 0) -- Preencher pai
	textLabel.Text = text
	textLabel.TextColor3 = Color3.new(1, 1, 1)
	textLabel.TextStrokeTransparency = 0
	textLabel.BackgroundTransparency = 1
	textLabel.Parent = bbgui
	-- Adicionar à peça
	bbgui.Parent = part
	bbgui.Adornee = part
end

local function onPlayerSpawned(player, character)
	local head = character:WaitForChild("Head")
	if player.AccountAge >= MIN_AGE_VETERAN then
		mark(head, "Veteran Player")
	elseif player.AccountAge <= MAX_AGE_NEW_PLAYER then
		mark(head, "New Player")
	else
		mark(head, "Regular Player")
	end
end

local function onPlayerAdded(player)
	-- Ouça este jogador sendo gerado
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

A propriedade AutoJumpEnabled determina se o Player.Character de um Player usando um dispositivo móvel saltará automaticamente quando atingir um obstáculo.Isso pode tornar os níveis mais navegáveis enquanto em um dispositivo móvel.

Quando o jogador entra no jogo, o valor StarterPlayer.AutoJumpEnabled determina o estado inicial dessa propriedade.Então, essa propriedade determina o valor da propriedade Humanoid.AutoJumpEnabled da Player.Character no momento do spawn.Em outras palavras, é possível definir o comportamento de pulo automático em uma base por personagem, por jogador e por jogo usando essas três propriedades.

local Players = game:GetService("Players")

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

local function update()
	-- Atualizar texto do botão
	if player.AutoJumpEnabled then
		button.Text = "Auto-Jump is ON"
	else
		button.Text = "Auto-Jump is OFF"
	end
	-- Reflete a propriedade no personagem do jogador, se ele tiver uma
	if player.Character then
		local human = player.Character:FindFirstChild("Humanoid")
		if human then
			human.AutoJumpEnabled = player.AutoJumpEnabled
		end
	end
end

local function onActivated()
	-- Alternar pulo automático
	player.AutoJumpEnabled = not player.AutoJumpEnabled
	-- Atualize tudo o mais
	update()
end

button.Activated:Connect(onActivated)
update()

A propriedade CameraMaxZoomDistance Player define a distância máxima em studs que a câmera pode estar do personagem com as câmeras padrão.

Em outras palavras, ele controla a distância máxima que a câmera do jogador pode se afastar.

O valor padrão desta propriedade é definido por StarterPlayer.CameraMaxZoomDistance .Se esse valor for definido para um valor inferior a Player.CameraMinZoomDistance, ele será aumentado para CameraMinZoomDistance.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

A propriedade CameraMinZoonDistance Player define a distância mínima em studs que a câmera pode estar do personagem com as câmeras padrão.

Em outras palavras, ele controla a distância mínima em que a câmera do jogador é permitida se aproximar.

O valor padrão desta propriedade é definido por StarterPlayer.CameraMinZoomDistance .Se esse valor for definido para um valor maior que Player.CameraMaxZoomDistance , ele será reduzido para CameraMaxZoomDistance.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

A propriedade Modo de Câmera define o modo de câmera do jogador, padrão para terceira pessoa.

Terceira Pessoa

No modo padrão de terceira pessoa ( Enum.CameraMode.Classic ), o personagem pode ser visto na câmera. Enquanto neste modo, o comportamento padrão é:

• Jogadores podem clicar com o botão direito e arrastar (鼠), tocar e arrastar (celular), usar o botão analógico secundário (gamepad), ou pressionar as setas esquerda/direita (teclado) para girar a câmera em torno de seu personagem.
• Quando um jogador move seu personagem, ele enfrenta na direção de movimento correspondente.
• Os jogadores podem ampliar e reduzir livremente, até mesmo para a primeira pessoa em zoom total em.

Primeira Pessoa

No modo de primeira pessoa ( Enum.CameraMode.LockFirstPerson ), a câmera do jogador é ampliada até o fim.A menos que haja uma GUI visível presente com o set de propriedades GuiButton.Modal definido para true, movendo o mouse, arrastando no celular ou usando o botão secundário em um gamepad, a câmera girará em torno do personagem.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMode = Enum.CameraMode.LockFirstPerson

A propriedade CanLoadCharacterAppearance Player determina se a aparência do personagem será carregada quando o jogador for gerado.O valor padrão desta propriedade é definido por StarterPlayer.LoadPlayerAppearance .

Se verdadeiro , o personagem carregará a aparência do jogador correspondente ao jogador Player.CharacterAppearanceId .

Se falsa , o jogador será gerado com uma aparência padrão - um modelo de personagem cinza sem quaisquer chapéus, camisas, calças, etc.

Tentar definir a propriedade depois que o personagem foi gerado não alterará o personagem, você deve chamar Player:LoadCharacter() para carregar a nova aparência.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CanLoadCharacterAppearance = false

A propriedade Personagem contém uma referência a um Model que contém um Humanoid , partes do corpo, scripts e outros objetos necessários para simular o avatar do jogador na experiência.O modelo é parentado para o Workspace mas pode ser movido.É carregado automaticamente quando Players.CharacterAutoLoads é true e pode ser carregado manualmente caso contrário usando Player:LoadCharacter() .

Inicialmente, essa propriedade é nil e é definida quando o personagem do jogador aparece pela primeira vez.Use o evento Player.CharacterAdded para detectar quando o personagem de um jogador carrega corretamente e o evento Player.CharacterRemoving para detectar quando o personagem está prestes a desaparecer.Evite usar Object:GetPropertyChangedSignal() nesta propriedade.

Observe que LocalScripts que são clonados de StarterGui ou StarterPack em um jogador's PlayerGui ou Backpack respectivamente são frequentemente executados antes que o modelo de personagem antigo seja substituído, então Player.Character pode se referir ao modelo antigo cuja propriedade Parent é nil.Portanto, em um LocalScript sob StarterGui ou StarterPack , é aconselhável garantir que o pai de Personagem não seja nil antes de usá-lo, por exemplo:

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

local character = player.Character
if not character or character.Parent == nil then
	character = player.CharacterAdded:Wait()
end

Essa propriedade determina o ID do usuário da conta cuja aparência de personagem é usada para um jogador de character.Por padrão, esta propriedade é a Player.UserId, que usa o avatar do jogador como ele o criou no site do Roblox.

Alterar esta propriedade para o ID do usuário de outra conta fará com que o jogador apareça com a aparência dessa conta ( chapéus, camisas, calças, etc ).

Jogos também podem alternar se a aparência do personagem de um jogador é carregada no jogo ou não alterando a propriedade StarterPlayer.LoadCharacterAppearance.

local Players = game:GetService("Players")

local disguiseCommand = "/disguise "

local function onPlayerChatted(player, message)
	if message:sub(1, disguiseCommand:len()):lower() == disguiseCommand:lower() then
		local input = message:sub(disguiseCommand:len() + 1)
		local id = tonumber(input)
		if not id then -- Número falhou ao ser analisado, talvez eles tenham digitado um nome de usuário em vez disso
			pcall(function() -- Essa chamada pode falhar às vezes!
				id = Players:GetUserIdFromNameAsync(input) -- Obter ID de recuperação a partir do nome
			end)
		end
		if id then
			-- Defina a aparência do personagem e depois respawn
			player.CharacterAppearanceId = id
			player:LoadCharacter()
		else
			-- Não conseguimos obter um ID de sua entrada
		end
	end
end

local function onPlayerAdded(player)
	player.Chatted:Connect(function(...)
		onPlayerChatted(player, ...)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

Define como os scripts de câmera padrão lidam com objetos entre a câmera e o assunto da câmera.Definido por StarterPlayer.DevCameraOcclusionMode e não pode ser alterado para jogadores individuais.

O valor padrão é Zoom (0). Veja Enum.DevCameraOcclusionMode para uma lista de modos disponíveis.

A propriedade DevComputerCameraMode determina a maneira pela qual um jogador move sua câmera ao usar um dispositivo com mouse e teclado.Veja Enum.DevComputerCameraMovementMode para uma descrição de cada modo de controle de câmera disponível.Essa propriedade não pode ser definida usando um LocalScript (ela deve ser definida no servidor usando um Script).

O valor padrão desta propriedade é determinado por StarterPlayer.DevComputerCameraMovementMode.

A palavra "Computador" neste nome de propriedade se refere a dispositivos não TouchEnabled , não GamepadEnabled .

Quando definido para Escolha do Usuário , um jogador pode escolher entre qualquer modo de controle (exceto Programável ) nas configurações da experiência durante o jogo.Em geral, é uma boa ideia permitir que os jogadores escolham o modo de controle para maximizar a acessibilidade.

É possível criar um esquema de controle personalizado definindo essa propriedade para Scriptable .

Essa propriedade não afeta jogadores usando um dispositivo com toque habilitado. Veja Player.DevTouchCameraMode.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

-- Set the player's camera movement mode on computers to classic
player.DevComputerCameraMode = Enum.DevComputerCameraMovementMode.Classic

A propriedade DevComputerMovementMode determina a maneira pela qual um jogador move seu personagem ao usar um dispositivo com mouse e teclado.Veja Enum.DevComputerMovementMode para uma descrição de cada modo de controle de movimento disponível.Essa propriedade não pode ser definida usando um LocalScript (ela deve ser definida no servidor usando um Script).

O valor padrão desta propriedade é determinado por StarterPlayer.DevComputerMovementMode.

A palavra "Computador" neste nome de propriedade se refere a dispositivos não TouchEnabled .

Quando definido para Escolha do Usuário , um jogador pode escolher entre qualquer modo de controle (exceto Programável ) nas configurações da experiência durante o jogo.Em geral, é uma boa ideia permitir que os jogadores escolham seu modo de controle para maximizar a acessibilidade.

É possível criar um esquema de controle personalizado definindo essa propriedade para Scriptable .

Essa propriedade não afeta jogadores usando um dispositivo habilitado para toque. Veja Player.DevTouchMovementMode.

local Players = game:GetService("Players")

local function onPlayerAdded(player: Player)
	-- Set the player's movement mode on desktop devices to click-to-move
	-- Once set, the player can right click in the game world and the character will move there.
	player.DevComputerMovementMode = Enum.DevComputerMovementMode.ClickToMove
end

Players.PlayerAdded:Connect(onPlayerAdded)

Essa propriedade determina se um jogador é capaz de alternar o bloqueio Mouse pressionando Shift.Um jogador pode desativar o botão de bloqueio do mouse nas configurações da experiência durante o jogo.Por padrão, esta propriedade é definida para o valor de StarterPlayer.EnableMouseLockOption .Isso pode ser definido do lado do servidor durante o tempo de execução usando um Script.Não pode ser definido do lado do cliente.

Quando o bloqueio do mouse estiver ativado, o cursor do jogador é bloqueado no centro da tela.Mover o mouse orbitará a câmera ao redor do jogador character e o personagem enfrentará a mesma direção que o camera .Também compensa a visão da câmera apenas sobre o ombro direito do personagem do jogador.

Observe que as APIs relacionadas ao shift-lock estão em processo de serem depreciadas, portanto, é recomendado usar UserInputService.MouseBehavior em vez disso para bloquear o mouse.

local Players = game:GetService("Players")

local function toggleMouseLock(player)
	player.DevEnableMouseLock = not player.DevEnableMouseLock
	if player.DevEnableMouseLock then
		print("Mouse lock is available")
	else
		print("Mouse lock is not available")
	end
end

local function onPlayerChatted(player, message, _recipient)
	if message == "mouselock" then
		toggleMouseLock(player)
	end
end

local function onPlayerAdded(player)
	player.Chatted:Connect(function(...)
		onPlayerChatted(player, ...)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

A propriedade DevTouchCameraMode determina a maneira pela qual um jogador move sua câmera ao usar um dispositivo TouchEnabled.Veja Enum.DevTouchCameraMovementMode para uma descrição de cada modo de controle de câmera disponível.Essa propriedade não pode ser definida usando um LocalScript (ela deve ser definida no servidor usando um Script ).

O valor padrão desta propriedade é determinado por StarterPlayer.DevTouchCameraMovementMode.

Quando definido para Escolha do Usuário , um jogador pode escolher entre qualquer modo de controle (exceto Programável ) nas configurações da experiência durante o jogo.Em geral, é uma boa ideia permitir que os jogadores escolham seu modo de controle para maximizar a acessibilidade.

É possível criar um esquema de controle personalizado definindo essa propriedade para Scriptable .

Essa propriedade não afeta jogadores que não estão usando um dispositivo habilitado para toque. Veja Player.DevComputerCameraMovementMode.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

-- Set the player's camera movement mode on mobile devices to classic
player.DevTouchCameraMovementMode = Enum.DevTouchCameraMovementMode.Classic

A propriedade DevTouchMovementMode determina a maneira pela qual um jogador move seu personagem ao usar um dispositivo TouchEnabled.Veja Enum.DevTouchMovementMode para uma descrição de cada modo de controle de movimento disponível.Essa propriedade não pode ser definida usando um LocalScript (ela deve ser definida no servidor usando um Script ).

O valor padrão desta propriedade é determinado por StarterPlayer.DevTouchMovementMode.

Quando definido para Escolha do Usuário , um jogador pode escolher entre qualquer modo de controle (exceto Programável ) nas configurações da experiência durante o jogo.Em geral, é uma boa ideia permitir que os jogadores escolham o modo de controle para maximizar a acessibilidade.

É possível criar um esquema de controle personalizado definindo essa propriedade para Scriptable .

Essa propriedade não afeta jogadores que não estão usando um dispositivo habilitado para toque. Veja Player.DevComputerMovementMode.

local Players = game:GetService("Players")

game.Players.PlayerAdded:Connect(function(player)
	-- Set the player's movement mode on mobile devices to a dynamic thumbstick
	player.DevTouchMovementMode = Enum.DevTouchMovementMode.DynamicThumbstick
end)

O DisplayName é uma propriedade Player que contém o nome de exibição do usuário autenticado associado ao objeto Player.Ao contrário de nomes de usuários, os nomes de exibição são nomes não exclusivos que um jogador exibe para os outros.Se o usuário do Roblox não escolheu nenhuma, a propriedade lerá a mesma que a propriedade Name.

Nota:

• Como os nomes de exibição não são exclusivos, é possível que dois jogadores em uma única instância tenham nomes idênticos.Se você precisar de um identificador globalmente único para um jogador, use Player.UserId (que é estático) ou Player.Name (que é o nome de usuário atual) em vez disso.
• Personagens gerados com Player.LoadCharacter ou pelo motor do Roblox terão sua propriedade Humanoid.DisplayName atribuída à propriedade Player.DisplayName.
• Nomes de exibição podem ter caracteres de idioma em string. Veja UTF-8 para mais informações sobre como trabalhar com strings com caracteres de idioma.

O FollowUserId é uma propriedade Player que contém o Player.UserId do usuário que um jogador seguiu para o jogo.Se o jogador não seguir ninguém para o jogo, esta propriedade será 0.Essa propriedade é útil para alertar jogadores que foram seguidos por outro jogador para o jogo.

Você pode obter o nome do jogador seguido usando esse ID de usuário e a função Players:GetNameFromUserIdAsync().

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local screenGui = Instance.new("ScreenGui")
screenGui.Parent = player:WaitForChild("PlayerGui")

local function onPlayerAdded(newPlayer)
	if newPlayer.FollowUserId == player.UserId then
		local textLabel = Instance.new("TextLabel")
		textLabel.Parent = screenGui
		textLabel.Text = "You were followed to this game by " .. newPlayer.Name .. "!"
		task.delay(3, function()
			if textLabel then
				textLabel:Destroy()
			end
		end)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

A propriedade JogabilidadePausada indica se o jogador está atualmente em um estado de pausa em um local com StreamingEnabled ativado.É definido no cliente, mas replicado para o servidor.Para determinar o status de pausa, você pode utilizar esta propriedade.

Veja também:

• Workspace.StreamingEnabled que controla se o streaming de conteúdo está habilitado
• Workspace.StreamingIntegrityMode e Enum.StreamingIntegrityMode para mais detalhes sobre quando o jogo é pausado.

A propriedade HasVerifiedBadge Player indica se o jogador tem um distintivo verificado.

A propriedade HealthDisplayDistance define a distância em studs em que esse jogador verá outras barras de saúde.Se definido como 0, as barras de saúde não serão exibidas.Essa propriedade é definida como StarterPlayer.HealthDisplayDistance por padrão.

Se a barra de saúde de um Humanoide for visível, você pode definir o tipo de exibição usando Humanoid.DisplayDistanceType.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

A propriedade LocaleId Player mostra o ID do local que o jogador local definiu para a conta Roblox deles.Ela contém uma string com o código de duas letras (por exemplo, "en-us") para o idioma local.

Isso pode ser usado para determinar a demografia geográfica da base de jogadores do seu jogo e também é o local que será usado para localização automática de conteúdo na experiência (veja GuiBase2d.AutoLocalize).Essa propriedade permite o acesso ao local do jogador do servidor.

Veja também LocalizationService.RobloxLocaleId , a ID local usada para localizar conteúdo interno.Este será um valor diferente quando o Roblox ainda não suportar internamente o conjunto local do jogador local.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

print(player.LocaleId)

Essa propriedade só pode ser lida para determinar a adesão (não pode ser definida para outro tipo de adesão).Ela armazena um Enum.MembershipType enum do tipo de membros da conta.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

if player.MembershipType == Enum.MembershipType.Premium then
	-- Tome alguma ação especificamente para membros Premium
end

A propriedade NameDisplayDistance StarterPlayer define a distância em studs em que esse jogador verá outros nomes Humanoid.Se a propriedade for definida como 0, os nomes são ocultados.Essa propriedade é definida como StarterPlayer.NameDisplayDistance por padrão.

Se a barra de saúde de um Humanoide for visível, você pode definir o tipo de exibição usando Humanoid.DisplayDistanceType.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

A propriedade Neutral determina se o jogador está em uma equipe específica.

• Quando verdade, o jogador não está em uma equipe específica.Isso também significa que a propriedade Player.Team será nil e a Player.TeamColor será branca.
• Quando falso, o jogador está em uma equipe específica.A propriedade Player.Team corresponderá ao Team em que o jogador está, assim como o Player.TeamColor .

local Players = game:GetService("Players")

local player = Players.LocalPlayer

if player.Neutral then
	print("Player is neutral!")
else
	print("Player is not neutral!")
end

Uma string de leitura exclusiva que identifica o grupo ao qual o jogador atualmente pertence dentro da experiência.Se o jogador não está em uma equipe, esse valor é uma string vazia.

Essa propriedade é essencial para integrar com o recurso de Grupo do Roblox.Use-o em combinação com SocialService:GetPlayersByPartyId() e SocialService:GetPartyAsync() para acessar informações sobre a festa de um jogador e seus membros.

Observe que este serviço não funciona durante o teste de jogo no Roblox Studio; para testar aspectos de sua experiência usando-o, você deve publicar a experiência e jogá-la no aplicativo Roblox.

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	local partyId = player.PartyId

	if partyId ~= "" then
		print("Player is in a party with ID: " .. partyId)
	else
		warn("Player is not in a party")
	end
end)

A propriedade ReplicationFocus Player define a parte para se concentrar na replicação em torno de um Jogador.Diferentes sistemas do Roblox que se comunicam através da rede (como física, streaming, etc) se replicam em diferentes taxas dependendo de quão próximos os objetos estão do foco de replicação.

Quando essa propriedade é nil, ela reverte ao seu comportamento padrão, que é tratar o personagem do jogador local PrimaryPart como o foco de replicação.

Essa propriedade só deve ser definida no servidor com um Script, não um LocalScript.Observe que esta propriedade não altera ou atualiza a propriedade de rede de peças.

local Players = game:GetService("Players")

local PLAYER_NAME = "polarpanda16"

local player = Players:WaitForChild(PLAYER_NAME)

local part = Instance.new("Part")
part.Parent = workspace
part.Name = "ReplicationFocusPart"
part.Anchored = true
player.ReplicationFocus = part

Se definido, o jogador reaparecerá no dado SpawnLocation.Essa propriedade só pode ser definida através do Luau e deve conter uma referência a um válido SpawnLocation, que deve atender aos seguintes critérios:

• Descendente de Workspace
• SpawnLocation.TeamColor é definido para o Player.TeamColor ou SpawnLocation.Neutral é definido como verdadeiro

Se RespawnLocation não for definido como válido SpawnLocation então a lógica de spawn padrão será aplicada.Para mais informações sobre isso, veja a página para SpawnLocation .

Alternativas para RespawnLocation

• Um Player vai aparecer de SpawnLocations pertencente à sua equipe. Em alguns casos, pode ser mais simples mudar o Player.Team do jogador em vez disso.
• Implemente sua própria lógica de spawn personalizada usando PVInstance:PivotTo() para mover manualmente o Player.Character.

local Players = game:GetService("Players")

local function addSpawn(spawnLocation)
	-- listen for the spawn being touched
	spawnLocation.Touched:Connect(function(hit)
		local character = hit:FindFirstAncestorOfClass("Model")
		if character then
			local player = Players:GetPlayerFromCharacter(character)
			if player and player.RespawnLocation ~= spawnLocation then
				local humanoid = character:FindFirstChildOfClass("Humanoid")
				-- make sure the character isn't dead
				if humanoid and humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
					print("spawn set")
					player.RespawnLocation = spawnLocation
				end
			end
		end
	end)
end

local firstSpawn

-- look through the workspace for spawns
for _, descendant in pairs(workspace:GetDescendants()) do
	if descendant:IsA("SpawnLocation") then
		if descendant.Name == "FirstSpawn" then
			firstSpawn = descendant
		end
		addSpawn(descendant)
	end
end

local function playerAdded(player)
	player.RespawnLocation = firstSpawn
end

-- listen for new players
Players.PlayerAdded:Connect(playerAdded)

-- go through existing players
for _, player in pairs(Players:GetPlayers()) do
	playerAdded(player)
end

A propriedade Equipe é uma referência a um objeto Team dentro do serviço Teams.Ela determina a equipe em que o jogador está; se o Player não está em uma equipe ou tem um Player.TeamColor inválido, essa propriedade é nil .Quando essa propriedade é definida, o jogador se juntou ao evento Team e ao evento Team.PlayerAdded na equipe associada.Da mesma forma, Team.PlayerRemoved fogos quando a propriedade é desdefinida de um determinado Team.

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

local teamPlaying = Teams.Playing
local teamSpectators = Teams.Spectating

local playCommand = "/play"

local function play(player)
	player.Team = teamPlaying
	player.TeamColor = teamPlaying.TeamColor
	-- Respawn the player (moves them to spawn location)
	player:LoadCharacter()
end

local function onPlayerDied(player, _character)
	-- When someone dies, put them on the spectator team
	player.Team = teamSpectators
end

local function onPlayerSpawned(player, character)
	local human = character:WaitForChild("Humanoid")
	human.Died:Connect(function()
		onPlayerDied(player, character)
	end)
end

local function onPlayerChatted(player, message)
	if message:sub(1, playCommand:len()):lower() == playCommand then
		play(player)
	end
end

local function onPlayerAdded(player)
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
	player.Chatted:Connect(function(message, _recipient)
		onPlayerChatted(player, message)
	end)
end

for _, player in pairs(Players:GetPlayers()) do
	onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)

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

-- Command to choose a team (note the trailing space)
local joinCommand = "/jointeam "

local function findTeamByName(name)
	-- First, check for the exact name of a team
	if Teams:FindFirstChild(name) then
		return Teams[name]
	end
	-- Let's check for case-insensitive partial matches, like "red" for "Red Robins"
	for _, team in pairs(Teams:GetChildren()) do
		if team.Name:sub(1, name:len()):lower() == name:lower() then
			return team
		end
	end
	-- If we get to this point, no team matched the one we were looking for :(
end

local function onPlayerChatted(player, message, _recipient)
	-- Note: string.sub(message, ...) is the same as message:sub(...)
	if message:sub(1, joinCommand:len()):lower() == joinCommand:lower() then
		-- Matched "/JOINTEAM xyz" to our join command prefix "/jointeam "
		local teamName = message:sub(joinCommand:len() + 1) -- Cut out the "xyz" from "/jointeam xyz"
		local team = findTeamByName(teamName)
		if team then
			-- Set the team!
			player.Team = team
			player.Neutral = false
		else
			-- Tell the player that team could not be found :(
			player.Team = nil
			player.Neutral = true
		end
	end
end

local function onPlayerAdded(player)
	player.Chatted:Connect(function(...)
		onPlayerChatted(player, ...)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

A propriedade TeamColor determina com qual equipe um Jogador está associado de acordo com a Team.TeamColor daquela equipe.Mudar esta propriedade mudará Player.Team de acordo com qualquer equipe que tenha o mesmo BrickColor para seu Team.TeamColor .Se nenhum objeto de Equipe tiver a cor de equipe associada, o jogador não será associado a uma equipe.

Muitas vezes é uma ideia melhor definir Player.Team para o respectivo Team em vez de usar essa propriedade.Definir essa propriedade frequentemente leva à repetição do mesmo valor de BrickColor para uma determinada equipe em muitos scripts; isso é algo que você quer evitar ao aderir ao princípio "Não se repita a si mesmo" (DRY).

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

local teamPlaying = Teams.Playing
local teamSpectators = Teams.Spectating

local playCommand = "/play"

local function play(player)
	player.Team = teamPlaying
	player.TeamColor = teamPlaying.TeamColor
	-- Respawn the player (moves them to spawn location)
	player:LoadCharacter()
end

local function onPlayerDied(player, _character)
	-- When someone dies, put them on the spectator team
	player.Team = teamSpectators
end

local function onPlayerSpawned(player, character)
	local human = character:WaitForChild("Humanoid")
	human.Died:Connect(function()
		onPlayerDied(player, character)
	end)
end

local function onPlayerChatted(player, message)
	if message:sub(1, playCommand:len()):lower() == playCommand then
		play(player)
	end
end

local function onPlayerAdded(player)
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
	player.Chatted:Connect(function(message, _recipient)
		onPlayerChatted(player, message)
	end)
end

for _, player in pairs(Players:GetPlayers()) do
	onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)

O UserId é uma propriedade Player que contém um inteiro de leitura que identifica de forma exclusiva e consistente cada conta de usuário no Roblox.Ao contrário do Instance.Name de um Jogador, que pode mudar de acordo com o nome de usuário presente do usuário, esse valor nunca mudará para a mesma conta.

Essa propriedade é essencial ao salvar/carregar dados do jogador usando GlobalDataStores.Use o ID de usuário de um jogador como a chave do armazenamento de dados para que cada jogador tenha uma chave única.

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	print(player.UserId)
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")

local player = Players:GetPlayerByUserId(1)

if player then
	print("Player with userId 1 is in this server! Their name is: " .. player.Name)
else
	print("Player with userId 1 is not in this server!")
end

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

local OWNER_ID = 212423 -- can use game.CreatorId for published places
local BADGE_ID = 1

local ownerInGame = false

local function playerAdded(newPlayer)
	if newPlayer.UserId == OWNER_ID then
		-- if new player is the owner, set ownerInGame to true and give everyone the badge
		ownerInGame = true
		for _, player in pairs(Players:GetPlayers()) do
			-- don't award the owner
			if player ~= newPlayer then
				BadgeService:AwardBadge(player.UserId, BADGE_ID)
			end
		end
	elseif ownerInGame then
		-- if the owner is in the game, award the badge
		BadgeService:AwardBadge(newPlayer.UserId, BADGE_ID)
	end
end

local function playerRemoving(oldPlayer)
	if oldPlayer.UserId == OWNER_ID then
		ownerInGame = false
	end
end

Players.PlayerAdded:Connect(playerAdded)
Players.PlayerRemoving:Connect(playerRemoving)

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

local goldDataStore = DataStoreService:GetDataStore("Gold")

local STARTING_GOLD = 100

local function onPlayerAdded(player)
	local playerKey = "Player_" .. player.UserId

	local leaderstats = Instance.new("IntValue")
	leaderstats.Name = "leaderstats"

	local gold = Instance.new("IntValue")
	gold.Name = "Gold"
	gold.Parent = leaderstats

	local success, result = pcall(function()
		return goldDataStore:GetAsync(playerKey) or STARTING_GOLD
	end)
	if success then
		gold.Value = result
	else
		-- Failed to retrieve data
		warn(result)
	end

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)

Parâmetros

Devolução

A função ClearCharacterAppearance remove todos Accessory , Shirt , Pants , CharacterMesh e BodyColors do jogador dado Player.Character .Além disso, também remove a camiseta Decal no torso do jogador.A cor da parte do corpo do personagem e o rosto permanecerão inalterados.Este método não faz nada se o jogador não tiver um Personagem.

Não remove t-shirts , malhas de cabeça ou rostos.

Devolução

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local character = player.Character or player.CharacterAdded:Wait()

local function onChildRemoved(child)
	print(child.ClassName, "removed from character")
end

character.ChildRemoved:Connect(onChildRemoved)

player:ClearCharacterAppearance()
--> BodyColors removed from character
--> ShirtGraphic removed from character
--> Shirt removed from character
--> Pants removed from character
--> CharacterMesh removed from character
--> Hat removed from character
--> Shirt removed from character

A função DistanceFromCharacter Player retorna a distância entre a cabeça do personagem e o ponto dado Vector3.Ele retorna 0 se o jogador não tiver Player.Character.

Isso é útil ao determinar a distância entre um jogador e outro objeto ou local no jogo.

Se você quiser determinar a distância entre duas instâncias ou posições não jogadoras, você pode usar o seguinte:

local distance = (position1 - position2).Magnitude

Parâmetros

Devolução

local Players = game:GetService("Players")

for _, player in pairs(Players:GetPlayers()) do
	print(player:DistanceFromCharacter(Vector3.new(0, 0, 0)))
end

Retorna um dicionário que contém informações sobre como o Jogador se junta à experiência. O dicionário contém qualquer um dos seguintes campos:

<th>Tipo de valor</th>

    <th>Descrição</th>
  </tr>
</thead>

<tbody>
  <tr>
    <th>Fonte do JogoId</th>

    <td>número</td>

    <td>O <code>Class.DataModel.GameId</code> da experiência do <code>Jogador</code> teletransportado de.Apenas presente se o jogador se teletransportar para a experiência atual e se um servidor chamar a função de teletransporte.</td>
  </tr>

  <tr>
    <th>Id do Local da Fonte</th>

    <td>número</td>

    <td>O <code>Class.DataModel.PlaceId</code> do local onde o <code>Jogador</code> teletransportou.Apenas presente se o jogador se teletransportar para o local atual e um servidor chamar a função de teletransporte.</td>
  </tr>

  <tr>
    <th>ReferenciadoByPlayerId</th>

    <td>número</td>

    <td>O <code>Class.Player.UserId</code> do jogador que convidou o jogador atual para a experiência.Use esses dados para identificar o remetente e ativar a lógica de recompensa.</td>
  </tr>

  <tr>
    <th>Membros</th>

    <td>array</td>

    <td>Um array que contém os números <code>Class.Player.UserId</code> dos usuários teletransportados ao lado do <code>Jogador</code>.Apenas presente se o jogador se teletransportou como parte de um grupo.</td>
  </tr>

  <tr>
    <th>Dados de Teletransporte</th>

    <td>variáveis</td>

    <td>Reflete o <code>teleportData</code> especificado no teletransporte original.Útil para compartilhar informações entre os servidores para os quais o jogador se teletransporta.Apenas presente se <code>teleportData</code> for especificado e um servidor chamar a função de teletransporte.</td>
  </tr>

  <tr>
    <th>Dados de lançamento</th>

    <td>corda</td>

    <td>Uma string codificada em JSON ou simples que contém dados de lançamento especificados em um <a href="/production/promotion/deeplinks">deep link</a> URL ou <code>Class.ExperienceInviteOptions.LaunchData</code>.</td>
  </tr>

  <tr>
    <th>Contexto de Entrada de Jogo</th><td>dicionário</td>

    <td>
      Um dicionário que inclui informações relevantes com base no contexto da entrada do jogo. Contém as seguintes chaves:

      <ul>
        Fonte de Entrada : Enum.JoinSource > Tipo de Item : opcional Enum.AvatarItemType ID de Recurso : opcional string ID de Conjunto : opcional string Tipo de Recurso : opcional Enum.ResourceType ID de Recurso : opcional string
      </ul>
    </td>
  </tr>
</tbody>

Obter Dados de Entrada e Teletransporte de Dados

Se um servidor iniciar o teletransporte do Jogador, o dicionário que este método retorna inclui os dados de teletransporte do jogador.O método Player:GetJoinData() só pode ser usado para obter dados de teletransporte no servidor.Para obter os dados no cliente, use TeleportService:GetLocalPlayerTeleportData() .

Ao contrário de TeleportService:GetLocalPlayerTeleportData(), Player:GetJoinData() fornece apenas dados de teletransporte que atendam aos seguintes critérios de segurança:

• Está garantido que foi enviado por um servidor Roblox nas últimas 48 horas.
• Está garantido que foi enviado com este Player .
• O SourcePlaceId e SourceGameId são garantidos de ser o local e o universo de onde os dados foram enviados.Isso significa que você pode verificar que os dados de teleporte vieram de um local aprovado.

Como esses dados são transmitidos pelo cliente, ainda pode ser potencialmente abusado por um explorador.Dados sensíveis, como moeda do jogador, devem ser transmitidos por meio de uma solução segura como Armazenamentos de Memória.

Devolução

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

local analyticsStore = DataStoreService:GetDataStore("Analytics")

local ALLOWED_SOURCES = {
	"twitter",
	"youtube",
	"discord",
}

local function onPlayerAdded(player)
	local source = player:GetJoinData().LaunchData
	-- check if the provided source is valid
	if source and table.find(ALLOWED_SOURCES, source) then
		-- update the data store to track the source popularity
		local success, result = pcall(analyticsStore.IncrementAsync, analyticsStore, source)

		if success then
			print(player.Name, "joined from", source, "- total:", result)
		else
			warn("Failed to record join source: " .. result)
		end
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local DIRECT_JOIN_URL = "https://www.roblox.com/games/start?placeId=%d&launchData=%s"

local textBox = script.Parent

local function generateReferralURL(player)
	return DIRECT_JOIN_URL:format(game.PlaceId, player.UserId)
end

local function highlightAll()
	if -- avoid recursive property updates
		textBox:IsFocused() and not (textBox.SelectionStart == 1 and textBox.CursorPosition == #textBox.Text + 1)
	then
		textBox.SelectionStart = 1
		textBox.CursorPosition = #textBox.Text + 1
	end
end

textBox.Focused:Connect(highlightAll)
textBox:GetPropertyChangedSignal("SelectionStart"):Connect(highlightAll)
textBox:GetPropertyChangedSignal("CursorPosition"):Connect(highlightAll)

textBox.TextEditable = false
textBox.ClearTextOnFocus = false

textBox.Text = generateReferralURL(player)

local HttpService = game:GetService("HttpService")

local DATA_CHARACTER_LIMIT = 200

local function encodeTableAsLaunchData(data)
	-- convert the table to a string
	local jsonEncodedData = HttpService:JSONEncode(data)

	if #jsonEncodedData <= DATA_CHARACTER_LIMIT then
		-- escape potentially invalid characters, such as spaces
		local urlEncodedData = HttpService:UrlEncode(jsonEncodedData)
		return true, urlEncodedData
	else
		-- report character limit error
		return false, ("Encoded table exceeds %d character limit"):format(DATA_CHARACTER_LIMIT)
	end
end

local sampleData = {
	joinMessage = "Hello!",
	urlCreationDate = os.time(),
	magicNumbers = {
		534,
		1337,
		746733573,
	},
}

local success, encodedData = encodeTableAsLaunchData(sampleData)

if success then
	print(encodedData)
else
	warn("failed to encode launch data: " .. encodedData)
end

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

local function onPlayerAdded(player)
	local launchData = player:GetJoinData().LaunchData
	if launchData then
		-- attempt to decode the data
		local success, result = pcall(HttpService.JSONDecode, HttpService, launchData)
		if success then
			print(player.Name, "joined with data:", result)
		else
			-- this is probably due to the user messing with the URL
			warn("Failed to parse launch data:" .. result)
		end
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")

local approvedPlaceIds = { 1 } -- insert approved PlaceIds here

local function isPlaceIdApproved(placeId)
	for _, id in pairs(approvedPlaceIds) do
		if id == placeId then
			return true
		end
	end
	return false
end

local function onPlayerAdded(player)
	local joinData = player:GetJoinData()

	-- verify this data was sent by an approved place
	if isPlaceIdApproved(joinData.SourcePlaceId) then
		local teleportData = joinData.TeleportData
		if teleportData then
			local currentLevel = teleportData.currentLevel
			print(player.Name .. " is on level " .. currentLevel)
		end
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

A função GetMouse Player retorna o Mouse sendo usado pelo cliente.A instância do mouse do jogador pode ser usada para rastrear a entrada do mouse do usuário, incluindo cliques de botão de mouse esquerdo e direito e movimento e localização.

O serviço UserInputService fornece funções e eventos adicionais para rastrear a entrada do usuário - especialmente para dispositivos que não usam um mouse.

Nota:

• Este item deve ser usado em um LocalScript funcionar como esperado online.
• Após uma atualização em julho de 2014, o ícone do mouse agora pode ser definido com este método.

Devolução

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local mouse = player:GetMouse()

local function onButton1Down()
	print("Button 1 is down")
end

mouse.Button1Down:Connect(onButton1Down)

GetNetworkPing retorna a latência de rede isolada do Player em segundos.“Ping” é uma medida do tempo levado para os dados serem enviados do cliente para o servidor, e depois de volta.Não envolve deserialização ou processamento de dados.

Para o lado do cliente LocalScripts, esta função só pode ser chamada no Players.LocalPlayer.Essa função é útil para identificar e solucionar problemas que ocorrem em cenários de latência de rede alta.Também é útil para disfarçar a latência, como ajustar a velocidade de animações de arremesso para projéteis.

Devolução

A função HasAppearanceLoaded Player retorna se a aparência do jogador Player.Character foi carregada ou não.

A aparência de um jogador inclui itens como o do jogador Shirt, Pants e Accessories.

Isso é útil ao determinar se a aparência de um jogador foi carregada após ele se juntar ao jogo pela primeira vez, que pode ser rastreada usando o evento Players.PlayerAdded.

Devolução

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	local loaded = player:HasAppearanceLoaded()
	print(loaded)

	while not loaded do
		loaded = player:HasAppearanceLoaded()
		print(loaded)
		task.wait()
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

Retorna um valor booleano indicando o status de verificação do jogador.Quando verdadeiro, o jogador é verificado.A verificação inclui, mas não se limita a, número de telefone não VOIP ou verificação de identificação do governo.

Ao implementar IsVerified, exercite cautela para garantir que a implementação não bloqueie inadvertidamente todos os usuários não verificados.

Observe que o método só pode ser chamado no servidor de backend.Chamá-lo de resultados do lado do cliente resulta em um erro.Além disso, esse método sempre retornará false no Studio.

Devolução

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	print(player:IsVerified())
end

for _, player in pairs(Players:GetPlayers()) do
	onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)

O método Kick() permite que uma experiência desconecte gentilmente um cliente e opcionalmente forneça uma mensagem ao usuário desconectado.Isso é útil para moderar usuários abusivos.Você deve permitir apenas usuários específicos de quem você confia para disparar esse método em outros usuários.

Chamar este método em um Player sem argumentos desconecta o usuário do servidor e fornece uma mensagem de aviso padrão.Chamando este método em um Player junto com uma string como o primeiro argumento substitui a mensagem padrão pela string fornecida.

Ao usar esse método a partir de um LocalScript , apenas o cliente do usuário local pode ser expulso.

Parâmetros

Devolução

A função Movimento Player faz com que o personagem do jogador caminhe na direção dada até ser interrompido ou interrompido pelo jogador (usando seus controles).

Isso é útil ao escrever NPC Humanoids que se movem ao redor de um mapa - mas não são controlados pela entrada de um jogador real.

Observe que o segundo argumento da função indica se o fornecido Vector3 deve mover o jogador em relação às coordenadas mundiais ( falsa ) ou ao jogador Camera ( verdadeira ).