private void ResponseConnect(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Warn($"已经存在连接{endPoint}!无需重复连接");
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Connect, packetHead);
return;
}
var service = PoolAllocator <SocketService> .GetObject();
service.Connection.RemoteAddress = endPoint;
if (_connections.TryAdd(endPoint, service))
{
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
HandleAccept?.Invoke(service, readStream, writeStream);
var byteSegment = writeStream.ToByteFragment();
Acknowledge(service, SendOption.Acknowledge | SendOption.Connect, packetHead, writeStream);
SocketStatistics.LogAcknowledgementSend();
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogDataBytesReceived(byteSegment.Count);
SocketStatistics.LogTotalBytesReceived(writeStream.ToByteFragment().Count);
}
Logger.Info($"创建{endPoint}连接心跳包！");
}
else
{
Logger.Error($"添加连接{endPoint}失败!");
}
}
private bool Acknowledge(
SocketService socketService,
SendOption sendOption,
PacketHead packetHead,
IWriteStream writeStream = null)
{
if (socketService == null)
{
Logger.Error($"{nameof(socketService)} 为 null ！");
return(false);
}
var fragment = writeStream?.ToByteFragment();
packetHead.Length = fragment.HasValue ? (ushort)(PacketHead.GetSize() + fragment?.Count) : (ushort)PacketHead.GetSize();
packetHead.SendOption = sendOption;
var ws = PoolAllocator <IWriteStream> .GetObject();
if (writeStream != null)
{
ws.ShiftRight(writeStream.ToByteFragment());
}
Packet.ToBytes(packetHead, ws);
var byteSegment = ws.ToByteFragment();
var result = StartWrite(socketService, byteSegment.Buffer, byteSegment.Offset, byteSegment.Count, ws, true);
SocketStatistics.LogUnreliableSend();
SocketStatistics.LogTotalBytesSent(packetHead.Length);
return(true);
}
public Pool(PoolAllocator alloc, PoolDeallocator dealloc)
{
free = new Queue <TItem>();
allocator = alloc;
deallocator = dealloc;
}
public override void Start(SocketConfig socketConfig)
{
if (socketConfig == null)
{
throw new ArgumentNullException(nameof(socketConfig));
}
_connections = new ConcurrentDictionary <EndPoint, SocketService>();
if (socketConfig.OpenKeepAlive)
{
_udpKeepAlive = new UdpKeepAlive();
_udpKeepAlive.Start(socketConfig.KeepAliveInterval, socketConfig.ReconnectMaxCount);
}
if (socketConfig.OpenFragmentResend)
{
_fragmentTimer = new FragmentsTimer();
_fragmentTimer.Start(socketConfig.FragmentInterval);
}
var endPoint = new IPEndPoint(IPAddress.Parse(socketConfig.IP), socketConfig.Port);
_readSocket = CreateSocket(endPoint.AddressFamily, endPoint);
var socketService = PoolAllocator <SocketService> .GetObject();
socketService.Connection.LocalAddress = endPoint;
BeginRead(socketService);
}
private async void ReceiveAsync(object state)
{
var networkConfig = state as NetworkConfig;
using (var readStream = PoolAllocator <IReadStream> .GetObject()) {
while (true)
{
UdpReceiveResult result;
try {
result = await _writer.ReceiveAsync();
} catch (ObjectDisposedException) {
//Logger.Error(e.ToString());
break;
} catch (SocketException e) {
Logger.Error(e.ToString());
continue;
}
var length = result.Buffer.ToValue <ushort>();
Logger.Debug("数据长度：" + length);
if (length == result.Buffer.Length)
{
readStream.CopyBuffer(result.Buffer, 0, length);
Logger.Debug("开始读取！");
try {
OnRead(networkConfig, result.RemoteEndPoint, readStream);
} catch (Exception e) {
Logger.Error(e);
}
}
readStream.Reset();
}
}
}
public UdpSocket(int nextHeadOffset, NetworkConfig networkConfig)
{
_networkConfig = networkConfig ?? throw new ArgumentNullException(nameof(networkConfig));
_tokenSource = new CancellationTokenSource();
_autoResetEvent = new AutoResetEvent(false);
_connections = new ConcurrentDictionary <EndPoint, SocketService>();
_fragmentsTimer = new FragmentsTimer();
_nextHeadOffset = nextHeadOffset;
PoolAllocator <IWriteStream> .SetPool(args =>
ObjectFactory.GetActivator <IWriteStream>(typeof(WriteStream).GetConstructors().First())());
PoolAllocator <IReadStream> .SetPool(args =>
ObjectFactory.GetActivator <IReadStream>(typeof(ReadStream).GetConstructors().First())());
if (_networkConfig.KeepAlive)
{
UdpKeepAlive.Start(_networkConfig.AckInterval, _networkConfig.MaxReconnectCount);
}
if (_networkConfig.FragmentResend)
{
_fragmentsTimer.Start(_networkConfig.ResendInterval);
}
var ipAddress = new IPEndPoint(IPAddress.Parse(_networkConfig.ServerIp), _networkConfig.ServerPort);
_writer = new UdpClient(ipAddress.AddressFamily)
{
Client = CreateSocket(ipAddress.AddressFamily, null)
};
Task.Factory.StartNew(ReceiveAsync, _networkConfig, _tokenSource.Token);
}
public Serializable(object _ = null)
{
WriteStream = PoolAllocator <IWriteStream> .GetObject();
_endianBinaryWriter = new EndianBinaryWriter(WriteStream);
WriteStream.ShiftRight((byte)0);
}
private void AcknowledgeConnect(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (_connections.ContainsKey(endPoint))
{
Logger.Warn($"{endPoint}已经连接，无需重复连接！");
return;
}
var service = PoolAllocator <SocketService> .GetObject();
service.Connection.RemoteAddress = endPoint;
service.Connection.LocalAddress = _readSocket.LocalEndPoint as IPEndPoint;
if (_connections.TryAdd(endPoint, service))
{
CreateAck(service);
HandleConnect?.Invoke(service, readStream);
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogAcknowledgementReceive();
SocketStatistics.LogDataBytesReceived(packetHead.TotalBytes);
SocketStatistics.LogTotalBytesReceived(packetHead.Length);
Logger.Info($"{endPoint}连接成功！");
}
else
{
Logger.Error($"添加连接{endPoint}失败!");
}
}
public override void ConnectionGenerator(IPEndPoint remoteAddress, IWriteStream writeStream, Action <SocketService> action)
{
if (remoteAddress == null)
{
throw new ArgumentNullException(nameof(remoteAddress));
}
if (_connections.TryGetValue(remoteAddress, out var socketService))
{
Logger.Warn($"已经存在连接{remoteAddress}!无需重复连接");
WriteMessage(socketService, SendOption.Acknowledge | SendOption.Connect, null);
return;
}
socketService = PoolAllocator <SocketService> .GetObject();
socketService.Connection.RemoteAddress = remoteAddress;
if (_connections.TryAdd(remoteAddress, socketService))
{
action?.Invoke(socketService);
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Connect, new PacketHead(), writeStream);
CreateAck(socketService);
Logger.Info($"创建{remoteAddress}连接心跳包！");
}
else
{
Logger.Error($"添加连接{remoteAddress}失败!");
}
}
protected virtual void Initialize()
{
PoolAllocator <ISecurityComponent> .SetPool(
args => ObjectFactory.GetActivator <ISecurityComponent>(
typeof(SecurityComponent).GetConstructors().First())());
RegisterModules(ModuleManager);
}
public IReadStream Clone()
{
var readStream = PoolAllocator <IReadStream> .GetObject() as ReadStream;
Array.Copy(_buffer, readStream._buffer, _buffer.Length);
readStream._maxCount = _maxCount;
readStream._currentReadCount = _currentReadCount;
readStream._rightOffsetRead = _rightOffsetRead;
readStream._startOffset = _startOffset;
return(readStream);
}
public IUser AddListener(SocketService socketService)
{
var peer = PoolAllocator <IPeer> .GetObject() as Peer;
peer.SetStatus(ConnectionStatus.Connected, socketService, this);
socketService.HandleDisconnect += () => {
if (peer.Status != ConnectionStatus.Connected)
{
return;
}
Disconnected?.Invoke(peer);
peer.Recycle();
};
socketService.HandleRead += (readStream) => {
var tmp = readStream.Clone();
_messageQueue.Enqueue(() => {
var securityComponent = peer.GetComponent <ISecurityComponent>();
if (securityComponent == null)
{
Logger.Error($"{nameof(securityComponent)}组件为空！");
return;
}
var remoteMessageId = tmp.ShiftRight <ulong>();
Ssfi.Security.DecryptAES(tmp, securityComponent.AesKey);
RpcProxy.Invoke(remoteMessageId, tmp, peer);
tmp.Dispose();
});
};
socketService.HandleError += reason => Logger.Error(reason);
socketService.HandleWrite += (isSuccess) => {
if (!isSuccess)
{
Logger.Error($"消息发送失败！");
}
};
socketService.HandleAcknowledge += (isSuccess, readStream) => {
var securityComponent = peer.GetComponent <ISecurityComponent>();
if (securityComponent == null)
{
Logger.Error($"{nameof(securityComponent)}组件为空！");
return;
}
// local
var localMessageId = readStream.ShiftRight <ulong>();
peer.Acknowledge(isSuccess, localMessageId);
};
return(peer);
}
void Start()
{
audioSource = GetComponent <AudioSource>();
playerSprite.sprite = PlayerPrefManager.GetCurrentSkinSprite();
playerSprite.color = PlayerPrefManager.GetCurrentColor();
hatSprite.sprite = PlayerPrefManager.GetCurrentHatSprite();
Bounds playerBounds = playerSprite.sprite.bounds;
float playerXFactor = 1 / playerBounds.size.x;
float playerYFactor = 1 / playerBounds.size.y;
transform.GetChild(0).localScale = new Vector3(playerXFactor, playerYFactor, 0);
if (hatSprite.sprite != null)
{
Bounds hatBounds = hatSprite.sprite.bounds;
float hatXFactor = 1 / hatBounds.size.x / 2;
float hatYFactor = 1 / hatBounds.size.y / 2;
transform.GetChild(1).localScale = new Vector3(hatXFactor, hatYFactor, 0);
}
rb = GetComponent <Rigidbody2D>();
maxHP = HP.transform.childCount;
infectChance = 1 - Mathf.Pow(1 - ronaChance, Time.fixedDeltaTime);
cam = Camera.main;
bottomLeft = cam.ScreenToWorldPoint(new Vector3(0, 0, cam.nearClipPlane));
topRight = cam.ScreenToWorldPoint(new Vector3(cam.pixelWidth, cam.pixelHeight, cam.nearClipPlane));
Vector2 topLeft = new Vector2(bottomLeft.x, topRight.y);
Vector2 bottomRight = new Vector2(topRight.x, bottomLeft.y);
ec.points = new Vector2[5] {
bottomLeft, topLeft, topRight, bottomRight, bottomLeft
};
enemyPool = new PoolAllocator <enemyInfo>(enemyPrefab, 100);
powerups = new List <GameObject>();
powerupObjects = new GameObject[1];
if (Application.isEditor == true)
{
passedGyroTest = true;
gyroTMP.gameObject.SetActive(false);
}
superStart();
}
public void Connect(string ip, int port)
{
_keys = Ssui.Security.CreateAesKey();
var publicKey = _keys.PublicKey;
Task.Factory.StartNew(() => {
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
writeStream.ShiftRight(publicKey);
_socket.Connect(ip, port, writeStream);
}
});
}
public APM_UdpSocket(int nextHeadOffset)
{
SocketStatistics = new SocketStatistics();
_nextHeadOffset = nextHeadOffset;
PoolAllocator <SocketService> .SetPool(args =>
ObjectFactory.GetActivator <SocketService>(typeof(SocketService).GetConstructors().First())());
PoolAllocator <IWriteStream> .SetPool(args =>
ObjectFactory.GetActivator <IWriteStream>(typeof(WriteStream).GetConstructors().First())());
PoolAllocator <IReadStream> .SetPool(args =>
ObjectFactory.GetActivator <IReadStream>(typeof(ReadStream).GetConstructors().First())());
}
public ServerSocket(string serviceId)
{
if (string.IsNullOrEmpty(serviceId))
{
throw new ArgumentException(nameof(serviceId));
}
Socket = new APM_UdpSocket(sizeof(ulong));
_serviceId = serviceId;
PoolAllocator <IPeer> .SetPool(args =>
ObjectFactory.GetActivator <IPeer>(typeof(Peer).GetConstructors().First())());
Socket.HandleAccept += Accept;
Socket.HandleConnect += PeerConnected;
_messageQueue = new MessageQueue();
}
public void Test()
{
var player = new Player();
player.UserName = "******";
player.ID = 100;
player.Sex = true;
player.Signature = "签名";
player.HeadId = 100;
player.MobilePhone = "100086";
player.CardCount = 5000;
player.PlayTimes = 40000;
PoolAllocator <IWriteStream> .SetPool((arguments => new WriteStream()));
var writeStream = PoolAllocator <IWriteStream> .GetObject();
var writer = new EndianBinaryWriter(writeStream);
player.ToBinaryWriter(writer);
var byteFragment = writeStream.ToByteFragment();
PoolAllocator <IReadStream> .SetPool((arguments => new ReadStream()));
var readStream = PoolAllocator <IReadStream> .GetObject();
readStream.CopyBuffer(byteFragment.Buffer, byteFragment.Offset, byteFragment.Count);
var reader = new EndianBinaryReader(readStream);
var check = new Player();
check.FromBinaryReader(reader);
Assert.That(check.UserName, Is.EqualTo(player.UserName));
Assert.That(check.ID, Is.EqualTo(player.ID));
Assert.That(check.Sex, Is.EqualTo(player.Sex));
Assert.That(check.Signature, Is.EqualTo(player.Signature));
Assert.That(check.HeadId, Is.EqualTo(player.HeadId));
Assert.That(check.MobilePhone, Is.EqualTo(player.MobilePhone));
Assert.That(check.CardCount, Is.EqualTo(player.CardCount));
Assert.That(check.PlayTimes, Is.EqualTo(player.PlayTimes));
}
public virtual void Connect(SocketConfig socketConfig)
{
SocketConfig = socketConfig;
foreach (var module in _moduleManager.ForeachInitializedModule())
{
var serverModule = module.Value;
if (serverModule.ServiceId != ID)
{
continue;
}
RpcMethodIds.AddRange(serverModule.RpcMethodIds);
RpcPacketTypes.AddRange(serverModule.RpcPacketTypes);
}
_keys = Ssfi.Security.CreateAesKey();
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
writeStream.ShiftRight(_keys.PublicKey);
_serverSocket.Connect(socketConfig, writeStream);
}
}
public CollisionDispatcher(ICollisionConfiguration collisionConfiguration)
{
m_dispatcherFlags = DispatcherFlags.CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD;
m_collisionConfiguration = collisionConfiguration;
m_neerCallback = DefaultNearCallback;
#if false
m_collisionAlgorithmPoolAllocator = collisionConfiguration.getCollisionAlgorithmPool();
m_persistentManifoldPoolAllocator = collisionConfiguration.getPersistentManifoldPool();
#endif
m_doubleDispatch = new CollisionAlgorithmCreateFunc[(int)BroadphaseNativeTypes.MAX_BROADPHASE_COLLISION_TYPES, (int)BroadphaseNativeTypes.MAX_BROADPHASE_COLLISION_TYPES];
for (BroadphaseNativeTypes i = BroadphaseNativeTypes.BOX_SHAPE_PROXYTYPE; i < BroadphaseNativeTypes.MAX_BROADPHASE_COLLISION_TYPES; i++)
{
for (BroadphaseNativeTypes j = BroadphaseNativeTypes.BOX_SHAPE_PROXYTYPE; j < BroadphaseNativeTypes.MAX_BROADPHASE_COLLISION_TYPES; j++)
{
m_doubleDispatch[(int)i, (int)j] = m_collisionConfiguration.getCollisionAlgorithmCreateFunc(i, j);
if (m_doubleDispatch[(int)i, (int)j] == null)
throw new BulletException();
}
}
}
/// <summary>
/// 发送数据
/// </summary>
private bool Write(SocketService socketService, ulong messageId, SendOption sendOption)
{
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
var packetHead = new PacketHead {
Length = (ushort)PacketHead.GetSize(),
PacketId = messageId,
SendOption = sendOption,
TotalBytes = 0,
FragmentId = 0,
TotalFragments = 1
};
Packet.ToBytes(packetHead, writeStream);
var byteFragment = writeStream.ToByteFragment();
var result = _writer.Client.SendTo(byteFragment.Buffer, byteFragment.Offset, byteFragment.Count, SocketFlags.None,
socketService.Connection.RemoteAddress);
socketService.OnWrite(result == byteFragment.Count);
return(result == byteFragment.Count);
}
}
public void Test()
{
PoolAllocator <IWriteStream> .SetPool((arguments => new WriteStream()));
var writeStream = PoolAllocator <IWriteStream> .GetObject();
writeStream.ShiftRight("Test");
writeStream.ShiftRight(123);
writeStream.ShiftRight(5.0f);
writeStream.ShiftLeft("front");
var byteFragment = writeStream.ToByteFragment();
PoolAllocator <IReadStream> .SetPool((arguments => new ReadStream()));
var readStream = PoolAllocator <IReadStream> .GetObject();
readStream.CopyBuffer(byteFragment.Buffer, byteFragment.Offset, byteFragment.Count);
Assert.That(readStream.ShiftRight <string>(), Is.EqualTo("front"));
Assert.That(readStream.ShiftRight <string>(), Is.EqualTo("Test"));
Assert.That(readStream.ShiftRight <int>(), Is.EqualTo(123));
Assert.That(readStream.ShiftRight <float>(), Is.EqualTo(5.0f));
}
private bool Acknowledge(
SocketService socketService,
SendOption sendOption,
PacketHead packetHead,
IWriteStream writeStream = null)
{
var fragment = writeStream?.ToByteFragment();
packetHead.Length = fragment.HasValue ? (ushort)(PacketHead.GetSize() + fragment?.Count) : (ushort)PacketHead.GetSize();
packetHead.SendOption = sendOption;
using (var ws = PoolAllocator <IWriteStream> .GetObject()) {
if (writeStream != null)
{
ws.ShiftRight(writeStream.ToByteFragment());
}
Packet.ToBytes(packetHead, ws);
var bf = ws.ToByteFragment();
var result = _writer.Client.SendTo(bf.Buffer, bf.Offset, bf.Count,
SocketFlags.None, socketService.Connection.RemoteAddress);
socketService.OnWrite(result == bf.Count);
return(result == bf.Count);
}
}
private bool Write(SocketService socketService, IWriteStream writeStream, SendOption sendOption)
{
var fragment = writeStream?.ToByteFragment();
var packetHead = new PacketHead {
Length = fragment.HasValue?(ushort)(PacketHead.GetSize() + fragment?.Count):(ushort)PacketHead.GetSize(),
PacketId = socketService.SendCounter,
SendOption = sendOption,
TotalBytes = fragment.HasValue?(ushort)fragment?.Count:(ushort)0
};
var ws = PoolAllocator <IWriteStream> .GetObject();
if (fragment.HasValue)
{
ws.ShiftRight((ByteFragment)fragment);
}
Packet.ToBytes(packetHead, ws);
var byteFragment = ws.ToByteFragment();
var result = _writer.Client.SendTo(byteFragment.Buffer, byteFragment.Offset, byteFragment.Count, SocketFlags.None,
socketService.Connection.RemoteAddress);
socketService.OnWrite(result == byteFragment.Count);
return(result == byteFragment.Count);
}
protected override bool WriteMessage(
SocketService socketService,
SendOption sendOption,
ulong messageId,
IWriteStream writeStream)
{
if (socketService == null)
{
Logger.Error($"{nameof(socketService)} 为 null ！");
return(false);
}
var fragment = writeStream?.ToByteFragment();
var packetHead = new PacketHead {
Length = fragment.HasValue ? (ushort)(PacketHead.GetSize() + fragment?.Count) : (ushort)PacketHead.GetSize(),
PacketId = messageId,
SendOption = sendOption,
TotalBytes = fragment.HasValue ? (ushort)fragment?.Count : (ushort)0,
FragmentId = 0,
TotalFragments = 1
};
var ws = PoolAllocator <IWriteStream> .GetObject();
if (fragment.HasValue)
{
ws.ShiftRight((ByteFragment)fragment);
}
Packet.ToBytes(packetHead, ws);
var byteSegment = ws.ToByteFragment();
var result = StartWrite(socketService, byteSegment.Buffer, byteSegment.Offset, byteSegment.Count, ws, true);
SocketStatistics.LogUnreliableSend();
SocketStatistics.LogTotalBytesSent(packetHead.Length);
return(result);
}
void PreparePools()
{
troops = new List<GameObject>();
troopDataPool = new PoolAllocator<TroopData>(
() => { return new TroopData(); },
(TroopData troop) => { troop.Init(null, null, 0, 0); }
);
troopPool = new PoolAllocator<GameObject>(
() => {
GameObject gObj = GameObject.Instantiate(troopPrefab) as GameObject;
return gObj;
},
(GameObject gObj) => {
gObj.SetActive(false);
gObj.name = "Pooled troop";
gObj.transform.SetParent(pooledGameObjectHolder.transform, false);
}
);
}
protected override bool WriteMessage(
SocketService socketService,
SendOption sendOption,
IWriteStream writeStream)
{
if (socketService == null)
{
Logger.Error($"{nameof(socketService)} 为 null ！");
return(false);
}
if (writeStream == null)
{
Logger.Error($"{nameof(writeStream)} 为 null ！");
return(false);
}
var fragment = writeStream.ToByteFragment();
var dataLengnth = MTU - PacketHead.GetSize();
var messageId = socketService.SendCounter;
// 分包
var splits = Math.Ceiling(fragment.Count * 1.0d / dataLengnth);
for (var i = 0; i < splits; i++)
{
var packetHead = new PacketHead {
Length = (ushort)(Math.Min(fragment.Count - i * dataLengnth, dataLengnth) + PacketHead.GetSize()),
PacketId = messageId,
SendOption = sendOption,
TotalBytes = (ushort)Math.Min(fragment.Count - i * dataLengnth, dataLengnth),
FragmentId = (ushort)i,
TotalFragments = (ushort)splits
};
var ws = PoolAllocator <IWriteStream> .GetObject();
ws.ShiftRight(fragment.Buffer, fragment.Offset + i * dataLengnth, packetHead.TotalBytes);
Packet.ToBytes(packetHead, ws);
var byteSegment = ws.ToByteFragment();
void Action()
{
StartWrite(socketService, byteSegment.Buffer, byteSegment.Offset, byteSegment.Count, ws);
SocketStatistics.LogFragmentedSend();
SocketStatistics.LogDataBytesSent(packetHead.TotalBytes);
SocketStatistics.LogTotalBytesSent(packetHead.Length);
Logger.Info("重发数据包！");
}
void RecycleAction()
{
ws.Dispose();
}
var id = BuildID(packetHead);
_fragmentTimer?.Add(id, Action, RecycleAction);
StartWrite(socketService, byteSegment.Buffer, byteSegment.Offset, byteSegment.Count, writeStream);
socketService.PacketIds.Add(id);
SocketStatistics.LogFragmentedSend();
SocketStatistics.LogReliableSend();
SocketStatistics.LogDataBytesSent(packetHead.TotalBytes);
SocketStatistics.LogTotalBytesSent(packetHead.Length);
}
return(true);
}
public static IUser Create()
{
return(PoolAllocator <IUser> .GetObject());
}
public override void Connect(SocketConfig socketConfig)
{
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
Connect(socketConfig, writeStream);
}
}
private void ResponseFragment(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Error($"{endPoint}连接没有添加！");
return;
}
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
writeStream.ShiftRight(readStream.RightPeek(_nextHeadOffset));
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Fragment, packetHead, writeStream);
}
SocketStatistics.LogAcknowledgementSend();
SocketStatistics.LogFragmentedReceive();
lock (socketService) {
// 过滤已处理的之前包
if (socketService.RecvCounter >= packetHead.PacketId)
{
Logger.Warn($"重复包messageId:{packetHead.PacketId} fragmentId:{packetHead.FragmentId}丢弃!");
return;
}
var byteFragment = readStream.ToByteFragment();
if (!socketService.Packets.TryGetValue(packetHead.PacketId, out var result))
{
// 分包第一次处理
result = new Recorder()
{
Count = packetHead.TotalFragments,
Flag = 0,
ReadStream = PoolAllocator <IReadStream> .GetObject(),
};
socketService.Packets.Add(packetHead.PacketId, result);
}
var readBuffer = result.ReadStream.GetReadBuffer();
// 过滤已经处理的分包
if (packetHead.TotalFragments != 1 && (result.Flag & (((ulong)1) << packetHead.FragmentId)) > 0)
{
Logger.Warn("过滤已经处理的分包!");
return;
}
Array.Copy(byteFragment.Buffer, byteFragment.Offset, readBuffer.Buffer,
readBuffer.Offset + packetHead.FragmentId * packetHead.TotalBytes,
byteFragment.Count);
result.Flag |= ((ulong)1) << packetHead.FragmentId;
socketService.Packets[packetHead.PacketId] = result;
Logger.Debug($"MessageID:{packetHead.PacketId} 段数：{packetHead.FragmentId} 总段数：{packetHead.TotalFragments} 当前全部包数：" + socketService.Packets.Count);
while (socketService.Packets.Count != 0)
{
var next = socketService.RecvCounter + 1;
if (!socketService.Packets.TryGetValue(next, out var first))
{
break;
}
if (!first.IsComplete())
{
break;
}
Logger.Debug("MessageID:" + next + " 包数：" + socketService.Packets.Count + " 完成！");
socketService.RecvIncrement();
socketService.Packets.Remove(next);
socketService.OnRead(first.ReadStream);
first.ReadStream.Dispose();
}
}
SocketStatistics.LogDataBytesReceived(packetHead.TotalBytes);
SocketStatistics.LogTotalBytesReceived(packetHead.Length);
SocketStatistics.LogReliableReceive();
}
public PoolManager()
{
PoolAllocator <LuaPeerComponent> .SetPool(
args => ObjectFactory.GetActivator <LuaPeerComponent>(
typeof(LuaPeerComponent).GetConstructors().First())());
}
// Use this for initialization
void Start()
{
eventButtonPool = new PoolAllocator<GameObject>(
() =>
{
GameObject gObj = GameObject.Instantiate(sampleButton) as GameObject;
return gObj;
},
(GameObject gObj) =>
{
gObj.SetActive(false);
gObj.name = "Pooled EventButton";
gObj.transform.SetParent(pooledGameObjectHolder.transform, false);
}
);
}
private void BeginRead(SocketService socketService)
{
if (socketService == null)
{
Logger.Error($"{nameof(socketService)} 为 null ！");
return;
}
var endPoint = socketService.Connection.LocalAddress;
var readStream = PoolAllocator <IReadStream> .GetObject();
var byteFragment = readStream.GetReadBuffer();
try {
lock (_receiveLock) {
_readSocket.BeginReceiveFrom(byteFragment.Buffer, byteFragment.Offset, byteFragment.Count, SocketFlags.None,
ref endPoint, result => {
EndPoint remoteEndPoint = new IPEndPoint(
endPoint.AddressFamily == AddressFamily.InterNetwork
? IPAddress.Any
: IPAddress.IPv6Any,
0);
var bytesReceived = 0;
try {
lock (_receiveLock) {
bytesReceived = _readSocket.EndReceiveFrom(result, ref remoteEndPoint);
}
} catch (SocketException e) {
socketService?.OnError(e.ToString());
readStream.Dispose();
BeginRead(socketService);
return;
} catch (ObjectDisposedException objectDisposedException) {
socketService?.OnError(objectDisposedException.ToString());
readStream.Dispose();
return;
} catch (InvalidOperationException invalidOperationException) {
socketService?.OnError(invalidOperationException.ToString());
readStream.Dispose();
return;
}
if (bytesReceived == 0)
{
return;
}
BeginRead(socketService);
var length = byteFragment.Buffer.ToValue <ushort>(byteFragment.Offset);
if (length == bytesReceived)
{
readStream.SetReadCount(length);
try {
OnRead(remoteEndPoint, readStream);
} catch (Exception e) {
Logger.Error(e);
}
}
else
{
Logger.Warn($"包数据未接收全,总长{length}，接收长度{bytesReceived}，自动丢弃！");
}
readStream.Dispose();
}, null);
}
} catch (SocketException e) {
socketService?.OnError(e.ToString());
BeginRead(socketService);
} catch (ObjectDisposedException objectDisposedException) {
socketService?.OnError(objectDisposedException.ToString());
} catch (InvalidOperationException invalidOperationException) {
socketService?.OnError(invalidOperationException.ToString());
}
}
public void TestRpcService()
{
PoolAllocator <IWriteStream> .SetPool((arguments => new WriteStream()));
Ssci.Invoke <ITest>(() => (rpc) => rpc.Test(200), null, null);
}
