internal static void InstallEvents()
{
SteamInventory.InstallEvents();
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);
}
internal static void InstallEvents()
{
SteamServersConnected_t.Install(x => OnSteamServersConnected?.Invoke());
SteamServerConnectFailure_t.Install(x => OnSteamServerConnectFailure?.Invoke());
SteamServersDisconnected_t.Install(x => OnSteamServersDisconnected?.Invoke());
ClientGameServerDeny_t.Install(x => OnClientGameServerDeny?.Invoke());
LicensesUpdated_t.Install(x => OnLicensesUpdated?.Invoke());
ValidateAuthTicketResponse_t.Install(x => OnValidateAuthTicketResponse?.Invoke(x.SteamID, x.OwnerSteamID, x.AuthSessionResponse));
MicroTxnAuthorizationResponse_t.Install(x => OnMicroTxnAuthorizationResponse?.Invoke(x.AppID, x.OrderID, x.Authorized != 0));
GameWebCallback_t.Install(x => OnGameWebCallback?.Invoke(x.URL));
}
internal static bool CheckValid(ValidateAuthTicketResponse_t r)
{
ESteamRejection? reason = null;
try
{
RocketPermissionsGroup g = R.Permissions.GetGroups(new Rocket.API.RocketPlayer(r.m_SteamID.ToString()),true).FirstOrDefault();
if (g != null)
{
SteamPending steamPending = Provider.pending.FirstOrDefault(x => x.playerID.steamID == r.m_SteamID);
if (steamPending != null)
{
string prefix = g.Prefix == null ? "" : g.Prefix;
string suffix = g.Suffix == null ? "" : g.Suffix;
if (prefix != "" && !steamPending.playerID.characterName.StartsWith(g.Prefix))
{
steamPending.playerID.characterName = prefix + steamPending.playerID.characterName;
}
if (suffix != "" && !steamPending.playerID.characterName.EndsWith(g.Suffix))
{
steamPending.playerID.characterName = steamPending.playerID.characterName + suffix;
}
}
}
}
catch (Exception ex)
{
Core.Logging.Logger.Log("Failed adding prefix/suffix to player "+r.m_SteamID+": "+ex.ToString());
}
if (OnJoinRequested != null)
{
foreach (var handler in OnJoinRequested.GetInvocationList().Cast<JoinRequested>())
{
try
{
handler(r.m_SteamID, ref reason);
if (reason != null)
{
Provider.reject(r.m_SteamID, reason.Value);
return false;
}
}
catch (Exception ex)
{
Core.Logging.Logger.LogException(ex);
}
}
}
return true;
}
internal static void InstallEvents()
{
SteamInventory.InstallEvents();
ValidateAuthTicketResponse_t.Install((ValidateAuthTicketResponse_t x) => {
Action <SteamId, SteamId, AuthResponse> onValidateAuthTicketResponse = SteamServer.OnValidateAuthTicketResponse;
if (onValidateAuthTicketResponse != null)
{
onValidateAuthTicketResponse(x.SteamID, x.OwnerSteamID, x.AuthSessionResponse);
}
else
{
}
}, true);
SteamServersConnected_t.Install((SteamServersConnected_t x) => {
Action onSteamServersConnected = SteamServer.OnSteamServersConnected;
if (onSteamServersConnected != null)
{
onSteamServersConnected();
}
else
{
}
}, true);
SteamServerConnectFailure_t.Install((SteamServerConnectFailure_t x) => {
Action <Result, bool> onSteamServerConnectFailure = SteamServer.OnSteamServerConnectFailure;
if (onSteamServerConnectFailure != null)
{
onSteamServerConnectFailure(x.Result, x.StillRetrying);
}
else
{
}
}, true);
SteamServersDisconnected_t.Install((SteamServersDisconnected_t x) => {
Action <Result> onSteamServersDisconnected = SteamServer.OnSteamServersDisconnected;
if (onSteamServersDisconnected != null)
{
onSteamServersDisconnected(x.Result);
}
else
{
}
}, true);
}
internal static bool CheckValid(ValidateAuthTicketResponse_t r)
{
ESteamRejection? reason = null;
if (OnJoinRequested != null)
{
foreach (var handler in OnJoinRequested.GetInvocationList().Cast<JoinRequested>())
{
try
{
handler(r.m_SteamID, ref reason);
if (reason != null)
{
Provider.Reject(r.m_SteamID, reason.Value);
return false;
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
}
return true;
}
void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t pCallback) {
Debug.Log("[" + ValidateAuthTicketResponse_t.k_iCallback + " - ValidateAuthTicketResponse] - " + pCallback.m_SteamID + " -- " + pCallback.m_eAuthSessionResponse + " -- " + pCallback.m_OwnerSteamID);
}
internal static void InstallEvents()
{
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(), true);
}
//-----------------------------------------------------------------------------
// Purpose: Tells us Steam3 (VAC and newer license checking) has accepted the user connection
//-----------------------------------------------------------------------------
void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t pResponse) {
Debug.Log("OnValidateAuthTicketResponse Called steamID: " + pResponse.m_SteamID); // Riley
if (pResponse.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseOK) {
// This is the final approval, and means we should let the client play (find the pending auth by steamid)
/* TODO Riley:
for (uint i = 0; i < MAX_PLAYERS_PER_SERVER; ++i) {
if (!m_rgPendingClientData[i].m_bActive)
continue;
else if (m_rgPendingClientData[i].m_SteamIDUser == pResponse.m_SteamID) {
Debug.Log("Auth completed for a client");
OnAuthCompleted(true, i);
return;
}
}
*/
}
else {
// Looks like we shouldn't let this user play, kick them
/* TODO Riley:
for (uint i = 0; i < MAX_PLAYERS_PER_SERVER; ++i) {
if (!m_rgPendingClientData[i].m_bActive)
continue;
else if (m_rgPendingClientData[i].m_SteamIDUser == pResponse.m_SteamID) {
Debug.Log("Auth failed for a client");
OnAuthCompleted(false, i);
return;
}
}
*/
}
}
/// <summary>
/// From Spacewar:
/// Tells us Steam3 (VAC and newer license checking) has accepted the user connection
/// </summary>
/// <param name="callback"></param>
void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t callback)
{
EAuthSessionResponse response = callback.m_eAuthSessionResponse;
if (response == EAuthSessionResponse.k_EAuthSessionResponseOK){
_Players[callback.m_SteamID] = EPlayerStatus.InServer;
if (PlayerAuthenticated != null)
PlayerAuthenticated(callback.m_SteamID);
}else{
// Auth ticket failed to validate, kick the player.
SteamGameServer.EndAuthSession(callback.m_SteamID);
SendFailedConnection(callback.m_SteamID, EGSConnectionError.AuthenticationError);
_Players.Remove(callback.m_SteamID);
}
}
internal static void InstallEvents()
{
ValidateAuthTicketResponse_t.Install(x => OnValidateAuthTicketResponse?.Invoke(x.SteamID, x.OwnerSteamID, x.AuthSessionResponse), true);
SteamServerInventory.InstallEvents();
}
public static bool CheckValid(ValidateAuthTicketResponse_t r)
{
return UnturnedPermissions.CheckValid(r);
}
internal static void InstallEvents()
{
SteamServersConnected_t.Install((SteamServersConnected_t x) => {
Action onSteamServersConnected = SteamUser.OnSteamServersConnected;
if (onSteamServersConnected != null)
{
onSteamServersConnected();
}
else
{
}
}, false);
SteamServerConnectFailure_t.Install((SteamServerConnectFailure_t x) => {
Action onSteamServerConnectFailure = SteamUser.OnSteamServerConnectFailure;
if (onSteamServerConnectFailure != null)
{
onSteamServerConnectFailure();
}
else
{
}
}, false);
SteamServersDisconnected_t.Install((SteamServersDisconnected_t x) => {
Action onSteamServersDisconnected = SteamUser.OnSteamServersDisconnected;
if (onSteamServersDisconnected != null)
{
onSteamServersDisconnected();
}
else
{
}
}, false);
ClientGameServerDeny_t.Install((ClientGameServerDeny_t x) => {
Action onClientGameServerDeny = SteamUser.OnClientGameServerDeny;
if (onClientGameServerDeny != null)
{
onClientGameServerDeny();
}
else
{
}
}, false);
LicensesUpdated_t.Install((LicensesUpdated_t x) => {
Action onLicensesUpdated = SteamUser.OnLicensesUpdated;
if (onLicensesUpdated != null)
{
onLicensesUpdated();
}
else
{
}
}, false);
ValidateAuthTicketResponse_t.Install((ValidateAuthTicketResponse_t x) => {
Action <SteamId, SteamId, AuthResponse> onValidateAuthTicketResponse = SteamUser.OnValidateAuthTicketResponse;
if (onValidateAuthTicketResponse != null)
{
onValidateAuthTicketResponse(x.SteamID, x.OwnerSteamID, x.AuthSessionResponse);
}
else
{
}
}, false);
MicroTxnAuthorizationResponse_t.Install((MicroTxnAuthorizationResponse_t x) => {
Action <AppId, ulong, bool> onMicroTxnAuthorizationResponse = SteamUser.OnMicroTxnAuthorizationResponse;
if (onMicroTxnAuthorizationResponse != null)
{
onMicroTxnAuthorizationResponse(x.AppID, x.OrderID, x.Authorized != 0);
}
else
{
}
}, false);
GameWebCallback_t.Install((GameWebCallback_t x) => {
Action <string> onGameWebCallback = SteamUser.OnGameWebCallback;
if (onGameWebCallback != null)
{
onGameWebCallback(x.URL);
}
else
{
}
}, false);
GetAuthSessionTicketResponse_t.Install((GetAuthSessionTicketResponse_t x) => {
Action <GetAuthSessionTicketResponse_t> onGetAuthSessionTicketResponse = SteamUser.OnGetAuthSessionTicketResponse;
if (onGetAuthSessionTicketResponse != null)
{
onGetAuthSessionTicketResponse(x);
}
else
{
}
}, false);
}
