Player

El AccountAge es una propiedad Player que describe cuánto tiempo atrás se registró una cuenta de jugador en días.Se establece usando la función Player:SetAccountAge(), que no puede ser accedida por scripts.

Esta propiedad es útil para mostrar condicionalmente el contenido nuevo de los jugadores de Roblox, como tutoriales.

local Players = game:GetService("Players")

local MAX_AGE_NEW_PLAYER = 7 -- una semana
local MIN_AGE_VETERAN = 365 -- un año

-- Esta función marca una parte con texto usando un 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) -- Llenar padre
	textLabel.Text = text
	textLabel.TextColor3 = Color3.new(1, 1, 1)
	textLabel.TextStrokeTransparency = 0
	textLabel.BackgroundTransparency = 1
	textLabel.Parent = bbgui
	-- Añadir a la parte
	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)
	-- Escuchar a este jugador apareciendo
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

La propiedad AutoJumpEnabled determina si el Player.Character de un Player usando un dispositivo móvil saltará automáticamente cuando golpee un obstáculo.Esto puede hacer que los niveles sean más navegables mientras estás en un dispositivo móvil.

Cuando el jugador se une al juego, el valor StarterPlayer.AutoJumpEnabled determina el estado inicial de esta propiedad.Luego, esta propiedad determina el valor de la propiedad Humanoid.AutoJumpEnabled de la Player.Character en el momento del desove.En otras palabras, es posible establecer el comportamiento de salto automático en una base por caracteres, por jugadores y por juegos usando estas tres propiedades.

local Players = game:GetService("Players")

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

local function update()
	-- Texto del botón de actualización
	if player.AutoJumpEnabled then
		button.Text = "Auto-Jump is ON"
	else
		button.Text = "Auto-Jump is OFF"
	end
	-- Reflejar la propiedad en el personaje del jugador, si tiene uno
	if player.Character then
		local human = player.Character:FindFirstChild("Humanoid")
		if human then
			human.AutoJumpEnabled = player.AutoJumpEnabled
		end
	end
end

local function onActivated()
	-- Alternar salto automático
	player.AutoJumpEnabled = not player.AutoJumpEnabled
	-- Actualizar todo lo demás
	update()
end

button.Activated:Connect(onActivated)
update()

La propiedad CameraMaxZoomDistance Player establece la distancia máxima en studs que la cámara puede estar del personaje con las cámaras predeterminadas.

En otras palabras, controla la distancia máxima que la cámara del jugador se permite alejar.

El valor predeterminado de esta propiedad se establece por StarterPlayer.CameraMaxZoomDistance .Si este valor se establece en un valor inferior a Player.CameraMinZoomDistance , se aumentará a CameraMinZoomDistance.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

La propiedad CameraMinZoonDistance Player establece la distancia mínima en studs que la cámara puede estar del personaje con las cámaras predeterminadas.

En otras palabras, controla la distancia mínima en la que la cámara del jugador se puede acercar.

El valor predeterminado de esta propiedad se establece por StarterPlayer.CameraMinZoomDistance .Si este valor se establece en un valor superior a Player.CameraMaxZoomDistance se reducirá a CameraMaxZoomDistance.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

La propiedad Modo de cámara establece el modo de cámara del jugador, predeterminando el modo de tercera persona.

Tercera persona

En el modo predeterminado de tercera persona ( Enum.CameraMode.Classic ), el personaje se puede ver en la cámara. Mientras que en este modo, el comportamiento predeterminado es:

• Los jugadores pueden hacer clic derecho y arrastrar (ratón), tocar y arrastrar (móvil), usar el joystick secundario (consola) o presionar las flechas izquierda/derecha (teclado) para girar la cámara alrededor de su personaje.
• Cuando un jugador mueve a su personaje, se enfrenta en la dirección de movimiento correspondiente.
• Los jugadores pueden acercarse y alejarse libremente, incluso para la primera persona en zoom completo.

Primera persona

En el modo de primera persona ( Enum.CameraMode.LockFirstPerson ), la cámara del jugador se acerca todo el camino.A menos que haya una interfaz gráfica visible presente con la propiedad GuiButton.Modal configurada en true , mover el mouse, arrastrar en el móvil o usar el joystick secundario en un gamepad girará la cámara alrededor del personaje.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMode = Enum.CameraMode.LockFirstPerson

La propiedad CanLoadCharacterAppearance Player determina si se cargará la apariencia del personaje cuando el jugador se genere.El valor predeterminado de esta propiedad se establece por StarterPlayer.LoadPlayerAppearance .

Si verdadero , el personaje cargará la apariencia del jugador correspondiente al jugador Player.CharacterAppearanceId .

Si false , el jugador se generará con una apariencia predeterminada - un modelo de personaje gris sin sombreros, camisas, pantalones, etc.

Intentar establecer la propiedad después de que el personaje se haya generado no cambiará el personaje, debe llamar Player:LoadCharacter() para cargar la nueva apariencia.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CanLoadCharacterAppearance = false

La propiedad Carácter contiene una referencia a un Model que contiene un Humanoid , partes del cuerpo, scripts y otros objetos requeridos para simular el avatar del jugador en la experiencia.El modelo está patrocinado por el Workspace pero se puede mover.Se carga automáticamente cuando Players.CharacterAutoLoads es true y se puede cargar manualmente de otra manera usando Player:LoadCharacter() .

Inicialmente, esta propiedad es nil y se establece cuando el personaje del jugador aparece por primera vez.Usa el evento Player.CharacterAdded para detectar cuando el personaje de un jugador se carga correctamente, y el evento Player.CharacterRemoving para detectar cuando el personaje está a punto de desaparecer.Evite usar Object:GetPropertyChangedSignal() en esta propiedad.

Tenga en cuenta que LocalScripts que se clonan de StarterGui o StarterPack en un jugador de PlayerGui o Backpack respectivamente se ejecutan a menudo antes de que se reemplace el modelo de personaje antiguo, por lo que Player.Character puede referirse al modelo antiguo cuya propiedad Parent es nil.Por lo tanto, en un LocalScript bajo StarterGui o StarterPack , es recomendable asegurarse de que el padre de Personaje no sea nil antes de usarlo, por ejemplo:

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

Esta propiedad determina la ID de usuario de la cuenta cuya apariencia de personaje se usa para la apariencia de un jugador de character .Por defecto, esta propiedad es la Player.UserId , que utiliza el avatar del jugador como lo han creado en el sitio web de Roblox.

Cambiar esta propiedad a la ID de usuario de otra cuenta hará que el jugador se genere con la apariencia de esa cuenta (sombreros, camisa, pantalones, etc).

Los juegos también pueden alternar si el aspecto del personaje de un jugador se carga en el juego o no cambiando la propiedad 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 -- El número no se pudo analizar, tal vez escribieron un nombre de usuario en lugar
			pcall(function() -- ¡Esta llamada puede fallar a veces!
				id = Players:GetUserIdFromNameAsync(input) -- Obtener ID de nombre
			end)
		end
		if id then
			-- Establecer la apariencia del personaje y luego reaparecer
			player.CharacterAppearanceId = id
			player:LoadCharacter()
		else
			-- No pudimos obtener una identificación de su entrada
		end
	end
end

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

Players.PlayerAdded:Connect(onPlayerAdded)

Define cómo los scripts de cámara predeterminados manejan los objetos entre la cámara y el sujeto de la cámara.Establecido por StarterPlayer.DevCameraOcclusionMode y no se puede cambiar para jugadores individuales.

El valor predeterminado es Zoom (0). Vea Enum.DevCameraOcclusionMode para una lista de modos disponibles.

La propiedad DevComputerCameraMode determina la manera en que un jugador mueve su cámara al usar un dispositivo con un mouse y un teclado.Vea Enum.DevComputerCameraMovementMode para una descripción de cada modo de control de cámara disponible.Esta propiedad no se puede configurar usando un LocalScript (debe configurarse en el servidor usando un Script ).

El valor predeterminado de esta propiedad se determina por StarterPlayer.DevComputerCameraMovementMode.

La palabra "Ordenador" en este nombre de propiedad se refiere a dispositivos no TouchEnabled , no GamepadEnabled .

Cuando se establece en Elección del usuario , un jugador puede elegir entre cualquier modo de control (excepto Scriptable ) en las configuraciones de la experiencia durante el juego.En general, es una buena idea permitir que los jugadores elijan su modo de control para maximizar la accesibilidad.

