// todo please please please change this
private static void FigureTypeBalances(ref PokemonInfo info ,pokemonType type)
{
switch (type) {
case pokemonType.fire:
info.weak.Add (pokemonType.water);
info.weak.Add (pokemonType.rock);
info.resistant.Add (pokemonType.grass);
info.resistant.Add (pokemonType.ghost);
break;
case pokemonType.water:
info.weak.Add (pokemonType.grass);
info.weak.Add (pokemonType.electric);
info.resistant.Add (pokemonType.fire);
info.resistant.Add (pokemonType.water);
info.resistant.Add (pokemonType.rock);
break;
case pokemonType.grass:
info.weak.Add (pokemonType.fire);
info.weak.Add (pokemonType.normal);
info.resistant.Add (pokemonType.water);
info.resistant.Add (pokemonType.grass);
info.resistant.Add (pokemonType.electric);
break;
case pokemonType.ghost:
info.weak.Add (pokemonType.fire);
info.weak.Add (pokemonType.ghost); // todo i dont want types countering itself
info.weak.Add (pokemonType.electric);
info.weak.Add (pokemonType.psychic);
info.immune.Add (pokemonType.normal);
info.immune.Add (pokemonType.fighting);
break;
case pokemonType.normal:
info.weak.Add (pokemonType.normal); // todo, again dont want types countering itself
break;
case pokemonType.electric:
info.weak.Add (pokemonType.fighting);
break;
case pokemonType.psychic:
info.weak.Add (pokemonType.ghost);
info.weak.Add (pokemonType.rock);
info.resistant.Add (pokemonType.psychic);
break;
case pokemonType.fighting:
info.weak.Add (pokemonType.psychic);
info.resistant.Add (pokemonType.rock);
break;
default:
break;
}
}
public AttackInfo(int teamId, pokemonType type, float dmg, PokemonInfo pokemon, PlayerInfo player, System.Action<HitInfo> hitcallback, System.Action<HitInfo> killcallback)
{
this.teamId = teamId;
this.type = type;
this.damage = dmg;
this.pokemon = pokemon;
this.player = player;
this.hitCallback = hitcallback;
this.killCallback = killcallback;
}
public HitInfo(float dmg, float weakDmg, float resistBlock, bool isDead, float xp, PokemonInfo pokemon, PlayerInfo player)
{
this.totalDmgDealt = dmg;
this.weaknessDmg = weakDmg;
this.resistantLoss = resistBlock;
this.killed = isDead;
this.xpGiven = xp;
this.pokemon = pokemon;
this.player = player;
}
public void prepSprite(PokemonInfo pokemon, PlayerInfo player = default(PlayerInfo))
{
// Set weaknesses/resistances
hp.weakAgainst = new List<pokemonType> (pokemon.weak);
hp.resistantTo = new List<pokemonType> (pokemon.resistant);
// Set animation controller
an.runtimeAnimatorController = pokemon.animator;
// set attack controller info
ac.pokemonInfo = pokemon;
ac.prepareProjectilePool ();
}
public override void spawnMyCharacter(PokemonInfo pokemon)
{
if (myCharacter == null) { // If this is the first time spawning, create a new guy
GameObject playerGO = (GameObject)Instantiate (playerPrefab, Vector3.zero, Quaternion.identity);
playerGO.GetComponent<TeamMember> ().teamId = currentTeamId++;
playerGO.tag = "Player";
setCameraToFollowObject (playerGO.transform);
myCharacter = playerGO;
}
myCharacter.GetComponent<PlayerSprite> ().prepSprite (pokemon);
myCharacter.transform.position = getRandomSpawnPoint ();
}
public static PokemonInfo create(string _name, pokemonType _type, string portraitName = default(string), string animatorName = default(string))
{
PokemonInfo info = new PokemonInfo();
// set basic vars
info.name = _name;
info.type = _type;
info.level = 0;
// set portraits
if (portraitName == default(string)) {
portraitName = info.name.ToLower ().Substring (0, 4) + "_port";
}
if (animatorName == default(string)) {
animatorName = info.name.ToLower ().Substring (0, 4) + "_anim";
}
info.portrait = (Texture)Resources.Load ("pokemon/" + info.name + "/" + portraitName);
info.animator = Resources.Load ("pokemon/" + info.name + "/" + animatorName) as RuntimeAnimatorController;
// set type balances
info.weak = new List<pokemonType>();
info.resistant = new List<pokemonType> ();
info.immune = new List<pokemonType> ();
FigureTypeBalances(ref info, info.type);
// get attack animators
loadAttackAnimators (ref info, info.type);
// get icons
info.typeIcon = (Texture)Resources.Load("images/icons/bigCircle/"+_type.ToString().ToLower());
info.weakIcons = new List<Texture> ();
info.resistantIcons = new List<Texture> ();
for (int i = 0; i < info.weak.Count; i++) {
info.weakIcons.Add ((Texture)Resources.Load ("images/icons/bigCircle/" + info.weak [i].ToString ().ToLower ()));
}
for (int i = 0; i < info.resistant.Count; i++) {
info.resistantIcons.Add ((Texture)Resources.Load ("images/icons/bigCircle/" + info.resistant [i].ToString ().ToLower ()));
}
return info;
}
public virtual void spawnMyCharacter (PokemonInfo info)
{
}
private async void Execute()
{
EnabledButton(false, "Reloading Pokemon list.");
await check();
try
{
client = Logic.Logic._client;
if (client.readyToUse != false)
{
profile = await client.Player.GetPlayer();
inventory = await client.Inventory.GetInventory();
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 imageSize = 50;
var imageList = new ImageList {
ImageSize = new Size(imageSize, imageSize)
};
PokemonListView.ShowItemToolTips = true;
PokemonListView.SmallImageList = imageList;
var templates = await client.Download.GetItemTemplates();
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();
PokemonListView.DoubleBuffered(true);
PokemonListView.View = View.Details;
ColumnHeader columnheader;
columnheader = new ColumnHeader();
columnheader.Text = "Name";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "CP";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "IV A-D-S";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "LVL";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "Evolvable?";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "Height";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "Weight";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "HP";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "Attack";
PokemonListView.Columns.Add(columnheader);
columnheader = new ColumnHeader();
columnheader.Text = "SpecialAttack (DPS)";
PokemonListView.Columns.Add(columnheader);
foreach (var pokemon in pokemons)
{
Bitmap pokemonImage = null;
await Task.Run(() =>
{
pokemonImage = GetPokemonImage((int)pokemon.PokemonId);
});
imageList.Images.Add(pokemon.PokemonId.ToString(), pokemonImage);
PokemonListView.LargeImageList = imageList;
var listViewItem = new ListViewItem();
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));
listViewItem.SubItems.Add(string.Format("{0}% {1}-{2}-{3}", PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00"), pokemon.IndividualAttack, pokemon.IndividualDefense, pokemon.IndividualStamina));
listViewItem.SubItems.Add(string.Format("{0}", PokemonInfo.GetLevel(pokemon)));
listViewItem.ImageKey = pokemon.PokemonId.ToString();
listViewItem.Text = string.Format((pokemon.Favorite == 1) ? "{0} ★" : "{0}", StringUtils.getPokemonNameByLanguage(ClientSettings, (PokemonId)pokemon.PokemonId));
listViewItem.ToolTipText = new DateTime((long)pokemon.CreationTimeMs * 10000).AddYears(1769).ToString("dd/MM/yyyy HH:mm:ss");
if (pokemon.Nickname != "")
{
listViewItem.ToolTipText += "\nNickname: " + 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("Y (" + familyCandy.Candy_ + "/" + settings.CandyToEvolve + ")");
listViewItem.Checked = true;
}
else
{
if (settings.EvolutionIds.Count > 0)
{
listViewItem.SubItems.Add("N (" + familyCandy.Candy_ + "/" + settings.CandyToEvolve + ")");
}
else
{
listViewItem.SubItems.Add("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)));
PokemonListView.Items.Add(listViewItem);
}
PokemonListView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
Text = "Pokemon List | User: "******" | Pokemons: " + pokemons.Count() + "/" + profile.PlayerData.MaxPokemonStorage;
EnabledButton(true);
statusTexbox.Text = string.Empty;
}
}
catch (Exception e)
{
Logger.Error("[PokemonList-Error] " + e.StackTrace);
await Task.Delay(1000); // Lets the API make a little pause, so we dont get blocked
Execute();
}
}
private static void loadAttackAnimators(ref PokemonInfo info, pokemonType type)
{
switch (type) {
case pokemonType.fire:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/FireBlast") as RuntimeAnimatorController;
break;
case pokemonType.water:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Water") as RuntimeAnimatorController;
break;
case pokemonType.grass:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Grass") as RuntimeAnimatorController;
break;
case pokemonType.ghost:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Ghost") as RuntimeAnimatorController;
break;
case pokemonType.normal:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Normal") as RuntimeAnimatorController;
break;
case pokemonType.electric:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Electric") as RuntimeAnimatorController;
break;
case pokemonType.psychic:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Psychic") as RuntimeAnimatorController;
break;
case pokemonType.fighting:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Fighting") as RuntimeAnimatorController;
break;
case pokemonType.rock:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Rock") as RuntimeAnimatorController;
break;
default:
info.attackAnimator = Resources.Load ("attacks/AttackAnimation/Fighting") as RuntimeAnimatorController;
break;
}
}
public double GetPerfect(PokemonData poke)
{
var result = PokemonInfo.CalculatePokemonPerfection(poke);
return(result);
}
public static async Task Snipe(ISession session, IEnumerable <PokemonId> pokemonIds, double latitude,
double longitude, CancellationToken cancellationToken)
{
if (LocsVisited.Contains(new PokemonLocation(latitude, longitude)))
{
return;
}
var CurrentLatitude = session.Client.CurrentLatitude;
var CurrentLongitude = session.Client.CurrentLongitude;
var catchedPokemon = false;
session.EventDispatcher.Send(new SnipeModeEvent {
Active = true
});
List <MapPokemon> catchablePokemon;
try
{
await session.Client.Player.UpdatePlayerLocation(latitude, longitude, session.Client.CurrentAltitude);
session.EventDispatcher.Send(new UpdatePositionEvent
{
Longitude = longitude,
Latitude = latitude
});
var mapObjects = session.Client.Map.GetMapObjects().Result;
catchablePokemon =
mapObjects.Item1.MapCells.SelectMany(q => q.CatchablePokemons)
.Where(q => pokemonIds.Contains(q.PokemonId))
.OrderByDescending(pokemon => PokemonInfo.CalculateMaxCpMultiplier(pokemon.PokemonId))
.ToList();
}
finally
{
await session.Client.Player.UpdatePlayerLocation(CurrentLatitude, CurrentLongitude, session.Client.CurrentAltitude);
}
if (catchablePokemon.Count == 0)
{
// Pokemon not found but we still add to the locations visited, so we don't keep sniping
// locations with no pokemon.
if (!LocsVisited.Contains(new PokemonLocation(latitude, longitude)))
{
LocsVisited.Add(new PokemonLocation(latitude, longitude));
}
}
foreach (var pokemon in catchablePokemon)
{
EncounterResponse encounter;
try
{
await session.Client.Player.UpdatePlayerLocation(latitude, longitude, session.Client.CurrentAltitude);
encounter = session.Client.Encounter.EncounterPokemon(pokemon.EncounterId, pokemon.SpawnPointId).Result;
}
finally
{
await session.Client.Player.UpdatePlayerLocation(CurrentLatitude, CurrentLongitude, session.Client.CurrentAltitude);
}
if (encounter.Status == EncounterResponse.Types.Status.EncounterSuccess)
{
if (!LocsVisited.Contains(new PokemonLocation(latitude, longitude)))
{
LocsVisited.Add(new PokemonLocation(latitude, longitude));
}
//Also add exact pokemon location to LocsVisited, some times the server one differ a little.
if (!LocsVisited.Contains(new PokemonLocation(pokemon.Latitude, pokemon.Longitude)))
{
LocsVisited.Add(new PokemonLocation(pokemon.Latitude, pokemon.Longitude));
}
session.EventDispatcher.Send(new UpdatePositionEvent
{
Latitude = CurrentLatitude,
Longitude = CurrentLongitude
});
await CatchPokemonTask.Execute(session, cancellationToken, encounter, pokemon);
catchedPokemon = true;
}
else if (encounter.Status == EncounterResponse.Types.Status.PokemonInventoryFull)
{
if (session.LogicSettings.EvolveAllPokemonAboveIv ||
session.LogicSettings.EvolveAllPokemonWithEnoughCandy ||
session.LogicSettings.UseLuckyEggsWhileEvolving ||
session.LogicSettings.KeepPokemonsThatCanEvolve)
{
await EvolvePokemonTask.Execute(session, cancellationToken);
}
if (session.LogicSettings.TransferDuplicatePokemon)
{
await TransferDuplicatePokemonTask.Execute(session, cancellationToken);
}
else
{
session.EventDispatcher.Send(new WarnEvent
{
Message = session.Translation.GetTranslation(TranslationString.InvFullTransferManually)
});
}
}
else
{
session.EventDispatcher.Send(new WarnEvent
{
Message =
session.Translation.GetTranslation(
TranslationString.EncounterProblem, encounter.Status)
});
}
if (!Equals(catchablePokemon.ElementAtOrDefault(catchablePokemon.Count - 1), pokemon))
{
await Task.Delay(session.LogicSettings.DelayBetweenPokemonCatch, cancellationToken);
}
}
if (!catchedPokemon)
{
session.EventDispatcher.Send(new SnipeEvent
{
Message = session.Translation.GetTranslation(TranslationString.NoPokemonToSnipe)
});
}
_lastSnipe = DateTime.Now;
if (catchedPokemon)
{
session.Stats.SnipeCount++;
session.Stats.LastSnipeTime = _lastSnipe;
}
session.EventDispatcher.Send(new SnipeModeEvent {
Active = false
});
await Task.Delay(session.LogicSettings.DelayBetweenPlayerActions, cancellationToken);
}
public async Task <IEnumerable <PokemonData> > GetDuplicatePokemonToTransfer(
IEnumerable <PokemonId> pokemonsNotToTransfer, IEnumerable <PokemonId> pokemonsToEvolve,
bool keepPokemonsThatCanEvolve = false, bool prioritizeIVoverCp = false
)
{
var myPokemon = GetPokemons();
var pokemonToTransfer = myPokemon
.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 (ActiveSwitchByRuleException e)
{
throw e;
}
catch (Exception)
{
//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 = 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);
var settings = pokemonSettings.FirstOrDefault(x => x.PokemonId == pokemonGroupToTransfer.Key);
if (settings != null &&
pokemonsToEvolve.Contains(pokemonGroupToTransfer.Key) &&
settings.CandyToEvolve > 0 &&
settings.EvolutionIds.Count != 0)
{
var familyCandy = pokemonFamilies.FirstOrDefault(x => settings.FamilyId == x.FamilyId);
if (familyCandy != null)
{
// Calculate the number of evolutions possible (taking into account +1 candy for evolve and +1 candy for transfer)
var evolutionCalcs = CalculatePokemonEvolution(canBeRemoved, familyCandy.Candy_, settings.CandyToEvolve, 1); // 1 for candy gain after evolution
// Subtract the number of evolutions possible from the number that can be transferred.
canBeRemoved -= evolutionCalcs.Evolves;
}
}
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 async Task <IEnumerable <PokemonData> > GetPokemonToTransfer(IEnumerable <PokemonData> myPokemon, ISettings settings, bool keepPokemonsThatCanEvolve = false, bool prioritizeIVoverCp = false, IEnumerable <PokemonId> filter = null)
{
IEnumerable <ulong> keepPokemonsList = new List <ulong>();
// Get a list of all Max CP pokemon
IEnumerable <ulong> maxCPPokemon = myPokemon.GroupBy(p => p.PokemonId)
.Where(x => x.Any())
.SelectMany(
p =>
p.OrderByDescending(x => x.Cp)
.ThenBy(n => n.StaminaMax)
.Take(settings.TransferPokemonKeepDuplicateAmountMaxCP)
.Select(n => n.Id)
.ToList());
// Add them to the keep list
keepPokemonsList = keepPokemonsList.Union(maxCPPokemon);
// Get a list of all Max IV pokemon
IEnumerable <ulong> maxIVPokemon = myPokemon.GroupBy(p => p.PokemonId)
.Where(x => x.Any())
.SelectMany(
p =>
p.OrderByDescending(x => PokemonInfo.CalculatePokemonPerfection(x))
.ThenBy(n => n.StaminaMax)
.Take(settings.TransferPokemonKeepDuplicateAmountMaxIV)
.Select(n => n.Id)
.ToList());
// Add them to the keep list
keepPokemonsList = keepPokemonsList.Union(maxIVPokemon);
// All pokemon that are not in my favourites list and are not currently deployed to a fort
IEnumerable <ulong> pokemonInFortsAndFavourites = myPokemon.Where(p => p.DeployedFortId != 0 && p.Favorite != 0).Select(n => n.Id).ToList();
// Add them to the keep list
keepPokemonsList = keepPokemonsList.Union(pokemonInFortsAndFavourites);
// Do we want to keep any that can evolve?
if (keepPokemonsThatCanEvolve)
{
List <ulong> keepEvolveList = new List <ulong>();
var pokemonsThatCanBeTransfered = myPokemon.GroupBy(p => p.PokemonId).ToList();
var myPokemonSettings = await GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
foreach (var pokemon in pokemonsThatCanBeTransfered)
{
var individualPokemonsettings = pokemonSettings.Single(x => x.PokemonId == pokemon.Key);
var familyCandy = pokemonFamilies.Single(x => individualPokemonsettings.FamilyId == x.FamilyId);
int amountToSkip = 0;
if (individualPokemonsettings.CandyToEvolve > 0)
{
amountToSkip = familyCandy.Candy / individualPokemonsettings.CandyToEvolve;
}
keepEvolveList.AddRange(myPokemon.Where(x => x.PokemonId == pokemon.Key)
.OrderByDescending(
x => (prioritizeIVoverCp) ? PokemonInfo.CalculatePokemonPerfection(x) : x.Cp)
.ThenBy(n => n.StaminaMax)
.Take(amountToSkip)
.Select(n => n.Id)
.ToList());
}
// Add the list of pokemons to keep for evolving
keepPokemonsList = keepPokemonsList.Union(keepEvolveList);
}
// Keep any that are on my NotToTransfer list
if (settings.UsePokemonToNotTransferList && filter != null)
{
keepPokemonsList = keepPokemonsList.Union(myPokemon.Where(p => filter.Contains(p.PokemonId)).Select(n => n.Id).ToList());
}
// Keep any that have CP higher than my KeepAboveCP setting
if (settings.UseTransferPokemonKeepAboveCP)
{
keepPokemonsList = keepPokemonsList.Union(myPokemon.Where(p => p.Cp < settings.TransferPokemonKeepAboveCP).Select(n => n.Id).ToList());
}
// Keep any that have higher IV than my KeepAboveIV setting
if (settings.UseTransferPokemonKeepAboveIV)
{
var aboveMaxIVList = myPokemon.Where(p => PokemonInfo.CalculatePokemonPerfection(p) >= settings.TransferPokemonKeepAboveIVPercentage).Select(n => n.Id).ToList();
keepPokemonsList = keepPokemonsList.Union(aboveMaxIVList);
}
// Remove any that are not in my Keep list
IEnumerable <PokemonData> pokemonList = myPokemon.Where(p => !keepPokemonsList.Contains(p.Id)).ToList();
return(pokemonList);
}
public static async Task Execute(ISession session, dynamic encounter, MapPokemon pokemon,
FortData currentFortData = null, ulong encounterId = 0)
{
CatchPokemonResponse caughtPokemonResponse;
var attemptCounter = 1;
do
{
if (session.LogicSettings.MaxPokeballsPerPokemon > 0 &&
attemptCounter > session.LogicSettings.MaxPokeballsPerPokemon)
{
break;
}
float probability = encounter?.CaptureProbability?.CaptureProbability_[0];
var 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
});
return;
}
var isLowProbability = probability < 0.35;
var isHighCp = encounter != null &&
(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData?.Cp
: encounter.PokemonData?.Cp) > 400;
var isHighPerfection =
PokemonInfo.CalculatePokemonPerfection(encounter is EncounterResponse
? encounter.WildPokemon?.PokemonData
: encounter?.PokemonData) >= session.LogicSettings.KeepMinIvPercentage;
if ((isLowProbability && isHighCp) || isHighPerfection)
{
await
UseBerry(session,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.EncounterId
: encounterId,
encounter is EncounterResponse || encounter is IncenseEncounterResponse
?pokemon.SpawnPointId
: currentFortData?.Id);
}
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);
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 evt = new PokemonCaptureEvent {
Status = caughtPokemonResponse.Status
};
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();
}
}
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);
}
public override async Task <bool> OnCommand(ISession session, string cmd, Action <string> callback)
{
var commandMatch = Match(cmd, CommandParseRegex);
if (!commandMatch.Success)
{
return(false);
}
// Parse orderBy
var orderBy = string.IsNullOrEmpty(commandMatch.Groups["orderBy"].Value)
? DefaultOrderBy
: commandMatch.Groups["orderBy"].Value;
var allPokemonCount = (await session.Inventory.GetPokemons()).Count();
// Get all Pokemon and 'orderBy' -> will never be null
var topPokemon = string.Equals("iv", orderBy)
? await session.Inventory.GetHighestsPerfect(allPokemonCount)
: await session.Inventory.GetHighestsCp(allPokemonCount);
var topPokemonList = topPokemon as IList <PokemonData> ?? topPokemon.ToList();
var answerTextmessage = GetMsgHead(session, session.Profile.PlayerData.Username, topPokemonList.Count) + "\r\n\r\n";
answerTextmessage = topPokemonList.Aggregate(answerTextmessage, (current, pokemon)
=> current + session.Translation.GetTranslation(
TranslationString.ShowPokeSkillTemplate,
pokemon.Cp,
PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00"),
session.Translation.GetPokemonMovesetTranslation(PokemonInfo.GetPokemonMove1(pokemon)),
session.Translation.GetPokemonMovesetTranslation(PokemonInfo.GetPokemonMove2(pokemon)),
session.Translation.GetPokemonTranslation(pokemon.PokemonId)
)
);
callback(answerTextmessage);
return(true);
}
public VenueMessageHandler(PokemonInfo pokemonInfo, GymHelper gymHelper, DateTimeZone dateTimeZone)
{
myPokemonInfo = pokemonInfo;
myGymHelper = gymHelper;
myDateTimeZone = dateTimeZone;
}
public static async Task Execute(ISession session)
{
var highestsPokemonCp = await
session.Inventory.GetHighestsCp(session.LogicSettings.AmountOfPokemonToDisplayOnStart).ConfigureAwait(false);
var pokemonPairedWithStatsCp =
highestsPokemonCp.Select(
pokemon =>
Tuple.Create(
pokemon,
PokemonInfo.CalculateMaxCp(pokemon.PokemonId),
PokemonInfo.CalculatePokemonPerfection(pokemon),
PokemonInfo.GetLevel(pokemon),
PokemonInfo.GetPokemonMove1(pokemon),
PokemonInfo.GetPokemonMove2(pokemon),
PokemonInfo.GetCandy(session, pokemon).Result
)
)
.ToList();
var highestsPokemonPerfect = await
session.Inventory.GetHighestsPerfect(session.LogicSettings.AmountOfPokemonToDisplayOnStart).ConfigureAwait(false);
var pokemonPairedWithStatsIv =
highestsPokemonPerfect.Select(
pokemon =>
Tuple.Create(
pokemon,
PokemonInfo.CalculateMaxCp(pokemon.PokemonId),
PokemonInfo.CalculatePokemonPerfection(pokemon),
PokemonInfo.GetLevel(pokemon),
PokemonInfo.GetPokemonMove1(pokemon),
PokemonInfo.GetPokemonMove2(pokemon),
PokemonInfo.GetCandy(session, pokemon).Result
)
)
.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).ConfigureAwait(false)
: await session.Inventory.GetHighestsCp(1000).ConfigureAwait(false);
if (session.LogicSettings.DumpPokemonStats)
{
const string dumpFileName = "PokeBagStats";
try
{
Dumper.ClearDumpFile(session, dumpFileName);
string[] data =
{
"Pokemon",
"Slashed",
"Level",
"CP",
"IV",
"Stamina",
"Stamina Max",
"Move1",
"Move2",
"Candies",
"Owner Name",
"Origin",
"Height(M)",
"Weight(KG)",
"Attack",
"Defense",
"Stamina",
"CP Multi",
"Gyms Attacked",
"Gyms Defended",
"Creationtimems",
"Power Ups",
"Additional CP Multi",
"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),
pokemon.IsBad.ToString(),
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(session, pokemon).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."
}
);
}
}
}
private static void TransferDuplicatePokemon(bool keepPokemonsThatCanEvolve = false, bool transferFirstLowIv = false)
{
if (Shared.GlobalVars.RelocateDefaultLocation)
{
return;
}
if (Shared.GlobalVars.TransferDoublePokemons)
{
var profil = Logic.objClient.Player.GetPlayer();
RandomHelper.RandomSleep(300, 400);
if (Shared.GlobalVars.pauseAtEvolve2)
{
Logger.ColoredConsoleWrite(ConsoleColor.Green, "Stopping to transfer some Pokemons.");
Shared.GlobalVars.PauseTheWalking = true;
}
TransferUnwantedPokemon(profil.PlayerData.BuddyPokemon.Id);
var duplicatePokemons = Logic.objClient.Inventory.GetDuplicatePokemonToTransfer(Shared.GlobalVars.HoldMaxDoublePokemons, keepPokemonsThatCanEvolve, transferFirstLowIv);
var pokemonsToTransfer = new List <ulong>();
foreach (var duplicatePokemon in duplicatePokemons)
{
var Pokename = duplicatePokemon.PokemonId.ToString();
var IVPercent = PokemonInfo.CalculatePokemonPerfection(duplicatePokemon).ToString("0.00");
if (!Shared.GlobalVars.pokemonsToHold.Contains(duplicatePokemon.PokemonId))
{
if (duplicatePokemon.Cp >= Shared.GlobalVars.DontTransferWithCPOver || PokemonInfo.CalculatePokemonPerfection(duplicatePokemon) >= Shared.GlobalVars.ivmaxpercent)
{
continue; // go to next itearion from foreach
}
if (profil.PlayerData.BuddyPokemon.Id == duplicatePokemon.Id)
{
Logger.Warning($"Pokemon {Pokename} with {IVPercent}% IV Is your buddy so can not be transfered");
continue;// go to next itearion from foreach
}
var bestPokemonOfType = Logic.objClient.Inventory.GetHighestCPofType(duplicatePokemon);
var bestPokemonsCpOfType = Logic.objClient.Inventory.GetHighestCPofType2(duplicatePokemon);
var bestPokemonsIvOfType = Logic.objClient.Inventory.GetHighestIVofType(duplicatePokemon);
pokemonsToTransfer.Add(duplicatePokemon.Id);
var logs = Path.Combine(logPath, "TransferLog.txt");
var date = DateTime.Now.ToString();
if (transferFirstLowIv)
{
var BestIV = PokemonInfo.CalculatePokemonPerfection(bestPokemonsIvOfType.First()).ToString("0.00");
if (Shared.GlobalVars.LogTransfer)
{
File.AppendAllText(logs, $"[{date}] - Transfer {Pokename} CP {duplicatePokemon.Cp} IV {IVPercent} % (Your best is: {BestIV}% IV)" + Environment.NewLine);
}
Logger.ColoredConsoleWrite(ConsoleColor.Yellow, $"Enqueuing to BULK Transfer {Pokename} CP {duplicatePokemon.Cp} IV {IVPercent} % (Your best is: {BestIV}% IV)");
}
else
{
if (Shared.GlobalVars.LogTransfer)
{
File.AppendAllText(logs, $"[{date}] - Transfer {Pokename} CP {duplicatePokemon.Cp} IV {IVPercent} % (Best: {bestPokemonsCpOfType.First().Cp} CP)" + Environment.NewLine);
}
Logger.ColoredConsoleWrite(ConsoleColor.Yellow, $"Enqueuing to BULK Transfer {Pokename} CP {duplicatePokemon.Cp} IV {IVPercent} % (Best: {bestPokemonsCpOfType.First().Cp} CP)");
}
if (Logic.Instance.Telegram != null)
{
Logic.Instance.Telegram.sendInformationText(TelegramUtil.TelegramUtilInformationTopics.Transfer, StringUtils.getPokemonNameByLanguage(duplicatePokemon.PokemonId), duplicatePokemon.Cp, PokemonInfo.CalculatePokemonPerfection(duplicatePokemon).ToString("0.00"), bestPokemonOfType);
}
RandomHelper.RandomSleep(400, 600);
}
}
if (pokemonsToTransfer.Any())
{
var _response = Logic.objClient.Inventory.TransferPokemon(pokemonsToTransfer);
if (_response.Result == ReleasePokemonResponse.Types.Result.Success)
{
Logger.ColoredConsoleWrite(ConsoleColor.Yellow, "Transfer Successful of " + pokemonsToTransfer.Count + " pokemons => " + _response.CandyAwarded + ((_response.CandyAwarded == 1) ? " candy" : " candies") + " awarded.", LogLevel.Info);
Helpers.RandomHelper.RandomSleep(1000, 2000);
}
else
{
Logger.ColoredConsoleWrite(ConsoleColor.Red, $"Something happened while transferring pokemons.");
}
if (Shared.GlobalVars.pauseAtEvolve2)
{
Logger.ColoredConsoleWrite(ConsoleColor.Green, "Pokemons transfered. Time to continue our journey!");
Shared.GlobalVars.PauseTheWalking = false;
}
}
}
}
private static void StartIncubation()
{
try
{
if (Shared.GlobalVars.RelocateDefaultLocation)
{
return;
}
var inventory = Logic.objClient.Inventory.GetInventory();
var incubators = Logic.objClient.Inventory.GetEggIncubators().ToList();
var unusedEggs = (Logic.objClient.Inventory.GetEggs()).Where(x => string.IsNullOrEmpty(x.EggIncubatorId)).OrderBy(x => x.EggKmWalkedTarget - x.EggKmWalkedStart).ToList();
var pokemons = (Logic.objClient.Inventory.GetPokemons()).ToList();
var playerStats = Logic.objClient.Inventory.GetPlayerStats();
var stats = playerStats.First();
var kmWalked = stats.KmWalked;
var logs = Path.Combine(logPath, "EggLog.txt");
var date = DateTime.Now.ToString();
var unusedEggsBasicInc = eggsHatchingAllowedBasicInc(unusedEggs);
var unusedEggsUnlimitInc = eggsHatchingAllowed(unusedEggs);
foreach (var incubator in rememberedIncubators)
{
var hatched = pokemons.FirstOrDefault(x => !x.IsEgg && x.Id == incubator.PokemonId);
if (hatched == null)
{
continue;
}
if (Shared.GlobalVars.LogEggs)
{
var MaxCP = PokemonInfo.CalculateMaxCP(hatched);
var Level = PokemonInfo.GetLevel(hatched);
var IVPercent = PokemonInfo.CalculatePokemonPerfection(hatched).ToString("0.00");
File.AppendAllText(logs, $"[{date}] - Egg hatched and we got a {hatched.PokemonId} (CP: {hatched.Cp} | MaxCP: {MaxCP} | Level: {Level} | IV: {IVPercent}% )" + Environment.NewLine);
}
Logger.ColoredConsoleWrite(ConsoleColor.DarkYellow, "Egg hatched and we got a " + hatched.PokemonId + " CP: " + hatched.Cp + " MaxCP: " + PokemonInfo.CalculateMaxCP(hatched) + " Level: " + PokemonInfo.GetLevel(hatched) + " IV: " + PokemonInfo.CalculatePokemonPerfection(hatched).ToString("0.00") + "%");
}
if ((unusedEggsUnlimitInc.Count < 1) && (unusedEggsUnlimitInc.Count < 1))
{
Logger.ColoredConsoleWrite(ConsoleColor.DarkYellow, "There is not Allowed Eggs to hatch");
return;
}
var newRememberedIncubators = new List <IncubatorUsage>();
foreach (EggIncubator incubator in incubators)
{
if (incubator.PokemonId == 0)
{
// If is basic incubator and user don't want use it, we go to the next incubator
if ((incubator.ItemId == ItemId.ItemIncubatorBasic) &&
(!Shared.GlobalVars.UseBasicIncubators))
{
continue;
}
POGOProtos.Data.PokemonData egg;
if (incubator.ItemId == ItemId.ItemIncubatorBasic)
{
egg = Shared.GlobalVars.EggsAscendingSelectionBasicInc ? unusedEggsBasicInc.FirstOrDefault() : unusedEggsBasicInc.LastOrDefault();
}
else
{
egg = Shared.GlobalVars.EggsAscendingSelection ? unusedEggsUnlimitInc.FirstOrDefault() : unusedEggsUnlimitInc.LastOrDefault();
}
// If there is not eggs then we finish this function
if (egg == null)
{
return;
}
var response = Logic.objClient.Inventory.UseItemEggIncubator(incubator.Id, egg.Id);
try
{
unusedEggsUnlimitInc.Remove(egg);
unusedEggsBasicInc.Remove(egg);
}
catch (Exception ex) {
Logger.ColoredConsoleWrite(ConsoleColor.Red, "Error: Logic.cs - StartIncubation()");
Logger.ColoredConsoleWrite(ConsoleColor.Red, ex.Message);
}
newRememberedIncubators.Add(new IncubatorUsage {
IncubatorId = incubator.Id, PokemonId = egg.Id
});
Logger.ColoredConsoleWrite(ConsoleColor.DarkYellow, "Added Egg which needs " + egg.EggKmWalkedTarget + "km");
// We need some sleep here or this shit explodes
RandomHelper.RandomSleep(100, 200);
}
else
{
newRememberedIncubators.Add(new IncubatorUsage
{
IncubatorId = incubator.Id,
PokemonId = incubator.PokemonId
});
Logger.ColoredConsoleWrite(ConsoleColor.DarkYellow, "Egg (" + (incubator.TargetKmWalked - incubator.StartKmWalked) + "km) need to walk " + Math.Round(incubator.TargetKmWalked - kmWalked, 2) + " km.");
}
}
if (!newRememberedIncubators.SequenceEqual(rememberedIncubators))
{
rememberedIncubators = newRememberedIncubators;
}
}
catch (Exception ex)
{
// Leave this here: Logger.Error(e.StackTrace);
Logger.ColoredConsoleWrite(ConsoleColor.DarkYellow, "Egg: We dont have any eggs we could incubate.");
Logger.ColoredConsoleWrite(ConsoleColor.Red, ex.Message);
}
}
private static void EvolveAllPokemonWithEnoughCandy(IEnumerable <PokemonId> filter)
{
int evolvecount = 0;
int gotXP = 0;
if (Shared.GlobalVars.RelocateDefaultLocation)
{
return;
}
EvolvePokemonResponse evolvePokemonOutProto;
var pokemonToEvolve = Logic.objClient.Inventory.GetPokemonToEvolve(true, filter);
var toEvolveCount = pokemonToEvolve.Count();
var startEvolving = (toEvolveCount == 0 || toEvolveCount == Shared.GlobalVars.EvolveAt);
if (startEvolving && Shared.GlobalVars.UseLuckyEgg)
{
Logic.objClient.Inventory.UseLuckyEgg(Logic.objClient);
}
foreach (var pokemon in pokemonToEvolve)
{
var item = Inventory.GeteNeededItemToEvolve(pokemon.PokemonId);
if (item != ItemId.ItemUnknown && Logic.objClient.Inventory.GetItemAmountByType(item) < 1)
{
if (pokemon.PokemonId == PokemonId.Poliwhirl ||
pokemon.PokemonId == PokemonId.Gloom
)
{
item = ItemId.ItemUnknown; // try to evolve without items
}
else
{
continue; // go to next pokemon
}
}
evolvePokemonOutProto = Logic.objClient.Inventory.EvolvePokemon(pokemon.Id, item);
if (evolvePokemonOutProto == null)
{
continue;
}
var date = DateTime.Now.ToString();
var evolvelog = Path.Combine(logPath, "EvolveLog.txt");
var getPokemonName = pokemon.PokemonId.ToString();
var cp = pokemon.Cp;
var calcPerf = PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00");
var getEvolvedName = StringUtils.getPokemonNameByLanguage(evolvePokemonOutProto.EvolvedPokemonData.PokemonId);
var getEvolvedCP = evolvePokemonOutProto.EvolvedPokemonData.Cp;
gotXP = gotXP + evolvePokemonOutProto.ExperienceAwarded;
if (evolvePokemonOutProto.Result == EvolvePokemonResponse.Types.Result.Success)
{
if (evolvecount == 0)
{
if (Shared.GlobalVars.pauseAtEvolve2)
{
Logger.Info("Stopping to evolve some Pokemons.");
Shared.GlobalVars.PauseTheWalking = true;
}
}
var experienceAwarded = evolvePokemonOutProto.ExperienceAwarded.ToString("N0");
if (Shared.GlobalVars.LogEvolve)
{
File.AppendAllText(evolvelog, $"[{date}] - Evolved Pokemon: {getPokemonName} | CP {cp} | Perfection {calcPerf}% | => to {getEvolvedName} | CP: {getEvolvedCP} | XP Reward: {experienceAwarded} XP" + Environment.NewLine);
}
Logger.Info($"Evolved Pokemon: {getPokemonName} | CP {cp} | Perfection {calcPerf}% | => to {getEvolvedName} | CP: {getEvolvedCP} | XP Reward: {experienceAwarded} XP");
Logic.Instance.BotStats.AddExperience(evolvePokemonOutProto.ExperienceAwarded);
if (Logic.Instance.Telegram != null)
{
Logic.Instance.Telegram.sendInformationText(TelegramUtil.TelegramUtilInformationTopics.Evolve, StringUtils.getPokemonNameByLanguage(pokemon.PokemonId), pokemon.Cp, PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00"), StringUtils.getPokemonNameByLanguage(evolvePokemonOutProto.EvolvedPokemonData.PokemonId), evolvePokemonOutProto.EvolvedPokemonData.Cp, evolvePokemonOutProto.ExperienceAwarded.ToString("N0"));
}
evolvecount++;
}
else
{
if (evolvePokemonOutProto.Result != EvolvePokemonResponse.Types.Result.Success)
{
if (Shared.GlobalVars.LogEvolve)
{
File.AppendAllText(evolvelog, $"[{date}] - Failed to evolve {pokemon.PokemonId}. EvolvePokemonOutProto.Result was {evolvePokemonOutProto.Result}" + Environment.NewLine);
}
Logger.ColoredConsoleWrite(ConsoleColor.Red, $"Failed to evolve {pokemon.PokemonId}. EvolvePokemonOutProto.Result was {evolvePokemonOutProto.Result}");
evolvecount++;
}
}
if (Shared.GlobalVars.UseAnimationTimes)
{
RandomHelper.RandomSleep(30000, 35000);
}
else
{
RandomHelper.RandomSleep(500, 600);
}
}
if (evolvecount > 0)
{
var strGotXP = gotXP.ToString("N0");
Logger.Info($"Evolved {evolvecount} Pokemons. We have got {strGotXP} XP.");
if (Shared.GlobalVars.pauseAtEvolve2)
{
Logger.ColoredConsoleWrite(ConsoleColor.Green, "Pokemons evolved. Time to continue our journey!");
Shared.GlobalVars.PauseTheWalking = false;
}
}
}
public async Task <IEnumerable <PokemonData> > GetPokemonToEvolve(bool prioritizeIVoverCp = false, IEnumerable <PokemonId> filter = null)
{
var myPokemons = await GetPokemons();
myPokemons = myPokemons.Where(p => p.DeployedFortId == 0);
if (filter != null)
{
myPokemons = myPokemons.Where(p => filter.Contains(p.PokemonId));
}
if (_client.Settings.EvolveOnlyPokemonAboveIV)
{
myPokemons = myPokemons.Where(p => PokemonInfo.CalculatePokemonPerfection(p) >= _client.Settings.EvolveOnlyPokemonAboveIVValue);
}
myPokemons = prioritizeIVoverCp ? myPokemons.OrderByDescending(PokemonInfo.CalculatePokemonPerfection) : myPokemons.OrderByDescending(p => p.Cp);
var pokemons = myPokemons.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.Single(x => x.PokemonId == pokemon.PokemonId);
var familyCandy = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId);
//Don't evolve if we can't evolve it
if (settings.EvolutionIds.Count == 0)
{
continue;
}
var pokemonCandyNeededAlready =
pokemonToEvolve.Count(
p => pokemonSettings.Single(x => x.PokemonId == p.PokemonId).FamilyId == settings.FamilyId) *
settings.CandyToEvolve;
var familiecandies = familyCandy.Candy;
if (_client.Settings.EvolveKeepCandiesValue > 0)
{
if (familyCandy.Candy <= _client.Settings.EvolveKeepCandiesValue)
{
continue;
}
familiecandies = familyCandy.Candy - _client.Settings.EvolveKeepCandiesValue;
if (familiecandies - pokemonCandyNeededAlready > settings.CandyToEvolve)
{
pokemonToEvolve.Add(pokemon);
}
}
else if (familiecandies - pokemonCandyNeededAlready > settings.CandyToEvolve)
{
pokemonToEvolve.Add(pokemon);
}
}
return(pokemonToEvolve);
}
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;
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.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);
}
public async Task ExportPokemonToCsv(Profile player, string filename = "PokeList.csv")
{
if (player == null)
{
return;
}
var stats = await GetPlayerStats();
var stat = stats.FirstOrDefault();
if (stat == null)
{
return;
}
if (!Directory.Exists(_exportPath))
{
Directory.CreateDirectory(_exportPath);
}
if (Directory.Exists(_exportPath))
{
try
{
var pokelistFile = Path.Combine(_exportPath, $"Profile_{player.Username}_{filename}");
if (File.Exists(pokelistFile))
{
File.Delete(pokelistFile);
}
var ls = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ListSeparator;
const string header = "PokemonID,Name,NickName,Level,CP / MaxCP,IV Perfection in %,Attack 1,Attack 2,HP,Attk,Def,Stamina,Familie Candies,IsInGym,IsFavorite,previewLink";
File.WriteAllText(pokelistFile, $"{header.Replace(",", $"{ls}")}");
var allPokemon = await GetHighestsPerfect();
var myPokemonSettings = await GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
var trainerLevel = stat.Level;
var expReq = 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 };
var expReqAtLevel = expReq[stat.Level - 1];
using (var w = File.AppendText(pokelistFile))
{
w.WriteLine("");
foreach (var pokemon in allPokemon)
{
var 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));
var isInGym = string.Empty;
//var isInGym = pokemon.DeployedFortId == 0 ? "Yes" : "No";
var isFavorite = pokemon.Favorite != 0 ? "Yes" : "No";
var settings = pokemonSettings.Single(x => x.PokemonId == pokemon.PokemonId);
var familiecandies = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId).Candy;
var perfection = PokemonInfo.CalculatePokemonPerfection(pokemon).ToString("0.00");
perfection = perfection.Replace(",", ls == "," ? "." : ",");
string contentPart1 = $"\"{(int)pokemon.PokemonId}\",\"{pokemon.PokemonId}\",\"{pokemon.Nickname}\",";
string contentPart2 = $",\"{pokemon.Cp} / {PokemonInfo.CalculateMaxCp(pokemon)}\",";
string contentPart3 = $",\"{pokemon.Move1}\",\"{pokemon.Move2}\",\"{pokemon.Stamina}\",\"{pokemon.IndividualAttack}\",\"{pokemon.IndividualDefense}\",\"{pokemon.IndividualStamina}\",\"{familiecandies}\",\"{isInGym}\",\"{isFavorite}\",http://poke.isitin.org/#{encoded}";
string content = $"{contentPart1.Replace(",", $"{ls}")}\"{PokemonInfo.GetLevel(pokemon)}\"{contentPart2.Replace(",", $"{ls}")}\"{perfection}\"{contentPart3.Replace(",", $"{ls}")}";
w.WriteLine($"{content}");
}
w.Close();
}
Logger.Write($"Export Player Infos and all Pokemon to \"\\Export\\Profile_{player.Username}_{filename}\"", LogLevel.Info);
}
catch
{
Logger.Write("Export Player Infos and all Pokemons to CSV not possible. File seems be in use!", LogLevel.Warning);
}
}
}
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);
}
else if (greatBallsCount > 0)
{
return(ItemId.ItemGreatBall);
}
else if (ultraBallsCount > 0)
{
return(ItemId.ItemUltraBall);
}
else
{
return(ItemId.ItemUnknown);
}
//return pokeBallsCount > 0 ? ItemId.ItemPokeBall : ItemId.ItemUnknown;
}
public List <PokemonData> GetPokemonToUpgrade()
{
var upgradePokemon = new List <PokemonData>();
if (!_logicSettings.AutomaticallyLevelUpPokemon)
{
return(upgradePokemon);
}
var myPokemon = GetPokemons().Where(p => CanUpgradePokemon(p));
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, ulong pokemonId, CancellationToken cancellationToken, bool toMax = false)
{
if (!await CheckBotStateTask.Execute(session, cancellationToken))
{
return;
}
var prevState = session.State;
session.State = BotState.LevelPoke;
var all = await session.Inventory.GetPokemons();
var pokemon = all.FirstOrDefault(p => p.Id == pokemonId);
if (pokemon == null)
{
return;
}
if (!string.IsNullOrEmpty(pokemon.DeployedFortId))
{
session.EventDispatcher.Send(new WarnEvent()
{
Message = $"Pokemon {(string.IsNullOrEmpty(pokemon.Nickname) ? pokemon.PokemonId.ToString() : pokemon.Nickname)} is signed to defend a GYM!"
});
return;
}
bool success;
UpgradePokemonResponse latestSuccessResponse = null;
do
{
success = false;
var upgradeResult = await session.Inventory.UpgradePokemon(pokemon.Id);
switch (upgradeResult.Result)
{
case UpgradePokemonResponse.Types.Result.Success:
success = true;
latestSuccessResponse = upgradeResult;
session.EventDispatcher.Send(new NoticeEvent()
{
Message =
session.Translation.GetTranslation(TranslationString.PokemonUpgradeSuccess,
session.Translation.GetPokemonName(upgradeResult.UpgradedPokemon.PokemonId),
upgradeResult.UpgradedPokemon.Cp)
});
break;
case UpgradePokemonResponse.Types.Result.ErrorInsufficientResources:
session.EventDispatcher.Send(new NoticeEvent()
{
Message = session.Translation.GetTranslation(TranslationString.PokemonUpgradeFailed)
});
break;
case UpgradePokemonResponse.Types.Result.ErrorUpgradeNotAvailable:
session.EventDispatcher.Send(new NoticeEvent()
{
Message =
session.Translation.GetTranslation(TranslationString.PokemonUpgradeUnavailable,
session.Translation.GetPokemonName(pokemon.PokemonId), pokemon.Cp,
PokemonInfo.CalculateMaxCp(pokemon))
});
break;
default:
session.EventDispatcher.Send(new NoticeEvent()
{
Message =
session.Translation.GetTranslation(TranslationString.PokemonUpgradeFailedError,
session.Translation.GetPokemonName(pokemon.PokemonId))
});
break;
}
await DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 2000);
} while (success && toMax);
if (latestSuccessResponse != null)
{
var pokemonFamilies = await session.Inventory.GetPokemonFamilies();
var pokemonSettings = (await session.Inventory.GetPokemonSettings()).ToList();
var setting = pokemonSettings.Single(q => q.PokemonId == pokemon.PokemonId);
var family = pokemonFamilies.First(q => q.FamilyId == setting.FamilyId);
session.EventDispatcher.Send(new PokemonStatsChangedEvent()
{
Name = !string.IsNullOrEmpty(pokemon.Nickname)
? pokemon.Nickname
: pokemon.PokemonId.ToString(),
Uid = pokemonId,
Id = pokemon.PokemonId,
Family = family.FamilyId,
Candy = family.Candy_,
Cp = latestSuccessResponse.UpgradedPokemon.Cp,
Iv = latestSuccessResponse.UpgradedPokemon.CalculatePokemonPerfection(),
Favourite = pokemon.Favorite == 1
});
}
session.State = prevState;
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
await session.Inventory.RefreshCachedInventory();
if (session.Inventory.GetStarDust() <= session.LogicSettings.GetMinStarDustForLevelUp)
{
return;
}
upgradablePokemon = await session.Inventory.GetPokemonToUpgrade();
if (session.LogicSettings.OnlyUpgradeFavorites)
{
var fave = upgradablePokemon.Where(i => i.Favorite == 1);
upgradablePokemon = fave;
}
if (upgradablePokemon.Count() == 0)
{
return;
}
var myPokemonSettings = await session.Inventory.GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await session.Inventory.GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
var upgradedNumber = 0;
var PokemonToLevel = session.LogicSettings.PokemonsToLevelUp;
foreach (var pokemon in upgradablePokemon)
{
if (session.LogicSettings.UseLevelUpList && PokemonToLevel != null)
{
for (int i = 0; i < PokemonToLevel.Count; i++)
{
if (PokemonToLevel.Contains(pokemon.PokemonId))
{
PlayerStats playerStats = await session.Inventory.GetPlayerStats();
if (PokemonInfo.GetLevel(pokemon) >= playerStats.Level + 1)
{
continue;
}
var settings = pokemonSettings.Single(x => x.PokemonId == pokemon.PokemonId);
var familyCandy = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId);
if (familyCandy.Candy_ <= 0)
{
continue;
}
var upgradeResult = await session.Inventory.UpgradePokemon(pokemon.Id);
if (upgradeResult.Result.ToString().ToLower().Contains("success"))
{
Logger.Write("Pokemon Upgraded:" +
session.Translation.GetPokemonTranslation(
upgradeResult.UpgradedPokemon.PokemonId) + ":" +
upgradeResult.UpgradedPokemon.Cp, LogLevel.LevelUp);
upgradedNumber++;
}
if (upgradedNumber >= session.LogicSettings.AmountOfTimesToUpgradeLoop)
{
break;
}
}
else
{
break;
}
}
}
else
{
PlayerStats playerStats = await session.Inventory.GetPlayerStats();
if (PokemonInfo.GetLevel(pokemon) >= playerStats.Level + 1)
{
continue;
}
var settings = pokemonSettings.Single(x => x.PokemonId == pokemon.PokemonId);
var familyCandy = pokemonFamilies.Single(x => settings.FamilyId == x.FamilyId);
if (familyCandy.Candy_ <= 0)
{
continue;
}
var upgradeResult = await session.Inventory.UpgradePokemon(pokemon.Id);
if (upgradeResult.Result.ToString().ToLower().Contains("success"))
{
Logger.Write("Pokemon Upgraded:" + session.Translation.GetPokemonTranslation(upgradeResult.UpgradedPokemon.PokemonId) + ":" +
upgradeResult.UpgradedPokemon.Cp, LogLevel.LevelUp);
upgradedNumber++;
}
if (upgradedNumber >= session.LogicSettings.AmountOfTimesToUpgradeLoop)
{
break;
}
}
}
}
public static async Task Execute(ISession session, ulong pokemonId, bool toMax = false)
{
var all = await session.Inventory.GetPokemons();
var pokemons = all.OrderByDescending(x => x.Cp).ThenBy(n => n.StaminaMax);
var pokemon = pokemons.FirstOrDefault(p => p.Id == pokemonId);
if (pokemon == null)
{
return;
}
bool success;
UpgradePokemonResponse latestSuccessResponse = null;
do
{
success = false;
var upgradeResult = await session.Inventory.UpgradePokemon(pokemon.Id);
switch (upgradeResult.Result)
{
case UpgradePokemonResponse.Types.Result.Success:
success = true;
latestSuccessResponse = upgradeResult;
session.EventDispatcher.Send(new NoticeEvent()
{
Message =
session.Translation.GetTranslation(TranslationString.PokemonUpgradeSuccess,
session.Translation.GetPokemonName(upgradeResult.UpgradedPokemon.PokemonId),
upgradeResult.UpgradedPokemon.Cp)
});
break;
case UpgradePokemonResponse.Types.Result.ErrorInsufficientResources:
session.EventDispatcher.Send(new NoticeEvent()
{
Message = session.Translation.GetTranslation(TranslationString.PokemonUpgradeFailed)
});
break;
case UpgradePokemonResponse.Types.Result.ErrorUpgradeNotAvailable:
session.EventDispatcher.Send(new NoticeEvent()
{
Message =
session.Translation.GetTranslation(TranslationString.PokemonUpgradeUnavailable,
session.Translation.GetPokemonName(pokemon.PokemonId), pokemon.Cp,
PokemonInfo.CalculateMaxCp(pokemon))
});
break;
default:
session.EventDispatcher.Send(new NoticeEvent()
{
Message =
session.Translation.GetTranslation(TranslationString.PokemonUpgradeFailedError,
session.Translation.GetPokemonName(pokemon.PokemonId))
});
break;
}
await DelayingUtils.Delay(session.LogicSettings.DelayBetweenPlayerActions, 2000);
} while (success && toMax);
if (latestSuccessResponse != null)
{
var pokemonFamilies = await session.Inventory.GetPokemonFamilies();
var pokemonSettings = (await session.Inventory.GetPokemonSettings()).ToList();
var setting = pokemonSettings.Single(q => q.PokemonId == pokemon.PokemonId);
var family = pokemonFamilies.First(q => q.FamilyId == setting.FamilyId);
session.EventDispatcher.Send(new PokemonStatsChangedEvent()
{
Uid = pokemonId,
Id = pokemon.PokemonId,
Family = family.FamilyId,
Candy = family.Candy_,
Cp = latestSuccessResponse.UpgradedPokemon.Cp,
Iv = latestSuccessResponse.UpgradedPokemon.CalculatePokemonPerfection()
});
}
}
public async Task <IEnumerable <PokemonData> > GetDuplicatePokemonToTransfer(
bool keepPokemonsThatCanEvolve = false, bool prioritizeIVoverCp = false,
IEnumerable <PokemonId> filter = null)
{
var myPokemon = await GetPokemons();
var pokemonFiltered = (_logicSettings.KeepMinOperator.ToLower().Equals("and")) ?
myPokemon.Where(
p => p.DeployedFortId == string.Empty &&
p.Favorite == 0 && (p.Cp < GetPokemonTransferFilter(p.PokemonId).KeepMinCp ||
PokemonInfo.CalculatePokemonPerfection(p) < GetPokemonTransferFilter(p.PokemonId).KeepMinIvPercentage)) :
myPokemon.Where(
p => p.DeployedFortId == string.Empty &&
p.Favorite == 0 && (p.Cp < GetPokemonTransferFilter(p.PokemonId).KeepMinCp&&
PokemonInfo.CalculatePokemonPerfection(p) < GetPokemonTransferFilter(p.PokemonId).KeepMinIvPercentage));
if (filter != null)
{
pokemonFiltered = pokemonFiltered.Where(p => !filter.Contains(p.PokemonId));
}
var pokemonList = pokemonFiltered.ToList();
var results = new List <PokemonData>();
var pokemonsThatCanBeTransfered = pokemonList.GroupBy(p => p.PokemonId).ToList();
var myPokemonSettings = await GetPokemonSettings();
var pokemonSettings = myPokemonSettings.ToList();
var myPokemonFamilies = await GetPokemonFamilies();
var pokemonFamilies = myPokemonFamilies.ToArray();
foreach (var pokemon in pokemonsThatCanBeTransfered)
{
var settings = pokemonSettings.Single(x => x.PokemonId == pokemon.Key);
var amountToSkip = GetPokemonTransferFilter(pokemon.Key).KeepMinDuplicatePokemon;
var transferrablePokemonTypeCount = pokemonFiltered.Where(p => p.PokemonId == pokemon.Key).Count();
var currentPokemonTypeCount = myPokemon.Where(p => p.PokemonId == pokemon.Key).Count();
var currentlyKeepingPokemonType = currentPokemonTypeCount - transferrablePokemonTypeCount;
if (currentlyKeepingPokemonType > GetPokemonTransferFilter(pokemon.Key).KeepMinDuplicatePokemon)
{
amountToSkip = 0;
}
else if (transferrablePokemonTypeCount > amountToSkip || currentlyKeepingPokemonType > 1)
{
amountToSkip = (amountToSkip - currentlyKeepingPokemonType + 1);
}
// Fail safe
if (amountToSkip < 0)
{
amountToSkip = 0;
}
// Don't get rid of it if we can evolve it
if (keepPokemonsThatCanEvolve && settings.EvolutionIds.Count != 0)
{
continue;
}
if (prioritizeIVoverCp)
{
results.AddRange(pokemonList.Where(x => x.PokemonId == pokemon.Key)
.OrderByDescending(PokemonInfo.CalculatePokemonPerfection)
.ThenByDescending(n => n.Cp)
.Skip(amountToSkip)
.ToList());
}
else
{
results.AddRange(pokemonList.Where(x => x.PokemonId == pokemon.Key)
.OrderByDescending(x => x.Cp)
.ThenByDescending(PokemonInfo.CalculatePokemonPerfection)
.Skip(amountToSkip)
.ToList());
}
}
return(results);
}
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);
}
/// <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)
{
// 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.MultipleBotConfig.SwitchOnCatchLimit)
{
throw new Exceptions.ActiveSwitchByRuleException()
{
MatchedRule = SwitchRules.CatchLimitReached, ReachedValue = session.LogicSettings.CatchPokemonLimit
};
}
return(false);
}
using (var block = new BlockableScope(session, Model.BotActions.Catch))
{
if (!await block.WaitToRun())
{
return(true);
}
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(true); // 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(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)}{encounterEV.PokemonId}{Math.Round(encounterEV.Longitude, 6)}";
session.Cache.Add(uniqueCacheKey, encounterEV, DateTime.Now.AddMinutes(15));
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.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(false);
}
// 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, 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, -1);
var evt = new PokemonCaptureEvent()
{
Status = caughtPokemonResponse.Status,
Latitude = latitude,
Longitude = longitude
};
lastThrow = caughtPokemonResponse.Status; // sets lastThrow status
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
var totalExp = 0;
if (encounteredPokemon != null)
{
encounteredPokemon.Id = caughtPokemonResponse.CapturedPokemonId;
await session.Inventory.AddPokemonToCache(encounteredPokemon);
}
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)
{
await session.Inventory.UpdateCandy(family, caughtPokemonResponse.CaptureAward.Candy.Sum());
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);
if (session.LogicSettings.AllowMultipleBot)
{
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchFlee)
{
CatchFleeContinuouslyCount++;
if (CatchFleeContinuouslyCount > session.LogicSettings.MultipleBotConfig.CatchFleeCount)
{
CatchFleeContinuouslyCount = 0;
throw new ActiveSwitchByRuleException()
{
MatchedRule = SwitchRules.CatchFlee,
ReachedValue = session.LogicSettings.MultipleBotConfig.CatchFleeCount
};
}
}
else
{
//reset if not catch flee.
CatchFleeContinuouslyCount = 0;
}
}
session.Actions.RemoveAll(x => x == Model.BotActions.Catch);
if (MultipleBotConfig.IsMultiBotActive(session.LogicSettings))
{
ExecuteSwitcher(session, encounterEV);
}
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 async void toolStripMenuItem1_Click(object sender, EventArgs e)
{
var pokemon = (PokemonData)PokemonListView.SelectedItems[0].Tag;
taskResponse resp = new taskResponse(false, string.Empty);
if (MessageBox.Show(this, pokemon.PokemonId + " with " + pokemon.Cp + " CP thats " + Math.Round(PokemonInfo.CalculatePokemonPerfection(pokemon)) + "% perfect", "Are you sure you want to transfer?", MessageBoxButtons.OKCancel) == DialogResult.OK)
{
resp = await transferPokemon(pokemon);
}
else
{
return;
}
if (resp.Status)
{
PokemonListView.Items.Remove(PokemonListView.SelectedItems[0]);
Text = "Pokemon List | User: "******" | Pokemons: " + PokemonListView.Items.Count + "/" + profile.PlayerData.MaxPokemonStorage;
}
else
{
MessageBox.Show(resp.Message + " transfer failed!", "Transfer Status", MessageBoxButtons.OK);
}
}
private async void powerUpToolStripMenuItem_Click(object sender, EventArgs e)
{
var pokemon = (PokemonData)PokemonListView.SelectedItems[0].Tag;
taskResponse resp = new taskResponse(false, string.Empty);
if (MessageBox.Show(this, pokemon.PokemonId + " with " + pokemon.Cp + " CP thats " + Math.Round(PokemonInfo.CalculatePokemonPerfection(pokemon)) + "% perfect", "Are you sure you want to power it up?", MessageBoxButtons.OKCancel) == DialogResult.OK)
{
resp = await PowerUp(pokemon);
}
else
{
return;
}
if (resp.Status)
{
PokemonListView.Clear();
Execute();
}
else
{
MessageBox.Show(resp.Message + " powering up failed!", "PowerUp Status", MessageBoxButtons.OK);
}
}
public static async Task Execute(ISession session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
TinyIoC.TinyIoCContainer.Current.Resolve <MultiAccountManager>().ThrowIfSwitchAccountRequested();
try
{
var playerStats = (await session.Inventory.GetPlayerStats().ConfigureAwait(false)).FirstOrDefault();
if (playerStats == null)
{
return;
}
var kmWalked = playerStats.KmWalked;
var incubators = (await session.Inventory.GetEggIncubators().ConfigureAwait(false))
.Where(x => x.UsesRemaining > 0 || x.ItemId == ItemId.ItemIncubatorBasicUnlimited)
.OrderByDescending(x => x.ItemId == ItemId.ItemIncubatorBasicUnlimited)
.ToList();
var unusedEggs = (await session.Inventory.GetEggs().ConfigureAwait(false))
.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().ConfigureAwait(false)).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;
}
//Still Needs some work - TheWizard1328
var stats = session.RuntimeStatistics; // Total Km walked
var KMs = playerStats.KmWalked - hatched.EggKmWalkedStart; // Total Km Walked(hatched.EggKmWalkedStart=0)
var stardust1 = session.Inventory.GetStarDust(); // Total trainer Stardust
var stardust2 = stats.TotalStardust; // Total trainer Stardust
var ExpAwarded1 = playerStats.Experience; // Total Player Exp - TheWizard1328
var ExpAwarded2 = stats.TotalExperience; // Session Exp - TheWizard1328
var TotCandy = session.Inventory.GetCandyCount(hatched.PokemonId);
//Temp logger line personal testing info - TheWizard1328
Logger.Write($"Rem.Incu: {rememberedIncubators.Capacity} | Hatch: PS-KmWalked: {playerStats.KmWalked:0.00}, H-EggKmWalkedStart: {hatched.EggKmWalkedStart:0.00}, | " +
$"KmToWalk: {KmToWalk:0.00}kmWalked: {kmWalked:0.00}, | " +
$"XP1: {ExpAwarded1} | XP2: {ExpAwarded2} | " +
$"SD1: {stardust1} | SD2: {stardust2}", LogLevel.Egg);
if (session.LogicSettings.NotificationConfig.EnablePushBulletNotification == true)
{
await PushNotificationClient.SendNotification(session, $"Egg has hatched.", $"Pokemon: {hatched.PokemonId}\n" +
$"Level: {PokemonInfo.GetLevel(hatched)}\n" +
$"CP: {hatched.Cp}\n" +
$"IV: {Math.Round(PokemonInfo.CalculatePokemonPerfection(hatched), 2)}\n", true).ConfigureAwait(false);
}
session.EventDispatcher.Send(new EggHatchedEvent
{
Dist = kmWalked - KmToWalk, //Still working on this - TheWizard1328
Id = hatched.Id,
PokemonId = hatched.PokemonId,
Level = PokemonInfo.GetLevel(hatched),
Cp = hatched.Cp,
MaxCp = PokemonInfo.CalculateMaxCp(hatched.PokemonId),
Perfection = Math.Round(PokemonInfo.CalculatePokemonPerfection(hatched), 2),
HXP = ExpAwarded1,
HSD = stardust2, // This still needs work too to display the total SD after hatching - TheWizard1328
HCandy = await TotCandy,
});
}
var newRememberedIncubators = new List <IncubatorUsage>();
foreach (var incubator in incubators)
{
cancellationToken.ThrowIfCancellationRequested();
TinyIoC.TinyIoCContainer.Current.Resolve <MultiAccountManager>().ThrowIfSwitchAccountRequested();
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).ConfigureAwait(false);
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);
}
}
catch (Exception)
{
}
}
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(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
var egg = incubator.ItemId == ItemId.ItemIncubatorBasicUnlimited
? unusedEggs.FirstOrDefault()
: unusedEggs.LastOrDefault();
if (egg == null)
{
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);
}
}
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);
}
}
private static async Task <ItemId> GetBestBall(ISession session, dynamic encounter, float probability)
{
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 (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);
}
