Gérer les joueurs

Avec la boucle de jeu codée, il est temps d'ajouter des fonctionnalités dedans.Pendant un correspondre, les joueurs peuvent aller et venir.En raison de cela, le code est nécessaire pour des tâches telles que l'envoi de joueurs dans une partie et le suivi des joueurs actifs.Pour gérer ces tâches, créez un script de module nommé PlayerManager .

Ce script lancera une fonction pour envoyer des joueurs dans l'arène avec une arme et sera étendu plus tard dans la série.

Configurer le script

Comme le gestionnaire du joueur inclut des fonctions utilisées par d'autres scripts, ce sera un script de module.

Dans ServerStorage > ModuleScripts, ajoutez un nouveau script de module nommé PlayerManager.Ensuite, renommez la table du module pour correspondre au nom du script et ajoutez des commentaires pour les fonctions locales et de module.


local PlayerManager = {}
-- Fonctions locales

-- Fonctions de module

return PlayerManager

Ajoutez des variables locales pour ce qui suivre:

Services :

Joueurs - Savoir ce que les joueurs ont rejoint ou quitté le jeu.
ServerStorage - Stockage des armes du joueur.

Variables de carte et de joueur :

Lobby Spawn, dossier d'arène et dossier de spawn d'arène - Utilisé pour téléporter les joueurs dans différentes zones.
Un ensemble de joueurs actifs - Suit les joueurs actuellement dans un jeu.


local PlayerManager = {}

-- Services
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")
-- Variables de carte
local lobbySpawn = workspace.Lobby.StartSpawn
local arenaMap = workspace.Arena
local spawnLocations = arenaMap.SpawnLocations
-- Variables du joueur
local activePlayers = {}

-- Fonctions locales

-- Fonctions de module

return PlayerManager

Créer une fonction de module nommée sendPlayersToMatch() avec une impression de test à l'intérieur.


-- Fonctions locales

-- Fonctions de module
function PlayerManager.sendPlayersToMatch()
	print("Sending players to match")
end

return PlayerManager

Générer des joueurs dans le lobby

En ce moment, il y a plusieurs endroits de génération, ce qui signifie que les joueurs apparaissent à un endroit aléatoire lorsqu'ils rejoignent le jeu.Pour garantir que les joueurs apparaissent dans le lobby, modifiez la propriété RespawnLocation du joueur.

Créez une nouvelle fonction locale nommée onPlayerJoin() avec un paramètre de player .Dans cette fonction, définissez la position de réapparition du joueur à la variable d'apparition du lobby créée plus tôt.


-- Fonctions locales
local function onPlayerJoin(player)
	player.RespawnLocation = lobbySpawn
end

Ajoutez une section événements sous la fonction de votre module. Ensuite, connectez onPlayerJoin() à l'événement du service du joueur PlayerAdded.


-- Fonctions de module
function PlayerManager.sendPlayersToMatch()
	print("Sending players to match")
end

-- Événements
Players.PlayerAdded:Connect(onPlayerJoin)

Connecter et tester

Les modules peuvent maintenant être connectés et testés.Avec le PlayerManager créé, exigez-le afin que le code dans ce script de module puisse ensuite s'exécuter et envoyer des joueurs dans le lobby.

Retournez à MatchManager et créez des variables pour ce qui suivre:

Service de stockage du serveur .
ModuleScripts dossier, enfant de ServerStorage.
Script du module PlayerManager , enfant des scripts de module.


local MatchManager = {}

-- Services
local ServerStorage = game:GetService("ServerStorage")

-- Scripts de module
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local playerManager = require(moduleScripts:WaitForChild("PlayerManager"))

function MatchManager.prepareGame()
	playerManager.sendPlayersToMatch()
end

return MatchManager

Utilisez un serveur local avec au moins le minimum de joueurs à tester . Confirmez que vous pouvez voir ce qui suivre:
- Tous les joueurs apparaissent dans le lobby.
- La déclaration d'impression de PlayerManager apparaît dans la fenêtre de sortie.
Une fois terminé, cliquez sur Nettoyage pour fermer le serveur.

Conseils de dépannage

À ce stade, certaines parties du script ne fonctionnent pas comme prévu, essayez l'une des suivantes ci-dessous.

Vérifiez le nom des parties telles que l'arène, ou l'emplacement de Lobby > StartSpawn, surtout si vous les avez nommées différemment que ce qui est indiqué dans la leçon.
Assurez-vous que les modules sont nécessaires dans chaque script en utilisant la fonction require() et qu'ils sont correctement orthographiés.

Envoyer des joueurs dans l'arène

