/// <summary>
/// Add a network node and connects if it hasn't been done already.
/// Duplicate network nodes cannot exist in the pool.
/// Maximum of x connected nodes are allowed.
/// <seealso cref="NetworkConstants.MaxConcurrentConnections"/>
/// </summary>
/// <param name="node">The node to add</param>
public bool AddNetworkNode(NetworkNode node)
{
var added = false;
if (!node.IsDisposed && Count() < NetworkConstants.MaxConcurrentConnections)
{
lock (_nodesPool)
{
var endpoint = node.ListenEndpoint ?? node.DirectEndpoint;
if (!_nodesPool.Values.Where(
n => (n.ListenEndpoint != null && n.ListenEndpoint.Address.ToString().Contains(endpoint.Address.ToString())) ||
(n.DirectEndpoint != null && n.DirectEndpoint.Address.ToString().Contains(endpoint.Address.ToString()))).Any())
{
added = _nodesPool.TryAdd(node.ToString(), node);
}
}
}
if (added)
{
_logger.LogDebug("Added node {0} to pool. {0}/{1} connections.", node.Id, Count(), NetworkConstants.MaxConcurrentConnections);
// Subscribe to events
node.OnDisconnected += Node_OnDisconnected;
node.OnListenerEndpointChanged += Node_OnListenerEndpointChanged;
}
return(added);
}
public override async Task HandleMessage(NetworkNode node, Message msg)
{
if (node.HandshakeIsCompleted)
{
return;
}
var blockchain = _blockchainRepo.GetChainByNetId(_netId);
try
{
if (node.ConnectionType == ConnectionType.Inbound)
{
await HandleInboundHandshakeMessage(node, msg, blockchain);
}
else
{
await HandleOutboundHandshakeMessage(node, msg, blockchain);
}
}
catch (Exception)
{
node?.Disconnect();
}
}
public async Task <bool> AddAsync(string enode, bool updateFile = true)
{
NetworkNode node = new NetworkNode(enode);
if (!_nodes.TryAdd(node.NodeId, node))
{
if (_logger.IsInfo)
{
_logger.Info($"Static node was already added: {enode}");
}
return(false);
}
if (_logger.IsInfo)
{
_logger.Info($"Static node added: {enode}");
}
NodeAdded?.Invoke(this, new NetworkNodeEventArgs(node));
if (updateFile)
{
await SaveFileAsync();
}
return(true);
}
public void Render(NetworkNode node, RenderWindow win, CharacterEntity character, View charView)
{
_win = win;
_node = node;
if (Character != character)
{
Reset();
}
Character = character;
GUI.RestoreView = charView;
GUI.Win = _win;
if (character != null)
{
GUI.Begin();
GUI.IsActive = true;
DrawStats(character);
//DrawQuests(character as IQuester);
SelectedInteractive = DrawInteractions(character);
DrawItems(character, SelectedInteractive);
GUI.End();
DrawOverlayForInteractive(SelectedInteractive);
DrawCurrentSpell(character);
}
}
public void CircleInsideRectPolygon()
{
Point pointA = new Point(10, 10);
NetworkNode nodeA = new NetworkNode("A", 5, pointA, Color.Red);
Point pointB = new Point(40, 10);
NetworkNode nodeB = new NetworkNode("B", 5, pointB, Color.Red);
Link link = new Link(6, nodeA, nodeB, Color.Red);
bool collision;
Point point;
Entity entity;
point = new Point(20, 10);
entity = new Entity(point, Color.Blue);
collision = link.DetectCollision(entity);
Assert.IsTrue(collision == false);
point = new Point(20, 11);
entity = new Entity(point, Color.Blue);
collision = link.DetectCollision(entity);
Assert.IsTrue(collision == true);
point = new Point(16, 10);
entity = new Entity(point, Color.Blue);
collision = link.DetectCollision(entity);
Assert.IsTrue(collision == true);
}
public Edge(NetworkNode N1, NetworkNode N2, bool[] slots, int len)
{
NodeA = N1;
NobeB = N2;
this.slots = slots;
length = len;
}
public bool testCompatibility(NetworkNode testNode)
{
if (this.nodeName == null || testNode.getNodeName() == null)
{
return(false);
}
if (this.nodeName == "router" && testNode.getNodeName() == "router")
{
return(false);
}
else if (this.nodeName == "router" || testNode.getNodeName() == "router")
{
return(true);
}
else if (this.nodeName == "switch" || testNode.getNodeName() == "switch")
{
return(true);
}
else if (this.nodeName == "accesspoint" || testNode.getNodeName() == "accesspoint")
{
return(true);
}
else
{
return(false);
}
}
/// <param name="component1"></param>
/// <param name="component2"></param>
/// <param name="text"></param>
public void SetLineMessage(NetworkNode component1, NetworkNode component2, string text)
{
DiagramAnalysisNodeMessage messageNode;
//flag node and put up the message
//if the message is already there over write with the latest edition
if (dictionaryNodeMessages.ContainsKey(component2.ComponentGuid))
{
messageNode = dictionaryNodeMessages[component2.ComponentGuid];
}
else if (dictionaryNodeMessages.ContainsKey(component1.ComponentGuid))
{
messageNode = dictionaryNodeMessages[component1.ComponentGuid];
}
else
{
messageNode = new DiagramAnalysisNodeMessage()
{
Component = (NetworkComponent)component1,
NodeId1 = component1.ID,
NodeId2 = component2.ID,
SetMessages = new HashSet <string>()
};
dictionaryNodeMessages.Add(component1.ComponentGuid, messageNode);
IsMessageAdded = true;
}
messageNode.AddMessage(text);
}
public void Tap(Vector2 position)
{
Ray ray = mainCamera.ScreenPointToRay(position);
PointerEventData ped = new PointerEventData(null);
ped.position = position;
List <RaycastResult> results = new List <RaycastResult>();
EventSystem.current.RaycastAll(ped, results);
if (results.Count > 0)
{
return; // ignorar caso o nó esteja atras de um painel do HUD
}
RaycastHit[] hits = Physics.RaycastAll(ray);
foreach (RaycastHit hit in hits)
{
GameObject go = hit.collider.gameObject;
NetworkNode nn = go.GetComponent <NetworkNode>();
if (nn != null)
{
GameManager.SetSelectedNode(nn);
}
// o nó deve ser a primeira selecao - ignorar hud
//hit.collider.gameObject.transform.position += new Vector3(0, 5, 0);
}
}
public override string execute(params string[] args)
{
NetworkNode node = GameManager.currentHost;
if (!(node is IFileSystem))
{
throw new ExecutionException("The current node does not support a file system.");
}
FileSystem currentFileSystem = (node as IFileSystem).fileSystem;
string currentPath = GameManager.currentPath;
string filename = args [1];
File newFile = currentFileSystem.getFile(currentPath + "/" + filename);
if (newFile == null)
{
throw new ExecutionException("Directory \"" + filename + "\" does not exist.");
}
/*
* if (!newFile.isDirectory) {
* throw new ExecutionException ("Can't change directory into a non-directory file.");
* }
*/
// This forces a simplification of paths, so things like "/test/../test/.." get turned into "/".
GameManager.currentPath = newFile.getPath();
return("Current directory is now \"" + GameManager.currentPath + "/\".");
}
private bool registerExistingNode(RegisterMessage message, Socket socket)
{
NetworkNode node = new NetworkNode(message.Type, message.Id, (uint)systemTracker.Timeout, message.ParallelThreads, message.SolvableProblems,
clientTracker.BackupServers);
IPAddress address = (socket.RemoteEndPoint as IPEndPoint).Address;
int port = (ushort)Server.PRIMARY_PORT;
// TODO hack
if (clientTracker.BackupServers.Length == 1)
{
port = (ushort)Server.PRIMARY_PORT2;
}
node.Address = address;
node.Port = (ushort)port;
// Dont inform backup about it self
// It comes naturally in NoOperation message
if (node.Type == RegisterType.CommunicationServer &&
(server.Address.ToString().Equals(address.ToString()) && server.Port == port))
{
return(false);
}
SmartConsole.PrintLine("Backup adding existing node", SmartConsole.DebugLevel.Advanced);
clientTracker.AddNode(node);
return(true);
}
/// <summary>
/// function updating status of each thread
/// </summary>
/// <param name="node"></param>
/// <param name="message"></param>
private void UpdateThreadsStatus(NetworkNode node, StatusMessage message)
{
for (int i = 0; i < node.TaskThreads.Count(); i++)
{
node.TaskThreads[i].StatusThread.State = message.Threads[i].State;
}
}
/// <summary>
/// Helper method that catches new messages (and handles connection exceptions).
/// When an exception occurs, we will disconnect with the peer.
/// </summary>
/// <param name="node">The node to listen to</param>
/// <param name="timeout">The message timeout to maintain. Disconnect when timeout has been exceeded.</param>
/// <returns>The message that we received from the node</returns>
public async Task <Message> ListenForNewMessage(NetworkNode node, TimeSpan timeout)
{
try
{
var msg = await node.ReceiveMessageAsync(timeout);
/*
* var delaySec = 0;
* Random rnd = new Random();
* int delayChance = rnd.Next(1, 100);
* if (delayChance > 55 && delayChance < 86)
* {
* delaySec = rnd.Next(1, 3);
* }
* else if (delayChance > 85 && delayChance < 96)
* {
* delaySec = rnd.Next(3, 6);
* }
* else if (delayChance > 95 && delayChance < 101)
* {
* delaySec = rnd.Next(7, 13);
* }
*
* await Task.Delay(delaySec * 1000);
*/
return(msg);
}
catch (Exception)
{
await node?.Disconnect();
}
return(null);
}
/// <summary>
/// this function is a response to task manager status message
/// </summary>
/// <param name="networkNode"></param>
/// <param name="messagePackage"></param>
private void ReactToTaskManagerStatusMessage(NetworkNode networkNode, MessagePackage messagePackage)
{
//checks if divide or merge solution message has been sent. If not than send noOperation message.
bool hasMessageBeenSent = false;
int numberOfAvaliableThreads = AvaliableThreadsCount(networkNode);
for (int i = 0; i < taskTracker.Tasks.Count && numberOfAvaliableThreads > 0; i++)
{
if (isMessageProblemDividedSent(i, networkNode, messagePackage))
{
hasMessageBeenSent = true;
numberOfAvaliableThreads--;
}
}
// If there are avaliable threads than try to send merge solution message
for (int i = 0; i < taskTracker.Tasks.Count && numberOfAvaliableThreads > 0; i++)
{
if (isMergeSolutionSent(i, networkNode, messagePackage))
{
hasMessageBeenSent = true;
numberOfAvaliableThreads--;
}
}
//if divideProblemMessage hasn't been sent than send noOperationMessage
if (hasMessageBeenSent == false && Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message. 0 tasks to divide or 0 apropriate task managers", SmartConsole.DebugLevel.Basic);
}
}
/******************************************************************/
/************************** CONSTRUCTORS **************************/
/******************************************************************/
public MessageProcessor(ClientMessageHandler messageHandler, NetworkClient client, NetworkNode node)
{
this.client = client;
this.messageHandler = messageHandler;
this.node = node;
}
public async Task <bool> RemoveAsync(string enode, bool updateFile = true)
{
var node = new NetworkNode(enode);
var removed = _nodes.TryRemove(node.NodeId, out _);
if (!removed && _logger.IsDebug)
{
_logger.Debug($"Static node already was not found: {enode}");
}
else
{
if (_logger.IsInfo)
{
_logger.Info($"Static node was removed: {enode}");
}
if (updateFile)
{
await SaveFileAsync();
}
}
var args = new RemoveNetworkNodeEventArgs(node, removed);
NodeRemoved?.Invoke(this, args);
return(args.Removed);
}
public long ping(NetworkNode node)
{
return(pingRecur(node.ip, new Dictionary <NetworkNode, int>()
{
{ this, 0 }
}));
}
public async Task <bool> RemoveAsync(string enode, bool updateFile = true)
{
NetworkNode node = new NetworkNode(enode);
if (!_nodes.TryRemove(node.NodeId, out _))
{
if (_logger.IsInfo)
{
_logger.Info($"Static node was not found: {enode}");
}
return(false);
}
if (_logger.IsInfo)
{
_logger.Info($"Static node was removed: {enode}");
}
NodeRemoved?.Invoke(this, new NetworkNodeEventArgs(node));
if (updateFile)
{
await SaveFileAsync();
}
return(true);
}
// Use this for initialization
void Start()
{
//TODO: Make this into a Network object, and serialize it into a level.
/*
* RouterNode route1 = new RouterNode ("test1", "1");
* RouterNode route2 = new RouterNode ("test2", "2");
*
* DesktopNode desk1 = new DesktopNode ("George's computer", "1.1");
* DesktopNode desk2 = new DesktopNode ("George's server", "1.2");
* desk2.active = false;
*
* DesktopNode desk3 = new DesktopNode ("Remote server", "2.1");
*
* route1.addConnection(route2);
* desk1.addConnection (route1);
* desk2.addConnection (route1);
* desk3.addConnection (route2);
*
* currentHost = desk1;
*/
currentLevel = Network.getLevel1();
currentHost = currentLevel.getStart();
}
private IEnumerator DoTakeOver(NetworkNode nn)
{
Debug.Log("STARTED TRACE COROUTINE");
foreach (var conn in nn.Connetions)
{
int otherNodeIndex = (conn.nodes[0].netnode == nn) ? 1 : 0;
if (conn.nodes[otherNodeIndex].netnode.CapFirewall >= 100)
{
conn.Trigger(1, otherNodeIndex);
}
}
yield return(new WaitForSeconds(Connection.LineDrawGroup.movetime));
Factory.Singleton.SpawnActionTag(nn.gameObject, actionTag.ATOwner.OwnerEnemy, actionTag.ATTrackProperty.TrackCapture);
float capf = 1f;
float startime = Time.time;
float expectedTime = GetFirewallTime(nn);
while (nn.CapFirewall < 100)
{
if (bModoStop)
{
yield return(new WaitUntil(() => bModoStop == false));
}
float totalTime = GetFirewallTime(nn);
capf += 99f * Time.deltaTime / totalTime;
nn.CapFirewall = Mathf.CeilToInt(capf);
yield return(new WaitForEndOfFrame());
}
Debug.Log(string.Format("TRACE COMPLETE {5}: {0} of expected {1} [FBT:{2} CP:{3} FORT:{4}]", (Time.time - startime), expectedTime, firewallBaseTime, nn.CapPlayer, nn.Fortification, nn.Type));
audioEffects.playSprite(audioEffects.effectType.firewallcap);
PropagateFirewall(nn);
}
private async Task HandleInboundHandshakeMessage(NetworkNode node, Message msg, Blockchain blockchain)
{
if (node.HandshakeStage == 0)
{
// Receive a version message
// Verify if the protocol version is the same as ours and set the ListenPort
var payload = (VersionPayload)msg.Payload;
if (payload.ProtocolVersion != BlockchainConstants.ProtocolVersion)
{
throw new ArgumentException("Mismatch in protocol version"); // todo maybe create a 'NodeException' or something
}
_logger.LogDebug("Accepted version from node {0} on direct port {1}. Remote listen port = {2}", node.DirectEndpoint.Address.ToString(), node.DirectEndpoint.Port, payload.ListenPort);
node.IsSyncCandidate = payload.BlockHeight > blockchain.CurrentHeight;
node.SetListenEndpoint(new IPEndPoint(node.DirectEndpoint.Address, payload.ListenPort));
node.ProgressHandshakeStage();
// Send an acknowledgement
await SendMessageToNode(node, NetworkCommand.VerAck, null);
// Send a version
ISerializableComponent versionPayload = new VersionPayload(BlockchainConstants.ProtocolVersion, blockchain.CurrentHeight, _networkManager.ListeningPort);
await SendMessageToNode(node, NetworkCommand.Version, versionPayload);
}
else if (node.HandshakeStage == 1 && msg.Command == NetworkCommand.VerAck.ToString())
{
// And receive a version acknowledgement
_logger.LogInformation("Successfully connected to node {0} on port {1}", node.DirectEndpoint.Address.ToString(), node.DirectEndpoint.Port);
node.ProgressHandshakeStage();
// Download their transaction pool
await SendMessageToNode(node, NetworkCommand.GetTxPool, null);
}
}
private bool CaptureAction()
{
NetworkNode nn = selectedNode;
if (!CanCapture(nn))
{
return(false);
}
int numberOfConnections = 0;
//Debug.Log("NN has " + nn.Connetions.Count);
foreach (var conn in nn.Connetions)
{
int otherNodeIndex = (conn.nodes[0].netnode == nn) ? 1 : 0;
if (conn.nodes[otherNodeIndex].netnode.CapPlayer >= 100)
{
conn.Trigger(0, otherNodeIndex);
numberOfConnections++;
}
}
audioEffects.playSprite(audioEffects.effectType.connect);
nn.CapPlayer = 2;
float captureTime = GetCaptureTime(nn, numberOfConnections);
StartCoroutine(PerformCapture(nn, DetermineDetection(nn), captureTime, Connection.LineDrawGroup.movetime));
SetStress();
return(true);
}
public bool LoadNodes()
{
//Try to load Nodes from disk
if (File.Exists(NodesFileName))
{
_logger.LogInformation($"Loading network nodes from file {NodesFileName}:");
var theNodesFile = File.ReadAllBytes(NodesFileName);
NetworkNodes = (List <NetworkNode>)Utility.ByteArrayToObject(theNodesFile);
int index = 1;
foreach (var node in NetworkNodes)
{
_logger.LogInformation($"----------Node #{index} -------------------------");
_logger.LogInformation($"Access Key:{node.AccessKey}");
_logger.LogInformation($"Description:{node.Description}");
_logger.LogInformation($"Endpoint:{node.Endpoint}");
_logger.LogInformation("--------------------------------------------------");
index++;
}
}
else
{
_logger.LogWarning("No nodes founds on file, adding myself to nodes");
NetworkNode myselfNode = new NetworkNode();
myselfNode.Description = _configuration["NodeIdentification:Name"];
myselfNode.Endpoint = _configuration["NodeIdentification:IPEndpoint"];
AddNode(myselfNode);
}
return(true);
}
public void NetworkNodeSetupTest()
{
var networkNodeSerializableParameters = new NetworkNodeModel {
NetworkAddress = new NetworkAddress(1),
NumberOfPorts = 8,
CableCloudListeningPort = 10000,
IpAddress = "127.0.0.1",
NetworkManagmentSystemListeningPort = 6666,
SignallingCloudListeningPort = PortRandomizer.RandomFreePort()
};
var serializedParameters = XmlSerializer.Serialize(networkNodeSerializableParameters);
var args = serializedParameters.Split(' ');
var joinedArgs = string.Join(" ", args);
var parameters =
(NetworkNodeModel)
XmlSerializer.Deserialize(joinedArgs, typeof(NetworkNodeModel));
var networkNode = new NetworkNode(parameters);
networkNode.Initialize();
}
/******************************************************************/
/************************** CONSTRUCTORS **************************/
/******************************************************************/
public MessageProcessor(ClientMessageHandler messageHandler, NetworkClient client, NetworkNode node)
{
this.client = client;
this.messageHandler = messageHandler;
this.node = node;
}
public async Task <byte[]> CallGetDataBlockBytes(int Id, NetworkNode node)
{
HttpClient client = new HttpClient();
byte[] blockBytes = null;
client.BaseAddress = new Uri(node.Endpoint); //"http://localhost:64195/"
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
try
{
var url = WebApi.GetDataBlockBytes.Value + $"{Id}";
HttpResponseMessage response = await client.GetAsync(url);
if (response.IsSuccessStatusCode)
{
var responseString = await response.Content.ReadAsStringAsync();
//Transform JSON to object
blockBytes = JsonConvert.DeserializeObject <byte[]>(responseString);
}
}
catch (Exception e)
{
_logger.LogCritical(e, "Cannot call remote Node");
}
return(blockBytes);
}
public override string execute(params string[] args)
{
NetworkNode node = GameManager.currentHost;
if (!(node is IFileSystem))
{
throw new ExecutionException("The current node does not support a file system.");
}
FileSystem currentFileSystem = (node as IFileSystem).fileSystem;
Directory currentFile = currentFileSystem.getFile(GameManager.currentPath) as Directory;
string filename = args [1];
if (!(currentFile is Directory))
{
throw new ExecutionException("Invalid state: Current path is not a directory.");
}
if (filename == null || (filename.GetType() != typeof(string)))
{
throw new ExecutionException("Invalid argument: filename must be a string.");
}
try {
//currentFileSystem.createFile(filename, currentFile);
currentFileSystem.createFile(currentFile.getPath() + "/" + filename);
return("Created new file \"" + filename + "\".");
} catch (InvalidFileException e) {
throw new ExecutionException("Could not create file. Reason: " + e.Message);
}
}
public override void Update(GameTime gameTime)
{
NetworkNode oldNode = HoverNode;
base.Update(gameTime);
foreach (NetworkNode n in _networkNodes)
{
n.Update(gameTime);
}
if (HoverNode == null)
{
return;
}
if (oldNode != HoverNode)
{
float wat = (1f - (float)(_rnd.NextDouble()) / 100);
_nodeHoverSound.Play((Globals.Settings.SoundVolume * Globals.Settings.MasterVolume), wat, 0f);
}
if (HoverNode.InfoBox.Rectangle.X + HoverNode.InfoBox.Rectangle.Width >= Game.Window.ClientBounds.Width - 10)
{
HoverNode.InfoBox.ChangeLocation(new Point(HoverNode.Rectangle.Location.X - HoverNode.InfoBox.Rectangle.Width - 20, HoverNode.Rectangle.Location.Y));
}
while (HoverNode.InfoBox.Rectangle.Y + HoverNode.InfoBox.Rectangle.Height > Rectangle.Y + Rectangle.Height - 2)
{
HoverNode.InfoBox.ChangeLocation(new Point(HoverNode.InfoBox.Rectangle.X, HoverNode.InfoBox.Rectangle.Y - 1));
}
}
public IClient Create(string name)
{
var user = new NetworkUser(name);
var node = new NetworkNode(name);
return(_clientInstanceFactory.Create(user, node));
}
/// <param name="component1"></param>
/// <param name="component2"></param>
/// <param name="text"></param>
public void SetLineMessage(NetworkNode component1, NetworkNode component2, string text)
{
DiagramAnalysisNodeMessage messageNode;
//flag node and put up the message
//if the message is already there over write with the latest edition
ComponentPairing pair = (new ComponentPairing()
{
Source = component1.ComponentGuid,
Target = component2.ComponentGuid
});
if (dictionaryLineMessages.ContainsKey(pair))
{
return;// messageNode = dictionaryNodeMessages[component2.ComponentGuid];
}
//
string appropriateEdgeId = findEdgeId(component1, component2, pair);
messageNode = new DiagramAnalysisNodeMessage()
{
Component = (NetworkComponent)component1,
NodeId1 = component1.ID,
NodeId2 = component2.ID,
edgeId = appropriateEdgeId,
SetMessages = new HashSet <string>()
};
dictionaryLineMessages.Add(pair, messageNode);
IsMessageAdded = true;
messageNode.AddMessage(text);
}
void Awake()
{
rigid = GetComponent <Rigidbody2D>();
visuals = transform.Find("visuals");
coll = visuals.GetComponent <CircleCollider2D>();
randGenerator = new System.Random(UnityEngine.Random.Range(0, 9999999));
vectoredMetaballMat = transform.Find("metaBallVisuals").GetComponent <SpriteRenderer>().material;
vectoredMetaballMat.SetFloat("_NumBoids", 8);
node = NetworkNode.node;
if (node != null && (node is Client || node is Server))
{
id = nextID++;
if (node is Server)
{
node.Subscribe <OutgoingNetworkStreamMessage>(this);
}
else if (node is Client && boids.Count == 0)
{
Debug.Log("DING!");
subscribedID = id;
node.Subscribe(this);
}
boids[id] = this;
}
}
public void SendToClient(NetworkNode.ConnectedNode connectedNode, string message,
string data)
{
SendDataWriter writer = BeginMessage(connectedNode, transferMessageType);
writer.Write(message);
writer.Write(data);
EndMessage();
}
bool ReceiveMessage_TransferMessageToClient( 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 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;
}
void Start()
{
node = NetworkNode.node;
if (node == null) //if null, no networking, server controls it if there is networking
{
mode = NetworkMode.UNKNOWN;
StartCoroutine(LocalGoalSpawning());
}
else if(node is Server)
{
mode = NetworkMode.LOCALSERVER;
StartCoroutine(ServerGoalSpawning());
}
else if (node is Client)
{
mode = NetworkMode.REMOTECLIENT;
node.Subscribe(this);
}
}
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;
}
void Start()
{
node = NetworkNode.node;
if (node == null) //if null, no networking, server controls it if there is networking
{
mode = NetworkMode.UNKNOWN;
}
else if (node is Server)
{
mode = NetworkMode.LOCALSERVER;
node.Subscribe(this);
}
else if (node is Client)
{
mode = NetworkMode.REMOTECLIENT;
node.Subscribe(this);
}
for (int i = 0; i < charactersData.Length; i++)
{
charactersData[i].characterID = i;
}
}
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_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;
}
public UserInfo GetUser(NetworkNode.ConnectedNode connectedNode)
{
UserInfo user;
if (!usersByConnectedNode.TryGetValue(connectedNode, out user))
return null;
return user;
}
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.
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;
}
}
}
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 );
}
public UserInfo CreateClientUser(NetworkNode.ConnectedNode connectedNode)
{
return CreateUser(connectedNode.LoginName, connectedNode);
}
private void addCameraNode()
{
Vector3 pos = EditorHelper.Instance.getMousePosInZ(gameScreenPos, 0);
NetworkNode<CameraData> newNode = new NetworkNode<CameraData>(new CameraData(pos, -1, false), pos + new Vector3(0, 0, 1000));
CameraManager.Instance.addNode(newNode);
if (CameraManager.Instance.getNodes().getNodes().Count == 2)
{
CameraManager.Instance.setupCamera();
}
}
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;
}
bool ReceiveMessage_WorldCreateBeginToClient( NetworkNode.ConnectedNode sender,
MessageType messageType, ReceiveDataReader reader, ref string additionalErrorMessage )
{
string worldTypeName = reader.ReadString();
string mapVirtualFileName = reader.ReadString();
if( !reader.Complete() )
return false;
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;
}
private void CheckNetworkEdge(
NetworkEdge networkEdge, Network network,
NetworkNode startNode, NetworkNode endNode)
{
Assert.IsNotNull(networkEdge);
CheckNetworkObjectId(networkEdge);
Assert.AreEqual(network, networkEdge.Network);
Assert.AreEqual(startNode, networkEdge.StartNode);
Assert.AreEqual(endNode, networkEdge.EndNode);
}
private 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_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;
}
//
internal UserInfo(uint identifier, string name, NetworkNode.ConnectedNode connectedNode)
{
this.identifier = identifier;
this.name = name;
this.connectedNode = connectedNode;
}
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);
}
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;
}
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.LastRoundtripTime * 1000 ) );
}
}
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;
}
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 );
}
}
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;
}
private void CheckNetworkNode(
NetworkNode networkNode, Network network, string name,
List<NetworkEdge> incomingEdges, List<NetworkEdge> outgoingEdges)
{
Assert.IsNotNull(networkNode);
CheckNetworkObjectId(networkNode);
Assert.AreEqual(network, networkNode.Network);
Assert.AreEqual(name, networkNode.Name);
Assert.AreEqual(incomingEdges.Count, networkNode.IncomingEdges.Count());
for (int i = 0; i < incomingEdges.Count; i++)
{
Assert.AreEqual(incomingEdges[i], networkNode.IncomingEdges.ElementAt(i));
}
Assert.AreEqual(outgoingEdges.Count, networkNode.OutgoingEdges.Count());
for (int i = 0; i < outgoingEdges.Count; i++)
{
Assert.AreEqual(outgoingEdges[i], networkNode.OutgoingEdges.ElementAt(i));
}
}
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 );
}
private 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;
}
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;
}
