Definieren des Hauptobjekts für das SpielDefine the main game object

Hinweis

Dieses Thema ist Teil der Tutorial-Reihe zum Erstellen eines einfachen universelle Windows-Plattform (UWP) mit DirectX .This topic is part of the Create a simple Universal Windows Platform (UWP) game with DirectX tutorial series. Das Thema unter diesem Link legt den Kontext für die Reihe fest.The topic at that link sets the context for the series.

Nachdem Sie das grundlegende Framework des Beispiel Spiels angelegt und einen Zustands Automat implementiert haben, der das allgemeine Benutzer-und Systemverhalten behandelt, sollten Sie die Regeln und die Mechanismen untersuchen, mit denen das Beispiel Spiel in ein Spiel verwandelt wird.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. Betrachten wir nun die Details des Haupt Objekts des samplingspiels und das Übersetzen von Spielregeln in Interaktionen mit der Spiel Welt.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.

ZieleObjectives

  • Erfahren Sie, wie Sie grundlegende Entwicklungsverfahren zum Implementieren von Spielregeln und-Mechanismen für ein UWP DirectX-Spiel anwenden.Learn how to apply basic development techniques to implement game rules and mechanics for a UWP DirectX game.

Hauptobjekt für das SpielMain game object

Im Simple3DGameDX -Beispiel Spiel ist Simple3DGame die Hauptklasse der Spielobjekte.In the Simple3DGameDX sample game, Simple3DGame is the main game object class. Eine Instanz von Simple3DGame wird indirekt über die App:: Load -Methode erstellt.An instance of Simple3DGame is constructed, indirectly, via the App::Load method.

Im folgenden finden Sie einige Funktionen der Simple3DGame -Klasse.Here are some of the features of the Simple3DGame class.

  • Enthält die Implementierung der-Spiellogik.Contains implementation of the gameplay logic.
  • Enthält Methoden, die diese Details übermitteln.Contains methods that communicate these details.
    • Ändert den Spielzustand in den Zustands Automat, der im App-Framework definiert ist.Changes in the game state to the state machine defined in the app framework.
    • Ändert den Spielzustand von der APP zum Spielobjekt selbst.Changes in the game state from the app to the game object itself.
    • Details zum Aktualisieren der Benutzeroberfläche des Spiels (Overlay und Heads-Up-Display), Animationen und Physik (Dynamics).Details for updating the game's UI (overlay and heads-up display), animations, and physics (the dynamics).

    Hinweis

    Das Aktualisieren von Grafiken wird von der gamererererklasse verarbeitet, die Methoden zum Abrufen und Verwenden von Grafikgeräte Ressourcen enthält, die vom Spiel verwendet werden.Updating of graphics is handled by the GameRenderer class, which contains methods to obtain and use graphics device resources used by the game. Weitere Informationen finden Sie unter Rendering Framework I: Intro to Rendering.For more info, see Rendering framework I: Intro to rendering.

  • Dient als Container für die Daten, die eine Spielsitzung,-Ebene oder-Lebensdauer definieren, je nachdem, wie Sie Ihr Spiel auf hoher Ebene definieren.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. In diesem Fall sind die Spiel Zustandsdaten für die Lebensdauer des Spiels und werden einmal initialisiert, wenn ein Benutzer das Spiel aufruft.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.

Informationen zum Anzeigen der von dieser Klasse definierten Methoden und Daten finden Sie unter der Simple3DGame-Klasse unten.To view the methods and data defined by this class, see The Simple3DGame class below.

Initialisieren und Starten des SpielsInitialize and start the game

Wenn ein Spieler das Spiel startet, muss das Spielobjekt den eigenen Zustand initialisieren, das Overlay erstellen und hinzufügen, die Variablen zur Nachverfolgung der Erfolge des Spielers festlegen und die Objekte instanziieren, die zum Erstellen der Level benötigt werden.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. In diesem Beispiel wird dies erreicht, wenn die gamemain -Instanz in " App:: Load" erstellt wird.In this sample, this is done when the GameMain instance is created in App::Load.

Das Game-Objekt vom Typ Simple3DGamewird im gamemain:: gamemain -Konstruktor erstellt.The game object, of type Simple3DGame, is created in the GameMain::GameMain constructor. Sie wird dann mithilfe der Simple3DGame:: Initialize -Methode initialisiert, während der " gamemain:: constructinbackground Fire-and-Forget"-Coroutine, die von " gamemain:: gamemain" aufgerufen wird.It's then initialized using the Simple3DGame::Initialize method during the GameMain::ConstructInBackground fire-and-forget coroutine, which is called from GameMain::GameMain.