Es posible crear un esquema de control personalizado al establecer esta propiedad en Scriptable .

Esta propiedad no afecta a los jugadores que usan un dispositivo habilitado para tocar. Vea 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

La propiedad DevComputerMovementMode determina la manera en que un jugador mueve su personaje al usar un dispositivo con un mouse y un teclado.Vea Enum.DevComputerMovementMode para una descripción de cada modo de control de movimiento disponible.Esta propiedad no se puede configurar usando un LocalScript (debe configurarse en el servidor usando un Script ).

El valor predeterminado de esta propiedad se determina por StarterPlayer.DevComputerMovementMode.

La palabra "Ordenador" en este nombre de propiedad se refiere a dispositivos no TouchEnabled de.

Cuando se establece en Elección del usuario , un jugador puede elegir entre cualquier modo de control (excepto Scriptable ) en las configuraciones de la experiencia durante el juego.En general, es una buena idea permitir que los jugadores elijan su modo de control para maximizar la accesibilidad.

Es posible crear un esquema de control personalizado al establecer esta propiedad en Scriptable .

Esta propiedad no afecta a los jugadores que usan un dispositivo habilitado para tocar. Vea 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)

Esta propiedad determina si un jugador puede alternar el bloqueo Mouse presionando Shift.Un jugador puede desactivar el interruptor de bloqueo del mouse en las configuraciones de la experiencia durante el juego.Por defecto, esta propiedad se establece en el valor de StarterPlayer.EnableMouseLockOption .Esto se puede configurar en el lado del servidor durante el tiempo de ejecución usando un Script.No se puede configurar en el lado del cliente.

Cuando se habilita el bloqueo del mouse, el cursor del jugador se bloquea en el centro de la pantalla.Mover el mouse orbitará la cámara alrededor del jugador character , y el personaje se enfrentará con la misma dirección que el camera .También compensa la vista de la cámara justo sobre el hombro derecho del personaje del jugador.

Tenga en cuenta que las API relacionadas con el bloqueo de cambio están en proceso de ser obsoletas, por lo que se recomienda usar UserInputService.MouseBehavior en lugar de bloquear el 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)

La propiedad DevTouchCameraMode determina la manera en que un jugador mueve su cámara al usar un dispositivo TouchEnabled.Vea Enum.DevTouchCameraMovementMode para una descripción de cada modo de control de cámara disponible.Esta propiedad no se puede configurar usando un LocalScript (debe configurarse en el servidor usando un Script ).

El valor predeterminado de esta propiedad se determina por StarterPlayer.DevTouchCameraMovementMode.

Cuando se establece en Elección del usuario , un jugador puede elegir entre cualquier modo de control (excepto Scriptable ) en las configuraciones de la experiencia durante el juego.En general, es una buena idea permitir que los jugadores elijan su modo de control para maximizar la accesibilidad.

Es posible crear un esquema de control personalizado al establecer esta propiedad en Scriptable .

Esta propiedad no afecta a los jugadores que no están usando un dispositivo habilitado para tocar. Vea 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

La propiedad DevTouchMovementMode determina la manera en que un jugador mueve a su personaje al usar un dispositivo TouchEnabled.Vea Enum.DevTouchMovementMode para una descripción de cada modo de control de movimiento disponible.Esta propiedad no se puede configurar usando un LocalScript (debe configurarse en el servidor usando un Script ).

El valor predeterminado de esta propiedad se determina por StarterPlayer.DevTouchMovementMode.

Cuando se establece en Elección del usuario , un jugador puede elegir entre cualquier modo de control (excepto Scriptable ) en las configuraciones de la experiencia durante el juego.En general, es una buena idea permitir que los jugadores elijan su modo de control para maximizar la accesibilidad.

Es posible crear un esquema de control personalizado al establecer esta propiedad en Scriptable .

Esta propiedad no afecta a los jugadores que no están usando un dispositivo habilitado para tocar. Vea 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)

El DisplayName es una propiedad Player que contiene el nombre de visualización del usuario autenticado asociado con el objeto Player.A diferencia de los nombres de usuario, los nombres de visualización son nombres no únicos que un jugador muestra a los demás.Si el usuario de Roblox no ha elegido uno, la propiedad se leerá igual que la propiedad Name.

