MonoGame

https://docs.monogame.net
Admin
MonoGame is an open-source, cross-platform game development framework that allows developers to...
Tokens:1,322,999
Snippets:11,721
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install Wine prerequisites

Source: https://docs.monogame.net/articles/getting_started/1_setting_up_your_os_for_development_ubuntu.html

Installs wget, curl, and p7zip-full required for the Wine setup script.

```bash
sudo apt install wget curl p7zip-full
```

--------------------------------

### Setup .NET SDK and install workload

Source: https://docs.monogame.net/articles/getting_started/content_pipeline/content_builder/advanced.html

Pins the .NET SDK version via a generated `global.json`, sets up the SDK, and installs the required workload when the matrix entry specifies one. The `DotnetVersion` environment variable is set to 10.0.401 and the configuration defaults to 'Release'.

```yaml
env:
  DotnetVersion: 10.0.401
  Configuration: ${{ inputs.configuration || 'Release' }}

steps:
  - uses: actions/checkout@v7

  - name: Generate global.json
    shell: bash
    run: |
      echo '{ "sdk": { "version": "${{ env.DotnetVersion }}" } }' > global.json

  - name: Setup .NET SDK
    uses: actions/setup-dotnet@v6
    with:
      dotnet-version: ${{ env.DotnetVersion }}
      global-json-file: ./global.json

  - name: Install workload
    if: ${{ matrix.workload != '' }}
    run: dotnet workload install ${{ matrix.workload }}
```

--------------------------------

### Start()

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Audio.Microphone.html

Starts microphone capture.

```APIDOC
## Start()

### Description
Starts microphone capture.

### Method
Start

### Signature
public void Start()

```

--------------------------------

### Start recording with Microphone.Start

Source: https://docs.monogame.net/articles/getting_to_know/howto/audio/HowTo_Record_Microphone.html

Starts recording audio from the microphone. Checks if the microphone exists and catches NoMicrophoneConnectedException if it is disconnected.

```csharp
private void StartRecording()
{
    // Can't start a microphone that doesn't exist.
    if (activeMicrophone == null) { return; }

    try
    {
        activeMicrophone.Start();
    }
    catch (NoMicrophoneConnectedException)
    {
        // Microphone was disconnected - let the user know.
    }
}
```

--------------------------------

### Install Android, iOS, and MAUI workloads

Source: https://docs.monogame.net/articles/getting_started/1_setting_up_your_os_for_development_macos.html

Run this command to install all three workloads (Android, iOS, and MAUI) in one go. Useful when targeting multiple mobile platforms.

```bash
dotnet workload install android ios maui
```

--------------------------------

### Install MGFXC as a .NET tool

Source: https://docs.monogame.net/articles/getting_started/tools/mgfxc.html

Run this command in a terminal to install MGFXC globally. Requires the .NET SDK to be installed.

```bash
dotnet tool install -g dotnet-mgfxc
```

--------------------------------

### Game1.cs with Sound Effects and Music Setup

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/14_soundeffects_and_music/index.html

Updated Game1.cs for the Dungeon Slime game, adding SoundEffect fields for bounce and collect sounds, and initializing room bounds and slime position. This is the starting point for integrating audio into the game.

```csharp
using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using MonoGameLibrary;
using MonoGameLibrary.Graphics;
using MonoGameLibrary.Input;

namespace DungeonSlime;

public class Game1 : Core
{
    // Defines the slime animated sprite.
    private AnimatedSprite _slime;

    // Defines the bat animated sprite.
    private AnimatedSprite _bat;

    // Tracks the position of the slime.
    private Vector2 _slimePosition;

    // Speed multiplier when moving.
    private const float MOVEMENT_SPEED = 5.0f;

    // Tracks the position of the bat.
    private Vector2 _batPosition;

    // Tracks the velocity of the bat.
    private Vector2 _batVelocity;

    // Defines the tilemap to draw.
    private Tilemap _tilemap;

    // Defines the bounds of the room that the slime and bat are contained within.
    private Rectangle _roomBounds;

    // The sound effect to play when the bat bounces off the edge of the screen.
    private SoundEffect _bounceSoundEffect;

    // The sound effect to play when the slime eats a bat.
    private SoundEffect _collectSoundEffect;

    public Game1() : base("Dungeon Slime", 1280, 720, false)
    {

    }

    protected override void Initialize()
    {
        base.Initialize();

        Rectangle screenBounds = GraphicsDevice.PresentationParameters.Bounds;

        _roomBounds = new Rectangle(
            (int)_tilemap.TileWidth,
            (int)_tilemap.TileHeight,
            screenBounds.Width - (int)_tilemap.TileWidth * 2,
            screenBounds.Height - (int)_tilemap.TileHeight * 2
        );

        // Initial slime position will be the center tile of the tile map.
        int centerRow = _tilemap.Rows / 2;
        int centerColumn = _tilemap.Columns / 2;
        _slimePosition = new Vector2(centerColumn * _tilemap.TileWidth, centerRow * _tilemap.TileHeight);
    }
}
```

