static void OnCSGOMatchDetails(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf <CMsgGCCStrike15_v2_MatchList>(packetMsg); CSGOMatchHistoryCallback.SafeInvoke(packetMsg); //Stream stream = Helpers.GetStreamFromUrl(msg.Body.matches[0].roundstats.map); }
public override void OnMatchmakingHelloResponse(IPacketGCMsg msg) { var response = new ClientGCMsgProtobuf <CMsgGCCStrike15_v2_MatchmakingGC2ClientHello>(msg); if (response.Body.penalty_reasonSpecified) { Cooldown cooldown = response.Body.penalty_reason; _log.Error("This account has received a {type} cooldown: {reason}", cooldown.Permanent ? "global" : "temporary", cooldown.Reason); if (cooldown.Permanent) { _log.Error("This ban is permanent. Botting with banned accounts is not possible."); } else { var penalty = TimeSpan.FromSeconds(response.Body.penalty_seconds); var time = penalty.Minutes >= 60 ? penalty.Hours + " Hours" : penalty.Minutes + " Minutes"; _log.Error("This ban will end in {end}. Botting with banned accounts is not possible.", time); } Result = Result.AccountBanned; Stop(); return; } // When the CS:GO GC sends a vac_banned (type 2) but not a penalty_reason (type 0) // the account has received a yellow "This account has been banned by Overwatch" // banner in-game and has no longer the ability to report or commend. if (response.Body.vac_bannedSpecified && !response.Body.penalty_reasonSpecified && response.Body.vac_banned == 2 && !response.Body.penalty_secondsSpecified) { _log.Error("This account has been banned by Valve Anti Cheat. Botting with banned " + "accounts is not possible and will not give successfull results. Aborting!"); Result = Result.AccountBanned; Stop(); return; } var type = _liveGameInfo != null ? "Live Game Request" : (_reportInfo != null ? "Report" : "Commend"); _log.Debug("Received hello from CS:GO matchmaking services. Authentificated as {id}. Sending {type}.", response.Body.account_id, type); if (_liveGameInfo != null) { _gameCoordinator.Send(GetLiveGamePayload(), GetAppID()); } else if (_reportInfo != null) { _gameCoordinator.Send(GetReportPayload(), GetAppID()); } else { _gameCoordinator.Send(GetCommendPayload(), GetAppID()); } }
void OnLobbyCreate(IPacketGCMsg packetMsg) { var msg = packetMsg; waitTime = 5; checkCreateLobby = false; }
static async void OnMatchmakingClientHello(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf <CMsgGCCStrike15_v2_MatchmakingGC2ClientHello>(packetMsg); if (SteamAccountID != 0 || msg == null || msg.Body == null || msg.Body.ranking == null || msg.Body.commendation == null) { await Task.Delay(1000).ConfigureAwait(false); return; } if (msg.Body.vac_banned == 0) { banned = true; } else { banned = false; } rankID = 0; SteamAccountID = msg.Body.ranking.account_id; var commendation = msg.Body.commendation; rankID = (RankName)msg.Body.ranking.rank_id; level = msg.Body.player_level; }
static void OnClientWelcome(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf <CMsgClientWelcome>(packetMsg); clientWelcome = true; CSGOClientWelcomeCallback.SafeInvoke(); }
static void OnRecentMatchesResponse(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf <CMsgGCCStrike15_v2_MatchList>(packetMsg); uint serverTime = msg.Body.servertime; uint expectedLastReportTime = 0; foreach (var match in msg.Body.matches) { int matchDuration = 0; foreach (var round in match.roundstatsall) { matchDuration = matchDuration < round.match_duration ? round.match_duration : matchDuration; } if (expectedLastReportTime < match.matchtime + matchDuration) { expectedLastReportTime = match.matchtime + (uint)matchDuration; } } LastMatchInfo matchInfo = new LastMatchInfo(); matchInfo.lastCheck = serverTime; matchInfo.matchEnded = expectedLastReportTime; File.WriteAllText("data/" + Config.SteamLogin + ".lastmatch", JsonConvert.SerializeObject(matchInfo)); checkOWBypass(serverTime, expectedLastReportTime); isRunning = false; }
private void HandlePingRequest(IPacketGCMsg obj) { var req = new ClientGCMsgProtobuf <CMsgGCClientPing>(obj); Pong(); Client.PostCallback(new PingRequest(req.Body)); }
//Initial message sent when connected to the GC private void HandleWelcome(IPacketGCMsg msg) { gcConnectTimer.Stop(); Ready = true; // Clear these. They will be updated in the subscriptions if they exist still. Lobby = null; Party = null; PartyInvite = null; var wel = new ClientGCMsgProtobuf <CMsgClientWelcome>(msg); Client.PostCallback(new GCWelcomeCallback(wel.Body)); //Handle any cache subscriptions foreach (CMsgSOCacheSubscribed cache in wel.Body.outofdate_subscribed_caches) { foreach (CMsgSOCacheSubscribed.SubscribedType obj in cache.objects) { HandleSubscribedType(obj); } } UploadRichPresence(); }
/// <summary> /// Initializes a new instance of the <see cref="ClientGCMsgProtobuf<BodyType>"/> class. /// This is a recieve constructor. /// </summary> /// <param name="msg">The packet message to build this gc message from.</param> public ClientGCMsgProtobuf(IPacketGCMsg msg) : this(msg.MsgType) { DebugLog.Assert(msg.IsProto, "ClientGCMsgProtobuf", "ClientGCMsgProtobuf used for non-proto message!"); Deserialize(msg.GetData()); }
/// <summary> /// Handle when a cache is destroyed. /// </summary> /// <param name="obj">Message</param> public void HandleCacheDestroy(IPacketGCMsg obj) { var dest = new ClientGCMsgProtobuf <CMsgSOSingleObject>(obj); if (PartyInvite != null && dest.Body.type_id == (int)CSOTypes.PARTYINVITE) { PartyInvite = null; Client.PostCallback(new PartyInviteLeave(null)); } else if (Lobby != null && dest.Body.type_id == (int)CSOTypes.LOBBY) { Lobby = null; Client.PostCallback(new PracticeLobbyLeave(null)); } else if (Party != null && dest.Body.type_id == (int)CSOTypes.PARTY) { Party = null; Client.PostCallback(new PartyLeave(null)); } else if (LobbyInvite != null && dest.Body.type_id == (int)CSOTypes.LOBBYINVITE) { LobbyInvite = null; Client.PostCallback(new LobbyInviteLeave(null)); } }
private void onMatchDetailsReceived(IPacketGCMsg msg) { Console.Error.WriteLine("Match Details Received"); ClientGCMsgProtobuf <CMsgGCMatchDetailsResponse> response = new ClientGCMsgProtobuf <CMsgGCMatchDetailsResponse>(msg); if ((EResult)response.Body.result != EResult.OK) { Console.Error.WriteLine("Unable to request match details: {0}", response.Body.result); return; } CMsgDOTAMatch match = response.Body.match; if (match.replay_state != CMsgDOTAMatch.ReplayState.REPLAY_AVAILABLE) { Console.Error.WriteLine("Replay cannot be downloaded"); return; } uint replayCluster = match.cluster; ulong matchID = match.match_id; uint replaySalt = match.replay_salt; string replayURL = String.Format("http://replay{0}.valve.net/{1}/{2}_{3}.dem.bz2", replayCluster, DOTA_APP_ID, matchID, replaySalt); receivedReplayURLs.Add(replayURL); Console.WriteLine(replayURL); }
public override void OnClientWelcome(IPacketGCMsg msg) { switch (GetAppID()) { case CSGO_APPID: { var welcome = new ClientGCMsgProtobuf <SteamKit2.GC.CSGO.Internal.CMsgClientWelcome>(msg); _log.Debug("Received welcome from CS:GO GC version {v} (Connected to {loc}). " + "Sending hello the CS:GO's matchmaking service.", welcome.Body.version, welcome.Body.location.country); var mmHello = new ClientGCMsgProtobuf <CMsgGCCStrike15_v2_MatchmakingClient2GCHello>( (uint)ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello ); _gameCoordinator.Send(mmHello, GetAppID()); break; } case TF2_APPID: { var welcome = new ClientGCMsgProtobuf <SteamKit2.GC.TF2.Internal.CMsgClientWelcome>(msg); _log.Debug("Received welcome from TF2 GC version {v}. Sending report...", welcome.Body.version); _gameCoordinator.Send(GetReportPayload(), GetAppID()); break; } } }
private void HandleUpdateMultiple(IPacketGCMsg obj) { var resp = new ClientGCMsgProtobuf <CMsgSOMultipleObjects>(obj); bool handled = true; foreach (CMsgSOMultipleObjects.SingleObject mObj in resp.Body.objects_modified) { if (mObj.type_id == 2004) { HandleLobbySnapshot(mObj.object_data, true); } else if (mObj.type_id == 2003) { HandlePartySnapshot(mObj.object_data, true); } else if (mObj.type_id == 2006) { //HandlePartyInviteSnapshot(mObj.object_data, true); } else { handled = false; } } if (!handled) { Client.PostCallback(new UnhandledDotaGCCallback(obj)); } }
/// <summary> /// Initializes a new instance of the <see cref="ClientGCMsg<BodyType>"/> class. /// This is a recieve constructor. /// </summary> /// <param name="msg">The packet message to build this gc message from.</param> public ClientGCMsg(IPacketGCMsg msg) : this() { DebugLog.Assert(!msg.IsProto, "ClientGCMsg", "ClientGCMsg used for proto message!"); Deserialize(msg.GetData()); }
internal MessageCallback(CMsgGCClient gcMsg) { this.eMsg = gcMsg.msgtype; this.AppID = gcMsg.appid; this.Message = GetPacketGCMsg(gcMsg.msgtype, gcMsg.payload); this.JobID = this.Message.TargetJobID; }
public override void OnCommendResponse(IPacketGCMsg msg) { _log.Information("Successfully commended target {Target}.", _info.Target); Result = Result.Success; Stop(); }
private void EventOnPlayerMatchHistoryResponse(IPacketGCMsg packetMsg) { if (OnPlayerMatchHistoryResponse != null) { var response = new ClientGCMsgProtobuf <CMsgDOTAGetPlayerMatchHistoryResponse>(packetMsg); OnPlayerMatchHistoryResponse(response); } }
private void EventOnChatMessage(IPacketGCMsg packetMsg) { if (OnChatMessage != null) { var response = new ClientGCMsgProtobuf <CMsgDOTAChatMessage>(packetMsg); OnChatMessage(response); } }
private void EventOnChatChannelJoin(IPacketGCMsg packetMsg) { if (OnChatChannelJoined != null) { var response = new ClientGCMsgProtobuf <CMsgDOTAJoinChatChannelResponse>(packetMsg); OnChatChannelJoined(response); } }
private void EventOnClientWelcome(IPacketGCMsg packetMsg) { var response = new ClientGCMsgProtobuf <CMsgClientWelcome>(packetMsg); _clientVersion = response.Body.version; _logger.Info(String.Format("Dota 2 launch successful - Client version: {0}", _clientVersion)); OnDota2Launched?.Invoke(); }
private void EventOnMatchDetailsResponse(IPacketGCMsg packetMsg) { if (OnMatchDetailsResponse != null) { var response = new ClientGCMsgProtobuf <CMsgGCMatchDetailsResponse>(packetMsg); OnMatchDetailsResponse(response); } }
private void EventOnReadyUpStatus(IPacketGCMsg packetMsg) { if (OnReadyUpStatus != null) { var response = new ClientGCMsgProtobuf <CMsgReadyUpStatus>(packetMsg); OnReadyUpStatus(response); } }
private void OnMatchmakingHelloResponse(IPacketGCMsg obj) { Logger.Log("Received client hello!"); LastActionTime = DateTime.Now; IsSuccess = true; IsDone = true; }
private void OnSystemMessage(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf <CMsgSystemBroadcast>(packetMsg).Body; Log.WriteInfo(Name, "Message: {0}", msg.message); IRC.SendMain("{0}{1}{2} system message:{3} {4}", Colors.OLIVE, SteamProxy.GetAppName(AppID), Colors.NORMAL, Colors.OLIVE, msg.message); }
public override void OnCommendResponse(IPacketGCMsg msg) { _log.Information("Successfully commended target {Target}.", _commendInfo.SteamID.ConvertToUInt64()); Result = Result.Success; Stop(); }
private void HandleCacheSubscribed(IPacketGCMsg obj) { var sub = new ClientGCMsgProtobuf <CMsgSOCacheSubscribed>(obj); foreach (CMsgSOCacheSubscribed.SubscribedType cache in sub.Body.objects) { HandleSubscribedType(cache); } }
public static uint GetMsgTypeWithNullCheck(this IPacketGCMsg msg, string name) { if (msg == null) { throw new ArgumentNullException(name); } return(msg.MsgType); }
private void OnSystemMessage(uint appID, IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf <CMsgSystemBroadcast>(packetMsg).Body; var message = string.Format("{0}{1}{2} system message:{3} {4}", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL, Colors.OLIVE, msg.message); IRC.Instance.SendMain(message); IRC.Instance.SendAnnounce(message); }
void OnGCUpdateItemSchema(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf <CMsgUpdateItemSchema>(packetMsg); Logger.WriteLine("Item schema version: " + msg.Body.item_schema_version); UpdateBackpack(); Logger.WriteLine("Loaded backpack: {0} items found", Backpack.Items.Length); }
public void HandleCacheDestroy(IPacketGCMsg obj) { var dest = new ClientGCMsgProtobuf <CMsgSOSingleObject>(obj); if (PartyInvite != null && dest.Body.type_id == 2006) { PartyInvite = null; Client.PostCallback(new PartyInviteLeave(null)); } }
private void HandleGuildCancelInviteResponse(IPacketGCMsg obj) { var resp = new ClientGCMsgProtobuf<CMsgDOTAGuildCancelInviteResponse>(obj); Client.PostCallback(new GuildCancelInviteResponse(resp.Body)); }
private void OnWelcome(uint appID, IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgClientWelcome>(packetMsg).Body; var info = GetSessionInfo(appID); string message = string.Format("{0}{1}{2} new GC session", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL); if (info.Version == 0 || info.Version == msg.version) { message += string.Format(" {0}(version {1})", Colors.DARKGRAY, msg.version); } else { message += string.Format(" {0}(version changed from {1} to {2})", Colors.DARKGRAY, info.Version, msg.version); IRC.Instance.SendMain(message); } IRC.Instance.SendAnnounce(message); info.Version = msg.version; info.Status = GCConnectionStatus.GCConnectionStatus_HAVE_SESSION; }
// this message arrives when the GC welcomes a client // this happens after telling steam that we launched dota (with the ClientGamesPlayed message) // this can also happen after the GC has restarted (due to a crash or new version) void OnClientWelcome( IPacketGCMsg packetMsg ) { // in order to get at the contents of the message, we need to create a ClientGCMsgProtobuf from the packet message we recieve // note here the difference between ClientGCMsgProtobuf and the ClientMsgProtobuf used when sending ClientGamesPlayed // this message is used for the GC, while the other is used for general steam messages var msg = new ClientGCMsgProtobuf<CMsgClientWelcome>( packetMsg ); Console.WriteLine( "GC is welcoming us. Version: {0}", msg.Body.version ); Console.WriteLine( "Requesting details of match {0}", matchId ); // at this point, the GC is now ready to accept messages from us // so now we'll request the details of the match we're looking for var requestMatch = new ClientGCMsgProtobuf<CMsgGCMatchDetailsRequest>( ( uint )EDOTAGCMsg.k_EMsgGCMatchDetailsRequest ); requestMatch.Body.match_id = matchId; gameCoordinator.Send( requestMatch, APPID ); }
private void OnItemBroadcast(uint appID, IPacketGCMsg packetMsg) { if (appID != 440) { // This message should be TF2 specific, but just in case return; } var msg = new ClientGCMsgProtobuf<CMsgGCTFSpecificItemBroadcast>(packetMsg).Body; var itemName = GetItemName(441, msg.item_def_index); IRC.Instance.SendMain("{0}{1}{2} item notification: {3}{4}{5} {6} {7}{8}{9}!", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL, Colors.BLUE, msg.user_name, Colors.NORMAL, msg.was_destruction ? "has destroyed their" : "just received a", Colors.OLIVE, itemName, Colors.NORMAL ); }
private void OnSystemMessage(uint appID, IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgSystemBroadcast>(packetMsg).Body; IRC.Instance.SendMain("{0}{1}{2} system message:{3} {4}", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL, Colors.OLIVE, msg.message); }
private void HandleProfileCardResponse(IPacketGCMsg obj) { var resp = new ClientGCMsgProtobuf<CMsgDOTAProfileCard>(obj); Client.PostCallback(new ProfileCardResponse(resp.Body)); }
private void HandleGuildData(IPacketGCMsg obj) { var resp = new ClientGCMsgProtobuf<CMsgDOTAGuildSDO>(obj); Client.PostCallback(new GuildDataResponse(resp.Body)); }
private void HandleInvitationCreated(IPacketGCMsg obj) { var msg = new ClientGCMsgProtobuf<CMsgInvitationCreated>(obj); Client.PostCallback(new InvitationCreated(msg.Body)); }
internal abstract void Run( IPacketGCMsg msg );
/// <summary> /// GC tells us if there are tournaments running. /// </summary> /// <param name="obj"></param> private void HandleLiveLeageGameUpdate(IPacketGCMsg obj) { var resp = new ClientGCMsgProtobuf<CMsgDOTALiveLeagueGameUpdate>(obj); Client.PostCallback(new LiveLeagueGameUpdate(resp.Body)); }
private void HandleCacheSubscribed(IPacketGCMsg obj) { var sub = new ClientGCMsgProtobuf<CMsgSOCacheSubscribed>(obj); foreach (CMsgSOCacheSubscribed.SubscribedType cache in sub.Body.objects) { HandleSubscribedType(cache); } }
//Initial message sent when connected to the GC private void HandleWelcome(IPacketGCMsg msg) { gcConnectTimer.Stop(); Ready = true; // Clear these. They will be updated in the subscriptions if they exist still. Lobby = null; Party = null; PartyInvite = null; var wel = new ClientGCMsgProtobuf<CMsgClientWelcome>(msg); Client.PostCallback(new GCWelcomeCallback(wel.Body)); //Handle any cache subscriptions foreach (CMsgSOCacheSubscribed cache in wel.Body.outofdate_subscribed_caches) foreach (CMsgSOCacheSubscribed.SubscribedType obj in cache.objects) HandleSubscribedType(obj); UploadRichPresence(); }
internal MessageCallback( CMsgGCClient gcMsg ) { this.eMsg = gcMsg.msgtype; this.AppID = gcMsg.appid; this.Message = GetPacketGCMsg( gcMsg.msgtype, gcMsg.payload ); }
void OnClientWelcome( IPacketGCMsg msg ) { var clientWelcome = new ClientGCMsgProtobuf<CMsgClientWelcome>( msg ); clientVersion = clientWelcome.Body.version; DebugLog.WriteLine( "DotaGCClient", "GC is version {0}", clientWelcome.Body.version ); var findGames = new ClientGCMsgProtobuf<CMsgFindSourceTVGames>( EGCMsg.FindSourceTVGames ); findGames.Body.num_games = 10; SteamGameCoordinator.Send( findGames, APPID ); }
private void OnWelcome(uint appID, IPacketGCMsg packetMsg) { uint version = 0; switch (appID) { case 730: version = new ClientGCMsgProtobuf<SteamKit2.GC.CSGO.Internal.CMsgClientWelcome>(packetMsg).Body.version; break; case 440: version = new ClientGCMsgProtobuf<SteamKit2.GC.TF2.Internal.CMsgClientWelcome>(packetMsg).Body.version; break; default: version = new ClientGCMsgProtobuf<CMsgClientWelcome>(packetMsg).Body.version; break; } var info = GetSessionInfo(appID); string message = string.Format("{0}{1}{2} new GC session", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL); if (info.Version == 0 || info.Version == version) { message += string.Format(" {0}(version {1})", Colors.DARKGRAY, version); } else { message += string.Format(" {0}(version changed from {1} to {2})", Colors.DARKGRAY, info.Version, version); } IRC.Instance.SendAnnounce(message); info.Version = version; info.Status = GCConnectionStatus.GCConnectionStatus_HAVE_SESSION; }
void OnSourceTVGames( IPacketGCMsg msg ) { var gamesList = new ClientGCMsgProtobuf<CMsgSourceTVGamesResponse>( msg ); DebugLog.WriteLine( "DotaGCClient", "There are currently {0} viewable games", gamesList.Body.num_total_games ); var game = gamesList.Body.games[ 0 ]; var watchGame = new ClientGCMsgProtobuf<CMsgWatchGame>( EGCMsg.WatchGame ); watchGame.Body.client_version = clientVersion; watchGame.Body.server_steamid = game.server_steamid; SteamGameCoordinator.Send( watchGame, APPID ); }
void OnWatchGame( IPacketGCMsg msg ) { var response = new ClientGCMsgProtobuf<CMsgWatchGameResponse>( msg ); if ( response.Body.watch_game_result == CMsgWatchGameResponse.WatchGameResult.PENDING ) { DebugLog.WriteLine( "DotaGCClient", "STV details pending..." ); return; } if ( response.Body.watch_game_result != CMsgWatchGameResponse.WatchGameResult.READY ) { DebugLog.WriteLine( "DotaGCClient", "Unable to get STV details: {0}", response.Body.watch_game_result ); return; } IPEndPoint server = new IPEndPoint( NetHelpers.GetIPAddress( response.Body.source_tv_public_addr ), ( int )response.Body.source_tv_port ); DebugLog.WriteLine("DotaGCClient", "Got STV details: {0} ({1}) ({2})", server, response.Body.watch_tv_unique_secret_code, server); if ( FoundMatch != null ) { FoundMatch( this, new FoundMatchEventArgs { Server = server, Password = response.Body.watch_tv_unique_secret_code.ToString(), } ); } }
internal UnhandledDotaGCCallback(IPacketGCMsg msg) { Message = msg; }
private void OnConnectionStatus(uint appID, IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgConnectionStatus>(packetMsg).Body; GetSessionInfo(appID).Status = msg.status; string extraInfo = string.Empty; if (msg.status == GCConnectionStatus.GCConnectionStatus_NO_SESSION_IN_LOGON_QUEUE) { extraInfo = string.Format(" {0}(queue: {1}/{2}, waited {3} of an estimated {4} seconds)", Colors.DARKGRAY, msg.queue_position, msg.queue_size, msg.wait_seconds, msg.estimated_wait_seconds_remaining ); } IRC.Instance.SendAnnounce("{0}{1}{2} status:{3} {4}{5}", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL, Colors.OLIVE, msg.status, extraInfo); }
private void OnClientConnectionStatus(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgConnectionStatus>(packetMsg).Body; LastStatus = msg.status; Log.WriteInfo(Name, "Status: {0}", LastStatus); string message = string.Format("{0}{1}{2} GC status:{3} {4}", Colors.OLIVE, SteamProxy.GetAppName(AppID), Colors.NORMAL, Colors.OLIVE, LastStatus); IRC.SendAnnounce(message); if (LastStatus == GCConnectionStatus.GCConnectionStatus_NO_SESSION) { Timer.Interval = TimeSpan.FromSeconds(5).TotalMilliseconds; Timer.Start(); } UpdateStatus(AppID, LastStatus.ToString()); }
private void OnItemSchemaUpdate(uint appID, IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgUpdateItemSchema>(packetMsg).Body; var info = GetSessionInfo(appID); if (info.SchemaVersion != 0 && info.SchemaVersion != msg.item_schema_version) { IRC.Instance.SendMain("{0}{1}{2} item schema updated: {3}{4}{5} -{6} {7}", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL, Colors.DARKGRAY, msg.item_schema_version.ToString("X4"), Colors.NORMAL, Colors.DARKBLUE, msg.items_game_url); } info.SchemaVersion = msg.item_schema_version; }
private void OnClientWelcome(IPacketGCMsg packetMsg) { Timer.Stop(); var msg = new ClientGCMsgProtobuf<CMsgClientWelcome>(packetMsg).Body; Log.WriteInfo(Name, "New GC session ({0} -> {1})", LastVersion, msg.version); string message = string.Format("New {0}{1}{2} GC session", Colors.OLIVE, SteamProxy.GetAppName(AppID), Colors.NORMAL); if (LastVersion == -1 || LastVersion == msg.version) { message += string.Format(" {0}(version {1})", Colors.DARK_GRAY, msg.version); } else { message += string.Format(" {0}(version changed from {1} to {2})", Colors.DARK_GRAY, LastVersion, msg.version); } if (LastVersion != -1 && (LastVersion != msg.version || LastStatus != GCConnectionStatus.GCConnectionStatus_HAVE_SESSION)) { IRC.SendMain(message); } IRC.SendAnnounce(message); LastVersion = (int)msg.version; LastStatus = GCConnectionStatus.GCConnectionStatus_HAVE_SESSION; UpdateStatus(AppID, LastStatus.ToString()); }
private void OnVersionUpdate(uint appID, IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgGCClientVersionUpdated>(packetMsg).Body; var info = GetSessionInfo(appID); IRC.Instance.SendMain("{0}{1}{2} client version changed:{3} {4} {5}(from {6})", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL, Colors.BLUE, msg.client_version, Colors.DARKGRAY, info.Version); info.Version = msg.client_version; }
private void OnItemSchemaUpdate(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgUpdateItemSchema>(packetMsg).Body; if (LastSchemaVersion != 0 && LastSchemaVersion != msg.item_schema_version) { Log.WriteInfo(Name, "Schema change from {0} to {1}", LastSchemaVersion, msg.item_schema_version); IRC.SendMain("{0}{1}{2} item schema updated: {3}{4}{5} -{6} {7}", Colors.OLIVE, SteamProxy.GetAppName(AppID), Colors.NORMAL, Colors.DARK_GRAY, msg.item_schema_version.ToString("X4"), Colors.NORMAL, Colors.DARK_BLUE, msg.items_game_url); } LastSchemaVersion = msg.item_schema_version; }
private void OnWrenchBroadcast(uint appID, IPacketGCMsg packetMsg) { if (appID != 440) { // This message should be TF2 specific, but just in case return; } var msg = new ClientGCMsgProtobuf<CMsgTFGoldenWrenchBroadcast>(packetMsg).Body; IRC.Instance.SendMain("{0}{1}{2} item notification: {3}{4}{5} has {6} Golden Wrench no. {7}{8}{9}!", Colors.BLUE, Steam.GetAppName(appID), Colors.NORMAL, Colors.BLUE, msg.user_name, Colors.NORMAL, msg.deleted ? "destroyed" : "found", Colors.OLIVE, msg.wrench_number, Colors.NORMAL ); }
private void OnSystemMessage(IPacketGCMsg packetMsg) { var msg = new ClientGCMsgProtobuf<CMsgSystemBroadcast>(packetMsg).Body; Log.WriteInfo(Name, "Message: {0}", msg.message); IRC.SendMain("{0}{1}{2} system message:{3} {4}", Colors.OLIVE, SteamProxy.GetAppName(AppID), Colors.NORMAL, Colors.OLIVE, msg.message); }
// this message arrives after we've requested the details for a match void OnMatchDetails( IPacketGCMsg packetMsg ) { var msg = new ClientGCMsgProtobuf<CMsgGCMatchDetailsResponse>( packetMsg ); EResult result = ( EResult )msg.Body.result; if ( result != EResult.OK ) { Console.WriteLine( "Unable to request match details: {0}", result ); } gotMatch = true; Match = msg.Body.match; // we've got everything we need, we can disconnect from steam now client.Disconnect(); }
private void HandleGuildAccountRoleResponse(IPacketGCMsg obj) { var resp = new ClientGCMsgProtobuf<CMsgDOTAGuildSetAccountRoleResponse>(obj); Client.PostCallback(new GuildSetRoleResponse(resp.Body)); }
/// <summary> /// Handle when a cache is destroyed. /// </summary> /// <param name="obj">Message</param> public void HandleCacheDestroy(IPacketGCMsg obj) { var dest = new ClientGCMsgProtobuf<CMsgSOSingleObject>(obj); if (PartyInvite != null && dest.Body.type_id == (int) CSOTypes.PARTYINVITE) { PartyInvite = null; Client.PostCallback(new PartyInviteLeave(null)); } else if (Lobby != null && dest.Body.type_id == (int) CSOTypes.LOBBY) { Lobby = null; Client.PostCallback(new PracticeLobbyLeave(null)); } else if (Party != null && dest.Body.type_id == (int) CSOTypes.PARTY) { Party = null; Client.PostCallback(new PartyLeave(null)); } else if (LobbyInvite != null && dest.Body.type_id == (int) CSOTypes.LOBBYINVITE) { LobbyInvite = null; Client.PostCallback(new LobbyInviteLeave(null)); } }
private void HandleCacheUnsubscribed(IPacketGCMsg obj) { var unSub = new ClientGCMsgProtobuf<CMsgSOCacheUnsubscribed>(obj); if (Lobby != null && unSub.Body.owner_soid.id == Lobby.lobby_id) { Lobby = null; Client.PostCallback(new PracticeLobbyLeave(unSub.Body)); } else if (Party != null && unSub.Body.owner_soid.id == Party.party_id) { Party = null; Client.PostCallback(new PartyLeave(unSub.Body)); } else if (PartyInvite != null && unSub.Body.owner_soid.id == PartyInvite.group_id) { PartyInvite = null; Client.PostCallback(new PartyInviteLeave(unSub.Body)); } else Client.PostCallback(new CacheUnsubscribed(unSub.Body)); }