/// <inheritdoc/>
public void SendSingleData(TPacketId packetId, IPacketData packetData, params ushort[] playerIds)
{
foreach (var playerId in playerIds)
{
SendSingleData(packetId, packetData, playerId);
}
}
public void SendMessage(MyMessageId id, IPacketData data, bool reliable, List <EndpointId> endpoints, byte index = 0)
{
MyNetworkWriter.MyPacketDescriptor packet = this.InitSendStream(EndpointId.Null, reliable ? MyP2PMessageEnum.ReliableWithBuffering : MyP2PMessageEnum.Unreliable, id, index);
packet.Recipients.AddRange(endpoints);
packet.Data = data;
MyNetworkWriter.SendPacket(packet);
}
/// <inheritdoc/>
public void BroadcastSingleData(TPacketId packetId, IPacketData packetData)
{
if (!_netServer.IsStarted)
{
throw new InvalidOperationException(ServerNotStartedExceptionMsg);
}
if (!PacketIdLookup.TryGetValue(packetId, out var idValue))
{
throw new InvalidOperationException(
PacketIdInvalidExceptionMsg);
}
if (!_serverAddon.Id.HasValue)
{
throw new InvalidOperationException(NoAddonIdMsg);
}
_netServer.SetDataForAllClients(updateManager => {
updateManager?.SetAddonData(
_serverAddon.Id.Value,
idValue,
_packetIdSize,
packetData
);
});
}
/// <inheritdoc/>
public void SendSingleData(TPacketId packetId, IPacketData packetData)
{
if (!_netClient.IsConnected)
{
throw new InvalidOperationException(NotConnectedMsg);
}
if (!PacketIdLookup.TryGetValue(packetId, out var idValue))
{
throw new InvalidOperationException(
InvalidPacketIdMsg);
}
if (!_clientAddon.Id.HasValue)
{
throw new InvalidOperationException(NoClientAddonId);
}
_netClient.UpdateManager.SetAddonData(
_clientAddon.Id.Value,
idValue,
_packetIdSize,
packetData
);
}
/// <summary>
/// Execute the packet handler for the client addon data.
/// </summary>
/// <param name="addonId">The ID of the addon.</param>
/// <param name="packetId">The ID of the packet data for the addon.</param>
/// <param name="packetData">The packet data instance.</param>
private void ExecuteClientAddonPacketHandler(
byte addonId,
byte packetId,
IPacketData packetData
)
{
var addonPacketIdMessage = $"for addon ID: {addonId} and packet ID: {packetId}";
var noHandlerWarningMessage =
$"There is no client addon packet handler registered {addonPacketIdMessage}";
if (!_clientAddonPacketHandlers.TryGetValue(addonId, out var addonPacketHandlers))
{
Logger.Get().Warn(this, noHandlerWarningMessage);
return;
}
if (!addonPacketHandlers.TryGetValue(packetId, out var handler))
{
Logger.Get().Warn(this, noHandlerWarningMessage);
return;
}
// Invoke the packet handler on the Unity main thread
ThreadUtil.RunActionOnMainThread(() => {
try {
handler.Invoke(packetData);
} catch (Exception e) {
Logger.Get().Error(this,
$"Exception occurred while executing client addon packet handler {addonPacketIdMessage}, type: {e.GetType()}, message: {e.Message}, stacktrace: {e.StackTrace}");
}
});
}
/// <inheritdoc/>
public void SendSingleData(TPacketId packetId, IPacketData packetData, ushort playerId)
{
if (!_netServer.IsStarted)
{
throw new InvalidOperationException(ServerNotStartedExceptionMsg);
}
if (!PacketIdLookup.TryGetValue(packetId, out var idValue))
{
throw new InvalidOperationException(
PacketIdInvalidExceptionMsg);
}
var updateManager = _netServer.GetUpdateManagerForClient(playerId);
if (updateManager == null)
{
throw new InvalidOperationException($"Player with ID '{playerId}' is not connected");
}
if (!_serverAddon.Id.HasValue)
{
throw new InvalidOperationException(NoAddonIdMsg);
}
updateManager.SetAddonData(
_serverAddon.Id.Value,
idValue,
_packetIdSize,
packetData
);
}
/// <summary>
/// Execute the packet handler for the server addon data from a client.
/// </summary>
/// <param name="id">The ID of the client.</param>
/// <param name="addonId">The ID of the addon.</param>
/// <param name="packetId">The ID of the packet data for the addon.</param>
/// <param name="packetData">The packet data instance.</param>
private void ExecuteServerAddonPacketHandler(
ushort id,
byte addonId,
byte packetId,
IPacketData packetData
)
{
var addonPacketIdMessage = $"for addon ID: {addonId} and packet ID: {packetId}";
var noHandlerWarningMessage =
$"There is no server addon packet handler registered {addonPacketIdMessage}";
if (!_serverAddonPacketHandlers.TryGetValue(addonId, out var addonPacketHandlers))
{
Logger.Get().Warn(this, noHandlerWarningMessage);
return;
}
if (!addonPacketHandlers.TryGetValue(packetId, out var handler))
{
Logger.Get().Warn(this, noHandlerWarningMessage);
return;
}
// Invoke the packet handler for this ID directly, in contrast to the client packet handling.
// We don't do anything game specific with server packet handler, so there's no need to do it
// on the Unity main thread
try {
handler.Invoke(id, packetData);
} catch (Exception e) {
Logger.Get().Error(this,
$"Exception occurred while executing server addon packet handler {addonPacketIdMessage}, type: {e.GetType()}, message: {e.Message}, stacktrace: {e.StackTrace}");
}
}
public void Reset()
{
if (this.Data != null)
{
this.Data.Return();
}
this.Header.Position = 0L;
this.Data = null;
this.Recipients.Clear();
}
public static TPKGHead CreateMessage(AsyncSocketConnection agent, IPacketData data)
{
TPKGHead ts = new TPKGHead()
{
Data = data,
Major_Ver = 1,
Minor_Ver = 1,
Term_Code = agent.TerminalId,
};
return(ts);
}
private static void Split(MyPacketDescriptor packet)
{
int offset = 0xf4240 - ((int)packet.Header.Position);
int size = packet.Data.Size;
while (offset < size)
{
int num3 = Math.Min(size - offset, 0xf4240);
IPacketData item = (packet.Data.Data == null) ? GetPacketData(packet.Data.Ptr, offset, num3) : GetPacketData(packet.Data.Data, offset, num3);
m_packetsTmp.Add(item);
offset += num3;
}
}
public static TPKGHead CreateResponseMessage(TPKGHead msg, IPacketData data)
{
TPKGHead ts = new TPKGHead()
{
Data = data,
Major_Ver = 1,
Minor_Ver = 1,
SessionId = msg.SessionId,
Seq_Id = ++msg.Seq_Id,
Term_Code = msg.Term_Code,
};
return(ts);
}
public override Task Invoke(IPacketData context)
{
try
{
var json = JsonConvert.SerializeObject(context);
var eventData = new EventData(Encoding.UTF8.GetBytes(json));
return _eventHubClient.SendAsync(eventData);
}
catch (Exception)
{
// todo: log?
}
return Task.FromResult(false);
}
/**
* Executes the correct packet handler corresponding to this packet.
* Assumes that the packet is not read yet.
*/
private void ExecuteServerPacketHandler(ushort id, ServerPacketId packetId, IPacketData packetData)
{
if (!_serverPacketHandlers.ContainsKey(packetId))
{
Logger.Get().Warn(this, $"There is no server packet handler registered for ID: {packetId}");
return;
}
// Invoke the packet handler for this ID directly, in contrast to the client packet handling.
// We don't do anything game specific with server packet handler, so there's no need to do it
// on the Unity main thread
try {
_serverPacketHandlers[packetId].Invoke(id, packetData);
} catch (Exception e) {
Logger.Get().Error(this, $"Exception occured while executing server packet handler for packet ID: {packetId}, message: {e.Message}, stacktrace: {e.StackTrace}");
}
}
/// <summary>
/// Executes the correct packet handler corresponding to this packet data.
/// </summary>
/// <param name="packetId">The client packet ID for this data.</param>
/// <param name="packetData">The packet data instance.</param>
private void ExecuteClientPacketHandler(ClientPacketId packetId, IPacketData packetData)
{
if (!_clientPacketHandlers.ContainsKey(packetId))
{
Logger.Get().Warn(this, $"There is no client packet handler registered for ID: {packetId}");
return;
}
// Invoke the packet handler for this ID on the Unity main thread
ThreadUtil.RunActionOnMainThread(() => {
try {
_clientPacketHandlers[packetId].Invoke(packetData);
} catch (Exception e) {
Logger.Get().Error(this,
$"Exception occured while executing client packet handler for packet ID: {packetId}, message: {e.Message}, stacktrace: {e.StackTrace}");
}
});
}
/// <summary>
/// Find or create a packet data instance in the current packet that matches the given ID of a client.
/// </summary>
/// <param name="id">The ID of the client in the generic client data.</param>
/// <param name="packetId">The ID of the packet data.</param>
/// <typeparam name="T">The type of the generic client packet data.</typeparam>
/// <returns>An instance of the packet data in the packet.</returns>
private T FindOrCreatePacketData <T>(ushort id, ClientPacketId packetId) where T : GenericClientData, new()
{
PacketDataCollection <T> packetDataCollection;
IPacketData packetData = null;
// First check whether there actually exists a data collection for this packet ID
if (CurrentUpdatePacket.TryGetSendingPacketData(packetId, out var iPacketDataAsCollection))
{
// And if so, try to find the packet data with the requested client ID
packetDataCollection = (PacketDataCollection <T>)iPacketDataAsCollection;
foreach (var existingPacketData in packetDataCollection.DataInstances)
{
if (((GenericClientData)existingPacketData).Id == id)
{
packetData = existingPacketData;
break;
}
}
}
else
{
// If no data collection exists, we create one instead
packetDataCollection = new PacketDataCollection <T>();
CurrentUpdatePacket.SetSendingPacketData(packetId, packetDataCollection);
}
// If no existing instance was found, create one and add it to the (newly created) collection
if (packetData == null)
{
packetData = new T {
Id = id
};
packetDataCollection.DataInstances.Add(packetData);
}
return((T)packetData);
}
private void SendClientUpdate(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.CLIENT_UPDATE, data, false, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
private void SendClientAcks(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.CLIENT_ACKS, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
/// <summary>
/// Sets the given packetData with the given packet ID for sending.
/// </summary>
/// <param name="packetId">The packet ID to set data for.</param>
/// <param name="packetData">The packet data to set.</param>
public void SetSendingPacketData(T packetId, IPacketData packetData)
{
_normalPacketData[packetId] = packetData;
}
/// <summary>
/// Tries to get packet data that is going to be sent with the given packet ID.
/// </summary>
/// <param name="packetId">The packet ID to try and get.</param>
/// <param name="packetData">Variable to store the retrieved data in. Null if this method returns false.</param>
/// <returns>true if the packet data exists and will be stored in the packetData variable; otherwise
/// false.</returns>
public bool TryGetSendingPacketData(T packetId, out IPacketData packetData)
{
return(_normalPacketData.TryGetValue(packetId, out packetData));
}
public override Task Invoke(IPacketData context)
{
var line = string.Format("[{0}: {1}] {2}", context.Timestamp, context.Sender, context.Data);
Trace.WriteLine(line);
return Next.Invoke(context);
}
void IReplicationServerCallback.SendWorldData(IPacketData data, List <EndpointId> endpoints)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.WORLD_DATA, data, true, endpoints, 0);
}
private void SendReplicableReady(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.REPLICATION_READY, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
void IReplicationServerCallback.SendReplicationDestroy(IPacketData data, List <EndpointId> endpoints)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_DESTROY, data, true, endpoints, 0);
}
void IReplicationServerCallback.SendStateSync(IPacketData data, Endpoint endpoint, bool reliable)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.SERVER_STATE_SYNC, data, reliable, endpoint.Id, endpoint.Index);
}
private void ProcessPacket(string packet, IPacketData context)
{
ParsedPacket parsedPacket;
var packetResult = PacketParser.TryParse(packet, out parsedPacket);
if (packetResult != PacketParseResult.Ok)
{
IncCounter(string.Format(StatsdServiceStatConstants.PacketBadFormat, _config.ServiceStatsPrefix));
return;
}
Func<ParsedPacket, bool> handler;
if (!_handlers.TryGetValue(parsedPacket.MetricType, out handler))
{
IncCounter(string.Format(StatsdServiceStatConstants.PacketBadFormat, _config.ServiceStatsPrefix));
return;
}
if (!handler(parsedPacket))
{
IncCounter(string.Format(StatsdServiceStatConstants.PacketBadFormat, _config.ServiceStatsPrefix));
}
IncCounter(string.Format(StatsdServiceStatConstants.MetricsCountFormat, _config.ServiceStatsPrefix));
}
public abstract Task Invoke(IPacketData context);
void IReplicationServerCallback.SentClientJoined(IPacketData data, EndpointId endpoint)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.CLIENT_CONNNECTED, data, true, endpoint, 0);
}
private void SendConnectRequest(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.CLIENT_CONNNECTED, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
void IReplicationServerCallback.SendServerData(IPacketData data, Endpoint endpoint)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.SERVER_DATA, data, true, endpoint.Id, endpoint.Index);
}
private void SendEvent(IPacketData data, bool reliable)
{
TransportLayer.SendMessage(MyMessageId.RPC, data, reliable, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
void IReplicationServerCallback.SendReplicationIslandDone(IPacketData data, Endpoint endpoint)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_ISLAND_DONE, data, true, endpoint.Id, endpoint.Index);
}
public Task Invoke(IPacketData context)
{
IncCounter(string.Format(StatsdServiceStatConstants.PacketCountFormat, _config.ServiceStatsPrefix));
IEnumerable<string> packets;
if (context.Data.Contains("\n"))
{
packets = context.Data.Split('\n');
}
else
{
packets = new[] { context.Data };
}
foreach (var packet in packets.Where(i => !string.IsNullOrWhiteSpace(i)).Select(i=>i.Replace("\r", "")))
{
ProcessPacket(packet, context);
}
// Done
return Task.FromResult(true);
}
void IReplicationServerCallback.SendWorld(IPacketData data, EndpointId endpoint)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.WORLD, data, true, endpoint, 0);
}
void IReplicationServerCallback.SendJoinResult(IPacketData data, EndpointId endpoint)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.JOIN_RESULT, data, true, endpoint, 0);
}
void IReplicationServerCallback.SendReplicationCreateStreamed(IPacketData data, Endpoint endpoint)
{
base.SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_STREAM_BEGIN, data, true, endpoint.Id, endpoint.Index);
}
public void Parse(Encoder s)
{
packetType = s.Read<PacketType>();
reserved1 = s.ReadByte();
reserved2 = s.ReadByte();
reserved3 = s.ReadByte();
packetId = s.Read<PacketId>();
reserved = s.ReadUshort();
dataSize = s.ReadUint();
switch (packetId)
{
case PacketId.StartSession:
data = new PSessionStarted();
data.Parse(s);
break;
case PacketId.ProductData:
data = new PProductData();
data.Parse(s);
break;
case PacketId.ProtocolArray:
data = new PProtocolArray();
data.Parse(s);
break;
case PacketId.RecordCount:
data = new PRecords();
data.Parse(s);
break;
case PacketId.TrackData:
data = new PTrkData();
data.Parse(s);
break;
case PacketId.TrackHeader:
data = new PTrackHeader();
data.Parse(s);
break;
case PacketId.TransferComplete:
data = new PXferComplete();
data.Parse(s);
break;
case PacketId.CourseTrackData:
data = new PTrkData();
data.Parse(s);
break;
}
}
public override Task Invoke(IPacketData context)
{
return Task.FromResult(true);
}
