tracking player, refactoring api. not working

MyGame/ExtensionMethods.cs

@@ -1,8 +1,11 @@
 // using MonoGame.Extended;
 using System.Collections.Generic;
+using System.Collections;
 using System.IO;
 using Microsoft.Xna.Framework.Content;
 using Microsoft.Xna.Framework;
+using System.Linq;
+
 namespace MyGame
 {
     public static class ExtensionMethods
@@ -22,11 +25,14 @@ namespace MyGame
             return result;
         }
 
-       public static Point AbsPoint(this Point point)
+        public static IEnumerable<string> Split(this string str, int chunkSize) => Enumerable.Range(0, str.Length / chunkSize)
-{
+                                                                                 .Select(i => str.Substring(i * chunkSize, chunkSize));
-    return new Point(System.Math.Abs(point.X), System.Math.Abs(point.Y));
+
-}
+        public static Point AbsPoint(this Point point)
+        {
+            return new Point(System.Math.Abs(point.X), System.Math.Abs(point.Y));
+        }
     }
-    
+
 }
-        
+

MyGame/Game1.cs

@@ -14,6 +14,33 @@ using System.Linq;
 
 namespace MyGame
 {
+    public class SessionData
+
+    {
+        public SessionData()
+        {
+            Map = new List<Tile>();
+            Overlays = new List<Overlay>();
+            Walls = new List<Wall>();
+            Players = new List<Player>();
+            Colors = new List<string>();
+        }
+        public List<Tile> Map { get; set; }
+        public List<Wall> Walls { get; set; }
+        public List<Overlay> Overlays { get; set; }
+        public bool IsValid { get; set; }
+        public List<Player> Players { get; set; }
+        public List<string> Colors;
+    }
+
+    public class Player
+    {
+        public string ConnectionId { get; set; }
+        public string Color { get; set; }
+
+        public Tile Position { get; set; }
+    }
+
     public class Game1 : Game
     {
         private GraphicsDeviceManager _graphics;
@@ -51,8 +78,10 @@ namespace MyGame
             // TODO: Add your initialization logic here
             IsMouseVisible = true;
             Window.AllowUserResizing = true;
+            Players = new List<Player>();
             connection = new HubConnectionBuilder()
-                                  .WithUrl("http://hub.michelescandura.com:5000/ChatHub")
+                                  .WithUrl("http://localhost:5000/ChatHub")
+                                  //   .WithUrl("http://hub.michelescandura.com:5000/ChatHub")
                                   .Build();
 
             connection.On<string, string>("ReceiveMessage", (user, message) =>
@@ -66,9 +95,56 @@ namespace MyGame
                 _map = map;
             });
 
+            connection.On<Player>("PlayerUpdate", (player) =>
+            {
+                var p = Players.First(m => m.ConnectionId == player.ConnectionId);
+                p.Position = player.Position;
+            });
+
+            connection.On<Tile>("DeleteTile", (tile) =>
+            {
+                _map.Remove(tile);
+            });
+
+            connection.On<Wall>("DeleteWall", (tile) =>
+           {
+               _mapWalls.Remove(tile);
+           });
+
+            connection.On<Overlay>("DeleteOverlay", (tile) =>
+           {
+               _overlays.Remove(tile);
+           });
+
+            connection.On<Tile>("NewTile", (tile) =>
+           {
+               _map.Remove(tile);
+               _map.Add(tile);
+           });
+
+            connection.On<Wall>("NewWall", (tile) =>
+           {
+               _mapWalls.Remove(tile);
+               _mapWalls.Add(tile);
+           });
+
+            connection.On<Overlay>("NewOverlay", (tile) =>
+           {
+               _overlays.Remove(tile);
+               _overlays.Add(tile);
+           });
+
+
+            connection.On<Player>("NewPlayer", (player) =>
+           {
+               Players.Add(player);
+           });
+
             base.Initialize();
         }
 
+        public List<Player> Players { get; set; }
+
         private HorizontalMenu BuildMenu()
         {
             var menu = new HorizontalMenu();
@@ -164,8 +240,12 @@ namespace MyGame
                     var successful = false;
                     try
                     {
-                        await connection?.InvokeAsync("NewSession", textbox.Text);
+                        var session = await connection?.InvokeAsync<SessionData>("NewSession", textbox.Text);
-                        successful = true;
+                        if (session!=null)
+                        {
+Players= session.Players;
+                        }
+                        successful = session!=null;
                     }
                     catch { }
                     if (successful)
@@ -211,12 +291,15 @@ namespace MyGame
                      var successful = false;
                      try
                      {
-                         var result = await connection?.InvokeAsync<bool>("JoinSession", textbox.Text);
+                         var result = await connection?.InvokeAsync<SessionData>("JoinSession", textbox.Text);
-                         if (result)
+                         if (result != null)
                          {
-                             _map = await connection.InvokeAsync<List<Tile>>("Refresh", textbox.Text);
+                             _map = result.Map;
+                             _mapWalls = result.Walls;
+                             _overlays = result.Overlays;
+                             Players = result.Players;
                          }
-                         successful = result;
+                         successful = result != null; ;
                      }
                      catch { }
                      if (successful)
@@ -372,76 +455,91 @@ namespace MyGame
 
         protected override void Update(GameTime gameTime)
         {
-            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
+            // if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
-                Exit();
+            //     Exit();
             KeyboardState newState = Keyboard.GetState();
             // TODO: Add your update logic here
-
+            if (IsActive && GraphicsDevice.Viewport.Bounds.Contains(Mouse.GetState().Position))
-            var mouseState = Mouse.GetState();
-
-            var screenPosition = new Point((mouseState.Position.X - (int)_viewportCenter.X), (mouseState.Position.Y - (int)_viewportCenter.Y));
-
-            _hoveredTile.X = screenPosition.X / _tileSize;
-            _hoveredTile.Y = screenPosition.Y / _tileSize;
-            if (screenPosition.X < 0)
             {
-                _hoveredTile.X--;
+                var mouseState = Mouse.GetState();
-            }
-            if (screenPosition.Y < 0)
-            {
-                _hoveredTile.Y--;
-            }
-            SelectClosestWall(screenPosition);
-            SelectOverlay(screenPosition);
 
+                var screenPosition = new Point((mouseState.Position.X - (int)_viewportCenter.X), (mouseState.Position.Y - (int)_viewportCenter.Y));
 
-
+                _hoveredTile.X = screenPosition.X / _tileSize;
-            if (mouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton != oldMouseState.LeftButton)
+                _hoveredTile.Y = screenPosition.Y / _tileSize;
-            {
+                if (screenPosition.X < 0)
-                _selectedTile.X = _hoveredTile.X;
-                _selectedTile.Y = _hoveredTile.Y;
-            }
-
-            if (newState.IsKeyDown(Keys.LeftControl) && mouseState.LeftButton == ButtonState.Pressed)
-            {
-                switch (_insertMode)
                 {
-                    case InsertMode.Tile:
+                    _hoveredTile.X--;
-                        _selectedTile.X = _hoveredTile.X;
-                        _selectedTile.Y = _hoveredTile.Y;
-                        SetTile(_currentTileId);
-                        break;
-
-                    case InsertMode.Wall:
-
-                        SetWall(_currentWallId);
-                        break;
-                    case InsertMode.Overlay:
-                        SetOverlay(_currentOverlayId);
-                        break;
                 }
 
-
+                if (screenPosition.Y < 0)
-            }
-
-            if (!newState.IsKeyDown(Keys.LeftControl) && 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);
-            }
-
-            if (newState.IsKeyDown(Keys.LeftControl) && mouseState.ScrollWheelValue != oldMouseState.ScrollWheelValue)
-            {
-                if (mouseState.ScrollWheelValue > oldMouseState.ScrollWheelValue)
                 {
-                    _tileSize = System.Math.Min(120, _tileSize + 10);
+                    _hoveredTile.Y--;
+                }
 
-                }
+                if (_insertMode == InsertMode.Wall)
-                else if (mouseState.ScrollWheelValue < oldMouseState.ScrollWheelValue)
                 {
-                    _tileSize = System.Math.Max(10, _tileSize - 10);
+                    SelectClosestWall(screenPosition);
                 }
+
+                if (_insertMode == InsertMode.Overlay)
+                {
+                    SelectOverlay(screenPosition);
+                }
+
+                if (mouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton != oldMouseState.LeftButton)
+                {
+                    _selectedTile.X = _hoveredTile.X;
+                    _selectedTile.Y = _hoveredTile.Y;
+                    connection?.SendAsync("UpdatePosition", _session, _selectedTile);
+                }
+
+                if (newState.IsKeyDown(Keys.LeftControl)
+                && mouseState.LeftButton == ButtonState.Pressed
+                && ((mouseState.LeftButton != oldMouseState.LeftButton) || (_selectedTile.X != _hoveredTile.X && _selectedTile.Y != _hoveredTile.Y)))
+                {
+                    switch (_insertMode)
+                    {
+                        case InsertMode.Tile:
+                            _selectedTile.X = _hoveredTile.X;
+                            _selectedTile.Y = _hoveredTile.Y;
+                            connection?.SendAsync("UpdatePosition", _session, _selectedTile);
+
+                            SetTile(_currentTileId);
+                            break;
+
+                        case InsertMode.Wall:
+
+                            SetWall(_currentWallId);
+                            break;
+                        case InsertMode.Overlay:
+                            SetOverlay(_currentOverlayId);
+                            break;
+                    }
+                }
+
+                if (!newState.IsKeyDown(Keys.LeftControl) && 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);
+                }
+
+                if (newState.IsKeyDown(Keys.LeftControl) && mouseState.ScrollWheelValue != oldMouseState.ScrollWheelValue)
+                {
+                    if (mouseState.ScrollWheelValue > oldMouseState.ScrollWheelValue)
+                    {
+                        _tileSize = System.Math.Min(120, _tileSize + 10);
+
+                    }
+                    else if (mouseState.ScrollWheelValue < oldMouseState.ScrollWheelValue)
+                    {
+                        _tileSize = System.Math.Max(10, _tileSize - 10);
+                    }
+                }
+
+                oldMouseState = mouseState;
             }
 
