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);
}
internal async Task Start()
{
if (isRunning && steamClient.IsConnected)
{
Status = StatusEnum.Connected;
return;
}
initialized = false;
var config = BotConfig.Load();
if (config != BotConfig)
{
BotConfig = config;
}
if (!string.IsNullOrWhiteSpace(BotConfig.SteamAuthCode))
{
steamAuth = new CSteamAuth();
if (File.Exists($"{SMAForm.ConfigDirectory}{BotName}.sga"))
{
steamAuth.LoadAuthenticator(BotConfig.SteamAuthCode, $"{SMAForm.ConfigDirectory}{BotName}.sga");
}
}
isRunning = true;
Task.Run(() => CallbacksHandler()).Forget();
Log("Connecting to steam...", LogType.Info);
Status = StatusEnum.Connecting;
steamClient.Connect();
}
/// <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));
}
}
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 bool Connect()
{
if (Disabled || (WaitingForCode && AuthCode == null && TwoFactorCode == null))
{
return(false);
}
LoggedIn = false;
Logger.Debug(PREFIX + "Connecting...");
steamClient.Connect();
return(true);
}
public void Auth()
{
stop = false;
loginInfo.LoginFailCount = 0;
steamUser = steamClient.GetHandler <SteamUser>();
SteamFriends = steamClient.GetHandler <SteamFriends>();
SubscribeToEvents();
steamClient.Connect();
}
public void Tick()
{
Client.Connect();
var timeout = TimeSpan.FromSeconds(5);
while (IsRunning)
{
CallbackManager.RunWaitCallbacks(timeout);
}
}
/// <summary>
/// Starts the callback thread and connects to Steam via SteamKit2.
/// </summary>
/// <remarks>
/// THIS NEVER RETURNS.
/// </remarks>
/// <returns><c>true</c>. See remarks</returns>
public bool StartBot()
{
IsRunning = true;
Log.Info("Connecting...");
if (!botThread.IsBusy)
{
botThread.RunWorkerAsync();
}
SteamClient.Connect();
Log.Success("Done Loading Bot!");
return(true); // never get here
}
/// <summary>
/// Starts the callback thread and connects to Steam via SteamKit2.
/// </summary>
/// <remarks>
/// THIS NEVER RETURNS.
/// </remarks>
/// <returns><c>true</c>. See remarks</returns>
public void StartBot()
{
System.Diagnostics.Debug.WriteLine("Connecting...");
//if (!backgroundWorker.IsBusy)
// // background worker is not running
// backgroundWorker.RunWorkerAsync();
SteamClient.Connect();
System.Diagnostics.Debug.WriteLine("Done Loading Bot!");
}
public void Connect()
{
//SteamClient.Servers.CellID = 148;
//SteamClient.Servers.ServerListProvider = new FileStorageServerListProvider("servers_list.bin");
SteamDirectory.Initialize().Wait();
steamClient.Connect();
while (!isStartOver)
{
// continue running callbacks until we get match details
callbackMgr.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}
public void Connect(String user, String pass)
{
isRunning = true;
username = user;
password = pass;
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 public void OnDisconnected(SteamClient.DisconnectedCallback callback)
{
if (callback == null)
{
return;
}
informationsteam = (String.Format("Disconnecting from steam! Reconnecting..."));
Thread.Sleep(TimeSpan.FromSeconds(5));
SteamClient.Connect();
}
void OnDisconnect(SteamClient.DisconnectedCallback callback)
{
setStatus("Disconnected from Steam!");
if (doReconnect && !callback.UserInitiated)
{
Task.Delay(TimeSpan.FromSeconds(5)).ContinueWith(x => steamClient.Connect());
}
else if (callback.UserInitiated)
{
isRunning = false;
}
}
static public void OnDisconnected(SteamClient.DisconnectedCallback callback)
{
if (callback == null)
{
return;
}
informationsteam = (String.Format("Отключен от стима! Переподключаюсь..."));
Thread.Sleep(TimeSpan.FromSeconds(5));
SteamClient.Connect();
}
public static void Main()
{
Console.Title = "SteamToTwitter";
Log("Starting...");
Console.CancelKeyPress += delegate
{
Log("Exiting...");
try
{
User.LogOff();
Client.Disconnect();
}
catch
{
Log("Failed to disconnect from Steam");
}
IsRunning = false;
};
Configuration = JsonConvert.DeserializeObject <Configuration>(File.ReadAllText("settings.json"), new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Error
});
Twitter = new TinyTwitter.TinyTwitter(Configuration.Twitter);
var 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 <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
callbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
callbackManager.Subscribe <SteamFriends.ClanStateCallback>(OnClanState);
Client.Connect();
var reconnectTime = TimeSpan.FromHours(6);
new Timer(_ => Client.Disconnect(), null, reconnectTime, reconnectTime);
while (IsRunning)
{
callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(5));
}
}
public void Tick()
{
Client.Connect();
while (IsRunning)
{
CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(5));
if (IsLoggedOn)
{
Apps.PICSGetChangesSince(PreviousChangeNumber, true, true);
}
}
}
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 SteamBot(string newUser, string newPass)
{
// Bot user and password
user = newUser;
pass = newPass;
// 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 );
// we use the following callbacks for friends related activities
new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager );
new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager );
new Callback<SteamFriends.FriendMsgCallback> (OnFriendMessage, manager);
// initiate the connection
steamClient.Connect();
// Make sure the main loop runs
isRunning = true;
}
private Task Connect()
{
var taskCompletionSource = TaskHelper.CreateResultlessTaskCompletionSourceWithTimeout(myWaitTimeInMilliseconds, $"Steam client didn't connect within {myWaitTimeInMilliseconds} milliseconds.");
if (mySteamClient.IsConnected)
{
taskCompletionSource.SetResult();
}
else
{
var connectedCallbackRegistration = myCallbackManager.Subscribe <SteamClient.ConnectedCallback>((callback) =>
{
myLogger.LogTrace("Successfully connected to steam");
taskCompletionSource.SetResult();
UnregisterCallback(CallbackType.Connected);
});
myRegisteredCallbacks.Add(CallbackType.Connected, connectedCallbackRegistration);
mySteamClient.Connect();
myLogger.LogTrace("Connecting to Steam...");
}
return(taskCompletionSource.Task);
}
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);
}
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);
}
private void DisconnectedCallback(SteamClient.DisconnectedCallback disconnected)
{
bDidDisconnect = true;
if (disconnected.UserInitiated || bExpectingDisconnectRemote)
{
Log.Info("Disconnected from Steam");
}
else if (connectionBackoff >= 10)
{
Log.Info("Could not connect to Steam after 10 tries");
Abort(false);
}
else if (!bAborted)
{
if (bConnecting)
{
Log.Info("Connection to Steam failed. Trying again");
}
else
{
Log.Info("Lost connection to Steam. Reconnecting");
}
Thread.Sleep(1000 * ++connectionBackoff);
steamClient.Connect();
}
}
static void OnDisconnected(SteamClient.DisconnectedCallback callback)
{
Console.WriteLine("\n[i] {0} is reconnecting to Steam!\n[i] This is normal!", user);
Thread.Sleep(TimeSpan.FromSeconds(5));
steamClient.Connect();
}
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();
}
public SteamAPIService(ILogger <SteamCMDService> logger)
{
_logger = logger;
// app_info_print
// 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);
_logger.LogInformation("Connecting to Steam...");
steamClient.Connect();
manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(15));
}
public Bot(Configuration.BotInfo config, string apiKey, bool debug = false) {
sql = new Sql();
Username = config.Username;
Password = config.Password;
DisplayName = config.DisplayName;
Admins = config.Admins;
id = config.Id;
this.apiKey = apiKey;
TradeListener = new ScrapTrade(this);
TradeListenerInternal = new ExchangeTrade(this);
TradeListenerAdmin = new AdminTrade(this);
List<object[]> result = sql.query("SELECT text, response FROM responses");
foreach (object[] row in result) {
responses.Add(((string) row[0]).ToLower(), (string) row[1]);
}
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler<SteamTrading>();
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
queueHandler = new QueueHandler(this);
SteamClient.Connect();
while (true) {
Update();
}
}
/// <summary>
/// Starts the callback thread and connects to Steam via SteamKit2.
/// </summary>
/// <remarks>
/// THIS NEVER RETURNS.
/// </remarks>
/// <returns><c>true</c>. See remarks</returns>
public bool StartBot()
{
log.Info("Connecting...");
if (!backgroundWorker.IsBusy)
{
// background worker is not running
backgroundWorker.RunWorkerAsync();
}
SteamClient.Connect();
log.Success("Done Loading Bot!");
return(true); // never get here
}
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();
}
public async Task <bool> Logon(string user = "******", string pw = "")
{
if (user == null)
{
throw new ArgumentNullException("User can't be null!");
}
if (user != "anonymous" && pw != "")
{
throw new ArgumentNullException("Password can't be null if user is not anonymous!");
}
Username = user;
password = pw;
logonTaskCompletionSource = new TaskCompletionSource <bool>();
steamUser = steamClient.GetHandler <SteamUser>();
cbManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
cbManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
cbManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
cbManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
Log.Info("Connecting to Steam...");
steamClient.Connect();
await logonTaskCompletionSource.Task;
return(logonTaskCompletionSource.Task.Result);
}
static void OnDisconnected(SteamClient.DisconnectedCallback callback)
{
Console.WriteLine("\n{0} Disconnected From Steam, Reconnecting In 5 Seconds...\n", user);
Thread.Sleep(TimeSpan.FromSeconds(5));
steamClient.Connect();
}
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 void Connect()
{
Console.WriteLine("Connecting to Steam...");
// begin the connection to steam
client.Connect();
}
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));
}
}
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)
{
}
}
}
public static void Connect()
{
Client = new SteamClient(ProtocolType.Udp);
Friends = Client.GetHandler<SteamFriends>();
User = Client.GetHandler<SteamUser>();
Chat = new Chat();
Client.Connect();
}
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 Bot(Configuration.BotInfo config, string apiKey, bool debug = false)
{
Username = config.Username;
Password = config.Password;
DisplayName = config.DisplayName;
ChatResponse = config.ChatResponse;
Admins = config.Admins;
this.apiKey = apiKey;
AuthCode = null;
TradeListener = new TradeEnterTradeListener(this);
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler<SteamTrading>();
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
SteamClient.Connect();
Thread CallbackThread = new Thread(() => // Callback Handling
{
while (true)
{
CallbackMsg msg = SteamClient.WaitForCallback (true);
HandleSteamMessage (msg);
}
});
new Thread(() => // Trade Polling if needed
{
while (true)
{
Thread.Sleep (800);
if (CurrentTrade != null)
{
try
{
CurrentTrade.Poll ();
}
catch (Exception e)
{
Console.Write ("Error polling the trade: ");
Console.WriteLine (e);
}
}
}
}).Start ();
CallbackThread.Start();
CallbackThread.Join();
}
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( "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( "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( "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( "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 ) );
}
}
// 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));
}
}
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));
}
}
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 ) );
}
}
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)
{
// TODO: Add check for instance already running
//login info
string userID = ConfigurationManager.AppSettings["userID"];
string userPW = ConfigurationManager.AppSettings["userPW"];
string botName = ConfigurationManager.AppSettings["botName"];
List<SteamID> chatRooms = new List<SteamID>();
ulong chatSteamID;
if (ulong.TryParse(ConfigurationManager.AppSettings["chatSteamID"], out chatSteamID))
{
//List of Chats to join
// TODO: multiple chatrooms
chatRooms.Add(chatSteamID);
}
else
{
Console.WriteLine("Exit Code 10: Failed to Load SteamID");
Environment.Exit(10);
}
//Initiliaze Steam Client
SteamClient steamClient = new SteamClient();
SteamUser steamUsr = steamClient.GetHandler<SteamUser>();
SteamFriends steamFrds = steamClient.GetHandler<SteamFriends>();
//Connect to Steam Network
steamClient.Connect();
while (true)
{
// start listening
CallbackMsg msg = steamClient.WaitForCallback(true);
msg.Handle<SteamClient.ConnectedCallback>(callback =>
{
if (callback.Result != EResult.OK)
{
Console.WriteLine("Exit Code 1: Failed to Connect to Steam Network - " + callback.Result.ToString());
Environment.Exit(1);
// connect fail
}
else
{
Console.WriteLine("Connected to Steam Network");
steamUsr.LogOn(new SteamUser.LogOnDetails
{
Username = userID,
Password = userPW,
});
}
});
msg.Handle<SteamUser.LoggedOnCallback>(callback =>
{
if (callback.Result != EResult.OK)
{
Console.WriteLine("Exit Code 2: Logon Failure - " + callback.Result.ToString());
//Environment.Exit(2);
// logon fail
}
else
{
Console.WriteLine("Logged into Steam Network");
// Join Chat
// if you set PersonaState without setting PersonaName it goes to [unknown] and GetPersonaName doesn't work?
//steamFrds.SetPersonaName(steamFrds.GetPersonaName());
steamFrds.SetPersonaName(botName);
steamFrds.SetPersonaState(EPersonaState.Online);
foreach (SteamID steamID in chatRooms)
{
steamFrds.JoinChat(steamID);
}
}
});
msg.Handle<SteamFriends.ChatEnterCallback>(callback =>
{
if (callback.EnterResponse != EChatRoomEnterResponse.Success)
{
Console.WriteLine("Exit Code 3: Failure to Enter Chat" + callback.EnterResponse.ToString());
//Environment.Exit(3);
// join chat fail
}
else
{
Console.WriteLine("Joined Chat");
foreach (SteamID steamID in chatRooms)
{
steamFrds.SendChatRoomMessage(steamID, EChatEntryType.ChatMsg, "Now listening");
}
}
});
msg.Handle<SteamFriends.ChatMsgCallback>(callback =>
{
// TODO: Handle this in BotCommandHandler.cs
BotCommandHandler cmd = new BotCommandHandler();
foreach (SteamID steamID in chatRooms)
{
if (cmd.isCommand(callback.Message))
{
steamFrds.SendChatRoomMessage(steamID, EChatEntryType.ChatMsg, "Acknowledged. Processing...");
string retMsg = cmd.CommandHandler(callback.Message);
if (!string.IsNullOrEmpty(retMsg))
{
steamFrds.SendChatRoomMessage(steamID, EChatEntryType.ChatMsg, cmd.CommandHandler(callback.Message));
}
}
}
});
}
}
public Bot(Configuration.BotInfo config, string apiKey, UserHandlerCreator handlerCreator, bool debug = false)
{
Username = config.Username;
Password = config.Password;
DisplayName = config.DisplayName;
ChatResponse = config.ChatResponse;
MaximumTradeTime = config.MaximumTradeTime;
MaximiumActionGap = config.MaximumActionGap;
DisplayNamePrefix = config.DisplayNamePrefix;
TradePollingInterval = config.TradePollingInterval <= 100 ? 800 : config.TradePollingInterval;
Admins = config.Admins;
this.apiKey = apiKey;
AuthCode = null;
log = new Log (config.LogFile, this);
CreateHandler = handlerCreator;
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
log.Debug ("Initializing Steam Bot...");
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler<SteamTrading>();
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
log.Info ("Connecting...");
SteamClient.Connect();
Thread CallbackThread = new Thread(() => // Callback Handling
{
while (true)
{
CallbackMsg msg = SteamClient.WaitForCallback (true);
HandleSteamMessage (msg);
}
});
new Thread(() => // Trade Polling if needed
{
while (true)
{
Thread.Sleep (TradePollingInterval);
if (CurrentTrade != null)
{
try
{
CurrentTrade.Poll ();
}
catch (Exception e)
{
log.Error ("Error Polling Trade: " + e);
}
}
}
}).Start ();
CallbackThread.Start();
log.Success ("Done Loading Bot!");
CallbackThread.Join();
}
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();
}
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 ) );
}
}
public Bot(Configuration.BotInfo config, string apiKey, UserHandlerCreator handlerCreator, bool debug = false)
{
Username = config.Username;
Password = config.Password;
DisplayName = config.DisplayName;
ChatResponse = config.ChatResponse;
MaximumTradeTime = config.MaximumTradeTime;
MaximiumActionGap = config.MaximumActionGap;
DisplayNamePrefix = config.DisplayNamePrefix;
TradePollingInterval = config.TradePollingInterval <= 100 ? 800 : config.TradePollingInterval;
Admins = config.Admins;
this.apiKey = apiKey;
AuthCode = null;
try
{
LogLevel = (Log.LogLevel)Enum.Parse(typeof(Log.LogLevel), config.LogLevel, true);
}
catch (ArgumentException)
{
Console.WriteLine("Invalid LogLevel provided in configuration. Defaulting to 'INFO'");
LogLevel = Log.LogLevel.Info;
}
log = new Log (config.LogFile, this.DisplayName, LogLevel);
CreateHandler = handlerCreator;
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
log.Debug ("Initializing Steam Bot...");
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler<SteamTrading>();
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
log.Info ("Connecting...");
SteamClient.Connect();
Thread CallbackThread = new Thread(() => // Callback Handling
{
while (true)
{
CallbackMsg msg = SteamClient.WaitForCallback (true);
HandleSteamMessage (msg);
}
});
new Thread(() => // Trade Polling if needed
{
while (true)
{
Thread.Sleep (TradePollingInterval);
if (CurrentTrade != null)
{
try
{
CurrentTrade.Poll ();
if (CurrentTrade.OtherUserCancelled)
{
log.Info("Other user cancelled the trade.");
CurrentTrade = null;
}
}
catch (Exception e)
{
log.Error ("Error Polling Trade: " + e);
// ok then we should stop polling...
CurrentTrade = null;
}
}
}
}).Start ();
CallbackThread.Start();
log.Success ("Done Loading Bot!");
CallbackThread.Join();
}
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 Bot(Configuration.BotInfo config, Log log, string apiKey, UserHandlerCreator handlerCreator, Login _login, bool debug = false)
{
this.main = _login;
logOnDetails = new SteamUser.LogOnDetails
{
Username = _login.Username,
Password = _login.Password
};
ChatResponse = "";
TradePollingInterval = 500;
Admins = new ulong[1];
Admins[0] = 0;
this.apiKey = apiKey;
try
{
LogLevel = (Log.LogLevel)Enum.Parse(typeof(Log.LogLevel), "Debug", true);
}
catch (ArgumentException)
{
Console.WriteLine("Invalid LogLevel provided in configuration. Defaulting to 'INFO'");
LogLevel = Log.LogLevel.Info;
}
this.log = log;
CreateHandler = handlerCreator;
BotControlClass = "SteamBot.SimpleUserHandler";
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
log.Debug ("Initializing Steam account...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Initializing Steam account...";
}));
SteamClient = new SteamClient();
SteamClient.AddHandler(new ClientPlayerNicknameListHandler());
SteamTrade = SteamClient.GetHandler<SteamTrading>();
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
SteamGameCoordinator = SteamClient.GetHandler<SteamGameCoordinator>();
SteamNicknames = SteamClient.GetHandler<ClientPlayerNicknameListHandler>();
log.Info ("Connecting...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Connecting to Steam...";
}));
SteamClient.Connect();
Thread CallbackThread = new Thread(() => // Callback Handling
{
while (true)
{
CallbackMsg msg = SteamClient.WaitForCallback(true);
new Thread(() => HandleSteamMessage(msg)).Start();
}
});
CallbackThread.Start();
CallbackThread.Join();
log.Success("Done loading account!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Done loading account!";
}));
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
System.Console.Title = "TradeBot";
System.Console.WriteLine("Welcome to TradeBot!\nCreated by Jessecar.\nTurn of Steam Guard before loggin in!\n\n");
Console.ForegroundColor = ConsoleColor.White;
printConsole("Steam Username:"******"jessecar96"; //Console.ReadLine();
System.Console.WriteLine("Steam Password: "******"Sorry, could not connect to Steam.");
}
steamUser.LogOn(new SteamUser.LogOnDetails
{
Username = username,
Password = password,
});
});
//Login Callback
msg.Handle<SteamUser.LoggedOnCallback>(callback =>
{
if (callback.Result != EResult.OK)
{
printConsole("Incorrect username or Password. Make sure you have disabled steam guard!");
}
else
{
printConsole("Connected to Steam!\nWelcome "+steamUser.SteamID);
steamFriends.SetPersonaName("ChatBot Beta (Say hi)");
steamFriends.SetPersonaState((EPersonaState)6);
}
});
//Chat Messages
msg.Handle<SteamFriends.FriendMsgCallback>(callback =>
{
EChatEntryType type = callback.EntryType;
if (type == EChatEntryType.ChatMsg)
{
SteamID sid = callback.Sender;
if (!clients.Contains(callback.Sender))
{
printConsole("[New Client]" + callback.Sender, ConsoleColor.Magenta);
clients.Add(callback.Sender);
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "Welcome to TradeBot created by Jessecar. To see a list of commands type /help");
}
if (callback.Message.StartsWith("/"))
{
string message = callback.Message.Replace("/", "");
printConsole("[Command]" + callback.Sender + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + "): " + message, ConsoleColor.Magenta);
//string[] args = .Split(" ");
string[] words = message.Split(new char[] { ' ' }, 2);
switch (words[0])
{
case "trade":
//Send a trade
trade.RequestTrade(callback.Sender);
printConsole("Trade requested by " + callback.Sender + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + ")", ConsoleColor.Green);
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "initiated a trade request.");
break;
case "remove":
//Remove Friend
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "Thank you for using the Steam TradeBot BETA.");
steamFriends.RemoveFriend(callback.Sender);
printConsole("[Friend] Friend Removed: " + callback.Sender + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + ")", ConsoleColor.Yellow);
break;
case "status":
//get status (nothing)
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "is Online and working good.");
break;
case "hi":
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "says hello.");
break;
case "help":
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "\nList Of Commands:\n/trade - Start a trade.\n/remove - Remove TradeBot from your friends.\n/hi - say hello");
break;
case "name":
if(checkAdmin(sid))
steamFriends.SetPersonaName(words[1]);
break;
case "send":
string[] wrds = message.Split(new char[] { ' ' }, 3);
int index = int.Parse(wrds[1]);
if(index<clients.Count() && index>=0)
steamFriends.SendChatMessage(clients[index], EChatEntryType.ChatMsg, wrds[2]);
else
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "Error: index out of bounds.");
break;
default:
printConsole("[Error]Unknown command from " + callback.Sender + ": " + callback.Message, ConsoleColor.Red);
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "doesn't know that command.");
break;
}
}
else
{
printConsole("[Chat][" + getIndex(sid) + "]" + callback.Sender + ": " + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + ")" + callback.Message, ConsoleColor.Magenta);
if ((callback.Message != "hi" || callback.Message != "hello") && clients.Contains(callback.Sender))
{
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "You Said: " + callback.Message);
}
}
}
else if (type == EChatEntryType.Emote)
{
printConsole("[Emote]" + callback.Sender + ": " + callback.Message, ConsoleColor.DarkMagenta);
}
});
msg.Handle<SteamTrading.TradeProposedCallback>(callback =>
{
SteamID sid = callback.Other;
//trade.RespondTradeRequest(callback.TradeRequestId, sid, true);
//trade.HandleMsg((IPacketMsg)EMsg.EconTrading_InitiateTradeProposed);
});
msg.Handle<SteamTrading.TradeRequestCallback>(callback =>
{
printConsole("[Trade] Trade Status with " + callback.Other + " (" + steamFriends.GetFriendPersonaName(callback.Other) + "): " + callback.Status.ToString(), ConsoleColor.Green);
if (callback.Status == ETradeStatus.Rejected)
{
printConsole("[Trade] Trade rejected by " + callback.Other + " (" + steamFriends.GetFriendPersonaName(callback.Other) + ")", ConsoleColor.DarkRed);
steamFriends.SendChatMessage(callback.Other, EChatEntryType.Emote, "detected that you rejected that trade.");
}
//trade.RespondTradeRequest(callback.TradeRequestId, callback.Other, true);
});
msg.Handle<SteamTrading.TradeStartSessionCallback>(callback =>
{
//callback.Other
});
msg.Handle<SteamFriends.PersonaStateCallback>(callback =>
{
if (callback.FriendID == steamUser.SteamID)
return;
EFriendRelationship relationship = steamFriends.GetFriendRelationship(callback.FriendID);
if (!(relationship == EFriendRelationship.RequestRecipient))
return;
printConsole("[Friend] Added Friend: " + callback.FriendID + "(" + steamFriends.GetFriendPersonaName(callback.FriendID) + ")", ConsoleColor.Yellow);
steamFriends.AddFriend(callback.FriendID);
});
}
}
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));
}
}
public BotControlForm(Configuration.BotInfo config, string apiKey, bool debug = false)
{
InitializeComponent();
foreach(EPersonaState state in Enum.GetValues(typeof(EPersonaState)))
{
this.cbxPersonaState.Items.Add(state);
}
SetStatus("Setting variables...");
logOnDetails = new SteamUser.LogOnDetails
{
Username = config.Username,
Password = config.Password
};
DisplayName = config.DisplayName;
ChatResponse = config.ChatResponse;
MaximumTradeTime = config.MaximumTradeTime;
MaximiumActionGap = config.MaximumActionGap;
DisplayNamePrefix = config.DisplayNamePrefix;
TradePollingInterval = config.TradePollingInterval <= 100 ? 800 : config.TradePollingInterval;
Admins = config.Admins;
this.apiKey = apiKey;
try
{
LogLevel = (Log.LogLevel)Enum.Parse(typeof(Log.LogLevel), config.LogLevel, true);
}
catch (ArgumentException)
{
Console.WriteLine("Invalid LogLevel provided in configuration. Defaulting to 'INFO'");
LogLevel = Log.LogLevel.Info;
}
log = new Log(config.LogFile, this.DisplayName, LogLevel);
//CreateHandler = handlerCreator;
BotControlClass = config.BotControlClass;
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler<SteamTrading>();
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
SetStatus("Connecting to Steam...");
SteamClient.Connect();
masterThread = new Thread(this.pollSteam);
masterThread.Start();
}
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 );
}
}
}
