private Result CheckIfNodesAreInRange(IEnumerable<Node> pNodes)
        {
            var result = new Result { Status = ResultStatus.Success };

            Log.Write(LogLevel.Info, "Rozpoczęto proces wyznaczenia topologii gwiazdy, używając węzłów naniesionych na plan budynku.");

            foreach (var node in pNodes)
            {
                var distance = Tools.GetRealDistanceBetweenNodes(node.Position, mSink.Position);

                var nodeSignal = mNodeNetwork.PropagationModel.CountSignalStrength(distance, node.Parameters);
                var sinkSignal = mNodeNetwork.PropagationModel.CountSignalStrength(distance, mSink.Parameters);

                if (nodeSignal < mSink.Parameters.Sensitivity || sinkSignal < node.Parameters.Sensitivity)
                {
                    result.Status = ResultStatus.NotAllConnected;
                    result.ErrorNodes.Add(node);
                    result.Message +=
                        string.Format(
                            "Nie można dwukierunkowo połączyć węzła: {0} na pozycji: [{1},{2}] ze stacją bazową\n",
                            node.Name, node.Position.X, node.Position.Y);
                }
                else
                {
                    var nodeLink = new NodeLink
                    {
                        Start = node.Position,
                        End = mSink.Position,
                        Sink = mSink,
                        FirstNode = node.Guid,
                        Type = NodeLink.Mode.Duplex
                    };

                    Log.Write(LogLevel.Info, string.Format("Wyznaczono połączenie między węzłem {0} a stacją bazową [{1}, {2}]",
                                                            node.Name, mSink.Position.X, mSink.Position.Y));

                    mNodeNetwork.CreateNodeLink(nodeLink);
                }
            }

            if (result.Status == ResultStatus.Success)
            {
                result.Message = "Wszystkie węzły połączono ze stacją bazową";
            }

            Log.Write(LogLevel.Info, result.Message);

            return result;
        }
        private string GetConnectionMode(NodeLink.Mode pMode)
        {
            switch (pMode)
            {
                case NodeLink.Mode.Duplex:
                    return "Dwukierunkowa";

                case NodeLink.Mode.SimplexToEnd:
                    return "Jednokierunkowa";

                case NodeLink.Mode.SimplexToStart:
                    return "Jednokierunkowa";

                default:
                    return string.Empty;
            }
        }
        private string GenerateLinkInfo(Position pos1, Position pos2, NodeLink.Mode mode)
        {
            var info = new StringBuilder();
            var distance = Tools.GetRealDistanceBetweenNodes(pos1, pos2);

            info.Append("Odległość: ").Append(distance.ToString("#0.####")).AppendLine(" m");
            info.Append("Możliwość komunikacji: ").Append(GetConnectionMode(mode));

            return info.ToString();
        }
        private void ConnectWithNeighbours(Node pNode)
        {
            foreach (var neighbour in pNode.Neighbours)
            {
                var nodeLink = new NodeLink
                {
                    Start = pNode.Position,
                    End = neighbour.Position,
                    FirstNode = pNode.Guid,
                    SecondNode = neighbour.Guid,
                    Distance = Tools.GetRealDistanceBetweenNodes(pNode.Position, neighbour.Position),
                    Type = NodeLink.Mode.SimplexToEnd
                };

                nodeLink.Type = neighbour.Neighbours.Any(n => n.Guid == pNode.Guid) ? NodeLink.Mode.Duplex : NodeLink.Mode.SimplexToEnd;

                Log.Write(LogLevel.Info, string.Format("Wyznaczono połączenie między węzłem {0} a węzłem {1} [{2}, {3}]",
                    pNode.Name, neighbour.Name, neighbour.Position.X, neighbour.Position.Y));

                mNodeNetwork.CreateNodeLink(nodeLink);
            }
        }
        private void TryConnectWithSink(Node pNode)
        {
            double nodeSignal, sinkSignal;

            if (mBlueprint.IsGeometryMode)
            {
                nodeSignal = mNodeNetwork.PropagationModel.CountSignalStrength(pNode.Position, mSink.Position, pNode.Parameters) + mSink.Parameters.Gain;
                sinkSignal = mNodeNetwork.PropagationModel.CountSignalStrength(mSink.Position, pNode.Position, mSink.Parameters) + pNode.Parameters.Gain;
            }
            else
            {
                var distance = Tools.GetRealDistanceBetweenNodes(pNode.Position, mSink.Position);

                nodeSignal = mNodeNetwork.PropagationModel.CountSignalStrength(distance, pNode.Parameters) + mSink.Parameters.Gain;
                sinkSignal = mNodeNetwork.PropagationModel.CountSignalStrength(distance, mSink.Parameters) + pNode.Parameters.Gain;
            }

            Log.Write(LogLevel.Info, string.Format("Sygnał nadawany z węzła: {0} dBm, docierający do stacji bazowej: {1} dBm (czułość odbiornika stacji bazowej {2} dBm)\n" +
                                                   "Sygnał nadawany ze stacji bazowej: {3} dBm, docierający do węzła: {4} dBm (czułość odbiornika węzła {5} dBm)",
                                                   pNode.Parameters.SignalStrength, nodeSignal, mSink.Parameters.Sensitivity,
                                                   mSink.Parameters.SignalStrength, sinkSignal, pNode.Parameters.Sensitivity));

            if (nodeSignal >= mSink.Parameters.Sensitivity && sinkSignal >= pNode.Parameters.Sensitivity)
            {
                var nodeLink = new NodeLink
                {
                    Start = pNode.Position,
                    End = mSink.Position,
                    Sink = mSink,
                    FirstNode = pNode.Guid,
                    Distance = Tools.GetRealDistanceBetweenNodes(pNode.Position, mSink.Position),
                    Type = NodeLink.Mode.Duplex
                };

                Log.Write(LogLevel.Info, string.Format("Wyznaczono połączenie między węzłem {0} a stacją bazową [{1},{2}]",
                                                        pNode.Name, mSink.Position.X, mSink.Position.Y));

                mNodeNetwork.CreateNodeLink(nodeLink);
                InSinkRangeNodes.Add(pNode);
            }
            else
            {
                Log.Write(LogLevel.Info, string.Format("Nie jest możliwe dwukierunkowe połączenie węzła {0} ze stacją bazową", pNode.Name));
                NotInSinkRangeNodes.Add(pNode);
            }
        }