public void Send(MessageFromServer outgoingChat)
{
foreach (var user in Users)
{
user.Connection.Send(outgoingChat.ToByteArray());
}
}
public bool Registration(string username, string password)
{
MessageToServer message = new MessageToServer
{
Command = CommandToServer.ASK_REGISTRATION,
Username = username,
Password = password
};
byte[] bytes = message.EncodeMessage();
_sender.Send(bytes);
bytes = new byte[3072];
_sender.Receive(bytes);
MessageFromServer received = MessageFromServer.DecodeMessage(bytes);
if (received.Command == CommandFromServer.ACCEPTED)
{
UserInfo.Id = received.Id;
UserInfo.Name = received.Name;
UserInfo.Username = username;
return(true);
}
else
{
return(false);
}
}
internal void Reject(Socket handler)
{
MessageFromServer message = new MessageFromServer()
{
Command = CommandFromServer.REJECTED
};
handler.Send(message.EncodeMessage());
}
internal void Accept(Socket handler)
{
MessageFromServer message = new MessageFromServer()
{
Command = CommandFromServer.ACCEPTED
};
handler.Send(message.EncodeMessage());
}
internal void SearchContacts(MessageToServer receivedMessage, Socket handler)
{
MessageFromServer message = new MessageFromServer
{
Users = _database.SearchUsers(receivedMessage.Name)
};
handler.Send(message.EncodeMessage());
}
internal void GetContacts(MessageToServer receivedMessage, Socket handler)
{
MessageFromServer message = new MessageFromServer
{
Users = _database.SelectContacts(receivedMessage.Id)
};
handler.Send(message.EncodeMessage());
}
internal void LoadMessages(MessageToServer receivedMessage, Socket handler)
{
MessageFromServer message = new MessageFromServer
{
Messages = _database.SelectMessages(receivedMessage.Id, receivedMessage.TargetId)
};
handler.Send(message.EncodeMessage());
}
/// <summary>
/// Called when a command from player arrives. Login and register requests are already handled by the GCC system.
/// </summary>
/// <param name="context">Context of the message. See more at Context Serialization in our online documentation.</param>
/// <param name="command">Message class implementing IGameCommand</param>
/// <param name="playerId">Player who sends the command. GCC has filtered unauthorized or malicious requests before calling this method.</param>
public override void OnCommand(ulong connectionId, short context, IGameCommand command) //ulong connectionId, short context, IGameCommand command
{
switch (context)
{
case NetworkCommands.PLAYER_CHARACTER_STATE_CHANGE:
PlayersInGame[((PlayerCharacter)command).playerId].UpdateState((PlayerCharacter)command, false);
NotifyStateChanged(PlayersInGame[((PlayerCharacter)command).playerId]);
break;
case NetworkCommands.GET_AREA:
SendInitArea(connectionId);
foreach (PlayerCharacter plr in PlayersInGame.Values.ToList())
{
if (connectionId == plr.connectionId)
{
plr.isInGame = true;
}
}
break;
case NetworkCommands.MESSAGE_SEND:
string sender = GetMessageSender(connectionId);
MessageFromServer curr = new MessageFromServer()
{
Sender = sender, Msg = ((Message)command).Msg
};
command = curr;
//Message curr = (Message)command;
Console.WriteLine(curr.Msg);
foreach (var pl in PlayersInGame)
{
List <ulong> players = new List <ulong>();
foreach (var plr in PlayersInGame)
{
players.Add(plr.Value.connectionId);
}
SendToMultipleConnections(NetworkCommands.MESSAGE_RECIEVE, command, players);
Console.WriteLine("Message send back to clients!");
}
break;
default:
throw new InvalidOperationException(string.Format("Received not supported command:{0} context:{1}, connectionId:{2}",
command, context, connectionId));
}
}
public void AddUser(User newUser)
{
//send a join message to the room
var userJoinBroadcast = new MessageFromServer();
userJoinBroadcast.UserAction = new MessageFromServer.Types.UserAction
{
Name = newUser.Name,
ActionType = ActionType.Join
};
Send(userJoinBroadcast);
Users.Add(newUser);
}
public void RemoveUser(User leavingUser)
{
Users.Remove(leavingUser);
//broadcast to room that the user left
var userLeaveBroadcast = new MessageFromServer();
userLeaveBroadcast.UserAction = new MessageFromServer.Types.UserAction
{
Name = leavingUser.Name,
ActionType = ActionType.Leave
};
Send(userLeaveBroadcast);
}
public List <Contact> SearchContacts(string search)
{
MessageToServer message = new MessageToServer
{
Command = CommandToServer.SEARCH_CONTACTS,
Name = search
};
byte[] bytes = message.EncodeMessage();
_sender.Send(bytes);
bytes = new byte[3072];
_sender.Receive(bytes);
MessageFromServer received = MessageFromServer.DecodeMessage(bytes);
return(received.Users);
}
public List <Contact> Contacts(int id)
{
MessageToServer message = new MessageToServer
{
Command = CommandToServer.GET_CONTACTS,
Id = id
};
byte[] bytes = message.EncodeMessage();
_sender.Send(bytes);
bytes = new byte[3072];
_sender.Receive(bytes);
MessageFromServer received = MessageFromServer.DecodeMessage(bytes);
return(received.Users);
}
/// <summary>
/// Get message from server
/// </summary>
/// <param name="msg"></param>
public string GetMsg()
{
byte[] receivedBytes = new byte[128];
var size = 0;
var serverAnswer = new StringBuilder();
do
{
size = tcpSocket.Receive(receivedBytes);
serverAnswer.Append(Encoding.UTF8.GetString(receivedBytes, 0, size));
} while (tcpSocket.Available > 0);
MessageFromServer?.Invoke(serverAnswer.ToString());
tcpSocket.Shutdown(SocketShutdown.Both);
tcpSocket.Close();
return(serverAnswer.ToString());
}
internal List <Message> GetMessages(int id)
{
MessageToServer message = new MessageToServer
{
Command = CommandToServer.GET_MESSAGES,
Id = UserInfo.Id,
TargetId = id
};
byte[] bytes = message.EncodeMessage();
_sender.Send(bytes);
bytes = new byte[3072];
_sender.Receive(bytes);
MessageFromServer received = MessageFromServer.DecodeMessage(bytes);
return(received.Messages);
}
public void OnSocketMessage(IWebSocketConnection connection, byte[] data)
{
//if user has already logged in
if (joinedUsers.ContainsKey(connection))
{
var message = MessageToServer.Parser.ParseFrom(data);
var user = joinedUsers[connection];
//if message is of type Chat
if (message.MessageCase == MessageToServer.MessageOneofCase.ChatToServer)
{
var outgoingChat = new MessageFromServer();
outgoingChat.ChatFromServer = new MessageFromServer.Types.Chat
{
Name = user.Name,
Trip = user.Trip,
Text = message.ChatToServer.Text
};
Log.LogInfo($"{user.Name} @{user.Room.Name} {user.Trip} : {message.ChatToServer}");
//send message to all users in that person's room
joinedUsers[connection].Room.Send(outgoingChat);
}
}
else
{
//this is a new user joining for the first time
var joinMessage = Join.Parser.ParseFrom(data);
//the room the the new user is joining
var room = GetRoom(joinMessage.Room);
var newUser = new User(connection, joinMessage.Name, joinMessage.Password, GetRoom(joinMessage.Room));
joinedUsers.Add(connection, newUser);
room.AddUser(newUser);
//send a success response back to the new client
var joinResponse = new JoinResponse {
Success = new JoinResponseSuccessful()
};
joinResponse.Success.OnlineUsers.Add(room.Users.Select(roomUser => roomUser.Name).ToList());
Console.WriteLine("size: " + joinResponse.CalculateSize());
connection.Send(joinResponse.ToByteArray());
Log.LogInfo($"{newUser.Name} @ {newUser.Room.Name} {newUser.Trip} joined");
}
}
internal void Authorize(MessageToServer receivedMessage, Socket handler)
{
User user = _database.SelectOneUser(receivedMessage.Username);
if (user != null)
{
if (user.Password == receivedMessage.Password)
{
_connectedUsers.Add(receivedMessage.Username, handler);
MessageFromServer message = new MessageFromServer()
{
Command = CommandFromServer.ACCEPTED,
Id = user.Id,
Name = user.Name
};
handler.Send(message.EncodeMessage());
return;
}
}
Reject(handler);
}
internal void Register(MessageToServer receivedMessage, Socket handler)
{
User user = _database.SelectOneUser(receivedMessage.Username);
if (user != null)
{
Reject(handler);
}
else
{
_connectedUsers.Add(receivedMessage.Username, handler);
user = new User(receivedMessage.Username, receivedMessage.Password, receivedMessage.Username);
_database.Insert(user);
user = _database.SelectOneUser(user.Username);
MessageFromServer message = new MessageFromServer()
{
Command = CommandFromServer.ACCEPTED,
Id = user.Id,
Name = user.Name
};
handler.Send(message.EncodeMessage());
}
}
private void Update()
{
if (msgToProcess != null)
{
if (!(msgToProcess.showStore) && (msgToProcess.message != null))
{
DialogCanvasController.RequestStatusPrompt(msgToProcess.title, msgToProcess.message, () => {});
}
if ((msgToProcess.showStore) && (msgToProcess.message != null))
{
DialogCanvasController.RequestConfirmationPrompt(msgToProcess.title, msgToProcess.message,
(response) =>
{
if (response)
{
DialogCanvasController.RequestStore(PF_GameData.StandardStores[0]);
}
}
);
}
}
msgToProcess = null;
}
private void HandleOnMessageToPlayer(MessageFromServer msg)
{
msgToProcess = msg;
}
void Listen_server(object socket)
{
Socket connectionSocket = socket as Socket;
while (true)
{
try
{
object serverMessage;
{
byte[] serverData = new byte[10000];
if (connectionSocket.Receive(serverData) == 0)
{
Console.WriteLine("00000000");
return;
}
serverMessage = Functions.Deserialize(serverData);
Console.WriteLine("Получен ответ");
}
if (serverMessage is MessageFromServer)
{
MessageFromServer message = (serverMessage as MessageFromServer);
if (message.Message.IndexOf("Пользователь") != -1)
{
Dispatcher.Invoke(() =>
{
if (!OnlineAndAllCheckBox.IsChecked.Value)
{
_getUsersOnline.BeginInvoke(null, null);
}
});
}
else
{
MessageBox.Show(message.Message);
}
Console.WriteLine("Пришло простое сообщение от сервера");
}
if (serverMessage is GetUsersOnline)
{
GetUsersOnline usersInform = serverMessage as GetUsersOnline;
Console.WriteLine("Пришёл список пользователей");
Dispatcher.Invoke(() =>
{
if (OnlineAndAllCheckBox.IsChecked.Value)
{
return;
}
UsersListBox.Items.Clear();
foreach (AccountInformation t in usersInform.AccountsInformation)
{
UsersListBox.Items.Add(new Correspondence(t));
}
});
}
if (serverMessage is GetMessages)
{
Console.WriteLine("Пришла переписка с пользователем");
Dispatcher.Invoke(() =>
{
listMessagesStackPanel.Children.Clear();
foreach (Message message in (serverMessage as GetMessages).Messages)
{
DrawingMessage(message);
message.WhetherRead = true;
Functions.SerializeAndSend(message, _connectionSocket);
}
});
}
if (serverMessage is Message)
{
Message message = (serverMessage as Message);
Console.WriteLine("Сообщение: " + message.TextMessage);
Dispatcher.Invoke(() =>
{
Correspondence correspondence1 = UsersListBox.SelectedItem as Correspondence;
if (correspondence1 != null && correspondence1.Interlocutor.Id == message.SenderId)
{
DrawingMessage(message);
//прочитано сообщение
}
else
{
for (int index = 0; index < UsersListBox.Items.Count; index++)
{
Correspondence correspondence = (UsersListBox.Items[index] as Correspondence);
if (correspondence.Interlocutor.Id != message.SenderId)
{
continue;
}
correspondence.NumberOfUnreadMessages++;
//usersOnlineListBox.Items.Insert(index, correspondence);
}
UsersListBox.UpdateLayout();
}
});
}
if (serverMessage is GetAllUsers)
{
GetAllUsers usersInform = (serverMessage as GetAllUsers);
Console.WriteLine("Пришёл список пользователей");
Dispatcher.Invoke(() =>
{
UsersListBox.Items.Clear();
foreach (AccountInformation t in usersInform.AccountsInformation)
{
UsersListBox.Items.Add(new Correspondence(t));
}
});
}
if (serverMessage is UserDisconnect)
{
UserDisconnect ud = (serverMessage as UserDisconnect);
Dispatcher.Invoke(() =>
{
if (!OnlineAndAllCheckBox.IsChecked.Value)
{
for (int i = 0; i < UsersListBox.Items.Count; i++)
{
if ((UsersListBox.Items[i] as Correspondence).Interlocutor.Id ==
ud.ThisAccountInforamtion.Id)
{
UsersListBox.Items.RemoveAt(i);
}
}
}
});
}
}
catch (Exception ex)
{
//connectionSocket.Disconnect(false);
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
return;
}
}
}
