michele/sledgemapper
1
0
Fork 0
Code Issues 5 Pull requests Projects Releases 4 Wiki Activity

tracking player, refactoring api. not working

Browse source
This commit is contained in:
Michele 2020-11-03 00:03:40 +00:00
parent c2045e74cf
commit d31d448182
6 changed files with 401 additions and 124 deletions
Download patch file Download diff file Expand all files Collapse all files

18
MyGame/ExtensionMethods.cs
View file

@ -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)
{
return new Point(System.Math.Abs(point.X), System.Math.Abs(point.Y));
}
public static IEnumerable<string> Split(this string str, int chunkSize) => Enumerable.Range(0, str.Length / chunkSize)
.Select(i => str.Substring(i * chunkSize, chunkSize));
public static Point AbsPoint(this Point point)
{
return new Point(System.Math.Abs(point.X), System.Math.Abs(point.Y));
}
}
}

345
MyGame/Game1.cs
View file

@ -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);
successful = true;
var session = await connection?.InvokeAsync<SessionData>("NewSession", textbox.Text);
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);
if (result)
var result = await connection?.InvokeAsync<SessionData>("JoinSession", textbox.Text);
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))
Exit();
// 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();
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)
if (IsActive && GraphicsDevice.Viewport.Bounds.Contains(Mouse.GetState().Position))
{
_hoveredTile.X--;
}
if (screenPosition.Y < 0)
{
_hoveredTile.Y--;
}
SelectClosestWall(screenPosition);
SelectOverlay(screenPosition);
var mouseState = Mouse.GetState();
var screenPosition = new Point((mouseState.Position.X - (int)_viewportCenter.X), (mouseState.Position.Y - (int)_viewportCenter.Y));
if (mouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton != oldMouseState.LeftButton)
{
_selectedTile.X = _hoveredTile.X;
_selectedTile.Y = _hoveredTile.Y;
}
if (newState.IsKeyDown(Keys.LeftControl) && mouseState.LeftButton == ButtonState.Pressed)
{
switch (_insertMode)
_hoveredTile.X = screenPosition.X / _tileSize;
_hoveredTile.Y = screenPosition.Y / _tileSize;
if (screenPosition.X < 0)
{
case InsertMode.Tile:
_selectedTile.X = _hoveredTile.X;
_selectedTile.Y = _hoveredTile.Y;
SetTile(_currentTileId);
break;
case InsertMode.Wall:
SetWall(_currentWallId);
break;
case InsertMode.Overlay:
SetOverlay(_currentOverlayId);
break;
_hoveredTile.X--;
}
}
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)
if (screenPosition.Y < 0)
{
_tileSize = System.Math.Min(120, _tileSize + 10);
_hoveredTile.Y--;
}
}
else if (mouseState.ScrollWheelValue < oldMouseState.ScrollWheelValue)
if (_insertMode == InsertMode.Wall)
{
_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))
{
var tileId = ((int)key) - 48;
if (tileId >= 1 && tileId <= 9)
{
SetTile(tileId);
connection?.SendAsync("UpdatePosition", _session, _selectedTile);
}
}
}
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)
{
var posX = tile.X * _tileSize ;
var posY = tile.Y * _tileSize ;
if (tile.Intersection)
{
var posX = tile.X * _tileSize;
var posY = tile.Y * _tileSize;
_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.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);
// var q2 = System.Math.Pow((_hoveredTile.Y * _tileSize - mousePosition.Y), 2);
q1 = System.Math.Pow(mousePosition.X - (_hoveredTile.X + 1) * _tileSize, 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 });
connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
var newTile = new Tile { X = _selectedTile.X, Y = _selectedTile.Y, ID = tileId };
_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 });
//connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
var newOverlay = new Overlay { X = _selectedOverlay.X, Y = _selectedOverlay.Y, ID = tileId, Intersection = _selectedOverlay.Intersection };
_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);
_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);
}
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);
}

1
SignalRChat/.vscode/launch.json vendored
View file

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

2
SignalRChat/Dockerfile
View file

@ -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"]

157
SignalRChat/SignalRChat/Hubs/ChatHub.cs
View file

@ -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());
await Groups.AddToGroupAsync(Context.ConnectionId, sessionName);
if (_sessions[sessionName].Map.Contains(tile))
{
_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;
}
}
}
}

2
SignalRChat/SignalRChat/Startup.cs
View file

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