protected void Application_Start(object sender, EventArgs e)
{
//App_Start Configuration
WebApiConfig.Register(GlobalConfiguration.Configuration);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Inform the game loop about its environment
GameLoop.Instance.MachineName = System.Environment.MachineName.ToLower();
GameLoop.Instance.VirtualPath = HostingEnvironment.ApplicationVirtualPath;
GameLoop.Instance.SetEngine();
// Get latest codes from the WebService
var dms = new DescilMturkService(new PersistedRepository());
dms.GetCodes();
try
{
using (var db = new PersistedRepository()) { db.Log.AddEvent("ApplicationStart"); }
}
catch
{
//Swallow this
}
}
/// <summary>
/// Lets clients pull a client view object on init
/// </summary>
/// <returns>ClientView object</returns>
public ClientView Init()
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get the grid the player sits on
var grid = db.Grid.GetByConnectionId(Context.ConnectionId);
if(grid != null)
{
var initData = new ClientView
{
Round = 0,
OwnType = 0,
Move = false,
TypeChange = false,
Timeout = false,
LastPayoff = 0,
TotalPayoff = 0,
BlueCount = 0,
YellowCount = 0,
WhiteCount = 0,
OwnShare = "",
OtherShare = "",
CountDown = grid.IntroTimer
};
return initData;
}
}
return null;
}
public DescilMturkService(PersistedRepository repo, string serviceUrl, string serviceKey, string projectCode)
{
_db = repo;
_serviceUrl = serviceUrl;
_serviceKey = serviceKey;
_projectCode = projectCode;
}
/// <summary>
/// Save page request time
/// </summary>
private void SavePageLog()
{
using (var db = new PersistedRepository())
{
db.Log.AddPageLog("default");
}
}
//CTOR
public DescilMturkService(PersistedRepository repo)
{
_db = repo;
var config = new Configuration();
_serviceUrl = config.AppSettings("DescilServiceUrl");
_serviceKey = config.AppSettings("DescilServiceKey");
_projectCode = config.AppSettings("DescilProjectCode");
}
/// <summary>
/// Simply broadcast a message to all clients
/// </summary>
/// <param name="message">The message</param>
public void Send(string message)
{
using (var db = new PersistedRepository())
{
var playerCode = db.Player.GetShortAccessCode(Context.ConnectionId);
Clients.Group("admin").chatMessage(playerCode + " says: " + message);
Clients.Group("playerview-" + playerCode).chatMessage(playerCode + " says: " + message);
}
}
/// <summary>
/// Add entry to questions
/// </summary>
private void AddResponse(string accessCode)
{
using (var db = new PersistedRepository())
{
var question = db.Questionnaires.FirstOrDefault(q => q.AccessCode.Equals(LblAccessCode.Text));
if (question == null)
{
db.Add(new Questionnaire { AccessCode = accessCode });
db.Save();
}
}
}
protected void Application_Error(object sender, EventArgs e)
{
try
{
// Get the exception object.
Exception exc = Server.GetLastError();
using (var db = new PersistedRepository()) { db.Log.AddEvent(exc.ToString() + " " + exc.InnerException.ToString() ); }
}
catch
{
//Swallow this
}
}
/// <summary>
/// Save events / exceptions on this page
/// </summary>
private void SaveExceptions(string message, string method)
{
using (var db = new PersistedRepository())
{
var evlog = new EventLog
{
EventLogTime = DateTime.Now,
Message = message,
PlayerId = 0,
AccessCode = LblAccessCode.Text,
Page = "default",
PageStep = 0,
Method = method
};
db.Add(evlog);
}
}
/// <summary>
/// Save hub message and sends it to admin
/// </summary>
/// <param name="gridId">GridId</param>
/// <param name="accessCode">Access Code</param>
/// <param name="message">The message</param>
/// <returns></returns>
private async Task HubMessageAsync(int gridId, string accessCode, string message, string method, long runtime, int verbosity)
{
using (var db = new PersistedRepository())
{
// Add to message log
var messageLog = new MessageLog(gridId, accessCode, message, method, runtime);
db.Add(messageLog);
db.Save();
}
if(_segregLoop.Engine.Verbosity >= verbosity)
{
// Send to admin
await AdminMessageAsync(message);
}
}
/// <summary>
/// Fires when a client establishes a hub connection
/// </summary>
public override Task OnConnected()
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// User definition
var connectionId = Context.ConnectionId;
var isAdmin = false;
var isAuthorized = false;
// Collect client info
var myContext = Context.Request.GetHttpContext();
string ip = myContext.Request.ServerVariables["REMOTE_ADDR"];
string browser = myContext.Request.Browser.Browser + " " + myContext.Request.Browser.Version;
// Check for access code in cookie
string accessCode = "";
foreach (var c in myContext.Request.Cookies.AllKeys)
{
if (c.Equals("SegRegCode")) accessCode = myContext.Request.Cookies["SegRegCode"].Value;
}
// Check for access code in querystring
var qsAccessCode = Context.QueryString["a"];
if(!string.IsNullOrEmpty(qsAccessCode))
{
// Override if present
accessCode = qsAccessCode;
}
// Authorize: Check if AccessCode is present and valid, otherwise throw
if (!string.IsNullOrEmpty(accessCode))
{
isAuthorized = db.Code.IsAuthorized(accessCode);
if (!isAuthorized)
{
HubMessage(0, accessCode, accessCode.Substring(0, 8) + " access denied.", "OnConnected", stopwatch.ElapsedMilliseconds, 1);
//throw new Exception("Access denied");
}
}
else
{
HubMessage(0, "", "Access denied.", "OnConnected", stopwatch.ElapsedMilliseconds, 2);
//throw new Exception("Access denied");
}
// Check query string for page url and add to groups
var transport = Context.QueryString["transport"];
var page = Context.QueryString["page"];
if (!string.IsNullOrEmpty(page))
{
// Add to groups
page = AddToPageGroup(connectionId, page);
// Test for admin
if (page.IndexOf("admin") >= 0) isAdmin = true;
if (page.IndexOf("gridview") >= 0) isAdmin = true;
if (page.IndexOf("playerview") >= 0) isAdmin = true;
}
// .Net clients
//var clientType = Context.QueryString["segregclient"];
//if (!string.IsNullOrEmpty(clientType))
//{
// page = AddToPageGroup(connectionId, "admin");
// isAdmin = true;
// AdminMessage(connectionId.Substring(0, 8) + " connected as client.");
//}
//Add or update player
var player = db.Player.GetByAccessCode(accessCode);
if (player == null)
{
// Add a new player to the database
db.Player.Add(accessCode, connectionId, true, isAdmin, ip, browser, transport);
}
else
{
// Set connected if player is found
db.Player.SetConnectionStatus(accessCode, connectionId, true, isAdmin, ip, browser, transport);
// Check if he is/was in a specific room/game
// If the players grid is non static but he tries to connect to lobby waiting room
// We redirect him to the game room.
if (!player.Grid.IsStatic & page.IndexOf("game") < 0)
{
string url = db.Grid.GetUrl(_segregLoop.Engine, player.GridId);
url += "?a=" + accessCode;
Clients.Caller.navigate(url);
}
}
// AutoStart the game engine on admin entrance
if (page == "admin") _segregLoop.AutoStart();
//if (page == "lobby") _segregLoop.AutoStart();
// Report back
HubMessage(0, accessCode, accessCode.Substring(0, 8) + " connected", "OnConnected", stopwatch.ElapsedMilliseconds, 2);
return base.OnConnected();
}
}
/// <summary>
/// Start grids
/// </summary>
private async Task StartGrids()
{
using (var db = new PersistedRepository())
{
//Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Set random number generator
db.Random = _rng;
// Loop over all grids that are setup and ready
foreach (var g in db.Grids.Where(x => x.GridState == 3))
{
// Add AI bots
db.Game.AddBots(g.GridId);
// Check number of players
var playerCount = db.Players.Count(p => p.GridId == g.GridId);
if (g.TotalPlayerCount != playerCount)
{
await GridMessageAsync(g, " *** Grid Excpetion: wrong number of players: " + playerCount.ToString(), "StartGrids", stopwatch.ElapsedMilliseconds, 1);
db.Grid.SetState(g.GridId, 9);
return;
}
// Assign Player Types
db.Game.AssignPlayerTypes(g.GridId);
// Move players into cells
db.Game.AssignPlayerToCells(g.GridId);
// Reset player flags
db.Game.ResetRealPlayerFlags(g.GridId);
// Tell the grid startup is completed
db.Grid.SetState(g.GridId, 4);
// Report back
await GridMessageAsync(g, "started grid", "StartGrids", stopwatch.ElapsedMilliseconds, 1);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="target"></param>
/// <param name="statusType"></param>
public async Task SetPlayerStatus(string accessCode, string statusType)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
string message = "";
var player = db.Players.FirstOrDefault(p => p.AccessCode.Substring(0, 8) == accessCode.Trim());
if (player != null)
{
switch(statusType)
{
case "zombie":
db.Player.SetZombie(player.AccessCode);
message = "Player " + accessCode + " marked as zombie.";
break;
case "exit":
await GridMove(player.AccessCode.Substring(0, 8), "3", "");
message = "Player " + accessCode + " moved to the exit.";
break;
case "swap":
db.Grid.SwapPlayer(player);
await GridMove(player.AccessCode.Substring(0, 8), "3", "");
message = "Player " + accessCode + " swapped and moved to the exit.";
break;
}
}
else
{
message = "Player has not been found.";
}
Clients.Caller.chatMessage("PlayerCode:" + accessCode);
// Report back
Clients.Caller.chatMessage(message);
await HubMessageAsync(0, "admin", "HubSetPlayerStatus: " + message, "SetPlayerStatus", stopwatch.ElapsedMilliseconds, 1);
}
}
/// <summary>
/// Player requests a type change for the next round
/// </summary>
/// <param name="request">Change type if true, false otherwise</param>
/// <param name="timeout">True if player didn't reach a decision withing the allotted time.</param>
public Task TypeChange(bool request, bool timeout)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Save choice
db.Player.RequestTypeChange(Context.ConnectionId, request, timeout);
// Get AccessCode and Grid
string accessCode = "";
int gridId = 0;
var player = db.Players.FirstOrDefault(p => p.ConnectionId == Context.ConnectionId);
if (player != null)
{
accessCode = player.AccessCode;
gridId = player.GridId;
}
var message = request.ToString();
if (timeout) message = "timeout";
message = db.Player.GetShortAccessCode(Context.ConnectionId) + " requested change: " + message;
return HubMessageAsync(gridId, accessCode, message, "TypeChange", stopwatch.ElapsedMilliseconds, 2);
}
}
/// <summary>
/// Send a chat or script message to grids or players
/// </summary>
/// <param name="target">Grid or player identification</param>
/// <param name="targetType">GridName, GridId, GridGrui, AccessCode, or PlayerId</param>
/// <param name="message">The message</param>
/// <param name="isScript">True if message is a script, false otherwise</param>
public async Task ChatMessage(string target, int targetType, string message, bool isScript)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
switch (targetType)
{
case 1: // GridId
int gridId = 0;
var isGridId = Int32.TryParse(target, out gridId);
var grid2 = db.Grids.FirstOrDefault(g => g.GridId == gridId);
if (grid2 != null)
{
if (grid2.IsStatic)
{
await SendMessageToGroup(grid2.GridName.ToLower(), message, isScript);
}
else
{
switch (grid2.GameTypeId)
{
case 1:
await SendMessageToGroup("mgame-" + grid2.GridGuid, message, isScript);
break;
case 2:
await SendMessageToGroup("tgame-" + grid2.GridGuid, message, isScript);
break;
case 3:
await SendMessageToGroup("rtmgame-" + grid2.GridGuid, message, isScript);
break;
case 4:
await SendMessageToGroup("rttgame-" + grid2.GridGuid, message, isScript);
break;
}
}
}
break;
case 2: // GridName
var grid1 = db.Grids.FirstOrDefault(g => g.GridName.Equals(target, StringComparison.OrdinalIgnoreCase));
if (grid1 != null)
{
await SendMessageToGroup(target.ToLower(), message, isScript);
}
break;
case 3: // GridGuid
var grid3 = db.Grids.FirstOrDefault(g => g.GridGuid.Equals(target, StringComparison.OrdinalIgnoreCase));
if (grid3 != null)
{
if (grid3.IsStatic)
{
await SendMessageToGroup(grid3.GridName.ToLower(), message, isScript);
}
else
{
switch (grid3.GameTypeId)
{
case 1:
await SendMessageToGroup("mgame-" + grid3.GridGuid, message, isScript);
break;
case 2:
await SendMessageToGroup("tgame-" + grid3.GridGuid, message, isScript);
break;
case 3:
await SendMessageToGroup("rtmgame-" + grid3.GridGuid, message, isScript);
break;
case 4:
await SendMessageToGroup("rttgame-" + grid3.GridGuid, message, isScript);
break;
}
}
}
break;
case 4: // AccessCode
var player1 = db.Players.FirstOrDefault(p => p.AccessCode.Substring(0, 8).Equals(target, StringComparison.OrdinalIgnoreCase));
if (player1 != null)
{
await SendMessageToPlayer(player1.ConnectionId, message, isScript);
}
break;
case 5: // PlayerId
int playerId = 0;
var isPlayerId = Int32.TryParse(target, out playerId);
var player2 = db.Players.FirstOrDefault(p => p.PlayerId == playerId);
if (player2 != null)
{
await SendMessageToPlayer(player2.ConnectionId, message, isScript);
}
break;
case 6: // ConnectionId
await SendMessageToPlayer(target, message, isScript);
break;
}
// Report back
await HubMessageAsync(0, "admin", "HubChatMessage: " + target + ": Message has been sent.", "ChatMessage", stopwatch.ElapsedMilliseconds, 1);
}
}
/// <summary>
/// Push initial grid state to clients
/// </summary>
/// <returns></returns>
private async Task PushInit()
{
using (var db = new PersistedRepository())
{
//Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Set common random number generator
db.Random = _rng;
// Loop over all grids that are setup and ready
foreach (var g in db.Grids.Where(x => x.GridState == 4))
{
// Initial round 0, just send neighborhood
if (!g.Players.Any(p => !p.IsReady))
{
// Get neighborhoods of all players
var nei = db.Game.Neighborhoods(g.GridId);
// Loop over a shuffled list of players
foreach (var p in g.Players.Shuffle(db.Random))
{
// Get player neighborhood
var pNei = nei.FirstOrDefault(n => n.PlayerId == p.PlayerId);
if (pNei != null)
{
// Set player neighborhood
p.Neighborhood = pNei;
}
}
// Save Neighborhoods to database
db.Save();
// Grid statistics
db.Grid.GridStats(g, nei);
// Logging
await LogGrids(g.GridId);
// Loop over a shuffled list of players
foreach (var p in g.Players.Where(p => !p.IsBot).Shuffle(db.Random))
{
// Compute client view state
var cv = db.View.GetClientStatus(g, p);
// Push state to clients
Clients.Client(p.ConnectionId).nextRound(cv);
}
// Reset player flags
db.Game.ResetPlayerFlags(g.GridId);
// Initial Push completed
db.Grid.SetState(g.GridId, 5);
// Report back to admin
await GridMessageAsync(g, "init push", "PushInit", stopwatch.ElapsedMilliseconds, 1);
}
}
}
}
//Ctor
public LogController(SegregContext context, PersistedRepository repo)
{
ctx = context;
db = repo;
}
/// <summary>
/// Answer of a ping-pong roundtrip test
/// </summary>
public Task PingBack()
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
var player = db.Player.SetConnectionStatus(Context.ConnectionId, true);
// Get AccessCode and Grid
string accessCode = "";
int gridId = 0;
string message = "";
if (player != null)
{
accessCode = player.AccessCode;
gridId = player.GridId;
message = db.Player.GetShortAccessCode(Context.ConnectionId) + " ping pong";
}
else
{
message = "Exception: Player not found: " + Context.ConnectionId;
}
return HubMessageAsync(gridId, accessCode, message, "PingBack", stopwatch.ElapsedMilliseconds, 2);
}
}
/// <summary>
/// Relocation and type change choices of bots
/// </summary>
private async Task UpdateBots()
{
using (var db = new PersistedRepository())
{
//Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Set common random number generator
db.Random = _rng;
// Loop over all running grids
foreach (var g in db.Grids.Where(x => x.GridState == 5 & x.BotCount > 0))
{
// Relocation decisions
// Test if all real players are ready AND bots are not ready AND endround is not yet reached
if (!g.Players.Any(p => !p.IsBot & !p.IsReady) & !g.Players.Any(p => p.IsBot & p.IsReady) & g.Round < g.RoundCount & g.GameTypeId == 1)
{
var movedBots = 0;
// Let bots decide if they want to move
foreach (var p in g.Players.Where(x => x.IsBot))
{
// Try to move the bot
db.Game.BotRelocationDecision(g, p);
if (p.RequestMove) movedBots++;
}
// Save changes
db.Save();
// Report back
await GridMessageAsync(g, "bots moved (" + movedBots.ToString() + ")", "UpdateBots", stopwatch.ElapsedMilliseconds, 2);
}
// Type change decisions
// Test if all real players are ready AND bots are not ready AND endround is not yet reached
if (!g.Players.Any(p => !p.IsBot & !p.IsReady) & !g.Players.Any(p => p.IsBot & p.IsReady) & g.Round < g.RoundCount & g.GameTypeId == 2)
{
var changedBots = 0;
// Let bots decide if they want to move
foreach (var p in g.Players.Where(x => x.IsBot))
{
// Try to move the bot
db.Game.BotTypeChangeDecision(g, p);
if (p.RequestTypeChange) changedBots++;
}
// Save changes
db.Save();
// Report back
await GridMessageAsync(g, "bots changed (" + changedBots.ToString() + ")", "UpdateBots", stopwatch.ElapsedMilliseconds, 2);
}
}
}
}
/// <summary>
/// Set the engine settings
/// </summary>
/// <param name="engineSettings">The EngineSettings Object</param>
public Task SetEngine(EngineSettings engineSettings)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
bool wasRunning = false;
// Stop loops if they are running
if (_segregLoop.GameState == GameState.Started)
{
wasRunning = true;
_segregLoop.StopGameLoop();
_segregLoop.StopEngineLoop();
//_segregLoop.StopSweepLoop();
}
// Update the engine in database
db.Engine.Update(_segregLoop.Engine.EngineId, engineSettings);
// Refresh Engine in Loop
_segregLoop.SetEngine();
// Restart loops if they were running
if (wasRunning)
{
_segregLoop.StartGameLoop();
_segregLoop.StartEngineLoop();
//_segregLoop.StartSweepLoop();
}
// Report back
return HubMessage(0, "admin", "HubSetEngine", "SetEngine", stopwatch.ElapsedMilliseconds, 1);
}
}
/// <summary>
/// Start and stop the game loop
/// </summary>
/// <param name="start">If true game loop starts and stops otherwise</param>
public void ToggleLoops(bool start)
{
using (var db = new PersistedRepository())
{
var engine = db.Engines.FirstOrDefault(e => e.EngineId == _segregLoop.Engine.EngineId);
if (start)
{
engine.GameLoop = true;
engine.EngineLoop = true;
//engine.SweepLoop = true;
db.Save();
_segregLoop.StartGameLoop();
_segregLoop.StartEngineLoop();
//_segregLoop.StartSweepLoop();
}
else
{
engine.GameLoop = false;
engine.EngineLoop = false;
//engine.SweepLoop = false;
db.Save();
_segregLoop.StopGameLoop();
_segregLoop.StopEngineLoop();
// _segregLoop.StopSweepLoop();
}
}
}
/// <summary>
/// Request a ping of a specific client
/// </summary>
/// <param name="accessCode">The access code</param>
/// <returns></returns>
public async Task Ping(string accessCode)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
var player = db.Players.FirstOrDefault(p => p.AccessCode.Substring(0, 8).Equals(accessCode, StringComparison.OrdinalIgnoreCase));
if (player != null)
{
await Clients.Client(player.ConnectionId).ping();
}
// Report back
Clients.Caller.chatMessage("Sent ping to player " + accessCode);
await HubMessageAsync(0, "admin", "HubPing", "Ping", stopwatch.ElapsedMilliseconds, 1);
}
}
/// <summary>
/// Fires when a client reconnects to the hub
/// </summary>
public override Task OnReconnected()
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Set connected true and return player
var player = db.Player.SetConnectionStatus(Context.ConnectionId, true);
if (player != null)
{
HubMessage(0, player.AccessCode, player.AccessCode.Substring(0, 8) + " reconnected", "OnReconnected", stopwatch.ElapsedMilliseconds, 1);
}
}
return base.OnReconnected();
}
/// <summary>
/// Move or recruit players from
/// </summary>
/// <param name="originGrid">Origin grid to take from</param>
/// <param name="destinationGrid">Destination grid to move to</param>
/// <param name="playerCount">Number of players to recruit or move</param>
/// <param name="pId">A Player Id (connection id or player id)</param>
/// <param name="url">Url to navigate to</param>
public Task GridRecruit(int originGridId, int destinationGridId, int playerCount, string url)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Define url for movement target
if (string.IsNullOrEmpty(url))
{
url = db.Grid.GetUrl(_segregLoop.Engine, destinationGridId);
}
// Get the required experience level
var destGrid = db.Grids.FirstOrDefault(g => g.GridId == destinationGridId);
if (destGrid == null)
{
// Report back
return HubMessage(destinationGridId, "admin", "HubGridRecruit: Destination grid not found.", "GridRecruit", stopwatch.ElapsedMilliseconds, 1);
}
// Count players in origin grid
if (db.Player.PlayerCountByGrid(destGrid) < playerCount)
{
// Report back
return HubMessage(destinationGridId, "admin", "HubGridRecruit: Not enough players in origin grid.", "GridRecruit", stopwatch.ElapsedMilliseconds, 1);
}
else
{
// Recruit players
var recruited = db.Player.RecruitPlayers(originGridId, destinationGridId, playerCount);
// Loop over all players
foreach (var player in recruited)
{
// Setup url
var url2 = url + "?a=" + player.AccessCode;
if (_segregLoop.Engine.Testing) url2 += "&test";
// Navigate to correspondig url
Clients.Client(player.ConnectionId).navigate(url2);
}
// Report back
return HubMessage(destinationGridId, "admin", "HubGridRecruit", "GridRecruit", stopwatch.ElapsedMilliseconds, 1);
}
}
}
/// <summary>
/// Fires when a client disconnects from the hub
/// </summary>
public override Task OnDisconnected(bool stopCalled)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Set connected false and return player
var player = db.Player.SetConnectionStatus(Context.ConnectionId, false);
if (player != null)
{
// Check if player is playing a game, i.e. he is in a non-static, running grid
if(!player.Grid.IsStatic & player.Grid.GridState == 5)
{
HubMessage(0, player.AccessCode, "*** Disconnect Exception: Player " + player.AccessCode.Substring(0, 8) + " left the game while Grid is running.", "OnDisconnected", stopwatch.ElapsedMilliseconds, 1);
}
HubMessage(0, player.AccessCode, player.AccessCode.Substring(0, 8) + " disconnected", "OnDisconnected", stopwatch.ElapsedMilliseconds, 2);
}
}
return base.OnDisconnected(stopCalled);
}
/// <summary>
/// Move a single player between grids
/// </summary>
/// <param name="playerId">Player Id or Access code start segment</param>
/// <param name="destinationGrid">Destination grid id or grid guid to move to</param>
/// <param name="url">Url to navigate to</param>
public Task GridMove(string playerGuid, string destinationGrid, string url)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
var player = db.Player.GetByAnyId(playerGuid.Trim());
var grid = db.Grid.GetByAnyId(destinationGrid);
if (player != null)
{
// Set ids
int playerId = player.PlayerId;
int gridId = 1;
if (grid != null)
{
gridId = grid.GridId;
// Define url for movement target
if (string.IsNullOrEmpty(url)) url = db.Grid.GetUrl(_segregLoop.Engine, gridId);
}
// Reformat Url
var context = Context.Request.GetHttpContext();
if (url.IndexOf("~/") >= 0) url = url.Replace("~/", context.Request.ApplicationPath + "/");
// If url not starts with http, add access code for local redirects
if (url.IndexOf("http") < 0) url += "/" + player.AccessCode;
// Change grid in db
db.Grid.MovePlayer(playerId, gridId, null);
// Navigate
Clients.Client(player.ConnectionId).navigate(url);
//Report back
return HubMessage(gridId, "admin", "HubGridMove: " + url, "GridMove", stopwatch.ElapsedMilliseconds, 1);
}
}
return null;
}
/// <summary>
/// Starts a new grid in a group of chained grids
/// </summary>
public Task StartChain()
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Start the chain
db.Grid.StartChain();
// Report back
return HubMessage(0, "admin", "HubStartChain", "StartChain", stopwatch.ElapsedMilliseconds, 1);
}
}
/// <summary>
/// Player is ready
/// </summary>
public Task Ready(bool timeout)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Save choice
db.Player.SetReady(Context.ConnectionId, true, timeout);
// Get AccessCode and Grid
string accessCode = "";
int gridId = 0;
var player = db.Players.FirstOrDefault(p=>p.ConnectionId == Context.ConnectionId);
if(player != null)
{
accessCode = player.AccessCode;
gridId = player.GridId;
}
var message = db.Player.GetShortAccessCode(Context.ConnectionId) + " is ready";
return HubMessageAsync(gridId, accessCode, message, "Ready", stopwatch.ElapsedMilliseconds, 2);
}
}
//Ctor
public PowerShellController(PersistedRepository repo)
{
db = repo;
}
/// <summary>
/// Setup a grid from the admin web interface
/// </summary>
/// <param name="gridSettings">GridSettings object</param>
public Task GridSetup(GridSettings gridSettings)
{
using (var db = new PersistedRepository())
{
// Diagnostics
var stopwatch = new Stopwatch();
stopwatch.Start();
// Add the grid
int gridId = 0;
db.Grid.Add(gridSettings.GridName,
gridSettings.GameTypeId,
gridSettings.TreatmentTypeId,
gridSettings.RoundCount,
gridSettings.X,
gridSettings.Y,
gridSettings.PlayerCount,
gridSettings.BotCount,
gridSettings.FillFactor,
gridSettings.LowerThreshold,
gridSettings.UpperThreshold,
gridSettings.HighPayoff,
gridSettings.LowPayoff,
gridSettings.NoiseLevel,
gridSettings.RandomSeed,
gridSettings.ExchangeRate,
gridSettings.IntroTimer,
gridSettings.RoundTimer,
gridSettings.SummaryTimer,
gridSettings.EntryGrid,
gridSettings.ExitGrid,
gridSettings.PlayedMGames,
gridSettings.PlayedTGames,
gridSettings.Chained,
out gridId);
// Report back
return HubMessage(gridId, "admin", "HubGridSetup", "GridSetup", stopwatch.ElapsedMilliseconds, 1);
}
}
