XNA 4.0 Game Development by Example: Beginner's Guide: The best way to start creating your own games is simply to dive in and give it a go with this Beginner’s Guide to XNA. Full of examples, tips, and tricks for a solid grounding.

Texture2D playingPieces;
Texture2D backgroundScreen;
Texture2D titleScreen;

playingPieces = Content.Load<Texture2D>(@"Textures\Tile_Sheet");
backgroundScreen = Content.Load<Texture2D>(@"Textures\Background");
titleScreen = Content.Load<Texture2D>(@"Textures\TitleScreen");

using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;

  public static string[] PieceTypes = 
  { 
    "Left,Right", 
    "Top,Bottom", 
    "Left,Top", 
    "Top,Right",
    "Right,Bottom", 
    "Bottom,Left",
    "Empty"
  };

  public const int PieceHeight = 40;
  public const int PieceWidth = 40;

  public const int MaxPlayablePieceIndex = 5;
  public const int EmptyPieceIndex = 6;

  private const int textureOffsetX = 1;
  private const int textureOffsetY = 1;
  private const int texturePaddingX = 1;
  private const int texturePaddingY = 1;

  private string pieceType = "";
...

  public GamePiece(string type, string suffix)
  {
      pieceType = type;
      pieceSuffix = suffix;
  }

  public GamePiece(string type)
  {
      pieceType = type;
      pieceSuffix = "";
  }

  public void SetPiece(string type, string suffix)
  {
      pieceType = type;
      pieceSuffix = suffix;
  }
  
  public void SetPiece(string type)
  {
      SetPiece(type,"");
  }

  public void AddSuffix(string suffix)
  {
      if (!pieceSuffix.Contains(suffix))
          pieceSuffix += suffix;
  }

  public void RemoveSuffix(string suffix)
  {
      pieceSuffix = pieceSuffix.Replace(suffix, "");
  }

  public void RotatePiece(bool Clockwise)
  {
      switch (pieceType)
      {
          case "Left,Right":
              pieceType = "Top,Bottom";
              break;
          case "Top,Bottom":
              pieceType = "Left,Right";
              break;
          case "Left,Top":
              if (Clockwise)
                  pieceType = "Top,Right";
              else
                  pieceType = "Bottom,Left";
              break;
          case "Top,Right":
              if (Clockwise)
                  pieceType = "Right,Bottom";
              else
                  pieceType = "Left,Top";
              break;
          case "Right,Bottom":
              if (Clockwise)
                  pieceType = "Bottom,Left";
              else
                  pieceType = "Top,Right";
              break;
          case "Bottom,Left":
              if (Clockwise)
            ...

  public string[] GetOtherEnds(string startingEnd)
  {
      List<string> opposites = new List<string>();

      foreach (string end in pieceType.Split(','))
      {
          if (end != startingEnd)
              opposites.Add(end);
      }
       return opposites.ToArray();
  }

  public bool HasConnector(string direction)
  {
      return pieceType.Contains(direction);
  }

  public Rectangle GetSourceRect()
  {
      int x = textureOffsetX;
      int y = textureOffsetY;
        
      if (pieceSuffix.Contains("W"))
          x += PieceWidth + texturePaddingX;

      y += (Array.IndexOf(PieceTypes, pieceType) * 
           (PieceHeight + texturePaddingY));


      return new Rectangle(x, y, PieceWidth, PieceHeight);
  }

using Microsoft.Xna.Framework;

  Random rand = new Random();

  public const int GameBoardWidth = 8;
  public const int GameBoardHeight = 10;

  private GamePiece[,] boardSquares = 
    new GamePiece[GameBoardWidth, GameBoardHeight];
  private List<Vector2> WaterTracker = new List<Vector2>();

  public GameBoard()
  {
      ClearBoard();
  }

  public void ClearBoard()
  {
      for (int x = 0; x < GameBoardWidth; x++)
          for (int y = 0; y < GameBoardHeight; y++)
              boardSquares[x, y] = new GamePiece("Empty");
  }

  public void RotatePiece(int x, int y, bool clockwise)
  {
      boardSquares[x, y].RotatePiece(clockwise);
  }

  public Rectangle GetSourceRect(int x, int y)
  {
      return boardSquares[x, y].GetSourceRect();
  }

  public string GetSquare(int x, int y)
  {
      return boardSquares[x, y].PieceType;
  }

  public void SetSquare(int x, int y, string pieceName)
  {
      boardSquares[x, y].SetPiece(pieceName);
  }

  public bool HasConnector(int x, int y, string direction)
  {
      return boardSquares[x, y].HasConnector(direction); 
  }

  public void RandomPiece(int x, int y)
  {
    boardSquares[x, y].SetPiece(GamePiece.PieceTypes[rand.Next(0, 
         GamePiece.MaxPlayablePieceIndex+1)]);
  }

public void FillFromAbove(int x, int y)
{
    int rowLookup = y - 1;

    while (rowLookup >= 0)
    {
        if (GetSquare(x, rowLookup) != "Empty")
        {
            SetSquare(x, y,
              GetSquare(x, rowLookup));
            SetSquare(x, rowLookup, "Empty");
            rowLookup = -1;
        }
        rowLookup--;
    }
}

public void GenerateNewPieces(bool dropSquares)
{

    if (dropSquares)
    {
        for (int x = 0; x < GameBoard.GameBoardWidth; x++)
        {
            for (int y = GameBoard.GameBoardHeight - 1; y >= 0; y--)
            {
                if (GetSquare(x, y) == "Empty")
                {
                    FillFromAbove(x, y);
                }
            }
        }
    }

    for (int y = 0; y < GameBoard.GameBoardHeight; y++)
        for (int x = 0; x < GameBoard.GameBoardWidth; x++)
        {
            if (GetSquare(x, y) == "Empty")
            {
                RandomPiece(x, y);
            }
        }
}

  public void ResetWater()
  {
      for (int y = 0; y < GameBoardHeight; y++)
          for (int x = 0; x < GameBoardWidth; x++)
              boardSquares[x,y].RemoveSuffix("W");
  }

  public void FillPiece(int X, int Y)
  {
      boardSquares[X,Y].AddSuffix("W");
  }

  public void PropagateWater(int x, int y, string fromDirection)
  {
      if ((y >= 0) && (y < GameBoardHeight) &&
          (x >= 0) && (x < GameBoardWidth))
      {
          if (boardSquares[x,y].HasConnector(fromDirection) &&
              !boardSquares[x,y].Suffix.Contains("W"))
          {
              FillPiece(x, y);
              WaterTracker.Add(new Vector2(x, y));
              foreach (string end in
                       boardSquares[x,y].GetOtherEnds(fromDirection))
                  switch (end)
                        {
                      case "Left": PropagateWater(x - 1, y, "Right");
                          break;
                      case "Right": PropagateWater(x + 1, y, "Left");
                          break;
                      case "Top": PropagateWater(x, y - 1, "Bottom");
                          break;
         ...

GameBoard gameBoard;

Vector2 gameBoardDisplayOrigin = new Vector2(70, 89);

int playerScore = 0;

enum GameStates { TitleScreen, Playing };
GameStates gameState = GameStates.TitleScreen;

Rectangle EmptyPiece = new Rectangle(1, 247, 40, 40);

const float MinTimeSinceLastInput = 0.25f;
float timeSinceLastInput = 0.0f;

this.IsMouseVisible = true;
graphics.PreferredBackBufferWidth = 800;
graphics.PreferredBackBufferHeight = 600;
graphics.ApplyChanges();
gameBoard = new GameBoard();

if (gameState == GameStates.TitleScreen)
{
    spriteBatch.Begin();
    spriteBatch.Draw(titleScreen,
        new Rectangle(0, 0,
            this.Window.ClientBounds.Width,
            this.Window.ClientBounds.Height),
        Color.White);
    spriteBatch.End();
}

if (gameState == GameStates.Playing)
{
    spriteBatch.Begin();

    spriteBatch.Draw(backgroundScreen,
        new Rectangle(0, 0,
            this.Window.ClientBounds.Width,
            this.Window.ClientBounds.Height),
        Color.White);

    for (int x = 0; x < GameBoard.GameBoardWidth; x++)
        for (int y = 0; y < GameBoard.GameBoardHeight; y++)
        {
            int pixelX = (int)gameBoardDisplayOrigin.X + 
                (x * GamePiece.PieceWidth);
            int pixelY = (int)gameBoardDisplayOrigin.Y + 
                (y * GamePiece.PieceHeight);

            spriteBatch.Draw(
                playingPieces,
                new Rectangle(
                  pixelX, 
                  pixelY, 
                  GamePiece.PieceWidth, 
                  GamePiece.PieceHeight),
         ...

private int DetermineScore(int SquareCount)
{
    return (int)((Math.Pow((SquareCount/5), 2) + SquareCount)*10);
}

private void CheckScoringChain(List<Vector2> WaterChain)
{

    if (WaterChain.Count > 0)
    {
        Vector2 LastPipe = WaterChain[WaterChain.Count - 1];


        if (LastPipe.X == GameBoard.GameBoardWidth - 1)
        {
            if (gameBoard.HasConnector(
                (int)LastPipe.X, (int)LastPipe.Y, "Right"))
            {
                playerScore += DetermineScore(WaterChain.Count);

                foreach (Vector2 ScoringSquare in WaterChain)
                {
                    gameBoard.SetSquare((int)ScoringSquare.X,
                        (int)ScoringSquare.Y, "Empty");
                }
            }
        }
    }
}

private void HandleMouseInput(MouseState mouseState)
{

    int x = ((mouseState.X -
        (int)gameBoardDisplayOrigin.X) / GamePiece.PieceWidth);

    int y = ((mouseState.Y -
        (int)gameBoardDisplayOrigin.Y) / GamePiece.PieceHeight);

    if ((x >= 0) && (x < GameBoard.GameBoardWidth) &&
      (y >= 0) && (y < GameBoard.GameBoardHeight))
    {
        if (mouseState.LeftButton == ButtonState.Pressed)
        {
            gameBoard.RotatePiece(x, y, false);
            timeSinceLastInput = 0.0f;
        }

        if (mouseState.RightButton == ButtonState.Pressed)
        {
            gameBoard.RotatePiece(x, y, true);
            timeSinceLastInput = 0.0f;
        }
    }
}

switch (gameState)
{
    case GameStates.TitleScreen:
        if (Keyboard.GetState().IsKeyDown(Keys.Space))
        {
            gameBoard.ClearBoard();
            gameBoard.GenerateNewPieces(false);
            playerScore = 0;
            gameState = GameStates.Playing;
        }
        break;

    case GameStates.Playing:
        timeSinceLastInput +=
          (float)gameTime.ElapsedGameTime.TotalSeconds;

        if (timeSinceLastInput >= MinTimeSinceLastInput)
        {
            HandleMouseInput(Mouse.GetState());
        }

        gameBoard.ResetWater();

        for (int y = 0; y < GameBoard.GameBoardHeight; y++)
        {
            CheckScoringChain(gameBoard.GetWaterChain(y));        
        }

        gameBoard.GenerateNewPieces(true);

        break;
}