public TargetingDummy(IPlayerManager playerManager, INetworkManager networkManager,
                              IResourceManager resourceManager)
        {
            _networkManager = networkManager;
            _playerManager = playerManager;
            _resourceManager = resourceManager;

            var head = new TargetingDummyElement("dummy_head", BodyPart.Head, _resourceManager);
            var torso = new TargetingDummyElement("dummy_torso", BodyPart.Torso, _resourceManager);
            var groin = new TargetingDummyElement("dummy_groin", BodyPart.Groin, _resourceManager);
            var armL = new TargetingDummyElement("dummy_arm_l", BodyPart.Left_Arm, _resourceManager);
            var armR = new TargetingDummyElement("dummy_arm_r", BodyPart.Right_Arm, _resourceManager);
            var legL = new TargetingDummyElement("dummy_leg_l", BodyPart.Left_Leg, _resourceManager);
            var legR = new TargetingDummyElement("dummy_leg_r", BodyPart.Right_Leg, _resourceManager);

            _elements.Add(head);
            _elements.Add(torso);
            _elements.Add(groin);
            _elements.Add(armL);
            _elements.Add(armR);
            _elements.Add(legL);
            _elements.Add(legR);
            head.Clicked += Selected;
            torso.Clicked += Selected;
            groin.Clicked += Selected;
            armL.Clicked += Selected;
            armR.Clicked += Selected;
            legL.Clicked += Selected;
            legR.Clicked += Selected;
            Update(0);
            UpdateHealthIcon();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="UdpServerEntryPoint" /> class.
 /// </summary>
 /// <param name="logger">The logger.</param>
 /// <param name="networkManager">The network manager.</param>
 /// <param name="appHost">The application host.</param>
 /// <param name="json">The json.</param>
 public UdpServerEntryPoint(ILogger logger, INetworkManager networkManager, IServerApplicationHost appHost, IJsonSerializer json)
 {
     _logger = logger;
     _networkManager = networkManager;
     _appHost = appHost;
     _json = json;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ReloadLoggerFileTask" /> class.
 /// </summary>
 /// <param name="logManager">The logManager.</param>
 /// <param name="appHost"></param>
 /// <param name="httpClient"></param>
 public StatisticsTask(ILogManager logManager, IApplicationHost appHost, INetworkManager networkManager, IHttpClient httpClient)
 {
     LogManager = logManager;
     ApplicationHost = appHost;
     NetworkManager = networkManager;
     HttpClient = httpClient;
 }

 public DlnaEntryPoint(IServerConfigurationManager config, 
     ILogManager logManager, 
     IServerApplicationHost appHost, 
     INetworkManager network, 
     ISessionManager sessionManager, 
     IHttpClient httpClient, 
     ILibraryManager libraryManager, 
     IUserManager userManager, 
     IDlnaManager dlnaManager, 
     IImageProcessor imageProcessor, 
     IUserDataManager userDataManager, 
     ILocalizationManager localization, 
     IMediaSourceManager mediaSourceManager, 
     ISsdpHandler ssdpHandler)
 {
     _config = config;
     _appHost = appHost;
     _network = network;
     _sessionManager = sessionManager;
     _httpClient = httpClient;
     _libraryManager = libraryManager;
     _userManager = userManager;
     _dlnaManager = dlnaManager;
     _imageProcessor = imageProcessor;
     _userDataManager = userDataManager;
     _localization = localization;
     _mediaSourceManager = mediaSourceManager;
     _ssdpHandler = (SsdpHandler)ssdpHandler;
     _logger = logManager.GetLogger("Dlna");
 }

 public UsageEntryPoint(ILogger logger, IApplicationHost applicationHost, INetworkManager networkManager, IHttpClient httpClient)
 {
     _logger = logger;
     _applicationHost = applicationHost;
     _networkManager = networkManager;
     _httpClient = httpClient;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="UdpServerEntryPoint"/> class.
 /// </summary>
 /// <param name="logger">The logger.</param>
 /// <param name="networkManager">The network manager.</param>
 /// <param name="serverConfigurationManager">The server configuration manager.</param>
 /// <param name="httpServer">The HTTP server.</param>
 public UdpServerEntryPoint(ILogger logger, INetworkManager networkManager, IServerConfigurationManager serverConfigurationManager, IHttpServer httpServer)
 {
     _logger = logger;
     _networkManager = networkManager;
     _serverConfigurationManager = serverConfigurationManager;
     _httpServer = httpServer;
 }

 public UsageReporter(IApplicationHost applicationHost, INetworkManager networkManager, IHttpClient httpClient, IUserManager userManager)
 {
     _applicationHost = applicationHost;
     _networkManager = networkManager;
     _httpClient = httpClient;
     _userManager = userManager;
 }

        public static void Init(IApplicationPaths appPaths, INetworkManager networkManager)
        {
            // Ugly alert (static init)

            _appPaths = appPaths;
            _networkManager = networkManager;
        }

 public NetworkGrapher(IResourceManager resourceManager, INetworkManager networkManager)
 {
     _resourceManager = resourceManager;
     _networkManager = networkManager;
     _dataPoints = new List<NetworkStatisticsDataPoint>();
     _lastDataPointTime = DateTime.Now;
     _textSprite = new TextSprite("NetGraphText", "", _resourceManager.GetFont("base_font"));
 }

 public PlayToControllerFactory(ISessionManager sessionManager, IItemRepository itemRepository, ILibraryManager libraryManager, ILogManager logManager, INetworkManager networkManager)
 {
     _itemRepository = itemRepository;
     _sessionManager = sessionManager;
     _libraryManager = libraryManager;
     _networkManager = networkManager;
     _logger = logManager.GetLogger("PlayTo");
 }

        public static void Init(IApplicationPaths appPaths, INetworkManager networkManager, ILogManager logManager)
        {
            // Ugly alert (static init)

            _appPaths = appPaths;
            _networkManager = networkManager;
            _logger = logManager.GetLogger("SecurityManager");
        }

 public ConnectEntryPoint(IHttpClient httpClient, IApplicationPaths appPaths, ILogger logger, INetworkManager networkManager, IConnectManager connectManager)
 {
     _httpClient = httpClient;
     _appPaths = appPaths;
     _logger = logger;
     _networkManager = networkManager;
     _connectManager = connectManager;
 }

 public PlayToController(SessionInfo session, ISessionManager sessionManager, IItemRepository itemRepository, ILibraryManager libraryManager, ILogger logger, INetworkManager networkManager)
 {
     _session = session;
     _itemRepository = itemRepository;
     _sessionManager = sessionManager;
     _libraryManager = libraryManager;
     _networkManager = networkManager;
     _logger = logger;
 }

        public DlnaServerEntryPoint(IServerConfigurationManager config, ILogManager logManager, IApplicationHost appHost, INetworkManager network)
        {
            Instance = this;

            _config = config;
            _appHost = appHost;
            _network = network;
            _logger = logManager.GetLogger("DlnaServer");
        }

        public NetworkManager()
        {
            if (!ManagerPresent) {
                throw new ApplicationException(String.Format("Name {0} has no owner", BusName));
            }

            manager = Bus.System.GetObject<INetworkManager>(BusName, new ObjectPath(ObjectPath));
            manager.StateChange += OnStateChange;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="PackageManager" /> class.
 /// </summary>
 /// <param name="securityManager">The security manager.</param>
 /// <param name="networkManager">The network manager.</param>
 /// <param name="httpClient">The HTTP client.</param>
 /// <param name="applicationPaths">The application paths.</param>
 /// <param name="jsonSerializer">The json serializer.</param>
 /// <param name="logger">The logger.</param>
 public PackageManager(ISecurityManager securityManager, INetworkManager networkManager, IHttpClient httpClient, IApplicationPaths applicationPaths, IJsonSerializer jsonSerializer, ILogger logger)
 {
     _securityManager = securityManager;
     _networkManager = networkManager;
     _httpClient = httpClient;
     _appPaths = applicationPaths;
     _jsonSerializer = jsonSerializer;
     _logger = logger;
 }

        public DeviceDiscovery(ILogger logger, IServerConfigurationManager config, IServerApplicationHost appHost, INetworkManager networkManager)
        {
            _tokenSource = new CancellationTokenSource();

            _logger = logger;
            _config = config;
            _appHost = appHost;
            _networkManager = networkManager;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="UdpServerEntryPoint"/> class.
 /// </summary>
 /// <param name="logger">The logger.</param>
 /// <param name="networkManager">The network manager.</param>
 /// <param name="serverConfigurationManager">The server configuration manager.</param>
 /// <param name="httpServer">The HTTP server.</param>
 public UdpServerEntryPoint(ILogger logger, INetworkManager networkManager, IServerConfigurationManager serverConfigurationManager, IHttpServer httpServer, IServerApplicationHost appHost, IJsonSerializer json)
 {
     _logger = logger;
     _networkManager = networkManager;
     _serverConfigurationManager = serverConfigurationManager;
     _httpServer = httpServer;
     _appHost = appHost;
     _json = json;
 }

 /// # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
 ///  C L A S S F U N C T I O N S   C L A S S F U N C T I O N S   C L A S S F U N C T I O N S   C L
 /// # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
 public BattleshipGame(INetworkManager networkManager)
 {
     _graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
        Window.AllowUserResizing = true;
        _graphics.PreferredBackBufferWidth = 900;
        _graphics.PreferredBackBufferHeight = 500;
        this._networkManager = networkManager;
        //_graphics.IsFullScreen = true;
 }

        public UsageEntryPoint(ILogger logger, IApplicationHost applicationHost, INetworkManager networkManager, IHttpClient httpClient, ISessionManager sessionManager)
        {
            _logger = logger;
            _applicationHost = applicationHost;
            _networkManager = networkManager;
            _httpClient = httpClient;
            _sessionManager = sessionManager;

            _sessionManager.SessionStarted += _sessionManager_SessionStarted;
        }