/// <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;
}