+
             if (newState.IsKeyDown(Keys.Delete))
             {
                 switch (_insertMode)
@@ -482,19 +580,12 @@ namespace MyGame
                         { _selectedTile.Y++; }
                         break;
                 }
-                if (oldState.IsKeyUp(key) && newState.IsKeyDown(key))
+                connection?.SendAsync("UpdatePosition", _session, _selectedTile);
-                {
-                    var tileId = ((int)key) - 48;
-                    if (tileId >= 1 && tileId <= 9)
-                    {
-                        SetTile(tileId);
 
-                    }
-                }
             }
 
             oldState = newState;
-            oldMouseState = mouseState;
+
             base.Update(gameTime);
         }
 
@@ -588,38 +679,47 @@ namespace MyGame
 
                 var content = Content.Load<Texture2D>($"overlays/overlay{tile.ID.ToString().PadLeft(2, '0')}");
 
-if (tile.Intersection)
+                if (tile.Intersection)
-{
+                {
-     var posX = tile.X * _tileSize ;
+                    var posX = tile.X * _tileSize;
-                var posY = tile.Y * _tileSize ;
+                    var posY = tile.Y * _tileSize;
 
-                _spriteBatch.Draw(content, new Vector2(posX, posY),
+                    _spriteBatch.Draw(content, new Vector2(posX, posY),
-                null, Color.White, MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_tileSize - 10) / content.Width, SpriteEffects.None, 0);
+                    null, Color.White, MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_tileSize - 10) / content.Width, SpriteEffects.None, 0);
-           
-}
-else
-{
-     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), ((float)_tileSize - 10) / content.Width, SpriteEffects.None, 0);
+                else
-           
+                {
-}
+                    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), ((float)_tileSize - 10) / content.Width, SpriteEffects.None, 0);
+                }
 
 
             }
 
 
