Restructure chapters

Make chapters consistent in that they now introduce the concepts and then update the game code at the end instead of gradually updating game code while introducing concepts.  This also allows for the full game1.cs file to be displayed at the end of the chapter for reference.

Author: AristurtleDev

articles/tutorials/building_2d_games/01_what_is_monogame/index.md

@@ -69,23 +69,15 @@ Regardless of which .NET language used, developers should have a foundational un
 
 1. Name one of the advantages of using the MonoGame framework to develop games.
 
-    <details>
-    <summary>Question 1 Answer</summary>
-
-    > Any of the following are advantages of using the MonoGame
-    > 1. It provides cross-platform support, allowing developers to target multiple platforms from a single code base.
-    >
-    > 2. It offers a set of libraries and APIs common for game development tasks, such as graphics rendering, input handling, audio, and content management
-    >
-    > 3. It is a "bring your own tools" framework, giving developers flexibility in their working environment.
-
-    </details><br />
+    :::question-answer
+    Any of the following are advantages of using the MonoGame
+    1. It provides cross-platform support, allowing developers to target multiple platforms from a single code base.
+    2. It offers a set of libraries and APIs common for game development tasks, such as graphics rendering, input handling, audio, and content management
+    3. It is a "bring your own tools" framework, giving developers flexibility in their working environment.
+    :::
 
 2. What programming languages can be used when creating a game with MonoGame?
 
-    <details>
-    <summary>Question 2 Answer</summary>
-
-    > The primary language used is C#, which is the same language that the MonoGame framework is developed in.  However, any .NET language can be used, such as F# or Visual Basic.
-
-    </details><br />
+    :::question-answer
+    The primary language used is C#, which is the same language that the MonoGame framework is developed in.  However, any .NET language can be used, such as F# or Visual Basic.
+    :::

articles/tutorials/building_2d_games/02_getting_started/images/cornflower-blue.png

@@ -17,11 +17,13 @@ While the environment setup process is similar to the standard setup process for
 The first thing we need to do is install the .NET *Software Development Kit* (SDK). At the time of this writing, MonoGame targets the .NET 8.0 SDK. To install it, follow the instructions based on your operating system below
 
 ### [Windows](#tab/windows)
+
 1. Open a web browser and navigate to https://dotnet.microsoft.com/en-us/download.
 2. Click the *Download .NET SDK x64* button to start the download of the .NET SDK Installer.
 3. Once the download finishes, run the installer
 
 ### [macOS](#tab/macos)
+
 1. Open a web browser and navigate to https://dotnet.microsoft.com/en-us/download.
 2. Click the *Download .NET SDK x64 (Intel)* button start the download of the .NET SDK Installer
 3. Once the download finishes, run the installer.  
@@ -152,7 +154,7 @@ Now that you have your development environment setup, it's time to create your f
 3. Type `.NET New Project` in the *Command Palette* and choose the *.NET New Project* command
 4. Next you'll be shown a list of the available .NET project templates. Enter `MonoGame` into the prompt to filter the project templates to only show the MonoGame ones, then choose the *MonoGame Cross-Platform Desktop Application* project template.
 5. After choosing the template, a dialog window will appear asking you to choose a location to save the project.
-6. Next you'll be prompted to enter a name for the project. Enter the name `MonoGameSnake`.
+6. Next you'll be prompted to enter a name for the project. Enter the name `DungeonSlime`.
 7. Finally, select the *Create Project* prompt.
 
 After selecting *Create Project*, a new C# project will be created based on the MonoGame template we choose and opened automatically in VSCode.
@@ -199,27 +201,18 @@ Now that your development environment is setup and ready to go, you can dive in
 
 1. What version of the .NET SDK is currently targeted by MonoGame applications?
 
-    <details>
-    <summary>Question 1 Answer</summary>
-
-    > .NET 8.0
-
-    </details><br />
+    :::question-answer
+    .NET 8.0
+    :::
 
 2. What is the current version of MonoGame?
 
-    <details>
-    <summary>Question 2 Answer</summary>
-
-    > 3.8.2.1105
-
-    </details><br /> 
+    :::question-answer
+    3.8.2.1105
+    :::
 
 3. What is the color of the game window when you run a MonoGame project for the first time?
 