Die Simple3DGame:: Initialize-MethodeThe Simple3DGame::Initialize method

Das Beispiel Spiel richtet diese Komponenten im Game-Objekt ein.The sample game sets up these components in the game object.

  • Ein neues Audiowiedergabeobjekt wird erstellt.A new audio playback object is created.
  • Arrays für die Grafikgrundtypen des Spiels werden erstellt (einschließlich Arrays für die Levelgrundtypen, Munition und Hindernisse).Arrays for the game's graphic primitives are created, including arrays for the level primitives, ammo, and obstacles.
  • Ein Speicherort für die Spielzustandsdaten mit der Bezeichnung Game wird erstellt und am durch ApplicationData::Current festgelegten Speicherort der App-Dateneinstellungen platziert.A location for saving game state data is created, named Game, and placed in the app data settings storage location specified by ApplicationData::Current.
  • Ein Spieltimer und die anfängliche spielinterne Overlaybitmap werden erstellt.A game timer and the initial in-game overlay bitmap are created.
  • Eine neue Kamera mit einem spezifischen Satz von Ansichts- und Projektionsparametern wird erstellt.A new camera is created with a specific set of view and projection parameters.
  • Das Eingabegerät (Controller) wird auf die gleiche Ausgangsausrichtung festgelegt wie die Kamera, sodass die Ausgangsposition der Steuerung exakt der Kameraposition entspricht.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.
  • Das Spielerobjekt wird erstellt und aktiviert.The player object is created and set to active. Wir verwenden ein Sphere-Objekt, um die Nähe des Players zu Wänden und Hindernissen zu erkennen und zu verhindern, dass die Kamera an einer Position positioniert wird, die das Eintauchen möglicherweise unterbricht.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.
  • Der Spielweltgrundtyp wird erstellt.The game world primitive is created.
  • Die Zylinderhindernisse werden erstellt.The cylinder obstacles are created.
  • Die Ziele (Face-Objekte) werden erstellt und nummeriert.The targets (Face objects) are created and numbered.
  • Die Munitionskugeln werden erstellt.The ammo spheres are created.
  • Die Level werden erstellt.The levels are created.
  • Der Highscore wird geladen.The high score is loaded.
  • Alle ggf. zuvor gespeicherten Spielzustände werden geladen.Any prior saved game state is loaded.

Das Spiel verfügt jetzt über Instanzen aller Hauptkomponenten — der Welt, des Players, der Hindernisse, der Ziele und der Ammo-Sphären.The game now has instances of all the key components—the world, the player, the obstacles, the targets, and the ammo spheres. Außerdem besitzt es Instanzen der Level. Diese stehen für Konfigurationen aller oben genannten Komponenten und ihrer Verhalten für die einzelnen spezifischen Level.It also has instances of the levels, which represent configurations of all of the above components and their behaviors for each specific level. Sehen wir uns nun an, wie das Spiel die Ebenen erstellt.Now let's see how the game builds the levels.

Spiele Ebenen erstellen und ladenBuild and load game levels

In den Dateien, die Level[N].h/.cpp im Ordner " gamelevels " der Beispiellösung gefunden werden, wird der größte Teil der Arbeit auf der Ebene erstellt.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. Da es sich um eine sehr spezifische Implementierung konzentriert, werden Sie hier nicht behandelt.Because it focuses on a very specific implementation, we won't be covering them here. Wichtig ist, dass der Code für jede Ebene als separates Ebene [N] -Objekt ausgeführt wird.The important thing is that the code for each level is run as a separate Level[N] object. Wenn Sie das Spiel erweitern möchten, können Sie ein Level [N] -Objekt erstellen, das eine zugewiesene Zahl als Parameter annimmt und die Hindernisse und Ziele nach dem Zufallsprinzip platziert.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. Oder Sie können Konfigurationsdaten auf Lade Ebene aus einer Ressourcen Datei oder sogar aus dem Internet laden.Or, you can have it load level configuration data from a resource file, or even the internet.

Definieren des SpielsDefine the gameplay

An dieser Stelle haben wir alle Komponenten, die wir für die Entwicklung des Spiels benötigen.At this point, we have all the components we need to develop the game. Die Ebenen wurden im Arbeitsspeicher aus den primitiven erstellt und sind bereit für den Start der Interaktion mit dem Player.The levels have been constructed in memory from the primitives, and are ready for the player to start interacting with.

