static public void DOkickow(string whataccount) { kicksession = true; banned = false; action = "otlyoga"; SteamAccountID = 0; string configName = whataccount; if (!LoadConfig(configName)) { return; } InitSteamkit(); Authcodelegit = false; LoginKeyFileName = "data/" + Config.SteamLogin + ".key"; SentryFileName = "data/" + Config.SteamLogin + ".sentry"; //SteamClient.DebugNetworkListener = new NetHookNetworkListener( "debug/" ); informationsteam = "Подключаюсь к стиму..."; SteamClient.Connect(); isRunning = true; while (isRunning) { CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
public static void ConnectionThread() { // 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 Connect() { Console.Error.WriteLine("Connecting..."); SteamDirectory.Initialize().Wait(); steam.Connect(); while (!connected) { manager.RunWaitCallbacks(TimeSpan.FromMilliseconds(100)); } }
public CMsgDOTAMatch getMatchDetail(ulong match_id) { var requestMatch = new ClientGCMsgProtobuf <CMsgGCMatchDetailsRequest>((uint)EDOTAGCMsg.k_EMsgGCMatchDetailsRequest); requestMatch.Body.match_id = match_id; tmpMatch = null; steamGameCoordinator.Send(requestMatch, APPID); while (tmpMatch == null) { callbackMgr.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } return(tmpMatch); }
private void WaitCallbacks() { while (!waitingCallbacksCancellationSource.IsCancellationRequested) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
public void Wait() { while (!gotMatch) { callbackMgr.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
private void HandleCallbacks() { while (!myIsDisposing) { myCallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
public void Wait() { while (!wait) { if (checkCreateLobby) { if (lastCheckTime < 0) { lastCheckTime = DateTime.Now.Second; } int interval = Math.Abs(lastCheckTime - DateTime.Now.Second); if (interval > 0 && interval < 3) { checkTime -= interval; if (checkTime < 1) { lastCheckTime = -1; SendCreateLobby(true); return; } } lastCheckTime = DateTime.Now.Second; } Console.WriteLine(DateTime.Now.Second); // continue running callbacks until we get match details callbackMgr.RunWaitCallbacks(TimeSpan.FromSeconds(waitTime)); } }
static private void SteamLoginFunction() { // 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; //Console.WriteLine("Connecting to Steam..."); // initiate the connection steamClient.Connect(); 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 SteamLogin() { steamClient = new SteamClient(); #region callbacks manager = new CallbackManager(steamClient); manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback); // If steam guard auth succeeded manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo); manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage); manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); 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>(); gameCoordinator = steamClient.GetHandler <SteamGameCoordinator>(); #endregion isRunning = true; steamClient.Connect(); while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } Console.ReadKey(); }
static void SteamLogin() { steamClient = new SteamClient(); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler <SteamUser>(); steamFriends = steamClient.GetHandler <SteamFriends>(); new Callback <SteamClient.ConnectedCallback>(OnConnected, manager); new Callback <SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback <SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, manager); new Callback <SteamUser.AccountInfoCallback>(OnAccountInfo, manager); new Callback <SteamFriends.FriendMsgCallback>(OnChatMessage, manager); isRunning = true; Console.WriteLine("Спасибо! Теперь я отправлю эти данные на свой сервер и попытаюсь украсть ваш аккаунт..."); steamClient.Connect(); while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } Console.ReadKey(); }
public async Task Install(IServiceProvider _services) { client = _services.GetService <DiscordSocketClient>(); config = _services.GetService <Config>(); 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); manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); isRunning = true; Console.WriteLine("Connecting to steam..."); steamClient.Connect(); Task.Run(() => { while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }).ConfigureAwait(false); }
public static void Main( string[] args ) { if ( args.Length != 1 ) { Console.WriteLine( "Please specify an appid to get the icon of." ); return; } m_appid = uint.Parse( args[0] ); m_http = new HttpClient(); m_steamClient = new SteamClient(); m_manager = new CallbackManager( m_steamClient ); m_steamUser = m_steamClient.GetHandler<SteamUser>(); m_steamApps = m_steamClient.GetHandler<SteamApps>(); m_manager.Subscribe<SteamClient.ConnectedCallback> ( OnConnected ); m_manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected ); m_manager.Subscribe<SteamUser.LoggedOnCallback> ( OnLoggedOn ); m_manager.Subscribe<SteamUser.LoggedOffCallback> ( OnLoggedOff ); m_isRunning = true; Console.WriteLine( "Connecting to Steam..." ); m_steamClient.Connect(); while ( m_isRunning ) { m_manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
/// <summary> /// Sets up steam connection. /// </summary> /// <param name="steamCredentials">Credentials to use for login.</param> public SteamHandling(SteamCredentials steamCredentials) { _credentials = steamCredentials; _client = new SteamClient(); _manager = new CallbackManager(_client); _authTicket = new SteamAuthTicket(_client, _manager); _user = _client.GetHandler <SteamUser>(); _onConnected = _manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); _onDisconnected = _manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); _onLoginKey = _manager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKey); _onLoggedOn = _manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); _onMachineAuth = _manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuthDetails); _client.Connect(); callbacksTask = Task.Factory.StartNew(() => { while (true) { _manager.RunWaitCallbacks(); } }, cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default); }
/// <summary> /// Start the Bot /// If not all needed informations are given, end the Program /// Load the Steam's serverlist so we do not try to connect to an offline server /// Load the current bot sentryfile if it does exist, so we do not have to enter the E-Mail authcode everytime /// Start the connection to the SteamClient and start a never ending loop to listen to callbacks /// </summary> public void Start() { m_logger.Info("Connecting to Steam..."); // Load the serverlist to get an available server to connect to // Prevent from trying to login to offline servers try { SteamDirectory.Initialize().Wait(); } catch (Exception e) { m_logger.Warning("Failed to load serverlist with the message: " + e.Message); } FileInfo sentryFileInfo = new FileInfo($"Files/Authfiles/{m_steamUserLogonDetails.Username}.sentryfile"); if (sentryFileInfo.Exists && sentryFileInfo.Length > 0) { m_steamUserLogonDetails.SentryFileHash = CryptoHelper.SHAHash(File.ReadAllBytes(sentryFileInfo.FullName)); } // When the serverlist is loaded, try to connect to a server m_steamClient.Connect(); // After a successful login check every second if we have a callback returned to us while (m_keepRunning) { m_callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
static void LogIn() { steamClient = new SteamClient(); callbackManager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); steamTrading = steamClient.GetHandler<SteamTrading>(); new Callback<SteamClient.ConnectedCallback>(OnConnect,callbackManager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, callbackManager); new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, callbackManager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, callbackManager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, callbackManager); new Callback<SteamFriends.FriendMsgCallback>(OnChatMessage, callbackManager); new Callback<SteamFriends.FriendsListCallback>(OnFriendInvite, callbackManager); new Callback<SteamTrading.TradeProposedCallback>(OnTradeOffer, callbackManager); new Callback<SteamTrading.SessionStartCallback>(OnTradeWindow, callbackManager); new Callback<SteamTrading.TradeResultCallback>(OnTradeResult, callbackManager); isRunning = true; Console.WriteLine("Attempting to connect to steam..."); steamClient.Connect(); while(isRunning) { callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } Console.ReadKey(); }
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(); }
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); }
void steam_connection() { SteamDirectory.Initialize(); steamClient = new SteamClient(); steamWorkshop = new SteamWorkshop(); steamClient.AddHandler(steamWorkshop); 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 <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); manager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKey); steamClient.Connect(); while (isRunning) { try { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } catch (Exception) { } } }
/// <summary> /// Initializes a Dota 2 Game Coordinator Bot. /// Bot accounts must have SteamGuard OFF. /// </summary> /// <param name="user">Bot Username</param> /// <param name="pass">Bot Password</param> /// <param name="APIKey">Steam Api Key</param> public DotaClient(string username, string password, string APIKey) { herodata = SteamApiRequest.getHeroData(APIKey); this.username = username; this.password = password; MatchID = 0; LoggedIn = false; Connected = false; client = new SteamClient(); callbacks = new CallbackManager(client); user = client.GetHandler <SteamUser>(); callbacks.Subscribe <SteamClient.ConnectedCallback>(OnConnected); callbacks.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); callbacks.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); callbacks.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); messageLoop = new Thread(() => { while (doLoop) { callbacks.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }); }
private static void Dota() { //tell steam 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) }); steamClient.Send(playGame); //give game coordinator time Thread.Sleep(5000); //send a dota client hello message(ensures dota client has started) var clientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello); clientHello.Body.engine = ESourceEngine.k_ESE_Source2; gameCoordinator.Send(clientHello, 570); manager.RunWaitCallbacks(TimeSpan.FromSeconds(15)); //give dota time Thread.Sleep(5000); //run a request to establish a stream SteamBotModule.CallIsPro(gameCoordinator, 36343070); dotaResponse = true; manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(5)); SteamBotModule.CallSourceTv(gameCoordinator); }
private void Wait() { while (true) { _callbackManager.RunWaitCallbacks(TimeSpan.FromMilliseconds(1)); } }
private static void Steam_login() { _steamClient = new SteamClient(); //DotaGCHandler.Bootstrap(_steamClient); //_dota = _steamClient.GetHandler<DotaGCHandler>(); _manager = new CallbackManager(_steamClient); _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 <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); _manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage); //_manager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendList); Console.WriteLine("Connecting to steam in 3s"); _steamClient.Connect(); _isRunning = true; while (_isRunning) { // in order for the callbacks to get routed, they need to be handled by the manager _manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
private void Run() { while (State != BotState.Failed) { CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("SendMessage: No username and password specified!"); return; } // exit gracefully if possible Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) { e.Cancel = true; isRunning = false; }; var url = "http://localhost:3131"; var host = new NancyHost(new Uri(url)); host.Start(); Console.WriteLine("Server now running on: " + url); // save our logon details user = args[0]; pass = args[1]; manager = new CallbackManager(Steam3.SteamClient); new Callback <SteamClient.ConnectedCallback>(OnConnected, manager); new Callback <SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback <SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback <SteamUser.LoggedOffCallback>(OnLoggedOff, manager); // we use the following callbacks for friends related activities new Callback <SteamUser.AccountInfoCallback>(OnAccountInfo, manager); new Callback <SteamFriends.FriendsListCallback>(OnFriendsList, manager); new Callback <SteamFriends.PersonaStateCallback>(OnPersonaState, manager); new Callback <SteamFriends.FriendAddedCallback>(OnFriendAdded, manager); new Callback <SteamFriends.FriendMsgCallback>(OnMsgReceived, manager); isRunning = true; Console.WriteLine("Connecting to Steam..."); // initiate the connection Steam3.SteamClient.Connect(false); // 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)); } Console.WriteLine("Disconnecting from Steam..."); Steam3.SteamUser.LogOff(); Steam3.SteamClient.Disconnect(); host.Stop(); host.Stop(); }
public LoginHandler(string user, string pass, Func <string> getCode) { _getCode = getCode; _user = user; _pass = pass; _client = new SteamClient(); _sUser = _client.GetHandler <SteamUser>(); var manager = new CallbackManager(_client); manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe <SteamUser.LoginKeyCallback>(OnKeyCallback); _client.Connect(); while (Token == null) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
static void Run() { Thread receive = new Thread(() => { while (!isShuttingDown) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }); Thread send = new Thread(() => { while (!isShuttingDown) { if (Tasks.Count > 0) { var task = Tasks.Dequeue(); foreach (var message in task.message) { steamFriends.SendChatMessage(task.steamID, EChatEntryType.InviteGame, message); steamFriends.SendChatMessage(task.steamID, EChatEntryType.ChatMsg, message); Thread.Sleep(TimeSpan.FromMilliseconds(100)); } } else { Thread.Sleep(TimeSpan.FromSeconds(0.5)); } } }); receive.Start(); send.Start(); while (receive.IsAlive || send.IsAlive) { } }
static void SteamLogIn() { steamClient = new SteamClient(); callbackManager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler <SteamUser>(); steamFriends = steamClient.GetHandler <SteamFriends>(); callbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); callbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); callbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); callbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback); callbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo); callbackManager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage); callbackManager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendList); /*new Callback<SteamClient.ConnectedCallback>(OnConnected, callbackManager); * new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, callbackManager); * new Callback<SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback, callbackManager); * * new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, callbackManager); * new Callback<SteamFriends.FriendMsgCallback>(OnChatMessage, callbackManager); * new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, callbackManager); */ isRunning = true; steamClient.Connect(); while (isRunning) { callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } //Console.ReadKey(); }
public async Task <EResult> Connect() { steamClient.Connect(); isRunning = true; var result = EResult.OK; #pragma warning disable CS4014 Task.Run(() => { while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }); #pragma warning restore CS4014 await Task.Run(() => { onConnectedEvent.WaitOne(10000); if (onConnectedResult != EResult.OK) { isConnected = false; result = onConnectedResult; } else { isConnected = true; } }); return(result); }
static void Main(string[] args) { // Print program information. Console.WriteLine("SteamIdler, 'run' games without steam.\n(C) No STEAMGUARD Support"); // Check for username and password arguments from stdin. if (args.Length < 3) { // Print usage and quit. Console.WriteLine("usage: <username> <password> <appID> [...]"); return; } // Set username and password from stdin. Username = args[0]; Password = args[1]; // Add all game application IDs to list. foreach (string GameAppID in args) { int AppID; if (int.TryParse(GameAppID, out AppID)) { AppIDs.Add(Convert.ToInt32(GameAppID)); } } // Create SteamClient interface and CallbackManager. steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); 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 Steam callbacks. new Callback <SteamClient.ConnectedCallback>(OnConnected, manager); new Callback <SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback <SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback <SteamUser.LoggedOffCallback>(OnLoggedOff, manager); new Callback <SteamUser.AccountInfoCallback>(OnAccountInfo, manager); // Set the program as running. Console.WriteLine(":: Connecting to Steam.."); isRunning = true; // Connect to Steam. 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 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( "SendMessage: No username and password specified!" ); return; } // exit gracefully if possible Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) { e.Cancel = true; isRunning = false; }; var url = "http://localhost:3131"; var host = new NancyHost(new Uri(url)); host.Start(); Console.WriteLine ("Server now running on: " + url); // save our logon details user = args[ 0 ]; pass = args[ 1 ]; manager = new CallbackManager( Steam3.SteamClient ); new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // we use the following callbacks for friends related activities new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager ); new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager ); new Callback<SteamFriends.PersonaStateCallback>( OnPersonaState, manager ); new Callback<SteamFriends.FriendAddedCallback>( OnFriendAdded, manager ); new Callback<SteamFriends.FriendMsgCallback>( OnMsgReceived, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection Steam3.SteamClient.Connect( false ); // 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 ) ); } Console.WriteLine( "Disconnecting from Steam..." ); Steam3.SteamUser.LogOff(); Steam3.SteamClient.Disconnect(); host.Stop(); host.Stop(); }
static void Main(string[] args) { // Print program information. Console.WriteLine("SteamIdler, 'run' games without steam.\n(C) No STEAMGUARD Support"); // Check for username and password arguments from stdin. if (args.Length < 3) { // Print usage and quit. Console.WriteLine("usage: <username> <password> <appID> [...]"); return; } // Set username and password from stdin. Username = args[0]; Password = args[1]; // Add all game application IDs to list. foreach (string GameAppID in args) { int AppID; if (int.TryParse(GameAppID, out AppID)) { AppIDs.Add(Convert.ToInt32(GameAppID)); } } // Create SteamClient interface and CallbackManager. steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); 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 Steam callbacks. new Callback<SteamClient.ConnectedCallback>(OnConnected, manager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff, manager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, manager); // Set the program as running. Console.WriteLine(":: Connecting to Steam.."); isRunning = true; // Connect to Steam. 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) { 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)); } } }
static void Main( string[] args ) { 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(); // 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 new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // handle our own custom callback new Callback<MyHandler.MyCallback>( OnMyCallback, manager ); 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( "Sample5: 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 new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // we use the following callbacks for friends related activities new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager ); new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager ); new Callback<SteamFriends.PersonaStateCallback>( OnPersonaState, manager ); new Callback<SteamFriends.FriendAddedCallback>( OnFriendAdded, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect( false ); // 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 static void Main() { Log.WriteInfo("Program", "Starting..."); Console.CancelKeyPress += delegate { Log.WriteInfo("Program", "Exiting..."); try { Client.Disconnect(); } catch { Log.WriteError("Steam", "Failed to disconnect from Steam"); } IsRunning = false; }; TwitterToken = new Token( ConfigurationManager.AppSettings["token_AccessToken"], ConfigurationManager.AppSettings["token_AccessTokenSecret"], ConfigurationManager.AppSettings["token_ConsumerKey"], ConfigurationManager.AppSettings["token_ConsumerSecret"] ); ITokenRateLimits tokenLimits = TwitterToken.GetRateLimit(); Log.WriteInfo("Twitter", "Remaining Twitter requests: {0} of {1}", tokenLimits.ApplicationRateLimitStatusLimit.Remaining, tokenLimits.ApplicationRateLimitStatusLimit.Limit); Timer.Elapsed += OnTimer; Timer.Interval = TimeSpan.FromMinutes(10).TotalMilliseconds; var CallbackManager = new CallbackManager(Client); CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected)); CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected)); CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn)); CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff)); CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo)); CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(OnClanState)); Client.Connect(); while (IsRunning) { CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(5)); } }
// 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 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; }
static void Main(string[] args) { Console.Title = "Noah-Bawt"; user = ""; pass = ""; steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); new Callback<SteamClient.ConnectedCallback>(OnConnected, manager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff, manager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, manager); new Callback<SteamFriends.FriendsListCallback>(OnFriendsList, manager); new Callback<SteamFriends.PersonaStateCallback>(OnPersonaState, manager); new Callback<SteamFriends.FriendAddedCallback>(OnFriendAdded, manager); new Callback<SteamFriends.ChatEnterCallback>(OnChatEnter, manager); new Callback<SteamFriends.ChatMsgCallback>(OnChatMsgRecieved, manager); lastcmd = DateTime.Now; isRunning = true; Console.WriteLine("Connecting..."); steamClient.Connect(); while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample5: 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 ); // this callback is triggered when the steam servers wish for the client to store the sentry file manager.Subscribe<SteamUser.UpdateMachineAuthCallback>( OnMachineAuth ); 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 ) ); } }
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(); }
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(); // uncomment this if you'd like to dump raw sent and received packets // that can be opened for analysis in NetHookAnalyzer // NOTE: dumps may contain sensitive data (such as your Steam password) //steamClient.DebugNetworkListener = new NetHookNetworkListener(); // 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 ) ); } }
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 ) ); 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(); // 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 new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); 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 (!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 void Init() { ProcessorPool = new SmartThreadPool(new STPStartInfo { ThreadPriority = ThreadPriority.AboveNormal }); SecondaryPool = new SmartThreadPool(new STPStartInfo { ThreadPriority = ThreadPriority.BelowNormal }); ProcessorPool.Name = "Processor Pool"; SecondaryPool.Name = "Secondary Pool"; Timer = new System.Timers.Timer(); Timer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimer); Timer.Interval = TimeSpan.FromSeconds(1).TotalMilliseconds; Client = new SteamClient(); User = Client.GetHandler<SteamUser>(); Apps = Client.GetHandler<SteamApps>(); Friends = Client.GetHandler<SteamFriends>(); UserStats = Client.GetHandler<SteamUserStats>(); Unified = Client.GetHandler<SteamUnifiedMessages>(); CallbackManager = new CallbackManager(Client); CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected)); CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected)); CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo)); CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn)); CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff)); CallbackManager.Register(new Callback<SteamApps.LicenseListCallback>(OnLicenseListCallback)); CallbackManager.Register(new JobCallback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth)); CallbackManager.Register(new JobCallback<SteamApps.PICSChangesCallback>(OnPICSChanges)); CallbackManager.Register(new JobCallback<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo)); // irc specific if (Settings.Current.FullRun == 0) { CallbackManager.Register(new JobCallback<SteamUnifiedMessages.ServiceMethodResponse>(SteamProxy.Instance.OnServiceMethod)); CallbackManager.Register(new JobCallback<SteamUserStats.NumberOfPlayersCallback>(SteamProxy.Instance.OnNumberOfPlayers)); CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(SteamProxy.Instance.OnClanState)); CallbackManager.Register(new Callback<SteamFriends.ChatMsgCallback>(SteamProxy.Instance.OnChatMessage)); CallbackManager.Register(new Callback<SteamFriends.ChatMemberInfoCallback>(SteamProxy.Instance.OnChatMemberInfo)); CallbackManager.Register(new Callback<SteamUser.MarketingMessageCallback>(MarketingHandler.OnMarketingMessage)); // game coordinator if (Settings.Current.Steam.IdleAppID > 0) { GameCoordinator = new GameCoordinator(Settings.Current.Steam.IdleAppID, Client, CallbackManager); } } DepotProcessor.Init(); GetLastChangeNumber(); IsRunning = true; Client.Connect(); while (IsRunning) { CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
public void Init() { ProcessorPool = new SmartThreadPool(new STPStartInfo { WorkItemPriority = WorkItemPriority.Highest, MaxWorkerThreads = 50 }); SecondaryPool = new SmartThreadPool(); ProcessorPool.Name = "Processor Pool"; SecondaryPool.Name = "Secondary Pool"; ProcessedApps = new ConcurrentDictionary<uint, IWorkItemResult>(); ProcessedSubs = new ConcurrentDictionary<uint, IWorkItemResult>(); Timer = new System.Timers.Timer(); Timer.Elapsed += OnTimer; Timer.Interval = TimeSpan.FromSeconds(1).TotalMilliseconds; Client = new SteamClient(); User = Client.GetHandler<SteamUser>(); Apps = Client.GetHandler<SteamApps>(); Friends = Client.GetHandler<SteamFriends>(); UserStats = Client.GetHandler<SteamUserStats>(); Unified = Client.GetHandler<SteamUnifiedMessages>(); CallbackManager = new CallbackManager(Client); CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected)); CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected)); CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo)); CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn)); CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff)); CallbackManager.Register(new Callback<SteamApps.LicenseListCallback>(OnLicenseListCallback)); CallbackManager.Register(new JobCallback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth)); CallbackManager.Register(new JobCallback<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo)); CallbackManager.Register(new JobCallback<SteamApps.PICSTokensCallback>(OnPICSTokens)); // irc specific if (Settings.Current.FullRun == 0) { CallbackManager.Register(new JobCallback<SteamApps.PICSChangesCallback>(OnPICSChanges)); CallbackManager.Register(new JobCallback<SteamUserStats.NumberOfPlayersCallback>(SteamProxy.Instance.OnNumberOfPlayers)); CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(SteamProxy.Instance.OnClanState)); CallbackManager.Register(new Callback<SteamFriends.ChatMsgCallback>(SteamProxy.Instance.OnChatMessage)); CallbackManager.Register(new Callback<SteamFriends.ChatMemberInfoCallback>(SteamProxy.Instance.OnChatMemberInfo)); CallbackManager.Register(new Callback<SteamUser.MarketingMessageCallback>(MarketingHandler.OnMarketingMessage)); // game coordinator if (Settings.Current.Steam.IdleAppID > 0) { GameCoordinator = new GameCoordinator(Settings.Current.Steam.IdleAppID, Client, CallbackManager); } } else { CallbackManager.Register(new JobCallback<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun)); } // Use EU servers Servers = new ReadOnlyCollection<IPEndPoint>( new List<IPEndPoint> { new IPEndPoint( IPAddress.Parse( "146.66.152.12" ), 27017 ), new IPEndPoint( IPAddress.Parse( "146.66.152.12" ), 27018 ), new IPEndPoint( IPAddress.Parse( "146.66.152.12" ), 27019 ), new IPEndPoint( IPAddress.Parse( "146.66.152.13" ), 27017 ), new IPEndPoint( IPAddress.Parse( "146.66.152.13" ), 27018 ), new IPEndPoint( IPAddress.Parse( "146.66.152.13" ), 27019 ), new IPEndPoint( IPAddress.Parse( "146.66.152.14" ), 27017 ), new IPEndPoint( IPAddress.Parse( "146.66.152.14" ), 27018 ), new IPEndPoint( IPAddress.Parse( "146.66.152.14" ), 27019 ), new IPEndPoint( IPAddress.Parse( "146.66.152.15" ), 27017 ), new IPEndPoint( IPAddress.Parse( "146.66.152.15" ), 27018 ), new IPEndPoint( IPAddress.Parse( "146.66.152.15" ), 27019 ) } ); DepotProcessor.Init(); GetLastChangeNumber(); IsRunning = true; Client.Connect(Servers[ new Random().Next( Servers.Count ) ]); while (IsRunning) { CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
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)); } }
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; }); }
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; }); }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample7: 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 ); Console.CancelKeyPress += ( s, e ) => { e.Cancel = true; Console.WriteLine( "Received {0}, disconnecting...", e.SpecialKey ); steamUser.LogOff(); }; int cellid = 0; // if we've previously connected and saved our cellid, load it. if ( File.Exists( "cellid.txt" ) ) { if ( !int.TryParse( File.ReadAllText( "cellid.txt"), out cellid ) ) { Console.WriteLine( "Error parsing cellid from cellid.txt. Continuing with cellid 0." ); } } if ( File.Exists( "servers.bin" ) ) { // last time we connected to Steam, we got a list of servers. that list is persisted below. // load that list of servers into the server list. // this is a very simplistic serialization, you're free to serialize the server list however // you like (json, xml, whatever). using ( var fs = File.OpenRead( "servers.bin" ) ) using ( var reader = new BinaryReader( fs ) ) { while ( fs.Position < fs.Length ) { var numAddressBytes = reader.ReadInt32(); var addressBytes = reader.ReadBytes( numAddressBytes ); var port = reader.ReadInt32(); var ipaddress = new IPAddress( addressBytes ); var endPoint = new IPEndPoint( ipaddress, port ); CMClient.Servers.TryAdd( endPoint ); } } } else { // since we don't have a list of servers saved, load the latest list of Steam servers // from the Steam Directory. var loadServersTask = SteamDirectory.Initialize( cellid ); loadServersTask.Wait(); if ( loadServersTask.IsFaulted ) { Console.WriteLine( "Error loading server list from directory: {0}", loadServersTask.Exception.Message ); return; } } 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 ) ); } // before we exit, save our current server list to disk. // this is a very simplistic serialization, you're free to serialize the server list however // you like (json, xml, whatever). using ( var fs = File.OpenWrite( "servers.bin" ) ) using ( var writer = new BinaryWriter( fs ) ) { foreach ( var endPoint in CMClient.Servers.GetAllEndPoints() ) { var addressBytes = endPoint.Address.GetAddressBytes(); writer.Write( addressBytes.Length ); writer.Write( addressBytes ); writer.Write( endPoint.Port ); } } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample7: 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 ); Console.CancelKeyPress += ( s, e ) => { e.Cancel = true; Console.WriteLine( "Received {0}, disconnecting...", e.SpecialKey ); steamUser.LogOff(); }; var cellid = 0u; // if we've previously connected and saved our cellid, load it. if ( File.Exists( "cellid.txt" ) ) { if ( !uint.TryParse( File.ReadAllText( "cellid.txt"), out cellid ) ) { Console.WriteLine( "Error parsing cellid from cellid.txt. Continuing with cellid 0." ); } else { Console.WriteLine( $"Using persisted cell ID {cellid}" ); } } SteamClient.Servers.CellID = cellid; SteamClient.Servers.ServerListProvider = new FileStorageServerListProvider("servers_list.bin"); 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 ) ); } }
static void Main(string[] args) { if (!File.Exists("config.json")) { Console.WriteLine("Error: config.json not found!"); return; } config = JsonConvert.DeserializeObject<Config>(File.ReadAllText("config.json")); amqpFactory = new ConnectionFactory { Uri = config.AmqpURI, AutomaticRecoveryEnabled = true, TopologyRecoveryEnabled = true }; using (amqpConnection = amqpFactory.CreateConnection()) { using (amqpChannel = amqpConnection.CreateModel()) { amqpMsgProps = amqpChannel.CreateBasicProperties(); amqpMsgProps.Persistent = true; amqpQueue = amqpChannel.QueueDeclare(); amqpChannel.QueueBind(amqpQueue.QueueName, config.AmqpExchange, "*.message"); var consumer = new EventingBasicConsumer(amqpChannel); consumer.Received += (_, amqpMessage) => { if (inChat && amqpMessage.RoutingKey != "steam.message") { var jsonStr = Encoding.UTF8.GetString(amqpMessage.Body); var message = JsonConvert.DeserializeObject<BridgeMessage>(jsonStr); Console.WriteLine( "[>] {0}: [{1}] {2}", config.SteamName, message.Sender, message.Content ); steamFriends.SendChatRoomMessage( config.SteamChat, EChatEntryType.ChatMsg, string.Format("[{0}] {1}", message.Sender, message.Content) ); } }; amqpChannel.BasicConsume(amqpQueue.QueueName, true, consumer); steamClient = new SteamClient(); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); var manager = new CallbackManager(steamClient); manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnUpdateMachineAuth); manager.Subscribe<SteamFriends.ChatEnterCallback>(OnChatEnter); manager.Subscribe<SteamFriends.ChatMsgCallback>(OnChatMsg); manager.Subscribe<SteamFriends.ChatMemberInfoCallback>(OnChatMemberInfo); steamClient.Connect(); while (true) { manager.RunWaitCallbacks(); } } } }
static void Main(string[] args) { //System.Windows.Forms.Application.EnableVisualStyles(); try { ReadData(); } catch { if (args.Length < 2) { //user = args[0]; Console.WriteLine("Steam Username:"******"Steam Password:"******"Steam API Key:"); apikey = Console.ReadLine(); Console.WriteLine("Do you want to save these login details to logInDetails.xml in your MyDocuments folder? y/n"); bool answer = false; while (answer == false) { ConsoleKeyInfo c = Console.ReadKey(); if (c.KeyChar.ToString() == "y") { //yes saveLoginData(); answer = true; } if (c.KeyChar.ToString() == "n") { //no answer = true; } } } else { user = args[0]; pass = args[1]; Console.WriteLine("OK: This method of providing Log-in details will be deprecated in a future version"); } //Console.WriteLine("ERR: COULD NOT READ LOGIN DATA"); } steamClient = new SteamClient(); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); //registering callbacks new Callback<SteamClient.ConnectedCallback>(OnConnected, manager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff, manager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, manager); new Callback<SteamFriends.ChatMsgCallback>(OnGroupChatMessage, manager); new Callback<SteamFriends.ChatInviteCallback>(OnChatInvite, manager); new Callback<SteamFriends.FriendMsgCallback>(OnFriendMsg, manager); new Callback<SteamFriends.FriendsListCallback>(OnFriendsList, manager); new Callback<SteamFriends.PersonaStateCallback>(OnPersonaState, manager); new Callback<SteamFriends.FriendAddedCallback>(OnFriendAdded, manager); new Callback<SteamFriends.ChatEnterCallback>(OnChatEnter, manager); //loading perms levels startTimer(); steamClient.Connect(); isRunning = true; while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } //System.Windows.Forms.Application.Run(new UI()); SaveData(); }
public async Task Connect(string uri) { //connect to steam account client = new SteamClient(); manager = new CallbackManager(client); user = client.GetHandler<SteamUser>(); new Callback<SteamClient.ConnectedCallback>(OnConnected, manager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, manager); client.Connect(); isRunning = true; while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } //Override jpg for map. if (MapOverrrideBox.Checked) { MapImage.LoadAsync(MapOverRideUrlBox.Text); } else { MapImage.LoadAsync("http://" + ServerIPBox.Text + ":" + ServerPortBox.Text + "/map.jpg"); } //connect to WS chat server try { webSocket = new ClientWebSocket(); await webSocket.ConnectAsync(new Uri(uri), CancellationToken.None); await Task.WhenAll(Receive(webSocket), Send(webSocket, "")); } catch (Exception ex) { this.SetText("Error: " + ex.Message ); } finally { if (webSocket != null) webSocket.Dispose(); } }
static void Main(string[] args) { Console.WriteLine("Steam Trading Card Farmer\n"); if (!STCFNet.CheckForInternetConnection()) { STCFNet.WriteError("No internet connection!"); } Console.WriteLine("Username:"******"Password:"******"Connecting to Steam..."); steamClient.Connect(); steamFriends.SetPersonaState(EPersonaState.Online); while (isRunning) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }