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));
}
}