Die besten Spiele reagieren umgehend auf die Eingabe des Players und stellen sofortiges Feedback bereit.The best games react instantly to player input, and provide immediate feedback. Dies gilt für jede Art von Spiel, von Twitch-Action und Echt Zeit Ersteller bis hin zu durchdachten, Turn-basierten Strategie spielen.This is true for any type of a game, from twitch-action, real-time first-person shooters to thoughtful, turn-based strategy games.

Die Simple3DGame:: rungame-MethodeThe Simple3DGame::RunGame method

Während der Ausführung einer Spielebene befindet sich das Spiel im Dynamics -Zustand.While a game level is in progress, the game is in the Dynamics state.

Gamemain:: Update ist die Haupt Update Schleife, die den Anwendungs Zustand einmal pro Frame aktualisiert, wie unten gezeigt.GameMain::Update is the main update loop that updates the application state once per frame, as shown below. Die Update-Schleife ruft die Simple3DGame:: rungame -Methode auf, um die Arbeit zu verarbeiten, wenn sich das Spiel im Dynamics -Zustand befindet.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 verarbeitet den Satz von Daten, der den aktuellen Zustand des Spiels für die aktuelle Iterationen der Spiel Schleife definiert.Simple3DGame::RunGame handles the set of data that defines the current state of the game play for the current iteration of the game loop.

Hier ist die Spielfluss Logik in Simple3DGame:: rungame.Here's the game flow logic in Simple3DGame::RunGame.

  • Die-Methode aktualisiert den Timer, der die Sekunden nach unten anzählt, bis die Ebene abgeschlossen ist, und testet, ob die Zeit der Ebene abgelaufen ist.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. Dies ist eine der Regeln des Spiels — , wenn die Zeit abgelaufen ist, wenn nicht alle Ziele erreicht wurden, dann ist das Spiel.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.
  • Wenn die Zeit abgelaufen ist, legt die-Methode den Zeit abgelaufenen Spielzustand fest und kehrt zur Update -Methode im vorherigen Code zurück.If time has run out, then the method sets the TimeExpired game state, and returns to the Update method in the previous code.
  • Wenn die Zeit verbleibt, wird der Verschiebungs Controller für ein Update der Kameraposition abgerufen. genauer gesagt: ein Update für den Winkel der Ansicht, das normal von der Kameraebene projiziert wird (wo der Spieler sucht), und die Entfernung, die der Winkel seit der letzten Abruf Position des Controllers verschoben wurde.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.
  • Die Kamera wird auf der Grundlage der neuen Daten des Bewegungs- und Blickrichtungscontrollers aktualisiert.The camera is updated based on the new data from the move-look controller.
  • Die Dynamik (also die Animationen und das Verhalten von Objekten in der Spielwelt, die nicht vom Spieler gesteuert werden) wird aktualisiert.The dynamics, or the animations and behaviors of objects in the game world independent of player control, are updated. In diesem Beispiel Spiel wird die Simple3DGame:: updatedynamics -Methode aufgerufen, um die Bewegung der ausgelösten Ammo-Bereiche, die Animation der Säulen Hindernisse und die Verschiebung der Ziele zu aktualisieren.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. Weitere Informationen finden Sie unter Aktualisieren der Spiel Welt.For more information, see Update the game world.
  • Die-Methode überprüft, ob die Kriterien für den erfolgreichen Abschluss einer Ebene erfüllt sind.The method checks to see whether the criteria for the successful completion of a level have been met. Wenn dies der Fall ist, wird das Ergebnis für die Ebene abgeschlossen, und es wird überprüft, ob es sich um die letzte Ebene (von 6) handelt.If so, it finalizes the score for the level, and checks to see whether this is the last level (of 6). Wenn es sich um die letzte Ebene handelt, gibt die Methode den gamestate:: gamecomplete -Spielzustand zurück. Andernfalls wird der gamestate:: levelcomplete -Spielstatus zurückgegeben.If it's the last level, then the method returns the GameState::GameComplete game state; otherwise, it returns the GameState::LevelComplete game state.
  • Wenn die Ebene nicht fertig ist, legt die-Methode den Spielzustand auf gamestate:: Activefest und gibt zurück.If the level isn't complete, then the method sets the game state to GameState::Active, and returns.

Aktualisieren der Spiel WeltUpdate the game world