-            _spriteBatch.DrawRectangle(new Rectangle(_selectedTile.X * _tileSize, _selectedTile.Y * _tileSize, _tileSize, _tileSize), Color.Blue, 3);
+            _spriteBatch.DrawRectangle(new Rectangle(_selectedTile.X * _tileSize, _selectedTile.Y * _tileSize, _tileSize - 1, _tileSize - 1), Color.Red, 2);
 
+            foreach (var player in Players)
+            {
+
+                var hexs = player.Color.Split(2).ToArray();
+                var color = new Color(int.Parse(hexs[0], System.Globalization.NumberStyles.HexNumber),
+                int.Parse(hexs[1], System.Globalization.NumberStyles.HexNumber),
+                int.Parse(hexs[2], System.Globalization.NumberStyles.HexNumber));
+                _spriteBatch.DrawRectangle(new Rectangle(player.Position.X * _tileSize, player.Position.Y * _tileSize, _tileSize - 1, _tileSize - 1), color, 2);
+
+            }
 
             var startWall = new Vector2(_selectedWall.X * _tileSize, _selectedWall.Y * _tileSize);
             if (_insertMode == InsertMode.Wall)
             {
                 _spriteBatch.DrawLine(startWall, _tileSize, MathHelper.ToRadians(90 * _selectedWall.Rotation), Color.Red, 2);
             }
-            var overlay=new Vector2(_selectedOverlay.X * _tileSize, _selectedOverlay.Y * _tileSize);
+            var overlay = new Vector2(_selectedOverlay.X * _tileSize, _selectedOverlay.Y * _tileSize);
             if (_insertMode == InsertMode.Overlay)
             {
                 if (_selectedOverlay.Intersection)
@@ -699,26 +799,46 @@ else
             var q1 = System.Math.Pow(mousePosition.X - _hoveredTile.X * _tileSize, 2);
             var q2 = System.Math.Pow((_hoveredTile.Y * _tileSize - mousePosition.Y), 2);
             var s = System.Math.Sqrt(q1 + q2);
-            
+
             if (s < _tileSize / 3)
             {
                 _selectedOverlay.Intersection = true;
                 return;
             }
 
-            q1 = System.Math.Pow(mousePosition.X - (_hoveredTile.X+1) * _tileSize, 2);
+            q1 = System.Math.Pow(mousePosition.X - (_hoveredTile.X + 1) * _tileSize, 2);
-           // var q2 = System.Math.Pow((_hoveredTile.Y * _tileSize - mousePosition.Y), 2);
+            // var q2 = System.Math.Pow((_hoveredTile.Y * _tileSize - mousePosition.Y), 2);
             s = System.Math.Sqrt(q1 + q2);
             if (s < _tileSize / 3)
             {
-                _selectedOverlay.X = _selectedOverlay.X+1;
+                _selectedOverlay.X = _selectedOverlay.X + 1;
                 _selectedOverlay.Intersection = true;
                 return;
             }
-            else
+
+            //q1 = System.Math.Pow(mousePosition.X - (_hoveredTile.X + 1) * _tileSize, 2);
+            q2 = System.Math.Pow(((_hoveredTile.Y + 1) * _tileSize - mousePosition.Y), 2);
+            s = System.Math.Sqrt(q1 + q2);
+            if (s < _tileSize / 3)
             {
-                _selectedOverlay.Intersection = false;
+                _selectedOverlay.X = _selectedOverlay.X + 1;
+                _selectedOverlay.Y = _selectedOverlay.Y + 1;
+                _selectedOverlay.Intersection = true;
+                return;
             }
+
+            q1 = System.Math.Pow(mousePosition.X - _hoveredTile.X * _tileSize, 2);
+            q2 = System.Math.Pow(((_hoveredTile.Y + 1) * _tileSize - mousePosition.Y), 2);
+            s = System.Math.Sqrt(q1 + q2);
+            if (s < _tileSize / 3)
+            {
+                _selectedOverlay.X = _selectedOverlay.X;
+                _selectedOverlay.Y = _selectedOverlay.Y + 1;
+                _selectedOverlay.Intersection = true;
+                return;
+            }
+
+            _selectedOverlay.Intersection = false;
         }
 
         private void SetTile(int tileId)
