vlad.os/LuaCsForBarotraumaEP
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

(61d00a474) v0.9.7.1

Browse Source
This commit is contained in:
Regalis
2020-03-04 13:04:10 +01:00
parent 3c50efa5c9
commit 3c09ebe02f
5086 changed files with 786063 additions and 295871 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Libraries/Facepunch.Steamworks/SteamServer.cs
+467
View File
@@ -0,0 +1,467 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using Steamworks.Data;
namespace Steamworks
{
/// <summary>
/// Provides the core of the Steam Game Servers API
/// </summary>
public static partial class SteamServer
{
static bool initialized;
static ISteamGameServer _internal;
internal static ISteamGameServer Internal
{
get
{
if ( _internal == null )
{
_internal = new ISteamGameServer( );
_internal.InitServer();
}
return _internal;
}
}
public static bool IsValid => initialized;
public static Action<Exception> OnCallbackException;
internal static void InstallEvents()
{
SteamInventory.InstallEvents();
SteamNetworkingSockets.InstallEvents(true);
SteamUGC.InstallEvents(true);
ValidateAuthTicketResponse_t.Install( x => OnValidateAuthTicketResponse?.Invoke( x.SteamID, x.OwnerSteamID, x.AuthSessionResponse ), true );
SteamServersConnected_t.Install( x => OnSteamServersConnected?.Invoke(), true );
SteamServerConnectFailure_t.Install( x => OnSteamServerConnectFailure?.Invoke( x.Result, x.StillRetrying ), true );
SteamServersDisconnected_t.Install( x => OnSteamServersDisconnected?.Invoke( x.Result ), true );
}
/// <summary>
/// User has been authed or rejected
/// </summary>
public static event Action<SteamId, SteamId, AuthResponse> OnValidateAuthTicketResponse;
/// <summary>
/// Called when a connections to the Steam back-end has been established.
/// This means the server now is logged on and has a working connection to the Steam master server.
/// </summary>
public static event Action OnSteamServersConnected;
/// <summary>
/// This will occur periodically if the Steam client is not connected, and has failed when retrying to establish a connection (result, stilltrying)
/// </summary>
public static event Action<Result, bool> OnSteamServerConnectFailure;
/// <summary>
/// Disconnected from Steam
/// </summary>
public static event Action<Result> OnSteamServersDisconnected;
/// <summary>
/// Initialize the steam server.
/// If asyncCallbacks is false you need to call RunCallbacks manually every frame.
/// </summary>
public static void Init( AppId appid, SteamServerInit init, bool asyncCallbacks = true )
{
uint ipaddress = 0; // Any Port
if ( init.SteamPort == 0 )
init = init.WithRandomSteamPort();
if ( init.IpAddress != null )
ipaddress = Utility.IpToInt32( init.IpAddress );
System.Environment.SetEnvironmentVariable( "SteamAppId", appid.ToString() );
System.Environment.SetEnvironmentVariable( "SteamGameId", appid.ToString() );
var secure = (int)(init.Secure ? 3 : 2);
//
// Get other interfaces
//
if ( !SteamInternal.GameServer_Init( ipaddress, init.SteamPort, init.GamePort, init.QueryPort, secure, init.VersionString ) )
{
throw new System.Exception( $"InitGameServer returned false ({ipaddress},{init.SteamPort},{init.GamePort},{init.QueryPort},{secure},\"{init.VersionString}\")" );
}
initialized = true;
//
// Initial settings
//
AutomaticHeartbeats = true;
MaxPlayers = 32;
BotCount = 0;
Product = $"{appid.Value}";
ModDir = init.ModDir;
GameDescription = init.GameDescription;
Passworded = false;
DedicatedServer = init.DedicatedServer;
InstallEvents();
if ( asyncCallbacks )
{
RunCallbacksAsync();
}
}
static List<SteamInterface> openIterfaces = new List<SteamInterface>();
internal static void WatchInterface( SteamInterface steamInterface )
{
if ( openIterfaces.Contains( steamInterface ) )
throw new System.Exception( "openIterfaces already contains interface!" );
openIterfaces.Add( steamInterface );
}
internal static void ShutdownInterfaces()
{
foreach ( var e in openIterfaces )
{
e.Shutdown();
}
openIterfaces.Clear();
}
public static void Shutdown()
{
Event.DisposeAllServer();
initialized = false;
_internal = null;
ShutdownInterfaces();
SteamNetworkingUtils.Shutdown();
SteamNetworkingSockets.Shutdown();
SteamInventory.Shutdown();
SteamGameServer.Shutdown();
}
internal static async void RunCallbacksAsync()
{
while ( IsValid )
{
try
{
RunCallbacks();
}
catch ( System.Exception e )
{
OnCallbackException?.Invoke( e );
}
await Task.Delay( 16 );
}
}
/// <summary>
/// Run the callbacks. This is also called in Async callbacks.
/// </summary>
public static void RunCallbacks()
{
SteamGameServer.RunCallbacks();
}
/// <summary>
/// Sets whether this should be marked as a dedicated server.
/// If not, it is assumed to be a listen server.
/// </summary>
public static bool DedicatedServer
{
get => _dedicatedServer;
set { if ( _dedicatedServer == value ) return; Internal.SetDedicatedServer( value ); _dedicatedServer = value; }
}
private static bool _dedicatedServer;
/// <summary>
/// Gets or sets the current MaxPlayers.
/// This doesn't enforce any kind of limit, it just updates the master server.
/// </summary>
public static int MaxPlayers
{
get => _maxplayers;
set { if ( _maxplayers == value ) return; Internal.SetMaxPlayerCount( value ); _maxplayers = value; }
}
private static int _maxplayers = 0;
/// <summary>
/// Gets or sets the current BotCount.
/// This doesn't enforce any kind of limit, it just updates the master server.
/// </summary>
public static int BotCount
{
get => _botcount;
set { if ( _botcount == value ) return; Internal.SetBotPlayerCount( value ); _botcount = value; }
}
private static int _botcount = 0;
/// <summary>
/// Gets or sets the current Map Name.
/// </summary>
public static string MapName
{
get => _mapname;
set { if ( _mapname == value ) return; Internal.SetMapName( value ); _mapname = value; }
}
private static string _mapname;
/// <summary>
/// Gets or sets the current ModDir
/// </summary>
public static string ModDir
{
get => _modDir;
internal set { if ( _modDir == value ) return; Internal.SetModDir( value ); _modDir = value; }
}
private static string _modDir = "";
/// <summary>
/// Gets the current product
/// </summary>
public static string Product
{
get => _product;
internal set { if ( _product == value ) return; Internal.SetProduct( value ); _product = value; }
}
private static string _product = "";
/// <summary>
/// Gets or sets the current Product
/// </summary>
public static string GameDescription
{
get => _gameDescription;
internal set { if ( _gameDescription == value ) return; Internal.SetGameDescription( value ); _gameDescription = value; }
}
private static string _gameDescription = "";
/// <summary>
/// Gets or sets the current ServerName
/// </summary>
public static string ServerName
{
get => _serverName;
set { if ( _serverName == value ) return; Internal.SetServerName( value ); _serverName = value; }
}
private static string _serverName = "";
/// <summary>
/// Set whether the server should report itself as passworded
/// </summary>
public static bool Passworded
{
get => _passworded;
set { if ( _passworded == value ) return; Internal.SetPasswordProtected( value ); _passworded = value; }
}
private static bool _passworded;
/// <summary>
/// Gets or sets the current GameTags. This is a comma seperated list of tags for this server.
/// When querying the server list you can filter by these tags.
/// </summary>
public static string GameTags
{
get => _gametags;
set
{
if ( _gametags == value ) return;
Internal.SetGameTags( value );
_gametags = value;
}
}
private static string _gametags = "";
/// <summary>
/// Log onto Steam anonymously.
/// </summary>
public static void LogOnAnonymous()
{
Internal.LogOnAnonymous();
ForceHeartbeat();
}
/// <summary>
/// Log onto Steam anonymously.
/// </summary>
public static void LogOff()
{
Internal.LogOff();
}
/// <summary>
/// Returns true if the server is connected and registered with the Steam master server
/// You should have called LogOnAnonymous etc on startup.
/// </summary>
public static bool LoggedOn => Internal.BLoggedOn();
/// <summary>
/// To the best of its ability this tries to get the server's
/// current public ip address. Be aware that this is likely to return
/// null for the first few seconds after initialization.
/// </summary>
public static System.Net.IPAddress PublicIp
{
get
{
var ip = Internal.GetPublicIP();
if ( ip == 0 ) return null;
return Utility.Int32ToIp( ip );
}
}
/// <summary>
/// Enable or disable heartbeats, which are sent regularly to the master server.
/// Enabled by default.
/// </summary>
public static bool AutomaticHeartbeats
{
set { Internal.EnableHeartbeats( value ); }
}
/// <summary>
/// Set heartbeat interval, if automatic heartbeats are enabled.
/// You can leave this at the default.
/// </summary>
public static int AutomaticHeartbeatRate
{
set { Internal.SetHeartbeatInterval( value ); }
}
/// <summary>
/// Force send a heartbeat to the master server instead of waiting
/// for the next automatic update (if you've left them enabled)
/// </summary>
public static void ForceHeartbeat()
{
Internal.ForceHeartbeat();
}
/// <summary>
/// Update this connected player's information. You should really call this
/// any time a player's name or score changes. This keeps the information shown
/// to server queries up to date.
/// </summary>
public static void UpdatePlayer( SteamId steamid, string name, int score )
{
Internal.BUpdateUserData( steamid, name, (uint)score );
}
static Dictionary<string, string> KeyValue = new Dictionary<string, string>();
/// <summary>
/// Sets a Key Value. These can be anything you like, and are accessible
/// when querying servers from the server list.
///
/// Information describing gamemodes are common here.
/// </summary>
public static void SetKey( string Key, string Value )
{
if ( KeyValue.ContainsKey( Key ) )
{
if ( KeyValue[Key] == Value )
return;
KeyValue[Key] = Value;
}
else
{
KeyValue.Add( Key, Value );
}
Internal.SetKeyValue( Key, Value );
}
/// <summary>
/// Remove all key values
/// </summary>
public static void ClearKeys()
{
KeyValue.Clear();
Internal.ClearAllKeyValues();
}
/// <summary>
/// Start authorizing a ticket. This user isn't authorized yet. Wait for a call to OnValidateAuthTicketResponse.
/// </summary>
public static unsafe BeginAuthResult BeginAuthSession( byte[] data, SteamId steamid )
{
fixed ( byte* p = data )
{
var result = Internal.BeginAuthSession( (IntPtr)p, data.Length, steamid );
return result;
}
}
/// <summary>
/// Forget this guy. They're no longer in the game.
/// </summary>
public static void EndSession( SteamId steamid )
{
Internal.EndAuthSession( steamid );
}
/// <summary>
/// If true, Steam wants to send a packet. You should respond by sending
/// this packet in an unconnected way to the returned Address and Port.
/// </summary>
/// <param name="packet">Packet to send. The Data passed is pooled - so use it immediately.</param>
/// <returns>True if we want to send a packet</returns>
public static unsafe bool GetOutgoingPacket( out OutgoingPacket packet )
{
var buffer = Helpers.TakeBuffer( 1024 * 32 );
packet = new OutgoingPacket();
fixed ( byte* ptr = buffer )
{
uint addr = 0;
ushort port = 0;
var size = Internal.GetNextOutgoingPacket( (IntPtr)ptr, buffer.Length, ref addr, ref port );
if ( size == 0 )
return false;
packet.Size = size;
packet.Data = buffer;
packet.Address = addr;
packet.Port = port;
return true;
}
}
/// <summary>
/// We have received a server query on our game port. Pass it to Steam to handle.
/// </summary>
public static unsafe void HandleIncomingPacket( byte[] data, int size, uint address, ushort port )
{
fixed ( byte* ptr = data )
{
HandleIncomingPacket( (IntPtr)ptr, size, address, port );
}
}
/// <summary>
/// We have received a server query on our game port. Pass it to Steam to handle.
/// </summary>
public static unsafe void HandleIncomingPacket( IntPtr ptr, int size, uint address, ushort port )
{
Internal.HandleIncomingPacket( ptr, size, address, port );
}
}
}