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();
}
