Definir el objeto principal del juegoDefine the main game object

Nota

Este tema forma parte de la serie de tutoriales de creación de una plataforma universal de Windows sencilla (UWP) con DirectX .This topic is part of the Create a simple Universal Windows Platform (UWP) game with DirectX tutorial series. El tema de ese vínculo establece el contexto de la serie.The topic at that link sets the context for the series.

Una vez que haya diseñado el marco de trabajo básico del juego de ejemplo e implementado una máquina de Estados que controle los comportamientos de los usuarios y del sistema de alto nivel, querrá examinar las reglas y las mecánicas que convierten el juego de ejemplo en un juego.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. Echemos un vistazo a los detalles del objeto principal del juego de ejemplo y cómo traducir las reglas del juego en interacciones con el mundo de juego.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.

ObjetivosObjectives

  • Obtenga información sobre cómo aplicar las técnicas de desarrollo básicas para implementar las reglas y los mecanismos de juego para un juego DirectX de UWP.Learn how to apply basic development techniques to implement game rules and mechanics for a UWP DirectX game.

Objeto principal del juegoMain game object

En el juego de ejemplo Simple3DGameDX , Simple3DGame es la clase principal del juego de objetos.In the Simple3DGameDX sample game, Simple3DGame is the main game object class. Una instancia de Simple3DGame se construye, indirectamente, a través del método App:: Load .An instance of Simple3DGame is constructed, indirectly, via the App::Load method.

Estas son algunas de las características de la clase Simple3DGame .Here are some of the features of the Simple3DGame class.

  • Contiene la implementación de la lógica de juego.Contains implementation of the gameplay logic.
  • Contiene métodos que comunican estos detalles.Contains methods that communicate these details.
    • Cambios en el estado del juego a la máquina de Estados definida en el marco de trabajo de la aplicación.Changes in the game state to the state machine defined in the app framework.
    • Cambios en el estado del juego desde la aplicación hasta el propio objeto de juego.Changes in the game state from the app to the game object itself.
    • Detalles para actualizar la interfaz de usuario del juego (pantalla de superposición y cabeza arriba), animaciones y física (la dinámica).Details for updating the game's UI (overlay and heads-up display), animations, and physics (the dynamics).

    Nota

    La actualización de gráficos se controla mediante la clase GameRenderer , que contiene métodos para obtener y usar los recursos de dispositivo gráficos utilizados por el juego.Updating of graphics is handled by the GameRenderer class, which contains methods to obtain and use graphics device resources used by the game. Para obtener más información, vea marco de representación I: Introducción a la representación.For more info, see Rendering framework I: Intro to rendering.

  • Actúa como contenedor de los datos que definen una sesión de juego, un nivel o una duración, en función de cómo se defina el juego en un nivel alto.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. En este caso, los datos de estado del juego son para la duración del juego y se inicializan una vez cuando un usuario inicia el juego.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.

Para ver los métodos y los datos definidos por esta clase, vea la clase Simple3DGame a continuación.To view the methods and data defined by this class, see The Simple3DGame class below.

Inicializar e iniciar el juegoInitialize and start the game

Cuando un jugador inicia el juego, el objeto del juego debe inicializar su estado, crear y agregar la superposición, establecer las variables que realizan un seguimiento del rendimiento del jugador y crear una instancia de los objetos que usará para generar los niveles.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. En este ejemplo, esto se hace cuando se crea la instancia de GameMain en App:: Load.In this sample, this is done when the GameMain instance is created in App::Load.

El objeto Game, de tipo Simple3DGame, se crea en el constructor GameMain:: GameMain .The game object, of type Simple3DGame, is created in the GameMain::GameMain constructor. Después, se inicializa con el método Simple3DGame:: Initialize durante la corutina GameMain:: ConstructInBackground Fire-and-olvidó, a la que se llama desde 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.

El método Simple3DGame:: InitializeThe Simple3DGame::Initialize method

