public void ClientDisconnectedThrowGame(string currentPlayer, string opponent, string whosOut)
{
try
{
Tuple <string, string> thisGamePlayers = Tuple.Create(currentPlayer, opponent);
Game theGame = null;
if (_games.ContainsKey(thisGamePlayers))
{
theGame = _games[thisGamePlayers];
_games.Remove(thisGamePlayers);
}
using (var ctx = new FourinrowDBContext())
{
var removeGameNow = (from gdw in ctx.GameDetailsNows
where ((gdw.User1Name == currentPlayer && gdw.User2Name == opponent) ||
(gdw.User1Name == opponent && gdw.User2Name == currentPlayer))
select gdw).FirstOrDefault();
if (removeGameNow != null)
{
ctx.GameDetailsNows.Remove(removeGameNow);
ctx.SaveChanges();
}
string winnerName = whosOut == currentPlayer ? opponent : currentPlayer;
UpdatePointAndHistory(currentPlayer, opponent, winnerName, theGame, ctx);
ctx.SaveChanges();
string player2Notify = whosOut == currentPlayer ? opponent : currentPlayer;
if (ConnectedClient.ContainsKey(player2Notify))
{
new Thread(() =>
{
Clients[player2Notify].OpponentDisconnectedThrowGameYouWon();
}).Start();
}
if (_clientsThatNotPlay.Contains(player2Notify))
{
return;
}
_clientsThatNotPlay.Add(player2Notify);
}
}
catch (DbException ex)
{
throw new FaultException <DbException>(ex);
}
catch (Exception ex)
{
throw new FaultException <Exception>(ex);
}
}
public void ClientRegistered(string userName, string hashedPasswd)
{
if (Clients.ContainsKey(userName))
{
throw new FaultException <UserExistsFault>(new UserExistsFault()
{
Details = "User name " + userName + " already exists. Try something else"
});
}
using (var ctx = new FourinrowDBContext())
{
var user = (from u in ctx.Users
where u.UserName == userName
select u).FirstOrDefault();
if (user == null)
{
User newUser = new User()
{
UserName = userName,
HashedPassword = hashedPasswd
};
ctx.Users.Add(newUser);
ctx.SaveChanges();
}
++NumClients;
IFourRowServiceCallback callbackChannel = OperationContext.Current.GetCallbackChannel <IFourRowServiceCallback>();
Clients.Add(userName, callbackChannel);
}
}
private void UpdatePointAndHistory(
string currentPlayer,
string opponent,
string winnerName,
Game theGame,
FourinrowDBContext ctx)
{
Tuple <int, int> points = theGame.CalcPoints(currentPlayer, opponent, winnerName);
DateTime endGameDate = DateTime.Now;
GameDetail updateGameHistory = (from gd in ctx.GameDetails
where ((gd.User1Name == currentPlayer && gd.User2Name == opponent &&
gd.PointsUser1 == -1 && gd.PointsUser2 == -1) ||
(gd.User1Name == opponent && gd.User2Name == currentPlayer &&
gd.PointsUser1 == -1 && gd.PointsUser2 == -1))
select gd).FirstOrDefault();
if (updateGameHistory == null)
{
return;
}
updateGameHistory.WinningUserName = winnerName;
updateGameHistory.PointsUser1 = points.Item1;
updateGameHistory.PointsUser2 = points.Item2;
updateGameHistory.GameDateEnd = endGameDate;
ctx.SaveChanges();
}
private void WinOrDraw(
string currentPlayer,
string opponent,
Game theGame,
MoveResult result,
string whoMoved)
{
using (FourinrowDBContext ctx = new FourinrowDBContext())
{
GameDetailsNow gameDetailsNow = (from gdn in ctx.GameDetailsNows
where ((gdn.User1Name == currentPlayer && gdn.User2Name == opponent) ||
(gdn.User1Name == opponent && gdn.User2Name == currentPlayer))
select gdn).FirstOrDefault();
if (gameDetailsNow != null)
{
ctx.GameDetailsNows.Remove(gameDetailsNow);
ctx.SaveChanges();
}
string winnerName = result == MoveResult.Draw ? "draw" : whoMoved;
UpdatePointAndHistory(currentPlayer, opponent, winnerName, theGame, ctx);
ctx.SaveChanges();
}
}
public bool ClearUsers()
{
try
{
using (var ctx = new FourinrowDBContext())
{
string res = "elements: ";
int cnt = 0;
var x = (from u in ctx.Users
select u); // clear db
foreach (var item in x)
{
if (item.UserName != null)
{
res += item.UserName + " ";
}
cnt++;
if (x.FirstOrDefault() == null)
{
break;
}
ctx.Users.Remove(item);
//ctx.SaveChanges();
}
MessageBox.Show(res + " element count: " + cnt.ToString());
ctx.SaveChanges();
var x1 = (from u in ctx.Users
orderby u.UserName descending
select u).FirstOrDefault();
if (x1 == null)
{
Clients.Clear();
return(true);
}
}
}
catch (DbException dex)
{
throw new FaultException <DbException>(dex);
}
catch (Exception ex)
{
throw new FaultException <Exception>(ex);
}
return(false);
}
public void OpponentAcceptToPlay(string currentPlayer, string opponent)
{
try
{
if (!(Clients.ContainsKey(currentPlayer) && Clients.ContainsKey(opponent)))
{
return;
}
if (_clientsThatNotPlay.Contains(currentPlayer))
{
_clientsThatNotPlay.Remove(currentPlayer);
}
if (_clientsThatNotPlay.Contains(opponent))
{
_clientsThatNotPlay.Remove(opponent);
}
Tuple <string, string> thisGamePlayers = Tuple.Create(currentPlayer, opponent);
if (_sideModeClients.Contains(thisGamePlayers))
{
_sideModeClients.Remove(thisGamePlayers);
}
if (!_games.ContainsKey(thisGamePlayers))
{
_games.Add(thisGamePlayers, new Game());
}
using (var ctx = new FourinrowDBContext())
{
ctx.GameDetailsNows.Add(new GameDetailsNow()
{
User1Name = currentPlayer,
User2Name = opponent,
GameDateStart = DateTime.Now
});
ctx.SaveChanges();
ctx.GameDetails.Add(new GameDetail()
{
User1Name = currentPlayer,
User2Name = opponent,
WinningUserName = "******",
PointsUser1 = -1,
PointsUser2 = -1,
GameDateStart = DateTime.Now,
GameDateEnd = DateTime.Now
});
ctx.SaveChanges();
}
if (ConnectedClient.ContainsKey(currentPlayer))
{
Thread updateOtherPlayerThread = new Thread(() =>
{
Clients[currentPlayer].OpponentAcceptToPlayLetsStart();
}
);
updateOtherPlayerThread.Start();
}
if (ConnectedClient.ContainsKey(opponent))
{
Thread updateOtherPlayerThread = new Thread(() =>
{
Clients[opponent].LetsStart();
}
);
updateOtherPlayerThread.Start();
}
}
catch (DbException ex)
{
throw new FaultException <DbException>(ex);
}
catch (Exception ex)
{
throw new FaultException <Exception>(ex);
}
}