sledgemapper/MyGame/Game1.cs

using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using MonoGame.Extended;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
namespace MyGame
{
public struct Tile
{
    public int X { get; set; }
    public int Y { get; set; }
    public int ID { get; set; }
    public int Rotation{get;set;}
}

public struct Wall
{
    public int X { get; set; }
    public int Y { get; set; }
    public int ID { get; set; }
    public int Rotation{get;set;}
}

    public class Game1 : Game
    {
        private GraphicsDeviceManager _graphics;
        private SpriteBatch _spriteBatch;

        private Vector2 _topLeft = new Vector2(-20,20);

        private List<Tile> _map = new List<Tile>();
        private List<Wall> _mapWalls = new List<Wall>();
        private Tile _selectedTile = new Tile{X=1,Y=1};

        private int _tileSize = 30;
        HubConnection connection;

        public Game1()
        {
            _graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            IsMouseVisible = true;

            _map.Add(new Tile{X=5,Y=5,ID=1 });


             connection = new HubConnectionBuilder()
                .WithUrl("http://localhost:5000/ChatHub")
                .Build();
                connection.StartAsync();

                connection.On<string, string>("ReceiveMessage", (user, message) =>
{
     
       var newMessage = $"{user}: {message}";
       _map.Add(new Tile{X=int.Parse(user.Split('-')[0]),Y=int.Parse(user.Split('-')[1]),ID =int.Parse(message) });
});
        }

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

            base.Initialize();
        }

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


            // TODO: use this.Content to load your game content here
        }
private KeyboardState oldState;
private MouseState oldMouseState;

private Vector3 _viewportCenter  = new Vector3(0,0,0);
        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
                Exit();
KeyboardState newState = Keyboard.GetState();
            // TODO: Add your update logic here

 var mouseState = Mouse.GetState();
 if (mouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton!=oldMouseState.LeftButton)
 {
     _selectedTile.X=(mouseState.Position.X-(int)_viewportCenter.X)/_tileSize;
     _selectedTile.Y=(mouseState.Position.Y-(int)_viewportCenter.Y)/_tileSize;
 }

 if(mouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton==oldMouseState.LeftButton)
 {
    _viewportCenter = new Vector3 (_viewportCenter.X+ mouseState.Position.X-oldMouseState.Position.X,_viewportCenter.Y+ mouseState.Position.Y-oldMouseState.Position.Y ,0);

    System.Console.WriteLine(_viewportCenter.X);
    System.Console.WriteLine(_viewportCenter.Y);
 }

foreach(var key in newState.GetPressedKeys())
{
   
    switch(key)
    {
        case Keys.Left:
        if (oldState.IsKeyUp(Keys.Left) && newState.IsKeyDown(Keys.Left))
        {_selectedTile.X--;}
        break;
            case Keys.Right:
        if (oldState.IsKeyUp(Keys.Right) && newState.IsKeyDown(Keys.Right))
            {_selectedTile.X++;}
        break;
            case Keys.Up:
        if (oldState.IsKeyUp(Keys.Up) && newState.IsKeyDown(Keys.Up))
            {_selectedTile.Y--;}
        break;
            case Keys.Down:
        if (oldState.IsKeyUp(Keys.Down) && newState.IsKeyDown(Keys.Down))
            {_selectedTile.Y++;}
        break;
      
      
    }
     if (oldState.IsKeyUp(key) && newState.IsKeyDown(key))
     {
    var tileId=((int)key)-48;
    if (tileId>=1 && tileId<=9)
    {
        
 var tileExist = _map.Any(m=>m.X==_selectedTile.X && m.Y==_selectedTile.Y);
                if (tileExist)
                {
                    var tile = _map.First(m=>m.X==_selectedTile.X && m.Y==_selectedTile.Y);
                    var index = _map.IndexOf(tile);
                   _map.RemoveAt(index);
                   if(tile.ID==tileId)
                   {
                   var newTile = new Tile{X=_selectedTile.X,Y=_selectedTile.Y,ID=tileId,Rotation=(tile.Rotation+1)%4};
                   _map.Add(newTile);
                   System.Console.WriteLine(newTile.Rotation);
                   }
                   else{
                   _map.Add(new Tile{X=_selectedTile.X,Y=_selectedTile.Y,ID=tileId});
                   }
                }
                else{
                    _map.Add(new Tile{X=_selectedTile.X,Y=_selectedTile.Y, ID=tileId});
                    connection.InvokeAsync("SendMessage",$"{_selectedTile.X}-{_selectedTile.Y}", tileId.ToString());
                }
            }
    }
 
}

