/// <summary>
/// <para>/ Parse back SteamNetworkPingLocation_t string. Returns false if we couldn't understand</para>
/// <para>/ the string.</para>
/// </summary>
public static bool ParsePingLocationString(string pszString, out SteamNetworkPingLocation_t result)
{
InteropHelp.TestIfAvailableClient();
using (var pszString2 = new InteropHelp.UTF8StringHandle(pszString)) {
return(NativeMethods.ISteamNetworkingUtils_ParsePingLocationString(CSteamAPIContext.GetSteamNetworkingUtils(), pszString2, out result));
}
}
/// <summary>
/// <para>/ Convert a ping location into a text format suitable for sending over the wire.</para>
/// <para>/ The format is a compact and human readable. However, it is subject to change</para>
/// <para>/ so please do not parse it yourself. Your buffer must be at least</para>
/// <para>/ k_cchMaxSteamNetworkingPingLocationString bytes.</para>
/// </summary>
public static void ConvertPingLocationToString(ref SteamNetworkPingLocation_t location, out string pszBuf, int cchBufSize)
{
InteropHelp.TestIfAvailableClient();
IntPtr pszBuf2 = Marshal.AllocHGlobal(cchBufSize);
NativeMethods.ISteamNetworkingUtils_ConvertPingLocationToString(CSteamAPIContext.GetSteamNetworkingUtils(), ref location, pszBuf2, cchBufSize);
pszBuf = InteropHelp.PtrToStringUTF8(pszBuf2);
Marshal.FreeHGlobal(pszBuf2);
}
/// <summary>
/// <para> "Ping location" functions</para>
/// <para> We use the ping times to the valve relays deployed worldwide to</para>
/// <para> generate a "marker" that describes the location of an Internet host.</para>
/// <para> Given two such markers, we can estimate the network latency between</para>
/// <para> two hosts, without sending any packets. The estimate is based on the</para>
/// <para> optimal route that is found through the Valve network. If you are</para>
/// <para> using the Valve network to carry the traffic, then this is precisely</para>
/// <para> the ping you want. If you are not, then the ping time will probably</para>
/// <para> still be a reasonable estimate.</para>
/// <para> This is extremely useful to select peers for matchmaking!</para>
/// <para> The markers can also be converted to a string, so they can be transmitted.</para>
/// <para> We have a separate library you can use on your app's matchmaking/coordinating</para>
/// <para> server to manipulate these objects. (See steamdatagram_gamecoordinator.h)</para>
/// <para>/ Return location info for the current host. Returns the approximate</para>
/// <para>/ age of the data, in seconds, or -1 if no data is available.</para>
/// <para>/</para>
/// <para>/ It takes a few seconds to initialize access to the relay network. If</para>
/// <para>/ you call this very soon after calling InitRelayNetworkAccess,</para>
/// <para>/ the data may not be available yet.</para>
/// <para>/</para>
/// <para>/ This always return the most up-to-date information we have available</para>
/// <para>/ right now, even if we are in the middle of re-calculating ping times.</para>
/// </summary>
public static float GetLocalPingLocation(out SteamNetworkPingLocation_t result)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamNetworkingUtils_GetLocalPingLocation(CSteamAPIContext.GetSteamNetworkingUtils(), out result));
}
/// <summary>
/// <para>/ Same as EstimatePingTime, but assumes that one location is the local host.</para>
/// <para>/ This is a bit faster, especially if you need to calculate a bunch of</para>
/// <para>/ these in a loop to find the fastest one.</para>
/// <para>/</para>
/// <para>/ In rare cases this might return a slightly different estimate than combining</para>
/// <para>/ GetLocalPingLocation with EstimatePingTimeBetweenTwoLocations. That's because</para>
/// <para>/ this function uses a slightly more complete set of information about what</para>
/// <para>/ route would be taken.</para>
/// </summary>
public static int EstimatePingTimeFromLocalHost(ref SteamNetworkPingLocation_t remoteLocation)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamNetworkingUtils_EstimatePingTimeFromLocalHost(CSteamAPIContext.GetSteamNetworkingUtils(), ref remoteLocation));
}
/// <summary>
/// <para>/ Estimate the round-trip latency between two arbitrary locations, in</para>
/// <para>/ milliseconds. This is a conservative estimate, based on routing through</para>
/// <para>/ the relay network. For most basic relayed connections, this ping time</para>
/// <para>/ will be pretty accurate, since it will be based on the route likely to</para>
/// <para>/ be actually used.</para>
/// <para>/</para>
/// <para>/ If a direct IP route is used (perhaps via NAT traversal), then the route</para>
/// <para>/ will be different, and the ping time might be better. Or it might actually</para>
/// <para>/ be a bit worse! Standard IP routing is frequently suboptimal!</para>
/// <para>/</para>
/// <para>/ But even in this case, the estimate obtained using this method is a</para>
/// <para>/ reasonable upper bound on the ping time. (Also it has the advantage</para>
/// <para>/ of returning immediately and not sending any packets.)</para>
/// <para>/</para>
/// <para>/ In a few cases we might not able to estimate the route. In this case</para>
/// <para>/ a negative value is returned. k_nSteamNetworkingPing_Failed means</para>
/// <para>/ the reason was because of some networking difficulty. (Failure to</para>
/// <para>/ ping, etc) k_nSteamNetworkingPing_Unknown is returned if we cannot</para>
/// <para>/ currently answer the question for some other reason.</para>
/// <para>/</para>
/// <para>/ Do you need to be able to do this from a backend/matchmaking server?</para>
/// <para>/ You are looking for the "ticketgen" library.</para>
/// </summary>
public static int EstimatePingTimeBetweenTwoLocations(ref SteamNetworkPingLocation_t location1, ref SteamNetworkPingLocation_t location2)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations(CSteamAPIContext.GetSteamNetworkingUtils(), ref location1, ref location2));
}