En el juego de ejemplo se configuran estos componentes en el objeto Game.The sample game sets up these components in the game object.

  • Se crea un objeto de reproducción de audio.A new audio playback object is created.
  • Se crean matrices para los primitivos gráficos del juego, incluidas matrices para los primitivos de nivel, munición y obstáculos.Arrays for the game's graphic primitives are created, including arrays for the level primitives, ammo, and obstacles.
  • Se crea una ubicación denominada Game donde guardar los datos de estado de las partidas, y se coloca en la ubicación de almacenamiento de configuración de datos de aplicación especificada por 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.
  • Se crea un reloj de juego y el mapa de bits de representación en la partida inicial.A game timer and the initial in-game overlay bitmap are created.
  • Se crea una nueva cámara con un conjunto específico de parámetros de vista y proyección.A new camera is created with a specific set of view and projection parameters.
  • El dispositivo de entrada (el mando) se establece con la misma rotación alrededor del eje x (pitch) y la misma rotación alrededor del eje y (yaw) de inicio que la cámara, de modo que el jugador tiene una correspondencia 1 a 1 entre la posición de control inicial y la posición de la cámara.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.
  • Se crea el objeto de jugador y se establece en activo.The player object is created and set to active. Usamos un objeto sphere para detectar la proximidad del jugador con las paredes y los obstáculos y para evitar que la cámara se coloque en una posición que pueda romper la inmersión.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.
  • Se crea el primitivo del mundo de juego.The game world primitive is created.
  • Se crean los obstáculos cilíndricos.The cylinder obstacles are created.
  • Se crean los objetivos (objetos Face) y se numeran.The targets (Face objects) are created and numbered.
  • Se crean las esferas de munición.The ammo spheres are created.
  • Se crean los niveles.The levels are created.
  • Se carga la puntuación más alta.The high score is loaded.
  • Se carga cualquier estado de juego guardado anteriormente.Any prior saved game state is loaded.

Ahora, el juego tiene instancias de todos los componentes clave — del mundo, el jugador, los obstáculos, los objetivos y las esferas de munición.The game now has instances of all the key components—the world, the player, the obstacles, the targets, and the ammo spheres. También tiene instancias de los niveles, que representan configuraciones de todos los componentes anteriores y sus comportamientos en cada nivel específico.It also has instances of the levels, which represent configurations of all of the above components and their behaviors for each specific level. Ahora veamos cómo el juego compila los niveles.Now let's see how the game builds the levels.

Compilar y cargar niveles de juegoBuild and load game levels

La mayor parte del trabajo pesado para la construcción de nivel se realiza en los Level[N].h/.cpp archivos que se encuentran en la carpeta GameLevels de la solución de ejemplo.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. Dado que se centra en una implementación muy específica, no los cubriremos aquí.Because it focuses on a very specific implementation, we won't be covering them here. Lo importante es que el código de cada nivel se ejecute como un objeto de nivel independiente [N] .The important thing is that the code for each level is run as a separate Level[N] object. Si desea ampliar el juego, puede crear un objeto de nivel [N] que toma un número asignado como parámetro y coloca aleatoriamente los obstáculos y los destinos.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. O bien, puede hacer que se carguen datos de configuración de nivel de un archivo de recursos o incluso Internet.Or, you can have it load level configuration data from a resource file, or even the internet.

Definir el juegoDefine the gameplay

En este momento, tenemos todos los componentes necesarios para desarrollar el juego.At this point, we have all the components we need to develop the game. Los niveles se han construido en la memoria a partir de los primitivos y están listos para que el reproductor empiece a interactuar con.The levels have been constructed in memory from the primitives, and are ready for the player to start interacting with.

Los mejores juegos reaccionan al instante a la entrada del jugador y proporcionan comentarios inmediatos.The best games react instantly to player input, and provide immediate feedback. Esto se aplica a cualquier tipo de juego, desde Twitch-Action, los captadores de primera persona en tiempo real a juegos de estrategia meditados y basados en turnos.This is true for any type of a game, from twitch-action, real-time first-person shooters to thoughtful, turn-based strategy games.

El método Simple3DGame:: RunGameThe Simple3DGame::RunGame method

Mientras un nivel de juego está en curso, el juego está en el estado de Dynamics .While a game level is in progress, the game is in the Dynamics state.

GameMain:: Update es el bucle de actualización principal que actualiza el estado de la aplicación una vez por cada fotograma, como se muestra a continuación.GameMain::Update is the main update loop that updates the application state once per frame, as shown below. El bucle de actualización llama al método Simple3DGame:: RunGame para controlar el trabajo si el juego está en el estado de 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 controla el conjunto de datos que define el estado actual de la reproducción del juego para la iteración actual del bucle del juego.Simple3DGame::RunGame handles the set of data that defines the current state of the game play for the current iteration of the game loop.