--------------------------------

### Install .NET 9 SDK on Ubuntu

Source: https://docs.monogame.net/articles/getting_started/1_setting_up_your_os_for_development_ubuntu.html

Run this command in a terminal to install the latest .NET 9 SDK. Requires Ubuntu 20.04 or later.

```bash
sudo apt-get update && sudo apt-get install -y dotnet-sdk-9.0
```

--------------------------------

### MonoGame microphone recording and playback example

Source: https://docs.monogame.net/articles/getting_to_know/howto/audio/HowTo_Record_Microphone.html

Complete MonoGame Game class that records from the active microphone and plays back audio using DynamicSoundEffectInstance. Press Space to start recording, P to stop. Includes extension methods for microphone connection checks and selection, and an InitializeMicrophone method that runs in Update to monitor connection status.

```csharp
using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace MonoGameMicrophoneExample;

public class Game1 : Game
{
    private GraphicsDeviceManager graphics;
    private SpriteBatch spriteBatch;
    SpriteFont font;
    // The most recent microphone samples.
    byte[] micSamples;
    // DynamicSoundEffectInstance is used to playback the captured audio after processing it for echo.
    DynamicSoundEffectInstance dynamicSound;
    // Microphone used for recording.
    Microphone activeMicrophone;
    // Used to communicate the microphone status to the user.
    string microphoneStatus = string.Empty;
    const string instructions = @"Press 'Space' to start and 'P' to stop recording";

#region MonoGame Boilerplate
    public Game1()
    {
        graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
        IsMouseVisible = true;
    }

    protected override void Initialize()
    {
        // TODO: Add your initialization logic here

        base.Initialize();
    }

    protected override void LoadContent()
    {
        spriteBatch = new SpriteBatch(GraphicsDevice);

        // Make sure to create a SpriteFont in the Content project and set its build action to "Content".
        font = Content.Load<SpriteFont>("File");
    }


    protected override void Update(GameTime gameTime)
    {
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
            Exit();

        // Constantly check for a good microphone to start recording.
        InitializeMicrophone();

        // Check and update microphone status.
        UpdateMicrophoneStatus();

        if (IsKeyPressed(Keys.Space))
        {
            StartRecording();
        }
        if (IsKeyPressed(Keys.P))
        {
            StopRecording();
        }

        base.Update(gameTime);
    }


    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);

        // TODO: Add your drawing code here
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
        spriteBatch.DrawString(font, instructions, new Vector2(10f, 20f), Color.White);
        spriteBatch.DrawString(font, microphoneStatus, new Vector2(10f, 50f), Color.White);
        spriteBatch.End();
        base.Draw(gameTime);
    }    
#endregion MonoGame Boilerplate

#region Input Handling
    private bool IsKeyPressed(Keys key)
    {
        return Keyboard.GetState().IsKeyDown(key);
    }

    private void StartRecording()
    {
        // Can't start a microphone that doesn't exist.
        if (activeMicrophone == null) { return; }

        try
        {
            activeMicrophone.Start();
        }
        catch (NoMicrophoneConnectedException)
        {
            UpdateMicrophoneStatus();
        }
    }

    private void StopRecording()
    {
        // Can't stop a microphone that doesn't exist.
        if (activeMicrophone == null) { return; }

        try
        {
            // Stop the microphone
            activeMicrophone.Stop();
        }
        catch (NoMicrophoneConnectedException)
        {
            UpdateMicrophoneStatus();
        }
    }
#endregion Input Handling

#region Microphone Handling
    /// <summary>
    /// Keep track of the microphone status to communicate to the user.
    /// </summary>
    private void UpdateMicrophoneStatus()
    {
        // We don't have any microphones connected to the system.
        if (activeMicrophone == null)
        {
            microphoneStatus = "Waiting for microphone connection...";
        }
        else
        {
            try
            {
                // Update the status - if the microphone gets disconnected this will throw
                microphoneStatus = string.Format("{0} is {1}", activeMicrophone.Name, activeMicrophone.State);
            }
            catch (NoMicrophoneConnectedException)
            {
                // Microphone got disconnected - Let's ask the user to reconnect it.
                microphoneStatus = string.Format("Please reconnect {0}", activeMicrophone.Name);
            }
        }
    }

```

