Added cellid and server list

Author: Ezzpify

.vs/HourBoostr/v14/.suo

@@ -10,6 +10,7 @@
 using System.ComponentModel;
 using System.Net;
 using SteamKit2.Internal;
+using SteamKit2.Discovery;
 using SteamKit2;
 
 namespace HourBoostr
@@ -81,6 +82,12 @@ class ChatMessageData
         private int mDisconnectedCounter;
 
 
+        /// <summary>
+        /// How many diconnects that can occure before we force a pause
+        /// </summary>
+        private int mMaxDisconnectsBeforePause = 10;
+
+
         /// <summary>
         /// If we have connected once successfully this will be true
         /// Good to know if we disconnect
@@ -202,8 +209,15 @@ private void Connect()
         {
             mIsRunning = true;
             mLog.Write(Log.LogLevel.Info, $"Connecting to Steam ...");
-            SteamDirectory.Initialize().Wait();
-            mSteam.client.Connect();
+
+            try
+            {
+                mSteam.client.Connect();
+            }
+            catch (Exception ex)
+            {
+                mLog.Write(Log.LogLevel.Error, $"Error connecting to Steam: {ex}");
+            }
         }
 
 
@@ -223,17 +237,17 @@ private void BackgroundWorkerOnDoWork(object sender, DoWorkEventArgs doWorkEvent
                 }
                 catch (Exception ex)
                 {
-                    mLog.Write(Log.LogLevel.Warn, $"Exception occured for callbackManager: {ex}");
-                    errors++;
-
-                    Thread.Sleep(5000);
-                    if (errors >= 3)
+                    mLog.Write(Log.LogLevel.Warn, $"Exception occured for callbackManager: {ex.Message}");
+                    if (errors++ >= 3)
                     {
-                        /*This has historically only really occured when Steam is down
-                        so if too many errors here happen we'll pause for a while*/
+                        /*This has historically only really occured when Steam is down,
+                        but if too many errors happen here we'll pause*/
                         mLog.Write(Log.LogLevel.Info, $"Pausing for 15 minutes due to too many errors occuring.");
                         Thread.Sleep(TimeSpan.FromMinutes(15));
                     }
+
+                    if (!mSteam.client.IsConnected)
+                        Connect();
                 }
             }
         }
