public void CmdStartMemoryProfile(string adminId, string adminToken, bool full, NetworkConnectionToClient sender = null) { if (IsAdmin(adminId, adminToken, sender) == false) { return; } ProfileManager.Instance.RunMemoryProfile(full); }
public void CmdTriggerGameEvent(int eventIndex, bool isFake, bool announceEvent, InGameEventType eventType, string serializedEventParameters, NetworkConnectionToClient sender = null) { if (IsAdmin(sender, out var player) == false) { return; } InGameEventsManager.Instance.TriggerSpecificEvent( eventIndex, eventType, isFake, player.Username, announceEvent, serializedEventParameters); }
// create GameObject + NetworkIdentity + NetworkBehaviour & SPAWN // => ownerConnection can be NetworkServer.localConnection if needed. protected void CreateNetworkedAndSpawn(out GameObject go, out NetworkIdentity identity, NetworkConnectionToClient ownerConnection = null) { // server & client need to be active before spawning Debug.Assert(NetworkClient.active, "NetworkClient needs to be active before spawning."); Debug.Assert(NetworkServer.active, "NetworkServer needs to be active before spawning."); CreateNetworked(out go, out identity); // spawn NetworkServer.Spawn(go, ownerConnection); ProcessMessages(); }
private void CmdRaiseOfferingConfirmed(int offeringValue, bool sacrifice, NetworkConnectionToClient sender = null) { OnOfferingConfirmed?.Invoke(sender, offeringValue, sacrifice); }
public void CmdReleaseAuthority(NetworkIdentity ni, NetworkConnectionToClient sender = null) { ni.RemoveClientAuthority(); }
// InvokeCmd/Rpc Delegate can all use the same function here internal static bool Invoke(int functionHash, RemoteCallType remoteCallType, NetworkReader reader, NetworkBehaviour component, NetworkConnectionToClient senderConnection = null) { // IMPORTANT: we check if the message's componentIndex component is // actually of the right type. prevents attackers trying // to invoke remote calls on wrong components. if (GetInvokerForHash(functionHash, remoteCallType, out Invoker invoker) && invoker.componentType.IsInstanceOfType(component)) { // invoke function on this component invoker.function(component, reader, senderConnection); return(true); } return(false); }
public void CmdConstruct(int index, NetworkConnectionToClient client = null) { // Check if sending player is holding if (client != null && client.identity.GetComponent <Hands>().ItemInHand.gameObject != gameObject) { return; } Construction construction = constructions[index]; TileDefinition tile = selectedTile.Tile; IInteraction interaction; if (construction.turf) { interaction = new TurfConstructionInteraction { Turf = construction.turf, ConstructIfTurf = construction.constructOverTurf, LoadingBarPrefab = loadingBarPrefab, Delay = construction.buildTime, ObstacleMask = obstacleMask }; } else if (construction.fixture) { interaction = new FixtureConstructionInteraction { Fixture = construction.fixture, TileLayer = construction.tileLayer, WallLayer = construction.wallLayer, FloorLayer = construction.floorLayer, FixtureType = construction.type, LoadingBarPrefab = loadingBarPrefab, Delay = construction.buildTime, ObstacleMask = obstacleMask }; } else { Debug.LogError("Construction does not have a turf or fixture to construct"); return; } // Add material requirement interaction = new ItemRequirement(interaction, item.ItemId, construction.amount); var source = GetComponent <IInteractionSource>(); // Create interaction data var @event = new InteractionEvent(source, new InteractionTargetGameObject(selectedTile.gameObject), selectedTile.transform.position); // Check if interaction is possible if (!interaction.CanInteract(@event)) { return; } // Start interaction source.Interact(@event, interaction); }
internal override void OnActivate(NetworkConnectionToClient sender) { Debug.Log("open"); }
internal override void OnActivate(NetworkConnectionToClient sender) { GetComponent <SpriteRenderer>().color = Color.green; }
void CmdFunction(int someNumber, NetworkIdentity someTarget, NetworkConnectionToClient connection = null) { // do something }
internal override void OnDeactivate(NetworkConnectionToClient sender) { Debug.Log("close"); }
public override void OnServerDisconnect(NetworkConnectionToClient conn) { base.OnServerDisconnect(conn); ++called; }
/// <summary> /// Called on server from OnServerAuthenticateInternal when a client needs to authenticate /// </summary> /// <param name="conn">Connection to client.</param> public override void OnServerAuthenticate(NetworkConnectionToClient conn) { // do nothing, wait for client to send his id }
void CmdFunction(NetworkConnectionToClient connection = null) { // do something }
// InvokeCmd/Rpc/SyncEventDelegate can all use the same function here internal static bool InvokeHandlerDelegate(int cmdHash, MirrorInvokeType invokeType, NetworkReader reader, NetworkBehaviour invokingType, NetworkConnectionToClient senderConnection = null) { if (GetInvokerForHash(cmdHash, invokeType, out Invoker invoker) && invoker.invokeClass.IsInstanceOfType(invokingType)) { invoker.invokeFunction(invokingType, reader, senderConnection); return(true); } return(false); }
public void CmdSendInt(int someInt, NetworkConnectionToClient conn = null) { onSendInt?.Invoke(someInt, conn); }
/// <summary> /// Called on the server when a client disconnects. /// <para>This is called on the Server when a Client disconnects from the Server. Use an override to decide what should happen when a disconnection is detected.</para> /// </summary> /// <param name="conn">Connection from client.</param> public override void OnServerDisconnect(NetworkConnectionToClient conn) { base.OnServerDisconnect(conn); Player.ResetPlayerNumbers(); }
internal override void OnDeactivate(NetworkConnectionToClient sender) { throw new System.NotImplementedException(); }
internal void OnServerDisconnect(NetworkConnectionToClient conn) { if (!NetworkServer.active) { return; } // Invoke OnPlayerDisconnected on all instances of MatchController OnPlayerDisconnected?.Invoke(conn); Guid matchId; if (playerMatches.TryGetValue(conn, out matchId)) { playerMatches.Remove(conn); openMatches.Remove(matchId); foreach (NetworkConnectionToClient playerConn in matchConnections[matchId]) { PlayerInfo _playerInfo = playerInfos[playerConn]; _playerInfo.ready = false; _playerInfo.matchId = Guid.Empty; playerInfos[playerConn] = _playerInfo; playerConn.Send(new ClientMatchMessage { clientMatchOperation = ClientMatchOperation.Departed }); } } foreach (KeyValuePair <Guid, HashSet <NetworkConnectionToClient> > kvp in matchConnections) { kvp.Value.Remove(conn); } PlayerInfo playerInfo = playerInfos[conn]; if (playerInfo.matchId != Guid.Empty) { MatchInfo matchInfo; if (openMatches.TryGetValue(playerInfo.matchId, out matchInfo)) { matchInfo.players--; openMatches[playerInfo.matchId] = matchInfo; } HashSet <NetworkConnectionToClient> connections; if (matchConnections.TryGetValue(playerInfo.matchId, out connections)) { PlayerInfo[] infos = connections.Select(playerConn => playerInfos[playerConn]).ToArray(); foreach (NetworkConnectionToClient playerConn in matchConnections[playerInfo.matchId]) { if (playerConn != conn) { playerConn.Send(new ClientMatchMessage { clientMatchOperation = ClientMatchOperation.UpdateRoom, playerInfos = infos }); } } } } SendMatchList(); }
public void CmdResendData(GameObject player, NetworkConnectionToClient sender = null) { Player p = player.GetComponent <Player>(); p.TargetSyncMovement(sender, p.transform.position, p._syncMovementKeys); }
public void RegisterUnregisterClearHandlerTest() { // message handlers that are needed for the test NetworkServer.RegisterHandler <ConnectMessage>((conn, msg) => { }, false); NetworkServer.RegisterHandler <DisconnectMessage>((conn, msg) => { }, false); NetworkServer.RegisterHandler <ErrorMessage>((conn, msg) => { }, false); // RegisterHandler(conn, msg) variant int variant1Called = 0; NetworkServer.RegisterHandler <TestMessage1>((conn, msg) => { ++variant1Called; }, false); // RegisterHandler(msg) variant int variant2Called = 0; NetworkServer.RegisterHandler <TestMessage2>(msg => { ++variant2Called; }, false); // listen NetworkServer.Listen(1); Assert.That(NetworkServer.connections.Count, Is.EqualTo(0)); // add a connection NetworkConnectionToClient connection = new NetworkConnectionToClient(42); NetworkServer.AddConnection(connection); Assert.That(NetworkServer.connections.Count, Is.EqualTo(1)); // serialize first message, send it to server, check if it was handled NetworkWriter writer = new NetworkWriter(); MessagePacker.Pack(new TestMessage1(), writer); Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0); Assert.That(variant1Called, Is.EqualTo(1)); // serialize second message, send it to server, check if it was handled writer = new NetworkWriter(); MessagePacker.Pack(new TestMessage2(), writer); Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0); Assert.That(variant2Called, Is.EqualTo(1)); // unregister first handler, send, should fail NetworkServer.UnregisterHandler <TestMessage1>(); writer = new NetworkWriter(); MessagePacker.Pack(new TestMessage1(), writer); // log error messages are expected LogAssert.ignoreFailingMessages = true; Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0); LogAssert.ignoreFailingMessages = false; // still 1, not 2 Assert.That(variant1Called, Is.EqualTo(1)); // unregister second handler via ClearHandlers to test that one too. send, should fail NetworkServer.ClearHandlers(); // (only add this one to avoid disconnect error) NetworkServer.RegisterHandler <DisconnectMessage>((conn, msg) => { }, false); writer = new NetworkWriter(); MessagePacker.Pack(new TestMessage1(), writer); // log error messages are expected LogAssert.ignoreFailingMessages = true; Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0); LogAssert.ignoreFailingMessages = false; // still 1, not 2 Assert.That(variant2Called, Is.EqualTo(1)); }
private void CmdSynchronizeTaskList(NetworkConnectionToClient sender = null) { SynchronizeTaskListInternal(sender); }
public void CmdMove(NetworkIdentity ni, Vector3 targetPosition, NetworkConnectionToClient sender = null) { ni.gameObject.transform.position = targetPosition; }
public void CmdSelect(int characterIndex, NetworkConnectionToClient sender = null) { GameObject selectedCharacter = Instantiate(characters[characterIndex].GameplayCharacterPrefab); NetworkServer.Spawn(selectedCharacter, sender); }
public void AssignClientAuthority(NetworkIdentity ni, NetworkConnectionToClient sender = null) { ni.AssignClientAuthority(sender); }
public void CmdRequestEmbark(NetworkConnectionToClient sender = null) { // Spawns the player LoginNetworkManager.singleton.SpawnPlayerAfterRoundStart(sender); }
/// <summary> /// Called on server from OnServerConnectInternal when a client needs to authenticate /// </summary> /// <param name="conn">Connection to client.</param> public override void OnServerAuthenticate(NetworkConnectionToClient conn) { // do nothing...wait for AuthRequestMessage from client }
public void CmdRequestExitGame(NetworkConnectionToClient sender = null) { StartCoroutine(ServerEndMatch(sender, false)); }
// create GameObject + NetworkIdentity + NetworkBehaviour & SPAWN // => ownerConnection can be NetworkServer.localConnection if needed. protected void CreateNetworkedAndSpawn <T, U>(out GameObject go, out NetworkIdentity identity, out T componentA, out U componentB, NetworkConnectionToClient ownerConnection = null) where T : NetworkBehaviour where U : NetworkBehaviour { // server & client need to be active before spawning Debug.Assert(NetworkClient.active, "NetworkClient needs to be active before spawning."); Debug.Assert(NetworkServer.active, "NetworkServer needs to be active before spawning."); CreateNetworked(out go, out identity, out componentA, out componentB); // spawn NetworkServer.Spawn(go, ownerConnection); ProcessMessages(); // double check that we have authority if we passed an owner connection if (ownerConnection != null) { Debug.Assert(componentA.hasAuthority == true, $"Behaviour Had Wrong Authority when spawned, This means that the test is broken and will give the wrong results"); Debug.Assert(componentB.hasAuthority == true, $"Behaviour Had Wrong Authority when spawned, This means that the test is broken and will give the wrong results"); } }
public void CmdDeleteProfile(string adminId, string adminToken, string profileName, NetworkConnectionToClient sender = null) { if (IsAdmin(adminId, adminToken, sender) == false) { return; } if (ProfileManager.runningProfile || ProfileManager.runningMemoryProfile) { return; } string path = Directory.GetCurrentDirectory() + "/Profiles/" + profileName; if (File.Exists(path)) { File.Delete(path); } ProfileMessage.SendToApplicable(); }