/// <summary>
/// Startup method for Ceres UCI chess engine and supplemental features.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
#if DEBUG
Console.WriteLine();
ConsoleUtils.WriteLineColored(ConsoleColor.Red, "*** WARNING: Ceres binaries built in Debug mode and will run much more slowly than Release");
#endif
OutputBanner();
CheckRecursiveOverflow();
HardwareManager.VerifyHardwareSoftwareCompatability();
// Load (or cause to be created) a settings file.
if (!CeresUserSettingsManager.DefaultConfigFileExists)
{
Console.WriteLine();
ConsoleUtils.WriteLineColored(ConsoleColor.Red, $"*** NOTE: Configuration file {CeresUserSettingsManager.DefaultCeresConfigFileName} not found in working directory.");
Console.WriteLine();
Console.WriteLine($"Prompting to for required values to initialize:");
CeresUserSettingsManager.DoSetupInitialize();
}
// Configure logging level
const bool LOG = false;
CeresEnvironment.MONITORING_EVENTS = LOG;
LogLevel logLevel = LOG ? LogLevel.Information : LogLevel.Critical;
LoggerTypes loggerTypes = LoggerTypes.WinDebugLogger | LoggerTypes.ConsoleLogger;
CeresEnvironment.Initialize(loggerTypes, logLevel);
CeresEnvironment.MONITORING_METRICS = CeresUserSettingsManager.Settings.LaunchMonitor;
// if (CeresUserSettingsManager.Settings.DirLC0Networks != null)
// NNWeightsFilesLC0.RegisterDirectory(CeresUserSettingsManager.Settings.DirLC0Networks);
MCTSEngineInitialization.BaseInitialize();
Console.WriteLine();
#if DEBUG
CheckDebugAllowed();
#endif
if (args.Length > 0 && args[0].ToUpper() == "CUSTOM")
{
TournamentTest.Test(); return;
// SuiteTest.RunSuiteTest(); return;
}
StringBuilder allArgs = new StringBuilder();
for (int i = 0; i < args.Length; i++)
{
allArgs.Append(args[i] + " ");
}
string allArgsString = allArgs.ToString();
DispatchCommands.ProcessCommand(allArgsString);
// Win32.WriteCrashdumpFile(@"d:\temp\dump.dmp");
}
/*
* public string ExceptionMessage
* {
* get
* {
* if(Exception == null)
* {
* return String.Empty;
*
* }
*
* return Exception.Message;
* }
* }*/
public Log(LoggerTypes type, string message, string exceptionMessage = null)
{
this.LoggerType = type;
this.Message = message;
this.Date = DateTime.Now;
this.ExceptionMessage = exceptionMessage;
}
public void AddLog(LoggerTypes type, string message, Exception exception = null)
{
LogModel newLog = new LogModel(type, message, exception);
EventLog.Add(newLog);
this.LastLog = newLog.ToString();
OnEventLogAdded(newLog);
}
//BBernard - this concept for initializing a ListLogger was inspired by the Microsoft walk-through
// for testing Azure Functions here: https://docs.microsoft.com/en-us/azure/azure-functions/functions-test-a-function
public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.List)
{
var logger = type == LoggerTypes.List
? new ListLogger()
: NullLoggerFactory.Instance.CreateLogger("Null Logger");
return(logger);
}
public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
{
if (type == LoggerTypes.List)
{
return(new ListLogger());
}
else
{
return(NullLoggerFactory.Instance.CreateLogger("Null Logger"));
}
}
} //required when loggertypes as appinsights; otherwise omit
public LoggerType GetLoggerTypes()
{
if (string.IsNullOrEmpty(LoggerTypes))
{
return(default(LoggerType));
}
string loggerTypes = LoggerTypes.Replace(";", ",");
return(Enum.Parse <LoggerType>(loggerTypes, true));
}
public static Mock <ILoggerFactory> CreateLoggerFactory(LoggerTypes type = LoggerTypes.Null)
{
var mock = new Mock <ILoggerFactory>();
mock.Setup(m => m.CreateLogger(It.IsAny <string>()))
.Returns(() =>
{
return(CreateLogger(type));
});
return(mock);
}
public ILogger CreateLogger(LoggerTypes type, ICollection <IAppender> appenders)
{
switch (type)
{
case LoggerTypes.Logger:
return(new Logger(appenders));
default:
throw new ArgumentException("Invalid logger type!");
}
}
/*
* public string ExceptionMessage
* {
* get
* {
* if(Exception == null)
* {
* return String.Empty;
*
* }
*
* return Exception.Message;
* }
* }*/
public Log(LoggerTypes type, string message, Exception exception = null)
{
this.LoggerType = type;
this.Message = message;
this.Date = DateTime.Now;
if (exception != null)
{
this.StackTrace = exception.StackTrace;
this.ExceptionMessage = exception.Message;
}
}
/// <param name="loggerType">The logging service type</param>
/// <param name="level" >The minimum logging level</param>
/// <param name="logFilePath">The full path of the log file</param>
public LoggerOptions(LoggerTypes loggerType, LogRecordTypes level, string logFilePath)
{
LoggerType = loggerType;
Level = level;
if ((LoggerType & LoggerTypes.File) != 0 && string.IsNullOrEmpty(logFilePath))
{
throw new ArgumentNullException(nameof(logFilePath));
}
LogFilePath = logFilePath;
}
public static ILogger GetLogger(LoggerTypes logType, TextBox writer)
{
switch (logType)
{
case LoggerTypes.Silent:
return(new SilentLoggerVisitor());
case LoggerTypes.Verbose:
return(new VerboseLoggerVisitor(writer));
default:
return(new SummaryLoggerVisitor(writer));
}
}
/// <summary>
/// Write a message and possibly an exception to the logging system
/// </summary>
/// <param name="loggerType">Type of logger to use</param>
/// <param name="logLevel">Level of log reporting</param>
/// <param name="message">Message to be logged</param>
/// <param name="ex">Exception to be logged; null if no exception</param>
/// <remarks>Log message will not be written if logLevel is LogLevel or higher)</remarks>
private static void WriteLogWork(LoggerTypes loggerType, BaseLogger.LogLevels logLevel, string message, Exception ex)
{
if (OfflineMode && loggerType == LoggerTypes.LogDb)
{
loggerType = LoggerTypes.LogFile;
}
BaseLogger myLogger;
// Establish which logger will be used
switch (loggerType)
{
case LoggerTypes.LogDb:
// Note that the Database logger will (by default) also echo messages to the file logger
myLogger = mDbLogger;
message = System.Net.Dns.GetHostName() + ": " + message;
break;
case LoggerTypes.LogFile:
myLogger = mFileLogger;
if (!string.IsNullOrWhiteSpace(FileLogger.LogFilePath) &&
!FileLogger.LogFilePath.Contains(Path.DirectorySeparatorChar.ToString()))
{
var logFileName = Path.GetFileName(FileLogger.LogFilePath);
string workDirLogPath;
if (string.IsNullOrEmpty(WorkDirPath))
{
workDirLogPath = Path.Combine(".", logFileName);
}
else
{
workDirLogPath = Path.Combine(WorkDirPath, logFileName);
}
ChangeLogFileBaseName(workDirLogPath, FileLogger.AppendDateToBaseFileName);
}
break;
default:
throw new Exception("Invalid logger type specified");
}
MessageLogged?.Invoke(message, logLevel);
// Send the log message
myLogger?.LogMessage(logLevel, message, ex);
}
public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
{
ILogger logger;
if (type == LoggerTypes.List)
{
logger = new ListLogger();
}
else
{
logger = new NullLogger();
}
return(logger);
}
/// <summary>
/// Adds a logger to the loggers collection
/// </summary>
public void AddLogger(ILogger logger, LoggerTypes type)
{
if (!AllowedTypes.HasFlag(type))
{
return;
}
foreach (var log in Records.ToList())
{
if (log.Type >= MinimumLevel)
{
logger.Log(log);
}
}
_loggers.Add(logger);
}
public LogModel(LoggerTypes loggerType, string message, Exception exception = null)
{
this.LoggerType = loggerType;
this.Message = string.Intern(message);
if (exception == null)
{
return;
}
if (exception.StackTrace != null)
{
this.StackTrace = string.Intern(exception.StackTrace);
}
this.ExceptionMessage = string.Intern(exception.Message);
}
public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
{
ILogger logger;
if (type == LoggerTypes.List)
{
logger = new ListLogger();
}
else
{
logger = NullLoggerFactory.Instance.CreateLogger("Null Logger");
}
return(logger);
}
public void AddLogger <TLogger, TInfo>() where TLogger : ILogger <TInfo>
{
if (LoggerTypes.ContainsKey(typeof(TInfo)))
{
var list = LoggerTypes[typeof(TInfo)];
list.Add(typeof(TLogger));
}
else
{
LoggerTypes.Add(typeof(TInfo), new List <Type>()
{
typeof(TLogger)
});
}
}
public static LoggerFactory GetLoggerFactory(LoggerTypes loggerType)
{
switch (loggerType)
{
case LoggerTypes.EventLogger:
return(new EventLoggerFactory());
case LoggerTypes.RegistryLogger:
return(new RegistryLoggerFactory());
case LoggerTypes.TxtLogger:
return(new TxtLoggerFactory());
default:
throw new InvalidOperationException();
}
}
public LogModel(LoggerTypes loggerType, string message, string html = "", Exception exception = null)
{
Date = DateTime.Now;
this.LoggerType = loggerType;
this.Message = string.Intern(message);
this.Html = html;
if (exception == null)
{
return;
}
if (exception.StackTrace != null)
{
this.StackTrace = string.Intern(exception.StackTrace);
}
this.ExceptionMessage = string.Intern(exception.Message);
}
private void LogToFile(string message, LoggerTypes logType, string errorCode)
{
switch (logType)
{
case LoggerTypes.Audit:
case LoggerTypes.Info:
_fileLogger.Info(message);
break;
case LoggerTypes.Debug:
_fileLogger.Debug(message);
break;
case LoggerTypes.Warn:
_fileLogger.Warn(message);
break;
case LoggerTypes.Error:
_fileLogger.Error((!string.IsNullOrEmpty(errorCode) ? errorCode + " - " : string.Empty) + message);
break;
}
}
private async void RunningThread()
{
const int failedWaitTime = 5000;
int currentFails = 0;
//Reset account state
AccountState = AccountState.Good;
while (IsRunning)
{
if (CheckTime())
{
Stop();
}
WaitPaused();
if ((_proxyIssue || CurrentProxy == null) && UserSettings.AutoRotateProxies)
{
bool success = await ChangeProxy();
//Fails when it's stopping
if (!success)
{
continue;
}
//Have to restart to set proxy
Restart();
_proxyIssue = false;
}
StartingUp = true;
if (currentFails >= UserSettings.MaxFailBeforeReset)
{
currentFails = 0;
_client.Logout();
}
if (_failedInventoryReponses >= _failedInventoryUntilBan)
{
AccountState = AccountState.PermanentBan;
LogCaller(new LoggerEventArgs("Potential account ban", LoggerTypes.Warning));
Stop();
}
++currentFails;
var result = new MethodResult();
#region Startup
try
{
if (!_client.LoggedIn)
{
//Login
result = await AcLogin();
if (!result.Success)
{
//A failed login should require longer wait
await Task.Delay(failedWaitTime * 3);
continue;
}
}
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
result = await CheckReauthentication();
if (!result.Success)
{
LogCaller(new LoggerEventArgs("Echo failed. Logging out before retry.", LoggerTypes.Debug));
Stop();
}
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
if (UserSettings.StopOnAPIUpdate)
{
//Get Game settings
LogCaller(new LoggerEventArgs("Grabbing game settings ...", LoggerTypes.Debug));
try
{
var remote = new Version();
if (_client.ClientSession.GlobalSettings != null)
{
remote = new Version(_client.ClientSession.GlobalSettings?.MinimumClientVersion);
}
if (_client.VersionStr < remote)
{
LogCaller(new LoggerEventArgs($"Emulates API {_client.VersionStr} ...", LoggerTypes.FatalError, new Exception($"New API needed {remote}. Stopping ...")));
Stop();
}
}
catch (Exception ex1)
{
//if (AccountState != AccountState.CaptchaReceived || AccountState != AccountState.HashIssues)
// AccountState = AccountState.TemporalBan;
LogCaller(new LoggerEventArgs("Exception: " + ex1, LoggerTypes.Debug));
LogCaller(new LoggerEventArgs("Game settings failed", LoggerTypes.FatalError, new Exception("Maybe this account is banned ...")));
Stop();
}
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
//Get pokemon settings
if (PokeSettings == null)
{
LogCaller(new LoggerEventArgs("Grabbing pokemon settings ...", LoggerTypes.Debug));
result = await GetItemTemplates();
if (!result.Success)
{
//if (AccountState != AccountState.CaptchaReceived || AccountState != AccountState.HashIssues)
// AccountState = AccountState.TemporalBan;
LogCaller(new LoggerEventArgs("Load pokemon settings failed", LoggerTypes.FatalError, new Exception("Maybe this account is banned ...")));
Stop();
}
}
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
//Auto complete tutorials
if (UserSettings.CompleteTutorial)
{
if (!PlayerData.TutorialState.Contains(TutorialState.AvatarSelection))
{
result = await MarkStartUpTutorialsComplete(true);
if (!result.Success)
{
LogCaller(new LoggerEventArgs("Failed. Marking startup tutorials completed..", LoggerTypes.Warning));
Stop();
}
LogCaller(new LoggerEventArgs("Marking startup tutorials completed.", LoggerTypes.Success));
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
}
_failedInventoryReponses = 0;
WaitPaused();
//End startup phase
StartingUp = false;
//Prevent changing back to running state
if (State != BotState.Stopping)
{
State = BotState.Running;
}
//Update location
if (_firstRun)
{
LogCaller(new LoggerEventArgs("Setting default location ...", LoggerTypes.Debug));
result = await UpdateLocation(new GeoCoordinate(UserSettings.Latitude, UserSettings.Longitude));
UpdateInventory(InventoryRefresh.All);
if (!result.Success)
{
Stop();
}
}
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
#endregion
#region PokeStopTask
//Get pokestops
LogCaller(new LoggerEventArgs("getting pokestops...", LoggerTypes.Debug));
MethodResult <List <FortData> > pokestops = GetAllForts();
if (!pokestops.Success)
{
await Task.Delay(failedWaitTime);
continue;
}
int pokeStopNumber = 1;
int totalStops = pokestops.Data.Count;
if (totalStops == 0)
{
_proxyIssue = false;
_potentialPokeStopBan = false;
LogCaller(new LoggerEventArgs(String.Format("{0}. Failure {1}/{2}", pokestops.Message, currentFails, UserSettings.MaxFailBeforeReset), LoggerTypes.Warning));
if (UserSettings.AutoRotateProxies && currentFails >= UserSettings.MaxFailBeforeReset)
{
if (pokestops.Message.StartsWith("No pokestop data found.", StringComparison.Ordinal))
{
_proxyIssue = true;
await ChangeProxy();
}
}
await Task.Delay(failedWaitTime);
continue;
}
var defaultLocation = new GeoCoordinate(_client.ClientSession.Player.Latitude, _client.ClientSession.Player.Longitude);
int currentFailedStops = 0;
var pokestopsToFarm = new Queue <FortData>(pokestops.Data);
while (pokestopsToFarm.Any())
{
// In each iteration of the loop we store the current level
int prevLevel = Level;
if (!IsRunning || currentFailedStops >= UserSettings.MaxFailBeforeReset)
{
break;
}
if (CheckTime())
{
Stop();
}
FortData pokestop = pokestopsToFarm.Dequeue();
LogCaller(new LoggerEventArgs("Fort Dequeued: " + pokestop.Id, LoggerTypes.Debug));
if (UserSettings.GoOnlyToGyms && pokestop.Type != FortType.Gym)
{
continue;
}
var currentLocation = new GeoCoordinate(_client.ClientSession.Player.Latitude, _client.ClientSession.Player.Longitude);
var fortLocation = new GeoCoordinate(pokestop.Latitude, pokestop.Longitude);
double distance = CalculateDistanceInMeters(currentLocation, fortLocation);
string fort = "pokestop";
LoggerTypes loggerTypes = LoggerTypes.Info;
if (pokestop.Type == FortType.Gym && Level >= 5 && !UserSettings.DefaultTeam.Equals("Neutral") && !String.IsNullOrEmpty(UserSettings.DefaultTeam))
{
if (!UserSettings.SpinGyms)
{
continue;
}
fort = "Gym";
loggerTypes = LoggerTypes.Gym;
}
LogCaller(new LoggerEventArgs(String.Format("Going to {0} {1} of {2}. Distance {3:0.00}m", fort, pokeStopNumber, totalStops, distance), loggerTypes));
//Go to pokestops
MethodResult walkResult = await GoToLocation(new GeoCoordinate(pokestop.Latitude, pokestop.Longitude));
if (!walkResult.Success)
{
LogCaller(new LoggerEventArgs("Too many failed walking attempts. Restarting to fix ...", LoggerTypes.Warning));
LogCaller(new LoggerEventArgs("Result: " + walkResult.Message, LoggerTypes.Debug));
Stop();
}
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
if (CatchDisabled)
{
//Check delay if account not have balls
var now = DateTime.Now;
LogCaller(new LoggerEventArgs("Now: " + now.ToLongDateString() + " " + now.ToLongTimeString(), LoggerTypes.Debug));
LogCaller(new LoggerEventArgs("TimeAutoCatch: " + TimeAutoCatch.ToLongDateString() + " " + TimeAutoCatch.ToLongTimeString(), LoggerTypes.Debug));
if (now > TimeAutoCatch)
{
CatchDisabled = false;
LogCaller(new LoggerEventArgs("Enable catch after wait time.", LoggerTypes.Info));
}
}
// NOTE: not an "else" we could enabled catch in this time
if (!CatchDisabled)
{
var remainingBalls = RemainingPokeballs();
LogCaller(new LoggerEventArgs("Remaining Balls: " + remainingBalls, LoggerTypes.Debug));
if (remainingBalls > 0)
{
if (PlayerData.MaxPokemonStorage > Pokemon.Count)
{
//Catch nearby pokemon
MethodResult nearbyPokemonResponse = await CatchNeabyPokemon();
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
//Catch incense pokemon
MethodResult incensePokemonResponse = await CatchInsencePokemon();
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
//Catch lured pokemon
MethodResult luredPokemonResponse = await CatchLuredPokemon(pokestop);
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
//Check sniping NearyPokemon
MethodResult Snipe = await SnipeAllNearyPokemon();
if (Snipe.Success)
{
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
pokestopsToFarm.Clear();
pokestopsToFarm = new Queue <FortData>(GetAllForts().Data);
continue;
}
}
else
{
LogCaller(new LoggerEventArgs("You inventory pokemon storage is full please transfer some pokemons.", LoggerTypes.Warning));
}
}
else
{
LogCaller(new LoggerEventArgs("You don't have any pokeball catching pokemon will be disabled during " + UserSettings.DisableCatchDelay.ToString(CultureInfo.InvariantCulture) + " minutes.", LoggerTypes.Info));
CatchDisabled = true;
TimeAutoCatch = DateTime.Now.AddMinutes(UserSettings.DisableCatchDelay);
}
}
//Stop bot instantly
if (!IsRunning)
{
break;
}
//Clean inventory,
if (UserSettings.RecycleItems)
{
await RecycleFilteredItems();
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
//Search
double filledInventorySpace = FilledInventoryStorage();
LogCaller(new LoggerEventArgs(String.Format("Filled Inventory Storage: {0:0.00}%", filledInventorySpace), LoggerTypes.Debug));
if ((filledInventorySpace < UserSettings.SearchFortBelowPercent) && (filledInventorySpace <= 100))
{
if (pokestop.CooldownCompleteTimestampMs < DateTime.UtcNow.ToUnixTime())
{
if (pokestop.Type == FortType.Gym && Level >= 5 && (!string.IsNullOrEmpty(UserSettings.DefaultTeam) || UserSettings.DefaultTeam != "Neutral"))
{
if (!PlayerData.TutorialState.Contains(TutorialState.GymTutorial))
{
if (PlayerData.Team == TeamColor.Neutral)
{
TeamColor team = TeamColor.Neutral;
foreach (TeamColor _team in Enum.GetValues(typeof(TeamColor)))
{
if (UserSettings.DefaultTeam == _team.ToString())
{
team = _team;
}
}
if (team != TeamColor.Neutral)
{
var setplayerteam = await SetPlayerTeam(team);
if (setplayerteam.Success)
{
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
result = await MarkTutorialsComplete(new[] { TutorialState.GymTutorial });
if (!result.Success)
{
LogCaller(new LoggerEventArgs("Failed. Marking Gym tutorials completed..", LoggerTypes.Warning));
continue;
}
LogCaller(new LoggerEventArgs("Marking Gym tutorials completed.", LoggerTypes.Success));
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
//Check for missed tutorials
foreach (TutorialState tutos in Enum.GetValues(typeof(TutorialState)))
{
if (!PlayerData.TutorialState.Contains(tutos))
{
DialogResult box = MessageBox.Show($"Tutorial {tutos.ToString()} is not completed on this account {PlayerData.Username}! Complete this?", "Confirmation", MessageBoxButtons.YesNo);
if (box == DialogResult.Yes)
{
result = await MarkTutorialsComplete(new[] { tutos });
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
}
}
//First spin gym after complet tuto
var gyminfo = await GymGetInfo(pokestop);
if (gyminfo.Success)
{
LogCaller(new LoggerEventArgs("Gym Name: " + gyminfo.Data.Name, LoggerTypes.Info));
}
else
{
continue;
}
MethodResult spingym = await SearchPokestop(pokestop);
//OutOfRange will show up as a success
if (spingym.Success)
{
currentFailedStops = 0;
//Try to deploy, full gym is 6 now
if (gyminfo.Data.GymStatusAndDefenders.GymDefender.Count < 6)
{
//Checks team color if same of player or Neutral
if (pokestop.OwnedByTeam == PlayerData.Team || pokestop.OwnedByTeam == TeamColor.Neutral)
{
//Check if config as deploy actived
if (UserSettings.DeployPokemon)
{
//Try to deploy
await GymDeploy(pokestop);
}
}
}
//Here try to attack gym not released yet
//
}
else
{
if (currentFailedStops > 10)
{
Stop();
}
++currentFailedStops;
}
}
}
}
else if (PlayerData.TutorialState.Contains(TutorialState.GymTutorial))
{
var gyminfo = await GymGetInfo(pokestop);
if (gyminfo.Success)
{
LogCaller(new LoggerEventArgs("Gym Name: " + gyminfo.Data.Name, LoggerTypes.Info));
}
else
{
continue;
}
MethodResult spingym = await SearchPokestop(pokestop);
//OutOfRange will show up as a success
if (spingym.Success)
{
currentFailedStops = 0;
//Try to deploy, full gym is 6 now
if (gyminfo.Data.GymStatusAndDefenders.GymDefender.Count < 6)
{
//Checks team color if same of player or Neutral
if (pokestop.OwnedByTeam == PlayerData.Team || pokestop.OwnedByTeam == TeamColor.Neutral)
{
//Check if config as deploy actived
if (UserSettings.DeployPokemon)
{
//Try to deploy
await GymDeploy(pokestop);
}
}
}
//Here try to attack gym not released yet
//
}
else
{
if (currentFailedStops > 10)
{
Stop();
}
++currentFailedStops;
}
}
}
else
{
if (!PlayerData.TutorialState.Contains(TutorialState.PokestopTutorial))
{
result = await MarkTutorialsComplete(new[] { TutorialState.PokestopTutorial, TutorialState.PokemonBerry, TutorialState.UseItem });
if (!result.Success)
{
LogCaller(new LoggerEventArgs("Failed. Marking pokestop, pokemonberry, useitem, pokemoncapture tutorials completed..", LoggerTypes.Warning));
Stop();
}
LogCaller(new LoggerEventArgs("Marking pokestop, pokemonberry, useitem, pokemoncapture tutorials completed.", LoggerTypes.Success));
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
var fortDetails = await FortDetails(pokestop);
if (fortDetails.Success)
{
LogCaller(new LoggerEventArgs("Fort Name: " + fortDetails.Data.Name, LoggerTypes.Info));
}
else
{
continue;
}
MethodResult searchResult = await SearchPokestop(pokestop);
//OutOfRange will show up as a success
if (searchResult.Success)
{
currentFailedStops = 0;
}
else
{
if (currentFailedStops > 10)
{
Stop();
}
++currentFailedStops;
}
}
}
else
{
LogCaller(new LoggerEventArgs(String.Format("Skipping fort. In cooldown"), LoggerTypes.Info));
}
}
else
{
LogCaller(new LoggerEventArgs(String.Format("Skipping fort. Inventory Currently at {0:0.00}% filled", filledInventorySpace), LoggerTypes.Info));
}
//Stop bot instantly
if (!IsRunning)
{
break;
}
//Check account client session state
if (AccountState != AccountState.CaptchaReceived && (_client.ClientSession.State == SessionState.Paused || _client.ClientSession.State == SessionState.Stopped))
{
await _client.ClientSession.ResumeAsync();
}
// evolve, transfer, etc on first and every 10 stops
if (IsRunning && ((pokeStopNumber > 4 && pokeStopNumber % 10 == 0) || pokeStopNumber == 1))
{
// clean account state
if (AccountState != AccountState.Flagged || AccountState != AccountState.SoftBan)
{
AccountState = AccountState.Good;
}
MethodResult echoResult = await CheckReauthentication();
//Echo failed, restart
if (!echoResult.Success)
{
Stop();
}
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
if (UserSettings.TransferPokemon)
{
MethodResult transferResult = await TransferFilteredPokemon();
if (transferResult.Success)
{
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
}
if (UserSettings.EvolvePokemon)
{
MethodResult evolveResult = await EvolveFilteredPokemon();
if (evolveResult.Success)
{
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
}
if (UserSettings.UpgradePokemon)
{
MethodResult upgradeResult = await UpgradeFilteredPokemon();
if (upgradeResult.Success)
{
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
}
if (UserSettings.IncubateEggs)
{
MethodResult incubateResult = await IncubateEggs();
if (incubateResult.Success)
{
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
}
}
UpdateInventory(InventoryRefresh.All); //all inventory
}
WaitPaused();
UpdateInventory(InventoryRefresh.Stats);
if (Level > prevLevel)
{
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
await ClaimLevelUpRewards(Level);
}
++pokeStopNumber;
await Task.Delay(CalculateDelay(UserSettings.GeneralDelay, UserSettings.GeneralDelayRandom));
if (UserSettings.MaxLevel > 0 && Level >= UserSettings.MaxLevel)
{
LogCaller(new LoggerEventArgs(String.Format("Max level of {0} reached.", UserSettings.MaxLevel), LoggerTypes.Info));
Stop();
}
if (_totalZeroExpStops > 25)
{
LogCaller(new LoggerEventArgs("Potential PokeStop SoftBan.", LoggerTypes.Warning));
AccountState = AccountState.SoftBan;
// reset values
_totalZeroExpStops = 0;
Stop();
}
if (_potentialPokeStopBan)
{
if (_failedPokestopResponse >= 10)
{
AccountState = AccountState.SoftBan;
_failedPokestopResponse = 0;
LogCaller(new LoggerEventArgs("Potential PokeStop SoftBan or daily limit reached. Stoping ...", LoggerTypes.Warning));
Stop();
}
else
{
//Break out of pokestop loop to test for ip ban
break;
}
}
if (Tracker.PokemonCaught >= UserSettings.CatchPokemonDayLimit && Tracker.PokestopsFarmed >= UserSettings.SpinPokestopsDayLimit)
{
LogCaller(new LoggerEventArgs("Daily limits reached. Stoping ...", LoggerTypes.Warning));
Stop();
}
}
}
catch (StackOverflowException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs(ex.Message, LoggerTypes.FatalError));
Stop();
}
catch (HashVersionMismatchException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs(ex.Message, LoggerTypes.FatalError));
Stop();
}
catch (GoogleLoginException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs(ex.Message, LoggerTypes.FatalError));
Stop();
}
catch (PtcLoginException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs(ex.Message, LoggerTypes.FatalError));
Stop();
}
catch (TaskCanceledException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs("TaskCanceledException. Restarting ...", LoggerTypes.Warning, ex));
}
catch (OperationCanceledException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs("OperationCanceledException. Restarting ...", LoggerTypes.Warning, ex));
}
catch (APIBadRequestException ex)
{
LogCaller(new LoggerEventArgs("API Bad Request. Restarting ...", LoggerTypes.Warning, ex));
}
catch (InvalidPlatformException ex)
{
LogCaller(new LoggerEventArgs("Invalid Platform or token session refresh. Restarting ...", LoggerTypes.Warning, ex));
}
catch (SessionInvalidatedException ex)
{
LogCaller(new LoggerEventArgs("Session Invalidated or token session refresh. Restarting ...", LoggerTypes.Warning, ex));
}
catch (PokeHashException ex)
{
AccountState = AccountState.HashIssues;
LogCaller(new LoggerEventArgs($"Hash service exception occured. Restarting ...", LoggerTypes.Warning, ex));
}
catch (SessionUnknowException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs("Skipping request. Restarting ...", LoggerTypes.Exception, ex));
}
catch (ArgumentOutOfRangeException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs("Skipping request. Restarting ...", LoggerTypes.Exception, ex));
}
catch (SessionStateException ex)
{
AccountState = AccountState.Unknown;
LogCaller(new LoggerEventArgs("SessionStateException. Restarting ...", LoggerTypes.Exception, ex));
_client.CleanLocalAccesToken();
}
catch (Exception ex)
{
LogCaller(new LoggerEventArgs("Unknown exception occured. Restarting ...", LoggerTypes.Exception, ex));
}
#endregion
currentFails = 0;
_firstRun = false;
}
State = BotState.Stopped;
Stop();
LogCaller(new LoggerEventArgs(String.Format("Bot fully stopped at {0}", DateTime.Now), LoggerTypes.Info));
if (_autoRestart)
{
_wasAutoRestarted = true;
Start();
}
else if (UserSettings.AutoRemoveOnStop)
{
RemoveProxy();
}
}
public LoggerEventArgs(string message, LoggerTypes logtype, Exception exception = null)
{
LogType = logtype;
Message = message;
Exception = exception;
}
//Catch encountered pokemon
private async Task <MethodResult> CatchPokemon(dynamic eResponse, MapPokemon mapPokemon, bool snipped = false)
{
PokemonData _encounteredPokemon = null;
long _unixTimeStamp = 0;
ulong _encounterId = 0;
string _spawnPointId = null;
string _pokemonType = null;
//Default catch success
LoggerTypes _loggerType = LoggerTypes.Success;
// Calling from CatchNormalPokemon
if (eResponse is EncounterResponse &&
(eResponse?.Status == EncounterResponse.Types.Status.EncounterSuccess))
{
_encounteredPokemon = eResponse.WildPokemon?.PokemonData;
_unixTimeStamp = eResponse.WildPokemon?.LastModifiedTimestampMs
+ eResponse.WildPokemon?.TimeTillHiddenMs;
_spawnPointId = eResponse.WildPokemon?.SpawnPointId;
_encounterId = eResponse.WildPokemon?.EncounterId;
_pokemonType = "Normal";
}
// Calling from CatchIncensePokemon
else if (eResponse is IncenseEncounterResponse &&
(eResponse?.Result == IncenseEncounterResponse.Types.Result.IncenseEncounterSuccess))
{
_encounteredPokemon = eResponse?.PokemonData;
_unixTimeStamp = mapPokemon.ExpirationTimestampMs;
_spawnPointId = mapPokemon.SpawnPointId;
_encounterId = mapPokemon.EncounterId;
_pokemonType = "Incense";
}
if (_encounterId == _lastPokeSniperId || snipped)
{
_pokemonType = "Local Snipe: " + _pokemonType;
_loggerType = LoggerTypes.Snipe;
AlreadySnipped = true;
}
CatchPokemonResponse catchPokemonResponse = null;
int attemptCount = 1;
bool berryUsed = false;
if (_encounteredPokemon == null || _encounteredPokemon.PokemonId == PokemonId.Missingno)
{
return(new MethodResult());
}
do
{
if (!CatchDisabled)
{
if (RemainingPokeballs() < 1)
{
LogCaller(new LoggerEventArgs("You don't have any pokeball catching pokemon will be disabled during " + UserSettings.DisableCatchDelay.ToString(CultureInfo.InvariantCulture) + " minutes.", LoggerTypes.Info));
CatchDisabled = true;
TimeAutoCatch = DateTime.Now.AddMinutes(UserSettings.DisableCatchDelay);
return(new MethodResult());
}
}
else
{
return(new MethodResult());
}
//Uses lowest capture probability
float probability = eResponse.CaptureProbability.CaptureProbability_[0];
ItemId pokeBall = GetBestBall(_encounteredPokemon);
if (UserSettings.UseBerries)
{
bool isLowProbability = probability < 0.40;
bool isHighCp = _encounteredPokemon.Cp > 800;
bool isHighPerfection = CalculateIVPerfection(_encounteredPokemon) > 95;
if (!berryUsed)
{
if ((isLowProbability && isHighCp) || isHighPerfection)
{
await UseBerry(mapPokemon, ItemId.ItemRazzBerry);
berryUsed = true;
}
else
{
bool isHighProbability = probability > 0.65;
var catchSettings = UserSettings.CatchSettings.FirstOrDefault(x => x.Id == _encounteredPokemon.PokemonId);
if (isHighProbability && catchSettings.UsePinap)
{
await UseBerry(mapPokemon, ItemId.ItemPinapBerry);
berryUsed = true;
}
else if (new Random().Next(0, 100) < 50)
{
// IF we dont use razz neither use pinap, then we will use nanab randomly the 50% of times.
await UseBerry(mapPokemon, ItemId.ItemNanabBerry);
berryUsed = true;
}
}
await Task.Delay(CalculateDelay(UserSettings.DelayBetweenPlayerActions, UserSettings.PlayerActionDelayRandom));
}
}
await Task.Delay(CalculateDelay(UserSettings.DelayBetweenPlayerActions, UserSettings.PlayerActionDelayRandom));
double reticuleSize = 1.95;
bool hitInsideReticule = true;
//Humanization
if (UserSettings.EnableHumanization)
{
reticuleSize = (double)_rand.Next(10, 195) / 100;
hitInsideReticule = HitInsideReticle();
}
var arPlusValues = new ARPlusEncounterValues();
if (UserSettings.GetArBonus)
{
LogCaller(new LoggerEventArgs("Using AR Bonus Values", LoggerTypes.Debug));
arPlusValues.Awareness = (float)UserSettings.ARBonusAwareness;
arPlusValues.Proximity = (float)UserSettings.ARBonusProximity;
arPlusValues.PokemonFrightened = false;
}
if (!_client.LoggedIn)
{
MethodResult result = await AcLogin();
if (!result.Success)
{
return(result);
}
}
var catchresponse = await _client.ClientSession.RpcClient.SendRemoteProcedureCallAsync(new Request
{
RequestType = RequestType.CatchPokemon,
RequestMessage = new CatchPokemonMessage
{
ArPlusValues = arPlusValues,
EncounterId = _encounterId,
HitPokemon = hitInsideReticule,
NormalizedHitPosition = 1,
NormalizedReticleSize = reticuleSize,
Pokeball = pokeBall,
SpawnPointId = _spawnPointId,
SpinModifier = 1
}.ToByteString()
});
if (catchresponse == null)
{
return(new MethodResult());
}
catchPokemonResponse = CatchPokemonResponse.Parser.ParseFrom(catchresponse);
string pokemon = String.Format("Name: {0}, CP: {1}, IV: {2:0.00}%", _encounteredPokemon.PokemonId.ToString(), _encounteredPokemon.Cp, CalculateIVPerfection(_encounteredPokemon));
string pokeBallName = pokeBall.ToString().Replace("Item", "");
switch (catchPokemonResponse.Status)
{
case CatchPokemonResponse.Types.CatchStatus.CatchError:
LogCaller(new LoggerEventArgs(String.Format("Unknown Error. {0}. Attempt #{1}. Status: {2}", pokemon, attemptCount, catchPokemonResponse.Status), LoggerTypes.Warning));
continue;
case CatchPokemonResponse.Types.CatchStatus.CatchEscape:
//If we get this response, means we're good
_fleeingPokemonResponses = 0;
_potentialPokemonBan = false;
if (AccountState == Enums.AccountState.SoftBan)
{
AccountState = Enums.AccountState.Good;
LogCaller(new LoggerEventArgs("Pokemon ban was lifted", LoggerTypes.Info));
}
LogCaller(new LoggerEventArgs(String.Format("Escaped ball. {0}. Attempt #{1}. Ball: {2}", pokemon, attemptCount, pokeBallName), LoggerTypes.PokemonEscape));
continue;
case CatchPokemonResponse.Types.CatchStatus.CatchFlee:
++_fleeingPokemonResponses;
LogCaller(new LoggerEventArgs(String.Format("Pokemon fled. {0}. Attempt #{1}. Ball: {2}", pokemon, attemptCount, pokeBallName), LoggerTypes.PokemonFlee));
continue;
case CatchPokemonResponse.Types.CatchStatus.CatchMissed:
LogCaller(new LoggerEventArgs(String.Format("Missed. {0}. Attempt #{1}. Status: {2}", pokemon, attemptCount, catchPokemonResponse.Status), LoggerTypes.Warning));
continue;
case CatchPokemonResponse.Types.CatchStatus.CatchSuccess:
//Reset data
_fleeingPokemonResponses = 0;
Tracker.AddValues(1, 0);
_potentialPokemonBan = false;
int expGained = catchPokemonResponse.CaptureAward.Xp.Sum();
int candyGained = catchPokemonResponse.CaptureAward.Candy.Sum();
ExpIncrease(expGained);
//_expGained += expGained;
LogCaller(new LoggerEventArgs(String.Format("[{0}] Pokemon Caught. {1}. Exp {2}. Candy: {3}. Attempt #{4}. Ball: {5}", _pokemonType, pokemon, expGained, candyGained, attemptCount, pokeBallName), _loggerType));
//Auto favorit shiny
if (UserSettings.AutoFavoritShiny && _encounteredPokemon.PokemonDisplay.Shiny)
{
LogCaller(new LoggerEventArgs(String.Format("[{0}] Pokemon shiny. Auto favorit this pokemon.", _encounteredPokemon.PokemonId.ToString()), LoggerTypes.Info));
await FavoritePokemon(new List <PokemonData> {
_encounteredPokemon
}, true);
await Task.Delay(CalculateDelay(UserSettings.DelayBetweenPlayerActions, UserSettings.PlayerActionDelayRandom));
}
//Pokemon.Add(_encounteredPokemon);
UpdateInventory(InventoryRefresh.Pokemon);
UpdateInventory(InventoryRefresh.PokemonCandy);
return(new MethodResult
{
Message = "Pokemon caught",
Success = true
});
}
++attemptCount;
await Task.Delay(CalculateDelay(UserSettings.DelayBetweenPlayerActions, UserSettings.PlayerActionDelayRandom));
} while (catchPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed || catchPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
return(new MethodResult());
}
/// <summary>
/// Overload to write a message and exception to the logging system
/// </summary>
/// <param name="LoggerType">Type of logger to use</param>
/// <param name="LogLevel">Level of log reporting</param>
/// <param name="InpMsg">Message to be logged</param>
/// <param name="Ex">Exception to be logged</param>
public static void WriteLog(LoggerTypes LoggerType, LogLevels LogLevel, string InpMsg, Exception Ex)
{
ILog MyLogger;
//Establish which logger will be used
switch (LoggerType)
{
case LoggerTypes.LogDb:
MyLogger = m_DbLogger;
break;
case LoggerTypes.LogFile:
MyLogger = m_FileLogger;
// Check to determine if a new file should be started
var TestFileDate = DateTime.Now.ToString("MM-dd-yyyy");
if (TestFileDate != m_FileDate)
{
m_FileDate = TestFileDate;
ChangeLogFileName();
}
break;
case LoggerTypes.LogSystem:
MyLogger = m_SysLogger;
break;
default:
throw new Exception("Invalid logger type specified");
}
//Update the status file data
clsStatusData.MostRecentLogMessage = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") + "; "
+ InpMsg + "; " + LogLevel.ToString();
//Send the log message
switch (LogLevel)
{
case LogLevels.DEBUG:
if (MyLogger.IsDebugEnabled)
MyLogger.Debug(InpMsg, Ex);
break;
case LogLevels.ERROR:
clsStatusData.AddErrorMessage(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") + "; " + InpMsg
+ "; " + LogLevel.ToString());
if (MyLogger.IsErrorEnabled)
MyLogger.Error(InpMsg, Ex);
break;
case LogLevels.FATAL:
if (MyLogger.IsFatalEnabled)
MyLogger.Fatal(InpMsg, Ex);
break;
case LogLevels.INFO:
if (MyLogger.IsInfoEnabled)
MyLogger.Info(InpMsg, Ex);
break;
case LogLevels.WARN:
if (MyLogger.IsWarnEnabled)
MyLogger.Warn(InpMsg, Ex);
break;
default:
throw new Exception("Invalid log level specified");
}
}
/// <param name="loggerType">The logging service type</param>
/// <param name="level" >The minimum logging level</param>
public LoggerOptions(LoggerTypes loggerType, LogRecordTypes level)
: this(loggerType, level, null)
{
}
public LoggerAttribute(LoggerTypes loggerType) : base()
{
LoggerType = loggerType;
}
public void SetLogger(LoggerTypes type)
{
this.logger = loggerFactory.CreateLogger(type, this.appenders);
}
/// <summary>
/// Resets the logger and creates a new one on next request.
/// </summary>
public static void Reset()
{
_logger = null;
_loggerType = LoggerTypes.Null;
}
private void AddToLogs(string message, LoggerTypes logType, string errorCode = "")
{
var logMessage = " " + GetExternalSource() + " - " + message;
LogToFile(logMessage, logType, errorCode);
}
public ILogger CreateLogger(LoggerTypes type)
{
return(_loggersFactory[type]);
}
public static void Initialize(LoggerTypes loggers, LogLevel loggingLevel)
{
CeresEnvironment.loggers = loggers;
CreateLogger(loggers, loggingLevel);
}
public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
{
return(type == LoggerTypes.List ? new LoggerFake() : NullLoggerFactory.Instance.CreateLogger("Null Logger"));
}