--------------------------------

### Example executable path

Source: https://docs.monogame.net/articles/tutorials/advanced/2d_shaders/04_debug_ui/index.html

An example path to the built executable for RenderDoc's Executable Path field.

```text
C:\proj\MonoGame.Samples\Tutorials\2dShaders\src\04-Debug-UI\DungeonSlime\bin\Debug\net9.0-windows\DungeonSlime.exe
```

--------------------------------

### Example MGCB response file

Source: https://docs.monogame.net/articles/getting_started/tools/mgcb.html

A sample response file demonstrating directory options, rebuild, and building textures with specific importer and processor settings. Comment lines start with #.

```plaintext
# Directories
/outputDir:bin/foo
/intermediateDir:obj/foo

/rebuild

# Build a texture
/importer:TextureImporter
/processor:TextureProcessor
/processorParam:ColorKeyEnabled=false
/build:Textures\wood.png
/build:Textures\metal.png
/build:Textures\plastic.png
```

--------------------------------

### Install .NET SDK on Linux via apt

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/02_getting_started/index.html

Use this command in a Terminal to install the .NET SDK on Linux. It updates the package list and installs the dotnet-sdk-8.0 package. Note that the recommended minimum version is .NET 9, with .NET 10 also supported.

```bash
sudo apt-get update && sudo apt-get install -y dotnet-sdk-8.0
```

--------------------------------

### Run mgfxc_wine_setup.sh script

Source: https://docs.monogame.net/articles/getting_started/1_setting_up_your_os_for_development_macos.html

Downloads and executes MonoGame's Wine setup script. Creates a .winemonogame directory in your home directory; delete it to undo the setup.

```bash
wget -qO- https://monogame.net/downloads/net9_mgfxc_wine_setup.sh | bash
```

--------------------------------

### Install iOS and Android workloads with dotnet workload install

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/02_getting_started/index.html

Run these commands in a Command Prompt or Terminal to install the mobile workloads for iOS and Android. Required only if you intend to target mobile devices.

```bash
dotnet workload install ios
dotnet workload install android
```

--------------------------------

### Run dotnet watch

Source: https://docs.monogame.net/articles/tutorials/advanced/2d_shaders/02_hot_reload/index.html

Starts the game with dotnet watch, which watches for changes and reloads. The game should start normally.

```bash
dotnet watch
```

--------------------------------

### Call StartContentWatcherTask from Program.cs

Source: https://docs.monogame.net/articles/tutorials/advanced/2d_shaders/02_hot_reload/index.html

Call the new function from DungeonSlime's Program.cs before starting the game. This ensures the watcher starts automatically when the game runs.

```csharp
MonoGameLibrary.Content.ContentManagerExtensions.StartContentWatcherTask();
using var game = new DungeonSlime.Game1();
game.Run();
```

--------------------------------

### Install MonoGame dotnet tools for preview

Source: https://docs.monogame.net/articles/getting_to_know/howto/HowTo_Install_Preview_Release.html

These commands install the MonoGame Content Builder and Editor tools with the specified preview version. Run them in the project folder to update the dotnet-tools.json configuration.

```bash
dotnet tool install dotnet-mgcb --version 3.8.4-preview.1
dotnet tool install dotnet-mgcb-editor --version 3.8.4-preview.1
dotnet tool install dotnet-mgcb-editor-linux --version 3.8.4-preview.1
dotnet tool install dotnet-mgcb-editor-windows --version 3.8.4-preview.1
dotnet tool install dotnet-mgcb-editor-mac --version 3.8.4-preview.1
```