Maintenant que les joueurs apparaissent dans le lobby, téléportez-les dans une partie une fois l'intermission terminée.Changez le RespawnLocation du joueur en une position d'apparition dans l'arène en utilisant une fonction dans l'objet Joueur appelée ReloadCharacter().

Accédez au script PlayerManager , ci-dessous onPlayerJoin(), ajoutez une nouvelle fonction locale nommée preparePlayer().Incluez deux paramètres : player et whichSpawn , l'emplacement d'apparition pour les envoyer.


local activePlayers = {}

-- Fonctions locales
local function onPlayerJoin(player)
	player.RespawnLocation = lobbySpawn
end

local function preparePlayer(player, whichSpawn)

end

-- Fonctions de module
function PlayerManager.sendPlayersToMatch()
	print("Sending players to match")
end

Définissez la position de réapparition du joueur à whichSpawn.


local function preparePlayer(player, whichSpawn)
	player.RespawnLocation = whichSpawn
end

Forcez le personnage à se recharger, en utilisant LoadCharacter() , et le joueur réapparaîtra en utilisant sa nouvelle position attribuée.


local function preparePlayer(player, whichSpawn)
	player.RespawnLocation = whichSpawn
	player:LoadCharacter()
end

Recharger un personnage garantit que les joueurs ne commencent qu'avec les outils fournis au début d'une ronde.Par instance, si vous développez davantage ce jeu et ajoutez des outils avec des munitions et des armes de récupération, il est possible qu'un personnage les apporte, leur donnant un avantage injuste.

Envoyer les joueurs au régénération, apparition

Assurez-vous que chaque joueur soit téléporté à un endroit de génération différent dans l'arène en utilisant une boucle for itérative pour parcourir l'matricedes joueurs actifs.L'utilisation d'une boucle for permet de parcourir toutes les valeurs de l'matricedes joueurs, ce qui permet au script d'adapter à une variété de nombres de joueurs.

Dans la fonction sendPlayersToMatch(), utilisez une variable pour créer un tableau de tous les emplacements de spawn de l'arène en obtenant les enfants du dossier Arena > SpawnLocations.


--Fonctions de module
function PlayerManager.sendPlayersToMatch()
	local arenaSpawns = spawnLocations:GetChildren()
end

Ajoutez la boucle for ci-dessous pour obtenir une liste de tous les joueurs puis d'itérer à travers chacun d'entre eux. Pour obtenir des joueurs, taper: Players:GetPlayers() .


function PlayerManager.sendPlayersToMatch()
	local arenaSpawns = spawnLocations:GetChildren()

	for playerKey, whichPlayer in Players:GetPlayers() do

	end
end

Suivre et régénération, apparition

Lorsque le jeu s'exécute, il doit identifier les utilisateurs qui jouent pour qu'ils puissent être générés dans l'arène.Au début d'une manche, chaque joueur sera suivi dans une liste d'acteurs actifs.Cet array sera utilisé pour différentes fonctions, telles que la téléportation ou l'attribution d'armes, afin de garantir que les joueurs encore dans le lobby pendant une manche ne soient pas affectés.

Dans la boucle for, utilisez table.insert() , en utilisant les deux paramètres pour l'ensemble de données activePlayers et le joueur à ajouter.


function PlayerManager.sendPlayersToMatch()
	local arenaSpawns = spawnLocations:GetChildren()

	for playerKey, whichPlayer in Players:GetPlayers() do
		table.insert(activePlayers, whichPlayer)
	end
end

Pour obtenir un lieu d'apparition de l'arène, créez une variable nommée et définissez-la sur l'index premier dans la table .


for playerKey, whichPlayer in Players:GetPlayers() do
	table.insert(activePlayers, whichPlayer)
	local spawnLocation = arenaSpawns[1]
end

Appellez preparePlayer() et passez en whichPlayer et spawnLocation.Ensuite, puisque cette position d'apparition a été utilisée, supprimer elle de la table afin que le prochain joueur obtienne un autre point d'apparition.


for playerKey, whichPlayer in Players:GetPlayers() do
	table.insert(activePlayers, whichPlayer)
	local spawnLocation = table.remove(arenaSpawns, 1)
	preparePlayer(whichPlayer, spawnLocation)
end

Testez sur un serveur local local sur lequel les joueurs sont envoyés dans l'arène.Les joueurs continueront de réapparaître au même endroit car le code pour les renvoyer dans le lobby n'est pas encore en emplacement.

Conseils de dépannage

À ce stade, vous n'avez pas vu les résultats prévus, essayez l'une des options suivantes.

