private static async Task <ItemId> GetBestBall(ISession session, dynamic encounter, float probability, bool blPrint = false)
{
var pokemonCp = encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.Cp
: encounter?.PokemonData?.Cp;
var pokemonId = encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.PokemonId
: encounter?.PokemonData?.PokemonId;
var iV =
Math.Round(
PokemonInfo.CalculatePokemonPerfection(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData), 2);
var pokeBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemPokeBall);
var greatBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemGreatBall);
var ultraBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemUltraBall);
var masterBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemMasterBall);
if (blPrint == true)
{
Logger.Write($"poke ball ({pokeBallsCount}) , great ball ({greatBallsCount}) , ultra ball ({ultraBallsCount}) , master ball ({masterBallsCount}) ", LogLevel.Self, ConsoleColor.White);
}
if ((pokeBallsCount + greatBallsCount + ultraBallsCount) < GlobalSettings.irCritical_Ball_Lowest)
{
GlobalSettings.blCriticalBall = true;
}
if ((pokeBallsCount + greatBallsCount + ultraBallsCount) > GlobalSettings.irCritical_Ball_Upper)
{
GlobalSettings.blCriticalBall = false;
}
if (masterBallsCount > 0 && (
(!session.LogicSettings.PokemonToUseMasterball.Any() && (
pokemonCp >= session.LogicSettings.UseMasterBallAboveCp ||
probability < session.LogicSettings.UseMasterBallBelowCatchProbability)) ||
session.LogicSettings.PokemonToUseMasterball.Contains(pokemonId)))
{
return(ItemId.ItemMasterBall);
}
if (ultraBallsCount > 0 && (
pokemonCp >= session.LogicSettings.UseUltraBallAboveCp ||
iV >= session.LogicSettings.UseUltraBallAboveIv ||
probability < session.LogicSettings.UseUltraBallBelowCatchProbability))
{
return(ItemId.ItemUltraBall);
}
if (greatBallsCount > 0 && (
pokemonCp >= session.LogicSettings.UseGreatBallAboveCp ||
iV >= session.LogicSettings.UseGreatBallAboveIv ||
probability < session.LogicSettings.UseGreatBallBelowCatchProbability))
{
return(ItemId.ItemGreatBall);
}
if (pokeBallsCount > 0)
{
return(ItemId.ItemPokeBall);
}
if (greatBallsCount > 0)
{
return(ItemId.ItemGreatBall);
}
if (ultraBallsCount > 0)
{
return(ItemId.ItemUltraBall);
}
if (masterBallsCount > 0 && !session.LogicSettings.PokemonToUseMasterball.Any())
{
return(ItemId.ItemMasterBall);
}
return(ItemId.ItemUnknown);
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
// Refresh inventory so that the player stats are fresh
//await session.Inventory.RefreshCachedInventory();
var playerStats = (await session.Inventory.GetPlayerStats()).FirstOrDefault();
if (playerStats == null)
{
return;
}
var kmWalked = playerStats.KmWalked;
var incubators = (await session.Inventory.GetEggIncubators())
.Where(x => x.UsesRemaining > 0 || x.ItemId == ItemId.ItemIncubatorBasicUnlimited)
.OrderByDescending(x => x.ItemId == ItemId.ItemIncubatorBasicUnlimited)
.ToList();
var unusedEggs = (await session.Inventory.GetEggs())
.Where(x => string.IsNullOrEmpty(x.EggIncubatorId))
.OrderBy(x => x.EggKmWalkedTarget - x.EggKmWalkedStart)
.ToList();
var rememberedIncubatorsFilePath = Path.Combine(session.LogicSettings.ProfilePath, "temp", "incubators.json");
var rememberedIncubators = GetRememberedIncubators(rememberedIncubatorsFilePath);
var pokemons = (await session.Inventory.GetPokemons()).ToList();
// Check if eggs in remembered incubator usages have since hatched
// (instead of calling session.Client.Inventory.GetHatchedEgg(), which doesn't seem to work properly)
foreach (var incubator in rememberedIncubators)
{
var hatched = pokemons.FirstOrDefault(x => !x.IsEgg && x.Id == incubator.PokemonId);
if (hatched == null)
{
continue;
}
session.EventDispatcher.Send(new EggHatchedEvent
{
Id = hatched.Id,
PokemonId = hatched.PokemonId,
Level = PokemonInfo.GetLevel(hatched),
Cp = hatched.Cp,
MaxCp = PokemonInfo.CalculateMaxCp(hatched),
Perfection = Math.Round(PokemonInfo.CalculatePokemonPerfection(hatched), 2)
});
}
var newRememberedIncubators = new List <IncubatorUsage>();
foreach (var incubator in incubators)
{
cancellationToken.ThrowIfCancellationRequested();
if (incubator.PokemonId == 0)
{
// Unlimited incubators prefer short eggs, limited incubators prefer long eggs
// Special case: If only one incubator is available at all, it will prefer long eggs
var egg = (incubator.ItemId == ItemId.ItemIncubatorBasicUnlimited && incubators.Count > 1)
? unusedEggs.FirstOrDefault()
: unusedEggs.LastOrDefault();
if (egg == null)
{
continue;
}
// Skip (save) limited incubators depending on user choice in config
if (!session.LogicSettings.UseLimitedEggIncubators &&
incubator.ItemId != ItemId.ItemIncubatorBasicUnlimited)
{
continue;
}
var response = await session.Client.Inventory.UseItemEggIncubator(incubator.Id, egg.Id);
unusedEggs.Remove(egg);
newRememberedIncubators.Add(new IncubatorUsage {
IncubatorId = incubator.Id, PokemonId = egg.Id
});
session.EventDispatcher.Send(new EggIncubatorStatusEvent
{
IncubatorId = incubator.Id,
WasAddedNow = true,
PokemonId = egg.Id,
KmToWalk = egg.EggKmWalkedTarget,
KmRemaining = response.EggIncubator.TargetKmWalked - kmWalked
});
}
else
{
newRememberedIncubators.Add(new IncubatorUsage
{
IncubatorId = incubator.Id,
PokemonId = incubator.PokemonId
});
session.EventDispatcher.Send(new EggIncubatorStatusEvent
{
IncubatorId = incubator.Id,
PokemonId = incubator.PokemonId,
KmToWalk = incubator.TargetKmWalked - incubator.StartKmWalked,
KmRemaining = incubator.TargetKmWalked - kmWalked
});
}
}
if (!newRememberedIncubators.SequenceEqual(rememberedIncubators))
{
SaveRememberedIncubators(newRememberedIncubators, rememberedIncubatorsFilePath);
}
}
public double GetPerfect(PokemonData poke)
{
var result = PokemonInfo.CalculatePokemonPerfection(poke);
return(result);
}
private async Task DisplayHighests()
{
Logger.Write("====== DisplayHighestsCP ======", LogLevel.Info, ConsoleColor.Yellow);
var highestsPokemonCp = await _inventory.GetHighestsCp(10);
foreach (var pokemon in highestsPokemonCp)
{
Logger.Write(
$"# CP {pokemon.Cp.ToString().PadLeft(4, ' ')}/{PokemonInfo.CalculateMaxCp(pokemon).ToString().PadLeft(4, ' ')} | ({PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00")}% perfect)\t| Lvl {PokemonInfo.GetLevel(pokemon).ToString("00")}\t NAME: '{pokemon.PokemonId}'",
LogLevel.Info, ConsoleColor.Yellow);
}
Logger.Write("====== DisplayHighestsPerfect ======", LogLevel.Info, ConsoleColor.Yellow);
var highestsPokemonPerfect = await _inventory.GetHighestsPerfect(10);
foreach (var pokemon in highestsPokemonPerfect)
{
Logger.Write(
$"# CP {pokemon.Cp.ToString().PadLeft(4, ' ')}/{PokemonInfo.CalculateMaxCp(pokemon).ToString().PadLeft(4, ' ')} | ({PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00")}% perfect)\t| Lvl {PokemonInfo.GetLevel(pokemon).ToString("00")}\t NAME: '{pokemon.PokemonId}'",
LogLevel.Info, ConsoleColor.Yellow);
}
}
public static async Task SaveAsExcel(ISession session, string Filename = "")
{
await Task.Run(async() =>
{
var allPokemonInBag = session.LogicSettings.PrioritizeIvOverCp
? await session.Inventory.GetHighestsPerfect(1000).ConfigureAwait(false)
: await session.Inventory.GetHighestsCp(1000).ConfigureAwait(false);
string file = !string.IsNullOrEmpty(Filename)
? Filename
: $"config\\{session.Settings.Username}\\allpokemon.xlsx";
int rowNum = 1;
using (Stream stream = File.OpenWrite(file))
using (var package = new ExcelPackage(stream))
{
var ws = package.Workbook.Worksheets.Add("Pokemons");
foreach (var item in allPokemonInBag)
{
var settings = await session.Inventory.GetPokemonSetting(item.PokemonId).ConfigureAwait(false);
if (rowNum == 1)
{
ws.Cells[1, 1].Value = "#";
ws.Cells[1, 2].Value = "Pokemon";
ws.Cells[1, 3].Value = "Display Name";
ws.Cells[1, 4].Value = "Nickname";
ws.Cells[1, 5].Value = "IV";
ws.Cells[1, 6].Value = "Attack";
ws.Cells[1, 7].Value = "Defense";
ws.Cells[1, 8].Value = "Stamina";
ws.Cells[1, 9].Value = "HP";
ws.Cells[1, 10].Value = "MaxHP";
ws.Cells[1, 11].Value = "CP";
ws.Cells[1, 12].Value = "Level";
ws.Cells[1, 13].Value = "Candy";
ws.Cells[1, 14].Value = "Move1";
ws.Cells[1, 15].Value = "Move2";
ws.Cells[1, 16].Value = "Type";
ws.Cells[1, 17].Value = "Shiny";
ws.Cells[1, 18].Value = "Form";
ws.Cells[1, 19].Value = "Costume";
ws.Cells[1, 20].Value = "Sex";
ws.Cells["A1:Q1"].AutoFilter = true;
ws.Cells["A1:Q1"].Style.Font.Bold = true;
}
ws.Cells[rowNum + 1, 1].Value = rowNum;
ws.Cells[rowNum + 1, 2].Value = item.PokemonId.ToString();
ws.Cells[rowNum + 1, 3].Value = item.Nickname;
ws.Cells[rowNum + 1, 4].Value = item.OwnerName;
ws.Cells[rowNum + 1, 5].Value = Math.Round(PokemonInfo.CalculatePokemonPerfection(item), 2);
ws.Cells[rowNum + 1, 6].Value = item.IndividualAttack;
ws.Cells[rowNum + 1, 7].Value = item.IndividualDefense;
ws.Cells[rowNum + 1, 8].Value = item.IndividualStamina;
ws.Cells[rowNum + 1, 9].Value = item.Stamina;
ws.Cells[rowNum + 1, 10].Value = item.StaminaMax;
ws.Cells[rowNum + 1, 11].Value = PokemonInfo.CalculateCp(item);
ws.Cells[rowNum + 1, 12].Value = PokemonInfo.GetLevel(item);
ws.Cells[rowNum + 1, 13].Value = session.Inventory.GetCandyCount(item.PokemonId);
ws.Cells[rowNum + 1, 14].Value = item.Move1.ToString();
ws.Cells[rowNum + 1, 15].Value = item.Move2.ToString();
ws.Cells[rowNum + 1, 16].Value = $"{settings.Type.ToString()},{settings.Type2.ToString()}";
ws.Cells[rowNum + 1, 17].Value = $"{(item.PokemonDisplay.Shiny ? "Yes" : "No")}";
ws.Cells[rowNum + 1, 18].Value = $"{(item.PokemonDisplay.Form.ToString().Replace("Unown", "").Replace("Unset", "Normal"))}";
ws.Cells[rowNum + 1, 19].Value = $"{(item.PokemonDisplay.Costume.ToString().Replace("Unset", "Regular"))}";
ws.Cells[rowNum + 1, 20].Value = $"{(item.PokemonDisplay.Gender.ToString().Replace("Less", "Genderless"))}";
rowNum++;
}
package.Save();
}
}).ConfigureAwait(false);
}
private void powerUpToolStripMenuItem_Click(object sender, EventArgs e)
{
if (PokemonListView.SelectedItems.Count < 1)
{
return;
}
var pokemon = (PokemonData)PokemonListView.SelectedItems[0].Tag;
if (MessageBox.Show(this, th.TS(" {0} with {1} CP thats {2} % perfect", pokemon.PokemonId, pokemon.Cp, Math.Round(PokemonInfo.CalculatePokemonPerfection(pokemon))), th.TS("Are you sure you want to power it up?"), MessageBoxButtons.OKCancel) == DialogResult.OK)
{
if (PowerUp(pokemon))
{
Execute();
}
}
}
private async Task CatchEncounter(EncounterResponse encounter, MapPokemon pokemon)
{
CatchPokemonResponse caughtPokemonResponse;
var attemptCounter = 1;
do
{
var probability = encounter?.CaptureProbability?.CaptureProbability_?.FirstOrDefault();
var bestPokeball = await GetBestBall(encounter);
if (bestPokeball == MiscEnums.Item.ITEM_UNKNOWN)
{
Logger.Write($"You don't own any Pokeballs :( - We missed a {pokemon.PokemonId} with CP {encounter?.WildPokemon?.PokemonData?.Cp}", LogLevel.Warning);
return;
}
var bestBerry = await GetBestBerry(encounter);
var inventoryBerries = await _inventory.GetItems();
var berries = inventoryBerries.FirstOrDefault(p => (ItemId)p.Item_ == bestBerry);
if (bestBerry != ItemId.ItemUnknown && probability.HasValue && probability.Value < 0.35)
{
await _client.UseCaptureItem(pokemon.EncounterId, bestBerry, pokemon.SpawnpointId);
berries.Count--;
Logger.Write($"{bestBerry} used, remaining: {berries.Count}", LogLevel.Berry);
}
var distance = LocationUtils.CalculateDistanceInMeters(_client.CurrentLat, _client.CurrentLng, pokemon.Latitude, pokemon.Longitude);
caughtPokemonResponse = await _client.CatchPokemon(pokemon.EncounterId, pokemon.SpawnpointId, pokemon.Latitude, pokemon.Longitude, bestPokeball);
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
foreach (var xp in caughtPokemonResponse.Scores.Xp)
{
_stats.AddExperience(xp);
}
_stats.IncreasePokemons();
var profile = await _client.GetProfile();
_stats.GetStardust(profile.Profile.Currency.ToArray()[1].Amount);
}
_stats.UpdateConsoleTitle(_client, _inventory);
if (encounter?.CaptureProbability?.CaptureProbability_ != null)
{
Func <MiscEnums.Item, string> returnRealBallName = a =>
{
switch (a)
{
case MiscEnums.Item.ITEM_POKE_BALL:
return("Poke");
case MiscEnums.Item.ITEM_GREAT_BALL:
return("Great");
case MiscEnums.Item.ITEM_ULTRA_BALL:
return("Ultra");
case MiscEnums.Item.ITEM_MASTER_BALL:
return("Master");
default:
return("Unknown");
}
};
var catchStatus = attemptCounter > 1
? $"{caughtPokemonResponse.Status} Attempt #{attemptCounter}"
: $"{caughtPokemonResponse.Status}";
var receivedXp = caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess
? $"and received XP {caughtPokemonResponse.Scores.Xp.Sum()}"
: $"";
Logger.Write($"({catchStatus}) | {pokemon.PokemonId} - Lvl {PokemonInfo.GetLevel(encounter?.WildPokemon?.PokemonData)} [CP {encounter?.WildPokemon?.PokemonData?.Cp}/{PokemonInfo.CalculateMaxCp(encounter?.WildPokemon?.PokemonData)} | IV: {PokemonInfo.CalculatePokemonPerfection(encounter?.WildPokemon?.PokemonData).ToString("0.00")}% perfect] | Chance: {(float)((int)(encounter?.CaptureProbability?.CaptureProbability_.First() * 100)) / 100} | {distance:0.##}m dist | with a {returnRealBallName(bestPokeball)}Ball {receivedXp}", LogLevel.Pokemon);
}
attemptCounter++;
}while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed || caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
}
private async Task TransferDuplicatePokemon(bool keepPokemonsThatCanEvolve = false)
{
if (_clientSettings.TransferDoublePokemons)
{
var duplicatePokemons = await _inventory.GetDuplicatePokemonToTransfer(keepPokemonsThatCanEvolve);
foreach (var duplicatePokemon in duplicatePokemons)
{
if (!_clientSettings.pokemonsToHold.Contains(duplicatePokemon.PokemonId))
{
if (duplicatePokemon.Cp > _clientSettings.DontTransferWithCPOver)
{
continue;
}
var bestPokemonOfType = await _inventory.GetHighestCPofType(duplicatePokemon);
var transfer = await _client.TransferPokemon(duplicatePokemon.Id);
Logger.ColoredConsoleWrite(ConsoleColor.Yellow, $"Transfer {StringUtils.getPokemonNameByLanguage(_clientSettings, duplicatePokemon.PokemonId)} with {duplicatePokemon.Cp} CP ({PokemonInfo.CalculatePokemonPerfection(duplicatePokemon)} % perfect) (Best: {bestPokemonOfType} CP)", LogLevel.Info);
await RandomHelper.RandomDelay(500, 700);
}
}
}
}
public async void BotOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
Message message = messageEventArgs.Message;
if (message == null || message.Type != MessageType.TextMessage)
{
return;
}
_chatid = message.Chat.Id;
try
{
Logger.ColoredConsoleWrite(ConsoleColor.Red, "[TelegramAPI] Got Request from " + message.From.Username + " | " + message.Text);
string username = _botSettings.TelegramName;
string telegramAnswer = string.Empty;
if (username != message.From.Username)
{
using (System.IO.Stream stream = new System.IO.MemoryStream())
{
PokemonGo.RocketAPI.Logic.Properties.Resources.norights.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);
stream.Position = 0;
await _telegram.SendPhotoAsync(_chatid, new FileToSend("norights.jpg", stream), replyMarkup : new ReplyKeyboardHide()).ConfigureAwait(false);
}
return;
}
// [0]-Commando; [1+]-Argument
var msgText = message.Text;
string[] textCMD = msgText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
TelegramUtilTask cmd = getTask(textCMD[0]);
switch (cmd)
{
case TelegramUtilTask.UNKNOWN:
telegramAnswer = string.Format("Usage:\r\n{0}\r\n{1}\r\n{2}\r\n{3}\r\n{4}\r\n{5}\r\n{6}\r\n{7}\r\n{8}\r\n{9}",
@"/stats - Get Current Stats",
@"/livestats - Enable/Disable Live Stats",
@"/information <topic> - Enable/Disable Information topics",
@"/top <HowMany?> - Outputs Top (?) Pokemons",
@"/transfer pokemon cp - transfer pokemons that matches with the given data",
@"/items - Outputs Items List",
@"/drop item amount - Throws the amount of items given",
@"/forceevolve - Forces Evolve",
@"/snipe pokemon latitude, longitude - snipe desired pokemon",
@"/stopbot - stop running bot");
break;
case TelegramUtilTask.GET_STATS:
var ps = _client.Inventory.GetPlayerStats();
int l = ps.First().Level;
long expneeded = ((ps.First().NextLevelXp - ps.First().PrevLevelXp) - StringUtils.getExpDiff(ps.First().Level));
long curexp = ((ps.First().Experience - ps.First().PrevLevelXp) - StringUtils.getExpDiff(ps.First().Level));
double curexppercent = (Convert.ToDouble(curexp) / Convert.ToDouble(expneeded)) * 100;
string curloc = _client.CurrentLatitude + "%20" + _client.CurrentLongitude;
curloc = curloc.Replace(",", ".");
string curlochtml = "https://www.google.com/maps/search/" + curloc + "/";
double shortenLng = Math.Round(_client.CurrentLongitude, 3);
double shortenLat = Math.Round(_client.CurrentLatitude, 3);
var player = _client.Player.GetPlayer();
telegramAnswer += "\nNickname: " + player.PlayerData.Username;
telegramAnswer += "\nLevel: " + ps.First().Level;
telegramAnswer += "\nEXP Needed: " + ((ps.First().NextLevelXp - ps.First().PrevLevelXp) - StringUtils.getExpDiff(ps.First().Level));
telegramAnswer += $"\nCurrent EXP: {curexp} ({Math.Round(curexppercent)}%)";
telegramAnswer += "\nEXP to Level up: " + ((ps.First().NextLevelXp) - (ps.First().Experience));
telegramAnswer += "\nKM walked: " + ps.First().KmWalked;
telegramAnswer += "\nPokeStops visited: " + ps.First().PokeStopVisits;
telegramAnswer += "\nStardust: " + player.PlayerData.Currencies.ToArray()[1].Amount;
telegramAnswer += "\nPokemons: " + (_client.Inventory.GetPokemons()).Count() + "/" + player.PlayerData.MaxPokemonStorage;
telegramAnswer += "\nItems: " + _client.Inventory.GetItems().Count() + " / " + player.PlayerData.MaxItemStorage;
telegramAnswer += "\nCurentLocation:\n" + curlochtml;
break;
case TelegramUtilTask.GET_TOPLIST:
int shows = 10;
if (textCMD.Length > 1 && !int.TryParse(textCMD[1], out shows))
{
telegramAnswer += $"Error! This is not a Number: {textCMD[1]}\nNevermind...\n";
shows = 10; //TryParse error will reset to 0
}
telegramAnswer += "Showing " + shows + " Pokemons...\nSorting...";
await _telegram.SendTextMessageAsync(_chatid, telegramAnswer, replyMarkup : new ReplyKeyboardHide()).ConfigureAwait(false);
var myPokemons = _client.Inventory.GetPokemons();
myPokemons = myPokemons.OrderByDescending(x => x.Cp);
var PogoUsername = _client.Player.GetPlayer().PlayerData.Username;
telegramAnswer = $"Top {shows} Pokemons of {PogoUsername}:";
IEnumerable <PokemonData> topPokemon = myPokemons.Take(shows);
foreach (PokemonData pokemon in topPokemon)
{
telegramAnswer += string.Format("\n{0} | CP: {1} ({2}% perfect)",
pokemon.PokemonId,
pokemon.Cp,
Math.Round(PokemonInfo.CalculatePokemonPerfection(pokemon), 2));
}
break;
case TelegramUtilTask.SWITCH_LIVESTATS:
_livestats = SwitchAndGetAnswer(_livestats, out telegramAnswer, "Live Stats");
break;
case TelegramUtilTask.SWITCH_INFORMATION:
//_informations = SwitchAndGetAnswer(_informations, out telegramAnswer, "Information");
Array topics = Enum.GetValues(typeof(TelegramUtilInformationTopics));
if (textCMD.Length > 1)
{
if (textCMD[1] == "all-enable")
{
foreach (TelegramUtilInformationTopics topic in topics)
{
String niceName = topic.ToString().Substring(0, 1).ToUpper() + topic.ToString().Substring(1).ToLower();
telegramAnswer += "Enabled information topic " + niceName + "\n";
_information[topic] = true;
}
break;
}
else if (textCMD[1] == "all-disable")
{
foreach (TelegramUtilInformationTopics topic in topics)
{
String niceName = topic.ToString().Substring(0, 1).ToUpper() + topic.ToString().Substring(1).ToLower();
telegramAnswer += "Disabled information topic " + niceName + "\n";
_information[topic] = false;
}
break;
}
else
{
foreach (TelegramUtilInformationTopics topic in topics)
{
if (textCMD[1].ToLower() == topic.ToString().ToLower())
{
String niceName = topic.ToString().Substring(0, 1).ToUpper() + topic.ToString().Substring(1).ToLower();
_information[topic] = !_information[topic];
telegramAnswer = (_information[topic] ? "En" : "Dis") + "abled information topic " + niceName + "\n";
break;
}
}
}
}
else
{
foreach (TelegramUtilInformationTopics topic in topics)
{
String niceName = topic.ToString().Substring(0, 1).ToUpper() + topic.ToString().Substring(1).ToLower();
telegramAnswer += " - " + niceName + "\n";
telegramAnswer += " - " + _informationDescription[topic] + "\n";
telegramAnswer += " - Currently " + (_information[topic] ? "enabled" : "disabled") + "\n";
telegramAnswer += "\n";
}
telegramAnswer += " - all-disable\n";
telegramAnswer += " - " + TranslationHandler.GetString("telegram-disable-all", "Disable all topics") + "\n";
telegramAnswer += "\n";
telegramAnswer += " - all-enable\n";
telegramAnswer += " - " + TranslationHandler.GetString("telegram-enable-all", "Enable all topics") + "\n";
telegramAnswer += "\n";
break;
}
break;
case TelegramUtilTask.RUN_FORCEEVOLVE:
IEnumerable <PokemonData> pokemonToEvolve = Setout.GetPokemonToEvolve(true);
if (pokemonToEvolve.Count() > 3)
{
Setout.UseLuckyEgg(_client);
}
foreach (PokemonData pokemon in pokemonToEvolve)
{
if (_botSettings.pokemonsToEvolve.Contains(pokemon.PokemonId))
{
var evolvePokemonOutProto = _client.Inventory.EvolvePokemon((ulong)pokemon.Id);
if (evolvePokemonOutProto.Result == POGOProtos.Networking.Responses.EvolvePokemonResponse.Types.Result.Success)
{
await _telegram.SendTextMessageAsync(_chatid, $"Evolved {pokemon.PokemonId} successfully for {evolvePokemonOutProto.ExperienceAwarded}xp", replyMarkup : new ReplyKeyboardHide()).ConfigureAwait(false);
}
else
{
await _telegram.SendTextMessageAsync(_chatid, $"Failed to evolve {pokemon.PokemonId}. EvolvePokemonOutProto.Result was {evolvePokemonOutProto.Result}, stopping evolving {pokemon.PokemonId}", replyMarkup : new ReplyKeyboardHide()).ConfigureAwait(false);
}
RandomHelper.RandomSleep(2000);
}
}
telegramAnswer = "Done.";
break;
case TelegramUtilTask.RUN_SNIPE:
telegramAnswer = ProcessSnipeCommand(msgText.Replace(textCMD[0], "").Trim());
break;
case TelegramUtilTask.FORCE_STOP:
var secs = 1;
if (textCMD.Length > 1)
{
int.TryParse(textCMD[1].Trim(), out secs);
}
telegramAnswer = $"Stopping bot in {secs} seconds";
await _telegram.SendTextMessageAsync(_chatid, telegramAnswer, replyMarkup : new ReplyKeyboardHide()).ConfigureAwait(false);
_telegram.StopReceiving();
RandomHelper.RandomSleep(secs * 1000);
Environment.Exit(0);
break;
case TelegramUtilTask.TRANSFER_POKEMON:
telegramAnswer = ProcessTransferPokemon(msgText.Replace(textCMD[0], "").Trim());
break;
case TelegramUtilTask.GET_ITEMSLIST:
telegramAnswer = ProcessGetItemList();
break;
case TelegramUtilTask.DROP_ITEM:
telegramAnswer = ProcessDropItem(msgText.Replace(textCMD[0], "").Trim());
break;
}
await _telegram.SendTextMessageAsync(_chatid, telegramAnswer, replyMarkup : new ReplyKeyboardHide()).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.Debug(ex.ToString());
var apiRequestException = ex as ApiRequestException;
if (apiRequestException != null)
{
await _telegram.SendTextMessageAsync(_chatid, apiRequestException.Message, replyMarkup : new ReplyKeyboardHide()).ConfigureAwait(false);
}
}
}
private async Task ExecuteCatchAllNearbyPokemons()
{
var client = _client;
var mapObjects = await client.GetMapObjects();
//var pokemons = mapObjects.MapCells.SelectMany(i => i.CatchablePokemons);
var pokemons =
mapObjects.MapCells.SelectMany(i => i.CatchablePokemons)
.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(_client.CurrentLat, _client.CurrentLng, i.Latitude, i.Longitude));
if (pokemons != null && pokemons.Any())
{
Logger.ColoredConsoleWrite(ConsoleColor.Magenta, $"Found {pokemons.Count()} catchable Pokemon(s).");
}
foreach (var pokemon in pokemons)
{
count++;
if (count >= 3)
{
count = 0;
await StatsLog(client);
if (_clientSettings.EvolvePokemonsIfEnoughCandy)
{
await EvolveAllPokemonWithEnoughCandy();
}
await TransferDuplicatePokemon(false);
await RecycleItems();
}
if (_clientSettings.catchPokemonSkipList.Contains(pokemon.PokemonId))
{
Logger.ColoredConsoleWrite(ConsoleColor.Green, "Skipped Pokemon: " + pokemon.PokemonId);
continue;
}
var distance = LocationUtils.CalculateDistanceInMeters(_client.CurrentLat, _client.CurrentLng, pokemon.Latitude, pokemon.Longitude);
await Task.Delay(distance > 100? 1000 : 100);
var encounterPokemonResponse = await _client.EncounterPokemon(pokemon.EncounterId, pokemon.SpawnpointId);
if (encounterPokemonResponse.Status == EncounterResponse.Types.Status.EncounterSuccess)
{
var bestPokeball = await GetBestBall(encounterPokemonResponse?.WildPokemon);
if (bestPokeball == MiscEnums.Item.ITEM_UNKNOWN)
{
Logger.ColoredConsoleWrite(ConsoleColor.Red, $"We dont own Pokeballs! - We missed a {pokemon.PokemonId} with CP {encounterPokemonResponse?.WildPokemon?.PokemonData?.Cp}");
return;
}
CatchPokemonResponse caughtPokemonResponse;
do
{
var inventoryBerries = await _inventory.GetItems();
var probability = encounterPokemonResponse?.CaptureProbability?.CaptureProbability_?.FirstOrDefault();
var bestBerry = await GetBestBerry(encounterPokemonResponse?.WildPokemon);
var berries = inventoryBerries.Where(p => (ItemId)p.Item_ == bestBerry).FirstOrDefault();
if (bestBerry != ItemId.ItemUnknown && probability.HasValue && probability.Value < 0.35)
{
//Throw berry is we can
var useRaspberry = await _client.UseCaptureItem(pokemon.EncounterId, bestBerry, pokemon.SpawnpointId);
Logger.ColoredConsoleWrite(ConsoleColor.Green, $"Used {bestBerry}. Remaining: {berries.Count}.", LogLevel.Info);
await RandomHelper.RandomDelay(50, 200);
}
caughtPokemonResponse = await _client.CatchPokemon(pokemon.EncounterId, pokemon.SpawnpointId, pokemon.Latitude, pokemon.Longitude, bestPokeball);
}while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed || caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
foreach (int xp in caughtPokemonResponse.Scores.Xp)
{
_botStats.addExperience(xp);
}
Logger.ColoredConsoleWrite(ConsoleColor.Magenta, $"We caught a {StringUtils.getPokemonNameByLanguage(_clientSettings, pokemon.PokemonId)} with CP {encounterPokemonResponse?.WildPokemon?.PokemonData?.Cp} ({PokemonInfo.CalculatePokemonPerfection(encounterPokemonResponse?.WildPokemon.PokemonData)}% perfect) using a {bestPokeball} and we got {caughtPokemonResponse.Scores.Xp.Sum()} XP.");
//try
//{
// var r = (HttpWebRequest)WebRequest.Create("http://pokemon.becher.xyz/index.php?pokeName=" + pokemon.PokemonId);
// var rp = (HttpWebResponse)r.GetResponse();
// var rps = new StreamReader(rp.GetResponseStream()).ReadToEnd();
// Logger.ColoredConsoleWrite(ConsoleColor.Magenta, $"We caught a {pokemon.PokemonId} ({rps}) with CP {encounterPokemonResponse?.WildPokemon?.PokemonData?.Cp} using a {bestPokeball}");
//} catch (Exception)
//{
// Logger.ColoredConsoleWrite(ConsoleColor.Magenta, $"We caught a {pokemon.PokemonId} (Language Server Offline) with CP {encounterPokemonResponse?.WildPokemon?.PokemonData?.Cp} using a {bestPokeball}");
//}
_botStats.addPokemon(1);
}
else
{
Logger.ColoredConsoleWrite(ConsoleColor.DarkYellow, $"{StringUtils.getPokemonNameByLanguage(_clientSettings, pokemon.PokemonId)} with CP {encounterPokemonResponse?.WildPokemon?.PokemonData?.Cp} ({PokemonInfo.CalculatePokemonPerfection(encounterPokemonResponse?.WildPokemon.PokemonData)} % perfect) got away while using a {bestPokeball}..");
failed_softban++;
}
}
else
{
Logger.ColoredConsoleWrite(ConsoleColor.Red, $"Error Catching Pokemon: {encounterPokemonResponse?.Status}");
}
await RandomHelper.RandomDelay(50, 200);
}
}
private async Task EvolveAllPokemonWithEnoughCandy(IEnumerable <PokemonId> filter = null)
{
var pokemonToEvolve = await _inventory.GetPokemonToEvolve(filter);
if (pokemonToEvolve.Count() != 0)
{
if (_clientSettings.UseLuckyEgg)
{
await UseLuckyEgg(_client);
}
}
foreach (var pokemon in pokemonToEvolve)
{
if (!_clientSettings.pokemonsToEvolve.Contains(pokemon.PokemonId))
{
continue;
}
count++;
if (count == 6)
{
count = 0;
await StatsLog(_client);
}
var evolvePokemonOutProto = await _client.EvolvePokemon((ulong)pokemon.Id);
if (evolvePokemonOutProto.Result == EvolvePokemonOut.Types.EvolvePokemonStatus.PokemonEvolvedSuccess)
{
Logger.ColoredConsoleWrite(ConsoleColor.Green, $"Evolved {StringUtils.getPokemonNameByLanguage(_clientSettings,pokemon.PokemonId)} with {pokemon.Cp} CP ({PokemonInfo.CalculatePokemonPerfection(pokemon)} % perfect) successfully to {StringUtils.getPokemonNameByLanguage(_clientSettings, evolvePokemonOutProto.EvolvedPokemon.PokemonType)} with {evolvePokemonOutProto.EvolvedPokemon.Cp} CP ({PokemonInfo.CalculatePokemonPerfection(evolvePokemonOutProto.EvolvedPokemon)} % perfect) for {evolvePokemonOutProto.ExpAwarded}xp", LogLevel.Info);
_botStats.addExperience(evolvePokemonOutProto.ExpAwarded);
}
else
{
Logger.ColoredConsoleWrite(ConsoleColor.Red, $"Failed to evolve {pokemon.PokemonId}. EvolvePokemonOutProto.Result was {evolvePokemonOutProto.Result}, stopping evolving {pokemon.PokemonId}", LogLevel.Info);
}
await RandomHelper.RandomDelay(1000, 2000);
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var duplicatePokemons =
await
session.Inventory.GetDuplicatePokemonToTransfer(session.LogicSettings.KeepPokemonsThatCanEvolve,
session.LogicSettings.PrioritizeIvOverCp,
session.LogicSettings.PokemonsNotToTransfer);
var pokemonSettings = await session.Inventory.GetPokemonSettings();
var pokemonFamilies = await session.Inventory.GetPokemonFamilies();
foreach (var duplicatePokemon in duplicatePokemons)
{
cancellationToken.ThrowIfCancellationRequested();
var pokemonTransferFilter = session.Inventory.GetPokemonTransferFilter(duplicatePokemon.PokemonId);
if (pokemonTransferFilter != null && session.LogicSettings.KeepMinOperator.ToLower().Equals("and"))
{
if ((duplicatePokemon.Cp >= pokemonTransferFilter.KeepMinCp &&
PokemonInfo.CalculatePokemonPerfection(duplicatePokemon) >= pokemonTransferFilter.KeepMinIvPercentage) ||
pokemonTransferFilter.Moves.Contains(duplicatePokemon.Move1) ||
pokemonTransferFilter.Moves.Contains(duplicatePokemon.Move2))
{
continue;
}
}
else if (pokemonTransferFilter != null)
{
if (duplicatePokemon.Cp >= pokemonTransferFilter.KeepMinCp ||
PokemonInfo.CalculatePokemonPerfection(duplicatePokemon) >
pokemonTransferFilter.KeepMinIvPercentage ||
pokemonTransferFilter.Moves.Contains(duplicatePokemon.Move1) ||
pokemonTransferFilter.Moves.Contains(duplicatePokemon.Move2))
{
continue;
}
}
await session.Client.Inventory.TransferPokemon(duplicatePokemon.Id);
await session.Inventory.DeletePokemonFromInvById(duplicatePokemon.Id);
var bestPokemonOfType = (session.LogicSettings.PrioritizeIvOverCp
? await session.Inventory.GetHighestPokemonOfTypeByIv(duplicatePokemon)
: await session.Inventory.GetHighestPokemonOfTypeByCp(duplicatePokemon)) ?? duplicatePokemon;
var setting = pokemonSettings.Single(q => q.PokemonId == duplicatePokemon.PokemonId);
var family = pokemonFamilies.First(q => q.FamilyId == setting.FamilyId);
family.Candy_++;
session.EventDispatcher.Send(new TransferPokemonEvent
{
Id = duplicatePokemon.PokemonId,
Perfection = PokemonInfo.CalculatePokemonPerfection(duplicatePokemon),
Cp = duplicatePokemon.Cp,
BestCp = bestPokemonOfType.Cp,
BestPerfection = PokemonInfo.CalculatePokemonPerfection(bestPokemonOfType),
FamilyCandies = family.Candy_
});
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 0);
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken, ulong pokemonId = 0)
{
PokemonData newBuddy = null;
if (pokemonId == 0)
{
if (string.IsNullOrEmpty(session.LogicSettings.DefaultBuddyPokemon))
{
return;
}
PokemonId buddyPokemonId;
bool success = Enum.TryParse(session.LogicSettings.DefaultBuddyPokemon, out buddyPokemonId);
if (!success)
{
// Invalid buddy pokemon type
Logger.Write($"The DefaultBuddyPokemon ({session.LogicSettings.DefaultBuddyPokemon}) is not a valid pokemon.", LogLevel.Error);
return;
}
if (session.Profile.PlayerData.BuddyPokemon?.Id > 0)
{
var currentBuddy = (await session.Inventory.GetPokemons().ConfigureAwait(false)).FirstOrDefault(x => x.Id == session.Profile.PlayerData.BuddyPokemon.Id);
if (currentBuddy.PokemonId == buddyPokemonId)
{
//dont change same buddy
return;
}
}
var buddy = (await session.Inventory.GetPokemons().ConfigureAwait(false)).Where(x => x.PokemonId == buddyPokemonId)
.OrderByDescending(x => PokemonInfo.CalculateCp(x));
if (session.LogicSettings.PrioritizeIvOverCp)
{
buddy = buddy.OrderByDescending(x => PokemonInfo.CalculatePokemonPerfection(x));
}
newBuddy = buddy.FirstOrDefault();
if (newBuddy == null)
{
Logger.Write($"You don't have the pokemon {session.LogicSettings.DefaultBuddyPokemon} to set as your buddy");
return;
}
}
if (newBuddy == null)
{
newBuddy = (await session.Inventory.GetPokemons().ConfigureAwait(false)).FirstOrDefault(x => x.Id == pokemonId);
}
if (newBuddy == null)
{
return;
}
var response = await session.Client.Player.SelectBuddy(newBuddy.Id).ConfigureAwait(false);
if (response.Result == SetBuddyPokemonResponse.Types.Result.Success)
{
session.EventDispatcher.Send(new BuddyUpdateEvent(response.UpdatedBuddy, newBuddy));
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken, dynamic encounter, MapPokemon pokemon,
FortData currentFortData = null, ulong encounterId = 0)
{
cancellationToken.ThrowIfCancellationRequested();
// If the encounter is null nothing will work below, so exit now
if (encounter == null)
{
return;
}
float probability = encounter?.CaptureProbability?.CaptureProbability_[0];
// Check for pokeballs before proceeding
var pokeball = await GetBestBall(session, encounter, probability);
if (pokeball == ItemId.ItemUnknown)
{
return;
}
//Calculate CP and IV
var pokemonCp = (encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.Cp
: encounter.PokemonData?.Cp);
var pokemonIv = PokemonInfo.CalculatePokemonPerfection(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData);
// Determine whether to use berries or not
if ((session.LogicSettings.UseBerriesOperator.ToLower().Equals("and") &&
pokemonIv >= session.LogicSettings.UseBerriesMinIv &&
pokemonCp >= session.LogicSettings.UseBerriesMinCp &&
probability < session.LogicSettings.UseBerriesBelowCatchProbability) ||
(session.LogicSettings.UseBerriesOperator.ToLower().Equals("or") && (
pokemonIv >= session.LogicSettings.UseBerriesMinIv ||
pokemonCp >= session.LogicSettings.UseBerriesMinCp ||
probability < session.LogicSettings.UseBerriesBelowCatchProbability)))
{
await
UseBerry(session,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.EncounterId
: encounterId,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.SpawnPointId
: currentFortData?.Id);
}
// Calculate distance away
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Latitude
: currentFortData.Latitude,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Longitude
: currentFortData.Longitude);
CatchPokemonResponse caughtPokemonResponse;
var attemptCounter = 1;
do
{
if ((session.LogicSettings.MaxPokeballsPerPokemon > 0 &&
attemptCounter > session.LogicSettings.MaxPokeballsPerPokemon))
{
break;
}
pokeball = await GetBestBall(session, encounter, probability, true);
if (pokeball == ItemId.ItemUnknown)
{
session.EventDispatcher.Send(new NoPokeballEvent
{
Id = encounter is EncounterResponse ? pokemon.PokemonId : encounter?.PokemonData.PokemonId,
Cp =
(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.Cp
: encounter?.PokemonData?.Cp) ?? 0
});
return;
}
caughtPokemonResponse =
await session.Client.Encounter.CatchPokemon(
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.EncounterId
: encounterId,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.SpawnPointId
: currentFortData.Id, pokeball);
var lat = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Latitude : currentFortData.Latitude;
var lng = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Longitude : currentFortData.Longitude;
var evt = new PokemonCaptureEvent()
{
Status = caughtPokemonResponse.Status,
Latitude = lat,
Longitude = lng
};
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
var totalExp = 0;
foreach (var xp in caughtPokemonResponse.CaptureAward.Xp)
{
totalExp += xp;
}
var profile = await session.Client.Player.GetPlayer();
evt.Exp = totalExp;
evt.Stardust = profile.PlayerData.Currencies.ToArray()[1].Amount;
var pokemonSettings = await session.Inventory.GetPokemonSettings();
var pokemonFamilies = await session.Inventory.GetPokemonFamilies();
var setting =
pokemonSettings.FirstOrDefault(q => pokemon != null && q.PokemonId == pokemon.PokemonId);
var family = pokemonFamilies.FirstOrDefault(q => setting != null && q.FamilyId == setting.FamilyId);
if (family != null)
{
family.Candy_ += caughtPokemonResponse.CaptureAward.Candy.Sum();
evt.FamilyCandies = family.Candy_;
}
else
{
evt.FamilyCandies = caughtPokemonResponse.CaptureAward.Candy.Sum();
}
if (session.LogicSettings.TransferDuplicatePokemonOnCapture && session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
}
evt.CatchType = encounter is EncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeNormal)
: encounter is DiskEncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeLure)
: session.Translation.GetTranslation(TranslationString.CatchTypeIncense);
evt.Id = encounter is EncounterResponse ? pokemon.PokemonId : encounter?.PokemonData.PokemonId;
evt.Level =
PokemonInfo.GetLevel(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData);
evt.Cp = encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.Cp
: encounter?.PokemonData?.Cp ?? 0;
evt.MaxCp =
PokemonInfo.CalculateMaxCp(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData);
evt.Perfection =
Math.Round(
PokemonInfo.CalculatePokemonPerfection(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData));
evt.Probability =
Math.Round(probability * 100, 2);
evt.Distance = distance;
evt.Pokeball = pokeball;
evt.Attempt = attemptCounter;
await session.Inventory.RefreshCachedInventory();
evt.BallAmount = await session.Inventory.GetItemAmountByType(pokeball);
session.EventDispatcher.Send(evt);
attemptCounter++;
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPokemonCatch, 2000);
} while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed ||
caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
}
private void btnEvolve_Click(object sender, EventArgs e)
{
EnabledButton(false, "Evolving...");
var selectedItems = PokemonListView.SelectedItems;
int evolved = 0;
int total = selectedItems.Count;
string failed = string.Empty;
var date = DateTime.Now.ToString();
string logPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs");
string evolvelog = System.IO.Path.Combine(logPath, "EvolveLog.txt");
int gotXP = 0;
//var resp = new taskResponse(false, string.Empty);
EvolvePokemonResponse resp = new EvolvePokemonResponse();
if (GlobalVars.pauseAtEvolve2)
{
Logger.ColoredConsoleWrite(ConsoleColor.Green, $"Taking a break to evolve some pokemons!");
GlobalVars.PauseTheWalking = true;
}
foreach (ListViewItem selectedItem in selectedItems)
{
var pokemoninfo = (PokemonData)selectedItem.Tag;
resp = client.Inventory.EvolvePokemon(pokemoninfo.Id);
var name = pokemoninfo.PokemonId;
var getPokemonName = StringUtils.getPokemonNameByLanguage(pokemoninfo.PokemonId);
var cp = pokemoninfo.Cp;
var calcPerf = PokemonInfo.CalculatePokemonPerfection(pokemoninfo).ToString("0.00");
var getEvolvedName = StringUtils.getPokemonNameByLanguage(resp.EvolvedPokemonData.PokemonId);
var getEvolvedCP = resp.EvolvedPokemonData.Cp;
gotXP = gotXP + resp.ExperienceAwarded;
var xpreward = resp.ExperienceAwarded.ToString("N0");
Logger.Info($"Evolved Pokemon: {getPokemonName} | CP {cp} | Perfection {calcPerf}% | => to {getEvolvedName} | CP: {getEvolvedCP} | XP Reward: {xpreward} XP");
if (resp.Result == EvolvePokemonResponse.Types.Result.Success)
{
evolved++;
statusTexbox.Text = "Evolving..." + evolved;
}
else
{
Logger.ColoredConsoleWrite(ConsoleColor.Red, $"Failed to evolve {pokemoninfo.PokemonId}. EvolvePokemonOutProto.Result was {resp.Result}");
failed += " {pokemoninfo.PokemonId} ";
}
if (GlobalVars.UseAnimationTimes)
{
Helpers.RandomHelper.RandomSleep(30000, 35000);
}
}
PokemonListView.Refresh();
if (failed != string.Empty)
{
if (BotSettings.LogEvolve)
{
File.AppendAllText(evolvelog, $"[{date}] - MANUAL - Sucessfully evolved {evolved}/{total} Pokemons. Failed: {failed}" + Environment.NewLine);
}
MessageBox.Show(th.TS("Succesfully evolved {0}/{1} Pokemons. Failed: {2}", evolved, total, failed), th.TS("Evolve status"), MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
if (BotSettings.LogEvolve)
{
File.AppendAllText(evolvelog, $"[{date}] - MANUAL - Sucessfully evolved {evolved}/{total} Pokemons." + Environment.NewLine);
}
MessageBox.Show(th.TS("Succesfully evolved {0}/{1} Pokemons.", evolved, total), th.TS("Evolve status"), MessageBoxButtons.OK, MessageBoxIcon.Information);
}
var gotxpno = gotXP.ToString("N0");
Logger.Info($"Evolved {evolved} Pokemons. We have got {gotxpno} XP.");
if (evolved > 0)
{
Execute();
}
else
{
EnabledButton(true);
}
if (GlobalVars.pauseAtEvolve)
{
Logger.ColoredConsoleWrite(ConsoleColor.Green, $"Evolved everything. Time to continue our journey!");
GlobalVars.PauseTheWalking = false;
}
}
public async Task <IEnumerable <PokemonData> > GetPokemonToEvolve(IEnumerable <PokemonId> filter = null)
{
var myPokemon = await GetPokemons();
myPokemon = myPokemon.Where(p => p.DeployedFortId == string.Empty).OrderByDescending(p => p.Cp);
//Don't evolve pokemon in gyms
IEnumerable <PokemonId> pokemonIds = filter as PokemonId[] ?? filter.ToArray();
if (pokemonIds.Any())
{
myPokemon =
myPokemon.Where(
p => (pokemonIds.Contains(p.PokemonId)) ||
(_logicSettings.EvolveAllPokemonAboveIv &&
(PokemonInfo.CalculatePokemonPerfection(p) >= _logicSettings.EvolveAboveIvValue)));
}
else if (_logicSettings.EvolveAllPokemonAboveIv)
{
myPokemon =
myPokemon.Where(
p => PokemonInfo.CalculatePokemonPerfection(p) >= _logicSettings.EvolveAboveIvValue);
}
var pokemons = myPokemon.ToList();
var myPokemonSettings = await GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
var pokemonToEvolve = new List <PokemonData>();
foreach (var pokemon in pokemons)
{
var settings = pokemonSettings.SingleOrDefault(x => x.PokemonId == pokemon.PokemonId);
var familyCandy = pokemonFamilies.SingleOrDefault(x => settings.FamilyId == x.FamilyId);
//Don't evolve if we can't evolve it
if (settings.EvolutionIds.Count == 0)
{
continue;
}
//DO NOT CHANGE! TESTED AND WORKS
//TRUONG: temporary change 1 to 2 to fix not enought resource when evolve. not a big deal when we keep few candy
var pokemonCandyNeededAlready =
(pokemonToEvolve.Count(
p => pokemonSettings.FirstOrDefault(x => x.PokemonId == p.PokemonId) != null &&
pokemonSettings.FirstOrDefault(x => x.PokemonId == p.PokemonId).FamilyId == settings.FamilyId) + 2) *
settings.CandyToEvolve;
if (familyCandy.Candy_ >= pokemonCandyNeededAlready)
{
pokemonToEvolve.Add(pokemon);
}
}
return(pokemonToEvolve);
}
private void transferSelectedPokemons()
{
try {
EnabledButton(false, th.TS("Transfering..."));
var selectedItems = PokemonListView.SelectedItems;
int transfered = 0;
int total = selectedItems.Count;
string failed = string.Empty;
string logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs");
string logs = Path.Combine(logPath, "TransferLog.txt");
string date = DateTime.Now.ToString();
if (GlobalVars.pauseAtEvolve2) // stop walking
{
Logger.Info("Taking a short break to transfer some pokemons!");
GlobalVars.PauseTheWalking = true;
}
DialogResult dialogResult = MessageBox.Show(th.TS("You're going to transfer pokemons. This can not be reversed."), th.TS("Are you Sure?"), MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
var pokemonsToTransfer = new List <ulong>();
foreach (ListViewItem selectedItem in selectedItems)
{
var pokemon = (PokemonData)selectedItem.Tag;
var strPokename = th.TS(pokemon.PokemonId.ToString());
if (pokemon.DeployedFortId == "" && pokemon.Favorite == 0)
{
if (profile != null && profile.PlayerData.BuddyPokemon != null)
{
if (pokemon.Id == profile.PlayerData.BuddyPokemon.Id)
{
continue;
}
}
pokemonsToTransfer.Add(pokemon.Id);
transfered++;
File.AppendAllText(logs, $"[{date}] - MANUAL - Enqueuing to BULK transfer pokemon {transfered}/{total}: {Logic.Utils.StringUtils.getPokemonNameByLanguage(BotSettings, pokemon.PokemonId)}" + Environment.NewLine);
var strPerfection = PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00");
var strTransfer = $"Enqueuing to BULK transfer pokemon {transfered}/{total}: {strPokename} CP {pokemon.Cp} IV {strPerfection}";
Logger.ColoredConsoleWrite(ConsoleColor.Yellow, strTransfer, LogLevel.Info);
PokemonListView.Items.Remove(selectedItem);
}
else
{
if (pokemon.DeployedFortId != "")
{
Logger.ColoredConsoleWrite(ConsoleColor.Gray, $"Impossible to transfer {strPokename} because it is deployed in a Gym.");
}
if (pokemon.Favorite == 1)
{
Logger.ColoredConsoleWrite(ConsoleColor.Gray, $"Impossible to transfer {strPokename} because it is a favourite pokemon.");
}
if (pokemon.Id == profile.PlayerData.BuddyPokemon.Id)
{
Logger.ColoredConsoleWrite(ConsoleColor.Gray, $"Impossible to transfer {strPokename} because it is your Buddy.");
}
total--;
}
}
if (pokemonsToTransfer.Any())
{
var _response = client.Inventory.TransferPokemon(pokemonsToTransfer);
if (_response.Result == ReleasePokemonResponse.Types.Result.Success)
{
if (BotSettings.LogTransfer)
{
File.AppendAllText(logs, $"[{date}] - MANUAL - Sucessfully Bulk transfered {transfered}/{total} Pokemons. Failed: {failed}" + Environment.NewLine);
}
Logger.ColoredConsoleWrite(ConsoleColor.Yellow, $"Transfer Successful of {transfered}/{total} pokemons => {_response.CandyAwarded.ToString()} candy/ies awarded.");
statusTexbox.Text = $"Succesfully Bulk transfered {total} Pokemons.";
Helpers.RandomHelper.RandomSleep(1000, 2000);
}
else
{
Logger.Error("Something happened while transferring pokemons.");
}
RefreshTitle();
client.Inventory.GetInventory(true); // force refresh inventory
}
if (GlobalVars.pauseAtEvolve)
{
Logger.Info("Transferred everything. Time to continue our journey!");
GlobalVars.PauseTheWalking = false;
}
}
EnabledButton(true);
} catch (Exception ex1) {
Logger.ExceptionInfo(ex1.ToString());
}
}
public async Task <List <PokemonData> > GetPokemonToUpgrade()
{
var upgradePokemon = new List <PokemonData>();
if (!_logicSettings.AutomaticallyLevelUpPokemon)
{
return(upgradePokemon);
}
var myPokemon = await GetPokemons();
myPokemon = myPokemon.Where(p => p.DeployedFortId == string.Empty);
var grouped = myPokemon.GroupBy(p => p.PokemonId);
Parallel.ForEach(grouped, (group) =>
{
var appliedFilter = _logicSettings.PokemonUpgradeFilters.ContainsKey(group.Key)
? _logicSettings.PokemonUpgradeFilters[group.Key]
: new UpgradeFilter(_logicSettings.LevelUpByCPorIv, _logicSettings.UpgradePokemonCpMinimum,
_logicSettings.UpgradePokemonIvMinimum, _logicSettings.UpgradePokemonMinimumStatsOperator,
_logicSettings.OnlyUpgradeFavorites);
IEnumerable <PokemonData> highestPokemonForUpgrade =
(appliedFilter.UpgradePokemonMinimumStatsOperator.ToLower().Equals("and"))
? group.Where(
p => (p.Cp >= appliedFilter.UpgradePokemonCpMinimum &&
PokemonInfo.CalculatePokemonPerfection(p) >=
appliedFilter.UpgradePokemonIvMinimum))
.OrderByDescending(p => p.Cp)
.ToList()
: group.Where(
p => (p.Cp >= appliedFilter.UpgradePokemonCpMinimum ||
PokemonInfo.CalculatePokemonPerfection(p) >=
appliedFilter.UpgradePokemonIvMinimum))
.OrderByDescending(p => p.Cp)
.ToList();
if (appliedFilter.OnlyUpgradeFavorites)
{
highestPokemonForUpgrade = highestPokemonForUpgrade.Where(i => i.Favorite == 1);
}
var upgradeableList = (appliedFilter.LevelUpByCPorIv.ToLower().Equals("iv"))
? highestPokemonForUpgrade.OrderByDescending(PokemonInfo.CalculatePokemonPerfection).ToList()
: highestPokemonForUpgrade.OrderByDescending(p => p.Cp).ToList();
lock (upgradePokemon)
{
upgradePokemon.AddRange(upgradeableList);
}
});
return(upgradePokemon);
//IEnumerable<PokemonData> highestPokemonForUpgrade = (_logicSettings.UpgradePokemonMinimumStatsOperator.ToLower().Equals("and")) ?
// myPokemon.Where(
// p => (p.Cp >= _logicSettings.UpgradePokemonCpMinimum &&
// PokemonInfo.CalculatePokemonPerfection(p) >= _logicSettings.UpgradePokemonIvMinimum)).OrderByDescending(p => p.Cp).ToList() :
// myPokemon.Where(
// p => (p.Cp >= _logicSettings.UpgradePokemonCpMinimum ||
// PokemonInfo.CalculatePokemonPerfection(p) >= _logicSettings.UpgradePokemonIvMinimum)).OrderByDescending(p => p.Cp).ToList();
//return upgradePokemon = (_logicSettings.LevelUpByCPorIv.ToLower().Equals("iv")) ?
// highestPokemonForUpgrade.OrderByDescending(PokemonInfo.CalculatePokemonPerfection).ToList() :
// highestPokemonForUpgrade.OrderByDescending(p => p.Cp).ToList();
}
public static async Task Execute(ISession session)
{
var myPokemonFamilies = await session.Inventory.GetPokemonFamilies();
var myPokeSettings = await session.Inventory.GetPokemonSettings();
var highestsPokemonCp =
await session.Inventory.GetHighestsCp(session.LogicSettings.AmountOfPokemonToDisplayOnStart);
var pokemonPairedWithStatsCp =
highestsPokemonCp.Select(
pokemon =>
Tuple.Create(
pokemon,
PokemonInfo.CalculateMaxCp(pokemon),
PokemonInfo.CalculatePokemonPerfection(pokemon),
PokemonInfo.GetLevel(pokemon),
PokemonInfo.GetPokemonMove1(pokemon),
PokemonInfo.GetPokemonMove2(pokemon),
PokemonInfo.GetCandy(pokemon, myPokemonFamilies, myPokeSettings)
)
)
.ToList();
var highestsPokemonPerfect =
await session.Inventory.GetHighestsPerfect(session.LogicSettings.AmountOfPokemonToDisplayOnStart);
var pokemonPairedWithStatsIv =
highestsPokemonPerfect.Select(
pokemon =>
Tuple.Create(
pokemon,
PokemonInfo.CalculateMaxCp(pokemon),
PokemonInfo.CalculatePokemonPerfection(pokemon),
PokemonInfo.GetLevel(pokemon),
PokemonInfo.GetPokemonMove1(pokemon),
PokemonInfo.GetPokemonMove2(pokemon),
PokemonInfo.GetCandy(pokemon, myPokemonFamilies, myPokeSettings)
)
)
.ToList();
session.EventDispatcher.Send(
new DisplayHighestsPokemonEvent
{
SortedBy = "CP",
PokemonList = pokemonPairedWithStatsCp
});
session.EventDispatcher.Send(
new DisplayHighestsPokemonEvent
{
SortedBy = "IV",
PokemonList = pokemonPairedWithStatsIv
});
var allPokemonInBag = session.LogicSettings.PrioritizeIvOverCp
? await session.Inventory.GetHighestsPerfect(1000)
: await session.Inventory.GetHighestsCp(1000);
if (session.LogicSettings.DumpPokemonStats)
{
const string dumpFileName = "PokeBagStats";
try
{
Dumper.ClearDumpFile(session, dumpFileName);
string[] data =
{
"pokemonid",
"pokemonlevel",
"cp",
"perfection",
"stamina",
"staminamax",
"move1",
"move2",
"candy",
"ownername",
"origin",
"heightm",
"weightkg",
"individualattack",
"individualdefense",
"individualstamina",
"cpmultiplier",
"battlesattacked",
"battlesdefended",
"creationtimems",
"numupgrades",
"additionalcpmultiplier",
"favorite",
"nickname"
};
Dumper.Dump(session, data, dumpFileName);
// set culture to OS default
CultureInfo prevCulture = Thread.CurrentThread.CurrentCulture;
CultureInfo culture = CultureInfo.CurrentUICulture;
Thread.CurrentThread.CurrentCulture = culture;
foreach (var pokemon in allPokemonInBag)
{
string[] pokemonData =
{
session.Translation.GetPokemonTranslation(pokemon.PokemonId),
PokemonInfo.GetLevel(pokemon).ToString(),
pokemon.Cp.ToString(),
PokemonInfo.CalculatePokemonPerfection(pokemon).ToString(),
pokemon.Stamina.ToString(),
pokemon.StaminaMax.ToString(),
pokemon.Move1.ToString(),
pokemon.Move2.ToString(),
PokemonInfo.GetCandy(pokemon, myPokemonFamilies,myPokeSettings).ToString(),
pokemon.OwnerName,
pokemon.Origin.ToString(),
pokemon.HeightM.ToString(),
pokemon.WeightKg.ToString(),
pokemon.IndividualAttack.ToString(),
pokemon.IndividualDefense.ToString(),
pokemon.IndividualStamina.ToString(),
pokemon.CpMultiplier.ToString(),
pokemon.BattlesAttacked.ToString(),
pokemon.BattlesDefended.ToString(),
pokemon.CreationTimeMs.ToString(),
pokemon.NumUpgrades.ToString(),
pokemon.AdditionalCpMultiplier.ToString(),
pokemon.Favorite.ToString(),
pokemon.Nickname
};
Dumper.Dump(session, pokemonData, dumpFileName);
}
// restore culture
Thread.CurrentThread.CurrentCulture = prevCulture;
}
catch (IOException)
{
session.EventDispatcher.Send(
new ErrorEvent {
Message = $"Could not write {dumpFileName} dump file."
}
);
}
}
}
public async Task ExportPokemonToCSV(PlayerData player, string filename = "PokemonList.csv")
{
if (player == null)
{
return;
}
var stats = await GetPlayerStats();
var stat = stats.FirstOrDefault();
if (stat == null)
{
return;
}
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs");
if (Directory.Exists(path))
{
try
{
string pokelist_file = Path.Combine(path, $"Profile_{player.Username}_{filename}");
if (File.Exists(pokelist_file))
{
File.Delete(pokelist_file);
}
string ls = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ListSeparator;
string header = "PokemonID,Name,NickName,CP / MaxCP,IV Perfection in %,Attack 1,Attack 2,HP,Attk,Def,Stamina,Familie Candies,IsInGym,IsFavorite,previewLink";
File.WriteAllText(pokelist_file, $"{header.Replace(",", $"{ls}")}");
var AllPokemon = await GetHighestsPerfect();
var myPokemonSettings = await GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
int trainerLevel = stat.Level;
int[] exp_req = new[] { 0, 1000, 3000, 6000, 10000, 15000, 21000, 28000, 36000, 45000, 55000, 65000, 75000, 85000, 100000, 120000, 140000, 160000, 185000, 210000, 260000, 335000, 435000, 560000, 710000, 900000, 1100000, 1350000, 1650000, 2000000, 2500000, 3000000, 3750000, 4750000, 6000000, 7500000, 9500000, 12000000, 15000000, 20000000 };
int exp_req_at_level = exp_req[stat.Level - 1];
using (var w = File.AppendText(pokelist_file))
{
w.WriteLine("");
foreach (var pokemon in AllPokemon)
{
string toEncode = $"{(int)pokemon.PokemonId}" + "," + trainerLevel + "," + PokemonInfo.GetLevel(pokemon) + "," + pokemon.Cp + "," + pokemon.Stamina;
//Generate base64 code to make it viewable here http://poke.isitin.org/#MTUwLDIzLDE3LDE5MDIsMTE4
var encoded = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(toEncode));
string IsInGym = string.Empty;
string IsFavorite = string.Empty;
if (pokemon.Favorite != 0)
{
IsFavorite = "Yes";
}
else
{
IsFavorite = "No";
}
var settings = pokemonSettings.SingleOrDefault(x => x.PokemonId == pokemon.PokemonId);
var familiecandies = pokemonFamilies.SingleOrDefault(x => settings.FamilyId == x.FamilyId).Candy_;
string perfection = PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00");
perfection = perfection.Replace(",", ls == "," ? "." : ",");
string content_part1 = $"{(int)pokemon.PokemonId},{pokemon.PokemonId},{pokemon.Nickname},{pokemon.Cp}/{PokemonInfo.CalculateMaxCP(pokemon)},";
string content_part2 = $",{pokemon.Move1},{pokemon.Move2},{pokemon.Stamina},{pokemon.IndividualAttack},{pokemon.IndividualDefense},{pokemon.IndividualStamina},{familiecandies},{IsInGym},{IsFavorite},http://poke.isitin.org/#{encoded}";
string content = $"{content_part1.Replace(",", $"{ls}")}\"{perfection}\"{content_part2.Replace(",", $"{ls}")}";
w.WriteLine($"{content}");
}
w.Close();
}
Logger.ColoredConsoleWrite(ConsoleColor.Green, $"Export Player Infos and all Pokemon to \"\\Config\\{filename}\"", LogLevel.Info);
}
catch
{
Logger.Error("Export Player Infos and all Pokemons to CSV not possible. File seems be in use!" /*, LogLevel.Warning*/);
}
}
}
private async Task TransferPokemon()
{
await Inventory.GetCachedInventory(_client, true);
var pokemonToTransfer = await _inventory.GetPokemonToTransfer(_clientSettings.NotTransferPokemonsThatCanEvolve, _clientSettings.PrioritizeIVOverCP, _clientSettings.PokemonsToNotTransfer);
if (pokemonToTransfer != null && pokemonToTransfer.Any())
{
Logger.Write($"Found {pokemonToTransfer.Count()} Pokemon for Transfer:", LogLevel.Info);
}
foreach (var pokemon in pokemonToTransfer)
{
await _client.TransferPokemon(pokemon.Id);
await Inventory.GetCachedInventory(_client, true);
var myPokemonSettings = await _inventory.GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await _inventory.GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
var settings = pokemonSettings.Single(x => x.PokemonId == pokemon.PokemonId);
var familyCandy = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId);
var familyCandies = $"{familyCandy.Candy}";
_stats.IncreasePokemonsTransfered();
_stats.UpdateConsoleTitle(_client, _inventory);
var bestPokemonOfType = _client.Settings.PrioritizeIVOverCP
? await _inventory.GetHighestPokemonOfTypeByIv(pokemon)
: await _inventory.GetHighestPokemonOfTypeByCp(pokemon);
var bestPokemonInfo = "NONE";
if (bestPokemonOfType != null)
{
bestPokemonInfo = $"CP: {bestPokemonOfType.Cp}/{PokemonInfo.CalculateMaxCp(bestPokemonOfType)} | IV: {PokemonInfo.CalculatePokemonPerfection(bestPokemonOfType).ToString("0.00")}% perfect";
}
Logger.Write($"{pokemon.PokemonId} [CP {pokemon.Cp}/{PokemonInfo.CalculateMaxCp(pokemon)} | IV: { PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00")}% perfect] | Best: [{bestPokemonInfo}] | Family Candies: {familyCandies}", LogLevel.Transfer);
}
}
public static async Task Execute()
{
await Inventory.GetCachedInventory(true);
var pokemonToTransfer = await Inventory.GetPokemonToTransfer(Logic._clientSettings.NotTransferPokemonsThatCanEvolve, Logic._clientSettings.PrioritizeIVOverCP, Logic._clientSettings.PokemonToNotTransfer);
if (pokemonToTransfer == null || !pokemonToTransfer.Any())
{
return;
}
Logger.Write($"Found {pokemonToTransfer.Count()} Pokemon for Transfer:", LogLevel.Debug);
foreach (var pokemon in pokemonToTransfer)
{
await Logic._client.Inventory.TransferPokemon(pokemon.Id);
await Inventory.GetCachedInventory(true);
var myPokemonSettings = await Inventory.GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await Inventory.GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
var settings = pokemonSettings.Single(x => x.PokemonId == pokemon.PokemonId);
var familyCandy = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId);
var familyCandies = $"{familyCandy.Candy_}";
BotStats.PokemonTransferedThisSession += 1;
var bestPokemonOfType = Logic._client.Settings.PrioritizeIVOverCP
? await Inventory.GetHighestPokemonOfTypeByIv(pokemon)
: await Inventory.GetHighestPokemonOfTypeByCp(pokemon);
var bestPokemonInfo = "NONE";
if (bestPokemonOfType != null)
{
bestPokemonInfo = $"CP: {bestPokemonOfType.Cp}/{PokemonInfo.CalculateMaxCp(bestPokemonOfType)} | IV: {PokemonInfo.CalculatePokemonPerfection(bestPokemonOfType).ToString("0.00")}% perfect";
}
Logger.Write($"{pokemon.PokemonId} [CP: {pokemon.Cp}/{PokemonInfo.CalculateMaxCp(pokemon)} | IV: { PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00")}% perfect] | Best: [{bestPokemonInfo}] | Family Candies: {familyCandies}", LogLevel.Transfer);
}
await BotStats.GetPokemonCount();
BotStats.UpdateConsoleTitle();
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
TinyIoC.TinyIoCContainer.Current.Resolve <MultiAccountManager>().ThrowIfSwitchAccountRequested();
var pokemons = await session.Inventory.GetPokemons().ConfigureAwait(false);
if (session.LogicSettings.TransferDuplicatePokemon && session.LogicSettings.RenamePokemonRespectTransferRule)
{
var duplicatePokemons = await
session.Inventory.GetDuplicatePokemonToTransfer(
session.LogicSettings.PokemonsNotToTransfer,
session.LogicSettings.PokemonEvolveFilters,
session.LogicSettings.KeepPokemonsThatCanEvolve,
session.LogicSettings.PrioritizeIvOverCp).ConfigureAwait(false);
pokemons = pokemons.Where(x => !duplicatePokemons.Any(p => p.Id == x.Id));
}
if (session.LogicSettings.TransferWeakPokemon && session.LogicSettings.RenamePokemonRespectTransferRule)
{
var weakPokemons = await
session.Inventory.GetWeakPokemonToTransfer(
session.LogicSettings.PokemonsNotToTransfer,
session.LogicSettings.PokemonEvolveFilters,
session.LogicSettings.KeepPokemonsThatCanEvolve,
session.LogicSettings.PrioritizeIvOverCp).ConfigureAwait(false);
pokemons = pokemons.Where(x => !weakPokemons.Any(p => p.Id == x.Id));
}
foreach (var pokemon in pokemons)
{
cancellationToken.ThrowIfCancellationRequested();
TinyIoC.TinyIoCContainer.Current.Resolve <MultiAccountManager>().ThrowIfSwitchAccountRequested();
var perfection = Math.Round(PokemonInfo.CalculatePokemonPerfection(pokemon));
var level = PokemonInfo.GetLevel(pokemon);
var pokemonName = session.Translation.GetPokemonTranslation(pokemon.PokemonId);
var cp = PokemonInfo.CalculateCp(pokemon);
// iv number + templating part + pokemonName <= 12
var newNickname = session.LogicSettings.RenameTemplate.ToUpper();
newNickname = newNickname.Replace("{IV}", Math.Round(perfection, 0).ToString());
newNickname = newNickname.Replace("{LEVEL}", Math.Round(level, 0).ToString());
newNickname = newNickname.Replace("{CP}", cp.ToString());
var nameLength = 18 - newNickname.Length;
if (pokemonName.Length > nameLength && nameLength > 0)
{
pokemonName = pokemonName.Substring(0, nameLength);
}
newNickname = newNickname.Replace("{NAME}", pokemonName);
//verify
if (nameLength <= 0)
{
Logger.Write($"Your rename template : {session.LogicSettings.RenameTemplate} incorrect. : {pokemonName} / {newNickname}");
continue;
}
var oldNickname = pokemon.Nickname.Length != 0 ? pokemon.Nickname : pokemon.PokemonId.ToString();
// If "RenameOnlyAboveIv" = true only rename pokemon with IV over "KeepMinIvPercentage"
if ((!session.LogicSettings.RenameOnlyAboveIv ||
perfection >= session.LogicSettings.KeepMinIvPercentage) &&
newNickname != oldNickname)
{
var result = await session.Client.Inventory.NicknamePokemon(pokemon.Id, newNickname).ConfigureAwait(false);
if (result.Result == NicknamePokemonResponse.Types.Result.Success)
{
pokemon.Nickname = newNickname;
session.EventDispatcher.Send(new RenamePokemonEvent
{
Id = pokemon.Id,
PokemonId = pokemon.PokemonId,
OldNickname = oldNickname,
NewNickname = newNickname
});
}
//Delay only if the pokemon was really renamed!
await DelayingUtils.DelayAsync(session.LogicSettings.RenamePokemonActionDelay, 500, session.CancellationTokenSource.Token).ConfigureAwait(false);
}
}
}
public static async Task <bool> Execute(ISession session, dynamic encounter, PokemonCacheItem pokemon, CancellationToken cancellationToken,
FortData currentFortData = null, ulong encounterId = 0)
{
//if (!await CheckBotStateTask.Execute(session, cancellationToken)) return false;
if (encounter is EncounterResponse && pokemon == null)
{
throw new ArgumentException("Parameter pokemon must be set, if encounter is of type EncounterResponse",
nameof(pokemon));
}
var prevState = session.State;
session.State = BotState.Catch;
var canUseBerry = true;
CatchPokemonResponse caughtPokemonResponse;
var attemptCounter = 1;
do
{
if (session.LogicSettings.MaxPokeballsPerPokemon > 0 &&
attemptCounter > session.LogicSettings.MaxPokeballsPerPokemon)
{
break;
}
float probability = encounter?.CaptureProbability?.CaptureProbability_[0];
ItemId pokeball = await GetBestBall(session, encounter, probability);
if (pokeball == ItemId.ItemUnknown)
{
session.EventDispatcher.Send(new NoPokeballEvent
{
Id = encounter is EncounterResponse ? pokemon.PokemonId : encounter?.PokemonData.PokemonId,
Cp = (encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.Cp
: encounter?.PokemonData?.Cp) ?? 0
});
session.State = prevState;
return(false);
}
var useBerryBelowCatchProbability = session.LogicSettings.UseBerryBelowCatchProbability > 1
? session.LogicSettings.UseBerryBelowCatchProbability / 100
: session.LogicSettings.UseBerryBelowCatchProbability;
var isLowProbability = probability < useBerryBelowCatchProbability;
var isHighCp = encounter != null &&
(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.Cp
: encounter.PokemonData?.Cp) > session.LogicSettings.UseBerryMinCp;
var isHighPerfection =
PokemonInfo.CalculatePokemonPerfection(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData) >= session.LogicSettings.UseBerryMinIv;
if (isLowProbability && ((session.LogicSettings.PrioritizeIvOverCp && isHighPerfection) || isHighCp) && canUseBerry)
{
await
UseBerry(session,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.EncounterId
: encounterId,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.SpawnPointId
: currentFortData?.Id);
canUseBerry = false;
await DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 1000);
}
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Latitude
: currentFortData.Latitude,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Longitude
: currentFortData.Longitude);
double normalizedRecticleSize, spinModifier;
if (session.LogicSettings.HumanizeThrows)
{
normalizedRecticleSize =
Rng.NextInRange(session.LogicSettings.ThrowAccuracyMin, session.LogicSettings.ThrowAccuracyMax) *
1.85 + 0.1; // 0.1..1.95
if (normalizedRecticleSize > 1.95)
{
normalizedRecticleSize = 1.95;
}
else if (normalizedRecticleSize < 0.1)
{
normalizedRecticleSize = 0.1;
}
spinModifier = Rng.NextDouble() > session.LogicSettings.ThrowSpinFrequency ? 0.0 : 1.0;
}
else
{
normalizedRecticleSize = 1.95;
spinModifier = 1.00;
}
Func <ItemId, string> returnRealBallName = a =>
{
switch (a)
{
case ItemId.ItemPokeBall:
return(session.Translation.GetTranslation(TranslationString.Pokeball));
case ItemId.ItemGreatBall:
return(session.Translation.GetTranslation(TranslationString.GreatPokeball));
case ItemId.ItemUltraBall:
return(session.Translation.GetTranslation(TranslationString.UltraPokeball));
case ItemId.ItemMasterBall:
return(session.Translation.GetTranslation(TranslationString.MasterPokeball));
default:
return(session.Translation.GetTranslation(TranslationString.CommonWordUnknown));
}
};
Func <double, string> getThrowType = a =>
{
if (a < 1.0)
{
return("Normal ");
}
if (a < 1.3)
{
return("Nice! ");
}
if (a < 1.7)
{
return("Great! ");
}
return(a > 1.6 ? "Excellent! " : "unknown ");
};
var hit = Rng.NextDouble() > session.LogicSettings.MissChance;
Logger.Write($"Throwing {(Math.Abs(spinModifier - 1) < 0.00001 ?"Spinning " : "" )}{getThrowType(normalizedRecticleSize)}{returnRealBallName(pokeball)} - {(hit ? "WILL HIT" : "WILL MISS")}", Logging.LogLevel.Caught, session: session);
caughtPokemonResponse =
await session.Client.Encounter.CatchPokemon(
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.EncounterId
: encounterId,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.SpawnPointId
: currentFortData.Id, pokeball,
normalizedRecticleSize,
spinModifier, hitPokemon : hit);
session.EventDispatcher.Send(new ItemLostEvent {
Id = pokeball, Count = 1
});
var lat = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Latitude
: currentFortData.Latitude;
var lng = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Longitude
: currentFortData.Longitude;
var evt = new PokemonCaptureEvent
{
Status = caughtPokemonResponse.Status,
Latitude = lat,
Longitude = lng
};
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
if (pokemon != null)
{
pokemon.Caught = true;
}
evt.Uid = caughtPokemonResponse.CapturedPokemonId;
var totalExp = caughtPokemonResponse.CaptureAward.Xp.Sum();
var profile = await session.Client.Player.GetPlayer();
evt.Exp = totalExp;
evt.Stardust = profile.PlayerData.Currencies.ToArray()[1].Amount;
var pokemonSettings = await session.Inventory.GetPokemonSettings();
var pokemonFamilies = await session.Inventory.GetPokemonFamilies();
var setting =
pokemonSettings.FirstOrDefault(q => q.PokemonId == pokemon?.PokemonId);
var family = pokemonFamilies.FirstOrDefault(q => setting != null && q.FamilyId == setting.FamilyId);
if (family != null)
{
family.Candy_ += caughtPokemonResponse.CaptureAward.Candy.Sum();
evt.Family = family.FamilyId;
evt.FamilyCandies = family.Candy_;
evt.Type1 = setting.Type;
evt.Type2 = setting.Type2;
evt.Stats = setting.Stats;
evt.CandyToEvolve = setting.CandyToEvolve;
PokemonData poke = encounter is EncounterResponse ? encounter.WildPokemon?.PokemonData : encounter?.PokemonData;
if (poke != null)
{
evt.Stamina = poke.Stamina;
evt.MaxStamina = poke.StaminaMax;
}
}
else
{
evt.FamilyCandies = caughtPokemonResponse.CaptureAward.Candy.Sum();
}
session.MapCache.PokemonCaught(pokemon);
Logger.Write($"[Catch Dump] Caught {pokemon.PokemonId} - Coords[Lat: {lat} - Lng: {lng}]");
}
else if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchFlee)
{
pokemon.Caught = true;
}
else if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape)
{
canUseBerry = true;
}
evt.CatchType = encounter is EncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeNormal)
: encounter is DiskEncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeLure)
: session.Translation.GetTranslation(TranslationString.CatchTypeIncense);
evt.Id = encounter is EncounterResponse ? pokemon.PokemonId : encounter?.PokemonData.PokemonId;
var pokeData = (encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData) as PokemonData;
if (pokeData != null)
{
evt.Level = PokemonInfo.GetLevel(pokeData);
evt.Cp = pokeData.Cp;
evt.MaxCp = (int)PokemonInfo.GetMaxCpAtTrainerLevel(pokeData, session.Runtime.CurrentLevel);
evt.Perfection = Math.Round(pokeData.CalculatePokemonPerfection(), 2);
evt.Probability =
Math.Round(probability * 100, 2);
evt.Move1 = pokeData.Move1;
evt.Move2 = pokeData.Move2;
evt.PossibleCp = (int)PokemonInfo.GetMaxCpAtTrainerLevel(pokeData, 40);
}
evt.Distance = distance;
evt.Pokeball = pokeball;
evt.Attempt = attemptCounter;
//await session.Inventory.RefreshCachedInventory();
evt.BallAmount = await session.Inventory.GetItemAmountByType(pokeball);
session.EventDispatcher.Send(evt);
attemptCounter++;
await Task.Delay(session.LogicSettings.DelayCatchPokemon, cancellationToken);
} while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed ||
caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
session.State = prevState;
return(true);
}
/// <summary>
/// Because this function sometime being called inside loop, return true it mean we don't want break look, false it mean not need to call this , break a loop from caller function
/// </summary>
/// <param name="session"></param>
/// <param name="cancellationToken"></param>
/// <param name="encounter"></param>
/// <param name="pokemon"></param>
/// <param name="currentFortData"></param>
/// <param name="sessionAllowTransfer"></param>
/// <returns></returns>
public static async Task <bool> Execute(ISession session,
CancellationToken cancellationToken,
dynamic encounter,
MapPokemon pokemon,
FortData currentFortData,
bool sessionAllowTransfer)
{
TinyIoC.TinyIoCContainer.Current.Resolve <MultiAccountManager>().ThrowIfSwitchAccountRequested();
// If the encounter is null nothing will work below, so exit now
if (encounter == null)
{
return(true);
}
// Exit if user defined max limits reached
if (session.Stats.CatchThresholdExceeds(session))
{
if (session.LogicSettings.AllowMultipleBot &&
session.LogicSettings.MultipleBotConfig.SwitchOnCatchLimit &&
TinyIoCContainer.Current.Resolve <MultiAccountManager>().AllowSwitch())
{
throw new ActiveSwitchByRuleException()
{
MatchedRule = SwitchRules.CatchLimitReached,
ReachedValue = session.LogicSettings.CatchPokemonLimit
};
}
return(false);
}
using (var block = new BlockableScope(session, BotActions.Catch))
{
if (!await block.WaitToRun())
{
return(true);
}
AmountOfBerries = new Dictionary <ItemId, int>();
cancellationToken.ThrowIfCancellationRequested();
float probability = encounter.CaptureProbability?.CaptureProbability_[0];
PokemonData encounteredPokemon;
long unixTimeStamp;
ulong _encounterId;
string _spawnPointId;
// Calling from CatchNearbyPokemonTask and SnipePokemonTask
if (encounter is EncounterResponse &&
(encounter?.Status == EncounterResponse.Types.Status.EncounterSuccess))
{
encounteredPokemon = encounter.WildPokemon?.PokemonData;
unixTimeStamp = encounter.WildPokemon?.LastModifiedTimestampMs
+ encounter.WildPokemon?.TimeTillHiddenMs;
_spawnPointId = encounter.WildPokemon?.SpawnPointId;
_encounterId = encounter.WildPokemon?.EncounterId;
}
// Calling from CatchIncensePokemonTask
else if (encounter is IncenseEncounterResponse &&
(encounter?.Result == IncenseEncounterResponse.Types.Result.IncenseEncounterSuccess))
{
encounteredPokemon = encounter?.PokemonData;
unixTimeStamp = pokemon.ExpirationTimestampMs;
_spawnPointId = pokemon.SpawnPointId;
_encounterId = pokemon.EncounterId;
}
// Calling from CatchLurePokemon
else if (encounter is DiskEncounterResponse &&
encounter?.Result == DiskEncounterResponse.Types.Result.Success &&
!(currentFortData == null))
{
encounteredPokemon = encounter?.PokemonData;
unixTimeStamp = currentFortData.LureInfo.LureExpiresTimestampMs;
_spawnPointId = currentFortData.Id;
_encounterId = currentFortData.LureInfo.EncounterId;
}
else
{
return(true); // No success to work with, exit
}
// Check for pokeballs before proceeding
var pokeball = GetBestBall(session, encounteredPokemon, probability);
if (pokeball == ItemId.ItemUnknown)
{
Logger.Write(session.Translation.GetTranslation(TranslationString.ZeroPokeballInv));
return(false);
}
// Calculate CP and IV
var pokemonCp = encounteredPokemon?.Cp;
var pokemonIv = PokemonInfo.CalculatePokemonPerfection(encounteredPokemon);
var lv = PokemonInfo.GetLevel(encounteredPokemon);
// Calculate distance away
var latitude = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Latitude
: currentFortData.Latitude;
var longitude = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Longitude
: currentFortData.Longitude;
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, latitude, longitude);
if (session.LogicSettings.ActivateMSniper)
{
var newdata = new MSniperServiceTask.EncounterInfo();
newdata.EncounterId = _encounterId.ToString();
newdata.Iv = Math.Round(pokemonIv, 2);
newdata.Latitude = latitude.ToString("G17", CultureInfo.InvariantCulture);
newdata.Longitude = longitude.ToString("G17", CultureInfo.InvariantCulture);
newdata.PokemonId = (int)(encounteredPokemon?.PokemonId ?? 0);
newdata.PokemonName = encounteredPokemon?.PokemonId.ToString();
newdata.SpawnPointId = _spawnPointId;
newdata.Move1 = PokemonInfo.GetPokemonMove1(encounteredPokemon).ToString();
newdata.Move2 = PokemonInfo.GetPokemonMove2(encounteredPokemon).ToString();
newdata.Expiration = unixTimeStamp;
session.EventDispatcher.Send(newdata);
}
DateTime expiredDate =
new DateTime(1970, 1, 1, 0, 0, 0).AddMilliseconds(Convert.ToDouble(unixTimeStamp));
var encounterEV = new EncounteredEvent()
{
Latitude = latitude,
Longitude = longitude,
PokemonId = encounteredPokemon.PokemonId,
IV = pokemonIv,
Level = (int)lv,
Expires = expiredDate.ToUniversalTime(),
ExpireTimestamp = unixTimeStamp,
SpawnPointId = _spawnPointId,
EncounterId = _encounterId.ToString(),
Move1 = PokemonInfo.GetPokemonMove1(encounteredPokemon).ToString(),
Move2 = PokemonInfo.GetPokemonMove2(encounteredPokemon).ToString(),
};
//add catch to avoid snipe duplicate
string uniqueCacheKey =
$"{session.Settings.PtcUsername}{session.Settings.GoogleUsername}{Math.Round(encounterEV.Latitude, 6)}{(int)encounterEV.PokemonId}{Math.Round(encounterEV.Longitude, 6)}";
session.Cache.Add(uniqueCacheKey, encounterEV, DateTime.Now.AddMinutes(30));
session.EventDispatcher.Send(encounterEV);
if (IsNotMetWithCatchCriteria(session, encounteredPokemon, pokemonIv, lv, pokemonCp))
{
session.EventDispatcher.Send(new NoticeEvent
{
Message = session.Translation.GetTranslation(TranslationString.PokemonSkipped,
encounteredPokemon.PokemonId)
});
session.Cache.Add(_encounterId.ToString(), encounteredPokemon, expiredDate);
Logger.Write(
$"Filter catch not met. {encounteredPokemon.PokemonId.ToString()} IV {pokemonIv} lv {lv} {pokemonCp} move1 {PokemonInfo.GetPokemonMove1(encounteredPokemon)} move 2 {PokemonInfo.GetPokemonMove2(encounteredPokemon)}");
return(true);
}
CatchPokemonResponse caughtPokemonResponse = null;
var lastThrow = CatchPokemonResponse.Types.CatchStatus.CatchSuccess; // Initializing lastThrow
var attemptCounter = 1;
// Main CatchPokemon-loop
do
{
if (session.LogicSettings.UseHumanlikeDelays)
{
DelayingUtils.Delay(session.LogicSettings.BeforeCatchDelay, 0);
}
if ((session.LogicSettings.MaxPokeballsPerPokemon > 0 &&
attemptCounter > session.LogicSettings.MaxPokeballsPerPokemon))
{
break;
}
pokeball = GetBestBall(session, encounteredPokemon, probability);
if (pokeball == ItemId.ItemUnknown)
{
session.EventDispatcher.Send(new NoPokeballEvent
{
Id = encounter is EncounterResponse ? pokemon.PokemonId : encounter?.PokemonData.PokemonId,
Cp = encounteredPokemon.Cp
});
return(false);
}
// Determine whether to use berries or not
if (lastThrow != CatchPokemonResponse.Types.CatchStatus.CatchMissed)
{
//AmountOfBerries++;
//if (AmountOfBerries <= session.LogicSettings.MaxBerriesToUsePerPokemon)
await UseBerry(session,
encounterEV.PokemonId,
_encounterId,
_spawnPointId,
pokemonIv,
pokemonCp.HasValue?pokemonCp.Value : 10000, //unknow CP pokemon, want to use berry
encounterEV.Level,
probability,
cancellationToken);
}
bool hitPokemon = true;
//default to excellent throw
var normalizedRecticleSize = 1.95;
//default spin
var spinModifier = 1.0;
//Humanized throws
if (session.LogicSettings.EnableHumanizedThrows)
{
//thresholds: https://gist.github.com/anonymous/077d6dea82d58b8febde54ae9729b1bf
var spinTxt = "Curve";
var hitTxt = "Excellent";
if (pokemonCp > session.LogicSettings.ForceExcellentThrowOverCp ||
pokemonIv > session.LogicSettings.ForceExcellentThrowOverIv)
{
normalizedRecticleSize = Random.NextDouble() * (1.95 - 1.7) + 1.7;
}
else if (pokemonCp >= session.LogicSettings.ForceGreatThrowOverCp ||
pokemonIv >= session.LogicSettings.ForceGreatThrowOverIv)
{
normalizedRecticleSize = Random.NextDouble() * (1.95 - 1.3) + 1.3;
hitTxt = "Great";
}
else
{
var regularThrow = 100 - (session.LogicSettings.ExcellentThrowChance +
session.LogicSettings.GreatThrowChance +
session.LogicSettings.NiceThrowChance);
var rnd = Random.Next(1, 101);
if (rnd <= regularThrow)
{
normalizedRecticleSize = Random.NextDouble() * (1 - 0.1) + 0.1;
hitTxt = "Ordinary";
}
else if (rnd <= regularThrow + session.LogicSettings.NiceThrowChance)
{
normalizedRecticleSize = Random.NextDouble() * (1.3 - 1) + 1;
hitTxt = "Nice";
}
else if (rnd <=
regularThrow + session.LogicSettings.NiceThrowChance +
session.LogicSettings.GreatThrowChance)
{
normalizedRecticleSize = Random.NextDouble() * (1.7 - 1.3) + 1.3;
hitTxt = "Great";
}
if (Random.NextDouble() * 100 > session.LogicSettings.CurveThrowChance)
{
spinModifier = 0.0;
spinTxt = "Straight";
}
}
// Round to 2 decimals
normalizedRecticleSize = Math.Round(normalizedRecticleSize, 2);
// Missed throw check
int missChance = Random.Next(1, 101);
if (missChance <= session.LogicSettings.ThrowMissPercentage &&
session.LogicSettings.EnableMissedThrows)
{
hitPokemon = false;
}
Logger.Write($"(Threw ball) {hitTxt} throw, {spinTxt}-ball, HitPokemon = {hitPokemon}...",
LogLevel.Debug);
}
caughtPokemonResponse =
await session.Client.Encounter.CatchPokemon(
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.EncounterId
: _encounterId,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.SpawnPointId
: currentFortData.Id, pokeball, normalizedRecticleSize, spinModifier, hitPokemon);
await session.Inventory.UpdateInventoryItem(pokeball);
var evt = new PokemonCaptureEvent()
{
Status = caughtPokemonResponse.Status,
CaptureReason = caughtPokemonResponse.CaptureReason,
Latitude = latitude,
Longitude = longitude
};
lastThrow = caughtPokemonResponse.Status; // sets lastThrow status
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
var totalExp = 0;
var totalStarDust = caughtPokemonResponse.CaptureAward.Stardust.Sum();
if (encounteredPokemon != null)
{
encounteredPokemon.Id = caughtPokemonResponse.CapturedPokemonId;
}
foreach (var xp in caughtPokemonResponse.CaptureAward.Xp)
{
totalExp += xp;
}
var stardust = session.Inventory.UpdateStarDust(totalStarDust);
evt.Exp = totalExp;
evt.Stardust = stardust;
evt.UniqueId = caughtPokemonResponse.CapturedPokemonId;
evt.Candy = session.Inventory.GetCandyFamily(pokemon.PokemonId);
if (session.LogicSettings.UseCatchLimit)
{
session.Stats.AddPokemonTimestamp(DateTime.Now.Ticks);
session.EventDispatcher.Send(new CatchLimitUpdate(session.Stats.GetNumPokemonsInLast24Hours(), session.LogicSettings.CatchPokemonLimit));
}
}
evt.CatchType = encounter is EncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeNormal)
: encounter is DiskEncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeLure)
: session.Translation.GetTranslation(TranslationString.CatchTypeIncense);
evt.CatchTypeText = encounter is EncounterResponse
? "normal"
: encounter is DiskEncounterResponse
? "lure"
: "incense";
evt.Id = encounter is EncounterResponse
? pokemon.PokemonId
: encounter?.PokemonData.PokemonId;
evt.EncounterId = _encounterId;
evt.Move1 = PokemonInfo.GetPokemonMove1(encounteredPokemon);
evt.Move2 = PokemonInfo.GetPokemonMove2(encounteredPokemon);
evt.Expires = pokemon?.ExpirationTimestampMs ?? 0;
evt.SpawnPointId = _spawnPointId;
evt.Level = PokemonInfo.GetLevel(encounteredPokemon);
evt.Cp = encounteredPokemon.Cp;
evt.MaxCp = PokemonInfo.CalculateMaxCp(encounteredPokemon.PokemonId);
evt.Perfection = Math.Round(PokemonInfo.CalculatePokemonPerfection(encounteredPokemon));
evt.Probability = Math.Round(probability * 100, 2);
evt.Distance = distance;
evt.Pokeball = pokeball;
evt.Attempt = attemptCounter;
//await session.Inventory.RefreshCachedInventory();
evt.BallAmount = session.Inventory.GetItemAmountByType(pokeball);
evt.Rarity = PokemonGradeHelper.GetPokemonGrade(evt.Id).ToString();
session.EventDispatcher.Send(evt);
attemptCounter++;
// If Humanlike delays are used
if (session.LogicSettings.UseHumanlikeDelays)
{
switch (caughtPokemonResponse.Status)
{
case CatchPokemonResponse.Types.CatchStatus.CatchError:
DelayingUtils.Delay(session.LogicSettings.CatchErrorDelay, 0);
break;
case CatchPokemonResponse.Types.CatchStatus.CatchSuccess:
DelayingUtils.Delay(session.LogicSettings.CatchSuccessDelay, 0);
break;
case CatchPokemonResponse.Types.CatchStatus.CatchEscape:
DelayingUtils.Delay(session.LogicSettings.CatchEscapeDelay, 0);
break;
case CatchPokemonResponse.Types.CatchStatus.CatchFlee:
DelayingUtils.Delay(session.LogicSettings.CatchFleeDelay, 0);
break;
case CatchPokemonResponse.Types.CatchStatus.CatchMissed:
DelayingUtils.Delay(session.LogicSettings.CatchMissedDelay, 0);
break;
default:
break;
}
}
else
{
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 0);
}
} while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed ||
caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
if (session.LogicSettings.AllowMultipleBot)
{
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchFlee)
{
CatchFleeContinuouslyCount++;
if (CatchFleeContinuouslyCount > session.LogicSettings.MultipleBotConfig.CatchFleeCount &&
TinyIoCContainer.Current.Resolve <MultiAccountManager>().AllowSwitch())
{
CatchFleeContinuouslyCount = 0;
throw new ActiveSwitchByRuleException()
{
MatchedRule = SwitchRules.CatchFlee,
ReachedValue = session.LogicSettings.MultipleBotConfig.CatchFleeCount
};
}
}
else
{
//reset if not catch flee.
CatchFleeContinuouslyCount = 0;
MSniperServiceTask.UnblockSnipe();
}
}
session.Actions.RemoveAll(x => x == BotActions.Catch);
if (MultipleBotConfig.IsMultiBotActive(session.LogicSettings))
{
ExecuteSwitcher(session, encounterEV, uniqueCacheKey);
}
if (session.LogicSettings.TransferDuplicatePokemonOnCapture &&
session.LogicSettings.TransferDuplicatePokemon &&
sessionAllowTransfer &&
caughtPokemonResponse != null &&
caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
if (session.LogicSettings.UseNearActionRandom)
{
await HumanRandomActionTask.TransferRandom(session, cancellationToken);
}
else
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
}
}
return(true);
}
private static async Task <ItemId> GetBestBall(ISession session, dynamic encounter, float probability)
{
/*var pokemonCp = encounter is EncounterResponse //commented for possible future uses
* ? encounter.WildPokemon?.PokemonData?.Cp
* : encounter?.PokemonData?.Cp;*/
var pokemonId = encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.PokemonId
: encounter?.PokemonData?.PokemonId;
var iV =
Math.Round(
PokemonInfo.CalculatePokemonPerfection(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData));
var useUltraBallBelowCatchProbability = session.LogicSettings.UseUltraBallBelowCatchProbability > 1
? session.LogicSettings.UseUltraBallBelowCatchProbability / 100
: session.LogicSettings.UseUltraBallBelowCatchProbability;
var useGreatBallBelowCatchProbability = session.LogicSettings.UseGreatBallBelowCatchProbability > 1
? session.LogicSettings.UseGreatBallBelowCatchProbability / 100
: session.LogicSettings.UseGreatBallBelowCatchProbability;
await session.Inventory.RefreshCachedInventory();
var pokeBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemPokeBall);
var greatBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemGreatBall);
var ultraBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemUltraBall);
var masterBallsCount = await session.Inventory.GetItemAmountByType(ItemId.ItemMasterBall);
if (masterBallsCount > 0 && !session.LogicSettings.PokemonToUseMasterball.Any() ||
session.LogicSettings.PokemonToUseMasterball.Contains(pokemonId))
{
return(ItemId.ItemMasterBall);
}
if (ultraBallsCount > 0 && iV >= session.LogicSettings.UseUltraBallAboveIv ||
ultraBallsCount > 0 && probability <= useUltraBallBelowCatchProbability)
{
return(ItemId.ItemUltraBall);
}
if (greatBallsCount > 0 && iV >= session.LogicSettings.UseGreatBallAboveIv ||
greatBallsCount > 0 && probability <= useGreatBallBelowCatchProbability)
{
return(ItemId.ItemGreatBall);
}
//so we counted down, now if we don't have pokeballs we need to just use the best one available
if (pokeBallsCount > 0)
{
return(ItemId.ItemPokeBall);
}
if (greatBallsCount > 0)
{
return(ItemId.ItemGreatBall);
}
if (ultraBallsCount > 0)
{
return(ItemId.ItemUltraBall);
}
return(ItemId.ItemUnknown);
//return pokeBallsCount > 0 ? ItemId.ItemPokeBall : ItemId.ItemUnknown;
}
public async Task <IEnumerable <PokemonData> > GetDuplicatePokemonToTransfer(
IEnumerable <PokemonId> pokemonsNotToTransfer, IEnumerable <PokemonId> pokemonsToEvolve,
bool keepPokemonsThatCanEvolve = false, bool prioritizeIVoverCp = false
)
{
var myPokemon = await GetPokemons();
var myPokemonList = myPokemon.ToList();
var pokemonToTransfer = myPokemonList.Where(p => !pokemonsNotToTransfer.Contains(p.PokemonId) && p.DeployedFortId == string.Empty && p.Favorite == 0 && p.BuddyTotalKmWalked == 0).ToList();
try
{
pokemonToTransfer =
pokemonToTransfer.Where(
p =>
{
var pokemonTransferFilter = GetPokemonTransferFilter(p.PokemonId);
return(!pokemonTransferFilter.MovesOperator.BoolFunc(
pokemonTransferFilter.MovesOperator.ReverseBoolFunc(
pokemonTransferFilter.MovesOperator.InverseBool(pokemonTransferFilter.Moves.Count > 0),
pokemonTransferFilter.Moves.Any(moveset =>
pokemonTransferFilter.MovesOperator.ReverseBoolFunc(
pokemonTransferFilter.MovesOperator.InverseBool(moveset.Count > 0),
moveset.Intersect(new[] { p.Move1, p.Move2 }).Count() == Math.Max(Math.Min(moveset.Count, 2), 0)))),
pokemonTransferFilter.KeepMinOperator.BoolFunc(
p.Cp >= pokemonTransferFilter.KeepMinCp,
PokemonInfo.CalculatePokemonPerfection(p) >= pokemonTransferFilter.KeepMinIvPercentage,
pokemonTransferFilter.KeepMinOperator.ReverseBoolFunc(
pokemonTransferFilter.KeepMinOperator.InverseBool(pokemonTransferFilter.UseKeepMinLvl),
PokemonInfo.GetLevel(p) >= pokemonTransferFilter.KeepMinLvl))));
}).ToList();
}
catch (Exceptions.ActiveSwitchByRuleException e)
{
throw e;
}
catch (Exception e)
{
//throw e;
}
var myPokemonSettings = await GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
var results = new List <PokemonData>();
foreach (var pokemonGroupToTransfer in pokemonToTransfer.GroupBy(p => p.PokemonId).ToList())
{
var amountToKeepInStorage = Math.Max(GetPokemonTransferFilter(pokemonGroupToTransfer.Key).KeepMinDuplicatePokemon, 0);
var inStorage = myPokemonList.Count(data => data.PokemonId == pokemonGroupToTransfer.Key);
var needToRemove = inStorage - amountToKeepInStorage;
if (needToRemove <= 0)
{
continue;
}
var weakPokemonCount = pokemonGroupToTransfer.Count();
var canBeRemoved = Math.Min(needToRemove, weakPokemonCount);
var settings = pokemonSettings.Single(x => x.PokemonId == pokemonGroupToTransfer.Key);
//Lets calc new canBeRemoved pokemons according to transferring some of them for +1 candy or to evolving for +1 candy
if (keepPokemonsThatCanEvolve &&
pokemonsToEvolve.Contains(pokemonGroupToTransfer.Key) &&
settings.CandyToEvolve > 0 &&
settings.EvolutionIds.Count != 0)
{
var familyCandy = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId);
// its an solution in fixed numbers of equations with two variables
// (N = X + Y, X + C + Y >= Y * E) -> X >= (N * (E - 1) - C) / E
// where N - current canBeRemoved, X - new canBeRemoved, Y - possible to keep more, E - CandyToEvolve, C - candy amount
canBeRemoved = (int)Math.Ceiling((double)((settings.CandyToEvolve - 1) * canBeRemoved - familyCandy.Candy_) / settings.CandyToEvolve);
}
if (canBeRemoved <= 0)
{
continue;
}
if (prioritizeIVoverCp)
{
results.AddRange(pokemonGroupToTransfer
.OrderBy(PokemonInfo.CalculatePokemonPerfection)
.ThenBy(n => n.Cp)
.Take(canBeRemoved));
}
else
{
results.AddRange(pokemonGroupToTransfer
.OrderBy(x => x.Cp)
.ThenBy(PokemonInfo.CalculatePokemonPerfection)
.Take(canBeRemoved));
}
}
#region For testing
/*
* results.ForEach(data =>
* {
* var allpokemonoftype = myPokemonList.Where(x => x.PokemonId == data.PokemonId);
* var bestPokemonOfType =
* (_logicSettings.PrioritizeIvOverCp
* ? allpokemonoftype
* .OrderByDescending(PokemonInfo.CalculatePokemonPerfection)
* .FirstOrDefault()
* : allpokemonoftype
* .OrderByDescending(x => x.Cp)
* .FirstOrDefault())
* ?? data;
*
* var perfection = PokemonInfo.CalculatePokemonPerfection(data);
* var cp = data.Cp;
*
* var bestPerfection = PokemonInfo.CalculatePokemonPerfection(bestPokemonOfType);
* var bestCp = bestPokemonOfType.Cp;
* });
*/
#endregion
return(results);
}
public void Execute()
{
EnabledButton(false, th.TS("Reloading Pokemon list."));
try
{
client = Logic.Logic.objClient;
if (client.ReadyToUse != false)
{
RandomHelper.RandomSleep(1000, 1200);
refreshData();
pokemons =
inventory.InventoryDelta.InventoryItems
.Select(i => i.InventoryItemData?.PokemonData)
.Where(p => p != null && p?.PokemonId > 0)
.OrderByDescending(key => key.Cp);
var families = inventory.InventoryDelta.InventoryItems
.Select(i => i.InventoryItemData?.Candy)
.Where(p => p != null && (int)p?.FamilyId > 0)
.OrderByDescending(p => (int)p.FamilyId);
var myPokemonSettings = templates.ItemTemplates.Select(i => i.PokemonSettings).Where(p => p != null && p?.FamilyId != PokemonFamilyId.FamilyUnset);
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = inventory.InventoryDelta.InventoryItems.Select(i => i.InventoryItemData?.Candy).Where(p => p != null && p?.FamilyId != PokemonFamilyId.FamilyUnset);
var pokemonFamilies = myPokemonFamilies.ToArray();
try{
PokemonListView.BeginUpdate();
}catch (Exception ex1) {
Logger.ExceptionInfo(ex1.ToString());
}
PokemonListView.Items.Clear();
foreach (var pokemon in pokemons)
{
var listViewItem = new ListViewItem();
listViewItem.UseItemStyleForSubItems = false;
listViewItem.Tag = pokemon;
var currentCandy = families
.Where(i => (int)i.FamilyId <= (int)pokemon.PokemonId)
.Select(f => f.Candy_)
.First();
listViewItem.SubItems.Add(string.Format("{0}", pokemon.Cp));
if (checkBox_ShortName.Checked)
{
listViewItem.SubItems.Add(string.Format("{0}% {1}{2}{3} ({4})", PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0"), pokemon.IndividualAttack.ToString("X"), pokemon.IndividualDefense.ToString("X"), pokemon.IndividualStamina.ToString("X"), (45 - pokemon.IndividualAttack - pokemon.IndividualDefense - pokemon.IndividualStamina)));
}
else
{
listViewItem.SubItems.Add(string.Format("{0}% {1}-{2}-{3}", PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0"), pokemon.IndividualAttack, pokemon.IndividualDefense, pokemon.IndividualStamina));
}
listViewItem.SubItems.Add(string.Format("{0}", PokemonInfo.GetLevel(pokemon)));
listViewItem.ImageKey = pokemon.PokemonId.ToString();
var specSymbol = "";
if (pokemon.Favorite == 1)
{
specSymbol = "★";
}
if ((profile != null) && (profile.PlayerData.BuddyPokemon.Id == pokemon.Id))
{
specSymbol = "☉";
}
listViewItem.Text = specSymbol + th.TS(pokemon.PokemonId.ToString());
listViewItem.ToolTipText = Logic.Utils.StringUtils.ConvertTimeMSinString(pokemon.CreationTimeMs, "dd/MM/yyyy HH:mm:ss");
if (pokemon.Nickname != "")
{
listViewItem.ToolTipText += th.TS("\n+Nickname: {0}", pokemon.Nickname);
}
var settings = pokemonSettings.Single(x => x.PokemonId == pokemon.PokemonId);
var familyCandy = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId);
if (settings.EvolutionIds.Count > 0 && familyCandy.Candy_ >= settings.CandyToEvolve)
{
listViewItem.SubItems.Add("");
listViewItem.SubItems[listViewItem.SubItems.Count - 1].ForeColor = Color.ForestGreen;
//listViewItem.SubItems[listViewItem.SubItems.Count - 1].Font = new Font("Microsoft Sans Serif", 8F, System.Drawing.FontStyle.Bold);
listViewItem.SubItems[listViewItem.SubItems.Count - 1].Text = "Y (" + familyCandy.Candy_ + "/" + settings.CandyToEvolve + ")";
listViewItem.Checked = true;
}
else
{
listViewItem.SubItems.Add("");
if (settings.EvolutionIds.Count > 0)
{
listViewItem.SubItems[listViewItem.SubItems.Count - 1].ForeColor = Color.DarkRed;
listViewItem.SubItems[listViewItem.SubItems.Count - 1].Text = "N (" + familyCandy.Candy_ + "/" + settings.CandyToEvolve + ")";
}
else
{
listViewItem.SubItems[listViewItem.SubItems.Count - 1].ForeColor = Color.DarkRed;
listViewItem.SubItems[listViewItem.SubItems.Count - 1].Text = "N (" + familyCandy.Candy_ + "/Max)";
}
}
listViewItem.SubItems.Add(string.Format("{0}", Math.Round(pokemon.HeightM, 2)));
listViewItem.SubItems.Add(string.Format("{0}", Math.Round(pokemon.WeightKg, 2)));
listViewItem.SubItems.Add(string.Format("{0}/{1}", pokemon.Stamina, pokemon.StaminaMax));
listViewItem.SubItems.Add(string.Format("{0}", pokemon.Move1));
listViewItem.SubItems.Add(string.Format("{0} ({1})", pokemon.Move2, PokemonInfo.GetAttack(pokemon.Move2)));
listViewItem.SubItems.Add(string.Format("{0}", (int)pokemon.PokemonId));
listViewItem.SubItems.Add(string.Format("{0}", PokemonInfo.CalculatePokemonPerfectionCP(pokemon).ToString("0.00")));
AdditionalPokeData addData = additionalPokeData.FirstOrDefault(x => x.PokedexNumber == (int)pokemon.PokemonId);
if (addData != null)
{
listViewItem.SubItems.Add(addData.Type1);
listViewItem.SubItems.Add(addData.Type2);
}
else
{
listViewItem.SubItems.Add("");
listViewItem.SubItems.Add("");
}
// NOTE: yyyy/MM/dd is inverted order to can sort correctly as text.
listViewItem.SubItems.Add(Logic.Utils.StringUtils.ConvertTimeMSinString(pokemon.CreationTimeMs, "yyyy/MM/dd HH:mm:ss"));
listViewItem.SubItems.Add(th.TS(pokemon.Pokeball.ToString().Replace("Item", "")));
listViewItem.SubItems.Add("" + pokemon.NumUpgrades);
listViewItem.SubItems.Add("" + pokemon.BattlesAttacked);
listViewItem.SubItems.Add("" + pokemon.BattlesDefended);
listViewItem.SubItems.Add("" + pokemon.DeployedFortId);
if (pokemon.DeployedFortId != "")
{
listViewItem.SubItems[0].BackColor = Color.Bisque;
}
var CapturedLatlng = S2Helper.GetLatLng(pokemon.CapturedCellId);
listViewItem.SubItems.Add(Logic.Utils.LocationUtils.FindAddress(CapturedLatlng[0], CapturedLatlng[1]));
PokemonListView.Items.Add(listViewItem);
}
try{
PokemonListView.EndUpdate();
}catch (Exception ex1) {
Logger.ExceptionInfo(ex1.ToString());
}
PokemonListView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
EnabledButton(true);
statusTexbox.Text = string.Empty;
RefreshTitle();
if (playerPanel1 != null)
{
playerPanel1.SetPokemons(pokemons);
}
}
}
catch (Exception ex1)
{
Logger.ExceptionInfo(ex1.ToString());
}
}
public async Task <IEnumerable <PokemonData> > GetDuplicatePokemonToTransfer(
IEnumerable <PokemonId> pokemonsNotToTransfer, Dictionary <PokemonId, EvolveFilter> pokemonEvolveFilters,
bool keepPokemonsThatCanEvolve = false, bool prioritizeIVoverCp = false
)
{
var session = TinyIoCContainer.Current.Resolve <ISession>();
var myPokemon = await GetPokemons().ConfigureAwait(false);
var pokemonToTransfer = myPokemon.Where(p => !pokemonsNotToTransfer.Contains(p.PokemonId) && CanTransferPokemon(p));
try
{
pokemonToTransfer =
pokemonToTransfer.Where(
p =>
{
var pokemonTransferFilter = session.LogicSettings.PokemonsTransferFilter.GetFilter <TransferFilter>(p.PokemonId);
return(!pokemonTransferFilter.MovesOperator.BoolFunc(
pokemonTransferFilter.MovesOperator.ReverseBoolFunc(
pokemonTransferFilter.MovesOperator.InverseBool(
pokemonTransferFilter.Moves.Count > 0),
pokemonTransferFilter.Moves.Any(moveset =>
pokemonTransferFilter.MovesOperator.ReverseBoolFunc(
pokemonTransferFilter.MovesOperator.InverseBool(moveset.Count > 0),
moveset.Intersect(new[] { p.Move1, p.Move2 }).Count() ==
Math.Max(Math.Min(moveset.Count, 2), 0)))),
pokemonTransferFilter.KeepMinOperator.BoolFunc(
p.Cp >= pokemonTransferFilter.KeepMinCp,
PokemonInfo.CalculatePokemonPerfection(p) >=
pokemonTransferFilter.KeepMinIvPercentage,
pokemonTransferFilter.KeepMinOperator.ReverseBoolFunc(
pokemonTransferFilter.KeepMinOperator.InverseBool(pokemonTransferFilter
.UseKeepMinLvl),
PokemonInfo.GetLevel(p) >= pokemonTransferFilter.KeepMinLvl))));
})
.ToList();
}
catch (ActiveSwitchByRuleException e)
{
throw e;
}
var results = new List <PokemonData>();
var pokemonToEvolve = await GetPokemonToEvolve(pokemonEvolveFilters).ConfigureAwait(false);
foreach (var pokemonGroupToTransfer in pokemonToTransfer.GroupBy(p => p.PokemonId).ToList())
{
var amountToKeepInStorage = GetApplyFilter <TransferFilter>(session.LogicSettings.PokemonsTransferFilter, pokemonGroupToTransfer.Key).KeepMinDuplicatePokemon;
var inStorage = myPokemon.Count(data => data.PokemonId == pokemonGroupToTransfer.Key);
var needToRemove = inStorage - amountToKeepInStorage;
if (needToRemove <= 0)
{
continue;
}
var weakPokemonCount = pokemonGroupToTransfer.Count();
var canBeRemoved = Math.Min(needToRemove, weakPokemonCount);
// Adjust canBeRemoved by subtracting the number of evolve pokemon we are saving.
var pokemonToEvolveForThisGroup = pokemonToEvolve.Where(p => p.PokemonId == pokemonGroupToTransfer.Key);
var numToSaveForEvolve = pokemonGroupToTransfer.Count(p => pokemonToEvolveForThisGroup.Any(p2 => p2.Id == p.Id));
canBeRemoved -= numToSaveForEvolve;
Logger.Write($"Saving {numToSaveForEvolve} {pokemonGroupToTransfer.Key} for evolve. Number of {pokemonGroupToTransfer.Key} to be transferred: {canBeRemoved}", Logic.Logging.LogLevel.Info);
if (prioritizeIVoverCp)
{
results.AddRange(pokemonGroupToTransfer
.Where(p => !pokemonToEvolveForThisGroup.Any(p2 => p2.Id == p.Id)) // Remove pokemon to evolve from the transfer list.
.OrderBy(PokemonInfo.CalculatePokemonPerfection)
.ThenBy(n => n.Cp)
.Take(canBeRemoved));
}
else
{
results.AddRange(pokemonGroupToTransfer
.Where(p => !pokemonToEvolveForThisGroup.Any(p2 => p2.Id == p.Id)) // Remove pokemon to evolve from the transfer list.
.OrderBy(x => x.Cp)
.ThenBy(PokemonInfo.CalculatePokemonPerfection)
.Take(canBeRemoved));
}
}
return(results);
}
// Structure of calling Tasks
// ## From CatchNearbyPokemonTask
// await CatchPokemonTask.Execute(session, cancellationToken, encounter, pokemon, currentFortData: null, sessionAllowTransfer:sessionAllowTransfer);
// ## From CatchLurePokemonTask
// await CatchPokemonTask.Execute(session, cancellationToken, encounter, pokemon, currentFortData, sessionAllowTransfer: true);
// ## From CatchIncensePokemonTask
// await CatchPokemonTask.Execute(session, cancellationToken, encounter, pokemon, currentFortData: null, sessionAllowTransfer: true);
// ## From SnipePokemonTask
// await CatchPokemonTask.Execute(session, cancellationToken, encounter, pokemon, currentFortData: null, sessionAllowTransfer: true);
// ## From MSniperServiceTask
// await CatchPokemonTask.Execute(session, cancellationToken, encounter, pokemon, currentFortData: null, sessionAllowTransfer: true);
public static async Task Execute(ISession session,
CancellationToken cancellationToken,
dynamic encounter,
MapPokemon pokemon,
FortData currentFortData,
bool sessionAllowTransfer)
{
// If the encounter is null nothing will work below, so exit now
if (encounter == null)
{
return;
}
// Exit if user defined max limits reached
if (CatchThresholdExceeds(session, cancellationToken))
{
return;
}
using (var block = new BlockableScope(session, Model.BotActions.Catch))
{
if (!await block.WaitToRun())
{
return;
}
AmountOfBerries = 0;
cancellationToken.ThrowIfCancellationRequested();
float probability = encounter.CaptureProbability?.CaptureProbability_[0];
PokemonData encounteredPokemon;
long unixTimeStamp;
ulong _encounterId;
string _spawnPointId;
// Calling from CatchNearbyPokemonTask and SnipePokemonTask
if (encounter is EncounterResponse &&
(encounter?.Status == EncounterResponse.Types.Status.EncounterSuccess))
{
encounteredPokemon = encounter.WildPokemon?.PokemonData;
unixTimeStamp = encounter.WildPokemon?.LastModifiedTimestampMs
+ encounter.WildPokemon?.TimeTillHiddenMs;
_spawnPointId = encounter.WildPokemon?.SpawnPointId;
_encounterId = encounter.WildPokemon?.EncounterId;
}
// Calling from CatchIncensePokemonTask
else if (encounter is IncenseEncounterResponse &&
(encounter?.Result == IncenseEncounterResponse.Types.Result.IncenseEncounterSuccess))
{
encounteredPokemon = encounter?.PokemonData;
unixTimeStamp = pokemon.ExpirationTimestampMs;
_spawnPointId = pokemon.SpawnPointId;
_encounterId = pokemon.EncounterId;
}
// Calling from CatchLurePokemon
else if (encounter is DiskEncounterResponse &&
encounter?.Result == DiskEncounterResponse.Types.Result.Success &&
!(currentFortData == null))
{
encounteredPokemon = encounter?.PokemonData;
unixTimeStamp = currentFortData.LureInfo.LureExpiresTimestampMs;
_spawnPointId = currentFortData.Id;
_encounterId = currentFortData.LureInfo.EncounterId;
}
else
{
return; // No success to work with, exit
}
// Check for pokeballs before proceeding
var pokeball = await GetBestBall(session, encounteredPokemon, probability);
if (pokeball == ItemId.ItemUnknown)
{
Logger.Write(session.Translation.GetTranslation(TranslationString.ZeroPokeballInv));
return;
}
// Calculate CP and IV
var pokemonCp = encounteredPokemon?.Cp;
var pokemonIv = PokemonInfo.CalculatePokemonPerfection(encounteredPokemon);
var lv = PokemonInfo.GetLevel(encounteredPokemon);
// Calculate distance away
var latitude = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Latitude
: currentFortData.Latitude;
var longitude = encounter is EncounterResponse || encounter is IncenseEncounterResponse
? pokemon.Longitude
: currentFortData.Longitude;
var distance = LocationUtils.CalculateDistanceInMeters(session.Client.CurrentLatitude,
session.Client.CurrentLongitude, latitude, longitude);
DateTime expiredDate = new DateTime(1970, 1, 1, 0, 0, 0).AddMilliseconds(Convert.ToDouble(unixTimeStamp));
session.EventDispatcher.Send(new EncounteredEvent()
{
Latitude = latitude,
Longitude = longitude,
PokemonId = encounteredPokemon.PokemonId,
IV = pokemonIv,
Level = (int)lv,
Expires = expiredDate.ToUniversalTime(),
ExpireTimestamp = unixTimeStamp,
SpawnPointId = _spawnPointId,
EncounterId = _encounterId.ToString(),
Move1 = PokemonInfo.GetPokemonMove1(encounteredPokemon).ToString(),
Move2 = PokemonInfo.GetPokemonMove2(encounteredPokemon).ToString(),
});
if (IsNotMetWithCatchCriteria(session, encounteredPokemon, pokemonIv, lv, pokemonCp))
{
session.EventDispatcher.Send(new NoticeEvent
{
Message = session.Translation.GetTranslation(TranslationString.PokemonSkipped, encounteredPokemon.PokemonId)
});
session.Cache.Add(_encounterId.ToString(), encounteredPokemon, expiredDate);
Logger.Write($"Filter catch not met. {encounteredPokemon.PokemonId.ToString()} IV {pokemonIv} lv {lv} {pokemonCp} move1 {PokemonInfo.GetPokemonMove1(encounteredPokemon)} move 2 {PokemonInfo.GetPokemonMove2(encounteredPokemon)}");
return;
}
;
CatchPokemonResponse caughtPokemonResponse = null;
var lastThrow = CatchPokemonResponse.Types.CatchStatus.CatchSuccess; // Initializing lastThrow
var attemptCounter = 1;
// Main CatchPokemon-loop
do
{
if ((session.LogicSettings.MaxPokeballsPerPokemon > 0 &&
attemptCounter > session.LogicSettings.MaxPokeballsPerPokemon))
{
break;
}
pokeball = await GetBestBall(session, encounteredPokemon, probability);
if (pokeball == ItemId.ItemUnknown)
{
session.EventDispatcher.Send(new NoPokeballEvent
{
Id = encounter is EncounterResponse ? pokemon.PokemonId : encounter?.PokemonData.PokemonId,
Cp = encounteredPokemon.Cp
});
return;
}
// Determine whether to use berries or not
if (((session.LogicSettings.UseBerriesOperator.ToLower().Equals("and") &&
pokemonIv >= session.LogicSettings.UseBerriesMinIv &&
pokemonCp >= session.LogicSettings.UseBerriesMinCp &&
probability < session.LogicSettings.UseBerriesBelowCatchProbability) ||
(session.LogicSettings.UseBerriesOperator.ToLower().Equals("or") && (
pokemonIv >= session.LogicSettings.UseBerriesMinIv ||
pokemonCp >= session.LogicSettings.UseBerriesMinCp ||
probability < session.LogicSettings.UseBerriesBelowCatchProbability))) &&
lastThrow != CatchPokemonResponse.Types.CatchStatus.CatchMissed) // if last throw is a miss, no double berry
{
AmountOfBerries++;
if (AmountOfBerries <= session.LogicSettings.MaxBerriesToUsePerPokemon)
{
await UseBerry(session, _encounterId, _spawnPointId);
}
}
bool hitPokemon = true;
//default to excellent throw
var normalizedRecticleSize = 1.95;
//default spin
var spinModifier = 1.0;
//Humanized throws
if (session.LogicSettings.EnableHumanizedThrows)
{
//thresholds: https://gist.github.com/anonymous/077d6dea82d58b8febde54ae9729b1bf
var spinTxt = "Curve";
var hitTxt = "Excellent";
if (pokemonCp > session.LogicSettings.ForceExcellentThrowOverCp ||
pokemonIv > session.LogicSettings.ForceExcellentThrowOverIv)
{
normalizedRecticleSize = Random.NextDouble() * (1.95 - 1.7) + 1.7;
}
else if (pokemonCp >= session.LogicSettings.ForceGreatThrowOverCp ||
pokemonIv >= session.LogicSettings.ForceGreatThrowOverIv)
{
normalizedRecticleSize = Random.NextDouble() * (1.95 - 1.3) + 1.3;
hitTxt = "Great";
}
else
{
var regularThrow = 100 - (session.LogicSettings.ExcellentThrowChance +
session.LogicSettings.GreatThrowChance +
session.LogicSettings.NiceThrowChance);
var rnd = Random.Next(1, 101);
if (rnd <= regularThrow)
{
normalizedRecticleSize = Random.NextDouble() * (1 - 0.1) + 0.1;
hitTxt = "Ordinary";
}
else if (rnd <= regularThrow + session.LogicSettings.NiceThrowChance)
{
normalizedRecticleSize = Random.NextDouble() * (1.3 - 1) + 1;
hitTxt = "Nice";
}
else if (rnd <=
regularThrow + session.LogicSettings.NiceThrowChance +
session.LogicSettings.GreatThrowChance)
{
normalizedRecticleSize = Random.NextDouble() * (1.7 - 1.3) + 1.3;
hitTxt = "Great";
}
if (Random.NextDouble() * 100 > session.LogicSettings.CurveThrowChance)
{
spinModifier = 0.0;
spinTxt = "Straight";
}
}
// Round to 2 decimals
normalizedRecticleSize = Math.Round(normalizedRecticleSize, 2);
// Missed throw check
int missChance = Random.Next(1, 101);
if (missChance <= session.LogicSettings.ThrowMissPercentage && session.LogicSettings.EnableMissedThrows)
{
hitPokemon = false;
}
Logger.Write($"(Threw ball) {hitTxt} throw, {spinTxt}-ball, HitPokemon = {hitPokemon}...", LogLevel.Debug);
}
caughtPokemonResponse =
await session.Client.Encounter.CatchPokemon(
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.EncounterId
: _encounterId,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.SpawnPointId
: currentFortData.Id, pokeball, normalizedRecticleSize, spinModifier, hitPokemon);
var evt = new PokemonCaptureEvent()
{
Status = caughtPokemonResponse.Status,
Latitude = latitude,
Longitude = longitude
};
lastThrow = caughtPokemonResponse.Status; // sets lastThrow status
// Only use EncounterResponse for MSnipe (no Incense or Lures)
if (session.LogicSettings.ActivateMSniper && encounter is EncounterResponse)
{
MSniperServiceTask.AddToList(session, encounter);
}
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
var totalExp = 0;
foreach (var xp in caughtPokemonResponse.CaptureAward.Xp)
{
totalExp += xp;
}
var profile = await session.Client.Player.GetPlayer();
evt.Exp = totalExp;
evt.Stardust = profile.PlayerData.Currencies.ToArray()[1].Amount;
evt.UniqueId = caughtPokemonResponse.CapturedPokemonId;
var pokemonSettings = await session.Inventory.GetPokemonSettings();
var pokemonFamilies = await session.Inventory.GetPokemonFamilies();
var setting =
pokemonSettings.FirstOrDefault(q => pokemon != null && q.PokemonId == pokemon.PokemonId);
var family = pokemonFamilies.FirstOrDefault(q => setting != null && q.FamilyId == setting.FamilyId);
if (family != null)
{
family.Candy_ += caughtPokemonResponse.CaptureAward.Candy.Sum();
evt.FamilyCandies = family.Candy_;
}
else
{
evt.FamilyCandies = caughtPokemonResponse.CaptureAward.Candy.Sum();
}
if (session.LogicSettings.UseCatchLimit)
{
session.Stats.AddPokemonTimestamp(DateTime.Now.Ticks);
Logger.Write($"(CATCH LIMIT) {session.Stats.GetNumPokemonsInLast24Hours()}/{session.LogicSettings.CatchPokemonLimit}",
LogLevel.Info, ConsoleColor.Yellow);
}
}
evt.CatchType = encounter is EncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeNormal)
: encounter is DiskEncounterResponse
? session.Translation.GetTranslation(TranslationString.CatchTypeLure)
: session.Translation.GetTranslation(TranslationString.CatchTypeIncense);
evt.CatchTypeText = encounter is EncounterResponse
? "normal"
: encounter is DiskEncounterResponse
? "lure"
: "incense";
evt.Id = encounter is EncounterResponse
? pokemon.PokemonId : encounter?.PokemonData.PokemonId;
evt.EncounterId = _encounterId;
evt.Move1 = PokemonInfo.GetPokemonMove1(encounteredPokemon);
evt.Move2 = PokemonInfo.GetPokemonMove2(encounteredPokemon);
evt.Expires = pokemon?.ExpirationTimestampMs ?? 0;
evt.SpawnPointId = _spawnPointId;
evt.Level = PokemonInfo.GetLevel(encounteredPokemon);
evt.Cp = encounteredPokemon.Cp;
evt.MaxCp = PokemonInfo.CalculateMaxCp(encounteredPokemon);
evt.Perfection = Math.Round(PokemonInfo.CalculatePokemonPerfection(encounteredPokemon));
evt.Probability = Math.Round(probability * 100, 2);
evt.Distance = distance;
evt.Pokeball = pokeball;
evt.Attempt = attemptCounter;
await session.Inventory.RefreshCachedInventory();
evt.BallAmount = await session.Inventory.GetItemAmountByType(pokeball);
evt.Rarity = PokemonGradeHelper.GetPokemonGrade(evt.Id).ToString();
session.EventDispatcher.Send(evt);
attemptCounter++;
DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 0);
} while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed ||
caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
session.Actions.RemoveAll(x => x == Model.BotActions.Catch);
if (session.LogicSettings.TransferDuplicatePokemonOnCapture &&
session.LogicSettings.TransferDuplicatePokemon &&
sessionAllowTransfer &&
caughtPokemonResponse != null &&
caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
if (session.LogicSettings.UseNearActionRandom)
{
await HumanRandomActionTask.TransferRandom(session, cancellationToken);
}
else
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
}
}
}