--------------------------------

### Install MonoGame preview templates

Source: https://docs.monogame.net/articles/getting_to_know/howto/HowTo_Install_Preview_Release.html

This command installs the MonoGame project templates with the specified preview version. It is optional and only needed if you want to generate new projects using the latest templates.

```bash
dotnet new install MonoGame.Templates.CSharp::3.8.4-preview.1
```

--------------------------------

### FogStart

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Graphics.EnvironmentMapEffect.html

Gets or sets the fog start distance.

```APIDOC
## FogStart

### Description
Gets or sets the fog start distance.

### Property Signature
```csharp
public float FogStart { get; set; }
```

### Property Value
[float](https://learn.microsoft.com/dotnet/api/system.single)
```

--------------------------------

### Show method example

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Input.KeyboardInput.html

Displays a keyboard input dialog and awaits the entered text.

```csharp
var name = await KeyboardInput.Show("Name", "What's your name?", "Player");
```

--------------------------------

### AlphaTestEffect.FogStart

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Graphics.AlphaTestEffect.html

Gets or sets the fog start distance.

```APIDOC
## AlphaTestEffect.FogStart

### Description
Gets or sets the fog start distance.

### Property Value
- **Type**: float

### Syntax
```csharp
public float FogStart { get; set; }
```
```

--------------------------------

### GameScene Initialize method

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/23_completing_the_game/index.html

Sets up the game scene: disables exit on escape, calculates room bounds, subscribes to slime collision, clears UI, initializes UI, and starts a new game.

```csharp
public override void Initialize()
{
    // LoadContent is called during base.Initialize().
    base.Initialize();

    // During the game scene, we want to disable exit on escape. Instead,
    // the escape key will be used to return back to the title screen.
    Core.ExitOnEscape = false;

    // Create the room bounds by getting the bounds of the screen then
    // using the Inflate method to "Deflate" the bounds by the width and
    // height of a tile so that the bounds only covers the inside room of
    // the dungeon tilemap.
    _roomBounds = Core.GraphicsDevice.PresentationParameters.Bounds;
    _roomBounds.Inflate(-_tilemap.TileWidth, -_tilemap.TileHeight);

    // Subscribe to the slime's BodyCollision event so that a game over
    // can be triggered when this event is raised.
    _slime.BodyCollision += OnSlimeBodyCollision;

    // Create any UI elements from the root element created in previous
    // scenes.
    GumService.Default.Root.Children.Clear();

    // Initialize the user interface for the game scene.
    InitializeUI();

    // Initialize a new game to be played.
    InitializeNewGame();
}
```

--------------------------------

### GamePadButtons.BigButton

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Input.GamePadButtons.html

Gets a value indicating if the guide button is pressed.

```APIDOC
## Property: BigButton

### Description
Gets a value indicating if the guide button is pressed.

### Signature
public ButtonState BigButton { get; }

### Property Value
- **ButtonState** - Pressed if the guide button is pressed; otherwise, Released.

```

--------------------------------

### Create a simple ImGui window with text

Source: https://docs.monogame.net/articles/tutorials/advanced/2d_shaders/04_debug_ui/index.html

Creates a draggable ImGui window that displays 'Hello world!' between the BeforeLayout and AfterLayout calls.

```csharp
protected override void Draw(GameTime gameTime)
{
    // ...

    // Draw debug UI
    Core.ImGuiRenderer.BeforeLayout(gameTime);  
    
    ImGui.Begin("Demo Window");  
    ImGui.Text("Hello world!");  
    ImGui.End();

    // Finish drawing the debug UI here
    Core.ImGuiRenderer.AfterLayout();

    base.Draw(gameTime);
}
```

--------------------------------

### GamePadCapabilities.HasStartButton

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Input.GamePadCapabilities.html

Gets a value indicating whether the controller has the button Start.

```APIDOC
## Property: HasStartButton

### Description
Gets a value indicating whether the controller has the button Start.

### Signature
```csharp
public readonly bool HasStartButton { get; }
```

### Property Value
- **Type**: [bool](https://learn.microsoft.com/dotnet/api/system.boolean)
- **Description**: `true` if it has the button Start; otherwise, `false`.
```