Esta es la lógica de flujo de juegos en Simple3DGame:: RunGame.Here's the game flow logic in Simple3DGame::RunGame.

  • El método actualiza el temporizador que cuenta los segundos hasta que se completa el nivel y comprueba si ha expirado la hora del nivel.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. Esta es una de las reglas del juego — cuando se agota el tiempo, si no se han captado todos los destinos, se trata de un juego.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 se agota el tiempo, el método establece el estado del juego TimeExpired y vuelve al método Update en el código anterior.If time has run out, then the method sets the TimeExpired game state, and returns to the Update method in the previous code.
  • Si se mantiene el tiempo, el controlador de movimiento y búsqueda se sondea en busca de una actualización en la posición de la cámara. en concreto, una actualización en el ángulo de la vista normal proyectando desde el plano de la cámara (donde está buscando el reproductor) y la distancia que el ángulo ha cambiado desde que se sondeó el controlador por última vez.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 cámara se actualiza basándose en los nuevos datos del mando de movimiento y vista.The camera is updated based on the new data from the move-look controller.
  • Se actualiza la dinámica, es decir, la animación y los comportamientos de los objetos en el mundo del juego que son independientes del control del jugador.The dynamics, or the animations and behaviors of objects in the game world independent of player control, are updated. En este juego de ejemplo, se llama al método Simple3DGame:: UpdateDynamics para actualizar el movimiento de las esferas de munición que se han desencadenado, la animación de los obstáculos del Pilar y el movimiento de los destinos.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. Para obtener más información, consulte actualización del mundo de juegos.For more information, see Update the game world.
  • El método comprueba si se han cumplido los criterios de la finalización correcta de un nivel.The method checks to see whether the criteria for the successful completion of a level have been met. Si es así, finaliza la puntuación para el nivel y comprueba si este es el último nivel (de 6).If so, it finalizes the score for the level, and checks to see whether this is the last level (of 6). Si es el último nivel, el método devuelve el estado de juego GameState:: GameComplete . de lo contrario, devuelve el estado de juego 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 el nivel no está completo, el método establece el estado del juego en GameState:: Activey devuelve.If the level isn't complete, then the method sets the game state to GameState::Active, and returns.

Actualizar el mundo del juegoUpdate the game world

En este ejemplo, cuando se ejecuta el juego, se llama al método Simple3DGame:: UpdateDynamics desde el método Simple3DGame:: RunGame (al que se llama desde GameMain:: Update) para actualizar los objetos que se representan en una escena de juego.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.

Un bucle como UpdateDynamics llama a los métodos que se usan para establecer el mundo del juego en movimiento, independientemente de la entrada del jugador, para crear una experiencia de juego envolvente y hacer que el nivel esté activo.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. Esto incluye los gráficos que se deben representar y la ejecución de bucles de animación para traer un mundo dinámico, incluso cuando no hay ninguna entrada en el reproductor.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. En el juego, eso podría incluir árboles que se encuentran en el viento, la cresta de las ondas a lo largo de las líneas de tierra, el fumar de la maquinaria y la Monsters y el desplazamiento.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. También incluye la interacción entre objetos, incluidas las colisiones entre la esfera del jugador y el mundo, o entre la munición y los obstáculos y objetivos.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.

Excepto cuando el juego está en pausa, el bucle del juego debe seguir actualizando el mundo del juego; Si se basa en la lógica del juego, en los algoritmos físicos o en si es simplemente aleatorio simple.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.

En el juego de ejemplo, este principio se denomina Dynamicsy engloba el aumento y el descenso de los obstáculos del pilar, y el movimiento y los comportamientos físicos de las esferas de munición a medida que se activan y están en movimiento.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.

El método Simple3DGame:: UpdateDynamicsThe Simple3DGame::UpdateDynamics method

Este método trata los cuatro conjuntos de cálculos.This method deals with these four sets of computations.

  • Las posiciones de las esferas de munición disparadas en el mundo.The positions of the fired ammo spheres in the world.
  • La animación de los obstáculos con forma de columna.The animation of the pillar obstacles.
  • La intersección de los límites del jugador y el mundo.The intersection of the player and the world boundaries.
  • Las colisiones de las esferas de munición con los obstáculos, los destinos, otras esferas de munición y el mundo.The collisions of the ammo spheres with the obstacles, the targets, other ammo spheres, and the world.

