Définir l’objet jeu principalDefine the main game object

Notes

Cette rubrique fait partie de la série de didacticiels créer un jeu de plateforme Windows universelle simple (UWP) avec DirectX .This topic is part of the Create a simple Universal Windows Platform (UWP) game with DirectX tutorial series. La rubrique de ce lien définit le contexte de la série.The topic at that link sets the context for the series.

Une fois que vous avez disposé l’infrastructure de base de l’exemple de jeu et implémenté une machine à États qui gère les comportements utilisateur et système de haut niveau, vous souhaiterez examiner les règles et les mécanismes qui transforment l’exemple de jeu en jeu.Once you've laid out the basic framework of the sample game, and implemented a state machine that handles the high-level user and system behaviors, you'll want to examine the rules and mechanics that turn the sample game into a game. Examinons les détails de l’objet principal du jeu d’exemples et comment traduire les règles de jeu en interactions avec le monde du jeu.Let's look at the details of the sample game's main object, and how to translate game rules into interactions with the game world.

ObjectifsObjectives

  • Découvrez comment appliquer des techniques de développement de base pour implémenter des règles de jeu et des mécanismes pour un jeu DirectX UWP.Learn how to apply basic development techniques to implement game rules and mechanics for a UWP DirectX game.

Objet de jeu principalMain game object

Dans l’exemple de jeu Simple3DGameDX , Simple3DGame est la classe d’objets de jeu principale.In the Simple3DGameDX sample game, Simple3DGame is the main game object class. Une instance de Simple3DGame est construite, indirectement, via la méthode App :: Load .An instance of Simple3DGame is constructed, indirectly, via the App::Load method.

Voici quelques-unes des fonctionnalités de la classe Simple3DGame .Here are some of the features of the Simple3DGame class.

  • Contient l’implémentation de la logique de jeu.Contains implementation of the gameplay logic.
  • Contient des méthodes qui communiquent ces détails.Contains methods that communicate these details.
    • Modifications de l’état du jeu sur l’ordinateur d’état défini dans l’infrastructure de l’application.Changes in the game state to the state machine defined in the app framework.
    • Modifications de l’état du jeu de l’application à l’objet de jeu lui-même.Changes in the game state from the app to the game object itself.
    • Détails de la mise à jour de l’interface utilisateur du jeu (superposition et tête d’affichage), des animations et de la physique (Dynamics).Details for updating the game's UI (overlay and heads-up display), animations, and physics (the dynamics).

    Notes

    La mise à jour des graphiques est gérée par la classe GameRenderer , qui contient des méthodes pour obtenir et utiliser des ressources de périphériques graphiques utilisées par le jeu.Updating of graphics is handled by the GameRenderer class, which contains methods to obtain and use graphics device resources used by the game. Pour plus d’informations, consultez rendu de l’infrastructure I : introduction au rendu.For more info, see Rendering framework I: Intro to rendering.

  • Sert de conteneur pour les données qui définissent une session de jeu, un niveau ou une durée de vie, en fonction de la façon dont vous définissez votre jeu à un niveau élevé.Serves as a container for the data that defines a game session, level, or lifetime, depending on how you define your game at a high level. Dans ce cas, les données d’État du jeu sont pour la durée de vie du jeu et sont initialisées une fois lorsqu’un utilisateur lance le jeu.In this case, the game state data is for the lifetime of the game, and is initialized one time when a user launches the game.

Pour afficher les méthodes et les données définies par cette classe, consultez la classe Simple3DGame ci-dessous.To view the methods and data defined by this class, see The Simple3DGame class below.

Initialiser et démarrer le jeuInitialize and start the game

Lorsqu’un joueur démarre le jeu, l’objet jeu doit initialiser son état, créer et ajouter la superposition, définir les variables qui suivent les performances du joueur et instancier les objets qui seront utilisés pour générer les niveaux.When a player starts the game, the game object must initialize its state, create and add the overlay, set the variables that track the player's performance, and instantiate the objects that it will use to build the levels. Dans cet exemple, cette opération est effectuée lorsque l’instance GameMain est créée dans App :: Load.In this sample, this is done when the GameMain instance is created in App::Load.

