void INetEventListener.OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
if (NetworkReceiveUnconnectedEvent != null)
{
NetworkReceiveUnconnectedEvent(remoteEndPoint, reader, messageType);
}
}
private void NetListener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
Console.WriteLine("reiceived");
}
public override void NetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
netPacketProcessor.ReadAllPackets(reader);
}
public static object Read(NetPacketReader message)
{
return(new LoginSuccessPacket());
}
private void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
reader.Recycle();
reader.Clear();
// Do nothing.
}
void INetEventListener.OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader,
UnconnectedMessageType messageType)
{
}
public static IPacket Read(NetPacketReader message)
{
return((IPacket)parsers[(int)message.GetVariableUInt32()](message));
}
public WorldUpdatePacket(NetPacketReader im)
{
this.Decode(im);
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
Console.WriteLine($"{ClientSignature} Received data. Processing...");
_netPacketProcessor.ReadAllPackets(reader, peer);
}
public void Decode(NetPacketReader im)
{
faction = im.GetByte();
amount = im.GetInt();
}
public virtual void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
PacketProcessor.ReadAllPackets(reader, peer);
}
public PopulationUpdatePacket(NetPacketReader im)
{
this.Decode(im);
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
logger.WriteLine("Received: {0}", reader.GetString());
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
netMgr.OnRecvData(peer, reader);
}
public static NetSoldShip Read(NetPacketReader message) => new()
public void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
throw new NotImplementedException();
}
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
var peerID = _peerIDs[peer];
var data = new NetBitPackedDataReader(reader);
var packetID = data.ReadRangedInt(0, NetClient._packets.Count);
if (packetID == 0)
{
Console.WriteLine($"Server received initial data from ID: {peerID}");
var packetID2 = data.ReadRangedInt(0, _initialDataPackets.Count);
if (packetID2 == 0)
{
var writer = new NetBitPackedDataWriter();
{
writer.WriteRangedInt(0, _packets.Count, 0);
writer.WriteRangedInt(0, _initialPacketBits, (int)INITIAL_PACKET.PEER_JOIN);
writer.WriteRangedInt(0, _maxPlayersIndex, peerID);
}
if (IsListen)
{
NetClient.InvokeOnPeerJoin(peerID);
foreach (var kv in _peerIDs)
{
if (kv.Value != NetClient._selfID && kv.Value != peerID)
{
kv.Key.Send(writer.Data, DeliveryMethod.ReliableOrdered);
}
}
}
else
{
OnPeerJoin?.Invoke(peerID);
_manager.SendToAll(writer.Data, DeliveryMethod.ReliableOrdered, peer);
}
_peers1.Add(peerID, peer);
_peers2.Add(peerID, peer);
_expectedPacketsWithFiles.Add(peer, new Dictionary <Type, ISet <int> >());
}
else
{
var(_, _, reads, _) = NetClient._packetsWithFilesInfo[NetClient._initialDataPackets[packetID2]];
var i = data.ReadInt();
var packet = InitialData[i];
for (var j = 0; j < reads.Length; j++)
{
reads[j](data, packet);
}
var writer = new NetBitPackedDataWriter();
{
writer.WriteRangedInt(0, _packets.Count, 0);
writer.WriteRangedInt(0, _initialPacketBits, (int)INITIAL_PACKET.INITIAL_DATA);
writer.WriteRangedInt(0, _initialDataIDBits, (int)INITIAL_DATA_ID.DATA);
var(_, writes2, _, _) = _initialDataPacketInfo[packet.GetType()];
writer.WriteRangedInt(0, _initialDataPackets.Count, packetID2);
writer.Write(i == InitialData.Count - 1);
writer.Write(i);
writer.Write(false);
for (var j = 0; j < writes2.Length; j++)
{
writes2[j](writer, packet);
}
peer.Send(writer.Data, DeliveryMethod.ReliableOrdered);
}
}
return;
}
//Console.WriteLine($"Server received data: Packet ID: {id}");
try
{
var t = NetClient._packets[packetID];
if (_expectedPacketsWithFiles[peer].ContainsKey(t))
{
var(_, _, reads2, _) = NetClient._packetsWithFilesInfo[t];
var(_, writes2, _, _) = _packetInfo[t];
var i = data.ReadInt();
var packet = _netFilePackets[i];
for (var j = 0; j < reads2.Length; j++)
{
reads2[j](data, packet);
}
var writer = new NetBitPackedDataWriter();
{
writer.WriteRangedInt(0, _packets.Count, packetID);
writer.WriteRangedInt(0, _netFilePackets.Length - 1, i);
writer.Write(false);
for (var j = 0; j < writes2.Length; j++)
{
writes2[j](writer, packet);
}
peer.Send(writer.Data, DeliveryMethod.ReliableOrdered);
}
_netFilePackets[i] = null;
_expectedPacketsWithFiles[peer][t].Remove(i);
if (_expectedPacketsWithFiles[peer][t].Count == 0)
{
_expectedPacketsWithFiles[peer].Remove(t);
}
}
else
{
var(_, _, reads, instance, shouldRelay) = NetClient._packetInfo[t];
for (var i = 0; i < reads.Length; i++)
{
reads[i](data, instance);
}
instance.SenderID = peerID;
if (!IsListen || (peerID != NetClient._selfID))
{
try { instance.Process(); }
catch (Exception e) { throw e; }
}
if (_packets.ContainsKey(packetID) && shouldRelay)
{
SendToAll(instance, deliveryMethod, peer);
}
}
}
catch { Console.WriteLine($"Server failed to read data: Packet ID: {packetID}"); }
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
}
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
((NetLibSession)Session).OnReceiveData(new ArraySegment <byte>(reader.RawData, reader.UserDataOffset, reader.UserDataSize));
Dispatch().ConfigureAwait(false).GetAwaiter();
}
public static NetDlgLine Read(NetPacketReader message) => new NetDlgLine()
{
Voice = message.GetString(), Hash = message.GetUInt()
};
void INetEventListener.OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
UnityEngine.Debug.Log("ClientTransport: OnNetworkReceiveUnconnected");
}
/// <inheritdoc/>
public void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
//TODO broadcast messages support
}
private void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
Sys.Ref.Shared.GetNode <InterpreterSys>().ProcessScript(Encoding.UTF8.GetString(reader.GetRemainingBytes()));
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod method)
{
byte[] data = reader.GetRemainingBytes();
Multiplayer.HandleReceive(new ByteReader(data), method == DeliveryMethod.ReliableOrdered);
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
OnNetworkReceived?.Invoke(peer, reader, deliveryMethod);
}
public void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
}
public void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
{
Console.WriteLine("OnNetworkReceiveUnconnected");
}
public static SellCount Read(NetPacketReader message) => new()
private static void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliverymethod)
{
LiteNetLib4MirrorTransport.Singleton.OnServerDataReceived.Invoke(peer.Id + 1, reader.GetRemainingBytesSegment(), -1);
reader.Recycle();
}