La animación de los obstáculos tiene lugar en un bucle definido en los archivos de código fuente Animate. h/. cpp .The animation of the obstacles takes place in a loop defined in the Animate.h/.cpp source code files. El comportamiento de la munición y las colisiones se definen mediante algoritmos de física simplificada, suministrados en el código y parametrizados por un conjunto de constantes globales para el mundo de juego, incluidas las propiedades de la gravedad y del material.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. Todo esto se calcula en el espacio coordinado del mundo de juego.This is all computed in the game world coordinate space.

Revisar el flujoReview the flow

Ahora que hemos actualizado todos los objetos de la escena y se han calculado las colisiones, es necesario usar esta información para dibujar los cambios visuales correspondientes.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.

Después de que GameMain:: Update haya completado la iteración actual del bucle del juego, el ejemplo llama inmediatamente a GameRenderer:: Render para tomar los datos del objeto actualizado y generar una nueva escena para presentar al reproductor, como se muestra a continuación.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.
}

Presentar los gráficos del mundo de juegoRender the game world's graphics

Se recomienda que los gráficos de un juego se actualicen a menudo, idealmente exactamente como se repite el bucle principal del juego.We recommend that the graphics in a game update often, ideally exactly as often as the main game loop iterates. A medida que el bucle se repite, se actualiza el estado del mundo del juego, con o sin la entrada del jugador.As the loop iterates, the game world's state is updated, with or without player input. Esto permite que las animaciones calculadas y los comportamientos se muestren sin problemas.This allows the calculated animations and behaviors to be displayed smoothly. Imagine que tuvimos una escena simple de agua que se movía solo cuando el jugador presionó un botón.Imagine if we had a simple scene of water that moved only when the player pressed a button. Eso no sería realista; un buen juego parece suave y fluido todo el tiempo.That wouldn't be realistic; a good game looks smooth and fluid all the time.

Recuerde el bucle del juego de ejemplo tal y como se muestra anteriormente en GameMain:: Run.Recall the sample game's loop as shown above in GameMain::Run. Si la ventana principal del juego está visible y no está ajustada o desactivada, el juego continúa actualizando y procesando los resultados de esa actualización.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. El método GameRenderer:: Render que examinamos a continuación representa una representación de ese estado.The GameRenderer::Render method we examine next renders a representation of that state. Esto se realiza inmediatamente después de una llamada a GameMain:: Update, que incluye Simple3DGame:: RunGame para actualizar los Estados, como se describe en la sección anterior.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 dibuja la proyección del mundo 3D y, a continuación, dibuja la superposición de Direct2D en la parte superior.GameRenderer::Render draws the projection of the 3D world, and then draws the Direct2D overlay on top of it. Una vez completado, presenta la cadena de intercambio final con los búferes combinados para su representación.When completed, it presents the final swap chain with the combined buffers for display.

Nota

Hay dos Estados para la superposición de Direct2D del juego de ejemplo — , donde el juego muestra la superposición de la información del juego que contiene el mapa de bits para el menú de pausa y otro en el que el juego muestra las cruces junto con los rectángulos para el controlador de movimiento y búsqueda de la pantalla táctil.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. El texto de puntuación aparece dibujado en ambos estados.The score text is drawn in both states. Para obtener más información, vea marco de representación I: Introducción a la representación.For more information, see Rendering framework I: Intro to rendering.

El método 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 clase Simple3DGameThe Simple3DGame class

Estos son los métodos y miembros de datos que se definen mediante la clase Simple3DGame .These are the methods and data members that are defined by the Simple3DGame class.

Funciones miembroMember functions

