Game Mode et Game State

Il y a deux classes principales qui traitent des informations sur le jeu en cours de lecture: Game Mode et Game State. Même le jeu le plus ouvert a un fondement de règles, et ces règles constituent un mode de jeu (Game Mode).

Au niveau le plus basique, ces règles incluent :

  • Le nombre de joueurs et de spectateurs présents, ainsi que le nombre maximum de joueurs et de spectateurs autorisés.
  • Comment les joueurs entrent dans le jeu, ce qui peut inclure des règles pour sélectionner les emplacements de spawn et d'autres comportements de spawn / respawn.
  • Si le jeu peut être suspendu ou non, et comment le jeu est suspendu.
  • Les transitions entre les niveaux, y compris si le jeu doit commencer ou non en mode cinématique.

Lorsque des événements liés aux règles surviennent dans le jeu et doivent être suivis et partagés avec tous les joueurs, ces informations sont stockées et synchronisées via l'état du jeu.

Cette information comprend :

  • Combien de temps a duré le jeu (y compris le temps d'exécution avant que le joueur local ne rejoigne).
  • Quand chaque joueur individuel a rejoint le jeu, et l'état actuel de ce joueur.
  • La classe de base du Game Mode actuel.
  • Si oui ou non le jeu a commencé.

Game Modes

Alors que certains principes fondamentaux, comme le nombre de joueurs requis pour jouer ou la méthode par laquelle ces joueurs rejoignent le jeu, sont communs à de nombreux types de jeux, des variations de règles illimitées sont possibles en fonction du jeu spécifique que vous développez. Quelles que soient ces règles, les modes de jeu sont conçus pour les définir et les mettre en œuvre. Il existe actuellement deux classes de base couramment utilisées pour les Game Modes.

La version 4.14 du moteur introduit AGameModeBase, qui est la classe de base pour tous les modes de jeu et est une version simplifiée et rationalisée de l'AGameMode classique. AGameMode, la classe de base Game Mode avant la version 4.14, existe toujours et fonctionne comme avant, mais est maintenant un enfant de AGameModeBase. AGameMode est plus adapté aux types de jeux standard comme les jeux de tir multijoueurs en raison de sa mise en œuvre du concept d'état de correspondance. AGameModeBase est le nouveau mode de jeu par défaut inclus dans les nouveaux projets de code en raison de sa simplicité et de son efficacité.

AGameModeBase

Tous les modes de jeu sont des sous-classes de AGameModeBase, qui contient des fonctionnalités de base considérables qui peuvent être surchargées. Certaines des fonctions communes comprennent :

Fonction / ÉvénementObjectif
InitGameL'événement InitGame est appelé avant tout autre script (y compris PreInitializeComponents) et est utilisé par AGameModeBase pour initialiser les paramètres et générer ses classes auxiliaires.
PreLoginAccepte ou rejette un joueur qui tente de rejoindre le serveur. Provoque l'échec de la fonction de connexion si elle définit ErrorMessage sur une chaîne non vide. PreLogin est appelé avant la connexion, et un délai significatif peut s'écouler avant que Login ne soit appelé, en particulier si le joueur participant doit télécharger le contenu du jeu.
PostLoginAppelé après une connexion réussie. C'est le premier endroit où il est sûr d'appeler des fonctions répliquées sur le PlayerController. OnPostLogin peut être implémenté dans Blueprint pour ajouter une logique supplémentaire.
HandleStartingNewPlayerAppelé après PostLogin ou après un voyage sans interruption, cela peut être annulé dans Blueprint pour changer ce qui arrive à un nouveau joueur. Par défaut, il créera un Pawn pour le joueur.
RestartPlayerCeci est appelé pour lancer le Pawn d'un joueur. Il existe également des fonctions RestartPlayerAtPlayerStart et RestartPlayerAtTransform disponibles si vous souhaitez dicter l'endroit où le Pawn sera généré. OnRestartPlayer peut être implémenté dans Blueprint pour ajouter de la logique une fois cette fonction terminée.
SpawnDefaultPawnAtTransformC'est ce qui engendre le Pawn du joueur et peut être écrasé dans Blueprints.
LogoutAppelé lorsqu'un joueur quitte le jeu ou est détruit. OnLogout peut être implémenté pour faire la logique Blueprint.

Une sous-classe de la classe AGameModeBase peut être créée pour chaque format de correspondance, type de mission ou zone spéciale que le jeu offre. Un jeu peut avoir n'importe quel nombre de modes de jeu, et donc des sous-classes de la classe AGameModeBase; Cependant, un seul mode de jeu peut être utilisé à tout moment. Un Actor en Game Mode est instancié chaque fois qu'un niveau est initialisé pour la lecture via la fonction UGameEngine::LoadMap().

Le Game Mode n'est pas répliqué sur les clients distants qui participent à une partie multijoueur. Il n'existe que sur le serveur, ce qui permet aux clients locaux de voir la classe Game Game (ou Blueprint) utilisée, mais ne peut pas accéder à l'instance réelle et vérifier ses variables pour voir ce qui a changé au fur et à mesure de la progression du jeu. Si les joueurs ont besoin d'informations actualisées concernant le mode de jeu en cours, ces informations sont facilement synchronisées en étant stockées sur un Actor AGameStateBase, dont l'une sera créée avec le mode jeu, puis répliquée vers tous les clients distants.

AGameMode

AGameMode est une sous-classe de AGameModeBase qui dispose de fonctionnalités supplémentaires pour prendre en charge les correspondances multijoueurs et le comportement hérité. Tous les projets nouvellement créés utilisent AGameModeBase par défaut, mais vous pouvez passer à l'héritage de AGameMode si vous avez besoin de ce comportement supplémentaire. Si vous héritez de AGameMode, vous devez également hériter de votre état de jeu à partir de AGameState, qui prend également en charge la machine d'état de correspondance.

AGameMode contient une machine d'état qui suit l'état de la correspondance ou le déroulement général du jeu. Pour interroger l'état actuel, vous pouvez utiliser GetMatchState ou des wrappers tels que HasMatchStarted, IsMatchInProgress et HasMatchEnded.

Voici les états de correspondance possibles :

  • EnteringMap est l'état initial. Les acteurs ne sont pas encore actifs et le monde n'a pas été complètement initialisé. Il passera à l'état suivant lorsque les éléments sont complètement chargées.
  • WaitingToStart est l'état suivant, et HandleMatchIsWaitingToStart est appelé lors de l'entrée. Les Actors cochent, mais les joueurs ne sont pas encore apparus. Il passe à l'état suivant si ReadyToStartMatch renvoie true ou si StartMatch est appelé.
  • InProgress est l'état dans lequel se déroulera la majeure partie du jeu. HandleMatchHasStarted est appelé lors de l'entrée, qui appelle alors BeginPlay sur tous les Actors. A ce stade, le gameplay normal est en cours. Le match passera à l'état suivant lorsque ReadyToEndMatch renvoie true ou EndMatch est appelé.
  • WaitingPostPostMatch est l'état avant-dernier, et HandleMatchHasEnded est appelé lors de l'entrée. Les actors continuent de jouer, mais les nouveaux joueurs ne peuvent pas participer. Il passe à l'état suivant lorsqu'un transfert de carte commence.
  • LeavingMap est le dernier état d'un flux normal et appelle HandleLeavingMap à l'entrée. Le match reste dans cet état lors du transfert vers une nouvelle carte, où il passera à EnteringMap.
  • Aborted est l'état d'échec et peut être démarré en appelant AbortMatch. Ceci est défini en cas d'erreur irrémédiable.

L'état de correspondance sera presque toujours InProgress puisque c'est l'état où BeginPlay est appelé. Cependant, les jeux individuels peuvent remplacer le comportement de ces états pour construire un jeu multijoueur avec des règles plus compliquées, comme permettre aux joueurs de voler librement autour du niveau en attendant que d'autres joueurs rejoignent.

Game Mode Blueprints

Il est possible de créer des Blueprints dérivés de classes Game Mode, et de les utiliser comme mode de jeu par défaut pour votre projet ou votre niveau.

Les blueprints dérivés des modes de jeu peuvent définir les paramètres par défaut suivants :

  • Classe Default Pawn
  • Classe HUD
  • Classe PlayerController
  • Classe Spectator
  • Classe Game State
  • Classe Player State

En outre, les Blueprints des Game Modes sont très utiles car ils permettent d'ajuster les variables sans altérer le code, et peuvent donc être utilisés pour adapter un seul mode de jeu à plusieurs niveaux différents sans utiliser des références d'actifs codés en dur ou nécessiter un support technique et des changements de code pour chaque tweak.

Réglage du mode de jeu

Il existe plusieurs méthodes pour définir le mode de jeu pour un niveau, classés ici de la priorité la plus basse à la priorité la plus élevée.

  • La définition de l'entrée GlobalDefaultGameMode dans la section /Script/EngineSettings.GameMapsSettings du fichier DefaultEngine.ini définira le mode de jeu par défaut pour toutes les cartes du projet.
    Txt[/Script/EngineSettings.GameMapsSettings]
    GlobalDefaultGameMode="/Script/MyGame.MyGameGameMode"
    GlobalDefaultServerGameMode="/Script/MyGame.MyGameGameMode"
  • Pour remplacer les paramètres du projet pour une carte individuelle, définissez l'option GameMode Override dans l'onglet World Settings de l'éditeur.
    Paramètres World Settings pour l'option GameMode
    Paramètres World Settings pour l'option GameMode.
  • Les URL peuvent être passées à l'exécutable pour forcer le jeu à charger avec des options spécifiques. Utilisez l'option de jeu pour définir le mode de jeu. Voir Arguments de ligne de commande pour plus d'informations.
    CmdUE4Editor.exe /Game/Maps/MyMap?game=MyGameMode -game
  • Enfin, les préfixes de la carte (et les alias pour la méthode URL) peuvent être définis dans la section /Script/Engine.WorldSettings/ du fichier DefaultEngine.ini. Ces préfixes définissent le mode de jeu par défaut pour toutes les cartes ayant un préfixe donné.
    Txt[/Script/EngineSettings.GameMapsSettings]
    +GameModeMapPrefixes=(Name="DM",GameMode="/Script/UnrealTournament.UTDMGameMode")
    +GameModeClassAliases=(Name="DM",GameMode="/Script/UnrealTournament.UTDMGameMode")

Game State

Le Game State est responsable de permettre aux clients de surveiller l'état du jeu. D'un point de vue conceptuel, l'état du jeu doit gérer les informations destinées à être connues de tous les clients connectés et est spécifique au mode jeu, mais n'est spécifique à aucun joueur individuel. Il peut garder une trace des propriétés à l'échelle du jeu telles que la liste des joueurs connectés, le score de l'équipe dans Capture The Flag, les missions qui ont été accomplies dans un jeu en monde ouvert, et ainsi de suite.

Game State n'est pas le meilleur endroit pour garder une trace des choses spécifiques au joueur comme le nombre de points qu'un joueur spécifique a marqué pour l'équipe dans un match Capture The Flag, car cela peut être géré plus proprement par le Player State. En général, le GameState doit suivre les propriétés qui changent pendant le jeu et sont pertinentes et visibles pour tout le monde. Alors que le Game Mode existe uniquement sur le serveur, le Game State existe sur le serveur et est répliqué sur tous les clients, ce qui permet de garder à jour toutes les machines connectées au fur et à mesure de la progression du jeu.

AGameStateBase est l'implémentation de base et certaines de ses fonctionnalités par défaut incluent :

Fonction ou variableUtilisation
GetServerWorldTimeSecondsC'est la version du serveur de la fonction UWorld GetTimeSeconds et sera synchronisée sur le client et le serveur, donc c'est un temps fiable à utiliser pour la réplication.
PlayerArrayC'est le tableau de tous les objets APlayerState, ce qui est utile lorsque vous faites quelque chose à tous les joueurs dans une partie.
HasBegunPlayRenvoie true si la fonction BeginPlay a été appelée sur les actors du jeu.

AGameStateBase est très souvent étendu en C++ ou Blueprints pour contenir des variables et des fonctions supplémentaires qui sont nécessaires pour garder les joueurs informés de ce qui se passe dans le jeu. Les modifications spécifiques effectuées sont généralement basées sur un Game Mode associé pour lequel le Game State est créé. Le Game Mode lui-même peut également remplacer son type Game State par défaut pour qu'il soit n'importe quelle classe C++ ou Blueprint dérivé de AGameStateBase.

les réactions

Pour laisser un avis, vous devez être inscrit et connecté

Se connecter