C# Clamp object to window?

Question

In Monogame (c#), I can't figure out how to keep an object (in this case a burger) to stay inside the game window's borders so it doesn't go off the game window when the cursor does. Or in other words, "clamp" an object to the game window.

    public class Burger
{
    #region Fields

    // graphic and drawing info
    Texture2D sprite;
    Rectangle drawRectangle;

    // burger stats
    int health = 100;

    // shooting support
    bool canShoot = true;
    int elapsedCooldownMilliseconds = 0;

    // sound effect
    SoundEffect shootSound;

    #endregion

    #region Constructors

    /// <summary>
    ///  Constructs a burger
    /// </summary>
    /// <param name="contentManager">the content manager for loading content</param>
    /// <param name="spriteName">the sprite name</param>
    /// <param name="x">the x location of the center of the burger</param>
    /// <param name="y">the y location of the center of the burger</param>
    /// <param name="shootSound">the sound the burger plays when shooting</param>
    public Burger(ContentManager contentManager, string spriteName, int x, int y,
        SoundEffect shootSound)
    {
        LoadContent(contentManager, spriteName, x, y);
        this.shootSound = shootSound;
    }

    #endregion

    #region Properties

    /// <summary>
    /// Gets the collision rectangle for the burger
    /// </summary>
    public Rectangle CollisionRectangle
    {
        get { return drawRectangle; }
    }

    #endregion

    #region Public methods

    /// <summary>
    /// Updates the burger's location based on mouse. Also fires 
    /// french fries as appropriate
    /// </summary>
    /// <param name="gameTime">game time</param>
    /// <param name="mouse">the current state of the mouse</param>
    public void Update(GameTime gameTime, MouseState mouse)
    {
        // burger should only respond to input if it still has health

        // move burger using mouse
        if (health > 0)
        {
            drawRectangle.X = mouse.X;
            drawRectangle.Y = mouse.Y;

        }

        // clamp burger in window

        [THIS IS WHERE THE CODE SHOULD GO]

        // update shooting allowed
        // timer concept (for animations) introduced in Chapter 7

        // shoot if appropriate

    }

    /// <summary>
    /// Draws the burger
    /// </summary>
    /// <param name="spriteBatch">the sprite batch to use</param>
    public void Draw(SpriteBatch spriteBatch)
    {
        spriteBatch.Draw(sprite, drawRectangle, Color.CornflowerBlue);
    }

    #endregion

    #region Private methods

    /// <summary>
    /// Loads the content for the burger
    /// </summary>
    /// <param name="contentManager">the content manager to use</param>
    /// <param name="spriteName">the name of the sprite for the burger</param>
    /// <param name="x">the x location of the center of the burger</param>
    /// <param name="y">the y location of the center of the burger</param>
    private void LoadContent(ContentManager contentManager, string spriteName,
        int x, int y)
    {
        // load content and set remainder of draw rectangle
        sprite = contentManager.Load<Texture2D>(spriteName);
        drawRectangle = new Rectangle(x - sprite.Width / 2,
            y - sprite.Height / 2, sprite.Width,
            sprite.Height);
    }

    #endregion
}

Any ideas how I could go about this? I've tried using mouse.Getstate and trying to lock the mouse cursor to the window but that didn't seem to work.

Answer 1

The issue seems to be that you are controlling the coordinates from inside your burger class (well sort of a problem) and you don't seem to have any references to the window borders.

The way I see it is you have 2 options:

Option 1. It's not bad, but in larger projects it might backfire further stages of the project:

public void Update(GameTime gameTime, MouseState mouse)
{
    if (health > 0)
    {
        //Simple version
        //if mouse is within borders, continue with position update.
        if(mouse.X > 0 && mouse.X < windowWidth && mouse.Y > 0 && mouse.Y < windowHeight){
           drawRectangle.X = mouse.X;
           drawRectangle.Y = mouse.Y;
        }else{
           //stuff to do if it it's not updating   
        }

        //a little different (better) version that should trace walls
        if(mouse.X < 0){
           drawRectangle.X = 0;
        }else if(mouse.X + drawRectangle.width > windowWidth){ //if I made no mistakes it should subtract the size of the picture and trace the inside border if mouse is outside
           drawRectangle.X = windowWidth - drawRectangle.width;
        }else{
           drawRectangle.X = mouse.X
        }
        if(mouse.Y < 0){
           drawRectangle.Y = 0;
        }else if(mouse.Y + drawRectangle.height > windowHeight ){
           drawRectangle.Y = windowHeight - drawRectangle.height;
        }else{
           drawRectangle.Y = mouse.Y
        }
    }

}

Option 2 restrict update calls in main update function when mouse is outside the borders:

class YourApp{
   ....
   public void Update(GameTime gameTime, MouseState mouse)
    {
         if([mouse is within the window]){
            burger.Update(...);
            //+most of your updates here
         }else{
            //pause game or just display a warning that mouse is outside of the window
         }
    }
    ...
}

Answer 2

When you are assigning values to drawRectangle's X and Y properties, you should be performing Min and Max functions to make sure its position is inside the window.

drawRectangle.X = Math.Min(Math.Max(mouse.X, 0), GraphicsDevice.Viewport.Width);
drawRectangle.Y = Math.Min(Math.Max(mouse.Y, 0), GraphicsDevice.Viewport.Height);

If you want the sprite to be completely bounded, you will have to account for the sprite/rectangle's own height and width (assuming the X and Y positions are the top left corner of the rectangle, I can't remember if XNA's rectangles are different from the ones in System.Drawing).

drawRectangle.X = Math.Min(Math.Max(mouse.X, 0), (GraphicsDevice.Viewport.Width - drawRectangle.Width));
drawRectangle.Y = Math.Min(Math.Max(mouse.Y, 0), (GraphicsDevice.Viewport.Height - drawRectangle.Height));

Answer 3

You can use MathHelper.Clamp() for clamp and GraphicsDevice.Viewport for the screen size:

public void Update(GameTime gameTime, MouseState mouse)
{
    if (health > 0)
    {
        drawRectangle.X = (int) MathHelper.Clamp(mouse.X, 0, 
                  GraphicsDevice.Viewport.Width - drawRectangle.Width);
        drawRectangle.Y = (int) MathHelper.Clamp(mouse.Y, 0,
                  GraphicsDevice.Viewport.Height - drawRectangle.Height);
    }
    // ...
}