--------------------------------

### LoopStart Property

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Content.Pipeline.Audio.AudioContent.html

Gets the current loop start location in samples.

```APIDOC
## LoopStart Property

### Description
Gets the current loop start location in samples.

### Property Signature
`public int LoopStart { get; }`

### Property Value
- **LoopStart** (int) - The current loop start location in samples.

### Remarks
This changes from the source loop start to the output loop start after conversion.
```

--------------------------------

### MouseState.ScrollWheelValue

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Input.MouseState.html

Gets the cumulative scroll wheel value since the game start.

```APIDOC
## Property: ScrollWheelValue

### Description
Returns cumulative scroll wheel value since the game start.

### Signature
```csharp
public int ScrollWheelValue { get; }
```

### Property Value
- **Type**: int

### Remarks
The current mouse wheel value is incremented when the wheel is scrolled up and decremented on scroll down. This is a real value showing the current position since the game started, to capture the delta, store the value and compare to the previous frame.
```

--------------------------------

### StartIndex Property

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Graphics.ModelMeshPart.html

Gets the location in the index array at which to start reading vertices.

```APIDOC
## StartIndex Property

### Description
Gets the location in the index array at which to start reading vertices.

### Syntax
```csharp
public int StartIndex { get; set; }
```

### Property Value
Type: int
```

--------------------------------

### Game.LaunchParameters

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Game.html

The start up parameters for this Game.

```APIDOC
## Game.LaunchParameters

### Description
The start up parameters for this Game.

### Property
```csharp
public LaunchParameters LaunchParameters { get; }
```

### Property Value
[LaunchParameters](https://docs.monogame.net/api/Microsoft.Xna.Framework.LaunchParameters.html)

```

--------------------------------

### LoadContent method with game material setup

Source: https://docs.monogame.net/articles/tutorials/advanced/2d_shaders/07_sprite_vertex_effect/index.html

Loads the color map, creates the game material, sets parameters for ColorMap, MatrixTransform, and ScreenSize, and initializes the SpriteCamera3d.

```csharp
     public override void LoadContent()
     {
         // ...
     
         // Load the colorSwap map
         _colorMap = Content.Load<Texture2D>("images/color-map-dark-purple");
         _slimeColorMap = new RedColorMap();
         _slimeColorMap.SetColorsByExistingColorMap(_colorMap);
         _slimeColorMap.SetColorsByRedValue(new Dictionary<int, Color>
         {
             // main color
             [32] = Color.LightSteelBlue,
         }, false);    
     
         // Load the game material
         _gameMaterial = Content.WatchMaterial("effects/gameEffect");
         _gameMaterial.IsDebugVisible = true;
         _gameMaterial.SetParameter("ColorMap", _colorMap);
         _camera = new SpriteCamera3d();
         _gameMaterial.SetParameter("MatrixTransform", _camera.CalculateMatrixTransform());
         _gameMaterial.SetParameter("ScreenSize", new Vector2(Core.GraphicsDevice.Viewport.Width, Core.GraphicsDevice.Viewport.Height));
     }

```

--------------------------------

### ContentBuilderParams.Servers Property

Source: https://docs.monogame.net/api/MonoGame.Framework.Content.Pipeline.Builder.ContentBuilderParams.html

Gets or sets a list of servers to start up when the Mode is set to Server.

```APIDOC
## Property: Servers

### Description
A list of servers to start up when the Mode is set to Server.

### Signature
```csharp
public List<ContentServer> Servers { get; set; }
```

### Property Value
- **Type**: List<ContentServer>
- **Description**: A collection of ContentServer classes found by scanning all referenced assemblies.
```

--------------------------------

### MouseState.HorizontalScrollWheelValue

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Input.MouseState.html

Gets the cumulative horizontal scroll wheel value since the game start.

```APIDOC
## Property: HorizontalScrollWheelValue

### Description
Returns the cumulative horizontal scroll wheel value since the game start.

### Signature
```csharp
public int HorizontalScrollWheelValue { get; }
```

### Property Value
- **Type**: int

### Remarks
The current mouse wheel value is incremented when the wheel is scrolled up and decremented on scroll down. This is a real value showing the current position since the game started, to capture the delta, store the value and compare to the previous frame.
```

