906 lines
27 KiB
C#
906 lines
27 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using HeathenEngineering.Events;
|
|
using Steamworks;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.Serialization;
|
|
|
|
namespace HeathenEngineering.SteamApi.Foundation
|
|
{
|
|
[HelpURL("https://heathen-engineering.github.io/steamworks-documentation/class_heathen_engineering_1_1_steam_api_1_1_foundation_1_1_steam_settings.html")]
|
|
[CreateAssetMenu(menuName = "Steamworks/Foundation/Steam Settings")]
|
|
public class SteamSettings : ScriptableObject
|
|
{
|
|
[Serializable]
|
|
public class SteamClan
|
|
{
|
|
public CSteamID id;
|
|
|
|
public string displayName;
|
|
|
|
public string tagString;
|
|
|
|
public SteamUserData Owner;
|
|
|
|
public List<SteamUserData> Officers;
|
|
|
|
public SteamClan(CSteamID clanId)
|
|
{
|
|
id = clanId;
|
|
displayName = SteamFriends.GetClanName(id);
|
|
tagString = SteamFriends.GetClanTag(id);
|
|
Owner = current.client.GetUserData(SteamFriends.GetClanOwner(id));
|
|
int clanOfficerCount = SteamFriends.GetClanOfficerCount(id);
|
|
Officers = new List<SteamUserData>();
|
|
for (int i = 0; i < clanOfficerCount; i++)
|
|
{
|
|
Officers.Add(current.client.GetUserData(SteamFriends.GetClanOfficerByIndex(id, i)));
|
|
}
|
|
}
|
|
|
|
public void OpenChat()
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("chat", id);
|
|
}
|
|
|
|
public List<SteamUserData> GetChatMembers()
|
|
{
|
|
List<SteamUserData> list = new List<SteamUserData>();
|
|
int clanChatMemberCount = SteamFriends.GetClanChatMemberCount(id);
|
|
for (int i = 0; i < clanChatMemberCount; i++)
|
|
{
|
|
list.Add(current.client.GetUserData(SteamFriends.GetChatMemberByIndex(id, i)));
|
|
}
|
|
return list;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class GameServer
|
|
{
|
|
[Serializable]
|
|
public class DisconnectedEvent : UnityEvent<SteamServersDisconnected_t>
|
|
{
|
|
}
|
|
|
|
[Serializable]
|
|
public class ConnectedEvent : UnityEvent<SteamServersConnected_t>
|
|
{
|
|
}
|
|
|
|
[Serializable]
|
|
public class FailureEvent : UnityEvent<SteamServerConnectFailure_t>
|
|
{
|
|
}
|
|
|
|
[Header("System Configuraiton")]
|
|
public bool autoInitalize;
|
|
|
|
public bool enableMirror = true;
|
|
|
|
[Header("Initalization Settings")]
|
|
public uint ip;
|
|
|
|
[Tooltip("Port for the master server updater to listen on")]
|
|
public ushort masterServerUpdaterPort = 27016;
|
|
|
|
[Tooltip("Port for the server to do authentication on")]
|
|
public ushort authenticationPort = 8766;
|
|
|
|
[Tooltip("Port for the server to listen on")]
|
|
public ushort serverPort = 27015;
|
|
|
|
public string serverVersion = "1.0.0.0";
|
|
|
|
[Tooltip("Only used if supporting spectators.")]
|
|
public ushort spectatorPort = 27017;
|
|
|
|
[Header("Server Settings")]
|
|
[Tooltip("This will get set on logon and is how users will connect.")]
|
|
public CSteamID serverId;
|
|
|
|
[Tooltip("Should the system use the Game Server Authentication API.")]
|
|
public bool usingGameServerAuthApi;
|
|
|
|
[Tooltip("Heartbeats notify the master server of this servers details, if disabled your server will not list\nIf usingGameServerAuthApi is enabled heartbeats are always enabled..")]
|
|
public bool enableHeartbeats = true;
|
|
|
|
[Tooltip("If true the spectator port and server name will be used and configured on the server.")]
|
|
public bool supportSpectators;
|
|
|
|
[Tooltip("Only used if supporting spectators.")]
|
|
public string spectatorServerName = "Usually GameDescription + Spectator";
|
|
|
|
public bool anonymousServerLogin;
|
|
|
|
[Tooltip("See https://steamcommunity.com/dev/managegameservers \nOr\nUse Anonymous Server Login")]
|
|
public string gameServerToken = "See https://steamcommunity.com/dev/managegameservers";
|
|
|
|
public bool isPasswordProtected;
|
|
|
|
public string serverName = "My Server Name";
|
|
|
|
[Tooltip("It is recomended to set this to the full name of your game.")]
|
|
public string gameDescription = "Usually the name of your game";
|
|
|
|
[Tooltip("Typically the same as the game's name e.g. its folder name.")]
|
|
public string gameDirectory = "e.g. its folder name";
|
|
|
|
public bool isDedicated;
|
|
|
|
public int maxPlayerCount = 4;
|
|
|
|
public int botPlayerCount;
|
|
|
|
public string mapName = "";
|
|
|
|
[Tooltip("A delimited string used for Matchmaking Filtering e.g. CoolPeopleOnly,NoWagonsAllowed.\nThe above represents 2 data points matchmaking will then filter accordingly\n... see Heathen Game Server Browser for more informaiton.")]
|
|
public string gameData;
|
|
|
|
public List<StringKeyValuePair> rulePairs = new List<StringKeyValuePair>();
|
|
|
|
[Header("Events")]
|
|
public UnityEvent gameServerShuttingDown;
|
|
|
|
public DisconnectedEvent disconnected;
|
|
|
|
public ConnectedEvent connected;
|
|
|
|
public FailureEvent failure;
|
|
|
|
public Callback<SteamServerConnectFailure_t> steamServerConnectFailure;
|
|
|
|
public Callback<SteamServersConnected_t> steamServersConnected;
|
|
|
|
public Callback<SteamServersDisconnected_t> steamServersDisconnected;
|
|
|
|
public void OnSteamServersDisconnected(SteamServersDisconnected_t param)
|
|
{
|
|
if (current.isDebugging)
|
|
{
|
|
Debug.Log("Server disconnected!");
|
|
}
|
|
disconnected.Invoke(param);
|
|
}
|
|
|
|
public void OnSteamServersConnected(SteamServersConnected_t param)
|
|
{
|
|
if (current.isDebugging)
|
|
{
|
|
Debug.Log("Server connected!");
|
|
}
|
|
connected.Invoke(param);
|
|
}
|
|
|
|
public void OnSteamServerConnectFailure(SteamServerConnectFailure_t param)
|
|
{
|
|
if (current.isDebugging)
|
|
{
|
|
Debug.Log("Server failure!" + param.m_eResult);
|
|
}
|
|
failure.Invoke(param);
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class GameClient
|
|
{
|
|
[Serializable]
|
|
public class Overlay
|
|
{
|
|
public Vector2Int notificationInset;
|
|
|
|
public ENotificationPosition notificationPosition = ENotificationPosition.k_EPositionBottomRight;
|
|
|
|
private static bool _OverlayOpen;
|
|
|
|
public bool IsEnabled => SteamUtils.IsOverlayEnabled();
|
|
|
|
public bool IsOpen => _OverlayOpen;
|
|
|
|
public void HandleOnOverlayOpen(GameOverlayActivated_t data)
|
|
{
|
|
_OverlayOpen = data.m_bActive == 1;
|
|
}
|
|
|
|
public void Invite(CSteamID lobbyId)
|
|
{
|
|
SteamFriends.ActivateGameOverlayInviteDialog(lobbyId);
|
|
}
|
|
|
|
public void OpenStore()
|
|
{
|
|
OpenStore(SteamUtils.GetAppID(), EOverlayToStoreFlag.k_EOverlayToStoreFlag_None);
|
|
}
|
|
|
|
public void OpenStore(uint appId)
|
|
{
|
|
OpenStore(new AppId_t(appId), EOverlayToStoreFlag.k_EOverlayToStoreFlag_None);
|
|
}
|
|
|
|
public void OpenStore(uint appId, EOverlayToStoreFlag flag)
|
|
{
|
|
OpenStore(new AppId_t(appId), flag);
|
|
}
|
|
|
|
public void OpenStore(AppId_t appId, EOverlayToStoreFlag flag)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToStore(appId, flag);
|
|
}
|
|
|
|
public void Open(string dialog)
|
|
{
|
|
SteamFriends.ActivateGameOverlay(dialog);
|
|
}
|
|
|
|
public void OpenWebPage(string URL)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToWebPage(URL);
|
|
}
|
|
|
|
public void OpenFriends()
|
|
{
|
|
SteamFriends.ActivateGameOverlay("friends");
|
|
}
|
|
|
|
public void OpenCommunity()
|
|
{
|
|
SteamFriends.ActivateGameOverlay("community");
|
|
}
|
|
|
|
public void OpenPlayers()
|
|
{
|
|
SteamFriends.ActivateGameOverlay("players");
|
|
}
|
|
|
|
public void OpenSettings()
|
|
{
|
|
SteamFriends.ActivateGameOverlay("settings");
|
|
}
|
|
|
|
public void OpenOfficialGameGroup()
|
|
{
|
|
SteamFriends.ActivateGameOverlay("officialgamegroup");
|
|
}
|
|
|
|
public void OpenStats()
|
|
{
|
|
SteamFriends.ActivateGameOverlay("stats");
|
|
}
|
|
|
|
public void OpenAchievements()
|
|
{
|
|
SteamFriends.ActivateGameOverlay("achievements");
|
|
}
|
|
|
|
public void OpenChat(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("Chat", user);
|
|
}
|
|
|
|
public void OpenProfile(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("steamid", user);
|
|
}
|
|
|
|
public void OpenTrade(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("jointrade", user);
|
|
}
|
|
|
|
public void OpenStats(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("stats", user);
|
|
}
|
|
|
|
public void OpenAchievements(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("achievements", user);
|
|
}
|
|
|
|
public void OpenFriendAdd(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("friendadd", user);
|
|
}
|
|
|
|
public void OpenFriendRemove(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("friendremove", user);
|
|
}
|
|
|
|
public void OpenRequestAccept(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("friendrequestaccept", user);
|
|
}
|
|
|
|
public void OpenRequestIgnore(CSteamID user)
|
|
{
|
|
SteamFriends.ActivateGameOverlayToUser("friendrequestignore", user);
|
|
}
|
|
}
|
|
|
|
public SteamUserData user;
|
|
|
|
public Overlay overlay = new Overlay();
|
|
|
|
public int lastKnownPlayerCount;
|
|
|
|
public Dictionary<ulong, SteamUserData> knownUsers = new Dictionary<ulong, SteamUserData>();
|
|
|
|
public List<SteamStatData> stats = new List<SteamStatData>();
|
|
|
|
public List<SteamAchievementData> achievements = new List<SteamAchievementData>();
|
|
|
|
private CGameID m_GameID;
|
|
|
|
private Callback<AvatarImageLoaded_t> avatarLoadedCallback;
|
|
|
|
private Callback<PersonaStateChange_t> personaStateChange;
|
|
|
|
private Callback<UserStatsReceived_t> m_UserStatsReceived;
|
|
|
|
private Callback<UserStatsStored_t> m_UserStatsStored;
|
|
|
|
public Callback<GameOverlayActivated_t> m_GameOverlayActivated;
|
|
|
|
private Callback<UserAchievementStored_t> m_UserAchievementStored;
|
|
|
|
private Callback<GameConnectedFriendChatMsg_t> m_GameConnectedFrinedChatMsg;
|
|
|
|
private CallResult<NumberOfCurrentPlayers_t> m_OnNumberOfCurrentPlayersCallResult;
|
|
|
|
private CallResult<FriendsGetFollowerCount_t> m_FriendsGetFollowerCount;
|
|
|
|
private Dictionary<CSteamID, Action<SteamUserData, int>> FollowCallbacks = new Dictionary<CSteamID, Action<SteamUserData, int>>();
|
|
|
|
[HideInInspector]
|
|
public UnityAvatarImageLoadedEvent onAvatarLoaded;
|
|
|
|
[HideInInspector]
|
|
public UnityPersonaStateChangeEvent onPersonaStateChanged;
|
|
|
|
[HideInInspector]
|
|
public UnityUserStatsReceivedEvent onUserStatsReceived;
|
|
|
|
[HideInInspector]
|
|
public UnityUserStatsStoredEvent onUserStatsStored;
|
|
|
|
[HideInInspector]
|
|
public UnityBoolEvent onOverlayActivated;
|
|
|
|
[HideInInspector]
|
|
public UnityUserAchievementStoredEvent onAchievementStored;
|
|
|
|
[HideInInspector]
|
|
public FriendChatMessageEvent onRecievedFriendChatMessage;
|
|
|
|
[HideInInspector]
|
|
public UnityNumberOfCurrentPlayersResultEvent onNumberOfCurrentPlayersResult;
|
|
|
|
[Obsolete("Please use user as opposed to userData. This field will be removed in a future update.")]
|
|
public SteamUserData userData
|
|
{
|
|
get
|
|
{
|
|
return user;
|
|
}
|
|
set
|
|
{
|
|
user = value;
|
|
}
|
|
}
|
|
|
|
public void StoreStatsAndAchievements()
|
|
{
|
|
SteamUserStats.StoreStats();
|
|
}
|
|
|
|
public void RegisterAchievementsSystem()
|
|
{
|
|
m_GameID = new CGameID(SteamUtils.GetAppID());
|
|
m_UserStatsReceived = Callback<UserStatsReceived_t>.Create(HandleUserStatsReceived);
|
|
m_UserStatsStored = Callback<UserStatsStored_t>.Create(HandleUserStatsStored);
|
|
m_UserAchievementStored = Callback<UserAchievementStored_t>.Create(HandleAchievementStored);
|
|
m_FriendsGetFollowerCount = CallResult<FriendsGetFollowerCount_t>.Create(HandleGetFollowerCount);
|
|
m_OnNumberOfCurrentPlayersCallResult = CallResult<NumberOfCurrentPlayers_t>.Create(OnNumberOfCurrentPlayers);
|
|
}
|
|
|
|
public bool RequestCurrentStats()
|
|
{
|
|
SteamAPICall_t numberOfCurrentPlayers = SteamUserStats.GetNumberOfCurrentPlayers();
|
|
m_OnNumberOfCurrentPlayersCallResult.Set(numberOfCurrentPlayers);
|
|
return SteamUserStats.RequestCurrentStats();
|
|
}
|
|
|
|
public void RefreshPlayerCount()
|
|
{
|
|
SteamAPICall_t numberOfCurrentPlayers = SteamUserStats.GetNumberOfCurrentPlayers();
|
|
m_OnNumberOfCurrentPlayersCallResult.Set(numberOfCurrentPlayers);
|
|
}
|
|
|
|
private void OnNumberOfCurrentPlayers(NumberOfCurrentPlayers_t pCallback, bool bIOFailure)
|
|
{
|
|
if (!bIOFailure)
|
|
{
|
|
if (pCallback.m_bSuccess == 1)
|
|
{
|
|
lastKnownPlayerCount = pCallback.m_cPlayers;
|
|
}
|
|
if (onNumberOfCurrentPlayersResult != null)
|
|
{
|
|
onNumberOfCurrentPlayersResult.Invoke(pCallback);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandleUserStatsReceived(UserStatsReceived_t pCallback)
|
|
{
|
|
if ((ulong)m_GameID != pCallback.m_nGameID)
|
|
{
|
|
return;
|
|
}
|
|
if (EResult.k_EResultOK == pCallback.m_eResult)
|
|
{
|
|
foreach (SteamAchievementData achievement in achievements)
|
|
{
|
|
if (SteamUserStats.GetAchievement(achievement.achievementId.ToString(), out achievement.isAchieved))
|
|
{
|
|
achievement.displayName = SteamUserStats.GetAchievementDisplayAttribute(achievement.achievementId, "name");
|
|
achievement.displayDescription = SteamUserStats.GetAchievementDisplayAttribute(achievement.achievementId, "desc");
|
|
achievement.hidden = SteamUserStats.GetAchievementDisplayAttribute(achievement.achievementId, "hidden") == "1";
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("SteamUserStats.GetAchievement failed for Achievement " + achievement.achievementId + "\nIs it registered in the Steam Partner site?");
|
|
}
|
|
}
|
|
foreach (SteamStatData stat in stats)
|
|
{
|
|
int pData2;
|
|
if (stat.DataType == SteamStatData.StatDataType.Float)
|
|
{
|
|
if (SteamUserStats.GetStat(stat.statName, out float pData))
|
|
{
|
|
stat.InternalUpdateValue(pData);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("SteamUserStats.GetAchievement failed for Stat " + stat.statName + "\nIs it registered in the Steam Partner site and the correct data type?");
|
|
}
|
|
}
|
|
else if (SteamUserStats.GetStat(stat.statName, out pData2))
|
|
{
|
|
stat.InternalUpdateValue(pData2);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("SteamUserStats.GetAchievement failed for Stat " + stat.statName + "\nIs it registered in the Steam Partner site and the correct data type?");
|
|
}
|
|
}
|
|
onUserStatsReceived.Invoke(pCallback);
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("RequestStats - failed, " + pCallback.m_eResult);
|
|
}
|
|
}
|
|
|
|
private void HandleUserStatsStored(UserStatsStored_t pCallback)
|
|
{
|
|
if ((ulong)m_GameID == pCallback.m_nGameID)
|
|
{
|
|
if (EResult.k_EResultOK == pCallback.m_eResult)
|
|
{
|
|
onUserStatsStored.Invoke(pCallback);
|
|
}
|
|
else if (EResult.k_EResultInvalidParam == pCallback.m_eResult)
|
|
{
|
|
Debug.Log("StoreStats - some failed to validate, re-syncing data now in an attempt to correct.");
|
|
HandleUserStatsReceived(new UserStatsReceived_t
|
|
{
|
|
m_eResult = EResult.k_EResultOK,
|
|
m_nGameID = (ulong)m_GameID
|
|
});
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("StoreStats - failed, " + pCallback.m_eResult);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandleAchievementStored(UserAchievementStored_t pCallback)
|
|
{
|
|
if ((ulong)m_GameID == pCallback.m_nGameID)
|
|
{
|
|
if (pCallback.m_nMaxProgress == 0)
|
|
{
|
|
Debug.Log("Achievement '" + pCallback.m_rgchAchievementName + "' unlocked!");
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("Achievement '" + pCallback.m_rgchAchievementName + "' progress callback, (" + pCallback.m_nCurProgress + "," + pCallback.m_nMaxProgress + ")");
|
|
}
|
|
onAchievementStored.Invoke(pCallback);
|
|
}
|
|
}
|
|
|
|
private void HandleGetFollowerCount(FriendsGetFollowerCount_t param, bool bIOFailure)
|
|
{
|
|
if (FollowCallbacks.ContainsKey(param.m_steamID))
|
|
{
|
|
Action<SteamUserData, int> action = FollowCallbacks[param.m_steamID];
|
|
if (param.m_eResult != EResult.k_EResultOK || bIOFailure)
|
|
{
|
|
action?.Invoke(GetUserData(param.m_steamID), -1);
|
|
FollowCallbacks.Remove(param.m_steamID);
|
|
}
|
|
else
|
|
{
|
|
action?.Invoke(GetUserData(param.m_steamID), param.m_nCount);
|
|
FollowCallbacks.Remove(param.m_steamID);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UnlockAchievement(uint achievementIndex)
|
|
{
|
|
SteamAchievementData steamAchievementData = achievements[Convert.ToInt32(achievementIndex)];
|
|
if (steamAchievementData != null && !steamAchievementData.isAchieved)
|
|
{
|
|
UnlockAchievementData(steamAchievementData);
|
|
}
|
|
}
|
|
|
|
public void UnlockAchievementData(SteamAchievementData data)
|
|
{
|
|
data.Unlock();
|
|
}
|
|
|
|
public void ClearAchievement(uint achievementIndex)
|
|
{
|
|
SteamAchievementData steamAchievementData = achievements[Convert.ToInt32(achievementIndex)];
|
|
if (steamAchievementData != null && !steamAchievementData.isAchieved)
|
|
{
|
|
ClearAchievement(steamAchievementData);
|
|
}
|
|
}
|
|
|
|
public void ClearAchievement(SteamAchievementData data)
|
|
{
|
|
data.ClearAchievement();
|
|
}
|
|
|
|
public void HandleOnOverlayOpen(GameOverlayActivated_t data)
|
|
{
|
|
overlay.HandleOnOverlayOpen(data);
|
|
onOverlayActivated.Invoke(overlay.IsOpen);
|
|
}
|
|
|
|
public void SetNotificationPosition(ENotificationPosition position)
|
|
{
|
|
SteamUtils.SetOverlayNotificationPosition(overlay.notificationPosition);
|
|
overlay.notificationPosition = position;
|
|
}
|
|
|
|
public void SetNotificationInset(int X, int Y)
|
|
{
|
|
SteamUtils.SetOverlayNotificationInset(X, Y);
|
|
overlay.notificationInset = new Vector2Int(X, Y);
|
|
}
|
|
|
|
public void SetNotificationInset(Vector2Int inset)
|
|
{
|
|
SteamUtils.SetOverlayNotificationInset(inset.x, inset.y);
|
|
overlay.notificationInset = inset;
|
|
}
|
|
|
|
public List<SteamUserData> ListFriends(EFriendFlags friendFlags = EFriendFlags.k_EFriendFlagImmediate)
|
|
{
|
|
List<SteamUserData> list = new List<SteamUserData>();
|
|
int friendCount = SteamFriends.GetFriendCount(friendFlags);
|
|
for (int i = 0; i < friendCount; i++)
|
|
{
|
|
list.Add(GetUserData(SteamFriends.GetFriendByIndex(i, friendFlags)));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public List<SteamClan> ListClans()
|
|
{
|
|
List<SteamClan> list = new List<SteamClan>();
|
|
int clanCount = SteamFriends.GetClanCount();
|
|
for (int i = 0; i < clanCount; i++)
|
|
{
|
|
list.Add(new SteamClan(SteamFriends.GetClanByIndex(i)));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public void GetFollowerCount(CSteamID followingThisUser, Action<SteamUserData, int> callback)
|
|
{
|
|
FollowCallbacks.Add(followingThisUser, callback);
|
|
SteamFriends.GetFollowerCount(followingThisUser);
|
|
}
|
|
|
|
public bool SetRichPresence(string key, string value)
|
|
{
|
|
return SteamFriends.SetRichPresence(key, value);
|
|
}
|
|
|
|
public void ClearRichPresence()
|
|
{
|
|
SteamFriends.ClearRichPresence();
|
|
}
|
|
|
|
public void RegisterFriendsSystem(SteamUserData data = null)
|
|
{
|
|
avatarLoadedCallback = Callback<AvatarImageLoaded_t>.Create(HandleAvatarLoaded);
|
|
personaStateChange = Callback<PersonaStateChange_t>.Create(HandlePersonaStatReceived);
|
|
m_GameConnectedFrinedChatMsg = Callback<GameConnectedFriendChatMsg_t>.Create(HandleGameConnectedFriendMsg);
|
|
if (onRecievedFriendChatMessage == null)
|
|
{
|
|
onRecievedFriendChatMessage = new FriendChatMessageEvent();
|
|
}
|
|
if (onAvatarLoaded == null)
|
|
{
|
|
onAvatarLoaded = new UnityAvatarImageLoadedEvent();
|
|
}
|
|
if (onPersonaStateChanged == null)
|
|
{
|
|
onPersonaStateChanged = new UnityPersonaStateChangeEvent();
|
|
}
|
|
if (data != null)
|
|
{
|
|
user = data;
|
|
}
|
|
if (user == null)
|
|
{
|
|
user = ScriptableObject.CreateInstance<SteamUserData>();
|
|
}
|
|
user.id = SteamUser.GetSteamID();
|
|
knownUsers.Clear();
|
|
knownUsers.Add(user.id.m_SteamID, user);
|
|
int largeFriendAvatar = SteamFriends.GetLargeFriendAvatar(user.id);
|
|
if (largeFriendAvatar > 0)
|
|
{
|
|
ApplyAvatarImage(user, largeFriendAvatar);
|
|
}
|
|
}
|
|
|
|
private void HandleAvatarLoaded(AvatarImageLoaded_t data)
|
|
{
|
|
if (knownUsers.ContainsKey(data.m_steamID.m_SteamID))
|
|
{
|
|
SteamUserData steamUserData = knownUsers[data.m_steamID.m_SteamID];
|
|
ApplyAvatarImage(steamUserData, data.m_iImage);
|
|
if (steamUserData.OnAvatarLoaded == null)
|
|
{
|
|
steamUserData.OnAvatarLoaded = new UnityEvent();
|
|
}
|
|
steamUserData.OnAvatarLoaded.Invoke();
|
|
}
|
|
else
|
|
{
|
|
SteamUserData steamUserData2 = ScriptableObject.CreateInstance<SteamUserData>();
|
|
steamUserData2.id = data.m_steamID;
|
|
knownUsers.Add(steamUserData2.id.m_SteamID, steamUserData2);
|
|
ApplyAvatarImage(steamUserData2, data.m_iImage);
|
|
steamUserData2.OnAvatarLoaded.Invoke();
|
|
}
|
|
onAvatarLoaded.Invoke(data);
|
|
}
|
|
|
|
private void HandleGameConnectedFriendMsg(GameConnectedFriendChatMsg_t callback)
|
|
{
|
|
SteamFriends.GetFriendMessage(callback.m_steamIDUser, callback.m_iMessageID, out var pvData, 2048, out var peChatEntryType);
|
|
onRecievedFriendChatMessage.Invoke(GetUserData(callback.m_steamIDUser), pvData, peChatEntryType);
|
|
}
|
|
|
|
private void HandlePersonaStatReceived(PersonaStateChange_t pCallback)
|
|
{
|
|
SteamUserData steamUserData = null;
|
|
if (knownUsers.ContainsKey(pCallback.m_ulSteamID))
|
|
{
|
|
steamUserData = knownUsers[pCallback.m_ulSteamID];
|
|
}
|
|
else
|
|
{
|
|
steamUserData = ScriptableObject.CreateInstance<SteamUserData>();
|
|
steamUserData.id = new CSteamID(pCallback.m_ulSteamID);
|
|
knownUsers.Add(steamUserData.id.m_SteamID, steamUserData);
|
|
}
|
|
switch (pCallback.m_nChangeFlags)
|
|
{
|
|
case EPersonaChange.k_EPersonaChangeAvatar:
|
|
try
|
|
{
|
|
int largeFriendAvatar = SteamFriends.GetLargeFriendAvatar(steamUserData.id);
|
|
if (largeFriendAvatar > 0)
|
|
{
|
|
steamUserData.iconLoaded = true;
|
|
SteamUtils.GetImageSize(largeFriendAvatar, out var pnWidth, out var pnHeight);
|
|
byte[] array = new byte[4 * pnWidth * pnHeight];
|
|
if (SteamUtils.GetImageRGBA(largeFriendAvatar, array, array.Length))
|
|
{
|
|
steamUserData.avatar.LoadRawTextureData(SteamUtilities.FlipImageBufferVertical((int)pnWidth, (int)pnHeight, array));
|
|
steamUserData.avatar.Apply();
|
|
steamUserData.OnAvatarChanged.Invoke();
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
break;
|
|
case EPersonaChange.k_EPersonaChangeComeOnline:
|
|
if (steamUserData.OnComeOnline != null)
|
|
{
|
|
steamUserData.OnComeOnline.Invoke();
|
|
}
|
|
if (steamUserData.OnStateChange != null)
|
|
{
|
|
steamUserData.OnStateChange.Invoke();
|
|
}
|
|
break;
|
|
case EPersonaChange.k_EPersonaChangeGamePlayed:
|
|
if (steamUserData.OnGameChanged != null)
|
|
{
|
|
steamUserData.OnGameChanged.Invoke();
|
|
}
|
|
if (steamUserData.OnStateChange != null)
|
|
{
|
|
steamUserData.OnStateChange.Invoke();
|
|
}
|
|
break;
|
|
case EPersonaChange.k_EPersonaChangeGoneOffline:
|
|
if (steamUserData.OnGoneOffline != null)
|
|
{
|
|
steamUserData.OnGoneOffline.Invoke();
|
|
}
|
|
if (steamUserData.OnStateChange != null)
|
|
{
|
|
steamUserData.OnStateChange.Invoke();
|
|
}
|
|
break;
|
|
case EPersonaChange.k_EPersonaChangeName:
|
|
if (steamUserData.OnNameChanged != null)
|
|
{
|
|
steamUserData.OnNameChanged.Invoke();
|
|
}
|
|
break;
|
|
}
|
|
onPersonaStateChanged.Invoke(pCallback);
|
|
}
|
|
|
|
private void ApplyAvatarImage(SteamUserData user, int imageId)
|
|
{
|
|
SteamUtils.GetImageSize(imageId, out var pnWidth, out var pnHeight);
|
|
user.avatar = new Texture2D((int)pnWidth, (int)pnHeight, TextureFormat.RGBA32, mipChain: false);
|
|
int num = (int)(pnWidth * pnHeight * 4);
|
|
byte[] array = new byte[num];
|
|
SteamUtils.GetImageRGBA(imageId, array, num);
|
|
user.avatar.LoadRawTextureData(SteamUtilities.FlipImageBufferVertical((int)pnWidth, (int)pnHeight, array));
|
|
user.avatar.Apply();
|
|
user.iconLoaded = true;
|
|
}
|
|
|
|
public bool ListenForFriendMessages(bool isOn)
|
|
{
|
|
return SteamFriends.SetListenForFriendsMessages(isOn);
|
|
}
|
|
|
|
public bool SendFriendChatMessage(SteamUserData friend, string message)
|
|
{
|
|
return friend.SendMessage(message);
|
|
}
|
|
|
|
public bool SendFriendChatMessage(ulong friendId, string message)
|
|
{
|
|
return SendFriendChatMessage(new CSteamID(friendId), message);
|
|
}
|
|
|
|
public bool SendFriendChatMessage(CSteamID friend, string message)
|
|
{
|
|
return SteamFriends.ReplyToFriendMessage(friend, message);
|
|
}
|
|
|
|
public void RefreshAvatar(SteamUserData userData)
|
|
{
|
|
int largeFriendAvatar = SteamFriends.GetLargeFriendAvatar(userData.id);
|
|
if (largeFriendAvatar > 0)
|
|
{
|
|
ApplyAvatarImage(userData, largeFriendAvatar);
|
|
}
|
|
}
|
|
|
|
public SteamUserData GetUserData(CSteamID steamID)
|
|
{
|
|
if (knownUsers.ContainsKey(steamID.m_SteamID))
|
|
{
|
|
SteamUserData result = knownUsers[steamID.m_SteamID];
|
|
int largeFriendAvatar = SteamFriends.GetLargeFriendAvatar(steamID);
|
|
if (largeFriendAvatar > 0)
|
|
{
|
|
ApplyAvatarImage(result, largeFriendAvatar);
|
|
}
|
|
return result;
|
|
}
|
|
SteamUserData steamUserData = ScriptableObject.CreateInstance<SteamUserData>();
|
|
steamUserData.id = steamID;
|
|
knownUsers.Add(steamID.m_SteamID, steamUserData);
|
|
int largeFriendAvatar2 = SteamFriends.GetLargeFriendAvatar(steamID);
|
|
if (largeFriendAvatar2 > 0)
|
|
{
|
|
ApplyAvatarImage(steamUserData, largeFriendAvatar2);
|
|
}
|
|
return steamUserData;
|
|
}
|
|
|
|
public SteamUserData GetUserData(ulong steamID)
|
|
{
|
|
return GetUserData(new CSteamID(steamID));
|
|
}
|
|
}
|
|
|
|
public static SteamSettings current;
|
|
|
|
[FormerlySerializedAs("ApplicationId")]
|
|
public AppId_t applicationId = new AppId_t(0u);
|
|
|
|
public bool isDebugging;
|
|
|
|
public GameServer server = new GameServer();
|
|
|
|
public GameClient client = new GameClient();
|
|
|
|
public bool Initialized { get; private set; }
|
|
|
|
[Obsolete("Use SteamSettings.client.overlay.notificationPosition", false)]
|
|
public ENotificationPosition NotificationPosition => client.overlay.notificationPosition;
|
|
|
|
[Obsolete("UserData is deprecated and will be removed in a later update, use SteamSettings.client.userData in its place", false)]
|
|
public SteamUserData UserData => client.userData;
|
|
|
|
[Obsolete("LastKnownPlayerCount is deprecated and will be removed in a later update, use SteamSettings.client.lastKnownPlayerCount in its place", false)]
|
|
public int LastKnownPlayerCount => client.lastKnownPlayerCount;
|
|
|
|
[Obsolete("Overlay is deprecated and will be removed in a later update, use SteamSettings.client.overlay in its place", false)]
|
|
public GameClient.Overlay Overlay => client.overlay;
|
|
|
|
[Obsolete("Use SteamSettings.client.knownUsers", false)]
|
|
public Dictionary<ulong, SteamUserData> KnownUsers => client.knownUsers;
|
|
|
|
[Obsolete("Use SteamSettings.client.onAvatarLoaded", false)]
|
|
public UnityAvatarImageLoadedEvent OnAvatarLoaded => client.onAvatarLoaded;
|
|
|
|
[Obsolete("Use SteamSettings.client.onPersonaStateChanged", false)]
|
|
public UnityPersonaStateChangeEvent OnPersonaStateChanged => client.onPersonaStateChanged;
|
|
|
|
[Obsolete("Use SteamSettings.client.onUserStatsReceived", false)]
|
|
public UnityUserStatsReceivedEvent OnUserStatsReceived => client.onUserStatsReceived;
|
|
|
|
[Obsolete("Use SteamSettings.client.onUserStatsStored", false)]
|
|
public UnityUserStatsStoredEvent OnUserStatsStored => client.onUserStatsStored;
|
|
|
|
[Obsolete("Use SteamSettings.client.onOverlayActivated", false)]
|
|
public UnityBoolEvent OnOverlayActivated => client.onOverlayActivated;
|
|
|
|
[Obsolete("Use SteamSettings.client.onAchievementStored", false)]
|
|
public UnityUserAchievementStoredEvent OnAchievementStored => client.onAchievementStored;
|
|
|
|
[Obsolete("Use SteamSettings.client.onRecievedFriendChatMessage", false)]
|
|
public FriendChatMessageEvent OnRecievedFriendChatMessage => client.onRecievedFriendChatMessage;
|
|
|
|
[Obsolete("Use SteamSettings.client.onNumberOfCurrentPlayersResult", false)]
|
|
public UnityNumberOfCurrentPlayersResultEvent OnNumberOfCurrentPlayersResult => client.onNumberOfCurrentPlayersResult;
|
|
|
|
public void Init()
|
|
{
|
|
current = this;
|
|
Initialized = SteamAPI.Init();
|
|
}
|
|
}
|
|
}
|