Пример #1
0
        private async Task CatchEncounter(EncounterResponse encounter, MapPokemon pokemon, Client client)
        {
            CatchPokemonResponse caughtPokemonResponse;

            do
            {
                if (encounter?.CaptureProbability.CaptureProbability_.First() < 0.40)
                {
                    _logger.Write("Using berry", LogLevel.INFO);
                    await _pokemonItems.UseBerry(pokemon.EncounterId, pokemon.SpawnPointId, client);
                }

                var pokeball = await _pokemonItems.GetBestBall(encounter?.WildPokemon, client.Inventory);

                await Task.Delay(1000);

                caughtPokemonResponse =
                    await client.Encounter.CatchPokemon(pokemon.EncounterId, pokemon.SpawnPointId, pokeball);

                await Task.Delay(500);
            } while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed ||
                     caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);

            if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
            {
                var wildPokemon = encounter?.WildPokemon.PokemonData;
                if (wildPokemon != null)
                {
                    OnCatch?.Invoke(wildPokemon);
                    OnExperienceAwarded?.Invoke(caughtPokemonResponse.CaptureAward.Xp.Sum(x => x));

                    var iv = wildPokemon.IndividualAttack + wildPokemon.IndividualDefense +
                             wildPokemon.IndividualStamina;

                    _logger.Write($"Gotcha! {pokemon.PokemonId} - CP: {wildPokemon.Cp}, " +
                                  $"IV {iv}", LogLevel.SUCC);

                    if (_settings.Settings.QuickTransfer)
                    {
                        if (_pokemonHelper.ShouldTranferPokemon(wildPokemon, _settings.Settings.IvPercentageDiscart,
                                                                _settings.Settings.KeepMinCp, _settings.Settings.IvOverCp))
                        {
                            await _transferPokemonHandler.TransferPokemon(client, wildPokemon, true);
                        }
                    }
                }
                else
                {
                    _logger.Write($"Caught status: {caughtPokemonResponse.Status}", LogLevel.WARN);
                }
            }
        }
Пример #2
0
        public async Task EvolveAllPokemonWithEnoughCandy(Client client)
        {
            var notEnoughCandyToEvolvePokemon = new Dictionary <PokemonId, bool>();

            var pokemonToEvolve = await GetPokemonToEvolve(client);

            foreach (var pokemon in pokemonToEvolve)
            {
                if (notEnoughCandyToEvolvePokemon.ContainsKey(pokemon.PokemonId))
                {
                    continue;
                }

                var evolvePokemonOutProto = await EvolvePokemon(client, pokemon);

                if (evolvePokemonOutProto.Result == EvolvePokemonResponse.Types.Result.Success)
                {
                    OnExperienceAwarded?.Invoke(evolvePokemonOutProto.ExperienceAwarded);

                    _logger.Write(
                        $"Evolved {pokemon.PokemonId} successfully for {evolvePokemonOutProto.ExperienceAwarded}xp",
                        LogLevel.INFO);

                    await Task.Delay(_settingsHandler.Settings.DelayBetweenActions);
                }
                else
                {
                    _logger.Write(
                        $"Failed to evolve {pokemon.PokemonId}. EvolvePokemonOutProto.Result was {evolvePokemonOutProto.Result}, stopping evolving {pokemon.PokemonId}",
                        LogLevel.INFO);

                    if (evolvePokemonOutProto.Result == EvolvePokemonResponse.Types.Result.FailedInsufficientResources)
                    {
                        notEnoughCandyToEvolvePokemon.Add(pokemon.PokemonId, false);
                    }
                }
            }
        }
Пример #3
0
        public async Task FarmPokestops(Client client)
        {
            var mapObjects = await client.Map.GetMapObjects();

            IEnumerable <FortData> pokeStops =
                mapObjects.Item1.MapCells.SelectMany(i => i.Forts)
                .Where(i =>
                       i.Type.Equals(FortType.Checkpoint) &&
                       i.CooldownCompleteTimestampMs < DateTime.UtcNow.ToUnixTime());

            _logger.Write("Sorting pokestops per distance", LogLevel.DEBUG);

            List <PokestopPoco> pokeStopsPoco = PokestopDistanceSorter.SortByDistance(pokeStops, client.CurrentLatitude,
                                                                                      client.CurrentLongitude, _settings.Settings.PlayerMaxTravelInMeters);

            var pokestopsCount = pokeStopsPoco.Count;

            OnPokestopFound?.Invoke(pokestopsCount);
            _logger.Write($"Found {pokestopsCount} pokestops nearby", LogLevel.INFO);

            foreach (var pokeStop in pokeStopsPoco)
            {
                if (_settings.Settings.UpdateLocation)
                {
                    _logger.Write($"Walking to location [LAT: {pokeStop.Latitude} | LON: {pokeStop.Longitude}]",
                                  LogLevel.INFO);

                    await _walkingHandler.Walking(client, pokeStop.Latitude, pokeStop.Longitude,
                                                  _settings.Settings.PlayerWalkingSpeed, () => _catchPokemonHandler.CatchAllNearbyPokemon(client));
                }

                var fortInfo = await client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);

                await Task.Delay(2000);

                _logger.Write($"Spinning pokestop: {fortInfo.Name}", LogLevel.INFO);
                var fortSearch = await client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude);

                if (fortSearch.Result == FortSearchResponse.Types.Result.Success)
                {
                    if (fortSearch.ExperienceAwarded == 0)
                    {
                        _logger.Write("[Softban] No exp on pokestop.", LogLevel.ERROR);
                    }
                    else
                    {
                        _logger.Write($"Reward: {fortSearch.ExperienceAwarded}xp", LogLevel.INFO);
                        OnExperienceAwarded?.Invoke(fortSearch.ExperienceAwarded);
                    }

                    foreach (var r in fortSearch.ItemsAwarded.GroupBy(x => x.ItemId))
                    {
                        _logger.Write($"Reward: {r.Count()}x {r.Key} ", LogLevel.INFO);
                    }
                }
                else if (fortSearch.Result == FortSearchResponse.Types.Result.InCooldownPeriod)
                {
                    _logger.Write($"Pokestop in cooldown: {fortSearch.CooldownCompleteTimestampMs}", LogLevel.WARN);
                }
                else if (fortSearch.Result == FortSearchResponse.Types.Result.InventoryFull)
                {
                    _logger.Write("Inventory full", LogLevel.WARN);
                }
                else if (fortSearch.Result == FortSearchResponse.Types.Result.OutOfRange)
                {
                    _logger.Write("Pokestop to far away", LogLevel.WARN);
                }

                OnPokestopVisited?.Invoke();

                await Task.Delay(1000);
            }
        }