private static void Main()
{
Logger.SetLogger(new ConsoleLogger(LogLevel.Info));
var machine = new StateMachine();
var stats = new Statistics();
stats.DirtyEvent += () => Console.Title = stats.ToString();
var aggregator = new StatisticsAggregator(stats);
var listener = new ConsoleEventListener();
machine.EventListener += listener.Listen;
machine.EventListener += aggregator.Listen;
machine.SetFailureState(new LoginState());
GlobalSettings settings = GlobalSettings.Load("\\config\\config.json");
var context = new Context(new ClientSettings(settings), new LogicSettings(settings));
context.Client.Login.GoogleDeviceCodeEvent += LoginWithGoogle;
machine.AsyncStart(new VersionCheckState(), context);
Console.ReadLine();
}
public static void Execute(Context ctx, StateMachine machine)
{
var pokemons = ctx.Inventory.GetPokemons().Result;
foreach (var pokemon in pokemons)
{
var perfection = Math.Round(PokemonInfo.CalculatePokemonPerfection(pokemon));
var pokemonName = pokemon.PokemonId.ToString();
if (pokemonName.Length > 10 - perfection.ToString().Length)
{
pokemonName = pokemonName.Substring(0, 10 - perfection.ToString().Length);
}
var newNickname = $"{pokemonName}_{perfection}";
if (perfection > ctx.LogicSettings.KeepMinIvPercentage && newNickname != pokemon.Nickname && ctx.LogicSettings.RenameAboveIv)
{
var result = ctx.Client.Inventory.NicknamePokemon(pokemon.Id, newNickname).Result;
machine.Fire(new NoticeEvent
{
Message = $"Pokemon {pokemon.PokemonId} ({pokemon.Id}) renamed from {pokemon.Nickname} to {newNickname}."
});
}
else if (newNickname == pokemon.Nickname && !ctx.LogicSettings.RenameAboveIv)
{
var result = ctx.Client.Inventory.NicknamePokemon(pokemon.Id, pokemon.PokemonId.ToString());
machine.Fire(new NoticeEvent
{
Message = $"Pokemon {pokemon.PokemonId} ({pokemon.Id}) renamed from {pokemon.Nickname} to {pokemon.PokemonId}."
});
}
}
}
public void HandleEvent(PokemonEvolveEvent evt, Context ctx)
{
Logger.Write(evt.Result == EvolvePokemonResponse.Types.Result.Success
? $"{evt.Id} successfully for {evt.Exp}xp"
: $"Failed {evt.Id}. EvolvePokemonOutProto.Result was {evt.Result}, stopping evolving {evt.Id}",
LogLevel.Evolve);
}
public void HandleEvent(PokemonCaptureEvent evt, Context ctx)
{
Func<ItemId, string> returnRealBallName = a =>
{
switch (a)
{
case ItemId.ItemPokeBall:
return "Poke";
case ItemId.ItemGreatBall:
return "Great";
case ItemId.ItemUltraBall:
return "Ultra";
case ItemId.ItemMasterBall:
return "Master";
default:
return "Unknown";
}
};
var catchStatus = evt.Attempt > 1
? $"{evt.Status} Attempt #{evt.Attempt}"
: $"{evt.Status}";
var familyCandies = evt.FamilyCandies > 0
? $"Candies: {evt.FamilyCandies}"
: "";
Logger.Write(
$"({catchStatus}) {evt.Id} Lvl: {evt.Level} CP: ({evt.Cp}/{evt.MaxCp}) IV: {evt.Perfection.ToString("0.00")}% | Chance: {evt.Probability}% | {Math.Round(evt.Distance)}m dist | with a {returnRealBallName(evt.Pokeball)}Ball. | {familyCandies}",
LogLevel.Caught);
}
public static void Execute(Context ctx, StateMachine machine)
{
if (ctx.LogicSettings.UseLuckyEggsWhileEvolving)
{
UseLuckyEgg(ctx.Client, ctx.Inventory, machine);
}
var pokemonToEvolveTask = ctx.Inventory.GetPokemonToEvolve(ctx.LogicSettings.PokemonsToEvolve);
pokemonToEvolveTask.Wait();
var pokemonToEvolve = pokemonToEvolveTask.Result;
foreach (var pokemon in pokemonToEvolve)
{
var evolveTask = ctx.Client.Inventory.EvolvePokemon(pokemon.Id);
evolveTask.Wait();
var evolvePokemonOutProto = evolveTask.Result;
machine.Fire(new PokemonEvolveEvent
{
Id = pokemon.PokemonId,
Exp = evolvePokemonOutProto.ExperienceAwarded,
Result = evolvePokemonOutProto.Result
});
Thread.Sleep(3000);
}
}
public IState Execute(Context ctx, StateMachine machine)
{
RenamePokemonTask.Execute(ctx, machine);
if (ctx.LogicSettings.EvolveAllPokemonAboveIv || ctx.LogicSettings.EvolveAllPokemonWithEnoughCandy)
{
EvolvePokemonTask.Execute(ctx, machine);
}
if (ctx.LogicSettings.TransferDuplicatePokemon)
{
TransferDuplicatePokemonTask.Execute(ctx, machine);
}
RecycleItemsTask.Execute(ctx, machine);
if (ctx.LogicSettings.UseGpxPathing)
{
FarmPokestopsGpxTask.Execute(ctx, machine);
}
else
{
FarmPokestopsTask.Execute(ctx, machine);
}
machine.RequestDelay(10000);
return this;
}
public void HandleEvent(PokemonCaptureEvent evt, Context ctx)
{
if (evt.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
_stats.TotalExperience += evt.Exp;
_stats.TotalPokemons++;
_stats.TotalStardust = evt.Stardust;
_stats.Dirty(ctx.Inventory);
}
}
private static IOrderedEnumerable<MapPokemon> GetNearbyPokemons(Context ctx)
{
var mapObjects = ctx.Client.Map.GetMapObjects().Result;
var pokemons = mapObjects.MapCells.SelectMany(i => i.CatchablePokemons)
.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude, ctx.Client.CurrentLongitude,
i.Latitude, i.Longitude));
return pokemons;
}
public IState Execute(Context ctx, StateMachine machine)
{
if (!IsLatest())
{
machine.Fire(new WarnEvent
{
Message = "There is a new version available: https://github.com/WooAf/PoGoBoT"
});
}
return new LoginState();
}
public IState Execute(Context ctx, StateMachine machine)
{
var coordsPath = Directory.GetCurrentDirectory() + "\\Configs\\Coords.ini";
if (File.Exists(coordsPath))
{
var latLngFromFile = LoadPositionFromDisk(machine);
if (latLngFromFile != null)
{
var distance = LocationUtils.CalculateDistanceInMeters(latLngFromFile.Item1, latLngFromFile.Item2,
ctx.Settings.DefaultLatitude, ctx.Settings.DefaultLongitude);
var lastModified = File.Exists(coordsPath) ? (DateTime?) File.GetLastWriteTime(coordsPath) : null;
if (lastModified != null)
{
var hoursSinceModified = (DateTime.Now - lastModified).HasValue
? (double?) ((DateTime.Now - lastModified).Value.Minutes/60.0)
: null;
if (hoursSinceModified != null && hoursSinceModified != 0)
{
var kmph = distance/1000/(double) hoursSinceModified;
if (kmph < 80) // If speed required to get to the default location is < 80km/hr
{
File.Delete(coordsPath);
machine.Fire(new WarnEvent
{
Message = "Detected realistic Traveling , using UserSettings.settings"
});
}
else
{
machine.Fire(new WarnEvent
{
Message = "Not realistic Traveling at " + kmph + ", using last saved Coords.ini"
});
}
}
}
}
}
machine.Fire(new WarnEvent
{
Message =
$"Make sure Lat & Lng are right. Exit Program if not! Lat: {ctx.Client.CurrentLatitude} Lng: {ctx.Client.CurrentLongitude}"
});
machine.RequestDelay(3000);
return new FarmState();
}
public static void Execute(Context ctx, StateMachine machine)
{
var items = ctx.Inventory.GetItemsToRecycle(ctx.Settings).Result;
foreach (var item in items)
{
ctx.Client.Inventory.RecycleItem(item.ItemId, item.Count).Wait();
machine.Fire(new ItemRecycledEvent {Id = item.ItemId, Count = item.Count});
Thread.Sleep(500);
}
ctx.Inventory.RefreshCachedInventory().Wait();
}
public IState Execute(Context ctx, StateMachine machine)
{
try
{
switch (ctx.Settings.AuthType)
{
case AuthType.Ptc:
try
{
ctx.Client.Login.DoPtcLogin(ctx.Settings.PtcUsername, ctx.Settings.PtcPassword).Wait();
}
catch (System.AggregateException ae)
{
throw ae.Flatten().InnerException;
}
break;
case AuthType.Google:
ctx.Client.Login.DoGoogleLogin().Wait();
break;
default:
machine.Fire(new ErrorEvent {Message = "wrong AuthType"});
return null;
}
}
catch (PtcOfflineException)
{
machine.Fire(new ErrorEvent
{
Message = "PTC Servers are probably down OR your credentials are wrong. Try google"
});
machine.Fire(new NoticeEvent {Message = "Trying again in 20 seconds..."});
machine.RequestDelay(20000);
return this;
}
catch (AccountNotVerifiedException)
{
machine.Fire(new ErrorEvent {Message = "Account not verified. - Exiting"});
return null;
}
DownloadProfile(ctx, machine);
return new PositionCheckState();
}
private static List<FortData> GetPokeStops(Context ctx)
{
var mapObjects = ctx.Client.Map.GetMapObjects().Result;
// Wasn't sure how to make this pretty. Edit as needed.
var pokeStops = mapObjects.MapCells.SelectMany(i => i.Forts)
.Where(
i =>
i.Type == FortType.Checkpoint &&
i.CooldownCompleteTimestampMs < DateTime.UtcNow.ToUnixTime() &&
( // Make sure PokeStop is within 40 meters or else it is pointless to hit it
LocationUtils.CalculateDistanceInMeters(
ctx.Settings.DefaultLatitude, ctx.Settings.DefaultLongitude,
i.Latitude, i.Longitude) < 40) ||
ctx.LogicSettings.MaxTravelDistanceInMeters == 0
);
return pokeStops.ToList();
}
public void Start(IState initialState, Context ctx)
{
_ctx = ctx;
var state = initialState;
do
{
try
{
state = state.Execute(ctx, this);
Thread.Sleep(_delay);
_delay = 0;
}
catch (Exception ex)
{
Fire(new ErrorEvent {Message = ex.ToString()});
state = _initialState;
}
} while (state != null);
}
public static void Execute(Context ctx, StateMachine machine)
{
var duplicatePokemons =
ctx.Inventory.GetDuplicatePokemonToTransfer(ctx.LogicSettings.KeepPokemonsThatCanEvolve, ctx.LogicSettings.PrioritizeIvOverCp,
ctx.LogicSettings.PokemonsNotToTransfer).Result;
var pokemonSettings = ctx.Inventory.GetPokemonSettings().Result;
var pokemonFamilies = ctx.Inventory.GetPokemonFamilies().Result;
foreach (var duplicatePokemon in duplicatePokemons)
{
if (duplicatePokemon.Cp >= ctx.LogicSettings.KeepMinCp ||
PokemonInfo.CalculatePokemonPerfection(duplicatePokemon) > ctx.LogicSettings.KeepMinIvPercentage)
{
continue;
}
ctx.Client.Inventory.TransferPokemon(duplicatePokemon.Id).Wait();
ctx.Inventory.DeletePokemonFromInvById(duplicatePokemon.Id);
var bestPokemonOfType = ctx.LogicSettings.PrioritizeIvOverCp
? ctx.Inventory.GetHighestPokemonOfTypeByIv(duplicatePokemon).Result
: ctx.Inventory.GetHighestPokemonOfTypeByCp(duplicatePokemon).Result;
if (bestPokemonOfType == null)
bestPokemonOfType = duplicatePokemon;
var setting = pokemonSettings.Single(q => q.PokemonId == duplicatePokemon.PokemonId);
var family = pokemonFamilies.Single(q => q.FamilyId == setting.FamilyId);
family.Candy++;
machine.Fire(new TransferPokemonEvent
{
Id = duplicatePokemon.PokemonId,
Perfection = PokemonInfo.CalculatePokemonPerfection(duplicatePokemon),
Cp = duplicatePokemon.Cp,
BestCp = bestPokemonOfType.Cp,
BestPerfection = PokemonInfo.CalculatePokemonPerfection(bestPokemonOfType),
FamilyCandies = family.Candy
});
}
}
//Please do not change GetPokeStops() in this file, it's specifically set
//to only find stops within 40 meters
//this is for gpx pathing, we are not going to the pokestops,
//so do not make it more than 40 because it will never get close to those stops.
public static void Execute(Context ctx, StateMachine machine)
{
var pokestopList = GetPokeStops(ctx);
while (pokestopList.Any())
{
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
ctx.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Wait();
var fortSearch =
ctx.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Result;
if (fortSearch.ExperienceAwarded > 0)
{
machine.Fire(new FortUsedEvent
{
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded)
});
}
Thread.Sleep(1000);
RecycleItemsTask.Execute(ctx, machine);
if (ctx.LogicSettings.TransferDuplicatePokemon)
{
TransferDuplicatePokemonTask.Execute(ctx, machine);
}
}
}
public static void Execute(Context ctx, StateMachine machine)
{
Logger.Write("Looking for pokemon..", LogLevel.Debug);
var pokemons = GetNearbyPokemons(ctx);
foreach (var pokemon in pokemons)
{
if (ctx.LogicSettings.UsePokemonToNotCatchFilter &&
ctx.LogicSettings.PokemonsNotToCatch.Contains(pokemon.PokemonId))
{
Logger.Write("Skipped " + pokemon.PokemonId);
continue;
}
var distance = LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, pokemon.Latitude, pokemon.Longitude);
Thread.Sleep(distance > 100 ? 15000 : 500);
var encounter = ctx.Client.Encounter.EncounterPokemon(pokemon.EncounterId, pokemon.SpawnPointId).Result;
if (encounter.Status == EncounterResponse.Types.Status.EncounterSuccess)
{
CatchPokemonTask.Execute(ctx, machine, encounter, pokemon);
}
else
{
machine.Fire(new WarnEvent {Message = $"Encounter problem: {encounter.Status}"});
}
// If pokemon is not last pokemon in list, create delay between catches, else keep moving.
if (!Equals(pokemons.ElementAtOrDefault(pokemons.Count() - 1), pokemon))
{
Thread.Sleep(ctx.LogicSettings.DelayBetweenPokemonCatch);
}
}
}
public void HandleEvent(ErrorEvent evt, Context ctx)
{
}
public void HandleEvent(PokemonEvolveEvent evt, Context ctx)
{
_stats.TotalExperience += evt.Exp;
_stats.Dirty(ctx.Inventory);
}
public void HandleEvent(WarnEvent evt, Context ctx)
{
}
public void HandleEvent(NoticeEvent evt, Context ctx)
{
}
public void DownloadProfile(Context ctx, StateMachine machine)
{
ctx.Profile = ctx.Client.Player.GetPlayer().Result;
machine.Fire(new ProfileEvent {Profile = ctx.Profile});
}
public void HandleEvent(UseLuckyEggEvent evt, Context ctx)
{
}
public void HandleEvent(UseBerryEvent evt, Context ctx)
{
}
public void Listen(IEvent evt, Context ctx)
{
dynamic eve = evt;
HandleEvent(eve, ctx);
}
public void HandleEvent(NoPokeballEvent evt, Context ctx)
{
}
public void HandleEvent(TransferPokemonEvent evt, Context ctx)
{
_stats.TotalPokemonsTransfered++;
_stats.Dirty(ctx.Inventory);
}
public void HandleEvent(FortTargetEvent evt, Context ctx)
{
}
public void HandleEvent(FortUsedEvent evt, Context ctx)
{
_stats.TotalExperience += evt.Exp;
_stats.Dirty(ctx.Inventory);
}
public void HandleEvent(ItemRecycledEvent evt, Context ctx)
{
_stats.TotalItemsRemoved++;
_stats.Dirty(ctx.Inventory);
}