--------------------------------

### AudioEngine(string settingsFile)

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Audio.AudioEngine.html

Initializes a new instance of the AudioEngine class by reading the specified XACT settings file.

```APIDOC
## AudioEngine(string settingsFile)

### Description
Initializes a new instance of the AudioEngine class by reading out the specified XACT `settingsFile`.

### Method
Constructor

### Signature
public AudioEngine(string settingsFile)

### Parameters
- **settingsFile** (string) - Required - Path to a XACT settings file.

### Exceptions
- **ArgumentException** - Thrown if `settingsFile` is null or empty (IsNullOrEmpty).

```

--------------------------------

### Time Property

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Content.Pipeline.Graphics.AnimationKeyframe.html

Gets the time offset from the start of the animation to the position described by this keyframe.

```APIDOC
## Time Property

### Description
Gets the time offset from the start of the animation to the position described by this keyframe.

### Property Signature
`public TimeSpan Time { get; }`

### Property Value
- **TimeSpan** - The time offset from the start of the animation.

```

--------------------------------

### InitializeMicrophone method

Source: https://docs.monogame.net/articles/getting_to_know/howto/audio/HowTo_Record_Microphone.html

Finds a connected microphone and sets up the capture buffer and DynamicSoundEffectInstance for playback. Sets BufferDuration to 100ms for low latency, subscribes to BufferReady, and allocates the sample buffer. Handles NoMicrophoneConnectedException by unsubscribing and resetting the active microphone.

```csharp
    /// <summary>
    /// Finds a good microphone to use and sets up everything to start recording and playback.
    /// Once a microphone is selected the game uses it throughout its lifetime.
    /// If it gets disconnected it will tell the user to reconnect it.
    /// </summary>
    private void InitializeMicrophone()
    {
        // We already have a microphone, skip out early.
        if (activeMicrophone != null) { return; }

        try
        {
            // Find the first microphone that's ready to rock.
            activeMicrophone = PickFirstConnectedMicrophone();
            if (activeMicrophone != null)
            {
                // Set the capture buffer size for kow latency.
                // Microphone will call the game back when it has captured at least that much audio data.
                activeMicrophone.BufferDuration = TimeSpan.FromMilliseconds(100);
                // Subscribe to the event that's raised when the capture buffer is filled.
                activeMicrophone.BufferReady += BufferReady;
                // We will put the mic samples in this buffer.  We only want to allocate it once.
                micSamples = new byte[activeMicrophone.GetSampleSizeInBytes(activeMicrophone.BufferDuration)];

                 // Create a DynamicSoundEffectInstance in the right format to playback the captured audio.
                dynamicSound = new DynamicSoundEffectInstance(activeMicrophone.SampleRate, AudioChannels.Mono);
                dynamicSound.Play();
            }
        }
        catch (NoMicrophoneConnectedException)
        {
            // Uh oh, the microphone was disconnected in the middle of initialization.
            // Let's clean up everything so we can look for another microphone again on the next update.
            activeMicrophone.BufferReady -= BufferReady;
            activeMicrophone = null;
        }
    }
```

--------------------------------

### Model.Tag

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Graphics.Model.html

Gets or sets a custom attached object. Skinning data is an example of an attached object for a model.

```APIDOC
## Model.Tag

### Description
Gets or sets a custom attached object. Skinning data is an example of an attached object for a model.

### Property
```csharp
public object Tag { get; set; }
```

### Property Value
[object](https://learn.microsoft.com/dotnet/api/system.object)
```

--------------------------------

### Initialize world, view, and projection matrices

Source: https://docs.monogame.net/articles/getting_to_know/howto/graphics/HowTo_Create_a_BasicEffect.html

Sets up the world, view, and projection matrices in the Initialize method. Uses Matrix.Identity for the world, a look-at view from (0,0,50) to the origin, and a perspective projection with a 45-degree field of view.

