/// <summary>
/// The destructor cleans up all ObjMaint references
/// to this PhysicsObj
/// </summary>
public void DestroyObject()
{
rwLock.EnterWriteLock();
try
{
foreach (var obj in KnownObjects.Values)
{
obj.ObjMaint.RemoveObject(PhysicsObj);
}
// we are maintaining the inverses here,
// so passing false to iterate with modifying these collections
foreach (var obj in KnownPlayers.Values)
{
obj.ObjMaint.RemoveObject(PhysicsObj, false);
}
foreach (var obj in VisibleTargets.Values)
{
obj.ObjMaint.RemoveObject(PhysicsObj, false);
}
RemoveAllObjects();
ServerObjectManager.RemoveServerObject(PhysicsObj);
}
finally
{
rwLock.ExitWriteLock();
}
}
public void Setup()
{
// todo use Substitute for interfaces instead of gameobjeccts for this test
serverGO = new GameObject("Network Server", typeof(TestSocketFactory), typeof(NetworkServer), typeof(ServerObjectManager));
server = serverGO.GetComponent <NetworkServer>();
serverObjectManager = serverGO.GetComponent <ServerObjectManager>();
serverObjectManager.Server = server;
character1 = new GameObject("TestCharacter1", typeof(NetworkIdentity), typeof(NetworkMatchChecker));
character2 = new GameObject("TestCharacter2", typeof(NetworkIdentity), typeof(NetworkMatchChecker));
character3 = new GameObject("TestCharacter3", typeof(NetworkIdentity));
character1.GetComponent <NetworkIdentity>().Server = server;
character1.GetComponent <NetworkIdentity>().ServerObjectManager = serverObjectManager;
character2.GetComponent <NetworkIdentity>().Server = server;
character2.GetComponent <NetworkIdentity>().ServerObjectManager = serverObjectManager;
character3.GetComponent <NetworkIdentity>().Server = server;
character3.GetComponent <NetworkIdentity>().ServerObjectManager = serverObjectManager;
player1MatchChecker = character1.GetComponent <NetworkMatchChecker>();
player2MatchChecker = character2.GetComponent <NetworkMatchChecker>();
player1Connection = CreatePlayer(character1);
player2Connection = CreatePlayer(character2);
player3Connection = CreatePlayer(character3);
var g = GetMatchPlayersDictionary();
matchPlayers = g;
}
void ParseForServerMode()
{
if (!string.IsNullOrEmpty(GetArg("-server")))
{
var serverGo = new GameObject($"Server", typeof(NetworkServer), typeof(ServerObjectManager), typeof(NetworkSceneManager), typeof(PlayerSpawner));
server = serverGo.GetComponent <NetworkServer>();
server.MaxConnections = 9999;
server.Transport = transport;
serverObjectManager = serverGo.GetComponent <ServerObjectManager>();
NetworkSceneManager networkSceneManager = serverGo.GetComponent <NetworkSceneManager>();
networkSceneManager.Server = server;
serverObjectManager.Server = server;
serverObjectManager.NetworkSceneManager = networkSceneManager;
serverObjectManager.Start();
PlayerSpawner spawner = serverGo.GetComponent <PlayerSpawner>();
spawner.PlayerPrefab = PlayerPrefab.GetComponent <NetworkIdentity>();
spawner.ServerObjectManager = serverObjectManager;
spawner.Server = server;
server.Started.AddListener(OnServerStarted);
server.Authenticated.AddListener(conn => serverObjectManager.SetClientReady(conn));
_ = server.ListenAsync();
Console.WriteLine("Starting Server Only Mode");
}
}
// Start is called before the first frame update
protected override void Start()
{
base.Start();
serverObj = new ServerObjectManager();
connectedPlayers = new Dictionary <string, MyNetworkIdentity>();
Hook();
}
public IEnumerator SetupHost() => UniTask.ToCoroutine(async() =>
{
networkManagerGo = new GameObject();
networkManagerGo.AddComponent <MockTransport>();
sceneManager = networkManagerGo.AddComponent <NetworkSceneManager>();
serverObjectManager = networkManagerGo.AddComponent <ServerObjectManager>();
clientObjectManager = networkManagerGo.AddComponent <ClientObjectManager>();
manager = networkManagerGo.AddComponent <NetworkManager>();
manager.client = networkManagerGo.GetComponent <NetworkClient>();
manager.server = networkManagerGo.GetComponent <NetworkServer>();
server = manager.server;
client = manager.client;
sceneManager.client = client;
sceneManager.server = server;
serverObjectManager.server = server;
serverObjectManager.networkSceneManager = sceneManager;
clientObjectManager.client = client;
clientObjectManager.networkSceneManager = sceneManager;
ExtraSetup();
// wait for all Start() methods to get invoked
await UniTask.DelayFrame(1);
await StartHost();
playerGO = new GameObject("playerGO", typeof(Rigidbody));
identity = playerGO.AddComponent <NetworkIdentity>();
component = playerGO.AddComponent <T>();
serverObjectManager.AddPlayerForConnection(server.LocalConnection, playerGO);
client.Update();
});
public void Setup()
{
serverGO = new GameObject("Network Server", typeof(LoopbackTransport), typeof(NetworkServer), typeof(ServerObjectManager));
server = serverGO.GetComponent <NetworkServer>();
serverObjectManager = serverGO.GetComponent <ServerObjectManager>();
serverObjectManager.Server = server;
player1 = new GameObject("TestPlayer1", typeof(NetworkIdentity), typeof(NetworkMatchChecker));
player2 = new GameObject("TestPlayer2", typeof(NetworkIdentity), typeof(NetworkMatchChecker));
player3 = new GameObject("TestPlayer3", typeof(NetworkIdentity));
player1.GetComponent <NetworkIdentity>().Server = server;
player1.GetComponent <NetworkIdentity>().ServerObjectManager = serverObjectManager;
player2.GetComponent <NetworkIdentity>().Server = server;
player2.GetComponent <NetworkIdentity>().ServerObjectManager = serverObjectManager;
player3.GetComponent <NetworkIdentity>().Server = server;
player3.GetComponent <NetworkIdentity>().ServerObjectManager = serverObjectManager;
player1MatchChecker = player1.GetComponent <NetworkMatchChecker>();
player2MatchChecker = player2.GetComponent <NetworkMatchChecker>();
player1Connection = CreateNetworkConnection(player1);
player2Connection = CreateNetworkConnection(player2);
player3Connection = CreateNetworkConnection(player3);
Dictionary <Guid, HashSet <NetworkIdentity> > g = GetMatchPlayersDictionary();
matchPlayers = g;
}
// This is called from PlayerController.CmdClaimPrize which is invoked by PlayerController.OnControllerColliderHit
// This only runs on the server
public void ClaimPrize(GameObject player)
{
if (available)
{
// This is a fast switch to prevent two players claiming the prize in a bang-bang close contest for it.
// First hit turns it off, pending the object being destroyed a few frames later.
available = false;
Color prizeColor = randomColor.color;
// calculate the points from the color ... lighter scores higher as the average approaches 255
// UnityEngine.Color RGB values are float fractions of 255
uint points = (uint)(((prizeColor.r * 255) + (prizeColor.g * 255) + (prizeColor.b * 255)) / 3);
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Log, "Scored {0} points R:{1} G:{2} B:{3}", points, prizeColor.r, prizeColor.g, prizeColor.b);
}
// award the points via SyncVar on the PlayerController
player.GetComponent <PlayerScore>().score += points;
// spawn a replacement
spawner.SpawnPrize();
// destroy this one
ServerObjectManager.Destroy(gameObject);
}
}
private void ParseForServerMode()
{
if (string.IsNullOrEmpty(GetArg("-server")))
{
return;
}
var serverGo = Instantiate(ServerPrefab);
serverGo.name = "Server";
server = serverGo.GetComponent <NetworkServer>();
server.MaxConnections = 9999;
server.SocketFactory = socketFactory;
serverObjectManager = serverGo.GetComponent <ServerObjectManager>();
var networkSceneManager = serverGo.GetComponent <NetworkSceneManager>();
networkSceneManager.Server = server;
serverObjectManager.Server = server;
serverObjectManager.NetworkSceneManager = networkSceneManager;
serverObjectManager.Start();
var spawner = serverGo.GetComponent <CharacterSpawner>();
spawner.ServerObjectManager = serverObjectManager;
spawner.Server = server;
server.Started.AddListener(OnServerStarted);
server.Authenticated.AddListener(conn => serverObjectManager.SpawnVisibleObjects(conn, true));
server.StartServer();
Console.WriteLine("Starting Server Only Mode");
}
public void Setup()
{
go = new GameObject();
client = go.AddComponent <NetworkClient>();
server = go.AddComponent <NetworkServer>();
spawner = go.AddComponent <CharacterSpawner>();
sceneManager = go.AddComponent <NetworkSceneManager>();
serverObjectManager = go.AddComponent <ServerObjectManager>();
clientObjectManager = go.AddComponent <ClientObjectManager>();
spawner.SceneManager = sceneManager;
sceneManager.Client = client;
sceneManager.Server = server;
serverObjectManager.Server = server;
clientObjectManager.Client = client;
clientObjectManager.NetworkSceneManager = sceneManager;
spawner.Client = client;
spawner.Server = server;
spawner.ServerObjectManager = serverObjectManager;
spawner.ClientObjectManager = clientObjectManager;
playerPrefab = new GameObject();
NetworkIdentity playerId = playerPrefab.AddComponent <NetworkIdentity>();
spawner.PlayerPrefab = playerId;
pos1 = new GameObject().transform;
pos2 = new GameObject().transform;
spawner.startPositions.Add(pos1);
spawner.startPositions.Add(pos2);
}
protected virtual void OnPhotonPlayerDisconnected(PhotonPlayer disconnected)
{
if (disconnected == info.owner)
{
ServerObjectManager.RemoveObjectFromGame(gameObject);
Destroy(gameObject);
}
}
public void OnServerDisconnect(INetworkConnection conn)
{
// destroy ball
if (ball != null)
{
ServerObjectManager.Destroy(ball);
}
}
public void OnServerDisconnect(INetworkPlayer _)
{
// after 1 player disconnects then destroy the balll
if (ball != null)
{
ServerObjectManager.Destroy(ball);
}
}
void CmdFire()
{
GameObject projectile = Instantiate(projectilePrefab, projectileMount.position, transform.rotation);
projectile.GetComponent <Projectile>().source = gameObject;
ServerObjectManager.Spawn(projectile);
RpcOnFire();
}
public override void OnServerAddPlayer(INetworkPlayer player)
{
var character = Instantiate(PlayerPrefab);
// Make this a child of the layout panel in the Canvas
character.transform.SetParent(Parent);
SetCharacterName(player, character);
ServerObjectManager.AddCharacter(player, character.gameObject);
}
public IEnumerator SetUp() => UniTask.ToCoroutine(async() =>
{
#if UNITY_EDITOR
await EditorSceneManager.LoadSceneAsyncInPlayMode(ScenePath, new LoadSceneParameters {
loadSceneMode = LoadSceneMode.Additive
});
#else
throw new System.NotSupportedException("Test not supported in player");
#endif
var scene = SceneManager.GetSceneByPath(ScenePath);
SceneManager.SetActiveScene(scene);
#if UNITY_EDITOR
MonsterPrefab = AssetDatabase.LoadAssetAtPath <NetworkIdentity>(MonsterPath);
#else
throw new System.NotSupportedException("Test not supported in player");
#endif
// load host
Server = Object.FindObjectOfType <NetworkServer>();
ServerObjectManager = Object.FindObjectOfType <ServerObjectManager>();
Server.Authenticated.AddListener(conn => ServerObjectManager.SpawnVisibleObjects(conn, true));
var started = new UniTaskCompletionSource();
Server.Started.AddListener(() => started.TrySetResult());
// wait 1 frame before Starting server to give time for Unity to call "Start"
await UniTask.Yield();
Server.StartServer();
await started.Task;
socketFactory = Server.GetComponent <SocketFactory>();
Debug.Assert(socketFactory != null, "Could not find socket factory for test");
// connect from a bunch of clients
for (var i = 0; i < ClientCount; i++)
{
await StartClient(i, socketFactory);
}
// spawn a bunch of monsters
for (var i = 0; i < MonsterCount; i++)
{
SpawnMonster(i);
}
while (Object.FindObjectsOfType <MonsterBehavior>().Count() < MonsterCount * (ClientCount + 1))
{
await UniTask.Delay(10);
}
});
private void OnCreatePlayer(INetworkConnection connection, CreatePlayerMessage createPlayerMessage)
{
// create a gameobject using the name supplied by client
GameObject playergo = Instantiate(playerPrefab).gameObject;
playergo.GetComponent <Player>().playerName = createPlayerMessage.name;
// set it as the player
ServerObjectManager.AddPlayerForConnection(connection, playergo);
chatWindow.gameObject.SetActive(true);
}
public void SpawnPrize()
{
var spawnPosition = new Vector3(Random.Range(-19, 20), 1, Random.Range(-19, 20));
GameObject newPrize = Instantiate(prizePrefab.gameObject, spawnPosition, Quaternion.identity);
Reward reward = newPrize.gameObject.GetComponent <Reward>();
reward.spawner = this;
ServerObjectManager.Spawn(newPrize);
SceneManager.MoveGameObjectToScene(newPrize, gameObject.scene);
}
public IEnumerator SetupHost() => UniTask.ToCoroutine(async() =>
{
networkManagerGo = new GameObject();
// set gameobject name to test name (helps with debugging)
networkManagerGo.name = TestContext.CurrentContext.Test.MethodName;
networkManagerGo.AddComponent <TestSocketFactory>();
sceneManager = networkManagerGo.AddComponent <NetworkSceneManager>();
serverObjectManager = networkManagerGo.AddComponent <ServerObjectManager>();
clientObjectManager = networkManagerGo.AddComponent <ClientObjectManager>();
manager = networkManagerGo.AddComponent <NetworkManager>();
manager.Client = networkManagerGo.GetComponent <NetworkClient>();
manager.Server = networkManagerGo.GetComponent <NetworkServer>();
server = manager.Server;
client = manager.Client;
if (ServerConfig != null)
{
server.PeerConfig = ServerConfig;
}
if (ClientConfig != null)
{
client.PeerConfig = ClientConfig;
}
sceneManager.Client = client;
sceneManager.Server = server;
serverObjectManager.Server = server;
serverObjectManager.NetworkSceneManager = sceneManager;
clientObjectManager.Client = client;
clientObjectManager.NetworkSceneManager = sceneManager;
ExtraSetup();
// wait for all Start() methods to get invoked
await UniTask.DelayFrame(1);
if (AutoStartServer)
{
await StartHost();
playerGO = new GameObject("playerGO", typeof(Rigidbody));
identity = playerGO.AddComponent <NetworkIdentity>();
component = playerGO.AddComponent <T>();
serverObjectManager.AddCharacter(server.LocalPlayer, playerGO);
// wait for client to spawn it
await AsyncUtil.WaitUntilWithTimeout(() => client.Player.HasCharacter);
}
});
public void SpawnObjectExposeExceptionTest()
{
var gameObject = new GameObject();
ServerObjectManager comp = gameObject.AddComponent <ServerObjectManager>();
var obj = new GameObject();
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(() =>
{
comp.SpawnObject(obj, connectionToServer);
});
Assert.That(ex.Message, Is.EqualTo("SpawnObject for " + obj + ", NetworkServer is not active. Cannot spawn objects without an active server."));
}
void OnTriggerEnter(Collider co)
{
//Hit another player
if (co.tag.Equals("Player") && co.gameObject != source)
{
//Apply damage
co.GetComponent <Tank>().health -= damage;
//update score on source
source.GetComponent <Tank>().score += damage;
}
ServerObjectManager.Destroy(gameObject);
}
public override void OnServerAddPlayer(INetworkConnection conn)
{
// add player at correct spawn position
Transform start = Server.NumPlayers == 0 ? leftRacketSpawn : rightRacketSpawn;
NetworkIdentity player = Instantiate(PlayerPrefab, start.position, start.rotation);
ServerObjectManager.AddPlayerForConnection(conn, player.gameObject);
// spawn ball if two players
if (Server.NumPlayers == 2)
{
ball = Instantiate(ballPrefab);
ServerObjectManager.Spawn(ball);
}
}
// override OnServerAddPlayer so to do custom spawn location for character
// this method will be called by base class when player sends `AddCharacterMessage`
public override void OnServerAddPlayer(INetworkPlayer player)
{
// add player at correct spawn position
var start = Server.NumberOfPlayers == 0 ? leftRacketSpawn : rightRacketSpawn;
var character = Instantiate(PlayerPrefab, start.position, start.rotation);
ServerObjectManager.AddCharacter(player, character.gameObject);
// spawn ball if two players
if (Server.NumberOfPlayers == 2)
{
ball = Instantiate(ballPrefab);
ServerObjectManager.Spawn(ball);
}
}
public TransitionState check_entry_restrictions(Transition transition)
{
// custom - acclient checks for entry restrictions (housing barriers)
// for each tick in the transition, regardless if there is a cell change
// optimizing for server here, to only check unverified cell changes
if (!transition.ObjectInfo.Object.IsPlayer || transition.CollisionInfo.VerifiedRestrictions || transition.SpherePath.BeginCell?.ID == ID)
{
return(TransitionState.OK);
}
if (transition.ObjectInfo.Object == null)
{
return(TransitionState.Collided);
}
var weenieObj = transition.ObjectInfo.Object.WeenieObj;
// TODO: handle DatObject
if (weenieObj != null)
{
//if (transition.ObjectInfo.State.HasFlag(ObjectInfoState.IsPlayer))
if (transition.ObjectInfo.Object.IsPlayer)
{
if (RestrictionObj != 0 && !weenieObj.CanBypassMoveRestrictions())
{
var restrictionObj = ServerObjectManager.GetObjectA(RestrictionObj);
if (restrictionObj?.WeenieObj == null)
{
return(TransitionState.Collided);
}
if (!restrictionObj.WeenieObj.CanMoveInto(weenieObj))
{
handle_move_restriction(transition);
return(TransitionState.Collided);
}
else
{
transition.CollisionInfo.VerifiedRestrictions = true;
}
}
}
}
return(TransitionState.OK);
}
public void SetUp()
{
networkServerGameObject = new GameObject();
server = networkServerGameObject.AddComponent <NetworkServer>();
serverObjectManager = networkServerGameObject.AddComponent <ServerObjectManager>();
serverObjectManager.Server = server;
networkServerGameObject.AddComponent <NetworkClient>();
gameObject = new GameObject($"Test go {TestContext.CurrentContext.Test.Name}");
identity = gameObject.AddComponent <NetworkIdentity>();
identity.Server = server;
identity.ServerObjectManager = serverObjectManager;
player1 = Substitute.For <INetworkPlayer>();
player2 = Substitute.For <INetworkPlayer>();
}
public void SetUp()
{
networkServerGameObject = new GameObject();
server = networkServerGameObject.AddComponent <NetworkServer>();
serverObjectManager = networkServerGameObject.AddComponent <ServerObjectManager>();
serverObjectManager.Server = server;
client = networkServerGameObject.AddComponent <NetworkClient>();
gameObject = new GameObject();
identity = gameObject.AddComponent <NetworkIdentity>();
identity.Server = server;
identity.ServerObjectManager = serverObjectManager;
tconn42 = Substitute.For <IConnection>();
tconn43 = Substitute.For <IConnection>();
}
public void SetUp()
{
networkServerGameObject = new GameObject();
server = networkServerGameObject.AddComponent <NetworkServer>();
serverObjectManager = networkServerGameObject.AddComponent <ServerObjectManager>();
serverObjectManager.Server = server;
client = networkServerGameObject.AddComponent <NetworkClient>();
gameObject = new GameObject();
identity = gameObject.AddComponent <NetworkIdentity>();
identity.Server = server;
identity.ServerObjectManager = serverObjectManager;
player1 = Substitute.For <INetworkPlayer>();
player2 = Substitute.For <INetworkPlayer>();
}
public IEnumerator UnitySetUp() => UniTask.ToCoroutine(async() =>
{
Console.WriteLine($"[MirageTest] UnitySetUp class:{TestContext.CurrentContext.Test.ClassName} method:{TestContext.CurrentContext.Test.MethodName}");
networkManagerGo = new GameObject();
networkManagerGo.AddComponent <TestSocketFactory>();
serverObjectManager = networkManagerGo.AddComponent <ServerObjectManager>();
clientObjectManager = networkManagerGo.AddComponent <ClientObjectManager>();
manager = networkManagerGo.AddComponent <NetworkManager>();
server = networkManagerGo.AddComponent <NetworkServer>();
client = networkManagerGo.AddComponent <NetworkClient>();
manager.Client = networkManagerGo.GetComponent <NetworkClient>();
manager.Server = networkManagerGo.GetComponent <NetworkServer>();
if (ServerConfig != null)
{
server.PeerConfig = ServerConfig;
}
if (ClientConfig != null)
{
client.PeerConfig = ClientConfig;
}
serverObjectManager.Server = server;
clientObjectManager.Client = client;
ExtraSetup();
// wait for all Start() methods to get invoked
await UniTask.DelayFrame(2);
if (AutoStartServer)
{
await StartHost();
playerGO = new GameObject("playerGO", typeof(Rigidbody));
playerIdentity = playerGO.AddComponent <NetworkIdentity>();
playerComponent = playerGO.AddComponent <T>();
serverObjectManager.AddCharacter(server.LocalPlayer, playerGO);
// wait for client to spawn it
await AsyncUtil.WaitUntilWithTimeout(() => client.Player.HasCharacter);
}
});
public IEnumerator SetUp() => UniTask.ToCoroutine(async() =>
{
// load scene
await EditorSceneManager.LoadSceneAsyncInPlayMode(ScenePath, new LoadSceneParameters {
loadSceneMode = LoadSceneMode.Additive
});
Scene scene = SceneManager.GetSceneByPath(ScenePath);
SceneManager.SetActiveScene(scene);
MonsterPrefab = AssetDatabase.LoadAssetAtPath <NetworkIdentity>(MonsterPath);
// load host
Server = Object.FindObjectOfType <NetworkServer>();
ServerObjectManager = Object.FindObjectOfType <ServerObjectManager>();
Server.Authenticated.AddListener(conn => ServerObjectManager.SetClientReady(conn));
var started = new UniTaskCompletionSource();
Server.Started.AddListener(() => started.TrySetResult());
// wait 1 frame before Starting server to give time for Unity to call "Start"
await UniTask.Yield();
Server.ListenAsync().Forget();
await started.Task;
Transport = Object.FindObjectOfType <Transport>();
// connect from a bunch of clients
for (int i = 0; i < ClientCount; i++)
{
await StartClient(i, Transport);
}
// spawn a bunch of monsters
for (int i = 0; i < MonsterCount; i++)
{
SpawnMonster(i);
}
while (Object.FindObjectsOfType <MonsterBehavior>().Count() < MonsterCount * (ClientCount + 1))
{
await UniTask.Delay(10);
}
});
public IEnumerator SetupHost() => UniTask.ToCoroutine(async() =>
{
networkManagerGo = new GameObject();
// set gameobject name to test name (helps with debugging)
networkManagerGo.name = TestContext.CurrentContext.Test.MethodName;
networkManagerGo.AddComponent <MockTransport>();
sceneManager = networkManagerGo.AddComponent <NetworkSceneManager>();
serverObjectManager = networkManagerGo.AddComponent <ServerObjectManager>();
clientObjectManager = networkManagerGo.AddComponent <ClientObjectManager>();
manager = networkManagerGo.AddComponent <NetworkManager>();
manager.Client = networkManagerGo.GetComponent <NetworkClient>();
manager.Server = networkManagerGo.GetComponent <NetworkServer>();
server = manager.Server;
client = manager.Client;
sceneManager.Client = client;
sceneManager.Server = server;
serverObjectManager.Server = server;
serverObjectManager.NetworkSceneManager = sceneManager;
clientObjectManager.Client = client;
clientObjectManager.NetworkSceneManager = sceneManager;
ExtraSetup();
// wait for all Start() methods to get invoked
await UniTask.DelayFrame(1);
await StartHost();
playerGO = new GameObject("playerGO", typeof(Rigidbody));
identity = playerGO.AddComponent <NetworkIdentity>();
component = playerGO.AddComponent <T>();
serverObjectManager.AddPlayerForConnection(server.LocalConnection, playerGO);
// wait for client to spawn it
await AsyncUtil.WaitUntilWithTimeout(() => client.Connection.Identity != null);
});
void DestroySelf()
{
ServerObjectManager.Destroy(gameObject);
}