Wenn das Spiel in diesem Beispiel ausgeführt wird, wird die Simple3DGame:: updatedynamics -Methode von der Simple3DGame:: rungame -Methode aufgerufen (die aus gamemain:: Updateaufgerufen wird), um Objekte zu aktualisieren, die in einer Spielszene gerendert werden.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.

Eine-Schleife, wie z. b. updatedynamics , ruft alle Methoden auf, die verwendet werden, um die Spiel Welt in Bewegung unabhängig von der Player Eingabe festzulegen, um ein immersives Spielverhalten zu schaffen und die Ebene in den Leben zu bringen.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. Dies umfasst Grafiken, die gerendert werden müssen, und das Ausführen von Animations Schleifen, um eine dynamische Welt zu bringen, auch wenn keine Spieler Eingaben vorhanden sind.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. In Ihrem Spiel kann es Strukturen geben, die sich im Wind befinden, Wellen entlang der Küstenlinien, das Rauchen von Maschinen und die Art und Weise, in der Sie sich bewegen.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. Hierzu gehört auch die Interaktion zwischen Objekten (beispielsweise Kollisionen zwischen der Spielerkugel und der Welt oder zwischen der Munition und den Hindernissen oder Zielen).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.

Wenn das Spiel nicht speziell angehalten wurde, sollte die Spiel Schleife weiterhin die Spielewelt aktualisieren. ob dies auf der Spiellogik, physischen Algorithmen oder ganz einfach ist.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.

Im Beispiel Spiel heißt dieses Prinzip Dynamicsund umfasst den Anstieg und den Rückgang der Säulen Hindernisse sowie das Bewegungsverhalten und das physische Verhalten der Ammo-Sphären, wenn Sie ausgelöst und in Bewegung sind.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.

Die Simple3DGame:: updatedynamics-MethodeThe Simple3DGame::UpdateDynamics method

Diese Methode behandelt diese vier Sätze von Berechnungen.This method deals with these four sets of computations.

  • Die Positionen der Kugeln für die abgefeuerte Munition in der Spielwelt.The positions of the fired ammo spheres in the world.
  • Die Animation der Säulenhindernisse.The animation of the pillar obstacles.
  • Die Überschneidung des Spielers mit den Begrenzungen der Spielwelt.The intersection of the player and the world boundaries.
  • Die Kollisionen von Munitionskugeln mit den Hindernissen, den Zielen, anderen Munitionskugeln und der Spielwelt.The collisions of the ammo spheres with the obstacles, the targets, other ammo spheres, and the world.

Die Animation der Hindernisse findet in einer Schleife statt, die in den Quell Code Dateien animieren. h/. cpp definiert ist.The animation of the obstacles takes place in a loop defined in the Animate.h/.cpp source code files. Das Verhalten des Ammo und aller Kollisionen wird durch vereinfachte Physik Algorithmen definiert, die im Code bereitgestellt und durch eine Reihe von globalen Konstanten für die Spiel Welt parametrisiert werden, einschließlich der Schweregrad-und Materialeigenschaften.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. All dies wird im Koordinatenbereich der Spielwelt berechnet.This is all computed in the game world coordinate space.

Überprüfen des FlowsReview the flow

Nachdem wir alle Objekte in der Szene aktualisiert und alle Kollisionen berechnet haben, müssen wir diese Informationen verwenden, um die entsprechenden visuellen Änderungen zu zeichnen.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.

Nachdem gamemain:: Update die aktuelle iterierung der Game-Schleife abgeschlossen hat, ruft das Beispiel sofort gamerenderer:: Rendering auf, um die aktualisierten Objektdaten zu erstellen und eine neue Szene zu generieren, die dem Player angezeigt wird, wie unten gezeigt.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.
}

Renderdie Grafiken der Spiel WeltRender the game world's graphics

Es wird empfohlen, die Grafiken in einem Spiel zu aktualisieren, im Idealfall genau so oft wie die Hauptspiel Schleife.We recommend that the graphics in a game update often, ideally exactly as often as the main game loop iterates. Wenn die Schleife durchlaufen wird, wird der Zustand der Spiel Welt mit oder ohne Player Eingabe aktualisiert.As the loop iterates, the game world's state is updated, with or without player input. Dadurch können die berechneten Animationen und Verhalten reibungslos angezeigt werden.This allows the calculated animations and behaviors to be displayed smoothly. Stellen Sie sich vor, dass eine einfache Wasser Szene, die nur verschoben wurde, wenn der Player auf eine Schaltfläche geklickt hat.Imagine if we had a simple scene of water that moved only when the player pressed a button. Das wäre nicht realistisch. ein gutes Spiel sieht immer glatt und flüssig aus.That wouldn't be realistic; a good game looks smooth and fluid all the time.