```csharp
protected override void Initialize()
{
    // Setup the matrices to look forward
    worldMatrix = Matrix.Identity;
    viewMatrix = Matrix.CreateLookAt(new Vector3(0, 0, 50), Vector3.Zero, Vector3.Up);

    projectionMatrix = Matrix.CreatePerspectiveFieldOfView(
        MathHelper.PiOver4,
        GraphicsDevice.Viewport.AspectRatio,
        1.0f, 300.0f);

    base.Initialize();
}
```

--------------------------------

### Linux WINE setup commands

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/02_getting_started/index.html

Run these commands in a new Terminal window on Linux to install WINE and configure MonoGame effect compilation. This creates a .winemonogame folder in your home directory; delete it to undo the setup.

```bash
sudo apt-get update && sudo apt-get install -y curl p7zip-full wine64
wget -qO- https://monogame.net/downloads/net8_mgfxc_wine_setup.sh | bash  
```

--------------------------------

### macOS WINE setup commands

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/02_getting_started/index.html

Run these commands in a new Terminal window on macOS to install WINE and configure MonoGame effect compilation. This creates a .winemonogame folder in your home directory; delete it to undo the setup.

```bash
brew install p7zip
brew install --cask xquartz
curl -L -o wine.tar.xz "https://github.com/Gcenx/macOS_Wine_builds/releases/download/11.0_1/wine-stable-11.0_1-osx64.tar.xz"
tar -xJf wine.tar.xz
sudo mv "Wine Stable.app" /Applications/
sudo xattr -dr com.apple.quarantine "/Applications/Wine Stable.app"
echo "export PATH="/Applications/Wine Stable.app/Contents/Resources/wine/bin:$PATH"" > ~/.zprofile
source ~/.zprofile
wine --version
wget -qO- https://monogame.net/downloads/net8_mgfxc_wine_setup.sh | bash
```

--------------------------------

### GameTime.TotalGameTime

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.GameTime.html

Gets or sets the total time elapsed since the start of the game. This property is of type TimeSpan and represents the cumulative game time.

```APIDOC
## Property: TotalGameTime

### Description
Time since the start of the Game.

### Property Signature
```csharp
public TimeSpan TotalGameTime { get; set; }
```

### Property Value
- **Type**: TimeSpan
- **Description**: The total time elapsed since the game started.
```

--------------------------------

### Create and Dock a Panel to Fill

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/20_implementing_ui_with_gum/index.html

Creates a Panel, adds it to the root, and docks it to fill the entire root space using Gum.Wireframe.Dock.Fill.

```csharp
// Creating a panel and adding it to the root
Panel mainMenuPanel = new Panel();
mainMenuPanel.AddToRoot();

// Docking the panel to fill the entire root space
mainMenuPanel.Dock(Gum.Wireframe.Dock.Fill);
```

--------------------------------

### Installation instructions template for MonoGame project

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/26_publish_to_itch/index.html

Template for download and installation instructions covering Windows, Linux, and macOS. Includes steps to extract archives and run executables, with commands to change file permissions using chmod +x when needed.

```markdown
Once the download has completed:

For Windows:
    1. Extract the contents of the ZIP archive.
    2. Run the "[YourGameName].exe" executable from the extracted folder.

For Linux:
    1. Extract the contents of the tar.gz archive.
    2. Run the "[YourGameName]" executable from the extracted folder.
    3. If the game does not open or states it is not executable, you may need to change the file permissions.  To do this:
        1. Open a terminal in the extracted directory.
        2. Make the game executable with the command: chmod +x ./[YourGameName]

For macOS:
    1. Extract the contents of the tar.gz archive.
    2. Run the [YourGameName].app executable from the extracted folder.
    3. If the game does not open or states it is not an executable, you may need to change the file permissions.  To do this:
        1. Open a terminal in the extracted directory.
        2. Make the game executable with the command: chmod +x ./[YourGameName].app/Contents/MacOS/[YourGameName]
```

--------------------------------

### Build the project

Source: https://docs.monogame.net/articles/tutorials/advanced/2d_shaders/04_debug_ui/index.html

Build the DungeonSlime project manually using the dotnet build command.

```bash
dotnet build
```

--------------------------------

### Handle Horizontal and Vertical Drag Gestures

Source: https://docs.monogame.net/articles/tutorials/building_2d_games/10_handling_input/index.html

