public ReplicationTransmission(int inNetworkId, ReplicationAction inAction, uint32_t inState, byte inWorldId)
{
mNetworkId = inNetworkId;
mAction = inAction;
mState = inState;
mWorldId = inWorldId;
}
public void HandleCreateAckd()
{
if (mAction == ReplicationAction.RA_Create)
{
mAction = ReplicationAction.RA_Update;
}
}
public void ClearDirtyState(uint32_t inStateToClear)
{
mDirtyState &= ~inStateToClear;
if (mAction == ReplicationAction.RA_Destroy)
{
mAction = ReplicationAction.RA_Update;
}
}
public void AddTransmission(int inNetworkId, ReplicationAction inAction, uint32_t inState)
{
//it would be silly if we already had a transmission for this network id in here...
//for( const auto& transmission: mTransmissions )
//{
// assert( inNetworkId != transmission.GetNetworkId() );
//}
mTransmissions.Add(new ReplicationTransmission(inNetworkId, inAction, inState));
}
public void AddTransmission(int inNetworkId, ReplicationAction inAction, uint32_t inState, byte inWorldId)
{
//it would be silly if we already had a transmission for this network id in here...
foreach (var transmission in mTransmissions)
{
//assert(inNetworkId != transmission.GetNetworkId());
if (inNetworkId == transmission.GetNetworkId())
{
Log.Warning($"AddTransmission inNetworkID:{inNetworkId}, transmission.NetworkID:{transmission.GetNetworkId()}");
}
}
mTransmissions.Add(new ReplicationTransmission(inNetworkId, inAction, inState, inWorldId));
}
public void Write(NetOutgoingMessage inOutputStream, ReplicationManagerTransmissionData ioTransmissinData)
{
//run through each replication command and do something...
foreach (var pair in mNetworkIdToReplicationCommand)
{
ReplicationCommand replicationCommand = pair.Value;
if (replicationCommand.HasDirtyState())
{
int networkId = pair.Key;
//well, first write the network id...
inOutputStream.Write(networkId);
//only need 2 bits for action...
ReplicationAction action = replicationCommand.GetAction();
inOutputStream.Write(action);
uint32_t writtenState = 0;
uint32_t dirtyState = replicationCommand.GetDirtyState();
//now do what?
switch (action)
{
case ReplicationAction.RA_Create:
writtenState = WriteCreateAction(inOutputStream, networkId, dirtyState);
break;
case ReplicationAction.RA_Update:
writtenState = WriteUpdateAction(inOutputStream, networkId, dirtyState);
break;
case ReplicationAction.RA_Destroy:
//don't need anything other than state!
writtenState = WriteDestroyAction(inOutputStream, networkId, dirtyState);
break;
}
ioTransmissinData.AddTransmission(networkId, action, writtenState);
//let's pretend everything was written- don't make this too hard
replicationCommand.ClearDirtyState(writtenState);
}
}
}
public void SetDestroy()
{
mAction = ReplicationAction.RA_Destroy;
}
public ReplicationCommand(uint32_t inInitialDirtyState)
{
mAction = ReplicationAction.RA_Create;
mDirtyState = inInitialDirtyState;
}
public static void Read(this NetBuffer buff, out ReplicationAction r)
{
r = (ReplicationAction)buff.ReadByte(2);
}
public static void Write(this NetBuffer buff, ReplicationAction r)
{
buff.Write((byte)r, 2);
}
public static void Read(this NetBuffer buff, out ReplicationAction r)
{
r = (ReplicationAction)buff.ReadByte(ReplicationCommand.ReplicationActionTypeSize);
}
public static void Write(this NetBuffer buff, ReplicationAction r)
{
buff.Write((byte)r, ReplicationCommand.ReplicationActionTypeSize);
}
public ReplicateResultDetail(string channelName, ReplicationAction action)
{
ChannelName = channelName;
Action = action;
}
public ReplicationTransmission(int inNetworkId, ReplicationAction inAction, uint32_t inState)
{
mNetworkId = inNetworkId;
mAction = inAction;
mState = inState;
}
public int Write(NetOutgoingMessage inOutputStream, ReplicationManagerTransmissionData ioTransmissinData, int inRestartedNetworkId, byte inWorldId)
{
int count = 0;
bool skip = (inRestartedNetworkId != 0);
//run through each replication command and do something...
List <int> removeObject = null;
foreach (var pair in mNetworkIdToReplicationCommand)
{
ReplicationCommand replicationCommand = pair.Value;
if (replicationCommand.HasDirtyState())
{
// 이전에 중단 되었던 network ID 부터 재개
if (skip)
{
if (inRestartedNetworkId == pair.Key)
{
skip = false;
}
else
{
continue;
}
}
int networkId = pair.Key;
ReplicationAction action = replicationCommand.GetAction();
NetGameObject gameObject = NetworkManagerServer.sInstance.GetGameObject(networkId, inWorldId);
if (gameObject == null && action != ReplicationAction.RA_Destroy)
{
if (removeObject == null)
{
removeObject = new List <int>();
}
removeObject.Add(networkId);
continue;
}
// 최대로 동기화 할수 있는 개수 초과시 중단
++count;
if (count > max_replication_count)
{
return(pair.Key);
}
//well, first write the network id...
inOutputStream.Write((uint)networkId, NetGameObject.NetworkIdSize);
//Log.Information($"write networkId:{networkId}, classId:{gameObject?.GetClassId()}, action:{action}");
//only need 2 bits for action...
inOutputStream.Write(action);
uint32_t writtenState = 0;
uint32_t dirtyState = replicationCommand.GetDirtyState();
//now do what?
switch (action)
{
case ReplicationAction.RA_Create:
{
inOutputStream.Write(gameObject.GetClassId());
writtenState = gameObject.Write(inOutputStream, dirtyState);
}
break;
case ReplicationAction.RA_Update:
{
writtenState = gameObject.Write(inOutputStream, dirtyState);
}
break;
case ReplicationAction.RA_Destroy:
{
//don't need anything other than state!
writtenState = dirtyState;
}
break;
}
ioTransmissinData.AddTransmission(networkId, action, writtenState, inWorldId);
//let's pretend everything was written- don't make this too hard
replicationCommand.ClearDirtyState(writtenState);
}
}
if (removeObject != null)
{
foreach (var key in removeObject)
{
mNetworkIdToReplicationCommand.Remove(key);
}
}
return(0);
}
