public void PostedCallbacksTriggerActions()
{
var callback = new CallbackForTest {
UniqueID = Guid.NewGuid()
};
var numCallbacksRun = 0;
Action <CallbackForTest> action = delegate(CallbackForTest cb)
{
Assert.Equal(callback.UniqueID, cb.UniqueID);
numCallbacksRun++;
};
using (mgr.Subscribe(action))
{
for (var i = 0; i < 10; i++)
{
client.PostCallback(callback);
}
mgr.RunWaitAllCallbacks(TimeSpan.Zero);
Assert.Equal(10, numCallbacksRun);
// Callbacks should have been freed.
mgr.RunWaitAllCallbacks(TimeSpan.Zero);
Assert.Equal(10, numCallbacksRun);
}
}
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);
}
public void Run()
{
while (RUN_FLAG || loggedOn)
{
if (user != null && pass != null)
{
if (!attemptedToConnect)
{
UpdateUILabel("Connecting...");
ConnectToSteam();
attemptedToConnect = true;
}
else
{
manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(0.25));
}
}
if (!recieverUI.IsEmpty)
{
object message = null;
recieverUI.TryDequeue(out message);
ProcessMessage(message);
}
}
doneClose.Set();
}
//Helper function :
#region Helper function
public void Run()
{
if (!stop)
{
manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(1));
}
}
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 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);
}
/// <summary>
/// Blocking call to manage SteamKit CallbackManager. Blocks while m_isRunning is true.
/// </summary>
private void ManageCallbacks()
{
while (m_isRunning)
{
m_callbackManager.RunWaitAllCallbacks(Settings.Default.SteamCallbackManagerPeriod);
waitForLastCallback.Set(); //let stop() know i've run my last callbacks.
}
}
public void Disconnect(bool sendLogOff = true)
{
if (sendLogOff)
{
steamUser.LogOff();
}
steamClient.Disconnect();
bConnected = false;
bConnecting = false;
bAborted = true;
// flush callbacks until our disconnected event
while (!bDidDisconnect)
{
callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(100));
}
}
private async Task CallbackManagerHandler()
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
CallbackManager.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(100));
}
}
private bool RunClient()
{
// create our steamclient instance
var configuration = SteamConfiguration.Create(b => b.WithProtocolTypes(ProtocolTypes.Tcp));
_steamClient = new SteamClient(configuration);
// create the callback _manager which will route callbacks to function calls
_manager = new CallbackManager(_steamClient);
// get the steamuser handler, which is used for logging on after successfully connecting
_steamUser = _steamClient.GetHandler <SteamUser>();
// get the steam friends handler, which is used for interacting with friends on the network after logging on
_steamFriends = _steamClient.GetHandler <SteamFriends>();
// register a few callbacks we're interested in
// these are registered upon creation to a callback _manager, which will then route the callbacks
// to the functions specified
_manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
_manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
_manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
_manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
// we use the following callbacks for friends related activities
_manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
_manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList);
_manager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState);
_manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded);
Console.WriteLine("Connecting to Steam...");
_isRunning = true;
// initiate the connection
_steamClient.Connect();
Thread.Sleep(100);
// create our callback handling loop
int attempts = 5;
while (_isRunning && attempts > 0 && !_isMessageSent)
{
// in order for the callbacks to get routed, they need to be handled by the _manager
_manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(5));
attempts--;
}
return(_isMessageSent);
}
public void DoTick()
{
// we'll check for callbacks every 10ms
// thread quantum granularity might hose us,
// but it should wake often enough to handle callbacks within a single thread
callbackMgr.RunWaitAllCallbacks(CallbackTimeout);
if (DateTime.Now >= nextConnect)
{
nextConnect = DateTime.Now + TimeSpan.FromMinutes(1);
Reconnecting++;
Task.Run(() => Client.Connect(Server));
}
}
public override Result Start()
{
Thread.CurrentThread.Name = JsonAccount.Username + " - " + (_reportInfo != null ? "Report" : "Commend");
_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);
IsRunning = true;
_steamClient.Connect();
while (IsRunning)
{
_callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(500));
}
return(Result);
}
public void Run()
{
isRunning = true;
steamClient.Connect();
while (isRunning)
{
manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(5));
if (sw.Elapsed.Seconds > 5)
{
Console.WriteLine("Resending CMsgClientHello");
var ClientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello);
SteamGameCoordinator.Send(ClientHello, 730);
sw.Restart();
}
}
}
static public void joininlobby(string cfgname)
{
Config = JsonConvert.DeserializeObject <Config>(File.ReadAllText("data/" + cfgname));
username = Config.SteamLogin;
password = Config.SteamPassword;
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
gameCoordinator = steamClient.GetHandler <SteamGameCoordinator>();
steamClient.AddHandler(new Handler());
_handler = steamClient.GetHandler <Handler>();
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);
manager.Subscribe <SteamGameCoordinator.MessageCallback>(OnMessageCall);
// Ausgeklammert, weil du das dem Handler geben musst.
/*statusteam = "LobbyID to Chat?");
* lobbyid = ulong.Parse(Console.ReadLine());*/
statusteam = "Подкючаюсь к стиму...";
steamClient.Connect();
while (mainform.isjoinlobby)
{
manager.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(1000));
}
}
/// <summary>
/// 启动机器人实例
/// </summary>
/// <param name="startWait">是否等待三秒后再启动，默认 <c>false</c></param>
public void Start(bool startWait = false)
{
lock (_startStopLock)
{
if (_disposed)
{
_logger.Fatal($"#{SequenceNumber} Try to restart disposed bot.");
// throw new InvalidOperationException("Try to restart disposed bot.");
}
if (!_callbackPumpStarted)
{
_callbackPumpStarted = true;
Task.Run(() =>
{
_logger.Info($"#{SequenceNumber} Listening callbacks...");
while (!_disposed)
{
_callbackManager.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(10));
}
_logger.Info($"#{SequenceNumber} Stopped listening callbacks.");
});
}
try
{
_coordinator.Consume(coordinator => coordinator.UpdateBot(Id, null, false, null));
}
catch (Exception e)
{
_logger.Fatal($"#{SequenceNumber} Cannot clear online state before start : {e.Message}");
Restart();
return;
}
if (startWait)
{
_logger.Info($"#{SequenceNumber} Starting in 3 seconds...");
Thread.Sleep(TimeSpan.FromSeconds(3));
}
var sfhPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data", $"{LogOnDetails.Username}.sfh");
if (File.Exists(sfhPath))
{
LogOnDetails.SentryFileHash = File.ReadAllBytes(sfhPath);
_logger.Info($"#{SequenceNumber} Use sentry file hash from {LogOnDetails.Username}.sfh.");
}
if (!_loginPending)
{
LoginSemaphore.WaitOne();
_loginPending = true;
}
SteamClient.Connect();
_mqChannel = _mqClientProvider.CreateModel();
_mqChannel.BasicQos(0, 5, false);
var queueName = MqClientProvider.SteamBotDelayedActionQueue(Id);
_mqChannel.QueueDeclare(queueName, true, false, false, null);
_mqChannel.QueueBind(queueName, MqClientProvider.DelayedMessageExchange, queueName);
var consumer = new EventingBasicConsumer(_mqChannel);
consumer.Received += OnDelayedActionReceived;
_mqChannel.BasicConsume(queueName, false, consumer);
}
}