@@ -297,7 +311,7 @@ private void OnDisconnected(SteamClient.DisconnectedCallback callback)
 
             if (mIsRunning)
             {
-                if (mDisconnectedCounter >= 5)
+                if (mDisconnectedCounter >= mMaxDisconnectsBeforePause)
                 {
                     /*If we get too many disconnects it can be because the user has logged on
                     their account and started playing, or steam is down. Either way we'll want
@@ -428,8 +442,8 @@ private void OnLoggedOn(SteamUser.LoggedOnCallback callback)
                 case EResult.NoConnection:
                 case EResult.TryAnotherCM:
                 case EResult.ServiceUnavailable:
-                    mLog.Write(Log.LogLevel.Warn, $"Service unavailable. We'll force a pause here.");
-                    mDisconnectedCounter = 4;
+                    mLog.Write(Log.LogLevel.Warn, $"Service unavailable. Waiting 1 minute.");
+                    Thread.Sleep(TimeSpan.FromMinutes(1));
                     return;
             }
 
@@ -445,6 +459,9 @@ private void OnLoggedOn(SteamUser.LoggedOnCallback callback)
             mSteam.nounce = callback.WebAPIUserNonce;
             mBotState = BotState.LoggedIn;
 
+            if (callback.CellID != 0 && Program.mGlobalDB.CellID != callback.CellID)
+                Program.mGlobalDB.CellID = callback.CellID;
+
             mHasConnectedOnce = true;
             mDisconnectedCounter = 0;
             mPlayingBlocked = false;
@@ -519,9 +536,9 @@ private void OnFriendMsgCallback(SteamFriends.FriendMsgCallback callback)
                 string friendUserName = mSteam.friends.GetFriendPersonaName(callback.Sender);
                 mLogChat.Write(Log.LogLevel.Text, $"Msg from {friendUserName}: {callback.Message}");
 
-                /*Clear blocked users that are older than 20 minutes
+                /*Clear blocked users that are older than 10 minutes
                 This is to avoid responding every time a user is spamming us in the chat*/
-                mSteamChatBlockList.RemoveAll(data => DateTime.Now.Subtract(data.DateReceived) > TimeSpan.FromMinutes(20));
+                mSteamChatBlockList.RemoveAll(data => DateTime.Now.Subtract(data.DateReceived) > TimeSpan.FromMinutes(10));
 
                 /*Only send a response if one is set in the settings file*/
                 if (!string.IsNullOrWhiteSpace(mAccountSettings.ChatResponse))

HourBoostr/Bot.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace HourBoostr
+{
+    /*
+     * Credits for this part goes to JustArchi at:
+     * https://github.com/JustArchi/ArchiSteamFarm
+     */
+
+    class ConcurrentEnumerator<T> : IEnumerator<T>
+    {
+        public T Current => Enumerator.Current;
+
+        private readonly IEnumerator<T> Enumerator;
+        private readonly ReaderWriterLockSlim Lock;
+
+        object IEnumerator.Current => Current;
+
+        internal ConcurrentEnumerator(ICollection<T> collection, ReaderWriterLockSlim rwLock)
+        {
+            if ((collection == null) || (rwLock == null))
+            {
+                throw new ArgumentNullException(nameof(collection) + " || " + nameof(rwLock));
+            }
+
+            rwLock.EnterReadLock();
+
+            Lock = rwLock;
+            Enumerator = collection.GetEnumerator();
+        }
+
+        public void Dispose() => Lock?.ExitReadLock();
+
+        public bool MoveNext() => Enumerator.MoveNext();
+        public void Reset() => Enumerator.Reset();
+    }
+}

HourBoostr/ConcurrentEnumerator.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace HourBoostr
+{
+    /*
+     * Credits for this part goes to JustArchi at:
+     * https://github.com/JustArchi/ArchiSteamFarm
+     */
+
+    class ConcurrentHashSet<T> : ICollection<T>, IDisposable
+    {
+        public int Count
+        {
+            get
+            {
+                Lock.EnterReadLock();
+
+                try
+                {
+                    return HashSet.Count;
+                }
+                finally
+                {
+                    Lock.ExitReadLock();
+                }
+            }
+        }
+
+        public bool IsReadOnly => false;
+
+        private readonly HashSet<T> HashSet = new HashSet<T>();
+        private readonly ReaderWriterLockSlim Lock = new ReaderWriterLockSlim();
+
+        public void Clear()
+        {
+            Lock.EnterWriteLock();
+
+            try
+            {
+                HashSet.Clear();
+            }
+            finally
+            {
+                Lock.ExitWriteLock();
+            }
+        }
+
+        public bool Contains(T item)
+        {
+            Lock.EnterReadLock();
+
+            try
+            {
+                return HashSet.Contains(item);
+            }
+            finally
+            {
+                Lock.ExitReadLock();
+            }
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            Lock.EnterReadLock();
+
+            try
+            {
+                HashSet.CopyTo(array, arrayIndex);
+            }
+            finally
+            {
+                Lock.ExitReadLock();
+            }
+        }
+
+        public void Dispose() => Lock.Dispose();
+        public IEnumerator<T> GetEnumerator() => new ConcurrentEnumerator<T>(HashSet, Lock);
+
+        public bool Remove(T item)
+        {
+            Lock.EnterWriteLock();
+
+            try
+            {
+                return HashSet.Remove(item);
+            }
+            finally
+            {
+                Lock.ExitWriteLock();
+            }
+        }
+
+        void ICollection<T>.Add(T item) => Add(item);
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        internal void Add(T item)
+        {
+            Lock.EnterWriteLock();
+
+            try
+            {
+                HashSet.Add(item);
+            }
+            finally
+            {
+                Lock.ExitWriteLock();
+            }
+        }
+
+        internal void ClearAndTrim()
+        {
+            Lock.EnterWriteLock();
+
+            try
+            {
+                HashSet.Clear();
+                HashSet.TrimExcess();
+            }
+            finally
+            {
+                Lock.ExitWriteLock();
+            }
+        }
+
+        internal bool ReplaceIfNeededWith(ICollection<T> items)
+        {
+            Lock.EnterUpgradeableReadLock();
+
+            try
+            {
+                if (HashSet.SetEquals(items))
+                {
+                    return false;
+                }
+
+                ReplaceWith(items);
+                return true;
+            }
+            finally
+            {
+                Lock.ExitUpgradeableReadLock();
+            }
+        }
+
+        internal void ReplaceWith(IEnumerable<T> items)
+        {
+            Lock.EnterWriteLock();
+
+            try
+            {
+                HashSet.Clear();
+
+                foreach (T item in items)
+                {
+                    HashSet.Add(item);
+                }
+
+                HashSet.TrimExcess();
+            }
+            finally
+            {
+                Lock.ExitWriteLock();
+            }
+        }
+    }
+}

HourBoostr/ConcurrentHashSet.cs

@@ -95,6 +95,14 @@ public class AccountSettings
             public bool JoinSteamGroup { get; set; } = true;
 
 
+            /// <summary>
+            /// If we should ignore running this account
+            /// Useful if user doesn't want to boost a particular account right now but
+            /// don't want to delete it from settings file because that's annoying as fuck
+            /// </summary>
+            public bool IgnoreAccount { get; set; } = false;
+
+
             /// <summary>
             /// What the bot should reply if someone sends it a message
             /// </summary>

HourBoostr/Config.cs

@@ -6,6 +6,7 @@ namespace HourBoostr
     class EndPoint
     {
         public static string SETTINGS_FILE_PATH = Path.Combine(Application.StartupPath, "Settings.json");
+        public static string GLOBAL_SETTINGS_FILE_PATH = Path.Combine(Application.StartupPath, "GlobalDB.hb");
         public static string SENTRY_FOLDER_PATH = Path.Combine(Application.StartupPath, "Sentryfiles");
         public static string LOG_FOLDER_PATH = Path.Combine(Application.StartupPath, "Logs");
         public static string CONSOLE_TITLE = $"HourBoostr v{Application.ProductVersion}";