public async Task DoesntTryToDiscoverServerWithCustomIpAddressIfSet() { var settings = new UserSettings { ServerAddress = "192.168.1.3" }; bool discoverServerSubscribed = false; var messenger = Substitute.For <INetworkMessenger>(); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()) .Returns(Observable.Defer(() => Observable.Start(() => discoverServerSubscribed = true).Select(_ => string.Empty))); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); await vm.ConnectCommand.ExecuteAsync(); Assert.False(discoverServerSubscribed); }
// Use this for initialization void Start() { networker = gameObject.GetComponent<NetworkMessenger>(); if (!isServer) { if (isLocalPlayer) { Transform spawnedClient = (Transform)GameObject.Instantiate(client, transform.position, Quaternion.identity); spawnedClient.parent = transform; DontDestroyOnLoad(gameObject); Application.LoadLevel("clientScene"); networker.InitializeOnClient(); } else { GameObject.Destroy(gameObject); } } else { Transform spawnedPlayer = (Transform)GameObject.Instantiate(player, transform.position, Quaternion.identity); spawnedPlayer.parent = transform; networker.InitializeOnServer(); if (isLocalPlayer) { //if we are the server and spawned a local client, use this as a tester //TO DO: //Make sure the compoenent goes on correct game object, possibly the child gameObject.AddComponent<DesktopController>(); } } }
public async Task SmokeTest() { var messenger = Substitute.For <INetworkMessenger>(); messenger.IsConnected.Returns(false); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(); vm.Activator.Activate(); Assert.True(vm.ConnectCommand.CanExecute(null)); await vm.ConnectCommand.ExecuteAsync(); messenger.IsConnected.Returns(true); messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected")); Assert.False(vm.ConnectCommand.CanExecute(null)); messenger.Received(1).ConnectAsync("192.168.1.1", NetworkConstants.DefaultPort, Arg.Any <Guid>(), null); }
public async Task IsFalseWhileConnectCommandExecutesWithPassword() { var messenger = Substitute.For <INetworkMessenger>(); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(x => { messenger.IsConnected.Returns(true); messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected")); return(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")).ToTaskResult()); }); messenger.IsConnected.Returns(false); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); NetworkMessenger.Override(messenger); var settings = new UserSettings { AdministratorPassword = "******" }; ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); var coll = messenger.WhenAnyValue(x => x.IsConnected).CreateCollection(); await vm.ConnectCommand.ExecuteAsync(); Assert.Equal(new[] { false, true }, coll); }
public void AppDoeNotDieWhenDeactivatingViewModelBeforeCommandThrows() { var settings = new UserSettings { ServerAddress = "192.168.1.1" }; var messenger = Substitute.For <INetworkMessenger>(); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Observable.Never <ConnectionResultContainer>().ToTask()); messenger.IsConnected.Returns(false); NetworkMessenger.Override(messenger); new TestScheduler().With(sched => { ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); vm.ConnectCommand.Execute(null); vm.Activator.Deactivate(); sched.AdvanceByMs(ConnectionViewModel.ConnectCommandTimeout.TotalMilliseconds + 10); }); }
public void ThrottlesTimeChangesToNetworkByTime() { var messenger = CreateDefaultPlaylistMessenger(); NetworkMessenger.Override(messenger); new TestScheduler().With(sched => { var vm = new PlaylistViewModel(); vm.Activator.Activate(); vm.CurrentTimeSeconds = 10; sched.AdvanceByMs(1); vm.CurrentTimeSeconds = 20; sched.AdvanceByMs(1); vm.CurrentTimeSeconds = 30; sched.AdvanceByMs(PlaylistViewModel.TimeThrottleDuration.TotalMilliseconds + 1); messenger.ReceivedWithAnyArgs(2).SetCurrentTime(Arg.Any <TimeSpan>()); messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(10)); messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(30)); }); }
public async Task ConnectsWithCustomIpAddressIfSet() { var settings = new UserSettings { ServerAddress = "192.168.1.3" }; var messenger = Substitute.For <INetworkMessenger>(); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); ConnectionResultContainer result = await vm.ConnectCommand.ExecuteAsync(); Assert.Equal(ConnectionResult.Successful, result.ConnectionResult); Assert.Equal(new Version("99.99.99"), result.ServerVersion);; messenger.Received(1).ConnectAsync(settings.ServerAddress, NetworkConstants.DefaultPort, settings.UniqueIdentifier, null); }
public async Task IgnoresPasswordIfNotPremium() { var messenger = Substitute.For <INetworkMessenger>(); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); NetworkMessenger.Override(messenger); var settings = new UserSettings { AdministratorPassword = "******", IsPremium = false }; // We're not in the trial period var installationDateFetcher = Substitute.For <IInstallationDateFetcher>(); installationDateFetcher.GetInstallationDate().Returns(DateTimeOffset.MinValue); var clock = Substitute.For <IClock>(); clock.Now.Returns(DateTimeOffset.MinValue + AppConstants.TrialTime); var vm = new ConnectionViewModel(settings, () => "192.168.1.2", installationDateFetcher, clock); vm.Activator.Activate(); await vm.ConnectCommand.ExecuteAsync(); messenger.Received().ConnectAsync("192.168.1.1", settings.Port, new Guid(), null); }
private void HandleChatLine(string line) { NetworkMessenger.Broadcast(new ChatInputMessage { ChatLine = string.Format(line) }); UIManager.Instance.ChatInput.text = string.Empty; }
//A server has connected tot he client public override void OnClientConnect(NetworkConnection conn) { ClientsNetworkConnection = conn; Debug.Log("A server has connected to the client"); NetworkMessenger.Broadcast(new TestMessage { TestInt = 1337 }); }
public LiveSessionPublisher(NetworkMessenger messenger, LocalServerDiscoveryFile discoveryFile) : this(messenger, new NetworkConnectionOptions() { HostName = IPAddress.Loopback.ToString(), Port = discoveryFile.PublisherPort }) { m_DiscoveryFile = discoveryFile; }
/// <summary> /// Create a new connection with the specified options /// </summary> public LiveSessionPublisher(NetworkMessenger messenger, NetworkConnectionOptions options, int majorVersion, int minorVersion) : base(options, true, majorVersion, minorVersion) { if (!Log.SilentMode) { Log.Write(LogMessageSeverity.Verbose, LogCategory, "New live sessions publisher being created", "Configuration:\r\n{0}", options); } lock (m_Lock) //since we promptly access these variables from another thread, I'm adding this as paranoia to ensure they get synchronized. { m_Messenger = messenger; } }
public void Update() { if (Input.GetMouseButton(0) && !EventSystem.current.IsPointerOverGameObject()) { var inputRay = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (Physics.Raycast(inputRay, out hit)) { Debug.Log("Sending hex update broadcast."); NetworkMessenger.Broadcast(new HexUpdateMessage { color = Color.red, hitPoint = hit.point }); } } }
private static INetworkMessenger CreateDefaultPlaylistMessenger() { var messenger = Substitute.For <INetworkMessenger>(); messenger.GuestSystemInfo.Returns(new GuestSystemInfo { IsEnabled = false }); messenger.PlaybackStateChanged.Returns(Observable.Never <NetworkPlaybackState>()); messenger.PlaylistChanged.Returns(Observable.Never <NetworkPlaylist>()); messenger.AccessPermission.Returns(NetworkAccessPermission.Admin); NetworkMessenger.Override(messenger); return(messenger); }
public static void Main(string[] args) { // -- Start database connection databaseManager = new DatabaseManager(); // -- Run web server webServer = new WebServer(); // -- Set up debugging NetworkManager.isUnity = false; // -- Set up network messenger networkMessenger = NetworkMessenger.GetInstance(); // -- Set up client manager clientManager = new ClientManager(4); // -- Set up message processor messageProcessor = new MessageProcessorServer(); // -- Set up game manager gameManager = new GameManager(); // -- Open local socket for sending and receiving networkMessenger.OpenClient(11999); // -- Start listening networkMessenger.Listen(IPAddress.Any, messageProcessor); // -- Build server world BuildServerWorld(); // -- Start ping Ping(); // -- Start update Update(); // -- Start tick Tick(); // -- Wait for exit command CommandLoop(); // -- Close all networkMessenger.Close(); }
public void SendsFirstTimeImmediatelyToNetwork() { var messenger = CreateDefaultPlaylistMessenger(); NetworkMessenger.Override(messenger); new TestScheduler().With(sched => { var vm = new PlaylistViewModel(); vm.Activator.Activate(); vm.CurrentTimeSeconds = 60; sched.AdvanceByMs(1); messenger.Received().SetCurrentTime(TimeSpan.FromSeconds(60)); }); }
public async Task SmokeTest() { var messenger = Substitute.For <INetworkMessenger>(); messenger.GuestSystemInfo.Returns(new GuestSystemInfo()); messenger.AddSongToPlaylistAsync(Arg.Any <Guid>()).Returns(new ResponseInfo().ToTaskResult()); NetworkMessenger.Override(messenger); var songs = Helpers.SetupSongs(4).ToList(); var vm = new RemoteSongsViewModel(songs); vm.Activator.Activate(); vm.SelectedSong = vm.Songs[2]; await vm.AddToPlaylistCommand.ExecuteAsync(); messenger.Received().AddSongToPlaylistAsync(songs[2].Guid); }
public void ThrottlesTimeChangesToNetworkByCount() { var messenger = CreateDefaultPlaylistMessenger(); NetworkMessenger.Override(messenger); var vm = new PlaylistViewModel(); vm.Activator.Activate(); for (int i = 1; i < PlaylistViewModel.TimeThrottleCount + 1; i++) { vm.CurrentTimeSeconds = i; } messenger.ReceivedWithAnyArgs(2).SetCurrentTime(Arg.Any <TimeSpan>()); messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(1)); messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(PlaylistViewModel.TimeThrottleCount)); }
public override void OnStartServer() { NetworkMessenger.AddListener <HexUpdateMessage>(OnHexUpdated); //Load persistant data here. hexGridDimensions = new HexGridDimensions { Width = 12, Height = 12 }; for (var z = 0; z < hexGridDimensions.Height; z++) { for (var x = 0; x < hexGridDimensions.Width; x++) { CreateCell(x, z); } } }
public async Task SmokeTest() { var messenger = Substitute.For <INetworkMessenger>(); messenger.GuestSystemInfo.Returns(new GuestSystemInfo()); NetworkMessenger.Override(messenger); var songs = Helpers.SetupSongs(4).ToList(); var vm = new RemoteSongsViewModel(songs); vm.Activator.Activate(); vm.SelectedSong = vm.Songs[2]; await vm.PlaySongsCommand.ExecuteAsync(); var guids = new[] { songs[2].Guid, songs[3].Guid }; messenger.Received().PlaySongsAsync(Arg.Is <IEnumerable <Guid> >(x => x.SequenceEqual(guids))); }
public void SendsTimeToNetworkOnlyIfChangedInWindow() { var messenger = CreateDefaultPlaylistMessenger(); NetworkMessenger.Override(messenger); new TestScheduler().With(sched => { var vm = new PlaylistViewModel(); vm.Activator.Activate(); vm.CurrentTimeSeconds = 60; vm.CurrentTimeSeconds = 60; sched.AdvanceByMs(PlaylistViewModel.TimeThrottleDuration.TotalMilliseconds + 1); messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(60)); }); }
public async Task ChecksMinimumServerVersion() { var messenger = Substitute.For <INetworkMessenger>(); messenger.IsConnected.Returns(true); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.ServerVersionToLow, serverVersion: new Version("0.1.0")))); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(); vm.Activator.Activate(); ConnectionResultContainer result = await vm.ConnectCommand.ExecuteAsync(); Assert.Equal(ConnectionResult.ServerVersionToLow, result.ConnectionResult); Assert.Equal(new Version("0.1.0"), result.ServerVersion); }
void StartDB() { FirebaseApp.DefaultInstance.SetEditorDatabaseUrl("https://bcgj2020p10.firebaseio.com/"); dbReference = FirebaseDatabase.DefaultInstance.RootReference; if (dbReference != null) { Debug.Log("CONNECTED"); } if (PlayerPrefs.HasKey("PlayerID")) { PlayerID = PlayerPrefs.GetString("PlayerID"); } else { SetPlayerUniqueID(); } networkMessenger = this.GetComponent <NetworkMessenger>(); }
// Use this for initialization void Start() { GameObject manager = GameObject.Find("NetworkMessenger"); this.msger = manager.GetComponent <NetworkMessenger>(); // we can use this.msger.games[0].entities for now to draw all entities! for (int i = 0; i < this.msger.games[0].entities.Length; i++) { Entity e = this.msger.games [0].entities [i]; if (e.EType == 3) { Transform tree = (Transform)Instantiate(this.treePrefab, new Vector3(e.X, 0, e.Y), Quaternion.identity); tree.localScale = new Vector3(e.Height, e.Height, e.Width); tree.name = "tree" + e.ID.ToString(); } else if (e.EType == 4) { // TODO: move player here! } } }
public void TimeoutTriggersConnectionFailed() { var messenger = Substitute.For <INetworkMessenger>(); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Observable.Never <ConnectionResultContainer>().ToTask()); messenger.IsConnected.Returns(false); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(); vm.Activator.Activate(); (new TestScheduler()).With(scheduler => { var connectTask = vm.ConnectCommand.ExecuteAsyncTask(); scheduler.AdvanceByMs(ConnectionViewModel.ConnectCommandTimeout.TotalMilliseconds + 1); Assert.Equal(ConnectionResult.Timeout, connectTask.Result.ConnectionResult); }); }
public async Task WrongPasswordTriggersConnectionFailed() { var messenger = Substitute.For <INetworkMessenger>(); messenger.IsConnected.Returns(false); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(new ConnectionResultContainer(ConnectionResult.WrongPassword).ToTaskResult()); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); NetworkMessenger.Override(messenger); var settings = new UserSettings { AdministratorPassword = "******", IsPremium = true }; ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); Assert.Equal(ConnectionResult.WrongPassword, (await vm.ConnectCommand.ExecuteAsync()).ConnectionResult); }
public async Task SmokeTest() { var messenger = Substitute.For <INetworkMessenger>(); messenger.IsConnected.Returns(true); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(); vm.Activator.Activate(); Assert.True(vm.DisconnectCommand.CanExecute(true)); await vm.DisconnectCommand.ExecuteAsync(); messenger.IsConnected.Returns(false); messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected")); Assert.False(vm.DisconnectCommand.CanExecute(null)); messenger.Received(1).Disconnect(); }
// Use this for initialization void Start() { playerMovement = ClientNetworkToolbox.Instance.GetNetworkMessenger(); }
// Use this for initialization void Start() { GameObject managerobj = GameObject.Find("NetworkMessenger"); this.msger = managerobj.GetComponent <NetworkMessenger>(); }
//A client has connected to the server. public override void OnServerConnect(NetworkConnection conn) { //Possible issue where this is called twice :( https://issuetracker.unity3d.com/issues/onserverconnect-function-is-called-twice Debug.Log(string.Format("A client has connected to the server with id: {0}, host id: {1}", conn.connectionId, conn.hostId)); NetworkMessenger.AddListener <TestMessage>(Handler); }
// Use this for initialization void Start() { currentState = State.Normal; cooldownDuration = stunDuration; myMovement =GetComponent<Server.PlayerMovement>(); myRenderer = GetComponent<SpriteRenderer>(); networker = transform.parent.GetComponent<NetworkMessenger>(); }
// Use this for initialization void Start() { networker = ClientNetworkToolbox.Instance.GetNetworkMessenger(); }
public void Awake() { GameObject manager = GameObject.Find("NetworkMessenger"); this.msger = manager.GetComponent <NetworkMessenger>(); }
/// <summary> /// Create a new connection with the specified options /// </summary> public LiveSessionPublisher(NetworkMessenger messenger, NetworkConnectionOptions options) : this(messenger, options, FileHeader.DefaultMajorVersion, FileHeader.DefaultMinorVersion) { }