-    <details>
-    <summary>Question 3 Answer</summary>
-
-    > Cornflower Blue
-
-    </details><br />
+    :::question-answer
+    Cornflower Blue
+    :::

articles/tutorials/building_2d_games/02_getting_started/images/game-window.png

@@ -5,9 +5,6 @@ description: Explore the contents of the Game1 file generated when creating a ne
 
 After you created a new MonoGame project using the *MonoGame Cross-Platform Desktop Application* template in [Chapter 02](../02_getting_started/index.md#creating-your-first-monogame-application), you will notice the generated files and project structure that serve as a starting point for your game application.  While MonoGame offers different templates based on target platform, all projects will contain the *Game1.cs* file.
 
-> [!TIP]  
-> For an in-depth look at all files created in a MonoGame project when using the MonoGame templates, refer to [Appendix 02: MonoGame Project Overview](#).
-
 ## Exploring the Game1 Class
 
 At the core of a MonoGame project is the [**Game**](xref:Microsoft.Xna.Framework.Game) class.  This class handles the initialization of graphics services, initialization of the game, loading content, updating, and rendering the game.  When you create a new Monogame project, this [**Game**](xref:Microsoft.Xna.Framework.Game) class is implemented as the `Game1` class that you can customize as needed for your specific game.
@@ -17,54 +14,10 @@ At the core of a MonoGame project is the [**Game**](xref:Microsoft.Xna.Framework
 
 Locate the *Game1.cs* file that was generated when you created the MonoGame project and open it.  The default content will be:
 
-```cs
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-using Microsoft.Xna.Framework.Input;
-
-namespace MonoGameSnake;
-
-public class Game1 : Game
-{
-    private GraphicsDeviceManager _graphics;
-    private SpriteBatch _spriteBatch;
-
-    public Game1()
-    {
-        _graphics = new GraphicsDeviceManager(this);
-        Content.RootDirectory = "Content";
-        IsMouseVisible = true;
-    }
-
-    protected override void Initialize()
-    {
-        base.Initialize();
-    }
-
-    protected override void LoadContent()
-    {
-        _spriteBatch = new SpriteBatch(GraphicsDevice);
-    }
-
-    protected override void Update(GameTime gameTime)
-    {
-        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
-            Exit();
-
-        base.Update(gameTime);
-    }
-
-    protected override void Draw(GameTime gameTime)
-    {
-        GraphicsDevice.Clear(Color.CornflowerBlue);
-
-        base.Draw(gameTime);
-    }
-}
-
-```
+[!code-csharp[](./files/game1.cs)]
 
 This class provides the following structure:
+
 1. **Graphics and Rendering**: The class declares two core graphics components; the [**GraphicsDeviceManager**](xref:Microsoft.Xna.Framework.GraphicsDeviceManager) for interacting with the Graphics Processing Unit (GPU) and the [**SpriteBatch**](xref:Microsoft.Xna.Framework.Graphics.SpriteBatch) for 2D rendering.
 2. **Initialization**: The constructor and [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method handle the game's setup sequence.
 3. **Content Loading**: The [**LoadContent**](xref:Microsoft.Xna.Framework.Game.LoadContent) method manages game asset loading during startup.
@@ -77,76 +30,43 @@ Figure 3-1 below shows the lifecycle of a MonoGame game including the [**Update*
 | **Figure 3-1: Lifecycle of a MonoGame game** |
 
 ## Graphics and Rendering
+
 The graphics pipeline in monogame starts with two components: the [**GraphicsDeviceManager**](xref:Microsoft.Xna.Framework.GraphicsDeviceManager) and [**SpriteBatch**](xref:Microsoft.Xna.Framework.Graphics.SpriteBatch).
 
-```cs
-private GraphicsDeviceManager _graphics;
-private SpriteBatch _spriteBatch;
-```
+[!code-csharp[](./files/Game1.cs?start=9&end=10)]
 
 The [**GraphicsDeviceManager**](xref:Microsoft.Xna.Framework.GraphicsDeviceManager) initializes and the connection to the graphics hardware.  It handles tasks such as setting the screen resolution, toggling between fullscreen and windowed mode, and managing the [**GraphicsDevice**](xref:Microsoft.Xna.Framework.Graphics.GraphicsDevice), which is the interface between your game and the Graphics Processing Unit (GPU) the game is running on. The [**SpriteBatch**](xref:Microsoft.Xna.Framework.Graphics.SpriteBatch) optimizes 2D rendering by batching similar draw calls together, improving draw performance when rendering multiple sprites.
 
 ## Initialization
 
 MonoGame's initialization process for your game follows a specific sequence.  The constructor runs first, which handles basic setup like creating the [**GraphicsDeviceManager**](xref:Microsoft.Xna.Framework.GraphicsDeviceManager), setting the content directory, and the visibility of the mouse.
 
-```cs
-public Game1()
-{
-    _graphics = new GraphicsDeviceManager(this);
-    Content.RootDirectory = "Content";
-    IsMouseVisible = true;
-}
-```
+[!code-csharp[](./files/Game1.cs?start=12&end=17)]
 
 After that, the [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method executes, providing a dedicated place for additional configuration and initializations.  
 
-```cs
-protected override void Initialize()
-{
-    base.Initialize();
-}
-```
+[!code-csharp[](./files/Game1.cs?start=19&end=22)]
 
 This separation allows you to perform setup tasks in a logical order; core systems in the constructor and game-specific initializations in the [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method.  The call to `base.Initialize()` should never be removed, as this is where the graphics device is initialized for the target platform.
 
 > [!TIP]
 > You may be wondering why there is an [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method instead of performing all initializations in the constructor.  The [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method is a `virtual` method that is overridden, and [it is advised to not call overridable methods from within a constructor](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca2214), as this can lead to unexpected states in object constructor when called.  Additionally, when the constructor is called, the base constructor will instantiate properties and services based on the target platform that may be needed first before performing initializations for the game itself.
 
 ## Content Loading
+
 The [**LoadContent**](xref:Microsoft.Xna.Framework.Game.LoadContent) method serves as the place for asset management. Here you can load textures, sound effects, music, and other game assets.  We will cover loading assets in the coming chapters as we discuss each asset type that can be loaded.  In a new project, the only task it performs is initializing a new instance of the [**SpriteBatch**](xref:Microsoft.Xna.Framework.Graphics.SpriteBatch).
 
-```cs
-protected override void LoadContent()
-{
-    _spriteBatch = new SpriteBatch(GraphicsDevice);
-}
-```
+[!code-csharp[](./files/Game1.cs?start=24&end=27)]
 
 This method is only call once during the startup of the game, but *when* it is called can be a little confusing at first.  In the [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method shown above, when the `base.Initialize` call is executed, the final task it performs is calling the [**LoadContent**](xref:Microsoft.Xna.Framework.Game.LoadContent) method.  This means any initializations you need to perform that have a dependency on assets being loaded should be done *after* the `base.Initialize` call and not *before* it.
 
 ## The Game Loop
 
 MonoGame implements a *game loop* by calling [**Update**](xref:Microsoft.Xna.Framework.Game.Update(Microsoft.Xna.Framework.GameTime)) and [**Draw**](xref:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime)) over and over until the game is told to exit. Recall at the end of [Chapter 02](../02_getting_started/index.md#creating-your-first-monogame-application) when you ran the project for the first time, I mentioned that there is a lot going on behind the scenes? This game loop is what I was referring to.
 
-MonoGame is executing the [**Update**](xref:Microsoft.Xna.Framework.Game.Update(Microsoft.Xna.Framework.GameTime)) method and then the [**Draw**](xref:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime)) method 60 times per second. 
-
-```cs
-protected override void Update(GameTime gameTime)
-{
-    if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
-        Exit();
+MonoGame is executing the [**Update**](xref:Microsoft.Xna.Framework.Game.Update(Microsoft.Xna.Framework.GameTime)) method and then the [**Draw**](xref:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime)) method 60 times per second.
 
-    base.Update(gameTime);
-}
-
-protected override void Draw(GameTime gameTime)
-{
-    GraphicsDevice.Clear(Color.CornflowerBlue);
-
-    base.Draw(gameTime);
-}
-```
+[!code-csharp[](./files/Game1.cs?start=29&end=42)]
 
 The [**Update**](xref:Microsoft.Xna.Framework.Game.Update(Microsoft.Xna.Framework.GameTime)) method at the moment is not doing much, only checking for input from a controller or keyboard to determine if the game should exit. However, the [**Draw**](xref:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime)) method is doing more than what it appears to at first glance.
 
@@ -172,44 +92,28 @@ Here is a review of what was accomplished in this chapter:
 
 In the next chapter, you will start working with sprites and learn how to load and render them.
 
-## See Also
-
-This chapter briefly touched on the *Game1.cs* file and the [**Game**](xref:Microsoft.Xna.Framework.Game) class. For an in-depth detailed discussion of all files created in a MonoGame project, including a full overview of the order of execution for a MonoGame game, see [Appendix 02: MonoGame Project Overview](#).
-
 ## Test Your Knowledge
 
 1. Can the `Game1` class be renamed or is it required to be called `Game1`
 
-    <details>
-    <summary>Question 1 Answer</summary>
-
-    > It is not a requirement that it be called `Game1`.  This is just the default name given to it by the templates when creating a new MonoGame game project.  
-
-    </details><br />
+    :::question-answer
+    It is not a requirement that it be called `Game1`.  This is just the default name given to it by the templates when creating a new MonoGame game project.  
+    :::
 
 2. What is the [**SpriteBatch**](xref:Microsoft.Xna.Framework.Graphics.SpriteBatch) used for?
 
-    <details>
-    <summary>Question 2 Answer</summary>
-
-    > The [**SpriteBatch**](xref:Microsoft.Xna.Framework.Graphics.SpriteBatch) provides an optimized method of rendering 2D graphics, like sprites, onto the screen
-    
-    </details><br />
+    :::question-answer
+    The [**SpriteBatch**](xref:Microsoft.Xna.Framework.Graphics.SpriteBatch) provides an optimized method of rendering 2D graphics, like sprites, onto the screen
+    :::
 
 3. When is the [**LoadContent**](xref:Microsoft.Xna.Framework.Game.LoadContent) method executed and why is it important to know this?
 
-    <details>
-    <summary>Question 3 Answer</summary>
-
-    > [**LoadContent**](xref:Microsoft.Xna.Framework.Game.LoadContent) is executed during the `base.Initialize()` method call within the [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method.  It is important to know this because anything being initialized that is dependent on content loaded should be done **after** the `base.Initialize()` call and not **before**. 
-    
-    </details><br />
+    :::question-answer
+    [**LoadContent**](xref:Microsoft.Xna.Framework.Game.LoadContent) is executed during the `base.Initialize()` method call within the [**Initialize**](xref:Microsoft.Xna.Framework.Game.Initialize) method.  It is important to know this because anything being initialized that is dependent on content loaded should be done **after** the `base.Initialize()` call and not **before**.
+    :::
 
 4. How does MonoGame provide a *delta time* value?
 
-    <details>
-    <summary>Question 4 Answer</summary>
-
-    > Through the [**GameTime**](xref:Microsoft.Xna.Framework.GameTime) parameter that is given to both the [**Update**](xref:Microsoft.Xna.Framework.Game.Update(Microsoft.Xna.Framework.GameTime)) and the [**Draw**](xref:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime)) methods.
-    
-    </details><br />
+    :::question-answer
+    Through the [**GameTime**](xref:Microsoft.Xna.Framework.GameTime) parameter that is given to both the [**Update**](xref:Microsoft.Xna.Framework.Game.Update(Microsoft.Xna.Framework.GameTime)) and the [**Draw**](xref:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime)) methods.
+    :::

articles/tutorials/building_2d_games/02_getting_started/index.md

@@ -0,0 +1,43 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace DungeonSlime;
+
+public class Game1 : Game
+{
+    private GraphicsDeviceManager _graphics;
+    private SpriteBatch _spriteBatch;
+
+    public Game1()
+    {
+        _graphics = new GraphicsDeviceManager(this);
+        Content.RootDirectory = "Content";
+        IsMouseVisible = true;
+    }
+
+    protected override void Initialize()
+    {
+        base.Initialize();
+    }
+
+    protected override void LoadContent()
+    {
+        _spriteBatch = new SpriteBatch(GraphicsDevice);
+    }
+
+    protected override void Update(GameTime gameTime)
+    {
+        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
+            Exit();
+
+        base.Update(gameTime);
+    }
+
+    protected override void Draw(GameTime gameTime)
+    {
+        GraphicsDevice.Clear(Color.CornflowerBlue);
+
+        base.Draw(gameTime);
+    }
+}