Nota:

• Dado que los nombres de visualización no son únicos, es posible que dos jugadores en una sola instancia tengan nombres idénticos.Si necesita un identificador globalmente único para un jugador, use Player.UserId (que es estático) o Player.Name (que es el nombre de usuario actual) en su lugar.
• Los personajes generados con Player.LoadCharacter o por el motor de Roblox tendrán asignada su propiedad Humanoid.DisplayName a la propiedad Player.DisplayName.
• Los nombres de visualización pueden tener caracteres de un idioma en la cadena. Vea UTF-8 para más información sobre cómo trabajar con cadenas con caracteres de un idioma.

El seguimiento de usuario es una propiedad Player que contiene el Player.UserId del usuario que un jugador siguió al juego.Si el jugador no siguió a nadie al juego, esta propiedad será 0.Esta propiedad es útil para alertar a los jugadores que han sido seguidos por otro jugador al juego.

Puedes obtener el nombre del jugador seguido usando este ID de usuario y la función 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)

La propiedad GameplayPaused indica si el jugador está actualmente en un estado de pausa en un lugar con StreamingEnabled activado.Se establece en el cliente pero se replica al servidor.Para determinar el estado de pausa, puedes utilizar esta propiedad.

Vea también:

• Workspace.StreamingEnabled que controla si se habilita el streaming de contenido
• Workspace.StreamingIntegrityMode y Enum.StreamingIntegrityMode para más detalles sobre cuándo se detiene el juego.

La propiedad HasVerifiedBadge Player indica si el jugador tiene una insignia verificada.

La propiedad HealthDisplayDistance establece la distancia en studs en la que este jugador verá otras barras de salud.Si se establece en 0, las barras de salud no se mostrarán.Esta propiedad se establece en StarterPlayer.HealthDisplayDistance por defecto.

Si la barra de salud de un humanoide es visible, puedes establecer el tipo de visualización usando Humanoid.DisplayDistanceType.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

La propiedad LocaleId Player muestra el ID del idioma que el jugador local ha establecido para su cuenta de Roblox.Almacena una cadena con el código de dos letras (por ejemplo, "en-us") para el idioma local.

Esto se puede utilizar para determinar la demografía geográfica de la base de jugadores de tu juego y también es el idioma que se utilizará para la localización automática del contenido en la experiencia (ver GuiBase2d.AutoLocalize ).Esta propiedad permite el acceso al local del jugador desde el servidor.

Vea también LocalizationService.RobloxLocaleId , la ID local utilizada para localizar el contenido interno.Este será un valor diferente cuando Roblox aún no soporte internamente el conjunto local del jugador local.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

print(player.LocaleId)

Esta propiedad solo se puede leer para determinar la membresía (no se puede establecer en otro tipo de membresía).Contiene un Enum.MembershipType enumerado de tipo de membresía de la cuenta.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

if player.MembershipType == Enum.MembershipType.Premium then
	-- Toma alguna acción específicamente para miembros premium
end

La propiedad NameDisplayDistance StarterPlayer establece la distancia en studs en la que este jugador verá otros nombres Humanoid.Si la propiedad se establece en 0, los nombres se ocultan.Esta propiedad se establece en StarterPlayer.NameDisplayDistance por defecto.

Si la barra de salud de un humanoide es visible, puedes establecer el tipo de visualización usando Humanoid.DisplayDistanceType.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

La propiedad Neutral determina si el jugador está en un equipo específico.

• Cuando verdadero, el jugador no está en un equipo específico.Esto también significa que la propiedad Player.Team será nil y la Player.TeamColor será blanca.
• Cuando false, el jugador está en un equipo específico.La propiedad Player.Team se corresponderá con la Team en la que se encuentra el jugador, así como la 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

Una cadena de solo lectura que identifica al grupo al que el jugador actualmente pertenece dentro de la experiencia.Si el jugador no está en una fiesta, este valor es una cadena vacía.

Esta propiedad es esencial para integrarse con la función de fiesta de Roblox.Úselo en combinación con SocialService:GetPlayersByPartyId() y SocialService:GetPartyAsync() para acceder a información sobre el grupo de un jugador y sus miembros.