Erinnern Sie sich an die Beispiel Spiel Schleife, wie oben in gamemain:: Rungezeigt.Recall the sample game's loop as shown above in GameMain::Run. Wenn das Hauptfenster des Spiels sichtbar ist, nicht angedockt oder deaktiviert ist, werden die Ergebnisse dieses Updates weiterhin aktualisiert und gerenppt.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. Die " gamerenderer:: Rendering "-Methode, die wir als nächstes untersuchen, rendert eine Darstellung dieses Zustands.The GameRenderer::Render method we examine next renders a representation of that state. Dies erfolgt unmittelbar nach einem callmain:: Update-Befehl, der Simple3DGame:: rungame zum Aktualisieren von Zuständen umfasst, wie im vorherigen Abschnitt erläutert wurde.This is done immediately after a call to GameMain::Update, which includes Simple3DGame::RunGame to update states, as discussed in the previous section.

Gamerderderer:: Rendering zeichnet die Projektion der 3D-Welt und zeichnet dann die Direct2D-Überlagerung.GameRenderer::Render draws the projection of the 3D world, and then draws the Direct2D overlay on top of it. Nach Abschluss des Vorgangs zeigt sie die finale Swapchain mit den kombinierten Puffern an.When completed, it presents the final swap chain with the combined buffers for display.

Hinweis

Es gibt zwei Zustände für den Direct2D-Overlay des samplingspiels — , bei dem das Spiel das Spiel Info-Overlay anzeigt, das die Bitmap für das Menü Pause enthält, und eines, in dem das Spiel die Kreuz und die Rechtecke für den Touchscreen-Verschiebungs Controller anzeigt.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. Der Text mit dem Spielstand wird in beiden Zuständen gezeichnet.The score text is drawn in both states. Weitere Informationen finden Sie unter Rendering Framework I: Intro to Rendering.For more information, see Rendering framework I: Intro to rendering.

Die gamerderderer:: Rendering-MethodeThe 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
                );
        }
        ...
    }
}

Die Simple3DGame-KlasseThe Simple3DGame class

Dabei handelt es sich um die Methoden und Datenmember, die von der Simple3DGame -Klasse definiert werden.These are the methods and data members that are defined by the Simple3DGame class.

MemberfunktionenMember functions

Die von Simple3DGame definierten öffentlichen Member-Funktionen enthalten die folgenden.Public member functions defined by Simple3DGame include the ones below.

  • Initialisieren.Initialize. Legt die Anfangswerte der globalen Variablen fest und initialisiert die Spielobjekte.Sets the starting values of the global variables, and initializes the game objects. Dies wird im Abschnitt initialisieren und Starten des Spiels beschrieben.This is covered in the Initialize and start the game section.
  • LoadGame.LoadGame. Initialisiert eine neue Ebene und beginnt damit, Sie zu laden.Initializes a new level, and starts loading it.
  • LoadLevelAsync.LoadLevelAsync. Eine Coroutine, die die Ebene initialisiert und dann eine weitere Coroutine für den Renderer aufruft, um die gerätespezifischen ebenendourcen zu laden.A coroutine that initializes the level, and then invokes another coroutine on the renderer to load the device-specific level resources. Diese Methode wird in einem gesonderten Thread ausgeführt. Daher können in diesem Thread nur ID3D11Device-Methoden (und keine ID3D11DeviceContext-Methoden) aufgerufen werden.This method runs in a separate thread; as a result, only ID3D11Device methods (as opposed to ID3D11DeviceContext methods) can be called from this thread. Alle Gerätekontextmethoden werden in der FinalizeLoadLevel-Methode aufgerufen.Any device context methods are called in the FinalizeLoadLevel method. Wenn Sie mit der asynchronen Programmierung noch nicht vertraut sind, finden Sie weitere Informationen unter Parallelität und asynchrone Vorgänge mit C++/WinRT.If you're new to asynchronous programming, then see Concurrency and asynchronous operations with C++/WinRT.
  • FinalizeLoadLevel.FinalizeLoadLevel. Führt alle Aktionen zum Laden des Levels aus, die im Hauptthread durchgeführt werden müssen.Completes any work for level loading that needs to be done on the main thread. Dies schließt alle Aufrufe von Direct3D 11-Gerätekontextmethoden (ID3D11DeviceContext) ein.This includes any calls to Direct3D 11 device context (ID3D11DeviceContext) methods.
  • StartLevel.StartLevel. Startet das Spiel für eine neue Ebene.Starts the gameplay for a new level.
  • PauseGame.PauseGame. Hält das Spiel an.Pauses the game.
  • RunGame.RunGame. Führt eine Iteration der Spielschleife aus.Runs an iteration of the game loop. Wird jeweils einmal pro Iteration der Spielschleife von App::Update aufgerufen, sofern sich das Spiel im Zustand Active befindet.It's called from App::Update one time every iteration of the game loop if the game state is Active.
  • OnSuspending und OnResuming.OnSuspending and OnResuming. Halten Sie die Audiodatei an bzw. setzen Sie Sie fort.Suspend/resume the game's audio, respectively.

