/// <summary>
/// Called when a requested user's persona state has changed.
/// </summary>
/// <param name="callback"></param>
private static void OnPersonaStateChanged(PersonaStateChange_t callback)
{
if (callback.m_nChangeFlags == EPersonaChange.k_EPersonaChangeAvatar)
{
LoadAvatarIfNotExists(callback.m_ulSteamID);
}
}
void OnPersonaStateChanged(PersonaStateChange_t param)
{
var player = GetSteamPlayer(new CSteamID(param.m_ulSteamID));
if (player != null)
{
player.InternalPersonaChanged(param);
}
if ((param.m_nChangeFlags & EPersonaChange.k_EPersonaChangeRelationshipChanged) != 0)
{
var steamID = new CSteamID(param.m_ulSteamID);
var relationship = SteamFriends.GetFriendRelationship(steamID);
if ((relationship == EFriendRelationship.k_EFriendRelationshipFriend) || (relationship == EFriendRelationship.k_EFriendRelationshipNone))
{
if (player == null)
{
player = CreateSteamPlayer(steamID);
}
if (relationship == EFriendRelationship.k_EFriendRelationshipFriend)
{
FriendshipChanged(player, EOnlinePlayerChangedFlags.FriendAdded);
}
else
{
FriendshipChanged(player, EOnlinePlayerChangedFlags.FriendRemoved);
}
}
}
if (player != null)
{
player.Dispose();
}
}
static EOnlinePlayerChangedFlags GetChangedFlags(PersonaStateChange_t param)
{
EOnlinePlayerChangedFlags flags = 0;
if ((param.m_nChangeFlags & EPersonaChange.k_EPersonaChangeAvatar) != 0)
{
flags |= EOnlinePlayerChangedFlags.Avatar;
}
if ((param.m_nChangeFlags & EPersonaChange.k_EPersonaChangeStatus) != 0)
{
flags |= EOnlinePlayerChangedFlags.Status;
}
if ((param.m_nChangeFlags & (EPersonaChange.k_EPersonaChangeName | EPersonaChange.k_EPersonaChangeNickname)) != 0)
{
flags |= EOnlinePlayerChangedFlags.Name;
}
if ((param.m_nChangeFlags & EPersonaChange.k_EPersonaChangeRelationshipChanged) != 0)
{
var relationship = SteamFriends.GetFriendRelationship(new CSteamID(param.m_ulSteamID));
switch (relationship)
{
case EFriendRelationship.k_EFriendRelationshipFriend:
flags |= EOnlinePlayerChangedFlags.FriendAdded;
break;
case EFriendRelationship.k_EFriendRelationshipNone:
flags |= EOnlinePlayerChangedFlags.FriendRemoved;
break;
}
}
return(flags);
}
private void OnPersonaStateChange(PersonaStateChange_t data)
{
if ((data.ChangeFlags & 0x0040) != 0x0040)
{
return; // wait for k_EPersonaChangeAvatar
}
for (int i = 0; i < PersonaCallbacks.Count; i++)
{
var cb = PersonaCallbacks[i];
if (cb.SteamId != data.SteamID)
{
continue;
}
var image = GetCachedAvatar(cb.Size, cb.SteamId);
if (image == null)
{
continue;
}
PersonaCallbacks.Remove(cb);
if (cb.Callback != null)
{
cb.Callback(image);
}
}
}
private void OnPersonaStateChange(PersonaStateChange_t i_Params)
{
CSteamID steamId = new CSteamID(i_Params.m_ulSteamID);
SteamFriend steamFriend = Internal_GetFriend(steamId);
if (steamFriend != null)
{
bool isMyFriend = SteamFriends.HasFriend(steamId, EFriendFlags.k_EFriendFlagImmediate);
if (isMyFriend)
{
steamFriend.Refresh();
}
else
{
m_Friends.Remove(steamId);
}
}
else
{
steamFriend = new SteamFriend(steamId);
m_Friends.Add(steamId, steamFriend);
}
RaiseFriendsChangedEvent();
}
private void OnPersonaStateChange(PersonaStateChange_t data)
{
if ((data.ChangeFlags & 0x0040) != 0x0040)
{
return; // wait for k_EPersonaChangeAvatar
}
LoadForSteamid(data.SteamID);
}
// Token: 0x06002ED7 RID: 11991 RVA: 0x0013209E File Offset: 0x0013049E
private static void onPersonaStateChange(PersonaStateChange_t callback)
{
if (Lobbies.currentLobby == CSteamID.Nil)
{
return;
}
Lobbies.triggerLobbiesRefreshed();
}
private void OnPersonaStateChange(PersonaStateChange_t callback)
{
if ((callback.m_nChangeFlags == EPersonaChange.k_EPersonaChangeName) && (callback.m_ulSteamID == ((SteamIdentity)Connection.ClientID).SteamID.m_SteamID))
{
Connection.ClientName = SteamFriends.GetPersonaName();
//Todo: OnNameChangeEvent
}
}
void PersonaStateChange(PersonaStateChange_t obj)
{
txtCallbacks.Invoke((MethodInvoker) delegate
{
txtCallbacks.AppendText("PersonaStateChange_t: " + context.SteamFriends.GetFriendPersonaName(obj.m_ulSteamID) + " (" + new CSteamID(obj.m_ulSteamID).Render() + ") Flags: " + obj.m_nChangeFlags + Environment.NewLine);
txtCallbacks.ScrollToCaret();
});
}
void PersonaStateChangeRequest(PersonaStateChange_t cb)
{
Texture2D tex = GetUserAvatar((CSteamID)cb.m_ulSteamID);
if (tex != null)
{
SteamAvatarImage = tex;
}
}
/// <summary>
/// Makes sure we send an update callback if a Lobby user updates their information
/// </summary>
internal void OnLobbyMemberPersonaChangeAPI(PersonaStateChange_t callback)
{
if (!UserIsInCurrentLobby(callback.SteamID))
{
return;
}
if (OnLobbyMemberDataUpdated != null)
{
OnLobbyMemberDataUpdated(callback.SteamID);
}
}
private void StateChange(PersonaStateChange_t change)
{
IClient cl;
if (change.m_nChangeFlags == EPersonaChange.k_EPersonaChangeComeOnline)
{
cl = new SteamClient(change.m_ulSteamID);
clients.Add(cl);
Database.GetDatabase().GetChannel("Friends").AddClient(cl);
}
else if (change.m_nChangeFlags == EPersonaChange.k_EPersonaChangeGoneOffline)
{
cl = GetSteamClient(change.m_ulSteamID);
if (cl != null)
{
cl.Dispose();
}
}
else if (change.m_nChangeFlags == EPersonaChange.k_EPersonaChangeName)
{
cl = GetSteamClient(change.m_ulSteamID);
if (cl != null)
{
cl.RealName = clientFriends.GetFriendPersonaName(change.m_ulSteamID);
if (!clientList.Clients.ContainsKey(change.m_ulSteamID))
{
cl.AddMessage(IRCMessage.GetStatic().CreateMessage(cl, "NICK " + StripString(cl.RealName)));
}
//Server.GetChannel("Friends").SendMessage(Message.CreateMessage(cl, cl.UserString, "NICK", new string[] { StripString(cl.RealName) }));
//cl.NickName = StripString(cl.RealName);
}
}
else if (change.m_nChangeFlags == EPersonaChange.k_EPersonaChangeStatus)
{
EPersonaState st = clientFriends.GetFriendPersonaState(change.m_ulSteamID);
cl = GetSteamClient(change.m_ulSteamID);
if (cl != null)
{
if (st == EPersonaState.k_EPersonaStateOffline)
{
cl.Dispose();
}
else
{
cl.AddMessage(IRCMessage.GetStatic().CreateMessage(cl, cl.UserString, "AWAY", new string[] { (st == EPersonaState.k_EPersonaStateOnline ? "" : st.ToString().Remove(0, 15)) }));
}
}
//cl.AwayMsg = (st == EPersonaState.k_EPersonaStateOnline ? "" : st.ToString().Remove(0, 15));
}
}
void OnStateChange_OnRun(PersonaStateChange_t param)
{
lock ( closeLock )
{
if (bClosing)
{
return;
}
this.Invoke(new MethodInvoker(() => HandleStateChange(param)));
}
}
void HandleStateChange(PersonaStateChange_t param)
{
FriendControl fc = friendsFlow.GetFriendControl(new Friend(param.m_ulSteamID));
if (fc == null)
{
return;
}
// force update
fc.SetSteamID(fc.Friend);
}
private void HandlePersonaStateChange(PersonaStateChange_t param)
{
var id = new CSteamID(param.m_ulSteamID);
if (id == LocalUser)
{
LocalUser.NotifyStateChanged();
}
else
{
Friends.NotifyStateChanged(new CSteamID(param.m_ulSteamID));
}
}
protected void onPersonaStateChange(PersonaStateChange_t callback)
{
if (callback.m_ulSteamID != this.workshopItemDetails.m_ulSteamIDOwner)
{
return;
}
if (this.hasPersonaInfo)
{
return;
}
this.hasPersonaInfo = true;
this.downloadWorkshopItem();
}
void OnPersonaStateChange(PersonaStateChange_t pCallback)
{
SteamFriendsData data = SteamGetFriendsProcess.Instance.GetFriendInfo(new CSteamID(pCallback.m_ulSteamID));
if (_funPersonStateChange != null && data != null)
{
foreach (var iter in _FriendsList)
{
if (iter.Value._SteamID == data._SteamID)
{
_FriendsList[iter.Key] = data;
_funPersonStateChange(iter.Key);
break;
}
}
}
//Debug.Log("[" + PersonaStateChange_t.k_iCallback + " - PersonaStateChange] - " + pCallback.m_ulSteamID + " -- " + pCallback.m_nChangeFlags);
}
internal void InternalPersonaChanged(PersonaStateChange_t param)
{
_waitingForPersona = false;
CheckDisposed();
var flags = GetChangedFlags(param);
if ((flags & EOnlinePlayerChangedFlags.Name) != 0)
{
UpdateName();
}
if ((flags & EOnlinePlayerChangedFlags.Avatar) != 0)
{
api.GetSmallAvatar(this, false);
api.GetLargeAvatar(this, false);
}
api.InternalPersonaStateChanged(this, flags);
}
private void OnPersonaStateChange(PersonaStateChange_t data)
{
// k_EPersonaChangeAvatar
if ((data.ChangeFlags & 0x0040) == 0x0040)
{
LoadAvatarForSteamId(data.SteamID);
}
//
// Find and refresh this friend's status
//
foreach (var friend in All)
{
if (friend.Id != data.SteamID)
{
continue;
}
friend.Refresh();
}
}
void PersonaStateChange_OnRun(PersonaStateChange_t param)
{
if (param.m_ulSteamID != SteamContext.SteamUser.GetSteamID())
{
// we're only interested in our own persona changes
return;
}
if (!SkypeContext.IsReady)
{
Log("Warning: Detect game launch, but skype isn't attached!");
return;
}
if ((param.m_nChangeFlags & EPersonaChange.k_EPersonaChangeGamePlayed) != 0)
{
this.Invoke(new MethodInvoker(() =>
{
UpdateSkypeMood(param);
}));
}
}
private void UpdateSkypeMood(PersonaStateChange_t param)
{
FriendGameInfo_t gameInfo = new FriendGameInfo_t();
if (!SteamContext.SteamFriends.GetFriendGamePlayed(param.m_ulSteamID, ref gameInfo))
{
// this happens when we stop playing a game
SetSkypeMood("Stopped playing");
return;
}
CGameID gameId = gameInfo.m_gameID;
if (gameId.AppType != CGameID.EGameID.k_EGameIDTypeApp)
{
Log("Info: Detected game launch, but wasn't steam game. Only official steam apps are supported!");
return;
}
StringBuilder sb = new StringBuilder(256);
int len = SteamContext.SteamApps.GetAppData(gameId.AppID, "name", sb);
string name = sb.ToString();
if (string.IsNullOrWhiteSpace(name) || len == 0)
{
Log("Info: Detect game launch, but wasn't able to get the name! AppID: {0}, GameID: {1}", gameId.AppID, gameId.ConvertToUint64());
Log("Will try to pick up a delayed game update!");
delayAppId = gameId.AppID;
return;
}
SetSkypeMood("Now Playing: {0}", name);
Log("Now playing: {0}", name);
}
void StateChange( PersonaStateChange_t perState )
{
}
void OnPersonaStateChange(PersonaStateChange_t pCallback)
{
Debug.Log("Script state Changed");
}
private static void StartAndWaitForSteam()
{
if (Process.GetProcessesByName("Steam").Length == 0 && Directory.Exists(steamDir))
{
Environment.SetEnvironmentVariable("SteamAppId", "000");
Stopwatch stopwatch = null;
if (!Steamworks.Load(true))
{
Println("Steamworks could not be loaded, falling back to older method...", "warning");
LegacyStartAndWaitForSteam();
return;
}
if (!firstRun)
{
steamclient = Steamworks.CreateInterface <ISteamClient017>();
}
if (steamclient == null)
{
Println("Steamworks could not be loaded, falling back to older method...", "warning");
LegacyStartAndWaitForSteam();
return;
}
int pipe = steamclient.CreateSteamPipe();
if (pipe == 0)
{
Println("Starting Steam...");
Process.Start(steamDir + "\\Steam.exe", steamargs);
Println("Waiting for friends list to connect...");
stopwatch = Stopwatch.StartNew();
while (pipe == 0 && stopwatch.Elapsed.Seconds < Timeout)
{
pipe = steamclient.CreateSteamPipe();
Thread.Sleep(100);
}
stopwatch.Stop();
if (stopwatch.Elapsed.Seconds >= Timeout && pipe == 0)
{
Println("Steamworks could not be loaded, falling back to older method...", "warning");
steamclient.BShutdownIfAllPipesClosed();
LegacyStartAndWaitForSteam();
return;
}
}
int user = steamclient.ConnectToGlobalUser(pipe);
if (user == 0 || user == -1)
{
Println("Steamworks could not be loaded, falling back to older method...", "warning");
steamclient.BReleaseSteamPipe(pipe);
steamclient.BShutdownIfAllPipesClosed();
LegacyStartAndWaitForSteam();
return;
}
if (!firstRun)
{
steamfriends = steamclient.GetISteamFriends <ISteamFriends015>(user, pipe);
firstRun = true;
}
if (steamfriends == null)
{
Println("Steamworks could not be loaded, falling back to older method...", "warning");
steamclient.BReleaseSteamPipe(pipe);
steamclient.BShutdownIfAllPipesClosed();
LegacyStartAndWaitForSteam();
return;
}
CallbackMsg_t callbackMsg = default(CallbackMsg_t);
bool stateChangeDetected = false;
stopwatch = Stopwatch.StartNew();
while (!stateChangeDetected && stopwatch.Elapsed.Seconds < Timeout)
{
while (Steamworks.GetCallback(pipe, ref callbackMsg) && !stateChangeDetected && stopwatch.Elapsed.Seconds < Timeout)
{
if (callbackMsg.m_iCallback == PersonaStateChange_t.k_iCallback)
{
PersonaStateChange_t onPersonaStateChange = (PersonaStateChange_t)Marshal.PtrToStructure(callbackMsg.m_pubParam, typeof(PersonaStateChange_t));
if (onPersonaStateChange.m_nChangeFlags.HasFlag(EPersonaChange.k_EPersonaChangeComeOnline))
{
stateChangeDetected = true;
Println("Friends list connected!", "success");
break;
}
}
Steamworks.FreeLastCallback(pipe);
}
Thread.Sleep(100);
}
stopwatch.Stop();
Steamworks.FreeLastCallback(pipe);
steamclient.ReleaseUser(pipe, user);
steamclient.BReleaseSteamPipe(pipe);
steamclient.BShutdownIfAllPipesClosed();
if (stopwatch.Elapsed.Seconds >= Timeout)
{
Println("Steamworks could not be loaded, falling back to older method...", "warning");
LegacyStartAndWaitForSteam();
return;
}
}
}
public void OnPersonaStateChange(PersonaStateChange_t pCallback)
{
Fsm.Event(eventTarget, Changed);
}
private void onPersonaStateChange(PersonaStateChange_t persona)
{
this.PersonaNotification.Changed();
}
void OnPersonaStateChange(PersonaStateChange_t pCallback)
{
Debug.Log("[" + PersonaStateChange_t.k_iCallback + " - PersonaStateChange] - " + pCallback.m_ulSteamID + " -- " + pCallback.m_nChangeFlags);
}
private void OnPersonaStateChange(PersonaStateChange_t data, bool error)
{
}
private void OnPersonaStateChange(PersonaStateChange_t data)
{
// HUH
}
void OnPersonaStateChange(PersonaStateChange_t pCallback)
{
Console.WriteLine("[" + PersonaStateChange_t.k_iCallback + " - PersonaStateChange] - " + pCallback.m_ulSteamID + " -- " + pCallback.m_nChangeFlags);
}
