protected override void Read(DataStreamReader stream)
{
var readerLength = Readers.Count;
for (int i = 0; i < readerLength; i++)
{
INetworkReader reader = Readers[i];
var context = default(DataStreamReader.Context);
var header = reader.Match(stream, ref context);
if (!header.Matched)
{
continue;
}
reader.Read(stream, ref context);
// Need to come up with a nicer way
if (reader is SpawnRPC spawnRpc)
{
var spawner = FindObjectOfType <SpawnSystem>();
var spawnData = spawnRpc.Data;
var position = spawnData.Position;
var rotation = spawnData.Rotation;
spawner.SpawnInClient(spawnData.PrefabId, spawnData.InstanceId, (int)spawnData.Ownership, position, rotation, this);
}
}
}
protected override void Read(int connectionId, DataStreamReader stream, ref DataStreamReader.Context context)
{
var readerLength = Readers.Count;
for (int i = 0; i < readerLength; i++)
{
INetworkReader reader = Readers[i];
var readerContext = default(DataStreamReader.Context);
var header = reader.Match(stream, ref readerContext);
if (!header.Matched)
{
continue;
}
reader.Read(stream, ref readerContext);
// TODO This should be refactored to not have to check
if (reader is SpawnRequestRPC spawnRpc)
{
var spawner = FindObjectOfType <SpawnSystem>();
var spawnData = spawnRpc.Data;
// Passing the connection id will make it owned by the connection.
spawner.SpawnInServer(spawnData.PrefabId, spawnData.Position, spawnData.Rotation, null);
}
SuccessfullyRead(reader, connectionId);
}
}
private void SuccessfullyRead(INetworkReader reader, int connectionId)
{
if (!_pingMap.ContainsKey(connectionId))
{
return;
}
var lastSent = _pingMap[connectionId];
lastSent[lastSent.Count - 1].ReceivedTime = Time.time;
}
public void unregister(INetworkReader _reader)
{
if( _reader == null )
return;
// 각 키에 존재하는 reader를 지워줌
foreach( List<INetworkReader> _readersForEachKey in readers.Values )
{
if( _readersForEachKey.Contains( _reader ) )
_readersForEachKey.Remove( _reader );
}
}
internal ReceivedRpcCall(
int program,
int[] versions,
INetworkReader networkReader,
INetworkWriter networkWriter,
Action <ReceivedRpcCall> receivedCallDispatcher)
{
this.program = program;
this.receivedCallDispatcher = receivedCallDispatcher;
this.lowVersion = (uint)versions.Min();
this.highVersion = (uint)versions.Max();
this.xdrReader = new XdrReader(networkReader);
this.xdrWriter = new XdrWriter(networkWriter);
}
public void register(INetworkReader _reader, List<PacketType_SC> _receivePacketType)
{
if( _reader == null )
return;
if( _receivePacketType == null )
return;
foreach( PacketType_SC type in _receivePacketType )
{
//print ("type"+type+" added for reader" + _reader);
lock(this)
{
// 만약 해당 페킷 타입이 처음 등
if( readers.ContainsKey(type) == false )
readers.Add( type, new List<INetworkReader>() );
// 해당 페킷 타입에 현재 reader를 추가
if( readers[type].Contains(_reader) == false )
readers[type].Add( _reader);
}
}
}
public RpcCall(
int program,
IPEndPoint remoteIpEndPoint,
INetworkReader networkReader,
INetworkWriter networkWriter,
Action reestablishConnection,
ILogger logger = default)
{
this.remoteIpEndPoint = remoteIpEndPoint;
this.networkReader = networkReader;
this.networkWriter = networkWriter;
this.xdrReader = new XdrReader(networkReader);
this.xdrWriter = new XdrWriter(networkWriter);
this.rpcMessage = new RpcMessage
{
Body = new Body
{
MessageType = MessageType.Call,
CallBody = new CallBody
{
RpcVersion = 2,
Program = (uint)program,
Credential = new OpaqueAuthentication
{
AuthenticationFlavor = AuthenticationFlavor.None, Body = new byte[0]
},
Verifier = new OpaqueAuthentication
{
AuthenticationFlavor = AuthenticationFlavor.None, Body = new byte[0]
}
}
}
};
this.logger = logger;
this.reestablishConnection = reestablishConnection;
}
public static void RegisterDecoder(ServerCommands command, INetworkReader decoder)
{
if (decoders.ContainsKey(command))
throw new ArgumentException("Command is allready registered!", nameof(command));
decoders.Add(command, decoder);
}
public UdpMessageListener(int port)
{
reader = NetworkingFactory.UdpReader <E>(port);
}
public XdrReader(INetworkReader networkReader)
{
this.networkReader = networkReader;
}
public void Add(INetworkReader reader)
{
Readers.Add(reader);
}