L’objet de jeu, de type Simple3DGame, est créé dans le constructeur GameMain :: GameMain .The game object, of type Simple3DGame, is created in the GameMain::GameMain constructor. Elle est ensuite initialisée à l’aide de la méthode Simple3DGame :: Initialize pendant la Coroutine de GameMain :: ConstructInBackground Fire-and-oublier, qui est appelée à partir de GameMain :: GameMain.It's then initialized using the Simple3DGame::Initialize method during the GameMain::ConstructInBackground fire-and-forget coroutine, which is called from GameMain::GameMain.

Méthode Simple3DGame :: InitializeThe Simple3DGame::Initialize method

L’exemple de jeu définit ces composants dans l’objet de jeu.The sample game sets up these components in the game object.

  • Un nouvel objet lecture audio est créé.A new audio playback object is created.
  • Des tableaux pour les primitives graphiques du jeu sont créés, notamment des tableaux pour les primitives de niveau, les munitions et les obstacles.Arrays for the game's graphic primitives are created, including arrays for the level primitives, ammo, and obstacles.
  • Un emplacement pour enregistrer les données de l’état du jeu est créé : il est nommé Game et est placé dans l’emplacement de stockage des paramètres des données d’application spécifié par ApplicationData::Current.A location for saving game state data is created, named Game, and placed in the app data settings storage location specified by ApplicationData::Current.
  • Un minuteur de jeu et la bitmap de superposition initiale, intégrée au jeu, sont créés.A game timer and the initial in-game overlay bitmap are created.
  • Une nouvelle caméra est créée avec un ensemble spécifique de paramètres de vue et de projection.A new camera is created with a specific set of view and projection parameters.
  • Le périphérique d’entrée (contrôleur) étant défini sur les mêmes tangage et lacet de départ que la caméra, le joueur a une correspondance un-à-un entre la position du contrôle de départ et la position de la caméra.The input device (the controller) is set to the same starting pitch and yaw as the camera, so the player has a 1-to-1 correspondence between the starting control position and the camera position.
  • L’objet joueur est créé et associé à l’état actif.The player object is created and set to active. Nous utilisons un objet Sphere pour détecter la proximité du joueur aux murs et obstacles et pour empêcher l’appareil photo de se placer dans une position susceptible de briser l’immersion.We use a sphere object to detect the player's proximity to walls and obstacles and to keep the camera from getting placed in a position that might break immersion.
  • La primitive du monde du jeu est créée.The game world primitive is created.
  • Les obstacles sous forme de cylindres sont créés.The cylinder obstacles are created.
  • Les cibles (objets Face) sont créées et numérotées.The targets (Face objects) are created and numbered.
  • Les sphères de munitions sont créées.The ammo spheres are created.
  • Les niveaux sont créés.The levels are created.
  • Les meilleurs scores sont chargés.The high score is loaded.
  • Tout état de jeu précédemment enregistré est chargé.Any prior saved game state is loaded.

Le jeu possède maintenant des instances de tous les principaux composants — du monde, le joueur, les obstacles, les cibles et le AMMO.The game now has instances of all the key components—the world, the player, the obstacles, the targets, and the ammo spheres. Il a également des instances des niveaux, qui représentent les configurations de tous les composants ci-dessus ainsi que leurs comportements pour chaque niveau spécifique.It also has instances of the levels, which represent configurations of all of the above components and their behaviors for each specific level. Voyons maintenant comment le jeu crée les niveaux.Now let's see how the game builds the levels.

Générer et charger des niveaux de jeuBuild and load game levels

La majeure partie du travail important pour la construction du niveau est effectuée dans les Level[N].h/.cpp fichiers figurant dans le dossier GameLevels de l’exemple de solution.Most of the heavy lifting for the level construction is done in the Level[N].h/.cpp files found in the GameLevels folder of the sample solution. Étant donné qu’elle se concentre sur une implémentation très spécifique, nous ne les présenterons pas ici.Because it focuses on a very specific implementation, we won't be covering them here. L’important est que le code de chaque niveau soit exécuté sous la forme d’un objet de niveau [N] distinct.The important thing is that the code for each level is run as a separate Level[N] object. Si vous souhaitez étendre le jeu, vous pouvez créer un objet Level [N] qui accepte un nombre affecté comme paramètre et place de façon aléatoire les obstacles et les cibles.If you'd like to extend the game, you can create a Level[N] object that takes an assigned number as a parameter and randomly places the obstacles and targets. Ou bien, vous pouvez lui demander des données de configuration de niveau de charge à partir d’un fichier de ressources, ou même d’Internet.Or, you can have it load level configuration data from a resource file, or even the internet.