@@ -733,16 +853,20 @@ else
                 {
                     var newTile = new Tile { X = _selectedTile.X, Y = _selectedTile.Y, ID = tileId, Rotation = (tile.Rotation + 1) % 4 };
                     _map.Add(newTile);
+                    connection?.InvokeAsync("NewTile", _session, newTile);
                 }
                 else
                 {
-                    _map.Add(new Tile { X = _selectedTile.X, Y = _selectedTile.Y, ID = tileId });
+                    var newTile = new Tile { X = _selectedTile.X, Y = _selectedTile.Y, ID = tileId };
+                    _map.Add(newTile);
+                    connection?.InvokeAsync("NewTile", _session, newTile);
                 }
             }
             else
             {
-                _map.Add(new Tile { X = _selectedTile.X, Y = _selectedTile.Y, ID = tileId });
+                var newTile = new Tile { X = _selectedTile.X, Y = _selectedTile.Y, ID = tileId };
-                connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
+                _map.Add(newTile);
+                connection?.InvokeAsync("NewTile", _session, newTile);
             }
         }
 
@@ -758,16 +882,20 @@ else
                 {
                     var newOverlay = new Overlay { X = _selectedOverlay.X, Y = _selectedOverlay.Y, ID = tileId, Intersection = _selectedOverlay.Intersection, Rotation = (_selectedOverlay.Rotation + 1) % 4 };
                     _overlays.Add(newOverlay);
+                    connection?.InvokeAsync("NewOverlay", _session, newOverlay);
                 }
                 else
                 {
-                    _overlays.Add(new Overlay { X = _selectedOverlay.X, Y = _selectedOverlay.Y, ID = tileId, Intersection = _selectedOverlay.Intersection });
+                    var newOverlay = new Overlay { X = _selectedOverlay.X, Y = _selectedOverlay.Y, ID = tileId, Intersection = _selectedOverlay.Intersection };
+                    _overlays.Add(newOverlay);
+                    connection?.InvokeAsync("NewOverlay", _session, newOverlay);
                 }
             }
             else
             {
-                _overlays.Add(new Overlay { X = _selectedOverlay.X, Y = _selectedOverlay.Y, ID = tileId, Intersection = _selectedOverlay.Intersection });
+                var newOverlay = new Overlay { X = _selectedOverlay.X, Y = _selectedOverlay.Y, ID = tileId, Intersection = _selectedOverlay.Intersection };
-                //connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
+                _overlays.Add(newOverlay);
+                connection?.InvokeAsync("NewOverlay", _session, newOverlay);
             }
         }
 
@@ -779,7 +907,7 @@ else
                 var wall = _mapWalls.First(m => m.X == _selectedWall.X && m.Y == _selectedWall.Y && m.Rotation == _selectedWall.Rotation);
                 var index = _mapWalls.IndexOf(wall);
                 _mapWalls.RemoveAt(index);
-                //connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
+                connection?.InvokeAsync("DeleteWall", _session, wall);
             }
         }
 
@@ -791,7 +919,7 @@ else
                 var tile = _map.First(m => m.X == _selectedTile.X && m.Y == _selectedTile.Y);
                 var index = _map.IndexOf(tile);
                 _map.RemoveAt(index);
-                //connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
+                connection?.InvokeAsync("DeleteTile", _session, tile);
             }
         }
 
@@ -803,13 +931,16 @@ else
                 var wall = _mapWalls.First(m => m.X == _selectedWall.X && m.Y == _selectedWall.Y && m.Rotation == _selectedWall.Rotation);
                 var index = _mapWalls.IndexOf(wall);
                 _mapWalls.RemoveAt(index);
