private static async Task ActionsWhenTravelToSnipeTarget(ISession session, CancellationToken cancellationToken,
SnipePokemonInfo pokemon, bool allowCatchPokemon, bool allowSpinPokeStop)
{
var distance = LocationUtils.CalculateDistanceInMeters(
pokemon.Latitude,
pokemon.Longitude,
session.Client.CurrentLatitude,
session.Client.CurrentLongitude
);
if (allowCatchPokemon && distance > 50.0)
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken, sessionAllowTransfer : false);
}
if (allowSpinPokeStop)
{
//looking for neaby pokestop. spin it
await UseNearbyPokestopsTask.SpinPokestopNearBy(session, cancellationToken, null);
}
if (session.LogicSettings.ActivateMSniper)
{
await MSniperServiceTask.Execute(session, cancellationToken);
}
}
private static async Task OnWalkingToPokeStopOrGym(ISession session, FortData pokeStop, CancellationToken cancellationToken)
{
await MSniperServiceTask.Execute(session, cancellationToken);
//to avoid api call when walking.
if (lastCatch < DateTime.Now.AddSeconds(-2))
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
lastCatch = DateTime.Now;
}
if (!session.LogicSettings.UseGpxPathing)
{
// Spin as long as we haven't reached the user defined limits
if (!_pokestopLimitReached && !_pokestopTimerReached)
{
await SpinPokestopNearBy(session, cancellationToken, pokeStop);
}
}
}
public static async Task SnipePokemon(ISession session, Location snipeLocation, PokemonId pokemonId)
{
Tuple <double, double, double> curCoords = new Tuple <double, double, double>(session.Client.CurrentLatitude, session.Client.CurrentLongitude, session.Client.CurrentAltitude);
await session.Client.Player.UpdatePlayerLocation(snipeLocation.Latitude, snipeLocation.Longitude, session.Settings.DefaultAltitude);
Logger.Write($"Trying to snipe a { pokemonId } @ { snipeLocation.Latitude } : { snipeLocation.Longitude }", LogLevel.Snipe);
var pokemons = await CatchNearbyPokemonsTask.GetNearbyPokemons(session);
var pokemon = pokemons.Where(i => i.PokemonId == pokemonId);
if (pokemon == null || pokemon.Count() == 0)
{
Logger.Write($"Unable to find { pokemonId } at location... Returning to original spot.", LogLevel.Snipe);
await session.Client.Player.UpdatePlayerLocation(curCoords.Item1, curCoords.Item2, curCoords.Item3);
return;
}
Logger.Write($"Found { pokemon.Count() } { pokemonId }'s at location. Trying to catch them ALL!", LogLevel.Snipe);
foreach (var p in pokemon)
{
var encounter = session.Client.Encounter.EncounterPokemon(p.EncounterId, p.SpawnPointId).Result;
if (encounter.Status == EncounterResponse.Types.Status.EncounterSuccess)
{
await session.Client.Player.UpdatePlayerLocation(curCoords.Item1, curCoords.Item2, curCoords.Item3);
await CatchPokemonTask.Execute(session, encounter, p);
}
else if (encounter.Status == EncounterResponse.Types.Status.EncounterNotInRange)
{
Logger.Write($"{pokemonId } is out of range. Moving closer....", LogLevel.Snipe);
await session.Client.Player.UpdatePlayerLocation(p.Latitude, p.Longitude, curCoords.Item3);
encounter = session.Client.Encounter.EncounterPokemon(p.EncounterId, p.SpawnPointId).Result;
if (encounter.Status == EncounterResponse.Types.Status.EncounterSuccess)
{
await session.Client.Player.UpdatePlayerLocation(curCoords.Item1, curCoords.Item2, curCoords.Item3);
await CatchPokemonTask.Execute(session, encounter, p);
}
else
{
await session.Client.Player.UpdatePlayerLocation(curCoords.Item1, curCoords.Item2, curCoords.Item3);
Logger.Write($"Failed to catch again ({ encounter.Status }). Moving back to original coords.", LogLevel.Snipe);
return;
}
}
else
{
await session.Client.Player.UpdatePlayerLocation(curCoords.Item1, curCoords.Item2, curCoords.Item3);
Logger.Write($"Error occurred when entering encounter: { encounter.Status }.", LogLevel.Snipe);
return;
}
}
}
private static async Task MoveToLocationAsync(ISession session, CancellationToken cancellationToken, double latitude, double longitude)
{
await session.Navigation.Move(new GeoCoordinate(latitude, longitude),
session.LogicSettings.WalkingSpeedInKilometerPerHour,
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
}, cancellationToken, session.LogicSettings.DisableHumanWalking);
}
private static async Task WalkingBackGPXPath(ISession session, CancellationToken cancellationToken, FortData originalPokestop)
{
var destination = new GeoCoordinate(originalPokestop.Latitude, originalPokestop.Longitude,
LocationUtils.getElevation(session, originalPokestop.Latitude, originalPokestop.Longitude));
await session.Navigation.Move(destination,
async() =>
{
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.SpinPokestopNearBy(session, cancellationToken);
},
session,
cancellationToken);
}
private static async Task WalkingBackGPXPath(ISession session, CancellationToken cancellationToken, FortData originalPokestop, FortDetailsResponse fortInfo)
{
var destination = new FortLocation(originalPokestop.Latitude, originalPokestop.Longitude,
LocationUtils.getElevation(session.ElevationService, originalPokestop.Latitude, originalPokestop.Longitude), originalPokestop, fortInfo);
await session.Navigation.Move(destination,
async() =>
{
await MSniperServiceTask.Execute(session, cancellationToken);
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.SpinPokestopNearBy(session, cancellationToken);
},
session,
cancellationToken);
}
public static async Task <bool> IsReachedDestination(FortData destination, ISession session, CancellationToken cancellationToken)
{
if (destination == _targetStop && destination.Id == TARGET_ID)
{
_targetStop = null;
//looking for pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//TODO - maybe looking for lure pokestop and try catch lure pokestop task
return(true);
}
return(false);
}
public static async Task<bool> IsReachedDestination(FortData destination, ISession session,
CancellationToken cancellationToken)
{
if (_targetStop != null && destination.Id == _targetStop.Id)
{
_targetStop = null;
queue.Dequeue();
//looking for pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//TODO - maybe looking for lure pokestop and try catch lure pokestop task
return true;
}
return false;
}
private static async Task OnWalkingToPokeStopOrGym(ISession session, FortData pokeStop, CancellationToken cancellationToken)
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
if (!session.LogicSettings.UseGpxPathing)
{
// Spin as long as we haven't reached the user defined limits
if (!_pokestopLimitReached && !_pokestopTimerReached)
{
await SpinPokestopNearBy(session, cancellationToken, pokeStop);
}
}
}
private static async Task WalkingBackGPXPath(ISession session, CancellationToken cancellationToken, FortData originalPokestop)
{
var destination = new FortLocation(originalPokestop.Latitude, originalPokestop.Longitude,
LocationUtils.getElevation(session, originalPokestop.Latitude, originalPokestop.Longitude), originalPokestop, null);
await session.Navigation.Move(destination,
async() =>
{
if (session.LogicSettings.ActivateMSniper)
{
await MSniperServiceTask.Execute(session, cancellationToken);
}
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.SpinPokestopNearBy(session, cancellationToken);
},
session,
cancellationToken);
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var distanceFromStart = LocationUtils.CalculateDistanceInMeters(
session.Settings.DefaultLatitude, session.Settings.DefaultLongitude,
session.Client.CurrentLatitude, session.Client.CurrentLongitude);
var response = await session.Client.Player.UpdatePlayerLocation(session.Client.CurrentLatitude, session.Client.CurrentLongitude, session.Client.CurrentAltitude, 0);
// Edge case for when the client somehow ends up outside the defined radius
if (session.LogicSettings.MaxTravelDistanceInMeters != 0 && checkForMoveBackToDefault &&
distanceFromStart > session.LogicSettings.MaxTravelDistanceInMeters)
{
checkForMoveBackToDefault = false;
Logger.Write(
session.Translation.GetTranslation(TranslationString.FarmPokestopsOutsideRadius, distanceFromStart),
LogLevel.Warning);
var eggWalker = new EggWalker(1000, session);
var defaultLocation = new MapLocation(session.Settings.DefaultLatitude,
session.Settings.DefaultLongitude,
LocationUtils.getElevation(session.ElevationService, session.Settings.DefaultLatitude, session.Settings.DefaultLongitude)
);
await session.Navigation.Move(defaultLocation,
async() =>
{
await MSniperServiceTask.Execute(session, cancellationToken);
},
session,
cancellationToken);
// we have moved this distance, so apply it immediately to the egg walker.
await eggWalker.ApplyDistance(distanceFromStart, cancellationToken);
}
checkForMoveBackToDefault = false;
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
// initialize the variables in UseNearbyPokestopsTask here, as this is a fresh start.
UseNearbyPokestopsTask.Initialize();
await UseNearbyPokestopsTask.Execute(session, cancellationToken);
}
private static async Task OnWalkingToPokeStopOrGym(ISession session, FortData pokeStop, CancellationToken cancellationToken)
{
//TODO - refactore this call to somewhere else
if (SetMoveToTargetTask.CheckStopforSetMoveToTarget())
{
return;
}
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
// Minor fix google route ignore pokestop
if (session.LogicSettings.UseGoogleWalk && !session.LogicSettings.UseYoursWalk && !session.LogicSettings.UseGpxPathing)
{
await SpinPokestopNearBy(session, cancellationToken, pokeStop);
}
}
private static async Task resetLocation(ISession session, CancellationToken cancellationToken)
{
if (GlobalSettings.lstPokeStopLocations.Count < 1)
{
await session.Navigation.Move(new GeoCoordinate(GlobalSettings.Default.DefaultLatitude, GlobalSettings.Default.DefaultLongitude),
session.LogicSettings.WalkingSpeedInKilometerPerHour,
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
}, cancellationToken);
return;
}
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("EN-US");
if (GlobalSettings.irLastPokeStopIndex >= GlobalSettings.lstPokeStopLocations.Count)
{
GlobalSettings.irLastPokeStopIndex = 0;
}
Logger.Write("Re setting global location no Poke Stop index " + GlobalSettings.irLastPokeStopIndex + " : "
+ GlobalSettings.lstPokeStopLocations[GlobalSettings.irLastPokeStopIndex], LogLevel.Self, ConsoleColor.Yellow);
double dblLat = Convert.ToDouble(GlobalSettings.lstPokeStopLocations[GlobalSettings.irLastPokeStopIndex].Split(':')[0]);
double dblLng = Convert.ToDouble(GlobalSettings.lstPokeStopLocations[GlobalSettings.irLastPokeStopIndex].Split(':')[1]);
GlobalSettings.irLastPokeStopIndex++;
await session.Navigation.Move(new GeoCoordinate(dblLat, dblLng),
session.LogicSettings.WalkingSpeedInKilometerPerHour,
async() =>
{
return(true);
}, cancellationToken);
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
var tracks = GetGpxTracks(session);
var eggWalker = new EggWalker(1000, session);
if (!_resumeTrack.HasValue || !_resumeTrackSeg.HasValue || !_resumeTrackPt.HasValue)
{
_resumeTrack = session.LogicSettings.ResumeTrack;
_resumeTrackSeg = session.LogicSettings.ResumeTrackSeg;
_resumeTrackPt = session.LogicSettings.ResumeTrackPt;
// initialize the variables in UseNearbyPokestopsTask here, as this is a fresh start.
UseNearbyPokestopsTask.Initialize();
}
for (var curTrk = _resumeTrack.Value; curTrk < tracks.Count; curTrk++)
{
_resumeTrack = curTrk;
cancellationToken.ThrowIfCancellationRequested();
var track = tracks.ElementAt(curTrk);
var trackSegments = track.Segments;
for (var curTrkSeg = _resumeTrackSeg.Value; curTrkSeg < trackSegments.Count; curTrkSeg++)
{
_resumeTrackSeg = curTrkSeg;
cancellationToken.ThrowIfCancellationRequested();
var trackPoints = trackSegments.ElementAt(curTrkSeg).TrackPoints;
for (var curTrkPt = _resumeTrackPt.Value; curTrkPt < trackPoints.Count; curTrkPt++)
{
_resumeTrackPt = curTrkPt;
cancellationToken.ThrowIfCancellationRequested();
var nextPoint = trackPoints.ElementAt(curTrkPt);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude,
Convert.ToDouble(nextPoint.Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(nextPoint.Lon, CultureInfo.InvariantCulture));
if (distance > 5000)
{
session.EventDispatcher.Send(new ErrorEvent
{
Message =
session.Translation.GetTranslation(TranslationString.DesiredDestTooFar,
nextPoint.Lat, nextPoint.Lon, session.Client.CurrentLatitude,
session.Client.CurrentLongitude)
});
break;
}
var lat = Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lat, CultureInfo.InvariantCulture);
var lng = Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lon, CultureInfo.InvariantCulture);
IGeoLocation destination = new GPXPointLocation(lat, lng, LocationUtils.getElevation(session.ElevationService, lat, lng));
await session.Navigation.Move(destination,
async() =>
{
await MSniperServiceTask.Execute(session, cancellationToken);
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.Execute(session, cancellationToken);
},
session,
cancellationToken);
await eggWalker.ApplyDistance(distance, cancellationToken);
// Return to FarmState/StateMachine if we have reached both user defined limits
if ((UseNearbyPokestopsTask._pokestopLimitReached || UseNearbyPokestopsTask._pokestopTimerReached) &&
(CatchPokemonTask._catchPokemonLimitReached || CatchPokemonTask._catchPokemonTimerReached))
{
return;
}
} //end trkpts
_resumeTrackPt = 0;
} //end trksegs
_resumeTrackSeg = 0;
} //end tracks
_resumeTrack = 0;
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
var tracks = GetGpxTracks(session);
var curTrkPt = 0;
var curTrk = 0;
var maxTrk = tracks.Count - 1;
var curTrkSeg = 0;
var eggWalker = new EggWalker(1000, session);
while (curTrk <= maxTrk)
{
cancellationToken.ThrowIfCancellationRequested();
var track = tracks.ElementAt(curTrk);
var trackSegments = track.Segments;
var maxTrkSeg = trackSegments.Count - 1;
while (curTrkSeg <= maxTrkSeg)
{
cancellationToken.ThrowIfCancellationRequested();
var trackPoints = track.Segments.ElementAt(0).TrackPoints;
var maxTrkPt = trackPoints.Count - 1;
while (curTrkPt <= maxTrkPt)
{
cancellationToken.ThrowIfCancellationRequested();
var nextPoint = trackPoints.ElementAt(curTrkPt);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, Convert.ToDouble(nextPoint.Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(nextPoint.Lon, CultureInfo.InvariantCulture));
if (distance > 5000)
{
session.EventDispatcher.Send(new ErrorEvent
{
Message = session.Translation.GetTranslation(Common.TranslationString.DesiredDestTooFar, nextPoint.Lat, nextPoint.Lon, session.Client.CurrentLatitude, session.Client.CurrentLongitude)
});
break;
}
var pokestopList = await GetPokeStops(session);
session.EventDispatcher.Send(new PokeStopListEvent {
Forts = pokestopList
});
while (pokestopList.Any())
{
cancellationToken.ThrowIfCancellationRequested();
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
var fortInfo = await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (pokeStop.LureInfo != null)
{
await CatchLurePokemonsTask.Execute(session, pokeStop, cancellationToken);
}
var fortSearch =
await session.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (fortSearch.ExperienceAwarded > 0)
{
session.EventDispatcher.Send(new FortUsedEvent
{
Id = pokeStop.Id,
Name = fortInfo.Name,
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded),
Latitude = pokeStop.Latitude,
Longitude = pokeStop.Longitude
});
}
if (fortSearch.ItemsAwarded.Count > 0)
{
await session.Inventory.RefreshCachedInventory();
}
await RecycleItemsTask.Execute(session, cancellationToken);
if (session.LogicSettings.SnipeAtPokestops)
{
await SnipePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.EvolveAllPokemonAboveIv)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.RenameAboveIv)
{
await RenamePokemonTask.Execute(session, cancellationToken);
}
}
await session.Navigation.HumanPathWalking(
trackPoints.ElementAt(curTrkPt),
session.LogicSettings.WalkingSpeedInKilometerPerHour,
async() =>
{
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.Execute(session, cancellationToken);
return(true);
},
cancellationToken
);
await eggWalker.ApplyDistance(distance, cancellationToken);
if (curTrkPt >= maxTrkPt)
{
curTrkPt = 0;
}
else
{
curTrkPt++;
}
} //end trkpts
if (curTrkSeg >= maxTrkSeg)
{
curTrkSeg = 0;
}
else
{
curTrkSeg++;
}
} //end trksegs
if (curTrk >= maxTrkSeg)
{
curTrk = 0;
}
else
{
curTrk++;
}
} //end tracks
}
public static async Task Execute(ISession session, CancellationToken cancellationToken, Func <double, double, Task> actionWhenWalking = null, Func <Task> afterCatchFunc = null)
{
pokestopCount++;
pokestopCount = pokestopCount % 3;
if (pokestopCount > 0 && !prioritySnipeFlag)
{
return;
}
InitSession(session);
if (!_setting.CatchPokemon && !prioritySnipeFlag)
{
return;
}
cancellationToken.ThrowIfCancellationRequested();
if (_setting.HumanWalkingSnipeTryCatchEmAll)
{
var checkBall = await CheckPokeballsToSnipe(_setting.HumanWalkingSnipeCatchEmAllMinBalls, session, cancellationToken);
if (!checkBall && !prioritySnipeFlag)
{
return;
}
}
bool keepWalking = true;
bool caughtAnyPokemonInThisWalk = false;
while (keepWalking)
{
prioritySnipeFlag = false;
var pokemons = GetRarePokemons(session.Client.CurrentLatitude, session.Client.CurrentLongitude, !caughtAnyPokemonInThisWalk);
foreach (var pokemon in pokemons)
{
caughtAnyPokemonInThisWalk = true;
CalculateDistanceAndEstTime(pokemon);
var remainTimes = (pokemon.expired - DateTime.Now).TotalSeconds * 0.95; //just use 90% times
var catchPokemonTimeEST = (pokemon.distance / 100) * 10; //assume that 100m we catch 1 pokemon and it took 10 second for each.
string strPokemon = session.Translation.GetPokemonTranslation(pokemon.Id);
var spinPokestopEST = (pokemon.distance / 100) * 5;
bool catchPokemon = (pokemon.estimateTime + catchPokemonTimeEST) < remainTimes && pokemon.FilterSetting.CatchPokemonWhileWalking;
bool spinPokestop = pokemon.FilterSetting.SpinPokestopWhileWalking && (pokemon.estimateTime + catchPokemonTimeEST + spinPokestopEST) < remainTimes;
pokemon.catching = true;
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
PokemonId = pokemon.Id,
Latitude = pokemon.latitude,
Longitude = pokemon.longitude,
Distance = pokemon.distance,
Expires = (pokemon.expired - DateTime.Now).TotalSeconds,
Estimate = (int)pokemon.estimateTime,
Setting = pokemon.FilterSetting,
CatchPokemon = catchPokemon,
Pokemons = rarePokemons,
SpinPokeStop = pokemon.FilterSetting.SpinPokestopWhileWalking,
WalkSpeedApplied = pokemon.FilterSetting.AllowSpeedUp ? pokemon.FilterSetting.MaxSpeedUpSpeed : _session.LogicSettings.WalkingSpeedInKilometerPerHour,
Type = HumanWalkSnipeEventTypes.StartWalking
});
await session.Navigation.Move(new GeoCoordinate(pokemon.latitude, pokemon.longitude,
LocationUtils.getElevation(session, pokemon.latitude, pokemon.longitude)),
async() =>
{
var distance = LocationUtils.CalculateDistanceInMeters(pokemon.latitude, pokemon.longitude, session.Client.CurrentLatitude, session.Client.CurrentLongitude);
if (catchPokemon && distance > 80.0)
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
}
if (actionWhenWalking != null && spinPokestop)
{
await actionWhenWalking(session.Client.CurrentLatitude, session.Client.CurrentLongitude);
}
return(true);
},
session,
cancellationToken, pokemon.FilterSetting.AllowSpeedUp?pokemon.FilterSetting.MaxSpeedUpSpeed : 0);
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
Latitude = pokemon.latitude,
Longitude = pokemon.longitude,
Type = HumanWalkSnipeEventTypes.DestinationReached
});
await Task.Delay(2000);
await CatchNearbyPokemonsTask.Execute(session, cancellationToken, pokemon.Id);
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
pokemon.visited = true;
pokemon.catching = false;
}
keepWalking = _setting.HumanWalkingSnipeTryCatchEmAll && pokemons.Count > 0;
}
if (caughtAnyPokemonInThisWalk && !_setting.HumanWalkingSnipeAlwaysWalkBack)
{
await afterCatchFunc?.Invoke();
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var pokestopList = await GetPokeStops(session);
while (pokestopList.Any())
{
cancellationToken.ThrowIfCancellationRequested();
await SnipeMSniperTask.CheckMSniperLocation(session, cancellationToken);
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
// randomize next pokestop between first and second by distance
var pokestopListNum = 0;
if (pokestopList.Count > 1)
{
pokestopListNum = rc.Next(0, 2);
}
var pokeStop = pokestopList[pokestopListNum];
pokestopList.RemoveAt(pokestopListNum);
var fortInfo = await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
// we only move to the PokeStop, and send the associated FortTargetEvent, when not using GPX
// also, GPX pathing uses its own EggWalker and calls the CatchPokemon tasks internally.
if (!session.LogicSettings.UseGpxPathing)
{
var eggWalker = new EggWalker(1000, session);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
cancellationToken.ThrowIfCancellationRequested();
if (!session.LogicSettings.UseGoogleWalk && !session.LogicSettings.UseYoursWalk)
{
session.EventDispatcher.Send(new FortTargetEvent {
Name = fortInfo.Name, Distance = distance, Route = "NecroBot"
});
}
else
{
BaseWalkStrategy.FortInfo = fortInfo;
}
await session.Navigation.Move(new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude,
LocationUtils.getElevation(pokeStop.Latitude, pokeStop.Longitude)),
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
// we have moved this distance, so apply it immediately to the egg walker.
await eggWalker.ApplyDistance(distance, cancellationToken);
}
//Catch Lure Pokemon
if (pokeStop.LureInfo != null)
{
await CatchLurePokemonsTask.Execute(session, pokeStop, cancellationToken);
}
FortSearchResponse fortSearch;
var timesZeroXPawarded = 0;
var fortTry = 0; //Current check
const int retryNumber = 50; //How many times it needs to check to clear softban
const int zeroCheck = 5; //How many times it checks fort before it thinks it's softban
do
{
cancellationToken.ThrowIfCancellationRequested();
if (SearchThresholdExceeds(session))
{
break;
}
fortSearch =
await session.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (fortSearch.ExperienceAwarded > 0 && timesZeroXPawarded > 0)
{
timesZeroXPawarded = 0;
}
if (fortSearch.ExperienceAwarded == 0)
{
timesZeroXPawarded++;
if (timesZeroXPawarded > zeroCheck)
{
if ((int)fortSearch.CooldownCompleteTimestampMs != 0)
{
break; // Check if successfully looted, if so program can continue as this was "false alarm".
}
fortTry += 1;
session.EventDispatcher.Send(new FortFailedEvent
{
Name = fortInfo.Name,
Try = fortTry,
Max = retryNumber - zeroCheck,
Looted = false
});
if (!session.LogicSettings.FastSoftBanBypass)
{
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 0);
}
}
}
else
{
if (fortTry != 0)
{
session.EventDispatcher.Send(new FortFailedEvent
{
Name = fortInfo.Name,
Try = fortTry + 1,
Max = retryNumber - zeroCheck,
Looted = true
});
}
session.EventDispatcher.Send(new FortUsedEvent
{
Id = pokeStop.Id,
Name = fortInfo.Name,
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded),
Latitude = pokeStop.Latitude,
Longitude = pokeStop.Longitude,
InventoryFull = fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull
});
if (fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull)
{
storeRI = 1;
}
session.Stats.PokeStopTimestamps.Add(DateTime.Now.Ticks);
break; //Continue with program as loot was succesfull.
}
} while (fortTry < retryNumber - zeroCheck);
//Stop trying if softban is cleaned earlier or if 40 times fort looting failed.
if (session.LogicSettings.RandomlyPauseAtStops)
{
if (++RandomStop >= RandomNumber)
{
RandomNumber = rc.Next(4, 11);
RandomStop = 0;
int RandomWaitTime = rc.Next(30, 120);
Thread.Sleep(RandomWaitTime);
}
}
if (++stopsHit >= storeRI) //TODO: OR item/pokemon bag is full //check stopsHit against storeRI random without dividing.
{
storeRI = rc.Next(6, 12); //set new storeRI for new random value
stopsHit = 0;
await RecycleItemsTask.Execute(session, cancellationToken);
if (session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.EvolveAllPokemonAboveIv ||
session.LogicSettings.UseLuckyEggsWhileEvolving ||
session.LogicSettings.KeepPokemonsThatCanEvolve)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseLuckyEggConstantly)
{
await UseLuckyEggConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseIncenseConstantly)
{
await UseIncenseConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferWeakPokemon)
{
await TransferWeakPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.RenamePokemon)
{
await RenamePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutoFavoritePokemon)
{
await FavoritePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutomaticallyLevelUpPokemon)
{
await LevelUpPokemonTask.Execute(session, cancellationToken);
}
await GetPokeDexCount.Execute(session, cancellationToken);
}
if (session.LogicSettings.SnipeAtPokestops || session.LogicSettings.UseSnipeLocationServer)
{
await SnipePokemonTask.Execute(session, cancellationToken);
}
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var pokestopsTuple = await GetPokeStops(session);
pokestopList = pokestopsTuple.Item2;
while (pokestopList.Any())
{
cancellationToken.ThrowIfCancellationRequested();
await SnipeMSniperTask.CheckMSniperLocation(session, cancellationToken);
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
// randomize next pokestop between first and second by distance
var pokestopListNum = 0;
if (pokestopList.Count > 1)
{
pokestopListNum = rc.Next(0, 2);
}
var pokeStop = pokestopList[pokestopListNum];
pokestopList.RemoveAt(pokestopListNum);
// this logic should only be called when we reach a pokestop either via GPX path or normal walking
// as when walk-sniping, we want to get to the snipe ASAP rather than stop for lured pokemon upon
// calling FarmPokestop; in that situation we are also always within 40m of the pokestop, so no
// need to walk to it
var fortInfo = await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
// we only move to the PokeStop, and send the associated FortTargetEvent, when not using GPX
// also, GPX pathing uses its own EggWalker and calls the CatchPokemon tasks internally.
if (!session.LogicSettings.UseGpxPathing)
{
var eggWalker = new EggWalker(1000, session);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
cancellationToken.ThrowIfCancellationRequested();
if (!session.LogicSettings.UseGoogleWalk && !session.LogicSettings.UseYoursWalk)
{
session.EventDispatcher.Send(new FortTargetEvent {
Name = fortInfo.Name, Distance = distance, Route = "NecroBot"
});
}
else
{
BaseWalkStrategy.FortInfo = fortInfo;
}
await session.Navigation.Move(new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude,
LocationUtils.getElevation(session, pokeStop.Latitude, pokeStop.Longitude)),
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
// Minor fix google route ignore pokestop
await LookPokestops(session, pokeStop, cancellationToken);
return(true);
},
session,
cancellationToken);
// we have moved this distance, so apply it immediately to the egg walker.
await eggWalker.ApplyDistance(distance, cancellationToken);
}
await FortAction(session, pokeStop, fortInfo, cancellationToken);
if (session.LogicSettings.SnipeAtPokestops || session.LogicSettings.UseSnipeLocationServer)
{
await SnipePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.EnableHumanWalkingSnipe)
{
//refactore to move this code inside the task later.
await HumanWalkSnipeTask.Execute(session, cancellationToken,
async (double lat, double lng) =>
{
//idea of this function is to spin pokestop on way. maybe risky.
var reachablePokestops = pokestopList.Where(i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude) < 40 &&
i.CooldownCompleteTimestampMs == 0
).ToList();
reachablePokestops = reachablePokestops.OrderBy(i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
foreach (var ps in reachablePokestops)
{
if (!session.LogicSettings.UseGpxPathing)
{
pokestopList.Remove(ps);
}
var fi = await session.Client.Fort.GetFort(ps.Id, ps.Latitude, ps.Longitude);
await FarmPokestop(session, ps, fi, cancellationToken, true);
await Task.Delay(2000);
}
},
async() =>
{
// if using GPX we have to move back to the original pokestop, to resume the path.
// we do not try to use pokest;ops on the way back, as we will have used them getting
// here.
if (session.LogicSettings.UseGpxPathing)
{
var eggWalker = new EggWalker(1000, session);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
var geo = new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude);
await session.Navigation.Move(geo,
async() =>
{
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
await eggWalker.ApplyDistance(distance, cancellationToken);
return;
}
var nearestStop = pokestopList.OrderBy(i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).FirstOrDefault();
var walkedDistance = LocationUtils.CalculateDistanceInMeters(nearestStop.Latitude, nearestStop.Longitude, session.Client.CurrentLatitude, session.Client.CurrentLongitude);
if (walkedDistance > session.LogicSettings.HumanWalkingSnipeWalkbackDistanceLimit)
{
await Task.Delay(3000);
var nearbyPokeStops = await UpdateFortsData(session);
var notexists = nearbyPokeStops.Where(p => !pokestopList.Any(x => x.Id == p.Id)).ToList();
pokestopList.AddRange(notexists);
session.EventDispatcher.Send(new PokeStopListEvent {
Forts = pokestopList
});
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
Type = HumanWalkSnipeEventTypes.PokestopUpdated,
Pokestops = notexists,
NearestDistance = walkedDistance
});
}
});
}
}
}
public static async Task Execute(ISession session)
{
var distanceFromStart = LocationUtils.CalculateDistanceInMeters(
session.Settings.DefaultLatitude, session.Settings.DefaultLongitude,
session.Client.CurrentLatitude, session.Client.CurrentLongitude);
// Edge case for when the client somehow ends up outside the defined radius
if (session.LogicSettings.MaxTravelDistanceInMeters != 0 &&
distanceFromStart > session.LogicSettings.MaxTravelDistanceInMeters)
{
Logger.Write(
session.Translation.GetTranslation(TranslationString.FarmPokestopsOutsideRadius, distanceFromStart),
LogLevel.Warning);
await Task.Delay(1000);
await session.Navigation.HumanLikeWalking(
new GeoCoordinate(session.Settings.DefaultLatitude, session.Settings.DefaultLongitude),
session.LogicSettings.WalkingSpeedInKilometerPerHour, null);
}
var pokestopList = await GetPokeStops(session);
var stopsHit = 0;
var eggWalker = new EggWalker(1000, session);
if (pokestopList.Count <= 0)
{
session.EventDispatcher.Send(new WarnEvent
{
Message = session.Translation.GetTranslation(TranslationString.FarmPokestopsNoUsableFound)
});
}
session.EventDispatcher.Send(new PokeStopListEvent {
Forts = pokestopList
});
while (pokestopList.Any())
{
//resort
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
var fortInfo = await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
session.EventDispatcher.Send(new FortTargetEvent {
Name = fortInfo.Name, Distance = distance
});
await session.Navigation.HumanLikeWalking(new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude),
session.LogicSettings.WalkingSpeedInKilometerPerHour,
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session);
return(true);
});
//Catch Lure Pokemon
if (pokeStop.LureInfo != null)
{
await CatchLurePokemonsTask.Execute(session, pokeStop);
}
FortSearchResponse fortSearch;
var TimesZeroXPawarded = 0;
var fortTry = 0; //Current check
const int retryNumber = 50; //How many times it needs to check to clear softban
const int zeroCheck = 5; //How many times it checks fort before it thinks it's softban
do
{
fortSearch = await session.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (fortSearch.ExperienceAwarded > 0 && TimesZeroXPawarded > 0)
{
TimesZeroXPawarded = 0;
}
if (fortSearch.ExperienceAwarded == 0)
{
TimesZeroXPawarded++;
if (TimesZeroXPawarded > zeroCheck)
{
if ((int)fortSearch.CooldownCompleteTimestampMs != 0)
{
break; // Check if successfully looted, if so program can continue as this was "false alarm".
}
fortTry += 1;
session.EventDispatcher.Send(new FortFailedEvent
{
Name = fortInfo.Name,
Try = fortTry,
Max = retryNumber - zeroCheck
});
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 400);
}
}
else
{
session.EventDispatcher.Send(new FortUsedEvent
{
Id = pokeStop.Id,
Name = fortInfo.Name,
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded),
Latitude = pokeStop.Latitude,
Longitude = pokeStop.Longitude,
inventoryFull = (fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull)
});
break; //Continue with program as loot was succesfull.
}
} while (fortTry < retryNumber - zeroCheck); //Stop trying if softban is cleaned earlier or if 40 times fort looting failed.
await Task.Delay(1000);
await eggWalker.ApplyDistance(distance);
if (++stopsHit % 5 == 0) //TODO: OR item/pokemon bag is full
{
stopsHit = 0;
if (fortSearch.ItemsAwarded.Count > 0)
{
await session.Inventory.RefreshCachedInventory();
}
await RecycleItemsTask.Execute(session);
if (session.LogicSettings.SnipeAtPokestops)
{
await SnipePokemonTask.Execute(session);
}
if (session.LogicSettings.EvolveAllPokemonWithEnoughCandy || session.LogicSettings.EvolveAllPokemonAboveIv)
{
await EvolvePokemonTask.Execute(session);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session);
}
if (session.LogicSettings.RenameAboveIv)
{
await RenamePokemonTask.Execute(session);
}
}
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken,
FortData originalPokestop, FortDetailsResponse fortInfo)
{
StartAsyncPollingTask(session, cancellationToken);
pokestopCount++;
pokestopCount = pokestopCount % 3;
if (pokestopCount > 0 && !prioritySnipeFlag)
{
return;
}
InitSession(session);
if (!_setting.CatchPokemon && !prioritySnipeFlag)
{
return;
}
cancellationToken.ThrowIfCancellationRequested();
if (_setting.HumanWalkingSnipeTryCatchEmAll)
{
var checkBall = CheckPokeballsToSnipe(_setting.HumanWalkingSnipeCatchEmAllMinBalls, session,
cancellationToken);
if (!checkBall && !prioritySnipeFlag)
{
return;
}
}
bool caughtAnyPokemonInThisWalk = false;
SnipePokemonInfo pokemon = null;
do
{
cancellationToken.ThrowIfCancellationRequested();
TinyIoC.TinyIoCContainer.Current.Resolve <MultiAccountManager>().ThrowIfSwitchAccountRequested();
prioritySnipeFlag = false;
pokemon = await GetNextSnipeablePokemon(session.Client.CurrentLatitude, session.Client.CurrentLongitude,
!caughtAnyPokemonInThisWalk);
if (pokemon != null)
{
caughtAnyPokemonInThisWalk = true;
CalculateDistanceAndEstTime(pokemon);
var remainTimes = (pokemon.ExpiredTime - DateTime.Now).TotalSeconds * 0.95; //just use 90% times
//assume that 100m we catch 1 pokemon and it took 10 second for each.
var catchPokemonTimeEST =
(pokemon.Distance / 100) * 10;
string strPokemon = session.Translation.GetPokemonTranslation(pokemon.PokemonId);
var spinPokestopEST = (pokemon.Distance / 100) * 5;
bool catchPokemon = (pokemon.EstimatedTime + catchPokemonTimeEST) < remainTimes &&
pokemon.Setting.CatchPokemonWhileWalking;
bool spinPokestop = pokemon.Setting.SpinPokestopWhileWalking &&
(pokemon.EstimatedTime + catchPokemonTimeEST + spinPokestopEST) < remainTimes;
lock (threadLocker)
{
pokemon.IsCatching = true;
}
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
PokemonId = pokemon.PokemonId,
Latitude = pokemon.Latitude,
Longitude = pokemon.Longitude,
Distance = pokemon.Distance,
Expires = (pokemon.ExpiredTime - DateTime.Now).TotalSeconds,
Estimate = (int)pokemon.EstimatedTime,
Setting = pokemon.Setting,
CatchPokemon = catchPokemon,
Pokemons = ApplyFilter(rarePokemons.ToList()),
SpinPokeStop = pokemon.Setting.SpinPokestopWhileWalking,
WalkSpeedApplied = pokemon.Setting.AllowSpeedUp
? pokemon.Setting.MaxSpeedUpSpeed
: _session.LogicSettings.WalkingSpeedInKilometerPerHour,
Type = HumanWalkSnipeEventTypes.StartWalking,
Rarity = PokemonGradeHelper.GetPokemonGrade(pokemon.PokemonId).ToString()
});
var snipeTarget = new SnipeLocation(pokemon.Latitude, pokemon.Longitude,
LocationUtils.getElevation(session.ElevationService, pokemon.Latitude, pokemon.Longitude));
await session.Navigation.Move(
snipeTarget,
async() =>
{
cancellationToken.ThrowIfCancellationRequested();
await ActionsWhenTravelToSnipeTarget(session, cancellationToken, pokemon, catchPokemon, spinPokestop);
},
session,
cancellationToken,
pokemon.Setting.AllowSpeedUp?pokemon.Setting.MaxSpeedUpSpeed : 0
);
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
Latitude = pokemon.Latitude,
Longitude = pokemon.Longitude,
PauseDuration = pokemon.Setting.DelayTimeAtDestination / 1000,
Type = HumanWalkSnipeEventTypes.DestinationReached,
UniqueId = pokemon.UniqueId
});
//await Task.Delay(pokemon.Setting.DelayTimeAtDestination, cancellationToken);
await CatchNearbyPokemonsTask
.Execute(session, cancellationToken, pokemon.PokemonId, pokemon.Setting.AllowTransferWhileWalking);
await Task.Delay(1000, cancellationToken);
if (!pokemon.IsVisited)
{
await CatchLurePokemonsTask.Execute(session, cancellationToken);
}
lock (threadLocker)
{
pokemon.IsVisited = true;
pokemon.IsCatching = false;
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferWeakPokemon)
{
await TransferWeakPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.EvolveAllPokemonAboveIv ||
session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.UseLuckyEggsWhileEvolving ||
session.LogicSettings.KeepPokemonsThatCanEvolve)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
}
} while (pokemon != null && _setting.HumanWalkingSnipeTryCatchEmAll);
if (caughtAnyPokemonInThisWalk && (!_setting.HumanWalkingSnipeAlwaysWalkBack || _setting.UseGpxPathing))
{
if (session.LogicSettings.UseGpxPathing)
{
await WalkingBackGPXPath(session, cancellationToken, originalPokestop, fortInfo);
}
else
{
await UpdateFarmingPokestop(session, cancellationToken);
}
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var pokestopsTuple = await GetPokeStops(session);
var allPokestops = pokestopsTuple.Item1;
var pokestopList = pokestopsTuple.Item2;
while (pokestopList.Any())
{
cancellationToken.ThrowIfCancellationRequested();
await SnipeMSniperTask.CheckMSniperLocation(session, cancellationToken);
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
// randomize next pokestop between first and second by distance
var pokestopListNum = 0;
if (pokestopList.Count > 1)
{
pokestopListNum = rc.Next(0, 2);
}
var pokeStop = pokestopList[pokestopListNum];
pokestopList.RemoveAt(pokestopListNum);
// this logic should only be called when we reach a pokestop either via GPX path or normal walking
// as when walk-sniping, we want to get to the snipe ASAP rather than stop for lured pokemon upon
// calling FarmPokestop; in that situation we are also always within 40m of the pokestop, so no
// need to walk to it
var fortInfo = await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
// we only move to the PokeStop, and send the associated FortTargetEvent, when not using GPX
// also, GPX pathing uses its own EggWalker and calls the CatchPokemon tasks internally.
if (!session.LogicSettings.UseGpxPathing)
{
var eggWalker = new EggWalker(1000, session);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
cancellationToken.ThrowIfCancellationRequested();
if (!session.LogicSettings.UseGoogleWalk && !session.LogicSettings.UseYoursWalk)
{
session.EventDispatcher.Send(new FortTargetEvent {
Name = fortInfo.Name, Distance = distance, Route = "NecroBot"
});
}
else
{
BaseWalkStrategy.FortInfo = fortInfo;
}
await session.Navigation.Move(new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude,
LocationUtils.getElevation(session, pokeStop.Latitude, pokeStop.Longitude)),
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
// we have moved this distance, so apply it immediately to the egg walker.
await eggWalker.ApplyDistance(distance, cancellationToken);
}
//Catch Lure Pokemon
if (pokeStop.LureInfo != null)
{
// added for cooldowns
await Task.Delay(Math.Min(session.LogicSettings.DelayBetweenPlayerActions, 3000));
await CatchLurePokemonsTask.Execute(session, pokeStop, cancellationToken);
}
await FarmPokestop(session, pokeStop, fortInfo, cancellationToken);
if (++stopsHit >= storeRI) //TODO: OR item/pokemon bag is full //check stopsHit against storeRI random without dividing.
{
storeRI = rc.Next(6, 12); //set new storeRI for new random value
stopsHit = 0;
if (session.LogicSettings.UseNearActionRandom)
{
await HumanRandomActionTask.Execute(session, cancellationToken);
}
else
{
await RecycleItemsTask.Execute(session, cancellationToken);
if (session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.EvolveAllPokemonAboveIv ||
session.LogicSettings.UseLuckyEggsWhileEvolving ||
session.LogicSettings.KeepPokemonsThatCanEvolve)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseLuckyEggConstantly)
{
await UseLuckyEggConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseIncenseConstantly)
{
await UseIncenseConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferWeakPokemon)
{
await TransferWeakPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.RenamePokemon)
{
await RenamePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutoFavoritePokemon)
{
await FavoritePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutomaticallyLevelUpPokemon)
{
await LevelUpPokemonTask.Execute(session, cancellationToken);
}
await GetPokeDexCount.Execute(session, cancellationToken);
}
}
if (session.LogicSettings.SnipeAtPokestops || session.LogicSettings.UseSnipeLocationServer)
{
await SnipePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.EnableHumanWalkingSnipe)
{
//refactore to move this code inside the task later.
await HumanWalkSnipeTask.Execute(session, cancellationToken,
async (double lat, double lng) =>
{
//idea of this function is to spin pokestop on way. maybe risky.
var reachablePokestops = allPokestops.Where(i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude) < 40).ToList();
reachablePokestops = reachablePokestops.OrderBy(i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
foreach (var ps in reachablePokestops)
{
if (!session.LogicSettings.UseGpxPathing || pokestopList.Contains(ps))
{
pokestopList.Remove(ps);
}
var fi = await session.Client.Fort.GetFort(ps.Id, ps.Latitude, ps.Longitude);
await FarmPokestop(session, ps, fi, cancellationToken);
}
},
async() =>
{
// if using GPX we have to move back to the original pokestop, to resume the path.
// we do not try to use pokestops on the way back, as we will have used them getting
// here.
if (session.LogicSettings.UseGpxPathing)
{
var eggWalker = new EggWalker(1000, session);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
var geo = new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude);
await session.Navigation.Move(geo,
async() =>
{
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
await eggWalker.ApplyDistance(distance, cancellationToken);
return;
}
var nearestStop = pokestopList.OrderBy(i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).FirstOrDefault();
var walkedDistance = LocationUtils.CalculateDistanceInMeters(nearestStop.Latitude, nearestStop.Longitude, session.Client.CurrentLatitude, session.Client.CurrentLongitude);
if (walkedDistance > session.LogicSettings.HumanWalkingSnipeWalkbackDistanceLimit)
{
await Task.Delay(3000);
var nearbyPokeStops = await UpdateFortsData(session);
var notexists = nearbyPokeStops.Where(p => !pokestopList.Any(x => x.Id == p.Id)).ToList();
pokestopList.AddRange(notexists);
session.EventDispatcher.Send(new PokeStopListEvent {
Forts = pokestopList
});
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
Type = HumanWalkSnipeEventTypes.PokestopUpdated,
Pokestops = notexists,
NearestDistance = walkedDistance
});
}
});
}
}
}
private static async Task FortPokestop(ISession session, CancellationToken cancellationToken, FortData pokeStop)
{
var fortInfo = await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
// we only move to the PokeStop, and send the associated FortTargetEvent, when not using GPX
// also, GPX pathing uses its own EggWalker and calls the CatchPokemon tasks internally.
if (!session.LogicSettings.UseGpxPathing)
{
var eggWalker = new EggWalker(1000, session);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
cancellationToken.ThrowIfCancellationRequested();
if (!session.LogicSettings.UseGoogleWalk && !session.LogicSettings.UseYoursWalk)
{
session.EventDispatcher.Send(new FortTargetEvent {
Name = fortInfo.Name, Distance = distance, Route = "NecroBot"
});
}
else
{
BaseWalkStrategy.FortInfo = fortInfo;
}
await session.Navigation.Move(new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude,
LocationUtils.getElevation(pokeStop.Latitude, pokeStop.Longitude)),
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
// we have moved this distance, so apply it immediately to the egg walker.
await eggWalker.ApplyDistance(distance, cancellationToken);
}
//Catch Lure Pokemon
if (pokeStop.LureInfo != null)
{
await CatchLurePokemonsTask.Execute(session, pokeStop, cancellationToken);
}
FortSearchResponse fortSearch;
var timesZeroXPawarded = 0;
var fortTry = 0; //Current check
const int retryNumber = 50; //How many times it needs to check to clear softban
const int zeroCheck = 5; //How many times it checks fort before it thinks it's softban
do
{
cancellationToken.ThrowIfCancellationRequested();
if (SearchThresholdExceeds(session))
{
break;
}
fortSearch =
await session.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (fortSearch.ExperienceAwarded > 0 && timesZeroXPawarded > 0)
{
timesZeroXPawarded = 0;
}
if (fortSearch.ExperienceAwarded == 0)
{
timesZeroXPawarded++;
if (timesZeroXPawarded > zeroCheck)
{
if ((int)fortSearch.CooldownCompleteTimestampMs != 0)
{
break; // Check if successfully looted, if so program can continue as this was "false alarm".
}
fortTry += 1;
session.EventDispatcher.Send(new FortFailedEvent
{
Name = fortInfo.Name,
Try = fortTry,
Max = retryNumber - zeroCheck,
Looted = false
});
if (!session.LogicSettings.FastSoftBanBypass)
{
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 0);
}
}
}
else
{
if (fortTry != 0)
{
session.EventDispatcher.Send(new FortFailedEvent
{
Name = fortInfo.Name,
Try = fortTry + 1,
Max = retryNumber - zeroCheck,
Looted = true
});
}
session.EventDispatcher.Send(new FortUsedEvent
{
Id = pokeStop.Id,
Name = fortInfo.Name,
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded),
Latitude = pokeStop.Latitude,
Longitude = pokeStop.Longitude,
InventoryFull = fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull
});
if (fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull)
{
storeRI = 1;
}
session.Stats.PokeStopTimestamps.Add(DateTime.Now.Ticks);
break; //Continue with program as loot was succesfull.
}
} while (fortTry < retryNumber - zeroCheck);
//Stop trying if softban is cleaned earlier or if 40 times fort looting failed.
if (session.LogicSettings.RandomlyPauseAtStops)
{
if (++RandomStop >= RandomNumber)
{
RandomNumber = rc.Next(4, 11);
RandomStop = 0;
int RandomWaitTime = rc.Next(30, 120);
Thread.Sleep(RandomWaitTime);
}
}
}
public static async Task ExeCuteMyFarm(ISession session, CancellationToken cancellationToken)
{
System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us");
blWentAnyLoc = false;
var vrList = funcReturnPokeLoc();
Logger.Write("Location found count " + vrList.Count, LogLevel.Self, ConsoleColor.DarkGray);
int irLoop = 1;
double dblMinDistance = 9999999;
double dblMinDistLat = 0;
double dblMinDistLng = 0;
string srMinDistLoc = "na";
double dblRareIndex = 999;
int irRarePokeId = 0;
for (int i = 0; i < vrList.Count; i++)
{
foreach (var vrloc in vrList)
{
if (hsGonaLocations.Contains(vrloc))
{
continue;
}
List <string> lstData = vrloc.Split(';').ToList();
if (DateTime.UtcNow.AddSeconds(-5) > Convert.ToDateTime(lstData[3]))
{
continue;
}
double dblLat;
double dblLong;
double.TryParse(vrloc.Split(';')[0].Replace(",", "."), NumberStyles.Any, CultureInfo.InvariantCulture, out dblLat);
double.TryParse(vrloc.Split(';')[1].Replace(",", "."), NumberStyles.Any, CultureInfo.InvariantCulture, out dblLong);
if (dblLat == 0 || dblLong == 0)
{
continue;
}
int irPokemonId = Convert.ToInt32(lstData[4]);
int irThisRareIndex = 999;
if (GlobalSettings.lstPriorityPokemon.Contains(irPokemonId) == true)
{
irThisRareIndex = GlobalSettings.lstPriorityPokemon.IndexOf(irPokemonId);
}
var sourceLocation = new GeoCoordinate(session.Client.CurrentLatitude, session.Client.CurrentLongitude);
var targetLocation = new GeoCoordinate(dblLat, dblLong);
var distance = LocationUtils.CalculateDistanceInMeters(sourceLocation, targetLocation);
if (distance < dblMinDistance && dblRareIndex >= irThisRareIndex)
{
dblMinDistance = distance;
dblMinDistLat = dblLat;
dblMinDistLng = dblLong;
srMinDistLoc = vrloc;
irRarePokeId = irPokemonId;
}
if (dblRareIndex > irThisRareIndex && GlobalSettings.blEnableRareHunt == true)
{
dblMinDistance = distance;
dblMinDistLat = dblLat;
dblMinDistLng = dblLong;
srMinDistLoc = vrloc;
dblRareIndex = irThisRareIndex;
irRarePokeId = irPokemonId;
}
}
if (dblMinDistLat != 0 && dblMinDistLng != 0)
{
blWentAnyLoc = true;
Logger.Write("Target Poke Loop " + irLoop + " | Target Poke " + (PokemonId)irRarePokeId + " (" + irRarePokeId + ") | Target: " + srMinDistLoc, LogLevel.Self, ConsoleColor.DarkGray);
if (dblRareIndex != 999)
{
Logger.Write("Going for rare Index " + dblRareIndex + "| Target Poke " + (PokemonId)irRarePokeId + " (" + irRarePokeId + ") | Target: " + srMinDistLoc, LogLevel.Self, ConsoleColor.DarkMagenta);
}
hsGonaLocations.Add(srMinDistLoc);
await session.Navigation.Move(new GeoCoordinate(dblMinDistLat, dblMinDistLng),
session.LogicSettings.WalkingSpeedInKilometerPerHour,
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
}, cancellationToken);
irLoop++;
dblMinDistance = 9999999;
dblMinDistLat = 0;
dblMinDistLng = 0;
if (GlobalSettings.blCriticalBall == true)
{
Logger.Write("Critical BALL check...", LogLevel.Self, ConsoleColor.Yellow);
await Execute(session, cancellationToken);
}
}
}
if (blWentAnyLoc == false)
{
Logger.Write("No location found make sure that poke miner is running!", LogLevel.Self, ConsoleColor.Yellow);
await Execute(session, cancellationToken);
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
var tracks = GetGpxTracks(session);
var eggWalker = new EggWalker(1000, session);
for (var curTrk = 0; curTrk < tracks.Count; curTrk++)
{
cancellationToken.ThrowIfCancellationRequested();
var track = tracks.ElementAt(curTrk);
var trackSegments = track.Segments;
if (curTrkSeg >= trackSegments.Count)
{
curTrkSeg = 0;
}
for (; curTrkSeg < trackSegments.Count; curTrkSeg++)
{
cancellationToken.ThrowIfCancellationRequested();
var trackPoints = track.Segments.ElementAt(curTrkSeg).TrackPoints;
if (curTrkPt >= trackPoints.Count)
{
curTrkPt = 0;
}
for (; curTrkPt < trackPoints.Count; curTrkPt++)
{
cancellationToken.ThrowIfCancellationRequested();
var nextPoint = trackPoints.ElementAt(curTrkPt);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude,
Convert.ToDouble(nextPoint.Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(nextPoint.Lon, CultureInfo.InvariantCulture));
if (distance > 5000)
{
session.EventDispatcher.Send(new ErrorEvent
{
Message =
session.Translation.GetTranslation(TranslationString.DesiredDestTooFar,
nextPoint.Lat, nextPoint.Lon, session.Client.CurrentLatitude,
session.Client.CurrentLongitude)
});
break;
}
var pokestopList = await GetPokeStops(session);
while (pokestopList.Any())
// warning: this is never entered due to ps cooldowns from UseNearbyPokestopsTask
{
cancellationToken.ThrowIfCancellationRequested();
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
var fortInfo =
await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (pokeStop.LureInfo != null)
{
await CatchLurePokemonsTask.Execute(session, pokeStop, cancellationToken);
}
var fortSearch =
await session.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (fortSearch.ExperienceAwarded > 0)
{
session.EventDispatcher.Send(new FortUsedEvent
{
Id = pokeStop.Id,
Name = fortInfo.Name,
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded),
Latitude = pokeStop.Latitude,
Longitude = pokeStop.Longitude
});
}
else
{
await RecycleItemsTask.Execute(session, cancellationToken);
}
if (fortSearch.ItemsAwarded.Count > 0)
{
await session.Inventory.RefreshCachedInventory();
}
}
if (DateTime.Now > _lastTasksCall)
{
_lastTasksCall =
DateTime.Now.AddMilliseconds(Math.Min(session.LogicSettings.DelayBetweenPlayerActions,
3000));
await RecycleItemsTask.Execute(session, cancellationToken);
if (session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.EvolveAllPokemonAboveIv ||
session.LogicSettings.UseLuckyEggsWhileEvolving ||
session.LogicSettings.KeepPokemonsThatCanEvolve)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
await GetPokeDexCount.Execute(session, cancellationToken);
if (session.LogicSettings.AutomaticallyLevelUpPokemon)
{
await LevelUpPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseLuckyEggConstantly)
{
await UseLuckyEggConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseIncenseConstantly)
{
await UseIncenseConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferWeakPokemon)
{
await TransferWeakPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.RenamePokemon)
{
await RenamePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutoFavoritePokemon)
{
await FavoritePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.SnipeAtPokestops || session.LogicSettings.UseSnipeLocationServer)
{
await SnipePokemonTask.Execute(session, cancellationToken);
}
}
var geo = new GeoCoordinate(Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lon, CultureInfo.InvariantCulture));
await session.Navigation.Move(geo,
async() =>
{
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
await eggWalker.ApplyDistance(distance, cancellationToken);
} //end trkpts
} //end trksegs
} //end tracks
}
public static async Task Execute(ISession session, CancellationToken cancellationToken, Func <double, double, Task> actionWhenWalking = null, Func <Task> afterCatchFunc = null)
{
pokestopCount++;
pokestopCount = pokestopCount % 3;
if (pokestopCount > 0)
{
return;
}
_session = session;
_setting = session.LogicSettings;
cancellationToken.ThrowIfCancellationRequested();
if (!_setting.CatchPokemon)
{
return;
}
pokemonToBeSnipedIds = _setting.PokemonToSnipe.Pokemon;
pokemonToBeSnipedIds.AddRange(_setting.HumanWalkSnipeFilters.Where(x => !pokemonToBeSnipedIds.Any(t => t == x.Key)).Select(x => x.Key).ToList()); //this will combine with pokemon snipe filter
if (_setting.HumanWalkingSnipeTryCatchEmAll)
{
var checkBall = await CheckPokeballsToSnipe(_setting.HumanWalkingSnipeCatchEmAllMinBalls, session, cancellationToken);
if (!checkBall)
{
return;
}
}
bool keepWalking = true;
bool caughtAnyPokemonInThisWalk = false;
while (keepWalking)
{
var pokemons = GetRarePokemons(session.Client.CurrentLatitude, session.Client.CurrentLongitude, !caughtAnyPokemonInThisWalk);
foreach (var pokemon in pokemons)
{
caughtAnyPokemonInThisWalk = true;
CalculateDistanceAndEstTime(pokemon);
var remainTimes = (pokemon.expired - DateTime.Now).TotalSeconds * 0.9; //just use 90% times
var catchPokemonTimeEST = (pokemon.distance / 100) * 10; //assume that 100m we catch 1 pokemon and it took 10 second for each.
string strPokemon = session.Translation.GetPokemonTranslation(pokemon.Id);
var spinPokestopEST = (pokemon.distance / 100) * 5;
bool catchPokemon = (pokemon.estimateTime + catchPokemonTimeEST) < remainTimes && pokemon.FilterSetting.CatchPokemonWhileWalking;
bool spinPokestop = pokemon.FilterSetting.SpinPokestopWhileWalking && (pokemon.estimateTime + catchPokemonTimeEST + spinPokestopEST) < remainTimes;
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
PokemonId = pokemon.Id,
Latitude = pokemon.latitude,
Longitude = pokemon.longitude,
Distance = pokemon.distance,
Expires = (pokemon.expired - DateTime.Now).TotalSeconds,
Estimate = (int)pokemon.estimateTime,
Setting = pokemon.FilterSetting,
CatchPokemon = catchPokemon,
SpinPokeStop = pokemon.FilterSetting.SpinPokestopWhileWalking,
Type = HumanWalkSnipeEventTypes.StartWalking
});
await session.Navigation.Move(new GeoCoordinate(pokemon.latitude, pokemon.longitude,
LocationUtils.getElevation(pokemon.latitude, pokemon.longitude)),
async() =>
{
var distance = LocationUtils.CalculateDistanceInMeters(pokemon.latitude, pokemon.longitude, session.Client.CurrentLatitude, session.Client.CurrentLongitude);
if (catchPokemon && distance > 50)
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
}
if (actionWhenWalking != null && spinPokestop)
{
await actionWhenWalking(session.Client.CurrentLatitude, session.Client.CurrentLongitude);
}
return(await Task.FromResult <bool>(true));
},
session,
cancellationToken);
session.EventDispatcher.Send(new HumanWalkSnipeEvent()
{
Latitude = pokemon.latitude,
Longitude = pokemon.longitude,
Type = HumanWalkSnipeEventTypes.DestinationReached
});
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
}
keepWalking = _setting.HumanWalkingSnipeTryCatchEmAll && pokemons.Count > 0;
}
if (caughtAnyPokemonInThisWalk && !_setting.HumanWalkingSnipeAlwaysWalkBack)
{
await afterCatchFunc?.Invoke();
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
var tracks = GetGpxTracks(session);
var eggWalker = new EggWalker(1000, session);
if (_resumeTrack + _resumeTrackSeg + _resumeTrackPt == 0)
{
_resumeTrack = session.LogicSettings.ResumeTrack;
_resumeTrackSeg = session.LogicSettings.ResumeTrackSeg;
_resumeTrackPt = session.LogicSettings.ResumeTrackPt;
// initialize the variables in UseNearbyPokestopsTask here, as this is a fresh start.
UseNearbyPokestopsTask.Initialize();
}
for (var curTrk = _resumeTrack; curTrk < tracks.Count; curTrk++)
{
_resumeTrack = curTrk;
cancellationToken.ThrowIfCancellationRequested();
var track = tracks.ElementAt(curTrk);
var trackSegments = track.Segments;
for (var curTrkSeg = _resumeTrackSeg; curTrkSeg < trackSegments.Count; curTrkSeg++)
{
_resumeTrackSeg = curTrkSeg;
cancellationToken.ThrowIfCancellationRequested();
var trackPoints = trackSegments.ElementAt(curTrkSeg).TrackPoints;
for (var curTrkPt = _resumeTrackPt; curTrkPt < trackPoints.Count; curTrkPt++)
{
_resumeTrackPt = curTrkPt;
cancellationToken.ThrowIfCancellationRequested();
var nextPoint = trackPoints.ElementAt(curTrkPt);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude,
Convert.ToDouble(nextPoint.Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(nextPoint.Lon, CultureInfo.InvariantCulture));
if (distance > 5000)
{
session.EventDispatcher.Send(new ErrorEvent
{
Message =
session.Translation.GetTranslation(TranslationString.DesiredDestTooFar,
nextPoint.Lat, nextPoint.Lon, session.Client.CurrentLatitude,
session.Client.CurrentLongitude)
});
break;
}
var geo = new GeoCoordinate(Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lon, CultureInfo.InvariantCulture));
await session.Navigation.Move(geo,
async() =>
{
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
await eggWalker.ApplyDistance(distance, cancellationToken);
} //end trkpts
_resumeTrackPt = 0;
} //end trksegs
_resumeTrackSeg = 0;
} //end tracks
_resumeTrack = 0;
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var distanceFromStart = LocationUtils.CalculateDistanceInMeters(
session.Settings.DefaultLatitude, session.Settings.DefaultLongitude,
session.Client.CurrentLatitude, session.Client.CurrentLongitude);
// Edge case for when the client somehow ends up outside the defined radius
if (session.LogicSettings.MaxTravelDistanceInMeters != 0 &&
distanceFromStart > session.LogicSettings.MaxTravelDistanceInMeters)
{
Logger.Write(
session.Translation.GetTranslation(TranslationString.FarmPokestopsOutsideRadius, distanceFromStart),
LogLevel.Warning);
await session.Navigation.Move(
new GeoCoordinate(session.Settings.DefaultLatitude, session.Settings.DefaultLongitude, LocationUtils.getElevation(session.Settings.DefaultLatitude, session.Settings.DefaultLongitude)),
session.LogicSettings.WalkingSpeedInKilometerPerHour, null, cancellationToken, session.LogicSettings.DisableHumanWalking);
}
var pokestopList = await GetPokeStops(session);
var stopsHit = 0;
var rc = new Random(); //initialize pokestop random cleanup counter first time
storeRI = rc.Next(8, 15);
var eggWalker = new EggWalker(1000, session);
if (pokestopList.Count <= 0)
{
session.EventDispatcher.Send(new WarnEvent
{
Message = session.Translation.GetTranslation(TranslationString.FarmPokestopsNoUsableFound)
});
}
session.EventDispatcher.Send(new PokeStopListEvent {
Forts = pokestopList
});
while (pokestopList.Any())
{
cancellationToken.ThrowIfCancellationRequested();
//resort
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
var fortInfo = await session.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
session.EventDispatcher.Send(new FortTargetEvent {
Name = fortInfo.Name, Distance = distance
});
await session.Navigation.Move(new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude, LocationUtils.getElevation(pokeStop.Latitude, pokeStop.Longitude)),
session.LogicSettings.WalkingSpeedInKilometerPerHour,
async() =>
{
// Catch normal map Pokemon
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
return(true);
}, cancellationToken, session.LogicSettings.DisableHumanWalking);
//Catch Lure Pokemon
if (pokeStop.LureInfo != null)
{
await CatchLurePokemonsTask.Execute(session, pokeStop, cancellationToken);
}
FortSearchResponse fortSearch;
var timesZeroXPawarded = 0;
var fortTry = 0; //Current check
const int retryNumber = 50; //How many times it needs to check to clear softban
const int zeroCheck = 5; //How many times it checks fort before it thinks it's softban
do
{
cancellationToken.ThrowIfCancellationRequested();
fortSearch =
await session.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);
if (fortSearch.ExperienceAwarded > 0 && timesZeroXPawarded > 0)
{
timesZeroXPawarded = 0;
}
if (fortSearch.ExperienceAwarded == 0)
{
timesZeroXPawarded++;
if (timesZeroXPawarded > zeroCheck)
{
if ((int)fortSearch.CooldownCompleteTimestampMs != 0)
{
break;
// Check if successfully looted, if so program can continue as this was "false alarm".
}
fortTry += 1;
session.EventDispatcher.Send(new FortFailedEvent
{
Name = fortInfo.Name,
Try = fortTry,
Max = retryNumber - zeroCheck
});
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 0);
}
}
else
{
session.EventDispatcher.Send(new FortUsedEvent
{
Id = pokeStop.Id,
Name = fortInfo.Name,
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded),
Latitude = pokeStop.Latitude,
Longitude = pokeStop.Longitude,
InventoryFull = fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull
});
if (fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull)
{
storeRI = 1;
}
break; //Continue with program as loot was succesfull.
}
} while (fortTry < retryNumber - zeroCheck);
//Stop trying if softban is cleaned earlier or if 40 times fort looting failed.
await eggWalker.ApplyDistance(distance, cancellationToken);
if (++stopsHit >= storeRI) //TODO: OR item/pokemon bag is full //check stopsHit against storeRI random without dividing.
{
storeRI = rc.Next(6, 12); //set new storeRI for new random value
stopsHit = 0;
await RecycleItemsTask.Execute(session, cancellationToken);
if (fortSearch.ItemsAwarded.Count > 0)
{
await session.Inventory.RefreshCachedInventory();
}
if (session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.EvolveAllPokemonAboveIv ||
session.LogicSettings.UseLuckyEggsWhileEvolving ||
session.LogicSettings.KeepPokemonsThatCanEvolve)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseLuckyEggConstantly)
{
await UseLuckyEggConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseIncenseConstantly)
{
await UseIncenseConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferWeakPokemon)
{
await TransferWeakPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.RenamePokemon)
{
await RenamePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutoFavoritePokemon)
{
await FavoritePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutomaticallyLevelUpPokemon)
{
await LevelUpPokemonTask.Execute(session, cancellationToken);
}
await GetPokeDexCount.Execute(session, cancellationToken);
}
if (session.LogicSettings.SnipeAtPokestops || session.LogicSettings.UseSnipeLocationServer)
{
await SnipePokemonTask.Execute(session, cancellationToken);
}
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
var tracks = GetGpxTracks(session);
var eggWalker = new EggWalker(1000, session);
if (_resumeTrack + _resumeTrackSeg + _resumeTrackPt == 0)
{
_resumeTrack = session.LogicSettings.ResumeTrack;
_resumeTrackSeg = session.LogicSettings.ResumeTrackSeg;
_resumeTrackPt = session.LogicSettings.ResumeTrackPt;
}
for (var curTrk = _resumeTrack; curTrk < tracks.Count; curTrk++)
{
_resumeTrack = curTrk;
cancellationToken.ThrowIfCancellationRequested();
var track = tracks.ElementAt(curTrk);
var trackSegments = track.Segments;
for (var curTrkSeg = _resumeTrackSeg; curTrkSeg < trackSegments.Count; curTrkSeg++)
{
_resumeTrackSeg = curTrkSeg;
cancellationToken.ThrowIfCancellationRequested();
var trackPoints = trackSegments.ElementAt(curTrkSeg).TrackPoints;
for (var curTrkPt = _resumeTrackPt; curTrkPt < trackPoints.Count; curTrkPt++)
{
_resumeTrackPt = curTrkPt;
cancellationToken.ThrowIfCancellationRequested();
var nextPoint = trackPoints.ElementAt(curTrkPt);
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude,
Convert.ToDouble(nextPoint.Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(nextPoint.Lon, CultureInfo.InvariantCulture));
if (distance > 5000)
{
session.EventDispatcher.Send(new ErrorEvent
{
Message =
session.Translation.GetTranslation(TranslationString.DesiredDestTooFar,
nextPoint.Lat, nextPoint.Lon, session.Client.CurrentLatitude,
session.Client.CurrentLongitude)
});
break;
}
if (DateTime.Now > _lastTasksCall)
{
_lastTasksCall =
DateTime.Now.AddMilliseconds(Math.Min(session.LogicSettings.DelayBetweenPlayerActions,
3000));
await RecycleItemsTask.Execute(session, cancellationToken);
if (session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.EvolveAllPokemonAboveIv ||
session.LogicSettings.UseLuckyEggsWhileEvolving ||
session.LogicSettings.KeepPokemonsThatCanEvolve)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
await GetPokeDexCount.Execute(session, cancellationToken);
if (session.LogicSettings.AutomaticallyLevelUpPokemon)
{
await LevelUpPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseLuckyEggConstantly)
{
await UseLuckyEggConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.UseIncenseConstantly)
{
await UseIncenseConstantlyTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferWeakPokemon)
{
await TransferWeakPokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.RenamePokemon)
{
await RenamePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.AutoFavoritePokemon)
{
await FavoritePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.SnipeAtPokestops || session.LogicSettings.UseSnipeLocationServer)
{
await SnipePokemonTask.Execute(session, cancellationToken);
}
}
var geo = new GeoCoordinate(Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(trackPoints.ElementAt(curTrkPt).Lon, CultureInfo.InvariantCulture));
await session.Navigation.Move(geo,
async() =>
{
await CatchNearbyPokemonsTask.Execute(session, cancellationToken);
//Catch Incense Pokemon
await CatchIncensePokemonsTask.Execute(session, cancellationToken);
await UseNearbyPokestopsTask.Execute(session, cancellationToken);
return(true);
},
session,
cancellationToken);
await eggWalker.ApplyDistance(distance, cancellationToken);
} //end trkpts
_resumeTrackPt = 0;
} //end trksegs
_resumeTrackSeg = 0;
} //end tracks
_resumeTrack = 0;
}