Définir le jeuDefine the gameplay

À ce stade, nous disposons de tous les composants dont nous avons besoin pour développer le jeu.At this point, we have all the components we need to develop the game. Les niveaux ont été construits en mémoire à partir des primitives et sont prêts pour que le joueur commence à interagir avec.The levels have been constructed in memory from the primitives, and are ready for the player to start interacting with.

Les meilleurs jeux réagissent instantanément à la saisie des joueurs et fournissent des commentaires immédiats.The best games react instantly to player input, and provide immediate feedback. Cela est vrai pour tout type de jeu, des Twitch à l’action, des pousseurs de la première personne en temps réel à des jeux de stratégie réfléchis et basés sur l’activation.This is true for any type of a game, from twitch-action, real-time first-person shooters to thoughtful, turn-based strategy games.

La méthode Simple3DGame :: RunGameThe Simple3DGame::RunGame method

Lorsqu’un niveau de jeu est en cours, le jeu est dans l’état Dynamics .While a game level is in progress, the game is in the Dynamics state.

GameMain :: Update est la boucle de mise à jour principale qui met à jour l’état de l’application une fois par Frame, comme indiqué ci-dessous.GameMain::Update is the main update loop that updates the application state once per frame, as shown below. La boucle Update appelle la méthode Simple3DGame :: RunGame pour gérer le travail si le jeu est dans l’état Dynamics .The update loop calls the Simple3DGame::RunGame method to handle the work if the game is in the Dynamics state.

