public async Task ProcessInviteToParty(ConnectedUser usr, InviteToParty msg)
{
ConnectedUser target;
if (server.ConnectedUsers.TryGetValue(msg.UserName, out target))
{
if (target.Ignores.Contains(usr.Name)) return;
var myParty = GetParty(usr.Name);
var targetParty = GetParty(target.Name);
if ((myParty != null) && (myParty == targetParty)) return;
RemoveOldInvites();
var partyInvite = partyInvites.FirstOrDefault(x => (x.Inviter == usr.Name) && (x.Invitee == target.Name));
if (partyInvite == null)
{
partyInvite = new PartyInvite()
{
PartyID = myParty?.PartyID ?? Interlocked.Increment(ref partyCounter),
Inviter = usr.Name,
Invitee = target.Name
};
partyInvites.Add(partyInvite);
}
await
target.SendCommand(new OnPartyInvite()
{
PartyID = partyInvite.PartyID,
UserNames = myParty?.UserNames?.ToList() ?? new List<string>() { usr.Name },
TimeoutSeconds = inviteTimeoutSeconds
});
}
}
protected void UpdateUser(PacketHeader header, Connection connection, UserInfo userInfo)
{
ConnectedUser senderUser = server.GetConnectedUser(connection);
senderUser.user.avatar = userInfo.avatar;
senderUser.user.comment = userInfo.comment;
senderUser.user.status = userInfo.status;
senderUser.user.name = userInfo.name;
server.accountManager.UpdateAccount(userInfo.id, userInfo.name, userInfo.comment, userInfo.avatar);
if (!Config.Properties.AVATAR_ENABLE)
{
senderUser.user.avatar = "";
}
else
{
Uri baseUri = new Uri(Config.Properties.AVATAR_IMAGE_URL);
Uri address = new Uri(baseUri, userInfo.avatar);
senderUser.user.avatar = address.ToString();
}
server.SendPersonalUserUpdate(connection, senderUser.user);
server.SendUpdateToUsersContactList(connection, senderUser.user);
}
public void Delete(int userId)
{
ConnectedUser connectedUser = context.ConnectedUsers.Where(c => c.UserId == userId).FirstOrDefault();
context.ConnectedUsers.Remove(connectedUser);
context.SaveChanges();
}
public void SomeoneIsConnecting(string IPaddress, string Name)
{
ConnectedUser tmp = new ConnectedUser();
tmp.Ip = IPaddress;
tmp.Name = Name;
tmp.MyNumber = connectedUsers.Count + 1;
tmp.HasControl = false;
MTObservableCollection <ConnectedUser> newList = new MTObservableCollection <ConnectedUser>();
newList = connectedUsers;
newList.Add(tmp);
connectedUsers = new MTObservableCollection <ConnectedUser>();
connectedUsers = newList;
this.RaisePropertyChanged("ConnectedUsers");
SocketMessage socketMessage = new SocketMessage();
socketMessage.Port = (listenerSockets.Count + 12001).ToString();
socketMessage.MessageType = "PortInformation";
talkerSocket = new TalkerSocket(IPaddress, ClientUnderlyingListenerPort);
ListenerSocket newListenSocket = new ListenerSocket(Int32.Parse(socketMessage.Port), this);
listenerSockets.Add(newListenSocket);
listenerSockets.ElementAt(listenerSockets.Count - 1).StartListening();
talkerSocket.sendData(socketMessage);
viewShouldUpdate = true;
}
public async Task ProcessPartyInviteResponse(ConnectedUser usr, PartyInviteResponse response)
{
RemoveOldInvites();
if (response.Accepted)
{
var inv = partyInvites.FirstOrDefault(x => x.PartyID == response.PartyID);
if ((inv != null) && (inv.Invitee == usr.Name))
{
var inviterParty = parties.FirstOrDefault(x => x.PartyID == response.PartyID);
var inviteeParty = parties.FirstOrDefault(x => x.UserNames.Contains(usr.Name));
Party party = null;
if ((inviterParty == null) && (inviteeParty != null)) party = inviteeParty;
if ((inviterParty == null) && (inviteeParty == null))
{
party = new Party(inv.PartyID);
parties.Add(party);
}
if ((inviterParty != null) && (inviteeParty == null)) party = inviterParty;
if ((inviterParty != null) && (inviteeParty != null))
{
await RemoveFromParty(inviterParty, inv.Invitee);
party = inviterParty;
}
await AddToParty(party, inv.Invitee, inv.Inviter);
}
}
}
private async Task NotifyUser(string playgroundId, PlaygroundReservation acceptedReservation, string msg)
{
// creating a new message and saving it to the database
var sentMsg = _messageRepository.PostMessage(new Message
{
Body = msg,
MessageDate = DateTime.Now,
ReceiverId = acceptedReservation.UserId,
SenderId = playgroundId
});
var playground = await _userManager.GetUserAsync(User);
// getting the user that made the reservation request
// then we change the status of his mesages to true
ApplicationUser receiver = _userRepository.GetUserById(acceptedReservation.UserId);
_userRepository.ChangeMsgsStatus(receiver, true);
// getting the conId of the reserver user and see if he is online
// if so, i will send a the message in real time
ConnectedUser receiverConnectedUser = _connectedUsersRepository.GetConnectionIdOfUser(acceptedReservation.UserId);
if (receiverConnectedUser != null)
{
await _hubContext.Clients.Client(receiverConnectedUser.ConnectionId).SendAsync("recMsg", sentMsg.Body, playgroundId, playground.UserName, sentMsg.MessageDate.ToString("dd/MM/yyyy hh:mm:ss tt"));
}
}
public static void PollSocket(this ConnectedUser connectedUser, ITcpMessageProcessorCache tcpMessageProcessorCache)
{
if (!connectedUser.TcpClient.Connected)
{
return;
}
var stream = connectedUser.TcpClient.GetStream();
if (!stream.CanRead || !stream.DataAvailable)
{
return;
}
var prefixBuffer = new byte[4];
var messageTypeBuffer = new byte[1];
stream.Read(prefixBuffer, 0, 4);
stream.Read(messageTypeBuffer, 0, 1);
var length = BitConverter.ToInt32(prefixBuffer, 0);
var buffer = new byte[length];
stream.Read(buffer, 0, length);
var processor = tcpMessageProcessorCache.GetApplicableProcessor((MessageType)messageTypeBuffer.First());
processor.Execute(connectedUser, Encoding.ASCII.GetString(buffer));
}
private static UserSessionNavigation ToUserSessionNavigation(ConnectedUser user)
{
return(new(
user.Id,
user.IsAdmin
));
}
public async Task <IActionResult> KickStart(ConnectedUser user)
{
if (await _redisHandler.IsCached("Userlist:ConnectedUser"))
{
var users = JsonConvert.DeserializeObject <List <ConnectedUser> >(await _redisHandler.GetFromCache("Userlist:ConnectedUser"));
var cuser = users.FirstOrDefault(x => x.ConnectionId == user.ConnectionId);
var req = new
{
Username = cuser.Username,
ConnectionId = cuser.ConnectionId,
};
await _hubContext.Clients.Group(cuser.ConnectedRoomName).SendAsync("KickStart", req);
return(await Task.FromResult(Ok(req)));
}
var data = await _connectedUserRepository.FirstOrDefault(x => x.ConnectionId == user.ConnectionId);
if (data != null)
{
var req = new
{
Username = data.Username,
ConnectionId = data.ConnectionId,
};
await _hubContext.Clients.Group(data.ConnectedRoomName).SendAsync("KickStart", req);
return(await Task.FromResult(Ok(req)));
}
return(await Task.FromResult(Ok(false)));
}
public bool IsStudentEnrolled(int id, string surname)
{
ConnectedUser connectedUser = connectedUsers.FirstOrDefault(u => u.Id == id);
if (connectedUser != null)
{
List <Student> students = Reader.ReaderTextFile.Read("../../../Students_Information.txt");
if (students != null)
{
if (students.Count == 0 || students.FirstOrDefault(s => s.Surname == surname) == null)
{
return(false);
}
else
{
return(true);
}
}
else
{
connectedUser.CallBack.ShowErrorMessage("Could not read from file");
return(false);
}
}
return(false);
}
public ActionResult Login(User givenUser)
{
string captchaString = Session["Crntcapthca"].ToString().ToLower();
if (givenUser.Capthca.ToLower() != captchaString)
{
ModelState.AddModelError("", "Captcha Validation Failuer");
givenUser.Capthca = "";
return(View(givenUser));
}
else
{
ConnectedUser connectedUser = null;
if (UserManipulations.ifUserExists(givenUser.email, givenUser.password, out connectedUser) > 0)
{
connectedUser.sessionStartedTime = DateTime.Now.ToLocalTime().ToString();
Session["userdata"] = connectedUser;
FormsAuthentication.SetAuthCookie(givenUser.email, true);
return(RedirectToAction("index", "myprtctd"));
}
ModelState.AddModelError("", "Invalide Username or Password");
}
return(View(givenUser));
}
public async Task <IActionResult> Edit(Guid id, [Bind("ConnectedUserId,BaseUserId,FriendUserId")] ConnectedUser connectedUser)
{
if (id != connectedUser.ConnectedUserId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(connectedUser);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConnectedUserExists(connectedUser.ConnectedUserId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["BaseUserId"] = new SelectList(_context.Users, "UserId", "Email", connectedUser.BaseUserId);
ViewData["FriendUserId"] = new SelectList(_context.Users, "UserId", "Email", connectedUser.FriendUserId);
return(View(connectedUser));
}
public ActionResult EditUser(HttpPostedFileBase loginpicture, User user)
{
String sessionTimeOut = ((ConnectedUser)Session["userdata"]).sessionStartedTime;
user.imageFileName = loginpicture;
ConnectedUser connectedUser = null;
int userNumber = UserManipulations.editUser(user, out connectedUser);
if (userNumber > 0)
{
connectedUser.sessionStartedTime = sessionTimeOut;
Session["userdata"] = connectedUser;
//FormsAuthentication.SetAuthCookie(userNumber.ToString(), true);
return(RedirectToAction("index", "myprtctd"));
}
else if (userNumber == 0)
{
ModelState.AddModelError("userLogin", "this login Already Exist");
}
else
{
ModelState.AddModelError("", "Failed to update given user.");
}
return(View(user));
}
protected void DeleteContact(PacketHeader header, Connection connection, string userID)
{
ConnectedUser senderUser = server.GetConnectedUser(connection);
ConnectedUser targetUser = null;
Connection targetConnection = server.GetConnectionFromUserID(userID);
if (targetConnection != null)
{
targetUser = server.GetConnectedUser(targetConnection);
}
else
{
targetUser = new ConnectedUser(server.accountManager.GetUser(userID), new ContactList(
server.accountManager.GetContacts(userID)));
}
senderUser.contactList.RemoveUser(userID);
targetUser.contactList.RemoveUser(senderUser.user.id);
server.accountManager.SaveContactData(senderUser.user.id, senderUser.contactList.CreateData());
server.accountManager.SaveContactData(targetUser.user.id, targetUser.contactList.CreateData());
server.SendDeleteContact(connection, targetUser.user);
if (targetConnection != null)
{
UserInfo offlineUser = new UserInfo(senderUser.user.id, senderUser.user.name, senderUser.user.comment,
(int)UserStatus.Offline, senderUser.user.avatar, senderUser.user.blocked);
server.SendDeleteContact(targetConnection, senderUser.user);
}
}
public async Task <IActionResult> KickVoteNo(ConnectedUser user)
{
if (!(await _redisHandler.IsCached($"kicklist:{user.Username}")))
{
var data = new RoomVote
{
Yes = 0,
Username = user.Username,
No = 1,
Id = user.Id
};
await _redisHandler.AddToCache($"kicklist:{user.Username}", TimeSpan.FromMinutes(5), JsonConvert.SerializeObject(data));
}
else
{
var kick = JsonConvert.DeserializeObject <RoomVote>(await _redisHandler.GetFromCache($"kicklist:{user.Username}"));
kick.No += 1;
//CACHE GÜNCELLEMİYOR
await _redisHandler.RemoveFromCache($"kicklist:{user.Username}");
await _redisHandler.AddToCache($"kicklist:{user.Username}", TimeSpan.FromMinutes(5), JsonConvert.SerializeObject(kick));
return(await Task.FromResult(Ok(true)));
}
return(await Task.FromResult(Ok(false)));
}
public static bool SetUserIsReady(ConnectedUser currentUser, ref string firstConnectionId, ref string secondConnectionId)
{
if (!CheckUserIsConnected(currentUser.User.Id))
{
return(false);
}
if (GetMatchByUser(currentUser) == null)
{
return(false);
}
if (_matchedUsers.Where(x => x.SecondUser != null).FirstOrDefault(x => x.FirstUser.User.Id == currentUser.User.Id) != null)
{
var match = _matchedUsers.Where(x => x.SecondUser != null).FirstOrDefault(x => x.FirstUser.User.Id == currentUser.User.Id);
firstConnectionId = match.FirstUser.ConnectionId;
secondConnectionId = match.SecondUser.ConnectionId;
_matchedUsers.Where(x => x.SecondUser != null).FirstOrDefault(x => x.FirstUser.User.Id == currentUser.User.Id).FirstUserIsReady = true;
return(true);
}
else if (_matchedUsers.Where(x => x.SecondUser != null).FirstOrDefault(x => x.SecondUser.User.Id == currentUser.User.Id) != null)
{
var match = _matchedUsers.Where(x => x.SecondUser != null).FirstOrDefault(x => x.SecondUser.User.Id == currentUser.User.Id);
firstConnectionId = match.FirstUser.ConnectionId;
secondConnectionId = match.SecondUser.ConnectionId;
_matchedUsers.Where(x => x.SecondUser != null).FirstOrDefault(x => x.SecondUser.User.Id == currentUser.User.Id).SecondUserIsReady = true;
return(true);
}
return(false);
}
public void Join(string login, int sideSizeNeed)
{
ICallBackClient callBackClient = OperationContext.Current.GetCallbackChannel <ICallBackClient>();
connectedUser = new ConnectedUser {
CallBack = callBackClient, Login = login
};
if (connectedUsers.Count == 0)
{
connectedUser.Status = "player №1";
sideSize = sideSizeNeed;
CreateArrayMoves();
callBackClient.CreateButtons(sideSize);
}
else if (connectedUsers.Count == 1)
{
connectedUser.Status = "player №2";
callBackClient.CreateButtons(sideSize);
callBackClient.PrintAllMove(moves);
}
else
{
connectedUser.Status = $"observer №{connectedUsers.Count - 1}";
callBackClient.CreateButtons(sideSize);
callBackClient.DisableAllButtons();
callBackClient.PrintAllMove(moves);
}
connectedUsers.Add(connectedUser);
callBackClient.SetStatus(connectedUser.Status);
foreach (ConnectedUser u in connectedUsers)
{
u.CallBack.PrintNameClients(GetUsersList());
}
}
public async Task <IActionResult> KickStatus(ConnectedUser user)
{
var kick = JsonConvert.DeserializeObject <RoomVote>(await _redisHandler.GetFromCache($"kicklist:{user.Username}"));
if (kick != null)
{
if (Math.Abs(kick.Yes - kick.No) == 1)
{
await _redisHandler.RemoveFromCache($"kicklist:{user.Username}");
return(await Task.FromResult(Ok("Atılma işlemi olmadı")));
}
else
{
if (kick.Yes > kick.No)
{
await _redisHandler.RemoveFromCache($"kicklist:{user.Username}");
await _hubContext.Clients.Client(user.ConnectionId).SendAsync("KickedFromRoom", true);
return(await Task.FromResult(Ok("Atılma işlemi gerçekleşti")));
}
}
}
await _redisHandler.RemoveFromCache($"kicklist:{user.Username}");
return(await Task.FromResult(Ok("Atılma işlemi olmadı")));
}
public ActionResult adduser(HttpPostedFileBase loginpicture, User user)
{
//Captcha Validation:
if (user.Capthca.ToLower() != Session["Crntcapthca"].ToString().ToLower())
{
ModelState.AddModelError("", "Captcha Validation Failuer");
user.Capthca = "";
return(View(user));
}
user.imageFileName = loginpicture;
ConnectedUser connectedUser = null;
int userNumber = UserManipulations.addUser(user, out connectedUser);
if (userNumber > 0)
{
connectedUser.sessionStartedTime = DateTime.Now.ToLocalTime().ToString();
Session["userdata"] = connectedUser;
FormsAuthentication.SetAuthCookie(userNumber.ToString(), true);
return(RedirectToAction("index", "myprtctd"));
}
else if (userNumber == 0)
{
ModelState.AddModelError("userLogin", "this login Already Exist");
}
else
{
ModelState.AddModelError("", "problem during trying to reach the DB");
}
return(View(user));
}
private void AddInformationToTextFile(ConnectedUser connectedUser)
{
if (Writer.WriterTextFile.Write("../../../Students_Information.txt", connectedUser.Student) != null)
{
connectedUser.CallBack.ShowErrorMessage("Could not write into file");
}
}
public void Login(NetworkPlayer np, User user)
{
ConnectedUser uc = new ConnectedUser();
uc.networkPlayer = np;
uc.user = user;
players.Add(np, uc);
users.Add(user.Username, uc);
}
/// <summary>
/// New connection starting point
/// </summary>
protected override void OnOpen()
{
base.OnOpen();
myUser = new ConnectedUser(this.Context);
logger.Info($"Connection received from {GetLogIdentifier()}");
}
public async Task Disconnect(string userId)
{
ConnectedUser user = GetByUserId(userId);
_database.Context.ConnectedUsers.Remove(user);
await _database.SaveAsync();
}
public void userChat(ConnectedUser sender, string message, string userName)
{
sendChat(sender._UserID, message, userName);
foreach (RoomBot Bot in _Bots.Values)
{
Bot.DoChat(message, sender);
}
}
public async Task UpdateConnection(ConnectedUser user, string connection)
{
user.Connection = connection;
_database.Context.ConnectedUsers.Update(user);
await _database.SaveAsync();
}
public void AddUser(int dbId, string connectionId, string name, string osp)
{
if (ConnectedUsers.FindAll(x => x.ConnectionId == connectionId).Count == 0)
{
var connectedUser = new ConnectedUser(dbId, connectionId, name, osp);
ConnectedUsers.Add(connectedUser);
}
}
public void Leave(int id)
{
ConnectedUser connectedUser = connectedUsers.FirstOrDefault(u => u.Id == id);
if (connectedUser != null)
{
connectedUsers.Remove(connectedUser);
}
}
public static string IsPiloto()
{
ConnectedUser connUser = Utils.getConnectedUser();
var objAcceso = new DBOAcceso();
var result = objAcceso.IsPiloto(connUser.userName);
return(result);
}
private void EstablishKeepAliveFor(ConnectedUser connectedUser)
{
var client = connectedUser.TcpClient.Client;
client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
const uint time = 1000;
const uint interval = 2000;
BuildKeepAliveValues(client, true, time, interval);
}
// Method executes 'Add User' procedure:
public static int addUser(User user, out ConnectedUser connectedUser)
{
byte[] data = null;
int finalResult = 0;
ConnectedUser tempUser = null;
SqlConnection cnctn = null;
SqlCommand cmd = new SqlCommand();
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "addUser";
if (null != user.imageFileName)
{
MemoryStream target = new MemoryStream();
user.imageFileName.InputStream.CopyTo(target);
data = target.ToArray();
cmd.Parameters.Add("@userUserpicture", System.Data.SqlDbType.VarBinary, -1).Value = data;
}
cmd.Parameters.Add("@userEmail", System.Data.SqlDbType.NVarChar, 254).Value = user.email;
cmd.Parameters.Add("@userActualname", System.Data.SqlDbType.NVarChar, 60).Value = user.realname;
cmd.Parameters.Add("@userPassword", System.Data.SqlDbType.VarBinary, 60).Value = GlobalFunctions.getEncriptedPassword(user.password);
try
{
cnctn = new SqlConnection(GlobalFunctions.getConnectionString());
cmd.Connection = cnctn;
cnctn.Open();
int rc = cmd.ExecuteNonQuery();
if (rc == 1)
{
finalResult = getUserNumber(user.email);
tempUser = new ConnectedUser(finalResult, user.email, user.realname);
if (null != data)
{
tempUser.userPicture = data;
}
}
else
{
tempUser = null;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
if (cnctn != null)
{
cnctn.Close();
}
}
connectedUser = tempUser;
return(finalResult);
}
protected void Transfer(PacketHeader header, Connection connection, string userID)
{
Connection targetUserConnection = server.GetConnectionFromUserID(userID);
ConnectedUser senderUser = server.GetConnectedUser(connection);
if (targetUserConnection != null)
{
server.SendPacket(targetUserConnection, PacketName.sendNudge.ToString(), senderUser.user.id);
}
}
public static Ejecutivo ObtieneDatosEjecutivo()
{
ConnectedUser connUser = Utils.getConnectedUser();
var objDocumentos = new DBOSolicitudes();
var objEjecutivo = objDocumentos.ObtenerDatosEjecutivo(connUser.userName);
return(objEjecutivo);
}
public async Task OnJoinPlanet(ConnectedUser conus, PwJoinPlanet args)
{
if (GlobalConst.PlanetWarsMode == PlanetWarsModes.Running)
{
if (conus.User.CanUserPlanetWars())
{
await JoinPlanet(conus.Name, args.PlanetID);
}
}
}
private void EstablishKeepAliveFor(ConnectedUser connectedUser)
{
var client = connectedUser.TcpClient.Client;
client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
const uint time = 1000;
const uint interval = 2000;
BuildKeepAliveValues(client, true, time, interval);
}
public void Execute(ConnectedUser connectedUser, string jsonMessage)
{
var loginModel = JsonConvert.DeserializeObject<LoginModel>(jsonMessage);
if (loginModel != null)
{
connectedUser.Player = new Player { User = new User { Username = loginModel.Username, Password = loginModel.Password } };
EstablishKeepAliveFor(connectedUser);
Console.WriteLine("User: {0} with password of {1} has logged in with the following identifier: {2}.", loginModel.Username, loginModel.Password,
connectedUser.Identifier);
}
}
// Method executes 'Edit User' procedure:
public static int editUser(User user, out ConnectedUser connectedUser)
{
byte[] data = null;
int finalResult = 0;
ConnectedUser tempUser = null;
SqlConnection cnctn = null;
SqlCommand cmd = new SqlCommand();
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "editUser";
if (null != user.imageFileName)
{
MemoryStream target = new MemoryStream();
user.imageFileName.InputStream.CopyTo(target);
data = target.ToArray();
cmd.Parameters.Add("@userUserpicture", System.Data.SqlDbType.VarBinary, -1).Value = data;
}
cmd.Parameters.Add("@userEmail", System.Data.SqlDbType.NVarChar, 254).Value = user.email;
cmd.Parameters.Add("@userActualname", System.Data.SqlDbType.NVarChar, 60).Value = user.realname;
cmd.Parameters.Add("@userPassword", System.Data.SqlDbType.VarBinary, 60).Value = GlobalFunctions.getEncriptedPassword(user.password);
try
{
cnctn = new SqlConnection(GlobalFunctions.getConnectionString());
cmd.Connection = cnctn;
cnctn.Open();
int rc = cmd.ExecuteNonQuery();
if (rc == 1)
{
finalResult = getUserNumber(user.email);
tempUser = new ConnectedUser(finalResult, user.email, user.realname);
if (null != data)
{
tempUser.userPicture = data;
}
}
else
{ tempUser = null; }
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
if (cnctn != null)
cnctn.Close();
}
connectedUser = tempUser;
return finalResult;
}
int PlayerRoll(ConnectedUser user)
{
int roll = rnd.Next(1000) + 1;
ConnectedUser lastLoser = PrevUsers.OrderBy(x => x.RollNumber).FirstOrDefault();
if (lastLoser != null && user.Name == lastLoser.Name)
{
int bonusroll = rnd.Next(1000) + 1;
SendMessage(user.Name + " gets bonus roll for losing!");
Clients.Caller.addMessage(string.Format("Roll: {0}, Bonus: {1}", roll, bonusroll));
return roll > bonusroll ? roll : bonusroll;
}
return roll;
}
public override Task OnConnected()
{
foreach (ConnectedUser connectedUser in CurrentUsers)
{
Clients.Caller.addMessage(connectedUser.Name + " has previously connected.");
}
var user = new ConnectedUser {ConnectionId = Context.ConnectionId, Name = Context.User.Identity.Name};
CurrentUsers.Add(user);
SendMessage(user.Name + " has connected.");
ResetTimer();
return base.OnConnected();
}
public async Task AreYouReadyResponse(ConnectedUser user, AreYouReadyResponse response)
{
PlayerEntry entry;
if (players.TryGetValue(user.Name, out entry))
if (entry.InvitedToPlay)
{
if (response.Ready) entry.LastReadyResponse = true;
else
{
entry.LastReadyResponse = false;
await RemoveUser(user.Name);
}
var invitedPeople = players.Values.Where(x => x?.InvitedToPlay == true).ToList();
if ((invitedPeople.Count <= 1) || invitedPeople.All(x => x.LastReadyResponse)) OnTick();
else
{
var readyCounts = CountQueuedPeople(invitedPeople.Where(x => x.LastReadyResponse));
var proposedBattles = ProposeBattles(invitedPeople.Where(x => x.LastReadyResponse));
await Task.WhenAll(invitedPeople.Select(async (p) =>
{
var invitedBattle = invitationBattles?.FirstOrDefault(x => x.Players.Contains(p));
await
server.SendToUser(p.Name,
new AreYouReadyUpdate()
{
QueueReadyCounts = readyCounts,
ReadyAccepted = p.LastReadyResponse == true,
LikelyToPlay = proposedBattles.Any(y => y.Players.Contains(p)),
YourBattleSize = invitedBattle?.Size,
YourBattleReady =
invitedPeople.Count(x => x.LastReadyResponse && (invitedBattle?.Players.Contains(x) == true))
});
}));
}
}
}
private void RemoveConnection(string connectionId, ConnectedUser user)
{
_usersByConnections.Remove(connectionId);
user.RemoveConnection(connectionId);
}
public async Task QueueRequest(ConnectedUser user, MatchMakerQueueRequest cmd)
{
var banTime = BannedSeconds(user.Name);
if (banTime != null)
{
await UpdatePlayerStatus(user.Name);
await user.Respond($"Please rest and wait for {banTime}s because you refused previous match");
return;
}
// already invited ignore requests
PlayerEntry entry;
if (players.TryGetValue(user.Name, out entry) && entry.InvitedToPlay)
{
await UpdatePlayerStatus(user.Name);
return;
}
var wantedQueueNames = cmd.Queues?.ToList() ?? new List<string>();
var wantedQueues = possibleQueues.Where(x => wantedQueueNames.Contains(x.Name)).ToList();
if (wantedQueues.Count == 0) // delete
{
await RemoveUser(user.Name, true);
return;
}
players.AddOrUpdate(user.Name,
(str) => new PlayerEntry(user.User, wantedQueues),
(str, usr) =>
{
usr.UpdateTypes(wantedQueues);
return usr;
});
// if nobody is invited, we can do tick now to speed up things
if (invitationBattles?.Any() != true) OnTick();
else await UpdateAllPlayerStatuses(); // else we just send statuses
}
// Method executes 'Login' procedure:
public static int ifUserExists(string email, string password, out ConnectedUser connectedUser)
{
int result = 0;
ConnectedUser tempUser = null;
SqlConnection cnctn = null;
SqlCommand cmd = new SqlCommand();
SqlDataReader rdr = null;
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "ifUserExists";
cmd.Parameters.Add("@userEmail", System.Data.SqlDbType.NVarChar, 254).Value = email;
try
{
cnctn = new SqlConnection(GlobalFunctions.getConnectionString());
cmd.Connection = cnctn;
cnctn.Open();
rdr = cmd.ExecuteReader();
if (rdr.Read())
{
//Check if passed password is right:
if (GlobalFunctions.checkPassword((byte[])rdr["Passowrd"], password))
{
tempUser = new ConnectedUser((int)rdr["Usernum"], email, rdr["Actualname"].ToString());
try
{
tempUser.userPicture = (byte[])rdr["Userpicture"];
}
catch { }
result = 1;
}
}
else
{
tempUser = null;
result = 0; // incorect username or password or the combination!
}
rdr.Close();
}
catch //(Exception prblm)
{
tempUser = null;
result = -1;
}
finally
{
cnctn.Close();
}
connectedUser = tempUser;
return result;
}
public void Execute(ConnectedUser connectedUser, string jsonMessage)
{
Console.WriteLine("--------------- Keep-alive messasge received. ---------------");
}
public async Task OnLoginAccepted(ConnectedUser conus)
{
await conus.SendCommand(new MatchMakerSetup() { PossibleQueues = possibleQueues });
await UpdatePlayerStatus(conus.Name);
}
public async Task ProcessLeaveParty(ConnectedUser usr, LeaveParty msg)
{
var party = parties.FirstOrDefault(x => x.PartyID == msg.PartyID);
if (party != null) await RemoveFromParty(party, usr.Name);
}
private void AddConnection(DateTime now, string connectionId, ConnectedUser user)
{
user.AddConnection(new UserConnection(connectionId, now));
_usersByConnections.Add(connectionId, user);
}
private static ChatEvent JoinsChatIfUserHasNoConnection(DateTime now, ConnectedUser user)
{
return user.Connections.Any()
? ChatEvent.NothingHappens(now)
: ChatEvent.UserJoinsChat(user.Username, now);
}
public async Task QueueRequest(ConnectedUser user, MatchMakerQueueRequest cmd)
{
var banTime = BannedSeconds(user.Name);
if (banTime != null)
{
await UpdatePlayerStatus(user.Name);
await user.Respond($"Please rest and wait for {banTime}s because you refused previous match");
return;
}
// already invited ignore requests
PlayerEntry entry;
if (players.TryGetValue(user.Name, out entry) && entry.InvitedToPlay)
{
await UpdatePlayerStatus(user.Name);
return;
}
var wantedQueueNames = cmd.Queues?.ToList() ?? new List<string>();
var wantedQueues = possibleQueues.Where(x => wantedQueueNames.Contains(x.Name)).ToList();
var party = server.PartyManager.GetParty(user.Name);
if (party != null) wantedQueues = wantedQueues.Where(x => x.MaxSize/2 >= party.UserNames.Count).ToList(); // if is in party keep only queues where party fits
if (wantedQueues.Count == 0) // delete
{
await RemoveUser(user.Name, true);
return;
}
await AddOrUpdateUser(user, wantedQueues);
}
private async Task AddOrUpdateUser(ConnectedUser user, List<MatchMakerSetup.Queue> wantedQueues)
{
var party = server.PartyManager.GetParty(user.Name);
if (party != null)
foreach (var p in party.UserNames)
{
var conUs = server.ConnectedUsers.Get(p);
if (conUs != null)
players.AddOrUpdate(p,
(str) => new PlayerEntry(conUs.User, wantedQueues, party),
(str, usr) =>
{
usr.UpdateTypes(wantedQueues);
usr.Party = party;
return usr;
});
}
else
players.AddOrUpdate(user.Name,
(str) => new PlayerEntry(user.User, wantedQueues, null),
(str, usr) =>
{
usr.UpdateTypes(wantedQueues);
usr.Party = null;
return usr;
});
// if nobody is invited, we can do tick now to speed up things
if (invitationBattles?.Any() != true) OnTick();
else await UpdateAllPlayerStatuses(); // else we just send statuses
}
private void ModifyUsersToReflectEvent(ConnectedUser user, ChatEvent chatEvent)
{
if (chatEvent.UserJoinsChat())
_users.Add(user);
if (chatEvent.UserLeavesChat())
_users.Remove(user);
}
public void Execute(ConnectedUser connectedUser, string jsonMessage)
{
Console.WriteLine("Unknown Data Received: {0}", jsonMessage);
}
