public PICSChanges(CallbackManager manager) : base(manager) { if (Settings.IsFullRun) { PreviousChangeNumber = 1; // Request everything manager.Subscribe<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun); return; } manager.Subscribe<SteamApps.PICSChangesCallback>(OnPICSChanges); using (var db = Database.GetConnection()) { BillingTypeKey = db.ExecuteScalar<uint>("SELECT `ID` FROM `KeyNamesSubs` WHERE `Name` = 'root_billingtype'"); PreviousChangeNumber = db.ExecuteScalar<uint>("SELECT `ChangeID` FROM `Changelists` ORDER BY `ChangeID` DESC LIMIT 1"); Log.WriteInfo("PICSChanges", "Previous changelist was {0}", PreviousChangeNumber); } if (PreviousChangeNumber == 0) { Log.WriteWarn("PICSChanges", "Looks like there are no changelists in the database."); Log.WriteWarn("PICSChanges", "If you want to fill up your database first, restart with \"FullRun\" setting set to 1."); } }
public GameCoordinator(SteamClient steamClient, CallbackManager manager) { SessionMap = new Dictionary<uint, SessionInfo>(); // Map gc messages to our callback functions MessageMap = new Dictionary<uint, Action<uint, IPacketGCMsg>> { { (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnConnectionStatus }, { (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnWelcome }, { (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate }, { (uint)EGCItemMsg.k_EMsgGCClientVersionUpdated, OnVersionUpdate }, { (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage }, // TF2 specific messages { k_EMsgGCClientGoodbye, OnConnectionStatus }, { (uint)EGCItemMsg.k_EMsgGCGoldenWrenchBroadcast, OnWrenchBroadcast }, { k_EMsgGCTFSpecificItemBroadcast, OnItemBroadcast }, }; SteamGameCoordinator = steamClient.GetHandler<SteamGameCoordinator>(); SessionTimer = new Timer(); SessionTimer.Interval = TimeSpan.FromSeconds(30).TotalMilliseconds; SessionTimer.Elapsed += OnSessionTick; SessionTimer.Start(); manager.Subscribe<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage); manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); }
public Login(SteamNerd steamNerd, CallbackManager manager) { _steamNerd = steamNerd; manager.Subscribe <SteamClient.ConnectedCallback>(OnConnect); manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnect); manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKey); }
public Login(SteamNerd steamNerd, CallbackManager manager) { _steamNerd = steamNerd; manager.Subscribe<SteamClient.ConnectedCallback>(OnConnect); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnect); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe<SteamUser.LoginKeyCallback>(OnLoginKey); }
static void Main(string[] args) { // install our debug listeners for this example // install an instance of our custom listener DebugLog.AddListener(new MyListener()); // install a listener as an anonymous method // this call is commented as it would be redundant to install a second listener that also displays messages to the console // DebugLog.AddListener( ( category, msg ) => Console.WriteLine( "AnonymousMethod - {0}: {1}", category, msg ) ); // Enable DebugLog in release builds DebugLog.Enabled = true; if (args.Length < 2) { Console.WriteLine("Sample3: 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>(); // 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); 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)); } }
public SteamBot(string login, string password) { var configuration = SteamConfiguration.Create(b => b.WithProtocolTypes(ProtocolTypes.Tcp).WithCellID(1)); SteamClient = new SteamClient(configuration); Manager = new CallbackManager(SteamClient); Chatters = new HashSet <Friend>(); SteamUser = SteamClient.GetHandler <SteamUser>(); SteamFriends = SteamClient.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.AccountInfoCallback>(OnAccountInfo); Manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList); Manager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState); Manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded); Manager.Subscribe <SteamFriends.FriendMsgCallback>(OnFriendMsg); _login = login; _password = password; IsRunning = true; Console.WriteLine("Connecting to Steam"); SteamClient.Connect(); KeepBotAlive(); }
private static void Login() { steamClient = new SteamClient(); callBackManager = new CallbackManager(steamClient); steamFriends = steamClient.GetHandler<SteamFriends>(); steamUser = steamClient.GetHandler<SteamUser>(); callBackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); callBackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedIn); callBackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); callBackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); callBackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnMsgRecieved); callBackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo); callBackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList); callBackManager.Subscribe<SteamFriends.FriendAddedCallback>(OnFriendAdded); callBackManager.Subscribe<SteamFriends.PersonaStateCallback>(OnFriendPersonaChange); SteamDirectory.Initialize().Wait(); steamClient.Connect(); isRunning = true; while (isRunning) { callBackManager.RunWaitCallbacks(TimeSpan.FromSeconds(0.5)); } Console.ReadKey(); }
public Task Run(CancellationToken cancellation = default(CancellationToken)) { var tcs = new TaskCompletionSource <object>(); var steamThread = new Thread(() => { CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); CallbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); CallbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo); CallbackManager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList); CallbackManager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState); CallbackManager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage); Trace.WriteLine("Connecting ...", "Steam"); SteamClient.Connect(); while (!cancellation.IsCancellationRequested) { try { CallbackManager.RunWaitCallbacks(); } catch (Exception ex) { Trace.WriteLine((object)ex, "Steam callback exception"); } } tcs.SetCanceled(); }); steamThread.Name = "Steam thread"; steamThread.Start(); return(tcs.Task); }
public SteamApiClient() { steamClient = new SteamClient(); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler <SteamUser>(); steamApps = steamClient.GetHandler <SteamApps>(); manager.Subscribe <SteamClient.ConnectedCallback>(onConnected); manager.Subscribe <SteamClient.DisconnectedCallback>(onDisconnected); manager.Subscribe <SteamUser.LoggedOnCallback>(onLoggedOn); manager.Subscribe <SteamUser.LoggedOffCallback>(onLoggedOff); }
public TestApp() { Console.Write("Enter API Key: "); SteamManager.SteamAPIKey = Console.ReadLine(); Console.Write("Enter UserName: "******"Enter Password: "******"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)); } }
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 ) ); } }
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)); } }
public void Start(string[] args) { DebugLog.AddListener((category, msg) => Console.WriteLine("AnonymousMethod - {0}: {1}", category, msg)); DebugLog.Enabled = false; if (args.Length < 2) { Console.WriteLine("Sample1: 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 friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler <SteamFriends>(); gameCoordinator = steamClient.GetHandler <SteamGameCoordinator>(); manager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage); // 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); 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)); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample9: 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 our steamapps handler, we'll use this as an example of how async jobs can be handled steamApps = steamClient.GetHandler<SteamApps>(); // 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 ); // notice that we're not subscribing to the SteamApps.PICSProductInfoCallback callback here (or other SteamApps callbacks) // since this sample is using the async job directly, we no longer need to subscribe to the callback. // however, if we still wish to use callbacks (or have existing code which subscribes to callbacks, they will // continue to operate alongside direct async job handling. (i.e.: steamclient will still post callbacks for // any async jobs that are completed) 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 ) ); } }
static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Sample9: 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 our steamapps handler, we'll use this as an example of how async jobs can be handled steamApps = steamClient.GetHandler <SteamApps>(); // 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); // notice that we're not subscribing to the SteamApps.PICSProductInfoCallback callback here (or other SteamApps callbacks) // since this sample is using the async job directly, we no longer need to subscribe to the callback. // however, if we still wish to use callbacks (or have existing code which subscribes to callbacks, they will // continue to operate alongside direct async job handling. (i.e.: steamclient will still post callbacks for // any async jobs that are completed) 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)); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample2: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // add our custom handler to our steamclient steamClient.AddHandler( new MyHandler() ); // 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>(); // now get an instance of our custom handler myHandler = steamClient.GetHandler<MyHandler>(); // 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 ); // handle our own custom callback manager.Subscribe<MyHandler.MyCallback>( OnMyCallback ); 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 ) ); } }
static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Sample2: No username and password specified!"); return; } // save our logon details user = args[0]; pass = args[1]; // create our steamclient instance steamClient = new SteamClient(); // add our custom handler to our steamclient steamClient.AddHandler(new MyHandler()); // 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>(); // now get an instance of our custom handler myHandler = steamClient.GetHandler <MyHandler>(); // 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); // handle our own custom callback manager.Subscribe <MyHandler.MyCallback>(OnMyCallback); 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)); } }
public Steam() { Client = new SteamClient(); User = Client.GetHandler <SteamUser>(); Apps = Client.GetHandler <SteamApps>(); CallbackManager = new CallbackManager(Client); CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); CallbackManager.Subscribe <SteamApps.PICSChangesCallback>(OnPICSChanges); }
public SteamUserFixture(SteamUser.LogOnDetails logOnDetails) { this.logOnDetails = logOnDetails; Friends = Client.GetHandler <SteamFriends>(); Matchmaking = Client.GetHandler <SteamMatchmaking>(); User = Client.GetHandler <SteamUser>(); CallbackManager = new CallbackManager(Client); CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); }
private void CreateSteamCallbacks() { if (manager != null) { return; } manager = new CallbackManager(client); disposables.Add(manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected)); disposables.Add(manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected)); disposables.Add(manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn)); disposables.Add(manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff)); }
public SteamSession() { Client = new SteamClient("SteamDepotBrowser"); steamUser = Client.GetHandler <SteamUser>(); steamApps = Client.GetHandler <SteamApps>(); callbacks = new CallbackManager(Client); callbacks.Subscribe <SteamUser.LoginKeyCallback>(OnSteamLoginKey); callbacks.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnSteamUpdateMachineAuth); callbacks.Subscribe <SteamApps.LicenseListCallback>(OnSteamLicenseList); Task.Run(UpdateSteamThread); }
public Connection(CallbackManager manager) : base(manager) { ReconnectionTimer = new Timer(); ReconnectionTimer.AutoReset = false; ReconnectionTimer.Elapsed += Reconnect; ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds; 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); }
public BotInstance(IServiceConsumer <ISteamBotCoordinator> coordinator, ILogProvider logProvider, BotCookieManager cookieManager, MqClientProvider mqClientProvider) { _coordinator = coordinator; _logger = logProvider.Logger; _mqClientProvider = mqClientProvider; CookieManager = cookieManager; _callbackManager = new CallbackManager(SteamClient); _callbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); _callbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); _callbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); _callbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnUpdateMachineAuth); _callbackManager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKeyReceived); _callbackManager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaStateChanged); _callbackManager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendListUpdated); _callbackManager.Subscribe <SteamFriends.FriendMsgCallback>(OnFriendMessageReceived); _steamUser = SteamClient.GetHandler <SteamUser>(); SteamFriends = SteamClient.GetHandler <SteamFriends>(); SteamApps = SteamClient.GetHandler <SteamApps>(); }
public Connection(CallbackManager manager) : base(manager) { ReconnectionTimer = new Timer(); ReconnectionTimer.AutoReset = false; ReconnectionTimer.Elapsed += Reconnect; ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds; 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); }
static void SteamConnect() { //Declare materials client = new SteamClient(); manager = new CallbackManager(client); credentials = client.GetHandler <SteamUser>(); friends = client.GetHandler <SteamFriends>(); //Declare dependencies manager.Subscribe <SteamClient.ConnectedCallback>(onConnectingToSteam); manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedIn); manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo); manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMsg); manager.Subscribe <SteamFriends.ProfileInfoCallback>(OnRequestingCustomerInfo); //Connect Client to Steam client.Connect(); Console.WriteLine("Connecting to Steam..."); isRunning = true; //Await commands from customer while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromMilliseconds(500)); } Console.ReadKey(); }
// Registers callbacks and connects to steam client private void ConnectToSteam() { steamClient = new SteamClient(); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler <SteamUser>(); 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); steamClient.Connect(); }
public Monitor(DatabaseRecord server, SteamConfiguration config) { Server = server; Client = new SteamClient(config); steamUser = new SteamMonitorUser(); Client.AddHandler(steamUser); callbackMgr = new CallbackManager(Client); callbackMgr.Subscribe <SteamClient.ConnectedCallback>(OnConnected); callbackMgr.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); callbackMgr.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); callbackMgr.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); }
// ReSharper disable once SuggestBaseTypeForParameter protected SteamKitBot(ISteamKitBotSettings settings, ILogger botLogger) : base(settings, botLogger) { CancellationTokenSource = new CancellationTokenSource(); SteamClient = new SteamClient( SteamConfiguration.Create( builder => { if (settings.ConnectionTimeout != null) { builder.WithConnectionTimeout( TimeSpan.FromSeconds(settings.ConnectionTimeout.Value) ); } if (!string.IsNullOrWhiteSpace(settings.ApiKey)) { builder.WithWebAPIKey(settings.ApiKey); } } ) ); CallbackManager = new CallbackManager(SteamClient); SteamUser = SteamClient.GetHandler <SteamUser>(); SteamFriends = SteamClient.GetHandler <SteamFriends>(); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnInternalSteamClientConnected) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnInternalSteamClientDisconnect) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnInternalSteamUserLoggedOn) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnInternalSteamUserLoggedOff) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamUser.LoginKeyCallback>(OnInternalSteamUserLoginKeyExchange) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamUser.WebAPIUserNonceCallback>(OnInternalSteamUserNewWebApiUserNonce) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnInternalSteamUserUpdateMachineAuthenticationCallback) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnInternalAccountInfoAvailable) ); SubscribedCallbacks.Add( CallbackManager.Subscribe <SteamUser.WalletInfoCallback>(OnInternalWalletInfoAvailable) ); }
public PICSTokens(CallbackManager manager) : base(manager) { manager.Subscribe <SteamApps.PICSTokensCallback>(OnPICSTokens); Reload(); }
public FreeLicense(CallbackManager manager) : base(manager) { PackageRegex = new Regex("RemoveFreeLicense\\( ?(?<subid>[0-9]+), ?'(?<name>.+)' ?\\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture); manager.Subscribe <SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback); }
public void Start() { //get game coordinator handler, use in game _steamGameCoordinator = _steamClient.GetHandler <SteamGameCoordinator>(); _callbackManager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGcMessage); //tell that we are playing DOTA var playGame = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed); playGame.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed { game_id = new GameID(570), // or game_id = APPID, }); _steamClient.Send(playGame); // inform the dota GC that we want a session var clientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello) { Body = { engine = ESourceEngine.k_ESE_Source2, client_session_need = 104 } }; AddMessageHandler((uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, Connected); AddMessageHandler((uint)ESOMsg.k_ESOMsg_CacheSubscribed, OnCacheSubscribed); AddMessageHandler((uint)ESOMsg.k_ESOMsg_UpdateMultiple, OnUpdateMultiple); _steamGameCoordinator.Send(clientHello, 570); _status = DotaManagerStatus.Connecting; }
public FreeLicense(CallbackManager manager) { PackageRegex = new Regex("RemoveFreeLicense\\( ?(?<subid>[0-9]+), ?'(?<name>.+)' ?\\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture); manager.Subscribe <SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback); FreeLicenseTimer = new Timer { AutoReset = false, Interval = TimeSpan.FromMinutes(61).TotalMilliseconds }; FreeLicenseTimer.Elapsed += OnTimer; var db = Database.Get(); var data = db.ExecuteScalar <string>("SELECT `Value` FROM `LocalConfig` WHERE `ConfigKey` = 'backend.freelicense.requests'"); if (data != null) { FreeLicensesToRequest = JsonConvert.DeserializeObject <Dictionary <uint, uint> >(data); } if (FreeLicensesToRequest.Count == 0) { return; } Log.WriteInfo(nameof(FreeLicense), $"There are {FreeLicensesToRequest.Count} free licenses to request"); if (!Settings.IsFullRun) { AppsRequestedInHour = REQUEST_RATE_LIMIT; FreeLicenseTimer.Start(); } }
public Steam() { DebugLog.AddListener(new SteamKitLogger()); DebugLog.Enabled = true; Client = new SteamClient(); User = Client.GetHandler <SteamUser>(); Apps = Client.GetHandler <SteamApps>(); CallbackManager = new CallbackManager(Client); CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); CallbackManager.Subscribe <SteamApps.PICSChangesCallback>(OnPICSChanges); }
public Dota2Client(string userName, string password) { this.userName = userName; this.password = password; isStartOver = false; steamClient = new SteamClient(); // get our handlers steamUser = steamClient.GetHandler <SteamUser>(); steamGameCoordinator = steamClient.GetHandler <SteamGameCoordinator>(); // setup callbacks callbackMgr = new CallbackManager(steamClient); callbackMgr.Subscribe <SteamClient.ConnectedCallback>(OnConnected); callbackMgr.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); callbackMgr.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); callbackMgr.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage); }
public PICSTokens(CallbackManager manager) : base(manager) { manager.Subscribe<SteamApps.PICSTokensCallback>(OnPICSTokens); Reload(); }
public FreeLicense(CallbackManager manager) : base(manager) { PackageRegex = new Regex("RemoveFreeLicense\\( ?(?<subid>[0-9]+), ?'(?<name>.+)' ?\\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture); manager.Subscribe<SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback); }
private static void steamLogin() { // create our steamclient instance var configuration = SteamConfiguration.Create(b => b.WithProtocolTypes(ProtocolTypes.Tcp)); 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>(); steamFriends = steamClient.GetHandler <SteamFriends>(); // 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); // this callback is triggered when the steam servers wish for the client to store the sentry file manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); // we use the following callbacks for friends related activities manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo); manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList); manager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState); manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded); manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage); 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)); } }
static void Run(string[] args) { user = args[0]; pass = args[1]; steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler <SteamUser>(); steamUserStats = steamClient.GetHandler <SteamUserStats>(); manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); isRunning = true; Console.WriteLine("Connecting to Steam..."); loggedIn = false; SteamDirectory.Initialize().Wait(); steamClient.Connect(); while (!loggedIn) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); if (!isRunning) { return; } } uint appid = Convert.ToUInt32(args[2]); string lbListFile = args[3]; foreach (string lbname in File.ReadLines(lbListFile)) { if (!String.IsNullOrEmpty(lbname) && isRunning) { DownloadLeaderboard(appid, lbname); } } }
public Dota2Client() { steam = new SteamClient(); user = steam.GetHandler <SteamUser>(); manager = new CallbackManager(steam); gameCoordinator = steam.GetHandler <SteamGameCoordinator>(); manager.Subscribe <SteamClient.ConnectedCallback>(onConnect); manager.Subscribe <SteamUser.LoggedOnCallback>(onLogon); manager.Subscribe <SteamGameCoordinator.MessageCallback>(onMessage); connected = false; loggedOn = false; welcomed = false; receivedReplayURLs = new List <string>(); }
// static string toptlb; // public static string steamgg(string code) // { // return code; // } public static void Enter_(string us, string pa, ToolStripLabel tlb_) { user = us; pass = pa; tlb = tlb_; if ((user.Length < 2) || (pass.Length < 2)) { tlb.Text = "No username and password specified!"; return; } // 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>(); // 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); // this callback is triggered when the steam servers wish for the client to store the sentry file //manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); isRunning = true; tlb.Text = "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)); } }
public override Result Start() { Thread.CurrentThread.Name = JsonAccount.Username + " - " + (_reportInfo != null ? "Report" : "Commend"); _freeGamesHandler = new PrimitiveFreeGamesRequestHandler(OnFreeLicenseResponse); _steamClient.AddHandler(_freeGamesHandler); _callbacks.Subscribe <SteamClient.ConnectedCallback>(OnConnected); _callbacks.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); _callbacks.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); _callbacks.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); _callbacks.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage); _callbacks.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); _callbacks.Subscribe <SteamUser.LoginKeyCallback>(OnNewLoginKey); IsRunning = true; _steamClient.Connect(); while (IsRunning) { _callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(500)); } return(Result); }
public SteamWrappedClient() { Client = new SteamClient(); CallbackManager = new CallbackManager(Client); User = Client.GetHandler<SteamUser>(); TradingHandler = Client.GetHandler<SteamTrading>(); CallbackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnect); CallbackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnect); CallbackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLogon); CallbackManager.Subscribe<SteamUser.LoggedOffCallback>(OnLogoff); CallbackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); RegisterOtherCallbacks(); }
public DepotProcessor(SteamClient client, CallbackManager manager) { DepotLocks = new ConcurrentDictionary<uint, byte>(); CDNClient = new CDNClient(client); FileDownloader.SetCDNClient(CDNClient); CDNServers = new List<string> { "cdn.level3.cs.steampowered.com", "cdn.akamai.cs.steampowered.com", "cdn.highwinds.cs.steampowered.com" }; manager.Subscribe<SteamApps.CDNAuthTokenCallback>(OnCDNAuthTokenCallback); manager.Subscribe<SteamApps.DepotKeyCallback>(OnDepotKeyCallback); }
public DotaClient( string userName, string password, uint matchId ) { this.userName = userName; this.password = password; this.matchId = matchId; client = new SteamClient(); // get our handlers user = client.GetHandler<SteamUser>(); gameCoordinator = client.GetHandler<SteamGameCoordinator>(); // setup callbacks callbackMgr = new CallbackManager( client ); callbackMgr.Subscribe<SteamClient.ConnectedCallback>( OnConnected ); callbackMgr.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); callbackMgr.Subscribe<SteamGameCoordinator.MessageCallback>( OnGCMessage ); }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample4: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient( System.Net.Sockets.ProtocolType.Tcp ); // 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 friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); // 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 friends related activities manager.Subscribe<SteamUser.AccountInfoCallback>( OnAccountInfo ); manager.Subscribe<SteamFriends.FriendsListCallback>( OnFriendsList ); manager.Subscribe<SteamFriends.PersonaStateCallback>( OnPersonaState ); manager.Subscribe<SteamFriends.FriendAddedCallback>( OnFriendAdded ); 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 ) ); } }
public ECheckResult StartSteam() { _steamClient = new SteamClient(); _manager = new CallbackManager(_steamClient); _steamUser = _steamClient.GetHandler<SteamUser>(); _manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); _manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); _manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); _manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); _isRunning = true; _steamClient.Connect(); while (_isRunning) _manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); if (_operation == EOperationType.CreateSentry) Thread.Sleep(500); _steamClient.Disconnect(); return _checkResult; }
public UGCHandler( CallbackManager manager ) : base(manager) { try { Directory.CreateDirectory( Path.Combine( "cache", "ugc" ) ); } catch ( IOException ex ) { Log.WriteError( "UGCHandler", "Unable to create ugc cache directory: {0}", ex.Message ); } manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>( OnServiceMethod ); Steam.Instance.CallbackManager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); }
public FreeLicense(CallbackManager manager) : base(manager) { manager.Subscribe<SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback); }
public void Init() { Client = new SteamClient(); CallbackManager = new CallbackManager( Client ); User = Client.GetHandler<SteamUser>(); Friends = Client.GetHandler<SteamFriends>(); Apps = Client.GetHandler<SteamApps>(); UserStats = Client.GetHandler<SteamUserStats>(); Cloud = Client.GetHandler<SteamCloud>(); Workshop = Client.GetHandler<SteamWorkshop>(); Unified = Client.GetHandler<SteamUnifiedMessages>(); MasterServer = Client.GetHandler<SteamMasterServer>(); GameCoordinator = Client.GetHandler<SteamGameCoordinator>(); Levels = new SteamLevels(); Games = new SteamGames(); AppInfo = new SteamAppInfo(); Account = new SteamAccount(); PublishedFiles = Unified.CreateService<IPublishedFile>(); Client.AddHandler( Levels ); Client.AddHandler( Games ); Client.AddHandler( AppInfo ); Client.AddHandler( Account ); SteamManager = new SteamManager( CallbackManager ); GCManager = new GCManager( CallbackManager ); JobManager = new JobManager( CallbackManager ); CallbackManager.Subscribe<SteamClient.ConnectedCallback>( OnConnected ); CallbackManager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected ); CallbackManager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); CallbackManager.Subscribe<SteamUser.LoggedOffCallback>( OnLoggedOff ); CallbackManager.Subscribe<SteamUser.AccountInfoCallback>( OnAccountInfo ); }
public async Task<byte[]> DownloadReplay(ulong matchId, CancellationToken cancellationToken) { return await Task.Run<byte[]>(async () => { CMsgDOTAMatch matchDetails = null; // get the GC handler, which is used for messaging DOTA var gcHandler = this.SteamClient.GetHandler<SteamGameCoordinator>(); // register a few callbacks we're interested in var cbManager = new CallbackManager(this.SteamClient); var sub = cbManager.Subscribe<SteamGameCoordinator.MessageCallback>((SteamGameCoordinator.MessageCallback callback) => { cancellationToken.ThrowIfCancellationRequested(); if (callback.EMsg == (uint)EDOTAGCMsg.k_EMsgGCMatchDetailsResponse) { var msg = new ClientGCMsgProtobuf<CMsgGCMatchDetailsResponse>(callback.Message); matchDetails = msg.Body.match; } }); // Send Request var request = new ClientGCMsgProtobuf<CMsgGCMatchDetailsRequest>((uint)EDOTAGCMsg.k_EMsgGCMatchDetailsRequest); request.Body.match_id = matchId; gcHandler.Send(request, APPID); while (matchDetails == null) { cancellationToken.ThrowIfCancellationRequested(); // in order for the callbacks to get routed, they need to be handled by the manager cbManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } var url = string.Format("http://replay{0}.valve.net/{1}/{2}_{3}.dem.bz2", matchDetails.cluster, APPID, matchDetails.match_id, matchDetails.replay_salt); var webClient = new WebClient(); var compressedMatchData = await webClient.DownloadDataTaskAsync(url); var uncompressedMatchData = CompressionFactory.BZip2.Decompress(compressedMatchData); return uncompressedMatchData; }); }
static void Main(string[] args) { Logger.filename = "RelayBot.log"; log = Logger.GetLogger(); steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); bot = new Bot(steamUser, steamFriends, steamClient); manager.Subscribe<SteamClient.ConnectedCallback>(bot.OnConnected); manager.Subscribe<SteamClient.DisconnectedCallback>(bot.OnDisconnected); manager.Subscribe<SteamUser.LoggedOnCallback>(bot.OnLoggedOn); manager.Subscribe<SteamUser.LoggedOffCallback>(bot.OnLoggedOff); manager.Subscribe<SteamUser.AccountInfoCallback>(bot.OnAccountInfo); manager.Subscribe<SteamFriends.FriendsListCallback>(bot.OnFriendsList); manager.Subscribe<SteamFriends.FriendAddedCallback>(bot.OnFriendAdded); manager.Subscribe<SteamFriends.ChatInviteCallback>(bot.OnChatInvite); manager.Subscribe<SteamFriends.ChatEnterCallback>(bot.OnChatEnter); manager.Subscribe<SteamFriends.FriendMsgCallback>(bot.OnFriendMessage); manager.Subscribe<SteamFriends.ChatMsgCallback>(bot.OnChatroomMessage); manager.Subscribe<SteamFriends.ChatMemberInfoCallback>(bot.OnMemberInfo); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(bot.OnMachineAuth); bot.isRunning = true; log.Info("Connecting to Steam..."); steamClient.Connect(); //callback loop while (bot.isRunning) { try { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } catch (Exception e) { Logger.filename = "RelayBot.log"; log.Error(String.Format("Caught exception: {0}\nMessage: {1}\nStack trace: {2}", e.GetType().ToString(), e.Message, e.StackTrace)); } } }
void steam_connection() { steamClient = new SteamClient(); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnect); manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>(OnServiceMethod); steamClient.Connect(); while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
internal Bot(string botName) { if (Bots.ContainsKey(botName)) { return; } BotName = botName; ConfigFile = Path.Combine(Program.ConfigDirectoryPath, BotName + ".xml"); SentryFile = Path.Combine(Program.ConfigDirectoryPath, BotName + ".bin"); if (!ReadConfig()) { return; } if (!Enabled) { return; } lock (Bots) { Bots.Add(BotName, this); } // Initialize SteamClient = new SteamClient(); ArchiHandler = new ArchiHandler(); SteamClient.AddHandler(ArchiHandler); CallbackManager = new CallbackManager(SteamClient); CallbackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); CallbackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); SteamFriends = SteamClient.GetHandler<SteamFriends>(); CallbackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList); CallbackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnFriendMsg); CallbackManager.Subscribe<SteamFriends.PersonaStateCallback>(OnPersonaState); SteamUser = SteamClient.GetHandler<SteamUser>(); CallbackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo); CallbackManager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); CallbackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); CallbackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); CallbackManager.Subscribe<ArchiHandler.NotificationCallback>(OnNotification); CallbackManager.Subscribe<ArchiHandler.PurchaseResponseCallback>(OnPurchaseResponse); ArchiWebHandler = new ArchiWebHandler(this, SteamApiKey); CardsFarmer = new CardsFarmer(this); Trading = new Trading(this); // Start Start(); }
public SteamBot() { reconnectBackoff = new ExponentialBackoff(); // 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 friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); steamApps = steamClient.GetHandler<SteamApps>(); steamClient.AddHandler(new CustomHandler()); // 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); //manager.Subscribe<SteamUser.MarketingMessageCallback>(OnMarketing); // we use the following callbacks for friends related activities manager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo); manager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList); manager.Subscribe<SteamFriends.PersonaStateCallback>(OnPersonaState); manager.Subscribe<SteamFriends.FriendAddedCallback>(OnFriendAdded); manager.Subscribe<SteamFriends.FriendMsgCallback>(OnFriendMsg); manager.Subscribe<SteamFriends.FriendMsgEchoCallback>(EchoMsg); manager.Subscribe<SteamFriends.FriendMsgHistoryCallback>(ch_OnOfflineMessage2); manager.Subscribe<SteamFriends.ChatInviteCallback>(OnChatInvite); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); }
public WebAuth(CallbackManager manager) : base(manager) { manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe<SteamUser.WebAPIUserNonceCallback>(OnWebAPIUserNonce); }
public PICSProductInfo(CallbackManager manager) : base(manager) { manager.Subscribe<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo); }
static void Main(string[] args) { if (!File.Exists("chat.txt")) { File.Create("chat.txt").Close(); File.WriteAllText("chat.txt", "abc | 123"); } if (!File.Exists("admin.txt")) { File.Create("admin.txt").Close(); File.WriteAllText("admin.txt", "Please Insert Your steamID64"); } Console.Title = "Steam Bot Beta V0.1"; Console.WriteLine("CTRL+C To Quit....."); Console.Write("Username: "******"Password: "******"\nConnecting To Steam....\n"); steamClient.Connect(); while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
public AccountInfo(CallbackManager manager) : base(manager) { manager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo); }
internal Bot(string botName) { if (string.IsNullOrEmpty(botName)) { throw new ArgumentNullException(nameof(botName)); } if (Bots.ContainsKey(botName)) { throw new ArgumentException("That bot is already defined!"); } string botPath = Path.Combine(SharedInfo.ConfigDirectory, botName); BotName = botName; SentryFile = botPath + ".bin"; string botConfigFile = botPath + ".json"; BotConfig = BotConfig.Load(botConfigFile); if (BotConfig == null) { Logging.LogGenericError("Your bot config is invalid, please verify content of " + botConfigFile + " and try again!", botName); return; } // Register bot as available for ASF if (!Bots.TryAdd(botName, this)) { throw new ArgumentException("That bot is already defined!"); } string botDatabaseFile = botPath + ".db"; BotDatabase = BotDatabase.Load(botDatabaseFile); if (BotDatabase == null) { Logging.LogGenericError("Bot database could not be loaded, refusing to create this bot instance! In order to recreate it, remove " + botDatabaseFile + " and try again!", botName); return; } if (BotDatabase.MobileAuthenticator != null) { BotDatabase.MobileAuthenticator.Init(this); } else { // Support and convert SDA files string maFilePath = botPath + ".maFile"; if (File.Exists(maFilePath)) { ImportAuthenticator(maFilePath); } } // Initialize SteamClient = new SteamClient(Program.GlobalConfig.SteamProtocol); if (Program.GlobalConfig.Debug && Directory.Exists(SharedInfo.DebugDirectory)) { string debugListenerPath = Path.Combine(SharedInfo.DebugDirectory, botName); try { Directory.CreateDirectory(debugListenerPath); SteamClient.DebugNetworkListener = new NetHookNetworkListener(debugListenerPath); } catch (Exception e) { Logging.LogGenericException(e, botName); } } ArchiHandler = new ArchiHandler(this); SteamClient.AddHandler(ArchiHandler); CallbackManager = new CallbackManager(SteamClient); CallbackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); CallbackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); SteamApps = SteamClient.GetHandler<SteamApps>(); CallbackManager.Subscribe<SteamApps.FreeLicenseCallback>(OnFreeLicense); CallbackManager.Subscribe<SteamApps.GuestPassListCallback>(OnGuestPassList); CallbackManager.Subscribe<SteamApps.LicenseListCallback>(OnLicenseList); SteamFriends = SteamClient.GetHandler<SteamFriends>(); CallbackManager.Subscribe<SteamFriends.ChatInviteCallback>(OnChatInvite); CallbackManager.Subscribe<SteamFriends.ChatMsgCallback>(OnChatMsg); CallbackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList); CallbackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnFriendMsg); CallbackManager.Subscribe<SteamFriends.FriendMsgHistoryCallback>(OnFriendMsgHistory); CallbackManager.Subscribe<SteamFriends.PersonaStateCallback>(OnPersonaState); SteamUser = SteamClient.GetHandler<SteamUser>(); CallbackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo); CallbackManager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); CallbackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); CallbackManager.Subscribe<SteamUser.LoginKeyCallback>(OnLoginKey); CallbackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); CallbackManager.Subscribe<SteamUser.WebAPIUserNonceCallback>(OnWebAPIUserNonce); CallbackManager.Subscribe<ArchiHandler.NotificationsCallback>(OnNotifications); CallbackManager.Subscribe<ArchiHandler.OfflineMessageCallback>(OnOfflineMessage); CallbackManager.Subscribe<ArchiHandler.PlayingSessionStateCallback>(OnPlayingSessionState); CallbackManager.Subscribe<ArchiHandler.PurchaseResponseCallback>(OnPurchaseResponse); CallbackManager.Subscribe<ArchiHandler.SharedLibraryLockStatusCallback>(OnSharedLibraryLockStatus); ArchiWebHandler = new ArchiWebHandler(this); CardsFarmer = new CardsFarmer(this) { Paused = BotConfig.Paused }; Trading = new Trading(this); HeartBeatTimer = new Timer( async e => await HeartBeat().ConfigureAwait(false), null, TimeSpan.FromMinutes(1) + TimeSpan.FromMinutes(0.2 * Bots.Count), // Delay TimeSpan.FromMinutes(1) // Period ); Initialize().Forget(); }
public Task<uint> Connect(bool autoReconect, CancellationToken cancellationToken) { return Task.Run<uint>(() => { bool completed = false; uint version = 0; // get the GC handler, which is used for messaging DOTA var gcHandler = this.SteamClient.GetHandler<SteamGameCoordinator>(); // register a few callbacks we're interested in var cbManager = new CallbackManager(this.SteamClient); // these are registered upon creation to a callback manager, // which will then route the callbacks to the functions specified cbManager.Subscribe<SteamClient.ConnectedCallback>((SteamClient.ConnectedCallback callback) => { cancellationToken.ThrowIfCancellationRequested(); if (callback.Result == EResult.OK) { Trace.TraceInformation("Connected to Steam, Logging in '{0}'", this.Username); // get the steamuser handler, which is used for logging on after successfully connecting var UserHandler = this.SteamClient.GetHandler<SteamUser>(); UserHandler.LogOn(new SteamUser.LogOnDetails { Username = this.Username, Password = this.Password, SentryFileHash = this.Sentry, }); } else { Trace.TraceError("Unable to connect to Steam"); throw new Exception("Failed to Connect"); } }); cbManager.Subscribe<SteamClient.DisconnectedCallback>((SteamClient.DisconnectedCallback callback) => { cancellationToken.ThrowIfCancellationRequested(); Trace.TraceInformation("Disconnected from Steam."); if (autoReconect) { // delay a little to give steam some time to finalize the DC Thread.Sleep(TimeSpan.FromSeconds(1)); // reconect this.SteamClient.Connect(); } }); cbManager.Subscribe<SteamUser.LoggedOnCallback>((SteamUser.LoggedOnCallback callback) => { cancellationToken.ThrowIfCancellationRequested(); if (callback.Result == EResult.OK) { Trace.TraceInformation("Successfully logged on!"); // we've logged into the account // now we need to inform the steam server that we're playing dota (in order to receive GC messages) // steamkit doesn't expose the "play game" message through any handler, so we'll just send the message manually var gameMsg = new ClientMsgProtobuf<CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed); gameMsg.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed { game_id = new GameID(APPID), // or game_id = APPID, }); // send it off - notice here we're sending this message directly using the SteamClient this.SteamClient.Send(gameMsg); // delay a little to give steam some time to establish a GC connection to us Thread.Sleep(TimeSpan.FromSeconds(1)); // inform the dota GC that we want a session var helloMsg = new ClientGCMsgProtobuf<CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello); helloMsg.Body.engine = ESourceEngine.k_ESE_Source2; gcHandler.Send(helloMsg, APPID); } else if (callback.Result == EResult.AccountLogonDenied) { Trace.TraceInformation("Account {0}@{1} is denied.", this.Username, callback.EmailDomain); throw new Exception(string.Format("Account {0}@{1} is denied.", this.Username, callback.EmailDomain)); } else { Trace.TraceError("Failed to Login; Result {0}", callback.Result); throw new Exception("Failed to Login."); } }); cbManager.Subscribe<SteamGameCoordinator.MessageCallback>((SteamGameCoordinator.MessageCallback callback) => { cancellationToken.ThrowIfCancellationRequested(); if (callback.EMsg == (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome) { var msg = new ClientGCMsgProtobuf<CMsgClientWelcome>(callback.Message); version = msg.Body.version; Trace.TraceInformation("GC - Welcome Message"); completed = true; } }); // initiate the connection SteamClient.Connect(); while(completed == false) { cancellationToken.ThrowIfCancellationRequested(); // in order for the callbacks to get routed, they need to be handled by the manager cbManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } return version; }); }