Hier sind die private Member-Funktionen aufgeführt.Here are the private member functions.

  • LoadSavedState und SaveState.LoadSavedState and SaveState. Laden/Speichern Sie den aktuellen Status des Spiels.Load/save the current state of the game, respectively.
  • Loadhighscore und savehighscore.LoadHighScore and SaveHighScore. Laden/Speichern Sie die hohe Bewertung über die Spiele hinweg.Load/save the high score across games, respectively.
  • InitializeAmmo.InitializeAmmo. Setzt den Zustand der als Munition verwendeten Kugelobjekte in den Originalzustand für den Beginn einer neuen Runde zurück.Resets the state of each sphere object used as ammunition back to its original state for the beginning of each round.
  • UpdateDynamics.UpdateDynamics. Dies ist eine wichtige Methode, da Sie alle Spielobjekte auf der Grundlage von Animations Routinen, Physik und Steuerungs Eingaben aktualisiert.This is an important method because it updates all the game objects based on canned animation routines, physics, and control input. Hierbei handelt es sich gewissermaßen um das Herzstück der Interaktivität, die das Spiel ausmacht.This is the heart of the interactivity that defines the game. Dies wird im Abschnitt Aktualisieren der Spiel Welt behandelt.This is covered in the Update the game world section.

Bei den anderen öffentlichen Methoden handelt es sich um einen Eigenschafts Accessor, der für die Anzeige ein-und über Lagerungs spezifische Informationen zum App-Framework zurückgibtThe other public methods are property accessor that return gameplay- and overlay-specific information to the app framework for display.

DatenmemberData members

Diese Objekte werden aktualisiert, wenn die Spiel Schleife ausgeführt wird.These objects are updated as the game loop runs.

  • Das Objekt " muvelookcontroller ".MoveLookController object. Stellt die Eingabe des Players dar.Represents the player input. Weitere Informationen finden Sie unter Hinzufügen von Steuerelementen.For more information, see Adding controls.
  • Gamerenderer -Objekt.GameRenderer object. Stellt einen Direct3D 11-Renderer dar, der alle gerätespezifischen Objekte und deren Rendering behandelt.Represents a Direct3D 11 renderer, which handles all the device-specific objects and their rendering. Weitere Informationen finden Sie unter Rendering Framework I.For more information, see Rendering framework I.
  • Audioobjekt .Audio object. Steuert die Audiowiedergabe für das Spiel.Controls the audio playback for the game. Weitere Informationen finden Sie unter Hinzufügen von Sound.For more information, see Adding sound.

Die restlichen Spiel Variablen enthalten die Listen der primitiven und ihre jeweiligen in-Game-Beträge sowie die spezifischen Daten und Einschränkungen für das Spiel.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.

Nächste SchritteNext steps

Wir müssen noch über die tatsächliche Renderingengine sprechen, — wie Aufrufe der Rendermethoden auf den aktualisierten primitiven in Pixel auf dem Bildschirm umgewandelt werden.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. Diese Aspekte werden in zwei Teilen beschrieben: Einführung in das — Rendering und Rendering Framework II: Game Rendering.Those aspects are covered in two parts—Rendering framework I: Intro to rendering and Rendering framework II: Game rendering. Wenn Sie mehr darüber interessiert sind, wie die Player Steuerelemente den Spielzustand aktualisieren, finden Sie weitere Informationen unter Hinzufügen von Steuerelementen.If you're more interested in how the player controls update the game state, then see Adding controls.