Entre las funciones miembro públicas definidas por Simple3DGame se incluyen las siguientes.Public member functions defined by Simple3DGame include the ones below.

  • Inicializar.Initialize. Establece los valores iniciales de las variables globales e inicializa los objetos de juego.Sets the starting values of the global variables, and initializes the game objects. Esto se trata en la sección inicialización e inicio del juego .This is covered in the Initialize and start the game section.
  • LoadGame.LoadGame. Inicializa un nuevo nivel y comienza a cargarlo.Initializes a new level, and starts loading it.
  • LoadLevelAsync.LoadLevelAsync. Una corutina que inicializa el nivel y, a continuación, invoca otra corutina en el representador para cargar los recursos del nivel específico del dispositivo.A coroutine that initializes the level, and then invokes another coroutine on the renderer to load the device-specific level resources. Este método se ejecuta en otro subproceso; como consecuencia, solo se puede llamar a los métodos ID3D11Device (en contraposición a los métodos ID3D11DeviceContext) desde este subproceso.This method runs in a separate thread; as a result, only ID3D11Device methods (as opposed to ID3D11DeviceContext methods) can be called from this thread. Los métodos de contexto de dispositivo se llaman en el método FinalizeLoadLevel.Any device context methods are called in the FinalizeLoadLevel method. Si no está familiarizado con la programación asincrónica, vea simultaneidad y operaciones asincrónicas con C++/WinRT.If you're new to asynchronous programming, then see Concurrency and asynchronous operations with C++/WinRT.
  • FinalizeLoadLevel.FinalizeLoadLevel. Finaliza cualquier tarea de carga de nivel que sea necesario realizar en el subproceso principal.Completes any work for level loading that needs to be done on the main thread. Esto incluye cualquier llamada a métodos de contexto de dispositivo de Direct3D 11 (ID3D11DeviceContext).This includes any calls to Direct3D 11 device context (ID3D11DeviceContext) methods.
  • StartLevel.StartLevel. Inicia el juego para un nuevo nivel.Starts the gameplay for a new level.
  • PauseGame.PauseGame. Pausa el juego.Pauses the game.
  • RunGame.RunGame. Ejecuta una iteración del bucle del juego.Runs an iteration of the game loop. Si el estado del juego es is Active, recibe una llamada de App::Update una vez cada iteración del bucle del juego.It's called from App::Update one time every iteration of the game loop if the game state is Active.
  • OnSuspending y OnResuming.OnSuspending and OnResuming. Suspender o reanudar el audio del juego, respectivamente.Suspend/resume the game's audio, respectively.

Estas son las funciones miembro privadas.Here are the private member functions.

  • LoadSavedState and SaveState.LoadSavedState and SaveState. Carga y guarda el estado actual del juego, respectivamente.Load/save the current state of the game, respectively.
  • LoadHighScore y SaveHighScore.LoadHighScore and SaveHighScore. Carga y guarda la puntuación alta en los juegos, respectivamente.Load/save the high score across games, respectively.
  • InitializeAmmo.InitializeAmmo. Restablece el estado de cada objeto de esfera usado como munición a su estado original al inicio de cada ronda.Resets the state of each sphere object used as ammunition back to its original state for the beginning of each round.
  • UpdateDynamics.UpdateDynamics. Se trata de un método importante porque actualiza todos los objetos de juego basados en rutinas de animación predefinidas, física y entrada de control.This is an important method because it updates all the game objects based on canned animation routines, physics, and control input. Es el corazón de la interactividad que define el juego.This is the heart of the interactivity that defines the game. Esto se trata en la sección actualización del mundo de juegos .This is covered in the Update the game world section.

Los otros métodos públicos son los descriptores de acceso de propiedades que devuelven información específica de juegos y superposición al marco de trabajo de la aplicación para su presentación.The other public methods are property accessor that return gameplay- and overlay-specific information to the app framework for display.

Miembros de datosData members

Estos objetos se actualizan cuando se ejecuta el bucle de juego.These objects are updated as the game loop runs.

  • Objeto MoveLookController .MoveLookController object. Representa la entrada del reproductor.Represents the player input. Para obtener más información, vea Agregar controles.For more information, see Adding controls.
  • Objeto GameRenderer .GameRenderer object. Representa un representador de Direct3D 11, que controla todos los objetos específicos del dispositivo y su representación.Represents a Direct3D 11 renderer, which handles all the device-specific objects and their rendering. Para obtener más información, consulte el marco de representación I.For more information, see Rendering framework I.
  • Objeto de audio .Audio object. Controla la reproducción de audio del juego.Controls the audio playback for the game. Para obtener más información, consulte Agregar sonido.For more information, see Adding sound.

El resto de las variables del juego contienen las listas de los primitivos, así como sus respectivas cantidades en el juego, y los datos y las restricciones específicos de la reproducción del juego.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.

Pasos siguientesNext steps

Todavía hemos hablado sobre el motor de representación real sobre — cómo las llamadas a los métodos de representación en los primitivos actualizados se convierten en píxeles en la pantalla.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. Estos aspectos se describen en el marco de trabajo de representación de dos partes — I: Introducción a la representación y representación del marco II: representación de juegos.Those aspects are covered in two parts—Rendering framework I: Intro to rendering and Rendering framework II: Game rendering. Si está más interesado en la forma en que los controles del reproductor actualizan el estado del juego, vea Agregar controles.If you're more interested in how the player controls update the game state, then see Adding controls.