public void CompleteInitialization(NetworkObject networkObject)
{
lock (NetworkObjects)
{
NetworkObjects.Add(networkObject.NetworkId, networkObject);
NetworkObjectList.Add(networkObject);
}
List <Action <NetworkObject> > actions = null;
lock (missingObjectBuffer)
{
missingObjectBuffer.TryGetValue(networkObject.NetworkId, out actions);
missingObjectBuffer.Remove(networkObject.NetworkId);
}
if (actions == null)
{
return;
}
foreach (var action in actions)
{
action(networkObject);
}
}
/// <summary>
/// Creates a frame for a specific transmitter and list
/// </summary>
/// <param name="transmitter"></param>
/// <param name="objectList"></param>
/// <returns></returns>
private Frame CreateFrame(NetworkFrameListTransmitter transmitter, NetworkObjectList objectList)
{
var previousFrame = transmitter.CurrentList?.FindFrameByListId(objectList.Id);
var frame = new Frame(objectList.Id);
transmitter.Listener.OnBeginProcessList(objectList);
foreach (var networkObject in objectList.InternalNetworkObjects)
{
if (networkObject.Destroyed)
{
frame.CreateObjectDestruction(networkObject.Handle.Id);
//Don't remove a destroyed object's data from previous frames, we may need to reconstruct it for lag compensation
}
else
{
if (transmitter.Listener.FilterNetworkObject(objectList, networkObject))
{
frame.CreateUpdate(networkObject, previousFrame);
}
}
}
transmitter.Listener.OnEndProcessList(objectList);
return(frame);
}
public void CompleteInitialization(NetworkObject networkObject)
{
lock (NetworkObjects)
{
if (!NetworkObjects.ContainsKey(networkObject.NetworkId))
{
NetworkObjects.Add(networkObject.NetworkId, networkObject);
NetworkObjectList.Add(networkObject);
}
}
}
/// <summary>
/// Used to manually remove a networkobject from the networker
/// </summary>
/// <param name="networkObject"></param>
public void ManualRemove(NetworkObject networkObject)
{
lock (NetworkObjects)
{
NetworkObjects.Remove(networkObject.NetworkId);
}
lock (NetworkObjectList)
{
NetworkObjectList.Remove(networkObject);
}
}
public void NetworkObjectListWorksProperly2()
{
GameObject go_a = new GameObject();
GameObject go_b = new GameObject();
GameObject go_c = new GameObject();
NetworkObjectList list = new NetworkObjectList();
Assert.True(list.IsVacant(0));
list[0] = go_a;
Assert.False(list.IsVacant(0));
Assert.AreSame(go_a, list[0]);
GameObject go_d = list.RemoveAt(0);
Assert.AreSame(go_a, go_d);
Assert.True(list.IsVacant(0));
}
/// <summary>
/// Used to manually remove a bunch of networkobjects from the networker
/// </summary>
/// <param name="networkObjects"></param>
public void ManualRemove(List <NetworkObject> networkObjects)
{
foreach (NetworkObject obj in networkObjects)
{
lock (NetworkObjects)
{
NetworkObjects.Remove(obj.NetworkId);
}
}
foreach (NetworkObject obj in networkObjects)
{
lock (NetworkObjectList)
{
NetworkObjectList.Remove(obj);
}
}
}
/// <summary>
/// Creates a new list with the given name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public INetworkObjectList CreateList(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("Network object list name should contain at least one valid character", nameof(name));
}
if (FindListByName(name) != null)
{
throw new ArgumentException($"A list with name \"{name}\" already exists", nameof(name));
}
var objectList = new NetworkObjectList(this, name, _objectLists.Count);
_objectLists.Add(objectList);
return(objectList);
}
public FrameMessage Serialize(NetworkObjectList objectList, Frame previousFrame)
{
var updateList = new List <MemoryStream>();
foreach (var update in _updates)
{
var data = update.Serialize(objectList.InternalGetNetworkObjectById(update.ObjectHandle.Id), previousFrame?.FindUpdateByObjectId(update.ObjectHandle.Id));
//TODO: figure out if there's a better way to handle change detection during serialization
//if (data.ContainsChanges)
{
data.Memory.Position = 0;
updateList.Add(data.Memory);
}
}
var stream = new MemoryStream();
using (var codedStream = new CodedOutputStream(stream, true))
{
codedStream.WriteInt32(updateList.Count);
foreach (var update in updateList)
{
codedStream.WriteBytes(ByteString.FromStream(update));
update.Dispose();
}
}
stream.Position = 0;
var frameMessage = new FrameMessage
{
ListId = (uint)ListId,
ObjectUpdates = ByteString.FromStream(stream)
};
stream.Dispose();
frameMessage.ObjectsDestroyed.AddRange(_destroyedObjects);
return(frameMessage);
}
public void NetworkObjectListWorksProperly()
{
NetworkObjectList list = new NetworkObjectList();
GameObject go_a = new GameObject();
GameObject go_b = new GameObject();
GameObject go_c = new GameObject();
GameObject go_d = new GameObject();
list[0] = go_a;
Assert.AreSame(go_a, list[0]);
list[1] = go_b;
Assert.AreSame(go_b, list[1]);
list[2] = go_c;
Assert.AreSame(go_b, list[1]);
Assert.AreSame(go_b, list.RemoveAt(1));
Assert.Null(list[1]);
Assert.Null(list.RemoveAt(1));
Assert.NotNull(list[2]);
list[1] = go_d;
Assert.NotNull(list[2]);
Assert.AreSame(go_c, list[2]);
Assert.AreSame(go_c, list.RemoveAt(2));
}
/// <summary>
/// Register a networked object with this networker
/// </summary>
/// <param name="networkObject">The object that is to be registered with this networker</param>
/// <returns><c>true</c> if the object was registered successfully, else <c>false</c> if it has already been registered</returns>
public bool RegisterNetworkObject(NetworkObject networkObject, uint forceId = 0)
{
uint id = currentNetworkObjectId;
lock (NetworkObjects)
{
// If we are forcing this object
if (forceId != 0)
{
if (NetworkObjects.ContainsKey(forceId))
{
return(false);
}
id = forceId;
if (!networkObject.RegisterOnce(id))
{
throw new BaseNetworkException("The supplied network object has already been assigned to a networker and has an id");
}
//AddNetworkObject(forceId, networkObject);
//NetworkObjectList.Add(networkObject);
}
else
{
do
{
if (NetworkObjects.ContainsKey(++currentNetworkObjectId))
{
continue;
}
if (!networkObject.RegisterOnce(currentNetworkObjectId))
{
// Backtrack since the next call to this method will increment before checking
currentNetworkObjectId--;
throw new BaseNetworkException("The supplied network object has already been assigned to a networker and has an id");
}
//AddNetworkObject(currentNetworkObjectId, networkObject);
//NetworkObjectList.Add(networkObject);
break;
} while (IsBound);
}
}
// Assign the network id to the network object
networkObject.RegisterOnce(id);
// When this object is destroyed it needs to remove itself from the list
networkObject.onDestroy += (NetWorker sender) =>
{
lock (NetworkObjects)
{
NetworkObjects.Remove(networkObject.NetworkId);
NetworkObjectList.Remove(networkObject);
}
};
return(true);
}
private NetworkObject CreateNetworkObject(NetworkObjectList objectList, TypeMetaData metaData, in ObjectHandle objectHandle)
