void OnItemChanged(NetworkIdentity _, NetworkIdentity newValue) { Debug.Log("Received item: " + newValue.gameObject); currentItemBase = newValue.GetComponent <ItemBase>(); }
public void CommandMessageCallsCommandTest() { // listen NetworkServer.Listen(1); Assert.That(NetworkServer.connections.Count, Is.EqualTo(0)); // add connection ULocalConnectionToClient connection = new ULocalConnectionToClient(); connection.connectionToServer = new ULocalConnectionToServer(); NetworkServer.AddConnection(connection); // set as authenticated, otherwise removeplayer is rejected connection.isAuthenticated = true; // add an identity with two networkbehaviour components GameObject go = new GameObject(); NetworkIdentity identity = go.AddComponent <NetworkIdentity>(); identity.netId = 42; // for authority check identity.connectionToClient = connection; CommandTestNetworkBehaviour comp0 = go.AddComponent <CommandTestNetworkBehaviour>(); Assert.That(comp0.called, Is.EqualTo(0)); CommandTestNetworkBehaviour comp1 = go.AddComponent <CommandTestNetworkBehaviour>(); Assert.That(comp1.called, Is.EqualTo(0)); connection.identity = identity; // register the command delegate, otherwise it's not found NetworkBehaviour.RegisterCommandDelegate(typeof(CommandTestNetworkBehaviour), nameof(CommandTestNetworkBehaviour.CommandGenerated), CommandTestNetworkBehaviour.CommandGenerated); // identity needs to be in spawned dict, otherwise command handler // won't find it NetworkIdentity.spawned[identity.netId] = identity; // serialize a removeplayer message into an arraysegment CommandMessage message = new CommandMessage { componentIndex = 0, functionHash = NetworkBehaviour.GetMethodHash(typeof(CommandTestNetworkBehaviour), nameof(CommandTestNetworkBehaviour.CommandGenerated)), netId = identity.netId, payload = new ArraySegment <byte>(new byte[0]) }; NetworkWriter writer = new NetworkWriter(); MessagePacker.Pack(message, writer); ArraySegment <byte> segment = writer.ToArraySegment(); // call transport.OnDataReceived with the message // -> calls NetworkServer.OnRemovePlayerMessage // -> destroys conn.identity and sets it to null Transport.activeTransport.OnServerDataReceived.Invoke(0, segment, 0); // was the command called in the first component, not in the second one? Assert.That(comp0.called, Is.EqualTo(1)); Assert.That(comp1.called, Is.EqualTo(0)); // send another command for the second component comp0.called = 0; message.componentIndex = 1; writer = new NetworkWriter(); MessagePacker.Pack(message, writer); segment = writer.ToArraySegment(); Transport.activeTransport.OnServerDataReceived.Invoke(0, segment, 0); // was the command called in the second component, not in the first one? Assert.That(comp0.called, Is.EqualTo(0)); Assert.That(comp1.called, Is.EqualTo(1)); // sending a command without authority should fail // (= if connectionToClient is not what we received the data on) // set wrong authority identity.connectionToClient = new ULocalConnectionToClient(); comp0.called = 0; comp1.called = 0; Transport.activeTransport.OnServerDataReceived.Invoke(0, segment, 0); Assert.That(comp0.called, Is.EqualTo(0)); Assert.That(comp1.called, Is.EqualTo(0)); // restore authority identity.connectionToClient = connection; // sending a component with wrong netId should fail // wrong netid message.netId += 1; writer = new NetworkWriter(); // need to serialize the message again with wrong netid MessagePacker.Pack(message, writer); ArraySegment <byte> segmentWrongNetId = writer.ToArraySegment(); comp0.called = 0; comp1.called = 0; Transport.activeTransport.OnServerDataReceived.Invoke(0, segmentWrongNetId, 0); Assert.That(comp0.called, Is.EqualTo(0)); Assert.That(comp1.called, Is.EqualTo(0)); // clean up NetworkBehaviour.ClearDelegates(); NetworkIdentity.spawned.Clear(); NetworkBehaviour.ClearDelegates(); NetworkServer.Shutdown(); // destroy the test gameobject AFTER server was stopped. // otherwise isServer is true in OnDestroy, which means it would try // to call Destroy(go). but we need to use DestroyImmediate in // Editor GameObject.DestroyImmediate(go); }
public UNetServerCollection(NetworkIdentity owner, int slotCount, ILogger logger = null) : base(owner, slotCount, logger) { OnSlotsChanged += NotifyOnSlotsChanged; OnSizeChanged += NotifyOnSizeChanged; }
public void SetUp() { gameObject = new GameObject(); identity = gameObject.AddComponent <NetworkIdentity>(); }
[Command] public void CmdSetPlayer(NetworkIdentity playerNetworkIdentity) { seatedPlayer = playerNetworkIdentity.GetComponent <PlayerBehaviour>(); RpcSetPlayer(playerNetworkIdentity); }
internal PlayerController(GameObject go, short playerControllerId) { gameObject = go; unetView = go.GetComponent <NetworkIdentity>(); this.playerControllerId = playerControllerId; }
public void CmdSetAuthority(NetworkIdentity grabID, NetworkIdentity playerID) { grabID.AssignClientAuthority(playerID.connectionToClient); }
public UseTrapEvent(PlayerController player, Card card, NetworkIdentity[] targets, int[] indices) : base(player) { cardId = card.netIdentity; flattenedTargets = targets; indexes = indices; }
public CardDrawnEvent(PlayerController player, Card card) : base(player) { cardId = card.netIdentity; }
private void Start() { networkIdentity = GetComponent <NetworkIdentity>(); playerNetworkActions = gameObject.GetComponent <PlayerNetworkActions>(); playerScript = gameObject.GetComponent <PlayerScript>(); }
private void ChangeAuthority(NetworkIdentity position, string tag) { StartCoroutine(CheckOtherPlayer(tag, position)); }
// Update is called once per frame void Update() { identity = GameObject.FindObjectOfType <NetworkIdentity>(); setPlayerID(); }
void Start() { ps = GetComponentInChildren <ParticleSystem>(); networkIdentity = GetComponent <NetworkIdentity>(); }
public bool SyncVarNetworkIdentityEqualExposed(NetworkIdentity ni, uint netIdField) { return(SyncVarNetworkIdentityEqual(ni, netIdField)); }
public void RpcInstantiateCustomPlayer(NetworkIdentity playerNetID, GameObject spawnedObject) { instantiateCustomPlayer(playerNetID, spawnedObject); }
public UseTrapEvent(PlayerController player, Card card) : base(player) { cardId = card.netIdentity; flattenedTargets = null; indexes = null; }
public void CmdSetAuthority(NetworkIdentity playerNetID) { setAuthority(playerNetID); }
public static NetworkIdentity GetClientLocalPlayerIdentity(NetworkIdentity objectIdentity) { return(GetClientLocalPlayer(objectIdentity).netIdentity); }
public void CmdRespawnCustomPlayer(NetworkIdentity playerNetID, GameObject oldCharacter) { instantiateCustomPlayer(playerNetID, oldCharacter); }
[ClientRpc] public void RpcSetPlayer(NetworkIdentity playerNetworkIdentity) { seatedPlayer = playerNetworkIdentity.GetComponent <PlayerBehaviour>(); }
/// <summary> /// Called on the server when a client removes a player. /// <para>The default implementation of this function destroys the corresponding player object.</para> /// </summary> /// <param name="conn">The connection to remove the player from.</param> /// <param name="player">The player identity to remove.</param> public override void OnServerRemovePlayer(NetworkConnection conn, NetworkIdentity player) { base.OnServerRemovePlayer(conn, player); }
public void Target_UCE_StartUpgradePlaceableObjectClient(NetworkConnection target, NetworkIdentity ni) { if (ni != null) { UCE_PlaceableObject po = ni.GetComponent<UCE_PlaceableObject>(); Entity e = po.GetComponent<Entity>(); if (e != null) { LookAtY(po.gameObject.transform.position); UCE_myPlaceableObject = po; UCE_setTimer(po.getUpgradeCost(e.level).duration); UCE_CastbarShow(UCE_MSG_PLACEABLEOBJECT_UPGRADE, po.getUpgradeCost(e.level).duration); } } }
public static void SendToReady <T>(NetworkIdentity identity, T msg, bool includeSelf = true, int channelId = Channels.DefaultReliable) where T : struct, NetworkMessage { NetworkServer.SendToReady <T>(identity, msg, includeSelf, channelId); }
public void SendNetworkIdentityToServer(NetworkIdentity value) { onSendNetworkIdentityCalled?.Invoke(value); }
public static void SendToReady <T>(NetworkIdentity identity, T msg, int channelId = Channels.DefaultReliable) where T : struct, NetworkMessage { SendToReady(identity, msg, true, channelId); }
private void ReplaceName(NetworkIdentity pdaId, string newName) { //messengerSystem.ReplaceName(pdaID, newName); }
static public void SendToClientOfPlayer <T>(NetworkIdentity player, T msg) where T : struct, NetworkMessage { NetworkServer.SendToClientOfPlayer <T>(player, msg); }
private void NetUpdate( SpriteDataSO NewSpriteDataSO = null, int NewVariantIndex = -1, int NewCataloguePage = -1, bool NewPushTexture = false, bool NewEmpty = false, bool NewPushClear = false, bool NewClearPallet = false, Color?NewSetColour = null, List <Color> NewPalette = null, bool NewAnimateOnce = false) { if (NetworkThis == false) { return; } if (SpriteHandlerManager.Instance == null) { return; } if (NetworkIdentity == null) { if (this?.gameObject == null) { return; } var NetID = SpriteHandlerManager.GetRecursivelyANetworkBehaviour(this.gameObject); if (NetID == null) { Logger.LogError("Was unable to find A NetworkBehaviour for ", Category.Sprites); return; } NetworkIdentity = NetID; if (NetworkIdentity == null) { var gamename = ""; if (this?.gameObject != null) { gamename = gameObject.name; } Logger.LogError("Was unable to find A NetworkBehaviour for " + gamename, Category.Sprites); } } if (CustomNetworkManager.Instance._isServer == false) { return; } SpriteHandlerManager.SpriteChange spriteChange = null; if (SpriteHandlerManager.Instance.QueueChanges.ContainsKey(this)) { spriteChange = SpriteHandlerManager.Instance.QueueChanges[this]; } else { spriteChange = SpriteHandlerManager.GetSpriteChange(); } if (NewSpriteDataSO != null) { if (NewSpriteDataSO.setID == -1) { Logger.Log("NewSpriteDataSO NO ID!" + NewSpriteDataSO.name, Category.Sprites); } if (spriteChange.Empty) { spriteChange.Empty = false; } spriteChange.PresentSpriteSet = NewSpriteDataSO.setID; } if (NewVariantIndex != -1) { spriteChange.VariantIndex = NewVariantIndex; } if (NewCataloguePage != -1) { spriteChange.CataloguePage = NewCataloguePage; } if (NewPushTexture) { if (spriteChange.PushClear) { spriteChange.PushClear = false; } spriteChange.PushTexture = NewPushTexture; } if (NewEmpty) { if (spriteChange.PresentSpriteSet != -1) { spriteChange.PresentSpriteSet = -1; } spriteChange.Empty = NewEmpty; } if (NewPushClear) { if (spriteChange.PushTexture) { spriteChange.PushTexture = false; } spriteChange.PushClear = NewPushClear; } if (NewAnimateOnce) { if (spriteChange.AnimateOnce) { spriteChange.AnimateOnce = false; } spriteChange.AnimateOnce = NewAnimateOnce; } if (NewClearPallet) { if (spriteChange.Pallet != null) { spriteChange.Pallet = null; } spriteChange.ClearPallet = NewClearPallet; } if (NewSetColour != null) { spriteChange.SetColour = NewSetColour; } if (NewPalette != null) { if (spriteChange.ClearPallet) { spriteChange.ClearPallet = false; } spriteChange.Pallet = NewPalette; } if (NetworkIdentity.netId == 0) { //Logger.Log("ID hasn't been set for " + this.transform.parent); StartCoroutine(WaitForNetInitialisation(spriteChange)); } else { SpriteHandlerManager.Instance.QueueChanges[this] = spriteChange; } }
public CardSelectionEvent(PlayerController player, PlayerController source, int cardSeed, CardGenerationFlags cardFlags) : base(player) { srcPlayer = source.netIdentity; seed = cardSeed; flags = cardFlags; }
internal PlayerController(GameObject go, short playerControllerId) { this.gameObject = go; this.unetView = go.GetComponent<NetworkIdentity>(); this.playerControllerId = playerControllerId; }
OnGrabbedBehaviour onb; // component defining the behaviour of this GO when it is grabbed by a player // this component can implement different functionality for different GO´s //*************************************************************************************************** // these variables should be set up on the server // TODO: implement a mechanism for storing consequent authority requests from different clients // e.g. manage a situation where a client requests authority over an object that is currently being manipulated by another client //***************************************************************************************************** // TODO: avoid sending two or more consecutive RemoveClientAuthority or AssignClientAUthority commands for the same client and shared object // a mechanism preventing such situations can be implemented either on the client or on the server // Use this for initialization void Start() { netID = this.gameObject.GetComponent <NetworkIdentity>(); onb = this.gameObject.AddComponent <OnGrabbedBehaviour>(); }