public override bool Equals(object obj)
{
return(obj switch
{
UnturnedUser other => Equals(other),
UnturnedPendingUser otherPending => Equals(otherPending),
_ => false
});
protected virtual void OnPendingPlayerConnecting(ValidateAuthTicketResponse_t callback, ref bool isValid, ref string explanation)
{
if (m_PendingUsers.Any(d => d.SteamId == callback.m_SteamID))
{
return;
}
if (!isValid)
{
return;
}
//todo check if it is working, if not this should be patched
var isPendingValid = isValid;
var rejectExplanation = explanation;
AsyncHelper.RunSync(async() =>
{
var steamPending = Provider.pending.FirstOrDefault(d => d.playerID.steamID == callback.m_SteamID);
if (steamPending == null)
{
return;
}
var pendingUser = new UnturnedPendingUser(this, m_UserDataStore, steamPending);
var userData = await m_UserDataStore.GetUserDataAsync(pendingUser.Id, pendingUser.Type);
if (userData != null)
{
userData.LastSeen = DateTime.Now;
userData.LastDisplayName = pendingUser.DisplayName;
await m_UserDataStore.SetUserDataAsync(userData);
}
else
{
await m_DataSeeder.SeedUserDataAsync(pendingUser.Id, pendingUser.Type, pendingUser.DisplayName);
await m_EventBus.EmitAsync(m_Runtime, this, new UserFirstConnectEvent(pendingUser));
}
m_PendingUsers.Add(pendingUser);
var userConnectingEvent = new UserConnectEvent(pendingUser);
await m_EventBus.EmitAsync(m_Runtime, this, userConnectingEvent);
if (!string.IsNullOrEmpty(userConnectingEvent.RejectionReason))
{
isPendingValid = false;
rejectExplanation = userConnectingEvent.RejectionReason;
}
if (userConnectingEvent.IsCancelled)
{
isPendingValid = false;
}
});
isValid = isPendingValid;
explanation = rejectExplanation;
}
protected virtual void FinishSession(UnturnedPendingUser pending)
{
if (pending.Session is UnturnedPendingUserSession session)
{
session.OnSessionEnd();
}
m_PendingUsers.Remove(pending);
}
public UnturnedUser(IUserDataStore userDataStore, Player player, UnturnedPendingUser pending = null) : base(userDataStore)
{
Type = KnownActorTypes.Player;
Player = player;
SteamPlayer = Player.channel.owner;
var steamPlayerIdId = SteamPlayer.playerID;
SteamId = steamPlayerIdId.steamID;
DisplayName = SteamPlayer.playerID.characterName;
Session = new UnturnedUserSession(this, pending?.Session);
}
protected internal UnturnedUser(
UnturnedUserProvider userProvider,
IUserDataStore userDataStore,
Player player,
UnturnedPendingUser pending = null) : base(userProvider, userDataStore)
{
var steamPlayerIdId = player.channel.owner.playerID;
SteamId = steamPlayerIdId.steamID;
Player = new UnturnedPlayer(player);
DisplayName = player.channel.owner.playerID.characterName;
Type = KnownActorTypes.Player;
Session = new UnturnedUserSession(this, pending?.Session);
}
public UnturnedUser(Player player, UnturnedPendingUser pending)
{
Player = player;
SteamPlayer = Player.channel.owner;
var steamPlayerIdId = SteamPlayer.playerID;
SteamId = steamPlayerIdId.steamID;
DisplayName = SteamPlayer.playerID.characterName;
SessionData = pending.SessionData;
PersistentData = pending.PersistentData;
SessionStartTime = pending.SessionStartTime;
}
protected virtual void OnPendingPlayerConnected(ValidateAuthTicketResponse_t callback, ref bool isvalid, ref string explanation)
{
var isvalid_ = isvalid;
var explanation_ = explanation;
AsyncHelper.RunSync(async() =>
{
if (!isvalid_)
{
return;
}
var steamPending = Provider.pending.First(d => d.playerID.steamID == callback.m_SteamID);
var pendingUser = new UnturnedPendingUser(steamPending);
await m_DataSeeder.SeedUserDataAsync(pendingUser.Id, pendingUser.Type, pendingUser.DisplayName);
var userData = await m_UserDataStore.GetUserDataAsync(pendingUser.Type, pendingUser.Id);
userData.LastSeen = DateTime.Now;
userData.LastDisplayName = pendingUser.DisplayName;
await m_UserDataStore.SaveUserDataAsync(userData);
pendingUser.PersistentData = userData.Data;
m_PendingUsers.Add(pendingUser);
var userConnectingEvent = new UserConnectingEvent(pendingUser);
await m_EventBus.EmitAsync(m_Runtime, this, userConnectingEvent);
if (!string.IsNullOrEmpty(userConnectingEvent.RejectionReason))
{
isvalid_ = false;
explanation_ = userConnectingEvent.RejectionReason;
}
if (userConnectingEvent.IsCancelled)
{
isvalid_ = false;
}
});
isvalid = isvalid_;
explanation = explanation_;
}
public bool Equals(UnturnedPendingUser other)
{
return(other?.Equals(this) ?? false);
}
public UnturnedPendingUserSession(UnturnedPendingUser user)
{
User = user;
SessionStartTime = DateTime.Now;
SessionData = new Dictionary <string, object>();
}
protected virtual void FinishSession(UnturnedPendingUser pending)
{
pending.SessionEndTime = DateTime.Now;
m_PendingUsers.Remove(pending);
}
protected virtual void OnPendingPlayerConnecting(ValidateAuthTicketResponse_t callback, ref bool isValid,
ref string?explanation)
{
var user = GetUser(callback.m_SteamID);
if (user != null || m_PendingUsers.Any(d => d.SteamId == callback.m_SteamID))
{
return;
}
var steamPending = Provider.pending.FirstOrDefault(d => d.playerID.steamID == callback.m_SteamID);
if (steamPending == null)
{
return;
}
var pendingUser = new UnturnedPendingUser(this, m_UserDataStore, steamPending);
m_PendingUsers.Add(pendingUser);
var isPendingValid = isValid;
var rejectExplanation = explanation;
AsyncHelper.RunSync(async() =>
{
UnturnedUserConnectingEvent userEvent;
var userData = await m_UserDataStore.GetUserDataAsync(pendingUser.Id, pendingUser.Type);
if (userData != null)
{
userEvent = new UnturnedUserConnectingEvent(pendingUser);
userData.LastSeen = DateTime.Now;
userData.LastDisplayName = pendingUser.DisplayName;
UniTask.RunOnThreadPool(() => m_UserDataStore.SetUserDataAsync(userData)).Forget();
}
else
{
userEvent = new UnturnedUserFirstConnectingEvent(pendingUser);
UniTask.RunOnThreadPool(() => m_DataSeeder.SeedUserDataAsync(pendingUser.Id, pendingUser.Type, pendingUser.DisplayName)).Forget();
}
userEvent.IsCancelled = !isPendingValid;
if (rejectExplanation != null)
{
await userEvent.RejectAsync(rejectExplanation);
}
await m_EventBus.EmitAsync(m_Runtime, this, userEvent);
if (!string.IsNullOrEmpty(userEvent.RejectionReason))
{
isPendingValid = false;
rejectExplanation = userEvent.RejectionReason;
}
else if (userEvent.IsCancelled)
{
isPendingValid = false;
}
});
isValid = isPendingValid;
explanation = rejectExplanation;
}