// Updates the application state once per frame.
void GameMain::Update()
{
    // The controller object has its own update loop.
    m_controller->Update();

    switch (m_updateState)
    {
    ...
    case UpdateEngineState::Dynamics:
        if (m_controller->IsPauseRequested())
        {
            ...
        }
        else
        {
            // When the player is playing, work is done by Simple3DGame::RunGame.
            GameState runState = m_game->RunGame();
            switch (runState)
            {
                ...

Simple3DGame :: RunGame gère le jeu de données qui définit l’état actuel de la lecture du jeu pour l’itération actuelle de la boucle de jeu.Simple3DGame::RunGame handles the set of data that defines the current state of the game play for the current iteration of the game loop.

Voici la logique du workflow de jeu dans Simple3DGame :: RunGame.Here's the game flow logic in Simple3DGame::RunGame.

  • La méthode met à jour la minuterie qui compte les secondes jusqu’à ce que le niveau soit terminé, et vérifie si l’heure du niveau a expiré.The method updates the timer that counts down the seconds until the level is completed, and tests to see whether the level's time has expired. Il s’agit de l’une des règles du jeu — lorsque le temps est écoulé, si toutes les cibles n’ont pas été capturées, alors la partie est terminée.This is one of the rules of the game—when time runs out, if not all the targets have been shot, then it's game over.
  • Si le temps s’est écoulé, la méthode définit l’état du jeu TimeExpired et retourne à la méthode Update dans le code précédent.If time has run out, then the method sets the TimeExpired game state, and returns to the Update method in the previous code.
  • Si le temps reste, alors le contrôleur de déplacement-look est interrogé pour obtenir une mise à jour de la position de la caméra. plus précisément, une mise à jour de l’angle de la vue projetait normalement à partir du plan de l’appareil photo (où le joueur regarde) et de la distance à laquelle l’angle a été déplacé depuis la dernière interrogation du contrôleur.If time remains, then the move-look controller is polled for an update to the camera position; specifically, an update to the angle of the view normal projecting from the camera plane (where the player is looking), and the distance that angle has moved since the controller was polled last.
  • La caméra est mise à jour en fonction des nouvelles données du contrôleur de déplacement/vue.The camera is updated based on the new data from the move-look controller.
  • La dynamique, ou les animations et comportements des objets du monde du jeu indépendants du contrôle du joueur, sont mis à jour.The dynamics, or the animations and behaviors of objects in the game world independent of player control, are updated. Dans cet exemple de jeu, la méthode Simple3DGame :: UpdateDynamics est appelée pour mettre à jour le mouvement des sphères AMMO qui ont été déclenchées, l’animation des obstacles de pilier et le déplacement des cibles.In this sample game, the Simple3DGame::UpdateDynamics method is called to update the motion of the ammo spheres that have been fired, the animation of the pillar obstacles and the movement of the targets. Pour plus d’informations, consultez mettre à jour le monde du jeu.For more information, see Update the game world.
  • La méthode vérifie si les critères de réussite d’un niveau ont été atteints.The method checks to see whether the criteria for the successful completion of a level have been met. Si c’est le cas, il finalise le score pour le niveau et vérifie s’il s’agit du dernier niveau (de 6).If so, it finalizes the score for the level, and checks to see whether this is the last level (of 6). S’il s’agit du dernier niveau, la méthode retourne l’état du jeu GameState :: GameComplete ; Sinon, elle retourne l’état du jeu GameState :: LevelComplete .If it's the last level, then the method returns the GameState::GameComplete game state; otherwise, it returns the GameState::LevelComplete game state.
  • Si le niveau n’est pas terminé, la méthode définit l’état du jeu sur GameState :: activeet retourne.If the level isn't complete, then the method sets the game state to GameState::Active, and returns.

Mettre à jour le monde du jeuUpdate the game world

Dans cet exemple, lorsque le jeu est en cours d’exécution, la méthode Simple3DGame :: UpdateDynamics est appelée à partir de la méthode Simple3DGame :: RunGame (qui est appelée à partir de GameMain :: Update) pour mettre à jour les objets qui sont rendus dans une scène de jeu.In this sample, when the game is running, the Simple3DGame::UpdateDynamics method is called from the Simple3DGame::RunGame method (which is called from GameMain::Update) to update objects that are rendered in a game scene.

Une boucle telle que UpdateDynamics appelle toutes les méthodes utilisées pour définir le monde du jeu en mouvement, indépendamment de l’entrée du joueur, pour créer une expérience de jeu immersif et rendre le niveau actif.A loop such as UpdateDynamics calls any methods that are used to set the game world in motion, independent of the player input, to create an immersive game experience and make the level come alive. Cela inclut les graphiques qui doivent être rendus et l’exécution de boucles d’animation pour se déplacer sur un monde dynamique, même lorsqu’il n’y a pas d’entrée de joueur.This includes graphics that needs to be rendered, and running animation loops to bring about a dynamic world even when there's no player input. Dans votre jeu, il peut s’agir d’arbres en ligne dans le vent, d’ondulations sur terre, de machines à fumer et d’étirement et de déplacement de monstres étrangers.In your game, that could include trees swaying in the wind, waves cresting along shore lines, machinery smoking, and alien monsters stretching and moving around. Il englobe également l’interaction entre les objets, y compris les collisions entre la sphère du joueur et le monde, ou entre les munitions et les obstacles et cibles.It also encompasses the interaction between objects, including collisions between the player sphere and the world, or between the ammo and the obstacles and targets.

Sauf lorsque le jeu est en pause, la boucle de jeu doit continuer à mettre à jour le monde du jeu ; Si cette fonction est basée sur une logique de jeu, sur des algorithmes physiques ou si elle est simplement aléatoire.Except when the game is specifically paused, the game loop should continue updating the game world; whether that's based on game logic, physical algorithms, or whether it's just plain random.

Dans l’exemple de jeu, ce principe est appelé Dynamicset il englobe la hausse et la chute des obstacles de fondement, et les comportements et les comportements physiques des Ammos à mesure qu’ils sont déclenchés et en mouvement.In the sample game, this principle is called dynamics, and it encompasses the rise and fall of the pillar obstacles, and the motion and physical behaviors of the ammo spheres as they are fired and in motion.

La méthode Simple3DGame :: UpdateDynamicsThe Simple3DGame::UpdateDynamics method

Cette méthode gère ces quatre ensembles de calculs.This method deals with these four sets of computations.

  • Les positions des sphères de munitions tirées dans le monde.The positions of the fired ammo spheres in the world.
  • L’animation des colonnes d’obstacles.The animation of the pillar obstacles.
  • L’intersection du joueur et des limites du monde.The intersection of the player and the world boundaries.
  • Les collisions entre les sphères de munitions et les obstacles, les cibles, d’autres sphères de munitions et le monde.The collisions of the ammo spheres with the obstacles, the targets, other ammo spheres, and the world.

L’animation des obstacles a lieu dans une boucle définie dans les fichiers de code source Animate. h/. cpp .The animation of the obstacles takes place in a loop defined in the Animate.h/.cpp source code files. Le comportement des AMMO et des collisions est défini par des algorithmes physiques simplifiés, fournis dans le code et paramétrés par un ensemble de constantes globales pour le monde du jeu, y compris les propriétés de gravité et de matériau.The behavior of the ammo and any collisions are defined by simplified physics algorithms, supplied in the code and parameterized by a set of global constants for the game world, including gravity and material properties. Tout cela est calculé dans l’espace de coordonnées du monde du jeu.This is all computed in the game world coordinate space.

Examiner le FlowReview the flow

Maintenant que nous avons mis à jour tous les objets de la scène et calculé les collisions, nous devons utiliser ces informations pour dessiner les modifications visuelles correspondantes.Now that we've updated all of the objects in the scene, and calculated any collisions, we need to use this info to draw the corresponding visual changes.

Une fois GameMain :: Update a terminé l’itération actuelle de la boucle de jeu, l’exemple appelle immédiatement GameRenderer :: Render pour prendre les données d’objet mises à jour et générer une nouvelle scène à présenter au joueur, comme indiqué ci-dessous.After GameMain::Update has completed the current iteration of the game loop, the sample immediately calls GameRenderer::Render to take the updated object data and generate a new scene to present to the player, as shown below.

void GameMain::Run()
{
    while (!m_windowClosed)
    {
        if (m_visible)
        {
            switch (m_updateState)
            {
            case UpdateEngineState::Deactivated:
            case UpdateEngineState::TooSmall:
                ...
                // Otherwise, fall through and do normal processing to perform rendering.
            default:
                CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(
                    CoreProcessEventsOption::ProcessAllIfPresent);
                // GameMain::Update calls Simple3DGame::RunGame. If game is in Dynamics
                // state, uses Simple3DGame::UpdateDynamics to update game world.
                Update();
                // Render is called immediately after the Update loop.
                m_renderer->Render();
                m_deviceResources->Present();
                m_renderNeeded = false;
            }
        }
        else
        {
            CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(
                CoreProcessEventsOption::ProcessOneAndAllPending);
        }
    }
    m_game->OnSuspending();  // Exiting due to window close, so save state.
}

Restituer les graphiques du monde du jeuRender the game world's graphics

Nous recommandons que les graphiques d’un jeu soient mis à jour souvent, idéalement aussi souvent que la boucle de jeu principale.We recommend that the graphics in a game update often, ideally exactly as often as the main game loop iterates. À mesure que la boucle itère, l’état du monde du jeu est mis à jour, avec ou sans entrée de joueur.As the loop iterates, the game world's state is updated, with or without player input. Cela permet d’afficher correctement les animations et les comportements calculés.This allows the calculated animations and behaviors to be displayed smoothly. Imaginez si nous avions une scène simple d’eau qui a été déplacée uniquement lorsque le joueur a appuyé sur un bouton.Imagine if we had a simple scene of water that moved only when the player pressed a button. Cela ne serait pas réaliste ; un bon jeu semble lisse et fluide tout le temps.That wouldn't be realistic; a good game looks smooth and fluid all the time.

Souvenez-vous de la boucle de l’exemple de jeu comme indiqué ci-dessus dans GameMain :: Run.Recall the sample game's loop as shown above in GameMain::Run. Si la fenêtre principale du jeu est visible et n’est pas alignée ou désactivée, le jeu continue à mettre à jour et à restituer les résultats de cette mise à jour.If the game's main window is visible, and isn't snapped or deactivated, then the game continues to update and render the results of that update. La méthode GameRenderer :: Render que nous examinons ensuite affiche une représentation de cet État.The GameRenderer::Render method we examine next renders a representation of that state. Cette opération est effectuée immédiatement après un appel à GameMain :: Update, qui comprend Simple3DGame :: RunGame pour mettre à jour des États, comme indiqué dans la section précédente.This is done immediately after a call to GameMain::Update, which includes Simple3DGame::RunGame to update states, as discussed in the previous section.

GameRenderer :: Render dessine la projection du monde 3D, puis dessine la superposition de Direct2D par-dessus.GameRenderer::Render draws the projection of the 3D world, and then draws the Direct2D overlay on top of it. Une fois terminé, elle présente la chaîne de permutation finale avec les tampons combinés à afficher.When completed, it presents the final swap chain with the combined buffers for display.

Notes

Il existe deux États pour la superposition de Direct2D du jeu — , où le jeu affiche la superposition des informations de jeu qui contient l’image bitmap pour le menu pause, et l’autre où le jeu affiche la Croix avec les rectangles pour le contrôleur de déplacement-look de l’écran tactile.There are two states for the sample game's Direct2D overlay—one where the game displays the game info overlay that contains the bitmap for the pause menu, and one where the game displays the crosshairs along with the rectangles for the touchscreen move-look controller. Le texte des scores est écrit dans les deux états.The score text is drawn in both states. Pour plus d’informations, consultez rendu de l’infrastructure I : introduction au rendu.For more information, see Rendering framework I: Intro to rendering.

Méthode GameRenderer :: RenderThe GameRenderer::Render method

void GameRenderer::Render()
{
    bool stereoEnabled{ m_deviceResources->GetStereoState() };

    auto d3dContext{ m_deviceResources->GetD3DDeviceContext() };
    auto d2dContext{ m_deviceResources->GetD2DDeviceContext() };

    ...
        if (m_game != nullptr && m_gameResourcesLoaded && m_levelResourcesLoaded)
        {
            // This section is only used after the game state has been initialized and all device
            // resources needed for the game have been created and associated with the game objects.
            ...
            for (auto&& object : m_game->RenderObjects())
            {
                object->Render(d3dContext, m_constantBufferChangesEveryPrim.get());
            }
        }

        d3dContext->BeginEventInt(L"D2D BeginDraw", 1);
        d2dContext->BeginDraw();

        // To handle the swapchain being pre-rotated, set the D2D transformation to include it.
        d2dContext->SetTransform(m_deviceResources->GetOrientationTransform2D());

        if (m_game != nullptr && m_gameResourcesLoaded)
        {
            // This is only used after the game state has been initialized.
            m_gameHud.Render(m_game);
        }

        if (m_gameInfoOverlay.Visible())
        {
            d2dContext->DrawBitmap(
                m_gameInfoOverlay.Bitmap(),
                m_gameInfoOverlayRect
                );
        }
        ...
    }
}

La classe Simple3DGameThe Simple3DGame class

Il s’agit des méthodes et des membres de données définis par la classe Simple3DGame .These are the methods and data members that are defined by the Simple3DGame class.

Fonctions MembreMember functions

Les fonctions membres publiques définies par Simple3DGame incluent celles ci-dessous.Public member functions defined by Simple3DGame include the ones below.

  • Initialisationen cours.Initialize. Définit les valeurs de départ des variables globales et initialise les objets de jeu.Sets the starting values of the global variables, and initializes the game objects. Ce sujet est abordé dans la section Initialize and Start The Game .This is covered in the Initialize and start the game section.
  • LoadGame.LoadGame. Initialise un nouveau niveau et commence à le charger.Initializes a new level, and starts loading it.
  • LoadLevelAsync.LoadLevelAsync. Coroutine qui initialise le niveau, puis appelle une autre Coroutine sur le convertisseur pour charger les ressources de niveau spécifique à l’appareil.A coroutine that initializes the level, and then invokes another coroutine on the renderer to load the device-specific level resources. Cette méthode s’exécute dans un thread séparé ; seules les méthodes ID3D11Device (par opposition aux méthodes ID3D11DeviceContext) peuvent être appelées à partir de ce thread.This method runs in a separate thread; as a result, only ID3D11Device methods (as opposed to ID3D11DeviceContext methods) can be called from this thread. Toutes les méthodes de contexte de périphérique sont appelées dans la méthode FinalizeLoadLevel.Any device context methods are called in the FinalizeLoadLevel method. Si vous débutez en programmation asynchrone, consultez opérations simultanées et asynchrones avec C++/WinRT.If you're new to asynchronous programming, then see Concurrency and asynchronous operations with C++/WinRT.
  • FinalizeLoadLevel.FinalizeLoadLevel. Finit tout travail de chargement de niveau à effectuer sur le thread principal.Completes any work for level loading that needs to be done on the main thread. Cela comprend tout appel aux méthodes (ID3D11DeviceContext) de contexte de périphérique Direct3D 11.This includes any calls to Direct3D 11 device context (ID3D11DeviceContext) methods.
  • StartLevel.StartLevel. Démarre le jeu pour un nouveau niveau.Starts the gameplay for a new level.
  • PauseGame.PauseGame. Suspend le jeu.Pauses the game.
  • RunGame.RunGame. Exécute une itération de la boucle de jeu.Runs an iteration of the game loop. Cette méthode est appelée à partir d’App::Update une fois par itération de la boucle de jeu si le jeu présente l’état Active.It's called from App::Update one time every iteration of the game loop if the game state is Active.
  • OnSuspending et OnResuming.OnSuspending and OnResuming. Suspendez/reprenez l’audio du jeu, respectivement.Suspend/resume the game's audio, respectively.

Voici les fonctions membres privées.Here are the private member functions.

  • LoadSavedState et SaveState.LoadSavedState and SaveState. Chargez/enregistrez l’état actuel du jeu, respectivement.Load/save the current state of the game, respectively.
  • LoadHighScore et SaveHighScore.LoadHighScore and SaveHighScore. Chargez/enregistrez le score élevé entre les jeux, respectivement.Load/save the high score across games, respectively.
  • InitializeAmmo.InitializeAmmo. Redéfinit l’état de chaque objet sphère utilisé comme munition dans son état d’origine au début de chaque partie.Resets the state of each sphere object used as ammunition back to its original state for the beginning of each round.
  • UpdateDynamics.UpdateDynamics. Il s’agit d’une méthode importante, car elle met à jour tous les objets de jeu en fonction des routines d’animation consorties, de la physique et de l’entrée de contrôle.This is an important method because it updates all the game objects based on canned animation routines, physics, and control input. Elle représente le cœur de l’interactivité qui définit le jeu.This is the heart of the interactivity that defines the game. Ce sujet est abordé dans la section mettre à jour le monde du jeu .This is covered in the Update the game world section.

Les autres méthodes publiques sont l’accesseur de propriété qui retourne des informations spécifiques au jeu et à la superposition dans l’infrastructure d’application pour l’affichage.The other public methods are property accessor that return gameplay- and overlay-specific information to the app framework for display.

Membres de donnéesData members

Ces objets sont mis à jour au fur et à mesure de l’exécution de la boucle du jeu.These objects are updated as the game loop runs.

  • Objet MoveLookController .MoveLookController object. Représente l’entrée du lecteur.Represents the player input. Pour plus d’informations, consultez Ajout de contrôles.For more information, see Adding controls.
  • Objet GameRenderer .GameRenderer object. Représente un convertisseur Direct3D 11 qui gère tous les objets spécifiques à l’appareil et leur rendu.Represents a Direct3D 11 renderer, which handles all the device-specific objects and their rendering. Pour plus d’informations, consultez rendu de l' infrastructure I.For more information, see Rendering framework I.
  • Objet audio .Audio object. Contrôle la lecture audio pour le jeu.Controls the audio playback for the game. Pour plus d’informations, consultez Ajout de sons.For more information, see Adding sound.

Les autres variables de jeu contiennent les listes des primitives et leurs quantités respectives, ainsi que des données et des contraintes spécifiques aux jeux.The rest of the game variables contain the lists of the primitives, and their respective in-game amounts, and game play specific data and constraints.

Étapes suivantesNext steps

Nous n’avons pas encore parlé du moteur de rendu réel dans — lequel les appels aux méthodes Render sur les primitives mises à jour sont convertis en pixels sur votre écran.We have yet to talk about the actual rendering engine—how calls to the Render methods on the updated primitives get turned into pixels on your screen. Ces aspects sont traités dans l’infrastructure de rendu de deux parties — I : présentation du rendu et du rendu Framework II : rendu de jeu.Those aspects are covered in two parts—Rendering framework I: Intro to rendering and Rendering framework II: Game rendering. Si vous êtes plus intéressé par la manière dont le lecteur contrôle la mise à jour de l’état du jeu, consultez Ajout de contrôles.If you're more interested in how the player controls update the game state, then see Adding controls.