Mouse and Buttons how to simplify?

Windows
1

does time I 've been trying to make it work as I want more for me is complicated am not a programmer , do not know almost nothing about C# , more is exactly how and wanted , however the code is ridiculous, I not even find a way to simplify and continue working the same way , anyone know how to make simple?

The mouse can click more than one button , and have three states , normal, hovered, pressed , the button has 3 images for each 1 states mouse , each button has its 3 imagens.

using System;
using Gest.Manager;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace Gest.Screen.Menu
{
    class MainScreen : MenuScreen
    {
        private Texture2D backgroundTexture;
        private Vector2 backgroundPosition;

        private Texture2D logoTexture;
        private Vector2 logoPosition;

        Rectangle loginButtonRectangle = new Rectangle(200, 250, 114, 34);
        Texture2D loginNormalButtonTexture;
        Texture2D loginHoveredButtonTexture;
        Texture2D loginPressedButtonTexture;
        private Texture2D loginCurrentButtonTexture;

        Rectangle createButtonRectangle = new Rectangle(200, 300, 114, 34);
        Texture2D createNormalButtonTexture;
        Texture2D createHoveredButtonTexture;
        Texture2D createPressedButtonTexture;
        private Texture2D createCurrentButtonTexture;

        private double timeClicked = -5.0;

        private loginButtonState loginState = loginButtonState.None;
        private createButtonState createState = createButtonState.None;

        enum loginButtonState
        {
            None,
            Released,
            Hovered,
            Pressed
        }

        enum createButtonState
        {
            None,
            Released,
            Hovered,
            Pressed
        }

        public MainScreen()
            : base()
        {
            // start the menu music
            AudioManager.PushMusic("MainTheme");
        }

        public override void LoadContent()
        {
            // load the textures
            ContentManager content = ScreenManager.Game.Content;
            backgroundTexture = content.Load<Texture2D>("Textures/Menu/Background");
            backgroundPosition = new Vector2(0, 0);
            logoTexture = content.Load<Texture2D>("Textures/Menu/Logo");
            logoPosition = new Vector2(0, 40);

            loginNormalButtonTexture = content.Load<Texture2D>("Textures/Buttons/loginNormal");
            loginHoveredButtonTexture = content.Load<Texture2D>("Textures/Buttons/loginHovered");
            loginPressedButtonTexture = content.Load<Texture2D>("Textures/Buttons/loginPressed");
            loginCurrentButtonTexture = loginNormalButtonTexture;

            createNormalButtonTexture = content.Load<Texture2D>("Textures/Buttons/createNormal");
            createHoveredButtonTexture = content.Load<Texture2D>("Textures/Buttons/createHovered");
            createPressedButtonTexture = content.Load<Texture2D>("Textures/Buttons/createPressed");
            createCurrentButtonTexture = createNormalButtonTexture;

            base.LoadContent();
        }

        public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
        {
            base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

            MouseState mouseState = Mouse.GetState();

            //This is I think the main difference.. I am detecting the mouse position with a rectangle
            Rectangle mouseRec = new Rectangle(mouseState.X, mouseState.Y, 1, 1);

            if (mouseRec.Intersects(loginButtonRectangle))
            {
                if (mouseState.LeftButton == ButtonState.Pressed)
                    loginState = loginButtonState.Pressed;           
                else
                    loginState = loginState == loginButtonState.Pressed ? loginButtonState.Released : loginButtonState.Hovered;
            }
            else
            {
                loginState = loginButtonState.None;
            };

            if (mouseRec.Intersects(createButtonRectangle))
            {
                if (mouseState.LeftButton == ButtonState.Pressed)
                    createState = createButtonState.Pressed;
                else
                    createState = createState == createButtonState.Pressed ? createButtonState.Released : createButtonState.Hovered;
            }
            else
            {
                createState = createButtonState.None;
            };
        }

        void LoginSelected(object sender, EventArgs e)
        {
            // ScreenManager.AddScreen(new LoginScreen());
        }

        void ExitSelected(object sender, EventArgs e)
        {
            ScreenManager.Game.Exit();
        }

        public override void Draw(GameTime gameTime)
        {
            SpriteBatch spriteBatch = ScreenManager.SpriteBatch;

            spriteBatch.Begin();

            // draw the background images
            spriteBatch.Draw(backgroundTexture, backgroundPosition, Color.White);
            spriteBatch.Draw(logoTexture, logoPosition, Color.White);

            switch (loginState)
            {
                case loginButtonState.None:
                    loginCurrentButtonTexture = loginNormalButtonTexture;
                    break;

                case loginButtonState.Hovered:
                    loginCurrentButtonTexture = loginHoveredButtonTexture;
                    break;

                case loginButtonState.Pressed:
                    loginCurrentButtonTexture = loginPressedButtonTexture;                    
                    break;

                case loginButtonState.Released:
                    loginCurrentButtonTexture = loginNormalButtonTexture;
                    timeClicked = gameTime.TotalGameTime.TotalSeconds;
                    break;
            }
            spriteBatch.Draw(loginCurrentButtonTexture, loginButtonRectangle, Color.White);
            
            switch (createState)
            {
                case createButtonState.None:
                    createCurrentButtonTexture = createNormalButtonTexture;
                    break;

                case createButtonState.Hovered:
                    createCurrentButtonTexture = createHoveredButtonTexture;
                    break;

                case createButtonState.Pressed:
                    createCurrentButtonTexture = createPressedButtonTexture;
                    break;

                case createButtonState.Released:
                    createCurrentButtonTexture = createNormalButtonTexture;
                    timeClicked = gameTime.TotalGameTime.TotalSeconds;
                    break;
            }
            spriteBatch.Draw(createCurrentButtonTexture, createButtonRectangle, Color.White);

            spriteBatch.End();
        }
    }
}
2

You should put the logic for a button in a separate class. You only need 1 enum with the button states. A button class might look like this.

class Button {
    
    public enum State {
        None,
        Pressed,
        Hover,
        Released
    }

    private Rectangle _rectangle;
    private State _state;
    public State State {
        get { return _state; }
        set { _state = value; } // you can throw some events here if you'd like
    }

    private Dictionary<State, Texture2D> _textures;

    public Button(Rectangle rectangle, Texture2D noneTexture, Texture2D hoverTexture, Texture2D pressedTexture) 
    {
        _rectangle = rectangle;
        _textures = new Dictionary<State, Texture2D>
        {
            { State.None, noneTexture },
            { State.Hover, hoverTexture },
            { State.Pressed, pressedTexture }
        }
    }

    public void Update(MouseState mouseState) 
    {
        if (rectangle.Contains(mouseState.X, mouseState.Y))
        {
            if (mouseState.LeftButton == ButtonState.Pressed)
                State = State.Pressed;
            else
                State = State == State.Pressed ? State.Released : State.Hover;
        }
        else 
        {
            State = State.None
        }
    }

    // Make sure Begin is called on s before you call this function
    public void Draw(SpriteBatch s) 
    {
        s.Draw(_textures[State], _rectangle);
    }

}

That would mean a lot less logic in your MainScreen class. If you add the buttons to a collection (_buttons in the following example) all you need to do is

var mouseState = Mouse.GetState();
// in update
foreach (var button in _buttons)
    button.Update(mouseState);
/*
Either check for the state of your buttons here or let them throw events you can subscribe to
*/    

// in draw
spriteBatch.Begin();
foreach (var button in _buttons)
    button.Draw(spriteBatch);
spriteBatch.End();

I typed this up here, so there might be some typos!