Process queued gestures using a while loop with TouchPanel.IsGestureAvailable. This example checks for HorizontalDrag and VerticalDrag and uses the Delta property to get movement amounts.

```csharp
while(TouchPanel.IsGestureAvailable)
{
    GestureSample gesture = TouchPanel.ReadGesture();

    if(gesture.GestureType == GestureType.HorizontalDrag)
    {
        // A horizontal drag from left-to-right or right-to-left occurred.
        // You can use the Delta property to determine how much movement
        // occurred during the swipe.
        float xDragAmount = gesture.Delta.X;

        // Now do something with that information.
    }

    if(gesture.GestureType == GestureType.VerticalDrag)
    {
        // A vertical drag from top-to-bottom or bottom-to-top occurred.
        // You can use the Delta property to determine how much movement
        // occurred during the swipe.
        float yDragAmount = gesture.Delta.Y;

        // Now do something with that information.
    }
}
```

--------------------------------

### Initialize()

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Game.html

Override this to initialize the game and load any needed non-graphical resources. Initializes attached GameComponent instances and calls LoadContent().

```APIDOC
## Initialize()

### Description
Override this to initialize the game and load any needed non-graphical resources. Initializes attached GameComponent instances and calls LoadContent().

### Method
Initialize

### Signature
protected virtual void Initialize()

### Remarks
This method is called once during game startup. Override to perform custom initialization logic.
```

--------------------------------

### Initialize camera and transformations for drawing primitives

Source: https://docs.monogame.net/articles/getting_to_know/howto/graphics/HowTo_Draw_3D_Primitives.html

Sets up the world, view, and projection matrices, and calculates a translation matrix to center the primitives on the screen. Uses orthographic projection with the upper-left origin and screen dimensions.

```csharp
// Matrix to translate the drawn primitives to the center of the screen.
private Matrix translationMatrix;

// Number of vertex points to draw the primitive with.
private int points = 8;

// The length of the primitive lines to draw.
private int lineLength = 100;

protected override void Initialize()
{
    worldMatrix = Matrix.Identity;

    viewMatrix = Matrix.CreateLookAt(
        new Vector3(0.0f, 0.0f, 1.0f),
        Vector3.Zero,
        Vector3.Up
        );

    projectionMatrix = Matrix.CreateOrthographicOffCenter(
        0,
        (float)GraphicsDevice.Viewport.Width,
        (float)GraphicsDevice.Viewport.Height,
        0,
        1.0f, 1000.0f);

    // Calculate the center of the visible screen using the ViewPort.
    Vector2 screenCenter = new Vector2(GraphicsDevice.Viewport.Width / 2, GraphicsDevice.Viewport.Height / 2);
    // Calculate the center of the primitives to be drawn.
    var primitiveCenter = new Vector2((points / 2 - 1) * lineLength / 2, lineLength / 2);
    // Create a translation matrix to position the drawn primitives in the center of the screen and the center of the primitives.
    translationMatrix = Matrix.CreateTranslation(screenCenter.X - primitiveCenter.X, screenCenter.Y - primitiveCenter.Y, 0);

   base.Initialize();
}
```

--------------------------------

### MessageBox.Show example

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Input.MessageBox.html

Shows how to display a message box and await the result. Throws an exception if the message box is already visible.

```csharp
var color = await MessageBox.Show("Color", "What's your favorite color?", new[] { "Red", "Green", "Blue" });
```

--------------------------------

### Install MGCB as a .NET tool

Source: https://docs.monogame.net/articles/getting_started/tools/mgcb.html

Install the MonoGame Content Builder globally using the .NET CLI. Requires the .NET SDK. After installation, the 'mgcb' command is available.

```bash
dotnet tool install -g dotnet-mgcb
```

--------------------------------

### Get<T>(string)

Source: https://docs.monogame.net/api/Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannelCollection.html

Gets the vertex channel with the specified name and content type.

```APIDOC
## Get<T>(string)

### Description
Gets the vertex channel with the specified name and content type.

### Method
Get<T>(string name)

### Parameters
#### Parameters
- **name** (string) - Required - Name of a vertex channel.

### Type Parameters
- **T** - Type of the vertex channel.

### Returns
VertexChannel<T> - The vertex channel.
```
Tokens:
Raw