Tenga en cuenta que este servicio no funciona durante las pruebas de juego en Roblox Studio; para probar aspectos de su experiencia usándolo, debe publicar la experiencia y jugarla en la aplicación de 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)

La propiedad ReplicationFocus Player establece que la parte se centre en la replicación alrededor de un Jugador.Diferentes sistemas de Roblox que se comunican a través de la red (como la física, el streaming, etc) se replican a diferentes velocidades dependiendo de cuán cerca estén los objetos del enfoque de replicación.

Cuando esta propiedad es nil , se revertirá a su comportamiento predeterminado, que es tratar el personaje del jugador local PrimaryPart como el enfoque de replicación.

Esta propiedad solo debe establecerse en el servidor con un Script, no con un LocalScript.Tenga en cuenta que esta propiedad no cambia o actualiza la propiedad de red de partes.

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

Si se establece, el jugador reaparecerá en el dado SpawnLocation.Esta propiedad solo se puede establecer a través de Luau y debe contener una referencia a un válido SpawnLocation, que debe cumplir con los siguientes criterios:

• Descendiente de Workspace
• SpawnLocation.TeamColor está configurado como Player.TeamColor o SpawnLocation.Neutral está configurado como verdadero

Si RespawnLocation no está configurado como válido SpawnLocation entonces se aplicará la lógica de generación predeterminada.Para obtener más información sobre esto, consulte la página para SpawnLocation .

Alternativas para RespawnLocation

• Un Player aparecerá de SpawnLocations perteneciente a su equipo. En algunos casos, puede ser más sencillo cambiar el Player.Team del jugador en su lugar.
• Implementa tu propia lógica de generación personalizada utilizando PVInstance:PivotTo() para mover manualmente el 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

La propiedad Equipo es una referencia a un objeto Team dentro del servicio Teams.Determina el equipo al que está en el jugador; si el Player no está en un equipo o tiene un Player.TeamColor inválido, esta propiedad es nil .Cuando esta propiedad se establece, el jugador se ha unido al evento Team y al evento Team.PlayerAdded en el equipo asociado.Del mismo modo, Team.PlayerRemoved incendia cuando la propiedad no está desactivada de un cierto 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)

La propiedad TeamColor determina con qué equipo está asociado un jugador según el Team.TeamColor.Cambiar esta propiedad cambiará Player.Team de acuerdo con qué equipo tenga la misma BrickColor para su Team.TeamColor .Si ningún objeto de equipo tiene el color de equipo asociado, el jugador no se asociará con un equipo.

A menudo es una mejor idea establecer Player.Team a la respectiva Team en lugar de usar esta propiedad.Establecer esta propiedad a menudo conduce a la repetición del mismo valor de Color de ladrillo para un equipo determinado en muchos scripts; esto es algo que quieres evitar al adherirte al principio "No te repitas a ti mismo" (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)

El UserId es una propiedad Player que contiene un entero de lectura que identifica de manera única y consistente a cada cuenta de usuario en Roblox.A diferencia del Instance.Name de un Jugador, que puede cambiar según el nombre de usuario presente del usuario, este valor nunca cambiará por la misma cuenta.

Esta propiedad es esencial al guardar/cargar datos del jugador usando GlobalDataStores .Usa el ID de usuario de un jugador como clave del almacén de datos para que cada jugador tenga una clave ú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

Devuelve

La función ClearCharacterAppearance elimina todos Accessory , Shirt , Pants , CharacterMesh y BodyColors de la apariencia del jugador dado Player.Character .Además, también elimina la camiseta Decal en el torso del jugador.Las partes del cuerpo y la cara del personaje se mantendrán sin cambios.Este método no hace nada si el jugador no tiene un personaje.

No elimina t-shirts , mallas de cabeza o caras.

Devuelve

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

La función DistanceFromCharacter Player devuelve la distancia entre la cabeza del personaje y el punto dado Vector3.Devuelve 0 si el jugador no tiene Player.Character.

Esto es útil al determinar la distancia entre un jugador y otro objeto o ubicación en el juego.

Si desea determinar la distancia entre dos instancias o posiciones no jugadoras, puede usar lo siguiente:

local distance = (position1 - position2).Magnitude

Parámetros

Devuelve

local Players = game:GetService("Players")

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

