private void OnServiceMethod(SteamUnifiedMessages.ServiceMethodResponse callback)
{
JobAction job;
if (!JobManager.TryRemoveJob(callback.JobID, out job) || !job.IsCommand)
{
return;
}
var request = job.CommandRequest;
if (callback.Result != EResult.OK)
{
CommandHandler.ReplyToCommand(request.Command, "Unable to make service request: {0}", callback.Result);
return;
}
// .chat about grate
switch (request.Type)
{
case JobManager.IRCRequestType.TYPE_GAMESERVERS:
ServersCommand.OnServiceMethod(callback, request);
return;
case JobManager.IRCRequestType.TYPE_PUBFILE:
case JobManager.IRCRequestType.TYPE_PUBFILE_SILENT:
PubFileCommand.OnServiceMethod(callback, request);
return;
}
CommandHandler.ReplyToCommand(request.Command, "Unknown request type, I don't know what to do.");
}
public static void OnServiceMethod(SteamUnifiedMessages.ServiceMethodResponse callback, JobManager.IRCRequest request)
{
var response = callback.GetDeserializedResponse<CGameServers_GetServerList_Response>();
var servers = response.servers;
if (!servers.Any())
{
CommandHandler.ReplyToCommand(request.Command, "No servers.");
return;
}
if (servers.Count == 1)
{
var server = servers.First();
CommandHandler.ReplyToCommand(request.Command, "{0} - {1} - {2}/{3} - Map: {4} - AppID: {5} - Version: {6} - Dir: {7} - Tags: {8} - Name: {9}",
server.addr, new SteamID(server.steamid).Render(true), server.players, server.max_players, server.map, server.appid, server.version, server.gamedir, server.gametype, server.name
);
return;
}
var serv = servers.Take(5).Select(x => string.Format("{0} ({1})", x.addr, x.players));
CommandHandler.ReplyToCommand(request.Command, "{0}{1}", string.Join(", ", serv), servers.Count > 5 ? string.Format(", and {0}{1} more", servers.Count == 5000 ? ">" : "", servers.Count - 5) : "");
}
public async Task <bool> LoginPrompt(bool background = false, string username = null, string password = null, string authCode = null, string emailCode = null)
{
UserConfig.RegisterConfig("steam");
this.background = background;
this.username = username;
this.password = password;
this.authCode = authCode;
this.emailCode = emailCode;
client = new SteamClient();
manager = new CallbackManager(client);
user = client.GetHandler <SteamUser>();
friends = client.GetHandler <SteamFriends>();
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKey);
//manager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendList);
manager.Subscribe <SteamUnifiedMessages.ServiceMethodResponse>(OnMethodResponse);
unifiedMessages = client.GetHandler <SteamUnifiedMessages>();
servicePlayer = unifiedMessages.CreateService <IPlayer>();
loginStatus = LOGIN_STATUS.AWAITING;
Debug.WriteLine("Connecting to steam..");
client.Connect();
cancelCallbackTok = new CancellationTokenSource();
Task callbackTask = new Task(() =>
{
while (!cancelCallbackTok.IsCancellationRequested)
{
try
{
manager.RunCallbacks();
}
catch (Exception e) {
Console.WriteLine("Error! : " + e.Message);
}
}
}, cancelCallbackTok.Token);
callbackTask.Start();
return(await Task <bool> .Run(() =>
{
while (loginStatus == LOGIN_STATUS.AWAITING)
{
}
return loginStatus == LOGIN_STATUS.SUCCESS;
}));
}
static void Main( string[] args )
{
if ( args.Length < 2 )
{
Console.WriteLine( "Sample8: No username and password specified!" );
return;
}
// save our logon details
user = args[0];
pass = args[1];
// create our steamclient instance
steamClient = new SteamClient();
// create the callback manager which will route callbacks to function calls
manager = new CallbackManager( steamClient );
// get the steamuser handler, which is used for logging on after successfully connecting
steamUser = steamClient.GetHandler<SteamUser>();
// get the steam unified messages handler, which is used for sending and receiving responses from the unified service api
steamUnifiedMessages = steamClient.GetHandler<SteamUnifiedMessages>();
// we also want to create our local service interface, which will help us build requests to the unified api
playerService = steamUnifiedMessages.CreateService<IPlayer>();
// register a few callbacks we're interested in
// these are registered upon creation to a callback manager, which will then route the callbacks
// to the functions specified
manager.Subscribe<SteamClient.ConnectedCallback>( OnConnected );
manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected );
manager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn );
manager.Subscribe<SteamUser.LoggedOffCallback>( OnLoggedOff );
// we use the following callbacks for unified service responses
manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>( OnMethodResponse );
isRunning = true;
Console.WriteLine( "Connecting to Steam..." );
// initiate the connection
steamClient.Connect();
// create our callback handling loop
while ( isRunning )
{
// in order for the callbacks to get routed, they need to be handled by the manager
manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) );
}
}
internal ArchiHandler(ArchiLogger archiLogger, SteamUnifiedMessages steamUnifiedMessages)
{
ArgumentNullException.ThrowIfNull(steamUnifiedMessages);
ArchiLogger = archiLogger ?? throw new ArgumentNullException(nameof(archiLogger));
UnifiedChatRoomService = steamUnifiedMessages.CreateService <IChatRoom>();
UnifiedClanChatRoomsService = steamUnifiedMessages.CreateService <IClanChatRooms>();
UnifiedEconService = steamUnifiedMessages.CreateService <IEcon>();
UnifiedFriendMessagesService = steamUnifiedMessages.CreateService <IFriendMessages>();
UnifiedPlayerService = steamUnifiedMessages.CreateService <IPlayer>();
UnifiedTwoFactorService = steamUnifiedMessages.CreateService <ITwoFactor>();
}
static void Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Sample8: No username and password specified!");
return;
}
// save our logon details
user = args[0];
pass = args[1];
// create our steamclient instance
steamClient = new SteamClient();
// create the callback manager which will route callbacks to function calls
manager = new CallbackManager(steamClient);
// get the steamuser handler, which is used for logging on after successfully connecting
steamUser = steamClient.GetHandler <SteamUser>();
// get the steam unified messages handler, which is used for sending and receiving responses from the unified service api
steamUnifiedMessages = steamClient.GetHandler <SteamUnifiedMessages>();
// we also want to create our local service interface, which will help us build requests to the unified api
playerService = steamUnifiedMessages.CreateService <IPlayer>();
// register a few callbacks we're interested in
// these are registered upon creation to a callback manager, which will then route the callbacks
// to the functions specified
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
// we use the following callbacks for unified service responses
manager.Subscribe <SteamUnifiedMessages.ServiceMethodResponse>(OnMethodResponse);
isRunning = true;
Console.WriteLine("Connecting to Steam...");
// initiate the connection
steamClient.Connect();
// create our callback handling loop
while (isRunning)
{
// in order for the callbacks to get routed, they need to be handled by the manager
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}
internal ArchiHandler(ArchiLogger archiLogger, SteamUnifiedMessages steamUnifiedMessages)
{
if ((archiLogger == null) || (steamUnifiedMessages == null))
{
throw new ArgumentNullException(nameof(archiLogger) + " || " + nameof(steamUnifiedMessages));
}
ArchiLogger = archiLogger;
UnifiedChatRoomService = steamUnifiedMessages.CreateService <IChatRoom>();
UnifiedClanChatRoomsService = steamUnifiedMessages.CreateService <IClanChatRooms>();
UnifiedFriendMessagesService = steamUnifiedMessages.CreateService <IFriendMessages>();
UnifiedPlayerService = steamUnifiedMessages.CreateService <IPlayer>();
}
internal SCHandler([NotNull] Logger logger, [NotNull] SteamUnifiedMessages steamUnifiedMessages)
{
if (logger == null || steamUnifiedMessages == null)
{
throw new ArgumentNullException(nameof(logger) + " || " + nameof(steamUnifiedMessages));
}
Logger = logger;
UnifiedChatRoomService = steamUnifiedMessages.CreateService <IChatRoom>();
UnifiedClanChatRoomsService = steamUnifiedMessages.CreateService <IClanChatRooms>();
UnifiedEconService = steamUnifiedMessages.CreateService <IEcon>();
UnifiedFriendMessagesService = steamUnifiedMessages.CreateService <IFriendMessages>();
UnifiedPlayerService = steamUnifiedMessages.CreateService <IPlayer>();
}
public override void Init()
{
steam_friends = Instance.SteamClient.GetHandler <SteamFriends>();
unified_messages = Instance.SteamClient.GetHandler <SteamUnifiedMessages>();
Instance.CallbackManager.Subscribe <SteamFriends.ChatMsgCallback>(cb => OnChatMessage(cb));
Instance.CallbackManager.Subscribe <SteamFriends.ChatEnterCallback>(cb => OnChatEnter(cb));
Instance.CallbackManager.Subscribe <SteamFriends.PersonaStateCallback>(cb => OnPersonaState(cb));
Instance.CallbackManager.Subscribe <SteamFriends.FriendMsgCallback>(cb => OnFriendMessage(cb));
Instance.CallbackManager.Subscribe <SteamFriends.ClanStateCallback>(cb => OnClanState(cb));
Instance.CallbackManager.Subscribe <SteamUnifiedMessages.ServiceMethodNotification>(cb => OnServiceMethod(cb));
Instance.CallbackManager.Subscribe <SteamUnifiedMessages.ServiceMethodResponse>(cb => OnServiceMethodResponse(cb));
Instance.PacketHandler.Subscribe <CMsgClientFriendsGroupsList>(EMsg.ClientFriendsGroupsList, cb => OnClientFriendsGroupsList(cb));
}
public void RenderOnGUI()
{
GUILayout.BeginArea(new Rect(Screen.width - 200, 0, 200, Screen.height));
GUILayout.Label("Variables:");
GUILayout.Label("m_ClientUnifiedMessageHandle: " + m_ClientUnifiedMessageHandle);
GUILayout.EndArea();
GUILayout.BeginVertical("box");
m_ScrollPos = GUILayout.BeginScrollView(m_ScrollPos, GUILayout.Width(Screen.width - 215), GUILayout.Height(Screen.height - 33));
// TODO: I don't know what I'm doing. This whole interface has essentially Zero Documentation.
if (GUILayout.Button("SendMethod(\"Player.GetGameBadgeLevels#1\", null, 0, 1111)"))
{
ClientUnifiedMessageHandle ret = SteamUnifiedMessages.SendMethod("Player.GetGameBadgeLevels#1", null, 0, 1111);
m_ClientUnifiedMessageHandle = ret;
print("SteamUnifiedMessages.SendMethod(" + "\"Player.GetGameBadgeLevels#1\"" + ", " + null + ", " + 0 + ", " + 1111 + ") : " + ret);
}
if (GUILayout.Button("GetMethodResponseInfo(m_ClientUnifiedMessageHandle, out ResponseSize, out Result)"))
{
uint ResponseSize;
EResult Result;
bool ret = SteamUnifiedMessages.GetMethodResponseInfo(m_ClientUnifiedMessageHandle, out ResponseSize, out Result);
print("SteamUnifiedMessages.GetMethodResponseInfo(" + m_ClientUnifiedMessageHandle + ", " + "out ResponseSize" + ", " + "out Result" + ") : " + ret + " -- " + ResponseSize + " -- " + Result);
}
if (GUILayout.Button("GetMethodResponseData(m_ClientUnifiedMessageHandle, new byte[1], 1, true)"))
{
bool ret = SteamUnifiedMessages.GetMethodResponseData(m_ClientUnifiedMessageHandle, new byte[1], 1, true);
print("SteamUnifiedMessages.GetMethodResponseData(" + m_ClientUnifiedMessageHandle + ", " + new byte[1] + ", " + 1 + ", " + true + ") : " + ret);
}
if (GUILayout.Button("ReleaseMethod(m_ClientUnifiedMessageHandle)"))
{
bool ret = SteamUnifiedMessages.ReleaseMethod(m_ClientUnifiedMessageHandle);
print("SteamUnifiedMessages.ReleaseMethod(" + m_ClientUnifiedMessageHandle + ") : " + ret);
}
if (GUILayout.Button("SendNotification(\"MsgTest.NotifyServer#1\", null, 0)"))
{
bool ret = SteamUnifiedMessages.SendNotification("MsgTest.NotifyServer#1", null, 0);
print("SteamUnifiedMessages.SendNotification(" + "\"MsgTest.NotifyServer#1\"" + ", " + null + ", " + 0 + ") : " + ret);
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
static void SteamLogin()
{
steamClient = new SteamClient();
#region callbacks
manager = new CallbackManager(steamClient);
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback); // If steam guard auth succeeded
manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage);
manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded);
manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList);
manager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage);
#endregion
#region Handlers
steamUser = steamClient.GetHandler <SteamUser>();
steamFriends = steamClient.GetHandler <SteamFriends>();
steamCloud = steamClient.GetHandler <SteamCloud>();
steamGameServer = steamClient.GetHandler <SteamGameServer>();
steamMasterServer = steamClient.GetHandler <SteamMasterServer>();
steamGameCoordinator = steamClient.GetHandler <SteamGameCoordinator>();
steamScreenshots = steamClient.GetHandler <SteamScreenshots>();
steamTrading = steamClient.GetHandler <SteamTrading>();
steamUFM = steamClient.GetHandler <SteamUnifiedMessages>();
steamUserStats = steamClient.GetHandler <SteamUserStats>();
steamWorkShop = steamClient.GetHandler <SteamWorkshop>();
#endregion
isRunning = true;
Console.Title = "Steam Bot - Connecting...";
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
Console.ReadKey();
}
public void RenderOnGUI()
{
GUILayout.BeginArea(new Rect(Screen.width - 120, 0, 120, Screen.height));
GUILayout.Label("Variables:");
GUILayout.Label("m_ClientUnifiedMessageHandle: " + m_ClientUnifiedMessageHandle);
GUILayout.EndArea();
// TODO: I don't know what I'm doing. This whole interface has essentially Zero Documentation.
if (GUILayout.Button("SendMethod(\"CMsgTest_MessageToServer_Request\", null, 0, 1111)"))
{
m_ClientUnifiedMessageHandle = SteamUnifiedMessages.SendMethod("Player.GetGameBadgeLevels#1", null, 0, 1111);
print("SteamUnifiedMessages.SendMethod(\"CMsgTest_MessageToServer_Request\", null, 0, 1111) : " + m_ClientUnifiedMessageHandle);
}
if (GUILayout.Button("GetMethodResponseInfo(m_ClientUnifiedMessageHandle, out ResponseSize, out Result)"))
{
uint ResponseSize;
EResult Result;
bool ret = SteamUnifiedMessages.GetMethodResponseInfo(m_ClientUnifiedMessageHandle, out ResponseSize, out Result);
print("SteamUnifiedMessages.GetMethodResponseInfo(" + m_ClientUnifiedMessageHandle + ", out ResponseSize, out Result) : " + ret + " -- " + ResponseSize + " -- " + Result);
}
if (GUILayout.Button("GetMethodResponseData(m_ClientUnifiedMessageHandle, new byte[1], 1, true)"))
{
bool ret = SteamUnifiedMessages.GetMethodResponseData(m_ClientUnifiedMessageHandle, new byte[1], 1, true);
print("SteamUnifiedMessages.GetMethodResponseData(" + m_ClientUnifiedMessageHandle + ", new byte[1], 1, true) : " + ret);
}
if (GUILayout.Button("ReleaseMethod(m_ClientUnifiedMessageHandle)"))
{
bool ret = SteamUnifiedMessages.ReleaseMethod(m_ClientUnifiedMessageHandle);
print("SteamUnifiedMessages.ReleaseMethod(" + m_ClientUnifiedMessageHandle + ") : " + ret);
}
if (GUILayout.Button("SteamUnifiedMessages.SendNotification(\"MsgTest.NotifyServer#1\", null, 0)"))
{
bool ret = SteamUnifiedMessages.SendNotification("MsgTest.NotifyServer#1", null, 0);
print("SteamUnifiedMessages.SendNotification(\"MsgTest.NotifyServer#1\", null, 0) : " + ret);
}
}
public static void Main(string[] args)
{
//DebugLog.AddListener((level, msg) =>
//{
// Console.WriteLine("[{0}] {1}", level, msg);
//});
if (args.Length < 2)
{
Console.WriteLine("GMPublish: No username and password specified!");
return;
}
user = args[0];
pass = args[1];
SteamDirectory.Initialize().Wait();
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamUnifiedMessages = steamClient.GetHandler <SteamUnifiedMessages>();
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
Console.WriteLine("Connecting to Steam...");
isRunning = true;
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
Console.WriteLine("Done?");
Console.ReadLine();
}
public static void Main(string[] args)
{
//DebugLog.AddListener((level, msg) =>
//{
// Console.WriteLine("[{0}] {1}", level, msg);
//});
if (args.Length < 3)
{
Console.WriteLine("GMPublish: missing arguments. gmpublish.exe [user] [password] [addonFolder]");
return;
}
user = args[0];
pass = args[1];
addonRoot = args[2];
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamUnifiedMessages = steamClient.GetHandler <SteamUnifiedMessages>();
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
Console.WriteLine("Connecting to Steam...");
isRunning = true;
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
Console.WriteLine("Done?");
Console.ReadLine();
}
public static void OnServiceMethod(SteamUnifiedMessages.ServiceMethodResponse callback, JobManager.IRCRequest request)
{
var response = callback.GetDeserializedResponse<CPublishedFile_GetDetails_Response>();
var details = response.publishedfiledetails.FirstOrDefault();
if (request.Type == JobManager.IRCRequestType.TYPE_PUBFILE_SILENT)
{
if (details == null || (EResult)details.result != EResult.OK)
{
return;
}
string title;
if (!string.IsNullOrWhiteSpace(details.title))
{
title = details.title;
}
else if (!string.IsNullOrEmpty(details.file_description))
{
title = details.file_description;
}
else
{
title = details.filename;
}
if (title.Length > 49)
{
title = title.Substring(0, 49) + "…";
}
if (request.Command.CommandType == ECommandType.SteamChatRoom)
{
Steam.Instance.Friends.SendChatRoomMessage(request.Command.ChatRoomID, EChatEntryType.ChatMsg,
string.Format("» {0}: {1} for {2} ({3:N0} views){4}", ((EWorkshopFileType)details.file_type), title, details.app_name, details.views, details.spoiler_tag ? " :retreat: SPOILER" : "")
);
}
else
{
IRC.Instance.SendReply(request.Command.Recipient,
string.Format("{0}» {1}{2} {3}{4}{5} for {6}{7}{8} ({9} views)",
Colors.OLIVE,
Colors.NORMAL,
((EWorkshopFileType)details.file_type),
Colors.BLUE,
title,
Colors.NORMAL,
Colors.BLUE,
details.app_name,
Colors.LIGHTGRAY,
details.views
),
false
);
}
return;
}
if (details == null)
{
CommandHandler.ReplyToCommand(request.Command, "Unable to make service request for published file info: the server returned no info");
return;
}
var result = (EResult)details.result;
if (result != EResult.OK)
{
CommandHandler.ReplyToCommand(request.Command, "Unable to get published file info: {0}", result);
return;
}
try
{
var json = JsonConvert.SerializeObject(details, Formatting.Indented);
File.WriteAllText(Path.Combine(Application.Path, "ugc", string.Format("{0}.json", details.publishedfileid)), json, Encoding.UTF8);
}
catch (Exception e)
{
CommandHandler.ReplyToCommand(request.Command, "Unable to save file: {0}", e.Message);
return;
}
CommandHandler.ReplyToCommand(request.Command, "{0}, Title: {1}{2}{3}, Creator: {4}{5}{6}, App: {7}{8}{9}{10}, File UGC: {11}{12}{13}, Preview UGC: {14}{15}{16} -{17} {18}",
(EWorkshopFileType)details.file_type,
Colors.BLUE, string.IsNullOrWhiteSpace(details.title) ? "[no title]" : details.title, Colors.NORMAL,
Colors.BLUE, new SteamID(details.creator).Render(true), Colors.NORMAL,
Colors.BLUE, details.creator_appid,
details.creator_appid == details.consumer_appid ? "" : string.Format(" (consumer {0})", details.consumer_appid),
Colors.NORMAL,
Colors.BLUE, details.hcontent_file, Colors.NORMAL,
Colors.BLUE, details.hcontent_preview, Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetUGCURL(details.publishedfileid)
);
CommandHandler.ReplyToCommand(request.Command, true, "{0} - https://steamcommunity.com/sharedfiles/filedetails/?id={1}", details.file_url, details.publishedfileid);
}
void OnServiceMethod( SteamUnifiedMessages.ServiceMethodResponse callback )
{
UGCJob ugcJob;
bool foundJob = ugcJobs.TryGetValue( callback.JobID, out ugcJob );
ugcJobs.Remove( callback.JobID );
if ( !foundJob )
{
// didn't find a waiting UGC job for this response
return;
}
if ( callback.Result != EResult.OK )
{
ugcJob.Callback( new UGCJobResult( callback.JobID, callback.Result ) );
return;
}
var response = callback.GetDeserializedResponse<CPublishedFile_GetDetails_Response>();
var details = response.publishedfiledetails.FirstOrDefault(); // we only ever request one pubfile at a time
EResult pubResult = (EResult)details.result;
if ( pubResult != EResult.OK )
{
ugcJob.Callback( new UGCJobResult ( callback.JobID, pubResult ) );
return;
}
// cache out this ugc to file and memory
ugcCache[details.publishedfileid] = new UGCCacheEntry
{
PubFileID = details.publishedfileid,
AppID = details.consumer_appid,
Name = details.title,
Tags = details.tags
};
using ( var ms = new MemoryStream() )
{
Serializer.Serialize( ms, details );
try
{
File.WriteAllBytes( GetCachePath( details.publishedfileid ), ms.ToArray() );
}
catch ( IOException ex )
{
Log.WriteError( "UGCHandler", "Unable to cache ugc for pubfile {0}: {1}", details.publishedfileid, ex.Message );
return;
}
}
var result = new UGCJobResult
{
ID = callback.JobID,
Details = details,
};
ugcJob.Callback( result );
}
void OnServiceMethod(SteamUnifiedMessages.ServiceMethodResponse callback)
{
if (callback.RpcName == "QueryFiles")
HandleQueryFiles(callback.GetDeserializedResponse<CPublishedFile_QueryFiles_Response>(), callback.JobID);
}
public static void Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("GMPublish: You need to pass at least one agument!");
return;
}
// Get the user and pass from the args if they are set.
// The can be passed via args or via environment variables
user = FindArgumentValue("-user", args, false);
pass = FindArgumentValue("-pass", args, false);
if (user == null)
{
user = Environment.GetEnvironmentVariable("GMPUBLISH_USER");
}
if (pass == null)
{
pass = Environment.GetEnvironmentVariable("GMPUBLISH_PASS");
}
if (user == null || pass == null)
{
Console.WriteLine("GMPublish: You must pass a username and password via the -user and -pass arguments OR via the GMPUBLISH_USER and GMPUBLISH_PASS environment variables.");
Exit(8);
return;
}
string gmaFilePath, iconFilePath;
switch (args[0])
{
case "create":
currentAction = Action.CREATE;
gmaFilePath = FindArgumentValue("-addon", args, true);
gmaFile = GetFileInfoOrExit(gmaFilePath);
iconFilePath = FindArgumentValue("-icon", args, true);
iconFile = GetFileInfoOrExit(iconFilePath);
break;
case "update":
currentAction = Action.UPDATE;
gmaFilePath = FindArgumentValue("-addon", args, true);
gmaFile = GetFileInfoOrExit(gmaFilePath);
workshopId = int.Parse(FindArgumentValue("-id", args, true));
iconFilePath = FindArgumentValue("-icon", args, false);
if (iconFilePath != null)
{
iconFile = GetFileInfoOrExit(iconFilePath);
}
break;
case "list":
currentAction = Action.LIST;
break;
default:
Console.WriteLine("Invalid command please use either create, update or list");
Exit(8);
break;
}
SteamDirectory.Initialize().Wait();
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamUnifiedMessages = steamClient.GetHandler <SteamUnifiedMessages>();
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
Console.WriteLine("Connecting to Steam...");
isRunning = true;
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
Console.WriteLine("Done?");
Console.ReadLine();
}
internal ArchiHandler([JetBrains.Annotations.NotNull] ArchiLogger archiLogger, [JetBrains.Annotations.NotNull] SteamUnifiedMessages steamUnifiedMessages)
{
if ((archiLogger == null) || (steamUnifiedMessages == null))
{
throw new ArgumentNullException(nameof(archiLogger) + " || " + nameof(steamUnifiedMessages));
}
ArchiLogger = archiLogger;
UnifiedChatRoomService = steamUnifiedMessages.CreateService <IChatRoom>();
UnifiedClanChatRoomsService = steamUnifiedMessages.CreateService <IClanChatRooms>();
UnifiedEconService = steamUnifiedMessages.CreateService <IEcon>();
UnifiedFriendMessagesService = steamUnifiedMessages.CreateService <IFriendMessages>();
UnifiedPlayerService = steamUnifiedMessages.CreateService <IPlayer>();
UnifiedTwoFactorService = steamUnifiedMessages.CreateService <ITwoFactor>();
}
public void OnServiceMethod(SteamUnifiedMessages.ServiceMethodResponse callback, JobID jobID)
{
var request = IRCRequests.Find(r => r.JobID == jobID);
if (request == null)
{
return;
}
IRCRequests.Remove(request);
if (callback.Result != EResult.OK)
{
CommandHandler.ReplyToCommand(request.Command, "{0}{1}{2}: Unable to get player games: {3}", Colors.OLIVE, request.Command.Nickname, Colors.NORMAL, callback.Result);
return;
}
var response = callback.GetDeserializedResponse<SteamKit2.Unified.Internal.CPlayer_GetOwnedGames_Response>();
string roulette = string.Empty;
if (response.game_count > 2)
{
var game = response.games[new Random().Next((int)response.game_count)];
roulette = string.Format("{0} - Roulette: {1}{2}{3} -{4} steam://run/{5}/", Colors.NORMAL, Colors.OLIVE, GetAppName((uint)game.appid), Colors.NORMAL, Colors.DARK_BLUE, game.appid);
}
CommandHandler.ReplyToCommand(request.Command, "{0}{1}{2}: {3}{4}{5} games owned -{6} {7}{8}", Colors.OLIVE, request.Command.Nickname, Colors.NORMAL, Colors.YELLOW, response.game_count, Colors.NORMAL, Colors.DARK_BLUE, SteamDB.GetCalculatorURL(request.SteamID), roulette);
}
static void OnMethodResponse( SteamUnifiedMessages.ServiceMethodResponse callback )
{
if ( callback.JobID != badgeRequest )
{
// always double check the jobid of the response to ensure you're matching to your original request
return;
}
// and check for success
if ( callback.Result != EResult.OK )
{
Console.WriteLine( $"Unified service request failed with {callback.Result}" );
return;
}
// retrieve the deserialized response for the request we made
// notice the naming pattern
// for requests: CMyService_Method_Request
// for responses: CMyService_Method_Response
CPlayer_GetGameBadgeLevels_Response resp = callback.GetDeserializedResponse<CPlayer_GetGameBadgeLevels_Response>();
Console.WriteLine( $"Our player level is {resp.player_level}" );
foreach ( var badge in resp.badges )
{
Console.WriteLine( $"Badge series {badge.series} is level {badge.level}" );
}
badgeRequest = JobID.Invalid;
// now that we've completed our task, lets log off
steamUser.LogOff();
}