-
+                var newWall = new Wall { X = _selectedWall.X, Y = _selectedWall.Y, ID = wallId, Rotation = _selectedWall.Rotation };
-                _mapWalls.Add(new Wall { X = _selectedWall.X, Y = _selectedWall.Y, ID = wallId, Rotation = _selectedWall.Rotation });
+                _mapWalls.Add(newWall);
+                connection?.InvokeAsync("NewWall", _session, newWall);
 
             }
             else
             {
-                _mapWalls.Add(new Wall { X = _selectedWall.X, Y = _selectedWall.Y, ID = wallId, Rotation = _selectedWall.Rotation });
+                var newWall = new Wall { X = _selectedWall.X, Y = _selectedWall.Y, ID = wallId, Rotation = _selectedWall.Rotation };
+                _mapWalls.Add(newWall);
+                connection?.InvokeAsync("NewWall", _session, newWall);
 
                 //connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
             }

SignalRChat/.vscode/launch.json

@@ -1,3 +1,4 @@
+
 {
    // Use IntelliSense to find out which attributes exist for C# debugging
    // Use hover for the description of the existing attributes

SignalRChat/Dockerfile

@@ -17,4 +17,4 @@ RUN dotnet publish -c release -o /app --no-restore
 FROM mcr.microsoft.com/dotnet/aspnet:5.0
 WORKDIR /app
 COPY --from=build /app ./
-ENTRYPOINT ["dotnet", "SignalRChat.dll"]
+ENTRYPOINT ["dotnet", "SignalRChat.dll"]    

SignalRChat/SignalRChat/Hubs/ChatHub.cs

@@ -1,9 +1,20 @@
 using Microsoft.AspNetCore.SignalR;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 
 namespace SignalRChat.Hubs
 {
+    public struct Overlay
+    {
+        public int X { get; set; }
+        public int Y { get; set; }
+        public int ID { get; set; }
+        public bool Intersection { get; set; }
+        public int Rotation { get; set; }
+    }
+
     public struct Tile
     {
         public int X { get; set; }
@@ -12,48 +23,160 @@ namespace SignalRChat.Hubs
         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 Player
+    {
+        public string ConnectionId { get; set; }
+        public string Color { get; set; }
+
+        public Tile Position { get; set; }
+    }
+
     public class SessionData
 
     {
         public SessionData()
         {
             Map = new List<Tile>();
+            Overlays = new List<Overlay>();
+            Walls = new List<Wall>();
+            Players = new List<Player>();
+            Colors = new List<string>();
         }
         public List<Tile> Map { get; set; }
+        public List<Wall> Walls { get; set; }
+        public List<Overlay> Overlays { get; set; }
         public bool IsValid { get; set; }
+        public List<Player> Players { get; set; }
+        public List<string> Colors;
     }
 
     public class ChatHub : Hub
     {
         private static Dictionary<string, SessionData> _sessions = new Dictionary<string, SessionData>();
+        public List<string> Colors = new List<string>{"CC0000",
+"CC3300",
+"FFCC00",
+"009900",
+"006666",
+"0066FF",
+"0000CC",
+"663399",
+"CC0099"};
 
         public async Task SendMessage(string user, string message, string sessionName)
         {
             await Clients.Group(sessionName).SendAsync("ReceiveMessage", user, message);
         }
 
-        public async Task NewSession(string sessionName)
+        public async Task NewTile(string sessionName, Tile tile)
         {
-            _sessions.Add(sessionName, new SessionData());
+            if (_sessions[sessionName].Map.Contains(tile))
-            await Groups.AddToGroupAsync(Context.ConnectionId, sessionName);
+            {
+                _sessions[sessionName].Map.Remove(tile);
+            }
+
+            await Clients.Group(sessionName).SendAsync("NewTile", tile);
         }
 
-        public async Task<bool> JoinSession(string sessionName)
+        public async Task NewWall(string sessionName, Wall tile)
+        {
+            if (_sessions[sessionName].Walls.Contains(tile))
+            {
+                _sessions[sessionName].Walls.Remove(tile);
+            }
+
+            await Clients.Group(sessionName).SendAsync("NewWall", tile);
+        }
+
+        public async Task NewOverlay(string sessionName, Overlay tile)
+        {
+            if (_sessions[sessionName].Overlays.Contains(tile))
+            {
+                _sessions[sessionName].Overlays.Remove(tile);
+            }
+
+            await Clients.Group(sessionName).SendAsync("    ", tile);
+        }
+
+        public async Task DeleteTile(string sessionName, Tile tile)
+        {
+            if (_sessions[sessionName].Map.Contains(tile))
+            {
+                _sessions[sessionName].Map.Remove(tile);
+            }
+
+            await Clients.Group(sessionName).SendAsync("DeleteTile", tile);
+        }
+
+        public async Task DeleteWall(string sessionName, Wall tile)
+        {
+            if (_sessions[sessionName].Walls.Contains(tile))
+            {
+                _sessions[sessionName].Walls.Remove(tile);
+            }
+
+            await Clients.Group(sessionName).SendAsync("DeleteWall", tile);
+        }
+
+        public async Task DeleteOverlay(string sessionName, Overlay tile)
+        {
+            if (_sessions[sessionName].Overlays.Contains(tile))
+            {
+                _sessions[sessionName].Overlays.Remove(tile);
+            }
+
+            await Clients.Group(sessionName).SendAsync("DeleteOverlay", tile);
+        }
+
+        public async Task<SessionData> NewSession(string sessionName)
+        {
+            var session = new SessionData();
+            session.Colors = new List<string>(Colors);
+            session.Colors.Shuffle();
+            var player = new Player { Position = new Tile { X = 0, Y = 0 }, ConnectionId = Context.ConnectionId, Color = session.Colors[0] };
+            session.Players.Add(player);
+            _sessions.Add(sessionName, session);
+            await Clients.Group(sessionName).SendAsync("NewPlayer", player);
+
+            await Groups.AddToGroupAsync(Context.ConnectionId, sessionName);
+            return session;
+        }
+
+        public async Task<SessionData> JoinSession(string sessionName)
         {
             if (_sessions.ContainsKey(sessionName))
             {
+                var session = _sessions[sessionName];
+                var player = new Player { Position = new Tile { X = 0, Y = 0 }, ConnectionId = Context.ConnectionId, Color = session.Colors[session.Players.Count] };
+                session.Players.Add(player);
                 await Groups.AddToGroupAsync(Context.ConnectionId, sessionName);
-                return true;
+                return session;
             }
             else
             {
-                return false;
+                return null;
             }
         }
 
-        public async Task<List<Tile>> Refresh(string sessionName)
+        public async Task UpdatePosition(string sessionName, Tile tile)
         {
-            return _sessions[sessionName].Map;
+            var player = _sessions[sessionName].Players.First(m => m.ConnectionId == Context.ConnectionId);
+            player.Position = tile;
+            await Clients.Group(sessionName).SendAsync("PlayerUpdate", player);
+
+        }
+
+        public async Task<SessionData> Refresh(string sessionName)
+        {
+            return _sessions[sessionName];
         }
 
         public async Task Sync(string sessionName, List<Tile> map)
@@ -63,4 +186,22 @@ namespace SignalRChat.Hubs
 
         }
     }
+
+    public static class ExtensionMethods
+    {
+        private static Random rng = new Random();
+
+        public static void Shuffle<T>(this IList<T> list)
+        {
+            int n = list.Count;
+            while (n > 1)
+            {
+                n--;
+                int k = rng.Next(n + 1);
+                T value = list[k];
+                list[k] = list[n];
+                list[n] = value;
+            }
+        }
+    }
 }

SignalRChat/SignalRChat/Startup.cs

@@ -56,8 +56,6 @@ namespace SignalRChat
                 endpoints.MapHub<ChatHub>("/chathub");
 
             });
-
-            Console.WriteLine("blah");
         }
     }
 }