protected override bool OnIncomingConnectionApproval(NetworkNode.ConnectedNode connectedNode,
string clientVersion, string loginName, string password, ref string rejectReason)
{
if (!base.OnIncomingConnectionApproval(connectedNode, clientVersion, loginName,
password, ref rejectReason))
{
return(false);
}
if (!AllowToConnectNewClients)
{
rejectReason = string.Format(
"Game is already begun. Game do not support to connect after start.");
return(false);
}
//check login and password
//(use this code for rejection)
//if(false)
//{
// rejectReason = "Login failed";
// return false;
//}
return(true);
}
private bool ReceiveMessage_WorldDestroyToClient(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
bool newMapWillBeLoaded = reader.ReadBoolean();
if (!reader.Complete())
{
return(false);
}
if (WorldDestroy != null)
{
WorldDestroy(this, newMapWillBeLoaded);
}
if (EntitySystemWorld.Instance != null && networkingInterface != null)
{
if (serverRemoteEntityWorld != null)
{
networkingInterface.DisconnectRemoteEntityWorld(serverRemoteEntityWorld);
}
}
serverRemoteEntityWorld = null;
return(true);
}
private bool ReceiveMessage_TextToClient(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
//get data from message
uint fromUserIdentifier = reader.ReadVariableUInt32();
string text = reader.ReadString();
if (!reader.Complete())
{
return(false);
}
//get user by identifier
UserManagementClientNetworkService.UserInfo fromUser = userManagementService.GetUser(
fromUserIdentifier);
if (fromUser == null)
{
//error. no such user.
return(true);
}
if (ReceiveText != null)
{
ReceiveText(this, fromUser, text);
}
return(true);
}
public void SendToClient(NetworkNode.ConnectedNode connectedNode, string message,
string data)
{
SendDataWriter writer = BeginMessage(connectedNode, transferMessageType);
writer.Write(message);
writer.Write(data);
EndMessage();
}
public UserInfo GetUser(NetworkNode.ConnectedNode connectedNode)
{
UserInfo user;
if (!usersByConnectedNode.TryGetValue(connectedNode, out user))
{
return(null);
}
return(user);
}
UserInfo CreateUser(string name, NetworkNode.ConnectedNode connectedNode)
{
uint identifier = GetFreeUserIdentifier();
UserInfo newUser = new UserInfo(identifier, name, connectedNode);
usersByIdentifier.Add(identifier, newUser);
if (newUser.ConnectedNode != null)
{
usersByConnectedNode.Add(newUser.ConnectedNode, newUser);
}
{
MessageType messageType = GetMessageType("addUserToClient");
//send event about new user to the all users
foreach (UserInfo user in Users)
{
if (user.ConnectedNode != null)
{
bool thisUserFlag = user == newUser;
SendDataWriter writer = BeginMessage(user.ConnectedNode, messageType);
writer.WriteVariableUInt32(newUser.Identifier);
writer.Write(newUser.Name);
writer.Write(thisUserFlag);
EndMessage();
}
}
if (newUser.ConnectedNode != null)
{
//send list of users to new user
foreach (UserInfo user in Users)
{
if (user == newUser)
{
continue;
}
SendDataWriter writer = BeginMessage(newUser.ConnectedNode, messageType);
writer.WriteVariableUInt32(user.Identifier);
writer.Write(user.Name);
writer.Write(false); //this user flag
EndMessage();
}
}
}
if (AddUserEvent != null)
{
AddUserEvent(this, newUser);
}
return(newUser);
}
ClientRemoteEntityWorld GetRemoteEntityWorld(NetworkNode.ConnectedNode connectedNode)
{
for (int n = 0; n < clientRemoteEntityWorlds.Count; n++)
{
ClientRemoteEntityWorld remoteEntityWorld = clientRemoteEntityWorlds[n];
if (remoteEntityWorld.User.ConnectedNode == connectedNode)
{
return(remoteEntityWorld);
}
}
return(null);
}
bool ReceiveMessage_EntitySystemInternal(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
if (serverRemoteEntityWorld == null)
{
Log.Fatal("EntitySystemClientNetworkService: ReceiveMessage_EntitySystemInternal: " +
"serverRemoteEntityWorld == null.");
}
int entitySystemMessageIdentifier = messageType.Identifier - 1;
return(networkingInterface.ReceiveEntitySystemMessage(serverRemoteEntityWorld,
entitySystemMessageIdentifier, reader, ref additionalErrorMessage));
}
bool ReceiveMessage_WorldCreateEndToClient(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
if (!reader.Complete())
{
return(false);
}
if (WorldCreateEnd != null)
{
WorldCreateEnd(this);
}
return(true);
}
bool ReceiveMessage_EntitySystemInternal(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
RemoteEntityWorld fromRemoteEntityWorld = GetRemoteEntityWorld(sender);
if (fromRemoteEntityWorld == null)
{
//no such world already. as example World has been deleted.
return(true);
}
int entitySystemMessageIdentifier = messageType.Identifier - 1;
return(networkingInterface.ReceiveEntitySystemMessage(fromRemoteEntityWorld,
entitySystemMessageIdentifier, reader, ref additionalErrorMessage));
}
bool ReceiveMessage_AddUserToClient(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
//get data from message
uint identifier = reader.ReadVariableUInt32();
string name = reader.ReadString();
bool thisUserFlag = reader.ReadBoolean();
if (!reader.Complete())
{
return(false);
}
AddUser(identifier, name, thisUserFlag);
return(true);
}
private bool ReceiveMessage_WorldCreateBeginToClient(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
string worldTypeName = reader.ReadString();
string mapVirtualFileName = reader.ReadString();
int worldCheckIdentifier = reader.ReadInt32();
if (!reader.Complete())
{
return(false);
}
//send world identifier back to server
{
MessageType messageType2 = GetMessageType("worldIdentifierToServer");
SendDataWriter writer = BeginMessage(messageType2);
writer.Write(worldCheckIdentifier);
EndMessage();
}
bool remoteWorldAlreadyExists = EntitySystemWorld.Instance.RemoteEntityWorlds.Contains(
serverRemoteEntityWorld);
if (!remoteWorldAlreadyExists)
{
serverRemoteEntityWorld = new RemoteEntityWorld("Server remote entity world");
networkingInterface.ConnectRemoteEntityWorld(serverRemoteEntityWorld);
}
WorldType worldType = EntityTypes.Instance.GetByName(worldTypeName) as WorldType;
if (worldType == null)
{
Log.Fatal("EntitySystemClientNetworkService: " +
"ReceiveMessage_WorldCreateBeginToClient: World type \"{0}\" is not exists.",
worldTypeName);
}
if (WorldCreateBegin != null)
{
WorldCreateBegin(this, worldType, mapVirtualFileName);
}
return(true);
}
//public Unit AKServerOrSingle_CreatePlayerUnit(PlayerManager.ServerOrSingle_Player player,
// MapObject spawnPoint, string faction)
//{
// string unitTypeName;
// FactionType AKFaction;
// //PlayerIntellect intellect = player.Intellect as PlayerIntellect; //invalid
// if (faction.ToString().Equals("AssaultKnights") || faction.ToString().Equals("AssaultKnights (Faction)"))
// AKFaction = (FactionType)Entities.Instance.Create("AssaultKnights", Map.Instance).Type;
// else
// AKFaction = (FactionType)Entities.Instance.Create("Omni", Map.Instance).Type;
// if (GameMap.Instance.GameType == GameMap.GameTypes.AssaultKnights)
// {
// if (player.Intellect.Faction == null)
// player.Intellect.Faction = AKFaction;
// else if (player.Intellect.Faction != AKFaction)
// player.Intellect.Faction = AKFaction;
// else
// player.Intellect.Faction = AKFaction;
// }
// if (!player.Bot)
// {
// if (player.Intellect.Faction.Name == "AssaultKnights" && GameMap.Instance.GameType == GameMap.GameTypes.AssaultKnights)
// unitTypeName = "AKSoldier";
// else if (player.Intellect.Faction.Name == "Omni" && GameMap.Instance.GameType == GameMap.GameTypes.AssaultKnights)
// unitTypeName = "OmniSoldier";
// else if (GameMap.Instance.PlayerUnitType != null)
// unitTypeName = GameMap.Instance.PlayerUnitType.Name;
// else
// unitTypeName = "Girl";
// }
// else if (player.Bot)
// unitTypeName = player.Name;
// else
// unitTypeName = "Rabbit";
// Unit unit = (Unit)Entities.Instance.Create(unitTypeName, Map.Instance);
// Vec3 posOffset = new Vec3(0, 0, 1.5f);
// unit.Position = spawnPoint.Position + posOffset;
// unit.Rotation = spawnPoint.Rotation;
// if (GameMap.Instance.GameType == GameMap.GameTypes.AssaultKnights)
// unit.InitialFaction = AKFaction;//player.Intellect.Faction;
// unit.PostCreate();
// if (player.Intellect != null)
// {
// player.Intellect.Faction = AKFaction;//player.Intellect.Faction;
// player.Intellect.ControlledObject = unit;
// unit.SetIntellect(player.Intellect, false);
// }
// Teleporter teleporter = spawnPoint as Teleporter;
// if (teleporter != null)
// teleporter.ReceiveObject(unit, null);
// BoxTeleporter boxteleporter = spawnPoint as BoxTeleporter;
// if (boxteleporter != null)
// boxteleporter.ReceiveObject(unit, null);
// return unit;
//}
public static void SpawnInfo(CustomMessagesServerNetworkService sender,
NetworkNode.ConnectedNode info, string message, string data)
{
if (message == "SpawnInfoToServer")
{
string[] parameters = data.Split(';');
string userid = parameters[0];
string selectedspawnid = parameters[1];
string selectedfaction = parameters[2];
//SpawnPoint target = null;
var user = GameNetworkServer.Instance.UserManagementService.GetUser(uint.Parse(userid));
user.SpawnId = uint.Parse(selectedspawnid);
var player = PlayerManager.Instance.ServerOrSingle_GetPlayer(user);
player.Intellect.Faction = EntityTypes.Instance.GetByName(selectedfaction) as FactionType;
}
}
private bool ReceiveMessage_TransferMessageToServer(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string error)
{
string message = reader.ReadString();
string data = reader.ReadString();
if (!reader.Complete())
{
return(false);
}
if (ReceiveMessage != null)
{
ReceiveMessage(this, sender, message, data);
}
return(true);
}
private bool ReceiveMessage_SpawnInfoToClient(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
string message = reader.ReadString();
string data = reader.ReadString();
if (!reader.Complete())
{
return(false);
}
if (ReceiveMessage != null)
{
ReceiveMessage(this, message, data);
}
return(true);
}
private void CustomMessagesService_ReceiveMessage(CustomMessagesServerNetworkService sender,
NetworkNode.ConnectedNode source, string message, string data)
{
//Warning! Messages must be checked by security reasons.
//Modified client application can send any message with any data.
SpawnInfo(sender, source, message, data);
if (allowCustomClientCommands)
{
//load map
if (message == "Example_MapLoad")
{
string mapName = data;
MapDestroy(true);
if (!MapLoad(mapName))
{
return;
}
return;
}
//create map object
if (message == "Example_CreateMapObject")
{
string[] parameters = data.Split(';');
string typeName = parameters[0];
Vec3 position = Vec3.Parse(parameters[1]);
Quat rotation = Quat.Parse(parameters[2]);
if (Map.Instance != null)
{
MapObject entity = (MapObject)Entities.Instance.Create(typeName, Map.Instance);
entity.Position = position;
entity.Rotation = rotation;
entity.PostCreate();
}
return;
}
}
}
private bool ReceiveMessage_TextToServer(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
//get source user
UserManagementServerNetworkService.UserInfo fromUser = userManagementService.
GetUser(sender);
//get data of message
string text = reader.ReadString();
uint privateToUserIdentifier = reader.ReadVariableUInt32();
if (!reader.Complete())
{
return(false);
}
//send text to the clients
if (privateToUserIdentifier != 0)
{
//send text to the specific user
UserManagementServerNetworkService.UserInfo privateToUser = userManagementService.
GetUser(privateToUserIdentifier);
if (privateToUser != null)
{
SendText(fromUser, text, privateToUser);
}
else
{
//no user anymore
}
}
else
{
SendText(fromUser, text, null);
}
return(true);
}
private bool ReceiveMessage_EntitySystemInternal(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
ClientRemoteEntityWorld fromRemoteEntityWorld = GetRemoteEntityWorld(sender);
if (fromRemoteEntityWorld == null)
{
//no such world already. as example World has been deleted.
return(true);
}
//check for messages from old/destroyed world. We can get this situation after changing map.
if (worldCheckIdentifier != fromRemoteEntityWorld.ReceivedWorldIdentifier)
{
return(true);
}
int entitySystemMessageIdentifier = messageType.Identifier - 1;
return(networkingInterface.ReceiveEntitySystemMessage(fromRemoteEntityWorld,
entitySystemMessageIdentifier, reader, ref additionalErrorMessage));
}
void GetConnectedNodeData(NetworkNode.ConnectedNode connectedNode, StringBuilder text)
{
if (connectedNode.Status == NetworkConnectionStatuses.Connected)
{
text.AppendFormat("- Connection with {0}\n", connectedNode.RemoteEndPoint.Address);
NetworkNode.ConnectedNode.StatisticsData statistics = connectedNode.Statistics;
text.AppendFormat(
"- Send: Total: {0} kb, Speed: {1} b/s\n",
statistics.GetBytesSent(true) / 1024,
(long)statistics.GetBytesSentPerSecond(true));
text.AppendFormat(
"- Receive: Total: {0} kb, Speed: {1} b/s\n",
statistics.GetBytesReceived(true) / 1024,
(long)statistics.GetBytesReceivedPerSecond(true));
text.AppendFormat("- Ping: {0} ms\n",
(int)(connectedNode.AverageRoundtripTime * 1000));
}
}
bool ReceiveMessage_RemoveUserToClient(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
//get data from message
uint identifier = reader.ReadVariableUInt32();
if (!reader.Complete())
{
return(false);
}
UserInfo user;
users.TryGetValue(identifier, out user);
if (user != null)
{
RemoveUser(user);
}
return(true);
}
private bool ReceiveMessage_CheckWorldIdentifierToServer(NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage)
{
int identifier = reader.ReadInt32();
if (!reader.Complete())
{
return(false);
}
ClientRemoteEntityWorld fromRemoteEntityWorld = GetRemoteEntityWorld(sender);
if (fromRemoteEntityWorld == null)
{
//no such world already. as example World has been deleted.
return(true);
}
fromRemoteEntityWorld.ReceivedWorldIdentifier = identifier;
return(true);
}
public static void SpawnInfo(CustomMessagesServerNetworkService sender,
NetworkNode.ConnectedNode info, string message, string data)
{
if (message == "spawnInfoToServer")
{
string[] parameters = data.Split(';');
string userid = parameters[0];
string selectedspawnid = parameters[1];
string selectedfaction = parameters[2];
foreach (ProjectCommon.UserManagementServerNetworkService.UserInfo info2 in GameNetworkServer.Instance.UserManagementService.Users)
{
if (info2.Name.Equals(userid))
{
GameWorld.Instance.AKServerOrSingle_CreatePlayerUnit(PlayerManager.Instance.ServerOrSingle_GetPlayer(userid), target, selectedfaction);
GameNetworkServer.Instance.CustomMessagesService.SendToClient(info, message, data);
//GameEngineApp.Instance.CreateGameWindowForMap();
}
}
}
}
protected override void OnConnectedNodeConnectionStatusChanged(
NetworkNode.ConnectedNode connectedNode, NetworkConnectionStatuses status, string message)
{
base.OnConnectedNodeConnectionStatusChanged(connectedNode, status, message);
//connected
if (status == NetworkConnectionStatuses.Connected)
{
//add to user management and send events to all clients
userManagementService.CreateClientUser(connectedNode);
}
//disconnected
if (status == NetworkConnectionStatuses.Disconnected)
{
//remove user
UserManagementServerNetworkService.UserInfo user = userManagementService.GetUser(
connectedNode);
if (user != null)
{
userManagementService.RemoveUser(user);
}
}
}
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnTick()"/>.</summary>
protected override void OnTick()
{
base.OnTick();
//single mode. recreate player units if need
if (EntitySystemWorld.Instance.IsSingle())
{
if (GameMap.Instance.GameType == GameMap.GameTypes.Action ||
GameMap.Instance.GameType == GameMap.GameTypes.TPSArcade ||
GameMap.Instance.GameType == GameMap.GameTypes.TurretDemo ||
GameMap.Instance.GameType == GameMap.GameTypes.VillageDemo ||
GameMap.Instance.GameType == GameMap.GameTypes.PlatformerDemo ||
GameMap.Instance.GameType == GameMap.GameTypes.AssaultKnights)
{
if (PlayerManager.Instance != null)
{
foreach (PlayerManager.ServerOrSingle_Player player in
PlayerManager.Instance.ServerOrSingle_Players)
{
if (player.Intellect == null || player.Intellect.ControlledObject == null)
{
ServerOrSingle_CreatePlayerUnit(player);
}
}
}
}
}
//networking mode
if (EntitySystemWorld.Instance.IsServer())
{
if (GameMap.Instance.GameType == GameMap.GameTypes.Action ||
GameMap.Instance.GameType == GameMap.GameTypes.TPSArcade ||
GameMap.Instance.GameType == GameMap.GameTypes.TurretDemo ||
GameMap.Instance.GameType == GameMap.GameTypes.VillageDemo ||
GameMap.Instance.GameType == GameMap.GameTypes.PlatformerDemo ||
GameMap.Instance.GameType == GameMap.GameTypes.AssaultKnights) //iNCIN -- OK NOW
{
if (PlayerManager.Instance != null)
{
UserManagementServerNetworkService userManagementService =
GameNetworkServer.Instance.UserManagementService;
//remove users
again:
foreach (PlayerManager.ServerOrSingle_Player player in
PlayerManager.Instance.ServerOrSingle_Players)
{
if (player.User != null && player.User != userManagementService.ServerUser)
{
NetworkNode.ConnectedNode connectedNode = player.User.ConnectedNode;
if (connectedNode == null ||
connectedNode.Status != NetworkConnectionStatuses.Connected)
{
if (player.Intellect != null)
{
PlayerIntellect playerIntellect = player.Intellect as PlayerIntellect;
if (playerIntellect != null)
{
playerIntellect.TryToRestoreMainControlledUnit();
}
if (player.Intellect.ControlledObject != null)
{
player.Intellect.ControlledObject.Die();
}
player.Intellect.SetForDeletion(true);
player.Intellect = null;
}
PlayerManager.Instance.ServerOrSingle_RemovePlayer(player);
goto again;
}
}
}
//add users
foreach (UserManagementServerNetworkService.UserInfo user in
userManagementService.Users)
{
//check whether "EntitySystem" service on the client
if (user.ConnectedNode != null)
{
if (!user.ConnectedNode.RemoteServices.Contains("EntitySystem"))
{
continue;
}
}
PlayerManager.ServerOrSingle_Player player = PlayerManager.Instance.
ServerOrSingle_GetPlayer(user);
if (player == null)
{
player = PlayerManager.Instance.Server_AddClientPlayer(user);
PlayerIntellect intellect = (PlayerIntellect)Entities.Instance.
Create("PlayerIntellect", World.Instance);
intellect.PostCreate();
player.Intellect = intellect;
if (GameNetworkServer.Instance.UserManagementService.ServerUser != user)
{
//player on client
RemoteEntityWorld remoteEntityWorld = GameNetworkServer.Instance.
EntitySystemService.GetRemoteEntityWorld(user);
intellect.Server_SendSetInstanceToClient(remoteEntityWorld);
}
else
{
//player on this server
PlayerIntellect.SetInstance(intellect);
}
//player.Intellect = intellect;
if (player.User.Faction == null)
{
return;
}
FactionType f = (FactionType)EntityTypes.Instance.GetByName(player.User.Faction);
player.Intellect.Faction = f;
}
}
//create units
foreach (PlayerManager.ServerOrSingle_Player player in
PlayerManager.Instance.ServerOrSingle_Players)
{
if (player.Intellect != null && player.Intellect.ControlledObject == null)
{
if (GameMap.Instance.GameType == GameMap.GameTypes.AssaultKnights)
{
ServerOrSingle_CreatePlayerUnit(player);
}
else
{
ServerOrSingle_CreatePlayerUnit(player);
}
}
}
}
}
}
}
private bool ReceiveMessage_SpawnInfoToServer(NetworkNode.ConnectedNode sender, MessageType messageType,
ReceiveDataReader reader, ref string additionalErrorMessage)
{
return(ReceiveMessage_SpawnInfoToClient(sender, messageType, reader, ref additionalErrorMessage));
}
public UserInfo CreateClientUser(NetworkNode.ConnectedNode connectedNode)
{
return(CreateUser(connectedNode.LoginName, connectedNode));
}
//
internal UserInfo(uint identifier, string name, NetworkNode.ConnectedNode connectedNode)
{
this.identifier = identifier;
this.name = name;
this.connectedNode = connectedNode;
}
//
internal UserInfo(uint identifier, string name, NetworkNode.ConnectedNode connectedNode)
{
this.identifier = identifier;
this.name = name;
this.connectedNode = connectedNode;
}
