public static void SendMessageToClients(IEnumerable<Player> players, Command command, List<SerializableType> parameters)
{
var response = new RemoteInvokeMethod("BoardBehaviorMultiplayer", command, parameters);
var bytes = RemoteInvokeMethod.WriteToStream(response);
foreach (var client in players)
{
client.Sock.Send(bytes, bytes.Length, 0);
}
}
public void NewConnection(Socket sockClient)
{
var client = new Player(sockClient);
Console.WriteLine("Client {0}, joined", client.Sock.RemoteEndPoint);
var args = new List<SerializableType>();
var message = new SimpleMessage {Message = "Hello"};
args.Add(message);
var remoteMethod = new RemoteInvokeMethod("Handler", Command.Connect.ToString(), args);
var bytes = RemoteInvokeMethod.WriteToStream(remoteMethod);
client.Sock.Send(bytes, bytes.Length, SocketFlags.None);
client.SetupRecieveCallback();
}
public static RemoteInvokeMethod ReadFromStream(MemoryStream from)
{
var reader = new BinaryReader(from);
reader.BaseStream.Seek(0, SeekOrigin.Begin);
var className = reader.ReadString();
var methodName = reader.ReadString();
var count = reader.ReadString();
var paramsCount = Convert.ToInt32(count);
var parameters = new List<SerializableType>();
for (var i = 0; i < paramsCount; i++)
{
var type = reader.ReadString() + ", " + AssemblyName;
var objectType = Type.GetType(type);
var item = Activator.CreateInstance(objectType) as SerializableType;
if (UseJsonSerialization)
{
var json = reader.ReadString();
item = JsonToObject(json, objectType);
}
else
{
item.Deserialize(reader, objectType, item);
}
parameters.Add(item);
}
var instance = new RemoteInvokeMethod(className, methodName, parameters);
return instance;
}
public static byte[] WriteToStream(RemoteInvokeMethod toWrite)
{
var stream = new MemoryStream();
var writer = new BinaryWriter(stream);
writer.Write(toWrite.ServiceClassName);
writer.Write(toWrite.MethodName);
writer.Write(toWrite.Parameters.Count.ToString());
foreach (var parameter in toWrite.Parameters)
{
var type = parameter.GetType();
writer.Write(type.ToString());
if (UseJsonSerialization)
{
writer.Write(JsonConvert.SerializeObject(parameter));
continue;
}
parameter.Serialize(writer, type, parameter);
}
return stream.GetBuffer();
}
public RemoteInvokeMethod ChangeTeam(LobbyInfo lobby)
{
var playerId = lobby.PlayerId;
var roomName = lobby.Name;
var index = Players.FindIndex(x => x.Id == playerId);
var player = Players[index];
player.Team = player.Team == Team.Blue ? Team.Red : Team.Blue;
player.Slot = Lobbies[lobby.Name].TeamSlot(player.Team);
var args = Lobbies[roomName].Players.Select(user => new Gambler
{
Name = user.Name,
Id = user.Id,
Slot = user.Slot,
Response = Response.Succed.ToString()
}).Cast<SerializableType>().ToList();
var response = new RemoteInvokeMethod(Command.SyncLobby, args);
var bytes = RemoteInvokeMethod.WriteToStream(response);
var clients = Players.Where(client => client.Lobby == roomName);
foreach (var client in clients)
{
client.Sock.Send(bytes, bytes.Length, 0);
}
return new RemoteInvokeMethod(args);
}
private void SendSyncLobby(string roomName, Gambler gambler)
{
var newPlayer = new List<SerializableType> { gambler };
var response = new RemoteInvokeMethod(Command.SyncLobby, newPlayer);
var bytes = RemoteInvokeMethod.WriteToStream(response);
foreach (var player in Lobbies[roomName].Players)
{
player.Sock.Send(bytes, bytes.Length, 0);
}
var playersInLobby = Players.FindAll(x => (x.State == State.Lobby || x.State == State.Connect) && x.Id != gambler.Id);
var lobbyUpdate = new RemoteInvokeMethod(Command.UpdateLobby, newPlayer);
var bytesMessage = RemoteInvokeMethod.WriteToStream(lobbyUpdate);
foreach (var player in playersInLobby)
{
player.Sock.Send(bytesMessage, bytesMessage.Length, 0);
}
}
private void SendUnits(Player player)
{
var units = new List<SerializableType>();
units.AddRange(_creatures);
units.AddRange(_heroes);
var remoteInvokeMethod = new RemoteInvokeMethod(Command.SendUnits, units);
var bytesMessage = RemoteInvokeMethod.WriteToStream(remoteInvokeMethod);
player.Sock.Send(bytesMessage, bytesMessage.Length, 0);
}
private void SendGameIsReadyCallback(string gameName)
{
var remoteInvokeMethod = new RemoteInvokeMethod("BoardBehaviorMultiplayer", Command.GameIsReady, new List<SerializableType>());
var bytes = RemoteInvokeMethod.WriteToStream(remoteInvokeMethod);
foreach (var player in Games[gameName].Players)
{
player.Sock.Send(bytes, bytes.Length, 0);
}
}
private void AddNewPlayer(Player player, RemoteInvokeMethod remoteInvokeMethod)
{
if (Players.Any(p => p.Id == player.Id)) return;
var user = remoteInvokeMethod.Parameters.FirstOrDefault() as Gambler;
player.Id = user.Id;
player.Name = user.Name;
player.State = State.Lobby;
Players.Add(player);
}
public void RemoveLobby(string name)
{
Games.Remove(name);
var args = new List<SerializableType>();
args.AddRange(Lobbies.Values
.Where(x => x.IsGameStart == false)
.Select(lobby => new LobbyInfo()
{
GameType = lobby.GameType,
CurrentPlayers = lobby.Players.Count,
MaxPlayers = lobby.MaxPlayers,
Name = lobby.Name,
PlayerId = lobby.CreatorId
}));
var response = new RemoteInvokeMethod(Command.SyncRooms, args);
var bytes = RemoteInvokeMethod.WriteToStream(response);
var clients = Players.Where(client => client.State == State.Lobby);
foreach (var client in clients)
{
client.Sock.Send(bytes, bytes.Length, 0);
}
}
public RemoteInvokeMethod Leave(LobbyInfo lobby)
{
var playerId = lobby.PlayerId;
var player = Players.Find(x => x.Id == playerId);
player.State = State.Lobby;
Lobbies[lobby.Name].Players.Remove(player);
if (Lobbies[lobby.Name].Players.Count < 1)
{
Lobbies.Remove(lobby.Name);
var remainsLobbies = Lobbies.Values.Select(l => new LobbyInfo()
{
PlayerId = l.CreatorId,
Name = l.Name,
GameType = l.GameType,
MaxPlayers = l.MaxPlayers,
CurrentPlayers = 2
}).Cast<SerializableType>().ToList();
return new RemoteInvokeMethod(Command.SyncRooms, remainsLobbies);
}
var args = Lobbies[lobby.Name].Players.Select(user => new Gambler
{
Name = user.Name,
Id = user.Id,
Slot = user.Slot,
Response = Response.Succed.ToString()
}).Cast<SerializableType>().ToList();
//Sync Lobby
var response = new RemoteInvokeMethod(Command.SyncLobby, args);
var bytes = RemoteInvokeMethod.WriteToStream(response);
foreach (var user in Lobbies[lobby.Name].Players)
{
user.Sock.Send(bytes, bytes.Length, 0);
}
return new RemoteInvokeMethod(args);
}
public RemoteInvokeMethod Create(LobbyInfo room)
{
var creatorId = room.PlayerId;
var lobbyName = room.Name;
var maxPlayer = room.MaxPlayers;
var args = new List<SerializableType>();
if (!Lobbies.ContainsKey(lobbyName))
{
var player = Players.SingleOrDefault(x => x.Id == creatorId);
var newLobby = new Lobby(lobbyName, creatorId, maxPlayer, room.GameType);
player.Team = Team.Red;
player.Lobby = lobbyName;
player.State = State.Join;
player.Slot = 0;
newLobby.Players.Add(player);
Lobbies.Add(lobbyName, newLobby);
var board = new BoardBehavior(BoardSizeWidth, BoardSizeHeight, lobbyName) { NetworkHandler = this };
Games.Add(lobbyName, board);
var message = new ResponseMessage
{
Response = Response.Succed.ToString(),
Message = room.Name
};
SendUnits(player);
args.Add(message);
var lobby = new List<SerializableType> { room };
var response = new RemoteInvokeMethod(Command.SyncRooms, lobby);
var bytes = RemoteInvokeMethod.WriteToStream(response);
var clients = Players.Where(client => client.State == State.Lobby);
foreach (var client in clients)
{
client.Sock.Send(bytes, bytes.Length, 0);
}
return new RemoteInvokeMethod(args);
}
args.Add(new ResponseMessage
{
Response = Response.Fail.ToString(),
Message = "Room name already exist."
});
return new RemoteInvokeMethod(args);
}