Dans GetPlayers() , assurez-vous qu'il y a deux fermetures de parenthèses, comme Class.Players.GetPlayers(|Players:GetPlayers()) dans la déclaration.
Vérifiez la série d'appels de fonction dans les scripts de module. Par exemple, matchManager.prepareGame() devrait appeler playerManager.sendPlayersToMatch() .

Donner aux joueurs des armes

Lorsqu'un tour commence, chaque joueur dans l'arène recevra une arme à utiliser.

Ajouter un outil

Les armes du joueur seront un outil. Bien que tout outil dans Roblox puisse être utilisé, nous avons fourni une épée de test pour commencer.

Importer l'arme de la boîte à outils, ou créer la vôtre (voir Tools ).
Placez l'arme dans ServerStorage. Si vous créez votre propre outil, assurez-vous que l'outil s'appelle Arme, car il sera utilisé dans les scripts ultérieurs.

Donner des outils aux joueurs

Maintenant que l'outil est en stockage, travaillez sur un script pour parcourir l'ensemble des joueurs actifs et fournir chaque utilisateur cet outil.

Dans PlayerManager, ajoutez une variable nommée playerWeapon pour l'arme dans ServerStorage.


-- Variables de carte
local lobbySpawn = workspace.Lobby.StartSpawn
local arenaMap = workspace.Arena
local spawnLocations = arenaMap.SpawnLocations

-- Variables du joueur
local activePlayers = {}
local playerWeapon = ServerStorage.Weapon

Dans preparePlayer(), collez le code suivant pour obtenir le personnage du joueur.


local function preparePlayer(player, whichSpawn)
	player.RespawnLocation = whichSpawn
	player:LoadCharacter()

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

Il est possible que le personnage d'un joueur ne soit pas chargé lorsque le jeu commence.Ajouter l'attente supplémentaire garantit que si un personnage n'est pas immédiatement disponible, le script attendra et ne causera pas d'erreur.

Créez une nouvelle variable nommée épée et utilisez la fonction Clone() pour créer une copie de l'arme dans ServerStorage.Ensuite, parent la lame au personnage du joueur.


local function preparePlayer(player, whichSpawn)
	player.RespawnLocation = whichSpawn
	player:LoadCharacter()

	local character = player.Character or player.CharacterAdded:Wait()
	local sword = playerWeapon:Clone()
	sword.Parent = character
end

Testez sur un serveur local pour confirmer que chaque joueur reçoit un outil lorsqu'il est envoyé dans l'arène.Gardez à l'esprit, si vous continuez à tester, l'intermission va redémarrer et les joueurs réapparaîtront toutes les quelques secondes.Cela sera résolu dans la prochaine leçon.

Scripts terminés

Ci-dessous, les scripts terminés pour vérifier à nouveau votre travail.

scriptdu gestionnaire de jeu


-- Services
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")

-- Scripts de module
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local matchManager = require(moduleScripts:WaitForChild("MatchManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))

while true do
	repeat
		task.wait(gameSettings.intermissionDuration)
		print("Restarting intermission")
	until #Players:GetPlayers() >= gameSettings.minimumPlayers

	print("Intermission over")
	task.wait(gameSettings.transitionTime)

	matchManager.prepareGame()
end

scriptde MatchManager


local MatchManager = {}

-- Services
local ServerStorage = game:GetService("ServerStorage")

-- Scripts de module
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local playerManager = require(moduleScripts:WaitForChild("PlayerManager"))

function MatchManager.prepareGame()
	playerManager.sendPlayersToMatch()
end

return MatchManager

scriptdu module PlayerManager


local PlayerManager = {}
-- Services
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

-- Variables de carte
local lobbySpawn = workspace.Lobby.StartSpawn
local arenaMap = workspace.Arena
local spawnLocations = arenaMap.SpawnLocations

-- Variables du joueur
local activePlayers = {}
local playerWeapon = ServerStorage.Weapon

-- Fonctions locales
local function onPlayerJoin(player)
	player.RespawnLocation = lobbySpawn
end

local function preparePlayer(player, whichSpawn)
	player.RespawnLocation = whichSpawn
	player:LoadCharacter()
	local character = player.Character or player.CharacterAdded:Wait()
	local sword = playerWeapon:Clone()
	sword.Parent = character
end

-- Fonctions de module
function PlayerManager.sendPlayersToMatch()
	print("Sending players to match")

	local arenaSpawns = spawnLocations:GetChildren()

	for playerKey, whichPlayer in Players:GetPlayers() do
		table.insert(activePlayers, whichPlayer)
		local spawnLocation = table.remove(arenaSpawns, 1)
		preparePlayer(whichPlayer, spawnLocation)
	end
end

--événements
Players.PlayerAdded:Connect(onPlayerJoin)

return PlayerManager

Sur cette page