Devuelve un diccionario que contiene información que describe cómo el Jugador se une a la experiencia. El diccionario contiene cualquiera de los siguientes campos:

<th>Tipo de valor</th>

    <th>Descripción</th>
  </tr>
</thead>

<tbody>
  <tr>
    <th>Id de juego de origen</th>

    <td>número</td>

    <td>El <code>Class.DataModel.GameId</code> de la experiencia del <code>Jugador</code> que se teletransportó desde.Solo presente si el jugador se teletransporta a la experiencia actual y si un servidor llama a la función de teletransporte.</td>
  </tr>

  <tr>
    <th>Id de lugar de origen</th>

    <td>número</td>

    <td>El <code>Class.DataModel.PlaceId</code> del lugar al que se teletransportó el <code>Jugador</code>.Solo presente si el jugador se teletransporta al lugar actual y un servidor llama a la función de teletransporte.</td>
  </tr>

  <tr>
    <th>Referenciado por PlayerId</th>

    <td>número</td>

    <td>El <code>Class.Player.UserId</code> del jugador que invitó al jugador actual a la experiencia.Utilice estos datos para identificar al remitente y activar la lógica de recompensa.</td>
  </tr>

  <tr>
    <th>Miembros</th>

    <td>matriz</td>

    <td>Un array que contiene los números <code>Class.Player.UserId</code> de los usuarios teletransportados junto con el <code>Jugador</code>.Solo presente si el jugador se teletransportó como parte de un grupo.</td>
  </tr>

  <tr>
    <th>Teletransportar datos</th>

    <td>variación</td>

    <td>Refleja el <code>teleportData</code> especificado en el teletransporte original.Útil para compartir información entre los servidores a los que se teletransporta el jugador.Solo presente si <code>teleportData</code> se especificó y un servidor llama a la función de teletransporte.</td>
  </tr>

  <tr>
    <th>Datos de lanzamiento</th>

    <td>texto</td>

    <td>Una cadena simple o codificada en JSON que contiene datos de lanzamiento especificados en un <a href="/production/promotion/deeplinks">enlace profundo</a> URL o <code>Class.ExperienceInviteOptions.LaunchData</code>.</td>
  </tr>

  <tr>
    <th>Contexto de unión de juego</th><td>diccionario</td>

    <td>
      Un diccionario que incluye información relevante basada en el contexto de la unión del juego. Contiene las siguientes claves:

      <ul>
        JoinSource : Enum.JoinSource Tipo de artículo : opcional Enum.AvatarItemType ID de activo : opcional cadena Tipo de atuendo : opcional cadena Tipo de activo : opcional Enum.AssetType ID de activo : opcional cadena Tipo de artículo : opcional cadena
      </ul>
    </td>
  </tr>
</tbody>

Obtener datos de unión y datos de teletransporte

Si un servidor inicia el teletransporte del jugador, el diccionario que devuelve este método incluye los datos de teletransporte del jugador.El método Player:GetJoinData() solo se puede usar para recuperar datos de teletransporte en el servidor.Para recuperar los datos en el cliente, use TeleportService:GetLocalPlayerTeleportData() .

A diferencia de TeleportService:GetLocalPlayerTeleportData() , Player:GetJoinData() solo proporciona datos de teletransporte que cumplen con los siguientes criterios de seguridad:

• Está garantizado que fue enviado por un servidor de Roblox en las últimas 48 horas.
• Está garantizado que se haya enviado con este Player .
• Se garantiza que los SourcePlaceId y SourceGameId sean el lugar y el universo desde el que se enviaron los datos.Esto significa que puedes verificar que los datos de teletransporte provienen de un lugar aprobado.

Como estos datos son transmitidos por el cliente, aún puede ser abusado potencialmente por un explotador.Los datos sensibles como la moneda del jugador deben transmitirse a través de una solución segura como Almacenes de memoria.

Devuelve

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)

La función GetMouse Player devuelve el Mouse que está siendo utilizado por el cliente.La instancia del ratón del jugador se puede utilizar para rastrear la entrada del ratón del usuario, incluidos los clics de los botones izquierdo y derecho del ratón y el movimiento y la ubicación.

El servicio UserInputService proporciona funciones y eventos adicionales para rastrear la entrada del usuario - especialmente para dispositivos que no usan un mouse.