oldState=newState;
oldMouseState=mouseState;
            base.Update(gameTime);
        }

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

            // TODO: Add your drawing code here
            var visibleTilesX = (int)GraphicsDevice.Viewport.Width/_tileSize +1;
            var visibleTilesY = (int)GraphicsDevice.Viewport.Height/_tileSize +1;
            
            _spriteBatch.Begin(transformMatrix:Matrix.CreateTranslation(_viewportCenter));

            for (var i = 0;i<visibleTilesX;i++)
            {
var posX1=i*_tileSize-_viewportCenter.X;
var posY1=-_viewportCenter.Y;
posX1=posX1-posX1%_tileSize;
posY1=posY1-posY1%_tileSize;
var posX2=i*_tileSize-_viewportCenter.X;
var posY2=GraphicsDevice.Viewport.Height-_viewportCenter.Y;
posX2=posX2-posX2%_tileSize;
posY2=posY2-posY2%_tileSize;

                _spriteBatch.DrawLine(
                   posX1,posY1,
                    posX2,
                    posY2,
                    Color.Black);
            }

            for (var i = 0;i<visibleTilesY;i++)
            {
var posX1=-_viewportCenter.X;
var posY1=i*_tileSize-_viewportCenter.Y;
posX1=posX1-posX1%_tileSize;
posY1=posY1-posY1%_tileSize;
var posX2=GraphicsDevice.Viewport.Width-_viewportCenter.X;
var posY2=i*_tileSize-_viewportCenter.Y;
posX2=posX2-posX2%_tileSize;
posY2=posY2-posY2%_tileSize;

                _spriteBatch.DrawLine( posX1,posY1,
                    posX2,
                    posY2,
                Color.Black);
            }

            foreach(var tile in _map)
            {

                var content =  Content.Load<Texture2D>($"tiles/tile{tile.ID.ToString().PadLeft(2,'0')}");
                var destinationRectangle = new Rectangle(tile.X*_tileSize,tile.Y*_tileSize,_tileSize,_tileSize);
                
                // _spriteBatch.Draw(
                //     content,
                //     destinationRectangle,
                //     null,
                //     Color.White,
                //     MathHelper.ToRadians(90*tile.Rotation),
                //     new Vector2(tile.X*_tileSize+_tileSize/2f, tile.Y*_tileSize+_tileSize/2f),
                //     SpriteEffects.None,
                //     1);
var posX=tile.X*_tileSize+_tileSize/2f;
var posY=tile.Y*_tileSize+_tileSize/2f;
 
                _spriteBatch.Draw(content,new Vector2(posX, posY),
                null,Color.White,MathHelper.ToRadians(90*tile.Rotation),new Vector2(content.Width/2,content.Height/2),1,SpriteEffects.None,0);

//  _spriteBatch.Draw(
//                     content,
//                     destinationRectangle,
//                     null,
//                     Color.White,MathHelper.ToRadians(90*tile.Rotation),new Vector2(destinationRectangle.X,destinationRectangle.Y)
//                     );

                    //var rf = new RectangleF(tile.X*_tileSize,tile.Y*_tileSize,_tileSize,_tileSize);

           // _spriteBatch.DrawRectangle(rf,Color.Red,3,0);

            }

            _spriteBatch.DrawRectangle(new RectangleF(_selectedTile.X*_tileSize,_selectedTile.Y*_tileSize,_tileSize,_tileSize),Color.Blue,3,0);

            _spriteBatch.End();
            
            base.Draw(gameTime);
        }
    }
}