/// <summary> /// Sends a new network event, as long as the data being sent is inherited from INetworkObject and we check the class here, /// everything else is taken care of. /// </summary> /// <param name="netObject">The net object.</param> public async void SendNewNetworkEvent(INetworkObject netObject, ReceiverGroup receiverGroup, DeliveryMode deliveryMode) { await new WaitForBackgroundThread(); /*----------------------------------------------------------------------------------------------------------------------------*/ byte id = (byte)netObject.NetEvent; var message = netObject.NetData; object[] messageArray = await netObject.ConvertToNetworkObject(); /*----------------------------------------------------------------------------------------------------------------------------*/ var eventOptions = new RaiseEventOptions(); eventOptions.CachingOption = EventCaching.DoNotCache; eventOptions.Receivers = receiverGroup; /*----------------------------------------------------------------------------------------------------------------------------*/ var sendOptions = new SendOptions(); sendOptions.DeliveryMode = deliveryMode; /*----------------------------------------------------------------------------------------------------------------------------*/ if (PhotonNetwork.RaiseEvent(id, messageArray, eventOptions, sendOptions)) { } else { } await new WaitForUpdate(); }
public void OnNetworkObjectDestroyed(INetworkObjectList networkObjectList, INetworkObject networkObject, INetworkable networkableObject) { if (_listeners.TryGetValue(networkObjectList.Id, out var listener)) { listener.OnNetworkObjectDestroyed(networkObjectList, networkObject, networkableObject); } }
protected virtual void AddNetMessage(List <byte> msgs, INetworkObject networkObj) { byte[] id = ByteHelper.ConvertToByte(networkObj.Identifier); byte[] data = networkObj.GetMessage(); int totalSize = id.Length + data.Length + 1; if (totalSize > maxNetworkObjSize) { throw new GoblinException(networkObj.Identifier + " contains data larger than the current " + "transfer size of " + maxNetworkObjSize + ". Change the TransferSize to a larger size."); } byte[] size = null; switch (transferSize) { case TransferSize.Byte: size = new byte[1]; size[0] = (byte)totalSize; break; case TransferSize.UShort: size = BitConverter.GetBytes((ushort)totalSize); break; case TransferSize.Int: size = BitConverter.GetBytes(totalSize); break; } msgs.AddRange(size); msgs.Add((byte)networkObj.Identifier.Length); msgs.AddRange(id); msgs.AddRange(data); }
public override void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager) { var componentTypeId = Component.GetComponentId(); INetworkObjectSerializer componentSerializer = serializerManager.GetSerializer(componentTypeId); componentSerializer.Merge(Component as INetworkObject, target, _bitMask); }
public void OnEndUpdateNetworkObject(INetworkObjectList networkObjectList, INetworkObject networkObject) { if (_listeners.TryGetValue(networkObjectList.Id, out var listener)) { listener.OnEndUpdateNetworkObject(networkObjectList, networkObject); } }
public void Send(INetworkObject obj, Guid roomId, QueryType queryType) { var data = obj.ToBytes(); var requestData = data.GetRequestData(obj?.RequestItemId ?? Guid.Empty, roomId, queryType).ToArray(); _stream.Write(requestData, 0, requestData.Length); Logger.Log(LogLevel.Information, $"send {obj?.RequestItemId ?? Guid.Empty}"); }
public virtual void RemoveNetworkObject(INetworkObject networkObj) { // busy wait while the network handler is being updated while (updating) { } networkObjects.Remove(networkObj.Identifier); }
/// <summary> /// Alerts all listeners that a new network event has been received and the object as it's base class. /// </summary> /// <param name="netObject">The received event object at it's base class, listeners must check for type themselves, this keeps everything /// nice and generic.</param> public async Task SendNewNetworkEventReceived(INetworkObject netObject) { var signal = new Signal_Networking_OnNetworkObjectReceived() { NetworkObject = netObject }; Signaler.Instance.Broadcast <Signal_Networking_OnNetworkObjectReceived>(Instance, signal: signal); await new WaitForEndOfFrame(); }
// ------------------------------------------- /* * Get the the object in the list of types created by assignedName */ protected GameObject GetTypeByAssignedName(string _assignedName) { for (int i = 0; i < m_types.Count; i++) { INetworkObject obj = m_types[i].GetComponent <INetworkObject>(); if (obj.AssignedName == _assignedName) { return(m_types[i]); } } return(null); }
public NetworkId GetObjectIdFromName(INetworkObject monoBehaviour) { var target = monoBehaviour as MonoBehaviour; var key = target.name; if (existingIdAssignments.Contains(key)) { throw new Exception("Cannot add multiple objects of the same name."); } existingIdAssignments.Add(key); return(IdGenerator.GenerateFromName(key)); }
private void NetworkClientOnMessage(INetworkObject obj) { Logger.Log(LogLevel.Debug, obj.RequestItemId.ToString()); if (obj is ManagerPropertyValue managerPropertyValue) { SetManagerPropertyValue(managerPropertyValue); } else if (obj is CreateManagerItem createManagerItem) { CreateManagerPropertyItem(createManagerItem); } }
public NetObj(INetworkObject netObj) { this.networkObject = netObj; timeElapsedSinceLastTransmit = 0; if (networkObject.SendFrequencyInHertz != 0) { transmitSpan = 1000 / (float)networkObject.SendFrequencyInHertz; } else { transmitSpan = float.MaxValue; } }
// ------------------------------------------- /* * Get the the object in the list of objects created by UID */ protected GameObject GetTypeByUID(string _uidName) { #if !DISABLE_UNET_COMMS for (int i = 0; i < m_types.Count; i++) { INetworkObject obj = m_types[i].GetComponent <INetworkObject>(); if (PlayerConnectionController.GetNameIdentificator(obj.PrefabName, obj.UID, obj.NetID) == _uidName) { return(m_types[i]); } } #endif return(null); }
public virtual void AddNetworkObject(INetworkObject networkObj) { // busy wait while the network handler is being updated while (updating) { } if (!networkObjects.ContainsKey(networkObj.Identifier)) { if (networkObj.Identifier.Length > 255) { throw new GoblinException("A network object's Identifier should not exceed 255 " + "characters long"); } networkObjects.Add(networkObj.Identifier, new NetObj(networkObj)); } }
public void Instantiate(GameObject obj, ushort lId = 60000) { if (NetworkManager.Instance.MyNetworkId != networkId) { networkObject = GameObject.Instantiate(obj, GetPosition(), GetRotation()).GetComponent <INetworkObject>(); } else { NetworkManager.Instance.ObjectsInWaiting[lId].SetActive(true); networkObject = NetworkManager.Instance.ObjectsInWaiting[lId].GetComponent <INetworkObject>(); NetworkManager.Instance.ObjectsInWaiting.Remove(lId); } networkObject.Init(objectData.playerId, objectData.objectId, networkId); }
private void button1_Click_1(object sender, EventArgs e) { if (UOAI.Clients.Count > 0) { //TAKE CARE THAT ALL EVENT HANDLERS ARE """PUBLIC""" FUNCTIONS !!! //IF THEY ARE NOT PUBLIC, EVENTS FAIL SILENTLY !!! if (curclient != null) { curclient.OnKeyUp -= new OnKeyUpDelegate(cures_OnKeyUp); curclient.OnKeyDown -= new OnKeyDownDelegate(cures_OnKeyDown); curclient.OnQuit -= new SimpleDelegate(curclient_OnQuit); NetworkObject.OnPacketHandled -= new SimpleDelegate(NetworkObject_OnPacketHandled); NetworkObject.onPacketRecieve -= new OnPacketDelegate(NetworkObject_onPacketRecieve); NetworkObject.onPacketSend -= new OnPacketDelegate(NetworkObject_onPacketSend); //curclient.OnWindowsMessage -= new OnWindowsMessageDelegate(curclient_OnWindowsMessage); } curclient = UOAI.Clients[0]; //synchronize all events with this form's main thread curclient.SetInvokationTarget(new InvokationTarget(this), false); //prevent deadlocks by telling UOAIBasic to execute all methods that might trigger an event asynchronously curclient.SetAsync("IClient", "Macro", true); curclient.SetAsync("IClient", "SysMessage", true); curclient.SetAsync("INetworkObject", "SendPacket", true); curclient.SetAsync("INetworkObject", "HandlePacket", true); //install eventhandlers curclient.OnKeyUp += new OnKeyUpDelegate(cures_OnKeyUp); curclient.OnKeyDown += new OnKeyDownDelegate(cures_OnKeyDown); curclient.OnQuit += new SimpleDelegate(curclient_OnQuit); //curclient.OnWindowsMessage += new OnWindowsMessageDelegate(curclient_OnWindowsMessage); NetworkObject = curclient.NetworkObject; NetworkObject.OnPacketHandled += new SimpleDelegate(NetworkObject_OnPacketHandled); NetworkObject.onPacketRecieve += new OnPacketDelegate(NetworkObject_onPacketRecieve); NetworkObject.onPacketSend += new OnPacketDelegate(NetworkObject_onPacketSend); } else { curclient = null; NetworkObject = null; MessageBox.Show("No Running Client Found!"); } }
public NetworkContext RegisterComponent(INetworkComponent component) { INetworkObject networkObject = null; if (component is INetworkObject) { networkObject = component as INetworkObject; } else { foreach (var item in (component as MonoBehaviour).GetComponentsInParent <MonoBehaviour>()) // search up { if (item is INetworkObject) { networkObject = item as INetworkObject; break; } } } actions.Add((Action)(() => // this may be called while iterating over objectproperties, so register it to execute when outside of the iterator { if (!objectProperties.ContainsKey(networkObject)) { objectProperties.Add(networkObject, new ObjectProperties() { identity = networkObject, scene = this, }); } objectProperties[networkObject].components[GetComponentId(component)] = component; })); NetworkContext context = new NetworkContext(); context.scene = this; context.networkObject = networkObject; context.componentId = GetComponentId(component); return(context); }
public NetworkContext RegisterComponent(INetworkComponent component) { INetworkObject networkObject = null; if (component is INetworkObject) { networkObject = component as INetworkObject; } else { foreach (var item in (component as MonoBehaviour).GetComponentsInParent <MonoBehaviour>()) // search up { if (item is INetworkObject) { networkObject = item as INetworkObject; break; } } } if (!objectProperties.ContainsKey(networkObject)) { objectProperties.Add(networkObject, new ObjectProperties() { identity = networkObject, scene = this, }); } objectProperties[networkObject].components[GetComponentId(component)] = component; NetworkContext context = new NetworkContext(); context.scene = this; context.networkObject = networkObject; context.componentId = GetComponentId(component); context.component = component; return(context); }
// ------------------------------------------- /* * Get the maximum unique identificator to assign to the new cube */ private int GetMaximumUniqueIdentificatorTypes() { int finalUID = 0; CleanNULLObjects(); for (int i = 0; i < m_types.Count; i++) { INetworkObject type = m_types[i].GetComponent <INetworkObject>(); if (finalUID <= type.UID) { finalUID = type.UID + 1; } } if (finalUID <= m_currentMaximumTypes) { finalUID = m_currentMaximumTypes + 1; } m_currentMaximumTypes = finalUID; return(finalUID); }
// ------------------------------------------- /* * Get the maximum unique identificator to assign to the new cube */ private int GetMaximumUniqueIdentificatorObjects() { int finalUID = 0; CleanNULLObjects(); for (int i = 0; i < m_objects.Count; i++) { INetworkObject obj = m_objects[i].GetComponent <INetworkObject>(); if (finalUID <= obj.UID) { finalUID = obj.UID + 1; } } if (finalUID <= m_currentMaximumObjects) { finalUID = m_currentMaximumObjects + 1; } m_currentMaximumObjects = finalUID; return(finalUID); }
static void StartAll(string[] args) { // veriables INetworkObject inlet = null; INetworkObject outlet = null; DataManagement.IDataStore <string> dataStore = null; string[] options = args; int cindex = 2; // determine the inlet if (IsFrameWork(options[cindex])) { switch (options[cindex]) { case "lsl": // run LSL try { // get the new input inlet = new LSLInputConsoleWalkthough( options[++cindex], options[++cindex], int.Parse(options[++cindex]), options[++cindex].Equals("-D"), true); if (inlet == null) { return; } else { dataStore = ((LSLInputConsoleWalkthough)inlet).DataManager; } break; } catch (Exception e) { Console.WriteLine(e.Message); return; } case "udp": //TODO run UDP listener break; } } // the the current C index equals the d move forward one to get to the next marker if (options[cindex].ToLower().Equals("-d")) { cindex++; } // work out the outlet details switch (options[cindex].ToLower()) { case "lsl": //TODO run LSL case "udp": // Run UDP client try { outlet = new UDPOutlet(int.Parse(options[++cindex]), options[++cindex], dataStore); } catch (Exception e) { Console.WriteLine(e.Message); return; } break; } if (outlet != null && inlet != null) { inlet.Start(); outlet.Start(); Console.ReadKey(); inlet.Stop(); outlet.Stop(); outlet.Stop(); } return; }
public override void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager) { throw new System.NotImplementedException(); }
protected virtual void OnMessage(INetworkObject obj) { Message?.Invoke(obj); }
/// <summary> /// Sets the Network Object Id so that it will be consistent for this particular GameObject instance across /// different processes. /// This is currently based on the Name. There cannot be two objects with the same directory registered. /// </summary> /// <param name="monoBehaviour"></param> public static NetworkId ObjectIdFromName(INetworkObject monoBehaviour) { return((monoBehaviour as MonoBehaviour).GetComponentInParent <NetworkScene>().GetObjectIdFromName(monoBehaviour)); }
protected virtual void AddNetMessage(List<byte> msgs, List<byte> riMsgs, List<byte> ruMsgs, List<byte> uriMsgs, List<byte> uruMsgs, INetworkObject networkObj) { byte[] id = ByteHelper.ConvertToByte(networkObj.Identifier); byte[] data = networkObj.GetMessage(); int totalSize = id.Length + data.Length + 1; if (totalSize > maxNetworkObjSize || totalSize < 0) throw new GoblinException(networkObj.Identifier + " contains data larger than the current " + "transfer size of " + maxNetworkObjSize + ". Change the TransferSize to a larger size."); byte[] size = null; switch (transferSize) { case TransferSize.Byte: size = new byte[1]; size[0] = (byte)totalSize; break; case TransferSize.UShort: size = BitConverter.GetBytes((ushort)totalSize); break; case TransferSize.Int: size = BitConverter.GetBytes(totalSize); break; } msgs.AddRange(size); msgs.Add((byte)networkObj.Identifier.Length); msgs.AddRange(id); msgs.AddRange(data); if (networkObj.Reliable) { if (networkObj.Ordered) riMsgs.AddRange(msgs); else ruMsgs.AddRange(msgs); } else { if (networkObj.Ordered) uriMsgs.AddRange(msgs); else uruMsgs.AddRange(msgs); } msgs.Clear(); }
// ------------------------------------------- /* * Manager of global events */ protected virtual void OnNetworkEvent(string _nameEvent, bool _isLocalEvent, int _networkOriginID, int _networkTargetID, params object[] _list) { if (_nameEvent == NetworkEventController.EVENT_SYSTEM_INITIALITZATION_LOCAL_COMPLETED) { Initialitzation(); } if (_nameEvent == NetworkEventController.EVENT_COMMUNICATIONSCONTROLLER_REQUEST_TO_CREATE_NETWORK_OBJECT) { string nameClassResources = (string)_list[0]; string typeObjects = (string)_list[1]; string prefabName = (string)_list[2]; Vector3 positionCreate = (Vector3)_list[3]; string assignedName = (string)_list[4]; bool allowServerChange = (bool)_list[5]; bool allowClientChange = (bool)_list[6]; int newUniqueIdentificator = -1; switch (typeObjects) { case NetworkEventController.REGISTER_PREFABS_OBJECTS: newUniqueIdentificator = GetMaximumUniqueIdentificatorObjects(); break; } GameObject instanceExisting = GetInstanceByAssignedName(assignedName); if (instanceExisting == null) { NetworkEventController.Instance.DispatchLocalEvent(NetworkEventController.EVENT_PLAYERCONNECTIONCONTROLLER_CREATE_NETWORK_OBJECT, this.GetType().Name, typeObjects, prefabName, newUniqueIdentificator, positionCreate, false, assignedName, allowServerChange, allowClientChange); } else { Debug.LogError("WorldObjectController::ERROR::THE ASSIGNED NAME NETWORK VARIABLE EXISTS[" + assignedName + "]"); } } if (_nameEvent == NetworkEventController.EVENT_COMMUNICATIONSCONTROLLER_CREATION_CONFIRMATION_NETWORK_OBJECT) { #if !DISABLE_UNET_COMMS GameObject reference = (GameObject)_list[0]; INetworkObject objData = reference.GetComponent <INetworkObject>(); reference.name = PlayerConnectionController.GetNameIdentificator(objData.PrefabName, objData.UID, objData.NetID); if (GetInstanceByAssignedName(objData.AssignedName) == null) { switch (objData.TypeObject) { case NetworkEventController.REGISTER_PREFABS_OBJECTS: Debug.Log("CONFIRMATION NETWORK **OBJECT** CREATED[" + reference.name + "] ASSIGNED NAME[" + objData.AssignedName + "] FROM CLIENT [" + objData.NetID + "]+++++++++++++++++++++++++++++++++++++++++++++++++++++"); m_objects.Add(reference); break; } } else { Debug.LogError("WorldObjectController::ERROR::ASSIGNED NAME ALREADY USED!!!!!!!!!!!!!!!!!!!!!!!!!!"); } #endif } if (_nameEvent == NetworkEventController.EVENT_PLAYERCONNECTIONCONTROLLER_DESTROY_NETWORK_OBJECT) { string nameToDestroy = (string)_list[0]; GameObject objectToDestroy = GetInstanceByUID(nameToDestroy); if (objectToDestroy != null) { if (objectToDestroy.GetComponent <INetworkObject>() != null) { string assignedName = objectToDestroy.GetComponent <INetworkObject>().AssignedName; switch (objectToDestroy.GetComponent <INetworkObject>().TypeObject) { case NetworkEventController.REGISTER_PREFABS_OBJECTS: if (m_objects.Remove(objectToDestroy)) { Debug.Log("WorldObjectController::CONFIRMATION NETWORK **OBJECT** DESTROYED[" + nameToDestroy + "]---------------------------------------"); GameObject.Destroy(objectToDestroy); objectToDestroy = null; } break; } NetworkEventController.Instance.DispatchLocalEvent(NetworkEventController.EVENT_WORLDOBJECTCONTROLLER_DESTROY_CONFIRMATION, assignedName); } } } if (_nameEvent == NetworkEventController.EVENT_PLAYERCONNECTIONCONTROLLER_DESTROY_CONFIRMATION_NETWORK_OBJECT) { int cleaned = CleanNULLObjects(); Debug.Log("WorldObjectController::TOTAL NETWORK OBJECTS DELETED[" + cleaned + "]!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); } if (_nameEvent == NetworkEventController.EVENT_COMMUNICATIONSCONTROLLER_REGISTER_ALL_NETWORK_PREFABS) { // REGISTER ALL PREFABS FOR NETWORK for (int i = 0; i < WorldObjects.Length; i++) { NetworkEventController.Instance.DispatchLocalEvent(NetworkEventController.EVENT_COMMUNICATIONSCONTROLLER_REGISTER_PREFAB, this.GetType().Name, NetworkEventController.REGISTER_PREFABS_OBJECTS, WorldObjects[i].name); } } if (_nameEvent == YourNetworkTools.EVENT_YOURNETWORKTOOLS_DESTROYED_GAMEOBJECT) { GameObject destroyedObject = (GameObject)_list[0]; for (int i = 0; i < m_objects.Count; i++) { if (m_objects[i] == destroyedObject) { m_objects.RemoveAt(i); return; } } } }
public override void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager) { target.CopyFrom(Component); }
public virtual void AddNetworkObject(INetworkObject networkObj) { // busy wait while the network handler is being updated while (updating) { } if (!networkObjects.ContainsKey(networkObj.Identifier)) { if (networkObj.Identifier.Length > 255) throw new GoblinException("A network object's Identifier should not exceed 255 " + "characters long"); networkObjects.Add(networkObj.Identifier, new NetObj(networkObj)); } }
public INetworkConnection(INetworkPeer peer, INetworkObject gobject) { this.ParentPeer = peer; this.GameObjectController = gobject; }
public virtual void RemoveNetworkObject(INetworkObject networkObj) { // busy wait while the network handler is being updated while (updating) { } networkObjects.Remove(networkObj.Identifier); }
public abstract void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager);
public void Instantiate(GameObject obj) { networkObject = GameObject.Instantiate(obj, position, rotation).GetComponent <INetworkObject>(); networkObject.Init(playerId, objectId, networkId); }
public INetworkConnection(INetworkPeer peer) { this.ParentPeer = peer; this.GameObjectController = null; }
public NetObj(INetworkObject netObj) { this.networkObject = netObj; timeElapsedSinceLastTransmit = 0; if (networkObject.SendFrequencyInHertz != 0) transmitSpan = 1000 / (float)networkObject.SendFrequencyInHertz; else transmitSpan = float.MaxValue; }