Nota:

• Este elemento debe usarse en un LocalScript para funcionar como se esperaba en línea.
• Después de una actualización en julio de 2014, el icono del ratón ahora se puede configurar con este método.

Devuelve

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 devuelve la latencia de red aislada del Player en segundos.La "ping" es una medición del tiempo que se tarda en enviar los datos desde el cliente al servidor, y luego de nuevo.No implica la deserialización o procesamiento de datos.

Para el lado del cliente LocalScripts, esta función solo se puede llamar en el Players.LocalPlayer.Esta función es útil para identificar y solucionar problemas que ocurren en escenarios de alta latencia de red.También es útil para ocultar la latencia, como ajustar la velocidad de las animaciones de lanzamiento para proyectiles.

Devuelve

La función HasAppearanceLoaded Player devuelve si la apariencia del jugador Player.Character se ha cargado o no.

La apariencia de un jugador incluye elementos como la apariencia del jugador Shirt, Pants y Accessories.

Esto es útil al determinar si la apariencia de un jugador se ha cargado después de que se unan por primera vez al juego, que se puede rastrear usando el evento Players.PlayerAdded.

Devuelve

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)

Devuelve un valor booleano que indica el estado de verificación del jugador.Cuando es verdadero, el jugador se verifica.La verificación incluye, pero no se limita a, el número de teléfono no VOIP o la verificación de identificación gubernamental.

Al implementar IsVerified , ejerza precaución para asegurarse de que la implementación no bloquee inadvertidamente a todos los usuarios no verificados.

Tenga en cuenta que el método solo se puede llamar en el servidor de backend.Llamarlo resultados del lado del cliente da como resultado un error.Además, este método siempre devolverá false en Studio.

Devuelve

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)

El método Kick() permite que una experiencia desconecte elegantemente a un cliente y opcionalmente proporcione un mensaje al usuario desconectado.Esto es útil para moderar usuarios abusivos.Solo deberías permitir que usuarios específicos a los que confías activen este método en otros usuarios.

Llamar a este método en un Player sin argumentos desconecta al usuario del servidor y proporciona un mensaje de aviso predeterminado.Llamar a este método en un Player junto con una cadena como primer argumento que reemplaza el mensaje predeterminado con la cadena proporcionada.

Al usar este método desde un LocalScript , solo el cliente del usuario local puede ser expulsado.

Parámetros

Devuelve

La función de movimiento Player hace que el personaje del jugador camine en la dirección dada hasta que se detenga, o sea interrumpido por el jugador (usando sus controles).

Esto es útil cuando se programan NPC que se mueven alrededor de un mapa - pero no son controlados por la entrada de un jugador real.

Tenga en cuenta que el segundo argumento de la función indica si el proporcionado Vector3 debe mover al jugador en relación con las coordenadas mundiales (falsa) o con las coordenadas del jugador Camera (verdadera).

Parámetros

Devuelve

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

-- Wait for the player's character and humanoid, which must exist before calling :Move()
local character = localPlayer.Character or localPlayer.CharacterAdded:Wait()
character:WaitForChild("Humanoid")

-- The player will move until they are 50 studs away from the camera's position at the time of running
localPlayer:Move(Vector3.new(0, 0, -50), true)

Parámetros

Devuelve

La función SetAccountAge establece el Player.AccountAge del jugador en días.

Se usa para establecer la propiedad Player que describe cuánto tiempo se registró la cuenta de un jugador en días.

Esto no establece la edad del jugador en la cuenta, sino la edad de la cuenta misma en relación con cuando se creó por primera vez.

Parámetros

Devuelve

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player:SetAccountAge(100)

local Players = game:GetService("Players")

local MAX_AGE_NEW_PLAYER = 7 -- una semana
local MIN_AGE_VETERAN = 365 -- un año

-- Esta función marca una parte con texto usando un 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) -- Llenar padre
	textLabel.Text = text
	textLabel.TextColor3 = Color3.new(1, 1, 1)
	textLabel.TextStrokeTransparency = 0
	textLabel.BackgroundTransparency = 1
	textLabel.Parent = bbgui
	-- Añadir a la parte
	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)
	-- Escuchar a este jugador apareciendo
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)